PLplot
5.10.0
|
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 //--------------------------------------------------------------------------