1 | <?php |
---|
2 | //======================================================================= |
---|
3 | // File: JPGRAPH_PLOTBAND.PHP |
---|
4 | // Description: PHP4 Graph Plotting library. Extension module. |
---|
5 | // Created: 2004-02-18 |
---|
6 | // Ver: $Id: jpgraph_plotband.php 1106 2009-02-22 20:16:35Z ljp $ |
---|
7 | // |
---|
8 | // Copyright (c) Asial Corporation. All rights reserved. |
---|
9 | //======================================================================== |
---|
10 | |
---|
11 | // Constants for types of static bands in plot area |
---|
12 | define("BAND_RDIAG",1); // Right diagonal lines |
---|
13 | define("BAND_LDIAG",2); // Left diagonal lines |
---|
14 | define("BAND_SOLID",3); // Solid one color |
---|
15 | define("BAND_VLINE",4); // Vertical lines |
---|
16 | define("BAND_HLINE",5); // Horizontal lines |
---|
17 | define("BAND_3DPLANE",6); // "3D" Plane |
---|
18 | define("BAND_HVCROSS",7); // Vertical/Hor crosses |
---|
19 | define("BAND_DIAGCROSS",8); // Diagonal crosses |
---|
20 | |
---|
21 | |
---|
22 | // Utility class to hold coordinates for a rectangle |
---|
23 | class Rectangle { |
---|
24 | public $x,$y,$w,$h; |
---|
25 | public $xe, $ye; |
---|
26 | function __construct($aX,$aY,$aWidth,$aHeight) { |
---|
27 | $this->x=$aX; |
---|
28 | $this->y=$aY; |
---|
29 | $this->w=$aWidth; |
---|
30 | $this->h=$aHeight; |
---|
31 | $this->xe=$aX+$aWidth-1; |
---|
32 | $this->ye=$aY+$aHeight-1; |
---|
33 | } |
---|
34 | } |
---|
35 | |
---|
36 | //===================================================================== |
---|
37 | // Class RectPattern |
---|
38 | // Base class for pattern hierarchi that is used to display patterned |
---|
39 | // bands on the graph. Any subclass that doesn't override Stroke() |
---|
40 | // must at least implement method DoPattern($aImg) which is responsible |
---|
41 | // for drawing the pattern onto the graph. |
---|
42 | //===================================================================== |
---|
43 | class RectPattern { |
---|
44 | protected $color; |
---|
45 | protected $weight; |
---|
46 | protected $rect=null; |
---|
47 | protected $doframe=true; |
---|
48 | protected $linespacing; // Line spacing in pixels |
---|
49 | protected $iBackgroundColor=-1; // Default is no background fill |
---|
50 | |
---|
51 | function __construct($aColor,$aWeight=1) { |
---|
52 | $this->color = $aColor; |
---|
53 | $this->weight = $aWeight; |
---|
54 | } |
---|
55 | |
---|
56 | function SetBackground($aBackgroundColor) { |
---|
57 | $this->iBackgroundColor=$aBackgroundColor; |
---|
58 | } |
---|
59 | |
---|
60 | function SetPos($aRect) { |
---|
61 | $this->rect = $aRect; |
---|
62 | } |
---|
63 | |
---|
64 | function ShowFrame($aShow=true) { |
---|
65 | $this->doframe=$aShow; |
---|
66 | } |
---|
67 | |
---|
68 | function SetDensity($aDens) { |
---|
69 | if( $aDens < 1 || $aDens > 100 ) |
---|
70 | JpGraphError::RaiseL(16001,$aDens); |
---|
71 | //(" Desity for pattern must be between 1 and 100. (You tried $aDens)"); |
---|
72 | // 1% corresponds to linespacing=50 |
---|
73 | // 100 % corresponds to linespacing 1 |
---|
74 | $this->linespacing = floor(((100-$aDens)/100.0)*50)+1; |
---|
75 | |
---|
76 | } |
---|
77 | |
---|
78 | function Stroke($aImg) { |
---|
79 | if( $this->rect == null ) |
---|
80 | JpGraphError::RaiseL(16002); |
---|
81 | //(" No positions specified for pattern."); |
---|
82 | |
---|
83 | if( !(is_numeric($this->iBackgroundColor) && $this->iBackgroundColor==-1) ) { |
---|
84 | $aImg->SetColor($this->iBackgroundColor); |
---|
85 | $aImg->FilledRectangle($this->rect->x,$this->rect->y,$this->rect->xe,$this->rect->ye); |
---|
86 | } |
---|
87 | |
---|
88 | $aImg->SetColor($this->color); |
---|
89 | $aImg->SetLineWeight($this->weight); |
---|
90 | |
---|
91 | // Virtual function implemented by subclass |
---|
92 | $this->DoPattern($aImg); |
---|
93 | |
---|
94 | // Frame around the pattern area |
---|
95 | if( $this->doframe ) |
---|
96 | $aImg->Rectangle($this->rect->x,$this->rect->y,$this->rect->xe,$this->rect->ye); |
---|
97 | } |
---|
98 | |
---|
99 | } |
---|
100 | |
---|
101 | |
---|
102 | //===================================================================== |
---|
103 | // Class RectPatternSolid |
---|
104 | // Implements a solid band |
---|
105 | //===================================================================== |
---|
106 | class RectPatternSolid extends RectPattern { |
---|
107 | |
---|
108 | function __construct($aColor="black",$aWeight=1) { |
---|
109 | parent::__construct($aColor,$aWeight); |
---|
110 | } |
---|
111 | |
---|
112 | function DoPattern($aImg) { |
---|
113 | $aImg->SetColor($this->color); |
---|
114 | $aImg->FilledRectangle($this->rect->x,$this->rect->y, |
---|
115 | $this->rect->xe,$this->rect->ye); |
---|
116 | } |
---|
117 | } |
---|
118 | |
---|
119 | //===================================================================== |
---|
120 | // Class RectPatternHor |
---|
121 | // Implements horizontal line pattern |
---|
122 | //===================================================================== |
---|
123 | class RectPatternHor extends RectPattern { |
---|
124 | |
---|
125 | function __construct($aColor="black",$aWeight=1,$aLineSpacing=7) { |
---|
126 | parent::__construct($aColor,$aWeight); |
---|
127 | $this->linespacing = $aLineSpacing; |
---|
128 | } |
---|
129 | |
---|
130 | function DoPattern($aImg) { |
---|
131 | $x0 = $this->rect->x; |
---|
132 | $x1 = $this->rect->xe; |
---|
133 | $y = $this->rect->y; |
---|
134 | while( $y < $this->rect->ye ) { |
---|
135 | $aImg->Line($x0,$y,$x1,$y); |
---|
136 | $y += $this->linespacing; |
---|
137 | } |
---|
138 | } |
---|
139 | } |
---|
140 | |
---|
141 | //===================================================================== |
---|
142 | // Class RectPatternVert |
---|
143 | // Implements vertical line pattern |
---|
144 | //===================================================================== |
---|
145 | class RectPatternVert extends RectPattern { |
---|
146 | |
---|
147 | function __construct($aColor="black",$aWeight=1,$aLineSpacing=7) { |
---|
148 | parent::__construct($aColor,$aWeight); |
---|
149 | $this->linespacing = $aLineSpacing; |
---|
150 | } |
---|
151 | |
---|
152 | //-------------------- |
---|
153 | // Private methods |
---|
154 | // |
---|
155 | function DoPattern($aImg) { |
---|
156 | $x = $this->rect->x; |
---|
157 | $y0 = $this->rect->y; |
---|
158 | $y1 = $this->rect->ye; |
---|
159 | while( $x < $this->rect->xe ) { |
---|
160 | $aImg->Line($x,$y0,$x,$y1); |
---|
161 | $x += $this->linespacing; |
---|
162 | } |
---|
163 | } |
---|
164 | } |
---|
165 | |
---|
166 | |
---|
167 | //===================================================================== |
---|
168 | // Class RectPatternRDiag |
---|
169 | // Implements right diagonal pattern |
---|
170 | //===================================================================== |
---|
171 | class RectPatternRDiag extends RectPattern { |
---|
172 | |
---|
173 | function __construct($aColor="black",$aWeight=1,$aLineSpacing=12) { |
---|
174 | parent::__construct($aColor,$aWeight); |
---|
175 | $this->linespacing = $aLineSpacing; |
---|
176 | } |
---|
177 | |
---|
178 | function DoPattern($aImg) { |
---|
179 | // -------------------- |
---|
180 | // | / / / / /| |
---|
181 | // |/ / / / / | |
---|
182 | // | / / / / | |
---|
183 | // -------------------- |
---|
184 | $xe = $this->rect->xe; |
---|
185 | $ye = $this->rect->ye; |
---|
186 | $x0 = $this->rect->x + round($this->linespacing/2); |
---|
187 | $y0 = $this->rect->y; |
---|
188 | $x1 = $this->rect->x; |
---|
189 | $y1 = $this->rect->y + round($this->linespacing/2); |
---|
190 | |
---|
191 | while($x0<=$xe && $y1<=$ye) { |
---|
192 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
193 | $x0 += $this->linespacing; |
---|
194 | $y1 += $this->linespacing; |
---|
195 | } |
---|
196 | |
---|
197 | if( $xe-$x1 > $ye-$y0 ) { |
---|
198 | // Width larger than height |
---|
199 | $x1 = $this->rect->x + ($y1-$ye); |
---|
200 | $y1 = $ye; |
---|
201 | $y0 = $this->rect->y; |
---|
202 | while( $x0 <= $xe ) { |
---|
203 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
204 | $x0 += $this->linespacing; |
---|
205 | $x1 += $this->linespacing; |
---|
206 | } |
---|
207 | |
---|
208 | $y0=$this->rect->y + ($x0-$xe); |
---|
209 | $x0=$xe; |
---|
210 | } |
---|
211 | else { |
---|
212 | // Height larger than width |
---|
213 | $diff = $x0-$xe; |
---|
214 | $y0 = $diff+$this->rect->y; |
---|
215 | $x0 = $xe; |
---|
216 | $x1 = $this->rect->x; |
---|
217 | while( $y1 <= $ye ) { |
---|
218 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
219 | $y1 += $this->linespacing; |
---|
220 | $y0 += $this->linespacing; |
---|
221 | } |
---|
222 | |
---|
223 | $diff = $y1-$ye; |
---|
224 | $y1 = $ye; |
---|
225 | $x1 = $diff + $this->rect->x; |
---|
226 | } |
---|
227 | |
---|
228 | while( $y0 <= $ye ) { |
---|
229 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
230 | $y0 += $this->linespacing; |
---|
231 | $x1 += $this->linespacing; |
---|
232 | } |
---|
233 | } |
---|
234 | } |
---|
235 | |
---|
236 | //===================================================================== |
---|
237 | // Class RectPatternLDiag |
---|
238 | // Implements left diagonal pattern |
---|
239 | //===================================================================== |
---|
240 | class RectPatternLDiag extends RectPattern { |
---|
241 | |
---|
242 | function __construct($aColor="black",$aWeight=1,$aLineSpacing=12) { |
---|
243 | $this->linespacing = $aLineSpacing; |
---|
244 | parent::__construct($aColor,$aWeight); |
---|
245 | } |
---|
246 | |
---|
247 | function DoPattern($aImg) { |
---|
248 | // -------------------- |
---|
249 | // |\ \ \ \ \ | |
---|
250 | // | \ \ \ \ \| |
---|
251 | // | \ \ \ \ | |
---|
252 | // |------------------| |
---|
253 | $xe = $this->rect->xe; |
---|
254 | $ye = $this->rect->ye; |
---|
255 | $x0 = $this->rect->x + round($this->linespacing/2); |
---|
256 | $y0 = $this->rect->ye; |
---|
257 | $x1 = $this->rect->x; |
---|
258 | $y1 = $this->rect->ye - round($this->linespacing/2); |
---|
259 | |
---|
260 | while($x0<=$xe && $y1>=$this->rect->y) { |
---|
261 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
262 | $x0 += $this->linespacing; |
---|
263 | $y1 -= $this->linespacing; |
---|
264 | } |
---|
265 | if( $xe-$x1 > $ye-$this->rect->y ) { |
---|
266 | // Width larger than height |
---|
267 | $x1 = $this->rect->x + ($this->rect->y-$y1); |
---|
268 | $y0=$ye; $y1=$this->rect->y; |
---|
269 | while( $x0 <= $xe ) { |
---|
270 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
271 | $x0 += $this->linespacing; |
---|
272 | $x1 += $this->linespacing; |
---|
273 | } |
---|
274 | |
---|
275 | $y0=$this->rect->ye - ($x0-$xe); |
---|
276 | $x0=$xe; |
---|
277 | } |
---|
278 | else { |
---|
279 | // Height larger than width |
---|
280 | $diff = $x0-$xe; |
---|
281 | $y0 = $ye-$diff; |
---|
282 | $x0 = $xe; |
---|
283 | while( $y1 >= $this->rect->y ) { |
---|
284 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
285 | $y0 -= $this->linespacing; |
---|
286 | $y1 -= $this->linespacing; |
---|
287 | } |
---|
288 | $diff = $this->rect->y - $y1; |
---|
289 | $x1 = $this->rect->x + $diff; |
---|
290 | $y1 = $this->rect->y; |
---|
291 | } |
---|
292 | while( $y0 >= $this->rect->y ) { |
---|
293 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
294 | $y0 -= $this->linespacing; |
---|
295 | $x1 += $this->linespacing; |
---|
296 | } |
---|
297 | } |
---|
298 | } |
---|
299 | |
---|
300 | //===================================================================== |
---|
301 | // Class RectPattern3DPlane |
---|
302 | // Implements "3D" plane pattern |
---|
303 | //===================================================================== |
---|
304 | class RectPattern3DPlane extends RectPattern { |
---|
305 | private $alpha=50; // Parameter that specifies the distance |
---|
306 | // to "simulated" horizon in pixel from the |
---|
307 | // top of the band. Specifies how fast the lines |
---|
308 | // converge. |
---|
309 | |
---|
310 | function __construct($aColor="black",$aWeight=1) { |
---|
311 | parent::__construct($aColor,$aWeight); |
---|
312 | $this->SetDensity(10); // Slightly larger default |
---|
313 | } |
---|
314 | |
---|
315 | function SetHorizon($aHorizon) { |
---|
316 | $this->alpha=$aHorizon; |
---|
317 | } |
---|
318 | |
---|
319 | function DoPattern($aImg) { |
---|
320 | // "Fake" a nice 3D grid-effect. |
---|
321 | $x0 = $this->rect->x + $this->rect->w/2; |
---|
322 | $y0 = $this->rect->y; |
---|
323 | $x1 = $x0; |
---|
324 | $y1 = $this->rect->ye; |
---|
325 | $x0_right = $x0; |
---|
326 | $x1_right = $x1; |
---|
327 | |
---|
328 | // BTW "apa" means monkey in Swedish but is really a shortform for |
---|
329 | // "alpha+a" which was the labels I used on paper when I derived the |
---|
330 | // geometric to get the 3D perspective right. |
---|
331 | // $apa is the height of the bounding rectangle plus the distance to the |
---|
332 | // artifical horizon (alpha) |
---|
333 | $apa = $this->rect->h + $this->alpha; |
---|
334 | |
---|
335 | // Three cases and three loops |
---|
336 | // 1) The endpoint of the line ends on the bottom line |
---|
337 | // 2) The endpoint ends on the side |
---|
338 | // 3) Horizontal lines |
---|
339 | |
---|
340 | // Endpoint falls on bottom line |
---|
341 | $middle=$this->rect->x + $this->rect->w/2; |
---|
342 | $dist=$this->linespacing; |
---|
343 | $factor=$this->alpha /($apa); |
---|
344 | while($x1>$this->rect->x) { |
---|
345 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
346 | $aImg->Line($x0_right,$y0,$x1_right,$y1); |
---|
347 | $x1 = $middle - $dist; |
---|
348 | $x0 = $middle - $dist * $factor; |
---|
349 | $x1_right = $middle + $dist; |
---|
350 | $x0_right = $middle + $dist * $factor; |
---|
351 | $dist += $this->linespacing; |
---|
352 | } |
---|
353 | |
---|
354 | // Endpoint falls on sides |
---|
355 | $dist -= $this->linespacing; |
---|
356 | $d=$this->rect->w/2; |
---|
357 | $c = $apa - $d*$apa/$dist; |
---|
358 | while( $x0>$this->rect->x ) { |
---|
359 | $aImg->Line($x0,$y0,$this->rect->x,$this->rect->ye-$c); |
---|
360 | $aImg->Line($x0_right,$y0,$this->rect->xe,$this->rect->ye-$c); |
---|
361 | $dist += $this->linespacing; |
---|
362 | $x0 = $middle - $dist * $factor; |
---|
363 | $x1 = $middle - $dist; |
---|
364 | $x0_right = $middle + $dist * $factor; |
---|
365 | $c = $apa - $d*$apa/$dist; |
---|
366 | } |
---|
367 | |
---|
368 | // Horizontal lines |
---|
369 | // They need some serious consideration since they are a function |
---|
370 | // of perspective depth (alpha) and density (linespacing) |
---|
371 | $x0=$this->rect->x; |
---|
372 | $x1=$this->rect->xe; |
---|
373 | $y=$this->rect->ye; |
---|
374 | |
---|
375 | // The first line is drawn directly. Makes the loop below slightly |
---|
376 | // more readable. |
---|
377 | $aImg->Line($x0,$y,$x1,$y); |
---|
378 | $hls = $this->linespacing; |
---|
379 | |
---|
380 | // A correction factor for vertical "brick" line spacing to account for |
---|
381 | // a) the difference in number of pixels hor vs vert |
---|
382 | // b) visual apperance to make the first layer of "bricks" look more |
---|
383 | // square. |
---|
384 | $vls = $this->linespacing*0.6; |
---|
385 | |
---|
386 | $ds = $hls*($apa-$vls)/$apa; |
---|
387 | // Get the slope for the "perspective line" going from bottom right |
---|
388 | // corner to top left corner of the "first" brick. |
---|
389 | |
---|
390 | // Uncomment the following lines if you want to get a visual understanding |
---|
391 | // of what this helpline does. BTW this mimics the way you would get the |
---|
392 | // perspective right when drawing on paper. |
---|
393 | /* |
---|
394 | $x0 = $middle; |
---|
395 | $y0 = $this->rect->ye; |
---|
396 | $len=floor(($this->rect->ye-$this->rect->y)/$vls); |
---|
397 | $x1 = $middle+round($len*$ds); |
---|
398 | $y1 = $this->rect->ye-$len*$vls; |
---|
399 | $aImg->PushColor("red"); |
---|
400 | $aImg->Line($x0,$y0,$x1,$y1); |
---|
401 | $aImg->PopColor(); |
---|
402 | */ |
---|
403 | |
---|
404 | $y -= $vls; |
---|
405 | $k=($this->rect->ye-($this->rect->ye-$vls))/($middle-($middle-$ds)); |
---|
406 | $dist = $hls; |
---|
407 | while( $y>$this->rect->y ) { |
---|
408 | $aImg->Line($this->rect->x,$y,$this->rect->xe,$y); |
---|
409 | $adj = $k*$dist/(1+$dist*$k/$apa); |
---|
410 | if( $adj < 2 ) $adj=1; |
---|
411 | $y = $this->rect->ye - round($adj); |
---|
412 | $dist += $hls; |
---|
413 | } |
---|
414 | } |
---|
415 | } |
---|
416 | |
---|
417 | //===================================================================== |
---|
418 | // Class RectPatternCross |
---|
419 | // Vert/Hor crosses |
---|
420 | //===================================================================== |
---|
421 | class RectPatternCross extends RectPattern { |
---|
422 | private $vert=null; |
---|
423 | private $hor=null; |
---|
424 | function __construct($aColor="black",$aWeight=1) { |
---|
425 | parent::__construct($aColor,$aWeight); |
---|
426 | $this->vert = new RectPatternVert($aColor,$aWeight); |
---|
427 | $this->hor = new RectPatternHor($aColor,$aWeight); |
---|
428 | } |
---|
429 | |
---|
430 | function SetOrder($aDepth) { |
---|
431 | $this->vert->SetOrder($aDepth); |
---|
432 | $this->hor->SetOrder($aDepth); |
---|
433 | } |
---|
434 | |
---|
435 | function SetPos($aRect) { |
---|
436 | parent::SetPos($aRect); |
---|
437 | $this->vert->SetPos($aRect); |
---|
438 | $this->hor->SetPos($aRect); |
---|
439 | } |
---|
440 | |
---|
441 | function SetDensity($aDens) { |
---|
442 | $this->vert->SetDensity($aDens); |
---|
443 | $this->hor->SetDensity($aDens); |
---|
444 | } |
---|
445 | |
---|
446 | function DoPattern($aImg) { |
---|
447 | $this->vert->DoPattern($aImg); |
---|
448 | $this->hor->DoPattern($aImg); |
---|
449 | } |
---|
450 | } |
---|
451 | |
---|
452 | //===================================================================== |
---|
453 | // Class RectPatternDiagCross |
---|
454 | // Vert/Hor crosses |
---|
455 | //===================================================================== |
---|
456 | |
---|
457 | class RectPatternDiagCross extends RectPattern { |
---|
458 | private $left=null; |
---|
459 | private $right=null; |
---|
460 | function __construct($aColor="black",$aWeight=1) { |
---|
461 | parent::__construct($aColor,$aWeight); |
---|
462 | $this->right = new RectPatternRDiag($aColor,$aWeight); |
---|
463 | $this->left = new RectPatternLDiag($aColor,$aWeight); |
---|
464 | } |
---|
465 | |
---|
466 | function SetOrder($aDepth) { |
---|
467 | $this->left->SetOrder($aDepth); |
---|
468 | $this->right->SetOrder($aDepth); |
---|
469 | } |
---|
470 | |
---|
471 | function SetPos($aRect) { |
---|
472 | parent::SetPos($aRect); |
---|
473 | $this->left->SetPos($aRect); |
---|
474 | $this->right->SetPos($aRect); |
---|
475 | } |
---|
476 | |
---|
477 | function SetDensity($aDens) { |
---|
478 | $this->left->SetDensity($aDens); |
---|
479 | $this->right->SetDensity($aDens); |
---|
480 | } |
---|
481 | |
---|
482 | function DoPattern($aImg) { |
---|
483 | $this->left->DoPattern($aImg); |
---|
484 | $this->right->DoPattern($aImg); |
---|
485 | } |
---|
486 | |
---|
487 | } |
---|
488 | |
---|
489 | //===================================================================== |
---|
490 | // Class RectPatternFactory |
---|
491 | // Factory class for rectangular pattern |
---|
492 | //===================================================================== |
---|
493 | class RectPatternFactory { |
---|
494 | function __construct() { |
---|
495 | // Empty |
---|
496 | } |
---|
497 | function Create($aPattern,$aColor,$aWeight=1) { |
---|
498 | switch($aPattern) { |
---|
499 | case BAND_RDIAG: |
---|
500 | $obj = new RectPatternRDiag($aColor,$aWeight); |
---|
501 | break; |
---|
502 | case BAND_LDIAG: |
---|
503 | $obj = new RectPatternLDiag($aColor,$aWeight); |
---|
504 | break; |
---|
505 | case BAND_SOLID: |
---|
506 | $obj = new RectPatternSolid($aColor,$aWeight); |
---|
507 | break; |
---|
508 | case BAND_VLINE: |
---|
509 | $obj = new RectPatternVert($aColor,$aWeight); |
---|
510 | break; |
---|
511 | case BAND_HLINE: |
---|
512 | $obj = new RectPatternHor($aColor,$aWeight); |
---|
513 | break; |
---|
514 | case BAND_3DPLANE: |
---|
515 | $obj = new RectPattern3DPlane($aColor,$aWeight); |
---|
516 | break; |
---|
517 | case BAND_HVCROSS: |
---|
518 | $obj = new RectPatternCross($aColor,$aWeight); |
---|
519 | break; |
---|
520 | case BAND_DIAGCROSS: |
---|
521 | $obj = new RectPatternDiagCross($aColor,$aWeight); |
---|
522 | break; |
---|
523 | default: |
---|
524 | JpGraphError::RaiseL(16003,$aPattern); |
---|
525 | //(" Unknown pattern specification ($aPattern)"); |
---|
526 | } |
---|
527 | return $obj; |
---|
528 | } |
---|
529 | } |
---|
530 | |
---|
531 | |
---|
532 | //===================================================================== |
---|
533 | // Class PlotBand |
---|
534 | // Factory class which is used by the client. |
---|
535 | // It is responsible for factoring the corresponding pattern |
---|
536 | // concrete class. |
---|
537 | //===================================================================== |
---|
538 | class PlotBand { |
---|
539 | public $depth; // Determine if band should be over or under the plots |
---|
540 | private $prect=null; |
---|
541 | private $dir, $min, $max; |
---|
542 | |
---|
543 | function __construct($aDir,$aPattern,$aMin,$aMax,$aColor="black",$aWeight=1,$aDepth=DEPTH_BACK) { |
---|
544 | $f = new RectPatternFactory(); |
---|
545 | $this->prect = $f->Create($aPattern,$aColor,$aWeight); |
---|
546 | if( is_numeric($aMin) && is_numeric($aMax) && ($aMin > $aMax) ) |
---|
547 | JpGraphError::RaiseL(16004); |
---|
548 | //('Min value for plotband is larger than specified max value. Please correct.'); |
---|
549 | $this->dir = $aDir; |
---|
550 | $this->min = $aMin; |
---|
551 | $this->max = $aMax; |
---|
552 | $this->depth=$aDepth; |
---|
553 | } |
---|
554 | |
---|
555 | // Set position. aRect contains absolute image coordinates |
---|
556 | function SetPos($aRect) { |
---|
557 | assert( $this->prect != null ) ; |
---|
558 | $this->prect->SetPos($aRect); |
---|
559 | } |
---|
560 | |
---|
561 | function ShowFrame($aFlag=true) { |
---|
562 | $this->prect->ShowFrame($aFlag); |
---|
563 | } |
---|
564 | |
---|
565 | // Set z-order. In front of pplot or in the back |
---|
566 | function SetOrder($aDepth) { |
---|
567 | $this->depth=$aDepth; |
---|
568 | } |
---|
569 | |
---|
570 | function SetDensity($aDens) { |
---|
571 | $this->prect->SetDensity($aDens); |
---|
572 | } |
---|
573 | |
---|
574 | function GetDir() { |
---|
575 | return $this->dir; |
---|
576 | } |
---|
577 | |
---|
578 | function GetMin() { |
---|
579 | return $this->min; |
---|
580 | } |
---|
581 | |
---|
582 | function GetMax() { |
---|
583 | return $this->max; |
---|
584 | } |
---|
585 | |
---|
586 | function PreStrokeAdjust($aGraph) { |
---|
587 | // Nothing to do |
---|
588 | } |
---|
589 | |
---|
590 | // Display band |
---|
591 | function Stroke($aImg,$aXScale,$aYScale) { |
---|
592 | assert( $this->prect != null ) ; |
---|
593 | if( $this->dir == HORIZONTAL ) { |
---|
594 | if( $this->min === 'min' ) $this->min = $aYScale->GetMinVal(); |
---|
595 | if( $this->max === 'max' ) $this->max = $aYScale->GetMaxVal(); |
---|
596 | |
---|
597 | // Only draw the bar if it actually appears in the range |
---|
598 | if ($this->min < $aYScale->GetMaxVal() && $this->max > $aYScale->GetMinVal()) { |
---|
599 | |
---|
600 | // Trucate to limit of axis |
---|
601 | $this->min = max($this->min, $aYScale->GetMinVal()); |
---|
602 | $this->max = min($this->max, $aYScale->GetMaxVal()); |
---|
603 | |
---|
604 | $x=$aXScale->scale_abs[0]; |
---|
605 | $y=$aYScale->Translate($this->max); |
---|
606 | $width=$aXScale->scale_abs[1]-$aXScale->scale_abs[0]+1; |
---|
607 | $height=abs($y-$aYScale->Translate($this->min))+1; |
---|
608 | $this->prect->SetPos(new Rectangle($x,$y,$width,$height)); |
---|
609 | $this->prect->Stroke($aImg); |
---|
610 | } |
---|
611 | } |
---|
612 | else { // VERTICAL |
---|
613 | if( $this->min === 'min' ) $this->min = $aXScale->GetMinVal(); |
---|
614 | if( $this->max === 'max' ) $this->max = $aXScale->GetMaxVal(); |
---|
615 | |
---|
616 | // Only draw the bar if it actually appears in the range |
---|
617 | if ($this->min < $aXScale->GetMaxVal() && $this->max > $aXScale->GetMinVal()) { |
---|
618 | |
---|
619 | // Trucate to limit of axis |
---|
620 | $this->min = max($this->min, $aXScale->GetMinVal()); |
---|
621 | $this->max = min($this->max, $aXScale->GetMaxVal()); |
---|
622 | |
---|
623 | $y=$aYScale->scale_abs[1]; |
---|
624 | $x=$aXScale->Translate($this->min); |
---|
625 | $height=abs($aYScale->scale_abs[1]-$aYScale->scale_abs[0]); |
---|
626 | $width=abs($x-$aXScale->Translate($this->max)); |
---|
627 | $this->prect->SetPos(new Rectangle($x,$y,$width,$height)); |
---|
628 | $this->prect->Stroke($aImg); |
---|
629 | } |
---|
630 | } |
---|
631 | } |
---|
632 | } |
---|
633 | |
---|
634 | |
---|
635 | ?> |
---|