<?php

/*

PHPGraphLib Graphing Library

The first version PHPGraphLib was written in 2007 by Elliott Brueggeman to
deliver PHP generated graphs quickly and easily. It has grown in both features
and maturity since its inception, but remains PHP 4.04+ compatible. Originally
available only for paid commerial use, PHPGraphLib was open-sourced in 2013 
under the MIT License. Please visit http://www.ebrueggeman.com/phpgraphlib 
for more information.

---

The MIT License (MIT)

Copyright (c) 2013 Elliott Brueggeman

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

*/

class PHPGraphLib {

	//set to actual font heights and widths used
	const TITLE_CHAR_WIDTH = 6;
	const TITLE_CHAR_HEIGHT = 12;
	const TEXT_WIDTH = 6;
	const TEXT_HEIGHT = 12;
	const LEGEND_TEXT_WIDTH = 6;
	const LEGEND_TEXT_HEIGHT = 12;
	const DATA_VALUE_TEXT_WIDTH = 6;
	const DATA_VALUE_TEXT_HEIGHT = 12;

	//padding between axis and value displayed
	const AXIS_VALUE_PADDING = 5;

	//space b/t top of bar or center of point and data value
	const DATA_VALUE_PADDING = 5;

	//default margin % of width / height
	const X_AXIS_MARGIN_PERCENT = 12;
	const Y_AXIS_MARGIN_PERCENT = 8;

	//controls auto-adjusting grid interval
	const RANGE_DIVISOR_FACTOR = 25;

	//limit colors allocated for gradient
	const GRADIENT_MAX_COLORS = 200;

	//multiple dataset offset percents
	const MULTI_OFFSET_TWO = 24;
	const MULTI_OFFSET_THREE = 15;
	const MULTI_OFFSET_FOUR = 10;
	const MULTI_OFFSET_FIVE = 9;

	//padding inside legend box
	const LEGEND_PADDING = 4; 
	const LEGEND_MAX_CHARS = 15;

	//display default
	protected $height = 300;
	protected $width = 400;
	protected $bool_bars = true;
	protected $bool_bar_outline = true;
	protected $bool_x_axis = true;
	protected $bool_y_axis = true;
	protected $bool_x_axis_values = true;
	protected $bool_y_axis_values = true;
	protected $bool_grid = true;
	protected $bool_line = false;
	protected $bool_data_values = false;
	protected $bool_x_axis_values_vert = true;
	protected $bool_data_points = false;
	protected $bool_title_left = false;
	protected $bool_title_right = false;
	protected $bool_title_center = true;
	protected $bool_background = false;
	protected $bool_title = false;
	protected $bool_ignore_data_fit_errors = false;
	protected $data_point_width = 6;
	protected $x_axis_value_interval = false;
	
	//internal status vars
	protected $data_set_count = 0;
	protected $data_min = 0;
	protected $data_max = 0;
	protected $data_count = 0;
	protected $bool_data = false;
	protected $bool_bars_generate = true;
	protected $bool_all_negative = false;
	protected $bool_all_positive = false;
	protected $bool_gradient = false;
	protected $bool_user_data_range = false;
	protected $all_zero_data = false;
	protected $bool_gradient_colors_found = array();
	protected $bool_y_axis_setup = false;
	protected $bool_x_axis_setup = false;

	//color vars
	protected $background_color;
	protected $grid_color;
	protected $bar_color;
	protected $outline_color;
	protected $x_axis_text_color;
	protected $y_axis_text_color;
	protected $title_color;
	protected $x_axis_color;
	protected $y_axis_color;
	protected $data_point_color;
	protected $data_value_color;
	protected $line_color = array();
	protected $line_color_default;
	protected $goal_line_color;
	protected $gradient_color_array;
	protected $gradient_handicap = array();

	protected $image;
	protected $output_file;
	protected $error;
	protected $data_array;
	protected $actual_displayed_max_value;
	protected $actual_displayed_min_value;
	protected $data_currency;
	protected $data_format_array = array();
	protected $data_additional_length = 0;
	protected $data_format_generic;

	//bar vars / scale
	protected $bar_width;
	protected $space_width;
	protected $unit_scale;
	protected $goal_line_array = array();
	protected $horiz_grid_lines = array();
	protected $vert_grid_lines = array();
	protected $horiz_grid_values = array();
	protected $vert_grid_values = array();

	//axis points
	protected $x_axis_x1;
	protected $x_axis_y1;
	protected $x_axis_x2;
	protected $x_axis_y2;
	protected $y_axis_x1;
	protected $y_axis_y1;
	protected $y_axis_x2;
	protected $y_axis_y2;
	protected $lowest_x;
	protected $highest_x;

	//aka bottom margin
	protected $x_axis_margin; 

	//aka left margin
	protected $y_axis_margin;

	protected $data_range_max;
	protected $data_range_min;
	protected $top_margin = 0;
	protected $right_margin = 0;
	protected $data_point_array = array();

	protected $multi_gradient_colors_1 = array();
	protected $multi_gradient_colors_2 = array();
	protected $multi_bar_colors = array();

	//percent color decrease for multiple datasets
	protected $color_darken_factor = 30; 

	//legend variables
	protected $bool_legend = false;
	protected $legend_total_chars = array(); 
	
	protected $legend_width;
	protected $legend_height;
	protected $legend_x;
	protected $legend_y;
	protected $legend_color;
	protected $legend_text_color;
	protected $legend_outline_color;
	protected $legend_swatch_outline_color;
	protected $legend_titles = array();

	public function __construct($width, $height, $output_file = null) 
	{
		$this->width = $width;
		$this->height = $height;
		$this->output_file = $output_file;
		$this->initialize();
		$this->allocateColors();
	}

	protected function initialize() 
	{
		//header must be sent before any html or blank space output
		if (!$this->output_file) {
			header("Content-type: image/png");
		}

		$this->image = @imagecreate($this->width, $this->height)
			or die("Cannot Initialize new GD image stream - Check your PHP setup");
	}

	public function createGraph() 
	{
		//main class method - called last
		//setup axis if not already setup by user
		if ($this->bool_data){
			$this->analyzeData();
			if (!$this->bool_x_axis_setup) { 
				$this->setupXAxis(); 
			}
			if (!$this->bool_y_axis_setup){ 
				$this->setupYAxis(); 
			}
			
			//calculations
			$this->calcTopMargin();
			$this->calcRightMargin();
			$this->calcCoords();
			$this->setupData();
			
			//start creating actual image elements
			if ($this->bool_background) { 
				$this->generateBackgound(); 
			}
			
			//always gen grid values, even if not displayed
			$this->setupGrid();

			if ($this->bool_bars_generate) { 
				$this->generateBars(); 
			}
			if ($this->bool_data_points) {
				$this->generateDataPoints(); 
			}
			if ($this->bool_legend) { 
				$this->generateLegend(); 
			}
			if ($this->bool_title) { 
				$this->generateTitle(); 
			}
			if ($this->bool_x_axis) { 
				$this->generateXAxis(); 
			}
			if ($this->bool_y_axis) { 
				$this->generateYAxis(); 
			}
		} else {
			$this->error[] = "No valid data added to graph. Add data with the addData() function.";
		}

		//display errors
		$this->displayErrors();

		//output to browser
		if ($this->output_file) {
			imagepng($this->image, $this->output_file);
		} else {
			imagepng($this->image);
		}
		imagedestroy($this->image);
	}

