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";

abstract class awShape {

	/**

	 * Is the shape hidden ?

	 *

	 * @var bool

	 */

	protected $hide = FALSE;

	/**

	 * Shape style

	 *

	 * @var int

	 */

	public $style;

	/**

	 * Shape thickness

	 *

	 * @var int

	 */

	public $thickness;

	/**

	 * Solid shape

	 *

	 * @var int

	 */

	const SOLID = 1;

	/**

	 * Dotted shape

	 *

	 * @var int

	 */

	const DOTTED = 2;

	/**

	 * Dashed shape

	 *

	 * @var int

	 */

	const DASHED = 3;

	/**

	 * Change shape style

	 *

	 * @param int $style Line style

	 */

	public function setStyle($style) {

		$this->style = (int)$style;

	}

	/**

	 * Return shape style

	 *

	 * @return int

	 */

	public function getStyle() {

		return $this->style;

	}

	/**

	 * Change shape thickness

	 *

	 * @param int $thickness Shape thickness in pixels

	 */

	public function setThickness($thickness) {

		$this->thickness = (int)$thickness;

	}

	/**

	 * Return shape thickness

	 *

	 * @return int

	 */

	public function getThickness() {

		return $this->thickness;

	}

	/**

	 * Hide the shape

	 *

	 * @param bool $hide

	 */

	public function hide($hide) {

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

	}

	/**

	 * Show the shape

	 *

	 * @param bool $shape

	 */

	public function show($shape) {

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

	}

	/**

	 * Is the line hidden ?

	 *

	 * @return bool

	 */

	public function isHidden() {

		return $this->hide;

	}

}

registerClass('Shape', TRUE);

/**

 * Describe a point

 *

 * @package Artichow

 */

class awPoint extends awShape {

	/**

	 * X coord

	 *

	 * @var float

	 */

	public $x;

	/**

	 * Y coord

	 *

	 * @var float

	 */

	public $y;

	/**

	 * Build a new awpoint

	 *

	 * @param float $x

	 * @param float $y

	 */

	public function __construct($x, $y) {

		$this->setLocation($x, $y);

	}

	/**

	 * Change X value

	 *

	 * @param float $x

	 */

	public function setX($x) {

		$this->x = (float)$x;

	}

	/**

	 * Change Y value

	 *

	 * @param float $y

	 */

	public function setY($y) {

		$this->y = (float)$y;

	}

	/**

	 * Change point location

	 *

	 * @param float $x

	 * @param float $y

	 */

	public function setLocation($x, $y) {

		$this->setX($x);

		$this->setY($y);

	}

	/**

	 * Get point location

	 *

	 * @param array Point location

	 */

	public function getLocation() {

		return array($this->x, $this->y);

	}

	/**

	 * Get distance to another point

	 *

	 * @param awPoint $p A point

	 * @return float

	 */

	public function getDistance(awPoint $p) {

		return sqrt(pow($p->x - $this->x, 2) + pow($p->y - $this->y, 2));

	}

	/**

	 * Move the point to another location

	 *

	 * @param Point A Point with the new awlocation

	 */

	public function move($x, $y) {

		return new awPoint(

			$this->x + $x,

			$this->y + $y

		);

	}

}

registerClass('Point');

/**

 * Describe a line

 *

 * @package Artichow

 */

class awLine extends awShape {

	/**

	 * Line first point

	 *

	 * @param Point

	 */

	public $p1;

	/**

	 * Line second point

	 *

	 * @param Point

	 */

	public $p2;

	/**

	 * The line slope (the m in y = mx + p)

	 *

	 * @param float

	 */

	private $slope;

	/**

	 * The y-intercept value of the line (the p in y = mx + p)

	 *

	 * @param float

	 */

	private $origin;

	/**

	 * Build a new awline

	 *

	 * @param awPoint $p1 First point

	 * @param awPoint $p2 Second point

	 * @param int $type Style of line (default to solid)

	 * @param int $thickness Line thickness (default to 1)

	 */

	public function __construct($p1 = NULL, $p2 = NULL, $type = awLine::SOLID, $thickness = 1) {

		$this->setLocation($p1, $p2);

		$this->setStyle($type);

		$this->setThickness($thickness);

	}

