Subversion Repositories Applications.gtt

Rev

Rev 61 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
60 jpm 1 
<?php
2 
/*
3 
 * This work is hereby released into the Public Domain.
4 
 * To view a copy of the public domain dedication,
5 
 * visit http://creativecommons.org/licenses/publicdomain/ or send a letter to
6 
 * Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.
7 
 *
8 
 */
9 
 
10 
require_once dirname(__FILE__)."/Component.class.php";
11 
 
12 
 
13 
/**
14 
 * Graph using X and Y axis
15 
 *
16 
 * @package Artichow
17 
 */
18 
abstract class awPlot extends awComponent {
19 
 
20 
	/**
21 
	 * Values for Y axis
22 
	 *
23 
	 * @var array
24 
	 */
25 
	protected $datay;
26 
 
27 
	/**
28 
	 * Values for X axis
29 
	 *
30 
	 * @var array
31 
	 */
32 
	protected $datax;
33 
 
34 
	/**
35 
	 * Grid properties
36 
	 *
37 
	 * @var Grid
38 
	 */
39 
	public $grid;
40 
 
41 
	/**
42 
	 * X axis
43 
	 *
44 
	 * @var Axis
45 
	 */
46 
	public $xAxis;
47 
 
48 
	/**
49 
	 * Y axis
50 
	 *
51 
	 * @var Axis
52 
	 */
53 
	public $yAxis;
54 
 
55 
	/**
56 
	 * Position of X axis
57 
	 *
58 
	 * @var int
59 
	 */
60 
	protected $xAxisPosition = awPlot::BOTTOM;
61 
 
62 
	/**
63 
	 * Set X axis on zero ?
64 
	 *
65 
	 * @var bool
66 
	 */
67 
	protected $xAxisZero = TRUE;
68 
 
69 
	/**
70 
	 * Set Y axis on zero ?
71 
	 *
72 
	 * @var bool
73 
	 */
74 
	protected $yAxisZero = FALSE;
75 
 
76 
	/**
77 
	 * Position of Y axis
78 
	 *
79 
	 * @var int
80 
	 */
81 
	protected $yAxisPosition = awPlot::LEFT;
82 
 
83 
	/**
84 
	 * Change min value for Y axis
85 
	 *
86 
	 * @var mixed
87 
	 */
88 
	private $yMin = NULL;
89 
 
90 
	/**
91 
	 * Change max value for Y axis
92 
	 *
93 
	 * @var mixed
94 
	 */
95 
	private $yMax = NULL;
96 
 
97 
	/**
98 
	 * Change min value for X axis
99 
	 *
100 
	 * @var mixed
101 
	 */
102 
	private $xMin = NULL;
103 
 
104 
	/**
105 
	 * Change max value for X axis
106 
	 *
107 
	 * @var mixed
108 
	 */
109 
	private $xMax = NULL;
110 
 
111 
	/**
112 
	 * Left axis
113 
	 *
114 
	 * @var int
115 
	 */
116 
	const LEFT = 'left';
117 
 
118 
	/**
119 
	 * Right axis
120 
	 *
121 
	 * @var int
122 
	 */
123 
	const RIGHT = 'right';
124 
 
125 
	/**
126 
	 * Top axis
127 
	 *
128 
	 * @var int
129 
	 */
130 
	const TOP = 'top';
131 
 
132 
	/**
133 
	 * Bottom axis
134 
	 *
135 
	 * @var int
136 
	 */
137 
	const BOTTOM = 'bottom';
138 
 
139 
	/**
140 
	 * Both left/right or top/bottom axis
141 
	 *
142 
	 * @var int
143 
	 */
144 
	const BOTH = 'both';
145 
 
146 
	/**
147 
	 * Build the plot
148 
	 *
149 
	 */
150 
	public function __construct() {
151 
 
152 
		parent::__construct();
153 
 
154 
		$this->grid = new awGrid;
155 
		$this->grid->setBackgroundColor(new awWhite);
156 
 
157 
		$this->padding->add(20, 0, 0, 20);
158 
 
159 
		$this->xAxis = new awAxis;
160 
		$this->xAxis->addTick('major', new awTick(0, 5));
161 
		$this->xAxis->addTick('minor', new awTick(0, 3));
162 
		$this->xAxis->setTickStyle(awTick::OUT);
163 
		$this->xAxis->label->setFont(new awTuffy(7));
164 
 
165 
		$this->yAxis = new awAxis;
166 
		$this->yAxis->auto(TRUE);
167 
		$this->yAxis->addTick('major', new awTick(0, 5));
168 
		$this->yAxis->addTick('minor', new awTick(0, 3));
169 
		$this->yAxis->setTickStyle(awTick::OUT);
170 
		$this->yAxis->setNumberByTick('minor', 'major', 3);
171 
		$this->yAxis->label->setFont(new awTuffy(7));
172 
		$this->yAxis->title->setAngle(90);
173 
 
174 
	}
175 
 
176 
	/**
177 
	 * Get plot values
178 
	 *
179 
	 * @return array
180 
	 */
181 
	public function getValues() {
182 
		return $this->datay;
183 
	}
184 
 
185 
	/**
186 
	 * Reduce number of values in the plot
187 
	 *
188 
	 * @param int $number Reduce number of values to $number
189 
	 */
190 
	public function reduce($number) {
191 
 
192 
		$count = count($this->datay);
193 
		$ratio = ceil($count / $number);
194 
 
195 
		if($ratio > 1) {
196 
 
197 
			$tmpy = $this->datay;
198 
			$datay = array();
199 
 
200 
			$datax = array();
201 
			$cbLabel = $this->xAxis->label->getCallbackFunction();
202 
 
203 
			for($i = 0; $i < $count; $i += $ratio) {
204 
 
205 
				$slice = array_slice($tmpy, $i, $ratio);
206 
				$datay[] = array_sum($slice) / count($slice);
207 
 
208 
				// Reduce data on X axis if needed
209 
				if($cbLabel !== NULL) {
210 
					$datax[] = $cbLabel($i + round($ratio / 2));
211 
				}
212 
 
213 
			}
214 
 
215 
			$this->setValues($datay);
216 
 
217 
			if($cbLabel !== NULL) {
218 
				$this->xAxis->setLabelText($datax);
219 
			}
220 
 
221 
 
222 
		}
223 
 
224 
	}
225 
 
226 
	/**
227 
	 * Count values in the plot
228 
	 *
229 
	 * @return int
230 
	 */
231 
	public function getXAxisNumber() {
232 
		list($min, $max) = $this->xAxis->getRange();
233 
		return ($max - $min + 1);
234 
	}
235 
 
236 
	/**
237 
	 * Change X axis
238 
	 *
239 
	 * @param int $axis
240 
	 */
241 
	public function setXAxis($axis) {
242 
		$this->xAxisPosition = $axis;
243 
	}
244 
 
245 
	/**
246 
	 * Get X axis
247 
	 *
248 
	 * @return int
249 
	 */
250 
	public function getXAxis() {
251 
		return $this->xAxisPosition;
252 
	}
253 
 
254 
	/**
255 
	 * Set X axis on zero
256 
	 *
257 
	 * @param bool $zero
258 
	 */
259 
	public function setXAxisZero($zero) {
260 
		$this->xAxisZero = (bool)$zero;
261 
	}
262 
 
263 
	/**
264 
	 * Set Y axis on zero
265 
	 *
266 
	 * @param bool $zero
267 
	 */
268 
	public function setYAxisZero($zero) {
269 
		$this->yAxisZero = (bool)$zero;
270 
	}
271 
 
272 
	/**
273 
	 * Change Y axis
274 
	 *
275 
	 * @param int $axis
276 
	 */
277 
	public function setYAxis($axis) {
278 
		$this->yAxisPosition = $axis;
279 
	}
280 
 
281 
	/**
282 
	 * Get Y axis
283 
	 *
284 
	 * @return int
285 
	 */
286 
	public function getYAxis() {
287 
		return $this->yAxisPosition;
288 
	}
289 
 
290 
	/**
291 
	 * Change min value for Y axis
292 
	 * Set NULL for auto selection.
293 
	 *
294 
	 * @param float $value
295 
	 */
296 
	public function setYMin($value) {
297 
		$this->yMin = $value;
298 
		$this->yAxis->auto(FALSE);
299 
		$this->updateAxis();
300 
	}
301 
 
302 
	/**
303 
	 * Change max value for Y axis
304 
	 * Set NULL for auto selection.
305 
	 *
306 
	 * @param float $value
307 
	 */
308 
	public function setYMax($value) {
309 
		$this->yMax = $value;
310 
		$this->yAxis->auto(FALSE);
311 
		$this->updateAxis();
312 
	}
313 
 
314 
	/**
315 
	 * Change min value for X axis
316 
	 * Set NULL for auto selection.
317 
	 *
318 
	 * @param float $value
319 
	 */
320 
	public function setXMin($value) {
321 
		$this->xMin = $value;
322 
		$this->updateAxis();
323 
	}
324 
 
325 
	/**
326 
	 * Change max value for X axis
327 
	 * Set NULL for auto selection.
328 
	 *
329 
	 * @param float $value
330 
	 */
331 
	public function setXMax($value) {
332 
		$this->xMax = $value;
333 
		$this->updateAxis();
334 
	}
335 
 
336 
	/**
337 
	 * Get min value for Y axis
338 
	 *
339 
	 * @return float $value
340 
	 */
341 
	public function getYMin() {
342 
		if($this->auto) {
343 
			if(is_null($this->yMin)) {
344 
				$min = array_min($this->datay);
345 
				if($min > 0) {
346 
					return 0;
347 
				}
348 
			}
349 
		}
350 
		return is_null($this->yMin) ? array_min($this->datay) : (float)$this->yMin;
351 
	}
352 
 
353 
	/**
354 
	 * Get max value for Y axis
355 
	 *
356 
	 * @return float $value
357 
	 */
358 
	public function getYMax() {
359 
		if($this->auto) {
360 
			if(is_null($this->yMax)) {
361 
				$max = array_max($this->datay);
362 
				if($max < 0) {
363 
					return 0;
364 
				}
365 
			}
366 
		}
367 
		return is_null($this->yMax) ? array_max($this->datay) : (float)$this->yMax;
368 
	}
369 
 
370 
	/**
371 
	 * Get min value for X axis
372 
	 *
373 
	 * @return float $value
374 
	 */
375 
	public function getXMin() {
376 
		return floor(is_null($this->xMin) ? array_min($this->datax) : $this->xMin);
377 
	}
378 
 
379 
	/**
380 
	 * Get max value for X axis
381 
	 *
382 
	 * @return float $value
383 
	 */
384 
	public function getXMax() {
385 
		return (ceil(is_null($this->xMax) ? array_max($this->datax) : (float)$this->xMax)) + ($this->getXCenter() ? 1 : 0);
386 
	}
387 
 
388 
	/**
389 
	 * Get min value with spaces for Y axis
390 
	 *
391 
	 * @return float $value
392 
	 */
393 
	public function getRealYMin() {
394 
		$min = $this->getYMin();
395 
		if($this->space->bottom !== NULL) {
396 
			$interval = ($this->getYMax() - $min) * $this->space->bottom / 100;
397 
			return $min - $interval;
398 
		} else {
399 
			return is_null($this->yMin) ? $min : (float)$this->yMin;
400 
		}
401 
	}
402 
 
403 
	/**
404 
	 * Get max value with spaces for Y axis
405 
	 *
406 
	 * @return float $value
407 
	 */
408 
	public function getRealYMax() {
409 
		$max = $this->getYMax();
410 
		if($this->space->top !== NULL) {
411 
			$interval = ($max - $this->getYMin()) * $this->space->top / 100;
412 
			return $max + $interval;
413 
		} else {
414 
			return is_null($this->yMax) ? $max : (float)$this->yMax;
415 
		}
416 
	}
417 
 
418 
	public function init(awDriver $driver) {
419 
 
420 
		list($x1, $y1, $x2, $y2) = $this->getPosition();
421 
 
422 
		// Get space informations
423 
		list($leftSpace, $rightSpace, $topSpace, $bottomSpace) = $this->getSpace($x2 - $x1, $y2 - $y1);
424 
 
425 
		$this->xAxis->setPadding($leftSpace, $rightSpace);
426 
 
427 
		if($this->space->bottom > 0 or $this->space->top > 0) {
428 
 
429 
			list($min, $max) = $this->yAxis->getRange();
430 
			$interval = $max - $min;
431 
 
432 
			$this->yAxis->setRange(
433 
				$min - $interval * $this->space->bottom / 100,
434 
				$max + $interval * $this->space->top / 100
435 
			);
436 
 
437 
		}
438 
 
439 
		// Auto-scaling mode
440 
		$this->yAxis->autoScale();
441 
 
442 
		// Number of labels is not specified
443 
		if($this->yAxis->getLabelNumber() === NULL) {
444 
			$number = round(($y2 - $y1) / 75) + 2;
445 
			$this->yAxis->setLabelNumber($number);
446 
		}
447 
 
448 
		$this->xAxis->line->setX($x1, $x2);
449 
		$this->yAxis->line->setY($y2, $y1);
450 
 
451 
		// Set ticks
452 
 
453 
		$this->xAxis->tick('major')->setNumber($this->getXAxisNumber());
454 
		$this->yAxis->tick('major')->setNumber($this->yAxis->getLabelNumber());
455 
 
456 
 
457 
		// Center X axis on zero
458 
		if($this->xAxisZero) {
459 
			$this->xAxis->setYCenter($this->yAxis, 0);
460 
		}
461 
 
462 
		// Center Y axis on zero
463 
		if($this->yAxisZero) {
464 
			$this->yAxis->setXCenter($this->xAxis, 0);
465 
		}
466 
 
467 
		// Set axis labels
468 
		$labels = array();
469 
 
470 
		list($xMin, $xMax) = $this->xAxis->getRange();
471 
		for($i = $xMin; $i <= $xMax; $i++) {
472 
			$labels[] = $i;
473 
		}
474 
		$this->xAxis->label->set($labels);
475 
 
476 
		parent::init($driver);
477 
 
478 
		list($x1, $y1, $x2, $y2) = $this->getPosition();
479 
 
480 
		list($leftSpace, $rightSpace) = $this->getSpace($x2 - $x1, $y2 - $y1);
481 
 
482 
		// Create the grid
483 
		$this->createGrid();
484 
 
485 
		// Draw the grid
486 
		$this->grid->setSpace($leftSpace, $rightSpace, 0, 0);
487 
		$this->grid->draw($driver, $x1, $y1, $x2, $y2);
488 
 
489 
	}
490 
 
491 
	public function drawEnvelope(awDriver $driver) {
492 
 
493 
		list($x1, $y1, $x2, $y2) = $this->getPosition();
494 
 
495 
		if($this->getXCenter()) {
496 
			$size = $this->xAxis->getDistance(0, 1);
497 
			$this->xAxis->label->move($size / 2, 0);
498 
			$this->xAxis->label->hideLast(TRUE);
499 
		}
500 
 
501 
		// Draw top axis
502 
		if($this->xAxisPosition === awPlot::TOP or $this->xAxisPosition === awPlot::BOTH) {
503 
			$top = clone $this->xAxis;
504 
			if($this->xAxisZero === FALSE) {
505 
				$top->line->setY($y1, $y1);
506 
			}
507 
			$top->label->setAlign(NULL, awLabel::TOP);
508 
			$top->label->move(0, -3);
509 
			$top->title->move(0, -25);
510 
			$top->draw($driver);
511 
		}
512 
 
513 
		// Draw bottom axis
514 
		if($this->xAxisPosition === awPlot::BOTTOM or $this->xAxisPosition === awPlot::BOTH) {
515 
			$bottom = clone $this->xAxis;
516 
			if($this->xAxisZero === FALSE) {
517 
				$bottom->line->setY($y2, $y2);
518 
			}
519 
			$bottom->label->setAlign(NULL, awLabel::BOTTOM);
520 
			$bottom->label->move(0, 3);
521 
			$bottom->reverseTickStyle();
522 
			$bottom->title->move(0, 25);
523 
			$bottom->draw($driver);
524 
		}
525 
 
526 
		// Draw left axis
527 
		if($this->yAxisPosition === awPlot::LEFT or $this->yAxisPosition === awPlot::BOTH) {
528 
			$left = clone $this->yAxis;
529 
			if($this->yAxisZero === FALSE) {
530 
				$left->line->setX($x1, $x1);
531 
			}
532 
			$left->label->setAlign(awLabel::RIGHT);
533 
			$left->label->move(-6, 0);
534 
			$left->title->move(-25, 0);
535 
			$left->draw($driver);
536 
		}
537 
 
538 
		// Draw right axis
539 
		if($this->yAxisPosition === awPlot::RIGHT or $this->yAxisPosition === awPlot::BOTH) {
540 
			$right = clone $this->yAxis;
541 
			if($this->yAxisZero === FALSE) {
542 
				$right->line->setX($x2, $x2);
543 
			}
544 
			$right->label->setAlign(awLabel::LEFT);
545 
			$right->label->move(6, 0);
546 
			$right->reverseTickStyle();
547 
			$right->title->move(25, 0);
548 
			$right->draw($driver);
549 
		}
550 
 
551 
	}
552 
 
553 
	protected function createGrid() {
554 
 
555 
		$max = $this->getRealYMax();
556 
		$min = $this->getRealYMin();
557 
 
558 
		$number = $this->yAxis->getLabelNumber() - 1;
559 
 
560 
		if($number < 1) {
561 
			return;
562 
		}
563 
 
564 
		// Horizontal lines of the grid
565 
 
566 
		$h = array();
567 
		for($i = 0; $i <= $number; $i++) {
568 
			$h[] = $i / $number;
569 
		}
570 
 
571 
		// Vertical lines
572 
 
573 
		$major = $this->yAxis->tick('major');
574 
		$interval = $major->getInterval();
575 
		$number = $this->getXAxisNumber() - 1;
576 
 
577 
		$w = array();
578 
 
579 
		if($number > 0) {
580 
 
581 
			for($i = 0; $i <= $number; $i++) {
582 
				if($i%$interval === 0) {
583 
					$w[] = $i / $number;
584 
				}
585 
			}
586 
 
587 
		}
588 
 
589 
		$this->grid->setGrid($w, $h);
590 
 
591 
	}
592 
 
593 
	/**
594 
	 * Change values of Y axis
595 
	 * This method ignores not numeric values
596 
	 *
597 
	 * @param array $datay
598 
	 * @param array $datax
599 
	 */
600 
	public function setValues($datay, $datax = NULL) {
601 
 
602 
		$this->checkArray($datay);
603 
 
604 
		foreach($datay as $key => $value) {
605 
			unset($datay[$key]);
606 
			$datay[(int)$key] = $value;
607 
		}
608 
 
609 
		if($datax === NULL) {
610 
			$datax = array();
611 
			for($i = 0; $i < count($datay); $i++) {
612 
				$datax[] = $i;
613 
			}
614 
		} else {
615 
			foreach($datax as $key => $value) {
616 
				unset($datax[$key]);
617 
				$datax[(int)$key] = $value;
618 
			}
619 
		}
620 
 
621 
		$this->checkArray($datax);
622 
 
623 
		if(count($datay) === count($datax)) {
624 
 
625 
			// Set values
626 
			$this->datay = $datay;
627 
			$this->datax = $datax;
628 
			// Update axis with the new awvalues
629 
			$this->updateAxis();
630 
		} else {
631 
			awImage::drawError("Class Plot: Plots must have the same number of X and Y points.");
632 
		}
633 
 
634 
	}
635 
 
636 
	/**
637 
	 * Return begin and end values
638 
	 *
639 
	 * @return array
640 
	 */
641 
	protected function getLimit() {
642 
 
643 
		$i = 0;
644 
		while(array_key_exists($i, $this->datay) and $this->datay[$i] === NULL) {
645 
			$i++;
646 
		}
647 
		$start = $i;
648 
		$i = count($this->datay) - 1;
649 
		while(array_key_exists($i, $this->datay) and $this->datay[$i] === NULL) {
650 
			$i--;
651 
		}
652 
		$stop = $i;
653 
 
654 
		return array($start, $stop);
655 
 
656 
	}
657 
 
658 
	/**
659 
	 * Return TRUE if labels must be centered on X axis, FALSE otherwise
660 
	 *
661 
	 * @return bool
662 
	 */
663 
	abstract public function getXCenter();
664 
 
665 
	private function updateAxis() {
666 
 
667 
		$this->xAxis->setRange(
668 
			$this->getXMin(),
669 
			$this->getXMax()
670 
		);
671 
		$this->yAxis->setRange(
672 
			$this->getRealYMin(),
673 
			$this->getRealYMax()
674 
		);
675 
 
676 
	}
677 
 
678 
	private function checkArray(&$array) {
679 
 
680 
		if(is_array($array) === FALSE) {
681 
			awImage::drawError("Class Plot: You tried to set a value that is not an array.");
682 
		}
683 
 
684 
		foreach($array as $key => $value) {
685 
			if(is_numeric($value) === FALSE and is_null($value) === FALSE) {
686 
				awImage::drawError("Class Plot: Expected numeric values for the plot.");
687 
			}
688 
		}
689 
 
690 
		if(count($array) < 1) {
691 
			awImage::drawError("Class Plot: Your plot must have at least 1 value.");
692 
		}
693 
 
694 
	}
695 
 
696 
}
697 
 
