PageRenderTime 79ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/protected/components/pPie.php

https://bitbucket.org/y_widyatama/ijepa2
PHP | 1500 lines | 1137 code | 266 blank | 97 comment | 354 complexity | 0917d4f5b386c55a580cda966730e5f9 MD5 | raw file
Possible License(s): LGPL-2.1, BSD-3-Clause 
    

  1. <?php

    2. 

  2.  /*

    3. 

  3.      pPie - class to draw pie charts

    4. 

  4. 

    5. 

  5.      Version     : 2.1.3

    6. 

  6.      Made by     : Jean-Damien POGOLOTTI

    7. 

  7.      Last Update : 09/09/11

    8. 

  8. 

    9. 

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

    10. 

  10. 

    11. 

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

    12. 

  12. 

    13. 

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

    14. 

  14.  */

    15. 

  15. 

    16. 

  16.  /* Class return codes */

    17. 

  17.  define("PIE_NO_ABSCISSA"	, 140001);

    18. 

  18.  define("PIE_NO_DATASERIE"	, 140002);

    19. 

  19.  define("PIE_SUMISNULL"		, 140003);

    20. 

  20.  define("PIE_RENDERED"		, 140000);

    21. 

  21. 

    22. 

  22.  define("PIE_LABEL_COLOR_AUTO"	, 140010);

    23. 

  23.  define("PIE_LABEL_COLOR_MANUAL", 140011);

    24. 

  24. 

    25. 

  25.  define("PIE_VALUE_NATURAL"	, 140020);

    26. 

  26.  define("PIE_VALUE_PERCENTAGE"	, 140021);

    27. 

  27. 

    28. 

  28.  define("PIE_VALUE_INSIDE"      , 140030);

    29. 

  29.  define("PIE_VALUE_OUTSIDE"     , 140031);

    30. 

  30. 

    31. 

  31.  /* pPie class definition */

    32. 

  32.  class pPie

    33. 

  33.   {

    34. 

  34.    var $pChartObject;

    35. 

  35.    var $pDataObject;

    36. 

  36.    var $LabelPos = "" ;

    37. 

  37. 

    38. 

  38.    /* Class creator */

    39. 

  39.    function pPie($Object,$pDataObject)

    40. 

  40.     {

    41. 

  41.      /* Cache the pChart object reference */

    42. 

  42.      $this->pChartObject = $Object;

    43. 

  43. 

    44. 

  44.      /* Cache the pData object reference */

    45. 

  45.      $this->pDataObject  = $pDataObject;

    46. 

  46.     }

    47. 

  47. 

    48. 

  48.    /* Draw a pie chart */

    49. 

  49.    function draw2DPie($X,$Y,$Format="")

    50. 

  50.     {

    51. 

  51.      $Radius		= isset($Format["Radius"]) ? $Format["Radius"] : 60;

    52. 

  52.      $Precision		= isset($Format["Precision"]) ? $Format["Precision"] : 0;

    53. 

  53.      $DataGapAngle	= isset($Format["DataGapAngle"]) ? $Format["DataGapAngle"] : 0;

    54. 

  54.      $DataGapRadius	= isset($Format["DataGapRadius"]) ? $Format["DataGapRadius"] : 0;

    55. 

  55.      $SecondPass	= isset($Format["SecondPass"]) ? $Format["SecondPass"] : TRUE;

    56. 

  56.      $Border		= isset($Format["Border"]) ? $Format["Border"] : FALSE;

    57. 

  57.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 255;

    58. 

  58.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 255;

    59. 

  59.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 255;

    60. 

  60.      $Shadow		= isset($Format["Shadow"]) ? $Format["Shadow"] : FALSE;

    61. 

  61.      $DrawLabels	= isset($Format["DrawLabels"]) ? $Format["DrawLabels"] : FALSE;

    62. 

  62.      $LabelStacked	= isset($Format["LabelStacked"]) ? $Format["LabelStacked"] : FALSE;

    63. 

  63.      $LabelColor	= isset($Format["LabelColor"]) ? $Format["LabelColor"] : PIE_LABEL_COLOR_MANUAL;

    64. 

  64.      $LabelR		= isset($Format["LabelR"]) ? $Format["LabelR"] : 0;

    65. 

  65.      $LabelG		= isset($Format["LabelG"]) ? $Format["LabelG"] : 0;

    66. 

  66.      $LabelB		= isset($Format["LabelB"]) ? $Format["LabelB"] : 0;

    67. 

  67.      $LabelAlpha	= isset($Format["LabelAlpha"]) ? $Format["LabelAlpha"] : 100;

    68. 

  68.      $WriteValues	= isset($Format["WriteValues"]) ? $Format["WriteValues"] : NULL;

    69. 

  69.      $ValuePosition	= isset($Format["ValuePosition"]) ? $Format["ValuePosition"] : PIE_VALUE_OUTSIDE;

    70. 

  70.      $ValuePadding	= isset($Format["ValuePadding"]) ? $Format["ValuePadding"] : 15;

    71. 

  71.      $ValueSuffix	= isset($Format["ValueSuffix"]) ? $Format["ValueSuffix"] : "";

    72. 

  72.      $ValueR		= isset($Format["ValueR"]) ? $Format["ValueR"] : 255;

    73. 

  73.      $ValueG		= isset($Format["ValueG"]) ? $Format["ValueG"] : 255;

    74. 

  74.      $ValueB		= isset($Format["ValueB"]) ? $Format["ValueB"] : 255;

    75. 

  75.      $ValueAlpha	= isset($Format["ValueAlpha"]) ? $Format["ValueAlpha"] : 100;

    76. 

  76.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    77. 

  77. 

    78. 

  78.      /* Data Processing */

    79. 

  79.      $Data    = $this->pDataObject->getData();

    80. 

  80.      $Palette = $this->pDataObject->getPalette();

    81. 

  81. 

    82. 

  82.      /* Do we have an abscissa serie defined? */

    83. 

  83.      if ( $Data["Abscissa"] == "" ) { return(PIE_NO_ABSCISSA); }

    84. 

  84. 

    85. 

  85.      /* Try to find the data serie */

    86. 

  86.      $DataSerie = "";

    87. 

  87.      foreach ($Data["Series"] as $SerieName => $SerieData)

    88. 

  88.       { if ( $SerieName != $Data["Abscissa"]) { $DataSerie = $SerieName; } }

    89. 

  89. 

    90. 

  90.      /* Do we have data to compute? */

    91. 

  91.      if ( $DataSerie == "" ) { return(PIE_NO_DATASERIE); }

    92. 

  92. 

    93. 

  93.      /* Remove unused data */

    94. 

  94.      list($Data,$Palette) = $this->clean0Values($Data,$Palette,$DataSerie,$Data["Abscissa"]);

    95. 

  95. 

    96. 

  96.      /* Compute the pie sum */

    97. 

  97.      $SerieSum = $this->pDataObject->getSum($DataSerie);

    98. 

  98. 

    99. 

  99.      /* Do we have data to draw? */

    100. 

  100.      if ( $SerieSum == 0 ) { return(PIE_SUMISNULL); }

    101. 

  101. 

    102. 

  102.      /* Dump the real number of data to draw */

    103. 

  103.      $Values = "";

    104. 

  104.      foreach ($Data["Series"][$DataSerie]["Data"] as $Key => $Value)

    105. 

  105.       { if ($Value != 0) { $Values[] = $Value; } }

    106. 

  106. 

    107. 

  107.      /* Compute the wasted angular space between series */

    108. 

  108.      if (count($Values)==1) { $WastedAngular = 0; } else { $WastedAngular = count($Values) * $DataGapAngle; }

    109. 

  109. 

    110. 

  110.      /* Compute the scale */

    111. 

  111.      $ScaleFactor = (360 - $WastedAngular) / $SerieSum;

    112. 

  112. 

    113. 

  113.      $RestoreShadow = $this->pChartObject->Shadow;

    114. 

  114.      if ( $this->pChartObject->Shadow )

    115. 

  115.       {

    116. 

  116.        $this->pChartObject->Shadow = FALSE;

    117. 

  117. 

    118. 

  118.        $ShadowFormat = $Format; $ShadowFormat["Shadow"] = TRUE;

    119. 

  119.        $this->draw2DPie($X+$this->pChartObject->ShadowX,$Y+$this->pChartObject->ShadowY,$ShadowFormat);

    120. 

  120.       }

    121. 

  121. 

    122. 

  122.      /* Draw the polygon pie elements */

    123. 

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

    124. 

  124.      $Offset = 0; $ID = 0;

    125. 

  125.      foreach($Values as $Key => $Value)

    126. 

  126.       {

    127. 

  127.        if ( $Shadow )

    128. 

  128.         $Settings = array("R"=>$this->pChartObject->ShadowR,"G"=>$this->pChartObject->ShadowG,"B"=>$this->pChartObject->ShadowB,"Alpha"=>$this->pChartObject->Shadowa);

    129. 

  129.        else

    130. 

  130.         {

    131. 

  131.          if ( !isset($Palette[$ID]["R"]) ) { $Color = $this->pChartObject->getRandomColor(); $Palette[$ID] = $Color; $this->pDataObject->savePalette($ID,$Color); }

    132. 

  132.          $Settings = array("R"=>$Palette[$ID]["R"],"G"=>$Palette[$ID]["G"],"B"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);

    133. 

  133.         }

    134. 

  134. 

    135. 

  135.        if ( !$SecondPass && !$Shadow )

    136. 

  136.         {

    137. 

  137.          if ( !$Border )

    138. 

  138.           $Settings["Surrounding"] = 10;

    139. 

  139.          else

    140. 

  140.           { $Settings["BorderR"] = $BorderR; $Settings["BorderG"] = $BorderG; $Settings["BorderB"] = $BorderB; }

    141. 

  141.         }

    142. 

  142. 

    143. 

  143.        $Plots = "";

    144. 

  144.        $EndAngle = $Offset+($Value*$ScaleFactor); if ( $EndAngle > 360 ) { $EndAngle = 360; }

    145. 

  145. 

    146. 

  146.        $Angle = ($EndAngle - $Offset)/2 + $Offset;

    147. 

  147.        if ($DataGapAngle == 0)

    148. 

  148.         { $X0 = $X; $Y0 = $Y; }

    149. 

  149.        else

    150. 

  150.         {

    151. 

  151.          $X0 = cos(($Angle-90)*PI/180) * $DataGapRadius + $X;

    152. 

  152.          $Y0 = sin(($Angle-90)*PI/180) * $DataGapRadius + $Y;

    153. 

  153.         }

    154. 

  154. 

    155. 

  155.        $Plots[] = $X0; $Plots[] = $Y0;

    156. 

  156. 

    157. 

  157. 

    158. 

  158.        for($i=$Offset;$i<=$EndAngle;$i=$i+$Step)

    159. 

  159.         {

    160. 

  160.          $Xc = cos(($i-90)*PI/180) * $Radius + $X;

    161. 

  161.          $Yc = sin(($i-90)*PI/180) * $Radius + $Y;

    162. 

  162. 

    163. 

  163.          if ( $SecondPass && ( $i<90 )) { $Yc++; }

    164. 

  164.          if ( $SecondPass && ( $i>180 && $i<270 )) { $Xc++; }

    165. 

  165.          if ( $SecondPass && ( $i>=270 )) { $Xc++; $Yc++; }

    166. 

  166. 

    167. 

  167.          $Plots[] = $Xc; $Plots[] = $Yc;

    168. 

  168.         }

    169. 

  169. 

    170. 

  170.        $this->pChartObject->drawPolygon($Plots,$Settings);

    171. 

  171.        if ( $RecordImageMap && !$Shadow ) { $this->pChartObject->addToImageMap("POLY",$this->arraySerialize($Plots),$this->pChartObject->toHTMLColor($Palette[$ID]["R"],$Palette[$ID]["G"],$Palette[$ID]["B"]),$Data["Series"][$Data["Abscissa"]]["Data"][$Key],$Value); }

    172. 

  172. 

    173. 

  173.        if ( $DrawLabels && !$Shadow && !$SecondPass )

    174. 

  174.         {

    175. 

  175.          if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

    176. 

  176.           { $Settings = array("FillR"=>$Palette[$ID]["R"],"FillG"=>$Palette[$ID]["G"],"FillB"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);}

    177. 

  177.          else

    178. 

  178.           { $Settings = array("FillR"=>$LabelR,"FillG"=>$LabelG,"FillB"=>$LabelB,"Alpha"=>$LabelAlpha); }

    179. 

  179. 

    180. 

  180.          $Angle = ($EndAngle - $Offset)/2 + $Offset;

    181. 

  181.          $Xc = cos(($Angle-90)*PI/180) * $Radius + $X;

    182. 

  182.          $Yc = sin(($Angle-90)*PI/180) * $Radius + $Y;

    183. 

  183. 

    184. 

  184.          $Label = $Data["Series"][$Data["Abscissa"]]["Data"][$Key];

    185. 

  185. 

    186. 

  186.          if ( $LabelStacked )

    187. 

  187.           $this->writePieLabel($Xc,$Yc,$Label,$Angle,$Settings,TRUE,$X,$Y,$Radius);

    188. 

  188.          else

    189. 

  189.           $this->writePieLabel($Xc,$Yc,$Label,$Angle,$Settings,FALSE);

    190. 

  190.         }

    191. 

  191. 

    192. 

  192.        $Offset = $i + $DataGapAngle; $ID++;

    193. 

  193.       }

    194. 

  194. 

    195. 

  195.      /* Second pass to smooth the angles */

    196. 

  196.      if ( $SecondPass )

    197. 

  197.       {

    198. 

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

    199. 

  199.        $Offset = 0; $ID = 0;

    200. 

  200.        foreach($Values as $Key => $Value)

    201. 

  201.         {

    202. 

  202.          $FirstPoint = TRUE;

    203. 

  203.          if ( $Shadow )

    204. 

  204.           $Settings = array("R"=>$this->pChartObject->ShadowR,"G"=>$this->pChartObject->ShadowG,"B"=>$this->pChartObject->ShadowB,"Alpha"=>$this->pChartObject->Shadowa);

    205. 

  205.          else

    206. 

  206.           {

    207. 

  207.            if ( $Border )

    208. 

  208.             $Settings = array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB);

    209. 

  209.            else

    210. 

  210.             $Settings = array("R"=>$Palette[$ID]["R"],"G"=>$Palette[$ID]["G"],"B"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);

    211. 

  211.           }

    212. 

  212. 

    213. 

  213.          $EndAngle = $Offset+($Value*$ScaleFactor); if ( $EndAngle > 360 ) { $EndAngle = 360; }

    214. 

  214. 

    215. 

  215.          if ($DataGapAngle == 0)

    216. 

  216.           { $X0 = $X; $Y0 = $Y; }

    217. 

  217.          else

    218. 

  218.           {

    219. 

  219.            $Angle = ($EndAngle - $Offset)/2 + $Offset;

    220. 

  220.            $X0 = cos(($Angle-90)*PI/180) * $DataGapRadius + $X;

    221. 

  221.            $Y0 = sin(($Angle-90)*PI/180) * $DataGapRadius + $Y;

    222. 

  222.           }

    223. 

  223.          $Plots[] = $X0; $Plots[] = $Y0;

    224. 

  224. 

    225. 

  225.          for($i=$Offset;$i<=$EndAngle;$i=$i+$Step)

    226. 

  226.           {

    227. 

  227.            $Xc = cos(($i-90)*PI/180) * $Radius + $X;

    228. 

  228.            $Yc = sin(($i-90)*PI/180) * $Radius + $Y;

    229. 

  229. 

    230. 

  230.            if ( $FirstPoint ) { $this->pChartObject->drawLine($Xc,$Yc,$X0,$Y0,$Settings); } { $FirstPoint = FALSE; }

    231. 

  231.   

    232. 

  232.            $this->pChartObject->drawAntialiasPixel($Xc,$Yc,$Settings);

    233. 

  233.           }

    234. 

  234.          $this->pChartObject->drawLine($Xc,$Yc,$X0,$Y0,$Settings);

    235. 

  235. 

    236. 

  236.          if ( $DrawLabels && !$Shadow )

    237. 

  237.           {

    238. 

  238.            if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

    239. 

  239.             { $Settings = array("FillR"=>$Palette[$ID]["R"],"FillG"=>$Palette[$ID]["G"],"FillB"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);}

    240. 

  240.            else

    241. 

  241.             { $Settings = array("FillR"=>$LabelR,"FillG"=>$LabelG,"FillB"=>$LabelB,"Alpha"=>$LabelAlpha); }

    242. 

  242. 

    243. 

  243.            $Angle = ($EndAngle - $Offset)/2 + $Offset;

    244. 

  244.            $Xc = cos(($Angle-90)*PI/180) * $Radius + $X;

    245. 

  245.            $Yc = sin(($Angle-90)*PI/180) * $Radius + $Y;

    246. 

  246. 

    247. 

  247.            $Label = $Data["Series"][$Data["Abscissa"]]["Data"][$Key];

    248. 

  248. 

    249. 

  249.            if ( $LabelStacked )

    250. 

  250.             $this->writePieLabel($Xc,$Yc,$Label,$Angle,$Settings,TRUE,$X,$Y,$Radius);

    251. 

  251.            else

    252. 

  252.             $this->writePieLabel($Xc,$Yc,$Label,$Angle,$Settings,FALSE);

    253. 

  253.           }

    254. 

  254.   

    255. 

  255.          $Offset = $i + $DataGapAngle; $ID++;

    256. 

  256.         }

    257. 

  257.       }

    258. 

  258. 

    259. 

  259.      if ( $WriteValues != NULL && !$Shadow )

    260. 

  260.       {

    261. 

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

    262. 

  262.        $Offset = 0; $ID = count($Values)-1;

    263. 

  263.        $Settings = array("Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"R"=>$ValueR,"G"=>$ValueG,"B"=>$ValueB,"Alpha"=>$ValueAlpha);

    264. 

  264.        foreach($Values as $Key => $Value)

    265. 

  265.         {

    266. 

  266.          $EndAngle = ($Value*$ScaleFactor) + $Offset; if ( $EndAngle > 360 ) { $EndAngle = 0; }

    267. 

  267.          $Angle    = ($EndAngle - $Offset)/2 + $Offset;

    268. 

  268. 

    269. 

  269.          if ( $ValuePosition == PIE_VALUE_OUTSIDE )

    270. 

  270.           {

    271. 

  271.            $Xc = cos(($Angle-90)*PI/180) * ($Radius+$ValuePadding) + $X;

    272. 

  272.            $Yc = sin(($Angle-90)*PI/180) * ($Radius+$ValuePadding) + $Y;

    273. 

  273.           }

    274. 

  274.          else

    275. 

  275.           {

    276. 

  276.            $Xc = cos(($Angle-90)*PI/180) * ($Radius)/2 + $X;

    277. 

  277.            $Yc = sin(($Angle-90)*PI/180) * ($Radius)/2 + $Y;

    278. 

  278.           }

    279. 

  279. 

    280. 

  280.          if ( $WriteValues == PIE_VALUE_PERCENTAGE )

    281. 

  281.           $Display = round(( 100 / $SerieSum ) * $Value,$Precision)."%";

    282. 

  282.          elseif ( $WriteValues == PIE_VALUE_NATURAL )

    283. 

  283.           $Display = $Value.$ValueSuffix;

    284. 

  284. 

    285. 

  285.          $this->pChartObject->drawText($Xc,$Yc,$Display,$Settings);

    286. 

  286. 

    287. 

  287.          $Offset = $EndAngle + $DataGapAngle; $ID--;

    288. 

  288.         }

    289. 

  289.       }

    290. 

  290. 

    291. 

  291.      if ( $DrawLabels && $LabelStacked ) { $this->writeShiftedLabels(); }

    292. 

  292. 

    293. 

  293.      $this->pChartObject->Shadow = $RestoreShadow;

    294. 

  294. 

    295. 

  295.      return(PIE_RENDERED);

    296. 

  296.     }

    297. 

  297. 

    298. 

  298.    /* Draw a 3D pie chart */

    299. 

  299.    function draw3DPie($X,$Y,$Format="")

    300. 

  300.     {

    301. 

  301.      /* Rendering layout */

    302. 

  302.      $Radius		= isset($Format["Radius"]) ? $Format["Radius"] : 80;

    303. 

  303.      $Precision		= isset($Format["Precision"]) ? $Format["Precision"] : 0;

    304. 

  304.      $SkewFactor	= isset($Format["SkewFactor"]) ? $Format["SkewFactor"] : .5;

    305. 

  305.      $SliceHeight	= isset($Format["SliceHeight"]) ? $Format["SliceHeight"] : 20;

    306. 

  306.      $DataGapAngle	= isset($Format["DataGapAngle"]) ? $Format["DataGapAngle"] : 0;

    307. 

  307.      $DataGapRadius	= isset($Format["DataGapRadius"]) ? $Format["DataGapRadius"] : 0;

    308. 

  308.      $SecondPass	= isset($Format["SecondPass"]) ? $Format["SecondPass"] : TRUE;

    309. 

  309.      $Border		= isset($Format["Border"]) ? $Format["Border"] : FALSE;

    310. 

  310.      $Shadow		= isset($Format["Shadow"]) ? $Format["Shadow"] : FALSE;

    311. 

  311.      $DrawLabels	= isset($Format["DrawLabels"]) ? $Format["DrawLabels"] : FALSE;

    312. 

  312.      $LabelStacked	= isset($Format["LabelStacked"]) ? $Format["LabelStacked"] : FALSE;

    313. 

  313.      $LabelColor	= isset($Format["LabelColor"]) ? $Format["LabelColor"] : PIE_LABEL_COLOR_MANUAL;

    314. 

  314.      $LabelR		= isset($Format["LabelR"]) ? $Format["LabelR"] : 0;

    315. 

  315.      $LabelG		= isset($Format["LabelG"]) ? $Format["LabelG"] : 0;

    316. 

  316.      $LabelB		= isset($Format["LabelB"]) ? $Format["LabelB"] : 0;

    317. 

  317.      $LabelAlpha	= isset($Format["LabelAlpha"]) ? $Format["LabelAlpha"] : 100;

    318. 

  318.      $WriteValues	= isset($Format["WriteValues"]) ? $Format["WriteValues"] : NULL; //PIE_VALUE_PERCENTAGE

    319. 

  319.      $ValuePosition	= isset($Format["ValuePosition"]) ? $Format["ValuePosition"] : PIE_VALUE_INSIDE;

    320. 

  320.      $ValuePadding	= isset($Format["ValuePadding"]) ? $Format["ValuePadding"] : 15;

    321. 

  321.      $ValueSuffix	= isset($Format["ValueSuffix"]) ? $Format["ValueSuffix"] : "";

    322. 

  322.      $ValueR		= isset($Format["ValueR"]) ? $Format["ValueR"] : 255;

    323. 

  323.      $ValueG		= isset($Format["ValueG"]) ? $Format["ValueG"] : 255;

    324. 

  324.      $ValueB		= isset($Format["ValueB"]) ? $Format["ValueB"] : 255;

    325. 

  325.      $ValueAlpha	= isset($Format["ValueAlpha"]) ? $Format["ValueAlpha"] : 100;

    326. 

  326.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    327. 

  327. 

    328. 

  328.      /* Error correction for overlaying rounded corners */

    329. 

  329.      if ( $SkewFactor < .5 ) { $SkewFactor = .5; }

    330. 

  330. 

    331. 

  331.      /* Data Processing */

    332. 

  332.      $Data    = $this->pDataObject->getData();

    333. 

  333.      $Palette = $this->pDataObject->getPalette();

    334. 

  334. 

    335. 

  335.      /* Do we have an abscissa serie defined? */

    336. 

  336.      if ( $Data["Abscissa"] == "" ) { return(PIE_NO_ABSCISSA); }

    337. 

  337. 

    338. 

  338.      /* Try to find the data serie */

    339. 

  339.      $DataSerie = "";

    340. 

  340.      foreach ($Data["Series"] as $SerieName => $SerieData)

    341. 

  341.       { if ( $SerieName != $Data["Abscissa"]) { $DataSerie = $SerieName; } }

    342. 

  342. 

    343. 

  343.      /* Do we have data to compute? */

    344. 

  344.      if ( $DataSerie == "" ) { return(PIE_NO_DATASERIE); }

    345. 

  345. 

    346. 

  346.      /* Remove unused data */

    347. 

  347.      list($Data,$Palette) = $this->clean0Values($Data,$Palette,$DataSerie,$Data["Abscissa"]);

    348. 

  348. 

    349. 

  349.      /* Compute the pie sum */

    350. 

  350.      $SerieSum = $this->pDataObject->getSum($DataSerie);

    351. 

  351. 

    352. 

  352.      /* Do we have data to draw? */

    353. 

  353.      if ( $SerieSum == 0 ) { return(PIE_SUMISNULL); }

    354. 

  354. 

    355. 

  355.      /* Dump the real number of data to draw */

    356. 

  356.      $Values = "";

    357. 

  357.      foreach ($Data["Series"][$DataSerie]["Data"] as $Key => $Value)

    358. 

  358.       { if ($Value != 0) { $Values[] = $Value; } }

    359. 

  359. 

    360. 

  360.      /* Compute the wasted angular space between series */

    361. 

  361.      if (count($Values)==1) { $WastedAngular = 0; } else { $WastedAngular = count($Values) * $DataGapAngle; }

    362. 

  362. 

    363. 

  363.      /* Compute the scale */

    364. 

  364.      $ScaleFactor = (360 - $WastedAngular) / $SerieSum;

    365. 

  365. 

    366. 

  366.      $RestoreShadow = $this->pChartObject->Shadow;

    367. 

  367.      if ( $this->pChartObject->Shadow ) { $this->pChartObject->Shadow = FALSE; }

    368. 

  368. 

    369. 

  369.      /* Draw the polygon pie elements */

    370. 

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

    371. 

  371.      $Offset = 360; $ID = count($Values)-1;

    372. 

  372.      $Values = array_reverse($Values);

    373. 

  373.      $Slice  = 0; $Slices = ""; $SliceColors = ""; $Visible = ""; $SliceAngle = "";

    374. 

  374.      foreach($Values as $Key => $Value)

    375. 

  375.       {

    376. 

  376.        if ( !isset($Palette[$ID]["R"]) ) { $Color = $this->pChartObject->getRandomColor(); $Palette[$ID] = $Color; $this->pDataObject->savePalette($ID,$Color); }

    377. 

  377.        $Settings = array("R"=>$Palette[$ID]["R"],"G"=>$Palette[$ID]["G"],"B"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);

    378. 

  378. 

    379. 

  379.        $SliceColors[$Slice] = $Settings;

    380. 

  380. 

    381. 

  381.        $StartAngle = $Offset;

    382. 

  382.        $EndAngle   = $Offset-($Value*$ScaleFactor); if ( $EndAngle < 0 ) { $EndAngle = 0; }

    383. 

  383. 

    384. 

  384.        if ( $StartAngle > 180 ) { $Visible[$Slice]["Start"] = TRUE; } else { $Visible[$Slice]["Start"] = TRUE; }

    385. 

  385.        if ( $EndAngle < 180 )   { $Visible[$Slice]["End"] = FALSE; } else { $Visible[$Slice]["End"] = TRUE; }

    386. 

  386. 

    387. 

  387.        if ($DataGapAngle == 0)

    388. 

  388.         { $X0 = $X; $Y0 = $Y; }

    389. 

  389.        else

    390. 

  390.         {

    391. 

  391.          $Angle = ($EndAngle - $Offset)/2 + $Offset;

    392. 

  392.          $X0 = cos(($Angle-90)*PI/180) * $DataGapRadius + $X;

    393. 

  393.          $Y0 = sin(($Angle-90)*PI/180) * $DataGapRadius*$SkewFactor + $Y;

    394. 

  394.         }

    395. 

  395.        $Slices[$Slice][] = $X0; $Slices[$Slice][] = $Y0; $SliceAngle[$Slice][] = 0;

    396. 

  396. 

    397. 

  397.        for($i=$Offset;$i>=$EndAngle;$i=$i-$Step)

    398. 

  398.         {

    399. 

  399.          $Xc = cos(($i-90)*PI/180) * $Radius + $X;

    400. 

  400.          $Yc = sin(($i-90)*PI/180) * $Radius*$SkewFactor + $Y;

    401. 

  401. 

    402. 

  402.          if ( ($SecondPass || $RestoreShadow ) && ( $i<90 )) { $Yc++; }

    403. 

  403.          if ( ($SecondPass || $RestoreShadow ) && ( $i>90 && $i<180 )) { $Xc++; }

    404. 

  404.          if ( ($SecondPass || $RestoreShadow ) && ( $i>180 && $i<270 )) { $Xc++; }

    405. 

  405.          if ( ($SecondPass || $RestoreShadow ) && ( $i>=270 )) { $Xc++; $Yc++; }

    406. 

  406. 

    407. 

  407.          $Slices[$Slice][] = $Xc; $Slices[$Slice][] = $Yc; $SliceAngle[$Slice][] = $i;

    408. 

  408.         }

    409. 

  409. 

    410. 

  410.        $Offset = $i - $DataGapAngle; $ID--; $Slice++;

    411. 

  411.       }

    412. 

  412. 

    413. 

  413.      /* Draw the bottom shadow if needed */

    414. 

  414.      if ( $RestoreShadow && ($this->pChartObject->ShadowX != 0 || $this->pChartObject->ShadowY !=0 ))

    415. 

  415.       {

    416. 

  416.        foreach($Slices as $SliceID => $Plots)

    417. 

  417.         {

    418. 

  418.          $ShadowPie = "";

    419. 

  419.          for($i=0;$i<count($Plots);$i=$i+2)

    420. 

  420.           { $ShadowPie[] = $Plots[$i]+$this->pChartObject->ShadowX; $ShadowPie[] = $Plots[$i+1]+$this->pChartObject->ShadowY; }

    421. 

  421. 

    422. 

  422.          $Settings = array("R"=>$this->pChartObject->ShadowR,"G"=>$this->pChartObject->ShadowG,"B"=>$this->pChartObject->ShadowB,"Alpha"=>$this->pChartObject->Shadowa,"NoBorder"=>TRUE);

    423. 

  423.          $this->pChartObject->drawPolygon($ShadowPie,$Settings);

    424. 

  424.         }

    425. 

  425. 

    426. 

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

    427. 

  427.        $Offset = 360;

    428. 

  428.        foreach($Values as $Key => $Value)

    429. 

  429.         {

    430. 

  430.          $EndAngle = $Offset-($Value*$ScaleFactor); if ( $EndAngle < 0 ) { $EndAngle = 0; }

    431. 

  431. 

    432. 

  432.          for($i=$Offset;$i>=$EndAngle;$i=$i-$Step)

    433. 

  433.           {

    434. 

  434.            $Xc = cos(($i-90)*PI/180) * $Radius + $X + $this->pChartObject->ShadowX;

    435. 

  435.            $Yc = sin(($i-90)*PI/180) * $Radius*$SkewFactor + $Y + $this->pChartObject->ShadowY;

    436. 

  436. 

    437. 

  437.            $this->pChartObject->drawAntialiasPixel($Xc,$Yc,$Settings);

    438. 

  438.           }

    439. 

  439. 

    440. 

  440.          $Offset = $i - $DataGapAngle; $ID--;

    441. 

  441.         }

    442. 

  442.       }

    443. 

  443. 

    444. 

  444.      /* Draw the bottom pie splice */

    445. 

  445.      foreach($Slices as $SliceID => $Plots)

    446. 

  446.       {

    447. 

  447.        $Settings = $SliceColors[$SliceID];  $Settings["NoBorder"] = TRUE;

    448. 

  448.        $this->pChartObject->drawPolygon($Plots,$Settings);

    449. 

  449. 

    450. 

  450.        if ( $SecondPass )

    451. 

  451.         {

    452. 

  452.          $Settings = $SliceColors[$SliceID];

    453. 

  453.          if ( $Border )

    454. 

  454.           { $Settings["R"]+= 30; $Settings["G"]+= 30; $Settings["B"]+= 30;; }

    455. 

  455.   

    456. 

  456.          if ( isset($SliceAngle[$SliceID][1]) ) /* Empty error handling */

    457. 

  457.           {

    458. 

  458.            $Angle = $SliceAngle[$SliceID][1];

    459. 

  459.            $Xc = cos(($Angle-90)*PI/180) * $Radius + $X;

    460. 

  460.            $Yc = sin(($Angle-90)*PI/180) * $Radius*$SkewFactor + $Y;

    461. 

  461.            $this->pChartObject->drawLine($Plots[0],$Plots[1],$Xc,$Yc,$Settings);

    462. 

  462. 

    463. 

  463.            $Angle = $SliceAngle[$SliceID][count($SliceAngle[$SliceID])-1];

    464. 

  464.            $Xc = cos(($Angle-90)*PI/180) * $Radius + $X;

    465. 

  465.            $Yc = sin(($Angle-90)*PI/180) * $Radius*$SkewFactor + $Y;

    466. 

  466.            $this->pChartObject->drawLine($Plots[0],$Plots[1],$Xc,$Yc,$Settings);

    467. 

  467.           }

    468. 

  468.         }

    469. 

  469.       }

    470. 

  470. 

    471. 

  471.      /* Draw the two vertical edges */

    472. 

  472.      $Slices      = array_reverse($Slices);

    473. 

  473.      $SliceColors = array_reverse($SliceColors);

    474. 

  474.      foreach($Slices as $SliceID => $Plots)

    475. 

  475.       {

    476. 

  476.        $Settings = $SliceColors[$SliceID];

    477. 

  477.        $Settings["R"]+= 10; $Settings["G"]+= 10; $Settings["B"]+= 10; $Settings["NoBorder"] = TRUE;

    478. 

  478. 

    479. 

  479.        if ( $Visible[$SliceID]["Start"] && isset($Plots[2])) /* Empty error handling */

    480. 

  480.         {

    481. 

  481.          $this->pChartObject->drawLine($Plots[2],$Plots[3],$Plots[2],$Plots[3]- $SliceHeight,array("R"=>$Settings["R"],"G"=>$Settings["G"],"B"=>$Settings["B"]));

    482. 

  482.          $Border = "";

    483. 

  483.          $Border[] = $Plots[0]; $Border[] = $Plots[1]; $Border[] = $Plots[0]; $Border[] = $Plots[1] - $SliceHeight;

    484. 

  484.          $Border[] = $Plots[2]; $Border[] = $Plots[3] - $SliceHeight; $Border[] = $Plots[2]; $Border[] = $Plots[3]; 

    485. 

  485.          $this->pChartObject->drawPolygon($Border,$Settings);

    486. 

  486.         }

    487. 

  487.       }

    488. 

  488. 

    489. 

  489.      $Slices      = array_reverse($Slices);

    490. 

  490.      $SliceColors = array_reverse($SliceColors);

    491. 

  491.      foreach($Slices as $SliceID => $Plots)

    492. 

  492.       {

    493. 

  493.        $Settings = $SliceColors[$SliceID];

    494. 

  494.        $Settings["R"]+= 10; $Settings["G"]+= 10; $Settings["B"]+= 10; $Settings["NoBorder"] = TRUE;

    495. 

  495.        if ( $Visible[$SliceID]["End"] )

    496. 

  496.         {

    497. 

  497.          $this->pChartObject->drawLine($Plots[count($Plots)-2],$Plots[count($Plots)-1],$Plots[count($Plots)-2],$Plots[count($Plots)-1]- $SliceHeight,array("R"=>$Settings["R"],"G"=>$Settings["G"],"B"=>$Settings["B"]));

    498. 

  498. 

    499. 

  499.          $Border = "";

    500. 

  500.          $Border[] = $Plots[0]; $Border[] = $Plots[1]; $Border[] = $Plots[0]; $Border[] = $Plots[1] - $SliceHeight;

    501. 

  501.          $Border[] = $Plots[count($Plots)-2]; $Border[] = $Plots[count($Plots)-1] - $SliceHeight; $Border[] = $Plots[count($Plots)-2]; $Border[] = $Plots[count($Plots)-1]; 

    502. 

  502.          $this->pChartObject->drawPolygon($Border,$Settings);

    503. 

  503.         }

    504. 

  504.       }

    505. 

  505. 

    506. 

  506.      /* Draw the rounded edges */

    507. 

  507.      foreach($Slices as $SliceID => $Plots)

    508. 

  508.       {

    509. 

  509.        $Settings = $SliceColors[$SliceID];

    510. 

  510.        $Settings["R"]+= 10; $Settings["G"]+= 10; $Settings["B"]+= 10; $Settings["NoBorder"] = TRUE;

    511. 

  511. 

    512. 

  512.        for ($j=2;$j<count($Plots)-2;$j=$j+2)

    513. 

  513.         {

    514. 

  514.          $Angle = $SliceAngle[$SliceID][$j/2];

    515. 

  515.          if ( $Angle < 270 && $Angle > 90 )

    516. 

  516.           {

    517. 

  517.            $Border = "";

    518. 

  518.            $Border[] = $Plots[$j];   $Border[] = $Plots[$j+1];

    519. 

  519.            $Border[] = $Plots[$j+2]; $Border[] = $Plots[$j+3];

    520. 

  520.            $Border[] = $Plots[$j+2]; $Border[] = $Plots[$j+3] - $SliceHeight;

    521. 

  521.            $Border[] = $Plots[$j];   $Border[] = $Plots[$j+1] - $SliceHeight;

    522. 

  522.            $this->pChartObject->drawPolygon($Border,$Settings);

    523. 

  523.           }

    524. 

  524.         }

    525. 

  525. 

    526. 

  526.        if ( $SecondPass )

    527. 

  527.         {

    528. 

  528.          $Settings = $SliceColors[$SliceID];

    529. 

  529.          if ( $Border )

    530. 

  530.           { $Settings["R"]+= 30; $Settings["G"]+= 30; $Settings["B"]+= 30; }

    531. 

  531.   

    532. 

  532.          if ( isset($SliceAngle[$SliceID][1]) ) /* Empty error handling */

    533. 

  533.           {

    534. 

  534.            $Angle = $SliceAngle[$SliceID][1];

    535. 

  535.            if ( $Angle < 270 && $Angle > 90 )

    536. 

  536.             {

    537. 

  537.              $Xc = cos(($Angle-90)*PI/180) * $Radius + $X;

    538. 

  538.              $Yc = sin(($Angle-90)*PI/180) * $Radius*$SkewFactor + $Y;

    539. 

  539.              $this->pChartObject->drawLine($Xc,$Yc,$Xc,$Yc-$SliceHeight,$Settings);

    540. 

  540.             }

    541. 

  541.           }

    542. 

  542. 

    543. 

  543.          $Angle = $SliceAngle[$SliceID][count($SliceAngle[$SliceID])-1];

    544. 

  544.          if ( $Angle < 270 && $Angle > 90 )

    545. 

  545.           {

    546. 

  546.            $Xc = cos(($Angle-90)*PI/180) * $Radius + $X;

    547. 

  547.            $Yc = sin(($Angle-90)*PI/180) * $Radius*$SkewFactor + $Y;

    548. 

  548.            $this->pChartObject->drawLine($Xc,$Yc,$Xc,$Yc-$SliceHeight,$Settings);

    549. 

  549.           }

    550. 

  550. 

    551. 

  551.          if ( isset($SliceAngle[$SliceID][1]) && $SliceAngle[$SliceID][1] > 270 && $SliceAngle[$SliceID][count($SliceAngle[$SliceID])-1] < 270 )

    552. 

  552.           {

    553. 

  553.            $Xc = cos((270-90)*PI/180) * $Radius + $X;

    554. 

  554.            $Yc = sin((270-90)*PI/180) * $Radius*$SkewFactor + $Y;

    555. 

  555.            $this->pChartObject->drawLine($Xc,$Yc,$Xc,$Yc-$SliceHeight,$Settings);

    556. 

  556.           }

    557. 

  557. 

    558. 

  558.          if ( isset($SliceAngle[$SliceID][1]) && $SliceAngle[$SliceID][1] > 90 && $SliceAngle[$SliceID][count($SliceAngle[$SliceID])-1] < 90 )

    559. 

  559.           {

    560. 

  560.            $Xc = cos((0)*PI/180) * $Radius + $X;

    561. 

  561.            $Yc = sin((0)*PI/180) * $Radius*$SkewFactor + $Y;

    562. 

  562.            $this->pChartObject->drawLine($Xc,$Yc,$Xc,$Yc-$SliceHeight,$Settings);

    563. 

  563.           }

    564. 

  564. 

    565. 

  565.         }

    566. 

  566.       }

    567. 

  567. 

    568. 

  568.      /* Draw the top splice */

    569. 

  569.      foreach($Slices as $SliceID => $Plots)

    570. 

  570.       {

    571. 

  571.        $Settings = $SliceColors[$SliceID];

    572. 

  572.        $Settings["R"]+= 20; $Settings["G"]+= 20; $Settings["B"]+= 20;

    573. 

  573. 

    574. 

  574.        $Top = "";

    575. 

  575.        for($j=0;$j<count($Plots);$j=$j+2) { $Top[] = $Plots[$j]; $Top[] = $Plots[$j+1]- $SliceHeight; }

    576. 

  576.        $this->pChartObject->drawPolygon($Top,$Settings);

    577. 

  577. 

    578. 

  578.        if ( $RecordImageMap && !$Shadow ) { $this->pChartObject->addToImageMap("POLY",$this->arraySerialize($Top),$this->pChartObject->toHTMLColor($Settings["R"],$Settings["G"],$Settings["B"]),$Data["Series"][$Data["Abscissa"]]["Data"][count($Slices)-$SliceID-1],$Values[$SliceID]); }

    579. 

  579.       }

    580. 

  580. 

    581. 

  581. 

    582. 

  582.      /* Second pass to smooth the angles */

    583. 

  583.      if ( $SecondPass )

    584. 

  584.       {

    585. 

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

    586. 

  586.        $Offset = 360; $ID = count($Values)-1;

    587. 

  587.        foreach($Values as $Key => $Value)

    588. 

  588.         {

    589. 

  589.          $FirstPoint = TRUE;

    590. 

  590.          if ( $Shadow )

    591. 

  591.           $Settings = array("R"=>$this->pChartObject->ShadowR,"G"=>$this->pChartObject->ShadowG,"B"=>$this->pChartObject->ShadowB,"Alpha"=>$this->pChartObject->Shadowa);

    592. 

  592.          else

    593. 

  593.           {

    594. 

  594.            if ( $Border )

    595. 

  595.             { $Settings = array("R"=>$Palette[$ID]["R"]+30,"G"=>$Palette[$ID]["G"]+30,"B"=>$Palette[$ID]["B"]+30,"Alpha"=>$Palette[$ID]["Alpha"]); }

    596. 

  596.            else

    597. 

  597.             $Settings = array("R"=>$Palette[$ID]["R"],"G"=>$Palette[$ID]["G"],"B"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);

    598. 

  598.           }

    599. 

  599. 

    600. 

  600.          $EndAngle = $Offset-($Value*$ScaleFactor); if ( $EndAngle < 0 ) { $EndAngle = 0; }

    601. 

  601. 

    602. 

  602.          if ($DataGapAngle == 0)

    603. 

  603.           { $X0 = $X; $Y0 = $Y- $SliceHeight; }

    604. 

  604.          else

    605. 

  605.           {

    606. 

  606.            $Angle = ($EndAngle - $Offset)/2 + $Offset;

    607. 

  607.            $X0 = cos(($Angle-90)*PI/180) * $DataGapRadius + $X;

    608. 

  608.            $Y0 = sin(($Angle-90)*PI/180) * $DataGapRadius*$SkewFactor + $Y - $SliceHeight;

    609. 

  609.           }

    610. 

  610.          $Plots[] = $X0; $Plots[] = $Y0;

    611. 

  611. 

    612. 

  612.          for($i=$Offset;$i>=$EndAngle;$i=$i-$Step)

    613. 

  613.           {

    614. 

  614.            $Xc = cos(($i-90)*PI/180) * $Radius + $X;

    615. 

  615.            $Yc = sin(($i-90)*PI/180) * $Radius*$SkewFactor + $Y - $SliceHeight;

    616. 

  616. 

    617. 

  617.            if ( $FirstPoint ) { $this->pChartObject->drawLine($Xc,$Yc,$X0,$Y0,$Settings); } { $FirstPoint = FALSE; }

    618. 

  618.   

    619. 

  619.            $this->pChartObject->drawAntialiasPixel($Xc,$Yc,$Settings);

    620. 

  620.            if ($i < 270 && $i > 90 ) { $this->pChartObject->drawAntialiasPixel($Xc,$Yc+$SliceHeight,$Settings); }

    621. 

  621.           }

    622. 

  622.          $this->pChartObject->drawLine($Xc,$Yc,$X0,$Y0,$Settings);

    623. 

  623. 

    624. 

  624.          $Offset = $i - $DataGapAngle; $ID--;

    625. 

  625.         }

    626. 

  626.       }

    627. 

  627. 

    628. 

  628.      if ( $WriteValues != NULL )

    629. 

  629.       {

    630. 

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

    631. 

  631.        $Offset = 360; $ID = count($Values)-1;

    632. 

  632.        $Settings = array("Align"=>TEXT_ALIGN_MIDDLEMIDDLE,"R"=>$ValueR,"G"=>$ValueG,"B"=>$ValueB,"Alpha"=>$ValueAlpha);

    633. 

  633.        foreach($Values as $Key => $Value)

    634. 

  634.         {

    635. 

  635.          $EndAngle = $Offset-($Value*$ScaleFactor); if ( $EndAngle < 0 ) { $EndAngle = 0; }

    636. 

  636. 

    637. 

  637.          $Angle = ($EndAngle - $Offset)/2 + $Offset;

    638. 

  638. 

    639. 

  639.          if ( $ValuePosition == PIE_VALUE_OUTSIDE )

    640. 

  640.           {

    641. 

  641.            $Xc = cos(($Angle-90)*PI/180) * ($Radius+$ValuePadding) + $X;

    642. 

  642.            $Yc = sin(($Angle-90)*PI/180) * (($Radius*$SkewFactor)+$ValuePadding) + $Y - $SliceHeight;

    643. 

  643.           }

    644. 

  644.          else

    645. 

  645.           {

    646. 

  646.            $Xc = cos(($Angle-90)*PI/180) * ($Radius)/2 + $X;

    647. 

  647.            $Yc = sin(($Angle-90)*PI/180) * ($Radius*$SkewFactor)/2 + $Y - $SliceHeight;

    648. 

  648.           }

    649. 

  649. 

    650. 

  650.          if ( $WriteValues == PIE_VALUE_PERCENTAGE )

    651. 

  651.           $Display = round(( 100 / $SerieSum ) * $Value,$Precision)."%";

    652. 

  652.          elseif ( $WriteValues == PIE_VALUE_NATURAL )

    653. 

  653.           $Display = $Value.$ValueSuffix;

    654. 

  654. 

    655. 

  655.          $this->pChartObject->drawText($Xc,$Yc,$Display,$Settings);

    656. 

  656. 

    657. 

  657.          $Offset = $EndAngle - $DataGapAngle; $ID--;

    658. 

  658.         }

    659. 

  659.       }

    660. 

  660. 

    661. 

  661.      if ( $DrawLabels )

    662. 

  662.       {

    663. 

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

    664. 

  664.        $Offset = 360; $ID = count($Values)-1;

    665. 

  665.        foreach($Values as $Key => $Value)

    666. 

  666.         {

    667. 

  667.          if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

    668. 

  668.           { $Settings = array("FillR"=>$Palette[$ID]["R"],"FillG"=>$Palette[$ID]["G"],"FillB"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);}

    669. 

  669.          else

    670. 

  670.           { $Settings = array("FillR"=>$LabelR,"FillG"=>$LabelG,"FillB"=>$LabelB,"Alpha"=>$LabelAlpha); }

    671. 

  671. 

    672. 

  672.          $EndAngle = $Offset-($Value*$ScaleFactor); if ( $EndAngle < 0 ) { $EndAngle = 0; }

    673. 

  673. 

    674. 

  674.          $Angle = ($EndAngle - $Offset)/2 + $Offset;

    675. 

  675.          $Xc = cos(($Angle-90)*PI/180) * $Radius + $X;

    676. 

  676.          $Yc = sin(($Angle-90)*PI/180) * $Radius*$SkewFactor + $Y - $SliceHeight;

    677. 

  677. 

    678. 

  678.          if ( isset($Data["Series"][$Data["Abscissa"]]["Data"][$ID]) )

    679. 

  679.           {

    680. 

  680.            $Label = $Data["Series"][$Data["Abscissa"]]["Data"][$ID];

    681. 

  681. 

    682. 

  682.            if ( $LabelStacked )

    683. 

  683.             $this->writePieLabel($Xc,$Yc,$Label,$Angle,$Settings,TRUE,$X,$Y,$Radius,TRUE);

    684. 

  684.            else

    685. 

  685.             $this->writePieLabel($Xc,$Yc,$Label,$Angle,$Settings,FALSE);

    686. 

  686.           }

    687. 

  687. 

    688. 

  688.          $Offset = $EndAngle - $DataGapAngle; $ID--;

    689. 

  689.         }

    690. 

  690.       }

    691. 

  691. 

    692. 

  692.      if ( $DrawLabels && $LabelStacked ) { $this->writeShiftedLabels(); }

    693. 

  693. 

    694. 

  694.      $this->pChartObject->Shadow = $RestoreShadow;

    695. 

  695. 

    696. 

  696.      return(PIE_RENDERED);

    697. 

  697.     }

    698. 

  698. 

    699. 

  699.    /* Draw the legend of pie chart */

    700. 

  700.    function drawPieLegend($X,$Y,$Format="")

    701. 

  701.     {

    702. 

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

    703. 

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

    704. 

  704.      $FontR		= isset($Format["FontR"]) ? $Format["FontR"] : $this->pChartObject->FontColorR;

    705. 

  705.      $FontG		= isset($Format["FontG"]) ? $Format["FontG"] : $this->pChartObject->FontColorG;

    706. 

  706.      $FontB		= isset($Format["FontB"]) ? $Format["FontB"] : $this->pChartObject->FontColorB;

    707. 

  707.      $BoxSize		= isset($Format["BoxSize"]) ? $Format["BoxSize"] : 5;

    708. 

  708.      $Margin		= isset($Format["Margin"]) ? $Format["Margin"] : 5;

    709. 

  709.      $R			= isset($Format["R"]) ? $Format["R"] : 200;

    710. 

  710.      $G			= isset($Format["G"]) ? $Format["G"] : 200;

    711. 

  711.      $B			= isset($Format["B"]) ? $Format["B"] : 200;

    712. 

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

    713. 

  713.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 255;

    714. 

  714.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 255;

    715. 

  715.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 255;

    716. 

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

    717. 

  717.      $Style		= isset($Format["Style"]) ? $Format["Style"] : LEGEND_ROUND;

    718. 

  718.      $Mode		= isset($Format["Mode"]) ? $Format["Mode"] : LEGEND_VERTICAL;

    719. 

  719. 

    720. 

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

    721. 

  721. 

    722. 

  722.      $YStep = max($this->pChartObject->FontSize,$BoxSize) + 5;

    723. 

  723.      $XStep = $BoxSize + 5;

    724. 

  724. 

    725. 

  725.      /* Data Processing */

    726. 

  726.      $Data    = $this->pDataObject->getData();

    727. 

  727.      $Palette = $this->pDataObject->getPalette();

    728. 

  728. 

    729. 

  729.      /* Do we have an abscissa serie defined? */

    730. 

  730.      if ( $Data["Abscissa"] == "" ) { return(PIE_NO_ABSCISSA); }

    731. 

  731. 

    732. 

  732.      $Boundaries = ""; $Boundaries["L"] = $X; $Boundaries["T"] = $Y; $Boundaries["R"] = 0; $Boundaries["B"] = 0; $vY = $Y; $vX = $X;

    733. 

  733.      foreach($Data["Series"][$Data["Abscissa"]]["Data"] as $Key => $Value)

    734. 

  734.       {

    735. 

  735.        $BoxArray = $this->pChartObject->getTextBox($vX+$BoxSize+4,$vY+$BoxSize/2,$FontName,$FontSize,0,$Value);

    736. 

  736. 

    737. 

  737.        if ( $Mode == LEGEND_VERTICAL )

    738. 

  738.         {

    739. 

  739.          if ( $Boundaries["T"] > $BoxArray[2]["Y"]+$BoxSize/2 ) { $Boundaries["T"] = $BoxArray[2]["Y"]+$BoxSize/2; }

    740. 

  740.          if ( $Boundaries["R"] < $BoxArray[1]["X"]+2 ) { $Boundaries["R"] = $BoxArray[1]["X"]+2; }

    741. 

  741.          if ( $Boundaries["B"] < $BoxArray[1]["Y"]+2+$BoxSize/2 ) { $Boundaries["B"] = $BoxArray[1]["Y"]+2+$BoxSize/2; }

    742. 

  742.          $vY=$vY+$YStep;

    743. 

  743.         }

    744. 

  744.        elseif ( $Mode == LEGEND_HORIZONTAL )

    745. 

  745.         {

    746. 

  746.          if ( $Boundaries["T"] > $BoxArray[2]["Y"]+$BoxSize/2 ) { $Boundaries["T"] = $BoxArray[2]["Y"]+$BoxSize/2; }

    747. 

  747.          if ( $Boundaries["R"] < $BoxArray[1]["X"]+2 ) { $Boundaries["R"] = $BoxArray[1]["X"]+2; }

    748. 

  748.          if ( $Boundaries["B"] < $BoxArray[1]["Y"]+2+$BoxSize/2 ) { $Boundaries["B"] = $BoxArray[1]["Y"]+2+$BoxSize/2; }

    749. 

  749.          $vX=$Boundaries["R"]+$XStep;

    750. 

  750.         }

    751. 

  751.       }

    752. 

  752.      $vY=$vY-$YStep; $vX=$vX-$XStep;

    753. 

  753. 

    754. 

  754.      $TopOffset  = $Y - $Boundaries["T"];

    755. 

  755.      if ( $Boundaries["B"]-($vY+$BoxSize) < $TopOffset ) { $Boundaries["B"] = $vY+$BoxSize+$TopOffset; }

    756. 

  756. 

    757. 

  757.      if ( $Style == LEGEND_ROUND )

    758. 

  758.       $this->pChartObject->drawRoundedFilledRectangle($Boundaries["L"]-$Margin,$Boundaries["T"]-$Margin,$Boundaries["R"]+$Margin,$Boundaries["B"]+$Margin,$Margin,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB));

    759. 

  759.      elseif ( $Style == LEGEND_BOX )

    760. 

  760.       $this->pChartObject->drawFilledRectangle($Boundaries["L"]-$Margin,$Boundaries["T"]-$Margin,$Boundaries["R"]+$Margin,$Boundaries["B"]+$Margin,array("R"=>$R,"G"=>$G,"B"=>$B,"Alpha"=>$Alpha,"BorderR"=>$BorderR,"BorderG"=>$BorderG,"BorderB"=>$BorderB));

    761. 

  761. 

    762. 

  762.      $RestoreShadow = $this->pChartObject->Shadow; $this->pChartObject->Shadow = FALSE;

    763. 

  763.      foreach($Data["Series"][$Data["Abscissa"]]["Data"] as $Key => $Value)

    764. 

  764.       {

    765. 

  765.        $R = $Palette[$Key]["R"]; $G = $Palette[$Key]["G"]; $B = $Palette[$Key]["B"];

    766. 

  766. 

    767. 

  767.        $this->pChartObject->drawFilledRectangle($X+1,$Y+1,$X+$BoxSize+1,$Y+$BoxSize+1,array("R"=>0,"G"=>0,"B"=>0,"Alpha"=>20));

    768. 

  768.        $this->pChartObject->drawFilledRectangle($X,$Y,$X+$BoxSize,$Y+$BoxSize,array("R"=>$R,"G"=>$G,"B"=>$B,"Surrounding"=>20));

    769. 

  769.        if ( $Mode == LEGEND_VERTICAL )

    770. 

  770.         {

    771. 

  771.          $this->pChartObject->drawText($X+$BoxSize+4,$Y+$BoxSize/2,$Value,array("R"=>$FontR,"G"=>$FontG,"B"=>$FontB,"Align"=>TEXT_ALIGN_MIDDLELEFT,"FontName"=>$FontName,"FontSize"=>$FontSize));

    772. 

  772.          $Y=$Y+$YStep;

    773. 

  773.         }

    774. 

  774.        elseif ( $Mode == LEGEND_HORIZONTAL )

    775. 

  775.         {

    776. 

  776.          $BoxArray = $this->pChartObject->drawText($X+$BoxSize+4,$Y+$BoxSize/2,$Value,array("R"=>$FontR,"G"=>$FontG,"B"=>$FontB,"Align"=>TEXT_ALIGN_MIDDLELEFT,"FontName"=>$FontName,"FontSize"=>$FontSize));

    777. 

  777.          $X=$BoxArray[1]["X"]+2+$XStep;

    778. 

  778.         }

    779. 

  779.       }

    780. 

  780. 

    781. 

  781.      $this->Shadow = $RestoreShadow;

    782. 

  782.     }

    783. 

  783. 

    784. 

  784.    /* Set the color of the specified slice */

    785. 

  785.    function setSliceColor($SliceID,$Format="")

    786. 

  786.     {

    787. 

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

    788. 

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

    789. 

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

    790. 

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

    791. 

  791. 

    792. 

  792.      $this->pDataObject->Palette[$SliceID]["R"]     = $R;

    793. 

  793.      $this->pDataObject->Palette[$SliceID]["G"]     = $G;

    794. 

  794.      $this->pDataObject->Palette[$SliceID]["B"]     = $B;

    795. 

  795.      $this->pDataObject->Palette[$SliceID]["Alpha"] = $Alpha;

    796. 

  796.     }

    797. 

  797. 

    798. 

  798.    /* Internally used compute the label positions */

    799. 

  799.    function writePieLabel($X,$Y,$Label,$Angle,$Settings,$Stacked,$Xc=0,$Yc=0,$Radius=0,$Reversed=FALSE)

    800. 

  800.     {

    801. 

  801.      $LabelOffset	= 30;

    802. 

  802.      $FontName		= $this->pChartObject->FontName;

    803. 

  803.      $FontSize		= $this->pChartObject->FontSize;

    804. 

  804. 

    805. 

  805.      if ( !$Stacked )

    806. 

  806.       {

    807. 

  807.        $Settings["Angle"]  = 360-$Angle;

    808. 

  808.        $Settings["Length"] = 25;

    809. 

  809.        $Settings["Size"]   = 8;

    810. 

  810. 

    811. 

  811.        $this->pChartObject->drawArrowLabel($X,$Y," ".$Label." ",$Settings);

    812. 

  812.       }

    813. 

  813.      else

    814. 

  814.       {

    815. 

  815.        $X2 = cos(deg2rad($Angle-90))*20+$X;

    816. 

  816.        $Y2 = sin(deg2rad($Angle-90))*20+$Y;

    817. 

  817. 

    818. 

  818.        $TxtPos = $this->pChartObject->getTextBox($X,$Y,$FontName,$FontSize,0,$Label);

    819. 

  819.        $Height = $TxtPos[0]["Y"] - $TxtPos[2]["Y"];

    820. 

  820.        $YTop    = $Y2 - $Height/2 - 2;

    821. 

  821.        $YBottom = $Y2 + $Height/2 + 2;

    822. 

  822. 

    823. 

  823.        if ( $this->LabelPos != "" )

    824. 

  824.         {

    825. 

  825.          $Done = FALSE;

    826. 

  826.          foreach($this->LabelPos as $Key => $Settings)

    827. 

  827.           {

    828. 

  828.            if ( !$Done )

    829. 

  829.             {

    830. 

  830.              if ( $Angle <= 90 && (($YTop >= $Settings["YTop"] && $YTop <= $Settings["YBottom"]) || ($YBottom >= $Settings["YTop"] && $YBottom <= $Settings["YBottom"])))

    831. 

  831.               { $this->shift(0,180,-($Height+2),$Reversed); $Done = TRUE; }

    832. 

  832.              if ( $Angle > 90 && $Angle <= 180 && (($YTop >= $Settings["YTop"] && $YTop <= $Settings["YBottom"]) || ($YBottom >= $Settings["YTop"] && $YBottom <= $Settings["YBottom"])))

    833. 

  833.               { $this->shift(0,180,-($Height+2),$Reversed); $Done = TRUE; }

    834. 

  834.              if ( $Angle > 180 && $Angle <= 270 && (($YTop >= $Settings["YTop"] && $YTop <= $Settings["YBottom"]) || ($YBottom >= $Settings["YTop"] && $YBottom <= $Settings["YBottom"])))

    835. 

  835.               { $this->shift(180,360,($Height+2),$Reversed); $Done = TRUE; }

    836. 

  836.              if ( $Angle > 270 && $Angle <= 360 && (($YTop >= $Settings["YTop"] && $YTop <= $Settings["YBottom"]) || ($YBottom >= $Settings["YTop"] && $YBottom <= $Settings["YBottom"])))

    837. 

  837.               { $this->shift(180,360,($Height+2),$Reversed); $Done = TRUE; }

    838. 

  838.             }

    839. 

  839.           }

    840. 

  840.         }

    841. 

  841. 

    842. 

  842.        $LabelSettings = array("YTop"=>$YTop,"YBottom"=>$YBottom,"Label"=>$Label,"Angle"=>$Angle,"X1"=>$X,"Y1"=>$Y,"X2"=>$X2,"Y2"=>$Y2);

    843. 

  843.        if ( $Angle <= 180 ) { $LabelSettings["X3"] = $Xc+$Radius+$LabelOffset; }

    844. 

  844.        if ( $Angle > 180 )  { $LabelSettings["X3"] = $Xc-$Radius-$LabelOffset; }

    845. 

  845.        $this->LabelPos[] = $LabelSettings;

    846. 

  846.       }

    847. 

  847.     }

    848. 

  848. 

    849. 

  849.    /* Internally used to shift label positions */

    850. 

  850.    function shift($StartAngle,$EndAngle,$Offset,$Reversed)

    851. 

  851.     {

    852. 

  852.      if ( $Reversed ) { $Offset = -$Offset; }

    853. 

  853.      foreach($this->LabelPos as $Key => $Settings)

    854. 

  854.       {

    855. 

  855.        if ( $Settings["Angle"] > $StartAngle && $Settings["Angle"] <= $EndAngle ) { $this->LabelPos[$Key]["YTop"] = $Settings["YTop"] + $Offset; $this->LabelPos[$Key]["YBottom"] = $Settings["YBottom"] + $Offset; $this->LabelPos[$Key]["Y2"] = $Settings["Y2"] + $Offset; }

    856. 

  856.       }

    857. 

  857.     }

    858. 

  858. 

    859. 

  859.    /* Internally used to write the re-computed labels */

    860. 

  860.    function writeShiftedLabels()

    861. 

  861.     {

    862. 

  862.      if ( $this->LabelPos == "" ) { return(0); }

    863. 

  863.      foreach($this->LabelPos as $Key => $Settings)

    864. 

  864.       {

    865. 

  865.        $X1 = $Settings["X1"]; $Y1 = $Settings["Y1"];

    866. 

  866.        $X2 = $Settings["X2"]; $Y2 = $Settings["Y2"];

    867. 

  867.        $X3 = $Settings["X3"];

    868. 

  868.        $Angle = $Settings["Angle"];

    869. 

  869.        $Label = $Settings["Label"];

    870. 

  870. 

    871. 

  871.        $this->pChartObject->drawArrow($X2,$Y2,$X1,$Y1,array("Size"=>8));

    872. 

  872.        if ( $Angle <= 180 )

    873. 

  873.         {

    874. 

  874.          $this->pChartObject->drawLine($X2,$Y2,$X3,$Y2);

    875. 

  875.          $this->pChartObject->drawText($X3+2,$Y2,$Label,array("Align"=>TEXT_ALIGN_MIDDLELEFT));

    876. 

  876.         }

    877. 

  877.        else

    878. 

  878.         {

    879. 

  879.          $this->pChartObject->drawLine($X2,$Y2,$X3,$Y2);

    880. 

  880.          $this->pChartObject->drawText($X3-2,$Y2,$Label,array("Align"=>TEXT_ALIGN_MIDDLERIGHT));

    881. 

  881.         }

    882. 

  882.       }

    883. 

  883.     }

    884. 

  884. 

    885. 

  885.    /* Draw a ring chart */

    886. 

  886.    function draw2DRing($X,$Y,$Format="")

    887. 

  887.     {

    888. 

  888.      $OuterRadius	= isset($Format["Radius"]) ? $Format["Radius"] : 60;

    889. 

  889.      $Precision		= isset($Format["Precision"]) ? $Format["Precision"] : 0;

    890. 

  890.      $InnerRadius	= isset($Format["Radius"]) ? $Format["Radius"] : 30;

    891. 

  891.      $Border		= isset($Format["Border"]) ? $Format["Border"] : FALSE;

    892. 

  892.      $BorderR		= isset($Format["BorderR"]) ? $Format["BorderR"] : 255;

    893. 

  893.      $BorderG		= isset($Format["BorderG"]) ? $Format["BorderG"] : 255;

    894. 

  894.      $BorderB		= isset($Format["BorderB"]) ? $Format["BorderB"] : 255;

    895. 

  895.      $BorderAlpha	= isset($Format["BorderAlpha"]) ? $Format["BorderAlpha"] : 100;

    896. 

  896.      $Shadow		= isset($Format["Shadow"]) ? $Format["Shadow"] : FALSE;

    897. 

  897.      $DrawLabels	= isset($Format["DrawLabels"]) ? $Format["DrawLabels"] : FALSE;

    898. 

  898.      $LabelStacked	= isset($Format["LabelStacked"]) ? $Format["LabelStacked"] : FALSE;

    899. 

  899.      $LabelColor	= isset($Format["LabelColor"]) ? $Format["LabelColor"] : PIE_LABEL_COLOR_MANUAL;

    900. 

  900.      $LabelR		= isset($Format["LabelR"]) ? $Format["LabelR"] : 0;

    901. 

  901.      $LabelG		= isset($Format["LabelG"]) ? $Format["LabelG"] : 0;

    902. 

  902.      $LabelB		= isset($Format["LabelB"]) ? $Format["LabelB"] : 0;

    903. 

  903.      $LabelAlpha	= isset($Format["LabelAlpha"]) ? $Format["LabelAlpha"] : 100;

    904. 

  904.      $WriteValues	= isset($Format["WriteValues"]) ? $Format["WriteValues"] : NULL; //PIE_VALUE_PERCENTAGE

    905. 

  905.      $ValuePadding	= isset($Format["ValuePadding"]) ? $Format["ValuePadding"] : 5;

    906. 

  906.      $ValuePosition	= isset($Format["ValuePosition"]) ? $Format["ValuePosition"] : PIE_VALUE_OUTSIDE;

    907. 

  907.      $ValueSuffix	= isset($Format["ValueSuffix"]) ? $Format["ValueSuffix"] : "";

    908. 

  908.      $ValueR		= isset($Format["ValueR"]) ? $Format["ValueR"] : 255;

    909. 

  909.      $ValueG		= isset($Format["ValueG"]) ? $Format["ValueG"] : 255;

    910. 

  910.      $ValueB		= isset($Format["ValueB"]) ? $Format["ValueB"] : 255;

    911. 

  911.      $ValueAlpha	= isset($Format["ValueAlpha"]) ? $Format["ValueAlpha"] : 100;

    912. 

  912.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    913. 

  913. 

    914. 

  914.      /* Data Processing */

    915. 

  915.      $Data    = $this->pDataObject->getData();

    916. 

  916.      $Palette = $this->pDataObject->getPalette();

    917. 

  917. 

    918. 

  918.      /* Do we have an abscissa serie defined? */

    919. 

  919.      if ( $Data["Abscissa"] == "" ) { return(PIE_NO_ABSCISSA); }

    920. 

  920. 

    921. 

  921.      /* Try to find the data serie */

    922. 

  922.      $DataSerie = "";

    923. 

  923.      foreach ($Data["Series"] as $SerieName => $SerieData)

    924. 

  924.       { if ( $SerieName != $Data["Abscissa"]) { $DataSerie = $SerieName; } }

    925. 

  925. 

    926. 

  926.      /* Do we have data to compute? */

    927. 

  927.      if ( $DataSerie == "" ) { return(PIE_NO_DATASERIE); }

    928. 

  928. 

    929. 

  929.      /* Remove unused data */

    930. 

  930.      list($Data,$Palette) = $this->clean0Values($Data,$Palette,$DataSerie,$Data["Abscissa"]);

    931. 

  931. 

    932. 

  932.      /* Compute the pie sum */

    933. 

  933.      $SerieSum = $this->pDataObject->getSum($DataSerie);

    934. 

  934. 

    935. 

  935.      /* Do we have data to draw? */

    936. 

  936.      if ( $SerieSum == 0 ) { return(PIE_SUMISNULL); }

    937. 

  937. 

    938. 

  938.      /* Dump the real number of data to draw */

    939. 

  939.      $Values = "";

    940. 

  940.      foreach ($Data["Series"][$DataSerie]["Data"] as $Key => $Value)

    941. 

  941.       { if ($Value != 0) { $Values[] = $Value; } }

    942. 

  942. 

    943. 

  943.      /* Compute the wasted angular space between series */

    944. 

  944.      if (count($Values)==1) { $WastedAngular = 0; } else { $WastedAngular = 0; } // count($Values)

    945. 

  945. 

    946. 

  946.      /* Compute the scale */

    947. 

  947.      $ScaleFactor = (360 - $WastedAngular) / $SerieSum;

    948. 

  948. 

    949. 

  949.      $RestoreShadow = $this->pChartObject->Shadow;

    950. 

  950.      if ( $this->pChartObject->Shadow )

    951. 

  951.       {

    952. 

  952.        $this->pChartObject->Shadow = FALSE;

    953. 

  953. 

    954. 

  954.        $ShadowFormat = $Format; $ShadowFormat["Shadow"] = TRUE;

    955. 

  955.        $this->draw2DRing($X+$this->pChartObject->ShadowX,$Y+$this->pChartObject->ShadowY,$ShadowFormat);

    956. 

  956.       }

    957. 

  957. 

    958. 

  958.      /* Draw the polygon pie elements */

    959. 

  959.      $Step = 360 / (2 * PI * $OuterRadius);

    960. 

  960.      $Offset = 0; $ID = 0;

    961. 

  961.      foreach($Values as $Key => $Value)

    962. 

  962.       {

    963. 

  963.        if ( $Shadow )

    964. 

  964.         {

    965. 

  965.          $Settings    = array("R"=>$this->pChartObject->ShadowR,"G"=>$this->pChartObject->ShadowG,"B"=>$this->pChartObject->ShadowB,"Alpha"=>$this->pChartObject->Shadowa);

    966. 

  966.          $BorderColor = $Settings;

    967. 

  967.         }

    968. 

  968.        else

    969. 

  969.         {

    970. 

  970.          if ( !isset($Palette[$ID]["R"]) ) { $Color = $this->pChartObject->getRandomColor(); $Palette[$ID] = $Color; $this->pDataObject->savePalette($ID,$Color); }

    971. 

  971.          $Settings = array("R"=>$Palette[$ID]["R"],"G"=>$Palette[$ID]["G"],"B"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);

    972. 

  972. 

    973. 

  973.          if ( $Border )

    974. 

  974.           $BorderColor = array("R"=>$BorderR,"G"=>$BorderG,"B"=>$BorderB,"Alpha"=>$BorderAlpha);

    975. 

  975.          else

    976. 

  976.           $BorderColor = $Settings;

    977. 

  977.         }

    978. 

  978. 

    979. 

  979.        $Plots = ""; $Boundaries = ""; $AAPixels = "";

    980. 

  980.        $EndAngle = $Offset+($Value*$ScaleFactor); if ( $EndAngle > 360 ) { $EndAngle = 360; }

    981. 

  981.        for($i=$Offset;$i<=$EndAngle;$i=$i+$Step)

    982. 

  982.         {

    983. 

  983.          $Xc = cos(($i-90)*PI/180) * $OuterRadius + $X;

    984. 

  984.          $Yc = sin(($i-90)*PI/180) * $OuterRadius + $Y;

    985. 

  985. 

    986. 

  986.          if ( !isset($Boundaries[0]["X1"]) ) { $Boundaries[0]["X1"] = $Xc; $Boundaries[0]["Y1"] = $Yc; }

    987. 

  987.          $AAPixels[] = array($Xc,$Yc);

    988. 

  988. 

    989. 

  989.          if ( $i<90 ) { $Yc++; }

    990. 

  990.          if ( $i>180 && $i<270 ) { $Xc++; }

    991. 

  991.          if ( $i>=270 ) { $Xc++; $Yc++; }

    992. 

  992. 

    993. 

  993.          $Plots[] = $Xc; $Plots[] = $Yc;

    994. 

  994.         }

    995. 

  995.        $Boundaries[1]["X1"] = $Xc; $Boundaries[1]["Y1"] = $Yc;

    996. 

  996.        $Lasti = $EndAngle;

    997. 

  997. 

    998. 

  998.        for($i=$EndAngle;$i>=$Offset;$i=$i-$Step)

    999. 

  999.         {

    1000. 

  1000.          $Xc = cos(($i-90)*PI/180) * ($InnerRadius-1) + $X;

    1001. 

  1001.          $Yc = sin(($i-90)*PI/180) * ($InnerRadius-1) + $Y;

    1002. 

  1002. 

    1003. 

  1003.          if ( !isset($Boundaries[1]["X2"]) ) { $Boundaries[1]["X2"] = $Xc; $Boundaries[1]["Y2"] = $Yc; }

    1004. 

  1004.          $AAPixels[] = array($Xc,$Yc);

    1005. 

  1005. 

    1006. 

  1006.          $Xc = cos(($i-90)*PI/180) * $InnerRadius + $X;

    1007. 

  1007.          $Yc = sin(($i-90)*PI/180) * $InnerRadius + $Y;

    1008. 

  1008. 

    1009. 

  1009.          if ( $i<90 ) { $Yc++; }

    1010. 

  1010.          if ( $i>180 && $i<270 ) { $Xc++; }

    1011. 

  1011.          if ( $i>=270 ) { $Xc++; $Yc++; }

    1012. 

  1012. 

    1013. 

  1013.          $Plots[] = $Xc; $Plots[] = $Yc;

    1014. 

  1014.         }

    1015. 

  1015.        $Boundaries[0]["X2"] = $Xc; $Boundaries[0]["Y2"] = $Yc;

    1016. 

  1016. 

    1017. 

  1017.        /* Draw the polygon */

    1018. 

  1018.        $this->pChartObject->drawPolygon($Plots,$Settings);

    1019. 

  1019.        if ( $RecordImageMap && !$Shadow ) { $this->pChartObject->addToImageMap("POLY",$this->arraySerialize($Plots),$this->pChartObject->toHTMLColor($Palette[$ID]["R"],$Palette[$ID]["G"],$Palette[$ID]["B"]),$Data["Series"][$Data["Abscissa"]]["Data"][$Key],$Value); }

    1020. 

  1020. 

    1021. 

  1021.        /* Smooth the edges using AA */

    1022. 

  1022.        foreach($AAPixels as $iKey => $Pos ) { $this->pChartObject->drawAntialiasPixel($Pos[0],$Pos[1],$BorderColor); }

    1023. 

  1023.        $this->pChartObject->drawLine($Boundaries[0]["X1"],$Boundaries[0]["Y1"],$Boundaries[0]["X2"],$Boundaries[0]["Y2"],$BorderColor);

    1024. 

  1024.        $this->pChartObject->drawLine($Boundaries[1]["X1"],$Boundaries[1]["Y1"],$Boundaries[1]["X2"],$Boundaries[1]["Y2"],$BorderColor);

    1025. 

  1025. 

    1026. 

  1026.        if ( $DrawLabels && !$Shadow )

    1027. 

  1027.         {

    1028. 

  1028.          if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

    1029. 

  1029.           { $Settings = array("FillR"=>$Palette[$ID]["R"],"FillG"=>$Palette[$ID]["G"],"FillB"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);}

    1030. 

  1030.          else

    1031. 

  1031.           { $Settings = array("FillR"=>$LabelR,"FillG"=>$LabelG,"FillB"=>$LabelB,"Alpha"=>$LabelAlpha); }

    1032. 

  1032. 

    1033. 

  1033.          $Angle = ($EndAngle - $Offset)/2 + $Offset;

    1034. 

  1034.          $Xc = cos(($Angle-90)*PI/180) * $OuterRadius + $X;

    1035. 

  1035.          $Yc = sin(($Angle-90)*PI/180) * $OuterRadius + $Y;

    1036. 

  1036. 

    1037. 

  1037.          $Label = $Data["Series"][$Data["Abscissa"]]["Data"][$Key];

    1038. 

  1038. 

    1039. 

  1039.          if ( $LabelStacked )

    1040. 

  1040.           $this->writePieLabel($Xc,$Yc,$Label,$Angle,$Settings,TRUE,$X,$Y,$OuterRadius);

    1041. 

  1041.          else

    1042. 

  1042.           $this->writePieLabel($Xc,$Yc,$Label,$Angle,$Settings,FALSE);

    1043. 

  1043.         }

    1044. 

  1044. 

    1045. 

  1045.        $Offset = $Lasti; $ID++;

    1046. 

  1046.       }

    1047. 

  1047. 

    1048. 

  1048.      if ( $DrawLabels && $LabelStacked ) { $this->writeShiftedLabels(); }

    1049. 

  1049. 

    1050. 

  1050.      if ( $WriteValues && !$Shadow )

    1051. 

  1051.       {

    1052. 

  1052.        $Step = 360 / (2 * PI * $OuterRadius);

    1053. 

  1053.        $Offset = 0;

    1054. 

  1054.        foreach($Values as $Key => $Value)

    1055. 

  1055.         {

    1056. 

  1056.          $EndAngle = $Offset+($Value*$ScaleFactor);

    1057. 

  1057.          if ( $EndAngle > 360 ) { $EndAngle = 360; }

    1058. 

  1058. 

    1059. 

  1059.          $Angle = $Offset+($Value*$ScaleFactor)/2;

    1060. 

  1060.          if ( $ValuePosition == PIE_VALUE_OUTSIDE )

    1061. 

  1061.           {

    1062. 

  1062.            $Xc = cos(($Angle-90)*PI/180) * ($OuterRadius+$ValuePadding) + $X;

    1063. 

  1063.            $Yc = sin(($Angle-90)*PI/180) * ($OuterRadius+$ValuePadding) + $Y;

    1064. 

  1064.            if ( $Angle >=0 && $Angle <= 90 ) { $Align = TEXT_ALIGN_BOTTOMLEFT; }

    1065. 

  1065.            if ( $Angle > 90 && $Angle <= 180 ) { $Align = TEXT_ALIGN_TOPLEFT; }

    1066. 

  1066.            if ( $Angle > 180 && $Angle <= 270 ) { $Align = TEXT_ALIGN_TOPRIGHT; }

    1067. 

  1067.            if ( $Angle > 270 ) { $Align = TEXT_ALIGN_BOTTOMRIGHT; }

    1068. 

  1068.           }

    1069. 

  1069.          else

    1070. 

  1070.           {

    1071. 

  1071.            $Xc = cos(($Angle-90)*PI/180) * (($OuterRadius-$InnerRadius)/2+$InnerRadius) + $X;

    1072. 

  1072.            $Yc = sin(($Angle-90)*PI/180) * (($OuterRadius-$InnerRadius)/2+$InnerRadius) + $Y;

    1073. 

  1073.            $Align = TEXT_ALIGN_MIDDLEMIDDLE;

    1074. 

  1074.           }

    1075. 

  1075. 

    1076. 

  1076.          if ( $WriteValues == PIE_VALUE_PERCENTAGE )

    1077. 

  1077.           $Display = round(( 100 / $SerieSum ) * $Value,$Precision)."%";

    1078. 

  1078.          elseif ( $WriteValues == PIE_VALUE_NATURAL )

    1079. 

  1079.           $Display = $Value.$ValueSuffix;

    1080. 

  1080.          else

    1081. 

  1081.           $Label = "";

    1082. 

  1082. 

    1083. 

  1083.          $this->pChartObject->drawText($Xc,$Yc,$Display,array("Align"=>$Align,"R"=>$ValueR,"G"=>$ValueG,"B"=>$ValueB));

    1084. 

  1084.          $Offset = $EndAngle;

    1085. 

  1085.         }

    1086. 

  1086.       }

    1087. 

  1087. 

    1088. 

  1088.      $this->pChartObject->Shadow = $RestoreShadow;

    1089. 

  1089. 

    1090. 

  1090.      return(PIE_RENDERED);

    1091. 

  1091.     }

    1092. 

  1092. 

    1093. 

  1093.    /* Draw a 3D ring chart */

    1094. 

  1094.    function draw3DRing($X,$Y,$Format="")

    1095. 

  1095.     {

    1096. 

  1096.      $OuterRadius	= isset($Format["OuterRadius"]) ? $Format["OuterRadius"] : 100;

    1097. 

  1097.      $Precision		= isset($Format["Precision"]) ? $Format["Precision"] : 0;

    1098. 

  1098.      $InnerRadius	= isset($Format["InnerRadius"]) ? $Format["InnerRadius"] : 30;

    1099. 

  1099.      $SkewFactor	= isset($Format["SkewFactor"]) ? $Format["SkewFactor"] : .6;

    1100. 

  1100.      $SliceHeight	= isset($Format["SliceHeight"]) ? $Format["SliceHeight"] : 10;

    1101. 

  1101.      $DataGapAngle	= isset($Format["DataGapAngle"]) ? $Format["DataGapAngle"] : 10;

    1102. 

  1102.      $DataGapRadius	= isset($Format["DataGapRadius"]) ? $Format["DataGapRadius"] : 10;

    1103. 

  1103.      $Border		= isset($Format["Border"]) ? $Format["Border"] : FALSE;

    1104. 

  1104.      $Shadow		= isset($Format["Shadow"]) ? $Format["Shadow"] : FALSE;

    1105. 

  1105.      $DrawLabels	= isset($Format["DrawLabels"]) ? $Format["DrawLabels"] : FALSE;

    1106. 

  1106.      $LabelStacked	= isset($Format["LabelStacked"]) ? $Format["LabelStacked"] : FALSE;

    1107. 

  1107.      $LabelColor	= isset($Format["LabelColor"]) ? $Format["LabelColor"] : PIE_LABEL_COLOR_MANUAL;

    1108. 

  1108.      $LabelR		= isset($Format["LabelR"]) ? $Format["LabelR"] : 0;

    1109. 

  1109.      $LabelG		= isset($Format["LabelG"]) ? $Format["LabelG"] : 0;

    1110. 

  1110.      $LabelB		= isset($Format["LabelB"]) ? $Format["LabelB"] : 0;

    1111. 

  1111.      $LabelAlpha	= isset($Format["LabelAlpha"]) ? $Format["LabelAlpha"] : 100;

    1112. 

  1112.      $Cf		= isset($Format["Cf"]) ? $Format["Cf"] : 20;

    1113. 

  1113.      $WriteValues	= isset($Format["WriteValues"]) ? $Format["WriteValues"] : PIE_VALUE_NATURAL;

    1114. 

  1114.      $ValuePadding	= isset($Format["ValuePadding"]) ? $Format["ValuePadding"] : $SliceHeight + 15;

    1115. 

  1115.      $ValuePosition	= isset($Format["ValuePosition"]) ? $Format["ValuePosition"] : PIE_VALUE_OUTSIDE;

    1116. 

  1116.      $ValueSuffix	= isset($Format["ValueSuffix"]) ? $Format["ValueSuffix"] : "";

    1117. 

  1117.      $ValueR		= isset($Format["ValueR"]) ? $Format["ValueR"] : 255;

    1118. 

  1118.      $ValueG		= isset($Format["ValueG"]) ? $Format["ValueG"] : 255;

    1119. 

  1119.      $ValueB		= isset($Format["ValueB"]) ? $Format["ValueB"] : 255;

    1120. 

  1120.      $ValueAlpha	= isset($Format["ValueAlpha"]) ? $Format["ValueAlpha"] : 100;

    1121. 

  1121.      $RecordImageMap	= isset($Format["RecordImageMap"]) ? $Format["RecordImageMap"] : FALSE;

    1122. 

  1122. 

    1123. 

  1123.      /* Error correction for overlaying rounded corners */

    1124. 

  1124.      if ( $SkewFactor < .5 ) { $SkewFactor = .5; }

    1125. 

  1125. 

    1126. 

  1126.      /* Data Processing */

    1127. 

  1127.      $Data    = $this->pDataObject->getData();

    1128. 

  1128.      $Palette = $this->pDataObject->getPalette();

    1129. 

  1129. 

    1130. 

  1130.      /* Do we have an abscissa serie defined? */

    1131. 

  1131.      if ( $Data["Abscissa"] == "" ) { return(PIE_NO_ABSCISSA); }

    1132. 

  1132. 

    1133. 

  1133.      /* Try to find the data serie */

    1134. 

  1134.      $DataSerie = "";

    1135. 

  1135.      foreach ($Data["Series"] as $SerieName => $SerieData)

    1136. 

  1136.       { if ( $SerieName != $Data["Abscissa"]) { $DataSerie = $SerieName; } }

    1137. 

  1137. 

    1138. 

  1138.      /* Do we have data to compute? */

    1139. 

  1139.      if ( $DataSerie == "" ) { return(PIE_NO_DATASERIE); }

    1140. 

  1140. 

    1141. 

  1141.      /* Remove unused data */

    1142. 

  1142.      list($Data,$Palette) = $this->clean0Values($Data,$Palette,$DataSerie,$Data["Abscissa"]);

    1143. 

  1143. 

    1144. 

  1144.      /* Compute the pie sum */

    1145. 

  1145.      $SerieSum = $this->pDataObject->getSum($DataSerie);

    1146. 

  1146. 

    1147. 

  1147.      /* Do we have data to draw? */

    1148. 

  1148.      if ( $SerieSum == 0 ) { return(PIE_SUMISNULL); }

    1149. 

  1149. 

    1150. 

  1150.      /* Dump the real number of data to draw */

    1151. 

  1151.      $Values = "";

    1152. 

  1152.      foreach ($Data["Series"][$DataSerie]["Data"] as $Key => $Value)

    1153. 

  1153.       { if ($Value != 0) { $Values[] = $Value; } }

    1154. 

  1154. 

    1155. 

  1155.      /* Compute the wasted angular space between series */

    1156. 

  1156.      if (count($Values)==1) { $WastedAngular = 0; } else { $WastedAngular = count($Values) * $DataGapAngle; }

    1157. 

  1157. 

    1158. 

  1158.      /* Compute the scale */

    1159. 

  1159.      $ScaleFactor = (360 - $WastedAngular) / $SerieSum;

    1160. 

  1160. 

    1161. 

  1161.      $RestoreShadow = $this->pChartObject->Shadow;

    1162. 

  1162.      if ( $this->pChartObject->Shadow ) { $this->pChartObject->Shadow = FALSE; }

    1163. 

  1163. 

    1164. 

  1164.      /* Draw the polygon ring elements */

    1165. 

  1165.      $Offset = 360; $ID = count($Values)-1;

    1166. 

  1166.      $Values = array_reverse($Values);

    1167. 

  1167.      $Slice  = 0; $Slices = ""; $SliceColors = ""; $Visible = ""; $SliceAngle = "";

    1168. 

  1168.      foreach($Values as $Key => $Value)

    1169. 

  1169.       {

    1170. 

  1170.        if ( !isset($Palette[$ID]["R"]) ) { $Color = $this->pChartObject->getRandomColor(); $Palette[$ID] = $Color; $this->pDataObject->savePalette($ID,$Color); }

    1171. 

  1171.        $Settings = array("R"=>$Palette[$ID]["R"],"G"=>$Palette[$ID]["G"],"B"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);

    1172. 

  1172. 

    1173. 

  1173.        $SliceColors[$Slice] = $Settings;

    1174. 

  1174. 

    1175. 

  1175.        $StartAngle = $Offset;

    1176. 

  1176.        $EndAngle   = $Offset-($Value*$ScaleFactor); if ( $EndAngle < 0 ) { $EndAngle = 0; }

    1177. 

  1177. 

    1178. 

  1178.        if ( $StartAngle > 180 ) { $Visible[$Slice]["Start"] = TRUE; } else { $Visible[$Slice]["Start"] = TRUE; }

    1179. 

  1179.        if ( $EndAngle < 180 )   { $Visible[$Slice]["End"] = FALSE; } else { $Visible[$Slice]["End"] = TRUE; }

    1180. 

  1180. 

    1181. 

  1181.        $Step   = (360 / (2 * PI * $OuterRadius))/2;

    1182. 

  1182.        $OutX1 = VOID; $OutY1 = VOID;

    1183. 

  1183.        for($i=$Offset;$i>=$EndAngle;$i=$i-$Step)

    1184. 

  1184.         {

    1185. 

  1185.          $Xc = cos(($i-90)*PI/180) * ($OuterRadius+$DataGapRadius-2) + $X;

    1186. 

  1186.          $Yc = sin(($i-90)*PI/180) * ($OuterRadius+$DataGapRadius-2)*$SkewFactor + $Y;

    1187. 

  1187.          $Slices[$Slice]["AA"][] = array($Xc,$Yc);

    1188. 

  1188. 

    1189. 

  1189.          $Xc = cos(($i-90)*PI/180) * ($OuterRadius+$DataGapRadius-1) + $X;

    1190. 

  1190.          $Yc = sin(($i-90)*PI/180) * ($OuterRadius+$DataGapRadius-1)*$SkewFactor + $Y;

    1191. 

  1191.          $Slices[$Slice]["AA"][] = array($Xc,$Yc);

    1192. 

  1192. 

    1193. 

  1193.          $Xc = cos(($i-90)*PI/180) * ($OuterRadius+$DataGapRadius) + $X;

    1194. 

  1194.          $Yc = sin(($i-90)*PI/180) * ($OuterRadius+$DataGapRadius)*$SkewFactor + $Y;

    1195. 

  1195.          $this->pChartObject->drawAntialiasPixel($Xc,$Yc,$Settings);

    1196. 

  1196. 

    1197. 

  1197.          if ( $OutX1 == VOID ) { $OutX1 = $Xc; $OutY1 = $Yc; }

    1198. 

  1198. 

    1199. 

  1199.          if ( $i<90 ) { $Yc++; }

    1200. 

  1200.          if ( $i>90 && $i<180 ) { $Xc++; }

    1201. 

  1201.          if ( $i>180 && $i<270 ) { $Xc++; }

    1202. 

  1202.          if ( $i>=270 ) { $Xc++; $Yc++; }

    1203. 

  1203. 

    1204. 

  1204.          $Slices[$Slice]["BottomPoly"][] = floor($Xc); $Slices[$Slice]["BottomPoly"][] = floor($Yc);

    1205. 

  1205.          $Slices[$Slice]["TopPoly"][] = floor($Xc); $Slices[$Slice]["TopPoly"][] = floor($Yc)-$SliceHeight;

    1206. 

  1206.          $Slices[$Slice]["Angle"][] = $i;

    1207. 

  1207.         }

    1208. 

  1208.        $OutX2 = $Xc; $OutY2 = $Yc;

    1209. 

  1209. 

    1210. 

  1210.        $Slices[$Slice]["Angle"][] = VOID;

    1211. 

  1211.        $Lasti = $i;

    1212. 

  1212. 

    1213. 

  1213.        $Step   = (360 / (2 * PI * $InnerRadius))/2;

    1214. 

  1214.        $InX1 = VOID; $InY1 = VOID;

    1215. 

  1215.        for($i=$EndAngle;$i<=$Offset;$i=$i+$Step)

    1216. 

  1216.         {

    1217. 

  1217.          $Xc = cos(($i-90)*PI/180) * ($InnerRadius+$DataGapRadius-1) + $X;

    1218. 

  1218.          $Yc = sin(($i-90)*PI/180) * ($InnerRadius+$DataGapRadius-1)*$SkewFactor + $Y;

    1219. 

  1219.          $Slices[$Slice]["AA"][] = array($Xc,$Yc);

    1220. 

  1220. 

    1221. 

  1221.          $Xc = cos(($i-90)*PI/180) * ($InnerRadius+$DataGapRadius) + $X;

    1222. 

  1222.          $Yc = sin(($i-90)*PI/180) * ($InnerRadius+$DataGapRadius)*$SkewFactor + $Y;

    1223. 

  1223.          $Slices[$Slice]["AA"][] = array($Xc,$Yc);

    1224. 

  1224. 

    1225. 

  1225.          if ( $InX1 == VOID ) { $InX1 = $Xc; $InY1 = $Yc; }

    1226. 

  1226. 

    1227. 

  1227.          if ( $i<90 ) { $Yc++; }

    1228. 

  1228.          if ( $i>90 && $i<180 ) { $Xc++; }

    1229. 

  1229.          if ( $i>180 && $i<270 ) { $Xc++; }

    1230. 

  1230.          if ( $i>=270 ) { $Xc++; $Yc++; }

    1231. 

  1231. 

    1232. 

  1232.          $Slices[$Slice]["BottomPoly"][] = floor($Xc); $Slices[$Slice]["BottomPoly"][] = floor($Yc);

    1233. 

  1233.          $Slices[$Slice]["TopPoly"][] = floor($Xc); $Slices[$Slice]["TopPoly"][] = floor($Yc)-$SliceHeight;

    1234. 

  1234.          $Slices[$Slice]["Angle"][] = $i;

    1235. 

  1235.         }

    1236. 

  1236.        $InX2 = $Xc; $InY2 = $Yc;

    1237. 

  1237. 

    1238. 

  1238.        $Slices[$Slice]["InX1"] = $InX1;   $Slices[$Slice]["InY1"] = $InY1;

    1239. 

  1239.        $Slices[$Slice]["InX2"] = $InX2;   $Slices[$Slice]["InY2"] = $InY2;

    1240. 

  1240.        $Slices[$Slice]["OutX1"] = $OutX1; $Slices[$Slice]["OutY1"] = $OutY1;

    1241. 

  1241.        $Slices[$Slice]["OutX2"] = $OutX2; $Slices[$Slice]["OutY2"] = $OutY2;

    1242. 

  1242. 

    1243. 

  1243.        $Offset = $Lasti - $DataGapAngle; $ID--; $Slice++;

    1244. 

  1244.       }

    1245. 

  1245. 

    1246. 

  1246.      /* Draw the bottom pie splice */

    1247. 

  1247.      foreach($Slices as $SliceID => $Plots)

    1248. 

  1248.       {

    1249. 

  1249.        $Settings = $SliceColors[$SliceID];  $Settings["NoBorder"] = TRUE;

    1250. 

  1250.        $this->pChartObject->drawPolygon($Plots["BottomPoly"],$Settings);

    1251. 

  1251. 

    1252. 

  1252.        foreach($Plots["AA"] as $Key => $Pos)

    1253. 

  1253.         $this->pChartObject->drawAntialiasPixel($Pos[0],$Pos[1],$Settings);

    1254. 

  1254. 

    1255. 

  1255.        $this->pChartObject->drawLine($Plots["InX1"],$Plots["InY1"],$Plots["OutX2"],$Plots["OutY2"],$Settings);

    1256. 

  1256.        $this->pChartObject->drawLine($Plots["InX2"],$Plots["InY2"],$Plots["OutX1"],$Plots["OutY1"],$Settings);

    1257. 

  1257.       }

    1258. 

  1258. 

    1259. 

  1259.      $Slices      = array_reverse($Slices);

    1260. 

  1260.      $SliceColors = array_reverse($SliceColors);

    1261. 

  1261. 

    1262. 

  1262.      /* Draw the vertical edges (semi-visible) */

    1263. 

  1263.      foreach($Slices as $SliceID => $Plots)

    1264. 

  1264.       {

    1265. 

  1265.        $Settings = $SliceColors[$SliceID];  $Settings["NoBorder"] = TRUE;

    1266. 

  1266.        $Settings["R"] = $Settings["R"]+$Cf; $Settings["G"] = $Settings["G"]+$Cf; $Settings["B"] = $Settings["B"]+$Cf;

    1267. 

  1267. 

    1268. 

  1268.        $StartAngle = $Plots["Angle"][0];

    1269. 

  1269.        foreach($Plots["Angle"] as $Key =>$Angle) { if ($Angle == VOID) { $EndAngle = $Plots["Angle"][$Key-1]; } }

    1270. 

  1270. 

    1271. 

  1271.        if ( $StartAngle >= 270 || $StartAngle <= 90 )

    1272. 

  1272.         $this->pChartObject->drawLine($Plots["OutX1"],$Plots["OutY1"],$Plots["OutX1"],$Plots["OutY1"]-$SliceHeight,$Settings);

    1273. 

  1273.        if ( $StartAngle >= 270 || $StartAngle <= 90 )

    1274. 

  1274.         $this->pChartObject->drawLine($Plots["OutX2"],$Plots["OutY2"],$Plots["OutX2"],$Plots["OutY2"]-$SliceHeight,$Settings);

    1275. 

  1275. 

    1276. 

  1276.         $this->pChartObject->drawLine($Plots["InX1"],$Plots["InY1"],$Plots["InX1"],$Plots["InY1"]-$SliceHeight,$Settings);

    1277. 

  1277.         $this->pChartObject->drawLine($Plots["InX2"],$Plots["InY2"],$Plots["InX2"],$Plots["InY2"]-$SliceHeight,$Settings);

    1278. 

  1278.       }

    1279. 

  1279. 

    1280. 

  1280.      /* Draw the inner vertical slices */

    1281. 

  1281.      foreach($Slices as $SliceID => $Plots)

    1282. 

  1282.       {

    1283. 

  1283.        $Settings = $SliceColors[$SliceID];  $Settings["NoBorder"] = TRUE;

    1284. 

  1284.        $Settings["R"] = $Settings["R"]+$Cf; $Settings["G"] = $Settings["G"]+$Cf; $Settings["B"] = $Settings["B"]+$Cf;

    1285. 

  1285. 

    1286. 

  1286.        $Outer = TRUE; $Inner = FALSE;

    1287. 

  1287.        $InnerPlotsA = ""; $InnerPlotsB = "";

    1288. 

  1288.        foreach($Plots["Angle"] as $ID => $Angle)

    1289. 

  1289.         {

    1290. 

  1290.          if ( $Angle == VOID )

    1291. 

  1291.           { $Outer = FALSE; $Inner = TRUE; }

    1292. 

  1292.          elseif( $Inner )

    1293. 

  1293.           {

    1294. 

  1294.            if (( $Angle < 90 || $Angle > 270 ) && isset($Plots["BottomPoly"][$ID*2]) )

    1295. 

  1295.             {

    1296. 

  1296.              $Xo = $Plots["BottomPoly"][$ID*2];

    1297. 

  1297.              $Yo = $Plots["BottomPoly"][$ID*2+1];

    1298. 

  1298. 

    1299. 

  1299.              $InnerPlotsA[] = $Xo; $InnerPlotsA[] = $Yo;

    1300. 

  1300.              $InnerPlotsB[] = $Xo; $InnerPlotsB[] = $Yo-$SliceHeight;

    1301. 

  1301.             }

    1302. 

  1302.           }

    1303. 

  1303.         }

    1304. 

  1304. 

    1305. 

  1305.        if ( $InnerPlotsA != "" )

    1306. 

  1306.         { $InnerPlots = array_merge($InnerPlotsA,$this->arrayReverse($InnerPlotsB)); $this->pChartObject->drawPolygon($InnerPlots,$Settings); }

    1307. 

  1307.       }

    1308. 

  1308. 

    1309. 

  1309.      /* Draw the splice top and left poly */

    1310. 

  1310.      foreach($Slices as $SliceID => $Plots)

    1311. 

  1311.       {

    1312. 

  1312.        $Settings = $SliceColors[$SliceID];  $Settings["NoBorder"] = TRUE;

    1313. 

  1313.        $Settings["R"] = $Settings["R"]+$Cf*1.5; $Settings["G"] = $Settings["G"]+$Cf*1.5; $Settings["B"] = $Settings["B"]+$Cf*1.5;

    1314. 

  1314. 

    1315. 

  1315.        $StartAngle = $Plots["Angle"][0];

    1316. 

  1316.        foreach($Plots["Angle"] as $Key =>$Angle) { if ($Angle == VOID) { $EndAngle = $Plots["Angle"][$Key-1]; } }

    1317. 

  1317. 

    1318. 

  1318.        if ( $StartAngle < 180 )

    1319. 

  1319.         {

    1320. 

  1320.          $Points = "";

    1321. 

  1321.          $Points[] = $Plots["InX2"];

    1322. 

  1322.          $Points[] = $Plots["InY2"];

    1323. 

  1323.          $Points[] = $Plots["InX2"];

    1324. 

  1324.          $Points[] = $Plots["InY2"]-$SliceHeight;

    1325. 

  1325.          $Points[] = $Plots["OutX1"];

    1326. 

  1326.          $Points[] = $Plots["OutY1"]-$SliceHeight;

    1327. 

  1327.          $Points[] = $Plots["OutX1"];

    1328. 

  1328.          $Points[] = $Plots["OutY1"];

    1329. 

  1329. 

    1330. 

  1330.          $this->pChartObject->drawPolygon($Points,$Settings);

    1331. 

  1331.         }

    1332. 

  1332. 

    1333. 

  1333.        if ( $EndAngle > 180 )

    1334. 

  1334.         {

    1335. 

  1335.          $Points = "";

    1336. 

  1336.          $Points[] = $Plots["InX1"];

    1337. 

  1337.          $Points[] = $Plots["InY1"];

    1338. 

  1338.          $Points[] = $Plots["InX1"];

    1339. 

  1339.          $Points[] = $Plots["InY1"]-$SliceHeight;

    1340. 

  1340.          $Points[] = $Plots["OutX2"];

    1341. 

  1341.          $Points[] = $Plots["OutY2"]-$SliceHeight;

    1342. 

  1342.          $Points[] = $Plots["OutX2"];

    1343. 

  1343.          $Points[] = $Plots["OutY2"];

    1344. 

  1344. 

    1345. 

  1345.          $this->pChartObject->drawPolygon($Points,$Settings);

    1346. 

  1346.         }

    1347. 

  1347.       }

    1348. 

  1348. 

    1349. 

  1349. 

    1350. 

  1350.      /* Draw the vertical edges (visible) */

    1351. 

  1351.      foreach($Slices as $SliceID => $Plots)

    1352. 

  1352.       {

    1353. 

  1353.        $Settings = $SliceColors[$SliceID];  $Settings["NoBorder"] = TRUE;

    1354. 

  1354.        $Settings["R"] = $Settings["R"]+$Cf; $Settings["G"] = $Settings["G"]+$Cf; $Settings["B"] = $Settings["B"]+$Cf;

    1355. 

  1355. 

    1356. 

  1356.        $StartAngle = $Plots["Angle"][0];

    1357. 

  1357.        foreach($Plots["Angle"] as $Key =>$Angle) { if ($Angle == VOID) { $EndAngle = $Plots["Angle"][$Key-1]; } }

    1358. 

  1358. 

    1359. 

  1359.        if ( $StartAngle <= 270 && $StartAngle >= 90 )

    1360. 

  1360.         $this->pChartObject->drawLine($Plots["OutX1"],$Plots["OutY1"],$Plots["OutX1"],$Plots["OutY1"]-$SliceHeight,$Settings);

    1361. 

  1361.        if ( $EndAngle <= 270 && $EndAngle >= 90 )

    1362. 

  1362.         $this->pChartObject->drawLine($Plots["OutX2"],$Plots["OutY2"],$Plots["OutX2"],$Plots["OutY2"]-$SliceHeight,$Settings);

    1363. 

  1363.       }

    1364. 

  1364. 

    1365. 

  1365. 

    1366. 

  1366.      /* Draw the outer vertical slices */

    1367. 

  1367.      foreach($Slices as $SliceID => $Plots)

    1368. 

  1368.       {

    1369. 

  1369.        $Settings = $SliceColors[$SliceID];  $Settings["NoBorder"] = TRUE;

    1370. 

  1370.        $Settings["R"] = $Settings["R"]+$Cf; $Settings["G"] = $Settings["G"]+$Cf; $Settings["B"] = $Settings["B"]+$Cf;

    1371. 

  1371. 

    1372. 

  1372.        $Outer = TRUE; $Inner = FALSE;

    1373. 

  1373.        $OuterPlotsA = ""; $OuterPlotsB = ""; $InnerPlotsA = ""; $InnerPlotsB = "";

    1374. 

  1374.        foreach($Plots["Angle"] as $ID => $Angle)

    1375. 

  1375.         {

    1376. 

  1376.          if ( $Angle == VOID )

    1377. 

  1377.           { $Outer = FALSE; $Inner = TRUE; }

    1378. 

  1378.          elseif( $Outer )

    1379. 

  1379.           {

    1380. 

  1380.            if ( ( $Angle > 90 && $Angle < 270 ) && isset($Plots["BottomPoly"][$ID*2]) )

    1381. 

  1381.             {

    1382. 

  1382.              $Xo = $Plots["BottomPoly"][$ID*2];

    1383. 

  1383.              $Yo = $Plots["BottomPoly"][$ID*2+1];

    1384. 

  1384. 

    1385. 

  1385.              $OuterPlotsA[] = $Xo; $OuterPlotsA[] = $Yo;

    1386. 

  1386.              $OuterPlotsB[] = $Xo; $OuterPlotsB[] = $Yo-$SliceHeight;

    1387. 

  1387.             }

    1388. 

  1388.           }

    1389. 

  1389.         }

    1390. 

  1390.        if ( $OuterPlotsA != "" )

    1391. 

  1391.         { $OuterPlots = array_merge($OuterPlotsA,$this->arrayReverse($OuterPlotsB)); $this->pChartObject->drawPolygon($OuterPlots,$Settings); }

    1392. 

  1392.       }

    1393. 

  1393. 

    1394. 

  1394.      $Slices      = array_reverse($Slices);

    1395. 

  1395.      $SliceColors = array_reverse($SliceColors);

    1396. 

  1396. 

    1397. 

  1397. 

    1398. 

  1398.      /* Draw the top pie splice */

    1399. 

  1399.      foreach($Slices as $SliceID => $Plots)

    1400. 

  1400.       {

    1401. 

  1401.        $Settings = $SliceColors[$SliceID];  $Settings["NoBorder"] = TRUE;

    1402. 

  1402.        $Settings["R"] = $Settings["R"]+$Cf*2; $Settings["G"] = $Settings["G"]+$Cf*2; $Settings["B"] = $Settings["B"]+$Cf*2;

    1403. 

  1403.  

    1404. 

  1404.        $this->pChartObject->drawPolygon($Plots["TopPoly"],$Settings);

    1405. 

  1405. 

    1406. 

  1406.        if ( $RecordImageMap ) { $this->pChartObject->addToImageMap("POLY",$this->arraySerialize($Plots["TopPoly"]),$this->pChartObject->toHTMLColor($Settings["R"],$Settings["G"],$Settings["B"]),$Data["Series"][$Data["Abscissa"]]["Data"][$SliceID],$Data["Series"][$DataSerie]["Data"][count($Slices)-$SliceID-1]); }

    1407. 

  1407. 

    1408. 

  1408.        foreach($Plots["AA"] as $Key => $Pos)

    1409. 

  1409.         $this->pChartObject->drawAntialiasPixel($Pos[0],$Pos[1]-$SliceHeight,$Settings);

    1410. 

  1410. 

    1411. 

  1411.        $this->pChartObject->drawLine($Plots["InX1"],$Plots["InY1"]-$SliceHeight,$Plots["OutX2"],$Plots["OutY2"]-$SliceHeight,$Settings);

    1412. 

  1412.        $this->pChartObject->drawLine($Plots["InX2"],$Plots["InY2"]-$SliceHeight,$Plots["OutX1"],$Plots["OutY1"]-$SliceHeight,$Settings);

    1413. 

  1413.       }

    1414. 

  1414. 

    1415. 

  1415.      if ( $DrawLabels )

    1416. 

  1416.       {

    1417. 

  1417.        $Offset = 360;

    1418. 

  1418.        foreach($Values as $Key => $Value)

    1419. 

  1419.         {

    1420. 

  1420.          $StartAngle = $Offset;

    1421. 

  1421.          $EndAngle   = $Offset-($Value*$ScaleFactor); if ( $EndAngle < 0 ) { $EndAngle = 0; }

    1422. 

  1422. 

    1423. 

  1423.          if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

    1424. 

  1424.           { $Settings = array("FillR"=>$Palette[$ID]["R"],"FillG"=>$Palette[$ID]["G"],"FillB"=>$Palette[$ID]["B"],"Alpha"=>$Palette[$ID]["Alpha"]);}

    1425. 

  1425.          else

    1426. 

  1426.           { $Settings = array("FillR"=>$LabelR,"FillG"=>$LabelG,"FillB"=>$LabelB,"Alpha"=>$LabelAlpha); }

    1427. 

  1427. 

    1428. 

  1428.          $Angle = ($EndAngle - $Offset)/2 + $Offset;

    1429. 

  1429.          $Xc = cos(($Angle-90)*PI/180) * ($OuterRadius+$DataGapRadius) + $X;

    1430. 

  1430.          $Yc = sin(($Angle-90)*PI/180) * ($OuterRadius+$DataGapRadius)*$SkewFactor + $Y;

    1431. 

  1431. 

    1432. 

  1432.          if ( $WriteValues == PIE_VALUE_PERCENTAGE )

    1433. 

  1433.           $Label = $Display = round(( 100 / $SerieSum ) * $Value,$Precision)."%";

    1434. 

  1434.          elseif ( $WriteValues == PIE_VALUE_NATURAL )

    1435. 

  1435.           $Label = $Data["Series"][$Data["Abscissa"]]["Data"][$Key];

    1436. 

  1436.          else

    1437. 

  1437.           $Label = "";

    1438. 

  1438. 

    1439. 

  1439.          if ( $LabelStacked )

    1440. 

  1440.           $this->writePieLabel($Xc,$Yc-$SliceHeight,$Label,$Angle,$Settings,TRUE,$X,$Y,$OuterRadius);

    1441. 

  1441.          else

    1442. 

  1442.           $this->writePieLabel($Xc,$Yc-$SliceHeight,$Label,$Angle,$Settings,FALSE);

    1443. 

  1443. 

    1444. 

  1444.          $Offset = $EndAngle - $DataGapAngle; $ID--; $Slice++;

    1445. 

  1445.         }

    1446. 

  1446.       }

    1447. 

  1447.      if ( $DrawLabels && $LabelStacked ) { $this->writeShiftedLabels(); }

    1448. 

  1448. 

    1449. 

  1449.      $this->pChartObject->Shadow = $RestoreShadow;

    1450. 

  1450. 

    1451. 

  1451.      return(PIE_RENDERED);

    1452. 

  1452.     }

    1453. 

  1453. 

    1454. 

  1454.   /* Serialize an array */

    1455. 

  1455.   function arraySerialize($Data)

    1456. 

  1456.    {

    1457. 

  1457.     $Result = "";

    1458. 

  1458.     foreach($Data as $Key => $Value)

    1459. 

  1459.      { if ($Result == "") { $Result = floor($Value); } else { $Result = $Result.",".floor($Value); } }

    1460. 

  1460. 

    1461. 

  1461.     return($Result);

    1462. 

  1462.    }

    1463. 

  1463. 

    1464. 

  1464.   /* Reverse an array */

    1465. 

  1465.   function arrayReverse($Plots)

    1466. 

  1466.    {

    1467. 

  1467.     $Result = "";

    1468. 

  1468. 

    1469. 

  1469.     for($i=count($Plots)-1;$i>=0;$i=$i-2)

    1470. 

  1470.      { $Result[] = $Plots[$i-1]; $Result[] = $Plots[$i]; }

    1471. 

  1471. 

    1472. 

  1472.     return($Result);

    1473. 

  1473.    }

    1474. 

  1474. 

    1475. 

  1475.   /* Remove unused series & values */

    1476. 

  1476.   function clean0Values($Data,$Palette,$DataSerie,$AbscissaSerie)

    1477. 

  1477.    {

    1478. 

  1478.     $NewPalette = ""; $NewData = ""; $NewAbscissa = "";

    1479. 

  1479. 

    1480. 

  1480.     /* Remove unused series */

    1481. 

  1481.     foreach($Data["Series"] as $SerieName => $SerieSettings)

    1482. 

  1482.      { if ( $SerieName != $DataSerie && $SerieName != $AbscissaSerie ) { unset($Data["Series"][$SerieName]); } }

    1483. 

  1483. 

    1484. 

  1484.     /* Remove NULL values */

    1485. 

  1485.     foreach($Data["Series"][$DataSerie]["Data"] as $Key => $Value)

    1486. 

  1486.      {

    1487. 

  1487.       if ($Value != 0 )

    1488. 

  1488.        {

    1489. 

  1489.         $NewData[]     = $Value;

    1490. 

  1490.         $NewAbscissa[] = $Data["Series"][$AbscissaSerie]["Data"][$Key];

    1491. 

  1491.         if ( isset($Palette[$Key]) ) { $NewPalette[]  = $Palette[$Key]; }

    1492. 

  1492.        }

    1493. 

  1493.      }

    1494. 

  1494.     $Data["Series"][$DataSerie]["Data"]     = $NewData;

    1495. 

  1495.     $Data["Series"][$AbscissaSerie]["Data"] = $NewAbscissa;

    1496. 

  1496. 

    1497. 

  1497.     return(array($Data,$NewPalette));

    1498. 

  1498.    }

    1499. 

  1499.   }

    1500. 

  1500. ?>
    1501.