	/**

	 * Build a line from 4 coords

	 *

	 * @param int $x1 Left position

	 * @param int $y1 Top position

	 * @param int $x2 Right position

	 * @param int $y2 Bottom position

	 */

	public static function build($x1, $y1, $x2, $y2) {

		return new awLine(

			new awPoint($x1, $y1),

			new awPoint($x2, $y2)

		);

	}

	/**

	 * Change X values of the line

	 *

	 * @param int $x1 Begin value

	 * @param int $x2 End value

	 */

	public function setX($x1, $x2) {

		$this->p1->setX($x1);

		$this->p2->setX($x2);

		// Resets slope and origin values so they are

		// recalculated when and if needed.

		$this->slope = NULL;

		$this->origin = NULL;

	}

	/**

	 * Change Y values of the line

	 *

	 * @param int $y1 Begin value

	 * @param int $y2 End value

	 */

	public function setY($y1, $y2) {

		$this->p1->setY($y1);

		$this->p2->setY($y2);

		// Resets slope and origin values so they are

		// recalculated when and if needed.

		$this->slope = NULL;

		$this->origin = NULL;

	}

	/**

	 * Change line location

	 *

	 * @param awPoint $p1 First point

	 * @param awPoint $p2 Second point

	 */

	public function setLocation($p1, $p2) {

		if(is_null($p1) or $p1 instanceof awPoint) {

			$this->p1 = $p1;

		}

		if(is_null($p2) or $p2 instanceof awPoint) {

			$this->p2 = $p2;

		}

		// Resets slope and origin values so they are

		// recalculated when and if needed.

		$this->slope = NULL;

		$this->origin = NULL;

	}

	/**

	 * Get line location

	 *

	 * @param array Line location

	 */

	public function getLocation() {

		return array($this->p1, $this->p2);

	}

	/**

	 * Get the line size

	 *

	 * @return float

	 */

	public function getSize() {

		$square = pow($this->p2->x - $this->p1->x, 2) + pow($this->p2->y - $this->p1->y, 2);

		return sqrt($square);

	}

	/**

	 * Calculate the line slope

	 *

	 */

	private function calculateSlope() {

		if($this->isHorizontal()) {

			$this->slope = 0;

		} else {

			$slope = ($this->p1->y - $this->p2->y) / ($this->p1->x - $this->p2->x);

			$this->slope = $slope;

		}

	}

	/**

	 * Calculate the y-intercept value of the line

	 *

	 */

	private function calculateOrigin() {

		if($this->isHorizontal()) {

			$this->origin = $this->p1->y; // Or p2->y

		} else {

			$y1 = $this->p1->y;

			$y2 = $this->p2->y;

			$x1 = $this->p1->x;

			$x2 = $this->p2->x;

			$origin = ($y2 * $x1 - $y1 * $x2) / ($x1 - $x2);

			$this->origin = $origin;

		}

	}

	/**

	 * Calculate the slope and y-intercept value of the line

	 *

	 */

	private function calculateEquation() {

		$this->calculateSlope();

		$this->calculateOrigin();

	}

	/**

	 * Get the line slope value

	 *

	 * @return float

	 */

	public function getSlope() {

		if($this->isVertical()) {

			return NULL;

		} elseif($this->slope !== NULL) {

			return $this->slope;

		} else {

			$this->calculateSlope();

			return $this->slope;

		}

	}

	/**

	 * Get the line y-intercept value

	 *

	 * @return float

	 */

	public function getOrigin() {

		if($this->isVertical()) {

			return NULL;

		} elseif($this->origin !== NULL) {

			return $this->origin;

		} else {

			$this->calculateOrigin();

			return $this->origin;

		}

	}

	/**

	 * Get the line equation

	 *

	 * @return array An array containing the slope and y-intercept value of the line

	 */

	public function getEquation() {

		$slope	= $this->getSlope();

		$origin = $this->getOrigin();

		return array($slope, $origin);

	}

	/**

	 * Return the x coordinate of a point on the line

	 * given its y coordinate.

	 *

	 * @param float $y The y coordinate of the Point

	 * @return float $x The corresponding x coordinate

	 */

