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 :
29 : June 05, 2003 Abe Taaheri / Bruce Beaumont
30 :
31 : Changed MAXNREGIONS to 1024 to support MOPITT data
32 : Supplied cast for compcode in call to
33 : SDsetcompress to avoid compiler error
34 : Removed declaration for unused variable rstatus
35 : in SWwrrdfield
36 : Removed initialization code for unused variables
37 : in SWwrrdfield
38 : Removed declaration for unused variable tmpVal
39 : in SWdefboxregion
40 : Added code in SWdefboxregion to check for l_index k
41 : exceeding NSWATHREGN to avoid overwriting
42 : memory
43 : Removed declaration for unused variable retchar
44 : in SWregionl_index
45 : Removed initialization code for unused variables
46 : in SWregionl_index
47 : Removed declarations for unused variables tstatus,
48 : nfields, nflgs, and swathname in SWextractregion
49 : Removed initialization code for unused variables
50 : in SWextractregion
51 : Removed declaration for unused variable
52 : land_status in SWscan2longlat
53 : Removed initialization code for unused variables
54 : in SWscan2longlat
55 : Added clear (0) of timeflag in SWextractperiod if
56 : return status from SWextractregion is non-zero
57 : Removed declarations for unused variables tstatus,
58 : scandim, ndfields, ndflds, and swathname in
59 : SWregioninfo
60 : Removed initialization code for unused variables
61 : in SWregioninfo
62 : Added clear (0) of timeflag in SWperiodinfo if
63 : return status from SWregioninfo is non-zero
64 : Removed declarations for unused variables size,
65 : nfields, nflds, nswath, idxsz, cornerlon, and
66 : cornerlat in SWdefscanregion
67 : Removed initialization code for unused variables
68 : in SWdefscanregion
69 : Removed declarations for unused variables dims2,
70 : rank, nt, swathname, dimlist, and buffer in
71 : SWupdateidxmap
72 : Removed declaration for unused variable statmeta
73 : in SWgeomapinfo
74 : ******************************************************************************/
75 :
76 : #include "cpl_port.h" /* for M_PI */
77 : #include "cpl_string.h" /* for CPLsnprintf */
78 :
79 : #include "mfhdf.h"
80 : #include "hcomp.h"
81 : #include "HdfEosDef.h"
82 : #include <math.h>
83 :
84 : #include "hdf4compat.h"
85 :
86 : #define SWIDOFFSET 1048576
87 :
88 :
89 : static int32 SWX1dcomb[512*3];
90 :
91 : /* Added for routine that converts scanline to Lat/long
92 : ** for floating scene subsetting
93 : ** Jul 1999 DaW
94 : */
95 : #define RADOE 6371.0 /* Radius of Earth in Km */
96 :
97 : #define NSWATH 200
98 : /* Swath Structure External Arrays */
99 : struct swathStructure
100 : {
101 : int32 active;
102 : int32 IDTable;
103 : int32 VIDTable[3];
104 : int32 fid;
105 : int32 nSDS;
106 : int32 *sdsID;
107 : int32 compcode;
108 : intn compparm[5];
109 : int32 tilecode;
110 : int32 tilerank;
111 : int32 tiledims[8];
112 : };
113 : static struct swathStructure SWXSwath[NSWATH];
114 :
115 :
116 :
117 : #define NSWATHREGN 256
118 : #define MAXNREGIONS 1024
119 : struct swathRegion
120 : {
121 : int32 fid;
122 : int32 swathID;
123 : int32 nRegions;
124 : int32 StartRegion[MAXNREGIONS];
125 : int32 StopRegion[MAXNREGIONS];
126 : int32 StartVertical[8];
127 : int32 StopVertical[8];
128 : int32 StartScan[8];
129 : int32 StopScan[8];
130 : char *DimNamePtr[8];
131 : intn band8flag;
132 : intn scanflag;
133 : };
134 : static struct swathRegion *SWXRegion[NSWATHREGN];
135 :
136 : /* define a macro for the string size of the utility strings. The value
137 : of 80 in previous version of this code was resulting in core dump (Array
138 : Bounds Write and Array Bounds Read problem in SWfinfo function and the
139 : functions called from there) for 7-8 dimensional fields where the
140 : string length for "DimList" can exceed 80 characters, including " and
141 : commas in the string. The length now is 512 which seems to be more
142 : than enough to avoid the problem mentioned above. */
143 :
144 : #define UTLSTR_MAX_SIZE 512
145 :
146 : /* Swath Prototypes (internal routines) */
147 : static intn SWchkswid(int32, const char *, int32 *, int32 *, int32 *);
148 : static int32 SWfinfo(int32, const char *, const char *, int32 *,
149 : int32 [], int32 *, char *);
150 : static intn SWwrrdattr(int32, const char *, int32, int32, const char *, VOIDP);
151 : static intn SW1dfldsrch(int32, int32, const char *, const char *, int32 *,
152 : int32 *, int32 *);
153 : static intn SWSDfldsrch(int32, int32, const char *, int32 *, int32 *,
154 : int32 *, int32 *, int32 [], int32 *);
155 : static intn SWwrrdfield(int32, const char *, const char *,
156 : int32 [], int32 [], int32 [], VOIDP);
157 : static int32 SWinqfields(int32, const char *, char *, int32 [], int32 []);
158 :
159 : /*----------------------------------------------------------------------------|
160 : | BEGIN_PROLOG |
161 : | |
162 : | FUNCTION: SWopen |
163 : | |
164 : | DESCRIPTION: |
165 : | |
166 : | |
167 : | Return Value Type Units Description |
168 : | ============ ====== ========= ===================================== |
169 : | fid int32 HDF-EOS file ID |
170 : | |
171 : | INPUTS: |
172 : | filename char Filename |
173 : | access intn HDF access code |
174 : | |
175 : | |
176 : | OUTPUTS: |
177 : | None |
178 : | |
179 : | NOTES: |
180 : | |
181 : | |
182 : | Date Programmer Description |
183 : | ====== ============ ================================================= |
184 : | Jun 96 Joel Gales Original Programmer |
185 : | |
186 : | END_PROLOG |
187 : -----------------------------------------------------------------------------*/
188 : int32
189 4 : SWopen(const char *filename, intn i_access)
190 :
191 : {
192 : int32 fid /* HDF-EOS file ID */ ;
193 :
194 : /* Call EHopen to perform file access */
195 : /* ---------------------------------- */
196 4 : fid = EHopen(filename, i_access);
197 :
198 4 : return (fid);
199 : }
200 :
201 : /*----------------------------------------------------------------------------|
202 : | BEGIN_PROLOG |
203 : | |
204 : | FUNCTION: SWattach |
205 : | |
206 : | DESCRIPTION: Attaches to an existing swath within the file. |
207 : | |
208 : | |
209 : | Return Value Type Units Description |
210 : | ============ ====== ========= ===================================== |
211 : | swathID int32 swath structure ID |
212 : | |
213 : | INPUTS: |
214 : | fid int32 HDF-EOS file ID |
215 : | swathname char swath structure name |
216 : | |
217 : | OUTPUTS: |
218 : | None |
219 : | |
220 : | NOTES: |
221 : | |
222 : | |
223 : | Date Programmer Description |
224 : | ====== ============ ================================================= |
225 : | Jun 96 Joel Gales Original Programmer |
226 : | Apr 99 David Wynne Modified test for memory allocation check when no |
227 : | SDSs are in the Swath, NCR22513 |
228 : | |
229 : | END_PROLOG |
230 : -----------------------------------------------------------------------------*/
231 : int32
232 0 : SWattach(int32 fid, const char *swathname)
233 :
234 : {
235 : intn i; /* Loop index */
236 : intn j; /* Loop index */
237 0 : intn nswathopen = 0; /* # of swath structures open */
238 : intn status; /* routine return status variable */
239 :
240 : uint8 acs; /* Read/Write file access code */
241 :
242 : int32 HDFfid; /* HDF file id */
243 : int32 vgRef; /* Vgroup reference number */
244 : int32 vgid[4]; /* Vgroup ID array */
245 0 : int32 swathID = -1; /* HDF-EOS swath ID */
246 : int32 *tags; /* Pnt to Vgroup object tags array */
247 : int32 *refs; /* Pnt to Vgroup object refs array */
248 : int32 dum; /* dummy variable */
249 : int32 sdInterfaceID; /* HDF SDS interface ID */
250 : int32 nObjects; /* # of objects in Vgroup */
251 : int32 nSDS; /* SDS counter */
252 : int32 l_index; /* SDS l_index */
253 : int32 sdid; /* SDS object ID */
254 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
255 :
256 : char name[80]; /* Vgroup name */
257 : char class[80]; /* Vgroup class */
258 : char errbuf[256];/* Buffer for error message */
259 : char acsCode[1]; /* Read/Write access char: "r/w" */
260 :
261 :
262 : /* Check HDF-EOS file ID, get back HDF file ID and access code */
263 : /* ----------------------------------------------------------- */
264 0 : status = EHchkfid(fid, swathname, &HDFfid, &dum, &acs);
265 :
266 :
267 0 : if (status == 0)
268 : {
269 : /* Convert numeric access code to character */
270 : /* ---------------------------------------- */
271 0 : acsCode[0] = (acs == 1) ? 'w' : 'r';
272 :
273 : /* Determine number of swaths currently opened */
274 : /* ------------------------------------------- */
275 0 : for (i = 0; i < NSWATH; i++)
276 : {
277 0 : nswathopen += SWXSwath[i].active;
278 : }
279 :
280 : /* If room for more ... */
281 : /* -------------------- */
282 0 : if (nswathopen < NSWATH)
283 : {
284 :
285 : /* Search Vgroups for Swath */
286 : /* ------------------------ */
287 0 : vgRef = -1;
288 :
289 : while (1)
290 : {
291 0 : vgRef = Vgetid(HDFfid, vgRef);
292 :
293 :
294 : /* If no more Vgroups then exist while loop */
295 : /* ---------------------------------------- */
296 0 : if (vgRef == -1)
297 : {
298 0 : break;
299 : }
300 :
301 : /* Get name and class of Vgroup */
302 : /* ---------------------------- */
303 0 : vgid[0] = Vattach(HDFfid, vgRef, "r");
304 0 : Vgetname(vgid[0], name);
305 0 : Vgetclass(vgid[0], class);
306 :
307 :
308 : /*
309 : * If Vgroup with swathname and class SWATH found, load
310 : * tables
311 : */
312 :
313 0 : if (strcmp(name, swathname) == 0 &&
314 0 : strcmp(class, "SWATH") == 0)
315 : {
316 : /* Attach to "Fields" and "Swath Attributes" Vgroups */
317 : /* ------------------------------------------------- */
318 0 : tags = (int32 *) malloc(sizeof(int32) * 3);
319 0 : if(tags == NULL)
320 : {
321 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
322 0 : return(-1);
323 : }
324 0 : refs = (int32 *) malloc(sizeof(int32) * 3);
325 0 : if(refs == NULL)
326 : {
327 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
328 0 : free(tags);
329 0 : return(-1);
330 : }
331 0 : Vgettagrefs(vgid[0], tags, refs, 3);
332 0 : vgid[1] = Vattach(HDFfid, refs[0], acsCode);
333 0 : vgid[2] = Vattach(HDFfid, refs[1], acsCode);
334 0 : vgid[3] = Vattach(HDFfid, refs[2], acsCode);
335 0 : free(tags);
336 0 : free(refs);
337 :
338 : /* Setup External Arrays */
339 : /* --------------------- */
340 0 : for (i = 0; i < NSWATH; i++)
341 : {
342 : /* Find empty entry in array */
343 : /* ------------------------- */
344 0 : if (SWXSwath[i].active == 0)
345 : {
346 : /*
347 : * Set swathID, Set swath entry active, Store
348 : * root Vgroup ID, Store sub Vgroup IDs, Store
349 : * HDF-EOS file ID
350 : */
351 0 : swathID = i + idOffset;
352 0 : SWXSwath[i].active = 1;
353 0 : SWXSwath[i].IDTable = vgid[0];
354 0 : SWXSwath[i].VIDTable[0] = vgid[1];
355 0 : SWXSwath[i].VIDTable[1] = vgid[2];
356 0 : SWXSwath[i].VIDTable[2] = vgid[3];
357 0 : SWXSwath[i].fid = fid;
358 0 : break;
359 : }
360 : }
361 :
362 : /* Get SDS interface ID */
363 : /* -------------------- */
364 0 : status = SWchkswid(swathID, "SWattach", &dum,
365 : &sdInterfaceID, &dum);
366 :
367 :
368 : /* Access swath "Geolocation" SDS */
369 : /* ------------------------------ */
370 :
371 : /* Get # of entries within this Vgroup & search for SDS */
372 : /* ---------------------------------------------------- */
373 0 : nObjects = Vntagrefs(vgid[1]);
374 :
375 0 : if (nObjects > 0)
376 : {
377 : /* Get tag and ref # for Geolocation Vgroup objects */
378 : /* ------------------------------------------------ */
379 0 : tags = (int32 *) malloc(sizeof(int32) * nObjects);
380 0 : if(tags == NULL)
381 : {
382 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
383 0 : return(-1);
384 : }
385 0 : refs = (int32 *) malloc(sizeof(int32) * nObjects);
386 0 : if(refs == NULL)
387 : {
388 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
389 0 : free(tags);
390 0 : return(-1);
391 : }
392 0 : Vgettagrefs(vgid[1], tags, refs, nObjects);
393 :
394 : /* Count number of SDS & allocate SDS ID array */
395 : /* ------------------------------------------- */
396 0 : nSDS = 0;
397 0 : for (j = 0; j < nObjects; j++)
398 : {
399 0 : if (tags[j] == DFTAG_NDG)
400 : {
401 0 : nSDS++;
402 : }
403 : }
404 0 : SWXSwath[i].sdsID = (int32 *) calloc(nSDS, 4);
405 0 : if(SWXSwath[i].sdsID == NULL && nSDS != 0)
406 : {
407 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
408 0 : free(tags);
409 0 : free(refs);
410 0 : return(-1);
411 : }
412 0 : nSDS = 0;
413 :
414 :
415 : /* Fill SDS ID array */
416 : /* ----------------- */
417 0 : for (j = 0; j < nObjects; j++)
418 : {
419 : /* If object is SDS then get id */
420 : /* ---------------------------- */
421 0 : if (tags[j] == DFTAG_NDG)
422 : {
423 0 : l_index = SDreftoindex(sdInterfaceID, refs[j]);
424 0 : sdid = SDselect(sdInterfaceID, l_index);
425 0 : SWXSwath[i].sdsID[nSDS] = sdid;
426 0 : nSDS++;
427 0 : SWXSwath[i].nSDS++;
428 : }
429 : }
430 0 : free(tags);
431 0 : free(refs);
432 : }
433 :
434 : /* Access swath "Data" SDS */
435 : /* ----------------------- */
436 :
437 : /* Get # of entries within this Vgroup & search for SDS */
438 : /* ---------------------------------------------------- */
439 0 : nObjects = Vntagrefs(vgid[2]);
440 :
441 0 : if (nObjects > 0)
442 : {
443 : /* Get tag and ref # for Data Vgroup objects */
444 : /* ----------------------------------------- */
445 0 : tags = (int32 *) malloc(sizeof(int32) * nObjects);
446 0 : if(tags == NULL)
447 : {
448 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
449 0 : return(-1);
450 : }
451 0 : refs = (int32 *) malloc(sizeof(int32) * nObjects);
452 0 : if(refs == NULL)
453 : {
454 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
455 0 : free(tags);
456 0 : return(-1);
457 : }
458 0 : Vgettagrefs(vgid[2], tags, refs, nObjects);
459 :
460 :
461 : /* Count number of SDS & allocate SDS ID array */
462 : /* ------------------------------------------- */
463 0 : nSDS = 0;
464 0 : for (j = 0; j < nObjects; j++)
465 : {
466 0 : if (tags[j] == DFTAG_NDG)
467 : {
468 0 : nSDS++;
469 : }
470 : }
471 0 : SWXSwath[i].sdsID = (int32 *)
472 0 : realloc((void *) SWXSwath[i].sdsID,
473 0 : (SWXSwath[i].nSDS + nSDS) * 4);
474 0 : if(SWXSwath[i].sdsID == NULL && nSDS != 0)
475 : {
476 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
477 0 : return(-1);
478 : }
479 :
480 : /* Fill SDS ID array */
481 : /* ----------------- */
482 0 : for (j = 0; j < nObjects; j++)
483 : {
484 : /* If object is SDS then get id */
485 : /* ---------------------------- */
486 0 : if (tags[j] == DFTAG_NDG)
487 : {
488 0 : l_index = SDreftoindex(sdInterfaceID, refs[j]);
489 0 : sdid = SDselect(sdInterfaceID, l_index);
490 0 : SWXSwath[i].sdsID[SWXSwath[i].nSDS] = sdid;
491 0 : SWXSwath[i].nSDS++;
492 : }
493 : }
494 0 : free(tags);
495 0 : free(refs);
496 : }
497 0 : break;
498 : }
499 :
500 : /* Detach Vgroup if not desired Swath */
501 : /* ---------------------------------- */
502 0 : Vdetach(vgid[0]);
503 : }
504 :
505 : /* If Swath not found then set up error message */
506 : /* -------------------------------------------- */
507 0 : if (swathID == -1)
508 : {
509 0 : HEpush(DFE_RANGE, "SWattach", __FILE__, __LINE__);
510 0 : HEreport("Swath: \"%s\" does not exist within HDF file.\n",
511 : swathname);
512 : }
513 : }
514 : else
515 : {
516 : /* Too many files opened */
517 : /* --------------------- */
518 0 : swathID = -1;
519 0 : strcpy(errbuf,
520 : "No more than %d swaths may be open simultaneously");
521 0 : strcat(errbuf, " (%s)");
522 0 : HEpush(DFE_DENIED, "SWattach", __FILE__, __LINE__);
523 0 : HEreport(errbuf, NSWATH, swathname);
524 : }
525 :
526 : }
527 0 : return (swathID);
528 : }
529 :
530 : /*----------------------------------------------------------------------------|
531 : | BEGIN_PROLOG |
532 : | |
533 : | FUNCTION: SWchkswid |
534 : | |
535 : | DESCRIPTION: Checks for valid swathID and returns file ID, SDS ID, and |
536 : | swath Vgroup ID |
537 : | |
538 : | |
539 : | Return Value Type Units Description |
540 : | ============ ====== ========= ===================================== |
541 : | status intn return status (0) SUCCEED, (-1) FAIL |
542 : | |
543 : | INPUTS: |
544 : | swathID int32 swath structure ID |
545 : | routname char Name of routine calling SWchkswid |
546 : | |
547 : | OUTPUTS: |
548 : | fid int32 File ID |
549 : | sdInterfaceID int32 SDS interface ID |
550 : | swVgrpID int32 swath Vgroup ID |
551 : | |
552 : | NOTES: |
553 : | |
554 : | |
555 : | Date Programmer Description |
556 : | ====== ============ ================================================= |
557 : | Jun 96 Joel Gales Original Programmer |
558 : | |
559 : | END_PROLOG |
560 : -----------------------------------------------------------------------------*/
561 : static intn
562 0 : SWchkswid(int32 swathID, const char *routname,
563 : int32 * fid, int32 * sdInterfaceID, int32 * swVgrpID)
564 :
565 : {
566 0 : intn status = 0; /* routine return status variable */
567 : uint8 l_access; /* Read/Write access code */
568 :
569 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
570 :
571 0 : char message1[] =
572 : "Invalid swath id: %d in routine \"%s\". ID must be >= %d and < %d.\n";
573 0 : char message2[] =
574 : "Swath id %d in routine \"%s\" not active.\n";
575 :
576 :
577 : /* Check for valid swath id */
578 : /* ------------------------ */
579 0 : if (swathID < idOffset || swathID >= NSWATH + idOffset)
580 : {
581 0 : status = -1;
582 0 : HEpush(DFE_RANGE, "SWchkswid", __FILE__, __LINE__);
583 0 : HEreport(message1, swathID, routname, idOffset, NSWATH + idOffset);
584 : }
585 : else
586 : {
587 0 : int sID = swathID % idOffset;
588 : /* Check for active swath ID */
589 : /* ------------------------- */
590 0 : if (SWXSwath[sID].active == 0)
591 : {
592 0 : status = -1;
593 0 : HEpush(DFE_GENAPP, "SWchkswid", __FILE__, __LINE__);
594 0 : HEreport(message2, swathID, routname);
595 : }
596 : else
597 : {
598 :
599 : /* Get file & SDS ids and Swath Vgroup */
600 : /* ----------------------------------- */
601 0 : status = EHchkfid(SWXSwath[sID].fid, " ", fid,
602 : sdInterfaceID, &l_access);
603 0 : *swVgrpID = SWXSwath[sID].IDTable;
604 : }
605 : }
606 0 : return (status);
607 : }
608 :
609 :
610 :
611 : /*----------------------------------------------------------------------------|
612 : | BEGIN_PROLOG |
613 : | |
614 : | FUNCTION: SWdiminfo |
615 : | |
616 : | DESCRIPTION: Returns size in bytes of named dimension |
617 : | |
618 : | |
619 : | Return Value Type Units Description |
620 : | ============ ====== ========= ===================================== |
621 : | size int32 Size of dimension |
622 : | |
623 : | INPUTS: |
624 : | swathID int32 swath structure id |
625 : | dimname char Dimension name |
626 : | |
627 : | |
628 : | OUTPUTS: |
629 : | None |
630 : | |
631 : | NOTES: |
632 : | |
633 : | |
634 : | Date Programmer Description |
635 : | ====== ============ ================================================= |
636 : | Jun 96 Joel Gales Original Programmer |
637 : | Aug 96 Joel Gales Make metadata ODL compliant |
638 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
639 : | |
640 : | END_PROLOG |
641 : -----------------------------------------------------------------------------*/
642 : int32
643 0 : SWdiminfo(int32 swathID, const char *dimname)
644 :
645 : {
646 : intn status; /* routine return status variable */
647 :
648 : int32 fid; /* HDF-EOS file ID */
649 : int32 sdInterfaceID; /* HDF SDS interface ID */
650 : int32 swVgrpID; /* Swath root Vgroup ID */
651 : int32 size; /* Dimension size */
652 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
653 :
654 :
655 : char *metabuf; /* Pointer to structural metadata (SM) */
656 : char *metaptrs[2];/* Pointers to begin and end of SM section */
657 : char swathname[80]; /* Swath Name */
658 : char *utlstr; /* Utility string */
659 :
660 :
661 : /* Allocate space for utility string */
662 : /* --------------------------------- */
663 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
664 0 : if(utlstr == NULL)
665 : {
666 0 : HEpush(DFE_NOSPACE,"SWdiminfo", __FILE__, __LINE__);
667 0 : return(-1);
668 : }
669 : /* Initialize return value */
670 0 : size = -1;
671 :
672 : /* Check Swath ID */
673 0 : status = SWchkswid(swathID, "SWdiminfo", &fid, &sdInterfaceID, &swVgrpID);
674 :
675 0 : if (status == 0)
676 : {
677 : /* Get swath name */
678 0 : int sID = swathID % idOffset;
679 0 : if (sID >= NSWATH)
680 : {
681 0 : free(utlstr);
682 0 : return -1;
683 : }
684 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
685 :
686 : /* Get pointers to "Dimension" section within SM */
687 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
688 : "Dimension", metaptrs);
689 :
690 0 : if(metabuf == NULL)
691 : {
692 0 : free(utlstr);
693 0 : return(-1);
694 : }
695 :
696 : /* Search for dimension name (surrounded by quotes) */
697 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", dimname, "\"\n");
698 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
699 :
700 : /*
701 : * If dimension found within swath structure then get dimension value
702 : */
703 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
704 : {
705 : /* Set endptr at end of dimension definition entry */
706 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
707 :
708 0 : status = EHgetmetavalue(metaptrs, "Size", utlstr);
709 :
710 0 : if (status == 0)
711 : {
712 0 : size = atoi(utlstr);
713 : }
714 : else
715 : {
716 0 : HEpush(DFE_GENAPP, "SWdiminfo", __FILE__, __LINE__);
717 0 : HEreport("\"Size\" string not found in metadata.\n");
718 : }
719 : }
720 : else
721 : {
722 0 : HEpush(DFE_GENAPP, "SWdiminfo", __FILE__, __LINE__);
723 0 : HEreport("Dimension \"%s\" not found.\n", dimname);
724 : }
725 :
726 0 : free(metabuf);
727 : }
728 0 : free(utlstr);
729 :
730 0 : return (size);
731 : }
732 :
733 :
734 :
735 :
736 : /*----------------------------------------------------------------------------|
737 : | BEGIN_PROLOG |
738 : | |
739 : | FUNCTION: SWmapinfo |
740 : | |
741 : | DESCRIPTION: Returns dimension mapping information |
742 : | |
743 : | |
744 : | Return Value Type Units Description |
745 : | ============ ====== ========= ===================================== |
746 : | status intn return status (0) SUCCEED, (-1) FAIL |
747 : | |
748 : | INPUTS: |
749 : | swathID int32 swath structure id |
750 : | geodim char geolocation dimension name |
751 : | datadim char data dimension name |
752 : | |
753 : | OUTPUTS: |
754 : | offset int32 mapping offset |
755 : | increment int32 mapping increment |
756 : | |
757 : | NOTES: |
758 : | |
759 : | |
760 : | Date Programmer Description |
761 : | ====== ============ ================================================= |
762 : | Jun 96 Joel Gales Original Programmer |
763 : | Aug 96 Joel Gales Make metadata ODL compliant |
764 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
765 : | |
766 : | END_PROLOG |
767 : -----------------------------------------------------------------------------*/
768 : intn
769 0 : SWmapinfo(int32 swathID, const char *geodim, const char *datadim, int32 * offset,
770 : int32 * increment)
771 :
772 : {
773 : intn status; /* routine return status variable */
774 0 : intn statmeta = 0; /* EHgetmetavalue return status */
775 :
776 : int32 fid; /* HDF-EOS file ID */
777 : int32 sdInterfaceID; /* HDF SDS interface ID */
778 : int32 swVgrpID; /* Swath root Vgroup ID */
779 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
780 :
781 : char *metabuf; /* Pointer to structural metadata (SM) */
782 : char *metaptrs[2];/* Pointers to begin and end of SM section */
783 : char swathname[80]; /* Swath Name */
784 : char *utlstr; /* Utility string */
785 :
786 :
787 : /* Allocate space for utility string */
788 : /* --------------------------------- */
789 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
790 0 : if(utlstr == NULL)
791 : {
792 0 : HEpush(DFE_NOSPACE,"SWmapinfo", __FILE__, __LINE__);
793 0 : return(-1);
794 : }
795 : /* Initialize return values */
796 0 : *offset = -1;
797 0 : *increment = -1;
798 :
799 : /* Check Swath ID */
800 0 : status = SWchkswid(swathID, "SWmapinfo", &fid, &sdInterfaceID, &swVgrpID);
801 :
802 0 : if (status == 0)
803 : {
804 : /* Get swath name */
805 0 : int sID = swathID % idOffset;
806 0 : if (sID >= NSWATH)
807 : {
808 0 : free(utlstr);
809 0 : return -1;
810 : }
811 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
812 :
813 : /* Get pointers to "DimensionMap" section within SM */
814 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
815 : "DimensionMap", metaptrs);
816 0 : if(metabuf == NULL)
817 : {
818 0 : free(utlstr);
819 0 : return(-1);
820 : }
821 :
822 : /* Search for mapping - GeoDim/DataDim (surrounded by quotes) */
823 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s%s%s", "\t\t\t\tGeoDimension=\"", geodim,
824 : "\"\n\t\t\t\tDataDimension=\"", datadim, "\"\n");
825 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
826 :
827 : /*
828 : * If mapping found within swath structure then get offset and
829 : * increment value
830 : */
831 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
832 : {
833 : /* Get Offset */
834 0 : statmeta = EHgetmetavalue(metaptrs, "Offset", utlstr);
835 0 : if (statmeta == 0)
836 : {
837 0 : *offset = atoi(utlstr);
838 : }
839 : else
840 : {
841 0 : status = -1;
842 0 : HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__);
843 0 : HEreport("\"Offset\" string not found in metadata.\n");
844 : }
845 :
846 :
847 : /* Get Increment */
848 0 : statmeta = EHgetmetavalue(metaptrs, "Increment", utlstr);
849 0 : if (statmeta == 0)
850 : {
851 0 : *increment = atoi(utlstr);
852 : }
853 : else
854 : {
855 0 : status = -1;
856 0 : HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__);
857 0 : HEreport("\"Increment\" string not found in metadata.\n");
858 : }
859 : }
860 : else
861 : {
862 0 : status = -1;
863 0 : HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__);
864 0 : HEreport("Mapping \"%s/%s\" not found.\n", geodim, datadim);
865 : }
866 :
867 0 : free(metabuf);
868 : }
869 0 : free(utlstr);
870 0 : return (status);
871 : }
872 :
873 :
874 :
875 :
876 : /*----------------------------------------------------------------------------|
877 : | BEGIN_PROLOG |
878 : | |
879 : | FUNCTION: SWidxmapinfo |
880 : | |
881 : | DESCRIPTION: Returns l_indexed mapping information |
882 : | |
883 : | |
884 : | Return Value Type Units Description |
885 : | ============ ====== ========= ===================================== |
886 : | gsize int32 Number of l_index values (sz of geo dim) |
887 : | |
888 : | INPUTS: |
889 : | swathID int32 swath structure id |
890 : | geodim char geolocation dimension name |
891 : | datadim char data dimension name |
892 : | |
893 : | |
894 : | OUTPUTS: |
895 : | l_index int32 array of l_index values |
896 : | |
897 : | NOTES: |
898 : | |
899 : | |
900 : | Date Programmer Description |
901 : | ====== ============ ================================================= |
902 : | Jun 96 Joel Gales Original Programmer |
903 : | |
904 : | END_PROLOG |
905 : -----------------------------------------------------------------------------*/
906 : int32
907 0 : SWidxmapinfo(int32 swathID, const char *geodim, const char *datadim, int32 l_index[])
908 : {
909 : intn status; /* routine return status variable */
910 :
911 : int32 fid; /* HDF-EOS file ID */
912 : int32 sdInterfaceID; /* HDF SDS interface ID */
913 : int32 swVgrpID; /* Swath root Vgroup ID */
914 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
915 : int32 vgid; /* Swath Attributes Vgroup ID */
916 : int32 vdataID; /* Index Mapping Vdata ID */
917 0 : int32 gsize = -1; /* Size of geo dim */
918 :
919 : char utlbuf[256];/* Utility buffer */
920 :
921 :
922 : /* Check Swath ID */
923 0 : status = SWchkswid(swathID, "SWidxmapinfo",
924 : &fid, &sdInterfaceID, &swVgrpID);
925 :
926 0 : if (status == 0)
927 : {
928 : /* Find Index Mapping Vdata with Swath Attributes Vgroup */
929 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%s%s%s", "INDXMAP:", geodim, "/", datadim);
930 0 : int sID = swathID % idOffset;
931 0 : if (sID >= NSWATH)
932 : {
933 0 : return -1;
934 : }
935 0 : vgid = SWXSwath[sID].VIDTable[2];
936 0 : vdataID = EHgetid(fid, vgid, utlbuf, 1, "r");
937 :
938 : /* If found then get geodim size & read l_index mapping values */
939 0 : if (vdataID != -1)
940 : {
941 0 : gsize = SWdiminfo(swathID, geodim);
942 :
943 0 : VSsetfields(vdataID, "Index");
944 0 : VSread(vdataID, (uint8 *) l_index, 1, FULL_INTERLACE);
945 0 : VSdetach(vdataID);
946 : }
947 : else
948 : {
949 : /*status = -1;*/
950 0 : HEpush(DFE_GENAPP, "SWidxmapinfo", __FILE__, __LINE__);
951 0 : HEreport("Index Mapping \"%s\" not found.\n", utlbuf);
952 : }
953 : }
954 0 : return (gsize);
955 : }
956 :
957 :
958 :
959 :
960 : /*----------------------------------------------------------------------------|
961 : | BEGIN_PROLOG |
962 : | |
963 : | FUNCTION: SWcompinfo |
964 : | |
965 : | DESCRIPTION: |
966 : | |
967 : | |
968 : | Return Value Type Units Description |
969 : | ============ ====== ========= ===================================== |
970 : | status intn |
971 : | |
972 : | INPUTS: |
973 : | swathID int32 |
974 : | compcode int32 |
975 : | compparm intn |
976 : | |
977 : | |
978 : | OUTPUTS: |
979 : | None |
980 : | |
981 : | NOTES: |
982 : | |
983 : | |
984 : | Date Programmer Description |
985 : | ====== ============ ================================================= |
986 : | Oct 96 Joel Gales Original Programmer |
987 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
988 : | |
989 : | END_PROLOG |
990 : -----------------------------------------------------------------------------*/
991 : intn
992 0 : SWcompinfo(int32 swathID, const char *fieldname, int32 * compcode, intn compparm[])
993 : {
994 : intn i; /* Loop Index */
995 : intn status; /* routine return status variable */
996 0 : intn statmeta = 0; /* EHgetmetavalue return status */
997 :
998 : int32 fid; /* HDF-EOS file ID */
999 : int32 sdInterfaceID; /* HDF SDS interface ID */
1000 : int32 swVgrpID; /* Swath root Vgroup ID */
1001 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1002 :
1003 : char *metabuf; /* Pointer to structural metadata (SM) */
1004 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1005 : char swathname[80]; /* Swath Name */
1006 : char *utlstr; /* Utility string */
1007 :
1008 0 : const char *HDFcomp[5] = {"HDFE_COMP_NONE", "HDFE_COMP_RLE",
1009 : "HDFE_COMP_NBIT", "HDFE_COMP_SKPHUFF",
1010 : "HDFE_COMP_DEFLATE"}; /* Compression Codes */
1011 :
1012 : /* Allocate space for utility string */
1013 : /* --------------------------------- */
1014 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1015 0 : if(utlstr == NULL)
1016 : {
1017 0 : HEpush(DFE_NOSPACE,"SWcompinfo", __FILE__, __LINE__);
1018 0 : return(-1);
1019 : }
1020 :
1021 : /* Check Swath ID */
1022 0 : status = SWchkswid(swathID, "SWcompinfo",
1023 : &fid, &sdInterfaceID, &swVgrpID);
1024 :
1025 0 : if (status == 0)
1026 : {
1027 : /* Get swath name */
1028 0 : int sID = swathID % idOffset;
1029 0 : if (sID >= NSWATH)
1030 : {
1031 0 : free(utlstr);
1032 0 : return -1;
1033 : }
1034 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
1035 :
1036 : /* Get pointers to "DataField" section within SM */
1037 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
1038 : "DataField", metaptrs);
1039 0 : if(metabuf == NULL)
1040 : {
1041 0 : free(utlstr);
1042 0 : return(-1);
1043 : }
1044 : /* Search for field */
1045 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
1046 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1047 :
1048 : /* If not found then search in "GeoField" section */
1049 0 : if (metaptrs[0] > metaptrs[1] || metaptrs[0] == NULL)
1050 : {
1051 0 : free(metabuf);
1052 :
1053 : /* Get pointers to "GeoField" section within SM */
1054 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
1055 : "GeoField", metaptrs);
1056 0 : if(metabuf == NULL)
1057 : {
1058 0 : free(utlstr);
1059 0 : return(-1);
1060 : }
1061 : /* Search for field */
1062 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
1063 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1064 : }
1065 :
1066 :
1067 : /* If field found and user wants compression code ... */
1068 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1069 : {
1070 0 : if (compcode != NULL)
1071 : {
1072 : /* Set endptr at end of field's definition entry */
1073 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
1074 :
1075 : /* Get compression type */
1076 0 : statmeta = EHgetmetavalue(metaptrs, "CompressionType", utlstr);
1077 :
1078 : /*
1079 : * Default is no compression if "CompressionType" string not
1080 : * in metadata
1081 : */
1082 0 : *compcode = HDFE_COMP_NONE;
1083 :
1084 : /* If compression code is found ... */
1085 0 : if (statmeta == 0)
1086 : {
1087 : /* Loop through compression types until match */
1088 0 : for (i = 0; i < 5; i++)
1089 : {
1090 0 : if (strcmp(utlstr, HDFcomp[i]) == 0)
1091 : {
1092 0 : *compcode = i;
1093 0 : break;
1094 : }
1095 : }
1096 : }
1097 : }
1098 :
1099 : /* If user wants compression parameters ... */
1100 0 : if (compparm != NULL && compcode != NULL)
1101 : {
1102 : /* Initialize to zero */
1103 0 : for (i = 0; i < 4; i++)
1104 : {
1105 0 : compparm[i] = 0;
1106 : }
1107 :
1108 : /*
1109 : * Get compression parameters if NBIT or DEFLATE compression
1110 : */
1111 0 : if (*compcode == HDFE_COMP_NBIT)
1112 : {
1113 : statmeta =
1114 0 : EHgetmetavalue(metaptrs, "CompressionParams", utlstr);
1115 0 : if (statmeta == 0)
1116 : {
1117 0 : sscanf(utlstr, "(%d,%d,%d,%d)",
1118 : &compparm[0], &compparm[1],
1119 : &compparm[2], &compparm[3]);
1120 : }
1121 : else
1122 : {
1123 0 : status = -1;
1124 0 : HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__);
1125 0 : HEreport(
1126 : "\"CompressionParams\" string not found in metadata.\n");
1127 : }
1128 : }
1129 0 : else if (*compcode == HDFE_COMP_DEFLATE)
1130 : {
1131 : statmeta =
1132 0 : EHgetmetavalue(metaptrs, "DeflateLevel", utlstr);
1133 0 : if (statmeta == 0)
1134 : {
1135 0 : sscanf(utlstr, "%d", &compparm[0]);
1136 : }
1137 : else
1138 : {
1139 0 : status = -1;
1140 0 : HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__);
1141 0 : HEreport(
1142 : "\"DeflateLevel\" string not found in metadata.\n");
1143 : }
1144 : }
1145 : }
1146 : }
1147 : else
1148 : {
1149 0 : HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__);
1150 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
1151 : }
1152 :
1153 0 : free(metabuf);
1154 : }
1155 0 : free(utlstr);
1156 :
1157 0 : return (status);
1158 : }
1159 :
1160 :
1161 :
1162 : /*----------------------------------------------------------------------------|
1163 : | BEGIN_PROLOG |
1164 : | |
1165 : | FUNCTION: SWfinfo |
1166 : | |
1167 : | DESCRIPTION: Returns field info |
1168 : | |
1169 : | |
1170 : | Return Value Type Units Description |
1171 : | ============ ====== ========= ===================================== |
1172 : | status intn return status (0) SUCCEED, (-1) FAIL |
1173 : | |
1174 : | INPUTS: |
1175 : | swathID int32 swath structure id |
1176 : | fieldtype const char fieldtype (geo or data) |
1177 : | fieldname const char name of field |
1178 : | |
1179 : | |
1180 : | OUTPUTS: |
1181 : | rank int32 rank of field (# of dims) |
1182 : | dims int32 field dimensions |
1183 : | numbertype int32 field number type |
1184 : | dimlist char field dimension list |
1185 : | |
1186 : | NOTES: |
1187 : | |
1188 : | |
1189 : | Date Programmer Description |
1190 : | ====== ============ ================================================= |
1191 : | Jun 96 Joel Gales Original Programmer |
1192 : | Aug 96 Joel Gales Make metadata ODL compliant |
1193 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1194 : | |
1195 : | END_PROLOG |
1196 : -----------------------------------------------------------------------------*/
1197 : static int32
1198 0 : SWfinfo(int32 swathID, const char *fieldtype, const char *fieldname,
1199 : int32 *rank, int32 dims[], int32 *numbertype, char *dimlist)
1200 :
1201 : {
1202 : intn i; /* Loop index */
1203 : intn j; /* Loop index */
1204 : intn status; /* routine return status variable */
1205 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1206 :
1207 : int32 fid; /* HDF-EOS file ID */
1208 : int32 sdInterfaceID; /* HDF SDS interface ID */
1209 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1210 : int32 fsize; /* field size in bytes */
1211 0 : int32 ndims = 0; /* Number of dimensions */
1212 : int32 slen[8]; /* Length of each entry in parsed string */
1213 : int32 dum; /* Dummy variable */
1214 : int32 vdataID; /* 1d field vdata ID */
1215 :
1216 : uint8 *buf; /* One-Dim field buffer */
1217 :
1218 : char *metabuf; /* Pointer to structural metadata (SM) */
1219 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1220 : char swathname[80]; /* Swath Name */
1221 : char *utlstr; /* Utility string */
1222 : char *ptr[8]; /* String pointers for parsed string */
1223 : char dimstr[64]; /* Individual dimension entry string */
1224 :
1225 :
1226 : /* Allocate space for utility string */
1227 : /* --------------------------------- */
1228 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1229 0 : if(utlstr == NULL)
1230 : {
1231 0 : HEpush(DFE_NOSPACE,"SWfinfo", __FILE__, __LINE__);
1232 0 : return(-1);
1233 : }
1234 :
1235 : /* Initialize rank and numbertype to -1 (error) */
1236 : /* -------------------------------------------- */
1237 0 : *rank = -1;
1238 0 : *numbertype = -1;
1239 :
1240 : /* Get HDF-EOS file ID and SDS interface ID */
1241 0 : status = SWchkswid(swathID, "SWfinfo", &fid, &sdInterfaceID, &dum);
1242 :
1243 : /* Get swath name */
1244 0 : int sID = swathID % idOffset;
1245 0 : if (sID >= NSWATH)
1246 : {
1247 0 : free(utlstr);
1248 0 : return -1;
1249 : }
1250 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
1251 :
1252 : /* Get pointers to appropriate "Field" section within SM */
1253 0 : if (strcmp(fieldtype, "Geolocation Fields") == 0)
1254 : {
1255 0 : metabuf = EHmetagroup(sdInterfaceID, swathname, "s",
1256 : "GeoField", metaptrs);
1257 :
1258 0 : if(metabuf == NULL)
1259 : {
1260 0 : free(utlstr);
1261 0 : return(-1);
1262 : }
1263 : }
1264 : else
1265 : {
1266 0 : metabuf = EHmetagroup(sdInterfaceID, swathname, "s",
1267 : "DataField", metaptrs);
1268 0 : if(metabuf == NULL)
1269 : {
1270 0 : free(utlstr);
1271 0 : return(-1);
1272 : }
1273 : }
1274 :
1275 :
1276 : /* Search for field */
1277 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
1278 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1279 :
1280 : /* If field found ... */
1281 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1282 : {
1283 : /* Get DataType string */
1284 0 : statmeta = EHgetmetavalue(metaptrs, "DataType", utlstr);
1285 :
1286 : /* Convert to numbertype code */
1287 0 : if (statmeta == 0)
1288 0 : *numbertype = EHnumstr(utlstr);
1289 : else
1290 : {
1291 0 : status = -1;
1292 0 : HEpush(DFE_GENAPP, "SWfinfo", __FILE__, __LINE__);
1293 0 : HEreport("\"DataType\" string not found in metadata.\n");
1294 : }
1295 :
1296 :
1297 : /*
1298 : * Get DimList string and trim off leading and trailing parens "()"
1299 : */
1300 0 : statmeta = EHgetmetavalue(metaptrs, "DimList", utlstr);
1301 :
1302 0 : if (statmeta == 0)
1303 : {
1304 0 : memmove(utlstr, utlstr + 1, strlen(utlstr) - 2);
1305 0 : utlstr[strlen(utlstr) - 2] = 0;
1306 :
1307 : /* Parse trimmed DimList string and get rank */
1308 0 : ndims = EHparsestr(utlstr, ',', ptr, slen);
1309 0 : *rank = ndims;
1310 : }
1311 : else
1312 : {
1313 0 : status = -1;
1314 0 : HEpush(DFE_GENAPP, "SWfinfo", __FILE__, __LINE__);
1315 0 : HEreport("\"DimList\" string not found in metadata.\n");
1316 : }
1317 :
1318 : /* If dimension list is desired by user then initialize length to 0 */
1319 0 : if (dimlist != NULL)
1320 : {
1321 0 : dimlist[0] = 0;
1322 : }
1323 :
1324 : /*
1325 : * Copy each entry in DimList and remove leading and trailing quotes,
1326 : * Get dimension sizes and concatenate dimension names to dimension
1327 : * list
1328 : */
1329 0 : for (i = 0; i < ndims; i++)
1330 : {
1331 0 : memcpy(dimstr, ptr[i] + 1, slen[i] - 2);
1332 0 : dimstr[slen[i] - 2] = 0;
1333 0 : dims[i] = SWdiminfo(swathID, dimstr);
1334 0 : if (dimlist != NULL)
1335 : {
1336 0 : if (i > 0)
1337 : {
1338 0 : strcat(dimlist, ",");
1339 : }
1340 0 : strcat(dimlist, dimstr);
1341 : }
1342 :
1343 : }
1344 :
1345 :
1346 : /* Appendable Field Section */
1347 : /* ------------------------ */
1348 0 : if (dims[0] == 0)
1349 : {
1350 : /* One-Dimensional Field */
1351 0 : if (*rank == 1)
1352 : {
1353 : /* Get vdata ID */
1354 0 : status = SW1dfldsrch(fid, swathID, fieldname, "r",
1355 : &dum, &vdataID, &dum);
1356 :
1357 : /* Get actual size of field */
1358 0 : dims[0] = VSelts(vdataID);
1359 :
1360 : /*
1361 : * If size=1 then check where actual record of
1362 : * "initialization" record
1363 : */
1364 0 : if (dims[0] == 1)
1365 : {
1366 : /* Get record size and read 1st record */
1367 0 : fsize = VSsizeof(vdataID, (char *)fieldname);
1368 0 : buf = (uint8 *) calloc(fsize, 1);
1369 0 : if(buf == NULL)
1370 : {
1371 0 : HEpush(DFE_NOSPACE,"SWfinfo", __FILE__, __LINE__);
1372 0 : free(utlstr);
1373 0 : return(-1);
1374 : }
1375 0 : VSsetfields(vdataID, fieldname);
1376 0 : VSseek(vdataID, 0);
1377 0 : VSread(vdataID, (uint8 *) buf, 1, FULL_INTERLACE);
1378 :
1379 : /* Sum up "bytes" in record */
1380 0 : for (i = 0, j = 0; i < fsize; i++)
1381 : {
1382 0 : j += buf[i];
1383 : }
1384 :
1385 : /*
1386 : * If filled with 255 then "initialization" record,
1387 : * actual number of records = 0
1388 : */
1389 0 : if (j == 255 * fsize)
1390 : {
1391 0 : dims[0] = 0;
1392 : }
1393 :
1394 0 : free(buf);
1395 : }
1396 : /* Detach from 1d field */
1397 0 : VSdetach(vdataID);
1398 : }
1399 : else
1400 : {
1401 : /* Get actual size of Multi-Dimensional Field */
1402 0 : status = SWSDfldsrch(swathID, sdInterfaceID, fieldname,
1403 : &dum, &dum, &dum, &dum, dims,
1404 : &dum);
1405 : }
1406 : }
1407 : }
1408 0 : free(metabuf);
1409 :
1410 0 : if (*rank == -1)
1411 : {
1412 0 : status = -1;
1413 : }
1414 0 : free(utlstr);
1415 :
1416 0 : return (status);
1417 : }
1418 :
1419 :
1420 :
1421 :
1422 :
1423 : /*----------------------------------------------------------------------------|
1424 : | BEGIN_PROLOG |
1425 : | |
1426 : | FUNCTION: SWfieldinfo |
1427 : | |
1428 : | DESCRIPTION: Wrapper around SWfinfo |
1429 : | |
1430 : | |
1431 : | Return Value Type Units Description |
1432 : | ============ ====== ========= ===================================== |
1433 : | status intn return status (0) SUCCEED, (-1) FAIL |
1434 : | |
1435 : | INPUTS: |
1436 : | swathID int32 swath structure id |
1437 : | fieldname const char name of field |
1438 : | |
1439 : | |
1440 : | OUTPUTS: |
1441 : | rank int32 rank of field (# of dims) |
1442 : | dims int32 field dimensions |
1443 : | numbertype int32 field number type |
1444 : | dimlist char field dimension list |
1445 : | |
1446 : | NOTES: |
1447 : | |
1448 : | |
1449 : | Date Programmer Description |
1450 : | ====== ============ ================================================= |
1451 : | Jun 96 Joel Gales Original Programmer |
1452 : | |
1453 : | END_PROLOG |
1454 : -----------------------------------------------------------------------------*/
1455 : intn
1456 0 : SWfieldinfo(int32 swathID, const char *fieldname, int32 * rank, int32 dims[],
1457 : int32 * numbertype, char *dimlist)
1458 :
1459 : {
1460 : intn status; /* routine return status variable */
1461 :
1462 : int32 fid; /* HDF-EOS file ID */
1463 : int32 sdInterfaceID; /* HDF SDS interface ID */
1464 : int32 swVgrpID; /* Swath root Vgroup ID */
1465 :
1466 :
1467 : /* Check for valid swath id */
1468 0 : status = SWchkswid(swathID, "SWfieldinfo", &fid,
1469 : &sdInterfaceID, &swVgrpID);
1470 0 : if (status == 0)
1471 : {
1472 : /* Check for field within Geolocatation Fields */
1473 0 : status = SWfinfo(swathID, "Geolocation Fields", fieldname,
1474 : rank, dims, numbertype, dimlist);
1475 :
1476 : /* If not there then check within Data Fields */
1477 0 : if (status == -1)
1478 : {
1479 0 : status = SWfinfo(swathID, "Data Fields", fieldname,
1480 : rank, dims, numbertype, dimlist);
1481 : }
1482 :
1483 : /* If not there either then can't be found */
1484 0 : if (status == -1)
1485 : {
1486 0 : HEpush(DFE_GENAPP, "SWfieldinfo", __FILE__, __LINE__);
1487 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
1488 : }
1489 : }
1490 0 : return (status);
1491 : }
1492 :
1493 :
1494 :
1495 : /*----------------------------------------------------------------------------|
1496 : | BEGIN_PROLOG |
1497 : | |
1498 : | FUNCTION: SWwrrdattr |
1499 : | |
1500 : | DESCRIPTION: |
1501 : | |
1502 : | |
1503 : | Return Value Type Units Description |
1504 : | ============ ====== ========= ===================================== |
1505 : | status intn return status (0) SUCCEED, (-1) FAIL |
1506 : | |
1507 : | INPUTS: |
1508 : | swathID int32 swath structure ID |
1509 : | attrname char attribute name |
1510 : | numbertype int32 attribute HDF numbertype |
1511 : | count int32 Number of attribute elements |
1512 : | wrcode char Read/Write Code "w/r" |
1513 : | datbuf void I/O buffer |
1514 : | |
1515 : | OUTPUTS: |
1516 : | datbuf |
1517 : | |
1518 : | NOTES: |
1519 : | |
1520 : | |
1521 : | Date Programmer Description |
1522 : | ====== ============ ================================================= |
1523 : | Jun 96 Joel Gales Original Programmer |
1524 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
1525 : | |
1526 : | END_PROLOG |
1527 : -----------------------------------------------------------------------------*/
1528 : static intn
1529 0 : SWwrrdattr(int32 swathID, const char *attrname, int32 numbertype, int32 count,
1530 : const char *wrcode, VOIDP datbuf)
1531 :
1532 : {
1533 : intn status; /* routine return status variable */
1534 :
1535 : int32 fid; /* HDF-EOS file ID */
1536 : int32 attrVgrpID; /* Swath attribute ID */
1537 : int32 dum; /* dummy variable */
1538 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1539 :
1540 : /* Check Swath id */
1541 0 : status = SWchkswid(swathID, "SWwrrdattr", &fid, &dum, &dum);
1542 :
1543 0 : if (status == 0)
1544 : {
1545 : /* Get attribute Vgroup ID and call EHattr to perform I/O */
1546 : /* ------------------------------------------------------ */
1547 0 : int sID = swathID % idOffset;
1548 0 : if (sID >= NSWATH)
1549 : {
1550 0 : return -1;
1551 : }
1552 0 : attrVgrpID = SWXSwath[sID].VIDTable[2];
1553 0 : status = EHattr(fid, attrVgrpID, attrname, numbertype, count,
1554 : wrcode, datbuf);
1555 : }
1556 0 : return (status);
1557 : }
1558 :
1559 :
1560 : /*----------------------------------------------------------------------------|
1561 : | BEGIN_PROLOG |
1562 : | |
1563 : | FUNCTION: SWreadattr |
1564 : | |
1565 : | DESCRIPTION: Reads attribute from a swath. |
1566 : | |
1567 : | |
1568 : | Return Value Type Units Description |
1569 : | ============ ====== ========= ===================================== |
1570 : | status intn return status (0) SUCCEED, (-1) FAIL |
1571 : | |
1572 : | INPUTS: |
1573 : | swathID int32 swath structure ID |
1574 : | attrname char attribute name |
1575 : | |
1576 : | OUTPUTS: |
1577 : | datbuf void I/O buffer |
1578 : | |
1579 : | NOTES: |
1580 : | |
1581 : | |
1582 : | Date Programmer Description |
1583 : | ====== ============ ================================================= |
1584 : | Jun 96 Joel Gales Original Programmer |
1585 : | |
1586 : | END_PROLOG |
1587 : -----------------------------------------------------------------------------*/
1588 : intn
1589 0 : SWreadattr(int32 swathID, const char *attrname, VOIDP datbuf)
1590 : {
1591 0 : intn status = 0; /* routine return status variable */
1592 0 : int32 dum = 0; /* dummy variable */
1593 :
1594 : /* Call SWwrrdattr routine to read attribute */
1595 : /* ----------------------------------------- */
1596 0 : status = SWwrrdattr(swathID, attrname, dum, dum, "r", datbuf);
1597 :
1598 0 : return (status);
1599 : }
1600 :
1601 :
1602 :
1603 :
1604 :
1605 : /*----------------------------------------------------------------------------|
1606 : | BEGIN_PROLOG |
1607 : | |
1608 : | FUNCTION: SWattrinfo |
1609 : | |
1610 : | DESCRIPTION: |
1611 : | |
1612 : | |
1613 : | Return Value Type Units Description |
1614 : | ============ ====== ========= ===================================== |
1615 : | status intn return status (0) SUCCEED, (-1) FAIL |
1616 : | |
1617 : | INPUTS: |
1618 : | swathID int32 swath structure ID |
1619 : | attrname char attribute name |
1620 : | |
1621 : | OUTPUTS: |
1622 : | numbertype int32 attribute HDF numbertype |
1623 : | count int32 Number of attribute elements |
1624 : | |
1625 : | |
1626 : | OUTPUTS: |
1627 : | None |
1628 : | |
1629 : | NOTES: |
1630 : | |
1631 : | |
1632 : | Date Programmer Description |
1633 : | ====== ============ ================================================= |
1634 : | Jun 96 Joel Gales Original Programmer |
1635 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
1636 : | |
1637 : | END_PROLOG |
1638 : -----------------------------------------------------------------------------*/
1639 : intn
1640 0 : SWattrinfo(int32 swathID, const char *attrname, int32 * numbertype, int32 * count)
1641 : {
1642 0 : intn status = 0; /* routine return status variable */
1643 :
1644 : int32 fid; /* HDF-EOS file ID */
1645 : int32 attrVgrpID; /* Swath attribute ID */
1646 : int32 dum; /* dummy variable */
1647 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1648 :
1649 : /* Check for valid swath ID */
1650 : /* ------------------------ */
1651 0 : status = SWchkswid(swathID, "SWattrinfo", &fid, &dum, &dum);
1652 :
1653 0 : if (status == 0)
1654 : {
1655 : /* Get attribute Vgroup ID and call EHattrinfo */
1656 : /* ------------------------------------------- */
1657 0 : int sID = swathID % idOffset;
1658 0 : if (sID >= NSWATH)
1659 : {
1660 0 : return -1;
1661 : }
1662 0 : attrVgrpID = SWXSwath[sID].VIDTable[2];
1663 :
1664 0 : status = EHattrinfo(fid, attrVgrpID, attrname, numbertype,
1665 : count);
1666 : }
1667 0 : return (status);
1668 : }
1669 :
1670 :
1671 :
1672 :
1673 :
1674 :
1675 : /*----------------------------------------------------------------------------|
1676 : | BEGIN_PROLOG |
1677 : | |
1678 : | FUNCTION: SWinqattrs |
1679 : | |
1680 : | DESCRIPTION: |
1681 : | |
1682 : | |
1683 : | Return Value Type Units Description |
1684 : | ============ ====== ========= ===================================== |
1685 : | nattr int32 Number of attributes in swath struct |
1686 : | |
1687 : | INPUTS: |
1688 : | swath ID int32 swath structure ID |
1689 : | |
1690 : | OUTPUTS: |
1691 : | attrnames char Attribute names in swath struct |
1692 : | (Comma-separated list) |
1693 : | strbufsize int32 Attributes name list string length |
1694 : | |
1695 : | OUTPUTS: |
1696 : | None |
1697 : | |
1698 : | NOTES: |
1699 : | |
1700 : | |
1701 : | Date Programmer Description |
1702 : | ====== ============ ================================================= |
1703 : | Jun 96 Joel Gales Original Programmer |
1704 : | Oct 96 Joel Gales Initialize nattr |
1705 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
1706 : | |
1707 : | END_PROLOG |
1708 : -----------------------------------------------------------------------------*/
1709 : int32
1710 0 : SWinqattrs(int32 swathID, char *attrnames, int32 * strbufsize)
1711 : {
1712 : intn status; /* routine return status variable */
1713 :
1714 : int32 fid; /* HDF-EOS file ID */
1715 : int32 attrVgrpID; /* Swath attribute ID */
1716 : int32 dum; /* dummy variable */
1717 0 : int32 nattr = 0; /* Number of attributes */
1718 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1719 :
1720 : /* Check Swath id */
1721 0 : status = SWchkswid(swathID, "SWinqattrs", &fid, &dum, &dum);
1722 :
1723 0 : if (status == 0)
1724 : {
1725 : /* Get attribute Vgroup ID and call EHattrcat */
1726 : /* ------------------------------------------ */
1727 0 : int sID = swathID % idOffset;
1728 0 : if (sID >= NSWATH)
1729 : {
1730 0 : return -1;
1731 : }
1732 0 : attrVgrpID = SWXSwath[sID].VIDTable[2];
1733 :
1734 0 : nattr = EHattrcat(fid, attrVgrpID, attrnames, strbufsize);
1735 : }
1736 :
1737 0 : return (nattr);
1738 : }
1739 :
1740 : #define REMQUOTE(x) do { \
1741 : char* l_x = x; \
1742 : const size_t l_x_len = strlen(l_x); \
1743 : if (l_x_len >= 2 && l_x[0] == '"' && l_x[l_x_len - 1] == '"') {\
1744 : memmove(l_x, l_x + 1, l_x_len - 2); \
1745 : l_x[l_x_len - 2] = 0; \
1746 : } \
1747 : } while(0)
1748 :
1749 :
1750 : /*----------------------------------------------------------------------------|
1751 : | BEGIN_PROLOG |
1752 : | |
1753 : | FUNCTION: SWinqdims |
1754 : | |
1755 : | DESCRIPTION: Returns dimension names and values defined in swath structure |
1756 : | |
1757 : | |
1758 : | Return Value Type Units Description |
1759 : | ============ ====== ========= ===================================== |
1760 : | nDim int32 Number of defined dimensions |
1761 : | |
1762 : | INPUTS: |
1763 : | swathID int32 swath structure ID |
1764 : | |
1765 : | OUTPUTS: |
1766 : | dimnames char Dimension names (comma-separated) |
1767 : | dims int32 Dimension values |
1768 : | |
1769 : | NOTES: |
1770 : | |
1771 : | |
1772 : | Date Programmer Description |
1773 : | ====== ============ ================================================= |
1774 : | Jun 96 Joel Gales Original Programmer |
1775 : | Aug 96 Joel Gales Make metadata ODL compliant |
1776 : | Feb 97 Joel Gales Set nDim to -1 if status = -1 |
1777 : | |
1778 : | END_PROLOG |
1779 : -----------------------------------------------------------------------------*/
1780 : int32
1781 0 : SWinqdims(int32 swathID, char *dimnames, int32 dims[])
1782 :
1783 : {
1784 : intn status; /* routine return status variable */
1785 :
1786 : int32 fid; /* HDF-EOS file ID */
1787 : int32 sdInterfaceID; /* HDF SDS interface ID */
1788 : int32 swVgrpID; /* Swath root Vgroup ID */
1789 : int32 size; /* Dimension size */
1790 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1791 0 : int32 nDim = 0; /* Number of dimensions */
1792 :
1793 : char *metabuf; /* Pointer to structural metadata (SM) */
1794 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1795 : char swathname[80]; /* Swath Name */
1796 : char *utlstr; /* Utility string */
1797 :
1798 :
1799 : /* Allocate space for utility string */
1800 : /* --------------------------------- */
1801 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1802 0 : if(utlstr == NULL)
1803 : {
1804 0 : HEpush(DFE_NOSPACE,"SWinqdims", __FILE__, __LINE__);
1805 0 : return(-1);
1806 : }
1807 :
1808 : /* Check for valid swath id */
1809 0 : status = SWchkswid(swathID, "SWinqdims", &fid, &sdInterfaceID, &swVgrpID);
1810 :
1811 0 : if (status == 0)
1812 : {
1813 : /* If dimension names or sizes are desired ... */
1814 : /* ------------------------------------------- */
1815 0 : if (dimnames != NULL || dims != NULL)
1816 : {
1817 : /* Get swath name */
1818 0 : int sID = swathID % idOffset;
1819 0 : if (sID >= NSWATH)
1820 : {
1821 0 : free(utlstr);
1822 0 : return -1;
1823 : }
1824 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
1825 :
1826 : /* Get pointers to "Dimension" section within SM */
1827 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
1828 : "Dimension", metaptrs);
1829 0 : if(metabuf == NULL)
1830 : {
1831 0 : free(utlstr);
1832 0 : return(-1);
1833 : }
1834 : /* If dimension names are desired then "clear" name buffer */
1835 0 : if (dimnames != NULL)
1836 : {
1837 0 : dimnames[0] = 0;
1838 : }
1839 :
1840 :
1841 : /* Begin loop through dimension entries in metadata */
1842 : /* ------------------------------------------------ */
1843 : while (1)
1844 : {
1845 : /* Search for OBJECT string */
1846 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
1847 :
1848 : /* If found within "Dimension" metadata section ... */
1849 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1850 : {
1851 : /* Get Dimension Name (if desired) */
1852 0 : if (dimnames != NULL)
1853 : {
1854 : /* Check 1st for old meta data then new */
1855 : /* ------------------------------------ */
1856 0 : EHgetmetavalue(metaptrs, "OBJECT", utlstr);
1857 :
1858 : /*
1859 : * If OBJECT value begins with double quote then old
1860 : * metadata, dimension name is OBJECT value.
1861 : * Otherwise search for "DimensionName" string
1862 : */
1863 0 : if (utlstr[0] != '"')
1864 : {
1865 0 : metaptrs[0] =
1866 0 : strstr(metaptrs[0], "\t\t\t\tDimensionName=");
1867 0 : EHgetmetavalue(metaptrs, "DimensionName", utlstr);
1868 : }
1869 :
1870 : /* Strip off double quotes */
1871 : /* ----------------------- */
1872 0 : REMQUOTE(utlstr);
1873 :
1874 : /* If not first name then add comma delimiter */
1875 0 : if (nDim > 0)
1876 : {
1877 0 : strcat(dimnames, ",");
1878 : }
1879 : /* Add dimension name to dimension list */
1880 0 : strcat(dimnames, utlstr);
1881 : }
1882 :
1883 : /* Get Dimension Size (if desired) */
1884 0 : if (dims != NULL)
1885 : {
1886 0 : EHgetmetavalue(metaptrs, "Size", utlstr);
1887 0 : size = atoi(utlstr);
1888 0 : dims[nDim] = size;
1889 : }
1890 : /* Increment number of dimensions */
1891 0 : nDim++;
1892 : }
1893 : else
1894 : /* No more dimensions found */
1895 : {
1896 : break;
1897 : }
1898 : }
1899 0 : free(metabuf);
1900 : }
1901 : }
1902 :
1903 :
1904 : /* Set nDim to -1 if error status exists */
1905 : /* ------------------------------------- */
1906 0 : if (status == -1)
1907 : {
1908 0 : nDim = -1;
1909 : }
1910 0 : free(utlstr);
1911 :
1912 0 : return (nDim);
1913 : }
1914 :
1915 :
1916 :
1917 :
1918 :
1919 : /*----------------------------------------------------------------------------|
1920 : | BEGIN_PROLOG |
1921 : | |
1922 : | FUNCTION: SWinqmaps |
1923 : | |
1924 : | DESCRIPTION: Returns dimension mappings and offsets and increments |
1925 : | |
1926 : | |
1927 : | Return Value Type Units Description |
1928 : | ============ ====== ========= ===================================== |
1929 : | nMap int32 Number of dimension mappings |
1930 : | |
1931 : | INPUTS: |
1932 : | swathID int32 swath structure ID |
1933 : | |
1934 : | OUTPUTS: |
1935 : | dimmaps char dimension mappings (comma-separated) |
1936 : | offset int32 array of offsets |
1937 : | increment int32 array of increments |
1938 : | |
1939 : | NOTES: |
1940 : | |
1941 : | |
1942 : | Date Programmer Description |
1943 : | ====== ============ ================================================= |
1944 : | Jun 96 Joel Gales Original Programmer |
1945 : | Aug 96 Joel Gales Make metadata ODL compliant |
1946 : | Feb 97 Joel Gales Set nMap to -1 if status = -1 |
1947 : | |
1948 : | END_PROLOG |
1949 : -----------------------------------------------------------------------------*/
1950 : int32
1951 0 : SWinqmaps(int32 swathID, char *dimmaps, int32 offset[], int32 increment[])
1952 :
1953 : {
1954 : intn status; /* routine return status variable */
1955 :
1956 : int32 fid; /* HDF-EOS file ID */
1957 : int32 sdInterfaceID; /* HDF SDS interface ID */
1958 : int32 swVgrpID; /* Swath root Vgroup ID */
1959 : int32 off; /* Mapping Offset */
1960 : int32 incr; /* Mapping Increment */
1961 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1962 0 : int32 nMap = 0; /* Number of mappings */
1963 :
1964 : char *metabuf; /* Pointer to structural metadata (SM) */
1965 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1966 : char swathname[80]; /* Swath Name */
1967 : char *utlstr; /* Utility string */
1968 :
1969 :
1970 : /* Allocate space for utility string */
1971 : /* --------------------------------- */
1972 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1973 0 : if(utlstr == NULL)
1974 : {
1975 0 : HEpush(DFE_NOSPACE,"SWinqmaps", __FILE__, __LINE__);
1976 0 : return(-1);
1977 : }
1978 :
1979 : /* Check for valid swath id */
1980 0 : status = SWchkswid(swathID, "SWinqmaps", &fid, &sdInterfaceID, &swVgrpID);
1981 0 : if (status == 0)
1982 : {
1983 : /* If mapping names or offsets or increments desired ... */
1984 : /* ----------------------------------------------------- */
1985 0 : if (dimmaps != NULL || offset != NULL || increment != NULL)
1986 : {
1987 :
1988 : /* Get swath name */
1989 0 : int sID = swathID % idOffset;
1990 0 : if (sID >= NSWATH)
1991 : {
1992 0 : free(utlstr);
1993 0 : return -1;
1994 : }
1995 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
1996 :
1997 : /* Get pointers to "DimensionMap" section within SM */
1998 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
1999 : "DimensionMap", metaptrs);
2000 0 : if(metabuf == NULL)
2001 : {
2002 0 : free(utlstr);
2003 0 : return(-1);
2004 : }
2005 : /* If mapping names are desired then "clear" name buffer */
2006 0 : if (dimmaps != NULL)
2007 : {
2008 0 : dimmaps[0] = 0;
2009 : }
2010 :
2011 : /* Begin loop through mapping entries in metadata */
2012 : /* ---------------------------------------------- */
2013 : while (1)
2014 : {
2015 : /* Search for OBJECT string */
2016 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
2017 :
2018 : /* If found within "DimensionMap" metadata section ... */
2019 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2020 : {
2021 : /* Get Geo & Data Dimensions (if desired) */
2022 0 : if (dimmaps != NULL)
2023 : {
2024 : /* Get Geo Dim, remove quotes, add "/" */
2025 0 : EHgetmetavalue(metaptrs, "GeoDimension", utlstr);
2026 0 : REMQUOTE(utlstr);
2027 0 : strcat(utlstr, "/");
2028 :
2029 : /* If not first map then add comma delimiter. */
2030 0 : if (nMap > 0)
2031 : {
2032 0 : strcat(dimmaps, ",");
2033 : }
2034 :
2035 : /* Add to map list */
2036 0 : strcat(dimmaps, utlstr);
2037 :
2038 : /* Get Data Dim, remove quotes */
2039 0 : EHgetmetavalue(metaptrs, "DataDimension", utlstr);
2040 0 : REMQUOTE(utlstr);
2041 :
2042 : /* Add to map list */
2043 0 : strcat(dimmaps, utlstr);
2044 : }
2045 :
2046 : /* Get Offset (if desired) */
2047 0 : if (offset != NULL)
2048 : {
2049 0 : EHgetmetavalue(metaptrs, "Offset", utlstr);
2050 0 : off = atoi(utlstr);
2051 0 : offset[nMap] = off;
2052 : }
2053 :
2054 : /* Get Increment (if desired) */
2055 0 : if (increment != NULL)
2056 : {
2057 0 : EHgetmetavalue(metaptrs, "Increment", utlstr);
2058 0 : incr = atoi(utlstr);
2059 0 : increment[nMap] = incr;
2060 : }
2061 :
2062 : /* Increment number of maps */
2063 0 : nMap++;
2064 : }
2065 : else
2066 : /* No more mappings found */
2067 : {
2068 : break;
2069 : }
2070 : }
2071 0 : free(metabuf);
2072 : }
2073 : }
2074 :
2075 :
2076 : /* Set nMap to -1 if error status exists */
2077 : /* ------------------------------------- */
2078 0 : if (status == -1)
2079 : {
2080 0 : nMap = -1;
2081 : }
2082 0 : free(utlstr);
2083 :
2084 0 : return (nMap);
2085 : }
2086 :
2087 :
2088 :
2089 :
2090 :
2091 : /*----------------------------------------------------------------------------|
2092 : | BEGIN_PROLOG |
2093 : | |
2094 : | FUNCTION: SWinqidxmaps |
2095 : | |
2096 : | DESCRIPTION: Returns l_indexed mappings and l_index sizes |
2097 : | |
2098 : | |
2099 : | Return Value Type Units Description |
2100 : | ============ ====== ========= ===================================== |
2101 : | nMap int32 Number of l_indexed dimension mappings |
2102 : | |
2103 : | INPUTS: |
2104 : | swathID int32 swath structure ID |
2105 : | |
2106 : | OUTPUTS: |
2107 : | idxmaps char l_indexed dimension mappings |
2108 : | (comma-separated) |
2109 : | idxsizes int32 Number of elements in each mapping |
2110 : | |
2111 : | |
2112 : | NOTES: |
2113 : | |
2114 : | |
2115 : | Date Programmer Description |
2116 : | ====== ============ ================================================= |
2117 : | Jun 96 Joel Gales Original Programmer |
2118 : | Aug 96 Joel Gales Make metadata ODL compliant |
2119 : | Feb 97 Joel Gales Set nMap to -1 if status = -1 |
2120 : | |
2121 : | END_PROLOG |
2122 : -----------------------------------------------------------------------------*/
2123 : int32
2124 0 : SWinqidxmaps(int32 swathID, char *idxmaps, int32 idxsizes[])
2125 :
2126 : {
2127 : intn status; /* routine return status variable */
2128 :
2129 : int32 fid; /* HDF-EOS file ID */
2130 : int32 sdInterfaceID; /* HDF SDS interface ID */
2131 : int32 swVgrpID; /* Swath root Vgroup ID */
2132 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2133 0 : int32 nMap = 0; /* Number of mappings */
2134 :
2135 : char *metabuf; /* Pointer to structural metadata (SM) */
2136 : char *metaptrs[2];/* Pointers to begin and end of SM section */
2137 : char swathname[80]; /* Swath Name */
2138 : char *utlstr; /* Utility string */
2139 : char *slash; /* Pointer to slash */
2140 :
2141 :
2142 : /* Allocate space for utility string */
2143 : /* --------------------------------- */
2144 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2145 0 : if(utlstr == NULL)
2146 : {
2147 0 : HEpush(DFE_NOSPACE,"SWinqidxmaps", __FILE__, __LINE__);
2148 0 : return(-1);
2149 : }
2150 : /* Check for valid swath id */
2151 0 : status = SWchkswid(swathID, "SWinqidxmaps", &fid,
2152 : &sdInterfaceID, &swVgrpID);
2153 :
2154 0 : if (status == 0)
2155 : {
2156 : /* If mapping names or l_index sizes desired ... */
2157 : /* ------------------------------------------- */
2158 0 : if (idxmaps != NULL || idxsizes != NULL)
2159 : {
2160 : /* Get swath name */
2161 0 : int sID = swathID % idOffset;
2162 0 : if (sID >= NSWATH)
2163 : {
2164 0 : free(utlstr);
2165 0 : return -1;
2166 : }
2167 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
2168 :
2169 : /* Get pointers to "IndexDimensionMap" section within SM */
2170 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
2171 : "IndexDimensionMap", metaptrs);
2172 0 : if(metabuf == NULL)
2173 : {
2174 0 : free(utlstr);
2175 0 : return(-1);
2176 : }
2177 : /* If mapping names are desired then "clear" name buffer */
2178 0 : if (idxmaps != NULL)
2179 : {
2180 0 : idxmaps[0] = 0;
2181 : }
2182 :
2183 : /* Begin loop through mapping entries in metadata */
2184 : /* ---------------------------------------------- */
2185 : while (1)
2186 : {
2187 : /* Search for OBJECT string */
2188 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
2189 :
2190 : /* If found within "IndexDimensionMap" metadata section ... */
2191 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2192 : {
2193 : /* Get Geo & Data Dimensions and # of indices */
2194 0 : if (idxmaps != NULL)
2195 : {
2196 : /* Get Geo Dim, remove quotes, add "/" */
2197 0 : EHgetmetavalue(metaptrs, "GeoDimension", utlstr);
2198 0 : REMQUOTE(utlstr);
2199 0 : strcat(utlstr, "/");
2200 :
2201 : /* If not first map then add comma delimiter. */
2202 0 : if (nMap > 0)
2203 : {
2204 0 : strcat(idxmaps, ",");
2205 : }
2206 :
2207 : /* Add to map list */
2208 0 : strcat(idxmaps, utlstr);
2209 :
2210 :
2211 : /* Get Index size (if desired) */
2212 0 : if (idxsizes != NULL)
2213 : {
2214 : /* Parse off geo dimension and find its size */
2215 0 : slash = strchr(utlstr, '/');
2216 0 : if (slash) *slash = 0;
2217 0 : idxsizes[nMap] = SWdiminfo(swathID, utlstr);
2218 : }
2219 :
2220 :
2221 : /* Get Data Dim, remove quotes */
2222 0 : EHgetmetavalue(metaptrs, "DataDimension", utlstr);
2223 0 : REMQUOTE(utlstr);
2224 :
2225 : /* Add to map list */
2226 0 : strcat(idxmaps, utlstr);
2227 : }
2228 :
2229 : /* Increment number of maps */
2230 0 : nMap++;
2231 : }
2232 : else
2233 : /* No more mappings found */
2234 : {
2235 : break;
2236 : }
2237 : }
2238 0 : free(metabuf);
2239 : }
2240 : }
2241 :
2242 :
2243 : /* Set nMap to -1 if error status exists */
2244 : /* ------------------------------------- */
2245 0 : if (status == -1)
2246 : {
2247 0 : nMap = -1;
2248 : }
2249 0 : free(utlstr);
2250 :
2251 0 : return (nMap);
2252 : }
2253 :
2254 :
2255 :
2256 :
2257 : /*----------------------------------------------------------------------------|
2258 : | BEGIN_PROLOG |
2259 : | |
2260 : | FUNCTION: SWinqfields |
2261 : | |
2262 : | DESCRIPTION: Returns fieldnames, ranks and numbertypes defined in swath. |
2263 : | |
2264 : | |
2265 : | Return Value Type Units Description |
2266 : | ============ ====== ========= ===================================== |
2267 : | nFld int32 Number of (geo/data) fields in swath |
2268 : | |
2269 : | INPUTS: |
2270 : | swathID int32 swath structure ID |
2271 : | fieldtype char field type (geo or data) |
2272 : | |
2273 : | |
2274 : | OUTPUTS: |
2275 : | fieldlist char Field names (comma-separated) |
2276 : | rank int32 Array of ranks |
2277 : | numbertype int32 Array of HDF number types |
2278 : | |
2279 : | NOTES: |
2280 : | |
2281 : | |
2282 : | Date Programmer Description |
2283 : | ====== ============ ================================================= |
2284 : | Jun 96 Joel Gales Original Programmer |
2285 : | Aug 96 Joel Gales Make metadata ODL compliant |
2286 : | Feb 97 Joel Gales Set nFld to -1 if status = -1 |
2287 : | |
2288 : | END_PROLOG |
2289 : -----------------------------------------------------------------------------*/
2290 : static int32
2291 0 : SWinqfields(int32 swathID, const char *fieldtype, char *fieldlist, int32 rank[],
2292 : int32 numbertype[])
2293 :
2294 : {
2295 : intn status; /* routine return status variable */
2296 :
2297 : int32 fid; /* HDF-EOS file ID */
2298 : int32 sdInterfaceID; /* HDF SDS interface ID */
2299 : int32 swVgrpID; /* Swath root Vgroup ID */
2300 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2301 0 : int32 nFld = 0; /* Number of mappings */
2302 : int32 slen[8]; /* String length array */
2303 :
2304 : char *metabuf; /* Pointer to structural metadata (SM) */
2305 : char *metaptrs[2];/* Pointers to begin and end of SM section */
2306 : char swathname[80]; /* Swath Name */
2307 : char *utlstr; /* Utility string */
2308 : char *utlstr2; /* Utility string 2 */
2309 : char *ptr[8]; /* String pointer array */
2310 :
2311 :
2312 : /* Allocate space for utility string */
2313 : /* --------------------------------- */
2314 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2315 0 : if(utlstr == NULL)
2316 : {
2317 0 : HEpush(DFE_NOSPACE,"SWinqfields", __FILE__, __LINE__);
2318 0 : return(-1);
2319 : }
2320 :
2321 0 : utlstr2 = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2322 0 : if(utlstr2 == NULL)
2323 : {
2324 0 : HEpush(DFE_NOSPACE,"SWinqfields", __FILE__, __LINE__);
2325 0 : free(utlstr);
2326 0 : return(-1);
2327 : }
2328 :
2329 : /* Check for valid swath id */
2330 0 : status = SWchkswid(swathID, "SWinqfields",
2331 : &fid, &sdInterfaceID, &swVgrpID);
2332 :
2333 0 : if (status == 0)
2334 : {
2335 : /* If field names, ranks, or number types desired ... */
2336 : /* --------------------------------------------------- */
2337 0 : if (fieldlist != NULL || rank != NULL || numbertype != NULL)
2338 : {
2339 : /* Get swath name */
2340 0 : int sID = swathID % idOffset;
2341 0 : if (sID >= NSWATH)
2342 : {
2343 0 : free(utlstr);
2344 0 : free(utlstr2);
2345 0 : return -1;
2346 : }
2347 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
2348 :
2349 : /* Get pointers to "GeoField" or "DataField" section within SM */
2350 0 : if (strcmp(fieldtype, "Geolocation Fields") == 0)
2351 : {
2352 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
2353 : "GeoField", metaptrs);
2354 0 : if(metabuf == NULL)
2355 : {
2356 0 : free(utlstr);
2357 0 : free(utlstr2);
2358 0 : return(-1);
2359 : }
2360 0 : strcpy(utlstr2, "GeoFieldName");
2361 : }
2362 : else
2363 : {
2364 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
2365 : "DataField", metaptrs);
2366 0 : if(metabuf == NULL)
2367 : {
2368 0 : free(utlstr);
2369 0 : free(utlstr2);
2370 0 : return(-1);
2371 : }
2372 0 : strcpy(utlstr2, "DataFieldName");
2373 : }
2374 :
2375 :
2376 : /* If field names are desired then "clear" name buffer */
2377 0 : if (fieldlist != NULL)
2378 : {
2379 0 : fieldlist[0] = 0;
2380 : }
2381 :
2382 :
2383 : /* Begin loop through mapping entries in metadata */
2384 : /* ---------------------------------------------- */
2385 : while (1)
2386 : {
2387 : /* Search for OBJECT string */
2388 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
2389 :
2390 : /* If found within "Geo" or "Data" Field metadata section .. */
2391 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2392 : {
2393 : /* Get Fieldnames (if desired) */
2394 0 : if (fieldlist != NULL)
2395 : {
2396 : /* Check 1st for old meta data then new */
2397 : /* ------------------------------------ */
2398 0 : EHgetmetavalue(metaptrs, "OBJECT", utlstr);
2399 :
2400 : /*
2401 : * If OBJECT value begins with double quote then old
2402 : * metadata, field name is OBJECT value. Otherwise
2403 : * search for "GeoFieldName" or "DataFieldName"
2404 : * string
2405 : */
2406 :
2407 0 : if (utlstr[0] != '"')
2408 : {
2409 0 : strcpy(utlstr, "\t\t\t\t");
2410 0 : strcat(utlstr, utlstr2);
2411 0 : strcat(utlstr, "=");
2412 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
2413 0 : EHgetmetavalue(metaptrs, utlstr2, utlstr);
2414 : }
2415 :
2416 : /* Strip off double quotes */
2417 : /* ----------------------- */
2418 0 : REMQUOTE(utlstr);
2419 :
2420 :
2421 : /* Add to fieldlist */
2422 : /* ---------------- */
2423 0 : if (nFld > 0)
2424 : {
2425 0 : strcat(fieldlist, ",");
2426 : }
2427 0 : strcat(fieldlist, utlstr);
2428 :
2429 : }
2430 : /* Get Numbertype */
2431 0 : if (numbertype != NULL)
2432 : {
2433 0 : EHgetmetavalue(metaptrs, "DataType", utlstr);
2434 0 : numbertype[nFld] = EHnumstr(utlstr);
2435 : }
2436 : /*
2437 : * Get Rank (if desired) by counting # of dimensions in
2438 : * "DimList" string
2439 : */
2440 0 : if (rank != NULL)
2441 : {
2442 0 : EHgetmetavalue(metaptrs, "DimList", utlstr);
2443 0 : rank[nFld] = EHparsestr(utlstr, ',', ptr, slen);
2444 : }
2445 : /* Increment number of fields */
2446 0 : nFld++;
2447 : }
2448 : else
2449 : /* No more fields found */
2450 : {
2451 : break;
2452 : }
2453 : }
2454 0 : free(metabuf);
2455 : }
2456 : }
2457 :
2458 : /* Set nFld to -1 if error status exists */
2459 : /* ------------------------------------- */
2460 0 : if (status == -1)
2461 : {
2462 0 : nFld = -1;
2463 : }
2464 :
2465 0 : free(utlstr);
2466 0 : free(utlstr2);
2467 :
2468 0 : return (nFld);
2469 : }
2470 :
2471 :
2472 :
2473 :
2474 : /*----------------------------------------------------------------------------|
2475 : | BEGIN_PROLOG |
2476 : | |
2477 : | FUNCTION: SWinqgeofields |
2478 : | |
2479 : | DESCRIPTION: Inquires about geo fields in swath |
2480 : | |
2481 : | |
2482 : | Return Value Type Units Description |
2483 : | ============ ====== ========= ===================================== |
2484 : | nflds int32 Number of geo fields in swath |
2485 : | |
2486 : | INPUTS: |
2487 : | swathID int32 swath structure ID |
2488 : | |
2489 : | OUTPUTS: |
2490 : | fieldlist char Field names (comma-separated) |
2491 : | rank int32 Array of ranks |
2492 : | numbertype int32 Array of HDF number types |
2493 : | |
2494 : | NOTES: |
2495 : | |
2496 : | |
2497 : | Date Programmer Description |
2498 : | ====== ============ ================================================= |
2499 : | Jun 96 Joel Gales Original Programmer |
2500 : | |
2501 : | END_PROLOG |
2502 : -----------------------------------------------------------------------------*/
2503 : int32
2504 0 : SWinqgeofields(int32 swathID, char *fieldlist, int32 rank[],
2505 : int32 numbertype[])
2506 : {
2507 :
2508 : int32 nflds; /* Number of Geolocation fields */
2509 :
2510 : /* Call "SWinqfields" routine */
2511 : /* -------------------------- */
2512 0 : nflds = SWinqfields(swathID, "Geolocation Fields", fieldlist, rank,
2513 : numbertype);
2514 :
2515 0 : return (nflds);
2516 :
2517 : }
2518 :
2519 :
2520 :
2521 :
2522 : /*----------------------------------------------------------------------------|
2523 : | BEGIN_PROLOG |
2524 : | |
2525 : | FUNCTION: SWinqdatafields |
2526 : | |
2527 : | DESCRIPTION: Inquires about data fields in swath |
2528 : | |
2529 : | |
2530 : | Return Value Type Units Description |
2531 : | ============ ====== ========= ===================================== |
2532 : | nflds int32 Number of data fields in swath |
2533 : | |
2534 : | INPUTS: |
2535 : | swathID int32 swath structure ID |
2536 : | |
2537 : | OUTPUTS: |
2538 : | fieldlist char Field names (comma-separated) |
2539 : | rank int32 Array of ranks |
2540 : | numbertype int32 Array of HDF number types |
2541 : | |
2542 : | NOTES: |
2543 : | |
2544 : | |
2545 : | Date Programmer Description |
2546 : | ====== ============ ================================================= |
2547 : | Jun 96 Joel Gales Original Programmer |
2548 : | |
2549 : | END_PROLOG |
2550 : -----------------------------------------------------------------------------*/
2551 : int32
2552 0 : SWinqdatafields(int32 swathID, char *fieldlist, int32 rank[],
2553 : int32 numbertype[])
2554 : {
2555 :
2556 : int32 nflds; /* Number of Data fields */
2557 :
2558 : /* Call "SWinqfields" routine */
2559 : /* -------------------------- */
2560 0 : nflds = SWinqfields(swathID, "Data Fields", fieldlist, rank,
2561 : numbertype);
2562 :
2563 0 : return (nflds);
2564 :
2565 : }
2566 :
2567 :
2568 :
2569 :
2570 : /*----------------------------------------------------------------------------|
2571 : | BEGIN_PROLOG |
2572 : | |
2573 : | FUNCTION: SWnentries |
2574 : | |
2575 : | DESCRIPTION: Returns number of entries and string buffer size |
2576 : | |
2577 : | |
2578 : | Return Value Type Units Description |
2579 : | ============ ====== ========= ===================================== |
2580 : | nEntries int32 Number of entries |
2581 : | |
2582 : | INPUTS: |
2583 : | swathID int32 swath structure ID |
2584 : | entrycode int32 Entry code |
2585 : | HDFE_NENTDIM (0) |
2586 : | HDFE_NENTMAP (1) |
2587 : | HDFE_NENTIMAP (2) |
2588 : | HDFE_NENTGFLD (3) |
2589 : | HDFE_NENTDFLD (4) |
2590 : | |
2591 : | |
2592 : | OUTPUTS: |
2593 : | strbufsize int32 Length of comma-separated list |
2594 : | (Does not include null-terminator |
2595 : | |
2596 : | NOTES: |
2597 : | |
2598 : | |
2599 : | Date Programmer Description |
2600 : | ====== ============ ================================================= |
2601 : | Jun 96 Joel Gales Original Programmer |
2602 : | Aug 96 Joel Gales Make metadata ODL compliant |
2603 : | Feb 97 Joel Gales Set nEntries to -1 if status = -1 |
2604 : | |
2605 : | END_PROLOG |
2606 : -----------------------------------------------------------------------------*/
2607 : int32
2608 0 : SWnentries(int32 swathID, int32 entrycode, int32 * strbufsize)
2609 :
2610 : {
2611 : intn status; /* routine return status variable */
2612 : intn i; /* Loop index */
2613 :
2614 : int32 fid; /* HDF-EOS file ID */
2615 : int32 sdInterfaceID; /* HDF SDS interface ID */
2616 : int32 swVgrpID; /* Swath root Vgroup ID */
2617 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2618 0 : int32 nEntries = 0; /* Number of entries */
2619 : int32 metaflag; /* Old (0), New (1) metadata flag) */
2620 0 : int32 nVal = 0; /* Number of strings to search for */
2621 :
2622 0 : char *metabuf = NULL; /* Pointer to structural metadata (SM) */
2623 : char *metaptrs[2]; /* Pointers to begin and end of SM section */
2624 : char swathname[80]; /* Swath Name */
2625 : char *utlstr; /* Utility string */
2626 : char valName[2][32]; /* Strings to search for */
2627 :
2628 : /* Allocate space for utility string */
2629 : /* --------------------------------- */
2630 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
2631 0 : if(utlstr == NULL)
2632 : {
2633 0 : HEpush(DFE_NOSPACE,"SWnemtries", __FILE__, __LINE__);
2634 0 : return(-1);
2635 : }
2636 : /* Check for valid swath id */
2637 : /* ------------------------ */
2638 0 : status = SWchkswid(swathID, "SWnentries", &fid, &sdInterfaceID, &swVgrpID);
2639 :
2640 0 : if (status == 0)
2641 : {
2642 : /* Get swath name */
2643 0 : int sID = swathID % idOffset;
2644 0 : if (sID >= NSWATH)
2645 : {
2646 0 : free(utlstr);
2647 0 : return -1;
2648 : }
2649 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
2650 :
2651 : /* Zero out string buffer size */
2652 0 : *strbufsize = 0;
2653 :
2654 :
2655 : /*
2656 : * Get pointer to relevant section within SM and Get names of
2657 : * metadata strings to inquire about
2658 : */
2659 0 : switch (entrycode)
2660 : {
2661 0 : case HDFE_NENTDIM:
2662 : /* Dimensions */
2663 : {
2664 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
2665 : "Dimension", metaptrs);
2666 0 : if(metabuf == NULL)
2667 : {
2668 0 : free(utlstr);
2669 0 : return(-1);
2670 : }
2671 0 : nVal = 1;
2672 0 : strcpy(&valName[0][0], "DimensionName");
2673 : }
2674 0 : break;
2675 :
2676 0 : case HDFE_NENTMAP:
2677 : /* Dimension Maps */
2678 : {
2679 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
2680 : "DimensionMap", metaptrs);
2681 0 : if(metabuf == NULL)
2682 : {
2683 0 : free(utlstr);
2684 0 : return(-1);
2685 : }
2686 0 : nVal = 2;
2687 0 : strcpy(&valName[0][0], "GeoDimension");
2688 0 : strcpy(&valName[1][0], "DataDimension");
2689 : }
2690 0 : break;
2691 :
2692 0 : case HDFE_NENTIMAP:
2693 : /* Indexed Dimension Maps */
2694 : {
2695 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
2696 : "IndexDimensionMap", metaptrs);
2697 0 : if(metabuf == NULL)
2698 : {
2699 0 : free(utlstr);
2700 0 : return(-1);
2701 : }
2702 0 : nVal = 2;
2703 0 : strcpy(&valName[0][0], "GeoDimension");
2704 0 : strcpy(&valName[1][0], "DataDimension");
2705 : }
2706 0 : break;
2707 :
2708 0 : case HDFE_NENTGFLD:
2709 : /* Geolocation Fields */
2710 : {
2711 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
2712 : "GeoField", metaptrs);
2713 0 : if(metabuf == NULL)
2714 : {
2715 0 : free(utlstr);
2716 0 : return(-1);
2717 : }
2718 0 : nVal = 1;
2719 0 : strcpy(&valName[0][0], "GeoFieldName");
2720 : }
2721 0 : break;
2722 :
2723 0 : case HDFE_NENTDFLD:
2724 : /* Data Fields */
2725 : {
2726 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
2727 : "DataField", metaptrs);
2728 0 : if(metabuf == NULL)
2729 : {
2730 0 : free(utlstr);
2731 0 : return(-1);
2732 : }
2733 0 : nVal = 1;
2734 0 : strcpy(&valName[0][0], "DataFieldName");
2735 : }
2736 0 : break;
2737 : }
2738 :
2739 :
2740 : /*
2741 : * Check for presence of 'GROUP="' string If found then old metadata,
2742 : * search on OBJECT string
2743 : */
2744 0 : if (metabuf)
2745 : {
2746 0 : metaflag = (strstr(metabuf, "GROUP=\"") == NULL) ? 1 : 0;
2747 0 : if (metaflag == 0)
2748 : {
2749 0 : nVal = 1;
2750 0 : strcpy(&valName[0][0], "\t\tOBJECT");
2751 : }
2752 :
2753 :
2754 : /* Begin loop through entries in metadata */
2755 : /* -------------------------------------- */
2756 : while (1)
2757 : {
2758 : /* Search for first string */
2759 0 : strcpy(utlstr, &valName[0][0]);
2760 0 : strcat(utlstr, "=");
2761 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
2762 :
2763 : /* If found within relevant metadata section ... */
2764 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
2765 : {
2766 0 : for (i = 0; i < nVal; i++)
2767 : {
2768 : /*
2769 : * Get all string values Don't count quotes
2770 : */
2771 0 : EHgetmetavalue(metaptrs, &valName[i][0], utlstr);
2772 0 : *strbufsize += (int32)strlen(utlstr) - 2;
2773 : }
2774 : /* Increment number of entries */
2775 0 : nEntries++;
2776 :
2777 : /* Go to end of OBJECT */
2778 0 : metaptrs[0] = strstr(metaptrs[0], "END_OBJECT");
2779 : }
2780 : else
2781 : /* No more entries found */
2782 : {
2783 : break;
2784 : }
2785 : }
2786 0 : free(metabuf);
2787 : }
2788 :
2789 :
2790 : /* Count comma separators & slashes (if mappings) */
2791 : /* ---------------------------------------------- */
2792 0 : if (nEntries > 0)
2793 : {
2794 0 : *strbufsize += nEntries - 1;
2795 0 : *strbufsize += (nVal - 1) * nEntries;
2796 : }
2797 : }
2798 :
2799 :
2800 : /* Set nEntries to -1 if error status exists */
2801 : /* ----------------------------------------- */
2802 0 : if (status == -1)
2803 0 : nEntries = -1;
2804 :
2805 0 : free(utlstr);
2806 :
2807 0 : return (nEntries);
2808 : }
2809 :
2810 :
2811 :
2812 :
2813 :
2814 : /*----------------------------------------------------------------------------|
2815 : | BEGIN_PROLOG |
2816 : | |
2817 : | FUNCTION: SWinqswath |
2818 : | |
2819 : | DESCRIPTION: Returns number and names of swath structures in file |
2820 : | |
2821 : | |
2822 : | Return Value Type Units Description |
2823 : | ============ ====== ========= ===================================== |
2824 : | nSwath int32 Number of swath structures in file |
2825 : | |
2826 : | INPUTS: |
2827 : | filename char HDF-EOS filename |
2828 : | |
2829 : | OUTPUTS: |
2830 : | swathlist char List of swath names (comma-separated) |
2831 : | strbufsize int32 Length of swathlist |
2832 : | |
2833 : | NOTES: |
2834 : | |
2835 : | |
2836 : | Date Programmer Description |
2837 : | ====== ============ ================================================= |
2838 : | Jun 96 Joel Gales Original Programmer |
2839 : | |
2840 : | END_PROLOG |
2841 : -----------------------------------------------------------------------------*/
2842 : int32
2843 4 : SWinqswath(const char *filename, char *swathlist, int32 * strbufsize)
2844 : {
2845 : int32 nSwath; /* Number of swath structures in file */
2846 :
2847 : /* Call "EHinquire" routine */
2848 : /* ------------------------ */
2849 4 : nSwath = EHinquire(filename, "SWATH", swathlist, strbufsize);
2850 :
2851 4 : return (nSwath);
2852 : }
2853 :
2854 :
2855 :
2856 : /*----------------------------------------------------------------------------|
2857 : | BEGIN_PROLOG |
2858 : | |
2859 : | FUNCTION: SW1dfldsrch |
2860 : | |
2861 : | DESCRIPTION: Retrieves information about a 1D field |
2862 : | |
2863 : | |
2864 : | Return Value Type Units Description |
2865 : | ============ ====== ========= ===================================== |
2866 : | status intn return status (0) SUCCEED, (-1) FAIL |
2867 : | |
2868 : | INPUTS: |
2869 : | fid int32 HDF-EOS file ID |
2870 : | swathID int32 swath structure ID |
2871 : | fieldname const char field name |
2872 : | access const char Access code (w/r) |
2873 : | |
2874 : | |
2875 : | OUTPUTS: |
2876 : | vgidout int32 Field (geo/data) vgroup ID |
2877 : | vdataIDout int32 Field Vdata ID |
2878 : | fldtype int32 Field type |
2879 : | |
2880 : | NOTES: |
2881 : | |
2882 : | |
2883 : | Date Programmer Description |
2884 : | ====== ============ ================================================= |
2885 : | Jun 96 Joel Gales Original Programmer |
2886 : | |
2887 : | END_PROLOG |
2888 : -----------------------------------------------------------------------------*/
2889 : static intn
2890 0 : SW1dfldsrch(int32 fid, int32 swathID, const char *fieldname, const char *i_access,
2891 : int32 * vgidout, int32 * vdataIDout, int32 * fldtype)
2892 :
2893 : {
2894 0 : intn status = 0; /* routine return status variable */
2895 :
2896 : int32 sID; /* SwathID - offset */
2897 : int32 vgid; /* Swath Geo or Data Vgroup ID */
2898 : int32 vdataID; /* 1d field vdata */
2899 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2900 :
2901 :
2902 : /* Compute "reduced" swath ID */
2903 : /* -------------------------- */
2904 0 : sID = swathID % idOffset;
2905 0 : if (sID >= NSWATH)
2906 : {
2907 0 : return -1;
2908 : }
2909 :
2910 : /* Get Geolocation Vgroup id and 1D field name Vdata id */
2911 : /* ---------------------------------------------------- */
2912 0 : vgid = SWXSwath[sID].VIDTable[0];
2913 0 : vdataID = EHgetid(fid, vgid, fieldname, 1, i_access);
2914 0 : *fldtype = 0;
2915 :
2916 :
2917 : /*
2918 : * If name not found in Geolocation Vgroup then detach Geolocation Vgroup
2919 : * and search in Data Vgroup
2920 : */
2921 0 : if (vdataID == -1)
2922 : {
2923 0 : vgid = SWXSwath[sID].VIDTable[1];;
2924 0 : vdataID = EHgetid(fid, vgid, fieldname, 1, i_access);
2925 0 : *fldtype = 1;
2926 :
2927 : /* If field also not found in Data Vgroup then set error status */
2928 : /* ------------------------------------------------------------ */
2929 0 : if (vdataID == -1)
2930 : {
2931 0 : status = -1;
2932 0 : vgid = -1;
2933 0 : vdataID = -1;
2934 : }
2935 : }
2936 0 : *vgidout = vgid;
2937 0 : *vdataIDout = vdataID;
2938 :
2939 0 : return (status);
2940 : }
2941 :
2942 :
2943 :
2944 :
2945 :
2946 : /*----------------------------------------------------------------------------|
2947 : | BEGIN_PROLOG |
2948 : | |
2949 : | FUNCTION: SWSDfldsrch |
2950 : | |
2951 : | DESCRIPTION: Retrieves information SDS field |
2952 : | |
2953 : | |
2954 : | Return Value Type Units Description |
2955 : | ============ ====== ========= ===================================== |
2956 : | status intn return status (0) SUCCEED, (-1) FAIL |
2957 : | |
2958 : | INPUTS: |
2959 : | swathID int32 swath structure ID |
2960 : | sdInterfaceID int32 SD interface ID |
2961 : | fieldname const char field name |
2962 : | |
2963 : | |
2964 : | OUTPUTS: |
2965 : | sdid int32 SD element ID |
2966 : | rankSDS int32 Rank of SDS |
2967 : | rankFld int32 True rank of field (merging) |
2968 : | offset int32 Offset of field within merged field |
2969 : | dims int32 Dimensions of field |
2970 : | solo int32 Solo field flag |
2971 : | |
2972 : | NOTES: |
2973 : | |
2974 : | |
2975 : | Date Programmer Description |
2976 : | ====== ============ ================================================= |
2977 : | Jun 96 Joel Gales Original Programmer |
2978 : | Aug 96 Joel Gales Make metadata ODL compliant |
2979 : | |
2980 : | END_PROLOG |
2981 : -----------------------------------------------------------------------------*/
2982 : static intn
2983 0 : SWSDfldsrch(int32 swathID, int32 sdInterfaceID, const char *fieldname,
2984 : int32 * sdid, int32 * rankSDS, int32 * rankFld, int32 * offset,
2985 : int32 dims[], int32 * solo)
2986 : {
2987 : intn i; /* Loop index */
2988 0 : intn status = -1;/* routine return status variable */
2989 :
2990 : int32 sID; /* SwathID - offset */
2991 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2992 : int32 dum; /* Dummy variable */
2993 : int32 dums[128]; /* Dummy array */
2994 : int32 attrIndex; /* Attribute l_index */
2995 :
2996 : char name[2048]; /* Merged-Field Names */
2997 : char swathname[80]; /* Swath Name */
2998 : char *utlstr; /* Utility string */
2999 : char *metabuf; /* Pointer to structural metadata (SM) */
3000 : char *metaptrs[2];/* Pointers to begin and end of SM section */
3001 : char *oldmetaptr; /* Pointer within SM section */
3002 :
3003 :
3004 : /* Allocate space for utility string */
3005 : /* --------------------------------- */
3006 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
3007 0 : if(utlstr == NULL)
3008 : {
3009 0 : HEpush(DFE_NOSPACE,"SWSDfldsrch", __FILE__, __LINE__);
3010 0 : return(-1);
3011 : }
3012 : /* Set solo flag to 0 (no) */
3013 : /* ----------------------- */
3014 0 : *solo = 0;
3015 :
3016 :
3017 : /* Compute "reduced" swath ID */
3018 : /* -------------------------- */
3019 0 : sID = swathID % idOffset;
3020 0 : if (sID >= NSWATH)
3021 : {
3022 0 : free(utlstr);
3023 0 : return -1;
3024 : }
3025 :
3026 : /* Loop through all SDSs in swath */
3027 : /* ------------------------------ */
3028 0 : for (i = 0; i < SWXSwath[sID].nSDS; i++)
3029 : {
3030 : /* If active SDS ... */
3031 : /* ----------------- */
3032 0 : if (SWXSwath[sID].sdsID[i] != 0)
3033 : {
3034 : /* Get SDS ID, name, rankSDS, and dimensions */
3035 : /* ----------------------------------------- */
3036 0 : *sdid = SWXSwath[sID].sdsID[i];
3037 0 : SDgetinfo(*sdid, name, rankSDS, dims, &dum, &dum);
3038 0 : *rankFld = *rankSDS;
3039 :
3040 : /* If merged field ... */
3041 : /* ------------------- */
3042 0 : if (strstr(name, "MRGFLD_") == &name[0])
3043 : {
3044 : /* Get swath name */
3045 : /* -------------- */
3046 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
3047 :
3048 :
3049 : /* Get pointers to "MergedFields" section within SM */
3050 : /* ------------------------------------------------ */
3051 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
3052 : "MergedFields", metaptrs);
3053 0 : if(metabuf == NULL)
3054 : {
3055 0 : free(utlstr);
3056 0 : return(-1);
3057 : }
3058 :
3059 : /* Store metaptr in order to recover */
3060 : /* --------------------------------- */
3061 0 : oldmetaptr = metaptrs[0];
3062 :
3063 :
3064 : /* Search for Merged field name */
3065 : /* ---------------------------- */
3066 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%.480s%s", "MergedFieldName=\"",
3067 : name, "\"\n");
3068 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
3069 :
3070 :
3071 : /* If not found check for old metadata */
3072 : /* ----------------------------------- */
3073 0 : if (metaptrs[0] == NULL)
3074 : {
3075 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%.480s%s", "OBJECT=\"", name, "\"\n");
3076 0 : metaptrs[0] = strstr(oldmetaptr, utlstr);
3077 : }
3078 :
3079 :
3080 : /* Get field list and strip off leading and trailing quotes */
3081 0 : EHgetmetavalue(metaptrs, "FieldList", name); /* not return status --xhua */
3082 0 : memmove(name, name + 1, strlen(name) - 2);
3083 0 : name[strlen(name) - 2] = 0;
3084 :
3085 : /* Search for desired field within merged field list */
3086 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"");
3087 0 : dum = EHstrwithin(utlstr, name, ',');
3088 :
3089 0 : free(metabuf);
3090 : }
3091 : else
3092 : {
3093 : /* If solo (unmerged) check if SDS name matches fieldname */
3094 : /* ------------------------------------------------------ */
3095 0 : dum = EHstrwithin(fieldname, name, ',');
3096 0 : if (dum != -1)
3097 : {
3098 0 : *solo = 1;
3099 0 : *offset = 0;
3100 : }
3101 : }
3102 :
3103 :
3104 : /* If field found ... */
3105 : /* ------------------ */
3106 0 : if (dum != -1)
3107 : {
3108 0 : status = 0;
3109 :
3110 : /* If merged field ... */
3111 : /* ------------------- */
3112 0 : if (*solo == 0)
3113 : {
3114 : /* Get "Field Offsets" SDS attribute l_index */
3115 : /* --------------------------------------- */
3116 0 : attrIndex = SDfindattr(*sdid, "Field Offsets");
3117 :
3118 : /*
3119 : * If attribute exists then get offset of desired field
3120 : * within merged field
3121 : */
3122 0 : if (attrIndex != -1)
3123 : {
3124 0 : SDreadattr(*sdid, attrIndex, (VOIDP) dums);
3125 0 : *offset = dums[dum];
3126 : }
3127 :
3128 :
3129 : /* Get "Field Dims" SDS attribute l_index */
3130 : /* ------------------------------------ */
3131 0 : attrIndex = SDfindattr(*sdid, "Field Dims");
3132 :
3133 : /*
3134 : * If attribute exists then get 0th dimension of desired
3135 : * field within merged field
3136 : */
3137 0 : if (attrIndex != -1)
3138 : {
3139 0 : SDreadattr(*sdid, attrIndex, (VOIDP) dums);
3140 0 : dims[0] = dums[dum];
3141 :
3142 : /* If this dimension = 1 then field is really 2 dim */
3143 : /* ------------------------------------------------ */
3144 0 : if (dums[dum] == 1)
3145 : {
3146 0 : *rankFld = 2;
3147 : }
3148 : }
3149 : }
3150 :
3151 :
3152 : /* Break out of SDS loop */
3153 : /* --------------------- */
3154 0 : break;
3155 : } /* End of found field section */
3156 : }
3157 : else
3158 : {
3159 : /* First non-active SDS signifies no more, break out of SDS loop */
3160 : /* ------------------------------------------------------------- */
3161 0 : break;
3162 : }
3163 : }
3164 :
3165 0 : free(utlstr);
3166 :
3167 0 : return (status);
3168 : }
3169 :
3170 :
3171 :
3172 :
3173 :
3174 : /*----------------------------------------------------------------------------|
3175 : | BEGIN_PROLOG |
3176 : | |
3177 : | FUNCTION: SWwrrdfield |
3178 : | |
3179 : | DESCRIPTION: Writes/Reads fields |
3180 : | |
3181 : | |
3182 : | Return Value Type Units Description |
3183 : | ============ ====== ========= ===================================== |
3184 : | status intn return status (0) SUCCEED, (-1) FAIL |
3185 : | |
3186 : | INPUTS: |
3187 : | swathID int32 swath structure ID |
3188 : | fieldname const char fieldname |
3189 : | code const char Write/Read code (w/r) |
3190 : | start int32 start array |
3191 : | stride int32 stride array |
3192 : | edge int32 edge array |
3193 : | datbuf void data buffer for read |
3194 : | |
3195 : | |
3196 : | OUTPUTS: |
3197 : | datbuf void data buffer for write |
3198 : | |
3199 : | NOTES: |
3200 : | |
3201 : | |
3202 : | Date Programmer Description |
3203 : | ====== ============ ================================================= |
3204 : | Jun 96 Joel Gales Original Programmer |
3205 : | Feb 97 Joel Gales Stride = 1 HDF compression workaround |
3206 : | |
3207 : | END_PROLOG |
3208 : -----------------------------------------------------------------------------*/
3209 : static intn
3210 0 : SWwrrdfield(int32 swathID, const char *fieldname, const char *code,
3211 : int32 start[], int32 stride[], int32 edge[], VOIDP datbuf)
3212 :
3213 : {
3214 : intn i; /* Loop index */
3215 0 : intn status = 0; /* routine return status variable */
3216 :
3217 : int32 fid; /* HDF-EOS file ID */
3218 : int32 sdInterfaceID; /* HDF SDS interface ID */
3219 : int32 vgid; /* Swath Geo or Data Vgroup ID */
3220 : int32 sdid; /* SDS ID */
3221 : int32 dum; /* Dummy variable */
3222 : int32 rankSDS; /* Rank of SDS */
3223 : int32 rankFld; /* Rank of field */
3224 :
3225 : int32 vdataID; /* 1d field vdata */
3226 : int32 recsize; /* Vdata record size */
3227 : int32 fldsize; /* Field size */
3228 : int32 nrec; /* Number of records in Vdata */
3229 :
3230 : int32 offset[8]; /* I/O offset (start) */
3231 : int32 incr[8]; /* I/O increment (stride) */
3232 : int32 count[8]; /* I/O count (edge) */
3233 : int32 dims[8]; /* Field/SDS dimensions */
3234 : int32 mrgOffset; /* Merged field offset */
3235 : int32 nflds; /* Number of fields in Vdata */
3236 : int32 strideOne; /* Strides = 1 flag */
3237 :
3238 : uint8 *buf; /* I/O (transfer) buffer */
3239 : uint8 *fillbuf; /* Fill value buffer */
3240 :
3241 : char attrName[80]; /* Name of fill value attribute */
3242 : char *ptr[64]; /* String pointer array */
3243 : char fieldlist[256]; /* Vdata field list */
3244 :
3245 :
3246 : /* Check for valid swath ID */
3247 : /* ------------------------ */
3248 0 : status = SWchkswid(swathID, "SWwrrdfield", &fid, &sdInterfaceID, &dum);
3249 :
3250 :
3251 0 : if (status == 0)
3252 : {
3253 :
3254 : /* Check whether fieldname is in SDS (multi-dim field) */
3255 : /* --------------------------------------------------- */
3256 0 : status = SWSDfldsrch(swathID, sdInterfaceID, fieldname, &sdid,
3257 : &rankSDS, &rankFld, &mrgOffset, dims, &dum);
3258 :
3259 : /* Multi-Dimensional Field Section */
3260 : /* ------------------------------- */
3261 0 : if (status != -1)
3262 : {
3263 : /* Set I/O offset Section */
3264 : /* ---------------------- */
3265 :
3266 : /*
3267 : * If start == NULL (default) set I/O offset of 0th field to
3268 : * offset within merged field (if any) and the rest to 0
3269 : */
3270 0 : if (start == NULL)
3271 : {
3272 0 : for (i = 0; i < rankSDS; i++)
3273 : {
3274 0 : offset[i] = 0;
3275 : }
3276 0 : offset[0] = mrgOffset;
3277 : }
3278 : else
3279 : {
3280 : /*
3281 : * ... otherwise set I/O offset to user values, adjusting the
3282 : * 0th field with the merged field offset (if any)
3283 : */
3284 0 : if (rankFld == rankSDS)
3285 : {
3286 0 : for (i = 0; i < rankSDS; i++)
3287 : {
3288 0 : offset[i] = start[i];
3289 : }
3290 0 : offset[0] += mrgOffset;
3291 : }
3292 : else
3293 : {
3294 : /*
3295 : * If field really 2-dim merged in 3-dim field then set
3296 : * 0th field offset to merge offset and then next two to
3297 : * the user values
3298 : */
3299 0 : for (i = 0; i < rankFld; i++)
3300 : {
3301 0 : offset[i + 1] = start[i];
3302 : }
3303 0 : offset[0] = mrgOffset;
3304 : }
3305 : }
3306 :
3307 :
3308 :
3309 : /* Set I/O stride Section */
3310 : /* ---------------------- */
3311 :
3312 : /*
3313 : * If stride == NULL (default) set I/O stride to 1
3314 : */
3315 0 : if (stride == NULL)
3316 : {
3317 0 : for (i = 0; i < rankSDS; i++)
3318 : {
3319 0 : incr[i] = 1;
3320 : }
3321 : }
3322 : else
3323 : {
3324 : /*
3325 : * ... otherwise set I/O stride to user values
3326 : */
3327 0 : if (rankFld == rankSDS)
3328 : {
3329 0 : for (i = 0; i < rankSDS; i++)
3330 : {
3331 0 : incr[i] = stride[i];
3332 : }
3333 : }
3334 : else
3335 : {
3336 : /*
3337 : * If field really 2-dim merged in 3-dim field then set
3338 : * 0th field stride to 1 and then next two to the user
3339 : * values.
3340 : */
3341 0 : for (i = 0; i < rankFld; i++)
3342 : {
3343 0 : incr[i + 1] = stride[i];
3344 : }
3345 0 : incr[0] = 1;
3346 : }
3347 : }
3348 :
3349 :
3350 :
3351 : /* Set I/O count Section */
3352 : /* --------------------- */
3353 :
3354 : /*
3355 : * If edge == NULL (default) set I/O count to number of remaining
3356 : * entries (dims - start) / increment. Note that 0th field
3357 : * offset corrected for merged field offset (if any).
3358 : */
3359 0 : if (edge == NULL)
3360 : {
3361 0 : for (i = 1; i < rankSDS; i++)
3362 : {
3363 0 : count[i] = (dims[i] - offset[i]) / incr[i];
3364 : }
3365 0 : count[0] = (dims[0] - (offset[0] - mrgOffset)) / incr[0];
3366 : }
3367 : else
3368 : {
3369 : /*
3370 : * ... otherwise set I/O count to user values
3371 : */
3372 0 : if (rankFld == rankSDS)
3373 : {
3374 0 : for (i = 0; i < rankSDS; i++)
3375 : {
3376 0 : count[i] = edge[i];
3377 : }
3378 : }
3379 : else
3380 : {
3381 : /*
3382 : * If field really 2-dim merged in 3-dim field then set
3383 : * 0th field count to 1 and then next two to the user
3384 : * values.
3385 : */
3386 0 : for (i = 0; i < rankFld; i++)
3387 : {
3388 0 : count[i + 1] = edge[i];
3389 : }
3390 0 : count[0] = 1;
3391 : }
3392 : }
3393 :
3394 : /* Perform I/O with relevant HDF I/O routine */
3395 : /* ----------------------------------------- */
3396 0 : if (strcmp(code, "w") == 0)
3397 : {
3398 : /* Set strideOne to true (1) */
3399 : /* ------------------------- */
3400 0 : strideOne = 1;
3401 :
3402 :
3403 : /* If incr[i] != 1 set strideOne to false (0) */
3404 : /* ------------------------------------------ */
3405 0 : for (i = 0; i < rankSDS; i++)
3406 : {
3407 0 : if (incr[i] != 1)
3408 : {
3409 0 : strideOne = 0;
3410 0 : break;
3411 : }
3412 : }
3413 :
3414 :
3415 : /*
3416 : * If strideOne is true use NULL parameter for stride. This
3417 : * is a work-around to HDF compression problem
3418 : */
3419 0 : if (strideOne == 1)
3420 : {
3421 0 : status = SDwritedata(sdid, offset, NULL, count,
3422 : (VOIDP) datbuf);
3423 : }
3424 : else
3425 : {
3426 0 : status = SDwritedata(sdid, offset, incr, count,
3427 : (VOIDP) datbuf);
3428 : }
3429 : }
3430 : else
3431 : {
3432 0 : status = SDreaddata(sdid, offset, incr, count,
3433 : (VOIDP) datbuf);
3434 : }
3435 : } /* End of Multi-Dimensional Field Section */
3436 : else
3437 : {
3438 :
3439 : /* One-Dimensional Field Section */
3440 : /* ----------------------------- */
3441 :
3442 : /* Check fieldname within 1d field Vgroups */
3443 : /* --------------------------------------- */
3444 0 : status = SW1dfldsrch(fid, swathID, fieldname, code,
3445 : &vgid, &vdataID, &dum);
3446 :
3447 0 : if (status != -1)
3448 : {
3449 :
3450 : /* Get number of records */
3451 : /* --------------------- */
3452 0 : nrec = VSelts(vdataID);
3453 :
3454 :
3455 : /* Set offset, increment, & count */
3456 : /* ------------------------------ */
3457 0 : offset[0] = (start == NULL) ? 0 : start[0];
3458 0 : incr[0] = (stride == NULL) ? 1 : stride[0];
3459 0 : count[0] = (edge == NULL)
3460 0 : ? (nrec - offset[0]) / incr[0]
3461 0 : : edge[0];
3462 :
3463 :
3464 :
3465 : /* Write Section */
3466 : /* ------------- */
3467 0 : if (strcmp(code, "w") == 0)
3468 : {
3469 : /* Get size of field and setup fill buffer */
3470 : /* --------------------------------------- */
3471 0 : fldsize = VSsizeof(vdataID, (char *)fieldname);
3472 0 : fillbuf = (uint8 *) calloc(fldsize, 1);
3473 0 : if(fillbuf == NULL)
3474 : {
3475 0 : HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__);
3476 0 : return(-1);
3477 : }
3478 :
3479 : /* Get size of record in Vdata and setup I/O buffer */
3480 : /* ------------------------------------------------ */
3481 0 : VSQueryvsize(vdataID, &recsize);
3482 0 : buf = (uint8 *) calloc(recsize, count[0] * incr[0]);
3483 0 : if(buf == NULL)
3484 : {
3485 0 : HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__);
3486 0 : free(fillbuf);
3487 0 : return(-1);
3488 : }
3489 :
3490 :
3491 : /* Get names and number of fields in each record */
3492 : /* ---------------------------------------------- */
3493 0 : VSgetfields(vdataID, fieldlist);
3494 0 : dum = EHstrwithin(fieldname, fieldlist, ',');
3495 0 : nflds = EHparsestr(fieldlist, ',', ptr, NULL);
3496 :
3497 :
3498 : /* Get Merged Field Offset (if any) */
3499 : /* -------------------------------- */
3500 0 : if (nflds > 1)
3501 : {
3502 0 : if (dum > 0)
3503 : {
3504 0 : *(ptr[dum] - 1) = 0;
3505 0 : mrgOffset = VSsizeof(vdataID, fieldlist);
3506 0 : *(ptr[dum] - 1) = ',';
3507 : }
3508 : else
3509 : {
3510 0 : mrgOffset = 0;
3511 : }
3512 :
3513 : /* Read records to recover previously written data */
3514 0 : /* status = */ VSsetfields(vdataID, fieldlist);
3515 0 : /* status = */ VSseek(vdataID, offset[0]);
3516 0 : nrec = VSread(vdataID, buf, count[0] * incr[0],
3517 : FULL_INTERLACE);
3518 : }
3519 : else
3520 : {
3521 0 : mrgOffset = 0;
3522 : }
3523 :
3524 :
3525 :
3526 : /* Fill buffer with "Fill" value (if any) */
3527 : /* -------------------------------------- */
3528 0 : snprintf( attrName, sizeof(attrName), "_FV_%s", fieldname);
3529 :
3530 0 : status = SWreadattr(swathID, attrName, (char *) fillbuf);
3531 0 : if (status == 0)
3532 : {
3533 0 : for (i = 0; i < count[0] * incr[0]; i++)
3534 : {
3535 0 : memcpy(buf + i * recsize + mrgOffset,
3536 : fillbuf, fldsize);
3537 : }
3538 : }
3539 :
3540 :
3541 : /* Write new data into buffer */
3542 : /* -------------------------- */
3543 0 : if (incr[0] == 1 && nflds == 1)
3544 : {
3545 0 : memcpy(buf, datbuf, count[0] * recsize);
3546 : }
3547 : else
3548 : {
3549 0 : for (i = 0; i < count[0]; i++)
3550 : {
3551 0 : memcpy(buf + i * recsize * incr[0] + mrgOffset,
3552 0 : (uint8 *) datbuf + i * fldsize, fldsize);
3553 : }
3554 : }
3555 :
3556 :
3557 : /* If append read last record */
3558 : /* -------------------------- */
3559 0 : if (offset[0] == nrec)
3560 : {
3561 : /* abe added "status =" to next line 8/8/97 */
3562 0 : status = VSseek(vdataID, offset[0] - 1);
3563 0 : VSread(vdataID, fillbuf, 1, FULL_INTERLACE);
3564 : }
3565 : else
3566 : {
3567 0 : status = VSseek(vdataID, offset[0]);
3568 : }
3569 :
3570 :
3571 : /* Write data into Vdata */
3572 : /* --------------------- */
3573 0 : nrec = VSwrite(vdataID, buf, count[0] * incr[0],
3574 : FULL_INTERLACE);
3575 :
3576 0 : free(fillbuf);
3577 0 : if (status > 0)
3578 0 : status = 0;
3579 :
3580 : } /* End Write Section */
3581 : else
3582 : {
3583 : /* Read Section */
3584 : /* ------------ */
3585 0 : status = VSsetfields(vdataID, fieldname);
3586 0 : fldsize = VSsizeof(vdataID, (char *)fieldname);
3587 0 : buf = (uint8 *) calloc(fldsize, count[0] * incr[0]);
3588 0 : if(buf == NULL)
3589 : {
3590 0 : HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__);
3591 0 : return(-1);
3592 : }
3593 :
3594 0 : (void) VSseek(vdataID, offset[0]);
3595 0 : (void) VSread(vdataID, buf, count[0] * incr[0],
3596 : FULL_INTERLACE);
3597 :
3598 :
3599 : /* Copy from input buffer to returned data buffer */
3600 : /* ---------------------------------------------- */
3601 0 : if (incr[0] == 1)
3602 : {
3603 0 : memcpy(datbuf, buf, count[0] * fldsize);
3604 : }
3605 : else
3606 : {
3607 0 : for (i = 0; i < count[0]; i++)
3608 : {
3609 0 : memcpy((uint8 *) datbuf + i * fldsize,
3610 0 : buf + i * fldsize * incr[0], fldsize);
3611 : }
3612 : }
3613 :
3614 : } /* End Read Section */
3615 :
3616 0 : free(buf);
3617 0 : VSdetach(vdataID);
3618 : }
3619 : else
3620 : {
3621 0 : HEpush(DFE_GENAPP, "SWwrrdfield", __FILE__, __LINE__);
3622 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
3623 : }
3624 : } /* End One-D Field Section */
3625 :
3626 : }
3627 0 : return (status);
3628 : }
3629 :
3630 :
3631 :
3632 : /*----------------------------------------------------------------------------|
3633 : | BEGIN_PROLOG |
3634 : | |
3635 : | FUNCTION: SWreadfield |
3636 : | |
3637 : | DESCRIPTION: Reads data from field |
3638 : | |
3639 : | Return Value Type Units Description |
3640 : | ============ ====== ========= ===================================== |
3641 : | status intn return status (0) SUCCEED, (-1) FAIL |
3642 : | |
3643 : | INPUTS: |
3644 : | swathID int32 swath structure ID |
3645 : | fieldname const char fieldname |
3646 : | start int32 start array |
3647 : | stride int32 stride array |
3648 : | edge int32 edge array |
3649 : | buffer void data buffer for read |
3650 : | |
3651 : | |
3652 : | OUTPUTS: |
3653 : | None |
3654 : | |
3655 : | NOTES: |
3656 : | |
3657 : | |
3658 : | Date Programmer Description |
3659 : | ====== ============ ================================================= |
3660 : | Jun 96 Joel Gales Original Programmer |
3661 : | |
3662 : | END_PROLOG |
3663 : -----------------------------------------------------------------------------*/
3664 : intn
3665 0 : SWreadfield(int32 swathID, const char *fieldname,
3666 : int32 start[], int32 stride[], int32 edge[], VOIDP buffer)
3667 :
3668 : {
3669 0 : intn status = 0; /* routine return status variable */
3670 :
3671 0 : status = SWwrrdfield(swathID, fieldname, "r", start, stride, edge,
3672 : buffer);
3673 0 : return (status);
3674 : }
3675 :
3676 : /*----------------------------------------------------------------------------|
3677 : | BEGIN_PROLOG |
3678 : | |
3679 : | FUNCTION: SWgetfillvalue |
3680 : | |
3681 : | DESCRIPTION: Retrieves fill value for a specified field. |
3682 : | |
3683 : | |
3684 : | Return Value Type Units Description |
3685 : | ============ ====== ========= ===================================== |
3686 : | status intn return status (0) SUCCEED, (-1) FAIL |
3687 : | |
3688 : | INPUTS: |
3689 : | swathID int32 swath structure ID |
3690 : | fieldname char field name |
3691 : | |
3692 : | OUTPUTS: |
3693 : | fillval void fill value |
3694 : | |
3695 : | NOTES: |
3696 : | |
3697 : | |
3698 : | Date Programmer Description |
3699 : | ====== ============ ================================================= |
3700 : | Jun 96 Joel Gales Original Programmer |
3701 : | |
3702 : | END_PROLOG |
3703 : -----------------------------------------------------------------------------*/
3704 : intn
3705 0 : SWgetfillvalue(int32 swathID, const char *fieldname, VOIDP fillval)
3706 : {
3707 : intn status; /* routine return status variable */
3708 :
3709 : int32 nt; /* Number type */
3710 : int32 dims[8]; /* Dimensions array */
3711 : int32 dum; /* Dummy variable */
3712 :
3713 : char name[80]; /* Fill value "attribute" name */
3714 :
3715 : /* Check for valid swath ID */
3716 0 : status = SWchkswid(swathID, "SWgetfillvalue", &dum, &dum, &dum);
3717 :
3718 0 : if (status == 0)
3719 : {
3720 : /* Get field info */
3721 0 : status = SWfieldinfo(swathID, fieldname, &dum, dims, &nt, NULL);
3722 :
3723 0 : if (status == 0)
3724 : {
3725 : /* Read fill value attribute */
3726 0 : strcpy(name, "_FV_");
3727 0 : strcat(name, fieldname);
3728 0 : status = SWreadattr(swathID, name, fillval);
3729 : }
3730 : else
3731 : {
3732 0 : HEpush(DFE_GENAPP, "SWgetfillvalue", __FILE__, __LINE__);
3733 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
3734 : }
3735 :
3736 : }
3737 0 : return (status);
3738 : }
3739 :
3740 :
3741 : /*----------------------------------------------------------------------------|
3742 : | BEGIN_PROLOG |
3743 : | |
3744 : | FUNCTION: SWdetach |
3745 : | |
3746 : | DESCRIPTION: Detaches swath structure and performs housekeeping |
3747 : | |
3748 : | |
3749 : | Return Value Type Units Description |
3750 : | ============ ====== ========= ===================================== |
3751 : | status intn return status (0) SUCCEED, (-1) FAIL |
3752 : | |
3753 : | INPUTS: |
3754 : | swathID int32 swath structure ID |
3755 : | |
3756 : | |
3757 : | OUTPUTS: |
3758 : | None |
3759 : | |
3760 : | NOTES: |
3761 : | |
3762 : | |
3763 : | Date Programmer Description |
3764 : | ====== ============ ================================================= |
3765 : | Jun 96 Joel Gales Original Programmer |
3766 : | Aug 96 Joel Gales Cleanup Region External Structure |
3767 : | Sep 96 Joel Gales Setup dim names for SDsetdimnane in dimbuf1 rather |
3768 : | than utlstr |
3769 : | Nov 96 Joel Gales Call SWchkgdid to check for proper swath ID |
3770 : | Dec 96 Joel Gales Add multiple vertical subsetting garbage collection |
3771 : | |
3772 : | END_PROLOG |
3773 : -----------------------------------------------------------------------------*/
3774 : intn
3775 0 : SWdetach(int32 swathID)
3776 :
3777 : {
3778 : intn i; /* Loop index */
3779 : intn k; /* Loop index */
3780 0 : intn status = 0; /* routine return status variable */
3781 :
3782 : uint8 *buf; /* Buffer for blank (initial) 1D records */
3783 :
3784 : int32 vdataID; /* Vdata ID */
3785 : int32 dims[3]; /* Dimension array */
3786 : int32 sdInterfaceID; /* SDS interface ID */
3787 : int32 sID; /* Swath ID - offset */
3788 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
3789 : int32 dum; /* Dummy variable */
3790 :
3791 : char swathname[VGNAMELENMAX + 1]; /* Swath name */
3792 :
3793 : /* Check for proper swath ID and get SD interface ID */
3794 : /* ------------------------------------------------- */
3795 0 : status = SWchkswid(swathID, "SWdetach", &dum, &sdInterfaceID, &dum);
3796 :
3797 0 : if (status == 0)
3798 : {
3799 : /* Subtract off swath ID offset and get swath name */
3800 : /* ----------------------------------------------- */
3801 0 : sID = swathID % idOffset;
3802 0 : if (sID >= NSWATH)
3803 : {
3804 0 : return -1;
3805 : }
3806 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
3807 :
3808 :
3809 : /* Create 1D "orphaned" fields */
3810 : /* --------------------------- */
3811 0 : i = 0;
3812 :
3813 : /* Find "active" entries in 1d combination array */
3814 : /* --------------------------------------------- */
3815 0 : while (SWX1dcomb[3 * i] != 0)
3816 : {
3817 : /* For fields defined within swath... */
3818 : /* ---------------------------------- */
3819 0 : if (SWX1dcomb[3 * i + 1] == SWXSwath[sID].IDTable)
3820 : {
3821 : /* Get dimension size and vdata ID */
3822 : /* ------------------------------- */
3823 0 : dims[0] = abs(SWX1dcomb[3 * i]);
3824 0 : vdataID = SWX1dcomb[3 * i + 2];
3825 :
3826 : /* Get fieldname (= vdata name) */
3827 : /* ---------------------------- */
3828 0 : char* nambuf = (char *) calloc(VSNAMELENMAX + 1, 1);
3829 0 : if(nambuf == NULL)
3830 : {
3831 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
3832 0 : return(-1);
3833 : }
3834 :
3835 0 : VSgetname(vdataID, nambuf);
3836 :
3837 : /* Set field within vdata */
3838 : /* ---------------------- */
3839 0 : VSsetfields(vdataID, nambuf);
3840 :
3841 : /* Write (blank) records */
3842 : /* --------------------- */
3843 0 : buf = (uint8 *) calloc(VSsizeof(vdataID, nambuf), dims[0]);
3844 0 : if(buf == NULL)
3845 : {
3846 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
3847 0 : free(nambuf);
3848 0 : return(-1);
3849 : }
3850 0 : VSwrite(vdataID, buf, dims[0], FULL_INTERLACE);
3851 :
3852 0 : free(buf);
3853 0 : free(nambuf);
3854 :
3855 : /* Detach Vdata */
3856 : /* ------------ */
3857 0 : VSdetach(vdataID);
3858 : }
3859 0 : i++;
3860 : }
3861 :
3862 : /* "Contract" 1dcomb array */
3863 : /* ----------------------- */
3864 0 : i = 0;
3865 0 : while (SWX1dcomb[3 * i] != 0)
3866 : {
3867 0 : if (SWX1dcomb[3 * i + 1] == SWXSwath[sID].IDTable)
3868 : {
3869 0 : memcpy(&SWX1dcomb[3 * i],
3870 0 : &SWX1dcomb[3 * (i + 1)],
3871 0 : (512 - i - 1) * 3 * 4);
3872 : }
3873 : else
3874 0 : i++;
3875 : }
3876 :
3877 : /* "Detach" from previously attached SDSs */
3878 : /* -------------------------------------- */
3879 0 : for (k = 0; k < SWXSwath[sID].nSDS; k++)
3880 : {
3881 0 : SDendaccess(SWXSwath[sID].sdsID[k]);
3882 : }
3883 0 : free(SWXSwath[sID].sdsID);
3884 0 : SWXSwath[sID].sdsID = 0;
3885 0 : SWXSwath[sID].nSDS = 0;
3886 :
3887 :
3888 : /* Detach Swath Vgroups */
3889 : /* -------------------- */
3890 0 : Vdetach(SWXSwath[sID].VIDTable[0]);
3891 0 : Vdetach(SWXSwath[sID].VIDTable[1]);
3892 0 : Vdetach(SWXSwath[sID].VIDTable[2]);
3893 0 : Vdetach(SWXSwath[sID].IDTable);
3894 :
3895 :
3896 : /* Delete entries from External Arrays */
3897 : /* ----------------------------------- */
3898 0 : SWXSwath[sID].active = 0;
3899 0 : SWXSwath[sID].VIDTable[0] = 0;
3900 0 : SWXSwath[sID].VIDTable[1] = 0;
3901 0 : SWXSwath[sID].VIDTable[2] = 0;
3902 0 : SWXSwath[sID].IDTable = 0;
3903 0 : SWXSwath[sID].fid = 0;
3904 :
3905 :
3906 : /* Free Region Pointers */
3907 : /* -------------------- */
3908 0 : for (k = 0; k < NSWATHREGN; k++)
3909 : {
3910 0 : if (SWXRegion[k] != 0 &&
3911 0 : SWXRegion[k]->swathID == swathID)
3912 : {
3913 0 : for (i = 0; i < 8; i++)
3914 : {
3915 0 : if (SWXRegion[k]->DimNamePtr[i] != 0)
3916 : {
3917 0 : free(SWXRegion[k]->DimNamePtr[i]);
3918 : }
3919 : }
3920 :
3921 0 : free(SWXRegion[k]);
3922 0 : SWXRegion[k] = 0;
3923 : }
3924 : }
3925 :
3926 : }
3927 0 : return (status);
3928 : }
3929 :
3930 : /*----------------------------------------------------------------------------|
3931 : | BEGIN_PROLOG |
3932 : | |
3933 : | FUNCTION: SWclose |
3934 : | |
3935 : | DESCRIPTION: Closes HDF-EOS file |
3936 : | |
3937 : | |
3938 : | Return Value Type Units Description |
3939 : | ============ ====== ========= ===================================== |
3940 : | status intn return status (0) SUCCEED, (-1) FAIL |
3941 : | |
3942 : | INPUTS: |
3943 : | fid int32 File ID |
3944 : | |
3945 : | OUTPUTS: |
3946 : | None |
3947 : | |
3948 : | NOTES: |
3949 : | |
3950 : | |
3951 : | Date Programmer Description |
3952 : | ====== ============ ================================================= |
3953 : | Jun 96 Joel Gales Original Programmer |
3954 : | |
3955 : | END_PROLOG |
3956 : -----------------------------------------------------------------------------*/
3957 : intn
3958 4 : SWclose(int32 fid)
3959 :
3960 : {
3961 4 : intn status = 0; /* routine return status variable */
3962 :
3963 : /* Call EHclose to perform file close */
3964 : /* ---------------------------------- */
3965 4 : status = EHclose(fid);
3966 :
3967 4 : return (status);
3968 : }
3969 :
3970 : /*----------------------------------------------------------------------------|
3971 : | BEGIN_PROLOG |
3972 : | |
3973 : | FUNCTION: SWgeomapinfo |
3974 : | |
3975 : | DESCRIPTION: Returns mapping information for dimension |
3976 : | |
3977 : | |
3978 : | Return Value Type Units Description |
3979 : | ============ ====== ========= ===================================== |
3980 : | status intn 2 for l_indexed mapping, 1 for regular |
3981 : | mapping, 0 if the dimension is not |
3982 : | and (-1) FAIL |
3983 : | |
3984 : | INPUTS: |
3985 : | swathID int32 swath structure id |
3986 : | geodim char geolocation dimension name |
3987 : | |
3988 : | OUTPUTS: |
3989 : | |
3990 : | NONE |
3991 : | |
3992 : | NOTES: |
3993 : | |
3994 : | |
3995 : | Date Programmer Description |
3996 : | ====== ============ ================================================= |
3997 : | Aug 97 Abe Taaheri Original Programmer |
3998 : | Sept 97 DaW Modified return value so errors can be trapped |
3999 : | |
4000 : | END_PROLOG |
4001 : -----------------------------------------------------------------------------*/
4002 : intn
4003 0 : SWgeomapinfo(int32 swathID, const char *geodim)
4004 :
4005 : {
4006 : intn status; /* routine return status variable */
4007 :
4008 : int32 fid; /* HDF-EOS file ID */
4009 : int32 sdInterfaceID; /* HDF SDS interface ID */
4010 : int32 swVgrpID; /* Swath root Vgroup ID */
4011 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
4012 :
4013 : char *metabufr; /* Pointer to structural metadata (SM) */
4014 : char *metabufi; /* Pointer to structural metadata (SM) */
4015 : char *metaptrsr[2];/* Pointers to begin and end of SM section */
4016 : char *metaptrsi[2];/* Pointers to begin and end of SM section */
4017 : char swathname[80]; /* Swath Name */
4018 : char *utlstrr; /* Utility string */
4019 : char *utlstri; /* Utility string */
4020 :
4021 :
4022 : /* Allocate space for utility string */
4023 : /* --------------------------------- */
4024 0 : utlstrr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
4025 0 : if(utlstrr == NULL)
4026 : {
4027 0 : HEpush(DFE_NOSPACE,"SWgeomapinfo", __FILE__, __LINE__);
4028 0 : return(-1);
4029 : }
4030 0 : utlstri = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
4031 0 : if(utlstri == NULL)
4032 : {
4033 0 : HEpush(DFE_NOSPACE,"SWgeomapinfo", __FILE__, __LINE__);
4034 0 : free(utlstrr);
4035 0 : return(-1);
4036 : }
4037 0 : status = -1;
4038 :
4039 : /* Check for valid swath id */
4040 0 : status = SWchkswid(swathID, "SWgeomapinfo", &fid, &sdInterfaceID, &swVgrpID);
4041 0 : if (status == 0)
4042 : {
4043 : /* Get swath name */
4044 0 : int sID = swathID % idOffset;
4045 0 : if (sID >= NSWATH)
4046 : {
4047 0 : free(utlstrr);
4048 0 : free(utlstri);
4049 0 : return -1;
4050 : }
4051 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
4052 :
4053 : /* Get pointers to "DimensionMap" section within SM */
4054 0 : metabufr = EHmetagroup(sdInterfaceID, swathname, "s",
4055 : "DimensionMap", metaptrsr);
4056 :
4057 0 : if(metabufr == NULL)
4058 : {
4059 0 : free(utlstrr);
4060 0 : free(utlstri);
4061 0 : return(-1);
4062 : }
4063 : /* Search for mapping - GeoDim/DataDim (surrounded by quotes) */
4064 0 : snprintf(utlstrr, UTLSTR_MAX_SIZE, "%s%s%s", "\t\t\t\tGeoDimension=\"", geodim,
4065 : "\"\n\t\t\t\tDataDimension=");
4066 0 : metaptrsr[0] = strstr(metaptrsr[0], utlstrr);
4067 :
4068 : /* Get pointers to "IndexDimensionMap" section within SM */
4069 0 : metabufi = EHmetagroup(sdInterfaceID, swathname, "s",
4070 : "IndexDimensionMap", metaptrsi);
4071 0 : if(metabufi == NULL)
4072 : {
4073 0 : free(utlstrr);
4074 0 : free(utlstri);
4075 0 : return(-1);
4076 : }
4077 : /* Search for mapping - GeoDim/DataDim (surrounded by quotes) */
4078 0 : snprintf(utlstri, UTLSTR_MAX_SIZE, "%s%s%s", "\t\t\t\tGeoDimension=\"", geodim,
4079 : "\"\n\t\t\t\tDataDimension=");
4080 0 : metaptrsi[0] = strstr(metaptrsi[0], utlstri);
4081 :
4082 : /*
4083 : ** If regular mapping found add 1 to status
4084 : ** If l_indexed mapping found add 2
4085 : */
4086 0 : if (metaptrsr[0] < metaptrsr[1] && metaptrsr[0] != NULL)
4087 : {
4088 0 : status = status + 1;
4089 : }
4090 :
4091 0 : if (metaptrsi[0] < metaptrsi[1] && metaptrsi[0] != NULL)
4092 : {
4093 0 : status = status + 2;
4094 : }
4095 :
4096 0 : free(metabufr);
4097 0 : free(metabufi);
4098 : }
4099 :
4100 0 : free(utlstrr);
4101 0 : free(utlstri);
4102 :
4103 0 : return (status);
4104 : }
4105 :
4106 : /*----------------------------------------------------------------------------|
4107 : | BEGIN_PROLOG |
4108 : | |
4109 : | FUNCTION: SWsdid |
4110 : | |
4111 : | DESCRIPTION: Returns SD element ID for swath field |
4112 : | |
4113 : | |
4114 : | Return Value Type Units Description |
4115 : | ============ ====== ========= ===================================== |
4116 : | status intn return status (0) SUCCEED, (-1) FAIL |
4117 : | |
4118 : | INPUTS: |
4119 : | swathID int32 swath structure ID |
4120 : | fieldname const char field name |
4121 : | |
4122 : | |
4123 : | OUTPUTS: |
4124 : | sdid int32 SD element ID |
4125 : | |
4126 : | NOTES: |
4127 : | |
4128 : | |
4129 : | Date Programmer Description |
4130 : | ====== ============ ================================================= |
4131 : | Oct 07 Andrey Kiselev Original Programmer |
4132 : | |
4133 : | END_PROLOG |
4134 : -----------------------------------------------------------------------------*/
4135 : intn
4136 0 : SWsdid(int32 swathID, const char *fieldname, int32 *sdid)
4137 : {
4138 : intn status; /* routine return status variable */
4139 : int32 fid; /* HDF-EOS file ID */
4140 : int32 sdInterfaceID; /* HDF SDS interface ID */
4141 : int32 dum; /* Dummy variable */
4142 : int32 dims[H4_MAX_VAR_DIMS]; /* Field/SDS dimensions */
4143 :
4144 0 : status = SWchkswid(swathID, "SWsdid", &fid, &sdInterfaceID, &dum);
4145 0 : if (status != -1)
4146 : {
4147 0 : status = SWSDfldsrch(swathID, sdInterfaceID, fieldname,
4148 : sdid, &dum, &dum, &dum, dims, &dum);
4149 : }
4150 :
4151 0 : return (status);
4152 : }
|
