PLplot  5.12.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
plstream.cc
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 // @> Source file plstream.
26 //--------------------------------------------------------------------------
27 
28 #include "plplot.h"
29 #include "plstream.h"
30 
31 #include <iostream>
32 
33 #ifdef PL_USE_NAMESPACE
34 using namespace std;
35 #endif
36 
38 {
39  const Contourable_Data& d = *(Contourable_Data *) p;
40 
41  return d( i, j );
42 }
43 
45  PLFLT *nx, PLFLT *ny, PLPointer p )
46 {
47  const Coord_Xformer& xf = *(Coord_Xformer *) p;
48 
49  xf.xform( ox, oy, *nx, *ny );
50 }
51 
52 // A specific case for handling transformation defined by 2-d grid vertex
53 // specification matrices.
54 
56  : xg( cx ), yg( cy )
57 {
58 }
59 
60 // Next routine copied and modified for C++ from PLPLOT 4.99d.
61 
62 //--------------------------------------------------------------------------
63 // pltr2()
64 //
65 // Does linear interpolation from doubly dimensioned coord arrays
66 // (column dominant, as per normal C 2d arrays).
67 //
68 // This routine includes lots of checks for out of bounds. This would
69 // occur occasionally due to some bugs in the contour plotter (now fixed).
70 // If an out of bounds coordinate is obtained, the boundary value is provided
71 // along with a warning. These checks should stay since no harm is done if
72 // if everything works correctly.
73 //--------------------------------------------------------------------------
74 
75 void cxx_pltr2::xform( PLFLT x, PLFLT y, PLFLT& tx, PLFLT& ty ) const
76 {
77  int nx, ny;
78  xg.elements( nx, ny );
79 
80  int ul, ur, vl, vr;
81  PLFLT du, dv;
82 
83  PLFLT xll, xlr, xrl, xrr;
84  PLFLT yll, ylr, yrl, yrr;
85  PLFLT xmin, xmax, ymin, ymax;
86 
87  ul = (int) x;
88  ur = ul + 1;
89  du = x - ul;
90 
91  vl = (int) y;
92  vr = vl + 1;
93  dv = y - vl;
94 
95  xmin = 0;
96  xmax = nx - 1;
97  ymin = 0;
98  ymax = ny - 1;
99 
100  if ( x < xmin || x > xmax || y < ymin || y > ymax )
101  {
102  cerr << "cxx_pltr2::xform, Invalid coordinates\n";
103 
104  if ( x < xmin )
105  {
106  if ( y < ymin )
107  {
108  tx = xg( 0, 0 );
109  ty = yg( 0, 0 );
110  }
111  else if ( y > ymax )
112  {
113  tx = xg( 0, ny - 1 );
114  ty = yg( 0, ny - 1 );
115  }
116  else
117  {
118  xll = xg( 0, vl );
119  yll = yg( 0, vl );
120  xlr = xg( 0, vr );
121  ylr = yg( 0, vr );
122 
123  tx = xll * ( 1 - dv ) + xlr * ( dv );
124  ty = yll * ( 1 - dv ) + ylr * ( dv );
125  }
126  }
127  else if ( x > xmax )
128  {
129  if ( y < ymin )
130  {
131  tx = xg( nx - 1, 0 );
132  ty = yg( nx - 1, 0 );
133  }
134  else if ( y > ymax )
135  {
136  tx = xg( nx - 1, ny - 1 );
137  ty = yg( nx - 1, ny - 1 );
138  }
139  else
140  {
141  xll = xg( nx - 1, vl );
142  yll = yg( nx - 1, vl );
143  xlr = xg( nx - 1, vr );
144  ylr = yg( nx - 1, vr );
145 
146  tx = xll * ( 1 - dv ) + xlr * ( dv );
147  ty = yll * ( 1 - dv ) + ylr * ( dv );
148  }
149  }
150  else
151  {
152  if ( y < ymin )
153  {
154  xll = xg( ul, 0 );
155  xrl = xg( ur, 0 );
156  yll = yg( ul, 0 );
157  yrl = yg( ur, 0 );
158 
159  tx = xll * ( 1 - du ) + xrl * ( du );
160  ty = yll * ( 1 - du ) + yrl * ( du );
161  }
162  else if ( y > ymax )
163  {
164  xlr = xg( ul, ny - 1 );
165  xrr = xg( ur, ny - 1 );
166  ylr = yg( ul, ny - 1 );
167  yrr = yg( ur, ny - 1 );
168 
169  tx = xlr * ( 1 - du ) + xrr * ( du );
170  ty = ylr * ( 1 - du ) + yrr * ( du );
171  }
172  }
173  }
174 
175 // Normal case.
176 // Look up coordinates in row-dominant array.
177 // Have to handle right boundary specially -- if at the edge, we'd
178 // better not reference the out of bounds point.
179 
180  else
181  {
182  xll = xg( ul, vl );
183  yll = yg( ul, vl );
184 
185 // ur is out of bounds
186 
187  if ( ur == nx && vr < ny )
188  {
189  xlr = xg( ul, vr );
190  ylr = yg( ul, vr );
191 
192  tx = xll * ( 1 - dv ) + xlr * ( dv );
193  ty = yll * ( 1 - dv ) + ylr * ( dv );
194  }
195 
196 // vr is out of bounds
197 
198  else if ( ur < nx && vr == ny )
199  {
200  xrl = xg( ur, vl );
201  yrl = yg( ur, vl );
202 
203  tx = xll * ( 1 - du ) + xrl * ( du );
204  ty = yll * ( 1 - du ) + yrl * ( du );
205  }
206 
207 // both ur and vr are out of bounds
208 
209  else if ( ur == nx && vr == ny )
210  {
211  tx = xll;
212  ty = yll;
213  }
214 
215 // everything in bounds
216 
217  else
218  {
219  xrl = xg( ur, vl );
220  xlr = xg( ul, vr );
221  xrr = xg( ur, vr );
222 
223  yrl = yg( ur, vl );
224  ylr = yg( ul, vr );
225  yrr = yg( ur, vr );
226 
227  tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
228  xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
229 
230  ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
231  yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
232  }
233  }
234 }
235 
236 //Callbacks
237 
238 // Callback for plfill. This will just call the C plfill function
239 
240 void plcallback::fill( PLINT n, const PLFLT *x, const PLFLT *y )
241 {
242  plfill( n, x, y );
243 }
244 
245 // Transformation routines
246 
247 // Identity transformation.
248 
249 void plcallback::tr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
250  PLPointer pltr_data )
251 {
252  pltr0( x, y, tx, ty, pltr_data );
253 }
254 
255 // Does linear interpolation from singly dimensioned coord arrays.
256 
257 void plcallback::tr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
258  PLPointer pltr_data )
259 {
260  pltr1( x, y, tx, ty, pltr_data );
261 }
262 
263 // Does linear interpolation from doubly dimensioned coord arrays
264 // (column dominant, as per normal C 2d arrays).
265 
266 void plcallback::tr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
267  PLPointer pltr_data )
268 {
269  pltr2( x, y, tx, ty, pltr_data );
270 }
271 
272 // Just like pltr2() but uses pointer arithmetic to get coordinates from
273 // 2d grid tables.
274 
275 void plcallback::tr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
276  PLPointer pltr_data )
277 {
278  pltr2p( x, y, tx, ty, pltr_data );
279 }
280 
282 
284 {
285  ::c_plmkstrm( &stream );
286  //::c_plinit();
287  active_streams++;
288 }
289 
291 {
292  switch ( sid )
293  {
294  case PLS::Next:
295 // throw( "plstream ctor option not implemented." );
296  break;
297 
298  case PLS::Current:
299  ::c_plgstrm( &stream );
300  break;
301 
302  case PLS::Specific:
303  stream = strm;
304  break;
305 
306  default:
307 // throw( "plstream ctor option not implemented." );
308  break;
309  }
310 }
311 
312 plstream::plstream( PLINT nx, PLINT ny, const char *driver, const char *file )
313 {
314  ::c_plmkstrm( &stream );
315 
316  if ( driver )
317  ::c_plsdev( driver );
318  if ( file )
319  ::c_plsfnam( file );
320  ::c_plssub( nx, ny );
321  //::c_plinit();
322 
323  active_streams++;
324 }
325 
327  const char *driver, const char *file )
328 {
329  ::c_plmkstrm( &stream );
330 
331  if ( driver )
332  ::c_plsdev( driver );
333  if ( file )
334  ::c_plsfnam( file );
335  ::c_plssub( nx, ny );
336  ::c_plscolbg( r, g, b );
337  //::c_plinit();
338 
339  active_streams++;
340 }
341 
343 {
344  ::c_plsstrm( stream );
345  ::c_plend1();
346 
347  active_streams--;
348  if ( !active_streams )
349  ::c_plend();
350 }
351 
352 #define BONZAI { throw "plstream method not implemented."; }
353 
354 // C routines callable from stub routines come first
355 
356 // Advance to subpage "page", or to the next one if "page" = 0.
357 
358 void
360 {
361  set_stream();
362 
363  pladv( page );
364 }
365 
366 void
367 plstream::arc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
368  PLFLT rotate, PLBOOL fill )
369 {
370  set_stream();
371 
372  plarc( x, y, a, b, angle1, angle2, rotate, fill );
373 }
374 
375 void
376 plstream::vect( const PLFLT * const *u, const PLFLT * const *v, PLINT nx, PLINT ny, PLFLT scale,
377  PLTRANSFORM_callback pltr, PLPointer pltr_data )
378 {
379  set_stream();
380 
381  plvect( u, v, nx, ny, scale, pltr, pltr_data );
382 }
383 
384 void
385 plstream::svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, bool fill )
386 {
387  set_stream();
388 
389  plsvect( arrow_x, arrow_y, npts, (PLBOOL) fill );
390 }
391 
392 // Deprecated version using PLINT instead of bool
393 void
394 plstream::svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, PLINT fill )
395 {
396  set_stream();
397 
398  plsvect( arrow_x, arrow_y, npts, (PLBOOL) fill );
399 }
400 
401 // This functions similarly to plbox() except that the origin of the axes is
402 // placed at the user-specified point (x0, y0).
403 
404 void
405 plstream::axes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
406  const char *yopt, PLFLT ytick, PLINT nysub )
407 {
408  set_stream();
409 
410  plaxes( x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub );
411 }
412 
413 // Plot a histogram using x to store data values and y to store frequencies.
414 
415 void plstream::bin( PLINT nbin, const PLFLT *x, const PLFLT *y, PLINT center )
416 {
417  set_stream();
418 
419  plbin( nbin, x, y, center );
420 }
421 
422 // Start new page. Should only be used with pleop().
423 
425 {
426  set_stream();
427 
428  plbop();
429 }
430 
431 // This draws a box around the current viewport.
432 
433 void plstream::box( const char *xopt, PLFLT xtick, PLINT nxsub,
434  const char *yopt, PLFLT ytick, PLINT nysub )
435 {
436  set_stream();
437 
438  plbox( xopt, xtick, nxsub, yopt, ytick, nysub );
439 }
440 
441 
442 // This is the 3-d analogue of plbox().
443 
444 void
445 plstream::box3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx,
446  const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby,
447  const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz )
448 {
449  set_stream();
450 
451  plbox3( xopt, xlabel, xtick, nsubx,
452  yopt, ylabel, ytick, nsuby,
453  zopt, zlabel, ztick, nsubz );
454 }
455 
456 // Calculate broken-down time from continuous time for current stream.
457 void plstream::btime( PLINT & year, PLINT & month, PLINT & day, PLINT & hour,
458  PLINT & min, PLFLT & sec, PLFLT ctime )
459 {
460  set_stream();
461 
462  plbtime( &year, &month, &day, &hour, &min, &sec, ctime );
463 }
464 
465 // Calculate world coordinates and subpage from relative device coordinates.
466 
467 void plstream::calc_world( PLFLT rx, PLFLT ry, PLFLT & wx, PLFLT & wy,
468  PLINT & window )
469 {
470  set_stream();
471 
472  plcalc_world( rx, ry, &wx, &wy, &window );
473 }
474 
475 // Clear the current subpage.
476 
478 {
479  set_stream();
480 
481  plclear();
482 }
483 
484 // Set color, map 0. Argument is integer between 0 and 15.
485 
486 void plstream::col0( PLINT icol0 )
487 {
488  set_stream();
489 
490  plcol0( icol0 );
491 }
492 
493 // Set the color using a descriptive name. Replaces plcol0().
494 
496 {
497  set_stream();
498 
499  plcol0( (int) c );
500 }
501 
502 // Set color, map 1. Argument is a float between 0. and 1.
503 
505 {
506  set_stream();
507 
508  plcol1( c );
509 }
510 
511 // Old (incorrect) version retained only for compatibility
513 {
514  set_stream();
515 
516  cerr <<
517  "plstream::col(PLFLT c) : function deprecated. Use plstream::col1(PLFLT c) instead"
518  << endl;
519 
520  plcol1( c );
521 }
522 
523 // Configure transformation between continuous and broken-down time (and
524 // vice versa) for current stream.
525 void plstream::configtime( PLFLT scale, PLFLT offset1, PLFLT offset2,
526  PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year,
527  PLINT month, PLINT day, PLINT hour, PLINT min,
528  PLFLT sec )
529 {
530  set_stream();
531 
532  plconfigtime( scale, offset1, offset2, ccontrol, ifbtime_offset, year,
533  month, day, hour, min, sec );
534 }
535 
536 
537 
538 // Draws a contour plot from data in f(nx,ny). Is just a front-end to
539 // plfcont, with a particular choice for f2eval and f2eval_data.
540 
541 void plstream::cont( const PLFLT * const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx,
542  PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel,
543  PLTRANSFORM_callback pltr, PLPointer pltr_data )
544 {
545  set_stream();
546 
547  plcont( f, nx, ny, kx, lx, ky, ly, clevel, nlevel,
548  pltr, pltr_data );
549 }
550 
551 // Draws a contour plot using the function evaluator f2eval and data stored
552 // by way of the f2eval_data pointer. This allows arbitrary organizations
553 // of 2d array data to be used.
554 
555 void plstream::fcont( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
556  PLPointer f2eval_data,
557  PLINT nx, PLINT ny, PLINT kx, PLINT lx,
558  PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel,
559  PLTRANSFORM_callback pltr, PLPointer pltr_data )
560 {
561  set_stream();
562 
563  plfcont( f2eval, f2eval_data,
564  nx, ny, kx, lx, ky, ly, clevel, nlevel,
565  pltr, pltr_data );
566 }
567 
568 // Copies state parameters from the reference stream to the current stream.
569 
570 void plstream::cpstrm( plstream & pls, bool flags )
571 {
572  set_stream();
573 
574  plcpstrm( pls.stream, (PLBOOL) flags );
575 }
576 
577 // Deprecated version using PLINT not bool
579 {
580  set_stream();
581 
582  plcpstrm( pls.stream, (PLBOOL) flags );
583 }
584 
585 // Calculate continuous time from broken-down time for current stream.
586 void plstream::ctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min,
587  PLFLT sec, PLFLT & ctime )
588 {
589  set_stream();
590 
591  plctime( year, month, day, hour, min, sec, &ctime );
592 }
593 
594 // Converts input values from relative device coordinates to relative plot
595 // coordinates.
596 
597 void plstream::did2pc( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
598 {
599  set_stream();
600 
601  pldid2pc( &xmin, &ymin, &xmax, &ymax );
602 }
603 
604 // Converts input values from relative plot coordinates to relative device
605 // coordinates.
606 
607 void plstream::dip2dc( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
608 {
609  set_stream();
610 
611  pldip2dc( &xmin, &ymin, &xmax, &ymax );
612 }
613 
614 // These shouldn't be needed, are supposed to be handled by ctor/dtor
615 // semantics of the plstream object.
616 
617 // End a plotting session for all open streams.
618 
619 // void plstream::end()
620 // {
621 // set_stream();
622 
623 // plend();
624 // }
625 
626 // End a plotting session for the current stream only.
627 
628 // void plstream::end1()
629 // {
630 // set_stream();
631 
632 // plend1();
633 // }
634 
635 // Simple interface for defining viewport and window.
636 
637 void plstream::env( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
638  PLINT just, PLINT axis )
639 {
640  set_stream();
641 
642  plenv( xmin, xmax, ymin, ymax, just, axis );
643 }
644 
645 // Similar to env() above, but in multiplot mode does not advance
646 // the subpage, instead the current subpage is cleared
647 
648 void plstream::env0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
649  PLINT just, PLINT axis )
650 {
651  set_stream();
652 
653  plenv0( xmin, xmax, ymin, ymax, just, axis );
654 }
655 
656 // End current page. Should only be used with plbop().
657 
659 {
660  set_stream();
661 
662  pleop();
663 }
664 
665 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i)).
666 
667 void plstream::errx( PLINT n, const PLFLT *xmin, const PLFLT *xmax, const PLFLT *y )
668 {
669  set_stream();
670 
671  plerrx( n, xmin, xmax, y );
672 }
673 
674 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i)).
675 
676 void plstream::erry( PLINT n, const PLFLT *x, const PLFLT *ymin, const PLFLT *ymax )
677 {
678  set_stream();
679 
680  plerry( n, x, ymin, ymax );
681 }
682 
683 // Advance to the next family file on the next new page.
684 
686 {
687  set_stream();
688 
689  plfamadv();
690 }
691 
692 // Pattern fills the polygon bounded by the input points.
693 
694 void plstream::fill( PLINT n, const PLFLT *x, const PLFLT *y )
695 {
696  set_stream();
697 
698  plfill( n, x, y );
699 }
700 
701 // Pattern fills the 3d polygon bounded by the input points.
702 
703 void plstream::fill3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z )
704 {
705  set_stream();
706 
707  plfill3( n, x, y, z );
708 }
709 
710 // Flushes the output stream. Use sparingly, if at all.
711 
713 {
714  set_stream();
715 
716  ::c_plflush();
717 }
718 
719 // Sets the global font flag to 'ifont'.
720 
721 void plstream::font( PLINT ifont )
722 {
723  set_stream();
724 
725  plfont( ifont );
726 }
727 
728 // Load specified font set.
729 
731 {
732  set_stream();
733 
734  plfontld( fnt );
735 }
736 
737 // Get character default height and current (scaled) height.
738 
739 void plstream::gchr( PLFLT & p_def, PLFLT & p_ht )
740 {
741  set_stream();
742 
743  plgchr( &p_def, &p_ht );
744 }
745 
746 // Returns 8 bit RGB values for given color from color map 0.
747 
748 void plstream::gcol0( PLINT icol0, PLINT & r, PLINT & g, PLINT & b )
749 {
750  set_stream();
751 
752  plgcol0( icol0, &r, &g, &b );
753 }
754 
755 // Returns 8 bit RGB values + alpha value for given color from color map 0.
756 
757 void plstream::gcol0a( PLINT icol0, PLINT & r, PLINT & g, PLINT & b, PLFLT & a )
758 {
759  set_stream();
760 
761  plgcol0a( icol0, &r, &g, &b, &a );
762 }
763 
764 // Returns the background color by 8 bit RGB value.
765 
766 void plstream::gcolbg( PLINT & r, PLINT & g, PLINT & b )
767 {
768  set_stream();
769 
770  plgcolbg( &r, &g, &b );
771 }
772 
773 // Returns the background color by 8 bit RGB value + alpha value.
774 
775 void plstream::gcolbga( PLINT & r, PLINT & g, PLINT & b, PLFLT & a )
776 {
777  set_stream();
778 
779  plgcolbga( &r, &g, &b, &a );
780 }
781 
782 // Returns the current compression setting
783 
784 void plstream::gcompression( PLINT & compression )
785 {
786  set_stream();
787 
788  plgcompression( &compression );
789 }
790 
791 // Retrieve current window into device space.
792 
793 void plstream::gdidev( PLFLT & mar, PLFLT & aspect, PLFLT & jx, PLFLT & jy )
794 {
795  set_stream();
796 
797  plgdidev( &mar, &aspect, &jx, &jy );
798 }
799 
800 // Get plot orientation.
801 
802 void plstream::gdiori( PLFLT & rot )
803 {
804  set_stream();
805 
806  plgdiori( &rot );
807 }
808 
809 // Retrieve current window into plot space.
810 
811 void plstream::gdiplt( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
812 {
813  set_stream();
814 
815  plgdiplt( &xmin, &ymin, &xmax, &ymax );
816 }
817 
818 // Get FCI (font characterization integer)
819 
820 void plstream::gfci( PLUNICODE & pfci )
821 {
822  set_stream();
823 
824  plgfci( &pfci );
825 }
826 
827 // Get family file parameters.
828 
829 void plstream::gfam( PLINT & fam, PLINT & num, PLINT & bmax )
830 {
831  set_stream();
832 
833  plgfam( &fam, &num, &bmax );
834 }
835 
836 // Get the (current) output file name. Must be preallocated to >80 bytes.
837 
838 void plstream::gfnam( char *fnam )
839 {
840  set_stream();
841 
842  plgfnam( fnam );
843 }
844 
845 // Get the current font family, style and weight
846 
847 void plstream::gfont( PLINT & family, PLINT & style, PLINT & weight )
848 {
849  set_stream();
850 
851  plgfont( &family, &style, &weight );
852 }
853 
854 // Get current run level.
855 
856 void plstream::glevel( PLINT & level )
857 {
858  set_stream();
859 
860  plglevel( &level );
861 }
862 
863 // Get output device parameters.
864 
865 void plstream::gpage( PLFLT & xp, PLFLT & yp, PLINT & xleng, PLINT & yleng,
866  PLINT & xoff, PLINT & yoff )
867 {
868  set_stream();
869 
870  plgpage( &xp, &yp, &xleng, &yleng, &xoff, &yoff );
871 }
872 
873 // Switches to graphics screen.
874 
876 {
877  set_stream();
878 
879  plgra();
880 }
881 
882 
883 // Draw gradient in polygon.
884 
885 void plstream::gradient( PLINT n, const PLFLT *x, const PLFLT *y, PLFLT angle )
886 {
887  set_stream();
888 
889  plgradient( n, x, y, angle );
890 }
891 
892 // grid irregularly sampled data
893 void plstream::griddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts,
894  const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy,
895  PLFLT **zg, PLINT type, PLFLT data )
896 {
897  set_stream();
898 
899  plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data );
900 }
901 
902 // Get subpage boundaries in absolute coordinates.
903 
904 void plstream::gspa( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
905 {
906  set_stream();
907 
908  plgspa( &xmin, &xmax, &ymin, &ymax );
909 }
910 
911 // This shouldn't be needed in this model.
912 
913 // Get current stream number.
914 
915 // void plstream::gstrm( PLINT *p_strm )
916 // {
917 // set_stream();
918 
919 // plgstrm(p_strm);
920 // }
921 
922 // Get the current library version number.
923 
924 void plstream::gver( char *p_ver )
925 {
926  set_stream();
927 
928  plgver( p_ver );
929 }
930 
931 // Get viewport window in normalized world coordinates
932 
933 void plstream::gvpd( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
934 {
935  set_stream();
936 
937  plgvpd( &xmin, &xmax, &ymin, &ymax );
938 }
939 
940 // Get viewport window in world coordinates
941 
942 void plstream::gvpw( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
943 {
944  set_stream();
945 
946  plgvpw( &xmin, &xmax, &ymin, &ymax );
947 }
948 
949 // Get x axis labeling parameters.
950 
951 void plstream::gxax( PLINT & digmax, PLINT & digits )
952 {
953  set_stream();
954 
955  plgxax( &digmax, &digits );
956 }
957 
958 // Get y axis labeling parameters.
959 
960 void plstream::gyax( PLINT & digmax, PLINT & digits )
961 {
962  set_stream();
963 
964  plgyax( &digmax, &digits );
965 }
966 
967 // Get z axis labeling parameters
968 
969 void plstream::gzax( PLINT & digmax, PLINT & digits )
970 {
971  set_stream();
972 
973  plgzax( &digmax, &digits );
974 }
975 
976 // Draws a histogram of n values of a variable in array data[0..n-1]
977 
978 void plstream::hist( PLINT n, const PLFLT *data, PLFLT datmin, PLFLT datmax,
979  PLINT nbin, PLINT oldwin )
980 {
981  set_stream();
982 
983  plhist( n, data, datmin, datmax, nbin, oldwin );
984 }
985 
986 // Set current color (map 0) by hue, lightness, and saturation.
987 
988 #ifdef PL_DEPRECATED
989 void plstream::hls( PLFLT h, PLFLT l, PLFLT s )
990 {
991  set_stream();
992 
993  plhls( h, l, s );
994 }
995 #endif // PL_DEPRECATED
996 
997 // Initializes PLplot, using preset or default options
998 
1000 {
1001  set_stream();
1002 
1003  plinit();
1004 
1005  plgstrm( &stream );
1006 
1007  // This is only set in the constructor.
1008  //active_streams++;
1009 }
1010 
1011 // Draws a line segment from (x1, y1) to (x2, y2).
1012 
1013 void plstream::join( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 )
1014 {
1015  set_stream();
1016 
1017  pljoin( x1, y1, x2, y2 );
1018 }
1019 
1020 // Simple routine for labelling graphs.
1021 
1022 void plstream::lab( const char *xlabel, const char *ylabel,
1023  const char *tlabel )
1024 {
1025  set_stream();
1026 
1027  pllab( xlabel, ylabel, tlabel );
1028 }
1029 
1030 // Routine for drawing line, symbol, or cmap0 legends
1031 
1032 void plstream::legend( PLFLT *p_legend_width, PLFLT *p_legend_height,
1033  PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
1034  PLINT bg_color, PLINT bb_color, PLINT bb_style,
1035  PLINT nrow, PLINT ncolumn,
1036  PLINT nlegend, const PLINT *opt_array,
1037  PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
1038  PLFLT text_justification,
1039  const PLINT *text_colors, const char * const *text,
1040  const PLINT *box_colors, const PLINT *box_patterns,
1041  const PLFLT *box_scales, const PLFLT *box_line_widths,
1042  const PLINT *line_colors, const PLINT *line_styles,
1043  const PLFLT *line_widths,
1044  const PLINT *symbol_colors, const PLFLT *symbol_scales,
1045  const PLINT *symbol_numbers, const char * const *symbols )
1046 {
1047  set_stream();
1048 
1049  pllegend( p_legend_width, p_legend_height, opt, position, x, y, plot_width,
1050  bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array,
1051  text_offset, text_scale, text_spacing, text_justification,
1052  text_colors, text, box_colors, box_patterns, box_scales,
1053  box_line_widths, line_colors, line_styles, line_widths,
1054  symbol_colors, symbol_scales, symbol_numbers, symbols );
1055 }
1056 
1057 void plstream::colorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
1058  PLINT opt, PLINT position, PLFLT x, PLFLT y,
1059  PLFLT x_length, PLFLT y_length,
1060  PLINT bg_color, PLINT bb_color, PLINT bb_style,
1061  PLFLT low_cap_color, PLFLT high_cap_color,
1062  PLINT cont_color, PLFLT cont_width,
1063  PLINT n_labels, PLINT *label_opts, const char * const *label,
1064  PLINT n_axes, const char * const *axis_opts,
1065  PLFLT *ticks, PLINT *sub_ticks,
1066  PLINT *n_values, const PLFLT * const *values )
1067 {
1068  set_stream();
1069 
1070  plcolorbar( p_colorbar_width, p_colorbar_height, opt, position, x, y,
1071  x_length, y_length, bg_color, bb_color, bb_style,
1072  low_cap_color, high_cap_color, cont_color, cont_width,
1073  n_labels, label_opts, label, n_axes, axis_opts,
1074  ticks, sub_ticks, n_values, values );
1075 }
1076 
1077 
1078 // Sets position of the light source
1079 
1081 {
1082  set_stream();
1083 
1084  pllightsource( x, y, z );
1085 }
1086 
1087 // Draws line segments connecting a series of points.
1088 
1089 void plstream::line( PLINT n, const PLFLT *x, const PLFLT *y )
1090 {
1091  set_stream();
1092 
1093  plline( n, x, y );
1094 }
1095 
1096 // Draws a line in 3 space.
1097 
1098 void plstream::line3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z )
1099 {
1100  set_stream();
1101 
1102  plline3( n, x, y, z );
1103 }
1104 
1105 // Set line style.
1106 
1108 {
1109  set_stream();
1110 
1111  pllsty( lin );
1112 }
1113 
1114 // Plot continental outline in world coordinates
1115 
1117  const char *name, PLFLT minx, PLFLT maxx,
1118  PLFLT miny, PLFLT maxy )
1119 {
1120  set_stream();
1121 
1122  plmap( mapform, name, minx, maxx, miny, maxy );
1123 }
1124 
1125 // Plot map lines
1126 
1128  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1129  const PLINT *plotentries, PLINT nplotentries )
1130 {
1131  set_stream();
1132 
1133  plmapline( mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries );
1134 }
1135 
1136 // Plot map points
1137 
1139  const char *name, const char *string,
1140  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1141  const PLINT *plotentries, PLINT nplotentries )
1142 {
1143  set_stream();
1144 
1145  plmapstring( mapform, name, string, minx, maxx, miny, maxy, plotentries, nplotentries );
1146 }
1147 
1148 // Plot map text
1149 
1151  const char *name, PLFLT dx, PLFLT dy, PLFLT just, const char *text,
1152  PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy,
1153  PLINT plotentry )
1154 {
1155  set_stream();
1156 
1157  plmaptex( mapform, name, dx, dy, just, text, minx, maxx, miny, maxy, plotentry );
1158 }
1159 
1160 // Plot map fills
1161 
1163  const char *name, PLFLT minx, PLFLT maxx, PLFLT miny,
1164  PLFLT maxy, const PLINT *plotentries, PLINT nplotentries )
1165 {
1166  set_stream();
1167 
1168  plmapfill( mapform, name, minx, maxx, miny, maxy, plotentries, nplotentries );
1169 }
1170 
1171 // Plot the latitudes and longitudes on the background.
1172 
1174  PLFLT dlong, PLFLT dlat,
1175  PLFLT minlong, PLFLT maxlong,
1176  PLFLT minlat, PLFLT maxlat )
1177 {
1178  set_stream();
1179 
1180  plmeridians( mapform, dlong, dlat, minlong, maxlong, minlat,
1181  maxlat );
1182 }
1183 
1184 // Plots a mesh representation of the function z[x][y].
1185 
1186 void plstream::mesh( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny,
1187  PLINT opt )
1188 {
1189  set_stream();
1190 
1191  plmesh( x, y, z, nx, ny, opt );
1192 }
1193 
1194 // Plots a mesh representation of the function z[x][y] with contour.
1195 
1196 void plstream::meshc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny,
1197  PLINT opt, const PLFLT *clevel, PLINT nlevel )
1198 {
1199  set_stream();
1200 
1201  plmeshc( x, y, z, nx, ny, opt, clevel, nlevel );
1202 }
1203 
1204 // Creates a new stream and makes it the default.
1205 
1206 // void plstream::mkstrm( PLINT *p_strm )
1207 // {
1208 // set_stream();
1209 
1210 // plmkstrm(p_strm);
1211 // }
1212 
1213 // Prints out "text" at specified position relative to viewport
1214 
1215 void plstream::mtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
1216  const char *text )
1217 {
1218  set_stream();
1219 
1220  plmtex( side, disp, pos, just, text );
1221 }
1222 
1223 // Prints out "text" at specified position relative to viewport (3D)
1224 
1225 void plstream::mtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
1226  const char *text )
1227 {
1228  set_stream();
1229 
1230  plmtex3( side, disp, pos, just, text );
1231 }
1232 
1233 // Plots a 3-d shaded representation of the function z[x][y].
1234 
1235 void plstream::surf3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
1236  PLINT nx, PLINT ny, PLINT opt,
1237  const PLFLT *clevel, PLINT nlevel )
1238 {
1239  set_stream();
1240 
1241  plsurf3d( x, y, z, nx, ny, opt, clevel, nlevel );
1242 }
1243 
1244 // Plots a 3-d shaded representation of the function z[x][y] with
1245 // y index limits
1246 
1247 void plstream::surf3dl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
1248  PLINT nx, PLINT ny, PLINT opt,
1249  const PLFLT *clevel, PLINT nlevel,
1250  PLINT ixstart, PLINT ixn,
1251  const PLINT *indexymin, const PLINT *indexymax )
1252 {
1253  set_stream();
1254 
1255  plsurf3dl( x, y, z, nx, ny, opt, clevel, nlevel, ixstart, ixn,
1256  indexymin, indexymax );
1257 }
1258 
1259 // Plots a 3-d representation of the function z[x][y].
1260 
1261 void plstream::plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
1262  PLINT nx, PLINT ny, PLINT opt, bool side )
1263 {
1264  set_stream();
1265 
1266  ::plot3d( x, y, z, nx, ny, opt, (PLBOOL) side );
1267 }
1268 
1269 // Deprecated version using PLINT not bool
1270 void plstream::plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
1271  PLINT nx, PLINT ny, PLINT opt, PLINT side )
1272 {
1273  set_stream();
1274 
1275  ::plot3d( x, y, z, nx, ny, opt, (PLBOOL) side );
1276 }
1277 
1278 // Plots a 3-d representation of the function z[x][y] with contour.
1279 
1280 void plstream::plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
1281  PLINT nx, PLINT ny, PLINT opt,
1282  const PLFLT *clevel, PLINT nlevel )
1283 {
1284  set_stream();
1285 
1286  ::plot3dc( x, y, z, nx, ny, opt, clevel, nlevel );
1287 }
1288 
1289 // Plots a 3-d representation of the function z[x][y] with contour
1290 // and y index limits
1291 
1292 void plstream::plot3dcl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
1293  PLINT nx, PLINT ny, PLINT opt,
1294  const PLFLT *clevel, PLINT nlevel,
1295  PLINT ixstart, PLINT ixn,
1296  const PLINT *indexymin, const PLINT *indexymax )
1297 {
1298  set_stream();
1299 
1300  ::plot3dcl( x, y, z, nx, ny, opt, clevel, nlevel, ixstart, ixn,
1301  indexymin, indexymax );
1302 }
1303 
1304 // Process options list using current options info.
1305 
1306 PLINT plstream::parseopts( int *p_argc, char **argv, PLINT mode )
1307 {
1308  set_stream();
1309 
1310  return ::plparseopts( p_argc, argv, mode );
1311 }
1312 
1313 // Set fill pattern directly.
1314 
1315 void plstream::pat( PLINT nlin, const PLINT *inc, const PLINT *del )
1316 {
1317  set_stream();
1318 
1319  plpat( nlin, inc, del );
1320 }
1321 
1322 // Draw a line connecting two points, accounting for coordinate transforms
1323 
1324 void plstream::path( PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 )
1325 {
1326  set_stream();
1327 
1328  plpath( n, x1, y1, x2, y2 );
1329 }
1330 
1331 // Plots array y against x for n points using ASCII code "code".
1332 
1333 void plstream::poin( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code )
1334 {
1335  set_stream();
1336 
1337  plpoin( n, x, y, code );
1338 }
1339 
1340 // Draws a series of points in 3 space.
1341 
1342 void plstream::poin3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT code )
1343 {
1344  set_stream();
1345 
1346  plpoin3( n, x, y, z, code );
1347 }
1348 
1349 // Draws a polygon in 3 space.
1350 
1351 void plstream::poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z,
1352  const bool *draw, bool ifcc )
1353 {
1354  PLBOOL *loc_draw = new PLBOOL[n - 1];
1355  for ( int i = 0; i < n - 1; i++ )
1356  {
1357  loc_draw[i] = (PLBOOL) draw[i];
1358  }
1359 
1360  set_stream();
1361 
1362  plpoly3( n, x, y, z, loc_draw, (PLBOOL) ifcc );
1363 
1364  delete [] loc_draw;
1365 }
1366 
1367 // Deprecated version using PLINT not bool
1368 void plstream::poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z,
1369  const PLINT *draw, PLINT ifcc )
1370 {
1371  PLBOOL *loc_draw = new PLBOOL[n - 1];
1372  for ( int i = 0; i < n - 1; i++ )
1373  {
1374  loc_draw[i] = (PLBOOL) draw[i];
1375  }
1376 
1377  set_stream();
1378 
1379  plpoly3( n, x, y, z, loc_draw, (PLBOOL) ifcc );
1380 
1381  delete [] loc_draw;
1382 }
1383 
1384 // Set the floating point precision (in number of places) in numeric labels.
1385 
1386 void plstream::prec( PLINT setp, PLINT prec )
1387 {
1388  set_stream();
1389 
1390  plprec( setp, prec );
1391 }
1392 
1393 // Set fill pattern, using one of the predefined patterns.
1394 
1395 void plstream::psty( PLINT patt )
1396 {
1397  set_stream();
1398 
1399  plpsty( patt );
1400 }
1401 
1402 // Prints out "text" at world cooordinate (x,y).
1403 
1404 void plstream::ptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just,
1405  const char *text )
1406 {
1407  set_stream();
1408 
1409  plptex( x, y, dx, dy, just, text );
1410 }
1411 
1412 // Prints out "text" at world cooordinate (x,y).
1413 
1415  PLFLT dx, PLFLT dy, PLFLT dz,
1416  PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just,
1417  const char *text )
1418 {
1419  set_stream();
1420 
1421  plptex3( wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text );
1422 }
1423 
1424 // Get the world coordinates associated with device coordinates
1425 
1427 {
1428  set_stream();
1429 
1430  return plTranslateCursor( gin );
1431 }
1432 
1433 // Replays contents of plot buffer to current device/file.
1434 
1436 {
1437  set_stream();
1438 
1439  plreplot();
1440 }
1441 
1442 // Set line color by red, green, blue from 0. to 1.
1443 
1444 #ifdef PL_DEPRECATED
1445 void plstream::rgb( PLFLT r, PLFLT g, PLFLT b )
1446 {
1447  set_stream();
1448 
1449  plrgb( r, g, b );
1450 }
1451 #endif // PL_DEPRECATED
1452 
1453 // Set line color by 8 bit RGB values.
1454 
1455 #ifdef PL_DEPRECATED
1456 void plstream::rgb( PLINT r, PLINT g, PLINT b )
1457 {
1458  set_stream();
1459 
1460  plrgb1( r, g, b );
1461 }
1462 #endif // PL_DEPRECATED
1463 
1464 // Set character height.
1465 
1466 void plstream::schr( PLFLT def, PLFLT scale )
1467 {
1468  set_stream();
1469 
1470  plschr( def, scale );
1471 }
1472 
1473 // Set number of colors in cmap 0
1474 
1476 {
1477  set_stream();
1478 
1479  plscmap0n( ncol0 );
1480 }
1481 
1482 // Set number of colors in cmap 1
1483 
1485 {
1486  set_stream();
1487 
1488  plscmap1n( ncol1 );
1489 }
1490 
1491 // Set number of colors in cmap 1
1492 
1493 void plstream::scmap1_range( PLFLT min_color, PLFLT max_color )
1494 {
1495  set_stream();
1496 
1497  plscmap1_range( min_color, max_color );
1498 }
1499 
1500 // Set number of colors in cmap 1
1501 
1502 void plstream::gcmap1_range( PLFLT & min_color, PLFLT & max_color )
1503 {
1504  set_stream();
1505 
1506  plgcmap1_range( &min_color, &max_color );
1507 }
1508 
1509 // Set color map 0 colors by 8 bit RGB values
1510 
1511 void plstream::scmap0( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol0 )
1512 {
1513  set_stream();
1514 
1515  plscmap0( r, g, b, ncol0 );
1516 }
1517 
1518 // Set color map 0 colors by 8 bit RGB values + alpha value
1519 
1520 void plstream::scmap0a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol0 )
1521 {
1522  set_stream();
1523 
1524  plscmap0a( r, g, b, a, ncol0 );
1525 }
1526 
1527 // Set color map 1 colors by 8 bit RGB values
1528 
1529 void plstream::scmap1( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol1 )
1530 {
1531  set_stream();
1532 
1533  plscmap1( r, g, b, ncol1 );
1534 }
1535 
1536 // Set color map 1 colors by 8 bit RGB values + alpha value
1537 
1538 void plstream::scmap1a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol1 )
1539 {
1540  set_stream();
1541 
1542  plscmap1a( r, g, b, a, ncol1 );
1543 }
1544 
1545 // Set color map 1 colors using a piece-wise linear relationship between
1546 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
1547 
1548 void plstream::scmap1l( bool itype, PLINT npts, const PLFLT *intensity,
1549  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
1550  const bool *alt_hue_path )
1551 {
1552  PLBOOL *loc_alt_hue_path = NULL;
1553  if ( alt_hue_path != NULL )
1554  {
1555  loc_alt_hue_path = new PLBOOL[npts - 1];
1556  for ( int i = 0; i < npts - 1; i++ )
1557  {
1558  loc_alt_hue_path[i] = (PLBOOL) alt_hue_path[i];
1559  }
1560  }
1561 
1562  set_stream();
1563 
1564  plscmap1l( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3, loc_alt_hue_path );
1565 
1566  if ( loc_alt_hue_path != NULL )
1567  delete [] loc_alt_hue_path;
1568 }
1569 
1570 // Set color map 1 colors using a piece-wise linear relationship between
1571 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space
1572 // and alpha value.
1573 
1574 void plstream::scmap1la( bool itype, PLINT npts, const PLFLT *intensity,
1575  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
1576  const PLFLT *a, const bool *alt_hue_path )
1577 {
1578  PLBOOL *loc_alt_hue_path = NULL;
1579  if ( alt_hue_path != NULL )
1580  {
1581  loc_alt_hue_path = new PLBOOL[npts - 1];
1582  for ( int i = 0; i < npts - 1; i++ )
1583  {
1584  loc_alt_hue_path[i] = (PLBOOL) alt_hue_path[i];
1585  }
1586  }
1587 
1588  set_stream();
1589 
1590  plscmap1la( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3,
1591  a, loc_alt_hue_path );
1592 
1593  if ( loc_alt_hue_path != NULL )
1594  delete [] loc_alt_hue_path;
1595 }
1596 
1597 //
1598 // void plstream::scmap1l( bool itype, PLINT npts, PLFLT *intensity,
1599 // PLFLT *coord1, PLFLT *coord2, PLFLT *coord3)
1600 // {
1601 // set_stream();
1602 //
1603 // plscmap1l((PLBOOL) itype,npts,intensity,coord1,coord2,coord3,NULL);
1604 //
1605 // }
1606 
1607 // Deprecated version using PLINT instead of bool
1608 void plstream::scmap1l( PLINT itype, PLINT npts, const PLFLT *intensity,
1609  const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
1610  const PLINT *alt_hue_path )
1611 {
1612  PLBOOL *loc_alt_hue_path = NULL;
1613  if ( alt_hue_path != NULL )
1614  {
1615  loc_alt_hue_path = new PLBOOL[npts - 1];
1616  for ( int i = 0; i < npts - 1; i++ )
1617  {
1618  loc_alt_hue_path[i] = (PLBOOL) alt_hue_path[i];
1619  }
1620  }
1621 
1622  set_stream();
1623 
1624  plscmap1l( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3, loc_alt_hue_path );
1625 
1626  if ( loc_alt_hue_path != NULL )
1627  delete [] loc_alt_hue_path;
1628 }
1629 
1630 // Set a given color from color map 0 by 8 bit RGB value
1631 
1632 void plstream::scol0( PLINT icol0, PLINT r, PLINT g, PLINT b )
1633 {
1634  set_stream();
1635 
1636  plscol0( icol0, r, g, b );
1637 }
1638 
1639 // Set a given color from color map 0 by 8 bit RGB value + alpha value
1640 
1641 void plstream::scol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a )
1642 {
1643  set_stream();
1644 
1645  plscol0a( icol0, r, g, b, a );
1646 }
1647 
1648 // Set the background color by 8 bit RGB value
1649 
1651 {
1652  set_stream();
1653 
1654  plscolbg( r, g, b );
1655 }
1656 
1657 // Set the background color by 8 bit RGB + alpha value
1658 
1660 {
1661  set_stream();
1662 
1663  plscolbga( r, g, b, a );
1664 }
1665 
1666 // Used to globally turn color output on/off
1667 
1669 {
1670  set_stream();
1671 
1672  plscolor( color );
1673 }
1674 
1675 // Sets the compression level
1676 
1677 void plstream::scompression( PLINT compression )
1678 {
1679  set_stream();
1680 
1681  plscompression( compression );
1682 }
1683 
1684 // Set the device (keyword) name
1685 
1686 void plstream::sdev( const char *devname )
1687 {
1688  set_stream();
1689 
1690  plsdev( devname );
1691 }
1692 
1693 // Get the device (keyword) name
1694 
1695 void plstream::gdev( char *devname )
1696 {
1697  set_stream();
1698 
1699  plgdev( devname );
1700 }
1701 
1702 // Set window into device space using margin, aspect ratio, and
1703 // justification
1704 
1705 void plstream::sdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy )
1706 {
1707  set_stream();
1708 
1709  plsdidev( mar, aspect, jx, jy );
1710 }
1711 
1712 // Set up transformation from metafile coordinates.
1713 
1714 void plstream::sdimap( PLINT dimxmin, PLINT dimxmax,
1715  PLINT dimymin, PLINT dimymax,
1716  PLFLT dimxpmm, PLFLT dimypmm )
1717 {
1718  set_stream();
1719 
1720  plsdimap( dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm );
1721 }
1722 
1723 // Set plot orientation, specifying rotation in units of pi/2.
1724 
1726 {
1727  set_stream();
1728 
1729  plsdiori( rot );
1730 }
1731 
1732 // Set window into plot space
1733 
1734 void plstream::sdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax )
1735 {
1736  set_stream();
1737 
1738  plsdiplt( xmin, ymin, xmax, ymax );
1739 }
1740 
1741 // Set window into plot space incrementally (zoom)
1742 
1743 void plstream::sdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax )
1744 {
1745  set_stream();
1746 
1747  plsdiplz( xmin, ymin, xmax, ymax );
1748 }
1749 
1750 // Set the escape character for text strings.
1751 
1752 void plstream::sesc( char esc )
1753 {
1754  set_stream();
1755 
1756  plsesc( esc );
1757 }
1758 
1759 // Set the offset and spacing of contour labels
1760 
1761 void plstream::setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing,
1762  PLINT active )
1763 {
1764  set_stream();
1765 
1766  pl_setcontlabelparam( offset, size, spacing, active );
1767 }
1768 
1769 // Set the format of the contour labels
1770 
1772 {
1773  set_stream();
1774 
1775  pl_setcontlabelformat( lexp, sigdig );
1776 }
1777 
1778 // Set family file parameters
1779 
1780 void plstream::sfam( PLINT fam, PLINT num, PLINT bmax )
1781 {
1782  set_stream();
1783 
1784  plsfam( fam, num, bmax );
1785 }
1786 
1787 // Set FCI (font characterization integer)
1788 
1790 {
1791  set_stream();
1792 
1793  plsfci( fci );
1794 }
1795 
1796 // Set the output file name.
1797 
1798 void plstream::sfnam( const char *fnam )
1799 {
1800  set_stream();
1801 
1802  plsfnam( fnam );
1803 }
1804 
1805 // Set the pointer to the data used in driver initialisation
1806 
1807 void plstream::sdevdata( void *data )
1808 {
1809  set_stream();
1810 
1811  plsdevdata( data );
1812 }
1813 
1814 // Set the current font family, style and weight
1815 
1816 void plstream::sfont( PLINT family, PLINT style, PLINT weight )
1817 {
1818  set_stream();
1819 
1820  plsfont( family, style, weight );
1821 }
1822 
1823 // Shade region.
1824 
1825 void
1826 plstream::shade( const PLFLT * const *a, PLINT nx, PLINT ny,
1827  PLDEFINED_callback defined,
1828  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1829  PLFLT shade_min, PLFLT shade_max,
1830  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1831  PLINT min_color, PLFLT min_width,
1832  PLINT max_color, PLFLT max_width,
1833  PLFILL_callback fill, bool rectangular,
1834  PLTRANSFORM_callback pltr, PLPointer pltr_data )
1835 {
1836  set_stream();
1837 
1838  plshade( a, nx, ny, defined, left, right, bottom, top,
1839  shade_min, shade_max,
1840  sh_cmap, sh_color, sh_width,
1841  min_color, min_width, max_color, max_width,
1842  fill, (PLBOOL) rectangular, pltr, pltr_data );
1843 }
1844 
1845 // Deprecated version using PLINT instead of bool
1846 void
1847 plstream::shade( const PLFLT * const *a, PLINT nx, PLINT ny,
1848  PLDEFINED_callback defined,
1849  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1850  PLFLT shade_min, PLFLT shade_max,
1851  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1852  PLINT min_color, PLFLT min_width,
1853  PLINT max_color, PLFLT max_width,
1854  PLFILL_callback fill, PLINT rectangular,
1855  PLTRANSFORM_callback pltr, PLPointer pltr_data )
1856 {
1857  set_stream();
1858 
1859  plshade( a, nx, ny, defined, left, right, bottom, top,
1860  shade_min, shade_max,
1861  sh_cmap, sh_color, sh_width,
1862  min_color, min_width, max_color, max_width,
1863  fill, (PLBOOL) rectangular, pltr, pltr_data );
1864 }
1865 
1866 void
1867 plstream::shades( const PLFLT * const *a, PLINT nx, PLINT ny,
1868  PLDEFINED_callback defined,
1869  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
1870  const PLFLT *clevel, PLINT nlevel, PLFLT fill_width,
1871  PLINT cont_color, PLFLT cont_width,
1872  PLFILL_callback fill, bool rectangular,
1873  PLTRANSFORM_callback pltr, PLPointer pltr_data )
1874 {
1875  set_stream();
1876 
1877  plshades( a, nx, ny, defined, xmin, xmax, ymin, ymax,
1878  clevel, nlevel, fill_width, cont_color, cont_width,
1879  fill, (PLBOOL) rectangular, pltr, pltr_data );
1880 }
1881 
1882 // Deprecated version using PLINT instead of bool
1883 void
1884 plstream::shades( const PLFLT * const *a, PLINT nx, PLINT ny,
1885  PLDEFINED_callback defined,
1886  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
1887  const PLFLT *clevel, PLINT nlevel, PLFLT fill_width,
1888  PLINT cont_color, PLFLT cont_width,
1889  PLFILL_callback fill, PLINT rectangular,
1890  PLTRANSFORM_callback pltr, PLPointer pltr_data )
1891 {
1892  set_stream();
1893 
1894  plshades( a, nx, ny, defined, xmin, xmax, ymin, ymax,
1895  clevel, nlevel, fill_width, cont_color, cont_width,
1896  fill, (PLBOOL) rectangular, pltr, pltr_data );
1897 }
1898 
1899 void
1901  PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
1902  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1903  PLINT min_color, PLFLT min_width,
1904  PLINT max_color, PLFLT max_width,
1905  bool rectangular,
1906  Coord_Xformer *pcxf )
1907 {
1908  set_stream();
1909 
1910  int nx, ny;
1911  d.elements( nx, ny );
1912 
1913  if ( pcxf != NULL )
1915  NULL, NULL,
1916  nx, ny,
1917  xmin, xmax, ymin, ymax, shade_min, shade_max,
1918  sh_cmap, sh_color, sh_width,
1919  min_color, min_width, max_color, max_width,
1920  plcallback::fill, rectangular,
1921  Coord_Xform_evaluator, pcxf );
1922  else
1924  NULL, NULL,
1925  nx, ny,
1926  xmin, xmax, ymin, ymax, shade_min, shade_max,
1927  sh_cmap, sh_color, sh_width,
1928  min_color, min_width, max_color, max_width,
1929  plcallback::fill, rectangular,
1930  NULL, NULL );
1931 }
1932 
1933 // Deprecated version using PLINT not bool
1934 void
1936  PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
1937  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1938  PLINT min_color, PLFLT min_width,
1939  PLINT max_color, PLFLT max_width,
1940  PLINT rectangular,
1941  Coord_Xformer *pcxf )
1942 {
1943  set_stream();
1944 
1945  int nx, ny;
1946  d.elements( nx, ny );
1947 
1949  NULL, NULL,
1950  nx, ny,
1951  xmin, xmax, ymin, ymax, shade_min, shade_max,
1952  sh_cmap, sh_color, sh_width,
1953  min_color, min_width, max_color, max_width,
1954  plcallback::fill, rectangular != 0,
1955  Coord_Xform_evaluator, pcxf );
1956 }
1957 
1958 void
1959 plstream::shade1( const PLFLT *a, PLINT nx, PLINT ny,
1960  PLDEFINED_callback defined,
1961  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1962  PLFLT shade_min, PLFLT shade_max,
1963  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1964  PLINT min_color, PLFLT min_width,
1965  PLINT max_color, PLFLT max_width,
1966  PLFILL_callback fill, bool rectangular,
1967  PLTRANSFORM_callback pltr, PLPointer pltr_data )
1968 {
1969  set_stream();
1970 
1971  plshade1( a, nx, ny, defined,
1972  left, right, bottom, top,
1973  shade_min, shade_max,
1974  sh_cmap, sh_color, sh_width,
1975  min_color, min_width, max_color, max_width,
1976  fill, (PLBOOL) rectangular, pltr, pltr_data );
1977 }
1978 
1979 // Deprecated version using PLINT not bool
1980 void
1981 plstream::shade1( const PLFLT *a, PLINT nx, PLINT ny,
1982  PLDEFINED_callback defined,
1983  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
1984  PLFLT shade_min, PLFLT shade_max,
1985  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
1986  PLINT min_color, PLFLT min_width,
1987  PLINT max_color, PLFLT max_width,
1988  PLFILL_callback fill, PLINT rectangular,
1989  PLTRANSFORM_callback pltr, PLPointer pltr_data )
1990 {
1991  set_stream();
1992 
1993  plshade1( a, nx, ny, defined,
1994  left, right, bottom, top,
1995  shade_min, shade_max,
1996  sh_cmap, sh_color, sh_width,
1997  min_color, min_width, max_color, max_width,
1998  fill, (PLBOOL) rectangular, pltr, pltr_data );
1999 }
2000 
2001 void
2003  PLPointer f2eval_data,
2004  PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
2005  PLPointer c2eval_data,
2006  PLINT nx, PLINT ny,
2007  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2008  PLFLT shade_min, PLFLT shade_max,
2009  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
2010  PLINT min_color, PLFLT min_width,
2011  PLINT max_color, PLFLT max_width,
2012  PLFILL_callback fill, bool rectangular,
2013  PLTRANSFORM_callback pltr, PLPointer pltr_data )
2014 {
2015  set_stream();
2016 
2017  plfshade( f2eval, f2eval_data,
2018  c2eval, c2eval_data,
2019  nx, ny, left, right, bottom, top,
2020  shade_min, shade_max,
2021  sh_cmap, sh_color, sh_width,
2022  min_color, min_width, max_color, max_width,
2023  fill, (PLBOOL) rectangular, pltr, pltr_data );
2024 }
2025 
2026 // Deprecated version using PLINT not bool
2027 void
2029  PLPointer f2eval_data,
2030  PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
2031  PLPointer c2eval_data,
2032  PLINT nx, PLINT ny,
2033  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
2034  PLFLT shade_min, PLFLT shade_max,
2035  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
2036  PLINT min_color, PLFLT min_width,
2037  PLINT max_color, PLFLT max_width,
2038  PLFILL_callback fill, PLINT rectangular,
2039  PLTRANSFORM_callback pltr, PLPointer pltr_data )
2040 {
2041  set_stream();
2042 
2043  plfshade( f2eval, f2eval_data,
2044  c2eval, c2eval_data,
2045  nx, ny, left, right, bottom, top,
2046  shade_min, shade_max,
2047  sh_cmap, sh_color, sh_width,
2048  min_color, min_width, max_color, max_width,
2049  fill, (PLBOOL) rectangular, pltr, pltr_data );
2050 }
2051 
2052 // Setup a user-provided custom labeling function
2053 
2055 {
2056  set_stream();
2057 
2058  plslabelfunc( label_func, label_data );
2059 }
2060 
2061 // Set up lengths of major tick marks.
2062 
2063 void plstream::smaj( PLFLT def, PLFLT scale )
2064 {
2065  set_stream();
2066 
2067  plsmaj( def, scale );
2068 }
2069 
2070 // Set the RGB memory area to be plotted (with the 'mem' or 'memcairo' drivers)
2071 
2072 void plstream::smem( PLINT maxx, PLINT maxy, void *plotmem )
2073 {
2074  set_stream();
2075 
2076  plsmem( maxx, maxy, plotmem );
2077 }
2078 
2079 // Set the RGBA memory area to be plotted (with the 'memcairo' drivers)
2080 
2081 void plstream::smema( PLINT maxx, PLINT maxy, void *plotmem )
2082 {
2083  set_stream();
2084 
2085  plsmema( maxx, maxy, plotmem );
2086 }
2087 
2088 // Set up lengths of minor tick marks.
2089 
2090 void plstream::smin( PLFLT def, PLFLT scale )
2091 {
2092  set_stream();
2093 
2094  plsmin( def, scale );
2095 }
2096 
2097 // Set orientation. Must be done before calling plinit.
2098 
2100 {
2101  set_stream();
2102 
2103  plsori( ori );
2104 }
2105 
2106 // Set output device parameters. Usually ignored by the driver.
2107 
2108 void plstream::spage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng,
2109  PLINT xoff, PLINT yoff )
2110 {
2111  set_stream();
2112 
2113  plspage( xp, yp, xleng, yleng, xoff, yoff );
2114 }
2115 
2116 // Set the colors for color table 0 from a cmap0 file
2117 
2118 void plstream::spal0( const char *filename )
2119 {
2120  set_stream();
2121 
2122  plspal0( filename );
2123 }
2124 
2125 // Set the colors for color table 1 from a cmap1 file
2126 
2127 void plstream::spal1( const char *filename, bool interpolate )
2128 {
2129  set_stream();
2130 
2131  plspal1( filename, (PLBOOL) interpolate );
2132 }
2133 
2134 // Set the pause (on end-of-page) status
2135 
2136 void plstream::spause( bool pause )
2137 {
2138  set_stream();
2139 
2140  plspause( (PLBOOL) pause );
2141 }
2142 
2143 // Deprecated version using PLINT not bool
2145 {
2146  set_stream();
2147 
2148  plspause( (PLBOOL) pause );
2149 }
2150 
2151 // Set stream number.
2152 
2154 {
2155  set_stream();
2156 
2157  plsstrm( strm );
2158 }
2159 
2160 // Set the number of subwindows in x and y
2161 
2163 {
2164  set_stream();
2165 
2166  plssub( nx, ny );
2167 }
2168 
2169 // Set symbol height.
2170 
2171 void plstream::ssym( PLFLT def, PLFLT scale )
2172 {
2173  set_stream();
2174 
2175  plssym( def, scale );
2176 }
2177 
2178 // Initialize PLplot, passing in the windows/page settings.
2179 
2181 {
2182  set_stream();
2183 
2184  plstar( nx, ny );
2185 }
2186 
2187 // Initialize PLplot, passing the device name and windows/page settings.
2188 
2189 void plstream::start( const char *devname, PLINT nx, PLINT ny )
2190 {
2191  set_stream();
2192 
2193  plstart( devname, nx, ny );
2194 }
2195 
2196 // Set the coordinate transform
2197 
2198 void plstream::stransform( PLTRANSFORM_callback coordinate_transform, PLPointer coordinate_transform_data )
2199 {
2200  set_stream();
2201 
2202  plstransform( coordinate_transform, coordinate_transform_data );
2203 }
2204 
2205 // Prints out the same string repeatedly at the n points in world
2206 // coordinates given by the x and y arrays. Supersedes plpoin and
2207 // plsymbol for the case where text refers to a unicode glyph either
2208 // directly as UTF-8 or indirectly via the standard text escape
2209 // sequences allowed for PLplot input strings.
2210 
2211 void plstream::string( PLINT n, const PLFLT *x, const PLFLT *y, const char *string )
2212 {
2213  set_stream();
2214  plstring( n, x, y, string );
2215 }
2216 
2217 // Prints out the same string repeatedly at the n points in world
2218 // coordinates given by the x, y, and z arrays. Supersedes plpoin3
2219 // for the case where text refers to a unicode glyph either directly
2220 // as UTF-8 or indirectly via the standard text escape sequences
2221 // allowed for PLplot input strings.
2222 
2223 void plstream::string3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const char *string )
2224 {
2225  set_stream();
2226  plstring3( n, x, y, z, string );
2227 }
2228 
2229 // Create 1d stripchart
2230 
2231 void plstream::stripc( PLINT *id, const char *xspec, const char *yspec,
2232  PLFLT xmin, PLFLT xmax, PLFLT xjump,
2233  PLFLT ymin, PLFLT ymax,
2234  PLFLT xlpos, PLFLT ylpos, bool y_ascl,
2235  bool acc, PLINT colbox, PLINT collab,
2236  const PLINT colline[], const PLINT styline[],
2237  const char *legline[], const char *labx,
2238  const char *laby, const char *labtop )
2239 {
2240  set_stream();
2241 
2242  plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos,
2243  (PLBOOL) y_ascl, (PLBOOL) acc, colbox, collab, colline, styline,
2244  legline, labx, laby, labtop );
2245 }
2246 
2247 
2248 // Deprecated version using PLINT not bool
2249 void plstream::stripc( PLINT *id, const char *xspec, const char *yspec,
2250  PLFLT xmin, PLFLT xmax, PLFLT xjump,
2251  PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos,
2252  PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab,
2253  const PLINT colline[], const PLINT styline[],
2254  const char *legline[], const char *labx,
2255  const char *laby, const char *labtop )
2256 {
2257  set_stream();
2258 
2259  plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos,
2260  (PLBOOL) y_ascl, (PLBOOL) acc, colbox, collab, colline, styline,
2261  legline, labx, laby, labtop );
2262 }
2263 
2264 // Add a point to a stripchart.
2265 
2266 void plstream::stripa( PLINT id, PLINT pen, PLFLT x, PLFLT y )
2267 {
2268  set_stream();
2269 
2270  plstripa( id, pen, x, y );
2271 }
2272 
2273 // Deletes and releases memory used by a stripchart.
2274 
2276 {
2277  set_stream();
2278 
2279  plstripd( id );
2280 }
2281 
2282 // plots a 2d image (or a matrix too large for plshade() ) - colors
2283 // automatically scaled
2284 
2285 void plstream::image( const PLFLT * const *data, PLINT nx, PLINT ny,
2286  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2287  PLFLT zmin, PLFLT zmax,
2288  PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax )
2289 {
2290  set_stream();
2291 
2292  plimage( data, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
2293  Dxmin, Dxmax, Dymin, Dymax );
2294 }
2295 
2296 // plots a 2d image (or a matrix too large for plshade() )
2297 
2298 void plstream::imagefr( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
2299  PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
2300  PLFLT valuemin, PLFLT valuemax,
2301  PLTRANSFORM_callback pltr, PLPointer pltr_data )
2302 {
2303  set_stream();
2304 
2305  plimagefr( data, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
2306  valuemin, valuemax, pltr, pltr_data );
2307 }
2308 
2309 // Set up a new line style
2310 
2311 void plstream::styl( PLINT nms, const PLINT *mark, const PLINT *space )
2312 {
2313  set_stream();
2314 
2315  plstyl( nms, mark, space );
2316 }
2317 
2318 // Sets the edges of the viewport to the specified absolute coordinates
2319 
2320 void plstream::svpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
2321 {
2322  set_stream();
2323 
2324  plsvpa( xmin, xmax, ymin, ymax );
2325 }
2326 
2327 // Set x axis labeling parameters
2328 
2329 void plstream::sxax( PLINT digmax, PLINT digits )
2330 {
2331  set_stream();
2332 
2333  plsxax( digmax, digits );
2334 }
2335 
2336 // Set inferior X window
2337 
2338 void plstream::sxwin( PLINT window_id )
2339 {
2340  set_stream();
2341 
2342  plsxwin( window_id );
2343 }
2344 
2345 // Set y axis labeling parameters
2346 
2347 void plstream::syax( PLINT digmax, PLINT digits )
2348 {
2349  set_stream();
2350 
2351  plsyax( digmax, digits );
2352 }
2353 
2354 // Plots array y against x for n points using Hershey symbol "code"
2355 
2356 void plstream::sym( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code )
2357 {
2358  set_stream();
2359 
2360  plsym( n, x, y, code );
2361 }
2362 
2363 // Set z axis labeling parameters
2364 
2365 void plstream::szax( PLINT digmax, PLINT digits )
2366 {
2367  set_stream();
2368 
2369  plszax( digmax, digits );
2370 }
2371 
2372 // Switches to text screen.
2373 
2375 {
2376  set_stream();
2377 
2378  pltext();
2379 }
2380 
2381 // Set the format for date / time labels
2382 
2383 void plstream::timefmt( const char *fmt )
2384 {
2385  set_stream();
2386 
2387  pltimefmt( fmt );
2388 }
2389 
2390 // Sets the edges of the viewport with the given aspect ratio, leaving
2391 // room for labels.
2392 
2393 void plstream::vasp( PLFLT aspect )
2394 {
2395  set_stream();
2396 
2397  plvasp( aspect );
2398 }
2399 
2400 // Creates the largest viewport of the specified aspect ratio that fits
2401 // within the specified normalized subpage coordinates.
2402 
2403 void plstream::vpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
2404  PLFLT aspect )
2405 {
2406  set_stream();
2407 
2408  plvpas( xmin, xmax, ymin, ymax, aspect );
2409 }
2410 
2411 // Creates a viewport with the specified normalized subpage coordinates.
2412 
2413 void plstream::vpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
2414 {
2415  set_stream();
2416 
2417  plvpor( xmin, xmax, ymin, ymax );
2418 }
2419 
2420 // Defines a "standard" viewport with seven character heights for
2421 // the left margin and four character heights everywhere else.
2422 
2424 {
2425  set_stream();
2426 
2427  plvsta();
2428 }
2429 
2430 // Set up a window for three-dimensional plotting.
2431 
2432 void plstream::w3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0,
2433  PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0,
2434  PLFLT zmax0, PLFLT alt, PLFLT az )
2435 {
2436  set_stream();
2437 
2438  plw3d( basex, basey, height, xmin0, xmax0, ymin0, ymax0, zmin0, zmax0,
2439  alt, az );
2440 }
2441 
2442 // Set pen width.
2443 
2444 void plstream::width( PLFLT width )
2445 {
2446  set_stream();
2447 
2448  plwidth( width );
2449 }
2450 
2451 // Set up world coordinates of the viewport boundaries (2d plots).
2452 
2453 void plstream::wind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
2454 {
2455  set_stream();
2456 
2457  plwind( xmin, xmax, ymin, ymax );
2458 }
2459 
2460 // Set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
2461 
2462 void plstream::xormod( bool mode, bool *status )
2463 {
2464  PLBOOL loc_status;
2465 
2466  set_stream();
2467 
2468  plxormod( (PLBOOL) mode, &loc_status );
2469 
2470  *status = ( loc_status != 0 );
2471 }
2472 
2473 // Deprecated version using PLINT not bool
2474 void plstream::xormod( PLINT mode, PLINT *status )
2475 {
2476  PLBOOL loc_status;
2477 
2478  set_stream();
2479 
2480  plxormod( (PLBOOL) mode, &loc_status );
2481 
2482  *status = (PLINT) loc_status;
2483 }
2484 
2485 // Set the seed for the random number generator included.
2486 
2487 void plstream::seed( unsigned int s )
2488 {
2489  set_stream();
2490 
2491  plseed( s );
2492 }
2493 
2494 // Returns a random number on [0,1]-interval.
2495 
2497 {
2498  set_stream();
2499 
2500  return plrandd();
2501 }
2502 
2503 // The rest for use from C / C++ only
2504 
2505 // Returns a list of file-oriented device names and their menu strings
2506 
2507 void plstream::gFileDevs( const char ***p_menustr, const char ***p_devname,
2508  int *p_ndev )
2509 {
2510  set_stream();
2511 
2512  plgFileDevs( p_menustr, p_devname, p_ndev );
2513 }
2514 
2515 // Set the function pointer for the keyboard event handler
2516 
2517 void plstream::sKeyEH( void ( *KeyEH )( PLGraphicsIn *, void *, int * ),
2518  void *KeyEH_data )
2519 {
2520  set_stream();
2521 
2522  plsKeyEH( KeyEH, KeyEH_data );
2523 }
2524 
2525 // Set the variables to be used for storing error info
2526 
2527 void plstream::sError( PLINT *errcode, char *errmsg )
2528 {
2529  set_stream();
2530 
2531  plsError( errcode, errmsg );
2532 }
2533 
2534 // Sets an optional user exit handler.
2535 
2536 void plstream::sexit( int ( *handler )( const char * ) )
2537 {
2538  set_stream();
2539 
2540  plsexit( handler );
2541 }
2542 
2543 // We obviously won't be using this object from Fortran...
2544 // // Identity transformation for plots from Fortran.
2545 
2546 // void plstream::tr0f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data )
2547 // {
2548 // set_stream();
2549 
2550 // pltr0f(x,y,tx,ty,pltr_data);
2551 // }
2552 
2553 // // Does linear interpolation from doubly dimensioned coord arrays
2554 // // (row dominant, i.e. Fortran ordering).
2555 
2556 // void plstream::tr2f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data )
2557 // {
2558 // set_stream();
2559 
2560 // pltr2f(x,y,tx,ty,pltr_data);
2561 // }
2562 
2563 // Example linear transformation function for contour plotter.
2564 // This is not actually a part of the core library any more
2565 //
2566 // void plstream::xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty )
2567 // {
2568 // set_stream();
2569 //
2570 // xform(x,y,tx,ty);
2571 // }
2572 
2573 // Function evaluators
2574 
2575 // Does a lookup from a 2d function array. Array is of type (PLFLT **),
2576 // and is column dominant (normal C ordering).
2577 
2578 PLFLT plstream::f2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data )
2579 {
2580  set_stream();
2581 
2582  return ::plf2eval2( ix, iy, plf2eval_data );
2583 }
2584 
2585 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
2586 // and is column dominant (normal C ordering).
2587 
2588 PLFLT plstream::f2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data )
2589 {
2590  set_stream();
2591 
2592  return ::plf2eval( ix, iy, plf2eval_data );
2593 }
2594 
2595 // Does a lookup from a 2d function array. Array is of type (PLFLT *),
2596 // and is row dominant (Fortran ordering).
2597 
2598 PLFLT plstream::f2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data )
2599 {
2600  set_stream();
2601 
2602  return ::plf2evalr( ix, iy, plf2eval_data );
2603 }
2604 
2605 // Command line parsing utilities
2606 
2607 // Clear internal option table info structure.
2608 
2610 {
2611  set_stream();
2612 
2613  ::plClearOpts();
2614 }
2615 
2616 // Reset internal option table info structure.
2617 
2619 {
2620  set_stream();
2621 
2622  ::plResetOpts();
2623 }
2624 
2625 // Merge user option table into internal info structure.
2626 
2628  const char **notes )
2629 {
2630  set_stream();
2631 
2632  return ::plMergeOpts( options, name, notes );
2633 }
2634 
2635 // Set the strings used in usage and syntax messages.
2636 
2637 void plstream::SetUsage( char *program_string, char *usage_string )
2638 {
2639  set_stream();
2640 
2641  ::plSetUsage( program_string, usage_string );
2642 }
2643 
2644 // Process input strings, treating them as an option and argument pair.
2645 
2646 PLINT plstream::setopt( const char *opt, const char *optarg )
2647 {
2648  set_stream();
2649 
2650  return ::plsetopt( opt, optarg );
2651 }
2652 
2653 // Deprecated version - use setopt instead.
2654 #ifdef PL_DEPRECATED
2655 int plstream::SetOpt( const char *opt, const char *optarg )
2656 {
2657  set_stream();
2658 
2659  return ::plsetopt( opt, optarg );
2660 }
2661 #endif // PL_DEPRECATED
2662 
2663 // Print usage & syntax message.
2664 
2666 {
2667  set_stream();
2668 
2669  ::plOptUsage();
2670 }
2671 
2672 // Miscellaneous
2673 
2674 // Set the output file pointer
2675 
2676 void plstream::gfile( FILE **p_file )
2677 {
2678  set_stream();
2679 
2680  ::plgfile( p_file );
2681 }
2682 
2683 // Get the output file pointer
2684 
2685 void plstream::sfile( FILE *file )
2686 {
2687  set_stream();
2688 
2689  ::plsfile( file );
2690 }
2691 
2692 
2693 // Get the escape character for text strings.
2694 
2695 void plstream::gesc( char *p_esc )
2696 {
2697  set_stream();
2698 
2699  ::plgesc( p_esc );
2700 }
2701 
2702 // Front-end to driver escape function.
2703 
2704 void plstream::cmd( PLINT op, void *ptr )
2705 {
2706  set_stream();
2707 
2708  ::pl_cmd( op, ptr );
2709 }
2710 
2711 // Return full pathname for given file if executable
2712 
2714 {
2715  set_stream();
2716 
2717  return plFindName( p );
2718 }
2719 
2720 // Looks for the specified executable file according to usual search path.
2721 
2722 char *plstream::FindCommand( char *fn )
2723 {
2724  set_stream();
2725 
2726  return plFindCommand( fn );
2727 }
2728 
2729 // Gets search name for file by concatenating the dir, subdir, and file
2730 // name, allocating memory as needed.
2731 
2732 void plstream::GetName( char *dir, char *subdir, char *filename,
2733  char **filespec )
2734 {
2735  set_stream();
2736 
2737  plGetName( dir, subdir, filename, filespec );
2738 }
2739 
2740 // Prompts human to input an integer in response to given message.
2741 
2743 {
2744  set_stream();
2745 
2746  return plGetInt( s );
2747 }
2748 
2749 // Prompts human to input a float in response to given message.
2750 
2752 {
2753  set_stream();
2754 
2755  return plGetFlt( s );
2756 }
2757 
2758 // Nice way to allocate space for a vectored 2d grid
2759 
2760 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
2761 
2763 {
2764  set_stream();
2765 
2766  ::plAlloc2dGrid( f, nx, ny );
2767 }
2768 
2769 // Frees a block of memory allocated with plAlloc2dGrid().
2770 
2772 {
2773  set_stream();
2774 
2775  ::plFree2dGrid( f, nx, ny );
2776 }
2777 
2778 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
2779 void plstream::MinMax2dGrid( const PLFLT * const *f, PLINT nx, PLINT ny,
2780  PLFLT *fmax, PLFLT *fmin )
2781 {
2782  set_stream();
2783 
2784  ::plMinMax2dGrid( f, nx, ny, fmax, fmin );
2785 }
2786 
2787 // Functions for converting between HLS and RGB color space
2788 
2789 void plstream::hlsrgb( PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g,
2790  PLFLT *p_b )
2791 {
2792  set_stream();
2793 
2794  ::c_plhlsrgb( h, l, s, p_r, p_g, p_b );
2795 }
2796 
2797 void plstream::rgbhls( PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l,
2798  PLFLT *p_s )
2799 {
2800  set_stream();
2801 
2802  ::c_plrgbhls( r, g, b, p_h, p_l, p_s );
2803 }
2804 
2805 // Wait for right button mouse event and translate to world coordinates
2806 
2808 {
2809  set_stream();
2810 
2811  return plGetCursor( gin );
2812 }
2813 
2814 //--------------------------------------------------------------------------
2815 // end of plstream.cc
2816 //--------------------------------------------------------------------------
#define plsfam
Definition: plplot.h:818
#define plw3d
Definition: plplot.h:863
PLFLT plf2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:466
PLINT plMergeOpts(PLOptionTable *options, PLCHAR_VECTOR name, PLCHAR_VECTOR *notes)
Definition: plargs.c:795
void(* label_func)(PLINT, PLFLT, char *, PLINT, PLPointer)
void plsdevdata(void *data)
Definition: plcore.c:3823
void spal1(const char *filename, bool interpolate=true)
Definition: plstream.cc:2127
static const char * name
Definition: tkMain.c:135
#define plpath
Definition: plplot.h:759
void adv(PLINT page)
Definition: plstream.cc:359
plstream(void)
Definition: plstream.cc:283
static char ** argv
Definition: qt.cpp:40
#define plgxax
Definition: plplot.h:743
void clear(void)
Definition: plstream.cc:477
void plgesc(char *p_esc)
Definition: plcore.c:3893
#define plsstrm
Definition: plplot.h:836
PLINT parseopts(int *p_argc, char **argv, PLINT mode)
Definition: plstream.cc:1306
void(* PLTRANSFORM_callback)(PLFLT x, PLFLT y, PLFLT_NC_SCALAR xp, PLFLT_NC_SCALAR yp, PL_GENERIC_POINTER data)
Definition: plplot.h:258
PLINT plGetCursor(PLGraphicsIn *plg)
Definition: plpage.c:244
void vpor(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plstream.cc:2413
PLINT plGetInt(PLCHAR_VECTOR s)
Definition: plctrl.c:2900
void poin(PLINT n, const PLFLT *x, const PLFLT *y, PLINT code)
Definition: plstream.cc:1333
void stripd(PLINT id)
Definition: plstream.cc:2275
void cmd(PLINT op, void *ptr)
Definition: plstream.cc:2704
#define plspage
Definition: plplot.h:832
void btime(PLINT &year, PLINT &month, PLINT &day, PLINT &hour, PLINT &min, PLFLT &sec, PLFLT ctime)
Definition: plstream.cc:457
void plGetName(PLCHAR_VECTOR dir, PLCHAR_VECTOR subdir, PLCHAR_VECTOR filename, char **filespec)
Definition: plctrl.c:2443
#define plvpor
Definition: plplot.h:861
PLINT plFindName(char *p)
Definition: plctrl.c:2422
void scolbg(PLINT r, PLINT g, PLINT b)
Definition: plstream.cc:1650
void(* PLLABEL_FUNC_callback)(PLINT axis, PLFLT value, PLCHAR_NC_VECTOR label, PLINT length, PL_GENERIC_POINTER data)
Definition: plplot.h:259
void rgbhls(PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s)
Definition: plstream.cc:2797
void erry(PLINT n, const PLFLT *x, const PLFLT *ymin, const PLFLT *ymax)
Definition: plstream.cc:676
void(* PLMAPFORM_callback)(PLINT n, PLFLT_NC_VECTOR x, PLFLT_NC_VECTOR y)
Definition: plplot.h:257
void imagefr(const PLFLT *const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT valuemin, PLFLT valuemax, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plstream.cc:2298
void c_plssub(PLINT nx, PLINT ny)
Definition: plcore.c:3596
#define plmtex3
Definition: plplot.h:772
#define plerry
Definition: plplot.h:711
void svect(const PLFLT *arrow_x=NULL, const PLFLT *arrow_y=NULL, PLINT npts=0, bool fill=false)
Definition: plstream.cc:385
#define plsyax
Definition: plplot.h:853
#define plschr
Definition: plplot.h:792
#define plsdev
Definition: plplot.h:809
void box(const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
Definition: plstream.cc:433
#define plgdev
Definition: plplot.h:724
void gdiplt(PLFLT &xmin, PLFLT &ymin, PLFLT &xmax, PLFLT &ymax)
Definition: plstream.cc:811
PLFLT f2evalr(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plstream.cc:2598
int min(int a, int b)
void map(PLMAPFORM_callback mapform, const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plstream.cc:1116
#define pllegend
Definition: plplot.h:756
PLFLT plf2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:447
void mapform(PLINT n, PLFLT *x, PLFLT *y)
Definition: tclAPI.c:3693
void c_plgstrm(PLINT *p_strm)
Definition: plcore.c:2631
void sesc(char esc)
Definition: plstream.cc:1752
void SetUsage(char *program_string, char *usage_string)
Definition: plstream.cc:2637
void vect(const PLFLT *const *u, const PLFLT *const *v, PLINT nx, PLINT ny, PLFLT scale, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plstream.cc:376
void pldid2pc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1667
#define plshade
Definition: plplot.h:822
#define plscompression
Definition: plplot.h:808
#define plarc
Definition: plplot.h:689
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
void griddata(const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts, const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy, PLFLT **zg, PLINT type, PLFLT data)
Definition: plstream.cc:893
#define pllsty
Definition: plplot.h:761
void ssub(PLINT nx, PLINT ny)
Definition: plstream.cc:2162
void gcmap1_range(PLFLT &min_color, PLFLT &max_color)
Definition: plstream.cc:1502
#define plsmin
Definition: plplot.h:829
#define plwind
Definition: plplot.h:868
#define plclear
Definition: plplot.h:697
#define plfill
Definition: plplot.h:713
#define plconfigtime
Definition: plplot.h:701
void c_plend(void)
Definition: plcore.c:2463
PLINT GetInt(char *s)
Definition: plstream.cc:2742
void scmap0(const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol0)
Definition: plstream.cc:1511
void col0(PLINT icol0)
Definition: plstream.cc:486
void pat(PLINT nlin, const PLINT *inc, const PLINT *del)
Definition: plstream.cc:1315
void cpstrm(plstream &pls, bool flags)
Definition: plstream.cc:570
void wind(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plstream.cc:2453
#define plsurf3dl
Definition: plplot.h:849
PLFLT plf2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plcont.c:428
void sfnam(const char *fnam)
Definition: plstream.cc:1798
void path(PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plstream.cc:1324
cxx_pltr2(Coord_2d &cx, Coord_2d &cy)
Definition: plstream.cc:55
void smema(PLINT maxx, PLINT maxy, void *plotmem)
Definition: plstream.cc:2081
void plmapline(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:628
#define plbtime
Definition: plplot.h:695
#define pl_setcontlabelparam
Definition: plplot.h:687
void gspa(PLFLT &xmin, PLFLT &xmax, PLFLT &ymin, PLFLT &ymax)
Definition: plstream.cc:904
void c_plend1(void)
Definition: plcore.c:2521
void c_plsdev(PLCHAR_VECTOR devname)
Definition: plcore.c:3619
PLFLT randd(void)
Definition: plstream.cc:2496
PLDLLIMPEXP_CXX void tr0(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plstream.cc:249
char * FindCommand(char *fn)
Definition: plstream.cc:2722
void sdevdata(void *data)
Definition: plstream.cc:1807
#define plscolbg
Definition: plplot.h:805
void sori(PLINT ori)
Definition: plstream.cc:2099
#define plfont
Definition: plplot.h:716
void c_plsfnam(PLCHAR_VECTOR fnam)
Definition: plcore.c:3809
#define plstyl
Definition: plplot.h:847
Coord_2d & yg
Definition: plstream.h:75
#define plpoly3
Definition: plplot.h:780
void gfile(FILE **p_file)
Definition: plstream.cc:2676
void sfile(FILE *file)
Definition: plstream.cc:2685
#define plimage
Definition: plplot.h:751
void did2pc(PLFLT &xmin, PLFLT &ymin, PLFLT &xmax, PLFLT &ymax)
Definition: plstream.cc:597
virtual void elements(int &_nx, int &_ny)=0
void setcontlabelformat(PLINT lexp, PLINT sigdig)
Definition: plstream.cc:1771
#define plfontld
Definition: plplot.h:717
#define plscolbga
Definition: plplot.h:806
void image(const PLFLT *const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax, PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax)
Definition: plstream.cc:2285
void sdidev(PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy)
Definition: plstream.cc:1705
#define plbin
Definition: plplot.h:691
PLINT plTranslateCursor(PLGraphicsIn *plg)
Definition: plpage.c:259
#define plsdiori
Definition: plplot.h:812
void stripc(PLINT *id, const char *xspec, const char *yspec, PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos, bool y_ascl, bool acc, PLINT colbox, PLINT collab, const PLINT colline[], const PLINT styline[], const char *legline[], const char *labx, const char *laby, const char *labtop)
Definition: plstream.cc:2231
void surf3d(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plstream.cc:1235
void line(PLINT n, const PLFLT *x, const PLFLT *y)
Definition: plstream.cc:1089
void fill(PLINT n, const PLFLT *x, const PLFLT *y)
Definition: plstream.cc:694
void plmeridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plmap.c:742
#define plparseopts
Definition: plplot.h:776
void plmaptex(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT dx, PLFLT dy, PLFLT just, PLCHAR_VECTOR text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plmap.c:673
#define plsym
Definition: plplot.h:854
void gcompression(PLINT &compression)
Definition: plstream.cc:784
#define plscmap1
Definition: plplot.h:796
void vsta(void)
Definition: plstream.cc:2423
#define plinit
Definition: plplot.h:753
void join(PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2)
Definition: plstream.cc:1013
void plsfile(FILE *file)
Definition: plcore.c:3781
#define plctime
Definition: plplot.h:704
#define pltimefmt
Definition: plplot.h:857
#define plscmap1n
Definition: plplot.h:800
void pldip2dc(PLFLT *xmin, PLFLT *ymin, PLFLT *xmax, PLFLT *ymax)
Definition: plcore.c:1713
#define plbop
Definition: plplot.h:692
void plot3d(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, bool side)
Definition: plstream.cc:1261
#define plsdiplt
Definition: plplot.h:813
#define plsvect
Definition: plplot.h:850
#define plscmap1a
Definition: plplot.h:797
#define plssub
Definition: plplot.h:837
void env0(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plstream.cc:648
void c_plmkstrm(PLINT *p_strm)
Definition: plcore.c:2650
#define plspal1
Definition: plplot.h:834
#define plsetopt
Definition: plplot.h:817
#define plmeshc
Definition: plplot.h:769
#define plgcompression
Definition: plplot.h:723
PLINT(* PLDEFINED_callback)(PLFLT x, PLFLT y)
Definition: plplot.h:262
#define plszax
Definition: plplot.h:855
#define plvsta
Definition: plplot.h:862
virtual void xform(PLFLT ox, PLFLT oy, PLFLT &nx, PLFLT &ny) const =0
void shade(const PLFLT *const *a, PLINT nx, PLINT ny, PLDEFINED_callback 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, PLFILL_callback fill, bool rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plstream.cc:1826
void scol0a(PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plstream.cc:1641
#define plgpage
Definition: plplot.h:734
#define plaxes
Definition: plplot.h:690
#define plsori
Definition: plplot.h:831
void sfont(PLINT family, PLINT style, PLINT weight)
Definition: plstream.cc:1816
void plsError(PLINT *errcode, char *errmsg)
Definition: plcore.c:3732
static int sid
Definition: plstripc.c:44
void sKeyEH(void(*KeyEH)(PLGraphicsIn *, void *, int *), void *KeyEH_data)
Definition: plstream.cc:2517
void width(PLFLT width)
Definition: plstream.cc:2444
void seed(unsigned int s)
Definition: plstream.cc:2487
void scolbga(PLINT r, PLINT g, PLINT b, PLFLT a)
Definition: plstream.cc:1659
#define plgdiplt
Definition: plplot.h:727
#define plscmap0a
Definition: plplot.h:794
void scompression(PLINT compression)
Definition: plstream.cc:1677
void mapline(PLMAPFORM_callback mapform, const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
Definition: plstream.cc:1127
void ResetOpts(void)
Definition: plstream.cc:2618
Coord_2d & xg
Definition: plstream.h:74
#define plfamadv
Definition: plplot.h:712
void gfci(PLUNICODE &pfci)
Definition: plstream.cc:820
void(* PLFILL_callback)(PLINT n, PLFLT_VECTOR x, PLFLT_VECTOR y)
Definition: plplot.h:261
void plot3dc(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plstream.cc:1280
void fcont(PLFLT(*f2eval)(PLINT, PLINT, PLPointer), PLPointer f2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plstream.cc:555
#define plsmem
Definition: plplot.h:827
#define plgfont
Definition: plplot.h:732
#define plshade1
Definition: plplot.h:823
void svpa(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax)
Definition: plstream.cc:2320
int PLINT
Definition: plplot.h:174
#define plenv0
Definition: plplot.h:708
#define plgdiori
Definition: plplot.h:726
#define plshades
Definition: plplot.h:824
PLINT PLBOOL
Definition: plplot.h:197
void mtex3(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
Definition: plstream.cc:1225
void configtime(PLFLT scale, PLFLT offset1, PLFLT offset2, PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec)
Definition: plstream.cc:525
void shades(const PLFLT *const *a, PLINT nx, PLINT ny, PLDEFINED_callback defined, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, const PLFLT *clevel, PLINT nlevel, PLFLT fill_width, PLINT cont_color, PLFLT cont_width, PLFILL_callback fill, bool rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plstream.cc:1867
#define plssym
Definition: plplot.h:838
void sstrm(PLINT strm)
Definition: plstream.cc:2153
void sxax(PLINT digmax, PLINT digits)
Definition: plstream.cc:2329
#define pljoin
Definition: plplot.h:754
#define plgzax
Definition: plplot.h:745
void scmap1(const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol1)
Definition: plstream.cc:1529
void scolor(PLINT color)
Definition: plstream.cc:1668
void gesc(char *p_esc)
Definition: plstream.cc:2695
void gvpw(PLFLT &xmin, PLFLT &xmax, PLFLT &ymin, PLFLT &ymax)
Definition: plstream.cc:942
void w3d(PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0, PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0, PLFLT zmax0, PLFLT alt, PLFLT az)
Definition: plstream.cc:2432
#define plgfam
Definition: plplot.h:729
#define plgdidev
Definition: plplot.h:725
void poly3(PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const bool *draw, bool ifcc)
Definition: plstream.cc:1351
void errx(PLINT n, const PLFLT *xmin, const PLFLT *xmax, const PLFLT *y)
Definition: plstream.cc:667
void text(void)
Definition: plstream.cc:2374
#define plstar
Definition: plplot.h:839
virtual ~plstream(void)
Definition: plstream.cc:342
#define plcpstrm
Definition: plplot.h:703
#define plimagefr
Definition: plplot.h:752
#define plcalc_world
Definition: plplot.h:696
void spage(PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng, PLINT xoff, PLINT yoff)
Definition: plstream.cc:2108
void mapstring(PLMAPFORM_callback mapform, const char *name, const char *string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
Definition: plstream.cc:1138
#define plsfnam
Definition: plplot.h:820
void gchr(PLFLT &p_def, PLFLT &p_ht)
Definition: plstream.cc:739
void ssym(PLFLT def, PLFLT scale)
Definition: plstream.cc:2171
#define plhist
Definition: plplot.h:746
void eop(void)
Definition: plstream.cc:658
void plot3dcl(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax)
Definition: plstream.cc:1292
void gcolbg(PLINT &r, PLINT &g, PLINT &b)
Definition: plstream.cc:766
void scmap1a(const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol1)
Definition: plstream.cc:1538
void smem(PLINT maxx, PLINT maxy, void *plotmem)
Definition: plstream.cc:2072
void col1(PLFLT c)
Definition: plstream.cc:504
void scmap1n(PLINT ncol1)
Definition: plstream.cc:1484
#define plgchr
Definition: plplot.h:718
void glevel(PLINT &p_level)
Definition: plstream.cc:856
#define plsdidev
Definition: plplot.h:810
void bop(void)
Definition: plstream.cc:424
#define plspal0
Definition: plplot.h:833
void c_plhlsrgb(PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b)
Definition: plctrl.c:1251
void mtex(const char *side, PLFLT disp, PLFLT pos, PLFLT just, const char *text)
Definition: plstream.cc:1215
void plFree2dGrid(PLFLT **f, PLINT nx, PLINT PL_UNUSED(ny))
Definition: plmem.c:85
plSetUsage
Definition: plplotc.py:8414
#define plfill3
Definition: plplot.h:714
#define plsmema
Definition: plplot.h:828
void c_plsstrm(PLINT strm)
Definition: plcore.c:2600
void c_plflush(void)
Definition: plcore.c:2206
void meshc(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel)
Definition: plstream.cc:1196
#define plseed
Definition: plplot.h:815
#define plstring
Definition: plplot.h:842
plOptUsage
Definition: plplotc.py:8418
#define plstransform
Definition: plplot.h:841
#define plvect
Definition: plplot.h:859
PLFLT GetFlt(char *s)
Definition: plstream.cc:2751
void xform(PLFLT x, PLFLT y, PLFLT &tx, PLFLT &ty) const
Definition: plstream.cc:75
void sdiori(PLFLT rot)
Definition: plstream.cc:1725
void surf3dl(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt, const PLFLT *clevel, PLINT nlevel, PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax)
Definition: plstream.cc:1247
void star(PLINT nx, PLINT ny)
Definition: plstream.cc:2180
void gfam(PLINT &fam, PLINT &num, PLINT &bmax)
Definition: plstream.cc:829
#define plscmap1la
Definition: plplot.h:799
#define plgfnam
Definition: plplot.h:731
void sfci(PLUNICODE fci)
Definition: plstream.cc:1789
char * plFindCommand(PLCHAR_VECTOR fn)
Definition: plctrl.c:2136
#define plcont
Definition: plplot.h:702
#define plsxax
Definition: plplot.h:852
void syax(PLINT digmax, PLINT digits)
Definition: plstream.cc:2347
#define plstart
Definition: plplot.h:840
plClearOpts
Definition: plplotc.py:8406
void prec(PLINT setp, PLINT prec)
Definition: plstream.cc:1386
#define pleop
Definition: plplot.h:709
#define plmesh
Definition: plplot.h:768
void gxax(PLINT &digmax, PLINT &digits)
Definition: plstream.cc:951
void styl(PLINT nms, const PLINT *mark, const PLINT *space)
Definition: plstream.cc:2311
#define plsmaj
Definition: plplot.h:826
void c_plrgbhls(PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l, PLFLT *p_s)
Definition: plctrl.c:1284
PLINT stream
Definition: plstream.h:118
#define plcol1
Definition: plplot.h:699
void c_plscolbg(PLINT r, PLINT g, PLINT b)
Definition: plctrl.c:215
#define pllab
Definition: plplot.h:755
#define pllightsource
Definition: plplot.h:757
#define plbox
Definition: plplot.h:693
pl_setcontlabelformat
Definition: tclgen_s.h:1
void pl_cmd(PLINT op, void *ptr)
Definition: plctrl.c:2108
void sfam(PLINT fam, PLINT num, PLINT bmax)
Definition: plstream.cc:1780
void stripa(PLINT id, PLINT pen, PLFLT x, PLFLT y)
Definition: plstream.cc:2266
void scmap0a(const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol0)
Definition: plstream.cc:1520
void plgFileDevs(const char ***p_menustr, const char ***p_devname, int *p_ndev)
Definition: plcore.c:3509
void fshade(PLFLT(*f2eval)(PLINT, PLINT, PLPointer), PLPointer f2eval_data, PLFLT(*c2eval)(PLINT, PLINT, PLPointer), 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, PLFILL_callback fill, bool rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plstream.cc:2002
#define pltext
Definition: plplot.h:856
void gfnam(char *fnam)
Definition: plstream.cc:838
plMinMax2dGrid
Definition: plplotc.py:8422
#define plwidth
Definition: plplot.h:867
#define plgver
Definition: plplot.h:740
void ctime(PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec, PLFLT &ctime)
Definition: plstream.cc:586
#define plscol0a
Definition: plplot.h:804
#define plptex3
Definition: plplot.h:784
void plsexit(int(*handler)(PLCHAR_VECTOR))
Definition: plctrl.c:1977
void Coord_Xform_evaluator(PLFLT ox, PLFLT oy, PLFLT *nx, PLFLT *ny, PLPointer p)
Definition: plstream.cc:44
void vasp(PLFLT aspect)
Definition: plstream.cc:2393
#define plsdiplz
Definition: plplot.h:814
void sdev(const char *devname)
Definition: plstream.cc:1686
static PLStream * pls[PL_NSTREAMS]
Definition: plcore.h:88
stream_id
Definition: plstream.h:35
#define plspause
Definition: plplot.h:835
void gyax(PLINT &digmax, PLINT &digits)
Definition: plstream.cc:960
void bin(PLINT nbin, const PLFLT *x, const PLFLT *y, PLINT center)
Definition: plstream.cc:415
void timefmt(const char *fmt)
Definition: plstream.cc:2383
void scmap1la(bool itype, PLINT npts, const PLFLT *intensity, const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLFLT *a, const bool *alt_hue_path=NULL)
Definition: plstream.cc:1574
void init(void)
Definition: plstream.cc:999
#define plline3
Definition: plplot.h:760
#define plstripd
Definition: plplot.h:846
#define plgfci
Definition: plplot.h:730
#define plgspa
Definition: plplot.h:738
#define plgcolbg
Definition: plplot.h:721
void vpas(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect)
Definition: plstream.cc:2403
void sexit(int(*handler)(const char *))
Definition: plstream.cc:2536
#define plstripc
Definition: plplot.h:845
void mesh(const PLFLT *x, const PLFLT *y, const PLFLT *const *z, PLINT nx, PLINT ny, PLINT opt)
Definition: plstream.cc:1186
#define plstripa
Definition: plplot.h:844
#define plstring3
Definition: plplot.h:843
void setcontlabelparam(PLFLT offset, PLFLT size, PLFLT spacing, PLINT active)
Definition: plstream.cc:1761
#define plvpas
Definition: plplot.h:860
void gcol0a(PLINT icol0, PLINT &r, PLINT &g, PLINT &b, PLFLT &a)
Definition: plstream.cc:757
void scmap1l(bool itype, PLINT npts, const PLFLT *intensity, const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const bool *alt_hue_path=NULL)
Definition: plstream.cc:1548
void line3(PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z)
Definition: plstream.cc:1098
#define plsfont
Definition: plplot.h:821
void sdimap(PLINT dimxmin, PLINT dimxmax, PLINT dimymin, PLINT dimymax, PLFLT dimxpmm, PLFLT dimypmm)
Definition: plstream.cc:1714
void plmapfill(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:695
#define plpsty
Definition: plplot.h:782
void box3(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: plstream.cc:445
static PLOptionTable options[]
Definition: tclMain.c:108
#define plgvpd
Definition: plplot.h:741
#define plpoin
Definition: plplot.h:778
#define plgriddata
Definition: plplot.h:737
#define plgvpw
Definition: plplot.h:742
void smaj(PLFLT def, PLFLT scale)
Definition: plstream.cc:2063
void sym(PLINT n, const PLFLT *x, const PLFLT *y, PLINT code)
Definition: plstream.cc:2356
void dip2dc(PLFLT &xmin, PLFLT &ymin, PLFLT &xmax, PLFLT &ymax)
Definition: plstream.cc:607
void spause(bool pause)
Definition: plstream.cc:2136
void lsty(PLINT lin)
Definition: plstream.cc:1107
void fontld(PLINT fnt)
Definition: plstream.cc:730
void gdev(char *devname)
Definition: plstream.cc:1695
PLFLT f2eval2(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plstream.cc:2578
void mapfill(PLMAPFORM_callback mapform, const char *name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, const PLINT *plotentries, PLINT nplotentries)
Definition: plstream.cc:1162
void env(PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLINT just, PLINT axis)
Definition: plstream.cc:637
PLINT MergeOpts(PLOptionTable *options, const char *name, const char **notes)
Definition: plstream.cc:2627
void replot(void)
Definition: plstream.cc:1435
int SetOpt(const char *opt, const char *optarg)
float PLFLT
Definition: plplot.h:157
void gver(char *p_ver)
Definition: plstream.cc:924
#define plscol0
Definition: plplot.h:803
void sdiplt(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plstream.cc:1734
#define plxormod
Definition: plplot.h:869
void shade1(const PLFLT *a, PLINT nx, PLINT ny, PLDEFINED_callback 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, PLFILL_callback fill, bool rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plstream.cc:1959
#define plerrx
Definition: plplot.h:710
void gra(void)
Definition: plstream.cc:875
#define plgcol0a
Definition: plplot.h:720
void schr(PLFLT def, PLFLT scale)
Definition: plstream.cc:1466
PLINT setopt(const char *opt, const char *optarg)
Definition: plstream.cc:2646
#define plgcolbga
Definition: plplot.h:722
void start(const char *devname, PLINT nx, PLINT ny)
Definition: plstream.cc:2189
void plfshade(PLF2EVAL_callback f2eval, PLPointer f2eval_data, PLF2EVAL_callback c2eval, PLPointer c2eval_data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, 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, PLFILL_callback fill, PLINT rectangular, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plshade.c:412
void plAlloc2dGrid(PLFLT ***f, PLINT nx, PLINT ny)
Definition: plmem.c:60
void col(PLcolor c)
Definition: plstream.cc:495
void Free2dGrid(PLFLT **f, PLINT nx, PLINT ny)
Definition: plstream.cc:2771
void font(PLINT ifont)
Definition: plstream.cc:721
#define plgyax
Definition: plplot.h:744
#define plsesc
Definition: plplot.h:816
#define plenv
Definition: plplot.h:707
PLFLT f2eval(PLINT ix, PLINT iy, PLPointer plf2eval_data)
Definition: plstream.cc:2588
void GetName(char *dir, char *subdir, char *filename, char **filespec)
Definition: plstream.cc:2732
void stransform(PLTRANSFORM_callback coordinate_transform, PLPointer coordinate_transform_data)
Definition: plstream.cc:2198
void szax(PLINT digmax, PLINT digits)
Definition: plstream.cc:2365
void axes(PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub, const char *yopt, PLFLT ytick, PLINT nysub)
Definition: plstream.cc:405
void MinMax2dGrid(const PLFLT *const *f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin)
Definition: plstream.cc:2779
void lab(const char *xlabel, const char *ylabel, const char *tlabel)
Definition: plstream.cc:1022
#define plgcmap1_range
Definition: plplot.h:802
#define plcol0
Definition: plplot.h:698
void string3(PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const char *string)
Definition: plstream.cc:2223
void plgfile(FILE **p_file)
Definition: plcore.c:3773
void plsKeyEH(void(*KeyEH)(PLGraphicsIn *, void *, int *), void *KeyEH_data)
Definition: plcore.c:3694
#define plbox3
Definition: plplot.h:694
PLINT translatecursor(PLGraphicsIn *gin)
Definition: plstream.cc:1426
#define plcolorbar
Definition: plplot.h:700
void gpage(PLFLT &xp, PLFLT &yp, PLINT &xleng, PLINT &yleng, PLINT &xoff, PLINT &yoff)
Definition: plstream.cc:865
void gdidev(PLFLT &mar, PLFLT &aspect, PLFLT &jx, PLFLT &jy)
Definition: plstream.cc:793
void sError(PLINT *errcode, char *errmsg)
Definition: plstream.cc:2527
void lightsource(PLFLT x, PLFLT y, PLFLT z)
Definition: plstream.cc:1080
void sxwin(PLINT window_id)
Definition: plstream.cc:2338
void hist(PLINT n, const PLFLT *data, PLFLT datmin, PLFLT datmax, PLINT nbin, PLINT oldwin)
Definition: plstream.cc:978
#define plglevel
Definition: plplot.h:733
void maptex(PLMAPFORM_callback mapform, const char *name, PLFLT dx, PLFLT dy, PLFLT just, const char *text, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT plotentry)
Definition: plstream.cc:1150
void ptex(PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just, const char *text)
Definition: plstream.cc:1404
void scol0(PLINT icol0, PLINT r, PLINT g, PLINT b)
Definition: plstream.cc:1632
#define plpoin3
Definition: plplot.h:779
void gcol0(PLINT icol0, PLINT &r, PLINT &g, PLINT &b)
Definition: plstream.cc:748
#define plscmap0n
Definition: plplot.h:795
void poin3(PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT code)
Definition: plstream.cc:1342
void gFileDevs(const char ***p_menustr, const char ***p_devname, int *p_ndev)
Definition: plstream.cc:2507
#define plscolor
Definition: plplot.h:807
#define plsvpa
Definition: plplot.h:851
#define plpat
Definition: plplot.h:777
void meridians(PLMAPFORM_callback mapform, PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat)
Definition: plstream.cc:1173
void ClearOpts(void)
Definition: plstream.cc:2609
#define plscmap1_range
Definition: plplot.h:801
void gvpd(PLFLT &xmin, PLFLT &xmax, PLFLT &ymin, PLFLT &ymax)
Definition: plstream.cc:933
#define plgcol0
Definition: plplot.h:719
PLDLLIMPEXP_CXX void tr2(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plstream.cc:266
void gradient(PLINT n, const PLFLT *x, const PLFLT *y, PLFLT angle)
Definition: plstream.cc:885
static PLINT active_streams
Definition: plstream.h:120
PLFLT plGetFlt(PLCHAR_VECTOR s)
Definition: plctrl.c:2935
#define plreplot
Definition: plplot.h:786
void spal0(const char *filename)
Definition: plstream.cc:2118
void flush(void)
Definition: plstream.cc:712
void legend(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, const PLINT *opt_array, PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing, PLFLT text_justification, const PLINT *text_colors, const char *const *text, const PLINT *box_colors, const PLINT *box_patterns, const PLFLT *box_scales, const PLFLT *box_line_widths, const PLINT *line_colors, const PLINT *line_styles, const PLFLT *line_widths, const PLINT *symbol_colors, const PLFLT *symbol_scales, const PLINT *symbol_numbers, const char *const *symbols)
Definition: plstream.cc:1032
void arc(PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2, PLFLT rotate, PLBOOL fill)
Definition: plstream.cc:367
PLDLLIMPEXP_CXX void tr1(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plstream.cc:257
void hlsrgb(PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g, PLFLT *p_b)
Definition: plstream.cc:2789
void cont(const PLFLT *const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plstream.cc:541
static char errmsg[160]
Definition: tclAPI.c:158
#define plscmap1l
Definition: plplot.h:798
void plmap(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy)
Definition: plmap.c:599
#define plprec
Definition: plplot.h:781
void sdiplz(PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax)
Definition: plstream.cc:1743
#define plptex
Definition: plplot.h:783
void xormod(bool mode, bool *status)
Definition: plstream.cc:2462
#define plline
Definition: plplot.h:758
void fill3(PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z)
Definition: plstream.cc:703
#define plgradient
Definition: plplot.h:736
void gfont(PLINT &family, PLINT &style, PLINT &weight)
Definition: plstream.cc:847
void OptUsage(void)
Definition: plstream.cc:2665
void slabelfunc(PLLABEL_FUNC_callback label_func, PLPointer label_data)
Definition: plstream.cc:2054
void ptex3(PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz, PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text)
Definition: plstream.cc:1414
#define pladv
Definition: plplot.h:688
#define plvasp
Definition: plplot.h:858
virtual void set_stream(void)
Definition: plstream.h:129
#define plrandd
Definition: plplot.h:785
void scmap1_range(PLFLT min_color, PLFLT max_color)
Definition: plstream.cc:1493
void Alloc2dGrid(PLFLT ***f, PLINT nx, PLINT ny)
Definition: plstream.cc:2762
PLFLT Contourable_Data_evaluator(PLINT i, PLINT j, PLPointer p)
Definition: plstream.cc:37
void gdiori(PLFLT &rot)
Definition: plstream.cc:802
#define plscmap0
Definition: plplot.h:793
void plmapstring(PLMAPFORM_callback mapform, PLCHAR_VECTOR name, PLCHAR_VECTOR string, PLFLT minx, PLFLT maxx, PLFLT miny, PLFLT maxy, PLINT_VECTOR plotentries, PLINT nplotentries)
Definition: plmap.c:650
void colorbar(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, PLINT *label_opts, const char *const *label, PLINT n_axes, const char *const *axis_opts, PLFLT *ticks, PLINT *sub_ticks, PLINT *n_values, const PLFLT *const *values)
Definition: plstream.cc:1057
void smin(PLFLT def, PLFLT scale)
Definition: plstream.cc:2090
#define plgstrm
Definition: plplot.h:739
void pltr2p(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data)
Definition: plcont.c:1113
#define plsfci
Definition: plplot.h:819
void plfcont(PLF2EVAL_callback f2eval, PLPointer f2eval_data, PLINT nx, PLINT ny, PLINT kx, PLINT lx, PLINT ky, PLINT ly, PLFLT_VECTOR clevel, PLINT nlevel, PLTRANSFORM_callback pltr, PLPointer pltr_data)
Definition: plcont.c:535
void scmap0n(PLINT ncol0)
Definition: plstream.cc:1475
plResetOpts
Definition: plplotc.py:8410
void gzax(PLINT &digmax, PLINT &digits)
Definition: plstream.cc:969
#define plmtex
Definition: plplot.h:771
#define plsurf3d
Definition: plplot.h:848
#define plgra
Definition: plplot.h:735
PLINT GetCursor(PLGraphicsIn *plg)
Definition: plstream.cc:2807
void string(PLINT n, const PLFLT *x, const PLFLT *y, const char *string)
Definition: plstream.cc:2211
#define plsdimap
Definition: plplot.h:811
void psty(PLINT patt)
Definition: plstream.cc:1395
void calc_world(PLFLT rx, PLFLT ry, PLFLT &wx, PLFLT &wy, PLINT &window)
Definition: plstream.cc:467
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
PLcolor
Definition: plstream.h:38
PLINT FindName(char *p)
Definition: plstream.cc:2713
void famadv(void)
Definition: plstream.cc:685
#define plslabelfunc
Definition: plplot.h:825
void gcolbga(PLINT &r, PLINT &g, PLINT &b, PLFLT &a)
Definition: plstream.cc:775