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