PLplot  5.12.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plstream.h
Go to the documentation of this file.
1 //----------------------------------*-C++-*----------------------------------//
2 // Geoffrey Furnish
3 // Sep 21 1994
4 //
5 // Copyright (C) 2004,2005 Andrew Ross
6 // Copyright (C) 2004-2014 Alan W. Irwin
7 //
8 // This file is part of PLplot.
9 //
10 // PLplot is free software; you can redistribute it and/or modify
11 // it under the terms of the GNU Library General Public License as published
12 // by the Free Software Foundation; either version 2 of the License, or
13 // (at your option) any later version.
14 //
15 // PLplot is distributed in the hope that it will be useful,
16 // but WITHOUT ANY WARRANTY; without even the implied warranty of
17 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 // GNU Library General Public License for more details.
19 //
20 // You should have received a copy of the GNU Library General Public License
21 // along with PLplot; if not, write to the Free Software
22 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 
24 //--------------------------------------------------------------------------
25 // @> Header file plstream.
26 //--------------------------------------------------------------------------
27 
28 #ifndef __plstream_h__
29 #define __plstream_h__
30 
31 #include "plplot.h"
32 
33 class PLS {
34 public:
36 };
37 
38 enum PLcolor { Black = 0, Red, Yellow, Green,
42 
43 // A class for assisting in generalizing the data prescription
44 // interface to the contouring routines.
45 
47  int _nx, _ny;
48 public:
49  Contourable_Data( int nx, int ny ) : _nx( nx ), _ny( ny ) {}
50  virtual void elements( int& nx, int& ny ) const { nx = _nx; ny = _ny; }
51  virtual PLFLT operator()( int i, int j ) const = 0;
52  virtual ~Contourable_Data() {};
53 };
54 
56 
58 public:
59  virtual void xform( PLFLT ox, PLFLT oy, PLFLT& nx, PLFLT& ny ) const = 0;
60  virtual ~Coord_Xformer() {};
61 };
62 
64 
65 class Coord_2d {
66 public:
67  virtual PLFLT operator()( int ix, int iy ) const = 0;
68  virtual void elements( int& _nx, int& _ny ) = 0;
69  virtual void min_max( PLFLT& _min, PLFLT& _max ) = 0;
70  virtual ~Coord_2d() {};
71 };
72 
76 public:
77  cxx_pltr2( Coord_2d & cx, Coord_2d & cy );
78  void xform( PLFLT x, PLFLT y, PLFLT& tx, PLFLT& ty ) const;
79 };
80 
81 //--------------------------------------------------------------------------
82 //Callback functions for passing into various API methods. We provide these
83 //wrappers to avoid a requirement for linking to the C shared library.
84 //--------------------------------------------------------------------------
85 
86 namespace plcallback
87 {
88 // Callback for plfill. This will just call the C plfill function
89 
90 PLDLLIMPEXP_CXX void fill( PLINT n, const PLFLT *x, const PLFLT *y );
91 
92 // Identity transformation.
93 
94 PLDLLIMPEXP_CXX void tr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
95 
96 // Does linear interpolation from singly dimensioned coord arrays.
97 
98 PLDLLIMPEXP_CXX void tr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
99 
100 // Does linear interpolation from doubly dimensioned coord arrays
101 // (column dominant, as per normal C 2d arrays).
102 
103 PLDLLIMPEXP_CXX void tr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
104 
105 // Just like pltr2() but uses pointer arithmetic to get coordinates from
106 // 2d grid tables.
107 
108 PLDLLIMPEXP_CXX void tr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
109 }
110 
111 //--------------------------------------------------------------------------
112 // class plstream - C++ class for encapsulating PLplot streams
113 
114 // Cool stuff.
115 //--------------------------------------------------------------------------
116 
119 
121 
122 private:
123  // These have to be disabled till we implement reference counting.
124 
125  plstream( const plstream & );
126  plstream& operator=( const plstream& );
127 
128 protected:
129  virtual void set_stream( void ) { ::c_plsstrm( stream ); }
130 
131 public:
132  plstream( void );
133  plstream( plstream * pls );
134  plstream( PLS::stream_id sid, PLINT strm = 0 );
135  plstream( PLINT _stream ) : stream( _stream ) {}
136  plstream( PLINT nx /*=1*/, PLINT ny /*=1*/,
137  const char *driver = NULL, const char *file = NULL );
138  plstream( PLINT nx /*=1*/, PLINT ny /*=1*/, PLINT r, PLINT g, PLINT b,
139  const char *driver = NULL, const char *file = NULL );
140 
141  virtual ~plstream( void );
142 
143 // Now start miroring the PLplot C API.
144 
145  // C routines callable from stub routines come first
146 
147 // Advance to subpage "page", or to the next one if "page" = 0.
148 
149  void adv( PLINT page );
150 
151 // Plot an arc
152 
153  void arc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
154  PLFLT rotate, PLBOOL fill );
155 
156 // Simple arrow plotter
157 #ifdef PL_DEPRECATED
158  void arrows( const PLFLT *u, const PLFLT *v, const PLFLT *x, const PLFLT *y, PLINT n,
159  PLFLT scale, PLFLT dx, PLFLT dy );
160 #endif // PL_DEPRECATED
161 
162  void vect( const PLFLT * const *u, const PLFLT * const *v, PLINT nx, PLINT ny, PLFLT scale,
163  PLTRANSFORM_callback pltr, PLPointer pltr_data );
164 
165 // Set the arrow style
166  void svect( const PLFLT *arrow_x = NULL, const PLFLT *arrow_y = NULL, PLINT npts = 0, bool fill = false );
167 
168 // This functions similarly to plbox() except that the origin of the axes is
169 // placed at the user-specified point (x0, y0).
170 
171  void axes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
172  const char *yopt, PLFLT ytick, PLINT nysub );
173 
174 // Plot a histogram using x to store data values and y to store frequencies.
175 
176  void bin( PLINT nbin, const PLFLT *x, const PLFLT *y, PLINT center );
177 
178 // Start new page. Should only be used with pleop().
179 
180  void bop( void );
181 
182 // This draws a box around the current viewport.
183 
184  void box( const char *xopt, PLFLT xtick, PLINT nxsub,
185  const char *yopt, PLFLT ytick, PLINT nysub );
186 
187 // This is the 3-d analogue of plbox().
188 
189  void box3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx,
190  const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby,
191  const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz );
192 
193 // Calculate broken-down time from continuous time for current stream.
194 
195  void btime( PLINT &year, PLINT &month, PLINT &day, PLINT &hour,
196  PLINT &min, PLFLT &sec, PLFLT ctime );
197 
198 // Calculate world coordinates and subpage from relative device coordinates.
199 
200  void calc_world( PLFLT rx, PLFLT ry, PLFLT& wx, PLFLT& wy, PLINT& window );
201 
202 // Clear the current subpage.
203 
204  void clear( void );
205 
206 // Set color, map 0. Argument is integer between 0 and 15.
207 
208  void col0( PLINT icol0 );
209 
210 // Set the color using a descriptive name. Replaces plcol0(). (Except that
211 // col0 won't die.)
212 
213  void col( PLcolor c );
214 
215 // Set color, map 1. Argument is a float between 0. and 1.
216 
217  void col1( PLFLT c );
218 
219 // Previous function was inadvertently named plcol in old versions of
220 // plplot - this is maintained for backwards compatibility, but is best
221 // avoided in new code.
222  void col( PLFLT c );
223 
224 // Configure transformation between continuous and broken-down time (and
225 // vice versa) for current stream.
226  void configtime( PLFLT scale, PLFLT offset1, PLFLT offset2,
227  PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year,
228  PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec );
229 
230 // Draws a contour plot from data in f(nx,ny). Is just a front-end to
231 // plfcont, with a particular choice for f2eval and f2eval_data.
232 
233  void cont( const PLFLT * const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx,
234  PLINT ky, PLINT ly, const PLFLT * clevel, PLINT nlevel,
235  PLTRANSFORM_callback pltr, PLPointer pltr_data );
236 
237 // Draws a contour plot using the function evaluator f2eval and data stored
238 // by way of the f2eval_data pointer. This allows arbitrary organizations
239 // of 2d array data to be used.
240 
241  void fcont( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
242  PLPointer f2eval_data,
243  PLINT nx, PLINT ny, PLINT kx, PLINT lx,
244  PLINT ky, PLINT ly, const PLFLT * clevel, PLINT nlevel,
245  PLTRANSFORM_callback pltr, PLPointer pltr_data );
246 
247 // Copies state parameters from the reference stream to the current stream.
248 
249  void cpstrm( plstream &pls, bool flags );
250 
251 // Calculate continuous time from broken-down time for current stream.
252  void ctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min,
253  PLFLT sec, PLFLT &ctime );
254 
255 // Converts input values from relative device coordinates to relative plot
256 // coordinates.
257 
258  void did2pc( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
259 
260 // Converts input values from relative plot coordinates to relative device
261 // coordinates.
262 
263  void dip2dc( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
264 
265 // These shouldn't be needed, are supposed to be handled by ctor/dtor
266 // semantics of the plstream object.
267 
268 // End a plotting session for all open streams.
269 
270 // void end();
271 
272 // End a plotting session for the current stream only.
273 
274 // void end1();
275 
276 // Simple interface for defining viewport and window.
277 
278  void env( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
279  PLINT just, PLINT axis );
280 
281 // similar to env() above, but in multiplot mode does not advance
282 // the subpage, instead the current subpage is cleared
283 
284  void env0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
285  PLINT just, PLINT axis );
286 
287 // End current page. Should only be used with plbop().
288 
289  void eop( void );
290 
291 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i)).
292 
293  void errx( PLINT n, const PLFLT *xmin, const PLFLT *xmax, const PLFLT *y );
294 
295 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i)).
296 
297  void erry( PLINT n, const PLFLT *x, const PLFLT *ymin, const PLFLT *ymax );
298 
299 // Advance to the next family file on the next new page.
300 
301  void famadv( void );
302 
303 // Pattern fills the polygon bounded by the input points.
304 
305  void fill( PLINT n, const PLFLT *x, const PLFLT *y );
306 
307 // Pattern fills the 3d polygon bounded by the input points.
308 
309  void fill3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z );
310 
311 // Flushes the output stream. Use sparingly, if at all.
312 
313  void flush( void );
314 
315 // Sets the global font flag to 'ifont'.
316 
317  void font( PLINT ifont );
318 
319 // Load specified font set.
320 
321  void fontld( PLINT fnt );
322 
323 // Get character default height and current (scaled) height.
324 
325  void gchr( PLFLT& p_def, PLFLT& p_ht );
326 
327 // Returns 8 bit RGB values for given color from color map 0.
328 
329  void gcol0( PLINT icol0, PLINT& r, PLINT& g, PLINT& b );
330 
331 // Returns 8 bit RGB and 0.0-1.0 alpha values for given color from color map 0.
332 
333  void gcol0a( PLINT icol0, PLINT& r, PLINT& g, PLINT& b, PLFLT& a );
334 
335 // Returns the background color by 8 bit RGB value.
336 
337  void gcolbg( PLINT& r, PLINT& g, PLINT& b );
338 
339 // Returns the background color by 8 bit RGB and 0.0-1.0 alpha values.
340 
341  void gcolbga( PLINT& r, PLINT& g, PLINT& b, PLFLT& a );
342 
343 // Returns the current compression setting
344 
345  void gcompression( PLINT& compression );
346 
347 // Retrieve current window into device space.
348 
349  void gdidev( PLFLT& mar, PLFLT& aspect, PLFLT& jx, PLFLT& jy );
350 
351 // Get plot orientation.
352 
353  void gdiori( PLFLT& rot );
354 
355 // Retrieve current window into plot space.
356 
357  void gdiplt( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
358 
359 // Get FCI (font characterization integer)
360 
361  void gfci( PLUNICODE& pfci );
362 
363 // Get family file parameters.
364 
365  void gfam( PLINT& fam, PLINT& num, PLINT& bmax );
366 
367 // Get the (current) output file name. Must be preallocated to >80 bytes.
368 
369  void gfnam( char *fnam );
370 
371 // Get the current font family, style and weight
372 
373  void gfont( PLINT& family, PLINT& style, PLINT& weight );
374 
375 // Get the (current) run level.
376 
377  void glevel( PLINT &p_level );
378 
379 // Get output device parameters.
380 
381  void gpage( PLFLT& xp, PLFLT& yp, PLINT& xleng, PLINT& yleng,
382  PLINT& xoff, PLINT& yoff );
383 
384 // Switches to graphics screen.
385 
386  void gra( void );
387 
388 // Draw gradient in polygon.
389 
390  void gradient( PLINT n, const PLFLT *x, const PLFLT *y, PLFLT angle );
391 
392 // grid irregularly sampled data
393 
394  void griddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts,
395  const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy,
396  PLFLT **zg, PLINT type, PLFLT data );
397 
398 // Get subpage boundaries in absolute coordinates.
399 
400  void gspa( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
401 
402 // This shouldn't be needed in this model.
403 
404 // Get current stream number.
405 
406 // void gstrm( PLINT *p_strm );
407 
408 // Get the current library version number.
409 
410  void gver( char *p_ver );
411 
412 // Get the viewport window in normalized device coordinates
413 
414  void gvpd( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
415 
416 // Get the viewport window in world coordinates
417 
418  void gvpw( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
419 
420 // Get x axis labeling parameters.
421 
422  void gxax( PLINT& digmax, PLINT& digits );
423 
424 // Get y axis labeling parameters.
425 
426  void gyax( PLINT& digmax, PLINT& digits );
427 
428 // Get z axis labeling parameters
429 
430  void gzax( PLINT& digmax, PLINT& digits );
431 
432 // Draws a histogram of n values of a variable in array data[0..n-1]
433 
434  void hist( PLINT n, const PLFLT *data, PLFLT datmin, PLFLT datmax,
435  PLINT nbin, PLINT oldwin );
436 
437 // Set current color (map 0) by hue, lightness, and saturation.
438 
439 #ifdef PL_DEPRECATED
440  void hls( PLFLT h, PLFLT l, PLFLT s );
441 #endif // PL_DEPRECATED
442 
443 // Initializes PLplot, using preset or default options
444 
445  void init( void );
446 
447 // Draws a line segment from (x1, y1) to (x2, y2).
448 
449  void join( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
450 
451 // Simple routine for labelling graphs.
452 
453  void lab( const char *xlabel, const char *ylabel, const char *tlabel );
454 
455 // Routine for drawing line, symbol, or cmap0 legends
456  void legend( PLFLT *p_legend_width, PLFLT *p_legend_height,
457  PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
458  PLINT bg_color, PLINT bb_color, PLINT bb_style,
459  PLINT nrow, PLINT ncolumn,
460  PLINT nlegend, const PLINT *opt_array,
461  PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
462  PLFLT text_justification,
463  const PLINT *text_colors, const char * const *text,
464  const PLINT *box_colors, const PLINT *box_patterns,
465  const PLFLT *box_scales, const PLFLT *box_line_widths,
466  const PLINT *line_colors, const PLINT *line_styles,
467  const PLFLT *line_widths,
468  const PLINT *symbol_colors, const PLFLT *symbol_scales,
469  const PLINT *symbol_numbers, const char * const *symbols );
470 
471  void colorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
472  PLINT opt, PLINT position, PLFLT x, PLFLT y,
473  PLFLT x_length, PLFLT y_length,
474  PLINT bg_color, PLINT bb_color, PLINT bb_style,
475  PLFLT low_cap_color, PLFLT high_cap_color,
476  PLINT cont_color, PLFLT cont_width,
477  PLINT n_labels, PLINT *label_opts, const char * const *label,
478  PLINT n_axes, const char * const *axis_opts,
479  PLFLT *ticks, PLINT *sub_ticks,
480  PLINT *n_values, const PLFLT * const *values );
481 
482 // Sets position of the light source
483 
484  void lightsource( PLFLT x, PLFLT y, PLFLT z );
485 
486 // Draws line segments connecting a series of points.
487 
488  void line( PLINT n, const PLFLT *x, const PLFLT *y );
489 
490 // Draws a line in 3 space.
491 
492  void line3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z );
493 
494 // Set line style.
495 
496  void lsty( PLINT lin );
497 
498 // Plot continental outline in world coordinates
499 
500  void map( PLMAPFORM_callback mapform, const char *name,
501  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy );
502 
503 // Plot map lines
504 
505  void mapline( PLMAPFORM_callback mapform, const char *name,
506  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
507  const PLINT *plotentries, PLINT nplotentries );
508 
509 // Plot map points
510 
511  void mapstring( PLMAPFORM_callback mapform,
512  const char *name, const char *string,
513  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
514  const PLINT *plotentries, PLINT nplotentries );
515 
516 // Plot map text
517 
518  void maptex( PLMAPFORM_callback mapform,
519  const char *name, PLFLT dx, PLFLT dy, PLFLT just, const char *text,
520  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
521  PLINT plotentry );
522 
523 // Plot map fills
524 
525  void mapfill( PLMAPFORM_callback mapform,
526  const char *name, PLFLT minx, PLFLT maxx, PLFLT miny,
527  PLFLT maxy, const PLINT *plotentries, PLINT nplotentries );
528 
529 // Plot the latitudes and longitudes on the background.
530 
531  void meridians( PLMAPFORM_callback mapform,
532  PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong,
533  PLFLT minlat, PLFLT maxlat );
534 
535 // Plots a mesh representation of the function z[x][y].
536 
537  void mesh( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny, PLINT opt );
538 
539 // Plots a mesh representation of the function z[x][y] with contour.
540 
541  void meshc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny, PLINT opt,
542  const PLFLT *clevel, PLINT nlevel );
543 
544 // Creates a new stream and makes it the default.
545 
546 // void
547 // mkstrm(PLINT *p_strm);
548 
549 // Prints out "text" at specified position relative to viewport
550 
551  void mtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
552  const char *text );
553 
554 // Prints out "text" at specified position relative to viewport (3D)
555 
556  void mtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
557  const char *text );
558 
559 // Plots a 3-d representation of the function z[x][y].
560 
561  void plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
562  PLINT nx, PLINT ny, PLINT opt, bool side );
563 
564 // Plots a 3-d representation of the function z[x][y] with contour.
565 
566  void plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
567  PLINT nx, PLINT ny, PLINT opt,
568  const PLFLT *clevel, PLINT nlevel );
569 
570 // Plots a 3-d representation of the function z[x][y] with contour
571 // and y index limits.
572 
573  void plot3dcl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
574  PLINT nx, PLINT ny, PLINT opt,
575  const PLFLT *clevel, PLINT nlevel,
576  PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
577 
578 
579 // Plots a 3-d shaded representation of the function z[x][y].
580 
581  void surf3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
582  PLINT nx, PLINT ny, PLINT opt,
583  const PLFLT *clevel, PLINT nlevel );
584 
585 // Plots a 3-d shaded representation of the function z[x][y] with y
586 // index limits
587 
588  void surf3dl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
589  PLINT nx, PLINT ny, PLINT opt,
590  const PLFLT *clevel, PLINT nlevel,
591  PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
592 
593 
594 // Process options list using current options info.
595 
596  PLINT parseopts( int *p_argc, char **argv, PLINT mode );
597 
598 // Set fill pattern directly.
599 
600  void pat( PLINT nlin, const PLINT *inc, const PLINT *del );
601 
602 // Draw a line connecting two points, accounting for coordinate transforms
603 
604  void path( PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
605 
606 // Plots array y against x for n points using ASCII code "code".
607 
608  void poin( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code );
609 
610 // Draws a series of points in 3 space.
611 
612  void poin3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT code );
613 
614 // Draws a polygon in 3 space.
615 
616  void poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const bool *draw, bool ifcc );
617 
618 // Set the floating point precision (in number of places) in numeric labels.
619 
620  void prec( PLINT setp, PLINT prec );
621 
622 // Set fill pattern, using one of the predefined patterns.
623 
624  void psty( PLINT patt );
625 
626 // Prints out "text" at world cooordinate (x,y).
627 
628  void ptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just,
629  const char *text );
630 
631 // Prints out "text" at world cooordinate (x,y,z).
632 
633  void ptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz,
634  PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text );
635 
636 // Get the world coordinates associated with device coordinates
637 
638  PLINT translatecursor( PLGraphicsIn *gin );
639 
640 // Replays contents of plot buffer to current device/file.
641 
642  void replot( void );
643 
644 // Set line color by red, green, blue from 0. to 1.
645 
646 #ifdef PL_DEPRECATED
647  void rgb( PLFLT r, PLFLT g, PLFLT b );
648 #endif // PL_DEPRECATED
649 
650 // Set line color by 8 bit RGB values.
651 
652 #ifdef PL_DEPRECATED
653  void rgb( PLINT r, PLINT g, PLINT b );
654 #endif // PL_DEPRECATED
655 
656 // Set character height.
657 
658  void schr( PLFLT def, PLFLT scale );
659 
660 // Set number of colors in cmap 0
661 
662  void scmap0n( PLINT ncol0 );
663 
664 // Set number of colors in cmap 1
665 
666  void scmap1n( PLINT ncol1 );
667 
668 // Set the color map 1 range used in continuous plots
669 
670  void scmap1_range( PLFLT min_color, PLFLT max_color );
671 
672 // Get the color map 1 range used in continuous plots
673 
674  void gcmap1_range( PLFLT &min_color, PLFLT &max_color );
675 
676 // Set color map 0 colors by 8 bit RGB values
677 
678  void scmap0( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol0 );
679 
680 // Set color map 0 colors by 8 bit RGB values and alpha value (0.0-1.0)
681 
682  void scmap0a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol0 );
683 
684 // Set color map 1 colors by 8 bit RGB values
685 
686  void scmap1( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol1 );
687 
688 // Set color map 1 colors by 8 bit RGB values and alpha value (0.0-1.0)
689 
690  void scmap1a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol1 );
691 
692 // Set color map 1 colors using a piece-wise linear relationship between
693 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
694 
695  void scmap1l( bool itype, PLINT npts, const PLFLT *intensity,
696  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const bool *alt_hue_path = NULL );
697 
698 // void scmap1l( bool itype, PLINT npts, PLFLT *intensity,
699 // PLFLT *coord1, PLFLT *coord2, PLFLT *coord3 );
700 
701 // Set color map 1 colors using a piece-wise linear relationship between
702 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
703 // Include alpha value in range 0.0-1.0.
704 
705  void scmap1la( bool itype, PLINT npts, const PLFLT *intensity,
706  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLFLT *a,
707  const bool *alt_hue_path = NULL );
708 
709 // Set a given color from color map 0 by 8 bit RGB value
710 
711  void scol0( PLINT icol0, PLINT r, PLINT g, PLINT b );
712 
713 // Set a given color from color map 0 by 8 bit RGB value and alpha value (0.0-1.0)
714 
715  void scol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a );
716 
717 // Set the background color by 8 bit RGB value
718 
719  void scolbg( PLINT r, PLINT g, PLINT b );
720 
721 // Set the background color by 8 bit RGB + alpha value
722 
723  void scolbga( PLINT r, PLINT g, PLINT b, PLFLT a );
724 
725 // Used to globally turn color output on/off
726 
727  void scolor( PLINT color );
728 
729 // Set the compression level
730 
731  void scompression( PLINT compression );
732 
733 // Set the device (keyword) name
734 
735  void sdev( const char *devname );
736 
737 // Get the device (keyword) name
738 
739  void gdev( char *devname );
740 
741 // Set window into device space using margin, aspect ratio, and
742 // justification
743 
744  void sdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy );
745 
746 // Set up transformation from metafile coordinates.
747 
748  void sdimap( PLINT dimxmin, PLINT dimxmax,
749  PLINT dimymin, PLINT dimymax,
750  PLFLT dimxpmm, PLFLT dimypmm );
751 
752 // Set plot orientation, specifying rotation in units of pi/2.
753 
754  void sdiori( PLFLT rot );
755 
756 // Set window into plot space
757 
758  void sdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
759 
760 // Set window into plot space incrementally (zoom)
761 
762  void sdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
763 
764 // Set the escape character for text strings.
765 
766  void sesc( char esc );
767 
768 // Set offset and spacing of contour labels
769 
770  void setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing,
771  PLINT active );
772 
773 // Set the format of the contour labels
774 
775  void setcontlabelformat( PLINT lexp, PLINT sigdig );
776 
777 // Set family file parameters
778 
779  void sfam( PLINT fam, PLINT num, PLINT bmax );
780 
781 // Set FCI (font characterization integer)
782 
783  void sfci( PLUNICODE fci );
784 
785 // Set the output file name.
786 
787  void sfnam( const char *fnam );
788 
789 // Set the pointer to the data used in driver initialisation
790 
791  void sdevdata( void *data );
792 
793 // Set the current font family, style and weight
794 
795  void sfont( PLINT family, PLINT style, PLINT weight );
796 
797 // Shade region.
798 
799  void shade( const PLFLT * const *a, PLINT nx, PLINT ny,
800  PLDEFINED_callback defined,
801  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
802  PLFLT shade_min, PLFLT shade_max,
803  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
804  PLINT min_color, PLFLT min_width,
805  PLINT max_color, PLFLT max_width,
806  PLFILL_callback fill, bool rectangular,
807  PLTRANSFORM_callback pltr, PLPointer pltr_data );
808 
809  void shades( const PLFLT * const *a, PLINT nx, PLINT ny,
810  PLDEFINED_callback defined,
811  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
812  const PLFLT * clevel, PLINT nlevel, PLFLT fill_width,
813  PLINT cont_color, PLFLT cont_width,
814  PLFILL_callback fill, bool rectangular,
815  PLTRANSFORM_callback pltr, PLPointer pltr_data );
816 
817 // Would be nice to fix this even more, say by stuffing xmin, xmax,
818 // ymin, ymax, rectangular, and pcxf all into the contourable data
819 // class. Have to think more on that. Or maybe the coordinate info.
820 
821  void shade( Contourable_Data& d, PLFLT xmin, PLFLT xmax,
822  PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
823  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
824  PLINT min_color, PLFLT min_width,
825  PLINT max_color, PLFLT max_width,
826  bool rectangular,
827  Coord_Xformer *pcxf );
828 
829  void shade1( const PLFLT * a, PLINT nx, PLINT ny,
830  PLDEFINED_callback defined,
831  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
832  PLFLT shade_min, PLFLT shade_max,
833  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
834  PLINT min_color, PLFLT min_width,
835  PLINT max_color, PLFLT max_width,
836  PLFILL_callback fill, bool rectangular,
837  PLTRANSFORM_callback pltr, PLPointer pltr_data );
838 
839  void fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
840  PLPointer f2eval_data,
841  PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
842  PLPointer c2eval_data,
843  PLINT nx, PLINT ny,
844  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
845  PLFLT shade_min, PLFLT shade_max,
846  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
847  PLINT min_color, PLFLT min_width,
848  PLINT max_color, PLFLT max_width,
849  PLFILL_callback fill, bool rectangular,
850  PLTRANSFORM_callback pltr, PLPointer pltr_data );
851 
852 // Setup a user-provided custom labeling function
853 
854  void slabelfunc( PLLABEL_FUNC_callback label_func, PLPointer label_data );
855 
856 // Set up lengths of major tick marks.
857 
858  void smaj( PLFLT def, PLFLT scale );
859 
860 // Set the RGB memory area to be plotted (with the 'mem' or 'memcairo' drivers)
861 
862  void smem( PLINT maxx, PLINT maxy, void *plotmem );
863 
864 // Set the RGBA memory area to be plotted (with the 'memcairo' driver)
865 
866  void smema( PLINT maxx, PLINT maxy, void *plotmem );
867 
868 // Set up lengths of minor tick marks.
869 
870  void smin( PLFLT def, PLFLT scale );
871 
872 // Set orientation. Must be done before calling plinit.
873 
874  void sori( PLINT ori );
875 
876 // Set output device parameters. Usually ignored by the driver.
877 
878  void spage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng,
879  PLINT xoff, PLINT yoff );
880 
881 // Set the pause (on end-of-page) status
882 
883  void spause( bool pause );
884 
885 // Set the colors for color table 0 from a cmap0 file
886 
887  void spal0( const char *filename );
888 
889 // Set the colors for color table 1 from a cmap1 file
890 
891  void spal1( const char *filename, bool interpolate = true );
892 
893 // Set stream number.
894 
895  void sstrm( PLINT strm );
896 
897 // Set the number of subwindows in x and y
898 
899  void ssub( PLINT nx, PLINT ny );
900 
901 // Set symbol height.
902 
903  void ssym( PLFLT def, PLFLT scale );
904 
905 // Initialize PLplot, passing in the windows/page settings.
906 
907  void star( PLINT nx, PLINT ny );
908 
909 // Initialize PLplot, passing the device name and windows/page settings.
910 
911  void start( const char *devname, PLINT nx, PLINT ny );
912 
913 // Set the coordinate transform
914 
915  void stransform( PLTRANSFORM_callback coordinate_transform, PLPointer coordinate_transform_data );
916 
917 // Prints out the same string repeatedly at the n points in world
918 // coordinates given by the x and y arrays. Supersedes plpoin and
919 // plsymbol for the case where text refers to a unicode glyph either
920 // directly as UTF-8 or indirectly via the standard text escape
921 // sequences allowed for PLplot input strings.
922 
923  void string( PLINT n, const PLFLT *x, const PLFLT *y, const char *string );
924 
925 // Prints out the same string repeatedly at the n points in world
926 // coordinates given by the x, y, and z arrays. Supersedes plpoin3
927 // for the case where text refers to a unicode glyph either directly
928 // as UTF-8 or indirectly via the standard text escape sequences
929 // allowed for PLplot input strings.
930 
931  void string3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const char *string );
932 
933 // Create 1d stripchart
934 
935  void stripc( PLINT *id, const char *xspec, const char *yspec,
936  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
937  PLFLT xlpos, PLFLT ylpos,
938  bool y_ascl, bool acc,
939  PLINT colbox, PLINT collab,
940  const PLINT colline[], const PLINT styline[], const char *legline[],
941  const char *labx, const char *laby, const char *labtop );
942 
943 // Add a point to a stripchart.
944 
945  void stripa( PLINT id, PLINT pen, PLFLT x, PLFLT y );
946 
947 // Deletes and releases memory used by a stripchart.
948 
949  void stripd( PLINT id );
950 
951 // plots a 2d image (or a matrix too large for plshade() ) - colors
952 // automatically scaled
953 
954  void image( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
955  PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
956  PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax );
957 
958 // plots a 2d image (or a matrix too large for plshade() )
959 
960  void imagefr( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
961  PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
962  PLFLT valuemin, PLFLT valuemax,
963  PLTRANSFORM_callback pltr, PLPointer pltr_data );
964 
965 // Set up a new line style
966 
967  void styl( PLINT nms, const PLINT *mark, const PLINT *space );
968 
969 // Sets the edges of the viewport to the specified absolute coordinates
970 
971  void svpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
972 
973 // Set x axis labeling parameters
974 
975  void sxax( PLINT digmax, PLINT digits );
976 
977 // Set inferior X window
978 
979  void sxwin( PLINT window_id );
980 
981 // Set y axis labeling parameters
982 
983  void syax( PLINT digmax, PLINT digits );
984 
985 // Plots array y against x for n points using Hershey symbol "code"
986 
987  void sym( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code );
988 
989 // Set z axis labeling parameters
990 
991  void szax( PLINT digmax, PLINT digits );
992 
993 // Switches to text screen.
994 
995  void text( void );
996 
997 // Set the format for date / time labels
998 
999  void timefmt( const char *fmt );
1000 
1001 // Sets the edges of the viewport with the given aspect ratio, leaving
1002 // room for labels.
1003 
1004  void vasp( PLFLT aspect );
1005 
1006 // Creates the largest viewport of the specified aspect ratio that fits
1007 // within the specified normalized subpage coordinates.
1008 
1009  void vpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect );
1010 
1011 // Creates a viewport with the specified normalized subpage coordinates.
1012 
1013  void vpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
1014 
1015 // Defines a "standard" viewport with seven character heights for
1016 // the left margin and four character heights everywhere else.
1017 
1018  void vsta( void );
1019 
1020 // Set up a window for three-dimensional plotting.
1021 
1022  void w3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0,
1023  PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0,
1024  PLFLT zmax0, PLFLT alt, PLFLT az );
1025 
1026 // Set pen width.
1027 
1028  void width( PLFLT width );
1029 
1030 // Set up world coordinates of the viewport boundaries (2d plots).
1031 
1032  void wind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
1033 
1034 // Set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
1035  void xormod( bool mode, bool *status );
1036 
1037 // Random number generator based on Mersenne Twister.
1038 // Functions to set seed and obtain real random numbers in the range [0,1].
1039 
1040  void seed( unsigned int s );
1041 
1042  PLFLT randd( void );
1043 
1044 
1045  // The rest for use from C only
1046 
1047 // Returns a list of file-oriented device names and their menu strings
1048 
1049  void gFileDevs( const char ***p_menustr, const char ***p_devname,
1050  int *p_ndev );
1051 
1052 // Set the function pointer for the keyboard event handler
1053 
1054  void sKeyEH( void ( *KeyEH )( PLGraphicsIn *, void *, int * ),
1055  void *KeyEH_data );
1056 
1057 // Sets an optional user bop handler
1058 
1059  void sbopH( void ( *handler )( void *, int * ), void *handlier_data );
1060 
1061 // Sets an optional user eop handler
1062 
1063  void seopH( void ( *handler )( void *, int * ), void *handlier_data );
1064 
1065 // Set the variables to be used for storing error info
1066 
1067  void sError( PLINT *errcode, char *errmsg );
1068 
1069 // Sets an optional user exit handler.
1070 
1071  void sexit( int ( *handler )( const char * ) );
1072 
1073  // Transformation routines
1074 
1075 // Identity transformation.
1076 
1077  //static void tr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
1078 
1079 // Does linear interpolation from singly dimensioned coord arrays.
1080 
1081  //static void tr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
1082 
1083 // Does linear interpolation from doubly dimensioned coord arrays
1084 // (column dominant, as per normal C 2d arrays).
1085 
1086  //static void tr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
1087 
1088 // Just like pltr2() but uses pointer arithmetic to get coordinates from
1089 // 2d grid tables.
1090 
1091  //static void tr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
1092 
1093 // We obviously won't be using this object from Fortran...
1094 
1095 // Identity transformation for plots from Fortran.
1096 
1097 // void tr0f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
1098 
1099 // Does linear interpolation from doubly dimensioned coord arrays
1100 // (row dominant, i.e. Fortran ordering).
1101 
1102 // void tr2f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
1103 
1104 // Example linear transformation function for contour plotter.
1105 // This is not actually part of the core library any more
1106  //void xform( PLFLT x, PLFLT y, PLFLT * tx, PLFLT * ty );
1107 
1108  // Function evaluators
1109 
1110 // Does a lookup from a 2d function array. Array is of type (PLFLT **),
1111 // and is column dominant (normal C ordering).
1112 
1113  PLFLT f2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data );
1114 
1115 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
1116 // and is column dominant (normal C ordering).
1117 
1118  PLFLT f2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data );
1119 
1120 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
1121 // and is row dominant (Fortran ordering).
1122 
1123  PLFLT f2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data );
1124 
1125  // Command line parsing utilities
1126 
1127 // Clear internal option table info structure.
1128 
1129  void ClearOpts( void );
1130 
1131 // Reset internal option table info structure.
1132 
1133  void ResetOpts( void );
1134 
1135 // Merge user option table into internal info structure.
1136 
1137  PLINT MergeOpts( PLOptionTable *options, const char *name, const char **notes );
1138 
1139 // Set the strings used in usage and syntax messages.
1140 
1141  void SetUsage( char *program_string, char *usage_string );
1142 
1143 // Process input strings, treating them as an option and argument pair.
1144 
1145  PLINT setopt( const char *opt, const char *optarg );
1146 
1147 // This version is for backward compatibility only - don't use in new code
1148 
1149  int SetOpt( const char *opt, const char *optarg );
1150 
1151 // Process options list using current options info.
1152 
1153  int ParseOpts( int *p_argc, const char **argv, PLINT mode );
1154 
1155 // Print usage & syntax message.
1156 
1157  void OptUsage( void );
1158 
1159  // Miscellaneous
1160 
1161 // Set the output file pointer
1162 
1163  void gfile( FILE **p_file );
1164 
1165 // Get the output file pointer
1166 
1167  void sfile( FILE *file );
1168 
1169 // Get the escape character for text strings.
1170 
1171  void gesc( char *p_esc );
1172 
1173 // Front-end to driver escape function.
1174 
1175  void cmd( PLINT op, void *ptr );
1176 
1177 // Return full pathname for given file if executable
1178 
1179  PLINT FindName( char *p );
1180 
1181 // Looks for the specified executable file according to usual search path.
1182 
1183  char *FindCommand( char *fn );
1184 
1185 // Gets search name for file by concatenating the dir, subdir, and file
1186 // name, allocating memory as needed.
1187 
1188  void GetName( char *dir, char *subdir, char *filename, char **filespec );
1189 
1190 // Prompts human to input an integer in response to given message.
1191 
1192  PLINT GetInt( char *s );
1193 
1194 // Prompts human to input a float in response to given message.
1195 
1196  PLFLT GetFlt( char *s );
1197 
1198  // Nice way to allocate space for a vectored 2d grid
1199 
1200 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
1201 
1202  void Alloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny );
1203 
1204 // Frees a block of memory allocated with plAlloc2dGrid().
1205 
1206  void Free2dGrid( PLFLT **f, PLINT nx, PLINT ny );
1207 
1208 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
1209  void MinMax2dGrid( const PLFLT * const *f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin );
1210 
1211 // Functions for converting between HLS and RGB color space
1212 
1213  void hlsrgb( PLFLT h, PLFLT l, PLFLT s,
1214  PLFLT *p_r, PLFLT *p_g, PLFLT *p_b );
1215 
1216  void rgbhls( PLFLT r, PLFLT g, PLFLT b,
1217  PLFLT *p_h, PLFLT *p_l, PLFLT *p_s );
1218 
1219 // Wait for graphics input event and translate to world coordinates
1220 
1221  PLINT GetCursor( PLGraphicsIn *plg );
1222 
1223 // Deprecated versions of methods which use PLINT instead of bool
1224  void svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, PLINT fill );
1225  void cpstrm( plstream &pls, PLINT flags );
1226  void plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
1227  PLINT nx, PLINT ny, PLINT opt, PLINT side );
1228  void poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const PLINT *draw, PLINT ifcc );
1229  void scmap1l( PLINT itype, PLINT npts, const PLFLT *intensity,
1230  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLINT *alt_hue_path );
1231 
1232  void shade( const PLFLT * const *a, PLINT nx, PLINT ny,
1233  PLDEFINED_callback defined,
1234  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1235  PLFLT shade_min, PLFLT shade_max,
1236  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1237  PLINT min_color, PLFLT min_width,
1238  PLINT max_color, PLFLT max_width,
1239  PLFILL_callback fill, PLINT rectangular,
1240  PLTRANSFORM_callback pltr, PLPointer pltr_data );
1241 
1242  void shades( const PLFLT * const *a, PLINT nx, PLINT ny, PLDEFINED_callback defined,
1243  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
1244  const PLFLT * clevel, PLINT nlevel, PLFLT fill_width,
1245  PLINT cont_color, PLFLT cont_width,
1246  PLFILL_callback fill, PLINT rectangular,
1247  PLTRANSFORM_callback pltr, PLPointer pltr_data );
1248 
1249  void shade( Contourable_Data& d, PLFLT xmin, PLFLT xmax,
1250  PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
1251  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1252  PLINT min_color, PLFLT min_width,
1253  PLINT max_color, PLFLT max_width,
1254  PLINT rectangular,
1255  Coord_Xformer *pcxf );
1256 
1257  void shade1( const PLFLT * a, PLINT nx, PLINT ny,
1258  PLDEFINED_callback defined,
1259  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1260  PLFLT shade_min, PLFLT shade_max,
1261  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1262  PLINT min_color, PLFLT min_width,
1263  PLINT max_color, PLFLT max_width,
1264  PLFILL_callback fill, PLINT rectangular,
1265  PLTRANSFORM_callback pltr, PLPointer pltr_data );
1266 
1267  void fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
1268  PLPointer f2eval_data,
1269  PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
1270  PLPointer c2eval_data,
1271  PLINT nx, PLINT ny,
1272  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1273  PLFLT shade_min, PLFLT shade_max,
1274  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1275  PLINT min_color, PLFLT min_width,
1276  PLINT max_color, PLFLT max_width,
1277  PLFILL_callback fill, PLINT rectangular,
1278  PLTRANSFORM_callback pltr, PLPointer pltr_data );
1279 
1280  void spause( PLINT pause );
1281 
1282  void stripc( PLINT *id, const char *xspec, const char *yspec,
1283  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
1284  PLFLT xlpos, PLFLT ylpos,
1285  PLINT y_ascl, PLINT acc,
1286  PLINT colbox, PLINT collab,
1287  const PLINT colline[], const PLINT styline[], const char *legline[],
1288  const char *labx, const char *laby, const char *labtop );
1289 
1290  void xormod( PLINT mode, PLINT *status );
1291 };
1292 
1293 
1294 
1295 #endif // __plstream_h__
1296 
1297 //--------------------------------------------------------------------------
1298 // end of plstream.h
1299 //--------------------------------------------------------------------------
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
static const char * name
Definition: tkMain.c:135
static char ** argv
Definition: qt.cpp:40
void(* PLTRANSFORM_callback)(PLFLT x, PLFLT y, PLFLT_NC_SCALAR xp, PLFLT_NC_SCALAR yp, PL_GENERIC_POINTER data)
Definition: plplot.h:258
void(* PLLABEL_FUNC_callback)(PLINT axis, PLFLT value, PLCHAR_NC_VECTOR label, PLINT length, PL_GENERIC_POINTER data)
Definition: plplot.h:259
Definition: plstream.h:39
void(* PLMAPFORM_callback)(PLINT n, PLFLT_NC_VECTOR x, PLFLT_NC_VECTOR y)
Definition: plplot.h:257
static void arc(PLStream *, arc_struct *)
Definition: cairo.c:1608
Definition: plstream.h:41
int min(int a, int b)
virtual PLFLT operator()(int ix, int iy) const =0
void mapform(PLINT n, PLFLT *x, PLFLT *y)
Definition: tclAPI.c:3693
PLUINT PLUNICODE
Definition: plplot.h:194
PL_NC_GENERIC_POINTER PLPointer
Definition: plplot.h:211
virtual void elements(int &nx, int &ny) const
Definition: plstream.h:50
#define plot3dc
Definition: plplot.h:774
#define plot3dcl
Definition: plplot.h:775
plstream(PLINT _stream)
Definition: plstream.h:135
PLDLLIMPEXP_CXX void tr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plstream.cc:249
Coord_2d & yg
Definition: plstream.h:75
virtual void elements(int &_nx, int &_ny)=0
Definition: plstream.h:38
PLINT(* PLDEFINED_callback)(PLFLT x, PLFLT y)
Definition: plplot.h:262
virtual void xform(PLFLT ox, PLFLT oy, PLFLT &nx, PLFLT &ny) const =0
Definition: plstream.h:41
static int sid
Definition: plstripc.c:44
Coord_2d & xg
Definition: plstream.h:74
void(* PLFILL_callback)(PLINT n, PLFLT_VECTOR x, PLFLT_VECTOR y)
Definition: plplot.h:261
int PLINT
Definition: plplot.h:174
PLINT PLBOOL
Definition: plplot.h:197
PLFLT Contourable_Data_evaluator(PLINT i, PLINT j, PLPointer p)
Definition: plstream.cc:37
static PLStrip * stripc
Definition: plstripc.c:47
static struct line line[]
void c_plsstrm(PLINT strm)
Definition: plcore.c:2600
static void gradient(PLStream *pls, short *xa, short *ya, PLINT npts)
Definition: cairo.c:1499
PLINT stream
Definition: plstream.h:118
void xform(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Contourable_Data(int nx, int ny)
Definition: plstream.h:49
static PLStream * pls[PL_NSTREAMS]
Definition: plcore.h:88
stream_id
Definition: plstream.h:35
virtual ~Coord_2d()
Definition: plstream.h:70
virtual void min_max(PLFLT &_min, PLFLT &_max)=0
Definition: plstream.h:39
static PLOptionTable options[]
Definition: tclMain.c:108
#define PLDLLIMPEXP_CXX
Definition: pldll.h:81
Definition: plstream.h:38
float PLFLT
Definition: plplot.h:157
virtual PLFLT operator()(int i, int j) const =0
static int scol0(Tcl_Interp *interp, register PlFrame *plFramePtr, int i, const char *col, int *p_changed)
Definition: plframe.c:1816
Definition: plstream.h:39
void Coord_Xform_evaluator(PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer)
Definition: plstream.cc:44
Definition: plstream.h:39
PLDLLIMPEXP_CXX void tr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plstream.cc:266
static PLINT active_streams
Definition: plstream.h:120
PLDLLIMPEXP_CXX void tr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plstream.cc:257
static char errmsg[160]
Definition: tclAPI.c:158
virtual ~Coord_Xformer()
Definition: plstream.h:60
virtual void set_stream(void)
Definition: plstream.h:129
Definition: plstream.h:33
Definition: plstream.h:38
virtual ~Contourable_Data()
Definition: plstream.h:52
PLDLLIMPEXP_CXX void tr2p(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plstream.cc:275
PLDLLIMPEXP_CXX void fill(PLINT n, const PLFLT *x, const PLFLT *y)
Definition: plstream.cc:240
#define plot3d
Definition: plplot.h:773
PLcolor
Definition: plstream.h:38