Subversion Repositories Applications.gtt

<?php

/*

 * This work is hereby released into the Public Domain.

 * To view a copy of the public domain dedication,

 * visit http://creativecommons.org/licenses/publicdomain/ or send a letter to

 * Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

 *

 */

require_once dirname(__FILE__)."/../Graph.class.php";

/**

 * Handle axis

 *

 * @package Artichow

 */

class awAxis {

	/**

	 * Axis line

	 *

	 * @var Line

	 */

	public $line;

	/**

	 * Axis labels

	 *

	 * @var Label

	 */

	public $label;

	/**

	 * Axis title

	 *

	 * @var Label

	 */

	public $title;

	/**

	 * Title position

	 *

	 * @var float

	 */

	protected $titlePosition = 0.5;

	/**

	 * Labels number

	 *

	 * @var int

	 */

	protected $labelNumber;

	/**

	 * Axis ticks

	 *

	 * @var array

	 */

	protected $ticks = array();

	/**

	 * Axis and ticks color

	 *

	 * @var Color

	 */

	protected $color;

	/**

	 * Axis left and right padding

	 *

	 * @var Side

	 */

	protected $padding;

	/**

	 * Axis range

	 *

	 * @var array

	 */

	protected $range;

	/**

	 * Hide axis

	 *

	 * @var bool

	 */

	protected $hide = FALSE;

	/**

	 * Auto-scaling mode

	 *

	 * @var bool

	 */

	protected $auto = TRUE;

	/**

	 * Axis range callback function

	 *

	 * @var array

	 */

	protected $rangeCallback = array(

		'toValue' => 'toProportionalValue',

		'toPosition' => 'toProportionalPosition'

	);

	/**

	 * Build the axis

	 *

	 * @param float $min Begin of the range of the axis

	 * @param float $max End of the range of the axis

	 */

	public function __construct($min = NULL, $max = NULL) {

		$this->line = new awVector(

			new awPoint(0, 0),

			new awPoint(0, 0)

		);

		$this->label = new awLabel;

		$this->padding = new awSide;

		$this->title = new awLabel(

			NULL,

			NULL,

			NULL,

		);

		$this->setColor(new awBlack);

		if($min !== NULL and $max !== NULL) {

			$this->setRange($min, $max);

		}

	}

	/**

	 * Enable/disable auto-scaling mode

	 *

	 * @param bool $auto

	 */

	public function auto($auto) {

		$this->auto = (bool)$auto;

	}

	/**

	 * Get auto-scaling mode status

	 *

	 * @return bool

	 */

	public function isAuto() {

		return $this->auto;

	}

	/**

	 * Hide axis

	 *

	 * @param bool $hide

	 */

	public function hide($hide = TRUE) {

		$this->hide = (bool)$hide;

	}

	/**

	 * Show axis

	 *

	 * @param bool $show

	 */

	public function show($show = TRUE) {

		$this->hide = !(bool)$show;

	}

	/**

	 * Return a tick object from its name

	 *

	 * @param string $name Tick object name

	 * @return Tick

	 */

	public function tick($name) {

		return array_key_exists($name, $this->ticks) ? $this->ticks[$name] : NULL;

			}

	/**

	 * Add a tick object

	 *

	 * @param string $name Tick object name

	 * @param awTick $tick Tick object

	 */

	public function addTick($name, awTick $tick) {

		$this->ticks[$name] = $tick;

			}

	/**

	 * Delete a tick object

	 *

	 * @param string $name Tick object name

	 */

	public function deleteTick($name) {

		if(array_key_exists($name, $this->ticks)) {

			unset($this->ticks[$name]);

		}

	}

	/**

	 * Hide all ticks

	 *

	 * @param bool $hide Hide or not ?

	 */

	public function hideTicks($hide = TRUE) {

		foreach($this->ticks as $tick) {

			$tick->hide($hide);

		}

			}

	/**

	 * Change ticks style

	 *

	 * @param int $style Ticks style

	 */

