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