	public function getXFrom($y) {

		$x = NULL;

		if($this->isVertical()) {

			list($p, ) = $this->getLocation();

			$x = $p->x;

		} else {

			list($slope, $origin) = $this->getEquation();

			if($slope !== 0) {

				$y = (float)$y;

				$x = ($y - $origin) / $slope;

			}

		}

		return $x;

	}

	/**

	 * Return the y coordinate of a point on the line

	 * given its x coordinate.

	 *

	 * @param float $x The x coordinate of the Point

	 * @return float $y The corresponding y coordinate

	 */

	public function getYFrom($x) {

		$y = NULL;

		if($this->isHorizontal()) {

			list($p, ) = $this->getLocation();

			$y = $p->y;

		} else {

			list($slope, $origin) = $this->getEquation();

			if($slope !== NULL) {

				$x = (float)$x;

				$y = $slope * $x + $origin;

			}

		}

		return $y;

	}

	/**

	 * Test if the line can be considered as a point

	 *

	 * @return bool

	 */

	public function isPoint() {

		return ($this->p1->x === $this->p2->x and $this->p1->y === $this->p2->y);

	}

	/**

	 * Test if the line is a vertical line

	 *

	 * @return bool

	 */

	public function isVertical() {

		return ($this->p1->x === $this->p2->x);

	}

	/**

	 * Test if the line is an horizontal line

	 *

	 * @return bool

	 */

	public function isHorizontal() {

		return ($this->p1->y === $this->p2->y);

	}

	/**

	 * Returns TRUE if the line is going all the way from the top

	 * to the bottom of the polygon surrounding box.

	 *

	 * @param $polygon Polygon A Polygon object

	 * @return bool

	 */

	public function isTopToBottom(awPolygon $polygon) {

		list($xMin, $xMax) = $polygon->getBoxXRange();

		list($yMin, $yMax) = $polygon->getBoxYRange();

		if($this->isHorizontal()) {

			return FALSE;

		} else {

			if($this->p1->y < $this->p2->y) {

				$top = $this->p1;

				$bottom = $this->p2;

			} else {

				$top = $this->p2;

				$bottom = $this->p1;

			}

			return (

				$this->isOnBoxTopSide($top, $xMin, $xMax, $yMin)

				and

				$this->isOnBoxBottomSide($bottom, $xMin, $xMax, $yMax)

			);

		}

	}

	/**

	 * Returns TRUE if the line is going all the way from the left side

	 * to the right side of the polygon surrounding box.

	 *

	 * @param $polygon Polygon A Polygon object

	 * @return bool

	 */

	public function isLeftToRight(awPolygon $polygon) {

		list($xMin, $xMax) = $polygon->getBoxXRange();

		list($yMin, $yMax) = $polygon->getBoxYRange();

		if($this->isVertical()) {

			return FALSE;

		} else {

			if($this->p1->x < $this->p2->x) {

				$left = $this->p1;

				$right = $this->p2;

			} else {

				$left = $this->p2;

				$right = $this->p1;

			}

		}

		return (

			$this->isOnBoxLeftSide($left, $yMin, $yMax, $xMin)

			and

			$this->isOnBoxRightSide($right, $yMin, $yMax, $xMax)

		);

	}

	private function isOnBoxTopSide(awPoint $point, $xMin, $xMax, $yMin) {

		if(

			$point->y === $yMin

			and

			$point->x >= $xMin

			and

			$point->x <= $xMax

		) {

			return TRUE;

		} else {

			return FALSE;

		}

	}

	private function isOnBoxBottomSide(awPoint $point, $xMin, $xMax, $yMax) {

		if(

			$point->y === $yMax

			and

			$point->x >= $xMin

			and

			$point->x <= $xMax

		) {

			return TRUE;

		} else {

			return FALSE;

		}

	}

	private function isOnBoxLeftSide(awPoint $point, $yMin, $yMax, $xMin) {

		if(

			$point->x === $xMin

			and

			$point->y >= $yMin

			and

			$point->y <= $yMax

		) {

			return TRUE;

		} else {

			return FALSE;

		}

	}

