coderkun/questlab
1
0
Fork 0
Code Issues 15 Pull requests Projects Releases Wiki Activity

add piwik installation

Browse source
This commit is contained in:
coderkun 2014-04-25 03:56:02 +02:00
commit 8c5d4f0c31
3197 changed files with 563902 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

159
www/analytics/libs/sparkline/lib/Object.php Normal file
View file

@ -0,0 +1,159 @@
<?php
/*
* Sparkline PHP Graphing Library
* Copyright 2004 James Byers <jbyers@gmail.com>
* http://sparkline.org
*
* Dual-licensed under the BSD (LICENSE-BSD.txt) and GPL (LICENSE-GPL.txt)
* licenses.
*
* $Id: Object.php,v 1.9 2008/03/11 19:12:49 jbyers Exp $
*
*/
define('DEBUG_NONE', 0); // nothing
define('DEBUG_ERROR', 1); // major errors
define('DEBUG_WARNING', 2); // warnings
define('DEBUG_STATS', 4); // dataset, rendering statistics
define('DEBUG_CALLS', 8); // major function calls
define('DEBUG_SET', 16); // all Set methods
define('DEBUG_DRAW', 32); // all Draw methods
define('DEBUG_ALL', 2047); // everything
function error_handler($errno, $errstr, $errfile, $errline) {
switch ($errno) {
case E_ERROR:
$message = "ERROR: ";
break;
case E_WARNING:
$message = "WARNING: ";
break;
case E_PARSE:
$message = "PARSE: ";
break;
case E_NOTICE:
$message = "NOTICE: ";
break;
case E_USER_ERROR:
$message = "UERROR: ";
break;
case E_USER_WARNING:
$message = "UWARNING: ";
break;
case E_USER_NOTICE:
$message = "UNOTICE: ";
break;
default:
$message = "UNKNOWN: ";
break;
} // switch
$message .= "$errstr in $errfile at line $errline\n";
if (($errno != E_NOTICE) && // suppress notices
(error_reporting() != 0)) { // respect supressed errors (@)
log_write($message, 'PHP');
}
} // function error_handler
function log_write($string, $type = '', $date = false) {
global $LOGFILE;
if (isset($LOGFILE)) {
if ($date == false) {
$date = time();
}
$message = date('d/m/Y:H:i:s', $date) . " $type: $string \n";
error_log($message, 3, $LOGFILE);
}
} // function log_write
class Object {
var $isError;
var $logFile;
var $errorList;
var $debugList;
var $debugLevel;
var $startTime;
////////////////////////////////////////////////////////////////////////////
// constructor
//
function Object($catch_errors = true) {
$this->isError = false;
$this->logFile = null;
$this->logDate = '';
$this->errorList = array();
$this->debugList = array();
$this->debugLevel = DEBUG_NONE;
$this->startTime = $this->microTimer();
// if ($catch_errors) {
set_error_handler('error_handler');
//}
} // function Object
////////////////////////////////////////////////////////////////////////////
// utility
//
function microTimer() {
list($usec, $sec) = explode(" ", microtime());
return ((float)$usec + (float)$sec);
} // function microTimer
////////////////////////////////////////////////////////////////////////////
// error handling
//
function SetDebugLevel($level, $file = null) {
global $LOGFILE;
if ($level >= DEBUG_NONE &&
$level <= DEBUG_ALL) {
$this->debugLevel = $level;
}
if ($file != null) {
if ((!file_exists($file) && !touch($file)) ||
!is_writable($file)) {
die("error log file '$file' is not writable to the web server user");
} else {
$this->logFile = $file;
$LOGFILE = $file;
}
}
} // function SetDebugLevel
function Debug($string, $level = DEBUG_WARNING) {
$this->debugList[] = $string;
if ($this->debugLevel & $level &&
$this->logFile != null) {
log_write($string, 'DEBUG');
}
} // function Debug
function Error($string) {
$this->isError = true;
$this->errorList[] = $string;
if ($this->debugLevel & DEBUG_ERROR &&
$this->logFile != null) {
log_write($string, 'ERROR');
}
} // function Error
function GetDebug() {
return $this->debugList;
} // function GetDebug
function GetError() {
return $this->errorList;
} // function GetError
function IsError() {
return $this->isError;
} // function IsError
} // class Object
?>

494
www/analytics/libs/sparkline/lib/Sparkline.php Normal file
View file