	protected function setupData()
	{
		$unit_width = ($this->width - $this->y_axis_margin - $this->right_margin) / (($this->data_count * 2) + $this->data_count);
		if ($unit_width < 1 && !$this->bool_ignore_data_fit_errors) {	
			//error units too small, too many data points or not large enough graph
			$this->bool_bars_generate = false;
			$this->error[] = "Graph too small or too many data points.";
		} else {
			//default space between bars is 1/2 the width of the bar
			//find bar and space widths. bar = 2 units, space = 1 unit
			$this->bar_width = 2 * $unit_width;
			$this->space_width = $unit_width;
			//now calculate height (scale) units
			$availVertSpace = $this->height - $this->x_axis_margin - $this->top_margin;	
			if ($availVertSpace < 1) {
				$this->bool_bars_generate = false;
				$this->error[] = "Graph height not tall enough.";
				//error scale units too small, x axis margin too big or graph height not tall enough
			} else {
				if ($this->bool_user_data_range) {
					//if all zero data, set fake max and min to range boundaries
					if ($this->all_zero_data) {
						if ($this->data_range_min > $this->data_min) { 
							$this->data_min = $this->data_range_min; 
						}
						if ($this->data_range_max < $this->data_max) {
							$this->data_max = $this->data_range_max; 
						}
					}

					$graphTopScale = $this->data_range_max;
					$graphBottomScale = $this->data_range_min;
					$graphScaleRange = $graphTopScale - $graphBottomScale;
					$this->unit_scale = $availVertSpace / $graphScaleRange;
					$this->data_max = $this->data_range_max;
					$this->data_min = $this->data_range_min;
					if ($this->data_min < 0) {
						$this->x_axis_y1 -= round($this->unit_scale * abs($this->data_min));
						$this->x_axis_y2 -= round($this->unit_scale * abs($this->data_min));
					}
					//all data identical
					if ($graphScaleRange == 0) {
						$graphScaleRange = 100;
					}
				} else {
					//start at y value 0 or data min, whichever is less
					$graphBottomScale = ($this->data_min<0) ? $this->data_min : 0;
					$graphTopScale = ($this->data_max<0) ? 0 : $this->data_max ;
					$graphScaleRange = $graphTopScale - $graphBottomScale;
					
					//all data identical
					if ($graphScaleRange == 0) {
						$graphScaleRange = 100;
					}
					$this->unit_scale = $availVertSpace / $graphScaleRange;			
					//now adjust x axis in y value if negative values
					if ($this->data_min < 0) {
						$this->x_axis_y1 -= round($this->unit_scale * abs($this->data_min));
						$this->x_axis_y2 -= round($this->unit_scale * abs($this->data_min));
					}
				}
			}
		}
	}

	//always port changes to generatebars() to extensions
	protected function generateBars() 
	{
		$this->finalizeColors();

		$barCount = 0;
		$adjustment = 0;
		if ($this->bool_user_data_range && $this->data_min >= 0) {
			$adjustment = $this->data_min * $this->unit_scale;
		}

		//reverse array to order data sets in order of priority
		$this->data_array = array_reverse($this->data_array);

		//set different offsets based on number of data sets
		$dataset_offset = 0;
		switch ($this->data_set_count) {
			case 2: 
				$dataset_offset = $this->bar_width * (self::MULTI_OFFSET_TWO / 100); 
				break;
			case 3: 
				$dataset_offset = $this->bar_width * (self::MULTI_OFFSET_THREE / 100); 
				break;
			case 4: 
				$dataset_offset = $this->bar_width * (self::MULTI_OFFSET_FOUR / 100); 
				break;
			case 5: 
				$dataset_offset = $this->bar_width * (self::MULTI_OFFSET_FIVE / 100); 
				break;
		}
		
		foreach ($this->data_array as $data_set_num => $data_set) {
			$lineX2 = null;
			reset($data_set);
			$xStart = $this->y_axis_x1 + ($this->space_width / 2) + ((key($data_set) - $this->lowest_x) * ($this->bar_width + $this->space_width));
			foreach ($data_set as $key => $item) {
				$hideBarOutline = false;

				$x1 = round($xStart + ($dataset_offset * $data_set_num));
				$x2 = round(($xStart + $this->bar_width) + ($dataset_offset * $data_set_num));
				$y1 = round($this->x_axis_y1 - ($item * $this->unit_scale) + $adjustment);
				$y2 = round($this->x_axis_y1);
				
				//if we are using a user specified data range, need to limit what's displayed
				if ($this->bool_user_data_range) {
					if ($item <= $this->data_range_min) {
						//don't display, we are out of our allowed display range!
						$y1 = $y2;
						$hideBarOutline = true;
					} elseif ($item >= $this->data_range_max) {
						//display, but cut off display above range max
						$y1 = $this->x_axis_y1 - ($this->actual_displayed_max_value * $this->unit_scale) + $adjustment;	
					}
				}	
				//draw bar 
				if ($this->bool_bars) {
					if ($this->bool_gradient) {
						//draw gradient if desired
						$this->drawGradientBar($x1, $y1, $x2, $y2, $this->multi_gradient_colors_1[$data_set_num], $this->multi_gradient_colors_2[$data_set_num], $data_set_num);
					} else {
						imagefilledrectangle($this->image, $x1, $y1,$x2, $y2,  $this->multi_bar_colors[$data_set_num]);
					}
					//draw bar outline	
					if ($this->bool_bar_outline && !$hideBarOutline) { 
						imagerectangle($this->image, $x1, $y2, $x2, $y1, $this->outline_color); 
					}
				}
				// draw line
				if ($this->bool_line) {
					$lineX1 = $x1 + ($this->bar_width / 2); //MIDPOINT OF BARS, IF SHOWN
					$lineY1 = $y1;
					if (isset($lineX2)) {
						imageline($this->image, $lineX2, $lineY2, $lineX1, $lineY1, $this->line_color[$data_set_num]);
						$lineX2 = $lineX1;
						$lineY2 = $lineY1;
					} else {
						$lineX2 = $lineX1;
						$lineY2 = $lineY1;
					}	
				}
				// display data points
				if ($this->bool_data_points) {
					//dont draw datapoints here or will overlap poorly with line
					//instead collect coordinates
					$pointX = $x1 + ($this->bar_width / 2); //MIDPOINT OF BARS, IF SHOWN
					$this->data_point_array[] = array($pointX, $y1);
				}
				// display data values
				if ($this->bool_data_values) {
					$dataX = ($x1 + ($this->bar_width / 2)) - ((strlen($item) * self::DATA_VALUE_TEXT_WIDTH) / 2);
					//value to be graphed is equal/over 0
					if ($item >= 0) {
						$dataY = $y1 - self::DATA_VALUE_PADDING - self::DATA_VALUE_TEXT_HEIGHT;
					} else {
						//check for item values below user spec'd range
						if ($this->bool_user_data_range && $item <= $this->data_range_min) {
							$dataY = $y1 - self::DATA_VALUE_PADDING - self::DATA_VALUE_TEXT_HEIGHT;
						} else {
							$dataY = $y1 + self::DATA_VALUE_PADDING;
						}
					}
					//add currency sign, formatting etc
					if ($this->data_format_array) {
						$item = $this->applyDataFormats($item);
					}
					if ($this->data_currency) {
						$item = $this->applyDataCurrency($item);
					}
					//recenter data position if necessary
					$dataX -= ($this->data_additional_length * self::DATA_VALUE_TEXT_WIDTH) / 2;
					imagestring($this->image, 2, $dataX, $dataY, $item,  $this->data_value_color);
				}
				//write x axis value 
				if ($this->bool_x_axis_values) {
					{
						if ($this->bool_x_axis_values_vert) {
							if ($this->bool_all_negative) {
								//we must put values above 0 line
								$textVertPos = round($this->y_axis_y2 - self::AXIS_VALUE_PADDING);
							} else {
								//mix of both pos and neg numbers
								//write value y axis bottom value (will be under bottom of grid even if x axis is floating due to
								$textVertPos = round($this->y_axis_y1 + (strlen($key) * self::TEXT_WIDTH) + self::AXIS_VALUE_PADDING);
							}
							$textHorizPos = round($xStart + ($this->bar_width / 2) - (self::TEXT_HEIGHT / 2));
					
							//skip and dispplay every x intervals
							if ($this->x_axis_value_interval) {
								if ($key % $this->x_axis_value_interval) {
								} else {
									imagestringup($this->image, 2, $textHorizPos, $textVertPos, $key,  $this->x_axis_text_color);
								}
							}
							else {
								imagestringup($this->image, 2, $textHorizPos, $textVertPos, $key,  $this->x_axis_text_color);
							}
						}
						else {
							if ($this->bool_all_negative) {
								//we must put values above 0 line
								$textVertPos = round($this->y_axis_y2 - self::TEXT_HEIGHT - self::AXIS_VALUE_PADDING);
							} else {
								//mix of both pos and neg numbers
								//write value y axis bottom value (will be under bottom of grid even if x axis is floating due to
								$textVertPos = round($this->y_axis_y1 + (self::TEXT_HEIGHT * 2 / 3) - self::AXIS_VALUE_PADDING);
							}
							//horizontal data keys
							$textHorizPos = round($xStart + ($this->bar_width / 2) - ((strlen($key) * self::TEXT_WIDTH) / 2));
							
							
							//skip and dispplay every x intervals
							if ($this->x_axis_value_interval) {
								if ($key % $this->x_axis_value_interval) {
								} else {
									imagestring($this->image, 2, $textHorizPos, $textVertPos, $key,  $this->x_axis_text_color);
								}
							} else {
								imagestring($this->image, 2, $textHorizPos, $textVertPos, $key,  $this->x_axis_text_color);
							}
						}
					}
				}
				$xStart += $this->bar_width + $this->space_width;
			}
		}
	}