698 
registerClass('Plot', TRUE);
699 
 
700 
class awPlotAxis {
701 
 
702 
	/**
703 
	 * Left axis
704 
	 *
705 
	 * @var Axis
706 
	 */
707 
	public $left;
708 
 
709 
	/**
710 
	 * Right axis
711 
	 *
712 
	 * @var Axis
713 
	 */
714 
	public $right;
715 
 
716 
	/**
717 
	 * Top axis
718 
	 *
719 
	 * @var Axis
720 
	 */
721 
	public $top;
722 
 
723 
	/**
724 
	 * Bottom axis
725 
	 *
726 
	 * @var Axis
727 
	 */
728 
	public $bottom;
729 
 
730 
	/**
731 
	 * Build the group of axis
732 
	 */
733 
	public function __construct() {
734 
 
735 
		$this->left = new awAxis;
736 
		$this->left->auto(TRUE);
737 
		$this->left->label->setAlign(awLabel::RIGHT);
738 
		$this->left->label->move(-6, 0);
739 
		$this->yAxis($this->left);
740 
		$this->left->setTickStyle(awTick::OUT);
741 
		$this->left->title->move(-25, 0);
742 
 
743 
		$this->right = new awAxis;
744 
		$this->right->auto(TRUE);
745 
		$this->right->label->setAlign(awLabel::LEFT);
746 
		$this->right->label->move(6, 0);
747 
		$this->yAxis($this->right);
748 
		$this->right->setTickStyle(awTick::IN);
749 
		$this->right->title->move(25, 0);
750 
 
751 
		$this->top = new awAxis;
752 
		$this->top->label->setAlign(NULL, awLabel::TOP);
753 
		$this->top->label->move(0, -3);
754 
		$this->xAxis($this->top);
755 
		$this->top->setTickStyle(awTick::OUT);
756 
		$this->top->title->move(0, -25);
757 
 
758 
		$this->bottom = new awAxis;
759 
		$this->bottom->label->setAlign(NULL, awLabel::BOTTOM);
760 
		$this->bottom->label->move(0, 3);
761 
		$this->xAxis($this->bottom);
762 
		$this->bottom->setTickStyle(awTick::IN);
763 
		$this->bottom->title->move(0, 25);
764 
 
765 
	}
766 
 
767 
	protected function xAxis(awAxis $axis) {
768 
 
769 
		$axis->addTick('major', new awTick(0, 5));
770 
		$axis->addTick('minor', new awTick(0, 3));
771 
		$axis->label->setFont(new awTuffy(7));
772 
 
773 
	}
774 
 
775 
	protected function yAxis(awAxis $axis) {
776 
 
777 
		$axis->addTick('major', new awTick(0, 5));
778 
		$axis->addTick('minor', new awTick(0, 3));
779 
		$axis->setNumberByTick('minor', 'major', 3);
780 
		$axis->label->setFont(new awTuffy(7));
781 
		$axis->title->setAngle(90);
782 
 
783 
	}
784 
 
785 
}
786 
 
