WeberDev.com PHP and MySQL Code

LOG IN
BEGINNER GUIDES  |  PHP CLASSES  |  CODE SEARCH  |  ARTICLES SEARCH  |  PHP FORUMS  |  PHP MANUAL  |  PHP FUNCTIONS LIST  |  WEB SITE TEMPLATES
Start typing to search for PHP and MySQL Code Snippets and Articles Search
Submit a code Example / Snippet Submit Your Code
Search Engine Optimization Monitor SEO Monitor
Web Site UpTime Monitor UpTime Monitor
WeberDev's Monthly code contest PHP Code Contest
Your Personal Examples List My Favorite Examples
Your Personal Articles List My Favorite Articles
Edit Account Info Update Your Profile
PHP Code Search
Web Development Forums
Learn MySQL Playing Trivia
PHPBB2 Templates
Web Development Index
PHP Web Logs (BLogs)
Web Development Resources
Web Development Content
PHPClasses
PHP Editor
PHP Jobs
Vision.To Design
Ajax Tutorials
PHP Programming Help
PHP/MySQL Programming
Webmaster Resources
Webmaster Forum
XML meta language
website builder
Submit Site
Forex Trading Online forex trading platform

Go Back Add a Comment Send this example to a friend Add this Article to your personal favoritest for easy future access to your favorite Code Examples and Articles. Submit a code example Print this code example.
BACK ADD A COMMENT SEND TO A FRIEND ADD TO MY FAVORITES ADD CODE EXAMPLES PRINT
Title : Simple class that uses GD to draw pie charts. After the class definition there's some sample code to demonstrate how you use the class.
Categories : Graphics, PHP, PHP Classes, GD image library, Charts and Graphs Update Picture
Bj?/TD Borud
Date : Jan 17th 1999
Grade : 5 of 5 (graded 2 times)
Viewed : 9600
File : No file for this code example.
Images : No Images for this code example.
Search : More code by Bj?/TD Borud
Action : Grade This Code Example
Tools : My Examples List

  Submit your own code examples 
 

<?php /* -*- C -*- */
/*
** $Id: piechart.phl,v 1.2 1998/02/03 16:55:06 borud Exp $
**
** PHP Class for creating pie charts using the GD library functions.
**
** There is a bug in the GD library somewhere that seems to kick in
** when you try to return images that are larger than 4K. We probably
** need a workaround for this...
**
** Pie charts look a bit shabby. There seems to be one or more
** roundoff errors lurking about making life hard for us. To fix this
** we should perhaps investigate how the Arc-drawing thingey works and
** try to find out how it gets the endpoints. Also the flood-filler
** doesn't quite cope with filling the pieces very well.
**
** Authors: Bj?Borud, Guardian Networks AS, <borud@guardian.no>
*/

/* {{{ piechart */

/*
** This is a class for creating pie charts. Generally you just have
** to instantiate it, and then make a call to the "init" method to
** set the size and transfer the data.
**
** The data is an array of arrays that consist the following data:
** o numeric value
** o value legend
** o red \
** o green > the RGB values for the color of the slice/legend
** o blue /
**
*/

