PageRenderTime 70ms CodeModel.GetById 29ms RepoModel.GetById 0ms app.codeStats 2ms

/TEMPLATE/Reports/class/pchart2/class/pDraw.class.php

https://bitbucket.org/Lahiru_LCB/sep_wd_07
PHP | 5363 lines | 4329 code | 922 blank | 112 comment | 2009 complexity | 13ffc408e253cc133be311d5c20035d7 MD5 | raw file
Possible License(s): LGPL-3.0, GPL-3.0, LGPL-2.1

Large files files are truncated, but you can click here to view the full file

    

  1. <?php
    2. 

  2.  /*
    3. 

  3.      pDraw - class extension with drawing methods
    4. 

    5. 

  5.      Version     : 2.1.1
    6. 

  6.      Made by     : Jean-Damien POGOLOTTI
    7. 

  7.      Last Update : 28/03/11
    8. 

    9. 

  9.      This file can be distributed under the license you can find at :
    10. 

    11. 

  11.                        http://www.pchart.net/license
    12. 

    13. 

  13.      You can find the whole class documentation on the pChart web site.
    14. 

  14.  */
    15. 

  15. 

  16.  define("DIRECTION_VERTICAL"		, 690001);
    17. 

  17.  define("DIRECTION_HORIZONTAL"		, 690002);
    18. 

  18. 

  19.  define("SCALE_POS_LEFTRIGHT"		, 690101);
    20. 

  20.  define("SCALE_POS_TOPBOTTOM"		, 690102);
    21. 

  21. 

  22.  define("SCALE_MODE_FLOATING"		, 690201);
    23. 

  23.  define("SCALE_MODE_START0"		, 690202);
    24. 

  24.  define("SCALE_MODE_ADDALL"		, 690203);
    25. 

  25.  define("SCALE_MODE_ADDALL_START0"	, 690204);
    26. 

  26.  define("SCALE_MODE_MANUAL"		, 690205);
    27. 

  27. 

  28.  define("SCALE_SKIP_NONE"		, 690301);
    29. 

  29.  define("SCALE_SKIP_SAME"		, 690302);
    30. 

  30.  define("SCALE_SKIP_NUMBERS"		, 690303);
    31. 

  31. 

  32.  define("TEXT_ALIGN_TOPLEFT"		, 690401);
    33. 

  33.  define("TEXT_ALIGN_TOPMIDDLE"		, 690402);
    34. 

  34.  define("TEXT_ALIGN_TOPRIGHT"		, 690403);
    35. 

  35.  define("TEXT_ALIGN_MIDDLELEFT"		, 690404);
    36. 

  36.  define("TEXT_ALIGN_MIDDLEMIDDLE"	, 690405);
    37. 

  37.  define("TEXT_ALIGN_MIDDLERIGHT"	, 690406);
    38. 

  38.  define("TEXT_ALIGN_BOTTOMLEFT"		, 690407);
    39. 

  39.  define("TEXT_ALIGN_BOTTOMMIDDLE"	, 690408);
    40. 

  40.  define("TEXT_ALIGN_BOTTOMRIGHT"	, 690409);
    41. 

  41. 

  42.  define("POSITION_TOP"                  , 690501);
    43. 

  43.  define("POSITION_BOTTOM"               , 690502);
    44. 

  44. 

  45.  define("LABEL_POS_LEFT"		, 690601);
    46. 

  46.  define("LABEL_POS_CENTER"		, 690602);
    47. 

  47.  define("LABEL_POS_RIGHT"		, 690603);
    48. 

  48.  define("LABEL_POS_TOP"			, 690604);
    49. 

  49.  define("LABEL_POS_BOTTOM"		, 690605);
    50. 

  50.  define("LABEL_POS_INSIDE"		, 690606);
    51. 

  51.  define("LABEL_POS_OUTSIDE"		, 690607);
    52. 

  52. 

  53.  define("ORIENTATION_HORIZONTAL"	, 690701);
    54. 

  54.  define("ORIENTATION_VERTICAL"		, 690702);
    55. 

  55. 

  56.  define("LEGEND_NOBORDER"		, 690800);
    57. 

  57.  define("LEGEND_BOX"			, 690801);
    58. 

  58.  define("LEGEND_ROUND"			, 690802);
    59. 

  59. 

  60.  define("LEGEND_VERTICAL"		, 690901);
    61. 

  61.  define("LEGEND_HORIZONTAL"		, 690902);
    62. 

  62. 

  63.  define("LEGEND_FAMILY_BOX"		, 691051);
    64. 

  64.  define("LEGEND_FAMILY_CIRCLE"		, 691052);
    65. 

  65.  define("LEGEND_FAMILY_LINE"		, 691053);
    66. 

  66. 

  67.  define("DISPLAY_AUTO"			, 691001);
    68. 

  68.  define("DISPLAY_MANUAL"		, 691002);
    69. 

  69. 

  70.  define("LABELING_ALL"			, 691011);
    71. 

  71.  define("LABELING_DIFFERENT"		, 691012);
    72. 

  72. 

  73.  define("BOUND_MIN"			, 691021);
    74. 

  74.  define("BOUND_MAX"			, 691022);
    75. 

  75.  define("BOUND_BOTH"			, 691023);
    76. 

  76. 

  77.  define("BOUND_LABEL_POS_TOP"		, 691031);
    78. 

  78.  define("BOUND_LABEL_POS_BOTTOM"	, 691032);
    79. 

  79.  define("BOUND_LABEL_POS_AUTO"		, 691033);
    80. 

  80. 

  81.  define("CAPTION_LEFT_TOP"		, 691041);
    82. 

  82.  define("CAPTION_RIGHT_BOTTOM"		, 691042);
    83. 

  83. 

  84.  define("GRADIENT_SIMPLE"		, 691051);
    85. 

  85.  define("GRADIENT_EFFECT_CAN"		, 691052);
    86. 

  86. 

  87.  define("LABEL_TITLE_NOBACKGROUND"	, 691061);
    88. 

  88.  define("LABEL_TITLE_BACKGROUND"	, 691062);
    89. 

  89. 

  90.  define("LABEL_POINT_NONE"		, 691071);
    91. 

  91.  define("LABEL_POINT_CIRCLE"		, 691072);
    92. 

  92.  define("LABEL_POINT_BOX"		, 691073);
    93. 

  93. 

  94.  define("PI"		, 3.14159265);
    95. 

  95.  define("ALL"		, 69);
    96. 

  96.  define("NONE"		, 31);
    97. 

  97.  define("AUTO"		, 690000);
    98. 

  98.  define("OUT_OF_SIGHT"	, -10000000000000);
    99. 

  99. 

  100.  class pDraw
    101. 

  101.   {
    102. 

  102.    /* Returns the number of drawable series */
    103. 

  103.    function countDrawableSeries()
    104. 

  104.     {
    105. 

  105.      $Results = 0;
    106. 

  106.      $Data = $this->DataSet->getData();
    107. 

  107. 

  108.      foreach($Data["Series"] as $SerieName => $Serie)
    109. 

  109.       { if ( $Serie["isDrawable"] == TRUE && $SerieName != $Data["Abscissa"] ) { $Results++; } }
    110. 

  110. 

  111.      return($Results);
    112. 

  112.     }
    113. 

  113. 

  114.    /* Fix box coordinates */
    115. 

  115.    function fixBoxCoordinates($Xa,$Ya,$Xb,$Yb)
    116. 

  116.     {
    117. 

  117.      $X1 = min($Xa,$Xb); $Y1 = min($Ya,$Yb);
    118. 

  118.      $X2 = max($Xa,$Xb); $Y2 = max($Ya,$Yb);
    119. 

  119. 

  120.      return(array($X1,$Y1,$X2,$Y2));
    121. 

  121.     }
    122. 

  122. 

  123.    /* Draw a polygon */
    124. 

  124.    function drawPolygon($Points,$Format="")
    125. 

  125.     {
    126. 

  126.      $R			= isset($Format["R"]) ? $Format["R"] : 0;
    127. 

  127.      $G			= isset($Format["G"]) ? $Format["G"] : 0;
    128. 

  128.      $B			= isset($Format["B"]) ? $Format["B"] : 0;
    129. 

  129.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    130. 

  130.      $NoBorder		= isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;
    131. 

  131.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : $R;
    132. 

  132.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : $G;
    133. 

  133.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : $B;
    134. 

  134.      $BorderAlpha 	= isset($Format["Alpha"]) ? $Format["Alpha"] : $Alpha / 2;
    135. 

  135.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    136. 

  136.      $SkipX		= isset($Format["SkipX"]) ? $Format["SkipX"] : OUT_OF_SIGHT;
    137. 

  137.      $SkipY		= isset($Format["SkipY"]) ? $Format["SkipY"] : OUT_OF_SIGHT;
    138. 

  138. 

  139.      /* Calling the ImageFilledPolygon() function over the $Points array will round it */ 	
    140. 

  140.      $Backup = $Points;
    141. 

  141. 

  142.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }
    143. 

  143. 

  144.      if ( $SkipX != OUT_OF_SIGHT ) { $SkipX = floor($SkipX); }
    145. 

  145.      if ( $SkipY != OUT_OF_SIGHT ) { $SkipY = floor($SkipY); }
    146. 

  146. 

  147.      $RestoreShadow = $this->Shadow;
    148. 

  148.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    149. 

  149.       {
    150. 

  150.        $this->Shadow = FALSE;
    151. 

  151.        for($i=0;$i<=count($Points)-1;$i=$i+2)
    152. 

  152.         { $Shadow[] = $Points[$i] + $this->ShadowX; $Shadow[] = $Points[$i+1] + $this->ShadowY; }
    153. 

  153.        $this->drawPolygon($Shadow,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"NoBorder"=>TRUE));
    154. 

  154.       }
    155. 

  155. 

  156.      $FillColor = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    157. 

  157. 

  158.      if ( count($Points) >= 6 )
    159. 

  159.       { ImageFilledPolygon($this->Picture,$Points,count($Points)/2,$FillColor); }
    160. 

  160. 

  161.      if ( !$NoBorder )
    162. 

  162.       {
    163. 

  163.        $Points = $Backup;
    164. 

  164. 

  165.        $BorderSettings = array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha);
    166. 

  166.        for($i=0;$i<=count($Points)-1;$i=$i+2)
    167. 

  167.         {
    168. 

  168.          if ( isset($Points[$i+2]) )
    169. 

  169.           {
    170. 

  170.            if ( !($Points[$i] == $Points[$i+2] && $Points[$i] == $SkipX ) && !($Points[$i+1] == $Points[$i+3] && $Points[$i+1] == $SkipY ) )
    171. 

  171.             $this->drawLine($Points[$i],$Points[$i+1],$Points[$i+2],$Points[$i+3],$BorderSettings);
    172. 

  172.           }
    173. 

  173.          else
    174. 

  174.           {
    175. 

  175.            if ( !($Points[$i] == $Points[0] && $Points[$i] == $SkipX ) && !($Points[$i+1] == $Points[1] && $Points[$i+1] == $SkipY ) )
    176. 

  176.             $this->drawLine($Points[$i],$Points[$i+1],$Points[0],$Points[1],$BorderSettings);
    177. 

  177.           }
    178. 

  178.         }
    179. 

  179.       }
    180. 

  180. 

  181.      $this->Shadow = $RestoreShadow;
    182. 

  182.     }
    183. 

  183. 

  184.    /* Apply AALias correction to the rounded box boundaries */
    185. 

  185.    function offsetCorrection($Value,$Mode)
    186. 

  186.     {
    187. 

  187.      $Value = round($Value,1);
    188. 

  188. 

  189.      if ( $Value == 0 && $Mode == 1 ) { return(.9); }
    190. 

  190.      if ( $Value == 0 ) { return(0); }
    191. 

  191. 

  192.      if ( $Mode == 1) 
    193. 

  193.       { if ( $Value == 1 ) { return(.9); }; if ( $Value == .1 ) { return(.9); }; if ( $Value == .2 ) { return(.8); }; if ( $Value == .3 ) { return(.8); }; if ( $Value == .4 ) { return(.7); }; if ( $Value == .5 ) { return(.5); }; if ( $Value == .6 ) { return(.8); }; if ( $Value == .7 ) { return(.7); }; if ( $Value == .8 ) { return(.6); }; if ( $Value == .9 ) { return(.9); }; }
    194. 

  194. 

  195.      if ( $Mode == 2) 
    196. 

  196.       { if ( $Value == 1 ) { return(.9); }; if ( $Value == .1 ) { return(.1); }; if ( $Value == .2 ) { return(.2); }; if ( $Value == .3 ) { return(.3); }; if ( $Value == .4 ) { return(.4); }; if ( $Value == .5 ) { return(.5); }; if ( $Value == .6 ) { return(.8); }; if ( $Value == .7 ) { return(.7); }; if ( $Value == .8 ) { return(.8); }; if ( $Value == .9 ) { return(.9); }; }
    197. 

  197. 

  198.      if ( $Mode == 3) 
    199. 

  199.       { if ( $Value == 1 ) { return(.1); }; if ( $Value == .1 ) { return(.1); }; if ( $Value == .2 ) { return(.2); }; if ( $Value == .3 ) { return(.3); }; if ( $Value == .4 ) { return(.4); }; if ( $Value == .5 ) { return(.9); }; if ( $Value == .6 ) { return(.6); }; if ( $Value == .7 ) { return(.7); }; if ( $Value == .8 ) { return(.4); }; if ( $Value == .9 ) { return(.5); }; }
    200. 

  200. 

  201.      if ( $Mode == 4) 
    202. 

  202.       { if ( $Value == 1 ) { return(-1); }; if ( $Value == .1 ) { return(.1); }; if ( $Value == .2 ) { return(.2); }; if ( $Value == .3 ) { return(.3); }; if ( $Value == .4 ) { return(.1); }; if ( $Value == .5 ) { return(-.1); }; if ( $Value == .6 ) { return(.8); }; if ( $Value == .7 ) { return(.1); }; if ( $Value == .8 ) { return(.1); }; if ( $Value == .9 ) { return(.1); }; }
    203. 

  203.     }
    204. 

  204. 

  205.    /* Draw a rectangle with rounded corners */
    206. 

  206.    function drawRoundedRectangle($X1,$Y1,$X2,$Y2,$Radius,$Format="")
    207. 

  207.     {
    208. 

  208.      $R	    = isset($Format["R"]) ? $Format["R"] : 0;
    209. 

  209.      $G	    = isset($Format["G"]) ? $Format["G"] : 0;
    210. 

  210.      $B	    = isset($Format["B"]) ? $Format["B"] : 0;
    211. 

  211.      $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    212. 

  212. 

  213.      list($X1,$Y1,$X2,$Y2) = $this->fixBoxCoordinates($X1,$Y1,$X2,$Y2);
    214. 

  214. 

  215.      if ( $X2 - $X1 < $Radius ) { $Radius = floor((($X2-$X1))/2); }
    216. 

  216.      if ( $Y2 - $Y1 < $Radius ) { $Radius = floor((($Y2-$Y1))/2); }
    217. 

  217. 

  218.      $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"NoBorder"=>TRUE);
    219. 

  219. 

  220.      if ( $Radius <= 0 ) { $this->drawRectangle($X1,$Y1,$X2,$Y2,$Color); return(0); }
    221. 

  221. 

  222.      if ( $this->Antialias )
    223. 

  223.       {
    224. 

  224.        $this->drawLine($X1+$Radius,$Y1,$X2-$Radius,$Y1,$Color);
    225. 

  225.        $this->drawLine($X2,$Y1+$Radius,$X2,$Y2-$Radius,$Color);
    226. 

  226.        $this->drawLine($X2-$Radius,$Y2,$X1+$Radius,$Y2,$Color);
    227. 

  227.        $this->drawLine($X1,$Y1+$Radius,$X1,$Y2-$Radius,$Color);
    228. 

  228.       }
    229. 

  229.      else
    230. 

  230.       {
    231. 

  231.        $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    232. 

  232.        imageline($this->Picture,$X1+$Radius,$Y1,$X2-$Radius,$Y1,$Color);
    233. 

  233.        imageline($this->Picture,$X2,$Y1+$Radius,$X2,$Y2-$Radius,$Color);
    234. 

  234.        imageline($this->Picture,$X2-$Radius,$Y2,$X1+$Radius,$Y2,$Color);
    235. 

  235.        imageline($this->Picture,$X1,$Y1+$Radius,$X1,$Y2-$Radius,$Color);
    236. 

  236.       }
    237. 

  237. 

  238.      $Step = 360 / (2 * PI * $Radius);
    239. 

  239.      for($i=0;$i<=90;$i=$i+$Step)
    240. 

  240.       {
    241. 

  241.        $X = cos(($i+180)*PI/180) * $Radius + $X1 + $Radius;
    242. 

  242.        $Y = sin(($i+180)*PI/180) * $Radius + $Y1 + $Radius;
    243. 

  243.        $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    244. 

  244. 

  245.        $X = cos(($i+90)*PI/180) * $Radius + $X1 + $Radius;
    246. 

  246.        $Y = sin(($i+90)*PI/180) * $Radius + $Y2 - $Radius;
    247. 

  247.        $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    248. 

  248. 

  249.        $X = cos($i*PI/180) * $Radius + $X2 - $Radius;
    250. 

  250.        $Y = sin($i*PI/180) * $Radius + $Y2 - $Radius;
    251. 

  251.        $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    252. 

  252. 

  253.        $X = cos(($i+270)*PI/180) * $Radius + $X2 - $Radius;
    254. 

  254.        $Y = sin(($i+270)*PI/180) * $Radius + $Y1 + $Radius;
    255. 

  255.        $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    256. 

  256.       }
    257. 

  257.     }
    258. 

  258. 

  259.    /* Draw a rectangle with rounded corners */
    260. 

  260.    function drawRoundedFilledRectangle($X1,$Y1,$X2,$Y2,$Radius,$Format="")
    261. 

  261.     {
    262. 

  262.      $R			= isset($Format["R"]) ? $Format["R"] : 0;
    263. 

  263.      $G			= isset($Format["G"]) ? $Format["G"] : 0;
    264. 

  264.      $B			= isset($Format["B"]) ? $Format["B"] : 0;
    265. 

  265.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    266. 

  266.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    267. 

  267.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    268. 

  268.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    269. 

  269.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    270. 

  270. 

  271.      /* Temporary fix for AA issue */
    272. 

  272.      $Y1 = floor($Y1); $Y2 = floor($Y2); $X1 = floor($X1); $X2 = floor($X2);
    273. 

  273. 

  274.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }
    275. 

  275.      if ( $BorderR == -1 ) { $BorderR = $R; $BorderG = $G; $BorderB = $B; }
    276. 

  276. 

  277.      list($X1,$Y1,$X2,$Y2) = $this->fixBoxCoordinates($X1,$Y1,$X2,$Y2);
    278. 

  278. 

  279.      if ( $X2 - $X1 < $Radius*2 ) { $Radius = floor((($X2-$X1))/4); }
    280. 

  280.      if ( $Y2 - $Y1 < $Radius*2 ) { $Radius = floor((($Y2-$Y1))/4); }
    281. 

  281. 

  282.      $RestoreShadow = $this->Shadow;
    283. 

  283.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    284. 

  284.       {
    285. 

  285.        $this->Shadow = FALSE;
    286. 

  286.        $this->drawRoundedFilledRectangle($X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,$Radius,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));
    287. 

  287.       }
    288. 

  288. 

  289.      $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"NoBorder"=>TRUE);
    290. 

  290. 

  291.      if ( $Radius <= 0 ) { $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,$Color); return(0); }
    292. 

  292. 

  293.      $YTop    = $Y1+$Radius;
    294. 

  294.      $YBottom = $Y2-$Radius;
    295. 

  295. 

  296.      $Step = 360 / (2 * PI * $Radius);
    297. 

  297.      $Positions = ""; $Radius--; $MinY = ""; $MaxY = "";
    298. 

  298.      for($i=0;$i<=90;$i=$i+$Step)
    299. 

  299.       {
    300. 

  300.        $Xp1 = cos(($i+180)*PI/180) * $Radius + $X1 + $Radius;
    301. 

  301.        $Xp2 = cos(((90-$i)+270)*PI/180) * $Radius + $X2 - $Radius;
    302. 

  302.        $Yp  = floor(sin(($i+180)*PI/180) * $Radius + $YTop);
    303. 

  303.        if ( $MinY == "" || $Yp > $MinY ) { $MinY = $Yp; }
    304. 

  304. 

  305.        if ( $Xp2 >= floor($X2) ) { $Xp2--; }
    306. 

  306.        $Xp1++;
    307. 

  307. 

  308.        if ( !isset($Positions[$Yp]) )
    309. 

  309.         { $Positions[$Yp]["X1"] = $Xp1; $Positions[$Yp]["X2"] = $Xp2; }
    310. 

  310.        else
    311. 

  311.         { $Positions[$Yp]["X1"] = ($Positions[$Yp]["X1"]+$Xp1)/2; $Positions[$Yp]["X2"] = ($Positions[$Yp]["X2"]+$Xp2)/2; }
    312. 

  312. 

  313.        $Xp1 = cos(($i+90)*PI/180) * $Radius + $X1 + $Radius;
    314. 

  314.        $Xp2 = cos((90-$i)*PI/180) * $Radius + $X2 - $Radius;
    315. 

  315.        $Yp  = floor(sin(($i+90)*PI/180) * $Radius + $YBottom);
    316. 

  316.        if ( $MaxY == "" || $Yp < $MaxY ) { $MaxY = $Yp; }
    317. 

  317. 

  318.        if ( $Xp2 >= floor($X2) ) { $Xp2--; }
    319. 

  319.        $Xp1++;
    320. 

  320. 

  321.        if ( !isset($Positions[$Yp]) )
    322. 

  322.         { $Positions[$Yp]["X1"] = $Xp1; $Positions[$Yp]["X2"] = $Xp2; }
    323. 

  323.        else
    324. 

  324.         { $Positions[$Yp]["X1"] = ($Positions[$Yp]["X1"]+$Xp1)/2; $Positions[$Yp]["X2"] = ($Positions[$Yp]["X2"]+$Xp2)/2; }
    325. 

  325.       }
    326. 

  326. 

  327.      $ManualColor  = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    328. 

  328.      foreach($Positions as $Yp => $Bounds)
    329. 

  329.       {
    330. 

  330.        $X1 = $Bounds["X1"]; $X1Dec = $this->getFirstDecimal($X1); if ( $X1Dec != 0 ) { $X1 = floor($X1)+1; }
    331. 

  331.        $X2 = $Bounds["X2"]; $X2Dec = $this->getFirstDecimal($X2); if ( $X2Dec != 0 ) { $X2 = floor($X2)-1; }
    332. 

  332.        imageline($this->Picture,$X1,$Yp,$X2,$Yp,$ManualColor);
    333. 

  333.       }
    334. 

  334.      $this->drawFilledRectangle($X1,$MinY+1,floor($X2),$MaxY-1,$Color);
    335. 

  335. 

  336.      $Radius++;
    337. 

  337.      $this->drawRoundedRectangle($X1,$Y1,$X2+1,$Y2-1,$Radius,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));
    338. 

  338. 

  339.      $this->Shadow = $RestoreShadow;
    340. 

  340.     }
    341. 

  341. 

  342.    /* Draw a rectangle with rounded corners */
    343. 

  343.    function drawRoundedFilledRectangle_deprecated($X1,$Y1,$X2,$Y2,$Radius,$Format="")
    344. 

  344.     {
    345. 

  345.      $R			= isset($Format["R"]) ? $Format["R"] : 0;
    346. 

  346.      $G			= isset($Format["G"]) ? $Format["G"] : 0;
    347. 

  347.      $B			= isset($Format["B"]) ? $Format["B"] : 0;
    348. 

  348.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    349. 

  349.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    350. 

  350.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    351. 

  351.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    352. 

  352.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    353. 

  353. 

  354.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }
    355. 

  355.      if ( $BorderR == -1 ) { $BorderR = $R; $BorderG = $G; $BorderB = $B; }
    356. 

  356. 

  357.      list($X1,$Y1,$X2,$Y2) = $this->fixBoxCoordinates($X1,$Y1,$X2,$Y2);
    358. 

  358. 

  359.      if ( $X2 - $X1 < $Radius ) { $Radius = floor((($X2-$X1)+2)/2); }
    360. 

  360.      if ( $Y2 - $Y1 < $Radius ) { $Radius = floor((($Y2-$Y1)+2)/2); }
    361. 

  361. 

  362.      $RestoreShadow = $this->Shadow;
    363. 

  363.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    364. 

  364.       {
    365. 

  365.        $this->Shadow = FALSE;
    366. 

  366.        $this->drawRoundedFilledRectangle($X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,$Radius,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa));
    367. 

  367.       }
    368. 

  368. 

  369.      if ( $this->getFirstDecimal($X2) >= 5 )  { $XOffset2 = 1; } else { $XOffset2 = 0; }
    370. 

  370.      if ( $this->getFirstDecimal($X1) <= 5 )  { $XOffset1 = 1; } else { $XOffset1 = 0; }
    371. 

  371. 

  372.      if ( !$this->Antialias ) { $XOffset1 = 1; $XOffset2 = 1; }
    373. 

  373. 

  374.      $YTop    = floor($Y1+$Radius);
    375. 

  375.      $YBottom = floor($Y2-$Radius);
    376. 

  376. 

  377.      $this->drawFilledRectangle($X1-$XOffset1,$YTop,$X2+$XOffset2,$YBottom,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"NoBorder"=>TRUE));
    378. 

  378. 

  379.      $Step = 360 / (2 * PI * $Radius);
    380. 

  380.      $Color  = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    381. 

  381.      $Color2 = $this->allocateColor($this->Picture,255,0,0,$Alpha);
    382. 

  382.      $Drawn = "";
    383. 

  383. 

  384.      if ( $Alpha < 100 )  { $Drawn[$YTop] = FALSE; }
    385. 

  385.      if ( $Alpha < 100 )  { $Drawn[$YBottom] = TRUE; }
    386. 

  386.      
    387. 

  387.      for($i=0;$i<=90;$i=$i+$Step)
    388. 

  388.       {
    389. 

  389.        $Xp1 = cos(($i+180)*PI/180) * $Radius + $X1 + $Radius;
    390. 

  390.        $Xp2 = cos(((90-$i)+270)*PI/180) * $Radius + $X2 - $Radius;
    391. 

  391.        $Yp  = sin(($i+180)*PI/180) * $Radius + $YTop;
    392. 

  392. 

  393.        if ( $this->getFirstDecimal($Xp1) > 5 )  { $XOffset1 = 1; } else { $XOffset1 = 0; }
    394. 

  394.        if ( $this->getFirstDecimal($Xp2) > 5 )  { $XOffset2 = 1; } else { $XOffset2 = 0; }
    395. 

  395.        if ( $this->getFirstDecimal($Yp) > 5 )  { $YOffset = 1; } else { $YOffset = 0; }
    396. 

  396. 

  397.        if ( !isset($Drawn[$Yp+$YOffset]) || $Alpha == 100 )
    398. 

  398.         imageline($this->Picture,$Xp1+$XOffset1,$Yp+$YOffset,$Xp2+$XOffset2,$Yp+$YOffset,$Color);
    399. 

  399. 

  400.        $Drawn[$Yp+$YOffset] = $Xp2;
    401. 

  401. 

  402.        $Xp1 = cos(($i+90)*PI/180) * $Radius + $X1 + $Radius;
    403. 

  403.        $Xp2 = cos((90-$i)*PI/180) * $Radius + $X2 - $Radius;
    404. 

  404.        $Yp  = sin(($i+90)*PI/180) * $Radius + $YBottom;
    405. 

  405. 

  406.        if ( $this->getFirstDecimal($Xp1) > 7 )  { $XOffset1 = 1; } else { $XOffset1 = 0; }
    407. 

  407.        if ( $this->getFirstDecimal($Xp2) > 7 )  { $XOffset2 = 1; } else { $XOffset2 = 0; }
    408. 

  408.        if ( $this->getFirstDecimal($Yp) > 5 )  { $YOffset = 1; } else { $YOffset = 0; }
    409. 

  409. 

  410.        if ( !isset($Drawn[$Yp+$YOffset]) || $Alpha == 100 )
    411. 

  411.         imageline($this->Picture,$Xp1+$XOffset1,$Yp+$YOffset,$Xp2+$XOffset2,$Yp+$YOffset,$Color);
    412. 

  412. 

  413.        $Drawn[$Yp+$YOffset] = $Xp2;
    414. 

  414.       }
    415. 

  415. 

  416.      $this->drawRoundedRectangle($X1,$Y1,$X2,$Y2,$Radius,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$Alpha));
    417. 

  417. 

  418.      $this->Shadow = $RestoreShadow;
    419. 

  419.     }
    420. 

  420. 

  421.    /* Draw a rectangle */
    422. 

  422.    function drawRectangle($X1,$Y1,$X2,$Y2,$Format="")
    423. 

  423.     {
    424. 

  424.      $R		= isset($Format["R"]) ? $Format["R"] : 0;
    425. 

  425.      $G		= isset($Format["G"]) ? $Format["G"] : 0;
    426. 

  426.      $B		= isset($Format["B"]) ? $Format["B"] : 0;
    427. 

  427.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    428. 

  428.      $Ticks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    429. 

  429.      $NoAngle	= isset($Format["NoAngle"]) ? $Format["NoAngle"] : FALSE;
    430. 

  430. 

  431.      if ($X1 > $X2) { list($X1, $X2) = array($X2, $X1); }
    432. 

  432.      if ($Y1 > $Y2) { list($Y1, $Y2) = array($Y2, $Y1); }
    433. 

  433. 

  434.      if ( $this->Antialias )
    435. 

  435.       {
    436. 

  436.        if ( $NoAngle )
    437. 

  437.         {
    438. 

  438.          $this->drawLine($X1+1,$Y1,$X2-1,$Y1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    439. 

  439.          $this->drawLine($X2,$Y1+1,$X2,$Y2-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    440. 

  440.          $this->drawLine($X2-1,$Y2,$X1+1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    441. 

  441.          $this->drawLine($X1,$Y1+1,$X1,$Y2-1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    442. 

  442.         }
    443. 

  443.        else
    444. 

  444.         {
    445. 

  445.          $this->drawLine($X1+1,$Y1,$X2-1,$Y1,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    446. 

  446.          $this->drawLine($X2,$Y1,$X2,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    447. 

  447.          $this->drawLine($X2-1,$Y2,$X1+1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    448. 

  448.          $this->drawLine($X1,$Y1,$X1,$Y2,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    449. 

  449.         }
    450. 

  450.       }
    451. 

  451.      else
    452. 

  452.       {
    453. 

  453.        $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    454. 

  454.        imagerectangle($this->Picture,$X1,$Y1,$X2,$Y2,$Color);
    455. 

  455.       }
    456. 

  456.     }
    457. 

  457. 

  458.    /* Draw a filled rectangle */
    459. 

  459.    function drawFilledRectangle($X1,$Y1,$X2,$Y2,$Format="")
    460. 

  460.     {
    461. 

  461.      $R			= isset($Format["R"]) ? $Format["R"] : 0;
    462. 

  462.      $G			= isset($Format["G"]) ? $Format["G"] : 0;
    463. 

  463.      $B			= isset($Format["B"]) ? $Format["B"] : 0;
    464. 

  464.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    465. 

  465.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    466. 

  466.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    467. 

  467.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    468. 

  468.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha;
    469. 

  469.      $Surrounding	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    470. 

  470.      $Ticks		= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    471. 

  471.      $NoAngle		= isset($Format["NoAngle"]) ? $Format["NoAngle"] : NULL;
    472. 

  472.      $Dash		= isset($Format["Dash"]) ? $Format["Dash"] : FALSE;
    473. 

  473.      $DashStep		= isset($Format["DashStep"]) ? $Format["DashStep"] : 4;
    474. 

  474.      $DashR		= isset($Format["DashR"]) ? $Format["DashR"] : 0;
    475. 

  475.      $DashG		= isset($Format["DashG"]) ? $Format["DashG"] : 0;
    476. 

  476.      $DashB		= isset($Format["DashB"]) ? $Format["DashB"] : 0;
    477. 

  477.      $NoBorder		= isset($Format["NoBorder"]) ? $Format["NoBorder"] : FALSE;
    478. 

  478. 

  479.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }
    480. 

  480. 

  481.      if ($X1 > $X2) { list($X1, $X2) = array($X2, $X1); }
    482. 

  482.      if ($Y1 > $Y2) { list($Y1, $Y2) = array($Y2, $Y1); }
    483. 

  483. 

  484.      $RestoreShadow = $this->Shadow;
    485. 

  485.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    486. 

  486.       {
    487. 

  487.        $this->Shadow = FALSE;
    488. 

  488.        $this->drawFilledRectangle($X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"Ticks"=>$Ticks,"NoAngle"=>$NoAngle));
    489. 

  489.       }
    490. 

  490. 

  491.      $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    492. 

  492.      if ( $NoAngle )
    493. 

  493.       {
    494. 

  494.        imagefilledrectangle($this->Picture,ceil($X1)+1,ceil($Y1),floor($X2)-1,floor($Y2),$Color);
    495. 

  495.        imageline($this->Picture,ceil($X1),ceil($Y1)+1,ceil($X1),floor($Y2)-1,$Color);
    496. 

  496.        imageline($this->Picture,floor($X2),ceil($Y1)+1,floor($X2),floor($Y2)-1,$Color);
    497. 

  497.       }
    498. 

  498.      else
    499. 

  499.       imagefilledrectangle($this->Picture,ceil($X1),ceil($Y1),floor($X2),floor($Y2),$Color);
    500. 

  500. 

  501.      if ( $Dash )
    502. 

  502.       {
    503. 

  503.        if ( $BorderR != -1 ) { $iX1=$X1+1; $iY1=$Y1+1; $iX2=$X2-1; $iY2=$Y2-1; } else { $iX1=$X1; $iY1=$Y1; $iX2=$X2; $iY2=$Y2; }
    504. 

  504. 

  505.        $Color = $this->allocateColor($this->Picture,$DashR,$DashG,$DashB,$Alpha);
    506. 

  506.        $Y=$iY1-$DashStep;
    507. 

  507.        for($X=$iX1; $X<=$iX2+($iY2-$iY1); $X=$X+$DashStep)
    508. 

  508.         {
    509. 

  509.          $Y=$Y+$DashStep;
    510. 

  510.          if ( $X > $iX2 ) { $Xa = $X-($X-$iX2); $Ya = $iY1+($X-$iX2); } else { $Xa = $X; $Ya = $iY1; }
    511. 

  511.          if ( $Y > $iY2 ) { $Xb = $iX1+($Y-$iY2); $Yb = $Y-($Y-$iY2); } else { $Xb = $iX1; $Yb = $Y; }
    512. 

  512.          imageline($this->Picture,$Xa,$Ya,$Xb,$Yb,$Color);
    513. 

  513.         }
    514. 

  514.       }
    515. 

  515. 

  516.      if ( $this->Antialias && !$NoBorder )
    517. 

  517.       {
    518. 

  518.        if ( $X1 < ceil($X1) )
    519. 

  519.         {
    520. 

  520.          $AlphaA = $Alpha * (ceil($X1) - $X1);
    521. 

  521.          $Color = $this->allocateColor($this->Picture,$R,$G,$B,$AlphaA);
    522. 

  522.          imageline($this->Picture,ceil($X1)-1,ceil($Y1),ceil($X1)-1,floor($Y2),$Color);
    523. 

  523.         }
    524. 

  524. 

  525.        if ( $Y1 < ceil($Y1) )
    526. 

  526.         {
    527. 

  527.          $AlphaA = $Alpha * (ceil($Y1) - $Y1);
    528. 

  528.          $Color = $this->allocateColor($this->Picture,$R,$G,$B,$AlphaA);
    529. 

  529.          imageline($this->Picture,ceil($X1),ceil($Y1)-1,floor($X2),ceil($Y1)-1,$Color);
    530. 

  530.         }
    531. 

  531. 

  532.        if ( $X2 > floor($X2) )
    533. 

  533.         {
    534. 

  534.          $AlphaA = $Alpha * (.5-($X2 - floor($X2)));
    535. 

  535.          $Color = $this->allocateColor($this->Picture,$R,$G,$B,$AlphaA);
    536. 

  536.          imageline($this->Picture,floor($X2)+1,ceil($Y1),floor($X2)+1,floor($Y2),$Color);
    537. 

  537.         } 
    538. 

  538. 

  539.        if ( $Y2 > floor($Y2) )
    540. 

  540.         {
    541. 

  541.          $AlphaA = $Alpha * (.5-($Y2 - floor($Y2)));
    542. 

  542.          $Color = $this->allocateColor($this->Picture,$R,$G,$B,$AlphaA);
    543. 

  543.          imageline($this->Picture,ceil($X1),floor($Y2)+1,floor($X2),floor($Y2)+1,$Color);
    544. 

  544.         }
    545. 

  545.       }
    546. 

  546. 

  547.      if ( $BorderR != -1 )
    548. 

  548.       $this->drawRectangle($X1,$Y1,$X2,$Y2,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$Ticks,"NoAngle"=>$NoAngle));
    549. 

  549. 

  550.      $this->Shadow = $RestoreShadow;
    551. 

  551.     }
    552. 

  552. 

  553.    /* Draw a rectangular marker of the specified size */
    554. 

  554.    function drawRectangleMarker($X,$Y,$Format="")
    555. 

  555.     {
    556. 

  556.      $Size = isset($Format["Size"]) ? $Format["Size"] : 4;
    557. 

  557. 

  558.      $HalfSize = floor($Size/2);
    559. 

  559.      $this->drawFilledRectangle($X-$HalfSize,$Y-$HalfSize,$X+$HalfSize,$Y+$HalfSize,$Format);
    560. 

  560.     }
    561. 

  561. 

  562.    /* Drawn a spline based on the bezier function */
    563. 

  563.    function drawSpline($Coordinates,$Format="")
    564. 

  564.     {
    565. 

  565.      $R		= isset($Format["R"]) ? $Format["R"] : 0;
    566. 

  566.      $G		= isset($Format["G"]) ? $Format["G"] : 0;
    567. 

  567.      $B		= isset($Format["B"]) ? $Format["B"] : 0;
    568. 

  568.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    569. 

  569.      $Force	= isset($Format["Force"]) ? $Format["Force"] : 30;
    570. 

  570.      $Forces	= isset($Format["Forces"]) ? $Format["Forces"] : NULL;
    571. 

  571.      $ShowC	= isset($Format["ShowControl"]) ? $Format["ShowControl"] : FALSE;
    572. 

  572.      $Ticks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    573. 

  573.      $PathOnly	= isset($Format["PathOnly"]) ? $Format["PathOnly"] : FALSE;
    574. 

  574.      $Weight	= isset($Format["Weight"]) ? $Format["Weight"] : NULL;
    575. 

  575. 

  576.      $Cpt = NULL; $Mode = NULL; $Result = "";
    577. 

  577.      for($i=1;$i<=count($Coordinates)-1;$i++)
    578. 

  578.       {
    579. 

  579.        $X1 = $Coordinates[$i-1][0]; $Y1 = $Coordinates[$i-1][1];
    580. 

  580.        $X2 = $Coordinates[$i][0];   $Y2 = $Coordinates[$i][1];
    581. 

  581. 

  582.        if ( $Forces != NULL ) { $Force = $Forces[$i]; }
    583. 

  583. 

  584.        /* First segment */
    585. 

  585.        if ( $i == 1 )
    586. 

  586.         { $Xv1 = $X1; $Yv1 = $Y1; }
    587. 

  587.        else
    588. 

  588.         {
    589. 

  589.          $Angle1 = $this->getAngle($XLast,$YLast,$X1,$Y1);
    590. 

  590.          $Angle2 = $this->getAngle($X1,$Y1,$X2,$Y2);
    591. 

  591.          $XOff = cos($Angle2 * PI / 180) * $Force + $X1;
    592. 

  592.          $YOff = sin($Angle2 * PI / 180) * $Force + $Y1;
    593. 

  593. 

  594.          $Xv1 = cos($Angle1 * PI / 180) * $Force + $XOff;
    595. 

  595.          $Yv1 = sin($Angle1 * PI / 180) * $Force + $YOff;
    596. 

  596.         }
    597. 

  597. 

  598.        /* Last segment */
    599. 

  599.        if ( $i == count($Coordinates)-1 )
    600. 

  600.         { $Xv2 = $X2; $Yv2 = $Y2; }
    601. 

  601.        else
    602. 

  602.         {
    603. 

  603.          $Angle1 = $this->getAngle($X2,$Y2,$Coordinates[$i+1][0],$Coordinates[$i+1][1]);
    604. 

  604.          $Angle2 = $this->getAngle($X1,$Y1,$X2,$Y2);
    605. 

  605.          $XOff = cos(($Angle2+180) * PI / 180) * $Force + $X2;
    606. 

  606.          $YOff = sin(($Angle2+180) * PI / 180) * $Force + $Y2;
    607. 

  607. 

  608.          $Xv2 = cos(($Angle1+180) * PI / 180) * $Force + $XOff;
    609. 

  609.          $Yv2 = sin(($Angle1+180) * PI / 180) * $Force + $YOff;
    610. 

  610.         }
    611. 

  611. 

  612.        $Path = $this->drawBezier($X1,$Y1,$X2,$Y2,$Xv1,$Yv1,$Xv2,$Yv2,$Format);
    613. 

  613.        if ($PathOnly) { $Result[] = $Path; }
    614. 

  614. 

  615.        $XLast = $X1; $YLast = $Y1;
    616. 

  616.       }
    617. 

  617. 

  618.      return($Result);
    619. 

  619.     }
    620. 

  620. 

  621.    /* Draw a bezier curve with two controls points */
    622. 

  622.    function drawBezier($X1,$Y1,$X2,$Y2,$Xv1,$Yv1,$Xv2,$Yv2,$Format="")
    623. 

  623.     {
    624. 

  624.      $R		= isset($Format["R"]) ? $Format["R"] : 0;
    625. 

  625.      $G		= isset($Format["G"]) ? $Format["G"] : 0;
    626. 

  626.      $B		= isset($Format["B"]) ? $Format["B"] : 0;
    627. 

  627.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    628. 

  628.      $ShowC	= isset($Format["ShowControl"]) ? $Format["ShowControl"] : FALSE;
    629. 

  629.      $Segments	= isset($Format["Segments"]) ? $Format["Segments"] : NULL;
    630. 

  630.      $Ticks	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    631. 

  631.      $NoDraw    = isset($Format["NoDraw"]) ? $Format["NoDraw"] : FALSE;
    632. 

  632.      $PathOnly  = isset($Format["PathOnly"]) ? $Format["PathOnly"] : FALSE;
    633. 

  633.      $Weight    = isset($Format["Weight"]) ? $Format["Weight"] : NULL;
    634. 

  634.      $DrawArrow		= isset($Format["DrawArrow"]) ? $Format["DrawArrow"] : FALSE;
    635. 

  635.      $ArrowSize		= isset($Format["ArrowSize"]) ? $Format["ArrowSize"] : 10;
    636. 

  636.      $ArrowRatio	= isset($Format["ArrowRatio"]) ? $Format["ArrowRatio"] : .5;
    637. 

  637.      $ArrowTwoHeads	= isset($Format["ArrowTwoHeads"]) ? $Format["ArrowTwoHeads"] : FALSE;
    638. 

  638. 

  639.      if ( $Segments == NULL )
    640. 

  640.       {
    641. 

  641.        $Length    = $this->getLength($X1,$Y1,$X2,$Y2);
    642. 

  642.        $Precision = ($Length*125)/1000;
    643. 

  643.       }
    644. 

  644.      else
    645. 

  645.       $Precision = $Segments;
    646. 

  646. 

  647.      $P[0]["X"] = $X1;  $P[0]["Y"] = $Y1;
    648. 

  648.      $P[1]["X"] = $Xv1; $P[1]["Y"] = $Yv1;
    649. 

  649.      $P[2]["X"] = $Xv2; $P[2]["Y"] = $Yv2;
    650. 

  650.      $P[3]["X"] = $X2;  $P[3]["Y"] = $Y2;
    651. 

  651. 

  652.      /* Compute the bezier points */
    653. 

  653.      $Q = ""; $ID = 0; $Path = "";
    654. 

  654.      for($i=0;$i<=$Precision;$i=$i+1)
    655. 

  655.       {
    656. 

  656.        $u = $i / $Precision;
    657. 

  657. 

  658.        $C    = "";
    659. 

  659.        $C[0] = (1 - $u) * (1 - $u) * (1 - $u);
    660. 

  660.        $C[1] = ($u * 3) * (1 - $u) * (1 - $u);
    661. 

  661.        $C[2] = 3 * $u * $u * (1 - $u);
    662. 

  662.        $C[3] = $u * $u * $u;
    663. 

  663. 

  664.        for($j=0;$j<=3;$j++)
    665. 

  665.         {
    666. 

  666.          if ( !isset($Q[$ID]) ) { $Q[$ID] = ""; }
    667. 

  667.          if ( !isset($Q[$ID]["X"]) ) { $Q[$ID]["X"] = 0; }
    668. 

  668.          if ( !isset($Q[$ID]["Y"]) ) { $Q[$ID]["Y"] = 0; }
    669. 

  669. 

  670.          $Q[$ID]["X"] = $Q[$ID]["X"] + $P[$j]["X"] * $C[$j];
    671. 

  671.          $Q[$ID]["Y"] = $Q[$ID]["Y"] + $P[$j]["Y"] * $C[$j];
    672. 

  672.         }
    673. 

  673.        $ID++;
    674. 

  674.       }        
    675. 

  675.      $Q[$ID]["X"] = $X2; $Q[$ID]["Y"] = $Y2;
    676. 

  676. 

  677.      if ( !$NoDraw )
    678. 

  678.       {
    679. 

  679.        /* Display the control points */
    680. 

  680.        if ( $ShowC && !$PathOnly )
    681. 

  681.         {
    682. 

  682.          $Xv1 = floor($Xv1); $Yv1 = floor($Yv1); $Xv2 = floor($Xv2); $Yv2 = floor($Yv2);
    683. 

  683. 

  684.          $this->drawLine($X1,$Y1,$X2,$Y2,array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>30));
    685. 

  685. 

  686.          $MyMarkerSettings = array("R"=>255,"G"=>0,"B"=>0,"BorderR"=>255,"BorderB"=>255,"BorderG"=>255,"Size"=>4);
    687. 

  687.          $this->drawRectangleMarker($Xv1,$Yv1,$MyMarkerSettings);
    688. 

  688.          $this->drawText($Xv1+4,$Yv1,"v1");
    689. 

  689.          $MyMarkerSettings = array("R"=>0,"G"=>0,"B"=>255,"BorderR"=>255,"BorderB"=>255,"BorderG"=>255,"Size"=>4);
    690. 

  690.          $this->drawRectangleMarker($Xv2,$Yv2,$MyMarkerSettings);
    691. 

  691.          $this->drawText($Xv2+4,$Yv2,"v2");
    692. 

  692.         }
    693. 

  693. 

  694.        /* Draw the bezier */
    695. 

  695.        $LastX = NULL; $LastY = NULL; $Cpt = NULL; $Mode = NULL; $ArrowS = NULL;
    696. 

  696.        foreach ($Q as $Key => $Point)
    697. 

  697.         {
    698. 

  698.          $X = $Point["X"]; $Y = $Point["Y"];
    699. 

  699. 

  700.          /* Get the first segment */
    701. 

  701.          if ( $ArrowS == NULL && $LastX != NULL && $LastY != NULL )
    702. 

  702.           { $ArrowS["X2"] = $LastX; $ArrowS["Y2"] = $LastY; $ArrowS["X1"] = $X; $ArrowS["Y1"] = $Y; }
    703. 

  703. 

  704.          if ( $LastX != NULL && $LastY != NULL && !$PathOnly)
    705. 

  705.           list($Cpt,$Mode) = $this->drawLine($LastX,$LastY,$X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks,"Cpt"=>$Cpt,"Mode"=>$Mode,"Weight"=>$Weight));
    706. 

  706. 

  707.          /* Get the last segment */
    708. 

  708.          $ArrowE["X1"] = $LastX; $ArrowE["Y1"] = $LastY; $ArrowE["X2"] = $X; $ArrowE["Y2"] = $Y;
    709. 

  709. 

  710.          $LastX = $X; $LastY = $Y;
    711. 

  711.         }
    712. 

  712. 

  713.        if ( $DrawArrow && !$PathOnly )
    714. 

  714.         {
    715. 

  715.          $ArrowSettings = array("FillR"=>$R,"FillG"=>$G,"FillB"=>$B,"Alpha"=>$Alpha,"Size"=>$ArrowSize,"Ratio"=>$ArrowRatio);
    716. 

  716.          if ( $ArrowTwoHeads )
    717. 

  717.           $this->drawArrow($ArrowS["X1"],$ArrowS["Y1"],$ArrowS["X2"],$ArrowS["Y2"],$ArrowSettings);
    718. 

  718. 

  719.          $this->drawArrow($ArrowE["X1"],$ArrowE["Y1"],$ArrowE["X2"],$ArrowE["Y2"],$ArrowSettings);
    720. 

  720.         }
    721. 

  721.       }
    722. 

  722.      return($Q);
    723. 

  723.     }
    724. 

  724. 

  725.    /* Draw a line between two points */
    726. 

  726.    function drawLine($X1,$Y1,$X2,$Y2,$Format="")
    727. 

  727.     {
    728. 

  728.      $R	    = isset($Format["R"]) ? $Format["R"] : 0;
    729. 

  729.      $G	    = isset($Format["G"]) ? $Format["G"] : 0;
    730. 

  730.      $B	    = isset($Format["B"]) ? $Format["B"] : 0;
    731. 

  731.      $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    732. 

  732.      $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    733. 

  733.      $Cpt   = isset($Format["Cpt"]) ? $Format["Cpt"] : 1;
    734. 

  734.      $Mode  = isset($Format["Mode"]) ? $Format["Mode"] : 1;
    735. 

  735.      $Weight = isset($Format["Weight"]) ? $Format["Weight"] : NULL;
    736. 

  736. 

  737.      if ( $this->Antialias == FALSE && $Ticks == NULL )
    738. 

  738.       {
    739. 

  739.        if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    740. 

  740.         {
    741. 

  741.          $ShadowColor = $this->allocateColor($this->Picture,$this->ShadowR,$this->ShadowG,$this->ShadowB,$this->Shadowa);
    742. 

  742.          imageline($this->Picture,$X1+$this->ShadowX,$Y1+$this->ShadowY,$X2+$this->ShadowX,$Y2+$this->ShadowY,$ShadowColor);
    743. 

  743.         }
    744. 

  744. 

  745.        $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    746. 

  746.        imageline($this->Picture,$X1,$Y1,$X2,$Y2,$Color);
    747. 

  747.        return(0);
    748. 

  748.       }
    749. 

  749. 

  750.      $Distance = sqrt(($X2-$X1)*($X2-$X1)+($Y2-$Y1)*($Y2-$Y1));  
    751. 

  751.      if ( $Distance == 0 ) { return(-1); }
    752. 

  752. 

  753.      /* Derivative algorithm for overweighted lines, re-route to polygons primitives */
    754. 

  754.      if ( $Weight != NULL )
    755. 

  755.       {
    756. 

  756.        $Angle        = $this->getAngle($X1,$Y1,$X2,$Y2);
    757. 

  757.        $PolySettings = array ("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderAlpha"=>$Alpha);
    758. 

  758. 

  759.        if ( $Ticks == NULL )
    760. 

  760.         {
    761. 

  761.          $Points   = ""; 
    762. 

  762.          $Points[] = cos(deg2rad($Angle-90)) * $Weight + $X1; $Points[] = sin(deg2rad($Angle-90)) * $Weight + $Y1;
    763. 

  763.          $Points[] = cos(deg2rad($Angle+90)) * $Weight + $X1; $Points[] = sin(deg2rad($Angle+90)) * $Weight + $Y1;
    764. 

  764.          $Points[] = cos(deg2rad($Angle+90)) * $Weight + $X2; $Points[] = sin(deg2rad($Angle+90)) * $Weight + $Y2;
    765. 

  765.          $Points[] = cos(deg2rad($Angle-90)) * $Weight + $X2; $Points[] = sin(deg2rad($Angle-90)) * $Weight + $Y2;
    766. 

  766. 

  767.          $this->drawPolygon($Points,$PolySettings);
    768. 

  768.         }
    769. 

  769.        else
    770. 

  770.         {
    771. 

  771.          for($i=0;$i<=$Distance;$i=$i+$Ticks*2)
    772. 

  772.           {
    773. 

  773.            $Xa = (($X2-$X1)/$Distance) * $i + $X1; $Ya = (($Y2-$Y1)/$Distance) * $i + $Y1;
    774. 

  774.            $Xb = (($X2-$X1)/$Distance) * ($i+$Ticks) + $X1; $Yb = (($Y2-$Y1)/$Distance) * ($i+$Ticks) + $Y1;
    775. 

  775. 

  776.            $Points   = ""; 
    777. 

  777.            $Points[] = cos(deg2rad($Angle-90)) * $Weight + $Xa; $Points[] = sin(deg2rad($Angle-90)) * $Weight + $Ya;
    778. 

  778.            $Points[] = cos(deg2rad($Angle+90)) * $Weight + $Xa; $Points[] = sin(deg2rad($Angle+90)) * $Weight + $Ya;
    779. 

  779.            $Points[] = cos(deg2rad($Angle+90)) * $Weight + $Xb; $Points[] = sin(deg2rad($Angle+90)) * $Weight + $Yb;
    780. 

  780.            $Points[] = cos(deg2rad($Angle-90)) * $Weight + $Xb; $Points[] = sin(deg2rad($Angle-90)) * $Weight 	+ $Yb;
    781. 

  781. 

  782.            $this->drawPolygon($Points,$PolySettings);
    783. 

  783.           }
    784. 

  784.         }
    785. 

  785. 

  786.        return(1);
    787. 

  787.       }
    788. 

  788. 

  789.      $XStep = ($X2-$X1) / $Distance;
    790. 

  790.      $YStep = ($Y2-$Y1) / $Distance;
    791. 

  791. 

  792.      for($i=0;$i<=$Distance;$i++)
    793. 

  793.       {
    794. 

  794.        $X = $i * $XStep + $X1;
    795. 

  795.        $Y = $i * $YStep + $Y1;
    796. 

  796. 

  797.        if ( $Ticks != NULL )
    798. 

  798.         {
    799. 

  799.          if ( $Cpt % $Ticks == 0 )
    800. 

  800.           { $Cpt = 0; if ( $Mode == 1 ) { $Mode = 0; } else { $Mode = 1; } }
    801. 

  801. 

  802.          if ( $Mode == 1 )
    803. 

  803.           $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    804. 

  804. 

  805.          $Cpt++;
    806. 

  806.         }
    807. 

  807.        else
    808. 

  808.         $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    809. 

  809.       }
    810. 

  810.      return(array($Cpt,$Mode));
    811. 

  811.     }
    812. 

  812. 

  813.    /* Draw a circle */
    814. 

  814.    function drawCircle($Xc,$Yc,$Height,$Width,$Format="")
    815. 

  815.     {
    816. 

  816.      $R	    = isset($Format["R"]) ? $Format["R"] : 0;
    817. 

  817.      $G	    = isset($Format["G"]) ? $Format["G"] : 0;
    818. 

  818.      $B	    = isset($Format["B"]) ? $Format["B"] : 0;
    819. 

  819.      $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    820. 

  820.      $Ticks = isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    821. 

  821. 

  822.      $Height	= abs($Height);
    823. 

  823.      $Width	= abs($Width);
    824. 

  824. 

  825.      if ( $Height == 0 ) { $Height = 1; }
    826. 

  826.      if ( $Width == 0 )  { $Width = 1; }
    827. 

  827.      $Xc = floor($Xc); $Yc = floor($Yc);
    828. 

  828. 

  829.      $RestoreShadow = $this->Shadow;
    830. 

  830.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    831. 

  831.       {
    832. 

  832.        $this->Shadow = FALSE;
    833. 

  833.        $this->drawCircle($Xc+$this->ShadowX,$Yc+$this->ShadowY,$Height,$Width,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"Ticks"=>$Ticks));
    834. 

  834.       }
    835. 

  835. 

  836.      if ( $Width == 0 ) { $Width = $Height; }
    837. 

  837.      if ( $R < 0 ) { $R = 0; } if ( $R > 255 ) { $R = 255; }
    838. 

  838.      if ( $G < 0 ) { $G = 0; } if ( $G > 255 ) { $G = 255; }
    839. 

  839.      if ( $B < 0 ) { $B = 0; } if ( $B > 255 ) { $B = 255; }
    840. 

  840. 

  841.      $Step = 360 / (2 * PI * max($Width,$Height));
    842. 

  842.      $Mode = 1; $Cpt = 1;
    843. 

  843.      for($i=0;$i<=360;$i=$i+$Step)
    844. 

  844.       {
    845. 

  845.        $X = cos($i*PI/180) * $Height + $Xc;
    846. 

  846.        $Y = sin($i*PI/180) * $Width + $Yc;
    847. 

  847. 

  848.        if ( $Ticks != NULL )
    849. 

  849.         {
    850. 

  850.          if ( $Cpt % $Ticks == 0 )
    851. 

  851.           { $Cpt = 0; if ( $Mode == 1 ) { $Mode = 0; } else { $Mode = 1; } }
    852. 

  852. 

  853.          if ( $Mode == 1 )
    854. 

  854.           $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    855. 

  855. 

  856.          $Cpt++;
    857. 

  857.         }
    858. 

  858.        else
    859. 

  859.         $this->drawAntialiasPixel($X,$Y,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha));
    860. 

  860. 

  861.       }
    862. 

  862.      $this->Shadow = $RestoreShadow;
    863. 

  863.     }
    864. 

  864. 

  865.    /* Draw a filled circle */
    866. 

  866.    function drawFilledCircle($X,$Y,$Radius,$Format="")
    867. 

  867.     {
    868. 

  868.      $R			= isset($Format["R"]) ? $Format["R"] : 0;
    869. 

  869.      $G			= isset($Format["G"]) ? $Format["G"] : 0;
    870. 

  870.      $B			= isset($Format["B"]) ? $Format["B"] : 0;
    871. 

  871.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    872. 

  872.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : -1;
    873. 

  873.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : -1;
    874. 

  874.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : -1;
    875. 

  875.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : $Alpha;
    876. 

  876.      $Ticks     	= isset($Format["Ticks"]) ? $Format["Ticks"] : NULL;
    877. 

  877.      $Surrounding 	= isset($Format["Surrounding"]) ? $Format["Surrounding"] : NULL;
    878. 

  878. 

  879.      if ( $Radius == 0 ) { $Radius = 1; }
    880. 

  880.      if ( $Surrounding != NULL ) { $BorderR = $R+$Surrounding; $BorderG = $G+$Surrounding; $BorderB = $B+$Surrounding; }
    881. 

  881.      $X = floor($X); $Y = floor($Y);
    882. 

  882. 

  883.      $Radius = abs($Radius);
    884. 

  884. 

  885.      $RestoreShadow = $this->Shadow;
    886. 

  886.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    887. 

  887.       {
    888. 

  888.        $this->Shadow = FALSE;
    889. 

  889.        $this->drawFilledCircle($X+$this->ShadowX,$Y+$this->ShadowY,$Radius,array("R"=>$this->ShadowR,"G"=>$this->ShadowG,"B"=>$this->ShadowB,"Alpha"=>$this->Shadowa,"Ticks"=>$Ticks));
    890. 

  890.       }
    891. 

  891. 

  892.      $this->Mask  = "";
    893. 

  893.      $Color = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    894. 

  894.      for ($i=0; $i<=$Radius*2; $i++)
    895. 

  895.       {
    896. 

  896.        $Slice  = sqrt($Radius * $Radius - ($Radius - $i) * ($Radius - $i));
    897. 

  897.        $XPos   = floor($Slice);
    898. 

  898.        $YPos   = $Y + $i - $Radius;
    899. 

  899.        $AAlias = $Slice - floor($Slice);
    900. 

  900. 

  901.        $this->Mask[$X-$XPos][$YPos] = TRUE;
    902. 

  902.        $this->Mask[$X+$XPos][$YPos] = TRUE;
    903. 

  903.        imageline($this->Picture,$X-$XPos,$YPos,$X+$XPos,$YPos,$Color);
    904. 

  904.       }
    905. 

  905.      if ( $this->Antialias )
    906. 

  906.       $this->drawCircle($X,$Y,$Radius,$Radius,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"Ticks"=>$Ticks));
    907. 

  907. 

  908.      $this->Mask = "";
    909. 

  909. 

  910.      if ( $BorderR != -1 )
    911. 

  911.       $this->drawCircle($X,$Y,$Radius,$Radius,array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha,"Ticks"=>$Ticks));
    912. 

  912. 

  913.      $this->Shadow	= $RestoreShadow;
    914. 

  914.     }
    915. 

  915. 

  916.    /* Write text */
    917. 

  917.    function drawText($X,$Y,$Text,$Format="")
    918. 

  918.     {
    919. 

  919.      $R			= isset($Format["R"]) ? $Format["R"] : $this->FontColorR;
    920. 

  920.      $G			= isset($Format["G"]) ? $Format["G"] : $this->FontColorG;
    921. 

  921.      $B			= isset($Format["B"]) ? $Format["B"] : $this->FontColorB;
    922. 

  922.      $Angle		= isset($Format["Angle"]) ? $Format["Angle"] : 0;
    923. 

  923.      $Align		= isset($Format["Align"]) ? $Format["Align"] : TEXT_ALIGN_BOTTOMLEFT;
    924. 

  924.      $Alpha		= isset($Format["Alpha"]) ? $Format["Alpha"] : $this->FontColorA;
    925. 

  925.      $FontName		= isset($Format["FontName"]) ? $Format["FontName"] : $this->FontName;
    926. 

  926.      $FontSize		= isset($Format["FontSize"]) ? $Format["FontSize"] : $this->FontSize;
    927. 

  927.      $ShowOrigine	= isset($Format["ShowOrigine"]) ? $Format["ShowOrigine"] : FALSE;
    928. 

  928.      $TOffset		= isset($Format["TOffset"]) ? $Format["TOffset"] : 2;
    929. 

  929.      $DrawBox		= isset($Format["DrawBox"]) ? $Format["DrawBox"] : FALSE;
    930. 

  930.      $DrawBoxBorder	= isset($Format["DrawBoxBorder"]) ? $Format["DrawBoxBorder"] : TRUE;
    931. 

  931.      $BorderOffset	= isset($Format["BorderOffset"]) ? $Format["BorderOffset"] : 6;
    932. 

  932.      $BoxRounded	= isset($Format["BoxRounded"]) ? $Format["BoxRounded"] : FALSE;
    933. 

  933.      $RoundedRadius	= isset($Format["RoundedRadius"]) ? $Format["RoundedRadius"] : 6;
    934. 

  934.      $BoxR		= isset($Format["BoxR"]) ? $Format["BoxR"] : 255;
    935. 

  935.      $BoxG		= isset($Format["BoxG"]) ? $Format["BoxG"] : 255;
    936. 

  936.      $BoxB		= isset($Format["BoxB"]) ? $Format["BoxB"] : 255;
    937. 

  937.      $BoxAlpha		= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 50;
    938. 

  938.      $BoxSurrounding	= isset($Format["BoxSurrounding"]) ? $Format["BoxSurrounding"] : "";
    939. 

  939.      $BoxBorderR	= isset($Format["BoxR"]) ? $Format["BoxR"] : 0;
    940. 

  940.      $BoxBorderG	= isset($Format["BoxG"]) ? $Format["BoxG"] : 0;
    941. 

  941.      $BoxBorderB	= isset($Format["BoxB"]) ? $Format["BoxB"] : 0;
    942. 

  942.      $BoxBorderAlpha	= isset($Format["BoxAlpha"]) ? $Format["BoxAlpha"] : 50;
    943. 

  943.      $NoShadow		= isset($Format["NoShadow"]) ? $Format["NoShadow"] : FALSE;
    944. 

  944. 

  945.      $Shadow = $this->Shadow;
    946. 

  946.      if ( $NoShadow ) { $this->Shadow = FALSE; }
    947. 

  947. 

  948.      if ( $BoxSurrounding != "" ) { $BoxBorderR = $BoxR - $BoxSurrounding; $BoxBorderG = $BoxG - $BoxSurrounding; $BoxBorderB = $BoxB - $BoxSurrounding; $BoxBorderAlpha = $Boxalpha; }
    949. 

  949. 

  950.      if ( $ShowOrigine )
    951. 

  951.       {
    952. 

  952.        $MyMarkerSettings = array("R"=>255,"G"=>0,"B"=>0,"BorderR"=>255,"BorderB"=>255,"BorderG"=>255,"Size"=>4);
    953. 

  953.        $this->drawRectangleMarker($X,$Y,$MyMarkerSettings);
    954. 

  954.       }
    955. 

  955. 

  956.      $TxtPos = $this->getTextBox($X,$Y,$FontName,$FontSize,$Angle,$Text);
    957. 

  957. 

  958.      if ( $DrawBox && ($Angle == 0 || $Angle == 90 || $Angle == 180 || $Angle == 270))
    959. 

  959.       {
    960. 

  960.        $T[0]["X"]=0;$T[0]["Y"]=0;$T[1]["X"]=0;$T[1]["Y"]=0;$T[2]["X"]=0;$T[2]["Y"]=0;$T[3]["X"]=0;$T[3]["Y"]=0;
    961. 

  961.        if ( $Angle == 0 ) { $T[0]["X"]=-$TOffset;$T[0]["Y"]=$TOffset;$T[1]["X"]=$TOffset;$T[1]["Y"]=$TOffset;$T[2]["X"]=$TOffset;$T[2]["Y"]=-$TOffset;$T[3]["X"]=-$TOffset;$T[3]["Y"]=-$TOffset; }
    962. 

  962. 

  963.        $X1 = min($TxtPos[0]["X"],$TxtPos[1]["X"],$TxtPos[2]["X"],$TxtPos[3]["X"]) - $BorderOffset + 3;
    964. 

  964.        $Y1 = min($TxtPos[0]["Y"],$TxtPos[1]["Y"],$TxtPos[2]["Y"],$TxtPos[3]["Y"]) - $BorderOffset;
    965. 

  965.        $X2 = max($TxtPos[0]["X"],$TxtPos[1]["X"],$TxtPos[2]["X"],$TxtPos[3]["X"]) + $BorderOffset + 3;
    966. 

  966.        $Y2 = max($TxtPos[0]["Y"],$TxtPos[1]["Y"],$TxtPos[2]["Y"],$TxtPos[3]["Y"]) + $BorderOffset - 3;
    967. 

  967. 

  968.        $X1 = $X1 - $TxtPos[$Align]["X"] + $X + $T[0]["X"];
    969. 

  969.        $Y1 = $Y1 - $TxtPos[$Align]["Y"] + $Y + $T[0]["Y"];
    970. 

  970.        $X2 = $X2 - $TxtPos[$Align]["X"] + $X + $T[0]["X"];
    971. 

  971.        $Y2 = $Y2 - $TxtPos[$Align]["Y"] + $Y + $T[0]["Y"];
    972. 

  972. 

  973.        $Settings = array("R"=>$BoxR,"G"=>$BoxG,"B"=>$BoxB,"Alpha"=>$BoxAlpha,"BorderR"=>$BoxBorderR,"BorderG"=>$BoxBorderG,"BorderB"=>$BoxBorderB,"BorderAlpha"=>$BoxBorderAlpha);
    974. 

  974. 

  975.        if ( $BoxRounded )
    976. 

  976.         { $this->drawRoundedFilledRectangle($X1,$Y1,$X2,$Y2,$RoundedRadius,$Settings); }
    977. 

  977.        else
    978. 

  978.         { $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,$Settings); }
    979. 

  979.       }
    980. 

  980. 

  981.      $X = $X - $TxtPos[$Align]["X"] + $X;
    982. 

  982.      $Y = $Y - $TxtPos[$Align]["Y"] + $Y;
    983. 

  983. 

  984.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    985. 

  985.       {
    986. 

  986.        $C_ShadowColor = $this->allocateColor($this->Picture,$this->ShadowR,$this->ShadowG,$this->ShadowB,$this->Shadowa);
    987. 

  987.        imagettftext($this->Picture,$FontSize,$Angle,$X+$this->ShadowX,$Y+$this->ShadowY,$C_ShadowColor,$FontName,$Text);
    988. 

  988.       }
    989. 

  989. 

  990.      $C_TextColor = $this->AllocateColor($this->Picture,$R,$G,$B,$Alpha);
    991. 

  991.      imagettftext($this->Picture,$FontSize,$Angle,$X,$Y,$C_TextColor,$FontName,$Text);
    992. 

  992. 

  993.      $this->Shadow = $Shadow;
    994. 

  994. 

  995.      return($TxtPos);
    996. 

  996.     }
    997. 

  997. 

  998.    /* Draw a gradient within a defined area */
    999. 

  999.    function drawGradientArea($X1,$Y1,$X2,$Y2,$Direction,$Format="")
    1000. 

  1000.     {
    1001. 

  1001.      $StartR	= isset($Format["StartR"]) ? $Format["StartR"] : 90;
    1002. 

  1002.      $StartG	= isset($Format["StartG"]) ? $Format["StartG"] : 90;
    1003. 

  1003.      $StartB	= isset($Format["StartB"]) ? $Format["StartB"] : 90;
    1004. 

  1004.      $EndR	= isset($Format["EndR"]) ? $Format["EndR"] : 0;
    1005. 

  1005.      $EndG	= isset($Format["EndG"]) ? $Format["EndG"] : 0;
    1006. 

  1006.      $EndB	= isset($Format["EndB"]) ? $Format["EndB"] : 0;
    1007. 

  1007.      $Alpha	= isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    1008. 

  1008.      $Levels	= isset($Format["Levels"]) ? $Format["Levels"] : NULL;
    1009. 

  1009. 

  1010.      $Shadow = $this->Shadow;
    1011. 

  1011.      $this->Shadow = FALSE;
    1012. 

  1012. 

  1013.      if ( $StartR == $EndR && $StartG == $EndG && $StartB == $EndB )
    1014. 

  1014.       {
    1015. 

  1015.        $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,array("R"=>$StartR,"G"=>$StartG,"B"=>$StartB,"Alpha"=>$Alpha));
    1016. 

  1016.        return(0);
    1017. 

  1017.       }
    1018. 

  1018. 

  1019.      if ( $Levels != NULL )
    1020. 

  1020.       { $EndR=$StartR+$Levels; $EndG=$StartG+$Levels; $EndB=$StartB+$Levels; }
    1021. 

  1021. 

  1022.      if ($X1 > $X2) { list($X1, $X2) = array($X2, $X1); }
    1023. 

  1023.      if ($Y1 > $Y2) { list($Y1, $Y2) = array($Y2, $Y1); }
    1024. 

  1024. 

  1025.      if ( $Direction == DIRECTION_VERTICAL )   { $Width = abs($Y2-$Y1); }
    1026. 

  1026.      if ( $Direction == DIRECTION_HORIZONTAL ) { $Width = abs($X2-$X1); }
    1027. 

  1027. 

  1028.      $Step     = max(abs($EndR-$StartR),abs($EndG-$StartG),abs($EndB-$StartB));
    1029. 

  1029.      $StepSize = $Width/$Step;
    1030. 

  1030.      $RStep    = ($EndR-$StartR)/$Step;
    1031. 

  1031.      $GStep    = ($EndG-$StartG)/$Step;
    1032. 

  1032.      $BStep    = ($EndB-$StartB)/$Step;
    1033. 

  1033. 

  1034.      $R=$StartR;$G=$StartG;$B=$StartB;
    1035. 

  1035.      switch($Direction)
    1036. 

  1036.       {
    1037. 

  1037.        case DIRECTION_VERTICAL:
    1038. 

  1038.         $StartY = $Y1; $EndY = floor($Y2)+1; $LastY2 = $StartY;
    1039. 

  1039.         for($i=0;$i<=$Step;$i++)
    1040. 

  1040.          {
    1041. 

  1041.           $Y2 = floor($StartY + ($i * $StepSize));
    1042. 

  1042. 

  1043.           if ($Y2 > $EndY) { $Y2 = $EndY; }
    1044. 

  1044.           if (($Y1 != $Y2 && $Y1 < $Y2) || $Y2 == $EndY)
    1045. 

  1045.            {
    1046. 

  1046.             $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);
    1047. 

  1047.             $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,$Color);
    1048. 

  1048.             $LastY2 = max($LastY2,$Y2);
    1049. 

  1049.             $Y1 = $Y2+1;
    1050. 

  1050.            }
    1051. 

  1051.           $R = $R + $RStep; $G = $G + $GStep; $B = $B + $BStep;
    1052. 

  1052.          }
    1053. 

  1053.         if ( $LastY2 < $EndY && isset($Color)) { for ($i=$LastY2+1;$i<=$EndY;$i++) { $this->drawLine($X1,$i,$X2,$i,$Color); } }
    1054. 

  1054.         break;
    1055. 

  1055. 

  1056.        case DIRECTION_HORIZONTAL:
    1057. 

  1057.         $StartX = $X1; $EndX = $X2;
    1058. 

  1058.         for($i=0;$i<=$Step;$i++)
    1059. 

  1059.          {
    1060. 

  1060.           $X2 = floor($StartX + ($i * $StepSize));
    1061. 

  1061. 

  1062.           if ($X2 > $EndX) { $X2 = $EndX; }
    1063. 

  1063.           if (($X1 != $X2 && $X1 < $X2) || $X2 == $EndX)
    1064. 

  1064.            {
    1065. 

  1065.             $Color = array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha);
    1066. 

  1066.             $this->drawFilledRectangle($X1,$Y1,$X2,$Y2,$Color);
    1067. 

  1067.             $X1 = $X2+1;
    1068. 

  1068.            }
    1069. 

  1069.           $R = $R + $RStep; $G = $G + $GStep; $B = $B + $BStep; 
    1070. 

  1070.          }
    1071. 

  1071.         if ( $X2 < $EndX && isset($Color)) { $this->drawFilledRectangle($X2,$Y1,$EndX,$Y2,$Color); }
    1072. 

  1072.         break;
    1073. 

  1073.       }
    1074. 

  1074. 

  1075.      $this->Shadow = $Shadow;
    1076. 

  1076. 

  1077.     }
    1078. 

  1078. 

  1079.    /* Draw an aliased pixel */
    1080. 

  1080.    function drawAntialiasPixel($X,$Y,$Format="")
    1081. 

  1081.     {
    1082. 

  1082.      $R     = isset($Format["R"]) ? $Format["R"] : 0;
    1083. 

  1083.      $G     = isset($Format["G"]) ? $Format["G"] : 0;
    1084. 

  1084.      $B     = isset($Format["B"]) ? $Format["B"] : 0;
    1085. 

  1085.      $Alpha = isset($Format["Alpha"]) ? $Format["Alpha"] : 100;
    1086. 

  1086. 

  1087.      if ( $X < 0 || $Y < 0 || $X >= $this->XSize || $Y >= $this->YSize )
    1088. 

  1088.       return(-1);
    1089. 

  1089. 

  1090.      if ( $R < 0 ) { $R = 0; } if ( $R > 255 ) { $R = 255; }
    1091. 

  1091.      if ( $G < 0 ) { $G = 0; } if ( $G > 255 ) { $G = 255; }
    1092. 

  1092.      if ( $B < 0 ) { $B = 0; } if ( $B > 255 ) { $B = 255; }
    1093. 

  1093. 

  1094.      if ( !$this->Antialias )
    1095. 

  1095.       {
    1096. 

  1096.        if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    1097. 

  1097.         {
    1098. 

  1098.          $ShadowColor = $this->allocateColor($this->Picture,$this->ShadowR,$this->ShadowG,$this->ShadowB,$this->Shadowa);
    1099. 

  1099.          imagesetpixel($this->Picture,$X+$this->ShadowX,$Y+$this->ShadowY,$ShadowColor);
    1100. 

  1100.         }
    1101. 

  1101. 

  1102.        $PlotColor = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    1103. 

  1103.        imagesetpixel($this->Picture,$X,$Y,$PlotColor);
    1104. 

  1104. 

  1105.        return(0);
    1106. 

  1106.       }
    1107. 

  1107. 

  1108.      $Plot = "";
    1109. 

  1109.      $Xi   = floor($X);
    1110. 

  1110.      $Yi   = floor($Y);
    1111. 

  1111. 

  1112.      if ( $Xi == $X && $Yi == $Y)
    1113. 

  1113.       {
    1114. 

  1114.        if ( $Alpha == 100 )
    1115. 

  1115.         $this->drawAlphaPixel($X,$Y,100,$R,$G,$B);
    1116. 

  1116.        else
    1117. 

  1117.         $this->drawAlphaPixel($X,$Y,$Alpha,$R,$G,$B);
    1118. 

  1118.       }
    1119. 

  1119.      else
    1120. 

  1120.       {
    1121. 

  1121.        $Alpha1 = (((1 - ($X - floor($X))) * (1 - ($Y - floor($Y))) * 100) / 100) * $Alpha;
    1122. 

  1122.        if ( $Alpha1 > $this->AntialiasQuality ) { $this->drawAlphaPixel($Xi,$Yi,$Alpha1,$R,$G,$B); }
    1123. 

  1123. 

  1124.        $Alpha2 = ((($X - floor($X)) * (1 - ($Y - floor($Y))) * 100) / 100) * $Alpha;
    1125. 

  1125.        if ( $Alpha2 > $this->AntialiasQuality ) { $this->drawAlphaPixel($Xi+1,$Yi,$Alpha2,$R,$G,$B); }
    1126. 

  1126. 

  1127.        $Alpha3 = (((1 - ($X - floor($X))) * ($Y - floor($Y)) * 100) / 100) * $Alpha;
    1128. 

  1128.        if ( $Alpha3 > $this->AntialiasQuality ) { $this->drawAlphaPixel($Xi,$Yi+1,$Alpha3,$R,$G,$B); }
    1129. 

  1129. 

  1130.        $Alpha4 = ((($X - floor($X)) * ($Y - floor($Y)) * 100) / 100) * $Alpha;
    1131. 

  1131.        if ( $Alpha4 > $this->AntialiasQuality ) { $this->drawAlphaPixel($Xi+1,$Yi+1,$Alpha4,$R,$G,$B); }
    1132. 

  1132.       }
    1133. 

  1133.     }
    1134. 

  1134. 

  1135.    /* Draw a semi-transparent pixel */
    1136. 

  1136.    function drawAlphaPixel($X,$Y,$Alpha,$R,$G,$B)
    1137. 

  1137.     {
    1138. 

  1138.      if ( isset($this->Mask[$X])) { if ( isset($this->Mask[$X][$Y]) ) { return(0); } }
    1139. 

  1139. 

  1140.      if ( $X < 0 || $Y < 0 || $X >= $this->XSize || $Y >= $this->YSize )
    1141. 

  1141.       return(-1);
    1142. 

  1142. 

  1143.      if ( $R < 0 ) { $R = 0; } if ( $R > 255 ) { $R = 255; }
    1144. 

  1144.      if ( $G < 0 ) { $G = 0; } if ( $G > 255 ) { $G = 255; }
    1145. 

  1145.      if ( $B < 0 ) { $B = 0; } if ( $B > 255 ) { $B = 255; }
    1146. 

  1146. 

  1147.      if ( $this->Shadow && $this->ShadowX != 0 && $this->ShadowY != 0 )
    1148. 

  1148.       {
    1149. 

  1149.        $AlphaFactor = floor(($Alpha / 100) * $this->Shadowa);
    1150. 

  1150.        $ShadowColor = $this->allocateColor($this->Picture,$this->ShadowR,$this->ShadowG,$this->ShadowB,$AlphaFactor);
    1151. 

  1151.        imagesetpixel($this->Picture,$X+$this->ShadowX,$Y+$this->ShadowY,$ShadowColor);
    1152. 

  1152.       }
    1153. 

  1153. 

  1154.      $C_Aliased = $this->allocateColor($this->Picture,$R,$G,$B,$Alpha);
    1155. 

  1155.      imagesetpixel($this->Picture,$X,$Y,$C_Aliased);
    1156. 

  1156.     }
    1157. 

  1157. 

  1158.    /* Convert apha to base 10 */
    1159. 

  1159.    function convertAlpha($AlphaValue)
    1160. 

  1160.     { return((127/100)*(100-$AlphaValue)); }
    1161. 

  1161. 

  1162.    /* Allocate a color with transparency */
    1163. 

  1163.    function allocateColor($Picture,$R,$G,$B,$Alpha=100)
    1164. 

  1164.     {
    1165. 

  1165.      if ( $R < 0 ) { $R = 0; } if ( $R > 255 ) { $R = 255; }
    1166. 

  1166.      if ( $G < 0 ) { $G = 0; } if ( $G > 255 ) { $G = 255; }
    1167. 

  1167.      if ( $B < 0 ) { $B = 0; } if ( $B > 255 ) { $B = 255; }
    1168. 

  1168.      if ( $Alpha < 0 )  { $Alpha = 0; }
    1169. 

  1169.      if ( $Alpha > 100) { $Alpha = 100; }
    1170. 

  1170. 

  1171.      $Alpha = $this->convertAlpha($Alpha);
    1172. 

  1172.      return(imagecolorallocatealpha($Picture,$R,$G,$B,$Alpha));
    1173. 

  1173.     }
    1174. 

  1174. 

  1175.    /* Load a PNG file and draw it over the chart */
    1176. 

  1176.    function drawFromPNG($X,$Y,$FileName)
    1177. 

  1177.     { $this->drawFromPicture(1,$FileName,$X,$Y); }
    1178. 

  1178. 

  1179.    /* Load a GIF file and draw it over the chart */
    1180. 

  1180.    function drawFromGIF($X,$Y,$FileName)
    1181. 

  1181.     { $this->drawFromPicture(2,$FileName,$X,$Y); }
    1182. 

  1182. 

  1183.    /* Load a JPEG file and draw it over the chart */
    1184. 

  1184.    function drawFromJPG($X,$Y,$FileName)
    1185. 

  1185.     { $this->drawFromPicture(3,$FileName,$X,$Y); }
    1186. 

  1186. 

  1187.    function getPicInfo($FileName)
    1188. 

  1188.     {
    1189. 

  1189.      $…
    1190.

Large files files are truncated, but you can click here to view the full file