@ -0,0 +1,494 @@
<?php
/*
* Sparkline PHP Graphing Library
* Copyright 2004 James Byers <jbyers@gmail.com>
* http://sparkline.org
*
* Dual-licensed under the BSD (LICENSE-BSD.txt) and GPL (LICENSE-GPL.txt)
* licenses.
*
* $Id: Sparkline.php,v 1.10 2008/03/11 19:12:49 jbyers Exp $
*
*/
define('TEXT_TOP', 1);
define('TEXT_RIGHT', 2);
define('TEXT_BOTTOM', 3);
define('TEXT_LEFT', 4);
define('FONT_1', 1);
define('FONT_2', 2);
define('FONT_3', 3);
define('FONT_4', 4);
define('FONT_5', 5);
require_once dirname(__FILE__).'/Object.php';
class Sparkline extends Object {
var $imageX;
var $imageY;
var $imageHandle;
var $graphAreaPx;
var $graphAreaPt;
var $colorList;
var $colorBackground;
var $lineSize;
////////////////////////////////////////////////////////////////////////////
// constructor
//
function Sparkline($catch_errors = true) {
parent::Object($catch_errors);
$this->colorList = array();
$this->colorBackground = 'white';
$this->lineSize = 1;
$this->graphAreaPx = array(array(0, 0), array(0, 0)); // px(L, B), px(R, T)
}
////////////////////////////////////////////////////////////////////////////
// init
//
function Init($x, $y) {
$this->Debug("Sparkline :: Init($x, $y)", DEBUG_CALLS);
$this->imageX = $x;
$this->imageY = $y;
// Set functions may have already set graphAreaPx offsets; add image dimensions
//
$this->graphAreaPx = array(array($this->graphAreaPx[0][0],
$this->graphAreaPx[0][1]),
array($this->graphAreaPx[1][0] + $x - 1,
$this->graphAreaPx[1][1] + $y - 1));
$this->imageHandle = $this->CreateImageHandle($x, $y);
// load default colors; set all color handles
//
$this->SetColorDefaults();
while (list($k, $v) = each($this->colorList)) {
$this->SetColorHandle($k, $this->DrawColorAllocate($k));
}
reset($this->colorList);
return !$this->IsError();
}
////////////////////////////////////////////////////////////////////////////
// color, drawing setup functions
//
function SetColor($name, $r, $g, $b) {
$this->Debug("Sparkline :: SetColor('$name', $r, $g, $b)", DEBUG_SET);
$name = strtolower($name);
$this->colorList[$name] = array('rgb' => array($r, $g, $b));
}
function SetColorHandle($name, $handle) {
$this->Debug("Sparkline :: SetColorHandle('$name', $handle)", DEBUG_SET);
$name = strtolower($name);
if (array_key_exists($name, $this->colorList)) {
$this->colorList[$name]['handle'] = $handle;
return true;
}
return false;
}
function SetColorHex($name, $r, $g, $b) {
$this->Debug("Sparkline :: SetColorHex('$name', $r, $g, $b)", DEBUG_SET);
$this->SetColor($name, hexdec($r), hexdec($g), hexdec($b));
}
function SetColorHtml($name, $rgb) {
$this->Debug("Sparkline :: SetColorHtml('$name', '$rgb')", DEBUG_SET);
$rgb = trim($rgb, '#');
$this->SetColor($name, hexdec(substr($rgb, 0, 2)), hexdec(substr($rgb, 2, 2)), hexdec(substr($rgb, 4, 2)));
}
function SetColorBackground($name) {
$this->Debug("Sparkline :: SetColorBackground('$name')", DEBUG_SET);
$this->colorBackground = $name;
}
function GetColor($name) {
$name = strtolower($name);
if (array_key_exists($name, $this->colorList)) {
return $this->colorList[$name]['rgb'];
} else {
return false;
}
}
function GetColorHandle($name) {
$name = strtolower($name);
if (array_key_exists($name, $this->colorList)) {
return $this->colorList[$name]['handle'];
} else {
$this->Debug("Sparkline :: GetColorHandle color '$name' not set", DEBUG_WARNING);
return false;
}
}
function SetColorDefaults() {
$this->Debug("Sparkline :: SetColorDefaults()", DEBUG_SET);
$colorDefaults = array(array('aqua', '#00FFFF'),
array('black', '#010101'), // TODO failure if 000000?
array('blue', '#0000FF'),
array('fuscia', '#FF00FF'),
array('gray', '#808080'),
array('grey', '#808080'),
array('green', '#008000'),
array('lime', '#00FF00'),
array('maroon', '#800000'),
array('navy', '#000080'),
array('olive', '#808000'),
array('purple', '#800080'),
array('red', '#FF0000'),
array('silver', '#C0C0C0'),
array('teal', '#008080'),
array('white', '#FFFFFF'),
array('yellow', '#FFFF00'));
while (list(, $v) = each($colorDefaults)) {
if (!array_key_exists($v[0], $this->colorList)) {
$this->SetColorHtml($v[0], $v[1]);
}
}
}
function SetLineSize($size) {
$this->Debug("Sparkline :: SetLineSize($size)", DEBUG_CALLS);
$this->lineSize = $size;
}
function GetLineSize() {
return($this->lineSize);
}
function SetPadding($T, $R = null, $B = null, $L = null) {
$this->Debug("Sparkline :: SetPadding($T, $R, $B, $L)", DEBUG_CALLS);
if (null == $R &&
null == $B &&
null == $L) {
$this->graphAreaPx = array(array($this->graphAreaPx[0][0] + $T,
$this->graphAreaPx[0][1] + $T),
array($this->graphAreaPx[1][0] - $T,
$this->graphAreaPx[1][1] - $T));
} else {
$this->graphAreaPx = array(array($this->graphAreaPx[0][0] + $L,
$this->graphAreaPx[0][1] + $B),
array($this->graphAreaPx[1][0] - $R,
$this->graphAreaPx[1][1] - $T));
}
}
////////////////////////////////////////////////////////////////////////////
// canvas setup
//
function CreateImageHandle($x, $y) {
$this->Debug("Sparkline :: CreateImageHandle($x, $y)", DEBUG_CALLS);
$handle = @imagecreatetruecolor($x, $y);
if (!is_resource($handle)) {
$handle = @imagecreate($x, $y);
$this->Debug('imagecreatetruecolor unavailable', DEBUG_WARNING);
}
if (!is_resource($handle)) {
$this->Debug('imagecreate unavailable', DEBUG_WARNING);
$this->Error('could not create image; GD imagecreate functions unavailable');
}
return $handle;
}
////////////////////////////////////////////////////////////////////////////
// drawing primitives
//
// NB: all drawing primitives use the coordinate system where (0,0)
// corresponds to the bottom left of the image, unlike y-inverted
// PHP gd functions
//
function DrawBackground($handle = false) {
$this->Debug("Sparkline :: DrawBackground()", DEBUG_DRAW);
if (!$this->IsError()) {
if ($handle === false) $handle = $this->imageHandle;
return $this->DrawRectangleFilled(0,
0,
imagesx($handle) - 1,
imagesy($handle) - 1,
$this->colorBackground,
$handle);
}
}
function DrawColorAllocate($color, $handle = false) {
$this->Debug("Sparkline :: DrawColorAllocate('$color')", DEBUG_DRAW);
if (!$this->IsError() &&
$colorRGB = $this->GetColor($color)) {
if ($handle === false) $handle = $this->imageHandle;
return imagecolorallocate($handle,
$colorRGB[0],
$colorRGB[1],
$colorRGB[2]);
}
}
function DrawFill($x, $y, $color, $handle = false) {
$this->Debug("Sparkline :: DrawFill($x, $y, '$color')", DEBUG_DRAW);
if (!$this->IsError() &&
$colorHandle = $this->GetColorHandle($color)) {
if ($handle === false) $handle = $this->imageHandle;
return imagefill($handle,
$x,
$this->TxGDYToSLY($y, $handle),
$colorHandle);
}
}
function DrawLine($x1, $y1, $x2, $y2, $color, $thickness = 1, $handle = false) {
$this->Debug("Sparkline :: DrawLine($x1, $y1, $x2, $y2, '$color', $thickness)", DEBUG_DRAW);
if (!$this->IsError() &&
$colorHandle = $this->GetColorHandle($color)) {
if ($handle === false) $handle = $this->imageHandle;
imagesetthickness($handle, $thickness);
$result = imageline($handle,
$x1,
$this->TxGDYToSLY($y1, $handle),
$x2,
$this->TxGDYToSLY($y2, $handle),
$colorHandle);
imagesetthickness($handle, 1);
return $result;
}
}
function DrawPoint($x, $y, $color, $handle = false) {
$this->Debug("Sparkline :: DrawPoint($x, $y, '$color')", DEBUG_DRAW);
if (!$this->IsError() &&
$colorHandle = $this->GetColorHandle($color)) {
if ($handle === false) $handle = $this->imageHandle;
return imagesetpixel($handle,
$x,
$this->TxGDYToSLY($y, $handle),
$colorHandle);
}
}
function DrawRectangle($x1, $y1, $x2, $y2, $color, $handle = false) {
$this->Debug("Sparkline :: DrawRectangle($x1, $y1, $x2, $y2 '$color')", DEBUG_DRAW);
if (!$this->IsError() &&
$colorHandle = $this->GetColorHandle($color)) {
if ($handle === false) $handle = $this->imageHandle;
return imagerectangle($handle,
$x1,
$this->TxGDYToSLY($y1, $handle),
$x2,
$this->TxGDYToSLY($y2, $handle),
$colorHandle);
}
}
function DrawRectangleFilled($x1, $y1, $x2, $y2, $color, $handle = false) {
$this->Debug("Sparkline :: DrawRectangleFilled($x1, $y1, $x2, $y2 '$color')", DEBUG_DRAW);
if (!$this->IsError() &&
$colorHandle = $this->GetColorHandle($color)) {
// NB: switch y1, y2 post conversion
//
if ($y1 < $y2) {
$yt = $y1;
$y1 = $y2;
$y2 = $yt;
}
if ($handle === false) $handle = $this->imageHandle;
return imagefilledrectangle($handle,
$x1,
$this->TxGDYToSLY($y1, $handle),
$x2,
$this->TxGDYToSLY($y2, $handle),
$colorHandle);
}
}
function DrawCircleFilled($x, $y, $diameter, $color, $handle = false) {
$this->Debug("Sparkline :: DrawCircleFilled($x, $y, $diameter, '$color')", DEBUG_DRAW);
if (!$this->IsError() &&
$colorHandle = $this->GetColorHandle($color)) {
if ($handle === false) $handle = $this->imageHandle;
return imagefilledellipse($handle,
$x,
$this->TxGDYToSLY($y, $handle),
$diameter,
$diameter,
$colorHandle);
}
}
function DrawText($string, $x, $y, $color, $font = FONT_1, $handle = false) {
$this->Debug("Sparkline :: DrawText('$string', $x, $y, '$color', $font)", DEBUG_DRAW);
if (!$this->IsError() &&
$colorHandle = $this->GetColorHandle($color)) {
// adjust for font height so x,y corresponds to bottom left of font
//
if ($handle === false) $handle = $this->imageHandle;
return imagestring($handle,
$font,
$x,
$this->TxGDYToSLY($y + imagefontheight($font), $handle),
$string,
$colorHandle);
}
}
function DrawTextRelative($string, $x, $y, $color, $position, $padding = 2, $font = FONT_1, $handle = false) {
$this->Debug("Sparkline :: DrawTextRelative('$string', $x, $y, '$color', $position, $font, $padding)", DEBUG_DRAW);
if (!empty($string) && !$this->IsError() &&
$colorHandle = $this->GetColorHandle($color)) {
if ($handle === false) $handle = $this->imageHandle;
// rendered text width, height
//
$textHeight = imagefontheight($font);
$textWidth = imagefontwidth($font) * strlen($string);
// set (pxX, pxY) based on position and point
//
switch($position) {
case TEXT_TOP:
$x = $x - round($textWidth / 2);
$y = $y + $padding;
break;
case TEXT_RIGHT:
$x = $x + $padding;
$y = $y - round($textHeight / 2);
break;
case TEXT_BOTTOM:
$x = $x - round($textWidth / 2);
$y = $y - $padding - $textHeight;
break;
case TEXT_LEFT:
default:
$x = $x - $padding - $textWidth;
$y = $y - round($textHeight / 2);
break;
}
// truncate bounds based on string size in pixels, image bounds
// order: TRBL
//
$y = min($y, $this->GetImageHeight() - $textHeight);
$x = min($x, $this->GetImageWidth() - $textWidth);
$y = max($y, 0);
$x = max($x, 0);
return $this->DrawText($string,
$x,
$y,
$color,
$font,
$handle);
}
}
function DrawImageCopyResampled($dhandle, $shandle, $dx, $dy, $sx, $sy, $dw, $dh, $sw, $sh) {
$this->Debug("Sparkline :: DrawImageCopyResampled($dhhandle, $shandle, $dx, $dy, $sx, $sy, $dw, $dh, $sw, $sh)", DEBUG_DRAW);
if (!$this->IsError()) {
return imagecopyresampled($dhandle, // dest handle
$shandle, // src handle
$dx, $dy, // dest x, y
$sx, $sy, // src x, y
$dw, $dh, // dest w, h
$sw, $sh); // src w, h
}
}
////////////////////////////////////////////////////////////////////////////
// coordinate system functions
// world coordinates are referenced as points or pt
// graph coordinates are referenced as pixels or px
// sparkline inverts GD Y pixel coordinates; the bottom left of the
// image rendering area is px(0,0)
// all coordinate transformation functions are prefixed with Tx
// all coordinate transformation functions depend on a valid image handle
// and will only return valid results after all Set* calls are performed
//
function TxGDYToSLY($gdY, $handle) {
return imagesy($handle) - 1 - $gdY;
}
function TxPxToPt($pxX, $pxY, $handle) {
// TODO; must occur after data series conversion
}
function TxPtToPx($ptX, $ptY, $handle) {
// TODO; must occur after data series conversion
}
function GetGraphWidth() {
return $this->graphAreaPx[1][0] - $this->graphAreaPx[0][0];
}
function GetGraphHeight() {
return $this->graphAreaPx[1][1] - $this->graphAreaPx[0][1];
}
function GetImageWidth() {
return $this->imageX;
}
function GetImageHeight() {
return $this->imageY;
}
////////////////////////////////////////////////////////////////////////////
// image output
//
function Output($file = '') {
$this->Debug("Sparkline :: Output($file)", DEBUG_CALLS);
if ($this->IsError()) {
$colorError = imagecolorallocate($this->imageHandle, 0xFF, 0x00, 0x00);
imagestring($this->imageHandle,
1,
($this->imageX / 2) - (5 * imagefontwidth(1) / 2),
($this->imageY / 2) - (imagefontheight(1) / 2),
"ERROR",
$colorError);
}
if ($file == '') {
header('Content-type: image/png');
imagepng($this->imageHandle);
} else {
imagepng($this->imageHandle, $file);
}
$this->Debug('Sparkline :: Output - total execution time: ' . round($this->microTimer() - $this->startTime, 4) . ' seconds', DEBUG_STATS);
}
function OutputToFile($file) {
$this->Output($file);
}
function OutputToDataURI() {
ob_start(null, 4096);
$this->Output();
return "data:image/png;base64,".base64_encode(ob_get_clean());
}
}
?>

