756 lines
25 KiB
PHP
756 lines
25 KiB
PHP
<?
|
|
// TODO
|
|
// prendre en compte l'opacité grâce à imagecolorallocatealpha ?
|
|
// pour les rectangles avec point ou tiret http://fr.php.net/manual/fr/function.imagesetstyle.php
|
|
// ajout de title
|
|
// ajout de <text fill="#000000" x="541" y="258" transform="rotate(-0, 541, 258)" font-size="10" font-family="SansSerif" font-style="normal" font-weight="normal">0</text>
|
|
|
|
|
|
include 'log.php';
|
|
|
|
class SVGTOIMAGE{
|
|
|
|
protected $_svgXML;
|
|
protected $_image;
|
|
protected $_log;
|
|
protected $_x;
|
|
protected $_y;
|
|
protected $_width;
|
|
protected $_height;
|
|
protected $_showDesc = false;
|
|
protected $_desc;
|
|
private $transparentColor = array(0,0,255);
|
|
public $_debug = true; // change to false to stop debug mode
|
|
|
|
/* array of color names => hex color
|
|
because some svg creator uses them
|
|
*/
|
|
private $colors = array(
|
|
'black' => '#000000',
|
|
'red' => '#FF0000',
|
|
'white' => '#FFFFFF',
|
|
'turquoise' => '#00FFFF',
|
|
'grey' => '#CCCCCC',
|
|
'light grey' => '#C0C0C0',
|
|
'light blue' => '#0000FF',
|
|
'dark grey' => '#808080',
|
|
'dark blue' => '#0000A0',
|
|
'light purple' => '#FF0080',
|
|
'orange' => '#FF8040',
|
|
'dark purple' => '#800080',
|
|
'brown' => '#804000',
|
|
'yellow' => '#FFFF00',
|
|
'burgundy' => '#800000',
|
|
'pastel green' => '#00FF00',
|
|
'forest green' => '#808000',
|
|
'pink' => '#FF00FF',
|
|
'grass green' => '#408080',
|
|
);
|
|
|
|
/*
|
|
* constructor
|
|
* parse the svg with simplexml
|
|
*/
|
|
public function __construct($svg){
|
|
if($this->_debug) $this->_log = new Log('log.dat');
|
|
if($this->_debug) $this->_log->message('Ouverture du fichier contentant : '.$svg);
|
|
$this->_svgXML = simplexml_load_string($svg);
|
|
}
|
|
|
|
/*
|
|
* Construct with a file
|
|
* @param : string path to the file
|
|
* @return : instance of this class
|
|
*/
|
|
public static function load($file){
|
|
$svg = file_get_contents($file);
|
|
return new SVGTOIMAGE($svg);
|
|
}
|
|
|
|
/*
|
|
* Construct with a string
|
|
* @param : string <svg>...</svg>
|
|
* @return : instance of this class
|
|
*/
|
|
public static function parse($xml){
|
|
return new SVGTOIMAGE($xml);
|
|
}
|
|
|
|
/*
|
|
* Destroy the GD Image when finished
|
|
*/
|
|
public function __destruct(){
|
|
imagedestroy($this->_image);
|
|
}
|
|
|
|
/*
|
|
* setter - option : show the description from the svg into the image if present
|
|
* @param boolean
|
|
*/
|
|
public function setShowDesc($showDesc = true){
|
|
if(is_bool($showDesc)){
|
|
if($this->_debug) $this->_log->message('Passage de showDesc en '.$showDesc);
|
|
$this->_showDesc = $showDesc;
|
|
}else{
|
|
if($this->_debug) $this->_log->error('Erreur dans la fonction showDesc, doit recevoir booléen, a reçu : '.$showDesc);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* setter - option : origin of the final image from the svg (default : 0)
|
|
* @param int
|
|
*/
|
|
public function setX($x){
|
|
if(is_int($x)){
|
|
if($this->_debug) $this->_log->message('Passage de x en '.$x);
|
|
$this->_x = $x;
|
|
}else{
|
|
if($this->_debug) $this->_log->error('Erreur dans la fonction setX, doit recevoir int, a reçu : '.$x);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* setter - option : origin of the final image from the svg (default : 0)
|
|
* @param int
|
|
*/
|
|
public function setY($y){
|
|
if(is_int($y)){
|
|
if($this->_debug) $this->_log->message('Passage de y en '.$y);
|
|
$this->_y = $y;
|
|
}else{
|
|
if($this->_debug) $this->_log->error('Erreur dans la fonction setY, doit recevoir int, a reçu : '.$y);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* setter - option : width of the final image (default : svg width)
|
|
* @param int
|
|
*/
|
|
public function setWidth($width){
|
|
if(is_int($width)){
|
|
if($this->_debug) $this->_log->message('Passage de width en '.$width);
|
|
$this->_width = $width;
|
|
}else{
|
|
if($this->_debug) $this->_log->error('Erreur dans la fonction setWidth, doit recevoir int, a reçu : '.$width);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* setter - option : height of the final image (default : svg height)
|
|
* @param int
|
|
*/
|
|
public function setHeight($height){
|
|
if(is_int($height)){
|
|
if($this->_debug) $this->_log->message('Passage de height en '.$height);
|
|
$this->_height = $height;
|
|
}else{
|
|
if($this->_debug) $this->_log->error('Erreur dans la fonction setHeight, doit recevoir int, a reçu : '.$height);
|
|
}
|
|
}
|
|
|
|
/* return width and height from the SVG */
|
|
private function _getImageSize(){
|
|
$imageSize = array();
|
|
$imageSize['width'] = $this->_svgXML->attributes()->width;
|
|
$imageSize['height'] = $this->_svgXML->attributes()->height;
|
|
if($this->_debug) $this->_log->message('taille de l\'image : largeur : '.$imageSize['width'].' - longueur : '.$imageSize['height']);
|
|
return $imageSize;
|
|
}
|
|
|
|
/*
|
|
* @return int final image width
|
|
*/
|
|
private function _getImageWidth(){
|
|
return isset($this->_width) ? $this->_width : $this->_svgXML->attributes()->width;
|
|
}
|
|
|
|
/*
|
|
* @return int final image height
|
|
*/
|
|
private function _getImageHeight(){
|
|
return isset($this->_height) ? $this->_height : $this->_svgXML->attributes()->height;
|
|
}
|
|
|
|
/*
|
|
* @param string Color code (ie: #CCC , #FE4323, etc...)
|
|
* @return array with R | G | B
|
|
*/
|
|
private function _parseColor($colorCode){
|
|
if(strlen($colorCode) == 7){
|
|
if($this->_debug) $this->_log->message('Parse Color '.$colorCode);
|
|
return array(
|
|
base_convert(substr($colorCode, 1, 2), 16, 10),
|
|
base_convert(substr($colorCode, 3, 2), 16, 10),
|
|
base_convert(substr($colorCode, 5, 2), 16, 10),
|
|
);
|
|
}
|
|
if(strlen($colorCode) == 4){
|
|
if($this->_debug) $this->_log->message('Parse Color '.$colorCode);
|
|
return array(
|
|
base_convert(substr($colorCode, 1, 1).substr($colorCode, 1, 1), 16, 10),
|
|
base_convert(substr($colorCode, 2, 1).substr($colorCode, 2, 1), 16, 10),
|
|
base_convert(substr($colorCode, 3, 1).substr($colorCode, 3, 1), 16, 10),
|
|
);
|
|
}
|
|
if($this->_debug) $this->_log->error('Couleur mal indiquée '.$colorCode);
|
|
return array(0,0,0);
|
|
}
|
|
|
|
/*
|
|
* Allocate color to the final image thanks to _parseColor (check if the color isn't spelled directly 'black')
|
|
* @param string color code
|
|
* @return imageallocate on the image
|
|
*/
|
|
private function _allocateColor($color){
|
|
if($color != '' && array_key_exists(strtolower($color), $this->colors)){
|
|
$arrayColor = $this->_parseColor($this->colors[$color]);
|
|
}else{
|
|
$arrayColor = $this->_parseColor($color);
|
|
}
|
|
return imagecolorallocate( $this->_image, $arrayColor[0], $arrayColor[1], $arrayColor[2] );
|
|
}
|
|
|
|
/*
|
|
* return an array to use with imagesetstyle
|
|
* @param allocatecolorimage
|
|
* @return array
|
|
*/
|
|
private function _getDashedStroke($full, $empty, $color){
|
|
$tiret = array();
|
|
for($i=0;$i<$full;$i++){
|
|
$tiret[] = $color;
|
|
}
|
|
for($i=0;$i<$empty;$i++){
|
|
$tiret[] = IMG_COLOR_TRANSPARENT;
|
|
}
|
|
if($this->_debug) $this->_log->message('nouveaux tirets : '.implode('-', $tiret));
|
|
return $tiret;
|
|
}
|
|
|
|
/*
|
|
* add the given image from svg to the final image
|
|
* @param simpleXMLElement
|
|
* @return imagecopy
|
|
*/
|
|
private function _parseImage($imageNode){
|
|
$x = 0;
|
|
$y = 0;
|
|
$width = 0;
|
|
$height = 0;
|
|
$href = '';
|
|
$transform = '';
|
|
$r = 0;
|
|
foreach($imageNode->attributes() as $name => $value){
|
|
switch($name){
|
|
case 'x': $x = $value; break;
|
|
case 'y': $y = $value; break;
|
|
case 'width': $width = $value; break;
|
|
case 'height': $height = $value; break;
|
|
case 'href':
|
|
case 'xlink:href':$href = $value; break;
|
|
//case 'r' : $r = $value; break; // no, use transform instead !
|
|
case 'transform': $transform = $value;
|
|
case 'style' : if(strripos($value, 'display: none') || strripos($value, 'display:none')) return; break;
|
|
}
|
|
}
|
|
if($transform != ''){
|
|
$transforms = split('[()]', $transform);
|
|
$nb = count($transforms);
|
|
for($i = 0; $i < $nb; $i++){
|
|
// rotation
|
|
if($transforms[$i] == 'rotate'){
|
|
$rotinfo = $transforms[$i+1];
|
|
$rotinfo = explode(' ', $rotinfo);
|
|
$r = $rotinfo[0];
|
|
}
|
|
}
|
|
}
|
|
if($width == 0 || $height == 0 || $href == '')
|
|
return;
|
|
if($this->_debug) $this->_log->message('Image - x : '.$x.' - y : '.$y.' - largeur : '.$width.' - longueur : '.$height.' - url : '.$href.' - angle : '.$r);
|
|
$imageTypeArray = explode('.', $href);
|
|
$lastElementFromImageType = count($imageTypeArray);
|
|
$imageType = $imageTypeArray[$lastElementFromImageType-1];
|
|
if($imageType == 'jpg' || $imageType == 'jpeg')
|
|
$newImage = imagecreatefromjpeg($href);
|
|
else if($imageType == 'png')
|
|
$newImage = imagecreatefrompng($href);
|
|
else if($imageType == 'gif')
|
|
$newImage = imagecreatefromgif($href);
|
|
else return;
|
|
|
|
imagealphablending($newImage, true);
|
|
|
|
//rotating the image if needed
|
|
if($r != 0){
|
|
if($this->_debug){
|
|
if($newImage = imagerotate($newImage, - floatval($r), -1)){
|
|
$this->_log->message('Rotating image');
|
|
}else
|
|
$this->_log->error('Rotating image');
|
|
}else{
|
|
$newImage = imagerotate($newImage, - floatval($r), -1);
|
|
}
|
|
$blue = imagecolorallocate($newImage, $this->transparentColor[0], $this->transparentColor[1],$this->transparentColor[2]);
|
|
imagecolortransparent($newImage, $blue);
|
|
}
|
|
$newWidth = imagesx($newImage);
|
|
$newHeight = imagesy($newImage);
|
|
|
|
imagecopy($this->_image,$newImage,($newWidth == $width) ? $x : $x-($newWidth-$width)/2,($newHeight == $height) ? $y : $y-($newHeight-$height)/2,0,0,imagesx($newImage) , imagesy($newImage)); // Thanks Raphael & GD for saying things wrong.
|
|
}
|
|
|
|
/*
|
|
* Check if the given SVG xml is W3C valid
|
|
* DEPRECATED and unused anymore
|
|
* @param string <svg>...</svg>
|
|
* @return boolean
|
|
*/
|
|
private function _pathIsW3C($path){
|
|
if(strripos($path, ','))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
* small function to find int into a string - works like java parseint
|
|
* @param string containing numbers
|
|
* @return int
|
|
*/
|
|
private function _parseInt($string){
|
|
if(preg_match('/(\d+)/', $string, $array)) {
|
|
return $array[1];
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* add a line to the final image
|
|
* @param $x1, $y1, $x2, $y2 int position of segment
|
|
* @param imagecolorallocate color (via _allocatecolor !)
|
|
* @return imageline
|
|
*/
|
|
private function _drawLine($x1, $y1, $x2, $y2, $color){
|
|
if(!imageline( $this->_image , $x1, $y1, $x2, $y2, $color )){
|
|
if($this->_debug) $this->_log->error('Chemin erroné : '.$x1.' - '.$y1.' - '.$x2.' - '.$y2);
|
|
}else{
|
|
if($this->_debug) $this->_log->message('Chemin : '.$x1.' - '.$y1.' - '.$x2.' - '.$y2);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* add path/lineS/polyline whatever you name it.
|
|
* @param simpleXMLElement
|
|
* @return lines on the final image via _drawLine
|
|
*/
|
|
private function _parsePath($pathNode){
|
|
// imagesetbrush
|
|
// imagesetstyle (pour dotted, dashed etc)
|
|
$path = '';
|
|
$strokeWidth = 1;
|
|
$fill = '';
|
|
$stroke = '';
|
|
$strokeDasharray = '';
|
|
foreach($pathNode->attributes() as $name=>$value){
|
|
switch($name){
|
|
case 'd': case 'points': $path = $value; break;
|
|
case 'stroke': $stroke = $value; break;
|
|
case 'fill': $fill = ($value == 'none') ? '' : $value; break;
|
|
case 'stroke-width' : $strokeWidth = $value; break;
|
|
case 'stroke-dasharray' : $strokeDasharray = $value; break;
|
|
case 'style' : if(strripos($value, 'display: none') || strripos($value, 'display:none')) return; break;
|
|
}
|
|
}
|
|
if(substr($path, 0,1) != 'M' && !is_numeric(substr($path, 0,1))){
|
|
if($this->_debug) $this->_log->error('Mauvais path rencontré : '.$path);
|
|
return;
|
|
}
|
|
|
|
$thickness = imagesetthickness( $this->_image , $this->_parseInt($strokeWidth) );
|
|
if($this->_debug && !$thickness) $this->_log->error('Erreur dans la mise en place de l\'épaisseur du trait');
|
|
else $this->_log->message('épaisseur du trait à : '.$this->_parseInt($strokeWidth));
|
|
$colorStroke = $stroke != '' ? $this->_allocateColor((string)$stroke) : $this->_allocateColor('black');
|
|
$colorFill = $fill != '' ? $this->_allocateColor((string)$fill) : $this->_allocateColor('black');
|
|
if($strokeDasharray != ''){
|
|
$strokeDasharray = explode(',', $strokeDasharray);
|
|
imagesetstyle ( $this->_image , $this->_getDashedStroke($strokeDasharray[0], $strokeDasharray[1], $colorStroke ));
|
|
}else
|
|
imagesetstyle ( $this->_image , $this->_getDashedStroke(10, 0, $colorStroke ));
|
|
|
|
$lastOpe = '';
|
|
|
|
$pathArray = split('[ ,]', $path); //explode(' ', $path);
|
|
$nbArray = count($pathArray);
|
|
$nbLine = (($nbArray-1)/2)-1;
|
|
|
|
$i = 0;
|
|
$lastX = 0;
|
|
$lastY = 0;
|
|
while ($i < $nbArray) {
|
|
// Changement de départ
|
|
if(substr($pathArray[$i], 0, 1) == 'M'){
|
|
$lastX = $this->_parseInt($pathArray[$i]);
|
|
$lastY = $this->_parseInt($pathArray[$i+1]);
|
|
$lastOpe = 'M';
|
|
$i=$i+2;
|
|
|
|
}elseif(substr($pathArray[$i], 0, 1) == 'L'){
|
|
$newX = $this->_parseInt($pathArray[$i]);
|
|
$newY = $this->_parseInt($pathArray[$i+1]);
|
|
$this->_drawLine($lastX , $lastY , $newX , $newY , IMG_COLOR_STYLED);
|
|
$lastOpe = 'L';
|
|
$lastX = $newX;
|
|
$lastY = $newY;
|
|
$i=$i+2;
|
|
|
|
}elseif(substr($pathArray[$i], 0, 1) == 'H'){
|
|
$newX = $this->_parseInt($pathArray[$i]);
|
|
$this->_drawLine($lastX , $lastY , $newX , $lastY , IMG_COLOR_STYLED);
|
|
$lastOpe = 'H';
|
|
$lastX = $newX;
|
|
$i++;
|
|
|
|
}elseif(substr($pathArray[$i], 0, 1) == 'V'){
|
|
$newY = $this->_parseInt($pathArray[$i]);
|
|
$this->_drawLine($lastX , $lastY , $lastX , $newY , IMG_COLOR_STYLED);
|
|
$lastY = $newY;
|
|
$lastOpe = 'V';
|
|
$i++;
|
|
|
|
}elseif(substr($pathArray[$i], 0, 1) == 'C'){
|
|
|
|
$control1x = $this->_parseInt($pathArray[$i]);
|
|
$control1y = $this->_parseInt($pathArray[$i+1]);
|
|
$control2x = $this->_parseInt($pathArray[$i+2]);
|
|
$control2y = $this->_parseInt($pathArray[$i+3]);
|
|
$newX = $this->_parseInt($pathArray[$i+4]);
|
|
$newY = $this->_parseInt($pathArray[$i+5]);
|
|
|
|
// Algorithme de http://www.dreamstube.com/post/Bezier-Curves-In-PHP!.aspx ne fonctionne pas !
|
|
$cx=3*($control1x-$lastX);
|
|
$bx=3*($control2x-$control1x)-$cx;
|
|
$ax=$newX-$lastX-$cx-$bx;
|
|
|
|
$cy=3*($control1y-$lastY);
|
|
$by=3*($control2y-$control1y)-$cy;
|
|
$ay=$newY-$lastY-$cy-$by;
|
|
if($this->_debug) $this->_log->message('ax : '.$ax.', ay : '.$ay);
|
|
$function_x='('.$ax.')*$t*$t*$t+('.$bx.')*$t*$t+('.$cx.')*$t+'.$lastX;
|
|
$function_y='('.$ay.')*$t*$t*$t+('.$by.')*$t*$t+('.$cy.')*$t+'.$lastY;
|
|
$function_z=2;
|
|
$j=0;
|
|
for($t=0; $t<1; $t+=.01)
|
|
{
|
|
eval('$x_points[$j]=1*'.$function_x.';');
|
|
eval('$y_points[$j]=1*'.$function_y.';');
|
|
eval('$z_points[$j]=1*'.$function_z.';');
|
|
if($this->_debug) $this->_log->message('cx : '.$x_points[$j].', cy : '.$y_points[$j]*(-1).' d: '.$z_points[$j]);
|
|
imagearc($this->_image, $x_points[$j]+$this->_getImageWidth()/2, ($y_points[$j]*(-1))+$this->_getImageHeight()/2, $z_points[$j], $z_points[$j], 0, 360, $colorStroke);
|
|
$j++;
|
|
}
|
|
$lastX = $newX;
|
|
$lastY = $newY;
|
|
$i=$i+6;
|
|
}elseif(is_numeric(substr($pathArray[$i], 0, 1))){
|
|
switch($lastOpe){
|
|
case 'L':
|
|
$newX = $this->_parseInt($pathArray[$i]);
|
|
$newY = $this->_parseInt($pathArray[$i+1]);
|
|
$this->_drawLine($lastX , $lastY , $newX , $newY , IMG_COLOR_STYLED);
|
|
$lastX = $newX;
|
|
$lastY = $newY;
|
|
$i=$i+2;
|
|
break;
|
|
case 'H':
|
|
$newX = $this->_parseInt($pathArray[$i]);
|
|
$this->_drawLine($lastX , $lastY , $newX , $lastY , IMG_COLOR_STYLED);
|
|
$lastX = $newX;
|
|
$i++;
|
|
break;
|
|
case 'V':
|
|
$newY = $this->_parseInt($pathArray[$i]);
|
|
$this->_drawLine($lastX , $lastY , $lastX , $newY , IMG_COLOR_STYLED);
|
|
$lastY = $newY;
|
|
$i++;
|
|
break;
|
|
case 'Z':
|
|
if($this->_debug) $this->_log->error('2 bouclages dans une boucle');
|
|
$i++;
|
|
break;
|
|
default : //polyline
|
|
if($this->_debug) $this->_log->error('last opé inconnue '.$lastOpe);
|
|
$lastX = $this->_parseInt($pathArray[$i]);
|
|
$lastY = $this->_parseInt($pathArray[$i+1]);
|
|
$lastOpe = 'L';
|
|
$i=$i+2;
|
|
break;
|
|
}
|
|
|
|
}elseif(substr($pathArray[$i], 0, 1) == 'Z'){
|
|
$this->_drawLine($lastX , $lastY , $this->_parseInt($pathArray[0]) , $this->_parseInt($pathArray[1]) , IMG_COLOR_STYLED);
|
|
$lastOpe = 'Z'; //utile?
|
|
$i++;
|
|
}else
|
|
$i++; // au cas où pour éviter une boucle infinie.
|
|
if($this->_debug) $this->_log->message('counter :'.$i);
|
|
}
|
|
imagecolordeallocate( $this->_image, $colorStroke);
|
|
imagecolordeallocate( $this->_image, $colorFill);
|
|
imagesetthickness ( $this->_image , 1 );
|
|
imagesetstyle ( $this->_image , $this->_getDashedStroke(10, 0, $colorStroke ));
|
|
}
|
|
|
|
/*
|
|
* add a circle in the final image
|
|
* @param SimpleXMLElement
|
|
* @return
|
|
*/
|
|
private function _parseCircle($circleNode){
|
|
$x = 0;
|
|
$y = 0;
|
|
$r = 0;
|
|
$strokeWidth = 1;
|
|
$fill = '';
|
|
$stroke = '';
|
|
foreach($circleNode->attributes() as $name => $value){
|
|
switch($name){
|
|
case 'cx': $x = $value; break;
|
|
case 'cy': $y = $value; break;
|
|
case 'r': $r = $value; break;
|
|
case 'fill': $fill = ($value == 'none') ? '' : $value; break;
|
|
case 'stroke': $stroke = $value; break;
|
|
case 'style' : if(strripos($value, 'display: none') || strripos($value, 'display:none')) return; break;
|
|
case 'stroke-width' : $strokeWidth = $value; break;
|
|
}
|
|
}
|
|
if($r == 0)
|
|
return;
|
|
if($this->_debug) $this->_log->message('Cercle - x : '.$x.' - y : '.$y.' - rayon : '.$r.'-'.$colorStroke[2].' - épaisseur : '.$strokeWidth);
|
|
|
|
$thickness = imagesetthickness( $this->_image , (int)$strokeWidth );
|
|
if($this->_debug && !$thickness) $this->_log->error('Erreur dans la mise en place de l\'épaisseur du trait');
|
|
|
|
$colorStroke = $this->_allocateColor((string)$stroke);
|
|
$colorFill = $this->_allocateColor((string)$fill);
|
|
|
|
if($fill == ''){
|
|
imagearc($this->_image , $x , $y , $r*2 , $r*2,0,359.9, $colorStroke );
|
|
//imageellipse ($this->_image , $x , $y , $r*2 , $r*2, $colorStroke );
|
|
}else{
|
|
|
|
imagefilledarc($this->_image , $x , $y , $r*2 , $r*2 ,0,359.9, $colorFill, IMG_ARC_PIE );
|
|
}
|
|
imagecolordeallocate( $this->_image, $colorStroke);
|
|
imagecolordeallocate( $this->_image, $colorFill);
|
|
imagesetthickness ( $this->_image , 1 );
|
|
}
|
|
|
|
/*
|
|
* add text in the final image <text fill="#000000" x="541" y="258" transform="rotate(-0, 541, 258)" font-size="10" font-family="SansSerif" font-style="normal" font-weight="normal">0</text>
|
|
* @param SimpleXMLElement
|
|
* @return
|
|
*/
|
|
private function _parseText($textNode){
|
|
$x = 0;
|
|
$y = 0;
|
|
$r = 0;
|
|
$strokeWidth = 1;
|
|
$fill = '';
|
|
$fontSize = 10;
|
|
$fontFamily = 'SansSerif';
|
|
$fontStyle = 'normal';
|
|
$fontWeight = 'normal';
|
|
foreach($textNode->attributes() as $name => $value){
|
|
switch($name){
|
|
case 'x': $x = $value; break;
|
|
case 'y': $y = $value; break;
|
|
//case 'r': $r = $value; break; // todo
|
|
case 'fill': $fill = $value; break;
|
|
case 'font-size': $fontSize = $value; break;
|
|
case 'font-family': $fontFamily = $value; break;
|
|
case 'font-style': $fontStyle = $value; break;
|
|
case 'font-weight': $fontWeight = $value; break;
|
|
}
|
|
}
|
|
if($textNode == '')
|
|
return;
|
|
|
|
$colorStroke = $this->_allocateColor((string)$fill);
|
|
|
|
imagestring ( $this->_image , 2 , $x , $y , $textNode , $fill );
|
|
|
|
imagecolordeallocate( $this->_image, $colorStroke);
|
|
}
|
|
|
|
/*
|
|
* add a rectangle to the final image
|
|
* @param simpleXMLElement
|
|
* @return a nice rectangle !
|
|
*/
|
|
private function _parseRectangle($rectNode){
|
|
$x = 0;
|
|
$y = 0;
|
|
$width = 0;
|
|
$height = 0;
|
|
$r = 0;
|
|
$fill = '';
|
|
$stroke = '';
|
|
$strokeWidth = 1;
|
|
$strokeDasharray = '';
|
|
foreach($rectNode->attributes() as $name => $value){
|
|
switch($name){
|
|
// imagesetstyle (pour dotted, dashed etc)
|
|
case 'x': $x = $value; break;
|
|
case 'y': $y = $value; break;
|
|
case 'r': $r = $value; break;
|
|
case 'width': $width = $value; break;
|
|
case 'height': $height = $value; break;
|
|
case 'fill': $fill = ($value == 'none') ? '' : $value; break;
|
|
case 'stroke': $stroke = $value; break;
|
|
case 'stroke-width' : $strokeWidth = $value; break;
|
|
case 'stroke-dasharray' : $strokeDasharray = $value; break;
|
|
case 'style' : if(strripos($value, 'display: none') || strripos($value, 'display:none')) return; break;
|
|
}
|
|
}
|
|
if($width == 0 || $height == 0)
|
|
return;
|
|
$colorStroke = $this->_allocateColor((string)$stroke);
|
|
$colorFill = $this->_allocateColor((string)$fill);
|
|
$thickness = imagesetthickness( $this->_image , (int)$strokeWidth );
|
|
if($strokeDasharray != ''){
|
|
$strokeDasharray = explode(',', $strokeDasharray);
|
|
imagesetstyle ( $this->_image , $this->_getDashedStroke($strokeDasharray[0], $strokeDasharray[1], $colorStroke ));
|
|
}else
|
|
imagesetstyle ( $this->_image , $this->_getDashedStroke(10, 0, $colorStroke ));
|
|
|
|
if($this->_debug && !$thickness) $this->_log->error('Erreur dans la mise en place de l\'épaisseur du trait');
|
|
if($this->_debug) $this->_log->message('Rectangle - x : '.$x.' - y : '.$y.' - width : '.$width.' - height : '.$height.' - fill : '.$colorFill[0].'-'.$colorFill[1].'-'.$colorFill[2].' - stroke : '.$colorStroke[0].'-'.$colorStroke[1].'-'.$colorStroke[2]);
|
|
if($fill == ''){
|
|
imagerectangle($this->_image , $x , $y , $x+$width , $y+$height, IMG_COLOR_STYLED);
|
|
}else{
|
|
imagefilledrectangle ($this->_image , $x , $y , $x+$width , $y+$height, $colorFill );
|
|
}
|
|
imagecolordeallocate($this->_image,$colorStroke);
|
|
imagecolordeallocate($this->_image,$colorFill);
|
|
imagesetthickness ( $this->_image , 1 );
|
|
imagesetstyle ( $this->_image , $this->_getDashedStroke(10, 0, $colorStroke ));
|
|
}
|
|
|
|
/*
|
|
* add a polygon in the final image
|
|
* @param simpleXMLElement
|
|
* @return po-po-po-polygon !
|
|
*/
|
|
private function _parsePolygon($polyNode){
|
|
$points = '';
|
|
$fill = '';
|
|
$stroke = '';
|
|
$strokeWidth = 1;
|
|
foreach($polyNode->attributes() as $name => $value){
|
|
switch($name){
|
|
// imagesetstyle (pour dotted, dashed etc)
|
|
case 'points' : $points = $value; break;
|
|
case 'fill': $fill = ($value == 'none') ? '' : $value; break;
|
|
case 'stroke': $stroke = $value; break;
|
|
case 'stroke-width' : $strokeWidth = $value; break;
|
|
case 'style' : if(strripos($value, 'display: none') || strripos($value, 'display:none')) return; break;
|
|
}
|
|
}
|
|
if($points == '')
|
|
return;
|
|
$pointArray = split('[ ,]', $points);
|
|
$colorStroke = $this->_allocateColor((string)$stroke);
|
|
$colorFill = $this->_allocateColor((string)$fill);
|
|
$thickness = imagesetthickness( $this->_image , (int)$strokeWidth );
|
|
if($this->_debug && !$thickness) $this->_log->error('Erreur dans la mise en place de l\'épaisseur du trait');
|
|
|
|
if($fill == ''){
|
|
imagepolygon ( $this->_image , $pointArray , count($pointArray)/2 , $colorStroke );
|
|
}else{
|
|
imagefilledpolygon ($this->_image , $pointArray , count($pointArray)/2 , $colorFill );
|
|
}
|
|
imagecolordeallocate($this->_image,$colorStroke);
|
|
imagecolordeallocate($this->_image,$colorFill);
|
|
imagesetthickness ( $this->_image , 1 );
|
|
}
|
|
|
|
/*
|
|
* add the description text in the final image
|
|
* @param string the description
|
|
* @return boolean
|
|
*/
|
|
private function _parseDescription($desc){
|
|
if($this->_debug) $this->_log->message('Ajout de la description : '.$desc);
|
|
return imagestring ( $this->_image , 2, 10, $this->_getImageHeight()-20, $desc , imagecolorallocate($this->_image, 255, 255, 255));
|
|
}
|
|
|
|
/*
|
|
* ignore group for the moment
|
|
* acts like ungrouped
|
|
*/
|
|
private function _parseGroup($groupNode){
|
|
foreach($groupNode->children() as $element){
|
|
$this->_chooseParse($element);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* select what to parse
|
|
* @param simpleXMLElement
|
|
* @return the selected function
|
|
*/
|
|
private function _chooseParse($element){
|
|
if($element->getName() == 'image')
|
|
$this->_parseImage($element);
|
|
if($element->getName() == 'circle')
|
|
$this->_parseCircle($element);
|
|
if($element->getName() == 'rect')
|
|
$this->_parseRectangle($element);
|
|
if($element->getName() == 'path')
|
|
$this->_parsePath($element);
|
|
if($element->getName() == 'polygon')
|
|
$this->_parsePolygon($element);
|
|
if($element->getName() == 'polyline')
|
|
$this->_parsePath($element);
|
|
if($element->getName() == 'g')
|
|
$this->_parseGroup($element);
|
|
if($element->getName() == 'text')
|
|
$this->_parseText($element);
|
|
//if($element->getName() == 'title')
|
|
// $this->_parseTitle($element);
|
|
if($element->getName() == 'desc' && $this->_showDesc)
|
|
$this->_desc = $element;
|
|
}
|
|
|
|
/*
|
|
* parse everything, main function
|
|
* @param string format of the ouput 'png' 'gif' jpg'
|
|
* @param string path where you want to save the file (with the final name), null will just show the image but not saved on server
|
|
* @return the image
|
|
*/
|
|
public function toImage($format = 'png', $path = null){
|
|
$writeDesc = null;
|
|
$this->_image = imagecreatetruecolor($this->_getImageWidth(), $this->_getImageHeight());
|
|
imagealphablending($this->_image, true);
|
|
//imageantialias($this->_image, true); // On ne peut pas gérer l'épaisseur des traits si l'antialiasing est activé... lol ?
|
|
foreach($this->_svgXML->children() as $element){
|
|
$this->_chooseParse($element);
|
|
}
|
|
if($this->_showDesc && $this->_desc != null) $this->_parseDescription($this->_desc);
|
|
//imagefilter ( $this->_image , IMG_FILTER_SMOOTH, 6);
|
|
switch($format){
|
|
case 'gif' :
|
|
header("Content-type: " . image_type_to_mime_type(IMAGETYPE_GIF));
|
|
return imagegif($this->_image, $path);
|
|
case 'jpg':
|
|
header("Content-type: " . image_type_to_mime_type(IMAGETYPE_JPEG));
|
|
return imagejpeg($this->_image, $path);
|
|
case 'png' :
|
|
default :
|
|
header("Content-type: " . image_type_to_mime_type(IMAGETYPE_PNG));
|
|
return imagepng($this->_image, $path);
|
|
}
|
|
}
|
|
|
|
} |