Dominique.Fournier/DomFramework
1
0
Fork 0
Code Issues Pull Requests Projects Releases Activity
Files
2eb030056db4ba60179110a1766ae24c134928a6
DomFramework/graph.php

2599 lines
81 KiB
PHP
Raw Blame History

<?php
/** DomFramework
@package domframework
@author Dominique Fournier <dominique@fournier38.fr> */
require_once ("domframework/color.php");
/** This class allow to generate an image which is a graphic. A graphic takes
* an array of values and draw the lines/histo... like a spreadsheet
* graph methods are :
* ->height ($height) or ->width ($width) The heigh/width of the graph
*/
class graph
/* {{{ */
{
/** The X axis object
*/
public $axisX=null;
/** The main Y axis object
*/
public $axisY1=null;
/** The optional secondary Y axis object
*/
public $axisY2=null;
/** The legend object
*/
public $legend=null;
/** The graph title object
*/
public $title=null;
/** The height of the graph (150px by default)
*/
private $height = 200;
/** The width of the graph (200px by default)
*/
private $width = 300;
/** The background color of the graph (white by default)
*/
private $bgcolor = "whitesmoke";
/** The graph style by default. Each serie can define another value
*/
private $style = null;
/** The data object
*/
public $data = null;
/** The series object
*/
public $series = null;
/** Constructor : create the objects
*/
public function __construct ()
{
if (! function_exists ("imagecreatetruecolor"))
throw new \Exception (dgettext ("domframework",
"No GD support in PHP : can't create image"), 500);
$this->title = new graphTitle ();
$this->legend = new graphLegend ();
$this->data = new graphData ();
$this->series = new graphSeries ();
$this->axisX = new graphAxisX ();
$this->axisY1 = new graphAxisY1 ();
$this->axisY2 = new graphAxisY2 ();
// Default values
$defaultTitleFontFile = "/usr/share/fonts/truetype/liberation/".
"LiberationSans-Bold.ttf";
$defaultFontFile = "/usr/share/fonts/truetype/liberation/".
"LiberationSans-Regular.ttf";
$this->title->fontfile ($defaultTitleFontFile);
$this->legend->fontfile ($defaultFontFile);
$this->axisX->fontfile ($defaultFontFile);
$this->axisY1->fontfile ($defaultFontFile);
$this->axisY2->fontfile ($defaultFontFile);
$this->axisX->axisColor ("grey");
$this->axisY1->axisColor ("grey");
$this->axisY1->gridColor ("grey");
$this->axisY2->axisColor ("grey");
$this->style ("line");
$this->style()->palette ("basic");
}
/** Set the title position of the graph if the parameter is provided.
* Get the title position of the graph if the parameter is not provided
* @param string|null $titlePosition The title position of the graph
*/
public function titlePosition ($titlePosition = null)
{
if ($titlePosition === null)
return $this->titlePosition;
if (! is_string ($titlePosition) ||
( $titlePosition !== "top" && $titlePosition !== "bottom"))
throw new \Exception (dgettext ("domframework",
"Invalid titlePosition provided to graph"), 406);
$this->titlePosition = $titlePosition;
return $this;
}
/** Set the height of the graph if the parameter is provided.
* Get the height of the graph if the parameter is not provided
* @param integer|null $height The height of the graph
*/
public function height ($height = null)
{
if ($height === null)
return $this->height;
if (! is_integer ($height) || $height < 0 || $height > 3000)
throw new \Exception (dgettext ("domframework",
"Invalid height provided to graph"), 406);
$this->height = $height;
return $this;
}
/** Set the background-color of the graph if the parameter is provided.
* Get the background-color of the graph if the parameter is not provided
* @param string|null $bgcolor The background-color of the graph
*/
public function bgcolor ($bgcolor = null)
{
if ($bgcolor === null)
return $this->bgcolor;
if (! is_string ($bgcolor) ||
! in_array ($bgcolor, \color::colorList ()))
throw new \Exception (dgettext ("domframework",
"Invalid bgcolor provided to graph"), 406);
$this->bgcolor = $bgcolor;
return $this;
}
/** Set the width of the graph if the parameter is provided.
* Get the width of the graph if the parameter is not provided
* @param integer|null $width The width of the graph
*/
public function width ($width = null)
{
if ($width === null)
return $this->width;
if (! is_integer ($width) || $width < 0 || $width > 3000)
throw new \Exception (dgettext ("domframework",
"Invalid width provided to graph"), 406);
$this->width = $width;
return $this;
}
/** Set the default style of the graph if the parameter is provided.
* Get the default style of the graph if the parameter is not provided
* @param string|null $style The style of the graph
*/
public function style ($style = null)
{
if ($style === null)
return $this->style;
if (! is_string ($style) ||
! in_array ($style, array ("line", "points", "linePoints")))
throw new \Exception (dgettext ("domframework",
"Invalid style provided to graph"), 406);
$styleClass = "graphStyle".$style;
if ($this->style === null || $this->style ()->name () !== $style)
{
$this->style = new $styleClass ();
$this->style()->palette ("basic");
}
return $this->style;
}
/** Draw the graph to the screen with the previous defined parameters
*/
private function drawReal ()
{
// Read the data
$series = $this->data->getSeries ();
foreach ($this->series->getList () as $serie)
{
// Remove the previous defined series which doesn't exists in the data
if (! array_key_exists ($serie, $series))
$this->series->remove ($serie);
}
// Look for the min/max of the axis and use the data maximum if the user
// doesn't define it previously. The min/max are defined on ALL the series
// can not be defined by the axis directely
$minValueX = null;
$maxValueX = null;
$minValueY1 = null;
$maxValueY1 = null;
$minValueY2 = null;
$maxValueY2 = null;
foreach ($series as $serie=>$data)
{
// Add the data to the series or create them if they doesn't exists
$this->series->serie ($serie)->data ($data);
// Look for min/max and set the data for X axis
$this->axisX->data (array_keys ($data));
if ($minValueX === null)
$minValueX = $this->series->serie ($serie)->minKey ();
$minValueX = min ($minValueX,
$this->series->serie ($serie)->minKey ());
if ($maxValueX === null)
$maxValueX = $this->series->serie ($serie)->maxKey ();
$maxValueX = max ($maxValueX,
$this->series->serie ($serie)->maxKey ());
if (! $this->series->serie ($serie)->axisYsecondary ())
{
// Look for min/max for Y1 axis
if ($minValueY1 === null)
$minValueY1 = $this->series->serie ($serie)->minValue ();
$minValueY1 = min ($minValueY1,
$this->series->serie ($serie)->minValue ());
$maxValueY1 = max ($maxValueY1,
$this->series->serie ($serie)->maxValue ());
}
else
{
// Look for min/max for Y2 axis
if ($minValueY2 === null)
$minValueY2 = $this->series->serie ($serie)->minValue ();
$minValueY2 = min ($minValueY2,
$this->series->serie ($serie)->minValue ());
$maxValueY2 = max ($maxValueY2,
$this->series->serie ($serie)->maxValue ());
}
}
// Force the graph to display the 0 value
//if ($minValueY1 > 0 && $maxValueY1 > 0)
// $minValueY1 = 0;
//if ($minValueY1 < 0 && $maxValueY1 < 0)
// $minValueY1 = 0;
//if ($minValueY2 > 0 && $maxValueY2 > 0)
// $minValueY2 = 0;
//if ($minValueY2 < 0 && $maxValueY2 < 0)
// $minValueY2 = 0;
// Look for numeric or labeled axis
$numericalX = null;
$numericalY1 = null;
$numericalY2 = null;
foreach ($series as $serie=>$data)
{
$numericalKey = $this->series->serie ($serie)->numericalKey ();
if ($numericalX === null || $numericalX === true)
{
if ($numericalKey === false)
$numericalX = false;
else
$numericalX = true;
}
$numericalValue = $this->series->serie ($serie)->numericalValue ();
if (! $this->series->serie ($serie)->axisYsecondary ())
{
if ($numericalY1 === null || $numericalY1 === true)
{
if ($numericalValue === false)
$numericalY1 = false;
else
$numericalY1 = true;
}
}
else
{
if ($numericalY2 === null || $numericalY2 === true)
{
if ($numericalValue === false)
$numericalY2 = false;
else
$numericalY2 = true;
}
}
}
$this->axisX->numerical ($numericalX);
$this->axisY1->numerical ($numericalY1);
$this->axisY2->numerical ($numericalY2);
if ($minValueX !== null && $this->axisX->min () === null)
$this->axisX->min ($minValueX);
if ($maxValueX !== null && $this->axisX->max () === null)
$this->axisX->max ($maxValueX);
if ($minValueY1 !== null && $this->axisY1->min () === null)
$this->axisY1->min ($minValueY1);
if ($maxValueY1 !== null && $this->axisY1->max () === null)
$this->axisY1->max ($maxValueY1);
if ($minValueY2 !== null && $this->axisY2->min () === null)
$this->axisY2->min ($minValueY2);
if ($maxValueY2 !== null && $this->axisY2->max () === null)
$this->axisY2->max ($maxValueY2);
// Manage the styles for each serie
foreach ($this->series->getList () as $number=>$serie)
{
if ($this->series->serie ($serie)->style () === null)
$this->series->serie ($serie)->style ($this->style);
if ($this->series->serie ($serie)->style ()->palette () === null)
$this->series->serie ($serie)->style ()->palette (
$this->style->palette ());
$this->series->serie ($serie)->style ()->number ($number);
}
// Create the image
$gd = imagecreatetruecolor ($this->width, $this->height);
// Put the background color
imagefilledrectangle ($gd, 0, 0, $this->width - 1 , $this->height - 1 ,
\color::allocateFromText ($gd, $this->bgcolor));
// The coordinates of the free space. Will be modified each time something
// is drawing on the graph
// xtop, ytop, xbottom, ybottom
$free = array (0, 0, imagesx ($gd), imagesy ($gd));
// Add the title on top
$free = $this->title->draw ($gd, $free);
// Add the legend on right
$free = $this->legend->draw ($gd, $free, $this->series);
// If there is no title, add an offset of 10px to display correctely the
// first label of the Y axis
if ($free[1] === 0)
$free[1] = 10;
// Add the axis
// Need two passes as the X axis can modify the Y axes
$this->axisX->top ($free[1]);
$this->axisX->bottom ($free[3] - 1);
$this->axisY1->top ($free[1]);
$this->axisY2->top ($free[1]);
$this->axisY1->bottom ($free[3] - 1);
$this->axisY2->bottom ($free[3] - 1);
$Xleft = $this->axisY1->getWidth ($gd);
$Xright = $free[2] - $this->axisY2->getWidth ($gd);
$this->axisX->left ($Xleft);
$this->axisX->right ($Xright);
$Ybottom = $this->height - $this->axisX->getHeight ($gd);
$this->axisY1->right ($Xright);
$this->axisY1->bottom ($Ybottom);
//$this->axisY1->left (???);
$this->axisY2->right ($Xleft);
$this->axisY2->bottom ($Ybottom);
$this->axisY2->left ($Xright);
// Draw the axis
$this->axisX->draw ($gd);
$this->axisY1->draw ($gd);
$this->axisY2->draw ($gd);
// Add the graph part for each serie
$lastFree = $free;
foreach ($this->series->getList () as $number=>$serie)
{
// As the series are superposed, do not update the $free each time
if (! $this->series->serie ($serie)->axisYsecondary ())
$lastFree = $this->series->serie ($serie)->draw ($gd, $free,
$this->axisX, $this->axisY1);
else
$lastFree = $this->series->serie ($serie)->draw ($gd, $free,
$this->axisX, $this->axisY2);
}
$free = $lastFree;
imagepng ($gd);
imagedestroy ($gd);
}
/** Draw the graph to the screen with the previous defined parameters
*/
public function drawImage ()
{
header ('Content-Type: image/png');
$this->drawReal ();
}
/** Return the image coded in base64
* @return string The base64 string
*/
public function drawBase64 ()
{
ob_start ();
$this->drawReal ();
return base64_encode (ob_get_clean());
}
}
/* }}} */
/** The series objects */
class graphSeries
/* {{{ */
{
/** The series stored */
private $series = array ();
/** Return the serie object choosed. If doesn't exists, it is created before
* be returned
* @param string $name The name of the serie to create
*/
public function serie ($name)
{
if (is_integer ($name))
$name = dgettext ("domframework", "Serie")." $name";
if (! is_string ($name))
throw new \Exception (dgettext ("domframework",
"Can't get a serie if the name is not a string"),
406);
if (! array_key_exists ($name, $this->series))
$this->series[$name] = new graphSerie ($name);
return $this->series[$name];
}
/** Get the list of the defined series
*/
public function getList ()
{
return array_keys ($this->series);
}
/** Remove an existing serie
* @param string $name The name of the serie to remove
*/
public function remove ($name)
{
if (! is_string ($name))
throw new \Exception (dgettext ("domframework",
"Can't remove a serie if the name is not a string"),
406);
if (array_key_exists ($name, $this->series))
unset ($this->series[$name]);
}
}
/* }}} */
/** The serie object */
class graphSerie
/* {{{ */
{
/** The name of the serie
*/
private $name;
/** The data values for the serie
*/
private $data;
/** The numericalKey is true if all the keys are numeric
*/
private $numericalKey =null;
/** The minimum key of the serie
*/
private $minKey = null;
/** The maximum key of the serie
*/
private $maxKey = null;
/** The numericalValue is true if all the values are numeric
*/
private $numericalValue =null;
/** The minimum value of the serie
*/
private $minValue = null;
/** The maximum value of the serie
*/
private $maxValue = null;
/** The style object for the serie
*/
private $style;
/** The axis used to draw the serie.
* If false for main Y axis
* If true for secondary Y axis
*/
private $axisYsecondary = false;
/** When creating the serie, save the name
* @param string $name The name of the serie
*/
public function __construct ($name)
{
if (! is_string ($name))
throw new \Exception (dgettext ("domframework",
"Can't create a serie if the name is not a string"),
406);
$this->name = $name;
}
/** Set the data for the serie
If the parameter is not provided, return the actual $data value
* @param array|null $data The data to store in the serie
*/
public function data ($data = null)
{
if ($data === null)
return $this->data;
if (! is_array ($data))
throw new \Exception (dgettext ("domframework",
"Can't create a serie data if the value is not an array"),
406);
$this->data = $data;
$this->minmax ();
return $this;
}
/** Get the minimum and maximum values and keys
*/
private function minmax ()
{
if ($this->data === null)
return null;
foreach ($this->data as $key=>$value)
{
if ($this->minValue === null && is_numeric ($value))
$this->minValue = $value;
if ($this->minKey === null && is_numeric ($key))
$this->minKey = $key;
if (is_numeric ($value))
{
$this->minValue = min ($this->minValue, $value);
$this->maxValue = max ($this->maxValue, $value);
}
if (is_numeric ($key))
{
$this->minKey = min ($this->minKey, $key);
$this->maxKey = max ($this->maxKey, $key);
}
if (! is_numeric ($key) && $this->numericalKey === null)
$this->numericalKey = false;
if (! is_numeric ($value) && $value !== null &&
$this->numericalValue === null)
$this->numericalValue = false;
}
if ($this->numericalKey === null)
$this->numericalKey = true;
if ($this->numericalValue === null)
$this->numericalValue = true;
}
/** Set/get the numeric value of the serie
* If the parameter is not provided, return the actual state
* @param boolean|null The state of the numeric value
*/
public function numericalValue ($numericalValue = null)
{
if ($numericalValue === null)
return $this->numericalValue;
if (! is_bool ($numericalValue))
throw new \Exception (dgettext ("domframework",
"Invalid numericalValue provided to serie"), 406);
$this->numericalValue = $numericalValue;
return $this;
}
/** The minimum value of the serie
*/
public function minValue ()
{
if ($this->minValue === null && $this->data !== null)
$this->minmax ();
return $this->minValue;
}
/** The maximum value of the serie
*/
public function maxValue ()
{
if ($this->maxValue === null && $this->data !== null)
$this->minmax ();
return $this->maxValue;
}
/** Set/get the numeric key of the serie
* If the parameter is not provided, return the actual state
* @param boolean|null The state of the numeric key
*/
public function numericalKey ($numericalKey = null)
{
if ($numericalKey === null)
return $this->numericalKey;
if (! is_bool ($numericalKey))
throw new \Exception (dgettext ("domframework",
"Invalid numericalKey provided to serie"), 406);
$this->numericalKey = $numericalKey;
return $this;
}
/** The minimum key of the serie
*/
public function minKey ()
{
if ($this->minKey === null && $this->data !== null)
$this->minmax ();
return $this->minKey;
}
/** The maximum key of the serie
*/
public function maxKey ()
{
if ($this->maxKey === null && $this->data !== null)
$this->minmax ();
return $this->maxKey;
}
/** The number of elements in the serie
*/
public function count ()
{
return count ($this->data);
}
/** Set/Get the graph style for the serie
* If the parameter is not provided, return the actual state
* @param string|object|null $style The graph style
*/
public function style ($style = null)
{
if ($style === null)
return $this->style;
if (is_object ($style))
{
$this->style = clone $style;
return $this->style;
}
if (! is_string ($style) ||
! in_array ($style, array ("line", "points", "linePoints")))
throw new \Exception (dgettext ("domframework",
"Invalid style provided to serie"), 406);
$styleClass = "graphStyle".$style;
if ($this->style === null)
$this->style = new $styleClass ();
return $this->style;
}
/** The serie is based on the secondary Y axis
* Set the value if the parameter is provided, get the value if the parameter
* is not set
* @param boolean|null $axisYsecondary The Serie on secondary Y axis
*/
public function axisYsecondary ($axisYsecondary = null)
{
if ($axisYsecondary === null)
return $this->axisYsecondary;
if (! is_bool ($axisYsecondary))
throw new \Exception (dgettext ("domframework",
"Invalid axisYsecondary provided to graph axisYsecondary"),
406);
$this->axisYsecondary = $axisYsecondary;
return $this;
}
/** Draw the serie with the defined style class
* @param resource $gd The resource to modify
* @param array $free The free space coordinates on the graphic
* @param object $axisX The axis X used on the graph
* @param object $axisY The axis Y used on the graph
*/
public function draw ($gd, $free, $axisX, $axisY)
{
$this->style->draw ($gd, $free, $this->data, $axisX, $axisY);
}
}
/* }}} */
/** Read the data */
class graphData
/* {{{ */
{
/** Store the data when the user provided them. Store them in array form
*/
private $data;
/** The titles are on the first line
*/
private $titlesOnFirstLine = null;
/** The titles are on the first column
*/
private $titlesOnFirstColumn = null;
/** The data are stored horizontally
*/
private $horizontalData = null;
/** Get the data from an indexed array
* @param array $array The data array to graph
*/
public function arrayIndexed ($array)
{
$this->data = $array;
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"Invalid Array Parameter provided: not an array"),
406);
return $this;
}
/** Get the data from an associative array
* The associative array are provided by database results
* @param array $array The data array to graph
*/
public function arrayAssociative ($array)
{
if (! is_array ($array))
throw new \Exception (dgettext ("domframework",
"Invalid Array Parameter provided: not an array"),
406);
$titles = array ();
$this->data = array ();
foreach ($array as $line=>$lineArr)
{
foreach ($lineArr as $key=>$cell)
{
$titles[$key] = "";
$this->data[$line][] = $cell;
}
}
array_unshift ($this->data, array_keys ($titles));
return $this;
}
/** Get the data from a CSV string
* @param string $csv The CSV string
*/
public function csv ($csv)
{
$csv = trim ($csv);
$lines = preg_split ('/( *\R)+/s', $csv);
$this->data = array_map('str_getcsv', $lines);
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"Invalid CSV provided: not converted to array"),
406);
return $this;
}
/** Get the data from a JSON string
* @param string $json The JSON string
*/
public function json ($json)
{
$this->data = json_decode ($json, true);
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"Invalid JSON provided: not converted to array"),
406);
return $this;
}
/** Titles on first line
* Set the value if the parameter is provided, get the value if the parameter
* is not set
* @param boolean|null $titlesOnFirstLine The titles on first line
*/
public function titlesOnFirstLine ($titlesOnFirstLine = null)
{
if ($titlesOnFirstLine === null)
return $this->titlesOnFirstLine;
if (! is_bool ($titlesOnFirstLine))
throw new \Exception (dgettext ("domframework",
"Invalid titlesOnFirstLine provided to graph titlesOnFirstLine"),
406);
$this->titlesOnFirstLine = $titlesOnFirstLine;
return $this;
}
/** Titles on first column
* Set the value if the parameter is provided, get the value if the parameter
* is not set
* @param boolean|null $titlesOnFirstColumn The titles on first column
*/
public function titlesOnFirstColumn ($titlesOnFirstColumn = null)
{
if ($titlesOnFirstColumn === null)
return $this->titlesOnFirstColumn;
if (! is_bool ($titlesOnFirstColumn))
throw new \Exception (dgettext ("domframework",
"Invalid titlesOnFirstColumn provided to graph titlesOnFirstColumn"),
406);
$this->titlesOnFirstColumn = $titlesOnFirstColumn;
return $this;
}
/** The data are stored horizontally in the array
* Set the value if the parameter is provided, get the value if the parameter
* is not set
* @param boolean|null $horizontalData The data are stored horizontally
*/
public function horizontalData ($horizontalData = null)
{
if ($horizontalData === null)
return $this->horizontalData;
if (! is_bool ($horizontalData))
throw new \Exception (dgettext ("domframework",
"Invalid horizontalData provided to graph horizontalData"),
406);
$this->horizontalData = $horizontalData;
return $this;
}
/** Get the series in an array with the associated values
*/
public function getSeries ()
{
// 0. If there is no data to graph, nothing to do
if (count ($this->data) === 0)
return array ();
// 1. If $this->titlesOnFirstLine === null, look if the first line contains
// titles
if ($this->titlesOnFirstLine === null)
{
$this->titlesOnFirstLine = true;
if (count ($this->data) === 1)
$this->titlesOnFirstLine = false;
if (is_array ($this->data[0]))
{
foreach ($this->data[0] as $cell)
{
if (is_numeric ($cell))
{
$this->titlesOnFirstLine = false;
break;
}
}
}
else
{
$this->titlesOnFirstLine = false;
}
}
// 2. If $this->titlesOnFirstColumn === null, look if the first column
// contains titles
if ($this->titlesOnFirstColumn === null)
{
if (count ($this->data[0]) === 1)
$this->titlesOnFirstColumn = false;
else
{
$this->titlesOnFirstColumn = true;
foreach ($this->data as $lineArr)
{
if (is_numeric ($lineArr[0]))
{
$this->titlesOnFirstColumn = false;
break;
}
}
}
}
// 3. If $this->horizontalData === null, look for orientation with the
// titles states
if ($this->horizontalData === null)
{
if ($this->titlesOnFirstColumn === true ||
! array_key_exists (1, $this->data))
$this->horizontalData = true;
else
$this->horizontalData = false;
}
// 4. Create the series
$colTitles = array ();
$lineTitles = array ();
$series = array ();
foreach ($this->data as $linePos => $lineArr)
{
if (! is_array ($lineArr))
$lineArr = array ($lineArr);
if ($linePos === 0)
{
if ($this->titlesOnFirstLine)
{
$colTitles = $lineArr;
if ($this->horizontalData === false)
{
// First line with titles and vertical data: get the series names
$series = array_flip ($lineArr);
foreach ($series as &$value)
$value = array ();
if ($this->titlesOnFirstColumn)
array_shift ($series);
}
continue;
}
else
{
foreach ($lineArr as $i=>$value)
$colTitles[$i] = $i;
}
}
elseif (count ($lineArr) !== count ($colTitles))
throw new \Exception (sprintf (dgettext ("domframework",
"Invalid data provided: line %d doesn't have the same number ".
"of elements as the first line (%d != %d elements)"),
$linePos+1, count ($lineArr), count ($colTitles)), 406);
foreach ($lineArr as $colPos => $cell)
{
$cell = trim ($cell);
if ($colPos === 0)
{
if ($this->titlesOnFirstColumn)
{
$lineTitles[$linePos] = $cell;
if ($this->horizontalData === true)
{
$series[$cell] = array ();
}
continue;
}
else
{
$lineTitles[$linePos] = $linePos;
}
}
if (! is_numeric ($cell))
$cell = null;
else
$cell = $cell+0.0;
if ($this->horizontalData === false)
$series[$colTitles[$colPos]][$lineTitles[$linePos]] = $cell;
else
$series[$lineTitles[$linePos]][$colTitles[$colPos]] = $cell;
}
}
return $series;
}
}
/* }}} */
/** The graphTitle object */
class graphTitle
/* {{{ */
{
/** The title text
*/
private $text = null;
/** The TTF fontfile to use
*/
private $fontfile = null;
/** The font size to use
*/
private $fontsize = 14;
/** The title color
*/
private $color = "black";
/** The padding arround the title (in px)
*/
private $padding = 10;
/** Set the text of the title if the parameter is provided.
* Get the text of the title if the parameter is not provided
* @param string|null $text The text of the title
*/
public function text ($text = null)
{
if ($text === null)
return $this->text;
if (! is_string ($text) || strlen ($text) < 0 || strlen ($text) > 50)
throw new \Exception (dgettext ("domframework",
"Invalid text provided to graph title"), 406);
$this->text = $text;
return $this;
}
/** Set the fontfile of the title if the parameter is provided.
* Get the fontfile of the title if the parameter is not provided
* @param string|null $fontfile The fontfile of the title
*/
public function fontfile ($fontfile = null)
{
if ($fontfile === null)
return $this->fontfile;
if (! is_string ($fontfile) || strlen ($fontfile) < 0 ||
! file_exists ($fontfile) || ! is_readable ($fontfile))
throw new \Exception (dgettext ("domframework",
"Invalid fontfile provided to graph title"), 406);
$this->fontfile = $fontfile;
return $this;
}
/** Set the font size of the title if the parameter is provided.
* Get the font size of the title if the parameter is not provided
* @param integer|null $fontsize The font size of the title
*/
public function fontsize ($fontsize = null)
{
if ($fontsize === null)
return $this->fontsize;
if (! is_integer ($fontsize) || $fontsize < 2 || $fontsize > 100)
throw new \Exception (dgettext ("domframework",
"Invalid fontsize provided to graph title"), 406);
$this->fontsize = $fontsize;
return $this;
}
/** Set the color of the title if the parameter is provided.
* Get the color of the title if the parameter is not provided
* @param string|null $color The color of the title
*/
public function color ($color = null)
{
if ($color === null)
return $this->color;
if (! is_string ($color) ||
! in_array ($color, \color::colorList ()))
throw new \Exception (dgettext ("domframework",
"Invalid color provided to graph title"), 406);
$this->color = $color;
return $this;
}
/** Set the padding of the title if the parameter is provided.
* Get the padding of the title if the parameter is not provided
* @param integer|null $padding The padding of the title
*/
public function padding ($padding = null)
{
if ($padding === null)
return $this->padding;
if (! is_integer ($padding) || $padding < 0 || $padding > 200)
throw new \Exception (dgettext ("domframework",
"Invalid padding provided to graph title"), 406);
$this->padding = $padding;
return $this;
}
/** Draw the title in the $gd resource provided
* @param resource $gd The resource to modify
* @param array $free The free space coordinates on the graphic
* @return array the new free coordinates array
*/
public function draw ($gd, $free)
{
if ($this->text === null)
return $free;
// Look for the bounding box around the text. The bounding is not write on
// the image and return the coordinates for the text box
$bbox = imagettfbbox ($this->fontsize, 0, $this->fontfile, $this->text);
// Calculate the position of the text to be centered on the graph
// The padding is only on vertical : the x is centered
$x = floor (($free[2] - $free[0] - abs ($bbox[4] - $bbox[0])) / 2);
$y = ceil ($free[1] + abs ($bbox[5] - $bbox[1])) + $this->padding;
$x += $free[0];
$y += $free[1];
imagettftext ($gd, $this->fontsize, 0, $x, $y,
\color::allocateFromText ($gd, $this->color),
$this->fontfile, $this->text);
return array (intval ($free[0]), intval ($free[1] + $y + $this->padding),
intval ($free[2]), intval ($free[3]));
}
}
/* }}} */
/** The graphLegend object */
class graphLegend
/* {{{ */
{
/** Show the legend (no legend by default)
*/
private $show = false;
/** The TTF fontfile to use
*/
private $fontfile = null;
/** The font size to use
*/
private $fontsize = 10;
/** The legend color for the font
*/
private $color = "black";
/** The legend background-color
*/
private $bgcolor = "white";
/** The legend border color
*/
private $borderColor = "black";
/** The padding arround the title (in px)
*/
private $padding = 10;
/** Set the legend display status if the parameter is provided.
* Get the legend display status if the parameter is not provided
* @param boolean|null $show The legend display status
*/
public function show ($show = null)
{
if ($show === null)
return $this->show;
if (! is_bool ($show))
throw new \Exception (dgettext ("domframework",
"Invalid show value provided to graph legend"), 406);
$this->show = $show;
return $this;
}
/** Set the fontfile of the legend if the parameter is provided.
* Get the fontfile of the legend if the parameter is not provided
* @param string|null $fontfile The fontfile of the legend
*/
public function fontfile ($fontfile = null)
{
if ($fontfile === null)
return $this->fontfile;
if (! is_string ($fontfile) || strlen ($fontfile) < 0 ||
! file_exists ($fontfile) || ! is_readable ($fontfile))
throw new \Exception (dgettext ("domframework",
"Invalid fontfile provided to graph legend"), 406);
$this->fontfile = $fontfile;
return $this;
}
/** Set the font size of the legend if the parameter is provided.
* Get the font size of the legend if the parameter is not provided
* @param integer|null $fontsize The font size of the legend
*/
public function fontsize ($fontsize = null)
{
if ($fontsize === null)
return $this->fontsize;
if (! is_integer ($fontsize) || $fontsize < 2 || $fontsize > 100)
throw new \Exception (dgettext ("domframework",
"Invalid fontsize provided to graph legend"), 406);
$this->fontsize = $fontsize;
return $this;
}
/** Set the color of the legend if the parameter is provided.
* Get the color of the legend if the parameter is not provided
* @param string|null $color The color of the legend
*/
public function color ($color = null)
{
if ($color === null)
return $this->color;
if (! is_string ($color) ||
! in_array ($color, \color::colorList ()))
throw new \Exception (dgettext ("domframework",
"Invalid color provided to graph legend"), 406);
$this->color = $color;
return $this;
}
/** Set the background-color of the legend if the parameter is provided.
* Get the background-color of the legend if the parameter is not provided
* @param string|null $bgcolor The background-color of the legend
*/
public function bgcolor ($bgcolor = null)
{
if ($bgcolor === null)
return $this->bgcolor;
if (! is_string ($bgcolor) ||
! in_array ($bgcolor, \color::colorList ()))
throw new \Exception (dgettext ("domframework",
"Invalid bgcolor provided to graph legend"), 406);
$this->bgcolor = $bgcolor;
return $this;
}
/** Set the border color of the legend if the parameter is provided.
* Get the border color of the legend if the parameter is not provided
* @param string|null $borderColor The border color of the legend
*/
public function borderColor ($borderColor = null)
{
if ($borderColor === null)
return $this->borderColor;
if (! is_string ($borderColor) ||
! in_array ($borderColor, \color::colorList ()))
throw new \Exception (dgettext ("domframework",
"Invalid borderColor provided to graph legend"), 406);
$this->borderColor = $borderColor;
return $this;
}
/** Set the padding of the legend if the parameter is provided.
* Get the padding of the legend if the parameter is not provided
* @param integer|null $padding The padding of the legend
*/
public function padding ($padding = null)
{
if ($padding === null)
return $this->padding;
if (! is_integer ($padding) || $padding < 0 || $padding > 200)
throw new \Exception (dgettext ("domframework",
"Invalid padding provided to graph legend"), 406);
$this->padding = $padding;
return $this;
}
/** Draw the legend in the $gd resource provided
* @param resource $gd The resource to modify
* @param array $free The free space coordinates on the graphic
* @param object $series The series to graph
* @return array the new free coordinates array
*/
public function draw ($gd, $free, $series)
{
if ($this->show === false)
return $free;
// Look for maxmimum width of the labels
$maxwidth = 0;
$height = 0;
foreach ($series->getList () as $number=>$serie)
{
$bbox = imagettfbbox ($this->fontsize, 0, $this->fontfile, $serie);
$width = abs ($bbox[4] - $bbox[0]);
// TODO : If the serie name is too long, split it !
// 20px for the sample + the space before the label
if ((20 + $maxwidth) > (($free[2] - $free[0]) / 2))
throw new \Exception (dgettext ("domframework",
"The serie name in legend must not takes more than half of the graph"),
500);
if ($number > 0)
$height += $this->padding;
$height += abs ($bbox[5] - $bbox[1]);
$maxwidth = max ($maxwidth, $width);
}
$x1 = $free[2] - $maxwidth - 20 - $this->padding * 2;
$x2 = $free[2] - $this->padding;
$y1 = $free[1] + $this->padding;
$y2 = $y1 + $height + $this->padding;
// Size of the border : 1px
$border = 1;
// Draw the background rectangle
imagefilledrectangle ($gd, $x1, $y1, $x2, $y2,
\color::allocateFromText ($gd, $this->borderColor));
imagefilledrectangle ($gd, $x1+$border, $y1+$border,
$x2-$border, $y2-$border,
\color::allocateFromText ($gd, $this->bgcolor));
// Display the serie names
$y = $y1;
foreach ($series->getList () as $number=>$serie)
{
// Write the label
$bbox = imagettfbbox ($this->fontsize, 0, $this->fontfile, $serie);
$height = abs ($bbox[5] - $bbox[1]);
$y += $height;
imagettftext ($gd, $this->fontsize, 0,
$x1 + 30, intval ($y + $height / 2),
\color::allocateFromText ($gd, $this->color),
$this->fontfile, $serie);
// Draw the sample
$series->serie ($serie)->style ()->sample ($gd, $x1 + 15, $y);
$y += $this->padding;
}
$free = array ($free[0], $free[1], $x1 - 5, $free[3]);
return $free;
}
}
/* }}} */
/** The general axis management */
class graphAxisGeneral
/* {{{ */
{
/** The min value of the axis. Do not use it if the axis is composed of labels
*/
protected $min = null;
/** The max value of the axis. Do not use it if the axis is composed of labels
*/
protected $max = null;
/** The label max to display
*/
protected $labelMax;
/** The label min to display
*/
protected $labelMin;
/** The data displayed as values on the axis
*/
protected $data;
/** Set if the axis is only numerical (true) or is composed of labels (false)
*/
protected $numerical;
/** The minimum bottom position in pixels. Used on vertical axis
*/
protected $bottom;
/** The maximum top position in pixels. Used on vertical axis
*/
protected $top;
/** The minimum left position in pixels. Used on horizontal axis
*/
protected $left;
/** The maximum right position in pixels. Used on horizontal axis
*/
protected $right;
/** The fontfile to write the labels
*/
protected $fontfile;
/** The fontsize to write the labels
*/
protected $fontsize = 8;
/** Axis color
*/
protected $axisColor;
/** Grid color on the axis
* Can be set to null or "transparent" to not display the grid
*/
protected $gridColor;
/** Set the min value of the axis if the parameter is provided.
* Get the min value of the axis if the parameter is not provided
* @param integer|null $min The min value of the axis
*/
public function min ($min = null)
{
if ($min === null)
return $this->min;
if (! is_numeric ($min))
throw new \Exception (dgettext ("domframework",
"Invalid min provided to graph Axis")." ".get_class ($this), 406);
$this->min = $min;
return $this;
}
/** Set the max value of the axis if the parameter is provided.
* Get the max value of the axis if the parameter is not provided
* @param integer|null $max The max value of the axis
*/
public function max ($max = null)
{
if ($max === null)
return $this->max;
if (! is_numeric ($max))
throw new \Exception (dgettext ("domframework",
"Invalid max provided to graph Axis")." ".get_class ($this), 406);
$this->max = $max;
return $this;
}
/** Set the data of the axis if the parameter is provided.
* Get the data of the axis if the parameter is not provided
* @param array|null $data The data of the axis
*/
public function data ($data = null)
{
if ($data === null)
return $this->data;
if (! is_array ($data))
throw new \Exception (dgettext ("domframework",
"Invalid data provided to graph Axis")." ".get_class ($this), 406);
$this->data = $data;
if ($this->numerical === null)
{
// Look if the provided data are only numerical. Then define the numerical
// property
foreach ($data as $d)
{
if (! is_numeric ($d))
{
$this->numerical = false;
break;
}
}
if ($this->numerical === null)
$this->numerical = true;
}
return $this;
}
/** Set if the axis is numerical or composed of labels if the parameter is
* provided.
* Get if the axis is numerical if the parameter is not provided
* @param boolean|null $numerical the axis is numerical
*/
public function numerical ($numerical = null)
{
if ($numerical === null)
return $this->numerical;
if (! is_bool ($numerical))
throw new \Exception (dgettext ("domframework",
"Invalid numerical parameter provided to graph Axis")." ".
get_class ($this), 406);
$this->numerical = $numerical;
return $this;
}
/** Set the bottom position of the axis if the parameter is provided.
* Get the bottom position of the axis if the parameter is not provided
* @param integer|null $bottom The bottom position of the axis
*/
public function bottom ($bottom = null)
{
if ($bottom === null)
return $this->bottom;
if (! is_integer ($bottom) || $bottom < 0 || $bottom > 5000)
throw new \Exception (dgettext ("domframework",
"Invalid bottom provided to graph Axis")." ".get_class ($this), 406);
$this->bottom = $bottom;
return $this;
}
/** Set the top position of the axis if the parameter is provided.
* Get the top position of the axis if the parameter is not provided
* @param integer|null $top The top position of the axis
*/
public function top ($top = null)
{
if ($top === null)
return $this->top;
if (! is_integer ($top) || $top < 0 || $top > 5000)
throw new \Exception (dgettext ("domframework",
"Invalid top provided to graph Axis")." ".get_class ($this), 406);
$this->top = $top;
return $this;
}
/** Set the left position of the axis if the parameter is provided.
* Get the left position of the axis if the parameter is not provided
* @param integer|null $left The left position of the axis
*/
public function left ($left = null)
{
if ($left === null)
return $this->left;
if (! is_integer ($left) || $left < 0 || $left > 5000)
throw new \Exception (dgettext ("domframework",
"Invalid left provided to graph Axis")." ".get_class ($this), 406);
$this->left = $left;
return $this;
}
/** Set the right position of the axis if the parameter is provided.
* Get the right position of the axis if the parameter is not provided
* @param integer|null $right The right position of the axis
*/
public function right ($right = null)
{
if ($right === null)
return $this->right;
if (! is_integer ($right) || $right < 0 || $right > 5000)
throw new \Exception (dgettext ("domframework",
"Invalid right provided to graph Axis")." ".get_class ($this), 406);
$this->right = $right;
return $this;
}
/** Set the fontfile of the labels if the parameter is provided.
* Get the fontfile of the labels if the parameter is not provided
* @param string|null $fontfile The fontfile of the title
*/
public function fontfile ($fontfile = null)
{
if ($fontfile === null)
return $this->fontfile;
if (! is_string ($fontfile) || strlen ($fontfile) < 0 ||
! file_exists ($fontfile) || ! is_readable ($fontfile))
throw new \Exception (dgettext ("domframework",
"Invalid fontfile provided to graph title"), 406);
$this->fontfile = $fontfile;
return $this;
}
/** Set the font size of the labels if the parameter is provided.
* Get the font size of the labels if the parameter is not provided
* @param integer|null $fontsize The font size of the title
*/
public function fontsize ($fontsize = null)
{
if ($fontsize === null)
return $this->fontsize;
if (! is_integer ($fontsize) || $fontsize < 2 || $fontsize > 100)
throw new \Exception (dgettext ("domframework",
"Invalid fontsize provided to graph title"), 406);
$this->fontsize = $fontsize;
return $this;
}
/** Set the axis color if the parameter is provided.
* Get the axis color if the parameter is not provided
* @param string|null $axiscolor The axis color
*/
public function axisColor ($axisColor = null)
{
if ($axisColor === null)
return $this->axisColor;
if (! is_string ($axisColor) ||
! in_array ($axisColor, \color::colorList ()))
throw new \Exception (dgettext ("domframework",
"Invalid axisColor provided to graph axis"), 406);
$this->axisColor = $axisColor;
return $this;
}
/** Set the grid color if the parameter is provided.
* Get the grid color if the parameter is not provided
* @param string|null $gridcolor The grid color
*/
public function gridColor ($gridColor = null)
{
if ($gridColor === null)
return $this->gridColor;
if (! is_string ($gridColor) ||
! in_array ($gridColor, \color::colorList ()))
throw new \Exception (dgettext ("domframework",
"Invalid gridColor provided to graph grid"), 406);
$this->gridColor = $gridColor;
return $this;
}
/** Calculate the labels that will be displayed on the axis
* @param integer $nbMaxValues The maximum number of values to return
* @return array The array of labels to display
*/
protected function labels ($nbMaxValues)
{
// Activate the debug of this method
$deb = false;
if (! is_int ($nbMaxValues))
throw new \Exception (
"Invalid parameter nbMaxValues provided to graphAxisGeneral::labels",
500);
if ($deb) echo "=========== LABELS\n";
if ($this->min > 0)
$minLabel = $this->min * 0.90;
else
$minLabel = $this->min * 1.05;
if ($this->max > 0)
$maxLabel = $this->max * 1.05;
else
$maxLabel = $this->max * 0.90;
$minBase = intval (log10 ($minLabel)) - 1;
$maxBase = intval (log10 ($maxLabel)) - 1;
$base = max ($minBase, $maxBase);
if ($deb) echo "minBase=$minBase, maxBase=$maxBase ===> base = $base\n";
if ($base < 0 && $base > -1)
$base = $base - 1;
// The while loop reduce the base to not explode the number of labels
// If there is too much labels, remove one digit and retry
while (1)
{
$this->labelMin = null;
$this->labelMax = null;
$min = round ($minLabel, -1 * $base);
$max = round ($maxLabel, -1 * $base);
if ($deb) echo "min = $min, max = $max\n";
$scale = pow (10, $base);
if ($deb) echo "BASE=".($base).", SCALE = $scale\n";
if ($scale === 0 || $scale === 0.0)
die ("Scale equal 0 on line ".__LINE__."\n");
$labels = array ();
if ($this->min <= 0 && $this->max >= 0)
{
// Return the 0 label and the values arround it
$zeroAlreadyDraw = false;
for ($i = 0 ;
bccomp ($i, 1.2 * $max, abs ($base) + 1) < 1 ;
$i += $scale)
{
if ($i === 0)
$zeroAlreadyDraw = true;
if ($deb) echo "Values with Zero : add pos val $i\n";
$labels[] = $i;
}
for ($i = 0 ;
bccomp ($i, 1.4 * $min, abs ($base) + 1) >= 0 ;
$i -= $scale)
{
if ($zeroAlreadyDraw === true && $i === 0)
continue;
if ($deb) echo "Values with Zero : add neg val $i\n";
$labels[] = $i;
}
}
else
{
// No 0 Axis : From $this->min to $this->max
for ($i = $min ;
bccomp ($i, $max, abs ($base) + 1) < 1 ;
$i += $scale)
{
if ($deb) echo "Values no Zero : add val $i\n";
$labels[] = $i;
}
}
if (count ($labels) <= $nbMaxValues)
{
foreach ($labels as &$label)
{
if ($base < 0)
$label = sprintf ("%0.".intval (abs ($base))."f", $label);
else
$label = sprintf ("%".intval ($base)."d", $label);
if ($this->labelMin === null ||
bccomp ($this->labelMin, $label, abs ($base) + 1) >= 0)
$this->labelMin = $label;
if ($this->labelMax === null ||
bccomp ($this->labelMax, $label, abs ($base) + 1) <= 0)
$this->labelMax = $label;
}
if (bccomp ($this->labelMin, $this->min, abs ($base) + 1) > 0)
{
// Add a label in the minimum
$this->labelMin = $this->labelMin - $scale;
if ($deb) echo "Force Add Min $this->labelMin\n";
if ($base < 0)
$labels[] = sprintf ("%0.".intval (abs ($base))."f",
$this->labelMin);
else
$labels[] = sprintf ("%".intval ($base)."d", $this->labelMin);
}
if (bccomp ($this->labelMax, $this->max, abs ($base) + 1) < 0)
{
$this->labelMax = $this->labelMax + $scale;
if ($deb) echo "Force Add Max $this->labelMax\n";
if ($base < 0)
$labels[] = sprintf ("%0.".intval (abs ($base))."f",
$this->labelMax);
else
$labels[] = sprintf ("%".intval ($base)."d", $this->labelMax);
}
if ($this->labelMin > $this->min)
die ("labelMin > min ($this->labelMin > $this->min)\n");
if ($this->labelMax < $this->max)
die ("labelMax < max ($this->labelMax < $this->max)\n");
if (count ($labels) <= $nbMaxValues)
{
$labels = array_unique ($labels);
if ($deb) print_r ($labels);
return $labels;
}
}
if ($deb) echo "LOOP == ".count ($labels)." > $nbMaxValues ==========\n";
$base = $base + 0.1;
}
}
}
/* }}} */
/** The graph Axis Horizontal class */
class graphAxisHorizontal extends graphAxisGeneral
/* {{{ */
{
/** Calculate the position in pixels for a value
* If the value is out of range, return null to not draw the point
* @param string|float|integer $value The value to position
*/
public function position ($value)
{
if ($value === null)
return null;
if (! is_numeric ($value) && ! is_string ($value))
throw new \Exception (dgettext ("domframework",
"Invalid value provided to graph Axis for position")." ".
get_class ($this), 406);
if ($this->numerical === null)
throw new \Exception (dgettext ("domframework",
"No numerical type defined for Axis")." ".get_class ($this), 406);
if ($this->numerical)
{
// Numerical axis, use a standard scale
if ($value < $this->min || $value > $this->max)
return null;
if (($this->max - $this->min) == 0)
$dividor = 1;
else
$dividor = ($this->max - $this->min);
$scale = ($value - $this->min) / $dividor;
return intval ($this->left + $scale * ($this->right - $this->left));
}
else
{
// Label axis, count them
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"No data defined for Axis")." ".get_class ($this), 406);
$pos = array_search ($value, $this->data);
if ($pos === false)
return null;
$width = ($this->right - $this->left) / count ($this->data);
return intval ($this->left + $width * $pos + $width / 2);
}
}
/** Calculate the positionMin, used for labeled axies
* If the value is out of range, return null to not draw the point
* @param string|float|integer $value The value to position
*/
public function positionMin ($value)
{
if ($this->numerical)
return $posCenter;
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"No data defined for Axis")." ".get_class ($this), 406);
$pos = array_search ($value, $this->data);
if ($pos === false)
return null;
$width = ($this->right - $this->left) / count ($this->data);
return intval ($this->left + $width * $pos);
}
/** Calculate the positionMax, used for labeled axies
* If the value is out of range, return null to not draw the point
* @param string|float|integer $value The value to position
*/
public function positionMax ($value)
{
$posCenter = $this->position ($value);
if ($this->numerical)
return $posCenter;
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"No data defined for Axis")." ".get_class ($this), 406);
$pos = array_search ($value, $this->data);
if ($pos === false)
return null;
$width = ($this->right - $this->left) / count ($this->data);
return intval ($this->left + $width * $pos + $width);
}
}
/* }}} */
/** The X axis management */
class graphAxisX extends graphAxisHorizontal
/* {{{ */
{
/** The angle choosed to draw the graph
*/
private $angle;
/** The padding between the label and the axis
*/
private $padding = 7;
/** The heigth of the labels + padding (it is the base of the graph) in pixels
*/
private $height;
/** The number of chars to be displayed in one label
*/
protected $nbcharsLabel = 0;
/** Look for the height of the X axis based on the angle of the text when it
* will be drawn
*/
public function getHeight ($gd)
{
// Look for the angle of the value. Start Horizontally (angle=0), then
// try 45°, then finish at 90°. As all the values must in the same angle,
// test all the values. If one is bad, change the angle and retry all the
// values
$width = null;
if ($this->numerical)
{
if ($this->max === null)
throw new \Exception (dgettext ("domframework",
"The max is not defined for graphAxisHorizontal"), 406);
$powMax = intval (log10 ($this->max));
$tenPercent = round ($this->max / pow (10, $powMax), 1) + 0.1;
$labelMax = $tenPercent * pow (10, $powMax);
$this->nbcharsLabel = strlen ($labelMax);
$bbox = imagettfbbox ($this->fontsize, $this->angle, $this->fontfile,
$labelMax);
$height = abs ($bbox[4] - $bbox[0]);
$this->height = $height + 2 * $this->padding;
return $this->height;
}
else
{
if ($this->data === null)
return 0;
foreach (array (0, 45, 90) as $this->angle)
{
$bboxMaxHeight = 0;
foreach ($this->data as $key=>$value)
{
if ($width === null)
$width = $this->positionMax ($value) - $this->positionMin ($value);
// Look for the bounding box around the text. The bounding is not
// write on the image and return the coordinates for the text box
$bbox = imagettfbbox ($this->fontsize, $this->angle, $this->fontfile,
$value);
if (abs ($bbox[4] - $bbox[0]) > $width)
continue 2;
$bboxMaxHeight = max ($bboxMaxHeight, abs ($bbox[5] - $bbox[1]));
}
// All the values are OK : we have found the angle : break the angle
// loop
break;
}
}
$this->height = $bboxMaxHeight + 2 * $this->padding;
return $bboxMaxHeight + 2 * $this->padding;
}
/** Draw the axis
*/
public function draw ($gd)
{
$axisColor = \color::allocateFromText ($gd, $this->axisColor);
if ($this->numerical)
{
if ($this->angle === null)
$this->getHeight ($gd);
if ($this->data === null)
return;
foreach ($this->data as $key=>$value)
{
$position = $this->position ($value);
// Draw the labels
$bbox = imagettfbbox ($this->fontsize, $this->angle, $this->fontfile,
$value);
$width = abs ($bbox[4] - $bbox[0]);
$x = $position - $width / 2;
$y = $this->bottom - $this->padding;
// The font color is forced to black
imagettftext ($gd, $this->fontsize, $this->angle, $x, $y,
\color::allocateFromText ($gd, "black"),
$this->fontfile, $value);
// Draw the scale
imageline ($gd,
$position, $this->bottom - $this->height + 1,
$position,
$this->bottom - $this->height + 1 + $this->padding,
$axisColor);
// Draw the grid
$this->drawGrid ($gd, $this->bottom - $this->height, $position);
}
// Draw the axis
$y = $this->bottom - $this->height + 1;
imageline ($gd, $this->left, $y, $this->right, $y, $axisColor);
}
else
{
if ($this->angle === null)
$this->getHeight ($gd);
if ($this->data === null)
return;
foreach ($this->data as $key=>$value)
{
$position = $this->position ($value);
// Draw the labels
$bbox = imagettfbbox ($this->fontsize, $this->angle, $this->fontfile,
$value);
$width = abs ($bbox[4] - $bbox[0]);
$x = $position - $width / 2;
$y = $this->bottom - $this->padding;
// The font color is forced to black
imagettftext ($gd, $this->fontsize, $this->angle, $x, $y,
\color::allocateFromText ($gd, "black"),
$this->fontfile, $value);
// Draw the separators
$y = $this->bottom - $this->height + 1;
$xmin = $this->positionMin ($value);
$xmax = $this->positionMax ($value);
imageline ($gd, $xmin, $y, $xmin, $y + $this->padding, $axisColor);
imageline ($gd, $xmax, $y, $xmax, $y + $this->padding, $axisColor);
// Draw the grid
$this->drawGrid ($gd, $this->bottom - $this->height, $position);
}
// Draw the axis
$y = $this->bottom - $this->height + 1;
imageline ($gd, $this->left, $y, $this->right, $y, $axisColor);
}
}
/** Draw the grid
* @param resource $gd The resource to modify
* @param integer $width The width of the labels on the axis
* @param integer|float $position The position to draw
*/
protected function drawGrid ($gd, $width, $position)
{
if ($this->gridColor === null || $this->gridColor === "transparent")
return;
$gridColor = \color::allocateFromText ($gd, $this->gridColor);
if ($position === null)
return;
$y = $this->bottom - $this->height;
imageline ($gd, $position, $y, $position, $this->top, $gridColor);
}
}
/* }}} */
/** Manage the vertical axis */
class graphAxisVertical extends graphAxisGeneral
/* {{{ */
{
/** The angle choosed to draw the graph
*/
private $angle;
/** The padding between the label and the axis
*/
protected $padding = 7;
/** The width of the labels + padding (it is the base of the graph) in pixels
*/
protected $width;
/** The number of chars to be displayed in one label
*/
protected $nbcharsLabel = 0;
/** Look for the width of the Y axis
*/
public function getWidth ($gd)
{
if ($this->numerical)
{
if ($this->max === null)
throw new \Exception (dgettext ("domframework",
"The max is not defined for graphAxisVertical"), 406);
// Look at the minimum distance between two labeled values
$bbox = imagettfbbox ($this->fontsize, 0, $this->fontfile, "NOT");
$height = abs ($bbox[5] - $bbox[1]) + $this->padding;
for ($nbMaxValues = 10 ; $nbMaxValues > 2 ; $nbMaxValues--)
{
if ($nbMaxValues * $height < abs ($this->top - $this->bottom))
break;
}
$labels = $this->labels ($nbMaxValues);
$labelBiggest = "";
$this->nbcharsLabel = 0;
foreach ($labels as $label)
{
if (strlen ($label) > $this->nbcharsLabel)
{
$this->nbcharsLabel = strlen ($label);
$labelBiggest = $label;
}
}
$bbox = imagettfbbox ($this->fontsize, $this->angle, $this->fontfile,
$labelBiggest);
$width = abs ($bbox[4] - $bbox[0]);
$this->width = $width + 2 * $this->padding;
return $this->width;
}
else
{
if ($this->data === null)
return $this->padding;
die ("TODO : getWidth in labeled line ".__LINE__."\n");
}
}
/** Calculate the position in pixels for a value
* If the value is out of range, return null to not draw the point
* @param string|float|integer $value The value to position
*/
public function position ($value)
{
if ($value === null)
return null;
if (! is_numeric ($value) && ! is_string ($value))
throw new \Exception (dgettext ("domframework",
"Invalid value provided to graph Axis for position")." ".
get_class ($this), 406);
if ($this->numerical === null)
throw new \Exception (dgettext ("domframework",
"No numerical type defined for Axis")." ".get_class ($this), 406);
if ($this->numerical)
{
// Numerical axis, use a standard scale
if ($value > $this->labelMax || $value < $this->labelMin)
return null;
$scale = ($value - $this->labelMin) / ($this->labelMax - $this->labelMin);
$pos = intval ($this->bottom + $scale * ($this->top - $this->bottom));
return $pos;
}
else
{
// Label axis, count them
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"No data defined for Axis")." ".get_class ($this), 406);
$pos = array_search ($value, $this->data);
if ($pos === false)
return null;
$width = ($this->top - $this->bottom) / count ($this->data);
$pos = intval ($this->bottom + $width * $pos + $width / 2);
return $pos;
}
}
/** Calculate the positionMin, used for labeled axies
* If the value is out of range, return null to not draw the point
* @param string|float|integer $value The value to position
*/
public function positionMin ($value)
{
if ($this->numerical)
return $posCenter;
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"No data defined for Axis")." ".get_class ($this), 406);
$pos = array_search ($value, $this->data);
if ($pos === false)
return null;
$width = ($this->top - $this->bottom) / count ($this->data);
return intval ($this->bottom + $width * $pos);
}
/** Calculate the positionMax, used for labeled axies
* If the value is out of range, return null to not draw the point
* @param string|float|integer $value The value to position
*/
public function positionMax ($value)
{
$posCenter = $this->position ($value);
if ($this->numerical)
return $posCenter;
if (! is_array ($this->data))
throw new \Exception (dgettext ("domframework",
"No data defined for Axis")." ".get_class ($this), 406);
$pos = array_search ($value, $this->data);
if ($pos === false)
return null;
$width = ($this->top - $this->bottom) / count ($this->data);
return intval ($this->bottom + $width * $pos + $width);
}
/** Draw the axis labels and lines
*/
public function draw ($gd)
{
$axisColor = \color::allocateFromText ($gd, $this->axisColor);
if ($this->numerical)
{
// Look at the minimum distance between two labeled values
$bbox = imagettfbbox ($this->fontsize, 0, $this->fontfile, "NOT");
$height = abs ($bbox[5] - $bbox[1]) + $this->padding;
for ($nbMaxValues = 10 ; $nbMaxValues > 2 ; $nbMaxValues--)
{
if ($nbMaxValues * $height < abs ($this->top - $this->bottom))
break;
}
$width = $this->getWidth ($gd);
$labels = $this->labels ($nbMaxValues);
if (count ($labels) > $nbMaxValues)
die ("Too much labels to display (".
count ($labels)." > $nbMaxValues)\n");
foreach ($labels as $label)
{
$this->drawOne ($gd, $width, $label);
$this->drawGrid ($gd, $width, $label);
}
$this->drawAxis ($gd, $width);
}
else
{
// Labeled
// If there is no data, there is nothing to draw : return
if ($this->data === null)
return;
die ("graphAxisVertical::draw labeled TBD line ".__LINE__."\n");
}
}
}
/* }}} */
/** The Y1 axis management */
class graphAxisY1 extends graphAxisVertical
/* {{{ */
{
/** Draw one value on the axis
* @param resource $gd The resource to modify
* @param integer|float $value The value to draw
* @param integer $width The width of the labels on the axis
*/
protected function drawOne ($gd, $width, $val)
{
$axisColor = \color::allocateFromText ($gd, $this->axisColor);
if ($this->numerical)
{
// Do not allow the label to be longer than $this->max
if (strlen ($val) > $this->nbcharsLabel)
$itmp = rtrim (substr ($val, 0, $this->nbcharsLabel), ".");
else
$itmp = $val;
// Write the labels align to right
$bbox = imagettfbbox ($this->fontsize, 0, $this->fontfile, $itmp);
$labelwidth = abs ($bbox[4] - $bbox[0]) + $this->padding;
$labelheight = abs ($bbox[5] - $bbox[1]);
$y = $this->position ($val);
if ($y === null)
return;
// The color is forced to black
imagettftext ($gd, $this->fontsize, 0,
$width - $labelwidth,
$y + $labelheight / 2,
\color::allocateFromText ($gd, "black"),
$this->fontfile, $itmp);
// Display the separators
imageline ($gd, $width - $this->padding, $y,
$width, $y, $axisColor);
}
else
{
die ("graphAxisY1:: drawOne NOT numerical line ".__LINE__."\n");
}
}
/** Draw the axis
* @param resource $gd The resource to modify
* @param integer $width The width of the labels on the axis
*/
protected function drawAxis ($gd, $width)
{
$axisColor = \color::allocateFromText ($gd, $this->axisColor);
imageline ($gd, $width, $this->bottom, $width, $this->top, $axisColor);
}
/** Draw the grid
* @param resource $gd The resource to modify
* @param integer $width The width of the labels on the axis
* @param integer|float $val The value to draw
*/
protected function drawGrid ($gd, $width, $val)
{
if ($this->gridColor === null || $this->gridColor === "transparent")
return;
$gridColor = \color::allocateFromText ($gd, $this->gridColor);
if ($this->numerical)
{
$y = $this->position ($val);
if ($y === null)
return;
imageline ($gd, $width, $y, $this->right, $y, $gridColor);
}
else
{
die ("graphAxisY1:: drawGrid NOT numerical line ".__LINE__."\n");
}
}
}
/* }}} */
/** The Y2 axis management */
class graphAxisY2 extends graphAxisVertical
/* {{{ */
{
/** Draw one value on the axis
* @param resource $gd The resource to modify
* @param integer|float $value The value to draw
* @param integer $width The width of the labels on the axis
*/
protected function drawOne ($gd, $width, $val)
{
$axisColor = \color::allocateFromText ($gd, $this->axisColor);
if ($this->numerical)
{
// Do not allow the label to be longer than $this->max
if (strlen ($val) > $this->nbcharsLabel)
$itmp = rtrim (substr ($val, 0, $this->nbcharsLabel), ".");
else
$itmp = $val;
// Write the labels align to left
$bbox = imagettfbbox ($this->fontsize, 0, $this->fontfile, $itmp);
$labelwidth = abs ($bbox[4] - $bbox[0]) + $this->padding;
$labelheight = abs ($bbox[5] - $bbox[1]);
$y = $this->position ($val);
if ($y === null)
return;
// The color is forced to black
imagettftext ($gd, $this->fontsize, 0,
$this->left + $this->padding + 3,
$y + $labelheight / 2,
\color::allocateFromText ($gd, "black"),
$this->fontfile, $itmp);
// Display the separators
imageline ($gd, $this->left, $y,
$this->left + $this->padding, $y, $axisColor);
}
else
{
die ("graphAxisY2:: drawOne NOT numerical line ".__LINE__."\n");
}
}
/** Draw the axis
* @param resource $gd The resource to modify
* @param integer $width The width of the labels on the axis
*/
protected function drawAxis ($gd, $width)
{
$axisColor = \color::allocateFromText ($gd, $this->axisColor);
imageline ($gd, $this->left, $this->bottom,
$this->left, $this->top, $axisColor);
}
/** Draw the grid
* @param resource $gd The resource to modify
* @param integer $width The width of the labels on the axis
* @param integer|float $val The value to draw
*/
protected function drawGrid ($gd, $width, $val)
{
// The grid can't be graphed for Y2 axis : only the Y1 axis is allowed
return;
}
}
/* }}} */
/** The graphStyleLine : draw a graph with lines */
class graphStyleLinePoints
/* {{{ */
{
/** The line color. To hide the lines, choose "transparent"
*/
protected $lineColor;
/** The point color background. To hide the points, choose "transparent"
*/
protected $pointBgcolor;
/** The point color border
*/
protected $pointColor;
/** The point shape (square, circle, triangle, lozenge)
*/
protected $pointShape;
/** The point width in pixel
*/
protected $pointWidth;
/** The number of the colors/shapes to use
*/
protected $number;
/** The allowed shapes */
protected $allowedShapes = array ("square", "circle", "triangle", "lozenge");
/** The palette to use */
protected $palette;
/** Return the name of the style */
public function name ()
{
return "lineAndPoints";
}
/** Set the line color if the parameter is provided.
* Get the line color if the parameter is not provided
* @param string|null $lineColor The line color
*/
public function lineColor ($lineColor = null)
{
if ($lineColor === null)
return $this->lineColor;
if (! is_string ($lineColor) ||
($lineColor !== "transparent" &&
! in_array ($lineColor, \color::colorList ())))
throw new \Exception (dgettext ("domframework",
"Invalid lineColor provided to line style"), 406);
$this->lineColor = $lineColor;
return $this;
}
/** Set the palette to use if the parameter is provided
* Get the palette if the parameter is not provided
* @param string|null $palette The palette to use
*/
public function palette ($palette = null)
{
if ($palette === null)
return $this->palette;
if (! is_string ($palette))
throw new \Exception (dgettext ("domframework",
"Invalid palette provided to line style"), 406);
$this->palette = $palette;
return $this;
}
/** Set the point background color if the parameter is provided.
* Get the point background color if the parameter is not provided
* @param string|null $pointBgcolor The point background color
*/
public function pointBgcolor ($pointBgcolor = null)
{
if ($pointBgcolor === null)
return $this->pointBgcolor;
if (! is_string ($pointBgcolor) ||
($pointBgcolor !== "transparent" &&
! in_array ($pointBgcolor, \color::colorList ())))
throw new \Exception (dgettext ("domframework",
"Invalid pointBgcolor provided to line style"), 406);
$this->pointBgcolor = $pointBgcolor;
return $this;
}
/** Set the point border color if the parameter is provided.
* Get the point border color if the parameter is not provided
* @param string|null $pointColor The point border color
*/
public function pointColor ($pointColor = null)
{
if ($pointColor === null)
return $this->pointColor;
if (! is_string ($pointColor) ||
($pointColor !== "transparent" &&
! in_array ($pointColor, \color::colorList ())))
throw new \Exception (dgettext ("domframework",
"Invalid pointColor provided to line style"), 406);
$this->pointColor = $pointColor;
return $this;
}
/** Set the point shape if the parameter is provided.
* Get the point shape if the parameter is not provided
* @param string|null $pointShape The point shape
*/
public function pointShape ($pointShape = null)
{
if ($pointShape === null)
return $this->pointShape;
if (! is_string ($pointShape) ||
! in_array ($pointShape, $this->allowedShapes))
throw new \Exception (dgettext ("domframework",
"Invalid pointShape provided to line style"), 406);
$this->pointShape = $pointShape;
return $this;
}
/** Set the point width if the parameter is provided.
* Get the point width if the parameter is not provided
* @param string|null $pointWidth The point width
*/
public function pointWidth ($pointWidth = null)
{
if ($pointWidth === null)
return $this->pointWidth;
if (! is_integer ($pointWidth) || $pointWidth < 3 || $pointWidth > 20)
throw new \Exception (dgettext ("domframework",
"Invalid pointWidth provided to line style"), 406);
$this->pointWidth = $pointWidth;
return $this;
}
/** Select the colors, shapes by the serie number.
* Do not change any property if the property is already defined
* If the parameter is not provided, return the value
* @param integer|null $number The serie number
*/
public function number ($number = null)
{
if ($number === null)
return $this->number;
if (! is_int ($number) || $number < 0)
throw new \Exception (dgettext ("domframework",
"Invalid number provided to line style number"), 406);
$this->number = $number;
if ($this->pointShape === null)
$this->pointShape = $this->allowedShapes[
($number%count($this->allowedShapes))];
$palette = graphPalette::getPalette ($this->palette);
if ($this->pointBgcolor === null)
$this->pointBgcolor = $palette[($number%count ($palette))]["bgcolor"];
if ($this->pointColor === null)
$this->pointColor = $palette[($number%count ($palette))]["color"];
if ($this->lineColor === null)
$this->lineColor = $palette[($number%count ($palette))]["color"];
}
/** Draw in the $gd resource, in the $free array, the data with the parameter
* of the style
* @param resource $gd The resource to modify
* @param array $free The free space coordinates on the graphic
* @param array $data The data to graph
* @param object $axisX The X axis used to graph
* @param object $axisY The Y axis used to graph
*/
public function draw ($gd, $free, $data, $axisX, $axisY)
{
if ($this->lineColor !== "transparent")
$lineColor = \color::allocateFromText ($gd, $this->lineColor);
$lastX = null;
$lastY = null;
foreach ($data as $key=>$value)
{
$posX = $axisX->position ($key);
$posY = $axisY->position ($value);
if ($posX === null || $posY === null)
{
// NULL position : skip the point
$lastX = null;
$lastY = null;
continue;
}
// Draw the lines between points (except if the last point was null, or
// if the line color is "transparent")
if ($lastX !== null && $lastY !== null &&
$this->lineColor !== "transparent")
{
imageline ($gd, $lastX, $lastY, $posX, $posY, $lineColor);
// Redraw the old point which was scratch by the new created line
$this->drawPoint ($gd, $lastX, $lastY);
}
if ($lastX === null)
$lastX = $posX;
if ($lastY === null)
$lastY = $posY;
// Draw the point. Will overwrite the lines
if ($this->pointWidth === null)
$this->pointWidth = 6;
$this->drawPoint ($gd, $posX, $posY);
$lastX = $posX;
$lastY = $posY;
}
}
/** Draw a point defined in the property of the class
* @param resource $gd The resource to modify
* @param integer $posX The X position to draw the point
* @param integer $posY The Y position to draw the point
*/
private function drawPoint ($gd, $posX, $posY)
{
if ($this->pointColor !== "transparent")
$pointColor = \color::allocateFromText ($gd, $this->pointColor);
if ($this->pointBgcolor !== "transparent")
$pointBgcolor = \color::allocateFromText ($gd, $this->pointBgcolor);
$half = intval ($this->pointWidth / 2);
switch ($this->pointShape)
{
case "circle":
if ($this->pointColor !== "transparent")
imageellipse ($gd, $posX, $posY, $this->pointWidth + 2,
$this->pointWidth + 2, $pointColor);
if ($this->pointBgcolor !== "transparent")
imagefilledellipse ($gd, $posX, $posY, $this->pointWidth,
$this->pointWidth, $pointBgcolor);
break;
case "lozenge":
if ($this->pointColor !== "transparent")
imagepolygon ($gd, array ($posX - $half - 2, $posY,
$posX, $posY - $half - 2,
$posX + $half + 2, $posY,
$posX, $posY + $half + 2),
4, $pointColor);
if ($this->pointBgcolor !== "transparent")
imagefilledpolygon ($gd, array ($posX - $half, $posY,
$posX, $posY - $half,
$posX + $half, $posY,
$posX, $posY + $half),
4, $pointBgcolor);
break;
case "square":
if ($this->pointColor !== "transparent")
imagerectangle ($gd, $posX - $half - 1, $posY - $half - 1,
$posX + $half + 1, $posY + $half + 1,
$pointColor);
if ($this->pointBgcolor !== "transparent")
imagefilledrectangle ($gd, $posX - $half, $posY - $half,
$posX + $half, $posY + $half, $pointBgcolor);
break;
case "triangle":
if ($this->pointColor !== "transparent")
imagepolygon ($gd, array ($posX - $half - 2, $posY + $half + 2,
$posX, $posY - $half - 4,
$posX + $half + 2, $posY + $half + 2),
3, $pointColor);
if ($this->pointBgcolor !== "transparent")
imagefilledpolygon ($gd, array ($posX - $half, $posY + $half,
$posX, $posY - $half,
$posX + $half, $posY + $half),
3, $pointBgcolor);
break;
default:
throw new \Exception (dgettext ("domframework",
"Unknown pointShape for serie"), 406);
}
}
/** Draw a sample of the style for the legend
* @param resource $gd The resource to modify
* @param integer $x The central position of the sample in x
* @param integer $y The central position of the sample in y
*/
public function sample ($gd, $x, $y)
{
if ($this->lineColor !== "transparent")
{
$lineColor = \color::allocateFromText ($gd, $this->lineColor);
imageline ($gd, $x-10, $y, $x+10, $y, $lineColor);
}
if ($this->pointWidth === null)
$this->pointWidth = 6;
$this->drawPoint ($gd, $x, $y);
}
}
/* }}} */
/** The graphStylePoints : draw a graph with points */
class graphStylePoints extends graphStyleLinePoints
/* {{{ */
{
/** The line color : transparent
*/
protected $lineColor = "transparent";
/** Return the name of the style */
public function name ()
{
return "points";
}
}
/* }}} */
/** The graphStyleLine : draw a graph with line */
class graphStyleLine extends graphStyleLinePoints
/* {{{ */
{
/** The point color background. To hide the points, choose "transparent"
*/
protected $pointBgcolor = "transparent";
/** The point color border
*/
protected $pointColor = "transparent";
/** Return the name of the style */
public function name ()
{
return "line";
}
}
/* }}} */
/** The graphPalette class */
class graphPalette
/* {{{ */
{
/** Get the complete palette */
public static function getPalette ($name)
{
$palette = array (
"basic" => array (
array ("bgcolor"=>"indianred", "color"=>"firebrick"),
array ("bgcolor"=>"lightblue", "color"=>"blue"),
array ("bgcolor"=>"peru", "color"=>"maroon"),
array ("bgcolor"=>"mediumaquamarine", "color"=>"teal"),
array ("bgcolor"=>"goldenrod", "color"=>"orange"),
array ("bgcolor"=>"limegreen", "color"=>"green"),
array ("bgcolor"=>"darkgrey", "color"=>"grey"),
array ("bgcolor"=>"darkyellow1", "color"=>"darkyellow2"),
array ("bgcolor"=>"grey", "color"=>"black"),
),
);
if (! is_string ($name) || ! array_key_exists ($name, $palette))
throw new \Exception (dgettext ("domframework",
"Unknown palette name provided"), 406);
return $palette[$name];
}
}
/* }}} */
Reference in New Issue View Git Blame Copy Permalink