	protected function finalizeColors()
	{
		if ($this->bool_gradient) {
			$num_set=count($this->multi_gradient_colors_1);
			//loop through set colors and add backing colors if necessary
			if ($num_set != $this->data_set_count) {
				$color_darken_decimal = (100 - $this->color_darken_factor) / 100;
				while ($num_set < $this->data_set_count) {
					$color_ref_1 = $this->multi_gradient_colors_1[$num_set - 1];
					$color_ref_2 = $this->multi_gradient_colors_2[$num_set - 1];
					$this->multi_gradient_colors_1[] = array( 
						round($color_ref_1[0] * $color_darken_decimal),
						round($color_ref_1[1] * $color_darken_decimal),
						round($color_ref_1[2] * $color_darken_decimal));
					$this->multi_gradient_colors_2[]=array(
						round($color_ref_2[0] * $color_darken_decimal),
						round($color_ref_2[1] * $color_darken_decimal),
						round($color_ref_2[2] * $color_darken_decimal));
					$num_set++;
				}	
			}
			while (count($this->multi_gradient_colors_1) > $this->data_set_count) {
				$temp = array_pop($this->multi_gradient_colors_1);
			}
			while (count($this->multi_gradient_colors_2) > $this->data_set_count) {
				$temp = array_pop($this->multi_gradient_colors_2);
			}
			$this->multi_gradient_colors_1 = array_reverse($this->multi_gradient_colors_1);
			$this->multi_gradient_colors_2 = array_reverse($this->multi_gradient_colors_2);
		} elseif (!$this->bool_gradient) {
			$num_set = count($this->multi_bar_colors);
			if ($num_set == 0) {
				$this->multi_bar_colors[0] = $this->bar_color;
				$num_set = 1;
			}
			//loop through set colors and add backing colors if necessary
			while ($num_set < $this->data_set_count) {
				$color_ref = $this->multi_bar_colors[$num_set - 1];
				$color_parts = imagecolorsforindex($this->image, $color_ref);
				$color_darken_decimal = (100 - $this->color_darken_factor) / 100;
				$this->multi_bar_colors[$num_set] = imagecolorallocate($this->image, 
					round($color_parts['red'] * $color_darken_decimal), 
					round($color_parts['green'] * $color_darken_decimal), 
					round($color_parts['blue'] * $color_darken_decimal));
				$num_set++;
			}
			while (count($this->multi_bar_colors) > $this->data_set_count) {
				$temp = array_pop($this->multi_bar_colors);
			}
			$this->multi_bar_colors = array_reverse($this->multi_bar_colors);
		}
		if ($this->bool_line) {
			if (!$this->bool_bars) {
				$num_set = count($this->line_color);
				if ($num_set == 0) {
					$this->line_color[0] = $this->line_color_default;
					$num_set = 1;
				}
				//only darken each data set's lines when no bars present
				while ($num_set < $this->data_set_count) {
					$color_ref = $this->line_color[$num_set - 1];
					$color_parts = imagecolorsforindex($this->image, $color_ref);
					$color_darken_decimal = (100 - $this->color_darken_factor) / 100;
					$this->line_color[$num_set] = imagecolorallocate($this->image, 
						round($color_parts['red'] * $color_darken_decimal), 
						round($color_parts['green'] * $color_darken_decimal), 
						round($color_parts['blue'] * $color_darken_decimal));
					$num_set++;
				}
			} else {
				$num_set = count($this->line_color);
				while ($num_set < $this->data_set_count) {
					$this->line_color[$num_set] = $this->line_color_default;
					$num_set++;
				}
			}
			while (count($this->line_color) > $this->data_set_count) {
				$temp = array_pop($this->line_color);
			}
			$this->line_color = array_reverse($this->line_color);
		}	
	}

	protected function drawGradientBar($x1, $y1, $x2, $y2, $colorArr1, $colorArr2, $data_set_num) 
	{
		if (!isset($this->bool_gradient_colors_found[$data_set_num]) || $this->bool_gradient_colors_found[$data_set_num] == false) {
			$this->gradient_handicap[$data_set_num] = 0;
			$numLines = abs($x1 - $x2) + 1;
			while ($numLines * $this->data_set_count > self::GRADIENT_MAX_COLORS) {
				//we have more lines than allowable colors
				//use handicap to record this
				$numLines /= 2;
				$this->gradient_handicap[$data_set_num]++;
			}
			$color1R = $colorArr1[0];
			$color1G = $colorArr1[1];
			$color1B = $colorArr1[2];
			$color2R = $colorArr2[0];
			$color2G = $colorArr2[1];
			$color2B = $colorArr2[2];
			$rScale = ($color1R-$color2R) / $numLines;
			$gScale = ($color1G-$color2G) / $numLines;
			$bScale = ($color1B-$color2B) / $numLines;
			$this->allocateGradientColors($color1R, $color1G, $color1B, $rScale, $gScale, $bScale, $numLines, $data_set_num);
		}
		$numLines = abs($x1 - $x2) + 1;
		if ($this->gradient_handicap[$data_set_num] > 0) {
			//if handicap is used, it will allow us to move through the array more slowly, depending on the set value
			$interval = $this->gradient_handicap[$data_set_num];
			for($i = 0; $i < $numLines; $i++) {
				$adjusted_index = ceil($i / pow(2, $interval)) - 1;
				if ($adjusted_index < 0) {
					$adjusted_index = 0;
				}
				imageline($this->image, $x1+$i, $y1, $x1 + $i, $y2, $this->gradient_color_array[$data_set_num][$adjusted_index]);		
			}
		} else {
			//normal gradients with colors < self::GRADIENT_MAX_COLORS
			for ($i = 0; $i < $numLines; $i++) {
				imageline($this->image, $x1+$i, $y1, $x1+$i, $y2, $this->gradient_color_array[$data_set_num][$i]);		
			}
		}
	}

