PLplot: plplot.d Source File

PLplot 5.15.0

plplot.d
Go to the documentation of this file.
1 // Converted to D from plplot_d.h by htod
2 module plplot;
3
4 private import std.string;
5 private import std.array;
6 private import std.algorithm;
7 private import std.stdio;
8 private import std.conv;
9
10 // improved D interface
11
12 // certain functions must be declared as C functions so that PLplot
13 // can handle them
14 extern ( C ) {
15 alias PLINT function( PLFLT, PLFLT ) def_func;
16 alias void function( PLINT, PLFLT*, PLFLT* ) fill_func;
17 alias void function( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ) pltr_func;
18 alias void function( PLINT, PLFLT*, PLFLT* ) mapform_func;
19 alias void function( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ) ct_func;
20 }
21
22 // D definition of PLcGrid and PLcGrid2
23 struct PLcGrid
24 {
25 PLFLT[] xg;
26 PLFLT[] yg;
27 PLFLT[] zg;
28 }
29 struct PLcGrid2
30 {
31 PLFLT[][] xg;
32 PLFLT[][] yg;
33 PLFLT[][] zg;
34 }
35
36 // helper function to convert D dynamic arrays in C dynamic arrays
37 private PLFLT** convert_array( PLFLT[][] a )
38 {
39 if ( !a )
40 return null;
41
42 size_t nx = a.length;
43 size_t ny = a[0].length;
44
45 PLFLT ** c_a = ( new PLFLT *[nx] ).ptr;
46 for ( size_t i = 0; i < nx; i++ )
47 {
48 assert( ny == a[i].length, "convert_array(): Array must be 2 dimensional!" );
49 c_a[i] = a[i].ptr;
50 }
51
52 return c_a;
53 }
54
55 // Process options list using current options info.
56 PLINT plparseopts( char[][] args, PLINT mode )
57 {
58 char*[] c_args = new char*[args.length];
59 foreach ( size_t i, char[] arg; args )
60 c_args[i] = cast(char *) toStringz( arg );
61 int argc = cast(int) c_args.length;
62 return c_plparseopts( &argc, cast(char**) c_args, mode );
63 }
64
65 // simple arrow plotter.
66 void plvect( PLFLT[][] u, PLFLT[][] v, PLFLT scale, pltr_func pltr = null, PLPointer pltr_data = null )
67 {
68 PLINT nx = cast(PLINT) u.length;
69 PLINT ny = cast(PLINT) u[0].length;
70 assert( nx == v.length, "plvect(): Arrays must be of same length!" );
71 assert( ny == v[0].length, "plvect(): Arrays must be of same length!" );
72
73 c_plvect( convert_array( u ), convert_array( v ), nx, ny, scale, pltr, pltr_data );
74 }
75
76 void plvect( PLFLT[][] u, PLFLT[][] v, PLFLT scale, ref PLcGrid cgrid )
77 {
78 PLINT nx = cast(PLINT) u.length;
79 PLINT ny = cast(PLINT) u[0].length;
80 assert( nx == v.length, "plvect(): Arrays must be of same length!" );
81 assert( ny == v[0].length, "plvect(): Arrays must be of same length!" );
82
83 c_PLcGrid c;
84 c.xg = cgrid.xg.ptr;
85 c.nx = cast(PLINT) cgrid.xg.length;
86 c.yg = cgrid.yg.ptr;
87 c.ny = cast(PLINT) cgrid.yg.length;
88 c.zg = cgrid.zg.ptr;
89 c.nz = cast(PLINT) cgrid.zg.length;
90
91 c_plvect( convert_array( u ), convert_array( v ), nx, ny, scale, &pltr1, &c );
92 }
93
94 void plvect( PLFLT[][] u, PLFLT[][] v, PLFLT scale, ref PLcGrid2 cgrid2 )
95 {
96 PLINT nx = cast(PLINT) u.length;
97 PLINT ny = cast(PLINT) u[0].length;
98 assert( nx == v.length, "plvect(): Arrays must be of same length!" );
99 assert( ny == v[0].length, "plvect(): Arrays must be of same length!" );
100
101 c_PLcGrid2 c2;
102 c2.xg = convert_array( cgrid2.xg );
103 c2.yg = convert_array( cgrid2.yg );
104 c2.zg = convert_array( cgrid2.zg );
105 c2.nx = cast(PLINT) cgrid2.xg.length;
106 c2.ny = cast(PLINT) cgrid2.xg[0].length;
107 if ( cgrid2.yg )
108 {
109 assert( c2.nx == cgrid2.yg.length, "plvect(): Arrays must be of same length!" );
110 assert( c2.ny == cgrid2.yg[0].length, "plvect(): Arrays must be of same length!" );
111 }
112 if ( cgrid2.zg )
113 {
114 assert( c2.nx == cgrid2.zg.length, "plvect(): Arrays must be of same length!" );
115 assert( c2.ny == cgrid2.zg[0].length, "plvect(): Arrays must be of same length!" );
116 }
117
118 c_plvect( convert_array( u ), convert_array( v ), nx, ny, scale, &pltr2, &c2 );
119 }
120
121 void plsvect( PLFLT[] arrowx, PLFLT[] arrowy, PLBOOL fill )
122 {
123 PLINT npts = cast(PLINT) arrowx.length;
124 assert( npts == arrowy.length, "plsvect(): Arrays must be of same length!" );
125 c_plsvect( arrowx.ptr, arrowy.ptr, npts, fill );
126 }
127
128 // This functions similarly to plbox() except that the origin of the axes
129 // is placed at the user-specified point (x0, y0).
130 void plaxes( PLFLT x0, PLFLT y0, string xopt, PLFLT xtick, PLINT nxsub,
131 string yopt, PLFLT ytick, PLINT nysub )
132 {
133 c_plaxes( x0, y0, toStringz( xopt ), xtick, nxsub, toStringz( yopt ), ytick, nysub );
134 }
135
136 // Plot a histogram using x to store data values and y to store frequencies
137 void plbin( PLFLT[] x, PLFLT[] y, PLINT opt )
138 {
139 PLINT nbin = cast(PLINT) x.length;
140 assert( nbin == y.length, "plbin(): Arrays must be of same length!" );
141 c_plbin( nbin, x.ptr, y.ptr, opt );
142 }
143
144 // This draws a box around the current viewport.
145 void plbox( string xopt, PLFLT xtick, PLINT nxsub, string yopt, PLFLT ytick, PLINT nysub )
146 {
147 c_plbox( toStringz( xopt ), xtick, nxsub, toStringz( yopt ), ytick, nysub );
148 }
149
150 // This is the 3-d analogue of plbox().
151 void plbox3( string xopt, string xlabel, PLFLT xtick, PLINT nsubx,
152 string yopt, string ylabel, PLFLT ytick, PLINT nsuby,
153 string zopt, string zlabel, PLFLT ztick, PLINT nsubz )
154 {
155 c_plbox3( toStringz( xopt ), toStringz( xlabel ), xtick, nsubx,
156 toStringz( yopt ), toStringz( ylabel ), ytick, nsuby,
157 toStringz( zopt ), toStringz( zlabel ), ztick, nsubz );
158 }
159
160 // Routine for drawing continuous colour legends
161 void plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
162 PLINT opt, PLINT position, PLFLT x, PLFLT y,
163 PLFLT x_length, PLFLT y_length,
164 PLINT bg_color, PLINT bb_color, PLINT bb_style,
165 PLFLT low_cap_color, PLFLT high_cap_color,
166 PLINT cont_color, PLFLT cont_width,
167 PLINT[] label_opts, string[] label,
168 string[] axis_opts,
169 PLFLT[] ticks, PLINT[] sub_ticks,
170 PLFLT[][] values )
171 {
172 PLINT n_labels = cast(PLINT) label_opts.length;
173 PLINT n_axes = cast(PLINT) axis_opts.length;
174 PLINT[] n_values = new PLINT[values.length];
175 for ( size_t i = 0; i < values.length; i++ )
176 {
177 n_values[i] = cast(PLINT) values[i].length;
178 }
179 immutable( char ) * *labelz = array( map!toStringz( label ) ).ptr;
180 immutable( char ) * *axis_optsz = array( map!toStringz( axis_opts ) ).ptr;
181 assert( n_labels == label.length, "plcolorbar(): Arrays must be of same length!" );
182 assert( n_labels == label_opts.length, "plcolorbar(): Arrays must be of same length!" );
183 assert( n_axes == axis_opts.length, "plcolorbar(): Arrays must be of same length!" );
184 assert( n_axes == ticks.length, "plcolorbar(): Arrays must be of same length!" );
185 assert( n_axes == sub_ticks.length, "plcolorbar(): Arrays must be of same length!" );
186
187 c_plcolorbar( p_colorbar_width, p_colorbar_height,
188 opt, position, x, y,
189 x_length, y_length,
190 bg_color, bb_color, bb_style,
191 low_cap_color, high_cap_color,
192 cont_color, cont_width,
193 n_labels, label_opts.ptr, labelz,
194 n_axes, axis_optsz,
195 ticks.ptr, sub_ticks.ptr,
196 n_values.ptr, convert_array( values ) );
197 }
198
199 // Draws a contour plot from data in f(nx,ny). Is just a front-end to
200 // plfcont, with a particular choice for f2eval and f2eval_data.
201 //
202 void plcont( PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel,
203 pltr_func pltr, PLPointer pltr_data = null )
204 {
205 PLINT nx = cast(PLINT) f.length;
206 PLINT ny = cast(PLINT) f[0].length;
207
208 c_plcont( convert_array( f ), nx, ny, kx, lx, ky, ly, clevel.ptr, cast(PLINT) clevel.length,
209 pltr, pltr_data );
210 }
211
212 void plcont( PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel,
213 ref PLcGrid cgrid )
214 {
215 PLINT nx = cast(PLINT) f.length;
216 PLINT ny = cast(PLINT) f[0].length;
217
218 c_PLcGrid c;
219 c.xg = cgrid.xg.ptr;
220 c.nx = cast(PLINT) cgrid.xg.length;
221 c.yg = cgrid.yg.ptr;
222 c.ny = cast(PLINT) cgrid.yg.length;
223 c.zg = cgrid.zg.ptr;
224 c.nz = cast(PLINT) cgrid.zg.length;
225
226 c_plcont( convert_array( f ), nx, ny, kx, lx, ky, ly, clevel.ptr, cast(PLINT) clevel.length,
227 &pltr1, &c );
228 }
229
230 void plcont( PLFLT[][] f, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT[] clevel,
231 ref PLcGrid2 cgrid2 )
232 {
233 PLINT nx = cast(PLINT) f.length;
234 PLINT ny = cast(PLINT) f[0].length;
235
236 c_PLcGrid2 c2;
237 c2.xg = convert_array( cgrid2.xg );
238 c2.yg = convert_array( cgrid2.yg );
239 c2.zg = convert_array( cgrid2.zg );
240 c2.nx = cast(PLINT) cgrid2.xg.length;
241 c2.ny = cast(PLINT) cgrid2.xg[0].length;
242 if ( cgrid2.yg )
243 {
244 assert( c2.nx == cgrid2.yg.length, "plcont(): Arrays must be of same length!" );
245 assert( c2.ny == cgrid2.yg[0].length, "plcont(): Arrays must be of same length!" );
246 }
247 if ( cgrid2.zg )
248 {
249 assert( c2.nx == cgrid2.zg.length, "plcont(): Arrays must be of same length!" );
250 assert( c2.ny == cgrid2.zg[0].length, "plcont(): Arrays must be of same length!" );
251 }
252
253 c_plcont( convert_array( f ), nx, ny, kx, lx, ky, ly, clevel.ptr, cast(PLINT) clevel.length,
254 &pltr2, &c2 );
255 }
256
257 // Draws a contour plot using the function evaluator f2eval and data stored
258 // by way of the f2eval_data pointer. This allows arbitrary organizations
259 // of 2d array data to be used.
260 //
261 //void plfcont(PLFLT function(PLINT , PLINT , PLPointer )f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel, void function(PLFLT , PLFLT , PLFLT *, PLFLT *, PLPointer )pltr, PLPointer pltr_data);
262
263 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i))
264 void plerrx( PLFLT[] xmin, PLFLT[] xmax, PLFLT[] y )
265 {
266 PLINT n = cast(PLINT) y.length;
267 assert( n == xmin.length, "plerrx(): Arrays must be of same length!" );
268 assert( n == xmax.length, "plerrx(): Arrays must be of same length!" );
269 c_plerrx( n, xmin.ptr, xmax.ptr, y.ptr );
270 }
271
272 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i))
273 void plerry( PLFLT[] x, PLFLT[] ymin, PLFLT[] ymax )
274 {
275 PLINT n = cast(PLINT) x.length;
276 assert( n == ymin.length, "plerry(): Arrays must be of same length!" );
277 assert( n == ymax.length, "plerry(): Arrays must be of same length!" );
278 c_plerry( n, x.ptr, ymin.ptr, ymax.ptr );
279 }
280
281 // Pattern fills the polygon bounded by the input points.
282 void plfill( PLFLT[] x, PLFLT[] y )
283 {
284 PLINT n = cast(PLINT) x.length;
285 assert( n == y.length, "plfill(): Arrays must be of same length!" );
286 c_plfill( n, x.ptr, y.ptr );
287 }
288
289 // Pattern fills the 3d polygon bounded by the input points.
290 void plfill3( PLFLT[] x, PLFLT[] y, PLFLT[] z )
291 {
292 PLINT n = cast(PLINT) x.length;
293 assert( n == y.length, "plfill3(): Arrays must be of same length!" );
294 assert( n == z.length, "plfill3(): Arrays must be of same length!" );
295 c_plfill3( n, x.ptr, y.ptr, z.ptr );
296 }
297
298 // Get the current device (keyword) name
299 void plgdev( out string p_dev )
300 {
301 char cdev[1024];
302 c_plgdev( cdev.ptr );
303 p_dev = to!string( cdev.ptr );
304 }
305
306 // Get the (current) output file name. Must be preallocated to >80 bytes
307 void plgfnam( out string fnam )
308 {
309 char cfnam[1024];
310 c_plgfnam( cfnam.ptr );
311 fnam = to!string( cfnam.ptr );
312 }
313
314 // Draw gradient in polygon.
315 void plgradient( PLFLT[] x, PLFLT[] y, PLFLT angle )
316 {
317 PLINT n = cast(PLINT) x.length;
318 assert( n == y.length, "plgradient(): Arrays must be of same length!" );
319 c_plgradient( n, x.ptr, y.ptr, angle );
320 }
321
322 // grid irregularly sampled data
323 void plgriddata( PLFLT[] x, PLFLT[] y, PLFLT[] z, PLFLT[] xg, PLFLT[] yg, PLFLT[][] zg, PLINT type, PLFLT data )
324 {
325 PLINT npts = cast(PLINT) x.length;
326 assert( npts == y.length, "plgriddata(): Arrays must be of same length!" );
327 assert( npts == z.length, "plgriddata(): Arrays must be of same length!" );
328
329 PLINT nxg = cast(PLINT) xg.length;
330 PLINT nyg = cast(PLINT) yg.length;
331 assert( nxg == zg.length, "plgriddata(): Arrays must be of same length!" );
332 assert( nyg == zg[0].length, "plgriddata(): Arrays must be of same length!" );
333
334 c_plgriddata( x.ptr, y.ptr, z.ptr, npts, xg.ptr, nxg, yg.ptr, nyg, convert_array( zg ), type, data );
335 }
336
337 // Get the current library version number
338 void plgver( out string p_ver )
339 {
340 char cver[1024];
341 c_plgver( cver.ptr );
342 p_ver = to!string( cver.ptr );
343 }
344
345 // Draws a histogram of n values of a variable in array data[0..n-1]
346 void plhist( PLFLT[] data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt )
347 {
348 c_plhist( cast(PLINT) data.length, data.ptr, datmin, datmax, nbin, opt );
349 }
350
351 // Simple routine for labelling graphs.
352 void pllab( string xlabel, string ylabel, string tlabel )
353 {
354 c_pllab( toStringz( xlabel ), toStringz( ylabel ), toStringz( tlabel ) );
355 }
356
357 // Routine for drawing discrete line, symbol, or cmap0 legends
358 void pllegend( PLFLT *p_legend_width, PLFLT *p_legend_height,
359 PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
360 PLINT bg_color, PLINT bb_color, PLINT bb_style,
361 PLINT nrow, PLINT ncolumn,
362 PLINT[] opt_array,
363 PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
364 PLFLT text_justification,
365 PLINT[] text_colors, string[] text,
366 PLINT[] box_colors, PLINT[] box_patterns,
367 PLFLT[] box_scales, PLFLT[] box_line_widths,
368 PLINT[] line_colors, PLINT[] line_styles,
369 PLFLT[] line_widths,
370 PLINT[] symbol_colors, PLFLT[] symbol_scales,
371 PLINT[] symbol_numbers, string[] symbols )
372 {
373 PLINT nlegend = cast(PLINT) opt_array.length;
374 immutable( char ) * *textz = array( map!toStringz( text ) ).ptr;
375 immutable( char ) * *symbolsz = array( map!toStringz( symbols ) ).ptr;
376 assert( nlegend == text_colors.length, "pllegend(): Arrays must be of same length!" );
377 assert( nlegend == text.length, "pllegend(): Arrays must be of same length!" );
378 assert( box_colors == null || nlegend == box_colors.length, "pllegend(): Arrays must be of same length!" );
379 assert( box_patterns == null || nlegend == box_patterns.length, "pllegend(): Arrays must be of same length!" );
380 assert( box_scales == null || nlegend == box_scales.length, "pllegend(): Arrays must be of same length!" );
381 assert( box_line_widths == null || nlegend == box_line_widths.length, "pllegend(): Arrays must be of same length!" );
382 assert( line_colors == null || nlegend == line_colors.length, "pllegend(): Arrays must be of same length!" );
383 assert( line_styles == null || nlegend == line_styles.length, "pllegend(): Arrays must be of same length!" );
384 assert( line_widths == null || nlegend == line_widths.length, "pllegend(): Arrays must be of same length!" );
385 assert( symbol_colors == null || nlegend == symbol_colors.length, "pllegend(): Arrays must be of same length!" );
386 assert( symbol_scales == null || nlegend == symbol_scales.length, "pllegend(): Arrays must be of same length!" );
387 assert( symbol_numbers == null || nlegend == symbol_numbers.length, "pllegend(): Arrays must be of same length!" );
388 assert( symbols == null || nlegend == symbols.length, "pllegend(): Arrays must be of same length!" );
389 c_pllegend( p_legend_width, p_legend_height,
390 opt, position, x, y, plot_width,
391 bg_color, bb_color, bb_style,
392 nrow, ncolumn,
393 nlegend, opt_array.ptr,
394 text_offset, text_scale, text_spacing,
395 text_justification,
396 text_colors.ptr, textz,
397 box_colors.ptr, box_patterns.ptr,
398 box_scales.ptr, box_line_widths.ptr,
399 line_colors.ptr, line_styles.ptr,
400 line_widths.ptr,
401 symbol_colors.ptr, symbol_scales.ptr,
402 symbol_numbers.ptr, symbolsz );
403 }
404
405 // Draws line segments connecting a series of points.
406 void plline( PLFLT[] x, PLFLT[] y )
407 {
408 PLINT n = cast(PLINT) x.length;
409 assert( n == y.length, "plline(): Arrays must be of same length!" );
410 c_plline( n, x.ptr, y.ptr );
411 }
412
413 // Draws a line in 3 space.
414 void plline3( PLFLT[] x, PLFLT[] y, PLFLT[] z )
415 {
416 PLINT n = cast(PLINT) x.length;
417 assert( n == y.length, "plline3(): Arrays must be of same length!" );
418 assert( n == z.length, "plline3(): Arrays must be of same length!" );
419 c_plline3( n, x.ptr, y.ptr, z.ptr );
420 }
421
422 // plot continental outline in world coordinates
423 void plmap( mapform_func mapform, string type, PLFLT minlong, PLFLT maxlong,
424 PLFLT minlat, PLFLT maxlat )
425 {
426 c_plmap( mapform, toStringz( type ), minlong, maxlong, minlat, maxlat );
427 }
428
429
430 // Plot map outlines
431
432 void plmapline( mapform_func mapform, string name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
433 const PLINT[] plotentries )
434 {
435 PLINT n = cast(PLINT) plotentries.length;
436 c_plmapline( mapform, toStringz( name ), minx, maxx, miny, maxy, plotentries.ptr, n );
437 }
438
439 // Plot map points
440
441 void plmapstring( mapform_func mapform, string name, string string,
442 PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT[] plotentries )
443 {
444 PLINT n = cast(PLINT) plotentries.length;
445 c_plmapstring( mapform, toStringz( name ), toStringz( string ), minx, maxx, miny, maxy, plotentries.ptr, n );
446 }
447
448 // Plot map text
449
450 void plmaptex( mapform_func mapform, string name, PLFLT dx, PLFLT dy, PLFLT just, string text,
451 PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry )
452 {
453 c_plmaptex( mapform, toStringz( name ), dx, dy, just, toStringz( text ), minx, maxx, miny, maxy, plotentry );
454 }
455
456 // Plot map fills
457 void plmapfill( mapform_func mapform, string name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
458 const PLINT[] plotentries ) // Plots a mesh representation of the function z[x][y].
459 {
460 PLINT n = cast(PLINT) plotentries.length;
461 c_plmapfill( mapform, toStringz( name ), minx, maxx, miny, maxy, plotentries.ptr, n );
462 }
463
464 void plmesh( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt )
465 {
466 PLINT nx = cast(PLINT) z.length;
467 PLINT ny = cast(PLINT) z[0].length;
468
469 assert( nx == x.length, "plmesh(): Arrays must be of same length!" );
470 assert( ny == y.length, "plmesh(): Arrays must be of same length!" );
471
472 c_plmesh( x.ptr, y.ptr, convert_array( z ), nx, ny, opt );
473 }
474
475 // Plots a mesh representation of the function z[x][y] with contour
476 void plmeshc( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel )
477 {
478 PLINT nx = cast(PLINT) z.length;
479 PLINT ny = cast(PLINT) z[0].length;
480
481 assert( nx == x.length, "plmeshc(): Arrays must be of same length!" );
482 assert( ny == y.length, "plmeshc(): Arrays must be of same length!" );
483
484 c_plmeshc( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length );
485 }
486
487 // Prints out "text" at specified position relative to viewport
488 void plmtex( string side, PLFLT disp, PLFLT pos, PLFLT just, string text )
489 {
490 c_plmtex( toStringz( side ), disp, pos, just, toStringz( text ) );
491 }
492
493 // Prints out "text" at specified position relative to viewport (3D)
494 void plmtex3( string side, PLFLT disp, PLFLT pos, PLFLT just, string text )
495 {
496 c_plmtex3( toStringz( side ), disp, pos, just, toStringz( text ) );
497 }
498
499 // Plots a 3-d representation of the function z[x][y].
500 void plot3d( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLBOOL side )
501 {
502 PLINT nx = cast(PLINT) z.length;
503 PLINT ny = cast(PLINT) z[0].length;
504
505 assert( nx == x.length, "plot3d(): Arrays must be of same length!" );
506 assert( ny == y.length, "plot3d(): Arrays must be of same length!" );
507
508 c_plot3d( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, side );
509 }
510
511 // Plots a 3-d representation of the function z[x][y] with contour.
512 void plot3dc( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel )
513 {
514 PLINT nx = cast(PLINT) z.length;
515 PLINT ny = cast(PLINT) z[0].length;
516
517 assert( nx == x.length, "plot3dc(): Arrays must be of same length!" );
518 assert( ny == y.length, "plot3dc(): Arrays must be of same length!" );
519
520 c_plot3dc( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length );
521 }
522
523 // Plots a 3-d representation of the function z[x][y] with contour and
524 // y index limits.
525 void plot3dcl( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel,
526 PLINT ixstart, PLINT ixn, PLINT[] indexymin, PLINT[] indexymax )
527 {
528 PLINT nx = cast(PLINT) z.length;
529 PLINT ny = cast(PLINT) z[0].length;
530
531 assert( nx == x.length, "plot3dcl(): Arrays must be of same length!" );
532 assert( ny == y.length, "plot3dcl(): Arrays must be of same length!" );
533
534 c_plot3dcl( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length,
535 ixstart, ixn, indexymin.ptr, indexymax.ptr );
536 }
537
538 // Set fill pattern directly.
539 void plpat( PLINT[] inc, PLINT[] del )
540 {
541 PLINT nlin = cast(PLINT) inc.length;
542 assert( nlin == del.length, "plpat(): Arrays must be of same length!" );
543 c_plpat( nlin, inc.ptr, del.ptr );
544 }
545
546 // Plots array y against x for n points using ASCII code "code".
547 void plpoin( PLFLT[] x, PLFLT[] y, PLINT code )
548 {
549 PLINT n = cast(PLINT) x.length;
550 assert( n == y.length, "plpoin(): Arrays must be of same length!" );
551 c_plpoin( n, x.ptr, y.ptr, code );
552 }
553
554 // Draws a series of points in 3 space.
555 void plpoin3( PLFLT[] x, PLFLT[] y, PLFLT[] z, PLINT code )
556 {
557 PLINT n = cast(PLINT) x.length;
558 assert( n == y.length, "plpoin3(): Arrays must be of same length!" );
559 assert( n == z.length, "plpoin3(): Arrays must be of same length!" );
560 c_plpoin3( n, x.ptr, y.ptr, z.ptr, code );
561 }
562
563 // Plots array y against x for n points using (UTF-8) text string
564 void plstring( PLFLT[] x, PLFLT[] y, string text )
565 {
566 PLINT n = cast(PLINT) x.length;
567 assert( n == y.length, "plstring(): Arrays must be of same length!" );
568 c_plstring( n, x.ptr, y.ptr, toStringz( text ) );
569 }
570
571 // Draws a series of points (described by [UTF8] text string) in 3 space.
572 void plstring3( PLFLT[] x, PLFLT[] y, PLFLT[] z, string text )
573 {
574 PLINT n = cast(PLINT) x.length;
575 assert( n == y.length, "plstring3(): Arrays must be of same length!" );
576 assert( n == z.length, "plstring3(): Arrays must be of same length!" );
577 c_plstring3( n, x.ptr, y.ptr, z.ptr, toStringz( text ) );
578 }
579
580 // Draws a polygon in 3 space.
581 void plpoly3( PLFLT[] x, PLFLT[] y, PLFLT[] z, PLBOOL[] draw, PLBOOL ifcc )
582 {
583 PLINT n = cast(PLINT) x.length;
584 assert( n == y.length, "plpoly3(): Arrays must be of same length!" );
585 assert( n == z.length, "plpoly3(): Arrays must be of same length!" );
586 assert( n - 1 == draw.length, "plpoly3(): Array draw must be of same length then other arrays minus 1!" );
587 c_plpoly3( n, x.ptr, y.ptr, z.ptr, draw.ptr, ifcc );
588 }
589
590 // Prints out "text" at world cooordinate (x,y).
591 void plptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, string text )
592 {
593 c_plptex( x, y, dx, dy, just, toStringz( text ) );
594 }
595
596 // Prints out "text" at world cooordinate (x,y,z).
597 void plptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz,
598 PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, string text )
599 {
600 c_plptex3( wx, wy, wz, dx, dy, dz, sx, sy, sz, just, toStringz( text ) );
601 }
602
603 // Set the colors for color table 0 from a cmap0 file
604 void plspal0( string filename )
605 {
606 c_plspal0( toStringz( filename ) );
607 }
608
609 // Set the colors for color table 1 from a cmap1 file
610 void plspal1( string filename, PLBOOL interpolate )
611 {
612 c_plspal1( toStringz( filename ), interpolate );
613 }
614
615 // Set color map 0 colors by 8 bit RGB values
616 void plscmap0( PLINT[] r, PLINT[] g, PLINT[] b )
617 {
618 PLINT ncol0 = cast(PLINT) r.length;
619 assert( ncol0 == g.length, "plscmap0(): Arrays must be of same length!" );
620 assert( ncol0 == b.length, "plscmap0(): Arrays must be of same length!" );
621 c_plscmap0( r.ptr, g.ptr, b.ptr, ncol0 );
622 }
623
624 // Set color map 0 colors by 8 bit RGB values and alpha values
625 void plscmap0a( PLINT[] r, PLINT[] g, PLINT[] b, PLFLT[] a )
626 {
627 PLINT ncol0 = cast(PLINT) r.length;
628 assert( ncol0 == g.length, "plscmap0a(): Arrays must be of same length!" );
629 assert( ncol0 == b.length, "plscmap0a(): Arrays must be of same length!" );
630 assert( ncol0 == a.length, "plscmap0a(): Arrays must be of same length!" );
631 c_plscmap0a( r.ptr, g.ptr, b.ptr, a.ptr, ncol0 );
632 }
633
634 // Set color map 1 colors by 8 bit RGB values
635 void plscmap1( PLINT[] r, PLINT[] g, PLINT[] b )
636 {
637 PLINT ncol1 = cast(PLINT) r.length;
638 assert( ncol1 == g.length, "plscmap1(): Arrays must be of same length!" );
639 assert( ncol1 == b.length, "plscmap1(): Arrays must be of same length!" );
640 c_plscmap1( r.ptr, g.ptr, b.ptr, ncol1 );
641 }
642
643 // Set color map 1 colors by 8 bit RGB and alpha values
644 void plscmap1a( PLINT[] r, PLINT[] g, PLINT[] b, PLFLT[] a )
645 {
646 PLINT ncol1 = cast(PLINT) r.length;
647 assert( ncol1 == g.length, "plscmap1a(): Arrays must be of same length!" );
648 assert( ncol1 == b.length, "plscmap1a(): Arrays must be of same length!" );
649 assert( ncol1 == a.length, "plscmap1a(): Arrays must be of same length!" );
650 c_plscmap1a( r.ptr, g.ptr, b.ptr, a.ptr, ncol1 );
651 }
652
653 // Set color map 1 colors using a piece-wise linear relationship between
654 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
655 void plscmap1l( PLBOOL itype, PLFLT[] intensity, PLFLT[] coord1,
656 PLFLT[] coord2, PLFLT[] coord3, PLBOOL[] alt_hue_path = null )
657 {
658 PLINT npts = cast(PLINT) intensity.length;
659 assert( npts == coord1.length, "plscmap1l(): Arrays must be of same length!" );
660 assert( npts == coord2.length, "plscmap1l(): Arrays must be of same length!" );
661 assert( npts == coord3.length, "plscmap1l(): Arrays must be of same length!" );
662 if ( alt_hue_path != null )
663 {
664 assert( npts - 1 == alt_hue_path.length, "plscmap1l(): Array alt_hue_path must be of same length then other arrays minus 1!" );
665 c_plscmap1l( itype, npts, intensity.ptr, coord1.ptr, coord2.ptr, coord3.ptr, alt_hue_path.ptr );
666 }
667 else
668 c_plscmap1l( itype, npts, intensity.ptr, coord1.ptr, coord2.ptr, coord3.ptr, null );
669 }
670
671
672 // Set color map 1 colors using a piece-wise linear relationship between
673 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
674 // Will also linear interpolate alpha values.
675 void plscmap1la( PLBOOL itype, PLFLT[] intensity, PLFLT[] coord1,
676 PLFLT[] coord2, PLFLT[] coord3, PLFLT[] a, PLBOOL[] alt_hue_path = null )
677 {
678 PLINT npts = cast(PLINT) intensity.length;
679 assert( npts == coord1.length, "plscmap1la(): Arrays must be of same length!" );
680 assert( npts == coord2.length, "plscmap1la(): Arrays must be of same length!" );
681 assert( npts == coord3.length, "plscmap1la(): Arrays must be of same length!" );
682 assert( npts == a.length, "plscmap1la(): Arrays must be of same length!" );
683 if ( alt_hue_path != null )
684 {
685 assert( npts - 1 == alt_hue_path.length, "plscmap1la(): Array alt_hue_path must be of same length then other arrays minus 1!" );
686 c_plscmap1la( itype, npts, intensity.ptr, coord1.ptr, coord2.ptr, coord3.ptr, a.ptr, alt_hue_path.ptr );
687 }
688 else
689 c_plscmap1la( itype, npts, intensity.ptr, coord1.ptr, coord2.ptr, coord3.ptr, a.ptr, null );
690 }
691
692 // Set the device (keyword) name
693 void plsdev( string devname )
694 {
695 c_plsdev( toStringz( devname ) );
696 }
697
698 // Set the output file name.
699 void plsfnam( string fnam )
700 {
701 c_plsfnam( toStringz( fnam ) );
702 }
703
704 // Shade region.
705 void plshade( PLFLT[][] a, def_func defined, PLFLT left, PLFLT right,
706 PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap,
707 PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color,
708 PLFLT max_width, PLBOOL rectangular,
709 pltr_func pltr = null, PLPointer pltr_data = null )
710 {
711 PLINT nx = cast(PLINT) a.length;
712 PLINT ny = cast(PLINT) a[0].length;
713
714 c_plshade( convert_array( a ), nx, ny, defined, left, right, bottom, top, shade_min, shade_max, sh_cmap,
715 sh_color, sh_width, min_color, min_width, max_color, max_width, &c_plfill,
716 rectangular, pltr, pltr_data );
717 }
718
719 void plshades( PLFLT[][] a, def_func defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
720 PLFLT[] clevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width,
721 PLBOOL rectangular, pltr_func pltr = null, PLPointer pltr_data = null )
722 {
723 PLINT nx = cast(PLINT) a.length;
724 PLINT ny = cast(PLINT) a[0].length;
725
726 c_plshades( convert_array( a ), nx, ny, defined, xmin, xmax, ymin, ymax, clevel.ptr, cast(PLINT) clevel.length,
727 fill_width, cont_color, cont_width, &c_plfill, rectangular, pltr, pltr_data );
728 }
729
730 void plshades( PLFLT[][] a, def_func defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
731 PLFLT[] clevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width,
732 PLBOOL rectangular, ref PLcGrid cgrid )
733 {
734 PLINT nx = cast(PLINT) a.length;
735 PLINT ny = cast(PLINT) a[0].length;
736
737 c_PLcGrid c;
738 c.xg = cgrid.xg.ptr;
739 c.nx = cast(PLINT) cgrid.xg.length;
740 c.yg = cgrid.yg.ptr;
741 c.ny = cast(PLINT) cgrid.yg.length;
742 c.zg = cgrid.zg.ptr;
743 c.nz = cast(PLINT) cgrid.zg.length;
744
745 c_plshades( convert_array( a ), nx, ny, defined, xmin, xmax, ymin, ymax, clevel.ptr, cast(PLINT) clevel.length,
746 fill_width, cont_color, cont_width, &c_plfill, rectangular, &pltr1, &c );
747 }
748
749 void plshades( PLFLT[][] a, def_func defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
750 PLFLT[] clevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width,
751 PLBOOL rectangular, ref PLcGrid2 cgrid2 )
752 {
753 PLINT nx = cast(PLINT) a.length;
754 PLINT ny = cast(PLINT) a[0].length;
755
756 c_PLcGrid2 c2;
757 c2.xg = convert_array( cgrid2.xg );
758 c2.yg = convert_array( cgrid2.yg );
759 c2.zg = convert_array( cgrid2.zg );
760 c2.nx = cast(PLINT) cgrid2.xg.length;
761 c2.ny = cast(PLINT) cgrid2.xg[0].length;
762 if ( cgrid2.yg )
763 {
764 assert( c2.nx == cgrid2.yg.length, "plcont(): Arrays must be of same length!" );
765 assert( c2.ny == cgrid2.yg[0].length, "plcont(): Arrays must be of same length!" );
766 }
767 if ( cgrid2.zg )
768 {
769 assert( c2.nx == cgrid2.zg.length, "plcont(): Arrays must be of same length!" );
770 assert( c2.ny == cgrid2.zg[0].length, "plcont(): Arrays must be of same length!" );
771 }
772
773 c_plshades( convert_array( a ), nx, ny, defined, xmin, xmax, ymin, ymax, clevel.ptr, cast(PLINT) clevel.length,
774 fill_width, cont_color, cont_width, &c_plfill, rectangular, &pltr2, &c2 );
775 }
776
777 // Initialize PLplot, passing the device name and windows/page settings.
778 void plstart( string devname, PLINT nx, PLINT ny )
779 {
780 c_plstart( toStringz( devname ), nx, ny );
781 }
782
783 // Create 1d stripchart
784 void plstripc( PLINT* id, string xspec, string yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump,
785 PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc,
786 PLINT colbox, PLINT collab, PLINT[] colline, PLINT[] styline, string[] legline,
787 string labx, string laby, string labtop )
788 {
789 assert( 4 == colline.length, "plstripc(): Arrays must be of length 4!" );
790 assert( 4 == styline.length, "plstripc(): Arrays must be of length 4!" );
791 assert( 4 == legline.length, "plstripc(): Arrays must be of length 4!" );
792
793 immutable( char ) * *leglinez = array( map!toStringz( legline ) ).ptr;
794 //for ( int i = 0; i < 4; i++ )
795 //{
796 // leglinez[i] = toStringz( legline[i] );
797 //}
798
799 c_plstripc( id, toStringz( xspec ), toStringz( yspec ), xmin, xmax, xjump, ymin, ymax,
800 xlpos, ylpos, y_ascl, acc, colbox, collab, colline.ptr, styline.ptr, leglinez,
801 toStringz( labx ), toStringz( laby ), toStringz( labtop ) );
802 }
803
804 // plots a 2d image (or a matrix too large for plshade() )
805 void plimagefr( PLFLT[][] idata, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
806 PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax,
807 pltr_func pltr = null, PLPointer pltr_data = null )
808 {
809 PLINT nx = cast(PLINT) idata.length;
810 PLINT ny = cast(PLINT) idata[0].length;
811
812 c_plimagefr( convert_array( idata ), nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
813 valuemin, valuemax, pltr, pltr_data );
814 }
815
816 // plots a 2d image (or a matrix too large for plshade() )
817 void plimagefr( PLFLT[][] idata, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
818 PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLcGrid cgrid )
819 {
820 PLINT nx = cast(PLINT) idata.length;
821 PLINT ny = cast(PLINT) idata[0].length;
822
823 c_PLcGrid c;
824 c.xg = cgrid.xg.ptr;
825 c.nx = cast(PLINT) cgrid.xg.length;
826 c.yg = cgrid.yg.ptr;
827 c.ny = cast(PLINT) cgrid.yg.length;
828 c.zg = cgrid.zg.ptr;
829 c.nz = cast(PLINT) cgrid.zg.length;
830
831 c_plimagefr( convert_array( idata ), nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
832 valuemin, valuemax, &pltr1, &c );
833 }
834
835 // plots a 2d image (or a matrix too large for plshade() )
836 void plimagefr( PLFLT[][] idata, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
837 PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLcGrid2 cgrid2 )
838 {
839 PLINT nx = cast(PLINT) idata.length;
840 PLINT ny = cast(PLINT) idata[0].length;
841
842 c_PLcGrid2 c2;
843 c2.xg = convert_array( cgrid2.xg );
844 c2.yg = convert_array( cgrid2.yg );
845 c2.zg = convert_array( cgrid2.zg );
846 c2.nx = cast(PLINT) cgrid2.xg.length;
847 c2.ny = cast(PLINT) cgrid2.xg[0].length;
848 if ( cgrid2.yg )
849 {
850 assert( c2.nx == cgrid2.yg.length, "plcont(): Arrays must be of same length!" );
851 assert( c2.ny == cgrid2.yg[0].length, "plcont(): Arrays must be of same length!" );
852 }
853 if ( cgrid2.zg )
854 {
855 assert( c2.nx == cgrid2.zg.length, "plcont(): Arrays must be of same length!" );
856 assert( c2.ny == cgrid2.zg[0].length, "plcont(): Arrays must be of same length!" );
857 }
858
859 c_plimagefr( convert_array( idata ), nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
860 valuemin, valuemax, &pltr2, &c2 );
861 }
862
863 // plots a 2d image (or a matrix too large for plshade() ) - colors
864 // automatically scaled
865 void plimage( PLFLT[][] idata, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
866 PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax )
867 {
868 PLINT nx = cast(PLINT) idata.length;
869 PLINT ny = cast(PLINT) idata[0].length;
870
871 c_plimage( convert_array( idata ), nx, ny, xmin, xmax, ymin, ymax, zmin, zmax, Dxmin, Dxmax,
872 Dymin, Dymax );
873 }
874
875 // Set up a new line style
876 void plstyl( PLINT[] mark, PLINT[] space )
877 {
878 PLINT nms = cast(PLINT) mark.length;
879 assert( nms == space.length, "plstyl(): Arrays must be of same length!" );
880 c_plstyl( nms, mark.ptr, space.ptr );
881 }
882
883 // Plots the 3d surface representation of the function z[x][y].
884 void plsurf3d( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel = null )
885 {
886 PLINT nx = cast(PLINT) z.length;
887 PLINT ny = cast(PLINT) z[0].length;
888 assert( nx == x.length, "plsurf3d(): Arrays must be of same length!" );
889 assert( ny == y.length, "plsurf3d(): Arrays must be of same length!" );
890
891 if ( clevel )
892 c_plsurf3d( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length );
893 else
894 c_plsurf3d( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, null, 0 );
895 }
896
897 // Plots the 3d surface representation of the function z[x][y] with y
898 // index limits.
899 void plsurf3dl( PLFLT[] x, PLFLT[] y, PLFLT[][] z, PLINT opt, PLFLT[] clevel,
900 PLINT ixstart, PLINT ixn, PLINT[] indexymin, PLINT[] indexymax )
901 {
902 PLINT nx = cast(PLINT) z.length;
903 PLINT ny = cast(PLINT) z[0].length;
904 assert( nx == x.length, "plsurf3d(): Arrays must be of same length!" );
905 assert( ny == y.length, "plsurf3d(): Arrays must be of same length!" );
906
907 c_plsurf3dl( x.ptr, y.ptr, convert_array( z ), nx, ny, opt, clevel.ptr, cast(PLINT) clevel.length,
908 ixstart, ixn, indexymin.ptr, indexymax.ptr );
909 }
910
911 // Plots array y against x for n points using Hershey symbol "code"
912 void plsym( PLFLT[] x, PLFLT[] y, PLINT code )
913 {
914 PLINT n = cast(PLINT) x.length;
915 assert( n == y.length, "plsym(): Arrays must be of same length!" );
916 c_plsym( n, x.ptr, y.ptr, code );
917 }
918
919 // Set the format for date / time labels
920 void pltimefmt( string fmt )
921 {
922 c_pltimefmt( toStringz( fmt ) );
923 }
924
925 //--------------------------------------------------------------------------
926 // Functions for use from C or C++ only
927 //--------------------------------------------------------------------------
928
929 // Returns a list of file-oriented device names and their menu strings
930 //void plgFileDevs(char ***p_menustr, char ***p_devname, int *p_ndev);
931
932 // Returns a list of all device names and their menu strings
933 //void plgDevs(char ***p_menustr, char ***p_devname, int *p_ndev);
934
935 // Set the function pointer for the keyboard event handler
936 //void plsKeyEH(void function(PLGraphicsIn *, void *, int *)KeyEH, void *KeyEH_data);
937
938 // Set the function pointer for the (mouse) button event handler
939 //void plsButtonEH(void function(PLGraphicsIn *, void *, int *)ButtonEH, void *ButtonEH_data);
940
941 // Sets an optional user bop handler
942 //void plsbopH(void function(void *, int *)handler, void *handler_data);
943
944 // Sets an optional user eop handler
945 //void plseopH(void function(void *, int *)handler, void *handler_data);
946
947 // Set the variables to be used for storing error info
948 //void plsError(PLINT *errcode, char *errmsg)
949 //{
950 //}
951
952 // Sets an optional user exit handler.
953 //void plsexit(int function(char *)handler);
954
955 // Sets an optional user abort handler.
956 //void plsabort(void function(char *)handler);
957
958 // Function evaluators
959
960 // Does a lookup from a 2d function array. Array is of type (PLFLT **),
961 // and is column dominant (normal C ordering).
962 //PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data);
963
964 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
965 // and is column dominant (normal C ordering).
966 //PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data);
967
968 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
969 // and is row dominant (Fortran ordering).
970 //PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data);
971
972 // Command line parsing utilities
973
974 // Merge user option table into internal info structure.
975 //PLINT plMergeOpts(PLOptionTable *options, char *name, char **notes);
976
977 // Set the strings used in usage and syntax messages.
978 //void plSetUsage(char *program_string, char *usage_string);
979
980 // Process input strings, treating them as an option and argument pair.
981 PLINT plsetopt( string opt, string optarg )
982 {
983 return c_plsetopt( toStringz( opt ), toStringz( optarg ) );
984 }
985
986 // Miscellaneous
987
988 // Get the escape character for text strings.
989 //void plgesc(char *p_esc);
990
991 // Front-end to driver escape function.
992 //void pl_cmd(PLINT op, void *ptr);
993
994 // Return full pathname for given file if executable
995 //PLINT plFindName(char *p);
996
997 // Looks for the specified executable file according to usual search path.
998 //char * plFindCommand(char *fn);
999
1000 // Gets search name for file by concatenating the dir, subdir, and file
1001 // name, allocating memory as needed.
1002 //void plGetName(char *dir, char *subdir, char *filename, char **filespec);
1003
1004 // Prompts human to input an integer in response to given message.
1005 //PLINT plGetInt(char *s);
1006
1007 // Prompts human to input a float in response to given message.
1008 //PLFLT plGetFlt(char *s);
1009
1010 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
1011 void plMinMax2dGrid( PLFLT[][] f, out PLFLT fmax, out PLFLT fmin )
1012 {
1013 plMinMax2dGrid( convert_array( f ), cast(PLINT) f.length, cast(PLINT) f[0].length, &fmax, &fmin );
1014 }
1015
1016 // Wait for graphics input event and translate to world coordinates
1017 //PLINT plGetCursor(PLGraphicsIn *gin);
1018
1019 // Translates relative device coordinates to world coordinates.
1020 //PLINT plTranslateCursor(PLGraphicsIn *gin);
1021
1022 extern ( C ) :
1023
1024 alias double PLFLT;
1025
1026 // This is apparently portable if stdint.h exists.
1027 // A reasonable back-up in case stdint.h does not exist on the platform.
1028 alias uint PLUNICODE;
1029 alias int PLINT;
1030
1031 // For identifying logical (boolean) arguments
1032 alias PLINT PLBOOL;
1033
1034 // For passing user data, as with X's XtPointer
1035 alias void* PLPointer;
1036
1037 //--------------------------------------------------------------------------
1038 // Complex data types and other good stuff
1039 //--------------------------------------------------------------------------
1040
1041
1042 // Define constants that are accessible from the API
1043 // MAINTENANCE 2017-12
1044 // These are taken from the "#define" section of bindings/swig-support/plplotcapi.i
1045 // and transformed as follows:
1046 // grep '^#define' bindings/swig-support/plplotcapi.i |sed -e '/#define / s?#define ?const ?' -e 's? \([(0-9]\)? = \1?' -e 's? * //.*$??' -e 's? *$?;?' | grep '=' >|/tmp/software
1047 // and then that generated file was inserted here.
1048
1049 const PLESC_SET_RGB = 1;
1050 const PLESC_ALLOC_NCOL = 2;
1051 const PLESC_SET_LPB = 3;
1052 const PLESC_EXPOSE = 4;
1053 const PLESC_RESIZE = 5;
1054 const PLESC_REDRAW = 6;
1055 const PLESC_TEXT = 7;
1056 const PLESC_GRAPH = 8;
1057 const PLESC_FILL = 9;
1058 const PLESC_DI = 10;
1059 const PLESC_FLUSH = 11;
1060 const PLESC_EH = 12;
1061 const PLESC_GETC = 13;
1062 const PLESC_SWIN = 14;
1063 const PLESC_DOUBLEBUFFERING = 15;
1064 const PLESC_XORMOD = 16;
1065 const PLESC_SET_COMPRESSION = 17;
1066 const PLESC_CLEAR = 18;
1067 const PLESC_DASH = 19;
1068 const PLESC_HAS_TEXT = 20;
1069 const PLESC_IMAGE = 21;
1070 const PLESC_IMAGEOPS = 22;
1071 const PLESC_PL2DEVCOL = 23;
1072 const PLESC_DEV2PLCOL = 24;
1073 const PLESC_SETBGFG = 25;
1074 const PLESC_DEVINIT = 26;
1075 const PLESC_GETBACKEND = 27;
1076 const PLESC_BEGIN_TEXT = 28;
1077 const PLESC_TEXT_CHAR = 29;
1078 const PLESC_CONTROL_CHAR = 30;
1079 const PLESC_END_TEXT = 31;
1080 const PLESC_START_RASTERIZE = 32;
1081 const PLESC_END_RASTERIZE = 33;
1082 const PLESC_ARC = 34;
1083 const PLESC_GRADIENT = 35;
1084 const PLESC_MODESET = 36;
1085 const PLESC_MODEGET = 37;
1086 const PLESC_FIXASPECT = 38;
1087 const PLESC_IMPORT_BUFFER = 39;
1088 const PLESC_APPEND_BUFFER = 40;
1089 const PLESC_FLUSH_REMAINING_BUFFER = 41;
1090 const PLTEXT_FONTCHANGE = 0;
1091 const PLTEXT_SUPERSCRIPT = 1;
1092 const PLTEXT_SUBSCRIPT = 2;
1093 const PLTEXT_BACKCHAR = 3;
1094 const PLTEXT_OVERLINE = 4;
1095 const PLTEXT_UNDERLINE = 5;
1096 const ZEROW2B = 1;
1097 const ZEROW2D = 2;
1098 const ONEW2B = 3;
1099 const ONEW2D = 4;
1100 const PLSWIN_DEVICE = 1;
1101 const PLSWIN_WORLD = 2;
1102 const PL_X_AXIS = 1;
1103 const PL_Y_AXIS = 2;
1104 const PL_Z_AXIS = 3;
1105 const PL_OPT_ENABLED = 0x0001;
1106 const PL_OPT_ARG = 0x0002;
1107 const PL_OPT_NODELETE = 0x0004;
1108 const PL_OPT_INVISIBLE = 0x0008;
1109 const PL_OPT_DISABLED = 0x0010;
1110 const PL_OPT_FUNC = 0x0100;
1111 const PL_OPT_BOOL = 0x0200;
1112 const PL_OPT_INT = 0x0400;
1113 const PL_OPT_FLOAT = 0x0800;
1114 const PL_OPT_STRING = 0x1000;
1115 const PL_PARSE_PARTIAL = 0x0000;
1116 const PL_PARSE_FULL = 0x0001;
1117 const PL_PARSE_QUIET = 0x0002;
1118 const PL_PARSE_NODELETE = 0x0004;
1119 const PL_PARSE_SHOWALL = 0x0008;
1120 const PL_PARSE_OVERRIDE = 0x0010;
1121 const PL_PARSE_NOPROGRAM = 0x0020;
1122 const PL_PARSE_NODASH = 0x0040;
1123 const PL_PARSE_SKIP = 0x0080;
1124 const PL_FCI_MARK = 0x80000000;
1125 const PL_FCI_IMPOSSIBLE = 0x00000000;
1126 const PL_FCI_HEXDIGIT_MASK = 0xf;
1127 const PL_FCI_HEXPOWER_MASK = 0x7;
1128 const PL_FCI_HEXPOWER_IMPOSSIBLE = 0xf;
1129 const PL_FCI_FAMILY = 0x0;
1130 const PL_FCI_STYLE = 0x1;
1131 const PL_FCI_WEIGHT = 0x2;
1132 const PL_FCI_SANS = 0x0;
1133 const PL_FCI_SERIF = 0x1;
1134 const PL_FCI_MONO = 0x2;
1135 const PL_FCI_SCRIPT = 0x3;
1136 const PL_FCI_SYMBOL = 0x4;
1137 const PL_FCI_UPRIGHT = 0x0;
1138 const PL_FCI_ITALIC = 0x1;
1139 const PL_FCI_OBLIQUE = 0x2;
1140 const PL_FCI_MEDIUM = 0x0;
1141 const PL_FCI_BOLD = 0x1;
1142 const PL_MAXKEY = 16;
1143 const PL_MASK_SHIFT = 0x1;
1144 const PL_MASK_CAPS = 0x2;
1145 const PL_MASK_CONTROL = 0x4;
1146 const PL_MASK_ALT = 0x8;
1147 const PL_MASK_NUM = 0x10;
1148 const PL_MASK_ALTGR = 0x20;
1149 const PL_MASK_WIN = 0x40;
1150 const PL_MASK_SCROLL = 0x80;
1151 const PL_MASK_BUTTON1 = 0x100;
1152 const PL_MASK_BUTTON2 = 0x200;
1153 const PL_MASK_BUTTON3 = 0x400;
1154 const PL_MASK_BUTTON4 = 0x800;
1155 const PL_MASK_BUTTON5 = 0x1000;
1156 const PL_MAXWINDOWS = 64;
1157 const PL_NOTSET = ( -42 );
1158 const PLESC_DOUBLEBUFFERING_ENABLE = 1;
1159 const PLESC_DOUBLEBUFFERING_DISABLE = 2;
1160 const PLESC_DOUBLEBUFFERING_QUERY = 3;
1161 const PL_BIN_DEFAULT = 0x0;
1162 const PL_BIN_CENTRED = 0x1;
1163 const PL_BIN_NOEXPAND = 0x2;
1164 const PL_BIN_NOEMPTY = 0x4;
1165 const GRID_CSA = 1;
1166 const GRID_DTLI = 2;
1167 const GRID_NNI = 3;
1168 const GRID_NNIDW = 4;
1169 const GRID_NNLI = 5;
1170 const GRID_NNAIDW = 6;
1171 const PL_HIST_DEFAULT = 0x00;
1172 const PL_HIST_NOSCALING = 0x01;
1173 const PL_HIST_IGNORE_OUTLIERS = 0x02;
1174 const PL_HIST_NOEXPAND = 0x08;
1175 const PL_HIST_NOEMPTY = 0x10;
1176 const PL_POSITION_NULL = 0x0;
1177 const PL_POSITION_LEFT = 0x1;
1178 const PL_POSITION_RIGHT = 0x2;
1179 const PL_POSITION_TOP = 0x4;
1180 const PL_POSITION_BOTTOM = 0x8;
1181 const PL_POSITION_INSIDE = 0x10;
1182 const PL_POSITION_OUTSIDE = 0x20;
1183 const PL_POSITION_VIEWPORT = 0x40;
1184 const PL_POSITION_SUBPAGE = 0x80;
1185 const PL_LEGEND_NULL = 0x0;
1186 const PL_LEGEND_NONE = 0x1;
1187 const PL_LEGEND_COLOR_BOX = 0x2;
1188 const PL_LEGEND_LINE = 0x4;
1189 const PL_LEGEND_SYMBOL = 0x8;
1190 const PL_LEGEND_TEXT_LEFT = 0x10;
1191 const PL_LEGEND_BACKGROUND = 0x20;
1192 const PL_LEGEND_BOUNDING_BOX = 0x40;
1193 const PL_LEGEND_ROW_MAJOR = 0x80;
1194 const PL_COLORBAR_NULL = 0x0;
1195 const PL_COLORBAR_LABEL_LEFT = 0x1;
1196 const PL_COLORBAR_LABEL_RIGHT = 0x2;
1197 const PL_COLORBAR_LABEL_TOP = 0x4;
1198 const PL_COLORBAR_LABEL_BOTTOM = 0x8;
1199 const PL_COLORBAR_IMAGE = 0x10;
1200 const PL_COLORBAR_SHADE = 0x20;
1201 const PL_COLORBAR_GRADIENT = 0x40;
1202 const PL_COLORBAR_CAP_NONE = 0x80;
1203 const PL_COLORBAR_CAP_LOW = 0x100;
1204 const PL_COLORBAR_CAP_HIGH = 0x200;
1205 const PL_COLORBAR_SHADE_LABEL = 0x400;
1206 const PL_COLORBAR_ORIENT_RIGHT = 0x800;
1207 const PL_COLORBAR_ORIENT_TOP = 0x1000;
1208 const PL_COLORBAR_ORIENT_LEFT = 0x2000;
1209 const PL_COLORBAR_ORIENT_BOTTOM = 0x4000;
1210 const PL_COLORBAR_BACKGROUND = 0x8000;
1211 const PL_COLORBAR_BOUNDING_BOX = 0x10000;
1212 const PL_DRAWMODE_UNKNOWN = 0x0;
1213 const PL_DRAWMODE_DEFAULT = 0x1;
1214 const PL_DRAWMODE_REPLACE = 0x2;
1215 const PL_DRAWMODE_XOR = 0x4;
1216 const DRAW_LINEX = 0x001;
1217 const DRAW_LINEY = 0x002;
1218 const DRAW_LINEXY = 0x003;
1219 const MAG_COLOR = 0x004;
1220 const BASE_CONT = 0x008;
1221 const TOP_CONT = 0x010;
1222 const SURF_CONT = 0x020;
1223 const DRAW_SIDES = 0x040;
1224 const FACETED = 0x080;
1225 const MESH = 0x100;
1226 // End of constants.
1227
1228 // Obsolete names
1229
1230 // Option table definition
1231
1232 struct _N1
1233 {
1234 string opt;
1235 int function( char *, char *, void * ) handler;
1236 void *client_data;
1237 void *var;
1238 int mode;
1239 string syntax;
1240 string desc;
1241 }
1242 alias _N1 PLOptionTable;
1243
1244 // PLplot Graphics Input structure
1245
1246
1247 struct _N2
1248 {
1249 int type;
1250 uint state;
1251 uint keysym;
1252 uint button;
1253 PLINT subwindow;
1254 char [16] string;
1255 int pX;
1256 int pY;
1257 PLFLT dX;
1258 PLFLT dY;
1259 PLFLT wX;
1260 PLFLT wY;
1261 }
1262 alias _N2 PLGraphicsIn;
1263
1264 // Structure for describing the plot window
1265
1266
1267 struct _N3
1268 {
1269 PLFLT dxmi;
1270 PLFLT dxma;
1271 PLFLT dymi;
1272 PLFLT dyma;
1273 PLFLT wxmi;
1274 PLFLT wxma;
1275 PLFLT wymi;
1276 PLFLT wyma;
1277 }
1278 alias _N3 PLWindow;
1279
1280 // Structure for doing display-oriented operations via escape commands
1281 // May add other attributes in time
1282
1283 struct _N4
1284 {
1285 uint x;
1286 uint y;
1287 uint width;
1288 uint height;
1289 }
1290 alias _N4 PLDisplay;
1291
1292 // See plcont.c for examples of the following
1293
1294 //
1295 // PLfGrid is for passing (as a pointer to the first element) an arbitrarily
1296 // dimensioned array. The grid dimensions MUST be stored, with a maximum of 3
1297 // dimensions assumed for now.
1298 //
1299
1300 struct _N5
1301 {
1302 PLFLT *f;
1303 PLINT nx;
1304 PLINT ny;
1305 PLINT nz;
1306 }
1307 alias _N5 PLfGrid;
1308
1309 //
1310 // PLfGrid2 is for passing (as an array of pointers) a 2d function array. The
1311 // grid dimensions are passed for possible bounds checking.
1312 //
1313
1314 struct _N6
1315 {
1316 PLFLT **f;
1317 PLINT nx;
1318 PLINT ny;
1319 }
1320 alias _N6 PLfGrid2;
1321
1322 //
1323 // NOTE: a PLfGrid3 is a good idea here but there is no way to exploit it yet
1324 // so I'll leave it out for now.
1325 //
1326
1327 //
1328 // PLcGrid is for passing (as a pointer to the first element) arbitrarily
1329 // dimensioned coordinate transformation arrays. The grid dimensions MUST be
1330 // stored, with a maximum of 3 dimensions assumed for now.
1331 //
1332
1333 struct _N7
1334 {
1335 PLFLT *xg;
1336 PLFLT *yg;
1337 PLFLT *zg;
1338 PLINT nx;
1339 PLINT ny;
1340 PLINT nz;
1341 }
1342 alias _N7 c_PLcGrid;
1343
1344 //
1345 // PLcGrid2 is for passing (as arrays of pointers) 2d coordinate
1346 // transformation arrays. The grid dimensions are passed for possible bounds
1347 // checking.
1348 //
1349
1350 struct _N8
1351 {
1352 PLFLT **xg;
1353 PLFLT **yg;
1354 PLFLT **zg;
1355 PLINT nx;
1356 PLINT ny;
1357 }
1358 alias _N8 c_PLcGrid2;
1359
1360 //
1361 // NOTE: a PLcGrid3 is a good idea here but there is no way to exploit it yet
1362 // so I'll leave it out for now.
1363 //
1364
1365 // PLColor is the usual way to pass an rgb color value.
1366
1367 struct _N9
1368 {
1369 ubyte r;
1370 ubyte g;
1371 ubyte b;
1372 PLFLT a;
1373 char *name;
1374 }
1375 alias _N9 PLColor;
1376
1377 // PLControlPt is how cmap1 control points are represented.
1378
1379 struct _N10
1380 {
1381 PLFLT h;
1382 PLFLT l;
1383 PLFLT s;
1384 PLFLT p;
1385 PLFLT a;
1386 int alt_hue_path;
1387 }
1388 alias _N10 PLControlPt;
1389
1390 // A PLBufferingCB is a control block for interacting with devices
1391 // that support double buffering.
1392
1393 struct _N11
1394 {
1395 PLINT cmd;
1396 PLINT result;
1397 }
1398 alias _N11 PLBufferingCB;
1399
1400 //--------------------------------------------------------------------------* * BRAINDEAD-ness
1401 //
1402 // Some systems allow the Fortran & C namespaces to clobber each other.
1403 // For PLplot to work from Fortran on these systems, we must name the the
1404 // externally callable C functions something other than their Fortran entry
1405 // names. In order to make this as easy as possible for the casual user,
1406 // yet reversible to those who abhor my solution, I have done the
1407 // following:
1408 //
1409 // The C-language bindings are actually different from those
1410 // described in the manual. Macros are used to convert the
1411 // documented names to the names used in this package. The
1412 // user MUST include plplot.h in order to get the name
1413 // redefinition correct.
1414 //
1415 // Sorry to have to resort to such an ugly kludge, but it is really the
1416 // best way to handle the situation at present. If all available
1417 // compilers offer a way to correct this stupidity, then perhaps we can
1418 // eventually reverse it.
1419 //
1420 // If you feel like screaming at someone (I sure do), please
1421 // direct it at your nearest system vendor who has a braindead shared
1422 // C/Fortran namespace. Some vendors do offer compiler switches that
1423 // change the object names, but then everybody who wants to use the
1424 // package must throw these same switches, leading to no end of trouble.
1425 //
1426 // Note that this definition should not cause any noticable effects except
1427 // when debugging PLplot calls, in which case you will need to remember
1428 // the real function names (same as before but with a 'c_' prepended).
1429 //
1430 // Also, to avoid macro conflicts, the BRAINDEAD part must not be expanded
1431 // in the stub routines.
1432 //
1433 // Aside: the reason why a shared Fortran/C namespace is deserving of the
1434 // BRAINDEAD characterization is that it completely precludes the the kind
1435 // of universal API that is attempted (more or less) with PLplot, without
1436 // Herculean efforts (e.g. remapping all of the C bindings by macros as
1437 // done here). The vendors of such a scheme, in order to allow a SINGLE
1438 // type of argument to be passed transparently between C and Fortran,
1439 // namely, a pointer to a conformable data type, have slammed the door on
1440 // insertion of stub routines to handle the conversions needed for other
1441 // data types. Intelligent linkers could solve this problem, but these are
1442 // not anywhere close to becoming universal. So meanwhile, one must live
1443 // with either stub routines for the inevitable data conversions, or a
1444 // different API. The former is what is used here, but is made far more
1445 // difficult in a braindead shared Fortran/C namespace.
1446 //--------------------------------------------------------------------------
1447
1448
1449
1450
1451 alias c_pl_setcontlabelformat pl_setcontlabelformat;
1452 alias c_pl_setcontlabelparam pl_setcontlabelparam;
1453 alias c_pladv pladv;
1454 //alias c_plaxes plaxes;
1455 //alias c_plbin plbin;
1456 alias c_plbop plbop;
1457 //alias c_plbox plbox;
1458 //alias c_plbox3 plbox3;
1459 alias c_plbtime plbtime;
1460 alias c_plslabelfunc plslabelfunc;
1461 alias c_plcalc_world plcalc_world;
1462 alias c_plarc plarc;
1463 alias c_plclear plclear;
1464 alias c_plcol0 plcol0;
1465 alias c_plcol1 plcol1;
1466 //alias c_plcolorbar plcolorbar;
1467 alias c_plconfigtime plconfigtime;
1468 //alias c_plcont plcont;
1469 alias c_plcpstrm plcpstrm;
1470 alias c_plctime plctime;
1471 alias c_plend plend;
1472 alias c_plend1 plend1;
1473 alias c_plenv plenv;
1474 alias c_plenv0 plenv0;
1475 alias c_pleop pleop;
1476 //alias c_plerrx plerrx;
1477 //alias c_plerry plerry;
1478 alias c_plfamadv plfamadv;
1479 //alias c_plfill plfill;
1480 //alias c_plfill3 plfill3;
1481 alias c_plflush plflush;
1482 alias c_plfont plfont;
1483 alias c_plfontld plfontld;
1484 alias c_plgchr plgchr;
1485 alias c_plgcol0 plgcol0;
1486 alias c_plgcolbg plgcolbg;
1487 alias c_plgcol0a plgcol0a;
1488 alias c_plgcolbga plgcolbga;
1489 alias c_plgcompression plgcompression;
1490 //alias c_plgdev plgdev;
1491 alias c_plgdidev plgdidev;
1492 alias c_plgdiori plgdiori;
1493 alias c_plgdiplt plgdiplt;
1494 alias c_plgfam plgfam;
1495 alias c_plgfci plgfci;
1496 //alias c_plgfnam plgfnam;
1497 alias c_plgfont plgfont;
1498 alias c_plglevel plglevel;
1499 alias c_plgpage plgpage;
1500 alias c_plgradient plgrdient;
1501 alias c_plgra plgra;
1502 //alias c_plgriddata plgriddata;
1503 alias c_plgspa plgspa;
1504 alias c_plgstrm plgstrm;
1505 //alias c_plgver plgver;
1506 alias c_plgvpd plgvpd;
1507 alias c_plgvpw plgvpw;
1508 alias c_plgxax plgxax;
1509 alias c_plgyax plgyax;
1510 alias c_plgzax plgzax;
1511 //alias c_plhist plhist;
1512 alias c_plhlsrgb plhlsrgb;
1513 //alias c_plimage plimage;
1514 //alias c_plimagefr plimagefr;
1515 alias c_plinit plinit;
1516 alias c_pljoin pljoin;
1517 //alias c_pllab pllab;
1518 //alias c_pllegend pllegend;
1519 alias c_pllightsource pllightsource;
1520 //alias c_plline plline;
1521 alias c_plpath plpath;
1522 //alias c_plline3 plline3;
1523 alias c_pllsty pllsty;
1524 //alias c_plmap plmap;
1525 alias c_plmeridians plmeridians;
1526 //alias c_plmesh plmesh;
1527 //alias c_plmeshc plmeshc;
1528 alias c_plmkstrm plmkstrm;
1529 //alias c_plmtex plmtex;
1530 //alias c_plmtex3 plmtex3;
1531 //alias c_plot3d plot3d;
1532 //alias c_plot3dc plot3dc;
1533 //alias c_plot3dcl plot3dcl;
1534 //alias c_plparseopts plparseopts;
1535 //alias c_plpat plpat;
1536 //alias c_plpoin plpoin;
1537 //alias c_plpoin3 plpoin3;
1538 //alias c_plpoly3 plpoly3;
1539 alias c_plprec plprec;
1540 alias c_plpsty plpsty;
1541 //alias c_plptex plptex;
1542 //alias c_plptex3 plptex3;
1543 alias c_plrandd plrandd;
1544 alias c_plreplot plreplot;
1545 alias c_plrgbhls plrgbhls;
1546 alias c_plschr plschr;
1547 //alias c_plscmap0 plscmap0;
1548 //alias c_plscmap0a plscmap0a;
1549 alias c_plscmap0n plscmap0n;
1550 //alias c_plscmap1 plscmap1;
1551 //alias c_plscmap1a plscmap1a;
1552 //alias c_plscmap1l plscmap1l;
1553 //alias c_plscmap1la plscmap1la;
1554 alias c_plscmap1n plscmap1n;
1555 alias c_plscmap1_range plscmap1_range;
1556 alias c_plscol0 plscol0;
1557 alias c_plscol0a plscol0a;
1558 alias c_plscolbg plscolbg;
1559 alias c_plscolbga plscolbga;
1560 alias c_plscolor plscolor;
1561 alias c_plscompression plscompression;
1562 // alias c_plsdev plsdev;
1563 alias c_plsdidev plsdidev;
1564 alias c_plsdimap plsdimap;
1565 alias c_plsdiori plsdiori;
1566 alias c_plsdiplt plsdiplt;
1567 alias c_plsdiplz plsdiplz;
1568 alias c_plseed plseed;
1569 alias c_plsesc plsesc;
1570 //alias c_plsetopt plsetopt;
1571 alias c_plsfam plsfam;
1572 alias c_plsfci plsfci;
1573 // alias c_plsfnam plsfnam;
1574 alias c_plsfont plsfont;
1575 //alias c_plshade plshade;
1576 //alias c_plshades plshades;
1577 alias c_plsmaj plsmaj;
1578 alias c_plsmem plsmem;
1579 alias c_plsmin plsmin;
1580 alias c_plsori plsori;
1581 alias c_plspage plspage;
1582 // alias c_plspal0 plspal0;
1583 // alias c_plspal1 plspal1;
1584 alias c_plspause plspause;
1585 alias c_plsstrm plsstrm;
1586 alias c_plssub plssub;
1587 alias c_plssym plssym;
1588 alias c_plstar plstar;
1589 //alias c_plstart plstart;
1590 alias c_plstransform plstransform;
1591 alias c_plstripa plstripa;
1592 //alias c_plstripc plstripc;
1593 alias c_plstripd plstripd;
1594 //alias c_plstring plstring;
1595 //alias c_plstring3 plstring3;
1596 //alias c_plstyl plstyl;
1597 //alias c_plsurf3d plsurf3d;
1598 //alias c_plsurf3dl plsurf3dl;
1599 //alias c_plsvect plsvect;
1600 alias c_plsvpa plsvpa;
1601 alias c_plsxax plsxax;
1602 alias c_plsyax plsyax;
1603 //alias c_plsym plsym;
1604 alias c_plszax plszax;
1605 alias c_pltext pltext;
1606 //alias c_pltimefmt pltimefmt;
1607 alias c_plvasp plvasp;
1608 //alias c_plvect plvect;
1609 alias c_plvpas plvpas;
1610 alias c_plvpor plvpor;
1611 alias c_plvsta plvsta;
1612 alias c_plw3d plw3d;
1613 alias c_plwidth plwidth;
1614 alias c_plwind plwind;
1615
1616 alias c_plxormod plxormod;
1617
1618
1619 //--------------------------------------------------------------------------* * Function Prototypes
1620 //--------------------------------------------------------------------------
1621
1622
1623 // All void types
1624 // C routines callable from stub routines come first
1625
1626 // set the format of the contour labels
1627 void c_pl_setcontlabelformat( PLINT lexp, PLINT sigdig );
1628
1629 // set offset and spacing of contour labels
1630 void c_pl_setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing, PLINT active );
1631
1632 // Advance to subpage "page", or to the next one if "page" = 0.
1633 void c_pladv( PLINT page );
1634
1635 // simple arrow plotter.
1636 void c_plvect( PLFLT **u, PLFLT **v, PLINT nx, PLINT ny, PLFLT scale,
1637 void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1638 void c_plsvect( PLFLT *arrowx, PLFLT *arrowy, PLINT npts, PLBOOL fill );
1639
1640 // This functions similarly to plbox() except that the origin of the axes
1641 // is placed at the user-specified point (x0, y0).
1642 void c_plaxes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
1643 const char *yopt, PLFLT ytick, PLINT nysub );
1644
1645 // Plot a histogram using x to store data values and y to store frequencies
1646 void c_plbin( PLINT nbin, PLFLT *x, PLFLT *y, PLINT opt );
1647
1648 // Start new page. Should only be used with pleop().
1649 void c_plbop();
1650
1651 // This draws a box around the current viewport.
1652 void c_plbox( const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub );
1653
1654 // This is the 3-d analogue of plbox().
1655 void c_plbox3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx, const char *yopt,
1656 const char *ylabel, PLFLT ytick, PLINT nsuby, const char *zopt, const char *zlabel,
1657 PLFLT ztick, PLINT nsubz );
1658
1659 // Calculate broken-down time from continuous time for current stream.
1660 void c_plbtime( PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime );
1661
1662 // Setup a user-provided custom labeling function
1663 void c_plslabelfunc( void function( PLINT, PLFLT, char*, PLINT, PLPointer ) labelfunc,
1664 PLPointer label_data );
1665
1666 // Calculate world coordinates and subpage from relative device coordinates.
1667 void c_plcalc_world( PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window );
1668
1669 // Plot an arc
1670 void c_plarc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
1671 PLFLT rotate, PLBOOL fill );
1672
1673 // Clear current subpage.
1674 void c_plclear();
1675
1676 // Set color, map 0. Argument is integer between 0 and 15.
1677 void c_plcol0( PLINT icol0 );
1678
1679 // Set color, map 1. Argument is a float between 0. and 1.
1680 void c_plcol1( PLFLT col1 );
1681
1682
1683 // Configure transformation between continuous and broken-down time (and
1684 // vice versa) for current stream.
1685 void c_plconfigtime( PLFLT scale, PLFLT offset1, PLFLT offset2, PLINT ccontrol, PLBOOL ifbtime_offset,
1686 PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec );
1687
1688 // Draws a contour plot from data in f(nx,ny). Is just a front-end to
1689 // plfcont, with a particular choice for f2eval and f2eval_data.
1690 //
1691 void c_plcont( PLFLT **f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly,
1692 PLFLT *clevel, PLINT nlevel,
1693 void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1694
1695 // Draws a contour plot using the function evaluator f2eval and data stored
1696 // by way of the f2eval_data pointer. This allows arbitrary organizations
1697 // of 2d array data to be used.
1698 //
1699 void plfcont( PLFLT function( PLINT, PLINT, PLPointer ) f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny,
1700 PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel,
1701 void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1702
1703 // Copies state parameters from the reference stream to the current stream.
1704 void c_plcpstrm( PLINT iplsr, PLBOOL flags );
1705
1706 // Calculate continuous time from broken-down time for current stream.
1707 void c_plctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime );
1708
1709 // Converts input values from relative device coordinates to relative plot
1710 // coordinates.
1711 void pldid2pc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );
1712
1713 // Converts input values from relative plot coordinates to relative
1714 // device coordinates.
1715 void pldip2dc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );
1716
1717 // End a plotting session for all open streams.
1718 void c_plend();
1719
1720 // End a plotting session for the current stream only.
1721 void c_plend1();
1722
1723 // Simple interface for defining viewport and window.
1724 void c_plenv( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis );
1725
1726 // similar to plenv() above, but in multiplot mode does not advance the subpage,
1727 // instead the current subpage is cleared
1728 void c_plenv0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis );
1729
1730 // End current page. Should only be used with plbop().
1731 void c_pleop();
1732
1733 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i))
1734 void c_plerrx( PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y );
1735
1736 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i))
1737 void c_plerry( PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax );
1738
1739 // Advance to the next family file on the next new page
1740 void c_plfamadv();
1741
1742 // Pattern fills the polygon bounded by the input points.
1743 void c_plfill( PLINT n, PLFLT *x, PLFLT *y );
1744
1745 // Pattern fills the 3d polygon bounded by the input points.
1746 void c_plfill3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z );
1747
1748 // Flushes the output stream. Use sparingly, if at all.
1749 void c_plflush();
1750
1751 // Sets the global font flag to 'ifont'.
1752 void c_plfont( PLINT ifont );
1753
1754 // Load specified font set.
1755 void c_plfontld( PLINT fnt );
1756
1757 // Get character default height and current (scaled) height
1758 void c_plgchr( PLFLT *p_def, PLFLT *p_ht );
1759
1760 // Returns 8 bit RGB values for given color from color map 0
1761 void c_plgcol0( PLINT icol0, PLINT *r, PLINT *g, PLINT *b );
1762
1763 // Returns 8 bit RGB values for given color from color map 0 and alpha value
1764 void c_plgcol0a( PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a );
1765
1766 // Returns the background color by 8 bit RGB value
1767 void c_plgcolbg( PLINT *r, PLINT *g, PLINT *b );
1768
1769 // Returns the background color by 8 bit RGB value and alpha value
1770 void c_plgcolbga( PLINT *r, PLINT *g, PLINT *b, PLFLT *a );
1771
1772 // Returns the current compression setting
1773 void c_plgcompression( PLINT *compression );
1774
1775 // Get the current device (keyword) name
1776 void c_plgdev( char *p_dev );
1777
1778 // Retrieve current window into device space
1779 void c_plgdidev( PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy );
1780
1781 // Get plot orientation
1782 void c_plgdiori( PLFLT *p_rot );
1783
1784 // Retrieve current window into plot space
1785 void c_plgdiplt( PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax );
1786
1787 // Get FCI (font characterization integer)
1788
1789 void c_plgfci( PLUNICODE *pfci );
1790
1791 // Get family file parameters
1792
1793 void c_plgfam( PLINT *p_fam, PLINT *p_num, PLINT *p_bmax );
1794
1795 // Get the (current) output file name. Must be preallocated to >80 bytes
1796 void c_plgfnam( char *fnam );
1797
1798 // Get the current font family, style and weight
1799 void c_plgfont( PLINT *p_family, PLINT *p_style, PLINT *p_weight );
1800
1801 // Get the (current) run level.
1802 void c_plglevel( PLINT *p_level );
1803
1804 // Get output device parameters.
1805 void c_plgpage( PLFLT *p_xp, PLFLT *p_yp, PLINT *p_xleng, PLINT *p_yleng,
1806 PLINT *p_xoff, PLINT *p_yoff );
1807
1808 // Switches to graphics screen.
1809 void c_plgra();
1810
1811 // Draw gradient in polygon.
1812 void c_plgradient( PLINT n, PLFLT *x, PLFLT *y, PLFLT angle );
1813
1814 // grid irregularly sampled data
1815 void c_plgriddata( PLFLT *x, PLFLT *y, PLFLT *z, PLINT npts, PLFLT *xg, PLINT nptsx,
1816 PLFLT *yg, PLINT nptsy, PLFLT **zg, PLINT type, PLFLT data );
1817
1818 // Get subpage boundaries in absolute coordinates
1819 void c_plgspa( PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax );
1820
1821 // Get current stream number.
1822 void c_plgstrm( PLINT *p_strm );
1823
1824 // Get the current library version number
1825 void c_plgver( char *p_ver );
1826
1827 // Get viewport boundaries in normalized device coordinates
1828 void c_plgvpd( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax );
1829
1830 // Get viewport boundaries in world coordinates
1831 void c_plgvpw( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax );
1832
1833 // Get x axis labeling parameters
1834 void c_plgxax( PLINT *p_digmax, PLINT *p_digits );
1835
1836 // Get y axis labeling parameters
1837 void c_plgyax( PLINT *p_digmax, PLINT *p_digits );
1838
1839 // Get z axis labeling parameters
1840 void c_plgzax( PLINT *p_digmax, PLINT *p_digits );
1841
1842 // Draws a histogram of n values of a variable in array data[0..n-1]
1843 void c_plhist( PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt );
1844
1845 // Functions for converting between HLS and RGB color space
1846 void c_plhlsrgb( PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b );
1847
1848 // Initializes PLplot, using preset or default options
1849 void c_plinit();
1850
1851 // Draws a line segment from (x1, y1) to (x2, y2).
1852 void c_pljoin( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
1853
1854 // Simple routine for labelling graphs.
1855 void c_pllab( const char *xlabel, const char *ylabel, const char *tlabel );
1856
1857 // Routine for drawing discrete line, symbol, or cmap0 legends
1858 void c_pllegend( PLFLT *p_legend_width, PLFLT *p_legend_height,
1859 PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
1860 PLINT bg_color, PLINT bb_color, PLINT bb_style,
1861 PLINT nrow, PLINT ncolumn,
1862 PLINT nlegend, PLINT *opt_array,
1863 PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
1864 PLFLT text_justification,
1865 PLINT *text_colors, const char **text,
1866 PLINT *box_colors, PLINT *box_patterns,
1867 PLFLT *box_scales, PLFLT *box_line_widths,
1868 PLINT *line_colors, PLINT *line_styles,
1869 PLFLT *line_widths,
1870 PLINT *symbol_colors, PLFLT *symbol_scales,
1871 PLINT *symbol_numbers, const char **symbols );
1872
1873 // Routine for drawing continuous colour legends
1874 void c_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
1875 PLINT opt, PLINT position, PLFLT x, PLFLT y,
1876 PLFLT x_length, PLFLT y_length,
1877 PLINT bg_color, PLINT bb_color, PLINT bb_style,
1878 PLFLT low_cap_color, PLFLT high_cap_color,
1879 PLINT cont_color, PLFLT cont_width,
1880 PLINT n_labels, const PLINT *label_opts, const char **label,
1881 PLINT n_axes, const char ** axis_opts,
1882 const PLFLT *ticks, const PLINT *sub_ticks,
1883 const PLINT *n_values, const PLFLT **values );
1884
1885 // Sets position of the light source
1886 void c_pllightsource( PLFLT x, PLFLT y, PLFLT z );
1887
1888 // Draws line segments connecting a series of points.
1889 void c_plline( PLINT n, PLFLT *x, PLFLT *y );
1890
1891 // Draws a line in 3 space.
1892 void c_plline3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z );
1893
1894 // Set line style.
1895 void c_pllsty( PLINT lin );
1896
1897 // plot continental outline in world coordinates
1898 void c_plmap( void function( PLINT, PLFLT *, PLFLT* ) mapform, const char *type, PLFLT minlong,
1899 PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
1900
1901 // Plot map outlines
1902 void c_plmapline( void function( PLINT, PLFLT *, PLFLT * ) mapform, const char *name,
1903 PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1904 const PLINT *plotentries, PLINT nplotentries );
1905
1906 // Plot map points
1907 void c_plmapstring( void function( PLINT, PLFLT *, PLFLT * ) mapform,
1908 const char *name, const char *string,
1909 PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1910 const PLINT *plotentries, PLINT nplotentries );
1911
1912 // Plot map text
1913 void c_plmaptex( void function( PLINT, PLFLT *, PLFLT * ) mapform,
1914 const char *name, PLFLT dx, PLFLT dy, PLFLT just, const char *text,
1915 PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1916 PLINT plotentry );
1917
1918 // Plot map fills
1919 void c_plmapfill( void function( PLINT, PLFLT *, PLFLT * ) mapform,
1920 const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1921 const PLINT *plotentries, PLINT nplotentries );
1922
1923 // Plot the latitudes and longitudes on the background.
1924 void c_plmeridians( void function( PLINT, PLFLT *, PLFLT* ) mapform, PLFLT dlong, PLFLT dlat,
1925 PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
1926
1927 // Plots a mesh representation of the function z[x][y].
1928 void c_plmesh( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt );
1929
1930 // Plots a mesh representation of the function z[x][y] with contour
1931 void c_plmeshc( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1932 PLFLT *clevel, PLINT nlevel );
1933
1934 // Creates a new stream and makes it the default.
1935 void c_plmkstrm( PLINT *p_strm );
1936
1937 // Prints out "text" at specified position relative to viewport
1938 void c_plmtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text );
1939
1940 // Prints out "text" at specified position relative to viewport (3D)
1941 void c_plmtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text );
1942
1943 // Plots a 3-d representation of the function z[x][y].
1944 void c_plot3d( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side );
1945
1946 // Plots a 3-d representation of the function z[x][y] with contour.
1947 void c_plot3dc( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1948 PLFLT *clevel, PLINT nlevel );
1949
1950 // Plots a 3-d representation of the function z[x][y] with contour and
1951 // y index limits.
1952 void c_plot3dcl( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1953 PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn,
1954 PLINT *indexymin, PLINT *indexymax );
1955
1956 //
1957 // valid options for plot3dc():
1958 //
1959 // DRAW_SIDES, BASE_CONT, TOP_CONT (not yet),
1960 // MAG_COLOR, DRAW_LINEX, DRAW_LINEY, DRAW_LINEXY.
1961 //
1962 // valid options for plsurf3d():
1963 //
1964 // MAG_COLOR, BASE_CONT, SURF_CONT, FACETED, DRAW_SIDES.
1965 //
1966
1967 // Set fill pattern directly.
1968 void c_plpat( PLINT nlin, PLINT *inc, PLINT *del );
1969
1970 // Draw a line connecting two points, accounting for coordinate transforms
1971 void c_plpath( PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
1972
1973 // Plots array y against x for n points using ASCII code "code".
1974 void c_plpoin( PLINT n, PLFLT *x, PLFLT *y, PLINT code );
1975
1976 // Draws a series of points in 3 space.
1977 void c_plpoin3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code );
1978
1979 // Draws a polygon in 3 space.
1980 void c_plpoly3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc );
1981
1982 // Plots array y against x for n points using (UTF-8) text string
1983 void c_plstring( PLINT n, PLFLT *x, PLFLT *y, const char *text );
1984
1985 // Draws a series of points (described by [UTF8] text string) in 3 space.
1986 void c_plstring3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, const char * text );
1987
1988 // Set the floating point precision (in number of places) in numeric labels.
1989 void c_plprec( PLINT setp, PLINT prec );
1990
1991 // Set fill pattern, using one of the predefined patterns.
1992 void c_plpsty( PLINT patt );
1993
1994 // Prints out "text" at world cooordinate (x,y).
1995 void c_plptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text );
1996
1997 // Prints out "text" at world cooordinate (x,y,z).
1998 void c_plptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz, PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text );
1999
2000 // Random number generator based on Mersenne Twister.
2001 // Obtain real random number in range [0,1].
2002 PLFLT c_plrandd();
2003
2004 // Replays contents of plot buffer to current device/file.
2005 void c_plreplot();
2006
2007 // Functions for converting between HLS and RGB color space
2008
2009 void c_plrgbhls( PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s );
2010
2011 // Set character height.
2012
2013 void c_plschr( PLFLT def, PLFLT scale );
2014
2015 // Set color map 0 colors by 8 bit RGB values
2016 void c_plscmap0( PLINT *r, PLINT *g, PLINT *b, PLINT ncol0 );
2017
2018 // Set color map 0 colors by 8 bit RGB values and alpha values
2019 void c_plscmap0a( PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol0 );
2020
2021 // Set number of colors in cmap 0
2022 void c_plscmap0n( PLINT ncol0 );
2023
2024 // Set color map 1 colors by 8 bit RGB values
2025 void c_plscmap1( PLINT *r, PLINT *g, PLINT *b, PLINT ncol1 );
2026
2027 // Set color map 1 colors by 8 bit RGB and alpha values
2028 void c_plscmap1a( PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol1 );
2029
2030 // Set color map 1 colors using a piece-wise linear relationship between
2031 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
2032 void c_plscmap1l( PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLBOOL *alt_hue_path );
2033
2034 // Set color map 1 colors using a piece-wise linear relationship between
2035 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
2036 // Will also linear interpolate alpha values.
2037 void c_plscmap1la( PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLFLT *a, PLBOOL *alt_hue_path );
2038
2039 // Set number of colors in cmap 1
2040 void c_plscmap1n( PLINT ncol1 );
2041
2042 // Set the color map 1 range used in continuous plots
2043 void c_plscmap1_range( PLFLT min_color, PLFLT max_color );
2044
2045 // Get the color map 1 range used in continuous plots
2046 void c_plgcmap1_range( PLFLT *min_color, PLFLT *max_color );
2047
2048 // Set a given color from color map 0 by 8 bit RGB value
2049 void c_plscol0( PLINT icol0, PLINT r, PLINT g, PLINT b );
2050
2051 // Set a given color from color map 0 by 8 bit RGB value
2052 void c_plscol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a );
2053
2054 // Set the background color by 8 bit RGB value
2055 void c_plscolbg( PLINT r, PLINT g, PLINT b );
2056
2057 // Set the background color by 8 bit RGB value and alpha value
2058 void c_plscolbga( PLINT r, PLINT g, PLINT b, PLFLT a );
2059
2060 // Used to globally turn color output on/off
2061 void c_plscolor( PLINT color );
2062
2063 // Set the compression level
2064
2065 void c_plscompression( PLINT compression );
2066
2067 // Set the device (keyword) name
2068 void c_plsdev( const char *devname );
2069
2070 // Set window into device space using margin, aspect ratio, and
2071 // justification
2072
2073 void c_plsdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy );
2074
2075 // Set up transformation from metafile coordinates.
2076
2077 void c_plsdimap( PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax, PLFLT dimxpmm, PLFLT dimypmm );
2078
2079 // Set plot orientation, specifying rotation in units of pi/2.
2080
2081 void c_plsdiori( PLFLT rot );
2082
2083 // Set window into plot space
2084
2085 void c_plsdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
2086
2087 // Set window into plot space incrementally (zoom)
2088 void c_plsdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
2089
2090 // Set seed for internal random number generator
2091 void c_plseed( uint s );
2092
2093 // Set the escape character for text strings.
2094 void c_plsesc( char esc );
2095
2096 // Set family file parameters
2097
2098 void c_plsfam( PLINT fam, PLINT num, PLINT bmax );
2099
2100 // Set FCI (font characterization integer)
2101
2102 void c_plsfci( PLUNICODE fci );
2103
2104 // Set the output file name.
2105 void c_plsfnam( const char *fnam );
2106
2107 // Set the current font family, style and weight
2108
2109 void c_plsfont( PLINT family, PLINT style, PLINT weight );
2110
2111 // Shade region.
2112 void c_plshade( PLFLT **a, PLINT nx, PLINT ny, PLINT function( PLFLT, PLFLT ) defined, PLFLT left,
2113 PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap,
2114 PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color,
2115 PLFLT max_width, void function( PLINT, PLFLT *, PLFLT* ) fill, PLBOOL rectangular,
2116 void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
2117
2118 void c_plshades( PLFLT **a, PLINT nx, PLINT ny, PLINT function( PLFLT, PLFLT ) defined, PLFLT xmin,
2119 PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT *clevel, PLINT nlevel, PLFLT fill_width,
2120 PLINT cont_color, PLFLT cont_width, void function( PLINT, PLFLT *, PLFLT* ) fill,
2121 PLBOOL rectangular, void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr,
2122 PLPointer pltr_data );
2123
2124 void plfshade( PLFLT function( PLINT, PLINT, PLPointer ) f2eval, PLPointer f2eval_data, PLFLT function( PLINT, PLINT, PLPointer ) c2eval, PLPointer c2eval_data, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, void function( PLINT, PLFLT *, PLFLT * ) fill, PLBOOL rectangular, void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
2125
2126 // Set up lengths of major tick marks.
2127
2128 void c_plsmaj( PLFLT def, PLFLT scale );
2129
2130 // Set the memory area to be plotted (with the 'mem' driver)
2131
2132 void c_plsmem( PLINT maxx, PLINT maxy, void *plotmem );
2133
2134 // Set up lengths of minor tick marks.
2135
2136 void c_plsmin( PLFLT def, PLFLT scale );
2137
2138 // Set orientation. Must be done before calling plinit.
2139
2140 void c_plsori( PLINT ori );
2141
2142 // Set output device parameters. Usually ignored by the driver.
2143 void c_plspage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng, PLINT xoff, PLINT yoff );
2144
2145 // Set the colors for color table 0 from a cmap0 file
2146 void c_plspal0( const char* filename );
2147
2148 // Set the colors for color table 1 from a cmap1 file
2149 void c_plspal1( const char *filename, PLBOOL interpolate );
2150
2151 // Set the pause (on end-of-page) status
2152 void c_plspause( PLBOOL pause );
2153
2154 // Set stream number.
2155
2156 void c_plsstrm( PLINT strm );
2157
2158 // Set the number of subwindows in x and y
2159
2160 void c_plssub( PLINT nx, PLINT ny );
2161
2162 // Set symbol height.
2163
2164 void c_plssym( PLFLT def, PLFLT scale );
2165
2166 // Initialize PLplot, passing in the windows/page settings.
2167 void c_plstar( PLINT nx, PLINT ny );
2168
2169 // Initialize PLplot, passing the device name and windows/page settings.
2170 void c_plstart( const char *devname, PLINT nx, PLINT ny );
2171
2172 // Set the coordinate transform
2173 void c_plstransform( ct_func coordinate_transform = null, PLPointer coordinate_transform_data = null );
2174
2175 // Add a point to a stripchart.
2176 void c_plstripa( PLINT id, PLINT pen, PLFLT x, PLFLT y );
2177
2178 // Create 1d stripchart
2179 void c_plstripc( PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, PLINT *colline, PLINT *styline, const char **legline, const char *labx, const char *laby, const char *labtop );
2180
2181 // Deletes and releases memory used by a stripchart.
2182 void c_plstripd( PLINT id );
2183
2184 // plots a 2d image (or a matrix too large for plshade() )
2185 void c_plimagefr( PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2186 PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax,
2187 void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ), PLPointer pltr_data );
2188
2189 // plots a 2d image (or a matrix too large for plshade() ) - colors
2190 // automatically scaled
2191 void c_plimage( PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2192 PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax );
2193
2194 // Set up a new line style
2195 void c_plstyl( PLINT nms, PLINT *mark, PLINT *space );
2196
2197 // Plots the 3d surface representation of the function z[x][y].
2198 void c_plsurf3d( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
2199 PLFLT *clevel, PLINT nlevel );
2200
2201 // Plots the 3d surface representation of the function z[x][y] with y
2202 // index limits.
2203 void c_plsurf3dl( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel,
2204 PLINT nlevel, PLINT ixstart, PLINT ixn, PLINT *indexymin, PLINT *indexymax );
2205
2206 // Sets the edges of the viewport to the specified absolute coordinates
2207 void c_plsvpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2208
2209 // Set x axis labeling parameters
2210 void c_plsxax( PLINT digmax, PLINT digits );
2211
2212 // Set inferior X window
2213 void plsxwin( PLINT window_id );
2214
2215 // Set y axis labeling parameters
2216 void c_plsyax( PLINT digmax, PLINT digits );
2217
2218 // Plots array y against x for n points using Hershey symbol "code"
2219 void c_plsym( PLINT n, PLFLT *x, PLFLT *y, PLINT code );
2220
2221 // Set z axis labeling parameters
2222
2223 void c_plszax( PLINT digmax, PLINT digits );
2224
2225 // Switches to text screen.
2226
2227 void c_pltext();
2228
2229 // Set the format for date / time labels
2230 void c_pltimefmt( const char *fmt );
2231
2232 // Sets the edges of the viewport with the given aspect ratio, leaving
2233 // room for labels.
2234
2235 void c_plvasp( PLFLT aspect );
2236
2237 // Creates the largest viewport of the specified aspect ratio that fits
2238 // within the specified normalized subpage coordinates.
2239
2240 void c_plvpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect );
2241
2242 // Creates a viewport with the specified normalized subpage coordinates.
2243
2244 void c_plvpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2245
2246 // Defines a "standard" viewport with seven character heights for
2247 // the left margin and four character heights everywhere else.
2248
2249 void c_plvsta();
2250
2251 // Set up a window for three-dimensional plotting.
2252
2253 void c_plw3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0, PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0, PLFLT zmax0, PLFLT alt, PLFLT az );
2254
2255 // Set pen width.
2256
2257 void c_plwidth( PLFLT width );
2258
2259 // Set up world coordinates of the viewport boundaries (2d plots).
2260
2261 void c_plwind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2262
2263 // set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
2264
2265 void c_plxormod( PLBOOL mode, PLBOOL *status );
2266
2267 //--------------------------------------------------------------------------* * Functions for use from C or C++ only
2268 //--------------------------------------------------------------------------
2269
2270 // Returns a list of file-oriented device names and their menu strings
2271
2272 void plgFileDevs( char ***p_menustr, char ***p_devname, int *p_ndev );
2273
2274 // Returns a list of all device names and their menu strings
2275
2276 void plgDevs( char ***p_menustr, char ***p_devname, int *p_ndev );
2277
2278 // Set the function pointer for the keyboard event handler
2279
2280 void plsKeyEH( void function( PLGraphicsIn *, void *, int * ) KeyEH, void *KeyEH_data );
2281
2282 // Set the function pointer for the (mouse) button event handler
2283
2284 void plsButtonEH( void function( PLGraphicsIn *, void *, int * ) ButtonEH, void *ButtonEH_data );
2285
2286 // Sets an optional user bop handler
2287
2288 void plsbopH( void function( void *, int * ) handler, void *handler_data );
2289
2290 // Sets an optional user eop handler
2291
2292 void plseopH( void function( void *, int * ) handler, void *handler_data );
2293
2294 // Set the variables to be used for storing error info
2295
2296 void plsError( PLINT *errcode, const char *errmsg );
2297
2298 // Sets an optional user exit handler.
2299
2300 void plsexit( int function( const char * ) handler );
2301
2302 // Sets an optional user abort handler.
2303
2304 void plsabort( void function( const char * ) handler );
2305
2306 // Transformation routines
2307
2308 // Identity transformation.
2309 void pltr0( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2310
2311 // Does linear interpolation from singly dimensioned coord arrays.
2312 void pltr1( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2313
2314 // Does linear interpolation from doubly dimensioned coord arrays
2315 // (column dominant, as per normal C 2d arrays).
2316 void pltr2( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2317
2318 // Just like pltr2() but uses pointer arithmetic to get coordinates from
2319 // 2d grid tables.
2320 void pltr2p( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2321
2322 // Identity transformation for plots from Fortran.
2323 void pltr0f( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, void* pltr_data );
2324
2325 // Does linear interpolation from doubly dimensioned coord arrays
2326 // (row dominant, i.e. Fortran ordering).
2327 void pltr2f( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, void* pltr_data );
2328
2329 // Function evaluators
2330
2331 // Does a lookup from a 2d function array. Array is of type (PLFLT **),
2332 // and is column dominant (normal C ordering).
2333
2334 PLFLT plf2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2335
2336 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
2337 // and is column dominant (normal C ordering).
2338
2339 PLFLT plf2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2340
2341 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
2342 // and is row dominant (Fortran ordering).
2343
2344 PLFLT plf2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2345
2346 // Command line parsing utilities
2347 // Clear internal option table info structure.
2348 void plClearOpts();
2349
2350 // Reset internal option table info structure.
2351 void plResetOpts();
2352
2353 // Merge user option table into internal info structure.
2354
2355 PLINT plMergeOpts( PLOptionTable *options, const char *name, const char **notes );
2356
2357 // Set the strings used in usage and syntax messages.
2358
2359 void plSetUsage( const char *program_string, const char *usage_string );
2360
2361 // Process input strings, treating them as an option and argument pair.
2362 PLINT c_plsetopt( const char *opt, const char *optarg );
2363
2364 // Process options list using current options info.
2365 PLINT c_plparseopts( int *p_argc, char **argv, PLINT mode );
2366
2367 // Print usage & syntax message.
2368
2369 void plOptUsage();
2370
2371 // Miscellaneous
2372
2373 // Get the escape character for text strings.
2374
2375 void plgesc( char *p_esc );
2376
2377 // Front-end to driver escape function.
2378
2379 void pl_cmd( PLINT op, void *ptr );
2380
2381 // Return full pathname for given file if executable
2382
2383 PLINT plFindName( char *p );
2384
2385 // Looks for the specified executable file according to usual search path.
2386
2387 char * plFindCommand( const char *fn );
2388
2389 // Gets search name for file by concatenating the dir, subdir, and file
2390 // name, allocating memory as needed.
2391
2392 void plGetName( const char *dir, const char *subdir, const char *filename, char **filespec );
2393
2394 // Prompts human to input an integer in response to given message.
2395
2396 PLINT plGetInt( const char *s );
2397
2398 // Prompts human to input a float in response to given message.
2399
2400 PLFLT plGetFlt( const char *s );
2401
2402 // Nice way to allocate space for a vectored 2d grid
2403
2404 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
2405
2406 void plAlloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny );
2407
2408 // Frees a block of memory allocated with plAlloc2dGrid().
2409
2410 void plFree2dGrid( PLFLT **f, PLINT nx, PLINT ny );
2411
2412 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
2413 void plMinMax2dGrid( PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin );
2414
2415 // Wait for graphics input event and translate to world coordinates
2416
2417 PLINT plGetCursor( PLGraphicsIn *gin );
2418
2419 // Translates relative device coordinates to world coordinates.
2420
2421 PLINT plTranslateCursor( PLGraphicsIn *gin );
2422
plplot::_N3::wxmi
PLFLT wxmi
Definition: plplot.d:1273
plplot::c_plaxes
void c_plaxes(PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
Definition: plbox.c:135
plplot::c_plgfam
void c_plgfam(PLINT *p_fam, PLINT *p_num, PLINT *p_bmax)
Definition: plcore.c:3995
PLESC_REDRAW
#define PLESC_REDRAW
Definition: plplot.h:276
plplot::c_plconfigtime
void c_plconfigtime(PLFLT scale, PLFLT offset1, PLFLT offset2, PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec)
Definition: pltime.c:36
plsfam
#define plsfam
Definition: plplot.h:816
plplot::_N7::nz
PLINT nz
Definition: plplot.d:1340
PL_FCI_BOLD
#define PL_FCI_BOLD
Definition: plplot.h:391
plw3d
#define plw3d
Definition: plplot.h:862
PL_MASK_BUTTON3
#define PL_MASK_BUTTON3
Definition: plplot.h:429
PL_BIN_NOEXPAND
#define PL_BIN_NOEXPAND
Definition: plplot.h:916
plplot::_N7::yg
PLFLT * yg
Definition: plplot.d:1336
plplot::c_pl_setcontlabelformat
void c_pl_setcontlabelformat(PLINT lexp, PLINT sigdig)
Definition: plcont.c:256
PL_OPT_FUNC
#define PL_OPT_FUNC
Definition: plplot.h:349
name
static const char * name
Definition: tkMain.c:135
plpath
#define plpath
Definition: plplot.h:761
plplot::c_plptex3
void c_plptex3(PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz, PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text)
Definition: plsym.c:1982
plplot::PLfGrid
alias _N5 PLfGrid
Definition: plplot.d:1307
argv
static char ** argv
Definition: qt.cpp:49
plplot::c_plscmap1l
void c_plscmap1l(PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLBOOL *alt_hue_path)
plplot::c_plgcolbga
void c_plgcolbga(PLINT *r, PLINT *g, PLINT *b, PLFLT *a)
Definition: plctrl.c:279
ct_func
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotluacLUA_wrap.c:3046
plgxax
#define plgxax
Definition: plplot.h:748
PL_PARSE_NOPROGRAM
#define PL_PARSE_NOPROGRAM
Definition: plplot.h:365
PLESC_XORMOD
#define PLESC_XORMOD
Definition: plplot.h:286
plsstrm
#define plsstrm
Definition: plplot.h:835
plplot::_N1::var
void * var
Definition: plplot.d:1237
plplot::c_plgchr
void c_plgchr(PLFLT *p_def, PLFLT *p_ht)
Definition: plcore.c:4088
plplot::_N8::xg
PLFLT ** xg
Definition: plplot.d:1352
plplot::_N7::zg
PLFLT * zg
Definition: plplot.d:1337
PLESC_DEVINIT
#define PLESC_DEVINIT
Definition: plplot.h:296
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplotluacLUA_wrap.c:3044
plplot::c_plsfci
void c_plsfci(PLUNICODE fci)
Definition: plcore.c:3926
plplot::c_plpsty
void c_plpsty(PLINT patt)
Definition: plsdef.c:327
plplot::plOptUsage
void plOptUsage()
Definition: plargs.c:1304
plplot::c_plssym
void c_plssym(PLFLT def, PLFLT scale)
Definition: plsdef.c:250
plplot::c_plmkstrm
void c_plmkstrm(PLINT *p_strm)
Definition: plcore.c:2671
plplot::c_plseed
void c_plseed(uint s)
plspage
#define plspage
Definition: plplot.h:831
PLESC_DOUBLEBUFFERING_ENABLE
#define PLESC_DOUBLEBUFFERING_ENABLE
Definition: plplot.h:576
plvpor
#define plvpor
Definition: plplot.h:860
PLTEXT_OVERLINE
#define PLTEXT_OVERLINE
Definition: plplot.h:318
plplot::pldid2pc
void pldid2pc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1691
PLESC_DOUBLEBUFFERING_QUERY
#define PLESC_DOUBLEBUFFERING_QUERY
Definition: plplot.h:578
TOP_CONT
#define TOP_CONT
Definition: plplot.h:1508
plplot::c_plsmin
void c_plsmin(PLFLT def, PLFLT scale)
Definition: plsdef.c:220
PLESC_CONTROL_CHAR
#define PLESC_CONTROL_CHAR
Definition: plplot.h:300
PL_LEGEND_LINE
#define PL_LEGEND_LINE
Definition: plplot.h:1290
plplot::c_plstripd
void c_plstripd(PLINT id)
Definition: plstripc.c:327
plplot::c_plscol0a
void c_plscol0a(PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plctrl.c:326
plplot::_N2::type
int type
Definition: plplot.d:1249
plplot::c_plgver
void c_plgver(char *p_ver)
Definition: plcore.c:3970
plplot::_N6::nx
PLINT nx
Definition: plplot.d:1317
PL_COLORBAR_LABEL_TOP
#define PL_COLORBAR_LABEL_TOP
Definition: plplot.h:1301
plplot::_N1::syntax
string syntax
Definition: plplot.d:1239
plplot::_N9
Definition: plplot.d:1367
PL_FCI_UPRIGHT
#define PL_FCI_UPRIGHT
Definition: plplot.h:386
plplot::c_plstripc
void c_plstripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, PLBOOL y_ascl, PLBOOL acc, PLINT colbox, PLINT collab, PLINT *colline, PLINT *styline, const char **legline, const char *labx, const char *laby, const char *labtop)
plmtex3
#define plmtex3
Definition: plplot.h:774
plerry
#define plerry
Definition: plplot.h:715
plplot::c_plend
void c_plend()
Definition: plcore.c:2484
plplot::_N11::result
PLINT result
Definition: plplot.d:1396
plsyax
#define plsyax
Definition: plplot.h:852
PL_PARSE_QUIET
#define PL_PARSE_QUIET
Definition: plplot.h:360
c_plmap
PLDLLIMPEXP void c_plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
plschr
#define plschr
Definition: plplot.h:790
PL_PARSE_NODASH
#define PL_PARSE_NODASH
Definition: plplot.h:366
plsdev
#define plsdev
Definition: plplot.h:806
plplot::c_plgdidev
void c_plgdidev(PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy)
Definition: plcore.c:2007
plplot::c_plsstrm
void c_plsstrm(PLINT strm)
Definition: plcore.c:2621
PL_FCI_MEDIUM
#define PL_FCI_MEDIUM
Definition: plplot.h:390
plgdev
#define plgdev
Definition: plplot.h:729
plplot::PLfGrid2
alias _N6 PLfGrid2
Definition: plplot.d:1320
plplot::c_plcol0
void c_plcol0(PLINT icol0)
Definition: plctrl.c:154
plplot::_N3::wyma
PLFLT wyma
Definition: plplot.d:1276
plplot::c_plcont
void c_plcont(PLFLT **f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
PL_OPT_DISABLED
#define PL_OPT_DISABLED
Definition: plplot.h:345
plplot::c_plscmap1la
void c_plscmap1la(PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLFLT *a, PLBOOL *alt_hue_path)
plplot::_N3::dymi
PLFLT dymi
Definition: plplot.d:1271
min
int min(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2496
plplot::c_plspause
void c_plspause(PLBOOL pause)
Definition: plcore.c:3852
plplot::c_plot3dc
void c_plot3dc(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
SURF_CONT
#define SURF_CONT
Definition: plplot.h:1509
PLESC_FILL
#define PLESC_FILL
Definition: plplot.h:279
plplot::c_PLcGrid2
alias _N8 c_PLcGrid2
Definition: plplot.d:1358
plplot::c_plenv
void c_plenv(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plvpor.c:89
pllegend
#define pllegend
Definition: plplot.h:758
PLESC_DOUBLEBUFFERING
#define PLESC_DOUBLEBUFFERING
Definition: plplot.h:285
mapform
void mapform(PLINT n, PLFLT *x, PLFLT *y)
Definition: tclAPI.c:3693
plplot::c_plline3
void c_plline3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
MAG_COLOR
#define MAG_COLOR
Definition: plplot.h:1506
plplot::_N2::dY
PLFLT dY
Definition: plplot.d:1258
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplotluacLUA_wrap.c:3047
plplot::c_plhlsrgb
void c_plhlsrgb(PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b)
Definition: plctrl.c:1261
plshade
#define plshade
Definition: plplot.h:820
plscompression
#define plscompression
Definition: plplot.h:805
plarc
#define plarc
Definition: plplot.h:693
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
plplot::c_plscompression
void c_plscompression(PLINT compression)
Definition: plcore.c:4270
plplot::c_plot3dcl
void c_plot3dcl(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn, PLINT *indexymin, PLINT *indexymax)
PL_FCI_SYMBOL
#define PL_FCI_SYMBOL
Definition: plplot.h:384
PL_FCI_SERIF
#define PL_FCI_SERIF
Definition: plplot.h:381
plplot::_N2::pX
int pX
Definition: plplot.d:1255
plot3dc
#define plot3dc
Definition: plplot.h:776
plot3dcl
#define plot3dcl
Definition: plplot.h:777
plplot::c_plgcmap1_range
void c_plgcmap1_range(PLFLT *min_color, PLFLT *max_color)
Definition: plctrl.c:924
plplot::c_plstring
void c_plstring(PLINT n, PLFLT *x, PLFLT *y, const char *text)
plplot::pltr2f
void pltr2f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
Definition: plcont.c:1294
plplot::plseopH
void plseopH(void function(void *, int *) handler, void *handler_data)
pllsty
#define pllsty
Definition: plplot.h:763
plplot::_N4
Definition: plplot.d:1283
plsmin
#define plsmin
Definition: plplot.h:829
plwind
#define plwind
Definition: plplot.h:864
plclear
#define plclear
Definition: plplot.h:701
plfill
#define plfill
Definition: plplot.h:717
plconfigtime
#define plconfigtime
Definition: plplot.h:705
argc
static int argc
Definition: qt.cpp:48
plplot::c_plschr
void c_plschr(PLFLT def, PLFLT scale)
Definition: plsdef.c:202
plsurf3dl
#define plsurf3dl
Definition: plplot.h:848
PLTEXT_SUBSCRIPT
#define PLTEXT_SUBSCRIPT
Definition: plplot.h:316
PL_MASK_WIN
#define PL_MASK_WIN
Definition: plplot.h:425
plplot::c_plszax
void c_plszax(PLINT digmax, PLINT digits)
Definition: plcore.c:4079
PL_POSITION_BOTTOM
#define PL_POSITION_BOTTOM
Definition: plplot.h:1280
plplot::c_plot3d
void c_plot3d(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
plplot::_N11::cmd
PLINT cmd
Definition: plplot.d:1395
plmapline
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:594
PL_LEGEND_BACKGROUND
#define PL_LEGEND_BACKGROUND
Definition: plplot.h:1293
plplot::plFindCommand
char * plFindCommand(const char *fn)
Definition: plctrl.c:2146
plbtime
#define plbtime
Definition: plplot.h:699
plplot::c_plgcompression
void c_plgcompression(PLINT *compression)
Definition: plcore.c:4285
pl_setcontlabelparam
#define pl_setcontlabelparam
Definition: plplot.h:691
plplot::plFree2dGrid
void plFree2dGrid(PLFLT **f, PLINT nx, PLINT ny)
plplot::c_plsmaj
void c_plsmaj(PLFLT def, PLFLT scale)
Definition: plsdef.c:235
c_plmeridians
PLDLLIMPEXP void c_plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
plplot::c_plmeshc
void c_plmeshc(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
plplot::c_plwidth
void c_plwidth(PLFLT width)
Definition: plcore.c:3777
plplot::c_plscmap1n
void c_plscmap1n(PLINT ncol1)
Definition: plctrl.c:1067
plscolbg
#define plscolbg
Definition: plplot.h:802
plplot::c_plgradient
void c_plgradient(PLINT n, PLFLT *x, PLFLT *y, PLFLT angle)
plplot::c_plend1
void c_plend1()
Definition: plcore.c:2542
c_plmaptex
PLDLLIMPEXP void c_plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
plfont
#define plfont
Definition: plplot.h:720
plstyl
#define plstyl
Definition: plplot.h:846
PL_MAXKEY
#define PL_MAXKEY
Definition: plplot.h:408
PL_FCI_OBLIQUE
#define PL_FCI_OBLIQUE
Definition: plplot.h:388
plpoly3
#define plpoly3
Definition: plplot.h:782
plimage
#define plimage
Definition: plplot.h:753
PLESC_END_TEXT
#define PLESC_END_TEXT
Definition: plplot.h:301
PL_COLORBAR_ORIENT_TOP
#define PL_COLORBAR_ORIENT_TOP
Definition: plplot.h:1311
PL_LEGEND_SYMBOL
#define PL_LEGEND_SYMBOL
Definition: plplot.h:1291
plplot::c_plspal0
void c_plspal0(const char *filename)
Definition: plctrl.c:1558
plfontld
#define plfontld
Definition: plplot.h:721
PLOptionTable
Definition: plplot.h:395
plplot::c_plarc
void c_plarc(PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2, PLFLT rotate, PLBOOL fill)
Definition: plarc.c:141
PL_COLORBAR_BACKGROUND
#define PL_COLORBAR_BACKGROUND
Definition: plplot.h:1314
plscolbga
#define plscolbga
Definition: plplot.h:803
PL_FCI_HEXPOWER_MASK
#define PL_FCI_HEXPOWER_MASK
Definition: plplot.h:373
PLESC_TEXT
#define PLESC_TEXT
Definition: plplot.h:277
PL_POSITION_LEFT
#define PL_POSITION_LEFT
Definition: plplot.h:1277
plbin
#define plbin
Definition: plplot.h:695
PL_PARSE_NODELETE
#define PL_PARSE_NODELETE
Definition: plplot.h:361
plplot::c_plstransform
void c_plstransform(ct_func coordinate_transform=null, PLPointer coordinate_transform_data=null)
plsdiori
#define plsdiori
Definition: plplot.h:809
PL_FCI_IMPOSSIBLE
#define PL_FCI_IMPOSSIBLE
Definition: plplot.h:371
plplot::c_plscmap0a
void c_plscmap0a(PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol0)
plplot::plSetUsage
void plSetUsage(const char *program_string, const char *usage_string)
Definition: plargs.c:1287
plplot::_N3::dxmi
PLFLT dxmi
Definition: plplot.d:1269
plmeridians
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
plplot::c_plpath
void c_plpath(PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plline.c:94
plparseopts
#define plparseopts
Definition: plplot.h:778
plplot::c_plbop
void c_plbop()
Definition: plpage.c:118
plmaptex
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:639
plsym
#define plsym
Definition: plplot.h:853
plscmap1
#define plscmap1
Definition: plplot.h:794
plplot::c_plscol0
void c_plscol0(PLINT icol0, PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:296
plplot::plsbopH
void plsbopH(void function(void *, int *) handler, void *handler_data)
PL_BIN_CENTRED
#define PL_BIN_CENTRED
Definition: plplot.h:915
std
plinit
#define plinit
Definition: plplot.h:755
PL_BIN_DEFAULT
#define PL_BIN_DEFAULT
Definition: plplot.h:914
plplot::pltr1
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
plplot::c_plscmap0
void c_plscmap0(PLINT *r, PLINT *g, PLINT *b, PLINT ncol0)
plctime
#define plctime
Definition: plplot.h:708
pltimefmt
#define pltimefmt
Definition: plplot.h:856
plscmap1n
#define plscmap1n
Definition: plplot.h:798
PL_OPT_FLOAT
#define PL_OPT_FLOAT
Definition: plplot.h:352
plbop
#define plbop
Definition: plplot.h:696
plplot::c_plvsta
void c_plvsta()
Definition: plvpor.c:307
PLTEXT_SUPERSCRIPT
#define PLTEXT_SUPERSCRIPT
Definition: plplot.h:315
plplot::_N6::f
PLFLT ** f
Definition: plplot.d:1316
plsdiplt
#define plsdiplt
Definition: plplot.h:810
plplot::_N7::xg
PLFLT * xg
Definition: plplot.d:1335
plplot::c_plfont
void c_plfont(PLINT ifont)
Definition: plsym.c:1341
plplot::plsabort
void plsabort(void function(const char *) handler)
plsvect
#define plsvect
Definition: plplot.h:849
plscmap1a
#define plscmap1a
Definition: plplot.h:795
plssub
#define plssub
Definition: plplot.h:836
plplot::plGetName
void plGetName(const char *dir, const char *subdir, const char *filename, char **filespec)
Definition: plctrl.c:2453
plplot::c_plline
void c_plline(PLINT n, PLFLT *x, PLFLT *y)
plplot::_N2::keysym
uint keysym
Definition: plplot.d:1251
GRID_DTLI
#define GRID_DTLI
Definition: plplot.h:1195
PL_FCI_ITALIC
#define PL_FCI_ITALIC
Definition: plplot.h:387
PLPointer
void * PLPointer
Definition: plplot.h:209
plspal1
#define plspal1
Definition: plplot.h:833
plplot::_N9::a
PLFLT a
Definition: plplot.d:1372
plsetopt
#define plsetopt
Definition: plplot.h:815
plplot::c_plsurf3dl
void c_plsurf3dl(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn, PLINT *indexymin, PLINT *indexymax)
plmeshc
#define plmeshc
Definition: plplot.h:771
plgcompression
#define plgcompression
Definition: plplot.h:728
PLTEXT_BACKCHAR
#define PLTEXT_BACKCHAR
Definition: plplot.h:317
plszax
#define plszax
Definition: plplot.h:854
plvsta
#define plvsta
Definition: plplot.h:861
plplot::c_plflush
void c_plflush()
Definition: plcore.c:2230
PL_COLORBAR_SHADE
#define PL_COLORBAR_SHADE
Definition: plplot.h:1304
plplot::plGetCursor
PLINT plGetCursor(PLGraphicsIn *gin)
Definition: plpage.c:244
plplot::c_plprec
void c_plprec(PLINT setp, PLINT prec)
Definition: plcore.c:3860
PLESC_DI
#define PLESC_DI
Definition: plplot.h:280
plplot::c_plbox
void c_plbox(const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
Definition: plbox.c:89
PL_HIST_NOSCALING
#define PL_HIST_NOSCALING
Definition: plplot.h:1246
plplot::c_plgriddata
void c_plgriddata(PLFLT *x, PLFLT *y, PLFLT *z, PLINT npts, PLFLT *xg, PLINT nptsx, PLFLT *yg, PLINT nptsy, PLFLT **zg, PLINT type, PLFLT data)
plplot::_N8
Definition: plplot.d:1350
plplot::plResetOpts
void plResetOpts()
Definition: plargs.c:843
plplot::c_plsdiori
void c_plsdiori(PLFLT rot)
Definition: plcore.c:2022
plgpage
#define plgpage
Definition: plplot.h:739
plaxes
#define plaxes
Definition: plplot.h:694
plplot::c_plsetopt
PLINT c_plsetopt(const char *opt, const char *optarg)
Definition: plargs.c:749
plplot::c_plpoin3
void c_plpoin3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code)
plsori
#define plsori
Definition: plplot.h:830
plplot::plsKeyEH
void plsKeyEH(void function(PLGraphicsIn *, void *, int *) KeyEH, void *KeyEH_data)
plplot::c_pllegend
void c_pllegend(PLFLT *p_legend_width, PLFLT *p_legend_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLINT nrow, PLINT ncolumn, PLINT nlegend, PLINT *opt_array, PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing, PLFLT text_justification, PLINT *text_colors, const char **text, PLINT *box_colors, PLINT *box_patterns, PLFLT *box_scales, PLFLT *box_line_widths, PLINT *line_colors, PLINT *line_styles, PLFLT *line_widths, PLINT *symbol_colors, PLFLT *symbol_scales, PLINT *symbol_numbers, const char **symbols)
PL_MASK_SHIFT
#define PL_MASK_SHIFT
Definition: plplot.h:419
plgdiplt
#define plgdiplt
Definition: plplot.h:732
plscmap0a
#define plscmap0a
Definition: plplot.h:792
plfamadv
#define plfamadv
Definition: plplot.h:716
plplot::plsError
void plsError(PLINT *errcode, const char *errmsg)
PL_LEGEND_BOUNDING_BOX
#define PL_LEGEND_BOUNDING_BOX
Definition: plplot.h:1294
plplot::plsButtonEH
void plsButtonEH(void function(PLGraphicsIn *, void *, int *) ButtonEH, void *ButtonEH_data)
plplot::c_plmtex3
void c_plmtex3(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
Definition: plsym.c:1610
plplot::PLControlPt
alias _N10 PLControlPt
Definition: plplot.d:1388
MESH
#define MESH
Definition: plplot.h:1512
plend
#define plend
Definition: plplot.h:709
PL_LEGEND_NONE
#define PL_LEGEND_NONE
Definition: plplot.h:1288
plplot::_N8::yg
PLFLT ** yg
Definition: plplot.d:1353
plplot::PLGraphicsIn
alias _N2 PLGraphicsIn
Definition: plplot.d:1262
GRID_NNIDW
#define GRID_NNIDW
Definition: plplot.h:1197
PLESC_TEXT_CHAR
#define PLESC_TEXT_CHAR
Definition: plplot.h:299
plplot::plsexit
void plsexit(int function(const char *) handler)
PLTEXT_FONTCHANGE
#define PLTEXT_FONTCHANGE
Definition: plplot.h:314
plsmem
#define plsmem
Definition: plplot.h:827
plplot::c_plsfnam
void c_plsfnam(const char *fnam)
Definition: plcore.c:3830
plgfont
#define plgfont
Definition: plplot.h:737
color
static int color
Definition: ps.c:78
plend1
#define plend1
Definition: plplot.h:710
PLINT
int PLINT
Definition: plplot.h:181
plenv0
#define plenv0
Definition: plplot.h:712
plplot::plMinMax2dGrid
void plMinMax2dGrid(PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin)
BASE_CONT
#define BASE_CONT
Definition: plplot.h:1507
PL_HIST_NOEMPTY
#define PL_HIST_NOEMPTY
Definition: plplot.h:1249
plgdiori
#define plgdiori
Definition: plplot.h:731
plshades
#define plshades
Definition: plplot.h:824
plplot::c_plfamadv
void c_plfamadv()
Definition: plcore.c:4021
PLBOOL
PLINT PLBOOL
Definition: plplot.h:204
PL_POSITION_OUTSIDE
#define PL_POSITION_OUTSIDE
Definition: plplot.h:1282
PL_OPT_ENABLED
#define PL_OPT_ENABLED
Definition: plplot.h:341
PL_POSITION_RIGHT
#define PL_POSITION_RIGHT
Definition: plplot.h:1278
plplot::c_plgzax
void c_plgzax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4070
plplot::_N11
Definition: plplot.d:1393
plplot::c_plsurf3d
void c_plsurf3d(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
plplot::_N4::height
uint height
Definition: plplot.d:1288
plplot::c_plgdev
void c_plgdev(char *p_dev)
Definition: plcore.c:3658
plplot::_N2::wX
PLFLT wX
Definition: plplot.d:1259
plplot::_N3
Definition: plplot.d:1267
plplot::c_plgvpw
void c_plgvpw(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax)
Definition: plcore.c:4108
plssym
#define plssym
Definition: plplot.h:837
plplot::c_plsvpa
void c_plsvpa(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plvpor.c:506
plplot::plfcont
void plfcont(PLFLT function(PLINT, PLINT, PLPointer) f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
PL_COLORBAR_LABEL_LEFT
#define PL_COLORBAR_LABEL_LEFT
Definition: plplot.h:1299
plplot::c_pladv
void c_pladv(PLINT page)
Definition: plpage.c:34
PL_LEGEND_ROW_MAJOR
#define PL_LEGEND_ROW_MAJOR
Definition: plplot.h:1295
plplot::pldip2dc
void pldip2dc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1737
pljoin
#define pljoin
Definition: plplot.h:756
plplot::c_plcolorbar
void c_plcolorbar(PLFLT *p_colorbar_width, PLFLT *p_colorbar_height, PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT x_length, PLFLT y_length, PLINT bg_color, PLINT bb_color, PLINT bb_style, PLFLT low_cap_color, PLFLT high_cap_color, PLINT cont_color, PLFLT cont_width, PLINT n_labels, const PLINT *label_opts, const char **label, PLINT n_axes, const char **axis_opts, const PLFLT *ticks, const PLINT *sub_ticks, const PLINT *n_values, const PLFLT **values)
plplot::c_plgfnam
void c_plgfnam(char *fnam)
Definition: plcore.c:3811
plgzax
#define plgzax
Definition: plplot.h:750
plplot::c_plgxax
void c_plgxax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4034
FACETED
#define FACETED
Definition: plplot.h:1511
plplot::c_plscolbg
void c_plscolbg(PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:229
plplot::c_plstar
void c_plstar(PLINT nx, PLINT ny)
Definition: plcore.c:2286
plplot::c_plptex
void c_plptex(PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text)
Definition: plsym.c:734
plgfam
#define plgfam
Definition: plplot.h:734
plplot::c_plscmap1_range
void c_plscmap1_range(PLFLT min_color, PLFLT max_color)
Definition: plctrl.c:892
plplot::c_plfill3
void c_plfill3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
PLcGrid::ny
PLINT ny
Definition: plplot.h:509
plgdidev
#define plgdidev
Definition: plplot.h:730
plplot::c_plw3d
void c_plw3d(PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0, PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0, PLFLT zmax0, PLFLT alt, PLFLT az)
Definition: plwind.c:137
plplot::c_plbin
void c_plbin(PLINT nbin, PLFLT *x, PLFLT *y, PLINT opt)
PL_NOTSET
#define PL_NOTSET
Definition: plplot.h:468
plstar
#define plstar
Definition: plplot.h:838
plplot::c_plmtex
void c_plmtex(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
Definition: plsym.c:594
plplot::_N2::subwindow
PLINT subwindow
Definition: plplot.d:1253
PL_PARSE_PARTIAL
#define PL_PARSE_PARTIAL
Definition: plplot.h:358
plcpstrm
#define plcpstrm
Definition: plplot.h:707
PL_COLORBAR_SHADE_LABEL
#define PL_COLORBAR_SHADE_LABEL
Definition: plplot.h:1309
PL_FCI_MONO
#define PL_FCI_MONO
Definition: plplot.h:382
plplot::c_plsxax
void c_plsxax(PLINT digmax, PLINT digits)
Definition: plcore.c:4043
plplot::_N5::nx
PLINT nx
Definition: plplot.d:1303
plimagefr
#define plimagefr
Definition: plplot.h:754
plcalc_world
#define plcalc_world
Definition: plplot.h:700
plplot::c_plhist
void c_plhist(PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt)
plplot::c_plsdiplz
void c_plsdiplz(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plcore.c:1806
plplot::_N8::nx
PLINT nx
Definition: plplot.d:1355
PL_COLORBAR_ORIENT_BOTTOM
#define PL_COLORBAR_ORIENT_BOTTOM
Definition: plplot.h:1313
PLESC_FIXASPECT
#define PLESC_FIXASPECT
Definition: plplot.h:308
plsfnam
#define plsfnam
Definition: plplot.h:818
plhist
#define plhist
Definition: plplot.h:751
PL_POSITION_VIEWPORT
#define PL_POSITION_VIEWPORT
Definition: plplot.h:1283
plplot::c_plbtime
void c_plbtime(PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime)
Definition: pltime.c:26
PL_COLORBAR_GRADIENT
#define PL_COLORBAR_GRADIENT
Definition: plplot.h:1305
plplot::plTranslateCursor
PLINT plTranslateCursor(PLGraphicsIn *gin)
Definition: plpage.c:259
plgchr
#define plgchr
Definition: plplot.h:722
PL_OPT_NODELETE
#define PL_OPT_NODELETE
Definition: plplot.h:343
plplot::c_plstripa
void c_plstripa(PLINT id, PLINT pen, PLFLT x, PLFLT y)
Definition: plstripc.c:221
plsdidev
#define plsdidev
Definition: plplot.h:807
plplot::c_plsori
void c_plsori(PLINT ori)
Definition: plcore.c:3765
plplot::c_plcpstrm
void c_plcpstrm(PLINT iplsr, PLBOOL flags)
Definition: plcore.c:2761
plspal0
#define plspal0
Definition: plplot.h:832
PL_DRAWMODE_XOR
#define PL_DRAWMODE_XOR
Definition: plplot.h:1321
PLESC_MODESET
#define PLESC_MODESET
Definition: plplot.h:306
plplot::PLDisplay
alias _N4 PLDisplay
Definition: plplot.d:1290
plfill3
#define plfill3
Definition: plplot.h:718
GRID_NNI
#define GRID_NNI
Definition: plplot.h:1196
PLESC_GRAPH
#define PLESC_GRAPH
Definition: plplot.h:278
plplot::c_plcol1
void c_plcol1(PLFLT col1)
Definition: plctrl.c:188
PLESC_SET_COMPRESSION
#define PLESC_SET_COMPRESSION
Definition: plplot.h:287
plplot::c_plmesh
void c_plmesh(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt)
plplot::plfshade
void plfshade(PLFLT function(PLINT, PLINT, PLPointer) f2eval, PLPointer f2eval_data, PLFLT function(PLINT, PLINT, PLPointer) c2eval, PLPointer c2eval_data, PLINT nx, PLINT ny, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, void function(PLINT, PLFLT *, PLFLT *) fill, PLBOOL rectangular, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
PL_MAXWINDOWS
#define PL_MAXWINDOWS
Definition: plplot.h:448
PLESC_SET_RGB
#define PLESC_SET_RGB
Definition: plplot.h:271
plplot::_N9::b
ubyte b
Definition: plplot.d:1371
PL_MASK_SCROLL
#define PL_MASK_SCROLL
Definition: plplot.h:426
PLESC_RESIZE
#define PLESC_RESIZE
Definition: plplot.h:275
plplot::c_plsyax
void c_plsyax(PLINT digmax, PLINT digits)
Definition: plcore.c:4061
PLESC_FLUSH_REMAINING_BUFFER
#define PLESC_FLUSH_REMAINING_BUFFER
Definition: plplot.h:311
plplot::_N4::y
uint y
Definition: plplot.d:1286
plplot::_N3::wymi
PLFLT wymi
Definition: plplot.d:1275
plplot::c_plgspa
void c_plgspa(PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax)
Definition: plpage.c:222
PL_POSITION_SUBPAGE
#define PL_POSITION_SUBPAGE
Definition: plplot.h:1284
PL_HIST_NOEXPAND
#define PL_HIST_NOEXPAND
Definition: plplot.h:1248
plplot::_N10::p
PLFLT p
Definition: plplot.d:1384
plseed
#define plseed
Definition: plplot.h:813
c_plmapstring
PLDLLIMPEXP void c_plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
PLcGrid::yg
PLFLT_NC_FE_POINTER yg
Definition: plplot.h:508
plstring
#define plstring
Definition: plplot.h:841
plstransform
#define plstransform
Definition: plplot.h:840
plvect
#define plvect
Definition: plplot.h:858
plplot::c_plrgbhls
void c_plrgbhls(PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s)
Definition: plctrl.c:1294
PLcGrid::zg
PLFLT_NC_FE_POINTER zg
Definition: plplot.h:508
PL_COLORBAR_CAP_NONE
#define PL_COLORBAR_CAP_NONE
Definition: plplot.h:1306
PL_FCI_STYLE
#define PL_FCI_STYLE
Definition: plplot.h:377
plplot::c_plcalc_world
void c_plcalc_world(PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window)
Definition: plpage.c:289
plplot::plClearOpts
void plClearOpts()
Definition: plargs.c:830
plscmap1la
#define plscmap1la
Definition: plplot.h:797
PL_FCI_SCRIPT
#define PL_FCI_SCRIPT
Definition: plplot.h:383
plgfnam
#define plgfnam
Definition: plplot.h:736
plplot::c_plstyl
void c_plstyl(PLINT nms, PLINT *mark, PLINT *space)
plplot::_N7
Definition: plplot.d:1333
plplot::c_plssub
void c_plssub(PLINT nx, PLINT ny)
Definition: plcore.c:3617
PL_DRAWMODE_UNKNOWN
#define PL_DRAWMODE_UNKNOWN
Definition: plplot.h:1318
plplot::c_plsdev
void c_plsdev(const char *devname)
Definition: plcore.c:3640
plcont
#define plcont
Definition: plplot.h:706
plsxax
#define plsxax
Definition: plplot.h:851
plstart
#define plstart
Definition: plplot.h:839
plplot::c_plvpas
void c_plvpas(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect)
Definition: plvpor.c:384
PLESC_EH
#define PLESC_EH
Definition: plplot.h:282
pleop
#define pleop
Definition: plplot.h:713
plmesh
#define plmesh
Definition: plplot.h:770
plplot::c_plvpor
void c_plvpor(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plvpor.c:342
plhlsrgb
#define plhlsrgb
Definition: plplot.h:752
PL_Y_AXIS
#define PL_Y_AXIS
Definition: plplot.h:334
plsmaj
#define plsmaj
Definition: plplot.h:826
PLESC_END_RASTERIZE
#define PLESC_END_RASTERIZE
Definition: plplot.h:303
PLESC_CLEAR
#define PLESC_CLEAR
Definition: plplot.h:288
PL_LEGEND_NULL
#define PL_LEGEND_NULL
Definition: plplot.h:1287
plplot
Definition: plplot.d:2
plplot::PLBufferingCB
alias _N11 PLBufferingCB
Definition: plplot.d:1398
plplot::c_plclear
void c_plclear()
Definition: plpage.c:71
plcol1
#define plcol1
Definition: plplot.h:703
PLESC_ALLOC_NCOL
#define PLESC_ALLOC_NCOL
Definition: plplot.h:272
pllab
#define pllab
Definition: plplot.h:757
plplot::_N2::wY
PLFLT wY
Definition: plplot.d:1260
plplot::PLcGrid2
Definition: plplot.d:29
pllightsource
#define pllightsource
Definition: plplot.h:759
plplot::c_plsdidev
void c_plsdidev(PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy)
Definition: plcore.c:1892
plplot::plgFileDevs
void plgFileDevs(char ***p_menustr, char ***p_devname, int *p_ndev)
plplot::pltr2p
void pltr2p(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:1113
plplot::pltr2
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:941
PL_COLORBAR_ORIENT_LEFT
#define PL_COLORBAR_ORIENT_LEFT
Definition: plplot.h:1312
PL_HIST_IGNORE_OUTLIERS
#define PL_HIST_IGNORE_OUTLIERS
Definition: plplot.h:1247
plbox
#define plbox
Definition: plplot.h:697
plplot::c_plgcolbg
void c_plgcolbg(PLINT *r, PLINT *g, PLINT *b)
Definition: plctrl.c:263
plplot::c_pl_setcontlabelparam
void c_pl_setcontlabelparam(PLFLT offset, PLFLT size, PLFLT spacing, PLINT active)
Definition: plcont.c:247
plplot::PLcGrid2::yg
PLFLT [][] yg
Definition: plplot.d:32
plplot::_N10::alt_hue_path
int alt_hue_path
Definition: plplot.d:1386
PL_OPT_INVISIBLE
#define PL_OPT_INVISIBLE
Definition: plplot.h:344
PL_OPT_BOOL
#define PL_OPT_BOOL
Definition: plplot.h:350
pltext
#define pltext
Definition: plplot.h:855
DRAW_SIDES
#define DRAW_SIDES
Definition: plplot.h:1510
plplot::c_pljoin
void c_pljoin(PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plline.c:62
PL_Z_AXIS
#define PL_Z_AXIS
Definition: plplot.h:335
plplot::c_plgvpd
void c_plgvpd(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax)
Definition: plcore.c:4097
plwidth
#define plwidth
Definition: plplot.h:863
plgver
#define plgver
Definition: plplot.h:745
plplot::plf2evalr
PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:466
plplot::c_plsfam
void c_plsfam(PLINT fam, PLINT num, PLINT bmax)
Definition: plcore.c:4005
PLESC_APPEND_BUFFER
#define PLESC_APPEND_BUFFER
Definition: plplot.h:310
plplot::PLcGrid::xg
PLFLT [] xg
Definition: plplot.d:25
plscol0a
#define plscol0a
Definition: plplot.h:801
PLSWIN_WORLD
#define PLSWIN_WORLD
Definition: plplot.h:330
plplot::C
C
plptex3
#define plptex3
Definition: plplot.h:786
plplot::_N2
Definition: plplot.d:1247
plsdiplz
#define plsdiplz
Definition: plplot.h:811
plplot::plsxwin
void plsxwin(PLINT window_id)
Definition: plcore.c:3978
plplot::c_plglevel
void c_plglevel(PLINT *p_level)
Definition: plcore.c:3707
DRAW_LINEXY
#define DRAW_LINEXY
Definition: plplot.h:1505
PL_POSITION_INSIDE
#define PL_POSITION_INSIDE
Definition: plplot.h:1281
plspause
#define plspause
Definition: plplot.h:834
plplot::_N10::s
PLFLT s
Definition: plplot.d:1383
PLESC_MODEGET
#define PLESC_MODEGET
Definition: plplot.h:307
plplot::c_plsdimap
void c_plsdimap(PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax, PLFLT dimxpmm, PLFLT dimypmm)
Definition: plcore.c:2160
plline3
#define plline3
Definition: plplot.h:762
plstripd
#define plstripd
Definition: plplot.h:845
plplot::c_plimage
void c_plimage(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax)
plgfci
#define plgfci
Definition: plplot.h:735
plgspa
#define plgspa
Definition: plplot.h:743
plplot::_N10::h
PLFLT h
Definition: plplot.d:1381
plgcolbg
#define plgcolbg
Definition: plplot.h:726
plstripc
#define plstripc
Definition: plplot.h:844
ZEROW2D
#define ZEROW2D
Definition: plplot.h:323
plplot::c_plctime
void c_plctime(PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime)
Definition: pltime.c:54
plplot::_N3::dyma
PLFLT dyma
Definition: plplot.d:1272
plstripa
#define plstripa
Definition: plplot.h:843
plstring3
#define plstring3
Definition: plplot.h:842
PLESC_BEGIN_TEXT
#define PLESC_BEGIN_TEXT
Definition: plplot.h:298
plplot::c_plshade
void c_plshade(PLFLT **a, PLINT nx, PLINT ny, PLINT function(PLFLT, PLFLT) defined, PLFLT left, PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color, PLFLT max_width, void function(PLINT, PLFLT *, PLFLT *) fill, PLBOOL rectangular, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
plplot::_N1::mode
int mode
Definition: plplot.d:1238
plvpas
#define plvpas
Definition: plplot.h:859
PL_MASK_CAPS
#define PL_MASK_CAPS
Definition: plplot.h:420
plplot::c_plstart
void c_plstart(const char *devname, PLINT nx, PLINT ny)
Definition: plcore.c:2305
c_plmapfill
PLDLLIMPEXP void c_plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
plplot::PLcGrid2::zg
PLFLT [][] zg
Definition: plplot.d:33
plplot::c_plgfont
void c_plgfont(PLINT *p_family, PLINT *p_style, PLINT *p_weight)
Definition: plsym.c:2138
PL_X_AXIS
#define PL_X_AXIS
Definition: plplot.h:333
plsfont
#define plsfont
Definition: plplot.h:819
plplot::c_plsfont
void c_plsfont(PLINT family, PLINT style, PLINT weight)
Definition: plsym.c:2094
plmapfill
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:661
plplot::c_plsdiplt
void c_plsdiplt(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plcore.c:1782
plplot::_N2::state
uint state
Definition: plplot.d:1250
plplot::c_plfontld
void c_plfontld(PLINT fnt)
Definition: plcore.c:3488
plpsty
#define plpsty
Definition: plplot.h:784
plplot::c_plpoin
void c_plpoin(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
plplot::plGetFlt
PLFLT plGetFlt(const char *s)
Definition: plctrl.c:2945
plplot::PLColor
alias _N9 PLColor
Definition: plplot.d:1375
plplot::_N8::ny
PLINT ny
Definition: plplot.d:1356
PLSWIN_DEVICE
#define PLSWIN_DEVICE
Definition: plplot.h:329
PL_OPT_INT
#define PL_OPT_INT
Definition: plplot.h:351
PL_MASK_NUM
#define PL_MASK_NUM
Definition: plplot.h:423
options
static PLOptionTable options[]
Definition: tclMain.c:108
plgvpd
#define plgvpd
Definition: plplot.h:746
plpoin
#define plpoin
Definition: plplot.h:780
plgriddata
#define plgriddata
Definition: plplot.h:742
plgvpw
#define plgvpw
Definition: plplot.h:747
plplot::c_pllightsource
void c_pllightsource(PLFLT x, PLFLT y, PLFLT z)
Definition: plot3d.c:101
PL_OPT_STRING
#define PL_OPT_STRING
Definition: plplot.h:353
plplot::plf2eval
PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:447
text
static int text
Definition: ps.c:77
plplot::c_pltext
void c_pltext()
Switches to text screen.
Definition: plctrl.c:2100
plplot::c_plimagefr
void c_plimagefr(PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer), PLPointer pltr_data)
plplot::plf2eval2
PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:428
PL_OPT_ARG
#define PL_OPT_ARG
Definition: plplot.h:342
PL_POSITION_NULL
#define PL_POSITION_NULL
Definition: plplot.h:1276
PL_COLORBAR_CAP_HIGH
#define PL_COLORBAR_CAP_HIGH
Definition: plplot.h:1308
plplot::PLcGrid2::xg
PLFLT [][] xg
Definition: plplot.d:31
PL_MASK_BUTTON2
#define PL_MASK_BUTTON2
Definition: plplot.h:428
PL_DRAWMODE_REPLACE
#define PL_DRAWMODE_REPLACE
Definition: plplot.h:1320
plplot::_N2::button
uint button
Definition: plplot.d:1252
DRAW_LINEX
#define DRAW_LINEX
Definition: plplot.h:1503
plplot::c_plxormod
void c_plxormod(PLBOOL mode, PLBOOL *status)
Definition: plctrl.c:2018
PLESC_SWIN
#define PLESC_SWIN
Definition: plplot.h:284
PLESC_SET_LPB
#define PLESC_SET_LPB
Definition: plplot.h:273
plplot::c_pltimefmt
void c_pltimefmt(const char *fmt)
Definition: pltime.c:66
plplot::c_plsym
void c_plsym(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
plplot::_N5::nz
PLINT nz
Definition: plplot.d:1305
PL_COLORBAR_ORIENT_RIGHT
#define PL_COLORBAR_ORIENT_RIGHT
Definition: plplot.h:1310
ONEW2D
#define ONEW2D
Definition: plplot.h:325
plplot::c_plsmem
void c_plsmem(PLINT maxx, PLINT maxy, void *plotmem)
Definition: plcore.c:3673
plmkstrm
#define plmkstrm
Definition: plplot.h:772
PL_HIST_DEFAULT
#define PL_HIST_DEFAULT
Definition: plplot.h:1245
plplot::plMergeOpts
PLINT plMergeOpts(PLOptionTable *options, const char *name, const char **notes)
Definition: plargs.c:783
PLFLT
float PLFLT
Definition: plplot.h:163
plscol0
#define plscol0
Definition: plplot.h:800
PL_PARSE_FULL
#define PL_PARSE_FULL
Definition: plplot.h:359
plplot::_N10
Definition: plplot.d:1379
plplot::c_plscmap1
void c_plscmap1(PLINT *r, PLINT *g, PLINT *b, PLINT ncol1)
PLESC_START_RASTERIZE
#define PLESC_START_RASTERIZE
Definition: plplot.h:302
plxormod
#define plxormod
Definition: plplot.h:865
plplot::_N1::opt
string opt
Definition: plplot.d:1234
plplot::_N6
Definition: plplot.d:1314
plplot::c_plgdiori
void c_plgdiori(PLFLT *p_rot)
Definition: plcore.c:2145
PL_FCI_FAMILY
#define PL_FCI_FAMILY
Definition: plplot.h:376
plflush
#define plflush
Definition: plplot.h:719
plerrx
#define plerrx
Definition: plplot.h:714
PL_LEGEND_TEXT_LEFT
#define PL_LEGEND_TEXT_LEFT
Definition: plplot.h:1292
PLTEXT_UNDERLINE
#define PLTEXT_UNDERLINE
Definition: plplot.h:319
plplot::_N5::ny
PLINT ny
Definition: plplot.d:1304
plgcol0a
#define plgcol0a
Definition: plplot.h:725
PL_MASK_BUTTON4
#define PL_MASK_BUTTON4
Definition: plplot.h:430
PLESC_DOUBLEBUFFERING_DISABLE
#define PLESC_DOUBLEBUFFERING_DISABLE
Definition: plplot.h:577
plplot::pltr0
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
plplot::c_plscmap1a
void c_plscmap1a(PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol1)
plgcolbga
#define plgcolbga
Definition: plplot.h:727
PL_MASK_ALTGR
#define PL_MASK_ALTGR
Definition: plplot.h:424
plplot::c_plspage
void c_plspage(PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng, PLINT xoff, PLINT yoff)
Definition: plcore.c:3593
plplot::c_plrandd
PLFLT c_plrandd()
Definition: plctrl.c:3081
plgyax
#define plgyax
Definition: plplot.h:749
plsesc
#define plsesc
Definition: plplot.h:814
PL_PARSE_SKIP
#define PL_PARSE_SKIP
Definition: plplot.h:367
PL_COLORBAR_CAP_LOW
#define PL_COLORBAR_CAP_LOW
Definition: plplot.h:1307
plenv
#define plenv
Definition: plplot.h:711
plplot::c_plslabelfunc
void c_plslabelfunc(void function(PLINT, PLFLT, char *, PLINT, PLPointer) labelfunc, PLPointer label_data)
plplot::_N3::wxma
PLFLT wxma
Definition: plplot.d:1274
PL_FCI_WEIGHT
#define PL_FCI_WEIGHT
Definition: plplot.h:378
PLESC_IMPORT_BUFFER
#define PLESC_IMPORT_BUFFER
Definition: plplot.h:309
plplot::_N7::nx
PLINT nx
Definition: plplot.d:1338
plplot::c_plspal1
void c_plspal1(const char *filename, PLBOOL interpolate)
Definition: plctrl.c:1614
plplot::_N4::width
uint width
Definition: plplot.d:1287
plplot::c_plgra
void c_plgra()
Definition: plctrl.c:2003
plcol0
#define plcol0
Definition: plplot.h:702
plplot::plAlloc2dGrid
void plAlloc2dGrid(PLFLT ***f, PLINT nx, PLINT ny)
Definition: plmem.c:91
plbox3
#define plbox3
Definition: plplot.h:698
plplot::convert_array
PLFLT ** convert_array(PLFLT[][] a)
Definition: plplot.d:37
PLESC_GETBACKEND
#define PLESC_GETBACKEND
Definition: plplot.h:297
plplot::c_plgyax
void c_plgyax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4052
plcolorbar
#define plcolorbar
Definition: plplot.h:704
PL_MASK_ALT
#define PL_MASK_ALT
Definition: plplot.h:422
plplot::_N10::l
PLFLT l
Definition: plplot.d:1382
plglevel
#define plglevel
Definition: plplot.h:738
plplot::plgDevs
void plgDevs(char ***p_menustr, char ***p_devname, int *p_ndev)
PLcGrid::xg
PLFLT_NC_FE_POINTER xg
Definition: plplot.h:508
plplot::c_plerrx
void c_plerrx(PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y)
plplot::_N1
Definition: plplot.d:1232
plplot::_N2::pY
int pY
Definition: plplot.d:1256
plplot::c_plgpage
void c_plgpage(PLFLT *p_xp, PLFLT *p_yp, PLINT *p_xleng, PLINT *p_yleng, PLINT *p_xoff, PLINT *p_yoff)
Definition: plcore.c:3579
plpoin3
#define plpoin3
Definition: plplot.h:781
PLESC_HAS_TEXT
#define PLESC_HAS_TEXT
Definition: plplot.h:290
plplot::_N8::zg
PLFLT ** zg
Definition: plplot.d:1354
plplot::c_plerry
void c_plerry(PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax)
plscmap0n
#define plscmap0n
Definition: plplot.h:793
plplot::PLWindow
alias _N3 PLWindow
Definition: plplot.d:1278
plscolor
#define plscolor
Definition: plplot.h:804
plsvpa
#define plsvpa
Definition: plplot.h:850
PLESC_ARC
#define PLESC_ARC
Definition: plplot.h:304
plpat
#define plpat
Definition: plplot.h:779
plplot::_N2::string
char [16] string
Definition: plplot.d:1254
pl_setcontlabelformat
#define pl_setcontlabelformat
Definition: plplot.h:690
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
plplot::_N10::a
PLFLT a
Definition: plplot.d:1385
plgcol0
#define plgcol0
Definition: plplot.h:724
PL_MASK_BUTTON1
#define PL_MASK_BUTTON1
Definition: plplot.h:427
plplot::c_plgstrm
void c_plgstrm(PLINT *p_strm)
Definition: plcore.c:2652
plplot::pltr0f
void pltr0f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
plplot::PLcGrid
Definition: plplot.d:23
plplot::_N3::dxma
PLFLT dxma
Definition: plplot.d:1270
plplot::c_plwind
void c_plwind(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plwind.c:33
plreplot
#define plreplot
Definition: plplot.h:788
PLESC_IMAGE
#define PLESC_IMAGE
Definition: plplot.h:291
PL_PARSE_SHOWALL
#define PL_PARSE_SHOWALL
Definition: plplot.h:363
plplot::c_plinit
void c_plinit()
Definition: plcore.c:2325
errmsg
static char errmsg[160]
Definition: tclAPI.c:158
plplot::c_pllab
void c_pllab(const char *xlabel, const char *ylabel, const char *tlabel)
Definition: plsym.c:549
PLESC_DEV2PLCOL
#define PLESC_DEV2PLCOL
Definition: plplot.h:294
plscmap1l
#define plscmap1l
Definition: plplot.h:796
PLESC_SETBGFG
#define PLESC_SETBGFG
Definition: plplot.h:295
plmap
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
plprec
#define plprec
Definition: plplot.h:783
plptex
#define plptex
Definition: plplot.h:785
plplot::_N9::r
ubyte r
Definition: plplot.d:1369
PL_MASK_CONTROL
#define PL_MASK_CONTROL
Definition: plplot.h:421
PLESC_IMAGEOPS
#define PLESC_IMAGEOPS
Definition: plplot.h:292
PLESC_DASH
#define PLESC_DASH
Definition: plplot.h:289
plline
#define plline
Definition: plplot.h:760
plplot::c_plenv0
void c_plenv0(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plvpor.c:103
plplot::PLOptionTable
alias _N1 PLOptionTable
Definition: plplot.d:1242
c_plmapline
PLDLLIMPEXP void c_plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
plplot::_N9::g
ubyte g
Definition: plplot.d:1370
PL_LEGEND_COLOR_BOX
#define PL_LEGEND_COLOR_BOX
Definition: plplot.h:1289
PL_FCI_HEXDIGIT_MASK
#define PL_FCI_HEXDIGIT_MASK
Definition: plplot.h:372
plplot::c_plscmap0n
void c_plscmap0n(PLINT ncol0)
Definition: plctrl.c:942
PL_COLORBAR_LABEL_BOTTOM
#define PL_COLORBAR_LABEL_BOTTOM
Definition: plplot.h:1302
plplot::pl_cmd
void pl_cmd(PLINT op, void *ptr)
Definition: plctrl.c:2118
plplot::c_plvasp
void c_plvasp(PLFLT aspect)
Definition: plvpor.c:454
plgradient
#define plgradient
Definition: plplot.h:741
PL_POSITION_TOP
#define PL_POSITION_TOP
Definition: plplot.h:1279
PL_PARSE_OVERRIDE
#define PL_PARSE_OVERRIDE
Definition: plplot.h:364
plplot::c_PLcGrid
alias _N7 c_PLcGrid
Definition: plplot.d:1342
plplot::plgrdient
alias c_plgradient plgrdient
Definition: plplot.d:1500
PL_COLORBAR_NULL
#define PL_COLORBAR_NULL
Definition: plplot.h:1298
plplot::c_plgdiplt
void c_plgdiplt(PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax)
Definition: plcore.c:1872
plplot::c_plscolbga
void c_plscolbga(PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plctrl.c:248
plplot::PLcGrid::yg
PLFLT [] yg
Definition: plplot.d:26
plplot::c_plreplot
void c_plreplot()
Definition: plcore.c:3506
plplot::c_plscolor
void c_plscolor(PLINT color)
Definition: plctrl.c:1202
PL_COLORBAR_BOUNDING_BOX
#define PL_COLORBAR_BOUNDING_BOX
Definition: plplot.h:1315
plplot::_N5::f
PLFLT * f
Definition: plplot.d:1302
DRAW_LINEY
#define DRAW_LINEY
Definition: plplot.h:1504
plplot::c_plgcol0
void c_plgcol0(PLINT icol0, PLINT *r, PLINT *g, PLINT *b)
Definition: plctrl.c:359
pladv
#define pladv
Definition: plplot.h:692
plplot::c_plstring3
void c_plstring3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, const char *text)
PL_BIN_NOEMPTY
#define PL_BIN_NOEMPTY
Definition: plplot.h:917
plplot::c_plpat
void c_plpat(PLINT nlin, PLINT *inc, PLINT *del)
PLESC_GRADIENT
#define PLESC_GRADIENT
Definition: plplot.h:305
plplot::c_plgcol0a
void c_plgcol0a(PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a)
Definition: plctrl.c:396
plvasp
#define plvasp
Definition: plplot.h:857
PLESC_GETC
#define PLESC_GETC
Definition: plplot.h:283
PL_COLORBAR_IMAGE
#define PL_COLORBAR_IMAGE
Definition: plplot.h:1303
plrandd
#define plrandd
Definition: plplot.h:787
PLESC_PL2DEVCOL
#define PLESC_PL2DEVCOL
Definition: plplot.h:293
plplot::c_plshades
void c_plshades(PLFLT **a, PLINT nx, PLINT ny, PLINT function(PLFLT, PLFLT) defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT *clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, void function(PLINT, PLFLT *, PLFLT *) fill, PLBOOL rectangular, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
plscmap0
#define plscmap0
Definition: plplot.h:791
plmapstring
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:616
PL_FCI_SANS
#define PL_FCI_SANS
Definition: plplot.h:380
plgstrm
#define plgstrm
Definition: plplot.h:744
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotluacLUA_wrap.c:3045
plplot::c_plgfci
void c_plgfci(PLUNICODE *pfci)
Definition: plcore.c:3936
PL_DRAWMODE_DEFAULT
#define PL_DRAWMODE_DEFAULT
Definition: plplot.h:1319
plplot::c_plsesc
void c_plsesc(char esc)
Definition: plcore.c:3890
plsfci
#define plsfci
Definition: plplot.h:817
plplot::c_plpoly3
void c_plpoly3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc)
plplot::_N6::ny
PLINT ny
Definition: plplot.d:1318
plplot::_N1::client_data
void * client_data
Definition: plplot.d:1236
PLESC_EXPOSE
#define PLESC_EXPOSE
Definition: plplot.h:274
plplot::plFindName
PLINT plFindName(char *p)
Definition: plctrl.c:2432
plmtex
#define plmtex
Definition: plplot.h:773
ZEROW2B
#define ZEROW2B
Definition: plplot.h:322
PL_FCI_HEXPOWER_IMPOSSIBLE
#define PL_FCI_HEXPOWER_IMPOSSIBLE
Definition: plplot.h:374
plplot::c_pllsty
void c_pllsty(PLINT lin)
Definition: plsdef.c:268
plplot::_N5
Definition: plplot.d:1300
plrgbhls
#define plrgbhls
Definition: plplot.h:789
plsurf3d
#define plsurf3d
Definition: plplot.h:847
plplot::_N2::dX
PLFLT dX
Definition: plplot.d:1257
PL_COLORBAR_LABEL_RIGHT
#define PL_COLORBAR_LABEL_RIGHT
Definition: plplot.h:1300
plplot::c_plbox3
void c_plbox3(const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx, const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby, const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz)
Definition: plbox.c:593
plgra
#define plgra
Definition: plplot.h:740
ONEW2B
#define ONEW2B
Definition: plplot.h:324
plplot::PLcGrid::zg
PLFLT [] zg
Definition: plplot.d:27
plsdimap
#define plsdimap
Definition: plplot.h:808
plplot::c_plparseopts
PLINT c_plparseopts(int *p_argc, char **argv, PLINT mode)
Definition: plargs.c:865
plplot::c_pleop
void c_pleop()
Definition: plpage.c:101
plplot::c_plvect
void c_plvect(PLFLT **u, PLFLT **v, PLINT nx, PLINT ny, PLFLT scale, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
plplot::_N7::ny
PLINT ny
Definition: plplot.d:1339
plplot::c_plsvect
void c_plsvect(PLFLT *arrowx, PLFLT *arrowy, PLINT npts, PLBOOL fill)
PL_MASK_BUTTON5
#define PL_MASK_BUTTON5
Definition: plplot.h:431
plplot::_N4::x
uint x
Definition: plplot.d:1285
GRID_NNAIDW
#define GRID_NNAIDW
Definition: plplot.h:1199
plcallback::fill
PLDLLIMPEXP_CXX void fill(PLINT n, const PLFLT *x, const PLFLT *y)
Definition: plstream.cc:246
plot3d
#define plot3d
Definition: plplot.h:775
GRID_NNLI
#define GRID_NNLI
Definition: plplot.h:1198
plplot::c_plfill
void c_plfill(PLINT n, PLFLT *x, PLFLT *y)
plplot::_N9::name
char * name
Definition: plplot.d:1373
plplot::plgesc
void plgesc(char *p_esc)
Definition: plcore.c:3914
plslabelfunc
#define plslabelfunc
Definition: plplot.h:825
PLcGrid::nx
PLINT nx
Definition: plplot.h:509
plplot::_N1::desc
string desc
Definition: plplot.d:1240
PLESC_FLUSH
#define PLESC_FLUSH
Definition: plplot.h:281
PL_FCI_MARK
#define PL_FCI_MARK
Definition: plplot.h:370
GRID_CSA
#define GRID_CSA
Definition: plplot.h:1194
plplot::plGetInt
PLINT plGetInt(const char *s)
Definition: plctrl.c:2910
PLGraphicsIn
Definition: plplot.h:433