196
www/analytics/libs/sparkline/lib/Sparkline_Bar.php Normal file
View file

@ -0,0 +1,196 @@
<?php
/*
* Sparkline PHP Graphing Library
* Copyright 2004 James Byers <jbyers@gmail.com>
* http://sparkline.org
*
* Dual-licensed under the BSD (LICENSE-BSD.txt) and GPL (LICENSE-GPL.txt)
* licenses.
*
* $Id: Sparkline_Bar.php,v 1.3 2008/03/11 19:12:49 jbyers Exp $
*
*/
require_once dirname(__FILE__).'/Sparkline.php';
class Sparkline_Bar extends Sparkline {
var $dataSeries;
var $dataSeriesStats;
var $dataSeriesConverted;
var $yMin;
var $yMax;
var $barWidth;
var $barSpacing;
var $barColorDefault;
var $barColorUnderscoreDefault;
////////////////////////////////////////////////////////////////////////////
// constructor
//
function Sparkline_Bar($catch_errors = true) {
parent::Sparkline($catch_errors);
$this->dataSeries = array();
$this->dataSeriesStats = array();
$this->dataSeriesConverted = array();
$this->barWidth = 1;
$this->barSpacing = 1;
$this->barColorDefault = 'black';
$this->barColorUnderscoreDefault = 'black';
} // function Sparkline
////////////////////////////////////////////////////////////////////////////
// color, image property setting
//
function SetBarWidth($value) {
$this->Debug("Sparkline_Bar :: SetBarWidth($value)", DEBUG_SET);
$this->barWidth = $value;
} // function SetBarWidth
function SetBarSpacing($value) {
$this->Debug("Sparkline_Bar :: SetBarSpacing($value)", DEBUG_SET);
$this->barSpacing = $value;
} // function SetBarSpacing
function SetBarColorDefault($value) {
$this->Debug("Sparkline_Bar :: SetBarColorDefault($value)", DEBUG_SET);
$this->barColorDefault = $value;
} // function SetBarColorDefault
function SetBarColorUnderscoreDefault($value) {
$this->Debug("Sparkline_Bar :: SetBarColorUnderscoreDefault($value)", DEBUG_SET);
$this->barColorUnderscoreDefault = $value;
} // function SetBarColorUnderscoreDefault
////////////////////////////////////////////////////////////////////////////
// data setting
//
function SetData($x, $y, $color = null, $underscore = false, $series = 1) {
if(!is_numeric($x)) {
$x = trim($x);
}
if(!is_numeric($y)) {
$y = trim($y);
}
$this->Debug("Sparkline_Bar :: SetData($x, $y, $series)", DEBUG_SET);
if (!is_numeric($x) ||
!is_numeric($y)) {
$this->Debug("Sparkline_Bar :: SetData rejected values($x, $y) in series $series", DEBUG_WARNING);
return false;
} // if
if ($color == null) {
$color = $this->barColorDefault;
}
$this->dataSeries[$series][$x] = array('value' => $y,
'color' => $color,
'underscore' => $underscore);
if (!isset($this->dataSeriesStats[$series]['min']) ||
$y < $this->dataSeriesStats[$series]['min']) {
$this->dataSeriesStats[$series]['min'] = $y;
}
if (!isset($this->dataSeriesStats[$series]['max']) ||
abs($y) > $this->dataSeriesStats[$series]['max']) {
$this->dataSeriesStats[$series]['max'] = abs($y);
}
} // function SetData
function SetYMin($value) {
$this->Debug("Sparkline_Bar :: SetYMin($value)", DEBUG_SET);
$this->yMin = $value;
}
function SetYMax($value) {
$this->Debug("Sparkline_Bar :: SetYMax($value)", DEBUG_SET);
$this->yMax = $value;
}
function ConvertDataSeries($series, $xBound, $yBound) {
$this->Debug("Sparkline_Bar :: ConvertDataSeries($series, $xBound, $yBound)", DEBUG_CALLS);
if (!isset($this->yMin)) {
$this->yMin = $this->dataSeriesStats[$series]['min'];
}
if (!isset($this->yMax)) {
$this->yMax = $this->dataSeriesStats[$series]['max'];
}
while (list(, $v) = each($this->dataSeries[$series])) {
$y = floor($v['value'] * ($yBound / (abs($this->yMax) + abs($this->yMin))));
$this->dataSeriesConverted[$series][] = array('value' => $y,
'color' => $v['color'],
'underscore' => $v['underscore']);
if (!isset($this->dataSeriesStats[$series]['min_converted']) ||
$y < $this->dataSeriesStats[$series]['min_converted']) {
$this->dataSeriesStats[$series]['min_converted'] = $y;
}
if (!isset($this->dataSeriesStats[$series]['max_converted']) ||
abs($y) > $this->dataSeriesStats[$series]['max_converted']) {
$this->dataSeriesStats[$series]['max_converted'] = abs($y);
}
}
reset($this->dataSeries[$series]);
} // function ConvertDataSeries
function CalculateImageWidth() {
$this->Debug("Sparkline_Bar :: CalculateImageWidth()", DEBUG_CALLS);
$count = sizeof($this->dataSeries[1]);
return (($count - 1) * $this->barSpacing) + ($count * $this->barWidth);
} // function CalculateImageWidth
////////////////////////////////////////////////////////////////////////////
// rendering
//
function Render($y) {
$this->Debug("Sparkline_Bar :: Render($y)", DEBUG_CALLS);
// calculate size based on sets for init
//
if (!parent::Init($this->CalculateImageWidth(), $y)) {
return false;
}
// convert based on actual canvas size
//
$this->ConvertDataSeries(1, $this->GetGraphWidth(), $this->GetGraphHeight());
// stats debugging
//
$this->Debug('Sparkline_Bar :: Draw' .
' series: 1 min: ' . $this->dataSeriesStats[1]['min'] .
' max: ' . $this->dataSeriesStats[1]['max'] .
' height: ' . $this->GetGraphHeight() .
' yfactor: ' . ($this->GetGraphHeight() / (abs($this->dataSeriesStats[1]['max']) + abs($this->dataSeriesStats[1]['min']))));
$this->DrawBackground();
$yAxis = abs(min($this->dataSeriesStats[1]['min_converted'], 0));
for ($i = 0; $i < sizeof($this->dataSeriesConverted[1]); $i++) {
$this->DrawRectangleFilled($i * ($this->barWidth + $this->barSpacing),
$yAxis,
$i * ($this->barWidth + $this->barSpacing) + $this->barWidth - 1,
$yAxis + $this->dataSeriesConverted[1][$i]['value'],
$this->dataSeriesConverted[1][$i]['color']);
if ($this->dataSeriesConverted[1][$i]['underscore']) {
$this->DrawLine(max(0, $i * ($this->barWidth + $this->barSpacing) - ($this->barSpacing / 2)),
$yAxis,
min($this->GetGraphWidth(), $i * ($this->barWidth + $this->barSpacing) + ($this->barSpacing / 2)),
$yAxis,
$this->barColorUnderscoreDefault);
}
}
} // function Render
} // class Sparkline_Bar
?>

