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