79e3c052e2
For the host name set, if there is no data in the HTTP_HOST var, then set it to NA instead. Also default set to port 80 if no port info could be found.
788 lines
31 KiB
PHP
788 lines
31 KiB
PHP
<?php
|
|
/*
|
|
pDraw - class to manipulate data arrays
|
|
|
|
Version : 2.1.4
|
|
Made by : Jean-Damien POGOLOTTI
|
|
Last Update : 19/01/2014
|
|
|
|
This file can be distributed under the license you can find at :
|
|
|
|
http://www.pchart.net/license
|
|
|
|
You can find the whole class documentation on the pChart web site.
|
|
*/
|
|
|
|
/* Axis configuration */
|
|
define("AXIS_FORMAT_DEFAULT" , 680001);
|
|
define("AXIS_FORMAT_TIME" , 680002);
|
|
define("AXIS_FORMAT_DATE" , 680003);
|
|
define("AXIS_FORMAT_METRIC" , 680004);
|
|
define("AXIS_FORMAT_CURRENCY" , 680005);
|
|
define("AXIS_FORMAT_TRAFFIC" , 680006);
|
|
define("AXIS_FORMAT_CUSTOM" , 680007);
|
|
|
|
/* Axis position */
|
|
define("AXIS_POSITION_LEFT" , 681001);
|
|
define("AXIS_POSITION_RIGHT" , 681002);
|
|
define("AXIS_POSITION_TOP" , 681001);
|
|
define("AXIS_POSITION_BOTTOM" , 681002);
|
|
|
|
/* Families of data points */
|
|
define("SERIE_SHAPE_FILLEDCIRCLE" , 681011);
|
|
define("SERIE_SHAPE_FILLEDTRIANGLE" , 681012);
|
|
define("SERIE_SHAPE_FILLEDSQUARE" , 681013);
|
|
define("SERIE_SHAPE_FILLEDDIAMOND" , 681017);
|
|
define("SERIE_SHAPE_CIRCLE" , 681014);
|
|
define("SERIE_SHAPE_TRIANGLE" , 681015);
|
|
define("SERIE_SHAPE_SQUARE" , 681016);
|
|
define("SERIE_SHAPE_DIAMOND" , 681018);
|
|
|
|
/* Axis position */
|
|
define("AXIS_X" , 682001);
|
|
define("AXIS_Y" , 682002);
|
|
|
|
/* Define value limits */
|
|
define("ABSOLUTE_MIN" , -10000000000000);
|
|
define("ABSOLUTE_MAX" , 10000000000000);
|
|
|
|
/* Replacement to the PHP NULL keyword */
|
|
define("VOID" , 0.123456789);
|
|
|
|
/* Euro symbol for GD fonts */
|
|
define("EURO_SYMBOL" , utf8_encode("€"));
|
|
|
|
/* pData class definition */
|
|
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+.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); }
|
|
}
|
|
?>
|