	protected function setupGrid() 
	{
		//adjustment for when user sets their data display range
		$adjustment = 0;
		if ($this->bool_user_data_range && $this->data_min >= 0) {
			$adjustment = $this->data_min * $this->unit_scale;
		}

		$this->calculateGridHoriz($adjustment);
		$this->calculateGridVert();
		$this->generateGrids();
		$this->generateGoalLines($adjustment);
	}

	protected function calculateGridHoriz($adjustment = 0) 
	{
		//determine horizontal grid lines
		$horizGridArray = array();
		$min = $this->bool_user_data_range ? $this->data_min : 0;
		$horizGridArray[] = $min;

		//use our function to determine ideal y axis scale interval
		$intervalFromZero = $this->determineAxisMarkerScale($this->data_max, $this->data_min);

		//if we have positive values, add grid values to array 
		//until we reach the max needed (we will go 1 over)
		$cur = $min;
		while ($cur < $this->data_max) {
			$cur += $intervalFromZero;
			$horizGridArray[] = $cur;
		}

		//if we have negative values, add grid values to array 
		//until we reach the min needed (we will go 1 over)
		$cur = $min;
		while ($cur > $this->data_min) {
			$cur -= $intervalFromZero;
			$horizGridArray[] = $cur;
		}

		//sort needed b/c we will use last value later (max)
		sort($horizGridArray);
		$this->actual_displayed_max_value = $horizGridArray[count($horizGridArray) - 1];
		$this->actual_displayed_min_value = $horizGridArray[0];	

		//loop through each horizontal line
		foreach ($horizGridArray as $value) {
			$yValue = round($this->x_axis_y1 - ($value * $this->unit_scale) + $adjustment);
			if ($this->bool_grid) {
				//imageline($this->image, $this->y_axis_x1, $yValue, $this->x_axis_x2 , $yValue, $this->grid_color);
				$this->horiz_grid_lines[] = array('x1' => $this->y_axis_x1, 'y1' => $yValue, 
					'x2' => $this->x_axis_x2, 'y2' => $yValue, 'color' => $this->grid_color);
			}
			//display value on y axis if desired using calc'd grid values
			if ($this->bool_y_axis_values) {
				$adjustedYValue = $yValue - (self::TEXT_HEIGHT / 2);
				$adjustedXValue = $this->y_axis_x1 - ((strlen($value) + $this->data_additional_length) * self::TEXT_WIDTH) - self::AXIS_VALUE_PADDING;
				//add currency sign, formatting etc
				if ($this->data_format_array) {
					$value = $this->applyDataFormats($value);
				}
				if ($this->data_currency) {
					$value = $this->applyDataCurrency($value);
				}
				//imagestring($this->image, 2, $adjustedXValue, $adjustedYValue, $value, $this->y_axis_text_color);
				$this->horiz_grid_values[] = array('size' => 2, 'x' => $adjustedXValue, 'y' => $adjustedYValue,
					'value' => $value, 'color' => $this->y_axis_text_color);
			}
		}
		if (!$this->bool_all_positive && !$this->bool_user_data_range) {
			//reset with better value based on grid min value calculations, not data min
			$this->y_axis_y1 = $this->x_axis_y1 - ($horizGridArray[0] * $this->unit_scale);
		}
		//reset with better value based on grid value calculations, not data min
		$this->y_axis_y2 = $yValue;
	}

	protected function calculateGridVert()
	{
		//determine vertical grid lines
		$vertGridArray = array();
		$vertGrids = $this->data_count + 1;
		$interval = $this->bar_width + $this->space_width;
		//assemble vert gridline array
		for ($i = 1; $i < $vertGrids; $i++) {
			$vertGridArray[] = $this->y_axis_x1 + ($interval * $i);
		}
		
		//loop through each vertical line
		if ($this->bool_grid) {
			$xValue = $this->y_axis_y1;
			foreach ($vertGridArray as $value) {
				//imageline($this->image, $value, $this->y_axis_y2, $value, $xValue , $this->grid_color);
				$this->vert_grid_lines[] = array('x1' => $value, 'y1' => $this->y_axis_y2, 
					'x2' => $value, 'y2' => $xValue, 'color' => $this->grid_color);
			}
		}
	}

	protected function imagelinedashed(&$image_handle, $x_axis_x1, $yLocation, $x_axis_x2, $color)
	{
		$step  = 3;
		for ($i = $x_axis_x1; $i < $x_axis_x2 -1; $i += ($step*2)) {
			imageline($this->image, $i, $yLocation,  $i + $step - 1, $yLocation, $color);
		}
	}

	protected function generateGrids() 
	{
		//loop through and display values
		foreach ($this->horiz_grid_lines as $line) {
			imageline($this->image, $line['x1'], $line['y1'], $line['x2'], $line['y2'] , $line['color']);
		}
		foreach ($this->vert_grid_lines as $line) {
			imageline($this->image, $line['x1'], $line['y1'], $line['x2'], $line['y2'] , $line['color']);
		}
		foreach ($this->horiz_grid_values as $value) {
			imagestring($this->image, $value['size'], $value['x'], $value['y'], $value['value'], $value['color']);
		}
		//not implemented in the base library, but used in extensions
		foreach ($this->vert_grid_values as $value) {
			imagestring($this->image, $value['size'], $value['x'], $value['y'], $value['value'], $value['color']);
		}
	}

	protected function generateGoalLines($adjustment = 0) 
	{
		//draw goal lines if present (after grid) - doesn't get executed if array empty
		foreach ($this->goal_line_array as $goal_line_data) {
			$yLocation = $goal_line_data['yValue'];
			$style = $goal_line_data['style'];
			$color = $goal_line_data['color'] ? $goal_line_data['color'] : $this->goal_line_color;
			$yLocation = round(($this->x_axis_y1 - ($yLocation * $this->unit_scale) + $adjustment));

			if ($style == 'dashed') {
				$this->imagelinedashed($this->image, $this->x_axis_x1, $yLocation, $this->x_axis_x2, $color);
			} else {
				//a solid line is the default if a style condition is not matched
				imageline($this->image, $this->x_axis_x1, $yLocation, $this->x_axis_x2 , $yLocation, $color);
			}
		}
	}

	protected function generateDataPoints() 
	{
		foreach ($this->data_point_array as $pointArray) {
			imagefilledellipse($this->image, $pointArray[0], $pointArray[1], $this->data_point_width, $this->data_point_width, $this->data_point_color);
		}		
	}

	protected function generateXAxis() 
	{
		imageline($this->image, $this->x_axis_x1, $this->x_axis_y1, $this->x_axis_x2, $this->x_axis_y2, $this->x_axis_color);
	}

