PLplot  5.11.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros
sccont.c
Go to the documentation of this file.
1 // Contour plotter front-ends for Fortran.
2 //
3 // Copyright (C) 2004-2014 Alan W. Irwin
4 //
5 // This file is part of PLplot.
6 //
7 // PLplot is free software; you can redistribute it and/or modify
8 // it under the terms of the GNU Library General Public License as published
9 // by the Free Software Foundation; either version 2 of the License, or
10 // (at your option) any later version.
11 //
12 // PLplot is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU Library General Public License for more details.
16 //
17 // You should have received a copy of the GNU Library General Public License
18 // along with PLplot; if not, write to the Free Software
19 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 //
21 //
22 
23 #include "plstubs.h"
24 
25 // Function prototypes
26 void pltr0f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
27 void PLCON07( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
28  PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel );
29 void PLCON17( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
30  PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
31  PLFLT *xg, PLFLT *yg );
32 void PLCON27( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
33  PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
34  PLFLT *xg, PLFLT *yg );
35 void PLVEC07( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale );
36 void PLVEC17( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
37  PLFLT *xg, PLFLT *yg );
38 void PLVEC27( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
39  PLFLT *xg, PLFLT *yg );
40 static void pltr( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data );
41 void PLCONT7( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
42  PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel, PLFLT *ftr );
43 void PLVECT7( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
44  PLFLT *ftr );
45 void PLSHADE07( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
47  PLFLT *shade_min, PLFLT *shade_max,
48  PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
49  PLINT *min_color, PLFLT *min_width,
50  PLINT *max_color, PLFLT *max_width, PLINT *lx );
51 void PLSHADE17( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
53  PLFLT *shade_min, PLFLT *shade_max,
54  PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
55  PLINT *min_color, PLFLT *min_width,
56  PLINT *max_color, PLFLT *max_width,
57  PLFLT *xg1, PLFLT *yg1, PLINT *lx );
58 void PLSHADE27( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
60  PLFLT *shade_min, PLFLT *shade_max,
61  PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
62  PLINT *min_color, PLFLT *min_width,
63  PLINT *max_color, PLFLT *max_width,
64  PLFLT *xg2, PLFLT *yg2, PLINT *lx );
65 void PLSHADE7( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
67  PLFLT *shade_min, PLFLT *shade_max,
68  PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
69  PLINT *min_color, PLFLT *min_width,
70  PLINT *max_color, PLFLT *max_width, PLFLT *ftr, PLINT *lx );
71 void PLSHADES07( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
73  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
74  PLINT *cont_color, PLFLT *cont_width, PLINT *lx, PLINT *rect );
75 void PLSHADES17( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
77  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
78  PLINT *cont_color, PLFLT *cont_width,
79  PLFLT *xg1, PLFLT *yg1, PLINT *lx, PLINT *rect );
80 void PLSHADES27( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
82  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
83  PLINT *cont_color, PLFLT *cont_width,
84  PLFLT *xg2, PLFLT *yg2, PLINT *lx, PLINT *rect );
85 void PLSHADES7( PLFLT *z, PLINT *nx, PLINT *ny, const char *defined,
87  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
88  PLINT *cont_color, PLFLT *cont_width, PLFLT *ftr, PLINT *lx, PLINT *rect );
89 void PLGRIDDATA( PLFLT *x, PLFLT *y, PLFLT *z, PLINT *npts, PLFLT *xg,
90  PLINT *nx, PLFLT *yg, PLINT *ny, PLFLT *zg, PLINT *type,
91  PLFLT *data );
92 void PLIMAGEFR07( PLFLT *idata, PLINT *nx, PLINT *ny,
94  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
95  PLINT *lx );
96 void PLIMAGEFR17( PLFLT *idata, PLINT *nx, PLINT *ny,
98  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
99  PLFLT *xg, PLFLT *yg, PLINT *lx );
100 void PLIMAGEFR27( PLFLT *idata, PLINT *nx, PLINT *ny,
102  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
103  PLFLT *xg, PLFLT *yg, PLINT *lx );
104 void PLIMAGEFR7( PLFLT *idata, PLINT *nx, PLINT *ny,
106  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
107  PLFLT *ftr, PLINT *lx );
108 
109 
110 
111 
112 //--------------------------------------------------------------------------
113 // pltr0f()
114 //
115 // Identity transformation for plots from Fortran.
116 // Only difference from C-language identity function (pltr0) is that the
117 // Fortran paradigm for array index is used, i.e. starting at 1.
118 //--------------------------------------------------------------------------
119 
120 void
121 pltr0f( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *PL_UNUSED( pltr_data ) )
122 {
123  *tx = x + 1.0;
124  *ty = y + 1.0;
125 }
126 
127 //--------------------------------------------------------------------------
128 // Contour plotter front-ends.
129 // These specify the row-dominant function evaluator in the plfcont
130 // argument list. NO TRANSPOSE IS NECESSARY. The routines are as follows:
131 //
132 // - plcon0 no transformation
133 // - plcon1 linear interpolation from singly dimensioned coord arrays
134 // - plcon2 linear interpolation from doubly dimensioned coord arrays
135 //
136 // The latter two work by calling plfcont() with the appropriate grid
137 // structure for input to pltr2f().
138 //--------------------------------------------------------------------------
139 
140 // no transformation
141 
142 void
143 PLCON07( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
144  PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel )
145 {
146  PLfGrid fgrid;
147 
148  fgrid.nx = *nx;
149  fgrid.ny = *ny;
150  fgrid.f = z;
151 
152  plfcont( plf2evalr, (void *) &fgrid,
153  *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
154  pltr0f, NULL );
155 }
156 
157 // 1-d transformation
158 
159 void
160 PLCON17( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
161  PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
162  PLFLT *xg, PLFLT *yg )
163 {
164  PLfGrid fgrid;
165  PLcGrid cgrid;
166 
167  fgrid.nx = *nx;
168  fgrid.ny = *ny;
169  fgrid.f = z;
170 
171  cgrid.nx = *nx;
172  cgrid.ny = *ny;
173  cgrid.xg = xg;
174  cgrid.yg = yg;
175 
176  plfcont( plf2evalr, (void *) &fgrid,
177  *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
178  pltr1, (void *) &cgrid );
179 }
180 
181 // 2-d transformation
182 
183 void
184 PLCON27( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
185  PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel,
186  PLFLT *xg, PLFLT *yg )
187 {
188  PLfGrid fgrid;
189  PLcGrid cgrid;
190 
191  fgrid.nx = *nx;
192  fgrid.ny = *ny;
193  fgrid.f = z;
194 
195  cgrid.nx = *nx;
196  cgrid.ny = *ny;
197  cgrid.xg = xg;
198  cgrid.yg = yg;
199 
200  plfcont( plf2evalr, (void *) &fgrid,
201  *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
202  pltr2f, (void *) &cgrid );
203 }
204 
205 //--------------------------------------------------------------------------
206 // Vector plotter front-ends.
207 // These specify the row-dominant function evaluator in the plfvect
208 // argument list. NO TRANSPOSE IS NECESSARY. The routines are as follows:
209 //
210 // - plvec0 no transformation
211 // - plvec1 linear interpolation from singly dimensioned coord arrays
212 // - plvec2 linear interpolation from doubly dimensioned coord arrays
213 //
214 // The latter two work by calling plfvect() with the appropriate grid
215 // structure for input to pltr2f().
216 //--------------------------------------------------------------------------
217 
218 // no transformation
219 
220 void
221 PLVEC07( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale )
222 {
223  PLfGrid fgrid1, fgrid2;
224 
225  fgrid1.nx = *nx;
226  fgrid1.ny = *ny;
227  fgrid1.f = u;
228 
229  fgrid2.nx = *nx;
230  fgrid2.ny = *ny;
231  fgrid2.f = v;
232 
233  plfvect( plf2evalr, (void *) &fgrid1, (void *) &fgrid2,
234  *nx, *ny, *scale, pltr0f, NULL );
235 }
236 
237 // 1-d transformation
238 
239 void
240 PLVEC17( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
241  PLFLT *xg, PLFLT *yg )
242 {
243  PLfGrid fgrid1;
244  PLfGrid fgrid2;
245  PLcGrid cgrid;
246 
247  fgrid1.nx = *nx;
248  fgrid1.ny = *ny;
249  fgrid1.f = u;
250 
251  fgrid2.nx = *nx;
252  fgrid2.ny = *ny;
253  fgrid2.f = v;
254 
255  cgrid.nx = *nx;
256  cgrid.ny = *ny;
257  cgrid.xg = xg;
258  cgrid.yg = yg;
259 
260  plfvect( plf2evalr, (void *) &fgrid1, (void *) &fgrid2,
261  *nx, *ny, *scale, pltr1, (void *) &cgrid );
262 }
263 
264 // 2-d transformation
265 
266 void
267 PLVEC27( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
268  PLFLT *xg, PLFLT *yg )
269 {
270  PLfGrid fgrid1;
271  PLfGrid fgrid2;
272  PLcGrid cgrid;
273 
274  fgrid1.nx = *nx;
275  fgrid1.ny = *ny;
276  fgrid1.f = u;
277 
278  fgrid2.nx = *nx;
279  fgrid2.ny = *ny;
280  fgrid2.f = v;
281 
282  cgrid.nx = *nx;
283  cgrid.ny = *ny;
284  cgrid.xg = xg;
285  cgrid.yg = yg;
286 
287  plfvect( plf2evalr, (void *) &fgrid1, (void *) &fgrid2,
288  *nx, *ny, *scale, pltr2f, (void *) &cgrid );
289 }
290 
291 //--------------------------------------------------------------------------
292 // Here are the old contour plotters.
293 //--------------------------------------------------------------------------
294 
295 static void
296 pltr( PLFLT x, PLFLT y, PLFLT *tx, PLFLT *ty, void *pltr_data )
297 {
298  PLFLT *tr = (PLFLT *) pltr_data;
299 
300  *tx = tr[0] * x + tr[1] * y + tr[2];
301  *ty = tr[3] * x + tr[4] * y + tr[5];
302 }
303 
304 void
305 PLCONT7( PLFLT *z, PLINT *nx, PLINT *ny, PLINT *kx, PLINT *lx,
306  PLINT *ky, PLINT *ly, PLFLT *clevel, PLINT *nlevel, PLFLT *ftr )
307 {
308  PLfGrid fgrid;
309 
310  fgrid.nx = *nx;
311  fgrid.ny = *ny;
312  fgrid.f = z;
313 
314  plfcont( plf2evalr, (void *) &fgrid,
315  *nx, *ny, *kx, *lx, *ky, *ly, clevel, *nlevel,
316  pltr, (void *) ftr );
317 }
318 
319 void
320 PLVECT7( PLFLT *u, PLFLT *v, PLINT *nx, PLINT *ny, PLFLT *scale,
321  PLFLT *ftr )
322 {
323  PLfGrid fgrid1;
324  PLfGrid fgrid2;
325 
326  fgrid1.nx = *nx;
327  fgrid1.ny = *ny;
328  fgrid1.f = u;
329 
330  fgrid2.nx = *nx;
331  fgrid2.ny = *ny;
332  fgrid2.f = v;
333 
334  plfvect( plf2evalr, (void *) &fgrid1, (void *) &fgrid2,
335  *nx, *ny, *scale,
336  pltr, (void *) ftr );
337 }
338 
339 //--------------------------------------------------------------------------
340 // plfshade front-ends.
341 // These specify the row-dominant function evaluator in the plfshade
342 // argument list. NO TRANSPOSE IS NECESSARY. The routines are as follows:
343 //
344 // - plshade0 map indices to xmin, xmax, ymin, ymax.
345 // The next two work by calling plfshade() with the appropriate grid
346 // structure for input to pltr2f().
347 // - plshade1 linear interpolation from singly dimensioned coord arrays
348 // - plshade2 linear interpolation from doubly dimensioned coord arrays
349 // - plshade tr array transformation
350 //
351 //--------------------------------------------------------------------------
352 
353 void
354 PLSHADE07( PLFLT *z, PLINT *nx, PLINT *ny, const char *PL_UNUSED( defined ),
356  PLFLT *shade_min, PLFLT *shade_max,
357  PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
358  PLINT *min_color, PLFLT *min_width,
359  PLINT *max_color, PLFLT *max_width, PLINT *lx )
360 {
361  PLINT rect = 1;
362  PLFLT ** a;
363  int i, j;
364 
365 // Create a vectored a array from transpose of the fortran z array.
366  plAlloc2dGrid( &a, *nx, *ny );
367  for ( i = 0; i < *nx; i++ )
368  {
369  for ( j = 0; j < *ny; j++ )
370  {
371  a[i][j] = z[i + j * *lx];
372  }
373  }
374 
375  c_plshade( (const PLFLT * const *) a, *nx, *ny, NULL,
376  *xmin, *xmax, *ymin, *ymax,
377  *shade_min, *shade_max,
378  *sh_cmap, *sh_color, *sh_width,
379  *min_color, *min_width, *max_color, *max_width,
380  c_plfill, rect, NULL, NULL );
381 
382 // Clean up memory allocated for a
383  plFree2dGrid( a, *nx, *ny );
384 }
385 
386 
387 // 1-d transformation
388 
389 void
390 PLSHADE17( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
392  PLFLT *shade_min, PLFLT *shade_max,
393  PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
394  PLINT *min_color, PLFLT *min_width,
395  PLINT *max_color, PLFLT *max_width,
396  PLFLT *xg1, PLFLT *yg1, PLINT *lx )
397 {
398  PLINT rect = 1;
399  PLFLT ** a;
400  int i, j;
401  PLcGrid cgrid;
402 
403 // Create a vectored a array from transpose of the fortran z array.
404  plAlloc2dGrid( &a, *nx, *ny );
405  for ( i = 0; i < *nx; i++ )
406  {
407  for ( j = 0; j < *ny; j++ )
408  {
409  a[i][j] = z[i + j * *lx];
410  }
411  }
412 
413  cgrid.nx = *nx;
414  cgrid.ny = *ny;
415  cgrid.xg = xg1;
416  cgrid.yg = yg1;
417  c_plshade( (const PLFLT * const *) a, *nx, *ny, NULL,
418  *xmin, *xmax, *ymin, *ymax,
419  *shade_min, *shade_max,
420  *sh_cmap, *sh_color, *sh_width,
421  *min_color, *min_width, *max_color, *max_width,
422  c_plfill, rect, pltr1, ( PLPointer ) & cgrid );
423 
424 // Clean up memory allocated for a
425  plFree2dGrid( a, *nx, *ny );
426 }
427 
428 // 2-d transformation
429 
430 void
431 PLSHADE27( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
433  PLFLT *shade_min, PLFLT *shade_max,
434  PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
435  PLINT *min_color, PLFLT *min_width,
436  PLINT *max_color, PLFLT *max_width,
437  PLFLT *xg2, PLFLT *yg2, PLINT *lx )
438 {
439  PLINT rect = 0;
440  PLFLT **a;
441  int i, j;
442  PLcGrid2 cgrid2;
443 
444 // Create a vectored a array from transpose of the fortran z array.
445  plAlloc2dGrid( &a, *nx, *ny );
446  plAlloc2dGrid( &cgrid2.xg, *nx, *ny );
447  plAlloc2dGrid( &cgrid2.yg, *nx, *ny );
448  cgrid2.nx = *nx;
449  cgrid2.ny = *ny;
450  for ( i = 0; i < *nx; i++ )
451  {
452  for ( j = 0; j < *ny; j++ )
453  {
454  a[i][j] = z[i + j * *lx];
455  cgrid2.xg[i][j] = xg2[i + j * *lx];
456  cgrid2.yg[i][j] = yg2[i + j * *lx];
457  }
458  }
459 
460  c_plshade( (const PLFLT * const *) a, *nx, *ny, NULL,
461  *xmin, *xmax, *ymin, *ymax,
462  *shade_min, *shade_max,
463  *sh_cmap, *sh_color, *sh_width,
464  *min_color, *min_width, *max_color, *max_width,
465  c_plfill, rect, pltr2, (void *) &cgrid2 );
466 
467 // Clean up memory allocated for a
468  plFree2dGrid( a, *nx, *ny );
469  plFree2dGrid( cgrid2.xg, *nx, *ny );
470  plFree2dGrid( cgrid2.yg, *nx, *ny );
471 }
472 
473 void
474 PLSHADE7( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
476  PLFLT *shade_min, PLFLT *shade_max,
477  PLINT *sh_cmap, PLFLT *sh_color, PLFLT *sh_width,
478  PLINT *min_color, PLFLT *min_width,
479  PLINT *max_color, PLFLT *max_width, PLFLT *ftr, PLINT *lx )
480 {
481  PLINT rect = 1;
482  PLFLT ** a;
483  int i, j;
484 
485 // Create a vectored a array from transpose of the fortran z array.
486  plAlloc2dGrid( &a, *nx, *ny );
487  for ( i = 0; i < *nx; i++ )
488  {
489  for ( j = 0; j < *ny; j++ )
490  {
491  a[i][j] = z[i + j * *lx];
492  }
493  }
494 
495  c_plshade( (const PLFLT * const *) a, *nx, *ny, NULL,
496  *xmin, *xmax, *ymin, *ymax,
497  *shade_min, *shade_max,
498  *sh_cmap, *sh_color, *sh_width,
499  *min_color, *min_width, *max_color, *max_width,
500  c_plfill, rect, pltr, (void *) ftr );
501 
502 // Clean up memory allocated for a
503  plFree2dGrid( a, *nx, *ny );
504 }
505 
506 //--------------------------------------------------------------------------
507 // plshades front-ends.
508 //
509 // - plshades0 map indices to xmin, xmax, ymin, ymax
510 // - plshades1 linear interpolation from singly dimensioned coord arrays
511 // - plshades2 linear interpolation from doubly dimensioned coord arrays
512 // - plshades pass tr information with plplot common block (and
513 // then pass tr as last argument of PLSHADES7)
514 //--------------------------------------------------------------------------
515 
516 void
517 PLSHADES07( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
519  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
520  PLINT *cont_color, PLFLT *cont_width, PLINT *lx, PLINT *rect )
521 {
522  PLFLT ** a;
523  int i, j;
524 
525 // Create a vectored a array from transpose of the fortran z array.
526  plAlloc2dGrid( &a, *nx, *ny );
527  for ( i = 0; i < *nx; i++ )
528  {
529  for ( j = 0; j < *ny; j++ )
530  {
531  a[i][j] = z[i + j * *lx];
532  }
533  }
534 
535  c_plshades( (const PLFLT * const *) a, *nx, *ny, NULL,
536  *xmin, *xmax, *ymin, *ymax,
537  clevel, *nlevel, *fill_width,
538  *cont_color, *cont_width,
539  c_plfill, *rect, NULL, NULL );
540 
541 // Clean up memory allocated for a
542  plFree2dGrid( a, *nx, *ny );
543 }
544 
545 void
546 PLSHADES17( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
548  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
549  PLINT *cont_color, PLFLT *cont_width,
550  PLFLT *xg1, PLFLT *yg1, PLINT *lx, PLINT *rect )
551 {
552  PLFLT ** a;
553  int i, j;
554  PLcGrid cgrid;
555 
556 // Create a vectored a array from transpose of the fortran z array.
557  plAlloc2dGrid( &a, *nx, *ny );
558  for ( i = 0; i < *nx; i++ )
559  {
560  for ( j = 0; j < *ny; j++ )
561  {
562  a[i][j] = z[i + j * *lx];
563  }
564  }
565 
566  cgrid.nx = *nx;
567  cgrid.ny = *ny;
568  cgrid.xg = xg1;
569  cgrid.yg = yg1;
570 
571  c_plshades( (const PLFLT * const *) a, *nx, *ny, NULL,
572  *xmin, *xmax, *ymin, *ymax,
573  clevel, *nlevel, *fill_width,
574  *cont_color, *cont_width,
575  c_plfill, *rect, pltr1, ( PLPointer ) & cgrid );
576 
577 // Clean up memory allocated for a
578  plFree2dGrid( a, *nx, *ny );
579 }
580 
581 void
582 PLSHADES27( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
584  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
585  PLINT *cont_color, PLFLT *cont_width,
586  PLFLT *xg2, PLFLT *yg2, PLINT *lx, PLINT *rect )
587 {
588  PLFLT **a;
589  int i, j;
590  PLcGrid2 cgrid2;
591 
592 // Create a vectored a array from transpose of the fortran z array.
593  plAlloc2dGrid( &a, *nx, *ny );
594  plAlloc2dGrid( &cgrid2.xg, *nx, *ny );
595  plAlloc2dGrid( &cgrid2.yg, *nx, *ny );
596  cgrid2.nx = *nx;
597  cgrid2.ny = *ny;
598  for ( i = 0; i < *nx; i++ )
599  {
600  for ( j = 0; j < *ny; j++ )
601  {
602  a[i][j] = z[i + j * *lx];
603  cgrid2.xg[i][j] = xg2[i + j * *lx];
604  cgrid2.yg[i][j] = yg2[i + j * *lx];
605  }
606  }
607 
608  c_plshades( (const PLFLT * const *) a, *nx, *ny, NULL,
609  *xmin, *xmax, *ymin, *ymax,
610  clevel, *nlevel, *fill_width,
611  *cont_color, *cont_width,
612  c_plfill, *rect, pltr2, (void *) &cgrid2 );
613 
614 // Clean up allocated memory
615  plFree2dGrid( a, *nx, *ny );
616  plFree2dGrid( cgrid2.xg, *nx, *ny );
617  plFree2dGrid( cgrid2.yg, *nx, *ny );
618 }
619 
620 void
621 PLSHADES7( PLFLT *z, PLINT *nx, PLINT *ny, const char * PL_UNUSED( defined ),
623  PLFLT *clevel, PLINT *nlevel, PLFLT *fill_width,
624  PLINT *cont_color, PLFLT *cont_width, PLFLT *ftr, PLINT *lx, PLINT *rect )
625 {
626  PLFLT ** a;
627  int i, j;
628 
629 // Create a vectored a array from transpose of the fortran z array.
630  plAlloc2dGrid( &a, *nx, *ny );
631  for ( i = 0; i < *nx; i++ )
632  {
633  for ( j = 0; j < *ny; j++ )
634  {
635  a[i][j] = z[i + j * *lx];
636  }
637  }
638 
639  c_plshades( (const PLFLT * const *) a, *nx, *ny, NULL,
640  *xmin, *xmax, *ymin, *ymax,
641  clevel, *nlevel, *fill_width,
642  *cont_color, *cont_width,
643  c_plfill, *rect, pltr, (void *) ftr );
644 
645 // Clean up memory allocated for a
646  plFree2dGrid( a, *nx, *ny );
647 }
648 
649 void
650 PLGRIDDATA( PLFLT *x, PLFLT *y, PLFLT *z, PLINT *npts, PLFLT *xg,
651  PLINT *nx, PLFLT *yg, PLINT *ny, PLFLT *zg, PLINT *type, PLFLT *data )
652 {
653  PLFLT ** a;
654  int i, j;
655 
656 // Create a vectored a array from transpose of the fortran z array.
657  plAlloc2dGrid( &a, *nx, *ny );
658 
659  c_plgriddata( x, y, z, *npts, xg, *nx, yg, *ny, a, *type, *data );
660 
661  for ( i = 0; i < *nx; i++ )
662  {
663  for ( j = 0; j < *ny; j++ )
664  {
665  zg[i + j * *nx] = a[i][j];
666  }
667  }
668 
669 // Clean up memory allocated for a
670  plFree2dGrid( a, *nx, *ny );
671 }
672 
673 void
674 PLIMAGEFR07( PLFLT *idata, PLINT *nx, PLINT *ny,
676  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
677  PLINT *lx )
678 {
679  int i, j;
680  PLFLT **pidata;
681 
682  plAlloc2dGrid( &pidata, *nx, *ny );
683 
684  for ( i = 0; i < *nx; i++ )
685  {
686  for ( j = 0; j < *ny; j++ )
687  {
688  pidata[i][j] = idata[i + j * ( *lx )];
689  }
690  }
691 
692  c_plimagefr( (const PLFLT * const *) pidata, *nx, *ny,
693  *xmin, *xmax, *ymin, *ymax, *zmin, *zmax,
694  *valuemin, *valuemax, pltr0, NULL );
695 
696  plFree2dGrid( pidata, *nx, *ny );
697 }
698 
699 void
700 PLIMAGEFR17( PLFLT *idata, PLINT *nx, PLINT *ny,
702  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
703  PLFLT *xg, PLFLT *yg, PLINT *lx )
704 {
705  int i, j;
706  PLFLT **pidata;
707  PLcGrid cgrid;
708 
709  plAlloc2dGrid( &pidata, *nx, *ny );
710 
711  cgrid.nx = ( *nx ) + 1;
712  cgrid.ny = ( *ny ) + 1;
713  cgrid.xg = xg;
714  cgrid.yg = yg;
715 
716  for ( i = 0; i < *nx; i++ )
717  {
718  for ( j = 0; j < *ny; j++ )
719  {
720  pidata[i][j] = idata[i + j * ( *lx )];
721  }
722  }
723 
724  c_plimagefr( (const PLFLT * const *) pidata, *nx, *ny,
725  *xmin, *xmax, *ymin, *ymax, *zmin, *zmax,
726  *valuemin, *valuemax, pltr1, (void *) &cgrid );
727 
728  plFree2dGrid( pidata, *nx, *ny );
729 }
730 
731 void
732 PLIMAGEFR27( PLFLT *idata, PLINT *nx, PLINT *ny,
734  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
735  PLFLT *xg, PLFLT *yg, PLINT *lx )
736 {
737  int i, j;
738  PLFLT **pidata;
739  PLcGrid2 cgrid2;
740 
741  plAlloc2dGrid( &pidata, *nx, *ny );
742  plAlloc2dGrid( &cgrid2.xg, ( *nx ) + 1, ( *ny ) + 1 );
743  plAlloc2dGrid( &cgrid2.yg, ( *nx ) + 1, ( *ny ) + 1 );
744 
745  cgrid2.nx = ( *nx ) + 1;
746  cgrid2.ny = ( *ny ) + 1;
747  for ( i = 0; i <= *nx; i++ )
748  {
749  for ( j = 0; j <= *ny; j++ )
750  {
751  cgrid2.xg[i][j] = xg[i + j * ( ( *lx ) + 1 )];
752  cgrid2.yg[i][j] = yg[i + j * ( ( *lx ) + 1 )];
753  }
754  }
755 
756  for ( i = 0; i < *nx; i++ )
757  {
758  for ( j = 0; j < *ny; j++ )
759  {
760  pidata[i][j] = idata[i + j * ( *lx )];
761  }
762  }
763 
764  c_plimagefr( (const PLFLT * const *) pidata, *nx, *ny,
765  *xmin, *xmax, *ymin, *ymax, *zmin, *zmax,
766  *valuemin, *valuemax, pltr2, (void *) &cgrid2 );
767 
768  plFree2dGrid( pidata, *nx, *ny );
769  plFree2dGrid( cgrid2.xg, ( *nx ) + 1, ( *ny ) + 1 );
770  plFree2dGrid( cgrid2.yg, ( *nx ) + 1, ( *ny ) + 1 );
771 }
772 
773 void
774 PLIMAGEFR7( PLFLT *idata, PLINT *nx, PLINT *ny,
776  PLFLT *zmin, PLFLT *zmax, PLFLT *valuemin, PLFLT *valuemax,
777  PLFLT *ftr, PLINT *lx )
778 {
779  int i, j;
780  PLFLT **pidata;
781 
782  plAlloc2dGrid( &pidata, *nx, *ny );
783 
784  for ( i = 0; i < *nx; i++ )
785  {
786  for ( j = 0; j < *ny; j++ )
787  {
788  pidata[i][j] = idata[i + j * ( *lx )];
789  }
790  }
791 
792  c_plimagefr( (const PLFLT * const *) pidata, *nx, *ny,
793  *xmin, *xmax, *ymin, *ymax, *zmin, *zmax,
794  *valuemin, *valuemax, pltr, (void *) ftr );
795 
796  plFree2dGrid( pidata, *nx, *ny );
797 }