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

Last change on this file since 388 was 284, checked in by roby, 6 years ago
File size: 29.8 KB
Line 
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 1796 2009-09-07 09:37:19Z ljp $
7 //
8 // Copyright (c) Asial Corporation. 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 __construct($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
135 ++$i;
136 }
137
138 if( $this->iFillColor != '' ) {
139 $img->SetColor($this->iFillColor);
140 $img->FilledPolygon($p);
141 }
142 $img->SetLineWeight($this->iLineWeight);
143 $img->SetColor($this->iColor);
144 $img->Polygon($p,$this->iFillColor!='');
145 }
146}
147
148//--------------------------------------------------------------------------
149// class PolarAxis
150//--------------------------------------------------------------------------
151class PolarAxis extends Axis {
152 private $angle_step=15,$angle_color='lightgray',$angle_label_color='black';
153 private $angle_fontfam=FF_FONT1,$angle_fontstyle=FS_NORMAL,$angle_fontsize=10;
154 private $angle_fontcolor = 'navy';
155 private $gridminor_color='lightgray',$gridmajor_color='lightgray';
156 private $show_minor_grid = false, $show_major_grid = true ;
157 private $show_angle_mark=true, $show_angle_grid=true, $show_angle_label=true;
158 private $angle_tick_len=3, $angle_tick_len2=3, $angle_tick_color='black';
159 private $show_angle_tick=true;
160 private $radius_tick_color='black';
161
162 function __construct($img,$aScale) {
163 parent::__construct($img,$aScale);
164 }
165
166 function ShowAngleDegreeMark($aFlg=true) {
167 $this->show_angle_mark = $aFlg;
168 }
169
170 function SetAngleStep($aStep) {
171 $this->angle_step=$aStep;
172 }
173
174 function HideTicks($aFlg=true,$aAngleFlg=true) {
175 parent::HideTicks($aFlg,$aFlg);
176 $this->show_angle_tick = !$aAngleFlg;
177 }
178
179 function ShowAngleLabel($aFlg=true) {
180 $this->show_angle_label = $aFlg;
181 }
182
183 function ShowGrid($aMajor=true,$aMinor=false,$aAngle=true) {
184 $this->show_minor_grid = $aMinor;
185 $this->show_major_grid = $aMajor;
186 $this->show_angle_grid = $aAngle ;
187 }
188
189 function SetAngleFont($aFontFam,$aFontStyle=FS_NORMAL,$aFontSize=10) {
190 $this->angle_fontfam = $aFontFam;
191 $this->angle_fontstyle = $aFontStyle;
192 $this->angle_fontsize = $aFontSize;
193 }
194
195 function SetColor($aColor,$aRadColor='',$aAngleColor='') {
196 if( $aAngleColor == '' )
197 $aAngleColor=$aColor;
198 parent::SetColor($aColor,$aRadColor);
199 $this->angle_fontcolor = $aAngleColor;
200 }
201
202 function SetGridColor($aMajorColor,$aMinorColor='',$aAngleColor='') {
203 if( $aMinorColor == '' )
204 $aMinorColor = $aMajorColor;
205 if( $aAngleColor == '' )
206 $aAngleColor = $aMajorColor;
207
208 $this->gridminor_color = $aMinorColor;
209 $this->gridmajor_color = $aMajorColor;
210 $this->angle_color = $aAngleColor;
211 }
212
213 function SetTickColors($aRadColor,$aAngleColor='') {
214 $this->radius_tick_color = $aRadColor;
215 $this->angle_tick_color = $aAngleColor;
216 }
217
218 // Private methods
219 function StrokeGrid($pos) {
220 $x = round($this->img->left_margin + $this->img->plotwidth/2);
221 $this->scale->ticks->Stroke($this->img,$this->scale,$pos);
222
223 // Stroke the minor arcs
224 $pmin = array();
225 $p = $this->scale->ticks->ticks_pos;
226 $n = count($p);
227 $i = 0;
228 $this->img->SetColor($this->gridminor_color);
229 while( $i < $n ) {
230 $r = $p[$i]-$x+1;
231 $pmin[]=$r;
232 if( $this->show_minor_grid ) {
233 $this->img->Circle($x,$pos,$r);
234 }
235 $i++;
236 }
237
238 $limit = max($this->img->plotwidth,$this->img->plotheight)*1.4 ;
239 while( $r < $limit ) {
240 $off = $r;
241 $i=1;
242 $r = $off + round($p[$i]-$x+1);
243 while( $r < $limit && $i < $n ) {
244 $r = $off+$p[$i]-$x;
245 $pmin[]=$r;
246 if( $this->show_minor_grid ) {
247 $this->img->Circle($x,$pos,$r);
248 }
249 $i++;
250 }
251 }
252
253 // Stroke the major arcs
254 if( $this->show_major_grid ) {
255 // First determine how many minor step on
256 // every major step. We have recorded the minor radius
257 // in pmin and use these values. This is done in order
258 // to avoid rounding errors if we were to recalculate the
259 // different major radius.
260 $pmaj = $this->scale->ticks->maj_ticks_pos;
261 $p = $this->scale->ticks->ticks_pos;
262 if( $this->scale->name == 'lin' ) {
263 $step=round(($pmaj[1] - $pmaj[0])/($p[1] - $p[0]));
264 }
265 else {
266 $step=9;
267 }
268 $n = round(count($pmin)/$step);
269 $i = 0;
270 $this->img->SetColor($this->gridmajor_color);
271 $limit = max($this->img->plotwidth,$this->img->plotheight)*1.4 ;
272 $off = $r;
273 $i=0;
274 $r = $pmin[$i*$step];
275 while( $r < $limit && $i < $n ) {
276 $r = $pmin[$i*$step];
277 $this->img->Circle($x,$pos,$r);
278 $i++;
279 }
280 }
281
282 // Draw angles
283 if( $this->show_angle_grid ) {
284 $this->img->SetColor($this->angle_color);
285 $d = max($this->img->plotheight,$this->img->plotwidth)*1.4 ;
286 $a = 0;
287 $p = $this->scale->ticks->ticks_pos;
288 $start_radius = $p[1]-$x;
289 while( $a < 360 ) {
290 if( $a == 90 || $a == 270 ) {
291 // Make sure there are no rounding problem with
292 // exactly vertical lines
293 $this->img->Line($x+$start_radius*cos($a/180*M_PI)+1,
294 $pos-$start_radius*sin($a/180*M_PI),
295 $x+$start_radius*cos($a/180*M_PI)+1,
296 $pos-$d*sin($a/180*M_PI));
297
298 }
299 else {
300 $this->img->Line($x+$start_radius*cos($a/180*M_PI)+1,
301 $pos-$start_radius*sin($a/180*M_PI),
302 $x+$d*cos($a/180*M_PI),
303 $pos-$d*sin($a/180*M_PI));
304 }
305 $a += $this->angle_step;
306 }
307 }
308 }
309
310 function StrokeAngleLabels($pos,$type) {
311
312 if( !$this->show_angle_label )
313 return;
314
315 $x0 = round($this->img->left_margin+$this->img->plotwidth/2)+1;
316
317 $d = max($this->img->plotwidth,$this->img->plotheight)*1.42;
318 $a = $this->angle_step;
319 $t = new Text();
320 $t->SetColor($this->angle_fontcolor);
321 $t->SetFont($this->angle_fontfam,$this->angle_fontstyle,$this->angle_fontsize);
322 $xright = $this->img->width - $this->img->right_margin;
323 $ytop = $this->img->top_margin;
324 $xleft = $this->img->left_margin;
325 $ybottom = $this->img->height - $this->img->bottom_margin;
326 $ha = 'left';
327 $va = 'center';
328 $w = $this->img->plotwidth/2;
329 $h = $this->img->plotheight/2;
330 $xt = $x0; $yt = $pos;
331 $margin=5;
332
333 $tl = $this->angle_tick_len ; // Outer len
334 $tl2 = $this->angle_tick_len2 ; // Interior len
335
336 $this->img->SetColor($this->angle_tick_color);
337 $rot90 = $this->img->a == 90 ;
338
339 if( $type == POLAR_360 ) {
340
341 // Corner angles of the four corners
342 $ca1 = atan($h/$w)/M_PI*180;
343 $ca2 = 180-$ca1;
344 $ca3 = $ca1+180;
345 $ca4 = 360-$ca1;
346 $end = 360;
347
348 while( $a < $end ) {
349 $ca = cos($a/180*M_PI);
350 $sa = sin($a/180*M_PI);
351 $x = $d*$ca;
352 $y = $d*$sa;
353 $xt=1000;$yt=1000;
354 if( $a <= $ca1 || $a >= $ca4 ) {
355 $yt = $pos - $w * $y/$x;
356 $xt = $xright + $margin;
357 if( $rot90 ) {
358 $ha = 'center';
359 $va = 'top';
360 }
361 else {
362 $ha = 'left';
363 $va = 'center';
364 }
365 $x1=$xright-$tl2; $x2=$xright+$tl;
366 $y1=$y2=$yt;
367 }
368 elseif( $a > $ca1 && $a < $ca2 ) {
369 $xt = $x0 + $h * $x/$y;
370 $yt = $ytop - $margin;
371 if( $rot90 ) {
372 $ha = 'left';
373 $va = 'center';
374 }
375 else {
376 $ha = 'center';
377 $va = 'bottom';
378 }
379 $y1=$ytop+$tl2;$y2=$ytop-$tl;
380 $x1=$x2=$xt;
381 }
382 elseif( $a >= $ca2 && $a <= $ca3 ) {
383 $yt = $pos + $w * $y/$x;
384 $xt = $xleft - $margin;
385 if( $rot90 ) {
386 $ha = 'center';
387 $va = 'bottom';
388 }
389 else {
390 $ha = 'right';
391 $va = 'center';
392 }
393 $x1=$xleft+$tl2;$x2=$xleft-$tl;
394 $y1=$y2=$yt;
395 }
396 else {
397 $xt = $x0 - $h * $x/$y;
398 $yt = $ybottom + $margin;
399 if( $rot90 ) {
400 $ha = 'right';
401 $va = 'center';
402 }
403 else {
404 $ha = 'center';
405 $va = 'top';
406 }
407 $y1=$ybottom-$tl2;$y2=$ybottom+$tl;
408 $x1=$x2=$xt;
409 }
410 if( $a != 0 && $a != 180 ) {
411 $t->Align($ha,$va);
412 if( $this->scale->clockwise ) {
413 $t->Set(360-$a);
414 }
415 else {
416 $t->Set($a);
417 }
418 if( $this->show_angle_mark && $t->font_family > 4 ) {
419 $a .= SymChar::Get('degree');
420 }
421 $t->Stroke($this->img,$xt,$yt);
422 if( $this->show_angle_tick ) {
423 $this->img->Line($x1,$y1,$x2,$y2);
424 }
425 }
426 $a = (int) $a;
427 $a += $this->angle_step;
428 }
429 }
430 else {
431 // POLAR_HALF
432 $ca1 = atan($h/$w*2)/M_PI*180;
433 $ca2 = 180-$ca1;
434 $end = 180;
435 while( $a < $end ) {
436 $ca = cos($a/180*M_PI);
437 $sa = sin($a/180*M_PI);
438 $x = $d*$ca;
439 $y = $d*$sa;
440 if( $a <= $ca1 ) {
441 $yt = $pos - $w * $y/$x;
442 $xt = $xright + $margin;
443 if( $rot90 ) {
444 $ha = 'center';
445 $va = 'top';
446 }
447 else {
448 $ha = 'left';
449 $va = 'center';
450 }
451 $x1=$xright-$tl2; $x2=$xright+$tl;
452 $y1=$y2=$yt;
453 }
454 elseif( $a > $ca1 && $a < $ca2 ) {
455 $xt = $x0 + 2*$h * $x/$y;
456 $yt = $ytop - $margin;
457 if( $rot90 ) {
458 $ha = 'left';
459 $va = 'center';
460 }
461 else {
462 $ha = 'center';
463 $va = 'bottom';
464 }
465 $y1=$ytop+$tl2;$y2=$ytop-$tl;
466 $x1=$x2=$xt;
467 }
468 elseif( $a >= $ca2 ) {
469 $yt = $pos + $w * $y/$x;
470 $xt = $xleft - $margin;
471 if( $rot90 ) {
472 $ha = 'center';
473 $va = 'bottom';
474 }
475 else {
476 $ha = 'right';
477 $va = 'center';
478 }
479 $x1=$xleft+$tl2;$x2=$xleft-$tl;
480 $y1=$y2=$yt;
481 }
482 $t->Align($ha,$va);
483 if( $this->show_angle_mark && $t->font_family > 4 ) {
484 $a .= SymChar::Get('degree');
485 }
486 $t->Set($a);
487 $t->Stroke($this->img,$xt,$yt);
488 if( $this->show_angle_tick ) {
489 $this->img->Line($x1,$y1,$x2,$y2);
490 }
491 $a = (int) $a;
492 $a += $this->angle_step;
493 }
494 }
495 }
496
497 function Stroke($pos,$dummy=true) {
498
499 $this->img->SetLineWeight($this->weight);
500 $this->img->SetColor($this->color);
501 $this->img->SetFont($this->font_family,$this->font_style,$this->font_size);
502 if( !$this->hide_line ) {
503 $this->img->FilledRectangle($this->img->left_margin,$pos,
504 $this->img->width-$this->img->right_margin,
505 $pos+$this->weight-1);
506 }
507 $y=$pos+$this->img->GetFontHeight()+$this->title_margin+$this->title->margin;
508 if( $this->title_adjust=="high" ) {
509 $this->title->SetPos($this->img->width-$this->img->right_margin,$y,"right","top");
510 }
511 elseif( $this->title_adjust=="middle" || $this->title_adjust=="center" ) {
512 $this->title->SetPos(($this->img->width-$this->img->left_margin-$this->img->right_margin)/2+$this->img->left_margin,
513 $y,"center","top");
514 }
515 elseif($this->title_adjust=="low") {
516 $this->title->SetPos($this->img->left_margin,$y,"left","top");
517 }
518 else {
519 JpGraphError::RaiseL(17002,$this->title_adjust);
520 //('Unknown alignment specified for X-axis title. ('.$this->title_adjust.')');
521 }
522
523
524 if (!$this->hide_labels) {
525 $this->StrokeLabels($pos,false);
526 }
527 $this->img->SetColor($this->radius_tick_color);
528 $this->scale->ticks->Stroke($this->img,$this->scale,$pos);
529
530 //
531 // Mirror the positions for the left side of the scale
532 //
533 $mid = 2*($this->img->left_margin+$this->img->plotwidth/2);
534 $n = count($this->scale->ticks->ticks_pos);
535 $i=0;
536 while( $i < $n ) {
537 $this->scale->ticks->ticks_pos[$i] =
538 $mid-$this->scale->ticks->ticks_pos[$i] ;
539 ++$i;
540 }
541
542 $n = count($this->scale->ticks->maj_ticks_pos);
543 $i=0;
544 while( $i < $n ) {
545 $this->scale->ticks->maj_ticks_pos[$i] =
546 $mid-$this->scale->ticks->maj_ticks_pos[$i] ;
547 ++$i;
548 }
549
550 $n = count($this->scale->ticks->maj_ticklabels_pos);
551 $i=1;
552 while( $i < $n ) {
553 $this->scale->ticks->maj_ticklabels_pos[$i] =
554 $mid-$this->scale->ticks->maj_ticklabels_pos[$i] ;
555 ++$i;
556 }
557
558 // Draw the left side of the scale
559 $n = count($this->scale->ticks->ticks_pos);
560 $yu = $pos - $this->scale->ticks->direction*$this->scale->ticks->GetMinTickAbsSize();
561
562
563 // Minor ticks
564 if( ! $this->scale->ticks->supress_minor_tickmarks ) {
565 $i=1;
566 while( $i < $n/2 ) {
567 $x = round($this->scale->ticks->ticks_pos[$i]) ;
568 $this->img->Line($x,$pos,$x,$yu);
569 ++$i;
570 }
571 }
572
573 $n = count($this->scale->ticks->maj_ticks_pos);
574 $yu = $pos - $this->scale->ticks->direction*$this->scale->ticks->GetMajTickAbsSize();
575
576
577 // Major ticks
578 if( ! $this->scale->ticks->supress_tickmarks ) {
579 $i=1;
580 while( $i < $n/2 ) {
581 $x = round($this->scale->ticks->maj_ticks_pos[$i]) ;
582 $this->img->Line($x,$pos,$x,$yu);
583 ++$i;
584 }
585 }
586 if (!$this->hide_labels) {
587 $this->StrokeLabels($pos,false);
588 }
589 $this->title->Stroke($this->img);
590 }
591}
592
593class PolarScale extends LinearScale {
594 private $graph;
595 public $clockwise=false;
596
597 function __construct($aMax,$graph,$aClockwise) {
598 parent::__construct(0,$aMax,'x');
599 $this->graph = $graph;
600 $this->clockwise = $aClockwise;
601 }
602
603 function SetClockwise($aFlg) {
604 $this->clockwise = $aFlg;
605 }
606
607 function _Translate($v) {
608 return parent::Translate($v);
609 }
610
611 function PTranslate($aAngle,$aRad) {
612
613 $m = $this->scale[1];
614 $w = $this->graph->img->plotwidth/2;
615 $aRad = $aRad/$m*$w;
616
617 $a = $aAngle/180 * M_PI;
618 if( $this->clockwise ) {
619 $a = 2*M_PI-$a;
620 }
621
622 $x = cos($a) * $aRad;
623 $y = sin($a) * $aRad;
624
625 $x += $this->_Translate(0);
626
627 if( $this->graph->iType == POLAR_360 ) {
628 $y = ($this->graph->img->top_margin + $this->graph->img->plotheight/2) - $y;
629 }
630 else {
631 $y = ($this->graph->img->top_margin + $this->graph->img->plotheight) - $y;
632 }
633 return array($x,$y);
634 }
635}
636
637class PolarLogScale extends LogScale {
638 private $graph;
639 public $clockwise=false;
640
641 function __construct($aMax,$graph,$aClockwise=false) {
642 parent::__construct(0,$aMax,'x');
643 $this->graph = $graph;
644 $this->ticks->SetLabelLogType(LOGLABELS_MAGNITUDE);
645 $this->clockwise = $aClockwise;
646
647 }
648
649 function SetClockwise($aFlg) {
650 $this->clockwise = $aFlg;
651 }
652
653 function PTranslate($aAngle,$aRad) {
654
655 if( $aRad == 0 )
656 $aRad = 1;
657 $aRad = log10($aRad);
658 $m = $this->scale[1];
659 $w = $this->graph->img->plotwidth/2;
660 $aRad = $aRad/$m*$w;
661
662 $a = $aAngle/180 * M_PI;
663 if( $this->clockwise ) {
664 $a = 2*M_PI-$a;
665 }
666
667 $x = cos( $a ) * $aRad;
668 $y = sin( $a ) * $aRad;
669
670 $x += $w+$this->graph->img->left_margin;//$this->_Translate(0);
671 if( $this->graph->iType == POLAR_360 ) {
672 $y = ($this->graph->img->top_margin + $this->graph->img->plotheight/2) - $y;
673 }
674 else {
675 $y = ($this->graph->img->top_margin + $this->graph->img->plotheight) - $y;
676 }
677 return array($x,$y);
678 }
679}
680
681class PolarGraph extends Graph {
682 public $scale;
683 public $axis;
684 public $iType=POLAR_360;
685 private $iClockwise=false;
686
687 function __construct($aWidth=300,$aHeight=200,$aCachedName="",$aTimeOut=0,$aInline=true) {
688 parent::__construct($aWidth,$aHeight,$aCachedName,$aTimeOut,$aInline) ;
689 $this->SetDensity(TICKD_DENSE);
690 $this->SetBox();
691 $this->SetMarginColor('white');
692 }
693
694 function SetDensity($aDense) {
695 $this->SetTickDensity(TICKD_NORMAL,$aDense);
696 }
697
698 function SetClockwise($aFlg) {
699 $this->scale->SetClockwise($aFlg);
700 }
701
702 function Set90AndMargin($lm=0,$rm=0,$tm=0,$bm=0) {
703 $adj = ($this->img->height - $this->img->width)/2;
704 $this->SetAngle(90);
705 $lm2 = -$adj + ($lm-$rm+$tm+$bm)/2;
706 $rm2 = -$adj + (-$lm+$rm+$tm+$bm)/2;
707 $tm2 = $adj + ($tm-$bm+$lm+$rm)/2;
708 $bm2 = $adj + (-$tm+$bm+$lm+$rm)/2;
709 $this->SetMargin($lm2, $rm2, $tm2, $bm2);
710 $this->axis->SetLabelAlign('right','center');
711 }
712
713 function SetScale($aScale,$rmax=0,$dummy1=1,$dummy2=1,$dummy3=1) {
714 if( $aScale == 'lin' ) {
715 $this->scale = new PolarScale($rmax,$this,$this->iClockwise);
716 }
717 elseif( $aScale == 'log' ) {
718 $this->scale = new PolarLogScale($rmax,$this,$this->iClockwise);
719 }
720 else {
721 JpGraphError::RaiseL(17004);//('Unknown scale type for polar graph. Must be "lin" or "log"');
722 }
723
724 $this->axis = new PolarAxis($this->img,$this->scale);
725 $this->SetMargin(40,40,50,40);
726 }
727
728 function SetType($aType) {
729 $this->iType = $aType;
730 }
731
732 function SetPlotSize($w,$h) {
733 $this->SetMargin(($this->img->width-$w)/2,($this->img->width-$w)/2,
734 ($this->img->height-$h)/2,($this->img->height-$h)/2);
735 }
736
737 // Private methods
738 function GetPlotsMax() {
739 $n = count($this->plots);
740 $m = $this->plots[0]->Max();
741 $i=1;
742 while($i < $n) {
743 $m = max($this->plots[$i]->Max(),$m);
744 ++$i;
745 }
746 return $m;
747 }
748
749 function Stroke($aStrokeFileName="") {
750
751 // Start by adjusting the margin so that potential titles will fit.
752 $this->AdjustMarginsForTitles();
753
754 // If the filename is the predefined value = '_csim_special_'
755 // we assume that the call to stroke only needs to do enough
756 // to correctly generate the CSIM maps.
757 // We use this variable to skip things we don't strictly need
758 // to do to generate the image map to improve performance
759 // a best we can. Therefor you will see a lot of tests !$_csim in the
760 // code below.
761 $_csim = ($aStrokeFileName===_CSIM_SPECIALFILE);
762
763 // We need to know if we have stroked the plot in the
764 // GetCSIMareas. Otherwise the CSIM hasn't been generated
765 // and in the case of GetCSIM called before stroke to generate
766 // CSIM without storing an image to disk GetCSIM must call Stroke.
767 $this->iHasStroked = true;
768
769 //Check if we should autoscale axis
770 if( !$this->scale->IsSpecified() && count($this->plots)>0 ) {
771 $max = $this->GetPlotsMax();
772 $t1 = $this->img->plotwidth;
773 $this->img->plotwidth /= 2;
774 $t2 = $this->img->left_margin;
775 $this->img->left_margin += $this->img->plotwidth+1;
776 $this->scale->AutoScale($this->img,0,$max,
777 $this->img->plotwidth/$this->xtick_factor/2);
778 $this->img->plotwidth = $t1;
779 $this->img->left_margin = $t2;
780 }
781 else {
782 // The tick calculation will use the user suplied min/max values to determine
783 // the ticks. If auto_ticks is false the exact user specifed min and max
784 // values will be used for the scale.
785 // If auto_ticks is true then the scale might be slightly adjusted
786 // so that the min and max values falls on an even major step.
787 //$min = 0;
788 $max = $this->scale->scale[1];
789 $t1 = $this->img->plotwidth;
790 $this->img->plotwidth /= 2;
791 $t2 = $this->img->left_margin;
792 $this->img->left_margin += $this->img->plotwidth+1;
793 $this->scale->AutoScale($this->img,0,$max,
794 $this->img->plotwidth/$this->xtick_factor/2);
795 $this->img->plotwidth = $t1;
796 $this->img->left_margin = $t2;
797 }
798
799 if( $this->iType == POLAR_180 ) {
800 $pos = $this->img->height - $this->img->bottom_margin;
801 }
802 else {
803 $pos = $this->img->plotheight/2 + $this->img->top_margin;
804 }
805
806 if( !$_csim ) {
807 $this->StrokePlotArea();
808 }
809
810 $this->iDoClipping = true;
811
812 if( $this->iDoClipping ) {
813 $oldimage = $this->img->CloneCanvasH();
814 }
815
816 if( !$_csim ) {
817 $this->axis->StrokeGrid($pos);
818 }
819
820 // Stroke all plots for Y1 axis
821 for($i=0; $i < count($this->plots); ++$i) {
822 $this->plots[$i]->Stroke($this->img,$this->scale);
823 }
824
825
826 if( $this->iDoClipping ) {
827 // Clipping only supports graphs at 0 and 90 degrees
828 if( $this->img->a == 0 ) {
829 $this->img->CopyCanvasH($oldimage,$this->img->img,
830 $this->img->left_margin,$this->img->top_margin,
831 $this->img->left_margin,$this->img->top_margin,
832 $this->img->plotwidth+1,$this->img->plotheight+1);
833 }
834 elseif( $this->img->a == 90 ) {
835 $adj1 = round(($this->img->height - $this->img->width)/2);
836 $adj2 = round(($this->img->width - $this->img->height)/2);
837 $lm = $this->img->left_margin;
838 $rm = $this->img->right_margin;
839 $tm = $this->img->top_margin;
840 $bm = $this->img->bottom_margin;
841 $this->img->CopyCanvasH($oldimage,$this->img->img,
842 $adj2 + round(($lm-$rm+$tm+$bm)/2),
843 $adj1 + round(($tm-$bm+$lm+$rm)/2),
844 $adj2 + round(($lm-$rm+$tm+$bm)/2),
845 $adj1 + round(($tm-$bm+$lm+$rm)/2),
846 $this->img->plotheight+1,
847 $this->img->plotwidth+1);
848 }
849 $this->img->Destroy();
850 $this->img->SetCanvasH($oldimage);
851 }
852
853 if( !$_csim ) {
854 $this->axis->Stroke($pos);
855 $this->axis->StrokeAngleLabels($pos,$this->iType);
856 }
857
858 if( !$_csim ) {
859 $this->StrokePlotBox();
860 $this->footer->Stroke($this->img);
861
862 // The titles and legends never gets rotated so make sure
863 // that the angle is 0 before stroking them
864 $aa = $this->img->SetAngle(0);
865 $this->StrokeTitles();
866 }
867
868 for($i=0; $i < count($this->plots) ; ++$i ) {
869 $this->plots[$i]->Legend($this);
870 }
871
872 $this->legend->Stroke($this->img);
873
874 if( !$_csim ) {
875
876 $this->StrokeTexts();
877 $this->img->SetAngle($aa);
878
879 // Draw an outline around the image map
880 if(_JPG_DEBUG)
881 $this->DisplayClientSideaImageMapAreas();
882
883 // If the filename is given as the special "__handle"
884 // then the image handler is returned and the image is NOT
885 // streamed back
886 if( $aStrokeFileName == _IMG_HANDLER ) {
887 return $this->img->img;
888 }
889 else {
890 // Finally stream the generated picture
891 $this->cache->PutAndStream($this->img,$this->cache_name,$this->inline,$aStrokeFileName);
892 }
893 }
894 }
895}
896
897
898
899?>
Note: See TracBrowser for help on using the repository browser.