• Main Page
  • Namespaces
  • Classes
  • Files
  • File List
  • File Members

plstream.cc

Go to the documentation of this file.
00001 //----------------------------------*-C++-*----------------------------------//
00002 // $Id: plstream.cc 11935 2011-09-25 16:09:38Z airwin $
00003 // Geoffrey Furnish
00004 // Sep 21 1994
00005 //
00006 // Copyright (C) 2004,2005  Andrew Ross
00007 // Copyright (C) 2004  Alan W. Irwin
00008 //
00009 // This file is part of PLplot.
00010 //
00011 // PLplot is free software; you can redistribute it and/or modify
00012 // it under the terms of the GNU Library General Public License as published
00013 // by the Free Software Foundation; either version 2 of the License, or
00014 // (at your option) any later version.
00015 //
00016 // PLplot is distributed in the hope that it will be useful,
00017 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00018 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00019 // GNU Library General Public License for more details.
00020 //
00021 // You should have received a copy of the GNU Library General Public License
00022 // along with PLplot; if not, write to the Free Software
00023 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00024 
00025 //--------------------------------------------------------------------------
00026 // @> Source file plstream.
00027 //--------------------------------------------------------------------------
00028 
00029 #include "plplot.h"
00030 #include "plstream.h"
00031 
00032 #include <iostream>
00033 
00034 #ifdef PL_USE_NAMESPACE
00035 using namespace std;
00036 #endif
00037 
00038 PLFLT Contourable_Data_evaluator( PLINT i, PLINT j, PLPointer p )
00039 {
00040     const Contourable_Data& d = *(Contourable_Data *) p;
00041 
00042     return d( i, j );
00043 }
00044 
00045 void Coord_Xform_evaluator( PLFLT ox, PLFLT oy,
00046                             PLFLT *nx, PLFLT *ny, PLPointer p )
00047 {
00048     const Coord_Xformer& xf = *(Coord_Xformer *) p;
00049 
00050     xf.xform( ox, oy, *nx, *ny );
00051 }
00052 
00053 // A specific case for handling transformation defined by 2-d grid vertex
00054 // specification matrices.
00055 
00056 cxx_pltr2::cxx_pltr2( Coord_2d& cx, Coord_2d& cy )
00057     : xg( cx ), yg( cy )
00058 {
00059 }
00060 
00061 // Next routine copied and modified for C++ from PLPLOT 4.99d.
00062 
00063 //--------------------------------------------------------------------------
00064 // pltr2()
00065 //
00066 // Does linear interpolation from doubly dimensioned coord arrays
00067 // (column dominant, as per normal C 2d arrays).
00068 //
00069 // This routine includes lots of checks for out of bounds.  This would
00070 // occur occasionally due to some bugs in the contour plotter (now fixed).
00071 // If an out of bounds coordinate is obtained, the boundary value is provided
00072 // along with a warning.  These checks should stay since no harm is done if
00073 // if everything works correctly.
00074 //--------------------------------------------------------------------------
00075 
00076 void cxx_pltr2::xform( PLFLT x, PLFLT y, PLFLT& tx, PLFLT& ty ) const
00077 {
00078     int nx, ny;
00079     xg.elements( nx, ny );
00080 
00081     int   ul, ur, vl, vr;
00082     PLFLT du, dv;
00083 
00084     PLFLT xll, xlr, xrl, xrr;
00085     PLFLT yll, ylr, yrl, yrr;
00086     PLFLT xmin, xmax, ymin, ymax;
00087 
00088     ul = (int) x;
00089     ur = ul + 1;
00090     du = x - ul;
00091 
00092     vl = (int) y;
00093     vr = vl + 1;
00094     dv = y - vl;
00095 
00096     xmin = 0;
00097     xmax = nx - 1;
00098     ymin = 0;
00099     ymax = ny - 1;
00100 
00101     if ( x < xmin || x > xmax || y < ymin || y > ymax )
00102     {
00103         cerr << "cxx_pltr2::xform, Invalid coordinates\n";
00104 
00105         if ( x < xmin )
00106         {
00107             if ( y < ymin )
00108             {
00109                 tx = xg( 0, 0 );
00110                 ty = yg( 0, 0 );
00111             }
00112             else if ( y > ymax )
00113             {
00114                 tx = xg( 0, ny - 1 );
00115                 ty = yg( 0, ny - 1 );
00116             }
00117             else
00118             {
00119                 xll = xg( 0, vl );
00120                 yll = yg( 0, vl );
00121                 xlr = xg( 0, vr );
00122                 ylr = yg( 0, vr );
00123 
00124                 tx = xll * ( 1 - dv ) + xlr * ( dv );
00125                 ty = yll * ( 1 - dv ) + ylr * ( dv );
00126             }
00127         }
00128         else if ( x > xmax )
00129         {
00130             if ( y < ymin )
00131             {
00132                 tx = xg( nx - 1, 0 );
00133                 ty = yg( nx - 1, 0 );
00134             }
00135             else if ( y > ymax )
00136             {
00137                 tx = xg( nx - 1, ny - 1 );
00138                 ty = yg( nx - 1, ny - 1 );
00139             }
00140             else
00141             {
00142                 xll = xg( nx - 1, vl );
00143                 yll = yg( nx - 1, vl );
00144                 xlr = xg( nx - 1, vr );
00145                 ylr = yg( nx - 1, vr );
00146 
00147                 tx = xll * ( 1 - dv ) + xlr * ( dv );
00148                 ty = yll * ( 1 - dv ) + ylr * ( dv );
00149             }
00150         }
00151         else
00152         {
00153             if ( y < ymin )
00154             {
00155                 xll = xg( ul, 0 );
00156                 xrl = xg( ur, 0 );
00157                 yll = yg( ul, 0 );
00158                 yrl = yg( ur, 0 );
00159 
00160                 tx = xll * ( 1 - du ) + xrl * ( du );
00161                 ty = yll * ( 1 - du ) + yrl * ( du );
00162             }
00163             else if ( y > ymax )
00164             {
00165                 xlr = xg( ul, ny - 1 );
00166                 xrr = xg( ur, ny - 1 );
00167                 ylr = yg( ul, ny - 1 );
00168                 yrr = yg( ur, ny - 1 );
00169 
00170                 tx = xlr * ( 1 - du ) + xrr * ( du );
00171                 ty = ylr * ( 1 - du ) + yrr * ( du );
00172             }
00173         }
00174     }
00175 
00176 // Normal case.
00177 // Look up coordinates in row-dominant array.
00178 // Have to handle right boundary specially -- if at the edge, we'd
00179 // better not reference the out of bounds point.
00180 
00181     else
00182     {
00183         xll = xg( ul, vl );
00184         yll = yg( ul, vl );
00185 
00186 // ur is out of bounds
00187 
00188         if ( ur == nx && vr < ny )
00189         {
00190             xlr = xg( ul, vr );
00191             ylr = yg( ul, vr );
00192 
00193             tx = xll * ( 1 - dv ) + xlr * ( dv );
00194             ty = yll * ( 1 - dv ) + ylr * ( dv );
00195         }
00196 
00197 // vr is out of bounds
00198 
00199         else if ( ur < nx && vr == ny )
00200         {
00201             xrl = xg( ur, vl );
00202             yrl = yg( ur, vl );
00203 
00204             tx = xll * ( 1 - du ) + xrl * ( du );
00205             ty = yll * ( 1 - du ) + yrl * ( du );
00206         }
00207 
00208 // both ur and vr are out of bounds
00209 
00210         else if ( ur == nx && vr == ny )
00211         {
00212             tx = xll;
00213             ty = yll;
00214         }
00215 
00216 // everything in bounds
00217 
00218         else
00219         {
00220             xrl = xg( ur, vl );
00221             xlr = xg( ul, vr );
00222             xrr = xg( ur, vr );
00223 
00224             yrl = yg( ur, vl );
00225             ylr = yg( ul, vr );
00226             yrr = yg( ur, vr );
00227 
00228             tx = xll * ( 1 - du ) * ( 1 - dv ) + xlr * ( 1 - du ) * ( dv ) +
00229                  xrl * ( du ) * ( 1 - dv ) + xrr * ( du ) * ( dv );
00230 
00231             ty = yll * ( 1 - du ) * ( 1 - dv ) + ylr * ( 1 - du ) * ( dv ) +
00232                  yrl * ( du ) * ( 1 - dv ) + yrr * ( du ) * ( dv );
00233         }
00234     }
00235 }
00236 
00237 PLINT plstream::active_streams = 0;
00238 
00239 plstream::plstream()
00240 {
00241     ::c_plmkstrm( &stream );
00242     //::c_plinit();
00243     active_streams++;
00244 }
00245 
00246 plstream::plstream ( PLS::stream_id sid, PLINT strm /*=0*/ )
00247 {
00248     switch ( sid )
00249     {
00250     case PLS::Next:
00251 //      throw( "plstream ctor option not implemented." );
00252         break;
00253 
00254     case PLS::Current:
00255         ::c_plgstrm( &stream );
00256         break;
00257 
00258     case PLS::Specific:
00259         stream = strm;
00260         break;
00261 
00262     default:
00263 //      throw( "plstream ctor option not implemented." );
00264         break;
00265     }
00266 }
00267 
00268 plstream::plstream( PLINT nx, PLINT ny, const char *driver, const char *file )
00269 {
00270     ::c_plmkstrm( &stream );
00271 
00272     if ( driver )
00273         ::c_plsdev( driver );
00274     if ( file )
00275         ::c_plsfnam( file );
00276     ::c_plssub( nx, ny );
00277     //::c_plinit();
00278 
00279     active_streams++;
00280 }
00281 
00282 plstream::plstream( PLINT nx, PLINT ny, PLINT r, PLINT g, PLINT b,
00283                     const char *driver, const char *file )
00284 {
00285     ::c_plmkstrm( &stream );
00286 
00287     if ( driver )
00288         ::c_plsdev( driver );
00289     if ( file )
00290         ::c_plsfnam( file );
00291     ::c_plssub( nx, ny );
00292     ::c_plscolbg( r, g, b );
00293     //::c_plinit();
00294 
00295     active_streams++;
00296 }
00297 
00298 plstream::~plstream()
00299 {
00300     ::c_plsstrm( stream );
00301     ::c_plend1();
00302 
00303     active_streams--;
00304     if ( !active_streams )
00305         ::c_plend();
00306 }
00307 
00308 #define BONZAI    { throw "plstream method not implemented."; }
00309 
00310 // C routines callable from stub routines come first
00311 
00312 // Advance to subpage "page", or to the next one if "page" = 0.
00313 
00314 void
00315 plstream::adv( PLINT page )
00316 {
00317     set_stream();
00318 
00319     pladv( page );
00320 }
00321 
00322 void
00323 plstream::arc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
00324                PLFLT rotate, PLBOOL fill )
00325 {
00326     set_stream();
00327 
00328     plarc( x, y, a, b, angle1, angle2, rotate, fill );
00329 }
00330 
00331 void
00332 plstream::vect( const PLFLT * const *u, const PLFLT * const *v, PLINT nx, PLINT ny, PLFLT scale,
00333                 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00334                 PLPointer pltr_data )
00335 {
00336     set_stream();
00337 
00338     plvect( (const PLFLT **) u, (const PLFLT **) v, nx, ny, scale, pltr, pltr_data );
00339 }
00340 
00341 void
00342 plstream::svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, bool fill )
00343 {
00344     set_stream();
00345 
00346     plsvect( arrow_x, arrow_y, npts, (PLBOOL) fill );
00347 }
00348 
00349 // Deprecated version using PLINT instead of bool
00350 void
00351 plstream::svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, PLINT fill )
00352 {
00353     set_stream();
00354 
00355     plsvect( arrow_x, arrow_y, npts, (PLBOOL) fill );
00356 }
00357 
00358 // This functions similarly to plbox() except that the origin of the axes is
00359 // placed at the user-specified point (x0, y0).
00360 
00361 void
00362 plstream::axes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
00363                 const char *yopt, PLFLT ytick, PLINT nysub )
00364 {
00365     set_stream();
00366 
00367     plaxes( x0, y0, xopt, xtick, nxsub, yopt, ytick, nysub );
00368 }
00369 
00370 // Plot a histogram using x to store data values and y to store frequencies.
00371 
00372 void plstream::bin( PLINT nbin, const PLFLT *x, const PLFLT *y, PLINT center )
00373 {
00374     set_stream();
00375 
00376     plbin( nbin, x, y, center );
00377 }
00378 
00379 // Start new page.  Should only be used with pleop().
00380 
00381 void plstream::bop()
00382 {
00383     set_stream();
00384 
00385     plbop();
00386 }
00387 
00388 // This draws a box around the current viewport.
00389 
00390 void plstream::box( const char *xopt, PLFLT xtick, PLINT nxsub,
00391                     const char *yopt, PLFLT ytick, PLINT nysub )
00392 {
00393     set_stream();
00394 
00395     plbox( xopt, xtick, nxsub, yopt, ytick, nysub );
00396 }
00397 
00398 
00399 // This is the 3-d analogue of plbox().
00400 
00401 void
00402 plstream::box3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx,
00403                 const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby,
00404                 const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz )
00405 {
00406     set_stream();
00407 
00408     plbox3( xopt, xlabel, xtick, nsubx,
00409         yopt, ylabel, ytick, nsuby,
00410         zopt, zlabel, ztick, nsubz );
00411 }
00412 
00413 // Calculate broken-down time from continuous time for current stream.
00414 void plstream::btime( PLINT & year, PLINT & month, PLINT & day, PLINT & hour,
00415                       PLINT & min, PLFLT & sec, PLFLT ctime )
00416 {
00417     set_stream();
00418 
00419     plbtime( &year, &month, &day, &hour, &min, &sec, ctime );
00420 }
00421 
00422 // Calculate world coordinates and subpage from relative device coordinates.
00423 
00424 void plstream::calc_world( PLFLT rx, PLFLT ry, PLFLT & wx, PLFLT & wy,
00425                            PLINT & window )
00426 {
00427     set_stream();
00428 
00429     plcalc_world( rx, ry, &wx, &wy, &window );
00430 }
00431 
00432 // Clear the current subpage.
00433 
00434 void plstream::clear()
00435 {
00436     set_stream();
00437 
00438     plclear();
00439 }
00440 
00441 // Set color, map 0.  Argument is integer between 0 and 15.
00442 
00443 void plstream::col0( PLINT icol0 )
00444 {
00445     set_stream();
00446 
00447     plcol0( icol0 );
00448 }
00449 
00450 // Set the color using a descriptive name.  Replaces plcol0().
00451 
00452 void plstream::col( PLcolor c )
00453 {
00454     set_stream();
00455 
00456     plcol0( (int) c );
00457 }
00458 
00459 // Set color, map 1.  Argument is a float between 0. and 1.
00460 
00461 void plstream::col1( PLFLT c )
00462 {
00463     set_stream();
00464 
00465     plcol1( c );
00466 }
00467 
00468 // Old (incorrect) version retained only for compatibility
00469 void plstream::col( PLFLT c )
00470 {
00471     set_stream();
00472 
00473     cerr <<
00474     "plstream::col(PLFLT c) : function deprecated. Use plstream::col1(PLFLT c) instead"
00475          << endl;
00476 
00477     plcol1( c );
00478 }
00479 
00480 // Configure transformation between continuous and broken-down time (and
00481 // vice versa) for current stream.
00482 void plstream::configtime( PLFLT scale, PLFLT offset1, PLFLT offset2,
00483                            PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year,
00484                            PLINT month, PLINT day, PLINT hour, PLINT min,
00485                            PLFLT sec )
00486 {
00487     set_stream();
00488 
00489     plconfigtime( scale, offset1, offset2, ccontrol, ifbtime_offset, year,
00490         month, day, hour, min, sec );
00491 }
00492 
00493 
00494 
00495 // Draws a contour plot from data in f(nx,ny).  Is just a front-end to
00496 // plfcont, with a particular choice for f2eval and f2eval_data.
00497 
00498 void plstream::cont( const PLFLT * const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx,
00499                      PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel,
00500                      void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00501                      PLPointer pltr_data )
00502 {
00503     set_stream();
00504 
00505     plcont( (const PLFLT **) f, nx, ny, kx, lx, ky, ly, clevel, nlevel,
00506         pltr, pltr_data );
00507 }
00508 
00509 // Draws a contour plot using the function evaluator f2eval and data stored
00510 // by way of the f2eval_data pointer.  This allows arbitrary organizations
00511 // of 2d array data to be used.
00512 
00513 void plstream::fcont( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
00514                       PLPointer f2eval_data,
00515                       PLINT nx, PLINT ny, PLINT kx, PLINT lx,
00516                       PLINT ky, PLINT ly, const PLFLT *clevel, PLINT nlevel,
00517                       void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00518                       PLPointer pltr_data )
00519 {
00520     set_stream();
00521 
00522     plfcont( f2eval, f2eval_data,
00523         nx, ny, kx, lx, ky, ly, clevel, nlevel,
00524         pltr, pltr_data );
00525 }
00526 
00527 // Copies state parameters from the reference stream to the current stream.
00528 
00529 void plstream::cpstrm( plstream & pls, bool flags )
00530 {
00531     set_stream();
00532 
00533     plcpstrm( pls.stream, (PLBOOL) flags );
00534 }
00535 
00536 // Deprecated version using PLINT not bool
00537 void plstream::cpstrm( plstream & pls, PLINT flags )
00538 {
00539     set_stream();
00540 
00541     plcpstrm( pls.stream, (PLBOOL) flags );
00542 }
00543 
00544 // Calculate continuous time from broken-down time for current stream.
00545 void plstream::ctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min,
00546                       PLFLT sec, PLFLT & ctime )
00547 {
00548     set_stream();
00549 
00550     plctime( year, month, day, hour, min, sec, &ctime );
00551 }
00552 
00553 // Converts input values from relative device coordinates to relative plot
00554 // coordinates.
00555 
00556 void plstream::did2pc( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
00557 {
00558     set_stream();
00559 
00560     pldid2pc( &xmin, &ymin, &xmax, &ymax );
00561 }
00562 
00563 // Converts input values from relative plot coordinates to relative device
00564 // coordinates.
00565 
00566 void plstream::dip2dc( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
00567 {
00568     set_stream();
00569 
00570     pldip2dc( &xmin, &ymin, &xmax, &ymax );
00571 }
00572 
00573 // These shouldn't be needed, are supposed to be handled by ctor/dtor
00574 // semantics of the plstream object.
00575 
00576 // End a plotting session for all open streams.
00577 
00578 // void plstream::end()
00579 // {
00580 //     set_stream();
00581 
00582 //     plend();
00583 // }
00584 
00585 // End a plotting session for the current stream only.
00586 
00587 // void plstream::end1()
00588 // {
00589 //     set_stream();
00590 
00591 //     plend1();
00592 // }
00593 
00594 // Simple interface for defining viewport and window.
00595 
00596 void plstream::env( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00597                     PLINT just, PLINT axis )
00598 {
00599     set_stream();
00600 
00601     plenv( xmin, xmax, ymin, ymax, just, axis );
00602 }
00603 
00604 // Similar to env() above, but in multiplot mode does not advance
00605 // the subpage, instead the current subpage is cleared
00606 
00607 void plstream::env0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00608                      PLINT just, PLINT axis )
00609 {
00610     set_stream();
00611 
00612     plenv0( xmin, xmax, ymin, ymax, just, axis );
00613 }
00614 
00615 // End current page.  Should only be used with plbop().
00616 
00617 void plstream::eop()
00618 {
00619     set_stream();
00620 
00621     pleop();
00622 }
00623 
00624 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i)).
00625 
00626 void plstream::errx( PLINT n, const PLFLT *xmin, const PLFLT *xmax, const PLFLT *y )
00627 {
00628     set_stream();
00629 
00630     plerrx( n, xmin, xmax, y );
00631 }
00632 
00633 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i)).
00634 
00635 void plstream::erry( PLINT n, const PLFLT *x, const PLFLT *ymin, const PLFLT *ymax )
00636 {
00637     set_stream();
00638 
00639     plerry( n, x, ymin, ymax );
00640 }
00641 
00642 // Advance to the next family file on the next new page.
00643 
00644 void plstream::famadv()
00645 {
00646     set_stream();
00647 
00648     plfamadv();
00649 }
00650 
00651 // Pattern fills the polygon bounded by the input points.
00652 
00653 void plstream::fill( PLINT n, const PLFLT *x, const PLFLT *y )
00654 {
00655     //set_stream();
00656 
00657     plfill( n, x, y );
00658 }
00659 
00660 // Pattern fills the 3d polygon bounded by the input points.
00661 
00662 void plstream::fill3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z )
00663 {
00664     //set_stream();
00665 
00666     plfill3( n, x, y, z );
00667 }
00668 
00669 // Flushes the output stream.  Use sparingly, if at all.
00670 
00671 void plstream::flush()
00672 {
00673     set_stream();
00674 
00675     ::c_plflush();
00676 }
00677 
00678 // Sets the global font flag to 'ifont'.
00679 
00680 void plstream::font( PLINT ifont )
00681 {
00682     set_stream();
00683 
00684     plfont( ifont );
00685 }
00686 
00687 // Load specified font set.
00688 
00689 void plstream::fontld( PLINT fnt )
00690 {
00691     set_stream();
00692 
00693     plfontld( fnt );
00694 }
00695 
00696 // Get character default height and current (scaled) height.
00697 
00698 void plstream::gchr( PLFLT & p_def, PLFLT & p_ht )
00699 {
00700     set_stream();
00701 
00702     plgchr( &p_def, &p_ht );
00703 }
00704 
00705 // Returns 8 bit RGB values for given color from color map 0.
00706 
00707 void plstream::gcol0( PLINT icol0, PLINT & r, PLINT & g, PLINT & b )
00708 {
00709     set_stream();
00710 
00711     plgcol0( icol0, &r, &g, &b );
00712 }
00713 
00714 // Returns 8 bit RGB values + alpha value for given color from color map 0.
00715 
00716 void plstream::gcol0a( PLINT icol0, PLINT & r, PLINT & g, PLINT & b, PLFLT & a )
00717 {
00718     set_stream();
00719 
00720     plgcol0a( icol0, &r, &g, &b, &a );
00721 }
00722 
00723 // Returns the background color by 8 bit RGB value.
00724 
00725 void plstream::gcolbg( PLINT & r, PLINT & g, PLINT & b )
00726 {
00727     set_stream();
00728 
00729     plgcolbg( &r, &g, &b );
00730 }
00731 
00732 // Returns the background color by 8 bit RGB value + alpha value.
00733 
00734 void plstream::gcolbga( PLINT & r, PLINT & g, PLINT & b, PLFLT & a )
00735 {
00736     set_stream();
00737 
00738     plgcolbga( &r, &g, &b, &a );
00739 }
00740 
00741 // Returns the current compression setting
00742 
00743 void plstream::gcompression( PLINT & compression )
00744 {
00745     set_stream();
00746 
00747     plgcompression( &compression );
00748 }
00749 
00750 // Retrieve current window into device space.
00751 
00752 void plstream::gdidev( PLFLT & mar, PLFLT & aspect, PLFLT & jx, PLFLT & jy )
00753 {
00754     set_stream();
00755 
00756     plgdidev( &mar, &aspect, &jx, &jy );
00757 }
00758 
00759 // Get plot orientation.
00760 
00761 void plstream::gdiori( PLFLT & rot )
00762 {
00763     set_stream();
00764 
00765     plgdiori( &rot );
00766 }
00767 
00768 // Retrieve current window into plot space.
00769 
00770 void plstream::gdiplt( PLFLT & xmin, PLFLT & ymin, PLFLT & xmax, PLFLT & ymax )
00771 {
00772     set_stream();
00773 
00774     plgdiplt( &xmin, &ymin, &xmax, &ymax );
00775 }
00776 
00777 // Get FCI (font characterization integer)
00778 
00779 void plstream::gfci( PLUNICODE & pfci )
00780 {
00781     set_stream();
00782 
00783     plgfci( &pfci );
00784 }
00785 
00786 // Get family file parameters.
00787 
00788 void plstream::gfam( PLINT & fam, PLINT & num, PLINT & bmax )
00789 {
00790     set_stream();
00791 
00792     plgfam( &fam, &num, &bmax );
00793 }
00794 
00795 // Get the (current) output file name.  Must be preallocated to >80 bytes.
00796 
00797 void plstream::gfnam( char *fnam )
00798 {
00799     set_stream();
00800 
00801     plgfnam( fnam );
00802 }
00803 
00804 // Get the current font family, style and weight
00805 
00806 void plstream::gfont( PLINT & family, PLINT & style, PLINT & weight )
00807 {
00808     set_stream();
00809 
00810     plgfont( &family, &style, &weight );
00811 }
00812 
00813 // Get current run level.
00814 
00815 void plstream::glevel( PLINT & level )
00816 {
00817     set_stream();
00818 
00819     plglevel( &level );
00820 }
00821 
00822 // Get output device parameters.
00823 
00824 void plstream::gpage( PLFLT & xp, PLFLT & yp, PLINT & xleng, PLINT & yleng,
00825                       PLINT & xoff, PLINT & yoff )
00826 {
00827     set_stream();
00828 
00829     plgpage( &xp, &yp, &xleng, &yleng, &xoff, &yoff );
00830 }
00831 
00832 // Switches to graphics screen.
00833 
00834 void plstream::gra()
00835 {
00836     set_stream();
00837 
00838     plgra();
00839 }
00840 
00841 
00842 // Draw gradient in polygon.
00843 
00844 void plstream::gradient( PLINT n, const PLFLT *x, const PLFLT *y, PLFLT angle )
00845 {
00846     //set_stream();
00847 
00848     plgradient( n, x, y, angle );
00849 }
00850 
00851 // grid irregularly sampled data
00852 void plstream::griddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts,
00853                          const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy,
00854                          PLFLT **zg, PLINT type, PLFLT data )
00855 {
00856     set_stream();
00857 
00858     plgriddata( x, y, z, npts, xg, nptsx, yg, nptsy, zg, type, data );
00859 }
00860 
00861 // Get subpage boundaries in absolute coordinates.
00862 
00863 void plstream::gspa( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
00864 {
00865     set_stream();
00866 
00867     plgspa( &xmin, &xmax, &ymin, &ymax );
00868 }
00869 
00870 // This shouldn't be needed in this model.
00871 
00872 // Get current stream number.
00873 
00874 // void plstream::gstrm( PLINT *p_strm )
00875 // {
00876 //     set_stream();
00877 
00878 //     plgstrm(p_strm);
00879 // }
00880 
00881 // Get the current library version number.
00882 
00883 void plstream::gver( char *p_ver )
00884 {
00885     set_stream();
00886 
00887     plgver( p_ver );
00888 }
00889 
00890 // Get viewport window in normalized world coordinates
00891 
00892 void plstream::gvpd( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
00893 {
00894     set_stream();
00895 
00896     plgvpd( &xmin, &xmax, &ymin, &ymax );
00897 }
00898 
00899 // Get viewport window in world coordinates
00900 
00901 void plstream::gvpw( PLFLT & xmin, PLFLT & xmax, PLFLT & ymin, PLFLT & ymax )
00902 {
00903     set_stream();
00904 
00905     plgvpw( &xmin, &xmax, &ymin, &ymax );
00906 }
00907 
00908 // Get x axis labeling parameters.
00909 
00910 void plstream::gxax( PLINT & digmax, PLINT & digits )
00911 {
00912     set_stream();
00913 
00914     plgxax( &digmax, &digits );
00915 }
00916 
00917 // Get y axis labeling parameters.
00918 
00919 void plstream::gyax( PLINT & digmax, PLINT & digits )
00920 {
00921     set_stream();
00922 
00923     plgyax( &digmax, &digits );
00924 }
00925 
00926 // Get z axis labeling parameters
00927 
00928 void plstream::gzax( PLINT & digmax, PLINT & digits )
00929 {
00930     set_stream();
00931 
00932     plgzax( &digmax, &digits );
00933 }
00934 
00935 // Draws a histogram of n values of a variable in array data[0..n-1]
00936 
00937 void plstream::hist( PLINT n, const PLFLT *data, PLFLT datmin, PLFLT datmax,
00938                      PLINT nbin, PLINT oldwin )
00939 {
00940     set_stream();
00941 
00942     plhist( n, data, datmin, datmax, nbin, oldwin );
00943 }
00944 
00945 // Set current color (map 0) by hue, lightness, and saturation.
00946 
00947 #ifdef PL_DEPRECATED
00948 void plstream::hls( PLFLT h, PLFLT l, PLFLT s )
00949 {
00950     set_stream();
00951 
00952     plhls( h, l, s );
00953 }
00954 #endif // PL_DEPRECATED
00955 
00956 // Initializes PLplot, using preset or default options
00957 
00958 void plstream::init()
00959 {
00960     set_stream();
00961 
00962     plinit();
00963 
00964     plgstrm( &stream );
00965 
00966     // This is only set in the constructor.
00967     //active_streams++;
00968 }
00969 
00970 // Draws a line segment from (x1, y1) to (x2, y2).
00971 
00972 void plstream::join( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 )
00973 {
00974     set_stream();
00975 
00976     pljoin( x1, y1, x2, y2 );
00977 }
00978 
00979 // Simple routine for labelling graphs.
00980 
00981 void plstream::lab( const char *xlabel, const char *ylabel,
00982                     const char *tlabel )
00983 {
00984     set_stream();
00985 
00986     pllab( xlabel, ylabel, tlabel );
00987 }
00988 
00989 // Routine for drawing line, symbol, or cmap0 legends
00990 
00991 void plstream::legend( PLFLT *p_legend_width, PLFLT *p_legend_height,
00992                        PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
00993                        PLINT bg_color, PLINT bb_color, PLINT bb_style,
00994                        PLINT nrow, PLINT ncolumn,
00995                        PLINT nlegend, const PLINT *opt_array,
00996                        PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
00997                        PLFLT text_justification,
00998                        const PLINT *text_colors, const char **text,
00999                        const PLINT *box_colors, const PLINT *box_patterns,
01000                        const PLFLT *box_scales, const PLINT *box_line_widths,
01001                        const PLINT *line_colors, const PLINT *line_styles,
01002                        const PLINT *line_widths,
01003                        const PLINT *symbol_colors, const PLFLT *symbol_scales,
01004                        const PLINT *symbol_numbers, const char **symbols )
01005 {
01006     set_stream();
01007 
01008     pllegend( p_legend_width, p_legend_height, opt, position, x, y, plot_width,
01009         bg_color, bb_color, bb_style, nrow, ncolumn, nlegend, opt_array,
01010         text_offset, text_scale, text_spacing, text_justification,
01011         text_colors, text, box_colors, box_patterns, box_scales,
01012         box_line_widths, line_colors, line_styles, line_widths,
01013         symbol_colors, symbol_scales, symbol_numbers, symbols );
01014 }
01015 
01016 void plstream::colorbar( PLINT position, PLINT opt, PLFLT x, PLFLT y, PLFLT length, PLFLT width, PLINT cont_color, PLINT cont_width,
01017                          PLFLT ticks, PLINT sub_ticks,
01018                          const char *axis_opts, const char *label,
01019                          PLINT n_colors, const PLFLT *colors, const PLFLT *values )
01020 {
01021     set_stream();
01022 
01023 #if 0
01024     plcolorbar( position, opt, x, y, length, width,
01025         cont_color, cont_width, ticks, sub_ticks, axis_opts,
01026         label, n_colors, colors, values );
01027 #endif
01028 }
01029 
01030 
01031 // Sets position of the light source
01032 
01033 void plstream::lightsource( PLFLT x, PLFLT y, PLFLT z )
01034 {
01035     set_stream();
01036 
01037     pllightsource( x, y, z );
01038 }
01039 
01040 // Draws line segments connecting a series of points.
01041 
01042 void plstream::line( PLINT n, const PLFLT *x, const PLFLT *y )
01043 {
01044     set_stream();
01045 
01046     plline( n, x, y );
01047 }
01048 
01049 // Draws a line in 3 space.
01050 
01051 void plstream::line3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z )
01052 {
01053     set_stream();
01054 
01055     plline3( n, x, y, z );
01056 }
01057 
01058 // Set line style.
01059 
01060 void plstream::lsty( PLINT lin )
01061 {
01062     set_stream();
01063 
01064     pllsty( lin );
01065 }
01066 
01067 // plot continental outline in world coordinates
01068 
01069 void plstream::map( void ( *mapform )( PLINT, PLFLT *, PLFLT * ),
01070                     const char *type, PLFLT minlong, PLFLT maxlong,
01071                     PLFLT minlat, PLFLT maxlat )
01072 {
01073     set_stream();
01074 
01075     plmap( mapform, type, minlong, maxlong, minlat, maxlat );
01076 }
01077 
01078 // Plot the latitudes and longitudes on the background.
01079 
01080 void plstream::meridians( void ( *mapform )( PLINT, PLFLT *, PLFLT * ),
01081                           PLFLT dlong, PLFLT dlat,
01082                           PLFLT minlong, PLFLT maxlong,
01083                           PLFLT minlat, PLFLT maxlat )
01084 {
01085     set_stream();
01086 
01087     plmeridians( mapform, dlong, dlat, minlong, maxlong, minlat,
01088         maxlat );
01089 }
01090 
01091 // Plots a mesh representation of the function z[x][y].
01092 
01093 void plstream::mesh( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny,
01094                      PLINT opt )
01095 {
01096     set_stream();
01097 
01098     plmesh( x, y, (const PLFLT **) z, nx, ny, opt );
01099 }
01100 
01101 // Plots a mesh representation of the function z[x][y] with contour.
01102 
01103 void plstream::meshc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny,
01104                       PLINT opt, const PLFLT *clevel, PLINT nlevel )
01105 {
01106     set_stream();
01107 
01108     plmeshc( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel );
01109 }
01110 
01111 //  Creates a new stream and makes it the default.
01112 
01113 // void plstream::mkstrm( PLINT *p_strm )
01114 // {
01115 //     set_stream();
01116 
01117 //     plmkstrm(p_strm);
01118 // }
01119 
01120 // Prints out "text" at specified position relative to viewport
01121 
01122 void plstream::mtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
01123                      const char *text )
01124 {
01125     set_stream();
01126 
01127     plmtex( side, disp, pos, just, text );
01128 }
01129 
01130 // Prints out "text" at specified position relative to viewport (3D)
01131 
01132 void plstream::mtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
01133                       const char *text )
01134 {
01135     set_stream();
01136 
01137     plmtex3( side, disp, pos, just, text );
01138 }
01139 
01140 // Plots a 3-d shaded representation of the function z[x][y].
01141 
01142 void plstream::surf3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01143                        PLINT nx, PLINT ny, PLINT opt,
01144                        const PLFLT *clevel, PLINT nlevel )
01145 {
01146     set_stream();
01147 
01148     plsurf3d( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel );
01149 }
01150 
01151 // Plots a 3-d shaded representation of the function z[x][y] with
01152 // y index limits
01153 
01154 void plstream::surf3dl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01155                         PLINT nx, PLINT ny, PLINT opt,
01156                         const PLFLT *clevel, PLINT nlevel,
01157                         PLINT ixstart, PLINT ixn,
01158                         const PLINT *indexymin, const PLINT *indexymax )
01159 {
01160     set_stream();
01161 
01162     plsurf3dl( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel, ixstart, ixn,
01163         indexymin, indexymax );
01164 }
01165 
01166 // Plots a 3-d representation of the function z[x][y].
01167 
01168 void plstream::plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01169                        PLINT nx, PLINT ny, PLINT opt, bool side )
01170 {
01171     set_stream();
01172 
01173     ::plot3d( x, y, (const PLFLT **) z, nx, ny, opt, (PLBOOL) side );
01174 }
01175 
01176 // Deprecated version using PLINT not bool
01177 void plstream::plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01178                        PLINT nx, PLINT ny, PLINT opt, PLINT side )
01179 {
01180     set_stream();
01181 
01182     ::plot3d( x, y, (const PLFLT **) z, nx, ny, opt, (PLBOOL) side );
01183 }
01184 
01185 // Plots a 3-d representation of the function z[x][y] with contour.
01186 
01187 void plstream::plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01188                         PLINT nx, PLINT ny, PLINT opt,
01189                         const PLFLT *clevel, PLINT nlevel )
01190 {
01191     set_stream();
01192 
01193     ::plot3dc( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel );
01194 }
01195 
01196 // Plots a 3-d representation of the function z[x][y] with contour
01197 // and y index limits
01198 
01199 void plstream::plot3dcl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01200                          PLINT nx, PLINT ny, PLINT opt,
01201                          const PLFLT *clevel, PLINT nlevel,
01202                          PLINT ixstart, PLINT ixn,
01203                          const PLINT *indexymin, const PLINT *indexymax )
01204 {
01205     set_stream();
01206 
01207     ::plot3dcl( x, y, (const PLFLT **) z, nx, ny, opt, clevel, nlevel, ixstart, ixn,
01208         indexymin, indexymax );
01209 }
01210 
01211 // Process options list using current options info.
01212 
01213 int plstream::parseopts( int *p_argc, const char **argv, PLINT mode )
01214 {
01215     set_stream();
01216 
01217     return ::plparseopts( p_argc, argv, mode );
01218 }
01219 
01220 // Set fill pattern directly.
01221 
01222 void plstream::pat( PLINT nlin, const PLINT *inc, const PLINT *del )
01223 {
01224     set_stream();
01225 
01226     plpat( nlin, inc, del );
01227 }
01228 
01229 // Plots array y against x for n points using ASCII code "code".
01230 
01231 void plstream::poin( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code )
01232 {
01233     set_stream();
01234 
01235     plpoin( n, x, y, code );
01236 }
01237 
01238 // Draws a series of points in 3 space.
01239 
01240 void plstream::poin3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT code )
01241 {
01242     set_stream();
01243 
01244     plpoin3( n, x, y, z, code );
01245 }
01246 
01247 // Draws a polygon in 3 space.
01248 
01249 void plstream::poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z,
01250                       const bool *draw, bool ifcc )
01251 {
01252     PLBOOL *loc_draw = new PLBOOL[n - 1];
01253     for ( int i = 0; i < n - 1; i++ )
01254     {
01255         loc_draw[i] = (PLBOOL) draw[i];
01256     }
01257 
01258     set_stream();
01259 
01260     plpoly3( n, x, y, z, loc_draw, (PLBOOL) ifcc );
01261 
01262     delete [] loc_draw;
01263 }
01264 
01265 // Deprecated version using PLINT not bool
01266 void plstream::poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z,
01267                       const PLINT *draw, PLINT ifcc )
01268 {
01269     PLBOOL *loc_draw = new PLBOOL[n - 1];
01270     for ( int i = 0; i < n - 1; i++ )
01271     {
01272         loc_draw[i] = (PLBOOL) draw[i];
01273     }
01274 
01275     set_stream();
01276 
01277     plpoly3( n, x, y, z, loc_draw, (PLBOOL) ifcc );
01278 
01279     delete [] loc_draw;
01280 }
01281 
01282 // Set the floating point precision (in number of places) in numeric labels.
01283 
01284 void plstream::prec( PLINT setp, PLINT prec )
01285 {
01286     set_stream();
01287 
01288     plprec( setp, prec );
01289 }
01290 
01291 // Set fill pattern, using one of the predefined patterns.
01292 
01293 void plstream::psty( PLINT patt )
01294 {
01295     set_stream();
01296 
01297     plpsty( patt );
01298 }
01299 
01300 // Prints out "text" at world cooordinate (x,y).
01301 
01302 void plstream::ptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just,
01303                      const char *text )
01304 {
01305     set_stream();
01306 
01307     plptex( x, y, dx, dy, just, text );
01308 }
01309 
01310 // Prints out "text" at world cooordinate (x,y).
01311 
01312 void plstream::ptex3( PLFLT wx, PLFLT wy, PLFLT wz,
01313                       PLFLT dx, PLFLT dy, PLFLT dz,
01314                       PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just,
01315                       const char *text )
01316 {
01317     set_stream();
01318 
01319     plptex3( wx, wy, wz, dx, dy, dz, sx, sy, sz, just, text );
01320 }
01321 
01322 // Replays contents of plot buffer to current device/file.
01323 
01324 void plstream::replot()
01325 {
01326     set_stream();
01327 
01328     plreplot();
01329 }
01330 
01331 // Set line color by red, green, blue from  0. to 1.
01332 
01333 #ifdef PL_DEPRECATED
01334 void plstream::rgb( PLFLT r, PLFLT g, PLFLT b )
01335 {
01336     set_stream();
01337 
01338     plrgb( r, g, b );
01339 }
01340 #endif // PL_DEPRECATED
01341 
01342 // Set line color by 8 bit RGB values.
01343 
01344 #ifdef PL_DEPRECATED
01345 void plstream::rgb( PLINT r, PLINT g, PLINT b )
01346 {
01347     set_stream();
01348 
01349     plrgb1( r, g, b );
01350 }
01351 #endif // PL_DEPRECATED
01352 
01353 // Set character height.
01354 
01355 void plstream::schr( PLFLT def, PLFLT scale )
01356 {
01357     set_stream();
01358 
01359     plschr( def, scale );
01360 }
01361 
01362 // Set number of colors in cmap 0
01363 
01364 void plstream::scmap0n( PLINT ncol0 )
01365 {
01366     set_stream();
01367 
01368     plscmap0n( ncol0 );
01369 }
01370 
01371 // Set number of colors in cmap 1
01372 
01373 void plstream::scmap1n( PLINT ncol1 )
01374 {
01375     set_stream();
01376 
01377     plscmap1n( ncol1 );
01378 }
01379 
01380 // Set color map 0 colors by 8 bit RGB values
01381 
01382 void plstream::scmap0( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol0 )
01383 {
01384     set_stream();
01385 
01386     plscmap0( r, g, b, ncol0 );
01387 }
01388 
01389 // Set color map 0 colors by 8 bit RGB values + alpha value
01390 
01391 void plstream::scmap0a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol0 )
01392 {
01393     set_stream();
01394 
01395     plscmap0a( r, g, b, a, ncol0 );
01396 }
01397 
01398 // Set color map 1 colors by 8 bit RGB values
01399 
01400 void plstream::scmap1( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol1 )
01401 {
01402     set_stream();
01403 
01404     plscmap1( r, g, b, ncol1 );
01405 }
01406 
01407 // Set color map 1 colors by 8 bit RGB values + alpha value
01408 
01409 void plstream::scmap1a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol1 )
01410 {
01411     set_stream();
01412 
01413     plscmap1a( r, g, b, a, ncol1 );
01414 }
01415 
01416 // Set color map 1 colors using a piece-wise linear relationship between
01417 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
01418 
01419 void plstream::scmap1l( bool itype, PLINT npts, const PLFLT *intensity,
01420                         const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
01421                         const bool *rev )
01422 {
01423     PLBOOL *loc_rev = NULL;
01424     if ( rev != NULL )
01425     {
01426         loc_rev = new PLBOOL[npts - 1];
01427         for ( int i = 0; i < npts - 1; i++ )
01428         {
01429             loc_rev[i] = (PLBOOL) rev[i];
01430         }
01431     }
01432 
01433     set_stream();
01434 
01435     plscmap1l( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3, loc_rev );
01436 
01437     if ( loc_rev != NULL )
01438         delete [] loc_rev;
01439 }
01440 
01441 // Set color map 1 colors using a piece-wise linear relationship between
01442 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space
01443 // and alpha value.
01444 
01445 void plstream::scmap1la( bool itype, PLINT npts, const PLFLT *intensity,
01446                          const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
01447                          const PLFLT *a, const bool *rev )
01448 {
01449     PLBOOL *loc_rev = NULL;
01450     if ( rev != NULL )
01451     {
01452         loc_rev = new PLBOOL[npts - 1];
01453         for ( int i = 0; i < npts - 1; i++ )
01454         {
01455             loc_rev[i] = (PLBOOL) rev[i];
01456         }
01457     }
01458 
01459     set_stream();
01460 
01461     plscmap1la( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3,
01462         a, loc_rev );
01463 
01464     if ( loc_rev != NULL )
01465         delete [] loc_rev;
01466 }
01467 
01468 //
01469 // void plstream::scmap1l( bool itype, PLINT npts, PLFLT *intensity,
01470 //                      PLFLT *coord1, PLFLT *coord2, PLFLT *coord3)
01471 // {
01472 //  set_stream();
01473 //
01474 //  plscmap1l((PLBOOL) itype,npts,intensity,coord1,coord2,coord3,NULL);
01475 //
01476 // }
01477 
01478 // Deprecated version using PLINT instead of bool
01479 void plstream::scmap1l( PLINT itype, PLINT npts, const PLFLT *intensity,
01480                         const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3,
01481                         const PLINT *rev )
01482 {
01483     PLBOOL *loc_rev = NULL;
01484     if ( rev != NULL )
01485     {
01486         loc_rev = new PLBOOL[npts - 1];
01487         for ( int i = 0; i < npts - 1; i++ )
01488         {
01489             loc_rev[i] = (PLBOOL) rev[i];
01490         }
01491     }
01492 
01493     set_stream();
01494 
01495     plscmap1l( (PLBOOL) itype, npts, intensity, coord1, coord2, coord3, loc_rev );
01496 
01497     if ( loc_rev != NULL )
01498         delete [] loc_rev;
01499 }
01500 
01501 // Set a given color from color map 0 by 8 bit RGB value
01502 
01503 void plstream::scol0( PLINT icol0, PLINT r, PLINT g, PLINT b )
01504 {
01505     set_stream();
01506 
01507     plscol0( icol0, r, g, b );
01508 }
01509 
01510 // Set a given color from color map 0 by 8 bit RGB value + alpha value
01511 
01512 void plstream::scol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a )
01513 {
01514     set_stream();
01515 
01516     plscol0a( icol0, r, g, b, a );
01517 }
01518 
01519 // Set the background color by 8 bit RGB value
01520 
01521 void plstream::scolbg( PLINT r, PLINT g, PLINT b )
01522 {
01523     set_stream();
01524 
01525     plscolbg( r, g, b );
01526 }
01527 
01528 // Set the background color by 8 bit RGB + alpha value
01529 
01530 void plstream::scolbga( PLINT r, PLINT g, PLINT b, PLFLT a )
01531 {
01532     set_stream();
01533 
01534     plscolbga( r, g, b, a );
01535 }
01536 
01537 // Used to globally turn color output on/off
01538 
01539 void plstream::scolor( PLINT color )
01540 {
01541     set_stream();
01542 
01543     plscolor( color );
01544 }
01545 
01546 // Sets the compression level
01547 
01548 void plstream::scompression( PLINT compression )
01549 {
01550     set_stream();
01551 
01552     plscompression( compression );
01553 }
01554 
01555 // Set the device (keyword) name
01556 
01557 void plstream::sdev( const char *devname )
01558 {
01559     set_stream();
01560 
01561     plsdev( devname );
01562 }
01563 
01564 // Get the device (keyword) name
01565 
01566 void plstream::gdev( char *devname )
01567 {
01568     set_stream();
01569 
01570     plgdev( devname );
01571 }
01572 
01573 // Set window into device space using margin, aspect ratio, and
01574 // justification
01575 
01576 void plstream::sdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy )
01577 {
01578     set_stream();
01579 
01580     plsdidev( mar, aspect, jx, jy );
01581 }
01582 
01583 // Set up transformation from metafile coordinates.
01584 
01585 void plstream::sdimap( PLINT dimxmin, PLINT dimxmax,
01586                        PLINT dimymin, PLINT dimymax,
01587                        PLFLT dimxpmm, PLFLT dimypmm )
01588 {
01589     set_stream();
01590 
01591     plsdimap( dimxmin, dimxmax, dimymin, dimymax, dimxpmm, dimypmm );
01592 }
01593 
01594 // Set plot orientation, specifying rotation in units of pi/2.
01595 
01596 void plstream::sdiori( PLFLT rot )
01597 {
01598     set_stream();
01599 
01600     plsdiori( rot );
01601 }
01602 
01603 // Set window into plot space
01604 
01605 void plstream::sdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax )
01606 {
01607     set_stream();
01608 
01609     plsdiplt( xmin, ymin, xmax, ymax );
01610 }
01611 
01612 // Set window into plot space incrementally (zoom)
01613 
01614 void plstream::sdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax )
01615 {
01616     set_stream();
01617 
01618     plsdiplz( xmin, ymin, xmax, ymax );
01619 }
01620 
01621 // Set the escape character for text strings.
01622 
01623 void plstream::sesc( char esc )
01624 {
01625     set_stream();
01626 
01627     plsesc( esc );
01628 }
01629 
01630 // Set the offset and spacing of contour labels
01631 
01632 void plstream::setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing,
01633                                   PLINT active )
01634 {
01635     set_stream();
01636 
01637     pl_setcontlabelparam( offset, size, spacing, active );
01638 }
01639 
01640 // Set the format of the contour labels
01641 
01642 void plstream::setcontlabelformat( PLINT lexp, PLINT sigdig )
01643 {
01644     set_stream();
01645 
01646     pl_setcontlabelformat( lexp, sigdig );
01647 }
01648 
01649 // Set family file parameters
01650 
01651 void plstream::sfam( PLINT fam, PLINT num, PLINT bmax )
01652 {
01653     set_stream();
01654 
01655     plsfam( fam, num, bmax );
01656 }
01657 
01658 // Set FCI (font characterization integer)
01659 
01660 void plstream::sfci( PLUNICODE fci )
01661 {
01662     set_stream();
01663 
01664     plsfci( fci );
01665 }
01666 
01667 // Set the output file name.
01668 
01669 void plstream::sfnam( const char *fnam )
01670 {
01671     set_stream();
01672 
01673     plsfnam( fnam );
01674 }
01675 
01676 // Set the current font family, style and weight
01677 
01678 void plstream::sfont( PLINT family, PLINT style, PLINT weight )
01679 {
01680     set_stream();
01681 
01682     plsfont( family, style, weight );
01683 }
01684 
01685 // Shade region.
01686 
01687 void
01688 plstream::shade( const PLFLT * const *a, PLINT nx, PLINT ny,
01689                  PLINT ( *defined )( PLFLT, PLFLT ),
01690                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01691                  PLFLT shade_min, PLFLT shade_max,
01692                  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01693                  PLINT min_color, PLINT min_width,
01694                  PLINT max_color, PLINT max_width,
01695                  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
01696                  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01697                  PLPointer pltr_data )
01698 {
01699     set_stream();
01700 
01701     plshade( (const PLFLT **) a, nx, ny, defined, left, right, bottom, top,
01702         shade_min, shade_max,
01703         sh_cmap, sh_color, sh_width,
01704         min_color, min_width, max_color, max_width,
01705         fill, (PLBOOL) rectangular, pltr, pltr_data );
01706 }
01707 
01708 // Deprecated version using PLINT instead of bool
01709 void
01710 plstream::shade( const PLFLT * const *a, PLINT nx, PLINT ny,
01711                  PLINT ( *defined )( PLFLT, PLFLT ),
01712                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01713                  PLFLT shade_min, PLFLT shade_max,
01714                  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01715                  PLINT min_color, PLINT min_width,
01716                  PLINT max_color, PLINT max_width,
01717                  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01718                  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01719                  PLPointer pltr_data )
01720 {
01721     set_stream();
01722 
01723     plshade( (const PLFLT **) a, nx, ny, defined, left, right, bottom, top,
01724         shade_min, shade_max,
01725         sh_cmap, sh_color, sh_width,
01726         min_color, min_width, max_color, max_width,
01727         fill, (PLBOOL) rectangular, pltr, pltr_data );
01728 }
01729 
01730 void
01731 plstream::shades( const PLFLT * const *a, PLINT nx, PLINT ny,
01732                   PLINT ( *defined )( PLFLT, PLFLT ),
01733                   PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
01734                   const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
01735                   PLINT cont_color, PLINT cont_width,
01736                   void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
01737                   void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01738                   PLPointer pltr_data )
01739 {
01740     set_stream();
01741 
01742     plshades( (const PLFLT **) a, nx, ny, defined, xmin, xmax, ymin, ymax,
01743         clevel, nlevel, fill_width, cont_color, cont_width,
01744         fill, (PLBOOL) rectangular, pltr, pltr_data );
01745 }
01746 
01747 // Deprecated version using PLINT instead of bool
01748 void
01749 plstream::shades( const PLFLT * const *a, PLINT nx, PLINT ny,
01750                   PLINT ( *defined )( PLFLT, PLFLT ),
01751                   PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
01752                   const PLFLT *clevel, PLINT nlevel, PLINT fill_width,
01753                   PLINT cont_color, PLINT cont_width,
01754                   void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01755                   void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01756                   PLPointer pltr_data )
01757 {
01758     set_stream();
01759 
01760     plshades( (const PLFLT **) a, nx, ny, defined, xmin, xmax, ymin, ymax,
01761         clevel, nlevel, fill_width, cont_color, cont_width,
01762         fill, (PLBOOL) rectangular, pltr, pltr_data );
01763 }
01764 
01765 void
01766 plstream::shade( Contourable_Data & d, PLFLT xmin, PLFLT xmax,
01767                  PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
01768                  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01769                  PLINT min_color, PLINT min_width,
01770                  PLINT max_color, PLINT max_width,
01771                  bool rectangular,
01772                  Coord_Xformer *pcxf )
01773 {
01774     set_stream();
01775 
01776     int nx, ny;
01777     d.elements( nx, ny );
01778 
01779     if ( pcxf != NULL )
01780         ::plfshade( Contourable_Data_evaluator, &d,
01781             NULL, NULL,
01782             nx, ny,
01783             xmin, xmax, ymin, ymax, shade_min, shade_max,
01784             sh_cmap, sh_color, sh_width,
01785             min_color, min_width, max_color, max_width,
01786             ::plfill, rectangular,
01787             Coord_Xform_evaluator, pcxf );
01788     else
01789         ::plfshade( Contourable_Data_evaluator, &d,
01790             NULL, NULL,
01791             nx, ny,
01792             xmin, xmax, ymin, ymax, shade_min, shade_max,
01793             sh_cmap, sh_color, sh_width,
01794             min_color, min_width, max_color, max_width,
01795             ::plfill, rectangular,
01796             NULL, NULL );
01797 }
01798 
01799 // Deprecated version using PLINT not bool
01800 void
01801 plstream::shade( Contourable_Data & d, PLFLT xmin, PLFLT xmax,
01802                  PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
01803                  PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01804                  PLINT min_color, PLINT min_width,
01805                  PLINT max_color, PLINT max_width,
01806                  PLINT rectangular,
01807                  Coord_Xformer *pcxf )
01808 {
01809     set_stream();
01810 
01811     int nx, ny;
01812     d.elements( nx, ny );
01813 
01814     ::plfshade( Contourable_Data_evaluator, &d,
01815         NULL, NULL,
01816         nx, ny,
01817         xmin, xmax, ymin, ymax, shade_min, shade_max,
01818         sh_cmap, sh_color, sh_width,
01819         min_color, min_width, max_color, max_width,
01820         ::plfill, rectangular != 0,
01821         Coord_Xform_evaluator, pcxf );
01822 }
01823 
01824 void
01825 plstream::shade1( const PLFLT *a, PLINT nx, PLINT ny,
01826                   PLINT ( *defined )( PLFLT, PLFLT ),
01827                   PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01828                   PLFLT shade_min, PLFLT shade_max,
01829                   PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01830                   PLINT min_color, PLINT min_width,
01831                   PLINT max_color, PLINT max_width,
01832                   void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
01833                   void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01834                   PLPointer pltr_data )
01835 {
01836     set_stream();
01837 
01838     plshade1( a, nx, ny, defined,
01839         left, right, bottom, top,
01840         shade_min, shade_max,
01841         sh_cmap, sh_color, sh_width,
01842         min_color, min_width, max_color, max_width,
01843         fill, (PLBOOL) rectangular, pltr, pltr_data );
01844 }
01845 
01846 // Deprecated version using PLINT not bool
01847 void
01848 plstream::shade1( const PLFLT *a, PLINT nx, PLINT ny,
01849                   PLINT ( *defined )( PLFLT, PLFLT ),
01850                   PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01851                   PLFLT shade_min, PLFLT shade_max,
01852                   PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01853                   PLINT min_color, PLINT min_width,
01854                   PLINT max_color, PLINT max_width,
01855                   void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01856                   void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01857                   PLPointer pltr_data )
01858 {
01859     set_stream();
01860 
01861     plshade1( a, nx, ny, defined,
01862         left, right, bottom, top,
01863         shade_min, shade_max,
01864         sh_cmap, sh_color, sh_width,
01865         min_color, min_width, max_color, max_width,
01866         fill, (PLBOOL) rectangular, pltr, pltr_data );
01867 }
01868 
01869 void
01870 plstream::fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
01871                   PLPointer f2eval_data,
01872                   PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
01873                   PLPointer c2eval_data,
01874                   PLINT nx, PLINT ny,
01875                   PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01876                   PLFLT shade_min, PLFLT shade_max,
01877                   PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01878                   PLINT min_color, PLINT min_width,
01879                   PLINT max_color, PLINT max_width,
01880                   void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
01881                   void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01882                   PLPointer pltr_data )
01883 {
01884     set_stream();
01885 
01886     plfshade( f2eval, f2eval_data,
01887         c2eval, c2eval_data,
01888         nx, ny, left, right, bottom, top,
01889         shade_min, shade_max,
01890         sh_cmap, sh_color, sh_width,
01891         min_color, min_width, max_color, max_width,
01892         fill, (PLBOOL) rectangular, pltr, pltr_data );
01893 }
01894 
01895 // Deprecated version using PLINT not bool
01896 void
01897 plstream::fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
01898                   PLPointer f2eval_data,
01899                   PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
01900                   PLPointer c2eval_data,
01901                   PLINT nx, PLINT ny,
01902                   PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01903                   PLFLT shade_min, PLFLT shade_max,
01904                   PLINT sh_cmap, PLFLT sh_color, PLINT sh_width,
01905                   PLINT min_color, PLINT min_width,
01906                   PLINT max_color, PLINT max_width,
01907                   void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01908                   void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01909                   PLPointer pltr_data )
01910 {
01911     set_stream();
01912 
01913     plfshade( f2eval, f2eval_data,
01914         c2eval, c2eval_data,
01915         nx, ny, left, right, bottom, top,
01916         shade_min, shade_max,
01917         sh_cmap, sh_color, sh_width,
01918         min_color, min_width, max_color, max_width,
01919         fill, (PLBOOL) rectangular, pltr, pltr_data );
01920 }
01921 
01922 // Setup a user-provided custom labeling function
01923 
01924 void plstream::slabelfunc( void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer ),
01925                            PLPointer label_data )
01926 {
01927     set_stream();
01928 
01929     plslabelfunc( label_func, label_data );
01930 }
01931 
01932 // Set up lengths of major tick marks.
01933 
01934 void plstream::smaj( PLFLT def, PLFLT scale )
01935 {
01936     set_stream();
01937 
01938     plsmaj( def, scale );
01939 }
01940 
01941 // Set the RGB memory area to be plotted (with the 'mem' or 'memcairo' drivers)
01942 
01943 void plstream::smem( PLINT maxx, PLINT maxy, void *plotmem )
01944 {
01945     set_stream();
01946 
01947     plsmem( maxx, maxy, plotmem );
01948 }
01949 
01950 // Set the RGBA memory area to be plotted (with the 'memcairo' drivers)
01951 
01952 void plstream::smema( PLINT maxx, PLINT maxy, void *plotmem )
01953 {
01954     set_stream();
01955 
01956     plsmema( maxx, maxy, plotmem );
01957 }
01958 
01959 // Set up lengths of minor tick marks.
01960 
01961 void plstream::smin( PLFLT def, PLFLT scale )
01962 {
01963     set_stream();
01964 
01965     plsmin( def, scale );
01966 }
01967 
01968 // Set orientation.  Must be done before calling plinit.
01969 
01970 void plstream::sori( PLINT ori )
01971 {
01972     set_stream();
01973 
01974     plsori( ori );
01975 }
01976 
01977 // Set output device parameters.  Usually ignored by the driver.
01978 
01979 void plstream::spage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng,
01980                       PLINT xoff, PLINT yoff )
01981 {
01982     set_stream();
01983 
01984     plspage( xp, yp, xleng, yleng, xoff, yoff );
01985 }
01986 
01987 // Set the colors for color table 0 from a cmap0 file
01988 
01989 void plstream::spal0( const char *filename )
01990 {
01991     set_stream();
01992 
01993     plspal0( filename );
01994 }
01995 
01996 // Set the colors for color table 1 from a cmap1 file
01997 
01998 void plstream::spal1( const char *filename, bool interpolate )
01999 {
02000     set_stream();
02001 
02002     plspal1( filename, (PLBOOL) interpolate );
02003 }
02004 
02005 // Set the pause (on end-of-page) status
02006 
02007 void plstream::spause( bool pause )
02008 {
02009     set_stream();
02010 
02011     plspause( (PLBOOL) pause );
02012 }
02013 
02014 // Deprecated version using PLINT not bool
02015 void plstream::spause( PLINT pause )
02016 {
02017     set_stream();
02018 
02019     plspause( (PLBOOL) pause );
02020 }
02021 
02022 // Set stream number.
02023 
02024 void plstream::sstrm( PLINT strm )
02025 {
02026     set_stream();
02027 
02028     plsstrm( strm );
02029 }
02030 
02031 // Set the number of subwindows in x and y
02032 
02033 void plstream::ssub( PLINT nx, PLINT ny )
02034 {
02035     set_stream();
02036 
02037     plssub( nx, ny );
02038 }
02039 
02040 // Set symbol height.
02041 
02042 void plstream::ssym( PLFLT def, PLFLT scale )
02043 {
02044     set_stream();
02045 
02046     plssym( def, scale );
02047 }
02048 
02049 // Initialize PLplot, passing in the windows/page settings.
02050 
02051 void plstream::star( PLINT nx, PLINT ny )
02052 {
02053     set_stream();
02054 
02055     plstar( nx, ny );
02056 }
02057 
02058 // Initialize PLplot, passing the device name and windows/page settings.
02059 
02060 void plstream::start( const char *devname, PLINT nx, PLINT ny )
02061 {
02062     set_stream();
02063 
02064     plstart( devname, nx, ny );
02065 }
02066 
02067 // Set the coordinate transform
02068 
02069 void plstream::stransform( void ( *coordinate_transform )( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ),
02070                            PLPointer coordinate_transform_data )
02071 {
02072     set_stream();
02073 
02074     plstransform( coordinate_transform, coordinate_transform_data );
02075 }
02076 
02077 // Prints out the same string repeatedly at the n points in world
02078 // coordinates given by the x and y arrays.  Supersedes plpoin and
02079 // plsymbol for the case where text refers to a unicode glyph either
02080 // directly as UTF-8 or indirectly via the standard text escape
02081 // sequences allowed for PLplot input strings.
02082 
02083 void plstream::string( PLINT n, const PLFLT *x, const PLFLT *y, const char *string )
02084 {
02085     set_stream();
02086     plstring( n, x, y, string );
02087 }
02088 
02089 // Prints out the same string repeatedly at the n points in world
02090 // coordinates given by the x, y, and z arrays.  Supersedes plpoin3
02091 // for the case where text refers to a unicode glyph either directly
02092 // as UTF-8 or indirectly via the standard text escape sequences
02093 // allowed for PLplot input strings.
02094 
02095 void plstream::string3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const char *string )
02096 {
02097     set_stream();
02098     plstring3( n, x, y, z, string );
02099 }
02100 
02101 // Create 1d stripchart
02102 
02103 void plstream::stripc( PLINT *id, const char *xspec, const char *yspec,
02104                        PLFLT xmin, PLFLT xmax, PLFLT xjump,
02105                        PLFLT ymin, PLFLT ymax,
02106                        PLFLT xlpos, PLFLT ylpos, bool y_ascl,
02107                        bool acc, PLINT colbox, PLINT collab,
02108                        const PLINT colline[], const PLINT styline[],
02109                        const char *legline[], const char *labx,
02110                        const char *laby, const char *labtop )
02111 {
02112     set_stream();
02113 
02114     plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos,
02115         (PLBOOL) y_ascl, (PLBOOL) acc, colbox, collab, colline, styline,
02116         legline, labx, laby, labtop );
02117 }
02118 
02119 
02120 // Deprecated version using PLINT not bool
02121 void plstream::stripc( PLINT *id, const char *xspec, const char *yspec,
02122                        PLFLT xmin, PLFLT xmax, PLFLT xjump,
02123                        PLFLT ymin, PLFLT ymax, PLFLT xlpos, PLFLT ylpos,
02124                        PLINT y_ascl, PLINT acc, PLINT colbox, PLINT collab,
02125                        const PLINT colline[], const PLINT styline[],
02126                        const char *legline[], const char *labx,
02127                        const char *laby, const char *labtop )
02128 {
02129     set_stream();
02130 
02131     plstripc( id, xspec, yspec, xmin, xmax, xjump, ymin, ymax, xlpos, ylpos,
02132         (PLBOOL) y_ascl, (PLBOOL) acc, colbox, collab, colline, styline,
02133         legline, labx, laby, labtop );
02134 }
02135 
02136 // Add a point to a stripchart.
02137 
02138 void plstream::stripa( PLINT id, PLINT pen, PLFLT x, PLFLT y )
02139 {
02140     set_stream();
02141 
02142     plstripa( id, pen, x, y );
02143 }
02144 
02145 // Deletes and releases memory used by a stripchart.
02146 
02147 void plstream::stripd( PLINT id )
02148 {
02149     set_stream();
02150 
02151     plstripd( id );
02152 }
02153 
02154 // plots a 2d image (or a matrix too large for plshade() )  - colors
02155 // automatically scaled
02156 
02157 void plstream::image( const PLFLT * const *data, PLINT nx, PLINT ny,
02158                       PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
02159                       PLFLT zmin, PLFLT zmax,
02160                       PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax )
02161 {
02162     set_stream();
02163 
02164     plimage( (const PLFLT **) data, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
02165         Dxmin, Dxmax, Dymin, Dymax );
02166 }
02167 
02168 // plots a 2d image (or a matrix too large for plshade() )
02169 
02170 void plstream::imagefr( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
02171                         PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
02172                         PLFLT valuemin, PLFLT valuemax,
02173                         void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
02174                         PLPointer pltr_data )
02175 {
02176     set_stream();
02177 
02178     plimagefr( (const PLFLT **) data, nx, ny, xmin, xmax, ymin, ymax, zmin, zmax,
02179         valuemin, valuemax, pltr, pltr_data );
02180 }
02181 
02182 // Set up a new line style
02183 
02184 void plstream::styl( PLINT nms, const PLINT *mark, const PLINT *space )
02185 {
02186     set_stream();
02187 
02188     plstyl( nms, mark, space );
02189 }
02190 
02191 // Sets the edges of the viewport to the specified absolute coordinates
02192 
02193 void plstream::svpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
02194 {
02195     set_stream();
02196 
02197     plsvpa( xmin, xmax, ymin, ymax );
02198 }
02199 
02200 // Set x axis labeling parameters
02201 
02202 void plstream::sxax( PLINT digmax, PLINT digits )
02203 {
02204     set_stream();
02205 
02206     plsxax( digmax, digits );
02207 }
02208 
02209 // Set inferior X window
02210 
02211 void plstream::sxwin( PLINT window_id )
02212 {
02213     set_stream();
02214 
02215     plsxwin( window_id );
02216 }
02217 
02218 // Set y axis labeling parameters
02219 
02220 void plstream::syax( PLINT digmax, PLINT digits )
02221 {
02222     set_stream();
02223 
02224     plsyax( digmax, digits );
02225 }
02226 
02227 // Plots array y against x for n points using Hershey symbol "code"
02228 
02229 void plstream::sym( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code )
02230 {
02231     set_stream();
02232 
02233     plsym( n, x, y, code );
02234 }
02235 
02236 // Set z axis labeling parameters
02237 
02238 void plstream::szax( PLINT digmax, PLINT digits )
02239 {
02240     set_stream();
02241 
02242     plszax( digmax, digits );
02243 }
02244 
02245 // Switches to text screen.
02246 
02247 void plstream::text()
02248 {
02249     set_stream();
02250 
02251     pltext();
02252 }
02253 
02254 // Set the format for date / time labels
02255 
02256 void plstream::timefmt( const char *fmt )
02257 {
02258     set_stream();
02259 
02260     pltimefmt( fmt );
02261 }
02262 
02263 // Sets the edges of the viewport with the given aspect ratio, leaving
02264 // room for labels.
02265 
02266 void plstream::vasp( PLFLT aspect )
02267 {
02268     set_stream();
02269 
02270     plvasp( aspect );
02271 }
02272 
02273 // Creates the largest viewport of the specified aspect ratio that fits
02274 // within the specified normalized subpage coordinates.
02275 
02276 void plstream::vpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
02277                      PLFLT aspect )
02278 {
02279     set_stream();
02280 
02281     plvpas( xmin, xmax, ymin, ymax, aspect );
02282 }
02283 
02284 // Creates a viewport with the specified normalized subpage coordinates.
02285 
02286 void plstream::vpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
02287 {
02288     set_stream();
02289 
02290     plvpor( xmin, xmax, ymin, ymax );
02291 }
02292 
02293 // Defines a "standard" viewport with seven character heights for
02294 // the left margin and four character heights everywhere else.
02295 
02296 void plstream::vsta()
02297 {
02298     set_stream();
02299 
02300     plvsta();
02301 }
02302 
02303 // Set up a window for three-dimensional plotting.
02304 
02305 void plstream::w3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0,
02306                     PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0,
02307                     PLFLT zmax0, PLFLT alt, PLFLT az )
02308 {
02309     set_stream();
02310 
02311     plw3d( basex, basey, height, xmin0, xmax0, ymin0, ymax0, zmin0, zmax0,
02312         alt, az );
02313 }
02314 
02315 // Set pen width.
02316 
02317 void plstream::wid( PLINT width )
02318 {
02319     set_stream();
02320 
02321     plwid( width );
02322 }
02323 
02324 // Set up world coordinates of the viewport boundaries (2d plots).
02325 
02326 void plstream::wind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax )
02327 {
02328     set_stream();
02329 
02330     plwind( xmin, xmax, ymin, ymax );
02331 }
02332 
02333 //  Set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
02334 
02335 void plstream::xormod( bool mode, bool *status )
02336 {
02337     PLBOOL loc_status;
02338 
02339     set_stream();
02340 
02341     plxormod( (PLBOOL) mode, &loc_status );
02342 
02343     *status = ( loc_status != 0 );
02344 }
02345 
02346 // Deprecated version using PLINT not bool
02347 void plstream::xormod( PLINT mode, PLINT *status )
02348 {
02349     PLBOOL loc_status;
02350 
02351     set_stream();
02352 
02353     plxormod( (PLBOOL) mode, &loc_status );
02354 
02355     *status = (PLINT) loc_status;
02356 }
02357 
02358 // Set the seed for the random number generator included.
02359 
02360 void plstream::seed( unsigned int s )
02361 {
02362     set_stream();
02363 
02364     plseed( s );
02365 }
02366 
02367 // Returns a random number on [0,1]-interval.
02368 
02369 PLFLT plstream::randd( void )
02370 {
02371     set_stream();
02372 
02373     return plrandd();
02374 }
02375 
02376 // The rest for use from C / C++ only
02377 
02378 // Returns a list of file-oriented device names and their menu strings
02379 
02380 void plstream::gFileDevs( const char ***p_menustr, const char ***p_devname,
02381                           int *p_ndev )
02382 {
02383     set_stream();
02384 
02385     plgFileDevs( p_menustr, p_devname, p_ndev );
02386 }
02387 
02388 // Set the function pointer for the keyboard event handler
02389 
02390 void plstream::sKeyEH( void ( *KeyEH )( PLGraphicsIn *, void *, int * ),
02391                        void *KeyEH_data )
02392 {
02393     set_stream();
02394 
02395     plsKeyEH( KeyEH, KeyEH_data );
02396 }
02397 
02398 // Set the variables to be used for storing error info
02399 
02400 void plstream::sError( PLINT *errcode, char *errmsg )
02401 {
02402     set_stream();
02403 
02404     plsError( errcode, errmsg );
02405 }
02406 
02407 // Sets an optional user exit handler.
02408 
02409 void plstream::sexit( int ( *handler )( const char * ) )
02410 {
02411     set_stream();
02412 
02413     plsexit( handler );
02414 }
02415 
02416 // Transformation routines
02417 
02418 // Identity transformation.
02419 
02420 void plstream::tr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
02421                     PLPointer pltr_data )
02422 {
02423     pltr0( x, y, tx, ty, pltr_data );
02424 }
02425 
02426 // Does linear interpolation from singly dimensioned coord arrays.
02427 
02428 void plstream::tr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
02429                     PLPointer pltr_data )
02430 {
02431     pltr1( x, y, tx, ty, pltr_data );
02432 }
02433 
02434 // Does linear interpolation from doubly dimensioned coord arrays
02435 // (column dominant, as per normal C 2d arrays).
02436 
02437 void plstream::tr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
02438                     PLPointer pltr_data )
02439 {
02440     pltr2( x, y, tx, ty, pltr_data );
02441 }
02442 
02443 // Just like pltr2() but uses pointer arithmetic to get coordinates from
02444 // 2d grid tables.
02445 
02446 void plstream::tr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty,
02447                      PLPointer pltr_data )
02448 {
02449     pltr2p( x, y, tx, ty, pltr_data );
02450 }
02451 
02452 // We obviously won't be using this object from Fortran...
02453 // // Identity transformation for plots from Fortran.
02454 
02455 // void plstream::tr0f(PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data )
02456 // {
02457 //     set_stream();
02458 
02459 //     pltr0f(x,y,tx,ty,pltr_data);
02460 // }
02461 
02462 // // Does linear interpolation from doubly dimensioned coord arrays
02463 // // (row dominant, i.e. Fortran ordering).
02464 
02465 // void plstream::tr2f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data )
02466 // {
02467 //     set_stream();
02468 
02469 //     pltr2f(x,y,tx,ty,pltr_data);
02470 // }
02471 
02472 // Example linear transformation function for contour plotter.
02473 // This is not actually a part of the core library any more
02474 //
02475 // void  plstream::xform( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty )
02476 // {
02477 //  set_stream();
02478 //
02479 //  xform(x,y,tx,ty);
02480 // }
02481 
02482 // Function evaluators
02483 
02484 // Does a lookup from a 2d function array.  Array is of type (PLFLT **),
02485 // and is column dominant (normal C ordering).
02486 
02487 PLFLT plstream::f2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data )
02488 {
02489     set_stream();
02490 
02491     return ::plf2eval2( ix, iy, plf2eval_data );
02492 }
02493 
02494 // Does a lookup from a 2d function array.  Array is of type (PLFLT *),
02495 // and is column dominant (normal C ordering).
02496 
02497 PLFLT plstream::f2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data )
02498 {
02499     set_stream();
02500 
02501     return ::plf2eval( ix, iy, plf2eval_data );
02502 }
02503 
02504 // Does a lookup from a 2d function array.  Array is of type (PLFLT *),
02505 // and is row dominant (Fortran ordering).
02506 
02507 PLFLT plstream::f2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data )
02508 {
02509     set_stream();
02510 
02511     return ::plf2evalr( ix, iy, plf2eval_data );
02512 }
02513 
02514 // Command line parsing utilities
02515 
02516 // Clear internal option table info structure.
02517 
02518 void plstream::ClearOpts()
02519 {
02520     set_stream();
02521 
02522     ::plClearOpts();
02523 }
02524 
02525 // Reset internal option table info structure.
02526 
02527 void plstream::ResetOpts()
02528 {
02529     set_stream();
02530 
02531     ::plResetOpts();
02532 }
02533 
02534 // Merge user option table into internal info structure.
02535 
02536 int plstream::MergeOpts( PLOptionTable *options, const char *name,
02537                          const char **notes )
02538 {
02539     set_stream();
02540 
02541     return ::plMergeOpts( options, name, notes );
02542 }
02543 
02544 // Set the strings used in usage and syntax messages.
02545 
02546 void plstream::SetUsage( char *program_string, char *usage_string )
02547 {
02548     set_stream();
02549 
02550     ::plSetUsage( program_string, usage_string );
02551 }
02552 
02553 // Process input strings, treating them as an option and argument pair.
02554 
02555 int plstream::setopt( const char *opt, const char *optarg )
02556 {
02557     set_stream();
02558 
02559     return ::plsetopt( opt, optarg );
02560 }
02561 
02562 // Depreciated version - use setopt instead.
02563 #ifdef PL_DEPRECATED
02564 int plstream::SetOpt( const char *opt, const char *optarg )
02565 {
02566     set_stream();
02567 
02568     return ::plsetopt( opt, optarg );
02569 }
02570 #endif // PL_DEPRECATED
02571 
02572 // Print usage & syntax message.
02573 
02574 void plstream::OptUsage()
02575 {
02576     set_stream();
02577 
02578     ::plOptUsage();
02579 }
02580 
02581 // Miscellaneous
02582 
02583 // Set the output file pointer
02584 
02585 void plstream::gfile( FILE **p_file )
02586 {
02587     set_stream();
02588 
02589     ::plgfile( p_file );
02590 }
02591 
02592 // Get the output file pointer
02593 
02594 void plstream::sfile( FILE *file )
02595 {
02596     set_stream();
02597 
02598     ::plsfile( file );
02599 }
02600 
02601 
02602 // Get the escape character for text strings.
02603 
02604 void plstream::gesc( char *p_esc )
02605 {
02606     set_stream();
02607 
02608     ::plgesc( p_esc );
02609 }
02610 
02611 // Front-end to driver escape function.
02612 
02613 void plstream::cmd( PLINT op, void *ptr )
02614 {
02615     set_stream();
02616 
02617     ::pl_cmd( op, ptr );
02618 }
02619 
02620 // Return full pathname for given file if executable
02621 
02622 int plstream::FindName( char *p )
02623 {
02624     set_stream();
02625 
02626     return plFindName( p );
02627 }
02628 
02629 // Looks for the specified executable file according to usual search path.
02630 
02631 char *plstream::FindCommand( char *fn )
02632 {
02633     set_stream();
02634 
02635     return plFindCommand( fn );
02636 }
02637 
02638 // Gets search name for file by concatenating the dir, subdir, and file
02639 // name, allocating memory as needed.
02640 
02641 void plstream::GetName( char *dir, char *subdir, char *filename,
02642                         char **filespec )
02643 {
02644     set_stream();
02645 
02646     plGetName( dir, subdir, filename, filespec );
02647 }
02648 
02649 // Prompts human to input an integer in response to given message.
02650 
02651 PLINT plstream::GetInt( char *s )
02652 {
02653     set_stream();
02654 
02655     return plGetInt( s );
02656 }
02657 
02658 // Prompts human to input a float in response to given message.
02659 
02660 PLFLT plstream::GetFlt( char *s )
02661 {
02662     set_stream();
02663 
02664     return plGetFlt( s );
02665 }
02666 
02667 // Nice way to allocate space for a vectored 2d grid
02668 
02669 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
02670 
02671 void plstream::Alloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny )
02672 {
02673     set_stream();
02674 
02675     ::plAlloc2dGrid( f, nx, ny );
02676 }
02677 
02678 // Frees a block of memory allocated with plAlloc2dGrid().
02679 
02680 void plstream::Free2dGrid( PLFLT **f, PLINT nx, PLINT ny )
02681 {
02682     set_stream();
02683 
02684     ::plFree2dGrid( f, nx, ny );
02685 }
02686 
02687 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
02688 void plstream::MinMax2dGrid( const PLFLT * const *f, PLINT nx, PLINT ny,
02689                              PLFLT *fmax, PLFLT *fmin )
02690 {
02691     set_stream();
02692 
02693     ::plMinMax2dGrid( (const PLFLT **) f, nx, ny, fmax, fmin );
02694 }
02695 
02696 // Functions for converting between HLS and RGB color space
02697 
02698 void plstream::hlsrgb( PLFLT h, PLFLT l, PLFLT s, PLFLT *p_r, PLFLT *p_g,
02699                        PLFLT *p_b )
02700 {
02701     set_stream();
02702 
02703     ::c_plhlsrgb( h, l, s, p_r, p_g, p_b );
02704 }
02705 
02706 void plstream::rgbhls( PLFLT r, PLFLT g, PLFLT b, PLFLT *p_h, PLFLT *p_l,
02707                        PLFLT *p_s )
02708 {
02709     set_stream();
02710 
02711     ::c_plrgbhls( r, g, b, p_h, p_l, p_s );
02712 }
02713 
02714 // Wait for right button mouse event and translate to world coordinates
02715 
02716 int plstream::GetCursor( PLGraphicsIn *gin )
02717 {
02718     set_stream();
02719 
02720     return plGetCursor( gin );
02721 }
02722 
02723 //--------------------------------------------------------------------------
02724 //                              end of plstream.cc
02725 //--------------------------------------------------------------------------

Generated on Wed Oct 12 2011 20:42:23 for PLplot by  doxygen 1.7.1