Line data Source code
1 : /*****************************************************************************
2 : *
3 : * This module has a number of additions and improvements over the original
4 : * implementation to be suitable for usage in GDAL HDF driver.
5 : *
6 : * Andrey Kiselev <dron@ak4719.spb.edu> is responsible for all the changes.
7 : ****************************************************************************/
8 :
9 : /*
10 : Copyright (C) 1996 Hughes and Applied Research Corporation
11 :
12 : Permission to use, modify, and distribute this software and its documentation
13 : for any purpose without fee is hereby granted, provided that the above
14 : copyright notice appear in all copies and that both that copyright notice and
15 : this permission notice appear in supporting documentation.
16 : */
17 : /*****************************************************************************
18 : REVISIONS:
19 :
20 : Aug 31, 1999 Abe Taaheri Changed memory allocation for utility strings to
21 : the size of UTLSTR_MAX_SIZE.
22 : Added error check for memory unavailability in
23 : several functions.
24 : Added check for NULL metabuf returned from
25 : EHmeta... functions. NULL pointer returned from
26 : EHmeta... functions indicate that memory could not
27 : be allocated for metabuf.
28 : Jun 27, 2000 Abe Taaheri Added support for EASE grid that uses
29 : Behrmann Cylinderical Equal Area (BCEA) projection
30 : Oct 23, 2000 Abe Taaheri Updated for ISINUS projection, so that both codes
31 : 31 and 99 can be used for this projection.
32 : Jan 15, 2003 Abe Taaheri Modified for generalization of EASE Grid.
33 :
34 : Jun 05, 2003 Bruce Beaumont / Abe Taaheri
35 :
36 : Fixed SQUARE definition.
37 : Added static projection number/name translation
38 : Added projection table lookup in GDdefproj.
39 : Removed projection table from GDdefproj
40 : Added projection table lookup in GDprojinfo
41 : Removed projection table from GDprojinfo
42 : Added cast for compcode in call to SDsetcompress
43 : in GDdeffield to avoid compiler errors
44 : Removed declaration for unused variable endptr
45 : in GDSDfldsrch
46 : Removed initialization code for unused variables
47 : in GDSDfldsrch
48 : Removed declarations for unused variables
49 : BCEA_scale, r0, s0, xMtr0, xMtr1, yMtr0,
50 : and yMtr1 in GDll2ij
51 : Removed initialization code for unused variables
52 : in GDll2ij
53 : Added code in GEO projection handling to allow
54 : map to span dateline in GDll2ij
55 : Changed "for each point" loop in GDll2ij to
56 : return -2147483648.0 for xVal and yVal if
57 : for_trans returned an error instead of
58 : returning an error to the caller
59 : (Note: MAXLONG is defined as 2147483647.0 in
60 : function cproj.c of GCTP)
61 : Added code in GDij2ll to use for_trans to
62 : translate the BCEA corner points from packed
63 : degrees to meters
64 : Removed declarations for unused variables
65 : BCEA_scale, r0, s0, xMtr, yMtr, epsilon,
66 : beta, qp_cea, kz_cea, eccen, eccen_sq,
67 : phi1, sinphi1, cosphi1, lon, lat, xcor,
68 : ycor, and nlatlon from GDij2ll
69 : Removed initialization code for unused variables
70 : in GDij2ll
71 : Added declarations for xMtr0, yMtr0, xMtr1, and
72 : yMtr1 in GDij2ll
73 : Added special-case code for BCEA
74 : Changed "for each point" loop in GDij2ll to
75 : return PGSd_GCT_IN_ERROR (1.0e51) for
76 : longitude and latitude values if inv_trans
77 : returned an error instead of return an error
78 : to the caller
79 : Removed declaration for unused variable ii in
80 : GDgetpixvalues
81 : Removed declaration for unused variable
82 : numTileDims in GDtileinfo
83 : Added error message and error return at the
84 : end of GDll2mm_cea
85 : Added return statement to GDll2mm_cea
86 : ******************************************************************************/
87 : #include "cpl_string.h"
88 : #include "stdio.h"
89 : #include "mfhdf.h"
90 : #include "hcomp.h"
91 : #include <math.h>
92 : #include "HdfEosDef.h"
93 :
94 : #include "hdf4compat.h"
95 :
96 : extern void for_init(int32, int32, float64 *, int32, const char *, const char *, int32 *,
97 : int32 (*for_trans[])(double, double, double*, double*));
98 : extern void inv_init(int32, int32, float64 *, int32, const char *, const char *, int32 *,
99 : int32 (*inv_trans[])(double, double, double*, double*));
100 :
101 : #define GDIDOFFSET 4194304
102 : #define SQUARE(x) ((x) * (x)) /* x**2 */
103 :
104 :
105 : #define NGRID 200
106 : /* Grid Structure External Arrays */
107 : struct gridStructure
108 : {
109 : int32 active;
110 : int32 IDTable;
111 : int32 VIDTable[2];
112 : int32 fid;
113 : int32 nSDS;
114 : int32 *sdsID;
115 : int32 compcode;
116 : intn compparm[5];
117 : int32 tilecode;
118 : int32 tilerank;
119 : int32 tiledims[8];
120 : };
121 : static struct gridStructure GDXGrid[NGRID];
122 :
123 :
124 :
125 : #define NGRIDREGN 256
126 : struct gridRegion
127 : {
128 : int32 fid;
129 : int32 gridID;
130 : int32 xStart;
131 : int32 xCount;
132 : int32 yStart;
133 : int32 yCount;
134 : int32 somStart;
135 : int32 somCount;
136 : float64 upleftpt[2];
137 : float64 lowrightpt[2];
138 : int32 StartVertical[8];
139 : int32 StopVertical[8];
140 : char *DimNamePtr[8];
141 : };
142 : static struct gridRegion *GDXRegion[NGRIDREGN];
143 :
144 : /* define a macro for the string size of the utility strings and some dimension
145 : list strings. The value of 80 in the previous version of this code
146 : may not be enough in some cases. The length now is 512 which seems to
147 : be more than enough to hold larger strings. */
148 :
149 : #define UTLSTR_MAX_SIZE 512
150 :
151 : /* Static projection table */
152 : static const struct {
153 : int32 projcode;
154 : const char *projname;
155 : } Projections[] = {
156 : {GCTP_GEO, "GCTP_GEO"},
157 : {GCTP_UTM, "GCTP_UTM"},
158 : {GCTP_SPCS, "GCTP_SPCS"},
159 : {GCTP_ALBERS, "GCTP_ALBERS"},
160 : {GCTP_LAMCC, "GCTP_LAMCC"},
161 : {GCTP_MERCAT, "GCTP_MERCAT"},
162 : {GCTP_PS, "GCTP_PS"},
163 : {GCTP_POLYC, "GCTP_POLYC"},
164 : {GCTP_EQUIDC, "GCTP_EQUIDC"},
165 : {GCTP_TM, "GCTP_TM"},
166 : {GCTP_STEREO, "GCTP_STEREO"},
167 : {GCTP_LAMAZ, "GCTP_LAMAZ"},
168 : {GCTP_AZMEQD, "GCTP_AZMEQD"},
169 : {GCTP_GNOMON, "GCTP_GNOMON"},
170 : {GCTP_ORTHO, "GCTP_ORTHO"},
171 : {GCTP_GVNSP, "GCTP_GVNSP"},
172 : {GCTP_SNSOID, "GCTP_SNSOID"},
173 : {GCTP_EQRECT, "GCTP_EQRECT"},
174 : {GCTP_MILLER, "GCTP_MILLER"},
175 : {GCTP_VGRINT, "GCTP_VGRINT"},
176 : {GCTP_HOM, "GCTP_HOM"},
177 : {GCTP_ROBIN, "GCTP_ROBIN"},
178 : {GCTP_SOM, "GCTP_SOM"},
179 : {GCTP_ALASKA, "GCTP_ALASKA"},
180 : {GCTP_GOOD, "GCTP_GOOD"},
181 : {GCTP_MOLL, "GCTP_MOLL"},
182 : {GCTP_IMOLL, "GCTP_IMOLL"},
183 : {GCTP_HAMMER, "GCTP_HAMMER"},
184 : {GCTP_WAGIV, "GCTP_WAGIV"},
185 : {GCTP_WAGVII, "GCTP_WAGVII"},
186 : {GCTP_OBLEQA, "GCTP_OBLEQA"},
187 : {GCTP_ISINUS1, "GCTP_ISINUS1"},
188 : {GCTP_CEA, "GCTP_CEA"},
189 : {GCTP_BCEA, "GCTP_BCEA"},
190 : {GCTP_ISINUS, "GCTP_ISINUS"},
191 : {-1, NULL}
192 : };
193 :
194 : /* Compression Codes */
195 : static const char * const HDFcomp[] = {
196 : "HDFE_COMP_NONE",
197 : "HDFE_COMP_RLE",
198 : "HDFE_COMP_NBIT",
199 : "HDFE_COMP_SKPHUFF",
200 : "HDFE_COMP_DEFLATE"
201 : };
202 :
203 : /* Origin Codes */
204 : static const char * const originNames[] = {
205 : "HDFE_GD_UL",
206 : "HDFE_GD_UR",
207 : "HDFE_GD_LL",
208 : "HDFE_GD_LR"
209 : };
210 :
211 : /* Pixel Registration Codes */
212 : static const char * const pixregNames[] = {
213 : "HDFE_CENTER",
214 : "HDFE_CORNER"
215 : };
216 :
217 : /* Grid Function Prototypes (internal routines) */
218 : static intn GDchkgdid(int32, const char *, int32 *, int32 *, int32 *);
219 : static intn GDSDfldsrch(int32, int32, const char *, int32 *, int32 *,
220 : int32 *, int32 *, int32 [], int32 *);
221 : static intn GDwrrdfield(int32, const char *, const char *,
222 : int32 [], int32 [], int32 [], VOIDP datbuf);
223 : static intn GDwrrdattr(int32, const char *, int32, int32, const char *, VOIDP);
224 : static intn GDll2ij(int32, int32, float64 [], int32, int32, int32, float64[],
225 : float64[], int32, float64[], float64[], int32[], int32[],
226 : float64[], float64[]);
227 : static intn GDgetdefaults(int32, int32, float64[], int32,
228 : float64[], float64[]);
229 : static intn GDwrrdtile(int32, const char *, const char *, int32 [], VOIDP);
230 :
231 : /*----------------------------------------------------------------------------|
232 : | BEGIN_PROLOG |
233 : | |
234 : | FUNCTION: GDopen |
235 : | |
236 : | DESCRIPTION: Opens or creates HDF file in order to create, read, or write |
237 : | a grid. |
238 : | |
239 : | |
240 : | Return Value Type Units Description |
241 : | ============ ====== ========= ===================================== |
242 : | fid int32 HDF-EOS file ID |
243 : | |
244 : | INPUTS: |
245 : | filename char Filename |
246 : | l_access intn HDF l_access code |
247 : | |
248 : | |
249 : | OUTPUTS: |
250 : | None |
251 : | |
252 : | NOTES: |
253 : | |
254 : | |
255 : | Date Programmer Description |
256 : | ====== ============ ================================================= |
257 : | Jun 96 Joel Gales Original Programmer |
258 : | |
259 : | END_PROLOG |
260 : -----------------------------------------------------------------------------*/
261 : int32
262 4 : GDopen(const char *filename, intn l_access)
263 :
264 : {
265 : int32 fid /* HDF-EOS file ID */ ;
266 :
267 : /* Call EHopen to perform file l_access */
268 : /* ---------------------------------- */
269 4 : fid = EHopen(filename, l_access);
270 :
271 4 : return (fid);
272 :
273 : }
274 :
275 :
276 : /*----------------------------------------------------------------------------|
277 : | BEGIN_PROLOG |
278 : | |
279 : | FUNCTION: GDattach |
280 : | |
281 : | DESCRIPTION: Attaches to an existing grid within the file. |
282 : | |
283 : | |
284 : | Return Value Type Units Description |
285 : | ============ ====== ========= ===================================== |
286 : | gridID int32 grid structure ID |
287 : | |
288 : | INPUTS: |
289 : | fid int32 HDF-EOS file id |
290 : | gridname char grid structure name |
291 : | |
292 : | |
293 : | OUTPUTS: |
294 : | None |
295 : | |
296 : | NOTES: |
297 : | |
298 : | |
299 : | Date Programmer Description |
300 : | ====== ============ ================================================= |
301 : | Jun 96 Joel Gales Original Programmer |
302 : | Sep 99 Abe Taaheri Modified test for memory allocation check when no |
303 : | SDSs are in the grid, NCR24147 |
304 : | |
305 : | END_PROLOG |
306 : -----------------------------------------------------------------------------*/
307 : int32
308 0 : GDattach(int32 fid, const char *gridname)
309 :
310 : {
311 : intn i; /* Loop index */
312 : intn j; /* Loop index */
313 0 : intn ngridopen = 0; /* # of grid structures open */
314 : intn status; /* routine return status variable */
315 :
316 : uint8 acs; /* Read/Write file l_access code */
317 :
318 : int32 HDFfid; /* HDF file id */
319 : int32 vgRef; /* Vgroup reference number */
320 : int32 vgid[3]; /* Vgroup ID array */
321 0 : int32 gridID = -1;/* HDF-EOS grid ID */
322 : int32 *tags; /* Pnt to Vgroup object tags array */
323 : int32 *refs; /* Pnt to Vgroup object refs array */
324 : int32 dum; /* dummy variable */
325 : int32 sdInterfaceID; /* HDF SDS interface ID */
326 : int32 nObjects; /* # of objects in Vgroup */
327 : int32 nSDS; /* SDS counter */
328 : int32 l_index; /* SDS l_index */
329 : int32 sdid; /* SDS object ID */
330 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
331 :
332 : char name[80]; /* Vgroup name */
333 : char class[80]; /* Vgroup class */
334 : char errbuf[256];/* Buffer for error message */
335 : char acsCode[1]; /* Read/Write l_access char: "r/w" */
336 :
337 :
338 : /* Check HDF-EOS file ID, get back HDF file ID and l_access code */
339 : /* ----------------------------------------------------------- */
340 0 : status = EHchkfid(fid, gridname, &HDFfid, &dum, &acs);
341 :
342 :
343 0 : if (status == 0)
344 : {
345 : /* Convert numeric l_access code to character */
346 : /* ---------------------------------------- */
347 :
348 0 : acsCode[0] = (acs == 1) ? 'w' : 'r';
349 :
350 : /* Determine number of grids currently opened */
351 : /* ------------------------------------------- */
352 0 : for (i = 0; i < NGRID; i++)
353 : {
354 0 : ngridopen += GDXGrid[i].active;
355 : }
356 :
357 :
358 : /* If room for more ... */
359 : /* -------------------- */
360 0 : if (ngridopen < NGRID)
361 : {
362 :
363 : /* Search Vgroups for Grid */
364 : /* ------------------------ */
365 0 : vgRef = -1;
366 :
367 : while (1)
368 : {
369 0 : vgRef = Vgetid(HDFfid, vgRef);
370 :
371 : /* If no more Vgroups then exist while loop */
372 : /* ---------------------------------------- */
373 0 : if (vgRef == -1)
374 : {
375 0 : break;
376 : }
377 :
378 : /* Get name and class of Vgroup */
379 : /* ---------------------------- */
380 0 : vgid[0] = Vattach(HDFfid, vgRef, "r");
381 0 : Vgetname(vgid[0], name);
382 0 : Vgetclass(vgid[0], class);
383 :
384 :
385 : /*
386 : * If Vgroup with gridname and class GRID found, load tables
387 : */
388 :
389 0 : if (strcmp(name, gridname) == 0 &&
390 0 : strcmp(class, "GRID") == 0)
391 : {
392 : /* Attach to "Data Fields" and "Grid Attributes" Vgroups */
393 : /* ----------------------------------------------------- */
394 0 : tags = (int32 *) malloc(sizeof(int32) * 2);
395 0 : if(tags == NULL)
396 : {
397 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
398 0 : return(-1);
399 : }
400 0 : refs = (int32 *) malloc(sizeof(int32) * 2);
401 0 : if(refs == NULL)
402 : {
403 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
404 0 : free(tags);
405 0 : return(-1);
406 : }
407 0 : Vgettagrefs(vgid[0], tags, refs, 2);
408 0 : vgid[1] = Vattach(HDFfid, refs[0], acsCode);
409 0 : vgid[2] = Vattach(HDFfid, refs[1], acsCode);
410 0 : free(tags);
411 0 : free(refs);
412 :
413 :
414 : /* Setup External Arrays */
415 : /* --------------------- */
416 0 : for (i = 0; i < NGRID; i++)
417 : {
418 : /* Find empty entry in array */
419 : /* ------------------------- */
420 0 : if (GDXGrid[i].active == 0)
421 : {
422 : /*
423 : * Set gridID, Set grid entry active, Store root
424 : * Vgroup ID, Store sub Vgroup IDs, Store HDF-EOS
425 : * file ID
426 : */
427 0 : gridID = i + idOffset;
428 0 : GDXGrid[i].active = 1;
429 0 : GDXGrid[i].IDTable = vgid[0];
430 0 : GDXGrid[i].VIDTable[0] = vgid[1];
431 0 : GDXGrid[i].VIDTable[1] = vgid[2];
432 0 : GDXGrid[i].fid = fid;
433 0 : break;
434 : }
435 : }
436 :
437 : /* Get SDS interface ID */
438 : /* -------------------- */
439 0 : status = GDchkgdid(gridID, "GDattach", &dum,
440 : &sdInterfaceID, &dum);
441 :
442 :
443 : /* Get # of entries within Data Vgroup & search for SDS */
444 : /* ---------------------------------------------------- */
445 0 : nObjects = Vntagrefs(vgid[1]);
446 :
447 0 : if (nObjects > 0)
448 : {
449 : /* Get tag and ref # for Data Vgroup objects */
450 : /* ----------------------------------------- */
451 0 : tags = (int32 *) malloc(sizeof(int32) * nObjects);
452 0 : if(tags == NULL)
453 : {
454 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
455 0 : return(-1);
456 : }
457 0 : refs = (int32 *) malloc(sizeof(int32) * nObjects);
458 0 : if(refs == NULL)
459 : {
460 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
461 0 : free(tags);
462 0 : return(-1);
463 : }
464 0 : Vgettagrefs(vgid[1], tags, refs, nObjects);
465 :
466 : /* Count number of SDS & allocate SDS ID array */
467 : /* ------------------------------------------- */
468 0 : nSDS = 0;
469 0 : for (j = 0; j < nObjects; j++)
470 : {
471 0 : if (tags[j] == DFTAG_NDG)
472 : {
473 0 : nSDS++;
474 : }
475 : }
476 0 : GDXGrid[i].sdsID = (int32 *) calloc(nSDS, 4);
477 0 : if(GDXGrid[i].sdsID == NULL && nSDS != 0)
478 : {
479 0 : HEpush(DFE_NOSPACE,"GDattach", __FILE__, __LINE__);
480 0 : free(tags);
481 0 : free(refs);
482 0 : return(-1);
483 : }
484 0 : nSDS = 0;
485 :
486 :
487 :
488 : /* Fill SDS ID array */
489 : /* ----------------- */
490 0 : for (j = 0; j < nObjects; j++)
491 : {
492 : /* If object is SDS then get id */
493 : /* ---------------------------- */
494 0 : if (tags[j] == DFTAG_NDG)
495 : {
496 0 : l_index = SDreftoindex(sdInterfaceID, refs[j]);
497 0 : sdid = SDselect(sdInterfaceID, l_index);
498 0 : GDXGrid[i].sdsID[nSDS] = sdid;
499 0 : nSDS++;
500 0 : GDXGrid[i].nSDS++;
501 : }
502 : }
503 0 : free(tags);
504 0 : free(refs);
505 : }
506 0 : break;
507 : }
508 :
509 : /* Detach Vgroup if not desired Grid */
510 : /* --------------------------------- */
511 0 : Vdetach(vgid[0]);
512 : }
513 :
514 : /* If Grid not found then set up error message */
515 : /* ------------------------------------------- */
516 0 : if (gridID == -1)
517 : {
518 0 : HEpush(DFE_RANGE, "GDattach", __FILE__, __LINE__);
519 0 : HEreport("Grid: \"%s\" does not exist within HDF file.\n",
520 : gridname);
521 : }
522 : }
523 : else
524 : {
525 : /* Too many files opened */
526 : /* --------------------- */
527 0 : gridID = -1;
528 0 : strcpy(errbuf,
529 : "No more than %d grids may be open simultaneously");
530 0 : strcat(errbuf, " (%s)");
531 0 : HEpush(DFE_DENIED, "GDattach", __FILE__, __LINE__);
532 0 : HEreport(errbuf, NGRID, gridname);
533 : }
534 :
535 : }
536 0 : return (gridID);
537 : }
538 :
539 :
540 : /*----------------------------------------------------------------------------|
541 : | BEGIN_PROLOG |
542 : | |
543 : | FUNCTION: GDchkgdid |
544 : | |
545 : | DESCRIPTION: |
546 : | |
547 : | |
548 : | Return Value Type Units Description |
549 : | ============ ====== ========= ===================================== |
550 : | status intn return status (0) SUCCEED, (-1) FAIL |
551 : | |
552 : | INPUTS: |
553 : | gridID int32 grid structure ID |
554 : | routname char Name of routine calling GDchkgdid |
555 : | |
556 : | OUTPUTS: |
557 : | fid int32 File ID |
558 : | sdInterfaceID int32 SDS interface ID |
559 : | gdVgrpID int32 grid Vgroup ID |
560 : | |
561 : | |
562 : | OUTPUTS: |
563 : | None |
564 : | |
565 : | NOTES: |
566 : | |
567 : | |
568 : | Date Programmer Description |
569 : | ====== ============ ================================================= |
570 : | Jun 96 Joel Gales Original Programmer |
571 : | |
572 : | END_PROLOG |
573 : -----------------------------------------------------------------------------*/
574 : static intn
575 0 : GDchkgdid(int32 gridID, const char *routname,
576 : int32 * fid, int32 * sdInterfaceID, int32 * gdVgrpID)
577 : {
578 0 : intn status = 0; /* routine return status variable */
579 : uint8 l_access; /* Read/Write l_access code */
580 : int32 gID; /* Grid ID - offset */
581 :
582 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
583 :
584 : static const char message1[] =
585 : "Invalid grid id: %d in routine \"%s\". ID must be >= %d and < %d.\n";
586 : static const char message2[] =
587 : "Grid id %d in routine \"%s\" not active.\n";
588 :
589 :
590 :
591 : /* Check for valid grid id */
592 :
593 0 : if (gridID < idOffset || gridID >= NGRID + idOffset)
594 : {
595 0 : status = -1;
596 0 : HEpush(DFE_RANGE, "GDchkgdid", __FILE__, __LINE__);
597 0 : HEreport(message1, gridID, routname, idOffset, NGRID + idOffset);
598 : }
599 : else
600 : {
601 :
602 : /* Compute "reduced" ID */
603 : /* -------------------- */
604 0 : gID = gridID % idOffset;
605 :
606 : /* Check for active grid ID */
607 : /* ------------------------ */
608 0 : if (GDXGrid[gID].active == 0)
609 : {
610 0 : status = -1;
611 0 : HEpush(DFE_GENAPP, "GDchkgdid", __FILE__, __LINE__);
612 0 : HEreport(message2, gridID, routname);
613 : }
614 : else
615 : {
616 :
617 : /* Get file & SDS ids and Grid key */
618 : /* -------------------------------- */
619 0 : status = EHchkfid(GDXGrid[gID].fid, " ",
620 : fid, sdInterfaceID, &l_access);
621 0 : *gdVgrpID = GDXGrid[gID].IDTable;
622 : }
623 : }
624 0 : return (status);
625 :
626 : }
627 :
628 :
629 : /*----------------------------------------------------------------------------|
630 : | BEGIN_PROLOG |
631 : | |
632 : | FUNCTION: GDdiminfo |
633 : | |
634 : | DESCRIPTION: Retrieve size of specified dimension. |
635 : | |
636 : | |
637 : | Return Value Type Units Description |
638 : | ============ ====== ========= ===================================== |
639 : | size int32 Size of dimension |
640 : | |
641 : | INPUTS: |
642 : | gridID int32 grid structure id |
643 : | dimname char Dimension name |
644 : | |
645 : | |
646 : | OUTPUTS: |
647 : | None |
648 : | |
649 : | NOTES: |
650 : | |
651 : | |
652 : | Date Programmer Description |
653 : | ====== ============ ================================================= |
654 : | Jun 96 Joel Gales Original Programmer |
655 : | Aug 96 Joel Gales Make metadata ODL compliant |
656 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
657 : | |
658 : | END_PROLOG |
659 : -----------------------------------------------------------------------------*/
660 : int32
661 0 : GDdiminfo(int32 gridID, const char *dimname)
662 :
663 : {
664 : intn status; /* routine return status variable */
665 :
666 : int32 fid; /* HDF-EOS file ID */
667 : int32 sdInterfaceID; /* HDF SDS interface ID */
668 : int32 gdVgrpID; /* Grid root Vgroup ID */
669 : int32 size; /* Dimension size */
670 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
671 :
672 :
673 : char *metabuf; /* Pointer to structural metadata (SM) */
674 : char *metaptrs[2];/* Pointers to begin and end of SM section */
675 : char gridname[80]; /* Grid Name */
676 : char *utlstr; /* Utility string */
677 :
678 : /* Allocate space for utility string */
679 : /* --------------------------------- */
680 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
681 0 : if(utlstr == NULL)
682 : {
683 0 : HEpush(DFE_NOSPACE,"GDdiminfo", __FILE__, __LINE__);
684 0 : return(-1);
685 : }
686 : /* Initialize return value */
687 : /* ----------------------- */
688 0 : size = -1;
689 :
690 :
691 : /* Check Grid ID */
692 : /* ------------- */
693 0 : status = GDchkgdid(gridID, "GDdiminfo", &fid, &sdInterfaceID, &gdVgrpID);
694 :
695 :
696 0 : if (status == 0)
697 : {
698 : /* Get grid name */
699 : /* ------------- */
700 0 : int gID = gridID % idOffset;
701 0 : if (gID >= NGRID)
702 : {
703 0 : free(utlstr);
704 0 : return -1;
705 : }
706 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
707 :
708 :
709 : /* Get pointers to "Dimension" section within SM */
710 : /* --------------------------------------------- */
711 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
712 : "Dimension", metaptrs);
713 :
714 0 : if(metabuf == NULL)
715 : {
716 0 : free(utlstr);
717 0 : return(-1);
718 : }
719 :
720 : /* Search for dimension name (surrounded by quotes) */
721 : /* ------------------------------------------------ */
722 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", dimname, "\"\n");
723 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
724 :
725 : /*
726 : * If dimension found within grid structure then get dimension value
727 : */
728 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
729 : {
730 : /* Set endptr at end of dimension definition entry */
731 : /* ----------------------------------------------- */
732 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
733 :
734 0 : status = EHgetmetavalue(metaptrs, "Size", utlstr);
735 :
736 0 : if (status == 0)
737 : {
738 0 : size = atoi(utlstr);
739 : }
740 : else
741 : {
742 0 : HEpush(DFE_GENAPP, "GDdiminfo", __FILE__, __LINE__);
743 0 : HEreport("\"Size\" string not found in metadata.\n");
744 : }
745 : }
746 : else
747 : {
748 0 : HEpush(DFE_GENAPP, "GDdiminfo", __FILE__, __LINE__);
749 0 : HEreport("Dimension \"%s\" not found.\n", dimname);
750 : }
751 :
752 0 : free(metabuf);
753 : }
754 0 : free(utlstr);
755 0 : return (size);
756 : }
757 :
758 :
759 :
760 :
761 :
762 : /*----------------------------------------------------------------------------|
763 : | BEGIN_PROLOG |
764 : | |
765 : | FUNCTION: GDgridinfo |
766 : | |
767 : | DESCRIPTION: Returns xdim, ydim and location of upper left and lower |
768 : | right corners, in meters. |
769 : | |
770 : | |
771 : | Return Value Type Units Description |
772 : | ============ ====== ========= ===================================== |
773 : | status intn return status (0) SUCCEED, (-1) FAIL |
774 : | |
775 : | INPUTS: |
776 : | fid int32 File ID |
777 : | gridname char Grid structure name |
778 : | |
779 : | OUTPUTS: |
780 : | xdimsize int32 Number of columns in grid |
781 : | ydimsize int32 Number of rows in grid |
782 : | upleftpt float64 Location (m/deg) of upper left corner |
783 : | lowrightpt float64 Location (m/deg) of lower right corner |
784 : | |
785 : | NOTES: |
786 : | |
787 : | |
788 : | Date Programmer Description |
789 : | ====== ============ ================================================= |
790 : | Jun 96 Joel Gales Original Programmer |
791 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
792 : | |
793 : | END_PROLOG |
794 : -----------------------------------------------------------------------------*/
795 : intn
796 0 : GDgridinfo(int32 gridID, int32 * xdimsize, int32 * ydimsize,
797 : float64 upleftpt[], float64 lowrightpt[])
798 :
799 : {
800 0 : intn status = 0; /* routine return status variable */
801 0 : intn statmeta = 0; /* EHgetmetavalue return status */
802 :
803 : int32 fid; /* HDF-EOS file ID */
804 : int32 sdInterfaceID; /* HDF SDS interface ID */
805 : int32 gdVgrpID; /* Grid root Vgroup ID */
806 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
807 :
808 :
809 : char *metabuf; /* Pointer to structural metadata (SM) */
810 : char *metaptrs[2];/* Pointers to begin and end of SM section */
811 : char gridname[80]; /* Grid Name */
812 : char *utlstr; /* Utility string */
813 :
814 : /* Allocate space for utility string */
815 : /* --------------------------------- */
816 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
817 0 : if(utlstr == NULL)
818 : {
819 0 : HEpush(DFE_NOSPACE,"GDgridinfo", __FILE__, __LINE__);
820 0 : return(-1);
821 : }
822 : /* Check Grid ID */
823 : /* ------------- */
824 0 : status = GDchkgdid(gridID, "GDgridinfo", &fid, &sdInterfaceID, &gdVgrpID);
825 :
826 0 : if (status == 0)
827 : {
828 : /* Get grid name */
829 : /* ------------- */
830 0 : int gID = gridID % idOffset;
831 0 : if (gID >= NGRID)
832 : {
833 0 : free(utlstr);
834 0 : return -1;
835 : }
836 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
837 :
838 :
839 : /* Get pointers to grid structure section within SM */
840 : /* ------------------------------------------------ */
841 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
842 : NULL, metaptrs);
843 :
844 0 : if(metabuf == NULL)
845 : {
846 0 : free(utlstr);
847 0 : return(-1);
848 : }
849 :
850 :
851 : /* Get xdimsize if requested */
852 : /* ------------------------- */
853 0 : if (xdimsize != NULL)
854 : {
855 0 : statmeta = EHgetmetavalue(metaptrs, "XDim", utlstr);
856 0 : if (statmeta == 0)
857 : {
858 0 : *xdimsize = atoi(utlstr);
859 : }
860 : else
861 : {
862 0 : status = -1;
863 0 : HEpush(DFE_GENAPP, "GDgridinfo", __FILE__, __LINE__);
864 0 : HEreport("\"XDim\" string not found in metadata.\n");
865 : }
866 : }
867 :
868 :
869 : /* Get ydimsize if requested */
870 : /* ------------------------- */
871 0 : if (ydimsize != NULL)
872 : {
873 0 : statmeta = EHgetmetavalue(metaptrs, "YDim", utlstr);
874 0 : if (statmeta == 0)
875 : {
876 0 : *ydimsize = atoi(utlstr);
877 : }
878 : else
879 : {
880 0 : status = -1;
881 0 : HEpush(DFE_GENAPP, "GDgridinfo", __FILE__, __LINE__);
882 0 : HEreport("\"YDim\" string not found in metadata.\n");
883 : }
884 : }
885 :
886 :
887 : /* Get upleftpt if requested */
888 : /* ------------------------- */
889 0 : if (upleftpt != NULL)
890 : {
891 0 : statmeta = EHgetmetavalue(metaptrs, "UpperLeftPointMtrs", utlstr);
892 0 : if (statmeta == 0)
893 : {
894 : /* If value is "DEFAULT" then return zeros */
895 : /* --------------------------------------- */
896 0 : if (strcmp(utlstr, "DEFAULT") == 0)
897 : {
898 0 : upleftpt[0] = 0;
899 0 : upleftpt[1] = 0;
900 : }
901 : else
902 : {
903 0 : sscanf(utlstr, "(%lf,%lf)",
904 : &upleftpt[0], &upleftpt[1]);
905 : }
906 : }
907 : else
908 : {
909 0 : status = -1;
910 0 : HEpush(DFE_GENAPP, "GDgridinfo", __FILE__, __LINE__);
911 0 : HEreport(
912 : "\"UpperLeftPointMtrs\" string not found in metadata.\n");
913 : }
914 :
915 : }
916 :
917 : /* Get lowrightpt if requested */
918 : /* --------------------------- */
919 0 : if (lowrightpt != NULL)
920 : {
921 0 : statmeta = EHgetmetavalue(metaptrs, "LowerRightMtrs", utlstr);
922 0 : if (statmeta == 0)
923 : {
924 : /* If value is "DEFAULT" then return zeros */
925 0 : if (strcmp(utlstr, "DEFAULT") == 0)
926 : {
927 0 : lowrightpt[0] = 0;
928 0 : lowrightpt[1] = 0;
929 : }
930 : else
931 : {
932 0 : sscanf(utlstr, "(%lf,%lf)",
933 : &lowrightpt[0], &lowrightpt[1]);
934 : }
935 : }
936 : else
937 : {
938 0 : status = -1;
939 0 : HEpush(DFE_GENAPP, "GDgridinfo", __FILE__, __LINE__);
940 0 : HEreport(
941 : "\"LowerRightMtrs\" string not found in metadata.\n");
942 : }
943 : }
944 :
945 0 : free(metabuf);
946 : }
947 0 : free(utlstr);
948 0 : return (status);
949 : }
950 :
951 :
952 :
953 :
954 :
955 :
956 :
957 : /*----------------------------------------------------------------------------|
958 : | BEGIN_PROLOG |
959 : | |
960 : | FUNCTION: GDprojinfo |
961 : | |
962 : | DESCRIPTION: Returns GCTP projection code, zone code, spheroid code |
963 : | and projection parameters. |
964 : | |
965 : | |
966 : | Return Value Type Units Description |
967 : | ============ ====== ========= ===================================== |
968 : | status intn return status (0) SUCCEED, (-1) FAIL |
969 : | |
970 : | INPUTS: |
971 : | gridID int32 Grid structure ID |
972 : | |
973 : | OUTPUTS: |
974 : | projcode int32 GCTP projection code |
975 : | zonecode int32 UTM zone code |
976 : | spherecode int32 GCTP spheriod code |
977 : | projparm float64 Projection parameters |
978 : | |
979 : | NOTES: |
980 : | |
981 : | |
982 : | Date Programmer Description |
983 : | ====== ============ ================================================= |
984 : | Jun 96 Joel Gales Original Programmer |
985 : | Oct 96 Joel Gales Add check for no projection code |
986 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
987 : | Jun 00 Abe Taaheri Added support for EASE grid |
988 : | |
989 : | END_PROLOG |
990 : -----------------------------------------------------------------------------*/
991 : intn
992 0 : GDprojinfo(int32 gridID, int32 * projcode, int32 * zonecode,
993 : int32 * spherecode, float64 projparm[])
994 :
995 : {
996 : intn i; /* Loop index */
997 : intn projx; /* Loop index */
998 0 : intn status = 0; /* routine return status variable */
999 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1000 :
1001 : int32 fid; /* HDF-EOS file ID */
1002 : int32 sdInterfaceID; /* HDF SDS interface ID */
1003 : int32 gdVgrpID; /* Grid root Vgroup ID */
1004 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1005 :
1006 :
1007 : char *metabuf; /* Pointer to structural metadata (SM) */
1008 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1009 : char gridname[80]; /* Grid Name */
1010 : char *utlstr; /* Utility string */
1011 : char fmt[96]; /* Format String */
1012 :
1013 : /* Allocate space for utility string */
1014 : /* --------------------------------- */
1015 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1016 0 : if(utlstr == NULL)
1017 : {
1018 0 : HEpush(DFE_NOSPACE,"GDprojinfo", __FILE__, __LINE__);
1019 0 : return(-1);
1020 : }
1021 :
1022 : /* Check Grid ID */
1023 : /* ------------- */
1024 0 : status = GDchkgdid(gridID, "GDprojinfo", &fid, &sdInterfaceID, &gdVgrpID);
1025 :
1026 0 : if (status == 0)
1027 : {
1028 : /* Get grid name */
1029 : /* ------------- */
1030 0 : int gID = gridID % idOffset;
1031 0 : if (gID >= NGRID)
1032 : {
1033 0 : free(utlstr);
1034 0 : return -1;
1035 : }
1036 :
1037 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
1038 :
1039 :
1040 : /* Get pointers to grid structure section within SM */
1041 : /* ------------------------------------------------ */
1042 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1043 : NULL, metaptrs);
1044 :
1045 0 : if(metabuf == NULL)
1046 : {
1047 0 : free(utlstr);
1048 0 : return(-1);
1049 : }
1050 :
1051 :
1052 : /* Get projcode if requested */
1053 : /* ------------------------- */
1054 0 : if (projcode != NULL)
1055 : {
1056 0 : *projcode = -1;
1057 :
1058 0 : statmeta = EHgetmetavalue(metaptrs, "Projection", utlstr);
1059 0 : if (statmeta == 0)
1060 : {
1061 : /* Loop through projection codes until found */
1062 : /* ----------------------------------------- */
1063 0 : for (projx = 0; Projections[projx].projcode != -1; projx++)
1064 0 : if (strcmp(utlstr, Projections[projx].projname) == 0)
1065 0 : break;
1066 0 : if (Projections[projx].projname != NULL)
1067 0 : *projcode = Projections[projx].projcode;
1068 : }
1069 : else
1070 : {
1071 0 : status = -1;
1072 0 : HEpush(DFE_GENAPP, "GDprojinfo", __FILE__, __LINE__);
1073 0 : HEreport("Projection Code not defined for \"%s\".\n",
1074 : gridname);
1075 :
1076 0 : if (projparm != NULL)
1077 : {
1078 0 : for (i = 0; i < 13; i++)
1079 : {
1080 0 : projparm[i] = -1;
1081 : }
1082 : }
1083 : }
1084 : }
1085 :
1086 :
1087 : /* Get zonecode if requested */
1088 : /* ------------------------- */
1089 0 : if (projcode && zonecode != NULL)
1090 : {
1091 0 : *zonecode = -1;
1092 :
1093 :
1094 : /* Zone code only relevant for UTM and State Code projections */
1095 : /* ---------------------------------------------------------- */
1096 0 : if (*projcode == GCTP_UTM || *projcode == GCTP_SPCS)
1097 : {
1098 0 : statmeta = EHgetmetavalue(metaptrs, "ZoneCode", utlstr);
1099 0 : if (statmeta == 0)
1100 : {
1101 0 : *zonecode = atoi(utlstr);
1102 : }
1103 : else
1104 : {
1105 0 : status = -1;
1106 0 : HEpush(DFE_GENAPP, "GDprojinfo", __FILE__, __LINE__);
1107 0 : HEreport("Zone Code not defined for \"%s\".\n",
1108 : gridname);
1109 : }
1110 : }
1111 : }
1112 :
1113 :
1114 : /* Get projection parameters if requested */
1115 : /* -------------------------------------- */
1116 0 : if (projcode && projparm != NULL)
1117 : {
1118 :
1119 : /*
1120 : * Note: No projection parameters for GEO, UTM, and State Code
1121 : * projections
1122 : */
1123 0 : if (*projcode == GCTP_GEO || *projcode == GCTP_UTM ||
1124 0 : *projcode == GCTP_SPCS)
1125 : {
1126 0 : for (i = 0; i < 13; i++)
1127 : {
1128 0 : projparm[i] = 0.0;
1129 : }
1130 :
1131 : }
1132 : else
1133 : {
1134 0 : statmeta = EHgetmetavalue(metaptrs, "ProjParams", utlstr);
1135 :
1136 0 : if (statmeta == 0)
1137 : {
1138 :
1139 : /* Build format string to read projection parameters */
1140 : /* ------------------------------------------------- */
1141 0 : strcpy(fmt, "%lf,");
1142 0 : for (i = 1; i <= 11; i++)
1143 0 : strcat(fmt, "%lf,");
1144 0 : strcat(fmt, "%lf");
1145 :
1146 :
1147 : /* Read parameters from numeric list */
1148 : /* --------------------------------- */
1149 0 : sscanf(&utlstr[1], fmt,
1150 : &projparm[0], &projparm[1],
1151 : &projparm[2], &projparm[3],
1152 : &projparm[4], &projparm[5],
1153 : &projparm[6], &projparm[7],
1154 : &projparm[8], &projparm[9],
1155 : &projparm[10], &projparm[11],
1156 : &projparm[12]);
1157 : }
1158 : else
1159 : {
1160 0 : status = -1;
1161 0 : HEpush(DFE_GENAPP, "GDprojinfo", __FILE__, __LINE__);
1162 0 : HEreport("Projection parameters not defined for \"%s\".\n",
1163 : gridname);
1164 :
1165 : }
1166 : }
1167 : }
1168 :
1169 :
1170 : /* Get spherecode if requested */
1171 : /* --------------------------- */
1172 0 : if (projcode && spherecode != NULL)
1173 : {
1174 0 : *spherecode = 0;
1175 :
1176 : /* Note: Spherecode not defined for GEO projection */
1177 : /* ----------------------------------------------- */
1178 0 : if ((*projcode != GCTP_GEO))
1179 : {
1180 0 : EHgetmetavalue(metaptrs, "SphereCode", utlstr);
1181 0 : if (statmeta == 0)
1182 : {
1183 0 : *spherecode = atoi(utlstr);
1184 : }
1185 : }
1186 : }
1187 0 : free(metabuf);
1188 :
1189 : }
1190 0 : free(utlstr);
1191 0 : return (status);
1192 : }
1193 :
1194 :
1195 :
1196 : /*----------------------------------------------------------------------------|
1197 : | BEGIN_PROLOG |
1198 : | |
1199 : | FUNCTION: GDorigininfo |
1200 : | |
1201 : | DESCRIPTION: Returns origin code |
1202 : | |
1203 : | |
1204 : | Return Value Type Units Description |
1205 : | ============ ====== ========= ===================================== |
1206 : | status intn return status (0) SUCCEED, (-1) FAIL |
1207 : | |
1208 : | INPUTS: |
1209 : | gridID int32 Grid structure ID |
1210 : | |
1211 : | |
1212 : | OUTPUTS: |
1213 : | origincode int32 grid origin code |
1214 : | |
1215 : | NOTES: |
1216 : | |
1217 : | |
1218 : | Date Programmer Description |
1219 : | ====== ============ ================================================= |
1220 : | Jun 96 Joel Gales Original Programmer |
1221 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1222 : | |
1223 : | END_PROLOG |
1224 : -----------------------------------------------------------------------------*/
1225 : intn
1226 0 : GDorigininfo(int32 gridID, int32 * origincode)
1227 : {
1228 : intn i; /* Loop index */
1229 0 : intn status = 0; /* routine return status variable */
1230 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1231 :
1232 : int32 fid; /* HDF-EOS file ID */
1233 : int32 sdInterfaceID; /* HDF SDS interface ID */
1234 : int32 gdVgrpID; /* Grid root Vgroup ID */
1235 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1236 :
1237 :
1238 : char *metabuf; /* Pointer to structural metadata (SM) */
1239 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1240 : char gridname[80]; /* Grid Name */
1241 : char *utlstr; /* Utility string */
1242 :
1243 : /* Allocate space for utility string */
1244 : /* --------------------------------- */
1245 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1246 0 : if(utlstr == NULL)
1247 : {
1248 0 : HEpush(DFE_NOSPACE,"GDorigininfo", __FILE__, __LINE__);
1249 0 : return(-1);
1250 : }
1251 : /* Check Grid ID */
1252 : /* ------------- */
1253 0 : status = GDchkgdid(gridID, "GDorigininfo",
1254 : &fid, &sdInterfaceID, &gdVgrpID);
1255 :
1256 :
1257 : /* Initialize pixreg code to -1 (in case of error) */
1258 : /* ----------------------------------------------- */
1259 0 : *origincode = -1;
1260 :
1261 0 : if (status == 0)
1262 : {
1263 : /* Set default origin code */
1264 : /* ----------------------- */
1265 0 : *origincode = 0;
1266 :
1267 :
1268 : /* Get grid name */
1269 : /* ------------- */
1270 0 : int gID = gridID % idOffset;
1271 0 : if (gID >= NGRID)
1272 : {
1273 0 : free(utlstr);
1274 0 : return -1;
1275 : }
1276 :
1277 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
1278 :
1279 :
1280 : /* Get pointers to grid structure section within SM */
1281 : /* ------------------------------------------------ */
1282 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1283 : NULL, metaptrs);
1284 :
1285 0 : if(metabuf == NULL)
1286 : {
1287 0 : free(utlstr);
1288 0 : return(-1);
1289 : }
1290 :
1291 :
1292 0 : statmeta = EHgetmetavalue(metaptrs, "GridOrigin", utlstr);
1293 :
1294 0 : if (statmeta == 0)
1295 : {
1296 : /*
1297 : * If "GridOrigin" string found in metadata then convert to
1298 : * numeric origin code (fixed added: Jan 97)
1299 : */
1300 0 : for (i = 0; i < (intn)(sizeof(originNames) / sizeof(originNames[0])); i++)
1301 : {
1302 0 : if (strcmp(utlstr, originNames[i]) == 0)
1303 : {
1304 0 : *origincode = i;
1305 0 : break;
1306 : }
1307 : }
1308 : }
1309 :
1310 0 : free(metabuf);
1311 : }
1312 0 : free(utlstr);
1313 0 : return (status);
1314 : }
1315 :
1316 :
1317 :
1318 :
1319 :
1320 :
1321 : /*----------------------------------------------------------------------------|
1322 : | BEGIN_PROLOG |
1323 : | |
1324 : | FUNCTION: GDpixreginfo |
1325 : | |
1326 : | DESCRIPTION: |
1327 : | |
1328 : | |
1329 : | Return Value Type Units Description |
1330 : | ============ ====== ========= ===================================== |
1331 : | status intn return status (0) SUCCEED, (-1) FAIL |
1332 : | |
1333 : | INPUTS: |
1334 : | gridID int32 Grid structure ID |
1335 : | |
1336 : | |
1337 : | OUTPUTS: |
1338 : | pixregcode int32 Pixel registration code |
1339 : | |
1340 : | |
1341 : | OUTPUTS: |
1342 : | None |
1343 : | |
1344 : | NOTES: |
1345 : | |
1346 : | |
1347 : | Date Programmer Description |
1348 : | ====== ============ ================================================= |
1349 : | Jun 96 Joel Gales Original Programmer |
1350 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1351 : | |
1352 : | END_PROLOG |
1353 : -----------------------------------------------------------------------------*/
1354 : intn
1355 0 : GDpixreginfo(int32 gridID, int32 * pixregcode)
1356 : {
1357 : intn i; /* Loop index */
1358 0 : intn status = 0; /* routine return status variable */
1359 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1360 :
1361 : int32 fid; /* HDF-EOS file ID */
1362 : int32 sdInterfaceID; /* HDF SDS interface ID */
1363 : int32 gdVgrpID; /* Grid root Vgroup ID */
1364 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1365 :
1366 :
1367 : char *metabuf; /* Pointer to structural metadata (SM) */
1368 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1369 : char gridname[80]; /* Grid Name */
1370 : char *utlstr; /* Utility string */
1371 :
1372 : /* Allocate space for utility string */
1373 : /* --------------------------------- */
1374 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1375 0 : if(utlstr == NULL)
1376 : {
1377 0 : HEpush(DFE_NOSPACE,"GDpixreginfo", __FILE__, __LINE__);
1378 0 : return(-1);
1379 : }
1380 : /* Check Grid ID */
1381 0 : status = GDchkgdid(gridID, "GDpixreginfo",
1382 : &fid, &sdInterfaceID, &gdVgrpID);
1383 :
1384 : /* Initialize pixreg code to -1 (in case of error) */
1385 0 : *pixregcode = -1;
1386 :
1387 0 : if (status == 0)
1388 : {
1389 : /* Set default pixreg code */
1390 0 : *pixregcode = 0;
1391 :
1392 : /* Get grid name */
1393 0 : int gID = gridID % idOffset;
1394 0 : if (gID >= NGRID)
1395 : {
1396 0 : free(utlstr);
1397 0 : return -1;
1398 : }
1399 :
1400 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
1401 :
1402 : /* Get pointers to grid structure section within SM */
1403 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1404 : NULL, metaptrs);
1405 :
1406 0 : if(metabuf == NULL)
1407 : {
1408 0 : free(utlstr);
1409 0 : return(-1);
1410 : }
1411 :
1412 :
1413 0 : statmeta = EHgetmetavalue(metaptrs, "PixelRegistration", utlstr);
1414 :
1415 0 : if (statmeta == 0)
1416 : {
1417 : /*
1418 : * If "PixelRegistration" string found in metadata then convert
1419 : * to numeric origin code (fixed added: Jan 97)
1420 : */
1421 :
1422 0 : for (i = 0; i < (intn)(sizeof(pixregNames) / sizeof(pixregNames[0])); i++)
1423 : {
1424 0 : if (strcmp(utlstr, pixregNames[i]) == 0)
1425 : {
1426 0 : *pixregcode = i;
1427 0 : break;
1428 : }
1429 : }
1430 : }
1431 0 : free(metabuf);
1432 : }
1433 0 : free(utlstr);
1434 0 : return (status);
1435 : }
1436 :
1437 :
1438 :
1439 : /*----------------------------------------------------------------------------|
1440 : | BEGIN_PROLOG |
1441 : | |
1442 : | FUNCTION: GDcompinfo |
1443 : | |
1444 : | DESCRIPTION: |
1445 : | |
1446 : | |
1447 : | Return Value Type Units Description |
1448 : | ============ ====== ========= ===================================== |
1449 : | status intn |
1450 : | |
1451 : | INPUTS: |
1452 : | gridID int32 |
1453 : | compcode int32 |
1454 : | compparm intn |
1455 : | |
1456 : | |
1457 : | OUTPUTS: |
1458 : | None |
1459 : | |
1460 : | NOTES: |
1461 : | |
1462 : | |
1463 : | Date Programmer Description |
1464 : | ====== ============ ================================================= |
1465 : | Oct 96 Joel Gales Original Programmer |
1466 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1467 : | |
1468 : | END_PROLOG |
1469 : -----------------------------------------------------------------------------*/
1470 : intn
1471 0 : GDcompinfo(int32 gridID, const char *fieldname, int32 * compcode, intn compparm[])
1472 : {
1473 : intn i; /* Loop index */
1474 0 : intn status = 0; /* routine return status variable */
1475 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1476 :
1477 : int32 fid; /* HDF-EOS file ID */
1478 : int32 sdInterfaceID; /* HDF SDS interface ID */
1479 : int32 gdVgrpID; /* Grid root Vgroup ID */
1480 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1481 :
1482 :
1483 : char *metabuf; /* Pointer to structural metadata (SM) */
1484 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1485 : char gridname[80]; /* Grid Name */
1486 : char *utlstr;/* Utility string */
1487 :
1488 : /* Allocate space for utility string */
1489 : /* --------------------------------- */
1490 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1491 0 : if(utlstr == NULL)
1492 : {
1493 0 : HEpush(DFE_NOSPACE,"GDcompinfo", __FILE__, __LINE__);
1494 0 : return(-1);
1495 : }
1496 : /* Check Grid ID */
1497 0 : status = GDchkgdid(gridID, "GDcompinfo", &fid, &sdInterfaceID, &gdVgrpID);
1498 :
1499 :
1500 0 : if (status == 0)
1501 : {
1502 : /* Get grid name */
1503 0 : int gID = gridID % idOffset;
1504 0 : if (gID >= NGRID)
1505 : {
1506 0 : free(utlstr);
1507 0 : return -1;
1508 : }
1509 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
1510 :
1511 : /* Get pointers to "DataField" section within SM */
1512 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1513 : "DataField", metaptrs);
1514 0 : if(metabuf == NULL)
1515 : {
1516 0 : free(utlstr);
1517 0 : return(-1);
1518 : }
1519 :
1520 :
1521 : /* Search for field */
1522 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
1523 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1524 :
1525 :
1526 : /* If field found and user wants compression code ... */
1527 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1528 : {
1529 0 : if (compcode != NULL)
1530 : {
1531 : /* Set endptr at end of field's definition entry */
1532 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
1533 :
1534 : /* Get compression type */
1535 0 : statmeta = EHgetmetavalue(metaptrs, "CompressionType", utlstr);
1536 :
1537 : /*
1538 : * Default is no compression if "CompressionType" string not
1539 : * in metadata
1540 : */
1541 0 : *compcode = HDFE_COMP_NONE;
1542 :
1543 : /* If compression code is found ... */
1544 0 : if (statmeta == 0)
1545 : {
1546 : /* Loop through compression types until match */
1547 0 : for (i = 0; i < (intn)(sizeof(HDFcomp) / sizeof(HDFcomp[0])); i++)
1548 : {
1549 0 : if (strcmp(utlstr, HDFcomp[i]) == 0)
1550 : {
1551 0 : *compcode = i;
1552 0 : break;
1553 : }
1554 : }
1555 : }
1556 : }
1557 :
1558 : /* If user wants compression parameters ... */
1559 0 : if (compparm != NULL && compcode != NULL)
1560 : {
1561 : /* Initialize to zero */
1562 0 : for (i = 0; i < 4; i++)
1563 : {
1564 0 : compparm[i] = 0;
1565 : }
1566 :
1567 : /*
1568 : * Get compression parameters if NBIT or DEFLATE compression
1569 : */
1570 0 : if (*compcode == HDFE_COMP_NBIT)
1571 : {
1572 : statmeta =
1573 0 : EHgetmetavalue(metaptrs, "CompressionParams", utlstr);
1574 0 : if (statmeta == 0)
1575 : {
1576 0 : sscanf(utlstr, "(%d,%d,%d,%d)",
1577 : &compparm[0], &compparm[1],
1578 : &compparm[2], &compparm[3]);
1579 : }
1580 : else
1581 : {
1582 0 : status = -1;
1583 0 : HEpush(DFE_GENAPP, "GDcompinfo", __FILE__, __LINE__);
1584 0 : HEreport(
1585 : "\"CompressionParams\" string not found in metadata.\n");
1586 : }
1587 : }
1588 0 : else if (*compcode == HDFE_COMP_DEFLATE)
1589 : {
1590 : statmeta =
1591 0 : EHgetmetavalue(metaptrs, "DeflateLevel", utlstr);
1592 0 : if (statmeta == 0)
1593 : {
1594 0 : sscanf(utlstr, "%d", &compparm[0]);
1595 : }
1596 : else
1597 : {
1598 0 : status = -1;
1599 0 : HEpush(DFE_GENAPP, "GDcompinfo", __FILE__, __LINE__);
1600 0 : HEreport(
1601 : "\"DeflateLevel\" string not found in metadata.\n");
1602 : }
1603 : }
1604 : }
1605 : }
1606 : else
1607 : {
1608 0 : HEpush(DFE_GENAPP, "GDcompinfo", __FILE__, __LINE__);
1609 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
1610 : }
1611 :
1612 0 : free(metabuf);
1613 :
1614 : }
1615 0 : free(utlstr);
1616 0 : return (status);
1617 : }
1618 :
1619 :
1620 :
1621 :
1622 :
1623 :
1624 : /*----------------------------------------------------------------------------|
1625 : | BEGIN_PROLOG |
1626 : | |
1627 : | FUNCTION: GDfieldinfo |
1628 : | |
1629 : | DESCRIPTION: Retrieve information about a specific geolocation or data |
1630 : | field in the grid. |
1631 : | |
1632 : | |
1633 : | Return Value Type Units Description |
1634 : | ============ ====== ========= ===================================== |
1635 : | status intn return status (0) SUCCEED, (-1) FAIL |
1636 : | |
1637 : | INPUTS: |
1638 : | gridID int32 grid structure id |
1639 : | fieldname char name of field |
1640 : | |
1641 : | |
1642 : | OUTPUTS: |
1643 : | rank int32 rank of field (# of dims) |
1644 : | dims int32 field dimensions |
1645 : | numbertype int32 field number type |
1646 : | dimlist char field dimension list |
1647 : | |
1648 : | |
1649 : | OUTPUTS: |
1650 : | None |
1651 : | |
1652 : | NOTES: |
1653 : | |
1654 : | |
1655 : | Date Programmer Description |
1656 : | ====== ============ ================================================= |
1657 : | Jun 96 Joel Gales Original Programmer |
1658 : | Aug 96 Joel Gales Make metadata ODL compliant |
1659 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1660 : | Feb 99 Abe Taaheri Changed memcpy to memmove to avoid overlapping |
1661 : | problem when copying strings |
1662 : | |
1663 : | END_PROLOG |
1664 : -----------------------------------------------------------------------------*/
1665 : intn
1666 0 : GDfieldinfo(int32 gridID, const char *fieldname, int32 * rank, int32 dims[],
1667 : int32 * numbertype, char *dimlist)
1668 :
1669 : {
1670 : intn i; /* Loop index */
1671 : intn status; /* routine return status variable */
1672 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1673 :
1674 : int32 fid; /* HDF-EOS file ID */
1675 : int32 sdInterfaceID; /* HDF SDS interface ID */
1676 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1677 0 : int32 ndims = 0; /* Number of dimensions */
1678 : int32 slen[8]; /* Length of each entry in parsed string */
1679 : int32 dum; /* Dummy variable */
1680 : int32 xdim; /* X dim size */
1681 : int32 ydim; /* Y dim size */
1682 : int32 sdid; /* SDS id */
1683 :
1684 : char *metabuf; /* Pointer to structural metadata (SM) */
1685 : char *metaptrs[2]; /* Pointers to begin and end of SM section */
1686 : char gridname[80]; /* Grid Name */
1687 : char *utlstr; /* Utility string */
1688 : char *ptr[8]; /* String pointers for parsed string */
1689 : char dimstr[64]; /* Individual dimension entry string */
1690 :
1691 :
1692 : /* Allocate space for utility string */
1693 : /* --------------------------------- */
1694 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1695 0 : if(utlstr == NULL)
1696 : {
1697 0 : HEpush(DFE_NOSPACE,"GDfieldinfo", __FILE__, __LINE__);
1698 0 : return(-1);
1699 : }
1700 0 : *rank = -1;
1701 0 : *numbertype = -1;
1702 :
1703 0 : status = GDchkgdid(gridID, "GDfieldinfo", &fid, &sdInterfaceID, &dum);
1704 :
1705 0 : if (status == 0)
1706 : {
1707 0 : int gID = gridID % idOffset;
1708 0 : if (gID >= NGRID)
1709 : {
1710 0 : free(utlstr);
1711 0 : return -1;
1712 : }
1713 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
1714 :
1715 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1716 : "DataField", metaptrs);
1717 0 : if(metabuf == NULL)
1718 : {
1719 0 : free(utlstr);
1720 0 : return(-1);
1721 : }
1722 :
1723 :
1724 : /* Search for field */
1725 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
1726 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1727 :
1728 : /* If field found ... */
1729 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1730 : {
1731 :
1732 : /* Set endptr at end of dimension definition entry */
1733 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
1734 :
1735 : /* Get DataType string */
1736 0 : statmeta = EHgetmetavalue(metaptrs, "DataType", utlstr);
1737 :
1738 : /* Convert to numbertype code */
1739 0 : if (statmeta == 0)
1740 0 : *numbertype = EHnumstr(utlstr);
1741 : else
1742 : {
1743 0 : status = -1;
1744 0 : HEpush(DFE_GENAPP, "GDfieldinfo", __FILE__, __LINE__);
1745 0 : HEreport("\"DataType\" string not found in metadata.\n");
1746 : }
1747 :
1748 : /*
1749 : * Get DimList string and trim off leading and trailing parens
1750 : * "()"
1751 : */
1752 0 : statmeta = EHgetmetavalue(metaptrs, "DimList", utlstr);
1753 :
1754 0 : if (statmeta == 0)
1755 : {
1756 0 : memmove(utlstr, utlstr + 1, strlen(utlstr) - 2);
1757 0 : utlstr[strlen(utlstr) - 2] = 0;
1758 :
1759 : /* Parse trimmed DimList string and get rank */
1760 0 : ndims = EHparsestr(utlstr, ',', ptr, slen);
1761 0 : *rank = ndims;
1762 : }
1763 : else
1764 : {
1765 0 : status = -1;
1766 0 : HEpush(DFE_GENAPP, "GDfieldinfo", __FILE__, __LINE__);
1767 0 : HEreport("\"DimList\" string not found in metadata.\n");
1768 : }
1769 :
1770 :
1771 0 : if (status == 0)
1772 : {
1773 0 : status = GDgridinfo(gridID, &xdim, &ydim, NULL, NULL);
1774 :
1775 0 : for (i = 0; i < ndims; i++)
1776 : {
1777 0 : memcpy(dimstr, ptr[i] + 1, slen[i] - 2);
1778 0 : dimstr[slen[i] - 2] = 0;
1779 :
1780 0 : if (strcmp(dimstr, "XDim") == 0)
1781 : {
1782 0 : dims[i] = xdim;
1783 : }
1784 0 : else if (strcmp(dimstr, "YDim") == 0)
1785 : {
1786 0 : dims[i] = ydim;
1787 : }
1788 : else
1789 : {
1790 0 : dims[i] = GDdiminfo(gridID, dimstr);
1791 : }
1792 :
1793 :
1794 0 : if (dimlist != NULL)
1795 : {
1796 0 : if (i == 0)
1797 : {
1798 0 : dimlist[0] = 0;
1799 : }
1800 :
1801 0 : if (i > 0)
1802 : {
1803 0 : strcat(dimlist, ",");
1804 : }
1805 0 : strcat(dimlist, dimstr);
1806 : }
1807 : }
1808 :
1809 :
1810 0 : if (dims[0] == 0)
1811 : {
1812 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname,
1813 : &sdid, &dum, &dum, &dum, dims,
1814 : &dum);
1815 : }
1816 : }
1817 : }
1818 :
1819 0 : free(metabuf);
1820 : }
1821 :
1822 0 : if (*rank == -1)
1823 : {
1824 0 : status = -1;
1825 :
1826 0 : HEpush(DFE_GENAPP, "GDfieldinfo", __FILE__, __LINE__);
1827 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
1828 : }
1829 0 : free(utlstr);
1830 0 : return (status);
1831 : }
1832 :
1833 :
1834 :
1835 : /*----------------------------------------------------------------------------|
1836 : | BEGIN_PROLOG |
1837 : | |
1838 : | FUNCTION: GDSDfldsrch |
1839 : | |
1840 : | DESCRIPTION: Retrieves information from SDS fields |
1841 : | |
1842 : | |
1843 : | Return Value Type Units Description |
1844 : | ============ ====== ========= ===================================== |
1845 : | status intn return status (0) SUCCEED, (-1) FAIL |
1846 : | |
1847 : | INPUTS: |
1848 : | gridID int32 grid structure ID |
1849 : | sdInterfaceID int32 SD interface ID |
1850 : | fieldname char field name |
1851 : | |
1852 : | |
1853 : | OUTPUTS: |
1854 : | sdid int32 SD element ID |
1855 : | rankSDS int32 Rank of SDS |
1856 : | rankFld int32 True rank of field (merging) |
1857 : | offset int32 Offset of field within merged field |
1858 : | dims int32 Dimensions of field |
1859 : | solo int32 Solo field flag |
1860 : | |
1861 : | NOTES: |
1862 : | |
1863 : | |
1864 : | Date Programmer Description |
1865 : | ====== ============ ================================================= |
1866 : | Jun 96 Joel Gales Original Programmer |
1867 : | Aug 96 Joel Gales Make metadata ODL compliant |
1868 : | |
1869 : | END_PROLOG |
1870 : -----------------------------------------------------------------------------*/
1871 : static intn
1872 0 : GDSDfldsrch(int32 gridID, int32 sdInterfaceID, const char *fieldname,
1873 : int32 * sdid, int32 * rankSDS, int32 * rankFld, int32 * offset,
1874 : int32 dims[], int32 * solo)
1875 : {
1876 : intn i; /* Loop index */
1877 0 : intn status = -1;/* routine return status variable */
1878 :
1879 : int32 gID; /* GridID - offset */
1880 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
1881 : int32 dum; /* Dummy variable */
1882 : int32 dums[128]; /* Dummy array */
1883 : int32 attrIndex; /* Attribute l_index */
1884 :
1885 : char name[2048]; /* Merged-Field Names */
1886 : char gridname[80]; /* Grid Name */
1887 : char *utlstr;/* Utility string */
1888 : char *metabuf; /* Pointer to structural metadata (SM) */
1889 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1890 : #ifdef broken_logic
1891 : char *oldmetaptr; /* Pointer within SM section */
1892 : char *metaptr; /* Pointer within SM section */
1893 : #endif
1894 :
1895 : /* Allocate space for utility string */
1896 : /* --------------------------------- */
1897 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1898 0 : if(utlstr == NULL)
1899 : {
1900 0 : HEpush(DFE_NOSPACE,"GDSDfldsrch", __FILE__, __LINE__);
1901 0 : return(-1);
1902 : }
1903 : /* Set solo flag to 0 (no) */
1904 : /* ----------------------- */
1905 0 : *solo = 0;
1906 :
1907 :
1908 : /* Compute "reduced" grid ID */
1909 : /* ------------------------- */
1910 0 : gID = gridID % idOffset;
1911 0 : if (gID >= NGRID)
1912 : {
1913 0 : free(utlstr);
1914 0 : return -1;
1915 : }
1916 :
1917 : /* Loop through all SDSs in grid */
1918 : /* ----------------------------- */
1919 0 : for (i = 0; i < GDXGrid[gID].nSDS; i++)
1920 : {
1921 : /* If active SDS ... */
1922 : /* ----------------- */
1923 0 : if (GDXGrid[gID].sdsID[i] != 0)
1924 : {
1925 : /* Get SDS ID, name, rankSDS, and dimensions */
1926 : /* ----------------------------------------- */
1927 0 : *sdid = GDXGrid[gID].sdsID[i];
1928 0 : SDgetinfo(*sdid, name, rankSDS, dims, &dum, &dum);
1929 0 : *rankFld = *rankSDS;
1930 :
1931 :
1932 : /* If merged field ... */
1933 : /* ------------------- */
1934 0 : if (strstr(name, "MRGFLD_") == &name[0])
1935 : {
1936 : /* Get grid name */
1937 : /* ------------- */
1938 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
1939 :
1940 :
1941 : /* Get pointers to "MergedFields" section within SM */
1942 : /* ------------------------------------------------ */
1943 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
1944 : "MergedFields", metaptrs);
1945 0 : if(metabuf == NULL)
1946 : {
1947 0 : free(utlstr);
1948 0 : return(-1);
1949 : }
1950 :
1951 : #ifdef broken_logic
1952 : /* Initialize metaptr to beg. of section */
1953 : /* ------------------------------------- */
1954 : metaptr = metaptrs[0];
1955 :
1956 :
1957 : /* Store metaptr in order to recover */
1958 : /* --------------------------------- */
1959 : oldmetaptr = metaptr;
1960 :
1961 :
1962 : /* Search for Merged field name */
1963 : /* ---------------------------- */
1964 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "MergedFieldName=\"",
1965 : name, "\"\n");
1966 : metaptr = strstr(metaptr, utlstr);
1967 :
1968 :
1969 : /* If not found check for old metadata */
1970 : /* ----------------------------------- */
1971 : if (metaptr == NULL)
1972 : {
1973 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "OBJECT=\"", name, "\"\n");
1974 : metaptr = strstr(oldmetaptr, utlstr);
1975 : }
1976 : #endif
1977 :
1978 : /* Get field list and strip off leading and trailing quotes */
1979 : /* -------------------------------------------------------- */
1980 0 : EHgetmetavalue(metaptrs, "FieldList", name);
1981 0 : memmove(name, name + 1, strlen(name) - 2);
1982 0 : name[strlen(name) - 2] = 0;
1983 :
1984 :
1985 : /* Search for desired field within merged field list */
1986 : /* ------------------------------------------------- */
1987 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"");
1988 0 : dum = EHstrwithin(utlstr, name, ',');
1989 :
1990 0 : free(metabuf);
1991 : }
1992 : else
1993 : {
1994 : /* If solo (unmerged) check if SDS name matches fieldname */
1995 : /* ------------------------------------------------------ */
1996 0 : dum = EHstrwithin(fieldname, name, ',');
1997 0 : if (dum != -1)
1998 : {
1999 0 : *solo = 1;
2000 0 : *offset = 0;
2001 : }
2002 : }
2003 :
2004 :
2005 :
2006 : /* If field found ... */
2007 : /* ------------------ */
2008 0 : if (dum != -1)
2009 : {
2010 0 : status = 0;
2011 :
2012 : /* If merged field ... */
2013 : /* ------------------- */
2014 0 : if (*solo == 0)
2015 : {
2016 : /* Get "Field Offsets" SDS attribute l_index */
2017 : /* --------------------------------------- */
2018 0 : attrIndex = SDfindattr(*sdid, "Field Offsets");
2019 :
2020 : /*
2021 : * If attribute exists then get offset of desired field
2022 : * within merged field
2023 : */
2024 0 : if (attrIndex != -1)
2025 : {
2026 0 : SDreadattr(*sdid, attrIndex, (VOIDP) dums);
2027 0 : *offset = dums[dum];
2028 : }
2029 :
2030 :
2031 : /* Get "Field Dims" SDS attribute l_index */
2032 : /* ------------------------------------ */
2033 0 : attrIndex = SDfindattr(*sdid, "Field Dims");
2034 :
2035 : /*
2036 : * If attribute exists then get 0th dimension of desired
2037 : * field within merged field
2038 : */
2039 0 : if (attrIndex != -1)
2040 : {
2041 0 : SDreadattr(*sdid, attrIndex, (VOIDP) dums);
2042 0 : dims[0] = dums[dum];
2043 :
2044 : /* If this dimension = 1 then field is really 2 dim */
2045 : /* ------------------------------------------------ */
2046 0 : if (dums[dum] == 1)
2047 : {
2048 0 : *rankFld = 2;
2049 : }
2050 : }
2051 : }
2052 :
2053 :
2054 : /* Break out of SDS loop */
2055 : /* --------------------- */
2056 0 : break;
2057 : } /* End of found field section */
2058 : }
2059 : else
2060 : {
2061 : /* First non-active SDS signifies no more, break out of SDS loop */
2062 : /* ------------------------------------------------------------- */
2063 0 : break;
2064 : }
2065 : }
2066 0 : free(utlstr);
2067 0 : return (status);
2068 : }
2069 :
2070 :
2071 :
2072 :
2073 : /*----------------------------------------------------------------------------|
2074 : | BEGIN_PROLOG |
2075 : | |
2076 : | FUNCTION: GDwrrdfield |
2077 : | |
2078 : | DESCRIPTION: Writes/Reads fields |
2079 : | |
2080 : | |
2081 : | Return Value Type Units Description |
2082 : | ============ ====== ========= ===================================== |
2083 : | status intn return status (0) SUCCEED, (-1) FAIL |
2084 : | |
2085 : | INPUTS: |
2086 : | gridID int32 grid structure ID |
2087 : | fieldname char fieldname |
2088 : | code char Write/Read code (w/r) |
2089 : | start int32 start array |
2090 : | stride int32 stride array |
2091 : | edge int32 edge array |
2092 : | datbuf void data buffer for read |
2093 : | |
2094 : | |
2095 : | OUTPUTS: |
2096 : | datbuf void data buffer for write |
2097 : | |
2098 : | |
2099 : | NOTES: |
2100 : | |
2101 : | |
2102 : | Date Programmer Description |
2103 : | ====== ============ ================================================= |
2104 : | Jun 96 Joel Gales Original Programmer |
2105 : | Feb 97 Joel Gales Stride = 1 HDF compression workaround |
2106 : | |
2107 : | END_PROLOG |
2108 : -----------------------------------------------------------------------------*/
2109 : static intn
2110 0 : GDwrrdfield(int32 gridID, const char *fieldname, const char *code,
2111 : int32 start[], int32 stride[], int32 edge[], VOIDP datbuf)
2112 :
2113 : {
2114 : intn i; /* Loop index */
2115 0 : intn status = 0; /* routine return status variable */
2116 :
2117 : int32 fid; /* HDF-EOS file ID */
2118 : int32 sdInterfaceID; /* HDF SDS interface ID */
2119 : int32 sdid; /* SDS ID */
2120 : int32 dum; /* Dummy variable */
2121 : int32 rankSDS; /* Rank of SDS */
2122 : int32 rankFld; /* Rank of field */
2123 :
2124 : int32 offset[8]; /* I/O offset (start) */
2125 : int32 incr[8]; /* I/O increment (stride) */
2126 : int32 count[8]; /* I/O count (edge) */
2127 : int32 dims[8]; /* Field/SDS dimensions */
2128 : int32 mrgOffset; /* Merged field offset */
2129 : int32 strideOne; /* Strides = 1 flag */
2130 :
2131 :
2132 : /* Check for valid grid ID */
2133 : /* ----------------------- */
2134 0 : status = GDchkgdid(gridID, "GDwrrdfield", &fid, &sdInterfaceID, &dum);
2135 :
2136 :
2137 0 : if (status == 0)
2138 : {
2139 : /* Check that field exists */
2140 : /* ----------------------- */
2141 0 : status = GDfieldinfo(gridID, fieldname, &rankSDS, dims, &dum, NULL);
2142 :
2143 :
2144 0 : if (status != 0)
2145 : {
2146 0 : HEpush(DFE_GENAPP, "GDwrrdfield", __FILE__, __LINE__);
2147 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
2148 0 : status = -1;
2149 :
2150 : }
2151 :
2152 :
2153 0 : if (status == 0)
2154 : {
2155 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
2156 : &rankSDS, &rankFld, &mrgOffset, dims, &dum);
2157 :
2158 :
2159 : /* Set I/O offset Section */
2160 : /* ---------------------- */
2161 :
2162 : /*
2163 : * If start == NULL (default) set I/O offset of 0th field to
2164 : * offset within merged field (if any) and the rest to 0
2165 : */
2166 0 : if (start == NULL)
2167 : {
2168 0 : for (i = 0; i < rankSDS; i++)
2169 : {
2170 0 : offset[i] = 0;
2171 : }
2172 0 : offset[0] = mrgOffset;
2173 : }
2174 : else
2175 : {
2176 : /*
2177 : * ... otherwise set I/O offset to user values, adjusting the
2178 : * 0th field with the merged field offset (if any)
2179 : */
2180 0 : if (rankFld == rankSDS)
2181 : {
2182 0 : for (i = 0; i < rankSDS; i++)
2183 : {
2184 0 : offset[i] = start[i];
2185 : }
2186 0 : offset[0] += mrgOffset;
2187 : }
2188 : else
2189 : {
2190 : /*
2191 : * If field really 2-dim merged in 3-dim field then set
2192 : * 0th field offset to merge offset and then next two to
2193 : * the user values
2194 : */
2195 0 : for (i = 0; i < rankFld; i++)
2196 : {
2197 0 : offset[i + 1] = start[i];
2198 : }
2199 0 : offset[0] = mrgOffset;
2200 : }
2201 : }
2202 :
2203 :
2204 :
2205 : /* Set I/O stride Section */
2206 : /* ---------------------- */
2207 :
2208 : /*
2209 : * If stride == NULL (default) set I/O stride to 1
2210 : */
2211 0 : if (stride == NULL)
2212 : {
2213 0 : for (i = 0; i < rankSDS; i++)
2214 : {
2215 0 : incr[i] = 1;
2216 : }
2217 : }
2218 : else
2219 : {
2220 : /*
2221 : * ... otherwise set I/O stride to user values
2222 : */
2223 0 : if (rankFld == rankSDS)
2224 : {
2225 0 : for (i = 0; i < rankSDS; i++)
2226 : {
2227 0 : incr[i] = stride[i];
2228 : }
2229 : }
2230 : else
2231 : {
2232 : /*
2233 : * If field really 2-dim merged in 3-dim field then set
2234 : * 0th field stride to 1 and then next two to the user
2235 : * values.
2236 : */
2237 0 : for (i = 0; i < rankFld; i++)
2238 : {
2239 0 : incr[i + 1] = stride[i];
2240 : }
2241 0 : incr[0] = 1;
2242 : }
2243 : }
2244 :
2245 :
2246 :
2247 : /* Set I/O count Section */
2248 : /* --------------------- */
2249 :
2250 : /*
2251 : * If edge == NULL (default) set I/O count to number of remaining
2252 : * entries (dims - start) / increment. Note that 0th field
2253 : * offset corrected for merged field offset (if any).
2254 : */
2255 0 : if (edge == NULL)
2256 : {
2257 0 : for (i = 1; i < rankSDS; i++)
2258 : {
2259 0 : count[i] = (dims[i] - offset[i]) / incr[i];
2260 : }
2261 0 : count[0] = (dims[0] - (offset[0] - mrgOffset)) / incr[0];
2262 : }
2263 : else
2264 : {
2265 : /*
2266 : * ... otherwise set I/O count to user values
2267 : */
2268 0 : if (rankFld == rankSDS)
2269 : {
2270 0 : for (i = 0; i < rankSDS; i++)
2271 : {
2272 0 : count[i] = edge[i];
2273 : }
2274 : }
2275 : else
2276 : {
2277 : /*
2278 : * If field really 2-dim merged in 3-dim field then set
2279 : * 0th field count to 1 and then next two to the user
2280 : * values.
2281 : */
2282 0 : for (i = 0; i < rankFld; i++)
2283 : {
2284 0 : count[i + 1] = edge[i];
2285 : }
2286 0 : count[0] = 1;
2287 : }
2288 : }
2289 :
2290 :
2291 : /* Perform I/O with relevant HDF I/O routine */
2292 : /* ----------------------------------------- */
2293 0 : if (strcmp(code, "w") == 0)
2294 : {
2295 : /* Set strideOne to true (1) */
2296 : /* ------------------------- */
2297 0 : strideOne = 1;
2298 :
2299 :
2300 : /* If incr[i] != 1 set strideOne to false (0) */
2301 : /* ------------------------------------------ */
2302 0 : for (i = 0; i < rankSDS; i++)
2303 : {
2304 0 : if (incr[i] != 1)
2305 : {
2306 0 : strideOne = 0;
2307 0 : break;
2308 : }
2309 : }
2310 :
2311 :
2312 : /*
2313 : * If strideOne is true use NULL parameter for stride. This
2314 : * is a work-around to HDF compression problem
2315 : */
2316 0 : if (strideOne == 1)
2317 : {
2318 0 : status = SDwritedata(sdid, offset, NULL, count,
2319 : (VOIDP) datbuf);
2320 : }
2321 : else
2322 : {
2323 0 : status = SDwritedata(sdid, offset, incr, count,
2324 : (VOIDP) datbuf);
2325 : }
2326 : }
2327 : else
2328 : {
2329 0 : status = SDreaddata(sdid, offset, incr, count,
2330 : (VOIDP) datbuf);
2331 : }
2332 : }
2333 : }
2334 :
2335 0 : return (status);
2336 : }
2337 :
2338 :
2339 : /*----------------------------------------------------------------------------|
2340 : | BEGIN_PROLOG |
2341 : | |
2342 : | FUNCTION: GDreadfield |
2343 : | |
2344 : | DESCRIPTION: Reads data from a grid field. |
2345 : | |
2346 : | |
2347 : | Return Value Type Units Description |
2348 : | ============ ====== ========= ===================================== |
2349 : | status intn return status (0) SUCCEED, (-1) FAIL |
2350 : | |
2351 : | INPUTS: |
2352 : | gridID int32 grid structure ID |
2353 : | fieldname char fieldname |
2354 : | start int32 start array |
2355 : | stride int32 stride array |
2356 : | edge int32 edge array |
2357 : | buffer void data buffer for read |
2358 : | |
2359 : | |
2360 : | OUTPUTS: |
2361 : | None |
2362 : | |
2363 : | NOTES: |
2364 : | |
2365 : | |
2366 : | Date Programmer Description |
2367 : | ====== ============ ================================================= |
2368 : | Jun 96 Joel Gales Original Programmer |
2369 : | |
2370 : | END_PROLOG |
2371 : -----------------------------------------------------------------------------*/
2372 : intn
2373 0 : GDreadfield(int32 gridID, const char *fieldname,
2374 : int32 start[], int32 stride[], int32 edge[], VOIDP buffer)
2375 :
2376 : {
2377 0 : intn status = 0; /* routine return status variable */
2378 :
2379 0 : status = GDwrrdfield(gridID, fieldname, "r", start, stride, edge,
2380 : buffer);
2381 0 : return (status);
2382 : }
2383 :
2384 :
2385 :
2386 :
2387 : /*----------------------------------------------------------------------------|
2388 : | BEGIN_PROLOG |
2389 : | |
2390 : | FUNCTION: GDwrrdattr |
2391 : | |
2392 : | DESCRIPTION: |
2393 : | |
2394 : | |
2395 : | Return Value Type Units Description |
2396 : | ============ ====== ========= ===================================== |
2397 : | status intn return status (0) SUCCEED, (-1) FAIL |
2398 : | |
2399 : | INPUTS: |
2400 : | gridID int32 grid structure ID |
2401 : | attrname char attribute name |
2402 : | numbertype int32 attribute HDF numbertype |
2403 : | count int32 Number of attribute elements |
2404 : | wrcode char Read/Write Code "w/r" |
2405 : | datbuf void I/O buffer |
2406 : | |
2407 : | OUTPUTS: |
2408 : | datbuf |
2409 : | |
2410 : | NOTES: |
2411 : | |
2412 : | |
2413 : | Date Programmer Description |
2414 : | ====== ============ ================================================= |
2415 : | Jun 96 Joel Gales Original Programmer |
2416 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
2417 : | |
2418 : | END_PROLOG |
2419 : -----------------------------------------------------------------------------*/
2420 : static intn
2421 0 : GDwrrdattr(int32 gridID, const char *attrname, int32 numbertype, int32 count,
2422 : const char *wrcode, VOIDP datbuf)
2423 :
2424 : {
2425 : intn status; /* routine return status variable */
2426 :
2427 : int32 fid; /* HDF-EOS file ID */
2428 : int32 attrVgrpID; /* Grid attribute ID */
2429 : int32 dum; /* dummy variable */
2430 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2431 :
2432 :
2433 : /* Check Grid id */
2434 0 : status = GDchkgdid(gridID, "GDwrrdattr", &fid, &dum, &dum);
2435 :
2436 0 : if (status == 0)
2437 : {
2438 : /* Perform Attribute I/O */
2439 : /* --------------------- */
2440 0 : int gID = gridID % idOffset;
2441 0 : if (gID >= NGRID)
2442 : {
2443 0 : return -1;
2444 : }
2445 0 : attrVgrpID = GDXGrid[gID].VIDTable[1];
2446 0 : status = EHattr(fid, attrVgrpID, attrname, numbertype, count,
2447 : wrcode, datbuf);
2448 : }
2449 0 : return (status);
2450 : }
2451 :
2452 : /*----------------------------------------------------------------------------|
2453 : | BEGIN_PROLOG |
2454 : | |
2455 : | FUNCTION: GDreadattr |
2456 : | |
2457 : | DESCRIPTION: Reads attribute from a grid. |
2458 : | |
2459 : | |
2460 : | Return Value Type Units Description |
2461 : | ============ ====== ========= ===================================== |
2462 : | status intn return status (0) SUCCEED, (-1) FAIL |
2463 : | |
2464 : | INPUTS: |
2465 : | gridID int32 grid structure ID |
2466 : | attrname char attribute name |
2467 : | |
2468 : | OUTPUTS: |
2469 : | datbuf void I/O buffer |
2470 : | |
2471 : | NOTES: |
2472 : | |
2473 : | |
2474 : | Date Programmer Description |
2475 : | ====== ============ ================================================= |
2476 : | Jun 96 Joel Gales Original Programmer |
2477 : | |
2478 : | END_PROLOG |
2479 : -----------------------------------------------------------------------------*/
2480 : intn
2481 0 : GDreadattr(int32 gridID, const char *attrname, VOIDP datbuf)
2482 : {
2483 0 : intn status = 0; /* routine return status variable */
2484 0 : int32 dum = 0; /* dummy variable */
2485 :
2486 : /* Call GDwrrdattr routine to read attribute */
2487 : /* ----------------------------------------- */
2488 0 : status = GDwrrdattr(gridID, attrname, dum, dum, "r", datbuf);
2489 :
2490 0 : return (status);
2491 : }
2492 :
2493 :
2494 :
2495 :
2496 :
2497 : /*----------------------------------------------------------------------------|
2498 : | BEGIN_PROLOG |
2499 : | |
2500 : | FUNCTION: GDattrinfo |
2501 : | |
2502 : | DESCRIPTION: |
2503 : | |
2504 : | |
2505 : | Return Value Type Units Description |
2506 : | ============ ====== ========= ===================================== |
2507 : | status intn return status (0) SUCCEED, (-1) FAIL |
2508 : | |
2509 : | INPUTS: |
2510 : | gridID int32 grid structure ID |
2511 : | attrname char attribute name |
2512 : | |
2513 : | OUTPUTS: |
2514 : | numbertype int32 attribute HDF numbertype |
2515 : | count int32 Number of attribute elements |
2516 : | |
2517 : | |
2518 : | OUTPUTS: |
2519 : | None |
2520 : | |
2521 : | NOTES: |
2522 : | |
2523 : | |
2524 : | Date Programmer Description |
2525 : | ====== ============ ================================================= |
2526 : | Jun 96 Joel Gales Original Programmer |
2527 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
2528 : | |
2529 : | END_PROLOG |
2530 : -----------------------------------------------------------------------------*/
2531 : intn
2532 0 : GDattrinfo(int32 gridID, const char *attrname, int32 * numbertype, int32 * count)
2533 : {
2534 0 : intn status = 0; /* routine return status variable */
2535 :
2536 : int32 fid; /* HDF-EOS file ID */
2537 : int32 attrVgrpID; /* Grid attribute ID */
2538 : int32 dum; /* dummy variable */
2539 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2540 :
2541 0 : status = GDchkgdid(gridID, "GDattrinfo", &fid, &dum, &dum);
2542 :
2543 0 : int gID = gridID % idOffset;
2544 0 : if (gID >= NGRID)
2545 : {
2546 0 : return -1;
2547 : }
2548 0 : attrVgrpID = GDXGrid[gID].VIDTable[1];
2549 :
2550 0 : status = EHattrinfo(fid, attrVgrpID, attrname, numbertype,
2551 : count);
2552 :
2553 0 : return (status);
2554 : }
2555 :
2556 :
2557 :
2558 :
2559 :
2560 :
2561 : /*----------------------------------------------------------------------------|
2562 : | BEGIN_PROLOG |
2563 : | |
2564 : | FUNCTION: GDinqattrs |
2565 : | |
2566 : | DESCRIPTION: |
2567 : | |
2568 : | |
2569 : | Return Value Type Units Description |
2570 : | ============ ====== ========= ===================================== |
2571 : | nattr int32 Number of attributes in swath struct |
2572 : | |
2573 : | INPUTS: |
2574 : | grid ID int32 grid structure ID |
2575 : | |
2576 : | OUTPUTS: |
2577 : | attrnames char Attribute names in swath struct |
2578 : | (Comma-separated list) |
2579 : | strbufsize int32 Attributes name list string length |
2580 : | |
2581 : | OUTPUTS: |
2582 : | None |
2583 : | |
2584 : | NOTES: |
2585 : | |
2586 : | |
2587 : | Date Programmer Description |
2588 : | ====== ============ ================================================= |
2589 : | Jun 96 Joel Gales Original Programmer |
2590 : | Oct 96 Joel Gales Initialize nattr |
2591 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
2592 : | |
2593 : | END_PROLOG |
2594 : -----------------------------------------------------------------------------*/
2595 : int32
2596 0 : GDinqattrs(int32 gridID, char *attrnames, int32 * strbufsize)
2597 : {
2598 : intn status; /* routine return status variable */
2599 :
2600 : int32 fid; /* HDF-EOS file ID */
2601 : int32 attrVgrpID; /* Grid attribute ID */
2602 : int32 dum; /* dummy variable */
2603 0 : int32 nattr = 0; /* Number of attributes */
2604 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2605 :
2606 :
2607 : /* Check Grid id */
2608 0 : status = GDchkgdid(gridID, "GDinqattrs", &fid, &dum, &dum);
2609 :
2610 0 : if (status == 0)
2611 : {
2612 0 : int gID = gridID % idOffset;
2613 0 : if (gID >= NGRID)
2614 : {
2615 0 : return -1;
2616 : }
2617 0 : attrVgrpID = GDXGrid[gID].VIDTable[1];
2618 0 : nattr = EHattrcat(fid, attrVgrpID, attrnames, strbufsize);
2619 : }
2620 :
2621 0 : return (nattr);
2622 : }
2623 :
2624 :
2625 :
2626 :
2627 :
2628 :
2629 : #define REMQUOTE(x) do { \
2630 : char* l_x = x; \
2631 : const size_t l_x_len = strlen(l_x); \
2632 : if (l_x_len >= 2 && l_x[0] == '"' && l_x[l_x_len - 1] == '"') {\
2633 : memmove(l_x, l_x + 1, l_x_len - 2); \
2634 : l_x[l_x_len - 2] = 0; \
2635 : } \
2636 : } while(0)
2637 :
2638 :
2639 : /*----------------------------------------------------------------------------|
2640 : | BEGIN_PROLOG |
2641 : | |
2642 : | FUNCTION: GDinqdims |
2643 : | |
2644 : | DESCRIPTION: Retrieve information about all dimensions defined in a grid. |
2645 : | |
2646 : | |
2647 : | Return Value Type Units Description |
2648 : | ============ ====== ========= ===================================== |
2649 : | nDim int32 Number of defined dimensions |
2650 : | |
2651 : | INPUTS: |
2652 : | gridID int32 grid structure ID |
2653 : | |
2654 : | OUTPUTS: |
2655 : | dimnames char Dimension names (comma-separated) |
2656 : | dims int32 Dimension values |
2657 : | |
2658 : | |
2659 : | OUTPUTS: |
2660 : | None |
2661 : | |
2662 : | NOTES: |
2663 : | |
2664 : | |
2665 : | Date Programmer Description |
2666 : | ====== ============ ================================================= |
2667 : | Jun 96 Joel Gales Original Programmer |
2668 : | Aug 96 Joel Gales Make metadata ODL compliant |
2669 : | Feb 97 Joel Gales Set nDim to -1 if status = -1 |
2670 : | |
2671 : | END_PROLOG |
2672 : -----------------------------------------------------------------------------*/
2673 : int32
2674 0 : GDinqdims(int32 gridID, char *dimnames, int32 dims[])
2675 : {
2676 : intn status; /* routine return status variable */
2677 :
2678 : int32 fid; /* HDF-EOS file ID */
2679 : int32 sdInterfaceID; /* HDF SDS interface ID */
2680 : int32 gdVgrpID; /* Grid root Vgroup ID */
2681 : int32 size; /* Dimension size */
2682 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2683 0 : int32 nDim = 0; /* Number of dimensions */
2684 :
2685 : char *metabuf; /* Pointer to structural metadata (SM) */
2686 : char *metaptrs[2];/* Pointers to begin and end of SM section */
2687 : char gridname[80]; /* Grid Name */
2688 : char *utlstr;/* Utility string */
2689 :
2690 : /* Allocate space for utility string */
2691 : /* --------------------------------- */
2692 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2693 0 : if(utlstr == NULL)
2694 : {
2695 0 : HEpush(DFE_NOSPACE,"GDinqdims", __FILE__, __LINE__);
2696 0 : return(-1);
2697 : }
2698 : /* Check for valid grid id */
2699 : /* ----------------------- */
2700 0 : status = GDchkgdid(gridID, "GDinqdims", &fid, &sdInterfaceID, &gdVgrpID);
2701 :
2702 0 : if (status == 0)
2703 : {
2704 : /* If dimension names or sizes are requested */
2705 : /* ----------------------------------------- */
2706 0 : if (dimnames != NULL || dims != NULL)
2707 : {
2708 : /* Get grid name */
2709 : /* ------------- */
2710 0 : int gID = gridID % idOffset;
2711 0 : if (gID >= NGRID)
2712 : {
2713 0 : free(utlstr);
2714 0 : return -1;
2715 : }
2716 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
2717 :
2718 :
2719 : /* Get pointers to "Dimension" section within SM */
2720 : /* --------------------------------------------- */
2721 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
2722 : "Dimension", metaptrs);
2723 0 : if(metabuf == NULL)
2724 : {
2725 0 : free(utlstr);
2726 0 : return(-1);
2727 : }
2728 :
2729 :
2730 : /* If dimension names are requested then "clear" name buffer */
2731 : /* --------------------------------------------------------- */
2732 0 : if (dimnames != NULL)
2733 : {
2734 0 : dimnames[0] = 0;
2735 : }
2736 :
2737 0 : while (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2738 : {
2739 0 : strcpy(utlstr, "\t\tOBJECT=");
2740 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
2741 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2742 : {
2743 : /* Get Dimension Name */
2744 : /* ------------------ */
2745 0 : if (dimnames != NULL)
2746 : {
2747 : /* Check 1st for old meta data then new */
2748 : /* ------------------------------------ */
2749 0 : EHgetmetavalue(metaptrs, "OBJECT", utlstr);
2750 0 : if (utlstr[0] != '"')
2751 : {
2752 0 : metaptrs[0] =
2753 0 : strstr(metaptrs[0], "\t\t\t\tDimensionName=");
2754 0 : EHgetmetavalue(metaptrs, "DimensionName", utlstr);
2755 : }
2756 :
2757 : /* Strip off double quotes */
2758 : /* ----------------------- */
2759 0 : memmove(utlstr, utlstr + 1, strlen(utlstr) - 2);
2760 0 : utlstr[strlen(utlstr) - 2] = 0;
2761 :
2762 0 : if (nDim > 0)
2763 : {
2764 0 : strcat(dimnames, ",");
2765 : }
2766 0 : strcat(dimnames, utlstr);
2767 : }
2768 :
2769 : /* Get Dimension Size */
2770 : /* ------------------ */
2771 0 : if (dims != NULL)
2772 : {
2773 0 : EHgetmetavalue(metaptrs, "Size", utlstr);
2774 0 : size = atoi(utlstr);
2775 0 : dims[nDim] = size;
2776 : }
2777 0 : nDim++;
2778 : }
2779 : }
2780 0 : free(metabuf);
2781 :
2782 : }
2783 : }
2784 :
2785 :
2786 : /* Set nDim to -1 if error status exists */
2787 : /* ------------------------------------- */
2788 0 : if (status == -1)
2789 : {
2790 0 : nDim = -1;
2791 : }
2792 0 : free(utlstr);
2793 0 : return (nDim);
2794 : }
2795 :
2796 :
2797 :
2798 :
2799 :
2800 :
2801 : /*----------------------------------------------------------------------------|
2802 : | BEGIN_PROLOG |
2803 : | |
2804 : | FUNCTION: GDinqfields |
2805 : | |
2806 : | DESCRIPTION: Retrieve information about all data fields defined in a grid. |
2807 : | |
2808 : | |
2809 : | Return Value Type Units Description |
2810 : | ============ ====== ========= ===================================== |
2811 : | nFld int32 Number of fields in swath |
2812 : | |
2813 : | INPUTS: |
2814 : | gridID int32 grid structure ID |
2815 : | |
2816 : | |
2817 : | OUTPUTS: |
2818 : | fieldlist char Field names (comma-separated) |
2819 : | rank int32 Array of ranks |
2820 : | numbertype int32 Array of HDF number types |
2821 : | |
2822 : | NOTES: |
2823 : | |
2824 : | |
2825 : | Date Programmer Description |
2826 : | ====== ============ ================================================= |
2827 : | Jun 96 Joel Gales Original Programmer |
2828 : | Aug 96 Joel Gales Make metadata ODL compliant |
2829 : | Feb 97 Joel Gales Set nFld to -1 if status = -1 |
2830 : | |
2831 : | END_PROLOG |
2832 : -----------------------------------------------------------------------------*/
2833 : int32
2834 0 : GDinqfields(int32 gridID, char *fieldlist, int32 rank[],
2835 : int32 numbertype[])
2836 : {
2837 : intn status; /* routine return status variable */
2838 :
2839 : int32 fid; /* HDF-EOS file ID */
2840 : int32 sdInterfaceID; /* HDF SDS interface ID */
2841 : int32 gdVgrpID; /* Grid root Vgroup ID */
2842 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
2843 0 : int32 nFld = 0; /* Number of mappings */
2844 : int32 slen[8]; /* String length array */
2845 :
2846 : char *metabuf; /* Pointer to structural metadata (SM) */
2847 : char *metaptrs[2];/* Pointers to begin and end of SM section */
2848 : char gridname[80]; /* Grid Name */
2849 : char *utlstr;/* Utility string */
2850 : char *ptr[8]; /* String pointer array */
2851 :
2852 : /* Allocate space for utility string */
2853 : /* --------------------------------- */
2854 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2855 0 : if(utlstr == NULL)
2856 : {
2857 0 : HEpush(DFE_NOSPACE,"GDinqfields", __FILE__, __LINE__);
2858 0 : return(-1);
2859 : }
2860 : /* Check for valid grid id */
2861 : /* ----------------------- */
2862 0 : status = GDchkgdid(gridID, "GDinqfields", &fid, &sdInterfaceID, &gdVgrpID);
2863 0 : if (status == 0)
2864 : {
2865 :
2866 : /* If field names, ranks, or number types desired ... */
2867 : /* --------------------------------------------------- */
2868 0 : if (fieldlist != NULL || rank != NULL || numbertype != NULL)
2869 : {
2870 : /* Get grid name */
2871 : /* ------------- */
2872 0 : int gID = gridID % idOffset;
2873 0 : if (gID >= NGRID)
2874 : {
2875 0 : free(utlstr);
2876 0 : return -1;
2877 : }
2878 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
2879 :
2880 :
2881 : /* Get pointers to "DataField" section within SM */
2882 : /* --------------------------------------------- */
2883 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
2884 : "DataField", metaptrs);
2885 0 : if(metabuf == NULL)
2886 : {
2887 0 : free(utlstr);
2888 0 : return(-1);
2889 : }
2890 :
2891 :
2892 : /* If field names are desired then "clear" name buffer */
2893 : /* --------------------------------------------------- */
2894 0 : if (fieldlist != NULL)
2895 : {
2896 0 : fieldlist[0] = 0;
2897 : }
2898 :
2899 :
2900 : /* Begin loop through mapping entries in metadata */
2901 : /* ---------------------------------------------- */
2902 : while (1)
2903 : {
2904 : /* Search for OBJECT string */
2905 : /* ------------------------ */
2906 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
2907 :
2908 :
2909 : /* If found within "Data" Field metadata section .. */
2910 : /* ------------------------------------------------ */
2911 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2912 : {
2913 : /* Get Fieldnames (if desired) */
2914 : /* --------------------------- */
2915 0 : if (fieldlist != NULL)
2916 : {
2917 : /* Check 1st for old meta data then new */
2918 : /* ------------------------------------ */
2919 0 : EHgetmetavalue(metaptrs, "OBJECT", utlstr);
2920 :
2921 : /*
2922 : * If OBJECT value begins with double quote then old
2923 : * metadata, field name is OBJECT value. Otherwise
2924 : * search for "DataFieldName" string
2925 : */
2926 :
2927 0 : if (utlstr[0] != '"')
2928 : {
2929 0 : strcpy(utlstr, "\t\t\t\t");
2930 0 : strcat(utlstr, "DataFieldName");
2931 0 : strcat(utlstr, "=");
2932 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
2933 0 : EHgetmetavalue(metaptrs, "DataFieldName", utlstr);
2934 : }
2935 :
2936 : /* Strip off double quotes */
2937 : /* ----------------------- */
2938 0 : REMQUOTE(utlstr);
2939 :
2940 :
2941 : /* Add to fieldlist */
2942 : /* ---------------- */
2943 0 : if (nFld > 0)
2944 : {
2945 0 : strcat(fieldlist, ",");
2946 : }
2947 0 : strcat(fieldlist, utlstr);
2948 :
2949 : }
2950 : /* Get Numbertype */
2951 0 : if (numbertype != NULL)
2952 : {
2953 0 : EHgetmetavalue(metaptrs, "DataType", utlstr);
2954 0 : numbertype[nFld] = EHnumstr(utlstr);
2955 : }
2956 : /*
2957 : * Get Rank (if desired) by counting # of dimensions in
2958 : * "DimList" string
2959 : */
2960 0 : if (rank != NULL)
2961 : {
2962 0 : EHgetmetavalue(metaptrs, "DimList", utlstr);
2963 0 : rank[nFld] = EHparsestr(utlstr, ',', ptr, slen);
2964 : }
2965 : /* Increment number of fields */
2966 0 : nFld++;
2967 : }
2968 : else
2969 : /* No more fields found */
2970 : {
2971 : break;
2972 : }
2973 : }
2974 0 : free(metabuf);
2975 : }
2976 : }
2977 :
2978 : /* Set nFld to -1 if error status exists */
2979 : /* ------------------------------------- */
2980 0 : if (status == -1)
2981 : {
2982 0 : nFld = -1;
2983 : }
2984 0 : free(utlstr);
2985 0 : return (nFld);
2986 : }
2987 :
2988 :
2989 :
2990 :
2991 :
2992 : /*----------------------------------------------------------------------------|
2993 : | BEGIN_PROLOG |
2994 : | |
2995 : | FUNCTION: GDnentries |
2996 : | |
2997 : | DESCRIPTION: Returns number of entries and descriptive string buffer |
2998 : | size for a specified entity. |
2999 : | |
3000 : | |
3001 : | Return Value Type Units Description |
3002 : | ============ ====== ========= ===================================== |
3003 : | nEntries int32 Number of entries |
3004 : | |
3005 : | INPUTS: |
3006 : | gridID int32 grid structure ID |
3007 : | entrycode int32 Entry code |
3008 : | HDFE_NENTDIM (0) |
3009 : | HDFE_NENTDFLD (4) |
3010 : | |
3011 : | |
3012 : | OUTPUTS: |
3013 : | strbufsize int32 Length of comma-separated list |
3014 : | (Does not include null-terminator |
3015 : | |
3016 : | NOTES: |
3017 : | |
3018 : | |
3019 : | Date Programmer Description |
3020 : | ====== ============ ================================================= |
3021 : | Jun 96 Joel Gales Original Programmer |
3022 : | Aug 96 Joel Gales Make metadata ODL compliant |
3023 : | Feb 97 Joel Gales Set nEntries to -1 if status = -1 |
3024 : | |
3025 : | END_PROLOG |
3026 : -----------------------------------------------------------------------------*/
3027 : int32
3028 0 : GDnentries(int32 gridID, int32 entrycode, int32 * strbufsize)
3029 :
3030 : {
3031 : intn status; /* routine return status variable */
3032 : intn i; /* Loop index */
3033 :
3034 : int32 fid; /* HDF-EOS file ID */
3035 : int32 sdInterfaceID; /* HDF SDS interface ID */
3036 : int32 gdVgrpID; /* Grid root Vgroup ID */
3037 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
3038 0 : int32 nEntries = 0; /* Number of entries */
3039 : int32 metaflag; /* Old (0), New (1) metadata flag) */
3040 0 : int32 nVal = 0; /* Number of strings to search for */
3041 :
3042 0 : char *metabuf = NULL; /* Pointer to structural metadata (SM) */
3043 0 : char *metaptrs[2] = {NULL, NULL};/* Pointers to begin and end of SM section */
3044 : char gridname[80]; /* Grid Name */
3045 : char *utlstr;/* Utility string */
3046 : char valName[2][32]; /* Strings to search for */
3047 :
3048 0 : memset(valName, 0, sizeof(valName));
3049 :
3050 : /* Allocate space for utility string */
3051 : /* --------------------------------- */
3052 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
3053 0 : if(utlstr == NULL)
3054 : {
3055 0 : HEpush(DFE_NOSPACE,"GDnentries", __FILE__, __LINE__);
3056 0 : return(-1);
3057 : }
3058 0 : status = GDchkgdid(gridID, "GDnentries", &fid, &sdInterfaceID, &gdVgrpID);
3059 :
3060 0 : if (status == 0)
3061 : {
3062 : /* Get grid name */
3063 0 : int gID = gridID % idOffset;
3064 0 : if (gID >= NGRID)
3065 : {
3066 0 : free(utlstr);
3067 0 : return -1;
3068 : }
3069 :
3070 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
3071 :
3072 : /* Zero out string buffer size */
3073 0 : *strbufsize = 0;
3074 :
3075 :
3076 : /*
3077 : * Get pointer to relevant section within SM and Get names of
3078 : * metadata strings to inquire about
3079 : */
3080 0 : switch (entrycode)
3081 : {
3082 0 : case HDFE_NENTDIM:
3083 : {
3084 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
3085 : "Dimension", metaptrs);
3086 0 : if(metabuf == NULL)
3087 : {
3088 0 : free(utlstr);
3089 0 : return(-1);
3090 : }
3091 :
3092 0 : nVal = 1;
3093 0 : strcpy(&valName[0][0], "DimensionName");
3094 : }
3095 0 : break;
3096 :
3097 0 : case HDFE_NENTDFLD:
3098 : {
3099 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, gridname, "g",
3100 : "DataField", metaptrs);
3101 0 : if(metabuf == NULL)
3102 : {
3103 0 : free(utlstr);
3104 0 : return(-1);
3105 : }
3106 :
3107 0 : nVal = 1;
3108 0 : strcpy(&valName[0][0], "DataFieldName");
3109 : }
3110 0 : break;
3111 : }
3112 :
3113 0 : if (!metabuf || metaptrs[0] == NULL)
3114 : {
3115 0 : free(metabuf);
3116 0 : free(utlstr);
3117 0 : return -1;
3118 : }
3119 :
3120 : /*
3121 : * Check for presence of 'GROUP="' string If found then old metadata,
3122 : * search on OBJECT string
3123 : */
3124 0 : metaflag = (strstr(metabuf, "GROUP=\"") == NULL) ? 1 : 0;
3125 0 : if (metaflag == 0)
3126 : {
3127 0 : nVal = 1;
3128 0 : strcpy(&valName[0][0], "\t\tOBJECT");
3129 : }
3130 :
3131 :
3132 : /* Begin loop through entries in metadata */
3133 : /* -------------------------------------- */
3134 : while (1)
3135 : {
3136 : /* Search for first string */
3137 0 : strcpy(utlstr, &valName[0][0]);
3138 0 : strcat(utlstr, "=");
3139 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
3140 :
3141 : /* If found within relevant metadata section ... */
3142 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
3143 : {
3144 0 : for (i = 0; i < nVal; i++)
3145 : {
3146 : /*
3147 : * Get all string values Don't count quotes
3148 : */
3149 0 : EHgetmetavalue(metaptrs, &valName[i][0], utlstr);
3150 0 : *strbufsize += (int32)strlen(utlstr) - 2;
3151 : }
3152 : /* Increment number of entries */
3153 0 : nEntries++;
3154 :
3155 : /* Go to end of OBJECT */
3156 0 : metaptrs[0] = strstr(metaptrs[0], "END_OBJECT");
3157 : }
3158 : else
3159 : /* No more entries found */
3160 : {
3161 : break;
3162 : }
3163 : }
3164 0 : free(metabuf);
3165 :
3166 :
3167 : /* Count comma separators & slashes (if mappings) */
3168 : /* ---------------------------------------------- */
3169 0 : if (nEntries > 0)
3170 : {
3171 0 : *strbufsize += nEntries - 1;
3172 0 : *strbufsize += (nVal - 1) * nEntries;
3173 : }
3174 : }
3175 :
3176 :
3177 : /* Set nEntries to -1 if error status exists */
3178 : /* ----------------------------------------- */
3179 0 : if (status == -1)
3180 : {
3181 0 : nEntries = -1;
3182 : }
3183 :
3184 0 : free(utlstr);
3185 0 : return (nEntries);
3186 : }
3187 :
3188 :
3189 :
3190 :
3191 :
3192 : /*----------------------------------------------------------------------------|
3193 : | BEGIN_PROLOG |
3194 : | |
3195 : | FUNCTION: GDinqgrid |
3196 : | |
3197 : | DESCRIPTION: Returns number and names of grid structures in file |
3198 : | |
3199 : | |
3200 : | Return Value Type Units Description |
3201 : | ============ ====== ========= ===================================== |
3202 : | nGrid int32 Number of grid structures in file |
3203 : | |
3204 : | INPUTS: |
3205 : | filename char HDF-EOS filename |
3206 : | |
3207 : | OUTPUTS: |
3208 : | gridlist char List of grid names (comma-separated) |
3209 : | strbufsize int32 Length of gridlist |
3210 : | |
3211 : | NOTES: |
3212 : | |
3213 : | |
3214 : | Date Programmer Description |
3215 : | ====== ============ ================================================= |
3216 : | Jun 96 Joel Gales Original Programmer |
3217 : | |
3218 : | END_PROLOG |
3219 : -----------------------------------------------------------------------------*/
3220 : int32
3221 4 : GDinqgrid(const char *filename, char *gridlist, int32 * strbufsize)
3222 : {
3223 : int32 nGrid; /* Number of grid structures in file */
3224 :
3225 : /* Call "EHinquire" routine */
3226 : /* ------------------------ */
3227 4 : nGrid = EHinquire(filename, "GRID", gridlist, strbufsize);
3228 :
3229 4 : return (nGrid);
3230 : }
3231 :
3232 :
3233 :
3234 : /*----------------------------------------------------------------------------|
3235 : | BEGIN_PROLOG |
3236 : | |
3237 : | FUNCTION: GDgetfillvalue |
3238 : | |
3239 : | DESCRIPTION: Retrieves fill value for a specified field. |
3240 : | |
3241 : | |
3242 : | Return Value Type Units Description |
3243 : | ============ ====== ========= ===================================== |
3244 : | status intn return status (0) SUCCEED, (-1) FAIL |
3245 : | |
3246 : | INPUTS: |
3247 : | gridID int32 grid structure ID |
3248 : | fieldname char field name |
3249 : | |
3250 : | OUTPUTS: |
3251 : | fillval void fill value |
3252 : | |
3253 : | NOTES: |
3254 : | |
3255 : | |
3256 : | Date Programmer Description |
3257 : | ====== ============ ================================================= |
3258 : | Jun 96 Joel Gales Original Programmer |
3259 : | |
3260 : | END_PROLOG |
3261 : -----------------------------------------------------------------------------*/
3262 : intn
3263 0 : GDgetfillvalue(int32 gridID, const char *fieldname, VOIDP fillval)
3264 : {
3265 : intn status; /* routine return status variable */
3266 :
3267 : int32 nt; /* Number type */
3268 : int32 dims[8]; /* Dimensions array */
3269 : int32 dum; /* Dummy variable */
3270 :
3271 : char name[80]; /* Fill value "attribute" name */
3272 :
3273 0 : status = GDchkgdid(gridID, "GDgetfillvalue", &dum, &dum, &dum);
3274 :
3275 : /* Check for valid grid ID */
3276 0 : if (status == 0)
3277 : {
3278 : /* Get field info */
3279 0 : status = GDfieldinfo(gridID, fieldname, &dum, dims, &nt, NULL);
3280 :
3281 0 : if (status == 0)
3282 : {
3283 : /* Read fill value attribute */
3284 0 : strcpy(name, "_FV_");
3285 0 : strcat(name, fieldname);
3286 0 : status = GDreadattr(gridID, name, fillval);
3287 : }
3288 : else
3289 : {
3290 0 : HEpush(DFE_GENAPP, "GDgetfillvalue", __FILE__, __LINE__);
3291 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
3292 : }
3293 :
3294 : }
3295 0 : return (status);
3296 : }
3297 :
3298 :
3299 :
3300 :
3301 :
3302 : /*----------------------------------------------------------------------------|
3303 : | BEGIN_PROLOG |
3304 : | |
3305 : | FUNCTION: GDdetach |
3306 : | |
3307 : | DESCRIPTION: Detaches from grid interface and performs file housekeeping. |
3308 : | |
3309 : | |
3310 : | Return Value Type Units Description |
3311 : | ============ ====== ========= ===================================== |
3312 : | status intn return status (0) SUCCEED, (-1) FAIL |
3313 : | |
3314 : | INPUTS: |
3315 : | gridID int32 grid structure ID |
3316 : | |
3317 : | |
3318 : | OUTPUTS: |
3319 : | None |
3320 : | |
3321 : | NOTES: |
3322 : | |
3323 : | |
3324 : | Date Programmer Description |
3325 : | ====== ============ ================================================= |
3326 : | Jun 96 Joel Gales Original Programmer |
3327 : | Sep 96 Joel Gales Setup dim names for SDsetdimname in dimbuf1 rather |
3328 : | that utlstr |
3329 : | Oct 96 Joel Gales Detach Grid Vgroups |
3330 : | Oct 96 Joel Gales "Detach" from SDS |
3331 : | Nov 96 Joel Gales Call GDchkgdid to check for proper grid ID |
3332 : | Dec 96 Joel Gales Add multiple vertical subsetting garbage collection |
3333 : | Oct 98 Abe Taaheri Added GDXRegion[k]->DimNamePtr[i] =0; after freeing |
3334 : | memory |
3335 : | Sep 99 Abe Taaheri Changed memcpy to memmove because of overlapping |
3336 : | source and destination for GDXSDcomb, nameptr, and |
3337 : | dimptr. memcpy may cause unexpected results. |
3338 : | |
3339 : | END_PROLOG |
3340 : -----------------------------------------------------------------------------*/
3341 : intn
3342 0 : GDdetach(int32 gridID)
3343 :
3344 : {
3345 : intn i; /* Loop index */
3346 : intn k; /* Loop index */
3347 0 : intn status = 0; /* routine return status variable */
3348 :
3349 : int32 sdInterfaceID; /* SDS interface ID */
3350 : int32 gID; /* Grid ID - offset */
3351 0 : int32 idOffset = GDIDOFFSET; /* Grid ID offset */
3352 : int32 dum; /* Dummy variable */
3353 :
3354 : char gridname[VGNAMELENMAX + 1]; /* Grid name */
3355 :
3356 :
3357 0 : status = GDchkgdid(gridID, "GDdetach", &dum, &sdInterfaceID, &dum);
3358 :
3359 0 : if (status == 0)
3360 : {
3361 0 : gID = gridID % idOffset;
3362 0 : if (gID >= NGRID)
3363 : {
3364 0 : return -1;
3365 : }
3366 0 : Vgetname(GDXGrid[gID].IDTable, gridname);
3367 :
3368 :
3369 : /* "Detach" from previously attached SDSs */
3370 : /* -------------------------------------- */
3371 0 : for (k = 0; k < GDXGrid[gID].nSDS; k++)
3372 : {
3373 0 : SDendaccess(GDXGrid[gID].sdsID[k]);
3374 : }
3375 0 : free(GDXGrid[gID].sdsID);
3376 0 : GDXGrid[gID].sdsID = 0;
3377 0 : GDXGrid[gID].nSDS = 0;
3378 :
3379 :
3380 :
3381 : /* Detach Grid Vgroups */
3382 : /* ------------------- */
3383 0 : Vdetach(GDXGrid[gID].VIDTable[0]);
3384 0 : Vdetach(GDXGrid[gID].VIDTable[1]);
3385 0 : Vdetach(GDXGrid[gID].IDTable);
3386 :
3387 0 : GDXGrid[gID].active = 0;
3388 0 : GDXGrid[gID].VIDTable[0] = 0;
3389 0 : GDXGrid[gID].VIDTable[1] = 0;
3390 0 : GDXGrid[gID].IDTable = 0;
3391 0 : GDXGrid[gID].fid = 0;
3392 :
3393 :
3394 :
3395 :
3396 : /* Free Region Pointers */
3397 : /* -------------------- */
3398 0 : for (k = 0; k < NGRIDREGN; k++)
3399 : {
3400 0 : if (GDXRegion[k] != 0 &&
3401 0 : GDXRegion[k]->gridID == gridID)
3402 : {
3403 0 : for (i = 0; i < 8; i++)
3404 : {
3405 0 : if (GDXRegion[k]->DimNamePtr[i] != 0)
3406 : {
3407 0 : free(GDXRegion[k]->DimNamePtr[i]);
3408 0 : GDXRegion[k]->DimNamePtr[i] = 0;
3409 : }
3410 : }
3411 :
3412 0 : free(GDXRegion[k]);
3413 0 : GDXRegion[k] = 0;
3414 : }
3415 : }
3416 : }
3417 0 : return (status);
3418 : }
3419 :
3420 :
3421 : /*----------------------------------------------------------------------------|
3422 : | BEGIN_PROLOG |
3423 : | |
3424 : | FUNCTION: GDclose |
3425 : | |
3426 : | DESCRIPTION: Closes file. |
3427 : | |
3428 : | |
3429 : | Return Value Type Units Description |
3430 : | ============ ====== ========= ===================================== |
3431 : | status intn return status (0) SUCCEED, (-1) FAIL |
3432 : | |
3433 : | INPUTS: |
3434 : | fid int32 File ID |
3435 : | |
3436 : | |
3437 : | OUTPUTS: |
3438 : | None |
3439 : | |
3440 : | NOTES: |
3441 : | |
3442 : | |
3443 : | Date Programmer Description |
3444 : | ====== ============ ================================================= |
3445 : | Jun 96 Joel Gales Original Programmer |
3446 : | |
3447 : | END_PROLOG |
3448 : -----------------------------------------------------------------------------*/
3449 : intn
3450 4 : GDclose(int32 fid)
3451 :
3452 : {
3453 4 : intn status = 0; /* routine return status variable */
3454 :
3455 : /* Call EHclose to perform file close */
3456 : /* ---------------------------------- */
3457 4 : status = EHclose(fid);
3458 :
3459 4 : return (status);
3460 : }
3461 :
3462 :
3463 : /*----------------------------------------------------------------------------|
3464 : | BEGIN_PROLOG |
3465 : | |
3466 : | FUNCTION: GDgetdefaults |
3467 : | |
3468 : | DESCRIPTION: |
3469 : | |
3470 : | |
3471 : | Return Value Type Units Description |
3472 : | ============ ====== ========= ===================================== |
3473 : | status intn return status (0) SUCCEED, (-1) FAIL |
3474 : | |
3475 : | INPUTS: |
3476 : | projcode int32 GCTP projection code |
3477 : | zonecode int32 UTM zone code |
3478 : | projparm float64 Projection parameters |
3479 : | spherecode int32 GCTP spheriod code |
3480 : | upleftpt float64 upper left corner coordinates |
3481 : | lowrightpt float64 lower right corner coordinates |
3482 : | |
3483 : | |
3484 : | OUTPUTS: |
3485 : | upleftpt float64 upper left corner coordinates |
3486 : | lowrightpt float64 lower right corner coordinates |
3487 : | |
3488 : | NOTES: |
3489 : | |
3490 : | |
3491 : | Date Programmer Description |
3492 : | ====== ============ ================================================= |
3493 : | Aug 96 Joel Gales Original Programmer |
3494 : | Sep 96 Raj Gejjaga Fixed bugs in Polar Stereographic and Goode | | Homolosine default calculations. |
3495 : | Sep 96 Raj Gejjaga Added code to compute default boundary points |
3496 : | for Lambert Azimuthal Polar and Equatorial |
3497 : | projections. |
3498 : | Feb 97 Raj Gejjaga Added code to compute default boundary points |
3499 : | for Integerized Sinusoidal Grid. Added error |
3500 : | handling code. |
3501 : | Jun 00 Abe Taaheri Added support for EASE grid |
3502 : | |
3503 : | END_PROLOG |
3504 : -----------------------------------------------------------------------------*/
3505 : static intn
3506 0 : GDgetdefaults(int32 projcode, int32 zonecode, float64 projparm[],
3507 : int32 spherecode, float64 upleftpt[], float64 lowrightpt[])
3508 : {
3509 0 : int32 errorcode = 0, status = 0;
3510 : int32(*for_trans[100]) (double, double, double*, double*);
3511 :
3512 : float64 lon, lat, plat, x, y;
3513 : float64 plon, tlon, llon, rlon, pplon, LLon, LLat, RLon, RLat;
3514 :
3515 :
3516 : /* invoke GCTP initialization routine */
3517 : /* ---------------------------------- */
3518 0 : for_init(projcode, zonecode, projparm, spherecode, NULL, NULL,
3519 : &errorcode, for_trans);
3520 :
3521 : /* Report error if any */
3522 : /* ------------------- */
3523 0 : if (errorcode != 0)
3524 : {
3525 0 : status = -1;
3526 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3527 0 : HEreport("GCTP Error: %d\n", errorcode);
3528 0 : return (status);
3529 : }
3530 :
3531 : /* Compute Default Boundary Points for EASE Grid */
3532 : /* Use Global coverage */
3533 : /* ------------------------------------------------------ */
3534 0 : if (projcode == GCTP_BCEA &&
3535 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
3536 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
3537 : {
3538 0 : upleftpt[0] = EHconvAng(EASE_GRID_DEFAULT_UPLEFT_LON, HDFE_DEG_DMS);
3539 0 : upleftpt[1] = EHconvAng(EASE_GRID_DEFAULT_UPLEFT_LAT, HDFE_DEG_DMS);
3540 0 : lowrightpt[0] = EHconvAng(EASE_GRID_DEFAULT_LOWRGT_LON, HDFE_DEG_DMS);
3541 0 : lowrightpt[1] = EHconvAng(EASE_GRID_DEFAULT_LOWRGT_LAT, HDFE_DEG_DMS);
3542 : }
3543 :
3544 : /* Compute Default Boundary Points for CEA */
3545 : /* --------------------------------------------*/
3546 0 : if (projcode == GCTP_CEA &&
3547 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
3548 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
3549 : {
3550 0 : LLon = EHconvAng(EASE_GRID_DEFAULT_UPLEFT_LON, HDFE_DEG_RAD);
3551 0 : LLat = EHconvAng(EASE_GRID_DEFAULT_UPLEFT_LAT, HDFE_DEG_RAD);
3552 0 : RLon = EHconvAng(EASE_GRID_DEFAULT_LOWRGT_LON, HDFE_DEG_RAD);
3553 0 : RLat = EHconvAng(EASE_GRID_DEFAULT_LOWRGT_LAT, HDFE_DEG_RAD);
3554 :
3555 0 : errorcode = for_trans[projcode] (LLon, LLat, &x, &y);
3556 0 : if (errorcode != 0)
3557 : {
3558 0 : status = -1;
3559 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3560 0 : HEreport("GCTP Error: %d\n", errorcode);
3561 0 : return (status);
3562 : }
3563 0 : upleftpt[0] = x;
3564 0 : upleftpt[1] = y;
3565 :
3566 0 : errorcode = for_trans[projcode] (RLon, RLat, &x, &y);
3567 0 : if (errorcode != 0)
3568 : {
3569 0 : status = -1;
3570 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3571 0 : HEreport("GCTP Error: %d\n", errorcode);
3572 0 : return (status);
3573 : }
3574 0 : lowrightpt[0] = x;
3575 0 : lowrightpt[1] = y;
3576 :
3577 : }
3578 :
3579 :
3580 : /* Compute Default Boundary Points for Polar Sterographic */
3581 : /* ------------------------------------------------------ */
3582 0 : if (projcode == GCTP_PS &&
3583 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
3584 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
3585 : {
3586 : /*
3587 : * Convert the longitude and latitude from the DMS to decimal degree
3588 : * format.
3589 : */
3590 0 : plon = EHconvAng(projparm[4], HDFE_DMS_DEG);
3591 0 : plat = EHconvAng(projparm[5], HDFE_DMS_DEG);
3592 :
3593 : /*
3594 : * Compute the longitudes at 90, 180 and 270 degrees from the central
3595 : * longitude.
3596 : */
3597 :
3598 0 : if (plon <= 0.0)
3599 : {
3600 0 : tlon = 180.0 + plon;
3601 0 : pplon = plon + 360.0;
3602 : }
3603 : else
3604 : {
3605 0 : tlon = plon - 180.0;
3606 0 : pplon = plon;
3607 : }
3608 :
3609 0 : rlon = pplon + 90.0;
3610 0 : if (rlon > 360.0)
3611 0 : rlon = rlon - 360;
3612 :
3613 0 : if (rlon > 180.0)
3614 0 : rlon = rlon - 360.0;
3615 :
3616 0 : if (rlon <= 0.0)
3617 0 : llon = 180.0 + rlon;
3618 : else
3619 0 : llon = rlon - 180.0;
3620 :
3621 :
3622 : /* Convert all four longitudes from decimal degrees to radians */
3623 0 : plon = EHconvAng(plon, HDFE_DEG_RAD);
3624 0 : tlon = EHconvAng(tlon, HDFE_DEG_RAD);
3625 0 : llon = EHconvAng(llon, HDFE_DEG_RAD);
3626 0 : rlon = EHconvAng(rlon, HDFE_DEG_RAD);
3627 :
3628 0 : errorcode = for_trans[projcode] (llon, 0.0, &x, &y);
3629 0 : if (errorcode != 0)
3630 : {
3631 0 : status = -1;
3632 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3633 0 : HEreport("GCTP Error: %d\n", errorcode);
3634 0 : return (status);
3635 : }
3636 :
3637 0 : upleftpt[0] = x;
3638 :
3639 0 : errorcode = for_trans[projcode] (rlon, 0.0, &x, &y);
3640 0 : if (errorcode != 0)
3641 : {
3642 0 : status = -1;
3643 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3644 0 : HEreport("GCTP Error: %d\n", errorcode);
3645 0 : return (status);
3646 : }
3647 :
3648 0 : lowrightpt[0] = x;
3649 :
3650 : /*
3651 : * Compute the upperleft and lowright y values based on the south or
3652 : * north polar projection
3653 : */
3654 :
3655 0 : if (plat < 0.0)
3656 : {
3657 0 : errorcode = for_trans[projcode] (plon, 0.0, &x, &y);
3658 0 : if (errorcode != 0)
3659 : {
3660 0 : status = -1;
3661 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3662 0 : HEreport("GCTP Error: %d\n", errorcode);
3663 0 : return (status);
3664 : }
3665 :
3666 0 : upleftpt[1] = y;
3667 :
3668 0 : errorcode = for_trans[projcode] (tlon, 0.0, &x, &y);
3669 0 : if (errorcode != 0)
3670 : {
3671 0 : status = -1;
3672 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3673 0 : HEreport("GCTP Error: %d\n", errorcode);
3674 0 : return (status);
3675 : }
3676 :
3677 0 : lowrightpt[1] = y;
3678 :
3679 : }
3680 : else
3681 : {
3682 0 : errorcode = for_trans[projcode] (tlon, 0.0, &x, &y);
3683 0 : if (errorcode != 0)
3684 : {
3685 0 : status = -1;
3686 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3687 0 : HEreport("GCTP Error: %d\n", errorcode);
3688 0 : return (status);
3689 : }
3690 :
3691 0 : upleftpt[1] = y;
3692 :
3693 0 : errorcode = for_trans[projcode] (plon, 0.0, &x, &y);
3694 0 : if (errorcode != 0)
3695 : {
3696 0 : status = -1;
3697 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3698 0 : HEreport("GCTP Error: %d\n", errorcode);
3699 0 : return (status);
3700 : }
3701 :
3702 0 : lowrightpt[1] = y;
3703 :
3704 : }
3705 : }
3706 :
3707 :
3708 : /* Compute Default Boundary Points for Goode Homolosine */
3709 : /* ---------------------------------------------------- */
3710 0 : if (projcode == GCTP_GOOD &&
3711 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
3712 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
3713 : {
3714 0 : lon = EHconvAng(-180, HDFE_DEG_RAD);
3715 0 : lat = 0.0;
3716 :
3717 0 : errorcode = for_trans[projcode] (lon, lat, &x, &y);
3718 0 : if (errorcode != 0)
3719 : {
3720 0 : status = -1;
3721 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3722 0 : HEreport("GCTP Error: %d\n", errorcode);
3723 0 : return (status);
3724 : }
3725 :
3726 0 : upleftpt[0] = -fabs(x);
3727 0 : lowrightpt[0] = +fabs(x);
3728 :
3729 0 : lat = EHconvAng(90, HDFE_DEG_RAD);
3730 :
3731 0 : errorcode = for_trans[projcode] (lon, lat, &x, &y);
3732 0 : if (errorcode != 0)
3733 : {
3734 0 : status = -1;
3735 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3736 0 : HEreport("GCTP Error: %d\n", errorcode);
3737 0 : return (status);
3738 : }
3739 :
3740 0 : upleftpt[1] = +fabs(y);
3741 0 : lowrightpt[1] = -fabs(y);
3742 : }
3743 :
3744 : /* Compute Default Boundary Points for Lambert Azimuthal */
3745 : /* ----------------------------------------------------- */
3746 0 : if (projcode == GCTP_LAMAZ &&
3747 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
3748 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
3749 : {
3750 : /*
3751 : * Convert the longitude and latitude from the DMS to decimal degree
3752 : * format.
3753 : */
3754 0 : plon = EHconvAng(projparm[4], HDFE_DMS_DEG);
3755 0 : plat = EHconvAng(projparm[5], HDFE_DMS_DEG);
3756 :
3757 : /*
3758 : * Compute the longitudes at 90, 180 and 270 degrees from the central
3759 : * longitude.
3760 : */
3761 :
3762 0 : if (plon <= 0.0)
3763 : {
3764 0 : tlon = 180.0 + plon;
3765 0 : pplon = plon + 360.0;
3766 : }
3767 : else
3768 : {
3769 0 : tlon = plon - 180.0;
3770 0 : pplon = plon;
3771 : }
3772 :
3773 0 : rlon = pplon + 90.0;
3774 0 : if (rlon > 360.0)
3775 0 : rlon = rlon - 360;
3776 :
3777 0 : if (rlon > 180.0)
3778 0 : rlon = rlon - 360.0;
3779 :
3780 0 : if (rlon <= 0.0)
3781 0 : llon = 180.0 + rlon;
3782 : else
3783 0 : llon = rlon - 180.0;
3784 :
3785 : /* Convert all four longitudes from decimal degrees to radians */
3786 0 : plon = EHconvAng(plon, HDFE_DEG_RAD);
3787 0 : tlon = EHconvAng(tlon, HDFE_DEG_RAD);
3788 0 : llon = EHconvAng(llon, HDFE_DEG_RAD);
3789 0 : rlon = EHconvAng(rlon, HDFE_DEG_RAD);
3790 :
3791 0 : errorcode = for_trans[projcode] (llon, 0.0, &x, &y);
3792 0 : if (errorcode != 0)
3793 : {
3794 0 : status = -1;
3795 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3796 0 : HEreport("GCTP Error: %d\n", errorcode);
3797 0 : return (status);
3798 : }
3799 :
3800 0 : upleftpt[0] = x;
3801 :
3802 0 : errorcode = for_trans[projcode] (rlon, 0.0, &x, &y);
3803 0 : if (errorcode != 0)
3804 : {
3805 0 : status = -1;
3806 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3807 0 : HEreport("GCTP Error: %d\n", errorcode);
3808 0 : return (status);
3809 : }
3810 :
3811 0 : lowrightpt[0] = x;
3812 :
3813 : /*
3814 : * Compute upperleft and lowerright values based on whether the
3815 : * projection is south polar, north polar or equatorial
3816 : */
3817 :
3818 0 : if (plat == -90.0)
3819 : {
3820 0 : errorcode = for_trans[projcode] (plon, 0.0, &x, &y);
3821 0 : if (errorcode != 0)
3822 : {
3823 0 : status = -1;
3824 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3825 0 : HEreport("GCTP Error: %d\n", errorcode);
3826 0 : return (status);
3827 : }
3828 :
3829 0 : upleftpt[1] = y;
3830 :
3831 0 : errorcode = for_trans[projcode] (tlon, 0.0, &x, &y);
3832 0 : if (errorcode != 0)
3833 : {
3834 0 : status = -1;
3835 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3836 0 : HEreport("GCTP Error: %d\n", errorcode);
3837 0 : return (status);
3838 : }
3839 :
3840 0 : lowrightpt[1] = y;
3841 : }
3842 0 : else if (plat == 90.0)
3843 : {
3844 0 : errorcode = for_trans[projcode] (tlon, 0.0, &x, &y);
3845 0 : if (errorcode != 0)
3846 : {
3847 0 : status = -1;
3848 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3849 0 : HEreport("GCTP Error: %d\n", errorcode);
3850 0 : return (status);
3851 : }
3852 :
3853 0 : upleftpt[1] = y;
3854 :
3855 0 : errorcode = for_trans[projcode] (plon, 0.0, &x, &y);
3856 0 : if (errorcode != 0)
3857 : {
3858 0 : status = -1;
3859 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3860 0 : HEreport("GCTP Error: %d\n", errorcode);
3861 0 : return (status);
3862 : }
3863 :
3864 0 : lowrightpt[1] = y;
3865 : }
3866 : else
3867 : {
3868 0 : lat = EHconvAng(90, HDFE_DEG_RAD);
3869 0 : errorcode = for_trans[projcode] (plon, lat, &x, &y);
3870 0 : if (errorcode != 0)
3871 : {
3872 0 : status = -1;
3873 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3874 0 : HEreport("GCTP Error: %d\n", errorcode);
3875 0 : return (status);
3876 : }
3877 :
3878 0 : upleftpt[1] = y;
3879 :
3880 0 : lat = EHconvAng(-90, HDFE_DEG_RAD);
3881 0 : errorcode = for_trans[projcode] (plon, lat, &x, &y);
3882 0 : if (errorcode != 0)
3883 : {
3884 0 : status = -1;
3885 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3886 0 : HEreport("GCTP Error: %d\n", errorcode);
3887 0 : return (status);
3888 : }
3889 :
3890 0 : lowrightpt[1] = y;
3891 : }
3892 : }
3893 :
3894 : /* Compute Default Boundary Points for Integerized Sinusoidal Grid */
3895 : /* --------------------------------------------------------------- */
3896 0 : if (((projcode == GCTP_ISINUS) || (projcode == GCTP_ISINUS1)) &&
3897 0 : upleftpt[0] == 0 && upleftpt[1] == 0 &&
3898 0 : lowrightpt[0] == 0 && lowrightpt[1] == 0)
3899 : {
3900 : /*
3901 : * Convert the longitude and latitude from the DMS to decimal degree
3902 : * format.
3903 : */
3904 0 : plon = EHconvAng(projparm[4], HDFE_DMS_DEG);
3905 : /*plat = EHconvAng(projparm[5], HDFE_DMS_DEG); */
3906 :
3907 : /*
3908 : * Compute the longitudes at 90, 180 and 270 degrees from the central
3909 : * longitude.
3910 : */
3911 :
3912 0 : if (plon <= 0.0)
3913 : {
3914 0 : tlon = 180.0 + plon;
3915 0 : pplon = plon + 360.0;
3916 : }
3917 : else
3918 : {
3919 0 : tlon = plon - 180.0;
3920 0 : pplon = plon;
3921 : }
3922 :
3923 0 : rlon = pplon + 90.0;
3924 0 : if (rlon > 360.0)
3925 0 : rlon = rlon - 360;
3926 :
3927 0 : if (rlon > 180.0)
3928 0 : rlon = rlon - 360.0;
3929 :
3930 0 : if (rlon <= 0.0)
3931 0 : llon = 180.0 + rlon;
3932 : else
3933 0 : llon = rlon - 180.0;
3934 :
3935 : /* Convert all four longitudes from decimal degrees to radians */
3936 0 : plon = EHconvAng(plon, HDFE_DEG_RAD);
3937 0 : tlon = EHconvAng(tlon, HDFE_DEG_RAD);
3938 0 : llon = EHconvAng(llon, HDFE_DEG_RAD);
3939 0 : rlon = EHconvAng(rlon, HDFE_DEG_RAD);
3940 :
3941 0 : errorcode = for_trans[projcode] (llon, 0.0, &x, &y);
3942 0 : if (errorcode != 0)
3943 : {
3944 0 : status = -1;
3945 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3946 0 : HEreport("GCTP Error: %d\n", errorcode);
3947 0 : return (status);
3948 : }
3949 :
3950 0 : upleftpt[0] = x;
3951 :
3952 0 : errorcode = for_trans[projcode] (rlon, 0.0, &x, &y);
3953 0 : if (errorcode != 0)
3954 : {
3955 0 : status = -1;
3956 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3957 0 : HEreport("GCTP Error: %d\n", errorcode);
3958 0 : return (status);
3959 : }
3960 :
3961 0 : lowrightpt[0] = x;
3962 :
3963 0 : lat = EHconvAng(90, HDFE_DEG_RAD);
3964 0 : errorcode = for_trans[projcode] (plon, lat, &x, &y);
3965 0 : if (errorcode != 0)
3966 : {
3967 0 : status = -1;
3968 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3969 0 : HEreport("GCTP Error: %d\n", errorcode);
3970 0 : return (status);
3971 : }
3972 :
3973 0 : upleftpt[1] = y;
3974 :
3975 0 : lat = EHconvAng(-90, HDFE_DEG_RAD);
3976 0 : errorcode = for_trans[projcode] (plon, lat, &x, &y);
3977 0 : if (errorcode != 0)
3978 : {
3979 0 : status = -1;
3980 0 : HEpush(DFE_GENAPP, "GDgetdefaults", __FILE__, __LINE__);
3981 0 : HEreport("GCTP Error: %d\n", errorcode);
3982 0 : return (status);
3983 : }
3984 :
3985 0 : lowrightpt[1] = y;
3986 : }
3987 0 : return (errorcode);
3988 : }
3989 :
3990 : /*----------------------------------------------------------------------------|
3991 : | BEGIN_PROLOG |
3992 : | |
3993 : | FUNCTION: GDll2ij |
3994 : | |
3995 : | DESCRIPTION: |
3996 : | |
3997 : | |
3998 : | Return Value Type Units Description |
3999 : | ============ ====== ========= ===================================== |
4000 : | status intn return status (0) SUCCEED, (-1) FAIL |
4001 : | |
4002 : | INPUTS: |
4003 : | projcode int32 GCTP projection code |
4004 : | zonecode int32 UTM zone code |
4005 : | projparm float64 Projection parameters |
4006 : | spherecode int32 GCTP spheriod code |
4007 : | xdimsize int32 xdimsize from GDcreate |
4008 : | ydimsize int32 ydimsize from GDcreate |
4009 : | upleftpt float64 upper left corner coordinates |
4010 : | lowrightpt float64 lower right corner coordinates |
4011 : | npnts int32 number of lon-lat points |
4012 : | longitude float64 longitude array (radians) |
4013 : | latitude float64 latitude array (radians) |
4014 : | |
4015 : | OUTPUTS: |
4016 : | row int32 Row array |
4017 : | col int32 Column array |
4018 : | xval float64 X value array |
4019 : | yval float64 Y value array |
4020 : | |
4021 : | |
4022 : | NOTES: |
4023 : | |
4024 : | |
4025 : | Date Programmer Description |
4026 : | ====== ============ ================================================= |
4027 : | Jun 96 Joel Gales Original Programmer |
4028 : | Aug 96 Joel Gales Return x and y values if requested |
4029 : | Jun 00 Abe Taaheri Added support for EASE grid |
4030 : | |
4031 : | END_PROLOG |
4032 : -----------------------------------------------------------------------------*/
4033 : static intn
4034 0 : GDll2ij(int32 projcode, int32 zonecode, float64 projparm[],
4035 : int32 spherecode, int32 xdimsize, int32 ydimsize,
4036 : float64 upleftpt[], float64 lowrightpt[],
4037 : int32 npnts, float64 longitude[], float64 latitude[],
4038 : int32 row[], int32 col[], float64 xval[], float64 yval[])
4039 :
4040 :
4041 : {
4042 : intn i; /* Loop index */
4043 0 : intn status = 0; /* routine return status variable */
4044 :
4045 0 : int32 errorcode = 0; /* GCTP error code */
4046 : int32(*for_trans[100]) (double, double, double*, double*); /* GCTP function pointer */
4047 :
4048 : float64 xVal; /* Scaled x distance */
4049 : float64 yVal; /* Scaled y distance */
4050 : float64 xMtr; /* X value in meters from GCTP */
4051 : float64 yMtr; /* Y value in meters from GCTP */
4052 : float64 lonrad0; /* Longitude in radians of upleft point */
4053 0 : float64 latrad0 = 0; /* Latitude in radians of upleft point */
4054 : float64 lonrad; /* Longitude in radians of point */
4055 : float64 latrad; /* Latitude in radians of point */
4056 : float64 scaleX; /* X scale factor */
4057 : float64 scaleY; /* Y scale factor */
4058 0 : float64 xMtr0 = 0, xMtr1, yMtr0 = 0, yMtr1;
4059 : float64 lonrad1; /* Longitude in radians of lowright point */
4060 :
4061 : /* If projection not GEO call GCTP initialization routine */
4062 : /* ------------------------------------------------------ */
4063 0 : if (projcode != GCTP_GEO)
4064 : {
4065 0 : for_init(projcode, zonecode, projparm, spherecode, NULL, NULL,
4066 : &errorcode, for_trans);
4067 :
4068 : /* Report error if any */
4069 : /* ------------------- */
4070 0 : if (errorcode != 0)
4071 : {
4072 0 : status = -1;
4073 0 : HEpush(DFE_GENAPP, "GDll2ij", __FILE__, __LINE__);
4074 0 : HEreport("GCTP Error: %d\n", errorcode);
4075 : }
4076 : }
4077 :
4078 :
4079 0 : if (status == 0)
4080 : {
4081 : /* GEO projection */
4082 : /* -------------- */
4083 0 : if (projcode == GCTP_GEO)
4084 : {
4085 : /* Convert upleft and lowright X coords from DMS to radians */
4086 : /* -------------------------------------------------------- */
4087 0 : lonrad0 = EHconvAng(upleftpt[0], HDFE_DMS_RAD);
4088 0 : lonrad = EHconvAng(lowrightpt[0], HDFE_DMS_RAD);
4089 :
4090 : /* Compute x scale factor */
4091 : /* ---------------------- */
4092 0 : scaleX = (lonrad - lonrad0) / xdimsize;
4093 :
4094 :
4095 : /* Convert upleft and lowright Y coords from DMS to radians */
4096 : /* -------------------------------------------------------- */
4097 0 : latrad0 = EHconvAng(upleftpt[1], HDFE_DMS_RAD);
4098 0 : latrad = EHconvAng(lowrightpt[1], HDFE_DMS_RAD);
4099 :
4100 :
4101 : /* Compute y scale factor */
4102 : /* ---------------------- */
4103 0 : scaleY = (latrad - latrad0) / ydimsize;
4104 : }
4105 :
4106 : /* BCEA projection */
4107 : /* -------------- */
4108 0 : else if ( projcode == GCTP_BCEA)
4109 : {
4110 : /* Convert upleft and lowright X coords from DMS to radians */
4111 : /* -------------------------------------------------------- */
4112 :
4113 0 : lonrad0 = EHconvAng(upleftpt[0], HDFE_DMS_RAD);
4114 0 : lonrad = EHconvAng(lowrightpt[0], HDFE_DMS_RAD);
4115 :
4116 : /* Convert upleft and lowright Y coords from DMS to radians */
4117 : /* -------------------------------------------------------- */
4118 0 : latrad0 = EHconvAng(upleftpt[1], HDFE_DMS_RAD);
4119 0 : latrad = EHconvAng(lowrightpt[1], HDFE_DMS_RAD);
4120 :
4121 : /* Convert from lon/lat to meters(or whatever unit is, i.e unit
4122 : of r_major and r_minor) using GCTP */
4123 : /* ----------------------------------------- */
4124 0 : errorcode = for_trans[projcode] (lonrad0, latrad0, &xMtr0, &yMtr0);
4125 :
4126 :
4127 : /* Report error if any */
4128 : /* ------------------- */
4129 0 : if (errorcode != 0)
4130 : {
4131 0 : status = -1;
4132 0 : HEpush(DFE_GENAPP, "GDll2ij", __FILE__, __LINE__);
4133 0 : HEreport("GCTP Error: %d\n", errorcode);
4134 0 : return (status);
4135 : }
4136 :
4137 : /* Convert from lon/lat to meters(or whatever unit is, i.e unit
4138 : of r_major and r_minor) using GCTP */
4139 : /* ----------------------------------------- */
4140 0 : errorcode = for_trans[projcode] (lonrad, latrad, &xMtr1, &yMtr1);
4141 :
4142 :
4143 : /* Report error if any */
4144 : /* ------------------- */
4145 0 : if (errorcode != 0)
4146 : {
4147 0 : status = -1;
4148 0 : HEpush(DFE_GENAPP, "GDll2ij", __FILE__, __LINE__);
4149 0 : HEreport("GCTP Error: %d\n", errorcode);
4150 0 : return (status);
4151 : }
4152 :
4153 : /* Compute x scale factor */
4154 : /* ---------------------- */
4155 0 : scaleX = (xMtr1 - xMtr0) / xdimsize;
4156 :
4157 : /* Compute y scale factor */
4158 : /* ---------------------- */
4159 0 : scaleY = (yMtr1 - yMtr0) / ydimsize;
4160 : }
4161 : else
4162 : {
4163 : /* Non-GEO, Non_BCEA projections */
4164 : /* ---------------------------- */
4165 :
4166 : /* Compute x & y scale factors */
4167 : /* --------------------------- */
4168 0 : scaleX = (lowrightpt[0] - upleftpt[0]) / xdimsize;
4169 0 : scaleY = (lowrightpt[1] - upleftpt[1]) / ydimsize;
4170 : }
4171 :
4172 :
4173 :
4174 : /* Loop through all points */
4175 : /* ----------------------- */
4176 0 : for (i = 0; i < npnts; i++)
4177 : {
4178 : /* Convert lon & lat from decimal degrees to radians */
4179 : /* ------------------------------------------------- */
4180 0 : lonrad = EHconvAng(longitude[i], HDFE_DEG_RAD);
4181 0 : latrad = EHconvAng(latitude[i], HDFE_DEG_RAD);
4182 :
4183 :
4184 : /* GEO projection */
4185 : /* -------------- */
4186 0 : if (projcode == GCTP_GEO)
4187 : {
4188 : /* allow map to span dateline */
4189 0 : lonrad0 = EHconvAng(upleftpt[0], HDFE_DMS_RAD);
4190 0 : lonrad1 = EHconvAng(lowrightpt[0], HDFE_DMS_RAD);
4191 : /* if time-line is passed */
4192 0 : if(lonrad < lonrad1)
4193 : {
4194 0 : if (lonrad < lonrad0) lonrad += 2.0 * M_PI;
4195 0 : if (lonrad > lonrad1) lonrad -= 2.0 * M_PI;
4196 : }
4197 :
4198 : /* Compute scaled distance to point from origin */
4199 : /* -------------------------------------------- */
4200 0 : xVal = (lonrad - lonrad0) / scaleX;
4201 0 : yVal = (latrad - latrad0) / scaleY;
4202 : }
4203 : else
4204 : {
4205 : /* Convert from lon/lat to meters using GCTP */
4206 : /* ----------------------------------------- */
4207 0 : errorcode = for_trans[projcode] (lonrad, latrad, &xMtr, &yMtr);
4208 :
4209 :
4210 : /* Report error if any */
4211 : /* ------------------- */
4212 0 : if (errorcode != 0)
4213 : {
4214 : /*status = -1;
4215 : HEpush(DFE_GENAPP, "GDll2ij", __FILE__, __LINE__);
4216 : HEreport("GCTP Error: %d\n", errorcode);
4217 : return (status); */ /* Bruce Beaumont */
4218 0 : xVal = -2147483648.0; /* Bruce Beaumont */
4219 0 : yVal = -2147483648.0; /* Bruce Beaumont */
4220 : }/* (Note: MAXLONG is defined as 2147483647.0 in
4221 : function cproj.c of GCTP) */
4222 : else {
4223 : /* if projection is BCEA normalize x and y by cell size and
4224 : measure it from the upperleft corner of the grid */
4225 :
4226 : /* Compute scaled distance to point from origin */
4227 : /* -------------------------------------------- */
4228 0 : if( projcode == GCTP_BCEA)
4229 : {
4230 0 : xVal = (xMtr - xMtr0) / scaleX;
4231 0 : yVal = (yMtr - yMtr0) / scaleY;
4232 : }
4233 : else
4234 : {
4235 0 : xVal = (xMtr - upleftpt[0]) / scaleX;
4236 0 : yVal = (yMtr - upleftpt[1]) / scaleY;
4237 : }
4238 : }
4239 : }
4240 :
4241 :
4242 : /* Compute row and col from scaled distance */
4243 : /* ---------------------------------------- */
4244 0 : col[i] = (int32) xVal;
4245 0 : row[i] = (int32) yVal;
4246 :
4247 : /* Store scaled distances if requested */
4248 : /* ----------------------------------- */
4249 0 : if (xval != NULL)
4250 : {
4251 0 : xval[i] = xVal;
4252 : }
4253 :
4254 0 : if (yval != NULL)
4255 : {
4256 0 : yval[i] = yVal;
4257 : }
4258 : }
4259 : }
4260 0 : return (status);
4261 : }
4262 :
4263 : /*----------------------------------------------------------------------------|
4264 : | BEGIN_PROLOG |
4265 : | |
4266 : | FUNCTION: GDgetpixels |
4267 : | |
4268 : | DESCRIPTION: Finds row and columns for specified lon/lat values |
4269 : | |
4270 : | |
4271 : | Return Value Type Units Description |
4272 : | ============ ====== ========= ===================================== |
4273 : | status intn return status (0) SUCCEED, (-1) FAIL |
4274 : | |
4275 : | INPUTS: |
4276 : | gridID int32 Grid structure ID |
4277 : | nLonLat int32 Number of lonlat values |
4278 : | lonVal float64 dec deg Longitude values |
4279 : | latVal float64 dec deg Latitude values |
4280 : | |
4281 : | |
4282 : | OUTPUTS: |
4283 : | pixRow int32 Pixel rows |
4284 : | pixCol int32 Pixel columns |
4285 : | |
4286 : | NOTES: |
4287 : | |
4288 : | |
4289 : | Date Programmer Description |
4290 : | ====== ============ ================================================= |
4291 : | Aug 96 Joel Gales Original Programmer |
4292 : | Oct 96 Joel Gales Set row/col to -1 if outside boundary |
4293 : | Mar 97 Joel Gales Adjust row/col for CORNER pixel registration |
4294 : | |
4295 : | END_PROLOG |
4296 : -----------------------------------------------------------------------------*/
4297 : intn
4298 0 : GDgetpixels(int32 gridID, int32 nLonLat, float64 lonVal[], float64 latVal[],
4299 : int32 pixRow[], int32 pixCol[])
4300 : {
4301 : intn i; /* Loop index */
4302 0 : intn status = 0; /* routine return status variable */
4303 :
4304 : int32 fid; /* HDF-EOS file ID */
4305 : int32 sdInterfaceID; /* HDF SDS interface ID */
4306 : int32 gdVgrpID; /* Grid root Vgroup ID */
4307 :
4308 : int32 xdimsize; /* Size of "XDim" */
4309 : int32 ydimsize; /* Size of "YDim" */
4310 : int32 projcode; /* GCTP projection code */
4311 : int32 zonecode; /* Zone code */
4312 : int32 spherecode; /* Sphere code */
4313 : int32 origincode; /* Origin code */
4314 : int32 pixregcode; /* Pixel registration code */
4315 :
4316 : float64 upleftpt[2];/* Upper left point */
4317 : float64 lowrightpt[2]; /* Lower right point */
4318 : float64 projparm[16]; /* Projection parameters */
4319 : float64 *xVal; /* Pointer to point x location values */
4320 : float64 *yVal; /* Pointer to point y location values */
4321 :
4322 :
4323 : /* Check for valid grid ID */
4324 : /* ----------------------- */
4325 0 : status = GDchkgdid(gridID, "GDgetpixels", &fid, &sdInterfaceID, &gdVgrpID);
4326 :
4327 0 : if (status == 0)
4328 : {
4329 : /* Get grid info */
4330 : /* ------------- */
4331 0 : status = GDgridinfo(gridID, &xdimsize, &ydimsize,
4332 : upleftpt, lowrightpt);
4333 :
4334 :
4335 : /* Get projection info */
4336 : /* ------------------- */
4337 0 : status = GDprojinfo(gridID, &projcode, &zonecode,
4338 : &spherecode, projparm);
4339 :
4340 :
4341 : /* Get explicit upleftpt & lowrightpt if defaults are used */
4342 : /* ------------------------------------------------------- */
4343 0 : status = GDgetdefaults(projcode, zonecode, projparm, spherecode,
4344 : upleftpt, lowrightpt);
4345 :
4346 :
4347 : /* Get pixel registration and origin info */
4348 : /* -------------------------------------- */
4349 0 : status = GDorigininfo(gridID, &origincode);
4350 0 : status = GDpixreginfo(gridID, &pixregcode);
4351 :
4352 :
4353 : /* Allocate space for x & y locations */
4354 : /* ---------------------------------- */
4355 0 : xVal = (float64 *) calloc(nLonLat, sizeof(float64));
4356 0 : if(xVal == NULL)
4357 : {
4358 0 : HEpush(DFE_NOSPACE,"GDgetpixels", __FILE__, __LINE__);
4359 0 : return(-1);
4360 : }
4361 0 : yVal = (float64 *) calloc(nLonLat, sizeof(float64));
4362 0 : if(yVal == NULL)
4363 : {
4364 0 : HEpush(DFE_NOSPACE,"GDgetpixels", __FILE__, __LINE__);
4365 0 : free(xVal);
4366 0 : return(-1);
4367 : }
4368 :
4369 :
4370 : /* Get pixRow, pixCol, xVal, & yVal */
4371 : /* -------------------------------- */
4372 0 : status = GDll2ij(projcode, zonecode, projparm, spherecode,
4373 : xdimsize, ydimsize, upleftpt, lowrightpt,
4374 : nLonLat, lonVal, latVal, pixRow, pixCol,
4375 : xVal, yVal);
4376 :
4377 :
4378 :
4379 : /* Loop through all lon/lat values */
4380 : /* ------------------------------- */
4381 0 : for (i = 0; i < nLonLat; i++)
4382 : {
4383 : /* Adjust columns & rows for "corner" registered grids */
4384 : /* --------------------------------------------------- */
4385 0 : if (pixregcode == HDFE_CORNER)
4386 : {
4387 0 : if (origincode == HDFE_GD_UL)
4388 : {
4389 0 : if (xVal[i] - pixCol[i] > 0.5)
4390 : {
4391 0 : ++pixCol[i];
4392 : }
4393 :
4394 0 : if (yVal[i] - pixRow[i] > 0.5)
4395 : {
4396 0 : ++pixRow[i];
4397 : }
4398 : }
4399 0 : else if (origincode == HDFE_GD_UR)
4400 : {
4401 0 : if (xVal[i] - pixCol[i] <= 0.5)
4402 : {
4403 0 : --pixCol[i];
4404 : }
4405 :
4406 0 : if (yVal[i] - pixRow[i] > 0.5)
4407 : {
4408 0 : ++pixRow[i];
4409 : }
4410 : }
4411 0 : else if (origincode == HDFE_GD_LL)
4412 : {
4413 0 : if (xVal[i] - pixCol[i] > 0.5)
4414 : {
4415 0 : ++pixCol[i];
4416 : }
4417 :
4418 0 : if (yVal[i] - pixRow[i] <= 0.5)
4419 : {
4420 0 : --pixRow[i];
4421 : }
4422 : }
4423 0 : else if (origincode == HDFE_GD_LR)
4424 : {
4425 0 : if (xVal[i] - pixCol[i] <= 0.5)
4426 : {
4427 0 : --pixCol[i];
4428 : }
4429 :
4430 0 : if (yVal[i] - pixRow[i] <= 0.5)
4431 : {
4432 0 : --pixRow[i];
4433 : }
4434 : }
4435 : }
4436 :
4437 :
4438 : /* If outside grid boundaries then set to -1 */
4439 : /* ----------------------------------------- */
4440 0 : if (pixCol[i] < 0 || pixCol[i] >= xdimsize ||
4441 0 : pixRow[i] < 0 || pixRow[i] >= ydimsize)
4442 : {
4443 0 : pixCol[i] = -1;
4444 0 : pixRow[i] = -1;
4445 : }
4446 : }
4447 0 : free(xVal);
4448 0 : free(yVal);
4449 : }
4450 0 : return (status);
4451 : }
4452 :
4453 :
4454 :
4455 :
4456 :
4457 : /*----------------------------------------------------------------------------|
4458 : | BEGIN_PROLOG |
4459 : | |
4460 : | FUNCTION: GDgetpixvalues |
4461 : | |
4462 : | DESCRIPTION: Retrieves data from specified pixels. |
4463 : | |
4464 : | |
4465 : | Return Value Type Units Description |
4466 : | ============ ====== ========= ===================================== |
4467 : | size*nPixels int32 Size of data buffer |
4468 : | |
4469 : | INPUTS: |
4470 : | gridID int32 Grid structure ID |
4471 : | nPixels int32 Number of pixels |
4472 : | pixRow int32 Pixel row numbers |
4473 : | pixCol int32 Pixel column numbers |
4474 : | fieldname char Fieldname |
4475 : | |
4476 : | OUTPUTS: |
4477 : | buffer void Data buffer |
4478 : | |
4479 : | |
4480 : | NOTES: |
4481 : | |
4482 : | |
4483 : | Date Programmer Description |
4484 : | ====== ============ ================================================= |
4485 : | Aug 96 Joel Gales Original Programmer |
4486 : | Oct 96 Joel Gales Check for pixels outside boundaries (-1) |
4487 : | Mar 98 Abe Taaheri revised to reduce overhead for rechecking |
4488 : | for gridid, fieldname, etc in GDreadfield. |
4489 : | June 98 AT fixed bug with 2-dim field merged in 3-dim field |
4490 : | (for offset and count) |
4491 : | END_PROLOG |
4492 : -----------------------------------------------------------------------------*/
4493 : int32
4494 0 : GDgetpixvalues(int32 gridID, int32 nPixels, int32 pixRow[], int32 pixCol[],
4495 : const char *fieldname, VOIDP buffer)
4496 : {
4497 : intn i; /* Loop index */
4498 : intn j; /* Loop index */
4499 0 : intn status = 0; /* routine return status variable */
4500 :
4501 : int32 fid; /* HDF-EOS file ID */
4502 : int32 sdInterfaceID; /* HDF SDS interface ID */
4503 : int32 gdVgrpID; /* Grid root Vgroup ID */
4504 :
4505 : int32 start[8]; /* GDreadfield start array */
4506 : int32 edge[8]; /* GDreadfield edge array */
4507 : int32 dims[8]; /* Field dimensions */
4508 : int32 rank; /* Field rank */
4509 0 : int32 xdum = 0; /* Location of "XDim" within field list */
4510 0 : int32 ydum = 0; /* Location of "YDim" within field list */
4511 : int32 ntype; /* Field number type */
4512 : int32 origincode; /* Origin code */
4513 : int32 bufOffset; /* Data buffer offset */
4514 0 : int32 size = 0; /* Size of returned data buffer for each
4515 : * value in bytes */
4516 : int32 offset[8]; /* I/O offset (start) */
4517 : int32 incr[8]; /* I/O increment (stride) */
4518 : int32 count[8]; /* I/O count (edge) */
4519 : int32 sdid; /* SDS ID */
4520 : int32 rankSDS; /* Rank of SDS */
4521 : int32 rankFld; /* Rank of field */
4522 : int32 dum; /* Dummy variable */
4523 : int32 mrgOffset; /* Merged field offset */
4524 :
4525 : char *dimlist; /* Dimension list */
4526 :
4527 :
4528 :
4529 : /* Allocate space for dimlist */
4530 : /* --------------------------------- */
4531 0 : dimlist = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
4532 0 : if(dimlist == NULL)
4533 : {
4534 0 : HEpush(DFE_NOSPACE,"GDgetpixvalues", __FILE__, __LINE__);
4535 0 : return(-1);
4536 : }
4537 : /* Check for valid grid ID */
4538 : /* ----------------------- */
4539 0 : status = GDchkgdid(gridID, "GDgetpixvalues",
4540 : &fid, &sdInterfaceID, &gdVgrpID);
4541 :
4542 :
4543 0 : if (status == 0)
4544 : {
4545 : /* Get field list */
4546 : /* -------------- */
4547 0 : status = GDfieldinfo(gridID, fieldname, &rank, dims, &ntype, dimlist);
4548 :
4549 :
4550 : /* Check for "XDim" & "YDim" in dimension list */
4551 : /* ------------------------------------------- */
4552 0 : if (status == 0)
4553 : {
4554 0 : xdum = EHstrwithin("XDim", dimlist, ',');
4555 0 : ydum = EHstrwithin("YDim", dimlist, ',');
4556 :
4557 0 : if (xdum == -1)
4558 : {
4559 0 : status = -1;
4560 0 : HEpush(DFE_GENAPP, "GDgetpixvalues", __FILE__, __LINE__);
4561 0 : HEreport(
4562 : "\"XDim\" not present in dimlist for field: \"%s\".\n",
4563 : fieldname);
4564 : }
4565 :
4566 :
4567 0 : if (ydum == -1)
4568 : {
4569 0 : status = -1;
4570 0 : HEpush(DFE_GENAPP, "GDgetpixvalues", __FILE__, __LINE__);
4571 0 : HEreport(
4572 : "\"YDim\" not present in dimlist for field: \"%s\".\n",
4573 : fieldname);
4574 : }
4575 : }
4576 : else
4577 : {
4578 0 : status = -1;
4579 0 : HEpush(DFE_GENAPP, "GDgetpixvalues", __FILE__, __LINE__);
4580 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
4581 : }
4582 :
4583 :
4584 0 : if (status == 0)
4585 : {
4586 :
4587 : /* Get origin order info */
4588 : /* --------------------- */
4589 0 : status = GDorigininfo(gridID, &origincode);
4590 :
4591 :
4592 : /* Initialize start & edge arrays */
4593 : /* ------------------------------ */
4594 0 : for (i = 0; i < rank; i++)
4595 : {
4596 0 : start[i] = 0;
4597 0 : edge[i] = dims[i];
4598 : }
4599 :
4600 :
4601 : /* Compute size of data buffer for each pixel */
4602 : /* ------------------------------------------ */
4603 0 : edge[xdum] = 1;
4604 0 : edge[ydum] = 1;
4605 0 : size = edge[0];
4606 0 : for (j = 1; j < rank; j++)
4607 : {
4608 0 : size *= edge[j];
4609 : }
4610 0 : size *= DFKNTsize(ntype);
4611 :
4612 :
4613 :
4614 : /* If data values are requested ... */
4615 : /* -------------------------------- */
4616 0 : if (buffer != NULL)
4617 : {
4618 : /* get sdid */
4619 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
4620 : &rankSDS, &rankFld, &mrgOffset, dims, &dum);
4621 :
4622 : /* Loop through all pixels */
4623 : /* ----------------------- */
4624 0 : for (i = 0; i < nPixels; i++)
4625 : {
4626 : /* Conmpute offset within returned data buffer */
4627 : /* ------------------------------------------- */
4628 0 : bufOffset = size * i;
4629 :
4630 :
4631 : /* If pixel row & column OK ... */
4632 : /* ---------------------------- */
4633 0 : if (pixCol[i] != -1 && pixRow[i] != -1)
4634 : {
4635 0 : start[xdum] = pixCol[i];
4636 0 : start[ydum] = pixRow[i];
4637 :
4638 :
4639 : /* Adjust X-dim start if origin on right edge */
4640 : /* ------------------------------------------ */
4641 0 : if ((origincode & 1) == 1)
4642 : {
4643 0 : start[xdum] = dims[xdum] - (start[xdum] + 1);
4644 : }
4645 :
4646 :
4647 : /* Adjust Y-dim start if origin on lower edge */
4648 : /* ------------------------------------------ */
4649 0 : if ((origincode & 2) == 2)
4650 : {
4651 0 : start[ydum] = dims[ydum] - (start[ydum] + 1);
4652 : }
4653 :
4654 : /* Set I/O offset and count Section */
4655 : /* ---------------------- */
4656 :
4657 : /*
4658 : * start and edge != NULL, set I/O offset and count to
4659 : * user values, adjusting the
4660 : * 0th field with the merged field offset (if any)
4661 : */
4662 0 : if (rankFld == rankSDS)
4663 : {
4664 0 : for (j = 0; j < rankSDS; j++)
4665 : {
4666 0 : offset[j] = start[j];
4667 0 : count[j] = edge[j];
4668 : }
4669 0 : offset[0] += mrgOffset;
4670 : }
4671 : else
4672 : {
4673 : /*
4674 : * If field really 2-dim merged in 3-dim field then set
4675 : * 0th field offset to merge offset and then next two to
4676 : * the user values
4677 : */
4678 0 : for (j = 0; j < rankFld; j++)
4679 : {
4680 0 : offset[j + 1] = start[j];
4681 0 : count[j + 1] = edge[j];
4682 : }
4683 0 : offset[0] = mrgOffset;
4684 0 : count[0] = 1;
4685 : }
4686 :
4687 :
4688 :
4689 : /* Set I/O stride Section */
4690 : /* ---------------------- */
4691 :
4692 : /* In original code stride entered as NULL.
4693 : Abe Taaheri June 12, 1998 */
4694 : /*
4695 : * If stride == NULL (default) set I/O stride to 1
4696 : */
4697 0 : for (j = 0; j < rankSDS; j++)
4698 : {
4699 0 : incr[j] = 1;
4700 : }
4701 :
4702 :
4703 : /* Read into data buffer */
4704 : /* --------------------- */
4705 0 : status = SDreaddata(sdid,
4706 : offset, incr, count,
4707 : (VOIDP) ((uint8 *) buffer + bufOffset));
4708 : }
4709 : }
4710 : }
4711 : }
4712 : }
4713 :
4714 :
4715 : /* If successful return size of returned data in bytes */
4716 : /* --------------------------------------------------- */
4717 0 : if (status == 0)
4718 : {
4719 0 : free(dimlist);
4720 0 : return (size * nPixels);
4721 : }
4722 : else
4723 : {
4724 0 : free(dimlist);
4725 0 : return ((int32) status);
4726 : }
4727 : }
4728 :
4729 : /***********************************************
4730 : GDwrrdtile --
4731 : This function is the underlying function below GDwritetile and
4732 : GDreadtile.
4733 :
4734 :
4735 : Author--
4736 : Alexis Zubrow
4737 :
4738 : ********************************************************/
4739 :
4740 : static intn
4741 0 : GDwrrdtile(int32 gridID, const char *fieldname, const char *code, int32 start[],
4742 : VOIDP datbuf)
4743 : {
4744 : intn i; /* Loop index */
4745 0 : intn status = 0; /* routine return status variable */
4746 :
4747 : int32 fid; /* HDF-EOS file ID */
4748 : int32 sdInterfaceID; /* HDF SDS interface ID */
4749 : int32 sdid; /* SDS ID */
4750 :
4751 : int32 dum; /* Dummy variable */
4752 : int32 rankSDS; /* Rank of SDS/Field */
4753 :
4754 : int32 dims[8]; /* Field/SDS dimensions */
4755 : int32 tileFlags; /* flag to determine if field is tiled */
4756 : int32 numTileDims;/* number of tiles spanning a dimension */
4757 : HDF_CHUNK_DEF tileDef; /* union holding tiling info. */
4758 :
4759 :
4760 : /* Get gridID */
4761 0 : status = GDchkgdid(gridID, "GDwrrdtile", &fid, &sdInterfaceID, &dum);
4762 0 : if (status == 0)
4763 : {
4764 :
4765 : /* Get field info */
4766 0 : status = GDfieldinfo(gridID, fieldname, &rankSDS, dims, &dum, NULL);
4767 :
4768 0 : if (status == 0)
4769 : {
4770 :
4771 : /* Check whether fieldname is in SDS (multi-dim field) */
4772 : /* --------------------------------------------------- */
4773 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
4774 : &rankSDS, &dum, &dum, dims, &dum);
4775 :
4776 :
4777 :
4778 : /*
4779 : * Check for errors in parameters passed to GDwritetile or
4780 : * GDreadtile
4781 : */
4782 :
4783 : /* Check if untiled field */
4784 0 : status = SDgetchunkinfo(sdid, &tileDef, &tileFlags);
4785 0 : if (tileFlags == HDF_NONE)
4786 : {
4787 0 : HEpush(DFE_GENAPP, "GDwrrdtile", __FILE__, __LINE__);
4788 0 : HEreport("Field \"%s\" is not tiled.\n", fieldname);
4789 0 : status = -1;
4790 0 : return (status);
4791 :
4792 : }
4793 :
4794 : /*
4795 : * Check if rd/wr tilecoords are within the extent of the field
4796 : */
4797 0 : for (i = 0; i < rankSDS; i++)
4798 : {
4799 : /*
4800 : * Calculate the number of tiles which span a dimension of
4801 : * the field
4802 : */
4803 0 : numTileDims = dims[i] / tileDef.chunk_lengths[i];
4804 0 : if ((start[i] >= numTileDims) || (start[i] < 0))
4805 : {
4806 : /*
4807 : * ERROR INDICATING BEYOND EXTENT OF THAT DIMENSION OR
4808 : * NEGATIVE TILECOORDS
4809 : */
4810 0 : HEpush(DFE_GENAPP, "GDwrrdtile", __FILE__, __LINE__);
4811 0 : HEreport("Tilecoords for dimension \"%d\" ...\n", i);
4812 0 : HEreport("is beyond the extent of dimension length\n");
4813 0 : status = -1;
4814 :
4815 : }
4816 : }
4817 :
4818 0 : if (status == -1)
4819 : {
4820 0 : return (status);
4821 : }
4822 :
4823 :
4824 : /* Actually write/read to the field */
4825 :
4826 0 : if (strcmp(code, "w") == 0) /* write tile */
4827 : {
4828 0 : status = SDwritechunk(sdid, start, (VOIDP) datbuf);
4829 : }
4830 0 : else if (strcmp(code, "r") == 0) /* read tile */
4831 : {
4832 0 : status = SDreadchunk(sdid, start, (VOIDP) datbuf);
4833 : }
4834 :
4835 :
4836 : }
4837 :
4838 : /* Non-existent fieldname */
4839 : else
4840 : {
4841 0 : HEpush(DFE_GENAPP, "GDwrrdtile", __FILE__, __LINE__);
4842 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
4843 0 : status = -1;
4844 : }
4845 :
4846 : }
4847 :
4848 0 : return (status);
4849 : }
4850 :
4851 : /***********************************************
4852 : GDtileinfo --
4853 : This function queries the field to determine if it is tiled. If it is
4854 : tile, one can retrieve some of the characteristics of the tiles.
4855 :
4856 : Author-- Alexis Zubrow
4857 :
4858 : ********************************************************/
4859 :
4860 :
4861 : intn
4862 0 : GDtileinfo(int32 gridID, const char *fieldname, int32 * tilecode, int32 * tilerank,
4863 : int32 tiledims[])
4864 :
4865 : {
4866 : intn i; /* Loop index */
4867 0 : intn status = 0; /* routine return status variable */
4868 :
4869 : int32 fid; /* HDF-EOS file ID */
4870 : int32 sdInterfaceID; /* HDF SDS interface ID */
4871 : int32 sdid; /* SDS ID */
4872 :
4873 : int32 dum; /* Dummy variable */
4874 : int32 rankSDS; /* Rank of SDS/Field/tile */
4875 :
4876 : int32 dims[8]; /* Field/SDS dimensions */
4877 : int32 tileFlags; /* flag to determine if field is tiled */
4878 : HDF_CHUNK_DEF tileDef; /* union holding tiling info. */
4879 :
4880 :
4881 : /* Check if improper gridID */
4882 0 : status = GDchkgdid(gridID, "GDtileinfo", &fid, &sdInterfaceID, &dum);
4883 0 : if (status == 0)
4884 : {
4885 :
4886 : /* Get field info */
4887 0 : status = GDfieldinfo(gridID, fieldname, &rankSDS, dims, &dum, NULL);
4888 :
4889 0 : if (status == 0)
4890 : {
4891 :
4892 : /* Check whether fieldname is in SDS (multi-dim field) */
4893 : /* --------------------------------------------------- */
4894 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname, &sdid,
4895 : &rankSDS, &dum, &dum, dims, &dum);
4896 :
4897 :
4898 :
4899 : /* Query field for tiling information */
4900 0 : status = SDgetchunkinfo(sdid, &tileDef, &tileFlags);
4901 :
4902 : /* If field is untiled, return untiled flag */
4903 0 : if (tileFlags == HDF_NONE)
4904 : {
4905 0 : *tilecode = HDFE_NOTILE;
4906 0 : return (status);
4907 : }
4908 :
4909 : /* IF field is tiled or tiled with compression */
4910 0 : else if ((tileFlags == HDF_CHUNK) ||
4911 0 : (tileFlags == (HDF_CHUNK | HDF_COMP)))
4912 : {
4913 0 : if (tilecode != NULL)
4914 : {
4915 0 : *tilecode = HDFE_TILE;
4916 : }
4917 0 : if (tilerank != NULL)
4918 : {
4919 0 : *tilerank = rankSDS;
4920 : }
4921 0 : if (tiledims != NULL)
4922 : {
4923 : /* Assign size of tile dimensions */
4924 0 : for (i = 0; i < rankSDS; i++)
4925 : {
4926 0 : tiledims[i] = tileDef.chunk_lengths[i];
4927 : }
4928 : }
4929 : }
4930 : }
4931 :
4932 : /* Non-existent fieldname */
4933 : else
4934 : {
4935 0 : HEpush(DFE_GENAPP, "GDtileinfo", __FILE__, __LINE__);
4936 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
4937 0 : status = -1;
4938 : }
4939 :
4940 : }
4941 0 : return (status);
4942 : }
4943 :
4944 : /***********************************************
4945 : GDreadtile --
4946 : This function reads one tile from a particular field.
4947 :
4948 :
4949 : Author--
4950 : Alexis Zubrow
4951 :
4952 : ********************************************************/
4953 :
4954 : intn
4955 0 : GDreadtile(int32 gridID, const char *fieldname, int32 tilecoords[],
4956 : VOIDP tileData)
4957 : {
4958 0 : char code[] = "r"; /* read tile code */
4959 0 : intn status = 0; /* routine return status variable */
4960 :
4961 0 : status = GDwrrdtile(gridID, fieldname, code, tilecoords, tileData);
4962 :
4963 0 : return (status);
4964 : }
4965 :
4966 : /*----------------------------------------------------------------------------|
4967 : | BEGIN_PROLOG |
4968 : | |
4969 : | FUNCTION: GDsdid |
4970 : | |
4971 : | DESCRIPTION: Returns SD element ID for grid field |
4972 : | |
4973 : | |
4974 : | Return Value Type Units Description |
4975 : | ============ ====== ========= ===================================== |
4976 : | status intn return status (0) SUCCEED, (-1) FAIL |
4977 : | |
4978 : | INPUTS: |
4979 : | gridID int32 grid structure ID |
4980 : | fieldname const char field name |
4981 : | |
4982 : | |
4983 : | OUTPUTS: |
4984 : | sdid int32 SD element ID |
4985 : | |
4986 : | NOTES: |
4987 : | |
4988 : | |
4989 : | Date Programmer Description |
4990 : | ====== ============ ================================================= |
4991 : | Oct 07 Andrey Kiselev Original Programmer |
4992 : | |
4993 : | END_PROLOG |
4994 : -----------------------------------------------------------------------------*/
4995 : intn
4996 0 : GDsdid(int32 gridID, const char *fieldname, int32 *sdid)
4997 : {
4998 : intn status; /* routine return status variable */
4999 : int32 fid; /* HDF-EOS file ID */
5000 : int32 sdInterfaceID; /* HDF SDS interface ID */
5001 : int32 dum; /* Dummy variable */
5002 : int32 dims[H4_MAX_VAR_DIMS]; /* Field/SDS dimensions */
5003 :
5004 0 : status = GDchkgdid(gridID, "GDsdid", &fid, &sdInterfaceID, &dum);
5005 0 : if (status != -1)
5006 : {
5007 0 : status = GDSDfldsrch(gridID, sdInterfaceID, fieldname,
5008 : sdid, &dum, &dum, &dum, dims, &dum);
5009 : }
5010 :
5011 0 : return (status);
5012 : }
|