	public function setTickStyle($style) {

		foreach($this->ticks as $tick) {

			$tick->setStyle($style);

		}

			}

	/**

	 * Change ticks interval

	 *

	 * @param int $interval Ticks interval

	 */

	public function setTickInterval($interval) {

		foreach($this->ticks as $tick) {

			$tick->setInterval($interval);

		}

			}

	/**

	 * Change number of ticks relative to others ticks

	 *

	 * @param awTick $to Change number of theses ticks

	 * @param awTick $from Ticks reference

	 * @param float $number Number of ticks by the reference

	 */

	public function setNumberByTick($to, $from, $number) {

		$this->ticks[$to]->setNumberByTick($this->ticks[$from], $number);

	}

	/**

	 * Reverse ticks style

	 */

	public function reverseTickStyle() {

		foreach($this->ticks as $tick) {

			if($tick->getStyle() === awTick::IN) {

				$tick->setStyle(awTick::OUT);

			} else if($tick->getStyle() === awTick::OUT) {

				$tick->setStyle(awTick::IN);

			}

		}

			}

	/**

	 * Change interval of labels

	 *

	 * @param int $interval Interval

	 */

	public function setLabelInterval($interval) {

		$this->auto(FALSE);

		$this->setTickInterval($interval);

		$this->label->setInterval($interval);

	}

	/**

	 * Change number of labels

	 *

	 * @param int $number Number of labels to display (can be NULL)

	 */

	public function setLabelNumber($number) {

		$this->auto(FALSE);

		$this->labelNumber = is_null($number) ? NULL : (int)$number;

	}

	/**

	 * Get number of labels

	 *

	 * @return int

	 */

	public function getLabelNumber() {

		return $this->labelNumber;

	}

	/**

	 * Change precision of labels

	 *

	 * @param int $precision Precision

	 */

	public function setLabelPrecision($precision) {

		$this->auto(FALSE);

		$function = 'axis'.time().'_'.(microtime() * 1000000);

		eval('function '.$function.'($value) {

			return sprintf("%.'.(int)$precision.'f", $value);

		}');

		$this->label->setCallbackFunction($function);

	}

	/**

	 * Change text of labels

	 *

	 * @param array $texts Some texts

	 */

	public function setLabelText($texts) {

		if(is_array($texts)) {

			$this->auto(FALSE);

			$function = 'axis'.time().'_'.(microtime() * 1000000);

			eval('function '.$function.'($value) {

				$texts = '.var_export($texts, TRUE).';

				return isset($texts[$value]) ? $texts[$value] : \'?\';

			}');

			$this->label->setCallbackFunction($function);

		}

	}

	/**

	 * Get the position of a point

	 *

	 * @param awAxis $xAxis X axis

	 * @param awAxis $yAxis Y axis

	 * @param awPoint $p Position of the point

	 * @return Point Position on the axis

	 */

	public static function toPosition(awAxis $xAxis, awAxis $yAxis, awPoint $p) {

		$p1 = $xAxis->getPointFromValue($p->x);

		$p2 = $yAxis->getPointFromValue($p->y);

		return new awPoint(

			round($p1->x),

			round($p2->y)

		);

	}

	/**

	 * Change title alignment

	 *

	 * @param int $alignment New Alignment

	 */

	public function setTitleAlignment($alignment) {

		switch($alignment) {

			case awLabel::TOP :

				$this->setTitlePosition(1);

				$this->title->setAlign(NULL, awLabel::BOTTOM);

				break;

			case awLabel::BOTTOM :

				$this->setTitlePosition(0);

				$this->title->setAlign(NULL, awLabel::TOP);

				break;

			case awLabel::LEFT :

				$this->setTitlePosition(0);

				$this->title->setAlign(awLabel::LEFT);

				break;

			case awLabel::RIGHT :

				$this->setTitlePosition(1);

				$this->title->setAlign(awLabel::RIGHT);

				break;

		}

	}