286
www/analytics/libs/sparkline/lib/Sparkline_Line.php Normal file
View file

@ -0,0 +1,286 @@
<?php
/*
* Sparkline PHP Graphing Library
* Copyright 2004 James Byers <jbyers@gmail.com>
* http://sparkline.org
*
* Dual-licensed under the BSD (LICENSE-BSD.txt) and GPL (LICENSE-GPL.txt)
* licenses.
*
* $Id: Sparkline_Line.php,v 1.10 2008/03/11 19:12:49 jbyers Exp $
*
*/
require_once dirname(__FILE__).'/Sparkline.php';
class Sparkline_Line extends Sparkline {
var $dataSeries;
var $dataSeriesStats;
var $dataSeriesConverted;
var $yMin;
var $yMax;
var $featurePoint;
////////////////////////////////////////////////////////////////////////////
// constructor
//
function Sparkline_Line($catch_errors = true) {
parent::Sparkline($catch_errors);
$this->dataSeries = array();
$this->dataSeriesStats = array();
$this->dataSeriesConverted = array();
$this->colorBackground = 'backgroundColor';
$this->featurePoint = array();
} // function Sparkline
////////////////////////////////////////////////////////////////////////////
// data setting
//
function SetData($x, $y, $series = 1) {
if(!is_numeric($x)) {
$x = trim($x);
}
if(!is_numeric($y)) {
$y = trim($y);
}
$this->Debug("Sparkline_Line :: SetData($x, $y, $series)", DEBUG_SET);
if (!is_numeric($x) ||
!is_numeric($y)) {
$this->Debug("Sparkline_Line :: SetData rejected values($x, $y) in series $series", DEBUG_WARNING);
return false;
} // if
$this->dataSeries[$series][$x] = $y;
if (!isset($this->dataSeriesStats[$series]['yMin']) ||
$y < $this->dataSeriesStats[$series]['yMin']) {
$this->dataSeriesStats[$series]['yMin'] = $y;
}
if (!isset($this->dataSeriesStats[$series]['xMin']) ||
$x < $this->dataSeriesStats[$series]['xMin']) {
$this->dataSeriesStats[$series]['xMin'] = $x;
}
if (!isset($this->dataSeriesStats[$series]['yMax']) ||
$y > $this->dataSeriesStats[$series]['yMax']) {
$this->dataSeriesStats[$series]['yMax'] = $y;
}
if (!isset($this->dataSeriesStats[$series]['xMax']) ||
$x > $this->dataSeriesStats[$series]['xMax']) {
$this->dataSeriesStats[$series]['xMax'] = $x;
}
} // function SetData
function SetYMin($value) {
$this->Debug("Sparkline_Line :: SetYMin($value)", DEBUG_SET);
$this->yMin = $value;
} // function SetYMin
function SetYMax($value) {
$this->Debug("Sparkline_Line :: SetYMax($value)", DEBUG_SET);
$this->yMax = $value;
} // function SetYMin
function ConvertDataSeries($series, $xBound, $yBound) {
$this->Debug("Sparkline_Line :: ConvertDataSeries($series, $xBound, $yBound)", DEBUG_CALLS);
if (!isset($this->yMin)) {
$this->yMin = $this->dataSeriesStats[$series]['yMin'];
}
if (!isset($this->xMin)) {
$this->xMin = $this->dataSeriesStats[$series]['XMin'];
}
if (!isset($this->yMax)) {
$this->yMax = $this->dataSeriesStats[$series]['yMax'];
}
if (!isset($this->xMax)) {
$this->xMax = $this->dataSeriesStats[$series]['xMax'];
}
$this->yRange = $this->yMax + ($this->yMin * -1);
for ($i = 0; $i < sizeof($this->dataSeries[$series]); $i++) {
$y = round(($this->dataSeries[$series][$i] + ($this->yMin * -1)) * (($yBound-1) / $this->yRange));
$x = round($i * $xBound / (sizeof($this->dataSeries[$series])));
$this->dataSeriesConverted[$series][] = array($x, $y);
$this->Debug("Sparkline :: ConvertDataSeries series $series value $i ($x, $y)", DEBUG_SET);
}
} // function ConvertDataSeries
////////////////////////////////////////////////////////////////////////////
// features
//
function SetFeaturePoint($x, $y, $color, $diameter, $text = '', $position = TEXT_TOP, $font = FONT_1) {
$this->Debug("Sparkline_Line :: SetFeaturePoint($x, $y, '$color', $diameter, '$text')", DEBUG_CALLS);
$this->featurePoint[] = array('ptX' => $x,
'ptY' => $y,
'color' => $color,
'diameter' => $diameter,
'text' => $text,
'textpos' => $position,
'font' => $font);
} // function SetFeaturePoint
////////////////////////////////////////////////////////////////////////////
// low quality rendering
//
function Render($x, $y) {
$this->Debug("Sparkline_Line :: Render($x, $y)", DEBUG_CALLS);
if (!parent::Init($x, $y)) {
return false;
}
// convert based on graphAreaPx bounds
//
$this->ConvertDataSeries(1, $this->GetGraphWidth(), $this->GetGraphHeight());
// stats debugging
//
$this->Debug('Sparkline_Line :: Draw' .
' series: 1 min: ' . $this->dataSeriesStats[1]['yMin'] .
' max: ' . $this->dataSeriesStats[1]['yMax'] .
' offset: ' . ($this->dataSeriesStats[1]['yMin'] * -1) .
' height: ' . $this->GetGraphHeight() + 1 .
' yfactor: ' . ($this->GetGraphHeight() / ($this->dataSeriesStats[1]['yMax'] + ($this->dataSeriesStats[1]['yMin'] * -1))));
$this->Debug('Sparkline_Line :: Draw' .
' drawing area:' .
' (' . $this->graphAreaPx[0][0] . ',' . $this->graphAreaPx[0][1] . '), ' .
' (' . $this->graphAreaPx[1][0] . ',' . $this->graphAreaPx[1][1] . ')');
$this->DrawBackground();
// draw graph
//
for ($i = 0; $i < sizeof($this->dataSeriesConverted[1]) - 1; $i++) {
$this->DrawLine($this->dataSeriesConverted[1][$i][0] + $this->graphAreaPx[0][0],
$this->dataSeriesConverted[1][$i][1] + $this->graphAreaPx[0][1],
$this->dataSeriesConverted[1][$i+1][0] + $this->graphAreaPx[0][0],
$this->dataSeriesConverted[1][$i+1][1] + $this->graphAreaPx[0][1],
'lineColor');
}
// draw features
//
while (list(, $v) = each($this->featurePoint)) {
$pxY = round(($v['ptY'] + ($this->yMin * -1)) * ($this->GetGraphHeight() / $this->yRange));
$pxX = round($v['ptX'] * $this->GetGraphWidth() / sizeof($this->dataSeries[1]));
$this->DrawCircleFilled($pxX + $this->graphAreaPx[0][0],
$pxY + $this->graphAreaPx[0][1],
$v['diameter'],
$v['color'],
$this->imageHandle);
$this->DrawTextRelative($v['text'],
$pxX + $this->graphAreaPx[0][0],
$pxY + $this->graphAreaPx[0][1],
$v['color'],
$v['textpos'],
round($v['diameter'] / 2),
$v['font'],
$this->imageHandle);
}
} // function Render
////////////////////////////////////////////////////////////////////////////
// high quality rendering
//
function RenderResampled($x, $y) {
$this->Debug("Sparkline_Line :: RenderResampled($x, $y)", DEBUG_CALLS);
if (!parent::Init($x, $y)) {
return false;
}
// draw background on standard image in case of resample blit miss
//
$this->DrawBackground($this->imageHandle);
// convert based on virtual canvas: x based on size of dataset, y scaled proportionately
// if size of data set is small, default to 4X target canvas size
//
$xVC = max(sizeof($this->dataSeries[1]), 4 * $x);
$yVC = floor($xVC * ($this->GetGraphHeight() / $this->GetGraphWidth()));
$this->ConvertDataSeries(1, $xVC, $yVC);
// stats debugging
//
$this->Debug('Sparkline_Line :: DrawResampled' .
' series: 1 min: ' . $this->dataSeriesStats[1]['yMin'] .
' max: ' . $this->dataSeriesStats[1]['yMax'] .
' offset: ' . ($this->dataSeriesStats[1]['yMin'] * -1) .
' height: ' . $this->GetGraphHeight() .
' yfactor: ' . ($this->GetGraphHeight() / ($this->dataSeriesStats[1]['yMax'] + ($this->dataSeriesStats[1]['yMin'] * -1))), DEBUG_STATS);
$this->Debug('Sparkline_Line :: DrawResampled' .
' drawing area:' .
' (' . $this->graphAreaPx[0][0] . ',' . $this->graphAreaPx[0][1] . '), ' .
' (' . $this->graphAreaPx[1][0] . ',' . $this->graphAreaPx[1][1] . ')');
// create virtual image
// allocate colors
// draw background, graph
// resample and blit onto original graph
//
$imageVCHandle = $this->CreateImageHandle($xVC, $yVC);
while (list($k, $v) = each($this->colorList)) {
$this->SetColorHandle($k, $this->DrawColorAllocate($k, $imageVCHandle));
}
reset($this->colorList);
$this->DrawBackground($imageVCHandle);
for ($i = 0; $i < sizeof($this->dataSeriesConverted[1]) - 1; $i++) {
$this->DrawLine($this->dataSeriesConverted[1][$i][0],
$this->dataSeriesConverted[1][$i][1],
$this->dataSeriesConverted[1][$i+1][0],
$this->dataSeriesConverted[1][$i+1][1],
'lineColor',
$this->GetLineSize(),
$imageVCHandle);
}
$this->DrawImageCopyResampled($this->imageHandle,
$imageVCHandle,
$this->graphAreaPx[0][0], // dest x
$this->GetImageHeight() - $this->graphAreaPx[1][1], // dest y
0, 0, // src x, y
$this->GetGraphWidth(), // dest width
$this->GetGraphHeight(), // dest height
$xVC, // src width
$yVC); // src height
// draw features
//
while (list(, $v) = each($this->featurePoint)) {
$pxY = round(($v['ptY'] + ($this->yMin * -1)) * ($this->GetGraphHeight() / $this->yRange));
$pxX = round($v['ptX'] * $this->GetGraphWidth() / sizeof($this->dataSeries[1]));
$this->DrawCircleFilled($pxX + $this->graphAreaPx[0][0],
$pxY + $this->graphAreaPx[0][1],
$v['diameter'],
$v['color'],
$this->imageHandle);
$this->DrawTextRelative($v['text'],
$pxX + $this->graphAreaPx[0][0],
$pxY + $this->graphAreaPx[0][1],
$v['color'],
$v['textpos'],
round($v['diameter'] / 2),
$v['font'],
$this->imageHandle);
}
} // function RenderResampled
} // class Sparkline_Line
?>