class pData
 {
  var $Data = array();

  var $Palette = array("0" => array("R" => 188, "G" => 224, "B" => 46, "Alpha" => 100),
    "1" => array("R" => 224, "G" => 100, "B" => 46, "Alpha" => 100),
    "2" => array("R" => 224, "G" => 214, "B" => 46, "Alpha" => 100),
    "3" => array("R" => 46, "G" => 151, "B" => 224, "Alpha" => 100),
    "4" => array("R" => 176, "G" => 46, "B" => 224, "Alpha" => 100),
    "5" => array("R" => 224, "G" => 46, "B" => 117, "Alpha" => 100),
    "6" => array("R" => 92, "G" => 224, "B" => 46, "Alpha" => 100),
    "7" => array("R" => 224, "G" => 176, "B" => 46, "Alpha" => 100));

  /* Class creator */
  function pData() 
   {
    $this->Data = array();
    $this->Data ["XAxisDisplay"] = AXIS_FORMAT_DEFAULT;
    $this->Data ["XAxisFormat"] = NULL;
    $this->Data ["XAxisName"] = NULL;
    $this->Data ["XAxisUnit"] = NULL;
    $this->Data ["Abscissa"] = NULL;
    $this->Data ["AbsicssaPosition"] = AXIS_POSITION_BOTTOM;

    $this->Data ["Axis"][0]["Display"] = AXIS_FORMAT_DEFAULT;
    $this->Data ["Axis"][0]["Position"] = AXIS_POSITION_LEFT;
    $this->Data ["Axis"][0]["Identity"] = AXIS_Y;
  }

  /* Add a single point or an array to the given serie */
  function addPoints($Values, $SerieName = "Serie1") 
   {
    if (!isset($this->Data ["Series"][$SerieName])) {
      $this->initialise($SerieName);
    }

    if (is_array($Values)) 
     {
      foreach ($Values as $Key => $Value) 
       {
        $this->Data ["Series"][$SerieName]["Data"][] = $Value;
      }
    }
    else {
      $this->Data ["Series"][$SerieName]["Data"][] = $Values;
    }

    if ($Values != VOID) 
     {
      $StrippedData = $this->stripVOID($this->Data ["Series"][$SerieName]["Data"]);
      if (empty($StrippedData)) {
        $this->Data ["Series"][$SerieName]["Max"] = 0;
        $this->Data ["Series"][$SerieName]["Min"] = 0;
        return (0);
      }
      $this->Data ["Series"][$SerieName]["Max"] = max($StrippedData);
      $this->Data ["Series"][$SerieName]["Min"] = min($StrippedData);
    }
  }

  /* Strip VOID values */
  function stripVOID($Values) 
   {
    if (!is_array($Values)) {
      return (array());
    }
    $Result = array();
    foreach ($Values as $Key => $Value) {
      if ($Value != VOID) {
        $Result [] = $Value;
      }
    }
    return ($Result);
  }

  /* Return the number of values contained in a given serie */
  function getSerieCount($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie]["Data"])) {
      return (sizeof($this->Data ["Series"][$Serie]["Data"]));
    }
    else {
      return (0);
    }
  }

  /* Remove a serie from the pData object */
  function removeSerie($Series) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) {
      if (isset($this->Data ["Series"][$Serie])) {
        unset($this->Data ["Series"][$Serie]);
      }
    }
  }

  /* Return a value from given serie & index */
  function getValueAt($Serie, $Index = 0) 
   {
    if (isset($this->Data ["Series"][$Serie]["Data"][$Index])) {
      return ($this->Data ["Series"][$Serie]["Data"][$Index]);
    }
    else {
      return (NULL);
    }
  }

  /* Return the values array */
  function getValues($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie]["Data"])) {
      return ($this->Data ["Series"][$Serie]["Data"]);
    }
    else {
      return (NULL);
    }
  }

  /* Reverse the values in the given serie */
  function reverseSerie($Series) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) {
      if (isset($this->Data ["Series"][$Serie]["Data"])) {
        $this->Data ["Series"][$Serie]["Data"] = array_reverse($this->Data ["Series"][$Serie]["Data"]);
      }
    }
  }

  /* Return the sum of the serie values */
  function getSum($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie])) {
      return (array_sum($this->Data ["Series"][$Serie]["Data"]));
    }
    else {
      return (NULL);
    }
  }

  /* Return the max value of a given serie */
  function getMax($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie]["Max"])) {
      return ($this->Data ["Series"][$Serie]["Max"]);
    }
    else {
      return (NULL);
    }
  }

  /* Return the min value of a given serie */
  function getMin($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie]["Min"])) {
      return ($this->Data ["Series"][$Serie]["Min"]);
    }
    else {
      return (NULL);
    }
  }

  /* Set the description of a given serie */
  function setSerieShape($Series, $Shape = SERIE_SHAPE_FILLEDCIRCLE) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) {
      if (isset($this->Data ["Series"][$Serie])) {
        $this->Data ["Series"][$Serie]["Shape"] = $Shape;
      }
    }
  }

  /* Set the description of a given serie */
  function setSerieDescription($Series, $Description = "My serie") 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) {
      if (isset($this->Data ["Series"][$Serie])) {
        $this->Data ["Series"][$Serie]["Description"] = $Description;
      }
    }
  }

  /* Set a serie as "drawable" while calling a rendering function */
  function setSerieDrawable($Series, $Drawable = TRUE) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) {
      if (isset($this->Data ["Series"][$Serie])) {
        $this->Data ["Series"][$Serie]["isDrawable"] = $Drawable;
      }
    }
  }

  /* Set the icon associated to a given serie */
  function setSeriePicture($Series, $Picture = NULL) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) {
      if (isset($this->Data ["Series"][$Serie])) {
        $this->Data ["Series"][$Serie]["Picture"] = $Picture;
      }
    }
  }

  /* Set the name of the X Axis */
  function setXAxisName($Name) 
   {
    $this->Data ["XAxisName"] = $Name;
  }

  /* Set the display mode of the  X Axis */
  function setXAxisDisplay($Mode, $Format = NULL) 
   {
    $this->Data ["XAxisDisplay"] = $Mode;
    $this->Data ["XAxisFormat"] = $Format;
  }

  /* Set the unit that will be displayed on the X axis */
  function setXAxisUnit($Unit) 
   {
    $this->Data ["XAxisUnit"] = $Unit;
  }

  /* Set the serie that will be used as abscissa */
  function setAbscissa($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie])) {
      $this->Data ["Abscissa"] = $Serie;
    }
  }

  function setAbsicssaPosition($Position = AXIS_POSITION_BOTTOM) 
   {
    $this->Data ["AbsicssaPosition"] = $Position;
  }

  /* Set the name of the abscissa axis */
  function setAbscissaName($Name) 
   {
    $this->Data ["AbscissaName"] = $Name;
  }

  /* Create a scatter group specifyin X and Y data series */
  function setScatterSerie($SerieX, $SerieY, $ID = 0) 
   {
    if (isset($this->Data ["Series"][$SerieX]) && isset($this->Data ["Series"][$SerieY])) {
      $this->initScatterSerie($ID);
      $this->Data ["ScatterSeries"][$ID]["X"] = $SerieX;
      $this->Data ["ScatterSeries"][$ID]["Y"] = $SerieY;
    }
  }

  /* Set the shape of a given sctatter serie */
  function setScatterSerieShape($ID, $Shape = SERIE_SHAPE_FILLEDCIRCLE) 
   {
    if (isset($this->Data ["ScatterSeries"][$ID])) {
      $this->Data ["ScatterSeries"][$ID]["Shape"] = $Shape;
    }
  }

  /* Set the description of a given scatter serie */
  function setScatterSerieDescription($ID, $Description = "My serie") 
   {
    if (isset($this->Data ["ScatterSeries"][$ID])) {
      $this->Data ["ScatterSeries"][$ID]["Description"] = $Description;
    }
  }

  /* Set the icon associated to a given scatter serie */
  function setScatterSeriePicture($ID, $Picture = NULL) 
   {
    if (isset($this->Data ["ScatterSeries"][$ID])) {
      $this->Data ["ScatterSeries"][$ID]["Picture"] = $Picture;
    }
  }

  /* Set a scatter serie as "drawable" while calling a rendering function */
  function setScatterSerieDrawable($ID, $Drawable = TRUE) 
   {
    if (isset($this->Data ["ScatterSeries"][$ID])) {
      $this->Data ["ScatterSeries"][$ID]["isDrawable"] = $Drawable;
    }
  }

  /* Define if a scatter serie should be draw with ticks */
  function setScatterSerieTicks($ID, $Width = 0) 
   {
    if (isset($this->Data ["ScatterSeries"][$ID])) {
      $this->Data ["ScatterSeries"][$ID]["Ticks"] = $Width;
    }
  }

  /* Define if a scatter serie should be draw with a special weight */
  function setScatterSerieWeight($ID, $Weight = 0) 
   {
    if (isset($this->Data ["ScatterSeries"][$ID])) {
      $this->Data ["ScatterSeries"][$ID]["Weight"] = $Weight;
    }
  }

  /* Associate a color to a scatter serie */
  function setScatterSerieColor($ID, $Format) 
   {
    $R = isset($Format ["R"]) ? $Format ["R"] : 0;
    $G = isset($Format ["G"]) ? $Format ["G"] : 0;
    $B = isset($Format ["B"]) ? $Format ["B"] : 0;
    $Alpha = isset($Format ["Alpha"]) ? $Format ["Alpha"] : 100;

    if (isset($this->Data ["ScatterSeries"][$ID])) 
     {
      $this->Data ["ScatterSeries"][$ID]["Color"]["R"] = $R;
      $this->Data ["ScatterSeries"][$ID]["Color"]["G"] = $G;
      $this->Data ["ScatterSeries"][$ID]["Color"]["B"] = $B;
      $this->Data ["ScatterSeries"][$ID]["Color"]["Alpha"] = $Alpha;
    }
  }

  /* Compute the series limits for an individual and global point of view */
  function limits() 
   {
    $GlobalMin = ABSOLUTE_MAX;
    $GlobalMax = ABSOLUTE_MIN;

    foreach ($this->Data ["Series"] as $Key => $Value) 
     {
      if ($this->Data ["Abscissa"] != $Key && $this->Data ["Series"][$Key]["isDrawable"] == TRUE) 
       {
        if ($GlobalMin > $this->Data ["Series"][$Key]["Min"]) {
          $GlobalMin = $this->Data ["Series"][$Key]["Min"];
        }
        if ($GlobalMax < $this->Data ["Series"][$Key]["Max"]) {
          $GlobalMax = $this->Data ["Series"][$Key]["Max"];
        }
      }
    }
    $this->Data ["Min"] = $GlobalMin;
    $this->Data ["Max"] = $GlobalMax;

    return (array($GlobalMin, $GlobalMax));
  }

  /* Mark all series as drawable */
  function drawAll() 
   {
    foreach ($this->Data ["Series"] as $Key => $Value) {
      if ($this->Data ["Abscissa"] != $Key) {
        $this->Data ["Series"][$Key]["isDrawable"] = TRUE;
      }
    }
  }

  /* Return the average value of the given serie */
  function getSerieAverage($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie])) 
     {
      $SerieData = $this->stripVOID($this->Data ["Series"][$Serie]["Data"]);
      return (array_sum($SerieData) / sizeof($SerieData));
    }
    else {
      return (NULL);
    }
  }

  /* Return the geometric mean of the given serie */
  function getGeometricMean($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie])) 
     {
      $SerieData = $this->stripVOID($this->Data ["Series"][$Serie]["Data"]);
      $Seriesum = 1;
      foreach ($SerieData as $Key => $Value) {
        $Seriesum = $Seriesum * $Value;
      }
      return (pow($Seriesum, 1 / sizeof($SerieData)));
    }
    else {
      return (NULL);
    }
  }

  /* Return the harmonic mean of the given serie */
  function getHarmonicMean($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie])) 
     {
      $SerieData = $this->stripVOID($this->Data ["Series"][$Serie]["Data"]);
      $Seriesum = 0;
      foreach ($SerieData as $Key => $Value) {
        $Seriesum = $Seriesum + 1 / $Value;
      }
      return (sizeof($SerieData) / $Seriesum);
    }
    else {
      return (NULL);
    }
  }

  /* Return the standard deviation of the given serie */
  function getStandardDeviation($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie])) 
     {
      $Average = $this->getSerieAverage($Serie);
      $SerieData = $this->stripVOID($this->Data ["Series"][$Serie]["Data"]);

      $DeviationSum = 0;
      foreach ($SerieData as $Key => $Value) {
        $DeviationSum = $DeviationSum + ($Value -$Average) * ($Value -$Average);
      };

      $Deviation = sqrt($DeviationSum / count($SerieData));

      return ($Deviation);
    }
    else {
      return (NULL);
    }
  }

  /* Return the Coefficient of variation of the given serie */
  function getCoefficientOfVariation($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie])) 
     {
      $Average = $this->getSerieAverage($Serie);
      $StandardDeviation = $this->getStandardDeviation($Serie);

      if ($StandardDeviation != 0) {
        return ($StandardDeviation / $Average);
      }
      else {
        return (NULL);
      }
    }
    else {
      return (NULL);
    }
  }

  /* Return the median value of the given serie */
  function getSerieMedian($Serie) 
   {
    if (isset($this->Data ["Series"][$Serie])) 
     {
      $SerieData = $this->stripVOID($this->Data ["Series"][$Serie]["Data"]);
      sort($SerieData);
      $SerieCenter = floor(sizeof($SerieData) / 2);

      if (isset($SerieData [$SerieCenter])) {
        return ($SerieData [$SerieCenter]);
      }
      else {
        return (NULL);
      }
    }
    else {
      return (NULL);
    }
  }

  /* Return the x th percentil of the given serie */
  function getSeriePercentile($Serie = "Serie1", $Percentil = 95) 
   {
    if (!isset($this->Data ["Series"][$Serie]["Data"])) {
      return (NULL);
    }

    $Values = count($this->Data ["Series"][$Serie]["Data"]) -1;
    if ($Values < 0) {
      $Values = 0;
    }

    $PercentilID = floor(($Values / 100) * $Percentil + .5);
    $SortedValues = $this->Data ["Series"][$Serie]["Data"];
    sort($SortedValues);

    if (is_numeric($SortedValues [$PercentilID])) {
      return ($SortedValues [$PercentilID]);
    }
    else {
      return (NULL);
    }
  }

  /* Add random values to a given serie */
  function addRandomValues($SerieName = "Serie1", $Options = "") 
   {
    $Values = isset($Options ["Values"]) ? $Options ["Values"] : 20;
    $Min = isset($Options ["Min"]) ? $Options ["Min"] : 0;
    $Max = isset($Options ["Max"]) ? $Options ["Max"] : 100;
    $withFloat = isset($Options ["withFloat"]) ? $Options ["withFloat"] : FALSE;

    for ($i = 0; $i <= $Values; $i++) 
     {
      if ($withFloat) {
        $Value = rand($Min * 100, $Max * 100) / 100;
      }
      else {
        $Value = rand($Min, $Max);
      }
      $this->addPoints($Value, $SerieName);
    }
  }

  /* Test if we have valid data */
  function containsData() 
   {
    if (!isset($this->Data ["Series"])) {
      return (FALSE);
    }

    $Result = FALSE;
    foreach ($this->Data ["Series"] as $Key => $Value) 
     {
      if ($this->Data ["Abscissa"] != $Key && $this->Data ["Series"][$Key]["isDrawable"] == TRUE) {
        $Result = TRUE;
      }
    }
    return ($Result);
  }

  /* Set the display mode of an Axis */
  function setAxisDisplay($AxisID, $Mode = AXIS_FORMAT_DEFAULT, $Format = NULL) 
   {
    if (isset($this->Data ["Axis"][$AxisID])) 
     {
      $this->Data ["Axis"][$AxisID]["Display"] = $Mode;
      if ($Format != NULL) {
        $this->Data ["Axis"][$AxisID]["Format"] = $Format;
      }
    }
  }

  /* Set the position of an Axis */
  function setAxisPosition($AxisID, $Position = AXIS_POSITION_LEFT) 
   {
    if (isset($this->Data ["Axis"][$AxisID])) {
      $this->Data ["Axis"][$AxisID]["Position"] = $Position;
    }
  }

  /* Associate an unit to an axis */
  function setAxisUnit($AxisID, $Unit) 
   {
    if (isset($this->Data ["Axis"][$AxisID])) {
      $this->Data ["Axis"][$AxisID]["Unit"] = $Unit;
    }
  }

  /* Associate a name to an axis */
  function setAxisName($AxisID, $Name) 
   {
    if (isset($this->Data ["Axis"][$AxisID])) {
      $this->Data ["Axis"][$AxisID]["Name"] = $Name;
    }
  }

  /* Associate a color to an axis */
  function setAxisColor($AxisID, $Format) 
   {
    $R = isset($Format ["R"]) ? $Format ["R"] : 0;
    $G = isset($Format ["G"]) ? $Format ["G"] : 0;
    $B = isset($Format ["B"]) ? $Format ["B"] : 0;
    $Alpha = isset($Format ["Alpha"]) ? $Format ["Alpha"] : 100;

    if (isset($this->Data ["Axis"][$AxisID])) 
     {
      $this->Data ["Axis"][$AxisID]["Color"]["R"] = $R;
      $this->Data ["Axis"][$AxisID]["Color"]["G"] = $G;
      $this->Data ["Axis"][$AxisID]["Color"]["B"] = $B;
      $this->Data ["Axis"][$AxisID]["Color"]["Alpha"] = $Alpha;
    }
  }


  /* Design an axis as X or Y member */
  function setAxisXY($AxisID, $Identity = AXIS_Y) 
   {
    if (isset($this->Data ["Axis"][$AxisID])) {
      $this->Data ["Axis"][$AxisID]["Identity"] = $Identity;
    }
  }

  /* Associate one data serie with one axis */
  function setSerieOnAxis($Series, $AxisID) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) 
     {
      $PreviousAxis = $this->Data ["Series"][$Serie]["Axis"];

      /* Create missing axis */
      if (!isset($this->Data ["Axis"][$AxisID])) 
       {
        $this->Data ["Axis"][$AxisID]["Position"] = AXIS_POSITION_LEFT;
        $this->Data ["Axis"][$AxisID]["Identity"] = AXIS_Y;
      }

      $this->Data ["Series"][$Serie]["Axis"] = $AxisID;

      /* Cleanup unused axis */
      $Found = FALSE;
      foreach ($this->Data ["Series"] as $SerieName => $Values) {
        if ($Values ["Axis"] == $PreviousAxis) {
          $Found = TRUE;
        }
      }
      if (!$Found) {
        unset($this->Data ["Axis"][$PreviousAxis]);
      }
    }
  }

  /* Define if a serie should be draw with ticks */
  function setSerieTicks($Series, $Width = 0) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) {
      if (isset($this->Data ["Series"][$Serie])) {
        $this->Data ["Series"][$Serie]["Ticks"] = $Width;
      }
    }
  }

  /* Define if a serie should be draw with a special weight */
  function setSerieWeight($Series, $Weight = 0) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $Serie) {
      if (isset($this->Data ["Series"][$Serie])) {
        $this->Data ["Series"][$Serie]["Weight"] = $Weight;
      }
    }
  }

  /* Returns the palette of the given serie */
  function getSeriePalette($Serie) 
   {
    if (!isset($this->Data ["Series"][$Serie])) {
      return (NULL);
    }

    $Result = "";
    $Result ["R"] = $this->Data ["Series"][$Serie]["Color"]["R"];
    $Result ["G"] = $this->Data ["Series"][$Serie]["Color"]["G"];
    $Result ["B"] = $this->Data ["Series"][$Serie]["Color"]["B"];
    $Result ["Alpha"] = $this->Data ["Series"][$Serie]["Color"]["Alpha"];

    return ($Result);
  }

  /* Set the color of one serie */
  function setPalette($Series, $Format = NULL) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }

    foreach ($Series as $Key => $Serie) 
     {
      $R = isset($Format ["R"]) ? $Format ["R"] : 0;
      $G = isset($Format ["G"]) ? $Format ["G"] : 0;
      $B = isset($Format ["B"]) ? $Format ["B"] : 0;
      $Alpha = isset($Format ["Alpha"]) ? $Format ["Alpha"] : 100;

      if (isset($this->Data ["Series"][$Serie])) 
       {
        $OldR = $this->Data ["Series"][$Serie]["Color"]["R"];
        $OldG = $this->Data ["Series"][$Serie]["Color"]["G"];
        $OldB = $this->Data ["Series"][$Serie]["Color"]["B"];
        $this->Data ["Series"][$Serie]["Color"]["R"] = $R;
        $this->Data ["Series"][$Serie]["Color"]["G"] = $G;
        $this->Data ["Series"][$Serie]["Color"]["B"] = $B;
        $this->Data ["Series"][$Serie]["Color"]["Alpha"] = $Alpha;

        /* Do reverse processing on the internal palette array */
        foreach ($this->Palette as $Key => $Value) 
         {
          if ($Value ["R"] == $OldR && $Value ["G"] == $OldG && $Value ["B"] == $OldB) {
            $this->Palette [$Key]["R"] = $R;
            $this->Palette [$Key]["G"] = $G;
            $this->Palette [$Key]["B"] = $B;
            $this->Palette [$Key]["Alpha"] = $Alpha;
          }
        }
      }
    }
  }

  /* Load a palette file */
  function loadPalette($FileName, $Overwrite = FALSE) 
   {
    if (!file_exists($FileName)) {
      return (-1);
    }
    if ($Overwrite) {
      $this->Palette = "";
    }

    $fileHandle = @fopen($FileName, "r");
    if (!$fileHandle) {
      return (-1);
    }
    while (!feof($fileHandle)) 
     {
      $buffer = fgets($fileHandle, 4096);
      if (preg_match("/,/", $buffer)) 
       {
        list($R, $G, $B, $Alpha) = preg_split("/,/", $buffer);
        if ($this->Palette == "") {
          $ID = 0;
        }
        else {
          $ID = count($this->Palette);
        }
        $this->Palette [$ID] = array("R" => $R, "G" => $G, "B" => $B, "Alpha" => $Alpha);
      }
    }
    fclose($fileHandle);

    /* Apply changes to current series */
    $ID = 0;
    if (isset($this->Data ["Series"])) 
     {
      foreach ($this->Data ["Series"] as $Key => $Value) 
       {
        if (!isset($this->Palette [$ID])) {
          $this->Data ["Series"][$Key]["Color"] = array("R" => 0, "G" => 0, "B" => 0, "Alpha" => 0);
        }
        else {
          $this->Data ["Series"][$Key]["Color"] = $this->Palette [$ID];
        }
        $ID++;
      }
    }
  }

  /* Initialise a given scatter serie */
  function initScatterSerie($ID) 
   {
    if (isset($this->Data ["ScatterSeries"][$ID])) {
      return (0);
    }

    $this->Data ["ScatterSeries"][$ID]["Description"] = "Scatter " . $ID;
    $this->Data ["ScatterSeries"][$ID]["isDrawable"] = TRUE;
    $this->Data ["ScatterSeries"][$ID]["Picture"] = NULL;
    $this->Data ["ScatterSeries"][$ID]["Ticks"] = 0;
    $this->Data ["ScatterSeries"][$ID]["Weight"] = 0;

    if (isset($this->Palette [$ID])) {
      $this->Data ["ScatterSeries"][$ID]["Color"] = $this->Palette [$ID];
    }
    else 
     {
      $this->Data ["ScatterSeries"][$ID]["Color"]["R"] = rand(0, 255);
      $this->Data ["ScatterSeries"][$ID]["Color"]["G"] = rand(0, 255);
      $this->Data ["ScatterSeries"][$ID]["Color"]["B"] = rand(0, 255);
      $this->Data ["ScatterSeries"][$ID]["Color"]["Alpha"] = 100;
    }
  }

  /* Initialise a given serie */
  function initialise($Serie) 
   {
    if (isset($this->Data ["Series"])) {
      $ID = count($this->Data ["Series"]);
    }
    else {
      $ID = 0;
    }

    $this->Data ["Series"][$Serie]["Description"] = $Serie;
    $this->Data ["Series"][$Serie]["isDrawable"] = TRUE;
    $this->Data ["Series"][$Serie]["Picture"] = NULL;
    $this->Data ["Series"][$Serie]["Max"] = NULL;
    $this->Data ["Series"][$Serie]["Min"] = NULL;
    $this->Data ["Series"][$Serie]["Axis"] = 0;
    $this->Data ["Series"][$Serie]["Ticks"] = 0;
    $this->Data ["Series"][$Serie]["Weight"] = 0;
    $this->Data ["Series"][$Serie]["Shape"] = SERIE_SHAPE_FILLEDCIRCLE;

    if (isset($this->Palette [$ID])) {
      $this->Data ["Series"][$Serie]["Color"] = $this->Palette [$ID];
    }
    else 
     {
      $this->Data ["Series"][$Serie]["Color"]["R"] = rand(0, 255);
      $this->Data ["Series"][$Serie]["Color"]["G"] = rand(0, 255);
      $this->Data ["Series"][$Serie]["Color"]["B"] = rand(0, 255);
      $this->Data ["Series"][$Serie]["Color"]["Alpha"] = 100;
    }
  }

  function normalize($NormalizationFactor = 100, $UnitChange = NULL, $Round = 1) 
   {
    $Abscissa = $this->Data ["Abscissa"];

    $SelectedSeries = "";
    $MaxVal = 0;
    foreach ($this->Data ["Axis"] as $AxisID => $Axis) 
     {
      if ($UnitChange != NULL) {
        $this->Data ["Axis"][$AxisID]["Unit"] = $UnitChange;
      }

      foreach ($this->Data ["Series"] as $SerieName => $Serie) 
       {
        if ($Serie ["Axis"] == $AxisID && $Serie ["isDrawable"] == TRUE && $SerieName != $Abscissa) 
         {
          $SelectedSeries [$SerieName] = $SerieName;

          if (count($Serie ["Data"]) > $MaxVal) {
            $MaxVal = count($Serie ["Data"]);
          }
        }
      }
    }

    for ($i = 0; $i <= $MaxVal -1; $i++) 
     {
      $Factor = 0;
      foreach ($SelectedSeries as $Key => $SerieName) 
       {
        $Value = $this->Data ["Series"][$SerieName]["Data"][$i];
        if ($Value != VOID) {
          $Factor = $Factor + abs($Value);
        }
      }

      if ($Factor != 0) 
       {
        $Factor = $NormalizationFactor / $Factor;

        foreach ($SelectedSeries as $Key => $SerieName) 
         {
          $Value = $this->Data ["Series"][$SerieName]["Data"][$i];

          if ($Value != VOID && $Factor != $NormalizationFactor) {
            $this->Data ["Series"][$SerieName]["Data"][$i] = round(abs($Value) * $Factor, $Round);
          }
          elseif ($Value == VOID || $Value == 0) {
            $this->Data ["Series"][$SerieName]["Data"][$i] = VOID;
          }
          elseif ($Factor == $NormalizationFactor) {
            $this->Data ["Series"][$SerieName]["Data"][$i] = $NormalizationFactor;
          }
        }
      }
    }

    foreach ($SelectedSeries as $Key => $SerieName) 
     {
      $this->Data ["Series"][$SerieName]["Max"] = max($this->stripVOID($this->Data ["Series"][$SerieName]["Data"]));
      $this->Data ["Series"][$SerieName]["Min"] = min($this->stripVOID($this->Data ["Series"][$SerieName]["Data"]));
    }
  }

  /* Load data from a CSV (or similar) data source */
  function importFromCSV($FileName, $Options = "") 
   {
    $Delimiter = isset($Options ["Delimiter"]) ? $Options ["Delimiter"] : ",";
    $GotHeader = isset($Options ["GotHeader"]) ? $Options ["GotHeader"] : FALSE;
    $SkipColumns = isset($Options ["SkipColumns"]) ? $Options ["SkipColumns"] : array(-1);
    $DefaultSerieName = isset($Options ["DefaultSerieName"]) ? $Options ["DefaultSerieName"] : "Serie";

    $Handle = @fopen($FileName, "r");
    if ($Handle) 
     {
      $HeaderParsed = FALSE;
      $SerieNames = "";
      while (!feof($Handle)) 
       {
        $Buffer = fgets($Handle, 4096);
        $Buffer = str_replace(chr(10), "", $Buffer);
        $Buffer = str_replace(chr(13), "", $Buffer);
        $Values = preg_split("/" . $Delimiter . "/", $Buffer);

        if ($Buffer != "") 
         {
          if ($GotHeader && !$HeaderParsed) 
           {
            foreach ($Values as $Key => $Name) {
              if (!in_array($Key, $SkipColumns)) {
                $SerieNames [$Key] = $Name;
              }
            }
            $HeaderParsed = TRUE;
          }
          else 
           {
            if ($SerieNames == "") {
              foreach ($Values as $Key => $Name) {
                if (!in_array($Key, $SkipColumns)) {
                  $SerieNames [$Key] = $DefaultSerieName . $Key;
                }
              }
            }
            foreach ($Values as $Key => $Value) {
              if (!in_array($Key, $SkipColumns)) {
                $this->addPoints($Value, $SerieNames [$Key]);
              }
            }
          }
        }
      }
      fclose($Handle);
    }
  }

  /* Create a dataset based on a formula */
  function createFunctionSerie($SerieName, $Formula = "", $Options = "") 
   {
    $MinX = isset($Options ["MinX"]) ? $Options ["MinX"] : -10;
    $MaxX = isset($Options ["MaxX"]) ? $Options ["MaxX"] : 10;
    $XStep = isset($Options ["XStep"]) ? $Options ["XStep"] : 1;
    $AutoDescription = isset($Options ["AutoDescription"]) ? $Options ["AutoDescription"] : FALSE;
    $RecordAbscissa = isset($Options ["RecordAbscissa"]) ? $Options ["RecordAbscissa"] : FALSE;
    $AbscissaSerie = isset($Options ["AbscissaSerie"]) ? $Options ["AbscissaSerie"] : "Abscissa";

    if ($Formula == "") {
      return (0);
    }

    $Result = "";
    $Abscissa = "";
    for ($i = $MinX; $i <= $MaxX; $i = $i + $XStep) 
     {
      $Expression = "\$return = '!'.(" . str_replace("z", $i, $Formula) . ");";
      if (@eval($Expression) === FALSE) {
        $return = VOID;
      }
      if ($return == "!") {
        $return = VOID;
      }
      else {
        $return = $this->right($return, strlen($return) -1);
      }
      if ($return == "NAN") {
        $return = VOID;
      }
      if ($return == "INF") {
        $return = VOID;
      }
      if ($return == "-INF") {
        $return = VOID;
      }

      $Abscissa [] = $i;
      $Result [] = $return;
    }

    $this->addPoints($Result, $SerieName);
    if ($AutoDescription) {
      $this->setSerieDescription($SerieName, $Formula);
    }
    if ($RecordAbscissa) {
      $this->addPoints($Abscissa, $AbscissaSerie);
    }
  }

  function negateValues($Series) 
   {
    if (!is_array($Series)) {
      $Series = $this->convertToArray($Series);
    }
    foreach ($Series as $Key => $SerieName) 
     {
      if (isset($this->Data ["Series"][$SerieName])) 
       {
        $Data = "";
        foreach ($this->Data ["Series"][$SerieName]["Data"] as $Key => $Value) 
         {
          if ($Value == VOID) {
            $Data [] = VOID;
          }
          else {
            $Data [] = -$Value;
          }
        }
        $this->Data ["Series"][$SerieName]["Data"] = $Data;

        $this->Data ["Series"][$SerieName]["Max"] = max($this->stripVOID($this->Data ["Series"][$SerieName]["Data"]));
        $this->Data ["Series"][$SerieName]["Min"] = min($this->stripVOID($this->Data ["Series"][$SerieName]["Data"]));
      }
    }
  }

  /* Return the data & configuration of the series */
  function getData() 
   {
    return ($this->Data);
  }

  /* Save a palette element */
  function savePalette($ID, $Color) 
   {
    $this->Palette [$ID] = $Color;
  }

  /* Return the palette of the series */
  function getPalette() 
   {
    return ($this->Palette);
  }

  /* Called by the scaling algorithm to save the config */
  function saveAxisConfig($Axis) {
    $this->Data ["Axis"] = $Axis;
  }

  /* Save the Y Margin if set */
  function saveYMargin($Value) {
    $this->Data ["YMargin"] = $Value;
  }

  /* Save extended configuration to the pData object */
  function saveExtendedData($Tag, $Values) {
    $this->Data ["Extended"][$Tag] = $Values;
  }

  /* Called by the scaling algorithm to save the orientation of the scale */
  function saveOrientation($Orientation) {
    $this->Data ["Orientation"] = $Orientation;
  }

  /* Convert a string to a single elements array */
  function convertToArray($Value) 
   {
    $Values = "";
    $Values [] = $Value;
    return ($Values);
  }

  /* Class string wrapper */
  function __toString() 
   {
    return ("pData object.");
  }

  function left($value, $NbChar) {
    return substr($value, 0, $NbChar);
  }
  function right($value, $NbChar) {
    return substr($value, strlen($value) -$NbChar, $NbChar);
  }
  function mid($value, $Depart, $NbChar) {
    return substr($value, $Depart -1, $NbChar);
  }
}