You are here

Home » API reference » Visitors 7 » pData.class.php

class pData in Visitors 7

Same name and namespace in other branches
  1. 8 pchart/pData.inc \pData
  2. 7.2 pChart/class/pData.class.php \pData
  3. 7.0 pchart/pData.inc \pData

Hierarchy

Expanded class hierarchy of pData

File

pChart/class/pData.class.php, line 56

View source 
class pData {
  var $Data;
  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 = "";
    $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 + 0.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);
  }

}

Members

Namesort descending Modifiers Type Description Overrides
pData::$Data property
pData::$Palette property
pData::addPoints function
pData::addRandomValues function
pData::containsData function
pData::convertToArray function
pData::createFunctionSerie function
pData::drawAll function
pData::getCoefficientOfVariation function
pData::getData function
pData::getGeometricMean function
pData::getHarmonicMean function
pData::getMax function
pData::getMin function
pData::getPalette function
pData::getSerieAverage function
pData::getSerieCount function
pData::getSerieMedian function
pData::getSeriePalette function
pData::getSeriePercentile function
pData::getStandardDeviation function
pData::getSum function
pData::getValueAt function
pData::getValues function
pData::importFromCSV function
pData::initialise function
pData::initScatterSerie function
pData::left function
pData::limits function
pData::loadPalette function
pData::mid function
pData::negateValues function
pData::normalize function
pData::pData function
pData::removeSerie function
pData::reverseSerie function
pData::right function
pData::saveAxisConfig function
pData::saveExtendedData function
pData::saveOrientation function
pData::savePalette function
pData::saveYMargin function
pData::setAbscissa function
pData::setAbscissaName function
pData::setAbsicssaPosition function
pData::setAxisColor function
pData::setAxisDisplay function
pData::setAxisName function
pData::setAxisPosition function
pData::setAxisUnit function
pData::setAxisXY function
pData::setPalette function
pData::setScatterSerie function
pData::setScatterSerieColor function
pData::setScatterSerieDescription function
pData::setScatterSerieDrawable function
pData::setScatterSeriePicture function
pData::setScatterSerieShape function
pData::setScatterSerieTicks function
pData::setScatterSerieWeight function
pData::setSerieDescription function
pData::setSerieDrawable function
pData::setSerieOnAxis function
pData::setSeriePicture function
pData::setSerieShape function
pData::setSerieTicks function
pData::setSerieWeight function
pData::setXAxisDisplay function
pData::setXAxisName function
pData::setXAxisUnit function
pData::stripVOID function
pData::__toString function