Line data Source code
1 : /*****************************************************************************
2 : * $Id$
3 : *
4 : * This module has a number of additions and improvements over the original
5 : * implementation to be suitable for usage in GDAL HDF driver.
6 : *
7 : * Andrey Kiselev <dron@ak4719.spb.edu> is responsible for all the changes.
8 : ****************************************************************************/
9 :
10 : /*
11 : Copyright (C) 1996 Hughes and Applied Research Corporation
12 :
13 : Permission to use, modify, and distribute this software and its documentation
14 : for any purpose without fee is hereby granted, provided that the above
15 : copyright notice appear in all copies and that both that copyright notice and
16 : this permission notice appear in supporting documentation.
17 : */
18 : /*****************************************************************************
19 : REVISIONS:
20 :
21 : Aug 31, 1999 Abe Taaheri Changed memory allocation for utility strings to
22 : the size of UTLSTR_MAX_SIZE.
23 : Added error check for memory unavailability in
24 : several functions.
25 : Added check for NULL metabuf returned from
26 : EHmeta... functions. NULL pointer returned from
27 : EHmeta... functions indicate that memory could not
28 : be allocated for metabuf.
29 : Jun 27, 2000 Abe Taaheri Added support for EASE grid that uses
30 : Behrmann Cylinderical Equal Area (BCEA) projection
31 : Oct 23, 2000 Abe Taaheri Updated for ISINUS projection, so that both codes
32 : 31 and 99 can be used for this projection.
33 : Jan 15, 2003 Abe Taaheri Modified for generalization of EASE Grid.
34 :
35 : Jun 05, 2003 Bruce Beaumont / Abe Taaheri
36 :
37 : Fixed SQUARE definition.
38 : Added static projection number/name translation
39 : Added projection table lookup in GDdefproj.
40 : Removed projection table from GDdefproj
41 : Added projection table lookup in GDprojinfo
42 : Removed projection table from GDprojinfo
43 : Added cast for compcode in call to SDsetcompress
44 : in GDdeffield to avoid compiler errors
45 : Removed declaration for unused variable endptr
46 : in GDSDfldsrch
47 : Removed initialization code for unused variables
48 : in GDSDfldsrch
49 : Removed declarations for unused variables
50 : BCEA_scale, r0, s0, xMtr0, xMtr1, yMtr0,
51 : and yMtr1 in GDll2ij
52 : Removed initialization code for unused variables
53 : in GDll2ij
54 : Added code in GEO projection handling to allow
55 : map to span dateline in GDll2ij
56 : Changed "for each point" loop in GDll2ij to
57 : return -2147483648.0 for xVal and yVal if
58 : for_trans returned an error instead of
59 : returning an error to the caller
60 : (Note: MAXLONG is defined as 2147483647.0 in
61 : function cproj.c of GCTP)
62 : Added code in GDij2ll to use for_trans to
63 : translate the BCEA corner points from packed
64 : degrees to meters
65 : Removed declarations for unused variables
66 : BCEA_scale, r0, s0, xMtr, yMtr, epsilon,
67 : beta, qp_cea, kz_cea, eccen, eccen_sq,
68 : phi1, sinphi1, cosphi1, lon, lat, xcor,
69 : ycor, and nlatlon from GDij2ll
70 : Removed initialization code for unused variables
71 : in GDij2ll
72 : Added declarations for xMtr0, yMtr0, xMtr1, and
73 : yMtr1 in GDij2ll
74 : Added special-case code for BCEA
75 : Changed "for each point" loop in GDij2ll to
76 : return PGSd_GCT_IN_ERROR (1.0e51) for
77 : longitude and latitude values if inv_trans
78 : returned an error instead of return an error
79 : to the caller
80 : Removed declaration for unused variable ii in
81 : GDgetpixvalues
82 : Removed declaration for unused variable
83 : numTileDims in GDtileinfo
84 : Added error message and error return at the
85 : end of GDll2mm_cea
86 : Added return statement to GDll2mm_cea
87 : ******************************************************************************/
88 : #include "cpl_string.h"
89 : #include "stdio.h"
90 : #include "mfhdf.h"
91 : #include "hcomp.h"
92 : #include <math.h>
93 : #include "HdfEosDef.h"
94 :
95 : #include "hdf4compat.h"
96 :
97 : extern void for_init(int32, int32, float64 *, int32, const char *, const char *, int32 *,
98 : int32 (*for_trans[])(double, double, double*, double*));
99 : extern void inv_init(int32, int32, float64 *, int32, const char *, const char *, int32 *,
100 : int32 (*inv_trans[])(double, double, double*, double*));
101 :
102 : #define GDIDOFFSET 4194304
103 : #define SQUARE(x) ((x) * (x)) /* x**2 */
104 :
105 : static int32 GDXSDcomb[512*5];
106 : static char GDXSDname[HDFE_NAMBUFSIZE];
107 : static char GDXSDdims[HDFE_DIMBUFSIZE];
108 :
109 :
110 : #define NGRID 200
111 : /* Grid Structure External Arrays */
112 : struct gridStructure
113 : {
114 : int32 active;
115 : int32 IDTable;
116 : int32 VIDTable[2];
117 : int32 fid;
118 : int32 nSDS;
119 : int32 *sdsID;
120 : int32 compcode;
121 : intn compparm[5];
122 : int32 tilecode;
123 : int32 tilerank;
124 : int32 tiledims[8];
125 : };
126 : static struct gridStructure GDXGrid[NGRID];
127 :
128 :
129 :
130 : #define NGRIDREGN 256
131 : struct gridRegion
132 : {
133 : int32 fid;
134 : int32 gridID;
135 : int32 xStart;
136 : int32 xCount;
137 : int32 yStart;
138 : int32 yCount;
139 : int32 somStart;
140 : int32 somCount;
141 : float64 upleftpt[2];
142 : float64 lowrightpt[2];
143 : int32 StartVertical[8];
144 : int32 StopVertical[8];
145 : char *DimNamePtr[8];
146 : };
147 : static struct gridRegion *GDXRegion[NGRIDREGN];
148 :
149 : /* define a macro for the string size of the utility strings and some dimension
150 : list strings. The value of 80 in the previous version of this code
151 : may not be enough in some cases. The length now is 512 which seems to
152 : be more than enough to hold larger strings. */
153 :
154 : #define UTLSTR_MAX_SIZE 512
155 :
156 : /* Static projection table */
157 : static const struct {
158 : int32 projcode;
159 : const char *projname;
160 : } Projections[] = {
161 : {GCTP_GEO, "GCTP_GEO"},
162 : {GCTP_UTM, "GCTP_UTM"},
163 : {GCTP_SPCS, "GCTP_SPCS"},
164 : {GCTP_ALBERS, "GCTP_ALBERS"},
165 : {GCTP_LAMCC, "GCTP_LAMCC"},
166 : {GCTP_MERCAT, "GCTP_MERCAT"},
167 : {GCTP_PS, "GCTP_PS"},
168 : {GCTP_POLYC, "GCTP_POLYC"},
169 : {GCTP_EQUIDC, "GCTP_EQUIDC"},
170 : {GCTP_TM, "GCTP_TM"},
171 : {GCTP_STEREO, "GCTP_STEREO"},
172 : {GCTP_LAMAZ, "GCTP_LAMAZ"},
173 : {GCTP_AZMEQD, "GCTP_AZMEQD"},
174 : {GCTP_GNOMON, "GCTP_GNOMON"},
175 : {GCTP_ORTHO, "GCTP_ORTHO"},
176 : {GCTP_GVNSP, "GCTP_GVNSP"},
177 : {GCTP_SNSOID, "GCTP_SNSOID"},
178 : {GCTP_EQRECT, "GCTP_EQRECT"},
179 : {GCTP_MILLER, "GCTP_MILLER"},
180 : {GCTP_VGRINT, "GCTP_VGRINT"},
181 : {GCTP_HOM, "GCTP_HOM"},
182 : {GCTP_ROBIN, "GCTP_ROBIN"},
183 : {GCTP_SOM, "GCTP_SOM"},
184 : {GCTP_ALASKA, "GCTP_ALASKA"},
185 : {GCTP_GOOD, "GCTP_GOOD"},
186 : {GCTP_MOLL, "GCTP_MOLL"},
187 : {GCTP_IMOLL, "GCTP_IMOLL"},
188 : {GCTP_HAMMER, "GCTP_HAMMER"},
189 : {GCTP_WAGIV, "GCTP_WAGIV"},
190 : {GCTP_WAGVII, "GCTP_WAGVII"},
191 : {GCTP_OBLEQA, "GCTP_OBLEQA"},
192 : {GCTP_ISINUS1, "GCTP_ISINUS1"},
193 : {GCTP_CEA, "GCTP_CEA"},
194 : {GCTP_BCEA, "GCTP_BCEA"},
195 : {GCTP_ISINUS, "GCTP_ISINUS"},
196 : {-1, NULL}
197 : };
198 :
199 : /* Compression Codes */
200 : static const char * const HDFcomp[] = {
201 : "HDFE_COMP_NONE",
202 : "HDFE_COMP_RLE",
203 : "HDFE_COMP_NBIT",
204 : "HDFE_COMP_SKPHUFF",
205 : "HDFE_COMP_DEFLATE"
206 : };
207 :
208 : /* Origin Codes */
209 : static const char * const originNames[] = {
210 : "HDFE_GD_UL",
211 : "HDFE_GD_UR",
212 : "HDFE_GD_LL",
213 : "HDFE_GD_LR"
214 : };
215 :
216 : /* Pixel Registration Codes */
217 : static const char * const pixregNames[] = {
218 : "HDFE_CENTER",
219 : "HDFE_CORNER"
220 : };
221 :
222 : /* Grid Function Prototypes (internal routines) */
223 : static intn GDchkgdid(int32, const char *, int32 *, int32 *, int32 *);
224 : static intn GDSDfldsrch(int32, int32, const char *, int32 *, int32 *,
225 : int32 *, int32 *, int32 [], int32 *);
226 : static intn GDwrrdfield(int32, const char *, const char *,
227 : int32 [], int32 [], int32 [], VOIDP datbuf);
228 : static intn GDwrrdattr(int32, const char *, int32, int32, const char *, VOIDP);
229 : static intn GDll2ij(int32, int32, float64 [], int32, int32, int32, float64[],
230 : float64[], int32, float64[], float64[], int32[], int32[],
231 : float64[], float64[]);
232 : static intn GDgetdefaults(int32, int32, float64[], int32,
233 : float64[], float64[]);
234 : static intn GDtangentpnts(int32, float64[], float64[], float64[], float64[],
235 : float64 [], int32 *);
236 : static intn GDwrrdtile(int32, const char *, const char *, int32 [], VOIDP);
237 : static intn GDll2mm_cea(int32,int32, int32, float64[], int32, int32,
238 : float64[], float64[], int32, float64[],float64[],
239 : float64[], float64[], float64 *, float64 *);
240 :
241 : static intn GDmm2ll_cea(int32, int32, int32, float64[], int32, int32,
242 : float64[], float64[], int32, float64[], float64[],
243 : float64[], float64[]);
244 :
245 : /*----------------------------------------------------------------------------|
246 : | BEGIN_PROLOG |
247 : | |
248 : | FUNCTION: GDopen |
249 : | |
250 : | DESCRIPTION: Opens or creates HDF file in order to create, read, or write |
251 : | a grid. |
252 : | |
253 : | |
254 : | Return Value Type Units Description |
255 : | ============ ====== ========= ===================================== |
256 : | fid int32 HDF-EOS file ID |
257 : | |
258 : | INPUTS: |
259 : | filename char Filename |
260 : | l_access intn HDF l_access code |
261 : | |
262 : | |
263 : | OUTPUTS: |
264 : | None |
265 : | |
266 : | NOTES: |
267 : | |
268 : | |
269 : | Date Programmer Description |
270 : | ====== ============ ================================================= |
271 : | Jun 96 Joel Gales Original Programmer |
272 : | |
273 : | END_PROLOG |
274 : -----------------------------------------------------------------------------*/
275 : int32
276 4 : GDopen(const char *filename, intn l_access)
277 :
278 : {
279 : int32 fid /* HDF-EOS file ID */ ;
280 :
281 : /* Call EHopen to perform file l_access */
282 : /* ---------------------------------- */
283 4 : fid = EHopen(filename, l_access);
284 :
285 4 : return (fid);
286 :
287 : }
288 :
289 :
290 :
291 : /*----------------------------------------------------------------------------|
292 : | BEGIN_PROLOG |
293 : | |
294 : | FUNCTION: GDcreate |
295 : | |
296 : | DESCRIPTION: Creates a grid within the file. |
297 : | |
298 : | |
299 : | Return Value Type Units Description |
300 : | ============ ====== ========= ===================================== |
301 : | gridID int32 Grid structure ID |
302 : | |
303 : | INPUTS: |
304 : | fid int32 File ID |
305 : | gridname char Grid structure name |
306 : | xdimsize int32 Number of columns in grid |
307 : | ydimsize int32 Number of rows in grid |
308 : | upleftpt float64 Location (m/deg) of upper left corner |
309 : | lowrightpt float64 Location (m/deg) of lower right corner |
310 : | |
311 : | |
312 : | OUTPUTS: |
313 : | None |
314 : | |
315 : | NOTES: |
316 : | |
317 : | |
318 : | Date Programmer Description |
319 : | ====== ============ ================================================= |
320 : | Jun 96 Joel Gales Original Programmer |
321 : | Aug 96 Joel Gales Make metadata ODL compliant |
322 : | Aug 96 Joel Gales Check grid name for ODL compliance |
323 : | |
324 : | END_PROLOG |
325 : -----------------------------------------------------------------------------*/
326 : int32
327 0 : GDcreate(int32 fid, const char *gridname, int32 xdimsize, int32 ydimsize,
328 : float64 upleftpt[], float64 lowrightpt[])
329 : {
330 : intn i; /* Loop index */
331 0 : intn ngridopen = 0; /* # of grid structures open */
332 0 : intn status = 0; /* routine return status variable */
333 :
334 : uint8 l_access; /* Read/Write file l_access code */
335 :
336 : int32 HDFfid; /* HDF file id */
337 : int32 vgRef; /* Vgroup reference number */
338 : int32 vgid[3]; /* Vgroup ID array */
339 0 : int32 gridID = -1;/* HDF-EOS grid ID */
340 :
341 : int32 sdInterfaceID; /* HDF SDS interface ID */
342 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
343 0 : int32 nGrid = 0; /* Grid counter */
344 :
345 : char name[80]; /* Vgroup name */
346 : char class[80]; /* Vgroup class */
347 : char errbuf[256];/* Buffer for error message */
348 : char utlbuf[1024]; /* Utility buffer */
349 : char header[128];/* Structural metadata header string */
350 : char footer[256];/* Structural metadata footer string */
351 : char refstr1[128]; /* Upper left ref string (metadata) */
352 : char refstr2[128]; /* Lower right ref string (metadata) */
353 :
354 :
355 : /*
356 : * Check HDF-EOS file ID, get back HDF file ID, SD interface ID and
357 : * l_access code
358 : */
359 0 : status = EHchkfid(fid, gridname, &HDFfid, &sdInterfaceID, &l_access);
360 :
361 :
362 : /* Check gridname for length */
363 : /* ------------------------- */
364 0 : if ((intn) strlen(gridname) > VGNAMELENMAX)
365 : {
366 0 : status = -1;
367 0 : HEpush(DFE_GENAPP, "GDcreate", __FILE__, __LINE__);
368 0 : HEreport("Gridname \"%s\" must be less than %d characters.\n",
369 : gridname, VGNAMELENMAX);
370 : }
371 :
372 :
373 :
374 0 : if (status == 0)
375 : {
376 : /* Determine number of grids currently opened */
377 : /* ------------------------------------------- */
378 0 : for (i = 0; i < NGRID; i++)
379 : {
380 0 : ngridopen += GDXGrid[i].active;
381 : }
382 :
383 :
384 : /* Setup file interface */
385 : /* -------------------- */
386 0 : if (ngridopen < NGRID)
387 : {
388 :
389 : /* Check that grid has not been previously opened */
390 : /* ----------------------------------------------- */
391 0 : vgRef = -1;
392 :
393 : while (1)
394 : {
395 0 : vgRef = Vgetid(HDFfid, vgRef);
396 :
397 : /* If no more Vgroups then exist while loop */
398 : /* ---------------------------------------- */
399 0 : if (vgRef == -1)
400 : {
401 0 : break;
402 : }
403 :
404 : /* Get name and class of Vgroup */
405 : /* ---------------------------- */
406 0 : vgid[0] = Vattach(HDFfid, vgRef, "r");
407 0 : Vgetname(vgid[0], name);
408 0 : Vgetclass(vgid[0], class);
409 0 : Vdetach(vgid[0]);
410 :
411 :
412 : /* If GRID then increment # grid counter */
413 : /* ------------------------------------- */
414 0 : if (strcmp(class, "GRID") == 0)
415 : {
416 0 : nGrid++;
417 : }
418 :
419 :
420 : /* If grid already exist, return error */
421 : /* ------------------------------------ */
422 0 : if (strcmp(name, gridname) == 0 &&
423 0 : strcmp(class, "GRID") == 0)
424 : {
425 0 : status = -1;
426 0 : HEpush(DFE_GENAPP, "GDcreate", __FILE__, __LINE__);
427 0 : HEreport("\"%s\" already exists.\n", gridname);
428 0 : break;
429 : }
430 : }
431 :
432 :
433 0 : if (status == 0)
434 : {
435 : /* Create Root Vgroup for Grid */
436 : /* ---------------------------- */
437 0 : vgid[0] = Vattach(HDFfid, -1, "w");
438 :
439 :
440 : /* Set Name and Class (GRID) */
441 : /* -------------------------- */
442 0 : Vsetname(vgid[0], gridname);
443 0 : Vsetclass(vgid[0], "GRID");
444 :
445 :
446 :
447 : /* Create Data Fields Vgroup */
448 : /* ------------------------- */
449 0 : vgid[1] = Vattach(HDFfid, -1, "w");
450 0 : Vsetname(vgid[1], "Data Fields");
451 0 : Vsetclass(vgid[1], "GRID Vgroup");
452 0 : Vinsert(vgid[0], vgid[1]);
453 :
454 :
455 :
456 : /* Create Attributes Vgroup */
457 : /* ------------------------ */
458 0 : vgid[2] = Vattach(HDFfid, -1, "w");
459 0 : Vsetname(vgid[2], "Grid Attributes");
460 0 : Vsetclass(vgid[2], "GRID Vgroup");
461 0 : Vinsert(vgid[0], vgid[2]);
462 :
463 :
464 :
465 : /* Establish Grid in Structural MetaData Block */
466 : /* -------------------------------------------- */
467 0 : snprintf(header, sizeof(header), "%s%d%s%s%s%s%d%s%s%d%s",
468 : "\tGROUP=GRID_", (int)(nGrid + 1),
469 : "\n\t\tGridName=\"", gridname, "\"\n",
470 : "\t\tXDim=", (int)xdimsize, "\n",
471 : "\t\tYDim=", (int)ydimsize, "\n");
472 :
473 :
474 0 : snprintf(footer, sizeof(footer),
475 : "%s%s%s%s%s%s%s%d%s",
476 : "\t\tGROUP=Dimension\n",
477 : "\t\tEND_GROUP=Dimension\n",
478 : "\t\tGROUP=DataField\n",
479 : "\t\tEND_GROUP=DataField\n",
480 : "\t\tGROUP=MergedFields\n",
481 : "\t\tEND_GROUP=MergedFields\n",
482 : "\tEND_GROUP=GRID_", (int)(nGrid + 1), "\n");
483 :
484 :
485 :
486 : /* Build Ref point Col-Row strings */
487 : /* ------------------------------- */
488 0 : if (upleftpt == NULL ||
489 0 : (upleftpt[0] == 0 && upleftpt[1] == 0 &&
490 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0))
491 : {
492 0 : strcpy(refstr1, "DEFAULT");
493 0 : strcpy(refstr2, "DEFAULT");
494 : }
495 : else
496 : {
497 0 : CPLsnprintf(refstr1, sizeof(refstr1), "%s%f%s%f%s",
498 0 : "(", upleftpt[0], ",", upleftpt[1], ")");
499 :
500 0 : CPLsnprintf(refstr2, sizeof(refstr2), "%s%f%s%f%s",
501 0 : "(", lowrightpt[0], ",", lowrightpt[1], ")");
502 : }
503 :
504 0 : snprintf(utlbuf, sizeof(utlbuf),
505 : "%s%s%s%s%s%s%s%s",
506 : header,
507 : "\t\tUpperLeftPointMtrs=", refstr1, "\n",
508 : "\t\tLowerRightMtrs=", refstr2, "\n",
509 : footer);
510 :
511 0 : status = EHinsertmeta(sdInterfaceID, "", "g", 1002L,
512 : utlbuf, NULL);
513 :
514 : }
515 : }
516 : else
517 : {
518 : /* Too many files opened */
519 : /* --------------------- */
520 0 : status = -1;
521 0 : strcpy(errbuf,
522 : "No more than %d grids may be open simultaneously");
523 0 : strcat(errbuf, " (%s)");
524 0 : HEpush(DFE_DENIED, "GDcreate", __FILE__, __LINE__);
525 0 : HEreport(errbuf, NGRID, gridname);
526 : }
527 :
528 :
529 : /* Assign gridID # & Load grid and GDXGrid.fid table entries */
530 : /* --------------------------------------------------------- */
531 0 : if (status == 0)
532 : {
533 :
534 0 : for (i = 0; i < NGRID; i++)
535 : {
536 0 : if (GDXGrid[i].active == 0)
537 : {
538 0 : gridID = i + idOffset;
539 0 : GDXGrid[i].active = 1;
540 0 : GDXGrid[i].IDTable = vgid[0];
541 0 : GDXGrid[i].VIDTable[0] = vgid[1];
542 0 : GDXGrid[i].VIDTable[1] = vgid[2];
543 0 : GDXGrid[i].fid = fid;
544 0 : status = 0;
545 0 : break;
546 : }
547 : }
548 :
549 : }
550 : }
551 0 : return (gridID);
552 : }
553 :
554 :
555 :
556 : /*----------------------------------------------------------------------------|
557 : | BEGIN_PROLOG |
558 : | |
559 : | FUNCTION: GDattach |
560 : | |
561 : | DESCRIPTION: Attaches to an existing grid within the file. |
562 : | |
563 : | |
564 : | Return Value Type Units Description |
565 : | ============ ====== ========= ===================================== |
566 : | gridID int32 grid structure ID |
567 : | |
568 : | INPUTS: |
569 : | fid int32 HDF-EOS file id |
570 : | gridname char grid structure name |
571 : | |
572 : | |
573 : | OUTPUTS: |
574 : | None |
575 : | |
576 : | NOTES: |
577 : | |
578 : | |
579 : | Date Programmer Description |
580 : | ====== ============ ================================================= |
581 : | Jun 96 Joel Gales Original Programmer |
582 : | Sep 99 Abe Taaheri Modified test for memory allocation check when no |
583 : | SDSs are in the grid, NCR24147 |
584 : | |
585 : | END_PROLOG |
586 : -----------------------------------------------------------------------------*/
587 : int32
588 0 : GDattach(int32 fid, const char *gridname)
589 :
590 : {
591 : intn i; /* Loop index */
592 : intn j; /* Loop index */
593 0 : intn ngridopen = 0; /* # of grid structures open */
594 : intn status; /* routine return status variable */
595 :
596 : uint8 acs; /* Read/Write file l_access code */
597 :
598 : int32 HDFfid; /* HDF file id */
599 : int32 vgRef; /* Vgroup reference number */
600 : int32 vgid[3]; /* Vgroup ID array */
601 0 : int32 gridID = -1;/* HDF-EOS grid ID */
602 : int32 *tags; /* Pnt to Vgroup object tags array */
603 : int32 *refs; /* Pnt to Vgroup object refs array */
604 : int32 dum; /* dummy variable */
605 : int32 sdInterfaceID; /* HDF SDS interface ID */
606 : int32 nObjects; /* # of objects in Vgroup */
607 : int32 nSDS; /* SDS counter */
608 : int32 l_index; /* SDS l_index */
609 : int32 sdid; /* SDS object ID */
610 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
611 :
612 : char name[80]; /* Vgroup name */
613 : char class[80]; /* Vgroup class */
614 : char errbuf[256];/* Buffer for error message */
615 : char acsCode[1]; /* Read/Write l_access char: "r/w" */
616 :
617 :
618 : /* Check HDF-EOS file ID, get back HDF file ID and l_access code */
619 : /* ----------------------------------------------------------- */
620 0 : status = EHchkfid(fid, gridname, &HDFfid, &dum, &acs);
621 :
622 :
623 0 : if (status == 0)
624 : {
625 : /* Convert numeric l_access code to character */
626 : /* ---------------------------------------- */
627 :
628 0 : acsCode[0] = (acs == 1) ? 'w' : 'r';
629 :
630 : /* Determine number of grids currently opened */
631 : /* ------------------------------------------- */
632 0 : for (i = 0; i < NGRID; i++)
633 : {
634 0 : ngridopen += GDXGrid[i].active;
635 : }
636 :
637 :
638 : /* If room for more ... */
639 : /* -------------------- */
640 0 : if (ngridopen < NGRID)
641 : {
642 :
643 : /* Search Vgroups for Grid */
644 : /* ------------------------ */
645 0 : vgRef = -1;
646 :
647 : while (1)
648 : {
649 0 : vgRef = Vgetid(HDFfid, vgRef);
650 :
651 : /* If no more Vgroups then exist while loop */
652 : /* ---------------------------------------- */
653 0 : if (vgRef == -1)
654 : {
655 0 : break;
656 : }
657 :
658 : /* Get name and class of Vgroup */
659 : /* ---------------------------- */
660 0 : vgid[0] = Vattach(HDFfid, vgRef, "r");
661 0 : Vgetname(vgid[0], name);
662 0 : Vgetclass(vgid[0], class);
663 :
664 :
665 : /*
666 : * If Vgroup with gridname and class GRID found, load tables
667 : */
668 :
669 0 : if (strcmp(name, gridname) == 0 &&
670 0 : strcmp(class, "GRID") == 0)
671 : {
672 : /* Attach to "Data Fields" and "Grid Attributes" Vgroups */
673 : /* ----------------------------------------------------- */
674 0 : tags = (int32 *) malloc(sizeof(int32) * 2);
675 0 : if(tags == NULL)
676 : {
677 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
678 0 : return(-1);
679 : }
680 0 : refs = (int32 *) malloc(sizeof(int32) * 2);
681 0 : if(refs == NULL)
682 : {
683 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
684 0 : free(tags);
685 0 : return(-1);
686 : }
687 0 : Vgettagrefs(vgid[0], tags, refs, 2);
688 0 : vgid[1] = Vattach(HDFfid, refs[0], acsCode);
689 0 : vgid[2] = Vattach(HDFfid, refs[1], acsCode);
690 0 : free(tags);
691 0 : free(refs);
692 :
693 :
694 : /* Setup External Arrays */
695 : /* --------------------- */
696 0 : for (i = 0; i < NGRID; i++)
697 : {
698 : /* Find empty entry in array */
699 : /* ------------------------- */
700 0 : if (GDXGrid[i].active == 0)
701 : {
702 : /*
703 : * Set gridID, Set grid entry active, Store root
704 : * Vgroup ID, Store sub Vgroup IDs, Store HDF-EOS
705 : * file ID
706 : */
707 0 : gridID = i + idOffset;
708 0 : GDXGrid[i].active = 1;
709 0 : GDXGrid[i].IDTable = vgid[0];
710 0 : GDXGrid[i].VIDTable[0] = vgid[1];
711 0 : GDXGrid[i].VIDTable[1] = vgid[2];
712 0 : GDXGrid[i].fid = fid;
713 0 : break;
714 : }
715 : }
716 :
717 : /* Get SDS interface ID */
718 : /* -------------------- */
719 0 : status = GDchkgdid(gridID, "GDattach", &dum,
720 : &sdInterfaceID, &dum);
721 :
722 :
723 : /* Get # of entries within Data Vgroup & search for SDS */
724 : /* ---------------------------------------------------- */
725 0 : nObjects = Vntagrefs(vgid[1]);
726 :
727 0 : if (nObjects > 0)
728 : {
729 : /* Get tag and ref # for Data Vgroup objects */
730 : /* ----------------------------------------- */
731 0 : tags = (int32 *) malloc(sizeof(int32) * nObjects);
732 0 : if(tags == NULL)
733 : {
734 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
735 0 : return(-1);
736 : }
737 0 : refs = (int32 *) malloc(sizeof(int32) * nObjects);
738 0 : if(refs == NULL)
739 : {
740 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
741 0 : free(tags);
742 0 : return(-1);
743 : }
744 0 : Vgettagrefs(vgid[1], tags, refs, nObjects);
745 :
746 : /* Count number of SDS & allocate SDS ID array */
747 : /* ------------------------------------------- */
748 0 : nSDS = 0;
749 0 : for (j = 0; j < nObjects; j++)
750 : {
751 0 : if (tags[j] == DFTAG_NDG)
752 : {
753 0 : nSDS++;
754 : }
755 : }
756 0 : GDXGrid[i].sdsID = (int32 *) calloc(nSDS, 4);
757 0 : if(GDXGrid[i].sdsID == NULL && nSDS != 0)
758 : {
759 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
760 0 : free(tags);
761 0 : free(refs);
762 0 : return(-1);
763 : }
764 0 : nSDS = 0;
765 :
766 :
767 :
768 : /* Fill SDS ID array */
769 : /* ----------------- */
770 0 : for (j = 0; j < nObjects; j++)
771 : {
772 : /* If object is SDS then get id */
773 : /* ---------------------------- */
774 0 : if (tags[j] == DFTAG_NDG)
775 : {
776 0 : l_index = SDreftoindex(sdInterfaceID, refs[j]);
777 0 : sdid = SDselect(sdInterfaceID, l_index);
778 0 : GDXGrid[i].sdsID[nSDS] = sdid;
779 0 : nSDS++;
780 0 : GDXGrid[i].nSDS++;
781 : }
782 : }
783 0 : free(tags);
784 0 : free(refs);
785 : }
786 0 : break;
787 : }
788 :
789 : /* Detach Vgroup if not desired Grid */
790 : /* --------------------------------- */
791 0 : Vdetach(vgid[0]);
792 : }
793 :
794 : /* If Grid not found then set up error message */
795 : /* ------------------------------------------- */
796 0 : if (gridID == -1)
797 : {
798 0 : HEpush(DFE_RANGE, "GDattach", __FILE__, __LINE__);
799 0 : HEreport("Grid: \"%s\" does not exist within HDF file.\n",
800 : gridname);
801 : }
802 : }
803 : else
804 : {
805 : /* Too many files opened */
806 : /* --------------------- */
807 0 : gridID = -1;
808 0 : strcpy(errbuf,
809 : "No more than %d grids may be open simultaneously");
810 0 : strcat(errbuf, " (%s)");
811 0 : HEpush(DFE_DENIED, "GDattach", __FILE__, __LINE__);
812 0 : HEreport(errbuf, NGRID, gridname);
813 : }
814 :
815 : }
816 0 : return (gridID);
817 : }
818 :
819 :
820 : /*----------------------------------------------------------------------------|
821 : | BEGIN_PROLOG |
822 : | |
823 : | FUNCTION: GDchkgdid |
824 : | |
825 : | DESCRIPTION: |
826 : | |
827 : | |
828 : | Return Value Type Units Description |
829 : | ============ ====== ========= ===================================== |
830 : | status intn return status (0) SUCCEED, (-1) FAIL |
831 : | |
832 : | INPUTS: |
833 : | gridID int32 grid structure ID |
834 : | routname char Name of routine calling GDchkgdid |
835 : | |
836 : | OUTPUTS: |
837 : | fid int32 File ID |
838 : | sdInterfaceID int32 SDS interface ID |
839 : | gdVgrpID int32 grid Vgroup ID |
840 : | |
841 : | |
842 : | OUTPUTS: |
843 : | None |
844 : | |
845 : | NOTES: |
846 : | |
847 : | |
848 : | Date Programmer Description |
849 : | ====== ============ ================================================= |
850 : | Jun 96 Joel Gales Original Programmer |
851 : | |
852 : | END_PROLOG |
853 : -----------------------------------------------------------------------------*/
854 : static intn
855 0 : GDchkgdid(int32 gridID, const char *routname,
856 : int32 * fid, int32 * sdInterfaceID, int32 * gdVgrpID)
857 : {
858 0 : intn status = 0; /* routine return status variable */
859 : uint8 l_access; /* Read/Write l_access code */
860 : int32 gID; /* Grid ID - offset */
861 :
862 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
863 :
864 : static const char message1[] =
865 : "Invalid grid id: %d in routine \"%s\". ID must be >= %d and < %d.\n";
866 : static const char message2[] =
867 : "Grid id %d in routine \"%s\" not active.\n";
868 :
869 :
870 :
871 : /* Check for valid grid id */
872 :
873 0 : if (gridID < idOffset || gridID >= NGRID + idOffset)
874 : {
875 0 : status = -1;
876 0 : HEpush(DFE_RANGE, "GDchkgdid", __FILE__, __LINE__);
877 0 : HEreport(message1, gridID, routname, idOffset, NGRID + idOffset);
878 : }
879 : else
880 : {
881 :
882 : /* Compute "reduced" ID */
883 : /* -------------------- */
884 0 : gID = gridID % idOffset;
885 :
886 :
887 : /* Check for active grid ID */
888 : /* ------------------------ */
889 0 : if (GDXGrid[gID].active == 0)
890 : {
891 0 : status = -1;
892 0 : HEpush(DFE_GENAPP, "GDchkgdid", __FILE__, __LINE__);
893 0 : HEreport(message2, gridID, routname);
894 : }
895 : else
896 : {
897 :
898 : /* Get file & SDS ids and Grid key */
899 : /* -------------------------------- */
900 0 : status = EHchkfid(GDXGrid[gID].fid, " ",
901 : fid, sdInterfaceID, &l_access);
902 0 : *gdVgrpID = GDXGrid[gID].IDTable;
903 : }
904 : }
905 0 : return (status);
906 :
907 : }
908 :
909 :
910 : /*----------------------------------------------------------------------------|
911 : | BEGIN_PROLOG |
912 : | |
913 : | FUNCTION: GDdefdim |
914 : | |
915 : | DESCRIPTION: Defines a new dimension within the grid. |
916 : | |
917 : | |
918 : | Return Value Type Units Description |
919 : | ============ ====== ========= ===================================== |
920 : | status intn return status (0) SUCCEED, (-1) FAIL |
921 : | |
922 : | INPUTS: |
923 : | gridID int32 grid structure ID |
924 : | dimname char Dimension name to define |
925 : | dim int32 Dimension value |
926 : | |
927 : | |
928 : | OUTPUTS: |
929 : | None |
930 : | |
931 : | NOTES: |
932 : | |
933 : | |
934 : | Date Programmer Description |
935 : | ====== ============ ================================================= |
936 : | Jun 96 Joel Gales Original Programmer |
937 : | |
938 : | END_PROLOG |
939 : -----------------------------------------------------------------------------*/
940 : intn
941 0 : GDdefdim(int32 gridID, const char *dimname, int32 dim)
942 :
943 : {
944 : intn status; /* routine return status variable */
945 :
946 : int32 fid; /* HDF-EOS file id */
947 : int32 sdInterfaceID; /* HDF SDS interface ID */
948 : int32 gdVgrpID; /* Grid root Vgroup ID */
949 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
950 :
951 : char gridname[80] /* Grid name */ ;
952 :
953 :
954 : /* Check for valid grid id */
955 0 : status = GDchkgdid(gridID, "GDdefinedim",
956 : &fid, &sdInterfaceID, &gdVgrpID);
957 :
958 :
959 : /* Make sure dimension >= 0 */
960 : /* ------------------------ */
961 0 : if (dim < 0)
962 : {
963 0 : status = -1;
964 0 : HEpush(DFE_GENAPP, "GDdefdim", __FILE__, __LINE__);
965 0 : HEreport("Dimension value for \"%s\" less than zero: %d.\n",
966 : dimname, dim);
967 : }
968 :
969 :
970 : /* Write Dimension to Structural MetaData */
971 : /* -------------------------------------- */
972 0 : if (status == 0)
973 : {
974 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
975 : /* The cast to char* is somehow nasty since EHinsertmeta can modify */
976 : /* dimname, but not in this case since we call with metacode = 0 */
977 0 : status = EHinsertmeta(sdInterfaceID, gridname, "g", 0L,
978 : (char*) dimname, &dim);
979 : }
980 0 : return (status);
981 :
982 : }
983 :
984 : /*----------------------------------------------------------------------------|
985 : | BEGIN_PROLOG |
986 : | |
987 : | FUNCTION: GDdefproj |
988 : | |
989 : | DESCRIPTION: Defines projection of grid. |
990 : | |
991 : | |
992 : | Return Value Type Units Description |
993 : | ============ ====== ========= ===================================== |
994 : | status intn return status (0) SUCCEED, (-1) FAIL |
995 : | |
996 : | INPUTS: |
997 : | gridID int32 Grid structure ID |
998 : | projcode int32 GCTP projection code |
999 : | zonecode int32 UTM zone code |
1000 : | spherecode int32 GCTP spheriod code |
1001 : | projparm float64 Projection parameters |
1002 : | |
1003 : | OUTPUTS: |
1004 : | None |
1005 : | |
1006 : | NOTES: |
1007 : | |
1008 : | |
1009 : | Date Programmer Description |
1010 : | ====== ============ ================================================= |
1011 : | Jun 96 Joel Gales Original Programmer |
1012 : | Jun 00 Abe Taaheri Added support for EASE grid |
1013 : | |
1014 : | END_PROLOG |
1015 : -----------------------------------------------------------------------------*/
1016 : intn
1017 0 : GDdefproj(int32 gridID, int32 projcode, int32 zonecode, int32 spherecode,
1018 : float64 projparm[])
1019 : {
1020 : intn i; /* Loop index */
1021 : intn projx; /* Projection table l_index */
1022 0 : intn status = 0; /* routine return status variable */
1023 :
1024 : int32 fid; /* HDF-EOS file ID */
1025 : int32 sdInterfaceID; /* HDF SDS interface ID */
1026 : int32 gdVgrpID; /* Grid root Vgroup ID */
1027 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1028 : int32 slen; /* String length */
1029 : char utlbuf[1024]; /* Utility Buffer */
1030 : char projparmbuf[512]; /* Projection parameter metadata
1031 : * string */
1032 : char gridname[80]; /* Grid Name */
1033 :
1034 :
1035 : /* Check for valid grid id */
1036 : /* ----------------------- */
1037 0 : status = GDchkgdid(gridID, "GDdefproj", &fid, &sdInterfaceID, &gdVgrpID);
1038 :
1039 0 : if (status == 0)
1040 : {
1041 : /*
1042 : * If projection not GEO, UTM, or State Code build projection
1043 : * parameter string
1044 : */
1045 0 : if (projcode != GCTP_GEO &&
1046 0 : projcode != GCTP_UTM &&
1047 : projcode != GCTP_SPCS)
1048 : {
1049 :
1050 : /* Begin projection parameter list with "(" */
1051 0 : strcpy(projparmbuf, "(");
1052 :
1053 0 : for (i = 0; i < 13; i++)
1054 : {
1055 : /* If projparm[i] = 0 ... */
1056 0 : if (projparm[i] == 0.0)
1057 : {
1058 0 : strcpy(utlbuf, "0,");
1059 : }
1060 : else
1061 : {
1062 : /* if projparm[i] is integer ... */
1063 0 : if ((int32) projparm[i] == projparm[i])
1064 : {
1065 0 : snprintf(utlbuf, sizeof(utlbuf), "%d%s",
1066 0 : (int) projparm[i], ",");
1067 : }
1068 : /* else projparm[i] is non-zero floating point ... */
1069 : else
1070 : {
1071 0 : CPLsnprintf(utlbuf, sizeof(utlbuf), "%f%s", projparm[i], ",");
1072 : }
1073 : }
1074 0 : strcat(projparmbuf, utlbuf);
1075 : }
1076 0 : slen = (int)strlen(projparmbuf);
1077 :
1078 : /* Add trailing ")" */
1079 0 : projparmbuf[slen - 1] = ')';
1080 : }
1081 :
1082 0 : for (projx = 0; Projections[projx].projcode != -1; projx++)
1083 : {
1084 0 : if (projcode == Projections[projx].projcode)
1085 : {
1086 0 : break;
1087 : }
1088 : }
1089 :
1090 :
1091 : /* Build metadata string */
1092 : /* --------------------- */
1093 0 : if (projcode == GCTP_GEO)
1094 : {
1095 0 : snprintf(utlbuf, sizeof(utlbuf),
1096 : "%s%s%s",
1097 : "\t\tProjection=", Projections[projx].projname, "\n");
1098 : }
1099 0 : else if (projcode == GCTP_UTM || projcode == GCTP_SPCS)
1100 : {
1101 0 : snprintf(utlbuf, sizeof(utlbuf),
1102 : "%s%s%s%s%d%s%s%d%s",
1103 : "\t\tProjection=", Projections[projx].projname, "\n",
1104 : "\t\tZoneCode=", (int)zonecode, "\n",
1105 : "\t\tSphereCode=", (int)spherecode, "\n");
1106 : }
1107 : else
1108 : {
1109 0 : snprintf(utlbuf, sizeof(utlbuf),
1110 : "%s%s%s%s%s%s%s%d%s",
1111 : "\t\tProjection=", Projections[projx].projname, "\n",
1112 : "\t\tProjParams=", projparmbuf, "\n",
1113 : "\t\tSphereCode=", (int)spherecode, "\n");
1114 : }
1115 :
1116 :
1117 : /* Insert in structural metadata */
1118 : /* ----------------------------- */
1119 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
1120 0 : status = EHinsertmeta(sdInterfaceID, gridname, "g", 101L,
1121 : utlbuf, NULL);
1122 : }
1123 :
1124 0 : return (status);
1125 : }
1126 :
1127 :
1128 :
1129 : /*----------------------------------------------------------------------------|
1130 : | BEGIN_PROLOG |
1131 : | |
1132 : | FUNCTION: GDblkSOMoffset |
1133 : | |
1134 : | DESCRIPTION: Writes Block SOM offset values |
1135 : | |
1136 : | |
1137 : | Return Value Type Units Description |
1138 : | ============ ====== ========= ===================================== |
1139 : | status intn return status (0) SUCCEED, (-1) FAIL |
1140 : | |
1141 : | INPUTS: |
1142 : | gridID int32 Grid structure ID |
1143 : | offset float32 Offset values |
1144 : | count int32 Number of offset values |
1145 : | code char w/r code (w/r) |
1146 : | |
1147 : | OUTPUTS: |
1148 : | None |
1149 : | |
1150 : | NOTES: |
1151 : | |
1152 : | |
1153 : | Date Programmer Description |
1154 : | ====== ============ ================================================= |
1155 : | Sep 96 Joel Gales Original Programmer |
1156 : | Mar 99 David Wynne Changed data type of offset array from int32 to |
1157 : | float32, NCR 21197 |
1158 : | |
1159 : | END_PROLOG |
1160 : -----------------------------------------------------------------------------*/
1161 : intn
1162 0 : GDblkSOMoffset(int32 gridID, float32 offset[], int32 count, const char *code)
1163 : {
1164 0 : intn status = 0; /* routine return status variable */
1165 :
1166 : int32 fid; /* HDF-EOS file ID */
1167 : int32 sdInterfaceID; /* HDF SDS interface ID */
1168 : int32 gdVgrpID; /* Grid root Vgroup ID */
1169 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1170 : int32 projcode; /* GCTP projection code */
1171 :
1172 : float64 projparm[13]; /* Projection parameters */
1173 :
1174 : char utlbuf[128];/* Utility Buffer */
1175 : char gridname[80]; /* Grid Name */
1176 :
1177 : /* Check for valid grid id */
1178 0 : status = GDchkgdid(gridID, "GDblkSOMoffset",
1179 : &fid, &sdInterfaceID, &gdVgrpID);
1180 :
1181 0 : if (status == 0)
1182 : {
1183 : /* Get projection parameters */
1184 0 : status = GDprojinfo(gridID, &projcode, NULL, NULL, projparm);
1185 :
1186 : /* If SOM projection with projparm[11] non-zero ... */
1187 0 : if (projcode == GCTP_SOM && projparm[11] != 0)
1188 : {
1189 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
1190 0 : snprintf(utlbuf, sizeof(utlbuf),"%s%s", "_BLKSOM:", gridname);
1191 :
1192 : /* Write offset values as attribute */
1193 0 : if (strcmp(code, "w") == 0)
1194 : {
1195 0 : status = GDwriteattr(gridID, utlbuf, DFNT_FLOAT32,
1196 : count, offset);
1197 : }
1198 : /* Read offset values from attribute */
1199 0 : else if (strcmp(code, "r") == 0)
1200 : {
1201 0 : status = GDreadattr(gridID, utlbuf, offset);
1202 : }
1203 : }
1204 : }
1205 0 : return (status);
1206 : }
1207 :
1208 :
1209 : /*----------------------------------------------------------------------------|
1210 : | BEGIN_PROLOG |
1211 : | |
1212 : | FUNCTION: GDdefcomp |
1213 : | |
1214 : | DESCRIPTION: Defines compression type and parameters |
1215 : | |
1216 : | |
1217 : | Return Value Type Units Description |
1218 : | ============ ====== ========= ===================================== |
1219 : | status intn return status (0) SUCCEED, (-1) FAIL |
1220 : | |
1221 : | INPUTS: |
1222 : | gridID int32 grid structure ID |
1223 : | compcode int32 compression code |
1224 : | compparm intn compression parameters |
1225 : | |
1226 : | OUTPUTS: |
1227 : | None |
1228 : | |
1229 : | NOTES: |
1230 : | |
1231 : | |
1232 : | Date Programmer Description |
1233 : | ====== ============ ================================================= |
1234 : | Sep 96 Joel Gales Original Programmer |
1235 : | |
1236 : | END_PROLOG |
1237 : -----------------------------------------------------------------------------*/
1238 : intn
1239 0 : GDdefcomp(int32 gridID, int32 compcode, intn compparm[])
1240 : {
1241 0 : intn status = 0; /* routine return status variable */
1242 :
1243 : int32 fid; /* HDF-EOS file id */
1244 : int32 sdInterfaceID; /* HDF SDS interface ID */
1245 : int32 gdVgrpID; /* Grid root Vgroup ID */
1246 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1247 : int32 gID; /* gridID - offset */
1248 :
1249 : /* Check for valid grid id */
1250 0 : status = GDchkgdid(gridID, "GDdefcomp", &fid, &sdInterfaceID, &gdVgrpID);
1251 :
1252 0 : if (status == 0)
1253 : {
1254 0 : gID = gridID % idOffset;
1255 :
1256 : /* Set compression code in compression external array */
1257 0 : GDXGrid[gID].compcode = compcode;
1258 :
1259 0 : switch (compcode)
1260 : {
1261 : /* Set NBIT compression parameters in compression external array */
1262 0 : case HDFE_COMP_NBIT:
1263 :
1264 0 : GDXGrid[gID].compparm[0] = compparm[0];
1265 0 : GDXGrid[gID].compparm[1] = compparm[1];
1266 0 : GDXGrid[gID].compparm[2] = compparm[2];
1267 0 : GDXGrid[gID].compparm[3] = compparm[3];
1268 :
1269 0 : break;
1270 :
1271 : /* Set GZIP compression parameter in compression external array */
1272 0 : case HDFE_COMP_DEFLATE:
1273 :
1274 0 : GDXGrid[gID].compparm[0] = compparm[0];
1275 :
1276 0 : break;
1277 :
1278 : }
1279 0 : }
1280 :
1281 0 : return (status);
1282 : }
1283 :
1284 :
1285 :
1286 :
1287 : /*----------------------------------------------------------------------------|
1288 : | BEGIN_PROLOG |
1289 : | |
1290 : | FUNCTION: GDdeftile |
1291 : | |
1292 : | DESCRIPTION: Defines tiling parameters |
1293 : | |
1294 : | |
1295 : | Return Value Type Units Description |
1296 : | ============ ====== ========= ===================================== |
1297 : | status intn return status (0) SUCCEED, (-1) FAIL |
1298 : | |
1299 : | INPUTS: |
1300 : | gridID int32 grid structure ID |
1301 : | tilecode int32 tile code |
1302 : | tilerank int32 number of tiling dimensions |
1303 : | tiledims int32 tiling dimensions |
1304 : | |
1305 : | OUTPUTS: |
1306 : | None |
1307 : | |
1308 : | NOTES: |
1309 : | |
1310 : | |
1311 : | Date Programmer Description |
1312 : | ====== ============ ================================================= |
1313 : | Jan 97 Joel Gales Original Programmer |
1314 : | |
1315 : | END_PROLOG |
1316 : -----------------------------------------------------------------------------*/
1317 : intn
1318 0 : GDdeftile(int32 gridID, int32 tilecode, int32 tilerank, int32 tiledims[])
1319 : {
1320 : intn i; /* Loop index */
1321 0 : intn status = 0; /* routine return status variable */
1322 :
1323 : int32 fid; /* HDF-EOS file id */
1324 : int32 sdInterfaceID; /* HDF SDS interface ID */
1325 : int32 gdVgrpID; /* Grid root Vgroup ID */
1326 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1327 : int32 gID; /* gridID - offset */
1328 :
1329 : /* Check for valid grid id */
1330 : /* ----------------------- */
1331 0 : status = GDchkgdid(gridID, "GDdeftile", &fid, &sdInterfaceID, &gdVgrpID);
1332 :
1333 :
1334 0 : if (status == 0)
1335 : {
1336 0 : gID = gridID % idOffset;
1337 :
1338 0 : for (i = 0; i < 8; i++)
1339 : {
1340 0 : GDXGrid[gID].tiledims[i] = 0;
1341 : }
1342 :
1343 0 : GDXGrid[gID].tilecode = tilecode;
1344 :
1345 0 : switch (tilecode)
1346 : {
1347 0 : case HDFE_NOTILE:
1348 :
1349 0 : GDXGrid[gID].tilerank = 0;
1350 :
1351 0 : break;
1352 :
1353 :
1354 0 : case HDFE_TILE:
1355 :
1356 0 : GDXGrid[gID].tilerank = tilerank;
1357 :
1358 0 : for (i = 0; i < tilerank; i++)
1359 : {
1360 0 : GDXGrid[gID].tiledims[i] = tiledims[i];
1361 :
1362 0 : if (GDXGrid[gID].tiledims[i] == 0)
1363 : {
1364 0 : GDXGrid[gID].tiledims[i] = 1;
1365 : }
1366 : }
1367 :
1368 0 : break;
1369 :
1370 : }
1371 0 : }
1372 :
1373 0 : return (status);
1374 : }
1375 :
1376 :
1377 :
1378 :
1379 : /*----------------------------------------------------------------------------|
1380 : | BEGIN_PROLOG |
1381 : | |
1382 : | FUNCTION: GDdeforigin |
1383 : | |
1384 : | DESCRIPTION: Defines the origin of the grid data. |
1385 : | |
1386 : | |
1387 : | Return Value Type Units Description |
1388 : | ============ ====== ========= ===================================== |
1389 : | status intn return status (0) SUCCEED, (-1) FAIL |
1390 : | |
1391 : | INPUTS: |
1392 : | gridID int32 grid structure ID |
1393 : | origincode int32 origin code |
1394 : | HDFE_GD_UL (0) |
1395 : | HDFE_GD_UR (1) |
1396 : | HDFE_GD_LL (2) |
1397 : | HDFE_GD_LR (3) |
1398 : | |
1399 : | |
1400 : | OUTPUTS: |
1401 : | None |
1402 : | |
1403 : | NOTES: |
1404 : | |
1405 : | |
1406 : | Date Programmer Description |
1407 : | ====== ============ ================================================= |
1408 : | Jun 96 Joel Gales Original Programmer |
1409 : | |
1410 : | END_PROLOG |
1411 : -----------------------------------------------------------------------------*/
1412 : intn
1413 0 : GDdeforigin(int32 gridID, int32 origincode)
1414 : {
1415 0 : intn status = 0; /* routine return status variable */
1416 :
1417 : int32 fid; /* HDF-EOS file ID */
1418 : int32 gdVgrpID; /* Grid root Vgroup ID */
1419 : int32 sdInterfaceID; /* HDF SDS interface ID */
1420 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1421 :
1422 : char utlbuf[64]; /* Utility buffer */
1423 : char gridname[80]; /* Grid name */
1424 :
1425 :
1426 : /* Check for valid grid id */
1427 0 : status = GDchkgdid(gridID, "GDdeforigin",
1428 : &fid, &sdInterfaceID, &gdVgrpID);
1429 :
1430 0 : if (status == 0)
1431 : {
1432 : /* If proper origin code then write to structural metadata */
1433 : /* ------------------------------------------------------- */
1434 0 : if (origincode >= 0 && origincode < (int32)sizeof(originNames))
1435 : {
1436 0 : snprintf(utlbuf, sizeof(utlbuf),"%s%s%s",
1437 : "\t\tGridOrigin=", originNames[origincode], "\n");
1438 :
1439 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
1440 0 : status = EHinsertmeta(sdInterfaceID, gridname, "g", 101L,
1441 : utlbuf, NULL);
1442 : }
1443 : else
1444 : {
1445 0 : status = -1;
1446 0 : HEpush(DFE_GENAPP, "GDdeforigin", __FILE__, __LINE__);
1447 0 : HEreport("Improper Grid Origin code: %d\n", origincode);
1448 : }
1449 : }
1450 :
1451 0 : return (status);
1452 : }
1453 :
1454 : /*----------------------------------------------------------------------------|
1455 : | BEGIN_PROLOG |
1456 : | |
1457 : | FUNCTION: GDdefpixreg |
1458 : | |
1459 : | DESCRIPTION: Defines pixel registration within grid cell. |
1460 : | |
1461 : | |
1462 : | Return Value Type Units Description |
1463 : | ============ ====== ========= ===================================== |
1464 : | status intn return status (0) SUCCEED, (-1) FAIL |
1465 : | |
1466 : | INPUTS: |
1467 : | gridID int32 grid structure ID |
1468 : | pixregcode int32 Pixel registration code |
1469 : | HDFE_CENTER (0) |
1470 : | HDFE_CORNER (1) |
1471 : | |
1472 : | |
1473 : | OUTPUTS: |
1474 : | None |
1475 : | |
1476 : | NOTES: |
1477 : | |
1478 : | |
1479 : | Date Programmer Description |
1480 : | ====== ============ ================================================= |
1481 : | Jun 96 Joel Gales Original Programmer |
1482 : | |
1483 : | END_PROLOG |
1484 : -----------------------------------------------------------------------------*/
1485 : intn
1486 0 : GDdefpixreg(int32 gridID, int32 pixregcode)
1487 : {
1488 0 : intn status = 0; /* routine return status variable */
1489 :
1490 : int32 fid; /* HDF-EOS file ID */
1491 : int32 gdVgrpID; /* Grid root Vgroup ID */
1492 : int32 sdInterfaceID; /* HDF SDS interface ID */
1493 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1494 :
1495 : char utlbuf[64]; /* Utility buffer */
1496 : char gridname[80]; /* Grid name */
1497 :
1498 : /* Check for valid grid id */
1499 0 : status = GDchkgdid(gridID, "GDdefpixreg",
1500 : &fid, &sdInterfaceID, &gdVgrpID);
1501 :
1502 0 : if (status == 0)
1503 : {
1504 : /* If proper pix reg code then write to structural metadata */
1505 : /* -------------------------------------------------------- */
1506 0 : if (pixregcode >= 0 && pixregcode < (int32)sizeof(pixregNames))
1507 : {
1508 0 : snprintf(utlbuf, sizeof(utlbuf),"%s%s%s",
1509 : "\t\tPixelRegistration=", pixregNames[pixregcode], "\n");
1510 :
1511 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
1512 0 : status = EHinsertmeta(sdInterfaceID, gridname, "g", 101L,
1513 : utlbuf, NULL);
1514 : }
1515 : else
1516 : {
1517 0 : status = -1;
1518 0 : HEpush(DFE_GENAPP, "GDdefpixreg", __FILE__, __LINE__);
1519 0 : HEreport("Improper Pixel Registration code: %d\n", pixregcode);
1520 : }
1521 : }
1522 :
1523 0 : return (status);
1524 :
1525 : }
1526 :
1527 :
1528 :
1529 :
1530 :
1531 : /*----------------------------------------------------------------------------|
1532 : | BEGIN_PROLOG |
1533 : | |
1534 : | FUNCTION: GDdiminfo |
1535 : | |
1536 : | DESCRIPTION: Retrieve size of specified dimension. |
1537 : | |
1538 : | |
1539 : | Return Value Type Units Description |
1540 : | ============ ====== ========= ===================================== |
1541 : | size int32 Size of dimension |
1542 : | |
1543 : | INPUTS: |
1544 : | gridID int32 grid structure id |
1545 : | dimname char Dimension name |
1546 : | |
1547 : | |
1548 : | OUTPUTS: |
1549 : | None |
1550 : | |
1551 : | NOTES: |
1552 : | |
1553 : | |
1554 : | Date Programmer Description |
1555 : | ====== ============ ================================================= |
1556 : | Jun 96 Joel Gales Original Programmer |
1557 : | Aug 96 Joel Gales Make metadata ODL compliant |
1558 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1559 : | |
1560 : | END_PROLOG |
1561 : -----------------------------------------------------------------------------*/
1562 : int32
1563 0 : GDdiminfo(int32 gridID, const char *dimname)
1564 :
1565 : {
1566 : intn status; /* routine return status variable */
1567 :
1568 : int32 fid; /* HDF-EOS file ID */
1569 : int32 sdInterfaceID; /* HDF SDS interface ID */
1570 : int32 gdVgrpID; /* Grid root Vgroup ID */
1571 : int32 size; /* Dimension size */
1572 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1573 :
1574 :
1575 : char *metabuf; /* Pointer to structural metadata (SM) */
1576 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1577 : char gridname[80]; /* Grid Name */
1578 : char *utlstr; /* Utility string */
1579 :
1580 : /* Allocate space for utility string */
1581 : /* --------------------------------- */
1582 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1583 0 : if(utlstr == NULL)
1584 : {
1585 0 : HEpush(DFE_NOSPACE,"GDdiminfo", __FILE__, __LINE__);
1586 0 : return(-1);
1587 : }
1588 : /* Initialize return value */
1589 : /* ----------------------- */
1590 0 : size = -1;
1591 :
1592 :
1593 : /* Check Grid ID */
1594 : /* ------------- */
1595 0 : status = GDchkgdid(gridID, "GDdiminfo", &fid, &sdInterfaceID, &gdVgrpID);
1596 :
1597 :
1598 0 : if (status == 0)
1599 : {
1600 : /* Get grid name */
1601 : /* ------------- */
1602 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
1603 :
1604 :
1605 : /* Get pointers to "Dimension" section within SM */
1606 : /* --------------------------------------------- */
1607 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1608 : "Dimension", metaptrs);
1609 :
1610 0 : if(metabuf == NULL)
1611 : {
1612 0 : free(utlstr);
1613 0 : return(-1);
1614 : }
1615 :
1616 : /* Search for dimension name (surrounded by quotes) */
1617 : /* ------------------------------------------------ */
1618 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", dimname, "\"\n");
1619 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1620 :
1621 : /*
1622 : * If dimension found within grid structure then get dimension value
1623 : */
1624 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1625 : {
1626 : /* Set endptr at end of dimension definition entry */
1627 : /* ----------------------------------------------- */
1628 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
1629 :
1630 0 : status = EHgetmetavalue(metaptrs, "Size", utlstr);
1631 :
1632 0 : if (status == 0)
1633 : {
1634 0 : size = atoi(utlstr);
1635 : }
1636 : else
1637 : {
1638 0 : HEpush(DFE_GENAPP, "GDdiminfo", __FILE__, __LINE__);
1639 0 : HEreport("\"Size\" string not found in metadata.\n");
1640 : }
1641 : }
1642 : else
1643 : {
1644 0 : HEpush(DFE_GENAPP, "GDdiminfo", __FILE__, __LINE__);
1645 0 : HEreport("Dimension \"%s\" not found.\n", dimname);
1646 : }
1647 :
1648 0 : free(metabuf);
1649 : }
1650 0 : free(utlstr);
1651 0 : return (size);
1652 : }
1653 :
1654 :
1655 :
1656 :
1657 :
1658 : /*----------------------------------------------------------------------------|
1659 : | BEGIN_PROLOG |
1660 : | |
1661 : | FUNCTION: GDgridinfo |
1662 : | |
1663 : | DESCRIPTION: Returns xdim, ydim and location of upper left and lower |
1664 : | right corners, in meters. |
1665 : | |
1666 : | |
1667 : | Return Value Type Units Description |
1668 : | ============ ====== ========= ===================================== |
1669 : | status intn return status (0) SUCCEED, (-1) FAIL |
1670 : | |
1671 : | INPUTS: |
1672 : | fid int32 File ID |
1673 : | gridname char Grid structure name |
1674 : | |
1675 : | OUTPUTS: |
1676 : | xdimsize int32 Number of columns in grid |
1677 : | ydimsize int32 Number of rows in grid |
1678 : | upleftpt float64 Location (m/deg) of upper left corner |
1679 : | lowrightpt float64 Location (m/deg) of lower right corner |
1680 : | |
1681 : | NOTES: |
1682 : | |
1683 : | |
1684 : | Date Programmer Description |
1685 : | ====== ============ ================================================= |
1686 : | Jun 96 Joel Gales Original Programmer |
1687 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1688 : | |
1689 : | END_PROLOG |
1690 : -----------------------------------------------------------------------------*/
1691 : intn
1692 0 : GDgridinfo(int32 gridID, int32 * xdimsize, int32 * ydimsize,
1693 : float64 upleftpt[], float64 lowrightpt[])
1694 :
1695 : {
1696 0 : intn status = 0; /* routine return status variable */
1697 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1698 :
1699 : int32 fid; /* HDF-EOS file ID */
1700 : int32 sdInterfaceID; /* HDF SDS interface ID */
1701 : int32 gdVgrpID; /* Grid root Vgroup ID */
1702 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1703 :
1704 :
1705 : char *metabuf; /* Pointer to structural metadata (SM) */
1706 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1707 : char gridname[80]; /* Grid Name */
1708 : char *utlstr; /* Utility string */
1709 :
1710 : /* Allocate space for utility string */
1711 : /* --------------------------------- */
1712 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1713 0 : if(utlstr == NULL)
1714 : {
1715 0 : HEpush(DFE_NOSPACE,"GDgridinfo", __FILE__, __LINE__);
1716 0 : return(-1);
1717 : }
1718 : /* Check Grid ID */
1719 : /* ------------- */
1720 0 : status = GDchkgdid(gridID, "GDgridinfo", &fid, &sdInterfaceID, &gdVgrpID);
1721 :
1722 0 : if (status == 0)
1723 : {
1724 : /* Get grid name */
1725 : /* ------------- */
1726 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
1727 :
1728 :
1729 : /* Get pointers to grid structure section within SM */
1730 : /* ------------------------------------------------ */
1731 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1732 : NULL, metaptrs);
1733 :
1734 0 : if(metabuf == NULL)
1735 : {
1736 0 : free(utlstr);
1737 0 : return(-1);
1738 : }
1739 :
1740 :
1741 : /* Get xdimsize if requested */
1742 : /* ------------------------- */
1743 0 : if (xdimsize != NULL)
1744 : {
1745 0 : statmeta = EHgetmetavalue(metaptrs, "XDim", utlstr);
1746 0 : if (statmeta == 0)
1747 : {
1748 0 : *xdimsize = atoi(utlstr);
1749 : }
1750 : else
1751 : {
1752 0 : status = -1;
1753 0 : HEpush(DFE_GENAPP, "GDgridinfo", __FILE__, __LINE__);
1754 0 : HEreport("\"XDim\" string not found in metadata.\n");
1755 : }
1756 : }
1757 :
1758 :
1759 : /* Get ydimsize if requested */
1760 : /* ------------------------- */
1761 0 : if (ydimsize != NULL)
1762 : {
1763 0 : statmeta = EHgetmetavalue(metaptrs, "YDim", utlstr);
1764 0 : if (statmeta == 0)
1765 : {
1766 0 : *ydimsize = atoi(utlstr);
1767 : }
1768 : else
1769 : {
1770 0 : status = -1;
1771 0 : HEpush(DFE_GENAPP, "GDgridinfo", __FILE__, __LINE__);
1772 0 : HEreport("\"YDim\" string not found in metadata.\n");
1773 : }
1774 : }
1775 :
1776 :
1777 : /* Get upleftpt if requested */
1778 : /* ------------------------- */
1779 0 : if (upleftpt != NULL)
1780 : {
1781 0 : statmeta = EHgetmetavalue(metaptrs, "UpperLeftPointMtrs", utlstr);
1782 0 : if (statmeta == 0)
1783 : {
1784 : /* If value is "DEFAULT" then return zeros */
1785 : /* --------------------------------------- */
1786 0 : if (strcmp(utlstr, "DEFAULT") == 0)
1787 : {
1788 0 : upleftpt[0] = 0;
1789 0 : upleftpt[1] = 0;
1790 : }
1791 : else
1792 : {
1793 0 : sscanf(utlstr, "(%lf,%lf)",
1794 : &upleftpt[0], &upleftpt[1]);
1795 : }
1796 : }
1797 : else
1798 : {
1799 0 : status = -1;
1800 0 : HEpush(DFE_GENAPP, "GDgridinfo", __FILE__, __LINE__);
1801 0 : HEreport(
1802 : "\"UpperLeftPointMtrs\" string not found in metadata.\n");
1803 : }
1804 :
1805 : }
1806 :
1807 : /* Get lowrightpt if requested */
1808 : /* --------------------------- */
1809 0 : if (lowrightpt != NULL)
1810 : {
1811 0 : statmeta = EHgetmetavalue(metaptrs, "LowerRightMtrs", utlstr);
1812 0 : if (statmeta == 0)
1813 : {
1814 : /* If value is "DEFAULT" then return zeros */
1815 0 : if (strcmp(utlstr, "DEFAULT") == 0)
1816 : {
1817 0 : lowrightpt[0] = 0;
1818 0 : lowrightpt[1] = 0;
1819 : }
1820 : else
1821 : {
1822 0 : sscanf(utlstr, "(%lf,%lf)",
1823 : &lowrightpt[0], &lowrightpt[1]);
1824 : }
1825 : }
1826 : else
1827 : {
1828 0 : status = -1;
1829 0 : HEpush(DFE_GENAPP, "GDgridinfo", __FILE__, __LINE__);
1830 0 : HEreport(
1831 : "\"LowerRightMtrs\" string not found in metadata.\n");
1832 : }
1833 : }
1834 :
1835 0 : free(metabuf);
1836 : }
1837 0 : free(utlstr);
1838 0 : return (status);
1839 : }
1840 :
1841 :
1842 :
1843 :
1844 :
1845 :
1846 :
1847 : /*----------------------------------------------------------------------------|
1848 : | BEGIN_PROLOG |
1849 : | |
1850 : | FUNCTION: GDprojinfo |
1851 : | |
1852 : | DESCRIPTION: Returns GCTP projection code, zone code, spheroid code |
1853 : | and projection parameters. |
1854 : | |
1855 : | |
1856 : | Return Value Type Units Description |
1857 : | ============ ====== ========= ===================================== |
1858 : | status intn return status (0) SUCCEED, (-1) FAIL |
1859 : | |
1860 : | INPUTS: |
1861 : | gridID int32 Grid structure ID |
1862 : | |
1863 : | OUTPUTS: |
1864 : | projcode int32 GCTP projection code |
1865 : | zonecode int32 UTM zone code |
1866 : | spherecode int32 GCTP spheriod code |
1867 : | projparm float64 Projection parameters |
1868 : | |
1869 : | NOTES: |
1870 : | |
1871 : | |
1872 : | Date Programmer Description |
1873 : | ====== ============ ================================================= |
1874 : | Jun 96 Joel Gales Original Programmer |
1875 : | Oct 96 Joel Gales Add check for no projection code |
1876 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1877 : | Jun 00 Abe Taaheri Added support for EASE grid |
1878 : | |
1879 : | END_PROLOG |
1880 : -----------------------------------------------------------------------------*/
1881 : intn
1882 0 : GDprojinfo(int32 gridID, int32 * projcode, int32 * zonecode,
1883 : int32 * spherecode, float64 projparm[])
1884 :
1885 : {
1886 : intn i; /* Loop index */
1887 : intn projx; /* Loop index */
1888 0 : intn status = 0; /* routine return status variable */
1889 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1890 :
1891 : int32 fid; /* HDF-EOS file ID */
1892 : int32 sdInterfaceID; /* HDF SDS interface ID */
1893 : int32 gdVgrpID; /* Grid root Vgroup ID */
1894 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1895 :
1896 :
1897 : char *metabuf; /* Pointer to structural metadata (SM) */
1898 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1899 : char gridname[80]; /* Grid Name */
1900 : char *utlstr; /* Utility string */
1901 : char fmt[96]; /* Format String */
1902 :
1903 : /* Allocate space for utility string */
1904 : /* --------------------------------- */
1905 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1906 0 : if(utlstr == NULL)
1907 : {
1908 0 : HEpush(DFE_NOSPACE,"GDprojinfo", __FILE__, __LINE__);
1909 0 : return(-1);
1910 : }
1911 :
1912 : /* Check Grid ID */
1913 : /* ------------- */
1914 0 : status = GDchkgdid(gridID, "GDprojinfo", &fid, &sdInterfaceID, &gdVgrpID);
1915 :
1916 0 : if (status == 0)
1917 : {
1918 : /* Get grid name */
1919 : /* ------------- */
1920 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
1921 :
1922 :
1923 : /* Get pointers to grid structure section within SM */
1924 : /* ------------------------------------------------ */
1925 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1926 : NULL, metaptrs);
1927 :
1928 0 : if(metabuf == NULL)
1929 : {
1930 0 : free(utlstr);
1931 0 : return(-1);
1932 : }
1933 :
1934 :
1935 : /* Get projcode if requested */
1936 : /* ------------------------- */
1937 0 : if (projcode != NULL)
1938 : {
1939 0 : *projcode = -1;
1940 :
1941 0 : statmeta = EHgetmetavalue(metaptrs, "Projection", utlstr);
1942 0 : if (statmeta == 0)
1943 : {
1944 : /* Loop through projection codes until found */
1945 : /* ----------------------------------------- */
1946 0 : for (projx = 0; Projections[projx].projcode != -1; projx++)
1947 0 : if (strcmp(utlstr, Projections[projx].projname) == 0)
1948 0 : break;
1949 0 : if (Projections[projx].projname != NULL)
1950 0 : *projcode = Projections[projx].projcode;
1951 : }
1952 : else
1953 : {
1954 0 : status = -1;
1955 0 : HEpush(DFE_GENAPP, "GDprojinfo", __FILE__, __LINE__);
1956 0 : HEreport("Projection Code not defined for \"%s\".\n",
1957 : gridname);
1958 :
1959 0 : if (projparm != NULL)
1960 : {
1961 0 : for (i = 0; i < 13; i++)
1962 : {
1963 0 : projparm[i] = -1;
1964 : }
1965 : }
1966 : }
1967 : }
1968 :
1969 :
1970 : /* Get zonecode if requested */
1971 : /* ------------------------- */
1972 0 : if (zonecode != NULL)
1973 : {
1974 0 : *zonecode = -1;
1975 :
1976 :
1977 : /* Zone code only relevant for UTM and State Code projections */
1978 : /* ---------------------------------------------------------- */
1979 0 : if (*projcode == GCTP_UTM || *projcode == GCTP_SPCS)
1980 : {
1981 0 : statmeta = EHgetmetavalue(metaptrs, "ZoneCode", utlstr);
1982 0 : if (statmeta == 0)
1983 : {
1984 0 : *zonecode = atoi(utlstr);
1985 : }
1986 : else
1987 : {
1988 0 : status = -1;
1989 0 : HEpush(DFE_GENAPP, "GDprojinfo", __FILE__, __LINE__);
1990 0 : HEreport("Zone Code not defined for \"%s\".\n",
1991 : gridname);
1992 : }
1993 : }
1994 : }
1995 :
1996 :
1997 : /* Get projection parameters if requested */
1998 : /* -------------------------------------- */
1999 0 : if (projparm != NULL)
2000 : {
2001 :
2002 : /*
2003 : * Note: No projection parameters for GEO, UTM, and State Code
2004 : * projections
2005 : */
2006 0 : if (*projcode == GCTP_GEO || *projcode == GCTP_UTM ||
2007 0 : *projcode == GCTP_SPCS)
2008 : {
2009 0 : for (i = 0; i < 13; i++)
2010 : {
2011 0 : projparm[i] = 0.0;
2012 : }
2013 :
2014 : }
2015 : else
2016 : {
2017 0 : statmeta = EHgetmetavalue(metaptrs, "ProjParams", utlstr);
2018 :
2019 0 : if (statmeta == 0)
2020 : {
2021 :
2022 : /* Build format string to read projection parameters */
2023 : /* ------------------------------------------------- */
2024 0 : strcpy(fmt, "%lf,");
2025 0 : for (i = 1; i <= 11; i++)
2026 0 : strcat(fmt, "%lf,");
2027 0 : strcat(fmt, "%lf");
2028 :
2029 :
2030 : /* Read parameters from numeric list */
2031 : /* --------------------------------- */
2032 0 : sscanf(&utlstr[1], fmt,
2033 : &projparm[0], &projparm[1],
2034 : &projparm[2], &projparm[3],
2035 : &projparm[4], &projparm[5],
2036 : &projparm[6], &projparm[7],
2037 : &projparm[8], &projparm[9],
2038 : &projparm[10], &projparm[11],
2039 : &projparm[12]);
2040 : }
2041 : else
2042 : {
2043 0 : status = -1;
2044 0 : HEpush(DFE_GENAPP, "GDprojinfo", __FILE__, __LINE__);
2045 0 : HEreport("Projection parameters not defined for \"%s\".\n",
2046 : gridname);
2047 :
2048 : }
2049 : }
2050 : }
2051 :
2052 :
2053 : /* Get spherecode if requested */
2054 : /* --------------------------- */
2055 0 : if (spherecode != NULL)
2056 : {
2057 0 : *spherecode = 0;
2058 :
2059 : /* Note: Spherecode not defined for GEO projection */
2060 : /* ----------------------------------------------- */
2061 0 : if ((*projcode != GCTP_GEO))
2062 : {
2063 0 : EHgetmetavalue(metaptrs, "SphereCode", utlstr);
2064 0 : if (statmeta == 0)
2065 : {
2066 0 : *spherecode = atoi(utlstr);
2067 : }
2068 : }
2069 : }
2070 0 : free(metabuf);
2071 :
2072 : }
2073 0 : free(utlstr);
2074 0 : return (status);
2075 : }
2076 :
2077 :
2078 :
2079 : /*----------------------------------------------------------------------------|
2080 : | BEGIN_PROLOG |
2081 : | |
2082 : | FUNCTION: GDorigininfo |
2083 : | |
2084 : | DESCRIPTION: Returns origin code |
2085 : | |
2086 : | |
2087 : | Return Value Type Units Description |
2088 : | ============ ====== ========= ===================================== |
2089 : | status intn return status (0) SUCCEED, (-1) FAIL |
2090 : | |
2091 : | INPUTS: |
2092 : | gridID int32 Grid structure ID |
2093 : | |
2094 : | |
2095 : | OUTPUTS: |
2096 : | origincode int32 grid origin code |
2097 : | |
2098 : | NOTES: |
2099 : | |
2100 : | |
2101 : | Date Programmer Description |
2102 : | ====== ============ ================================================= |
2103 : | Jun 96 Joel Gales Original Programmer |
2104 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
2105 : | |
2106 : | END_PROLOG |
2107 : -----------------------------------------------------------------------------*/
2108 : intn
2109 0 : GDorigininfo(int32 gridID, int32 * origincode)
2110 : {
2111 : intn i; /* Loop index */
2112 0 : intn status = 0; /* routine return status variable */
2113 0 : intn statmeta = 0; /* EHgetmetavalue return status */
2114 :
2115 : int32 fid; /* HDF-EOS file ID */
2116 : int32 sdInterfaceID; /* HDF SDS interface ID */
2117 : int32 gdVgrpID; /* Grid root Vgroup ID */
2118 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2119 :
2120 :
2121 : char *metabuf; /* Pointer to structural metadata (SM) */
2122 : char *metaptrs[2];/* Pointers to begin and end of SM section */
2123 : char gridname[80]; /* Grid Name */
2124 : char *utlstr; /* Utility string */
2125 :
2126 : /* Allocate space for utility string */
2127 : /* --------------------------------- */
2128 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2129 0 : if(utlstr == NULL)
2130 : {
2131 0 : HEpush(DFE_NOSPACE,"GDorigininfo", __FILE__, __LINE__);
2132 0 : return(-1);
2133 : }
2134 : /* Check Grid ID */
2135 : /* ------------- */
2136 0 : status = GDchkgdid(gridID, "GDorigininfo",
2137 : &fid, &sdInterfaceID, &gdVgrpID);
2138 :
2139 :
2140 : /* Initialize pixreg code to -1 (in case of error) */
2141 : /* ----------------------------------------------- */
2142 0 : *origincode = -1;
2143 :
2144 0 : if (status == 0)
2145 : {
2146 : /* Set default origin code */
2147 : /* ----------------------- */
2148 0 : *origincode = 0;
2149 :
2150 :
2151 : /* Get grid name */
2152 : /* ------------- */
2153 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
2154 :
2155 :
2156 : /* Get pointers to grid structure section within SM */
2157 : /* ------------------------------------------------ */
2158 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
2159 : NULL, metaptrs);
2160 :
2161 0 : if(metabuf == NULL)
2162 : {
2163 0 : free(utlstr);
2164 0 : return(-1);
2165 : }
2166 :
2167 :
2168 0 : statmeta = EHgetmetavalue(metaptrs, "GridOrigin", utlstr);
2169 :
2170 0 : if (statmeta == 0)
2171 : {
2172 : /*
2173 : * If "GridOrigin" string found in metadata then convert to
2174 : * numeric origin code (fixed added: Jan 97)
2175 : */
2176 0 : for (i = 0; i < (intn)sizeof(originNames); i++)
2177 : {
2178 0 : if (strcmp(utlstr, originNames[i]) == 0)
2179 : {
2180 0 : *origincode = i;
2181 0 : break;
2182 : }
2183 : }
2184 : }
2185 :
2186 0 : free(metabuf);
2187 : }
2188 0 : free(utlstr);
2189 0 : return (status);
2190 : }
2191 :
2192 :
2193 :
2194 :
2195 :
2196 :
2197 : /*----------------------------------------------------------------------------|
2198 : | BEGIN_PROLOG |
2199 : | |
2200 : | FUNCTION: GDpixreginfo |
2201 : | |
2202 : | DESCRIPTION: |
2203 : | |
2204 : | |
2205 : | Return Value Type Units Description |
2206 : | ============ ====== ========= ===================================== |
2207 : | status intn return status (0) SUCCEED, (-1) FAIL |
2208 : | |
2209 : | INPUTS: |
2210 : | gridID int32 Grid structure ID |
2211 : | |
2212 : | |
2213 : | OUTPUTS: |
2214 : | pixregcode int32 Pixel registration code |
2215 : | |
2216 : | |
2217 : | OUTPUTS: |
2218 : | None |
2219 : | |
2220 : | NOTES: |
2221 : | |
2222 : | |
2223 : | Date Programmer Description |
2224 : | ====== ============ ================================================= |
2225 : | Jun 96 Joel Gales Original Programmer |
2226 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
2227 : | |
2228 : | END_PROLOG |
2229 : -----------------------------------------------------------------------------*/
2230 : intn
2231 0 : GDpixreginfo(int32 gridID, int32 * pixregcode)
2232 : {
2233 : intn i; /* Loop index */
2234 0 : intn status = 0; /* routine return status variable */
2235 0 : intn statmeta = 0; /* EHgetmetavalue return status */
2236 :
2237 : int32 fid; /* HDF-EOS file ID */
2238 : int32 sdInterfaceID; /* HDF SDS interface ID */
2239 : int32 gdVgrpID; /* Grid root Vgroup ID */
2240 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2241 :
2242 :
2243 : char *metabuf; /* Pointer to structural metadata (SM) */
2244 : char *metaptrs[2];/* Pointers to begin and end of SM section */
2245 : char gridname[80]; /* Grid Name */
2246 : char *utlstr; /* Utility string */
2247 :
2248 : /* Allocate space for utility string */
2249 : /* --------------------------------- */
2250 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2251 0 : if(utlstr == NULL)
2252 : {
2253 0 : HEpush(DFE_NOSPACE,"GDpixreginfo", __FILE__, __LINE__);
2254 0 : return(-1);
2255 : }
2256 : /* Check Grid ID */
2257 0 : status = GDchkgdid(gridID, "GDpixreginfo",
2258 : &fid, &sdInterfaceID, &gdVgrpID);
2259 :
2260 : /* Initialize pixreg code to -1 (in case of error) */
2261 0 : *pixregcode = -1;
2262 :
2263 0 : if (status == 0)
2264 : {
2265 : /* Set default pixreg code */
2266 0 : *pixregcode = 0;
2267 :
2268 : /* Get grid name */
2269 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
2270 :
2271 : /* Get pointers to grid structure section within SM */
2272 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
2273 : NULL, metaptrs);
2274 :
2275 0 : if(metabuf == NULL)
2276 : {
2277 0 : free(utlstr);
2278 0 : return(-1);
2279 : }
2280 :
2281 :
2282 0 : statmeta = EHgetmetavalue(metaptrs, "PixelRegistration", utlstr);
2283 :
2284 0 : if (statmeta == 0)
2285 : {
2286 : /*
2287 : * If "PixelRegistration" string found in metadata then convert
2288 : * to numeric origin code (fixed added: Jan 97)
2289 : */
2290 :
2291 0 : for (i = 0; i < (intn)sizeof(pixregNames); i++)
2292 : {
2293 0 : if (strcmp(utlstr, pixregNames[i]) == 0)
2294 : {
2295 0 : *pixregcode = i;
2296 0 : break;
2297 : }
2298 : }
2299 : }
2300 0 : free(metabuf);
2301 : }
2302 0 : free(utlstr);
2303 0 : return (status);
2304 : }
2305 :
2306 :
2307 :
2308 : /*----------------------------------------------------------------------------|
2309 : | BEGIN_PROLOG |
2310 : | |
2311 : | FUNCTION: GDcompinfo |
2312 : | |
2313 : | DESCRIPTION: |
2314 : | |
2315 : | |
2316 : | Return Value Type Units Description |
2317 : | ============ ====== ========= ===================================== |
2318 : | status intn |
2319 : | |
2320 : | INPUTS: |
2321 : | gridID int32 |
2322 : | compcode int32 |
2323 : | compparm intn |
2324 : | |
2325 : | |
2326 : | OUTPUTS: |
2327 : | None |
2328 : | |
2329 : | NOTES: |
2330 : | |
2331 : | |
2332 : | Date Programmer Description |
2333 : | ====== ============ ================================================= |
2334 : | Oct 96 Joel Gales Original Programmer |
2335 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
2336 : | |
2337 : | END_PROLOG |
2338 : -----------------------------------------------------------------------------*/
2339 : intn
2340 0 : GDcompinfo(int32 gridID, const char *fieldname, int32 * compcode, intn compparm[])
2341 : {
2342 : intn i; /* Loop index */
2343 0 : intn status = 0; /* routine return status variable */
2344 0 : intn statmeta = 0; /* EHgetmetavalue return status */
2345 :
2346 : int32 fid; /* HDF-EOS file ID */
2347 : int32 sdInterfaceID; /* HDF SDS interface ID */
2348 : int32 gdVgrpID; /* Grid root Vgroup ID */
2349 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2350 :
2351 :
2352 : char *metabuf; /* Pointer to structural metadata (SM) */
2353 : char *metaptrs[2];/* Pointers to begin and end of SM section */
2354 : char gridname[80]; /* Grid Name */
2355 : char *utlstr;/* Utility string */
2356 :
2357 : /* Allocate space for utility string */
2358 : /* --------------------------------- */
2359 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2360 0 : if(utlstr == NULL)
2361 : {
2362 0 : HEpush(DFE_NOSPACE,"GDcompinfo", __FILE__, __LINE__);
2363 0 : return(-1);
2364 : }
2365 : /* Check Grid ID */
2366 0 : status = GDchkgdid(gridID, "GDcompinfo", &fid, &sdInterfaceID, &gdVgrpID);
2367 :
2368 :
2369 0 : if (status == 0)
2370 : {
2371 : /* Get grid name */
2372 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
2373 :
2374 : /* Get pointers to "DataField" section within SM */
2375 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
2376 : "DataField", metaptrs);
2377 0 : if(metabuf == NULL)
2378 : {
2379 0 : free(utlstr);
2380 0 : return(-1);
2381 : }
2382 :
2383 :
2384 : /* Search for field */
2385 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
2386 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
2387 :
2388 :
2389 : /* If field found and user wants compression code ... */
2390 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2391 : {
2392 0 : if (compcode != NULL)
2393 : {
2394 : /* Set endptr at end of field's definition entry */
2395 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
2396 :
2397 : /* Get compression type */
2398 0 : statmeta = EHgetmetavalue(metaptrs, "CompressionType", utlstr);
2399 :
2400 : /*
2401 : * Default is no compression if "CompressionType" string not
2402 : * in metadata
2403 : */
2404 0 : *compcode = HDFE_COMP_NONE;
2405 :
2406 : /* If compression code is found ... */
2407 0 : if (statmeta == 0)
2408 : {
2409 : /* Loop through compression types until match */
2410 0 : for (i = 0; i < (intn)sizeof(HDFcomp); i++)
2411 : {
2412 0 : if (strcmp(utlstr, HDFcomp[i]) == 0)
2413 : {
2414 0 : *compcode = i;
2415 0 : break;
2416 : }
2417 : }
2418 : }
2419 : }
2420 :
2421 : /* If user wants compression parameters ... */
2422 0 : if (compparm != NULL && compcode != NULL)
2423 : {
2424 : /* Initialize to zero */
2425 0 : for (i = 0; i < 4; i++)
2426 : {
2427 0 : compparm[i] = 0;
2428 : }
2429 :
2430 : /*
2431 : * Get compression parameters if NBIT or DEFLATE compression
2432 : */
2433 0 : if (*compcode == HDFE_COMP_NBIT)
2434 : {
2435 : statmeta =
2436 0 : EHgetmetavalue(metaptrs, "CompressionParams", utlstr);
2437 0 : if (statmeta == 0)
2438 : {
2439 0 : sscanf(utlstr, "(%d,%d,%d,%d)",
2440 : &compparm[0], &compparm[1],
2441 : &compparm[2], &compparm[3]);
2442 : }
2443 : else
2444 : {
2445 0 : status = -1;
2446 0 : HEpush(DFE_GENAPP, "GDcompinfo", __FILE__, __LINE__);
2447 0 : HEreport(
2448 : "\"CompressionParams\" string not found in metadata.\n");
2449 : }
2450 : }
2451 0 : else if (*compcode == HDFE_COMP_DEFLATE)
2452 : {
2453 : statmeta =
2454 0 : EHgetmetavalue(metaptrs, "DeflateLevel", utlstr);
2455 0 : if (statmeta == 0)
2456 : {
2457 0 : sscanf(utlstr, "%d", &compparm[0]);
2458 : }
2459 : else
2460 : {
2461 0 : status = -1;
2462 0 : HEpush(DFE_GENAPP, "GDcompinfo", __FILE__, __LINE__);
2463 0 : HEreport(
2464 : "\"DeflateLevel\" string not found in metadata.\n");
2465 : }
2466 : }
2467 : }
2468 : }
2469 : else
2470 : {
2471 0 : HEpush(DFE_GENAPP, "GDcompinfo", __FILE__, __LINE__);
2472 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
2473 : }
2474 :
2475 0 : free(metabuf);
2476 :
2477 : }
2478 0 : free(utlstr);
2479 0 : return (status);
2480 : }
2481 :
2482 :
2483 :
2484 :
2485 :
2486 :
2487 : /*----------------------------------------------------------------------------|
2488 : | BEGIN_PROLOG |
2489 : | |
2490 : | FUNCTION: GDfieldinfo |
2491 : | |
2492 : | DESCRIPTION: Retrieve information about a specific geolocation or data |
2493 : | field in the grid. |
2494 : | |
2495 : | |
2496 : | Return Value Type Units Description |
2497 : | ============ ====== ========= ===================================== |
2498 : | status intn return status (0) SUCCEED, (-1) FAIL |
2499 : | |
2500 : | INPUTS: |
2501 : | gridID int32 grid structure id |
2502 : | fieldname char name of field |
2503 : | |
2504 : | |
2505 : | OUTPUTS: |
2506 : | rank int32 rank of field (# of dims) |
2507 : | dims int32 field dimensions |
2508 : | numbertype int32 field number type |
2509 : | dimlist char field dimension list |
2510 : | |
2511 : | |
2512 : | OUTPUTS: |
2513 : | None |
2514 : | |
2515 : | NOTES: |
2516 : | |
2517 : | |
2518 : | Date Programmer Description |
2519 : | ====== ============ ================================================= |
2520 : | Jun 96 Joel Gales Original Programmer |
2521 : | Aug 96 Joel Gales Make metadata ODL compliant |
2522 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
2523 : | Feb 99 Abe Taaheri Changed memcpy to memmove to avoid overlapping |
2524 : | problem when copying strings |
2525 : | |
2526 : | END_PROLOG |
2527 : -----------------------------------------------------------------------------*/
2528 : intn
2529 0 : GDfieldinfo(int32 gridID, const char *fieldname, int32 * rank, int32 dims[],
2530 : int32 * numbertype, char *dimlist)
2531 :
2532 : {
2533 : intn i; /* Loop index */
2534 : intn status; /* routine return status variable */
2535 0 : intn statmeta = 0; /* EHgetmetavalue return status */
2536 :
2537 : int32 fid; /* HDF-EOS file ID */
2538 : int32 sdInterfaceID; /* HDF SDS interface ID */
2539 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2540 0 : int32 ndims = 0; /* Number of dimensions */
2541 : int32 slen[8]; /* Length of each entry in parsed string */
2542 : int32 dum; /* Dummy variable */
2543 : int32 xdim; /* X dim size */
2544 : int32 ydim; /* Y dim size */
2545 : int32 sdid; /* SDS id */
2546 :
2547 : char *metabuf; /* Pointer to structural metadata (SM) */
2548 : char *metaptrs[2]; /* Pointers to begin and end of SM section */
2549 : char gridname[80]; /* Grid Name */
2550 : char *utlstr; /* Utility string */
2551 : char *ptr[8]; /* String pointers for parsed string */
2552 : char dimstr[64]; /* Individual dimension entry string */
2553 :
2554 :
2555 : /* Allocate space for utility string */
2556 : /* --------------------------------- */
2557 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2558 0 : if(utlstr == NULL)
2559 : {
2560 0 : HEpush(DFE_NOSPACE,"GDfieldinfo", __FILE__, __LINE__);
2561 0 : return(-1);
2562 : }
2563 0 : *rank = -1;
2564 0 : *numbertype = -1;
2565 :
2566 0 : status = GDchkgdid(gridID, "GDfieldinfo", &fid, &sdInterfaceID, &dum);
2567 :
2568 0 : if (status == 0)
2569 : {
2570 :
2571 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
2572 :
2573 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
2574 : "DataField", metaptrs);
2575 0 : if(metabuf == NULL)
2576 : {
2577 0 : free(utlstr);
2578 0 : return(-1);
2579 : }
2580 :
2581 :
2582 : /* Search for field */
2583 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
2584 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
2585 :
2586 : /* If field found ... */
2587 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2588 : {
2589 :
2590 : /* Set endptr at end of dimension definition entry */
2591 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
2592 :
2593 : /* Get DataType string */
2594 0 : statmeta = EHgetmetavalue(metaptrs, "DataType", utlstr);
2595 :
2596 : /* Convert to numbertype code */
2597 0 : if (statmeta == 0)
2598 0 : *numbertype = EHnumstr(utlstr);
2599 : else
2600 : {
2601 0 : status = -1;
2602 0 : HEpush(DFE_GENAPP, "GDfieldinfo", __FILE__, __LINE__);
2603 0 : HEreport("\"DataType\" string not found in metadata.\n");
2604 : }
2605 :
2606 : /*
2607 : * Get DimList string and trim off leading and trailing parens
2608 : * "()"
2609 : */
2610 0 : statmeta = EHgetmetavalue(metaptrs, "DimList", utlstr);
2611 :
2612 0 : if (statmeta == 0)
2613 : {
2614 0 : memmove(utlstr, utlstr + 1, strlen(utlstr) - 2);
2615 0 : utlstr[strlen(utlstr) - 2] = 0;
2616 :
2617 : /* Parse trimmed DimList string and get rank */
2618 0 : ndims = EHparsestr(utlstr, ',', ptr, slen);
2619 0 : *rank = ndims;
2620 : }
2621 : else
2622 : {
2623 0 : status = -1;
2624 0 : HEpush(DFE_GENAPP, "GDfieldinfo", __FILE__, __LINE__);
2625 0 : HEreport("\"DimList\" string not found in metadata.\n");
2626 : }
2627 :
2628 :
2629 0 : if (status == 0)
2630 : {
2631 0 : status = GDgridinfo(gridID, &xdim, &ydim, NULL, NULL);
2632 :
2633 0 : for (i = 0; i < ndims; i++)
2634 : {
2635 0 : memcpy(dimstr, ptr[i] + 1, slen[i] - 2);
2636 0 : dimstr[slen[i] - 2] = 0;
2637 :
2638 0 : if (strcmp(dimstr, "XDim") == 0)
2639 : {
2640 0 : dims[i] = xdim;
2641 : }
2642 0 : else if (strcmp(dimstr, "YDim") == 0)
2643 : {
2644 0 : dims[i] = ydim;
2645 : }
2646 : else
2647 : {
2648 0 : dims[i] = GDdiminfo(gridID, dimstr);
2649 : }
2650 :
2651 :
2652 0 : if (dimlist != NULL)
2653 : {
2654 0 : if (i == 0)
2655 : {
2656 0 : dimlist[0] = 0;
2657 : }
2658 :
2659 0 : if (i > 0)
2660 : {
2661 0 : strcat(dimlist, ",");
2662 : }
2663 0 : strcat(dimlist, dimstr);
2664 : }
2665 : }
2666 :
2667 :
2668 0 : if (dims[0] == 0)
2669 : {
2670 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname,
2671 : &sdid, &dum, &dum, &dum, dims,
2672 : &dum);
2673 : }
2674 : }
2675 : }
2676 :
2677 0 : free(metabuf);
2678 : }
2679 :
2680 0 : if (*rank == -1)
2681 : {
2682 0 : status = -1;
2683 :
2684 0 : HEpush(DFE_GENAPP, "GDfieldinfo", __FILE__, __LINE__);
2685 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
2686 : }
2687 0 : free(utlstr);
2688 0 : return (status);
2689 : }
2690 :
2691 :
2692 :
2693 :
2694 :
2695 :
2696 : /*----------------------------------------------------------------------------|
2697 : | BEGIN_PROLOG |
2698 : | |
2699 : | FUNCTION: GDdeffield |
2700 : | |
2701 : | DESCRIPTION: Defines a new data field within the grid. |
2702 : | |
2703 : | |
2704 : | Return Value Type Units Description |
2705 : | ============ ====== ========= ===================================== |
2706 : | status intn return status (0) SUCCEED, (-1) FAIL |
2707 : | |
2708 : | INPUTS: |
2709 : | gridID int32 grid structure ID |
2710 : | fieldname char fieldname |
2711 : | dimlist char Dimension list (comma-separated list) |
2712 : | numbertype int32 field type |
2713 : | merge int32 merge code |
2714 : | |
2715 : | |
2716 : | OUTPUTS: |
2717 : | None |
2718 : | |
2719 : | NOTES: |
2720 : | |
2721 : | |
2722 : | Date Programmer Description |
2723 : | ====== ============ ================================================= |
2724 : | Jun 96 Joel Gales Original Programmer |
2725 : | Aug 96 Joel Gales Check name for ODL compliance |
2726 : | Sep 96 Joel Gales Make string array "dimbuf" dynamic |
2727 : | Sep 96 Joel Gales Add support for Block SOM (MISR) |
2728 : | Jan 97 Joel Gales Add support for tiling |
2729 : | Feb 99 Abe Taaheri Changed strcpy to memmove to avoid overlapping |
2730 : | problem when copying strings |
2731 : | |
2732 : | END_PROLOG |
2733 : -----------------------------------------------------------------------------*/
2734 : intn
2735 0 : GDdeffield(int32 gridID, const char *fieldname, const char *dimlist,
2736 : int32 numbertype, int32 merge)
2737 :
2738 : {
2739 : intn i; /* Loop index */
2740 : intn status; /* routine return status variable */
2741 : intn found; /* utility found flag */
2742 0 : intn foundNT = 0;/* found number type flag */
2743 0 : intn foundAllDim = 1; /* found all dimensions flag */
2744 0 : intn first = 1; /* first entry flag */
2745 :
2746 : int32 fid; /* HDF-EOS file ID */
2747 : int32 vgid; /* Geo/Data field Vgroup ID */
2748 : int32 sdInterfaceID; /* HDF SDS interface ID */
2749 : int32 sdid; /* SDS object ID */
2750 : int32 dimid; /* SDS dimension ID */
2751 : int32 gdVgrpID; /* Grid root Vgroup ID */
2752 : int32 dims[8]; /* Dimension size array */
2753 : int32 dimsize; /* Dimension size */
2754 0 : int32 rank = 0; /* Field rank */
2755 : int32 slen[32]; /* String length array */
2756 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2757 : int32 compcode; /* Compression code */
2758 : int32 tilecode; /* Tiling code */
2759 : int32 chunkFlag; /* Chunking (Tiling) flag */
2760 : int32 gID; /* GridID - offset */
2761 : int32 xdim; /* Grid X dimension */
2762 : int32 ydim; /* Grid Y dimension */
2763 : int32 projcode; /* Projection Code */
2764 :
2765 : float64 projparm[13]; /* Projection Parameters */
2766 :
2767 : char *dimbuf; /* Dimension buffer */
2768 : char *dimlist0; /* Auxiliary dimension list */
2769 : char *comma; /* Pointer to comma */
2770 : char *dimcheck; /* Dimension check buffer */
2771 : char utlbuf[512];/* Utility buffer */
2772 : char utlbuf2[256]; /* Utility buffer 1 */
2773 : char *ptr[32]; /* String pointer array */
2774 : char gridname[80]; /* Grid name */
2775 : char parmbuf[128]; /* Parameter string buffer */
2776 : char errbuf1[128]; /* Error buffer 1 */
2777 : char errbuf2[128]; /* Error buffer 2 */
2778 : static const char errmsg1[] = "Dimension: %d (size: %d) not divisible by ";
2779 : /* Tiling error message part 1 */
2780 : static const char errmsg2[] = "tile dimension (size: %d).\n";
2781 : /* Tiling error message part 2 */
2782 : char errmsg[128];/* Tiling error message */
2783 :
2784 : /* Valid number types */
2785 : static const uint16 good_number[10] = {
2786 : 3, 4, 5, 6, 20, 21, 22, 23, 24, 25
2787 : };
2788 :
2789 : comp_info c_info; /* Compression parameter structure */
2790 :
2791 : HDF_CHUNK_DEF chunkDef; /* Tiling structure */
2792 :
2793 0 : memset(&c_info, 0, sizeof(c_info));
2794 0 : memset(&chunkDef, 0, sizeof(chunkDef));
2795 :
2796 :
2797 : /* Setup error message strings */
2798 : /* --------------------------- */
2799 0 : strcpy(errbuf1, "GDXSDname array too small.\nPlease increase ");
2800 0 : strcat(errbuf1, "size of HDFE_NAMBUFSIZE in \"HdfEosDef.h\".\n");
2801 0 : strcpy(errbuf2, "GDXSDdims array too small.\nPlease increase ");
2802 0 : strcat(errbuf2, "size of HDFE_DIMBUFSIZE in \"HdfEosDef.h\".\n");
2803 :
2804 :
2805 : /* Build tiling dimension error message */
2806 : /* ------------------------------------ */
2807 0 : strcpy(errmsg, errmsg1);
2808 0 : strcat(errmsg, errmsg2);
2809 :
2810 : /*
2811 : * Check for proper grid ID and return HDF-EOS file ID, SDinterface ID,
2812 : * and grid root Vgroup ID
2813 : */
2814 0 : status = GDchkgdid(gridID, "GDdefinefield",
2815 : &fid, &sdInterfaceID, &gdVgrpID);
2816 :
2817 :
2818 0 : if (status == 0)
2819 : {
2820 : /* Remove offset from grid ID & get gridname */
2821 0 : gID = gridID % idOffset;
2822 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
2823 :
2824 :
2825 : /* Allocate space for dimension buffer and auxiliary dimension list */
2826 : /* ---------------------------------------------------------------- */
2827 0 : dimbuf = (char *) calloc(strlen(dimlist) + 64, 1);
2828 0 : if(dimbuf == NULL)
2829 : {
2830 0 : HEpush(DFE_NOSPACE,"GDdeffield", __FILE__, __LINE__);
2831 0 : return(-1);
2832 : }
2833 0 : dimlist0 = (char *) calloc(strlen(dimlist) + 64, 1);
2834 0 : if(dimlist0 == NULL)
2835 : {
2836 0 : HEpush(DFE_NOSPACE,"GDdeffield", __FILE__, __LINE__);
2837 0 : free(dimbuf);
2838 0 : return(-1);
2839 : }
2840 :
2841 :
2842 : /* Get Grid and Projection info */
2843 : /* ---------------------------- */
2844 0 : status = GDgridinfo(gridID, &xdim, &ydim, NULL, NULL);
2845 0 : status = GDprojinfo(gridID, &projcode, NULL, NULL, projparm);
2846 :
2847 :
2848 : /* Setup Block Dimension if "Blocked" SOM projection */
2849 : /* ------------------------------------------------- */
2850 0 : if (projcode == GCTP_SOM && (int32) projparm[11] != 0)
2851 : {
2852 0 : dimsize = GDdiminfo(gridID, "SOMBlockDim");
2853 :
2854 : /* If "SOMBlockDim" not yet defined then do it */
2855 0 : if (dimsize == -1)
2856 : {
2857 0 : GDdefdim(gridID, "SOMBlockDim", (int32) projparm[11]);
2858 : }
2859 :
2860 : /* If not 1D field then prepend to dimension list */
2861 0 : if (strchr(dimlist, ',') != NULL)
2862 : {
2863 0 : strcpy(dimbuf, "SOMBlockDim,");
2864 0 : strcat(dimbuf, dimlist);
2865 : }
2866 : else
2867 : {
2868 0 : strcpy(dimbuf, dimlist);
2869 : }
2870 : }
2871 : else
2872 : {
2873 : /* If not "Blocked" SOM then just copy dim list to dim buffer */
2874 0 : strcpy(dimbuf, dimlist);
2875 : }
2876 :
2877 : /*
2878 : * Copy dimension buffer to auxiliary dimlist and append a comma to
2879 : * end of dimension list.
2880 : */
2881 0 : strcpy(dimlist0, dimbuf);
2882 0 : strcat(dimbuf, ",");
2883 :
2884 :
2885 : /* Find comma */
2886 : /* ---------- */
2887 0 : comma = strchr(dimbuf, ',');
2888 :
2889 :
2890 : /*
2891 : * Loop through entries in dimension list to make sure they are
2892 : * defined in grid
2893 : */
2894 0 : while (comma != NULL)
2895 : {
2896 : /* Copy dimension list entry to dimcheck */
2897 : /* ------------------------------------- */
2898 0 : dimcheck = (char *) calloc(comma - dimbuf + 1, 1);
2899 0 : if(dimcheck == NULL)
2900 : {
2901 0 : HEpush(DFE_NOSPACE,"GDdeffield", __FILE__, __LINE__);
2902 0 : free(dimbuf);
2903 0 : free(dimlist0);
2904 0 : return(-1);
2905 : }
2906 0 : memcpy(dimcheck, dimbuf, comma - dimbuf);
2907 :
2908 :
2909 : /* Get Dimension Size */
2910 : /* ------------------ */
2911 0 : if (strcmp(dimcheck, "XDim") == 0)
2912 : {
2913 : /* If "XDim" then use xdim value for grid definition */
2914 : /* ------------------------------------------------- */
2915 0 : dimsize = xdim;
2916 0 : found = 1;
2917 0 : dims[rank] = dimsize;
2918 0 : rank++;
2919 : }
2920 0 : else if (strcmp(dimcheck, "YDim") == 0)
2921 : {
2922 : /* If "YDim" then use ydim value for grid definition */
2923 : /* ------------------------------------------------- */
2924 0 : dimsize = ydim;
2925 0 : found = 1;
2926 0 : dims[rank] = dimsize;
2927 0 : rank++;
2928 : }
2929 : else
2930 : {
2931 : /* "Regular" Dimension */
2932 : /* ------------------- */
2933 0 : dimsize = GDdiminfo(gridID, dimcheck);
2934 0 : if (dimsize != -1)
2935 : {
2936 0 : found = 1;
2937 0 : dims[rank] = dimsize;
2938 0 : rank++;
2939 : }
2940 : else
2941 : {
2942 0 : found = 0;
2943 : }
2944 : }
2945 :
2946 :
2947 : /*
2948 : * If dimension list entry not found - set error return status,
2949 : * append name to utility buffer for error report
2950 : */
2951 0 : if (found == 0)
2952 : {
2953 0 : status = -1;
2954 0 : foundAllDim = 0;
2955 0 : if (first == 1)
2956 : {
2957 0 : strcpy(utlbuf, dimcheck);
2958 : }
2959 : else
2960 : {
2961 0 : strcat(utlbuf, ",");
2962 0 : strcat(utlbuf, dimcheck);
2963 : }
2964 0 : first = 0;
2965 : }
2966 :
2967 : /*
2968 : * Go to next dimension entry, find next comma, & free up
2969 : * dimcheck buffer
2970 : */
2971 0 : memmove(dimbuf, comma + 1, strlen(comma)-1);
2972 0 : dimbuf[strlen(comma)-1]= 0;
2973 0 : comma = strchr(dimbuf, ',');
2974 0 : free(dimcheck);
2975 : }
2976 0 : free(dimbuf);
2977 :
2978 : /* Check fieldname length */
2979 : /* ---------------------- */
2980 0 : if (status == 0)
2981 : {
2982 : /* if ((intn) strlen(fieldname) > MAX_NC_NAME - 7)
2983 : ** this was changed because HDF4.1r3 made a change in the
2984 : ** hlimits.h file. We have notified NCSA and asked to have
2985 : ** it made the same as in previous versions of HDF
2986 : ** see ncr 26314. DaW Apr 2000
2987 : */
2988 0 : if((intn) strlen(fieldname) > (256 - 7))
2989 : {
2990 0 : status = -1;
2991 0 : HEpush(DFE_GENAPP, "GDdefinefield", __FILE__, __LINE__);
2992 0 : HEreport("Fieldname \"%s\" too long.\n", fieldname);
2993 : }
2994 : }
2995 :
2996 : /* Check for valid numbertype */
2997 : /* -------------------------- */
2998 0 : if (status == 0)
2999 : {
3000 0 : for (i = 0; i < 10; i++)
3001 : {
3002 0 : if (numbertype == good_number[i])
3003 : {
3004 0 : foundNT = 1;
3005 0 : break;
3006 : }
3007 : }
3008 :
3009 0 : if (foundNT == 0)
3010 : {
3011 0 : HEpush(DFE_BADNUMTYPE, "GDdeffield", __FILE__, __LINE__);
3012 0 : HEreport("Invalid number type: %d (%s).\n",
3013 : numbertype, fieldname);
3014 0 : status = -1;
3015 : }
3016 : }
3017 :
3018 :
3019 : /* Define Field */
3020 : /* ------------ */
3021 0 : if (status == 0)
3022 : {
3023 : /* Get Field Vgroup id, compression code, & tiling code */
3024 : /* -------------------------------------------------- */
3025 0 : vgid = GDXGrid[gID].VIDTable[0];
3026 0 : compcode = GDXGrid[gID].compcode;
3027 0 : tilecode = GDXGrid[gID].tilecode;
3028 :
3029 :
3030 : /* SDS Interface (Multi-dim fields) */
3031 : /* -------------------------------- */
3032 :
3033 :
3034 : /*
3035 : * If rank is less than or equal to 3 (and greater than 1) and
3036 : * AUTOMERGE is set and the first dimension is not appendable and
3037 : * the compression code is set to none then ...
3038 : */
3039 0 : if (rank >= 2 && rank <= 3 && merge == HDFE_AUTOMERGE &&
3040 0 : dims[0] != 0 && compcode == HDFE_COMP_NONE &&
3041 : tilecode == HDFE_NOTILE)
3042 : {
3043 :
3044 : /* Find first empty slot in external combination array */
3045 : /* --------------------------------------------------- */
3046 0 : i = 0;
3047 0 : while (GDXSDcomb[5 * i] != 0)
3048 : {
3049 0 : i++;
3050 : }
3051 :
3052 : /*
3053 : * Store dimensions, grid root Vgroup ID, and number type in
3054 : * external combination array "GDXSDcomb"
3055 : */
3056 0 : if (rank == 2)
3057 : {
3058 : /* If 2-dim field then set lowest dimension to 1 */
3059 : /* --------------------------------------------- */
3060 0 : GDXSDcomb[5 * i] = 1;
3061 0 : GDXSDcomb[5 * i + 1] = dims[0];
3062 0 : GDXSDcomb[5 * i + 2] = dims[1];
3063 : }
3064 : else
3065 : {
3066 0 : GDXSDcomb[5 * i] = dims[0];
3067 0 : GDXSDcomb[5 * i + 1] = dims[1];
3068 0 : GDXSDcomb[5 * i + 2] = dims[2];
3069 : }
3070 :
3071 0 : GDXSDcomb[5 * i + 3] = gdVgrpID;
3072 0 : GDXSDcomb[5 * i + 4] = numbertype;
3073 :
3074 :
3075 : /* Concatenate fieldname with combined name string */
3076 : /* ----------------------------------------------- */
3077 0 : if ((intn) strlen(GDXSDname) +
3078 0 : (intn) strlen(fieldname) + 2 < HDFE_NAMBUFSIZE)
3079 : {
3080 0 : strcat(GDXSDname, fieldname);
3081 0 : strcat(GDXSDname, ",");
3082 : }
3083 : else
3084 : {
3085 : /* GDXSDname array too small! */
3086 : /* -------------------------- */
3087 0 : HEpush(DFE_GENAPP, "GDdefinefield",
3088 : __FILE__, __LINE__);
3089 0 : HEreport(errbuf1);
3090 0 : status = -1;
3091 0 : free(dimlist0);
3092 0 : return (status);
3093 : }
3094 :
3095 :
3096 : /*
3097 : * If 2-dim field then set lowest dimension (in 3-dim array)
3098 : * to "ONE"
3099 : */
3100 0 : if (rank == 2)
3101 : {
3102 0 : if ((intn) strlen(GDXSDdims) + 5 < HDFE_DIMBUFSIZE)
3103 : {
3104 0 : strcat(GDXSDdims, "ONE,");
3105 : }
3106 : else
3107 : {
3108 : /* GDXSDdims array too small! */
3109 : /* -------------------------- */
3110 0 : HEpush(DFE_GENAPP, "GDdefinefield",
3111 : __FILE__, __LINE__);
3112 0 : HEreport(errbuf2);
3113 0 : status = -1;
3114 0 : free(dimlist0);
3115 0 : return (status);
3116 : }
3117 : }
3118 :
3119 :
3120 : /*
3121 : * Concatanate field dimlist to merged dimlist and separate
3122 : * fields with semi-colon.
3123 : */
3124 0 : if ((intn) strlen(GDXSDdims) +
3125 0 : (intn) strlen(dimlist0) + 2 < HDFE_DIMBUFSIZE)
3126 : {
3127 0 : strcat(GDXSDdims, dimlist0);
3128 0 : strcat(GDXSDdims, ";");
3129 : }
3130 : else
3131 : {
3132 : /* GDXSDdims array too small! */
3133 : /* -------------------------- */
3134 0 : HEpush(DFE_GENAPP, "GDdefinefield",
3135 : __FILE__, __LINE__);
3136 0 : HEreport(errbuf2);
3137 0 : status = -1;
3138 0 : free(dimlist0);
3139 0 : return (status);
3140 : }
3141 :
3142 : } /* End Multi-Dim Merge Section */
3143 : else
3144 : {
3145 :
3146 : /* Multi-Dim No Merge Section */
3147 : /* ========================== */
3148 :
3149 :
3150 : /* Check that field dims are divisible by tile dims */
3151 : /* ------------------------------------------------ */
3152 0 : if (tilecode == HDFE_TILE)
3153 : {
3154 0 : for (i = 0; i < GDXGrid[gID].tilerank; i++)
3155 : {
3156 0 : if ((dims[i] % GDXGrid[gID].tiledims[i]) != 0)
3157 : {
3158 0 : HEpush(DFE_GENAPP, "GDdeffield",
3159 : __FILE__, __LINE__);
3160 0 : HEreport(errmsg,
3161 : i, dims[i], GDXGrid[gID].tiledims[0]);
3162 0 : status = -1;
3163 : }
3164 : }
3165 :
3166 0 : if (status == -1)
3167 : {
3168 0 : free(dimlist0);
3169 0 : return (status);
3170 : }
3171 : }
3172 :
3173 :
3174 : /* Create SDS dataset */
3175 : /* ------------------ */
3176 0 : sdid = SDcreate(sdInterfaceID, fieldname,
3177 : numbertype, rank, dims);
3178 :
3179 :
3180 : /* Store Dimension Names in SDS */
3181 : /* ---------------------------- */
3182 0 : rank = EHparsestr(dimlist0, ',', ptr, slen);
3183 0 : for (i = 0; i < rank; i++)
3184 : {
3185 : /* Dimension name = Swathname:Dimname */
3186 : /* ---------------------------------- */
3187 0 : memcpy(utlbuf, ptr[i], slen[i]);
3188 0 : utlbuf[slen[i]] = 0;
3189 0 : strcat(utlbuf, ":");
3190 0 : strcat(utlbuf, gridname);
3191 :
3192 0 : dimid = SDgetdimid(sdid, i);
3193 0 : SDsetdimname(dimid, utlbuf);
3194 : }
3195 :
3196 :
3197 : /* Setup Compression */
3198 : /* ----------------- */
3199 0 : if (compcode == HDFE_COMP_NBIT)
3200 : {
3201 0 : c_info.nbit.nt = numbertype;
3202 0 : c_info.nbit.sign_ext = GDXGrid[gID].compparm[0];
3203 0 : c_info.nbit.fill_one = GDXGrid[gID].compparm[1];
3204 0 : c_info.nbit.start_bit = GDXGrid[gID].compparm[2];
3205 0 : c_info.nbit.bit_len = GDXGrid[gID].compparm[3];
3206 : }
3207 0 : else if (compcode == HDFE_COMP_SKPHUFF)
3208 : {
3209 0 : c_info.skphuff.skp_size = (intn) DFKNTsize(numbertype);
3210 : }
3211 0 : else if (compcode == HDFE_COMP_DEFLATE)
3212 : {
3213 0 : c_info.deflate.level = GDXGrid[gID].compparm[0];
3214 : }
3215 :
3216 :
3217 : /* If field is compressed w/o tiling then call SDsetcompress */
3218 : /* --------------------------------------------------------- */
3219 0 : if (compcode != HDFE_COMP_NONE && tilecode == HDFE_NOTILE)
3220 : {
3221 0 : /* status = */ SDsetcompress(sdid, (comp_coder_t) compcode, &c_info);
3222 : }
3223 :
3224 :
3225 : /* Setup Tiling */
3226 : /* ------------ */
3227 0 : if (tilecode == HDFE_TILE)
3228 : {
3229 : /* Tiling without Compression */
3230 : /* -------------------------- */
3231 0 : if (compcode == HDFE_COMP_NONE)
3232 : {
3233 :
3234 : /* Setup chunk lengths */
3235 : /* ------------------- */
3236 0 : for (i = 0; i < GDXGrid[gID].tilerank; i++)
3237 : {
3238 0 : chunkDef.chunk_lengths[i] =
3239 0 : GDXGrid[gID].tiledims[i];
3240 : }
3241 :
3242 0 : chunkFlag = HDF_CHUNK;
3243 : }
3244 :
3245 : /* Tiling with Compression */
3246 : /* ----------------------- */
3247 : else
3248 : {
3249 : /* Setup chunk lengths */
3250 : /* ------------------- */
3251 0 : for (i = 0; i < GDXGrid[gID].tilerank; i++)
3252 : {
3253 0 : chunkDef.comp.chunk_lengths[i] =
3254 0 : GDXGrid[gID].tiledims[i];
3255 : }
3256 :
3257 :
3258 : /* Setup chunk flag & chunk compression type */
3259 : /* ----------------------------------------- */
3260 0 : chunkFlag = HDF_CHUNK | HDF_COMP;
3261 0 : chunkDef.comp.comp_type = compcode;
3262 :
3263 :
3264 : /* Setup chunk compression parameters */
3265 : /* ---------------------------------- */
3266 0 : if (compcode == HDFE_COMP_SKPHUFF)
3267 : {
3268 0 : chunkDef.comp.cinfo.skphuff.skp_size =
3269 0 : c_info.skphuff.skp_size;
3270 : }
3271 0 : else if (compcode == HDFE_COMP_DEFLATE)
3272 : {
3273 0 : chunkDef.comp.cinfo.deflate.level =
3274 0 : c_info.deflate.level;
3275 : }
3276 : }
3277 :
3278 : /* Call SDsetchunk routine */
3279 : /* ----------------------- */
3280 0 : /* status = */ SDsetchunk(sdid, chunkDef, chunkFlag);
3281 : }
3282 :
3283 :
3284 : /* Attach to Vgroup */
3285 : /* ---------------- */
3286 0 : Vaddtagref(vgid, DFTAG_NDG, SDidtoref(sdid));
3287 :
3288 :
3289 : /* Store SDS dataset IDs */
3290 : /* --------------------- */
3291 :
3292 : /* Allocate space for the SDS ID array */
3293 : /* ----------------------------------- */
3294 0 : if (GDXGrid[gID].nSDS > 0)
3295 : {
3296 : /* Array already exists therefore reallocate */
3297 : /* ----------------------------------------- */
3298 0 : GDXGrid[gID].sdsID = (int32 *)
3299 0 : realloc((void *) GDXGrid[gID].sdsID,
3300 0 : (GDXGrid[gID].nSDS + 1) * 4);
3301 0 : if(GDXGrid[gID].sdsID == NULL)
3302 : {
3303 0 : HEpush(DFE_NOSPACE,"GDdeffield", __FILE__, __LINE__);
3304 0 : free(dimlist0);
3305 0 : return(-1);
3306 : }
3307 : }
3308 : else
3309 : {
3310 : /* Array does not exist */
3311 : /* -------------------- */
3312 0 : GDXGrid[gID].sdsID = (int32 *) calloc(1, 4);
3313 0 : if(GDXGrid[gID].sdsID == NULL)
3314 : {
3315 0 : HEpush(DFE_NOSPACE,"GDdeffield", __FILE__, __LINE__);
3316 0 : free(dimlist0);
3317 0 : return(-1);
3318 : }
3319 : }
3320 :
3321 : /* Store SDS ID in array & increment count */
3322 : /* --------------------------------------- */
3323 0 : GDXGrid[gID].sdsID[GDXGrid[gID].nSDS] = sdid;
3324 0 : GDXGrid[gID].nSDS++;
3325 :
3326 : }
3327 :
3328 :
3329 : /* Setup metadata string */
3330 : /* --------------------- */
3331 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%s%s", fieldname, ":", dimlist0);
3332 :
3333 :
3334 : /* Setup compression metadata */
3335 : /* -------------------------- */
3336 0 : if (compcode != HDFE_COMP_NONE)
3337 : {
3338 0 : snprintf(utlbuf2, sizeof(utlbuf2),
3339 : "%s%s",
3340 : ":\n\t\t\t\tCompressionType=", HDFcomp[compcode]);
3341 :
3342 0 : switch (compcode)
3343 : {
3344 0 : case HDFE_COMP_NBIT:
3345 :
3346 0 : snprintf(parmbuf, sizeof(parmbuf),
3347 : "%s%d,%d,%d,%d%s",
3348 : "\n\t\t\t\tCompressionParams=(",
3349 : GDXGrid[gID].compparm[0],
3350 : GDXGrid[gID].compparm[1],
3351 : GDXGrid[gID].compparm[2],
3352 : GDXGrid[gID].compparm[3], ")");
3353 0 : strcat(utlbuf2, parmbuf);
3354 0 : break;
3355 :
3356 :
3357 0 : case HDFE_COMP_DEFLATE:
3358 :
3359 0 : snprintf(parmbuf, sizeof(parmbuf),
3360 : "%s%d",
3361 : "\n\t\t\t\tDeflateLevel=",
3362 : GDXGrid[gID].compparm[0]);
3363 0 : strcat(utlbuf2, parmbuf);
3364 0 : break;
3365 : }
3366 0 : strcat(utlbuf, utlbuf2);
3367 : }
3368 :
3369 :
3370 :
3371 :
3372 : /* Setup tiling metadata */
3373 : /* --------------------- */
3374 0 : if (tilecode == HDFE_TILE)
3375 : {
3376 0 : if (compcode == HDFE_COMP_NONE)
3377 : {
3378 0 : snprintf(utlbuf2, sizeof(utlbuf2), "%s%d",
3379 : ":\n\t\t\t\tTilingDimensions=(",
3380 0 : (int)GDXGrid[gID].tiledims[0]);
3381 : }
3382 : else
3383 : {
3384 0 : snprintf(utlbuf2, sizeof(utlbuf2), "%s%d",
3385 : "\n\t\t\t\tTilingDimensions=(",
3386 0 : (int)GDXGrid[gID].tiledims[0]);
3387 : }
3388 :
3389 0 : for (i = 1; i < GDXGrid[gID].tilerank; i++)
3390 : {
3391 0 : snprintf(parmbuf, sizeof(parmbuf), ",%d", (int)GDXGrid[gID].tiledims[i]);
3392 0 : strcat(utlbuf2, parmbuf);
3393 : }
3394 0 : strcat(utlbuf2, ")");
3395 0 : strcat(utlbuf, utlbuf2);
3396 : }
3397 :
3398 :
3399 : /* Insert field metadata within File Structural Metadata */
3400 : /* ----------------------------------------------------- */
3401 0 : status = EHinsertmeta(sdInterfaceID, gridname, "g", 4L,
3402 : utlbuf, &numbertype);
3403 :
3404 : }
3405 0 : free(dimlist0);
3406 :
3407 : }
3408 :
3409 : /* If all dimensions not found then report error */
3410 : /* --------------------------------------------- */
3411 0 : if (foundAllDim == 0)
3412 : {
3413 0 : HEpush(DFE_GENAPP, "GDdeffield", __FILE__, __LINE__);
3414 0 : HEreport("Dimension(s): \"%s\" not found (%s).\n",
3415 : utlbuf, fieldname);
3416 0 : status = -1;
3417 : }
3418 :
3419 0 : return (status);
3420 : }
3421 :
3422 :
3423 :
3424 :
3425 : /*----------------------------------------------------------------------------|
3426 : | BEGIN_PROLOG |
3427 : | |
3428 : | FUNCTION: GDwritefieldmeta |
3429 : | |
3430 : | DESCRIPTION: Writes field meta data for an existing grid field not |
3431 : | defined within the grid API routine "GDdeffield". |
3432 : | |
3433 : | Return Value Type Units Description |
3434 : | ============ ====== ========= ===================================== |
3435 : | status intn return status (0) SUCCEED, (-1) FAIL |
3436 : | |
3437 : | INPUTS: |
3438 : | gridID int32 grid structure ID |
3439 : | fieldname char fieldname |
3440 : | dimlist char Dimension list (comma-separated list) |
3441 : | numbertype int32 field type |
3442 : | |
3443 : | |
3444 : | OUTPUTS: |
3445 : | None |
3446 : | |
3447 : | NOTES: |
3448 : | |
3449 : | |
3450 : | Date Programmer Description |
3451 : | ====== ============ ================================================= |
3452 : | Jun 96 Joel Gales Original Programmer |
3453 : | |
3454 : | END_PROLOG |
3455 : -----------------------------------------------------------------------------*/
3456 : intn
3457 0 : GDwritefieldmeta(int32 gridID, const char *fieldname, const char *dimlist,
3458 : int32 numbertype)
3459 : {
3460 0 : intn status = 0; /* routine return status variable */
3461 :
3462 : int32 sdInterfaceID; /* HDF SDS interface ID */
3463 : int32 dum; /* dummy variable */
3464 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
3465 :
3466 : char utlbuf[256];/* Utility buffer */
3467 : char gridname[80]; /* Grid name */
3468 :
3469 :
3470 0 : status = GDchkgdid(gridID, "GDwritefieldmeta", &dum, &sdInterfaceID,
3471 : &dum);
3472 :
3473 0 : if (status == 0)
3474 : {
3475 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%s%s", fieldname, ":", dimlist);
3476 :
3477 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
3478 0 : status = EHinsertmeta(sdInterfaceID, gridname, "g", 4L,
3479 : utlbuf, &numbertype);
3480 : }
3481 0 : return (status);
3482 : }
3483 :
3484 :
3485 :
3486 :
3487 : /*----------------------------------------------------------------------------|
3488 : | BEGIN_PROLOG |
3489 : | |
3490 : | FUNCTION: GDSDfldsrch |
3491 : | |
3492 : | DESCRIPTION: Retrieves information from SDS fields |
3493 : | |
3494 : | |
3495 : | Return Value Type Units Description |
3496 : | ============ ====== ========= ===================================== |
3497 : | status intn return status (0) SUCCEED, (-1) FAIL |
3498 : | |
3499 : | INPUTS: |
3500 : | gridID int32 grid structure ID |
3501 : | sdInterfaceID int32 SD interface ID |
3502 : | fieldname char field name |
3503 : | |
3504 : | |
3505 : | OUTPUTS: |
3506 : | sdid int32 SD element ID |
3507 : | rankSDS int32 Rank of SDS |
3508 : | rankFld int32 True rank of field (merging) |
3509 : | offset int32 Offset of field within merged field |
3510 : | dims int32 Dimensions of field |
3511 : | solo int32 Solo field flag |
3512 : | |
3513 : | NOTES: |
3514 : | |
3515 : | |
3516 : | Date Programmer Description |
3517 : | ====== ============ ================================================= |
3518 : | Jun 96 Joel Gales Original Programmer |
3519 : | Aug 96 Joel Gales Make metadata ODL compliant |
3520 : | |
3521 : | END_PROLOG |
3522 : -----------------------------------------------------------------------------*/
3523 : static intn
3524 0 : GDSDfldsrch(int32 gridID, int32 sdInterfaceID, const char *fieldname,
3525 : int32 * sdid, int32 * rankSDS, int32 * rankFld, int32 * offset,
3526 : int32 dims[], int32 * solo)
3527 : {
3528 : intn i; /* Loop index */
3529 0 : intn status = -1;/* routine return status variable */
3530 :
3531 : int32 gID; /* GridID - offset */
3532 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
3533 : int32 dum; /* Dummy variable */
3534 : int32 dums[128]; /* Dummy array */
3535 : int32 attrIndex; /* Attribute l_index */
3536 :
3537 : char name[2048]; /* Merged-Field Names */
3538 : char gridname[80]; /* Grid Name */
3539 : char *utlstr;/* Utility string */
3540 : char *metabuf; /* Pointer to structural metadata (SM) */
3541 : char *metaptrs[2];/* Pointers to begin and end of SM section */
3542 : #ifdef broken_logic
3543 : char *oldmetaptr; /* Pointer within SM section */
3544 : char *metaptr; /* Pointer within SM section */
3545 : #endif
3546 :
3547 : /* Allocate space for utility string */
3548 : /* --------------------------------- */
3549 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
3550 0 : if(utlstr == NULL)
3551 : {
3552 0 : HEpush(DFE_NOSPACE,"GDSDfldsrch", __FILE__, __LINE__);
3553 0 : return(-1);
3554 : }
3555 : /* Set solo flag to 0 (no) */
3556 : /* ----------------------- */
3557 0 : *solo = 0;
3558 :
3559 :
3560 : /* Compute "reduced" grid ID */
3561 : /* ------------------------- */
3562 0 : gID = gridID % idOffset;
3563 :
3564 :
3565 : /* Loop through all SDSs in grid */
3566 : /* ----------------------------- */
3567 0 : for (i = 0; i < GDXGrid[gID].nSDS; i++)
3568 : {
3569 : /* If active SDS ... */
3570 : /* ----------------- */
3571 0 : if (GDXGrid[gID].sdsID[i] != 0)
3572 : {
3573 : /* Get SDS ID, name, rankSDS, and dimensions */
3574 : /* ----------------------------------------- */
3575 0 : *sdid = GDXGrid[gID].sdsID[i];
3576 0 : SDgetinfo(*sdid, name, rankSDS, dims, &dum, &dum);
3577 0 : *rankFld = *rankSDS;
3578 :
3579 :
3580 : /* If merged field ... */
3581 : /* ------------------- */
3582 0 : if (strstr(name, "MRGFLD_") == &name[0])
3583 : {
3584 : /* Get grid name */
3585 : /* ------------- */
3586 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
3587 :
3588 :
3589 : /* Get pointers to "MergedFields" section within SM */
3590 : /* ------------------------------------------------ */
3591 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
3592 : "MergedFields", metaptrs);
3593 0 : if(metabuf == NULL)
3594 : {
3595 0 : free(utlstr);
3596 0 : return(-1);
3597 : }
3598 :
3599 : #ifdef broken_logic
3600 : /* Initialize metaptr to beg. of section */
3601 : /* ------------------------------------- */
3602 : metaptr = metaptrs[0];
3603 :
3604 :
3605 : /* Store metaptr in order to recover */
3606 : /* --------------------------------- */
3607 : oldmetaptr = metaptr;
3608 :
3609 :
3610 : /* Search for Merged field name */
3611 : /* ---------------------------- */
3612 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "MergedFieldName=\"",
3613 : name, "\"\n");
3614 : metaptr = strstr(metaptr, utlstr);
3615 :
3616 :
3617 : /* If not found check for old metadata */
3618 : /* ----------------------------------- */
3619 : if (metaptr == NULL)
3620 : {
3621 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "OBJECT=\"", name, "\"\n");
3622 : metaptr = strstr(oldmetaptr, utlstr);
3623 : }
3624 : #endif
3625 :
3626 : /* Get field list and strip off leading and trailing quotes */
3627 : /* -------------------------------------------------------- */
3628 0 : EHgetmetavalue(metaptrs, "FieldList", name);
3629 0 : memmove(name, name + 1, strlen(name) - 2);
3630 0 : name[strlen(name) - 2] = 0;
3631 :
3632 :
3633 : /* Search for desired field within merged field list */
3634 : /* ------------------------------------------------- */
3635 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"");
3636 0 : dum = EHstrwithin(utlstr, name, ',');
3637 :
3638 0 : free(metabuf);
3639 : }
3640 : else
3641 : {
3642 : /* If solo (unmerged) check if SDS name matches fieldname */
3643 : /* ------------------------------------------------------ */
3644 0 : dum = EHstrwithin(fieldname, name, ',');
3645 0 : if (dum != -1)
3646 : {
3647 0 : *solo = 1;
3648 0 : *offset = 0;
3649 : }
3650 : }
3651 :
3652 :
3653 :
3654 : /* If field found ... */
3655 : /* ------------------ */
3656 0 : if (dum != -1)
3657 : {
3658 0 : status = 0;
3659 :
3660 : /* If merged field ... */
3661 : /* ------------------- */
3662 0 : if (*solo == 0)
3663 : {
3664 : /* Get "Field Offsets" SDS attribute l_index */
3665 : /* --------------------------------------- */
3666 0 : attrIndex = SDfindattr(*sdid, "Field Offsets");
3667 :
3668 : /*
3669 : * If attribute exists then get offset of desired field
3670 : * within merged field
3671 : */
3672 0 : if (attrIndex != -1)
3673 : {
3674 0 : SDreadattr(*sdid, attrIndex, (VOIDP) dums);
3675 0 : *offset = dums[dum];
3676 : }
3677 :
3678 :
3679 : /* Get "Field Dims" SDS attribute l_index */
3680 : /* ------------------------------------ */
3681 0 : attrIndex = SDfindattr(*sdid, "Field Dims");
3682 :
3683 : /*
3684 : * If attribute exists then get 0th dimension of desired
3685 : * field within merged field
3686 : */
3687 0 : if (attrIndex != -1)
3688 : {
3689 0 : SDreadattr(*sdid, attrIndex, (VOIDP) dums);
3690 0 : dims[0] = dums[dum];
3691 :
3692 : /* If this dimension = 1 then field is really 2 dim */
3693 : /* ------------------------------------------------ */
3694 0 : if (dums[dum] == 1)
3695 : {
3696 0 : *rankFld = 2;
3697 : }
3698 : }
3699 : }
3700 :
3701 :
3702 : /* Break out of SDS loop */
3703 : /* --------------------- */
3704 0 : break;
3705 : } /* End of found field section */
3706 : }
3707 : else
3708 : {
3709 : /* First non-active SDS signifies no more, break out of SDS loop */
3710 : /* ------------------------------------------------------------- */
3711 0 : break;
3712 : }
3713 : }
3714 0 : free(utlstr);
3715 0 : return (status);
3716 : }
3717 :
3718 :
3719 :
3720 :
3721 : /*----------------------------------------------------------------------------|
3722 : | BEGIN_PROLOG |
3723 : | |
3724 : | FUNCTION: GDwrrdfield |
3725 : | |
3726 : | DESCRIPTION: Writes/Reads fields |
3727 : | |
3728 : | |
3729 : | Return Value Type Units Description |
3730 : | ============ ====== ========= ===================================== |
3731 : | status intn return status (0) SUCCEED, (-1) FAIL |
3732 : | |
3733 : | INPUTS: |
3734 : | gridID int32 grid structure ID |
3735 : | fieldname char fieldname |
3736 : | code char Write/Read code (w/r) |
3737 : | start int32 start array |
3738 : | stride int32 stride array |
3739 : | edge int32 edge array |
3740 : | datbuf void data buffer for read |
3741 : | |
3742 : | |
3743 : | OUTPUTS: |
3744 : | datbuf void data buffer for write |
3745 : | |
3746 : | |
3747 : | NOTES: |
3748 : | |
3749 : | |
3750 : | Date Programmer Description |
3751 : | ====== ============ ================================================= |
3752 : | Jun 96 Joel Gales Original Programmer |
3753 : | Feb 97 Joel Gales Stride = 1 HDF compression workaround |
3754 : | |
3755 : | END_PROLOG |
3756 : -----------------------------------------------------------------------------*/
3757 : static intn
3758 0 : GDwrrdfield(int32 gridID, const char *fieldname, const char *code,
3759 : int32 start[], int32 stride[], int32 edge[], VOIDP datbuf)
3760 :
3761 : {
3762 : intn i; /* Loop index */
3763 0 : intn status = 0; /* routine return status variable */
3764 :
3765 : int32 fid; /* HDF-EOS file ID */
3766 : int32 sdInterfaceID; /* HDF SDS interface ID */
3767 : int32 sdid; /* SDS ID */
3768 : int32 dum; /* Dummy variable */
3769 : int32 rankSDS; /* Rank of SDS */
3770 : int32 rankFld; /* Rank of field */
3771 :
3772 : int32 offset[8]; /* I/O offset (start) */
3773 : int32 incr[8]; /* I/O increment (stride) */
3774 : int32 count[8]; /* I/O count (edge) */
3775 : int32 dims[8]; /* Field/SDS dimensions */
3776 : int32 mrgOffset; /* Merged field offset */
3777 : int32 strideOne; /* Strides = 1 flag */
3778 :
3779 :
3780 : /* Check for valid grid ID */
3781 : /* ----------------------- */
3782 0 : status = GDchkgdid(gridID, "GDwrrdfield", &fid, &sdInterfaceID, &dum);
3783 :
3784 :
3785 0 : if (status == 0)
3786 : {
3787 : /* Check that field exists */
3788 : /* ----------------------- */
3789 0 : status = GDfieldinfo(gridID, fieldname, &rankSDS, dims, &dum, NULL);
3790 :
3791 :
3792 0 : if (status != 0)
3793 : {
3794 0 : HEpush(DFE_GENAPP, "GDwrrdfield", __FILE__, __LINE__);
3795 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
3796 0 : status = -1;
3797 :
3798 : }
3799 :
3800 :
3801 0 : if (status == 0)
3802 : {
3803 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
3804 : &rankSDS, &rankFld, &mrgOffset, dims, &dum);
3805 :
3806 :
3807 : /* Set I/O offset Section */
3808 : /* ---------------------- */
3809 :
3810 : /*
3811 : * If start == NULL (default) set I/O offset of 0th field to
3812 : * offset within merged field (if any) and the rest to 0
3813 : */
3814 0 : if (start == NULL)
3815 : {
3816 0 : for (i = 0; i < rankSDS; i++)
3817 : {
3818 0 : offset[i] = 0;
3819 : }
3820 0 : offset[0] = mrgOffset;
3821 : }
3822 : else
3823 : {
3824 : /*
3825 : * ... otherwise set I/O offset to user values, adjusting the
3826 : * 0th field with the merged field offset (if any)
3827 : */
3828 0 : if (rankFld == rankSDS)
3829 : {
3830 0 : for (i = 0; i < rankSDS; i++)
3831 : {
3832 0 : offset[i] = start[i];
3833 : }
3834 0 : offset[0] += mrgOffset;
3835 : }
3836 : else
3837 : {
3838 : /*
3839 : * If field really 2-dim merged in 3-dim field then set
3840 : * 0th field offset to merge offset and then next two to
3841 : * the user values
3842 : */
3843 0 : for (i = 0; i < rankFld; i++)
3844 : {
3845 0 : offset[i + 1] = start[i];
3846 : }
3847 0 : offset[0] = mrgOffset;
3848 : }
3849 : }
3850 :
3851 :
3852 :
3853 : /* Set I/O stride Section */
3854 : /* ---------------------- */
3855 :
3856 : /*
3857 : * If stride == NULL (default) set I/O stride to 1
3858 : */
3859 0 : if (stride == NULL)
3860 : {
3861 0 : for (i = 0; i < rankSDS; i++)
3862 : {
3863 0 : incr[i] = 1;
3864 : }
3865 : }
3866 : else
3867 : {
3868 : /*
3869 : * ... otherwise set I/O stride to user values
3870 : */
3871 0 : if (rankFld == rankSDS)
3872 : {
3873 0 : for (i = 0; i < rankSDS; i++)
3874 : {
3875 0 : incr[i] = stride[i];
3876 : }
3877 : }
3878 : else
3879 : {
3880 : /*
3881 : * If field really 2-dim merged in 3-dim field then set
3882 : * 0th field stride to 1 and then next two to the user
3883 : * values.
3884 : */
3885 0 : for (i = 0; i < rankFld; i++)
3886 : {
3887 0 : incr[i + 1] = stride[i];
3888 : }
3889 0 : incr[0] = 1;
3890 : }
3891 : }
3892 :
3893 :
3894 :
3895 : /* Set I/O count Section */
3896 : /* --------------------- */
3897 :
3898 : /*
3899 : * If edge == NULL (default) set I/O count to number of remaining
3900 : * entries (dims - start) / increment. Note that 0th field
3901 : * offset corrected for merged field offset (if any).
3902 : */
3903 0 : if (edge == NULL)
3904 : {
3905 0 : for (i = 1; i < rankSDS; i++)
3906 : {
3907 0 : count[i] = (dims[i] - offset[i]) / incr[i];
3908 : }
3909 0 : count[0] = (dims[0] - (offset[0] - mrgOffset)) / incr[0];
3910 : }
3911 : else
3912 : {
3913 : /*
3914 : * ... otherwise set I/O count to user values
3915 : */
3916 0 : if (rankFld == rankSDS)
3917 : {
3918 0 : for (i = 0; i < rankSDS; i++)
3919 : {
3920 0 : count[i] = edge[i];
3921 : }
3922 : }
3923 : else
3924 : {
3925 : /*
3926 : * If field really 2-dim merged in 3-dim field then set
3927 : * 0th field count to 1 and then next two to the user
3928 : * values.
3929 : */
3930 0 : for (i = 0; i < rankFld; i++)
3931 : {
3932 0 : count[i + 1] = edge[i];
3933 : }
3934 0 : count[0] = 1;
3935 : }
3936 : }
3937 :
3938 :
3939 : /* Perform I/O with relevant HDF I/O routine */
3940 : /* ----------------------------------------- */
3941 0 : if (strcmp(code, "w") == 0)
3942 : {
3943 : /* Set strideOne to true (1) */
3944 : /* ------------------------- */
3945 0 : strideOne = 1;
3946 :
3947 :
3948 : /* If incr[i] != 1 set strideOne to false (0) */
3949 : /* ------------------------------------------ */
3950 0 : for (i = 0; i < rankSDS; i++)
3951 : {
3952 0 : if (incr[i] != 1)
3953 : {
3954 0 : strideOne = 0;
3955 0 : break;
3956 : }
3957 : }
3958 :
3959 :
3960 : /*
3961 : * If strideOne is true use NULL parameter for stride. This
3962 : * is a work-around to HDF compression problem
3963 : */
3964 0 : if (strideOne == 1)
3965 : {
3966 0 : status = SDwritedata(sdid, offset, NULL, count,
3967 : (VOIDP) datbuf);
3968 : }
3969 : else
3970 : {
3971 0 : status = SDwritedata(sdid, offset, incr, count,
3972 : (VOIDP) datbuf);
3973 : }
3974 : }
3975 : else
3976 : {
3977 0 : status = SDreaddata(sdid, offset, incr, count,
3978 : (VOIDP) datbuf);
3979 : }
3980 : }
3981 : }
3982 :
3983 0 : return (status);
3984 : }
3985 :
3986 :
3987 : /*----------------------------------------------------------------------------|
3988 : | BEGIN_PROLOG |
3989 : | |
3990 : | FUNCTION: GDwritefield |
3991 : | |
3992 : | DESCRIPTION: Writes data to a grid field. |
3993 : | |
3994 : | |
3995 : | Return Value Type Units Description |
3996 : | ============ ====== ========= ===================================== |
3997 : | status intn return status (0) SUCCEED, (-1) FAIL |
3998 : | |
3999 : | INPUTS: |
4000 : | gridID int32 grid structure ID |
4001 : | fieldname char fieldname |
4002 : | start int32 start array |
4003 : | stride int32 stride array |
4004 : | edge int32 edge array |
4005 : | |
4006 : | |
4007 : | OUTPUTS: |
4008 : | data void data buffer for write |
4009 : | |
4010 : | NOTES: |
4011 : | |
4012 : | |
4013 : | Date Programmer Description |
4014 : | ====== ============ ================================================= |
4015 : | Jun 96 Joel Gales Original Programmer |
4016 : | |
4017 : | END_PROLOG |
4018 : -----------------------------------------------------------------------------*/
4019 : intn
4020 0 : GDwritefield(int32 gridID, const char *fieldname,
4021 : int32 start[], int32 stride[], int32 edge[], VOIDP data)
4022 :
4023 : {
4024 0 : intn status = 0; /* routine return status variable */
4025 :
4026 0 : status = GDwrrdfield(gridID, fieldname, "w", start, stride, edge,
4027 : data);
4028 0 : return (status);
4029 : }
4030 :
4031 :
4032 :
4033 :
4034 :
4035 : /*----------------------------------------------------------------------------|
4036 : | BEGIN_PROLOG |
4037 : | |
4038 : | FUNCTION: GDreadfield |
4039 : | |
4040 : | DESCRIPTION: Reads data from a grid field. |
4041 : | |
4042 : | |
4043 : | Return Value Type Units Description |
4044 : | ============ ====== ========= ===================================== |
4045 : | status intn return status (0) SUCCEED, (-1) FAIL |
4046 : | |
4047 : | INPUTS: |
4048 : | gridID int32 grid structure ID |
4049 : | fieldname char fieldname |
4050 : | start int32 start array |
4051 : | stride int32 stride array |
4052 : | edge int32 edge array |
4053 : | buffer void data buffer for read |
4054 : | |
4055 : | |
4056 : | OUTPUTS: |
4057 : | None |
4058 : | |
4059 : | NOTES: |
4060 : | |
4061 : | |
4062 : | Date Programmer Description |
4063 : | ====== ============ ================================================= |
4064 : | Jun 96 Joel Gales Original Programmer |
4065 : | |
4066 : | END_PROLOG |
4067 : -----------------------------------------------------------------------------*/
4068 : intn
4069 0 : GDreadfield(int32 gridID, const char *fieldname,
4070 : int32 start[], int32 stride[], int32 edge[], VOIDP buffer)
4071 :
4072 : {
4073 0 : intn status = 0; /* routine return status variable */
4074 :
4075 0 : status = GDwrrdfield(gridID, fieldname, "r", start, stride, edge,
4076 : buffer);
4077 0 : return (status);
4078 : }
4079 :
4080 :
4081 :
4082 :
4083 : /*----------------------------------------------------------------------------|
4084 : | BEGIN_PROLOG |
4085 : | |
4086 : | FUNCTION: GDwrrdattr |
4087 : | |
4088 : | DESCRIPTION: |
4089 : | |
4090 : | |
4091 : | Return Value Type Units Description |
4092 : | ============ ====== ========= ===================================== |
4093 : | status intn return status (0) SUCCEED, (-1) FAIL |
4094 : | |
4095 : | INPUTS: |
4096 : | gridID int32 grid structure ID |
4097 : | attrname char attribute name |
4098 : | numbertype int32 attribute HDF numbertype |
4099 : | count int32 Number of attribute elements |
4100 : | wrcode char Read/Write Code "w/r" |
4101 : | datbuf void I/O buffer |
4102 : | |
4103 : | OUTPUTS: |
4104 : | datbuf |
4105 : | |
4106 : | NOTES: |
4107 : | |
4108 : | |
4109 : | Date Programmer Description |
4110 : | ====== ============ ================================================= |
4111 : | Jun 96 Joel Gales Original Programmer |
4112 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
4113 : | |
4114 : | END_PROLOG |
4115 : -----------------------------------------------------------------------------*/
4116 : static intn
4117 0 : GDwrrdattr(int32 gridID, const char *attrname, int32 numbertype, int32 count,
4118 : const char *wrcode, VOIDP datbuf)
4119 :
4120 : {
4121 : intn status; /* routine return status variable */
4122 :
4123 : int32 fid; /* HDF-EOS file ID */
4124 : int32 attrVgrpID; /* Grid attribute ID */
4125 : int32 dum; /* dummy variable */
4126 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
4127 :
4128 :
4129 : /* Check Grid id */
4130 0 : status = GDchkgdid(gridID, "GDwrrdattr", &fid, &dum, &dum);
4131 :
4132 0 : if (status == 0)
4133 : {
4134 : /* Perform Attribute I/O */
4135 : /* --------------------- */
4136 0 : attrVgrpID = GDXGrid[gridID % idOffset].VIDTable[1];
4137 0 : status = EHattr(fid, attrVgrpID, attrname, numbertype, count,
4138 : wrcode, datbuf);
4139 : }
4140 0 : return (status);
4141 : }
4142 :
4143 :
4144 :
4145 : /*----------------------------------------------------------------------------|
4146 : | BEGIN_PROLOG |
4147 : | |
4148 : | FUNCTION: GDwriteattr |
4149 : | |
4150 : | DESCRIPTION: Writes/updates attribute in a grid. |
4151 : | |
4152 : | |
4153 : | Return Value Type Units Description |
4154 : | ============ ====== ========= ===================================== |
4155 : | status intn return status (0) SUCCEED, (-1) FAIL |
4156 : | |
4157 : | INPUTS: |
4158 : | gridID int32 grid structure ID |
4159 : | attrname char attribute name |
4160 : | numbertype int32 attribute HDF numbertype |
4161 : | count int32 Number of attribute elements |
4162 : | datbuf void I/O buffer |
4163 : | |
4164 : | OUTPUTS: |
4165 : | None |
4166 : | |
4167 : | NOTES: |
4168 : | |
4169 : | |
4170 : | Date Programmer Description |
4171 : | ====== ============ ================================================= |
4172 : | Jun 96 Joel Gales Original Programmer |
4173 : | |
4174 : | END_PROLOG |
4175 : -----------------------------------------------------------------------------*/
4176 : intn
4177 0 : GDwriteattr(int32 gridID, const char *attrname, int32 numbertype, int32 count,
4178 : VOIDP datbuf)
4179 : {
4180 0 : intn status = 0; /* routine return status variable */
4181 :
4182 : /* Call GDwrrdattr routine to write attribute */
4183 : /* ------------------------------------------ */
4184 0 : status = GDwrrdattr(gridID, attrname, numbertype, count, "w", datbuf);
4185 :
4186 0 : return (status);
4187 : }
4188 :
4189 :
4190 :
4191 : /*----------------------------------------------------------------------------|
4192 : | BEGIN_PROLOG |
4193 : | |
4194 : | FUNCTION: GDreadattr |
4195 : | |
4196 : | DESCRIPTION: Reads attribute from a grid. |
4197 : | |
4198 : | |
4199 : | Return Value Type Units Description |
4200 : | ============ ====== ========= ===================================== |
4201 : | status intn return status (0) SUCCEED, (-1) FAIL |
4202 : | |
4203 : | INPUTS: |
4204 : | gridID int32 grid structure ID |
4205 : | attrname char attribute name |
4206 : | |
4207 : | OUTPUTS: |
4208 : | datbuf void I/O buffer |
4209 : | |
4210 : | NOTES: |
4211 : | |
4212 : | |
4213 : | Date Programmer Description |
4214 : | ====== ============ ================================================= |
4215 : | Jun 96 Joel Gales Original Programmer |
4216 : | |
4217 : | END_PROLOG |
4218 : -----------------------------------------------------------------------------*/
4219 : intn
4220 0 : GDreadattr(int32 gridID, const char *attrname, VOIDP datbuf)
4221 : {
4222 0 : intn status = 0; /* routine return status variable */
4223 0 : int32 dum = 0; /* dummy variable */
4224 :
4225 : /* Call GDwrrdattr routine to read attribute */
4226 : /* ----------------------------------------- */
4227 0 : status = GDwrrdattr(gridID, attrname, dum, dum, "r", datbuf);
4228 :
4229 0 : return (status);
4230 : }
4231 :
4232 :
4233 :
4234 :
4235 :
4236 : /*----------------------------------------------------------------------------|
4237 : | BEGIN_PROLOG |
4238 : | |
4239 : | FUNCTION: GDattrinfo |
4240 : | |
4241 : | DESCRIPTION: |
4242 : | |
4243 : | |
4244 : | Return Value Type Units Description |
4245 : | ============ ====== ========= ===================================== |
4246 : | status intn return status (0) SUCCEED, (-1) FAIL |
4247 : | |
4248 : | INPUTS: |
4249 : | gridID int32 grid structure ID |
4250 : | attrname char attribute name |
4251 : | |
4252 : | OUTPUTS: |
4253 : | numbertype int32 attribute HDF numbertype |
4254 : | count int32 Number of attribute elements |
4255 : | |
4256 : | |
4257 : | OUTPUTS: |
4258 : | None |
4259 : | |
4260 : | NOTES: |
4261 : | |
4262 : | |
4263 : | Date Programmer Description |
4264 : | ====== ============ ================================================= |
4265 : | Jun 96 Joel Gales Original Programmer |
4266 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
4267 : | |
4268 : | END_PROLOG |
4269 : -----------------------------------------------------------------------------*/
4270 : intn
4271 0 : GDattrinfo(int32 gridID, const char *attrname, int32 * numbertype, int32 * count)
4272 : {
4273 0 : intn status = 0; /* routine return status variable */
4274 :
4275 : int32 fid; /* HDF-EOS file ID */
4276 : int32 attrVgrpID; /* Grid attribute ID */
4277 : int32 dum; /* dummy variable */
4278 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
4279 :
4280 0 : status = GDchkgdid(gridID, "GDattrinfo", &fid, &dum, &dum);
4281 :
4282 0 : attrVgrpID = GDXGrid[gridID % idOffset].VIDTable[1];
4283 :
4284 0 : status = EHattrinfo(fid, attrVgrpID, attrname, numbertype,
4285 : count);
4286 :
4287 0 : return (status);
4288 : }
4289 :
4290 :
4291 :
4292 :
4293 :
4294 :
4295 : /*----------------------------------------------------------------------------|
4296 : | BEGIN_PROLOG |
4297 : | |
4298 : | FUNCTION: GDinqattrs |
4299 : | |
4300 : | DESCRIPTION: |
4301 : | |
4302 : | |
4303 : | Return Value Type Units Description |
4304 : | ============ ====== ========= ===================================== |
4305 : | nattr int32 Number of attributes in swath struct |
4306 : | |
4307 : | INPUTS: |
4308 : | grid ID int32 grid structure ID |
4309 : | |
4310 : | OUTPUTS: |
4311 : | attrnames char Attribute names in swath struct |
4312 : | (Comma-separated list) |
4313 : | strbufsize int32 Attributes name list string length |
4314 : | |
4315 : | OUTPUTS: |
4316 : | None |
4317 : | |
4318 : | NOTES: |
4319 : | |
4320 : | |
4321 : | Date Programmer Description |
4322 : | ====== ============ ================================================= |
4323 : | Jun 96 Joel Gales Original Programmer |
4324 : | Oct 96 Joel Gales Initialize nattr |
4325 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
4326 : | |
4327 : | END_PROLOG |
4328 : -----------------------------------------------------------------------------*/
4329 : int32
4330 0 : GDinqattrs(int32 gridID, char *attrnames, int32 * strbufsize)
4331 : {
4332 : intn status; /* routine return status variable */
4333 :
4334 : int32 fid; /* HDF-EOS file ID */
4335 : int32 attrVgrpID; /* Grid attribute ID */
4336 : int32 dum; /* dummy variable */
4337 0 : int32 nattr = 0; /* Number of attributes */
4338 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
4339 :
4340 :
4341 : /* Check Grid id */
4342 0 : status = GDchkgdid(gridID, "GDinqattrs", &fid, &dum, &dum);
4343 :
4344 0 : if (status == 0)
4345 : {
4346 0 : attrVgrpID = GDXGrid[gridID % idOffset].VIDTable[1];
4347 0 : nattr = EHattrcat(fid, attrVgrpID, attrnames, strbufsize);
4348 : }
4349 :
4350 0 : return (nattr);
4351 : }
4352 :
4353 :
4354 :
4355 :
4356 :
4357 :
4358 : #define REMQUOTE(x) do { \
4359 : char* l_x = x; \
4360 : const size_t l_x_len = strlen(l_x); \
4361 : if (l_x_len >= 2 && l_x[0] == '"' && l_x[l_x_len - 1] == '"') {\
4362 : memmove(l_x, l_x + 1, l_x_len - 2); \
4363 : l_x[l_x_len - 2] = 0; \
4364 : } \
4365 : } while(0)
4366 :
4367 :
4368 : /*----------------------------------------------------------------------------|
4369 : | BEGIN_PROLOG |
4370 : | |
4371 : | FUNCTION: GDinqdims |
4372 : | |
4373 : | DESCRIPTION: Retrieve information about all dimensions defined in a grid. |
4374 : | |
4375 : | |
4376 : | Return Value Type Units Description |
4377 : | ============ ====== ========= ===================================== |
4378 : | nDim int32 Number of defined dimensions |
4379 : | |
4380 : | INPUTS: |
4381 : | gridID int32 grid structure ID |
4382 : | |
4383 : | OUTPUTS: |
4384 : | dimnames char Dimension names (comma-separated) |
4385 : | dims int32 Dimension values |
4386 : | |
4387 : | |
4388 : | OUTPUTS: |
4389 : | None |
4390 : | |
4391 : | NOTES: |
4392 : | |
4393 : | |
4394 : | Date Programmer Description |
4395 : | ====== ============ ================================================= |
4396 : | Jun 96 Joel Gales Original Programmer |
4397 : | Aug 96 Joel Gales Make metadata ODL compliant |
4398 : | Feb 97 Joel Gales Set nDim to -1 if status = -1 |
4399 : | |
4400 : | END_PROLOG |
4401 : -----------------------------------------------------------------------------*/
4402 : int32
4403 0 : GDinqdims(int32 gridID, char *dimnames, int32 dims[])
4404 : {
4405 : intn status; /* routine return status variable */
4406 :
4407 : int32 fid; /* HDF-EOS file ID */
4408 : int32 sdInterfaceID; /* HDF SDS interface ID */
4409 : int32 gdVgrpID; /* Grid root Vgroup ID */
4410 : int32 size; /* Dimension size */
4411 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
4412 0 : int32 nDim = 0; /* Number of dimensions */
4413 :
4414 : char *metabuf; /* Pointer to structural metadata (SM) */
4415 : char *metaptrs[2];/* Pointers to begin and end of SM section */
4416 : char gridname[80]; /* Grid Name */
4417 : char *utlstr;/* Utility string */
4418 :
4419 : /* Allocate space for utility string */
4420 : /* --------------------------------- */
4421 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
4422 0 : if(utlstr == NULL)
4423 : {
4424 0 : HEpush(DFE_NOSPACE,"GDinqdims", __FILE__, __LINE__);
4425 0 : return(-1);
4426 : }
4427 : /* Check for valid grid id */
4428 : /* ----------------------- */
4429 0 : status = GDchkgdid(gridID, "GDinqdims", &fid, &sdInterfaceID, &gdVgrpID);
4430 :
4431 0 : if (status == 0)
4432 : {
4433 : /* If dimension names or sizes are requested */
4434 : /* ----------------------------------------- */
4435 0 : if (dimnames != NULL || dims != NULL)
4436 : {
4437 : /* Get grid name */
4438 : /* ------------- */
4439 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
4440 :
4441 :
4442 : /* Get pointers to "Dimension" section within SM */
4443 : /* --------------------------------------------- */
4444 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
4445 : "Dimension", metaptrs);
4446 0 : if(metabuf == NULL)
4447 : {
4448 0 : free(utlstr);
4449 0 : return(-1);
4450 : }
4451 :
4452 :
4453 : /* If dimension names are requested then "clear" name buffer */
4454 : /* --------------------------------------------------------- */
4455 0 : if (dimnames != NULL)
4456 : {
4457 0 : dimnames[0] = 0;
4458 : }
4459 :
4460 0 : while (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
4461 : {
4462 0 : strcpy(utlstr, "\t\tOBJECT=");
4463 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
4464 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
4465 : {
4466 : /* Get Dimension Name */
4467 : /* ------------------ */
4468 0 : if (dimnames != NULL)
4469 : {
4470 : /* Check 1st for old meta data then new */
4471 : /* ------------------------------------ */
4472 0 : EHgetmetavalue(metaptrs, "OBJECT", utlstr);
4473 0 : if (utlstr[0] != '"')
4474 : {
4475 0 : metaptrs[0] =
4476 0 : strstr(metaptrs[0], "\t\t\t\tDimensionName=");
4477 0 : EHgetmetavalue(metaptrs, "DimensionName", utlstr);
4478 : }
4479 :
4480 : /* Strip off double quotes */
4481 : /* ----------------------- */
4482 0 : memmove(utlstr, utlstr + 1, strlen(utlstr) - 2);
4483 0 : utlstr[strlen(utlstr) - 2] = 0;
4484 :
4485 0 : if (nDim > 0)
4486 : {
4487 0 : strcat(dimnames, ",");
4488 : }
4489 0 : strcat(dimnames, utlstr);
4490 : }
4491 :
4492 : /* Get Dimension Size */
4493 : /* ------------------ */
4494 0 : if (dims != NULL)
4495 : {
4496 0 : EHgetmetavalue(metaptrs, "Size", utlstr);
4497 0 : size = atoi(utlstr);
4498 0 : dims[nDim] = size;
4499 : }
4500 0 : nDim++;
4501 : }
4502 : }
4503 0 : free(metabuf);
4504 :
4505 : }
4506 : }
4507 :
4508 :
4509 : /* Set nDim to -1 if error status exists */
4510 : /* ------------------------------------- */
4511 0 : if (status == -1)
4512 : {
4513 0 : nDim = -1;
4514 : }
4515 0 : free(utlstr);
4516 0 : return (nDim);
4517 : }
4518 :
4519 :
4520 :
4521 :
4522 :
4523 :
4524 : /*----------------------------------------------------------------------------|
4525 : | BEGIN_PROLOG |
4526 : | |
4527 : | FUNCTION: GDinqfields |
4528 : | |
4529 : | DESCRIPTION: Retrieve information about all data fields defined in a grid. |
4530 : | |
4531 : | |
4532 : | Return Value Type Units Description |
4533 : | ============ ====== ========= ===================================== |
4534 : | nFld int32 Number of fields in swath |
4535 : | |
4536 : | INPUTS: |
4537 : | gridID int32 grid structure ID |
4538 : | |
4539 : | |
4540 : | OUTPUTS: |
4541 : | fieldlist char Field names (comma-separated) |
4542 : | rank int32 Array of ranks |
4543 : | numbertype int32 Array of HDF number types |
4544 : | |
4545 : | NOTES: |
4546 : | |
4547 : | |
4548 : | Date Programmer Description |
4549 : | ====== ============ ================================================= |
4550 : | Jun 96 Joel Gales Original Programmer |
4551 : | Aug 96 Joel Gales Make metadata ODL compliant |
4552 : | Feb 97 Joel Gales Set nFld to -1 if status = -1 |
4553 : | |
4554 : | END_PROLOG |
4555 : -----------------------------------------------------------------------------*/
4556 : int32
4557 0 : GDinqfields(int32 gridID, char *fieldlist, int32 rank[],
4558 : int32 numbertype[])
4559 : {
4560 : intn status; /* routine return status variable */
4561 :
4562 : int32 fid; /* HDF-EOS file ID */
4563 : int32 sdInterfaceID; /* HDF SDS interface ID */
4564 : int32 gdVgrpID; /* Grid root Vgroup ID */
4565 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
4566 0 : int32 nFld = 0; /* Number of mappings */
4567 : int32 slen[8]; /* String length array */
4568 :
4569 : char *metabuf; /* Pointer to structural metadata (SM) */
4570 : char *metaptrs[2];/* Pointers to begin and end of SM section */
4571 : char gridname[80]; /* Grid Name */
4572 : char *utlstr;/* Utility string */
4573 : char *ptr[8]; /* String pointer array */
4574 :
4575 : /* Allocate space for utility string */
4576 : /* --------------------------------- */
4577 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
4578 0 : if(utlstr == NULL)
4579 : {
4580 0 : HEpush(DFE_NOSPACE,"GDinqfields", __FILE__, __LINE__);
4581 0 : return(-1);
4582 : }
4583 : /* Check for valid grid id */
4584 : /* ----------------------- */
4585 0 : status = GDchkgdid(gridID, "GDinqfields", &fid, &sdInterfaceID, &gdVgrpID);
4586 0 : if (status == 0)
4587 : {
4588 :
4589 : /* If field names, ranks, or number types desired ... */
4590 : /* --------------------------------------------------- */
4591 0 : if (fieldlist != NULL || rank != NULL || numbertype != NULL)
4592 : {
4593 : /* Get grid name */
4594 : /* ------------- */
4595 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
4596 :
4597 :
4598 : /* Get pointers to "DataField" section within SM */
4599 : /* --------------------------------------------- */
4600 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
4601 : "DataField", metaptrs);
4602 0 : if(metabuf == NULL)
4603 : {
4604 0 : free(utlstr);
4605 0 : return(-1);
4606 : }
4607 :
4608 :
4609 : /* If field names are desired then "clear" name buffer */
4610 : /* --------------------------------------------------- */
4611 0 : if (fieldlist != NULL)
4612 : {
4613 0 : fieldlist[0] = 0;
4614 : }
4615 :
4616 :
4617 : /* Begin loop through mapping entries in metadata */
4618 : /* ---------------------------------------------- */
4619 : while (1)
4620 : {
4621 : /* Search for OBJECT string */
4622 : /* ------------------------ */
4623 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
4624 :
4625 :
4626 : /* If found within "Data" Field metadata section .. */
4627 : /* ------------------------------------------------ */
4628 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
4629 : {
4630 : /* Get Fieldnames (if desired) */
4631 : /* --------------------------- */
4632 0 : if (fieldlist != NULL)
4633 : {
4634 : /* Check 1st for old meta data then new */
4635 : /* ------------------------------------ */
4636 0 : EHgetmetavalue(metaptrs, "OBJECT", utlstr);
4637 :
4638 : /*
4639 : * If OBJECT value begins with double quote then old
4640 : * metadata, field name is OBJECT value. Otherwise
4641 : * search for "DataFieldName" string
4642 : */
4643 :
4644 0 : if (utlstr[0] != '"')
4645 : {
4646 0 : strcpy(utlstr, "\t\t\t\t");
4647 0 : strcat(utlstr, "DataFieldName");
4648 0 : strcat(utlstr, "=");
4649 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
4650 0 : EHgetmetavalue(metaptrs, "DataFieldName", utlstr);
4651 : }
4652 :
4653 : /* Strip off double quotes */
4654 : /* ----------------------- */
4655 0 : REMQUOTE(utlstr);
4656 :
4657 :
4658 : /* Add to fieldlist */
4659 : /* ---------------- */
4660 0 : if (nFld > 0)
4661 : {
4662 0 : strcat(fieldlist, ",");
4663 : }
4664 0 : strcat(fieldlist, utlstr);
4665 :
4666 : }
4667 : /* Get Numbertype */
4668 0 : if (numbertype != NULL)
4669 : {
4670 0 : EHgetmetavalue(metaptrs, "DataType", utlstr);
4671 0 : numbertype[nFld] = EHnumstr(utlstr);
4672 : }
4673 : /*
4674 : * Get Rank (if desired) by counting # of dimensions in
4675 : * "DimList" string
4676 : */
4677 0 : if (rank != NULL)
4678 : {
4679 0 : EHgetmetavalue(metaptrs, "DimList", utlstr);
4680 0 : rank[nFld] = EHparsestr(utlstr, ',', ptr, slen);
4681 : }
4682 : /* Increment number of fields */
4683 0 : nFld++;
4684 : }
4685 : else
4686 : /* No more fields found */
4687 : {
4688 : break;
4689 : }
4690 : }
4691 0 : free(metabuf);
4692 : }
4693 : }
4694 :
4695 : /* Set nFld to -1 if error status exists */
4696 : /* ------------------------------------- */
4697 0 : if (status == -1)
4698 : {
4699 0 : nFld = -1;
4700 : }
4701 0 : free(utlstr);
4702 0 : return (nFld);
4703 : }
4704 :
4705 :
4706 :
4707 :
4708 :
4709 : /*----------------------------------------------------------------------------|
4710 : | BEGIN_PROLOG |
4711 : | |
4712 : | FUNCTION: GDnentries |
4713 : | |
4714 : | DESCRIPTION: Returns number of entries and descriptive string buffer |
4715 : | size for a specified entity. |
4716 : | |
4717 : | |
4718 : | Return Value Type Units Description |
4719 : | ============ ====== ========= ===================================== |
4720 : | nEntries int32 Number of entries |
4721 : | |
4722 : | INPUTS: |
4723 : | gridID int32 grid structure ID |
4724 : | entrycode int32 Entry code |
4725 : | HDFE_NENTDIM (0) |
4726 : | HDFE_NENTDFLD (4) |
4727 : | |
4728 : | |
4729 : | OUTPUTS: |
4730 : | strbufsize int32 Length of comma-separated list |
4731 : | (Does not include null-terminator |
4732 : | |
4733 : | NOTES: |
4734 : | |
4735 : | |
4736 : | Date Programmer Description |
4737 : | ====== ============ ================================================= |
4738 : | Jun 96 Joel Gales Original Programmer |
4739 : | Aug 96 Joel Gales Make metadata ODL compliant |
4740 : | Feb 97 Joel Gales Set nEntries to -1 if status = -1 |
4741 : | |
4742 : | END_PROLOG |
4743 : -----------------------------------------------------------------------------*/
4744 : int32
4745 0 : GDnentries(int32 gridID, int32 entrycode, int32 * strbufsize)
4746 :
4747 : {
4748 : intn status; /* routine return status variable */
4749 : intn i; /* Loop index */
4750 :
4751 : int32 fid; /* HDF-EOS file ID */
4752 : int32 sdInterfaceID; /* HDF SDS interface ID */
4753 : int32 gdVgrpID; /* Grid root Vgroup ID */
4754 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
4755 0 : int32 nEntries = 0; /* Number of entries */
4756 : int32 metaflag; /* Old (0), New (1) metadata flag) */
4757 0 : int32 nVal = 0; /* Number of strings to search for */
4758 :
4759 0 : char *metabuf = NULL; /* Pointer to structural metadata (SM) */
4760 : char *metaptrs[2];/* Pointers to begin and end of SM section */
4761 : char gridname[80]; /* Grid Name */
4762 : char *utlstr;/* Utility string */
4763 : char valName[2][32]; /* Strings to search for */
4764 :
4765 : /* Allocate space for utility string */
4766 : /* --------------------------------- */
4767 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
4768 0 : if(utlstr == NULL)
4769 : {
4770 0 : HEpush(DFE_NOSPACE,"GDnentries", __FILE__, __LINE__);
4771 0 : return(-1);
4772 : }
4773 0 : status = GDchkgdid(gridID, "GDnentries", &fid, &sdInterfaceID, &gdVgrpID);
4774 :
4775 0 : if (status == 0)
4776 : {
4777 : /* Get grid name */
4778 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
4779 :
4780 : /* Zero out string buffer size */
4781 0 : *strbufsize = 0;
4782 :
4783 :
4784 : /*
4785 : * Get pointer to relevant section within SM and Get names of
4786 : * metadata strings to inquire about
4787 : */
4788 0 : switch (entrycode)
4789 : {
4790 0 : case HDFE_NENTDIM:
4791 : {
4792 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
4793 : "Dimension", metaptrs);
4794 0 : if(metabuf == NULL)
4795 : {
4796 0 : free(utlstr);
4797 0 : return(-1);
4798 : }
4799 :
4800 0 : nVal = 1;
4801 0 : strcpy(&valName[0][0], "DimensionName");
4802 : }
4803 0 : break;
4804 :
4805 0 : case HDFE_NENTDFLD:
4806 : {
4807 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
4808 : "DataField", metaptrs);
4809 0 : if(metabuf == NULL)
4810 : {
4811 0 : free(utlstr);
4812 0 : return(-1);
4813 : }
4814 :
4815 0 : nVal = 1;
4816 0 : strcpy(&valName[0][0], "DataFieldName");
4817 : }
4818 0 : break;
4819 : }
4820 :
4821 :
4822 : /*
4823 : * Check for presence of 'GROUP="' string If found then old metadata,
4824 : * search on OBJECT string
4825 : */
4826 0 : metaflag = (strstr(metabuf, "GROUP=\"") == NULL) ? 1 : 0;
4827 0 : if (metaflag == 0)
4828 : {
4829 0 : nVal = 1;
4830 0 : strcpy(&valName[0][0], "\t\tOBJECT");
4831 : }
4832 :
4833 :
4834 : /* Begin loop through entries in metadata */
4835 : /* -------------------------------------- */
4836 : while (1)
4837 : {
4838 : /* Search for first string */
4839 0 : strcpy(utlstr, &valName[0][0]);
4840 0 : strcat(utlstr, "=");
4841 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
4842 :
4843 : /* If found within relevant metadata section ... */
4844 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
4845 : {
4846 0 : for (i = 0; i < nVal; i++)
4847 : {
4848 : /*
4849 : * Get all string values Don't count quotes
4850 : */
4851 0 : EHgetmetavalue(metaptrs, &valName[i][0], utlstr);
4852 0 : *strbufsize += (int32)strlen(utlstr) - 2;
4853 : }
4854 : /* Increment number of entries */
4855 0 : nEntries++;
4856 :
4857 : /* Go to end of OBJECT */
4858 0 : metaptrs[0] = strstr(metaptrs[0], "END_OBJECT");
4859 : }
4860 : else
4861 : /* No more entries found */
4862 : {
4863 : break;
4864 : }
4865 : }
4866 0 : free(metabuf);
4867 :
4868 :
4869 : /* Count comma separators & slashes (if mappings) */
4870 : /* ---------------------------------------------- */
4871 0 : if (nEntries > 0)
4872 : {
4873 0 : *strbufsize += nEntries - 1;
4874 0 : *strbufsize += (nVal - 1) * nEntries;
4875 : }
4876 : }
4877 :
4878 :
4879 : /* Set nEntries to -1 if error status exists */
4880 : /* ----------------------------------------- */
4881 0 : if (status == -1)
4882 : {
4883 0 : nEntries = -1;
4884 : }
4885 :
4886 0 : free(utlstr);
4887 0 : return (nEntries);
4888 : }
4889 :
4890 :
4891 :
4892 :
4893 :
4894 : /*----------------------------------------------------------------------------|
4895 : | BEGIN_PROLOG |
4896 : | |
4897 : | FUNCTION: GDinqgrid |
4898 : | |
4899 : | DESCRIPTION: Returns number and names of grid structures in file |
4900 : | |
4901 : | |
4902 : | Return Value Type Units Description |
4903 : | ============ ====== ========= ===================================== |
4904 : | nGrid int32 Number of grid structures in file |
4905 : | |
4906 : | INPUTS: |
4907 : | filename char HDF-EOS filename |
4908 : | |
4909 : | OUTPUTS: |
4910 : | gridlist char List of grid names (comma-separated) |
4911 : | strbufsize int32 Length of gridlist |
4912 : | |
4913 : | NOTES: |
4914 : | |
4915 : | |
4916 : | Date Programmer Description |
4917 : | ====== ============ ================================================= |
4918 : | Jun 96 Joel Gales Original Programmer |
4919 : | |
4920 : | END_PROLOG |
4921 : -----------------------------------------------------------------------------*/
4922 : int32
4923 4 : GDinqgrid(const char *filename, char *gridlist, int32 * strbufsize)
4924 : {
4925 : int32 nGrid; /* Number of grid structures in file */
4926 :
4927 : /* Call "EHinquire" routine */
4928 : /* ------------------------ */
4929 4 : nGrid = EHinquire(filename, "GRID", gridlist, strbufsize);
4930 :
4931 4 : return (nGrid);
4932 : }
4933 :
4934 :
4935 : /*----------------------------------------------------------------------------|
4936 : | BEGIN_PROLOG |
4937 : | |
4938 : | FUNCTION: GDsetfillvalue |
4939 : | |
4940 : | DESCRIPTION: Sets fill value for the specified field. |
4941 : | |
4942 : | |
4943 : | Return Value Type Units Description |
4944 : | ============ ====== ========= ===================================== |
4945 : | status intn return status (0) SUCCEED, (-1) FAIL |
4946 : | |
4947 : | INPUTS: |
4948 : | gridID int32 grid structure ID |
4949 : | fieldname char field name |
4950 : | fillval void fill value |
4951 : | |
4952 : | OUTPUTS: |
4953 : | None |
4954 : | |
4955 : | NOTES: |
4956 : | |
4957 : | |
4958 : | Date Programmer Description |
4959 : | ====== ============ ================================================= |
4960 : | Jun 96 Joel Gales Original Programmer |
4961 : | |
4962 : | END_PROLOG |
4963 : -----------------------------------------------------------------------------*/
4964 : intn
4965 0 : GDsetfillvalue(int32 gridID, const char *fieldname, VOIDP fillval)
4966 : {
4967 : intn status; /* routine return status variable */
4968 :
4969 : int32 fid; /* HDF-EOS file ID */
4970 : int32 sdInterfaceID; /* HDF SDS interface ID */
4971 : int32 gdVgrpID; /* Grid root Vgroup ID */
4972 : int32 sdid; /* SDS id */
4973 : int32 nt; /* Number type */
4974 : int32 dims[8]; /* Dimensions array */
4975 : int32 dum; /* Dummy variable */
4976 : int32 solo; /* "Solo" (non-merged) field flag */
4977 :
4978 : char name[80]; /* Fill value "attribute" name */
4979 :
4980 : /* Check for valid grid ID and get SDS interface ID */
4981 0 : status = GDchkgdid(gridID, "GDsetfillvalue",
4982 : &fid, &sdInterfaceID, &gdVgrpID);
4983 :
4984 0 : if (status == 0)
4985 : {
4986 : /* Get field info */
4987 0 : status = GDfieldinfo(gridID, fieldname, &dum, dims, &nt, NULL);
4988 :
4989 0 : if (status == 0)
4990 : {
4991 : /* Get SDS ID and solo flag */
4992 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname,
4993 : &sdid, &dum, &dum, &dum,
4994 : dims, &solo);
4995 :
4996 : /* If unmerged field then call HDF set field routine */
4997 0 : if (solo == 1)
4998 : {
4999 0 : /* status = */ SDsetfillvalue(sdid, fillval);
5000 : }
5001 :
5002 : /*
5003 : * Store fill value in attribute. Name is given by fieldname
5004 : * prepended with "_FV_"
5005 : */
5006 0 : strcpy(name, "_FV_");
5007 0 : strcat(name, fieldname);
5008 0 : status = GDwriteattr(gridID, name, nt, 1, fillval);
5009 :
5010 :
5011 : }
5012 : else
5013 : {
5014 0 : HEpush(DFE_GENAPP, "GDsetfillvalue", __FILE__, __LINE__);
5015 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
5016 : }
5017 : }
5018 0 : return (status);
5019 : }
5020 :
5021 :
5022 :
5023 :
5024 :
5025 :
5026 :
5027 : /*----------------------------------------------------------------------------|
5028 : | BEGIN_PROLOG |
5029 : | |
5030 : | FUNCTION: GDgetfillvalue |
5031 : | |
5032 : | DESCRIPTION: Retrieves fill value for a specified field. |
5033 : | |
5034 : | |
5035 : | Return Value Type Units Description |
5036 : | ============ ====== ========= ===================================== |
5037 : | status intn return status (0) SUCCEED, (-1) FAIL |
5038 : | |
5039 : | INPUTS: |
5040 : | gridID int32 grid structure ID |
5041 : | fieldname char field name |
5042 : | |
5043 : | OUTPUTS: |
5044 : | fillval void fill value |
5045 : | |
5046 : | NOTES: |
5047 : | |
5048 : | |
5049 : | Date Programmer Description |
5050 : | ====== ============ ================================================= |
5051 : | Jun 96 Joel Gales Original Programmer |
5052 : | |
5053 : | END_PROLOG |
5054 : -----------------------------------------------------------------------------*/
5055 : intn
5056 0 : GDgetfillvalue(int32 gridID, const char *fieldname, VOIDP fillval)
5057 : {
5058 : intn status; /* routine return status variable */
5059 :
5060 : int32 nt; /* Number type */
5061 : int32 dims[8]; /* Dimensions array */
5062 : int32 dum; /* Dummy variable */
5063 :
5064 : char name[80]; /* Fill value "attribute" name */
5065 :
5066 0 : status = GDchkgdid(gridID, "GDgetfillvalue", &dum, &dum, &dum);
5067 :
5068 : /* Check for valid grid ID */
5069 0 : if (status == 0)
5070 : {
5071 : /* Get field info */
5072 0 : status = GDfieldinfo(gridID, fieldname, &dum, dims, &nt, NULL);
5073 :
5074 0 : if (status == 0)
5075 : {
5076 : /* Read fill value attribute */
5077 0 : strcpy(name, "_FV_");
5078 0 : strcat(name, fieldname);
5079 0 : status = GDreadattr(gridID, name, fillval);
5080 : }
5081 : else
5082 : {
5083 0 : HEpush(DFE_GENAPP, "GDgetfillvalue", __FILE__, __LINE__);
5084 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
5085 : }
5086 :
5087 : }
5088 0 : return (status);
5089 : }
5090 :
5091 :
5092 :
5093 :
5094 :
5095 : /*----------------------------------------------------------------------------|
5096 : | BEGIN_PROLOG |
5097 : | |
5098 : | FUNCTION: GDdetach |
5099 : | |
5100 : | DESCRIPTION: Detaches from grid interface and performs file housekeeping. |
5101 : | |
5102 : | |
5103 : | Return Value Type Units Description |
5104 : | ============ ====== ========= ===================================== |
5105 : | status intn return status (0) SUCCEED, (-1) FAIL |
5106 : | |
5107 : | INPUTS: |
5108 : | gridID int32 grid structure ID |
5109 : | |
5110 : | |
5111 : | OUTPUTS: |
5112 : | None |
5113 : | |
5114 : | NOTES: |
5115 : | |
5116 : | |
5117 : | Date Programmer Description |
5118 : | ====== ============ ================================================= |
5119 : | Jun 96 Joel Gales Original Programmer |
5120 : | Sep 96 Joel Gales Setup dim names for SDsetdimname in dimbuf1 rather |
5121 : | that utlstr |
5122 : | Oct 96 Joel Gales Detach Grid Vgroups |
5123 : | Oct 96 Joel Gales "Detach" from SDS |
5124 : | Nov 96 Joel Gales Call GDchkgdid to check for proper grid ID |
5125 : | Dec 96 Joel Gales Add multiple vertical subsetting garbage collection |
5126 : | Oct 98 Abe Taaheri Added GDXRegion[k]->DimNamePtr[i] =0; after freeing |
5127 : | memory |
5128 : | Sep 99 Abe Taaheri Changed memcpy to memmove because of overlapping |
5129 : | source and destination for GDXSDcomb, nameptr, and |
5130 : | dimptr. memcpy may cause unexpected results. |
5131 : | |
5132 : | END_PROLOG |
5133 : -----------------------------------------------------------------------------*/
5134 : intn
5135 0 : GDdetach(int32 gridID)
5136 :
5137 : {
5138 : intn i; /* Loop index */
5139 : intn j; /* Loop index */
5140 : intn k; /* Loop index */
5141 0 : intn status = 0; /* routine return status variable */
5142 0 : intn statusFill = 0; /* return status from GDgetfillvalue */
5143 :
5144 : int32 *namelen; /* Pointer to name string length array */
5145 : int32 *dimlen; /* Pointer to dim string length array */
5146 : int32 slen1[3]; /* String length array 1 */
5147 : int32 slen2[3]; /* String length array 2 */
5148 : int32 nflds; /* Number of fields */
5149 : int32 match[5]; /* Merged field match array */
5150 : int32 cmbfldcnt; /* Number of fields combined */
5151 : int32 sdid; /* SDS ID */
5152 : int32 vgid; /* Vgroup ID */
5153 : int32 dims[3]; /* Dimension array */
5154 : int32 *offset; /* Pointer to merged field offset array */
5155 : int32 *indvdims; /* Pointer to merged field size array */
5156 : int32 sdInterfaceID; /* SDS interface ID */
5157 : int32 gID; /* Grid ID - offset */
5158 : int32 nflds0; /* Number of fields */
5159 : int32 *namelen0; /* Pointer to name string length array */
5160 : int32 rank; /* Rank of merged field */
5161 : int32 truerank; /* True rank of merged field */
5162 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
5163 : int32 dum; /* Dummy variable */
5164 :
5165 : char *nambuf; /* Pointer to name buffer */
5166 : char **nameptr; /* Pointer to name string pointer array */
5167 : char **dimptr; /* Pointer to dim string pointer array */
5168 : char **nameptr0; /* Pointer to name string pointer array */
5169 : char *ptr1[3]; /* String pointer array */
5170 : char *ptr2[3]; /* String pointer array */
5171 : char dimbuf1[128]; /* Dimension buffer 1 */
5172 : char dimbuf2[128]; /* Dimension buffer 2 */
5173 : char gridname[VGNAMELENMAX + 1]; /* Grid name */
5174 : char *utlbuf; /* Utility buffer */
5175 : char fillval[32];/* Fill value buffer */
5176 :
5177 :
5178 :
5179 0 : status = GDchkgdid(gridID, "GDdetach", &dum, &sdInterfaceID, &dum);
5180 :
5181 0 : if (status == 0)
5182 : {
5183 0 : gID = gridID % idOffset;
5184 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
5185 :
5186 : /* SDS combined fields */
5187 : /* ------------------- */
5188 0 : if (strlen(GDXSDname) == 0)
5189 : {
5190 0 : nflds = 0;
5191 :
5192 : /* Allocate "dummy" arrays so free() doesn't bomb later */
5193 : /* ---------------------------------------------------- */
5194 0 : nameptr = (char **) calloc(1, sizeof(char *));
5195 0 : if(nameptr == NULL)
5196 : {
5197 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5198 0 : return(-1);
5199 : }
5200 0 : namelen = (int32 *) calloc(1, sizeof(int32));
5201 0 : if(namelen == NULL)
5202 : {
5203 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5204 0 : free(nameptr);
5205 0 : return(-1);
5206 : }
5207 0 : nameptr0 = (char **) calloc(1, sizeof(char *));
5208 0 : if(nameptr0 == NULL)
5209 : {
5210 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5211 0 : free(nameptr);
5212 0 : free(namelen);
5213 0 : return(-1);
5214 : }
5215 0 : namelen0 = (int32 *) calloc(1, sizeof(int32));
5216 0 : if(namelen0 == NULL)
5217 : {
5218 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5219 0 : free(nameptr);
5220 0 : free(namelen);
5221 0 : free(nameptr0);
5222 0 : return(-1);
5223 : }
5224 0 : dimptr = (char **) calloc(1, sizeof(char *));
5225 0 : if(dimptr == NULL)
5226 : {
5227 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5228 0 : free(nameptr);
5229 0 : free(namelen);
5230 0 : free(nameptr0);
5231 0 : free(namelen0);
5232 0 : return(-1);
5233 : }
5234 0 : dimlen = (int32 *) calloc(1, sizeof(int32));
5235 0 : if(dimlen == NULL)
5236 : {
5237 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5238 0 : free(nameptr);
5239 0 : free(namelen);
5240 0 : free(nameptr0);
5241 0 : free(namelen0);
5242 0 : free(dimptr);
5243 0 : return(-1);
5244 : }
5245 0 : offset = (int32 *) calloc(1, sizeof(int32));
5246 0 : if(offset == NULL)
5247 : {
5248 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5249 0 : free(nameptr);
5250 0 : free(namelen);
5251 0 : free(nameptr0);
5252 0 : free(namelen0);
5253 0 : free(dimptr);
5254 0 : free(dimlen);
5255 0 : return(-1);
5256 : }
5257 0 : indvdims = (int32 *) calloc(1, sizeof(int32));
5258 0 : if(indvdims == NULL)
5259 : {
5260 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5261 0 : free(nameptr);
5262 0 : free(namelen);
5263 0 : free(nameptr0);
5264 0 : free(namelen0);
5265 0 : free(dimptr);
5266 0 : free(dimlen);
5267 0 : free(offset);
5268 0 : return(-1);
5269 : }
5270 : }
5271 : else
5272 : {
5273 : /*
5274 : * "Trim Off" trailing "," and ";" in GDXSDname & GDXSDdims
5275 : * respectively
5276 : */
5277 0 : GDXSDname[strlen(GDXSDname) - 1] = 0;
5278 0 : GDXSDdims[strlen(GDXSDdims) - 1] = 0;
5279 :
5280 :
5281 : /* Get number of fields from GDXSDname string */
5282 : /* ------------------------------------------ */
5283 0 : nflds = EHparsestr(GDXSDname, ',', NULL, NULL);
5284 :
5285 : /* Allocate space for various dynamic arrays */
5286 : /* ----------------------------------------- */
5287 0 : nameptr = (char **) calloc(nflds, sizeof(char *));
5288 0 : if(nameptr == NULL)
5289 : {
5290 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5291 0 : return(-1);
5292 : }
5293 0 : namelen = (int32 *) calloc(nflds, sizeof(int32));
5294 0 : if(namelen == NULL)
5295 : {
5296 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5297 0 : free(nameptr);
5298 0 : return(-1);
5299 : }
5300 0 : nameptr0 = (char **) calloc(nflds, sizeof(char *));
5301 0 : if(nameptr0 == NULL)
5302 : {
5303 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5304 0 : free(nameptr);
5305 0 : free(namelen);
5306 0 : return(-1);
5307 : }
5308 0 : namelen0 = (int32 *) calloc(nflds, sizeof(int32));
5309 0 : if(namelen0 == NULL)
5310 : {
5311 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5312 0 : free(nameptr);
5313 0 : free(namelen);
5314 0 : free(nameptr0);
5315 0 : return(-1);
5316 : }
5317 0 : dimptr = (char **) calloc(nflds, sizeof(char *));
5318 0 : if(dimptr == NULL)
5319 : {
5320 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5321 0 : free(nameptr);
5322 0 : free(namelen);
5323 0 : free(nameptr0);
5324 0 : free(namelen0);
5325 0 : return(-1);
5326 : }
5327 0 : dimlen = (int32 *) calloc(nflds, sizeof(int32));
5328 0 : if(dimlen == NULL)
5329 : {
5330 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5331 0 : free(nameptr);
5332 0 : free(namelen);
5333 0 : free(nameptr0);
5334 0 : free(namelen0);
5335 0 : free(dimptr);
5336 0 : return(-1);
5337 : }
5338 0 : offset = (int32 *) calloc(nflds, sizeof(int32));
5339 0 : if(offset == NULL)
5340 : {
5341 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5342 0 : free(nameptr);
5343 0 : free(namelen);
5344 0 : free(nameptr0);
5345 0 : free(namelen0);
5346 0 : free(dimptr);
5347 0 : free(dimlen);
5348 0 : return(-1);
5349 : }
5350 0 : indvdims = (int32 *) calloc(nflds, sizeof(int32));
5351 0 : if(indvdims == NULL)
5352 : {
5353 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5354 0 : free(nameptr);
5355 0 : free(namelen);
5356 0 : free(nameptr0);
5357 0 : free(namelen0);
5358 0 : free(dimptr);
5359 0 : free(dimlen);
5360 0 : free(offset);
5361 0 : return(-1);
5362 : }
5363 :
5364 : /* Parse GDXSDname and GDXSDdims strings */
5365 : /* ------------------------------------- */
5366 0 : nflds = EHparsestr(GDXSDname, ',', nameptr, namelen);
5367 0 : nflds = EHparsestr(GDXSDdims, ';', dimptr, dimlen);
5368 : }
5369 :
5370 :
5371 0 : for (i = 0; i < nflds; i++)
5372 : {
5373 0 : if (GDXSDcomb[5 * i] != 0 &&
5374 0 : GDXSDcomb[5 * i + 3] == GDXGrid[gID].IDTable)
5375 : {
5376 0 : nambuf = (char *) calloc(strlen(GDXSDname) + 1, 1);
5377 0 : if(nambuf == NULL)
5378 : {
5379 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5380 0 : free(nameptr);
5381 0 : free(namelen);
5382 0 : free(nameptr0);
5383 0 : free(namelen0);
5384 0 : free(dimptr);
5385 0 : free(dimlen);
5386 0 : free(offset);
5387 0 : return(-1);
5388 : }
5389 0 : utlbuf = (char *) calloc(strlen(GDXSDname) * 2 + 7, 1);
5390 0 : if(utlbuf == NULL)
5391 : {
5392 0 : HEpush(DFE_NOSPACE,"GDdetach", __FILE__, __LINE__);
5393 0 : free(nambuf);
5394 0 : free(nameptr);
5395 0 : free(namelen);
5396 0 : free(nameptr0);
5397 0 : free(namelen0);
5398 0 : free(dimptr);
5399 0 : free(dimlen);
5400 0 : free(offset);
5401 0 : return(-1);
5402 : }
5403 :
5404 0 : for (k = 0; k < (intn)sizeof(dimbuf1); k++)
5405 0 : dimbuf1[k] = 0;
5406 :
5407 :
5408 : /* Load array to match, name & parse dims */
5409 : /* -------------------------------------- */
5410 0 : memcpy(match, &GDXSDcomb[5 * i], 20);
5411 0 : memcpy(nambuf, nameptr[i], namelen[i]);
5412 :
5413 0 : memcpy(dimbuf1, dimptr[i], dimlen[i]);
5414 0 : dum = EHparsestr(dimbuf1, ',', ptr1, slen1);
5415 :
5416 :
5417 : /* Separate combined dimension from others */
5418 : /* --------------------------------------- */
5419 0 : dimbuf1[slen1[0]] = 0;
5420 :
5421 0 : offset[0] = 0;
5422 0 : indvdims[0] = abs(match[0]);
5423 :
5424 0 : for (j = i + 1, cmbfldcnt = 0; j < nflds; j++)
5425 : {
5426 0 : for (k = 0; k < (intn)sizeof(dimbuf2); k++)
5427 0 : dimbuf2[k] = 0;
5428 0 : memcpy(dimbuf2, dimptr[j], dimlen[j]);
5429 0 : dum = EHparsestr(dimbuf2, ',', ptr2, slen2);
5430 0 : dimbuf2[slen2[0]] = 0;
5431 :
5432 :
5433 0 : if (GDXSDcomb[5 * j] != 0 &&
5434 0 : strcmp(dimbuf1 + slen1[0],
5435 0 : dimbuf2 + slen2[0]) == 0 &&
5436 0 : match[1] == GDXSDcomb[5 * j + 1] &&
5437 0 : match[2] == GDXSDcomb[5 * j + 2] &&
5438 0 : match[3] == GDXSDcomb[5 * j + 3] &&
5439 0 : match[4] == GDXSDcomb[5 * j + 4])
5440 : {
5441 : /* Add to combined dimension size */
5442 0 : match[0] += GDXSDcomb[5 * j];
5443 :
5444 : /* Concatenate name */
5445 0 : strcat(nambuf, ",");
5446 0 : memcpy(nambuf + strlen(nambuf),
5447 0 : nameptr[j], namelen[j]);
5448 :
5449 : /* Store individual dims and dim offsets */
5450 0 : cmbfldcnt++;
5451 0 : indvdims[cmbfldcnt] = abs(GDXSDcomb[5 * j]);
5452 0 : offset[cmbfldcnt] =
5453 0 : offset[cmbfldcnt - 1] + indvdims[cmbfldcnt - 1];
5454 :
5455 0 : GDXSDcomb[5 * j] = 0;
5456 : }
5457 : }
5458 :
5459 :
5460 : /* Create SDS */
5461 : /* ---------- */
5462 0 : nflds0 = EHparsestr(nambuf, ',', nameptr0, namelen0);
5463 :
5464 0 : if (abs(match[0]) == 1)
5465 : {
5466 0 : for (k = 0; k < 2; k++)
5467 0 : dims[k] = abs(match[k + 1]);
5468 :
5469 0 : rank = 2;
5470 :
5471 0 : sdid = SDcreate(sdInterfaceID, nambuf,
5472 0 : GDXSDcomb[5 * i + 4], 2, dims);
5473 : }
5474 : else
5475 : {
5476 0 : for (k = 0; k < 3; k++)
5477 0 : dims[k] = abs(match[k]);
5478 :
5479 0 : rank = 3;
5480 :
5481 0 : if (cmbfldcnt > 0)
5482 : {
5483 0 : strcpy(utlbuf, "MRGFLD_");
5484 0 : memcpy(utlbuf + 7, nameptr0[0], namelen0[0]);
5485 0 : utlbuf[7 + namelen0[0]] = 0;
5486 0 : strcat(utlbuf, ":");
5487 0 : strcat(utlbuf, nambuf);
5488 :
5489 0 : status = EHinsertmeta(sdInterfaceID, gridname, "g",
5490 : 6L, utlbuf, NULL);
5491 : }
5492 : else
5493 : {
5494 0 : strcpy(utlbuf, nambuf);
5495 : }
5496 :
5497 0 : sdid = SDcreate(sdInterfaceID, utlbuf,
5498 0 : GDXSDcomb[5 * i + 4], 3, dims);
5499 :
5500 :
5501 0 : if (cmbfldcnt > 0)
5502 : {
5503 0 : SDsetattr(sdid, "Field Dims", DFNT_INT32,
5504 : cmbfldcnt + 1, (VOIDP) indvdims);
5505 :
5506 0 : SDsetattr(sdid, "Field Offsets", DFNT_INT32,
5507 : cmbfldcnt + 1, (VOIDP) offset);
5508 : }
5509 :
5510 : }
5511 :
5512 :
5513 :
5514 : /* Register Dimensions in SDS */
5515 : /* -------------------------- */
5516 0 : for (k = 0; k < rank; k++)
5517 : {
5518 0 : if (rank == 2)
5519 : {
5520 0 : memcpy(dimbuf2, ptr1[k + 1], slen1[k + 1]);
5521 0 : dimbuf2[slen1[k + 1]] = 0;
5522 : }
5523 : else
5524 : {
5525 0 : memcpy(dimbuf2, ptr1[k], slen1[k]);
5526 0 : dimbuf2[slen1[k]] = 0;
5527 : }
5528 :
5529 :
5530 0 : if (k == 0 && rank > 2 && cmbfldcnt > 0)
5531 : {
5532 0 : snprintf(dimbuf2, sizeof(dimbuf2), "%s%s_%d", "MRGDIM:",
5533 0 : gridname, (int)dims[0]);
5534 : }
5535 : else
5536 : {
5537 0 : strcat(dimbuf2, ":");
5538 0 : strcat(dimbuf2, gridname);
5539 : }
5540 0 : SDsetdimname(SDgetdimid(sdid, k), (char *) dimbuf2);
5541 : }
5542 :
5543 :
5544 :
5545 : /* Write Fill Value */
5546 : /* ---------------- */
5547 0 : for (k = 0; k < nflds0; k++)
5548 : {
5549 0 : memcpy(utlbuf, nameptr0[k], namelen0[k]);
5550 0 : utlbuf[namelen[k]] = 0;
5551 0 : statusFill = GDgetfillvalue(gridID, utlbuf, fillval);
5552 :
5553 0 : if (statusFill == 0)
5554 : {
5555 0 : if (cmbfldcnt > 0)
5556 : {
5557 0 : dims[0] = indvdims[k];
5558 0 : truerank = (dims[0] == 1) ? 2 : 3;
5559 0 : EHfillfld(sdid, rank, truerank,
5560 0 : DFKNTsize(match[4]), offset[k],
5561 : dims, fillval);
5562 : }
5563 : else
5564 : {
5565 0 : status = SDsetfillvalue(sdid, fillval);
5566 : }
5567 : }
5568 : }
5569 :
5570 :
5571 0 : vgid = GDXGrid[gID].VIDTable[0];
5572 0 : Vaddtagref(vgid, DFTAG_NDG, SDidtoref(sdid));
5573 0 : SDendaccess(sdid);
5574 :
5575 0 : free(nambuf);
5576 0 : free(utlbuf);
5577 :
5578 : }
5579 : }
5580 :
5581 :
5582 0 : for (i = 0; i < nflds; i++)
5583 : {
5584 0 : if (GDXSDcomb[5 * i + 3] == GDXGrid[gID].IDTable)
5585 : {
5586 0 : if (i == (nflds - 1))
5587 : {
5588 0 : GDXSDcomb[5 * i] = 0;
5589 0 : *(nameptr[i] - (nflds != 1)) = 0;
5590 0 : *(dimptr[i] - (nflds != 1)) = 0;
5591 : }
5592 : else
5593 : {
5594 : /* memcpy(&GDXSDcomb[5 * i],
5595 : &GDXSDcomb[5 * (i + 1)],
5596 : (512 - i - 1) * 5 * 4);*/
5597 0 : memmove(&GDXSDcomb[5 * i],
5598 0 : &GDXSDcomb[5 * (i + 1)],
5599 0 : (512 - i - 1) * 5 * 4);
5600 : /* memcpy(nameptr[i],
5601 : nameptr[i + 1],
5602 : nameptr[0] + 2048 - nameptr[i + 1] - 1);*/
5603 0 : memmove(nameptr[i],
5604 0 : nameptr[i + 1],
5605 0 : nameptr[0] + 2048 - nameptr[i + 1] - 1);
5606 : /* memcpy(dimptr[i],
5607 : dimptr[i + 1],
5608 : dimptr[0] + 2048 * 2 - dimptr[i + 1] - 1);*/
5609 0 : memmove(dimptr[i],
5610 0 : dimptr[i + 1],
5611 0 : dimptr[0] + 2048 * 2 - dimptr[i + 1] - 1);
5612 : }
5613 :
5614 0 : i--;
5615 0 : nflds = EHparsestr(GDXSDname, ',', nameptr, namelen);
5616 0 : nflds = EHparsestr(GDXSDdims, ';', dimptr, dimlen);
5617 : }
5618 : }
5619 :
5620 0 : if (nflds != 0)
5621 : {
5622 0 : strcat(GDXSDname, ",");
5623 0 : strcat(GDXSDdims, ";");
5624 : }
5625 :
5626 :
5627 :
5628 : /* Free up a bunch of dynamically allocated arrays */
5629 : /* ----------------------------------------------- */
5630 0 : free(nameptr);
5631 0 : free(namelen);
5632 0 : free(nameptr0);
5633 0 : free(namelen0);
5634 0 : free(dimptr);
5635 0 : free(dimlen);
5636 0 : free(offset);
5637 0 : free(indvdims);
5638 :
5639 :
5640 :
5641 : /* "Detach" from previously attached SDSs */
5642 : /* -------------------------------------- */
5643 0 : for (k = 0; k < GDXGrid[gID].nSDS; k++)
5644 : {
5645 0 : SDendaccess(GDXGrid[gID].sdsID[k]);
5646 : }
5647 0 : free(GDXGrid[gID].sdsID);
5648 0 : GDXGrid[gID].sdsID = 0;
5649 0 : GDXGrid[gID].nSDS = 0;
5650 :
5651 :
5652 :
5653 : /* Detach Grid Vgroups */
5654 : /* ------------------- */
5655 0 : Vdetach(GDXGrid[gID].VIDTable[0]);
5656 0 : Vdetach(GDXGrid[gID].VIDTable[1]);
5657 0 : Vdetach(GDXGrid[gID].IDTable);
5658 :
5659 0 : GDXGrid[gID].active = 0;
5660 0 : GDXGrid[gID].VIDTable[0] = 0;
5661 0 : GDXGrid[gID].VIDTable[1] = 0;
5662 0 : GDXGrid[gID].IDTable = 0;
5663 0 : GDXGrid[gID].fid = 0;
5664 :
5665 :
5666 :
5667 :
5668 : /* Free Region Pointers */
5669 : /* -------------------- */
5670 0 : for (k = 0; k < NGRIDREGN; k++)
5671 : {
5672 0 : if (GDXRegion[k] != 0 &&
5673 0 : GDXRegion[k]->gridID == gridID)
5674 : {
5675 0 : for (i = 0; i < 8; i++)
5676 : {
5677 0 : if (GDXRegion[k]->DimNamePtr[i] != 0)
5678 : {
5679 0 : free(GDXRegion[k]->DimNamePtr[i]);
5680 0 : GDXRegion[k]->DimNamePtr[i] = 0;
5681 : }
5682 : }
5683 :
5684 0 : free(GDXRegion[k]);
5685 0 : GDXRegion[k] = 0;
5686 : }
5687 : }
5688 : }
5689 0 : return (status);
5690 : }
5691 :
5692 :
5693 : /*----------------------------------------------------------------------------|
5694 : | BEGIN_PROLOG |
5695 : | |
5696 : | FUNCTION: GDclose |
5697 : | |
5698 : | DESCRIPTION: Closes file. |
5699 : | |
5700 : | |
5701 : | Return Value Type Units Description |
5702 : | ============ ====== ========= ===================================== |
5703 : | status intn return status (0) SUCCEED, (-1) FAIL |
5704 : | |
5705 : | INPUTS: |
5706 : | fid int32 File ID |
5707 : | |
5708 : | |
5709 : | OUTPUTS: |
5710 : | None |
5711 : | |
5712 : | NOTES: |
5713 : | |
5714 : | |
5715 : | Date Programmer Description |
5716 : | ====== ============ ================================================= |
5717 : | Jun 96 Joel Gales Original Programmer |
5718 : | |
5719 : | END_PROLOG |
5720 : -----------------------------------------------------------------------------*/
5721 : intn
5722 4 : GDclose(int32 fid)
5723 :
5724 : {
5725 4 : intn status = 0; /* routine return status variable */
5726 :
5727 : /* Call EHclose to perform file close */
5728 : /* ---------------------------------- */
5729 4 : status = EHclose(fid);
5730 :
5731 4 : return (status);
5732 : }
5733 :
5734 :
5735 : /*----------------------------------------------------------------------------|
5736 : | BEGIN_PROLOG |
5737 : | |
5738 : | FUNCTION: GDgetdefaults |
5739 : | |
5740 : | DESCRIPTION: |
5741 : | |
5742 : | |
5743 : | Return Value Type Units Description |
5744 : | ============ ====== ========= ===================================== |
5745 : | status intn return status (0) SUCCEED, (-1) FAIL |
5746 : | |
5747 : | INPUTS: |
5748 : | projcode int32 GCTP projection code |
5749 : | zonecode int32 UTM zone code |
5750 : | projparm float64 Projection parameters |
5751 : | spherecode int32 GCTP spheriod code |
5752 : | upleftpt float64 upper left corner coordinates |
5753 : | lowrightpt float64 lower right corner coordinates |
5754 : | |
5755 : | |
5756 : | OUTPUTS: |
5757 : | upleftpt float64 upper left corner coordinates |
5758 : | lowrightpt float64 lower right corner coordinates |
5759 : | |
5760 : | NOTES: |
5761 : | |
5762 : | |
5763 : | Date Programmer Description |
5764 : | ====== ============ ================================================= |
5765 : | Aug 96 Joel Gales Original Programmer |
5766 : | Sep 96 Raj Gejjaga Fixed bugs in Polar Stereographic and Goode | | Homolosine default calculations. |
5767 : | Sep 96 Raj Gejjaga Added code to compute default boundary points |
5768 : | for Lambert Azimuthal Polar and Equatorial |
5769 : | projections. |
5770 : | Feb 97 Raj Gejjaga Added code to compute default boundary points |
5771 : | for Integerized Sinusoidal Grid. Added error |
5772 : | handling code. |
5773 : | Jun 00 Abe Taaheri Added support for EASE grid |
5774 : | |
5775 : | END_PROLOG |
5776 : -----------------------------------------------------------------------------*/
5777 : static intn
5778 0 : GDgetdefaults(int32 projcode, int32 zonecode, float64 projparm[],
5779 : int32 spherecode, float64 upleftpt[], float64 lowrightpt[])
5780 : {
5781 0 : int32 errorcode = 0, status = 0;
5782 : int32(*for_trans[100]) (double, double, double*, double*);
5783 :
5784 : float64 lon, lat, plat, x, y;
5785 : float64 plon, tlon, llon, rlon, pplon, LLon, LLat, RLon, RLat;
5786 :
5787 :
5788 : /* invoke GCTP initialization routine */
5789 : /* ---------------------------------- */
5790 0 : for_init(projcode, zonecode, projparm, spherecode, NULL, NULL,
5791 : &errorcode, for_trans);
5792 :
5793 : /* Report error if any */
5794 : /* ------------------- */
5795 0 : if (errorcode != 0)
5796 : {
5797 0 : status = -1;
5798 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5799 0 : HEreport("GCTP Error: %d\n", errorcode);
5800 0 : return (status);
5801 : }
5802 :
5803 : /* Compute Default Boundary Points for EASE Grid */
5804 : /* Use Global coverage */
5805 : /* ------------------------------------------------------ */
5806 0 : if (projcode == GCTP_BCEA &&
5807 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
5808 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
5809 : {
5810 0 : upleftpt[0] = EHconvAng(EASE_GRID_DEFAULT_UPLEFT_LON, HDFE_DEG_DMS);
5811 0 : upleftpt[1] = EHconvAng(EASE_GRID_DEFAULT_UPLEFT_LAT, HDFE_DEG_DMS);
5812 0 : lowrightpt[0] = EHconvAng(EASE_GRID_DEFAULT_LOWRGT_LON, HDFE_DEG_DMS);
5813 0 : lowrightpt[1] = EHconvAng(EASE_GRID_DEFAULT_LOWRGT_LAT, HDFE_DEG_DMS);
5814 : }
5815 :
5816 : /* Compute Default Boundary Points for CEA */
5817 : /* --------------------------------------------*/
5818 0 : if (projcode == GCTP_CEA &&
5819 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
5820 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
5821 : {
5822 0 : LLon = EHconvAng(EASE_GRID_DEFAULT_UPLEFT_LON, HDFE_DEG_RAD);
5823 0 : LLat = EHconvAng(EASE_GRID_DEFAULT_UPLEFT_LAT, HDFE_DEG_RAD);
5824 0 : RLon = EHconvAng(EASE_GRID_DEFAULT_LOWRGT_LON, HDFE_DEG_RAD);
5825 0 : RLat = EHconvAng(EASE_GRID_DEFAULT_LOWRGT_LAT, HDFE_DEG_RAD);
5826 :
5827 0 : errorcode = for_trans[projcode] (LLon, LLat, &x, &y);
5828 0 : if (errorcode != 0)
5829 : {
5830 0 : status = -1;
5831 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5832 0 : HEreport("GCTP Error: %d\n", errorcode);
5833 0 : return (status);
5834 : }
5835 0 : upleftpt[0] = x;
5836 0 : upleftpt[1] = y;
5837 :
5838 0 : errorcode = for_trans[projcode] (RLon, RLat, &x, &y);
5839 0 : if (errorcode != 0)
5840 : {
5841 0 : status = -1;
5842 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5843 0 : HEreport("GCTP Error: %d\n", errorcode);
5844 0 : return (status);
5845 : }
5846 0 : lowrightpt[0] = x;
5847 0 : lowrightpt[1] = y;
5848 :
5849 : }
5850 :
5851 :
5852 : /* Compute Default Boundary Points for Polar Sterographic */
5853 : /* ------------------------------------------------------ */
5854 0 : if (projcode == GCTP_PS &&
5855 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
5856 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
5857 : {
5858 : /*
5859 : * Convert the longitude and latitude from the DMS to decimal degree
5860 : * format.
5861 : */
5862 0 : plon = EHconvAng(projparm[4], HDFE_DMS_DEG);
5863 0 : plat = EHconvAng(projparm[5], HDFE_DMS_DEG);
5864 :
5865 : /*
5866 : * Compute the longitudes at 90, 180 and 270 degrees from the central
5867 : * longitude.
5868 : */
5869 :
5870 0 : if (plon <= 0.0)
5871 : {
5872 0 : tlon = 180.0 + plon;
5873 0 : pplon = plon + 360.0;
5874 : }
5875 : else
5876 : {
5877 0 : tlon = plon - 180.0;
5878 0 : pplon = plon;
5879 : }
5880 :
5881 0 : rlon = pplon + 90.0;
5882 0 : if (rlon > 360.0)
5883 0 : rlon = rlon - 360;
5884 :
5885 0 : if (rlon > 180.0)
5886 0 : rlon = rlon - 360.0;
5887 :
5888 0 : if (rlon <= 0.0)
5889 0 : llon = 180.0 + rlon;
5890 : else
5891 0 : llon = rlon - 180.0;
5892 :
5893 :
5894 : /* Convert all four longitudes from decimal degrees to radians */
5895 0 : plon = EHconvAng(plon, HDFE_DEG_RAD);
5896 0 : tlon = EHconvAng(tlon, HDFE_DEG_RAD);
5897 0 : llon = EHconvAng(llon, HDFE_DEG_RAD);
5898 0 : rlon = EHconvAng(rlon, HDFE_DEG_RAD);
5899 :
5900 0 : errorcode = for_trans[projcode] (llon, 0.0, &x, &y);
5901 0 : if (errorcode != 0)
5902 : {
5903 0 : status = -1;
5904 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5905 0 : HEreport("GCTP Error: %d\n", errorcode);
5906 0 : return (status);
5907 : }
5908 :
5909 0 : upleftpt[0] = x;
5910 :
5911 0 : errorcode = for_trans[projcode] (rlon, 0.0, &x, &y);
5912 0 : if (errorcode != 0)
5913 : {
5914 0 : status = -1;
5915 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5916 0 : HEreport("GCTP Error: %d\n", errorcode);
5917 0 : return (status);
5918 : }
5919 :
5920 0 : lowrightpt[0] = x;
5921 :
5922 : /*
5923 : * Compute the upperleft and lowright y values based on the south or
5924 : * north polar projection
5925 : */
5926 :
5927 0 : if (plat < 0.0)
5928 : {
5929 0 : errorcode = for_trans[projcode] (plon, 0.0, &x, &y);
5930 0 : if (errorcode != 0)
5931 : {
5932 0 : status = -1;
5933 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5934 0 : HEreport("GCTP Error: %d\n", errorcode);
5935 0 : return (status);
5936 : }
5937 :
5938 0 : upleftpt[1] = y;
5939 :
5940 0 : errorcode = for_trans[projcode] (tlon, 0.0, &x, &y);
5941 0 : if (errorcode != 0)
5942 : {
5943 0 : status = -1;
5944 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5945 0 : HEreport("GCTP Error: %d\n", errorcode);
5946 0 : return (status);
5947 : }
5948 :
5949 0 : lowrightpt[1] = y;
5950 :
5951 : }
5952 : else
5953 : {
5954 0 : errorcode = for_trans[projcode] (tlon, 0.0, &x, &y);
5955 0 : if (errorcode != 0)
5956 : {
5957 0 : status = -1;
5958 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5959 0 : HEreport("GCTP Error: %d\n", errorcode);
5960 0 : return (status);
5961 : }
5962 :
5963 0 : upleftpt[1] = y;
5964 :
5965 0 : errorcode = for_trans[projcode] (plon, 0.0, &x, &y);
5966 0 : if (errorcode != 0)
5967 : {
5968 0 : status = -1;
5969 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5970 0 : HEreport("GCTP Error: %d\n", errorcode);
5971 0 : return (status);
5972 : }
5973 :
5974 0 : lowrightpt[1] = y;
5975 :
5976 : }
5977 : }
5978 :
5979 :
5980 : /* Compute Default Boundary Points for Goode Homolosine */
5981 : /* ---------------------------------------------------- */
5982 0 : if (projcode == GCTP_GOOD &&
5983 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
5984 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
5985 : {
5986 0 : lon = EHconvAng(-180, HDFE_DEG_RAD);
5987 0 : lat = 0.0;
5988 :
5989 0 : errorcode = for_trans[projcode] (lon, lat, &x, &y);
5990 0 : if (errorcode != 0)
5991 : {
5992 0 : status = -1;
5993 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
5994 0 : HEreport("GCTP Error: %d\n", errorcode);
5995 0 : return (status);
5996 : }
5997 :
5998 0 : upleftpt[0] = -fabs(x);
5999 0 : lowrightpt[0] = +fabs(x);
6000 :
6001 0 : lat = EHconvAng(90, HDFE_DEG_RAD);
6002 :
6003 0 : errorcode = for_trans[projcode] (lon, lat, &x, &y);
6004 0 : if (errorcode != 0)
6005 : {
6006 0 : status = -1;
6007 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6008 0 : HEreport("GCTP Error: %d\n", errorcode);
6009 0 : return (status);
6010 : }
6011 :
6012 0 : upleftpt[1] = +fabs(y);
6013 0 : lowrightpt[1] = -fabs(y);
6014 : }
6015 :
6016 : /* Compute Default Boundary Points for Lambert Azimuthal */
6017 : /* ----------------------------------------------------- */
6018 0 : if (projcode == GCTP_LAMAZ &&
6019 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
6020 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
6021 : {
6022 : /*
6023 : * Convert the longitude and latitude from the DMS to decimal degree
6024 : * format.
6025 : */
6026 0 : plon = EHconvAng(projparm[4], HDFE_DMS_DEG);
6027 0 : plat = EHconvAng(projparm[5], HDFE_DMS_DEG);
6028 :
6029 : /*
6030 : * Compute the longitudes at 90, 180 and 270 degrees from the central
6031 : * longitude.
6032 : */
6033 :
6034 0 : if (plon <= 0.0)
6035 : {
6036 0 : tlon = 180.0 + plon;
6037 0 : pplon = plon + 360.0;
6038 : }
6039 : else
6040 : {
6041 0 : tlon = plon - 180.0;
6042 0 : pplon = plon;
6043 : }
6044 :
6045 0 : rlon = pplon + 90.0;
6046 0 : if (rlon > 360.0)
6047 0 : rlon = rlon - 360;
6048 :
6049 0 : if (rlon > 180.0)
6050 0 : rlon = rlon - 360.0;
6051 :
6052 0 : if (rlon <= 0.0)
6053 0 : llon = 180.0 + rlon;
6054 : else
6055 0 : llon = rlon - 180.0;
6056 :
6057 : /* Convert all four longitudes from decimal degrees to radians */
6058 0 : plon = EHconvAng(plon, HDFE_DEG_RAD);
6059 0 : tlon = EHconvAng(tlon, HDFE_DEG_RAD);
6060 0 : llon = EHconvAng(llon, HDFE_DEG_RAD);
6061 0 : rlon = EHconvAng(rlon, HDFE_DEG_RAD);
6062 :
6063 0 : errorcode = for_trans[projcode] (llon, 0.0, &x, &y);
6064 0 : if (errorcode != 0)
6065 : {
6066 0 : status = -1;
6067 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6068 0 : HEreport("GCTP Error: %d\n", errorcode);
6069 0 : return (status);
6070 : }
6071 :
6072 0 : upleftpt[0] = x;
6073 :
6074 0 : errorcode = for_trans[projcode] (rlon, 0.0, &x, &y);
6075 0 : if (errorcode != 0)
6076 : {
6077 0 : status = -1;
6078 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6079 0 : HEreport("GCTP Error: %d\n", errorcode);
6080 0 : return (status);
6081 : }
6082 :
6083 0 : lowrightpt[0] = x;
6084 :
6085 : /*
6086 : * Compute upperleft and lowerright values based on whether the
6087 : * projection is south polar, north polar or equatorial
6088 : */
6089 :
6090 0 : if (plat == -90.0)
6091 : {
6092 0 : errorcode = for_trans[projcode] (plon, 0.0, &x, &y);
6093 0 : if (errorcode != 0)
6094 : {
6095 0 : status = -1;
6096 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6097 0 : HEreport("GCTP Error: %d\n", errorcode);
6098 0 : return (status);
6099 : }
6100 :
6101 0 : upleftpt[1] = y;
6102 :
6103 0 : errorcode = for_trans[projcode] (tlon, 0.0, &x, &y);
6104 0 : if (errorcode != 0)
6105 : {
6106 0 : status = -1;
6107 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6108 0 : HEreport("GCTP Error: %d\n", errorcode);
6109 0 : return (status);
6110 : }
6111 :
6112 0 : lowrightpt[1] = y;
6113 : }
6114 0 : else if (plat == 90.0)
6115 : {
6116 0 : errorcode = for_trans[projcode] (tlon, 0.0, &x, &y);
6117 0 : if (errorcode != 0)
6118 : {
6119 0 : status = -1;
6120 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6121 0 : HEreport("GCTP Error: %d\n", errorcode);
6122 0 : return (status);
6123 : }
6124 :
6125 0 : upleftpt[1] = y;
6126 :
6127 0 : errorcode = for_trans[projcode] (plon, 0.0, &x, &y);
6128 0 : if (errorcode != 0)
6129 : {
6130 0 : status = -1;
6131 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6132 0 : HEreport("GCTP Error: %d\n", errorcode);
6133 0 : return (status);
6134 : }
6135 :
6136 0 : lowrightpt[1] = y;
6137 : }
6138 : else
6139 : {
6140 0 : lat = EHconvAng(90, HDFE_DEG_RAD);
6141 0 : errorcode = for_trans[projcode] (plon, lat, &x, &y);
6142 0 : if (errorcode != 0)
6143 : {
6144 0 : status = -1;
6145 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6146 0 : HEreport("GCTP Error: %d\n", errorcode);
6147 0 : return (status);
6148 : }
6149 :
6150 0 : upleftpt[1] = y;
6151 :
6152 0 : lat = EHconvAng(-90, HDFE_DEG_RAD);
6153 0 : errorcode = for_trans[projcode] (plon, lat, &x, &y);
6154 0 : if (errorcode != 0)
6155 : {
6156 0 : status = -1;
6157 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6158 0 : HEreport("GCTP Error: %d\n", errorcode);
6159 0 : return (status);
6160 : }
6161 :
6162 0 : lowrightpt[1] = y;
6163 : }
6164 : }
6165 :
6166 : /* Compute Default Boundary Points for Integerized Sinusoidal Grid */
6167 : /* --------------------------------------------------------------- */
6168 0 : if (((projcode == GCTP_ISINUS) || (projcode == GCTP_ISINUS1)) &&
6169 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
6170 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
6171 : {
6172 : /*
6173 : * Convert the longitude and latitude from the DMS to decimal degree
6174 : * format.
6175 : */
6176 0 : plon = EHconvAng(projparm[4], HDFE_DMS_DEG);
6177 : /*plat = EHconvAng(projparm[5], HDFE_DMS_DEG); */
6178 :
6179 : /*
6180 : * Compute the longitudes at 90, 180 and 270 degrees from the central
6181 : * longitude.
6182 : */
6183 :
6184 0 : if (plon <= 0.0)
6185 : {
6186 0 : tlon = 180.0 + plon;
6187 0 : pplon = plon + 360.0;
6188 : }
6189 : else
6190 : {
6191 0 : tlon = plon - 180.0;
6192 0 : pplon = plon;
6193 : }
6194 :
6195 0 : rlon = pplon + 90.0;
6196 0 : if (rlon > 360.0)
6197 0 : rlon = rlon - 360;
6198 :
6199 0 : if (rlon > 180.0)
6200 0 : rlon = rlon - 360.0;
6201 :
6202 0 : if (rlon <= 0.0)
6203 0 : llon = 180.0 + rlon;
6204 : else
6205 0 : llon = rlon - 180.0;
6206 :
6207 : /* Convert all four longitudes from decimal degrees to radians */
6208 0 : plon = EHconvAng(plon, HDFE_DEG_RAD);
6209 0 : tlon = EHconvAng(tlon, HDFE_DEG_RAD);
6210 0 : llon = EHconvAng(llon, HDFE_DEG_RAD);
6211 0 : rlon = EHconvAng(rlon, HDFE_DEG_RAD);
6212 :
6213 0 : errorcode = for_trans[projcode] (llon, 0.0, &x, &y);
6214 0 : if (errorcode != 0)
6215 : {
6216 0 : status = -1;
6217 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6218 0 : HEreport("GCTP Error: %d\n", errorcode);
6219 0 : return (status);
6220 : }
6221 :
6222 0 : upleftpt[0] = x;
6223 :
6224 0 : errorcode = for_trans[projcode] (rlon, 0.0, &x, &y);
6225 0 : if (errorcode != 0)
6226 : {
6227 0 : status = -1;
6228 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6229 0 : HEreport("GCTP Error: %d\n", errorcode);
6230 0 : return (status);
6231 : }
6232 :
6233 0 : lowrightpt[0] = x;
6234 :
6235 0 : lat = EHconvAng(90, HDFE_DEG_RAD);
6236 0 : errorcode = for_trans[projcode] (plon, lat, &x, &y);
6237 0 : if (errorcode != 0)
6238 : {
6239 0 : status = -1;
6240 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6241 0 : HEreport("GCTP Error: %d\n", errorcode);
6242 0 : return (status);
6243 : }
6244 :
6245 0 : upleftpt[1] = y;
6246 :
6247 0 : lat = EHconvAng(-90, HDFE_DEG_RAD);
6248 0 : errorcode = for_trans[projcode] (plon, lat, &x, &y);
6249 0 : if (errorcode != 0)
6250 : {
6251 0 : status = -1;
6252 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
6253 0 : HEreport("GCTP Error: %d\n", errorcode);
6254 0 : return (status);
6255 : }
6256 :
6257 0 : lowrightpt[1] = y;
6258 : }
6259 0 : return (errorcode);
6260 : }
6261 :
6262 : /*----------------------------------------------------------------------------|
6263 : | BEGIN_PROLOG |
6264 : | |
6265 : | FUNCTION: GDll2ij |
6266 : | |
6267 : | DESCRIPTION: |
6268 : | |
6269 : | |
6270 : | Return Value Type Units Description |
6271 : | ============ ====== ========= ===================================== |
6272 : | status intn return status (0) SUCCEED, (-1) FAIL |
6273 : | |
6274 : | INPUTS: |
6275 : | projcode int32 GCTP projection code |
6276 : | zonecode int32 UTM zone code |
6277 : | projparm float64 Projection parameters |
6278 : | spherecode int32 GCTP spheriod code |
6279 : | xdimsize int32 xdimsize from GDcreate |
6280 : | ydimsize int32 ydimsize from GDcreate |
6281 : | upleftpt float64 upper left corner coordinates |
6282 : | lowrightpt float64 lower right corner coordinates |
6283 : | npnts int32 number of lon-lat points |
6284 : | longitude float64 longitude array (radians) |
6285 : | latitude float64 latitude array (radians) |
6286 : | |
6287 : | OUTPUTS: |
6288 : | row int32 Row array |
6289 : | col int32 Column array |
6290 : | xval float64 X value array |
6291 : | yval float64 Y value array |
6292 : | |
6293 : | |
6294 : | NOTES: |
6295 : | |
6296 : | |
6297 : | Date Programmer Description |
6298 : | ====== ============ ================================================= |
6299 : | Jun 96 Joel Gales Original Programmer |
6300 : | Aug 96 Joel Gales Return x and y values if requested |
6301 : | Jun 00 Abe Taaheri Added support for EASE grid |
6302 : | |
6303 : | END_PROLOG |
6304 : -----------------------------------------------------------------------------*/
6305 : static intn
6306 0 : GDll2ij(int32 projcode, int32 zonecode, float64 projparm[],
6307 : int32 spherecode, int32 xdimsize, int32 ydimsize,
6308 : float64 upleftpt[], float64 lowrightpt[],
6309 : int32 npnts, float64 longitude[], float64 latitude[],
6310 : int32 row[], int32 col[], float64 xval[], float64 yval[])
6311 :
6312 :
6313 : {
6314 : intn i; /* Loop index */
6315 0 : intn status = 0; /* routine return status variable */
6316 :
6317 0 : int32 errorcode = 0; /* GCTP error code */
6318 : int32(*for_trans[100]) (double, double, double*, double*); /* GCTP function pointer */
6319 :
6320 : float64 xVal; /* Scaled x distance */
6321 : float64 yVal; /* Scaled y distance */
6322 : float64 xMtr; /* X value in meters from GCTP */
6323 : float64 yMtr; /* Y value in meters from GCTP */
6324 : float64 lonrad0; /* Longitude in radians of upleft point */
6325 0 : float64 latrad0 = 0; /* Latitude in radians of upleft point */
6326 : float64 lonrad; /* Longitude in radians of point */
6327 : float64 latrad; /* Latitude in radians of point */
6328 : float64 scaleX; /* X scale factor */
6329 : float64 scaleY; /* Y scale factor */
6330 0 : float64 xMtr0 = 0, xMtr1, yMtr0 = 0, yMtr1;
6331 : float64 lonrad1; /* Longitude in radians of lowright point */
6332 :
6333 : /* If projection not GEO call GCTP initialization routine */
6334 : /* ------------------------------------------------------ */
6335 0 : if (projcode != GCTP_GEO)
6336 : {
6337 0 : for_init(projcode, zonecode, projparm, spherecode, NULL, NULL,
6338 : &errorcode, for_trans);
6339 :
6340 : /* Report error if any */
6341 : /* ------------------- */
6342 0 : if (errorcode != 0)
6343 : {
6344 0 : status = -1;
6345 0 : HEpush(DFE_GENAPP, "GDll2ij", __FILE__, __LINE__);
6346 0 : HEreport("GCTP Error: %d\n", errorcode);
6347 : }
6348 : }
6349 :
6350 :
6351 0 : if (status == 0)
6352 : {
6353 : /* GEO projection */
6354 : /* -------------- */
6355 0 : if (projcode == GCTP_GEO)
6356 : {
6357 : /* Convert upleft and lowright X coords from DMS to radians */
6358 : /* -------------------------------------------------------- */
6359 0 : lonrad0 = EHconvAng(upleftpt[0], HDFE_DMS_RAD);
6360 0 : lonrad = EHconvAng(lowrightpt[0], HDFE_DMS_RAD);
6361 :
6362 : /* Compute x scale factor */
6363 : /* ---------------------- */
6364 0 : scaleX = (lonrad - lonrad0) / xdimsize;
6365 :
6366 :
6367 : /* Convert upleft and lowright Y coords from DMS to radians */
6368 : /* -------------------------------------------------------- */
6369 0 : latrad0 = EHconvAng(upleftpt[1], HDFE_DMS_RAD);
6370 0 : latrad = EHconvAng(lowrightpt[1], HDFE_DMS_RAD);
6371 :
6372 :
6373 : /* Compute y scale factor */
6374 : /* ---------------------- */
6375 0 : scaleY = (latrad - latrad0) / ydimsize;
6376 : }
6377 :
6378 : /* BCEA projection */
6379 : /* -------------- */
6380 0 : else if ( projcode == GCTP_BCEA)
6381 : {
6382 : /* Convert upleft and lowright X coords from DMS to radians */
6383 : /* -------------------------------------------------------- */
6384 :
6385 0 : lonrad0 = EHconvAng(upleftpt[0], HDFE_DMS_RAD);
6386 0 : lonrad = EHconvAng(lowrightpt[0], HDFE_DMS_RAD);
6387 :
6388 : /* Convert upleft and lowright Y coords from DMS to radians */
6389 : /* -------------------------------------------------------- */
6390 0 : latrad0 = EHconvAng(upleftpt[1], HDFE_DMS_RAD);
6391 0 : latrad = EHconvAng(lowrightpt[1], HDFE_DMS_RAD);
6392 :
6393 : /* Convert from lon/lat to meters(or whatever unit is, i.e unit
6394 : of r_major and r_minor) using GCTP */
6395 : /* ----------------------------------------- */
6396 0 : errorcode = for_trans[projcode] (lonrad0, latrad0, &xMtr0, &yMtr0);
6397 :
6398 :
6399 : /* Report error if any */
6400 : /* ------------------- */
6401 0 : if (errorcode != 0)
6402 : {
6403 0 : status = -1;
6404 0 : HEpush(DFE_GENAPP, "GDll2ij", __FILE__, __LINE__);
6405 0 : HEreport("GCTP Error: %d\n", errorcode);
6406 0 : return (status);
6407 : }
6408 :
6409 : /* Convert from lon/lat to meters(or whatever unit is, i.e unit
6410 : of r_major and r_minor) using GCTP */
6411 : /* ----------------------------------------- */
6412 0 : errorcode = for_trans[projcode] (lonrad, latrad, &xMtr1, &yMtr1);
6413 :
6414 :
6415 : /* Report error if any */
6416 : /* ------------------- */
6417 0 : if (errorcode != 0)
6418 : {
6419 0 : status = -1;
6420 0 : HEpush(DFE_GENAPP, "GDll2ij", __FILE__, __LINE__);
6421 0 : HEreport("GCTP Error: %d\n", errorcode);
6422 0 : return (status);
6423 : }
6424 :
6425 : /* Compute x scale factor */
6426 : /* ---------------------- */
6427 0 : scaleX = (xMtr1 - xMtr0) / xdimsize;
6428 :
6429 : /* Compute y scale factor */
6430 : /* ---------------------- */
6431 0 : scaleY = (yMtr1 - yMtr0) / ydimsize;
6432 : }
6433 : else
6434 : {
6435 : /* Non-GEO, Non_BCEA projections */
6436 : /* ---------------------------- */
6437 :
6438 : /* Compute x & y scale factors */
6439 : /* --------------------------- */
6440 0 : scaleX = (lowrightpt[0] - upleftpt[0]) / xdimsize;
6441 0 : scaleY = (lowrightpt[1] - upleftpt[1]) / ydimsize;
6442 : }
6443 :
6444 :
6445 :
6446 : /* Loop through all points */
6447 : /* ----------------------- */
6448 0 : for (i = 0; i < npnts; i++)
6449 : {
6450 : /* Convert lon & lat from decimal degrees to radians */
6451 : /* ------------------------------------------------- */
6452 0 : lonrad = EHconvAng(longitude[i], HDFE_DEG_RAD);
6453 0 : latrad = EHconvAng(latitude[i], HDFE_DEG_RAD);
6454 :
6455 :
6456 : /* GEO projection */
6457 : /* -------------- */
6458 0 : if (projcode == GCTP_GEO)
6459 : {
6460 : /* allow map to span dateline */
6461 0 : lonrad0 = EHconvAng(upleftpt[0], HDFE_DMS_RAD);
6462 0 : lonrad1 = EHconvAng(lowrightpt[0], HDFE_DMS_RAD);
6463 : /* if time-line is passed */
6464 0 : if(lonrad < lonrad1)
6465 : {
6466 0 : if (lonrad < lonrad0) lonrad += 2.0 * M_PI;
6467 0 : if (lonrad > lonrad1) lonrad -= 2.0 * M_PI;
6468 : }
6469 :
6470 : /* Compute scaled distance to point from origin */
6471 : /* -------------------------------------------- */
6472 0 : xVal = (lonrad - lonrad0) / scaleX;
6473 0 : yVal = (latrad - latrad0) / scaleY;
6474 : }
6475 : else
6476 : {
6477 : /* Convert from lon/lat to meters using GCTP */
6478 : /* ----------------------------------------- */
6479 0 : errorcode = for_trans[projcode] (lonrad, latrad, &xMtr, &yMtr);
6480 :
6481 :
6482 : /* Report error if any */
6483 : /* ------------------- */
6484 0 : if (errorcode != 0)
6485 : {
6486 : /*status = -1;
6487 : HEpush(DFE_GENAPP, "GDll2ij", __FILE__, __LINE__);
6488 : HEreport("GCTP Error: %d\n", errorcode);
6489 : return (status); */ /* Bruce Beaumont */
6490 0 : xVal = -2147483648.0; /* Bruce Beaumont */
6491 0 : yVal = -2147483648.0; /* Bruce Beaumont */
6492 : }/* (Note: MAXLONG is defined as 2147483647.0 in
6493 : function cproj.c of GCTP) */
6494 : else {
6495 : /* if projection is BCEA normalize x and y by cell size and
6496 : measure it from the upperleft corner of the grid */
6497 :
6498 : /* Compute scaled distance to point from origin */
6499 : /* -------------------------------------------- */
6500 0 : if( projcode == GCTP_BCEA)
6501 : {
6502 0 : xVal = (xMtr - xMtr0) / scaleX;
6503 0 : yVal = (yMtr - yMtr0) / scaleY;
6504 : }
6505 : else
6506 : {
6507 0 : xVal = (xMtr - upleftpt[0]) / scaleX;
6508 0 : yVal = (yMtr - upleftpt[1]) / scaleY;
6509 : }
6510 : }
6511 : }
6512 :
6513 :
6514 : /* Compute row and col from scaled distance */
6515 : /* ---------------------------------------- */
6516 0 : col[i] = (int32) xVal;
6517 0 : row[i] = (int32) yVal;
6518 :
6519 : /* Store scaled distances if requested */
6520 : /* ----------------------------------- */
6521 0 : if (xval != NULL)
6522 : {
6523 0 : xval[i] = xVal;
6524 : }
6525 :
6526 0 : if (yval != NULL)
6527 : {
6528 0 : yval[i] = yVal;
6529 : }
6530 : }
6531 : }
6532 0 : return (status);
6533 : }
6534 :
6535 :
6536 :
6537 :
6538 : /*----------------------------------------------------------------------------|
6539 : | BEGIN_PROLOG |
6540 : | |
6541 : | FUNCTION: GDrs2ll |
6542 : | |
6543 : | DESCRIPTION: Converts EASE grid's (r,s) coordinates to longitude and |
6544 : | latitude (in decimal degrees). |
6545 : | |
6546 : | |
6547 : | Return Value Type Units Description |
6548 : | ============ ====== ========= ===================================== |
6549 : | status intn return status (0) SUCCEED, (-1) FAIL |
6550 : | |
6551 : | INPUTS: |
6552 : | projcode int32 GCTP projection code |
6553 : | projparm float64 Projection parameters |
6554 : | xdimsize int32 xdimsize from GDcreate |
6555 : | ydimsize int32 ydimsize from GDcreate |
6556 : | pixcen int32 pixel center code |
6557 : | npnts int32 number of lon-lat points |
6558 : | s int32 s coordinate |
6559 : | r int32 r coordinate |
6560 : | pixcen int32 Code from GDpixreginfo |
6561 : | pixcnr int32 Code from GDorigininfo |
6562 : | upleft float64 upper left corner coordinates (DMS) |
6563 : | lowright float64 lower right corner coordinates (DMS) |
6564 : | |
6565 : | |
6566 : | OUTPUTS: |
6567 : | longitude float64 longitude array (decimal degrees) |
6568 : | latitude float64 latitude array (decimal degrees) |
6569 : | |
6570 : | NOTES: |
6571 : | |
6572 : | |
6573 : | Date Programmer Description |
6574 : | ====== ============ ================================================= |
6575 : | Jul 00 Abe Taaheri Original Programmer |
6576 : | |
6577 : | END_PROLOG |
6578 : -----------------------------------------------------------------------------*/
6579 : intn
6580 0 : GDrs2ll(int32 projcode, float64 projparm[],
6581 : int32 xdimsize, int32 ydimsize,
6582 : float64 upleft[], float64 lowright[],
6583 : int32 npnts, float64 r[], float64 s[],
6584 : float64 longitude[], float64 latitude[], int32 pixcen, int32 pixcnr)
6585 : {
6586 : intn i; /* Loop index */
6587 0 : intn status = 0; /* routine return status variable */
6588 :
6589 0 : int32 errorcode = 0; /* GCTP error code */
6590 : int32(*inv_trans[100]) (double, double, double*, double*); /* GCTP function pointer */
6591 :
6592 0 : float64 pixadjX = 0.0; /* Pixel adjustment (x) */
6593 0 : float64 pixadjY = 0.0; /* Pixel adjustment (y) */
6594 : float64 lonrad; /* Longitude in radians of point */
6595 : float64 latrad; /* Latitude in radians of point */
6596 : float64 xMtr; /* X value in meters from GCTP */
6597 : float64 yMtr; /* Y value in meters from GCTP */
6598 : float64 epsilon;
6599 : float64 beta;
6600 0 : float64 qp_cea = 0;
6601 0 : float64 kz_cea = 0;
6602 : float64 eccen, eccen_sq;
6603 : float64 phi1, sinphi1, cosphi1;
6604 : float64 scaleX, scaleY;
6605 :
6606 0 : int32 zonecode=0;
6607 :
6608 0 : int32 spherecode=0;
6609 : float64 lon[2],lat[2];
6610 : float64 xcor[2], ycor[2];
6611 : int32 nlatlon;
6612 :
6613 : /* If projection is BCEA define scale, r0 and s0 */
6614 0 : if (projcode == GCTP_BCEA)
6615 : {
6616 0 : eccen_sq = 1.0 - SQUARE(projparm[1]/projparm[0]);
6617 0 : eccen = sqrt(eccen_sq);
6618 0 : if(eccen < 0.00001)
6619 : {
6620 0 : qp_cea = 2.0;
6621 : }
6622 : else
6623 : {
6624 0 : qp_cea =
6625 0 : (1.0 - eccen_sq)*((1.0/(1.0 - eccen_sq))-(1.0/(2.0*eccen))*
6626 0 : log((1.0 - eccen)/(1.0 + eccen)));
6627 : }
6628 0 : phi1 = EHconvAng(projparm[5],HDFE_DMS_RAD);
6629 0 : cosphi1 = cos(phi1);
6630 0 : sinphi1 = sin(phi1);
6631 0 : kz_cea = cosphi1/(sqrt(1.0 - (eccen_sq*sinphi1*sinphi1)));
6632 : }
6633 :
6634 :
6635 :
6636 :
6637 : /* Compute adjustment of position within pixel */
6638 : /* ------------------------------------------- */
6639 0 : if (pixcen == HDFE_CENTER)
6640 : {
6641 : /* Pixel defined at center */
6642 : /* ----------------------- */
6643 0 : pixadjX = 0.5;
6644 0 : pixadjY = 0.5;
6645 : }
6646 : else
6647 : {
6648 0 : switch (pixcnr)
6649 : {
6650 0 : case HDFE_GD_UL:
6651 : {
6652 : /* Pixel defined at upper left corner */
6653 : /* ---------------------------------- */
6654 0 : pixadjX = 0.0;
6655 0 : pixadjY = 0.0;
6656 0 : break;
6657 : }
6658 :
6659 0 : case HDFE_GD_UR:
6660 : {
6661 : /* Pixel defined at upper right corner */
6662 : /* ----------------------------------- */
6663 0 : pixadjX = 1.0;
6664 0 : pixadjY = 0.0;
6665 0 : break;
6666 : }
6667 :
6668 0 : case HDFE_GD_LL:
6669 : {
6670 : /* Pixel defined at lower left corner */
6671 : /* ---------------------------------- */
6672 0 : pixadjX = 0.0;
6673 0 : pixadjY = 1.0;
6674 0 : break;
6675 : }
6676 :
6677 0 : case HDFE_GD_LR:
6678 : {
6679 : /* Pixel defined at lower right corner */
6680 : /* ----------------------------------- */
6681 0 : pixadjX = 1.0;
6682 0 : pixadjY = 1.0;
6683 0 : break;
6684 : }
6685 :
6686 : }
6687 0 : }
6688 :
6689 : /* If projection is BCEA call GCTP initialization routine */
6690 : /* ------------------------------------------------------ */
6691 0 : if (projcode == GCTP_BCEA)
6692 : {
6693 :
6694 0 : inv_init(projcode, 0, projparm, 0, NULL, NULL,
6695 : &errorcode, inv_trans);
6696 :
6697 : /* Report error if any */
6698 : /* ------------------- */
6699 0 : if (errorcode != 0)
6700 : {
6701 0 : status = -1;
6702 0 : HEpush(DFE_GENAPP, "GDrs2ll", __FILE__, __LINE__);
6703 0 : HEreport("GCTP Error: %d\n", errorcode);
6704 : }
6705 : else
6706 : {
6707 : /* For each point ... */
6708 : /* ------------------ */
6709 0 : for (i = 0; i < npnts; i++)
6710 : {
6711 : /* Convert from EASE grid's (r,s) to lon/lat (radians)
6712 : using GCTP */
6713 : /* --------------------------------------------------- */
6714 0 : nlatlon = 2;
6715 0 : lon[0] = upleft[0];
6716 0 : lon[1] = lowright[0];
6717 0 : lat[0] = upleft[1];
6718 0 : lat[1] = lowright[1];
6719 : status =
6720 0 : GDll2mm_cea(projcode,zonecode,spherecode,projparm,
6721 : xdimsize, ydimsize,
6722 : upleft, lowright, nlatlon,
6723 : lon, lat,
6724 : xcor, ycor, &scaleX, &scaleY);
6725 :
6726 0 : if (status == -1)
6727 : {
6728 0 : HEpush(DFE_GENAPP, "GDrs2ll", __FILE__, __LINE__);
6729 0 : return (status);
6730 : }
6731 :
6732 0 : xMtr = (r[i]/ scaleX + pixadjX - 0.5)* scaleX;
6733 0 : yMtr = - (s[i]/fabs(scaleY) + pixadjY - 0.5)* fabs(scaleY);
6734 :
6735 :
6736 : /* allow .5 cell tolerance in arcsin function
6737 : (used in bceainv function) so that grid
6738 : coordinates which are less than .5 cells
6739 : above 90.00N or below 90.00S are given lat of 90.00
6740 : */
6741 :
6742 0 : epsilon = 1 + 0.5 * (fabs(scaleY)/projparm[0]);
6743 0 : beta = 2.0 * (yMtr - projparm[7]) * kz_cea/(projparm[0] * qp_cea);
6744 :
6745 0 : if( fabs (beta) > epsilon)
6746 : {
6747 0 : status = -1;
6748 0 : HEpush(DFE_GENAPP, "GDrs2ll", __FILE__, __LINE__);
6749 0 : HEreport("GCTP Error: %s %s %s\n", "grid coordinates",
6750 : "are more than .5 cells",
6751 : "above 90.00N or below 90.00S. ");
6752 0 : return (status);
6753 : }
6754 0 : else if( beta <= -1)
6755 : {
6756 0 : errorcode = inv_trans[projcode] (xMtr, 0.0,
6757 : &lonrad, &latrad);
6758 0 : latrad = - M_PI/2;
6759 : }
6760 0 : else if( beta >= 1)
6761 : {
6762 0 : errorcode = inv_trans[projcode] (xMtr, 0.0,
6763 : &lonrad, &latrad);
6764 0 : latrad = M_PI/2;
6765 : }
6766 : else
6767 : {
6768 0 : errorcode = inv_trans[projcode] (xMtr, yMtr,
6769 : &lonrad, &latrad);
6770 : }
6771 :
6772 : /* Report error if any */
6773 : /* ------------------- */
6774 0 : if (errorcode != 0)
6775 : {
6776 0 : status = -1;
6777 0 : HEpush(DFE_GENAPP, "GDrs2ll", __FILE__, __LINE__);
6778 0 : HEreport("GCTP Error: %d\n", errorcode);
6779 0 : return (status);
6780 : }
6781 :
6782 : /* Convert from radians to decimal degrees */
6783 : /* --------------------------------------- */
6784 0 : longitude[i] = EHconvAng(lonrad, HDFE_RAD_DEG);
6785 0 : latitude[i] = EHconvAng(latrad, HDFE_RAD_DEG);
6786 : }
6787 : }
6788 : }
6789 :
6790 :
6791 :
6792 :
6793 0 : return (status);
6794 : }
6795 :
6796 :
6797 :
6798 : /*----------------------------------------------------------------------------|
6799 : | BEGIN_PROLOG |
6800 : | |
6801 : | FUNCTION: lamaxDxDtheta |
6802 : | |
6803 : | DESCRIPTION: Partial derivative along longitude line for Lambert Azimuthal |
6804 : | |
6805 : | |
6806 : | Return Value Type Units Description |
6807 : | ============ ====== ========= ===================================== |
6808 : | float64 Dx/D(theta) for LAMAZ projection |
6809 : | |
6810 : | INPUTS: |
6811 : | parms float64 Parameters defining partial derivative |
6812 : | |
6813 : | OUTPUTS: |
6814 : | None |
6815 : | |
6816 : | NOTES: |
6817 : | |
6818 : | |
6819 : | Date Programmer Description |
6820 : | ====== ============ ================================================= |
6821 : | Nov 96 Joel Gales Original Programmer |
6822 : | |
6823 : | END_PROLOG |
6824 : -----------------------------------------------------------------------------*/
6825 : static float64
6826 0 : lamazDxDtheta(float64 parms[])
6827 : {
6828 : float64 snTheta, sn2Theta, snTheta1, csTheta1, csLamda;
6829 :
6830 0 : snTheta = sin(EHconvAng(parms[0], HDFE_DEG_RAD));
6831 0 : sn2Theta = sin(2 * EHconvAng(parms[0], HDFE_DEG_RAD));
6832 0 : snTheta1 = sin(EHconvAng(parms[1], HDFE_DEG_RAD));
6833 0 : csTheta1 = cos(EHconvAng(parms[1], HDFE_DEG_RAD));
6834 0 : csLamda = cos(EHconvAng(parms[2], HDFE_DEG_RAD) -
6835 0 : EHconvAng(parms[3], HDFE_DEG_RAD));
6836 :
6837 0 : return (4 * snTheta +
6838 0 : (csTheta1 * csLamda * sn2Theta) +
6839 0 : (2 * snTheta1 * (1 + (snTheta * snTheta))));
6840 : }
6841 :
6842 :
6843 :
6844 :
6845 : /*----------------------------------------------------------------------------|
6846 : | BEGIN_PROLOG |
6847 : | |
6848 : | FUNCTION: lamaxDxDlamda |
6849 : | |
6850 : | DESCRIPTION: Partial derivative along latitude line for Lambert Azimuthal |
6851 : | |
6852 : | |
6853 : | Return Value Type Units Description |
6854 : | ============ ====== ========= ===================================== |
6855 : | float64 Dx/D(lamda) for LAMAZ projection |
6856 : | |
6857 : | INPUTS: |
6858 : | parms float64 Parameters defining partial derivative |
6859 : | |
6860 : | OUTPUTS: |
6861 : | None |
6862 : | |
6863 : | NOTES: |
6864 : | |
6865 : | |
6866 : | Date Programmer Description |
6867 : | ====== ============ ================================================= |
6868 : | Nov 96 Joel Gales Original Programmer |
6869 : | |
6870 : | END_PROLOG |
6871 : -----------------------------------------------------------------------------*/
6872 : static float64
6873 0 : lamazDxDlamda(float64 parms[])
6874 : {
6875 : float64 snTheta, csTheta, snTheta1, csTheta1, csLamda;
6876 : float64 cs, sn;
6877 :
6878 0 : snTheta = sin(EHconvAng(parms[2], HDFE_DEG_RAD));
6879 0 : csTheta = cos(EHconvAng(parms[2], HDFE_DEG_RAD));
6880 0 : snTheta1 = sin(EHconvAng(parms[1], HDFE_DEG_RAD));
6881 0 : csTheta1 = cos(EHconvAng(parms[1], HDFE_DEG_RAD));
6882 0 : csLamda = cos(EHconvAng(parms[0], HDFE_DEG_RAD) -
6883 0 : EHconvAng(parms[3], HDFE_DEG_RAD));
6884 :
6885 0 : cs = csTheta * csTheta1;
6886 0 : sn = snTheta * snTheta1;
6887 :
6888 0 : return (cs + (2 * (1 + sn) + (cs * csLamda)) * csLamda);
6889 : }
6890 :
6891 :
6892 :
6893 : /*----------------------------------------------------------------------------|
6894 : | BEGIN_PROLOG |
6895 : | |
6896 : | FUNCTION: lamaxDyDtheta |
6897 : | |
6898 : | DESCRIPTION: Partial derivative along longitude line for Lambert Azimuthal |
6899 : | |
6900 : | |
6901 : | Return Value Type Units Description |
6902 : | ============ ====== ========= ===================================== |
6903 : | float64 Dy/D(theta) for LAMAZ projection |
6904 : | |
6905 : | INPUTS: |
6906 : | parms float64 Parameters defining partial derivative |
6907 : | |
6908 : | OUTPUTS: |
6909 : | None |
6910 : | |
6911 : | NOTES: |
6912 : | |
6913 : | |
6914 : | Date Programmer Description |
6915 : | ====== ============ ================================================= |
6916 : | Nov 96 Joel Gales Original Programmer |
6917 : | |
6918 : | END_PROLOG |
6919 : -----------------------------------------------------------------------------*/
6920 : static float64
6921 0 : lamazDyDtheta(float64 parms[])
6922 : {
6923 : float64 snTheta, csTheta, snTheta1, csTheta1, csLamda;
6924 : float64 sn2, cs2, sndiff;
6925 :
6926 0 : snTheta = sin(EHconvAng(parms[0], HDFE_DEG_RAD));
6927 0 : csTheta = cos(EHconvAng(parms[0], HDFE_DEG_RAD));
6928 0 : snTheta1 = sin(EHconvAng(parms[1], HDFE_DEG_RAD));
6929 0 : csTheta1 = cos(EHconvAng(parms[1], HDFE_DEG_RAD));
6930 0 : csLamda = cos(EHconvAng(parms[2], HDFE_DEG_RAD) -
6931 0 : EHconvAng(parms[3], HDFE_DEG_RAD));
6932 :
6933 0 : sn2 = snTheta1 * snTheta;
6934 0 : cs2 = csTheta1 * csTheta;
6935 0 : sndiff = snTheta1 - snTheta;
6936 :
6937 0 : return (cs2 * (sn2 * (1 + (csLamda * csLamda)) + 2) +
6938 0 : csLamda * (2 * (1 + sn2 * sn2) - (sndiff * sndiff)));
6939 : }
6940 :
6941 :
6942 :
6943 : /*----------------------------------------------------------------------------|
6944 : | BEGIN_PROLOG |
6945 : | |
6946 : | FUNCTION: homDyDtheta |
6947 : | |
6948 : | DESCRIPTION: Partial derivative along longitude line for Oblique Mercator |
6949 : | |
6950 : | |
6951 : | Return Value Type Units Description |
6952 : | ============ ====== ========= ===================================== |
6953 : | float64 Dx/D(theta) for HOM projection |
6954 : | |
6955 : | INPUTS: |
6956 : | parms float64 Parameters defining partial derivative |
6957 : | |
6958 : | OUTPUTS: |
6959 : | None |
6960 : | |
6961 : | NOTES: |
6962 : | |
6963 : | |
6964 : | Date Programmer Description |
6965 : | ====== ============ ================================================= |
6966 : | Mar 97 Joel Gales Original Programmer |
6967 : | |
6968 : | END_PROLOG |
6969 : -----------------------------------------------------------------------------*/
6970 : static float64
6971 0 : homDyDtheta(float64 parms[])
6972 : {
6973 : float64 tnTheta, tnTheta1, snLamda;
6974 :
6975 0 : tnTheta = tan(EHconvAng(parms[0], HDFE_DEG_RAD));
6976 0 : tnTheta1 = tan(EHconvAng(parms[1], HDFE_DEG_RAD));
6977 0 : snLamda = cos(EHconvAng(parms[2], HDFE_DEG_RAD) -
6978 0 : EHconvAng(parms[3], HDFE_DEG_RAD));
6979 :
6980 0 : return (tnTheta * snLamda + tnTheta1);
6981 : }
6982 :
6983 :
6984 :
6985 :
6986 : /*----------------------------------------------------------------------------|
6987 : | BEGIN_PROLOG |
6988 : | |
6989 : | FUNCTION: GDtangentpnts |
6990 : | |
6991 : | DESCRIPTION: Finds tangent points along lon/lat lines |
6992 : | |
6993 : | |
6994 : | Return Value Type Units Description |
6995 : | ============ ====== ========= ===================================== |
6996 : | status intn return status (0) SUCCEED, (-1) FAIL |
6997 : | |
6998 : | INPUTS: |
6999 : | projcode int32 Projection code |
7000 : | projparm float64 Projection parameters |
7001 : | cornerlon float64 dec deg Longitude of opposite corners of box |
7002 : | cornerlat float64 dec deg Latitude of opposite corners of box |
7003 : | longitude float64 dec deg Longitude of points to check |
7004 : | latitude float64 dec deg Latitude of points to check |
7005 : | |
7006 : | |
7007 : | OUTPUTS: |
7008 : | npnts int32 Number of points to check in subset |
7009 : | |
7010 : | NOTES: |
7011 : | |
7012 : | |
7013 : | Date Programmer Description |
7014 : | ====== ============ ================================================= |
7015 : | Nov 96 Joel Gales Original Programmer |
7016 : | Mar 97 Joel Gales Add support for LAMCC, POLYC, TM |
7017 : | Aug 99 Abe Taaheri Add support for ALBERS, and MERCAT projections. |
7018 : | Also changed mistyped bisectParm[2] to |
7019 : | bisectParm[3] for HOM projection. |
7020 : | Jun 00 Abe Taaheri Added support for EASE grid |
7021 : | |
7022 : | END_PROLOG |
7023 : -----------------------------------------------------------------------------*/
7024 : static intn
7025 0 : GDtangentpnts(int32 projcode, float64 projparm[], float64 cornerlon[],
7026 : float64 cornerlat[], float64 longitude[], float64 latitude[],
7027 : int32 * npnts)
7028 : {
7029 : intn i; /* Loop index */
7030 0 : intn status = 0; /* routine return status variable */
7031 :
7032 : float64 lonrad; /* Longitude (radians) */
7033 : float64 latrad; /* Latitude (radians) */
7034 : float64 cs[4]; /* Cosine array */
7035 : float64 sn[4]; /* Sine array */
7036 : float64 csTest; /* Cosine test value */
7037 : float64 snTest; /* Sine test value */
7038 : float64 crs01; /* Cross product */
7039 : float64 crsTest[2]; /* Cross product array */
7040 : float64 longPol; /* Longitude beneath pole */
7041 : float64 minLat; /* Minimum latitude */
7042 : float64 bisectParm[4]; /* Bisection parameters */
7043 : float64 tanLat; /* Tangent latitude */
7044 : float64 tanLon; /* Tangent longitude */
7045 : float64 dotPrd; /* Dot product */
7046 : float64 centMerd; /* Central Meridian */
7047 : float64 orgLat; /* Latitude of origin */
7048 : float64 dpi; /* Double precision pi */
7049 :
7050 : #if 0
7051 : float64 lamazDxDtheta(); /* Lambert Azimuthal Dx/Dtheta */
7052 : float64 lamazDxDlamda(); /* Lambert Azimuthal Dx/Dlamda */
7053 : float64 lamazDyDtheta(); /* Lambert Azimuthal Dy/Dtheta */
7054 : float64 homDyDtheta(); /* Oblique Mercator Dy/Dtheta */
7055 : #endif
7056 :
7057 : /* Compute pi (double precision) */
7058 : /* ----------------------------- */
7059 0 : dpi = atan(1.0) * 4;
7060 :
7061 :
7062 0 : switch (projcode)
7063 : {
7064 0 : case GCTP_MERCAT:
7065 : {
7066 : /* No need for tangent points, since MERCAT projection
7067 : is rectangular */
7068 : }
7069 0 : break;
7070 0 : case GCTP_BCEA:
7071 : {
7072 : /* No need for tangent points, since BCEA projection
7073 : is rectangular */
7074 : }
7075 0 : break;
7076 0 : case GCTP_CEA:
7077 : {
7078 : /* No need for tangent points, since CEA projection
7079 : is rectangular */
7080 : }
7081 0 : break;
7082 :
7083 0 : case GCTP_PS:
7084 : {
7085 : /* Add "xy axis" points for Polar Stereographic if necessary */
7086 : /* --------------------------------------------------------- */
7087 :
7088 :
7089 : /* Get minimum of corner latitudes */
7090 : /* ------------------------------- */
7091 0 : minLat = (fabs(cornerlat[0]) <= fabs(cornerlat[1]))
7092 0 : ? cornerlat[0] : cornerlat[1];
7093 :
7094 :
7095 : /* Compute sine and cosine of corner longitudes */
7096 : /* -------------------------------------------- */
7097 0 : for (i = 0; i < 2; i++)
7098 : {
7099 0 : lonrad = EHconvAng(cornerlon[i], HDFE_DEG_RAD);
7100 0 : cs[i] = cos(lonrad);
7101 0 : sn[i] = sin(lonrad);
7102 : }
7103 :
7104 :
7105 : /* Compute cross product */
7106 : /* --------------------- */
7107 0 : crs01 = cs[0] * sn[1] - cs[1] * sn[0];
7108 :
7109 :
7110 : /* Convert longitude beneath pole from DMS to DEG */
7111 : /* ---------------------------------------------- */
7112 0 : longPol = EHconvAng(projparm[4], HDFE_DMS_RAD);
7113 :
7114 :
7115 :
7116 0 : for (i = 0; i < 4; i++)
7117 : {
7118 0 : csTest = cos(longPol);
7119 0 : snTest = sin(longPol);
7120 :
7121 0 : crsTest[0] = cs[0] * snTest - csTest * sn[0];
7122 0 : crsTest[1] = cs[1] * snTest - csTest * sn[1];
7123 :
7124 0 : if ((crs01 > 0 && crsTest[0] > 0 && crsTest[1] < 0) ||
7125 0 : (crs01 < 0 && crsTest[0] < 0 && crsTest[1] < 0) ||
7126 0 : (crs01 < 0 && crsTest[0] > 0 && crsTest[1] < 0) ||
7127 0 : (crs01 < 0 && crsTest[0] > 0 && crsTest[1] > 0))
7128 : {
7129 0 : longitude[*npnts] = EHconvAng(longPol, HDFE_RAD_DEG);
7130 0 : latitude[*npnts] = minLat;
7131 0 : (*npnts)++;
7132 : }
7133 0 : longPol += 0.5 * dpi;
7134 : }
7135 : }
7136 0 : break;
7137 :
7138 :
7139 0 : case GCTP_LAMAZ:
7140 : {
7141 0 : if ((int32) projparm[5] == +90000000 ||
7142 0 : (int32) projparm[5] == -90000000)
7143 : {
7144 : /* Add "xy axis" points for Polar Lambert Azimuthal */
7145 : /* ------------------------------------------------ */
7146 0 : minLat = (fabs(cornerlat[0]) <= fabs(cornerlat[1]))
7147 0 : ? cornerlat[0] : cornerlat[1];
7148 :
7149 0 : for (i = 0; i < 2; i++)
7150 : {
7151 0 : lonrad = EHconvAng(cornerlon[i], HDFE_DEG_RAD);
7152 0 : cs[i] = cos(lonrad);
7153 0 : sn[i] = sin(lonrad);
7154 : }
7155 0 : crs01 = cs[0] * sn[1] - cs[1] * sn[0];
7156 :
7157 0 : longPol = EHconvAng(projparm[4], HDFE_DMS_RAD);
7158 0 : for (i = 0; i < 4; i++)
7159 : {
7160 0 : csTest = cos(longPol);
7161 0 : snTest = sin(longPol);
7162 :
7163 0 : crsTest[0] = cs[0] * snTest - csTest * sn[0];
7164 0 : crsTest[1] = cs[1] * snTest - csTest * sn[1];
7165 :
7166 0 : if ((crs01 > 0 && crsTest[0] > 0 && crsTest[1] < 0) ||
7167 0 : (crs01 < 0 && crsTest[0] < 0 && crsTest[1] < 0) ||
7168 0 : (crs01 < 0 && crsTest[0] > 0 && crsTest[1] < 0) ||
7169 0 : (crs01 < 0 && crsTest[0] > 0 && crsTest[1] > 0))
7170 : {
7171 0 : longitude[*npnts] = EHconvAng(longPol, HDFE_RAD_DEG);
7172 0 : latitude[*npnts] = minLat;
7173 0 : (*npnts)++;
7174 : }
7175 0 : longPol += 0.5 * dpi;
7176 : }
7177 : }
7178 0 : else if ((int32) projparm[5] == 0)
7179 : {
7180 : /* Add "Equator" points for Equatorial Lambert Azimuthal */
7181 : /* ----------------------------------------------------- */
7182 0 : if (cornerlat[0] * cornerlat[1] < 0)
7183 : {
7184 0 : longitude[4] = cornerlon[0];
7185 0 : latitude[4] = 0;
7186 :
7187 0 : longitude[5] = cornerlon[1];
7188 0 : latitude[5] = 0;
7189 :
7190 0 : *npnts = 6;
7191 : }
7192 : }
7193 : else
7194 : {
7195 : /* Add tangent points for Oblique Lambert Azimuthal */
7196 : /* ------------------------------------------------ */
7197 0 : bisectParm[0] = EHconvAng(projparm[5], HDFE_DMS_DEG);
7198 0 : bisectParm[2] = EHconvAng(projparm[4], HDFE_DMS_DEG);
7199 :
7200 :
7201 : /* Tangent to y-axis along longitude */
7202 : /* --------------------------------- */
7203 0 : for (i = 0; i < 2; i++)
7204 : {
7205 0 : bisectParm[1] = cornerlon[i];
7206 :
7207 0 : if (EHbisect(lamazDxDtheta, bisectParm, 3,
7208 0 : cornerlat[0], cornerlat[1],
7209 : 0.0001, &tanLat) == 0)
7210 : {
7211 0 : longitude[*npnts] = cornerlon[i];
7212 0 : latitude[*npnts] = tanLat;
7213 0 : (*npnts)++;
7214 : }
7215 : }
7216 :
7217 : /* Tangent to y-axis along latitude */
7218 : /* -------------------------------- */
7219 0 : for (i = 0; i < 2; i++)
7220 : {
7221 0 : bisectParm[1] = cornerlat[i];
7222 :
7223 0 : if (EHbisect(lamazDxDlamda, bisectParm, 3,
7224 0 : cornerlon[0], cornerlon[1],
7225 : 0.0001, &tanLon) == 0)
7226 : {
7227 0 : longitude[*npnts] = tanLon;
7228 0 : latitude[*npnts] = cornerlat[i];
7229 0 : (*npnts)++;
7230 : }
7231 : }
7232 :
7233 :
7234 : /* Tangent to x-axis along longitude */
7235 : /* --------------------------------- */
7236 0 : for (i = 0; i < 2; i++)
7237 : {
7238 0 : bisectParm[1] = cornerlon[i];
7239 :
7240 0 : if (EHbisect(lamazDyDtheta, bisectParm, 3,
7241 0 : cornerlat[0], cornerlat[1],
7242 : 0.0001, &tanLat) == 0)
7243 : {
7244 0 : longitude[*npnts] = cornerlon[i];
7245 0 : latitude[*npnts] = tanLat;
7246 0 : (*npnts)++;
7247 : }
7248 : }
7249 :
7250 : /* Tangent to x-axis along latitude */
7251 : /* -------------------------------- */
7252 0 : for (i = 0; i < 2; i++)
7253 : {
7254 0 : lonrad = EHconvAng(cornerlon[i], HDFE_DEG_RAD);
7255 0 : cs[i] = cos(lonrad);
7256 0 : sn[i] = sin(lonrad);
7257 : }
7258 0 : crs01 = cs[0] * sn[1] - cs[1] * sn[0];
7259 :
7260 0 : longPol = EHconvAng(projparm[4], HDFE_DMS_RAD);
7261 0 : for (i = 0; i < 2; i++)
7262 : {
7263 0 : csTest = cos(longPol);
7264 0 : snTest = sin(longPol);
7265 :
7266 0 : crsTest[0] = cs[0] * snTest - csTest * sn[0];
7267 0 : crsTest[1] = cs[1] * snTest - csTest * sn[1];
7268 :
7269 0 : if ((crs01 > 0 && crsTest[0] > 0 && crsTest[1] < 0) ||
7270 0 : (crs01 < 0 && crsTest[0] < 0 && crsTest[1] < 0) ||
7271 0 : (crs01 < 0 && crsTest[0] > 0 && crsTest[1] < 0) ||
7272 0 : (crs01 < 0 && crsTest[0] > 0 && crsTest[1] > 0))
7273 : {
7274 0 : longitude[*npnts] = EHconvAng(longPol, HDFE_RAD_DEG);
7275 0 : latitude[*npnts] = cornerlat[0];
7276 0 : (*npnts)++;
7277 0 : longitude[*npnts] = EHconvAng(longPol, HDFE_RAD_DEG);
7278 0 : latitude[*npnts] = cornerlat[1];
7279 0 : (*npnts)++;
7280 : }
7281 0 : longPol += dpi;
7282 : }
7283 : }
7284 : }
7285 0 : break;
7286 :
7287 :
7288 0 : case GCTP_GOOD:
7289 : {
7290 : /* Add "Equator" points for Goode Homolosine if necessary */
7291 : /* ------------------------------------------------------ */
7292 0 : if (cornerlat[0] * cornerlat[1] < 0)
7293 : {
7294 0 : longitude[4] = cornerlon[0];
7295 0 : latitude[4] = 0;
7296 :
7297 0 : longitude[5] = cornerlon[1];
7298 0 : latitude[5] = 0;
7299 :
7300 0 : *npnts = 6;
7301 : }
7302 : }
7303 0 : break;
7304 :
7305 :
7306 0 : case GCTP_LAMCC:
7307 : {
7308 : /* Compute sine and cosine of corner longitudes */
7309 : /* -------------------------------------------- */
7310 0 : for (i = 0; i < 2; i++)
7311 : {
7312 0 : lonrad = EHconvAng(cornerlon[i], HDFE_DEG_RAD);
7313 0 : cs[i] = cos(lonrad);
7314 0 : sn[i] = sin(lonrad);
7315 : }
7316 :
7317 :
7318 : /* Compute dot product */
7319 : /* ------------------- */
7320 0 : dotPrd = cs[0] * cs[1] + sn[0] * sn[1];
7321 :
7322 :
7323 : /* Convert central meridian (DMS to DEG) & compute sin & cos */
7324 : /* --------------------------------------------------------- */
7325 0 : centMerd = EHconvAng(projparm[4], HDFE_DMS_DEG);
7326 0 : lonrad = EHconvAng(centMerd, HDFE_DEG_RAD);
7327 0 : cs[1] = cos(lonrad);
7328 0 : sn[1] = sin(lonrad);
7329 :
7330 :
7331 : /* If box brackets central meridian ... */
7332 : /* ------------------------------------ */
7333 0 : if (cs[0] * cs[1] + sn[0] * sn[1] > dotPrd)
7334 : {
7335 0 : latitude[4] = cornerlat[0];
7336 0 : longitude[4] = centMerd;
7337 :
7338 0 : latitude[5] = cornerlat[1];
7339 0 : longitude[5] = centMerd;
7340 :
7341 0 : *npnts = 6;
7342 : }
7343 : }
7344 0 : break;
7345 :
7346 :
7347 0 : case GCTP_ALBERS:
7348 : {
7349 : /* Compute sine and cosine of corner longitudes */
7350 : /* -------------------------------------------- */
7351 0 : for (i = 0; i < 2; i++)
7352 : {
7353 0 : lonrad = EHconvAng(cornerlon[i], HDFE_DEG_RAD);
7354 0 : cs[i] = cos(lonrad);
7355 0 : sn[i] = sin(lonrad);
7356 : }
7357 :
7358 :
7359 : /* Compute dot product */
7360 : /* ------------------- */
7361 0 : dotPrd = cs[0] * cs[1] + sn[0] * sn[1];
7362 :
7363 :
7364 : /* Convert central meridian (DMS to DEG) & compute sin & cos */
7365 : /* --------------------------------------------------------- */
7366 0 : centMerd = EHconvAng(projparm[4], HDFE_DMS_DEG);
7367 0 : lonrad = EHconvAng(centMerd, HDFE_DEG_RAD);
7368 0 : cs[1] = cos(lonrad);
7369 0 : sn[1] = sin(lonrad);
7370 :
7371 :
7372 : /* If box brackets central meridian ... */
7373 : /* ------------------------------------ */
7374 0 : if (cs[0] * cs[1] + sn[0] * sn[1] > dotPrd)
7375 : {
7376 0 : latitude[4] = cornerlat[0];
7377 0 : longitude[4] = centMerd;
7378 :
7379 0 : latitude[5] = cornerlat[1];
7380 0 : longitude[5] = centMerd;
7381 :
7382 0 : *npnts = 6;
7383 : }
7384 : }
7385 0 : break;
7386 :
7387 :
7388 0 : case GCTP_POLYC:
7389 : {
7390 : /* Compute sine and cosine of corner longitudes */
7391 : /* -------------------------------------------- */
7392 0 : for (i = 0; i < 2; i++)
7393 : {
7394 0 : lonrad = EHconvAng(cornerlon[i], HDFE_DEG_RAD);
7395 0 : cs[i] = cos(lonrad);
7396 0 : sn[i] = sin(lonrad);
7397 : }
7398 :
7399 :
7400 : /* Compute dot product */
7401 : /* ------------------- */
7402 0 : dotPrd = cs[0] * cs[1] + sn[0] * sn[1];
7403 :
7404 :
7405 : /* Convert central meridian (DMS to DEG) & compute sin & cos */
7406 : /* --------------------------------------------------------- */
7407 0 : centMerd = EHconvAng(projparm[4], HDFE_DMS_DEG);
7408 0 : lonrad = EHconvAng(centMerd, HDFE_DEG_RAD);
7409 0 : cs[1] = cos(lonrad);
7410 0 : sn[1] = sin(lonrad);
7411 :
7412 :
7413 : /* If box brackets central meridian ... */
7414 : /* ------------------------------------ */
7415 0 : if (cs[0] * cs[1] + sn[0] * sn[1] > dotPrd)
7416 : {
7417 0 : latitude[4] = cornerlat[0];
7418 0 : longitude[4] = centMerd;
7419 :
7420 0 : latitude[5] = cornerlat[1];
7421 0 : longitude[5] = centMerd;
7422 :
7423 0 : *npnts = 6;
7424 : }
7425 : }
7426 0 : break;
7427 :
7428 :
7429 0 : case GCTP_TM:
7430 : {
7431 : /* Compute sine and cosine of corner longitudes */
7432 : /* -------------------------------------------- */
7433 0 : for (i = 0; i < 2; i++)
7434 : {
7435 0 : lonrad = EHconvAng(cornerlon[i], HDFE_DEG_RAD);
7436 0 : cs[i] = cos(lonrad);
7437 0 : sn[i] = sin(lonrad);
7438 : }
7439 :
7440 :
7441 : /* Compute dot product */
7442 : /* ------------------- */
7443 0 : dotPrd = cs[0] * cs[1] + sn[0] * sn[1];
7444 :
7445 :
7446 0 : for (i = -1; i <= 1; i++)
7447 : {
7448 0 : centMerd = EHconvAng(projparm[4], HDFE_DMS_DEG);
7449 0 : lonrad = EHconvAng(centMerd + 90 * i, HDFE_DEG_RAD);
7450 0 : csTest = cos(lonrad);
7451 0 : snTest = sin(lonrad);
7452 :
7453 :
7454 : /* If box brackets meridian ... */
7455 : /* ---------------------------- */
7456 0 : if (csTest * cs[1] + snTest * sn[1] > dotPrd)
7457 : {
7458 0 : latitude[*npnts] = cornerlat[0];
7459 0 : longitude[*npnts] = centMerd;
7460 0 : (*npnts)++;
7461 :
7462 0 : latitude[*npnts] = cornerlat[1];
7463 0 : longitude[*npnts] = centMerd;
7464 0 : (*npnts)++;
7465 : }
7466 : }
7467 :
7468 :
7469 :
7470 : /* Compute sine and cosine of corner latitudes */
7471 : /* ------------------------------------------- */
7472 0 : for (i = 0; i < 2; i++)
7473 : {
7474 0 : latrad = EHconvAng(cornerlat[i], HDFE_DEG_RAD);
7475 0 : cs[i] = cos(latrad);
7476 0 : sn[i] = sin(latrad);
7477 : }
7478 :
7479 :
7480 : /* Compute dot product */
7481 : /* ------------------- */
7482 0 : dotPrd = cs[0] * cs[1] + sn[0] * sn[1];
7483 :
7484 :
7485 : /* Convert origin latitude (DMS to DEG) & compute sin & cos */
7486 : /* -------------------------------------------------------- */
7487 0 : orgLat = EHconvAng(projparm[5], HDFE_DMS_DEG);
7488 0 : latrad = EHconvAng(orgLat, HDFE_DEG_RAD);
7489 0 : cs[1] = cos(latrad);
7490 0 : sn[1] = sin(latrad);
7491 :
7492 :
7493 : /* If box brackets origin latitude ... */
7494 : /* ----------------------------------- */
7495 0 : if (cs[0] * cs[1] + sn[0] * sn[1] > dotPrd)
7496 : {
7497 0 : latitude[*npnts] = orgLat;
7498 0 : longitude[*npnts] = cornerlon[0];
7499 0 : (*npnts)++;
7500 :
7501 0 : latitude[*npnts] = orgLat;
7502 0 : longitude[*npnts] = cornerlon[1];
7503 0 : (*npnts)++;
7504 : }
7505 : }
7506 0 : break;
7507 :
7508 :
7509 0 : case GCTP_HOM:
7510 : {
7511 : /* Tangent to y-axis along longitude */
7512 : /* --------------------------------- */
7513 0 : if (projparm[12] == 0)
7514 : {
7515 0 : cs[0] = cos(EHconvAng(projparm[8], HDFE_DMS_RAD));
7516 0 : sn[0] = sin(EHconvAng(projparm[8], HDFE_DMS_RAD));
7517 0 : cs[1] = cos(EHconvAng(projparm[9], HDFE_DMS_RAD));
7518 0 : sn[1] = sin(EHconvAng(projparm[9], HDFE_DMS_RAD));
7519 0 : cs[2] = cos(EHconvAng(projparm[10], HDFE_DMS_RAD));
7520 0 : sn[2] = sin(EHconvAng(projparm[10], HDFE_DMS_RAD));
7521 0 : cs[3] = cos(EHconvAng(projparm[11], HDFE_DMS_RAD));
7522 0 : sn[3] = sin(EHconvAng(projparm[11], HDFE_DMS_RAD));
7523 :
7524 0 : bisectParm[3] = atan2(
7525 0 : (cs[1] * sn[3] * cs[0] - sn[1] * cs[3] * cs[2]),
7526 0 : (sn[1] * cs[3] * sn[2] - cs[1] * sn[3] * sn[0]));
7527 0 : bisectParm[0] = atan(
7528 0 : (sin(bisectParm[3]) * sn[0] - cos(bisectParm[3]) * cs[0]) /
7529 0 : (sn[1] / cs[1]));
7530 0 : bisectParm[2] = bisectParm[3] + 0.5 * dpi;
7531 : }
7532 : else
7533 : {
7534 0 : cs[0] = cos(EHconvAng(projparm[3], HDFE_DMS_RAD));
7535 0 : sn[0] = sin(EHconvAng(projparm[3], HDFE_DMS_RAD));
7536 0 : cs[1] = cos(EHconvAng(projparm[4], HDFE_DMS_RAD));
7537 0 : sn[1] = sin(EHconvAng(projparm[4], HDFE_DMS_RAD));
7538 :
7539 0 : bisectParm[0] = asin(cs[1] * sn[0]);
7540 0 : bisectParm[2] = atan2(-cs[0], (-sn[1] * sn[0])) + 0.5 * dpi;
7541 : }
7542 :
7543 0 : for (i = 0; i < 2; i++)
7544 : {
7545 0 : bisectParm[1] = cornerlon[i];
7546 :
7547 0 : if (EHbisect(homDyDtheta, bisectParm, 3,
7548 0 : cornerlat[0], cornerlat[1],
7549 : 0.0001, &tanLat) == 0)
7550 : {
7551 0 : longitude[*npnts] = cornerlon[i];
7552 0 : latitude[*npnts] = tanLat;
7553 0 : (*npnts)++;
7554 : }
7555 : }
7556 :
7557 : }
7558 0 : break;
7559 : }
7560 :
7561 :
7562 0 : return (status);
7563 : }
7564 :
7565 :
7566 :
7567 : /*----------------------------------------------------------------------------|
7568 : | BEGIN_PROLOG |
7569 : | |
7570 : | FUNCTION: GDdefboxregion |
7571 : | |
7572 : | DESCRIPTION: Defines region for subsetting in a grid. |
7573 : | |
7574 : | |
7575 : | Return Value Type Units Description |
7576 : | ============ ====== ========= ===================================== |
7577 : | regionID int32 Region ID |
7578 : | |
7579 : | INPUTS: |
7580 : | gridID int32 Grid structure ID |
7581 : | cornerlon float64 dec deg Longitude of opposite corners of box |
7582 : | cornerlat float64 dec deg Latitude of opposite corners of box |
7583 : | |
7584 : | |
7585 : | OUTPUTS: |
7586 : | None |
7587 : | |
7588 : | NOTES: |
7589 : | |
7590 : | |
7591 : | Date Programmer Description |
7592 : | ====== ============ ================================================= |
7593 : | Jun 96 Joel Gales Original Programmer |
7594 : | Oct 96 Joel Gales "Clamp" subset region around grid |
7595 : | Oct 96 Joel Gales Fix "outside region" check |
7596 : | Nov 96 Joel Gales Add check for "tangent" points (GDtangentpnts) |
7597 : | Dec 96 Joel Gales Trap if no projection code defined |
7598 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
7599 : | Mar 99 David Wynne Fix for NCR 21195, allow subsetting of MISR SOM |
7600 : | data sets |
7601 : | Jun 00 Abe Taaheri Added support for EASE grid |
7602 : | |
7603 : | END_PROLOG |
7604 : -----------------------------------------------------------------------------*/
7605 : int32
7606 0 : GDdefboxregion(int32 gridID, float64 cornerlon[], float64 cornerlat[])
7607 : {
7608 : intn i; /* Loop index */
7609 : intn j; /* Loop index */
7610 : intn k; /* Loop index */
7611 : intn n; /* Loop index */
7612 0 : intn status = 0; /* routine return status variable */
7613 :
7614 : int32 fid; /* HDF-EOS file ID */
7615 : int32 sdInterfaceID; /* HDF SDS interface ID */
7616 : int32 gdVgrpID; /* Grid root Vgroup ID */
7617 0 : int32 regionID = -1; /* Region ID */
7618 : int32 xdimsize; /* XDim size */
7619 : int32 ydimsize; /* YDim size */
7620 : int32 projcode; /* Projection code */
7621 : int32 zonecode; /* Zone code */
7622 : int32 spherecode; /* Sphere code */
7623 : int32 row[32]; /* Row array */
7624 : int32 col[32]; /* Column array */
7625 0 : int32 minCol = 0; /* Minimum column value */
7626 0 : int32 minRow = 0; /* Minimum row value */
7627 0 : int32 maxCol = 0; /* Maximum column value */
7628 0 : int32 maxRow = 0; /* Maximum row value */
7629 : int32 npnts; /* Number of boundary
7630 : (edge & tangent) pnts */
7631 :
7632 : float64 longitude[32]; /* Longitude array */
7633 : float64 latitude[32]; /* Latitude array */
7634 : float64 upleftpt[2]; /* Upper left pt coordinates */
7635 : float64 lowrightpt[2]; /* Lower right pt coordinates */
7636 : float64 somupleftpt[2]; /* temporary Upper left pt coordinates
7637 : for SOM projection */
7638 : float64 somlowrightpt[2]; /* temporary Lower right pt
7639 : coordinates for SOM projection */
7640 : float64 projparm[16]; /* Projection parameters */
7641 : float64 xscale; /* X scale */
7642 : float64 yscale; /* Y scale */
7643 : float64 lonrad0; /* Longitude of upper left point
7644 : (radians) */
7645 : float64 latrad0; /* Latitude of upper left point (radians) */
7646 : float64 lonrad2; /* Longitude of point (radians) */
7647 : float64 latrad2; /* Latitude of point (radians) */
7648 :
7649 : /* Used for SOM projection */
7650 : char *utlbuf;
7651 : char *gridname;
7652 0 : int32 blockindexstart = -1;
7653 0 : int32 blockindexstop = -1;
7654 : float32 offset[180];
7655 : float64 templeftpt[2];
7656 : float64 temprightpt[2];
7657 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
7658 : float64 xmtr[2], ymtr[2];
7659 : float64 lon[2],lat[2];
7660 : float64 xcor[2], ycor[2];
7661 : int32 nlatlon;
7662 : float64 upleftpt_m[2];
7663 :
7664 :
7665 0 : utlbuf = (char *)calloc(128, sizeof(char));
7666 0 : if(utlbuf == NULL)
7667 : {
7668 0 : HEpush(DFE_NOSPACE,"GDdefboxregion", __FILE__, __LINE__);
7669 0 : return(-1);
7670 : }
7671 0 : gridname = (char *)calloc(128, sizeof(char));
7672 0 : if(gridname == NULL)
7673 : {
7674 0 : HEpush(DFE_NOSPACE,"GDdefboxregion", __FILE__, __LINE__);
7675 0 : free(utlbuf);
7676 0 : return(-1);
7677 : }
7678 :
7679 : /* Check for valid grid ID */
7680 : /* ----------------------- */
7681 0 : status = GDchkgdid(gridID, "GDdefboxregion",
7682 : &fid, &sdInterfaceID, &gdVgrpID);
7683 :
7684 :
7685 0 : if (status == 0)
7686 : {
7687 : /* Get grid info */
7688 : /* ------------- */
7689 0 : status = GDgridinfo(gridID, &xdimsize, &ydimsize,
7690 : upleftpt, lowrightpt);
7691 :
7692 :
7693 : /* If error then bail */
7694 : /* ------------------ */
7695 0 : if (status != 0)
7696 : {
7697 0 : regionID = -1;
7698 0 : free(utlbuf);
7699 0 : free(gridname);
7700 0 : return (regionID);
7701 : }
7702 :
7703 :
7704 : /* Get proj info */
7705 : /* ------------- */
7706 0 : status = GDprojinfo(gridID, &projcode, &zonecode,
7707 : &spherecode, projparm);
7708 :
7709 :
7710 : /* If no projection code defined then bail */
7711 : /* --------------------------------------- */
7712 0 : if (projcode == -1)
7713 : {
7714 0 : regionID = -1;
7715 0 : free(utlbuf);
7716 0 : free(gridname);
7717 0 : return (regionID);
7718 : }
7719 :
7720 :
7721 : /* Get default values for upleft and lowright if necessary */
7722 : /* ------------------------------------------------------- */
7723 0 : if (upleftpt[0] == 0 && upleftpt[1] == 0 &&
7724 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
7725 : {
7726 0 : status = GDgetdefaults(projcode, zonecode, projparm, spherecode,
7727 : upleftpt, lowrightpt);
7728 :
7729 : /* If error then bail */
7730 : /* ------------------ */
7731 0 : if (status != 0)
7732 : {
7733 0 : regionID = -1;
7734 0 : free(utlbuf);
7735 0 : free(gridname);
7736 0 : return (regionID);
7737 : }
7738 : }
7739 :
7740 :
7741 :
7742 : /* Fill-up longitude and latitude arrays */
7743 : /* ------------------------------------- */
7744 0 : longitude[0] = cornerlon[0];
7745 0 : latitude[0] = cornerlat[0];
7746 :
7747 0 : longitude[1] = cornerlon[0];
7748 0 : latitude[1] = cornerlat[1];
7749 :
7750 0 : longitude[2] = cornerlon[1];
7751 0 : latitude[2] = cornerlat[0];
7752 :
7753 0 : longitude[3] = cornerlon[1];
7754 0 : latitude[3] = cornerlat[1];
7755 :
7756 0 : npnts = 4;
7757 :
7758 :
7759 : /* Find additional tangent points from GDtangentpnts */
7760 : /* ------------------------------------------------- */
7761 0 : status = GDtangentpnts(projcode, projparm, cornerlon, cornerlat,
7762 : longitude, latitude, &npnts);
7763 :
7764 : /* If SOM projection with projparm[11] non-zero ... */
7765 0 : if (projcode == GCTP_SOM && projparm[11] != 0)
7766 : {
7767 0 : Vgetname(GDXGrid[gridID % idOffset].IDTable, gridname);
7768 0 : snprintf(utlbuf, 128, "%s%s", "_BLKSOM:", gridname);
7769 0 : status = GDreadattr(gridID, utlbuf, offset);
7770 :
7771 0 : somupleftpt[0] = upleftpt[0];
7772 0 : somupleftpt[1] = upleftpt[1];
7773 0 : somlowrightpt[0]= lowrightpt[0];
7774 0 : somlowrightpt[1] = lowrightpt[1];
7775 :
7776 0 : k = 0;
7777 0 : n = 2;
7778 :
7779 0 : for (j = 0; j <= projparm[11] - 1; j++)
7780 : {
7781 :
7782 : /* Convert from lon/lat to row/col */
7783 : /* ------------------------------- */
7784 0 : status = GDll2ij(projcode, zonecode, projparm, spherecode,
7785 : xdimsize, ydimsize, somupleftpt, somlowrightpt,
7786 : npnts, longitude, latitude, row, col, NULL, NULL);
7787 :
7788 :
7789 : /* Find min/max values for row & col */
7790 : /* --------------------------------- */
7791 0 : minCol = col[0];
7792 0 : minRow = row[0];
7793 0 : maxCol = col[0];
7794 0 : maxRow = row[0];
7795 0 : for (i = 1; i < npnts; i++)
7796 : {
7797 0 : if (col[i] < minCol)
7798 : {
7799 0 : minCol = col[i];
7800 : }
7801 :
7802 0 : if (col[i] > maxCol)
7803 : {
7804 0 : maxCol = col[i];
7805 : }
7806 :
7807 0 : if (row[i] < minRow)
7808 : {
7809 0 : minRow = row[i];
7810 : }
7811 :
7812 0 : if (row[i] > maxRow)
7813 : {
7814 0 : maxRow = row[i];
7815 : }
7816 : }
7817 :
7818 :
7819 :
7820 : /* "Clamp" if outside Grid */
7821 : /* ----------------------- */
7822 0 : minCol = (minCol < 0) ? 0 : minCol;
7823 0 : minRow = (minRow < 0) ? 0 : minRow;
7824 :
7825 0 : maxCol = (maxCol >= xdimsize) ? xdimsize - 1 : maxCol;
7826 0 : maxRow = (maxRow >= ydimsize) ? ydimsize - 1 : maxRow;
7827 :
7828 :
7829 : /* Check whether subset region is outside grid region */
7830 : /* -------------------------------------------------- */
7831 0 : if (minCol >= xdimsize || minRow >= ydimsize ||
7832 0 : maxCol < 0 || maxRow < 0)
7833 : {
7834 0 : if ( blockindexstart == -1 && (projparm[11]) == j)
7835 : {
7836 0 : status = -1;
7837 0 : HEpush(DFE_GENAPP, "GDdefboxregion", __FILE__, __LINE__);
7838 0 : HEreport("Subset Region outside of Grid Region\n");
7839 0 : regionID = -1;
7840 : }
7841 : }
7842 : else
7843 : {
7844 0 : if (k == 0)
7845 : {
7846 0 : blockindexstart = j;
7847 0 : blockindexstop = j;
7848 0 : k = 1;
7849 : }
7850 : else
7851 : {
7852 0 : blockindexstop = j;
7853 : }
7854 : }
7855 :
7856 : // E. Rouault: FIXME: was really abs(int) indented here ? Forcing the cast to int to please compilers
7857 0 : templeftpt[0] = upleftpt[0] + ((offset[j]/xdimsize)*abs((int)(upleftpt[0] - lowrightpt[0]))) + abs((int)(upleftpt[0] - lowrightpt[0]))*(n-1);
7858 0 : templeftpt[1] = upleftpt[1] + ((lowrightpt[1] - upleftpt[1]))*(n-1);
7859 :
7860 0 : temprightpt[0] = lowrightpt[0] + ((offset[j]/xdimsize)*abs((int)(lowrightpt[0] - upleftpt[0]))) + abs((int)(lowrightpt[0] - upleftpt[0]))*(n-1);
7861 0 : temprightpt[1] = lowrightpt[1] + ((upleftpt[1] - lowrightpt[1]))*(n-1);
7862 :
7863 0 : somupleftpt[0] = templeftpt[0];
7864 0 : somupleftpt[1] = templeftpt[1];
7865 :
7866 0 : somlowrightpt[0] = temprightpt[0];
7867 0 : somlowrightpt[1] = temprightpt[1];
7868 0 : n++;
7869 : }
7870 : }
7871 : else
7872 : {
7873 :
7874 : /* Convert from lon/lat to row/col */
7875 : /* ------------------------------- */
7876 :
7877 0 : status = GDll2ij(projcode, zonecode, projparm, spherecode,
7878 : xdimsize, ydimsize, upleftpt, lowrightpt,
7879 : npnts, longitude, latitude, row, col, NULL, NULL);
7880 :
7881 : /* Find min/max values for row & col */
7882 : /* --------------------------------- */
7883 0 : minCol = col[0];
7884 0 : minRow = row[0];
7885 0 : maxCol = col[0];
7886 0 : maxRow = row[0];
7887 0 : for (i = 1; i < npnts; i++)
7888 : {
7889 0 : if (col[i] < minCol)
7890 : {
7891 0 : minCol = col[i];
7892 : }
7893 :
7894 0 : if (col[i] > maxCol)
7895 : {
7896 0 : maxCol = col[i];
7897 : }
7898 :
7899 0 : if (row[i] < minRow)
7900 : {
7901 0 : minRow = row[i];
7902 : }
7903 :
7904 0 : if (row[i] > maxRow)
7905 : {
7906 0 : maxRow = row[i];
7907 : }
7908 : }
7909 :
7910 :
7911 :
7912 : /* "Clamp" if outside Grid */
7913 : /* ----------------------- */
7914 0 : minCol = (minCol < 0) ? 0 : minCol;
7915 0 : minRow = (minRow < 0) ? 0 : minRow;
7916 :
7917 0 : maxCol = (maxCol >= xdimsize) ? xdimsize - 1 : maxCol;
7918 0 : maxRow = (maxRow >= ydimsize) ? ydimsize - 1 : maxRow;
7919 :
7920 :
7921 : /* Check whether subset region is outside grid region */
7922 : /* -------------------------------------------------- */
7923 0 : if (minCol >= xdimsize || minRow >= ydimsize || maxCol < 0 || maxRow < 0)
7924 : {
7925 0 : status = -1;
7926 0 : HEpush(DFE_GENAPP, "GDdefboxregion", __FILE__, __LINE__);
7927 0 : HEreport("Subset Region outside of Grid Region\n");
7928 0 : regionID = -1;
7929 :
7930 : }
7931 : }
7932 0 : if (status == 0)
7933 : {
7934 : /* Store grid region info */
7935 : /* ---------------------- */
7936 0 : for (i = 0; i < NGRIDREGN; i++)
7937 : {
7938 : /* Find first empty grid region */
7939 : /* ---------------------------- */
7940 0 : if (GDXRegion[i] == 0)
7941 : {
7942 : /* Allocate space for grid region entry */
7943 : /* ------------------------------------ */
7944 0 : GDXRegion[i] = (struct gridRegion *)
7945 0 : calloc(1, sizeof(struct gridRegion));
7946 0 : if(GDXRegion[i] == NULL)
7947 : {
7948 0 : HEpush(DFE_NOSPACE,"GDdefboxregion", __FILE__, __LINE__);
7949 0 : free(utlbuf);
7950 0 : free(gridname);
7951 0 : return(-1);
7952 : }
7953 :
7954 :
7955 : /* Store file and grid ID */
7956 : /* ---------------------- */
7957 0 : GDXRegion[i]->fid = fid;
7958 0 : GDXRegion[i]->gridID = gridID;
7959 :
7960 :
7961 : /* Initialize vertical subset entries to -1 */
7962 : /* ---------------------------------------- */
7963 0 : for (j = 0; j < 8; j++)
7964 : {
7965 0 : GDXRegion[i]->StartVertical[j] = -1;
7966 0 : GDXRegion[i]->StopVertical[j] = -1;
7967 : }
7968 :
7969 :
7970 : /* Store start & count along x & y */
7971 : /* ------------------------------- */
7972 0 : GDXRegion[i]->xStart = minCol;
7973 0 : GDXRegion[i]->xCount = maxCol - minCol + 1;
7974 0 : GDXRegion[i]->yStart = minRow;
7975 0 : GDXRegion[i]->yCount = maxRow - minRow + 1;
7976 :
7977 :
7978 : /* Store upleft and lowright points of subset region */
7979 : /* ------------------------------------------------- */
7980 0 : if (projcode == GCTP_GEO )
7981 : {
7982 : /* GEO projection */
7983 : /* ------------------------ */
7984 :
7985 : /* Convert upleft & lowright lon from DMS to radians */
7986 : /* ------------------------------------------------- */
7987 0 : lonrad0 = EHconvAng(upleftpt[0], HDFE_DMS_RAD);
7988 0 : lonrad2 = EHconvAng(lowrightpt[0], HDFE_DMS_RAD);
7989 :
7990 : /* Compute X scale */
7991 : /* --------------- */
7992 0 : xscale = (lonrad2 - lonrad0) / xdimsize;
7993 :
7994 : /* Convert upleft & lowright lat from DMS to radians */
7995 : /* ------------------------------------------------- */
7996 0 : latrad0 = EHconvAng(upleftpt[1], HDFE_DMS_RAD);
7997 0 : latrad2 = EHconvAng(lowrightpt[1], HDFE_DMS_RAD);
7998 :
7999 : /* Compute Y scale */
8000 : /* --------------- */
8001 0 : yscale = (latrad2 - latrad0) / ydimsize;
8002 :
8003 :
8004 : /* MinCol -> radians -> DMS -> upleftpt[0] */
8005 : /* --------------------------------------- */
8006 0 : GDXRegion[i]->upleftpt[0] =
8007 0 : EHconvAng(lonrad0 + xscale * minCol,
8008 : HDFE_RAD_DMS);
8009 :
8010 :
8011 : /* MinRow -> radians -> DMS -> upleftpt[1] */
8012 : /* --------------------------------------- */
8013 0 : GDXRegion[i]->upleftpt[1] =
8014 0 : EHconvAng(latrad0 + yscale * minRow,
8015 : HDFE_RAD_DMS);
8016 :
8017 :
8018 : /* MinCol + 1 -> radians -> DMS -> lowrightpt[0] */
8019 : /* --------------------------------------------- */
8020 0 : GDXRegion[i]->lowrightpt[0] =
8021 0 : EHconvAng(lonrad0 + xscale * (maxCol + 1),
8022 : HDFE_RAD_DMS);
8023 :
8024 :
8025 : /* MinRow + 1 -> radians -> DMS -> lowrightpt[1] */
8026 : /* --------------------------------------------- */
8027 0 : GDXRegion[i]->lowrightpt[1] =
8028 0 : EHconvAng(latrad0 + yscale * (maxRow + 1),
8029 : HDFE_RAD_DMS);
8030 : }
8031 0 : else if (projcode == GCTP_BCEA)
8032 : {
8033 : /* BCEA projection */
8034 : /* -------------- */
8035 0 : nlatlon = 2;
8036 0 : lon[0] = upleftpt[0];
8037 0 : lon[1] = lowrightpt[0];
8038 0 : lat[0] = upleftpt[1];
8039 0 : lat[1] = lowrightpt[1];
8040 : status =
8041 0 : GDll2mm_cea(projcode,zonecode,spherecode,projparm,
8042 : xdimsize, ydimsize,
8043 : upleftpt, lowrightpt,nlatlon,
8044 : lon, lat,
8045 : xcor, ycor, &xscale, &yscale);
8046 0 : upleftpt_m[0] = xcor[0];
8047 0 : upleftpt_m[1] = ycor[0];
8048 :
8049 :
8050 0 : if (status == -1)
8051 : {
8052 0 : HEpush(DFE_GENAPP, "GDdefboxregion", __FILE__, __LINE__);
8053 0 : free(utlbuf);
8054 0 : free(gridname);
8055 0 : return (status);
8056 : }
8057 :
8058 : /* MinCol -> meters -> upleftpt[0] */
8059 : /* ------------------------------- */
8060 0 : xmtr[0] = upleftpt_m[0] + xscale * minCol;
8061 :
8062 : /* MinRow -> meters -> upleftpt[1] */
8063 : /* ------------------------------- */
8064 0 : ymtr[0] = upleftpt_m[1] + yscale * minRow;
8065 :
8066 : /* MinCol + 1 -> meters -> lowrightpt[0] */
8067 : /* ------------------------------------- */
8068 0 : xmtr[1] = upleftpt_m[0] + xscale * (maxCol + 1);
8069 :
8070 : /* MinRow + 1 -> meters -> lowrightpt[1] */
8071 : /* ------------------------------------- */
8072 0 : ymtr[1] = upleftpt_m[1] + yscale * (maxRow + 1);
8073 :
8074 : /* Convert upleft & lowright lon from DMS to radians */
8075 : /* ------------------------------------------------- */
8076 0 : npnts = 2;
8077 0 : status = GDmm2ll_cea(projcode, zonecode, spherecode,
8078 : projparm, xdimsize, ydimsize,
8079 : upleftpt, lowrightpt, npnts,
8080 : xmtr, ymtr,
8081 : longitude, latitude);
8082 0 : if (status == -1)
8083 : {
8084 0 : HEpush(DFE_GENAPP, "GDdefboxregion", __FILE__, __LINE__);
8085 0 : free(utlbuf);
8086 0 : free(gridname);
8087 0 : return (status);
8088 : }
8089 0 : GDXRegion[i]->upleftpt[0] = longitude[0];
8090 :
8091 0 : GDXRegion[i]->upleftpt[1] = latitude[0];
8092 :
8093 0 : GDXRegion[i]->lowrightpt[0] = longitude[1];
8094 :
8095 0 : GDXRegion[i]->lowrightpt[1] = latitude[1];
8096 : }
8097 0 : else if (projcode == GCTP_SOM)
8098 : {
8099 : /* Store start & count along x & y */
8100 : /* ------------------------------- */
8101 0 : GDXRegion[i]->xStart = 0;
8102 0 : GDXRegion[i]->xCount = xdimsize;
8103 0 : GDXRegion[i]->yStart = 0;
8104 0 : GDXRegion[i]->yCount = ydimsize;
8105 :
8106 0 : GDXRegion[i]->somStart = blockindexstart;
8107 0 : GDXRegion[i]->somCount = blockindexstop - blockindexstart + 1;
8108 :
8109 : /* Store upleft and lowright points of subset region */
8110 : /* ------------------------------------------------- */
8111 0 : if (blockindexstart == 0)
8112 : {
8113 0 : GDXRegion[i]->upleftpt[0] = upleftpt[0];
8114 0 : GDXRegion[i]->upleftpt[1] = upleftpt[1];
8115 0 : GDXRegion[i]->lowrightpt[0] = lowrightpt[0];
8116 0 : GDXRegion[i]->lowrightpt[1] = lowrightpt[1];
8117 : }
8118 : else
8119 : {
8120 0 : GDXRegion[i]->upleftpt[0] =
8121 0 : (lowrightpt[0] - upleftpt[0])*
8122 0 : (offset[blockindexstart-1]/xdimsize) + upleftpt[0];
8123 0 : GDXRegion[i]->upleftpt[1] =
8124 0 : (lowrightpt[1] - upleftpt[1])*
8125 0 : (blockindexstart+1-1) + upleftpt[1];
8126 :
8127 0 : GDXRegion[i]->lowrightpt[0] =
8128 0 : (lowrightpt[0] - upleftpt[0])*
8129 0 : (offset[blockindexstart-1]/xdimsize) + lowrightpt[0];
8130 0 : GDXRegion[i]->lowrightpt[1] =
8131 0 : (lowrightpt[1] - upleftpt[1])*
8132 0 : (blockindexstart+1-1) + lowrightpt[1];
8133 :
8134 : }
8135 : }
8136 : else
8137 : {
8138 : /* Non-GEO, Non-BCEA projections */
8139 : /* ---------------------------- */
8140 :
8141 : /* Compute X & Y scale */
8142 : /* ------------------- */
8143 0 : xscale = (lowrightpt[0] - upleftpt[0]) / xdimsize;
8144 0 : yscale = (lowrightpt[1] - upleftpt[1]) / ydimsize;
8145 :
8146 :
8147 : /* MinCol -> meters -> upleftpt[0] */
8148 : /* ------------------------------- */
8149 0 : GDXRegion[i]->upleftpt[0] = upleftpt[0] +
8150 0 : xscale * minCol;
8151 :
8152 :
8153 : /* MinRow -> meters -> upleftpt[1] */
8154 : /* ------------------------------- */
8155 0 : GDXRegion[i]->upleftpt[1] = upleftpt[1] +
8156 0 : yscale * minRow;
8157 :
8158 :
8159 : /* MinCol + 1 -> meters -> lowrightpt[0] */
8160 : /* ------------------------------------- */
8161 0 : GDXRegion[i]->lowrightpt[0] = upleftpt[0] +
8162 0 : xscale * (maxCol + 1);
8163 :
8164 :
8165 : /* MinRow + 1 -> meters -> lowrightpt[1] */
8166 : /* ------------------------------------- */
8167 0 : GDXRegion[i]->lowrightpt[1] = upleftpt[1] +
8168 0 : yscale * (maxRow + 1);
8169 : }
8170 :
8171 : /* Store region ID */
8172 : /* --------------- */
8173 0 : regionID = i;
8174 0 : break;
8175 : }
8176 :
8177 : }
8178 : }
8179 :
8180 : }
8181 0 : free(utlbuf);
8182 0 : free(gridname);
8183 0 : return (regionID);
8184 : }
8185 :
8186 :
8187 :
8188 :
8189 :
8190 : /*----------------------------------------------------------------------------|
8191 : | BEGIN_PROLOG |
8192 : | |
8193 : | FUNCTION: GDregioninfo |
8194 : | |
8195 : | DESCRIPTION: Retrieves size of region in bytes. |
8196 : | |
8197 : | |
8198 : | Return Value Type Units Description |
8199 : | ============ ====== ========= ===================================== |
8200 : | status intn return status (0) SUCCEED, (-1) FAIL |
8201 : | |
8202 : | INPUTS: |
8203 : | gridID int32 Grid structure ID |
8204 : | regionID int32 Region ID |
8205 : | fieldname char Fieldname |
8206 : | |
8207 : | |
8208 : | OUTPUTS: |
8209 : | ntype int32 field number type |
8210 : | rank int32 field rank |
8211 : | dims int32 dimensions of field region |
8212 : | size int32 size in bytes of field region |
8213 : | upleftpt float64 Upper left corner coord for region |
8214 : | lowrightpt float64 Lower right corner coord for region |
8215 : | |
8216 : | NOTES: |
8217 : | |
8218 : | |
8219 : | Date Programmer Description |
8220 : | ====== ============ ================================================= |
8221 : | Jun 96 Joel Gales Original Programmer |
8222 : | Aug 96 Joel Gales Add vertical subsetting |
8223 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
8224 : | Apr 99 David Wynne Added support for MISR SOM projection, NCR 21195 |
8225 : | |
8226 : | END_PROLOG |
8227 : -----------------------------------------------------------------------------*/
8228 : intn
8229 0 : GDregioninfo(int32 gridID, int32 regionID, const char *fieldname,
8230 : int32 * ntype, int32 * rank, int32 dims[], int32 * size,
8231 : float64 upleftpt[], float64 lowrightpt[])
8232 : {
8233 : intn j; /* Loop index */
8234 0 : intn status = 0; /* routine return status variable */
8235 :
8236 : int32 fid; /* HDF-EOS file ID */
8237 : int32 sdInterfaceID; /* HDF SDS interface ID */
8238 : int32 gdVgrpID; /* Grid root Vgroup ID */
8239 : int32 l_index; /* Dimension l_index */
8240 :
8241 : char dimlist[256]; /* Dimension list */
8242 0 : const char *errMesg = "Vertical Dimension Not Found: \"%s\".\n";
8243 0 : const char *errM1 = "Both \"XDim\" and \"YDim\" must be present ";
8244 0 : const char *errM2 = "in the dimension list for \"%s\".\n";
8245 : char errbuf[256];/* Error buffer */
8246 :
8247 :
8248 : /* Check for valid grid ID */
8249 : /* ----------------------- */
8250 0 : status = GDchkgdid(gridID, "GDregioninfo", &fid, &sdInterfaceID,
8251 : &gdVgrpID);
8252 :
8253 :
8254 : /* Check for valid region ID */
8255 : /* ------------------------- */
8256 0 : if (status == 0)
8257 : {
8258 0 : if (regionID < 0 || regionID >= NGRIDREGN)
8259 : {
8260 0 : status = -1;
8261 0 : HEpush(DFE_RANGE, "GDregioninfo", __FILE__, __LINE__);
8262 0 : HEreport("Invalid Region id: %d.\n", regionID);
8263 : }
8264 : }
8265 :
8266 :
8267 : /* Check for active region ID */
8268 : /* -------------------------- */
8269 0 : if (status == 0)
8270 : {
8271 0 : if (GDXRegion[regionID] == 0)
8272 : {
8273 0 : status = -1;
8274 0 : HEpush(DFE_GENAPP, "GDregioninfo", __FILE__, __LINE__);
8275 0 : HEreport("Inactive Region ID: %d.\n", regionID);
8276 : }
8277 : }
8278 :
8279 :
8280 :
8281 : /* Check that region defined for this file */
8282 : /* --------------------------------------- */
8283 0 : if (status == 0)
8284 : {
8285 0 : if (GDXRegion[regionID]->fid != fid)
8286 : {
8287 0 : status = -1;
8288 0 : HEpush(DFE_GENAPP, "GDregioninfo", __FILE__, __LINE__);
8289 0 : HEreport("Region is not defined for this file.\n");
8290 : }
8291 : }
8292 :
8293 :
8294 : /* Check that region defined for this grid */
8295 : /* --------------------------------------- */
8296 0 : if (status == 0)
8297 : {
8298 0 : if (GDXRegion[regionID]->gridID != gridID)
8299 : {
8300 0 : status = -1;
8301 0 : HEpush(DFE_GENAPP, "GDregioninfo", __FILE__, __LINE__);
8302 0 : HEreport("Region is not defined for this Grid.\n");
8303 : }
8304 : }
8305 :
8306 :
8307 :
8308 : /* Check for valid fieldname */
8309 : /* ------------------------- */
8310 0 : if (status == 0)
8311 : {
8312 0 : status = GDfieldinfo(gridID, fieldname, rank, dims, ntype, dimlist);
8313 :
8314 0 : if (status != 0)
8315 : {
8316 : /* Fieldname not found in grid */
8317 : /* --------------------------- */
8318 0 : status = -1;
8319 0 : HEpush(DFE_GENAPP, "GDregioninfo", __FILE__, __LINE__);
8320 0 : HEreport("Fieldname \"%s\" not found.\n",
8321 : fieldname);
8322 : }
8323 0 : else if (*rank == 1)
8324 : {
8325 : /* Field is 1 dimensional */
8326 : /* ---------------------- */
8327 0 : status = -1;
8328 0 : HEpush(DFE_GENAPP, "GDregioninfo", __FILE__, __LINE__);
8329 0 : HEreport(
8330 : "One-Dimesional fields \"%s\" may not be subsetted.\n",
8331 : fieldname);
8332 : }
8333 : else
8334 : {
8335 : /* "XDim" and/or "YDim" not found */
8336 : /* ------------------------------ */
8337 0 : if (EHstrwithin("XDim", dimlist, ',') == -1 ||
8338 0 : EHstrwithin("YDim", dimlist, ',') == -1)
8339 : {
8340 0 : status = -1;
8341 0 : HEpush(DFE_GENAPP, "GDregioninfo", __FILE__, __LINE__);
8342 0 : snprintf(errbuf, sizeof(errbuf), "%s%s", errM1, errM2);
8343 0 : HEreport(errbuf, fieldname);
8344 : }
8345 : }
8346 : }
8347 :
8348 :
8349 :
8350 : /* If no problems ... */
8351 : /* ------------------ */
8352 0 : if (status == 0)
8353 : {
8354 : /* Check if SOM projection */
8355 : /* ----------------------- */
8356 0 : if (EHstrwithin("SOMBlockDim", dimlist, ',') == 0)
8357 : {
8358 0 : dims[EHstrwithin("SOMBlockDim", dimlist, ',')] =
8359 0 : GDXRegion[regionID]->somCount;
8360 : }
8361 :
8362 : /* Load XDim dimension from region entry */
8363 : /* ------------------------------------- */
8364 0 : if (GDXRegion[regionID]->xCount != 0)
8365 : {
8366 0 : dims[EHstrwithin("XDim", dimlist, ',')] =
8367 0 : GDXRegion[regionID]->xCount;
8368 : }
8369 :
8370 : /* Load YDim dimension from region entry */
8371 : /* ------------------------------------- */
8372 0 : if (GDXRegion[regionID]->yCount != 0)
8373 : {
8374 0 : dims[EHstrwithin("YDim", dimlist, ',')] =
8375 0 : GDXRegion[regionID]->yCount;
8376 : }
8377 :
8378 :
8379 : /* Vertical Subset */
8380 : /* --------------- */
8381 0 : for (j = 0; j < 8; j++)
8382 : {
8383 :
8384 : /* If active vertical subset ... */
8385 : /* ----------------------------- */
8386 0 : if (GDXRegion[regionID]->StartVertical[j] != -1)
8387 : {
8388 : /* Find vertical dimension within dimlist */
8389 : /* -------------------------------------- */
8390 0 : l_index = EHstrwithin(GDXRegion[regionID]->DimNamePtr[j],
8391 : dimlist, ',');
8392 :
8393 : /* If dimension found ... */
8394 : /* ---------------------- */
8395 0 : if (l_index != -1)
8396 : {
8397 : /* Compute dimension size */
8398 : /* ---------------------- */
8399 0 : dims[l_index] =
8400 0 : GDXRegion[regionID]->StopVertical[j] -
8401 0 : GDXRegion[regionID]->StartVertical[j] + 1;
8402 : }
8403 : else
8404 : {
8405 : /* Vertical dimension not found */
8406 : /* ---------------------------- */
8407 0 : status = -1;
8408 0 : *size = -1;
8409 0 : HEpush(DFE_GENAPP, "GDregioninfo",
8410 : __FILE__, __LINE__);
8411 0 : HEreport(errMesg,
8412 0 : GDXRegion[regionID]->DimNamePtr[j]);
8413 : }
8414 : }
8415 : }
8416 :
8417 :
8418 0 : if (status == 0)
8419 : {
8420 : /* Compute number of total elements */
8421 : /* -------------------------------- */
8422 0 : *size = dims[0];
8423 0 : for (j = 1; j < *rank; j++)
8424 : {
8425 0 : *size *= dims[j];
8426 : }
8427 :
8428 : /* Multiply by size in bytes of numbertype */
8429 : /* --------------------------------------- */
8430 0 : *size *= DFKNTsize(*ntype);
8431 :
8432 :
8433 : /* Return upper left and lower right subset values */
8434 : /* ----------------------------------------------- */
8435 0 : upleftpt[0] = GDXRegion[regionID]->upleftpt[0];
8436 0 : upleftpt[1] = GDXRegion[regionID]->upleftpt[1];
8437 0 : lowrightpt[0] = GDXRegion[regionID]->lowrightpt[0];
8438 0 : lowrightpt[1] = GDXRegion[regionID]->lowrightpt[1];
8439 : }
8440 : }
8441 0 : return (status);
8442 : }
8443 :
8444 :
8445 :
8446 :
8447 :
8448 : /*----------------------------------------------------------------------------|
8449 : | BEGIN_PROLOG |
8450 : | |
8451 : | FUNCTION: GDextractregion |
8452 : | |
8453 : | DESCRIPTION: Retrieves data from specified region. |
8454 : | |
8455 : | |
8456 : | Return Value Type Units Description |
8457 : | ============ ====== ========= ===================================== |
8458 : | status intn return status (0) SUCCEED, (-1) FAIL |
8459 : | |
8460 : | INPUTS: |
8461 : | gridID int32 Grid structure ID |
8462 : | regionID int32 Region ID |
8463 : | fieldname char Fieldname |
8464 : | |
8465 : | OUTPUTS: |
8466 : | buffer void Data buffer containing subsetted region |
8467 : | |
8468 : | |
8469 : | NOTES: |
8470 : | |
8471 : | |
8472 : | Date Programmer Description |
8473 : | ====== ============ ================================================= |
8474 : | Jun 96 Joel Gales Original Programmer |
8475 : | Aug 96 Joel Gales Add vertical subsetting |
8476 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
8477 : | Apr 99 David Wynne Add support for MISR SOM projection, NCR 21195 |
8478 : | |
8479 : | END_PROLOG |
8480 : -----------------------------------------------------------------------------*/
8481 : intn
8482 0 : GDextractregion(int32 gridID, int32 regionID, const char *fieldname,
8483 : VOIDP buffer)
8484 : {
8485 : intn i; /* Loop index */
8486 : intn j; /* Loop index */
8487 0 : intn status = 0; /* routine return status variable */
8488 :
8489 : int32 fid; /* HDF-EOS file ID */
8490 : int32 sdInterfaceID; /* HDF SDS interface ID */
8491 : int32 gdVgrpID; /* Grid root Vgroup ID */
8492 : int32 l_index; /* Dimension l_index */
8493 : int32 start[8]; /* Start array for data read */
8494 : int32 edge[8]; /* Edge array for data read */
8495 : int32 dims[8]; /* Dimensions */
8496 0 : int32 rank = 0; /* Field rank */
8497 : int32 ntype; /* Field number type */
8498 : int32 origincode; /* Pixel origin code */
8499 :
8500 : char dimlist[256]; /* Dimension list */
8501 0 : const char *errMesg = "Vertical Dimension Not Found: \"%s\".\n";
8502 0 : const char *errM1 = "Both \"XDim\" and \"YDim\" must be present ";
8503 0 : const char *errM2 = "in the dimension list for \"%s\".\n";
8504 : char errbuf[256];/* Error buffer */
8505 :
8506 :
8507 : /* Check for valid grid ID */
8508 : /* ----------------------- */
8509 0 : status = GDchkgdid(gridID, "GDextractregion", &fid, &sdInterfaceID,
8510 : &gdVgrpID);
8511 :
8512 :
8513 : /* Check for valid region ID */
8514 : /* ------------------------- */
8515 0 : if (status == 0)
8516 : {
8517 0 : if (regionID < 0 || regionID >= NGRIDREGN)
8518 : {
8519 0 : status = -1;
8520 0 : HEpush(DFE_RANGE, "GDextractregion", __FILE__, __LINE__);
8521 0 : HEreport("Invalid Region id: %d.\n", regionID);
8522 : }
8523 : }
8524 :
8525 :
8526 : /* Check for active region ID */
8527 : /* -------------------------- */
8528 0 : if (status == 0)
8529 : {
8530 0 : if (GDXRegion[regionID] == 0)
8531 : {
8532 0 : status = -1;
8533 0 : HEpush(DFE_GENAPP, "GDextractregion", __FILE__, __LINE__);
8534 0 : HEreport("Inactive Region ID: %d.\n", regionID);
8535 : }
8536 : }
8537 :
8538 :
8539 :
8540 : /* Check that region defined for this file */
8541 : /* --------------------------------------- */
8542 0 : if (status == 0)
8543 : {
8544 0 : if (GDXRegion[regionID]->fid != fid)
8545 : {
8546 0 : status = -1;
8547 0 : HEpush(DFE_GENAPP, "GDextractregion", __FILE__, __LINE__);
8548 0 : HEreport("Region is not defined for this file.\n");
8549 : }
8550 : }
8551 :
8552 :
8553 : /* Check that region defined for this grid */
8554 : /* --------------------------------------- */
8555 0 : if (status == 0)
8556 : {
8557 0 : if (GDXRegion[regionID]->gridID != gridID)
8558 : {
8559 0 : status = -1;
8560 0 : HEpush(DFE_GENAPP, "GDextractregion", __FILE__, __LINE__);
8561 0 : HEreport("Region is not defined for this Grid.\n");
8562 : }
8563 : }
8564 :
8565 :
8566 :
8567 : /* Check for valid fieldname */
8568 : /* ------------------------- */
8569 0 : if (status == 0)
8570 : {
8571 0 : status = GDfieldinfo(gridID, fieldname, &rank, dims, &ntype, dimlist);
8572 :
8573 0 : if (status != 0)
8574 : {
8575 : /* Fieldname not found in grid */
8576 : /* --------------------------- */
8577 0 : status = -1;
8578 0 : HEpush(DFE_GENAPP, "GDextractregion", __FILE__, __LINE__);
8579 0 : HEreport("Fieldname \"%s\" not found.\n",
8580 : fieldname);
8581 : }
8582 0 : else if (rank == 1)
8583 : {
8584 : /* Field is 1 dimensional */
8585 : /* ---------------------- */
8586 0 : status = -1;
8587 0 : HEpush(DFE_GENAPP, "GDextractregion", __FILE__, __LINE__);
8588 0 : HEreport(
8589 : "One-Dimesional fields \"%s\" may not be subsetted.\n",
8590 : fieldname);
8591 : }
8592 : else
8593 : {
8594 : /* "XDim" and/or "YDim" not found */
8595 : /* ------------------------------ */
8596 0 : if (EHstrwithin("XDim", dimlist, ',') == -1 ||
8597 0 : EHstrwithin("YDim", dimlist, ',') == -1)
8598 : {
8599 0 : status = -1;
8600 0 : HEpush(DFE_GENAPP, "GDextractregion", __FILE__, __LINE__);
8601 0 : snprintf(errbuf, sizeof(errbuf), "%s%s", errM1, errM2);
8602 0 : HEreport(errbuf, fieldname);
8603 : }
8604 : }
8605 : }
8606 :
8607 :
8608 :
8609 0 : if (status == 0)
8610 : {
8611 :
8612 : /* Get origin order info */
8613 : /* --------------------- */
8614 0 : status = GDorigininfo(gridID, &origincode);
8615 :
8616 :
8617 : /* Initialize start & edge arrays */
8618 : /* ------------------------------ */
8619 0 : for (i = 0; i < rank; i++)
8620 : {
8621 0 : start[i] = 0;
8622 0 : edge[i] = dims[i];
8623 : }
8624 :
8625 :
8626 : /* if MISR SOM projection, set start */
8627 : /* & edge arrays for SOMBlockDim */
8628 : /* --------------------------------- */
8629 0 : if (EHstrwithin("SOMBlockDim", dimlist, ',') == 0)
8630 : {
8631 0 : l_index = EHstrwithin("SOMBlockDim", dimlist, ',');
8632 0 : edge[l_index] = GDXRegion[regionID]->somCount;
8633 0 : start[l_index] = GDXRegion[regionID]->somStart;
8634 : }
8635 :
8636 :
8637 : /* Set start & edge arrays for XDim */
8638 : /* -------------------------------- */
8639 0 : l_index = EHstrwithin("XDim", dimlist, ',');
8640 0 : if (GDXRegion[regionID]->xCount != 0)
8641 : {
8642 0 : edge[l_index] = GDXRegion[regionID]->xCount;
8643 0 : start[l_index] = GDXRegion[regionID]->xStart;
8644 : }
8645 :
8646 : /* Adjust X-dim start if origin on right edge */
8647 : /* ------------------------------------------ */
8648 0 : if ((origincode & 1) == 1)
8649 : {
8650 0 : start[l_index] = dims[l_index] - (start[l_index] + edge[l_index]);
8651 : }
8652 :
8653 :
8654 : /* Set start & edge arrays for YDim */
8655 : /* -------------------------------- */
8656 0 : l_index = EHstrwithin("YDim", dimlist, ',');
8657 0 : if (GDXRegion[regionID]->yCount != 0)
8658 : {
8659 0 : start[l_index] = GDXRegion[regionID]->yStart;
8660 0 : edge[l_index] = GDXRegion[regionID]->yCount;
8661 : }
8662 :
8663 : /* Adjust Y-dim start if origin on lower edge */
8664 : /* ------------------------------------------ */
8665 0 : if ((origincode & 2) == 2)
8666 : {
8667 0 : start[l_index] = dims[l_index] - (start[l_index] + edge[l_index]);
8668 : }
8669 :
8670 :
8671 :
8672 : /* Vertical Subset */
8673 : /* --------------- */
8674 0 : for (j = 0; j < 8; j++)
8675 : {
8676 : /* If active vertical subset ... */
8677 : /* ----------------------------- */
8678 0 : if (GDXRegion[regionID]->StartVertical[j] != -1)
8679 : {
8680 :
8681 : /* Find vertical dimension within dimlist */
8682 : /* -------------------------------------- */
8683 0 : l_index = EHstrwithin(GDXRegion[regionID]->DimNamePtr[j],
8684 : dimlist, ',');
8685 :
8686 : /* If dimension found ... */
8687 : /* ---------------------- */
8688 0 : if (l_index != -1)
8689 : {
8690 : /* Compute start and edge for vertical dimension */
8691 : /* --------------------------------------------- */
8692 0 : start[l_index] = GDXRegion[regionID]->StartVertical[j];
8693 0 : edge[l_index] = GDXRegion[regionID]->StopVertical[j] -
8694 0 : GDXRegion[regionID]->StartVertical[j] + 1;
8695 : }
8696 : else
8697 : {
8698 : /* Vertical dimension not found */
8699 : /* ---------------------------- */
8700 0 : status = -1;
8701 0 : HEpush(DFE_GENAPP, "GDextractregion", __FILE__, __LINE__);
8702 0 : HEreport(errMesg,
8703 0 : GDXRegion[regionID]->DimNamePtr[j]);
8704 : }
8705 : }
8706 : }
8707 :
8708 :
8709 : /* Read into data buffer */
8710 : /* --------------------- */
8711 0 : if (status == 0)
8712 : {
8713 0 : status = GDreadfield(gridID, fieldname, start, NULL, edge, buffer);
8714 : }
8715 : }
8716 0 : return (status);
8717 : }
8718 :
8719 :
8720 :
8721 :
8722 : /*----------------------------------------------------------------------------|
8723 : | BEGIN_PROLOG |
8724 : | |
8725 : | FUNCTION: GDdupregion |
8726 : | |
8727 : | DESCRIPTION: Duplicates a region |
8728 : | |
8729 : | |
8730 : | Return Value Type Units Description |
8731 : | ============ ====== ========= ===================================== |
8732 : | newregionID int32 New region ID |
8733 : | |
8734 : | INPUTS: |
8735 : | oldregionID int32 Old region ID |
8736 : | |
8737 : | OUTPUTS: |
8738 : | None |
8739 : | |
8740 : | NOTES: |
8741 : | |
8742 : | |
8743 : | Date Programmer Description |
8744 : | ====== ============ ================================================= |
8745 : | Jan 97 Joel Gales Original Programmer |
8746 : | Oct 98 Abe Taaheri changed *GDXRegion[i] = *GDXRegion[oldregionID]; |
8747 : | to copy elements of structure one by one to avoid |
8748 : | copying pointer for DimNamePtr to another place that|
8749 : | causes "Freeing Unallocated Memory" in purify when |
8750 : | using GDdetach |
8751 : | |
8752 : | END_PROLOG |
8753 : -----------------------------------------------------------------------------*/
8754 : int32
8755 0 : GDdupregion(int32 oldregionID)
8756 : {
8757 : intn i; /* Loop index */
8758 : intn j; /* Loop index */
8759 : int32 slendupregion;
8760 0 : int32 newregionID = -1; /* New region ID */
8761 :
8762 :
8763 : /* Find first empty (inactive) region */
8764 : /* ---------------------------------- */
8765 0 : for (i = 0; i < NGRIDREGN; i++)
8766 : {
8767 0 : if (GDXRegion[i] == 0)
8768 : {
8769 : /* Allocate space for new grid region entry */
8770 : /* ---------------------------------------- */
8771 0 : GDXRegion[i] = (struct gridRegion *)
8772 0 : calloc(1, sizeof(struct gridRegion));
8773 0 : if(GDXRegion[i] == NULL)
8774 : {
8775 0 : HEpush(DFE_NOSPACE,"GDdupregion", __FILE__, __LINE__);
8776 0 : return(-1);
8777 : }
8778 :
8779 :
8780 : /* Copy old region structure data to new region */
8781 : /* -------------------------------------------- */
8782 :
8783 0 : GDXRegion[i]->fid = GDXRegion[oldregionID]->fid;
8784 0 : GDXRegion[i]->gridID = GDXRegion[oldregionID]->gridID;
8785 0 : GDXRegion[i]->xStart = GDXRegion[oldregionID]->xStart;
8786 0 : GDXRegion[i]->xCount = GDXRegion[oldregionID]->xCount;
8787 0 : GDXRegion[i]->yStart = GDXRegion[oldregionID]->yStart;
8788 0 : GDXRegion[i]->yCount = GDXRegion[oldregionID]->yCount;
8789 0 : GDXRegion[i]->upleftpt[0] = GDXRegion[oldregionID]->upleftpt[0];
8790 0 : GDXRegion[i]->upleftpt[1] = GDXRegion[oldregionID]->upleftpt[1];
8791 0 : GDXRegion[i]->lowrightpt[0] = GDXRegion[oldregionID]->lowrightpt[0];
8792 0 : GDXRegion[i]->lowrightpt[1] = GDXRegion[oldregionID]->lowrightpt[1];
8793 0 : for (j = 0; j < 8; j++)
8794 : {
8795 0 : GDXRegion[i]->StartVertical[j] = GDXRegion[oldregionID]->StartVertical[j];
8796 0 : GDXRegion[i]->StopVertical[j] = GDXRegion[oldregionID]->StopVertical[j];
8797 : }
8798 :
8799 0 : for (j=0; j<8; j++)
8800 : {
8801 0 : if(GDXRegion[oldregionID]->DimNamePtr[j] != NULL)
8802 : {
8803 0 : slendupregion = (int)strlen(GDXRegion[oldregionID]->DimNamePtr[j]);
8804 0 : GDXRegion[i]->DimNamePtr[j] = (char *) malloc(slendupregion + 1);
8805 0 : strcpy(GDXRegion[i]->DimNamePtr[j],GDXRegion[oldregionID]->DimNamePtr[j]);
8806 : }
8807 : }
8808 :
8809 :
8810 : /* Define new region ID */
8811 : /* -------------------- */
8812 0 : newregionID = i;
8813 :
8814 0 : break;
8815 : }
8816 : }
8817 0 : return (newregionID);
8818 : }
8819 :
8820 :
8821 : /*----------------------------------------------------------------------------|
8822 : | BEGIN_PROLOG |
8823 : | |
8824 : | FUNCTION: GDdefvrtregion |
8825 : | |
8826 : | DESCRIPTION: Finds elements of a monotonic field within a vertical subset |
8827 : | region. |
8828 : | |
8829 : | |
8830 : | Return Value Type Units Description |
8831 : | ============ ====== ========= ===================================== |
8832 : | regionID int32 Region ID |
8833 : | |
8834 : | INPUTS: |
8835 : | gridID int32 Grid structure ID |
8836 : | regionID int32 Region ID |
8837 : | vertObj char Vertical object to subset |
8838 : | range float64 Vertical subsetting range |
8839 : | |
8840 : | OUTPUTS: |
8841 : | None |
8842 : | |
8843 : | NOTES: |
8844 : | |
8845 : | |
8846 : | Date Programmer Description |
8847 : | ====== ============ ================================================= |
8848 : | Aug 96 Joel Gales Original Programmer |
8849 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
8850 : | Feb 97 Joel Gales Store XDim, YDim, upleftpt, lowrightpt in GDXRegion |
8851 : | |
8852 : | END_PROLOG |
8853 : -----------------------------------------------------------------------------*/
8854 : #define SETGRIDREG \
8855 : \
8856 : status = GDgridinfo(gridID, &xdimsize, &ydimsize, upleftpt, lowrightpt); \
8857 : for (k = 0; k < NGRIDREGN; k++) \
8858 : { \
8859 : if (GDXRegion[k] == 0) \
8860 : { \
8861 : GDXRegion[k] = (struct gridRegion *) \
8862 : calloc(1, sizeof(struct gridRegion)); \
8863 : GDXRegion[k]->fid = fid; \
8864 : GDXRegion[k]->gridID = gridID; \
8865 : GDXRegion[k]->xStart = 0; \
8866 : GDXRegion[k]->xCount = xdimsize; \
8867 : GDXRegion[k]->yStart = 0; \
8868 : GDXRegion[k]->yCount = ydimsize; \
8869 : GDXRegion[k]->upleftpt[0] = upleftpt[0]; \
8870 : GDXRegion[k]->upleftpt[1] = upleftpt[1]; \
8871 : GDXRegion[k]->lowrightpt[0] = lowrightpt[0]; \
8872 : GDXRegion[k]->lowrightpt[1] = lowrightpt[1]; \
8873 : regionID = k; \
8874 : for (j=0; j<8; j++) \
8875 : { \
8876 : GDXRegion[k]->StartVertical[j] = -1; \
8877 : GDXRegion[k]->StopVertical[j] = -1; \
8878 : } \
8879 : break; \
8880 : } \
8881 : }
8882 :
8883 : #define FILLVERTREG \
8884 : for (j=0; j<8; j++) \
8885 : { \
8886 : if (GDXRegion[regionID]->StartVertical[j] == -1) \
8887 : { \
8888 : GDXRegion[regionID]->StartVertical[j] = i; \
8889 : GDXRegion[regionID]->DimNamePtr[j] = \
8890 : (char *) malloc(slen + 1); \
8891 : memcpy(GDXRegion[regionID]->DimNamePtr[j], \
8892 : dimlist, slen + 1); \
8893 : break; \
8894 : } \
8895 : } \
8896 :
8897 :
8898 :
8899 : int32
8900 0 : GDdefvrtregion(int32 gridID, int32 regionID, const char *vertObj, float64 range[])
8901 : {
8902 0 : intn i, j = 0, k, status;
8903 0 : uint8 found = 0;
8904 :
8905 : int16 vertINT16;
8906 :
8907 : int32 fid, sdInterfaceID, slen;
8908 : int32 gdVgrpID, rank, nt, dims[8], size;
8909 : int32 vertINT32;
8910 : int32 xdimsize;
8911 : int32 ydimsize;
8912 :
8913 : float32 vertFLT32;
8914 : float64 vertFLT64;
8915 : float64 upleftpt[2];
8916 : float64 lowrightpt[2];
8917 :
8918 : char *vertArr;
8919 : char *dimlist;
8920 :
8921 : /* Allocate space for dimlist */
8922 : /* --------------------------------- */
8923 0 : dimlist = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
8924 0 : if(dimlist == NULL)
8925 : {
8926 0 : HEpush(DFE_NOSPACE,"GDdefvrtregion", __FILE__, __LINE__);
8927 0 : return(-1);
8928 : }
8929 : /* Check for valid grid ID */
8930 : /* ----------------------- */
8931 0 : status = GDchkgdid(gridID, "GDdefvrtregion",
8932 : &fid, &sdInterfaceID, &gdVgrpID);
8933 :
8934 0 : if (status == 0)
8935 : {
8936 0 : memcpy(dimlist, vertObj, 4);
8937 0 : dimlist[4] = 0;
8938 :
8939 0 : if (strcmp(dimlist, "DIM:") == 0)
8940 : {
8941 0 : slen = (int)strlen(vertObj) - 4;
8942 0 : if (regionID == -1)
8943 : {
8944 0 : SETGRIDREG;
8945 : }
8946 0 : for (j = 0; j < 8; j++)
8947 : {
8948 0 : if (GDXRegion[regionID]->StartVertical[j] == -1)
8949 : {
8950 0 : GDXRegion[regionID]->StartVertical[j] = (int32) range[0];
8951 0 : GDXRegion[regionID]->StopVertical[j] = (int32) range[1];
8952 0 : GDXRegion[regionID]->DimNamePtr[j] =
8953 0 : (char *) malloc(slen + 1);
8954 0 : if(GDXRegion[regionID]->DimNamePtr[j] == NULL)
8955 : {
8956 0 : HEpush(DFE_NOSPACE,"GDdefvrtregion", __FILE__, __LINE__);
8957 0 : free(dimlist);
8958 0 : return(-1);
8959 : }
8960 0 : memcpy(GDXRegion[regionID]->DimNamePtr[j],
8961 0 : vertObj + 4, slen + 1);
8962 0 : break;
8963 : }
8964 : }
8965 : }
8966 : else
8967 : {
8968 0 : status = GDfieldinfo(gridID, vertObj, &rank, dims, &nt, dimlist);
8969 0 : if (status != 0)
8970 : {
8971 0 : status = -1;
8972 0 : HEpush(DFE_GENAPP, "GDdefvrtregion", __FILE__, __LINE__);
8973 0 : HEreport("Vertical Field: \"%s\" not found.\n", vertObj);
8974 : }
8975 : else
8976 : {
8977 0 : if (rank != 1)
8978 : {
8979 0 : status = -1;
8980 0 : HEpush(DFE_GENAPP, "GDdefvrtregion", __FILE__, __LINE__);
8981 0 : HEreport("Vertical Field: \"%s\" must be 1-dim.\n",
8982 : vertObj);
8983 : }
8984 : else
8985 : {
8986 0 : slen = (int)strlen(dimlist);
8987 0 : size = DFKNTsize(nt);
8988 0 : vertArr = (char *) calloc(dims[0], size);
8989 0 : if(vertArr == NULL)
8990 : {
8991 0 : HEpush(DFE_NOSPACE,"GDdefvrtregion", __FILE__, __LINE__);
8992 0 : free(dimlist);
8993 0 : return(-1);
8994 : }
8995 :
8996 0 : status = GDreadfield(gridID, vertObj,
8997 : NULL, NULL, NULL, vertArr);
8998 :
8999 0 : switch (nt)
9000 : {
9001 0 : case DFNT_INT16:
9002 :
9003 0 : for (i = 0; i < dims[0]; i++)
9004 : {
9005 0 : memcpy(&vertINT16, vertArr + i * size, size);
9006 :
9007 0 : if (vertINT16 >= range[0] &&
9008 0 : vertINT16 <= range[1])
9009 : {
9010 0 : found = 1;
9011 0 : if (regionID == -1)
9012 : {
9013 0 : SETGRIDREG;
9014 : }
9015 0 : FILLVERTREG;
9016 :
9017 0 : break;
9018 : }
9019 : }
9020 :
9021 0 : if (found == 1)
9022 : {
9023 0 : for (i = dims[0] - 1; i >= 0; i--)
9024 : {
9025 0 : memcpy(&vertINT16, vertArr + i * size, size);
9026 :
9027 0 : if (vertINT16 >= range[0] &&
9028 0 : vertINT16 <= range[1])
9029 : {
9030 0 : GDXRegion[regionID]->StopVertical[j] = i;
9031 0 : break;
9032 : }
9033 : }
9034 : }
9035 : else
9036 : {
9037 0 : status = -1;
9038 : }
9039 0 : break;
9040 :
9041 :
9042 0 : case DFNT_INT32:
9043 :
9044 0 : for (i = 0; i < dims[0]; i++)
9045 : {
9046 0 : memcpy(&vertINT32, vertArr + i * size, size);
9047 :
9048 0 : if (vertINT32 >= range[0] &&
9049 0 : vertINT32 <= range[1])
9050 : {
9051 0 : found = 1;
9052 0 : if (regionID == -1)
9053 : {
9054 0 : SETGRIDREG;
9055 : }
9056 0 : FILLVERTREG;
9057 :
9058 0 : break;
9059 : }
9060 : }
9061 :
9062 0 : if (found == 1)
9063 : {
9064 0 : for (i = dims[0] - 1; i >= 0; i--)
9065 : {
9066 0 : memcpy(&vertINT32, vertArr + i * size, size);
9067 :
9068 0 : if (vertINT32 >= range[0] &&
9069 0 : vertINT32 <= range[1])
9070 : {
9071 0 : GDXRegion[regionID]->StopVertical[j] = i;
9072 0 : break;
9073 : }
9074 : }
9075 : }
9076 : else
9077 : {
9078 0 : status = -1;
9079 : }
9080 0 : break;
9081 :
9082 :
9083 0 : case DFNT_FLOAT32:
9084 :
9085 0 : for (i = 0; i < dims[0]; i++)
9086 : {
9087 0 : memcpy(&vertFLT32, vertArr + i * size, size);
9088 :
9089 0 : if (vertFLT32 >= range[0] &&
9090 0 : vertFLT32 <= range[1])
9091 : {
9092 0 : found = 1;
9093 0 : if (regionID == -1)
9094 : {
9095 0 : SETGRIDREG;
9096 : }
9097 0 : FILLVERTREG;
9098 :
9099 0 : break;
9100 : }
9101 : }
9102 :
9103 0 : if (found == 1)
9104 : {
9105 0 : for (i = dims[0] - 1; i >= 0; i--)
9106 : {
9107 0 : memcpy(&vertFLT32, vertArr + i * size, size);
9108 :
9109 0 : if (vertFLT32 >= range[0] &&
9110 0 : vertFLT32 <= range[1])
9111 : {
9112 0 : GDXRegion[regionID]->StopVertical[j] = i;
9113 0 : break;
9114 : }
9115 : }
9116 : }
9117 : else
9118 : {
9119 0 : status = -1;
9120 : }
9121 0 : break;
9122 :
9123 :
9124 0 : case DFNT_FLOAT64:
9125 :
9126 0 : for (i = 0; i < dims[0]; i++)
9127 : {
9128 0 : memcpy(&vertFLT64, vertArr + i * size, size);
9129 :
9130 0 : if (vertFLT64 >= range[0] &&
9131 0 : vertFLT64 <= range[1])
9132 : {
9133 0 : found = 1;
9134 0 : if (regionID == -1)
9135 : {
9136 0 : SETGRIDREG;
9137 : }
9138 0 : FILLVERTREG;
9139 :
9140 0 : break;
9141 : }
9142 : }
9143 :
9144 0 : if (found == 1)
9145 : {
9146 0 : for (i = dims[0] - 1; i >= 0; i--)
9147 : {
9148 0 : memcpy(&vertFLT64, vertArr + i * size, size);
9149 :
9150 0 : if (vertFLT64 >= range[0] &&
9151 0 : vertFLT64 <= range[1])
9152 : {
9153 0 : GDXRegion[regionID]->StopVertical[j] = i;
9154 0 : break;
9155 : }
9156 : }
9157 : }
9158 : else
9159 : {
9160 0 : status = -1;
9161 : }
9162 0 : break;
9163 :
9164 : }
9165 0 : free(vertArr);
9166 : }
9167 : }
9168 : }
9169 : }
9170 0 : if (status == -1)
9171 : {
9172 0 : regionID = -1;
9173 : }
9174 0 : free(dimlist);
9175 0 : return (regionID);
9176 : }
9177 :
9178 :
9179 :
9180 :
9181 :
9182 : /*----------------------------------------------------------------------------|
9183 : | BEGIN_PROLOG |
9184 : | |
9185 : | FUNCTION: GDdeftimeperiod |
9186 : | |
9187 : | DESCRIPTION: Finds elements of the "Time" field within a given time |
9188 : | period. |
9189 : | |
9190 : | |
9191 : | Return Value Type Units Description |
9192 : | ============ ====== ========= ===================================== |
9193 : | periodID int32 Period ID |
9194 : | |
9195 : | INPUTS: |
9196 : | gridID int32 Grid structure ID |
9197 : | periodID int32 Period ID |
9198 : | starttime float64 TAI sec Start of time period |
9199 : | stoptime float64 TAI sec Stop of time period |
9200 : | |
9201 : | OUTPUTS: |
9202 : | None |
9203 : | |
9204 : | NOTES: |
9205 : | |
9206 : | |
9207 : | Date Programmer Description |
9208 : | ====== ============ ================================================= |
9209 : | Aug 96 Joel Gales Original Programmer |
9210 : | |
9211 : | END_PROLOG |
9212 : -----------------------------------------------------------------------------*/
9213 : int32
9214 0 : GDdeftimeperiod(int32 gridID, int32 periodID, float64 starttime,
9215 : float64 stoptime)
9216 : {
9217 : float64 timerange[2];
9218 :
9219 0 : timerange[0] = starttime;
9220 0 : timerange[1] = stoptime;
9221 :
9222 0 : periodID = GDdefvrtregion(gridID, periodID, "Time", timerange);
9223 :
9224 0 : return (periodID);
9225 : }
9226 :
9227 :
9228 :
9229 : /*----------------------------------------------------------------------------|
9230 : | BEGIN_PROLOG |
9231 : | |
9232 : | FUNCTION: GDgetpixels |
9233 : | |
9234 : | DESCRIPTION: Finds row and columns for specified lon/lat values |
9235 : | |
9236 : | |
9237 : | Return Value Type Units Description |
9238 : | ============ ====== ========= ===================================== |
9239 : | status intn return status (0) SUCCEED, (-1) FAIL |
9240 : | |
9241 : | INPUTS: |
9242 : | gridID int32 Grid structure ID |
9243 : | nLonLat int32 Number of lonlat values |
9244 : | lonVal float64 dec deg Longitude values |
9245 : | latVal float64 dec deg Latitude values |
9246 : | |
9247 : | |
9248 : | OUTPUTS: |
9249 : | pixRow int32 Pixel rows |
9250 : | pixCol int32 Pixel columns |
9251 : | |
9252 : | NOTES: |
9253 : | |
9254 : | |
9255 : | Date Programmer Description |
9256 : | ====== ============ ================================================= |
9257 : | Aug 96 Joel Gales Original Programmer |
9258 : | Oct 96 Joel Gales Set row/col to -1 if outside boundary |
9259 : | Mar 97 Joel Gales Adjust row/col for CORNER pixel registration |
9260 : | |
9261 : | END_PROLOG |
9262 : -----------------------------------------------------------------------------*/
9263 : intn
9264 0 : GDgetpixels(int32 gridID, int32 nLonLat, float64 lonVal[], float64 latVal[],
9265 : int32 pixRow[], int32 pixCol[])
9266 : {
9267 : intn i; /* Loop index */
9268 0 : intn status = 0; /* routine return status variable */
9269 :
9270 : int32 fid; /* HDF-EOS file ID */
9271 : int32 sdInterfaceID; /* HDF SDS interface ID */
9272 : int32 gdVgrpID; /* Grid root Vgroup ID */
9273 :
9274 : int32 xdimsize; /* Size of "XDim" */
9275 : int32 ydimsize; /* Size of "YDim" */
9276 : int32 projcode; /* GCTP projection code */
9277 : int32 zonecode; /* Zone code */
9278 : int32 spherecode; /* Sphere code */
9279 : int32 origincode; /* Origin code */
9280 : int32 pixregcode; /* Pixel registration code */
9281 :
9282 : float64 upleftpt[2];/* Upper left point */
9283 : float64 lowrightpt[2]; /* Lower right point */
9284 : float64 projparm[16]; /* Projection parameters */
9285 : float64 *xVal; /* Pointer to point x location values */
9286 : float64 *yVal; /* Pointer to point y location values */
9287 :
9288 :
9289 : /* Check for valid grid ID */
9290 : /* ----------------------- */
9291 0 : status = GDchkgdid(gridID, "GDgetpixels", &fid, &sdInterfaceID, &gdVgrpID);
9292 :
9293 0 : if (status == 0)
9294 : {
9295 : /* Get grid info */
9296 : /* ------------- */
9297 0 : status = GDgridinfo(gridID, &xdimsize, &ydimsize,
9298 : upleftpt, lowrightpt);
9299 :
9300 :
9301 : /* Get projection info */
9302 : /* ------------------- */
9303 0 : status = GDprojinfo(gridID, &projcode, &zonecode,
9304 : &spherecode, projparm);
9305 :
9306 :
9307 : /* Get explicit upleftpt & lowrightpt if defaults are used */
9308 : /* ------------------------------------------------------- */
9309 0 : status = GDgetdefaults(projcode, zonecode, projparm, spherecode,
9310 : upleftpt, lowrightpt);
9311 :
9312 :
9313 : /* Get pixel registration and origin info */
9314 : /* -------------------------------------- */
9315 0 : status = GDorigininfo(gridID, &origincode);
9316 0 : status = GDpixreginfo(gridID, &pixregcode);
9317 :
9318 :
9319 : /* Allocate space for x & y locations */
9320 : /* ---------------------------------- */
9321 0 : xVal = (float64 *) calloc(nLonLat, sizeof(float64));
9322 0 : if(xVal == NULL)
9323 : {
9324 0 : HEpush(DFE_NOSPACE,"GDgetpixels", __FILE__, __LINE__);
9325 0 : return(-1);
9326 : }
9327 0 : yVal = (float64 *) calloc(nLonLat, sizeof(float64));
9328 0 : if(yVal == NULL)
9329 : {
9330 0 : HEpush(DFE_NOSPACE,"GDgetpixels", __FILE__, __LINE__);
9331 0 : free(xVal);
9332 0 : return(-1);
9333 : }
9334 :
9335 :
9336 : /* Get pixRow, pixCol, xVal, & yVal */
9337 : /* -------------------------------- */
9338 0 : status = GDll2ij(projcode, zonecode, projparm, spherecode,
9339 : xdimsize, ydimsize, upleftpt, lowrightpt,
9340 : nLonLat, lonVal, latVal, pixRow, pixCol,
9341 : xVal, yVal);
9342 :
9343 :
9344 :
9345 : /* Loop through all lon/lat values */
9346 : /* ------------------------------- */
9347 0 : for (i = 0; i < nLonLat; i++)
9348 : {
9349 : /* Adjust columns & rows for "corner" registered grids */
9350 : /* --------------------------------------------------- */
9351 0 : if (pixregcode == HDFE_CORNER)
9352 : {
9353 0 : if (origincode == HDFE_GD_UL)
9354 : {
9355 0 : if (xVal[i] - pixCol[i] > 0.5)
9356 : {
9357 0 : ++pixCol[i];
9358 : }
9359 :
9360 0 : if (yVal[i] - pixRow[i] > 0.5)
9361 : {
9362 0 : ++pixRow[i];
9363 : }
9364 : }
9365 0 : else if (origincode == HDFE_GD_UR)
9366 : {
9367 0 : if (xVal[i] - pixCol[i] <= 0.5)
9368 : {
9369 0 : --pixCol[i];
9370 : }
9371 :
9372 0 : if (yVal[i] - pixRow[i] > 0.5)
9373 : {
9374 0 : ++pixRow[i];
9375 : }
9376 : }
9377 0 : else if (origincode == HDFE_GD_LL)
9378 : {
9379 0 : if (xVal[i] - pixCol[i] > 0.5)
9380 : {
9381 0 : ++pixCol[i];
9382 : }
9383 :
9384 0 : if (yVal[i] - pixRow[i] <= 0.5)
9385 : {
9386 0 : --pixRow[i];
9387 : }
9388 : }
9389 0 : else if (origincode == HDFE_GD_LR)
9390 : {
9391 0 : if (xVal[i] - pixCol[i] <= 0.5)
9392 : {
9393 0 : --pixCol[i];
9394 : }
9395 :
9396 0 : if (yVal[i] - pixRow[i] <= 0.5)
9397 : {
9398 0 : --pixRow[i];
9399 : }
9400 : }
9401 : }
9402 :
9403 :
9404 : /* If outside grid boundaries then set to -1 */
9405 : /* ----------------------------------------- */
9406 0 : if (pixCol[i] < 0 || pixCol[i] >= xdimsize ||
9407 0 : pixRow[i] < 0 || pixRow[i] >= ydimsize)
9408 : {
9409 0 : pixCol[i] = -1;
9410 0 : pixRow[i] = -1;
9411 : }
9412 : }
9413 0 : free(xVal);
9414 0 : free(yVal);
9415 : }
9416 0 : return (status);
9417 : }
9418 :
9419 :
9420 :
9421 :
9422 :
9423 : /*----------------------------------------------------------------------------|
9424 : | BEGIN_PROLOG |
9425 : | |
9426 : | FUNCTION: GDgetpixvalues |
9427 : | |
9428 : | DESCRIPTION: Retrieves data from specified pixels. |
9429 : | |
9430 : | |
9431 : | Return Value Type Units Description |
9432 : | ============ ====== ========= ===================================== |
9433 : | size*nPixels int32 Size of data buffer |
9434 : | |
9435 : | INPUTS: |
9436 : | gridID int32 Grid structure ID |
9437 : | nPixels int32 Number of pixels |
9438 : | pixRow int32 Pixel row numbers |
9439 : | pixCol int32 Pixel column numbers |
9440 : | fieldname char Fieldname |
9441 : | |
9442 : | OUTPUTS: |
9443 : | buffer void Data buffer |
9444 : | |
9445 : | |
9446 : | NOTES: |
9447 : | |
9448 : | |
9449 : | Date Programmer Description |
9450 : | ====== ============ ================================================= |
9451 : | Aug 96 Joel Gales Original Programmer |
9452 : | Oct 96 Joel Gales Check for pixels outside boundaries (-1) |
9453 : | Mar 98 Abe Taaheri revised to reduce overhead for rechecking |
9454 : | for gridid, fieldname, etc in GDreadfield. |
9455 : | June 98 AT fixed bug with 2-dim field merged in 3-dim field |
9456 : | (for offset and count) |
9457 : | END_PROLOG |
9458 : -----------------------------------------------------------------------------*/
9459 : int32
9460 0 : GDgetpixvalues(int32 gridID, int32 nPixels, int32 pixRow[], int32 pixCol[],
9461 : const char *fieldname, VOIDP buffer)
9462 : {
9463 : intn i; /* Loop index */
9464 : intn j; /* Loop index */
9465 0 : intn status = 0; /* routine return status variable */
9466 :
9467 : int32 fid; /* HDF-EOS file ID */
9468 : int32 sdInterfaceID; /* HDF SDS interface ID */
9469 : int32 gdVgrpID; /* Grid root Vgroup ID */
9470 :
9471 : int32 start[8]; /* GDreadfield start array */
9472 : int32 edge[8]; /* GDreadfield edge array */
9473 : int32 dims[8]; /* Field dimensions */
9474 : int32 rank; /* Field rank */
9475 0 : int32 xdum = 0; /* Location of "XDim" within field list */
9476 0 : int32 ydum = 0; /* Location of "YDim" within field list */
9477 : int32 ntype; /* Field number type */
9478 : int32 origincode; /* Origin code */
9479 : int32 bufOffset; /* Data buffer offset */
9480 0 : int32 size = 0; /* Size of returned data buffer for each
9481 : * value in bytes */
9482 : int32 offset[8]; /* I/O offset (start) */
9483 : int32 incr[8]; /* I/O increment (stride) */
9484 : int32 count[8]; /* I/O count (edge) */
9485 : int32 sdid; /* SDS ID */
9486 : int32 rankSDS; /* Rank of SDS */
9487 : int32 rankFld; /* Rank of field */
9488 : int32 dum; /* Dummy variable */
9489 : int32 mrgOffset; /* Merged field offset */
9490 :
9491 : char *dimlist; /* Dimension list */
9492 :
9493 :
9494 :
9495 : /* Allocate space for dimlist */
9496 : /* --------------------------------- */
9497 0 : dimlist = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
9498 0 : if(dimlist == NULL)
9499 : {
9500 0 : HEpush(DFE_NOSPACE,"GDgetpixvalues", __FILE__, __LINE__);
9501 0 : return(-1);
9502 : }
9503 : /* Check for valid grid ID */
9504 : /* ----------------------- */
9505 0 : status = GDchkgdid(gridID, "GDgetpixvalues",
9506 : &fid, &sdInterfaceID, &gdVgrpID);
9507 :
9508 :
9509 0 : if (status == 0)
9510 : {
9511 : /* Get field list */
9512 : /* -------------- */
9513 0 : status = GDfieldinfo(gridID, fieldname, &rank, dims, &ntype, dimlist);
9514 :
9515 :
9516 : /* Check for "XDim" & "YDim" in dimension list */
9517 : /* ------------------------------------------- */
9518 0 : if (status == 0)
9519 : {
9520 0 : xdum = EHstrwithin("XDim", dimlist, ',');
9521 0 : ydum = EHstrwithin("YDim", dimlist, ',');
9522 :
9523 0 : if (xdum == -1)
9524 : {
9525 0 : status = -1;
9526 0 : HEpush(DFE_GENAPP, "GDgetpixvalues", __FILE__, __LINE__);
9527 0 : HEreport(
9528 : "\"XDim\" not present in dimlist for field: \"%s\".\n",
9529 : fieldname);
9530 : }
9531 :
9532 :
9533 0 : if (ydum == -1)
9534 : {
9535 0 : status = -1;
9536 0 : HEpush(DFE_GENAPP, "GDgetpixvalues", __FILE__, __LINE__);
9537 0 : HEreport(
9538 : "\"YDim\" not present in dimlist for field: \"%s\".\n",
9539 : fieldname);
9540 : }
9541 : }
9542 : else
9543 : {
9544 0 : status = -1;
9545 0 : HEpush(DFE_GENAPP, "GDgetpixvalues", __FILE__, __LINE__);
9546 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
9547 : }
9548 :
9549 :
9550 0 : if (status == 0)
9551 : {
9552 :
9553 : /* Get origin order info */
9554 : /* --------------------- */
9555 0 : status = GDorigininfo(gridID, &origincode);
9556 :
9557 :
9558 : /* Initialize start & edge arrays */
9559 : /* ------------------------------ */
9560 0 : for (i = 0; i < rank; i++)
9561 : {
9562 0 : start[i] = 0;
9563 0 : edge[i] = dims[i];
9564 : }
9565 :
9566 :
9567 : /* Compute size of data buffer for each pixel */
9568 : /* ------------------------------------------ */
9569 0 : edge[xdum] = 1;
9570 0 : edge[ydum] = 1;
9571 0 : size = edge[0];
9572 0 : for (j = 1; j < rank; j++)
9573 : {
9574 0 : size *= edge[j];
9575 : }
9576 0 : size *= DFKNTsize(ntype);
9577 :
9578 :
9579 :
9580 : /* If data values are requested ... */
9581 : /* -------------------------------- */
9582 0 : if (buffer != NULL)
9583 : {
9584 : /* get sdid */
9585 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
9586 : &rankSDS, &rankFld, &mrgOffset, dims, &dum);
9587 :
9588 : /* Loop through all pixels */
9589 : /* ----------------------- */
9590 0 : for (i = 0; i < nPixels; i++)
9591 : {
9592 : /* Conmpute offset within returned data buffer */
9593 : /* ------------------------------------------- */
9594 0 : bufOffset = size * i;
9595 :
9596 :
9597 : /* If pixel row & column OK ... */
9598 : /* ---------------------------- */
9599 0 : if (pixCol[i] != -1 && pixRow[i] != -1)
9600 : {
9601 0 : start[xdum] = pixCol[i];
9602 0 : start[ydum] = pixRow[i];
9603 :
9604 :
9605 : /* Adjust X-dim start if origin on right edge */
9606 : /* ------------------------------------------ */
9607 0 : if ((origincode & 1) == 1)
9608 : {
9609 0 : start[xdum] = dims[xdum] - (start[xdum] + 1);
9610 : }
9611 :
9612 :
9613 : /* Adjust Y-dim start if origin on lower edge */
9614 : /* ------------------------------------------ */
9615 0 : if ((origincode & 2) == 2)
9616 : {
9617 0 : start[ydum] = dims[ydum] - (start[ydum] + 1);
9618 : }
9619 :
9620 : /* Set I/O offset and count Section */
9621 : /* ---------------------- */
9622 :
9623 : /*
9624 : * start and edge != NULL, set I/O offset and count to
9625 : * user values, adjusting the
9626 : * 0th field with the merged field offset (if any)
9627 : */
9628 0 : if (rankFld == rankSDS)
9629 : {
9630 0 : for (j = 0; j < rankSDS; j++)
9631 : {
9632 0 : offset[j] = start[j];
9633 0 : count[j] = edge[j];
9634 : }
9635 0 : offset[0] += mrgOffset;
9636 : }
9637 : else
9638 : {
9639 : /*
9640 : * If field really 2-dim merged in 3-dim field then set
9641 : * 0th field offset to merge offset and then next two to
9642 : * the user values
9643 : */
9644 0 : for (j = 0; j < rankFld; j++)
9645 : {
9646 0 : offset[j + 1] = start[j];
9647 0 : count[j + 1] = edge[j];
9648 : }
9649 0 : offset[0] = mrgOffset;
9650 0 : count[0] = 1;
9651 : }
9652 :
9653 :
9654 :
9655 : /* Set I/O stride Section */
9656 : /* ---------------------- */
9657 :
9658 : /* In original code stride entered as NULL.
9659 : Abe Taaheri June 12, 1998 */
9660 : /*
9661 : * If stride == NULL (default) set I/O stride to 1
9662 : */
9663 0 : for (j = 0; j < rankSDS; j++)
9664 : {
9665 0 : incr[j] = 1;
9666 : }
9667 :
9668 :
9669 : /* Read into data buffer */
9670 : /* --------------------- */
9671 0 : status = SDreaddata(sdid,
9672 : offset, incr, count,
9673 : (VOIDP) ((uint8 *) buffer + bufOffset));
9674 : }
9675 : }
9676 : }
9677 : }
9678 : }
9679 :
9680 :
9681 : /* If successful return size of returned data in bytes */
9682 : /* --------------------------------------------------- */
9683 0 : if (status == 0)
9684 : {
9685 0 : free(dimlist);
9686 0 : return (size * nPixels);
9687 : }
9688 : else
9689 : {
9690 0 : free(dimlist);
9691 0 : return ((int32) status);
9692 : }
9693 : }
9694 :
9695 :
9696 : /*----------------------------------------------------------------------------|
9697 : | BEGIN_PROLOG |
9698 : | |
9699 : | FUNCTION: GDinterpolate |
9700 : | |
9701 : | DESCRIPTION: Performs bilinear interpolate on a set of xy values |
9702 : | |
9703 : | |
9704 : | Return Value Type Units Description |
9705 : | ============ ====== ========= ===================================== |
9706 : | nRetn*nValues* int32 Size of data buffer |
9707 : | sizeof(float64) |
9708 : | |
9709 : | INPUTS: |
9710 : | gridID int32 Grid structure ID |
9711 : | nValues int32 Number of lon/lat points to interpolate |
9712 : | xyValues float64 XY values of points to interpolate |
9713 : | fieldname char Fieldname |
9714 : | |
9715 : | OUTPUTS: |
9716 : | interpVal float64 Interpolated Data Values |
9717 : | |
9718 : | |
9719 : | NOTES: |
9720 : | |
9721 : | |
9722 : | Date Programmer Description |
9723 : | ====== ============ ================================================= |
9724 : | Aug 96 Joel Gales Original Programmer |
9725 : | Oct 96 Joel Gales Fix array l_index problem with interpVal write |
9726 : | Apr 97 Joel Gales Trap interpolation boundary out of bounds error |
9727 : | Jun 98 Abe Taaheri changed the return value so that the Return Value |
9728 : | is size in bytes for the data buffer which is |
9729 : | float64.
9730 : | |
9731 : | END_PROLOG |
9732 : -----------------------------------------------------------------------------*/
9733 : int32
9734 0 : GDinterpolate(int32 gridID, int32 nValues, float64 lonVal[], float64 latVal[],
9735 : const char *fieldname, float64 interpVal[])
9736 : {
9737 : intn i; /* Loop index */
9738 : intn j; /* Loop index */
9739 : intn k; /* Loop index */
9740 0 : intn status = 0; /* routine return status variable */
9741 :
9742 : int32 fid; /* HDF-EOS file ID */
9743 : int32 sdInterfaceID; /* HDF SDS interface ID */
9744 : int32 gdVgrpID; /* Grid root Vgroup ID */
9745 : int32 xdimsize; /* XDim size */
9746 : int32 ydimsize; /* YDim size */
9747 : int32 projcode; /* Projection code */
9748 : int32 zonecode; /* Zone code */
9749 : int32 spherecode; /* Sphere code */
9750 : int32 pixregcode; /* Pixel registration code */
9751 : int32 origincode; /* Origin code */
9752 : int32 dims[8]; /* Field dimensions */
9753 : int32 numsize; /* Size in bytes of number type */
9754 : int32 rank; /* Field rank */
9755 0 : int32 xdum = 0; /* Location of "XDim" within field list */
9756 0 : int32 ydum = 0; /* Location of "YDim" within field list */
9757 : int32 ntype; /* Number type */
9758 : int32 dum; /* Dummy variable */
9759 : int32 size; /* Size of returned data buffer for each
9760 : * value in bytes */
9761 : int32 pixCol[4]; /* Pixel columns for 4 nearest neighbors */
9762 : int32 pixRow[4]; /* Pixel rows for 4 nearest neighbors */
9763 : int32 tDen; /* Interpolation denominator value 1 */
9764 : int32 uDen; /* Interpolation denominator value 2 */
9765 0 : int32 nRetn = 0; /* Number of data values returned */
9766 :
9767 : float64 upleftpt[2];/* Upper left pt coordinates */
9768 : float64 lowrightpt[2]; /* Lower right pt coordinates */
9769 : float64 projparm[16]; /* Projection parameters */
9770 0 : float64 xVal = 0.0; /* "Exact" x location of interpolated point */
9771 0 : float64 yVal = 0.0; /* "Exact" y location of interpolated point */
9772 0 : float64 tNum = 0.0; /* Interpolation numerator value 1 */
9773 0 : float64 uNum = 0.0; /* Interpolation numerator value 2 */
9774 :
9775 : int16 i16[4]; /* Working buffer (int16) */
9776 : int32 i32[4]; /* Working buffer (int132) */
9777 : float32 f32[4]; /* Working buffer (float32) */
9778 : float64 f64[4]; /* Working buffer (float64) */
9779 :
9780 : char *pixVal; /* Nearest neighbor values */
9781 : char *dimlist; /* Dimension list */
9782 :
9783 : /* Allocate space for dimlist */
9784 : /* --------------------------------- */
9785 0 : dimlist = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
9786 0 : if(dimlist == NULL)
9787 : {
9788 0 : HEpush(DFE_NOSPACE,"GDinterpolate", __FILE__, __LINE__);
9789 0 : return(-1);
9790 : }
9791 : /* Check for valid grid ID */
9792 : /* ----------------------- */
9793 0 : status = GDchkgdid(gridID, "GDinterpolate",
9794 : &fid, &sdInterfaceID, &gdVgrpID);
9795 :
9796 :
9797 : /* If no problems ... */
9798 : /* ------------------ */
9799 0 : if (status == 0)
9800 : {
9801 : /* Get field information */
9802 : /* --------------------- */
9803 0 : status = GDfieldinfo(gridID, fieldname, &rank, dims, &ntype, dimlist);
9804 :
9805 :
9806 : /* Check for "XDim" & "YDim" in dimension list */
9807 : /* ------------------------------------------- */
9808 0 : if (status == 0)
9809 : {
9810 0 : xdum = EHstrwithin("XDim", dimlist, ',');
9811 0 : ydum = EHstrwithin("YDim", dimlist, ',');
9812 :
9813 0 : if (xdum == -1)
9814 : {
9815 0 : status = -1;
9816 0 : HEpush(DFE_GENAPP, "GDinterpolate", __FILE__, __LINE__);
9817 0 : HEreport(
9818 : "\"XDim\" not present in dimlist for field: \"%s\".\n",
9819 : fieldname);
9820 : }
9821 :
9822 :
9823 0 : if (ydum == -1)
9824 : {
9825 0 : status = -1;
9826 0 : HEpush(DFE_GENAPP, "GDinterpolate", __FILE__, __LINE__);
9827 0 : HEreport(
9828 : "\"YDim\" not present in dimlist for field: \"%s\".\n",
9829 : fieldname);
9830 : }
9831 : }
9832 : else
9833 : {
9834 : /* Fieldname not found in grid */
9835 : /* --------------------------- */
9836 0 : status = -1;
9837 0 : HEpush(DFE_GENAPP, "GDinterpolate", __FILE__, __LINE__);
9838 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
9839 : }
9840 :
9841 :
9842 : /* If no problems ... */
9843 : /* ------------------ */
9844 0 : if (status == 0)
9845 : {
9846 : /* Compute size of data buffer for each interpolated value */
9847 : /* ------------------------------------------------------- */
9848 0 : dims[xdum] = 1;
9849 0 : dims[ydum] = 1;
9850 0 : size = dims[0];
9851 0 : for (i = 1; i < rank; i++)
9852 : {
9853 0 : size *= dims[i];
9854 : }
9855 0 : numsize = DFKNTsize(ntype);
9856 0 : size *= numsize;
9857 :
9858 0 : nRetn = size / numsize;
9859 :
9860 :
9861 :
9862 : /* If interpolated values are requested ... */
9863 : /* ---------------------------------------- */
9864 0 : if (interpVal != NULL)
9865 : {
9866 : /* Get grid info */
9867 : /* ------------- */
9868 0 : status = GDgridinfo(gridID, &xdimsize, &ydimsize,
9869 : upleftpt, lowrightpt);
9870 :
9871 :
9872 : /* Get projection info */
9873 : /* ------------------- */
9874 0 : status = GDprojinfo(gridID, &projcode, &zonecode,
9875 : &spherecode, projparm);
9876 :
9877 :
9878 : /* Get explicit upleftpt & lowrightpt if defaults are used */
9879 : /* ------------------------------------------------------- */
9880 0 : status = GDgetdefaults(projcode, zonecode, projparm,
9881 : spherecode, upleftpt, lowrightpt);
9882 :
9883 :
9884 : /* Get pixel registration and origin info */
9885 : /* -------------------------------------- */
9886 0 : status = GDpixreginfo(gridID, &pixregcode);
9887 0 : status = GDorigininfo(gridID, &origincode);
9888 :
9889 :
9890 :
9891 : /* Loop through all interpolated points */
9892 : /* ------------------------------------ */
9893 0 : for (i = 0; i < nValues; i++)
9894 : {
9895 : /* Get row & column of point pixel */
9896 : /* ------------------------------- */
9897 0 : status = GDll2ij(projcode, zonecode, projparm, spherecode,
9898 : xdimsize, ydimsize, upleftpt, lowrightpt,
9899 0 : 1, &lonVal[i], &latVal[i],
9900 : pixRow, pixCol, &xVal, &yVal);
9901 :
9902 :
9903 : /* Get diff of interp. point from pixel location */
9904 : /* --------------------------------------------- */
9905 0 : if (pixregcode == HDFE_CENTER)
9906 : {
9907 0 : tNum = xVal - (pixCol[0] + 0.5);
9908 0 : uNum = yVal - (pixRow[0] + 0.5);
9909 : }
9910 0 : else if (origincode == HDFE_GD_UL)
9911 : {
9912 0 : tNum = xVal - pixCol[0];
9913 0 : uNum = yVal - pixRow[0];
9914 : }
9915 0 : else if (origincode == HDFE_GD_UR)
9916 : {
9917 0 : tNum = xVal - (pixCol[0] + 1);
9918 0 : uNum = yVal - pixRow[0];
9919 : }
9920 0 : else if (origincode == HDFE_GD_LL)
9921 : {
9922 0 : tNum = xVal - pixCol[0];
9923 0 : uNum = yVal - (pixRow[0] + 1);
9924 : }
9925 0 : else if (origincode == HDFE_GD_LR)
9926 : {
9927 0 : tNum = xVal - (pixCol[0] + 1);
9928 0 : uNum = yVal - (pixRow[0] + 1);
9929 : }
9930 :
9931 :
9932 : /* Get rows and columns of other nearest neighbor pixels */
9933 : /* ----------------------------------------------------- */
9934 0 : pixCol[1] = pixCol[0];
9935 0 : pixRow[3] = pixRow[0];
9936 :
9937 0 : if (tNum >= 0)
9938 : {
9939 0 : pixCol[2] = pixCol[0] + 1;
9940 0 : pixCol[3] = pixCol[0] + 1;
9941 : }
9942 :
9943 0 : if (tNum < 0)
9944 : {
9945 0 : pixCol[2] = pixCol[0] - 1;
9946 0 : pixCol[3] = pixCol[0] - 1;
9947 : }
9948 :
9949 0 : if (uNum >= 0)
9950 : {
9951 0 : pixRow[2] = pixRow[0] + 1;
9952 0 : pixRow[1] = pixRow[0] + 1;
9953 : }
9954 :
9955 0 : if (uNum < 0)
9956 : {
9957 0 : pixRow[2] = pixRow[0] - 1;
9958 0 : pixRow[1] = pixRow[0] - 1;
9959 : }
9960 :
9961 :
9962 : /* Get values of nearest neighbors */
9963 : /* -------------------------------- */
9964 0 : pixVal = (char *) malloc(4 * size);
9965 0 : if(pixVal == NULL)
9966 : {
9967 0 : HEpush(DFE_NOSPACE,"GDinterpolate", __FILE__, __LINE__);
9968 0 : free(dimlist);
9969 0 : return(-1);
9970 : }
9971 0 : dum = GDgetpixvalues(gridID, 4, pixRow, pixCol,
9972 : fieldname, pixVal);
9973 :
9974 :
9975 : /* Trap interpolation boundary out of range error */
9976 : /* ---------------------------------------------- */
9977 0 : if (dum == -1)
9978 : {
9979 0 : status = -1;
9980 0 : HEpush(DFE_GENAPP, "GDinterpolate", __FILE__, __LINE__);
9981 0 : HEreport("Interpolation boundary outside of grid.\n");
9982 : }
9983 : else
9984 : {
9985 :
9986 : /*
9987 : * Algorithm taken for Numerical Recipes in C, 2nd
9988 : * edition, Section 3.6
9989 : */
9990 :
9991 : /* Perform bilinear interpolation */
9992 : /* ------------------------------ */
9993 0 : tDen = pixCol[3] - pixCol[0];
9994 0 : uDen = pixRow[1] - pixRow[0];
9995 :
9996 0 : switch (ntype)
9997 : {
9998 0 : case DFNT_INT16:
9999 :
10000 :
10001 : /* Loop through all returned data values */
10002 : /* ------------------------------------- */
10003 0 : for (j = 0; j < nRetn; j++)
10004 : {
10005 : /* Copy 4 NN values into working array */
10006 : /* ----------------------------------- */
10007 0 : for (k = 0; k < 4; k++)
10008 : {
10009 0 : memcpy(&i16[k],
10010 0 : pixVal + j * numsize + k * size,
10011 : sizeof(int16));
10012 : }
10013 :
10014 : /* Compute interpolated value */
10015 : /* -------------------------- */
10016 0 : interpVal[i * nRetn + j] =
10017 0 : (1 - tNum / tDen) * (1 - uNum / uDen) *
10018 0 : i16[0] +
10019 0 : (tNum / tDen) * (1 - uNum / uDen) *
10020 0 : i16[3] +
10021 0 : (tNum / tDen) * (uNum / uDen) *
10022 0 : i16[2] +
10023 0 : (1 - tNum / tDen) * (uNum / uDen) *
10024 0 : i16[1];
10025 : }
10026 0 : break;
10027 :
10028 :
10029 0 : case DFNT_INT32:
10030 :
10031 0 : for (j = 0; j < nRetn; j++)
10032 : {
10033 0 : for (k = 0; k < 4; k++)
10034 : {
10035 0 : memcpy(&i32[k],
10036 0 : pixVal + j * numsize + k * size,
10037 : sizeof(int32));
10038 : }
10039 :
10040 0 : interpVal[i * nRetn + j] =
10041 0 : (1 - tNum / tDen) * (1 - uNum / uDen) *
10042 0 : i32[0] +
10043 0 : (tNum / tDen) * (1 - uNum / uDen) *
10044 0 : i32[3] +
10045 0 : (tNum / tDen) * (uNum / uDen) *
10046 0 : i32[2] +
10047 0 : (1 - tNum / tDen) * (uNum / uDen) *
10048 0 : i32[1];
10049 : }
10050 0 : break;
10051 :
10052 :
10053 0 : case DFNT_FLOAT32:
10054 :
10055 0 : for (j = 0; j < nRetn; j++)
10056 : {
10057 0 : for (k = 0; k < 4; k++)
10058 : {
10059 0 : memcpy(&f32[k],
10060 0 : pixVal + j * numsize + k * size,
10061 : sizeof(float32));
10062 : }
10063 :
10064 0 : interpVal[i * nRetn + j] =
10065 0 : (1 - tNum / tDen) * (1 - uNum / uDen) *
10066 0 : f32[0] +
10067 0 : (tNum / tDen) * (1 - uNum / uDen) *
10068 0 : f32[3] +
10069 0 : (tNum / tDen) * (uNum / uDen) *
10070 0 : f32[2] +
10071 0 : (1 - tNum / tDen) * (uNum / uDen) *
10072 0 : f32[1];
10073 : }
10074 0 : break;
10075 :
10076 :
10077 0 : case DFNT_FLOAT64:
10078 :
10079 0 : for (j = 0; j < nRetn; j++)
10080 : {
10081 0 : for (k = 0; k < 4; k++)
10082 : {
10083 0 : memcpy(&f64[k],
10084 0 : pixVal + j * numsize + k * size,
10085 : sizeof(float64));
10086 : }
10087 :
10088 0 : interpVal[i * nRetn + j] =
10089 0 : (1 - tNum / tDen) * (1 - uNum / uDen) *
10090 0 : f64[0] +
10091 0 : (tNum / tDen) * (1 - uNum / uDen) *
10092 0 : f64[3] +
10093 0 : (tNum / tDen) * (uNum / uDen) *
10094 0 : f64[2] +
10095 0 : (1 - tNum / tDen) * (uNum / uDen) *
10096 0 : f64[1];
10097 : }
10098 0 : break;
10099 : }
10100 0 : }
10101 0 : free(pixVal);
10102 : }
10103 : }
10104 : }
10105 : }
10106 :
10107 :
10108 : /* If successful return size of returned data in bytes */
10109 : /* --------------------------------------------------- */
10110 0 : if (status == 0)
10111 : {
10112 : /*always return size of float64 buffer */
10113 0 : free(dimlist);
10114 0 : return (nRetn * nValues * sizeof(float64));
10115 : }
10116 : else
10117 : {
10118 0 : free(dimlist);
10119 0 : return ((int32) status);
10120 : }
10121 :
10122 : }
10123 : /***********************************************
10124 : GDwrrdtile --
10125 : This function is the underlying function below GDwritetile and
10126 : GDreadtile.
10127 :
10128 :
10129 : Author--
10130 : Alexis Zubrow
10131 :
10132 : ********************************************************/
10133 :
10134 : static intn
10135 0 : GDwrrdtile(int32 gridID, const char *fieldname, const char *code, int32 start[],
10136 : VOIDP datbuf)
10137 : {
10138 : intn i; /* Loop index */
10139 0 : intn status = 0; /* routine return status variable */
10140 :
10141 : int32 fid; /* HDF-EOS file ID */
10142 : int32 sdInterfaceID; /* HDF SDS interface ID */
10143 : int32 sdid; /* SDS ID */
10144 :
10145 : int32 dum; /* Dummy variable */
10146 : int32 rankSDS; /* Rank of SDS/Field */
10147 :
10148 : int32 dims[8]; /* Field/SDS dimensions */
10149 : int32 tileFlags; /* flag to determine if field is tiled */
10150 : int32 numTileDims;/* number of tiles spanning a dimension */
10151 : HDF_CHUNK_DEF tileDef; /* union holding tiling info. */
10152 :
10153 :
10154 : /* Get gridID */
10155 0 : status = GDchkgdid(gridID, "GDwrrdtile", &fid, &sdInterfaceID, &dum);
10156 0 : if (status == 0)
10157 : {
10158 :
10159 : /* Get field info */
10160 0 : status = GDfieldinfo(gridID, fieldname, &rankSDS, dims, &dum, NULL);
10161 :
10162 0 : if (status == 0)
10163 : {
10164 :
10165 : /* Check whether fieldname is in SDS (multi-dim field) */
10166 : /* --------------------------------------------------- */
10167 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
10168 : &rankSDS, &dum, &dum, dims, &dum);
10169 :
10170 :
10171 :
10172 : /*
10173 : * Check for errors in parameters passed to GDwritetile or
10174 : * GDreadtile
10175 : */
10176 :
10177 : /* Check if untiled field */
10178 0 : status = SDgetchunkinfo(sdid, &tileDef, &tileFlags);
10179 0 : if (tileFlags == HDF_NONE)
10180 : {
10181 0 : HEpush(DFE_GENAPP, "GDwrrdtile", __FILE__, __LINE__);
10182 0 : HEreport("Field \"%s\" is not tiled.\n", fieldname);
10183 0 : status = -1;
10184 0 : return (status);
10185 :
10186 : }
10187 :
10188 : /*
10189 : * Check if rd/wr tilecoords are within the extent of the field
10190 : */
10191 0 : for (i = 0; i < rankSDS; i++)
10192 : {
10193 : /*
10194 : * Calculate the number of tiles which span a dimension of
10195 : * the field
10196 : */
10197 0 : numTileDims = dims[i] / tileDef.chunk_lengths[i];
10198 0 : if ((start[i] >= numTileDims) || (start[i] < 0))
10199 : {
10200 : /*
10201 : * ERROR INDICATING BEYOND EXTENT OF THAT DIMENSION OR
10202 : * NEGATIVE TILECOORDS
10203 : */
10204 0 : HEpush(DFE_GENAPP, "GDwrrdtile", __FILE__, __LINE__);
10205 0 : HEreport("Tilecoords for dimension \"%d\" ...\n", i);
10206 0 : HEreport("is beyond the extent of dimension length\n");
10207 0 : status = -1;
10208 :
10209 : }
10210 : }
10211 :
10212 0 : if (status == -1)
10213 : {
10214 0 : return (status);
10215 : }
10216 :
10217 :
10218 : /* Actually write/read to the field */
10219 :
10220 0 : if (strcmp(code, "w") == 0) /* write tile */
10221 : {
10222 0 : status = SDwritechunk(sdid, start, (VOIDP) datbuf);
10223 : }
10224 0 : else if (strcmp(code, "r") == 0) /* read tile */
10225 : {
10226 0 : status = SDreadchunk(sdid, start, (VOIDP) datbuf);
10227 : }
10228 :
10229 :
10230 : }
10231 :
10232 : /* Non-existent fieldname */
10233 : else
10234 : {
10235 0 : HEpush(DFE_GENAPP, "GDwrrdtile", __FILE__, __LINE__);
10236 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
10237 0 : status = -1;
10238 : }
10239 :
10240 : }
10241 :
10242 0 : return (status);
10243 : }
10244 :
10245 :
10246 : /***********************************************
10247 : GDtileinfo --
10248 : This function queries the field to determine if it is tiled. If it is
10249 : tile, one can retrieve some of the characteristics of the tiles.
10250 :
10251 : Author-- Alexis Zubrow
10252 :
10253 : ********************************************************/
10254 :
10255 :
10256 : intn
10257 0 : GDtileinfo(int32 gridID, const char *fieldname, int32 * tilecode, int32 * tilerank,
10258 : int32 tiledims[])
10259 :
10260 : {
10261 : intn i; /* Loop index */
10262 0 : intn status = 0; /* routine return status variable */
10263 :
10264 : int32 fid; /* HDF-EOS file ID */
10265 : int32 sdInterfaceID; /* HDF SDS interface ID */
10266 : int32 sdid; /* SDS ID */
10267 :
10268 : int32 dum; /* Dummy variable */
10269 : int32 rankSDS; /* Rank of SDS/Field/tile */
10270 :
10271 : int32 dims[8]; /* Field/SDS dimensions */
10272 : int32 tileFlags; /* flag to determine if field is tiled */
10273 : HDF_CHUNK_DEF tileDef; /* union holding tiling info. */
10274 :
10275 :
10276 : /* Check if improper gridID */
10277 0 : status = GDchkgdid(gridID, "GDtileinfo", &fid, &sdInterfaceID, &dum);
10278 0 : if (status == 0)
10279 : {
10280 :
10281 : /* Get field info */
10282 0 : status = GDfieldinfo(gridID, fieldname, &rankSDS, dims, &dum, NULL);
10283 :
10284 0 : if (status == 0)
10285 : {
10286 :
10287 : /* Check whether fieldname is in SDS (multi-dim field) */
10288 : /* --------------------------------------------------- */
10289 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
10290 : &rankSDS, &dum, &dum, dims, &dum);
10291 :
10292 :
10293 :
10294 : /* Query field for tiling information */
10295 0 : status = SDgetchunkinfo(sdid, &tileDef, &tileFlags);
10296 :
10297 : /* If field is untiled, return untiled flag */
10298 0 : if (tileFlags == HDF_NONE)
10299 : {
10300 0 : *tilecode = HDFE_NOTILE;
10301 0 : return (status);
10302 : }
10303 :
10304 : /* IF field is tiled or tiled with compression */
10305 0 : else if ((tileFlags == HDF_CHUNK) ||
10306 0 : (tileFlags == (HDF_CHUNK | HDF_COMP)))
10307 : {
10308 0 : if (tilecode != NULL)
10309 : {
10310 0 : *tilecode = HDFE_TILE;
10311 : }
10312 0 : if (tilerank != NULL)
10313 : {
10314 0 : *tilerank = rankSDS;
10315 : }
10316 0 : if (tiledims != NULL)
10317 : {
10318 : /* Assign size of tile dimensions */
10319 0 : for (i = 0; i < rankSDS; i++)
10320 : {
10321 0 : tiledims[i] = tileDef.chunk_lengths[i];
10322 : }
10323 : }
10324 : }
10325 : }
10326 :
10327 : /* Non-existent fieldname */
10328 : else
10329 : {
10330 0 : HEpush(DFE_GENAPP, "GDtileinfo", __FILE__, __LINE__);
10331 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
10332 0 : status = -1;
10333 : }
10334 :
10335 : }
10336 0 : return (status);
10337 : }
10338 : /***********************************************
10339 : GDwritetile --
10340 : This function writes one tile to a particular field.
10341 :
10342 :
10343 : Author--
10344 : Alexis Zubrow
10345 :
10346 : ********************************************************/
10347 :
10348 : intn
10349 0 : GDwritetile(int32 gridID, const char *fieldname, int32 tilecoords[],
10350 : VOIDP tileData)
10351 : {
10352 0 : char code[] = "w"; /* write tile code */
10353 0 : intn status = 0; /* routine return status variable */
10354 :
10355 0 : status = GDwrrdtile(gridID, fieldname, code, tilecoords, tileData);
10356 :
10357 0 : return (status);
10358 : }
10359 : /***********************************************
10360 : GDreadtile --
10361 : This function reads one tile from a particular field.
10362 :
10363 :
10364 : Author--
10365 : Alexis Zubrow
10366 :
10367 : ********************************************************/
10368 :
10369 : intn
10370 0 : GDreadtile(int32 gridID, const char *fieldname, int32 tilecoords[],
10371 : VOIDP tileData)
10372 : {
10373 0 : char code[] = "r"; /* read tile code */
10374 0 : intn status = 0; /* routine return status variable */
10375 :
10376 0 : status = GDwrrdtile(gridID, fieldname, code, tilecoords, tileData);
10377 :
10378 0 : return (status);
10379 : }
10380 : /***********************************************
10381 : GDsettilecache --
10382 : This function sets the cache size for a tiled field.
10383 :
10384 :
10385 : Author--
10386 : Alexis Zubrow
10387 :
10388 : ********************************************************/
10389 :
10390 : intn
10391 0 : GDsettilecache(int32 gridID, const char *fieldname, int32 maxcache, CPL_UNUSED int32 cachecode)
10392 : {
10393 :
10394 0 : intn status = 0; /* routine return status variable */
10395 :
10396 : int32 fid; /* HDF-EOS file ID */
10397 : int32 sdInterfaceID; /* HDF SDS interface ID */
10398 : int32 sdid; /* SDS ID */
10399 :
10400 : int32 dum; /* Dummy variable */
10401 :
10402 : int32 dims[8]; /* Field/SDS dimensions */
10403 :
10404 :
10405 : /* Check gridID */
10406 0 : status = GDchkgdid(gridID, "GDwrrdtile", &fid, &sdInterfaceID, &dum);
10407 0 : if (status == 0)
10408 : {
10409 :
10410 : /* Get field info */
10411 0 : status = GDfieldinfo(gridID, fieldname, &dum, dims, &dum, NULL);
10412 :
10413 0 : if (status == 0)
10414 : {
10415 :
10416 : /* Check whether fieldname is in SDS (multi-dim field) */
10417 : /* --------------------------------------------------- */
10418 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
10419 : &dum, &dum, &dum, dims, &dum);
10420 :
10421 :
10422 : /* Check if maxcache is less than or equal to zero */
10423 0 : if (maxcache <= 0)
10424 : {
10425 0 : HEpush(DFE_GENAPP, "GDsettilecache", __FILE__, __LINE__);
10426 0 : HEreport("Improper maxcache \"%d\"... \n", maxcache);
10427 0 : HEreport("maxcache must be greater than zero.\n");
10428 0 : status = -1;
10429 0 : return (status);
10430 : }
10431 :
10432 :
10433 : /* Set the number of tiles to cache */
10434 : /* Presently, the only cache flag allowed is 0 */
10435 0 : status = SDsetchunkcache(sdid, maxcache, 0);
10436 :
10437 :
10438 : }
10439 :
10440 : /* Non-existent fieldname */
10441 : else
10442 : {
10443 0 : HEpush(DFE_GENAPP, "GDwrrdtile", __FILE__, __LINE__);
10444 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
10445 0 : status = -1;
10446 : }
10447 :
10448 : }
10449 :
10450 0 : return (status);
10451 : }
10452 :
10453 : /*----------------------------------------------------------------------------|
10454 : | BEGIN_PROLOG |
10455 : | |
10456 : | FUNCTION: GDsettilecomp |
10457 : | |
10458 : | DESCRIPTION: Sets the tiling/compression parameters for the specified |
10459 : | field. This can be called after GDsetfillvalue and assumes |
10460 : | that the field was defined with no compression/tiling set |
10461 : | by GDdeftile or GDdefcomp. |
10462 : | |
10463 : | This function replaces the following sequence: |
10464 : | GDdefcomp |
10465 : | GDdeftile |
10466 : | GDdeffield |
10467 : | GDsetfillvalue |
10468 : | with: |
10469 : | GDdeffield |
10470 : | GDsetfillvalue |
10471 : | GDsettilecomp |
10472 : | so that fill values will work correctly. |
10473 : | |
10474 : | Return Value Type Units Description |
10475 : | ============ ====== ========= ===================================== |
10476 : | status intn return status (0) SUCCEED, (-1) FAIL |
10477 : | |
10478 : | INPUTS: |
10479 : | gridID int32 grid structure ID |
10480 : | fieldname char field name |
10481 : | tilerank int32 number of tiling dimensions |
10482 : | tiledims int32 tiling dimensions |
10483 : | compcode int32 compression code |
10484 : | compparm intn compression parameters |
10485 : | |
10486 : | OUTPUTS: |
10487 : | None |
10488 : | |
10489 : | NOTES: |
10490 : | |
10491 : | |
10492 : | Date Programmer Description |
10493 : | ====== ============ ================================================= |
10494 : | Jun 98 MISR Used GDsetfillvalue as a template and copied |
10495 : | tiling/comp portions of GDdeffield.(NCR15866). |
10496 : | |
10497 : | END_PROLOG |
10498 : -----------------------------------------------------------------------------*/
10499 : intn
10500 0 : GDsettilecomp(int32 gridID, const char *fieldname, int32 tilerank, int32*
10501 : tiledims, int32 compcode, intn* compparm)
10502 : {
10503 : intn status; /* routine return status variable */
10504 :
10505 : int32 fid; /* HDF-EOS file ID */
10506 : int32 sdInterfaceID; /* HDF SDS interface ID */
10507 : int32 gdVgrpID; /* Grid root Vgroup ID */
10508 : int i; /* Looping variable. */
10509 : int32 sdid; /* SDS id */
10510 : int32 nt; /* Number type */
10511 : int32 dims[8]; /* Dimensions array */
10512 : int32 dum; /* Dummy variable */
10513 : int32 solo; /* "Solo" (non-merged) field flag */
10514 : comp_info c_info; /* Compression parameter structure */
10515 : HDF_CHUNK_DEF chunkDef; /* Tiling structure */
10516 : int32 chunkFlag; /* Chunking (Tiling) flag */
10517 :
10518 0 : c_info.nbit.nt = 0;
10519 :
10520 : /* Check for valid grid ID and get SDS interface ID */
10521 0 : status = GDchkgdid(gridID, "GDsetfillvalue",
10522 : &fid, &sdInterfaceID, &gdVgrpID);
10523 :
10524 0 : if (status == 0)
10525 : {
10526 : /* Get field info */
10527 0 : status = GDfieldinfo(gridID, fieldname, &dum, dims, &nt, NULL);
10528 :
10529 0 : if (status == 0)
10530 : {
10531 : /* Get SDS ID and solo flag */
10532 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname,
10533 : &sdid, &dum, &dum, &dum,
10534 : dims, &solo);
10535 0 : if (status !=0) {
10536 0 : HEpush(DFE_GENAPP, "GDsettilecomp", __FILE__, __LINE__);
10537 0 : HEreport("GDSDfldsrch failed\n", fieldname);
10538 0 : return FAIL;
10539 : }
10540 : /* Tiling with Compression */
10541 : /* ----------------------- */
10542 :
10543 :
10544 : /* Setup Compression */
10545 : /* ----------------- */
10546 0 : if (compcode == HDFE_COMP_NBIT)
10547 : {
10548 0 : c_info.nbit.nt = nt;
10549 0 : c_info.nbit.sign_ext = compparm[0];
10550 0 : c_info.nbit.fill_one = compparm[1];
10551 0 : c_info.nbit.start_bit = compparm[2];
10552 0 : c_info.nbit.bit_len = compparm[3];
10553 : }
10554 0 : else if (compcode == HDFE_COMP_SKPHUFF)
10555 : {
10556 0 : c_info.skphuff.skp_size = (intn) DFKNTsize(nt);
10557 : }
10558 0 : else if (compcode == HDFE_COMP_DEFLATE)
10559 : {
10560 0 : c_info.deflate.level = compparm[0];
10561 : }
10562 :
10563 : /* Setup chunk lengths */
10564 : /* ------------------- */
10565 0 : for (i = 0; i < tilerank; i++)
10566 : {
10567 0 : chunkDef.comp.chunk_lengths[i] = tiledims[i];
10568 : }
10569 :
10570 : /* Setup chunk flag & chunk compression type */
10571 : /* ----------------------------------------- */
10572 0 : chunkFlag = HDF_CHUNK | HDF_COMP;
10573 0 : chunkDef.comp.comp_type = compcode;
10574 :
10575 : /* Setup chunk compression parameters */
10576 : /* ---------------------------------- */
10577 0 : if (compcode == HDFE_COMP_SKPHUFF)
10578 : {
10579 0 : chunkDef.comp.cinfo.skphuff.skp_size =
10580 0 : c_info.skphuff.skp_size;
10581 : }
10582 0 : else if (compcode == HDFE_COMP_DEFLATE)
10583 : {
10584 0 : chunkDef.comp.cinfo.deflate.level =
10585 0 : c_info.deflate.level;
10586 : }
10587 : /* Call SDsetchunk routine */
10588 : /* ----------------------- */
10589 0 : status = SDsetchunk(sdid, chunkDef, chunkFlag);
10590 0 : if (status ==FAIL) {
10591 0 : HEpush(DFE_GENAPP, "GDsettilecomp", __FILE__, __LINE__);
10592 0 : HEreport("Fieldname \"%s\" does not exist.\n",
10593 : fieldname);
10594 0 : return status;
10595 : }
10596 : }
10597 : else
10598 : {
10599 0 : HEpush(DFE_GENAPP, "GDsettilecomp", __FILE__, __LINE__);
10600 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
10601 : }
10602 : }
10603 0 : return (status);
10604 : }
10605 :
10606 : /*----------------------------------------------------------------------------|
10607 : | BEGIN_PROLOG |
10608 : | |
10609 : | FUNCTION: GDll2mm_cea |
10610 : | |
10611 : | DESCRIPTION: |
10612 : | |
10613 : | |
10614 : | Return Value Type Units Description |
10615 : | ============ ====== ========= ===================================== |
10616 : | status intn return status (0) SUCCEED, (-1) FAIL |
10617 : | |
10618 : | INPUTS: |
10619 : | projcode int32 GCTP projection code |
10620 : | zonecode int32 UTM zone code |
10621 : | projparm float64 Projection parameters |
10622 : | spherecode int32 GCTP spheriod code |
10623 : | xdimsize int32 xdimsize from GDcreate |
10624 : | ydimsize int32 ydimsize from GDcreate |
10625 : | upleftpt float64 upper left corner coordinates (DMS) |
10626 : | lowrightpt float64 lower right corner coordinates (DMS) |
10627 : | longitude float64 longitude array (DMS) |
10628 : | latitude float64 latitude array (DMS) |
10629 : | npnts int32 number of lon-lat points |
10630 : | |
10631 : | OUTPUTS: |
10632 : | x float64 X value array |
10633 : | y float64 Y value array |
10634 : | scaleX float64 X grid size |
10635 : | scaley float64 Y grid size |
10636 : | |
10637 : | NOTES: |
10638 : | |
10639 : | |
10640 : | Date Programmer Description |
10641 : | ====== ============ ================================================= |
10642 : | Oct 02 Abe Taaheri Added support for EASE grid |
10643 : | |
10644 : | END_PROLOG |
10645 : -----------------------------------------------------------------------------*/
10646 0 : static intn GDll2mm_cea(int32 projcode,int32 zonecode, int32 spherecode,
10647 : float64 projparm[],
10648 : int32 xdimsize, int32 ydimsize,
10649 : float64 upleftpt[], float64 lowrightpt[], int32 npnts,
10650 : CPL_UNUSED float64 lon[],CPL_UNUSED float64 lat[],
10651 : float64 x[],float64 y[], float64 *scaleX,float64 *scaleY)
10652 : {
10653 0 : intn status = 0; /* routine return status variable */
10654 0 : int32 errorcode = 0; /* GCTP error code */
10655 : float64 xMtr0, xMtr1, yMtr0, yMtr1;
10656 : float64 lonrad0; /* Longitude in radians of upleft point */
10657 : float64 latrad0; /* Latitude in radians of upleft point */
10658 : float64 lonrad; /* Longitude in radians of point */
10659 : float64 latrad; /* Latitude in radians of point */
10660 : int32(*for_trans[100]) (double, double, double*, double*); /* GCTP function pointer */
10661 :
10662 0 : if(npnts <= 0)
10663 : {
10664 0 : HEpush(DFE_GENAPP, " GDll2mm_cea", __FILE__, __LINE__);
10665 0 : HEreport("Improper npnts value\"%d\"... \n", npnts);
10666 0 : HEreport("npnts must be greater than zero.\n");
10667 0 : status = -1;
10668 0 : return (status);
10669 : }
10670 0 : if ( projcode == GCTP_BCEA)
10671 : {
10672 0 : for_init(projcode, zonecode, projparm, spherecode, NULL, NULL,
10673 : &errorcode, for_trans);
10674 : /* Convert upleft and lowright X coords from DMS to radians */
10675 : /* -------------------------------------------------------- */
10676 :
10677 0 : lonrad0 = EHconvAng(upleftpt[0], HDFE_DMS_RAD);
10678 0 : lonrad = EHconvAng(lowrightpt[0], HDFE_DMS_RAD);
10679 :
10680 : /* Convert upleft and lowright Y coords from DMS to radians */
10681 : /* -------------------------------------------------------- */
10682 0 : latrad0 = EHconvAng(upleftpt[1], HDFE_DMS_RAD);
10683 0 : latrad = EHconvAng(lowrightpt[1], HDFE_DMS_RAD);
10684 :
10685 : /* Convert from lon/lat to meters(or whatever unit is, i.e unit
10686 : of r_major and r_minor) using GCTP */
10687 : /* ----------------------------------------- */
10688 0 : errorcode = for_trans[projcode] (lonrad0, latrad0, &xMtr0, &yMtr0);
10689 0 : x[0] = xMtr0;
10690 0 : y[0] = yMtr0;
10691 :
10692 : /* Report error if any */
10693 : /* ------------------- */
10694 0 : if (errorcode != 0)
10695 : {
10696 0 : status = -1;
10697 0 : HEpush(DFE_GENAPP, "GDll2mm_cea", __FILE__, __LINE__);
10698 0 : HEreport("GCTP Error: %d\n", errorcode);
10699 0 : return (status);
10700 : }
10701 :
10702 : /* Convert from lon/lat to meters(or whatever unit is, i.e unit
10703 : of r_major and r_minor) using GCTP */
10704 : /* ----------------------------------------- */
10705 0 : errorcode = for_trans[projcode] (lonrad, latrad, &xMtr1, &yMtr1);
10706 0 : x[1] = xMtr1;
10707 0 : y[1] = yMtr1;
10708 :
10709 : /* Report error if any */
10710 : /* ------------------- */
10711 0 : if (errorcode != 0)
10712 : {
10713 0 : status = -1;
10714 0 : HEpush(DFE_GENAPP, "GDll2mm_cea", __FILE__, __LINE__);
10715 0 : HEreport("GCTP Error: %d\n", errorcode);
10716 0 : return (status);
10717 : }
10718 :
10719 : /* Compute x scale factor */
10720 : /* ---------------------- */
10721 0 : *scaleX = (xMtr1 - xMtr0) / xdimsize;
10722 :
10723 : /* Compute y scale factor */
10724 : /* ---------------------- */
10725 0 : *scaleY = (yMtr1 - yMtr0) / ydimsize;
10726 : }
10727 : else
10728 : {
10729 0 : status = -1;
10730 0 : HEpush(DFE_GENAPP, "GDll2mm_cea", __FILE__, __LINE__);
10731 0 : HEreport("Wrong projection code; this function is only for EASE grid");
10732 0 : return (status);
10733 : }
10734 0 : return (0);
10735 : }
10736 :
10737 :
10738 : /*----------------------------------------------------------------------------|
10739 : | BEGIN_PROLOG |
10740 : | |
10741 : | FUNCTION: GDmm2ll_cea |
10742 : | |
10743 : | DESCRIPTION: |
10744 : | |
10745 : | |
10746 : | Return Value Type Units Description |
10747 : | ============ ====== ========= ===================================== |
10748 : | status intn return status (0) SUCCEED, (-1) FAIL |
10749 : | |
10750 : | INPUTS: |
10751 : | projcode int32 GCTP projection code |
10752 : | zonecode int32 UTM zone code |
10753 : | projparm float64 Projection parameters |
10754 : | spherecode int32 GCTP spheriod code |
10755 : | xdimsize int32 xdimsize from GDcreate |
10756 : | ydimsize int32 ydimsize from GDcreate |
10757 : | upleftpt float64 upper left corner coordinates (DMS) |
10758 : | lowrightpt float64 lower right corner coordinates (DMS) |
10759 : | x float64 X value array |
10760 : | y float64 Y value array |
10761 : | npnts int32 number of x-y points |
10762 : | |
10763 : | OUTPUTS: |
10764 : | longitude float64 longitude array (DMS) |
10765 : | latitude float64 latitude array (DMS) |
10766 : | |
10767 : | NOTES: |
10768 : | |
10769 : | |
10770 : | Date Programmer Description |
10771 : | ====== ============ ================================================= |
10772 : | Oct 02 Abe Taaheri Added support for EASE grid |
10773 : | |
10774 : | END_PROLOG |
10775 : -----------------------------------------------------------------------------*/
10776 0 : static intn GDmm2ll_cea(int32 projcode,int32 zonecode, int32 spherecode,
10777 : float64 projparm[],
10778 : CPL_UNUSED int32 xdimsize, CPL_UNUSED int32 ydimsize,
10779 : CPL_UNUSED float64 upleftpt[], CPL_UNUSED float64 lowrightpt[], int32 npnts,
10780 : float64 x[], float64 y[],
10781 : float64 longitude[], float64 latitude[])
10782 : {
10783 0 : intn status = 0; /* routine return status variable */
10784 0 : int32 errorcode = 0; /* GCTP error code */
10785 : int32(*inv_trans[100]) (double, double, double*, double*); /* GCTP function pointer */
10786 : int32 i;
10787 :
10788 0 : if(npnts <= 0)
10789 : {
10790 0 : HEpush(DFE_GENAPP, " GDmm2ll_cea", __FILE__, __LINE__);
10791 0 : HEreport("Improper npnts value\"%d\"... \n", npnts);
10792 0 : HEreport("npnts must be greater than zero.\n");
10793 0 : status = -1;
10794 0 : return (status);
10795 : }
10796 0 : if ( projcode == GCTP_BCEA)
10797 : {
10798 0 : inv_init(projcode, zonecode, projparm, spherecode, NULL, NULL,
10799 : &errorcode, inv_trans);
10800 :
10801 : /* Convert from meters(or whatever unit is, i.e unit
10802 : of r_major and r_minor) to lat/lon using GCTP */
10803 : /* ----------------------------------------- */
10804 0 : for(i=0; i<npnts; i++)
10805 : {
10806 0 : errorcode =
10807 0 : inv_trans[projcode] (x[i], y[i],&longitude[i], &latitude[i]);
10808 : /* Report error if any */
10809 : /* ------------------- */
10810 0 : if (errorcode != 0)
10811 : {
10812 0 : status = -1;
10813 0 : HEpush(DFE_GENAPP, "GDmm2ll_cea", __FILE__, __LINE__);
10814 0 : HEreport("GCTP Error: %d\n", errorcode);
10815 0 : return (status);
10816 : }
10817 0 : longitude[i] = EHconvAng(longitude[i], HDFE_RAD_DMS);
10818 0 : latitude[i] = EHconvAng(latitude[i], HDFE_RAD_DMS);
10819 : }
10820 : }
10821 : else
10822 : {
10823 : /* Wrong projection code; this function is only for EASE grid */
10824 : }
10825 0 : return(status);
10826 : }
10827 :
10828 : /*----------------------------------------------------------------------------|
10829 : | BEGIN_PROLOG |
10830 : | |
10831 : | FUNCTION: GDsdid |
10832 : | |
10833 : | DESCRIPTION: Returns SD element ID for grid field |
10834 : | |
10835 : | |
10836 : | Return Value Type Units Description |
10837 : | ============ ====== ========= ===================================== |
10838 : | status intn return status (0) SUCCEED, (-1) FAIL |
10839 : | |
10840 : | INPUTS: |
10841 : | gridID int32 grid structure ID |
10842 : | fieldname const char field name |
10843 : | |
10844 : | |
10845 : | OUTPUTS: |
10846 : | sdid int32 SD element ID |
10847 : | |
10848 : | NOTES: |
10849 : | |
10850 : | |
10851 : | Date Programmer Description |
10852 : | ====== ============ ================================================= |
10853 : | Oct 07 Andrey Kiselev Original Programmer |
10854 : | |
10855 : | END_PROLOG |
10856 : -----------------------------------------------------------------------------*/
10857 : intn
10858 0 : GDsdid(int32 gridID, const char *fieldname, int32 *sdid)
10859 : {
10860 : intn status; /* routine return status variable */
10861 : int32 fid; /* HDF-EOS file ID */
10862 : int32 sdInterfaceID; /* HDF SDS interface ID */
10863 : int32 dum; /* Dummy variable */
10864 : int32 dims[H4_MAX_VAR_DIMS]; /* Field/SDS dimensions */
10865 :
10866 0 : status = GDchkgdid(gridID, "GDsdid", &fid, &sdInterfaceID, &dum);
10867 0 : if (status != -1)
10868 : {
10869 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname,
10870 : sdid, &dum, &dum, &dum, dims, &dum);
10871 : }
10872 :
10873 0 : return (status);
10874 : }
|