787 
registerClass('PlotAxis');
788 
 
789 
/**
790 
 * A graph with axis can contain some groups of components
791 
 *
792 
 * @package Artichow
793 
 */
794 
class awPlotGroup extends awComponentGroup {
795 
 
796 
	/**
797 
	 * Grid properties
798 
	 *
799 
	 * @var Grid
800 
	 */
801 
	public $grid;
802 
 
803 
	/**
804 
	 * Left, right, top and bottom axis
805 
	 *
806 
	 * @var PlotAxis
807 
	 */
808 
	public $axis;
809 
 
810 
	/**
811 
	 * Set the X axis on zero
812 
	 *
813 
	 * @var bool
814 
	 */
815 
	protected $xAxisZero = TRUE;
816 
 
817 
	/**
818 
	 * Set the Y axis on zero
819 
	 *
820 
	 * @var bool
821 
	 */
822 
	protected $yAxisZero = FALSE;
823 
 
824 
	/**
825 
	 * Real axis used for Y axis
826 
	 *
827 
	 * @var string
828 
	 */
829 
	private $yRealAxis = awPlot::LEFT;
830 
 
831 
	/**
832 
	 * Real axis used for X axis
833 
	 *
834 
	 * @var string
835 
	 */
836 
	private $xRealAxis = awPlot::BOTTOM;
837 
 
838 
	/**
839 
	 * Change min value for Y axis
840 
	 *
841 
	 * @var mixed
842 
	 */
843 
	private $yMin = NULL;
844 
 
845 
	/**
846 
	 * Change max value for Y axis
847 
	 *
848 
	 * @var mixed
849 
	 */
850 
	private $yMax = NULL;
851 
 
852 
	/**
853 
	 * Change min value for X axis
854 
	 *
855 
	 * @var mixed
856 
	 */
857 
	private $xMin = NULL;
858 
 
859 
	/**
860 
	 * Change max value for X axis
861 
	 *
862 
	 * @var mixed
863 
	 */
864 
	private $xMax = NULL;
865 
 
866 
	/**
867 
	 * Build the PlotGroup
868 
	 *
869 
	 */
870 
	public function __construct() {
871 
 
872 
		parent::__construct();
873 
 
874 
		$this->grid = new awGrid;
875 
		$this->grid->setBackgroundColor(new awWhite);
876 
 
877 
		$this->axis = new awPlotAxis;
878 
 
879 
	}
880 
 
881 
	/**
882 
	 * Set the X axis on zero or not
883 
	 *
884 
	 * @param bool $zero
885 
	 */
886 
	public function setXAxisZero($zero) {
887 
		$this->xAxisZero = (bool)$zero;
888 
	}
889 
 
890 
	/**
891 
	 * Set the Y axis on zero or not
892 
	 *
893 
	 * @param bool $zero
894 
	 */
895 
	public function setYAxisZero($zero) {
896 
		$this->yAxisZero = (bool)$zero;
897 
	}
898 
 
899 
	/**
900 
	 * Change min value for Y axis
901 
	 * Set NULL for auto selection.
902 
	 *
903 
	 * @param float $value
904 
	 */
905 
	public function setYMin($value) {
906 
		$this->axis->left->auto(FALSE);
907 
		$this->axis->right->auto(FALSE);
908 
		$this->yMin = $value;
909 
	}
910 
 
911 
	/**
912 
	 * Change max value for Y axis
913 
	 * Set NULL for auto selection.
914 
	 *
915 
	 * @param float $value
916 
	 */
917 
	public function setYMax($value) {
918 
		$this->axis->left->auto(FALSE);
919 
		$this->axis->right->auto(FALSE);
920 
		$this->yMax = $value;
921 
	}
922 
 
923 
	/**
924 
	 * Change min value for X axis
925 
	 * Set NULL for auto selection.
926 
	 *
927 
	 * @param float $value
928 
	 */
929 
	public function setXMin($value) {
930 
		$this->xMin = $value;
931 
	}
932 
 
933 
	/**
934 
	 * Change max value for X axis
935 
	 * Set NULL for auto selection.
936 
	 *
937 
	 * @param float $value
938 
	 */
939 
	public function setXMax($value) {
940 
		$this->xMax = $value;
941 
	}
942 
 
943 
	/**
944 
	 * Get min value for X axis
945 
	 *
946 
	 * @return float $value
947 
	 */
948 
	public function getXMin() {
949 
 
950 
		return $this->getX('min');
951 
 
952 
	}
953 
 
954 
	/**
955 
	 * Get max value for X axis
956 
	 *
957 
	 * @return float $value
958 
	 */
959 
	public function getXMax() {
960 
 
961 
		return $this->getX('max');
962 
 
963 
	}
964 
 
965 
	private function getX($type) {
966 
 
967 
		switch($type) {
968 
			case 'max' :
969 
				if($this->xMax !== NULL) {
970 
					return $this->xMax;
971 
				}
972 
				break;
973 
			case 'min' :
974 
				if($this->xMin !== NULL) {
975 
					return $this->xMin;
976 
				}
977 
				break;
978 
		}
979 
 
980 
		$value = NULL;
981 
		$get = 'getX'.ucfirst($type);
982 
 
983 
		for($i = 0; $i < count($this->components); $i++) {
984 
 
985 
			$component = $this->components[$i];
986 
 
987 
			if($value === NULL) {
988 
				$value = $component->$get();
989 
			} else {
990 
				$value = $type($value, $component->$get());
991 
			}
992 
 
993 
		}
994 
 
995 
		return $value;
996 
 
997 
	}
998 
 
999 
	/**
1000 
	 * Get min value with spaces for Y axis
1001 
	 *
1002 
	 * @param string $axis Axis name
1003 
	 * @return float $value
1004 
	 */
1005 
	public function getRealYMin($axis = NULL) {
1006 
 
1007 
		if($axis === NULL) {
1008 
			return NULL;
1009 
		}
1010 
 
1011 
		$min = $this->getRealY('min', $axis);
1012 
		$max = $this->getRealY('max', $axis);
1013 
 
1014 
		if($this->space->bottom !== NULL) {
1015 
			$interval = ($min - $max) * $this->space->bottom / 100;
1016 
			return $min + $interval;
1017 
		} else {
1018 
			return $min;
1019 
		}
1020 
 
1021 
	}
1022 
 
1023 
	/**
1024 
	 * Get max value with spaces for Y axis
1025 
	 *
1026 
	 * @param string $axis Axis name
1027 
	 * @return float $value
1028 
	 */
1029 
	public function getRealYMax($axis = NULL) {
1030 
 
1031 
		if($axis === NULL) {
1032 
			return NULL;
1033 
		}
1034 
 
1035 
		$min = $this->getRealY('min', $axis);
1036 
		$max = $this->getRealY('max', $axis);
1037 
 
1038 
		if($this->space->top !== NULL) {
1039 
			$interval = ($max - $min) * $this->space->top / 100;
1040 
			return $max + $interval;
1041 
		} else {
1042 
			return $max;
1043 
		}
1044 
 
1045 
	}
1046 
 
1047 
	private function getRealY($type, $axis) {
1048 
 
1049 
		switch($type) {
1050 
			case 'max' :
1051 
				if($this->yMax !== NULL) {
1052 
					return $this->yMax;
1053 
				}
1054 
				break;
1055 
			case 'min' :
1056 
				if($this->yMin !== NULL) {
1057 
					return $this->yMin;
1058 
				}
1059 
				break;
1060 
		}
1061 
 
1062 
		$value = NULL;
1063 
		$get = 'getY'.ucfirst($type);
1064 
 
1065 
		for($i = 0; $i < count($this->components); $i++) {
1066 
 
1067 
			$component = $this->components[$i];
1068 
 
1069 
			switch($axis) {
1070 
 
1071 
				case awPlot::LEFT :
1072 
				case awPlot::RIGHT :
1073 
					$test = ($component->getYAxis() === $axis);
1074 
					break;
1075 
				default :
1076 
					$test = FALSE;
1077 
 
1078 
			}
1079 
 
1080 
			if($test) {
1081 
 
1082 
				$auto = $component->yAxis->isAuto();
1083 
				$this->axis->{$axis}->auto($auto);
1084 
 
1085 
				if($value === NULL) {
1086 
					$value = $component->$get();
1087 
				} else {
1088 
					$value = $type($value, $component->$get());
1089 
				}
1090 
 
1091 
			}
1092 
 
1093 
		}
1094 
 
1095 
		return $value;
1096 
 
1097 
	}
1098 
 
1099 
	public function init(awDriver $driver) {
1100 
 
1101 
		list($x1, $y1, $x2, $y2) = $this->getPosition();
1102 
 
1103 
		// Get PlotGroup space
1104 
		list($leftSpace, $rightSpace, $topSpace, $bottomSpace) = $this->getSpace($x2 - $x1, $y2 - $y1);
1105 
 
1106 
		// Count values in the group
1107 
		$values = $this->getXAxisNumber();
1108 
 
1109 
		// Init the PlotGroup
1110 
		$this->axis->top->line->setX($x1, $x2);
1111 
		$this->axis->bottom->line->setX($x1, $x2);
1112 
		$this->axis->left->line->setY($y2, $y1);
1113 
		$this->axis->right->line->setY($y2, $y1);
1114 
 
1115 
		$this->axis->top->setPadding($leftSpace, $rightSpace);
1116 
		$this->axis->bottom->setPadding($leftSpace, $rightSpace);
1117 
 
1118 
		$xMin = $this->getXMin();
1119 
		$xMax = $this->getXMax();
1120 
 
1121 
		$this->axis->top->setRange($xMin, $xMax);
1122 
		$this->axis->bottom->setRange($xMin, $xMax);
1123 
 
1124 
		for($i = 0; $i < count($this->components); $i++) {
1125 
 
1126 
 
1127 
			$component = $this->components[$i];
1128 
 
1129 
						$component->auto($this->auto);
1130 
 
1131 
			// Copy space to the component
1132 
 
1133 
			$component->setSpace($this->space->left, $this->space->right, $this->space->top, $this->space->bottom);
1134 
 
1135 
			$component->xAxis->setPadding($leftSpace, $rightSpace);
1136 
			$component->xAxis->line->setX($x1, $x2);
1137 
 
1138 
			$component->yAxis->line->setY($y2, $y1);
1139 
 
1140 
		}
1141 
 
1142 
		// Set Y axis range
1143 
		foreach(array('left', 'right') as $axis) {
1144 
 
1145 
			if($this->isAxisUsed($axis)) {
1146 
 
1147 
				$min = $this->getRealYMin($axis);
1148 
				$max = $this->getRealYMax($axis);
1149 
 
1150 
				$interval = $max - $min;
1151 
 
1152 
				$this->axis->{$axis}->setRange(
1153 
					$min - $interval * $this->space->bottom / 100,
1154 
					$max + $interval * $this->space->top / 100
1155 
				);
1156 
 
1157 
				// Auto-scaling mode
1158 
				if($this->axis->{$axis}->isAuto()) {
1159 
					$this->axis->{$axis}->autoScale();
1160 
				}
1161 
 
1162 
			}
1163 
 
1164 
		}
1165 
 
1166 
		if($this->axis->left->getLabelNumber() === NULL) {
1167 
			$number = round(($y2 - $y1) / 75) + 2;
1168 
			$this->axis->left->setLabelNumber($number);
1169 
		}
1170 
 
1171 
		if($this->axis->right->getLabelNumber() === NULL) {
1172 
			$number = round(($y2 - $y1) / 75) + 2;
1173 
			$this->axis->right->setLabelNumber($number);
1174 
		}
1175 
 
1176 
		// Center labels on X axis if needed
1177 
		$test = array(awPlot::TOP => FALSE, awPlot::BOTTOM => FALSE);
1178 
 
1179 
		for($i = 0; $i < count($this->components); $i++) {
1180 
 
1181 
 
1182 
			$component = $this->components[$i];
1183 
 
1184 
 
1185 
			if($component->getValues() !== NULL) {
1186 
 
1187 
				$axis = $component->getXAxis();
1188 
 
1189 
				if($test[$axis] === FALSE) {
1190 
 
1191 
					// Center labels for bar plots
1192 
					if($component->getXCenter()) {
1193 
						$size = $this->axis->{$axis}->getDistance(0, 1);
1194 
						$this->axis->{$axis}->label->move($size / 2, 0);
1195 
						$this->axis->{$axis}->label->hideLast(TRUE);
1196 
						$test[$axis] = TRUE;
1197 
					}
1198 
 
1199 
				}
1200 
 
1201 
			}
1202 
 
1203 
 
1204 
		}
1205 
 
1206 
		// Set axis labels
1207 
		$labels = array();
1208 
		for($i = $xMin; $i <= $xMax; $i++) {
1209 
			$labels[] = $i;
1210 
		}
1211 
		if($this->axis->top->label->count() === 0) {
1212 
			$this->axis->top->label->set($labels);
1213 
		}
1214 
		if($this->axis->bottom->label->count() === 0) {
1215 
			$this->axis->bottom->label->set($labels);
1216 
		}
1217 
 
1218 
		// Set ticks
1219 
 
1220 
		$this->axis->top->tick('major')->setNumber($values);
1221 
		$this->axis->bottom->tick('major')->setNumber($values);
1222 
		$this->axis->left->tick('major')->setNumber($this->axis->left->getLabelNumber());
1223 
		$this->axis->right->tick('major')->setNumber($this->axis->right->getLabelNumber());
1224 
 
1225 
 
1226 
		// Set X axis on zero
1227 
		if($this->xAxisZero) {
1228 
			$axis = $this->selectYAxis();
1229 
			$this->axis->bottom->setYCenter($axis, 0);
1230 
			$this->axis->top->setYCenter($axis, 0);
1231 
		}
1232 
 
1233 
		// Set Y axis on zero
1234 
		if($this->yAxisZero) {
1235 
			$axis = $this->selectXAxis();
1236 
			$this->axis->left->setXCenter($axis, 1);
1237 
			$this->axis->right->setXCenter($axis, 1);
1238 
		}
1239 
 
1240 
		parent::init($driver);
1241 
 
1242 
		list($leftSpace, $rightSpace, $topSpace, $bottomSpace) = $this->getSpace($x2 - $x1, $y2 - $y1);
1243 
 
1244 
		// Create the grid
1245 
		$this->createGrid();
1246 
 
1247 
		// Draw the grid
1248 
		$this->grid->setSpace($leftSpace, $rightSpace, 0, 0);
1249 
		$this->grid->draw($driver, $x1, $y1, $x2, $y2);
1250 
 
1251 
	}
1252 
 
1253 
	public function drawComponent(awDriver $driver, $x1, $y1, $x2, $y2, $aliasing) {
1254 
 
1255 
		$xMin = $this->getXMin();
1256 
		$xMax = $this->getXMax();
1257 
 
1258 
		$maxLeft = $this->getRealYMax(awPlot::LEFT);
1259 
		$maxRight = $this->getRealYMax(awPlot::RIGHT);
1260 
 
1261 
		$minLeft = $this->getRealYMin(awPlot::LEFT);
1262 
		$minRight = $this->getRealYMin(awPlot::RIGHT);
1263 
 
1264 
		foreach($this->components as $component) {
1265 
 
1266 
			$min = $component->getYMin();
1267 
			$max = $component->getYMax();
1268 
 
1269 
			// Set component minimum and maximum
1270 
			if($component->getYAxis() === awPlot::LEFT) {
1271 
 
1272 
				list($min, $max) = $this->axis->left->getRange();
1273 
 
1274 
				$component->setYMin($min);
1275 
				$component->setYMax($max);
1276 
 
1277 
			} else {
1278 
 
1279 
				list($min, $max) = $this->axis->right->getRange();
1280 
 
1281 
				$component->setYMin($min);
1282 
				$component->setYMax($max);
1283 
 
1284 
			}
1285 
 
1286 
			$component->setXAxisZero($this->xAxisZero);
1287 
			$component->setYAxisZero($this->yAxisZero);
1288 
 
1289 
			$component->xAxis->setRange($xMin, $xMax);
1290 
 
1291 
			$component->drawComponent(
1292 
				$driver,
1293 
				$x1, $y1,
1294 
				$x2, $y2,
1295 
				$aliasing
1296 
			);
1297 
 
1298 
			$component->setYMin($min);
1299 
			$component->setYMax($max);
1300 
 
1301 
		}
1302 
 
1303 
	}
1304 
 
1305 
	public function drawEnvelope(awDriver $driver) {
1306 
 
1307 
		list($x1, $y1, $x2, $y2) = $this->getPosition();
1308 
 
1309 
		// Hide unused axis
1310 
		foreach(array(awPlot::LEFT, awPlot::RIGHT, awPlot::TOP, awPlot::BOTTOM) as $axis) {
1311 
			if($this->isAxisUsed($axis) === FALSE) {
1312 
				$this->axis->{$axis}->hide(TRUE);
1313 
			}
1314 
		}
1315 
 
1316 
		// Draw top axis
1317 
		$top = $this->axis->top;
1318 
		if($this->xAxisZero === FALSE) {
1319 
			$top->line->setY($y1, $y1);
1320 
		}
1321 
		$top->draw($driver);
1322 
 
1323 
		// Draw bottom axis
1324 
		$bottom = $this->axis->bottom;
1325 
		if($this->xAxisZero === FALSE) {
1326 
			$bottom->line->setY($y2, $y2);
1327 
		}
1328 
		$bottom->draw($driver);
1329 
 
1330 
		// Draw left axis
1331 
		$left = $this->axis->left;
1332 
		if($this->yAxisZero === FALSE) {
1333 
			$left->line->setX($x1, $x1);
1334 
		}
1335 
		$left->draw($driver);
1336 
 
1337 
		// Draw right axis
1338 
		$right = $this->axis->right;
1339 
		if($this->yAxisZero === FALSE) {
1340 
			$right->line->setX($x2, $x2);
1341 
		}
1342 
		$right->draw($driver);
1343 
 
1344 
	}
1345 
 
1346 
	/**
1347 
	 * Is the specified axis used ?
1348 
	 *
1349 
	 * @param string $axis Axis name
1350 
	 * @return bool
1351 
	 */
1352 
	protected function isAxisUsed($axis) {
1353 
 
1354 
		for($i = 0; $i < count($this->components); $i++) {
1355 
 
1356 
			$component = $this->components[$i];
1357 
 
1358 
			switch($axis) {
1359 
 
1360 
				case awPlot::LEFT :
1361 
				case awPlot::RIGHT :
1362 
					if($component->getYAxis() === $axis) {
1363 
						return TRUE;
1364 
					}
1365 
					break;
1366 
 
1367 
				case awPlot::TOP :
1368 
				case awPlot::BOTTOM :
1369 
					if($component->getXAxis() === $axis) {
1370 
						return TRUE;
1371 
					}
1372 
					break;
1373 
 
1374 
			}
1375 
 
1376 
		}
1377 
 
1378 
		return FALSE;
1379 
 
1380 
	}
1381 
 
1382 
	protected function createGrid() {
1383 
 
1384 
		$max = $this->getRealYMax(awPlot::LEFT);
1385 
		$min = $this->getRealYMin(awPlot::RIGHT);
1386 
 
1387 
		// Select axis (left if possible, right otherwise)
1388 
		$axis = $this->selectYAxis();
1389 
 
1390 
		$number = $axis->getLabelNumber() - 1;
1391 
 
1392 
		if($number < 1) {
1393 
			return;
1394 
		}
1395 
 
1396 
		// Horizontal lines of grid
1397 
 
1398 
		$h = array();
1399 
		for($i = 0; $i <= $number; $i++) {
1400 
			$h[] = $i / $number;
1401 
		}
1402 
 
1403 
		// Vertical lines
1404 
 
1405 
		$major = $axis->tick('major');
1406 
		$interval = $major->getInterval();
1407 
		$number = $this->getXAxisNumber() - 1;
1408 
 
1409 
		$w = array();
1410 
 
1411 
		if($number > 0) {
1412 
 
1413 
			for($i = 0; $i <= $number; $i++) {
1414 
				if($i%$interval === 0) {
1415 
					$w[] = $i / $number;
1416 
				}
1417 
			}
1418 
 
1419 
		}
1420 
 
1421 
		$this->grid->setGrid($w, $h);
1422 
 
1423 
	}
1424 
 
1425 
	protected function selectYAxis(){
1426 
 
1427 
		// Select axis (left if possible, right otherwise)
1428 
		if($this->isAxisUsed(awPlot::LEFT)) {
1429 
			$axis = $this->axis->left;
1430 
		} else {
1431 
			$axis = $this->axis->right;
1432 
		}
1433 
 
1434 
		return $axis;
1435 
 
1436 
	}
1437 
 
1438 
	protected function selectXAxis(){
1439 
 
1440 
		// Select axis (bottom if possible, top otherwise)
1441 
		if($this->isAxisUsed(awPlot::BOTTOM)) {
1442 
			$axis = $this->axis->bottom;
1443 
		} else {
1444 
			$axis = $this->axis->top;
1445 
		}
1446 
 
1447 
		return $axis;
1448 
 
1449 
	}
1450 
 
1451 
	protected function getXAxisNumber() {
1452 
		$offset = $this->components[0];
1453 
		$max = $offset->getXAxisNumber();
1454 
		for($i = 1; $i < count($this->components); $i++) {
1455 
			$offset = $this->components[$i];
1456 
			$max = max($max, $offset->getXAxisNumber());
1457 
		}
1458 
		return $max;
1459 
	}
1460 
 
1461 
}
1462 
 
1463 
registerClass('PlotGroup');
1464 
?>