	protected function generateYAxis() 
	{
		imageline($this->image, $this->y_axis_x1, $this->y_axis_y1, $this->y_axis_x2, $this->y_axis_y2, $this->y_axis_color);
	}

	protected function generateBackgound() 
	{
		imagefilledrectangle($this->image, 0, 0, $this->width, $this->height, $this->background_color);
	}

	protected function generateTitle() 
	{
		//spacing may have changed since earlier
		//use top margin or grid top y, whichever less
		$highestElement = ($this->top_margin < $this->y_axis_y2) ? $this->top_margin : $this->y_axis_y2;
		$textVertPos = ($highestElement / 2) - (self::TITLE_CHAR_HEIGHT / 2); //centered
		$titleLength = strlen($this->title_text);
		if ($this->bool_title_center) {
			$title_x = ($this->width / 2) - (($titleLength * self::TITLE_CHAR_WIDTH) / 2);
			$title_y = $textVertPos;
		} elseif ($this->bool_title_left) {
			$title_x = $this->y_axis_x1;
			$title_y = $textVertPos;
		} elseif ($this->bool_title_right) {
			$this->title_x = $this->x_axis_x2 - ($titleLength * self::TITLE_CHAR_WIDTH);
			$this->title_y = $textVertPos;
		}
		imagestring($this->image, 2, $title_x , $title_y , $this->title_text,  $this->title_color);
	}

	protected function calcTopMargin() 
	{
		if ($this->bool_title) {
			//include space for title, approx margin + 3*title height
			$this->top_margin = ($this->height * (self::X_AXIS_MARGIN_PERCENT / 100)) + self::TITLE_CHAR_HEIGHT;
		} else {
			//just use default spacing
			$this->top_margin = $this->height * (self::X_AXIS_MARGIN_PERCENT / 100);
		}	
	}

	protected function calcRightMargin() 
	{
		//just use default spacing
		$this->right_margin = $this->width * (self::Y_AXIS_MARGIN_PERCENT / 100);
	}

	protected function calcCoords() 
	{
		//calculate axis points, also used for other calculations
		$this->x_axis_x1 = $this->y_axis_margin;
		$this->x_axis_y1 = $this->height - $this->x_axis_margin;
		$this->x_axis_x2 = $this->width - $this->right_margin;
		$this->x_axis_y2 = $this->height - $this->x_axis_margin;
		$this->y_axis_x1 = $this->y_axis_margin;
		$this->y_axis_y1 = $this->height - $this->x_axis_margin;
		$this->y_axis_x2 = $this->y_axis_margin;
		$this->y_axis_y2 = $this->top_margin;
	}
	
	protected function determineAxisMarkerScale($max, $min, $axis = 'y') 
	{
		switch ($axis) {
			case 'y' : 
				$space = $this->height; 
				break;
			case 'x' : 
				$space = $this->width; 
				break;
		}
	
		//for calclation, take range or max-0
		if ($this->bool_user_data_range) {
			$range = abs($max - $min);
		} else {
			$range = (abs($max-$min) > abs($max - 0)) ? abs($max - $min) : abs($max - 0);
		}
		//handle all zero data
		if ($range == 0) {
			$range = 10;
		}
		//multiply up to over 100, to better figure interval
		$count = 0;
		while (abs($range) < 100) {
			$range *= 10;
			$count++;
		}
		//divide into intervals based on height / preset constant - after rounding will be approx
		$divisor = round($space / self::RANGE_DIVISOR_FACTOR);
		$divided = round($range / $divisor);
		$result = $this->roundUpOneExtraDigit($divided);
		//if rounded up w/ extra digit is more than 200% of divided value,
		//round up to next sig number with same num of digits
		if ($result / $divided >= 2) {
			$result = $this->roundUpSameDigits($divided);
		}
		//divide back down, if needed
		for ($i = 0; $i < $count; $i++) {
			$result /= 10;
		}
		return $result;	
	}
	
	protected function roundUpSameDigits($num) 
	{           
		$len = strlen($num);  
		if (round($num, -1 * ($len - 1)) == $num) {
			//we already have a sig number
			return $num;
		} else {
			$firstDig = substr($num, 0,1);
			$secondDig = substr($num, 1,1);
			$rest = substr($num, 2);
			$secondDig = 5;
			$altered = $firstDig.$secondDig.$rest;
			//after reassembly, round up to next sig number, same # of digits
			return round((int)$altered, -1 * ($len - 1));
		}
	}

	protected function roundUpOneExtraDigit($num) 
	{                     
		$len = strlen($num);  
		$firstDig = substr($num, 0, 1);
		$rest = substr($num, 1);
		$firstDig = 5;
		$altered = $firstDig . $rest;
		//after reassembly, round up to next sig number, one extra # of digits
		return round((int)$altered, -1 * ($len)); 
	}

	protected function displayErrors() 
	{
		if (count($this->error) > 0) {
			$lineHeight = 12;
			$errorColor = imagecolorallocate($this->image, 0, 0, 0);
			$errorBackColor = imagecolorallocate($this->image, 255, 204, 0);
			imagefilledrectangle($this->image, 0, 0, $this->width - 1, 2 * $lineHeight,  $errorBackColor);
			imagestring($this->image, 3, 2, 0, "!!----- PHPGraphLib Error -----!!",  $errorColor);
			foreach($this->error as $key => $errorText) {
				imagefilledrectangle($this->image, 0, ($key * $lineHeight) + $lineHeight, $this->width - 1, ($key * $lineHeight) + 2 * $lineHeight,  $errorBackColor);	
				imagestring($this->image, 2, 2, ($key * $lineHeight) + $lineHeight, "[". ($key + 1) . "] ". $errorText,  $errorColor);	
			}
			$errorOutlineColor = imagecolorallocate($this->image, 255, 0, 0);
			imagerectangle($this->image, 0, 0, $this->width-1,($key * $lineHeight) + 2 * $lineHeight,  $errorOutlineColor);		
		}
	}

	public function addData($data, $data2 = '', $data3 = '', $data4 = '', $data5 = '') 
	{
		$data_sets = array($data, $data2, $data3, $data4, $data5);

		foreach ($data_sets as $set) {
			if (is_array($set)) {
				$this->data_array[] = $set;
			}
		}

		//get rid of bad data, find max, min
		$low_x = 0;
		$high_x = 0;
		$force_set_x = 1;
		foreach ($this->data_array as $data_set_num => $data_set) {
			foreach ($data_set as $key => $item) {
				if ($force_set_x) {
					$low_x = $key;
					$high_x = $key;
					$force_set_x = 0;
				}
				if ($key < $low_x) {
					$low_x = $key;
				}
				if ($key > $high_x) {
					$high_x = $key;
				}
				if (!is_numeric($item)) {
					unset($this->data_array[$data_set_num][$key]);
					continue;
				}
				if ($item < $this->data_min) { 
					$this->data_min = $item;
				}
				if ($item > $this->data_max) { 
					$this->data_max = $item; 
				}
			}
			//find the count of the dataset with the most data points
			$count = count($this->data_array[$data_set_num]);
			if ($count > $this->data_count) {
				$this->data_count = $count;
			}
		}
		$this->lowest_x = $low_x;
		$this->highest_x = $high_x;
		$raw_size = $high_x - $low_x +1;
		if ($raw_size > $this->data_count) {
			$this->data_count = $raw_size;
		}

		//number of valid data sets
		$this->data_set_count = count($this->data_array);
		if ($this->data_set_count == 0) {
			$this->error[] = "No valid datasets added in adddata() function.";
			return;
		}
		
		$this->bool_data = true;
	}

