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

sccont.c

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

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