| 98 |
- |
1 |
<?php
|
|
|
2 |
/**
|
|
|
3 |
* PHPlot - A class for creating scientific and business graphs, charts, plots
|
|
|
4 |
*
|
|
|
5 |
* This file contains two PHP classes which are used to create graphs,
|
|
|
6 |
* charts, and plots. The PHPlot class is the basic class which creates
|
|
|
7 |
* indexed-color images, and the extended PHPlot_truecolor class creates
|
|
|
8 |
* full-color (24-bit) images.
|
|
|
9 |
* PHPlot currently requires PHP 5.3 or later.
|
|
|
10 |
*
|
|
|
11 |
* $Id: phplot.php 1774 2015-11-03 00:18:50Z lbayuk $
|
|
|
12 |
*
|
|
|
13 |
* @version 6.2.0
|
|
|
14 |
* @copyright 1998-2015 Afan Ottenheimer
|
|
|
15 |
* @license GNU Lesser General Public License, version 2.1
|
|
|
16 |
* @link http://sourceforge.net/projects/phplot/ PHPlot Web Site with downloads, tracker, discussion
|
|
|
17 |
* @link http://phplot.sourceforge.net PHPlot Project Web Site with links to documentation
|
|
|
18 |
* @author lbayuk (2006-present) <lbayuk@users.sourceforge.net>
|
|
|
19 |
* @author Miguel de Benito Delgado (co-author and maintainer, 2003-2005)
|
|
|
20 |
* @author Afan Ottenheimer (original author)
|
|
|
21 |
*/
|
|
|
22 |
|
|
|
23 |
/*
|
|
|
24 |
* This is free software; you can redistribute it and/or
|
|
|
25 |
* modify it under the terms of the GNU Lesser General Public
|
|
|
26 |
* License as published by the Free Software Foundation;
|
|
|
27 |
* version 2.1 of the License.
|
|
|
28 |
*
|
|
|
29 |
* This software is distributed in the hope that it will be useful,
|
|
|
30 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
31 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
32 |
* Lesser General Public License for more details.
|
|
|
33 |
*
|
|
|
34 |
* You should have received a copy of the GNU Lesser General Public
|
|
|
35 |
* License along with this software; if not, write to the Free Software
|
|
|
36 |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
37 |
* ---------------------------------------------------------------------
|
|
|
38 |
*/
|
|
|
39 |
|
|
|
40 |
/**
|
|
|
41 |
* Class for creating a plot
|
|
|
42 |
*
|
|
|
43 |
* The PHPlot class represents a plot (chart, graph) with all associated
|
|
|
44 |
* parameters. This creates a palette (indexed) color image which is limited
|
|
|
45 |
* to 256 total colors. For truecolor images (24 bit R, G, B), see the
|
|
|
46 |
* PHPlot_truecolor class.
|
|
|
47 |
*
|
|
|
48 |
* In most cases, methods of PHPlot just change the internal properties, and
|
|
|
49 |
* nothing actually happens until the DrawGraph() method is used. Therefore
|
|
|
50 |
* methods can be used in any order up until DrawGraph(); the order should not
|
|
|
51 |
* affect the results.
|
|
|
52 |
*
|
|
|
53 |
* Note: Without a background image, the PHPlot class creates a palette
|
|
|
54 |
* (indexed) color image, and the PHPlot_truecolor class creates a truecolor
|
|
|
55 |
* image. If a background image is used with the constructor of either class,
|
|
|
56 |
* the type of image produced matches the type of the background image.
|
|
|
57 |
*
|
|
|
58 |
*/
|
|
|
59 |
class PHPlot
|
|
|
60 |
{
|
|
|
61 |
/** PHPlot version constant as a string */
|
|
|
62 |
const version = '6.2.0';
|
|
|
63 |
/** PHPlot version constant as a number = major * 10000 + minor * 100 + patch */
|
|
|
64 |
const version_id = 60200;
|
|
|
65 |
|
|
|
66 |
// All class variables are declared here, and initialized (if applicable).
|
|
|
67 |
// Starting with PHPlot-6.0, most variables have 'protected' visibility
|
|
|
68 |
// For more information on these variables, see the Reference Manual, Developer's Guide, List
|
|
|
69 |
// of Member Variables. The list below is in alphabetical order, matching the manual.
|
|
|
70 |
|
|
|
71 |
/** Calculated width of bars for bar charts */
|
|
|
72 |
protected $actual_bar_width;
|
|
|
73 |
/** Calculated bar gap */
|
|
|
74 |
protected $bar_adjust_gap;
|
|
|
75 |
/** Extra space between groups of bars */
|
|
|
76 |
public $bar_extra_space = 0.5;
|
|
|
77 |
/** Width of bar relative to space for one bar */
|
|
|
78 |
public $bar_width_adjust = 1;
|
|
|
79 |
/** Color (R,G,B,A) for image background */
|
|
|
80 |
protected $bg_color;
|
|
|
81 |
/** Background image filename */
|
|
|
82 |
protected $bgimg;
|
|
|
83 |
/** Background image tiling mode */
|
|
|
84 |
protected $bgmode;
|
|
|
85 |
/** Scale factor for box widths in box plots */
|
|
|
86 |
public $boxes_frac_width = 0.3;
|
|
|
87 |
/** Maximum half-width for boxes in box plots */
|
|
|
88 |
public $boxes_max_width = 8;
|
|
|
89 |
/** Minimum half-width for boxes in box plots */
|
|
|
90 |
public $boxes_min_width = 2;
|
|
|
91 |
/** Ratio of the width of the 'T' ends of box plot whiskers to the width of the boxes */
|
|
|
92 |
public $boxes_t_width = 0.6;
|
|
|
93 |
/** Flag: Don't send cache suppression headers */
|
|
|
94 |
protected $browser_cache = FALSE;
|
|
|
95 |
/** Max bubble size for bubbles plots */
|
|
|
96 |
public $bubbles_max_size;
|
|
|
97 |
/** Min bubbles size for bubble plots */
|
|
|
98 |
public $bubbles_min_size = 6;
|
|
|
99 |
/** Callback (hook) function information, indexed by callback reason */
|
|
|
100 |
protected $callbacks = array(
|
|
|
101 |
'data_points' => NULL,
|
|
|
102 |
'draw_setup' => NULL,
|
|
|
103 |
'draw_image_background' => NULL,
|
|
|
104 |
'draw_plotarea_background' => NULL,
|
|
|
105 |
'draw_titles' => NULL,
|
|
|
106 |
'draw_axes' => NULL,
|
|
|
107 |
'draw_graph' => NULL,
|
|
|
108 |
'draw_border' => NULL,
|
|
|
109 |
'draw_legend' => NULL,
|
|
|
110 |
'draw_all' => NULL,
|
|
|
111 |
'data_color' => NULL,
|
|
|
112 |
'debug_textbox' => NULL,
|
|
|
113 |
'debug_scale' => NULL,
|
|
|
114 |
);
|
|
|
115 |
/** Flag: Draw dashed or solid grid lines? */
|
|
|
116 |
protected $dashed_grid = TRUE;
|
|
|
117 |
/** Initial dashed pattern code */
|
|
|
118 |
protected $dashed_style = '2-4';
|
|
|
119 |
/** The (converted) data array */
|
|
|
120 |
protected $data;
|
|
|
121 |
/** Array of colors (R,G,B,A) for data borders available with some plot types */
|
|
|
122 |
protected $data_border_colors;
|
|
|
123 |
/** Array of colors (R,G,B,A) for data lines/marks/bars/etc. */
|
|
|
124 |
protected $data_colors;
|
|
|
125 |
/** Maximum number of dependent variable values */
|
|
|
126 |
protected $data_columns;
|
|
|
127 |
/** Array: Per row maximum Y value */
|
|
|
128 |
protected $data_max;
|
|
|
129 |
/** Array: Per row minimum Y value */
|
|
|
130 |
protected $data_min;
|
|
|
131 |
/** Format of the data array */
|
|
|
132 |
protected $data_type = 'text-data';
|
|
|
133 |
/** Obsolete - suffix for 'data'-formatted labels */
|
|
|
134 |
public $data_units_text = '';
|
|
|
135 |
/** Angle (in degrees) for data value labels */
|
|
|
136 |
public $data_value_label_angle = 90;
|
|
|
137 |
/** Distance (in pixels) for data value labels */
|
|
|
138 |
public $data_value_label_distance = 5;
|
|
|
139 |
/** Color (R,G,B,A) to use for axis data labels */
|
|
|
140 |
protected $datalabel_color;
|
|
|
141 |
/** Flag: data type has error bars */
|
|
|
142 |
protected $datatype_error_bars;
|
|
|
143 |
/** Flag: data type has implied X or Y */
|
|
|
144 |
protected $datatype_implied;
|
|
|
145 |
/** Flag: data type is one-column data for pie chart */
|
|
|
146 |
protected $datatype_pie_single;
|
|
|
147 |
/** Flag: data type has swapped X and Y values (horizontal plot) */
|
|
|
148 |
protected $datatype_swapped_xy;
|
|
|
149 |
/** Flag: data type includes Y and Z value pairs */
|
|
|
150 |
protected $datatype_yz;
|
|
|
151 |
/** Static array of data type information */
|
|
|
152 |
static protected $datatypes = array( // See DecodeDataType() and $datatype_* flags
|
|
|
153 |
'text-data' => array('implied' => TRUE),
|
|
|
154 |
'text-data-single' => array('implied' => TRUE, 'pie_single' => TRUE),
|
|
|
155 |
'data-data' => array(),
|
|
|
156 |
'data-data-error' => array('error_bars' => TRUE),
|
|
|
157 |
'data-data-yx' => array('swapped_xy' => TRUE),
|
|
|
158 |
'text-data-yx' => array('implied' => TRUE, 'swapped_xy' => TRUE),
|
|
|
159 |
'data-data-xyz' => array('yz' => TRUE),
|
|
|
160 |
'data-data-yx-error' => array('swapped_xy' => TRUE, 'error_bars' => TRUE),
|
|
|
161 |
);
|
|
|
162 |
/** Static array of data type aliases => primary name */
|
|
|
163 |
static protected $datatypes_map = array(
|
|
|
164 |
'text-linear' => 'text-data',
|
|
|
165 |
'linear-linear' => 'data-data',
|
|
|
166 |
'linear-linear-error' => 'data-data-error',
|
|
|
167 |
'text-data-pie' => 'text-data-single',
|
|
|
168 |
'data-data-error-yx' => 'data-data-yx-error',
|
|
|
169 |
);
|
|
|
170 |
/** Character to use for decimal point in formatted numbers */
|
|
|
171 |
protected $decimal_point;
|
|
|
172 |
/** The default color array, used to initialize data_colors and error_bar_colors */
|
|
|
173 |
protected $default_colors = array(
|
|
|
174 |
'SkyBlue', 'green', 'orange', 'blue', 'red', 'DarkGreen', 'purple', 'peru',
|
|
|
175 |
'cyan', 'salmon', 'SlateBlue', 'YellowGreen', 'magenta', 'aquamarine1', 'gold', 'violet'
|
|
|
176 |
);
|
|
|
177 |
/** Dashed-line template, as a string of space-separated markers (see SetDefaultDashedStyle) */
|
|
|
178 |
protected $default_dashed_style;
|
|
|
179 |
/** Default TrueType font file */
|
|
|
180 |
protected $default_ttfont;
|
|
|
181 |
/** Array of flags for elements that must be drawn at most once */
|
|
|
182 |
protected $done = array();
|
|
|
183 |
/** Flag: How to handle missing Y values */
|
|
|
184 |
protected $draw_broken_lines = FALSE;
|
|
|
185 |
/** Flag: Draw data borders, available with some plot types */
|
|
|
186 |
protected $draw_data_borders;
|
|
|
187 |
/** Flag: Draw borders on pie chart segments */
|
|
|
188 |
protected $draw_pie_borders;
|
|
|
189 |
/** Flag: Draw the background of the plot area */
|
|
|
190 |
protected $draw_plot_area_background = FALSE;
|
|
|
191 |
/** Flag: Draw X data label lines */
|
|
|
192 |
protected $draw_x_data_label_lines = FALSE;
|
|
|
193 |
/** Flag: Draw X grid lines? */
|
|
|
194 |
protected $draw_x_grid;
|
|
|
195 |
/** Flag: Draw Y data label lines */
|
|
|
196 |
protected $draw_y_data_label_lines = FALSE;
|
|
|
197 |
/** Flag: Draw Y grid lines? */
|
|
|
198 |
protected $draw_y_grid;
|
|
|
199 |
/** Color (R,G,B,A) to use for data value labels */
|
|
|
200 |
protected $dvlabel_color;
|
|
|
201 |
/** Array of colors (R,G,B,A) for error bars */
|
|
|
202 |
protected $error_bar_colors;
|
|
|
203 |
/** Thickness of error bar lines */
|
|
|
204 |
protected $error_bar_line_width = 1;
|
|
|
205 |
/** Shape (style) of error bars: line or tee */
|
|
|
206 |
protected $error_bar_shape = 'tee';
|
|
|
207 |
/** Size of error bars */
|
|
|
208 |
protected $error_bar_size = 5;
|
|
|
209 |
/** Image format: png, gif, jpg, wbmp */
|
|
|
210 |
protected $file_format = 'png';
|
|
|
211 |
/** Array of font information (should be protected, but public for possible callback use) */
|
|
|
212 |
public $fonts;
|
|
|
213 |
/** Flag: Draw grid on top of or behind the plot */
|
|
|
214 |
public $grid_at_foreground = FALSE;
|
|
|
215 |
/** Color (R,G,B,A) to use for axes, plot area border, legend border, pie chart lines and text */
|
|
|
216 |
protected $grid_color;
|
|
|
217 |
/** Controls fraction of bar group space used for bar */
|
|
|
218 |
public $group_frac_width = 0.7;
|
|
|
219 |
/** Color (R,G,B,A) for image border, if drawn */
|
|
|
220 |
protected $i_border;
|
|
|
221 |
/** Image border type */
|
|
|
222 |
protected $image_border_type = 'none';
|
|
|
223 |
/** Width of image border in pixels */
|
|
|
224 |
protected $image_border_width;
|
|
|
225 |
/** Image height */
|
|
|
226 |
protected $image_height;
|
|
|
227 |
/** Image width */
|
|
|
228 |
protected $image_width;
|
|
|
229 |
/** Image resource (should be protected, but public to reduce breakage) */
|
|
|
230 |
public $img;
|
|
|
231 |
/** Prevent recursion in error message image production */
|
|
|
232 |
protected $in_error;
|
|
|
233 |
/** Flag: don't send headers */
|
|
|
234 |
protected $is_inline = FALSE;
|
|
|
235 |
/** Label format info */
|
|
|
236 |
protected $label_format = array('x' => array(), 'xd' => array(), 'y' => array(), 'yd' => array());
|
|
|
237 |
/** Pie chart label position factor */
|
|
|
238 |
protected $label_scale_position = 0.5;
|
|
|
239 |
/** Legend text array */
|
|
|
240 |
protected $legend;
|
|
|
241 |
/** Color (R,G,B,A) for the legend background */
|
|
|
242 |
protected $legend_bg_color;
|
|
|
243 |
/** Alignment of color boxes or shape markers in the legend: left, right, or none */
|
|
|
244 |
protected $legend_colorbox_align = 'right';
|
|
|
245 |
/** Color control for colorbox borders in legend */
|
|
|
246 |
protected $legend_colorbox_borders = 'textcolor';
|
|
|
247 |
/** Adjusts width of color boxes in the legend */
|
|
|
248 |
public $legend_colorbox_width = 1;
|
|
|
249 |
/** Array holding legend position information */
|
|
|
250 |
protected $legend_pos;
|
|
|
251 |
/** Flag: reverse the order of lines in the legend box, bottom to top */
|
|
|
252 |
protected $legend_reverse_order = FALSE;
|
|
|
253 |
/** Legend style setting, left or right */
|
|
|
254 |
protected $legend_text_align = 'right';
|
|
|
255 |
/** Color (R,G,B,A) for the legend text */
|
|
|
256 |
protected $legend_text_color;
|
|
|
257 |
/** Draw color boxes (if false or unset) or shape markers (if true) in the legend */
|
|
|
258 |
protected $legend_use_shapes = FALSE;
|
|
|
259 |
/** Color (R,G,B,A) for grid lines and X data lines */
|
|
|
260 |
protected $light_grid_color;
|
|
|
261 |
/** Controls inter-line spacing of text */
|
|
|
262 |
protected $line_spacing = 4;
|
|
|
263 |
/** Plot line style(s) */
|
|
|
264 |
protected $line_styles = array('solid', 'solid', 'dashed');
|
|
|
265 |
/** Plot line width(s) */
|
|
|
266 |
protected $line_widths = 1;
|
|
|
267 |
/** Flag to avoid importing locale info */
|
|
|
268 |
public $locale_override = FALSE;
|
|
|
269 |
/** Overall max X value in the data array */
|
|
|
270 |
protected $max_x;
|
|
|
271 |
/** Overall max Y value in the data array */
|
|
|
272 |
protected $max_y;
|
|
|
273 |
/** Overall max Z value in the data array (for X/Y/Z data type only) */
|
|
|
274 |
protected $max_z;
|
|
|
275 |
/** Overall min X value in the data array */
|
|
|
276 |
protected $min_x;
|
|
|
277 |
/** Overall min Y value in the data array */
|
|
|
278 |
protected $min_y;
|
|
|
279 |
/** Overall min Z value in the data array (for X/Y/Z data type only) */
|
|
|
280 |
protected $min_z;
|
|
|
281 |
/** Color index of image background */
|
|
|
282 |
protected $ndx_bg_color;
|
|
|
283 |
/** Color index array for data borders */
|
|
|
284 |
protected $ndx_data_border_colors;
|
|
|
285 |
/** Color index array for plot data lines/marks/bars/etc. */
|
|
|
286 |
protected $ndx_data_colors;
|
|
|
287 |
/** Color index array for plot data, darker shade */
|
|
|
288 |
protected $ndx_data_dark_colors;
|
|
|
289 |
/** Color index for axis data labels */
|
|
|
290 |
protected $ndx_datalabel_color;
|
|
|
291 |
/** Color index for data value labels */
|
|
|
292 |
protected $ndx_dvlabel_color;
|
|
|
293 |
/** Color index array for error bars */
|
|
|
294 |
protected $ndx_error_bar_colors;
|
|
|
295 |
/** Color index for axes, plot area border, legend border, pie chart lines and text */
|
|
|
296 |
protected $ndx_grid_color;
|
|
|
297 |
/** Color index for image border lines */
|
|
|
298 |
protected $ndx_i_border;
|
|
|
299 |
/** Color index for image border lines, darker shade */
|
|
|
300 |
protected $ndx_i_border_dark;
|
|
|
301 |
/** Color index for the legend background */
|
|
|
302 |
protected $ndx_legend_bg_color;
|
|
|
303 |
/** Color index for the legend text */
|
|
|
304 |
protected $ndx_legend_text_color;
|
|
|
305 |
/** Color index for grid lines and X data lines */
|
|
|
306 |
protected $ndx_light_grid_color;
|
|
|
307 |
/** Color index for unshaded pie chart segment borders */
|
|
|
308 |
protected $ndx_pieborder_color;
|
|
|
309 |
/** Color index for pie chart data labels */
|
|
|
310 |
protected $ndx_pielabel_color;
|
|
|
311 |
/** Color index of plot area background */
|
|
|
312 |
protected $ndx_plot_bg_color;
|
|
|
313 |
/** Color index for labels and legend text */
|
|
|
314 |
protected $ndx_text_color;
|
|
|
315 |
/** Color index for tick marks */
|
|
|
316 |
protected $ndx_tick_color;
|
|
|
317 |
/** Color index for tick labels */
|
|
|
318 |
protected $ndx_ticklabel_color;
|
|
|
319 |
/** Color index for main title */
|
|
|
320 |
protected $ndx_title_color;
|
|
|
321 |
/** Color index for X title */
|
|
|
322 |
protected $ndx_x_title_color;
|
|
|
323 |
/** Color index for Y title */
|
|
|
324 |
protected $ndx_y_title_color;
|
|
|
325 |
/** Number of rows in the data array (number of points along X, or number of bar groups, for example) */
|
|
|
326 |
protected $num_data_rows;
|
|
|
327 |
/** Array with number of entries in each data row (including label and X if present) */
|
|
|
328 |
protected $num_recs;
|
|
|
329 |
/** Forced number of X tick marks */
|
|
|
330 |
protected $num_x_ticks = '';
|
|
|
331 |
/** Forced number of Y tick marks */
|
|
|
332 |
protected $num_y_ticks = '';
|
|
|
333 |
/** Scale factor for element widths in OHLC plots. */
|
|
|
334 |
public $ohlc_frac_width = 0.3;
|
|
|
335 |
/** Maximum half-width for elements in OHLC plots */
|
|
|
336 |
public $ohlc_max_width = 8;
|
|
|
337 |
/** Minimum half-width for elements in OHLC plots */
|
|
|
338 |
public $ohlc_min_width = 2;
|
|
|
339 |
/** Redirect to output file */
|
|
|
340 |
protected $output_file;
|
|
|
341 |
/** Aspect ratio for shaded pie charts */
|
|
|
342 |
public $pie_diam_factor = 0.5;
|
|
|
343 |
/** Flag: True to draw pie chart segments clockwise, false or unset for counter-clockwise. */
|
|
|
344 |
protected $pie_direction_cw = FALSE;
|
|
|
345 |
/** Flag: If true, do not include label sizes when calculating pie size. */
|
|
|
346 |
protected $pie_full_size = FALSE;
|
|
|
347 |
/** Source of label text for pie charts (percent, value, label, or index) */
|
|
|
348 |
protected $pie_label_source;
|
|
|
349 |
/** Minimum amount of the plot area that will be reserved for the pie */
|
|
|
350 |
public $pie_min_size_factor = 0.5;
|
|
|
351 |
/** Starting angle in degrees for the first segment in a pie chart */
|
|
|
352 |
protected $pie_start_angle = 0;
|
|
|
353 |
/** Color (R,G,B,A) to use for unshaded pie chart segment borders */
|
|
|
354 |
protected $pieborder_color;
|
|
|
355 |
/** Color (R,G,B,A) to use for pie chart data labels */
|
|
|
356 |
protected $pielabel_color;
|
|
|
357 |
/** Calculated plot area array: ([0],[1]) is top left, ([2],[3]) is bottom right */
|
|
|
358 |
protected $plot_area;
|
|
|
359 |
/** Height of the plot area */
|
|
|
360 |
protected $plot_area_height;
|
|
|
361 |
/** Width of the plot area */
|
|
|
362 |
protected $plot_area_width;
|
|
|
363 |
/** Color (R,G,B,A) for plot area background */
|
|
|
364 |
protected $plot_bg_color;
|
|
|
365 |
/** Where to draw plot borders. Can be scalar or array of choices. */
|
|
|
366 |
protected $plot_border_type;
|
|
|
367 |
/** Max X of the plot area in world coordinates */
|
|
|
368 |
protected $plot_max_x;
|
|
|
369 |
/** Max Y of the plot area in world coordinates */
|
|
|
370 |
protected $plot_max_y;
|
|
|
371 |
/** Min X of the plot area in world coordinates */
|
|
|
372 |
protected $plot_min_x;
|
|
|
373 |
/** Min Y of the plot area in world coordinates */
|
|
|
374 |
protected $plot_min_y;
|
|
|
375 |
/** X device coordinate of the plot area origin */
|
|
|
376 |
protected $plot_origin_x;
|
|
|
377 |
/** Y device coordinate of the plot area origin */
|
|
|
378 |
protected $plot_origin_y;
|
|
|
379 |
/** Selected plot type */
|
|
|
380 |
protected $plot_type = 'linepoints';
|
|
|
381 |
/** Plot area background image filename */
|
|
|
382 |
protected $plotbgimg;
|
|
|
383 |
/** Plot area background image tiling mode */
|
|
|
384 |
protected $plotbgmode;
|
|
|
385 |
/** Array of plot type information, indexed by plot type */
|
|
|
386 |
static protected $plots = array(
|
|
|
387 |
'area' => array(
|
|
|
388 |
'draw_method' => 'DrawArea',
|
|
|
389 |
'abs_vals' => TRUE,
|
|
|
390 |
),
|
|
|
391 |
'bars' => array(
|
|
|
392 |
'draw_method' => 'DrawBars',
|
|
|
393 |
),
|
|
|
394 |
'boxes' => array(
|
|
|
395 |
'draw_method' => 'DrawBoxes',
|
|
|
396 |
'adjust_type' => 1, // See GetRangeEndAdjust()
|
|
|
397 |
),
|
|
|
398 |
'bubbles' => array(
|
|
|
399 |
'draw_method' => 'DrawBubbles',
|
|
|
400 |
'adjust_type' => 1, // See GetRangeEndAdjust()
|
|
|
401 |
),
|
|
|
402 |
'candlesticks' => array(
|
|
|
403 |
'draw_method' => 'DrawOHLC',
|
|
|
404 |
'draw_arg' => array(TRUE, FALSE), // Draw candlesticks, only fill if "closed down"
|
|
|
405 |
'adjust_type' => 2, // See GetRangeEndAdjust()
|
|
|
406 |
),
|
|
|
407 |
'candlesticks2' => array(
|
|
|
408 |
'draw_method' => 'DrawOHLC',
|
|
|
409 |
'draw_arg' => array(TRUE, TRUE), // Draw candlesticks, fill always
|
|
|
410 |
'adjust_type' => 2, // See GetRangeEndAdjust()
|
|
|
411 |
),
|
|
|
412 |
'linepoints' => array(
|
|
|
413 |
'draw_method' => 'DrawLinePoints',
|
|
|
414 |
'legend_alt_marker' => 'shape',
|
|
|
415 |
),
|
|
|
416 |
'lines' => array(
|
|
|
417 |
'draw_method' => 'DrawLines',
|
|
|
418 |
'legend_alt_marker' => 'line',
|
|
|
419 |
),
|
|
|
420 |
'ohlc' => array(
|
|
|
421 |
'draw_method' => 'DrawOHLC',
|
|
|
422 |
'draw_arg' => array(FALSE), // Don't draw candlesticks
|
|
|
423 |
'adjust_type' => 2, // See GetRangeEndAdjust()
|
|
|
424 |
),
|
|
|
425 |
'pie' => array(
|
|
|
426 |
'draw_method' => 'DrawPieChart',
|
|
|
427 |
'suppress_axes' => TRUE,
|
|
|
428 |
'abs_vals' => TRUE,
|
|
|
429 |
),
|
|
|
430 |
'points' => array(
|
|
|
431 |
'draw_method' => 'DrawDots',
|
|
|
432 |
'legend_alt_marker' => 'shape',
|
|
|
433 |
),
|
|
|
434 |
'squared' => array(
|
|
|
435 |
'draw_method' => 'DrawSquared',
|
|
|
436 |
'legend_alt_marker' => 'line',
|
|
|
437 |
),
|
|
|
438 |
'squaredarea' => array(
|
|
|
439 |
'draw_method' => 'DrawSquaredArea',
|
|
|
440 |
'abs_vals' => TRUE,
|
|
|
441 |
),
|
|
|
442 |
'stackedarea' => array(
|
|
|
443 |
'draw_method' => 'DrawArea',
|
|
|
444 |
'draw_arg' => array(TRUE), // Tells DrawArea to draw stacked area plot
|
|
|
445 |
'sum_vals' => TRUE,
|
|
|
446 |
'abs_vals' => TRUE,
|
|
|
447 |
),
|
|
|
448 |
'stackedbars' => array(
|
|
|
449 |
'draw_method' => 'DrawStackedBars',
|
|
|
450 |
'sum_vals' => TRUE,
|
|
|
451 |
),
|
|
|
452 |
'stackedsquaredarea' => array(
|
|
|
453 |
'draw_method' => 'DrawSquaredArea',
|
|
|
454 |
'draw_arg' => array(TRUE), // Tells DrawSquaredArea the data is cumulative
|
|
|
455 |
'sum_vals' => TRUE,
|
|
|
456 |
'abs_vals' => TRUE,
|
|
|
457 |
),
|
|
|
458 |
'thinbarline' => array(
|
|
|
459 |
'draw_method' => 'DrawThinBarLines',
|
|
|
460 |
),
|
|
|
461 |
);
|
|
|
462 |
/** Size of point_shapes and point_sizes arrays */
|
|
|
463 |
protected $point_counts;
|
|
|
464 |
/** Marker shapes for point plots */
|
|
|
465 |
protected $point_shapes = array(
|
|
|
466 |
'diamond', 'dot', 'delta', 'home', 'yield', 'box', 'circle', 'up', 'down', 'cross'
|
|
|
467 |
);
|
|
|
468 |
/** Marker sizes for point plots */
|
|
|
469 |
protected $point_sizes = array(6);
|
|
|
470 |
/** Flag: Automatic PrintImage after DrawGraph? */
|
|
|
471 |
protected $print_image = TRUE;
|
|
|
472 |
/** Tuning parameters for plot range calculation */
|
|
|
473 |
protected $rangectl = array( 'x' => array(
|
|
|
474 |
'adjust_mode' => 'T', // T=adjust to next tick
|
|
|
475 |
'adjust_amount' => NULL, // See GetRangeEndAdjust()
|
|
|
476 |
'zero_magnet' => 0.857142, // Value is 6/7
|
|
|
477 |
),
|
|
|
478 |
'y' => array(
|
|
|
479 |
'adjust_mode' => 'T', // T=adjust to next tick
|
|
|
480 |
'adjust_amount' => NULL, // See GetRangeEndAdjust()
|
|
|
481 |
'zero_magnet' => 0.857142, // Value is 6/7
|
|
|
482 |
));
|
|
|
483 |
/** Area for each bar in a bar chart */
|
|
|
484 |
protected $record_bar_width;
|
|
|
485 |
/** Maximum of num_recs[], max number of entries (including label and X if present) for all data rows */
|
|
|
486 |
protected $records_per_group;
|
|
|
487 |
/** Array mapping color names to array of R, G, B values */
|
|
|
488 |
protected $rgb_array;
|
|
|
489 |
/** Fixed extra margin used in multiple places */
|
|
|
490 |
public $safe_margin = 5;
|
|
|
491 |
/** Stores PHPlot version when object was serialized */
|
|
|
492 |
protected $saved_version;
|
|
|
493 |
/** Drop shadow size for pie and bar charts */
|
|
|
494 |
protected $shading = 5;
|
|
|
495 |
/** Skip bottom tick mark */
|
|
|
496 |
protected $skip_bottom_tick = FALSE;
|
|
|
497 |
/** Skip left tick mark */
|
|
|
498 |
protected $skip_left_tick = FALSE;
|
|
|
499 |
/** Skip right tick mark */
|
|
|
500 |
protected $skip_right_tick = FALSE;
|
|
|
501 |
/** Skip top tick mark */
|
|
|
502 |
protected $skip_top_tick = FALSE;
|
|
|
503 |
/** MIME boundary sequence used with streaming plots */
|
|
|
504 |
protected $stream_boundary;
|
|
|
505 |
/** Boundary and MIME header, output before each frame in a plot stream */
|
|
|
506 |
protected $stream_frame_header;
|
|
|
507 |
/** Name of the GD output function for this image type, used with streaming plots */
|
|
|
508 |
protected $stream_output_f;
|
|
|
509 |
/** Flag: Don't produce an error image on fatal error */
|
|
|
510 |
protected $suppress_error_image = FALSE;
|
|
|
511 |
/** Flag: Don't draw the X axis line */
|
|
|
512 |
protected $suppress_x_axis = FALSE;
|
|
|
513 |
/** Flag: Don't draw the Y axis line */
|
|
|
514 |
protected $suppress_y_axis = FALSE;
|
|
|
515 |
/** Color (R,G,B,A) for labels and legend text */
|
|
|
516 |
protected $text_color;
|
|
|
517 |
/** Character to use to group 1000s in formatted numbers */
|
|
|
518 |
protected $thousands_sep;
|
|
|
519 |
/** Color (R,G,B,A) for tick marks */
|
|
|
520 |
protected $tick_color;
|
|
|
521 |
/** Tuning parameters for tick increment calculation */
|
|
|
522 |
protected $tickctl = array( 'x' => array(
|
|
|
523 |
'tick_mode' => NULL,
|
|
|
524 |
'min_ticks' => 8,
|
|
|
525 |
'tick_inc_integer' => FALSE,
|
|
|
526 |
),
|
|
|
527 |
'y' => array(
|
|
|
528 |
'tick_mode' => NULL,
|
|
|
529 |
'min_ticks' => 8,
|
|
|
530 |
'tick_inc_integer' => FALSE,
|
|
|
531 |
));
|
|
|
532 |
/** Color (R,G,B,A) to use for tick labels */
|
|
|
533 |
protected $ticklabel_color;
|
|
|
534 |
/** Color (R,G,B,A) for main title (and default for X and Y titles) */
|
|
|
535 |
protected $title_color;
|
|
|
536 |
/** Y offset of main title position */
|
|
|
537 |
protected $title_offset;
|
|
|
538 |
/** Main title text */
|
|
|
539 |
protected $title_txt = '';
|
|
|
540 |
/** Total number of entries (rows times columns in each row) in the data array. */
|
|
|
541 |
protected $total_records;
|
|
|
542 |
/** Color (R,G,B,A) designated as transparent */
|
|
|
543 |
protected $transparent_color;
|
|
|
544 |
/** Flag: True if serialized object had a truecolor image */
|
|
|
545 |
protected $truecolor;
|
|
|
546 |
/** TrueType font directory */
|
|
|
547 |
protected $ttf_path = '.';
|
|
|
548 |
/** Default font type, True for TrueType, False for GD */
|
|
|
549 |
protected $use_ttf = FALSE;
|
|
|
550 |
/** Position of X axis (in world coordinates) */
|
|
|
551 |
protected $x_axis_position;
|
|
|
552 |
/** Device coordinate for the X axis */
|
|
|
553 |
protected $x_axis_y_pixels;
|
|
|
554 |
/** Effective X data label text angle */
|
|
|
555 |
protected $x_data_label_angle;
|
|
|
556 |
/** X data label text angle (see also x_data_label_angle) */
|
|
|
557 |
protected $x_data_label_angle_u = '';
|
|
|
558 |
/** Position of X data labels */
|
|
|
559 |
protected $x_data_label_pos;
|
|
|
560 |
/** X tick label text angle (and default for x_data_label_angle) */
|
|
|
561 |
protected $x_label_angle = 0;
|
|
|
562 |
/** Label offset relative to plot area */
|
|
|
563 |
protected $x_label_axis_offset;
|
|
|
564 |
/** Label offset relative to plot area */
|
|
|
565 |
protected $x_label_bot_offset;
|
|
|
566 |
/** Label offset relative to plot area */
|
|
|
567 |
protected $x_label_top_offset;
|
|
|
568 |
/** Calculated plot area margin - left side */
|
|
|
569 |
protected $x_left_margin;
|
|
|
570 |
/** Calculated plot area margin - right side */
|
|
|
571 |
protected $x_right_margin;
|
|
|
572 |
/** X tick anchor point */
|
|
|
573 |
protected $x_tick_anchor;
|
|
|
574 |
/** Length of X tick marks (inside plot area) */
|
|
|
575 |
protected $x_tick_cross = 3;
|
|
|
576 |
/** Effective step between X tick marks */
|
|
|
577 |
protected $x_tick_inc;
|
|
|
578 |
/** Step between X tick marks (see also x_tick_inc) */
|
|
|
579 |
protected $x_tick_inc_u = '';
|
|
|
580 |
/** Position of X tick labels */
|
|
|
581 |
protected $x_tick_label_pos;
|
|
|
582 |
/** Length of X tick marks (outside plot area) */
|
|
|
583 |
protected $x_tick_length = 5;
|
|
|
584 |
/** Position of X tick marks */
|
|
|
585 |
protected $x_tick_pos = 'plotdown';
|
|
|
586 |
/** Title offset relative to plot area */
|
|
|
587 |
protected $x_title_bot_offset;
|
|
|
588 |
/** Color (R,G,B,A) for X title */
|
|
|
589 |
protected $x_title_color;
|
|
|
590 |
/** X Axis title position */
|
|
|
591 |
protected $x_title_pos = 'none';
|
|
|
592 |
/** Title offset relative to plot area */
|
|
|
593 |
protected $x_title_top_offset;
|
|
|
594 |
/** X Axis title text */
|
|
|
595 |
protected $x_title_txt = '';
|
|
|
596 |
/** X scale factor for converting World to Device coordinates */
|
|
|
597 |
protected $xscale;
|
|
|
598 |
/** Linear or log scale on X */
|
|
|
599 |
protected $xscale_type = 'linear';
|
|
|
600 |
/** Position of Y axis (in world coordinates) */
|
|
|
601 |
protected $y_axis_position;
|
|
|
602 |
/** Device coordinate for the Y axis */
|
|
|
603 |
protected $y_axis_x_pixels;
|
|
|
604 |
/** Calculated plot area margin - bottom */
|
|
|
605 |
protected $y_bot_margin;
|
|
|
606 |
/** Y data label text angle */
|
|
|
607 |
protected $y_data_label_angle = 0;
|
|
|
608 |
/** Position of Y data labels */
|
|
|
609 |
protected $y_data_label_pos;
|
|
|
610 |
/** Y tick label text angle */
|
|
|
611 |
protected $y_label_angle = 0;
|
|
|
612 |
/** Label offset relative to plot area */
|
|
|
613 |
protected $y_label_axis_offset;
|
|
|
614 |
/** Label offset relative to plot area */
|
|
|
615 |
protected $y_label_left_offset;
|
|
|
616 |
/** Label offset relative to plot area */
|
|
|
617 |
protected $y_label_right_offset;
|
|
|
618 |
/** Y tick anchor point */
|
|
|
619 |
protected $y_tick_anchor;
|
|
|
620 |
/** Length of Y tick marks (inside plot area) */
|
|
|
621 |
protected $y_tick_cross = 3;
|
|
|
622 |
/** Effective step between Y tick marks */
|
|
|
623 |
protected $y_tick_inc;
|
|
|
624 |
/** Step between Y tick marks (see also y_tick_inc) */
|
|
|
625 |
protected $y_tick_inc_u = '';
|
|
|
626 |
/** Position of Y tick labels */
|
|
|
627 |
protected $y_tick_label_pos;
|
|
|
628 |
/** Length of Y tick marks (outside plot area) */
|
|
|
629 |
protected $y_tick_length = 5;
|
|
|
630 |
/** Position of Y tick marks */
|
|
|
631 |
protected $y_tick_pos = 'plotleft';
|
|
|
632 |
/** Color (R,G,B,A) for Y title */
|
|
|
633 |
protected $y_title_color;
|
|
|
634 |
/** Title offset relative to plot area */
|
|
|
635 |
protected $y_title_left_offset;
|
|
|
636 |
/** Y Axis title position */
|
|
|
637 |
protected $y_title_pos = 'none';
|
|
|
638 |
/** Title offset relative to plot area */
|
|
|
639 |
protected $y_title_right_offset;
|
|
|
640 |
/** Y Axis title text */
|
|
|
641 |
protected $y_title_txt = '';
|
|
|
642 |
/** Calculated plot area margin - top */
|
|
|
643 |
protected $y_top_margin;
|
|
|
644 |
/** Y scale factor for converting World to Device coordinates */
|
|
|
645 |
protected $yscale;
|
|
|
646 |
/** Linear or log scale on Y */
|
|
|
647 |
protected $yscale_type = 'linear';
|
|
|
648 |
|
|
|
649 |
/**
|
|
|
650 |
* Constructor: Sets up GD palette image resource, and initializes plot style controls
|
|
|
651 |
*
|
|
|
652 |
* @param int $width Image width in pixels
|
|
|
653 |
* @param int $height Image height in pixels
|
|
|
654 |
* @param string $output_file Path for output file. Omit, or NULL, or '' to mean no output file
|
|
|
655 |
* @param string $input_file Path to a file to be used as background. Omit, NULL, or '' for none
|
|
|
656 |
*/
|
|
|
657 |
function __construct($width=600, $height=400, $output_file=NULL, $input_file=NULL)
|
|
|
658 |
{
|
|
|
659 |
$this->initialize('imagecreate', $width, $height, $output_file, $input_file);
|
|
|
660 |
}
|
|
|
661 |
|
|
|
662 |
/**
|
|
|
663 |
* Initializes a PHPlot object (used by PHPlot and PHPlot_truecolor constructors)
|
|
|
664 |
*
|
|
|
665 |
* @param string $imagecreate_function GD function to use: imagecreate or imagecreatetruecolor
|
|
|
666 |
* @param int $width Image width in pixels
|
|
|
667 |
* @param int $height Image height in pixels
|
|
|
668 |
* @param string $output_file Path for output file. Omit, or NULL, or '' to mean no output file
|
|
|
669 |
* @param string $input_file Path to a file to be used as background. Omit, NULL, or '' for none
|
|
|
670 |
* @since 5.6.0
|
|
|
671 |
*/
|
|
|
672 |
protected function initialize($imagecreate_function, $width, $height, $output_file, $input_file)
|
|
|
673 |
{
|
|
|
674 |
$this->SetRGBArray('small');
|
|
|
675 |
|
|
|
676 |
if (isset($output_file) && $output_file !== '')
|
|
|
677 |
$this->SetOutputFile($output_file);
|
|
|
678 |
|
|
|
679 |
if (isset($input_file) && $input_file !== '') {
|
|
|
680 |
$this->SetInputFile($input_file);
|
|
|
681 |
} else {
|
|
|
682 |
$this->image_width = $width;
|
|
|
683 |
$this->image_height = $height;
|
|
|
684 |
$this->img = call_user_func($imagecreate_function, $width, $height);
|
|
|
685 |
if (!$this->img)
|
|
|
686 |
return $this->PrintError(get_class($this) . '(): Could not create image resource.');
|
|
|
687 |
}
|
|
|
688 |
$this->SetDefaultStyles();
|
|
|
689 |
$this->SetDefaultFonts();
|
|
|
690 |
}
|
|
|
691 |
|
|
|
692 |
/**
|
|
|
693 |
* Prepares object for serialization
|
|
|
694 |
*
|
|
|
695 |
* The image resource cannot be serialized. But rather than try to filter it out from the other
|
|
|
696 |
* properties, just let PHP serialize it (it will become an integer=0), and then fix it in __wakeup.
|
|
|
697 |
* This way the object is still usable after serialize().
|
|
|
698 |
* Note: This does not work if an input file was provided to the constructor.
|
|
|
699 |
*
|
|
|
700 |
* @return string[] Array of object property names, as required by PHP spec for __sleep()
|
|
|
701 |
* @since 5.8.0
|
|
|
702 |
*/
|
|
|
703 |
function __sleep()
|
|
|
704 |
{
|
|
|
705 |
$this->truecolor = imageistruecolor($this->img); // Remember image type
|
|
|
706 |
$this->saved_version = self::version; // Remember version of PHPlot, for checking on unserialize
|
|
|
707 |
return array_keys(get_object_vars($this));
|
|
|
708 |
}
|
|
|
709 |
|
|
|
710 |
/**
|
|
|
711 |
* Cleans up object after unserialization
|
|
|
712 |
*
|
|
|
713 |
* Recreates the image resource (which is not serializable), after validating the PHPlot version.
|
|
|
714 |
* @since 5.8.0
|
|
|
715 |
*/
|
|
|
716 |
function __wakeup()
|
|
|
717 |
{
|
|
|
718 |
if (strcmp($this->saved_version, self::version) != 0)
|
|
|
719 |
$this->PrintError(get_class($this) . '(): Unserialize version mismatch');
|
|
|
720 |
$imagecreate_function = $this->truecolor ? 'imagecreatetruecolor' : 'imagecreate';
|
|
|
721 |
$this->img = call_user_func($imagecreate_function, $this->image_width, $this->image_height);
|
|
|
722 |
if (!$this->img)
|
|
|
723 |
$this->PrintError(get_class($this) . '(): Could not create image resource.');
|
|
|
724 |
unset($this->truecolor, $this->saved_version);
|
|
|
725 |
}
|
|
|
726 |
|
|
|
727 |
/**
|
|
|
728 |
* Reads an image file (used by constructor via SetInput file, and by tile_img for backgrounds)
|
|
|
729 |
*
|
|
|
730 |
* @param string $image_filename Filename of the image file to read
|
|
|
731 |
* @param int $width Reference variable for width of the image in pixels
|
|
|
732 |
* @param int $height Reference variable for height of the image in pixels
|
|
|
733 |
* @return resource Image resource (False on error if an error handler returns True)
|
|
|
734 |
* @since 5.0.4
|
|
|
735 |
*/
|
|
|
736 |
protected function GetImage($image_filename, &$width, &$height)
|
|
|
737 |
{
|
|
|
738 |
$error = '';
|
|
|
739 |
$size = getimagesize($image_filename);
|
|
|
740 |
if (!$size) {
|
|
|
741 |
$error = "Unable to query image file $image_filename";
|
|
|
742 |
} else {
|
|
|
743 |
$image_type = $size[2];
|
|
|
744 |
switch ($image_type) {
|
|
|
745 |
case IMAGETYPE_GIF:
|
|
|
746 |
$img = @ ImageCreateFromGIF ($image_filename);
|
|
|
747 |
break;
|
|
|
748 |
case IMAGETYPE_PNG:
|
|
|
749 |
$img = @ ImageCreateFromPNG ($image_filename);
|
|
|
750 |
break;
|
|
|
751 |
case IMAGETYPE_JPEG:
|
|
|
752 |
$img = @ ImageCreateFromJPEG ($image_filename);
|
|
|
753 |
break;
|
|
|
754 |
default:
|
|
|
755 |
$error = "Unknown image type ($image_type) for image file $image_filename";
|
|
|
756 |
break;
|
|
|
757 |
}
|
|
|
758 |
}
|
|
|
759 |
if (empty($error) && !$img) {
|
|
|
760 |
// getimagesize is OK, but GD won't read it. Maybe unsupported format.
|
|
|
761 |
$error = "Failed to read image file $image_filename";
|
|
|
762 |
}
|
|
|
763 |
if (!empty($error)) {
|
|
|
764 |
return $this->PrintError("GetImage(): $error");
|
|
|
765 |
}
|
|
|
766 |
$width = $size[0];
|
|
|
767 |
$height = $size[1];
|
|
|
768 |
return $img;
|
|
|
769 |
}
|
|
|
770 |
|
|
|
771 |
/**
|
|
|
772 |
* Selects an input file to be used as background for the whole graph
|
|
|
773 |
*
|
|
|
774 |
* @param string $which_input_file Pathname to the image file to use as a background
|
|
|
775 |
* @deprecated Public use discouraged; intended for use by class constructor
|
|
|
776 |
* @return bool True (False on error if an error handler returns True)
|
|
|
777 |
*/
|
|
|
778 |
function SetInputFile($which_input_file)
|
|
|
779 |
{
|
|
|
780 |
$im = $this->GetImage($which_input_file, $this->image_width, $this->image_height);
|
|
|
781 |
if (!$im)
|
|
|
782 |
return FALSE; // GetImage already produced an error message.
|
|
|
783 |
|
|
|
784 |
// Deallocate any resources previously allocated
|
|
|
785 |
if (isset($this->img))
|
|
|
786 |
imagedestroy($this->img);
|
|
|
787 |
|
|
|
788 |
$this->img = $im;
|
|
|
789 |
|
|
|
790 |
// Do not overwrite the input file with the background color.
|
|
|
791 |
$this->done['background'] = TRUE;
|
|
|
792 |
|
|
|
793 |
return TRUE;
|
|
|
794 |
}
|
|
|
795 |
|
|
|
796 |
/////////////////////////////////////////////
|
|
|
797 |
////////////// COLORS
|
|
|
798 |
/////////////////////////////////////////////
|
|
|
799 |
|
|
|
800 |
/**
|
|
|
801 |
* Allocates a GD color index for a color specified as an array (R,G,B,A)
|
|
|
802 |
*
|
|
|
803 |
* At drawing time, this allocates a GD color index for the specified color, which
|
|
|
804 |
* is specified as a 4 component array. Earlier, when a color is specified,
|
|
|
805 |
* SetRGBColor() parsed and checked it and converted it to this component array form.
|
|
|
806 |
*
|
|
|
807 |
* @param int[] $color Color specification as (R, G, B, A), or unset variable
|
|
|
808 |
* @param int $default_color_index An already-allocated GD color index to use if $color is unset
|
|
|
809 |
* @return int A GD color index that can be used when drawing
|
|
|
810 |
* @since 5.2.0
|
|
|
811 |
*/
|
|
|
812 |
protected function GetColorIndex(&$color, $default_color_index = 0)
|
|
|
813 |
{
|
|
|
814 |
if (empty($color)) return $default_color_index;
|
|
|
815 |
list($r, $g, $b, $a) = $color;
|
|
|
816 |
return imagecolorresolvealpha($this->img, $r, $g, $b, $a);
|
|
|
817 |
}
|
|
|
818 |
|
|
|
819 |
/**
|
|
|
820 |
* Allocates an array of GD color indexes from an array of color specification arrays
|
|
|
821 |
*
|
|
|
822 |
* This is used for the data_colors array, for example.
|
|
|
823 |
* Note: $color_array must use 0-based sequential integer indexes.
|
|
|
824 |
*
|
|
|
825 |
* @param array $color_array Array of color specifications, each an array (R,G,B,A)
|
|
|
826 |
* @param int $max_colors Limit color allocation to no more than this number of colors
|
|
|
827 |
* @return int[] Array of GD color indexes that can be used when drawing
|
|
|
828 |
* @since 5.3.1
|
|
|
829 |
*/
|
|
|
830 |
protected function GetColorIndexArray($color_array, $max_colors)
|
|
|
831 |
{
|
|
|
832 |
$n = min(count($color_array), $max_colors);
|
|
|
833 |
$result = array();
|
|
|
834 |
for ($i = 0; $i < $n; $i++)
|
|
|
835 |
$result[] = $this->GetColorIndex($color_array[$i]);
|
|
|
836 |
return $result;
|
|
|
837 |
}
|
|
|
838 |
|
|
|
839 |
/**
|
|
|
840 |
* Allocates an array of GD color indexes for darker shades from an array of color specifications
|
|
|
841 |
*
|
|
|
842 |
* This is used for shadow colors such as those in bar charts with shading.
|
|
|
843 |
*
|
|
|
844 |
* @param array $color_array Array of color specifications, each an array (R,G,B,A)
|
|
|
845 |
* @param int $max_colors Limit color allocation to no more than this number of colors
|
|
|
846 |
* @return int[] Array of GD color indexes that can be used when drawing shadow colors
|
|
|
847 |
* @since 5.3.1
|
|
|
848 |
*/
|
|
|
849 |
protected function GetDarkColorIndexArray($color_array, $max_colors)
|
|
|
850 |
{
|
|
|
851 |
$n = min(count($color_array), $max_colors);
|
|
|
852 |
$result = array();
|
|
|
853 |
for ($i = 0; $i < $n; $i++)
|
|
|
854 |
$result[] = $this->GetDarkColorIndex($color_array[$i]);
|
|
|
855 |
return $result;
|
|
|
856 |
}
|
|
|
857 |
|
|
|
858 |
/**
|
|
|
859 |
* Allocates a GD color index for a darker shade of a color specified as an array (R,G,B,A)
|
|
|
860 |
*
|
|
|
861 |
* See notes on GetColorIndex() above.
|
|
|
862 |
*
|
|
|
863 |
* @param int[] $color Color specification as (R, G, B, A)
|
|
|
864 |
* @return int A GD color index that can be used when drawing a shadow color
|
|
|
865 |
* @since 5.2.0
|
|
|
866 |
*/
|
|
|
867 |
protected function GetDarkColorIndex($color)
|
|
|
868 |
{
|
|
|
869 |
list ($r, $g, $b, $a) = $color;
|
|
|
870 |
$r = max(0, $r - 0x30);
|
|
|
871 |
$g = max(0, $g - 0x30);
|
|
|
872 |
$b = max(0, $b - 0x30);
|
|
|
873 |
return imagecolorresolvealpha($this->img, $r, $g, $b, $a);
|
|
|
874 |
}
|
|
|
875 |
|
|
|
876 |
/**
|
|
|
877 |
* Sets or reverts all colors and styles to their defaults
|
|
|
878 |
*
|
|
|
879 |
* @return bool True always
|
|
|
880 |
*/
|
|
|
881 |
protected function SetDefaultStyles()
|
|
|
882 |
{
|
|
|
883 |
$this->SetDefaultDashedStyle($this->dashed_style);
|
|
|
884 |
$this->SetImageBorderColor(array(194, 194, 194));
|
|
|
885 |
$this->SetPlotBgColor('white');
|
|
|
886 |
$this->SetBackgroundColor('white');
|
|
|
887 |
$this->SetTextColor('black');
|
|
|
888 |
$this->SetGridColor('black');
|
|
|
889 |
$this->SetLightGridColor('gray');
|
|
|
890 |
$this->SetTickColor('black');
|
|
|
891 |
$this->SetTitleColor('black');
|
|
|
892 |
// These functions set up the default colors when called without parameters
|
|
|
893 |
$this->SetDataColors();
|
|
|
894 |
$this->SetErrorBarColors();
|
|
|
895 |
$this->SetDataBorderColors();
|
|
|
896 |
return TRUE;
|
|
|
897 |
}
|
|
|
898 |
|
|
|
899 |
/**
|
|
|
900 |
* Sets the overall image background color
|
|
|
901 |
*
|
|
|
902 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
903 |
* @return bool True (False on error if an error handler returns True)
|
|
|
904 |
*/
|
|
|
905 |
function SetBackgroundColor($which_color)
|
|
|
906 |
{
|
|
|
907 |
return (bool)($this->bg_color = $this->SetRGBColor($which_color));
|
|
|
908 |
}
|
|
|
909 |
|
|
|
910 |
/**
|
|
|
911 |
* Sets the plot area background color, which is only drawn if SetDrawPlotAreaBackground is used.
|
|
|
912 |
*
|
|
|
913 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
914 |
* @return bool True (False on error if an error handler returns True)
|
|
|
915 |
*/
|
|
|
916 |
function SetPlotBgColor($which_color)
|
|
|
917 |
{
|
|
|
918 |
return (bool)($this->plot_bg_color = $this->SetRGBColor($which_color));
|
|
|
919 |
}
|
|
|
920 |
|
|
|
921 |
/**
|
|
|
922 |
* Sets the color of the plot title, and the default color of the X and Y titles.
|
|
|
923 |
*
|
|
|
924 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
925 |
* @return bool True (False on error if an error handler returns True)
|
|
|
926 |
*/
|
|
|
927 |
function SetTitleColor($which_color)
|
|
|
928 |
{
|
|
|
929 |
return (bool)($this->title_color = $this->SetRGBColor($which_color));
|
|
|
930 |
}
|
|
|
931 |
|
|
|
932 |
/**
|
|
|
933 |
* Sets the color of the X title, overriding the color set with SetTitleColor()
|
|
|
934 |
*
|
|
|
935 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
936 |
* @return bool True (False on error if an error handler returns True)
|
|
|
937 |
* @since 5.2.0
|
|
|
938 |
*/
|
|
|
939 |
function SetXTitleColor($which_color)
|
|
|
940 |
{
|
|
|
941 |
return (bool)($this->x_title_color = $this->SetRGBColor($which_color));
|
|
|
942 |
}
|
|
|
943 |
|
|
|
944 |
/**
|
|
|
945 |
* Sets the color of the Y title, overriding the color set with SetTitleColor()
|
|
|
946 |
*
|
|
|
947 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
948 |
* @return bool True (False on error if an error handler returns True)
|
|
|
949 |
* @since 5.2.0
|
|
|
950 |
*/
|
|
|
951 |
function SetYTitleColor($which_color)
|
|
|
952 |
{
|
|
|
953 |
return (bool)($this->y_title_color = $this->SetRGBColor($which_color));
|
|
|
954 |
}
|
|
|
955 |
|
|
|
956 |
/**
|
|
|
957 |
* Sets the color of the axis tick marks
|
|
|
958 |
*
|
|
|
959 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
960 |
* @return bool True (False on error if an error handler returns True)
|
|
|
961 |
*/
|
|
|
962 |
function SetTickColor($which_color)
|
|
|
963 |
{
|
|
|
964 |
return (bool)($this->tick_color = $this->SetRGBColor($which_color));
|
|
|
965 |
}
|
|
|
966 |
|
|
|
967 |
/**
|
|
|
968 |
* @deprecated Use SetTitleColor() instead
|
|
|
969 |
*/
|
|
|
970 |
function SetLabelColor($which_color)
|
|
|
971 |
{
|
|
|
972 |
return $this->SetTitleColor($which_color);
|
|
|
973 |
}
|
|
|
974 |
|
|
|
975 |
/**
|
|
|
976 |
* Sets the general text color, which is the default color for legend text, tick and data labels
|
|
|
977 |
*
|
|
|
978 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
979 |
* @return bool True (False on error if an error handler returns True)
|
|
|
980 |
*/
|
|
|
981 |
function SetTextColor($which_color)
|
|
|
982 |
{
|
|
|
983 |
return (bool)($this->text_color = $this->SetRGBColor($which_color));
|
|
|
984 |
}
|
|
|
985 |
|
|
|
986 |
/**
|
|
|
987 |
* Sets the color for data labels, overriding the default set with SetTextColor()
|
|
|
988 |
*
|
|
|
989 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
990 |
* @return bool True (False on error if an error handler returns True)
|
|
|
991 |
* @since 5.7.0
|
|
|
992 |
*/
|
|
|
993 |
function SetDataLabelColor($which_color)
|
|
|
994 |
{
|
|
|
995 |
return (bool)($this->datalabel_color = $this->SetRGBColor($which_color));
|
|
|
996 |
}
|
|
|
997 |
|
|
|
998 |
/**
|
|
|
999 |
* Sets the color for data value labels, overriding SetTextColor() and SetDataLabelColor()
|
|
|
1000 |
*
|
|
|
1001 |
* Note: Data Value Labels are the labels within the plot area (not the axis labels).
|
|
|
1002 |
*
|
|
|
1003 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1004 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1005 |
* @since 5.7.0
|
|
|
1006 |
*/
|
|
|
1007 |
function SetDataValueLabelColor($which_color)
|
|
|
1008 |
{
|
|
|
1009 |
return (bool)($this->dvlabel_color = $this->SetRGBColor($which_color));
|
|
|
1010 |
}
|
|
|
1011 |
|
|
|
1012 |
/**
|
|
|
1013 |
* Sets the color for pie chart data labels, overriding the default set with SetGridColor()
|
|
|
1014 |
*
|
|
|
1015 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1016 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1017 |
* @since 5.7.0
|
|
|
1018 |
*/
|
|
|
1019 |
function SetPieLabelColor($which_color)
|
|
|
1020 |
{
|
|
|
1021 |
return (bool)($this->pielabel_color = $this->SetRGBColor($which_color));
|
|
|
1022 |
}
|
|
|
1023 |
|
|
|
1024 |
/**
|
|
|
1025 |
* Sets the color for pie chart segment borders
|
|
|
1026 |
*
|
|
|
1027 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1028 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1029 |
* @since 6.0.0
|
|
|
1030 |
*/
|
|
|
1031 |
function SetPieBorderColor($which_color)
|
|
|
1032 |
{
|
|
|
1033 |
return (bool)($this->pieborder_color = $this->SetRGBColor($which_color));
|
|
|
1034 |
}
|
|
|
1035 |
|
|
|
1036 |
/**
|
|
|
1037 |
* Sets the color for tick labels, overriding the default set with SetTextColor()
|
|
|
1038 |
*
|
|
|
1039 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1040 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1041 |
* @since 5.7.0
|
|
|
1042 |
*/
|
|
|
1043 |
function SetTickLabelColor($which_color)
|
|
|
1044 |
{
|
|
|
1045 |
return (bool)($this->ticklabel_color = $this->SetRGBColor($which_color));
|
|
|
1046 |
}
|
|
|
1047 |
|
|
|
1048 |
/**
|
|
|
1049 |
* Sets the X and Y grid colors, and the data label line color
|
|
|
1050 |
*
|
|
|
1051 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1052 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1053 |
*/
|
|
|
1054 |
function SetLightGridColor($which_color)
|
|
|
1055 |
{
|
|
|
1056 |
return (bool)($this->light_grid_color = $this->SetRGBColor($which_color));
|
|
|
1057 |
}
|
|
|
1058 |
|
|
|
1059 |
/**
|
|
|
1060 |
* Sets the color used for the X and Y axis lines, plot border, and legend border
|
|
|
1061 |
*
|
|
|
1062 |
* Also sets the default color for the pie chart data labels and pie chart segment borders.
|
|
|
1063 |
* These can be overridden by SetPieLabelColor() and SetPieBorderColor() respectively.
|
|
|
1064 |
* Note: This has nothing to do with the grid, and we don't know where this name came from.
|
|
|
1065 |
*
|
|
|
1066 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1067 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1068 |
*/
|
|
|
1069 |
function SetGridColor($which_color)
|
|
|
1070 |
{
|
|
|
1071 |
return (bool)($this->grid_color = $this->SetRGBColor($which_color));
|
|
|
1072 |
}
|
|
|
1073 |
|
|
|
1074 |
/**
|
|
|
1075 |
* Sets the color used for the image border, drawn if SetImageBorderType() enables it
|
|
|
1076 |
*
|
|
|
1077 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1078 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1079 |
*/
|
|
|
1080 |
function SetImageBorderColor($which_color)
|
|
|
1081 |
{
|
|
|
1082 |
return (bool)($this->i_border = $this->SetRGBColor($which_color));
|
|
|
1083 |
}
|
|
|
1084 |
|
|
|
1085 |
/**
|
|
|
1086 |
* Designates a color to be transparent, if transparency is supported by the image format
|
|
|
1087 |
*
|
|
|
1088 |
* @param string|int[]|null $which_color Color to make transparent; empty|omit|NULL to reset to none
|
|
|
1089 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1090 |
*/
|
|
|
1091 |
function SetTransparentColor($which_color = NULL)
|
|
|
1092 |
{
|
|
|
1093 |
$this->transparent_color = empty($which_color) ? NULL : $this->SetRGBColor($which_color);
|
|
|
1094 |
return ($this->transparent_color !== FALSE); // True unless SetRGBColor() returned an error
|
|
|
1095 |
}
|
|
|
1096 |
|
|
|
1097 |
/**
|
|
|
1098 |
* Sets the color used for the legend background, which defaults to the image background color
|
|
|
1099 |
*
|
|
|
1100 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1101 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1102 |
* @since 6.0.0
|
|
|
1103 |
*/
|
|
|
1104 |
function SetLegendBgColor($which_color)
|
|
|
1105 |
{
|
|
|
1106 |
return (bool)($this->legend_bg_color = $this->SetRGBColor($which_color));
|
|
|
1107 |
}
|
|
|
1108 |
|
|
|
1109 |
/**
|
|
|
1110 |
* Sets the color used for the legend text, which defaults to the general text color
|
|
|
1111 |
*
|
|
|
1112 |
* @param string|int[] $which_color Color name or spec (#rrggbb, (r,g,b) array, etc)
|
|
|
1113 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1114 |
* @since 6.0.0
|
|
|
1115 |
*/
|
|
|
1116 |
function SetLegendTextColor($which_color)
|
|
|
1117 |
{
|
|
|
1118 |
return (bool)($this->legend_text_color = $this->SetRGBColor($which_color));
|
|
|
1119 |
}
|
|
|
1120 |
|
|
|
1121 |
/**
|
|
|
1122 |
* Sets the array of colors to be used (the color map)
|
|
|
1123 |
*
|
|
|
1124 |
* The color map maps color names into arrays of R, G, B and optionally A values.
|
|
|
1125 |
* The selected color map can be user defined, a small predefined one,
|
|
|
1126 |
* or a large one included from the file 'rgb.inc.php'.
|
|
|
1127 |
*
|
|
|
1128 |
* @param array|string $which_color_array Color map array (name=>(R,G,B[,A]), or keyword small | large
|
|
|
1129 |
* @return bool True always
|
|
|
1130 |
*/
|
|
|
1131 |
function SetRGBArray($which_color_array)
|
|
|
1132 |
{
|
|
|
1133 |
if (is_array($which_color_array)) { // User defined array
|
|
|
1134 |
$this->rgb_array = $which_color_array;
|
|
|
1135 |
} elseif ($which_color_array == 'small') { // Small predefined color array
|
|
|
1136 |
$this->rgb_array = array(
|
|
|
1137 |
'white' => array(255, 255, 255),
|
|
|
1138 |
'snow' => array(255, 250, 250),
|
|
|
1139 |
'PeachPuff' => array(255, 218, 185),
|
|
|
1140 |
'ivory' => array(255, 255, 240),
|
|
|
1141 |
'lavender' => array(230, 230, 250),
|
|
|
1142 |
'black' => array( 0, 0, 0),
|
|
|
1143 |
'DimGrey' => array(105, 105, 105),
|
|
|
1144 |
'gray' => array(190, 190, 190),
|
|
|
1145 |
'grey' => array(190, 190, 190),
|
|
|
1146 |
'navy' => array( 0, 0, 128),
|
|
|
1147 |
'SlateBlue' => array(106, 90, 205),
|
|
|
1148 |
'blue' => array( 0, 0, 255),
|
|
|
1149 |
'SkyBlue' => array(135, 206, 235),
|
|
|
1150 |
'cyan' => array( 0, 255, 255),
|
|
|
1151 |
'DarkGreen' => array( 0, 100, 0),
|
|
|
1152 |
'green' => array( 0, 255, 0),
|
|
|
1153 |
'YellowGreen' => array(154, 205, 50),
|
|
|
1154 |
'yellow' => array(255, 255, 0),
|
|
|
1155 |
'orange' => array(255, 165, 0),
|
|
|
1156 |
'gold' => array(255, 215, 0),
|
|
|
1157 |
'peru' => array(205, 133, 63),
|
|
|
1158 |
'beige' => array(245, 245, 220),
|
|
|
1159 |
'wheat' => array(245, 222, 179),
|
|
|
1160 |
'tan' => array(210, 180, 140),
|
|
|
1161 |
'brown' => array(165, 42, 42),
|
|
|
1162 |
'salmon' => array(250, 128, 114),
|
|
|
1163 |
'red' => array(255, 0, 0),
|
|
|
1164 |
'pink' => array(255, 192, 203),
|
|
|
1165 |
'maroon' => array(176, 48, 96),
|
|
|
1166 |
'magenta' => array(255, 0, 255),
|
|
|
1167 |
'violet' => array(238, 130, 238),
|
|
|
1168 |
'plum' => array(221, 160, 221),
|
|
|
1169 |
'orchid' => array(218, 112, 214),
|
|
|
1170 |
'purple' => array(160, 32, 240),
|
|
|
1171 |
'azure1' => array(240, 255, 255),
|
|
|
1172 |
'aquamarine1' => array(127, 255, 212)
|
|
|
1173 |
);
|
|
|
1174 |
} elseif ($which_color_array == 'large') { // Large color array
|
|
|
1175 |
if (!@include('rgb.inc.php')) {
|
|
|
1176 |
return $this->PrintError("SetRGBArray(): Large color map could not be loaded "
|
|
|
1177 |
. "from 'rgb.inc.php'.");
|
|
|
1178 |
}
|
|
|
1179 |
$this->rgb_array = $ColorArray;
|
|
|
1180 |
} else {
|
|
|
1181 |
return $this->PrintError("SetRGBArray(): Invalid color map selection");
|
|
|
1182 |
}
|
|
|
1183 |
|
|
|
1184 |
return TRUE;
|
|
|
1185 |
}
|
|
|
1186 |
|
|
|
1187 |
/**
|
|
|
1188 |
* Parses a color specification and returns the color component values
|
|
|
1189 |
*
|
|
|
1190 |
* Accepted color specification forms are (1) component array: array(R,G,B)
|
|
|
1191 |
* or array(R,G,B,A); (2) component string hexadecimal: "#RRGGBB" or
|
|
|
1192 |
* "#RRGGBBAA"; (3) A color name from the color map array with optional
|
|
|
1193 |
* alpha value suffix as ":alpha". R, G, and B are integers 0-255, and
|
|
|
1194 |
* Alpha is 0 (opaque) to 127 (transparent).
|
|
|
1195 |
*
|
|
|
1196 |
* @param string|int[] $color_asked Color spec to parse (color name, #rrggbb, (r,g,b) array, etc)
|
|
|
1197 |
* @param int $alpha Optional default alpha value (0-127, default 0 for opaque)
|
|
|
1198 |
* @return int[] Color component values as array (red, green, blue, alpha)
|
|
|
1199 |
* @deprecated Public use discouraged; intended for class internal use
|
|
|
1200 |
*/
|
|
|
1201 |
function SetRGBColor($color_asked, $alpha = 0)
|
|
|
1202 |
{
|
|
|
1203 |
if (empty($color_asked)) {
|
|
|
1204 |
$ret_val = array(0, 0, 0);
|
|
|
1205 |
|
|
|
1206 |
} elseif (is_array($color_asked) && (($n = count($color_asked)) == 3 || $n == 4) ) {
|
|
|
1207 |
// Already an array of 3 or 4 elements:
|
|
|
1208 |
$ret_val = $color_asked;
|
|
|
1209 |
|
|
|
1210 |
} elseif (preg_match('/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})?$/i',
|
|
|
1211 |
$color_asked, $ss)) {
|
|
|
1212 |
// #RRGGBB or #RRGGBBAA notation:
|
|
|
1213 |
$ret_val = array(hexdec($ss[1]), hexdec($ss[2]), hexdec($ss[3]));
|
|
|
1214 |
if (isset($ss[4])) $ret_val[] = hexdec($ss[4]);
|
|
|
1215 |
|
|
|
1216 |
} elseif (isset($this->rgb_array[$color_asked])) {
|
|
|
1217 |
// Color by name:
|
|
|
1218 |
$ret_val = $this->rgb_array[$color_asked];
|
|
|
1219 |
|
|
|
1220 |
} elseif (preg_match('/(.+):([\d]+)$/', $color_asked, $ss)
|
|
|
1221 |
&& isset($this->rgb_array[$ss[1]])) {
|
|
|
1222 |
// Color by name with ":alpha" suffix, alpha is a decimal number:
|
|
|
1223 |
$ret_val = $this->rgb_array[$ss[1]];
|
|
|
1224 |
$ret_val[3] = (int)$ss[2];
|
|
|
1225 |
|
|
|
1226 |
} else {
|
|
|
1227 |
return $this->PrintError("SetRGBColor(): Color '$color_asked' is not valid.");
|
|
|
1228 |
}
|
|
|
1229 |
|
|
|
1230 |
// Append alpha if not already provided for:
|
|
|
1231 |
if (count($ret_val) == 3)
|
|
|
1232 |
$ret_val[] = $alpha;
|
|
|
1233 |
return $ret_val;
|
|
|
1234 |
}
|
|
|
1235 |
|
|
|
1236 |
/**
|
|
|
1237 |
* Sets the colors used for plotting data sets, with optional default alpha value
|
|
|
1238 |
*
|
|
|
1239 |
* If passed an array, use the values as colors for sequential data sets.
|
|
|
1240 |
* If passed a single color specification, plot all data sets using that
|
|
|
1241 |
* single color.
|
|
|
1242 |
* Special use cases for the $which_data argument: Missing or NULL loads
|
|
|
1243 |
* the default data color map if no map is already set; an empty string or
|
|
|
1244 |
* False loads the default color map even if a color map is already set.
|
|
|
1245 |
* Note: The default value for $alpha here is NULL, not 0, so we can tell
|
|
|
1246 |
* if it was defaulted. But the effective default value is 0 (opaque).
|
|
|
1247 |
*
|
|
|
1248 |
* @param array|string $which_data Array of color specifications, or one color, or empty
|
|
|
1249 |
* @param array|string $which_border Data border colors, deprecated - use SetDataBorderColors() instead
|
|
|
1250 |
* @param int $alpha Default alpha to apply to all data colors that do not have an alpha value
|
|
|
1251 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1252 |
*/
|
|
|
1253 |
function SetDataColors($which_data = NULL, $which_border = NULL, $alpha = NULL)
|
|
|
1254 |
{
|
|
|
1255 |
if (is_array($which_data)) {
|
|
|
1256 |
$colors = $which_data; // Use supplied array
|
|
|
1257 |
} elseif (!empty($which_data)) {
|
|
|
1258 |
$colors = array($which_data); // Use supplied single color
|
|
|
1259 |
} elseif (empty($this->data_colors) || !is_null($which_data)) {
|
|
|
1260 |
$colors = $this->default_colors; // Use default color array
|
|
|
1261 |
} else {
|
|
|
1262 |
// which_data is NULL or missing and a color array is already set.
|
|
|
1263 |
// The existing color array is left alone, except that if $alpha is
|
|
|
1264 |
// given this will replace the alpha value of each existing color.
|
|
|
1265 |
// This makes SetDataColors(NULL, NULL, $alpha) work.
|
|
|
1266 |
if (isset($alpha)) {
|
|
|
1267 |
$n_colors = count($this->data_colors);
|
|
|
1268 |
for ($i = 0; $i < $n_colors; $i++) {
|
|
|
1269 |
$this->data_colors[$i][3] = $alpha; // Component 3 = alpha value
|
|
|
1270 |
}
|
|
|
1271 |
}
|
|
|
1272 |
// No need to reparse the colors or anything else.
|
|
|
1273 |
return TRUE;
|
|
|
1274 |
}
|
|
|
1275 |
|
|
|
1276 |
if (!isset($alpha))
|
|
|
1277 |
$alpha = 0; // Actual default is opaque colors.
|
|
|
1278 |
|
|
|
1279 |
// Check each color and convert to array (r,g,b,a) form.
|
|
|
1280 |
// Use the $alpha argument as a default for the alpha value of each color.
|
|
|
1281 |
$this->data_colors = array();
|
|
|
1282 |
foreach ($colors as $color) {
|
|
|
1283 |
$color_array = $this->SetRGBColor($color, $alpha);
|
|
|
1284 |
if (!$color_array) return FALSE; // SetRGBColor already did an error message.
|
|
|
1285 |
$this->data_colors[] = $color_array;
|
|
|
1286 |
}
|
|
|
1287 |
|
|
|
1288 |
// For past compatibility:
|
|
|
1289 |
return $this->SetDataBorderColors($which_border);
|
|
|
1290 |
}
|
|
|
1291 |
|
|
|
1292 |
/**
|
|
|
1293 |
* Sets the colors used for data borders in some plot types
|
|
|
1294 |
*
|
|
|
1295 |
* For plot types which support data borders, such as 'bars', this sets
|
|
|
1296 |
* the colors used for those borders. See also SetDrawDataBorders().
|
|
|
1297 |
* Special cases: If $which_br is missing or NULL, use the default of all
|
|
|
1298 |
* black if colors were not already set; if an empty string or False then
|
|
|
1299 |
* set the default of all black regardless.
|
|
|
1300 |
*
|
|
|
1301 |
* @param array|string $which_br Array of color specifications, or one color, or empty
|
|
|
1302 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1303 |
*/
|
|
|
1304 |
function SetDataBorderColors($which_br = NULL)
|
|
|
1305 |
{
|
|
|
1306 |
if (is_array($which_br)) {
|
|
|
1307 |
$colors = $which_br; // Use supplied array
|
|
|
1308 |
} elseif (!empty($which_br)) {
|
|
|
1309 |
$colors = array($which_br); // Use supplied single color
|
|
|
1310 |
} elseif (empty($this->data_border_colors) || !is_null($which_br)) {
|
|
|
1311 |
$colors = array('black'); // Use default
|
|
|
1312 |
} else {
|
|
|
1313 |
return TRUE; // Do nothing: which_br is NULL or missing and a color array is already set.
|
|
|
1314 |
}
|
|
|
1315 |
|
|
|
1316 |
// Check each color and convert to array (r,g,b,a) form.
|
|
|
1317 |
$this->data_border_colors = array();
|
|
|
1318 |
foreach ($colors as $color) {
|
|
|
1319 |
$color_array = $this->SetRGBColor($color);
|
|
|
1320 |
if (!$color_array) return FALSE; // SetRGBColor already did an error message.
|
|
|
1321 |
$this->data_border_colors[] = $color_array;
|
|
|
1322 |
}
|
|
|
1323 |
return TRUE;
|
|
|
1324 |
}
|
|
|
1325 |
|
|
|
1326 |
/**
|
|
|
1327 |
* Sets the colors used for data error bars
|
|
|
1328 |
*
|
|
|
1329 |
* Special cases for $which_err: Missing or NULL loads the default colors
|
|
|
1330 |
* (same as default data colors) if no colors are aleady set; an empty
|
|
|
1331 |
* string or False loads the default colors even if colors were already set.
|
|
|
1332 |
*
|
|
|
1333 |
* @param array|string $which_err Array of color specifications, or one color, or empty
|
|
|
1334 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1335 |
*/
|
|
|
1336 |
function SetErrorBarColors($which_err = NULL)
|
|
|
1337 |
{
|
|
|
1338 |
if (is_array($which_err)) {
|
|
|
1339 |
$colors = $which_err; // Use supplied array
|
|
|
1340 |
} elseif (!empty($which_err)) {
|
|
|
1341 |
$colors = array($which_err); // Use supplied single color
|
|
|
1342 |
} elseif (empty($this->error_bar_colors) || !is_null($which_err)) {
|
|
|
1343 |
$colors = $this->default_colors; // Use default color array
|
|
|
1344 |
} else {
|
|
|
1345 |
return TRUE; // Do nothing: which_err is NULL or missing and a color array is already set.
|
|
|
1346 |
}
|
|
|
1347 |
|
|
|
1348 |
// Check each color and convert to array (r,g,b,a) form.
|
|
|
1349 |
$this->error_bar_colors = array();
|
|
|
1350 |
foreach ($colors as $color) {
|
|
|
1351 |
$color_array = $this->SetRGBColor($color);
|
|
|
1352 |
if (!$color_array) return FALSE; // SetRGBColor already did an error message.
|
|
|
1353 |
$this->error_bar_colors[] = $color_array;
|
|
|
1354 |
}
|
|
|
1355 |
return TRUE;
|
|
|
1356 |
}
|
|
|
1357 |
|
|
|
1358 |
/**
|
|
|
1359 |
* Sets the default dashed line style (on/off pattern for dashed lines)
|
|
|
1360 |
*
|
|
|
1361 |
* For example: SetDashedStyle('2-3-1-2') means 2 dots of color, 3
|
|
|
1362 |
* transparent, 1 color, then 2 transparent.
|
|
|
1363 |
* This builds a template string $this->default_dashed_style which contains
|
|
|
1364 |
* a space-separated series of marker (#) for pixels on, and the value of
|
|
|
1365 |
* IMG_COLOR_TRANSPARENT for each pixel which is off.
|
|
|
1366 |
* See SetDashedStyle() for how it is used.
|
|
|
1367 |
*
|
|
|
1368 |
* @param string $which_style Dashed line specification, in the form <pixels_on>-<pixels_off>...
|
|
|
1369 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1370 |
*/
|
|
|
1371 |
function SetDefaultDashedStyle($which_style)
|
|
|
1372 |
{
|
|
|
1373 |
// Validate the argument as "(number)-(number)-..." with at least 2 numbers:
|
|
|
1374 |
if (!preg_match('/^\d+-\d+(-\d+)*$/', $which_style)) {
|
|
|
1375 |
return $this->PrintError("SetDefaultDashedStyle(): Wrong parameter '$which_style'.");
|
|
|
1376 |
}
|
|
|
1377 |
$result = '';
|
|
|
1378 |
$use_color = TRUE;
|
|
|
1379 |
$transparent = ' ' . IMG_COLOR_TRANSPARENT;
|
|
|
1380 |
// Expand the dashed line style specifier:
|
|
|
1381 |
foreach (explode('-', $which_style) as $n) {
|
|
|
1382 |
$result .= str_repeat($use_color ? ' #' : $transparent, $n);
|
|
|
1383 |
$use_color = !$use_color; // Alternate color and transparent
|
|
|
1384 |
}
|
|
|
1385 |
$this->default_dashed_style = ltrim($result);
|
|
|
1386 |
return TRUE;
|
|
|
1387 |
}
|
|
|
1388 |
|
|
|
1389 |
/**
|
|
|
1390 |
* Returns a GD line style for drawing patterned or solid lines
|
|
|
1391 |
*
|
|
|
1392 |
* This returns a value which can be used in GD when drawing lines.
|
|
|
1393 |
* If styles are off, it just returns the color supplied.
|
|
|
1394 |
* If styles are on, it applies the given color to the pre-set dashed
|
|
|
1395 |
* line style (see SetDefaultDashedStyle()) and sets that as the GD
|
|
|
1396 |
* line style, then returns the special GD code for drawing styled lines.
|
|
|
1397 |
*
|
|
|
1398 |
* @param int $which_ndxcol Color index to be used for drawing
|
|
|
1399 |
* @param bool $use_style TRUE or omit for dashed lines, FALSE for solid lines
|
|
|
1400 |
* @return int A GD color index for drawing: either $which_ndxcol or IMG_COLOR_STYLED
|
|
|
1401 |
*/
|
|
|
1402 |
protected function SetDashedStyle($which_ndxcol, $use_style = TRUE)
|
|
|
1403 |
{
|
|
|
1404 |
if (!$use_style)
|
|
|
1405 |
return $which_ndxcol; // Styles are off; use original color for drawing
|
|
|
1406 |
// Set the line style, substituting the specified color for the # marker:
|
|
|
1407 |
imagesetstyle($this->img, explode(' ', str_replace('#', $which_ndxcol, $this->default_dashed_style)));
|
|
|
1408 |
return IMG_COLOR_STYLED; // Use this value as the color for drawing
|
|
|
1409 |
}
|
|
|
1410 |
|
|
|
1411 |
/**
|
|
|
1412 |
* Sets line widths (thickness) for each data set
|
|
|
1413 |
*
|
|
|
1414 |
* @param int[]|int $which_lw Array of line widths in pixels, or a single value to use for all data sets
|
|
|
1415 |
* @return bool True always
|
|
|
1416 |
*/
|
|
|
1417 |
function SetLineWidths($which_lw=NULL)
|
|
|
1418 |
{
|
|
|
1419 |
if (is_array($which_lw)) {
|
|
|
1420 |
$this->line_widths = $which_lw; // Use provided array
|
|
|
1421 |
} elseif (!is_null($which_lw)) {
|
|
|
1422 |
$this->line_widths = array($which_lw); // Convert value to array
|
|
|
1423 |
}
|
|
|
1424 |
return TRUE;
|
|
|
1425 |
}
|
|
|
1426 |
|
|
|
1427 |
/**
|
|
|
1428 |
* Sets the line style (solid or dashed) for each data set
|
|
|
1429 |
*
|
|
|
1430 |
* @param string[]|string $which_ls Array or single keyword: solid | dashed | none
|
|
|
1431 |
* @return bool True always
|
|
|
1432 |
*/
|
|
|
1433 |
function SetLineStyles($which_ls=NULL)
|
|
|
1434 |
{
|
|
|
1435 |
if (is_array($which_ls)) {
|
|
|
1436 |
$this->line_styles = $which_ls; // Use provided array
|
|
|
1437 |
} elseif (!is_null($which_ls)) {
|
|
|
1438 |
$this->line_styles = ($which_ls) ? array($which_ls) : array('solid');
|
|
|
1439 |
}
|
|
|
1440 |
return TRUE;
|
|
|
1441 |
}
|
|
|
1442 |
|
|
|
1443 |
/////////////////////////////////////////////
|
|
|
1444 |
////////////// TEXT and FONTS
|
|
|
1445 |
/////////////////////////////////////////////
|
|
|
1446 |
|
|
|
1447 |
/**
|
|
|
1448 |
* Sets spacing between lines of multi-line labels
|
|
|
1449 |
*
|
|
|
1450 |
* @param int $which_spc Text line spacing factor (pixels for GD text, scale control for TTF text)
|
|
|
1451 |
* @return bool True always
|
|
|
1452 |
*/
|
|
|
1453 |
function SetLineSpacing($which_spc)
|
|
|
1454 |
{
|
|
|
1455 |
$this->line_spacing = $which_spc;
|
|
|
1456 |
return TRUE;
|
|
|
1457 |
}
|
|
|
1458 |
|
|
|
1459 |
/**
|
|
|
1460 |
* Sets the default font type
|
|
|
1461 |
*
|
|
|
1462 |
* @param bool $which_ttf True to default to TrueType fonts, False to default to GD (fixed) fonts
|
|
|
1463 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1464 |
*/
|
|
|
1465 |
function SetUseTTF($which_ttf)
|
|
|
1466 |
{
|
|
|
1467 |
$this->use_ttf = $which_ttf;
|
|
|
1468 |
return $this->SetDefaultFonts();
|
|
|
1469 |
}
|
|
|
1470 |
|
|
|
1471 |
/**
|
|
|
1472 |
* Sets the default TrueType font directory
|
|
|
1473 |
*
|
|
|
1474 |
* @param string $which_path Full path to a directory containing TrueType fonts
|
|
|
1475 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1476 |
*/
|
|
|
1477 |
function SetTTFPath($which_path)
|
|
|
1478 |
{
|
|
|
1479 |
if (!is_dir($which_path) || !is_readable($which_path)) {
|
|
|
1480 |
return $this->PrintError("SetTTFPath(): $which_path is not a valid path.");
|
|
|
1481 |
}
|
|
|
1482 |
$this->ttf_path = $which_path;
|
|
|
1483 |
return TRUE;
|
|
|
1484 |
}
|
|
|
1485 |
|
|
|
1486 |
/**
|
|
|
1487 |
* Sets the default TrueType font, and resets all elements to use that TrueType font and default sizes
|
|
|
1488 |
*
|
|
|
1489 |
* @param string $which_font Font filename or path; omit or NULL to use a default font
|
|
|
1490 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1491 |
*/
|
|
|
1492 |
function SetDefaultTTFont($which_font = NULL)
|
|
|
1493 |
{
|
|
|
1494 |
$this->default_ttfont = $which_font;
|
|
|
1495 |
return $this->SetUseTTF(TRUE);
|
|
|
1496 |
}
|
|
|
1497 |
|
|
|
1498 |
/**
|
|
|
1499 |
* Returns the default TrueType font name, searching for one if necessary
|
|
|
1500 |
*
|
|
|
1501 |
* If no default has been set, this tries some likely candidates for a font which
|
|
|
1502 |
* can be loaded. If it finds one that works, that becomes the default TT font.
|
|
|
1503 |
* If there is no default and it cannot find a working font, it falls back to
|
|
|
1504 |
* the original PHPlot default (which will not likely work either).
|
|
|
1505 |
*
|
|
|
1506 |
* @return string Default TrueType font filename or pathname
|
|
|
1507 |
* @since 5.1.3
|
|
|
1508 |
*/
|
|
|
1509 |
protected function GetDefaultTTFont()
|
|
|
1510 |
{
|
|
|
1511 |
if (!isset($this->default_ttfont)) {
|
|
|
1512 |
// No default font yet. Try some common sans-serif fonts.
|
|
|
1513 |
$fonts = array('LiberationSans-Regular.ttf', // For Linux with a correct GD font search path
|
|
|
1514 |
'Verdana.ttf', 'Arial.ttf', 'Helvetica.ttf', // For Windows, maybe others
|
|
|
1515 |
'liberation/LiberationSans-Regular.ttf', // For newer Ubuntu etc
|
|
|
1516 |
'ttf-liberation/LiberationSans-Regular.ttf', // For older Debian, Ubuntu, etc
|
|
|
1517 |
'benjamingothic.ttf', // Original PHPlot default
|
|
|
1518 |
);
|
|
|
1519 |
foreach ($fonts as $font) {
|
|
|
1520 |
// First try the font name alone, to see if GD can find and load it.
|
|
|
1521 |
if (@imagettfbbox(10, 0, $font, "1") !== False)
|
|
|
1522 |
break;
|
|
|
1523 |
// If the font wasn't found, try it with the default TTF path in front.
|
|
|
1524 |
$font_with_path = $this->ttf_path . DIRECTORY_SEPARATOR . $font;
|
|
|
1525 |
if (@imagettfbbox(10, 0, $font_with_path, "1") !== False) {
|
|
|
1526 |
$font = $font_with_path;
|
|
|
1527 |
break;
|
|
|
1528 |
}
|
|
|
1529 |
}
|
|
|
1530 |
// We either have a working font, or are using the last one regardless.
|
|
|
1531 |
$this->default_ttfont = $font;
|
|
|
1532 |
}
|
|
|
1533 |
return $this->default_ttfont;
|
|
|
1534 |
}
|
|
|
1535 |
|
|
|
1536 |
/**
|
|
|
1537 |
* Selects all the default font values and sizes
|
|
|
1538 |
*
|
|
|
1539 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1540 |
*/
|
|
|
1541 |
protected function SetDefaultFonts()
|
|
|
1542 |
{
|
|
|
1543 |
if ($this->use_ttf) {
|
|
|
1544 |
// Defaults for use of TrueType fonts:
|
|
|
1545 |
return $this->SetFontTTF('generic', '', 8)
|
|
|
1546 |
&& $this->SetFontTTF('title', '', 14)
|
|
|
1547 |
&& $this->SetFontTTF('legend', '', 8)
|
|
|
1548 |
&& $this->SetFontTTF('x_label', '', 6)
|
|
|
1549 |
&& $this->SetFontTTF('y_label', '', 6)
|
|
|
1550 |
&& $this->SetFontTTF('x_title', '', 10)
|
|
|
1551 |
&& $this->SetFontTTF('y_title', '', 10);
|
|
|
1552 |
}
|
|
|
1553 |
// Defaults for use of GD fonts:
|
|
|
1554 |
return $this->SetFontGD('generic', 2)
|
|
|
1555 |
&& $this->SetFontGD('title', 5)
|
|
|
1556 |
&& $this->SetFontGD('legend', 2)
|
|
|
1557 |
&& $this->SetFontGD('x_label', 1)
|
|
|
1558 |
&& $this->SetFontGD('y_label', 1)
|
|
|
1559 |
&& $this->SetFontGD('x_title', 3)
|
|
|
1560 |
&& $this->SetFontGD('y_title', 3);
|
|
|
1561 |
}
|
|
|
1562 |
|
|
|
1563 |
/**
|
|
|
1564 |
* Selects a GD (fixed) font to use for a plot element
|
|
|
1565 |
*
|
|
|
1566 |
* Available element names are: title legend generic x_label y_label x_title y_title
|
|
|
1567 |
*
|
|
|
1568 |
* @param string $which_elem Name of the element to change the font for
|
|
|
1569 |
* @param int|string $which_font GD font number: 1 2 3 4 or 5
|
|
|
1570 |
* @param int $which_spacing Optional spacing in pixels between text lines
|
|
|
1571 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1572 |
* @since 5.0.6
|
|
|
1573 |
*/
|
|
|
1574 |
function SetFontGD($which_elem, $which_font, $which_spacing = NULL)
|
|
|
1575 |
{
|
|
|
1576 |
if ($which_font < 1 || 5 < $which_font) {
|
|
|
1577 |
return $this->PrintError(__FUNCTION__ . ': Font size must be 1, 2, 3, 4 or 5');
|
|
|
1578 |
}
|
|
|
1579 |
if (!$this->CheckOption($which_elem,
|
|
|
1580 |
'generic, title, legend, x_label, y_label, x_title, y_title',
|
|
|
1581 |
__FUNCTION__)) {
|
|
|
1582 |
return FALSE;
|
|
|
1583 |
}
|
|
|
1584 |
|
|
|
1585 |
// Store the font parameters: name/size, char cell height and width.
|
|
|
1586 |
$this->fonts[$which_elem] = array('ttf' => FALSE,
|
|
|
1587 |
'font' => $which_font,
|
|
|
1588 |
'height' => ImageFontHeight($which_font),
|
|
|
1589 |
'width' => ImageFontWidth($which_font),
|
|
|
1590 |
'line_spacing' => $which_spacing);
|
|
|
1591 |
return TRUE;
|
|
|
1592 |
}
|
|
|
1593 |
|
|
|
1594 |
/**
|
|
|
1595 |
* Selects a TrueType font for to use for a plot element
|
|
|
1596 |
*
|
|
|
1597 |
* Available element names are: title legend generic x_label y_label x_title y_title
|
|
|
1598 |
*
|
|
|
1599 |
* @param string $which_elem Name of the element to change the font for
|
|
|
1600 |
* @param string $which_font TrueType font file or pathname; empty or NULL for the default font
|
|
|
1601 |
* @param int $which_size Optional font size in points (default 12)
|
|
|
1602 |
* @param int $which_spacing Optional line spacing adjustment factor
|
|
|
1603 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1604 |
* @since 5.0.6
|
|
|
1605 |
*/
|
|
|
1606 |
function SetFontTTF($which_elem, $which_font, $which_size = 12, $which_spacing = NULL)
|
|
|
1607 |
{
|
|
|
1608 |
if (!$this->CheckOption($which_elem,
|
|
|
1609 |
'generic, title, legend, x_label, y_label, x_title, y_title',
|
|
|
1610 |
__FUNCTION__)) {
|
|
|
1611 |
return FALSE;
|
|
|
1612 |
}
|
|
|
1613 |
|
|
|
1614 |
// Empty font name means use the default font.
|
|
|
1615 |
if (empty($which_font))
|
|
|
1616 |
$which_font = $this->GetDefaultTTFont();
|
|
|
1617 |
$path = $which_font;
|
|
|
1618 |
|
|
|
1619 |
// First try the font name directly, if not then try with path.
|
|
|
1620 |
// Use GD imagettfbbox() to determine if this is a valid font.
|
|
|
1621 |
// The return $bbox is used below, if valid.
|
|
|
1622 |
if (($bbox = @imagettfbbox($which_size, 0, $path, "E")) === False) {
|
|
|
1623 |
$path = $this->ttf_path . DIRECTORY_SEPARATOR . $which_font;
|
|
|
1624 |
if (($bbox = @imagettfbbox($which_size, 0, $path, "E")) === False) {
|
|
|
1625 |
return $this->PrintError(__FUNCTION__ . ": Can't find TrueType font $which_font");
|
|
|
1626 |
}
|
|
|
1627 |
}
|
|
|
1628 |
|
|
|
1629 |
// Calculate the font height and inherent line spacing. TrueType fonts have this information
|
|
|
1630 |
// internally, but PHP/GD has no way to directly access it. So get the bounding box size of
|
|
|
1631 |
// an upper-case character without descenders, and the baseline-to-baseline height.
|
|
|
1632 |
// Note: In practice, $which_size = $height, maybe +/-1 . But which_size is in points,
|
|
|
1633 |
// and height is in pixels, and someday GD may be able to tell the difference.
|
|
|
1634 |
// The character width is saved too, but not used by the normal text drawing routines - it
|
|
|
1635 |
// isn't necessarily a fixed-space font. It is used in DrawLegend.
|
|
|
1636 |
$height = $bbox[1] - $bbox[5];
|
|
|
1637 |
$width = $bbox[2] - $bbox[0];
|
|
|
1638 |
$bbox = ImageTTFBBox($which_size, 0, $path, "E\nE");
|
|
|
1639 |
$spacing = $bbox[1] - $bbox[5] - 2 * $height;
|
|
|
1640 |
|
|
|
1641 |
// Store the font parameters:
|
|
|
1642 |
$this->fonts[$which_elem] = array('ttf' => TRUE,
|
|
|
1643 |
'font' => $path,
|
|
|
1644 |
'size' => $which_size,
|
|
|
1645 |
'height' => $height,
|
|
|
1646 |
'width' => $width,
|
|
|
1647 |
'spacing' => $spacing,
|
|
|
1648 |
'line_spacing' => $which_spacing);
|
|
|
1649 |
return TRUE;
|
|
|
1650 |
}
|
|
|
1651 |
|
|
|
1652 |
/**
|
|
|
1653 |
* Selects which font to use for a plot element
|
|
|
1654 |
*
|
|
|
1655 |
* This uses either GD (fixed) or TrueType fonts, depending on the default text
|
|
|
1656 |
* font type as set with SetUseTTF().
|
|
|
1657 |
*
|
|
|
1658 |
* Available element names are: title legend generic x_label y_label x_title y_title
|
|
|
1659 |
*
|
|
|
1660 |
* @param string $which_elem Name of the element to change the font for
|
|
|
1661 |
* @param int|string $which_font For GD fonts, a font number; for TrueType, a font filename or pathname
|
|
|
1662 |
* @param int $which_size Optional font size in points for TrueType fonts, ignored for GD fonts
|
|
|
1663 |
* @param int $line_spacing Optional line spacing adjustment factor
|
|
|
1664 |
* @return bool True (False on error if an error handler returns True)
|
|
|
1665 |
*/
|
|
|
1666 |
function SetFont($which_elem, $which_font, $which_size = 12, $line_spacing = NULL)
|
|
|
1667 |
{
|
|
|
1668 |
if ($this->use_ttf)
|
|
|
1669 |
return $this->SetFontTTF($which_elem, $which_font, $which_size, $line_spacing);
|
|
|
1670 |
return $this->SetFontGD($which_elem, $which_font, $line_spacing);
|
|
|
1671 |
}
|
|
|
1672 |
|
|
|
1673 |
/**
|
|
|
1674 |
* Returns the inter-line spacing for a font
|
|
|
1675 |
*
|
|
|
1676 |
* @param array $font The font, specified as a PHPlot font array
|
|
|
1677 |
* @return int Spacing between text lines in pixels for text using this font
|
|
|
1678 |
* @since 5.0.6
|
|
|
1679 |
*/
|
|
|
1680 |
protected function GetLineSpacing($font)
|
|
|
1681 |
{
|
|
|
1682 |
// Use the per-font line spacing preference, if set, else the global value:
|
|
|
1683 |
if (isset($font['line_spacing']))
|
|
|
1684 |
$line_spacing = $font['line_spacing'];
|
|
|
1685 |
else
|
|
|
1686 |
$line_spacing = $this->line_spacing;
|
|
|
1687 |
|
|
|
1688 |
// For GD fonts, that is the spacing in pixels.
|
|
|
1689 |
// For TTF, adjust based on the 'natural' font spacing (see SetFontTTF):
|
|
|
1690 |
if ($font['ttf']) {
|
|
|
1691 |
$line_spacing = (int)($line_spacing * $font['spacing'] / 6.0);
|
|
|
1692 |
}
|
|
|
1693 |
return $line_spacing;
|
|
|
1694 |
}
|
|
|
1695 |
|
|
|
1696 |
/*
|
|
|
1697 |
* Text drawing and sizing functions:
|
|
|
1698 |
* ProcessText is meant for use only by DrawText and SizeText.
|
|
|
1699 |
* ProcessText(True, ...) - Draw a block of text
|
|
|
1700 |
* ProcessText(False, ...) - Just return ($width, $height) of
|
|
|
1701 |
* the orthogonal bounding box containing the text.
|
|
|
1702 |
* ProcessText is further split into separate functions for GD and TTF
|
|
|
1703 |
* text, due to the size of the code.
|
|
|
1704 |
*
|
|
|
1705 |
* Horizontal and vertical alignment are relative to the drawing. That is:
|
|
|
1706 |
* vertical text (90 deg) gets centered along Y position with
|
|
|
1707 |
* v_align = 'center', and adjusted to the right of X position with
|
|
|
1708 |
* h_align = 'right'. Another way to look at this is to say
|
|
|
1709 |
* that text rotation happens first, then alignment.
|
|
|
1710 |
*
|
|
|
1711 |
* Original multiple lines code submitted by Remi Ricard.
|
|
|
1712 |
* Original vertical code submitted by Marlin Viss.
|
|
|
1713 |
*
|
|
|
1714 |
* Text routines rewritten by ljb to fix alignment and position problems.
|
|
|
1715 |
* Here is my explanation and notes.
|
|
|
1716 |
*
|
|
|
1717 |
* + Process TTF text one line at a time, not as a block. (See below)
|
|
|
1718 |
* + Flipped top vs bottom vertical alignment. The usual interpretation
|
|
|
1719 |
* is: bottom align means bottom of the text is at the specified Y
|
|
|
1720 |
* coordinate. For some reason, PHPlot did left/right the correct way,
|
|
|
1721 |
* but had top/bottom reversed. I fixed it, and left the default valign
|
|
|
1722 |
* argument as bottom, but the meaning of the default value changed.
|
|
|
1723 |
*
|
|
|
1724 |
* For GD font text, only single-line text is handled by GD, and the
|
|
|
1725 |
* basepoint is the upper left corner of each text line.
|
|
|
1726 |
* For TTF text, multi-line text could be handled by GD, with the text
|
|
|
1727 |
* basepoint at the lower left corner of the first line of text.
|
|
|
1728 |
* (Behavior of TTF drawing routines on multi-line text is not documented.)
|
|
|
1729 |
* But you cannot do left/center/right alignment on each line that way,
|
|
|
1730 |
* or proper line spacing.
|
|
|
1731 |
* Therefore, for either text type, we have to break up the text into
|
|
|
1732 |
* lines and position each line independently.
|
|
|
1733 |
*
|
|
|
1734 |
* There are 9 alignment modes: Horizontal = left, center, or right, and
|
|
|
1735 |
* Vertical = top, center, or bottom. Alignment is interpreted relative to
|
|
|
1736 |
* the image, not as the text is read. This makes sense when you consider
|
|
|
1737 |
* for example X axis labels. They need to be centered below the marks
|
|
|
1738 |
* (center, top alignment) regardless of the text angle.
|
|
|
1739 |
* 'Bottom' alignment really means baseline alignment.
|
|
|
1740 |
*
|
|
|
1741 |
* GD font text is supported (by libgd) at 0 degrees and 90 degrees only.
|
|
|
1742 |
* Multi-line or single line text works with any of the 9 alignment modes.
|
|
|
1743 |
*
|
|
|
1744 |
* TTF text can be at any angle. The 9 alignment modes work for all angles,
|
|
|
1745 |
* but the results might not be what you expect for multi-line text. Alignment
|
|
|
1746 |
* applies to the orthogonal (aligned with X and Y axes) bounding box that
|
|
|
1747 |
* contains the text, and to each line in the multi-line text box. Since
|
|
|
1748 |
* alignment is relative to the image, 45 degree multi-line text aligns
|
|
|
1749 |
* differently from 46 degree text.
|
|
|
1750 |
*
|
|
|
1751 |
* Note that PHPlot allows multi-line text for the 3 titles, and they
|
|
|
1752 |
* are only drawn at 0 degrees (main and X titles) or 90 degrees (Y title).
|
|
|
1753 |
* Data labels can also be multi-line, and they can be drawn at any angle.
|
|
|
1754 |
* -ljb 2007-11-03
|
|
|
1755 |
*
|
|
|
1756 |
*/
|
|
|
1757 |
|
|
|
1758 |
/**
|
|
|
1759 |
* Draws or returns the size of a text string using GD fixed fonts
|
|
|
1760 |
*
|
|
|
1761 |
* This is intended for use only by ProcessText(). See notes there, but note that
|
|
|
1762 |
* the $font and alignment parameters are pre-processed there and differ here.
|
|
|
1763 |
* GD text only supports 0 and 90 degrees. This function treats an angle >= 45
|
|
|
1764 |
* as 90 degrees, and < 45 as 0 degrees.
|
|
|
1765 |
*
|
|
|
1766 |
* @param bool $draw_it True to draw the text, False to just return the orthogonal width and height
|
|
|
1767 |
* @param array $font A PHPlot font array (with 'ttf' = False)
|
|
|
1768 |
* @param float $angle Text angle in degrees. GD only supports 0 and 90.
|
|
|
1769 |
* @param int $x Reference point X coordinate for the text (ignored if $draw_it is False)
|
|
|
1770 |
* @param int $y Reference point Y coordinate for the text (ignored if $draw_it is False)
|
|
|
1771 |
* @param int $color GD color index to use for drawing the text (ignored if $draw_it is False)
|
|
|
1772 |
* @param string $text The text to draw or size (can have newlines \n within)
|
|
|
1773 |
* @param float $h_factor Horizontal alignment factor: 0=left|0.5=center|1=right (ignored if !$draw_it)
|
|
|
1774 |
* @param float $v_factor Vertical alignment factor: 0=top|0.5=center|1=bottom (ignored if !$draw_it)
|
|
|
1775 |
* @return bool|int[] True, if drawing text; an array of ($width, $height) if not.
|
|
|
1776 |
* @since 5.0.5
|
|
|
1777 |
*/
|
|
|
1778 |
protected function ProcessTextGD($draw_it, $font, $angle, $x, $y, $color, $text, $h_factor, $v_factor)
|
|
|
1779 |
{
|
|
|
1780 |
// Extract font parameters:
|
|
|
1781 |
$font_number = $font['font'];
|
|
|
1782 |
$font_width = $font['width'];
|
|
|
1783 |
$font_height = $font['height'];
|
|
|
1784 |
$line_spacing = $this->GetLineSpacing($font);
|
|
|
1785 |
|
|
|
1786 |
// Break up the text into lines, trim whitespace, find longest line.
|
|
|
1787 |
// Save the lines and length for drawing below.
|
|
|
1788 |
$longest = 0;
|
|
|
1789 |
foreach (explode("\n", $text) as $each_line) {
|
|
|
1790 |
$lines[] = $line = trim($each_line);
|
|
|
1791 |
$line_lens[] = $line_len = strlen($line);
|
|
|
1792 |
if ($line_len > $longest) $longest = $line_len;
|
|
|
1793 |
}
|
|
|
1794 |
$n_lines = count($lines);
|
|
|
1795 |
|
|
|
1796 |
// Width, height are based on font size and longest line, line count respectively.
|
|
|
1797 |
// These are relative to the text angle.
|
|
|
1798 |
$total_width = $longest * $font_width;
|
|
|
1799 |
$total_height = $n_lines * $font_height + ($n_lines - 1) * $line_spacing;
|
|
|
1800 |
|
|
|
1801 |
if (!$draw_it) {
|
|
|
1802 |
if ($angle < 45) return array($total_width, $total_height);
|
|
|
1803 |
return array($total_height, $total_width);
|
|
|
1804 |
}
|
|
|
1805 |
|
|
|
1806 |
$interline_step = $font_height + $line_spacing; // Line-to-line step
|
|
|
1807 |
|
|
|
1808 |
if ($angle >= 45) {
|
|
|
1809 |
// Vertical text (90 degrees):
|
|
|
1810 |
// (Remember the alignment convention with vertical text)
|
|
|
1811 |
// For 90 degree text, alignment factors change like this:
|
|
|
1812 |
$temp = $v_factor;
|
|
|
1813 |
$v_factor = $h_factor;
|
|
|
1814 |
$h_factor = 1 - $temp;
|
|
|
1815 |
|
|
|
1816 |
$draw_func = 'ImageStringUp';
|
|
|
1817 |
|
|
|
1818 |
// Rotation matrix "R" for 90 degrees (with Y pointing down):
|
|
|
1819 |
$r00 = 0; $r01 = 1;
|
|
|
1820 |
$r10 = -1; $r11 = 0;
|
|
|
1821 |
|
|
|
1822 |
} else {
|
|
|
1823 |
// Horizontal text (0 degrees):
|
|
|
1824 |
$draw_func = 'ImageString';
|
|
|
1825 |
|
|
|
1826 |
// Rotation matrix "R" for 0 degrees:
|
|
|
1827 |
$r00 = 1; $r01 = 0;
|
|
|
1828 |
$r10 = 0; $r11 = 1;
|
|
|
1829 |
}
|
|
|
1830 |
|
|
|
1831 |
// Adjust for vertical alignment (horizontal text) or horizontal alignment (vertical text):
|
|
|
1832 |
$factor = (int)($total_height * $v_factor);
|
|
|
1833 |
$xpos = $x - $r01 * $factor;
|
|
|
1834 |
$ypos = $y - $r11 * $factor;
|
|
|
1835 |
|
|
|
1836 |
// Debug callback provides the bounding box:
|
|
|
1837 |
if ($this->GetCallback('debug_textbox')) {
|
|
|
1838 |
if ($angle >= 45) {
|
|
|
1839 |
$bbox_width = $total_height;
|
|
|
1840 |
$bbox_height = $total_width;
|
|
|
1841 |
$px = $xpos;
|
|
|
1842 |
$py = $ypos - (1 - $h_factor) * $total_width;
|
|
|
1843 |
} else {
|
|
|
1844 |
$bbox_width = $total_width;
|
|
|
1845 |
$bbox_height = $total_height;
|
|
|
1846 |
$px = $xpos - $h_factor * $total_width;
|
|
|
1847 |
$py = $ypos;
|
|
|
1848 |
}
|
|
|
1849 |
$this->DoCallback('debug_textbox', $px, $py, $bbox_width, $bbox_height);
|
|
|
1850 |
}
|
|
|
1851 |
|
|
|
1852 |
for ($i = 0; $i < $n_lines; $i++) {
|
|
|
1853 |
|
|
|
1854 |
// Adjust for alignment of this line within the text block:
|
|
|
1855 |
$factor = (int)($line_lens[$i] * $font_width * $h_factor);
|
|
|
1856 |
$x = $xpos - $r00 * $factor;
|
|
|
1857 |
$y = $ypos - $r10 * $factor;
|
|
|
1858 |
|
|
|
1859 |
// Call ImageString or ImageStringUp:
|
|
|
1860 |
$draw_func($this->img, $font_number, $x, $y, $lines[$i], $color);
|
|
|
1861 |
|
|
|
1862 |
// Step to the next line of text. This is a rotation of (x=0, y=interline_spacing)
|
|
|
1863 |
$xpos += $r01 * $interline_step;
|
|
|
1864 |
$ypos += $r11 * $interline_step;
|
|
|
1865 |
}
|
|
|
1866 |
return TRUE;
|
|
|
1867 |
}
|
|
|
1868 |
|
|
|
1869 |
/**
|
|
|
1870 |
* Draws or returns the size of a text string using TrueType fonts (TTF)
|
|
|
1871 |
*
|
|
|
1872 |
* This is intended for use only by ProcessText(). See notes there, but note that
|
|
|
1873 |
* the $font and alignment parameters are pre-processed there and differ here.
|
|
|
1874 |
*
|
|
|
1875 |
* @param bool $draw_it True to draw the text, False to just return the orthogonal width and height
|
|
|
1876 |
* @param array $font A PHPlot font array (with 'ttf' = True)
|
|
|
1877 |
* @param float $angle Text angle in degrees
|
|
|
1878 |
* @param int $x Reference point X coordinate for the text (ignored if $draw_it is False)
|
|
|
1879 |
* @param int $y Reference point Y coordinate for the text (ignored if $draw_it is False)
|
|
|
1880 |
* @param int $color GD color index to use for drawing the text (ignored if $draw_it is False)
|
|
|
1881 |
* @param string $text The text to draw or size (can have newlines \n within)
|
|
|
1882 |
* @param float $h_factor Horizontal alignment factor: 0=left|0.5=center|1=right (ignored if !$draw_it)
|
|
|
1883 |
* @param float $v_factor Vertical alignment factor: 0=top|0.5=center|1=bottom (ignored if !$draw_it)
|
|
|
1884 |
* @return bool|int[] True, if drawing text; an array of ($width, $height) if not.
|
|
|
1885 |
* @since 5.0.5
|
|
|
1886 |
*/
|
|
|
1887 |
protected function ProcessTextTTF($draw_it, $font, $angle, $x, $y, $color, $text, $h_factor, $v_factor)
|
|
|
1888 |
{
|
|
|
1889 |
// Extract font parameters (see SetFontTTF):
|
|
|
1890 |
$font_file = $font['font'];
|
|
|
1891 |
$font_size = $font['size'];
|
|
|
1892 |
$font_height = $font['height'];
|
|
|
1893 |
$line_spacing = $this->GetLineSpacing($font);
|
|
|
1894 |
|
|
|
1895 |
// Break up the text into lines, trim whitespace.
|
|
|
1896 |
// Calculate the total width and height of the text box at 0 degrees.
|
|
|
1897 |
// Save the trimmed lines and their widths for later when drawing.
|
|
|
1898 |
// To get uniform spacing, don't use the actual line heights.
|
|
|
1899 |
// Total height = Font-specific line heights plus inter-line spacing.
|
|
|
1900 |
// Total width = width of widest line.
|
|
|
1901 |
// Last Line Descent is the offset from the bottom to the text baseline.
|
|
|
1902 |
// Note: For some reason, ImageTTFBBox uses (-1,-1) as the reference point.
|
|
|
1903 |
// So 1+bbox[1] is the baseline to bottom distance.
|
|
|
1904 |
$total_width = 0;
|
|
|
1905 |
$lastline_descent = 0;
|
|
|
1906 |
foreach (explode("\n", $text) as $each_line) {
|
|
|
1907 |
$lines[] = $line = trim($each_line);
|
|
|
1908 |
$bbox = ImageTTFBBox($font_size, 0, $font_file, $line);
|
|
|
1909 |
$line_widths[] = $width = $bbox[2] - $bbox[0];
|
|
|
1910 |
if ($width > $total_width) $total_width = $width;
|
|
|
1911 |
$lastline_descent = 1 + $bbox[1];
|
|
|
1912 |
}
|
|
|
1913 |
$n_lines = count($lines);
|
|
|
1914 |
$total_height = $n_lines * $font_height + ($n_lines - 1) * $line_spacing;
|
|
|
1915 |
|
|
|
1916 |
// Calculate the rotation matrix for the text's angle. Remember that GD points Y down,
|
|
|
1917 |
// so the sin() terms change sign.
|
|
|
1918 |
$theta = deg2rad($angle);
|
|
|
1919 |
$cos_t = cos($theta);
|
|
|
1920 |
$sin_t = sin($theta);
|
|
|
1921 |
$r00 = $cos_t; $r01 = $sin_t;
|
|
|
1922 |
$r10 = -$sin_t; $r11 = $cos_t;
|
|
|
1923 |
|
|
|
1924 |
// Make a bounding box of the right size, with upper left corner at (0,0).
|
|
|
1925 |
// By convention, the point order is: LL, LR, UR, UL.
|
|
|
1926 |
// Note this is still working with the text at 0 degrees.
|
|
|
1927 |
// When sizing text (SizeText), use the overall size with descenders.
|
|
|
1928 |
// This tells the caller how much room to leave for the text.
|
|
|
1929 |
// When drawing text (DrawText), use the size without descenders - that
|
|
|
1930 |
// is, down to the baseline. This is for accurate positioning.
|
|
|
1931 |
$b[0] = 0;
|
|
|
1932 |
if ($draw_it) {
|
|
|
1933 |
$b[1] = $total_height;
|
|
|
1934 |
} else {
|
|
|
1935 |
$b[1] = $total_height + $lastline_descent;
|
|
|
1936 |
}
|
|
|
1937 |
$b[2] = $total_width; $b[3] = $b[1];
|
|
|
1938 |
$b[4] = $total_width; $b[5] = 0;
|
|
|
1939 |
$b[6] = 0; $b[7] = 0;
|
|
|
1940 |
|
|
|
1941 |
// Rotate the bounding box, then offset to the reference point:
|
|
|
1942 |
for ($i = 0; $i < 8; $i += 2) {
|
|
|
1943 |
$x_b = $b[$i];
|
|
|
1944 |
$y_b = $b[$i+1];
|
|
|
1945 |
$c[$i] = $x + $r00 * $x_b + $r01 * $y_b;
|
|
|
1946 |
$c[$i+1] = $y + $r10 * $x_b + $r11 * $y_b;
|
|
|
1947 |
}
|
|
|
1948 |
|
|
|
1949 |
// Get an orthogonal (aligned with X and Y axes) bounding box around it, by
|
|
|
1950 |
// finding the min and max X and Y:
|
|
|
1951 |
$bbox_ref_x = $bbox_max_x = $c[0];
|
|
|
1952 |
$bbox_ref_y = $bbox_max_y = $c[1];
|
|
|
1953 |
for ($i = 2; $i < 8; $i += 2) {
|
|
|
1954 |
$x_b = $c[$i];
|
|
|
1955 |
if ($x_b < $bbox_ref_x) $bbox_ref_x = $x_b;
|
|
|
1956 |
elseif ($bbox_max_x < $x_b) $bbox_max_x = $x_b;
|
|
|
1957 |
$y_b = $c[$i+1];
|
|
|
1958 |
if ($y_b < $bbox_ref_y) $bbox_ref_y = $y_b;
|
|
|
1959 |
elseif ($bbox_max_y < $y_b) $bbox_max_y = $y_b;
|
|
|
1960 |
}
|
|
|
1961 |
$bbox_width = $bbox_max_x - $bbox_ref_x;
|
|
|
1962 |
$bbox_height = $bbox_max_y - $bbox_ref_y;
|
|
|
1963 |
|
|
|
1964 |
if (!$draw_it) {
|
|
|
1965 |
// Return the bounding box, rounded up (so it always contains the text):
|
|
|
1966 |
return array((int)ceil($bbox_width), (int)ceil($bbox_height));
|
|
|
1967 |
}
|
|
|
1968 |
|
|
|
1969 |
$interline_step = $font_height + $line_spacing; // Line-to-line step
|
|
|
1970 |
|
|
|
1971 |
// Calculate the offsets from the supplied reference point to the
|
|
|
1972 |
// upper-left corner of the text.
|
|
|
1973 |
// Start at the reference point at the upper left corner of the bounding
|
|
|
1974 |
// box (bbox_ref_x, bbox_ref_y) then adjust it for the 9 point alignment.
|
|
|
1975 |
// h,v_factor are 0,0 for top,left, .5,.5 for center,center, 1,1 for bottom,right.
|
|
|
1976 |
// $off_x = $bbox_ref_x + $bbox_width * $h_factor - $x;
|
|
|
1977 |
// $off_y = $bbox_ref_y + $bbox_height * $v_factor - $y;
|
|
|
1978 |
// Then use that offset to calculate back to the supplied reference point x, y
|
|
|
1979 |
// to get the text base point.
|
|
|
1980 |
// $qx = $x - $off_x;
|
|
|
1981 |
// $qy = $y - $off_y;
|
|
|
1982 |
// Reduces to:
|
|
|
1983 |
$qx = 2 * $x - $bbox_ref_x - $bbox_width * $h_factor;
|
|
|
1984 |
$qy = 2 * $y - $bbox_ref_y - $bbox_height * $v_factor;
|
|
|
1985 |
|
|
|
1986 |
// Check for debug callback. Don't calculate bounding box unless it is wanted.
|
|
|
1987 |
if ($this->GetCallback('debug_textbox')) {
|
|
|
1988 |
// Calculate the orthogonal bounding box coordinates for debug testing.
|
|
|
1989 |
|
|
|
1990 |
// qx, qy is upper left corner relative to the text.
|
|
|
1991 |
// Calculate px,py: upper left corner (absolute) of the bounding box.
|
|
|
1992 |
// There are 4 equation sets for this, depending on the quadrant:
|
|
|
1993 |
if ($sin_t > 0) {
|
|
|
1994 |
if ($cos_t > 0) {
|
|
|
1995 |
// Quadrant: 0d - 90d:
|
|
|
1996 |
$px = $qx; $py = $qy - $total_width * $sin_t;
|
|
|
1997 |
} else {
|
|
|
1998 |
// Quadrant: 90d - 180d:
|
|
|
1999 |
$px = $qx + $total_width * $cos_t; $py = $qy - $bbox_height;
|
|
|
2000 |
}
|
|
|
2001 |
} else {
|
|
|
2002 |
if ($cos_t < 0) {
|
|
|
2003 |
// Quadrant: 180d - 270d:
|
|
|
2004 |
$px = $qx - $bbox_width; $py = $qy + $total_height * $cos_t;
|
|
|
2005 |
} else {
|
|
|
2006 |
// Quadrant: 270d - 360d:
|
|
|
2007 |
$px = $qx + $total_height * $sin_t; $py = $qy;
|
|
|
2008 |
}
|
|
|
2009 |
}
|
|
|
2010 |
$this->DoCallback('debug_textbox', $px, $py, $bbox_width, $bbox_height);
|
|
|
2011 |
}
|
|
|
2012 |
|
|
|
2013 |
// Since alignment is applied after rotation, which parameter is used
|
|
|
2014 |
// to control alignment of each line within the text box varies with
|
|
|
2015 |
// the angle.
|
|
|
2016 |
// Angle (degrees): Line alignment controlled by:
|
|
|
2017 |
// -45 < angle <= 45 h_align
|
|
|
2018 |
// 45 < angle <= 135 reversed v_align
|
|
|
2019 |
// 135 < angle <= 225 reversed h_align
|
|
|
2020 |
// 225 < angle <= 315 v_align
|
|
|
2021 |
if ($cos_t >= $sin_t) {
|
|
|
2022 |
if ($cos_t >= -$sin_t) $line_align_factor = $h_factor;
|
|
|
2023 |
else $line_align_factor = $v_factor;
|
|
|
2024 |
} else {
|
|
|
2025 |
if ($cos_t >= -$sin_t) $line_align_factor = 1-$v_factor;
|
|
|
2026 |
else $line_align_factor = 1-$h_factor;
|
|
|
2027 |
}
|
|
|
2028 |
|
|
|
2029 |
// Now we have the start point, spacing and in-line alignment factor.
|
|
|
2030 |
// We are finally ready to start drawing the text, line by line.
|
|
|
2031 |
for ($i = 0; $i < $n_lines; $i++) {
|
|
|
2032 |
|
|
|
2033 |
// For drawing TTF text, the reference point is the left edge of the
|
|
|
2034 |
// text baseline (not the lower left corner of the bounding box).
|
|
|
2035 |
// The following also adjusts for horizontal (relative to
|
|
|
2036 |
// the text) alignment of the current line within the box.
|
|
|
2037 |
// What is happening is rotation of this vector by the text angle:
|
|
|
2038 |
// (x = (total_width - line_width) * factor, y = font_height)
|
|
|
2039 |
|
|
|
2040 |
$width_factor = ($total_width - $line_widths[$i]) * $line_align_factor;
|
|
|
2041 |
$rx = $qx + $r00 * $width_factor + $r01 * $font_height;
|
|
|
2042 |
$ry = $qy + $r10 * $width_factor + $r11 * $font_height;
|
|
|
2043 |
|
|
|
2044 |
// Finally, draw the text:
|
|
|
2045 |
ImageTTFText($this->img, $font_size, $angle, $rx, $ry, $color, $font_file, $lines[$i]);
|
|
|
2046 |
|
|
|
2047 |
// Step to position of next line.
|
|
|
2048 |
// This is a rotation of (x=0,y=height+line_spacing) by $angle:
|
|
|
2049 |
$qx += $r01 * $interline_step;
|
|
|
2050 |
$qy += $r11 * $interline_step;
|
|
|
2051 |
}
|
|
|
2052 |
return TRUE;
|
|
|
2053 |
}
|
|
|
2054 |
|
|
|
2055 |
/**
|
|
|
2056 |
* Draws or returns the size of a text string
|
|
|
2057 |
*
|
|
|
2058 |
* This is intended for use by DrawText() and SizeText() exclusively. It hides the
|
|
|
2059 |
* differences between GD and TTF text from those and higher level functions. It uses
|
|
|
2060 |
* either ProcessTextTTF() or ProcessTextGD() to do the actual drawing or sizing.
|
|
|
2061 |
*
|
|
|
2062 |
* @param bool $draw_it True to draw the text, False to just return the orthogonal width and height
|
|
|
2063 |
* @param string|array|null $font_id Text element name, empty or NULL for 'generic', or font array
|
|
|
2064 |
* @param float $angle Text angle in degrees
|
|
|
2065 |
* @param int $x Reference point X coordinate for the text (ignored if $draw_it is False)
|
|
|
2066 |
* @param int $y Reference point Y coordinate for the text (ignored if $draw_it is False)
|
|
|
2067 |
* @param int $color GD color index to use for drawing the text (ignored if $draw_it is False)
|
|
|
2068 |
* @param string $text The text to draw or size (can have newlines \n within)
|
|
|
2069 |
* @param string $halign Horizontal alignment: left | center | right (ignored if $draw_it is False)
|
|
|
2070 |
* @param string $valign Vertical alignment: top | center | bottom (ignored if $draw_it is False)
|
|
|
2071 |
* @return bool|int[] True, if drawing text; an array of ($width, $height) if not.
|
|
|
2072 |
*/
|
|
|
2073 |
protected function ProcessText($draw_it, $font_id, $angle, $x, $y, $color, $text, $halign, $valign)
|
|
|
2074 |
{
|
|
|
2075 |
// Empty text case:
|
|
|
2076 |
if ($text === '') {
|
|
|
2077 |
if ($draw_it) return TRUE;
|
|
|
2078 |
return array(0, 0);
|
|
|
2079 |
}
|
|
|
2080 |
|
|
|
2081 |
// Calculate width and height offset factors using the alignment args:
|
|
|
2082 |
if ($valign == 'top') $v_factor = 0;
|
|
|
2083 |
elseif ($valign == 'center') $v_factor = 0.5;
|
|
|
2084 |
else $v_factor = 1.0; // 'bottom'
|
|
|
2085 |
if ($halign == 'left') $h_factor = 0;
|
|
|
2086 |
elseif ($halign == 'center') $h_factor = 0.5;
|
|
|
2087 |
else $h_factor = 1.0; // 'right'
|
|
|
2088 |
|
|
|
2089 |
// Preferred usage for $font_id is a text element name (see SetFont()), but for compatibility
|
|
|
2090 |
// accept a font array too. For external (callback) usage, support a default font.
|
|
|
2091 |
if (is_array($font_id)) $font = $font_id; // Use supplied array; deprecated
|
|
|
2092 |
elseif (!empty($font_id) && isset($this->fonts[$font_id])) $font = $this->fonts[$font_id];
|
|
|
2093 |
else $font = $this->fonts['generic']; // Fallback default, or font_id is empty.
|
|
|
2094 |
|
|
|
2095 |
if ($font['ttf']) {
|
|
|
2096 |
return $this->ProcessTextTTF($draw_it, $font, $angle, $x, $y, $color, $text,
|
|
|
2097 |
$h_factor, $v_factor);
|
|
|
2098 |
}
|
|
|
2099 |
return $this->ProcessTextGD($draw_it, $font, $angle, $x, $y, $color, $text, $h_factor, $v_factor);
|
|
|
2100 |
}
|
|
|
2101 |
|
|
|
2102 |
/**
|
|
|
2103 |
* Draws a string of text on the plot
|
|
|
2104 |
*
|
|
|
2105 |
* Note: This function is mostly for internal use, and is not documented
|
|
|
2106 |
* for public use. But it can be legitimately used from a PHPlot callback.
|
|
|
2107 |
*
|
|
|
2108 |
* @param string|array|null $which_font Text element name, empty or NULL for 'generic', or font array
|
|
|
2109 |
* @param float $which_angle Text angle in degrees
|
|
|
2110 |
* @param int $which_xpos Reference point X coordinate for the text
|
|
|
2111 |
* @param int $which_ypos Reference point Y coordinate for the text
|
|
|
2112 |
* @param int $which_color GD color index to use for drawing the text
|
|
|
2113 |
* @param string $which_text The text to draw, with newlines (\n) between lines
|
|
|
2114 |
* @param string $which_halign Horizontal alignment (relative to the image): left | center | right
|
|
|
2115 |
* @param string $which_valign Vertical alignment (relative to the image): top | center | bottom
|
|
|
2116 |
* @return bool True always
|
|
|
2117 |
*/
|
|
|
2118 |
function DrawText($which_font, $which_angle, $which_xpos, $which_ypos, $which_color, $which_text,
|
|
|
2119 |
$which_halign = 'left', $which_valign = 'bottom')
|
|
|
2120 |
{
|
|
|
2121 |
return $this->ProcessText(TRUE,
|
|
|
2122 |
$which_font, $which_angle, $which_xpos, $which_ypos,
|
|
|
2123 |
$which_color, $which_text, $which_halign, $which_valign);
|
|
|
2124 |
}
|
|
|
2125 |
|
|
|
2126 |
/**
|
|
|
2127 |
* Calculates the size of block of text
|
|
|
2128 |
*
|
|
|
2129 |
* The returned size is the orthogonal width and height of a bounding
|
|
|
2130 |
* box aligned with the X and Y axes of the text. Only for angle=0 is
|
|
|
2131 |
* this the actual width and height of the text block, but for any angle
|
|
|
2132 |
* it is the amount of space needed to contain the text.
|
|
|
2133 |
* Note: This function is mostly for internal use, and is not documented
|
|
|
2134 |
* for public use. But it can be legitimately used from a PHPlot callback.
|
|
|
2135 |
*
|
|
|
2136 |
* @param string|array|null $which_font Text element name, empty or NULL for 'generic', or font array
|
|
|
2137 |
* @param float $which_angle Text angle in degrees
|
|
|
2138 |
* @param string $which_text The text to calculate size of
|
|
|
2139 |
* @return int[] A two element array ($width, $height) of the text
|
|
|
2140 |
*/
|
|
|
2141 |
function SizeText($which_font, $which_angle, $which_text)
|
|
|
2142 |
{
|
|
|
2143 |
// Color, position, and alignment are not used when calculating the size.
|
|
|
2144 |
return $this->ProcessText(FALSE,
|
|
|
2145 |
$which_font, $which_angle, 0, 0, 1, $which_text, '', '');
|
|
|
2146 |
}
|
|
|
2147 |
|
|
|
2148 |
/////////////////////////////////////////////
|
|
|
2149 |
/////////// INPUT / OUTPUT CONTROL
|
|
|
2150 |
/////////////////////////////////////////////
|
|
|
2151 |
|
|
|
2152 |
/**
|
|
|
2153 |
* Selects the graphic image format generated by DrawGraph()
|
|
|
2154 |
*
|
|
|
2155 |
* @param string $format The format to use: jpg | png | gif | wbmp
|
|
|
2156 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2157 |
*/
|
|
|
2158 |
function SetFileFormat($format)
|
|
|
2159 |
{
|
|
|
2160 |
$asked = $this->CheckOption($format, 'jpg, png, gif, wbmp', __FUNCTION__);
|
|
|
2161 |
if (!$asked) return FALSE;
|
|
|
2162 |
switch ($asked) {
|
|
|
2163 |
case 'jpg':
|
|
|
2164 |
$format_test = IMG_JPG;
|
|
|
2165 |
break;
|
|
|
2166 |
case 'png':
|
|
|
2167 |
$format_test = IMG_PNG;
|
|
|
2168 |
break;
|
|
|
2169 |
case 'gif':
|
|
|
2170 |
$format_test = IMG_GIF;
|
|
|
2171 |
break;
|
|
|
2172 |
case 'wbmp':
|
|
|
2173 |
$format_test = IMG_WBMP;
|
|
|
2174 |
break;
|
|
|
2175 |
}
|
|
|
2176 |
if (!(imagetypes() & $format_test)) {
|
|
|
2177 |
return $this->PrintError("SetFileFormat(): File format '$format' not supported");
|
|
|
2178 |
}
|
|
|
2179 |
$this->file_format = $asked;
|
|
|
2180 |
return TRUE;
|
|
|
2181 |
}
|
|
|
2182 |
|
|
|
2183 |
/**
|
|
|
2184 |
* Sets an image file to be used as the image background
|
|
|
2185 |
*
|
|
|
2186 |
* @param string $input_file Path to the file to be used (jpeg, png or gif)
|
|
|
2187 |
* @param string $mode Optional method for the background: centeredtile | tile | scale
|
|
|
2188 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2189 |
*/
|
|
|
2190 |
function SetBgImage($input_file, $mode='centeredtile')
|
|
|
2191 |
{
|
|
|
2192 |
$this->bgmode = $this->CheckOption($mode, 'tile, centeredtile, scale', __FUNCTION__);
|
|
|
2193 |
$this->bgimg = $input_file;
|
|
|
2194 |
return (boolean)$this->bgmode;
|
|
|
2195 |
}
|
|
|
2196 |
|
|
|
2197 |
/**
|
|
|
2198 |
* Sets an image file to be used as the plot area background
|
|
|
2199 |
*
|
|
|
2200 |
* @param string $input_file Path to the file to be used (jpeg, png or gif)
|
|
|
2201 |
* @param string $mode Optional method for the background: centeredtile | tile | scale
|
|
|
2202 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2203 |
*/
|
|
|
2204 |
function SetPlotAreaBgImage($input_file, $mode='tile')
|
|
|
2205 |
{
|
|
|
2206 |
$this->plotbgmode = $this->CheckOption($mode, 'tile, centeredtile, scale', __FUNCTION__);
|
|
|
2207 |
$this->plotbgimg = $input_file;
|
|
|
2208 |
return (boolean)$this->plotbgmode;
|
|
|
2209 |
}
|
|
|
2210 |
|
|
|
2211 |
/**
|
|
|
2212 |
* Redirects PHPlot output to a file
|
|
|
2213 |
*
|
|
|
2214 |
* Note: Output file has no effect unless SetIsInline(TRUE) is called.
|
|
|
2215 |
*
|
|
|
2216 |
* @param string $which_output_file Pathname of the file to write the image data into
|
|
|
2217 |
* @return bool True always
|
|
|
2218 |
*/
|
|
|
2219 |
function SetOutputFile($which_output_file)
|
|
|
2220 |
{
|
|
|
2221 |
if (isset($which_output_file) && $which_output_file !== '')
|
|
|
2222 |
$this->output_file = $which_output_file;
|
|
|
2223 |
else
|
|
|
2224 |
$this->output_file = NULL;
|
|
|
2225 |
return TRUE;
|
|
|
2226 |
}
|
|
|
2227 |
|
|
|
2228 |
/**
|
|
|
2229 |
* Sets the output image to be inline, without HTTP headers
|
|
|
2230 |
*
|
|
|
2231 |
* This will suppress the Content-Type headers that would otherwise be sent.
|
|
|
2232 |
*
|
|
|
2233 |
* @param bool $which_ii True to suppress HTTP headers, False to include the headers
|
|
|
2234 |
* @return bool True always
|
|
|
2235 |
*/
|
|
|
2236 |
function SetIsInline($which_ii)
|
|
|
2237 |
{
|
|
|
2238 |
$this->is_inline = (bool)$which_ii;
|
|
|
2239 |
return TRUE;
|
|
|
2240 |
}
|
|
|
2241 |
|
|
|
2242 |
/**
|
|
|
2243 |
* Gets the MIME type and GD output function name for the current file type
|
|
|
2244 |
*
|
|
|
2245 |
* @param string $mime_type Reference variable where the MIME type is returned
|
|
|
2246 |
* @param string $output_f Reference variable where the GD output function name is returned
|
|
|
2247 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2248 |
* @since 5.5.0
|
|
|
2249 |
*/
|
|
|
2250 |
protected function GetImageType(&$mime_type, &$output_f)
|
|
|
2251 |
{
|
|
|
2252 |
switch ($this->file_format) {
|
|
|
2253 |
case 'png':
|
|
|
2254 |
$mime_type = 'image/png';
|
|
|
2255 |
$output_f = 'imagepng';
|
|
|
2256 |
break;
|
|
|
2257 |
case 'jpg':
|
|
|
2258 |
$mime_type = 'image/jpeg';
|
|
|
2259 |
$output_f = 'imagejpeg';
|
|
|
2260 |
break;
|
|
|
2261 |
case 'gif':
|
|
|
2262 |
$mime_type = 'image/gif';
|
|
|
2263 |
$output_f = 'imagegif';
|
|
|
2264 |
break;
|
|
|
2265 |
case 'wbmp':
|
|
|
2266 |
$mime_type = 'image/wbmp';
|
|
|
2267 |
$output_f = 'imagewbmp';
|
|
|
2268 |
break;
|
|
|
2269 |
default:
|
|
|
2270 |
// Report the error on PrintImage, because that is where this code used to be.
|
|
|
2271 |
return $this->PrintError('PrintImage(): Please select an image type!');
|
|
|
2272 |
}
|
|
|
2273 |
return TRUE;
|
|
|
2274 |
}
|
|
|
2275 |
|
|
|
2276 |
/**
|
|
|
2277 |
* Tells the browser not to cache the image
|
|
|
2278 |
*
|
|
|
2279 |
* This is used by PrintImage, depending on SetBrowserCache(). It sends
|
|
|
2280 |
* HTTP headers that discourage browser-side caching.
|
|
|
2281 |
* Originally submitted by Thiemo Nagel. Modified to add more options based on mjpg-streamer.
|
|
|
2282 |
*
|
|
|
2283 |
* @return bool True always
|
|
|
2284 |
* @since 5.8.0
|
|
|
2285 |
*/
|
|
|
2286 |
protected function DisableCaching()
|
|
|
2287 |
{
|
|
|
2288 |
header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');
|
|
|
2289 |
header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . 'GMT');
|
|
|
2290 |
header('Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0');
|
|
|
2291 |
header('Pragma: no-cache');
|
|
|
2292 |
return TRUE;
|
|
|
2293 |
}
|
|
|
2294 |
|
|
|
2295 |
/**
|
|
|
2296 |
* Outputs the generated image to standard output or to a file
|
|
|
2297 |
*
|
|
|
2298 |
* This is automatically called by DrawGraph(), unless SetPrintImage(False) was used.
|
|
|
2299 |
*
|
|
|
2300 |
* @return bool True always
|
|
|
2301 |
*/
|
|
|
2302 |
function PrintImage()
|
|
|
2303 |
{
|
|
|
2304 |
if (!$this->browser_cache && !$this->is_inline)
|
|
|
2305 |
$this->DisableCaching();
|
|
|
2306 |
|
|
|
2307 |
// Get MIME type and GD output function name:
|
|
|
2308 |
if (!$this->GetImageType($mime_type, $output_f)) return FALSE;
|
|
|
2309 |
|
|
|
2310 |
if (!$this->is_inline) {
|
|
|
2311 |
Header("Content-type: $mime_type");
|
|
|
2312 |
}
|
|
|
2313 |
if ($this->is_inline && isset($this->output_file)) {
|
|
|
2314 |
$output_f($this->img, $this->output_file);
|
|
|
2315 |
} else {
|
|
|
2316 |
$output_f($this->img);
|
|
|
2317 |
}
|
|
|
2318 |
return TRUE;
|
|
|
2319 |
}
|
|
|
2320 |
|
|
|
2321 |
/**
|
|
|
2322 |
* Returns the image data as raw data, base64 encoded, or data URL (see RFC2397)
|
|
|
2323 |
*
|
|
|
2324 |
* @param string $encoding Optional encoding to use: dataurl (default) | raw | base64
|
|
|
2325 |
* @return string Encoded image data (False on error if error handler returns True)
|
|
|
2326 |
* @since 5.5.0
|
|
|
2327 |
*/
|
|
|
2328 |
function EncodeImage($encoding = 'dataurl')
|
|
|
2329 |
{
|
|
|
2330 |
$enc = $this->CheckOption($encoding, 'dataurl, raw, base64', __FUNCTION__);
|
|
|
2331 |
if (!$enc || !$this->GetImageType($mime_type, $output_f)) return FALSE;
|
|
|
2332 |
ob_start();
|
|
|
2333 |
$output_f($this->img);
|
|
|
2334 |
switch ($enc) {
|
|
|
2335 |
case 'raw':
|
|
|
2336 |
return ob_get_clean();
|
|
|
2337 |
case 'base64':
|
|
|
2338 |
return base64_encode(ob_get_clean());
|
|
|
2339 |
default: // 'dataurl', checked above.
|
|
|
2340 |
return "data:$mime_type;base64,\n" . chunk_split(base64_encode(ob_get_clean()));
|
|
|
2341 |
}
|
|
|
2342 |
}
|
|
|
2343 |
|
|
|
2344 |
/**
|
|
|
2345 |
* Draws a text message on the image, replacing the plot
|
|
|
2346 |
*
|
|
|
2347 |
* This is used for PHPlot error handling, and is available for
|
|
|
2348 |
* application-level error handling or other special purposes.
|
|
|
2349 |
* Options (keys in $options) are: draw_background draw_border force_print
|
|
|
2350 |
* reset_font text_color text_wrap wrap_width.
|
|
|
2351 |
* Default option values were chosen for fail-safe error-handling.
|
|
|
2352 |
*
|
|
|
2353 |
* @param string $text Text of the message to display in the image
|
|
|
2354 |
* @param string[] $options Optional associative array of control options
|
|
|
2355 |
* @return bool True always
|
|
|
2356 |
* @since 5.7.0
|
|
|
2357 |
*/
|
|
|
2358 |
function DrawMessage($text, $options = NULL)
|
|
|
2359 |
{
|
|
|
2360 |
// Merge options with defaults, and set as local variables:
|
|
|
2361 |
extract( array_merge( array(
|
|
|
2362 |
'draw_background' => FALSE, // Draw image background per SetBgImage(), SetBackgroundColor()
|
|
|
2363 |
'draw_border' => FALSE, // Draw image border as set with SetBorder*()
|
|
|
2364 |
'force_print' => TRUE, // Ignore SetPrintImage() setting and always output
|
|
|
2365 |
'reset_font' => TRUE, // Reset fonts (to avoid possible TTF error)
|
|
|
2366 |
'text_color' => '', // If not empty, text color specification
|
|
|
2367 |
'text_wrap' => TRUE, // Wrap the message text with wordwrap()
|
|
|
2368 |
'wrap_width' => 75, // Width in characters for wordwrap()
|
|
|
2369 |
), (array)$options));
|
|
|
2370 |
|
|
|
2371 |
// Do colors, background, and border:
|
|
|
2372 |
if ($draw_border && !isset($this->ndx_i_border) || $draw_background && !isset($this->ndx_bg_color))
|
|
|
2373 |
$this->SetBgColorIndexes();
|
|
|
2374 |
if ($draw_background) { // User-specified background
|
|
|
2375 |
$this->DrawBackground(TRUE); // TRUE means force overwriting of background
|
|
|
2376 |
} else { // Default to plain white background
|
|
|
2377 |
$bgcolor = imagecolorresolve($this->img, 255, 255, 255);
|
|
|
2378 |
ImageFilledRectangle($this->img, 0, 0, $this->image_width, $this->image_height, $bgcolor);
|
|
|
2379 |
}
|
|
|
2380 |
if ($draw_border) $this->DrawImageBorder(TRUE);
|
|
|
2381 |
if (empty($text_color)) $rgb = array(0, 0, 0);
|
|
|
2382 |
else $rgb = $this->SetRGBColor($text_color);
|
|
|
2383 |
$ndx_text_color = imagecolorresolve($this->img, $rgb[0], $rgb[1], $rgb[2]);
|
|
|
2384 |
|
|
|
2385 |
// Error images should reset fonts, to avoid chance of a TTF error when displaying an error.
|
|
|
2386 |
if ($reset_font) $this->SetUseTTF(FALSE);
|
|
|
2387 |
|
|
|
2388 |
// Determine the space needed for the text, and center the text box within the image:
|
|
|
2389 |
if ($text_wrap) $text = wordwrap($text, $wrap_width);
|
|
|
2390 |
list($text_width, $text_height) = $this->SizeText('generic', 0, $text);
|
|
|
2391 |
$x = max($this->safe_margin, ($this->image_width - $text_width) / 2);
|
|
|
2392 |
$y = max($this->safe_margin, ($this->image_height - $text_height) / 2);
|
|
|
2393 |
$this->DrawText('generic', 0, $x, $y, $ndx_text_color, $text, 'left', 'top');
|
|
|
2394 |
if ($force_print || $this->print_image) $this->PrintImage();
|
|
|
2395 |
return TRUE;
|
|
|
2396 |
}
|
|
|
2397 |
|
|
|
2398 |
/**
|
|
|
2399 |
* Handles a fatal error in PHPlot
|
|
|
2400 |
*
|
|
|
2401 |
* When a fatal error occurs (most often a parameter error in a function call),
|
|
|
2402 |
* PHPlot will normally produce an image containing the error message,
|
|
|
2403 |
* output the image, and then trigger a user-level error with the message.
|
|
|
2404 |
* (The error message has to be presented as an image, because the browser is
|
|
|
2405 |
* expecting an image.)
|
|
|
2406 |
* If no error handler is set up, PHP will log the message and exit.
|
|
|
2407 |
* If there is an error handler, and it returns TRUE, PrintError returns FALSE,
|
|
|
2408 |
* and this will be passed back up to the calling code as a FALSE return.
|
|
|
2409 |
*
|
|
|
2410 |
* @param string $error_message Text of the error message
|
|
|
2411 |
* @return bool False, but only if there is an error handler that returned TRUE.
|
|
|
2412 |
*/
|
|
|
2413 |
protected function PrintError($error_message)
|
|
|
2414 |
{
|
|
|
2415 |
// Be sure not to loop recursively, e.g. PrintError - PrintImage - PrintError.
|
|
|
2416 |
if (isset($this->in_error)) return FALSE;
|
|
|
2417 |
$this->in_error = TRUE;
|
|
|
2418 |
|
|
|
2419 |
// Output an image containing the error message:
|
|
|
2420 |
if (!$this->suppress_error_image) {
|
|
|
2421 |
// img will be empty if the error occurs very early - e.g. when allocating the image.
|
|
|
2422 |
if (!empty($this->img)) {
|
|
|
2423 |
$this->DrawMessage($error_message);
|
|
|
2424 |
} elseif (!$this->is_inline) {
|
|
|
2425 |
Header('HTTP/1.0 500 Internal Server Error');
|
|
|
2426 |
}
|
|
|
2427 |
}
|
|
|
2428 |
trigger_error($error_message, E_USER_ERROR);
|
|
|
2429 |
// This is only reached if the error handler returns TRUE
|
|
|
2430 |
unset($this->in_error);
|
|
|
2431 |
return FALSE;
|
|
|
2432 |
}
|
|
|
2433 |
|
|
|
2434 |
/**
|
|
|
2435 |
* Enables or disables error image production on failure
|
|
|
2436 |
*
|
|
|
2437 |
* @param bool $error_image True to enable the error image, False to disable it.
|
|
|
2438 |
* @return bool True always
|
|
|
2439 |
* @since 5.5.0
|
|
|
2440 |
*/
|
|
|
2441 |
function SetFailureImage($error_image)
|
|
|
2442 |
{
|
|
|
2443 |
$this->suppress_error_image = !$error_image;
|
|
|
2444 |
return TRUE;
|
|
|
2445 |
}
|
|
|
2446 |
|
|
|
2447 |
/**
|
|
|
2448 |
* Begins a Motion-JPEG (or other type) plot stream
|
|
|
2449 |
*
|
|
|
2450 |
* @return bool True always
|
|
|
2451 |
* @since 5.8.0
|
|
|
2452 |
*/
|
|
|
2453 |
function StartStream()
|
|
|
2454 |
{
|
|
|
2455 |
$this->GetImageType($mime_type, $this->stream_output_f);
|
|
|
2456 |
$this->stream_boundary = "PHPlot-Streaming-Frame"; // Arbitrary MIME boundary
|
|
|
2457 |
$this->stream_frame_header = "\r\n--$this->stream_boundary\r\nContent-Type: $mime_type\r\n";
|
|
|
2458 |
$this->DisableCaching(); // Send headers to disable browser-side caching
|
|
|
2459 |
header("Content-type: multipart/x-mixed-replace; boundary=\"$this->stream_boundary\"");
|
|
|
2460 |
return TRUE;
|
|
|
2461 |
}
|
|
|
2462 |
|
|
|
2463 |
/**
|
|
|
2464 |
* Ends a Motion-JPEG (or other type) plot stream
|
|
|
2465 |
*
|
|
|
2466 |
* @return bool True always
|
|
|
2467 |
* @since 5.8.0
|
|
|
2468 |
*/
|
|
|
2469 |
function EndStream()
|
|
|
2470 |
{
|
|
|
2471 |
echo "\r\n--$this->stream_boundary--\r\n";
|
|
|
2472 |
flush();
|
|
|
2473 |
return TRUE;
|
|
|
2474 |
}
|
|
|
2475 |
|
|
|
2476 |
/**
|
|
|
2477 |
* Outputs the generated plot as one frame in a plot stream
|
|
|
2478 |
*
|
|
|
2479 |
* @return bool True always
|
|
|
2480 |
* @since 5.8.0
|
|
|
2481 |
*/
|
|
|
2482 |
function PrintImageFrame()
|
|
|
2483 |
{
|
|
|
2484 |
ob_start();
|
|
|
2485 |
call_user_func($this->stream_output_f, $this->img);
|
|
|
2486 |
$size = ob_get_length();
|
|
|
2487 |
$frame = ob_get_clean();
|
|
|
2488 |
echo $this->stream_frame_header, "Content-Length: $size\r\n\r\n", $frame, "\r\n";
|
|
|
2489 |
flush();
|
|
|
2490 |
// This gets the next DrawGraph() to do background and titles again.
|
|
|
2491 |
$this->done = array();
|
|
|
2492 |
return TRUE;
|
|
|
2493 |
}
|
|
|
2494 |
|
|
|
2495 |
/////////////////////////////////////////////
|
|
|
2496 |
/////////// LABELS
|
|
|
2497 |
/////////////////////////////////////////////
|
|
|
2498 |
|
|
|
2499 |
/**
|
|
|
2500 |
* Positions and controls X data labels
|
|
|
2501 |
*
|
|
|
2502 |
* For vertical plots, these are X axis data labels, showing label strings from the data array.
|
|
|
2503 |
* Accepted positions are: plotdown, plotup, both, none.
|
|
|
2504 |
* For horizontal plots, these are X data value labels, show the data values.
|
|
|
2505 |
* Accepted positions are: plotin, plotstack, none.
|
|
|
2506 |
*
|
|
|
2507 |
* @param string $which_xdlp Desired label position: plotdown | plotup | both | none | plotin | plotstack
|
|
|
2508 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2509 |
*/
|
|
|
2510 |
function SetXDataLabelPos($which_xdlp)
|
|
|
2511 |
{
|
|
|
2512 |
$which_xdlp = $this->CheckOption($which_xdlp, 'plotdown, plotup, both, none, plotin, plotstack',
|
|
|
2513 |
__FUNCTION__);
|
|
|
2514 |
if (!$which_xdlp) return FALSE;
|
|
|
2515 |
$this->x_data_label_pos = $which_xdlp;
|
|
|
2516 |
|
|
|
2517 |
return TRUE;
|
|
|
2518 |
}
|
|
|
2519 |
|
|
|
2520 |
/**
|
|
|
2521 |
* Positions and controls Y data labels
|
|
|
2522 |
*
|
|
|
2523 |
* For vertical plots, these are Y data value labels, showing the data values.
|
|
|
2524 |
* Accepted positions are: plotin, plotstack, none.
|
|
|
2525 |
* For horizontal plots, these are Y axis data labels, showing label strings from the data array.
|
|
|
2526 |
* Accepted positions are: plotleft, plotright, both, none.
|
|
|
2527 |
*
|
|
|
2528 |
* @param string $which_ydlp Desired label position: plotleft | plotright | both | none | ...
|
|
|
2529 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2530 |
*/
|
|
|
2531 |
function SetYDataLabelPos($which_ydlp)
|
|
|
2532 |
{
|
|
|
2533 |
$which_ydlp = $this->CheckOption($which_ydlp, 'plotleft, plotright, both, none, plotin, plotstack',
|
|
|
2534 |
__FUNCTION__);
|
|
|
2535 |
if (!$which_ydlp) return FALSE;
|
|
|
2536 |
$this->y_data_label_pos = $which_ydlp;
|
|
|
2537 |
|
|
|
2538 |
return TRUE;
|
|
|
2539 |
}
|
|
|
2540 |
|
|
|
2541 |
/**
|
|
|
2542 |
* Positions the X tick labels
|
|
|
2543 |
*
|
|
|
2544 |
* @param string $which_xtlp Desired label position: plotdown | plotup | both | none | xaxis
|
|
|
2545 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2546 |
*/
|
|
|
2547 |
function SetXTickLabelPos($which_xtlp)
|
|
|
2548 |
{
|
|
|
2549 |
$which_xtlp = $this->CheckOption($which_xtlp, 'plotdown, plotup, both, xaxis, none',
|
|
|
2550 |
__FUNCTION__);
|
|
|
2551 |
if (!$which_xtlp) return FALSE;
|
|
|
2552 |
$this->x_tick_label_pos = $which_xtlp;
|
|
|
2553 |
|
|
|
2554 |
return TRUE;
|
|
|
2555 |
}
|
|
|
2556 |
|
|
|
2557 |
/**
|
|
|
2558 |
* Positions the Y tick labels
|
|
|
2559 |
*
|
|
|
2560 |
* @param string $which_ytlp Desired label position: plotleft | plotright | both | none | yaxis
|
|
|
2561 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2562 |
*/
|
|
|
2563 |
function SetYTickLabelPos($which_ytlp)
|
|
|
2564 |
{
|
|
|
2565 |
$which_ytlp = $this->CheckOption($which_ytlp, 'plotleft, plotright, both, yaxis, none',
|
|
|
2566 |
__FUNCTION__);
|
|
|
2567 |
if (!$which_ytlp) return FALSE;
|
|
|
2568 |
$this->y_tick_label_pos = $which_ytlp;
|
|
|
2569 |
|
|
|
2570 |
return TRUE;
|
|
|
2571 |
}
|
|
|
2572 |
|
|
|
2573 |
/**
|
|
|
2574 |
* Sets the formatting type for tick, data, or pie chart labels
|
|
|
2575 |
*
|
|
|
2576 |
* This implements SetXLabelType(), SetYLabelType(), SetXYDataLabelType(), SetYDataLabelType(),
|
|
|
2577 |
* and part of SetPieLabelType(). Those functions combine their arguments into an array and
|
|
|
2578 |
* pass the array to this function as $args.
|
|
|
2579 |
*
|
|
|
2580 |
* $mode='x' or 'y' set the type for tick labels, and the default type for data labels
|
|
|
2581 |
* if they are not separately configured. $mode='xd' or 'yd' set the type for data labels.
|
|
|
2582 |
* $mode='p' sets the type for pie chart labels.
|
|
|
2583 |
*
|
|
|
2584 |
* $args[0] sets the formatting type: 'data' | 'time' | 'printf' | 'custom' | empty.
|
|
|
2585 |
* If this is missing or empty, the default formatting for $mode is restored.
|
|
|
2586 |
* Additional values in $args[] depend on the formatting type. All further paramters except
|
|
|
2587 |
* for the callback are optional.
|
|
|
2588 |
* For type='data': $args[1] = precision, $args[2] = prefix, $args[3] = suffix.
|
|
|
2589 |
* For type 'time': $args[1] = format string for strftime().
|
|
|
2590 |
* For type 'printf': $args[1:3] = 1, 2, or 3 format strings for sprintf().
|
|
|
2591 |
* For type 'custom': $args[1] = the callback (required), $args[2] = pass-through argument.
|
|
|
2592 |
*
|
|
|
2593 |
* @param string $mode Which label type to configure: x | y | xd | yd | p
|
|
|
2594 |
* @param array $args Additional arguments controlling the format type
|
|
|
2595 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2596 |
*/
|
|
|
2597 |
protected function SetLabelType($mode, $args)
|
|
|
2598 |
{
|
|
|
2599 |
if (!$this->CheckOption($mode, 'x, y, xd, yd, p', __FUNCTION__))
|
|
|
2600 |
return FALSE;
|
|
|
2601 |
|
|
|
2602 |
$type = isset($args[0]) ? $args[0] : '';
|
|
|
2603 |
$format = &$this->label_format[$mode]; // Shorthand reference to format storage variables
|
|
|
2604 |
switch ($type) {
|
|
|
2605 |
case 'data':
|
|
|
2606 |
if (isset($args[1]))
|
|
|
2607 |
$format['precision'] = $args[1];
|
|
|
2608 |
elseif (!isset($format['precision']))
|
|
|
2609 |
$format['precision'] = 1;
|
|
|
2610 |
$format['prefix'] = isset($args[2]) ? $args[2] : '';
|
|
|
2611 |
$format['suffix'] = isset($args[3]) ? $args[3] : '';
|
|
|
2612 |
break;
|
|
|
2613 |
|
|
|
2614 |
case 'time':
|
|
|
2615 |
if (isset($args[1]))
|
|
|
2616 |
$format['time_format'] = $args[1];
|
|
|
2617 |
elseif (!isset($format['time_format']))
|
|
|
2618 |
$format['time_format'] = '%H:%M:%S';
|
|
|
2619 |
break;
|
|
|
2620 |
|
|
|
2621 |
case 'printf':
|
|
|
2622 |
if (isset($args[1]))
|
|
|
2623 |
// Accept 1, 2, or 3 format strings (see FormatLabel)
|
|
|
2624 |
$format['printf_format'] = array_slice($args, 1, 3);
|
|
|
2625 |
elseif (!isset($format['printf_format']))
|
|
|
2626 |
$format['printf_format'] = '%e';
|
|
|
2627 |
break;
|
|
|
2628 |
|
|
|
2629 |
case 'custom':
|
|
|
2630 |
if (isset($args[1])) {
|
|
|
2631 |
$format['custom_callback'] = $args[1];
|
|
|
2632 |
$format['custom_arg'] = isset($args[2]) ? $args[2] : NULL;
|
|
|
2633 |
} else {
|
|
|
2634 |
$type = ''; // Error, 'custom' without a function, set to no-format mode.
|
|
|
2635 |
}
|
|
|
2636 |
break;
|
|
|
2637 |
|
|
|
2638 |
case '':
|
|
|
2639 |
case 'title': // Retained for backwards compatibility?
|
|
|
2640 |
break;
|
|
|
2641 |
|
|
|
2642 |
default:
|
|
|
2643 |
$this->CheckOption($type, 'data, time, printf, custom', __FUNCTION__);
|
|
|
2644 |
$type = '';
|
|
|
2645 |
}
|
|
|
2646 |
$format['type'] = $type;
|
|
|
2647 |
return (boolean)$type;
|
|
|
2648 |
}
|
|
|
2649 |
|
|
|
2650 |
/**
|
|
|
2651 |
* Sets formatting mode for X tick labels, and default for X data labels
|
|
|
2652 |
*
|
|
|
2653 |
* @param string $type Formatting mode: data | time | printf | custom, or '' to reset to default
|
|
|
2654 |
* @param mixed $varargs One or more additional arguments that depend on $type
|
|
|
2655 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2656 |
*/
|
|
|
2657 |
function SetXLabelType($type=NULL, $varargs=NULL) // Variable arguments
|
|
|
2658 |
{
|
|
|
2659 |
$args = func_get_args();
|
|
|
2660 |
return $this->SetLabelType('x', $args);
|
|
|
2661 |
}
|
|
|
2662 |
|
|
|
2663 |
/**
|
|
|
2664 |
* Sets formatting mode for X data labels (overriding any mode set with SetXLabelType)
|
|
|
2665 |
*
|
|
|
2666 |
* @param string $type Formatting mode: data | time | printf | custom, or '' to reset to default
|
|
|
2667 |
* @param mixed $varargs One or more additional arguments that depend on $type
|
|
|
2668 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2669 |
* @since 5.1.0
|
|
|
2670 |
*/
|
|
|
2671 |
function SetXDataLabelType($type=NULL, $varargs=NULL) // Variable arguments, named params are unused
|
|
|
2672 |
{
|
|
|
2673 |
$args = func_get_args();
|
|
|
2674 |
return $this->SetLabelType('xd', $args);
|
|
|
2675 |
}
|
|
|
2676 |
|
|
|
2677 |
/**
|
|
|
2678 |
* Sets formatting mode for Y tick labels, and default for Y data labels
|
|
|
2679 |
*
|
|
|
2680 |
* @param string $type Formatting mode: data | time | printf | custom, or '' to reset to default
|
|
|
2681 |
* @param mixed $varargs One or more additional arguments that depend on $type
|
|
|
2682 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2683 |
*/
|
|
|
2684 |
function SetYLabelType($type=NULL, $varargs=NULL) // Variable arguments, named params are unused
|
|
|
2685 |
{
|
|
|
2686 |
$args = func_get_args();
|
|
|
2687 |
return $this->SetLabelType('y', $args);
|
|
|
2688 |
}
|
|
|
2689 |
|
|
|
2690 |
/**
|
|
|
2691 |
* Sets formatting mode for Y data labels (overriding any mode set with SetYLabelType)
|
|
|
2692 |
*
|
|
|
2693 |
* @param string $type Formatting mode: data | time | printf | custom, or '' to reset to default
|
|
|
2694 |
* @param mixed $varargs One or more additional arguments that depend on $type
|
|
|
2695 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2696 |
* @since 5.1.0
|
|
|
2697 |
*/
|
|
|
2698 |
function SetYDataLabelType($type=NULL, $varargs=NULL) // Variable arguments, named params are unused
|
|
|
2699 |
{
|
|
|
2700 |
$args = func_get_args();
|
|
|
2701 |
return $this->SetLabelType('yd', $args);
|
|
|
2702 |
}
|
|
|
2703 |
|
|
|
2704 |
/**
|
|
|
2705 |
* Sets type and formatting mode for pie chart labels.
|
|
|
2706 |
*
|
|
|
2707 |
* @param string|string[] $source_ Label source keyword or array: percent | value | label | index | ''
|
|
|
2708 |
* @param string $type Optional formatting mode: data | printf | custom
|
|
|
2709 |
* @param mixed $varargs Zero or more additional arguments telling how to format the label
|
|
|
2710 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2711 |
* @since 5.6.0
|
|
|
2712 |
*/
|
|
|
2713 |
function SetPieLabelType($source_, $type=NULL, $varargs=NULL) // Variable arguments, named params unused
|
|
|
2714 |
{
|
|
|
2715 |
$args = func_get_args();
|
|
|
2716 |
$source = array_shift($args);
|
|
|
2717 |
if (empty($source)) {
|
|
|
2718 |
$this->pie_label_source = NULL; // Restore default
|
|
|
2719 |
$args = array(''); // See below - tells SetLabelType to do no formatting or default.
|
|
|
2720 |
} else {
|
|
|
2721 |
$this->pie_label_source = $this->CheckOptionArray($source, 'percent, value, label, index',
|
|
|
2722 |
__FUNCTION__);
|
|
|
2723 |
if (empty($this->pie_label_source)) return FALSE;
|
|
|
2724 |
}
|
|
|
2725 |
return $this->SetLabelType('p', $args);
|
|
|
2726 |
}
|
|
|
2727 |
|
|
|
2728 |
/**
|
|
|
2729 |
* Sets the date/time formatting string for X labels
|
|
|
2730 |
*
|
|
|
2731 |
* This does not enable date/time formatting. For that you need to use
|
|
|
2732 |
* SetXLabelType('time'). But since you can pass the formatting string
|
|
|
2733 |
* to SetXLabelType() also, there is no need to use SetXTimeFormat().
|
|
|
2734 |
*
|
|
|
2735 |
* @param string $which_xtf Formatting string to use (see PHP function strftime())
|
|
|
2736 |
* @return bool True always
|
|
|
2737 |
*/
|
|
|
2738 |
function SetXTimeFormat($which_xtf)
|
|
|
2739 |
{
|
|
|
2740 |
$this->label_format['x']['time_format'] = $which_xtf;
|
|
|
2741 |
return TRUE;
|
|
|
2742 |
}
|
|
|
2743 |
|
|
|
2744 |
/**
|
|
|
2745 |
* Sets the date/time formatting string for Y labels
|
|
|
2746 |
*
|
|
|
2747 |
* This does not enable date/time formatting. For that you need to use
|
|
|
2748 |
* SetYLabelType('time'). But since you can pass the formatting string
|
|
|
2749 |
* to SetYLabelType() also, there is no need to use SetYTimeFormat().
|
|
|
2750 |
*
|
|
|
2751 |
* @param string $which_ytf Formatting string (see PHP function strftime())
|
|
|
2752 |
* @return bool True always
|
|
|
2753 |
*/
|
|
|
2754 |
function SetYTimeFormat($which_ytf)
|
|
|
2755 |
{
|
|
|
2756 |
$this->label_format['y']['time_format'] = $which_ytf;
|
|
|
2757 |
return TRUE;
|
|
|
2758 |
}
|
|
|
2759 |
|
|
|
2760 |
/**
|
|
|
2761 |
* Sets the separators used when formatting number labels
|
|
|
2762 |
*
|
|
|
2763 |
* Separators are used with 'data' label formatting. The defaults
|
|
|
2764 |
* are set from the system locale (if available).
|
|
|
2765 |
*
|
|
|
2766 |
* @param string $decimal_point The character to use as a decimal point
|
|
|
2767 |
* @param string $thousands_sep The character to use as a thousands grouping separator
|
|
|
2768 |
* @return bool True always
|
|
|
2769 |
* @since 5.0.4
|
|
|
2770 |
*/
|
|
|
2771 |
function SetNumberFormat($decimal_point, $thousands_sep)
|
|
|
2772 |
{
|
|
|
2773 |
$this->decimal_point = $decimal_point;
|
|
|
2774 |
$this->thousands_sep = $thousands_sep;
|
|
|
2775 |
return TRUE;
|
|
|
2776 |
}
|
|
|
2777 |
|
|
|
2778 |
/**
|
|
|
2779 |
* Sets the text angle for X tick labels, and the default angle for X data labels
|
|
|
2780 |
*
|
|
|
2781 |
* @param float $which_xla Desired angle for label text, in degrees
|
|
|
2782 |
* @return bool True always
|
|
|
2783 |
*/
|
|
|
2784 |
function SetXLabelAngle($which_xla)
|
|
|
2785 |
{
|
|
|
2786 |
$this->x_label_angle = $which_xla;
|
|
|
2787 |
return TRUE;
|
|
|
2788 |
}
|
|
|
2789 |
|
|
|
2790 |
/**
|
|
|
2791 |
* Sets the text angle for Y tick labels
|
|
|
2792 |
*
|
|
|
2793 |
* Note: Unlike SetXLabelAngle(), this does not also apply to data labels.
|
|
|
2794 |
*
|
|
|
2795 |
* @param float $which_yla Desired angle for label text, in degrees
|
|
|
2796 |
* @return bool True always
|
|
|
2797 |
*/
|
|
|
2798 |
function SetYLabelAngle($which_yla)
|
|
|
2799 |
{
|
|
|
2800 |
$this->y_label_angle = $which_yla;
|
|
|
2801 |
return TRUE;
|
|
|
2802 |
}
|
|
|
2803 |
|
|
|
2804 |
/**
|
|
|
2805 |
* Sets the text angle for X data labels (overriding an angle set with SetXLabelAngle)
|
|
|
2806 |
*
|
|
|
2807 |
* @param float $which_xdla Desired angle for label text, in degrees
|
|
|
2808 |
* @return bool True always
|
|
|
2809 |
* @since 5.1.0
|
|
|
2810 |
*/
|
|
|
2811 |
function SetXDataLabelAngle($which_xdla)
|
|
|
2812 |
{
|
|
|
2813 |
$this->x_data_label_angle_u = $which_xdla;
|
|
|
2814 |
return TRUE;
|
|
|
2815 |
}
|
|
|
2816 |
|
|
|
2817 |
/**
|
|
|
2818 |
* Sets the angle for Y data labels
|
|
|
2819 |
*
|
|
|
2820 |
* @param float $which_ydla Desired angle for label text, in degrees
|
|
|
2821 |
* @return bool True always
|
|
|
2822 |
* @since 5.1.0
|
|
|
2823 |
*/
|
|
|
2824 |
function SetYDataLabelAngle($which_ydla)
|
|
|
2825 |
{
|
|
|
2826 |
$this->y_data_label_angle = $which_ydla;
|
|
|
2827 |
return TRUE;
|
|
|
2828 |
}
|
|
|
2829 |
|
|
|
2830 |
/////////////////////////////////////////////
|
|
|
2831 |
/////////// MISC
|
|
|
2832 |
/////////////////////////////////////////////
|
|
|
2833 |
|
|
|
2834 |
/**
|
|
|
2835 |
* Checks the validity of an option (a multiple-choice function parameter)
|
|
|
2836 |
*
|
|
|
2837 |
* @param string $which_opt String to check, usually the provided value of a function argument
|
|
|
2838 |
* @param string $which_acc String of accepted choices, lower-case, choices separated by comma space
|
|
|
2839 |
* @param string $which_func Name of the calling function, for error messages, usually __FUNCTION__
|
|
|
2840 |
* @return string|null Downcased/trimmed option value if valid; NULL on error if error handler returns
|
|
|
2841 |
*/
|
|
|
2842 |
protected function CheckOption($which_opt, $which_acc, $which_func)
|
|
|
2843 |
{
|
|
|
2844 |
$asked = strtolower(trim($which_opt));
|
|
|
2845 |
|
|
|
2846 |
// Look for the supplied value in a comma/space separated list.
|
|
|
2847 |
if (strpos(", $which_acc,", ", $asked,") !== FALSE)
|
|
|
2848 |
return $asked;
|
|
|
2849 |
|
|
|
2850 |
$this->PrintError("$which_func(): '$which_opt' not in available choices: '$which_acc'.");
|
|
|
2851 |
return NULL;
|
|
|
2852 |
}
|
|
|
2853 |
|
|
|
2854 |
/**
|
|
|
2855 |
* Checks the validity of an array of options (multiple-choice function parameters)
|
|
|
2856 |
*
|
|
|
2857 |
* This is used to validate arguments to functions that accept either a single value
|
|
|
2858 |
* or an array of values (example: SetPlotBorderType).
|
|
|
2859 |
*
|
|
|
2860 |
* @param string|string[] $opt String or array of strings to check
|
|
|
2861 |
* @param string $acc String of accepted choices, lower-case, choices separated by comma space
|
|
|
2862 |
* @param string $func Name of the calling function, for error messages, usually __FUNCTION__
|
|
|
2863 |
* @return string[]|null Downcased/trimmed option values if valid; NULL on error if error handler returns
|
|
|
2864 |
* @since 5.1.2
|
|
|
2865 |
*/
|
|
|
2866 |
protected function CheckOptionArray($opt, $acc, $func)
|
|
|
2867 |
{
|
|
|
2868 |
$opt_array = (array)$opt;
|
|
|
2869 |
$result = array();
|
|
|
2870 |
foreach ($opt_array as $option) {
|
|
|
2871 |
$choice = $this->CheckOption($option, $acc, $func);
|
|
|
2872 |
if (is_null($choice)) return NULL; // In case CheckOption error handler returns
|
|
|
2873 |
$result[] = $choice;
|
|
|
2874 |
}
|
|
|
2875 |
return $result;
|
|
|
2876 |
}
|
|
|
2877 |
|
|
|
2878 |
/**
|
|
|
2879 |
* Checks for compatibility of the plot type and data type
|
|
|
2880 |
*
|
|
|
2881 |
* This is called by the plot-type-specific drawing functions, such as DrawBars().
|
|
|
2882 |
* It checks to make sure that the current data type is supported by the
|
|
|
2883 |
* drawing function.
|
|
|
2884 |
*
|
|
|
2885 |
* @param string $valid_types Valid data types, separated by comma space
|
|
|
2886 |
* @return bool True if data type is valid; False on error if an error handler returns True
|
|
|
2887 |
* @since 5.1.2
|
|
|
2888 |
*/
|
|
|
2889 |
protected function CheckDataType($valid_types)
|
|
|
2890 |
{
|
|
|
2891 |
if (strpos(", $valid_types,", ", $this->data_type,") !== FALSE)
|
|
|
2892 |
return TRUE;
|
|
|
2893 |
|
|
|
2894 |
$this->PrintError("Data type '$this->data_type' is not valid for '$this->plot_type' plots."
|
|
|
2895 |
. " Supported data type(s): '$valid_types'");
|
|
|
2896 |
return FALSE;
|
|
|
2897 |
}
|
|
|
2898 |
|
|
|
2899 |
/**
|
|
|
2900 |
* Decodes the data type into variables used to determine how to process a data array
|
|
|
2901 |
*
|
|
|
2902 |
* This sets the 'datetype_*' class variables, which are used by other functions
|
|
|
2903 |
* that need to access the data array. This keeps the information about the meaning
|
|
|
2904 |
* of each data type in a single place (the datatypes static array).
|
|
|
2905 |
* @since 5.1.2
|
|
|
2906 |
*/
|
|
|
2907 |
protected function DecodeDataType()
|
|
|
2908 |
{
|
|
|
2909 |
$v = &self::$datatypes[$this->data_type]; // Shortcut reference, already validated in SetDataType()
|
|
|
2910 |
$this->datatype_implied = !empty($v['implied']); // X (Y for horizontal plots) is implied
|
|
|
2911 |
$this->datatype_error_bars = !empty($v['error_bars']); // Has +error, -error values
|
|
|
2912 |
$this->datatype_pie_single = !empty($v['pie_single']); // Single-row pie chart
|
|
|
2913 |
$this->datatype_swapped_xy = !empty($v['swapped_xy']); // Horizontal plot with swapped X:Y
|
|
|
2914 |
$this->datatype_yz = !empty($v['yz']); // Has a Z value for each Y
|
|
|
2915 |
}
|
|
|
2916 |
|
|
|
2917 |
/**
|
|
|
2918 |
* Validates the data array, making sure it is properly structured
|
|
|
2919 |
*
|
|
|
2920 |
* This function is used by DrawGraph() to make sure the data array is populated
|
|
|
2921 |
* and each row is structured correctly, according to the data type.
|
|
|
2922 |
*
|
|
|
2923 |
* It also calculates data_columns, which is the maximum number of dependent
|
|
|
2924 |
* variable values (usually Y) in the data array rows. (For pie charts, this is
|
|
|
2925 |
* the number of slices.) It depends on the data_type, unlike records_per_group
|
|
|
2926 |
* (which was previously used to pad style arrays, but is not accurate).
|
|
|
2927 |
*
|
|
|
2928 |
* Note error messages refer to the caller, the public DrawGraph().
|
|
|
2929 |
*
|
|
|
2930 |
* @return bool True (False on error if an error handler returns True)
|
|
|
2931 |
* @since 5.1.3
|
|
|
2932 |
*/
|
|
|
2933 |
protected function CheckDataArray()
|
|
|
2934 |
{
|
|
|
2935 |
// Test for missing image, which really should never happen.
|
|
|
2936 |
if (!$this->img) {
|
|
|
2937 |
return $this->PrintError('DrawGraph(): No image resource allocated');
|
|
|
2938 |
}
|
|
|
2939 |
|
|
|
2940 |
// Test for missing or empty data array:
|
|
|
2941 |
if (empty($this->data) || !is_array($this->data)) {
|
|
|
2942 |
return $this->PrintError("DrawGraph(): No data array");
|
|
|
2943 |
}
|
|
|
2944 |
if ($this->total_records == 0) {
|
|
|
2945 |
return $this->PrintError('DrawGraph(): Empty data set');
|
|
|
2946 |
}
|
|
|
2947 |
|
|
|
2948 |
// Decode the data type into functional flags.
|
|
|
2949 |
$this->DecodeDataType();
|
|
|
2950 |
|
|
|
2951 |
// Calculate the maximum number of dependent values per independent value
|
|
|
2952 |
// (e.g. Y for each X), or the number of pie slices. Also validate the rows.
|
|
|
2953 |
$skip = $this->datatype_implied ? 1 : 2; // Skip factor for data label and independent variable
|
|
|
2954 |
if ($this->datatype_error_bars) {
|
|
|
2955 |
$this->data_columns = (int)(($this->records_per_group - $skip) / 3);
|
|
|
2956 |
// Validate the data array for error plots: (label, X, then groups of Y, +err, -err):
|
|
|
2957 |
for ($i = 0; $i < $this->num_data_rows; $i++) {
|
|
|
2958 |
if ($this->num_recs[$i] < $skip || ($this->num_recs[$i] - $skip) % 3 != 0)
|
|
|
2959 |
return $this->PrintError("DrawGraph(): Invalid $this->data_type data array (row $i)");
|
|
|
2960 |
}
|
|
|
2961 |
} elseif ($this->datatype_pie_single) {
|
|
|
2962 |
$this->data_columns = $this->num_data_rows; // Special case for this type of pie chart.
|
|
|
2963 |
// Validate the data array for text-data-single pie charts. Requires 1 value per row.
|
|
|
2964 |
for ($i = 0; $i < $this->num_data_rows; $i++) {
|
|
|
2965 |
if ($this->num_recs[$i] != 2)
|
|
|
2966 |
return $this->PrintError("DrawGraph(): Invalid $this->data_type data array (row $i)");
|
|
|
2967 |
}
|
|
|
2968 |
} elseif ($this->datatype_yz) {
|
|
|
2969 |
$this->data_columns = (int)(($this->records_per_group - $skip) / 2); // (y, z) pairs
|
|
|
2970 |
// Validate the data array for plots using X, Y, Z: (label, X, then pairs of Y, Z)
|
|
|
2971 |
for ($i = 0; $i < $this->num_data_rows; $i++) {
|
|
|
2972 |
if ($this->num_recs[$i] < $skip || ($this->num_recs[$i] - $skip) % 2 != 0)
|
|
|
2973 |
return $this->PrintError("DrawGraph(): Invalid $this->data_type data array (row $i)");
|
|
|
2974 |
}
|
|
|
2975 |
} else {
|
|
|
2976 |
$this->data_columns = $this->records_per_group - $skip;
|
|
|
2977 |
// Validate the data array for non-error plots:
|
|
|
2978 |
for ($i = 0; $i < $this->num_data_rows; $i++) {
|
|
|
2979 |
if ($this->num_recs[$i] < $skip)
|
|
|
2980 |
return $this->PrintError("DrawGraph(): Invalid $this->data_type data array (row $i)");
|
|
|
2981 |
}
|
|
|
2982 |
}
|
|
|
2983 |
return TRUE;
|
|
|
2984 |
}
|
|
|
2985 |
|
|
|
2986 |
/**
|
|
|
2987 |
* Controls browser-side image caching
|
|
|
2988 |
*
|
|
|
2989 |
* @param bool $which_browser_cache True to allow the browser to cache the image, false to not allow
|
|
|
2990 |
* @return bool True always
|
|
|
2991 |
*/
|
|
|
2992 |
function SetBrowserCache($which_browser_cache)
|
|
|
2993 |
{
|
|
|
2994 |
$this->browser_cache = $which_browser_cache;
|
|
|
2995 |
return TRUE;
|
|
|
2996 |
}
|
|
|
2997 |
|
|
|
2998 |
/**
|
|
|
2999 |
* Determines whether or not DrawGraph() automatically outputs the image when the plot is drawn
|
|
|
3000 |
*
|
|
|
3001 |
* @param bool $which_pi True to have DrawGraph() call PrintImage() when done, false to not output
|
|
|
3002 |
* @return bool True always
|
|
|
3003 |
*/
|
|
|
3004 |
function SetPrintImage($which_pi)
|
|
|
3005 |
{
|
|
|
3006 |
$this->print_image = $which_pi;
|
|
|
3007 |
return TRUE;
|
|
|
3008 |
}
|
|
|
3009 |
|
|
|
3010 |
/**
|
|
|
3011 |
* Sets how much of a border is drawn around the plot area
|
|
|
3012 |
*
|
|
|
3013 |
* The argument can be a single value, or any array of values, indicating
|
|
|
3014 |
* which sides should get a border. 'full' means all 4 sides.
|
|
|
3015 |
*
|
|
|
3016 |
* @param string|string[] $pdt Border control keyword(s): left|right|top|bottom|sides|none|full
|
|
|
3017 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3018 |
*/
|
|
|
3019 |
function SetPlotBorderType($pbt)
|
|
|
3020 |
{
|
|
|
3021 |
$this->plot_border_type = $this->CheckOptionArray($pbt, 'left, right, top, bottom, sides, none, full',
|
|
|
3022 |
__FUNCTION__);
|
|
|
3023 |
return !empty($this->plot_border_type);
|
|
|
3024 |
}
|
|
|
3025 |
|
|
|
3026 |
/**
|
|
|
3027 |
* Sets the type of border drawn around the image
|
|
|
3028 |
*
|
|
|
3029 |
* @param string $sibt Border type: raised | solid | plain | none
|
|
|
3030 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3031 |
*/
|
|
|
3032 |
function SetImageBorderType($sibt)
|
|
|
3033 |
{
|
|
|
3034 |
$this->image_border_type = $this->CheckOption($sibt, 'raised, plain, solid, none', __FUNCTION__);
|
|
|
3035 |
return (boolean)$this->image_border_type;
|
|
|
3036 |
}
|
|
|
3037 |
|
|
|
3038 |
/**
|
|
|
3039 |
* Sets the width of the image border, if enabled
|
|
|
3040 |
*
|
|
|
3041 |
* @param int $width Image border width in pixels
|
|
|
3042 |
* @return bool True always
|
|
|
3043 |
* @since 5.1.2
|
|
|
3044 |
*/
|
|
|
3045 |
function SetImageBorderWidth($width)
|
|
|
3046 |
{
|
|
|
3047 |
$this->image_border_width = $width;
|
|
|
3048 |
return TRUE;
|
|
|
3049 |
}
|
|
|
3050 |
|
|
|
3051 |
/**
|
|
|
3052 |
* Enables or disables drawing of the plot area background color
|
|
|
3053 |
*
|
|
|
3054 |
* @param bool $dpab True to draw the plot area background color, false to not draw it
|
|
|
3055 |
* @return bool True always
|
|
|
3056 |
*/
|
|
|
3057 |
function SetDrawPlotAreaBackground($dpab)
|
|
|
3058 |
{
|
|
|
3059 |
$this->draw_plot_area_background = (bool)$dpab;
|
|
|
3060 |
return TRUE;
|
|
|
3061 |
}
|
|
|
3062 |
|
|
|
3063 |
/**
|
|
|
3064 |
* Enables or disables drawing of the X (vertical) grid lines
|
|
|
3065 |
*
|
|
|
3066 |
* @param bool $dxg True to draw the X grid lines, false to not draw them; or NULL to restore default
|
|
|
3067 |
* @return bool True always
|
|
|
3068 |
*/
|
|
|
3069 |
function SetDrawXGrid($dxg = NULL)
|
|
|
3070 |
{
|
|
|
3071 |
$this->draw_x_grid = $dxg;
|
|
|
3072 |
return TRUE;
|
|
|
3073 |
}
|
|
|
3074 |
|
|
|
3075 |
/**
|
|
|
3076 |
* Enables or disables drawing of the Y grid lines
|
|
|
3077 |
*
|
|
|
3078 |
* @param bool $dyg True to draw the Y grid lines, false to not draw them; or NULL to restore default
|
|
|
3079 |
* @return bool True always
|
|
|
3080 |
*/
|
|
|
3081 |
function SetDrawYGrid($dyg = NULL)
|
|
|
3082 |
{
|
|
|
3083 |
$this->draw_y_grid = $dyg;
|
|
|
3084 |
return TRUE;
|
|
|
3085 |
}
|
|
|
3086 |
|
|
|
3087 |
/**
|
|
|
3088 |
* Selects dashed or solid grid lines
|
|
|
3089 |
*
|
|
|
3090 |
* @param bool $ddg True to draw the grid with dashed lines, false to use solid lines
|
|
|
3091 |
* @return bool True always
|
|
|
3092 |
*/
|
|
|
3093 |
function SetDrawDashedGrid($ddg)
|
|
|
3094 |
{
|
|
|
3095 |
$this->dashed_grid = (bool)$ddg;
|
|
|
3096 |
return TRUE;
|
|
|
3097 |
}
|
|
|
3098 |
|
|
|
3099 |
/**
|
|
|
3100 |
* Enables or disables drawing of X data label lines
|
|
|
3101 |
*
|
|
|
3102 |
* @param bool $dxdl True to draw the X data label lines, false to not draw them
|
|
|
3103 |
* @return bool True always
|
|
|
3104 |
*/
|
|
|
3105 |
function SetDrawXDataLabelLines($dxdl)
|
|
|
3106 |
{
|
|
|
3107 |
$this->draw_x_data_label_lines = (bool)$dxdl;
|
|
|
3108 |
return TRUE;
|
|
|
3109 |
}
|
|
|
3110 |
|
|
|
3111 |
/**
|
|
|
3112 |
* Enables or disables drawing of Y data label Lines (horizontal plots only)
|
|
|
3113 |
*
|
|
|
3114 |
* @param bool $dydl True to draw the Y data label lines, false to not draw them
|
|
|
3115 |
* @return bool True always
|
|
|
3116 |
* @since 6.0.0
|
|
|
3117 |
*/
|
|
|
3118 |
function SetDrawYDataLabelLines($dydl)
|
|
|
3119 |
{
|
|
|
3120 |
$this->draw_y_data_label_lines = (bool)$dydl;
|
|
|
3121 |
return TRUE;
|
|
|
3122 |
}
|
|
|
3123 |
|
|
|
3124 |
/**
|
|
|
3125 |
* Enables or disables drawing of borders around pie chart segments
|
|
|
3126 |
*
|
|
|
3127 |
* @param bool $dpb True to draw the pie chart segment borders, false to not draw them
|
|
|
3128 |
* @return bool True always
|
|
|
3129 |
* @since 6.0.0
|
|
|
3130 |
*/
|
|
|
3131 |
function SetDrawPieBorders($dpb)
|
|
|
3132 |
{
|
|
|
3133 |
$this->draw_pie_borders = (bool)$dpb;
|
|
|
3134 |
return TRUE;
|
|
|
3135 |
}
|
|
|
3136 |
|
|
|
3137 |
/**
|
|
|
3138 |
* Enables or disables drawing of data borders for plot types that support them
|
|
|
3139 |
*
|
|
|
3140 |
* For plot types which support data borders, such as 'bars', this enables
|
|
|
3141 |
* or disables them. The default depends on the plot type.
|
|
|
3142 |
*
|
|
|
3143 |
* @param bool $ddb True to draw the data borders, false to not draw them
|
|
|
3144 |
* @return bool True always
|
|
|
3145 |
* @since 6.0.0
|
|
|
3146 |
*/
|
|
|
3147 |
function SetDrawDataBorders($ddb)
|
|
|
3148 |
{
|
|
|
3149 |
$this->draw_data_borders = (bool)$ddb;
|
|
|
3150 |
return TRUE;
|
|
|
3151 |
}
|
|
|
3152 |
|
|
|
3153 |
/**
|
|
|
3154 |
* Sets the main title text for the plot
|
|
|
3155 |
*
|
|
|
3156 |
* @param string $which_title The text to use for the main plot title. Can contain multiple lines
|
|
|
3157 |
* @return bool True always
|
|
|
3158 |
*/
|
|
|
3159 |
function SetTitle($which_title)
|
|
|
3160 |
{
|
|
|
3161 |
$this->title_txt = $which_title;
|
|
|
3162 |
return TRUE;
|
|
|
3163 |
}
|
|
|
3164 |
|
|
|
3165 |
/**
|
|
|
3166 |
* Sets the X axis title, and optionally its position
|
|
|
3167 |
*
|
|
|
3168 |
* Sets the text to be displayed as the X axis title. Optionally, it
|
|
|
3169 |
* also sets the position of the title and the axis itself: below the
|
|
|
3170 |
* graph (the usual place), above the graph, both, or neither.
|
|
|
3171 |
*
|
|
|
3172 |
* @param string $which_xtitle The text string to use for the X axis title. Can contain multiple lines
|
|
|
3173 |
* @param string $which_xpos Optional position for the X axis and title: plotdown plotup both none
|
|
|
3174 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3175 |
*/
|
|
|
3176 |
function SetXTitle($which_xtitle, $which_xpos = 'plotdown')
|
|
|
3177 |
{
|
|
|
3178 |
if (!($which_xpos = $this->CheckOption($which_xpos, 'plotdown, plotup, both, none', __FUNCTION__)))
|
|
|
3179 |
return FALSE;
|
|
|
3180 |
if (($this->x_title_txt = $which_xtitle) === '')
|
|
|
3181 |
$this->x_title_pos = 'none';
|
|
|
3182 |
else
|
|
|
3183 |
$this->x_title_pos = $which_xpos;
|
|
|
3184 |
return TRUE;
|
|
|
3185 |
}
|
|
|
3186 |
|
|
|
3187 |
/**
|
|
|
3188 |
* Sets the Y axis title, and optionally its position
|
|
|
3189 |
*
|
|
|
3190 |
* Sets the text to be displayed as the Y axis title. Optionally, it
|
|
|
3191 |
* also sets the position of the title and the axis itself: on the left
|
|
|
3192 |
* side of the graph (the usual place), on the right side, both, or neither.
|
|
|
3193 |
*
|
|
|
3194 |
* @param string $which_ytitle The text string to use for the Y axis title. Can contain multiple lines
|
|
|
3195 |
* @param string $which_ypos Optional position for the X axis and title: plotleft plotright both none
|
|
|
3196 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3197 |
*/
|
|
|
3198 |
function SetYTitle($which_ytitle, $which_ypos = 'plotleft')
|
|
|
3199 |
{
|
|
|
3200 |
if (!($which_ypos = $this->CheckOption($which_ypos, 'plotleft, plotright, both, none', __FUNCTION__)))
|
|
|
3201 |
return FALSE;
|
|
|
3202 |
if (($this->y_title_txt = $which_ytitle) === '')
|
|
|
3203 |
$this->y_title_pos = 'none';
|
|
|
3204 |
else
|
|
|
3205 |
$this->y_title_pos = $which_ypos;
|
|
|
3206 |
return TRUE;
|
|
|
3207 |
}
|
|
|
3208 |
|
|
|
3209 |
/**
|
|
|
3210 |
* Sets the size of the drop shadow for bar and pie charts
|
|
|
3211 |
*
|
|
|
3212 |
* Sets the size in pixels of the drop shadow used to give bar and pie
|
|
|
3213 |
* charts a 3-D look. The 3-D look can be disabled by setting the shading
|
|
|
3214 |
* to zero.
|
|
|
3215 |
*
|
|
|
3216 |
* @param int $which_s Size of the drop shadow in pixels
|
|
|
3217 |
* @return bool True always
|
|
|
3218 |
*/
|
|
|
3219 |
function SetShading($which_s)
|
|
|
3220 |
{
|
|
|
3221 |
$this->shading = (int)$which_s;
|
|
|
3222 |
return TRUE;
|
|
|
3223 |
}
|
|
|
3224 |
|
|
|
3225 |
/**
|
|
|
3226 |
* Selects the type of plot - how the data will be graphed
|
|
|
3227 |
*
|
|
|
3228 |
* @param string $which_pt The plot type, such as bars, lines, pie, ...
|
|
|
3229 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3230 |
*/
|
|
|
3231 |
function SetPlotType($which_pt)
|
|
|
3232 |
{
|
|
|
3233 |
$avail_plot_types = implode(', ', array_keys(self::$plots)); // List of known plot types
|
|
|
3234 |
$this->plot_type = $this->CheckOption($which_pt, $avail_plot_types, __FUNCTION__);
|
|
|
3235 |
return (boolean)$this->plot_type;
|
|
|
3236 |
}
|
|
|
3237 |
|
|
|
3238 |
/**
|
|
|
3239 |
* Sets the position of the X axis
|
|
|
3240 |
*
|
|
|
3241 |
* @param float $pos Axis position as an integer Y world coordinate; '' or omit for default
|
|
|
3242 |
* @return bool True always
|
|
|
3243 |
*/
|
|
|
3244 |
function SetXAxisPosition($pos='')
|
|
|
3245 |
{
|
|
|
3246 |
$this->x_axis_position = ($pos === '') ? NULL : (int)$pos;
|
|
|
3247 |
return TRUE;
|
|
|
3248 |
}
|
|
|
3249 |
|
|
|
3250 |
/**
|
|
|
3251 |
* Sets the position of the Y axis
|
|
|
3252 |
*
|
|
|
3253 |
* @param float $pos Axis position as an integer X world coordinate; '' or omit for default
|
|
|
3254 |
* @return bool True always
|
|
|
3255 |
*/
|
|
|
3256 |
function SetYAxisPosition($pos='')
|
|
|
3257 |
{
|
|
|
3258 |
$this->y_axis_position = ($pos === '') ? NULL : (int)$pos;
|
|
|
3259 |
return TRUE;
|
|
|
3260 |
}
|
|
|
3261 |
|
|
|
3262 |
/**
|
|
|
3263 |
* Enables or disables drawing of the X axis line
|
|
|
3264 |
*
|
|
|
3265 |
* Note: This controls drawing of the axis line only, and not the ticks, labels, or grid.
|
|
|
3266 |
*
|
|
|
3267 |
* @param bool $draw True to draw the axis line, False to not draw it
|
|
|
3268 |
* @return bool True always
|
|
|
3269 |
* @since 5.3.0
|
|
|
3270 |
*/
|
|
|
3271 |
function SetDrawXAxis($draw)
|
|
|
3272 |
{
|
|
|
3273 |
$this->suppress_x_axis = !$draw; // See DrawXAxis()
|
|
|
3274 |
return TRUE;
|
|
|
3275 |
}
|
|
|
3276 |
|
|
|
3277 |
/**
|
|
|
3278 |
* Enables or disables drawing of the Y axis line
|
|
|
3279 |
*
|
|
|
3280 |
* Note: This controls drawing of the axis line only, and not the ticks, labels, or grid.
|
|
|
3281 |
*
|
|
|
3282 |
* @param bool $draw True to draw the axis line, False to not draw it
|
|
|
3283 |
* @return bool True always
|
|
|
3284 |
* @since 5.3.0
|
|
|
3285 |
*/
|
|
|
3286 |
function SetDrawYAxis($draw)
|
|
|
3287 |
{
|
|
|
3288 |
$this->suppress_y_axis = !$draw; // See DrawYAxis()
|
|
|
3289 |
return TRUE;
|
|
|
3290 |
}
|
|
|
3291 |
|
|
|
3292 |
/**
|
|
|
3293 |
* Selects linear or logarithmic scale for the X axis
|
|
|
3294 |
*
|
|
|
3295 |
* @param string $which_xst The scale type: linear | log
|
|
|
3296 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3297 |
*/
|
|
|
3298 |
function SetXScaleType($which_xst)
|
|
|
3299 |
{
|
|
|
3300 |
$this->xscale_type = $this->CheckOption($which_xst, 'linear, log', __FUNCTION__);
|
|
|
3301 |
return (boolean)$this->xscale_type;
|
|
|
3302 |
}
|
|
|
3303 |
|
|
|
3304 |
/**
|
|
|
3305 |
* Selects linear or logarithmic scale for the Y axis
|
|
|
3306 |
*
|
|
|
3307 |
* @param string $which_yst The scale type: linear | log
|
|
|
3308 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3309 |
*/
|
|
|
3310 |
function SetYScaleType($which_yst)
|
|
|
3311 |
{
|
|
|
3312 |
$this->yscale_type = $this->CheckOption($which_yst, 'linear, log', __FUNCTION__);
|
|
|
3313 |
return (boolean)$this->yscale_type;
|
|
|
3314 |
}
|
|
|
3315 |
|
|
|
3316 |
/**
|
|
|
3317 |
* Sets the precision for numerically formatted X labels
|
|
|
3318 |
*
|
|
|
3319 |
* Note: Use of the equivalent SetXLabelType('data', $which_prec) is preferred.
|
|
|
3320 |
*
|
|
|
3321 |
* @param int $which_prec Number of digits to display
|
|
|
3322 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3323 |
*/
|
|
|
3324 |
function SetPrecisionX($which_prec)
|
|
|
3325 |
{
|
|
|
3326 |
return $this->SetXLabelType('data', $which_prec);
|
|
|
3327 |
}
|
|
|
3328 |
|
|
|
3329 |
/**
|
|
|
3330 |
* Sets the precision for numerically formatted Y labels
|
|
|
3331 |
*
|
|
|
3332 |
* Note: Use of the equivalent SetYLabelType('data', $which_prec) is preferred.
|
|
|
3333 |
*
|
|
|
3334 |
* @param int $which_prec Number of digits to display
|
|
|
3335 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3336 |
*/
|
|
|
3337 |
function SetPrecisionY($which_prec)
|
|
|
3338 |
{
|
|
|
3339 |
return $this->SetYLabelType('data', $which_prec);
|
|
|
3340 |
}
|
|
|
3341 |
|
|
|
3342 |
/**
|
|
|
3343 |
* Sets the line width used for error bars
|
|
|
3344 |
*
|
|
|
3345 |
* @param int $which_seblw Desired width in pixels of the lines used to draw error bars
|
|
|
3346 |
* @return bool True always
|
|
|
3347 |
*/
|
|
|
3348 |
function SetErrorBarLineWidth($which_seblw)
|
|
|
3349 |
{
|
|
|
3350 |
$this->error_bar_line_width = $which_seblw;
|
|
|
3351 |
return TRUE;
|
|
|
3352 |
}
|
|
|
3353 |
|
|
|
3354 |
/**
|
|
|
3355 |
* Sets the position for pie chart labels
|
|
|
3356 |
*
|
|
|
3357 |
* @param float $which_blp Label position factor (0 <= blp <= 1); 0 or False for no labels
|
|
|
3358 |
* @return bool True always
|
|
|
3359 |
*/
|
|
|
3360 |
function SetLabelScalePosition($which_blp)
|
|
|
3361 |
{
|
|
|
3362 |
$this->label_scale_position = $which_blp;
|
|
|
3363 |
return TRUE;
|
|
|
3364 |
}
|
|
|
3365 |
|
|
|
3366 |
/**
|
|
|
3367 |
* Sets the size of the error bar tee
|
|
|
3368 |
*
|
|
|
3369 |
* @param int $which_ebs Length in pixels of the error bar "T"
|
|
|
3370 |
* @return bool True always
|
|
|
3371 |
*/
|
|
|
3372 |
function SetErrorBarSize($which_ebs)
|
|
|
3373 |
{
|
|
|
3374 |
$this->error_bar_size = $which_ebs;
|
|
|
3375 |
return TRUE;
|
|
|
3376 |
}
|
|
|
3377 |
|
|
|
3378 |
/**
|
|
|
3379 |
* Selects the shape of the error bars
|
|
|
3380 |
*
|
|
|
3381 |
* @param string $which_ebs Error bar shape: tee | line
|
|
|
3382 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3383 |
*/
|
|
|
3384 |
function SetErrorBarShape($which_ebs)
|
|
|
3385 |
{
|
|
|
3386 |
$this->error_bar_shape = $this->CheckOption($which_ebs, 'tee, line', __FUNCTION__);
|
|
|
3387 |
return (boolean)$this->error_bar_shape;
|
|
|
3388 |
}
|
|
|
3389 |
|
|
|
3390 |
/**
|
|
|
3391 |
* Synchronizes the lengths of the point shapes and point sizes arrays
|
|
|
3392 |
*
|
|
|
3393 |
* This pads the smaller of $point_shapes[] and $point_sizes[], making them the same size.
|
|
|
3394 |
* It is called just before drawing any plot that needs 'points'.
|
|
|
3395 |
* @since 5.1.0
|
|
|
3396 |
*/
|
|
|
3397 |
protected function CheckPointParams()
|
|
|
3398 |
{
|
|
|
3399 |
$ps = count($this->point_sizes);
|
|
|
3400 |
$pt = count($this->point_shapes);
|
|
|
3401 |
|
|
|
3402 |
if ($ps < $pt) {
|
|
|
3403 |
$this->pad_array($this->point_sizes, $pt);
|
|
|
3404 |
$this->point_counts = $pt;
|
|
|
3405 |
} elseif ($ps > $pt) {
|
|
|
3406 |
$this->pad_array($this->point_shapes, $ps);
|
|
|
3407 |
$this->point_counts = $ps;
|
|
|
3408 |
} else {
|
|
|
3409 |
$this->point_counts = $ps;
|
|
|
3410 |
}
|
|
|
3411 |
}
|
|
|
3412 |
|
|
|
3413 |
/**
|
|
|
3414 |
* Selects the point shape for each data set
|
|
|
3415 |
*
|
|
|
3416 |
* Valid point shapes are known here and in DrawShape(). Includes: circle | dot | diamond | ...
|
|
|
3417 |
* The point shape and point sizes arrays are synchronized before drawing a graph
|
|
|
3418 |
* that uses points. See CheckPointParams()
|
|
|
3419 |
*
|
|
|
3420 |
* @param string|string[] $which_pt Array (or single value) of valid point shapes
|
|
|
3421 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3422 |
*/
|
|
|
3423 |
function SetPointShapes($which_pt)
|
|
|
3424 |
{
|
|
|
3425 |
$this->point_shapes = $this->CheckOptionArray($which_pt, 'halfline, line, plus, cross, rect,'
|
|
|
3426 |
. ' circle, dot, diamond, triangle, trianglemid, delta, yield, star, hourglass,'
|
|
|
3427 |
. ' bowtie, target, box, home, up, down, none', __FUNCTION__);
|
|
|
3428 |
return !empty($this->point_shapes);
|
|
|
3429 |
}
|
|
|
3430 |
|
|
|
3431 |
/**
|
|
|
3432 |
* Sets the point size for each data set
|
|
|
3433 |
*
|
|
|
3434 |
* The point shape and point sizes arrays are synchronized before drawing a graph
|
|
|
3435 |
* that uses points. See CheckPointParams()
|
|
|
3436 |
*
|
|
|
3437 |
* @param string[]|string $which_ps Array (or single value) of point sizes in pixels
|
|
|
3438 |
* @return bool True always
|
|
|
3439 |
*/
|
|
|
3440 |
function SetPointSizes($which_ps)
|
|
|
3441 |
{
|
|
|
3442 |
if (is_array($which_ps)) {
|
|
|
3443 |
// Use provided array:
|
|
|
3444 |
$this->point_sizes = $which_ps;
|
|
|
3445 |
} elseif (!is_null($which_ps)) {
|
|
|
3446 |
// Make the single value into an array:
|
|
|
3447 |
$this->point_sizes = array($which_ps);
|
|
|
3448 |
}
|
|
|
3449 |
return TRUE;
|
|
|
3450 |
}
|
|
|
3451 |
|
|
|
3452 |
/**
|
|
|
3453 |
* Sets whether lines should be broken at missing data, for 'lines' and 'squared' plots.
|
|
|
3454 |
*
|
|
|
3455 |
* @param bool $bl True to break the lines, false to connect around missing data
|
|
|
3456 |
* @return bool True always
|
|
|
3457 |
*/
|
|
|
3458 |
function SetDrawBrokenLines($bl)
|
|
|
3459 |
{
|
|
|
3460 |
$this->draw_broken_lines = (bool)$bl;
|
|
|
3461 |
return TRUE;
|
|
|
3462 |
}
|
|
|
3463 |
|
|
|
3464 |
/**
|
|
|
3465 |
* Sets the data type, which defines the structure of the data array
|
|
|
3466 |
*
|
|
|
3467 |
* For a list of available data types, see the static arrays $datatypes and $datatypes_map.
|
|
|
3468 |
*
|
|
|
3469 |
* @param string $which_dt The data array format type: text-data | data-data | ...
|
|
|
3470 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3471 |
*/
|
|
|
3472 |
function SetDataType($which_dt)
|
|
|
3473 |
{
|
|
|
3474 |
// Handle data type aliases - mostly for backward compatibility:
|
|
|
3475 |
if (isset(self::$datatypes_map[$which_dt]))
|
|
|
3476 |
$which_dt = self::$datatypes_map[$which_dt];
|
|
|
3477 |
// Validate the datatype argument against the available data types:
|
|
|
3478 |
$valid_data_types = implode(', ', array_keys(self::$datatypes));
|
|
|
3479 |
$this->data_type = $this->CheckOption($which_dt, $valid_data_types, __FUNCTION__);
|
|
|
3480 |
return (boolean)$this->data_type;
|
|
|
3481 |
}
|
|
|
3482 |
|
|
|
3483 |
/**
|
|
|
3484 |
* Sets the data array for plotting
|
|
|
3485 |
*
|
|
|
3486 |
* This copy the array of data values, converting rows to numerical indexes.
|
|
|
3487 |
* It also validates that the array uses 0-based sequential integer indexes,
|
|
|
3488 |
* and that each array value (row) is another array. Other validation is
|
|
|
3489 |
* deferred to CheckDataArray().
|
|
|
3490 |
*
|
|
|
3491 |
* @param array $which_dv The data array, an array of row arrays, interpreted per SetDataType()
|
|
|
3492 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3493 |
*/
|
|
|
3494 |
function SetDataValues($which_dv)
|
|
|
3495 |
{
|
|
|
3496 |
$this->num_data_rows = count($which_dv);
|
|
|
3497 |
$this->total_records = 0;
|
|
|
3498 |
$this->data = array();
|
|
|
3499 |
$this->num_recs = array();
|
|
|
3500 |
for ($i = 0; $i < $this->num_data_rows; $i++) {
|
|
|
3501 |
if (!isset($which_dv[$i]) || !is_array($which_dv[$i])) {
|
|
|
3502 |
return $this->PrintError("SetDataValues(): Invalid data array (row $i)");
|
|
|
3503 |
}
|
|
|
3504 |
$this->data[$i] = array_values($which_dv[$i]); // convert to numerical indices.
|
|
|
3505 |
|
|
|
3506 |
// Count size of each row, and total for the array.
|
|
|
3507 |
$this->total_records += $this->num_recs[$i] = count($this->data[$i]);
|
|
|
3508 |
}
|
|
|
3509 |
// This is the size of the widest row in the data array
|
|
|
3510 |
// Note records_per_group isn't used much anymore. See data_columns in CheckDataArray()
|
|
|
3511 |
$this->records_per_group = empty($this->num_recs) ? 0 : max($this->num_recs);
|
|
|
3512 |
return TRUE;
|
|
|
3513 |
}
|
|
|
3514 |
|
|
|
3515 |
/**
|
|
|
3516 |
* Pads the style arrays so they are large enough for the number of data sets
|
|
|
3517 |
*
|
|
|
3518 |
* The style arrays to be padded are line_widths, line_styles, data_colors, data_border_colors.
|
|
|
3519 |
* This ensures they have at least $data_columns entries (maximum number of data sets), which
|
|
|
3520 |
* simplifies the plot drawing functions.
|
|
|
3521 |
* Other data color arrays are handled in the Need*Colors() functions instead (if needed).
|
|
|
3522 |
*
|
|
|
3523 |
* @return bool True always
|
|
|
3524 |
*/
|
|
|
3525 |
protected function PadArrays()
|
|
|
3526 |
{
|
|
|
3527 |
$this->pad_array($this->line_widths, $this->data_columns);
|
|
|
3528 |
$this->pad_array($this->line_styles, $this->data_columns);
|
|
|
3529 |
$this->pad_array($this->ndx_data_colors, $this->data_columns);
|
|
|
3530 |
$this->pad_array($this->ndx_data_border_colors, $this->data_columns);
|
|
|
3531 |
return TRUE;
|
|
|
3532 |
}
|
|
|
3533 |
|
|
|
3534 |
/**
|
|
|
3535 |
* Pads an array with copies of itself until it reaches the given size
|
|
|
3536 |
*
|
|
|
3537 |
* pad_array only works on 0-based sequential integer indexed arrays. It also
|
|
|
3538 |
* accepts a scalar, which is first converted to a single element array.
|
|
|
3539 |
* Elements of the array are appended until it reaches the given size.
|
|
|
3540 |
*
|
|
|
3541 |
* @param array|mixed $arr Reference variable for the array (or scalar) to pad
|
|
|
3542 |
* @param int $size Minimum size of the resulting array
|
|
|
3543 |
*/
|
|
|
3544 |
protected function pad_array(&$arr, $size)
|
|
|
3545 |
{
|
|
|
3546 |
if (! is_array($arr)) {
|
|
|
3547 |
$arr = array($arr);
|
|
|
3548 |
}
|
|
|
3549 |
$n = count($arr);
|
|
|
3550 |
$base = 0;
|
|
|
3551 |
while ($n < $size) $arr[$n++] = $arr[$base++];
|
|
|
3552 |
}
|
|
|
3553 |
|
|
|
3554 |
/**
|
|
|
3555 |
* Formats a floating point number, with decimal separator and thousands groups separator
|
|
|
3556 |
*
|
|
|
3557 |
* This is like PHP's number_format, but uses class variables for separators, and tries to
|
|
|
3558 |
* get the separators from the current locale.
|
|
|
3559 |
* Note: The locale is saved and reset after getting the values. This is needed due to an issue with
|
|
|
3560 |
* PHP (see PHP bug 45365 and others): It uses a locale-specific decimal separator when converting
|
|
|
3561 |
* numbers to strings, but fails to convert back if the separator is other than dot. This would cause
|
|
|
3562 |
* pie chart labels to fail with "A non well formed numeric value encountered".
|
|
|
3563 |
*
|
|
|
3564 |
* @param float $number A floating point number to format
|
|
|
3565 |
* @param int $decimals Number of decimal places in the result
|
|
|
3566 |
* @return string The formatted result
|
|
|
3567 |
*/
|
|
|
3568 |
protected function number_format($number, $decimals=0)
|
|
|
3569 |
{
|
|
|
3570 |
// Try to get the proper decimal and thousands separators if they are not already set.
|
|
|
3571 |
if (!isset($this->decimal_point, $this->thousands_sep)) {
|
|
|
3572 |
// Load locale-specific values from environment, unless disabled (for testing):
|
|
|
3573 |
if (!$this->locale_override) {
|
|
|
3574 |
$save_locale = @setlocale(LC_NUMERIC, '0');
|
|
|
3575 |
@setlocale(LC_NUMERIC, '');
|
|
|
3576 |
}
|
|
|
3577 |
// Fetch locale settings:
|
|
|
3578 |
$locale = @localeconv();
|
|
|
3579 |
// Restore locale. (See note above.)
|
|
|
3580 |
if (!empty($save_locale)) @setlocale(LC_NUMERIC, $save_locale);
|
|
|
3581 |
if (isset($locale['decimal_point'], $locale['thousands_sep'])) {
|
|
|
3582 |
$this->decimal_point = $locale['decimal_point'];
|
|
|
3583 |
$this->thousands_sep = $locale['thousands_sep'];
|
|
|
3584 |
} else {
|
|
|
3585 |
// Locale information not available.
|
|
|
3586 |
$this->decimal_point = '.';
|
|
|
3587 |
$this->thousands_sep = ',';
|
|
|
3588 |
}
|
|
|
3589 |
}
|
|
|
3590 |
return number_format($number, $decimals, $this->decimal_point, $this->thousands_sep);
|
|
|
3591 |
}
|
|
|
3592 |
|
|
|
3593 |
/**
|
|
|
3594 |
* Registers a callback (hook) function
|
|
|
3595 |
*
|
|
|
3596 |
* See the $callbacks array (class property) for the available callback names
|
|
|
3597 |
*
|
|
|
3598 |
* @param string $reason A pre-defined name where a callback can be defined
|
|
|
3599 |
* @param callback $function Function or method to register for callback
|
|
|
3600 |
* @param mixed $arg Optional opaque argument to supply to the callback function when called
|
|
|
3601 |
* @return bool True if the callback reason is valid, else False
|
|
|
3602 |
* @since 5.0.4
|
|
|
3603 |
*/
|
|
|
3604 |
function SetCallback($reason, $function, $arg = NULL)
|
|
|
3605 |
{
|
|
|
3606 |
// Use array_key_exists because valid reason keys have NULL as value.
|
|
|
3607 |
if (!array_key_exists($reason, $this->callbacks))
|
|
|
3608 |
return FALSE;
|
|
|
3609 |
$this->callbacks[$reason] = array($function, $arg);
|
|
|
3610 |
return TRUE;
|
|
|
3611 |
}
|
|
|
3612 |
|
|
|
3613 |
/**
|
|
|
3614 |
* Returns the current callback function registered for the given reason
|
|
|
3615 |
*
|
|
|
3616 |
* Note you can safely test the return value with a simple 'if', as no valid
|
|
|
3617 |
* function name evaluates to false. PHPlot uses if (GetCallback(...)) to
|
|
|
3618 |
* to avoid preparing arguments to an unused callback.
|
|
|
3619 |
*
|
|
|
3620 |
* @param string $reason A pre-defined name where a callback can be defined
|
|
|
3621 |
* @return callback|false The current callback for the reason; False if none or invalid
|
|
|
3622 |
* @since 5.0.4
|
|
|
3623 |
*/
|
|
|
3624 |
function GetCallback($reason)
|
|
|
3625 |
{
|
|
|
3626 |
if (isset($this->callbacks[$reason]))
|
|
|
3627 |
return $this->callbacks[$reason][0];
|
|
|
3628 |
return FALSE;
|
|
|
3629 |
}
|
|
|
3630 |
|
|
|
3631 |
/**
|
|
|
3632 |
* Un-registers any callback registered for the given reason
|
|
|
3633 |
*
|
|
|
3634 |
* Note: A True return means $reason is valid; it does not mean a callback
|
|
|
3635 |
* was actually registered for that reason.
|
|
|
3636 |
*
|
|
|
3637 |
* @param string $reason A pre-defined name where a callback can be defined
|
|
|
3638 |
* @return bool True if it was a valid callback reason, else False
|
|
|
3639 |
* @since 5.0.4
|
|
|
3640 |
*/
|
|
|
3641 |
function RemoveCallback($reason)
|
|
|
3642 |
{
|
|
|
3643 |
if (!array_key_exists($reason, $this->callbacks))
|
|
|
3644 |
return FALSE;
|
|
|
3645 |
$this->callbacks[$reason] = NULL;
|
|
|
3646 |
return TRUE;
|
|
|
3647 |
}
|
|
|
3648 |
|
|
|
3649 |
/**
|
|
|
3650 |
* Invokes a callback function, if one is registered
|
|
|
3651 |
*
|
|
|
3652 |
* Callbacks are called like this: callback_function($image, $passthru, [$arg,...])
|
|
|
3653 |
* Here $passthru is the argument specified when the callback was defined by SetCallback()
|
|
|
3654 |
* and is under control of the application. $arg... is zero or more additional arguments
|
|
|
3655 |
* specified when then callback is called. These are under control of PHPlot itself.
|
|
|
3656 |
*
|
|
|
3657 |
* @param string $reason A string naming one of the pre-defined callback reasons
|
|
|
3658 |
* @param mixed $varargs Zero or more additional arguments to be passed to the callback
|
|
|
3659 |
* @return mixed Whatever value is returned by the callback function (if any)
|
|
|
3660 |
*/
|
|
|
3661 |
protected function DoCallback($reason, $varargs = NULL)
|
|
|
3662 |
{
|
|
|
3663 |
if (!isset($this->callbacks[$reason]))
|
|
|
3664 |
return;
|
|
|
3665 |
$args = func_get_args();
|
|
|
3666 |
// Make the argument vector $args[] look like: $image, $passthru, [$arg...]
|
|
|
3667 |
list($function, $args[0]) = $this->callbacks[$reason];
|
|
|
3668 |
array_unshift($args, $this->img);
|
|
|
3669 |
return call_user_func_array($function, $args);
|
|
|
3670 |
}
|
|
|
3671 |
|
|
|
3672 |
/**
|
|
|
3673 |
* Allocates colors for the image background and image border
|
|
|
3674 |
*
|
|
|
3675 |
* This is separate from SetColorIndexes() below so that DrawMessage can use it.
|
|
|
3676 |
*
|
|
|
3677 |
* @since 5.7.0
|
|
|
3678 |
*/
|
|
|
3679 |
protected function SetBgColorIndexes()
|
|
|
3680 |
{
|
|
|
3681 |
$this->ndx_bg_color = $this->GetColorIndex($this->bg_color); // Background first
|
|
|
3682 |
$this->ndx_plot_bg_color = $this->GetColorIndex($this->plot_bg_color);
|
|
|
3683 |
if ($this->image_border_type != 'none') {
|
|
|
3684 |
$this->ndx_i_border = $this->GetColorIndex($this->i_border);
|
|
|
3685 |
$this->ndx_i_border_dark = $this->GetDarkColorIndex($this->i_border);
|
|
|
3686 |
}
|
|
|
3687 |
}
|
|
|
3688 |
|
|
|
3689 |
/**
|
|
|
3690 |
* Allocates all the colors needed for the plot
|
|
|
3691 |
*
|
|
|
3692 |
* This is called by DrawGraph to allocate the colors needed for the plot. Each selectable
|
|
|
3693 |
* color has already been validated, parsed into an array (r,g,b,a), and stored into a member
|
|
|
3694 |
* variable. Now the GD color indexes are assigned and stored into the ndx_*_color variables.
|
|
|
3695 |
* This is deferred here to avoid allocating unneeded colors and to avoid order dependencies,
|
|
|
3696 |
* especially with the transparent color.
|
|
|
3697 |
*
|
|
|
3698 |
* For drawing data elements, only the main data colors and border colors are allocated here.
|
|
|
3699 |
* Dark colors and error bar colors are allocated by Need*Color() functions.
|
|
|
3700 |
* (Data border colors default to just black, so there is no cost to always allocating.)
|
|
|
3701 |
*
|
|
|
3702 |
* Data color allocation works as follows. If there is a data_color callback, then allocate all
|
|
|
3703 |
* defined data colors (because the callback can use them however it wants). Otherwise, only allocate
|
|
|
3704 |
* the number of colors that will be used. This is the larger of the number of data sets and the
|
|
|
3705 |
* number of legend lines.
|
|
|
3706 |
*
|
|
|
3707 |
* @since 5.2.0
|
|
|
3708 |
*/
|
|
|
3709 |
protected function SetColorIndexes()
|
|
|
3710 |
{
|
|
|
3711 |
$this->SetBgColorIndexes(); // Background and border colors
|
|
|
3712 |
|
|
|
3713 |
// Handle defaults for X and Y title colors.
|
|
|
3714 |
$this->ndx_title_color = $this->GetColorIndex($this->title_color);
|
|
|
3715 |
$this->ndx_x_title_color = $this->GetColorIndex($this->x_title_color, $this->ndx_title_color);
|
|
|
3716 |
$this->ndx_y_title_color = $this->GetColorIndex($this->y_title_color, $this->ndx_title_color);
|
|
|
3717 |
|
|
|
3718 |
// General text color, which is the default color for tick and data labels unless overridden.
|
|
|
3719 |
$this->ndx_text_color = $this->GetColorIndex($this->text_color);
|
|
|
3720 |
$this->ndx_ticklabel_color = $this->GetColorIndex($this->ticklabel_color, $this->ndx_text_color);
|
|
|
3721 |
$this->ndx_datalabel_color = $this->GetColorIndex($this->datalabel_color, $this->ndx_text_color);
|
|
|
3722 |
$this->ndx_dvlabel_color = $this->GetColorIndex($this->dvlabel_color, $this->ndx_datalabel_color);
|
|
|
3723 |
|
|
|
3724 |
$this->ndx_grid_color = $this->GetColorIndex($this->grid_color);
|
|
|
3725 |
$this->ndx_light_grid_color = $this->GetColorIndex($this->light_grid_color);
|
|
|
3726 |
$this->ndx_tick_color = $this->GetColorIndex($this->tick_color);
|
|
|
3727 |
// Pie label and border colors default to grid color, for historical reasons (PHPlot <= 5.6.1)
|
|
|
3728 |
$this->ndx_pielabel_color = $this->GetColorIndex($this->pielabel_color, $this->ndx_grid_color);
|
|
|
3729 |
$this->ndx_pieborder_color = $this->GetColorIndex($this->pieborder_color, $this->ndx_grid_color);
|
|
|
3730 |
|
|
|
3731 |
// Maximum number of data & border colors to allocate:
|
|
|
3732 |
if ($this->GetCallback('data_color')) {
|
|
|
3733 |
$n_data = count($this->data_colors); // Need all of them
|
|
|
3734 |
$n_border = count($this->data_border_colors);
|
|
|
3735 |
} else {
|
|
|
3736 |
$n_data = max($this->data_columns, empty($this->legend) ? 0 : count($this->legend));
|
|
|
3737 |
$n_border = $n_data; // One border color per data color
|
|
|
3738 |
}
|
|
|
3739 |
|
|
|
3740 |
// Allocate main data colors. For other colors used for data, see the functions which follow.
|
|
|
3741 |
$this->ndx_data_colors = $this->GetColorIndexArray($this->data_colors, $n_data);
|
|
|
3742 |
$this->ndx_data_border_colors = $this->GetColorIndexArray($this->data_border_colors, $n_border);
|
|
|
3743 |
|
|
|
3744 |
// Legend colors: background defaults to image background, text defaults to general text color.
|
|
|
3745 |
$this->ndx_legend_bg_color = $this->GetColorIndex($this->legend_bg_color, $this->ndx_bg_color);
|
|
|
3746 |
$this->ndx_legend_text_color = $this->GetColorIndex($this->legend_text_color, $this->ndx_text_color);
|
|
|
3747 |
|
|
|
3748 |
// Set up a color as transparent, if SetTransparentColor was used.
|
|
|
3749 |
if (!empty($this->transparent_color)) {
|
|
|
3750 |
imagecolortransparent($this->img, $this->GetColorIndex($this->transparent_color));
|
|
|
3751 |
}
|
|
|
3752 |
}
|
|
|
3753 |
|
|
|
3754 |
/**
|
|
|
3755 |
* Allocates dark-shade data colors used for shading
|
|
|
3756 |
*
|
|
|
3757 |
* This is called if needed by graph drawing functions that need shading.
|
|
|
3758 |
*
|
|
|
3759 |
* @since 5.2.0
|
|
|
3760 |
*/
|
|
|
3761 |
protected function NeedDataDarkColors()
|
|
|
3762 |
{
|
|
|
3763 |
// This duplicates the calculation in SetColorIndexes() for number of data colors to allocate.
|
|
|
3764 |
if ($this->GetCallback('data_color')) {
|
|
|
3765 |
$n_data = count($this->data_colors);
|
|
|
3766 |
} else {
|
|
|
3767 |
$n_data = max($this->data_columns, empty($this->legend) ? 0 : count($this->legend));
|
|
|
3768 |
}
|
|
|
3769 |
$this->ndx_data_dark_colors = $this->GetDarkColorIndexArray($this->data_colors, $n_data);
|
|
|
3770 |
$this->pad_array($this->ndx_data_dark_colors, $this->data_columns);
|
|
|
3771 |
}
|
|
|
3772 |
|
|
|
3773 |
/**
|
|
|
3774 |
* Allocates error bar colors
|
|
|
3775 |
*
|
|
|
3776 |
* This is called if needed by graph drawing functions that draw error bars.
|
|
|
3777 |
*
|
|
|
3778 |
* @since 5.2.0
|
|
|
3779 |
*/
|
|
|
3780 |
protected function NeedErrorBarColors()
|
|
|
3781 |
{
|
|
|
3782 |
// This is similar to the calculation in SetColorIndexes() for number of data colors to allocate.
|
|
|
3783 |
if ($this->GetCallback('data_color')) {
|
|
|
3784 |
$n_err = count($this->error_bar_colors);
|
|
|
3785 |
} else {
|
|
|
3786 |
$n_err = max($this->data_columns, empty($this->legend) ? 0 : count($this->legend));
|
|
|
3787 |
}
|
|
|
3788 |
$this->ndx_error_bar_colors = $this->GetColorIndexArray($this->error_bar_colors, $n_err);
|
|
|
3789 |
$this->pad_array($this->ndx_error_bar_colors, $this->data_columns);
|
|
|
3790 |
}
|
|
|
3791 |
|
|
|
3792 |
/**
|
|
|
3793 |
* Selects the best alignment for text, based on its vector angle from a point
|
|
|
3794 |
*
|
|
|
3795 |
* This picks one of 8 alignments (horizontal = left, center, or right; vertical = top, center
|
|
|
3796 |
* or bottom; but never center/center) for text that needs to be close to a point but directed
|
|
|
3797 |
* away from the point. The angle of the vector from the reference point determines the alignment.
|
|
|
3798 |
*
|
|
|
3799 |
* How it works: Picture a unit circle with 16 slices of 22.5 degrees each.
|
|
|
3800 |
* Draw horizontal lines at the 22.5 degree and -22.5 degree positions on the circle.
|
|
|
3801 |
* Text above the upper line will have 'bottom' vertical alignment; below the lower line will
|
|
|
3802 |
* have 'top' vertical alignment, and between the lines will have 'center' vertical alignment.
|
|
|
3803 |
* Horizontal alignment is similar, using +/- 22.5 degrees from vertical.
|
|
|
3804 |
*
|
|
|
3805 |
* @param float $sin_t sin() of the angle of the text offset from a reference point
|
|
|
3806 |
* @param float $cos_t cos() of the angle of the text offset from a reference point
|
|
|
3807 |
* @param string $h_align Reference variable to get the horizontal alignment, for DrawText()
|
|
|
3808 |
* @param string $v_align Reference variable to get the vertical alignment, for DrawText()
|
|
|
3809 |
* @param bool $reverse True to reverse the alignment, e.g. for text inside an ellipse
|
|
|
3810 |
* @since 5.6.0
|
|
|
3811 |
*/
|
|
|
3812 |
protected function GetTextAlignment($sin_t, $cos_t, &$h_align, &$v_align, $reverse = FALSE)
|
|
|
3813 |
{
|
|
|
3814 |
if ($reverse) { // Return the opposite alignment, align(T-180) vs align(T)
|
|
|
3815 |
$sin_t = -$sin_t; // sin(T-180) = -sin(T)
|
|
|
3816 |
$cos_t = -$cos_t; // cos(T-180) = -cos(T)
|
|
|
3817 |
}
|
|
|
3818 |
if ($sin_t >= 0.383) $v_align = 'bottom'; // 0.383 = sin(22.5 degrees)
|
|
|
3819 |
elseif ($sin_t >= -0.383) $v_align = 'center';
|
|
|
3820 |
else $v_align = 'top';
|
|
|
3821 |
if ($cos_t >= 0.383) $h_align = 'left'; // 0.383 = cos(90 - 22.5 degrees)
|
|
|
3822 |
elseif ($cos_t >= -0.383) $h_align = 'center';
|
|
|
3823 |
else $h_align = 'right';
|
|
|
3824 |
}
|
|
|
3825 |
|
|
|
3826 |
/**
|
|
|
3827 |
* Determines if and where to draw Data Value Labels
|
|
|
3828 |
*
|
|
|
3829 |
* This is called by plot drawing functions that support Data Value Labels (other
|
|
|
3830 |
* than bars and stackedbars, which have their own way of doing it). If those
|
|
|
3831 |
* labels are on, it returns True and sets 4 keys in $dvl[] which are used by
|
|
|
3832 |
* DrawDataValueLabel to position the label: x_offset, y_offset = pixel offsets
|
|
|
3833 |
* for the label; h_align, v_align = text alignment choices.
|
|
|
3834 |
* It uses two member variables: data_value_label_angle and data_value_label_distance
|
|
|
3835 |
* to define the vector to the label.
|
|
|
3836 |
*
|
|
|
3837 |
* @param string $label_control Label position control; either $x_data_label_pos or $y_data_label_pos
|
|
|
3838 |
* @param array $dvl Reference argument for result parameters for DrawDataValueLabel()
|
|
|
3839 |
* @return bool False if data value labels are off; True if on and $dvl is set
|
|
|
3840 |
* @since 5.3.0
|
|
|
3841 |
*/
|
|
|
3842 |
protected function CheckDataValueLabels($label_control, &$dvl)
|
|
|
3843 |
{
|
|
|
3844 |
if ($label_control != 'plotin')
|
|
|
3845 |
return FALSE; // No data value labels
|
|
|
3846 |
$angle = deg2rad($this->data_value_label_angle);
|
|
|
3847 |
$cos = cos($angle);
|
|
|
3848 |
$sin = sin($angle);
|
|
|
3849 |
$dvl['x_offset'] = (int)($this->data_value_label_distance * $cos);
|
|
|
3850 |
$dvl['y_offset'] = -(int)($this->data_value_label_distance * $sin); // Y is reversed (device coords)
|
|
|
3851 |
|
|
|
3852 |
// Choose text alignment based on angle:
|
|
|
3853 |
$this->GetTextAlignment($sin, $cos, $dvl['h_align'], $dvl['v_align']);
|
|
|
3854 |
return TRUE;
|
|
|
3855 |
}
|
|
|
3856 |
|
|
|
3857 |
/**
|
|
|
3858 |
* Enables or disables automatic pie chart size calculation
|
|
|
3859 |
*
|
|
|
3860 |
* If autosize is disabled, PHPlot uses the full plot area (as PHPlot-5.5.0
|
|
|
3861 |
* and earlier always did). Note the flag pie_full_size is unset by default,
|
|
|
3862 |
* and stores the complement of $enable.
|
|
|
3863 |
*
|
|
|
3864 |
* @param bool $enable True to enable automatic size calculation, False to use the maximum area
|
|
|
3865 |
* @return bool True always
|
|
|
3866 |
* @since 5.6.0
|
|
|
3867 |
*/
|
|
|
3868 |
function SetPieAutoSize($enable)
|
|
|
3869 |
{
|
|
|
3870 |
$this->pie_full_size = !$enable;
|
|
|
3871 |
return TRUE;
|
|
|
3872 |
}
|
|
|
3873 |
|
|
|
3874 |
/**
|
|
|
3875 |
* Sets the starting angle for pie chart segments
|
|
|
3876 |
*
|
|
|
3877 |
* @param float $angle Starting angle in degrees
|
|
|
3878 |
* @return bool True always
|
|
|
3879 |
* @since 6.0.0
|
|
|
3880 |
*/
|
|
|
3881 |
function SetPieStartAngle($angle)
|
|
|
3882 |
{
|
|
|
3883 |
$this->pie_start_angle = $angle;
|
|
|
3884 |
return TRUE;
|
|
|
3885 |
}
|
|
|
3886 |
|
|
|
3887 |
/**
|
|
|
3888 |
* Sets the direction for pie chart segments
|
|
|
3889 |
*
|
|
|
3890 |
* @param string $which Direction for pie segments: clockwise | cw | counterclockwise | ccw
|
|
|
3891 |
* @return bool True (False on error if an error handler returns True)
|
|
|
3892 |
* @since 6.0.0
|
|
|
3893 |
*/
|
|
|
3894 |
function SetPieDirection($which)
|
|
|
3895 |
{
|
|
|
3896 |
$control = $this->CheckOption($which, 'clockwise, cw, counterclockwise, ccw', __FUNCTION__);
|
|
|
3897 |
if (empty($control)) return FALSE;
|
|
|
3898 |
$this->pie_direction_cw = ($control == 'clockwise' || $control == 'cw');
|
|
|
3899 |
return TRUE;
|
|
|
3900 |
}
|
|
|
3901 |
|
|
|
3902 |
//////////////////////////////////////////////////////////
|
|
|
3903 |
/////////// DATA ANALYSIS, SCALING AND TRANSLATION
|
|
|
3904 |
//////////////////////////////////////////////////////////
|
|
|
3905 |
|
|
|
3906 |
/**
|
|
|
3907 |
* Analyzes the data array and calculates the minimum and maximum values
|
|
|
3908 |
*
|
|
|
3909 |
* In this function, IV refers to the independent variable, and DV the dependent
|
|
|
3910 |
* variable. For vertical plots (most common), IV is X and DV is Y. For
|
|
|
3911 |
* horizontal plots (swapped X/Y), IV is Y and DV is X. At the end of the
|
|
|
3912 |
* function, IV and DV ranges get assigned into X or Y variables.
|
|
|
3913 |
*
|
|
|
3914 |
* The data type mostly determines the data array structure, but some plot types
|
|
|
3915 |
* do special things such as sum the values in a row. This information is in the
|
|
|
3916 |
* plots[] array.
|
|
|
3917 |
*
|
|
|
3918 |
* This calculates min_x, max_x, min_y, and max_y. It also calculates two arrays
|
|
|
3919 |
* data_min[] and data_max[] with per-row min and max values. These are used for
|
|
|
3920 |
* data label lines. For vertical plots, these are the Y range for each X. For
|
|
|
3921 |
* vertical (swapped X/Y) plots, they are the X range for each Y. For X/Y/Z
|
|
|
3922 |
* plots, it also calculates min_z and max_z.
|
|
|
3923 |
*
|
|
|
3924 |
* @return bool True always
|
|
|
3925 |
*/
|
|
|
3926 |
protected function FindDataLimits()
|
|
|
3927 |
{
|
|
|
3928 |
// Does this plot type need special processing of the data values?
|
|
|
3929 |
$sum_vals = !empty(self::$plots[$this->plot_type]['sum_vals']); // Add up values in each row
|
|
|
3930 |
$abs_vals = !empty(self::$plots[$this->plot_type]['abs_vals']); // Take absolute values
|
|
|
3931 |
|
|
|
3932 |
// Initialize arrays which track the min/max per-row dependent values:
|
|
|
3933 |
$this->data_min = array();
|
|
|
3934 |
$this->data_max = array();
|
|
|
3935 |
|
|
|
3936 |
// Independent values are in the data array or assumed?
|
|
|
3937 |
if ($this->datatype_implied) {
|
|
|
3938 |
// Range for text-data is 0.5 to num_data_rows-0.5. Add 0.5 fixed margins on each side.
|
|
|
3939 |
$all_iv = array(0, $this->num_data_rows);
|
|
|
3940 |
} else {
|
|
|
3941 |
$all_iv = array(); // Calculated below
|
|
|
3942 |
}
|
|
|
3943 |
// For X/Y/Z plots, make sure these are not left over from a previous plot.
|
|
|
3944 |
if ($this->datatype_yz)
|
|
|
3945 |
$this->min_z = $this->max_z = NULL;
|
|
|
3946 |
|
|
|
3947 |
// Process all rows of data:
|
|
|
3948 |
for ($i = 0; $i < $this->num_data_rows; $i++) {
|
|
|
3949 |
$n_vals = $this->num_recs[$i];
|
|
|
3950 |
$j = 1; // Skips label at [0]
|
|
|
3951 |
|
|
|
3952 |
if (!$this->datatype_implied) {
|
|
|
3953 |
$all_iv[] = (double)$this->data[$i][$j++];
|
|
|
3954 |
}
|
|
|
3955 |
|
|
|
3956 |
if ($sum_vals) {
|
|
|
3957 |
$all_dv = array(0, 0); // One limit is 0, other calculated below
|
|
|
3958 |
} else {
|
|
|
3959 |
$all_dv = array();
|
|
|
3960 |
}
|
|
|
3961 |
while ($j < $n_vals) {
|
|
|
3962 |
if (is_numeric($val = $this->data[$i][$j++])) {
|
|
|
3963 |
|
|
|
3964 |
if ($this->datatype_error_bars) {
|
|
|
3965 |
$all_dv[] = $val + (double)$this->data[$i][$j++];
|
|
|
3966 |
$all_dv[] = $val - (double)$this->data[$i][$j++];
|
|
|
3967 |
} else {
|
|
|
3968 |
if ($abs_vals) {
|
|
|
3969 |
$val = abs($val); // Use absolute values
|
|
|
3970 |
}
|
|
|
3971 |
if ($sum_vals) {
|
|
|
3972 |
$all_dv[1] += $val; // Sum of values
|
|
|
3973 |
} else {
|
|
|
3974 |
$all_dv[] = $val; // List of all values
|
|
|
3975 |
}
|
|
|
3976 |
if ($this->datatype_yz) {
|
|
|
3977 |
$z = $this->data[$i][$j++]; // Note Z is required if Y is present.
|
|
|
3978 |
if (!isset($this->min_z) || $z < $this->min_z) $this->min_z = $z;
|
|
|
3979 |
if (!isset($this->max_z) || $z > $this->max_z) $this->max_z = $z;
|
|
|
3980 |
}
|
|
|
3981 |
}
|
|
|
3982 |
} else { // Missing DV value
|
|
|
3983 |
if ($this->datatype_error_bars) $j += 2;
|
|
|
3984 |
elseif ($this->datatype_yz) $j++;
|
|
|
3985 |
}
|
|
|
3986 |
}
|
|
|
3987 |
if (!empty($all_dv)) {
|
|
|
3988 |
$this->data_min[$i] = min($all_dv); // Store per-row DV range
|
|
|
3989 |
$this->data_max[$i] = max($all_dv);
|
|
|
3990 |
}
|
|
|
3991 |
}
|
|
|
3992 |
|
|
|
3993 |
if ($this->datatype_swapped_xy) {
|
|
|
3994 |
// Assign min and max for swapped X/Y plots: IV=Y and DV=X
|
|
|
3995 |
$this->min_y = min($all_iv);
|
|
|
3996 |
$this->max_y = max($all_iv);
|
|
|
3997 |
if (empty($this->data_min)) { // Guard against regressive case: No X at all
|
|
|
3998 |
$this->min_x = 0;
|
|
|
3999 |
$this->max_x = 0;
|
|
|
4000 |
} else {
|
|
|
4001 |
$this->min_x = min($this->data_min); // Store global X range
|
|
|
4002 |
$this->max_x = max($this->data_max);
|
|
|
4003 |
}
|
|
|
4004 |
} else {
|
|
|
4005 |
// Assign min and max for normal plots: IV=X and DV=Y
|
|
|
4006 |
$this->min_x = min($all_iv);
|
|
|
4007 |
$this->max_x = max($all_iv);
|
|
|
4008 |
if (empty($this->data_min)) { // Guard against regressive case: No Y at all
|
|
|
4009 |
$this->min_y = 0;
|
|
|
4010 |
$this->max_y = 0;
|
|
|
4011 |
} else {
|
|
|
4012 |
$this->min_y = min($this->data_min); // Store global Y range
|
|
|
4013 |
$this->max_y = max($this->data_max);
|
|
|
4014 |
}
|
|
|
4015 |
}
|
|
|
4016 |
// For X/Y/Z plots, make sure these are set. If there are no valid data values,
|
|
|
4017 |
// they will be unset, so set them here to prevent undefined property warnings.
|
|
|
4018 |
if ($this->datatype_yz && !isset($this->min_z)) { // Means max_z is also unset
|
|
|
4019 |
$this->max_z = $this->min_z = 0; // Actual values do not matter.
|
|
|
4020 |
}
|
|
|
4021 |
|
|
|
4022 |
if ($this->GetCallback('debug_scale')) {
|
|
|
4023 |
$this->DoCallback('debug_scale', __FUNCTION__, array(
|
|
|
4024 |
'min_x' => $this->min_x, 'min_y' => $this->min_y,
|
|
|
4025 |
'max_x' => $this->max_x, 'max_y' => $this->max_y,
|
|
|
4026 |
'min_z' => isset($this->min_z) ? $this->min_z : '',
|
|
|
4027 |
'max_z' => isset($this->max_z) ? $this->max_z : ''));
|
|
|
4028 |
}
|
|
|
4029 |
return TRUE;
|
|
|
4030 |
}
|
|
|
4031 |
|
|
|
4032 |
/**
|
|
|
4033 |
* Calculates the plot area margin size and related positions and offsets
|
|
|
4034 |
*
|
|
|
4035 |
* Calculates the title sizes: title_height, x_title_height, and y_title_width.
|
|
|
4036 |
* These are local, not class variables, since they are only used here.
|
|
|
4037 |
* The X and Y title size variables are 0 if there is no corresponding title.
|
|
|
4038 |
*
|
|
|
4039 |
* Calculates the tick label and axis data label offsets, relative to the plot
|
|
|
4040 |
* area: x_label_top_offset, x_label_bot_offset, x_label_axis_offset,
|
|
|
4041 |
* y_label_left_offset, y_label_right_offset, and y_label_axis_offset.
|
|
|
4042 |
*
|
|
|
4043 |
* Calculates the title position offsets, relative to the plot area:
|
|
|
4044 |
* x_title_top_offset, x_title_bot_offset, y_title_left_offset, and
|
|
|
4045 |
* y_title_left_offset. Also calculates the main title offset, which is relative
|
|
|
4046 |
* to the top of the image.
|
|
|
4047 |
*
|
|
|
4048 |
* Finally, calculates the plot area margins using the above to figure out how
|
|
|
4049 |
* much space outside the plot area is needed. The class variables are:
|
|
|
4050 |
* y_top_margin, y_bot_margin, x_left_margin, and x_right_margin. All 4 margins
|
|
|
4051 |
* are calculated, but only those not set with SetPlotAreaPixels() or
|
|
|
4052 |
* SetMarginsPixels() are stored into the class variables.
|
|
|
4053 |
*
|
|
|
4054 |
* A plot with $minimize True, such as a pie chart, does not have an X or Y axis
|
|
|
4055 |
* or X/Y titles, and so can use more of the image space.
|
|
|
4056 |
*
|
|
|
4057 |
* A picture of the locations of elements and spacing can be found in the
|
|
|
4058 |
* PHPlot Reference Manual.
|
|
|
4059 |
*
|
|
|
4060 |
* @param bool $maximize If True, use full image area (less margins and title space)
|
|
|
4061 |
* @return bool True always
|
|
|
4062 |
*/
|
|
|
4063 |
protected function CalcMargins($maximize)
|
|
|
4064 |
{
|
|
|
4065 |
// This is the line-to-line or line-to-text spacing:
|
|
|
4066 |
$gap = $this->safe_margin;
|
|
|
4067 |
// Initial margin on each side takes into account a possible image border.
|
|
|
4068 |
// For compatibility, if border is 1 or 2, don't increase the margins.
|
|
|
4069 |
$base_margin = max($gap, $this->GetImageBorderWidth() + 3);
|
|
|
4070 |
$this->title_offset = $base_margin; // For use in DrawTitle
|
|
|
4071 |
|
|
|
4072 |
// Minimum margin on each side. This reduces the chance that the
|
|
|
4073 |
// right-most tick label (for example) will run off the image edge
|
|
|
4074 |
// if there are no titles on that side.
|
|
|
4075 |
$min_margin = 2 * $gap + $base_margin;
|
|
|
4076 |
|
|
|
4077 |
// Calculate the title sizes (main here, axis titles below):
|
|
|
4078 |
list($unused, $title_height) = $this->SizeText('title', 0, $this->title_txt);
|
|
|
4079 |
|
|
|
4080 |
// Special case for maximum area usage with no X/Y titles or labels, only main title:
|
|
|
4081 |
if ($maximize) {
|
|
|
4082 |
if (!isset($this->x_left_margin))
|
|
|
4083 |
$this->x_left_margin = $base_margin;
|
|
|
4084 |
if (!isset($this->x_right_margin))
|
|
|
4085 |
$this->x_right_margin = $base_margin;
|
|
|
4086 |
if (!isset($this->y_top_margin)) {
|
|
|
4087 |
$this->y_top_margin = $base_margin;
|
|
|
4088 |
if ($title_height > 0)
|
|
|
4089 |
$this->y_top_margin += $title_height + $gap;
|
|
|
4090 |
}
|
|
|
4091 |
if (!isset($this->y_bot_margin))
|
|
|
4092 |
$this->y_bot_margin = $base_margin;
|
|
|
4093 |
|
|
|
4094 |
return TRUE;
|
|
|
4095 |
}
|
|
|
4096 |
|
|
|
4097 |
list($unused, $x_title_height) = $this->SizeText('x_title', 0, $this->x_title_txt);
|
|
|
4098 |
list($y_title_width, $unused) = $this->SizeText('y_title', 90, $this->y_title_txt);
|
|
|
4099 |
|
|
|
4100 |
// For X/Y tick and label position of 'xaxis' or 'yaxis', determine if the axis happens to be
|
|
|
4101 |
// on an edge of a plot. If it is, we need to account for the margins there.
|
|
|
4102 |
if ($this->x_axis_position <= $this->plot_min_y)
|
|
|
4103 |
$x_axis_pos = 'bottom';
|
|
|
4104 |
elseif ($this->x_axis_position >= $this->plot_max_y)
|
|
|
4105 |
$x_axis_pos = 'top';
|
|
|
4106 |
else
|
|
|
4107 |
$x_axis_pos = 'none';
|
|
|
4108 |
if ($this->y_axis_position <= $this->plot_min_x)
|
|
|
4109 |
$y_axis_pos = 'left';
|
|
|
4110 |
elseif ($this->y_axis_position >= $this->plot_max_x)
|
|
|
4111 |
$y_axis_pos = 'right';
|
|
|
4112 |
else
|
|
|
4113 |
$y_axis_pos = 'none';
|
|
|
4114 |
|
|
|
4115 |
// Calculate the heights for X tick and data labels, and the max (used if they are overlaid):
|
|
|
4116 |
$x_data_label_height = ($this->x_data_label_pos == 'none') ? 0 : $this->CalcMaxDataLabelSize('x');
|
|
|
4117 |
$x_tick_label_height = ($this->x_tick_label_pos == 'none') ? 0 : $this->CalcMaxTickLabelSize('x');
|
|
|
4118 |
$x_max_label_height = max($x_data_label_height, $x_tick_label_height);
|
|
|
4119 |
|
|
|
4120 |
// Calculate the space needed above and below the plot for X tick and X data labels:
|
|
|
4121 |
|
|
|
4122 |
// Above the plot:
|
|
|
4123 |
$tick_labels_above = ($this->x_tick_label_pos == 'plotup' || $this->x_tick_label_pos == 'both'
|
|
|
4124 |
|| ($this->x_tick_label_pos == 'xaxis' && $x_axis_pos == 'top'));
|
|
|
4125 |
$data_labels_above = ($this->x_data_label_pos == 'plotup' || $this->x_data_label_pos == 'both');
|
|
|
4126 |
if ($tick_labels_above) {
|
|
|
4127 |
if ($data_labels_above) {
|
|
|
4128 |
$label_height_above = $x_max_label_height;
|
|
|
4129 |
} else {
|
|
|
4130 |
$label_height_above = $x_tick_label_height;
|
|
|
4131 |
}
|
|
|
4132 |
} elseif ($data_labels_above) {
|
|
|
4133 |
$label_height_above = $x_data_label_height;
|
|
|
4134 |
} else {
|
|
|
4135 |
$label_height_above = 0;
|
|
|
4136 |
}
|
|
|
4137 |
|
|
|
4138 |
// Below the plot:
|
|
|
4139 |
$tick_labels_below = ($this->x_tick_label_pos == 'plotdown' || $this->x_tick_label_pos == 'both'
|
|
|
4140 |
|| ($this->x_tick_label_pos == 'xaxis' && $x_axis_pos == 'bottom'));
|
|
|
4141 |
$data_labels_below = ($this->x_data_label_pos == 'plotdown' || $this->x_data_label_pos == 'both');
|
|
|
4142 |
if ($tick_labels_below) {
|
|
|
4143 |
if ($data_labels_below) {
|
|
|
4144 |
$label_height_below = $x_max_label_height;
|
|
|
4145 |
} else {
|
|
|
4146 |
$label_height_below = $x_tick_label_height;
|
|
|
4147 |
}
|
|
|
4148 |
} elseif ($data_labels_below) {
|
|
|
4149 |
$label_height_below = $x_data_label_height;
|
|
|
4150 |
} else {
|
|
|
4151 |
$label_height_below = 0;
|
|
|
4152 |
}
|
|
|
4153 |
|
|
|
4154 |
// Calculate the width for Y tick and data labels, if on, and the max:
|
|
|
4155 |
// Note CalcMaxDataLabelSize('y') returns 0 except for swapped X/Y plots.
|
|
|
4156 |
$y_data_label_width = ($this->y_data_label_pos == 'none') ? 0 : $this->CalcMaxDataLabelSize('y');
|
|
|
4157 |
$y_tick_label_width = ($this->y_tick_label_pos == 'none') ? 0 : $this->CalcMaxTickLabelSize('y');
|
|
|
4158 |
$y_max_label_width = max($y_data_label_width, $y_tick_label_width);
|
|
|
4159 |
|
|
|
4160 |
// Calculate the space needed left and right of the plot for Y tick and Y data labels:
|
|
|
4161 |
// (Y data labels here are for swapped X/Y plots such has horizontal bars)
|
|
|
4162 |
|
|
|
4163 |
// Left of the plot:
|
|
|
4164 |
$tick_labels_left = ($this->y_tick_label_pos == 'plotleft' || $this->y_tick_label_pos == 'both'
|
|
|
4165 |
|| ($this->y_tick_label_pos == 'yaxis' && $y_axis_pos == 'left'));
|
|
|
4166 |
$data_labels_left = ($this->y_data_label_pos == 'plotleft' || $this->y_data_label_pos == 'both');
|
|
|
4167 |
if ($tick_labels_left) {
|
|
|
4168 |
if ($data_labels_left) {
|
|
|
4169 |
$label_width_left = $y_max_label_width;
|
|
|
4170 |
} else {
|
|
|
4171 |
$label_width_left = $y_tick_label_width;
|
|
|
4172 |
}
|
|
|
4173 |
} elseif ($data_labels_left) {
|
|
|
4174 |
$label_width_left = $y_data_label_width;
|
|
|
4175 |
} else {
|
|
|
4176 |
$label_width_left = 0;
|
|
|
4177 |
}
|
|
|
4178 |
|
|
|
4179 |
// Right of the plot:
|
|
|
4180 |
$tick_labels_right = ($this->y_tick_label_pos == 'plotright' || $this->y_tick_label_pos == 'both'
|
|
|
4181 |
|| ($this->y_tick_label_pos == 'yaxis' && $y_axis_pos == 'right'));
|
|
|
4182 |
$data_labels_right = ($this->y_data_label_pos == 'plotright' || $this->y_data_label_pos == 'both');
|
|
|
4183 |
if ($tick_labels_right) {
|
|
|
4184 |
if ($data_labels_right) {
|
|
|
4185 |
$label_width_right = $y_max_label_width;
|
|
|
4186 |
} else {
|
|
|
4187 |
$label_width_right = $y_tick_label_width;
|
|
|
4188 |
}
|
|
|
4189 |
} elseif ($data_labels_right) {
|
|
|
4190 |
$label_width_right = $y_data_label_width;
|
|
|
4191 |
} else {
|
|
|
4192 |
$label_width_right = 0;
|
|
|
4193 |
}
|
|
|
4194 |
|
|
|
4195 |
///////// Calculate margins:
|
|
|
4196 |
|
|
|
4197 |
// Calculating Top and Bottom margins:
|
|
|
4198 |
// y_top_margin: Main title, Upper X title, X ticks and tick labels, and X data labels:
|
|
|
4199 |
// y_bot_margin: Lower title, ticks and tick labels, and data labels:
|
|
|
4200 |
$top_margin = $base_margin;
|
|
|
4201 |
$bot_margin = $base_margin;
|
|
|
4202 |
$this->x_title_top_offset = $gap;
|
|
|
4203 |
$this->x_title_bot_offset = $gap;
|
|
|
4204 |
|
|
|
4205 |
// Space for main title?
|
|
|
4206 |
if ($title_height > 0)
|
|
|
4207 |
$top_margin += $title_height + $gap;
|
|
|
4208 |
|
|
|
4209 |
// Reserve space for X title, above and/or below as needed:
|
|
|
4210 |
if ($x_title_height > 0 && ($pos = $this->x_title_pos) != 'none') {
|
|
|
4211 |
if ($pos == 'plotup' || $pos == 'both')
|
|
|
4212 |
$top_margin += $x_title_height + $gap;
|
|
|
4213 |
if ($pos == 'plotdown' || $pos == 'both')
|
|
|
4214 |
$bot_margin += $x_title_height + $gap;
|
|
|
4215 |
}
|
|
|
4216 |
|
|
|
4217 |
// Space for X Labels above the plot?
|
|
|
4218 |
if ($label_height_above > 0) {
|
|
|
4219 |
$top_margin += $label_height_above + $gap;
|
|
|
4220 |
$this->x_title_top_offset += $label_height_above + $gap;
|
|
|
4221 |
}
|
|
|
4222 |
|
|
|
4223 |
// Space for X Labels below the plot?
|
|
|
4224 |
if ($label_height_below > 0) {
|
|
|
4225 |
$bot_margin += $label_height_below + $gap;
|
|
|
4226 |
$this->x_title_bot_offset += $label_height_below + $gap;
|
|
|
4227 |
}
|
|
|
4228 |
|
|
|
4229 |
// Space for X Ticks above the plot?
|
|
|
4230 |
if ($this->x_tick_pos == 'plotup' || $this->x_tick_pos == 'both'
|
|
|
4231 |
|| ($this->x_tick_pos == 'xaxis' && $x_axis_pos == 'top')) {
|
|
|
4232 |
$top_margin += $this->x_tick_length;
|
|
|
4233 |
$this->x_label_top_offset = $this->x_tick_length + $gap;
|
|
|
4234 |
$this->x_title_top_offset += $this->x_tick_length;
|
|
|
4235 |
} else {
|
|
|
4236 |
// No X Ticks above the plot:
|
|
|
4237 |
$this->x_label_top_offset = $gap;
|
|
|
4238 |
}
|
|
|
4239 |
|
|
|
4240 |
// Space for X Ticks below the plot?
|
|
|
4241 |
if ($this->x_tick_pos == 'plotdown' || $this->x_tick_pos == 'both'
|
|
|
4242 |
|| ($this->x_tick_pos == 'xaxis' && $x_axis_pos == 'bottom')) {
|
|
|
4243 |
$bot_margin += $this->x_tick_length;
|
|
|
4244 |
$this->x_label_bot_offset = $this->x_tick_length + $gap;
|
|
|
4245 |
$this->x_title_bot_offset += $this->x_tick_length;
|
|
|
4246 |
} else {
|
|
|
4247 |
// No X Ticks below the plot:
|
|
|
4248 |
$this->x_label_bot_offset = $gap;
|
|
|
4249 |
}
|
|
|
4250 |
// Label offsets for on-axis ticks:
|
|
|
4251 |
if ($this->x_tick_pos == 'xaxis') {
|
|
|
4252 |
$this->x_label_axis_offset = $this->x_tick_length + $gap;
|
|
|
4253 |
} else {
|
|
|
4254 |
$this->x_label_axis_offset = $gap;
|
|
|
4255 |
}
|
|
|
4256 |
|
|
|
4257 |
// Calculating Left and Right margins:
|
|
|
4258 |
// x_left_margin: Left Y title, Y ticks and tick labels:
|
|
|
4259 |
// x_right_margin: Right Y title, Y ticks and tick labels:
|
|
|
4260 |
$left_margin = $base_margin;
|
|
|
4261 |
$right_margin = $base_margin;
|
|
|
4262 |
$this->y_title_left_offset = $gap;
|
|
|
4263 |
$this->y_title_right_offset = $gap;
|
|
|
4264 |
|
|
|
4265 |
// Reserve space for Y title, on left and/or right as needed:
|
|
|
4266 |
if ($y_title_width > 0 && ($pos = $this->y_title_pos) != 'none') {
|
|
|
4267 |
if ($pos == 'plotleft' || $pos == 'both')
|
|
|
4268 |
$left_margin += $y_title_width + $gap;
|
|
|
4269 |
if ($pos == 'plotright' || $pos == 'both')
|
|
|
4270 |
$right_margin += $y_title_width + $gap;
|
|
|
4271 |
}
|
|
|
4272 |
|
|
|
4273 |
// Space for Y Labels left of the plot?
|
|
|
4274 |
if ($label_width_left > 0) {
|
|
|
4275 |
$left_margin += $label_width_left + $gap;
|
|
|
4276 |
$this->y_title_left_offset += $label_width_left + $gap;
|
|
|
4277 |
}
|
|
|
4278 |
|
|
|
4279 |
// Space for Y Labels right of the plot?
|
|
|
4280 |
if ($label_width_right > 0) {
|
|
|
4281 |
$right_margin += $label_width_right + $gap;
|
|
|
4282 |
$this->y_title_right_offset += $label_width_right + $gap;
|
|
|
4283 |
}
|
|
|
4284 |
|
|
|
4285 |
// Space for Y Ticks left of plot?
|
|
|
4286 |
if ($this->y_tick_pos == 'plotleft' || $this->y_tick_pos == 'both'
|
|
|
4287 |
|| ($this->y_tick_pos == 'yaxis' && $y_axis_pos == 'left')) {
|
|
|
4288 |
$left_margin += $this->y_tick_length;
|
|
|
4289 |
$this->y_label_left_offset = $this->y_tick_length + $gap;
|
|
|
4290 |
$this->y_title_left_offset += $this->y_tick_length;
|
|
|
4291 |
} else {
|
|
|
4292 |
// No Y Ticks left of plot:
|
|
|
4293 |
$this->y_label_left_offset = $gap;
|
|
|
4294 |
}
|
|
|
4295 |
|
|
|
4296 |
// Space for Y Ticks right of plot?
|
|
|
4297 |
if ($this->y_tick_pos == 'plotright' || $this->y_tick_pos == 'both'
|
|
|
4298 |
|| ($this->y_tick_pos == 'yaxis' && $y_axis_pos == 'right')) {
|
|
|
4299 |
$right_margin += $this->y_tick_length;
|
|
|
4300 |
$this->y_label_right_offset = $this->y_tick_length + $gap;
|
|
|
4301 |
$this->y_title_right_offset += $this->y_tick_length;
|
|
|
4302 |
} else {
|
|
|
4303 |
// No Y Ticks right of plot:
|
|
|
4304 |
$this->y_label_right_offset = $gap;
|
|
|
4305 |
}
|
|
|
4306 |
|
|
|
4307 |
// Label offsets for on-axis ticks:
|
|
|
4308 |
if ($this->x_tick_pos == 'yaxis') {
|
|
|
4309 |
$this->y_label_axis_offset = $this->y_tick_length + $gap;
|
|
|
4310 |
} else {
|
|
|
4311 |
$this->y_label_axis_offset = $gap;
|
|
|
4312 |
}
|
|
|
4313 |
|
|
|
4314 |
// Apply the minimum margins and store in the object.
|
|
|
4315 |
// Do not set margins which were user-defined (see note at top of function).
|
|
|
4316 |
if (!isset($this->y_top_margin))
|
|
|
4317 |
$this->y_top_margin = max($min_margin, $top_margin);
|
|
|
4318 |
if (!isset($this->y_bot_margin))
|
|
|
4319 |
$this->y_bot_margin = max($min_margin, $bot_margin);
|
|
|
4320 |
if (!isset($this->x_left_margin))
|
|
|
4321 |
$this->x_left_margin = max($min_margin, $left_margin);
|
|
|
4322 |
if (!isset($this->x_right_margin))
|
|
|
4323 |
$this->x_right_margin = max($min_margin, $right_margin);
|
|
|
4324 |
|
|
|
4325 |
if ($this->GetCallback('debug_scale')) {
|
|
|
4326 |
// (Too bad compact() doesn't work on class member variables...)
|
|
|
4327 |
$this->DoCallback('debug_scale', __FUNCTION__, array(
|
|
|
4328 |
'label_height_above' => $label_height_above,
|
|
|
4329 |
'label_height_below' => $label_height_below,
|
|
|
4330 |
'label_width_left' => $label_width_left,
|
|
|
4331 |
'label_width_right' => $label_width_right,
|
|
|
4332 |
'x_tick_length' => $this->x_tick_length,
|
|
|
4333 |
'y_tick_length' => $this->y_tick_length,
|
|
|
4334 |
'x_left_margin' => $this->x_left_margin,
|
|
|
4335 |
'x_right_margin' => $this->x_right_margin,
|
|
|
4336 |
'y_top_margin' => $this->y_top_margin,
|
|
|
4337 |
'y_bot_margin' => $this->y_bot_margin,
|
|
|
4338 |
'x_label_top_offset' => $this->x_label_top_offset,
|
|
|
4339 |
'x_label_bot_offset' => $this->x_label_bot_offset,
|
|
|
4340 |
'y_label_left_offset' => $this->y_label_left_offset,
|
|
|
4341 |
'y_label_right_offset' => $this->y_label_right_offset,
|
|
|
4342 |
'x_title_top_offset' => $this->x_title_top_offset,
|
|
|
4343 |
'x_title_bot_offset' => $this->x_title_bot_offset,
|
|
|
4344 |
'y_title_left_offset' => $this->y_title_left_offset,
|
|
|
4345 |
'y_title_right_offset' => $this->y_title_right_offset));
|
|
|
4346 |
}
|
|
|
4347 |
|
|
|
4348 |
return TRUE;
|
|
|
4349 |
}
|
|
|
4350 |
|
|
|
4351 |
/**
|
|
|
4352 |
* Calculates the plot area (in pixels) from the margins
|
|
|
4353 |
*
|
|
|
4354 |
* This does the deferred calculation of class variables plot_area,
|
|
|
4355 |
* plot_area_width, and plot_area_height. The margins might come
|
|
|
4356 |
* from SetMarginsPixels(), SetPlotAreaPixels(), or CalcMargins().
|
|
|
4357 |
*
|
|
|
4358 |
* @return bool True always
|
|
|
4359 |
* @since 5.0.5
|
|
|
4360 |
*/
|
|
|
4361 |
protected function CalcPlotAreaPixels()
|
|
|
4362 |
{
|
|
|
4363 |
$this->plot_area = array($this->x_left_margin, $this->y_top_margin,
|
|
|
4364 |
$this->image_width - $this->x_right_margin,
|
|
|
4365 |
$this->image_height - $this->y_bot_margin);
|
|
|
4366 |
$this->plot_area_width = $this->plot_area[2] - $this->plot_area[0];
|
|
|
4367 |
$this->plot_area_height = $this->plot_area[3] - $this->plot_area[1];
|
|
|
4368 |
|
|
|
4369 |
$this->DoCallback('debug_scale', __FUNCTION__, $this->plot_area);
|
|
|
4370 |
return TRUE;
|
|
|
4371 |
}
|
|
|
4372 |
|
|
|
4373 |
/**
|
|
|
4374 |
* Sets the margins around the plot area
|
|
|
4375 |
*
|
|
|
4376 |
* This determines the plot area, equivalent to SetPlotAreaPixels()
|
|
|
4377 |
* but instead of giving the plot area size, you give the margin sizes.
|
|
|
4378 |
*
|
|
|
4379 |
* @param int $which_lm Left margin in pixels; omit or NULL to auto-calculate
|
|
|
4380 |
* @param int $which_rm Right margin in pixels; omit or NULL to auto-calculate
|
|
|
4381 |
* @param int $which_tm Top margin in pixels; omit or NULL to auto-calculate
|
|
|
4382 |
* @param int $which_bm Bottom margin in pixels; omit or NULL to auto-calculate
|
|
|
4383 |
* @return bool True always
|
|
|
4384 |
*/
|
|
|
4385 |
function SetMarginsPixels($which_lm = NULL, $which_rm = NULL, $which_tm = NULL, $which_bm = NULL)
|
|
|
4386 |
{
|
|
|
4387 |
$this->x_left_margin = $which_lm;
|
|
|
4388 |
$this->x_right_margin = $which_rm;
|
|
|
4389 |
$this->y_top_margin = $which_tm;
|
|
|
4390 |
$this->y_bot_margin = $which_bm;
|
|
|
4391 |
return TRUE;
|
|
|
4392 |
}
|
|
|
4393 |
|
|
|
4394 |
/**
|
|
|
4395 |
* Sets the limits for the plot area, in device coordinates
|
|
|
4396 |
*
|
|
|
4397 |
* This determines the plot area, equivalent to SetMarginsPixels()
|
|
|
4398 |
* but instead of giving the margin sizes, you give the plot area size,
|
|
|
4399 |
*
|
|
|
4400 |
* This stores the margins, not the area. That may seem odd, but the idea is
|
|
|
4401 |
* to make SetPlotAreaPixels and SetMarginsPixels two ways to accomplish the
|
|
|
4402 |
* same thing, and the deferred calculations in CalcMargins and
|
|
|
4403 |
* CalcPlotAreaPixels don't need to know which was used.
|
|
|
4404 |
*
|
|
|
4405 |
* @param int $x1 Top left corner X coordinate in pixels; omit or NULL to auto-calculate
|
|
|
4406 |
* @param int $y1 Top left corner Y coordinate in pixels; omit or NULL to auto-calculate
|
|
|
4407 |
* @param int $x2 Bottom right corner X coordinate in pixels; omit or NULL to auto-calculate
|
|
|
4408 |
* @param int $y2 Bottom right corner Y coordinate in pixels; omit or NULL to auto-calculate
|
|
|
4409 |
* @return bool True always
|
|
|
4410 |
*/
|
|
|
4411 |
function SetPlotAreaPixels($x1 = NULL, $y1 = NULL, $x2 = NULL, $y2 = NULL)
|
|
|
4412 |
{
|
|
|
4413 |
$this->x_left_margin = $x1;
|
|
|
4414 |
$this->x_right_margin = isset($x2) ? $this->image_width - $x2 : NULL;
|
|
|
4415 |
$this->y_top_margin = $y1;
|
|
|
4416 |
$this->y_bot_margin = isset($y2) ? $this->image_height - $y2 : NULL;
|
|
|
4417 |
return TRUE;
|
|
|
4418 |
}
|
|
|
4419 |
|
|
|
4420 |
/**
|
|
|
4421 |
* Calculates an appropriate tick increment in 'decimal' mode
|
|
|
4422 |
*
|
|
|
4423 |
* This is used by CalcStep(). It returns the largest value that is 1, 2, or 5
|
|
|
4424 |
* times an integer power of 10, and which divides the data range into no fewer
|
|
|
4425 |
* than min_ticks tick intervals.
|
|
|
4426 |
*
|
|
|
4427 |
* @param float $range The data range (max - min), already checked as > 0
|
|
|
4428 |
* @param int $min_ticks Smallest number of intervals allowed, already checked > 0
|
|
|
4429 |
* @return float The calculated tick increment
|
|
|
4430 |
* @since 6.0.0
|
|
|
4431 |
*/
|
|
|
4432 |
protected function CalcStep125($range, $min_ticks)
|
|
|
4433 |
{
|
|
|
4434 |
$v = log10($range / $min_ticks);
|
|
|
4435 |
$vi = (int)floor($v);
|
|
|
4436 |
$tick_step = pow(10, $vi);
|
|
|
4437 |
$f = $v - $vi;
|
|
|
4438 |
if ($f > 0.69897) $tick_step *= 5; // Note 0.69897 = log10(5)
|
|
|
4439 |
elseif ($f > 0.301) $tick_step *= 2; // Note 0.30103 = log10(2), truncated to fix edge cases
|
|
|
4440 |
return $tick_step;
|
|
|
4441 |
}
|
|
|
4442 |
|
|
|
4443 |
/**
|
|
|
4444 |
* Calculates an appropriate tick increment in 'date/time' mode
|
|
|
4445 |
*
|
|
|
4446 |
* This is used by CalcStep() when the axis values use date/time units.
|
|
|
4447 |
* Unlike in CalcStep125(), there is no equation to compute this, so an array
|
|
|
4448 |
* $datetime_steps is used. The values are "natural" time intervals, keeping
|
|
|
4449 |
* the ratio between adjacent entries <= 2.5 (so that max_ticks <= 2.5*min_ticks).
|
|
|
4450 |
* For seconds or minutes, it uses: 1 2 5 10 15 30. For hours, it uses 1 2 4 8 12
|
|
|
4451 |
* 24 48 96 and 168 (=7 days). Above that, it falls back to CalcStep125 using days.
|
|
|
4452 |
*
|
|
|
4453 |
* @param float $range The data range (max - min), already checked as > 0
|
|
|
4454 |
* @param int $min_ticks Smallest number of intervals allowed, already checked > 0
|
|
|
4455 |
* @return int The calculated tick increment. This will always be >= 1 second
|
|
|
4456 |
* @since 6.0.0
|
|
|
4457 |
*/
|
|
|
4458 |
protected function CalcStepDatetime($range, $min_ticks)
|
|
|
4459 |
{
|
|
|
4460 |
static $datetime_steps = array(1, 2, 5, 10, 15, 30, 60, 120, 300, 600, 900, 1800, 3600,
|
|
|
4461 |
7200, 14400, 28800, 43200, 86400, 172800, 345600, 604800);
|
|
|
4462 |
static $datetime_limit = 1512000; // 1 week times 2.5, in seconds.
|
|
|
4463 |
|
|
|
4464 |
if ($range < $min_ticks) {
|
|
|
4465 |
$tick_step = 1; // Range is too small; minimum interval is 1 second.
|
|
|
4466 |
} elseif (($tick_limit = $range / $min_ticks) <= $datetime_limit) {
|
|
|
4467 |
// Find the biggest value in the table <= tick_limit (which is the
|
|
|
4468 |
// exact interval which would give min_ticks steps):
|
|
|
4469 |
foreach ($datetime_steps as $v) {
|
|
|
4470 |
if ($v <= $tick_limit) $tick_step = $v;
|
|
|
4471 |
else break;
|
|
|
4472 |
}
|
|
|
4473 |
} else {
|
|
|
4474 |
// Use the numeric-mode algorithm to find a 1,2,5*10**n solution, in units of days.
|
|
|
4475 |
$tick_step = $this->CalcStep125($range / 86400, $min_ticks) * 86400;
|
|
|
4476 |
}
|
|
|
4477 |
return $tick_step;
|
|
|
4478 |
}
|
|
|
4479 |
|
|
|
4480 |
/**
|
|
|
4481 |
* Calculates an appropriate tick increment in 'binary' mode
|
|
|
4482 |
*
|
|
|
4483 |
* This is used by CalcStep(). It returns the largest power of 2 that divides
|
|
|
4484 |
* the range into at least min_ticks intervals.
|
|
|
4485 |
* Note: This contains an ugly work-around to a round-off problem. Using
|
|
|
4486 |
* floor(log2(2^N)) should produce N for all integer N, but with glibc, it turns
|
|
|
4487 |
* out that log2(8) is slightly < 3, and similar for a few other values (64, 4096,
|
|
|
4488 |
* 8192). So they truncate to N-1. Other tested values, and all negative values,
|
|
|
4489 |
* and all values on Windows, were found to truncate with floor() in the right
|
|
|
4490 |
* direction. The adjustment below makes all values N=-50 to 50 truncate correctly.
|
|
|
4491 |
*
|
|
|
4492 |
* @param float $range The data range (max - min), already checked as > 0
|
|
|
4493 |
* @param int $min_ticks Smallest number of intervals allowed, already checked > 0
|
|
|
4494 |
* @return float The calculated tick increment
|
|
|
4495 |
* @since 6.0.0
|
|
|
4496 |
*/
|
|
|
4497 |
protected function CalcStepBinary($range, $min_ticks)
|
|
|
4498 |
{
|
|
|
4499 |
$log2 = log($range / $min_ticks, 2);
|
|
|
4500 |
if ($log2 > 0) $log2 *= 1.000001; // See note above
|
|
|
4501 |
return pow(2, (int)floor($log2));
|
|
|
4502 |
}
|
|
|
4503 |
|
|
|
4504 |
/**
|
|
|
4505 |
* Calculates an ideal tick increment for a given range
|
|
|
4506 |
*
|
|
|
4507 |
* This is only used when neither Set[XY]TickIncrement nor SetNum[XY]Ticks was used.
|
|
|
4508 |
*
|
|
|
4509 |
* @param string $which Which axis to calculate for. Must be 'x' or 'y'
|
|
|
4510 |
* @param float $range The data range (max - min), already checked as > 0
|
|
|
4511 |
* @return float The tick increment, using one of 3 methods depending on the 'tick_mode'
|
|
|
4512 |
* @since 6.0.0
|
|
|
4513 |
*/
|
|
|
4514 |
protected function CalcStep($which, $range)
|
|
|
4515 |
{
|
|
|
4516 |
// Get tick control variables: min_ticks, tick_mode, tick_inc_integer.
|
|
|
4517 |
extract($this->tickctl[$which]);
|
|
|
4518 |
|
|
|
4519 |
// If tick_mode is null, default to decimal mode unless the axis uses date/time formatting:
|
|
|
4520 |
if (!isset($tick_mode)) {
|
|
|
4521 |
if (isset($this->label_format[$which]['type']) && $this->label_format[$which]['type'] == 'time')
|
|
|
4522 |
$tick_mode = 'date';
|
|
|
4523 |
else
|
|
|
4524 |
$tick_mode = 'decimal';
|
|
|
4525 |
}
|
|
|
4526 |
|
|
|
4527 |
// Use proper mode to calculate the tick increment, with integer override option.
|
|
|
4528 |
if ($tick_mode == 'date') {
|
|
|
4529 |
$tick_step = $this->CalcStepDatetime($range, $min_ticks);
|
|
|
4530 |
} elseif ($tick_inc_integer && $range <= $min_ticks) {
|
|
|
4531 |
$tick_step = 1; // Whole integer ticks selected but range is too small.
|
|
|
4532 |
} elseif ($tick_mode == 'binary') {
|
|
|
4533 |
$tick_step = $this->CalcStepBinary($range, $min_ticks);
|
|
|
4534 |
} else {
|
|
|
4535 |
$tick_step = $this->CalcStep125($range, $min_ticks);
|
|
|
4536 |
}
|
|
|
4537 |
return $tick_step;
|
|
|
4538 |
}
|
|
|
4539 |
|
|
|
4540 |
/**
|
|
|
4541 |
* Initializes range variables for CalcPlotRange()
|
|
|
4542 |
*
|
|
|
4543 |
* This is a helper for CalcPlotRange(), which calls it 4 times, to initialize
|
|
|
4544 |
* each end of the range for each axis. It also sets flags to indicate
|
|
|
4545 |
* whether automatic adjustment of the range end is needed.
|
|
|
4546 |
*
|
|
|
4547 |
* @param float $plot_limit Reference to (possibly unset) plot_min_[xy] or plot_max_[xy]
|
|
|
4548 |
* @param bool $implied True if this is the implied variable (X for vertical plots)
|
|
|
4549 |
* @param float $data_limit Actual data limit at this end: one of min_x, max_x, etc.
|
|
|
4550 |
* @return array Array with (initial value of the range limit, adjustment flag)
|
|
|
4551 |
* @since 6.0.0
|
|
|
4552 |
*/
|
|
|
4553 |
protected function CalcRangeInit(&$plot_limit, $implied, $data_limit)
|
|
|
4554 |
{
|
|
|
4555 |
if (isset($plot_limit) && $plot_limit !== '') {
|
|
|
4556 |
// Use the user-supplied value, and do no further adjustments.
|
|
|
4557 |
return array($plot_limit, FALSE);
|
|
|
4558 |
}
|
|
|
4559 |
// Start with the actual data range. Set adjustment flag TRUE unless the range was implied.
|
|
|
4560 |
return array($data_limit, !$implied);
|
|
|
4561 |
}
|
|
|
4562 |
|
|
|
4563 |
/**
|
|
|
4564 |
* Checks for a positive plot area range, and adjust if necessary
|
|
|
4565 |
*
|
|
|
4566 |
* This makes sure that the X or Y plot range is positive. The tick increment and
|
|
|
4567 |
* other calculations cannot handle negative or zero range, so we need to do
|
|
|
4568 |
* something to prevent it. There are 2 general cases: 1) automatic range, and
|
|
|
4569 |
* data is 'flat' (all same value). 2) One side of range given in
|
|
|
4570 |
* SetPlotAreaWorld(), and all the data is on the wrong side of that.
|
|
|
4571 |
*
|
|
|
4572 |
* Note that values specified in SetPlotAreaWorld() are never adjusted, even if it
|
|
|
4573 |
* means an empty plot (because all the data is outside the range).
|
|
|
4574 |
*
|
|
|
4575 |
* Called by CalcPlotRange() after CalcRangeInit() applies the defaults.
|
|
|
4576 |
*
|
|
|
4577 |
* @param string $which Which axis: 'x' or 'y', used only for reporting
|
|
|
4578 |
* @param float $plot_min Reference variable for the low end limit, changed if necessary
|
|
|
4579 |
* @param float $plot_max Reference variable for the high end limit, changed if necessary
|
|
|
4580 |
* @param bool $adjust_min True means $plot_min was auto-calculated, and may be adjusted
|
|
|
4581 |
* @param bool $adjust_max True means $plot_max was auto-calculated, and may be adjusted
|
|
|
4582 |
* @return bool True (False on error if an error handler returns True)
|
|
|
4583 |
* @since 6.0.0
|
|
|
4584 |
*/
|
|
|
4585 |
protected function CheckPlotRange($which, &$plot_min, &$plot_max, $adjust_min, $adjust_max)
|
|
|
4586 |
{
|
|
|
4587 |
if ($plot_min < $plot_max)
|
|
|
4588 |
return TRUE; // No adjustment needed.
|
|
|
4589 |
|
|
|
4590 |
// Bad range, plot_min >= plot_max, needs fixing.
|
|
|
4591 |
if ($adjust_max && $adjust_min) {
|
|
|
4592 |
// Both min and max are calculated, so either or both can be adjusted.
|
|
|
4593 |
// It should not be possible that plot_min > plot_max here, but check it to be safe:
|
|
|
4594 |
if ($plot_max != $plot_min)
|
|
|
4595 |
return $this->PrintError("SetPlotAreaWorld(): Inverse auto $which range error");
|
|
|
4596 |
|
|
|
4597 |
if ($plot_max == 0.0) {
|
|
|
4598 |
// All 0. Use the arbitrary range 0:10
|
|
|
4599 |
$plot_max = 10;
|
|
|
4600 |
} elseif ($plot_min > 0) {
|
|
|
4601 |
// All same positive value. Use the range 0:10 (or larger).
|
|
|
4602 |
$plot_min = 0;
|
|
|
4603 |
$plot_max = max($plot_max, 10);
|
|
|
4604 |
} else {
|
|
|
4605 |
// All same negative value. Use the range -10:0 (or larger).
|
|
|
4606 |
$plot_min = min($plot_min, -10);
|
|
|
4607 |
$plot_max = 0;
|
|
|
4608 |
}
|
|
|
4609 |
} elseif ($adjust_max) { // Equivalent to: ($adjust_max && !$adjust_min)
|
|
|
4610 |
// Max is calculated, min was set, so adjust max
|
|
|
4611 |
if ($plot_min < 0) $plot_max = 0;
|
|
|
4612 |
else $plot_max = $plot_min + 10;
|
|
|
4613 |
|
|
|
4614 |
} elseif ($adjust_min) { // Equivalent to: (!$adjust_max && $adjust_min)
|
|
|
4615 |
// Min is calculated, max was set, so adjust min
|
|
|
4616 |
if ($plot_max > 0) $plot_min = 0;
|
|
|
4617 |
else $plot_min = $plot_max - 10;
|
|
|
4618 |
|
|
|
4619 |
} else { // Equivalent to: (!$adjust_max && !$adjust_min)
|
|
|
4620 |
// Both limits are set. This should never happen, since SetPlotAreaWorld stops it.
|
|
|
4621 |
return $this->PrintError("SetPlotAreaWorld(): Inverse $which range error");
|
|
|
4622 |
}
|
|
|
4623 |
return TRUE;
|
|
|
4624 |
}
|
|
|
4625 |
|
|
|
4626 |
/**
|
|
|
4627 |
* Gets the plot range end adjustment factor
|
|
|
4628 |
*
|
|
|
4629 |
* This is a helper for CalcPlotRange(). If $adjust is already set, it is left
|
|
|
4630 |
* alone, otherwise it uses the current plot type to apply a default setting.
|
|
|
4631 |
*
|
|
|
4632 |
* @param string $which Which axis to calculate for. Must be 'x' or 'y'
|
|
|
4633 |
* @param float $adjust Reference variable for the range end adjustment factor, NULL or already set
|
|
|
4634 |
* @since 6.0.0
|
|
|
4635 |
*/
|
|
|
4636 |
protected function GetRangeEndAdjust($which, &$adjust)
|
|
|
4637 |
{
|
|
|
4638 |
if (isset($adjust)) return; // Already set, nothing to do
|
|
|
4639 |
|
|
|
4640 |
// The plot type can customize how an end adjustment is applied:
|
|
|
4641 |
if (empty(self::$plots[$this->plot_type]['adjust_type'])) {
|
|
|
4642 |
// Default (adjust_type missing or 0) means pad the dependent variable axis only.
|
|
|
4643 |
$adjust = ($which == 'x' XOR $this->datatype_swapped_xy) ? 0 : 0.03;
|
|
|
4644 |
} else {
|
|
|
4645 |
switch (self::$plots[$this->plot_type]['adjust_type']) {
|
|
|
4646 |
case 1:
|
|
|
4647 |
// Adjust type = 1 means add extra padding to both X and Y axis ends
|
|
|
4648 |
$adjust = 0.03;
|
|
|
4649 |
break;
|
|
|
4650 |
case 2:
|
|
|
4651 |
// Adjust type = 2 means do not add extra padding to either axis.
|
|
|
4652 |
$adjust = 0;
|
|
|
4653 |
break;
|
|
|
4654 |
}
|
|
|
4655 |
}
|
|
|
4656 |
}
|
|
|
4657 |
|
|
|
4658 |
/**
|
|
|
4659 |
* Calculates the plot range and tick increment for X or Y
|
|
|
4660 |
*
|
|
|
4661 |
* This is a helper for CalcPlotAreaWorld(). It returns the plot range (plot_min
|
|
|
4662 |
* and plot_max), and the tick increment, for the X or Y axis. Priority is given
|
|
|
4663 |
* to user-set values with SetPlotAreaWorld() and Set[XY]TickIncrement(), but if
|
|
|
4664 |
* these were defaulted then values are automatically calculated.
|
|
|
4665 |
*
|
|
|
4666 |
* @param string $which Which axis to calculate for. Must be 'x' or 'y'
|
|
|
4667 |
* @return float[] Array of (tick_increment, plot_min, plot_max) or FALSE on handled error
|
|
|
4668 |
* @since 6.0.0
|
|
|
4669 |
*/
|
|
|
4670 |
protected function CalcPlotRange($which)
|
|
|
4671 |
{
|
|
|
4672 |
// Independent variable is X in the usual vertical plots; Y in horizontal plots:
|
|
|
4673 |
$independent_variable = ($this->datatype_swapped_xy XOR $which == 'x');
|
|
|
4674 |
// 'implied' means this is a non-explicitly given independent variable, e.g. X in 'text-data'.
|
|
|
4675 |
$implied = $this->datatype_implied && $independent_variable;
|
|
|
4676 |
|
|
|
4677 |
// Initialize the range (plot_min : plot_max) and get the adjustment flags:
|
|
|
4678 |
list($plot_min, $adjust_min) =
|
|
|
4679 |
$this->CalcRangeInit($this->{"plot_min_$which"}, $implied, $this->{"min_$which"});
|
|
|
4680 |
list($plot_max, $adjust_max) =
|
|
|
4681 |
$this->CalcRangeInit($this->{"plot_max_$which"}, $implied, $this->{"max_$which"});
|
|
|
4682 |
|
|
|
4683 |
// Get local copies of variables used for range adjustment: adjust_{mode,amount} zero_magnet
|
|
|
4684 |
extract($this->rangectl[$which]);
|
|
|
4685 |
$this->GetRangeEndAdjust($which, $adjust_amount); // Apply default to $adjust_amount if needed
|
|
|
4686 |
|
|
|
4687 |
// Get local copies of other variables for X or Y:
|
|
|
4688 |
if ($which == 'x') {
|
|
|
4689 |
$num_ticks = $this->num_x_ticks;
|
|
|
4690 |
$tick_inc = $this->x_tick_inc_u;
|
|
|
4691 |
// Tick anchor is only used in 'T' adjust mode, where no tick anchor means anchor at 0.
|
|
|
4692 |
$tick_anchor = isset($this->x_tick_anchor) ? $this->x_tick_anchor : 0;
|
|
|
4693 |
} else {
|
|
|
4694 |
$num_ticks = $this->num_y_ticks;
|
|
|
4695 |
$tick_inc = $this->y_tick_inc_u;
|
|
|
4696 |
$tick_anchor = isset($this->y_tick_anchor) ? $this->y_tick_anchor : 0;
|
|
|
4697 |
}
|
|
|
4698 |
|
|
|
4699 |
// Validate the range, which must be positive. Adjusts plot_min and plot_max if necessary.
|
|
|
4700 |
if (!$this->CheckPlotRange($which, $plot_min, $plot_max, $adjust_min, $adjust_max))
|
|
|
4701 |
return FALSE;
|
|
|
4702 |
|
|
|
4703 |
// Adjust the min and max values, if flagged above for adjustment.
|
|
|
4704 |
|
|
|
4705 |
// Notes: (zero_magnet / (1 - zero_magnet)) is just a way to map a control with range 0:1
|
|
|
4706 |
// into the range 0:infinity (with zero_magnet==1 handled as a special case).
|
|
|
4707 |
// (plot_max / (plot_max - plot_min)) compares the range after plot_min would be set
|
|
|
4708 |
// to zero with the original range. Similar for negative data: (plot_min / (plot_min - plot_max))
|
|
|
4709 |
// compares the range with plot_max=0 to the original range.
|
|
|
4710 |
|
|
|
4711 |
$range = $plot_max - $plot_min;
|
|
|
4712 |
|
|
|
4713 |
// When all data > 0, test to see if the zero magnet is strong enough to pull the min down to zero:
|
|
|
4714 |
if ($adjust_min && $plot_min > 0 && $zero_magnet > 0 && ($zero_magnet == 1.0 ||
|
|
|
4715 |
$plot_max / $range < $zero_magnet / (1 - $zero_magnet))) {
|
|
|
4716 |
$plot_min = 0;
|
|
|
4717 |
$range = $plot_max;
|
|
|
4718 |
}
|
|
|
4719 |
|
|
|
4720 |
// Similar to above, but for negative data: zero magnet pulls max up to zero:
|
|
|
4721 |
if ($adjust_max && $plot_max < 0 && $zero_magnet > 0 && ($zero_magnet == 1.0 ||
|
|
|
4722 |
-$plot_min / $range < $zero_magnet / (1 - $zero_magnet))) {
|
|
|
4723 |
$plot_max = 0;
|
|
|
4724 |
$range = 0 - $plot_min;
|
|
|
4725 |
}
|
|
|
4726 |
|
|
|
4727 |
// Calculate the tick increment, if it wasn't set using Set[XY]TickIncrement().
|
|
|
4728 |
$num_ticks_override = FALSE;
|
|
|
4729 |
if (empty($tick_inc)) {
|
|
|
4730 |
if (empty($num_ticks)) {
|
|
|
4731 |
// Calculate a reasonable tick increment, based on the current plot area limits
|
|
|
4732 |
$tick_inc = $this->CalcStep($which, $range);
|
|
|
4733 |
} else {
|
|
|
4734 |
// Number of ticks was provided: use exactly that.
|
|
|
4735 |
// Adjustment is below, after range is calculated using mode 'R':
|
|
|
4736 |
$adjust_mode = 'R';
|
|
|
4737 |
$num_ticks_override = TRUE;
|
|
|
4738 |
}
|
|
|
4739 |
}
|
|
|
4740 |
|
|
|
4741 |
// Adjust the lower bound, if necessary, using one of 3 modes:
|
|
|
4742 |
if ($adjust_min && $plot_min != 0) {
|
|
|
4743 |
// Mode 'R' and basis for other modes: Extend the limit by a percentage of the
|
|
|
4744 |
// plot range, but only when the data is negative (to leave room below for labels).
|
|
|
4745 |
if ($plot_min < 0)
|
|
|
4746 |
$plot_min -= $adjust_amount * $range;
|
|
|
4747 |
|
|
|
4748 |
if ($adjust_mode == 'T') {
|
|
|
4749 |
// Mode 'T': Adjust to previous tick mark, taking tick anchor into account.
|
|
|
4750 |
$pm = $tick_anchor + $tick_inc * floor(($plot_min - $tick_anchor) / $tick_inc);
|
|
|
4751 |
// Don't allow the tick anchor adjustment to result in the range end moving across 0:
|
|
|
4752 |
$plot_min = (($plot_min >= 0) === ($pm >= 0)) ? $pm : 0;
|
|
|
4753 |
} elseif ($adjust_mode == 'I') {
|
|
|
4754 |
// Mode 'I': Adjust to previous integer:
|
|
|
4755 |
$plot_min = floor($plot_min);
|
|
|
4756 |
}
|
|
|
4757 |
}
|
|
|
4758 |
|
|
|
4759 |
// Adjust the upper bound, if necessary, using one of 3 modes:
|
|
|
4760 |
if ($adjust_max && $plot_max != 0) {
|
|
|
4761 |
// Mode 'R' and basis for other modes: Extend the limit by a percentage of the
|
|
|
4762 |
// plot range, but only when the max is positive (leaves room above for labels).
|
|
|
4763 |
if ($plot_max > 0)
|
|
|
4764 |
$plot_max += $adjust_amount * $range;
|
|
|
4765 |
|
|
|
4766 |
if ($adjust_mode == 'T') {
|
|
|
4767 |
// Mode 'T': Adjust to next tick mark, taking tick anchor into account:
|
|
|
4768 |
$pm = $tick_anchor + $tick_inc * ceil(($plot_max - $tick_anchor) / $tick_inc);
|
|
|
4769 |
// Don't allow the tick anchor adjustment to result in the range end moving across 0:
|
|
|
4770 |
$plot_max = (($plot_max >= 0) === ($pm >= 0)) ? $pm : 0;
|
|
|
4771 |
} elseif ($adjust_mode == 'I') {
|
|
|
4772 |
// Mode 'I': Adjustment to next higher integer.
|
|
|
4773 |
$plot_max = ceil($plot_max);
|
|
|
4774 |
}
|
|
|
4775 |
}
|
|
|
4776 |
|
|
|
4777 |
// Calculate the tick increment for the case where number of ticks was given:
|
|
|
4778 |
if ($num_ticks_override) {
|
|
|
4779 |
$tick_inc = ($plot_max - $plot_min) / $num_ticks;
|
|
|
4780 |
}
|
|
|
4781 |
|
|
|
4782 |
// Check log scale range - plot_min and plot_max must be > 0.
|
|
|
4783 |
if ($which == 'y' && $this->yscale_type == 'log' || $which == 'x' && $this->xscale_type == 'log') {
|
|
|
4784 |
if ($plot_min <= 0) $plot_min = 1;
|
|
|
4785 |
if ($plot_max <= 0) {
|
|
|
4786 |
// Note: Error message names the public function, not this function.
|
|
|
4787 |
return $this->PrintError("SetPlotAreaWorld(): Invalid $which range for log scale");
|
|
|
4788 |
}
|
|
|
4789 |
}
|
|
|
4790 |
// Final error check to ensure the range is positive.
|
|
|
4791 |
if ($plot_min >= $plot_max) $plot_max = $plot_min + 1;
|
|
|
4792 |
|
|
|
4793 |
// Return the calculated values. (Note these get stored back into class variables.)
|
|
|
4794 |
return array($tick_inc, $plot_min, $plot_max);
|
|
|
4795 |
}
|
|
|
4796 |
|
|
|
4797 |
/**
|
|
|
4798 |
* Calculates the World Coordinate limits of the plot area, and the tick increments
|
|
|
4799 |
*
|
|
|
4800 |
* This is called by DrawGraph(), after FindDataLimits() determines the data
|
|
|
4801 |
* limits, to calculate the plot area scale and tick increments. The plot range
|
|
|
4802 |
* and increment are related, which is why they are calculated together.
|
|
|
4803 |
*
|
|
|
4804 |
* The plot range variables (plot_min_x, plot_max_x, plot_min_y, plot_max_y) are
|
|
|
4805 |
* calculated if necessary, then stored back into the object ('sticky' for
|
|
|
4806 |
* multiple plots on an image).
|
|
|
4807 |
*
|
|
|
4808 |
* The tick increments (x_tick_inc, y_tick_inc) are calculated. These default to
|
|
|
4809 |
* the user-set values (x_tick_inc_u, y_tick_inc_u) but we keep the effective
|
|
|
4810 |
* values separate so that they can be recalculated for a second plot (which may
|
|
|
4811 |
* have a different data range).
|
|
|
4812 |
*
|
|
|
4813 |
* @return bool True, unless an handled error occurred in a called function
|
|
|
4814 |
* @since 5.0.5
|
|
|
4815 |
*/
|
|
|
4816 |
protected function CalcPlotAreaWorld()
|
|
|
4817 |
{
|
|
|
4818 |
list($this->x_tick_inc, $this->plot_min_x, $this->plot_max_x) = $this->CalcPlotRange('x');
|
|
|
4819 |
list($this->y_tick_inc, $this->plot_min_y, $this->plot_max_y) = $this->CalcPlotRange('y');
|
|
|
4820 |
if ($this->GetCallback('debug_scale')) {
|
|
|
4821 |
$this->DoCallback('debug_scale', __FUNCTION__, array(
|
|
|
4822 |
'plot_min_x' => $this->plot_min_x, 'plot_min_y' => $this->plot_min_y,
|
|
|
4823 |
'plot_max_x' => $this->plot_max_x, 'plot_max_y' => $this->plot_max_y,
|
|
|
4824 |
'x_tick_inc' => $this->x_tick_inc, 'y_tick_inc' => $this->y_tick_inc));
|
|
|
4825 |
}
|
|
|
4826 |
return isset($this->x_tick_inc, $this->y_tick_inc); // Pass thru FALSE return from CalcPlotRange()
|
|
|
4827 |
}
|
|
|
4828 |
|
|
|
4829 |
/**
|
|
|
4830 |
* Overrides automatic data scaling to device coordinates
|
|
|
4831 |
*
|
|
|
4832 |
* This fixes one or more ends of the range of the plot to specific
|
|
|
4833 |
* value(s), given in World Coordinates.
|
|
|
4834 |
* Any limit not set or set to NULL will be calculated in
|
|
|
4835 |
* CalcPlotAreaWorld(). If both ends of either X or Y range are
|
|
|
4836 |
* supplied, the range is validated to ensure min < max.
|
|
|
4837 |
*
|
|
|
4838 |
* @param float $xmin X data range minimum; omit or NULL to auto-calculate
|
|
|
4839 |
* @param float $ymin Y data range minimum; omit or NULL to auto-calculate
|
|
|
4840 |
* @param float $xmax X data range maximum; omit or NULL to auto-calculate
|
|
|
4841 |
* @param float $ymax Y data range maximum; omit or NULL to auto-calculate
|
|
|
4842 |
* @return bool True (False on error if an error handler returns True)
|
|
|
4843 |
*/
|
|
|
4844 |
function SetPlotAreaWorld($xmin=NULL, $ymin=NULL, $xmax=NULL, $ymax=NULL)
|
|
|
4845 |
{
|
|
|
4846 |
$this->plot_min_x = $xmin;
|
|
|
4847 |
$this->plot_max_x = $xmax;
|
|
|
4848 |
$this->plot_min_y = $ymin;
|
|
|
4849 |
$this->plot_max_y = $ymax;
|
|
|
4850 |
if (isset($xmin) && isset($xmax) && $xmin >= $xmax) $bad = 'X';
|
|
|
4851 |
elseif (isset($ymin) && isset($ymax) && $ymin >= $ymax) $bad = 'Y';
|
|
|
4852 |
else return TRUE;
|
|
|
4853 |
return $this->PrintError("SetPlotAreaWorld(): $bad range error - min >= max");
|
|
|
4854 |
}
|
|
|
4855 |
|
|
|
4856 |
/**
|
|
|
4857 |
* Calculates sizes of bars for bars and stackedbars plots
|
|
|
4858 |
*
|
|
|
4859 |
* This calculates the following class variables, which control the size and
|
|
|
4860 |
* spacing of bars in vertical and horizontal 'bars' and 'stackedbars' plots:
|
|
|
4861 |
* record_bar_width (allocated width for each bar, including gaps),
|
|
|
4862 |
* actual_bar_width (actual drawn width of each bar), and
|
|
|
4863 |
* bar_adjust_gap (gap on each side of each bar, 0 if they touch).
|
|
|
4864 |
*
|
|
|
4865 |
* Note that when $verticals is False, the bars are horizontal, but the same
|
|
|
4866 |
* variable names are used. Think of "bar_width" as being the width if you
|
|
|
4867 |
* are standing on the Y axis looking towards positive X.
|
|
|
4868 |
*
|
|
|
4869 |
* @param bool $stacked If true, this is a stacked bar plot (1 bar per group)
|
|
|
4870 |
* @param bool $verticals If false, this is a horizontal bar plot
|
|
|
4871 |
* @return bool True always
|
|
|
4872 |
*/
|
|
|
4873 |
protected function CalcBarWidths($stacked, $verticals)
|
|
|
4874 |
{
|
|
|
4875 |
// group_width is the width of a group, including padding
|
|
|
4876 |
if ($verticals) {
|
|
|
4877 |
$group_width = $this->plot_area_width / $this->num_data_rows;
|
|
|
4878 |
} else {
|
|
|
4879 |
$group_width = $this->plot_area_height / $this->num_data_rows;
|
|
|
4880 |
}
|
|
|
4881 |
|
|
|
4882 |
// Number of bar spaces in the group, including actual bars and bar_extra_space extra:
|
|
|
4883 |
if ($stacked) {
|
|
|
4884 |
$num_spots = 1 + $this->bar_extra_space;
|
|
|
4885 |
} else {
|
|
|
4886 |
$num_spots = $this->data_columns + $this->bar_extra_space;
|
|
|
4887 |
}
|
|
|
4888 |
|
|
|
4889 |
// record_bar_width is the width of each bar's allocated area.
|
|
|
4890 |
// If bar_width_adjust=1 this is the width of the bar, otherwise
|
|
|
4891 |
// the bar is centered inside record_bar_width.
|
|
|
4892 |
// The equation is:
|
|
|
4893 |
// group_frac_width * group_width = record_bar_width * num_spots
|
|
|
4894 |
$this->record_bar_width = $this->group_frac_width * $group_width / $num_spots;
|
|
|
4895 |
|
|
|
4896 |
// Note that the extra space due to group_frac_width and bar_extra_space will be
|
|
|
4897 |
// evenly divided on each side of the group: the drawn bars are centered in the group.
|
|
|
4898 |
|
|
|
4899 |
// Within each bar's allocated space, if bar_width_adjust=1 the bar fills the
|
|
|
4900 |
// space, otherwise it is centered.
|
|
|
4901 |
// This is the actual drawn bar width:
|
|
|
4902 |
$this->actual_bar_width = $this->record_bar_width * $this->bar_width_adjust;
|
|
|
4903 |
// This is the gap on each side of the bar (0 if bar_width_adjust=1):
|
|
|
4904 |
$this->bar_adjust_gap = ($this->record_bar_width - $this->actual_bar_width) / 2;
|
|
|
4905 |
|
|
|
4906 |
if ($this->GetCallback('debug_scale')) {
|
|
|
4907 |
$this->DoCallback('debug_scale', __FUNCTION__, array(
|
|
|
4908 |
'record_bar_width' => $this->record_bar_width,
|
|
|
4909 |
'actual_bar_width' => $this->actual_bar_width,
|
|
|
4910 |
'bar_adjust_gap' => $this->bar_adjust_gap));
|
|
|
4911 |
}
|
|
|
4912 |
return TRUE;
|
|
|
4913 |
}
|
|
|
4914 |
|
|
|
4915 |
/**
|
|
|
4916 |
* Calculates the X and Y axis positions in world coordinates
|
|
|
4917 |
*
|
|
|
4918 |
* This validates or calculates the class variables x_axis_position and
|
|
|
4919 |
* y_axis_position. Note x_axis_position is the Y value where the X axis
|
|
|
4920 |
* goes; y_axis_position is the X value where the Y axis goes.
|
|
|
4921 |
* If they were set by the user, they are used as-is, unless they are
|
|
|
4922 |
* outside the data range. If they are not set, they are calculated here.
|
|
|
4923 |
*
|
|
|
4924 |
* For vertical plots, the X axis defaults to Y=0 if that is inside the plot
|
|
|
4925 |
* range, else whichever of the top or bottom that has the smallest absolute
|
|
|
4926 |
* value (that is, the value closest to 0). The Y axis defaults to the left
|
|
|
4927 |
* edge. For horizontal plots, the axis roles and defaults are switched.
|
|
|
4928 |
*
|
|
|
4929 |
* @return bool True always
|
|
|
4930 |
* @since 5.0.5
|
|
|
4931 |
*/
|
|
|
4932 |
protected function CalcAxisPositions()
|
|
|
4933 |
{
|
|
|
4934 |
// Validate user-provided X axis position, or calculate a default if not provided:
|
|
|
4935 |
if (isset($this->x_axis_position)) {
|
|
|
4936 |
// Force user-provided X axis position to be within the plot range:
|
|
|
4937 |
$this->x_axis_position = min(max($this->plot_min_y, $this->x_axis_position), $this->plot_max_y);
|
|
|
4938 |
} elseif ($this->yscale_type == 'log') {
|
|
|
4939 |
// Always use 1 for X axis position on log scale plots.
|
|
|
4940 |
$this->x_axis_position = 1;
|
|
|
4941 |
} elseif ($this->datatype_swapped_xy || $this->plot_min_y > 0) {
|
|
|
4942 |
// Horizontal plot, or Vertical Plot with all Y > 0: Place X axis on the bottom.
|
|
|
4943 |
$this->x_axis_position = $this->plot_min_y;
|
|
|
4944 |
} elseif ($this->plot_max_y < 0) {
|
|
|
4945 |
// Vertical plot with all Y < 0, so place the X axis at the top.
|
|
|
4946 |
$this->x_axis_position = $this->plot_max_y;
|
|
|
4947 |
} else {
|
|
|
4948 |
// Vertical plot range includes Y=0, so place X axis at 0.
|
|
|
4949 |
$this->x_axis_position = 0;
|
|
|
4950 |
}
|
|
|
4951 |
|
|
|
4952 |
// Validate user-provided Y axis position, or calculate a default if not provided:
|
|
|
4953 |
if (isset($this->y_axis_position)) {
|
|
|
4954 |
// Force user-provided Y axis position to be within the plot range:
|
|
|
4955 |
$this->y_axis_position = min(max($this->plot_min_x, $this->y_axis_position), $this->plot_max_x);
|
|
|
4956 |
} elseif ($this->xscale_type == 'log') {
|
|
|
4957 |
// Always use 1 for Y axis position on log scale plots.
|
|
|
4958 |
$this->y_axis_position = 1;
|
|
|
4959 |
} elseif (!$this->datatype_swapped_xy || $this->plot_min_x > 0) {
|
|
|
4960 |
// Vertical plot, or Horizontal Plot with all X > 0: Place Y axis on left side.
|
|
|
4961 |
$this->y_axis_position = $this->plot_min_x;
|
|
|
4962 |
} elseif ($this->plot_max_x < 0) {
|
|
|
4963 |
// Horizontal plot with all X < 0, so place the Y axis on the right side.
|
|
|
4964 |
$this->y_axis_position = $this->plot_max_x;
|
|
|
4965 |
} else {
|
|
|
4966 |
// Horizontal plot range includes X=0: place Y axis at 0.
|
|
|
4967 |
$this->y_axis_position = 0;
|
|
|
4968 |
}
|
|
|
4969 |
|
|
|
4970 |
if ($this->GetCallback('debug_scale')) {
|
|
|
4971 |
$this->DoCallback('debug_scale', __FUNCTION__, array(
|
|
|
4972 |
'x_axis_position' => $this->x_axis_position,
|
|
|
4973 |
'y_axis_position' => $this->y_axis_position));
|
|
|
4974 |
}
|
|
|
4975 |
|
|
|
4976 |
return TRUE;
|
|
|
4977 |
}
|
|
|
4978 |
|
|
|
4979 |
/**
|
|
|
4980 |
* Calculates parameters for transforming world coordinates to pixel coordinates
|
|
|
4981 |
*
|
|
|
4982 |
* This calculates xscale, yscale, plot_origin_x, and plot_origin_y, which map
|
|
|
4983 |
* world coordinate space into the plot area. These are used by xtr() and ytr()
|
|
|
4984 |
*
|
|
|
4985 |
* @return bool True always
|
|
|
4986 |
*/
|
|
|
4987 |
protected function CalcTranslation()
|
|
|
4988 |
{
|
|
|
4989 |
if ($this->plot_max_x - $this->plot_min_x == 0) { // Check for div by 0
|
|
|
4990 |
$this->xscale = 0;
|
|
|
4991 |
} else {
|
|
|
4992 |
if ($this->xscale_type == 'log') {
|
|
|
4993 |
$this->xscale = $this->plot_area_width /
|
|
|
4994 |
(log10($this->plot_max_x) - log10($this->plot_min_x));
|
|
|
4995 |
} else {
|
|
|
4996 |
$this->xscale = $this->plot_area_width / ($this->plot_max_x - $this->plot_min_x);
|
|
|
4997 |
}
|
|
|
4998 |
}
|
|
|
4999 |
|
|
|
5000 |
if ($this->plot_max_y - $this->plot_min_y == 0) { // Check for div by 0
|
|
|
5001 |
$this->yscale = 0;
|
|
|
5002 |
} else {
|
|
|
5003 |
if ($this->yscale_type == 'log') {
|
|
|
5004 |
$this->yscale = $this->plot_area_height /
|
|
|
5005 |
(log10($this->plot_max_y) - log10($this->plot_min_y));
|
|
|
5006 |
} else {
|
|
|
5007 |
$this->yscale = $this->plot_area_height / ($this->plot_max_y - $this->plot_min_y);
|
|
|
5008 |
}
|
|
|
5009 |
}
|
|
|
5010 |
// GD defines x = 0 at left and y = 0 at TOP so -/+ respectively
|
|
|
5011 |
if ($this->xscale_type == 'log') {
|
|
|
5012 |
$this->plot_origin_x = $this->plot_area[0] - ($this->xscale * log10($this->plot_min_x) );
|
|
|
5013 |
} else {
|
|
|
5014 |
$this->plot_origin_x = $this->plot_area[0] - ($this->xscale * $this->plot_min_x);
|
|
|
5015 |
}
|
|
|
5016 |
if ($this->yscale_type == 'log') {
|
|
|
5017 |
$this->plot_origin_y = $this->plot_area[3] + ($this->yscale * log10($this->plot_min_y));
|
|
|
5018 |
} else {
|
|
|
5019 |
$this->plot_origin_y = $this->plot_area[3] + ($this->yscale * $this->plot_min_y);
|
|
|
5020 |
}
|
|
|
5021 |
|
|
|
5022 |
// Convert axis positions to device coordinates:
|
|
|
5023 |
$this->y_axis_x_pixels = $this->xtr($this->y_axis_position);
|
|
|
5024 |
$this->x_axis_y_pixels = $this->ytr($this->x_axis_position);
|
|
|
5025 |
|
|
|
5026 |
if ($this->GetCallback('debug_scale')) {
|
|
|
5027 |
$this->DoCallback('debug_scale', __FUNCTION__, array(
|
|
|
5028 |
'xscale' => $this->xscale, 'yscale' => $this->yscale,
|
|
|
5029 |
'plot_origin_x' => $this->plot_origin_x, 'plot_origin_y' => $this->plot_origin_y,
|
|
|
5030 |
'y_axis_x_pixels' => $this->y_axis_x_pixels,
|
|
|
5031 |
'x_axis_y_pixels' => $this->x_axis_y_pixels));
|
|
|
5032 |
}
|
|
|
5033 |
|
|
|
5034 |
return TRUE;
|
|
|
5035 |
}
|
|
|
5036 |
|
|
|
5037 |
/**
|
|
|
5038 |
* Translates an X world coordinate value into a pixel coordinate value
|
|
|
5039 |
*
|
|
|
5040 |
* @param float $x_world X world coordinate value to translate
|
|
|
5041 |
* @return int Translated X device (pixel) coordinate
|
|
|
5042 |
* @deprecated Public use discouraged; use GetDeviceXY() instead
|
|
|
5043 |
*/
|
|
|
5044 |
function xtr($x_world)
|
|
|
5045 |
{
|
|
|
5046 |
if ($this->xscale_type == 'log') {
|
|
|
5047 |
$x_pixels = $this->plot_origin_x + log10($x_world) * $this->xscale ;
|
|
|
5048 |
} else {
|
|
|
5049 |
$x_pixels = $this->plot_origin_x + $x_world * $this->xscale ;
|
|
|
5050 |
}
|
|
|
5051 |
return round($x_pixels);
|
|
|
5052 |
}
|
|
|
5053 |
|
|
|
5054 |
/**
|
|
|
5055 |
* Translates a Y world coordinate value into a pixel coordinate value
|
|
|
5056 |
*
|
|
|
5057 |
* @param float $y_world Y world coordinate value to translate
|
|
|
5058 |
* @return int Translated Y device (pixel) coordinate
|
|
|
5059 |
* @deprecated Public use discouraged; use GetDeviceXY() instead
|
|
|
5060 |
*/
|
|
|
5061 |
function ytr($y_world)
|
|
|
5062 |
{
|
|
|
5063 |
if ($this->yscale_type == 'log') {
|
|
|
5064 |
//minus because GD defines y = 0 at top. doh!
|
|
|
5065 |
$y_pixels = $this->plot_origin_y - log10($y_world) * $this->yscale ;
|
|
|
5066 |
} else {
|
|
|
5067 |
$y_pixels = $this->plot_origin_y - $y_world * $this->yscale ;
|
|
|
5068 |
}
|
|
|
5069 |
return round($y_pixels);
|
|
|
5070 |
}
|
|
|
5071 |
|
|
|
5072 |
/**
|
|
|
5073 |
* Translates world coordinates into device coordinates
|
|
|
5074 |
*
|
|
|
5075 |
* This is a public interface to xtr() and ytr(), which are left as public
|
|
|
5076 |
* for historical reasons but deprecated for public use. It maps (x,y) in
|
|
|
5077 |
* world coordinates to (x,y) into device (pixel) coordinates. Typical usage
|
|
|
5078 |
* is: list($x_pixel, $y_pixel) = $plot->GetDeviceXY($x_world, $y_world)
|
|
|
5079 |
*
|
|
|
5080 |
* Note: This only works after scaling has been set up, which happens in
|
|
|
5081 |
* DrawGraph(). So it is only useful from a drawing callback, or if
|
|
|
5082 |
* SetPrintImage(False) was used and after DrawGraph().
|
|
|
5083 |
*
|
|
|
5084 |
* @param float $x_world X world coordinate value to translate
|
|
|
5085 |
* @param float $y_world Y world coordinate value to translate
|
|
|
5086 |
* @return int[] Array of ($x, $y) device coordinates; False on error if error handler returns True
|
|
|
5087 |
* @since 5.1.0
|
|
|
5088 |
*/
|
|
|
5089 |
function GetDeviceXY($x_world, $y_world)
|
|
|
5090 |
{
|
|
|
5091 |
if (!isset($this->xscale)) {
|
|
|
5092 |
return $this->PrintError("GetDeviceXY() was called before translation factors were calculated");
|
|
|
5093 |
}
|
|
|
5094 |
return array($this->xtr($x_world), $this->ytr($y_world));
|
|
|
5095 |
}
|
|
|
5096 |
|
|
|
5097 |
/**
|
|
|
5098 |
* Gets the tick mark parameters
|
|
|
5099 |
*
|
|
|
5100 |
* This is used by DrawXTicks(), DrawYTicks(), and CalcMaxTickLabelSize().
|
|
|
5101 |
* It returns the parameters needed to draw tick marks: start value, end value,
|
|
|
5102 |
* and step. Note CalcTicks() used to but no longer actually does the
|
|
|
5103 |
* calculations. That is done in CalcPlotAreaWorld().
|
|
|
5104 |
*
|
|
|
5105 |
* @param string $which Which axis to calculate tick parameters for. Must be 'x' or 'y'
|
|
|
5106 |
* @return float[] Array of (tick_start, tick_end, tick_step)
|
|
|
5107 |
* @since 5.0.5
|
|
|
5108 |
*/
|
|
|
5109 |
protected function CalcTicks($which)
|
|
|
5110 |
{
|
|
|
5111 |
if ($which == 'x') {
|
|
|
5112 |
$tick_step = $this->x_tick_inc;
|
|
|
5113 |
$anchor = &$this->x_tick_anchor; // Reference used because it might not be set.
|
|
|
5114 |
$plot_max = $this->plot_max_x;
|
|
|
5115 |
$plot_min = $this->plot_min_x;
|
|
|
5116 |
$skip_lo = $this->skip_left_tick;
|
|
|
5117 |
$skip_hi = $this->skip_right_tick;
|
|
|
5118 |
} else { // Assumed 'y'
|
|
|
5119 |
$tick_step = $this->y_tick_inc;
|
|
|
5120 |
$anchor = &$this->y_tick_anchor;
|
|
|
5121 |
$plot_max = $this->plot_max_y;
|
|
|
5122 |
$plot_min = $this->plot_min_y;
|
|
|
5123 |
$skip_lo = $this->skip_bottom_tick;
|
|
|
5124 |
$skip_hi = $this->skip_top_tick;
|
|
|
5125 |
}
|
|
|
5126 |
|
|
|
5127 |
// To avoid losing a final tick mark due to round-off errors, push tick_end out slightly.
|
|
|
5128 |
$tick_start = (double)$plot_min;
|
|
|
5129 |
$tick_end = (double)$plot_max + ($plot_max - $plot_min) / 10000.0;
|
|
|
5130 |
|
|
|
5131 |
// If a tick anchor was given, adjust the start of the range so the anchor falls
|
|
|
5132 |
// at an exact tick mark (or would, if it was within range).
|
|
|
5133 |
if (isset($anchor))
|
|
|
5134 |
$tick_start = $anchor - $tick_step * floor(($anchor - $tick_start) / $tick_step);
|
|
|
5135 |
|
|
|
5136 |
// Lastly, adjust for option to skip left/bottom or right/top tick marks:
|
|
|
5137 |
if ($skip_lo)
|
|
|
5138 |
$tick_start += $tick_step;
|
|
|
5139 |
if ($skip_hi)
|
|
|
5140 |
$tick_end -= $tick_step;
|
|
|
5141 |
|
|
|
5142 |
if ($this->GetCallback('debug_scale'))
|
|
|
5143 |
$this->DoCallback('debug_scale', __FUNCTION__,
|
|
|
5144 |
compact('which', 'tick_start', 'tick_end', 'tick_step'));
|
|
|
5145 |
return array($tick_start, $tick_end, $tick_step);
|
|
|
5146 |
}
|
|
|
5147 |
|
|
|
5148 |
/**
|
|
|
5149 |
* Calculates the size of the biggest tick label
|
|
|
5150 |
*
|
|
|
5151 |
* This is used by CalcMargins() to figure out how much margin space is needed
|
|
|
5152 |
* for the tick labels.
|
|
|
5153 |
* For 'x' ticks, it returns the height (delta Y) of the tallest label.
|
|
|
5154 |
* For 'y' ticks, it returns the width (delta X) of the widest label.
|
|
|
5155 |
*
|
|
|
5156 |
* @param string $which Which axis to calculate for. Must be 'x' or 'y'
|
|
|
5157 |
* @return float The needed tick label width (for Y) or height (for X)
|
|
|
5158 |
* @since 5.0.5
|
|
|
5159 |
*/
|
|
|
5160 |
protected function CalcMaxTickLabelSize($which)
|
|
|
5161 |
{
|
|
|
5162 |
list($tick_start, $tick_end, $tick_step) = $this->CalcTicks($which);
|
|
|
5163 |
|
|
|
5164 |
$angle = ($which == 'x') ? $this->x_label_angle : $this->y_label_angle;
|
|
|
5165 |
$font_id = $which . '_label'; // Use x_label or y_label font.
|
|
|
5166 |
$max_width = 0;
|
|
|
5167 |
$max_height = 0;
|
|
|
5168 |
|
|
|
5169 |
// Loop over ticks, same as DrawXTicks and DrawYTicks:
|
|
|
5170 |
// Avoid cumulative round-off errors from $val += $delta
|
|
|
5171 |
$n = 0;
|
|
|
5172 |
$tick_val = $tick_start;
|
|
|
5173 |
while ($tick_val <= $tick_end) {
|
|
|
5174 |
$tick_label = $this->FormatLabel($which, $tick_val);
|
|
|
5175 |
list($width, $height) = $this->SizeText($font_id, $angle, $tick_label);
|
|
|
5176 |
if ($width > $max_width) $max_width = $width;
|
|
|
5177 |
if ($height > $max_height) $max_height = $height;
|
|
|
5178 |
$tick_val = $tick_start + ++$n * $tick_step;
|
|
|
5179 |
}
|
|
|
5180 |
if ($this->GetCallback('debug_scale')) {
|
|
|
5181 |
$this->DoCallback('debug_scale', __FUNCTION__, array(
|
|
|
5182 |
'which' => $which, 'height' => $max_height, 'width' => $max_width));
|
|
|
5183 |
}
|
|
|
5184 |
|
|
|
5185 |
if ($which == 'x')
|
|
|
5186 |
return $max_height;
|
|
|
5187 |
return $max_width;
|
|
|
5188 |
}
|
|
|
5189 |
|
|
|
5190 |
/**
|
|
|
5191 |
* Calculates the size of the biggest axis data label
|
|
|
5192 |
*
|
|
|
5193 |
* This is used by CalcMargins() to figure out how much margin space is needed
|
|
|
5194 |
* for the axis data labels.
|
|
|
5195 |
* For X axis labels, it returns the height (delta Y) of the tallest label.
|
|
|
5196 |
* For Y axis labels, it returns the width (delta X) of the widest label.
|
|
|
5197 |
*
|
|
|
5198 |
* There can be at most one set of axis data labels. For vertical plots, these
|
|
|
5199 |
* are X axis data labels, and go along the top or bottom or both. For horizontal
|
|
|
5200 |
* plots, these are Y axis data labels, and go along the left or right or both.
|
|
|
5201 |
* CalcMaxDataLabelSize(axis) returns 0 if data labels do not apply to that axis.
|
|
|
5202 |
* To do this, it needs to check the plottype flag indicating swapped X/Y.
|
|
|
5203 |
*
|
|
|
5204 |
* @param string $which Which axis to calculate for. Must be 'x' or 'y'
|
|
|
5205 |
* @return float The needed axis data label width (for Y) or height (for X)
|
|
|
5206 |
* @since 5.0.5
|
|
|
5207 |
*/
|
|
|
5208 |
protected function CalcMaxDataLabelSize($which = 'x')
|
|
|
5209 |
{
|
|
|
5210 |
// Shortcut: Y data labels for vertical plots, and X data labels for horizontal plots,
|
|
|
5211 |
// are inside the plot, rather than along the axis lines, and so take up no margin space.
|
|
|
5212 |
if ($which == 'y' XOR $this->datatype_swapped_xy)
|
|
|
5213 |
return 0;
|
|
|
5214 |
|
|
|
5215 |
$angle = ($which == 'x') ? $this->x_data_label_angle : $this->y_data_label_angle;
|
|
|
5216 |
$font_id = $which . '_label'; // Use x_label or y_label font.
|
|
|
5217 |
$format_code = $which . 'd'; // Use format code 'xd' or 'yd'
|
|
|
5218 |
$max_width = 0;
|
|
|
5219 |
$max_height = 0;
|
|
|
5220 |
|
|
|
5221 |
// Loop over all data labels and find the biggest:
|
|
|
5222 |
for ($i = 0; $i < $this->num_data_rows; $i++) {
|
|
|
5223 |
$label = $this->FormatLabel($format_code, $this->data[$i][0], $i);
|
|
|
5224 |
list($width, $height) = $this->SizeText($font_id, $angle, $label);
|
|
|
5225 |
if ($width > $max_width) $max_width = $width;
|
|
|
5226 |
if ($height > $max_height) $max_height = $height;
|
|
|
5227 |
}
|
|
|
5228 |
if ($this->GetCallback('debug_scale')) {
|
|
|
5229 |
$this->DoCallback('debug_scale', __FUNCTION__, array(
|
|
|
5230 |
'height' => $max_height, 'width' => $max_width));
|
|
|
5231 |
}
|
|
|
5232 |
|
|
|
5233 |
if ($this->datatype_swapped_xy)
|
|
|
5234 |
return $max_width;
|
|
|
5235 |
return $max_height;
|
|
|
5236 |
}
|
|
|
5237 |
|
|
|
5238 |
/**
|
|
|
5239 |
* Determines if there are any non-empty data labels in the data array
|
|
|
5240 |
*
|
|
|
5241 |
* This is used by CheckLabels() to determine if data labels are available.
|
|
|
5242 |
*
|
|
|
5243 |
* @return bool True if all data labels are empty, else False.
|
|
|
5244 |
* @since 5.1.2
|
|
|
5245 |
*/
|
|
|
5246 |
protected function CheckLabelsAllEmpty()
|
|
|
5247 |
{
|
|
|
5248 |
for ($i = 0; $i < $this->num_data_rows; $i++)
|
|
|
5249 |
if ($this->data[$i][0] !== '') return FALSE;
|
|
|
5250 |
return TRUE;
|
|
|
5251 |
}
|
|
|
5252 |
|
|
|
5253 |
/**
|
|
|
5254 |
* Checks and sets label parameters
|
|
|
5255 |
*
|
|
|
5256 |
* This handles deferred processing for label positioning and other label-related
|
|
|
5257 |
* parameters. It sets defaults for label angles, and applies defaults to X and Y
|
|
|
5258 |
* tick and data label positions.
|
|
|
5259 |
*
|
|
|
5260 |
* @return bool True always
|
|
|
5261 |
* @since 5.1.0
|
|
|
5262 |
*/
|
|
|
5263 |
protected function CheckLabels()
|
|
|
5264 |
{
|
|
|
5265 |
// Default for X data label angle is a special case (different from Y).
|
|
|
5266 |
if ($this->x_data_label_angle_u === '')
|
|
|
5267 |
$this->x_data_label_angle = $this->x_label_angle; // Not set with SetXDataLabelAngle()
|
|
|
5268 |
else
|
|
|
5269 |
$this->x_data_label_angle = $this->x_data_label_angle_u; // Set with SetXDataLabelAngle()
|
|
|
5270 |
|
|
|
5271 |
// X Label position fixups, for x_data_label_pos and x_tick_label_pos:
|
|
|
5272 |
if ($this->datatype_swapped_xy) {
|
|
|
5273 |
// Just apply defaults - there is no position conflict for X labels.
|
|
|
5274 |
if (!isset($this->x_tick_label_pos))
|
|
|
5275 |
$this->x_tick_label_pos = 'plotdown';
|
|
|
5276 |
if (!isset($this->x_data_label_pos))
|
|
|
5277 |
$this->x_data_label_pos = 'none';
|
|
|
5278 |
} else {
|
|
|
5279 |
// Apply defaults but do not allow conflict between tick and data labels.
|
|
|
5280 |
if (isset($this->x_data_label_pos)) {
|
|
|
5281 |
if (!isset($this->x_tick_label_pos)) {
|
|
|
5282 |
// Case: data_label_pos is set, tick_label_pos needs a default:
|
|
|
5283 |
if ($this->x_data_label_pos == 'none')
|
|
|
5284 |
$this->x_tick_label_pos = 'plotdown';
|
|
|
5285 |
else
|
|
|
5286 |
$this->x_tick_label_pos = 'none';
|
|
|
5287 |
}
|
|
|
5288 |
} elseif (isset($this->x_tick_label_pos)) {
|
|
|
5289 |
// Case: tick_label_pos is set, data_label_pos needs a default:
|
|
|
5290 |
if ($this->x_tick_label_pos == 'none')
|
|
|
5291 |
$this->x_data_label_pos = 'plotdown';
|
|
|
5292 |
else
|
|
|
5293 |
$this->x_data_label_pos = 'none';
|
|
|
5294 |
} else {
|
|
|
5295 |
// Case: Neither tick_label_pos nor data_label_pos is set.
|
|
|
5296 |
// We do not want them to be both on (as PHPlot used to do in this case).
|
|
|
5297 |
// Turn on data labels if any were supplied, else tick labels.
|
|
|
5298 |
if ($this->CheckLabelsAllEmpty()) {
|
|
|
5299 |
$this->x_data_label_pos = 'none';
|
|
|
5300 |
$this->x_tick_label_pos = 'plotdown';
|
|
|
5301 |
} else {
|
|
|
5302 |
$this->x_data_label_pos = 'plotdown';
|
|
|
5303 |
$this->x_tick_label_pos = 'none';
|
|
|
5304 |
}
|
|
|
5305 |
}
|
|
|
5306 |
}
|
|
|
5307 |
|
|
|
5308 |
// Y Label position fixups, for y_data_label_pos and y_tick_label_pos:
|
|
|
5309 |
if (!$this->datatype_swapped_xy) {
|
|
|
5310 |
// Just apply defaults - there is no position conflict.
|
|
|
5311 |
if (!isset($this->y_tick_label_pos))
|
|
|
5312 |
$this->y_tick_label_pos = 'plotleft';
|
|
|
5313 |
if (!isset($this->y_data_label_pos))
|
|
|
5314 |
$this->y_data_label_pos = 'none';
|
|
|
5315 |
} else {
|
|
|
5316 |
// Apply defaults but do not allow conflict between tick and data labels.
|
|
|
5317 |
if (isset($this->y_data_label_pos)) {
|
|
|
5318 |
if (!isset($this->y_tick_label_pos)) {
|
|
|
5319 |
// Case: data_label_pos is set, tick_label_pos needs a default:
|
|
|
5320 |
if ($this->y_data_label_pos == 'none')
|
|
|
5321 |
$this->y_tick_label_pos = 'plotleft';
|
|
|
5322 |
else
|
|
|
5323 |
$this->y_tick_label_pos = 'none';
|
|
|
5324 |
}
|
|
|
5325 |
} elseif (isset($this->y_tick_label_pos)) {
|
|
|
5326 |
// Case: tick_label_pos is set, data_label_pos needs a default:
|
|
|
5327 |
if ($this->y_tick_label_pos == 'none')
|
|
|
5328 |
$this->y_data_label_pos = 'plotleft';
|
|
|
5329 |
else
|
|
|
5330 |
$this->y_data_label_pos = 'none';
|
|
|
5331 |
} else {
|
|
|
5332 |
// Case: Neither tick_label_pos nor data_label_pos is set.
|
|
|
5333 |
// Turn on data labels if any were supplied, else tick labels.
|
|
|
5334 |
if ($this->CheckLabelsAllEmpty()) {
|
|
|
5335 |
$this->y_data_label_pos = 'none';
|
|
|
5336 |
$this->y_tick_label_pos = 'plotleft';
|
|
|
5337 |
} else {
|
|
|
5338 |
$this->y_data_label_pos = 'plotleft';
|
|
|
5339 |
$this->y_tick_label_pos = 'none';
|
|
|
5340 |
}
|
|
|
5341 |
}
|
|
|
5342 |
}
|
|
|
5343 |
return TRUE;
|
|
|
5344 |
}
|
|
|
5345 |
|
|
|
5346 |
/**
|
|
|
5347 |
* Formats a value for use as a tick, data, or pie chart label
|
|
|
5348 |
*
|
|
|
5349 |
* @param string $which_pos Which format controls to use: x | y | xd | yd | p (tick, data, pie)
|
|
|
5350 |
* @param mixed $which_lab The value of the label to be formatted (usually a float)
|
|
|
5351 |
* @param mixed $varargs Zero or more additional arguments to pass to a custom format function
|
|
|
5352 |
* @return string The formatted label value (original value if no formatting is enabled)
|
|
|
5353 |
*/
|
|
|
5354 |
protected function FormatLabel($which_pos, $which_lab, $varargs=NULL) // Variable additional arguments
|
|
|
5355 |
{
|
|
|
5356 |
// Assign a reference shortcut to the label format controls, default xd,yd to x,y.
|
|
|
5357 |
if ($which_pos == 'xd' && empty($this->label_format['xd']))
|
|
|
5358 |
$which_pos = 'x';
|
|
|
5359 |
elseif ($which_pos == 'yd' && empty($this->label_format['yd']))
|
|
|
5360 |
$which_pos = 'y';
|
|
|
5361 |
$format = &$this->label_format[$which_pos];
|
|
|
5362 |
|
|
|
5363 |
// Don't format empty strings (especially as time or numbers), or if no type was set.
|
|
|
5364 |
if ($which_lab !== '' && !empty($format['type'])) {
|
|
|
5365 |
switch ($format['type']) {
|
|
|
5366 |
case 'title': // Note: This is obsolete
|
|
|
5367 |
$which_lab = @ $this->data[$which_lab][0];
|
|
|
5368 |
break;
|
|
|
5369 |
case 'data':
|
|
|
5370 |
$which_lab = $format['prefix']
|
|
|
5371 |
. $this->number_format($which_lab, $format['precision'])
|
|
|
5372 |
. $this->data_units_text // Obsolete
|
|
|
5373 |
. $format['suffix'];
|
|
|
5374 |
break;
|
|
|
5375 |
case 'time':
|
|
|
5376 |
$which_lab = strftime($format['time_format'], $which_lab);
|
|
|
5377 |
break;
|
|
|
5378 |
case 'printf':
|
|
|
5379 |
if (!is_array($format['printf_format'])) {
|
|
|
5380 |
$use_format = $format['printf_format'];
|
|
|
5381 |
} else {
|
|
|
5382 |
// Select from 1, 2, or 3 formats based on the sign of the value (like spreadsheets).
|
|
|
5383 |
// With 2 formats, use [0] for >= 0, [1] for < 0.
|
|
|
5384 |
// With 3 formats, use [0] for > 0, [1] for < 0, [2] for = 0.
|
|
|
5385 |
$n_formats = count($format['printf_format']);
|
|
|
5386 |
if ($n_formats == 3 && $which_lab == 0) {
|
|
|
5387 |
$use_format = $format['printf_format'][2];
|
|
|
5388 |
} elseif ($n_formats > 1 && $which_lab < 0) {
|
|
|
5389 |
$use_format = $format['printf_format'][1];
|
|
|
5390 |
$which_lab = -$which_lab; // Format the absolute value
|
|
|
5391 |
} else $use_format = $format['printf_format'][0];
|
|
|
5392 |
}
|
|
|
5393 |
$which_lab = sprintf($use_format, $which_lab);
|
|
|
5394 |
break;
|
|
|
5395 |
case 'custom':
|
|
|
5396 |
// Build argument vector: (text, custom_callback_arg, other_args...)
|
|
|
5397 |
$argv = func_get_args();
|
|
|
5398 |
$argv[0] = $which_lab;
|
|
|
5399 |
$argv[1] = $format['custom_arg'];
|
|
|
5400 |
$which_lab = call_user_func_array($format['custom_callback'], $argv);
|
|
|
5401 |
break;
|
|
|
5402 |
}
|
|
|
5403 |
}
|
|
|
5404 |
return $which_lab;
|
|
|
5405 |
}
|
|
|
5406 |
|
|
|
5407 |
/**
|
|
|
5408 |
* Sets range tuning parameters for X or Y
|
|
|
5409 |
*
|
|
|
5410 |
* This implements TuneXAutoRange() and TuneYAutoRange(). Note that
|
|
|
5411 |
* parameter values are checked, but invalid values are silently ignored.
|
|
|
5412 |
*
|
|
|
5413 |
* @param string $which Which axis to adjust parameters for: 'x' or 'y'
|
|
|
5414 |
* @param float $zero_magnet Zero magnet value, NULL to ignore
|
|
|
5415 |
* @param string $adjust_mode Range extension mode, NULL to ignore
|
|
|
5416 |
* @param float $adjust_amount Range extension amount, NULL to ignore
|
|
|
5417 |
* @return bool True always
|
|
|
5418 |
* @since 6.0.0
|
|
|
5419 |
*/
|
|
|
5420 |
protected function TuneAutoRange($which, $zero_magnet, $adjust_mode, $adjust_amount)
|
|
|
5421 |
{
|
|
|
5422 |
if (isset($zero_magnet) && $zero_magnet >= 0 && $zero_magnet <= 1.0)
|
|
|
5423 |
$this->rangectl[$which]['zero_magnet'] = $zero_magnet;
|
|
|
5424 |
if (isset($adjust_mode) && strpos('TRI', $adjust_mode[0]) !== FALSE)
|
|
|
5425 |
$this->rangectl[$which]['adjust_mode'] = $adjust_mode;
|
|
|
5426 |
if (isset($adjust_amount) && $adjust_amount >= 0)
|
|
|
5427 |
$this->rangectl[$which]['adjust_amount'] = $adjust_amount;
|
|
|
5428 |
return TRUE;
|
|
|
5429 |
}
|
|
|
5430 |
|
|
|
5431 |
/**
|
|
|
5432 |
* Adjusts tuning parameters for X axis range calculation
|
|
|
5433 |
*
|
|
|
5434 |
* See TuneAutoRange() above, which implements this function.
|
|
|
5435 |
*
|
|
|
5436 |
* @param float $zero_magnet Optional X axis zero magnet value, controlling range extension to include 0
|
|
|
5437 |
* @param string $adjust_mode Optional X axis range extension mode: T | R | I (Tick, Range, Integer)
|
|
|
5438 |
* @param float $adjust_amount Optional X axis range extension amount
|
|
|
5439 |
* @return bool True always
|
|
|
5440 |
* @since 6.0.0
|
|
|
5441 |
*/
|
|
|
5442 |
function TuneXAutoRange($zero_magnet = NULL, $adjust_mode = NULL, $adjust_amount = NULL)
|
|
|
5443 |
{
|
|
|
5444 |
return $this->TuneAutoRange('x', $zero_magnet, $adjust_mode, $adjust_amount);
|
|
|
5445 |
}
|
|
|
5446 |
|
|
|
5447 |
/**
|
|
|
5448 |
* Adjusts tuning parameters for Y axis range calculation
|
|
|
5449 |
*
|
|
|
5450 |
* See TuneAutoRange() above, which implements this function.
|
|
|
5451 |
*
|
|
|
5452 |
* @param float $zero_magnet Optional Y axis zero magnet value, controlling range extension to include 0
|
|
|
5453 |
* @param string $adjust_mode Optional Y axis range extension mode: T | R | I (Tick, Range, Integer)
|
|
|
5454 |
* @param float $adjust_amount Optional Y axis range extension amount
|
|
|
5455 |
* @return bool True always
|
|
|
5456 |
* @since 6.0.0
|
|
|
5457 |
*/
|
|
|
5458 |
function TuneYAutoRange($zero_magnet = NULL, $adjust_mode = NULL, $adjust_amount = NULL)
|
|
|
5459 |
{
|
|
|
5460 |
return $this->TuneAutoRange('y', $zero_magnet, $adjust_mode, $adjust_amount);
|
|
|
5461 |
}
|
|
|
5462 |
|
|
|
5463 |
/**
|
|
|
5464 |
* Sets tick tuning parameters for X or Y
|
|
|
5465 |
*
|
|
|
5466 |
* This implements TuneXAutoTicks() and TuneYAutoTicks().
|
|
|
5467 |
*
|
|
|
5468 |
* @param string $which Which axis to adjust parameters for: 'x' or 'y'
|
|
|
5469 |
* @param int $min_ticks Minimum number of tick intervals
|
|
|
5470 |
* @param string $tick_mode Tick increment calculation mode
|
|
|
5471 |
* @param bool $tick_inc_integer True to always use integer tick increments
|
|
|
5472 |
* @return bool True (False on error if an error handler returns True)
|
|
|
5473 |
* @since 6.0.0
|
|
|
5474 |
*/
|
|
|
5475 |
protected function TuneAutoTicks($which, $min_ticks, $tick_mode, $tick_inc_integer)
|
|
|
5476 |
{
|
|
|
5477 |
if (isset($min_ticks) && $min_ticks > 0)
|
|
|
5478 |
$this->tickctl[$which]['min_ticks'] = (integer)$min_ticks;
|
|
|
5479 |
if (isset($tick_mode)) {
|
|
|
5480 |
$tick_mode = $this->CheckOption($tick_mode, 'decimal, binary, date',
|
|
|
5481 |
'Tune' . strtoupper($which) . 'AutoTicks');
|
|
|
5482 |
if (!$tick_mode)
|
|
|
5483 |
return FALSE;
|
|
|
5484 |
$this->tickctl[$which]['tick_mode'] = $tick_mode;
|
|
|
5485 |
}
|
|
|
5486 |
if (isset($tick_inc_integer))
|
|
|
5487 |
$this->tickctl[$which]['tick_inc_integer'] = (bool)$tick_inc_integer;
|
|
|
5488 |
return TRUE;
|
|
|
5489 |
}
|
|
|
5490 |
|
|
|
5491 |
/**
|
|
|
5492 |
* Adjusts tuning parameters for X axis tick increment calculation
|
|
|
5493 |
*
|
|
|
5494 |
* See TuneAutoTicks() above, which implements this function.
|
|
|
5495 |
*
|
|
|
5496 |
* @param int $min_ticks Minimum number of tick intervals along the axis
|
|
|
5497 |
* @param string $tick_mode Tick increment calculation mode: decimal | binary | date
|
|
|
5498 |
* @param bool $tick_inc_integer True to always use integer tick increments, false to allow fractions
|
|
|
5499 |
* @return bool True (False on error if an error handler returns True)
|
|
|
5500 |
* @since 6.0.0
|
|
|
5501 |
*/
|
|
|
5502 |
function TuneXAutoTicks($min_ticks = NULL, $tick_mode = NULL, $tick_inc_integer = NULL)
|
|
|
5503 |
{
|
|
|
5504 |
return $this->TuneAutoTicks('x', $min_ticks, $tick_mode, $tick_inc_integer);
|
|
|
5505 |
}
|
|
|
5506 |
|
|
|
5507 |
/**
|
|
|
5508 |
* Adjusts tuning parameters for Y axis tick increment calculation
|
|
|
5509 |
*
|
|
|
5510 |
* See TuneAutoTicks() above, which implements this function.
|
|
|
5511 |
*
|
|
|
5512 |
* @param int $min_ticks Minimum number of tick intervals along the axis
|
|
|
5513 |
* @param string $tick_mode Tick increment calculation mode: decimal | binary | date
|
|
|
5514 |
* @param bool $tick_inc_integer True to always use integer tick increments, false to allow fractions
|
|
|
5515 |
* @return bool True (False on error if an error handler returns True)
|
|
|
5516 |
* @since 6.0.0
|
|
|
5517 |
*/
|
|
|
5518 |
function TuneYAutoTicks($min_ticks = NULL, $tick_mode = NULL, $tick_inc_integer = NULL)
|
|
|
5519 |
{
|
|
|
5520 |
return $this->TuneAutoTicks('y', $min_ticks, $tick_mode, $tick_inc_integer);
|
|
|
5521 |
}
|
|
|
5522 |
|
|
|
5523 |
|
|
|
5524 |
/////////////////////////////////////////////
|
|
|
5525 |
/////////////// TICKS
|
|
|
5526 |
/////////////////////////////////////////////
|
|
|
5527 |
|
|
|
5528 |
/**
|
|
|
5529 |
* Sets the length of the interval between X ticks
|
|
|
5530 |
*
|
|
|
5531 |
* @param float $which_ti X tick increment in world coordinates; omit or '' for default auto-calculate
|
|
|
5532 |
* @return bool True always
|
|
|
5533 |
*/
|
|
|
5534 |
function SetXTickIncrement($which_ti='')
|
|
|
5535 |
{
|
|
|
5536 |
$this->x_tick_inc_u = $which_ti;
|
|
|
5537 |
return TRUE;
|
|
|
5538 |
}
|
|
|
5539 |
|
|
|
5540 |
/**
|
|
|
5541 |
* Sets the length of the interval between Y ticks
|
|
|
5542 |
*
|
|
|
5543 |
* @param float $which_ti Y tick increment in world coordinates; omit or '' for default auto-calculate
|
|
|
5544 |
* @return bool True always
|
|
|
5545 |
*/
|
|
|
5546 |
function SetYTickIncrement($which_ti='')
|
|
|
5547 |
{
|
|
|
5548 |
$this->y_tick_inc_u = $which_ti;
|
|
|
5549 |
return TRUE;
|
|
|
5550 |
}
|
|
|
5551 |
|
|
|
5552 |
/**
|
|
|
5553 |
* Sets the number of X tick intervals
|
|
|
5554 |
*
|
|
|
5555 |
* @param int $which_nt Number of X tick intervals; omit or '' for default auto-calculate
|
|
|
5556 |
* @return bool True always
|
|
|
5557 |
*/
|
|
|
5558 |
function SetNumXTicks($which_nt='')
|
|
|
5559 |
{
|
|
|
5560 |
$this->num_x_ticks = $which_nt;
|
|
|
5561 |
return TRUE;
|
|
|
5562 |
}
|
|
|
5563 |
|
|
|
5564 |
/**
|
|
|
5565 |
* Sets the number of Y tick intervals
|
|
|
5566 |
*
|
|
|
5567 |
* @param int $which_nt Number of Y tick intervals; omit or '' for default auto-calculate
|
|
|
5568 |
* @return bool True always
|
|
|
5569 |
*/
|
|
|
5570 |
function SetNumYTicks($which_nt='')
|
|
|
5571 |
{
|
|
|
5572 |
$this->num_y_ticks = $which_nt;
|
|
|
5573 |
return TRUE;
|
|
|
5574 |
}
|
|
|
5575 |
|
|
|
5576 |
/**
|
|
|
5577 |
* Positions the X tick marks (above the plot, below, both above and below; at the X axis, or suppressed)
|
|
|
5578 |
*
|
|
|
5579 |
* @param string $which_tp Tick mark position: plotdown | plotup | both | xaxis | none
|
|
|
5580 |
* @return bool True (False on error if an error handler returns True)
|
|
|
5581 |
*/
|
|
|
5582 |
function SetXTickPos($which_tp)
|
|
|
5583 |
{
|
|
|
5584 |
$this->x_tick_pos = $this->CheckOption($which_tp, 'plotdown, plotup, both, xaxis, none',
|
|
|
5585 |
__FUNCTION__);
|
|
|
5586 |
return (boolean)$this->x_tick_pos;
|
|
|
5587 |
}
|
|
|
5588 |
|
|
|
5589 |
/**
|
|
|
5590 |
* Positions the Y tick marks (left, right, or both sides; at the Y axis, or suppressed)
|
|
|
5591 |
*
|
|
|
5592 |
* @param string $which_tp Tick mark position: plotleft | plotright | both | yaxis | none
|
|
|
5593 |
* @return bool True (False on error if an error handler returns True)
|
|
|
5594 |
*/
|
|
|
5595 |
function SetYTickPos($which_tp)
|
|
|
5596 |
{
|
|
|
5597 |
$this->y_tick_pos = $this->CheckOption($which_tp, 'plotleft, plotright, both, yaxis, none',
|
|
|
5598 |
__FUNCTION__);
|
|
|
5599 |
return (boolean)$this->y_tick_pos;
|
|
|
5600 |
}
|
|
|
5601 |
|
|
|
5602 |
/**
|
|
|
5603 |
* Suppress the top Y axis tick mark and label
|
|
|
5604 |
*
|
|
|
5605 |
* @param bool $skip True to skip the tick mark and label; false to draw them
|
|
|
5606 |
* @return bool True always
|
|
|
5607 |
*/
|
|
|
5608 |
function SetSkipTopTick($skip)
|
|
|
5609 |
{
|
|
|
5610 |
$this->skip_top_tick = (bool)$skip;
|
|
|
5611 |
return TRUE;
|
|
|
5612 |
}
|
|
|
5613 |
|
|
|
5614 |
/**
|
|
|
5615 |
* Suppress the bottom Y axis tick mark and label
|
|
|
5616 |
*
|
|
|
5617 |
* @param bool $skip True to skip the tick mark and label; false to draw them
|
|
|
5618 |
* @return bool True always
|
|
|
5619 |
*/
|
|
|
5620 |
function SetSkipBottomTick($skip)
|
|
|
5621 |
{
|
|
|
5622 |
$this->skip_bottom_tick = (bool)$skip;
|
|
|
5623 |
return TRUE;
|
|
|
5624 |
}
|
|
|
5625 |
|
|
|
5626 |
/**
|
|
|
5627 |
* Suppress the left-most (first) X axis tick mark and label
|
|
|
5628 |
*
|
|
|
5629 |
* @param bool $skip True to skip the tick mark and label; false to draw them
|
|
|
5630 |
* @return bool True always
|
|
|
5631 |
*/
|
|
|
5632 |
function SetSkipLeftTick($skip)
|
|
|
5633 |
{
|
|
|
5634 |
$this->skip_left_tick = (bool)$skip;
|
|
|
5635 |
return TRUE;
|
|
|
5636 |
}
|
|
|
5637 |
|
|
|
5638 |
/**
|
|
|
5639 |
* Suppress the right-most (last) X axis tick mark and label
|
|
|
5640 |
*
|
|
|
5641 |
* @param bool $skip True to skip the tick mark and label; false to draw them
|
|
|
5642 |
* @return bool True always
|
|
|
5643 |
*/
|
|
|
5644 |
function SetSkipRightTick($skip)
|
|
|
5645 |
{
|
|
|
5646 |
$this->skip_right_tick = (bool)$skip;
|
|
|
5647 |
return TRUE;
|
|
|
5648 |
}
|
|
|
5649 |
|
|
|
5650 |
/**
|
|
|
5651 |
* Sets the outer length of X tick marks (the part that sticks out from the plot area)
|
|
|
5652 |
*
|
|
|
5653 |
* @param int $which_xln Outer length of the tick marks, in pixels
|
|
|
5654 |
* @return bool True always
|
|
|
5655 |
*/
|
|
|
5656 |
function SetXTickLength($which_xln)
|
|
|
5657 |
{
|
|
|
5658 |
$this->x_tick_length = $which_xln;
|
|
|
5659 |
return TRUE;
|
|
|
5660 |
}
|
|
|
5661 |
|
|
|
5662 |
/**
|
|
|
5663 |
* Sets the outer length of Y tick marks (the part that sticks out from the plot area)
|
|
|
5664 |
*
|
|
|
5665 |
* @param int $which_yln Outer length of the tick marks, in pixels
|
|
|
5666 |
* @return bool True always
|
|
|
5667 |
*/
|
|
|
5668 |
function SetYTickLength($which_yln)
|
|
|
5669 |
{
|
|
|
5670 |
$this->y_tick_length = $which_yln;
|
|
|
5671 |
return TRUE;
|
|
|
5672 |
}
|
|
|
5673 |
|
|
|
5674 |
/**
|
|
|
5675 |
* Sets the crossing length of X tick marks (the part that sticks into the plot area)
|
|
|
5676 |
*
|
|
|
5677 |
* @param int $which_xc Crossing length of the tick marks, in pixels
|
|
|
5678 |
* @return bool True always
|
|
|
5679 |
*/
|
|
|
5680 |
function SetXTickCrossing($which_xc)
|
|
|
5681 |
{
|
|
|
5682 |
$this->x_tick_cross = $which_xc;
|
|
|
5683 |
return TRUE;
|
|
|
5684 |
}
|
|
|
5685 |
|
|
|
5686 |
/**
|
|
|
5687 |
* Sets the crossing length of Y tick marks (the part that sticks into the plot area)
|
|
|
5688 |
*
|
|
|
5689 |
* @param int $which_yc Crossing length of the tick marks, in pixels
|
|
|
5690 |
* @return bool True always
|
|
|
5691 |
*/
|
|
|
5692 |
function SetYTickCrossing($which_yc)
|
|
|
5693 |
{
|
|
|
5694 |
$this->y_tick_cross = $which_yc;
|
|
|
5695 |
return TRUE;
|
|
|
5696 |
}
|
|
|
5697 |
|
|
|
5698 |
/**
|
|
|
5699 |
* Sets an anchor point for X tick marks
|
|
|
5700 |
*
|
|
|
5701 |
* A tick anchor forces a tick mark at that exact value (if the data range were extended to include it).
|
|
|
5702 |
*
|
|
|
5703 |
* @param float $xta Tick anchor position in World Coordinates; omit or NULL for no anchor
|
|
|
5704 |
* @return bool True always
|
|
|
5705 |
* @since 5.4.0
|
|
|
5706 |
*/
|
|
|
5707 |
function SetXTickAnchor($xta = NULL)
|
|
|
5708 |
{
|
|
|
5709 |
$this->x_tick_anchor = $xta;
|
|
|
5710 |
return TRUE;
|
|
|
5711 |
}
|
|
|
5712 |
|
|
|
5713 |
/**
|
|
|
5714 |
* Sets an anchor point for Y tick marks
|
|
|
5715 |
*
|
|
|
5716 |
* A tick anchor forces a tick mark at that exact value (if the data range were extended to include it).
|
|
|
5717 |
*
|
|
|
5718 |
* @param float $yta Tick anchor position in World Coordinates; omit or NULL for no anchor
|
|
|
5719 |
* @return bool True always
|
|
|
5720 |
* @since 5.4.0
|
|
|
5721 |
*/
|
|
|
5722 |
function SetYTickAnchor($yta = NULL)
|
|
|
5723 |
{
|
|
|
5724 |
$this->y_tick_anchor = $yta;
|
|
|
5725 |
return TRUE;
|
|
|
5726 |
}
|
|
|
5727 |
|
|
|
5728 |
/////////////////////////////////////////////
|
|
|
5729 |
//////////////////// GENERIC DRAWING
|
|
|
5730 |
/////////////////////////////////////////////
|
|
|
5731 |
|
|
|
5732 |
/**
|
|
|
5733 |
* Fills the image background, with a tiled image file or solid color
|
|
|
5734 |
*
|
|
|
5735 |
* @param bool $overwrite True to do it even if already done, False or omit to do once only
|
|
|
5736 |
* @return bool True always
|
|
|
5737 |
*/
|
|
|
5738 |
protected function DrawBackground($overwrite=FALSE)
|
|
|
5739 |
{
|
|
|
5740 |
// Check if background should be drawn:
|
|
|
5741 |
if (empty($this->done['background']) || $overwrite) {
|
|
|
5742 |
if (isset($this->bgimg)) { // If bgimg is defined, use it
|
|
|
5743 |
$this->tile_img($this->bgimg, 0, 0, $this->image_width, $this->image_height, $this->bgmode);
|
|
|
5744 |
} else { // Else use solid color
|
|
|
5745 |
ImageFilledRectangle($this->img, 0, 0, $this->image_width, $this->image_height,
|
|
|
5746 |
$this->ndx_bg_color);
|
|
|
5747 |
}
|
|
|
5748 |
$this->done['background'] = TRUE;
|
|
|
5749 |
}
|
|
|
5750 |
return TRUE;
|
|
|
5751 |
}
|
|
|
5752 |
|
|
|
5753 |
/**
|
|
|
5754 |
* Fills the plot area background, with a tiled image file or solid color
|
|
|
5755 |
*
|
|
|
5756 |
* @return bool True always
|
|
|
5757 |
*/
|
|
|
5758 |
protected function DrawPlotAreaBackground()
|
|
|
5759 |
{
|
|
|
5760 |
if (isset($this->plotbgimg)) {
|
|
|
5761 |
$this->tile_img($this->plotbgimg, $this->plot_area[0], $this->plot_area[1],
|
|
|
5762 |
$this->plot_area_width, $this->plot_area_height, $this->plotbgmode);
|
|
|
5763 |
} elseif ($this->draw_plot_area_background) {
|
|
|
5764 |
ImageFilledRectangle($this->img, $this->plot_area[0], $this->plot_area[1],
|
|
|
5765 |
$this->plot_area[2], $this->plot_area[3], $this->ndx_plot_bg_color);
|
|
|
5766 |
}
|
|
|
5767 |
return TRUE;
|
|
|
5768 |
}
|
|
|
5769 |
|
|
|
5770 |
/**
|
|
|
5771 |
* Tiles an image from a file onto the plot image (for backgrounds)
|
|
|
5772 |
*
|
|
|
5773 |
* @param string $file Filename of the picture to be used as tile
|
|
|
5774 |
* @param int $xorig X device coordinate of where the tile is to begin
|
|
|
5775 |
* @param int $yorig Y device coordinate of where the tile is to begin
|
|
|
5776 |
* @param int $width Width of the area to be tiled
|
|
|
5777 |
* @param int $height Height of the area to be tiled
|
|
|
5778 |
* @param string $mode Tiling mode: centeredtile | tile | scale
|
|
|
5779 |
* @return bool True (False on error if an error handler returns True)
|
|
|
5780 |
*
|
|
|
5781 |
*/
|
|
|
5782 |
protected function tile_img($file, $xorig, $yorig, $width, $height, $mode)
|
|
|
5783 |
{
|
|
|
5784 |
$im = $this->GetImage($file, $tile_width, $tile_height);
|
|
|
5785 |
if (!$im)
|
|
|
5786 |
return FALSE; // GetImage already produced an error message.
|
|
|
5787 |
|
|
|
5788 |
if ($mode == 'scale') {
|
|
|
5789 |
imagecopyresampled($this->img, $im, $xorig, $yorig, 0, 0, $width, $height,
|
|
|
5790 |
$tile_width, $tile_height);
|
|
|
5791 |
return TRUE;
|
|
|
5792 |
}
|
|
|
5793 |
|
|
|
5794 |
if ($mode == 'centeredtile') {
|
|
|
5795 |
$x0 = - floor($tile_width/2); // Make the tile look better
|
|
|
5796 |
$y0 = - floor($tile_height/2);
|
|
|
5797 |
} else { // Accept anything else as $mode == 'tile'
|
|
|
5798 |
$x0 = 0;
|
|
|
5799 |
$y0 = 0;
|
|
|
5800 |
}
|
|
|
5801 |
|
|
|
5802 |
// Draw the tile onto a temporary image first.
|
|
|
5803 |
$tmp = imagecreate($width, $height);
|
|
|
5804 |
if (! $tmp)
|
|
|
5805 |
return $this->PrintError('tile_img(): Could not create image resource.');
|
|
|
5806 |
|
|
|
5807 |
for ($x = $x0; $x < $width; $x += $tile_width)
|
|
|
5808 |
for ($y = $y0; $y < $height; $y += $tile_height)
|
|
|
5809 |
imagecopy($tmp, $im, $x, $y, 0, 0, $tile_width, $tile_height);
|
|
|
5810 |
|
|
|
5811 |
// Copy the temporary image onto the final one.
|
|
|
5812 |
imagecopy($this->img, $tmp, $xorig, $yorig, 0,0, $width, $height);
|
|
|
5813 |
|
|
|
5814 |
// Free resources
|
|
|
5815 |
imagedestroy($tmp);
|
|
|
5816 |
imagedestroy($im);
|
|
|
5817 |
|
|
|
5818 |
return TRUE;
|
|
|
5819 |
}
|
|
|
5820 |
|
|
|
5821 |
/**
|
|
|
5822 |
* Returns the width of the image border, for CalcMargins() and DrawImageBorder().
|
|
|
5823 |
*
|
|
|
5824 |
* @return int Border width in pixels, 0 for no borders
|
|
|
5825 |
* @since 5.1.2
|
|
|
5826 |
*/
|
|
|
5827 |
protected function GetImageBorderWidth()
|
|
|
5828 |
{
|
|
|
5829 |
if ($this->image_border_type == 'none')
|
|
|
5830 |
return 0; // No border
|
|
|
5831 |
if (!empty($this->image_border_width))
|
|
|
5832 |
return $this->image_border_width; // Specified border width
|
|
|
5833 |
if ($this->image_border_type == 'raised')
|
|
|
5834 |
return 2; // Default for raised border is 2 pixels.
|
|
|
5835 |
return 1; // Default for other border types is 1 pixel.
|
|
|
5836 |
}
|
|
|
5837 |
|
|
|
5838 |
/**
|
|
|
5839 |
* Draws a border around the final image
|
|
|
5840 |
*
|
|
|
5841 |
* This draws a border around the image, if enabled by SetImageBorderType().
|
|
|
5842 |
* Note: type 'plain' draws a flat border using the dark shade of the border color.
|
|
|
5843 |
* This probably should have been written to use the actual border color, but
|
|
|
5844 |
* it is too late to fix it without changing plot appearances. Therefore a
|
|
|
5845 |
* new type 'solid' was added to use the SetImageBorderColor color.
|
|
|
5846 |
*
|
|
|
5847 |
* @param bool $overwrite True to do it even if already done, False or omit to do once only
|
|
|
5848 |
* @return bool True (False on error if an error handler returns True)
|
|
|
5849 |
*
|
|
|
5850 |
*/
|
|
|
5851 |
protected function DrawImageBorder($overwrite=FALSE)
|
|
|
5852 |
{
|
|
|
5853 |
// Check if border should be drawn:
|
|
|
5854 |
if ($this->image_border_type == 'none' || !(empty($this->done['border']) || $overwrite))
|
|
|
5855 |
return TRUE;
|
|
|
5856 |
$width = $this->GetImageBorderWidth();
|
|
|
5857 |
$color1 = $this->ndx_i_border;
|
|
|
5858 |
$color2 = $this->ndx_i_border_dark;
|
|
|
5859 |
$ex = $this->image_width - 1;
|
|
|
5860 |
$ey = $this->image_height - 1;
|
|
|
5861 |
switch ($this->image_border_type) {
|
|
|
5862 |
case 'raised':
|
|
|
5863 |
// Top and left lines use border color, right and bottom use the darker shade.
|
|
|
5864 |
// Drawing order matters in the upper right and lower left corners.
|
|
|
5865 |
for ($i = 0; $i < $width; $i++, $ex--, $ey--) {
|
|
|
5866 |
imageline($this->img, $i, $i, $ex, $i, $color1); // Top
|
|
|
5867 |
imageline($this->img, $ex, $i, $ex, $ey, $color2); // Right
|
|
|
5868 |
imageline($this->img, $i, $i, $i, $ey, $color1); // Left
|
|
|
5869 |
imageline($this->img, $i, $ey, $ex, $ey, $color2); // Bottom
|
|
|
5870 |
}
|
|
|
5871 |
break;
|
|
|
5872 |
case 'plain': // See note above re colors
|
|
|
5873 |
$color1 = $color2;
|
|
|
5874 |
// Fall through
|
|
|
5875 |
case 'solid':
|
|
|
5876 |
for ($i = 0; $i < $width; $i++, $ex--, $ey--) {
|
|
|
5877 |
imagerectangle($this->img, $i, $i, $ex, $ey, $color1);
|
|
|
5878 |
}
|
|
|
5879 |
break;
|
|
|
5880 |
default:
|
|
|
5881 |
return $this->PrintError(
|
|
|
5882 |
"DrawImageBorder(): unknown image_border_type: '$this->image_border_type'");
|
|
|
5883 |
}
|
|
|
5884 |
$this->done['border'] = TRUE; // Border should only be drawn once per image.
|
|
|
5885 |
return TRUE;
|
|
|
5886 |
}
|
|
|
5887 |
|
|
|
5888 |
/**
|
|
|
5889 |
* Draws the main plot title
|
|
|
5890 |
*
|
|
|
5891 |
* @return bool True always
|
|
|
5892 |
*/
|
|
|
5893 |
protected function DrawTitle()
|
|
|
5894 |
{
|
|
|
5895 |
if (!empty($this->done['title']) || $this->title_txt === '')
|
|
|
5896 |
return TRUE;
|
|
|
5897 |
|
|
|
5898 |
// Center of the image:
|
|
|
5899 |
$xpos = $this->image_width / 2;
|
|
|
5900 |
|
|
|
5901 |
// Place it at almost at the top
|
|
|
5902 |
$ypos = $this->title_offset;
|
|
|
5903 |
|
|
|
5904 |
$this->DrawText('title', 0, $xpos, $ypos, $this->ndx_title_color, $this->title_txt, 'center', 'top');
|
|
|
5905 |
|
|
|
5906 |
$this->done['title'] = TRUE;
|
|
|
5907 |
return TRUE;
|
|
|
5908 |
}
|
|
|
5909 |
|
|
|
5910 |
/**
|
|
|
5911 |
* Draws the X axis title, on the top or bottom (or both) of the plot area
|
|
|
5912 |
*
|
|
|
5913 |
* @return bool True always
|
|
|
5914 |
*/
|
|
|
5915 |
protected function DrawXTitle()
|
|
|
5916 |
{
|
|
|
5917 |
if ($this->x_title_pos == 'none')
|
|
|
5918 |
return TRUE;
|
|
|
5919 |
|
|
|
5920 |
// Center of the plot
|
|
|
5921 |
$xpos = ($this->plot_area[2] + $this->plot_area[0]) / 2;
|
|
|
5922 |
|
|
|
5923 |
// Upper title
|
|
|
5924 |
if ($this->x_title_pos == 'plotup' || $this->x_title_pos == 'both') {
|
|
|
5925 |
$ypos = $this->plot_area[1] - $this->x_title_top_offset;
|
|
|
5926 |
$this->DrawText('x_title', 0, $xpos, $ypos, $this->ndx_x_title_color,
|
|
|
5927 |
$this->x_title_txt, 'center', 'bottom');
|
|
|
5928 |
}
|
|
|
5929 |
// Lower title
|
|
|
5930 |
if ($this->x_title_pos == 'plotdown' || $this->x_title_pos == 'both') {
|
|
|
5931 |
$ypos = $this->plot_area[3] + $this->x_title_bot_offset;
|
|
|
5932 |
$this->DrawText('x_title', 0, $xpos, $ypos, $this->ndx_x_title_color,
|
|
|
5933 |
$this->x_title_txt, 'center', 'top');
|
|
|
5934 |
}
|
|
|
5935 |
return TRUE;
|
|
|
5936 |
}
|
|
|
5937 |
|
|
|
5938 |
/**
|
|
|
5939 |
* Draws the Y axis title, on the left or right side (or both) of the plot area
|
|
|
5940 |
*
|
|
|
5941 |
* @return bool True always
|
|
|
5942 |
*/
|
|
|
5943 |
protected function DrawYTitle()
|
|
|
5944 |
{
|
|
|
5945 |
if ($this->y_title_pos == 'none')
|
|
|
5946 |
return TRUE;
|
|
|
5947 |
|
|
|
5948 |
// Center the title vertically to the plot area
|
|
|
5949 |
$ypos = ($this->plot_area[3] + $this->plot_area[1]) / 2;
|
|
|
5950 |
|
|
|
5951 |
if ($this->y_title_pos == 'plotleft' || $this->y_title_pos == 'both') {
|
|
|
5952 |
$xpos = $this->plot_area[0] - $this->y_title_left_offset;
|
|
|
5953 |
$this->DrawText('y_title', 90, $xpos, $ypos, $this->ndx_y_title_color,
|
|
|
5954 |
$this->y_title_txt, 'right', 'center');
|
|
|
5955 |
}
|
|
|
5956 |
if ($this->y_title_pos == 'plotright' || $this->y_title_pos == 'both') {
|
|
|
5957 |
$xpos = $this->plot_area[2] + $this->y_title_right_offset;
|
|
|
5958 |
$this->DrawText('y_title', 90, $xpos, $ypos, $this->ndx_y_title_color,
|
|
|
5959 |
$this->y_title_txt, 'left', 'center');
|
|
|
5960 |
}
|
|
|
5961 |
|
|
|
5962 |
return TRUE;
|
|
|
5963 |
}
|
|
|
5964 |
|
|
|
5965 |
/**
|
|
|
5966 |
* Draws the X axis, including ticks and labels, and vertical grid lines
|
|
|
5967 |
*
|
|
|
5968 |
* @return bool True always
|
|
|
5969 |
*/
|
|
|
5970 |
protected function DrawXAxis()
|
|
|
5971 |
{
|
|
|
5972 |
// Draw ticks, labels and grid
|
|
|
5973 |
$this->DrawXTicks();
|
|
|
5974 |
|
|
|
5975 |
//Draw X Axis at Y = x_axis_y_pixels, unless suppressed (See SetXAxisPosition)
|
|
|
5976 |
if (!$this->suppress_x_axis) {
|
|
|
5977 |
ImageLine($this->img, $this->plot_area[0]+1, $this->x_axis_y_pixels,
|
|
|
5978 |
$this->plot_area[2]-1, $this->x_axis_y_pixels, $this->ndx_grid_color);
|
|
|
5979 |
}
|
|
|
5980 |
return TRUE;
|
|
|
5981 |
}
|
|
|
5982 |
|
|
|
5983 |
/**
|
|
|
5984 |
* Draws the Y axis, including ticks and labels, and horizontal grid lines
|
|
|
5985 |
*
|
|
|
5986 |
* This draws the Y axis and grid lines. It must be called before DrawXAxis() to avoid
|
|
|
5987 |
* having a horizontal grid line overwrite the X axis.
|
|
|
5988 |
*
|
|
|
5989 |
* @return bool True always
|
|
|
5990 |
*/
|
|
|
5991 |
protected function DrawYAxis()
|
|
|
5992 |
{
|
|
|
5993 |
// Draw ticks, labels and grid
|
|
|
5994 |
$this->DrawYTicks();
|
|
|
5995 |
|
|
|
5996 |
// Draw Y axis at X = y_axis_x_pixels, unless suppressed (See SetYAxisPosition)
|
|
|
5997 |
if (!$this->suppress_y_axis) {
|
|
|
5998 |
ImageLine($this->img, $this->y_axis_x_pixels, $this->plot_area[1],
|
|
|
5999 |
$this->y_axis_x_pixels, $this->plot_area[3], $this->ndx_grid_color);
|
|
|
6000 |
}
|
|
|
6001 |
return TRUE;
|
|
|
6002 |
}
|
|
|
6003 |
|
|
|
6004 |
/**
|
|
|
6005 |
* Draws one X tick mark and its tick label
|
|
|
6006 |
*
|
|
|
6007 |
* @param float $x X value for the label
|
|
|
6008 |
* @param int $x_pixels X device coordinate for this tick mark
|
|
|
6009 |
* @return bool True always
|
|
|
6010 |
* @since 5.0.5
|
|
|
6011 |
*/
|
|
|
6012 |
protected function DrawXTick($x, $x_pixels)
|
|
|
6013 |
{
|
|
|
6014 |
// Ticks on X axis
|
|
|
6015 |
if ($this->x_tick_pos == 'xaxis') {
|
|
|
6016 |
ImageLine($this->img, $x_pixels, $this->x_axis_y_pixels - $this->x_tick_cross,
|
|
|
6017 |
$x_pixels, $this->x_axis_y_pixels + $this->x_tick_length, $this->ndx_tick_color);
|
|
|
6018 |
}
|
|
|
6019 |
|
|
|
6020 |
// Ticks on top of the Plot Area
|
|
|
6021 |
if ($this->x_tick_pos == 'plotup' || $this->x_tick_pos == 'both') {
|
|
|
6022 |
ImageLine($this->img, $x_pixels, $this->plot_area[1] - $this->x_tick_length,
|
|
|
6023 |
$x_pixels, $this->plot_area[1] + $this->x_tick_cross, $this->ndx_tick_color);
|
|
|
6024 |
}
|
|
|
6025 |
|
|
|
6026 |
// Ticks on bottom of Plot Area
|
|
|
6027 |
if ($this->x_tick_pos == 'plotdown' || $this->x_tick_pos == 'both') {
|
|
|
6028 |
ImageLine($this->img, $x_pixels, $this->plot_area[3] + $this->x_tick_length,
|
|
|
6029 |
$x_pixels, $this->plot_area[3] - $this->x_tick_cross, $this->ndx_tick_color);
|
|
|
6030 |
}
|
|
|
6031 |
|
|
|
6032 |
if ($this->x_tick_label_pos != 'none') {
|
|
|
6033 |
$x_label = $this->FormatLabel('x', $x);
|
|
|
6034 |
|
|
|
6035 |
// Label on X axis
|
|
|
6036 |
if ($this->x_tick_label_pos == 'xaxis') {
|
|
|
6037 |
$this->DrawText('x_label', $this->x_label_angle,
|
|
|
6038 |
$x_pixels, $this->x_axis_y_pixels + $this->x_label_axis_offset,
|
|
|
6039 |
$this->ndx_ticklabel_color, $x_label, 'center', 'top');
|
|
|
6040 |
}
|
|
|
6041 |
|
|
|
6042 |
// Label on top of the plot area
|
|
|
6043 |
if ($this->x_tick_label_pos == 'plotup' || $this->x_tick_label_pos == 'both') {
|
|
|
6044 |
$this->DrawText('x_label', $this->x_label_angle,
|
|
|
6045 |
$x_pixels, $this->plot_area[1] - $this->x_label_top_offset,
|
|
|
6046 |
$this->ndx_ticklabel_color, $x_label, 'center', 'bottom');
|
|
|
6047 |
}
|
|
|
6048 |
|
|
|
6049 |
// Label on bottom of the plot area
|
|
|
6050 |
if ($this->x_tick_label_pos == 'plotdown' || $this->x_tick_label_pos == 'both') {
|
|
|
6051 |
$this->DrawText('x_label', $this->x_label_angle,
|
|
|
6052 |
$x_pixels, $this->plot_area[3] + $this->x_label_bot_offset,
|
|
|
6053 |
$this->ndx_ticklabel_color, $x_label, 'center', 'top');
|
|
|
6054 |
}
|
|
|
6055 |
}
|
|
|
6056 |
return TRUE;
|
|
|
6057 |
}
|
|
|
6058 |
|
|
|
6059 |
/**
|
|
|
6060 |
* Draws one Y tick mark and its tick label
|
|
|
6061 |
*
|
|
|
6062 |
* @param float $y Y value for the label
|
|
|
6063 |
* @param int $y_pixels Y device coordinate for this tick mark
|
|
|
6064 |
* @return bool True always
|
|
|
6065 |
* @since 5.8.0
|
|
|
6066 |
*/
|
|
|
6067 |
protected function DrawYTick($y, $y_pixels)
|
|
|
6068 |
{
|
|
|
6069 |
// Ticks on Y axis
|
|
|
6070 |
if ($this->y_tick_pos == 'yaxis') {
|
|
|
6071 |
ImageLine($this->img, $this->y_axis_x_pixels - $this->y_tick_length, $y_pixels,
|
|
|
6072 |
$this->y_axis_x_pixels + $this->y_tick_cross, $y_pixels, $this->ndx_tick_color);
|
|
|
6073 |
}
|
|
|
6074 |
|
|
|
6075 |
// Ticks to the left of the Plot Area
|
|
|
6076 |
if (($this->y_tick_pos == 'plotleft') || ($this->y_tick_pos == 'both') ) {
|
|
|
6077 |
ImageLine($this->img, $this->plot_area[0] - $this->y_tick_length, $y_pixels,
|
|
|
6078 |
$this->plot_area[0] + $this->y_tick_cross, $y_pixels, $this->ndx_tick_color);
|
|
|
6079 |
}
|
|
|
6080 |
|
|
|
6081 |
// Ticks to the right of the Plot Area
|
|
|
6082 |
if (($this->y_tick_pos == 'plotright') || ($this->y_tick_pos == 'both') ) {
|
|
|
6083 |
ImageLine($this->img, $this->plot_area[2] + $this->y_tick_length, $y_pixels,
|
|
|
6084 |
$this->plot_area[2] - $this->y_tick_cross, $y_pixels, $this->ndx_tick_color);
|
|
|
6085 |
}
|
|
|
6086 |
|
|
|
6087 |
if ($this->y_tick_label_pos != 'none') {
|
|
|
6088 |
$y_label = $this->FormatLabel('y', $y);
|
|
|
6089 |
|
|
|
6090 |
// Labels on Y axis
|
|
|
6091 |
if ($this->y_tick_label_pos == 'yaxis') {
|
|
|
6092 |
$this->DrawText('y_label', $this->y_label_angle,
|
|
|
6093 |
$this->y_axis_x_pixels - $this->y_label_axis_offset, $y_pixels,
|
|
|
6094 |
$this->ndx_ticklabel_color, $y_label, 'right', 'center');
|
|
|
6095 |
}
|
|
|
6096 |
|
|
|
6097 |
// Labels to the left of the plot area
|
|
|
6098 |
if ($this->y_tick_label_pos == 'plotleft' || $this->y_tick_label_pos == 'both') {
|
|
|
6099 |
$this->DrawText('y_label', $this->y_label_angle,
|
|
|
6100 |
$this->plot_area[0] - $this->y_label_left_offset, $y_pixels,
|
|
|
6101 |
$this->ndx_ticklabel_color, $y_label, 'right', 'center');
|
|
|
6102 |
}
|
|
|
6103 |
|
|
|
6104 |
// Labels to the right of the plot area
|
|
|
6105 |
if ($this->y_tick_label_pos == 'plotright' || $this->y_tick_label_pos == 'both') {
|
|
|
6106 |
$this->DrawText('y_label', $this->y_label_angle,
|
|
|
6107 |
$this->plot_area[2] + $this->y_label_right_offset, $y_pixels,
|
|
|
6108 |
$this->ndx_ticklabel_color, $y_label, 'left', 'center');
|
|
|
6109 |
}
|
|
|
6110 |
}
|
|
|
6111 |
return TRUE;
|
|
|
6112 |
}
|
|
|
6113 |
|
|
|
6114 |
/**
|
|
|
6115 |
* Draws the vertical grid lines, the X axis tick marks, and X axis tick labels
|
|
|
6116 |
*
|
|
|
6117 |
* @return bool True always
|
|
|
6118 |
*/
|
|
|
6119 |
protected function DrawXTicks()
|
|
|
6120 |
{
|
|
|
6121 |
// Set color for solid, or flag for dashed line:
|
|
|
6122 |
$style = $this->SetDashedStyle($this->ndx_light_grid_color, $this->dashed_grid);
|
|
|
6123 |
|
|
|
6124 |
// Draw grids lines?
|
|
|
6125 |
$draw_grid = $this->GetGridSetting('x');
|
|
|
6126 |
|
|
|
6127 |
// Calculate the tick start, end, and step:
|
|
|
6128 |
list($x_start, $x_end, $delta_x) = $this->CalcTicks('x');
|
|
|
6129 |
|
|
|
6130 |
// Loop, avoiding cumulative round-off errors from $x += $delta_x
|
|
|
6131 |
for ($n = 0; ($x = $x_start + $n * $delta_x) <= $x_end; $n++) {
|
|
|
6132 |
$x_pixels = $this->xtr($x);
|
|
|
6133 |
|
|
|
6134 |
// Draw vertical grid line:
|
|
|
6135 |
if ($draw_grid) {
|
|
|
6136 |
ImageLine($this->img, $x_pixels, $this->plot_area[1], $x_pixels, $this->plot_area[3], $style);
|
|
|
6137 |
}
|
|
|
6138 |
|
|
|
6139 |
// Draw tick mark and tick label:
|
|
|
6140 |
$this->DrawXTick($x, $x_pixels);
|
|
|
6141 |
}
|
|
|
6142 |
return TRUE;
|
|
|
6143 |
}
|
|
|
6144 |
|
|
|
6145 |
/**
|
|
|
6146 |
* Draws the horizontal grid lines, the Y axis tick marks, and Y axis tick labels
|
|
|
6147 |
*
|
|
|
6148 |
* @return bool True always
|
|
|
6149 |
*/
|
|
|
6150 |
protected function DrawYTicks()
|
|
|
6151 |
{
|
|
|
6152 |
// Set color for solid, or flag for dashed line:
|
|
|
6153 |
$style = $this->SetDashedStyle($this->ndx_light_grid_color, $this->dashed_grid);
|
|
|
6154 |
|
|
|
6155 |
// Draw grids lines?
|
|
|
6156 |
$draw_grid = $this->GetGridSetting('y');
|
|
|
6157 |
|
|
|
6158 |
// Calculate the tick start, end, and step:
|
|
|
6159 |
list($y_start, $y_end, $delta_y) = $this->CalcTicks('y');
|
|
|
6160 |
|
|
|
6161 |
// Loop, avoiding cumulative round-off errors from $y += $delta_y
|
|
|
6162 |
for ($n = 0; ($y = $y_start + $n * $delta_y) <= $y_end; $n++) {
|
|
|
6163 |
$y_pixels = $this->ytr($y);
|
|
|
6164 |
|
|
|
6165 |
// Draw horizontal grid line:
|
|
|
6166 |
if ($draw_grid) {
|
|
|
6167 |
ImageLine($this->img, $this->plot_area[0]+1, $y_pixels, $this->plot_area[2]-1,
|
|
|
6168 |
$y_pixels, $style);
|
|
|
6169 |
}
|
|
|
6170 |
|
|
|
6171 |
// Draw tick mark and tick label:
|
|
|
6172 |
$this->DrawYTick($y, $y_pixels);
|
|
|
6173 |
}
|
|
|
6174 |
return TRUE;
|
|
|
6175 |
}
|
|
|
6176 |
|
|
|
6177 |
/**
|
|
|
6178 |
* Draws the border around the plot area
|
|
|
6179 |
*
|
|
|
6180 |
* This draws the plot border, as set by SetPlotBorderType(). The
|
|
|
6181 |
* plot_border_type can be unset/NULL, a scaler, or an array. If unset or null,
|
|
|
6182 |
* the default is used ('sides' if the plot includes axes, 'none' if not).
|
|
|
6183 |
*
|
|
|
6184 |
* @param bool $draw_axes True or omit to draw the X axis and Y axis, false to not (for pie charts)
|
|
|
6185 |
* @return bool True always
|
|
|
6186 |
*/
|
|
|
6187 |
protected function DrawPlotBorder($draw_axes = TRUE)
|
|
|
6188 |
{
|
|
|
6189 |
// Force plot_border_type to array and apply defaults.
|
|
|
6190 |
if (isset($this->plot_border_type)) {
|
|
|
6191 |
$pbt = (array)$this->plot_border_type;
|
|
|
6192 |
} elseif ($draw_axes) $pbt = array('sides');
|
|
|
6193 |
else return TRUE; // Default to no border for plots without axes (e.g. pie charts)
|
|
|
6194 |
|
|
|
6195 |
$sides = 0; // Bitmap: 1=left 2=top 4=right 8=bottom
|
|
|
6196 |
$map = array('left' => 1, 'plotleft' => 1, 'right' => 4, 'plotright' => 4, 'top' => 2,
|
|
|
6197 |
'bottom' => 8, 'both' => 5, 'sides' => 5, 'full' => 15, 'none' => 0);
|
|
|
6198 |
foreach ($pbt as $option) $sides |= $map[$option];
|
|
|
6199 |
if ($sides == 15) { // Border on all 4 sides
|
|
|
6200 |
imagerectangle($this->img, $this->plot_area[0], $this->plot_area[1],
|
|
|
6201 |
$this->plot_area[2], $this->plot_area[3], $this->ndx_grid_color);
|
|
|
6202 |
} else {
|
|
|
6203 |
if ($sides & 1) // Left
|
|
|
6204 |
imageline($this->img, $this->plot_area[0], $this->plot_area[1],
|
|
|
6205 |
$this->plot_area[0], $this->plot_area[3], $this->ndx_grid_color);
|
|
|
6206 |
if ($sides & 2) // Top
|
|
|
6207 |
imageline($this->img, $this->plot_area[0], $this->plot_area[1],
|
|
|
6208 |
$this->plot_area[2], $this->plot_area[1], $this->ndx_grid_color);
|
|
|
6209 |
if ($sides & 4) // Right
|
|
|
6210 |
imageline($this->img, $this->plot_area[2], $this->plot_area[1],
|
|
|
6211 |
$this->plot_area[2], $this->plot_area[3], $this->ndx_grid_color);
|
|
|
6212 |
if ($sides & 8) // Bottom
|
|
|
6213 |
imageline($this->img, $this->plot_area[0], $this->plot_area[3],
|
|
|
6214 |
$this->plot_area[2], $this->plot_area[3], $this->ndx_grid_color);
|
|
|
6215 |
}
|
|
|
6216 |
return TRUE;
|
|
|
6217 |
}
|
|
|
6218 |
|
|
|
6219 |
/**
|
|
|
6220 |
* Draws the data value label associated with a point in the plot
|
|
|
6221 |
*
|
|
|
6222 |
* The labels drawn by this function are those that show the value (usually
|
|
|
6223 |
* the Y value) of the data point. They are drawn within the plot area,
|
|
|
6224 |
* not to be confused with axis data labels.
|
|
|
6225 |
*
|
|
|
6226 |
* The $dvl parameter array can contain these keys:
|
|
|
6227 |
* h_align v_align : Selects from 9-point text alignment (default center, center);
|
|
|
6228 |
* x_offset y_offset : Text position offsets, in device coordinates (default 0,0);
|
|
|
6229 |
* min_width min_height : Suppress the text if it will not fit (default null,null = no check).
|
|
|
6230 |
* See also CheckDataValueLabels() which sets some of these.
|
|
|
6231 |
*
|
|
|
6232 |
* @param string $x_or_y Which labels: x | y, used to select font, angle, formatting
|
|
|
6233 |
* @param int $row Identifies the row of the data point (for custom label formatting)
|
|
|
6234 |
* @param int $column Identifies the column of the data point (for custom label formatting)
|
|
|
6235 |
* @param float $x_world X world coordinate of the base point
|
|
|
6236 |
* @param float $y_world Y world coordinate of the base point
|
|
|
6237 |
* @param mixed $text The text to draw after formatting with FormatLabel()
|
|
|
6238 |
* @param mixed[] $dvl Associative array with additional label position controls (see above)
|
|
|
6239 |
* @return bool True, if the text was drawn, or False, if it will not fit
|
|
|
6240 |
* @since 5.1.3
|
|
|
6241 |
*/
|
|
|
6242 |
protected function DrawDataValueLabel($x_or_y, $row, $column, $x_world, $y_world, $text, $dvl)
|
|
|
6243 |
{
|
|
|
6244 |
if ($x_or_y == 'x') {
|
|
|
6245 |
$angle = $this->x_data_label_angle;
|
|
|
6246 |
$font_id = 'x_label';
|
|
|
6247 |
$formatted_text = $this->FormatLabel('xd', $text, $row, $column);
|
|
|
6248 |
} else { // Assumed 'y'
|
|
|
6249 |
$angle = $this->y_data_label_angle;
|
|
|
6250 |
$font_id = 'y_label';
|
|
|
6251 |
$formatted_text = $this->FormatLabel('yd', $text, $row, $column);
|
|
|
6252 |
}
|
|
|
6253 |
// Assign defaults and then extract control variables from $dvl:
|
|
|
6254 |
$x_offset = $y_offset = 0;
|
|
|
6255 |
$h_align = $v_align = 'center';
|
|
|
6256 |
extract($dvl);
|
|
|
6257 |
|
|
|
6258 |
// Check to see if the text fits in the available space, if requested.
|
|
|
6259 |
if (isset($min_width) || isset($min_height)) {
|
|
|
6260 |
list($width, $height) = $this->SizeText($font_id, $angle, $formatted_text);
|
|
|
6261 |
if ((isset($min_width) && ($min_width - $width) < 2)
|
|
|
6262 |
|| (isset($min_height) && ($min_height - $height) < 2))
|
|
|
6263 |
return FALSE;
|
|
|
6264 |
}
|
|
|
6265 |
|
|
|
6266 |
$this->DrawText($font_id, $angle, $this->xtr($x_world) + $x_offset, $this->ytr($y_world) + $y_offset,
|
|
|
6267 |
$this->ndx_dvlabel_color, $formatted_text, $h_align, $v_align);
|
|
|
6268 |
return TRUE;
|
|
|
6269 |
}
|
|
|
6270 |
|
|
|
6271 |
/**
|
|
|
6272 |
* Draws an X axis data label, and optional data label line (used in vertical plots)
|
|
|
6273 |
*
|
|
|
6274 |
* @param string $xlab Text of the label to draw
|
|
|
6275 |
* @param int $xpos X position for the label, in device coordinates
|
|
|
6276 |
* @param int $row Row index, 0 for the first X, 1 for the second, etc.
|
|
|
6277 |
* @param bool $do_lines True for plot types that support data label lines, False or omit if not
|
|
|
6278 |
* @return bool True always
|
|
|
6279 |
*/
|
|
|
6280 |
protected function DrawXDataLabel($xlab, $xpos, $row, $do_lines=FALSE)
|
|
|
6281 |
{
|
|
|
6282 |
$xlab = $this->FormatLabel('xd', $xlab, $row);
|
|
|
6283 |
|
|
|
6284 |
// Labels below the plot area
|
|
|
6285 |
if ($this->x_data_label_pos == 'plotdown' || $this->x_data_label_pos == 'both')
|
|
|
6286 |
$this->DrawText('x_label', $this->x_data_label_angle,
|
|
|
6287 |
$xpos, $this->plot_area[3] + $this->x_label_bot_offset,
|
|
|
6288 |
$this->ndx_datalabel_color, $xlab, 'center', 'top');
|
|
|
6289 |
|
|
|
6290 |
// Labels above the plot area
|
|
|
6291 |
if ($this->x_data_label_pos == 'plotup' || $this->x_data_label_pos == 'both')
|
|
|
6292 |
$this->DrawText('x_label', $this->x_data_label_angle,
|
|
|
6293 |
$xpos, $this->plot_area[1] - $this->x_label_top_offset,
|
|
|
6294 |
$this->ndx_datalabel_color, $xlab, 'center', 'bottom');
|
|
|
6295 |
|
|
|
6296 |
if ($do_lines && $this->draw_x_data_label_lines)
|
|
|
6297 |
$this->DrawXDataLine($xpos, $row);
|
|
|
6298 |
return TRUE;
|
|
|
6299 |
}
|
|
|
6300 |
|
|
|
6301 |
/**
|
|
|
6302 |
* Draws a Y axis data label, and optional data label line (used in horizontal plots)
|
|
|
6303 |
*
|
|
|
6304 |
* @param string $ylab Text of the label to draw
|
|
|
6305 |
* @param int $ypos Y position for the label, in device coordinates
|
|
|
6306 |
* @param int $row Row index, 0 for the first Y, 1 for the second, etc.
|
|
|
6307 |
* @param bool $do_lines True for plot types that support data label lines, False or omit if not
|
|
|
6308 |
* @return bool True always
|
|
|
6309 |
* @since 5.1.2
|
|
|
6310 |
*/
|
|
|
6311 |
protected function DrawYDataLabel($ylab, $ypos, $row, $do_lines=FALSE)
|
|
|
6312 |
{
|
|
|
6313 |
$ylab = $this->FormatLabel('yd', $ylab, $row);
|
|
|
6314 |
|
|
|
6315 |
// Labels left of the plot area
|
|
|
6316 |
if ($this->y_data_label_pos == 'plotleft' || $this->y_data_label_pos == 'both')
|
|
|
6317 |
$this->DrawText('y_label', $this->y_data_label_angle,
|
|
|
6318 |
$this->plot_area[0] - $this->y_label_left_offset, $ypos,
|
|
|
6319 |
$this->ndx_datalabel_color, $ylab, 'right', 'center');
|
|
|
6320 |
|
|
|
6321 |
// Labels right of the plot area
|
|
|
6322 |
if ($this->y_data_label_pos == 'plotright' || $this->y_data_label_pos == 'both')
|
|
|
6323 |
$this->DrawText('y_label', $this->y_data_label_angle,
|
|
|
6324 |
$this->plot_area[2] + $this->y_label_right_offset, $ypos,
|
|
|
6325 |
$this->ndx_datalabel_color, $ylab, 'left', 'center');
|
|
|
6326 |
|
|
|
6327 |
if ($do_lines && $this->draw_y_data_label_lines)
|
|
|
6328 |
$this->DrawYDataLine($ypos, $row);
|
|
|
6329 |
return TRUE;
|
|
|
6330 |
}
|
|
|
6331 |
|
|
|
6332 |
/**
|
|
|
6333 |
* Draws vertical data label lines (used in vertical plots)
|
|
|
6334 |
*
|
|
|
6335 |
* This draws vertical lines from a data point up and/or down.
|
|
|
6336 |
* Which lines are drawn depends on the value of x_data_label_pos.
|
|
|
6337 |
* Whether this is done not depends on draw_x_data_label_lines.
|
|
|
6338 |
*
|
|
|
6339 |
* @param int $xpos X position in pixels of the line
|
|
|
6340 |
* @param int $row Index of the data row being drawn
|
|
|
6341 |
* @return bool True always
|
|
|
6342 |
*/
|
|
|
6343 |
protected function DrawXDataLine($xpos, $row)
|
|
|
6344 |
{
|
|
|
6345 |
// Set color for solid, or flag for dashed line:
|
|
|
6346 |
$style = $this->SetDashedStyle($this->ndx_light_grid_color, $this->dashed_grid);
|
|
|
6347 |
|
|
|
6348 |
if ($this->x_data_label_pos == 'both') {
|
|
|
6349 |
// Lines from the bottom up
|
|
|
6350 |
ImageLine($this->img, $xpos, $this->plot_area[3], $xpos, $this->plot_area[1], $style);
|
|
|
6351 |
} elseif ($this->x_data_label_pos == 'plotdown' && isset($this->data_max[$row])) {
|
|
|
6352 |
// Lines from the bottom of the plot up to the max Y value at this X:
|
|
|
6353 |
$ypos = $this->ytr($this->data_max[$row]);
|
|
|
6354 |
ImageLine($this->img, $xpos, $ypos, $xpos, $this->plot_area[3], $style);
|
|
|
6355 |
} elseif ($this->x_data_label_pos == 'plotup' && isset($this->data_min[$row])) {
|
|
|
6356 |
// Lines from the top of the plot down to the min Y value at this X:
|
|
|
6357 |
$ypos = $this->ytr($this->data_min[$row]);
|
|
|
6358 |
ImageLine($this->img, $xpos, $this->plot_area[1], $xpos, $ypos, $style);
|
|
|
6359 |
}
|
|
|
6360 |
return TRUE;
|
|
|
6361 |
}
|
|
|
6362 |
|
|
|
6363 |
/**
|
|
|
6364 |
* Draws horizontal data label lines (used in horizontal plots)
|
|
|
6365 |
*
|
|
|
6366 |
* This draws horizontal lines from a data points left and/or right.
|
|
|
6367 |
* Which lines are drawn depends on the value of y_data_label_pos.
|
|
|
6368 |
* Whether this is done not depends on draw_y_data_label_lines.
|
|
|
6369 |
*
|
|
|
6370 |
* @param int $ypos Y position in pixels of the line
|
|
|
6371 |
* @param int $row Index of the data row being drawn
|
|
|
6372 |
* @return bool True always
|
|
|
6373 |
* @since 6.0.0
|
|
|
6374 |
*/
|
|
|
6375 |
protected function DrawYDataLine($ypos, $row)
|
|
|
6376 |
{
|
|
|
6377 |
// Set color for solid, or flag for dashed line:
|
|
|
6378 |
$style = $this->SetDashedStyle($this->ndx_light_grid_color, $this->dashed_grid);
|
|
|
6379 |
|
|
|
6380 |
if ($this->y_data_label_pos == 'both') {
|
|
|
6381 |
// Lines from the left side to the right side
|
|
|
6382 |
ImageLine($this->img, $this->plot_area[0], $ypos, $this->plot_area[2], $ypos, $style);
|
|
|
6383 |
} elseif ($this->y_data_label_pos == 'plotleft' && isset($this->data_max[$row])) {
|
|
|
6384 |
// Lines from the left of the plot rightwards the max X value at this Y:
|
|
|
6385 |
$xpos = $this->xtr($this->data_max[$row]);
|
|
|
6386 |
ImageLine($this->img, $xpos, $ypos, $this->plot_area[0], $ypos, $style);
|
|
|
6387 |
} elseif ($this->y_data_label_pos == 'plotright' && isset($this->data_min[$row])) {
|
|
|
6388 |
// Lines from the right of the plot leftwards to the min X value at this Y:
|
|
|
6389 |
$xpos = $this->xtr($this->data_min[$row]);
|
|
|
6390 |
ImageLine($this->img, $this->plot_area[2], $ypos, $xpos, $ypos, $style);
|
|
|
6391 |
}
|
|
|
6392 |
return TRUE;
|
|
|
6393 |
}
|
|
|
6394 |
|
|
|
6395 |
/**
|
|
|
6396 |
* Formats a pie chart label
|
|
|
6397 |
*
|
|
|
6398 |
* @param int $index Pie slice number, starting with 0
|
|
|
6399 |
* @param string[] $pie_label_source Label formatting mode(s). See CheckPieLabels() and SetPieLabelType()
|
|
|
6400 |
* @param float $arc_angle Delta angle for this slice, in degrees
|
|
|
6401 |
* @param float $slice_weight Numeric value, or relative weight, of this slice
|
|
|
6402 |
* @return string The formatted label value
|
|
|
6403 |
* @since 5.6.0
|
|
|
6404 |
*/
|
|
|
6405 |
protected function FormatPieLabel($index, $pie_label_source, $arc_angle, $slice_weight)
|
|
|
6406 |
{
|
|
|
6407 |
$values = array(); // Builds up label value, one field at a time.
|
|
|
6408 |
foreach ($pie_label_source as $word) {
|
|
|
6409 |
switch ($word) {
|
|
|
6410 |
case 'label': // Use label from data array, but only if data type is compatible
|
|
|
6411 |
$values[] = $this->datatype_pie_single ? $this->data[$index][0] : '';
|
|
|
6412 |
break;
|
|
|
6413 |
case 'value': // Use actual numeric value of the slice
|
|
|
6414 |
$values[] = $slice_weight;
|
|
|
6415 |
break;
|
|
|
6416 |
case 'index': // Use slice index: 0, 1, 2...
|
|
|
6417 |
$values[] = $index;
|
|
|
6418 |
break;
|
|
|
6419 |
default: // Use percentage: 100% x arc_angle / (360 degrees) = arc_angle / 3.6
|
|
|
6420 |
$values[] = $arc_angle / 3.6;
|
|
|
6421 |
}
|
|
|
6422 |
}
|
|
|
6423 |
// Format the label and return the result. Note: The conditional avoids a number-to-string
|
|
|
6424 |
// conversion for the single-source case. This avoids a PHP issue with locale-based conversion.
|
|
|
6425 |
return $this->FormatLabel('p', count($values) == 1 ? $values[0] : implode(' ', $values));
|
|
|
6426 |
}
|
|
|
6427 |
|
|
|
6428 |
/**
|
|
|
6429 |
* Draws a pie chart label
|
|
|
6430 |
*
|
|
|
6431 |
* This draws a single label for a pie chart.
|
|
|
6432 |
*
|
|
|
6433 |
* The $r parameter array is calculated by DrawPieChart() and contains
|
|
|
6434 |
* values that are constant for the chart, so do not need to be
|
|
|
6435 |
* recalculated for each slice. Array keys are 'x' 'y' and 'reverse'.
|
|
|
6436 |
* r[x], r[y] are the parameters of the ellipse: ` x**2 / r[x]**2 + y**2 / r[y]**2 = 1 `
|
|
|
6437 |
* Also: ` x = r[x] * cos(angle) ` and ` y = r[y] * sin(angle) ` (relative to pie center).
|
|
|
6438 |
* 'reverse' is a flag for text alignment (see GetTextAlignment()).
|
|
|
6439 |
*
|
|
|
6440 |
* @param string $label_txt Pre-formatted label, from FormatPieLabel()
|
|
|
6441 |
* @param int $xc X device coordinate of the pie center
|
|
|
6442 |
* @param int $yc Y device coordinate of the pie center
|
|
|
6443 |
* @param float $start_angle Slice starting angle in degrees
|
|
|
6444 |
* @param float $arc_angle Slice angular width in degrees
|
|
|
6445 |
* @param mixed[] $r Additional paramter array (from DrawPieChart, see comment above)
|
|
|
6446 |
* @return bool True always
|
|
|
6447 |
* @since 5.6.0
|
|
|
6448 |
*/
|
|
|
6449 |
protected function DrawPieLabel($label_txt, $xc, $yc, $start_angle, $arc_angle, $r)
|
|
|
6450 |
{
|
|
|
6451 |
$mid_angle = deg2rad($start_angle + $arc_angle / 2);
|
|
|
6452 |
$sin_mid = sin($mid_angle);
|
|
|
6453 |
$cos_mid = cos($mid_angle);
|
|
|
6454 |
// Calculate label reference point.
|
|
|
6455 |
$label_x = $xc + $cos_mid * $r['x'];
|
|
|
6456 |
$label_y = $yc - $sin_mid * $r['y'];
|
|
|
6457 |
// For labels in the lower half, outside the pie, offset it to account for shading.
|
|
|
6458 |
// But don't shift labels just below the horizontal, because the shading is too thin there,
|
|
|
6459 |
// and the label ends up too far from the slice. Make a smooth transition between label offsets on
|
|
|
6460 |
// shaded area and above. (This isn't perfect at all, but works for reasonably low shading.)
|
|
|
6461 |
if ($this->label_scale_position >= 0.5 && $this->shading > 0 && $sin_mid < 0) {
|
|
|
6462 |
$yoff = min($this->shading, -$sin_mid * $r['y']);
|
|
|
6463 |
} else $yoff = 0;
|
|
|
6464 |
|
|
|
6465 |
// Calculate text alignment (h_align, v_align) based on angle:
|
|
|
6466 |
$this->GetTextAlignment($sin_mid, $cos_mid, $h_align, $v_align, $r['reverse']);
|
|
|
6467 |
// Draw the label:
|
|
|
6468 |
$this->DrawText('generic', 0, $label_x, $label_y + $yoff, $this->ndx_pielabel_color,
|
|
|
6469 |
$label_txt, $h_align, $v_align);
|
|
|
6470 |
return TRUE;
|
|
|
6471 |
}
|
|
|
6472 |
|
|
|
6473 |
/////////////////////////////////////////////
|
|
|
6474 |
/////////////// LEGEND
|
|
|
6475 |
/////////////////////////////////////////////
|
|
|
6476 |
|
|
|
6477 |
/**
|
|
|
6478 |
* Adds text to a legend box
|
|
|
6479 |
*
|
|
|
6480 |
* The legend can be set up with a single call by passing an array of
|
|
|
6481 |
* strings (1 string per legend line/data set), or it can be built up
|
|
|
6482 |
* one line at a time with repeated calls passing a single string.
|
|
|
6483 |
* NULL (or an empty array) can be passed to cancel the legend.
|
|
|
6484 |
*
|
|
|
6485 |
* @param string|string[] $which_leg Array of strings for the legend, or a single string to append
|
|
|
6486 |
* @return bool True always
|
|
|
6487 |
*/
|
|
|
6488 |
function SetLegend($which_leg)
|
|
|
6489 |
{
|
|
|
6490 |
if (is_array($which_leg)) { // use array (or cancel, if empty array)
|
|
|
6491 |
$this->legend = $which_leg;
|
|
|
6492 |
} elseif (!is_null($which_leg)) { // append string
|
|
|
6493 |
if (!isset($this->legend)) $this->legend = array(); // Seems unnecessary, but be safe.
|
|
|
6494 |
$this->legend[] = $which_leg;
|
|
|
6495 |
} else {
|
|
|
6496 |
$this->legend = NULL; // Reset to no legend.
|
|
|
6497 |
}
|
|
|
6498 |
return TRUE;
|
|
|
6499 |
}
|
|
|
6500 |
|
|
|
6501 |
/**
|
|
|
6502 |
* Positions the legend on the image, using device coordinates
|
|
|
6503 |
*
|
|
|
6504 |
* @param int $which_x X coordinate in pixels of the upper left corner of the legend box
|
|
|
6505 |
* @param int $which_y Y coordinate in pixels of the upper left corner of the legend box
|
|
|
6506 |
* @return bool True (False on error if an error handler returns True)
|
|
|
6507 |
*/
|
|
|
6508 |
function SetLegendPixels($which_x=NULL, $which_y=NULL)
|
|
|
6509 |
{
|
|
|
6510 |
return $this->SetLegendPosition(0, 0, 'image', 0, 0, $which_x, $which_y);
|
|
|
6511 |
}
|
|
|
6512 |
|
|
|
6513 |
/**
|
|
|
6514 |
* Positions the legend on the image, using world coordinates
|
|
|
6515 |
*
|
|
|
6516 |
* @param int $which_x World coordinate X of the upper left corner of the legend box
|
|
|
6517 |
* @param int $which_y World coordinate Y of the upper left corner of the legend box
|
|
|
6518 |
* @return bool True (False on error if an error handler returns True)
|
|
|
6519 |
*/
|
|
|
6520 |
function SetLegendWorld($which_x, $which_y)
|
|
|
6521 |
{
|
|
|
6522 |
return $this->SetLegendPosition(0, 0, 'world', $which_x, $which_y);
|
|
|
6523 |
}
|
|
|
6524 |
|
|
|
6525 |
/**
|
|
|
6526 |
* Positions the legend
|
|
|
6527 |
*
|
|
|
6528 |
* This implements SetLegendWorld(), SetLegendPixels(), and also allows use
|
|
|
6529 |
* of relative coordinates, with optional pixel offset.
|
|
|
6530 |
*
|
|
|
6531 |
* 'Relative coordinates' means: (0,0) is the upper left corner, and (1,1)
|
|
|
6532 |
* is the lower right corner of the element (legend, image, plot, or title
|
|
|
6533 |
* area), regardless of its size. These are floating point values, each
|
|
|
6534 |
* usually in the range [0,1], but they can be negative or greater than 1.
|
|
|
6535 |
*
|
|
|
6536 |
* If any of x, y, x_offset, or y_offset are NULL, the default legend
|
|
|
6537 |
* positioning is restored.
|
|
|
6538 |
*
|
|
|
6539 |
* Note: This only stores the parameters. The real work is in GetLegendPosition().
|
|
|
6540 |
*
|
|
|
6541 |
* @param float $x Relative coordinate X indicating an anchor point on the legend box
|
|
|
6542 |
* @param float $y Relative coordinate X indicating an anchor point on the legend box
|
|
|
6543 |
* @param string $relative_to Position is relative to: image | plot | world | title
|
|
|
6544 |
* @param float $x_base Base point X for positioning to the anchor point
|
|
|
6545 |
* @param float $y_base Base point Y for positioning to the anchor point
|
|
|
6546 |
* @param int $x_offset Additional legend box offset X value in pixels
|
|
|
6547 |
* @param int $y_offset Additional legend box offset Y value in pixels
|
|
|
6548 |
* @return bool True (False on error if an error handler returns True)
|
|
|
6549 |
* @since 5.4.0
|
|
|
6550 |
*/
|
|
|
6551 |
function SetLegendPosition($x, $y, $relative_to, $x_base, $y_base, $x_offset = 0, $y_offset = 0)
|
|
|
6552 |
{
|
|
|
6553 |
// Special case: NULL means restore the default positioning.
|
|
|
6554 |
if (!isset($x, $y, $x_offset, $y_offset)) {
|
|
|
6555 |
$this->legend_pos = NULL;
|
|
|
6556 |
} else {
|
|
|
6557 |
$mode = $this->CheckOption($relative_to, 'image, plot, title, world', __FUNCTION__);
|
|
|
6558 |
if (empty($mode))
|
|
|
6559 |
return FALSE;
|
|
|
6560 |
// Save all values for use by GetLegendPosition()
|
|
|
6561 |
$this->legend_pos = compact('x', 'y', 'mode', 'x_base', 'y_base', 'x_offset', 'y_offset');
|
|
|
6562 |
}
|
|
|
6563 |
return TRUE;
|
|
|
6564 |
}
|
|
|
6565 |
|
|
|
6566 |
/**
|
|
|
6567 |
* Controls the appearance of the legend
|
|
|
6568 |
*
|
|
|
6569 |
* @param string $text_align How to align the text in the legend: left | right
|
|
|
6570 |
* @param string $colorbox_align How to align the color boxes or shape markers: left | right | none | ''
|
|
|
6571 |
* @return bool True (False on error if an error handler returns True)
|
|
|
6572 |
* @since 5.0.4
|
|
|
6573 |
*/
|
|
|
6574 |
function SetLegendStyle($text_align, $colorbox_align = '')
|
|
|
6575 |
{
|
|
|
6576 |
$this->legend_text_align = $this->CheckOption($text_align, 'left, right', __FUNCTION__);
|
|
|
6577 |
if (empty($colorbox_align))
|
|
|
6578 |
$this->legend_colorbox_align = $this->legend_text_align;
|
|
|
6579 |
else
|
|
|
6580 |
$this->legend_colorbox_align = $this->CheckOption($colorbox_align, 'left, right, none',
|
|
|
6581 |
__FUNCTION__);
|
|
|
6582 |
return ($this->legend_text_align && $this->legend_colorbox_align);
|
|
|
6583 |
}
|
|
|
6584 |
|
|
|
6585 |
/**
|
|
|
6586 |
* Selects use of color boxes or alternative shapes (point shapes or line segments) in the legend
|
|
|
6587 |
*
|
|
|
6588 |
* @param bool $use_shapes True to use shapes or lines, false to use color boxes
|
|
|
6589 |
* @return bool True always
|
|
|
6590 |
* @since 5.4.0
|
|
|
6591 |
*/
|
|
|
6592 |
function SetLegendUseShapes($use_shapes)
|
|
|
6593 |
{
|
|
|
6594 |
$this->legend_use_shapes = (bool)$use_shapes;
|
|
|
6595 |
return TRUE;
|
|
|
6596 |
}
|
|
|
6597 |
|
|
|
6598 |
/**
|
|
|
6599 |
* Controls the order of text lines in the legend (e.g. for Stackedbar plots)
|
|
|
6600 |
*
|
|
|
6601 |
* @param bool $reversal True to reverse the order - bottom up; False for default top down
|
|
|
6602 |
* @return bool True always
|
|
|
6603 |
* @since 5.5.0
|
|
|
6604 |
*/
|
|
|
6605 |
function SetLegendReverse($reversal = False)
|
|
|
6606 |
{
|
|
|
6607 |
$this->legend_reverse_order = (bool)$reversal;
|
|
|
6608 |
return TRUE;
|
|
|
6609 |
}
|
|
|
6610 |
|
|
|
6611 |
/**
|
|
|
6612 |
* Controls the borders around the color boxes in the legend
|
|
|
6613 |
*
|
|
|
6614 |
* @param string $cbbmode Color box mode: none | textcolor | databordercolor
|
|
|
6615 |
* @return bool True (False on error if an error handler returns True)
|
|
|
6616 |
* @since 6.0.0
|
|
|
6617 |
*/
|
|
|
6618 |
function SetLegendColorboxBorders($cbbmode = 'textcolor')
|
|
|
6619 |
{
|
|
|
6620 |
$this->legend_colorbox_borders = $this->CheckOption($cbbmode, 'none, textcolor, databordercolor',
|
|
|
6621 |
__FUNCTION__);
|
|
|
6622 |
return (boolean)$this->legend_colorbox_borders;
|
|
|
6623 |
}
|
|
|
6624 |
|
|
|
6625 |
/**
|
|
|
6626 |
* Calculates legend sizing parameters
|
|
|
6627 |
*
|
|
|
6628 |
* Used by DrawLegend() and the public GetLegendSize().
|
|
|
6629 |
* It returns information based on any SetLegend*() calls already made. It does not use
|
|
|
6630 |
* legend position or data scaling, so it can be called before data scaling is set up.
|
|
|
6631 |
* It must not be called if $this->legend is empty.
|
|
|
6632 |
*
|
|
|
6633 |
* Returns an associative array with these entries describing legend sizing:
|
|
|
6634 |
* 'width', 'height' : Overall legend box size in pixels.
|
|
|
6635 |
* 'char_w', 'char_h' : Width and height of 'E' in legend text font. (Used to size color boxes)
|
|
|
6636 |
* 'v_margin' : Inside margin for legend
|
|
|
6637 |
* 'dot_height' : Height of color boxes (even if not drawn), for line spacing.
|
|
|
6638 |
* 'colorbox_mode', 'colorbox_width' : Colorbox/shape mode and width factor.
|
|
|
6639 |
*
|
|
|
6640 |
* @return array Legend sizing parameter associative array
|
|
|
6641 |
* @since 5.4.0
|
|
|
6642 |
*/
|
|
|
6643 |
protected function GetLegendSizeParams()
|
|
|
6644 |
{
|
|
|
6645 |
$font = &$this->fonts['legend']; // Shortcut to font info array
|
|
|
6646 |
|
|
|
6647 |
// Find maximum legend label line width.
|
|
|
6648 |
$max_width = 0;
|
|
|
6649 |
foreach ($this->legend as $line) {
|
|
|
6650 |
list($width, $unused) = $this->SizeText('legend', 0, $line);
|
|
|
6651 |
if ($width > $max_width) $max_width = $width;
|
|
|
6652 |
}
|
|
|
6653 |
|
|
|
6654 |
// Font parameters are used to size the color boxes:
|
|
|
6655 |
$char_w = $font['width'];
|
|
|
6656 |
$char_h = $font['height'];
|
|
|
6657 |
$line_spacing = $this->GetLineSpacing($font);
|
|
|
6658 |
|
|
|
6659 |
// Get color-box mode. Note GetLegendSizeParams can be called from GetLegendSize, and not all
|
|
|
6660 |
// settings are defined then, but the colorbox_mode won't be used then so it need not be valid.
|
|
|
6661 |
if ($this->legend_colorbox_align == 'none') {
|
|
|
6662 |
$colorbox_mode = False; // Color boxes are off
|
|
|
6663 |
} elseif (!$this->legend_use_shapes || empty(self::$plots[$this->plot_type]['legend_alt_marker'])) {
|
|
|
6664 |
$colorbox_mode = 'box'; // Not using shapes, or plot type defines no shape, so use boxes.
|
|
|
6665 |
} else {
|
|
|
6666 |
$colorbox_mode = self::$plots[$this->plot_type]['legend_alt_marker']; // Shape from plot type
|
|
|
6667 |
}
|
|
|
6668 |
|
|
|
6669 |
// Sizing parameters:
|
|
|
6670 |
$v_margin = $char_h / 2; // Between vertical borders and labels
|
|
|
6671 |
$dot_height = $char_h + $line_spacing; // Height of the color boxes (even if not drawn)
|
|
|
6672 |
$colorbox_width = $char_w * $this->legend_colorbox_width; // Color box width, with adjustment
|
|
|
6673 |
|
|
|
6674 |
// The 'line' style marker needs a wider colorbox than shape or box.
|
|
|
6675 |
if ($colorbox_mode == 'line')
|
|
|
6676 |
$colorbox_width *= 4;
|
|
|
6677 |
|
|
|
6678 |
// Calculate overall legend box width and height.
|
|
|
6679 |
// Width is e.g.: "| space colorbox space text space |" where each space adds $char_w,
|
|
|
6680 |
// and colorbox (if drawn) adds $char_w * its width adjustment.
|
|
|
6681 |
if ($colorbox_mode) {
|
|
|
6682 |
$width = $max_width + 3 * $char_w + $colorbox_width;
|
|
|
6683 |
} else {
|
|
|
6684 |
$width = $max_width + 2 * $char_w;
|
|
|
6685 |
}
|
|
|
6686 |
$height = $dot_height * count($this->legend) + 2 * $v_margin;
|
|
|
6687 |
|
|
|
6688 |
return compact('width', 'height', 'char_w', 'char_h', 'v_margin',
|
|
|
6689 |
'colorbox_mode', 'dot_height', 'colorbox_width');
|
|
|
6690 |
}
|
|
|
6691 |
|
|
|
6692 |
/**
|
|
|
6693 |
* Gets the legend box size (can be used to adjust the plot margins, for example)
|
|
|
6694 |
*
|
|
|
6695 |
* @return int[] Legend box size as array of (width, height) in pixels, False if no legend defined.
|
|
|
6696 |
* @since 5.4.0
|
|
|
6697 |
*/
|
|
|
6698 |
function GetLegendSize()
|
|
|
6699 |
{
|
|
|
6700 |
if (empty($this->legend))
|
|
|
6701 |
return FALSE;
|
|
|
6702 |
$params = $this->GetLegendSizeParams();
|
|
|
6703 |
return array($params['width'], $params['height']);
|
|
|
6704 |
}
|
|
|
6705 |
|
|
|
6706 |
/**
|
|
|
6707 |
* Calculates the legend location in device coordinates
|
|
|
6708 |
*
|
|
|
6709 |
* This is a helper for DrawLegend, and is only called if there is a legend.
|
|
|
6710 |
* See SetLegendWorld(), SetLegendPixels(), SetLegendPosition().
|
|
|
6711 |
*
|
|
|
6712 |
* @param int $width Width of the legend box
|
|
|
6713 |
* @param int $height Height of the legend box
|
|
|
6714 |
* @return int[] Coordinates of the upper left corner of the legend box as an array ($x, $y)
|
|
|
6715 |
* @since 5.4.0
|
|
|
6716 |
*/
|
|
|
6717 |
protected function GetLegendPosition($width, $height)
|
|
|
6718 |
{
|
|
|
6719 |
// Extract variables set by SetLegend*(): $mode, $x, $y, $x_base, $y_base, $x_offset, $y_offset
|
|
|
6720 |
if (isset($this->legend_pos['mode']))
|
|
|
6721 |
extract($this->legend_pos);
|
|
|
6722 |
else
|
|
|
6723 |
$mode = ''; // Default legend position mode.
|
|
|
6724 |
|
|
|
6725 |
switch ($mode) {
|
|
|
6726 |
|
|
|
6727 |
case 'plot': // SetLegendPosition with mode='plot', relative coordinates over plot area.
|
|
|
6728 |
return array((int)($x_base * $this->plot_area_width - $x * $width)
|
|
|
6729 |
+ $this->plot_area[0] + $x_offset,
|
|
|
6730 |
(int)($y_base * $this->plot_area_height - $y * $height)
|
|
|
6731 |
+ $this->plot_area[1] + $y_offset);
|
|
|
6732 |
|
|
|
6733 |
case 'world': // User-defined position in world-coordinates (SetLegendWorld), using x_base, y_base
|
|
|
6734 |
return array($this->xtr($x_base) + $x_offset - (int)($x * $width),
|
|
|
6735 |
$this->ytr($y_base) + $y_offset - (int)($y * $height));
|
|
|
6736 |
|
|
|
6737 |
case 'image': // SetLegendPosition with mode='image', relative coordinates over image area.
|
|
|
6738 |
// SetLegendPixels() uses this too, with x=y=0.
|
|
|
6739 |
return array((int)($x_base * $this->image_width - $x * $width) + $x_offset,
|
|
|
6740 |
(int)($y_base * $this->image_height - $y * $height) + $y_offset);
|
|
|
6741 |
|
|
|
6742 |
case 'title': // SetLegendPosition with mode='title', relative to main title.
|
|
|
6743 |
// Recalculate main title position/size, since CalcMargins does not save it. See DrawTitle()
|
|
|
6744 |
list($title_width, $title_height) = $this->SizeText('title', 0, $this->title_txt);
|
|
|
6745 |
$title_x = (int)(($this->image_width - $title_width) / 2);
|
|
|
6746 |
return array((int)($x_base * $title_width - $x * $width) + $title_x + $x_offset,
|
|
|
6747 |
(int)($y_base * $title_height - $y * $height) + $this->title_offset + $y_offset);
|
|
|
6748 |
|
|
|
6749 |
default: // If mode is unset (or invalid), use default position.
|
|
|
6750 |
return array ($this->plot_area[2] - $width - $this->safe_margin,
|
|
|
6751 |
$this->plot_area[1] + $this->safe_margin);
|
|
|
6752 |
}
|
|
|
6753 |
}
|
|
|
6754 |
|
|
|
6755 |
/**
|
|
|
6756 |
* Draws the plot legend - the outline box, text labels, and color boxes or shapes
|
|
|
6757 |
*
|
|
|
6758 |
* @return bool True always
|
|
|
6759 |
*/
|
|
|
6760 |
protected function DrawLegend()
|
|
|
6761 |
{
|
|
|
6762 |
// Calculate legend box sizing parameters:
|
|
|
6763 |
// See GetLegendSizeParams() to see what variables are set by this.
|
|
|
6764 |
extract($this->GetLegendSizeParams());
|
|
|
6765 |
|
|
|
6766 |
// Get legend box position:
|
|
|
6767 |
list($box_start_x, $box_start_y) = $this->GetLegendPosition($width, $height);
|
|
|
6768 |
$box_end_y = $box_start_y + $height;
|
|
|
6769 |
$box_end_x = $box_start_x + $width;
|
|
|
6770 |
|
|
|
6771 |
// Draw outer box
|
|
|
6772 |
ImageFilledRectangle($this->img, $box_start_x, $box_start_y, $box_end_x, $box_end_y,
|
|
|
6773 |
$this->ndx_legend_bg_color);
|
|
|
6774 |
ImageRectangle($this->img, $box_start_x, $box_start_y, $box_end_x, $box_end_y,
|
|
|
6775 |
$this->ndx_grid_color);
|
|
|
6776 |
|
|
|
6777 |
// Calculate color box and text horizontal positions.
|
|
|
6778 |
if (!$colorbox_mode) {
|
|
|
6779 |
if ($this->legend_text_align == 'left')
|
|
|
6780 |
$x_pos = $box_start_x + $char_w;
|
|
|
6781 |
else
|
|
|
6782 |
$x_pos = $box_end_x - $char_w;
|
|
|
6783 |
$dot_left_x = 0; // Not used directly if color boxes/shapes are off, but referenced below.
|
|
|
6784 |
} elseif ($this->legend_colorbox_align == 'left') {
|
|
|
6785 |
$dot_left_x = $box_start_x + $char_w;
|
|
|
6786 |
$dot_right_x = $dot_left_x + $colorbox_width;
|
|
|
6787 |
if ($this->legend_text_align == 'left')
|
|
|
6788 |
$x_pos = $dot_right_x + $char_w;
|
|
|
6789 |
else
|
|
|
6790 |
$x_pos = $box_end_x - $char_w;
|
|
|
6791 |
} else { // colorbox_align == 'right'
|
|
|
6792 |
$dot_right_x = $box_end_x - $char_w;
|
|
|
6793 |
$dot_left_x = $dot_right_x - $colorbox_width;
|
|
|
6794 |
if ($this->legend_text_align == 'left')
|
|
|
6795 |
$x_pos = $box_start_x + $char_w;
|
|
|
6796 |
else
|
|
|
6797 |
$x_pos = $dot_left_x - $char_w;
|
|
|
6798 |
}
|
|
|
6799 |
|
|
|
6800 |
// $y_pos is the bottom of each color box. $yc is the vertical center of the color box or
|
|
|
6801 |
// the point shape (if drawn). The text is centered vertically on $yc.
|
|
|
6802 |
// For normal order (top-down), $y_pos starts at the top. For reversed order, at the bottom.
|
|
|
6803 |
if ($this->legend_reverse_order) {
|
|
|
6804 |
$y_pos = $box_end_y - $v_margin;
|
|
|
6805 |
$delta_y = -$dot_height;
|
|
|
6806 |
} else {
|
|
|
6807 |
$y_pos = $box_start_y + $v_margin + $dot_height;
|
|
|
6808 |
$delta_y = $dot_height;
|
|
|
6809 |
}
|
|
|
6810 |
$yc = (int)($y_pos - $dot_height / 2);
|
|
|
6811 |
$xc = (int)($dot_left_x + $colorbox_width / 2); // Horizontal center for point shape if drawn
|
|
|
6812 |
|
|
|
6813 |
// Colorbox color index, shape index, and line width/style index variables.
|
|
|
6814 |
// Note the arrays these are used to index have been padded to data_columns entries. The legend
|
|
|
6815 |
// can contain more than data_columns entries, though, but it only makes sense to be able
|
|
|
6816 |
// to index additional entries for the data color, due to the data_color callback.
|
|
|
6817 |
if ($colorbox_mode) {
|
|
|
6818 |
$color_index = 0;
|
|
|
6819 |
$max_color_index = count($this->ndx_data_colors) - 1;
|
|
|
6820 |
$lws_index = 0; // Line Width and Style index
|
|
|
6821 |
$shape_index = 0;
|
|
|
6822 |
}
|
|
|
6823 |
|
|
|
6824 |
foreach ($this->legend as $leg) {
|
|
|
6825 |
// Draw text with requested alignment:
|
|
|
6826 |
$this->DrawText('legend', 0, $x_pos, $yc, $this->ndx_legend_text_color, $leg,
|
|
|
6827 |
$this->legend_text_align, 'center');
|
|
|
6828 |
if ($colorbox_mode) {
|
|
|
6829 |
$y1 = $y_pos - $dot_height + 1;
|
|
|
6830 |
$y2 = $y_pos - 1;
|
|
|
6831 |
|
|
|
6832 |
// If plot area background is on, draw a background for any non-box shapes:
|
|
|
6833 |
if ($this->draw_plot_area_background && $colorbox_mode != 'box') {
|
|
|
6834 |
ImageFilledRectangle($this->img, $dot_left_x, $y1, $dot_right_x, $y2,
|
|
|
6835 |
$this->ndx_plot_bg_color);
|
|
|
6836 |
}
|
|
|
6837 |
|
|
|
6838 |
switch ($colorbox_mode) {
|
|
|
6839 |
case 'shape':
|
|
|
6840 |
// Draw the shape. DrawShape() takes shape_index modulo number of defined shapes.
|
|
|
6841 |
$this->DrawShape($xc, $yc, $shape_index++, $this->ndx_data_colors[$color_index], FALSE);
|
|
|
6842 |
break;
|
|
|
6843 |
|
|
|
6844 |
case 'line':
|
|
|
6845 |
// Draw a short line segment with proper color, width, and style
|
|
|
6846 |
imagesetthickness($this->img, $this->line_widths[$lws_index]);
|
|
|
6847 |
$style = $this->SetDashedStyle($this->ndx_data_colors[$color_index],
|
|
|
6848 |
$this->line_styles[$lws_index] == 'dashed');
|
|
|
6849 |
imageline($this->img, $dot_left_x, $yc, $dot_right_x, $yc, $style);
|
|
|
6850 |
imagesetthickness($this->img, 1);
|
|
|
6851 |
if (++$lws_index >= $this->data_columns) $lws_index = 0; // Wrap around
|
|
|
6852 |
break;
|
|
|
6853 |
|
|
|
6854 |
default:
|
|
|
6855 |
// Draw color boxes:
|
|
|
6856 |
ImageFilledRectangle($this->img, $dot_left_x, $y1, $dot_right_x, $y2,
|
|
|
6857 |
$this->ndx_data_colors[$color_index]);
|
|
|
6858 |
// Draw a rectangle around the box, if enabled.
|
|
|
6859 |
if ($this->legend_colorbox_borders != 'none') {
|
|
|
6860 |
if ($this->legend_colorbox_borders == 'databordercolor')
|
|
|
6861 |
$color = $this->ndx_data_border_colors[$color_index];
|
|
|
6862 |
else
|
|
|
6863 |
$color = $this->ndx_text_color;
|
|
|
6864 |
ImageRectangle($this->img, $dot_left_x, $y1, $dot_right_x, $y2, $color);
|
|
|
6865 |
}
|
|
|
6866 |
}
|
|
|
6867 |
if (++$color_index > $max_color_index) $color_index = 0;
|
|
|
6868 |
}
|
|
|
6869 |
$y_pos += $delta_y;
|
|
|
6870 |
$yc += $delta_y;
|
|
|
6871 |
}
|
|
|
6872 |
return TRUE;
|
|
|
6873 |
}
|
|
|
6874 |
|
|
|
6875 |
/////////////////////////////////////////////
|
|
|
6876 |
//////////////////// PLOT DRAWING HELPERS
|
|
|
6877 |
/////////////////////////////////////////////
|
|
|
6878 |
|
|
|
6879 |
/**
|
|
|
6880 |
* Gets the color index to use for plotting a data element (point or line segment, for example)
|
|
|
6881 |
*
|
|
|
6882 |
* This is used to select data colors for plotting. Without a custom data
|
|
|
6883 |
* color callback, color selection is based on $idx, the column index in
|
|
|
6884 |
* the data array. So the first data set (Y) uses the first color, etc.
|
|
|
6885 |
* With a custom data color callback, both row and column index values
|
|
|
6886 |
* are passed to the callback so it can use them to select a color.
|
|
|
6887 |
*
|
|
|
6888 |
* @param int $row Row index for the current data point (used only for a custom data color callback)
|
|
|
6889 |
* @param int $idx Column index for the current data point (e.g. 0 for the first Y value for each X)
|
|
|
6890 |
* @param mixed[] $vars Reference variable, array for local storage (caller makes an empty array)
|
|
|
6891 |
* @param int $data_color Reference variable: returned color index to use for drawing
|
|
|
6892 |
* @param mixed $extra Extra variable passed through to a data color callback
|
|
|
6893 |
* @since 5.2.0
|
|
|
6894 |
*/
|
|
|
6895 |
protected function GetDataColor($row, $idx, &$vars, &$data_color, $extra = 0)
|
|
|
6896 |
{
|
|
|
6897 |
// Initialize or extract variables:
|
|
|
6898 |
if (empty($vars)) {
|
|
|
6899 |
$custom_color = (bool)$this->GetCallback('data_color');
|
|
|
6900 |
$num_data_colors = count($this->ndx_data_colors);
|
|
|
6901 |
$vars = compact('custom_color', 'num_data_colors');
|
|
|
6902 |
} else {
|
|
|
6903 |
extract($vars);
|
|
|
6904 |
}
|
|
|
6905 |
|
|
|
6906 |
// Select the data color:
|
|
|
6907 |
if ($custom_color) {
|
|
|
6908 |
$idx = $this->DoCallback('data_color', $row, $idx, $extra) % $num_data_colors;
|
|
|
6909 |
}
|
|
|
6910 |
$data_color = $this->ndx_data_colors[$idx];
|
|
|
6911 |
}
|
|
|
6912 |
|
|
|
6913 |
/**
|
|
|
6914 |
* Gets the color indexes to use for data element and error bar plotting
|
|
|
6915 |
*
|
|
|
6916 |
* @param int $row Row index for the current data point (used only for a custom data color callback)
|
|
|
6917 |
* @param int $idx Column index for the current data point (e.g. 0 for the first Y value for each X)
|
|
|
6918 |
* @param mixed[] $vars Reference variable, array for local storage (caller makes an empty array)
|
|
|
6919 |
* @param int $data_color Reference variable: returned color index to use for drawing
|
|
|
6920 |
* @param int error_color Reference variable: returned color index to use for the error bars
|
|
|
6921 |
* @param mixed $extra Extra variable passed through to a data color callback
|
|
|
6922 |
* @since 5.2.0
|
|
|
6923 |
*/
|
|
|
6924 |
protected function GetDataErrorColors($row, $idx, &$vars, &$data_color, &$error_color, $extra = 0)
|
|
|
6925 |
{
|
|
|
6926 |
// Initialize or extract variables:
|
|
|
6927 |
if (empty($vars)) {
|
|
|
6928 |
$this->NeedErrorBarColors(); // This plot needs error bar colors.
|
|
|
6929 |
$custom_color = (bool)$this->GetCallback('data_color');
|
|
|
6930 |
$num_data_colors = count($this->ndx_data_colors);
|
|
|
6931 |
$num_error_colors = count($this->ndx_error_bar_colors);
|
|
|
6932 |
$vars = compact('custom_color', 'num_data_colors', 'num_error_colors');
|
|
|
6933 |
} else {
|
|
|
6934 |
extract($vars);
|
|
|
6935 |
}
|
|
|
6936 |
|
|
|
6937 |
// Select the colors.
|
|
|
6938 |
if ($custom_color) {
|
|
|
6939 |
$col_i = $this->DoCallback('data_color', $row, $idx, $extra); // Custom color index
|
|
|
6940 |
$data_color = $this->ndx_data_colors[$col_i % $num_data_colors];
|
|
|
6941 |
$error_color = $this->ndx_error_bar_colors[$col_i % $num_error_colors];
|
|
|
6942 |
} else {
|
|
|
6943 |
$data_color = $this->ndx_data_colors[$idx];
|
|
|
6944 |
$error_color = $this->ndx_error_bar_colors[$idx];
|
|
|
6945 |
}
|
|
|
6946 |
}
|
|
|
6947 |
|
|
|
6948 |
/**
|
|
|
6949 |
* Gets the color indexes to use for a bar chart (data color, border color, shading color)
|
|
|
6950 |
*
|
|
|
6951 |
* @param int $row Row index for the current data point (used only for a custom data color callback)
|
|
|
6952 |
* @param int $idx Column index for the current data point (e.g. 0 for the first Y value for each X)
|
|
|
6953 |
* @param mixed[] $vars Reference variable, array for local storage (caller makes an empty array)
|
|
|
6954 |
* @param int $data_color Returned color index to use for the bar fill
|
|
|
6955 |
* @param int $shade_color Returned color index for the shading, NULL if shading is off
|
|
|
6956 |
* @param int $border_color Returned color index for the bar borders, NULL if borders are off
|
|
|
6957 |
* @since 5.2.0
|
|
|
6958 |
*/
|
|
|
6959 |
protected function GetBarColors($row, $idx, &$vars, &$data_color, &$shade_color, &$border_color)
|
|
|
6960 |
{
|
|
|
6961 |
// Initialize or extract this functions persistant state variables:
|
|
|
6962 |
if (empty($vars)) {
|
|
|
6963 |
if (($shaded = ($this->shading > 0)))
|
|
|
6964 |
$this->NeedDataDarkColors(); // Plot needs dark colors for shading
|
|
|
6965 |
$custom_color = (bool)$this->GetCallback('data_color');
|
|
|
6966 |
$num_data_colors = count($this->ndx_data_colors);
|
|
|
6967 |
$num_border_colors = count($this->ndx_data_border_colors);
|
|
|
6968 |
// Are borders enabled? Default is true for unshaded plots, false for shaded.
|
|
|
6969 |
$borders = isset($this->draw_data_borders) ? $this->draw_data_borders : !$shaded;
|
|
|
6970 |
|
|
|
6971 |
$vars = compact('borders', 'custom_color', 'num_data_colors', 'num_border_colors', 'shaded');
|
|
|
6972 |
} else {
|
|
|
6973 |
extract($vars);
|
|
|
6974 |
}
|
|
|
6975 |
|
|
|
6976 |
// Select the colors.
|
|
|
6977 |
if ($custom_color) {
|
|
|
6978 |
$col_i = $this->DoCallback('data_color', $row, $idx); // Custom color index
|
|
|
6979 |
$i_data = $col_i % $num_data_colors; // Index for data colors and dark colors
|
|
|
6980 |
$i_border = $col_i % $num_border_colors; // Index for data borders (if used)
|
|
|
6981 |
} else {
|
|
|
6982 |
$i_data = $i_border = $idx;
|
|
|
6983 |
}
|
|
|
6984 |
$data_color = $this->ndx_data_colors[$i_data];
|
|
|
6985 |
$shade_color = $shaded ? $this->ndx_data_dark_colors[$i_data] : NULL;
|
|
|
6986 |
$border_color = $borders ? $this->ndx_data_border_colors[$i_border] : NULL;
|
|
|
6987 |
}
|
|
|
6988 |
|
|
|
6989 |
/**
|
|
|
6990 |
* Gets the grid setting, on or off
|
|
|
6991 |
*
|
|
|
6992 |
* This function determines the dynamic defaults. The grid defaults on for
|
|
|
6993 |
* the dependent variable, off for the independent variable.
|
|
|
6994 |
*
|
|
|
6995 |
* @param string $xy Which grid to check for: x | y
|
|
|
6996 |
* @return bool True if the grid should be drawn, False if it should not be drawn
|
|
|
6997 |
* @since 6.0.0
|
|
|
6998 |
*/
|
|
|
6999 |
protected function GetGridSetting($xy)
|
|
|
7000 |
{
|
|
|
7001 |
if ($xy == 'x')
|
|
|
7002 |
return isset($this->draw_x_grid) ? $this->draw_x_grid : $this->datatype_swapped_xy;
|
|
|
7003 |
// Assumed 'y'
|
|
|
7004 |
return isset($this->draw_y_grid) ? $this->draw_y_grid : !$this->datatype_swapped_xy;
|
|
|
7005 |
}
|
|
|
7006 |
|
|
|
7007 |
/**
|
|
|
7008 |
* Draws a single marker shape (a dot or shape)
|
|
|
7009 |
*
|
|
|
7010 |
* This is used by points and linepoints plots to draw a point, and by the
|
|
|
7011 |
* legend. Also see SetPointShapes() for the list of supported shapes.
|
|
|
7012 |
*
|
|
|
7013 |
* @param int $x X device coordinate of the center of the shape
|
|
|
7014 |
* @param int $y Y device coordinate of the center of the shape
|
|
|
7015 |
* @param int $record Index into point_shapes[] and point_sizes[] arrays (taken modulo their sizes)
|
|
|
7016 |
* @param int $color Color index to use for the point shape
|
|
|
7017 |
* @param bool $allow_none True or omit allow 'none' as shape, False to substitute (for legend)
|
|
|
7018 |
* @return bool True always
|
|
|
7019 |
* @since 5.4.0
|
|
|
7020 |
*/
|
|
|
7021 |
protected function DrawShape($x, $y, $record, $color, $allow_none = TRUE)
|
|
|
7022 |
{
|
|
|
7023 |
$index = $record % $this->point_counts;
|
|
|
7024 |
$point_size = $this->point_sizes[$index];
|
|
|
7025 |
$half_point = (int)($point_size / 2);
|
|
|
7026 |
|
|
|
7027 |
$x1 = $x - $half_point;
|
|
|
7028 |
$x2 = $x + $half_point;
|
|
|
7029 |
$y1 = $y - $half_point;
|
|
|
7030 |
$y2 = $y + $half_point;
|
|
|
7031 |
|
|
|
7032 |
switch ($this->point_shapes[$index]) {
|
|
|
7033 |
case 'halfline':
|
|
|
7034 |
ImageLine($this->img, $x1, $y, $x, $y, $color);
|
|
|
7035 |
break;
|
|
|
7036 |
case 'none': /* Special case, no point shape here */
|
|
|
7037 |
if ($allow_none) break; // But fall throught to line if a shape is required
|
|
|
7038 |
case 'line':
|
|
|
7039 |
ImageLine($this->img, $x1, $y, $x2, $y, $color);
|
|
|
7040 |
break;
|
|
|
7041 |
case 'plus':
|
|
|
7042 |
ImageLine($this->img, $x1, $y, $x2, $y, $color);
|
|
|
7043 |
ImageLine($this->img, $x, $y1, $x, $y2, $color);
|
|
|
7044 |
break;
|
|
|
7045 |
case 'cross':
|
|
|
7046 |
ImageLine($this->img, $x1, $y1, $x2, $y2, $color);
|
|
|
7047 |
ImageLine($this->img, $x1, $y2, $x2, $y1, $color);
|
|
|
7048 |
break;
|
|
|
7049 |
case 'circle':
|
|
|
7050 |
ImageArc($this->img, $x, $y, $point_size, $point_size, 0, 360, $color);
|
|
|
7051 |
break;
|
|
|
7052 |
case 'dot':
|
|
|
7053 |
ImageFilledEllipse($this->img, $x, $y, $point_size, $point_size, $color);
|
|
|
7054 |
break;
|
|
|
7055 |
case 'diamond':
|
|
|
7056 |
$arrpoints = array($x1, $y, $x, $y1, $x2, $y, $x, $y2);
|
|
|
7057 |
ImageFilledPolygon($this->img, $arrpoints, 4, $color);
|
|
|
7058 |
break;
|
|
|
7059 |
case 'triangle':
|
|
|
7060 |
$arrpoints = array($x1, $y, $x2, $y, $x, $y2);
|
|
|
7061 |
ImageFilledPolygon($this->img, $arrpoints, 3, $color);
|
|
|
7062 |
break;
|
|
|
7063 |
case 'trianglemid':
|
|
|
7064 |
$arrpoints = array($x1, $y1, $x2, $y1, $x, $y);
|
|
|
7065 |
ImageFilledPolygon($this->img, $arrpoints, 3, $color);
|
|
|
7066 |
break;
|
|
|
7067 |
case 'yield':
|
|
|
7068 |
$arrpoints = array($x1, $y1, $x2, $y1, $x, $y2);
|
|
|
7069 |
ImageFilledPolygon($this->img, $arrpoints, 3, $color);
|
|
|
7070 |
break;
|
|
|
7071 |
case 'delta':
|
|
|
7072 |
$arrpoints = array($x1, $y2, $x2, $y2, $x, $y1);
|
|
|
7073 |
ImageFilledPolygon($this->img, $arrpoints, 3, $color);
|
|
|
7074 |
break;
|
|
|
7075 |
case 'star':
|
|
|
7076 |
ImageLine($this->img, $x1, $y, $x2, $y, $color);
|
|
|
7077 |
ImageLine($this->img, $x, $y1, $x, $y2, $color);
|
|
|
7078 |
ImageLine($this->img, $x1, $y1, $x2, $y2, $color);
|
|
|
7079 |
ImageLine($this->img, $x1, $y2, $x2, $y1, $color);
|
|
|
7080 |
break;
|
|
|
7081 |
case 'hourglass':
|
|
|
7082 |
$arrpoints = array($x1, $y1, $x2, $y1, $x1, $y2, $x2, $y2);
|
|
|
7083 |
ImageFilledPolygon($this->img, $arrpoints, 4, $color);
|
|
|
7084 |
break;
|
|
|
7085 |
case 'bowtie':
|
|
|
7086 |
$arrpoints = array($x1, $y1, $x1, $y2, $x2, $y1, $x2, $y2);
|
|
|
7087 |
ImageFilledPolygon($this->img, $arrpoints, 4, $color);
|
|
|
7088 |
break;
|
|
|
7089 |
case 'target':
|
|
|
7090 |
ImageFilledRectangle($this->img, $x1, $y1, $x, $y, $color);
|
|
|
7091 |
ImageFilledRectangle($this->img, $x, $y, $x2, $y2, $color);
|
|
|
7092 |
ImageRectangle($this->img, $x1, $y1, $x2, $y2, $color);
|
|
|
7093 |
break;
|
|
|
7094 |
case 'box':
|
|
|
7095 |
ImageRectangle($this->img, $x1, $y1, $x2, $y2, $color);
|
|
|
7096 |
break;
|
|
|
7097 |
case 'home': /* As in: "home plate" (baseball), also looks sort of like a house. */
|
|
|
7098 |
$arrpoints = array($x1, $y2, $x2, $y2, $x2, $y, $x, $y1, $x1, $y);
|
|
|
7099 |
ImageFilledPolygon($this->img, $arrpoints, 5, $color);
|
|
|
7100 |
break;
|
|
|
7101 |
case 'up':
|
|
|
7102 |
ImagePolygon($this->img, array($x, $y1, $x2, $y2, $x1, $y2), 3, $color);
|
|
|
7103 |
break;
|
|
|
7104 |
case 'down':
|
|
|
7105 |
ImagePolygon($this->img, array($x, $y2, $x1, $y1, $x2, $y1), 3, $color);
|
|
|
7106 |
break;
|
|
|
7107 |
default: /* Also 'rect' */
|
|
|
7108 |
ImageFilledRectangle($this->img, $x1, $y1, $x2, $y2, $color);
|
|
|
7109 |
break;
|
|
|
7110 |
}
|
|
|
7111 |
return TRUE;
|
|
|
7112 |
}
|
|
|
7113 |
|
|
|
7114 |
/**
|
|
|
7115 |
* Draws a single marker point, using World Coordinates
|
|
|
7116 |
*
|
|
|
7117 |
* @param int $row Row index of data point (only used for a data_points callback)
|
|
|
7118 |
* @param int $column Column index of data point, used to select the marker shape and size
|
|
|
7119 |
* @param int $x_world X world coordinate of the data point
|
|
|
7120 |
* @param int $y_world Y world coordinate of the data point
|
|
|
7121 |
* @param int $color Color to use for the data point
|
|
|
7122 |
* @return bool True always (from DrawShape)
|
|
|
7123 |
*/
|
|
|
7124 |
protected function DrawDot($row, $column, $x_world, $y_world, $color)
|
|
|
7125 |
{
|
|
|
7126 |
$x = $this->xtr($x_world);
|
|
|
7127 |
$y = $this->ytr($y_world);
|
|
|
7128 |
$result = $this->DrawShape($x, $y, $column, $color);
|
|
|
7129 |
$this->DoCallback('data_points', 'dot', $row, $column, $x, $y);
|
|
|
7130 |
return $result;
|
|
|
7131 |
}
|
|
|
7132 |
|
|
|
7133 |
/**
|
|
|
7134 |
* Draws a single bar (or bar segment), with optional shading or border
|
|
|
7135 |
*
|
|
|
7136 |
* This draws a single bar (or bar segment), for bar and stackedbar plots,
|
|
|
7137 |
* both vertical and horizontal. The 3 color values come from GetBarColors.
|
|
|
7138 |
* Two flags (at most 1 of which can be false) are used to suppress shading
|
|
|
7139 |
* for some cases of stackedbar plots.
|
|
|
7140 |
*
|
|
|
7141 |
* @param int $row Row index of data point (only used for a data_points callback)
|
|
|
7142 |
* @param int $column Column index of data point (only used for a data_points callback)
|
|
|
7143 |
* @param int $x1 One corner of the bar X (device coordinates)
|
|
|
7144 |
* @param int $y1 One corner of the bar Y (device coordinates)
|
|
|
7145 |
* @param int $x2 Other corner of the bar X (device coordinates)
|
|
|
7146 |
* @param int $y2 Other corner of the bar Y (device coordinates)
|
|
|
7147 |
* @param int $data_color Color index to use for the bar fill
|
|
|
7148 |
* @param int $shade_color Color index to use for the shading (if shading is on, else NULL)
|
|
|
7149 |
* @param int $border_color Color index to use for the bar outlines (borders), if enabled, else NULL
|
|
|
7150 |
* @param bool $shade_top Shade the top? (Suppressed for downward stack segments except first)
|
|
|
7151 |
* @param bool $shade_side Shade the right side? (Suppressed for leftward stack segments except first)
|
|
|
7152 |
* @return bool True always
|
|
|
7153 |
* @since 5.2.0
|
|
|
7154 |
*/
|
|
|
7155 |
protected function DrawBar($row, $column, $x1, $y1, $x2, $y2, $data_color, $shade_color, $border_color,
|
|
|
7156 |
$shade_top = TRUE, $shade_side = TRUE)
|
|
|
7157 |
{
|
|
|
7158 |
// Sort the points so x1,y1 is upper left and x2,y2 is lower right. This
|
|
|
7159 |
// is needed in order to get the shading right, and imagerectangle may require it.
|
|
|
7160 |
if ($x1 > $x2) {
|
|
|
7161 |
$t = $x1; $x1 = $x2; $x2 = $t;
|
|
|
7162 |
}
|
|
|
7163 |
if ($y1 > $y2) {
|
|
|
7164 |
$t = $y1; $y1 = $y2; $y2 = $t;
|
|
|
7165 |
}
|
|
|
7166 |
|
|
|
7167 |
// Draw the bar
|
|
|
7168 |
ImageFilledRectangle($this->img, $x1, $y1, $x2, $y2, $data_color);
|
|
|
7169 |
|
|
|
7170 |
// Draw a shade, if shading is on.
|
|
|
7171 |
if (isset($shade_color)) {
|
|
|
7172 |
$shade = $this->shading;
|
|
|
7173 |
if ($shade_top && $shade_side) {
|
|
|
7174 |
$pts = array($x1, $y1, $x1 + $shade, $y1 - $shade, $x2 + $shade, $y1 - $shade,
|
|
|
7175 |
$x2 + $shade, $y2 - $shade, $x2, $y2, $x2, $y1);
|
|
|
7176 |
} elseif ($shade_top) { // Suppress side shading
|
|
|
7177 |
$pts = array($x1, $y1, $x1 + $shade, $y1 - $shade, $x2 + $shade, $y1 - $shade, $x2, $y1);
|
|
|
7178 |
} else { // Suppress top shading (Note shade_top==FALSE && shade_side==FALSE is not allowed)
|
|
|
7179 |
$pts = array($x2, $y2, $x2, $y1, $x2 + $shade, $y1 - $shade, $x2 + $shade, $y2 - $shade);
|
|
|
7180 |
}
|
|
|
7181 |
ImageFilledPolygon($this->img, $pts, count($pts) / 2, $shade_color);
|
|
|
7182 |
}
|
|
|
7183 |
|
|
|
7184 |
// Draw a border around the bar, if enabled.
|
|
|
7185 |
if (isset($border_color)) {
|
|
|
7186 |
// Avoid a PHP/GD bug with zero-height ImageRectangle resulting in "T"-shaped ends.
|
|
|
7187 |
if ($y1 == $y2)
|
|
|
7188 |
imageline($this->img, $x1, $y1, $x2, $y2, $border_color);
|
|
|
7189 |
else
|
|
|
7190 |
imagerectangle($this->img, $x1, $y1, $x2, $y2, $border_color);
|
|
|
7191 |
}
|
|
|
7192 |
$this->DoCallback('data_points', 'rect', $row, $column, $x1, $y1, $x2, $y2);
|
|
|
7193 |
return TRUE;
|
|
|
7194 |
}
|
|
|
7195 |
|
|
|
7196 |
/**
|
|
|
7197 |
* Draws an error bar set for horizontal plots, showing +/- error in X
|
|
|
7198 |
*
|
|
|
7199 |
* @param float $x X world coordinate of the data point (dependent variable)
|
|
|
7200 |
* @param float $y Y world coordinate of the data point (independent variable)
|
|
|
7201 |
* @param float $error_plus X error offset above $x (world coordinates >= 0)
|
|
|
7202 |
* @param float $error_minus X error offset below $x (world coordinates >= 0)
|
|
|
7203 |
* @param int $color Color to use for the error bars
|
|
|
7204 |
* @return bool True always
|
|
|
7205 |
* @since 6.1.0
|
|
|
7206 |
*/
|
|
|
7207 |
protected function DrawXErrorBars($x, $y, $error_plus, $error_minus, $color)
|
|
|
7208 |
{
|
|
|
7209 |
$x1 = $this->xtr($x);
|
|
|
7210 |
$y1 = $this->ytr($y);
|
|
|
7211 |
$x2p = $this->xtr($x + $error_plus);
|
|
|
7212 |
$x2m = $this->xtr($x - $error_minus);
|
|
|
7213 |
|
|
|
7214 |
imagesetthickness($this->img, $this->error_bar_line_width);
|
|
|
7215 |
imageline($this->img, $x2p, $y1 , $x2m, $y1, $color);
|
|
|
7216 |
if ($this->error_bar_shape == 'tee') {
|
|
|
7217 |
$e = $this->error_bar_size;
|
|
|
7218 |
imageline($this->img, $x2p, $y1 - $e, $x2p, $y1 + $e, $color);
|
|
|
7219 |
imageline($this->img, $x2m, $y1 - $e, $x2m, $y1 + $e, $color);
|
|
|
7220 |
}
|
|
|
7221 |
imagesetthickness($this->img, 1);
|
|
|
7222 |
return TRUE;
|
|
|
7223 |
}
|
|
|
7224 |
|
|
|
7225 |
/**
|
|
|
7226 |
* Draws an error bar set for vertical plots, showing +/- error in Y
|
|
|
7227 |
*
|
|
|
7228 |
* @param float $x X world coordinate of the data point (independent variable)
|
|
|
7229 |
* @param float $y Y world coordinate of the data point (dependent variable)
|
|
|
7230 |
* @param float $error_plus Y error offset above $y (world coordinates >= 0)
|
|
|
7231 |
* @param float $error_minus Y error offset below $y (world coordinates >= 0)
|
|
|
7232 |
* @param int $color Color to use for the error bars
|
|
|
7233 |
* @return bool True always
|
|
|
7234 |
* @since 6.1.0
|
|
|
7235 |
*/
|
|
|
7236 |
protected function DrawYErrorBars($x, $y, $error_plus, $error_minus, $color)
|
|
|
7237 |
{
|
|
|
7238 |
$x1 = $this->xtr($x);
|
|
|
7239 |
$y1 = $this->ytr($y);
|
|
|
7240 |
$y2p = $this->ytr($y + $error_plus);
|
|
|
7241 |
$y2m = $this->ytr($y - $error_minus);
|
|
|
7242 |
|
|
|
7243 |
imagesetthickness($this->img, $this->error_bar_line_width);
|
|
|
7244 |
imageline($this->img, $x1, $y2p , $x1, $y2m, $color);
|
|
|
7245 |
if ($this->error_bar_shape == 'tee') {
|
|
|
7246 |
$e = $this->error_bar_size;
|
|
|
7247 |
imageline($this->img, $x1 - $e, $y2p, $x1 + $e, $y2p, $color);
|
|
|
7248 |
imageline($this->img, $x1 - $e, $y2m, $x1 + $e, $y2m, $color);
|
|
|
7249 |
}
|
|
|
7250 |
imagesetthickness($this->img, 1);
|
|
|
7251 |
return TRUE;
|
|
|
7252 |
}
|
|
|
7253 |
|
|
|
7254 |
/**
|
|
|
7255 |
* Sets up the default pie chart label type and format
|
|
|
7256 |
*
|
|
|
7257 |
* If SetPieLabelType() was not called, this function set the default.
|
|
|
7258 |
* The default for pie chart labels is to show the slice percentage,
|
|
|
7259 |
* with fixed point precision. For backward compatibility with
|
|
|
7260 |
* PHPlot <= 5.5.0, the Y label data precision (if set) is the default
|
|
|
7261 |
* precision used.
|
|
|
7262 |
*
|
|
|
7263 |
* @return string[] A value to use as pie_label_source in FormatPieLabel()
|
|
|
7264 |
* @since 5.6.0
|
|
|
7265 |
*/
|
|
|
7266 |
protected function CheckPieLabels()
|
|
|
7267 |
{
|
|
|
7268 |
if (empty($this->pie_label_source)) { // SetPieLabelType() was not called, or was reset to default
|
|
|
7269 |
$prec = isset($this->label_format['y']['precision']) ? $this->label_format['y']['precision'] : 1;
|
|
|
7270 |
$this->SetLabelType('p', array('data', $prec, '', '%'));
|
|
|
7271 |
return array('percent'); // Default to 'percent' labels (leaving this->pie_label_source empty)
|
|
|
7272 |
}
|
|
|
7273 |
return $this->pie_label_source; // Use label type set set with SetPieLabelType()
|
|
|
7274 |
}
|
|
|
7275 |
|
|
|
7276 |
/**
|
|
|
7277 |
* Sets up for an area plot, calculating a points list and drawing data labels
|
|
|
7278 |
*
|
|
|
7279 |
* This is used for area fill plots: [stacked]area and [stacked]squaredarea.
|
|
|
7280 |
* It converts the data array to device coordinate arrays. This also
|
|
|
7281 |
* draws the axis data labels (if enabled). Caller ensures there are at
|
|
|
7282 |
* least 2 rows (X), and all rows have same number of columns (Y).
|
|
|
7283 |
* Note that the returned $yd array has an extra column for points along
|
|
|
7284 |
* the X axis. See comment below on 'artifical Y value'.
|
|
|
7285 |
* This does not support missing points or data value labels.
|
|
|
7286 |
*
|
|
|
7287 |
* @param bool $stacked True for a stacked plot (cumulative Y), false if not
|
|
|
7288 |
* @param int[] $xd Reference variable - returned array with X device coordinates
|
|
|
7289 |
* @param int[] $yd Reference variable - returned 2D array with Y device coordinates
|
|
|
7290 |
* @return int Number of columns in yd[][], which is $this->data_columns + 1
|
|
|
7291 |
* @since 6.2.0
|
|
|
7292 |
*/
|
|
|
7293 |
protected function SetupAreaPlot($stacked, &$xd, &$yd)
|
|
|
7294 |
{
|
|
|
7295 |
$xd = array();
|
|
|
7296 |
$yd = array();
|
|
|
7297 |
|
|
|
7298 |
// Outer loop over rows (X); inner over columns (Y):
|
|
|
7299 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
7300 |
$rec = 1; // Skip record #0 (data label)
|
|
|
7301 |
|
|
|
7302 |
if ($this->datatype_implied) // Implied X values?
|
|
|
7303 |
$x_now = 0.5 + $row; // Place text-data at X = 0.5, 1.5, 2.5, etc...
|
|
|
7304 |
else
|
|
|
7305 |
$x_now = $this->data[$row][$rec++]; // Read it, advance record index
|
|
|
7306 |
|
|
|
7307 |
$xd[$row] = $x_now_pixels = $this->xtr($x_now); // Save in device coordinates
|
|
|
7308 |
|
|
|
7309 |
if ($this->x_data_label_pos != 'none') // Draw X Data labels?
|
|
|
7310 |
$this->DrawXDataLabel($this->data[$row][0], $x_now_pixels, $row);
|
|
|
7311 |
|
|
|
7312 |
// There is an artificial Y value at the X axis. For stacked plots, it goes before the
|
|
|
7313 |
// first real Y, so the first area fill is from the axis to the first Y data set.
|
|
|
7314 |
// For non-stacked plots, it goes after the last Y, so the last area fill is from axis
|
|
|
7315 |
// to the last Y data set.
|
|
|
7316 |
if ($stacked)
|
|
|
7317 |
$yd[$row] = array($this->x_axis_y_pixels);
|
|
|
7318 |
else
|
|
|
7319 |
$yd[$row] = array();
|
|
|
7320 |
|
|
|
7321 |
// Store the Y values for this X. Missing Y values are not supported, and are replaced with 0.
|
|
|
7322 |
// Negative numbers are not supported, and are replaced with absolute values.
|
|
|
7323 |
// The resulting numbers are also clipped to the X axis' Y value (which can be > 0).
|
|
|
7324 |
$y = 0; // Accumulate (if not reset below) the Y values
|
|
|
7325 |
for ($idx = 0; $rec < $this->records_per_group; $rec++, $idx++) {
|
|
|
7326 |
if (is_numeric($y_now = $this->data[$row][$rec]))
|
|
|
7327 |
$y += abs($y_now);
|
|
|
7328 |
$yd[$row][] = $this->ytr(max($this->x_axis_position, $y));
|
|
|
7329 |
if (!$stacked) $y = 0; // For non-stacked plots, reset Y in each loop.
|
|
|
7330 |
}
|
|
|
7331 |
// See above: For non-stacked plots, the Y value for X axis goes at the end.
|
|
|
7332 |
if (!$stacked)
|
|
|
7333 |
$yd[$row][] = $this->x_axis_y_pixels;
|
|
|
7334 |
}
|
|
|
7335 |
return ($this->data_columns + 1); // This is the size of each yd[][]
|
|
|
7336 |
}
|
|
|
7337 |
|
|
|
7338 |
/**
|
|
|
7339 |
* Draws the data borders for an area fill plot
|
|
|
7340 |
*
|
|
|
7341 |
* This is used by area fill plots (area, squaredarea, and their stacked
|
|
|
7342 |
* variants) to draw the data borders, if enabled.
|
|
|
7343 |
*
|
|
|
7344 |
* @param int $n_columns Number of columns in $yd, returned by SetupAreaPlot()
|
|
|
7345 |
* @param int[] $xd X device coordinate array from SetupAreaPlot()
|
|
|
7346 |
* @param int[] $yd Y device coordinate array from SetupAreaPlot()
|
|
|
7347 |
* @param bool $stacked True for a stacked plot (cumulative Y), false if not
|
|
|
7348 |
* @param bool $stepped True for a stepped (squared) plot, false for a regular area plot
|
|
|
7349 |
* @return bool True always
|
|
|
7350 |
* @since 6.2.0
|
|
|
7351 |
*/
|
|
|
7352 |
function DrawAreaFillBorders($n_columns, $xd, $yd, $stacked, $stepped)
|
|
|
7353 |
{
|
|
|
7354 |
for ($col = 1; $col < $n_columns; $col++) {
|
|
|
7355 |
$color = $this->ndx_data_border_colors[$col-1];
|
|
|
7356 |
// This is due to the difference in the $yd array for stacked and unstacked.
|
|
|
7357 |
if ($stacked) {
|
|
|
7358 |
$this_col = $col; // Border follows column = 1 to N-1
|
|
|
7359 |
$other_col = $col - 1; // Left and right edges use the previous column
|
|
|
7360 |
} else {
|
|
|
7361 |
$this_col = $col - 1; // Border follows column = 0 to N-2
|
|
|
7362 |
$other_col = $col; // Left and right edges use the next column
|
|
|
7363 |
}
|
|
|
7364 |
|
|
|
7365 |
// Left edge:
|
|
|
7366 |
$x = $xd[0];
|
|
|
7367 |
$y = $yd[0][$this_col];
|
|
|
7368 |
ImageLine($this->img, $x, $yd[0][$other_col], $x, $y, $color);
|
|
|
7369 |
|
|
|
7370 |
// Across the top, with an 'X then Y' step at each point:
|
|
|
7371 |
for ($row = 1; $row < $this->num_data_rows; $row++) {
|
|
|
7372 |
$prev_x = $x;
|
|
|
7373 |
$prev_y = $y;
|
|
|
7374 |
$x = $xd[$row];
|
|
|
7375 |
$y = $yd[$row][$this_col];
|
|
|
7376 |
if ($stepped) {
|
|
|
7377 |
ImageLine($this->img, $prev_x, $prev_y, $x, $prev_y, $color);
|
|
|
7378 |
ImageLine($this->img, $x, $prev_y, $x, $y, $color);
|
|
|
7379 |
} else {
|
|
|
7380 |
ImageLine($this->img, $prev_x, $prev_y, $x, $y, $color);
|
|
|
7381 |
}
|
|
|
7382 |
}
|
|
|
7383 |
|
|
|
7384 |
// Right edge:
|
|
|
7385 |
ImageLine($this->img, $x, $y, $x, $yd[$this->num_data_rows - 1][$other_col], $color);
|
|
|
7386 |
}
|
|
|
7387 |
return TRUE;
|
|
|
7388 |
}
|
|
|
7389 |
|
|
|
7390 |
/////////////////////////////////////////////
|
|
|
7391 |
//////////////////// PLOT DRAWING
|
|
|
7392 |
/////////////////////////////////////////////
|
|
|
7393 |
|
|
|
7394 |
/**
|
|
|
7395 |
* Draws a pie plot (Pie chart)
|
|
|
7396 |
*
|
|
|
7397 |
* This is the main function for drawing a pie chart. Supported data
|
|
|
7398 |
* types are 'text-data', 'data-data', and 'text-data-single'.
|
|
|
7399 |
*
|
|
|
7400 |
* For text-data-single, the data array contains records with a label and
|
|
|
7401 |
* one Y value. Each record defines a sector of the pie, as a portion of
|
|
|
7402 |
* the sum of all Y values. Data labels are ignored by default, but can
|
|
|
7403 |
* be selected for display with SetPieLabelType().
|
|
|
7404 |
*
|
|
|
7405 |
* For text-data and data-data, the data array contains records with an
|
|
|
7406 |
* ignored label, an ignored X value for data-data only, and N (N>=1) Y
|
|
|
7407 |
* values per record. The pie chart will be produced with N segments. The
|
|
|
7408 |
* relative size of the first sector of the pie is the sum of the first Y
|
|
|
7409 |
* data value in each record, etc. The data labels cannot be used, since
|
|
|
7410 |
* they don't map to specific pie sectors.
|
|
|
7411 |
*
|
|
|
7412 |
* If there are no valid positive data points at all, just draw nothing.
|
|
|
7413 |
* It may seem more correct to raise an error, but all of the other plot
|
|
|
7414 |
* types handle it this way implicitly. DrawGraph() checks for an empty
|
|
|
7415 |
* data array, but this handles a non-empty data array with no Y values,
|
|
|
7416 |
* or all Y=0.
|
|
|
7417 |
*
|
|
|
7418 |
* @return bool True (False on error if an error handler returns True)
|
|
|
7419 |
*
|
|
|
7420 |
*/
|
|
|
7421 |
protected function DrawPieChart()
|
|
|
7422 |
{
|
|
|
7423 |
// Early checks and initialization:
|
|
|
7424 |
if (!$this->CheckDataType('text-data, text-data-single, data-data'))
|
|
|
7425 |
return FALSE;
|
|
|
7426 |
|
|
|
7427 |
// SetLabelScalePosition(0 or FALSE) means no labels.
|
|
|
7428 |
$do_labels = !empty($this->label_scale_position);
|
|
|
7429 |
if ($do_labels) {
|
|
|
7430 |
// Validate and get default for pie chart label source and format:
|
|
|
7431 |
$pie_label_source = $this->CheckPieLabels();
|
|
|
7432 |
// Labels outside (vs inside) the pie? If so, pie size will need adjusting.
|
|
|
7433 |
$labels_outside = $this->label_scale_position >= 0.5; // Only defined if ($do_labels)
|
|
|
7434 |
}
|
|
|
7435 |
|
|
|
7436 |
// Draw segment borders? Default is True for unshaded, False for shaded
|
|
|
7437 |
$do_borders = isset($this->draw_pie_borders) ? $this->draw_pie_borders : ($this->shading == 0);
|
|
|
7438 |
|
|
|
7439 |
$max_data_colors = count($this->ndx_data_colors); // Number of colors available
|
|
|
7440 |
|
|
|
7441 |
// Check shading. Diameter factor $diam_factor is (height / width)
|
|
|
7442 |
if ($this->shading > 0) {
|
|
|
7443 |
$diam_factor = $this->pie_diam_factor;
|
|
|
7444 |
$this->NeedDataDarkColors(); // Dark colors are needed for shading
|
|
|
7445 |
} else {
|
|
|
7446 |
$diam_factor = 1.0; // Unshaded pies are always round, width == height
|
|
|
7447 |
}
|
|
|
7448 |
|
|
|
7449 |
// Pie center point is always the center of the plot area, regardless of label sizes.
|
|
|
7450 |
$xpos = $this->plot_area[0] + $this->plot_area_width/2;
|
|
|
7451 |
$ypos = $this->plot_area[1] + $this->plot_area_height/2;
|
|
|
7452 |
|
|
|
7453 |
// Reduce the data array into sumarr[], accounting for the data type:
|
|
|
7454 |
$num_slices = $this->data_columns; // See CheckDataArray which calculates this for us.
|
|
|
7455 |
if ($num_slices < 1) return TRUE; // Give up early if there is no data at all.
|
|
|
7456 |
$sumarr = array_fill(0, $num_slices, 0); // Initialize array of per-sector sums.
|
|
|
7457 |
|
|
|
7458 |
if ($this->datatype_pie_single) {
|
|
|
7459 |
// text-data-single: One data column per row, one pie slice per row.
|
|
|
7460 |
for ($i = 0; $i < $num_slices; $i++) {
|
|
|
7461 |
if (is_numeric($val = $this->data[$i][1]))
|
|
|
7462 |
$sumarr[$i] = abs($val);
|
|
|
7463 |
}
|
|
|
7464 |
} else {
|
|
|
7465 |
// text-data: Sum each column (skipping label), one pie slice per column.
|
|
|
7466 |
// data-data: Sum each column (skipping X value and label), one pie slice per column.
|
|
|
7467 |
$skip = ($this->datatype_implied) ? 1 : 2; // Leading values to skip in each row.
|
|
|
7468 |
for ($i = 0; $i < $this->num_data_rows; $i++) {
|
|
|
7469 |
for ($j = $skip; $j < $this->num_recs[$i]; $j++) {
|
|
|
7470 |
if (is_numeric($val = $this->data[$i][$j]))
|
|
|
7471 |
$sumarr[$j-$skip] += abs($val);
|
|
|
7472 |
}
|
|
|
7473 |
}
|
|
|
7474 |
}
|
|
|
7475 |
|
|
|
7476 |
$total = array_sum($sumarr);
|
|
|
7477 |
if ($total == 0) {
|
|
|
7478 |
// There are either no valid data points, or all are 0.
|
|
|
7479 |
// See top comment about why not to make this an error.
|
|
|
7480 |
return TRUE;
|
|
|
7481 |
}
|
|
|
7482 |
|
|
|
7483 |
// Pre-calculate the label strings, if labels are on. Also get the maximum height and width
|
|
|
7484 |
// of the labels, to use in sizing the pie chart (if the labels are outside the pie).
|
|
|
7485 |
// This is an overly pessimistic approach - assumes the widest label is at 0 or 180 degrees - but
|
|
|
7486 |
// is much easier than calculating the exact space needed for all labels around the pie.
|
|
|
7487 |
// For more detailed comments on the in-loop calculations, see the second loop below where
|
|
|
7488 |
// the features are actually drawn.
|
|
|
7489 |
// Note this is going around the pie, with angles specified, but we do not yet know the pie size.
|
|
|
7490 |
|
|
|
7491 |
$label_max_width = 0; // Widest label width, in pixels
|
|
|
7492 |
$label_max_height = 0; // Tallest label height, in pixels
|
|
|
7493 |
if ($do_labels) {
|
|
|
7494 |
$labels = array(); // Array to store the formatted label strings
|
|
|
7495 |
$end_angle = $start_angle = $this->pie_start_angle;
|
|
|
7496 |
for ($j = 0; $j < $num_slices; $j++) {
|
|
|
7497 |
$slice_weight = $sumarr[$j];
|
|
|
7498 |
$arc_angle = 360 * $slice_weight / $total;
|
|
|
7499 |
if ($this->pie_direction_cw) {
|
|
|
7500 |
$end_angle = $start_angle;
|
|
|
7501 |
$start_angle -= $arc_angle;
|
|
|
7502 |
} else {
|
|
|
7503 |
$start_angle = $end_angle;
|
|
|
7504 |
$end_angle += $arc_angle;
|
|
|
7505 |
}
|
|
|
7506 |
$arc_start_angle = (int)(360 - $start_angle);
|
|
|
7507 |
$arc_end_angle = (int)(360 - $end_angle);
|
|
|
7508 |
if ($arc_start_angle > $arc_end_angle) { // Skip segments with angle < 1 degree
|
|
|
7509 |
$labels[$j] = $this->FormatPieLabel($j, $pie_label_source, $arc_angle, $slice_weight);
|
|
|
7510 |
if ($labels_outside) { // Labels are outside the pie chart
|
|
|
7511 |
list($width, $height) = $this->SizeText('generic', 0, $labels[$j]);
|
|
|
7512 |
if ($width > $label_max_width) $label_max_width = $width;
|
|
|
7513 |
if ($height > $label_max_height) $label_max_height = $height;
|
|
|
7514 |
}
|
|
|
7515 |
}
|
|
|
7516 |
}
|
|
|
7517 |
}
|
|
|
7518 |
|
|
|
7519 |
// Calculate the maximum available area for the pie, leaving room for labels (if outside the pie):
|
|
|
7520 |
// This can be overridden by using SetPieAutoSize(FALSE), which sets the flag: pie_full_size=TRUE.
|
|
|
7521 |
if ($do_labels && $labels_outside && !$this->pie_full_size) {
|
|
|
7522 |
// There needs to be safe_margin between the labels and the plot area margins, and at least
|
|
|
7523 |
// safe_margin between the labels and the pie edge (this is LR_marg and TB_marg below).
|
|
|
7524 |
// plot_area_width = avail_width + 2 * (LR_marg + label_width + safe_margin)
|
|
|
7525 |
// Where LR_marg = max(safe_margin, avail_width * label_scale_position - avail_width/2)
|
|
|
7526 |
// plot_area_height = avail_height + 2 * (TB_marg + label_height + safe_margin + shading)
|
|
|
7527 |
// Where TB_marg = max(safe_margin, avail_height * label_scale_position - avail_height/2)
|
|
|
7528 |
// Note shading is on bottom only, but since center is fixed, it is counted on top too.
|
|
|
7529 |
// Note (avail_width * label_scale_position) is the distance from the pie center to the label
|
|
|
7530 |
// text base point. Subtract avail_width/2 to get the inner margin (unless it is too small).
|
|
|
7531 |
// Similar for Y: avail_height * label_scale_position - avail_height/2 is the distance from
|
|
|
7532 |
// the pie center up to the label text base point.
|
|
|
7533 |
|
|
|
7534 |
// Calculate available space for both values of LR_marg, TB_marg and take the smaller ones.
|
|
|
7535 |
$avail_width = min(
|
|
|
7536 |
($this->plot_area_width / 2 - $label_max_width - $this->safe_margin) /
|
|
|
7537 |
$this->label_scale_position,
|
|
|
7538 |
$this->plot_area_width - 4 * $this->safe_margin - 2 * $label_max_width);
|
|
|
7539 |
|
|
|
7540 |
$avail_height = min(
|
|
|
7541 |
($this->plot_area_height / 2 - $label_max_height - $this->safe_margin - $this->shading) /
|
|
|
7542 |
$this->label_scale_position,
|
|
|
7543 |
$this->plot_area_height - 4*$this->safe_margin - 2*($label_max_height + $this->shading));
|
|
|
7544 |
|
|
|
7545 |
// Sanity check - don't let large labels shrink the pie too much.
|
|
|
7546 |
$avail_width = max($avail_width, $this->pie_min_size_factor * $this->plot_area_width);
|
|
|
7547 |
$avail_height = max($avail_height, $this->pie_min_size_factor * $this->plot_area_height);
|
|
|
7548 |
} else { // No adjustment needed for labels
|
|
|
7549 |
$avail_width = $this->plot_area_width - 2 * $this->safe_margin;
|
|
|
7550 |
// Note shading is only on bottom, but need to subtract 2x because center does not move.
|
|
|
7551 |
$avail_height = $this->plot_area_height - 2 * ($this->safe_margin + $this->shading);
|
|
|
7552 |
}
|
|
|
7553 |
|
|
|
7554 |
// Calculate the pie width and height for the best fit, given diam_factor and available space:
|
|
|
7555 |
if ($avail_height / $avail_width > $diam_factor) {
|
|
|
7556 |
$pie_width = $avail_width;
|
|
|
7557 |
$pie_height = $pie_width * $diam_factor;
|
|
|
7558 |
} else {
|
|
|
7559 |
$pie_height = $avail_height;
|
|
|
7560 |
$pie_width = $pie_height / $diam_factor;
|
|
|
7561 |
}
|
|
|
7562 |
|
|
|
7563 |
// Factors used to calculate label positions by DrawPieLabel(). See there for explanation.
|
|
|
7564 |
if ($do_labels) {
|
|
|
7565 |
$r['reverse'] = 0.25 < $this->label_scale_position && $this->label_scale_position < 0.5;
|
|
|
7566 |
$r['x'] = $pie_width * $this->label_scale_position;
|
|
|
7567 |
$r['y'] = $pie_height * $this->label_scale_position;
|
|
|
7568 |
if ($labels_outside) {
|
|
|
7569 |
// Don't let outside labels touch the pie edge - move them out a bit:
|
|
|
7570 |
$r['x'] = max($r['x'], $pie_width / 2 + $this->safe_margin);
|
|
|
7571 |
$r['y'] = max($r['y'], $pie_height / 2 + $this->safe_margin);
|
|
|
7572 |
} else {
|
|
|
7573 |
// Don't let inside labels touch the pie edge - move them in a bit:
|
|
|
7574 |
$r['x'] = min($r['x'], $pie_width / 2 - $this->safe_margin);
|
|
|
7575 |
$r['y'] = min($r['y'], $pie_height / 2 - $this->safe_margin);
|
|
|
7576 |
}
|
|
|
7577 |
}
|
|
|
7578 |
|
|
|
7579 |
// Draw the pie. For shaded pies, draw one set for each shading level ($h).
|
|
|
7580 |
for ($h = $this->shading; $h >= 0; $h--) {
|
|
|
7581 |
$color_index = 0;
|
|
|
7582 |
|
|
|
7583 |
// Initialize the start angle (for clockwise) or end angle (for counter-clockwise).
|
|
|
7584 |
// See "Calculate the two angles" below to make sense of this.
|
|
|
7585 |
$end_angle = $start_angle = $this->pie_start_angle;
|
|
|
7586 |
|
|
|
7587 |
// Loop over all pie segments:
|
|
|
7588 |
for ($j = 0; $j < $num_slices; $j++) {
|
|
|
7589 |
$slice_weight = $sumarr[$j];
|
|
|
7590 |
$arc_angle = 360 * $slice_weight / $total;
|
|
|
7591 |
|
|
|
7592 |
// For shaded pies: the last one (at the top of the "stack") has a brighter color:
|
|
|
7593 |
if ($h == 0)
|
|
|
7594 |
$slicecol = $this->ndx_data_colors[$color_index];
|
|
|
7595 |
else
|
|
|
7596 |
$slicecol = $this->ndx_data_dark_colors[$color_index];
|
|
|
7597 |
|
|
|
7598 |
// Calculate the two angles that define this pie segment.
|
|
|
7599 |
// Note that regardless of the direction (CW or CCW), start_angle < end_angle.
|
|
|
7600 |
if ($this->pie_direction_cw) {
|
|
|
7601 |
$end_angle = $start_angle;
|
|
|
7602 |
$start_angle -= $arc_angle;
|
|
|
7603 |
} else {
|
|
|
7604 |
$start_angle = $end_angle;
|
|
|
7605 |
$end_angle += $arc_angle;
|
|
|
7606 |
}
|
|
|
7607 |
|
|
|
7608 |
// Calculate the arc angles for ImageFilledArc(), which measures angles in the opposite
|
|
|
7609 |
// direction (counter-clockwise), and only takes integer values.
|
|
|
7610 |
$arc_start_angle = (int)(360 - $start_angle);
|
|
|
7611 |
$arc_end_angle = (int)(360 - $end_angle);
|
|
|
7612 |
// Don't try to draw a 0 degree slice - it would make a full circle.
|
|
|
7613 |
if ($arc_start_angle > $arc_end_angle) {
|
|
|
7614 |
// Draw the slice
|
|
|
7615 |
ImageFilledArc($this->img, $xpos, $ypos+$h, $pie_width, $pie_height,
|
|
|
7616 |
$arc_end_angle, $arc_start_angle, $slicecol, IMG_ARC_PIE);
|
|
|
7617 |
|
|
|
7618 |
// Processing to do only for the last (if shaded) or only (if unshaded) loop:
|
|
|
7619 |
if ($h == 0) {
|
|
|
7620 |
// Draw the pie segment outline (if enabled):
|
|
|
7621 |
if ($do_borders) {
|
|
|
7622 |
ImageFilledArc($this->img, $xpos, $ypos, $pie_width, $pie_height,
|
|
|
7623 |
$arc_end_angle, $arc_start_angle, $this->ndx_pieborder_color,
|
|
|
7624 |
IMG_ARC_PIE | IMG_ARC_EDGED |IMG_ARC_NOFILL);
|
|
|
7625 |
}
|
|
|
7626 |
|
|
|
7627 |
// Draw the label:
|
|
|
7628 |
if ($do_labels)
|
|
|
7629 |
$this->DrawPieLabel($labels[$j], $xpos, $ypos, $start_angle, $arc_angle, $r);
|
|
|
7630 |
// Trigger a data points callback; note it gets the calculated (reversed) angles:
|
|
|
7631 |
$this->DoCallback('data_points', 'pie', $j, 0, $xpos, $ypos, $pie_width,
|
|
|
7632 |
$pie_height, $arc_start_angle, $arc_end_angle);
|
|
|
7633 |
}
|
|
|
7634 |
}
|
|
|
7635 |
if (++$color_index >= $max_data_colors)
|
|
|
7636 |
$color_index = 0;
|
|
|
7637 |
} // end loop for each slice
|
|
|
7638 |
} // end loop for each level of shading
|
|
|
7639 |
return TRUE;
|
|
|
7640 |
}
|
|
|
7641 |
|
|
|
7642 |
/**
|
|
|
7643 |
* Draws a points plot, or the points for a linepoints plot
|
|
|
7644 |
*
|
|
|
7645 |
* This is the main function for drawing a points plot, and is also used
|
|
|
7646 |
* for a linepoints plot. Vertical and Horizontal plots, and error plots,
|
|
|
7647 |
* are all supported. "iv" is used for the independent variable (X for
|
|
|
7648 |
* vertical plots, Y for horizontal) and "dv" is used for the dependent
|
|
|
7649 |
* variable (Y or X respectively).
|
|
|
7650 |
*
|
|
|
7651 |
* When $paired is true, a linepoints plot is being drawn, and some
|
|
|
7652 |
* elements are suppressed here because they are done elsewhere. See
|
|
|
7653 |
* DrawLinePoints() for details.
|
|
|
7654 |
*
|
|
|
7655 |
* @param bool $paired True if doing a linepoints plot, False or omit for points plot
|
|
|
7656 |
* @return bool True (False on error if an error handler returns True)
|
|
|
7657 |
*/
|
|
|
7658 |
protected function DrawDots($paired = FALSE)
|
|
|
7659 |
{
|
|
|
7660 |
if (!$this->CheckDataType('text-data, data-data, text-data-yx, data-data-yx, '
|
|
|
7661 |
. 'data-data-error, data-data-yx-error'))
|
|
|
7662 |
return FALSE;
|
|
|
7663 |
|
|
|
7664 |
// Adjust the point shapes and point sizes arrays:
|
|
|
7665 |
$this->CheckPointParams();
|
|
|
7666 |
|
|
|
7667 |
$gcvars = array(); // For GetDataColor, which initializes and uses this.
|
|
|
7668 |
// Special flag for data color callback to indicate the 'points' part of 'linepoints':
|
|
|
7669 |
$alt_flag = $paired ? 1 : 0;
|
|
|
7670 |
|
|
|
7671 |
// Data labels, Data Value Labels? (Skip if doing the points from a linepoints plot)
|
|
|
7672 |
if ($this->datatype_swapped_xy) {
|
|
|
7673 |
// Horizontal plots can have X Data Value Labels, Y Axis Data Labels
|
|
|
7674 |
$do_x_axis_labels = FALSE;
|
|
|
7675 |
$do_x_valu_labels = !$paired && $this->CheckDataValueLabels($this->x_data_label_pos, $dvl);
|
|
|
7676 |
$do_y_axis_labels = !$paired && $this->y_data_label_pos != 'none';
|
|
|
7677 |
$do_y_valu_labels = FALSE;
|
|
|
7678 |
} else {
|
|
|
7679 |
// Vertical plots can have X Axis Data Labels, Y Data Value Labels
|
|
|
7680 |
$do_x_axis_labels = !$paired && $this->x_data_label_pos != 'none';
|
|
|
7681 |
$do_x_valu_labels = FALSE;
|
|
|
7682 |
$do_y_axis_labels = FALSE;
|
|
|
7683 |
$do_y_valu_labels = !$paired && $this->CheckDataValueLabels($this->y_data_label_pos, $dvl);
|
|
|
7684 |
}
|
|
|
7685 |
|
|
|
7686 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
7687 |
$rec = 1; // Skip record #0 (data label)
|
|
|
7688 |
|
|
|
7689 |
if ($this->datatype_implied) // Implied independent variable values?
|
|
|
7690 |
$iv = 0.5 + $row; // Place text-data at 0.5, 1.5, 2.5, etc...
|
|
|
7691 |
else
|
|
|
7692 |
$iv = $this->data[$row][$rec++]; // Read it, advance record index
|
|
|
7693 |
|
|
|
7694 |
// Axis data label?
|
|
|
7695 |
if ($do_x_axis_labels)
|
|
|
7696 |
$this->DrawXDataLabel($this->data[$row][0], $this->xtr($iv), $row, TRUE);
|
|
|
7697 |
elseif ($do_y_axis_labels)
|
|
|
7698 |
$this->DrawYDataLabel($this->data[$row][0], $this->ytr($iv), $row, TRUE);
|
|
|
7699 |
|
|
|
7700 |
// Proceed with dependent values
|
|
|
7701 |
for ($idx = 0; $rec < $this->num_recs[$row]; $idx++) {
|
|
|
7702 |
if (is_numeric($dv = $this->data[$row][$rec++])) { // Allow for missing data
|
|
|
7703 |
|
|
|
7704 |
// Select the color(s):
|
|
|
7705 |
if ($this->datatype_error_bars) {
|
|
|
7706 |
$this->GetDataErrorColors($row, $idx, $gcvars, $data_color, $error_color, $alt_flag);
|
|
|
7707 |
} else {
|
|
|
7708 |
$this->GetDataColor($row, $idx, $gcvars, $data_color, $alt_flag);
|
|
|
7709 |
}
|
|
|
7710 |
|
|
|
7711 |
// Draw the marker, and error bar (if enabled):
|
|
|
7712 |
if ($this->datatype_swapped_xy) {
|
|
|
7713 |
$this->DrawDot($row, $idx, $dv, $iv, $data_color);
|
|
|
7714 |
if ($this->datatype_error_bars) {
|
|
|
7715 |
$this->DrawXErrorBars($dv, $iv, $this->data[$row][$rec],
|
|
|
7716 |
$this->data[$row][$rec+1], $error_color);
|
|
|
7717 |
}
|
|
|
7718 |
} else {
|
|
|
7719 |
$this->DrawDot($row, $idx, $iv, $dv, $data_color);
|
|
|
7720 |
if ($this->datatype_error_bars) {
|
|
|
7721 |
$this->DrawYErrorBars($iv, $dv, $this->data[$row][$rec],
|
|
|
7722 |
$this->data[$row][$rec+1], $error_color);
|
|
|
7723 |
}
|
|
|
7724 |
}
|
|
|
7725 |
|
|
|
7726 |
// Draw data value labels?
|
|
|
7727 |
if ($do_y_valu_labels) { // Vertical plot
|
|
|
7728 |
$this->DrawDataValueLabel('y', $row, $idx, $iv, $dv, $dv, $dvl);
|
|
|
7729 |
} elseif ($do_x_valu_labels) { // Horizontal plot
|
|
|
7730 |
$this->DrawDataValueLabel('x', $row, $idx, $dv, $iv, $dv, $dvl);
|
|
|
7731 |
}
|
|
|
7732 |
}
|
|
|
7733 |
if ($this->datatype_error_bars) {
|
|
|
7734 |
$rec += 2; // Skip over error bar values, even in missing data case.
|
|
|
7735 |
}
|
|
|
7736 |
}
|
|
|
7737 |
}
|
|
|
7738 |
return TRUE;
|
|
|
7739 |
}
|
|
|
7740 |
|
|
|
7741 |
/**
|
|
|
7742 |
* Draws a thinbarline plot (Thin Bar Line)
|
|
|
7743 |
*
|
|
|
7744 |
* This is the main function for drawing a thinbarline plot, which
|
|
|
7745 |
* is also known as an Impulse plot. Supported data types are
|
|
|
7746 |
* data-data and text-data for vertical plots, and data-data-yx and
|
|
|
7747 |
* text-data-yx for horizontal plots. "iv" is used for the independent
|
|
|
7748 |
* variable (X for vertical plots, Y for horizontal) and "dv" is used
|
|
|
7749 |
* for the dependent variable (Y or X respectively).
|
|
|
7750 |
*
|
|
|
7751 |
* Although this plot type supports multiple data sets, it rarely makes
|
|
|
7752 |
* sense to have more than one, because the lines will overlay.
|
|
|
7753 |
*
|
|
|
7754 |
* @return bool True (False on error if an error handler returns True)
|
|
|
7755 |
*/
|
|
|
7756 |
protected function DrawThinBarLines()
|
|
|
7757 |
{
|
|
|
7758 |
if (!$this->CheckDataType('text-data, data-data, text-data-yx, data-data-yx'))
|
|
|
7759 |
return FALSE;
|
|
|
7760 |
|
|
|
7761 |
$gcvars = array(); // For GetDataColor, which initializes and uses this.
|
|
|
7762 |
|
|
|
7763 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
7764 |
$rec = 1; // Skip record #0 (data label)
|
|
|
7765 |
|
|
|
7766 |
if ($this->datatype_implied) // Implied independent variable values?
|
|
|
7767 |
$iv_now = 0.5 + $row; // Place text-data at 0.5, 1.5, 2.5, etc...
|
|
|
7768 |
else
|
|
|
7769 |
$iv_now = $this->data[$row][$rec++]; // Read it, advance record index
|
|
|
7770 |
|
|
|
7771 |
if ($this->datatype_swapped_xy) {
|
|
|
7772 |
$y_now_pixels = $this->ytr($iv_now);
|
|
|
7773 |
// Draw Y Data labels?
|
|
|
7774 |
if ($this->y_data_label_pos != 'none')
|
|
|
7775 |
$this->DrawYDataLabel($this->data[$row][0], $y_now_pixels, $row);
|
|
|
7776 |
} else {
|
|
|
7777 |
$x_now_pixels = $this->xtr($iv_now);
|
|
|
7778 |
// Draw X Data labels?
|
|
|
7779 |
if ($this->x_data_label_pos != 'none')
|
|
|
7780 |
$this->DrawXDataLabel($this->data[$row][0], $x_now_pixels, $row);
|
|
|
7781 |
}
|
|
|
7782 |
|
|
|
7783 |
// Proceed with dependent values
|
|
|
7784 |
for ($idx = 0; $rec < $this->num_recs[$row]; $rec++, $idx++) {
|
|
|
7785 |
if (is_numeric($dv = $this->data[$row][$rec])) { // Allow for missing data
|
|
|
7786 |
ImageSetThickness($this->img, $this->line_widths[$idx]);
|
|
|
7787 |
|
|
|
7788 |
// Select the color:
|
|
|
7789 |
$this->GetDataColor($row, $idx, $gcvars, $data_color);
|
|
|
7790 |
|
|
|
7791 |
if ($this->datatype_swapped_xy) {
|
|
|
7792 |
// Draw a line from user defined y axis position right (or left) to xtr($dv)
|
|
|
7793 |
ImageLine($this->img, $this->y_axis_x_pixels, $y_now_pixels,
|
|
|
7794 |
$this->xtr($dv), $y_now_pixels, $data_color);
|
|
|
7795 |
} else {
|
|
|
7796 |
// Draw a line from user defined x axis position up (or down) to ytr($dv)
|
|
|
7797 |
ImageLine($this->img, $x_now_pixels, $this->x_axis_y_pixels,
|
|
|
7798 |
$x_now_pixels, $this->ytr($dv), $data_color);
|
|
|
7799 |
}
|
|
|
7800 |
}
|
|
|
7801 |
}
|
|
|
7802 |
}
|
|
|
7803 |
|
|
|
7804 |
ImageSetThickness($this->img, 1);
|
|
|
7805 |
return TRUE;
|
|
|
7806 |
}
|
|
|
7807 |
|
|
|
7808 |
/**
|
|
|
7809 |
* Draws an area or stackedarea plot
|
|
|
7810 |
*
|
|
|
7811 |
* This is the main function for drawing area and stackedarea plots. Both
|
|
|
7812 |
* of these fill the area between lines, but 'stackedarea' is cumulative (like
|
|
|
7813 |
* stackedbars), and 'area' is not. Also 'area' fills from the last data set to
|
|
|
7814 |
* the X axis, and 'stackedarea' fills from the X axis to the first data set.
|
|
|
7815 |
* 'area' and 'stackedarea' plots are identical when there is only one data set.
|
|
|
7816 |
*
|
|
|
7817 |
* Supported data types are data-data and text-data. All Y values must be
|
|
|
7818 |
* >= 0 (with absolute value used if any negative values are found).
|
|
|
7819 |
* Missing data points are not supported (any missing points are set to
|
|
|
7820 |
* 0). All rows must have the same number of Y points, or an error will
|
|
|
7821 |
* be produced.
|
|
|
7822 |
*
|
|
|
7823 |
* @param bool $do_stacked True for stackedarea plot, false or omit for area plot
|
|
|
7824 |
* @return bool True (False on error if an error handler returns True)
|
|
|
7825 |
*/
|
|
|
7826 |
protected function DrawArea($do_stacked = FALSE)
|
|
|
7827 |
{
|
|
|
7828 |
if (!$this->CheckDataType('text-data, data-data'))
|
|
|
7829 |
return FALSE;
|
|
|
7830 |
|
|
|
7831 |
// Validation: Need at least 2 rows; all rows must have same number of columns.
|
|
|
7832 |
if (($n_rows = $this->num_data_rows) < 2) return TRUE;
|
|
|
7833 |
if ($this->records_per_group != min($this->num_recs)) {
|
|
|
7834 |
return $this->PrintError("DrawArea(): Data array must contain the same number"
|
|
|
7835 |
. " of Y values for each X");
|
|
|
7836 |
}
|
|
|
7837 |
|
|
|
7838 |
// Calculate and store device coordinates xd[] and yd[][], and draw the data labels.
|
|
|
7839 |
$n_columns = $this->SetupAreaPlot($do_stacked, $xd, $yd);
|
|
|
7840 |
|
|
|
7841 |
// Draw the filled polygons.
|
|
|
7842 |
// Note data_columns is the number of Y points (columns excluding label and X), and the
|
|
|
7843 |
// number of entries in the yd[] arrays is data_columns+1.
|
|
|
7844 |
$prev_col = 0;
|
|
|
7845 |
for ($col = 1; $col < $n_columns; $col++) { // 1 extra for X axis artificial column
|
|
|
7846 |
$pts = array();
|
|
|
7847 |
// Previous data set forms top (for area) or bottom (for stackedarea):
|
|
|
7848 |
for ($row = 0; $row < $n_rows; $row++) {
|
|
|
7849 |
array_push($pts, $xd[$row], $yd[$row][$prev_col]);
|
|
|
7850 |
}
|
|
|
7851 |
// Current data set forms bottom (for area) or top (for stackedarea):
|
|
|
7852 |
for ($row = $n_rows - 1; $row >= 0; $row--) {
|
|
|
7853 |
array_push($pts, $xd[$row], $yd[$row][$col]);
|
|
|
7854 |
}
|
|
|
7855 |
// Draw it:
|
|
|
7856 |
ImageFilledPolygon($this->img, $pts, $n_rows * 2, $this->ndx_data_colors[$prev_col]);
|
|
|
7857 |
|
|
|
7858 |
$prev_col = $col;
|
|
|
7859 |
}
|
|
|
7860 |
|
|
|
7861 |
// Draw the data borders, if enabled. (After, else the area fills cover parts of it.)
|
|
|
7862 |
if (!empty($this->draw_data_borders))
|
|
|
7863 |
$this->DrawAreaFillBorders($n_columns, $xd, $yd, $do_stacked, FALSE);
|
|
|
7864 |
|
|
|
7865 |
return TRUE;
|
|
|
7866 |
}
|
|
|
7867 |
|
|
|
7868 |
/**
|
|
|
7869 |
* Draws a lines plot, or the lines for a linepoints plot
|
|
|
7870 |
*
|
|
|
7871 |
* This is the main function for drawing a lines plot, and is also used
|
|
|
7872 |
* for a linepoints plot. Vertical and Horizontal plots, and error plots,
|
|
|
7873 |
* are all supported. "iv" is used for the independent variable (X for
|
|
|
7874 |
* vertical plots, Y for horizontal) and "dv" is used for the dependent
|
|
|
7875 |
* variable (Y or X respectively).
|
|
|
7876 |
*
|
|
|
7877 |
* When $paired is true, a linepoints plot is being drawn, and some
|
|
|
7878 |
* elements are suppressed here because they are done elsewhere. See
|
|
|
7879 |
* DrawLinePoints() for details.
|
|
|
7880 |
*
|
|
|
7881 |
* @param bool $paired True if doing a linepoints plots, False or omit for lines plot
|
|
|
7882 |
* @return bool True (False on error if an error handler returns True)
|
|
|
7883 |
*/
|
|
|
7884 |
protected function DrawLines($paired = FALSE)
|
|
|
7885 |
{
|
|
|
7886 |
if (!$this->CheckDataType('text-data, data-data, text-data-yx, data-data-yx, '
|
|
|
7887 |
. 'data-data-error, data-data-yx-error'))
|
|
|
7888 |
return FALSE;
|
|
|
7889 |
|
|
|
7890 |
// Flag array telling if the current point is valid, one element per plot line.
|
|
|
7891 |
// If start_lines[i] is true, then (lastx[i], lasty[i]) is the previous point.
|
|
|
7892 |
if ($this->data_columns > 0)
|
|
|
7893 |
$start_lines = array_fill(0, $this->data_columns, FALSE);
|
|
|
7894 |
|
|
|
7895 |
$gcvars = array(); // For GetDataColor, which initializes and uses this.
|
|
|
7896 |
|
|
|
7897 |
// Data labels, Data Value Labels?
|
|
|
7898 |
if ($this->datatype_swapped_xy) {
|
|
|
7899 |
// Horizontal plots can have X Data Value Labels, Y Axis Data Labels
|
|
|
7900 |
$do_x_axis_labels = FALSE;
|
|
|
7901 |
$do_x_valu_labels = $this->CheckDataValueLabels($this->x_data_label_pos, $dvl);
|
|
|
7902 |
$do_y_axis_labels = $this->y_data_label_pos != 'none';
|
|
|
7903 |
$do_y_valu_labels = FALSE;
|
|
|
7904 |
} else {
|
|
|
7905 |
// Vertical plots can have X Axis Data Labels, Y Data Value Labels
|
|
|
7906 |
$do_x_axis_labels = $this->x_data_label_pos != 'none';
|
|
|
7907 |
$do_x_valu_labels = FALSE;
|
|
|
7908 |
$do_y_axis_labels = FALSE;
|
|
|
7909 |
$do_y_valu_labels = $this->CheckDataValueLabels($this->y_data_label_pos, $dvl);
|
|
|
7910 |
}
|
|
|
7911 |
|
|
|
7912 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
7913 |
$rec = 1; // Skip record #0 (data label)
|
|
|
7914 |
|
|
|
7915 |
if ($this->datatype_implied) // Implied X values?
|
|
|
7916 |
$iv = 0.5 + $row; // Place text-data at X = 0.5, 1.5, 2.5, etc...
|
|
|
7917 |
else
|
|
|
7918 |
$iv = $this->data[$row][$rec++]; // Get actual X value from array
|
|
|
7919 |
|
|
|
7920 |
// Convert independent variable to device coordinates
|
|
|
7921 |
if ($this->datatype_swapped_xy) {
|
|
|
7922 |
$y_now_pixels = $this->ytr($iv);
|
|
|
7923 |
} else {
|
|
|
7924 |
$x_now_pixels = $this->xtr($iv);
|
|
|
7925 |
}
|
|
|
7926 |
|
|
|
7927 |
// Axis data label?
|
|
|
7928 |
if ($do_x_axis_labels)
|
|
|
7929 |
$this->DrawXDataLabel($this->data[$row][0], $x_now_pixels, $row, TRUE);
|
|
|
7930 |
elseif ($do_y_axis_labels)
|
|
|
7931 |
$this->DrawYDataLabel($this->data[$row][0], $y_now_pixels, $row, TRUE);
|
|
|
7932 |
|
|
|
7933 |
// Proceed with dependent values
|
|
|
7934 |
for ($idx = 0; $rec < $this->num_recs[$row]; $idx++) {
|
|
|
7935 |
$line_style = $this->line_styles[$idx];
|
|
|
7936 |
|
|
|
7937 |
// Skip point if data value is missing. Also skip if the whole line is suppressed
|
|
|
7938 |
// with style='none' (useful with linepoints plots)
|
|
|
7939 |
if (is_numeric($dv = $this->data[$row][$rec++]) && $line_style != 'none') {
|
|
|
7940 |
|
|
|
7941 |
// Convert dependent variable to device coordinates
|
|
|
7942 |
if ($this->datatype_swapped_xy) {
|
|
|
7943 |
$x_now_pixels = $this->xtr($dv);
|
|
|
7944 |
} else {
|
|
|
7945 |
$y_now_pixels = $this->ytr($dv);
|
|
|
7946 |
}
|
|
|
7947 |
|
|
|
7948 |
// Select the color(s):
|
|
|
7949 |
if ($this->datatype_error_bars) {
|
|
|
7950 |
$this->GetDataErrorColors($row, $idx, $gcvars, $data_color, $error_color);
|
|
|
7951 |
} else {
|
|
|
7952 |
$this->GetDataColor($row, $idx, $gcvars, $data_color);
|
|
|
7953 |
}
|
|
|
7954 |
|
|
|
7955 |
if ($start_lines[$idx]) {
|
|
|
7956 |
// Set line width, revert it to normal at the end
|
|
|
7957 |
ImageSetThickness($this->img, $this->line_widths[$idx]);
|
|
|
7958 |
|
|
|
7959 |
// Select solid color or dashed line
|
|
|
7960 |
$style = $this->SetDashedStyle($data_color, $line_style == 'dashed');
|
|
|
7961 |
|
|
|
7962 |
// Draw the line segment:
|
|
|
7963 |
ImageLine($this->img, $x_now_pixels, $y_now_pixels,
|
|
|
7964 |
$lastx[$idx], $lasty[$idx], $style);
|
|
|
7965 |
}
|
|
|
7966 |
|
|
|
7967 |
// Draw error bars, but not for linepoints plots, because DrawPoints() does it.
|
|
|
7968 |
if ($this->datatype_error_bars && !$paired) {
|
|
|
7969 |
if ($this->datatype_swapped_xy) {
|
|
|
7970 |
$this->DrawXErrorBars($dv, $iv, $this->data[$row][$rec],
|
|
|
7971 |
$this->data[$row][$rec+1], $error_color);
|
|
|
7972 |
} else {
|
|
|
7973 |
$this->DrawYErrorBars($iv, $dv, $this->data[$row][$rec],
|
|
|
7974 |
$this->data[$row][$rec+1], $error_color);
|
|
|
7975 |
}
|
|
|
7976 |
}
|
|
|
7977 |
|
|
|
7978 |
// Draw data value labels?
|
|
|
7979 |
if ($do_y_valu_labels) // Vertical plot
|
|
|
7980 |
$this->DrawDataValueLabel('y', $row, $idx, $iv, $dv, $dv, $dvl);
|
|
|
7981 |
elseif ($do_x_valu_labels) // Horizontal plot
|
|
|
7982 |
$this->DrawDataValueLabel('x', $row, $idx, $dv, $iv, $dv, $dvl);
|
|
|
7983 |
|
|
|
7984 |
$lastx[$idx] = $x_now_pixels;
|
|
|
7985 |
$lasty[$idx] = $y_now_pixels;
|
|
|
7986 |
$start_lines[$idx] = TRUE;
|
|
|
7987 |
} elseif ($this->draw_broken_lines) {
|
|
|
7988 |
$start_lines[$idx] = FALSE; // Missing point value or line style suppression
|
|
|
7989 |
}
|
|
|
7990 |
if ($this->datatype_error_bars)
|
|
|
7991 |
$rec += 2; // Skip over error bar values, even in missing data case.
|
|
|
7992 |
}
|
|
|
7993 |
}
|
|
|
7994 |
|
|
|
7995 |
ImageSetThickness($this->img, 1); // Revert to original state for lines to be drawn later.
|
|
|
7996 |
return TRUE;
|
|
|
7997 |
}
|
|
|
7998 |
|
|
|
7999 |
/**
|
|
|
8000 |
* Draws a linepoints plot (Lines and Points)
|
|
|
8001 |
*
|
|
|
8002 |
* This is the main function for drawing a linepoints plot. This just uses
|
|
|
8003 |
* DrawLines() to draw the lines, and DrawDots() to draw the points, so it
|
|
|
8004 |
* supports the same data types and variations as they do.
|
|
|
8005 |
*
|
|
|
8006 |
* The argument passed to the two drawing functions tells them not to
|
|
|
8007 |
* duplicate elements, as follows: DrawLines() draws the lines, not the
|
|
|
8008 |
* error bars (even if applicable), and the data labels. DrawDots() draws
|
|
|
8009 |
* the points, the error bars (if applicable), and not the data labels.
|
|
|
8010 |
*
|
|
|
8011 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8012 |
* @since 5.1.3
|
|
|
8013 |
*/
|
|
|
8014 |
protected function DrawLinePoints()
|
|
|
8015 |
{
|
|
|
8016 |
return $this->DrawLines(TRUE) && $this->DrawDots(TRUE);
|
|
|
8017 |
}
|
|
|
8018 |
|
|
|
8019 |
/**
|
|
|
8020 |
* Draws a squared plot (Squared Line, Stepped Line)
|
|
|
8021 |
*
|
|
|
8022 |
* This is the main function for drawing a squared plot. Supported data
|
|
|
8023 |
* types are data-data and text-data. This is based on DrawLines(), with
|
|
|
8024 |
* two line segments drawn for each point.
|
|
|
8025 |
*
|
|
|
8026 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8027 |
*/
|
|
|
8028 |
protected function DrawSquared()
|
|
|
8029 |
{
|
|
|
8030 |
if (!$this->CheckDataType('text-data, data-data'))
|
|
|
8031 |
return FALSE;
|
|
|
8032 |
|
|
|
8033 |
// Flag array telling if the current point is valid, one element per plot line.
|
|
|
8034 |
// If start_lines[i] is true, then (lastx[i], lasty[i]) is the previous point.
|
|
|
8035 |
if ($this->data_columns > 0)
|
|
|
8036 |
$start_lines = array_fill(0, $this->data_columns, FALSE);
|
|
|
8037 |
|
|
|
8038 |
$gcvars = array(); // For GetDataColor, which initializes and uses this.
|
|
|
8039 |
|
|
|
8040 |
// Data Value Labels?
|
|
|
8041 |
$do_dvls = $this->CheckDataValueLabels($this->y_data_label_pos, $dvl);
|
|
|
8042 |
|
|
|
8043 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
8044 |
$record = 1; // Skip record #0 (data label)
|
|
|
8045 |
|
|
|
8046 |
if ($this->datatype_implied) // Implied X values?
|
|
|
8047 |
$x_now = 0.5 + $row; // Place text-data at X = 0.5, 1.5, 2.5, etc...
|
|
|
8048 |
else
|
|
|
8049 |
$x_now = $this->data[$row][$record++]; // Read it, advance record index
|
|
|
8050 |
|
|
|
8051 |
$x_now_pixels = $this->xtr($x_now); // Absolute coordinates
|
|
|
8052 |
|
|
|
8053 |
if ($this->x_data_label_pos != 'none') // Draw X Data labels?
|
|
|
8054 |
$this->DrawXDataLabel($this->data[$row][0], $x_now_pixels, $row);
|
|
|
8055 |
|
|
|
8056 |
// Draw Lines
|
|
|
8057 |
for ($idx = 0; $record < $this->num_recs[$row]; $record++, $idx++) {
|
|
|
8058 |
if (is_numeric($y_now = $this->data[$row][$record])) { // Allow for missing Y data
|
|
|
8059 |
$y_now_pixels = $this->ytr($y_now);
|
|
|
8060 |
|
|
|
8061 |
if ($start_lines[$idx]) {
|
|
|
8062 |
// Set line width, revert it to normal at the end
|
|
|
8063 |
ImageSetThickness($this->img, $this->line_widths[$idx]);
|
|
|
8064 |
|
|
|
8065 |
// Select the color:
|
|
|
8066 |
$this->GetDataColor($row, $idx, $gcvars, $data_color);
|
|
|
8067 |
|
|
|
8068 |
// Select solid color or dashed line
|
|
|
8069 |
$style = $this->SetDashedStyle($data_color, $this->line_styles[$idx] == 'dashed');
|
|
|
8070 |
|
|
|
8071 |
// Draw the step:
|
|
|
8072 |
$y_mid = $lasty[$idx];
|
|
|
8073 |
ImageLine($this->img, $lastx[$idx], $y_mid, $x_now_pixels, $y_mid, $style);
|
|
|
8074 |
ImageLine($this->img, $x_now_pixels, $y_mid, $x_now_pixels, $y_now_pixels, $style);
|
|
|
8075 |
}
|
|
|
8076 |
|
|
|
8077 |
// Draw data value labels?
|
|
|
8078 |
if ($do_dvls)
|
|
|
8079 |
$this->DrawDataValueLabel('y', $row, $idx, $x_now, $y_now, $y_now, $dvl);
|
|
|
8080 |
|
|
|
8081 |
$lastx[$idx] = $x_now_pixels;
|
|
|
8082 |
$lasty[$idx] = $y_now_pixels;
|
|
|
8083 |
$start_lines[$idx] = TRUE;
|
|
|
8084 |
} elseif ($this->draw_broken_lines) { // Y data missing, leave a gap.
|
|
|
8085 |
$start_lines[$idx] = FALSE;
|
|
|
8086 |
}
|
|
|
8087 |
}
|
|
|
8088 |
}
|
|
|
8089 |
|
|
|
8090 |
ImageSetThickness($this->img, 1);
|
|
|
8091 |
return TRUE;
|
|
|
8092 |
}
|
|
|
8093 |
|
|
|
8094 |
/**
|
|
|
8095 |
* Draws a squaredarea or stackedsquaredarea plot (Squared Area)
|
|
|
8096 |
*
|
|
|
8097 |
* This is the main function for drawing squaredarea and stackedsquaredarea plots,
|
|
|
8098 |
* which area a blend of 'squared' plus either 'area' or 'stackedarea'. Supported
|
|
|
8099 |
* data types are data-data and text-data. Missing points are not allowed,
|
|
|
8100 |
* and all data sets must have the same number of points.
|
|
|
8101 |
*
|
|
|
8102 |
* @param bool $do_stacked True for cumulative (stacked), false or omit for unstacked.
|
|
|
8103 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8104 |
*/
|
|
|
8105 |
protected function DrawSquaredArea($do_stacked = FALSE)
|
|
|
8106 |
{
|
|
|
8107 |
if (!$this->CheckDataType('text-data, data-data'))
|
|
|
8108 |
return FALSE;
|
|
|
8109 |
|
|
|
8110 |
// Validation: Need at least 2 rows; all rows must have same number of columns.
|
|
|
8111 |
if (($n_rows = $this->num_data_rows) < 2) return TRUE;
|
|
|
8112 |
if ($this->records_per_group != min($this->num_recs)) {
|
|
|
8113 |
return $this->PrintError("DrawSquaredArea(): Data array must contain the same number"
|
|
|
8114 |
. " of Y values for each X");
|
|
|
8115 |
}
|
|
|
8116 |
|
|
|
8117 |
// Calculate and store device coordinates xd[] and yd[][], and draw the data labels.
|
|
|
8118 |
$n_columns = $this->SetupAreaPlot($do_stacked, $xd, $yd);
|
|
|
8119 |
|
|
|
8120 |
// Draw a filled polygon for each Y column
|
|
|
8121 |
$prev_col = 0;
|
|
|
8122 |
for ($col = 1; $col < $n_columns; $col++) { // 1 extra for X axis artificial column
|
|
|
8123 |
|
|
|
8124 |
// Current data set forms the top. For each point after the first, add 2 points.
|
|
|
8125 |
$x_prev = $xd[0];
|
|
|
8126 |
$y_prev = $yd[0][$col];
|
|
|
8127 |
$pts = array($x_prev, $y_prev); // Bottom left point
|
|
|
8128 |
for ($row = 1; $row < $n_rows; $row++) {
|
|
|
8129 |
$x = $xd[$row];
|
|
|
8130 |
$y = $yd[$row][$col];
|
|
|
8131 |
array_push($pts, $x, $y_prev, $x, $y);
|
|
|
8132 |
$x_prev = $x;
|
|
|
8133 |
$y_prev = $y;
|
|
|
8134 |
}
|
|
|
8135 |
|
|
|
8136 |
// Previous data set forms the bottom. Process right to left.
|
|
|
8137 |
// Note $row is now $n_rows, and it will be stepped back to 0.
|
|
|
8138 |
$row--;
|
|
|
8139 |
$x_prev = $xd[$row];
|
|
|
8140 |
$y_prev = $yd[$row][$prev_col];
|
|
|
8141 |
array_push($pts, $x_prev, $y_prev); // Bottom right point
|
|
|
8142 |
while (--$row >= 0) {
|
|
|
8143 |
$x = $xd[$row];
|
|
|
8144 |
$y = $yd[$row][$prev_col];
|
|
|
8145 |
array_push($pts, $x_prev, $y, $x, $y);
|
|
|
8146 |
$x_prev = $x;
|
|
|
8147 |
$y_prev = $y;
|
|
|
8148 |
}
|
|
|
8149 |
|
|
|
8150 |
// Draw the resulting polygon, which has (2 * (1 + 2*(n_rows-1))) points:
|
|
|
8151 |
ImageFilledPolygon($this->img, $pts, 4 * $n_rows - 2, $this->ndx_data_colors[$prev_col]);
|
|
|
8152 |
$prev_col = $col;
|
|
|
8153 |
}
|
|
|
8154 |
|
|
|
8155 |
// Draw the data borders, if enabled. (After, else the area fills cover parts of it.)
|
|
|
8156 |
if (!empty($this->draw_data_borders))
|
|
|
8157 |
$this->DrawAreaFillBorders($n_columns, $xd, $yd, $do_stacked, TRUE);
|
|
|
8158 |
|
|
|
8159 |
return TRUE;
|
|
|
8160 |
}
|
|
|
8161 |
|
|
|
8162 |
/**
|
|
|
8163 |
* Draws a bars plot (Bar chart)
|
|
|
8164 |
*
|
|
|
8165 |
* This is the main function for drawing a bars plot. Supported data
|
|
|
8166 |
* types are text-data, for vertical plots, and text-data-yx, for
|
|
|
8167 |
* horizontal plots (for which it calls DrawHorizBars()).
|
|
|
8168 |
*
|
|
|
8169 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8170 |
*/
|
|
|
8171 |
protected function DrawBars()
|
|
|
8172 |
{
|
|
|
8173 |
if (!$this->CheckDataType('text-data, text-data-yx'))
|
|
|
8174 |
return FALSE;
|
|
|
8175 |
if ($this->datatype_swapped_xy)
|
|
|
8176 |
return $this->DrawHorizBars();
|
|
|
8177 |
$this->CalcBarWidths(FALSE, TRUE); // Calculate bar widths for unstacked, vertical
|
|
|
8178 |
|
|
|
8179 |
// This is the X offset from the bar group's label center point to the left side of the first bar
|
|
|
8180 |
// in the group. See also CalcBarWidths above.
|
|
|
8181 |
$x_first_bar = ($this->data_columns * $this->record_bar_width) / 2 - $this->bar_adjust_gap;
|
|
|
8182 |
|
|
|
8183 |
$gcvars = array(); // For GetBarColors, which initializes and uses this.
|
|
|
8184 |
|
|
|
8185 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
8186 |
$record = 1; // Skip record #0 (data label)
|
|
|
8187 |
|
|
|
8188 |
$x_now_pixels = $this->xtr(0.5 + $row); // Place text-data at X = 0.5, 1.5, 2.5, etc...
|
|
|
8189 |
|
|
|
8190 |
if ($this->x_data_label_pos != 'none') // Draw X Data labels?
|
|
|
8191 |
$this->DrawXDataLabel($this->data[$row][0], $x_now_pixels, $row);
|
|
|
8192 |
|
|
|
8193 |
// Lower left X of first bar in the group:
|
|
|
8194 |
$x1 = $x_now_pixels - $x_first_bar;
|
|
|
8195 |
|
|
|
8196 |
// Draw the bars in the group:
|
|
|
8197 |
for ($idx = 0; $record < $this->num_recs[$row]; $record++, $idx++) {
|
|
|
8198 |
if (is_numeric($y = $this->data[$row][$record])) { // Allow for missing Y data
|
|
|
8199 |
$x2 = $x1 + $this->actual_bar_width;
|
|
|
8200 |
|
|
|
8201 |
if (($upgoing_bar = $y >= $this->x_axis_position)) {
|
|
|
8202 |
$y1 = $this->ytr($y);
|
|
|
8203 |
$y2 = $this->x_axis_y_pixels;
|
|
|
8204 |
} else {
|
|
|
8205 |
$y1 = $this->x_axis_y_pixels;
|
|
|
8206 |
$y2 = $this->ytr($y);
|
|
|
8207 |
}
|
|
|
8208 |
|
|
|
8209 |
// Select the colors:
|
|
|
8210 |
$this->GetBarColors($row, $idx, $gcvars, $data_color, $shade_color, $border_color);
|
|
|
8211 |
|
|
|
8212 |
// Draw the bar, and the shade or border:
|
|
|
8213 |
$this->DrawBar($row, $idx, $x1, $y1, $x2, $y2, $data_color, $shade_color, $border_color);
|
|
|
8214 |
|
|
|
8215 |
// Draw optional data value label above or below the bar:
|
|
|
8216 |
if ($this->y_data_label_pos == 'plotin') {
|
|
|
8217 |
$dvl['x_offset'] = ($idx + 0.5) * $this->record_bar_width - $x_first_bar;
|
|
|
8218 |
if ($upgoing_bar) {
|
|
|
8219 |
$dvl['v_align'] = 'bottom';
|
|
|
8220 |
$dvl['y_offset'] = -5 - $this->shading;
|
|
|
8221 |
} else {
|
|
|
8222 |
$dvl['v_align'] = 'top';
|
|
|
8223 |
$dvl['y_offset'] = 2;
|
|
|
8224 |
}
|
|
|
8225 |
$this->DrawDataValueLabel('y', $row, $idx, $row+0.5, $y, $y, $dvl);
|
|
|
8226 |
}
|
|
|
8227 |
}
|
|
|
8228 |
// Step to next bar in group:
|
|
|
8229 |
$x1 += $this->record_bar_width;
|
|
|
8230 |
}
|
|
|
8231 |
}
|
|
|
8232 |
return TRUE;
|
|
|
8233 |
}
|
|
|
8234 |
|
|
|
8235 |
/**
|
|
|
8236 |
* Draws a Horizontal Bar chart
|
|
|
8237 |
*
|
|
|
8238 |
* This is called from DrawBars() when the data type indicates a
|
|
|
8239 |
* horizontal plot.
|
|
|
8240 |
*
|
|
|
8241 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8242 |
* @since 5.1.2
|
|
|
8243 |
*/
|
|
|
8244 |
protected function DrawHorizBars()
|
|
|
8245 |
{
|
|
|
8246 |
$this->CalcBarWidths(FALSE, FALSE); // Calculate bar widths for unstacked, vertical
|
|
|
8247 |
|
|
|
8248 |
// This is the Y offset from the bar group's label center point to the bottom of the first bar
|
|
|
8249 |
// in the group. See also CalcBarWidths above.
|
|
|
8250 |
$y_first_bar = ($this->data_columns * $this->record_bar_width) / 2 - $this->bar_adjust_gap;
|
|
|
8251 |
|
|
|
8252 |
$gcvars = array(); // For GetBarColors, which initializes and uses this.
|
|
|
8253 |
|
|
|
8254 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
8255 |
$record = 1; // Skip record #0 (data label)
|
|
|
8256 |
|
|
|
8257 |
$y_now_pixels = $this->ytr(0.5 + $row); // Place bars at Y=0.5, 1.5, 2.5, etc...
|
|
|
8258 |
|
|
|
8259 |
if ($this->y_data_label_pos != 'none') // Draw Y Data Labels?
|
|
|
8260 |
$this->DrawYDataLabel($this->data[$row][0], $y_now_pixels, $row);
|
|
|
8261 |
|
|
|
8262 |
// Lower left Y of first bar in the group:
|
|
|
8263 |
$y1 = $y_now_pixels + $y_first_bar;
|
|
|
8264 |
|
|
|
8265 |
// Draw the bars in the group:
|
|
|
8266 |
for ($idx = 0; $record < $this->num_recs[$row]; $record++, $idx++) {
|
|
|
8267 |
if (is_numeric($x = $this->data[$row][$record])) { // Allow for missing X data
|
|
|
8268 |
$y2 = $y1 - $this->actual_bar_width;
|
|
|
8269 |
|
|
|
8270 |
if (($rightwards_bar = $x >= $this->y_axis_position)) {
|
|
|
8271 |
$x1 = $this->xtr($x);
|
|
|
8272 |
$x2 = $this->y_axis_x_pixels;
|
|
|
8273 |
} else {
|
|
|
8274 |
$x1 = $this->y_axis_x_pixels;
|
|
|
8275 |
$x2 = $this->xtr($x);
|
|
|
8276 |
}
|
|
|
8277 |
|
|
|
8278 |
// Select the colors:
|
|
|
8279 |
$this->GetBarColors($row, $idx, $gcvars, $data_color, $shade_color, $border_color);
|
|
|
8280 |
|
|
|
8281 |
// Draw the bar, and the shade or border:
|
|
|
8282 |
$this->DrawBar($row, $idx, $x1, $y1, $x2, $y2, $data_color, $shade_color, $border_color);
|
|
|
8283 |
|
|
|
8284 |
// Draw optional data value label to the right or left of the bar:
|
|
|
8285 |
if ($this->x_data_label_pos == 'plotin') {
|
|
|
8286 |
$dvl['y_offset'] = $y_first_bar - ($idx + 0.5) * $this->record_bar_width;
|
|
|
8287 |
if ($rightwards_bar) {
|
|
|
8288 |
$dvl['h_align'] = 'left';
|
|
|
8289 |
$dvl['x_offset'] = 5 + $this->shading;
|
|
|
8290 |
} else {
|
|
|
8291 |
$dvl['h_align'] = 'right';
|
|
|
8292 |
$dvl['x_offset'] = -2;
|
|
|
8293 |
}
|
|
|
8294 |
$this->DrawDataValueLabel('x', $row, $idx, $x, $row+0.5, $x, $dvl);
|
|
|
8295 |
}
|
|
|
8296 |
}
|
|
|
8297 |
// Step to next bar in group:
|
|
|
8298 |
$y1 -= $this->record_bar_width;
|
|
|
8299 |
}
|
|
|
8300 |
}
|
|
|
8301 |
return TRUE;
|
|
|
8302 |
}
|
|
|
8303 |
|
|
|
8304 |
/**
|
|
|
8305 |
* Draws a stackedbars plot (Stacked Bar chart)
|
|
|
8306 |
*
|
|
|
8307 |
* This is the main function for drawing a stackedbars plot. Supported
|
|
|
8308 |
* data types are text-data, for vertical plots, and text-data-yx, for
|
|
|
8309 |
* horizontal plots (for which it calls DrawHorizStackedBars()).
|
|
|
8310 |
* Original stacked bars idea by Laurent Kruk < lolok at users.sourceforge.net >
|
|
|
8311 |
*
|
|
|
8312 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8313 |
*/
|
|
|
8314 |
protected function DrawStackedBars()
|
|
|
8315 |
{
|
|
|
8316 |
if (!$this->CheckDataType('text-data, text-data-yx'))
|
|
|
8317 |
return FALSE;
|
|
|
8318 |
if ($this->datatype_swapped_xy)
|
|
|
8319 |
return $this->DrawHorizStackedBars();
|
|
|
8320 |
$this->CalcBarWidths(TRUE, TRUE); // Calculate bar widths for stacked, vertical
|
|
|
8321 |
|
|
|
8322 |
// This is the X offset from the bar's label center point to the left side of the bar.
|
|
|
8323 |
$x_first_bar = $this->record_bar_width / 2 - $this->bar_adjust_gap;
|
|
|
8324 |
|
|
|
8325 |
$gcvars = array(); // For GetBarColors, which initializes and uses this.
|
|
|
8326 |
|
|
|
8327 |
// Determine if any data labels are on:
|
|
|
8328 |
$data_labels_within = ($this->y_data_label_pos == 'plotstack');
|
|
|
8329 |
$data_labels_end = $data_labels_within || ($this->y_data_label_pos == 'plotin');
|
|
|
8330 |
$data_label_y_offset = -5 - $this->shading; // For upward labels only.
|
|
|
8331 |
|
|
|
8332 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
8333 |
$record = 1; // Skip record #0 (data label)
|
|
|
8334 |
|
|
|
8335 |
$x_now_pixels = $this->xtr(0.5 + $row); // Place text-data at X = 0.5, 1.5, 2.5, etc...
|
|
|
8336 |
|
|
|
8337 |
if ($this->x_data_label_pos != 'none') // Draw X Data labels?
|
|
|
8338 |
$this->DrawXDataLabel($this->data[$row][0], $x_now_pixels, $row);
|
|
|
8339 |
|
|
|
8340 |
// Determine bar direction based on 1st non-zero value. Note the bar direction is
|
|
|
8341 |
// based on zero, not the axis value.
|
|
|
8342 |
$n_recs = $this->num_recs[$row];
|
|
|
8343 |
$upward = TRUE; // Initialize this for the case of all segments = 0
|
|
|
8344 |
for ($i = $record; $i < $n_recs; $i++) {
|
|
|
8345 |
if (is_numeric($this_y = $this->data[$row][$i]) && $this_y != 0) {
|
|
|
8346 |
$upward = ($this_y > 0);
|
|
|
8347 |
break;
|
|
|
8348 |
}
|
|
|
8349 |
}
|
|
|
8350 |
|
|
|
8351 |
$x1 = $x_now_pixels - $x_first_bar; // Left X of bars in this stack
|
|
|
8352 |
$x2 = $x1 + $this->actual_bar_width; // Right X of bars in this stack
|
|
|
8353 |
$wy1 = 0; // World coordinates Y1, current sum of values
|
|
|
8354 |
$wy2 = $this->x_axis_position; // World coordinates Y2, last drawn value
|
|
|
8355 |
|
|
|
8356 |
// Draw bar segments and labels in this stack.
|
|
|
8357 |
$first = TRUE;
|
|
|
8358 |
for ($idx = 0; $record < $n_recs; $record++, $idx++) {
|
|
|
8359 |
|
|
|
8360 |
// Skip missing Y values. Process Y=0 values due to special case of moved axis.
|
|
|
8361 |
if (is_numeric($this_y = $this->data[$row][$record])) {
|
|
|
8362 |
|
|
|
8363 |
$wy1 += $this_y; // Keep the running total for this bar stack
|
|
|
8364 |
|
|
|
8365 |
// Draw the segment only if it will increase the stack height (ignore if wrong direction):
|
|
|
8366 |
if (($upward && $wy1 > $wy2) || (!$upward && $wy2 > $wy1)) {
|
|
|
8367 |
|
|
|
8368 |
$y1 = $this->ytr($wy1); // Convert to device coordinates. $y1 is outermost value.
|
|
|
8369 |
$y2 = $this->ytr($wy2); // $y2 is innermost (closest to axis).
|
|
|
8370 |
|
|
|
8371 |
// Select the colors:
|
|
|
8372 |
$this->GetBarColors($row, $idx, $gcvars, $data_color, $shade_color, $border_color);
|
|
|
8373 |
|
|
|
8374 |
// Draw the bar, and the shade or border:
|
|
|
8375 |
$this->DrawBar($row, $idx, $x1, $y1, $x2, $y2,
|
|
|
8376 |
$data_color, $shade_color, $border_color,
|
|
|
8377 |
// Only shade the top for upward bars, or the first segment of downward bars:
|
|
|
8378 |
$upward || $first, TRUE);
|
|
|
8379 |
|
|
|
8380 |
// Draw optional data label for this bar segment just inside the end.
|
|
|
8381 |
// Text value is the current Y, but position is the cumulative Y.
|
|
|
8382 |
// The label is only drawn if it fits in the segment height |y2-y1|.
|
|
|
8383 |
if ($data_labels_within) {
|
|
|
8384 |
$dvl['min_height'] = abs($y1 - $y2);
|
|
|
8385 |
if ($upward) {
|
|
|
8386 |
$dvl['v_align'] = 'top';
|
|
|
8387 |
$dvl['y_offset'] = 3;
|
|
|
8388 |
} else {
|
|
|
8389 |
$dvl['v_align'] = 'bottom';
|
|
|
8390 |
$dvl['y_offset'] = -3;
|
|
|
8391 |
}
|
|
|
8392 |
$this->DrawDataValueLabel('y', $row, $idx, $row+0.5, $wy1, $this_y, $dvl);
|
|
|
8393 |
}
|
|
|
8394 |
// Mark the new end of the bar, conditional on segment height > 0.
|
|
|
8395 |
$wy2 = $wy1;
|
|
|
8396 |
$first = FALSE;
|
|
|
8397 |
}
|
|
|
8398 |
}
|
|
|
8399 |
} // end for
|
|
|
8400 |
|
|
|
8401 |
// Draw optional data label above the bar with the total value.
|
|
|
8402 |
// Value is wy1 (total value), but position is wy2 (end of the bar stack).
|
|
|
8403 |
// These differ only with wrong-direction segments, or a stack completely clipped by the axis.
|
|
|
8404 |
if ($data_labels_end) {
|
|
|
8405 |
$dvl['min_height'] = NULL; // Might be set above, but the whole array might not exist.
|
|
|
8406 |
if ($upward) {
|
|
|
8407 |
$dvl['v_align'] = 'bottom';
|
|
|
8408 |
$dvl['y_offset'] = $data_label_y_offset;
|
|
|
8409 |
} else {
|
|
|
8410 |
$dvl['v_align'] = 'top';
|
|
|
8411 |
$dvl['y_offset'] = 5;
|
|
|
8412 |
}
|
|
|
8413 |
$this->DrawDataValueLabel('y', $row, NULL, $row+0.5, $wy2, $wy1, $dvl);
|
|
|
8414 |
}
|
|
|
8415 |
} // end for
|
|
|
8416 |
return TRUE;
|
|
|
8417 |
}
|
|
|
8418 |
|
|
|
8419 |
/**
|
|
|
8420 |
* Draws a Horizontal Stacked Bar chart
|
|
|
8421 |
*
|
|
|
8422 |
* This is called from DrawStackedBars() when the data type indicates a
|
|
|
8423 |
* horizontal plot.
|
|
|
8424 |
*
|
|
|
8425 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8426 |
* @since 5.1.3
|
|
|
8427 |
*/
|
|
|
8428 |
protected function DrawHorizStackedBars()
|
|
|
8429 |
{
|
|
|
8430 |
$this->CalcBarWidths(TRUE, FALSE); // Calculate bar widths for stacked, horizontal
|
|
|
8431 |
|
|
|
8432 |
// This is the Y offset from the bar's label center point to the bottom of the bar
|
|
|
8433 |
$y_first_bar = $this->record_bar_width / 2 - $this->bar_adjust_gap;
|
|
|
8434 |
|
|
|
8435 |
$gcvars = array(); // For GetBarColors, which initializes and uses this.
|
|
|
8436 |
|
|
|
8437 |
// Determine if any data labels are on:
|
|
|
8438 |
$data_labels_within = ($this->x_data_label_pos == 'plotstack');
|
|
|
8439 |
$data_labels_end = $data_labels_within || ($this->x_data_label_pos == 'plotin');
|
|
|
8440 |
$data_label_x_offset = 5 + $this->shading; // For rightward labels only
|
|
|
8441 |
|
|
|
8442 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
8443 |
$record = 1; // Skip record #0 (data label)
|
|
|
8444 |
|
|
|
8445 |
$y_now_pixels = $this->ytr(0.5 + $row); // Place bars at Y=0.5, 1.5, 2.5, etc...
|
|
|
8446 |
|
|
|
8447 |
if ($this->y_data_label_pos != 'none') // Draw Y Data labels?
|
|
|
8448 |
$this->DrawYDataLabel($this->data[$row][0], $y_now_pixels, $row);
|
|
|
8449 |
|
|
|
8450 |
// Determine bar direction based on 1st non-zero value. Note the bar direction is
|
|
|
8451 |
// based on zero, not the axis value.
|
|
|
8452 |
$n_recs = $this->num_recs[$row];
|
|
|
8453 |
$rightward = TRUE; // Initialize this for the case of all segments = 0
|
|
|
8454 |
for ($i = $record; $i < $n_recs; $i++) {
|
|
|
8455 |
if (is_numeric($this_x = $this->data[$row][$i]) && $this_x != 0) {
|
|
|
8456 |
$rightward = ($this_x > 0);
|
|
|
8457 |
break;
|
|
|
8458 |
}
|
|
|
8459 |
}
|
|
|
8460 |
|
|
|
8461 |
// Lower left and upper left Y of the bars in this stack:
|
|
|
8462 |
$y1 = $y_now_pixels + $y_first_bar; // Lower Y of bars in this stack
|
|
|
8463 |
$y2 = $y1 - $this->actual_bar_width; // Upper Y of bars in this stack
|
|
|
8464 |
$wx1 = 0; // World coordinates X1, current sum of values
|
|
|
8465 |
$wx2 = $this->y_axis_position; // World coordinates X2, last drawn value
|
|
|
8466 |
|
|
|
8467 |
// Draw bar segments and labels in this stack.
|
|
|
8468 |
$first = TRUE;
|
|
|
8469 |
for ($idx = 0; $record < $this->num_recs[$row]; $record++, $idx++) {
|
|
|
8470 |
|
|
|
8471 |
// Skip missing X values. Process X=0 values due to special case of moved axis.
|
|
|
8472 |
if (is_numeric($this_x = $this->data[$row][$record])) {
|
|
|
8473 |
|
|
|
8474 |
$wx1 += $this_x; // Keep the running total for this bar stack
|
|
|
8475 |
|
|
|
8476 |
// Draw the segment only if it will increase the stack length (ignore if wrong direction):
|
|
|
8477 |
if (($rightward && $wx1 > $wx2) || (!$rightward && $wx2 > $wx1)) {
|
|
|
8478 |
|
|
|
8479 |
$x1 = $this->xtr($wx1); // Convert to device coordinates. $x1 is outermost value.
|
|
|
8480 |
$x2 = $this->xtr($wx2); // $x2 is innermost (closest to axis).
|
|
|
8481 |
|
|
|
8482 |
// Select the colors:
|
|
|
8483 |
$this->GetBarColors($row, $idx, $gcvars, $data_color, $shade_color, $border_color);
|
|
|
8484 |
|
|
|
8485 |
// Draw the bar, and the shade or border:
|
|
|
8486 |
$this->DrawBar($row, $idx, $x1, $y1, $x2, $y2,
|
|
|
8487 |
$data_color, $shade_color, $border_color,
|
|
|
8488 |
// Only shade the side for rightward bars, or the first segment of leftward bars:
|
|
|
8489 |
TRUE, $rightward || $first);
|
|
|
8490 |
|
|
|
8491 |
// Draw optional data label for this bar segment just inside the end.
|
|
|
8492 |
// Text value is the current X, but position is the cumulative X.
|
|
|
8493 |
// The label is only drawn if it fits in the segment width |x2-x1|.
|
|
|
8494 |
if ($data_labels_within) {
|
|
|
8495 |
$dvl['min_width'] = abs($x1 - $x2);
|
|
|
8496 |
if ($rightward) {
|
|
|
8497 |
$dvl['h_align'] = 'right';
|
|
|
8498 |
$dvl['x_offset'] = -3;
|
|
|
8499 |
} else {
|
|
|
8500 |
$dvl['h_align'] = 'left';
|
|
|
8501 |
$dvl['x_offset'] = 3;
|
|
|
8502 |
}
|
|
|
8503 |
$this->DrawDataValueLabel('x', $row, $idx, $wx1, $row+0.5, $this_x, $dvl);
|
|
|
8504 |
}
|
|
|
8505 |
// Mark the new end of the bar, conditional on segment width > 0.
|
|
|
8506 |
$wx2 = $wx1;
|
|
|
8507 |
$first = FALSE;
|
|
|
8508 |
}
|
|
|
8509 |
}
|
|
|
8510 |
} // end for
|
|
|
8511 |
|
|
|
8512 |
// Draw optional data label right of the bar with the total value.
|
|
|
8513 |
// Value is wx1 (total value), but position is wx2 (end of the bar stack).
|
|
|
8514 |
// These differ only with wrong-direction segments, or a stack completely clipped by the axis.
|
|
|
8515 |
if ($data_labels_end) {
|
|
|
8516 |
$dvl['min_width'] = NULL; // Might be set above, but the whole array might not exist.
|
|
|
8517 |
if ($rightward) {
|
|
|
8518 |
$dvl['h_align'] = 'left';
|
|
|
8519 |
$dvl['x_offset'] = $data_label_x_offset;
|
|
|
8520 |
} else {
|
|
|
8521 |
$dvl['h_align'] = 'right';
|
|
|
8522 |
$dvl['x_offset'] = -5;
|
|
|
8523 |
}
|
|
|
8524 |
$this->DrawDataValueLabel('x', $row, NULL, $wx2, $row+0.5, $wx1, $dvl);
|
|
|
8525 |
}
|
|
|
8526 |
} // end for
|
|
|
8527 |
return TRUE;
|
|
|
8528 |
}
|
|
|
8529 |
|
|
|
8530 |
/**
|
|
|
8531 |
* Draws an ohlc, candlesticks, or candlesticks2 plot ("Open/High/Low/Close" OHLC plot)
|
|
|
8532 |
*
|
|
|
8533 |
* This is the main function for drawing an ohlc, candlesticks, or
|
|
|
8534 |
* candlesticks2 plot, which are typically used to show price changes in
|
|
|
8535 |
* financial instruments. Supported data types are text-data and
|
|
|
8536 |
* data-data, each with exactly 4 Y values per row: Open, High, Low, and
|
|
|
8537 |
* Close. The 2 parameters select one of the 3 plot subtypes.
|
|
|
8538 |
*
|
|
|
8539 |
* @param bool $draw_candles True to draw a candlestick plot, False to draw an ohlc plot
|
|
|
8540 |
* @param bool $always_fill True to always fill, False or omit to fill only when closing down
|
|
|
8541 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8542 |
* @since 5.3.0
|
|
|
8543 |
*/
|
|
|
8544 |
protected function DrawOHLC($draw_candles, $always_fill = FALSE)
|
|
|
8545 |
{
|
|
|
8546 |
if (!$this->CheckDataType('text-data, data-data'))
|
|
|
8547 |
return FALSE;
|
|
|
8548 |
if ($this->data_columns != 4) // early error check (more inside the loop)
|
|
|
8549 |
return $this->PrintError("DrawOHLC(): rows must have 4 values.");
|
|
|
8550 |
|
|
|
8551 |
// Assign name of GD function to draw candlestick bodies for stocks that close up.
|
|
|
8552 |
$draw_body_close_up = $always_fill ? 'imagefilledrectangle' : 'imagerectangle';
|
|
|
8553 |
|
|
|
8554 |
// Calculate the half-width of the candle body, or length of the tick marks.
|
|
|
8555 |
// This is scaled based on the plot density, but within tight limits.
|
|
|
8556 |
$dw = max($this->ohlc_min_width, min($this->ohlc_max_width,
|
|
|
8557 |
(int)($this->ohlc_frac_width * $this->plot_area_width / $this->num_data_rows)));
|
|
|
8558 |
|
|
|
8559 |
// Get line widths to use: index 0 for body/stroke, 1 for wick/tick.
|
|
|
8560 |
list($body_thickness, $wick_thickness) = $this->line_widths;
|
|
|
8561 |
|
|
|
8562 |
$gcvars = array(); // For GetDataColor, which initializes and uses this.
|
|
|
8563 |
|
|
|
8564 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
8565 |
$record = 1; // Skip record #0 (data label)
|
|
|
8566 |
|
|
|
8567 |
if ($this->datatype_implied) // Implied X values?
|
|
|
8568 |
$x_now = 0.5 + $row; // Place text-data at X = 0.5, 1.5, 2.5, etc...
|
|
|
8569 |
else
|
|
|
8570 |
$x_now = $this->data[$row][$record++]; // Read it, advance record index
|
|
|
8571 |
|
|
|
8572 |
$x_now_pixels = $this->xtr($x_now); // Convert X to device coordinates
|
|
|
8573 |
$x_left = $x_now_pixels - $dw;
|
|
|
8574 |
$x_right = $x_now_pixels + $dw;
|
|
|
8575 |
|
|
|
8576 |
if ($this->x_data_label_pos != 'none') // Draw X Data labels?
|
|
|
8577 |
$this->DrawXDataLabel($this->data[$row][0], $x_now_pixels, $row);
|
|
|
8578 |
|
|
|
8579 |
// Each row must have 4 values, but skip rows with non-numeric entries.
|
|
|
8580 |
if ($this->num_recs[$row] - $record != 4) {
|
|
|
8581 |
return $this->PrintError("DrawOHLC(): row $row must have 4 values.");
|
|
|
8582 |
}
|
|
|
8583 |
if (!is_numeric($yo = $this->data[$row][$record++])
|
|
|
8584 |
|| !is_numeric($yh = $this->data[$row][$record++])
|
|
|
8585 |
|| !is_numeric($yl = $this->data[$row][$record++])
|
|
|
8586 |
|| !is_numeric($yc = $this->data[$row][$record++])) {
|
|
|
8587 |
continue;
|
|
|
8588 |
}
|
|
|
8589 |
|
|
|
8590 |
// Set device coordinates for each value and direction flag:
|
|
|
8591 |
$yh_pixels = $this->ytr($yh);
|
|
|
8592 |
$yl_pixels = $this->ytr($yl);
|
|
|
8593 |
$yc_pixels = $this->ytr($yc);
|
|
|
8594 |
$yo_pixels = $this->ytr($yo);
|
|
|
8595 |
$closed_up = $yc >= $yo;
|
|
|
8596 |
|
|
|
8597 |
// Get data colors and line thicknesses:
|
|
|
8598 |
if ($closed_up) {
|
|
|
8599 |
$this->GetDataColor($row, 1, $gcvars, $body_color); // Color 1 for body, closing up
|
|
|
8600 |
$this->GetDataColor($row, 3, $gcvars, $ext_color); // Color 3 for wicks/ticks
|
|
|
8601 |
} else {
|
|
|
8602 |
$this->GetDataColor($row, 0, $gcvars, $body_color); // Color 0 for body, closing down
|
|
|
8603 |
$this->GetDataColor($row, 2, $gcvars, $ext_color); // Color 2 for wicks/ticks
|
|
|
8604 |
}
|
|
|
8605 |
imagesetthickness($this->img, $body_thickness);
|
|
|
8606 |
|
|
|
8607 |
if ($draw_candles) {
|
|
|
8608 |
// Note: Unlike ImageFilledRectangle, ImageRectangle 'requires' its arguments in
|
|
|
8609 |
// order with upper left corner first.
|
|
|
8610 |
if ($closed_up) {
|
|
|
8611 |
$yb1_pixels = $yc_pixels; // Upper body Y
|
|
|
8612 |
$yb2_pixels = $yo_pixels; // Lower body Y
|
|
|
8613 |
$draw_body = $draw_body_close_up;
|
|
|
8614 |
// Avoid a PHP/GD bug resulting in "T"-shaped ends to zero height unfilled rectangle:
|
|
|
8615 |
if ($yb1_pixels == $yb2_pixels)
|
|
|
8616 |
$draw_body = 'imagefilledrectangle';
|
|
|
8617 |
} else {
|
|
|
8618 |
$yb1_pixels = $yo_pixels;
|
|
|
8619 |
$yb2_pixels = $yc_pixels;
|
|
|
8620 |
$draw_body = 'imagefilledrectangle';
|
|
|
8621 |
}
|
|
|
8622 |
|
|
|
8623 |
// Draw candle body
|
|
|
8624 |
$draw_body($this->img, $x_left, $yb1_pixels, $x_right, $yb2_pixels, $body_color);
|
|
|
8625 |
|
|
|
8626 |
// Draw upper and lower wicks, if they have height. (In device coords, that's dY<0)
|
|
|
8627 |
imagesetthickness($this->img, $wick_thickness);
|
|
|
8628 |
if ($yh_pixels < $yb1_pixels) {
|
|
|
8629 |
imageline($this->img, $x_now_pixels, $yb1_pixels, $x_now_pixels, $yh_pixels, $ext_color);
|
|
|
8630 |
}
|
|
|
8631 |
if ($yl_pixels > $yb2_pixels) {
|
|
|
8632 |
imageline($this->img, $x_now_pixels, $yb2_pixels, $x_now_pixels, $yl_pixels, $ext_color);
|
|
|
8633 |
}
|
|
|
8634 |
} else {
|
|
|
8635 |
// Basic OHLC
|
|
|
8636 |
imageline($this->img, $x_now_pixels, $yl_pixels, $x_now_pixels, $yh_pixels, $body_color);
|
|
|
8637 |
imagesetthickness($this->img, $wick_thickness);
|
|
|
8638 |
imageline($this->img, $x_left, $yo_pixels, $x_now_pixels, $yo_pixels, $ext_color);
|
|
|
8639 |
imageline($this->img, $x_right, $yc_pixels, $x_now_pixels, $yc_pixels, $ext_color);
|
|
|
8640 |
}
|
|
|
8641 |
imagesetthickness($this->img, 1);
|
|
|
8642 |
$this->DoCallback('data_points', 'rect', $row, 0, $x_left, $yh_pixels, $x_right, $yl_pixels);
|
|
|
8643 |
}
|
|
|
8644 |
return TRUE;
|
|
|
8645 |
}
|
|
|
8646 |
|
|
|
8647 |
/**
|
|
|
8648 |
* Draws a bubbles plot (Bubble chart)
|
|
|
8649 |
*
|
|
|
8650 |
* This is the main function for drawing a bubbles plot, which is a
|
|
|
8651 |
* scatter plot with bubble size showing the Z value.
|
|
|
8652 |
* Supported data type is data-data-xyz with rows of (label, X, Y1, Z1, ...)
|
|
|
8653 |
* with multiple data sets (Y, Z pairs) supported.
|
|
|
8654 |
*
|
|
|
8655 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8656 |
* @since 5.5.0
|
|
|
8657 |
*/
|
|
|
8658 |
protected function DrawBubbles()
|
|
|
8659 |
{
|
|
|
8660 |
if (!$this->CheckDataType('data-data-xyz'))
|
|
|
8661 |
return FALSE;
|
|
|
8662 |
|
|
|
8663 |
$gcvars = array(); // For GetDataColor, which initializes and uses this.
|
|
|
8664 |
|
|
|
8665 |
// Calculate or use supplied maximum bubble size:
|
|
|
8666 |
if (isset($this->bubbles_max_size)) {
|
|
|
8667 |
$bubbles_max_size = $this->bubbles_max_size;
|
|
|
8668 |
} else {
|
|
|
8669 |
$bubbles_max_size = min($this->plot_area_width, $this->plot_area_height) / 12;
|
|
|
8670 |
}
|
|
|
8671 |
|
|
|
8672 |
// Calculate bubble scale parameters. Bubble_size(z) = $f_size * $z + $b_size
|
|
|
8673 |
if ($this->max_z <= $this->min_z) { // Regressive case, no Z range.
|
|
|
8674 |
$f_size = 0;
|
|
|
8675 |
$b_size = ($bubbles_max_size + $this->bubbles_min_size) / 2; // Use average size of all bubbles
|
|
|
8676 |
} else {
|
|
|
8677 |
$f_size = ($bubbles_max_size - $this->bubbles_min_size) / ($this->max_z - $this->min_z);
|
|
|
8678 |
$b_size = $bubbles_max_size - $f_size * $this->max_z;
|
|
|
8679 |
}
|
|
|
8680 |
|
|
|
8681 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
8682 |
$rec = 1; // Skip record #0 (data label)
|
|
|
8683 |
$x = $this->xtr($this->data[$row][$rec++]); // Get X value from data array.
|
|
|
8684 |
|
|
|
8685 |
// Draw X Data labels?
|
|
|
8686 |
if ($this->x_data_label_pos != 'none')
|
|
|
8687 |
$this->DrawXDataLabel($this->data[$row][0], $x, $row, TRUE);
|
|
|
8688 |
|
|
|
8689 |
// Proceed with Y,Z values
|
|
|
8690 |
for ($idx = 0; $rec < $this->num_recs[$row]; $rec += 2, $idx++) {
|
|
|
8691 |
|
|
|
8692 |
if (is_numeric($y_now = $this->data[$row][$rec])) { //Allow for missing Y data
|
|
|
8693 |
$y = $this->ytr($y_now);
|
|
|
8694 |
$z = (double)$this->data[$row][$rec+1]; // Z is required if Y is present.
|
|
|
8695 |
$size = (int)($f_size * $z + $b_size); // Calculate bubble size
|
|
|
8696 |
|
|
|
8697 |
// Select the color:
|
|
|
8698 |
$this->GetDataColor($row, $idx, $gcvars, $data_color);
|
|
|
8699 |
|
|
|
8700 |
// Draw the bubble:
|
|
|
8701 |
ImageFilledEllipse($this->img, $x, $y, $size, $size, $data_color);
|
|
|
8702 |
$this->DoCallback('data_points', 'circle', $row, $idx, $x, $y, $size);
|
|
|
8703 |
}
|
|
|
8704 |
}
|
|
|
8705 |
}
|
|
|
8706 |
return TRUE;
|
|
|
8707 |
}
|
|
|
8708 |
|
|
|
8709 |
/**
|
|
|
8710 |
* Draws a boxes plot (Box Plot or Box and Whisker plot)
|
|
|
8711 |
*
|
|
|
8712 |
* This is the main function for drawing a boxes plot. Supported data
|
|
|
8713 |
* types are text-data and data-data, each with 5 or more Y values per
|
|
|
8714 |
* row. The first 5 values are Ymin, YQ1, Ymid, YQ3, Ymax. Any additional
|
|
|
8715 |
* values are outliers. PHPlot requires Ymin <= YQ1 <= Ymin <= YQ3 <= Ymax
|
|
|
8716 |
* but does not assume anything about specific values (quartile, median).
|
|
|
8717 |
*
|
|
|
8718 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8719 |
* @since 6.1.0
|
|
|
8720 |
*/
|
|
|
8721 |
protected function DrawBoxes()
|
|
|
8722 |
{
|
|
|
8723 |
if (!$this->CheckDataType('text-data, data-data'))
|
|
|
8724 |
return FALSE;
|
|
|
8725 |
if ($this->data_columns < 5) // early error check (more inside the loop)
|
|
|
8726 |
return $this->PrintError("DrawBoxes(): rows must have 5 or more values.");
|
|
|
8727 |
|
|
|
8728 |
// Set up the point shapes/sizes arrays - needed for outliers:
|
|
|
8729 |
$this->CheckPointParams();
|
|
|
8730 |
|
|
|
8731 |
// Calculate the half-width of the boxes.
|
|
|
8732 |
// This is scaled based on the plot density, but within tight limits.
|
|
|
8733 |
$width1 = max($this->boxes_min_width, min($this->boxes_max_width,
|
|
|
8734 |
(int)($this->boxes_frac_width * $this->plot_area_width / $this->num_data_rows)));
|
|
|
8735 |
// This is the half-width of the upper and lower T's and the ends of the whiskers:
|
|
|
8736 |
$width2 = $this->boxes_t_width * $width1;
|
|
|
8737 |
|
|
|
8738 |
// A box plot can use up to 3 different line widths:
|
|
|
8739 |
list($box_thickness, $belt_thickness, $whisker_thickness) = $this->line_widths;
|
|
|
8740 |
|
|
|
8741 |
$gcvars = array(); // For GetDataColor, which initializes and uses this.
|
|
|
8742 |
|
|
|
8743 |
for ($row = 0; $row < $this->num_data_rows; $row++) {
|
|
|
8744 |
$record = 1; // Skip record #0 (data label)
|
|
|
8745 |
|
|
|
8746 |
if ($this->datatype_implied) // Implied X values?
|
|
|
8747 |
$xw = 0.5 + $row; // Place text-data at X = 0.5, 1.5, 2.5, etc...
|
|
|
8748 |
else
|
|
|
8749 |
$xw = $this->data[$row][$record++]; // Read it, advance record index
|
|
|
8750 |
|
|
|
8751 |
$xd = $this->xtr($xw); // Convert X to device coordinates
|
|
|
8752 |
$x_left = $xd - $width1;
|
|
|
8753 |
$x_right = $xd + $width1;
|
|
|
8754 |
|
|
|
8755 |
if ($this->x_data_label_pos != 'none') // Draw X Data labels?
|
|
|
8756 |
$this->DrawXDataLabel($this->data[$row][0], $xd, $row);
|
|
|
8757 |
|
|
|
8758 |
// Each row must have at least 5 values:
|
|
|
8759 |
$num_y = $this->num_recs[$row] - $record;
|
|
|
8760 |
if ($num_y < 5) {
|
|
|
8761 |
return $this->PrintError("DrawBoxes(): row $row must have at least 5 values.");
|
|
|
8762 |
}
|
|
|
8763 |
|
|
|
8764 |
// Collect the 5 primary Y values, plus any outliers:
|
|
|
8765 |
$yd = array(); // Device coords
|
|
|
8766 |
for ($i = 0; $i < $num_y; $i++) {
|
|
|
8767 |
$yd[$i] = is_numeric($y = $this->data[$row][$record++]) ? $this->ytr($y) : NULL;
|
|
|
8768 |
}
|
|
|
8769 |
|
|
|
8770 |
// Skip the row if either YQ1 or YQ3 is missing:
|
|
|
8771 |
if (!isset($yd[1], $yd[3])) continue;
|
|
|
8772 |
|
|
|
8773 |
// Box plot uses 4 colors, and 1 dashed line style for the whiskers:
|
|
|
8774 |
$this->GetDataColor($row, 0, $gcvars, $box_color);
|
|
|
8775 |
$this->GetDataColor($row, 1, $gcvars, $belt_color);
|
|
|
8776 |
$this->GetDataColor($row, 2, $gcvars, $outlier_color);
|
|
|
8777 |
$this->GetDataColor($row, 3, $gcvars, $whisker_color);
|
|
|
8778 |
$whisker_style = $this->SetDashedStyle($whisker_color, $this->line_styles[0] == 'dashed');
|
|
|
8779 |
|
|
|
8780 |
// Draw the lower whisker and T
|
|
|
8781 |
if (isset($yd[0]) && $yd[0] > $yd[1]) { // Note device Y coordinates are inverted (*-1)
|
|
|
8782 |
imagesetthickness($this->img, $whisker_thickness);
|
|
|
8783 |
imageline($this->img, $xd, $yd[0], $xd, $yd[1], $whisker_style);
|
|
|
8784 |
imageline($this->img, $xd - $width2, $yd[0], $xd + $width2, $yd[0], $whisker_color);
|
|
|
8785 |
}
|
|
|
8786 |
|
|
|
8787 |
// Draw the upper whisker and T
|
|
|
8788 |
if (isset($yd[4]) && $yd[3] > $yd[4]) { // Meaning: Yworld[3] < Yworld[4]
|
|
|
8789 |
imagesetthickness($this->img, $whisker_thickness);
|
|
|
8790 |
imageline($this->img, $xd, $yd[3], $xd, $yd[4], $whisker_style);
|
|
|
8791 |
imageline($this->img, $xd - $width2, $yd[4], $xd + $width2, $yd[4], $whisker_color);
|
|
|
8792 |
}
|
|
|
8793 |
|
|
|
8794 |
// Draw the median belt (before the box, so the ends of the belt don't break up the box.)
|
|
|
8795 |
if (isset($yd[2])) {
|
|
|
8796 |
imagesetthickness($this->img, $belt_thickness);
|
|
|
8797 |
imageline($this->img, $x_left, $yd[2], $x_right, $yd[2], $belt_color);
|
|
|
8798 |
}
|
|
|
8799 |
|
|
|
8800 |
// Draw the box
|
|
|
8801 |
imagesetthickness($this->img, $box_thickness);
|
|
|
8802 |
imagerectangle($this->img, $x_left, $yd[3], $x_right, $yd[1], $box_color);
|
|
|
8803 |
imagesetthickness($this->img, 1);
|
|
|
8804 |
|
|
|
8805 |
// Draw any outliers, all using the same shape marker (index 0) and color:
|
|
|
8806 |
for ($i = 5; $i < $num_y; $i++) {
|
|
|
8807 |
if (isset($yd[$i]))
|
|
|
8808 |
$this->DrawShape($xd, $yd[$i], 0, $outlier_color);
|
|
|
8809 |
}
|
|
|
8810 |
|
|
|
8811 |
$this->DoCallback('data_points', 'rect', $row, 0, $x_left, $yd[4], $x_right, $yd[0]);
|
|
|
8812 |
}
|
|
|
8813 |
return TRUE;
|
|
|
8814 |
}
|
|
|
8815 |
|
|
|
8816 |
/**
|
|
|
8817 |
* Draws the current graph onto the image
|
|
|
8818 |
*
|
|
|
8819 |
* This is the function that performs the actual drawing, after all the
|
|
|
8820 |
* parameters and data are set up. It also outputs the finished image,
|
|
|
8821 |
* unless told not to with SetPrintImage(False).
|
|
|
8822 |
* Note: It is possible for this to be called multiple times (multi-plot).
|
|
|
8823 |
*
|
|
|
8824 |
* @return bool True (False on error if an error handler returns True)
|
|
|
8825 |
*/
|
|
|
8826 |
function DrawGraph()
|
|
|
8827 |
{
|
|
|
8828 |
// Test for missing image, missing data, empty data:
|
|
|
8829 |
if (!$this->CheckDataArray())
|
|
|
8830 |
return FALSE; // Error message already reported.
|
|
|
8831 |
|
|
|
8832 |
// Load some configuration values from the array of plot types:
|
|
|
8833 |
$pt = &self::$plots[$this->plot_type]; // Use reference for shortcut
|
|
|
8834 |
$draw_method = $pt['draw_method'];
|
|
|
8835 |
$draw_arg = isset($pt['draw_arg']) ? $pt['draw_arg'] : array();
|
|
|
8836 |
$draw_axes = empty($pt['suppress_axes']);
|
|
|
8837 |
|
|
|
8838 |
// Allocate colors for the plot:
|
|
|
8839 |
$this->SetColorIndexes();
|
|
|
8840 |
|
|
|
8841 |
// Calculate scaling, but only for plots with axes (excludes pie charts).
|
|
|
8842 |
if ($draw_axes) {
|
|
|
8843 |
|
|
|
8844 |
// Get maxima and minima for scaling:
|
|
|
8845 |
if (!$this->FindDataLimits())
|
|
|
8846 |
return FALSE;
|
|
|
8847 |
|
|
|
8848 |
// Set plot area world values (plot_max_x, etc.):
|
|
|
8849 |
if (!$this->CalcPlotAreaWorld())
|
|
|
8850 |
return FALSE;
|
|
|
8851 |
|
|
|
8852 |
// Calculate X and Y axis positions in World Coordinates:
|
|
|
8853 |
$this->CalcAxisPositions();
|
|
|
8854 |
|
|
|
8855 |
// Process label-related parameters:
|
|
|
8856 |
$this->CheckLabels();
|
|
|
8857 |
}
|
|
|
8858 |
|
|
|
8859 |
// Calculate the plot margins, if needed.
|
|
|
8860 |
// For pie charts, set the $maximize argument to maximize space usage.
|
|
|
8861 |
$this->CalcMargins(!$draw_axes);
|
|
|
8862 |
|
|
|
8863 |
// Calculate the actual plot area in device coordinates:
|
|
|
8864 |
$this->CalcPlotAreaPixels();
|
|
|
8865 |
|
|
|
8866 |
// Calculate the mapping between world and device coordinates:
|
|
|
8867 |
if ($draw_axes) $this->CalcTranslation();
|
|
|
8868 |
|
|
|
8869 |
// Pad color and style arrays to fit records per group:
|
|
|
8870 |
$this->PadArrays();
|
|
|
8871 |
$this->DoCallback('draw_setup');
|
|
|
8872 |
|
|
|
8873 |
$this->DrawBackground();
|
|
|
8874 |
$this->DrawImageBorder();
|
|
|
8875 |
$this->DoCallback('draw_image_background');
|
|
|
8876 |
|
|
|
8877 |
$this->DrawPlotAreaBackground();
|
|
|
8878 |
$this->DoCallback('draw_plotarea_background', $this->plot_area);
|
|
|
8879 |
|
|
|
8880 |
$this->DrawTitle();
|
|
|
8881 |
if ($draw_axes) { // If no axes (pie chart), no axis titles either
|
|
|
8882 |
$this->DrawXTitle();
|
|
|
8883 |
$this->DrawYTitle();
|
|
|
8884 |
}
|
|
|
8885 |
$this->DoCallback('draw_titles');
|
|
|
8886 |
|
|
|
8887 |
// grid_at_foreground flag allows grid behind or in front of the plot
|
|
|
8888 |
if ($draw_axes && !$this->grid_at_foreground) {
|
|
|
8889 |
$this->DrawYAxis(); // Y axis must be drawn before X axis (see DrawYAxis())
|
|
|
8890 |
$this->DrawXAxis();
|
|
|
8891 |
$this->DoCallback('draw_axes');
|
|
|
8892 |
}
|
|
|
8893 |
|
|
|
8894 |
// Call the plot-type drawing method:
|
|
|
8895 |
call_user_func_array(array($this, $draw_method), $draw_arg);
|
|
|
8896 |
$this->DoCallback('draw_graph', $this->plot_area);
|
|
|
8897 |
|
|
|
8898 |
if ($draw_axes && $this->grid_at_foreground) {
|
|
|
8899 |
$this->DrawYAxis(); // Y axis must be drawn before X axis (see DrawYAxis())
|
|
|
8900 |
$this->DrawXAxis();
|
|
|
8901 |
$this->DoCallback('draw_axes');
|
|
|
8902 |
}
|
|
|
8903 |
|
|
|
8904 |
$this->DrawPlotBorder($draw_axes); // Flag controls default for plot area borders
|
|
|
8905 |
$this->DoCallback('draw_border');
|
|
|
8906 |
|
|
|
8907 |
if (!empty($this->legend)) {
|
|
|
8908 |
$this->DrawLegend();
|
|
|
8909 |
$this->DoCallback('draw_legend');
|
|
|
8910 |
}
|
|
|
8911 |
$this->DoCallback('draw_all', $this->plot_area);
|
|
|
8912 |
|
|
|
8913 |
if ($this->print_image && !$this->PrintImage())
|
|
|
8914 |
return FALSE;
|
|
|
8915 |
|
|
|
8916 |
return TRUE;
|
|
|
8917 |
}
|
|
|
8918 |
|
|
|
8919 |
/////////////////////////////////////////////
|
|
|
8920 |
////////////////// DEPRECATED METHODS
|
|
|
8921 |
/////////////////////////////////////////////
|
|
|
8922 |
|
|
|
8923 |
/*
|
|
|
8924 |
* Note on deprecated methods - as these pre-date the PHPlot Reference
|
|
|
8925 |
* Manual, and there is minimal documentation about them, I have neither
|
|
|
8926 |
* removed them nor changed them. They are not tested or documented, and
|
|
|
8927 |
* should not be used.
|
|
|
8928 |
*/
|
|
|
8929 |
|
|
|
8930 |
/**
|
|
|
8931 |
* @deprecated Use SetYTickPos() instead
|
|
|
8932 |
*/
|
|
|
8933 |
function SetDrawVertTicks($which_dvt)
|
|
|
8934 |
{
|
|
|
8935 |
if ($which_dvt != 1)
|
|
|
8936 |
$this->SetYTickPos('none');
|
|
|
8937 |
return TRUE;
|
|
|
8938 |
}
|
|
|
8939 |
|
|
|
8940 |
/**
|
|
|
8941 |
* @deprecated Use SetXTickPos() instead
|
|
|
8942 |
*/
|
|
|
8943 |
function SetDrawHorizTicks($which_dht)
|
|
|
8944 |
{
|
|
|
8945 |
if ($which_dht != 1)
|
|
|
8946 |
$this->SetXTickPos('none');
|
|
|
8947 |
return TRUE;
|
|
|
8948 |
}
|
|
|
8949 |
|
|
|
8950 |
/**
|
|
|
8951 |
* @deprecated Use SetNumXTicks() instead
|
|
|
8952 |
*/
|
|
|
8953 |
function SetNumHorizTicks($n)
|
|
|
8954 |
{
|
|
|
8955 |
return $this->SetNumXTicks($n);
|
|
|
8956 |
}
|
|
|
8957 |
|
|
|
8958 |
/**
|
|
|
8959 |
* @deprecated Use SetNumYTicks() instead
|
|
|
8960 |
*/
|
|
|
8961 |
function SetNumVertTicks($n)
|
|
|
8962 |
{
|
|
|
8963 |
return $this->SetNumYTicks($n);
|
|
|
8964 |
}
|
|
|
8965 |
|
|
|
8966 |
/**
|
|
|
8967 |
* @deprecated Use SetXTickIncrement() instead
|
|
|
8968 |
*/
|
|
|
8969 |
function SetHorizTickIncrement($inc)
|
|
|
8970 |
{
|
|
|
8971 |
return $this->SetXTickIncrement($inc);
|
|
|
8972 |
}
|
|
|
8973 |
|
|
|
8974 |
/**
|
|
|
8975 |
* @deprecated Use SetYTickIncrement() instead
|
|
|
8976 |
*/
|
|
|
8977 |
function SetVertTickIncrement($inc)
|
|
|
8978 |
{
|
|
|
8979 |
return $this->SetYTickIncrement($inc);
|
|
|
8980 |
}
|
|
|
8981 |
|
|
|
8982 |
/**
|
|
|
8983 |
* @deprecated Use SetYTickPos() instead
|
|
|
8984 |
*/
|
|
|
8985 |
function SetVertTickPosition($which_tp)
|
|
|
8986 |
{
|
|
|
8987 |
return $this->SetYTickPos($which_tp);
|
|
|
8988 |
}
|
|
|
8989 |
|
|
|
8990 |
/**
|
|
|
8991 |
* @deprecated Use SetXTickPos() instead
|
|
|
8992 |
*/
|
|
|
8993 |
function SetHorizTickPosition($which_tp)
|
|
|
8994 |
{
|
|
|
8995 |
return $this->SetXTickPos($which_tp);
|
|
|
8996 |
}
|
|
|
8997 |
|
|
|
8998 |
/**
|
|
|
8999 |
* @deprecated Use SetFont() instead
|
|
|
9000 |
*/
|
|
|
9001 |
function SetTitleFontSize($which_size)
|
|
|
9002 |
{
|
|
|
9003 |
return $this->SetFont('title', $which_size);
|
|
|
9004 |
}
|
|
|
9005 |
|
|
|
9006 |
/**
|
|
|
9007 |
* @deprecated Use SetFont() instead
|
|
|
9008 |
*/
|
|
|
9009 |
function SetAxisFontSize($which_size)
|
|
|
9010 |
{
|
|
|
9011 |
$this->SetFont('x_label', $which_size);
|
|
|
9012 |
$this->SetFont('y_label', $which_size);
|
|
|
9013 |
}
|
|
|
9014 |
|
|
|
9015 |
/**
|
|
|
9016 |
* @deprecated Use SetFont() instead
|
|
|
9017 |
*/
|
|
|
9018 |
function SetSmallFontSize($which_size)
|
|
|
9019 |
{
|
|
|
9020 |
return $this->SetFont('generic', $which_size);
|
|
|
9021 |
}
|
|
|
9022 |
|
|
|
9023 |
/**
|
|
|
9024 |
* @deprecated Use SetFont() instead
|
|
|
9025 |
*/
|
|
|
9026 |
function SetXLabelFontSize($which_size)
|
|
|
9027 |
{
|
|
|
9028 |
return $this->SetFont('x_title', $which_size);
|
|
|
9029 |
}
|
|
|
9030 |
|
|
|
9031 |
/**
|
|
|
9032 |
* @deprecated Use SetFont() instead
|
|
|
9033 |
*/
|
|
|
9034 |
function SetYLabelFontSize($which_size)
|
|
|
9035 |
{
|
|
|
9036 |
return $this->SetFont('y_title', $which_size);
|
|
|
9037 |
}
|
|
|
9038 |
|
|
|
9039 |
/**
|
|
|
9040 |
* @deprecated Use SetXTitle() instead
|
|
|
9041 |
*/
|
|
|
9042 |
function SetXLabel($which_xlab)
|
|
|
9043 |
{
|
|
|
9044 |
return $this->SetXTitle($which_xlab);
|
|
|
9045 |
}
|
|
|
9046 |
|
|
|
9047 |
/**
|
|
|
9048 |
* @deprecated Use SetYTitle() instead
|
|
|
9049 |
*/
|
|
|
9050 |
function SetYLabel($which_ylab)
|
|
|
9051 |
{
|
|
|
9052 |
return $this->SetYTitle($which_ylab);
|
|
|
9053 |
}
|
|
|
9054 |
|
|
|
9055 |
/**
|
|
|
9056 |
* @deprecated Use SetXTickLength() and SetYTickLength() instead
|
|
|
9057 |
*/
|
|
|
9058 |
function SetTickLength($which_tl)
|
|
|
9059 |
{
|
|
|
9060 |
$this->SetXTickLength($which_tl);
|
|
|
9061 |
$this->SetYTickLength($which_tl);
|
|
|
9062 |
return TRUE;
|
|
|
9063 |
}
|
|
|
9064 |
|
|
|
9065 |
/**
|
|
|
9066 |
* @deprecated Use SetYLabelType() instead
|
|
|
9067 |
*/
|
|
|
9068 |
function SetYGridLabelType($which_yglt)
|
|
|
9069 |
{
|
|
|
9070 |
return $this->SetYLabelType($which_yglt);
|
|
|
9071 |
}
|
|
|
9072 |
|
|
|
9073 |
/**
|
|
|
9074 |
* @deprecated Use SetXLabelType() instead
|
|
|
9075 |
*/
|
|
|
9076 |
function SetXGridLabelType($which_xglt)
|
|
|
9077 |
{
|
|
|
9078 |
return $this->SetXLabelType($which_xglt);
|
|
|
9079 |
}
|
|
|
9080 |
|
|
|
9081 |
/**
|
|
|
9082 |
* @deprecated Use SetYTickLabelPos() instead
|
|
|
9083 |
*/
|
|
|
9084 |
function SetYGridLabelPos($which_yglp)
|
|
|
9085 |
{
|
|
|
9086 |
return $this->SetYTickLabelPos($which_yglp);
|
|
|
9087 |
}
|
|
|
9088 |
|
|
|
9089 |
/**
|
|
|
9090 |
* @deprecated Use SetXTickLabelPos() instead
|
|
|
9091 |
*/
|
|
|
9092 |
function SetXGridLabelPos($which_xglp)
|
|
|
9093 |
{
|
|
|
9094 |
return $this->SetXTickLabelPos($which_xglp);
|
|
|
9095 |
}
|
|
|
9096 |
|
|
|
9097 |
/**
|
|
|
9098 |
* @deprecated Use SetXtitle() instead
|
|
|
9099 |
*/
|
|
|
9100 |
function SetXTitlePos($xpos)
|
|
|
9101 |
{
|
|
|
9102 |
$this->x_title_pos = $xpos;
|
|
|
9103 |
return TRUE;
|
|
|
9104 |
}
|
|
|
9105 |
|
|
|
9106 |
/**
|
|
|
9107 |
* @deprecated Use SetYTitle() instead
|
|
|
9108 |
*/
|
|
|
9109 |
function SetYTitlePos($xpos)
|
|
|
9110 |
{
|
|
|
9111 |
$this->y_title_pos = $xpos;
|
|
|
9112 |
return TRUE;
|
|
|
9113 |
}
|
|
|
9114 |
|
|
|
9115 |
/**
|
|
|
9116 |
* @deprecated Use SetXDataLabelPos() instead
|
|
|
9117 |
*/
|
|
|
9118 |
function SetDrawXDataLabels($which_dxdl)
|
|
|
9119 |
{
|
|
|
9120 |
if ($which_dxdl == '1' )
|
|
|
9121 |
$this->SetXDataLabelPos('plotdown');
|
|
|
9122 |
else
|
|
|
9123 |
$this->SetXDataLabelPos('none');
|
|
|
9124 |
}
|
|
|
9125 |
|
|
|
9126 |
/**
|
|
|
9127 |
* @deprecated Use SetPlotAreaPixels() instead
|
|
|
9128 |
*/
|
|
|
9129 |
function SetNewPlotAreaPixels($x1, $y1, $x2, $y2)
|
|
|
9130 |
{
|
|
|
9131 |
return $this->SetPlotAreaPixels($x1, $y1, $x2, $y2);
|
|
|
9132 |
}
|
|
|
9133 |
|
|
|
9134 |
/**
|
|
|
9135 |
* @deprecated Use SetLineWidths() instead
|
|
|
9136 |
*/
|
|
|
9137 |
function SetLineWidth($which_lw)
|
|
|
9138 |
{
|
|
|
9139 |
|
|
|
9140 |
$this->SetLineWidths($which_lw);
|
|
|
9141 |
|
|
|
9142 |
if (!$this->error_bar_line_width) {
|
|
|
9143 |
$this->SetErrorBarLineWidth($which_lw);
|
|
|
9144 |
}
|
|
|
9145 |
return TRUE;
|
|
|
9146 |
}
|
|
|
9147 |
|
|
|
9148 |
/**
|
|
|
9149 |
* @deprecated Use SetPointShapes() instead
|
|
|
9150 |
*/
|
|
|
9151 |
function SetPointShape($which_pt)
|
|
|
9152 |
{
|
|
|
9153 |
$this->SetPointShapes($which_pt);
|
|
|
9154 |
return TRUE;
|
|
|
9155 |
}
|
|
|
9156 |
|
|
|
9157 |
/**
|
|
|
9158 |
* @deprecated Use SetPointSizes() instead
|
|
|
9159 |
*/
|
|
|
9160 |
function SetPointSize($which_ps)
|
|
|
9161 |
{
|
|
|
9162 |
$this->SetPointSizes($which_ps);
|
|
|
9163 |
return TRUE;
|
|
|
9164 |
}
|
|
|
9165 |
|
|
|
9166 |
/**
|
|
|
9167 |
* @deprecated Use PrintError() instead
|
|
|
9168 |
*/
|
|
|
9169 |
protected function DrawError($error_message, $where_x = NULL, $where_y = NULL)
|
|
|
9170 |
{
|
|
|
9171 |
return $this->PrintError($error_message);
|
|
|
9172 |
}
|
|
|
9173 |
|
|
|
9174 |
}
|
|
|
9175 |
|
|
|
9176 |
/**
|
|
|
9177 |
* Class for creating a plot using a truecolor (24-bit R,G,B) image
|
|
|
9178 |
*
|
|
|
9179 |
* The PHPlot_truecolor class extends the PHPlot class to use GD truecolor
|
|
|
9180 |
* images. Unlike PHPlot which usually creates indexed RGB files limited to
|
|
|
9181 |
* 256 total colors, PHPlot_truecolor objects use images which do not have a
|
|
|
9182 |
* limit on the number of colors.
|
|
|
9183 |
*
|
|
|
9184 |
* Note: Without a background image, the PHPlot class creates a palette
|
|
|
9185 |
* (indexed) color image, and the PHPlot_truecolor class creates a truecolor
|
|
|
9186 |
* image. If a background image is used with the constructor of either class,
|
|
|
9187 |
* the type of image produced matches the type of the background image.
|
|
|
9188 |
*
|
|
|
9189 |
*/
|
|
|
9190 |
class PHPlot_truecolor extends PHPlot
|
|
|
9191 |
{
|
|
|
9192 |
/**
|
|
|
9193 |
* Constructor: Sets up GD truecolor image resource, and initializes plot style controls
|
|
|
9194 |
*
|
|
|
9195 |
* @param int $width Image width in pixels
|
|
|
9196 |
* @param int $height Image height in pixels
|
|
|
9197 |
* @param string $output_file Path for output file. Omit, or NULL, or '' to mean no output file
|
|
|
9198 |
* @param string $input_file Path to a file to be used as background. Omit, NULL, or '' for none
|
|
|
9199 |
*/
|
|
|
9200 |
function __construct($width=600, $height=400, $output_file=NULL, $input_file=NULL)
|
|
|
9201 |
{
|
|
|
9202 |
$this->initialize('imagecreatetruecolor', $width, $height, $output_file, $input_file);
|
|
|
9203 |
}
|
|
|
9204 |
}
|