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

plstream.h

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

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