	/**

	 * Change title position on the axis

	 *

	 * @param float $position A new awposition between 0 and 1

	 */

	public function setTitlePosition($position) {

		$this->titlePosition = (float)$position;

	}

	/**

	 * Change axis and axis title color

	 *

	 * @param awColor $color

	 */

	public function setColor(awColor $color) {

		$this->color = $color;

		$this->title->setColor($color);

	}

	/**

	 * Change axis padding

	 *

	 * @param int $left Left padding in pixels

	 * @param int $right Right padding in pixels

	 */

	public function setPadding($left, $right) {

		$this->padding->set($left, $right);

	}

	/**

	 * Get axis padding

	 *

	 * @return Side

	 */

	public function getPadding() {

		return $this->padding;

	}

	/**

	 * Change axis range

	 *

	 * @param float $min

	 * @param float $max

	 */

	public function setRange($min, $max) {

		if($min !== NULL) {

			$this->range[0] = (float)$min;

		}

		if($max !== NULL) {

			$this->range[1] = (float)$max;

		}

	}

	/**

	 * Get axis range

	 *

	 * @return array

	 */

	public function getRange() {

		return $this->range;

	}

	/**

	 * Change axis range callback function

	 *

	 * @param string $toValue Transform a position between 0 and 1 to a value

	 * @param string $toPosition Transform a value to a position between 0 and 1 on the axis

	 */

	public function setRangeCallback($toValue, $toPosition) {

		$this->rangeCallback = array(

			'toValue' => (string)$toValue,

			'toPosition' => (string)$toPosition

		);

	}

	/**

	 * Center X values of the axis

	 *

	 * @param awAxis $axis An axis

	 * @param float $value The reference value on the axis

	 */

	public function setXCenter(awAxis $axis, $value) {

		// Check vector angle

		if($this->line->isVertical() === FALSE) {

			awImage::drawError("Class Axis: setXCenter() can only be used on vertical axes.");

		}

		$p = $axis->getPointFromValue($value);

		$this->line->setX(

			$p->x,

			$p->x

		);

	}

	/**

	 * Center Y values of the axis

	 *

	 * @param awAxis $axis An axis

	 * @param float $value The reference value on the axis

	 */

	public function setYCenter(awAxis $axis, $value) {

		// Check vector angle

		if($this->line->isHorizontal() === FALSE) {

			awImage::drawError("Class Axis: setYCenter() can only be used on horizontal axes.");

		}

		$p = $axis->getPointFromValue($value);

		$this->line->setY(

			$p->y,

			$p->y

		);

	}

	/**

	 * Get the distance between to values on the axis

	 *

	 * @param float $from The first value

	 * @param float $to The last value

	 * @return Point

	 */

	public function getDistance($from, $to) {

		$p1 = $this->getPointFromValue($from);

		$p2 = $this->getPointFromValue($to);

		return $p1->getDistance($p2);

	}

	/**

	 * Get a point on the axis from a value

	 *

	 * @param float $value

	 * @return Point

	 */

	protected function getPointFromValue($value) {

		$callback = $this->rangeCallback['toPosition'];

		list($min, $max) = $this->range;

		$position = $callback($value, $min, $max);

		return $this->getPointFromPosition($position);

	}

	/**

	 * Get a point on the axis from a position

	 *

	 * @param float $position A position between 0 and 1

	 * @return Point

	 */

	protected function getPointFromPosition($position) {

		$vector = $this->getVector();

		$angle = $vector->getAngle();

		$size = $vector->getSize();

		return $vector->p1->move(

			cos($angle) * $size * $position,

			-1 * sin($angle) * $size * $position

		);

	}

	/**

	 * Draw axis

	 *

	 * @param awDriver $driver A driver

	 */

	public function draw(awDriver $driver) {

		if($this->hide) {

			return;

		}

		$vector = $this->getVector();

		// Draw axis ticks

		$this->drawTicks($driver, $vector);

		// Draw axis line

		$this->line($driver);

		// Draw labels

		$this->drawLabels($driver);

		// Draw axis title

		$p = $this->getPointFromPosition($this->titlePosition);

		$this->title->draw($driver, $p);

	}