	protected function analyzeData() 
	{
		if ($this->data_min >= 0) {
			$this->bool_all_positive = true;
		} elseif ($this->data_max <= 0) {
			$this->bool_all_negative = true;
		}
		//setup static max and min for all zero data
		if ($this->data_min >= 0 && $this->data_max == 0 ) {
			$this->data_min = 0;
			$this->data_max = 10;
			$this->all_zero_data = true;
		} 
	}

	public function setupXAxis($percent = '', $color = '') 
	{
		$this->bool_x_axis_setup = true;
		if ($percent === false) {
			$this->bool_x_axis = false;
		} else {
			$this->bool_x_axis = true;
		}
		if (!empty($color) && $arr = $this->returnColorArray($color)) {
			$this->x_axis_color = imagecolorallocate($this->image, $arr[0], $arr[1], $arr[2]);
		}
		if (is_numeric($percent) && $percent > 0) { 
			$percent = $percent / 100;
			$this->x_axis_margin = round($this->height * $percent);
		} else {
			$percent = self::X_AXIS_MARGIN_PERCENT / 100;
			$this->x_axis_margin = round($this->height * $percent);
		}	
	}

	public function setupYAxis($percent = '', $color = '') 
	{
		$this->bool_y_axis_setup = true;
		if ($percent === false) {
			$this->bool_y_axis = false;
		} else {
			$this->bool_y_axis = true;
		}
		if (!empty($color) && $arr = $this->returnColorArray($color)) {
			$this->y_axis_color = imagecolorallocate($this->image, $arr[0], $arr[1], $arr[2]);
		}
		if (is_numeric($percent) && $percent > 0) { 
			$this->y_axis_margin = round($this->width * ($percent / 100));
		} else {
			$percent = self::Y_AXIS_MARGIN_PERCENT / 100;
			$this->y_axis_margin = round($this->width * $percent);
		}
	}

	public function setRange($min, $max) 
	{
		//because of deprecated use of this function as($max, $min)
		if ($min > $max) {
			$this->data_range_max = $min;
			$this->data_range_min = $max;
		} else {
			$this->data_range_max = $max;
			$this->data_range_min = $min;
		}
		$this->bool_user_data_range = true;
	}

	public function setTitle($title) 
	{
		if (!empty($title)) {
			$this->title_text = $title;
			$this->bool_title = true;
		} else { 
			$this->error[] = "String arg for setTitle() not specified properly."; 
		}	
	}

	public function setTitleLocation($location) 
	{
		$this->bool_title_left = false;
		$this->bool_title_right = false;
		$this->bool_title_center = false;
		switch (strtolower($location)) {
			case 'left': 
				$this->bool_title_left = true;
				break;
			case 'right': 
				$this->bool_title_right = true;
				break;
			case 'center':
				$this->bool_title_center = true;
				break;
			default: 
				$this->error[] = "String arg for setTitleLocation() not specified properly.";
		}	
	}

	public function setBars($bool) 
	{
		if (is_bool($bool)) { 
			$this->bool_bars = $bool;
		} else { 
			$this->error[] = "Boolean arg for setBars() not specified properly.";
		}
	}

	public function setGrid($bool) 
	{
		if (is_bool($bool)) { 
			$this->bool_grid = $bool;
		} else { 
			$this->error[] = "Boolean arg for setGrid() not specified properly.";
		}
	}

	public function setXValues($bool) 
	{
		if (is_bool($bool)) {
			$this->bool_x_axis_values = $bool;
		} else { 
			$this->error[] = "Boolean arg for setXValues() not specified properly.";
		}
	}

	public function setYValues($bool) 
	{
		if (is_bool($bool)) {
			$this->bool_y_axis_values = $bool;
		} else { 
			$this->error[] = "Boolean arg for setYValues() not specified properly.";
		}
	}

	public function setXValuesHorizontal($bool) 
	{
		if (is_bool($bool)) {
			$this->bool_x_axis_values_vert = !$bool;
		} else {
			$this->error[] = "Boolean arg for setXValuesHorizontal() not specified properly."; 
		}
	}

	public function setXValuesVertical($bool) 
	{
		if (is_bool($bool)) {
			$this->bool_x_axis_values_vert = $bool;
		} else {
			$this->error[] = "Boolean arg for setXValuesVertical() not specified properly.";
		}
	}

	public function setXValuesInterval($value)
	{
		if (is_int($value) && $value > 0) {
			$this->x_axis_value_interval = $value;
		} else {
			$this->error[] = "Value arg for setXValuesInterval() not specified properly.";
		}
	}

	public function setBarOutline($bool) 
	{
		if (is_bool($bool)) {
			$this->bool_bar_outline = $bool;
		} else {
			$this->error[] = "Boolean arg for setBarOutline() not specified properly.";
		}
	}

	public function setDataPoints($bool) 
	{
		if (is_bool($bool)) {
			$this->bool_data_points = $bool;
		} else {
			$this->error[] = "Boolean arg for setDataPoints() not specified properly.";
		}
	}

	public function setDataPointSize($size) 
	{
		if (is_numeric($size)) {
			$this->data_point_width = $size;
		} else {
			$this->error[] = "Data point size in setDataPointSize() not specified properly.";
		}
	}

	public function setDataValues($bool) 
	{
		if (is_bool($bool)) {
			$this->bool_data_values = $bool;
		}
		else {
			$this->error[] = "Boolean arg for setDataValues() not specified properly.";
		}
	}

	public function setDataCurrency($currency_type = 'dollar')
	{
		switch (strtolower($currency_type)) {
			case 'dollar': $this->data_currency = '$'; break;
			case 'yen': $this->data_currency = '¥'; break;
			case 'pound': $this->data_currency = '£'; break;
			case 'lira': $this->data_currency = '£'; break;
			// Euro doesn't display properly
			// Franc doesn't display properly
			default: $this->data_currency = $currency_type; break;
		}
		$this->data_additional_length += strlen($this->data_currency);
	}

	protected function applyDataCurrency($input)
	{
		return $this->data_currency . $input;
	}

	public function setDataFormat($format)
	{
		//setup structure for future additional data formats - specify callback functions
		switch ($format) {
			case 'comma':
				$this->data_format_array[] = 'formatDataAsComma';
				$this->data_additional_length += floor(strlen($this->data_max) / 3);
				break;
			case 'percent':
				$this->data_format_array[] = 'formatDataAsPercent';
				$this->data_additional_length++; 
				break;
			case 'degrees':
				$this->data_format_array[] = 'formatDataAsDegrees';
				$this->data_additional_length++; 
				break;
			default: 
				$this->data_format_array[] = 'formatDataAsGeneric';
				$this->data_format_generic = $format; 
				$this->data_additional_length += strlen($format);
				break;
		}
	}

	protected function applyDataFormats($input)
	{
		//comma formatting must be done first
		if ($pos = array_search('formatDataAsComma', $this->data_format_array)) {
			unset($this->data_format_array[$pos]);
			array_unshift($this->data_format_array, 'formatDataAsComma');
		}
		//loop through each formatting function
		foreach ($this->data_format_array as $format_type_callback) {
			eval('$input=$this->' . $format_type_callback . '($input);');
		}
		return $input;
	}

