source: trunk/client/modules/Elezioni/grafici/jpgraph_polar.php@ 73

Last change on this file since 73 was 2, checked in by root, 15 years ago

importo il progetto
File size: 22.6 KB
RevLine 
[2]1<?php
2/*=======================================================================
3// File: JPGRAPH_POLAR.PHP
4// Description: Polar plot extension for JpGraph
5// Created: 2003-02-02
6// Ver: $Id: jpgraph_polar.php 1091 2009-01-18 22:57:40Z ljp $
7//
8// Copyright (c) Aditus Consulting. All rights reserved.
9//========================================================================
10*/
11
12require_once ('jpgraph_plotmark.inc.php');
13require_once "jpgraph_log.php";
14
15
16define('POLAR_360',1);
17define('POLAR_180',2);
18
19//
20// Note. Don't attempt to make sense of this code.
21// In order not to have to be able to inherit the scaling code
22// from the main graph package we have had to make some "tricks" since
23// the original scaling and axis was not designed to do what is
24// required here.
25// There were two option. 1: Re-implement everything and get a clean design
26// and 2: do some "small" trickery and be able to inherit most of
27// the functionlity from the main graph package.
28// We choose 2: here in order to save some time.
29//
30
31//--------------------------------------------------------------------------
32// class PolarPlot
33//--------------------------------------------------------------------------
34class PolarPlot {
35 public $line_style='solid',$mark;
36 public $legendcsimtarget='';
37 public $legendcsimalt='';
38 public $legend="";
39 public $csimtargets=array(); // Array of targets for CSIM
40 public $csimareas=""; // Resultant CSIM area tags
41 public $csimalts=null; // ALT:s for corresponding target
42 public $scale=null;
43 private $numpoints=0;
44 private $iColor='navy',$iFillColor='';
45 private $iLineWeight=1;
46 private $coord=null;
47
48 function PolarPlot($aData) {
49 $n = count($aData);
50 if( $n & 1 ) {
51 JpGraphError::RaiseL(17001);
52//('Polar plots must have an even number of data point. Each data point is a tuple (angle,radius).');
53 }
54 $this->numpoints = $n/2;
55 $this->coord = $aData;
56 $this->mark = new PlotMark();
57 }
58
59 function SetWeight($aWeight) {
60 $this->iLineWeight = $aWeight;
61 }
62
63 function SetColor($aColor){
64 $this->iColor = $aColor;
65 }
66
67 function SetFillColor($aColor){
68 $this->iFillColor = $aColor;
69 }
70
71 function Max() {
72 $m = $this->coord[1];
73 $i=1;
74 while( $i < $this->numpoints ) {
75 $m = max($m,$this->coord[2*$i+1]);
76 ++$i;
77 }
78 return $m;
79 }
80 // Set href targets for CSIM
81 function SetCSIMTargets($aTargets,$aAlts=null) {
82 $this->csimtargets=$aTargets;
83 $this->csimalts=$aAlts;
84 }
85
86 // Get all created areas
87 function GetCSIMareas() {
88 return $this->csimareas;
89 }
90
91 function SetLegend($aLegend,$aCSIM="",$aCSIMAlt="") {
92 $this->legend = $aLegend;
93 $this->legendcsimtarget = $aCSIM;
94 $this->legendcsimalt = $aCSIMAlt;
95 }
96
97 // Private methods
98
99 function Legend($aGraph) {
100 $color = $this->iColor ;
101 if( $this->legend != "" ) {
102 if( $this->iFillColor!='' ) {
103 $color = $this->iFillColor;
104 $aGraph->legend->Add($this->legend,$color,$this->mark,0,
105 $this->legendcsimtarget,$this->legendcsimalt);
106 }
107 else {
108 $aGraph->legend->Add($this->legend,$color,$this->mark,$this->line_style,
109 $this->legendcsimtarget,$this->legendcsimalt);
110 }
111 }
112 }
113
114 function Stroke($img,$scale) {
115
116 $i=0;
117 $p=array();
118 $this->csimareas='';
119 while($i < $this->numpoints) {
120 list($x1,$y1) = $scale->PTranslate($this->coord[2*$i],$this->coord[2*$i+1]);
121 $p[2*$i] = $x1;
122 $p[2*$i+1] = $y1;
123
124 if( isset($this->csimtargets[$i]) ) {
125 $this->mark->SetCSIMTarget($this->csimtargets[$i]);
126 $this->mark->SetCSIMAlt($this->csimalts[$i]);
127 $this->mark->SetCSIMAltVal($this->coord[2*$i], $this->coord[2*$i+1]);
128 $this->mark->Stroke($img,$x1,$y1);
129 $this->csimareas .= $this->mark->GetCSIMAreas();
130 }
131 else
132 $this->mark->Stroke($img,$x1,$y1);
133
134 ++$i;
135 }
136
137 if( $this->iFillColor != '' ) {
138 $img->SetColor($this->iFillColor);
139 $img->FilledPolygon($p);
140 }
141 $img->SetLineWeight($this->iLineWeight);
142 $img->SetColor($this->iColor);
143 $img->Polygon($p,$this->iFillColor!='');
144 }
145}
146
147//--------------------------------------------------------------------------
148// class PolarAxis
149//--------------------------------------------------------------------------
150class PolarAxis extends Axis {
151 private $angle_step=15,$angle_color='lightgray',$angle_label_color='black';
152 private $angle_fontfam=FF_FONT1,$angle_fontstyle=FS_NORMAL,$angle_fontsize=10;
153 private $angle_fontcolor = 'navy';
154 private $gridminor_color='lightgray',$gridmajor_color='lightgray';
155 private $show_minor_grid = false, $show_major_grid = true ;
156 private $show_angle_mark=true, $show_angle_grid=true, $show_angle_label=true;
157 private $angle_tick_len=3, $angle_tick_len2=3, $angle_tick_color='black';
158 private $show_angle_tick=true;
159 private $radius_tick_color='black';
160
161 function PolarAxis($img,$aScale) {
162 parent::Axis($img,$aScale);
163 }
164
165 function ShowAngleDegreeMark($aFlg=true) {
166 $this->show_angle_mark = $aFlg;
167 }
168
169 function SetAngleStep($aStep) {
170 $this->angle_step=$aStep;
171 }
172
173 function HideTicks($aFlg=true,$aAngleFlg=true) {
174 parent::HideTicks($aFlg,$aFlg);
175 $this->show_angle_tick = !$aAngleFlg;
176 }
177
178 function ShowAngleLabel($aFlg=true) {
179 $this->show_angle_label = $aFlg;
180 }
181
182 function ShowGrid($aMajor=true,$aMinor=false,$aAngle=true) {
183 $this->show_minor_grid = $aMinor;
184 $this->show_major_grid = $aMajor;
185 $this->show_angle_grid = $aAngle ;
186 }
187
188 function SetAngleFont($aFontFam,$aFontStyle=FS_NORMAL,$aFontSize=10) {
189 $this->angle_fontfam = $aFontFam;
190 $this->angle_fontstyle = $aFontStyle;
191 $this->angle_fontsize = $aFontSize;
192 }
193
194 function SetColor($aColor,$aRadColor='',$aAngleColor='') {
195 if( $aAngleColor == '' )
196 $aAngleColor=$aColor;
197 parent::SetColor($aColor,$aRadColor);
198 $this->angle_fontcolor = $aAngleColor;
199 }
200
201 function SetGridColor($aMajorColor,$aMinorColor='',$aAngleColor='') {
202 if( $aMinorColor == '' )
203 $aMinorColor = $aMajorColor;
204 if( $aAngleColor == '' )
205 $aAngleColor = $aMajorColor;
206
207 $this->gridminor_color = $aMinorColor;
208 $this->gridmajor_color = $aMajorColor;
209 $this->angle_color = $aAngleColor;
210 }
211
212 function SetTickColors($aRadColor,$aAngleColor='') {
213 $this->radius_tick_color = $aRadColor;
214 $this->angle_tick_color = $aAngleColor;
215 }
216
217 // Private methods
218 function StrokeGrid($pos) {
219 $x = round($this->img->left_margin + $this->img->plotwidth/2);
220 $this->scale->ticks->Stroke($this->img,$this->scale,$pos);
221
222 // Stroke the minor arcs
223 $pmin = array();
224 $p = $this->scale->ticks->ticks_pos;
225 $n = count($p);
226 $i = 0;
227 $this->img->SetColor($this->gridminor_color);
228 while( $i < $n ) {
229 $r = $p[$i]-$x+1;
230 $pmin[]=$r;
231 if( $this->show_minor_grid ) {
232 $this->img->Circle($x,$pos,$r);
233 }
234 $i++;
235 }
236
237 $limit = max($this->img->plotwidth,$this->img->plotheight)*1.4 ;
238 while( $r < $limit ) {
239 $off = $r;
240 $i=1;
241 $r = $off + round($p[$i]-$x+1);
242 while( $r < $limit && $i < $n ) {
243 $r = $off+$p[$i]-$x;
244 $pmin[]=$r;
245 if( $this->show_minor_grid ) {
246 $this->img->Circle($x,$pos,$r);
247 }
248 $i++;
249 }
250 }
251
252 // Stroke the major arcs
253 if( $this->show_major_grid ) {
254 // First determine how many minor step on
255 // every major step. We have recorded the minor radius
256 // in pmin and use these values. This is done in order
257 // to avoid rounding errors if we were to recalculate the
258 // different major radius.
259 $pmaj = $this->scale->ticks->maj_ticks_pos;
260 $p = $this->scale->ticks->ticks_pos;
261 if( $this->scale->name == 'lin' ) {
262 $step=round(($pmaj[1] - $pmaj[0])/($p[1] - $p[0]));
263 }
264 else {
265 $step=9;
266 }
267 $n = round(count($pmin)/$step);
268 $i = 0;
269 $this->img->SetColor($this->gridmajor_color);
270 $limit = max($this->img->plotwidth,$this->img->plotheight)*1.4 ;
271 $off = $r;
272 $i=0;
273 $r = $pmin[$i*$step];
274 while( $r < $limit && $i < $n ) {
275 $r = $pmin[$i*$step];
276 $this->img->Circle($x,$pos,$r);
277 $i++;
278 }
279 }
280
281 // Draw angles
282 if( $this->show_angle_grid ) {
283 $this->img->SetColor($this->angle_color);
284 $d = max($this->img->plotheight,$this->img->plotwidth)*1.4 ;
285 $a = 0;
286 $p = $this->scale->ticks->ticks_pos;
287 $start_radius = $p[1]-$x;
288 while( $a < 360 ) {
289 if( $a == 90 || $a == 270 ) {
290 // Make sure there are no rounding problem with
291 // exactly vertical lines
292 $this->img->Line($x+$start_radius*cos($a/180*M_PI)+1,
293 $pos-$start_radius*sin($a/180*M_PI),
294 $x+$start_radius*cos($a/180*M_PI)+1,
295 $pos-$d*sin($a/180*M_PI));
296
297 }
298 else {
299 $this->img->Line($x+$start_radius*cos($a/180*M_PI)+1,
300 $pos-$start_radius*sin($a/180*M_PI),
301 $x+$d*cos($a/180*M_PI),
302 $pos-$d*sin($a/180*M_PI));
303 }
304 $a += $this->angle_step;
305 }
306 }
307 }
308
309 function StrokeAngleLabels($pos,$type) {
310
311 if( !$this->show_angle_label )
312 return;
313
314 $x0 = round($this->img->left_margin+$this->img->plotwidth/2)+1;
315
316 $d = max($this->img->plotwidth,$this->img->plotheight)*1.42;
317 $a = $this->angle_step;
318 $t = new Text();
319 $t->SetColor($this->angle_fontcolor);
320 $t->SetFont($this->angle_fontfam,$this->angle_fontstyle,$this->angle_fontsize);
321 $xright = $this->img->width - $this->img->right_margin;
322 $ytop = $this->img->top_margin;
323 $xleft = $this->img->left_margin;
324 $ybottom = $this->img->height - $this->img->bottom_margin;
325 $ha = 'left';
326 $va = 'center';
327 $w = $this->img->plotwidth/2;
328 $h = $this->img->plotheight/2;
329 $xt = $x0; $yt = $pos;
330 $margin=5;
331
332 $tl = $this->angle_tick_len ; // Outer len
333 $tl2 = $this->angle_tick_len2 ; // Interior len
334
335 $this->img->SetColor($this->angle_tick_color);
336 $rot90 = $this->img->a == 90 ;
337
338 if( $type == POLAR_360 ) {
339 $ca1 = atan($h/$w)/M_PI*180;
340 $ca2 = 180-$ca1;
341 $ca3 = $ca1+180;
342 $ca4 = 360-$ca1;
343 $end = 360;
344 while( $a < $end ) {
345 $ca = cos($a/180*M_PI);
346 $sa = sin($a/180*M_PI);
347 $x = $d*$ca;
348 $y = $d*$sa;
349 $xt=1000;$yt=1000;
350 if( $a <= $ca1 || $a >= $ca4 ) {
351 $yt = $pos - $w * $y/$x;
352 $xt = $xright + $margin;
353 if( $rot90 ) {
354 $ha = 'center';
355 $va = 'top';
356 }
357 else {
358 $ha = 'left';
359 $va = 'center';
360 }
361 $x1=$xright-$tl2; $x2=$xright+$tl;
362 $y1=$y2=$yt;
363 }
364 elseif( $a > $ca1 && $a < $ca2 ) {
365 $xt = $x0 + $h * $x/$y;
366 $yt = $ytop - $margin;
367 if( $rot90 ) {
368 $ha = 'left';
369 $va = 'center';
370 }
371 else {
372 $ha = 'center';
373 $va = 'bottom';
374 }
375 $y1=$ytop+$tl2;$y2=$ytop-$tl;
376 $x1=$x2=$xt;
377 }
378 elseif( $a >= $ca2 && $a <= $ca3 ) {
379 $yt = $pos + $w * $y/$x;
380 $xt = $xleft - $margin;
381 if( $rot90 ) {
382 $ha = 'center';
383 $va = 'bottom';
384 }
385 else {
386 $ha = 'right';
387 $va = 'center';
388 }
389 $x1=$xleft+$tl2;$x2=$xleft-$tl;
390 $y1=$y2=$yt;
391 }
392 else {
393 $xt = $x0 - $h * $x/$y;
394 $yt = $ybottom + $margin;
395 if( $rot90 ) {
396 $ha = 'right';
397 $va = 'center';
398 }
399 else {
400 $ha = 'center';
401 $va = 'top';
402 }
403 $y1=$ybottom-$tl2;$y2=$ybottom+$tl;
404 $x1=$x2=$xt;
405 }
406 if( $a != 0 && $a != 180 ) {
407 $t->Align($ha,$va);
408 if( $this->show_angle_mark )
409 $a .= '°';
410 $t->Set($a);
411 $t->Stroke($this->img,$xt,$yt);
412 if( $this->show_angle_tick )
413 $this->img->Line($x1,$y1,$x2,$y2);
414 }
415 $a += $this->angle_step;
416 }
417 }
418 else {
419 // POLAR_HALF
420 $ca1 = atan($h/$w*2)/M_PI*180;
421 $ca2 = 180-$ca1;
422 $end = 180;
423 while( $a < $end ) {
424 $ca = cos($a/180*M_PI);
425 $sa = sin($a/180*M_PI);
426 $x = $d*$ca;
427 $y = $d*$sa;
428 if( $a <= $ca1 ) {
429 $yt = $pos - $w * $y/$x;
430 $xt = $xright + $margin;
431 if( $rot90 ) {
432 $ha = 'center';
433 $va = 'top';
434 }
435 else {
436 $ha = 'left';
437 $va = 'center';
438 }
439 $x1=$xright-$tl2; $x2=$xright+$tl;
440 $y1=$y2=$yt;
441 }
442 elseif( $a > $ca1 && $a < $ca2 ) {
443 $xt = $x0 + 2*$h * $x/$y;
444 $yt = $ytop - $margin;
445 if( $rot90 ) {
446 $ha = 'left';
447 $va = 'center';
448 }
449 else {
450 $ha = 'center';
451 $va = 'bottom';
452 }
453 $y1=$ytop+$tl2;$y2=$ytop-$tl;
454 $x1=$x2=$xt;
455 }
456 elseif( $a >= $ca2 ) {
457 $yt = $pos + $w * $y/$x;
458 $xt = $xleft - $margin;
459 if( $rot90 ) {
460 $ha = 'center';
461 $va = 'bottom';
462 }
463 else {
464 $ha = 'right';
465 $va = 'center';
466 }
467 $x1=$xleft+$tl2;$x2=$xleft-$tl;
468 $y1=$y2=$yt;
469 }
470 $t->Align($ha,$va);
471 if( $this->show_angle_mark )
472 $a .= '°';
473 $t->Set($a);
474 $t->Stroke($this->img,$xt,$yt);
475 if( $this->show_angle_tick )
476 $this->img->Line($x1,$y1,$x2,$y2);
477 $a += $this->angle_step;
478 }
479 }
480 }
481
482 function Stroke($pos,$dummy=true) {
483
484 $this->img->SetLineWeight($this->weight);
485 $this->img->SetColor($this->color);
486 $this->img->SetFont($this->font_family,$this->font_style,$this->font_size);
487 if( !$this->hide_line )
488 $this->img->FilledRectangle($this->img->left_margin,$pos,
489 $this->img->width-$this->img->right_margin,$pos+$this->weight-1);
490 $y=$pos+$this->img->GetFontHeight()+$this->title_margin+$this->title->margin;
491 if( $this->title_adjust=="high" )
492 $this->title->SetPos($this->img->width-$this->img->right_margin,$y,"right","top");
493 elseif( $this->title_adjust=="middle" || $this->title_adjust=="center" )
494 $this->title->SetPos(($this->img->width-$this->img->left_margin-
495 $this->img->right_margin)/2+$this->img->left_margin,
496 $y,"center","top");
497 elseif($this->title_adjust=="low")
498 $this->title->SetPos($this->img->left_margin,$y,"left","top");
499 else {
500 JpGraphError::RaiseL(17002,$this->title_adjust);
501//('Unknown alignment specified for X-axis title. ('.$this->title_adjust.')');
502 }
503
504
505 if (!$this->hide_labels) {
506 $this->StrokeLabels($pos,false);
507 }
508 $this->img->SetColor($this->radius_tick_color);
509 $this->scale->ticks->Stroke($this->img,$this->scale,$pos);
510
511 //
512 // Mirror the positions for the left side of the scale
513 //
514 $mid = 2*($this->img->left_margin+$this->img->plotwidth/2);
515 $n = count($this->scale->ticks->ticks_pos);
516 $i=0;
517 while( $i < $n ) {
518 $this->scale->ticks->ticks_pos[$i] =
519 $mid-$this->scale->ticks->ticks_pos[$i] ;
520 ++$i;
521 }
522
523 $n = count($this->scale->ticks->maj_ticks_pos);
524 $i=0;
525 while( $i < $n ) {
526 $this->scale->ticks->maj_ticks_pos[$i] =
527 $mid-$this->scale->ticks->maj_ticks_pos[$i] ;
528 ++$i;
529 }
530
531 $n = count($this->scale->ticks->maj_ticklabels_pos);
532 $i=1;
533 while( $i < $n ) {
534 $this->scale->ticks->maj_ticklabels_pos[$i] =
535 $mid-$this->scale->ticks->maj_ticklabels_pos[$i] ;
536 ++$i;
537 }
538
539 // Draw the left side of the scale
540 $n = count($this->scale->ticks->ticks_pos);
541 $yu = $pos - $this->scale->ticks->direction*$this->scale->ticks->GetMinTickAbsSize();
542
543
544 // Minor ticks
545 if( ! $this->scale->ticks->supress_minor_tickmarks ) {
546 $i=1;
547 while( $i < $n/2 ) {
548 $x = round($this->scale->ticks->ticks_pos[$i]) ;
549 $this->img->Line($x,$pos,$x,$yu);
550 ++$i;
551 }
552 }
553
554 $n = count($this->scale->ticks->maj_ticks_pos);
555 $yu = $pos - $this->scale->ticks->direction*$this->scale->ticks->GetMajTickAbsSize();
556
557
558 // Major ticks
559 if( ! $this->scale->ticks->supress_tickmarks ) {
560 $i=1;
561 while( $i < $n/2 ) {
562 $x = round($this->scale->ticks->maj_ticks_pos[$i]) ;
563 $this->img->Line($x,$pos,$x,$yu);
564 ++$i;
565 }
566 }
567 if (!$this->hide_labels) {
568 $this->StrokeLabels($pos,false);
569 }
570 $this->title->Stroke($this->img);
571 }
572}
573
574class PolarScale extends LinearScale {
575 private $graph;
576
577 function PolarScale($aMax=0,$graph) {
578 parent::LinearScale(0,$aMax,'x');
579 $this->graph = $graph;
580 }
581
582 function _Translate($v) {
583 return parent::Translate($v);
584 }
585
586 function PTranslate($aAngle,$aRad) {
587
588 $m = $this->scale[1];
589 $w = $this->graph->img->plotwidth/2;
590 $aRad = $aRad/$m*$w;
591
592 $x = cos( $aAngle/180 * M_PI ) * $aRad;
593 $y = sin( $aAngle/180 * M_PI ) * $aRad;
594
595 $x += $this->_Translate(0);
596
597 if( $this->graph->iType == POLAR_360 ) {
598 $y = ($this->graph->img->top_margin + $this->graph->img->plotheight/2) - $y;
599 }
600 else {
601 $y = ($this->graph->img->top_margin + $this->graph->img->plotheight) - $y;
602 }
603 return array($x,$y);
604 }
605}
606
607class PolarLogScale extends LogScale {
608 private $graph;
609 function PolarLogScale($aMax=1,$graph) {
610 parent::LogScale(0,$aMax,'x');
611 $this->graph = $graph;
612 $this->ticks->SetLabelLogType(LOGLABELS_MAGNITUDE);
613
614 }
615
616 function PTranslate($aAngle,$aRad) {
617
618 if( $aRad == 0 )
619 $aRad = 1;
620 $aRad = log10($aRad);
621 $m = $this->scale[1];
622 $w = $this->graph->img->plotwidth/2;
623 $aRad = $aRad/$m*$w;
624
625 $x = cos( $aAngle/180 * M_PI ) * $aRad;
626 $y = sin( $aAngle/180 * M_PI ) * $aRad;
627
628 $x += $w+$this->graph->img->left_margin;//$this->_Translate(0);
629 if( $this->graph->iType == POLAR_360 ) {
630 $y = ($this->graph->img->top_margin + $this->graph->img->plotheight/2) - $y;
631 }
632 else {
633 $y = ($this->graph->img->top_margin + $this->graph->img->plotheight) - $y;
634 }
635 return array($x,$y);
636 }
637}
638
639class PolarGraph extends Graph {
640 public $scale;
641 public $axis;
642 public $iType=POLAR_360;
643
644 function PolarGraph($aWidth=300,$aHeight=200,$aCachedName="",$aTimeOut=0,$aInline=true) {
645 parent::Graph($aWidth,$aHeight,$aCachedName,$aTimeOut,$aInline) ;
646 $this->SetDensity(TICKD_DENSE);
647 $this->SetBox();
648 $this->SetMarginColor('white');
649 }
650
651 function SetDensity($aDense) {
652 $this->SetTickDensity(TICKD_NORMAL,$aDense);
653 }
654
655 function Set90AndMargin($lm=0,$rm=0,$tm=0,$bm=0) {
656 $adj = ($this->img->height - $this->img->width)/2;
657 $this->SetAngle(90);
658 $this->img->SetMargin($lm-$adj,$rm-$adj,$tm+$adj,$bm+$adj);
659 $this->img->SetCenter(floor($this->img->width/2),floor($this->img->height/2));
660 $this->axis->SetLabelAlign('right','center');
661 //JpGraphError::Raise('Set90AndMargin() is not supported for polar graphs.');
662 }
663
664 function SetScale($aScale,$rmax=0,$dummy1=1,$dummy2=1,$dummy3=1) {
665 if( $aScale == 'lin' )
666 $this->scale = new PolarScale($rmax,$this);
667 elseif( $aScale == 'log' ) {
668 $this->scale = new PolarLogScale($rmax,$this);
669 }
670 else {
671 JpGraphError::RaiseL(17004);//('Unknown scale type for polar graph. Must be "lin" or "log"');
672 }
673
674 $this->axis = new PolarAxis($this->img,$this->scale);
675 $this->SetMargin(40,40,50,40);
676 }
677
678 function SetType($aType) {
679 $this->iType = $aType;
680 }
681
682 function SetPlotSize($w,$h) {
683 $this->SetMargin(($this->img->width-$w)/2,($this->img->width-$w)/2,
684 ($this->img->height-$h)/2,($this->img->height-$h)/2);
685 }
686
687 // Private methods
688 function GetPlotsMax() {
689 $n = count($this->plots);
690 $m = $this->plots[0]->Max();
691 $i=1;
692 while($i < $n) {
693 $m = max($this->plots[$i]->Max(),$m);
694 ++$i;
695 }
696 return $m;
697 }
698
699 function Stroke($aStrokeFileName="") {
700
701 // Start by adjusting the margin so that potential titles will fit.
702 $this->AdjustMarginsForTitles();
703
704 // If the filename is the predefined value = '_csim_special_'
705 // we assume that the call to stroke only needs to do enough
706 // to correctly generate the CSIM maps.
707 // We use this variable to skip things we don't strictly need
708 // to do to generate the image map to improve performance
709 // a best we can. Therefor you will see a lot of tests !$_csim in the
710 // code below.
711 $_csim = ($aStrokeFileName===_CSIM_SPECIALFILE);
712
713 // We need to know if we have stroked the plot in the
714 // GetCSIMareas. Otherwise the CSIM hasn't been generated
715 // and in the case of GetCSIM called before stroke to generate
716 // CSIM without storing an image to disk GetCSIM must call Stroke.
717 $this->iHasStroked = true;
718
719 //Check if we should autoscale axis
720 if( !$this->scale->IsSpecified() && count($this->plots)>0 ) {
721 $max = $this->GetPlotsMax();
722 $t1 = $this->img->plotwidth;
723 $this->img->plotwidth /= 2;
724 $t2 = $this->img->left_margin;
725 $this->img->left_margin += $this->img->plotwidth+1;
726 $this->scale->AutoScale($this->img,0,$max,
727 $this->img->plotwidth/$this->xtick_factor/2);
728 $this->img->plotwidth = $t1;
729 $this->img->left_margin = $t2;
730 }
731 else {
732 // The tick calculation will use the user suplied min/max values to determine
733 // the ticks. If auto_ticks is false the exact user specifed min and max
734 // values will be used for the scale.
735 // If auto_ticks is true then the scale might be slightly adjusted
736 // so that the min and max values falls on an even major step.
737 //$min = 0;
738 $max = $this->scale->scale[1];
739 $t1 = $this->img->plotwidth;
740 $this->img->plotwidth /= 2;
741 $t2 = $this->img->left_margin;
742 $this->img->left_margin += $this->img->plotwidth+1;
743 $this->scale->AutoScale($this->img,0,$max,
744 $this->img->plotwidth/$this->xtick_factor/2);
745 $this->img->plotwidth = $t1;
746 $this->img->left_margin = $t2;
747 }
748
749 if( $this->iType == POLAR_180 )
750 $pos = $this->img->height - $this->img->bottom_margin;
751 else
752 $pos = $this->img->plotheight/2 + $this->img->top_margin;
753
754
755 if( !$_csim ) {
756 $this->StrokePlotArea();
757 }
758
759 $this->iDoClipping = true;
760
761 if( $this->iDoClipping ) {
762 $oldimage = $this->img->CloneCanvasH();
763 }
764
765 if( !$_csim ) {
766 $this->axis->StrokeGrid($pos);
767 }
768
769 // Stroke all plots for Y1 axis
770 for($i=0; $i < count($this->plots); ++$i) {
771 $this->plots[$i]->Stroke($this->img,$this->scale);
772 }
773
774
775 if( $this->iDoClipping ) {
776 // Clipping only supports graphs at 0 and 90 degrees
777 if( $this->img->a == 0 ) {
778 $this->img->CopyCanvasH($oldimage,$this->img->img,
779 $this->img->left_margin,$this->img->top_margin,
780 $this->img->left_margin,$this->img->top_margin,
781 $this->img->plotwidth+1,$this->img->plotheight+1);
782 }
783 elseif( $this->img->a == 90 ) {
784 $adj = round(($this->img->height - $this->img->width)/2);
785 $this->img->CopyCanvasH($oldimage,$this->img->img,
786 $this->img->bottom_margin-$adj,$this->img->left_margin+$adj,
787 $this->img->bottom_margin-$adj,$this->img->left_margin+$adj,
788 $this->img->plotheight,$this->img->plotwidth);
789 }
790 $this->img->Destroy();
791 $this->img->SetCanvasH($oldimage);
792 }
793
794 if( !$_csim ) {
795 $this->axis->Stroke($pos);
796 $this->axis->StrokeAngleLabels($pos,$this->iType);
797 }
798
799 if( !$_csim ) {
800 $this->StrokePlotBox();
801 $this->footer->Stroke($this->img);
802
803 // The titles and legends never gets rotated so make sure
804 // that the angle is 0 before stroking them
805 $aa = $this->img->SetAngle(0);
806 $this->StrokeTitles();
807 }
808
809 for($i=0; $i < count($this->plots) ; ++$i ) {
810 $this->plots[$i]->Legend($this);
811 }
812
813 $this->legend->Stroke($this->img);
814
815 if( !$_csim ) {
816
817 $this->StrokeTexts();
818 $this->img->SetAngle($aa);
819
820 // Draw an outline around the image map
821 if(_JPG_DEBUG)
822 $this->DisplayClientSideaImageMapAreas();
823
824 // If the filename is given as the special "__handle"
825 // then the image handler is returned and the image is NOT
826 // streamed back
827 if( $aStrokeFileName == _IMG_HANDLER ) {
828 return $this->img->img;
829 }
830 else {
831 // Finally stream the generated picture
832 $this->cache->PutAndStream($this->img,$this->cache_name,$this->inline,
833 $aStrokeFileName);
834 }
835 }
836 }
837}
838
839
840
841?>
Note: See TracBrowser for help on using the repository browser.