	public function autoScale() {

		if($this->isAuto() === FALSE) {

			return;

		}

		list($min, $max) = $this->getRange();

		$interval = $max - $min;

		if($interval > 0) {

			$partMax = $max / $interval;

			$partMin = $min / $interval;

		} else {

			$partMax = 0;

			$partMin = 0;

		}

		$difference = log($interval) / log(10);

		$difference = floor($difference);

		$pow = pow(10, $difference);

		if($pow > 0) {

			$intervalNormalize = $interval / $pow;

		} else {

			$intervalNormalize = 0;

		}

		if($difference <= 0) {

			$precision = $difference * -1 + 1;

			if($intervalNormalize > 2) {

				$precision--;

			}

		} else {

			$precision = 0;

		}

		if($min != 0 and $max != 0) {

			$precision++;

		}

		if($this->label->getCallbackFunction() === NULL) {

			$this->setLabelPrecision($precision);

		}

		if($intervalNormalize <= 1.5) {

			$intervalReal = 1.5;

			$labelNumber = 4;

		} else if($intervalNormalize <= 2) {

			$intervalReal = 2;

			$labelNumber = 5;

		} else if($intervalNormalize <= 3) {

			$intervalReal = 3;

			$labelNumber = 4;

		} else if($intervalNormalize <= 4) {

			$intervalReal = 4;

			$labelNumber = 5;

		} else if($intervalNormalize <= 5) {

			$intervalReal = 5;

			$labelNumber = 6;

		} else if($intervalNormalize <= 8) {

			$intervalReal = 8;

			$labelNumber = 5;

		} else if($intervalNormalize <= 10) {

			$intervalReal = 10;

			$labelNumber = 6;

		}

		if($min == 0) {

			$this->setRange(

				$min,

				$intervalReal * $pow

			);

		} else if($max == 0) {

			$this->setRange(

				$intervalReal * $pow * -1,

			);

		}

		$this->setLabelNumber($labelNumber);

	}

	protected function line(awDriver $driver) {

		$driver->line(

			$this->color,

			$this->line

		);

	}

	protected function drawTicks(awDriver $driver, awVector $vector) {

		foreach($this->ticks as $tick) {

			$tick->setColor($this->color);

			$tick->draw($driver, $vector);

		}

	}

	protected function drawLabels($driver) {

		if($this->labelNumber !== NULL) {

			list($min, $max) = $this->range;

			$number = $this->labelNumber - 1;

			if($number < 1) {

				return;

			}

			$function = $this->rangeCallback['toValue'];

			$labels = array();

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

				$labels[] = $function($i / $number, $min, $max);

			}

			$this->label->set($labels);

		}

		$labels = $this->label->count();

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

			$p = $this->getPointFromValue($this->label->get($i));

			$this->label->draw($driver, $p, $i);

		}

	}

	protected function getVector() {

		$angle = $this->line->getAngle();

		// Compute paddings

		$vector = new awVector(

			$this->line->p1->move(

				cos($angle) * $this->padding->left,

				-1 * sin($angle) * $this->padding->left

			),

			$this->line->p2->move(

				-1 * cos($angle) * $this->padding->right,

				-1 * -1 * sin($angle) * $this->padding->right

			)

		);

		return $vector;

	}

	public function __clone() {

		$this->label = clone $this->label;

		$this->line = clone $this->line;

		$this->title = clone $this->title;

		foreach($this->ticks as $name => $tick) {

			$this->ticks[$name] = clone $tick;

		}

	}

}

registerClass('Axis');

function toProportionalValue($position, $min, $max) {

	return $min + ($max - $min) * $position;

}

function toProportionalPosition($value, $min, $max) {

	if($max - $min == 0) {

		return 0;

	}

	return ($value - $min) / ($max - $min);

}

?>