	protected function formatDataAsComma($input)
	{
		//check for negative sign
		$sign_part = '';
		if (substr($input, 0, 1) == '-') {
			$input = substr($input, 1);
			$sign_part = '-';
		}
		//handle decimals
		$decimal_part = '';
		if (($pos = strpos($input, '.')) !== false) {
			$decimal_part = substr($input, $pos);
			$input = substr($input, 0, $pos);
		}
		//turn data into format 12,234...
		$parts = '';
		while (strlen($input)>3) {
			$parts = ',' . substr($input, -3) . $parts;	
			$input = substr($input, 0, strlen($input) - 3);
		}
		return $sign_part . $currency_part . $input . $parts . $decimal_part;
	}

	protected function formatDataAsPercent($input)
	{
		return $input . '%';
	}

	protected function formatDataAsDegrees($input)
	{
		return $input . '°';
	}

	protected function formatDataAsGeneric($input)
	{
		return $input . $this->data_format_generic;
	}

	public function setLine($bool)
	{
		if (is_bool($bool)) { 
			$this->bool_line = $bool;
		} else { 
			$this->error[] = "Boolean arg for setLine() not specified properly.";
		}
	}

	public function setGoalLine($yValue, $color = null, $style = 'solid')
	{
		if (is_numeric($yValue)) {
			if ($color) {
				$this->setGenericColor($color, '$this->goal_line_custom_color', "Goal line color not specified properly.");	
				$color = $this->goal_line_custom_color;
			}
			$this->goal_line_array[] = array(
				'yValue' => $yValue, 
				'color' => $color, 
				'style' => $style
			);
			if($yValue > $this->data_max) {
				$this->data_range_max = $yValue;
				$this->bool_user_data_range = true;
			}
		} else {
			$this->error[] = "Goal line Y axis value not specified properly.";
		}
	}

	protected function allocateColors() 
	{
		$this->background_color = imagecolorallocate($this->image, 255, 255, 255);
		$this->grid_color = imagecolorallocate($this->image, 220, 220, 220);
		$this->bar_color = imagecolorallocate($this->image, 200, 200, 200);
		$this->line_color_default = imagecolorallocate($this->image, 100, 100, 100);
		$this->x_axis_text_color = $this->line_color_default;
		$this->y_axis_text_color = $this->line_color_default;
		$this->data_value_color = $this->line_color_default;
		$this->title_color = imagecolorallocate($this->image, 0, 0, 0);
		$this->outline_color = $this->title_color;
		$this->data_point_color = $this->title_color;
		$this->x_axis_color = $this->title_color;
		$this->y_axis_color = $this->title_color;
		$this->goal_line_color = $this->title_color;
		$this->legend_outline_color = $this->grid_color;
		$this->legend_color = $this->background_color;
		$this->legend_text_color = $this->line_color_default;
		$this->legend_swatch_outline_color = $this->line_color_default;
	}

	protected function returnColorArray($color) 
	{
		//check to see if color passed through in form '128,128,128' or hex format
		if (strpos($color,',') !== false) {
			return explode(',', $color);
		} elseif (substr($color, 0, 1) == '#') {	
			if (strlen($color) == 7) {
				$hex1 = hexdec(substr($color, 1, 2));
				$hex2 = hexdec(substr($color, 3, 2));
				$hex3 = hexdec(substr($color, 5, 2));
				return array($hex1, $hex2, $hex3);
			} elseif (strlen($color) == 4) {
				$hex1 = hexdec(substr($color, 1, 1) . substr($color, 1, 1));
				$hex2 = hexdec(substr($color, 2, 1) . substr($color, 2, 1));
				$hex3 = hexdec(substr($color, 3, 1) . substr($color, 3, 1));
				return array($hex1, $hex2, $hex3);
			}			
		}

		switch (strtolower($color)) {
			//named colors based on W3C's recd html colors
			case 'black':  return array(0,0,0); break;
			case 'silver': return array(192,192,192); break;
			case 'gray':   return array(128,128,128); break;
			case 'white':  return array(255,255,255); break;
			case 'maroon': return array(128,0,0); break;
			case 'red':    return array(255,0,0); break;
			case 'purple': return array(128,0,128); break;
			case 'fuscia': return array(255,0,255); break;
			case 'green':  return array(0,128,0); break;
			case 'lime':   return array(0,255,0); break;
			case 'olive':  return array(128,128,0); break;
			case 'yellow': return array(255,255,0); break;
			case 'navy':   return array(0,0,128); break;	
			case 'blue':   return array(0,0,255); break;
			case 'teal':   return array(0,128,128); break;
			case 'aqua':   return array(0,255,255); break;	
		}

		$this->error[] = "Color name \"$color\" not recogized.";
		return false;
	}

	protected function allocateGradientColors($color1R, $color1G, $color1B, $rScale, $gScale, $bScale, $num, $data_set_num)
	{
		//caluclate the colors used in our gradient and store them in array
		$this->gradient_color_array[$data_set_num] = array();
		for ($i = 0; $i <= $num + 1; $i++) {
			$this->gradient_color_array[$data_set_num][$i] = imagecolorallocate($this->image, $color1R - ($rScale * $i), $color1G - ($gScale * $i), $color1B - ($bScale * $i));
		}
		$this->bool_gradient_colors_found[$data_set_num] = true;
	}

	protected function setGenericColor($inputColor, $var, $errorMsg)
	{
		//can be used for most color setting options
		if (!empty($inputColor) && ($arr = $this->returnColorArray($inputColor))) {
			eval($var . ' = imagecolorallocate($this->image, $arr[0], $arr[1], $arr[2]);');
			return true;	
		}
		else {
			$this->error[] = $errorMsg;
			return false;
		}
	}

	public function setBackgroundColor($color) 
	{
		if ($this->setGenericColor($color, '$this->background_color', "Background color not specified properly.")) {
			$this->bool_background = true;
		}
	}

	public function setTitleColor($color)
	{
		$this->setGenericColor($color, '$this->title_color', "Title color not specified properly.");
	}

	public function setTextColor($color)
	{
		$this->setGenericColor($color, '$this->x_axis_text_color', "X axis text color not specified properly.");
		$this->setGenericColor($color, '$this->y_axis_text_color', "Y axis Text color not specified properly.");
	}

	public function setXAxisTextColor($color) 
	{
		$this->setGenericColor($color, '$this->x_axis_text_color', "X axis text color not specified properly.");
	}

	public function setYAxisTextColor($color) 
	{
		$this->setGenericColor($color, '$this->y_axis_text_color', "Y axis Text color not specified properly.");
	}

	public function setBarColor($color1, $color2 = '', $color3 = '', $color4 = '', $color5 = '')
	{
		$bar_colors = array($color1, $color2, $color3, $color4, $color5);
		foreach ($bar_colors as $key => $color) {
			if ($color) {
				$this->setGenericColor($color, '$this->multi_bar_colors[]', "Bar color " . ($key + 1) . " not specified properly.");
			}
		}
	}

	public function setGridColor($color)
	{
		$this->setGenericColor($color, '$this->grid_color', "Grid color not specified properly.");
	}

	public function setBarOutlineColor($color)
	{
		$this->setGenericColor($color, '$this->outline_color', "Bar outline color not specified properly.");
	}

	public function setDataPointColor($color)
	{
		$this->setGenericColor($color, '$this->data_point_color', "Data point color not specified properly.");
	}

