pPie.class.php

File

inc/pchart/pchart/class/pPie.class.php
View source
  1.  /*

  2.      pPie - class to draw pie charts

  3. 

  4.      Version     : 2.1.4

  5.      Made by     : Jean-Damien POGOLOTTI

  6.      Last Update : 19/01/2014

  7. 

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

  9. 

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

  11. 

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

  13.  */

  14. 

  15.  /* Class return codes */

  16.  define("PIE_NO_ABSCISSA"	, 140001);

  17.  define("PIE_NO_DATASERIE"	, 140002);

  18.  define("PIE_SUMISNULL"		, 140003);

  19.  define("PIE_RENDERED"		, 140000);

  20. 

  21.  define("PIE_LABEL_COLOR_AUTO"	, 140010);

  22.  define("PIE_LABEL_COLOR_MANUAL", 140011);

  23. 

  24.  define("PIE_VALUE_NATURAL"	, 140020);

  25.  define("PIE_VALUE_PERCENTAGE"	, 140021);

  26. 

  27.  define("PIE_VALUE_INSIDE"      , 140030);

  28.  define("PIE_VALUE_OUTSIDE"     , 140031);

  29. 

  30.  /* pPie class definition */

  31.  class pPie

  32.   {

  33.    var $pChartObject = array();

  34.    var $pDataObject = array();

  35.    var $LabelPos = "" ;

  36. 

  37.    /* Class creator */

  38.    function pPie($Object,$pDataObject)

  39.     {

  40.      /* Cache the pChart object reference */

  41.      $this->pChartObject = $Object;

  42. 

  43.      /* Cache the pData object reference */

  44.      $this->pDataObject  = $pDataObject;

  45.     }

  46. 

  47.    /* Draw a pie chart */

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

  49.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  76. 

  77.      /* Data Processing */

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

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

  80. 

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

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

  83. 

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

  85.      $DataSerie = "";

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

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

  88. 

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

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

  91. 

  92.      /* Remove unused data */

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

  94. 

  95.      /* Compute the pie sum */

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

  97. 

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

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

  100. 

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

  102.      $Values = array();

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

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

  105. 

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

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

  108. 

  109.      /* Compute the scale */

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

  111. 

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

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

  114.       {

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

  116. 

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

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

  119.       }

  120. 

  121.      /* Draw the polygon pie elements */

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

  123.      $Offset = 0; $ID = 0;

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

  125.       {

  126.        if ( $Shadow )

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

  128.        else

  129.         {

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

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

  132.         }

  133. 

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

  135.         {

  136.          if ( !$Border )

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

  138.          else

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

  140.         }

  141. 

  142.        $Plots = array();

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

  144. 

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

  146.        if ($DataGapAngle == 0)

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

  148.        else

  149.         {

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

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

  152.         }

  153. 

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

  155. 

  156. 

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

  158.         {

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

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

  161. 

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

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

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

  165. 

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

  167.         }

  168. 

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

  170.        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); }

  171. 

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

  173.         {

  174.          if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

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

  176.          else

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

  178. 

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

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

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

  182. 

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

  184. 

  185.          if ( $LabelStacked )

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

  187.          else

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

  189.         }

  190. 

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

  192.       }

  193. 

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

  195.      if ( $SecondPass )

  196.       {

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

  198.        $Offset = 0; $ID = 0;

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

  200.         {

  201.          $FirstPoint = TRUE;

  202.          if ( $Shadow )

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

  204.          else

  205.           {

  206.            if ( $Border )

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

  208.            else

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

  210.           }

  211. 

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

  213. 

  214.          if ($DataGapAngle == 0)

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

  216.          else

  217.           {

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

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

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

  221.           }

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

  223. 

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

  225.           {

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

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

  228. 

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

  230.   

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

  232.           }

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

  234. 

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

  236.           {

  237.            if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

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

  239.            else

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

  241. 

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

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

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

  245. 

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

  247. 

  248.            if ( $LabelStacked )

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

  250.            else

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

  252.           }

  253.   

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

  255.         }

  256.       }

  257. 

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

  259.       {

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

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

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

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

  264.         {

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

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

  267. 

  268.          if ( $ValuePosition == PIE_VALUE_OUTSIDE )

  269.           {

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

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

  272.           }

  273.          else

  274.           {

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

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

  277.           }

  278. 

  279.          if ( $WriteValues == PIE_VALUE_PERCENTAGE )

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

  281.          elseif ( $WriteValues == PIE_VALUE_NATURAL )

  282.           $Display = $Value.$ValueSuffix;

  283. 

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

  285. 

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

  287.         }

  288.       }

  289. 

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

  291. 

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

  293. 

  294.      return(PIE_RENDERED);

  295.     }

  296. 

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

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

  299.     {

  300.      /* Rendering layout */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  326. 

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

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

  329. 

  330.      /* Data Processing */

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

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

  333. 

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

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

  336. 

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

  338.      $DataSerie = "";

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

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

  341. 

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

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

  344. 

  345.      /* Remove unused data */

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

  347. 

  348.      /* Compute the pie sum */

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

  350. 

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

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

  353. 

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

  355.      $Values = array();

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

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

  358. 

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

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

  361. 

  362.      /* Compute the scale */

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

  364. 

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

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

  367. 

  368.      /* Draw the polygon pie elements */

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

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

  371.      $Values = array_reverse($Values);

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

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

  374.       {

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

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

  377. 

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

  379. 

  380.        $StartAngle = $Offset;

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

  382. 

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

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

  385. 

  386.        if ($DataGapAngle == 0)

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

  388.        else

  389.         {

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

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

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

  393.         }

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

  395. 

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

  397.         {

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

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

  400. 

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

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

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

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

  405. 

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

  407.         }

  408. 

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

  410.       }

  411. 

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

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

  414.       {

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

  416.         {

  417.          $ShadowPie = array();

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

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

  420. 

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

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

  423.         }

  424. 

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

  426.        $Offset = 360;

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

  428.         {

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

  430. 

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

  432.           {

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

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

  435. 

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

  437.           }

  438. 

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

  440.         }

  441.       }

  442. 

  443.      /* Draw the bottom pie splice */

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

  445.       {

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

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

  448. 

  449.        if ( $SecondPass )

  450.         {

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

  452.          if ( $Border )

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

  454.   

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

  456.           {

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

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

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

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

  461. 

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

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

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

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

  466.           }

  467.         }

  468.       }

  469. 

  470.      /* Draw the two vertical edges */

  471.      $Slices      = array_reverse($Slices);

  472.      $SliceColors = array_reverse($SliceColors);

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

  474.       {

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

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

  477. 

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

  479.         {

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

  481.          $Border = array();

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

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

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

  485.         }

  486.       }

  487. 

  488.      $Slices      = array_reverse($Slices);

  489.      $SliceColors = array_reverse($SliceColors);

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

  491.       {

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

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

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

  495.         {

  496.          $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"]));

  497. 

  498.          $Border = array();

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

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

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

  502.         }

  503.       }

  504. 

  505.      /* Draw the rounded edges */

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

  507.       {

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

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

  510. 

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

  512.         {

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

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

  515.           {

  516.            $Border = array();

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

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

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

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

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

  522.           }

  523.         }

  524. 

  525.        if ( $SecondPass )

  526.         {

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

  528.          if ( $Border )

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

  530.   

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

  532.           {

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

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

  535.             {

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

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

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

  539.             }

  540.           }

  541. 

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

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

  544.           {

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

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

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

  548.           }

  549. 

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

  551.           {

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

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

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

  555.           }

  556. 

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

  558.           {

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

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

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

  562.           }

  563. 

  564.         }

  565.       }

  566. 

  567.      /* Draw the top splice */

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

  569.       {

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

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

  572. 

  573.        $Top = array();

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

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

  576. 

  577.        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]); }

  578.       }

  579. 

  580. 

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

  582.      if ( $SecondPass )

  583.       {

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

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

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

  587.         {

  588.          $FirstPoint = TRUE;

  589.          if ( $Shadow )

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

  591.          else

  592.           {

  593.            if ( $Border )

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

  595.            else

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

  597.           }

  598. 

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

  600. 

  601.          if ($DataGapAngle == 0)

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

  603.          else

  604.           {

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

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

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

  608.           }

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

  610. 

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

  612.           {

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

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

  615. 

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

  617.   

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

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

  620.           }

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

  622. 

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

  624.         }

  625.       }

  626. 

  627.      if ( $WriteValues != NULL )

  628.       {

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

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

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

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

  633.         {

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

  635. 

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

  637. 

  638.          if ( $ValuePosition == PIE_VALUE_OUTSIDE )

  639.           {

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

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

  642.           }

  643.          else

  644.           {

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

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

  647.           }

  648. 

  649.          if ( $WriteValues == PIE_VALUE_PERCENTAGE )

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

  651.          elseif ( $WriteValues == PIE_VALUE_NATURAL )

  652.           $Display = $Value.$ValueSuffix;

  653. 

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

  655. 

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

  657.         }

  658.       }

  659. 

  660.      if ( $DrawLabels )

  661.       {

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

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

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

  665.         {

  666.          if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

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

  668.          else

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

  670. 

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

  672. 

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

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

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

  676. 

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

  678.           {

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

  680. 

  681.            if ( $LabelStacked )

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

  683.            else

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

  685.           }

  686. 

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

  688.         }

  689.       }

  690. 

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

  692. 

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

  694. 

  695.      return(PIE_RENDERED);

  696.     }

  697. 

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

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

  700.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  718. 

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

  720. 

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

  722.      $XStep = $BoxSize + 5;

  723. 

  724.      /* Data Processing */

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

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

  727. 

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

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

  730. 

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

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

  733.       {

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

  735. 

  736.        if ( $Mode == LEGEND_VERTICAL )

  737.         {

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

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

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

  741.          $vY=$vY+$YStep;

  742.         }

  743.        elseif ( $Mode == LEGEND_HORIZONTAL )

  744.         {

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

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

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

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

  749.         }

  750.       }

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

  752. 

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

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

  755. 

  756.      if ( $Style == LEGEND_ROUND )

  757.       $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));

  758.      elseif ( $Style == LEGEND_BOX )

  759.       $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));

  760. 

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

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

  763.       {

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

  765. 

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

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

  768.        if ( $Mode == LEGEND_VERTICAL )

  769.         {

  770.          $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));

  771.          $Y=$Y+$YStep;

  772.         }

  773.        elseif ( $Mode == LEGEND_HORIZONTAL )

  774.         {

  775.          $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));

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

  777.         }

  778.       }

  779. 

  780.      $this->Shadow = $RestoreShadow;

  781.     }

  782. 

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

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

  785.     {

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

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

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

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

  790. 

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

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

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

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

  795.     }

  796. 

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

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

  799.     {

  800.      $LabelOffset	= 30;

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

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

  803. 

  804.      if ( !$Stacked )

  805.       {

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

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

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

  809. 

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

  811.       }

  812.      else

  813.       {

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

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

  816. 

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

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

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

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

  821. 

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

  823.         {

  824.          $Done = FALSE;

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

  826.           {

  827.            if ( !$Done )

  828.             {

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

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

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

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

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

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

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

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

  837.             }

  838.           }

  839.         }

  840. 

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

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

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

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

  845.       }

  846.     }

  847. 

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

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

  850.     {

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

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

  853.       {

  854.        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; }

  855.       }

  856.     }

  857. 

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

  859.    function writeShiftedLabels()

  860.     {

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

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

  863.       {

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

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

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

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

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

  869. 

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

  871.        if ( $Angle <= 180 )

  872.         {

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

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

  875.         }

  876.        else

  877.         {

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

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

  880.         }

  881.       }

  882.     }

  883. 

  884.    /* Draw a ring chart */

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

  886.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  912. 

  913.      /* Data Processing */

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

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

  916. 

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

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

  919. 

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

  921.      $DataSerie = "";

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

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

  924. 

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

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

  927. 

  928.      /* Remove unused data */

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

  930. 

  931.      /* Compute the pie sum */

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

  933. 

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

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

  936. 

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

  938.      $Values = array();

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

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

  941. 

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

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

  944. 

  945.      /* Compute the scale */

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

  947. 

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

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

  950.       {

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

  952. 

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

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

  955.       }

  956. 

  957.      /* Draw the polygon pie elements */

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

  959.      $Offset = 0; $ID = 0;

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

  961.       {

  962.        if ( $Shadow )

  963.         {

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

  965.          $BorderColor = $Settings;

  966.         }

  967.        else

  968.         {

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

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

  971. 

  972.          if ( $Border )

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

  974.          else

  975.           $BorderColor = $Settings;

  976.         }

  977. 

  978.        $Plots = array(); $Boundaries = array(); $AAPixels = array();

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

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

  981.         {

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

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

  984. 

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

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

  987. 

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

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

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

  991. 

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

  993.         }

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

  995.        $Lasti = $EndAngle;

  996. 

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

  998.         {

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

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

  1001. 

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

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

  1004. 

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

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

  1007. 

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

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

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

  1011. 

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

  1013.         }

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

  1015. 

  1016.        /* Draw the polygon */

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

  1018.        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); }

  1019. 

  1020.        /* Smooth the edges using AA */

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

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

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

  1024. 

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

  1026.         {

  1027.          if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

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

  1029.          else

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

  1031. 

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

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

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

  1035. 

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

  1037. 

  1038.          if ( $LabelStacked )

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

  1040.          else

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

  1042.         }

  1043. 

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

  1045.       }

  1046. 

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

  1048. 

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

  1050.       {

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

  1052.        $Offset = 0;

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

  1054.         {

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

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

  1057. 

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

  1059.          if ( $ValuePosition == PIE_VALUE_OUTSIDE )

  1060.           {

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

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

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

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

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

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

  1067.           }

  1068.          else

  1069.           {

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

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

  1072.            $Align = TEXT_ALIGN_MIDDLEMIDDLE;

  1073.           }

  1074. 

  1075.          if ( $WriteValues == PIE_VALUE_PERCENTAGE )

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

  1077.          elseif ( $WriteValues == PIE_VALUE_NATURAL )

  1078.           $Display = $Value.$ValueSuffix;

  1079.          else

  1080.           $Label = "";

  1081. 

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

  1083.          $Offset = $EndAngle;

  1084.         }

  1085.       }

  1086. 

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

  1088. 

  1089.      return(PIE_RENDERED);

  1090.     }

  1091. 

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

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

  1094.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  1121. 

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

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

  1124. 

  1125.      /* Data Processing */

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

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

  1128. 

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

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

  1131. 

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

  1133.      $DataSerie = "";

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

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

  1136. 

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

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

  1139. 

  1140.      /* Remove unused data */

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

  1142. 

  1143.      /* Compute the pie sum */

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

  1145. 

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

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

  1148. 

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

  1150.      $Values = array();

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

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

  1153. 

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

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

  1156. 

  1157.      /* Compute the scale */

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

  1159. 

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

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

  1162. 

  1163.      /* Draw the polygon ring elements */

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

  1165.      $Values = array_reverse($Values);

  1166.      $Slice  = 0; $Slices = array(); $SliceColors = ""; $Visible = ""; $SliceAngle = "";

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

  1168.       {

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

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

  1171. 

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

  1173. 

  1174.        $StartAngle = $Offset;

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

  1176. 

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

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

  1179. 

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

  1181.        $OutX1 = VOID; $OutY1 = VOID;

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

  1183.         {

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

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

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

  1187. 

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

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

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

  1191. 

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

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

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

  1195. 

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

  1197. 

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

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

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

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

  1202. 

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

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

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

  1206.         }

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

  1208. 

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

  1210.        $Lasti = $i;

  1211. 

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

  1213.        $InX1 = VOID; $InY1 = VOID;

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

  1215.         {

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

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

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

  1219. 

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

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

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

  1223. 

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

  1225. 

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

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

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

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

  1230. 

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

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

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

  1234.         }

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

  1236. 

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

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

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

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

  1241. 

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

  1243.       }

  1244. 

  1245.      /* Draw the bottom pie splice */

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

  1247.       {

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

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

  1250. 

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

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

  1253. 

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

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

  1256.       }

  1257. 

  1258.      $Slices      = array_reverse($Slices);

  1259.      $SliceColors = array_reverse($SliceColors);

  1260. 

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

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

  1263.       {

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

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

  1266. 

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

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

  1269. 

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

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

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

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

  1274. 

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

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

  1277.       }

  1278. 

  1279.      /* Draw the inner vertical slices */

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

  1281.       {

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

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

  1284. 

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

  1286.        $InnerPlotsA = array(); $InnerPlotsB = array();

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

  1288.         {

  1289.          if ( $Angle == VOID )

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

  1291.          elseif( $Inner )

  1292.           {

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

  1294.             {

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

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

  1297. 

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

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

  1300.             }

  1301.           }

  1302.         }

  1303. 

  1304.        if ( $InnerPlotsA != "" )

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

  1306.       }

  1307. 

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

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

  1310.       {

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

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

  1313. 

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

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

  1316. 

  1317.        if ( $StartAngle < 180 )

  1318.         {

  1319.          $Points = array();

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

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

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

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

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

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

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

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

  1328. 

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

  1330.         }

  1331. 

  1332.        if ( $EndAngle > 180 )

  1333.         {

  1334.          $Points = array();

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

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

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

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

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

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

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

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

  1343. 

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

  1345.         }

  1346.       }

  1347. 

  1348. 

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

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

  1351.       {

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

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

  1354. 

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

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

  1357. 

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

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

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

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

  1362.       }

  1363. 

  1364. 

  1365.      /* Draw the outer vertical slices */

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

  1367.       {

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

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

  1370. 

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

  1372.        $OuterPlotsA = array(); $OuterPlotsB = array(); $InnerPlotsA = ""; $InnerPlotsB = "";

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

  1374.         {

  1375.          if ( $Angle == VOID )

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

  1377.          elseif( $Outer )

  1378.           {

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

  1380.             {

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

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

  1383. 

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

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

  1386.             }

  1387.           }

  1388.         }

  1389.        if ( $OuterPlotsA != "" )

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

  1391.       }

  1392. 

  1393.      $Slices      = array_reverse($Slices);

  1394.      $SliceColors = array_reverse($SliceColors);

  1395. 

  1396. 

  1397.      /* Draw the top pie splice */

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

  1399.       {

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

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

  1402.  

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

  1404. 

  1405.        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]); }

  1406. 

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

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

  1409. 

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

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

  1412.       }

  1413. 

  1414.      if ( $DrawLabels )

  1415.       {

  1416.        $Offset = 360;

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

  1418.         {

  1419.          $StartAngle = $Offset;

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

  1421. 

  1422.          if ( $LabelColor == PIE_LABEL_COLOR_AUTO )

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

  1424.          else

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

  1426. 

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

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

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

  1430. 

  1431.          if ( $WriteValues == PIE_VALUE_PERCENTAGE )

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

  1433.          elseif ( $WriteValues == PIE_VALUE_NATURAL )

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

  1435.          else

  1436.           $Label = "";

  1437. 

  1438.          if ( $LabelStacked )

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

  1440.          else

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

  1442. 

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

  1444.         }

  1445.       }

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

  1447. 

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

  1449. 

  1450.      return(PIE_RENDERED);

  1451.     }

  1452. 

  1453.   /* Serialize an array */

  1454.   function arraySerialize($Data)

  1455.    {

  1456.     $Result = "";

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

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

  1459. 

  1460.     return($Result);

  1461.    }

  1462. 

  1463.   /* Reverse an array */

  1464.   function arrayReverse($Plots)

  1465.    {

  1466.     $Result = array();

  1467. 

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

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

  1470. 

  1471.     return($Result);

  1472.    }

  1473. 

  1474.   /* Remove unused series & values */

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

  1476.    {

  1477.     $NewPalette = array(); $NewData = array(); $NewAbscissa = array();

  1478. 

  1479.     /* Remove unused series */

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

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

  1482. 

  1483.     /* Remove NULL values */

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

  1485.      {

  1486.       if ($Value != 0 )

  1487.        {

  1488.         $NewData[]     = $Value;

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

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

  1491.        }

  1492.      }

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

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

  1495. 

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

  1497.    }

  1498.   }

Constants

Namesort descending Description
PIE_LABEL_COLOR_AUTO
PIE_LABEL_COLOR_MANUAL
PIE_NO_ABSCISSA
PIE_NO_DATASERIE
PIE_RENDERED
PIE_SUMISNULL
PIE_VALUE_INSIDE
PIE_VALUE_NATURAL
PIE_VALUE_OUTSIDE
PIE_VALUE_PERCENTAGE

Classes

Namesort descending Description
pPie