	private function isOnBoxRightSide(awPoint $point, $yMin, $yMax, $xMax) {

		if(

			$point->x === $xMax

			and

			$point->y >= $yMin

			and

			$point->y <= $yMax

		) {

			return TRUE;

		} else {

			return FALSE;

		}

	}

}

registerClass('Line');

/**

 * A vector is a type of line

 * The sense of the vector goes from $p1 to $p2.

 *

 * @package Artichow

 */

class awVector extends awLine {

	/**

	 * Get vector angle in radians

	 *

	 * @return float

	 */

	public function getAngle() {

		if($this->isPoint()) {

			return 0.0;

		}

		$size = $this->getSize();

		$width = ($this->p2->x - $this->p1->x);

		$height = ($this->p2->y - $this->p1->y) * -1;

		if($width >= 0 and $height >= 0) {

			return acos($width / $size);

		} else if($width <= 0 and $height >= 0) {

			return acos($width / $size);

		} else {

			$height *= -1;

			if($width >= 0 and $height >= 0) {

				return 2 * M_PI - acos($width / $size);

			} else if($width <= 0 and $height >= 0) {

				return 2 * M_PI - acos($width / $size);

			}

		}

	}

}

registerClass('Vector');

/**

 * Describe a polygon

 *

 * @package Artichow

 */

class awPolygon extends awShape {

	/**

	 * Polygon points

	 *

	 * @var array

	 */

	protected $points = array();

	/**

	 * Set a point in the polygon

	 *

	 * @param int $pos Point position

	 * @param awPoint $point

	 */

	public function set($pos, $point) {

		if(is_null($point) or $point instanceof awPoint) {

			$this->points[$pos] = $point;

		}

	}

	/**

	 * Add a point at the end of the polygon

	 *

	 * @param awPoint $point

	 */

	public function append($point) {

		if(is_null($point) or $point instanceof awPoint) {

			$this->points[] = $point;

		}

	}

	/**

	 * Get a point at a position in the polygon

	 *

	 * @param int $pos Point position

	 * @return Point

	 */

	public function get($pos) {

		return $this->points[$pos];

	}

	/**

	 * Count number of points in the polygon

	 *

	 * @return int

	 */

	public function count() {

		return count($this->points);

	}

	/**

	 * Returns all points in the polygon

	 *

	 * @return array

	 */

	public function all() {

		return $this->points;

	}

	/**

	 * Returns the different lines formed by the polygon vertices

	 *

	 * @return array

	 */

	public function getLines() {

		$lines = array();

		$count = $this->count();

		for($i = 0; $i < $count - 1; $i++) {

			$lines[] = new Line($this->get($i), $this->get($i + 1));

		}

		// "Close" the polygon

		$lines[] = new Line($this->get($count - 1), $this->get(0));

		return $lines;

	}

	/**

	 * Get the upper-left and lower-right points

	 * of the bounding box around the polygon

	 *

	 * @return array An array of two Point objects

	 */

	public function getBoxPoints() {

		$count = $this->count();

		$x = $y = array();

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

			$point = $this->get($i);

			list($x[], $y[]) = $point->getLocation();

		}

		$upperLeft  = new Point(min($x), min($y));

		$lowerRight = new Point(max($x), max($y));

		return array($upperLeft, $lowerRight);

	}

	/**

	 * Return the range of the polygon on the y axis,

	 * i.e. the minimum and maximum y value of any point in the polygon

	 *

	 * @return array

	 */

	public function getBoxYRange() {

		list($p1, $p2) = $this->getBoxPoints();

		list(, $yMin) = $p1->getLocation();

		list(, $yMax) = $p2->getLocation();

		return array($yMin, $yMax);

	}

	/**

	 * Return the range of the polygon on the x axis,

	 * i.e. the minimum and maximum x value of any point in the polygon

	 *

	 * @return array

	 */

	public function getBoxXRange() {

		list($p1, $p2) = $this->getBoxPoints();

		list($xMin, ) = $p1->getLocation();

		list($xMax, ) = $p2->getLocation();

		return array($xMin, $xMax);

	}

}

registerClass('Polygon');

?>