class piechart {
/* {{{ attributes */

var $im;
var $width, $height;

var $data;
var $colors;
var $angles;

var $left=10;
var $right=200;
var $top=100;
var $bottom=10;
var $head_top=10;
var $head_space=5;

var $legend_left=20;

var $center_x;
var $center_y;
var $diameter;

/* sum of values */
var $sum;

/* font sizes */
var $fx, $fy;

var $legend_num = "";

/* }}} */
/* {{{ constants */

var $PI = 3.1415926535897931;

/* }}} */
/* {{{ roundoff */

/*
** PHP has no function for rounding off doubles to the nearest
** integer so we have to roll our own.
*/
function roundoff ($v) {
if ( $v - floor($v) >= 0.5) {
return(ceil($v));
} else {
return(floor($v));
}
}

/* }}} */
/* {{{ deg2rad */

/*
** The built-in trig functions use radians and there's no
** function in PHP to convert between degrees and radians
*/

function deg2rad ($degrees) {
return (($this->PI * $degrees) / doubleval(180));
}

/* }}} */
/* {{{ get_xy_factors */

/*
** Calculate the directional vector for the sides of the
** piece of pie.
*/

function get_xy_factors ($degrees) {
$x = cos($this->deg2rad($degrees));
$y = sin($this->deg2rad($degrees));
return (array($x, $y));
}

/* }}} */
/* {{{ init */

/*
** Initialize the object and draw the pie. This would be the
** constructor in an ordinary OO scenario -- just that we haven't
** got constructors in PHP, now do we? ;-)
*/

function init ($w, $h, $d) {
$this->im = ImageCreate($w, $h);
$this->width = $w;
$this->height = $h;

$this->data = $d;

$this->da_width = ($this->width - $this->left - $this->right);
$this->da_height = ($this->height - $this->top - $this->bottom);

$this->center_x = intval($this->left + ($this->da_width / 2));
$this->center_y = intval($this->top + ($this->da_height / 2));


/* font sizes */
$this->fx = array(0, 5,6,7,8,9);
$this->fy = array(0, 7,8,10,14,11);

/* decide the diameter of the pie */

if ($this->da_height > $this->da_width) {
$this->diameter = $this->da_width;
} else {
$this->diameter = $this->da_height;
}

$this->white = ImageColorAllocate($this->im, 255, 255, 255);
$this->black = ImageColorAllocate($this->im, 0, 0, 0);

$n = count($this->data);
for ($i = 0; $i < $n; $i++) {
$this->colors[$i] = ImageColorAllocate($this->im, $this->data[$i][2],
$this->data[$i][3],
$this->data[$i][4]);
$this->sum += $this->data[$i][0];
}

$from = 0; $to = 0;

for ($i = 0; $i < $n; $i++) {

$this->angles[$i] = $this->roundoff(($this->data[$i][0] * 360)
/ doubleval($this->sum));
$to = $from + $this->angles[$i];
$col = $this->colors[$i];

$foo = $this->angles[$i];
$this->draw_slice($this->center_x,
$this->center_y,
$from,
$to,
$this->colors[$i]);
$from += $this->angles[$i];
}
}

/* }}} */
/* {{{ set_legend_percent */

/* utility function to set an attribute so we display percentages */
function set_legend_percent () {
$this->legend_num = "p";
}

/* }}} */
/* {{{ set_legend_value */

/* utility function to set an attribute so we display values */
function set_legend_value () {
$this->legend_num = "v";
}

/* }}} */
/* {{{ draw_point */

/*
** This function is just here for debugging purposes. It is
** sometimes very useful to be able to draw an X to check
** coordinates.
*/
function draw_point($x, $y) {
ImageLine($this->im, $x-4, $y-4, $x+4, $y+4, $this->black);
ImageLine($this->im, $x-4, $y+4, $x+4, $y-4, $this->black);
}

/* }}} */
/* {{{ draw_margins */

/*
** Also a debugging function to show where the margins are at
*/
function draw_margins () {

ImageLine($this->im, 0, $this->top, $this->width,
$this->top,
$this->black);

ImageLine($this->im, 0, $this->height - $this->bottom,
$this->width, $this->height - $this->bottom,
$this->black);

ImageLine($this->im, $this->left, 0, $this->left,
$this->height, $this->black);

ImageLine($this->im, $this->width - $this->right,
0, $this->width - $this->right,
$this->height, $this->black);
}

/* }}} */
/* {{{ draw_legends */

/*
** Draw legends at the right side of the pie chart. This function
** accepts a fontsize and gathers all the other information from
** the multilevel data array
*/
function draw_legends ($fontsize) {
$n = count($this->data);

$x1 = $this->width - $this->right + $this->legend_left;
$x2 = $x1 + $this->fy[$fontsize];;

for ($i = 0; $i < $n; $i++) {

/* determine Y coordinates */
$y1 = ($i * $this->fy[$fontsize] * 1.5) + $this->top;
$y2 = $y1 + $this->fy[$fontsize];

/* draw the legend color rectangle */
ImageFilledRectangle($this->im, $x1, $y1, $x2, $y2, $this->colors[$i]);
ImageRectangle($this->im, $x1, $y1, $x2, $y2, $this->black);

$legend = $this->data[$i][1];

/* decide what to show after legend */
switch ($this->legend_num) {
case "v":
$legend .= sprintf( " (%.2f)", $this->data[$i][0]);
break;
case "p":
$legend .= sprintf( " (%.2f%%)",
($this->data[$i][0]
* 100 / doubleval($this->sum)));
break;
}

ImageString($this->im, $fontsize, $x2 + 5, $y1,
$legend, $this->black);
}
}

/* }}} */
/* {{{ draw_heading */

/*
** This function accepts an array of arrays containing (in order):
** o The text of the heading as a string
** o The fontsize as an integer
** o The justification ("c"=center)
**
*/
function draw_heading($head_data) {
$n = count($head_data);

$y = $this->head_top;
for ($i = 0; $i < $n; $i++) {

switch($head_data[$i][2]) {
case "c":
$x = ($this->width - $this->fx[$head_data[$i][1]]
* strlen($head_data[$i][0])) / 2;
break;

case "r": /* uses left margin here... */
$x = $this->width - $this->left -
($this->fx[$head_data[$i][1]] * strlen($head_data[$i][0]));
break;

default:
$x = $this->left;
break;


}

ImageString($this->im, $head_data[$i][1], $x, $y, $head_data[$i][0],
$this->black);

$y += ($this->fy[$head_data[$i][1]] + $this->head_space);
}
}

/* }}} */
/* {{{ draw_slice */

/*
** This function draws a piece of pie centered at x,y starting at
** "from" degrees and ending at "to" degrees using the specified color.
*/
function draw_slice ($x, $y, $from, $to, $color) {

# Awful Kludge!!!
if ($to > 360) {
$to = 360;
}

ImageArc($this->im, $this->center_x, $this->center_y,
$this->diameter, $this->diameter, $from, $to, $color);

/* First line */
$axy2 = $this->get_xy_factors($from);
$ax2 = floor($this->center_x + ($axy2[0] * ($this->diameter /2)));
$ay2 = floor($this->center_y + ($axy2[1] * ($this->diameter /2)));
ImageLine($this->im, $this->center_x, $this->center_y, $ax2, $ay2, $color);

/* Second line */
$bxy2 = $this->get_xy_factors($to);
$bx2 = ceil($this->center_x + ($bxy2[0] * ($this->diameter /2)));
$by2 = ceil($this->center_y + ($bxy2[1] * ($this->diameter /2)));
ImageLine($this->im, $this->center_x, $this->center_y, $bx2, $by2, $color);


/* decide where to start filling, then fill */
$xy2 = $this->get_xy_factors((($to - $from) / 2) + $from);
$x2 = floor($this->center_x + ($xy2[0] * ($this->diameter /3)));
$y2 = floor($this->center_y + ($xy2[1] * ($this->diameter /3)));
ImageFillToBorder($this->im, $x2, $y2, $color, $color);
}

/* }}} */
/* {{{ display */

/*
** Make sure the legends are drawn, then output the image to the
** client
*/
function display() {

$this->draw_legends(2);
# $this->draw_margins();

ImageGif($this->im, "/tmp/pie.gif");

Header( "Content-type: image/gif");
ImageGif($this->im);
}

/* }}} */
};

