PLplot  5.11.1
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
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 continous 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() )
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() )
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() )
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
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 // Switches for escape function call.
1042 // Some of these are obsolete but are retained in order to process
1043 // old metafiles.
1044 
1045 const PLESC_SET_RGB = 1;
1047 const PLESC_SET_LPB = 3;
1048 const PLESC_EXPOSE = 4;
1049 const PLESC_RESIZE = 5;
1050 const PLESC_REDRAW = 6;
1051 const PLESC_TEXT = 7;
1052 const PLESC_GRAPH = 8;
1053 const PLESC_FILL = 9;
1054 const PLESC_DI = 10;
1055 const PLESC_FLUSH = 11;
1056 const PLESC_EH = 12;
1057 const PLESC_GETC = 13;
1058 const PLESC_SWIN = 14;
1060 const PLESC_XORMOD = 16;
1062 const PLESC_CLEAR = 18;
1063 const PLESC_DASH = 19;
1064 const PLESC_HAS_TEXT = 20;
1065 const PLESC_IMAGE = 21;
1066 const PLESC_IMAGEOPS = 22;
1067 const PLESC_PL2DEVCOL = 23;
1068 const PLESC_DEV2PLCOL = 24;
1069 const PLESC_SETBGFG = 25;
1070 const PLESC_DEVINIT = 26;
1071 
1072 // image operations
1073 const ZEROW2B = 1;
1074 const ZEROW2D = 2;
1075 const ONEW2B = 3;
1076 const ONEW2D = 4;
1077 
1078 // Window parameter tags
1079 const PLSWIN_DEVICE = 1;
1080 const PLSWIN_WORLD = 2;
1081 
1082 // Axis label tags
1083 const PL_X_AXIS = 1; // The x-axis
1084 const PL_Y_AXIS = 2; // The y-axis
1085 const PL_Z_AXIS = 3; // The z-axis
1086 
1087 // PLplot Option table & support constants
1088 
1089 // Option-specific settings
1090 const PL_OPT_ENABLED = 0x0001;
1091 const PL_OPT_ARG = 0x0002;
1092 const PL_OPT_NODELETE = 0x0004;
1093 const PL_OPT_INVISIBLE = 0x0008;
1094 const PL_OPT_DISABLED = 0x0010;
1095 
1096 // Option-processing settings -- mutually exclusive
1097 const PL_OPT_FUNC = 0x0100;
1098 const PL_OPT_BOOL = 0x0200;
1099 const PL_OPT_INT = 0x0400;
1100 const PL_OPT_FLOAT = 0x0800;
1101 const PL_OPT_STRING = 0x1000;
1102 
1103 // Global mode settings
1104 // These override per-option settings
1105 const PL_PARSE_PARTIAL = 0x0000;
1106 const PL_PARSE_FULL = 0x0001;
1107 const PL_PARSE_QUIET = 0x0002;
1108 
1109 // processing
1110 const PL_PARSE_NODELETE = 0x0004;
1111 const PL_PARSE_SHOWALL = 0x0008;
1112 const PL_PARSE_OVERRIDE = 0x0010;
1113 const PL_PARSE_NOPROGRAM = 0x0020;
1114 const PL_PARSE_NODASH = 0x0040;
1115 const PL_PARSE_SKIP = 0x0080;
1116 
1117 // FCI (font characterization integer) related constants.
1118 const PL_FCI_MARK = 0x80000000;
1119 const PL_FCI_IMPOSSIBLE = 0x00000000;
1122 
1123 // These define hexpower values corresponding to each font attribute.
1125 const PL_FCI_FAMILY = 0x0;
1126 const PL_FCI_STYLE = 0x1;
1127 
1128 // These are legal values for font family attribute
1129 const PL_FCI_WEIGHT = 0x2;
1130 const PL_FCI_SANS = 0x0;
1131 const PL_FCI_SERIF = 0x1;
1132 const PL_FCI_MONO = 0x2;
1133 const PL_FCI_SCRIPT = 0x3;
1134 
1135 // These are legal values for font style attribute
1136 const PL_FCI_SYMBOL = 0x4;
1137 const PL_FCI_UPRIGHT = 0x0;
1138 const PL_FCI_ITALIC = 0x1;
1139 
1140 // These are legal values for font weight attribute
1141 const PL_FCI_MEDIUM = 0x0;
1142 const PL_FCI_BOLD = 0x1;
1143 const PL_FCI_OBLIQUE = 0x2;
1144 
1145 // Obsolete names
1146 
1147 // Option table definition
1148 
1149 struct _N1
1150 {
1151  string opt;
1152  int function( char *, char *, void * ) handler;
1154  void *var;
1155  int mode;
1156  string syntax;
1157  string desc;
1158 }
1159 alias _N1 PLOptionTable;
1160 
1161 // PLplot Graphics Input structure
1162 
1163 
1164 const PL_MAXKEY = 16;
1165 struct _N2
1166 {
1167  int type;
1168  uint state;
1169  uint keysym;
1170  uint button;
1172  char [16] string;
1173  int pX;
1174  int pY;
1179 }
1180 alias _N2 PLGraphicsIn;
1181 
1182 // Structure for describing the plot window
1183 
1184 
1185 const PL_MAXWINDOWS = 64;
1186 struct _N3
1187 {
1196 }
1197 alias _N3 PLWindow;
1198 
1199 // Structure for doing display-oriented operations via escape commands
1200 // May add other attributes in time
1201 
1202 struct _N4
1203 {
1204  uint x;
1205  uint y;
1206  uint width;
1207  uint height;
1208 }
1209 alias _N4 PLDisplay;
1210 
1211 // Macro used (in some cases) to ignore value of argument
1212 // I don't plan on changing the value so you can hard-code it
1213 
1214 const int PL_NOTSET = -42;
1215 
1216 // See plcont.c for examples of the following
1217 
1218 //
1219 // PLfGrid is for passing (as a pointer to the first element) an arbitrarily
1220 // dimensioned array. The grid dimensions MUST be stored, with a maximum of 3
1221 // dimensions assumed for now.
1222 //
1223 
1224 struct _N5
1225 {
1230 }
1231 alias _N5 PLfGrid;
1232 
1233 //
1234 // PLfGrid2 is for passing (as an array of pointers) a 2d function array. The
1235 // grid dimensions are passed for possible bounds checking.
1236 //
1237 
1238 struct _N6
1239 {
1243 }
1244 alias _N6 PLfGrid2;
1245 
1246 //
1247 // NOTE: a PLfGrid3 is a good idea here but there is no way to exploit it yet
1248 // so I'll leave it out for now.
1249 //
1250 
1251 //
1252 // PLcGrid is for passing (as a pointer to the first element) arbitrarily
1253 // dimensioned coordinate transformation arrays. The grid dimensions MUST be
1254 // stored, with a maximum of 3 dimensions assumed for now.
1255 //
1256 
1257 struct _N7
1258 {
1265 }
1266 alias _N7 c_PLcGrid;
1267 
1268 //
1269 // PLcGrid2 is for passing (as arrays of pointers) 2d coordinate
1270 // transformation arrays. The grid dimensions are passed for possible bounds
1271 // checking.
1272 //
1273 
1274 struct _N8
1275 {
1281 }
1282 alias _N8 c_PLcGrid2;
1283 
1284 //
1285 // NOTE: a PLcGrid3 is a good idea here but there is no way to exploit it yet
1286 // so I'll leave it out for now.
1287 //
1288 
1289 // PLColor is the usual way to pass an rgb color value.
1290 
1291 struct _N9
1292 {
1293  ubyte r;
1294  ubyte g;
1295  ubyte b;
1297  char *name;
1298 }
1299 alias _N9 PLColor;
1300 
1301 // PLControlPt is how cmap1 control points are represented.
1302 
1303 struct _N10
1304 {
1311 }
1312 alias _N10 PLControlPt;
1313 
1314 // A PLBufferingCB is a control block for interacting with devices
1315 // that support double buffering.
1316 
1317 struct _N11
1318 {
1321 }
1322 alias _N11 PLBufferingCB;
1323 
1326 
1328 
1329 //--------------------------------------------------------------------------* * BRAINDEAD-ness
1330 //
1331 // Some systems allow the Fortran & C namespaces to clobber each other.
1332 // For PLplot to work from Fortran on these systems, we must name the the
1333 // externally callable C functions something other than their Fortran entry
1334 // names. In order to make this as easy as possible for the casual user,
1335 // yet reversible to those who abhor my solution, I have done the
1336 // following:
1337 //
1338 // The C-language bindings are actually different from those
1339 // described in the manual. Macros are used to convert the
1340 // documented names to the names used in this package. The
1341 // user MUST include plplot.h in order to get the name
1342 // redefinition correct.
1343 //
1344 // Sorry to have to resort to such an ugly kludge, but it is really the
1345 // best way to handle the situation at present. If all available
1346 // compilers offer a way to correct this stupidity, then perhaps we can
1347 // eventually reverse it.
1348 //
1349 // If you feel like screaming at someone (I sure do), please
1350 // direct it at your nearest system vendor who has a braindead shared
1351 // C/Fortran namespace. Some vendors do offer compiler switches that
1352 // change the object names, but then everybody who wants to use the
1353 // package must throw these same switches, leading to no end of trouble.
1354 //
1355 // Note that this definition should not cause any noticable effects except
1356 // when debugging PLplot calls, in which case you will need to remember
1357 // the real function names (same as before but with a 'c_' prepended).
1358 //
1359 // Also, to avoid macro conflicts, the BRAINDEAD part must not be expanded
1360 // in the stub routines.
1361 //
1362 // Aside: the reason why a shared Fortran/C namespace is deserving of the
1363 // BRAINDEAD characterization is that it completely precludes the the kind
1364 // of universal API that is attempted (more or less) with PLplot, without
1365 // Herculean efforts (e.g. remapping all of the C bindings by macros as
1366 // done here). The vendors of such a scheme, in order to allow a SINGLE
1367 // type of argument to be passed transparently between C and Fortran,
1368 // namely, a pointer to a conformable data type, have slammed the door on
1369 // insertion of stub routines to handle the conversions needed for other
1370 // data types. Intelligent linkers could solve this problem, but these are
1371 // not anywhere close to becoming universal. So meanwhile, one must live
1372 // with either stub routines for the inevitable data conversions, or a
1373 // different API. The former is what is used here, but is made far more
1374 // difficult in a braindead shared Fortran/C namespace.
1375 //--------------------------------------------------------------------------
1376 
1377 
1378 
1379 
1383 //alias c_plaxes plaxes;
1384 //alias c_plbin plbin;
1386 //alias c_plbox plbox;
1387 //alias c_plbox3 plbox3;
1395 //alias c_plcolorbar plcolorbar;
1397 //alias c_plcont plcont;
1405 //alias c_plerrx plerrx;
1406 //alias c_plerry plerry;
1408 //alias c_plfill plfill;
1409 //alias c_plfill3 plfill3;
1419 //alias c_plgdev plgdev;
1425 //alias c_plgfnam plgfnam;
1431 //alias c_plgriddata plgriddata;
1434 //alias c_plgver plgver;
1440 //alias c_plhist plhist;
1443 //alias c_plimage plimage;
1444 //alias c_plimagefr plimagefr;
1447 //alias c_pllab pllab;
1448 //alias c_pllegend pllegend;
1450 //alias c_plline plline;
1452 //alias c_plline3 plline3;
1454 //alias c_plmap plmap;
1456 //alias c_plmesh plmesh;
1457 //alias c_plmeshc plmeshc;
1459 //alias c_plmtex plmtex;
1460 //alias c_plmtex3 plmtex3;
1461 //alias c_plot3d plot3d;
1462 //alias c_plot3dc plot3dc;
1463 //alias c_plot3dcl plot3dcl;
1464 //alias c_plparseopts plparseopts;
1465 //alias c_plpat plpat;
1466 //alias c_plpoin plpoin;
1467 //alias c_plpoin3 plpoin3;
1468 //alias c_plpoly3 plpoly3;
1471 //alias c_plptex plptex;
1472 //alias c_plptex3 plptex3;
1479 //alias c_plscmap0 plscmap0;
1480 //alias c_plscmap0a plscmap0a;
1482 //alias c_plscmap1 plscmap1;
1483 //alias c_plscmap1a plscmap1a;
1484 //alias c_plscmap1l plscmap1l;
1485 //alias c_plscmap1la plscmap1la;
1494 // alias c_plsdev plsdev;
1502 //alias c_plsetopt plsetopt;
1505 // alias c_plsfnam plsfnam;
1507 //alias c_plshade plshade;
1508 //alias c_plshades plshades;
1514 // alias c_plspal0 plspal0;
1515 // alias c_plspal1 plspal1;
1521 //alias c_plstart plstart;
1524 //alias c_plstripc plstripc;
1526 //alias c_plstring plstring;
1527 //alias c_plstring3 plstring3;
1528 //alias c_plstyl plstyl;
1529 //alias c_plsurf3d plsurf3d;
1530 //alias c_plsurf3dl plsurf3dl;
1531 //alias c_plsvect plsvect;
1535 //alias c_plsym plsym;
1538 //alias c_pltimefmt pltimefmt;
1540 //alias c_plvect plvect;
1547 
1549 
1550 
1551 // Redefine some old function names for backward compatibility
1552 
1553 
1554 alias pleop plclr;
1563 
1564 
1565 //--------------------------------------------------------------------------* * Function Prototypes
1566 //--------------------------------------------------------------------------
1567 
1568 
1569 // All void types
1570 // C routines callable from stub routines come first
1571 
1572 // set the format of the contour labels
1573 void c_pl_setcontlabelformat( PLINT lexp, PLINT sigdig );
1574 
1575 // set offset and spacing of contour labels
1576 void c_pl_setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing, PLINT active );
1577 
1578 // Advance to subpage "page", or to the next one if "page" = 0.
1579 void c_pladv( PLINT page );
1580 
1581 // simple arrow plotter.
1582 void c_plvect( PLFLT **u, PLFLT **v, PLINT nx, PLINT ny, PLFLT scale,
1583  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1584 void c_plsvect( PLFLT *arrowx, PLFLT *arrowy, PLINT npts, PLBOOL fill );
1585 
1586 // This functions similarly to plbox() except that the origin of the axes
1587 // is placed at the user-specified point (x0, y0).
1588 void c_plaxes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
1589  const char *yopt, PLFLT ytick, PLINT nysub );
1590 
1591 // Flags for plbin() - opt argument
1592 const PL_BIN_DEFAULT = 0;
1593 const PL_BIN_CENTRED = 1;
1595 const PL_BIN_NOEMPTY = 4;
1596 
1597 // Plot a histogram using x to store data values and y to store frequencies
1598 void c_plbin( PLINT nbin, PLFLT *x, PLFLT *y, PLINT opt );
1599 
1600 // Start new page. Should only be used with pleop().
1601 void c_plbop();
1602 
1603 // This draws a box around the current viewport.
1604 void c_plbox( const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub );
1605 
1606 // This is the 3-d analogue of plbox().
1607 void c_plbox3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx, const char *yopt,
1608  const char *ylabel, PLFLT ytick, PLINT nsuby, const char *zopt, const char *zlabel,
1609  PLFLT ztick, PLINT nsubz );
1610 
1611 // Calculate broken-down time from continuous time for current stream.
1612 void c_plbtime( PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime );
1613 
1614 // Setup a user-provided custom labeling function
1615 void c_plslabelfunc( void function( PLINT, PLFLT, char*, PLINT, PLPointer ) labelfunc,
1616  PLPointer label_data );
1617 
1618 // Calculate world coordinates and subpage from relative device coordinates.
1619 void c_plcalc_world( PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window );
1620 
1621 // Plot an arc
1622 void c_plarc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
1623  PLFLT rotate, PLBOOL fill );
1624 
1625 // Clear current subpage.
1626 void c_plclear();
1627 
1628 // Set color, map 0. Argument is integer between 0 and 15.
1629 void c_plcol0( PLINT icol0 );
1630 
1631 // Set color, map 1. Argument is a float between 0. and 1.
1632 void c_plcol1( PLFLT col1 );
1633 
1634 
1635 // Configure transformation between continuous and broken-down time (and
1636 // vice versa) for current stream.
1637 void c_plconfigtime( PLFLT scale, PLFLT offset1, PLFLT offset2, PLINT ccontrol, PLBOOL ifbtime_offset,
1638  PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec );
1639 
1640 // Draws a contour plot from data in f(nx,ny). Is just a front-end to
1641 // plfcont, with a particular choice for f2eval and f2eval_data.
1642 //
1643 void c_plcont( PLFLT **f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly,
1644  PLFLT *clevel, PLINT nlevel,
1645  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1646 
1647 // Draws a contour plot using the function evaluator f2eval and data stored
1648 // by way of the f2eval_data pointer. This allows arbitrary organizations
1649 // of 2d array data to be used.
1650 //
1651 void plfcont( PLFLT function( PLINT, PLINT, PLPointer ) f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny,
1652  PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT *clevel, PLINT nlevel,
1653  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
1654 
1655 // Copies state parameters from the reference stream to the current stream.
1656 void c_plcpstrm( PLINT iplsr, PLBOOL flags );
1657 
1658 // Calculate continuous time from broken-down time for current stream.
1659 void c_plctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime );
1660 
1661 // Converts input values from relative device coordinates to relative plot
1662 // coordinates.
1663 void pldid2pc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );
1664 
1665 // Converts input values from relative plot coordinates to relative
1666 // device coordinates.
1667 void pldip2dc( PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax );
1668 
1669 // End a plotting session for all open streams.
1670 void c_plend();
1671 
1672 // End a plotting session for the current stream only.
1673 void c_plend1();
1674 
1675 // Simple interface for defining viewport and window.
1676 void c_plenv( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis );
1677 
1678 // similar to plenv() above, but in multiplot mode does not advance the subpage,
1679 // instead the current subpage is cleared
1680 void c_plenv0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis );
1681 
1682 // End current page. Should only be used with plbop().
1683 void c_pleop();
1684 
1685 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i))
1686 void c_plerrx( PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y );
1687 
1688 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i))
1689 void c_plerry( PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax );
1690 
1691 // Advance to the next family file on the next new page
1692 void c_plfamadv();
1693 
1694 // Pattern fills the polygon bounded by the input points.
1695 void c_plfill( PLINT n, PLFLT *x, PLFLT *y );
1696 
1697 // Pattern fills the 3d polygon bounded by the input points.
1698 void c_plfill3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z );
1699 
1700 // Flushes the output stream. Use sparingly, if at all.
1701 void c_plflush();
1702 
1703 // Sets the global font flag to 'ifont'.
1704 void c_plfont( PLINT ifont );
1705 
1706 // Load specified font set.
1707 void c_plfontld( PLINT fnt );
1708 
1709 // Get character default height and current (scaled) height
1710 void c_plgchr( PLFLT *p_def, PLFLT *p_ht );
1711 
1712 // Returns 8 bit RGB values for given color from color map 0
1713 void c_plgcol0( PLINT icol0, PLINT *r, PLINT *g, PLINT *b );
1714 
1715 // Returns 8 bit RGB values for given color from color map 0 and alpha value
1716 void c_plgcol0a( PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a );
1717 
1718 // Returns the background color by 8 bit RGB value
1719 void c_plgcolbg( PLINT *r, PLINT *g, PLINT *b );
1720 
1721 // Returns the background color by 8 bit RGB value and alpha value
1722 void c_plgcolbga( PLINT *r, PLINT *g, PLINT *b, PLFLT *a );
1723 
1724 // Returns the current compression setting
1725 void c_plgcompression( PLINT *compression );
1726 
1727 // Get the current device (keyword) name
1728 void c_plgdev( char *p_dev );
1729 
1730 // Retrieve current window into device space
1731 void c_plgdidev( PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy );
1732 
1733 // Get plot orientation
1734 void c_plgdiori( PLFLT *p_rot );
1735 
1736 // Retrieve current window into plot space
1737 void c_plgdiplt( PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax );
1738 
1739 // Get FCI (font characterization integer)
1740 
1741 void c_plgfci( PLUNICODE *pfci );
1742 
1743 // Get family file parameters
1744 
1745 void c_plgfam( PLINT *p_fam, PLINT *p_num, PLINT *p_bmax );
1746 
1747 // Get the (current) output file name. Must be preallocated to >80 bytes
1748 void c_plgfnam( char *fnam );
1749 
1750 // Get the current font family, style and weight
1751 void c_plgfont( PLINT *p_family, PLINT *p_style, PLINT *p_weight );
1752 
1753 // Get the (current) run level.
1754 void c_plglevel( PLINT *p_level );
1755 
1756 // Get output device parameters.
1757 void c_plgpage( PLFLT *p_xp, PLFLT *p_yp, PLINT *p_xleng, PLINT *p_yleng,
1758  PLINT *p_xoff, PLINT *p_yoff );
1759 
1760 // Switches to graphics screen.
1761 void c_plgra();
1762 
1763 // Draw gradient in polygon.
1764 void c_plgradient( PLINT n, PLFLT *x, PLFLT *y, PLFLT angle );
1765 
1766 // grid irregularly sampled data
1767 void c_plgriddata( PLFLT *x, PLFLT *y, PLFLT *z, PLINT npts, PLFLT *xg, PLINT nptsx,
1768  PLFLT *yg, PLINT nptsy, PLFLT **zg, PLINT type, PLFLT data );
1769 
1770 // type of gridding algorithm for plgriddata()
1771 const GRID_CSA = 1;
1772 const GRID_DTLI = 2;
1773 const GRID_NNI = 3;
1774 const GRID_NNIDW = 4;
1775 const GRID_NNLI = 5;
1776 const GRID_NNAIDW = 6;
1777 
1778 // Get subpage boundaries in absolute coordinates
1779 void c_plgspa( PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax );
1780 
1781 // Get current stream number.
1782 void c_plgstrm( PLINT *p_strm );
1783 
1784 // Get the current library version number
1785 void c_plgver( char *p_ver );
1786 
1787 // Get viewport boundaries in normalized device coordinates
1788 void c_plgvpd( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax );
1789 
1790 // Get viewport boundaries in world coordinates
1791 void c_plgvpw( PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax );
1792 
1793 // Get x axis labeling parameters
1794 void c_plgxax( PLINT *p_digmax, PLINT *p_digits );
1795 
1796 // Get y axis labeling parameters
1797 void c_plgyax( PLINT *p_digmax, PLINT *p_digits );
1798 
1799 // Get z axis labeling parameters
1800 void c_plgzax( PLINT *p_digmax, PLINT *p_digits );
1801 
1802 // Flags for plhist() - opt argument; note: some flags are passed to
1803 // plbin() for the actual plotting
1808 const PL_HIST_NOEMPTY = 16;
1809 
1810 // Draws a histogram of n values of a variable in array data[0..n-1]
1811 void c_plhist( PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt );
1812 
1813 // Set current color (map 0) by hue, lightness, and saturation.
1814 void c_plhls( PLFLT h, PLFLT l, PLFLT s );
1815 
1816 // Functions for converting between HLS and RGB color space
1817 void c_plhlsrgb( PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b );
1818 
1819 // Initializes PLplot, using preset or default options
1820 void c_plinit();
1821 
1822 // Draws a line segment from (x1, y1) to (x2, y2).
1823 void c_pljoin( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
1824 
1825 // Simple routine for labelling graphs.
1826 void c_pllab( const char *xlabel, const char *ylabel, const char *tlabel );
1827 
1828 // Flags used for position argument of both pllegend and plcolorbar
1837 
1838 // Flags for pllegend
1839 const PL_LEGEND_NONE = 1;
1841 const PL_LEGEND_LINE = 4;
1847 
1848 // Flags for plcolorbar
1866 
1867 
1868 // Routine for drawing discrete line, symbol, or cmap0 legends
1869 void c_pllegend( PLFLT *p_legend_width, PLFLT *p_legend_height,
1870  PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
1871  PLINT bg_color, PLINT bb_color, PLINT bb_style,
1872  PLINT nrow, PLINT ncolumn,
1873  PLINT nlegend, PLINT *opt_array,
1874  PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
1875  PLFLT text_justification,
1876  PLINT *text_colors, const char **text,
1877  PLINT *box_colors, PLINT *box_patterns,
1878  PLFLT *box_scales, PLFLT *box_line_widths,
1879  PLINT *line_colors, PLINT *line_styles,
1880  PLFLT *line_widths,
1881  PLINT *symbol_colors, PLFLT *symbol_scales,
1882  PLINT *symbol_numbers, const char **symbols );
1883 
1884 // Routine for drawing continous colour legends
1885 void c_plcolorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
1886  PLINT opt, PLINT position, PLFLT x, PLFLT y,
1887  PLFLT x_length, PLFLT y_length,
1888  PLINT bg_color, PLINT bb_color, PLINT bb_style,
1889  PLFLT low_cap_color, PLFLT high_cap_color,
1890  PLINT cont_color, PLFLT cont_width,
1891  PLINT n_labels, const PLINT *label_opts, const char **label,
1892  PLINT n_axes, const char ** axis_opts,
1893  const PLFLT *ticks, const PLINT *sub_ticks,
1894  const PLINT *n_values, const PLFLT **values );
1895 
1896 // Sets position of the light source
1897 void c_pllightsource( PLFLT x, PLFLT y, PLFLT z );
1898 
1899 // Draws line segments connecting a series of points.
1900 void c_plline( PLINT n, PLFLT *x, PLFLT *y );
1901 
1902 // Draws a line in 3 space.
1903 void c_plline3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z );
1904 
1905 // Set line style.
1906 void c_pllsty( PLINT lin );
1907 
1908 // plot continental outline in world coordinates
1909 void c_plmap( void function( PLINT, PLFLT *, PLFLT* ) mapform, const char *type, PLFLT minlong,
1910  PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
1911 
1912 // Plot map outlines
1913 void c_plmapline( void function( PLINT, PLFLT *, PLFLT * ) mapform, const char *name,
1914  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1915  const PLINT *plotentries, PLINT nplotentries );
1916 
1917 // Plot map points
1918 void c_plmapstring( void function( PLINT, PLFLT *, PLFLT * ) mapform,
1919  const char *name, const char *string,
1920  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1921  const PLINT *plotentries, PLINT nplotentries );
1922 
1923 // Plot map text
1924 void c_plmaptex( void function( PLINT, PLFLT *, PLFLT * ) mapform,
1925  const char *name, PLFLT dx, PLFLT dy, PLFLT just, const char *text,
1926  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1927  PLINT plotentry );
1928 
1929 // Plot map fills
1930 void c_plmapfill( void function( PLINT, PLFLT *, PLFLT * ) mapform,
1931  const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1932  const PLINT *plotentries, PLINT nplotentries );
1933 
1934 // Plot the latitudes and longitudes on the background.
1935 void c_plmeridians( void function( PLINT, PLFLT *, PLFLT* ) mapform, PLFLT dlong, PLFLT dlat,
1936  PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
1937 
1938 // Plots a mesh representation of the function z[x][y].
1939 void c_plmesh( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt );
1940 
1941 // Plots a mesh representation of the function z[x][y] with contour
1942 void c_plmeshc( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1943  PLFLT *clevel, PLINT nlevel );
1944 
1945 // Creates a new stream and makes it the default.
1946 void c_plmkstrm( PLINT *p_strm );
1947 
1948 // Prints out "text" at specified position relative to viewport
1949 void c_plmtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text );
1950 
1951 // Prints out "text" at specified position relative to viewport (3D)
1952 void c_plmtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text );
1953 
1954 // Plots a 3-d representation of the function z[x][y].
1955 void c_plot3d( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side );
1956 
1957 // Plots a 3-d representation of the function z[x][y] with contour.
1958 void c_plot3dc( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1959  PLFLT *clevel, PLINT nlevel );
1960 
1961 // Plots a 3-d representation of the function z[x][y] with contour and
1962 // y index limits.
1963 void c_plot3dcl( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
1964  PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn,
1965  PLINT *indexymin, PLINT *indexymax );
1966 
1967 //
1968 // definitions for the opt argument in plot3dc() and plsurf3d()
1969 //
1970 // DRAW_LINEX *must* be 1 and DRAW_LINEY *must* be 2, because of legacy code!
1971 //
1972 const DRAW_LINEX = 1 << 0; // draw lines parallel to the X axis
1973 const DRAW_LINEY = 1 << 1; // draw lines parallel to the Y axis
1974 const DRAW_LINEXY = DRAW_LINEX | DRAW_LINEY; // draw lines parallel to both the X and Y axis
1975 const MAG_COLOR = 1 << 2; // draw the mesh with a color dependent of the magnitude
1976 const BASE_CONT = 1 << 3; // draw contour plot at bottom xy plane
1977 const TOP_CONT = 1 << 4; // draw contour plot at top xy plane
1978 const SURF_CONT = 1 << 5; // draw contour plot at surface
1979 const DRAW_SIDES = 1 << 6; // draw sides
1980 const FACETED = 1 << 7; // draw outline for each square that makes up the surface
1981 const MESH = 1 << 8; // draw mesh
1982 
1983 //
1984 // valid options for plot3dc():
1985 //
1986 // DRAW_SIDES, BASE_CONT, TOP_CONT (not yet),
1987 // MAG_COLOR, DRAW_LINEX, DRAW_LINEY, DRAW_LINEXY.
1988 //
1989 // valid options for plsurf3d():
1990 //
1991 // MAG_COLOR, BASE_CONT, SURF_CONT, FACETED, DRAW_SIDES.
1992 //
1993 
1994 // Set fill pattern directly.
1995 void c_plpat( PLINT nlin, PLINT *inc, PLINT *del );
1996 
1997 // Draw a line connecting two points, accounting for coordinate transforms
1998 void c_plpath( PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
1999 
2000 // Plots array y against x for n points using ASCII code "code".
2001 void c_plpoin( PLINT n, PLFLT *x, PLFLT *y, PLINT code );
2002 
2003 // Draws a series of points in 3 space.
2004 void c_plpoin3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code );
2005 
2006 // Draws a polygon in 3 space.
2007 void c_plpoly3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc );
2008 
2009 // Plots array y against x for n points using (UTF-8) text string
2010 void c_plstring( PLINT n, PLFLT *x, PLFLT *y, const char *text );
2011 
2012 // Draws a series of points (described by [UTF8] text string) in 3 space.
2013 void c_plstring3( PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, const char * text );
2014 
2015 // Set the floating point precision (in number of places) in numeric labels.
2016 void c_plprec( PLINT setp, PLINT prec );
2017 
2018 // Set fill pattern, using one of the predefined patterns.
2019 void c_plpsty( PLINT patt );
2020 
2021 // Prints out "text" at world cooordinate (x,y).
2022 void c_plptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text );
2023 
2024 // Prints out "text" at world cooordinate (x,y,z).
2025 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 );
2026 
2027 // Random number generator based on Mersenne Twister.
2028 // Obtain real random number in range [0,1].
2029 PLFLT c_plrandd();
2030 
2031 // Replays contents of plot buffer to current device/file.
2032 void c_plreplot();
2033 
2034 // Set line color by red, green, blue from 0. to 1.
2035 
2036 void c_plrgb( PLFLT r, PLFLT g, PLFLT b );
2037 
2038 // Set line color by 8 bit RGB values.
2039 
2040 void c_plrgb1( PLINT r, PLINT g, PLINT b );
2041 
2042 // Functions for converting between HLS and RGB color space
2043 
2044 void c_plrgbhls( PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s );
2045 
2046 // Set character height.
2047 
2048 void c_plschr( PLFLT def, PLFLT scale );
2049 
2050 // Set color map 0 colors by 8 bit RGB values
2051 void c_plscmap0( PLINT *r, PLINT *g, PLINT *b, PLINT ncol0 );
2052 
2053 // Set color map 0 colors by 8 bit RGB values and alpha values
2054 void c_plscmap0a( PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol0 );
2055 
2056 // Set number of colors in cmap 0
2057 void c_plscmap0n( PLINT ncol0 );
2058 
2059 // Set color map 1 colors by 8 bit RGB values
2060 void c_plscmap1( PLINT *r, PLINT *g, PLINT *b, PLINT ncol1 );
2061 
2062 // Set color map 1 colors by 8 bit RGB and alpha values
2063 void c_plscmap1a( PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol1 );
2064 
2065 // Set color map 1 colors using a piece-wise linear relationship between
2066 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
2067 void c_plscmap1l( PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLBOOL *alt_hue_path );
2068 
2069 // Set color map 1 colors using a piece-wise linear relationship between
2070 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
2071 // Will also linear interpolate alpha values.
2072 void c_plscmap1la( PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLFLT *a, PLBOOL *alt_hue_path );
2073 
2074 // Set number of colors in cmap 1
2075 void c_plscmap1n( PLINT ncol1 );
2076 
2077 // Set the color map 1 range used in continuous plots
2078 void c_plscmap1_range( PLFLT min_color, PLFLT max_color );
2079 
2080 // Get the color map 1 range used in continuous plots
2081 void c_plgcmap1_range( PLFLT *min_color, PLFLT *max_color );
2082 
2083 // Set a given color from color map 0 by 8 bit RGB value
2084 void c_plscol0( PLINT icol0, PLINT r, PLINT g, PLINT b );
2085 
2086 // Set a given color from color map 0 by 8 bit RGB value
2087 void c_plscol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a );
2088 
2089 // Set the background color by 8 bit RGB value
2090 void c_plscolbg( PLINT r, PLINT g, PLINT b );
2091 
2092 // Set the background color by 8 bit RGB value and alpha value
2093 void c_plscolbga( PLINT r, PLINT g, PLINT b, PLFLT a );
2094 
2095 // Used to globally turn color output on/off
2096 void c_plscolor( PLINT color );
2097 
2098 // Set the compression level
2099 
2100 void c_plscompression( PLINT compression );
2101 
2102 // Set the device (keyword) name
2103 void c_plsdev( const char *devname );
2104 
2105 // Set window into device space using margin, aspect ratio, and
2106 // justification
2107 
2108 void c_plsdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy );
2109 
2110 // Set up transformation from metafile coordinates.
2111 
2112 void c_plsdimap( PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax, PLFLT dimxpmm, PLFLT dimypmm );
2113 
2114 // Set plot orientation, specifying rotation in units of pi/2.
2115 
2116 void c_plsdiori( PLFLT rot );
2117 
2118 // Set window into plot space
2119 
2121 
2122 // Set window into plot space incrementally (zoom)
2124 
2125 // Set seed for internal random number generator
2126 void c_plseed( uint s );
2127 
2128 // Set the escape character for text strings.
2129 void c_plsesc( char esc );
2130 
2131 // Set family file parameters
2132 
2133 void c_plsfam( PLINT fam, PLINT num, PLINT bmax );
2134 
2135 // Set FCI (font characterization integer)
2136 
2137 void c_plsfci( PLUNICODE fci );
2138 
2139 // Set the output file name.
2140 void c_plsfnam( const char *fnam );
2141 
2142 // Set the current font family, style and weight
2143 
2144 void c_plsfont( PLINT family, PLINT style, PLINT weight );
2145 
2146 // Shade region.
2147 void c_plshade( PLFLT **a, PLINT nx, PLINT ny, PLINT function( PLFLT, PLFLT ) defined, PLFLT left,
2148  PLFLT right, PLFLT bottom, PLFLT top, PLFLT shade_min, PLFLT shade_max, PLINT sh_cmap,
2149  PLFLT sh_color, PLFLT sh_width, PLINT min_color, PLFLT min_width, PLINT max_color,
2150  PLFLT max_width, void function( PLINT, PLFLT *, PLFLT* ) fill, PLBOOL rectangular,
2151  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr, PLPointer pltr_data );
2152 
2153 void c_plshades( PLFLT **a, PLINT nx, PLINT ny, PLINT function( PLFLT, PLFLT ) defined, PLFLT xmin,
2154  PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT *clevel, PLINT nlevel, PLFLT fill_width,
2155  PLINT cont_color, PLFLT cont_width, void function( PLINT, PLFLT *, PLFLT* ) fill,
2156  PLBOOL rectangular, void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ) pltr,
2157  PLPointer pltr_data );
2158 
2159 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 );
2160 
2161 // Set up lengths of major tick marks.
2162 
2163 void c_plsmaj( PLFLT def, PLFLT scale );
2164 
2165 // Set the memory area to be plotted (with the 'mem' driver)
2166 
2167 void c_plsmem( PLINT maxx, PLINT maxy, void *plotmem );
2168 
2169 // Set up lengths of minor tick marks.
2170 
2171 void c_plsmin( PLFLT def, PLFLT scale );
2172 
2173 // Set orientation. Must be done before calling plinit.
2174 
2175 void c_plsori( PLINT ori );
2176 
2177 // Set output device parameters. Usually ignored by the driver.
2178 void c_plspage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng, PLINT xoff, PLINT yoff );
2179 
2180 // Set the colors for color table 0 from a cmap0 file
2181 void c_plspal0( const char* filename );
2182 
2183 // Set the colors for color table 1 from a cmap1 file
2184 void c_plspal1( const char *filename, PLBOOL interpolate );
2185 
2186 // Set the pause (on end-of-page) status
2187 void c_plspause( PLBOOL pause );
2188 
2189 // Set stream number.
2190 
2191 void c_plsstrm( PLINT strm );
2192 
2193 // Set the number of subwindows in x and y
2194 
2195 void c_plssub( PLINT nx, PLINT ny );
2196 
2197 // Set symbol height.
2198 
2199 void c_plssym( PLFLT def, PLFLT scale );
2200 
2201 // Initialize PLplot, passing in the windows/page settings.
2202 void c_plstar( PLINT nx, PLINT ny );
2203 
2204 // Initialize PLplot, passing the device name and windows/page settings.
2205 void c_plstart( const char *devname, PLINT nx, PLINT ny );
2206 
2207 // Set the coordinate transform
2208 void c_plstransform( ct_func coordinate_transform = null, PLPointer coordinate_transform_data = null );
2209 
2210 // Add a point to a stripchart.
2211 void c_plstripa( PLINT id, PLINT pen, PLFLT x, PLFLT y );
2212 
2213 // Create 1d stripchart
2214 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 );
2215 
2216 // Deletes and releases memory used by a stripchart.
2217 void c_plstripd( PLINT id );
2218 
2219 // plots a 2d image (or a matrix too large for plshade() )
2220 void c_plimagefr( PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2221  PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax,
2222  void function( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ), PLPointer pltr_data );
2223 
2224 // plots a 2d image (or a matrix too large for plshade() ) - colors
2225 // automatically scaled
2226 void c_plimage( PLFLT **idata, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2227  PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax );
2228 
2229 // Set up a new line style
2230 void c_plstyl( PLINT nms, PLINT *mark, PLINT *space );
2231 
2232 // Plots the 3d surface representation of the function z[x][y].
2233 void c_plsurf3d( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt,
2234  PLFLT *clevel, PLINT nlevel );
2235 
2236 // Plots the 3d surface representation of the function z[x][y] with y
2237 // index limits.
2238 void c_plsurf3dl( PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel,
2239  PLINT nlevel, PLINT ixstart, PLINT ixn, PLINT *indexymin, PLINT *indexymax );
2240 
2241 // Sets the edges of the viewport to the specified absolute coordinates
2242 void c_plsvpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2243 
2244 // Set x axis labeling parameters
2245 void c_plsxax( PLINT digmax, PLINT digits );
2246 
2247 // Set inferior X window
2248 void plsxwin( PLINT window_id );
2249 
2250 // Set y axis labeling parameters
2251 void c_plsyax( PLINT digmax, PLINT digits );
2252 
2253 // Plots array y against x for n points using Hershey symbol "code"
2254 void c_plsym( PLINT n, PLFLT *x, PLFLT *y, PLINT code );
2255 
2256 // Set z axis labeling parameters
2257 
2258 void c_plszax( PLINT digmax, PLINT digits );
2259 
2260 // Switches to text screen.
2261 
2262 void c_pltext();
2263 
2264 // Set the format for date / time labels
2265 void c_pltimefmt( const char *fmt );
2266 
2267 // Sets the edges of the viewport with the given aspect ratio, leaving
2268 // room for labels.
2269 
2270 void c_plvasp( PLFLT aspect );
2271 
2272 // Creates the largest viewport of the specified aspect ratio that fits
2273 // within the specified normalized subpage coordinates.
2274 
2275 void c_plvpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect );
2276 
2277 // Creates a viewport with the specified normalized subpage coordinates.
2278 
2279 void c_plvpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2280 
2281 // Defines a "standard" viewport with seven character heights for
2282 // the left margin and four character heights everywhere else.
2283 
2284 void c_plvsta();
2285 
2286 // Set up a window for three-dimensional plotting.
2287 
2288 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 );
2289 
2290 // Set pen width.
2291 
2292 void c_plwidth( PLFLT width );
2293 
2294 // Set up world coordinates of the viewport boundaries (2d plots).
2295 
2296 void c_plwind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
2297 
2298 // set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
2299 
2300 void c_plxormod( PLBOOL mode, PLBOOL *status );
2301 
2302 //--------------------------------------------------------------------------* * Functions for use from C or C++ only
2303 //--------------------------------------------------------------------------
2304 
2305 // Returns a list of file-oriented device names and their menu strings
2306 
2307 void plgFileDevs( char ***p_menustr, char ***p_devname, int *p_ndev );
2308 
2309 // Returns a list of all device names and their menu strings
2310 
2311 void plgDevs( char ***p_menustr, char ***p_devname, int *p_ndev );
2312 
2313 // Set the function pointer for the keyboard event handler
2314 
2315 void plsKeyEH( void function( PLGraphicsIn *, void *, int * ) KeyEH, void *KeyEH_data );
2316 
2317 // Set the function pointer for the (mouse) button event handler
2318 
2319 void plsButtonEH( void function( PLGraphicsIn *, void *, int * ) ButtonEH, void *ButtonEH_data );
2320 
2321 // Sets an optional user bop handler
2322 
2323 void plsbopH( void function( void *, int * ) handler, void *handler_data );
2324 
2325 // Sets an optional user eop handler
2326 
2327 void plseopH( void function( void *, int * ) handler, void *handler_data );
2328 
2329 // Set the variables to be used for storing error info
2330 
2331 void plsError( PLINT *errcode, const char *errmsg );
2332 
2333 // Sets an optional user exit handler.
2334 
2335 void plsexit( int function( const char * ) handler );
2336 
2337 // Sets an optional user abort handler.
2338 
2339 void plsabort( void function( const char * ) handler );
2340 
2341 // Transformation routines
2342 
2343 // Identity transformation.
2344 void pltr0( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2345 
2346 // Does linear interpolation from singly dimensioned coord arrays.
2347 void pltr1( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2348 
2349 // Does linear interpolation from doubly dimensioned coord arrays
2350 // (column dominant, as per normal C 2d arrays).
2351 void pltr2( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2352 
2353 // Just like pltr2() but uses pointer arithmetic to get coordinates from
2354 // 2d grid tables.
2355 void pltr2p( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, PLPointer pltr_data );
2356 
2357 // Identity transformation for plots from Fortran.
2358 void pltr0f( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, void* pltr_data );
2359 
2360 // Does linear interpolation from doubly dimensioned coord arrays
2361 // (row dominant, i.e. Fortran ordering).
2362 void pltr2f( PLFLT x, PLFLT y, PLFLT* tx, PLFLT* ty, void* pltr_data );
2363 
2364 // Function evaluators
2365 
2366 // Does a lookup from a 2d function array. Array is of type (PLFLT **),
2367 // and is column dominant (normal C ordering).
2368 
2369 PLFLT plf2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2370 
2371 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
2372 // and is column dominant (normal C ordering).
2373 
2374 PLFLT plf2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2375 
2376 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
2377 // and is row dominant (Fortran ordering).
2378 
2379 PLFLT plf2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data );
2380 
2381 // Command line parsing utilities
2382 // Clear internal option table info structure.
2383 void plClearOpts();
2384 
2385 // Reset internal option table info structure.
2386 void plResetOpts();
2387 
2388 // Merge user option table into internal info structure.
2389 
2390 PLINT plMergeOpts( PLOptionTable *options, const char *name, const char **notes );
2391 
2392 // Set the strings used in usage and syntax messages.
2393 
2394 void plSetUsage( const char *program_string, const char *usage_string );
2395 
2396 // Process input strings, treating them as an option and argument pair.
2397 PLINT c_plsetopt( const char *opt, const char *optarg );
2398 
2399 // Process options list using current options info.
2400 PLINT c_plparseopts( int *p_argc, char **argv, PLINT mode );
2401 
2402 // Print usage & syntax message.
2403 
2404 void plOptUsage();
2405 
2406 // Miscellaneous
2407 
2408 // Get the escape character for text strings.
2409 
2410 void plgesc( char *p_esc );
2411 
2412 // Front-end to driver escape function.
2413 
2414 void pl_cmd( PLINT op, void *ptr );
2415 
2416 // Return full pathname for given file if executable
2417 
2418 PLINT plFindName( char *p );
2419 
2420 // Looks for the specified executable file according to usual search path.
2421 
2422 char * plFindCommand( const char *fn );
2423 
2424 // Gets search name for file by concatenating the dir, subdir, and file
2425 // name, allocating memory as needed.
2426 
2427 void plGetName( const char *dir, const char *subdir, const char *filename, char **filespec );
2428 
2429 // Prompts human to input an integer in response to given message.
2430 
2431 PLINT plGetInt( const char *s );
2432 
2433 // Prompts human to input a float in response to given message.
2434 
2435 PLFLT plGetFlt( const char *s );
2436 
2437 // Nice way to allocate space for a vectored 2d grid
2438 
2439 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
2440 
2441 void plAlloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny );
2442 
2443 // Frees a block of memory allocated with plAlloc2dGrid().
2444 
2445 void plFree2dGrid( PLFLT **f, PLINT nx, PLINT ny );
2446 
2447 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
2448 void plMinMax2dGrid( PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin );
2449 
2450 // Wait for graphics input event and translate to world coordinates
2451 
2453 
2454 // Translates relative device coordinates to world coordinates.
2455 
2457 
PLFLT wxmi
Definition: plplot.d:1192
void c_plaxes(PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
Definition: plbox.c:135
void c_plgfam(PLINT *p_fam, PLINT *p_num, PLINT *p_bmax)
Definition: plcore.c:3974
#define PLESC_REDRAW
Definition: plplot.h:215
alias _N11 PLBufferingCB
Definition: plplot.d:1322
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
PLINT nz
Definition: plplot.d:1264
alias c_plgdidev plgdidev
Definition: plplot.d:1420
#define PL_FCI_BOLD
Definition: plplot.h:330
alias c_plgpage plgpage
Definition: plplot.d:1428
#define PL_BIN_NOEXPAND
Definition: plplot.h:880
PLFLT * yg
Definition: plplot.d:1260
void c_pl_setcontlabelformat(PLINT lexp, PLINT sigdig)
Definition: plcont.c:260
#define PL_OPT_FUNC
Definition: plplot.h:288
static const char * name
Definition: tkMain.c:135
void c_plptex3(PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz, PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text)
Definition: plsym.c:1964
static char ** argv
Definition: qt.cpp:40
void c_plscmap1l(PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLBOOL *alt_hue_path)
void c_plgcolbga(PLINT *r, PLINT *g, PLINT *b, PLFLT *a)
Definition: plctrl.c:265
alias PLINT PLBOOL
Definition: plplot.d:1032
#define PL_PARSE_NOPROGRAM
Definition: plplot.h:304
#define PLESC_XORMOD
Definition: plplot.h:225
void * var
Definition: plplot.d:1154
void c_plgchr(PLFLT *p_def, PLFLT *p_ht)
Definition: plcore.c:4067
PLFLT ** xg
Definition: plplot.d:1276
PLFLT * zg
Definition: plplot.d:1261
#define PLESC_DEVINIT
Definition: plplot.h:235
alias c_plgvpd plgvpd
Definition: plplot.d:1435
void c_plsfci(PLUNICODE fci)
Definition: plcore.c:3905
void c_plpsty(PLINT patt)
Definition: plsdef.c:327
void plOptUsage()
Definition: plargs.c:1304
void c_plssym(PLFLT def, PLFLT scale)
Definition: plsdef.c:250
void c_plmkstrm(PLINT *p_strm)
Definition: plcore.c:2650
void c_plseed(uint s)
#define PLESC_DOUBLEBUFFERING_ENABLE
Definition: plplot.h:510
alias c_plseed plseed
Definition: plplot.d:1500
void pldid2pc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1667
#define PLESC_DOUBLEBUFFERING_QUERY
Definition: plplot.h:512
#define TOP_CONT
Definition: plplot.h:1467
void c_plsmin(PLFLT def, PLFLT scale)
Definition: plsdef.c:220
#define PL_LEGEND_LINE
Definition: plplot.h:1250
void c_plstripd(PLINT id)
Definition: plstripc.c:327
void c_plscol0a(PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plctrl.c:318
int type
Definition: plplot.d:1167
alias c_plgdiplt plgdiplt
Definition: plplot.d:1422
void c_plgver(char *p_ver)
Definition: plcore.c:3949
alias c_plwidth plwidth
Definition: plplot.d:1545
void plmapline(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
Definition: plmap.c:628
#define PL_COLORBAR_LABEL_TOP
Definition: plplot.h:1260
PLINT nx
Definition: plplot.d:1241
string syntax
Definition: plplot.d:1156
#define PL_FCI_UPRIGHT
Definition: plplot.h:325
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)
#define plmtex3
Definition: plplot.h:709
static PLFLT ** xg
#define plerry
Definition: plplot.h:648
void c_plend()
Definition: plcore.c:2463
PLINT result
Definition: plplot.d:1320
#define PL_PARSE_QUIET
Definition: plplot.h:299
#define PL_PARSE_NODASH
Definition: plplot.h:305
#define plsdev
Definition: plplot.h:746
void c_plgdidev(PLFLT *p_mar, PLFLT *p_aspect, PLFLT *p_jx, PLFLT *p_jy)
Definition: plcore.c:1983
void c_plsstrm(PLINT strm)
Definition: plcore.c:2600
#define PL_FCI_MEDIUM
Definition: plplot.h:329
#define plgdev
Definition: plplot.h:661
alias c_plclear plclear
Definition: plplot.d:1392
void c_plcol0(PLINT icol0)
Definition: plctrl.c:141
PLFLT wyma
Definition: plplot.d:1195
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)
#define PL_OPT_DISABLED
Definition: plplot.h:284
void c_plscmap1la(PLBOOL itype, PLINT npts, PLFLT *intensity, PLFLT *coord1, PLFLT *coord2, PLFLT *coord3, PLFLT *a, PLBOOL *alt_hue_path)
PLFLT dymi
Definition: plplot.d:1190
int min(int a, int b)
void c_plspause(PLBOOL pause)
Definition: plcore.c:3831
void c_plot3dc(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
#define SURF_CONT
Definition: plplot.h:1468
#define PLESC_FILL
Definition: plplot.h:218
alias c_pltext pltext
Definition: plplot.d:1537
void c_plenv(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plvpor.c:89
#define pllegend
Definition: plplot.h:693
alias c_plreplot plreplot
Definition: plplot.d:1474
alias c_plsxax plsxax
Definition: plplot.d:1533
alias plgvpd plP_gvpd
Definition: plplot.d:1561
#define PLESC_DOUBLEBUFFERING
Definition: plplot.h:224
void mapform(PLINT n, PLFLT *x, PLFLT *y)
Definition: tclAPI.c:3640
void c_plline3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
#define MAG_COLOR
Definition: plplot.h:1465
PLFLT dY
Definition: plplot.d:1176
void c_plhlsrgb(PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b)
Definition: plctrl.c:1251
static PLcGrid2 * cgrid
#define plshade
Definition: plplot.h:759
PLUINT PLUNICODE
Definition: plplot.h:194
void c_plscompression(PLINT compression)
Definition: plcore.c:4249
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)
#define PL_FCI_SYMBOL
Definition: plplot.h:323
#define PL_FCI_SERIF
Definition: plplot.h:320
#define plot3dc
Definition: plplot.h:711
#define plot3dcl
Definition: plplot.h:712
void c_plgcmap1_range(PLFLT *min_color, PLFLT *max_color)
Definition: plctrl.c:914
alias plMinMax2dGrid MinMax2dGrid
Definition: plplot.d:1560
PLDLLIMPEXP void c_plmapline(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
alias c_plarc plarc
Definition: plplot.d:1391
void c_plstring(PLINT n, PLFLT *x, PLFLT *y, const char *text)
void pltr2f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
Definition: plcont.c:1306
void plseopH(void function(void *, int *) handler, void *handler_data)
alias c_plwind plwind
Definition: plplot.d:1546
#define plfill
Definition: plplot.h:650
static int argc
Definition: qt.cpp:39
void c_plschr(PLFLT def, PLFLT scale)
Definition: plsdef.c:202
alias c_plbop plbop
Definition: plplot.d:1385
#define plsurf3dl
Definition: plplot.h:786
void c_plszax(PLINT digmax, PLINT digits)
Definition: plcore.c:4058
void(* pltr_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
#define PL_POSITION_BOTTOM
Definition: plplot.h:1241
void c_plot3d(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLBOOL side)
alias c_plsdiori plsdiori
Definition: plplot.d:1497
PLINT cmd
Definition: plplot.d:1319
#define PL_LEGEND_BACKGROUND
Definition: plplot.h:1253
char * plFindCommand(const char *fn)
Definition: plctrl.c:2136
void c_plgcompression(PLINT *compression)
Definition: plcore.c:4264
alias c_plscmap1n plscmap1n
Definition: plplot.d:1486
void plFree2dGrid(PLFLT **f, PLINT nx, PLINT ny)
void c_plsmaj(PLFLT def, PLFLT scale)
Definition: plsdef.c:235
void c_plmeshc(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
alias pleop plclr
Definition: plplot.d:1554
void c_plwidth(PLFLT width)
Definition: plcore.c:3756
alias c_plcpstrm plcpstrm
Definition: plplot.d:1398
void c_plscmap1n(PLINT ncol1)
Definition: plctrl.c:1057
void c_plgradient(PLINT n, PLFLT *x, PLFLT *y, PLFLT angle)
void c_plend1()
Definition: plcore.c:2521
#define plstyl
Definition: plplot.h:784
#define PL_MAXKEY
Definition: plplot.h:357
#define PL_FCI_OBLIQUE
Definition: plplot.h:327
alias c_plgfci plgfci
Definition: plplot.d:1424
#define plpoly3
Definition: plplot.h:717
#define plimage
Definition: plplot.h:688
#define PL_COLORBAR_ORIENT_TOP
Definition: plplot.h:1270
#define PL_LEGEND_SYMBOL
Definition: plplot.h:1251
void c_plspal0(const char *filename)
Definition: plctrl.c:1548
alias c_plhlsrgb plhlsrgb
Definition: plplot.d:1442
void c_plarc(PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2, PLFLT rotate, PLBOOL fill)
Definition: plarc.c:141
#define PL_COLORBAR_BACKGROUND
Definition: plplot.h:1273
alias c_pl_setcontlabelformat pl_setcontlabelformat
Definition: plplot.d:1380
#define PL_FCI_HEXPOWER_MASK
Definition: plplot.h:312
alias c_plfontld plfontld
Definition: plplot.d:1412
#define PLESC_TEXT
Definition: plplot.h:216
#define PL_POSITION_LEFT
Definition: plplot.h:1238
#define plbin
Definition: plplot.h:628
#define PL_PARSE_NODELETE
Definition: plplot.h:300
void c_plrgb1(PLINT r, PLINT g, PLINT b)
void c_plstransform(ct_func coordinate_transform=null, PLPointer coordinate_transform_data=null)
alias c_plsyax plsyax
Definition: plplot.d:1534
#define PL_FCI_IMPOSSIBLE
Definition: plplot.h:310
PLDLLIMPEXP void c_plmapfill(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
alias _N1 PLOptionTable
Definition: plplot.d:1159
void c_plscmap0a(PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol0)
void plSetUsage(const char *program_string, const char *usage_string)
Definition: plargs.c:1287
PLFLT dxmi
Definition: plplot.d:1188
void c_plpath(PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plline.c:94
alias c_plgxax plgxax
Definition: plplot.d:1437
alias c_plfamadv plfamadv
Definition: plplot.d:1407
#define plparseopts
Definition: plplot.h:713
void c_plbop()
Definition: plpage.c:118
#define plsym
Definition: plplot.h:791
#define plscmap1
Definition: plplot.h:733
void c_plscol0(PLINT icol0, PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:282
void plsbopH(void function(void *, int *) handler, void *handler_data)
#define PL_BIN_CENTRED
Definition: plplot.h:879
alias c_plstar plstar
Definition: plplot.d:1520
alias c_plstripa plstripa
Definition: plplot.d:1523
tuple xmin
Definition: Plframe.py:907
#define PL_BIN_DEFAULT
Definition: plplot.h:878
void pltr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:886
void c_plscmap0(PLINT *r, PLINT *g, PLINT *b, PLINT ncol0)
#define pltimefmt
Definition: plplot.h:794
#define PL_OPT_FLOAT
Definition: plplot.h:291
alias c_plmkstrm plmkstrm
Definition: plplot.d:1458
void c_plvsta()
Definition: plvpor.c:307
void plmapstring(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, const char *string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
Definition: plmap.c:650
alias void * PLPointer
Definition: plplot.d:1035
PLFLT ** f
Definition: plplot.d:1240
PLFLT * xg
Definition: plplot.d:1259
void c_plfont(PLINT ifont)
Definition: plsym.c:1323
alias c_plvpor plvpor
Definition: plplot.d:1542
void plsabort(void function(const char *) handler)
#define plsvect
Definition: plplot.h:787
#define plscmap1a
Definition: plplot.h:734
void plGetName(const char *dir, const char *subdir, const char *filename, char **filespec)
Definition: plctrl.c:2443
void c_plline(PLINT n, PLFLT *x, PLFLT *y)
uint keysym
Definition: plplot.d:1169
#define GRID_DTLI
Definition: plplot.h:1157
#define PL_FCI_ITALIC
Definition: plplot.h:326
void * PLPointer
Definition: plplot.h:200
#define plspal1
Definition: plplot.h:771
PLFLT a
Definition: plplot.d:1296
#define plsetopt
Definition: plplot.h:754
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)
#define plmeshc
Definition: plplot.h:706
alias uint PLUNICODE
Definition: plplot.d:1028
alias c_plsdidev plsdidev
Definition: plplot.d:1495
alias c_plcalc_world plcalc_world
Definition: plplot.d:1390
void c_plflush()
Definition: plcore.c:2206
#define PL_COLORBAR_SHADE
Definition: plplot.h:1263
PLINT plGetCursor(PLGraphicsIn *gin)
Definition: plpage.c:244
void c_plprec(PLINT setp, PLINT prec)
Definition: plcore.c:3839
#define PLESC_DI
Definition: plplot.h:219
void c_plbox(const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
Definition: plbox.c:89
#define PL_HIST_NOSCALING
Definition: plplot.h:1208
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)
void plResetOpts()
Definition: plargs.c:855
void c_plsdiori(PLFLT rot)
Definition: plcore.c:1998
tuple ymin
Definition: Plframe.py:908
#define plaxes
Definition: plplot.h:627
PLINT c_plsetopt(const char *opt, const char *optarg)
Definition: plargs.c:761
void c_plpoin3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLINT code)
alias c_plgdiori plgdiori
Definition: plplot.d:1421
void plsKeyEH(void function(PLGraphicsIn *, void *, int *) KeyEH, void *KeyEH_data)
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)
#define plscmap0a
Definition: plplot.h:731
alias _N3 PLWindow
Definition: plplot.d:1197
alias c_plrgbhls plrgbhls
Definition: plplot.d:1477
static PLFLT ** yg
void plsError(PLINT *errcode, const char *errmsg)
#define PL_LEGEND_BOUNDING_BOX
Definition: plplot.h:1254
void plsButtonEH(void function(PLGraphicsIn *, void *, int *) ButtonEH, void *ButtonEH_data)
void(* ct_func)(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
alias c_plmeridians plmeridians
Definition: plplot.d:1455
void c_plmtex3(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
Definition: plsym.c:1592
#define MESH
Definition: plplot.h:1471
#define PL_LEGEND_NONE
Definition: plplot.h:1248
PLFLT ** yg
Definition: plplot.d:1277
alias c_plstripd plstripd
Definition: plplot.d:1525
#define GRID_NNIDW
Definition: plplot.h:1159
void plsexit(int function(const char *) handler)
PLDLLIMPEXP void c_plmeridians(void(*mapform)(PLINT, PLFLT *, PLFLT *), PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
void c_plsfnam(const char *fnam)
Definition: plcore.c:3809
int PLINT
Definition: plplot.h:174
void plMinMax2dGrid(PLFLT **f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin)
#define BASE_CONT
Definition: plplot.h:1466
#define PL_HIST_NOEMPTY
Definition: plplot.h:1211
#define plshades
Definition: plplot.h:761
void c_plfamadv()
Definition: plcore.c:4000
alias c_plsdiplt plsdiplt
Definition: plplot.d:1498
PLINT PLBOOL
Definition: plplot.h:197
#define PL_POSITION_OUTSIDE
Definition: plplot.h:1243
void plmapfill(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
Definition: plmap.c:695
#define PL_OPT_ENABLED
Definition: plplot.h:280
#define PL_POSITION_RIGHT
Definition: plplot.h:1239
void c_plgzax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4049
void c_plsurf3d(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt, PLFLT *clevel, PLINT nlevel)
uint height
Definition: plplot.d:1207
void c_plgdev(char *p_dev)
Definition: plcore.c:3637
PLFLT wX
Definition: plplot.d:1177
void c_plgvpw(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax)
Definition: plcore.c:4087
void c_plsvpa(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plvpor.c:508
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)
alias c_plschr plschr
Definition: plplot.d:1478
#define PL_COLORBAR_LABEL_LEFT
Definition: plplot.h:1258
void c_pladv(PLINT page)
Definition: plpage.c:34
#define PL_LEGEND_ROW_MAJOR
Definition: plplot.h:1255
PLDLLIMPEXP void c_plmapstring(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, const char *string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
alias c_plsmaj plsmaj
Definition: plplot.d:1509
void pldip2dc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1713
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)
void c_plgfnam(char *fnam)
Definition: plcore.c:3790
void c_plgxax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4013
#define FACETED
Definition: plplot.h:1470
void c_plscolbg(PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:215
alias c_plvpas plvpas
Definition: plplot.d:1541
void c_plstar(PLINT nx, PLINT ny)
Definition: plcore.c:2262
void c_plptex(PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text)
Definition: plsym.c:716
alias c_plspage plspage
Definition: plplot.d:1513
alias c_plgfam plgfam
Definition: plplot.d:1423
void c_plscmap1_range(PLFLT min_color, PLFLT max_color)
Definition: plctrl.c:885
void c_plfill3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z)
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
void c_plbin(PLINT nbin, PLFLT *x, PLFLT *y, PLINT opt)
#define PL_NOTSET
Definition: plplot.h:417
void c_plmtex(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
Definition: plsym.c:576
PLINT subwindow
Definition: plplot.d:1171
alias c_plgyax plgyax
Definition: plplot.d:1438
#define PL_PARSE_PARTIAL
Definition: plplot.h:297
alias plbop plpage
Definition: plplot.d:1555
#define PL_COLORBAR_SHADE_LABEL
Definition: plplot.h:1268
#define PL_FCI_MONO
Definition: plplot.h:321
void c_plsxax(PLINT digmax, PLINT digits)
Definition: plcore.c:4022
PLINT nx
Definition: plplot.d:1227
#define plimagefr
Definition: plplot.h:689
void c_plhist(PLINT n, PLFLT *data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT opt)
void c_plsdiplz(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plcore.c:1782
alias c_plscmap1_range plscmap1_range
Definition: plplot.d:1487
#define PL_COLORBAR_ORIENT_BOTTOM
Definition: plplot.h:1272
PLINT nx
Definition: plplot.d:1279
alias c_plssym plssym
Definition: plplot.d:1519
#define plsfnam
Definition: plplot.h:757
#define plhist
Definition: plplot.h:683
#define PL_POSITION_VIEWPORT
Definition: plplot.h:1244
void c_plbtime(PLINT *year, PLINT *month, PLINT *day, PLINT *hour, PLINT *min, PLFLT *sec, PLFLT ctime)
Definition: pltime.c:26
alias c_plsvpa plsvpa
Definition: plplot.d:1532
#define PL_COLORBAR_GRADIENT
Definition: plplot.h:1264
alias _N7 c_PLcGrid
Definition: plplot.d:1266
alias c_plgstrm plgstrm
Definition: plplot.d:1433
alias c_plgfont plgfont
Definition: plplot.d:1426
PLINT plTranslateCursor(PLGraphicsIn *gin)
Definition: plpage.c:259
#define PL_OPT_NODELETE
Definition: plplot.h:282
void c_plstripa(PLINT id, PLINT pen, PLFLT x, PLFLT y)
Definition: plstripc.c:221
void c_plsori(PLINT ori)
Definition: plcore.c:3744
void c_plcpstrm(PLINT iplsr, PLBOOL flags)
Definition: plcore.c:2740
#define plspal0
Definition: plplot.h:770
alias c_plscompression plscompression
Definition: plplot.d:1493
#define plfill3
Definition: plplot.h:651
#define GRID_NNI
Definition: plplot.h:1158
#define PLESC_GRAPH
Definition: plplot.h:217
void c_plcol1(PLFLT col1)
Definition: plctrl.c:175
alias c_pljoin pljoin
Definition: plplot.d:1446
alias c_plspause plspause
Definition: plplot.d:1516
#define PLESC_SET_COMPRESSION
Definition: plplot.h:226
void c_plmesh(PLFLT *x, PLFLT *y, PLFLT **z, PLINT nx, PLINT ny, PLINT opt)
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)
void(* mapform_func)(PLINT, PLFLT *, PLFLT *)
#define PL_MAXWINDOWS
Definition: plplot.h:397
#define PLESC_SET_RGB
Definition: plplot.h:210
ubyte b
Definition: plplot.d:1295
#define PLESC_RESIZE
Definition: plplot.h:214
void c_plsyax(PLINT digmax, PLINT digits)
Definition: plcore.c:4040
uint y
Definition: plplot.d:1205
PLFLT wymi
Definition: plplot.d:1194
void c_plgspa(PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax)
Definition: plpage.c:222
#define PL_POSITION_SUBPAGE
Definition: plplot.h:1245
#define PL_HIST_NOEXPAND
Definition: plplot.h:1210
PLFLT p
Definition: plplot.d:1308
alias c_plslabelfunc plslabelfunc
Definition: plplot.d:1389
#define plstring
Definition: plplot.h:779
#define plvect
Definition: plplot.h:796
alias c_plenv plenv
Definition: plplot.d:1402
alias c_plconfigtime plconfigtime
Definition: plplot.d:1396
void c_plrgbhls(PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s)
Definition: plctrl.c:1284
#define PL_COLORBAR_CAP_NONE
Definition: plplot.h:1265
#define PL_FCI_STYLE
Definition: plplot.h:316
void c_plcalc_world(PLFLT rx, PLFLT ry, PLFLT *wx, PLFLT *wy, PLINT *window)
Definition: plpage.c:289
void(* fill_func)(PLINT, const PLFLT *, const PLFLT *)
void plClearOpts()
Definition: plargs.c:842
#define plscmap1la
Definition: plplot.h:736
#define PL_FCI_SCRIPT
Definition: plplot.h:322
#define plgfnam
Definition: plplot.h:668
void c_plstyl(PLINT nms, PLINT *mark, PLINT *space)
void c_plssub(PLINT nx, PLINT ny)
Definition: plcore.c:3596
void c_plsdev(const char *devname)
Definition: plcore.c:3619
#define plcont
Definition: plplot.h:639
#define plstart
Definition: plplot.h:777
void c_plvpas(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect)
Definition: plvpor.c:386
alias c_plsmem plsmem
Definition: plplot.d:1510
#define PLESC_EH
Definition: plplot.h:221
alias c_plhls plhls
Definition: plplot.d:1441
#define plmesh
Definition: plplot.h:705
void c_plvpor(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plvpor.c:342
alias c_plglevel plglevel
Definition: plplot.d:1427
#define PL_Y_AXIS
Definition: plplot.h:273
void plmap(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:599
#define PLESC_CLEAR
Definition: plplot.h:227
Definition: plplot.d:2
void c_plclear()
Definition: plpage.c:71
alias c_plscolor plscolor
Definition: plplot.d:1492
alias c_plinit plinit
Definition: plplot.d:1445
alias c_plcol1 plcol1
Definition: plplot.d:1394
#define PLESC_ALLOC_NCOL
Definition: plplot.h:211
#define pllab
Definition: plplot.h:692
alias c_plgchr plgchr
Definition: plplot.d:1413
PLFLT wY
Definition: plplot.d:1178
alias c_plsdiplz plsdiplz
Definition: plplot.d:1499
void c_plsdidev(PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy)
Definition: plcore.c:1868
void plgFileDevs(char ***p_menustr, char ***p_devname, int *p_ndev)
void pltr2p(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:1125
void pltr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:953
#define PL_COLORBAR_ORIENT_LEFT
Definition: plplot.h:1271
#define PL_HIST_IGNORE_OUTLIERS
Definition: plplot.h:1209
#define plbox
Definition: plplot.h:630
void c_plgcolbg(PLINT *r, PLINT *g, PLINT *b)
Definition: plctrl.c:249
void c_pl_setcontlabelparam(PLFLT offset, PLFLT size, PLFLT spacing, PLINT active)
Definition: plcont.c:251
PLFLT[][] yg
Definition: plplot.d:32
int alt_hue_path
Definition: plplot.d:1310
#define PL_OPT_INVISIBLE
Definition: plplot.h:283
#define PL_OPT_BOOL
Definition: plplot.h:289
#define DRAW_SIDES
Definition: plplot.h:1469
void c_pljoin(PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plline.c:62
alias c_plpsty plpsty
Definition: plplot.d:1470
#define PL_Z_AXIS
Definition: plplot.h:274
void c_plgvpd(PLFLT *p_xmin, PLFLT *p_xmax, PLFLT *p_ymin, PLFLT *p_ymax)
Definition: plcore.c:4076
alias _N8 c_PLcGrid2
Definition: plplot.d:1282
#define plgver
Definition: plplot.h:677
PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:470
void c_plsfam(PLINT fam, PLINT num, PLINT bmax)
Definition: plcore.c:3984
PLFLT[] xg
Definition: plplot.d:25
#define PLSWIN_WORLD
Definition: plplot.h:269
#define plptex3
Definition: plplot.h:721
void plsxwin(PLINT window_id)
Definition: plcore.c:3957
alias c_plscolbga plscolbga
Definition: plplot.d:1491
void c_plglevel(PLINT *p_level)
Definition: plcore.c:3686
#define DRAW_LINEXY
Definition: plplot.h:1464
alias _N10 PLControlPt
Definition: plplot.d:1312
#define PL_POSITION_INSIDE
Definition: plplot.h:1242
PLFLT s
Definition: plplot.d:1307
alias c_plscolbg plscolbg
Definition: plplot.d:1490
tuple xmax
Definition: Plframe.py:909
void c_plsdimap(PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax, PLFLT dimxpmm, PLFLT dimypmm)
Definition: plcore.c:2136
#define plline3
Definition: plplot.h:697
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)
PLFLT h
Definition: plplot.d:1305
#define plstripc
Definition: plplot.h:782
#define ZEROW2D
Definition: plplot.h:262
void c_plctime(PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT *ctime)
Definition: pltime.c:54
PLFLT dyma
Definition: plplot.d:1191
#define plstring3
Definition: plplot.h:780
alias plgvpw plP_gvpw
Definition: plplot.d:1562
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)
int mode
Definition: plplot.d:1155
void c_plrgb(PLFLT r, PLFLT g, PLFLT b)
void c_plstart(const char *devname, PLINT nx, PLINT ny)
Definition: plcore.c:2281
PLFLT[][] zg
Definition: plplot.d:33
void c_plgfont(PLINT *p_family, PLINT *p_style, PLINT *p_weight)
Definition: plsym.c:2120
#define PL_X_AXIS
Definition: plplot.h:272
alias c_plxormod plxormod
Definition: plplot.d:1548
void c_plsfont(PLINT family, PLINT style, PLINT weight)
Definition: plsym.c:2076
void c_plsdiplt(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plcore.c:1758
uint state
Definition: plplot.d:1168
void c_plfontld(PLINT fnt)
Definition: plcore.c:3467
void c_plpoin(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
PLFLT plGetFlt(const char *s)
Definition: plctrl.c:2935
PLINT ny
Definition: plplot.d:1280
#define PLSWIN_DEVICE
Definition: plplot.h:268
alias c_plflush plflush
Definition: plplot.d:1410
#define PL_OPT_INT
Definition: plplot.h:290
alias c_plsori plsori
Definition: plplot.d:1512
static PLOptionTable options[]
Definition: tclMain.c:108
#define plgvpd
Definition: plplot.h:678
#define plpoin
Definition: plplot.h:715
#define plgriddata
Definition: plplot.h:674
#define plgvpw
Definition: plplot.h:679
void c_pllightsource(PLFLT x, PLFLT y, PLFLT z)
Definition: plot3d.c:99
alias c_plrgb1 plrgb1
Definition: plplot.d:1476
#define PL_OPT_STRING
Definition: plplot.h:292
PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:451
void c_pltext()
Switches to text screen.
Definition: plctrl.c:2090
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)
PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:432
#define PL_OPT_ARG
Definition: plplot.h:281
alias c_plsmin plsmin
Definition: plplot.d:1511
#define PL_COLORBAR_CAP_HIGH
Definition: plplot.h:1267
PLFLT[][] xg
Definition: plplot.d:31
uint button
Definition: plplot.d:1170
#define DRAW_LINEX
Definition: plplot.h:1462
alias c_plscol0a plscol0a
Definition: plplot.d:1489
alias c_plbtime plbtime
Definition: plplot.d:1388
void c_plxormod(PLBOOL mode, PLBOOL *status)
Definition: plctrl.c:2008
#define PLESC_SWIN
Definition: plplot.h:223
#define PLESC_SET_LPB
Definition: plplot.h:212
void c_pltimefmt(const char *fmt)
Definition: pltime.c:66
alias c_plw3d plw3d
Definition: plplot.d:1544
void c_plhls(PLFLT h, PLFLT l, PLFLT s)
void c_plsym(PLINT n, PLFLT *x, PLFLT *y, PLINT code)
PLINT nz
Definition: plplot.d:1229
alias _N5 PLfGrid
Definition: plplot.d:1231
#define PL_COLORBAR_ORIENT_RIGHT
Definition: plplot.h:1269
#define ONEW2D
Definition: plplot.h:264
void c_plsmem(PLINT maxx, PLINT maxy, void *plotmem)
Definition: plcore.c:3652
#define PL_HIST_DEFAULT
Definition: plplot.h:1207
PLINT plMergeOpts(PLOptionTable *options, const char *name, const char **notes)
Definition: plargs.c:795
float PLFLT
Definition: plplot.h:157
alias c_plpath plpath
Definition: plplot.d:1451
#define PL_PARSE_FULL
Definition: plplot.h:298
void c_plscmap1(PLINT *r, PLINT *g, PLINT *b, PLINT ncol1)
string opt
Definition: plplot.d:1151
alias c_plgzax plgzax
Definition: plplot.d:1439
void c_plgdiori(PLFLT *p_rot)
Definition: plcore.c:2121
#define PL_FCI_FAMILY
Definition: plplot.h:315
#define plerrx
Definition: plplot.h:647
#define PL_LEGEND_TEXT_LEFT
Definition: plplot.h:1252
PLINT ny
Definition: plplot.d:1228
#define PLESC_DOUBLEBUFFERING_DISABLE
Definition: plplot.h:511
void pltr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
alias _N2 PLGraphicsIn
Definition: plplot.d:1180
alias _N4 PLDisplay
Definition: plplot.d:1209
void c_plscmap1a(PLINT *r, PLINT *g, PLINT *b, PLFLT *a, PLINT ncol1)
alias c_plfont plfont
Definition: plplot.d:1411
alias c_plvasp plvasp
Definition: plplot.d:1539
void c_plspage(PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng, PLINT xoff, PLINT yoff)
Definition: plcore.c:3572
PLFLT c_plrandd()
Definition: plctrl.c:3071
alias c_plsfam plsfam
Definition: plplot.d:1503
#define PL_PARSE_SKIP
Definition: plplot.h:306
alias plAlloc2dGrid Alloc2dGrid
Definition: plplot.d:1558
#define PL_COLORBAR_CAP_LOW
Definition: plplot.h:1266
alias c_plrandd plrandd
Definition: plplot.d:1473
void c_plslabelfunc(void function(PLINT, PLFLT, char *, PLINT, PLPointer) labelfunc, PLPointer label_data)
PLFLT wxma
Definition: plplot.d:1193
#define PL_FCI_WEIGHT
Definition: plplot.h:317
PLINT nx
Definition: plplot.d:1262
void c_plspal1(const char *filename, PLBOOL interpolate)
Definition: plctrl.c:1604
alias plcol0 plcol
Definition: plplot.d:1556
uint width
Definition: plplot.d:1206
alias c_pleop pleop
Definition: plplot.d:1404
void c_plgra()
Definition: plctrl.c:1993
void plAlloc2dGrid(PLFLT ***f, PLINT nx, PLINT ny)
Definition: plmem.c:60
#define plbox3
Definition: plplot.h:631
PLFLT ** convert_array(PLFLT[][] a)
Definition: plplot.d:37
void c_plgyax(PLINT *p_digmax, PLINT *p_digits)
Definition: plcore.c:4031
#define plcolorbar
Definition: plplot.h:637
tuple ymax
Definition: Plframe.py:910
PLFLT l
Definition: plplot.d:1306
alias c_plprec plprec
Definition: plplot.d:1469
void plgDevs(char ***p_menustr, char ***p_devname, int *p_ndev)
alias c_plgcol0 plgcol0
Definition: plplot.d:1414
alias c_plsfci plsfci
Definition: plplot.d:1504
void c_plerrx(PLINT n, PLFLT *xmin, PLFLT *xmax, PLFLT *y)
alias c_plstransform plstransform
Definition: plplot.d:1522
void c_plgpage(PLFLT *p_xp, PLFLT *p_yp, PLINT *p_xleng, PLINT *p_yleng, PLINT *p_xoff, PLINT *p_yoff)
Definition: plcore.c:3558
alias c_plend1 plend1
Definition: plplot.d:1401
void plmaptex(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, PLFLT dx, PLFLT dy, PLFLT just, const char *text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:673
alias c_plgspa plgspa
Definition: plplot.d:1432
#define plpoin3
Definition: plplot.h:716
#define PLESC_HAS_TEXT
Definition: plplot.h:229
PLFLT ** zg
Definition: plplot.d:1278
alias c_plgcolbga plgcolbga
Definition: plplot.d:1417
void c_plerry(PLINT n, PLFLT *x, PLFLT *ymin, PLFLT *ymax)
alias c_pllightsource pllightsource
Definition: plplot.d:1449
alias plfcont plcontf
Definition: plplot.d:1557
#define plpat
Definition: plplot.h:714
char[16] string
Definition: plplot.d:1172
alias c_plssub plssub
Definition: plplot.d:1518
PLFLT a
Definition: plplot.d:1309
alias c_plgradient plgrdient
Definition: plplot.d:1429
void c_plgstrm(PLINT *p_strm)
Definition: plcore.c:2631
void pltr0f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data)
PLFLT dxma
Definition: plplot.d:1189
void c_plwind(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plwind.c:33
alias c_plgcolbg plgcolbg
Definition: plplot.d:1415
alias c_plsesc plsesc
Definition: plplot.d:1501
#define PLESC_IMAGE
Definition: plplot.h:230
alias c_plgra plgra
Definition: plplot.d:1430
#define PL_PARSE_SHOWALL
Definition: plplot.h:302
void c_plinit()
Definition: plcore.c:2301
static char errmsg[160]
Definition: tclAPI.c:146
void c_pllab(const char *xlabel, const char *ylabel, const char *tlabel)
Definition: plsym.c:531
#define PLESC_DEV2PLCOL
Definition: plplot.h:233
#define plscmap1l
Definition: plplot.h:735
#define PLESC_SETBGFG
Definition: plplot.h:234
alias c_plctime plctime
Definition: plplot.d:1399
#define plptex
Definition: plplot.h:720
ubyte r
Definition: plplot.d:1293
#define PLESC_IMAGEOPS
Definition: plplot.h:231
#define PLESC_DASH
Definition: plplot.h:228
#define plline
Definition: plplot.h:695
void c_plenv0(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plvpor.c:103
ubyte g
Definition: plplot.d:1294
#define PL_LEGEND_COLOR_BOX
Definition: plplot.h:1249
#define PL_FCI_HEXDIGIT_MASK
Definition: plplot.h:311
void c_plscmap0n(PLINT ncol0)
Definition: plctrl.c:932
alias c_plgcol0a plgcol0a
Definition: plplot.d:1416
#define PL_COLORBAR_LABEL_BOTTOM
Definition: plplot.h:1261
void pl_cmd(PLINT op, void *ptr)
Definition: plctrl.c:2108
alias c_plrgb plrgb
Definition: plplot.d:1475
void c_plvasp(PLFLT aspect)
Definition: plvpor.c:456
#define plgradient
Definition: plplot.h:673
#define PL_POSITION_TOP
Definition: plplot.h:1240
#define PL_PARSE_OVERRIDE
Definition: plplot.h:303
alias c_plscol0 plscol0
Definition: plplot.d:1488
alias c_pl_setcontlabelparam pl_setcontlabelparam
Definition: plplot.d:1381
void c_plgdiplt(PLFLT *p_xmin, PLFLT *p_ymin, PLFLT *p_xmax, PLFLT *p_ymax)
Definition: plcore.c:1848
void c_plscolbga(PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plctrl.c:234
dx
if { $zoomopts($this,1) == 0 } then {
Definition: Plframe.py:613
PLFLT[] yg
Definition: plplot.d:26
alias _N6 PLfGrid2
Definition: plplot.d:1244
void c_plreplot()
Definition: plcore.c:3485
void c_plscolor(PLINT color)
Definition: plctrl.c:1192
alias int PLINT
Definition: plplot.d:1029
#define PL_COLORBAR_BOUNDING_BOX
Definition: plplot.h:1274
PLFLT * f
Definition: plplot.d:1226
PLDLLIMPEXP void c_plmaptex(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, PLFLT dx, PLFLT dy, PLFLT just, const char *text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
#define DRAW_LINEY
Definition: plplot.h:1463
void c_plgcol0(PLINT icol0, PLINT *r, PLINT *g, PLINT *b)
Definition: plctrl.c:359
void c_plstring3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, const char *text)
#define PL_BIN_NOEMPTY
Definition: plplot.h:881
void c_plpat(PLINT nlin, PLINT *inc, PLINT *del)
void c_plgcol0a(PLINT icol0, PLINT *r, PLINT *g, PLINT *b, PLFLT *a)
Definition: plctrl.c:396
#define PLESC_GETC
Definition: plplot.h:222
alias c_plsdimap plsdimap
Definition: plplot.d:1496
#define PL_COLORBAR_IMAGE
Definition: plplot.h:1262
#define PLESC_PL2DEVCOL
Definition: plplot.h:232
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)
alias c_plenv0 plenv0
Definition: plplot.d:1403
#define plscmap0
Definition: plplot.h:730
alias c_plend plend
Definition: plplot.d:1400
alias c_plszax plszax
Definition: plplot.d:1536
#define PL_FCI_SANS
Definition: plplot.h:319
void c_plgfci(PLUNICODE *pfci)
Definition: plcore.c:3915
void c_plsesc(char esc)
Definition: plcore.c:3869
alias _N9 PLColor
Definition: plplot.d:1299
alias c_plgvpw plgvpw
Definition: plplot.d:1436
void c_plpoly3(PLINT n, PLFLT *x, PLFLT *y, PLFLT *z, PLBOOL *draw, PLBOOL ifcc)
PLINT ny
Definition: plplot.d:1242
PLDLLIMPEXP void c_plmap(void(*mapform)(PLINT, PLFLT *, PLFLT *), const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
alias c_pladv pladv
Definition: plplot.d:1382
void * client_data
Definition: plplot.d:1153
#define PLESC_EXPOSE
Definition: plplot.h:213
PLINT plFindName(char *p)
Definition: plctrl.c:2422
#define plmtex
Definition: plplot.h:708
#define ZEROW2B
Definition: plplot.h:261
#define PL_FCI_HEXPOWER_IMPOSSIBLE
Definition: plplot.h:313
void c_pllsty(PLINT lin)
Definition: plsdef.c:268
#define plsurf3d
Definition: plplot.h:785
PLFLT dX
Definition: plplot.d:1175
#define PL_COLORBAR_LABEL_RIGHT
Definition: plplot.h:1259
void c_plbox3(const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx, const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby, const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz)
Definition: plbox.c:593
alias c_plgcompression plgcompression
Definition: plplot.d:1418
alias c_pllsty pllsty
Definition: plplot.d:1453
#define ONEW2B
Definition: plplot.h:263
PLFLT[] zg
Definition: plplot.d:27
PLINT c_plparseopts(int *p_argc, char **argv, PLINT mode)
Definition: plargs.c:877
void c_pleop()
Definition: plpage.c:101
void c_plvect(PLFLT **u, PLFLT **v, PLINT nx, PLINT ny, PLFLT scale, void function(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer) pltr, PLPointer pltr_data)
PLINT ny
Definition: plplot.d:1263
void c_plsvect(PLFLT *arrowx, PLFLT *arrowy, PLINT npts, PLBOOL fill)
uint x
Definition: plplot.d:1204
alias c_plsstrm plsstrm
Definition: plplot.d:1517
#define GRID_NNAIDW
Definition: plplot.h:1161
PLDLLIMPEXP_CXX void fill(PLINT n, const PLFLT *x, const PLFLT *y)
Definition: plstream.cc:240
#define plot3d
Definition: plplot.h:710
#define GRID_NNLI
Definition: plplot.h:1160
alias c_plscmap0n plscmap0n
Definition: plplot.d:1481
void c_plfill(PLINT n, PLFLT *x, PLFLT *y)
char * name
Definition: plplot.d:1297
alias plFree2dGrid Free2dGrid
Definition: plplot.d:1559
void plgesc(char *p_esc)
Definition: plcore.c:3893
alias c_plsfont plsfont
Definition: plplot.d:1506
alias c_plvsta plvsta
Definition: plplot.d:1543
string desc
Definition: plplot.d:1157
#define PLESC_FLUSH
Definition: plplot.h:220
alias c_plcol0 plcol0
Definition: plplot.d:1393
#define PL_FCI_MARK
Definition: plplot.h:309
#define GRID_CSA
Definition: plplot.h:1156
PLINT plGetInt(const char *s)
Definition: plctrl.c:2900