PLplot  5.10.0
sccont.c
Go to the documentation of this file.
00001 //      Contour plotter front-ends for Fortran.
00002 //
00003 // Copyright (C) 2004-2014 Alan W. Irwin
00004 //
00005 // This file is part of PLplot.
00006 //
00007 // PLplot is free software; you can redistribute it and/or modify
00008 // it under the terms of the GNU Library General Public License as published
00009 // by the Free Software Foundation; either version 2 of the License, or
00010 // (at your option) any later version.
00011 //
00012 // PLplot is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // GNU Library General Public License for more details.
00016 //
00017 // You should have received a copy of the GNU Library General Public License
00018 // along with PLplot; if not, write to the Free Software
00019 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
00020 //
00021 //
00022 
00023 #include "plstubs.h"
00024 
00025 // Function prototypes
00026 void pltr0f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
00027 void PLCON07( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
00028               PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel );
00029 void PLCON17( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
00030               PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
00031               PLFLT *xg, PLFLT *yg );
00032 void PLCON27( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
00033               PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
00034               PLFLT *xg, PLFLT *yg );
00035 void PLVEC07( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale );
00036 void PLVEC17( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
00037               PLFLT *xg, PLFLT *yg );
00038 void PLVEC27( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
00039               PLFLT *xg, PLFLT *yg );
00040 static void pltr( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
00041 void PLCONT7( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
00042               PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel, PLFLT *ftr );
00043 void PLVECT7( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
00044               PLFLT *ftr );
00045 void PLSHADE07( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
00046                 PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00047                 PLFLT *shade_min, PLFLT *shade_max,
00048                 PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
00049                 PLINT *min_color, PLFLT *min_width,
00050                 PLINT *max_color, PLFLT *max_width, PLINT *lx );
00051 void PLSHADE17( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
00052                 PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00053                 PLFLT *shade_min, PLFLT *shade_max,
00054                 PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
00055                 PLINT *min_color, PLFLT *min_width,
00056                 PLINT *max_color, PLFLT *max_width,
00057                 PLFLT *xg1, PLFLT *yg1, PLINT *lx );
00058 void PLSHADE27( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
00059                 PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00060                 PLFLT *shade_min, PLFLT *shade_max,
00061                 PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
00062                 PLINT *min_color, PLFLT *min_width,
00063                 PLINT *max_color, PLFLT *max_width,
00064                 PLFLT *xg2, PLFLT *yg2, PLINT *lx );
00065 void PLSHADE7( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
00066                PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00067                PLFLT *shade_min, PLFLT *shade_max,
00068                PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
00069                PLINT *min_color, PLFLT *min_width,
00070                PLINT *max_color, PLFLT *max_width, PLFLT *ftr, PLINT *lx );
00071 void PLSHADES07( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
00072                  PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00073                  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
00074                  PLINT *cont_color, PLFLT *cont_width, PLINT *lx, PLINT *rect );
00075 void PLSHADES17( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
00076                  PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00077                  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
00078                  PLINT *cont_color, PLFLT *cont_width,
00079                  PLFLT *xg1, PLFLT *yg1, PLINT *lx, PLINT *rect );
00080 void PLSHADES27( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
00081                  PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00082                  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
00083                  PLINT *cont_color, PLFLT *cont_width,
00084                  PLFLT *xg2, PLFLT *yg2, PLINT *lx, PLINT *rect );
00085 void PLSHADES7( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
00086                 PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00087                 PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
00088                 PLINT *cont_color, PLFLT *cont_width, PLFLT *ftr, PLINT *lx, PLINT *rect );
00089 void PLGRIDDATA( PLFLT *x, PLFLT *y, PLFLT *z, PLINT *npts, PLFLT *xg,
00090                  PLINT *nx, PLFLT *yg, PLINT *ny, PLFLT *zg, PLINT *type,
00091                  PLFLT *data );
00092 void PLIMAGEFR07( PLFLT *idata, PLINT *nx, PLINT *ny,
00093                   PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00094                   PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
00095                   PLINT *lx );
00096 void PLIMAGEFR17( PLFLT *idata, PLINT *nx, PLINT *ny,
00097                   PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00098                   PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
00099                   PLFLT *xg, PLFLT *yg, PLINT *lx );
00100 void PLIMAGEFR27( PLFLT *idata, PLINT *nx, PLINT *ny,
00101                   PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00102                   PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
00103                   PLFLT *xg, PLFLT *yg, PLINT *lx );
00104 void PLIMAGEFR7( PLFLT *idata, PLINT *nx, PLINT *ny,
00105                  PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00106                  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
00107                  PLFLT *ftr, PLINT *lx );
00108 
00109 
00110 
00111 
00112 //--------------------------------------------------------------------------
00113 // pltr0f()
00114 //
00115 // Identity transformation for plots from Fortran.
00116 // Only difference from C-language identity function (pltr0) is that the
00117 // Fortran paradigm for array index is used, i.e. starting at 1.
00118 //--------------------------------------------------------------------------
00119 
00120 void
00121 pltr0f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *PL_UNUSED( pltr_data ) )
00122 {
00123     *tx = x + 1.0;
00124     *ty = y + 1.0;
00125 }
00126 
00127 //--------------------------------------------------------------------------
00128 // Contour plotter front-ends.
00129 // These specify the row-dominant function evaluator in the plfcont
00130 // argument list.  NO TRANSPOSE IS NECESSARY.  The routines are as follows:
00131 //
00132 // - plcon0     no transformation
00133 // - plcon1     linear interpolation from singly dimensioned coord arrays
00134 // - plcon2     linear interpolation from doubly dimensioned coord arrays
00135 //
00136 // The latter two work by calling plfcont() with the appropriate grid
00137 // structure for input to pltr2f().
00138 //--------------------------------------------------------------------------
00139 
00140 // no transformation
00141 
00142 void
00143 PLCON07( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
00144          PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel )
00145 {
00146     PLfGrid fgrid;
00147 
00148     fgrid.nx = *nx;
00149     fgrid.ny = *ny;
00150     fgrid.f  = z;
00151 
00152     plfcont( plf2evalr, (void *) &fgrid,
00153         *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
00154         pltr0f, NULL );
00155 }
00156 
00157 // 1-d transformation
00158 
00159 void
00160 PLCON17( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
00161          PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
00162          PLFLT *xg, PLFLT *yg )
00163 {
00164     PLfGrid fgrid;
00165     PLcGrid cgrid;
00166 
00167     fgrid.nx = *nx;
00168     fgrid.ny = *ny;
00169     fgrid.f  = z;
00170 
00171     cgrid.nx = *nx;
00172     cgrid.ny = *ny;
00173     cgrid.xg = xg;
00174     cgrid.yg = yg;
00175 
00176     plfcont( plf2evalr, (void *) &fgrid,
00177         *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
00178         pltr1, (void *) &cgrid );
00179 }
00180 
00181 // 2-d transformation
00182 
00183 void
00184 PLCON27( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
00185          PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
00186          PLFLT *xg, PLFLT *yg )
00187 {
00188     PLfGrid fgrid;
00189     PLcGrid cgrid;
00190 
00191     fgrid.nx = *nx;
00192     fgrid.ny = *ny;
00193     fgrid.f  = z;
00194 
00195     cgrid.nx = *nx;
00196     cgrid.ny = *ny;
00197     cgrid.xg = xg;
00198     cgrid.yg = yg;
00199 
00200     plfcont( plf2evalr, (void *) &fgrid,
00201         *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
00202         pltr2f, (void *) &cgrid );
00203 }
00204 
00205 //--------------------------------------------------------------------------
00206 // Vector plotter front-ends.
00207 // These specify the row-dominant function evaluator in the plfvect
00208 // argument list.  NO TRANSPOSE IS NECESSARY.  The routines are as follows:
00209 //
00210 // - plvec0     no transformation
00211 // - plvec1     linear interpolation from singly dimensioned coord arrays
00212 // - plvec2     linear interpolation from doubly dimensioned coord arrays
00213 //
00214 // The latter two work by calling plfvect() with the appropriate grid
00215 // structure for input to pltr2f().
00216 //--------------------------------------------------------------------------
00217 
00218 // no transformation
00219 
00220 void
00221 PLVEC07( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale )
00222 {
00223     PLfGrid fgrid1, fgrid2;
00224 
00225     fgrid1.nx = *nx;
00226     fgrid1.ny = *ny;
00227     fgrid1.f  = u;
00228 
00229     fgrid2.nx = *nx;
00230     fgrid2.ny = *ny;
00231     fgrid2.f  = v;
00232 
00233     plfvect( plf2evalr, (void *) &fgrid1, (void *) &fgrid2,
00234         *nx, *ny, *scale, pltr0f, NULL );
00235 }
00236 
00237 // 1-d transformation
00238 
00239 void
00240 PLVEC17( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
00241          PLFLT *xg, PLFLT *yg )
00242 {
00243     PLfGrid fgrid1;
00244     PLfGrid fgrid2;
00245     PLcGrid cgrid;
00246 
00247     fgrid1.nx = *nx;
00248     fgrid1.ny = *ny;
00249     fgrid1.f  = u;
00250 
00251     fgrid2.nx = *nx;
00252     fgrid2.ny = *ny;
00253     fgrid2.f  = v;
00254 
00255     cgrid.nx = *nx;
00256     cgrid.ny = *ny;
00257     cgrid.xg = xg;
00258     cgrid.yg = yg;
00259 
00260     plfvect( plf2evalr, (void *) &fgrid1, (void *) &fgrid2,
00261         *nx, *ny, *scale, pltr1, (void *) &cgrid );
00262 }
00263 
00264 // 2-d transformation
00265 
00266 void
00267 PLVEC27( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
00268          PLFLT *xg, PLFLT *yg )
00269 {
00270     PLfGrid fgrid1;
00271     PLfGrid fgrid2;
00272     PLcGrid cgrid;
00273 
00274     fgrid1.nx = *nx;
00275     fgrid1.ny = *ny;
00276     fgrid1.f  = u;
00277 
00278     fgrid2.nx = *nx;
00279     fgrid2.ny = *ny;
00280     fgrid2.f  = v;
00281 
00282     cgrid.nx = *nx;
00283     cgrid.ny = *ny;
00284     cgrid.xg = xg;
00285     cgrid.yg = yg;
00286 
00287     plfvect( plf2evalr, (void *) &fgrid1, (void *) &fgrid2,
00288         *nx, *ny, *scale, pltr2f, (void *) &cgrid );
00289 }
00290 
00291 //--------------------------------------------------------------------------
00292 // Here are the old contour plotters.
00293 //--------------------------------------------------------------------------
00294 
00295 static void
00296 pltr( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data )
00297 {
00298     PLFLT *tr = (PLFLT *) pltr_data;
00299 
00300     *tx = tr[0] * x + tr[1] * y + tr[2];
00301     *ty = tr[3] * x + tr[4] * y + tr[5];
00302 }
00303 
00304 void
00305 PLCONT7( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
00306          PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel, PLFLT *ftr )
00307 {
00308     PLfGrid fgrid;
00309 
00310     fgrid.nx = *nx;
00311     fgrid.ny = *ny;
00312     fgrid.f  = z;
00313 
00314     plfcont( plf2evalr, (void *) &fgrid,
00315         *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
00316         pltr, (void *) ftr );
00317 }
00318 
00319 void
00320 PLVECT7( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
00321          PLFLT *ftr )
00322 {
00323     PLfGrid fgrid1;
00324     PLfGrid fgrid2;
00325 
00326     fgrid1.nx = *nx;
00327     fgrid1.ny = *ny;
00328     fgrid1.f  = u;
00329 
00330     fgrid2.nx = *nx;
00331     fgrid2.ny = *ny;
00332     fgrid2.f  = v;
00333 
00334     plfvect( plf2evalr, (void *) &fgrid1, (void *) &fgrid2,
00335         *nx, *ny, *scale,
00336         pltr, (void *) ftr );
00337 }
00338 
00339 //--------------------------------------------------------------------------
00340 // plfshade front-ends.
00341 // These specify the row-dominant function evaluator in the plfshade
00342 // argument list.  NO TRANSPOSE IS NECESSARY.  The routines are as follows:
00343 //
00344 // - plshade0   map indices to xmin, xmax, ymin, ymax.
00345 // The next two work by calling plfshade() with the appropriate grid
00346 // structure for input to pltr2f().
00347 // - plshade1   linear interpolation from singly dimensioned coord arrays
00348 // - plshade2   linear interpolation from doubly dimensioned coord arrays
00349 // - plshade    tr array transformation
00350 //
00351 //--------------------------------------------------------------------------
00352 
00353 void
00354 PLSHADE07( PLFLT *z, PLINT *nx, PLINT *ny, const char *PL_UNUSED( defined ),
00355            PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00356            PLFLT *shade_min, PLFLT *shade_max,
00357            PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
00358            PLINT *min_color, PLFLT *min_width,
00359            PLINT *max_color, PLFLT *max_width, PLINT *lx )
00360 {
00361     PLINT rect = 1;
00362     PLFLT ** a;
00363     int   i, j;
00364 
00365 // Create a vectored a array from transpose of the fortran z array.
00366     plAlloc2dGrid( &a, *nx, *ny );
00367     for ( i = 0; i < *nx; i++ )
00368     {
00369         for ( j = 0; j < *ny; j++ )
00370         {
00371             a[i][j] = z[i + j * *lx];
00372         }
00373     }
00374 
00375     c_plshade( (const PLFLT * const *) a, *nx, *ny, NULL,
00376         *xmin, *xmax, *ymin, *ymax,
00377         *shade_min, *shade_max,
00378         *sh_cmap, *sh_color, *sh_width,
00379         *min_color, *min_width, *max_color, *max_width,
00380         c_plfill, rect, NULL, NULL );
00381 
00382 // Clean up memory allocated for a
00383     plFree2dGrid( a, *nx, *ny );
00384 }
00385 
00386 
00387 // 1-d transformation
00388 
00389 void
00390 PLSHADE17( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
00391            PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00392            PLFLT *shade_min, PLFLT *shade_max,
00393            PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
00394            PLINT *min_color, PLFLT *min_width,
00395            PLINT *max_color, PLFLT *max_width,
00396            PLFLT *xg1, PLFLT *yg1, PLINT *lx )
00397 {
00398     PLINT   rect = 1;
00399     PLFLT   ** a;
00400     int     i, j;
00401     PLcGrid cgrid;
00402 
00403 // Create a vectored a array from transpose of the fortran z array.
00404     plAlloc2dGrid( &a, *nx, *ny );
00405     for ( i = 0; i < *nx; i++ )
00406     {
00407         for ( j = 0; j < *ny; j++ )
00408         {
00409             a[i][j] = z[i + j * *lx];
00410         }
00411     }
00412 
00413     cgrid.nx = *nx;
00414     cgrid.ny = *ny;
00415     cgrid.xg = xg1;
00416     cgrid.yg = yg1;
00417     c_plshade( (const PLFLT * const *) a, *nx, *ny, NULL,
00418         *xmin, *xmax, *ymin, *ymax,
00419         *shade_min, *shade_max,
00420         *sh_cmap, *sh_color, *sh_width,
00421         *min_color, *min_width, *max_color, *max_width,
00422         c_plfill, rect, pltr1, ( PLPointer ) & cgrid );
00423 
00424 // Clean up memory allocated for a
00425     plFree2dGrid( a, *nx, *ny );
00426 }
00427 
00428 // 2-d transformation
00429 
00430 void
00431 PLSHADE27( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
00432            PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00433            PLFLT *shade_min, PLFLT *shade_max,
00434            PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
00435            PLINT *min_color, PLFLT *min_width,
00436            PLINT *max_color, PLFLT *max_width,
00437            PLFLT *xg2, PLFLT *yg2, PLINT *lx )
00438 {
00439     PLINT    rect = 0;
00440     PLFLT    **a;
00441     int      i, j;
00442     PLcGrid2 cgrid2;
00443 
00444 // Create a vectored a array from transpose of the fortran z array.
00445     plAlloc2dGrid( &a, *nx, *ny );
00446     plAlloc2dGrid( &cgrid2.xg, *nx, *ny );
00447     plAlloc2dGrid( &cgrid2.yg, *nx, *ny );
00448     cgrid2.nx = *nx;
00449     cgrid2.ny = *ny;
00450     for ( i = 0; i < *nx; i++ )
00451     {
00452         for ( j = 0; j < *ny; j++ )
00453         {
00454             a[i][j]         = z[i + j * *lx];
00455             cgrid2.xg[i][j] = xg2[i + j * *lx];
00456             cgrid2.yg[i][j] = yg2[i + j * *lx];
00457         }
00458     }
00459 
00460     c_plshade( (const PLFLT * const *) a, *nx, *ny, NULL,
00461         *xmin, *xmax, *ymin, *ymax,
00462         *shade_min, *shade_max,
00463         *sh_cmap, *sh_color, *sh_width,
00464         *min_color, *min_width, *max_color, *max_width,
00465         c_plfill, rect, pltr2, (void *) &cgrid2 );
00466 
00467 // Clean up memory allocated for a
00468     plFree2dGrid( a, *nx, *ny );
00469     plFree2dGrid( cgrid2.xg, *nx, *ny );
00470     plFree2dGrid( cgrid2.yg, *nx, *ny );
00471 }
00472 
00473 void
00474 PLSHADE7( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
00475           PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00476           PLFLT *shade_min, PLFLT *shade_max,
00477           PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
00478           PLINT *min_color, PLFLT *min_width,
00479           PLINT *max_color, PLFLT *max_width, PLFLT *ftr, PLINT *lx )
00480 {
00481     PLINT rect = 1;
00482     PLFLT ** a;
00483     int   i, j;
00484 
00485 // Create a vectored a array from transpose of the fortran z array.
00486     plAlloc2dGrid( &a, *nx, *ny );
00487     for ( i = 0; i < *nx; i++ )
00488     {
00489         for ( j = 0; j < *ny; j++ )
00490         {
00491             a[i][j] = z[i + j * *lx];
00492         }
00493     }
00494 
00495     c_plshade( (const PLFLT * const *) a, *nx, *ny, NULL,
00496         *xmin, *xmax, *ymin, *ymax,
00497         *shade_min, *shade_max,
00498         *sh_cmap, *sh_color, *sh_width,
00499         *min_color, *min_width, *max_color, *max_width,
00500         c_plfill, rect, pltr, (void *) ftr );
00501 
00502 // Clean up memory allocated for a
00503     plFree2dGrid( a, *nx, *ny );
00504 }
00505 
00506 //--------------------------------------------------------------------------
00507 // plshades front-ends.
00508 //
00509 // - plshades0  map indices to xmin, xmax, ymin, ymax
00510 // - plshades1  linear interpolation from singly dimensioned coord arrays
00511 // - plshades2  linear interpolation from doubly dimensioned coord arrays
00512 // - plshades   pass tr information with plplot common block (and
00513 //              then pass tr as last argument of PLSHADES7)
00514 //--------------------------------------------------------------------------
00515 
00516 void
00517 PLSHADES07( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
00518             PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00519             PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
00520             PLINT *cont_color, PLFLT *cont_width, PLINT *lx, PLINT *rect )
00521 {
00522     PLFLT ** a;
00523     int   i, j;
00524 
00525 // Create a vectored a array from transpose of the fortran z array.
00526     plAlloc2dGrid( &a, *nx, *ny );
00527     for ( i = 0; i < *nx; i++ )
00528     {
00529         for ( j = 0; j < *ny; j++ )
00530         {
00531             a[i][j] = z[i + j * *lx];
00532         }
00533     }
00534 
00535     c_plshades( (const PLFLT * const *) a, *nx, *ny, NULL,
00536         *xmin, *xmax, *ymin, *ymax,
00537         clevel, *nlevel, *fill_width,
00538         *cont_color, *cont_width,
00539         c_plfill, *rect, NULL, NULL );
00540 
00541 // Clean up memory allocated for a
00542     plFree2dGrid( a, *nx, *ny );
00543 }
00544 
00545 void
00546 PLSHADES17( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
00547             PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00548             PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
00549             PLINT *cont_color, PLFLT *cont_width,
00550             PLFLT *xg1, PLFLT *yg1, PLINT *lx, PLINT *rect )
00551 {
00552     PLFLT   ** a;
00553     int     i, j;
00554     PLcGrid cgrid;
00555 
00556 // Create a vectored a array from transpose of the fortran z array.
00557     plAlloc2dGrid( &a, *nx, *ny );
00558     for ( i = 0; i < *nx; i++ )
00559     {
00560         for ( j = 0; j < *ny; j++ )
00561         {
00562             a[i][j] = z[i + j * *lx];
00563         }
00564     }
00565 
00566     cgrid.nx = *nx;
00567     cgrid.ny = *ny;
00568     cgrid.xg = xg1;
00569     cgrid.yg = yg1;
00570 
00571     c_plshades( (const PLFLT * const *) a, *nx, *ny, NULL,
00572         *xmin, *xmax, *ymin, *ymax,
00573         clevel, *nlevel, *fill_width,
00574         *cont_color, *cont_width,
00575         c_plfill, *rect, pltr1, ( PLPointer ) & cgrid );
00576 
00577 // Clean up memory allocated for a
00578     plFree2dGrid( a, *nx, *ny );
00579 }
00580 
00581 void
00582 PLSHADES27( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
00583             PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00584             PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
00585             PLINT *cont_color, PLFLT *cont_width,
00586             PLFLT *xg2, PLFLT *yg2, PLINT *lx, PLINT *rect )
00587 {
00588     PLFLT    **a;
00589     int      i, j;
00590     PLcGrid2 cgrid2;
00591 
00592 // Create a vectored a array from transpose of the fortran z array.
00593     plAlloc2dGrid( &a, *nx, *ny );
00594     plAlloc2dGrid( &cgrid2.xg, *nx, *ny );
00595     plAlloc2dGrid( &cgrid2.yg, *nx, *ny );
00596     cgrid2.nx = *nx;
00597     cgrid2.ny = *ny;
00598     for ( i = 0; i < *nx; i++ )
00599     {
00600         for ( j = 0; j < *ny; j++ )
00601         {
00602             a[i][j]         = z[i + j * *lx];
00603             cgrid2.xg[i][j] = xg2[i + j * *lx];
00604             cgrid2.yg[i][j] = yg2[i + j * *lx];
00605         }
00606     }
00607 
00608     c_plshades( (const PLFLT * const *) a, *nx, *ny, NULL,
00609         *xmin, *xmax, *ymin, *ymax,
00610         clevel, *nlevel, *fill_width,
00611         *cont_color, *cont_width,
00612         c_plfill, *rect, pltr2, (void *) &cgrid2 );
00613 
00614 // Clean up allocated memory
00615     plFree2dGrid( a, *nx, *ny );
00616     plFree2dGrid( cgrid2.xg, *nx, *ny );
00617     plFree2dGrid( cgrid2.yg, *nx, *ny );
00618 }
00619 
00620 void
00621 PLSHADES7( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
00622            PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00623            PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
00624            PLINT *cont_color, PLFLT *cont_width, PLFLT *ftr, PLINT *lx, PLINT *rect )
00625 {
00626     PLFLT ** a;
00627     int   i, j;
00628 
00629 // Create a vectored a array from transpose of the fortran z array.
00630     plAlloc2dGrid( &a, *nx, *ny );
00631     for ( i = 0; i < *nx; i++ )
00632     {
00633         for ( j = 0; j < *ny; j++ )
00634         {
00635             a[i][j] = z[i + j * *lx];
00636         }
00637     }
00638 
00639     c_plshades( (const PLFLT * const *) a, *nx, *ny, NULL,
00640         *xmin, *xmax, *ymin, *ymax,
00641         clevel, *nlevel, *fill_width,
00642         *cont_color, *cont_width,
00643         c_plfill, *rect, pltr, (void *) ftr );
00644 
00645 // Clean up memory allocated for a
00646     plFree2dGrid( a, *nx, *ny );
00647 }
00648 
00649 void
00650 PLGRIDDATA( PLFLT *x, PLFLT *y, PLFLT *z, PLINT *npts, PLFLT *xg,
00651             PLINT *nx, PLFLT *yg, PLINT *ny, PLFLT *zg, PLINT *type, PLFLT *data )
00652 {
00653     PLFLT ** a;
00654     int   i, j;
00655 
00656 // Create a vectored a array from transpose of the fortran z array.
00657     plAlloc2dGrid( &a, *nx, *ny );
00658 
00659     c_plgriddata( x, y, z, *npts, xg, *nx, yg, *ny, a, *type, *data );
00660 
00661     for ( i = 0; i < *nx; i++ )
00662     {
00663         for ( j = 0; j < *ny; j++ )
00664         {
00665             zg[i + j * *nx] = a[i][j];
00666         }
00667     }
00668 
00669 // Clean up memory allocated for a
00670     plFree2dGrid( a, *nx, *ny );
00671 }
00672 
00673 void
00674 PLIMAGEFR07( PLFLT *idata, PLINT *nx, PLINT *ny,
00675              PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00676              PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
00677              PLINT *lx )
00678 {
00679     int   i, j;
00680     PLFLT **pidata;
00681 
00682     plAlloc2dGrid( &pidata, *nx, *ny );
00683 
00684     for ( i = 0; i < *nx; i++ )
00685     {
00686         for ( j = 0; j < *ny; j++ )
00687         {
00688             pidata[i][j] = idata[i + j * ( *lx )];
00689         }
00690     }
00691 
00692     c_plimagefr( (const PLFLT * const *) pidata, *nx, *ny,
00693         *xmin, *xmax, *ymin, *ymax, *zmin, *zmax,
00694         *valuemin, *valuemax, pltr0, NULL );
00695 
00696     plFree2dGrid( pidata, *nx, *ny );
00697 }
00698 
00699 void
00700 PLIMAGEFR17( PLFLT *idata, PLINT *nx, PLINT *ny,
00701              PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00702              PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
00703              PLFLT *xg, PLFLT *yg, PLINT *lx )
00704 {
00705     int     i, j;
00706     PLFLT   **pidata;
00707     PLcGrid cgrid;
00708 
00709     plAlloc2dGrid( &pidata, *nx, *ny );
00710 
00711     cgrid.nx = ( *nx ) + 1;
00712     cgrid.ny = ( *ny ) + 1;
00713     cgrid.xg = xg;
00714     cgrid.yg = yg;
00715 
00716     for ( i = 0; i < *nx; i++ )
00717     {
00718         for ( j = 0; j < *ny; j++ )
00719         {
00720             pidata[i][j] = idata[i + j * ( *lx )];
00721         }
00722     }
00723 
00724     c_plimagefr( (const PLFLT * const *) pidata, *nx, *ny,
00725         *xmin, *xmax, *ymin, *ymax, *zmin, *zmax,
00726         *valuemin, *valuemax, pltr1, (void *) &cgrid );
00727 
00728     plFree2dGrid( pidata, *nx, *ny );
00729 }
00730 
00731 void
00732 PLIMAGEFR27( PLFLT *idata, PLINT *nx, PLINT *ny,
00733              PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00734              PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
00735              PLFLT *xg, PLFLT *yg, PLINT *lx )
00736 {
00737     int      i, j;
00738     PLFLT    **pidata;
00739     PLcGrid2 cgrid2;
00740 
00741     plAlloc2dGrid( &pidata, *nx, *ny );
00742     plAlloc2dGrid( &cgrid2.xg, ( *nx ) + 1, ( *ny ) + 1 );
00743     plAlloc2dGrid( &cgrid2.yg, ( *nx ) + 1, ( *ny ) + 1 );
00744 
00745     cgrid2.nx = ( *nx ) + 1;
00746     cgrid2.ny = ( *ny ) + 1;
00747     for ( i = 0; i <= *nx; i++ )
00748     {
00749         for ( j = 0; j <= *ny; j++ )
00750         {
00751             cgrid2.xg[i][j] = xg[i + j * ( ( *lx ) + 1 )];
00752             cgrid2.yg[i][j] = yg[i + j * ( ( *lx ) + 1 )];
00753         }
00754     }
00755 
00756     for ( i = 0; i < *nx; i++ )
00757     {
00758         for ( j = 0; j < *ny; j++ )
00759         {
00760             pidata[i][j] = idata[i + j * ( *lx )];
00761         }
00762     }
00763 
00764     c_plimagefr( (const PLFLT * const *) pidata, *nx, *ny,
00765         *xmin, *xmax, *ymin, *ymax, *zmin, *zmax,
00766         *valuemin, *valuemax, pltr2, (void *) &cgrid2 );
00767 
00768     plFree2dGrid( pidata, *nx, *ny );
00769     plFree2dGrid( cgrid2.xg, ( *nx ) + 1, ( *ny ) + 1 );
00770     plFree2dGrid( cgrid2.yg, ( *nx ) + 1, ( *ny ) + 1 );
00771 }
00772 
00773 void
00774 PLIMAGEFR7( PLFLT *idata, PLINT *nx, PLINT *ny,
00775             PLFLT *xmin, PLFLT *xmax, PLFLT *ymin, PLFLT *ymax,
00776             PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
00777             PLFLT *ftr, PLINT *lx )
00778 {
00779     int   i, j;
00780     PLFLT **pidata;
00781 
00782     plAlloc2dGrid( &pidata, *nx, *ny );
00783 
00784     for ( i = 0; i < *nx; i++ )
00785     {
00786         for ( j = 0; j < *ny; j++ )
00787         {
00788             pidata[i][j] = idata[i + j * ( *lx )];
00789         }
00790     }
00791 
00792     c_plimagefr( (const PLFLT * const *) pidata, *nx, *ny,
00793         *xmin, *xmax, *ymin, *ymax, *zmin, *zmax,
00794         *valuemin, *valuemax, pltr, (void *) ftr );
00795 
00796     plFree2dGrid( pidata, *nx, *ny );
00797 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Defines