/* }}} */


/* {{{ Test code */

$vals = array(
array(100, "First value", 190, 0 ,0),
array(100, "Second value", 0, 190, 0),
array(100, "Third value", 0, 0 ,190),
array(100, "Fourth value", 0, 190 ,190),
array(301.2437, "Fifth value", 204, 0 ,204),
array(308, "Sixth value", 204,204,0)
);


$heads = array(
array( "First line (centered)", 4, "c"),
array( "Second line (left justified)", 4, "l"),
array( "Third line (right justified)", 4, "r")
);


$pie = new piechart;
$pie->init(400, 300, $vals);
$pie->draw_heading($heads);
$pie->set_legend_percent();
$pie->display();

/* }}} */

/*
* Local Variables:
* tab-width: 3
* End: */
?>



crop and resize image class using gd library function
Categories : PHP, PHP Classes, GD image library, Graphics
Display a bar chart based on random values.
Categories : Graphics, PHP, GD image library, Charts and Graphs
HTML_Graphs uses PHP to provide a consistent interface for creating HTML based charts. The user of the class sets up arrays that are passed to html_graph() which then takes care of all the messy HTML layout.
Categories : Graphics, Arrays, PHP, PHP Classes, Charts and Graphs
Advanced Image WaterMarker
Categories : PHP, PHP Classes, GD image library, Graphics, Object Oriented
HTML_Graphs provides a simple PHP interface for creating pure HTML charts.
Categories : Graphics, PHP, PHP Classes, Charts and Graphs
imageMarker v 3.00 with new advanced features
Categories : PHP, PHP Classes, Graphics, GD image library
3dLib - a class for drawing in 3D space. Supported functions: Line, SetPixel, Polygon, FilledPolygon, etc. 3dChart() function has been added for one-call drawing of 3d charts. Support of mostly used 3d-transformations.
Categories : Graphics, Math., PHP Classes, PHP, Charts and Graphs
PHP interface class to the eBusiness Charts generatation remote service.
Categories : PHP, PHP Classes, Graphics, Charts and Graphs
Image Generation Class ( PNG Format )
Categories : PHP, GD image library, PHP Classes, Graphics
a simple pie-chart in php3 (with gd)
Categories : PHP, Graphics, GD image library, Charts and Graphs
Create Thumbnails - resize an image - jpeg, jpg, gif, png to the specifed width and height in proportion without loosing out on pixcel quality.
Categories : PHP, GD image library, Graphics
PHP Email image generator - hide your email from bots - using the GD Library
Categories : PHP, Graphics, GD image library, Beginner Guides
A damaged image generator (class) for validating text. CAPTCHA - Completely Automated Public Turing test to tell Computers and Humans Apart
Categories : PHP, PHP Classes, Security, GD image library, Security
Render TTF Text to PNG. Text message, font, size, rotation, padding, color, background, and transparency can all be defined via URL.
Categories : PHP, PHP Classes, Graphics
Annual Bar Chart
Categories : Graphics, PHP, Charts and Graphs