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
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;
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;
1064 const PLESC_XORMOD = 16;
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;
1079 const PLESC_END_TEXT = 31;
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;
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;
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 );
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;
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;
1181 const PL_POSITION_INSIDE = 0x10;
1182 const PL_POSITION_OUTSIDE = 0x20;
1184 const PL_POSITION_SUBPAGE = 0x80;
1185 const PL_LEGEND_NULL = 0x0;
1186 const PL_LEGEND_NONE = 0x1;
1188 const PL_LEGEND_LINE = 0x4;
1189 const PL_LEGEND_SYMBOL = 0x8;
1190 const PL_LEGEND_TEXT_LEFT = 0x10;
1193 const PL_LEGEND_ROW_MAJOR = 0x80;
1194 const PL_COLORBAR_NULL = 0x0;
1199 const PL_COLORBAR_IMAGE = 0x10;
1200 const PL_COLORBAR_SHADE = 0x20;
1203 const PL_COLORBAR_CAP_LOW = 0x100;
1204 const PL_COLORBAR_CAP_HIGH = 0x200;
1207 const PL_COLORBAR_ORIENT_TOP = 0x1000;
1210 const PL_COLORBAR_BACKGROUND = 0x8000;
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;
1237  void *var;
1238  int mode;
1239  string syntax;
1240  string desc;
1241 }
1243 
1244 // PLplot Graphics Input structure
1245 
1246 
1247 struct _N2
1248 {
1249  int type;
1250  uint state;
1251  uint keysym;
1252  uint button;
1254  char [16] string;
1255  int pX;
1256  int pY;
1261 }
1263 
1264 // Structure for describing the plot window
1265 
1266 
1267 struct _N3
1268 {
1277 }
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 }
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 {
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 {
1319 }
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 {
1341 }
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 {
1357 }
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;
1373  char *name;
1374 }
1375 alias _N9 PLColor;
1376 
1377 // PLControlPt is how cmap1 control points are represented.
1378 
1379 struct _N10
1380 {
1387 }
1389 
1390 // A PLBufferingCB is a control block for interacting with devices
1391 // that support double buffering.
1392 
1393 struct _N11
1394 {
1397 }
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 
1454 //alias c_plaxes plaxes;
1455 //alias c_plbin plbin;
1457 //alias c_plbox plbox;
1458 //alias c_plbox3 plbox3;
1466 //alias c_plcolorbar plcolorbar;
1468 //alias c_plcont plcont;
1476 //alias c_plerrx plerrx;
1477 //alias c_plerry plerry;
1479 //alias c_plfill plfill;
1480 //alias c_plfill3 plfill3;
1490 //alias c_plgdev plgdev;
1496 //alias c_plgfnam plgfnam;
1502 //alias c_plgriddata plgriddata;
1505 //alias c_plgver plgver;
1511 //alias c_plhist plhist;
1513 //alias c_plimage plimage;
1514 //alias c_plimagefr plimagefr;
1517 //alias c_pllab pllab;
1518 //alias c_pllegend pllegend;
1520 //alias c_plline plline;
1522 //alias c_plline3 plline3;
1524 //alias c_plmap plmap;
1526 //alias c_plmesh plmesh;
1527 //alias c_plmeshc plmeshc;
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;
1541 //alias c_plptex plptex;
1542 //alias c_plptex3 plptex3;
1547 //alias c_plscmap0 plscmap0;
1548 //alias c_plscmap0a plscmap0a;
1550 //alias c_plscmap1 plscmap1;
1551 //alias c_plscmap1a plscmap1a;
1552 //alias c_plscmap1l plscmap1l;
1553 //alias c_plscmap1la plscmap1la;
1562 // alias c_plsdev plsdev;
1570 //alias c_plsetopt plsetopt;
1573 // alias c_plsfnam plsfnam;
1575 //alias c_plshade plshade;
1576 //alias c_plshades plshades;
1582 // alias c_plspal0 plspal0;
1583 // alias c_plspal1 plspal1;
1589 //alias c_plstart plstart;
1592 //alias c_plstripc plstripc;
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;
1603 //alias c_plsym plsym;
1606 //alias c_pltimefmt pltimefmt;
1608 //alias c_plvect plvect;
1615 
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 
2418 
2419 // Translates relative device coordinates to world coordinates.
2420 
2422 
PLTEXT_UNDERLINE
#define PLTEXT_UNDERLINE
Definition: plplot.h:319
pllsty
#define pllsty
Definition: plplot.h:763
plplot::c_plgcmap1_range
void c_plgcmap1_range(PLFLT *min_color, PLFLT *max_color)
Definition: plctrl.c:924
PLESC_XORMOD
#define PLESC_XORMOD
Definition: plplot.h:286
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::c_plgcompression
void c_plgcompression(PLINT *compression)
Definition: plcore.c:4285
plplot::_N9::r
ubyte r
Definition: plplot.d:1369
plplot::c_plsfont
void c_plsfont(PLINT family, PLINT style, PLINT weight)
Definition: plsym.c:2094
plsstrm
#define plsstrm
Definition: plplot.h:835
plsdidev
#define plsdidev
Definition: plplot.h:807
errmsg
static char errmsg[160]
Definition: tclAPI.c:158
PL_MASK_BUTTON1
#define PL_MASK_BUTTON1
Definition: plplot.h:427
plspage
#define plspage
Definition: plplot.h:831
PL_POSITION_BOTTOM
Definition: plplot_core.h:65
ONEW2B
#define ONEW2B
Definition: plplot.h:324
plshade
#define plshade
Definition: plplot.h:820
plplot::c_pllab
void c_pllab(const char *xlabel, const char *ylabel, const char *tlabel)
plsurf3d
#define plsurf3d
Definition: plplot.h:847
plplot::pltr2p
void pltr2p(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:1113
plplot::c_plsvpa
void c_plsvpa(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plvpor.c:506
PLESC_GETBACKEND
#define PLESC_GETBACKEND
Definition: plplot.h:297
PL_MASK_SCROLL
#define PL_MASK_SCROLL
Definition: plplot.h:426
PL_POSITION_VIEWPORT
Definition: plplot_core.h:68
plplot::_N6::f
PLFLT ** f
Definition: plplot.d:1316
plplot::plf2evalr
PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:466
plssym
#define plssym
Definition: plplot.h:837
plinit
#define plinit
Definition: plplot.h:755
plplot::c_plgspa
void c_plgspa(PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax)
Definition: plpage.c:222
PL_FCI_MEDIUM
Definition: plplot_core.h:129
PL_DRAWMODE_XOR
Definition: plplot_core.h:137
plplot::c_plscmap1n
void c_plscmap1n(PLINT ncol1)
Definition: plctrl.c:1067
plplot::c_plgxax
void c_plgxax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4034
plrandd
#define plrandd
Definition: plplot.h:787
plplot::_N10::a
PLFLT a
Definition: plplot.d:1385
PL_Z_AXIS
#define PL_Z_AXIS
Definition: plplot.h:335
PL_COLORBAR_ORIENT_RIGHT
Definition: plplot_core.h:101
plsfci
#define plsfci
Definition: plplot.h:817
plerry
#define plerry
Definition: plplot.h:715
plplot::c_plstar
void c_plstar(PLINT nx, PLINT ny)
Definition: plcore.c:2286
argc
static int argc
Definition: qt.cpp:48
PL_DRAWMODE_UNKNOWN
Definition: plplot_core.h:134
PLSWIN_WORLD
#define PLSWIN_WORLD
Definition: plplot.h:330
plptex3
#define plptex3
Definition: plplot.h:786
PL_FCI_HEXPOWER_MASK
#define PL_FCI_HEXPOWER_MASK
Definition: plplot.h:373
PL_LEGEND_COLOR_BOX
Definition: plplot_core.h:77
plplot::c_plxormod
void c_plxormod(PLBOOL mode, PLBOOL *status)
Definition: plctrl.c:2018
plplot::c_plmtex
void c_plmtex(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
plplot::c_plbin
void c_plbin(PLINT nbin, PLFLT *x, PLFLT *y, PLINT opt)
pltr_func
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotluacLUA_wrap.c:3062
plgspa
#define plgspa
Definition: plplot.h:743
plplot::_N8
Definition: plplot.d:1350
plplot::c_plsdev
void c_plsdev(const char *devname)
plplot::c_plstransform
void c_plstransform(ct_func coordinate_transform=null, PLPointer coordinate_transform_data=null)
plstart
#define plstart
Definition: plplot.h:839
plplot::c_plpath
void c_plpath(PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plline.c:94
GRID_NNIDW
#define GRID_NNIDW
Definition: plplot.h:1197
plgcolbg
#define plgcolbg
Definition: plplot.h:726
plplot::_N11::cmd
PLINT cmd
Definition: plplot.d:1395
plsym
#define plsym
Definition: plplot.h:853
PL_FCI_FAMILY
#define PL_FCI_FAMILY
Definition: plplot.h:376
PLESC_END_TEXT
#define PLESC_END_TEXT
Definition: plplot.h:301
PL_LEGEND_SYMBOL
Definition: plplot_core.h:79
plimage
#define plimage
Definition: plplot.h:753
plplot::plsbopH
void plsbopH(void function(void *, int *) handler, void *handler_data)
plgcol0a
#define plgcol0a
Definition: plplot.h:725
plplot::c_plscmap1
void c_plscmap1(PLINT *r, PLINT *g, PLINT *b, PLINT ncol1)
PLESC_DOUBLEBUFFERING
#define PLESC_DOUBLEBUFFERING
Definition: plplot.h:285
plplot::_N8::yg
PLFLT ** yg
Definition: plplot.d:1353
plplot::plsexit
void plsexit(int function(const char *) handler)
plplot::c_plfontld
void c_plfontld(PLINT fnt)
Definition: plcore.c:3488
plplot::_N3::wxma
PLFLT wxma
Definition: plplot.d:1274
PL_COLORBAR_IMAGE
Definition: plplot_core.h:94
plplot::_N4::width
uint width
Definition: plplot.d:1287
plplot::c_plpoly3
void c_plpoly3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc)
MAG_COLOR
#define MAG_COLOR
Definition: plplot.h:1506
plplot::c_plfont
void c_plfont(PLINT ifont)
Definition: plsym.c:1341
plplot::c_plsurf3d
void c_plsurf3d(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
PL_OPT_ENABLED
#define PL_OPT_ENABLED
Definition: plplot.h:341
pllab
#define pllab
Definition: plplot.h:757
plplot
Definition: plplot.d:2
plarc
#define plarc
Definition: plplot.h:693
plplot::_N5::ny
PLINT ny
Definition: plplot.d:1304
plprec
#define plprec
Definition: plplot.h:783
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::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::plf2eval2
PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:428
plsetopt
#define plsetopt
Definition: plplot.h:815
plplot::c_plinit
void c_plinit()
Definition: plcore.c:2325
PL_OPT_INT
#define PL_OPT_INT
Definition: plplot.h:351
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)
plclear
#define plclear
Definition: plplot.h:701
plschr
#define plschr
Definition: plplot.h:790
PL_MASK_BUTTON5
#define PL_MASK_BUTTON5
Definition: plplot.h:431
PL_PARSE_NODASH
#define PL_PARSE_NODASH
Definition: plplot.h:366
plplot::c_plvasp
void c_plvasp(PLFLT aspect)
Definition: plvpor.c:454
PL_FCI_UPRIGHT
Definition: plplot_core.h:122
plplot::_N6::ny
PLINT ny
Definition: plplot.d:1318
pltimefmt
#define pltimefmt
Definition: plplot.h:856
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)
plssub
#define plssub
Definition: plplot.h:836
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)
plctime
#define plctime
Definition: plplot.h:708
PLBOOL
PLINT PLBOOL
Definition: plplot.h:204
PL_COLORBAR_BOUNDING_BOX
Definition: plplot_core.h:106
FACETED
#define FACETED
Definition: plplot.h:1511
plplot::_N3
Definition: plplot.d:1267
pllegend
#define pllegend
Definition: plplot.h:758
PL_OPT_DISABLED
#define PL_OPT_DISABLED
Definition: plplot.h:345
plplot::c_plptex
void c_plptex(PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text)
plcolorbar
#define plcolorbar
Definition: plplot.h:704
PL_PARSE_PARTIAL
#define PL_PARSE_PARTIAL
Definition: plplot.h:358
BASE_CONT
#define BASE_CONT
Definition: plplot.h:1507
plplot::c_plgra
void c_plgra()
Definition: plctrl.c:2003
plplot::c_plscolbga
void c_plscolbga(PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plctrl.c:248
plplot::c_plpoin3
void c_plpoin3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code)
plplot::plClearOpts
void plClearOpts()
Definition: plargs.c:830
plplot::c_plsym
void c_plsym(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
plcont
#define plcont
Definition: plplot.h:706
plplot::c_plpat
void c_plpat(PLINT nlin, PLINT *inc, PLINT *del)
plplot::c_plerrx
void c_plerrx(PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y)
plscmap1
#define plscmap1
Definition: plplot.h:794
plscmap0a
#define plscmap0a
Definition: plplot.h:792
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
PL_PARSE_NODELETE
#define PL_PARSE_NODELETE
Definition: plplot.h:361
plscmap1la
#define plscmap1la
Definition: plplot.h:797
plplot::c_plbtime
void c_plbtime(PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime)
Definition: pltime.c:26
PLESC_SET_LPB
#define PLESC_SET_LPB
Definition: plplot.h:273
plplot::_N9::name
char * name
Definition: plplot.d:1373
pljoin
#define pljoin
Definition: plplot.h:756
name
static const char * name
Definition: tkMain.c:135
plstripd
#define plstripd
Definition: plplot.h:845
PLESC_REDRAW
#define PLESC_REDRAW
Definition: plplot.h:276
PLUNICODE
PLUINT PLUNICODE
Definition: plplot.h:201
ct_func
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plplotluacLUA_wrap.c:3063
plplot::c_plctime
void c_plctime(PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime)
Definition: pltime.c:54
PL_BIN_NOEXPAND
Definition: plplot_core.h:35
plmesh
#define plmesh
Definition: plplot.h:770
plxormod
#define plxormod
Definition: plplot.h:865
PLESC_ARC
#define PLESC_ARC
Definition: plplot.h:304
plvpor
#define plvpor
Definition: plplot.h:860
plplot::_N2::dX
PLFLT dX
Definition: plplot.d:1257
plaxes
#define plaxes
Definition: plplot.h:694
plplot::c_plsori
void c_plsori(PLINT ori)
Definition: plcore.c:3765
plgcolbga
#define plgcolbga
Definition: plplot.h:727
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_plgzax
void c_plgzax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4070
plplot::c_plclear
void c_plclear()
Definition: plpage.c:71
plgyax
#define plgyax
Definition: plplot.h:749
PL_FCI_MONO
Definition: plplot_core.h:115
PL_HIST_NOSCALING
Definition: plplot_core.h:43
plcol1
#define plcol1
Definition: plplot.h:703
plplot::c_plpoin
void c_plpoin(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
plplot::_N7::yg
PLFLT * yg
Definition: plplot.d:1336
plgvpd
#define plgvpd
Definition: plplot.h:746
PLESC_DASH
#define PLESC_DASH
Definition: plplot.h:289
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_POSITION_TOP
Definition: plplot_core.h:64
plpsty
#define plpsty
Definition: plplot.h:784
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
PLESC_RESIZE
#define PLESC_RESIZE
Definition: plplot.h:275
plplot::c_pleop
void c_pleop()
Definition: plpage.c:101
plplot::plf2eval
PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:447
plbop
#define plbop
Definition: plplot.h:696
plplot::c_plgvpw
void c_plgvpw(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax)
Definition: plcore.c:4108
plplot::_N1::syntax
string syntax
Definition: plplot.d:1239
plsdiplt
#define plsdiplt
Definition: plplot.h:810
plplot::_N8::xg
PLFLT ** xg
Definition: plplot.d:1352
plplot::pl_cmd
void pl_cmd(PLINT op, void *ptr)
Definition: plctrl.c:2118
PLTEXT_SUBSCRIPT
#define PLTEXT_SUBSCRIPT
Definition: plplot.h:316
plplot::c_plfill3
void c_plfill3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
plplot::c_pltext
void c_pltext()
Switches to text screen.
Definition: plctrl.c:2100
PLESC_DI
#define PLESC_DI
Definition: plplot.h:280
PL_FCI_SYMBOL
Definition: plplot_core.h:117
PLTEXT_FONTCHANGE
#define PLTEXT_FONTCHANGE
Definition: plplot.h:314
plsurf3dl
#define plsurf3dl
Definition: plplot.h:848
plplot::_N3::dxmi
PLFLT dxmi
Definition: plplot.d:1269
plslabelfunc
#define plslabelfunc
Definition: plplot.h:825
plplot::c_plscmap1_range
void c_plscmap1_range(PLFLT min_color, PLFLT max_color)
Definition: plctrl.c:892
pl_setcontlabelparam
#define pl_setcontlabelparam
Definition: plplot.h:691
plplot::_N3::wyma
PLFLT wyma
Definition: plplot.d:1276
plgradient
#define plgradient
Definition: plplot.h:741
plgdiori
#define plgdiori
Definition: plplot.h:731
plgdiplt
#define plgdiplt
Definition: plplot.h:732
plmeridians
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:708
plplot::c_plgcol0
void c_plgcol0(PLINT icol0, PLINT *r, PLINT *g, PLINT *b)
Definition: plctrl.c:359
GRID_DTLI
#define GRID_DTLI
Definition: plplot.h:1195
PL_LEGEND_BOUNDING_BOX
Definition: plplot_core.h:82
plplot::c_plgcol0a
void c_plgcol0a(PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a)
Definition: plctrl.c:396
plplot::c_plsxax
void c_plsxax(PLINT digmax, PLINT digits)
Definition: plcore.c:4043
plplot::plGetInt
PLINT plGetInt(const char *s)
plplot::_N3::wymi
PLFLT wymi
Definition: plplot.d:1275
GRID_NNI
#define GRID_NNI
Definition: plplot.h:1196
plline3
#define plline3
Definition: plplot.h:762
PLESC_GETC
#define PLESC_GETC
Definition: plplot.h:283
plplot::_N7::nx
PLINT nx
Definition: plplot.d:1338
plsfam
#define plsfam
Definition: plplot.h:816
PL_COLORBAR_BACKGROUND
Definition: plplot_core.h:105
plsfnam
#define plsfnam
Definition: plplot.h:818
ONEW2D
#define ONEW2D
Definition: plplot.h:325
MESH
#define MESH
Definition: plplot.h:1512
ZEROW2D
#define ZEROW2D
Definition: plplot.h:323
plflush
#define plflush
Definition: plplot.h:719
plplot::c_plstart
void c_plstart(const char *devname, PLINT nx, PLINT ny)
plplot::c_plgcolbga
void c_plgcolbga(PLINT *r, PLINT *g, PLINT *b, PLFLT *a)
Definition: plctrl.c:279
plplot::PLBufferingCB
alias _N11 PLBufferingCB
Definition: plplot.d:1398
PL_COLORBAR_CAP_NONE
Definition: plplot_core.h:97
plplot::c_plvpor
void c_plvpor(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plvpor.c:342
plplot::_N7
Definition: plplot.d:1333
color
static int color
Definition: ps.c:78
plgfam
#define plgfam
Definition: plplot.h:734
plsmin
#define plsmin
Definition: plplot.h:829
plscolor
#define plscolor
Definition: plplot.h:804
plplot::_N3::dyma
PLFLT dyma
Definition: plplot.d:1272
plplot::_N3::wxmi
PLFLT wxmi
Definition: plplot.d:1273
plplot::c_plwind
void c_plwind(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plwind.c:33
PLESC_MODESET
#define PLESC_MODESET
Definition: plplot.h:306
plconfigtime
#define plconfigtime
Definition: plplot.h:705
mapform_func
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
Definition: plplotluacLUA_wrap.c:3064
plplot::c_plslabelfunc
void c_plslabelfunc(void function(PLINT, PLFLT, char *, PLINT, PLPointer) labelfunc, PLPointer label_data)
plplot::c_plsdiplt
void c_plsdiplt(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plcore.c:1782
plplot::PLDisplay
alias _N4 PLDisplay
Definition: plplot.d:1290
plplot::c_plspage
void c_plspage(PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng, PLINT xoff, PLINT yoff)
Definition: plcore.c:3593
plscmap1n
#define plscmap1n
Definition: plplot.h:798
PL_OPT_INVISIBLE
#define PL_OPT_INVISIBLE
Definition: plplot.h:344
pltext
#define pltext
Definition: plplot.h:855
plplot::c_pljoin
void c_pljoin(PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plline.c:62
plgfont
#define plgfont
Definition: plplot.h:737
plplot::c_plsfam
void c_plsfam(PLINT fam, PLINT num, PLINT bmax)
Definition: plcore.c:4005
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::c_plcol1
void c_plcol1(PLFLT col1)
Definition: plctrl.c:188
plplot::c_plsmin
void c_plsmin(PLFLT def, PLFLT scale)
Definition: plsdef.c:220
plenv
#define plenv
Definition: plplot.h:711
plplot::C
C
plplot::_N7::zg
PLFLT * zg
Definition: plplot.d:1337
plplot::c_plmesh
void c_plmesh(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt)
plplot::plsxwin
void plsxwin(PLINT window_id)
Definition: plcore.c:3978
PL_BIN_CENTRED
Definition: plplot_core.h:34
plscmap1a
#define plscmap1a
Definition: plplot.h:795
plstyl
#define plstyl
Definition: plplot.h:846
plplot::plgesc
void plgesc(char *p_esc)
Definition: plcore.c:3914
plplot::c_plcalc_world
void c_plcalc_world(PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window)
Definition: plpage.c:289
PL_FCI_MARK
#define PL_FCI_MARK
Definition: plplot.h:370
plplot::_N7::ny
PLINT ny
Definition: plplot.d:1339
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)
plplot::c_plstripd
void c_plstripd(PLINT id)
Definition: plstripc.c:327
plplot::plAlloc2dGrid
void plAlloc2dGrid(PLFLT ***f, PLINT nx, PLINT ny)
Definition: plmem.c:91
PL_COLORBAR_LABEL_LEFT
Definition: plplot_core.h:90
PLOptionTable
Definition: plplot.h:395
plplot::_N2::button
uint button
Definition: plplot.d:1252
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::PLcGrid2::xg
PLFLT[][] xg
Definition: plplot.d:31
plplot::_N2
Definition: plplot.d:1247
plplot::c_plwidth
void c_plwidth(PLFLT width)
Definition: plcore.c:3777
PL_BIN_DEFAULT
Definition: plplot_core.h:33
plplot::_N2::wY
PLFLT wY
Definition: plplot.d:1260
plcallback::fill
PLDLLIMPEXP_CXX void fill(PLINT n, const PLFLT *x, const PLFLT *y)
Definition: plstream.cc:246
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)
PL_NOTSET
#define PL_NOTSET
Definition: plplot.h:468
plgdev
#define plgdev
Definition: plplot.h:729
plplot::_N9::a
PLFLT a
Definition: plplot.d:1372
PL_FCI_SANS
Definition: plplot_core.h:113
PLESC_CLEAR
#define PLESC_CLEAR
Definition: plplot.h:288
PL_MASK_BUTTON4
#define PL_MASK_BUTTON4
Definition: plplot.h:430
plplot::PLWindow
alias _N3 PLWindow
Definition: plplot.d:1278
plplot::PLcGrid2::yg
PLFLT[][] yg
Definition: plplot.d:32
plplot::c_plerry
void c_plerry(PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax)
PL_COLORBAR_NULL
Definition: plplot_core.h:89
plplot::c_pl_setcontlabelformat
void c_pl_setcontlabelformat(PLINT lexp, PLINT sigdig)
Definition: plcont.c:256
mapform
void mapform(PLINT n, PLFLT *x, PLFLT *y)
Definition: tclAPI.c:3693
plfontld
#define plfontld
Definition: plplot.h:721
plot3dcl
#define plot3dcl
Definition: plplot.h:777
PL_MASK_BUTTON3
#define PL_MASK_BUTTON3
Definition: plplot.h:429
plplot::c_plscmap0a
void c_plscmap0a(PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol0)
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)
plplot::c_plsfci
void c_plsfci(PLUNICODE fci)
Definition: plcore.c:3926
PL_LEGEND_NULL
Definition: plplot_core.h:75
plplot::c_pl_setcontlabelparam
void c_pl_setcontlabelparam(PLFLT offset, PLFLT size, PLFLT spacing, PLINT active)
Definition: plcont.c:247
plfill3
#define plfill3
Definition: plplot.h:718
PLESC_IMAGEOPS
#define PLESC_IMAGEOPS
Definition: plplot.h:292
plplot::c_plrandd
PLFLT c_plrandd()
Definition: plctrl.c:3081
plrgbhls
#define plrgbhls
Definition: plplot.h:789
PLGraphicsIn
Definition: plplot.h:433
plplot::PLOptionTable
alias _N1 PLOptionTable
Definition: plplot.d:1242
plszax
#define plszax
Definition: plplot.h:854
PL_MASK_CONTROL
#define PL_MASK_CONTROL
Definition: plplot.h:421
plplot::c_plspal1
void c_plspal1(const char *filename, PLBOOL interpolate)
plplot::c_plfill
void c_plfill(PLINT n, PLFLT *x, PLFLT *y)
PL_MASK_WIN
#define PL_MASK_WIN
Definition: plplot.h:425
plplot::_N1::client_data
void * client_data
Definition: plplot.d:1236
plplot::c_plgvpd
void c_plgvpd(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax)
Definition: plcore.c:4097
plplot::plsabort
void plsabort(void function(const char *) handler)
plfont
#define plfont
Definition: plplot.h:720
PL_MASK_BUTTON2
#define PL_MASK_BUTTON2
Definition: plplot.h:428
plsvect
#define plsvect
Definition: plplot.h:849
PLPointer
void * PLPointer
Definition: plplot.h:209
plplot::plgrdient
alias c_plgradient plgrdient
Definition: plplot.d:1500
plplot::_N1::opt
string opt
Definition: plplot.d:1234
PLTEXT_BACKCHAR
#define PLTEXT_BACKCHAR
Definition: plplot.h:317
plplot::plFindCommand
char * plFindCommand(const char *fn)
plplot::c_plgdiplt
void c_plgdiplt(PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax)
Definition: plcore.c:1872
c_plmeridians
PLDLLIMPEXP void c_plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
plplot::plgDevs
void plgDevs(char ***p_menustr, char ***p_devname, int *p_ndev)
plplot::c_plsdimap
void c_plsdimap(PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax, PLFLT dimxpmm, PLFLT dimypmm)
Definition: plcore.c:2160
plbin
#define plbin
Definition: plplot.h:695
PLESC_EH
#define PLESC_EH
Definition: plplot.h:282
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
plhlsrgb
#define plhlsrgb
Definition: plplot.h:752
PLESC_TEXT_CHAR
#define PLESC_TEXT_CHAR
Definition: plplot.h:299
plgfnam
#define plgfnam
Definition: plplot.h:736
plfamadv
#define plfamadv
Definition: plplot.h:716
PL_PARSE_FULL
#define PL_PARSE_FULL
Definition: plplot.h:359
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)
PL_LEGEND_NONE
Definition: plplot_core.h:76
plparseopts
#define plparseopts
Definition: plplot.h:778
PL_COLORBAR_ORIENT_TOP
Definition: plplot_core.h:102
plsori
#define plsori
Definition: plplot.h:830
plplot::_N10::alt_hue_path
int alt_hue_path
Definition: plplot.d:1386
PL_POSITION_LEFT
Definition: plplot_core.h:62
plplot::c_plsetopt
PLINT c_plsetopt(const char *opt, const char *optarg)
argv
static char ** argv
Definition: qt.cpp:49
plplot::c_plgstrm
void c_plgstrm(PLINT *p_strm)
Definition: plcore.c:2652
plplot::plsKeyEH
void plsKeyEH(void function(PLGraphicsIn *, void *, int *) KeyEH, void *KeyEH_data)
plplot::c_plenv
void c_plenv(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plvpor.c:89
PLTEXT_SUPERSCRIPT
#define PLTEXT_SUPERSCRIPT
Definition: plplot.h:315
plplot::c_plgfci
void c_plgfci(PLUNICODE *pfci)
Definition: plcore.c:3936
PL_LEGEND_BACKGROUND
Definition: plplot_core.h:81
PL_OPT_FLOAT
#define PL_OPT_FLOAT
Definition: plplot.h:352
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
PL_COLORBAR_ORIENT_LEFT
Definition: plplot_core.h:103
PL_LEGEND_ROW_MAJOR
Definition: plplot_core.h:83
plimagefr
#define plimagefr
Definition: plplot.h:754
plstar
#define plstar
Definition: plplot.h:838
PL_FCI_STYLE
#define PL_FCI_STYLE
Definition: plplot.h:377
plend1
#define plend1
Definition: plplot.h:710
plstripa
#define plstripa
Definition: plplot.h:843
PL_FCI_IMPOSSIBLE
#define PL_FCI_IMPOSSIBLE
Definition: plplot.h:371
plplot::_N2::pY
int pY
Definition: plplot.d:1256
PL_PARSE_NOPROGRAM
#define PL_PARSE_NOPROGRAM
Definition: plplot.h:365
plplot::c_pllightsource
void c_pllightsource(PLFLT x, PLFLT y, PLFLT z)
Definition: plot3d.c:101
plplot::_N6
Definition: plplot.d:1314
plplot::c_pllsty
void c_pllsty(PLINT lin)
Definition: plsdef.c:268
plvsta
#define plvsta
Definition: plplot.h:861
plplot::_N2::type
int type
Definition: plplot.d:1249
PLESC_FLUSH_REMAINING_BUFFER
#define PLESC_FLUSH_REMAINING_BUFFER
Definition: plplot.h:311
plplot::c_plpsty
void c_plpsty(PLINT patt)
Definition: plsdef.c:327
plplot::c_plscmap0n
void c_plscmap0n(PLINT ncol0)
Definition: plctrl.c:942
TOP_CONT
#define TOP_CONT
Definition: plplot.h:1508
plplot::PLGraphicsIn
alias _N2 PLGraphicsIn
Definition: plplot.d:1262
pleop
#define pleop
Definition: plplot.h:713
plplot::_N1::var
void * var
Definition: plplot.d:1237
plplot::_N5::f
PLFLT * f
Definition: plplot.d:1302
PLESC_DOUBLEBUFFERING_QUERY
#define PLESC_DOUBLEBUFFERING_QUERY
Definition: plplot.h:578
plplot::pltr1
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:874
PL_COLORBAR_CAP_HIGH
Definition: plplot_core.h:99
plplot::c_plseed
void c_plseed(uint s)
plgpage
#define plgpage
Definition: plplot.h:739
plplot::_N8::nx
PLINT nx
Definition: plplot.d:1355
plvect
#define plvect
Definition: plplot.h:858
plsdimap
#define plsdimap
Definition: plplot.h:808
plplot::c_plenv0
void c_plenv0(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plvpor.c:103
PLESC_ALLOC_NCOL
#define PLESC_ALLOC_NCOL
Definition: plplot.h:272
plplot::_N2::pX
int pX
Definition: plplot.d:1255
plscol0a
#define plscol0a
Definition: plplot.h:801
pllightsource
#define pllightsource
Definition: plplot.h:759
plplot::convert_array
PLFLT ** convert_array(PLFLT[][] a)
Definition: plplot.d:37
plshades
#define plshades
Definition: plplot.h:824
plgchr
#define plgchr
Definition: plplot.h:722
plplot::c_plgyax
void c_plgyax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4052
DRAW_LINEXY
#define DRAW_LINEXY
Definition: plplot.h:1505
plplot::c_plline
void c_plline(PLINT n, PLFLT *x, PLFLT *y)
plplot::_N10::l
PLFLT l
Definition: plplot.d:1382
plplot::c_plgdev
void c_plgdev(char *p_dev)
Definition: plcore.c:3658
plplot::_N4::x
uint x
Definition: plplot.d:1285
plplot::_N7::xg
PLFLT * xg
Definition: plplot.d:1335
plsdev
#define plsdev
Definition: plplot.h:806
plplot::c_plbox
void c_plbox(const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
plplot::c_plend1
void c_plend1()
Definition: plcore.c:2542
plplot::c_plaxes
void c_plaxes(PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
plplot::plFree2dGrid
void plFree2dGrid(PLFLT **f, PLINT nx, PLINT ny)
plplot::c_plspause
void c_plspause(PLBOOL pause)
Definition: plcore.c:3852
plplot::_N10::p
PLFLT p
Definition: plplot.d:1384
PL_MAXKEY
#define PL_MAXKEY
Definition: plplot.h:408
DRAW_SIDES
#define DRAW_SIDES
Definition: plplot.h:1510
plplot::pldip2dc
void pldip2dc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1737
plplot::c_pltimefmt
void c_pltimefmt(const char *fmt)
PL_FCI_ITALIC
Definition: plplot_core.h:123
plpoly3
#define plpoly3
Definition: plplot.h:782
plscolbg
#define plscolbg
Definition: plplot.h:802
plplot::c_plsdiori
void c_plsdiori(PLFLT rot)
Definition: plcore.c:2022
plplot::c_plcol0
void c_plcol0(PLINT icol0)
Definition: plctrl.c:154
plseed
#define plseed
Definition: plplot.h:813
plstring
#define plstring
Definition: plplot.h:841
PLESC_APPEND_BUFFER
#define PLESC_APPEND_BUFFER
Definition: plplot.h:310
plsmem
#define plsmem
Definition: plplot.h:827
plpath
#define plpath
Definition: plplot.h:761
plplot::pltr0f
void pltr0f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
plscolbga
#define plscolbga
Definition: plplot.h:803
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::_N1
Definition: plplot.d:1232
plplot::_N11
Definition: plplot.d:1393
plbox3
#define plbox3
Definition: plplot.h:698
plplot::_N1::mode
int mode
Definition: plplot.d:1238
plplot::c_plsesc
void c_plsesc(char esc)
Definition: plcore.c:3890
plplot::_N9::b
ubyte b
Definition: plplot.d:1371
plplot::_N10::s
PLFLT s
Definition: plplot.d:1383
PLINT
int PLINT
Definition: plplot.h:181
plcpstrm
#define plcpstrm
Definition: plplot.h:707
plplot::PLfGrid
alias _N5 PLfGrid
Definition: plplot.d:1307
plplot::c_plscmap1a
void c_plscmap1a(PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol1)
PL_MASK_ALTGR
#define PL_MASK_ALTGR
Definition: plplot.h:424
plplot::PLcGrid
Definition: plplot.d:23
plreplot
#define plreplot
Definition: plplot.h:788
plplot::plFindName
PLINT plFindName(char *p)
Definition: plctrl.c:2432
plplot::c_plsdiplz
void c_plsdiplz(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plcore.c:1806
PL_PARSE_SKIP
#define PL_PARSE_SKIP
Definition: plplot.h:367
plsmaj
#define plsmaj
Definition: plplot.h:826
PLESC_MODEGET
#define PLESC_MODEGET
Definition: plplot.h:307
plstring3
#define plstring3
Definition: plplot.h:842
plplot::c_plparseopts
PLINT c_plparseopts(int *p_argc, char **argv, PLINT mode)
Definition: plargs.c:865
plcalc_world
#define plcalc_world
Definition: plplot.h:700
plplot::plSetUsage
void plSetUsage(const char *program_string, const char *usage_string)
plstripc
#define plstripc
Definition: plplot.h:844
plplot::_N2::state
uint state
Definition: plplot.d:1250
PLESC_IMPORT_BUFFER
#define PLESC_IMPORT_BUFFER
Definition: plplot.h:309
plplot::c_plstring
void c_plstring(PLINT n, PLFLT *x, PLFLT *y, const char *text)
plplot::plMinMax2dGrid
void plMinMax2dGrid(PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin)
plplot::c_plmkstrm
void c_plmkstrm(PLINT *p_strm)
Definition: plcore.c:2671
PL_COLORBAR_SHADE
Definition: plplot_core.h:95
plvpas
#define plvpas
Definition: plplot.h:859
plplot::pldid2pc
void pldid2pc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1691
plplot::_N2::keysym
uint keysym
Definition: plplot.d:1251
plplot::c_plscmap0
void c_plscmap0(PLINT *r, PLINT *g, PLINT *b, PLINT ncol0)
plplot::c_PLcGrid
alias _N7 c_PLcGrid
Definition: plplot.d:1342
GRID_NNLI
#define GRID_NNLI
Definition: plplot.h:1198
plplot::c_plcpstrm
void c_plcpstrm(PLINT iplsr, PLBOOL flags)
Definition: plcore.c:2761
plplot::c_plsmaj
void c_plsmaj(PLFLT def, PLFLT scale)
Definition: plsdef.c:235
plplot::c_pladv
void c_pladv(PLINT page)
Definition: plpage.c:34
PL_FCI_SCRIPT
Definition: plplot_core.h:116
plplot::_N7::nz
PLINT nz
Definition: plplot.d:1340
plplot::PLcGrid::xg
PLFLT[] xg
Definition: plplot.d:25
plplot::c_plot3d
void c_plot3d(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
plplot::c_plscolor
void c_plscolor(PLINT color)
Definition: plctrl.c:1202
plplot::_N9::g
ubyte g
Definition: plplot.d:1370
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
plplot::c_plflush
void c_plflush()
Definition: plcore.c:2230
plplot::_N2::string
char[16] string
Definition: plplot.d:1254
plmeshc
#define plmeshc
Definition: plplot.h:771
plline
#define plline
Definition: plplot.h:760
plgcompression
#define plgcompression
Definition: plplot.h:728
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)
plplot::c_plscmap1l
void c_plscmap1l(PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLBOOL *alt_hue_path)
SURF_CONT
#define SURF_CONT
Definition: plplot.h:1509
plplot::_N2::wX
PLFLT wX
Definition: plplot.d:1259
plplot::c_plspal0
void c_plspal0(const char *filename)
PL_COLORBAR_SHADE_LABEL
Definition: plplot_core.h:100
DRAW_LINEY
#define DRAW_LINEY
Definition: plplot.h:1504
PLESC_END_RASTERIZE
#define PLESC_END_RASTERIZE
Definition: plplot.h:303
PLESC_SWIN
#define PLESC_SWIN
Definition: plplot.h:284
plplot::c_plscompression
void c_plscompression(PLINT compression)
Definition: plcore.c:4270
plspause
#define plspause
Definition: plplot.h:834
plspal0
#define plspal0
Definition: plplot.h:832
plplot::_N4::y
uint y
Definition: plplot.d:1286
plplot::_N10::h
PLFLT h
Definition: plplot.d:1381
plplot::c_plstyl
void c_plstyl(PLINT nms, PLINT *mark, PLINT *space)
PL_MASK_NUM
#define PL_MASK_NUM
Definition: plplot.h:423
plplot::plOptUsage
void plOptUsage()
Definition: plargs.c:1304
plsesc
#define plsesc
Definition: plplot.h:814
PLESC_SET_COMPRESSION
#define PLESC_SET_COMPRESSION
Definition: plplot.h:287
plplot::plsError
void plsError(PLINT *errcode, const char *errmsg)
PL_FCI_OBLIQUE
Definition: plplot_core.h:124
plptex
#define plptex
Definition: plplot.h:785
PL_FCI_BOLD
Definition: plplot_core.h:130
plscol0
#define plscol0
Definition: plplot.h:800
plgver
#define plgver
Definition: plplot.h:745
PL_MASK_CAPS
#define PL_MASK_CAPS
Definition: plplot.h:420
PL_POSITION_SUBPAGE
Definition: plplot_core.h:69
plplot::c_plssym
void c_plssym(PLFLT def, PLFLT scale)
Definition: plsdef.c:250
PL_X_AXIS
#define PL_X_AXIS
Definition: plplot.h:333
plplot::plGetName
void plGetName(const char *dir, const char *subdir, const char *filename, char **filespec)
plplot::_N5
Definition: plplot.d:1300
plplot::PLcGrid::yg
PLFLT[] yg
Definition: plplot.d:26
plwidth
#define plwidth
Definition: plplot.h:863
PL_PARSE_OVERRIDE
#define PL_PARSE_OVERRIDE
Definition: plplot.h:364
plplot::c_plsfnam
void c_plsfnam(const char *fnam)
plbtime
#define plbtime
Definition: plplot.h:699
options
static PLOptionTable options[]
Definition: tclMain.c:108
plplot::c_plscol0a
void c_plscol0a(PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plctrl.c:326
plstransform
#define plstransform
Definition: plplot.h:840
plplot::c_plszax
void c_plszax(PLINT digmax, PLINT digits)
Definition: plcore.c:4079
PL_OPT_NODELETE
#define PL_OPT_NODELETE
Definition: plplot.h:343
plspal1
#define plspal1
Definition: plplot.h:833
plcol0
#define plcol0
Definition: plplot.h:702
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)
PL_MASK_ALT
#define PL_MASK_ALT
Definition: plplot.h:422
PL_COLORBAR_LABEL_RIGHT
Definition: plplot_core.h:91
plgra
#define plgra
Definition: plplot.h:740
PLESC_EXPOSE
#define PLESC_EXPOSE
Definition: plplot.h:274
plplot::c_plstring3
void c_plstring3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, const char *text)
c_plmap
PLDLLIMPEXP void c_plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
plplot::c_plscolbg
void c_plscolbg(PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:229
plplot::c_plreplot
void c_plreplot()
Definition: plcore.c:3506
PL_LEGEND_TEXT_LEFT
Definition: plplot_core.h:80
plsxax
#define plsxax
Definition: plplot.h:851
PLFLT
float PLFLT
Definition: plplot.h:163
PL_OPT_STRING
#define PL_OPT_STRING
Definition: plplot.h:353
PLESC_START_RASTERIZE
#define PLESC_START_RASTERIZE
Definition: plplot.h:302
plplot::c_plgdidev
void c_plgdidev(PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy)
Definition: plcore.c:2007
PL_OPT_BOOL
#define PL_OPT_BOOL
Definition: plplot.h:350
plplot::c_plsstrm
void c_plsstrm(PLINT strm)
Definition: plcore.c:2621
PL_MAXWINDOWS
#define PL_MAXWINDOWS
Definition: plplot.h:448
plgzax
#define plgzax
Definition: plplot.h:750
PLESC_GRADIENT
#define PLESC_GRADIENT
Definition: plplot.h:305
PL_COLORBAR_LABEL_BOTTOM
Definition: plplot_core.h:93
plplot::plGetCursor
PLINT plGetCursor(PLGraphicsIn *gin)
Definition: plpage.c:244
plplot::PLcGrid2
Definition: plplot.d:29
PL_Y_AXIS
#define PL_Y_AXIS
Definition: plplot.h:334
PL_POSITION_NULL
Definition: plplot_core.h:61
plplot::plResetOpts
void plResetOpts()
Definition: plargs.c:843
plgcol0
#define plgcol0
Definition: plplot.h:724
plsfont
#define plsfont
Definition: plplot.h:819
PLESC_FILL
#define PLESC_FILL
Definition: plplot.h:279
plw3d
#define plw3d
Definition: plplot.h:862
plplot::c_plglevel
void c_plglevel(PLINT *p_level)
Definition: plcore.c:3707
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
plplot::c_plmtex3
void c_plmtex3(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
PL_COLORBAR_ORIENT_BOTTOM
Definition: plplot_core.h:104
plplot::c_plhist
void c_plhist(PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt)
plplot::c_plgchr
void c_plgchr(PLFLT *p_def, PLFLT *p_ht)
Definition: plcore.c:4088
plplot::plsButtonEH
void plsButtonEH(void function(PLGraphicsIn *, void *, int *) ButtonEH, void *ButtonEH_data)
plplot::PLcGrid2::zg
PLFLT[][] zg
Definition: plplot.d:33
plplot::c_plvpas
void c_plvpas(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect)
Definition: plvpor.c:384
plgvpw
#define plgvpw
Definition: plplot.h:747
PLSWIN_DEVICE
#define PLSWIN_DEVICE
Definition: plplot.h:329
ZEROW2B
#define ZEROW2B
Definition: plplot.h:322
plplot::c_plsvect
void c_plsvect(PLFLT *arrowx, PLFLT *arrowy, PLINT npts, PLBOOL fill)
plplot::c_plscol0
void c_plscol0(PLINT icol0, PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:296
plmkstrm
#define plmkstrm
Definition: plplot.h:772
plhist
#define plhist
Definition: plplot.h:751
GRID_NNAIDW
#define GRID_NNAIDW
Definition: plplot.h:1199
PLESC_PL2DEVCOL
#define PLESC_PL2DEVCOL
Definition: plplot.h:293
plplot::plseopH
void plseopH(void function(void *, int *) handler, void *handler_data)
plplot::c_plschr
void c_plschr(PLFLT def, PLFLT scale)
Definition: plsdef.c:202
plsvpa
#define plsvpa
Definition: plplot.h:850
plgriddata
#define plgriddata
Definition: plplot.h:742
PL_HIST_NOEXPAND
Definition: plplot_core.h:45
PLTEXT_OVERLINE
#define PLTEXT_OVERLINE
Definition: plplot.h:318
plplot::c_plvsta
void c_plvsta()
Definition: plvpor.c:307
plplot::pltr2f
void pltr2f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
Definition: plcont.c:1294
plsdiplz
#define plsdiplz
Definition: plplot.h:811
PL_HIST_DEFAULT
Definition: plplot_core.h:42
PL_DRAWMODE_DEFAULT
Definition: plplot_core.h:135
plplot::plTranslateCursor
PLINT plTranslateCursor(PLGraphicsIn *gin)
Definition: plpage.c:259
plwind
#define plwind
Definition: plplot.h:864
PL_FCI_HEXPOWER_IMPOSSIBLE
#define PL_FCI_HEXPOWER_IMPOSSIBLE
Definition: plplot.h:374
plplot::pltr2
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:941
plbox
#define plbox
Definition: plplot.h:697
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)
PLESC_DEVINIT
#define PLESC_DEVINIT
Definition: plplot.h:296
PL_BIN_NOEMPTY
Definition: plplot_core.h:36
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)
plplot::_N8::zg
PLFLT ** zg
Definition: plplot.d:1354
plplot::c_plgcolbg
void c_plgcolbg(PLINT *r, PLINT *g, PLINT *b)
Definition: plctrl.c:263
PL_POSITION_INSIDE
Definition: plplot_core.h:66
PL_PARSE_SHOWALL
#define PL_PARSE_SHOWALL
Definition: plplot.h:363
plplot::c_plprec
void c_plprec(PLINT setp, PLINT prec)
Definition: plcore.c:3860
plplot::c_plgfam
void c_plgfam(PLINT *p_fam, PLINT *p_num, PLINT *p_bmax)
Definition: plcore.c:3995
plplot::c_plmeshc
void c_plmeshc(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
PL_FCI_WEIGHT
#define PL_FCI_WEIGHT
Definition: plplot.h:378
plot3d
#define plot3d
Definition: plplot.h:775
plplot::c_plgradient
void c_plgradient(PLINT n, PLFLT *x, PLFLT *y, PLFLT angle)
PLESC_SET_RGB
#define PLESC_SET_RGB
Definition: plplot.h:271
plplot::_N3::dxma
PLFLT dxma
Definition: plplot.d:1270
plmap
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:565
plplot::c_plsyax
void c_plsyax(PLINT digmax, PLINT digits)
Definition: plcore.c:4061
plplot::c_plot3dc
void c_plot3dc(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
plplot::_N5::nz
PLINT nz
Definition: plplot.d:1305
plplot::_N9
Definition: plplot.d:1367
PL_COLORBAR_GRADIENT
Definition: plplot_core.h:96
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
PLESC_CONTROL_CHAR
#define PLESC_CONTROL_CHAR
Definition: plplot.h:300
plplot::_N1::desc
string desc
Definition: plplot.d:1240
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)
plpoin3
#define plpoin3
Definition: plplot.h:781
PL_MASK_SHIFT
#define PL_MASK_SHIFT
Definition: plplot.h:419
DRAW_LINEX
#define DRAW_LINEX
Definition: plplot.h:1503
PL_OPT_FUNC
#define PL_OPT_FUNC
Definition: plplot.h:349
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)
plplot::_N5::nx
PLINT nx
Definition: plplot.d:1303
PL_FCI_SERIF
Definition: plplot_core.h:114
PL_OPT_ARG
#define PL_OPT_ARG
Definition: plplot.h:342
PL_HIST_NOEMPTY
Definition: plplot_core.h:46
plplot::c_PLcGrid2
alias _N8 c_PLcGrid2
Definition: plplot.d:1358
PL_PARSE_QUIET
#define PL_PARSE_QUIET
Definition: plplot.h:360
plscmap1_range
#define plscmap1_range
Definition: plplot.h:799
plmtex3
#define plmtex3
Definition: plplot.h:774
plplot::c_plsmem
void c_plsmem(PLINT maxx, PLINT maxy, void *plotmem)
Definition: plcore.c:3673
plplot::c_plline3
void c_plline3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
PLESC_FLUSH
#define PLESC_FLUSH
Definition: plplot.h:281
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)
plplot::_N3::dymi
PLFLT dymi
Definition: plplot.d:1271
GRID_CSA
#define GRID_CSA
Definition: plplot.h:1194
PLESC_FIXASPECT
#define PLESC_FIXASPECT
Definition: plplot.h:308
PLESC_IMAGE
#define PLESC_IMAGE
Definition: plplot.h:291
pladv
#define pladv
Definition: plplot.h:692
PLESC_SETBGFG
#define PLESC_SETBGFG
Definition: plplot.h:295
plvasp
#define plvasp
Definition: plplot.h:857
plplot::_N6::nx
PLINT nx
Definition: plplot.d:1317
PL_COLORBAR_LABEL_TOP
Definition: plplot_core.h:92
plscmap0n
#define plscmap0n
Definition: plplot.h:793
pl_setcontlabelformat
#define pl_setcontlabelformat
Definition: plplot.h:690
text
static int text
Definition: ps.c:77
PL_DRAWMODE_REPLACE
Definition: plplot_core.h:136
plpoin
#define plpoin
Definition: plplot.h:780
plscmap0
#define plscmap0
Definition: plplot.h:791
PL_LEGEND_LINE
Definition: plplot_core.h:78
plpat
#define plpat
Definition: plplot.h:779
PL_FCI_HEXDIGIT_MASK
#define PL_FCI_HEXDIGIT_MASK
Definition: plplot.h:372
plplot::_N8::ny
PLINT ny
Definition: plplot.d:1356
PLESC_DOUBLEBUFFERING_ENABLE
#define PLESC_DOUBLEBUFFERING_ENABLE
Definition: plplot.h:576
plgxax
#define plgxax
Definition: plplot.h:748
plplot::_N4::height
uint height
Definition: plplot.d:1288
plenv0
#define plenv0
Definition: plplot.h:712
plplot::PLcGrid::zg
PLFLT[] zg
Definition: plplot.d:27
plplot::c_plsdidev
void c_plsdidev(PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy)
Definition: plcore.c:1892
plplot::PLColor
alias _N9 PLColor
Definition: plplot.d:1375
plplot::c_plfamadv
void c_plfamadv()
Definition: plcore.c:4021
plplot::plgFileDevs
void plgFileDevs(char ***p_menustr, char ***p_devname, int *p_ndev)
plplot::c_plstripa
void c_plstripa(PLINT id, PLINT pen, PLFLT x, PLFLT y)
Definition: plstripc.c:221
PL_POSITION_RIGHT
Definition: plplot_core.h:63
plplot::plGetFlt
PLFLT plGetFlt(const char *s)
plplot::c_plgver
void c_plgver(char *p_ver)
Definition: plcore.c:3970
PL_POSITION_OUTSIDE
Definition: plplot_core.h:67
plplot::c_plend
void c_plend()
Definition: plcore.c:2484
PLESC_GRAPH
#define PLESC_GRAPH
Definition: plplot.h:278
plplot::_N4
Definition: plplot.d:1283
plplot::_N10
Definition: plplot.d:1379
plplot::PLfGrid2
alias _N6 PLfGrid2
Definition: plplot.d:1320
PLESC_HAS_TEXT
#define PLESC_HAS_TEXT
Definition: plplot.h:290
plplot::_N2::dY
PLFLT dY
Definition: plplot.d:1258
plot3dc
#define plot3dc
Definition: plplot.h:776
PLESC_DEV2PLCOL
#define PLESC_DEV2PLCOL
Definition: plplot.h:294
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_plgfnam
void c_plgfnam(char *fnam)
Definition: plcore.c:3811
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
PL_COLORBAR_CAP_LOW
Definition: plplot_core.h:98
plfill
#define plfill
Definition: plplot.h:717
plsyax
#define plsyax
Definition: plplot.h:852
plglevel
#define plglevel
Definition: plplot.h:738
PLESC_TEXT
#define PLESC_TEXT
Definition: plplot.h:277
plgdidev
#define plgdidev
Definition: plplot.h:730
plerrx
#define plerrx
Definition: plplot.h:714
plplot::_N11::result
PLINT result
Definition: plplot.d:1396
plscompression
#define plscompression
Definition: plplot.h:805
PL_HIST_IGNORE_OUTLIERS
Definition: plplot_core.h:44
plgfci
#define plgfci
Definition: plplot.h:735
plsdiori
#define plsdiori
Definition: plplot.h:809
plplot::c_plbop
void c_plbop()
Definition: plpage.c:118
plplot::plMergeOpts
PLINT plMergeOpts(PLOptionTable *options, const char *name, const char **notes)
plscmap1l
#define plscmap1l
Definition: plplot.h:796
PLESC_BEGIN_TEXT
#define PLESC_BEGIN_TEXT
Definition: plplot.h:298
plplot::c_plssub
void c_plssub(PLINT nx, PLINT ny)
Definition: plcore.c:3617
plplot::c_plgdiori
void c_plgdiori(PLFLT *p_rot)
Definition: plcore.c:2145
plplot::PLControlPt
alias _N10 PLControlPt
Definition: plplot.d:1388
plmtex
#define plmtex
Definition: plplot.h:773
fill_func
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
Definition: plplotluacLUA_wrap.c:3061
plgstrm
#define plgstrm
Definition: plplot.h:744
plend
#define plend
Definition: plplot.h:709
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)
min
int min(int a, int b)
Definition: plplot_octaveOCTAVE_wrap.cxx:2497
plplot::_N2::subwindow
PLINT subwindow
Definition: plplot.d:1253
plplot::c_plgfont
void c_plgfont(PLINT *p_family, PLINT *p_style, PLINT *p_weight)
Definition: plsym.c:2138