	public function setDataValueColor($color)
	{
		$this->setGenericColor($color, '$this->data_value_color', "Data value color not specified properly.");
	}

	public function setLineColor($color1, $color2 = '', $color3 = '', $color4 = '', $color5 = '')
	{
		$line_colors = array($color1, $color2, $color3, $color4, $color5);
		foreach ($line_colors as $key => $color) {
			if ($color) {
				$this->setGenericColor($color, '$this->line_color[]', "Line color " . ($key + 1) . " not specified properly.");
			}
		}
	}

	/* @deprecated - setGoalLineColor() replaced with 2nd parameter of setGoalLine() */
	public function setGoalLineColor($color) {
		$this->setGenericColor($color, '$this->goal_line_color', "Goal line color not specified properly.");
	}

	public function setGradient($color1, $color2, $color3 = '', $color4 = '', $color5 = '', $color6 = '', $color7 = '', $color8 = '', $color9 = '', $color10 = '') 
	{
		if (!empty($color1) && !empty($color2) && ($arr1 = $this->returnColorArray($color1)) && ($arr2 = $this->returnColorArray($color2))) {
			$this->bool_gradient = true;
			$this->multi_gradient_colors_1[] = $arr1;
			$this->multi_gradient_colors_2[] = $arr2;
		}
		else {
			$this->error[] = "Gradient color(s) not specified properly.";
		}

		//Optional gradients
		if (!empty($color3) && !empty($color4) && ($arr1 = $this->returnColorArray($color3)) && ($arr2 = $this->returnColorArray($color4))) {
			$this->bool_gradient = true;
			$this->multi_gradient_colors_1[]=$arr1;
			$this->multi_gradient_colors_2[]=$arr2;
		}
		if (!empty($color5) && !empty($color6) && ($arr1 = $this->returnColorArray($color5)) && ($arr2 = $this->returnColorArray($color6))) {
			$this->bool_gradient = true;
			$this->multi_gradient_colors_1[] = $arr1;
			$this->multi_gradient_colors_2[] = $arr2;
		}
		if (!empty($color7) && !empty($color8) && ($arr1 = $this->returnColorArray($color7)) && ($arr2 = $this->returnColorArray($color8))) {
			$this->bool_gradient = true;
			$this->multi_gradient_colors_1[] = $arr1;
			$this->multi_gradient_colors_2[] = $arr2;
		}
		if (!empty($color9) && !empty($color10) && ($arr1 = $this->returnColorArray($color9)) && ($arr2 = $this->returnColorArray($color10))) {
			$this->bool_gradient = true;
			$this->multi_gradient_colors_1[] = $arr1;
			$this->multi_gradient_colors_2[] = $arr2;
		}
	}

	//Legend Related Functions
	public function setLegend($bool)
	{
		if (is_bool($bool)) { 
			$this->bool_legend = $bool;
		} else { 
			$this->error[] = "Boolean arg for setLegend() not specified properly.";
		}
	}

	public function setLegendColor($color) 
	{
		$this->setGenericColor($color, '$this->legend_color', "Legend color not specified properly.");
	}

	public function setLegendTextColor($color) 
	{
		$this->setGenericColor($color, '$this->legend_text_color', "Legend text color not specified properly.");
	}

	public function setLegendOutlineColor($color) 
	{
		$this->setGenericColor($color, '$this->legend_outline_color', "Legend outline color not specified properly.");
	}

	public function setSwatchOutlineColor($color)
	{
		$this->setGenericColor($color, '$this->legend_swatch_outline_color', "Swatch outline color not specified properly.");
	}

	public function setLegendTitle($title1, $title2 = '', $title3 = '', $title4 = '', $title5 = '')
	{
		$title_array = array($title1, $title2, $title3, $title4, $title5);
		foreach ($title_array as $title) {
			if ($len = strlen($title)) {
				if ($len > self::LEGEND_MAX_CHARS) { 
					$title = substr($title, 0, self::LEGEND_MAX_CHARS);
					$this->legend_total_chars[] = self::LEGEND_MAX_CHARS;
				} else {
					$this->legend_total_chars[] = $len;

				}
				$this->legend_titles[] = $title;
			}
		}
	}

	protected function generateLegend()
	{
		$swatchToTextOffset = (self::LEGEND_TEXT_HEIGHT - 6) / 2;
		$swatchSize = self::LEGEND_TEXT_HEIGHT - (2 * $swatchToTextOffset);
		//calc height / width based on # of data sets
		$this->legend_height = self::LEGEND_TEXT_HEIGHT + (2 * self::LEGEND_PADDING);
		$totalChars = 0;
		for ($i = 0; $i < $this->data_set_count; $i++) {
			//could have more titles than data sets - check for this
			if (isset($this->legend_total_chars[$i])){ $totalChars += $this->legend_total_chars[$i]; }
		}
		$this->legend_width = $totalChars * self::LEGEND_TEXT_WIDTH + (self::LEGEND_PADDING * 2.2) + 
			($this->data_set_count * ($swatchSize + (self::LEGEND_PADDING * 2)));
		$this->legend_x = $this->x_axis_x2 - $this->legend_width;
		$highestElement = ($this->top_margin < $this->y_axis_y2) ? $this->top_margin : $this->y_axis_y2;
		$this->legend_y = ($highestElement / 2) - ($this->legend_height / 2); //centered

		//draw background
		imagefilledrectangle($this->image, $this->legend_x, $this->legend_y, $this->legend_x + $this->legend_width,
			$this->legend_y + $this->legend_height, $this->legend_color);

		//draw border
		imagerectangle($this->image, $this->legend_x, $this->legend_y, $this->legend_x + $this->legend_width,
			$this->legend_y + $this->legend_height, $this->legend_outline_color);

		$length_covered = 0;
		for ($i = 0; $i < $this->data_set_count; $i++) {
			$data_label = '';
			if (isset($this->legend_titles[$i])) {
				$data_label = $this->legend_titles[$i];
			}
			$yValue = $this->legend_y + self::LEGEND_PADDING;
			$xValue = $this->legend_x + self::LEGEND_PADDING + ($length_covered * self::LEGEND_TEXT_WIDTH) + ($i * 4 * self::LEGEND_PADDING);
			$length_covered += strlen($data_label);
			//draw color boxes
			if ($this->bool_bars) {
				if ($this->bool_gradient) {
					$color = $this->gradient_color_array[$this->data_set_count - $i - 1][0];
				} else {
					$color = $this->multi_bar_colors[$this->data_set_count - $i - 1];
				}
			} elseif ($this->bool_line && !$this->bool_bars) {
				$color = $this->line_color[$this->data_set_count - $i - 1];
			}
			imagefilledrectangle($this->image, $xValue, $yValue + $swatchToTextOffset, $xValue + $swatchSize, $yValue + $swatchToTextOffset + $swatchSize, $color);
			imagerectangle($this->image, $xValue, $yValue + $swatchToTextOffset, $xValue + $swatchSize, $yValue + $swatchToTextOffset + $swatchSize, $this->legend_swatch_outline_color);	
			imagestring($this->image, 2, $xValue + (2 * self::LEGEND_PADDING + 2), $yValue, $data_label, $this->legend_text_color);
		}
	}

	public function setIgnoreDataFitErrors($bool) 
	{
		if (is_bool($bool)) {
			$this->bool_ignore_data_fit_errors = $bool;
		} else { 
			$this->error[] = "Boolean arg for setIgnoreDataFitErrors() not specified properly.";
		}	
	}
}