PLplot  5.10.0
plstream.h
Go to the documentation of this file.
00001 //----------------------------------*-C++-*----------------------------------//
00002 // Geoffrey Furnish
00003 // Sep 21 1994
00004 //
00005 // Copyright (C) 2004,2005  Andrew Ross
00006 // Copyright (C) 2004-2014 Alan W. Irwin
00007 //
00008 // This file is part of PLplot.
00009 //
00010 // PLplot is free software; you can redistribute it and/or modify
00011 // it under the terms of the GNU Library General Public License as published
00012 // by the Free Software Foundation; either version 2 of the License, or
00013 // (at your option) any later version.
00014 //
00015 // PLplot is distributed in the hope that it will be useful,
00016 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00017 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00018 // GNU Library General Public License for more details.
00019 //
00020 // You should have received a copy of the GNU Library General Public License
00021 // along with PLplot; if not, write to the Free Software
00022 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00023 
00024 //--------------------------------------------------------------------------
00025 // @> Header file plstream.
00026 //--------------------------------------------------------------------------
00027 
00028 #ifndef __plstream_h__
00029 #define __plstream_h__
00030 
00031 #include "plplot.h"
00032 
00033 class PLS {
00034 public:
00035     enum stream_id { Next, Current, Specific };
00036 };
00037 
00038 enum PLcolor { Black = 0, Red, Yellow, Green,
00039                Cyan, Pink, Tan, Grey,
00040                DarkRed, DeepBlue, Purple, LightCyan,
00041                LightBlue, Orchid, Mauve, White };
00042 
00043 // A class for assisting in generalizing the data prescription
00044 // interface to the contouring routines.
00045 
00046 class Contourable_Data {
00047     int _nx, _ny;
00048 public:
00049     Contourable_Data( int nx, int ny ) : _nx( nx ), _ny( ny ) {}
00050     virtual void elements( int& nx, int& ny ) const { nx = _nx; ny = _ny; }
00051     virtual PLFLT operator()( int i, int j ) const = 0;
00052     virtual ~Contourable_Data() {};
00053 };
00054 
00055 PLFLT Contourable_Data_evaluator( PLINT i, PLINT j, PLPointer p );
00056 
00057 class PLDLLIMPEXP_CXX Coord_Xformer {
00058 public:
00059     virtual void xform( PLFLT ox, PLFLT oy, PLFLT& nx, PLFLT& ny ) const = 0;
00060     virtual ~Coord_Xformer() {};
00061 };
00062 
00063 void Coord_Xform_evaluator( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer );
00064 
00065 class Coord_2d {
00066 public:
00067     virtual PLFLT operator()( int ix, int iy ) const = 0;
00068     virtual void elements( int& _nx, int& _ny )      = 0;
00069     virtual void min_max( PLFLT& _min, PLFLT& _max ) = 0;
00070     virtual ~Coord_2d() {};
00071 };
00072 
00073 class PLDLLIMPEXP_CXX cxx_pltr2 : public Coord_Xformer {
00074     Coord_2d& xg;
00075     Coord_2d& yg;
00076 public:
00077     cxx_pltr2( Coord_2d & cx, Coord_2d & cy );
00078     void xform( PLFLT x, PLFLT y, PLFLT& tx, PLFLT& ty ) const;
00079 };
00080 
00081 //--------------------------------------------------------------------------
00082 // class plstream - C++ class for encapsulating PLplot streams
00083 
00084 // Cool stuff.
00085 //--------------------------------------------------------------------------
00086 
00087 class PLDLLIMPEXP_CXX plstream {
00088     PLINT stream;
00089 
00090     static PLINT active_streams;
00091 
00092 private:
00093     // These have to be disabled till we implement reference counting.
00094 
00095     plstream( const plstream & );
00096     plstream& operator=( const plstream& );
00097 
00098 protected:
00099     virtual void set_stream( void ) { ::c_plsstrm( stream ); }
00100 
00101 public:
00102     plstream( void );
00103     plstream( plstream * pls );
00104     plstream( PLS::stream_id sid, PLINT strm = 0 );
00105     plstream( PLINT _stream ) : stream( _stream ) {}
00106     plstream( PLINT nx /*=1*/, PLINT ny /*=1*/,
00107               const char *driver = NULL, const char *file = NULL );
00108     plstream( PLINT nx /*=1*/, PLINT ny /*=1*/, PLINT r, PLINT g, PLINT b,
00109               const char *driver = NULL, const char *file = NULL );
00110 
00111     virtual ~plstream( void );
00112 
00113 // Now start miroring the PLplot C API.
00114 
00115     // C routines callable from stub routines come first
00116 
00117 // Advance to subpage "page", or to the next one if "page" = 0.
00118 
00119     void adv( PLINT page );
00120 
00121 // Plot an arc
00122 
00123     void arc( PLFLT x, PLFLT y, PLFLT a, PLFLT b, PLFLT angle1, PLFLT angle2,
00124               PLFLT rotate, PLBOOL fill );
00125 
00126 // Simple arrow plotter
00127 #ifdef PL_DEPRECATED
00128     void arrows( const PLFLT *u, const PLFLT *v, const PLFLT *x, const PLFLT *y, PLINT n,
00129                  PLFLT scale, PLFLT dx, PLFLT dy );
00130 #endif // PL_DEPRECATED
00131 
00132     void vect( const PLFLT * const *u, const PLFLT * const *v, PLINT nx, PLINT ny, PLFLT scale,
00133                void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00134                PLPointer pltr_data );
00135 
00136 // Set the arrow style
00137     void svect( const PLFLT *arrow_x = NULL, const PLFLT *arrow_y = NULL, PLINT npts = 0, bool fill = false );
00138 
00139 // This functions similarly to plbox() except that the origin of the axes is
00140 // placed at the user-specified point (x0, y0).
00141 
00142     void axes( PLFLT x0, PLFLT y0, const char *xopt, PLFLT xtick, PLINT nxsub,
00143                const char *yopt, PLFLT ytick, PLINT nysub );
00144 
00145 // Plot a histogram using x to store data values and y to store frequencies.
00146 
00147     void bin( PLINT nbin, const PLFLT *x, const PLFLT *y, PLINT center );
00148 
00149 // Start new page.  Should only be used with pleop().
00150 
00151     void bop( void );
00152 
00153 // This draws a box around the current viewport.
00154 
00155     void box( const char *xopt, PLFLT xtick, PLINT nxsub,
00156               const char *yopt, PLFLT ytick, PLINT nysub );
00157 
00158 // This is the 3-d analogue of plbox().
00159 
00160     void box3( const char *xopt, const char *xlabel, PLFLT xtick, PLINT nsubx,
00161                const char *yopt, const char *ylabel, PLFLT ytick, PLINT nsuby,
00162                const char *zopt, const char *zlabel, PLFLT ztick, PLINT nsubz );
00163 
00164 // Calculate broken-down time from continuous time for current stream.
00165 
00166     void btime( PLINT &year, PLINT &month, PLINT &day, PLINT &hour,
00167                 PLINT &min, PLFLT &sec, PLFLT ctime );
00168 
00169 // Calculate world coordinates and subpage from relative device coordinates.
00170 
00171     void calc_world( PLFLT rx, PLFLT ry, PLFLT& wx, PLFLT& wy, PLINT& window );
00172 
00173 // Clear the current subpage.
00174 
00175     void clear( void );
00176 
00177 // Set color, map 0.  Argument is integer between 0 and 15.
00178 
00179     void col0( PLINT icol0 );
00180 
00181 // Set the color using a descriptive name.  Replaces plcol0().  (Except that
00182 // col0 won't die.)
00183 
00184     void col( PLcolor c );
00185 
00186 // Set color, map 1.  Argument is a float between 0. and 1.
00187 
00188     void col1( PLFLT c );
00189 
00190 // Previous function was inadvertently named plcol in old versions of
00191 // plplot - this is maintained for backwards compatibility, but is best
00192 // avoided in new code.
00193     void col( PLFLT c );
00194 
00195 // Configure transformation between continuous and broken-down time (and
00196 // vice versa) for current stream.
00197     void configtime( PLFLT scale, PLFLT offset1, PLFLT offset2,
00198                      PLINT ccontrol, PLBOOL ifbtime_offset, PLINT year,
00199                      PLINT month, PLINT day, PLINT hour, PLINT min, PLFLT sec );
00200 
00201 // Draws a contour plot from data in f(nx,ny).  Is just a front-end to
00202 // plfcont, with a particular choice for f2eval and f2eval_data.
00203 
00204     void cont( const PLFLT * const *f, PLINT nx, PLINT ny, PLINT kx, PLINT lx,
00205                PLINT ky, PLINT ly, const PLFLT * clevel, PLINT nlevel,
00206                void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00207                PLPointer pltr_data );
00208 
00209 // Draws a contour plot using the function evaluator f2eval and data stored
00210 // by way of the f2eval_data pointer.  This allows arbitrary organizations
00211 // of 2d array data to be used.
00212 
00213     void fcont( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
00214                 PLPointer f2eval_data,
00215                 PLINT nx, PLINT ny, PLINT kx, PLINT lx,
00216                 PLINT ky, PLINT ly, const PLFLT * clevel, PLINT nlevel,
00217                 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00218                 PLPointer pltr_data );
00219 
00220 // Copies state parameters from the reference stream to the current stream.
00221 
00222     void cpstrm( plstream &pls, bool flags );
00223 
00224 // Calculate continuous time from broken-down time for current stream.
00225     void ctime( PLINT year, PLINT month, PLINT day, PLINT hour, PLINT min,
00226                 PLFLT sec, PLFLT &ctime );
00227 
00228 // Converts input values from relative device coordinates to relative plot
00229 // coordinates.
00230 
00231     void did2pc( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
00232 
00233 // Converts input values from relative plot coordinates to relative device
00234 // coordinates.
00235 
00236     void dip2dc( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
00237 
00238 // These shouldn't be needed, are supposed to be handled by ctor/dtor
00239 // semantics of the plstream object.
00240 
00241 //  End a plotting session for all open streams.
00242 
00243 //     void end();
00244 
00245 // End a plotting session for the current stream only.
00246 
00247 //     void end1();
00248 
00249 // Simple interface for defining viewport and window.
00250 
00251     void env( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00252               PLINT just, PLINT axis );
00253 
00254 // similar to env() above, but in multiplot mode does not advance
00255 // the subpage, instead the current subpage is cleared
00256 
00257     void env0( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00258                PLINT just, PLINT axis );
00259 
00260 // End current page.  Should only be used with plbop().
00261 
00262     void eop( void );
00263 
00264 // Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i)).
00265 
00266     void errx( PLINT n, const PLFLT *xmin, const PLFLT *xmax, const PLFLT *y );
00267 
00268 // Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i)).
00269 
00270     void erry( PLINT n, const PLFLT *x, const PLFLT *ymin, const PLFLT *ymax );
00271 
00272 // Advance to the next family file on the next new page.
00273 
00274     void famadv( void );
00275 
00276 // Pattern fills the polygon bounded by the input points.
00277 
00278     static void fill( PLINT n, const PLFLT *x, const PLFLT *y );
00279 
00280 // Pattern fills the 3d polygon bounded by the input points.
00281 
00282     static void fill3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z );
00283 
00284 // Flushes the output stream.  Use sparingly, if at all.
00285 
00286     void flush( void );
00287 
00288 // Sets the global font flag to 'ifont'.
00289 
00290     void font( PLINT ifont );
00291 
00292 // Load specified font set.
00293 
00294     void fontld( PLINT fnt );
00295 
00296 // Get character default height and current (scaled) height.
00297 
00298     void gchr( PLFLT& p_def, PLFLT& p_ht );
00299 
00300 // Returns 8 bit RGB values for given color from color map 0.
00301 
00302     void gcol0( PLINT icol0, PLINT& r, PLINT& g, PLINT& b );
00303 
00304 // Returns 8 bit RGB and 0.0-1.0 alpha values for given color from color map 0.
00305 
00306     void gcol0a( PLINT icol0, PLINT& r, PLINT& g, PLINT& b, PLFLT& a );
00307 
00308 // Returns the background color by 8 bit RGB value.
00309 
00310     void gcolbg( PLINT& r, PLINT& g, PLINT& b );
00311 
00312 // Returns the background color by 8 bit RGB and 0.0-1.0 alpha values.
00313 
00314     void gcolbga( PLINT& r, PLINT& g, PLINT& b, PLFLT& a );
00315 
00316 // Returns the current compression setting
00317 
00318     void gcompression( PLINT& compression );
00319 
00320 // Retrieve current window into device space.
00321 
00322     void gdidev( PLFLT& mar, PLFLT& aspect, PLFLT& jx, PLFLT& jy );
00323 
00324 // Get plot orientation.
00325 
00326     void gdiori( PLFLT& rot );
00327 
00328 // Retrieve current window into plot space.
00329 
00330     void gdiplt( PLFLT& xmin, PLFLT& ymin, PLFLT& xmax, PLFLT& ymax );
00331 
00332 // Get FCI (font characterization integer)
00333 
00334     void gfci( PLUNICODE& pfci );
00335 
00336 // Get family file parameters.
00337 
00338     void gfam( PLINT& fam, PLINT& num, PLINT& bmax );
00339 
00340 // Get the (current) output file name.  Must be preallocated to >80 bytes.
00341 
00342     void gfnam( char *fnam );
00343 
00344 // Get the current font family, style and weight
00345 
00346     void gfont( PLINT& family, PLINT& style, PLINT& weight );
00347 
00348 // Get the (current) run level.
00349 
00350     void glevel( PLINT &p_level );
00351 
00352 // Get output device parameters.
00353 
00354     void gpage( PLFLT& xp, PLFLT& yp, PLINT& xleng, PLINT& yleng,
00355                 PLINT& xoff, PLINT& yoff );
00356 
00357 // Switches to graphics screen.
00358 
00359     void gra( void );
00360 
00361 // Draw gradient in polygon.
00362 
00363     static void gradient( PLINT n, const PLFLT *x, const PLFLT *y, PLFLT angle );
00364 
00365 // grid irregularly sampled data
00366 
00367     void griddata( const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT npts,
00368                    const PLFLT *xg, PLINT nptsx, const PLFLT *yg, PLINT nptsy,
00369                    PLFLT **zg, PLINT type, PLFLT data );
00370 
00371 // Get subpage boundaries in absolute coordinates.
00372 
00373     void gspa( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
00374 
00375 // This shouldn't be needed in this model.
00376 
00377 // Get current stream number.
00378 
00379 //     void gstrm( PLINT *p_strm );
00380 
00381 // Get the current library version number.
00382 
00383     void gver( char *p_ver );
00384 
00385 // Get the viewport window in normalized device coordinates
00386 
00387     void gvpd( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
00388 
00389 // Get the viewport window in world coordinates
00390 
00391     void gvpw( PLFLT& xmin, PLFLT& xmax, PLFLT& ymin, PLFLT& ymax );
00392 
00393 // Get x axis labeling parameters.
00394 
00395     void gxax( PLINT& digmax, PLINT& digits );
00396 
00397 // Get y axis labeling parameters.
00398 
00399     void gyax( PLINT& digmax, PLINT& digits );
00400 
00401 // Get z axis labeling parameters
00402 
00403     void gzax( PLINT& digmax, PLINT& digits );
00404 
00405 // Draws a histogram of n values of a variable in array data[0..n-1]
00406 
00407     void hist( PLINT n, const PLFLT *data, PLFLT datmin, PLFLT datmax,
00408                PLINT nbin, PLINT oldwin );
00409 
00410 // Set current color (map 0) by hue, lightness, and saturation.
00411 
00412 #ifdef PL_DEPRECATED
00413     void hls( PLFLT h, PLFLT l, PLFLT s );
00414 #endif // PL_DEPRECATED
00415 
00416 // Initializes PLplot, using preset or default options
00417 
00418     void init( void );
00419 
00420 // Draws a line segment from (x1, y1) to (x2, y2).
00421 
00422     void join( PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
00423 
00424 // Simple routine for labelling graphs.
00425 
00426     void lab( const char *xlabel, const char *ylabel, const char *tlabel );
00427 
00428 // Routine for drawing line, symbol, or cmap0 legends
00429     void legend( PLFLT *p_legend_width, PLFLT *p_legend_height,
00430                  PLINT opt, PLINT position, PLFLT x, PLFLT y, PLFLT plot_width,
00431                  PLINT bg_color, PLINT bb_color, PLINT bb_style,
00432                  PLINT nrow, PLINT ncolumn,
00433                  PLINT nlegend, const PLINT *opt_array,
00434                  PLFLT text_offset, PLFLT text_scale, PLFLT text_spacing,
00435                  PLFLT text_justification,
00436                  const PLINT *text_colors, const char * const *text,
00437                  const PLINT *box_colors, const PLINT *box_patterns,
00438                  const PLFLT *box_scales, const PLFLT *box_line_widths,
00439                  const PLINT *line_colors, const PLINT *line_styles,
00440                  const PLFLT *line_widths,
00441                  const PLINT *symbol_colors, const PLFLT *symbol_scales,
00442                  const PLINT *symbol_numbers, const char * const *symbols );
00443 
00444     void colorbar( PLFLT *p_colorbar_width, PLFLT *p_colorbar_height,
00445                    PLINT opt, PLINT position, PLFLT x, PLFLT y,
00446                    PLFLT x_length, PLFLT y_length,
00447                    PLINT bg_color, PLINT bb_color, PLINT bb_style,
00448                    PLFLT low_cap_color, PLFLT high_cap_color,
00449                    PLINT cont_color, PLFLT cont_width,
00450                    PLINT n_labels, PLINT *label_opts, const char * const *label,
00451                    PLINT n_axes, const char * const *axis_opts,
00452                    PLFLT *ticks, PLINT *sub_ticks,
00453                    PLINT *n_values, const PLFLT * const *values );
00454 
00455 // Sets position of the light source
00456 
00457     void lightsource( PLFLT x, PLFLT y, PLFLT z );
00458 
00459 // Draws line segments connecting a series of points.
00460 
00461     void line( PLINT n, const PLFLT *x, const PLFLT *y );
00462 
00463 // Draws a line in 3 space.
00464 
00465     void line3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z );
00466 
00467 // Set line style.
00468 
00469     void lsty( PLINT lin );
00470 
00471 // Plot continental outline in world coordinates
00472 
00473     void map( void ( *mapform )( PLINT, PLFLT *, PLFLT * ), const char *type,
00474               PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat );
00475 
00476 // Plot map lines
00477 
00478         void mapline( void ( *mapform )( PLINT, PLFLT *, PLFLT * ), const char *type,
00479        PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat, 
00480            int* plotentries, int nplotentries);
00481 
00482 // Plot map points
00483 
00484         void mapstring( void ( *mapform )( PLINT, PLFLT *, PLFLT * ), 
00485                 const char *type, const char *string,
00486                 PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat, 
00487                 int* plotentries, int nplotentries);
00488 
00489 // Plot map text
00490 
00491         void maptex( void ( *mapform )( PLINT, PLFLT *, PLFLT * ), 
00492                 const char *type, PLFLT dx, PLFLT dy, PLFLT just, const char *text,
00493                 PLFLT minlong, PLFLT maxlong, PLFLT minlat, PLFLT maxlat, 
00494                 int plotentry);
00495 
00496 // Plot map fills
00497 
00498         void mapfill( void ( *mapform )( PLINT, PLFLT *, PLFLT * ), 
00499                 const char *type, PLFLT minlong, PLFLT maxlong, PLFLT minlat, 
00500                 PLFLT maxlat, int* plotentries, int nplotentries);
00501 
00502 // Plot the latitudes and longitudes on the background.
00503 
00504     void meridians( void ( *mapform )( PLINT, PLFLT *, PLFLT * ),
00505                     PLFLT dlong, PLFLT dlat, PLFLT minlong, PLFLT maxlong,
00506                     PLFLT minlat, PLFLT maxlat );
00507 
00508 // Plots a mesh representation of the function z[x][y].
00509 
00510     void mesh( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny, PLINT opt );
00511 
00512 // Plots a mesh representation of the function z[x][y] with contour.
00513 
00514     void meshc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z, PLINT nx, PLINT ny, PLINT opt,
00515                 const PLFLT *clevel, PLINT nlevel );
00516 
00517 // Creates a new stream and makes it the default.
00518 
00519 // void
00520 // mkstrm(PLINT *p_strm);
00521 
00522 // Prints out "text" at specified position relative to viewport
00523 
00524     void mtex( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
00525                const char *text );
00526 
00527 // Prints out "text" at specified position relative to viewport (3D)
00528 
00529     void mtex3( const char *side, PLFLT disp, PLFLT pos, PLFLT just,
00530                 const char *text );
00531 
00532 // Plots a 3-d representation of the function z[x][y].
00533 
00534     void plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
00535                  PLINT nx, PLINT ny, PLINT opt, bool side );
00536 
00537 // Plots a 3-d representation of the function z[x][y] with contour.
00538 
00539     void plot3dc( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
00540                   PLINT nx, PLINT ny, PLINT opt,
00541                   const PLFLT *clevel, PLINT nlevel );
00542 
00543 // Plots a 3-d representation of the function z[x][y] with contour
00544 // and y index limits.
00545 
00546     void plot3dcl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
00547                    PLINT nx, PLINT ny, PLINT opt,
00548                    const PLFLT *clevel, PLINT nlevel,
00549                    PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
00550 
00551 
00552 // Plots a 3-d shaded representation of the function z[x][y].
00553 
00554     void surf3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
00555                  PLINT nx, PLINT ny, PLINT opt,
00556                  const PLFLT *clevel, PLINT nlevel );
00557 
00558 // Plots a 3-d shaded representation of the function z[x][y] with y
00559 // index limits
00560 
00561     void surf3dl( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
00562                   PLINT nx, PLINT ny, PLINT opt,
00563                   const PLFLT *clevel, PLINT nlevel,
00564                   PLINT ixstart, PLINT ixn, const PLINT *indexymin, const PLINT *indexymax );
00565 
00566 
00567 // Process options list using current options info.
00568 
00569     int parseopts( int *p_argc, const char **argv, PLINT mode );
00570 
00571 // Set fill pattern directly.
00572 
00573     void pat( PLINT nlin, const PLINT *inc, const PLINT *del );
00574 
00575 // Draw a line connecting two points, accounting for coordinate transforms
00576 
00577     void path( PLINT n, PLFLT x1, PLFLT y1, PLFLT x2, PLFLT y2 );
00578 
00579 // Plots array y against x for n points using ASCII code "code".
00580 
00581     void poin( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code );
00582 
00583 // Draws a series of points in 3 space.
00584 
00585     void poin3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, PLINT code );
00586 
00587 // Draws a polygon in 3 space.
00588 
00589     void poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const bool *draw, bool ifcc );
00590 
00591 // Set the floating point precision (in number of places) in numeric labels.
00592 
00593     void prec( PLINT setp, PLINT prec );
00594 
00595 // Set fill pattern, using one of the predefined patterns.
00596 
00597     void psty( PLINT patt );
00598 
00599 // Prints out "text" at world cooordinate (x,y).
00600 
00601     void ptex( PLFLT x, PLFLT y, PLFLT dx, PLFLT dy, PLFLT just,
00602                const char *text );
00603 
00604 // Prints out "text" at world cooordinate (x,y,z).
00605 
00606     void ptex3( PLFLT wx, PLFLT wy, PLFLT wz, PLFLT dx, PLFLT dy, PLFLT dz,
00607                 PLFLT sx, PLFLT sy, PLFLT sz, PLFLT just, const char *text );
00608 
00609 // Replays contents of plot buffer to current device/file.
00610 
00611     void replot( void );
00612 
00613 // Set line color by red, green, blue from  0. to 1.
00614 
00615 #ifdef PL_DEPRECATED
00616     void rgb( PLFLT r, PLFLT g, PLFLT b );
00617 #endif // PL_DEPRECATED
00618 
00619 // Set line color by 8 bit RGB values.
00620 
00621 #ifdef PL_DEPRECATED
00622     void rgb( PLINT r, PLINT g, PLINT b );
00623 #endif // PL_DEPRECATED
00624 
00625 // Set character height.
00626 
00627     void schr( PLFLT def, PLFLT scale );
00628 
00629 // Set number of colors in cmap 0
00630 
00631     void scmap0n( PLINT ncol0 );
00632 
00633 // Set number of colors in cmap 1
00634 
00635     void scmap1n( PLINT ncol1 );
00636 
00637 // Set the color map 1 range used in continuous plots
00638 
00639     void scmap1_range( PLFLT min_color, PLFLT max_color );
00640 
00641 // Get the color map 1 range used in continuous plots
00642 
00643     void gcmap1_range( PLFLT &min_color, PLFLT &max_color );
00644 
00645 // Set color map 0 colors by 8 bit RGB values
00646 
00647     void scmap0( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol0 );
00648 
00649 // Set color map 0 colors by 8 bit RGB values and alpha value (0.0-1.0)
00650 
00651     void scmap0a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol0 );
00652 
00653 // Set color map 1 colors by 8 bit RGB values
00654 
00655     void scmap1( const PLINT *r, const PLINT *g, const PLINT *b, PLINT ncol1 );
00656 
00657 // Set color map 1 colors by 8 bit RGB values and alpha value (0.0-1.0)
00658 
00659     void scmap1a( const PLINT *r, const PLINT *g, const PLINT *b, const PLFLT *a, PLINT ncol1 );
00660 
00661 // Set color map 1 colors using a piece-wise linear relationship between
00662 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
00663 
00664     void scmap1l( bool itype, PLINT npts, const PLFLT *intensity,
00665                   const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const bool *alt_hue_path = NULL );
00666 
00667 //    void scmap1l( bool itype, PLINT npts, PLFLT *intensity,
00668 //                PLFLT *coord1, PLFLT *coord2, PLFLT *coord3 );
00669 
00670 // Set color map 1 colors using a piece-wise linear relationship between
00671 // intensity [0,1] (cmap 1 index) and position in HLS or RGB color space.
00672 // Include alpha value in range 0.0-1.0.
00673 
00674     void scmap1la( bool itype, PLINT npts, const PLFLT *intensity,
00675                    const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLFLT *a,
00676                    const bool *alt_hue_path = NULL );
00677 
00678 // Set a given color from color map 0 by 8 bit RGB value
00679 
00680     void scol0( PLINT icol0, PLINT r, PLINT g, PLINT b );
00681 
00682 // Set a given color from color map 0 by 8 bit RGB value and alpha value (0.0-1.0)
00683 
00684     void scol0a( PLINT icol0, PLINT r, PLINT g, PLINT b, PLFLT a );
00685 
00686 // Set the background color by 8 bit RGB value
00687 
00688     void scolbg( PLINT r, PLINT g, PLINT b );
00689 
00690 // Set the background color by 8 bit RGB + alpha value
00691 
00692     void scolbga( PLINT r, PLINT g, PLINT b, PLFLT a );
00693 
00694 // Used to globally turn color output on/off
00695 
00696     void scolor( PLINT color );
00697 
00698 // Set the compression level
00699 
00700     void scompression( PLINT compression );
00701 
00702 // Set the device (keyword) name
00703 
00704     void sdev( const char *devname );
00705 
00706 // Get the device (keyword) name
00707 
00708     void gdev( char *devname );
00709 
00710 // Set window into device space using margin, aspect ratio, and
00711 // justification
00712 
00713     void sdidev( PLFLT mar, PLFLT aspect, PLFLT jx, PLFLT jy );
00714 
00715 // Set up transformation from metafile coordinates.
00716 
00717     void sdimap( PLINT dimxmin, PLINT dimxmax,
00718                  PLINT dimymin, PLINT dimymax,
00719                  PLFLT dimxpmm, PLFLT dimypmm );
00720 
00721 // Set plot orientation, specifying rotation in units of pi/2.
00722 
00723     void sdiori( PLFLT rot );
00724 
00725 // Set window into plot space
00726 
00727     void sdiplt( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
00728 
00729 // Set window into plot space incrementally (zoom)
00730 
00731     void sdiplz( PLFLT xmin, PLFLT ymin, PLFLT xmax, PLFLT ymax );
00732 
00733 // Set the escape character for text strings.
00734 
00735     void sesc( char esc );
00736 
00737 // Set offset and spacing of contour labels
00738 
00739     void setcontlabelparam( PLFLT offset, PLFLT size, PLFLT spacing,
00740                             PLINT active );
00741 
00742 // Set the format of the contour labels
00743 
00744     void setcontlabelformat( PLINT lexp, PLINT sigdig );
00745 
00746 // Set family file parameters
00747 
00748     void sfam( PLINT fam, PLINT num, PLINT bmax );
00749 
00750 // Set FCI (font characterization integer)
00751 
00752     void sfci( PLUNICODE fci );
00753 
00754 // Set the output file name.
00755 
00756     void sfnam( const char *fnam );
00757 
00758 // Set the current font family, style and weight
00759 
00760     void sfont( PLINT family, PLINT style, PLINT weight );
00761 
00762 // Shade region.
00763 
00764     void shade( const PLFLT * const *a, PLINT nx, PLINT ny,
00765                 PLINT ( *defined )( PLFLT, PLFLT ),
00766                 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
00767                 PLFLT shade_min, PLFLT shade_max,
00768                 PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
00769                 PLINT min_color, PLFLT min_width,
00770                 PLINT max_color, PLFLT max_width,
00771                 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
00772                 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00773                 PLPointer pltr_data );
00774 
00775     void shades( const PLFLT * const *a, PLINT nx, PLINT ny,
00776                  PLINT ( *defined )( PLFLT, PLFLT ),
00777                  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
00778                  const PLFLT * clevel, PLINT nlevel, PLFLT fill_width,
00779                  PLINT cont_color, PLFLT cont_width,
00780                  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
00781                  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00782                  PLPointer pltr_data );
00783 
00784 // Would be nice to fix this even more, say by stuffing xmin, xmax,
00785 // ymin, ymax, rectangular, and pcxf all into the contourable data
00786 // class.  Have to think more on that.  Or maybe the coordinate info.
00787 
00788     void shade( Contourable_Data& d, PLFLT xmin, PLFLT xmax,
00789                 PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
00790                 PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
00791                 PLINT min_color, PLFLT min_width,
00792                 PLINT max_color, PLFLT max_width,
00793                 bool rectangular,
00794                 Coord_Xformer *pcxf );
00795 
00796     void shade1( const PLFLT * a, PLINT nx, PLINT ny,
00797                  PLINT ( *defined )( PLFLT, PLFLT ),
00798                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
00799                  PLFLT shade_min, PLFLT shade_max,
00800                  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
00801                  PLINT min_color, PLFLT min_width,
00802                  PLINT max_color, PLFLT max_width,
00803                  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
00804                  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00805                  PLPointer pltr_data );
00806 
00807     void fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
00808                  PLPointer f2eval_data,
00809                  PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
00810                  PLPointer c2eval_data,
00811                  PLINT nx, PLINT ny,
00812                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
00813                  PLFLT shade_min, PLFLT shade_max,
00814                  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
00815                  PLINT min_color, PLFLT min_width,
00816                  PLINT max_color, PLFLT max_width,
00817                  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), bool rectangular,
00818                  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00819                  PLPointer pltr_data );
00820 
00821 // Setup a user-provided custom labeling function
00822 
00823     void slabelfunc( void ( *label_func )( PLINT, PLFLT, char *, PLINT, PLPointer ),
00824                      PLPointer label_data );
00825 
00826 // Set up lengths of major tick marks.
00827 
00828     void smaj( PLFLT def, PLFLT scale );
00829 
00830 // Set the RGB memory area to be plotted (with the 'mem' or 'memcairo' drivers)
00831 
00832     void smem( PLINT maxx, PLINT maxy, void *plotmem );
00833 
00834 // Set the RGBA memory area to be plotted (with the 'memcairo' driver)
00835 
00836     void smema( PLINT maxx, PLINT maxy, void *plotmem );
00837 
00838 // Set up lengths of minor tick marks.
00839 
00840     void smin( PLFLT def, PLFLT scale );
00841 
00842 // Set orientation.  Must be done before calling plinit.
00843 
00844     void sori( PLINT ori );
00845 
00846 // Set output device parameters.  Usually ignored by the driver.
00847 
00848     void spage( PLFLT xp, PLFLT yp, PLINT xleng, PLINT yleng,
00849                 PLINT xoff, PLINT yoff );
00850 
00851 // Set the pause (on end-of-page) status
00852 
00853     void spause( bool pause );
00854 
00855 // Set the colors for color table 0 from a cmap0 file
00856 
00857     void spal0( const char *filename );
00858 
00859 // Set the colors for color table 1 from a cmap1 file
00860 
00861     void spal1( const char *filename, bool interpolate = true );
00862 
00863 // Set stream number.
00864 
00865     void sstrm( PLINT strm );
00866 
00867 // Set the number of subwindows in x and y
00868 
00869     void ssub( PLINT nx, PLINT ny );
00870 
00871 // Set symbol height.
00872 
00873     void ssym( PLFLT def, PLFLT scale );
00874 
00875 // Initialize PLplot, passing in the windows/page settings.
00876 
00877     void star( PLINT nx, PLINT ny );
00878 
00879 // Initialize PLplot, passing the device name and windows/page settings.
00880 
00881     void start( const char *devname, PLINT nx, PLINT ny );
00882 
00883 // Set the coordinate transform
00884 
00885     void stransform( void ( *coordinate_transform )( PLFLT, PLFLT, PLFLT*, PLFLT*, PLPointer ), PLPointer coordinate_transform_data );
00886 
00887 // Prints out the same string repeatedly at the n points in world
00888 // coordinates given by the x and y arrays.  Supersedes plpoin and
00889 // plsymbol for the case where text refers to a unicode glyph either
00890 // directly as UTF-8 or indirectly via the standard text escape
00891 // sequences allowed for PLplot input strings.
00892 
00893     void string( PLINT n, const PLFLT *x, const PLFLT *y, const char *string );
00894 
00895 // Prints out the same string repeatedly at the n points in world
00896 // coordinates given by the x, y, and z arrays.  Supersedes plpoin3
00897 // for the case where text refers to a unicode glyph either directly
00898 // as UTF-8 or indirectly via the standard text escape sequences
00899 // allowed for PLplot input strings.
00900 
00901     void string3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const char *string );
00902 
00903 // Create 1d stripchart
00904 
00905     void stripc( PLINT *id, const char *xspec, const char *yspec,
00906                  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
00907                  PLFLT xlpos, PLFLT ylpos,
00908                  bool y_ascl, bool acc,
00909                  PLINT colbox, PLINT collab,
00910                  const PLINT colline[], const PLINT styline[], const char *legline[],
00911                  const char *labx, const char *laby, const char *labtop );
00912 
00913 // Add a point to a stripchart.
00914 
00915     void stripa( PLINT id, PLINT pen, PLFLT x, PLFLT y );
00916 
00917 // Deletes and releases memory used by a stripchart.
00918 
00919     void stripd( PLINT id );
00920 
00921 // plots a 2d image (or a matrix too large for plshade() ) - colors
00922 // automatically scaled
00923 
00924     void image( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
00925                 PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
00926                 PLFLT Dxmin, PLFLT Dxmax, PLFLT Dymin, PLFLT Dymax );
00927 
00928 // plots a 2d image (or a matrix too large for plshade() )
00929 
00930     void imagefr( const PLFLT * const *data, PLINT nx, PLINT ny, PLFLT xmin, PLFLT xmax,
00931                   PLFLT ymin, PLFLT ymax, PLFLT zmin, PLFLT zmax,
00932                   PLFLT valuemin, PLFLT valuemax,
00933                   void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
00934                   PLPointer pltr_data );
00935 
00936 // Set up a new line style
00937 
00938     void styl( PLINT nms, const PLINT *mark, const PLINT *space );
00939 
00940 // Sets the edges of the viewport to the specified absolute coordinates
00941 
00942     void svpa( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
00943 
00944 // Set x axis labeling parameters
00945 
00946     void sxax( PLINT digmax, PLINT digits );
00947 
00948 // Set inferior X window
00949 
00950     void sxwin( PLINT window_id );
00951 
00952 // Set y axis labeling parameters
00953 
00954     void syax( PLINT digmax, PLINT digits );
00955 
00956 // Plots array y against x for n points using Hershey symbol "code"
00957 
00958     void sym( PLINT n, const PLFLT *x, const PLFLT *y, PLINT code );
00959 
00960 // Set z axis labeling parameters
00961 
00962     void szax( PLINT digmax, PLINT digits );
00963 
00964 // Switches to text screen.
00965 
00966     void text( void );
00967 
00968 // Set the format for date / time labels
00969 
00970     void timefmt( const char *fmt );
00971 
00972 // Sets the edges of the viewport with the given aspect ratio, leaving
00973 // room for labels.
00974 
00975     void vasp( PLFLT aspect );
00976 
00977 // Creates the largest viewport of the specified aspect ratio that fits
00978 // within the specified normalized subpage coordinates.
00979 
00980     void vpas( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax, PLFLT aspect );
00981 
00982 // Creates a viewport with the specified normalized subpage coordinates.
00983 
00984     void vpor( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
00985 
00986 // Defines a "standard" viewport with seven character heights for
00987 // the left margin and four character heights everywhere else.
00988 
00989     void vsta( void );
00990 
00991 // Set up a window for three-dimensional plotting.
00992 
00993     void w3d( PLFLT basex, PLFLT basey, PLFLT height, PLFLT xmin0,
00994               PLFLT xmax0, PLFLT ymin0, PLFLT ymax0, PLFLT zmin0,
00995               PLFLT zmax0, PLFLT alt, PLFLT az );
00996 
00997 // Set pen width.
00998 
00999     void width( PLFLT width );
01000 
01001 // Set up world coordinates of the viewport boundaries (2d plots).
01002 
01003     void wind( PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax );
01004 
01005 // Set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device
01006     void xormod( bool mode, bool *status );
01007 
01008 // Random number generator based on Mersenne Twister.
01009 // Functions to set seed and obtain real random numbers in the range [0,1].
01010 
01011     void seed( unsigned int s );
01012 
01013     PLFLT randd( void );
01014 
01015 
01016     // The rest for use from C only
01017 
01018 // Returns a list of file-oriented device names and their menu strings
01019 
01020     void gFileDevs( const char ***p_menustr, const char ***p_devname,
01021                     int *p_ndev );
01022 
01023 // Set the function pointer for the keyboard event handler
01024 
01025     void sKeyEH( void ( *KeyEH )( PLGraphicsIn *, void *, int * ),
01026                  void *KeyEH_data );
01027 
01028 // Sets an optional user bop handler
01029 
01030     void sbopH( void ( *handler )( void *, int * ), void *handlier_data );
01031 
01032 // Sets an optional user eop handler
01033 
01034     void seopH( void ( *handler )( void *, int * ), void *handlier_data );
01035 
01036 // Set the variables to be used for storing error info
01037 
01038     void sError( PLINT *errcode, char *errmsg );
01039 
01040 // Sets an optional user exit handler.
01041 
01042     void sexit( int ( *handler )( const char * ) );
01043 
01044     // Transformation routines
01045 
01046 // Identity transformation.
01047 
01048     static void tr0( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
01049 
01050 // Does linear interpolation from singly dimensioned coord arrays.
01051 
01052     static void tr1( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
01053 
01054 // Does linear interpolation from doubly dimensioned coord arrays
01055 // (column dominant, as per normal C 2d arrays).
01056 
01057     static void tr2( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
01058 
01059 // Just like pltr2() but uses pointer arithmetic to get coordinates from
01060 // 2d grid tables.
01061 
01062     static void tr2p( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, PLPointer pltr_data );
01063 
01064 // We obviously won't be using this object from Fortran...
01065 
01066 // Identity transformation for plots from Fortran.
01067 
01068 //     void tr0f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
01069 
01070 // Does linear interpolation from doubly dimensioned coord arrays
01071 // (row dominant, i.e. Fortran ordering).
01072 
01073 //     void tr2f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
01074 
01075 // Example linear transformation function for contour plotter.
01076 // This is not actually part of the core library any more
01077     //void  xform( PLFLT x, PLFLT y, PLFLT * tx, PLFLT * ty );
01078 
01079     // Function evaluators
01080 
01081 // Does a lookup from a 2d function array.  Array is of type (PLFLT **),
01082 // and is column dominant (normal C ordering).
01083 
01084     PLFLT f2eval2( PLINT ix, PLINT iy, PLPointer plf2eval_data );
01085 
01086 // Does a lookup from a 2d function array.  Array is of type (PLFLT *),
01087 // and is column dominant (normal C ordering).
01088 
01089     PLFLT f2eval( PLINT ix, PLINT iy, PLPointer plf2eval_data );
01090 
01091 // Does a lookup from a 2d function array.  Array is of type (PLFLT *),
01092 // and is row dominant (Fortran ordering).
01093 
01094     PLFLT f2evalr( PLINT ix, PLINT iy, PLPointer plf2eval_data );
01095 
01096     // Command line parsing utilities
01097 
01098 // Clear internal option table info structure.
01099 
01100     void ClearOpts( void );
01101 
01102 // Reset internal option table info structure.
01103 
01104     void ResetOpts( void );
01105 
01106 // Merge user option table into internal info structure.
01107 
01108     int MergeOpts( PLOptionTable *options, const char *name, const char **notes );
01109 
01110 // Set the strings used in usage and syntax messages.
01111 
01112     void SetUsage( char *program_string, char *usage_string );
01113 
01114 // Process input strings, treating them as an option and argument pair.
01115 
01116     int setopt( const char *opt, const char *optarg );
01117 
01118 // This version is for backward compatibility only - don't use in new code
01119 
01120     int SetOpt( const char *opt, const char *optarg );
01121 
01122 // Process options list using current options info.
01123 
01124     int ParseOpts( int *p_argc, const char **argv, PLINT mode );
01125 
01126 // Print usage & syntax message.
01127 
01128     void OptUsage( void );
01129 
01130     // Miscellaneous
01131 
01132 // Set the output file pointer
01133 
01134     void gfile( FILE **p_file );
01135 
01136 // Get the output file pointer
01137 
01138     void sfile( FILE *file );
01139 
01140 // Get the escape character for text strings.
01141 
01142     void gesc( char *p_esc );
01143 
01144 // Front-end to driver escape function.
01145 
01146     void cmd( PLINT op, void *ptr );
01147 
01148 // Return full pathname for given file if executable
01149 
01150     int  FindName( char *p );
01151 
01152 // Looks for the specified executable file according to usual search path.
01153 
01154     char *FindCommand( char *fn );
01155 
01156 // Gets search name for file by concatenating the dir, subdir, and file
01157 // name, allocating memory as needed.
01158 
01159     void GetName( char *dir, char *subdir, char *filename, char **filespec );
01160 
01161 // Prompts human to input an integer in response to given message.
01162 
01163     PLINT GetInt( char *s );
01164 
01165 // Prompts human to input a float in response to given message.
01166 
01167     PLFLT GetFlt( char *s );
01168 
01169     // Nice way to allocate space for a vectored 2d grid
01170 
01171 // Allocates a block of memory for use as a 2-d grid of PLFLT's.
01172 
01173     void Alloc2dGrid( PLFLT ***f, PLINT nx, PLINT ny );
01174 
01175 // Frees a block of memory allocated with plAlloc2dGrid().
01176 
01177     void Free2dGrid( PLFLT **f, PLINT nx, PLINT ny );
01178 
01179 // Find the maximum and minimum of a 2d matrix allocated with plAllc2dGrid().
01180     void MinMax2dGrid( const PLFLT * const *f, PLINT nx, PLINT ny, PLFLT *fmax, PLFLT *fmin );
01181 
01182 // Functions for converting between HLS and RGB color space
01183 
01184     void hlsrgb( PLFLT h, PLFLT l, PLFLT s,
01185                  PLFLT *p_r, PLFLT *p_g, PLFLT *p_b );
01186 
01187     void rgbhls( PLFLT r, PLFLT g, PLFLT b,
01188                  PLFLT *p_h, PLFLT *p_l, PLFLT *p_s );
01189 
01190 // Wait for graphics input event and translate to world coordinates
01191 
01192     int GetCursor( PLGraphicsIn *plg );
01193 
01194 // Deprecated versions of methods which use PLINT instead of bool
01195     void svect( const PLFLT *arrow_x, const PLFLT *arrow_y, PLINT npts, PLINT fill );
01196     void cpstrm( plstream &pls, PLINT flags );
01197     void plot3d( const PLFLT *x, const PLFLT *y, const PLFLT * const *z,
01198                  PLINT nx, PLINT ny, PLINT opt, PLINT side );
01199     void poly3( PLINT n, const PLFLT *x, const PLFLT *y, const PLFLT *z, const PLINT *draw, PLINT ifcc );
01200     void scmap1l( PLINT itype, PLINT npts, const PLFLT *intensity,
01201                   const PLFLT *coord1, const PLFLT *coord2, const PLFLT *coord3, const PLINT *alt_hue_path );
01202 
01203     void shade( const PLFLT * const *a, PLINT nx, PLINT ny,
01204                 PLINT ( *defined )( PLFLT, PLFLT ),
01205                 PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01206                 PLFLT shade_min, PLFLT shade_max,
01207                 PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
01208                 PLINT min_color, PLFLT min_width,
01209                 PLINT max_color, PLFLT max_width,
01210                 void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01211                 void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01212                 PLPointer pltr_data );
01213 
01214     void shades( const PLFLT * const *a, PLINT nx, PLINT ny, PLINT ( *defined )( PLFLT,
01215                                                                                  PLFLT ),
01216                  PLFLT xmin, PLFLT xmax, PLFLT ymin, PLFLT ymax,
01217                  const PLFLT * clevel, PLINT nlevel, PLFLT fill_width,
01218                  PLINT cont_color, PLFLT cont_width,
01219                  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01220                  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01221                  PLPointer pltr_data );
01222 
01223     void shade( Contourable_Data& d, PLFLT xmin, PLFLT xmax,
01224                 PLFLT ymin, PLFLT ymax, PLFLT shade_min, PLFLT shade_max,
01225                 PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
01226                 PLINT min_color, PLFLT min_width,
01227                 PLINT max_color, PLFLT max_width,
01228                 PLINT rectangular,
01229                 Coord_Xformer *pcxf );
01230 
01231     void shade1( const PLFLT * a, PLINT nx, PLINT ny,
01232                  PLINT ( *defined )( PLFLT, PLFLT ),
01233                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01234                  PLFLT shade_min, PLFLT shade_max,
01235                  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
01236                  PLINT min_color, PLFLT min_width,
01237                  PLINT max_color, PLFLT max_width,
01238                  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01239                  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01240                  PLPointer pltr_data );
01241 
01242     void fshade( PLFLT ( *f2eval )( PLINT, PLINT, PLPointer ),
01243                  PLPointer f2eval_data,
01244                  PLFLT ( *c2eval )( PLINT, PLINT, PLPointer ),
01245                  PLPointer c2eval_data,
01246                  PLINT nx, PLINT ny,
01247                  PLFLT left, PLFLT right, PLFLT bottom, PLFLT top,
01248                  PLFLT shade_min, PLFLT shade_max,
01249                  PLINT sh_cmap, PLFLT sh_color, PLFLT sh_width,
01250                  PLINT min_color, PLFLT min_width,
01251                  PLINT max_color, PLFLT max_width,
01252                  void ( *fill )( PLINT, const PLFLT *, const PLFLT * ), PLINT rectangular,
01253                  void ( *pltr )( PLFLT, PLFLT, PLFLT *, PLFLT *, PLPointer ),
01254                  PLPointer pltr_data );
01255 
01256     void spause( PLINT pause );
01257 
01258     void stripc( PLINT *id, const char *xspec, const char *yspec,
01259                  PLFLT xmin, PLFLT xmax, PLFLT xjump, PLFLT ymin, PLFLT ymax,
01260                  PLFLT xlpos, PLFLT ylpos,
01261                  PLINT y_ascl, PLINT acc,
01262                  PLINT colbox, PLINT collab,
01263                  const PLINT colline[], const PLINT styline[], const char *legline[],
01264                  const char *labx, const char *laby, const char *labtop );
01265 
01266     void xormod( PLINT mode, PLINT *status );
01267 };
01268 
01269 
01270 
01271 #endif                          // __plstream_h__
01272 
01273 //--------------------------------------------------------------------------
01274 //                              end of plstream.h
01275 //--------------------------------------------------------------------------
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines