Line data Source code
1 : /*****************************************************************************
2 : * $Id$
3 : *
4 : * This module has a number of additions and improvements over the original
5 : * implementation to be suitable for usage in GDAL HDF driver.
6 : *
7 : * Andrey Kiselev <dron@ak4719.spb.edu> is responsible for all the changes.
8 : ****************************************************************************/
9 :
10 : /*
11 : Copyright (C) 1996 Hughes and Applied Research Corporation
12 :
13 : Permission to use, modify, and distribute this software and its documentation
14 : for any purpose without fee is hereby granted, provided that the above
15 : copyright notice appear in all copies and that both that copyright notice and
16 : this permission notice appear in supporting documentation.
17 : */
18 : /*****************************************************************************
19 : REVISIONS:
20 :
21 : Aug 31, 1999 Abe Taaheri Changed memory allocation for utility strings to
22 : the size of UTLSTR_MAX_SIZE.
23 : Added error check for memory unavailability in
24 : several functions.
25 : Added check for NULL metabuf returned from
26 : EHmeta... functions. NULL pointer returned from
27 : EHmeta... functions indicate that memory could not
28 : be allocated for metabuf.
29 :
30 : June 05, 2003 Abe Taaheri / Bruce Beaumont
31 :
32 : Changed MAXNREGIONS to 1024 to support MOPITT data
33 : Supplied cast for compcode in call to
34 : SDsetcompress to avoid compiler error
35 : Removed declaration for unused variable rstatus
36 : in SWwrrdfield
37 : Removed initialization code for unused variables
38 : in SWwrrdfield
39 : Removed declaration for unused variable tmpVal
40 : in SWdefboxregion
41 : Added code in SWdefboxregion to check for l_index k
42 : exceeding NSWATHREGN to avoid overwriting
43 : memory
44 : Removed declaration for unused variable retchar
45 : in SWregionl_index
46 : Removed initialization code for unused variables
47 : in SWregionl_index
48 : Removed declarations for unused variables tstatus,
49 : nfields, nflgs, and swathname in SWextractregion
50 : Removed initialization code for unused variables
51 : in SWextractregion
52 : Removed declaration for unused variable
53 : land_status in SWscan2longlat
54 : Removed initialization code for unused variables
55 : in SWscan2longlat
56 : Added clear (0) of timeflag in SWextractperiod if
57 : return status from SWextractregion is non-zero
58 : Removed declarations for unused variables tstatus,
59 : scandim, ndfields, ndflds, and swathname in
60 : SWregioninfo
61 : Removed initialization code for unused variables
62 : in SWregioninfo
63 : Added clear (0) of timeflag in SWperiodinfo if
64 : return status from SWregioninfo is non-zero
65 : Removed declarations for unused variables size,
66 : nfields, nflds, nswath, idxsz, cornerlon, and
67 : cornerlat in SWdefscanregion
68 : Removed initialization code for unused variables
69 : in SWdefscanregion
70 : Removed declarations for unused variables dims2,
71 : rank, nt, swathname, dimlist, and buffer in
72 : SWupdateidxmap
73 : Removed declaration for unused variable statmeta
74 : in SWgeomapinfo
75 : ******************************************************************************/
76 :
77 : #include "cpl_port.h" /* for M_PI */
78 : #include "cpl_string.h" /* for CPLsnprintf */
79 :
80 : #include "mfhdf.h"
81 : #include "hcomp.h"
82 : #include "HdfEosDef.h"
83 : #include <math.h>
84 :
85 : #include "hdf4compat.h"
86 :
87 : #define SWIDOFFSET 1048576
88 :
89 :
90 : static int32 SWX1dcomb[512*3];
91 : static int32 SWXSDcomb[512*5];
92 : static char SWXSDname[HDFE_NAMBUFSIZE];
93 : static char SWXSDdims[HDFE_DIMBUFSIZE];
94 :
95 : /* This flag was added to allow the Time field to have different Dimensions
96 : ** than Longitude and Latitude and still be used for subsetting
97 : ** 23 June,1997 DaW
98 : */
99 : static intn timeflag = 0;
100 :
101 :
102 : /* Added for routine that converts scanline to Lat/long
103 : ** for floating scene subsetting
104 : ** Jul 1999 DaW
105 : */
106 : #define RADOE 6371.0 /* Radius of Earth in Km */
107 :
108 : #define NSWATH 200
109 : /* Swath Structure External Arrays */
110 : struct swathStructure
111 : {
112 : int32 active;
113 : int32 IDTable;
114 : int32 VIDTable[3];
115 : int32 fid;
116 : int32 nSDS;
117 : int32 *sdsID;
118 : int32 compcode;
119 : intn compparm[5];
120 : int32 tilecode;
121 : int32 tilerank;
122 : int32 tiledims[8];
123 : };
124 : static struct swathStructure SWXSwath[NSWATH];
125 :
126 :
127 :
128 : #define NSWATHREGN 256
129 : #define MAXNREGIONS 1024
130 : struct swathRegion
131 : {
132 : int32 fid;
133 : int32 swathID;
134 : int32 nRegions;
135 : int32 StartRegion[MAXNREGIONS];
136 : int32 StopRegion[MAXNREGIONS];
137 : int32 StartVertical[8];
138 : int32 StopVertical[8];
139 : int32 StartScan[8];
140 : int32 StopScan[8];
141 : char *DimNamePtr[8];
142 : intn band8flag;
143 : intn scanflag;
144 : };
145 : static struct swathRegion *SWXRegion[NSWATHREGN];
146 :
147 : /* define a macro for the string size of the utility strings. The value
148 : of 80 in previous version of this code was resulting in core dump (Array
149 : Bounds Write and Array Bounds Read problem in SWfinfo function and the
150 : functions called from there) for 7-8 dimensional fields where the
151 : string length for "DimList" can exceed 80 characters, including " and
152 : commas in the string. The length now is 512 which seems to be more
153 : than enough to avoid the problem mentioned above. */
154 :
155 : #define UTLSTR_MAX_SIZE 512
156 :
157 : /* Swath Prototypes (internal routines) */
158 : static intn SWchkswid(int32, const char *, int32 *, int32 *, int32 *);
159 : static int32 SWfinfo(int32, const char *, const char *, int32 *,
160 : int32 [], int32 *, char *);
161 : static intn SWdefinefield(int32, const char *, const char *, const char *, int32, int32);
162 : static intn SWwrrdattr(int32, const char *, int32, int32, const char *, VOIDP);
163 : static intn SW1dfldsrch(int32, int32, const char *, const char *, int32 *,
164 : int32 *, int32 *);
165 : static intn SWSDfldsrch(int32, int32, const char *, int32 *, int32 *,
166 : int32 *, int32 *, int32 [], int32 *);
167 : static intn SWwrrdfield(int32, const char *, const char *,
168 : int32 [], int32 [], int32 [], VOIDP);
169 : static int32 SWinqfields(int32, const char *, char *, int32 [], int32 []);
170 : static intn SWscan2longlat(int32, const char *, VOIDP, int32 [], int32 [],
171 : int32 *, int32, int32);
172 :
173 :
174 : /*----------------------------------------------------------------------------|
175 : | BEGIN_PROLOG |
176 : | |
177 : | FUNCTION: SWopen |
178 : | |
179 : | DESCRIPTION: |
180 : | |
181 : | |
182 : | Return Value Type Units Description |
183 : | ============ ====== ========= ===================================== |
184 : | fid int32 HDF-EOS file ID |
185 : | |
186 : | INPUTS: |
187 : | filename char Filename |
188 : | access intn HDF access code |
189 : | |
190 : | |
191 : | OUTPUTS: |
192 : | None |
193 : | |
194 : | NOTES: |
195 : | |
196 : | |
197 : | Date Programmer Description |
198 : | ====== ============ ================================================= |
199 : | Jun 96 Joel Gales Original Programmer |
200 : | |
201 : | END_PROLOG |
202 : -----------------------------------------------------------------------------*/
203 : int32
204 4 : SWopen(const char *filename, intn i_access)
205 :
206 : {
207 : int32 fid /* HDF-EOS file ID */ ;
208 :
209 : /* Call EHopen to perform file access */
210 : /* ---------------------------------- */
211 4 : fid = EHopen(filename, i_access);
212 :
213 4 : return (fid);
214 : }
215 :
216 : /*----------------------------------------------------------------------------|
217 : | BEGIN_PROLOG |
218 : | |
219 : | FUNCTION: SWcreate |
220 : | |
221 : | DESCRIPTION: Creates a new swath structure and returns swath ID |
222 : | |
223 : | |
224 : | Return Value Type Units Description |
225 : | ============ ====== ========= ===================================== |
226 : | swathID int32 Swath structure ID |
227 : | |
228 : | INPUTS: |
229 : | fid int32 File ID |
230 : | swathname char Swath structure name |
231 : | |
232 : | OUTPUTS: |
233 : | None |
234 : | |
235 : | NOTES: |
236 : | |
237 : | |
238 : | Date Programmer Description |
239 : | ====== ============ ================================================= |
240 : | Jun 96 Joel Gales Original Programmer |
241 : | Aug 96 Joel Gales Make metadata ODL compliant |
242 : | Sep 96 Joel Gales Check swath name for length |
243 : | Mar 97 Joel Gales Enlarge utlbuf to 512 |
244 : | |
245 : | END_PROLOG |
246 : -----------------------------------------------------------------------------*/
247 : int32
248 0 : SWcreate(int32 fid, const char *swathname)
249 : {
250 : intn i; /* Loop index */
251 0 : intn nswathopen = 0; /* # of swath structures open */
252 0 : intn status = 0; /* routine return status variable */
253 :
254 : uint8 l_access; /* Read/Write file access code */
255 :
256 : int32 HDFfid; /* HDF file id */
257 : int32 vgRef; /* Vgroup reference number */
258 : int32 vgid[4]; /* Vgroup ID array */
259 0 : int32 swathID = -1; /* HDF-EOS swath ID */
260 :
261 : int32 sdInterfaceID; /* HDF SDS interface ID */
262 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
263 0 : int32 nSwath = 0; /* Swath counter */
264 :
265 : char name[80]; /* Vgroup name */
266 : char class[80]; /* Vgroup class */
267 : char errbuf[256];/* Buffer for error message */
268 : char utlbuf[512];/* Utility buffer */
269 : char utlbuf2[32];/* Utility buffer 2 */
270 :
271 : /*
272 : * Check HDF-EOS file ID, get back HDF file ID, SD interface ID and
273 : * access code
274 : */
275 0 : status = EHchkfid(fid, swathname, &HDFfid, &sdInterfaceID, &l_access);
276 :
277 :
278 : /* Check swathname for length */
279 : /* -------------------------- */
280 0 : if ((intn) strlen(swathname) > VGNAMELENMAX)
281 : {
282 0 : status = -1;
283 0 : HEpush(DFE_GENAPP, "SWcreate", __FILE__, __LINE__);
284 0 : HEreport("Swathname \"%s\" must be less than %d characters.\n",
285 : swathname, VGNAMELENMAX);
286 : }
287 :
288 :
289 0 : if (status == 0)
290 : {
291 :
292 : /* Determine number of swaths currently opened */
293 : /* ------------------------------------------- */
294 0 : for (i = 0; i < NSWATH; i++)
295 : {
296 0 : nswathopen += SWXSwath[i].active;
297 : }
298 :
299 :
300 : /* Setup file interface */
301 : /* -------------------- */
302 0 : if (nswathopen < NSWATH)
303 : {
304 :
305 : /* Check that swath has not been previously opened */
306 : /* ----------------------------------------------- */
307 0 : vgRef = -1;
308 :
309 : while (1)
310 : {
311 0 : vgRef = Vgetid(HDFfid, vgRef);
312 :
313 : /* If no more Vgroups then exist while loop */
314 : /* ---------------------------------------- */
315 0 : if (vgRef == -1)
316 : {
317 0 : break;
318 : }
319 :
320 : /* Get name and class of Vgroup */
321 : /* ---------------------------- */
322 0 : vgid[0] = Vattach(HDFfid, vgRef, "r");
323 0 : Vgetname(vgid[0], name);
324 0 : Vgetclass(vgid[0], class);
325 0 : Vdetach(vgid[0]);
326 :
327 : /* If SWATH then increment # swath counter */
328 : /* --------------------------------------- */
329 0 : if (strcmp(class, "SWATH") == 0)
330 : {
331 0 : nSwath++;
332 : }
333 :
334 : /* If swath already exist, return error */
335 : /* ------------------------------------ */
336 0 : if (strcmp(name, swathname) == 0 &&
337 0 : strcmp(class, "SWATH") == 0)
338 : {
339 0 : status = -1;
340 0 : HEpush(DFE_GENAPP, "SWcreate", __FILE__, __LINE__);
341 0 : HEreport("\"%s\" already exists.\n", swathname);
342 0 : break;
343 : }
344 : }
345 :
346 :
347 0 : if (status == 0)
348 : {
349 :
350 : /* Create Root Vgroup for Swath */
351 : /* ---------------------------- */
352 0 : vgid[0] = Vattach(HDFfid, -1, "w");
353 :
354 :
355 : /* Set Name and Class (SWATH) */
356 : /* -------------------------- */
357 0 : Vsetname(vgid[0], swathname);
358 0 : Vsetclass(vgid[0], "SWATH");
359 :
360 :
361 :
362 : /* Create Geolocation Fields Vgroup */
363 : /* -------------------------------- */
364 0 : vgid[1] = Vattach(HDFfid, -1, "w");
365 0 : Vsetname(vgid[1], "Geolocation Fields");
366 0 : Vsetclass(vgid[1], "SWATH Vgroup");
367 0 : Vinsert(vgid[0], vgid[1]);
368 :
369 :
370 :
371 : /* Create Data Fields Vgroup */
372 : /* ------------------------- */
373 0 : vgid[2] = Vattach(HDFfid, -1, "w");
374 0 : Vsetname(vgid[2], "Data Fields");
375 0 : Vsetclass(vgid[2], "SWATH Vgroup");
376 0 : Vinsert(vgid[0], vgid[2]);
377 :
378 :
379 :
380 : /* Create Attributes Vgroup */
381 : /* ------------------------ */
382 0 : vgid[3] = Vattach(HDFfid, -1, "w");
383 0 : Vsetname(vgid[3], "Swath Attributes");
384 0 : Vsetclass(vgid[3], "SWATH Vgroup");
385 0 : Vinsert(vgid[0], vgid[3]);
386 :
387 :
388 :
389 : /* Establish Swath in Structural MetaData Block */
390 : /* -------------------------------------------- */
391 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%ld%s%s%s",
392 0 : "\tGROUP=SWATH_", (long)nSwath + 1,
393 : "\n\t\tSwathName=\"", swathname, "\"\n");
394 :
395 0 : strcat(utlbuf, "\t\tGROUP=Dimension\n");
396 0 : strcat(utlbuf, "\t\tEND_GROUP=Dimension\n");
397 0 : strcat(utlbuf, "\t\tGROUP=DimensionMap\n");
398 0 : strcat(utlbuf, "\t\tEND_GROUP=DimensionMap\n");
399 0 : strcat(utlbuf, "\t\tGROUP=IndexDimensionMap\n");
400 0 : strcat(utlbuf, "\t\tEND_GROUP=IndexDimensionMap\n");
401 0 : strcat(utlbuf, "\t\tGROUP=GeoField\n");
402 0 : strcat(utlbuf, "\t\tEND_GROUP=GeoField\n");
403 0 : strcat(utlbuf, "\t\tGROUP=DataField\n");
404 0 : strcat(utlbuf, "\t\tEND_GROUP=DataField\n");
405 0 : strcat(utlbuf, "\t\tGROUP=MergedFields\n");
406 0 : strcat(utlbuf, "\t\tEND_GROUP=MergedFields\n");
407 0 : CPLsnprintf(utlbuf2, sizeof(utlbuf2), "%s%ld%s",
408 0 : "\tEND_GROUP=SWATH_", (long)nSwath + 1, "\n");
409 0 : strcat(utlbuf, utlbuf2);
410 :
411 :
412 0 : status = EHinsertmeta(sdInterfaceID, "", "s", 1001L,
413 : utlbuf, NULL);
414 : }
415 : }
416 : else
417 : {
418 : /* Too many files opened */
419 : /* --------------------- */
420 0 : status = -1;
421 0 : strcpy(errbuf,
422 : "No more than %d swaths may be open simultaneously");
423 0 : strcat(errbuf, " (%s)");
424 0 : HEpush(DFE_DENIED, "SWcreate", __FILE__, __LINE__);
425 0 : HEreport(errbuf, NSWATH, swathname);
426 : }
427 :
428 :
429 : /* Assign swathID # & Load swath and SWXSwath table entries */
430 : /* -------------------------------------------------------- */
431 0 : if (status == 0)
432 : {
433 :
434 0 : for (i = 0; i < NSWATH; i++)
435 : {
436 0 : if (SWXSwath[i].active == 0)
437 : {
438 : /*
439 : * Set swathID, Set swath entry active, Store root Vgroup
440 : * ID, Store sub Vgroup IDs, Store HDF-EOS file ID
441 : */
442 0 : swathID = i + idOffset;
443 0 : SWXSwath[i].active = 1;
444 0 : SWXSwath[i].IDTable = vgid[0];
445 0 : SWXSwath[i].VIDTable[0] = vgid[1];
446 0 : SWXSwath[i].VIDTable[1] = vgid[2];
447 0 : SWXSwath[i].VIDTable[2] = vgid[3];
448 0 : SWXSwath[i].fid = fid;
449 0 : status = 0;
450 0 : break;
451 : }
452 : }
453 :
454 : }
455 : }
456 0 : return (swathID);
457 : }
458 :
459 :
460 : /*----------------------------------------------------------------------------|
461 : | BEGIN_PROLOG |
462 : | |
463 : | FUNCTION: SWattach |
464 : | |
465 : | DESCRIPTION: Attaches to an existing swath within the file. |
466 : | |
467 : | |
468 : | Return Value Type Units Description |
469 : | ============ ====== ========= ===================================== |
470 : | swathID int32 swath structure ID |
471 : | |
472 : | INPUTS: |
473 : | fid int32 HDF-EOS file ID |
474 : | swathname char swath structure name |
475 : | |
476 : | OUTPUTS: |
477 : | None |
478 : | |
479 : | NOTES: |
480 : | |
481 : | |
482 : | Date Programmer Description |
483 : | ====== ============ ================================================= |
484 : | Jun 96 Joel Gales Original Programmer |
485 : | Apr 99 David Wynne Modified test for memory allocation check when no |
486 : | SDSs are in the Swath, NCR22513 |
487 : | |
488 : | END_PROLOG |
489 : -----------------------------------------------------------------------------*/
490 : int32
491 0 : SWattach(int32 fid, const char *swathname)
492 :
493 : {
494 : intn i; /* Loop index */
495 : intn j; /* Loop index */
496 0 : intn nswathopen = 0; /* # of swath structures open */
497 : intn status; /* routine return status variable */
498 :
499 : uint8 acs; /* Read/Write file access code */
500 :
501 : int32 HDFfid; /* HDF file id */
502 : int32 vgRef; /* Vgroup reference number */
503 : int32 vgid[4]; /* Vgroup ID array */
504 0 : int32 swathID = -1; /* HDF-EOS swath ID */
505 : int32 *tags; /* Pnt to Vgroup object tags array */
506 : int32 *refs; /* Pnt to Vgroup object refs array */
507 : int32 dum; /* dummy variable */
508 : int32 sdInterfaceID; /* HDF SDS interface ID */
509 : int32 nObjects; /* # of objects in Vgroup */
510 : int32 nSDS; /* SDS counter */
511 : int32 l_index; /* SDS l_index */
512 : int32 sdid; /* SDS object ID */
513 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
514 :
515 : char name[80]; /* Vgroup name */
516 : char class[80]; /* Vgroup class */
517 : char errbuf[256];/* Buffer for error message */
518 : char acsCode[1]; /* Read/Write access char: "r/w" */
519 :
520 :
521 : /* Check HDF-EOS file ID, get back HDF file ID and access code */
522 : /* ----------------------------------------------------------- */
523 0 : status = EHchkfid(fid, swathname, &HDFfid, &dum, &acs);
524 :
525 :
526 0 : if (status == 0)
527 : {
528 : /* Convert numeric access code to character */
529 : /* ---------------------------------------- */
530 0 : acsCode[0] = (acs == 1) ? 'w' : 'r';
531 :
532 : /* Determine number of swaths currently opened */
533 : /* ------------------------------------------- */
534 0 : for (i = 0; i < NSWATH; i++)
535 : {
536 0 : nswathopen += SWXSwath[i].active;
537 : }
538 :
539 : /* If room for more ... */
540 : /* -------------------- */
541 0 : if (nswathopen < NSWATH)
542 : {
543 :
544 : /* Search Vgroups for Swath */
545 : /* ------------------------ */
546 0 : vgRef = -1;
547 :
548 : while (1)
549 : {
550 0 : vgRef = Vgetid(HDFfid, vgRef);
551 :
552 :
553 : /* If no more Vgroups then exist while loop */
554 : /* ---------------------------------------- */
555 0 : if (vgRef == -1)
556 : {
557 0 : break;
558 : }
559 :
560 : /* Get name and class of Vgroup */
561 : /* ---------------------------- */
562 0 : vgid[0] = Vattach(HDFfid, vgRef, "r");
563 0 : Vgetname(vgid[0], name);
564 0 : Vgetclass(vgid[0], class);
565 :
566 :
567 : /*
568 : * If Vgroup with swathname and class SWATH found, load
569 : * tables
570 : */
571 :
572 0 : if (strcmp(name, swathname) == 0 &&
573 0 : strcmp(class, "SWATH") == 0)
574 : {
575 : /* Attach to "Fields" and "Swath Attributes" Vgroups */
576 : /* ------------------------------------------------- */
577 0 : tags = (int32 *) malloc(sizeof(int32) * 3);
578 0 : if(tags == NULL)
579 : {
580 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
581 0 : return(-1);
582 : }
583 0 : refs = (int32 *) malloc(sizeof(int32) * 3);
584 0 : if(refs == NULL)
585 : {
586 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
587 0 : free(tags);
588 0 : return(-1);
589 : }
590 0 : Vgettagrefs(vgid[0], tags, refs, 3);
591 0 : vgid[1] = Vattach(HDFfid, refs[0], acsCode);
592 0 : vgid[2] = Vattach(HDFfid, refs[1], acsCode);
593 0 : vgid[3] = Vattach(HDFfid, refs[2], acsCode);
594 0 : free(tags);
595 0 : free(refs);
596 :
597 : /* Setup External Arrays */
598 : /* --------------------- */
599 0 : for (i = 0; i < NSWATH; i++)
600 : {
601 : /* Find empty entry in array */
602 : /* ------------------------- */
603 0 : if (SWXSwath[i].active == 0)
604 : {
605 : /*
606 : * Set swathID, Set swath entry active, Store
607 : * root Vgroup ID, Store sub Vgroup IDs, Store
608 : * HDF-EOS file ID
609 : */
610 0 : swathID = i + idOffset;
611 0 : SWXSwath[i].active = 1;
612 0 : SWXSwath[i].IDTable = vgid[0];
613 0 : SWXSwath[i].VIDTable[0] = vgid[1];
614 0 : SWXSwath[i].VIDTable[1] = vgid[2];
615 0 : SWXSwath[i].VIDTable[2] = vgid[3];
616 0 : SWXSwath[i].fid = fid;
617 0 : break;
618 : }
619 : }
620 :
621 : /* Get SDS interface ID */
622 : /* -------------------- */
623 0 : status = SWchkswid(swathID, "SWattach", &dum,
624 : &sdInterfaceID, &dum);
625 :
626 :
627 : /* Access swath "Geolocation" SDS */
628 : /* ------------------------------ */
629 :
630 : /* Get # of entries within this Vgroup & search for SDS */
631 : /* ---------------------------------------------------- */
632 0 : nObjects = Vntagrefs(vgid[1]);
633 :
634 0 : if (nObjects > 0)
635 : {
636 : /* Get tag and ref # for Geolocation Vgroup objects */
637 : /* ------------------------------------------------ */
638 0 : tags = (int32 *) malloc(sizeof(int32) * nObjects);
639 0 : if(tags == NULL)
640 : {
641 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
642 0 : return(-1);
643 : }
644 0 : refs = (int32 *) malloc(sizeof(int32) * nObjects);
645 0 : if(refs == NULL)
646 : {
647 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
648 0 : free(tags);
649 0 : return(-1);
650 : }
651 0 : Vgettagrefs(vgid[1], tags, refs, nObjects);
652 :
653 : /* Count number of SDS & allocate SDS ID array */
654 : /* ------------------------------------------- */
655 0 : nSDS = 0;
656 0 : for (j = 0; j < nObjects; j++)
657 : {
658 0 : if (tags[j] == DFTAG_NDG)
659 : {
660 0 : nSDS++;
661 : }
662 : }
663 0 : SWXSwath[i].sdsID = (int32 *) calloc(nSDS, 4);
664 0 : if(SWXSwath[i].sdsID == NULL && nSDS != 0)
665 : {
666 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
667 0 : free(tags);
668 0 : free(refs);
669 0 : return(-1);
670 : }
671 0 : nSDS = 0;
672 :
673 :
674 : /* Fill SDS ID array */
675 : /* ----------------- */
676 0 : for (j = 0; j < nObjects; j++)
677 : {
678 : /* If object is SDS then get id */
679 : /* ---------------------------- */
680 0 : if (tags[j] == DFTAG_NDG)
681 : {
682 0 : l_index = SDreftoindex(sdInterfaceID, refs[j]);
683 0 : sdid = SDselect(sdInterfaceID, l_index);
684 0 : SWXSwath[i].sdsID[nSDS] = sdid;
685 0 : nSDS++;
686 0 : SWXSwath[i].nSDS++;
687 : }
688 : }
689 0 : free(tags);
690 0 : free(refs);
691 : }
692 :
693 : /* Access swath "Data" SDS */
694 : /* ----------------------- */
695 :
696 : /* Get # of entries within this Vgroup & search for SDS */
697 : /* ---------------------------------------------------- */
698 0 : nObjects = Vntagrefs(vgid[2]);
699 :
700 0 : if (nObjects > 0)
701 : {
702 : /* Get tag and ref # for Data Vgroup objects */
703 : /* ----------------------------------------- */
704 0 : tags = (int32 *) malloc(sizeof(int32) * nObjects);
705 0 : if(tags == NULL)
706 : {
707 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
708 0 : return(-1);
709 : }
710 0 : refs = (int32 *) malloc(sizeof(int32) * nObjects);
711 0 : if(refs == NULL)
712 : {
713 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
714 0 : free(tags);
715 0 : return(-1);
716 : }
717 0 : Vgettagrefs(vgid[2], tags, refs, nObjects);
718 :
719 :
720 : /* Count number of SDS & allocate SDS ID array */
721 : /* ------------------------------------------- */
722 0 : nSDS = 0;
723 0 : for (j = 0; j < nObjects; j++)
724 : {
725 0 : if (tags[j] == DFTAG_NDG)
726 : {
727 0 : nSDS++;
728 : }
729 : }
730 0 : SWXSwath[i].sdsID = (int32 *)
731 0 : realloc((void *) SWXSwath[i].sdsID,
732 0 : (SWXSwath[i].nSDS + nSDS) * 4);
733 0 : if(SWXSwath[i].sdsID == NULL && nSDS != 0)
734 : {
735 0 : HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__);
736 0 : return(-1);
737 : }
738 :
739 : /* Fill SDS ID array */
740 : /* ----------------- */
741 0 : for (j = 0; j < nObjects; j++)
742 : {
743 : /* If object is SDS then get id */
744 : /* ---------------------------- */
745 0 : if (tags[j] == DFTAG_NDG)
746 : {
747 0 : l_index = SDreftoindex(sdInterfaceID, refs[j]);
748 0 : sdid = SDselect(sdInterfaceID, l_index);
749 0 : SWXSwath[i].sdsID[SWXSwath[i].nSDS] = sdid;
750 0 : SWXSwath[i].nSDS++;
751 : }
752 : }
753 0 : free(tags);
754 0 : free(refs);
755 : }
756 0 : break;
757 : }
758 :
759 : /* Detach Vgroup if not desired Swath */
760 : /* ---------------------------------- */
761 0 : Vdetach(vgid[0]);
762 : }
763 :
764 : /* If Swath not found then set up error message */
765 : /* -------------------------------------------- */
766 0 : if (swathID == -1)
767 : {
768 0 : HEpush(DFE_RANGE, "SWattach", __FILE__, __LINE__);
769 0 : HEreport("Swath: \"%s\" does not exist within HDF file.\n",
770 : swathname);
771 : }
772 : }
773 : else
774 : {
775 : /* Too many files opened */
776 : /* --------------------- */
777 0 : swathID = -1;
778 0 : strcpy(errbuf,
779 : "No more than %d swaths may be open simultaneously");
780 0 : strcat(errbuf, " (%s)");
781 0 : HEpush(DFE_DENIED, "SWattach", __FILE__, __LINE__);
782 0 : HEreport(errbuf, NSWATH, swathname);
783 : }
784 :
785 : }
786 0 : return (swathID);
787 : }
788 :
789 : /*----------------------------------------------------------------------------|
790 : | BEGIN_PROLOG |
791 : | |
792 : | FUNCTION: SWchkswid |
793 : | |
794 : | DESCRIPTION: Checks for valid swathID and returns file ID, SDS ID, and |
795 : | swath Vgroup ID |
796 : | |
797 : | |
798 : | Return Value Type Units Description |
799 : | ============ ====== ========= ===================================== |
800 : | status intn return status (0) SUCCEED, (-1) FAIL |
801 : | |
802 : | INPUTS: |
803 : | swathID int32 swath structure ID |
804 : | routname char Name of routine calling SWchkswid |
805 : | |
806 : | OUTPUTS: |
807 : | fid int32 File ID |
808 : | sdInterfaceID int32 SDS interface ID |
809 : | swVgrpID int32 swath Vgroup ID |
810 : | |
811 : | NOTES: |
812 : | |
813 : | |
814 : | Date Programmer Description |
815 : | ====== ============ ================================================= |
816 : | Jun 96 Joel Gales Original Programmer |
817 : | |
818 : | END_PROLOG |
819 : -----------------------------------------------------------------------------*/
820 : static intn
821 0 : SWchkswid(int32 swathID, const char *routname,
822 : int32 * fid, int32 * sdInterfaceID, int32 * swVgrpID)
823 :
824 : {
825 0 : intn status = 0; /* routine return status variable */
826 : uint8 l_access; /* Read/Write access code */
827 :
828 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
829 :
830 0 : char message1[] =
831 : "Invalid swath id: %d in routine \"%s\". ID must be >= %d and < %d.\n";
832 0 : char message2[] =
833 : "Swath id %d in routine \"%s\" not active.\n";
834 :
835 :
836 : /* Check for valid swath id */
837 : /* ------------------------ */
838 0 : if (swathID < idOffset || swathID >= NSWATH + idOffset)
839 : {
840 0 : status = -1;
841 0 : HEpush(DFE_RANGE, "SWchkswid", __FILE__, __LINE__);
842 0 : HEreport(message1, swathID, routname, idOffset, NSWATH + idOffset);
843 : }
844 : else
845 : {
846 : /* Check for active swath ID */
847 : /* ------------------------- */
848 0 : if (SWXSwath[swathID % idOffset].active == 0)
849 : {
850 0 : status = -1;
851 0 : HEpush(DFE_GENAPP, "SWchkswid", __FILE__, __LINE__);
852 0 : HEreport(message2, swathID, routname);
853 : }
854 : else
855 : {
856 :
857 : /* Get file & SDS ids and Swath Vgroup */
858 : /* ----------------------------------- */
859 0 : status = EHchkfid(SWXSwath[swathID % idOffset].fid, " ", fid,
860 : sdInterfaceID, &l_access);
861 0 : *swVgrpID = SWXSwath[swathID % idOffset].IDTable;
862 : }
863 : }
864 0 : return (status);
865 : }
866 :
867 :
868 :
869 :
870 :
871 :
872 :
873 : /*----------------------------------------------------------------------------|
874 : | BEGIN_PROLOG |
875 : | |
876 : | FUNCTION: SWdefdim |
877 : | |
878 : | DESCRIPTION: Defines numerical value of dimension |
879 : | |
880 : | |
881 : | Return Value Type Units Description |
882 : | ============ ====== ========= ===================================== |
883 : | status intn return status (0) SUCCEED, (-1) FAIL |
884 : | |
885 : | INPUTS: |
886 : | swathID int32 swath structure ID |
887 : | dimname char Dimension name to define |
888 : | dim int32 Dimension value |
889 : | |
890 : | OUTPUTS: |
891 : | None |
892 : | |
893 : | NOTES: |
894 : | |
895 : | |
896 : | Date Programmer Description |
897 : | ====== ============ ================================================= |
898 : | Jun 96 Joel Gales Original Programmer |
899 : | Dec 96 Joel Gales Check that dim value >= 0 |
900 : | |
901 : | END_PROLOG |
902 : -----------------------------------------------------------------------------*/
903 : intn
904 0 : SWdefdim(int32 swathID, char *dimname, int32 dim)
905 :
906 : {
907 : intn status; /* routine return status variable */
908 :
909 : int32 fid; /* HDF-EOS file id */
910 : int32 sdInterfaceID; /* HDF SDS interface ID */
911 : int32 swVgrpID; /* Swath root Vgroup ID */
912 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
913 :
914 : char swathname[80] /* Swath name */ ;
915 :
916 :
917 : /* Check for valid swath id */
918 : /* ------------------------ */
919 0 : status = SWchkswid(swathID, "SWdefdim", &fid, &sdInterfaceID, &swVgrpID);
920 :
921 :
922 : /* Make sure dimension >= 0 */
923 : /* ------------------------ */
924 0 : if (dim < 0)
925 : {
926 0 : status = -1;
927 0 : HEpush(DFE_GENAPP, "SWdefdim", __FILE__, __LINE__);
928 0 : HEreport("Dimension value for \"%s\" less than zero: %d.\n",
929 : dimname, dim);
930 : }
931 :
932 :
933 : /* Write Dimension to Structural MetaData */
934 : /* -------------------------------------- */
935 0 : if (status == 0)
936 : {
937 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
938 0 : status = EHinsertmeta(sdInterfaceID, swathname, "s", 0L,
939 : dimname, &dim);
940 : }
941 0 : return (status);
942 : }
943 :
944 :
945 :
946 : /*----------------------------------------------------------------------------|
947 : | BEGIN_PROLOG |
948 : | |
949 : | FUNCTION: SWdiminfo |
950 : | |
951 : | DESCRIPTION: Returns size in bytes of named dimension |
952 : | |
953 : | |
954 : | Return Value Type Units Description |
955 : | ============ ====== ========= ===================================== |
956 : | size int32 Size of dimension |
957 : | |
958 : | INPUTS: |
959 : | swathID int32 swath structure id |
960 : | dimname char Dimension name |
961 : | |
962 : | |
963 : | OUTPUTS: |
964 : | None |
965 : | |
966 : | NOTES: |
967 : | |
968 : | |
969 : | Date Programmer Description |
970 : | ====== ============ ================================================= |
971 : | Jun 96 Joel Gales Original Programmer |
972 : | Aug 96 Joel Gales Make metadata ODL compliant |
973 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
974 : | |
975 : | END_PROLOG |
976 : -----------------------------------------------------------------------------*/
977 : int32
978 0 : SWdiminfo(int32 swathID, const char *dimname)
979 :
980 : {
981 : intn status; /* routine return status variable */
982 :
983 : int32 fid; /* HDF-EOS file ID */
984 : int32 sdInterfaceID; /* HDF SDS interface ID */
985 : int32 swVgrpID; /* Swath root Vgroup ID */
986 : int32 size; /* Dimension size */
987 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
988 :
989 :
990 : char *metabuf; /* Pointer to structural metadata (SM) */
991 : char *metaptrs[2];/* Pointers to begin and end of SM section */
992 : char swathname[80]; /* Swath Name */
993 : char *utlstr; /* Utility string */
994 :
995 :
996 : /* Allocate space for utility string */
997 : /* --------------------------------- */
998 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
999 0 : if(utlstr == NULL)
1000 : {
1001 0 : HEpush(DFE_NOSPACE,"SWdiminfo", __FILE__, __LINE__);
1002 0 : return(-1);
1003 : }
1004 : /* Initialize return value */
1005 0 : size = -1;
1006 :
1007 : /* Check Swath ID */
1008 0 : status = SWchkswid(swathID, "SWdiminfo", &fid, &sdInterfaceID, &swVgrpID);
1009 :
1010 0 : if (status == 0)
1011 : {
1012 : /* Get swath name */
1013 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
1014 :
1015 : /* Get pointers to "Dimension" section within SM */
1016 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
1017 : "Dimension", metaptrs);
1018 :
1019 0 : if(metabuf == NULL)
1020 : {
1021 0 : free(utlstr);
1022 0 : return(-1);
1023 : }
1024 :
1025 : /* Search for dimension name (surrounded by quotes) */
1026 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", dimname, "\"\n");
1027 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1028 :
1029 : /*
1030 : * If dimension found within swath structure then get dimension value
1031 : */
1032 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1033 : {
1034 : /* Set endptr at end of dimension definition entry */
1035 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
1036 :
1037 0 : status = EHgetmetavalue(metaptrs, "Size", utlstr);
1038 :
1039 0 : if (status == 0)
1040 : {
1041 0 : size = atoi(utlstr);
1042 : }
1043 : else
1044 : {
1045 0 : HEpush(DFE_GENAPP, "SWdiminfo", __FILE__, __LINE__);
1046 0 : HEreport("\"Size\" string not found in metadata.\n");
1047 : }
1048 : }
1049 : else
1050 : {
1051 0 : HEpush(DFE_GENAPP, "SWdiminfo", __FILE__, __LINE__);
1052 0 : HEreport("Dimension \"%s\" not found.\n", dimname);
1053 : }
1054 :
1055 0 : free(metabuf);
1056 : }
1057 0 : free(utlstr);
1058 :
1059 0 : return (size);
1060 : }
1061 :
1062 :
1063 :
1064 :
1065 : /*----------------------------------------------------------------------------|
1066 : | BEGIN_PROLOG |
1067 : | |
1068 : | FUNCTION: SWmapinfo |
1069 : | |
1070 : | DESCRIPTION: Returns dimension mapping information |
1071 : | |
1072 : | |
1073 : | Return Value Type Units Description |
1074 : | ============ ====== ========= ===================================== |
1075 : | status intn return status (0) SUCCEED, (-1) FAIL |
1076 : | |
1077 : | INPUTS: |
1078 : | swathID int32 swath structure id |
1079 : | geodim char geolocation dimension name |
1080 : | datadim char data dimension name |
1081 : | |
1082 : | OUTPUTS: |
1083 : | offset int32 mapping offset |
1084 : | increment int32 mapping increment |
1085 : | |
1086 : | NOTES: |
1087 : | |
1088 : | |
1089 : | Date Programmer Description |
1090 : | ====== ============ ================================================= |
1091 : | Jun 96 Joel Gales Original Programmer |
1092 : | Aug 96 Joel Gales Make metadata ODL compliant |
1093 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1094 : | |
1095 : | END_PROLOG |
1096 : -----------------------------------------------------------------------------*/
1097 : intn
1098 0 : SWmapinfo(int32 swathID, const char *geodim, const char *datadim, int32 * offset,
1099 : int32 * increment)
1100 :
1101 : {
1102 : intn status; /* routine return status variable */
1103 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1104 :
1105 : int32 fid; /* HDF-EOS file ID */
1106 : int32 sdInterfaceID; /* HDF SDS interface ID */
1107 : int32 swVgrpID; /* Swath root Vgroup ID */
1108 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1109 :
1110 : char *metabuf; /* Pointer to structural metadata (SM) */
1111 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1112 : char swathname[80]; /* Swath Name */
1113 : char *utlstr; /* Utility string */
1114 :
1115 :
1116 : /* Allocate space for utility string */
1117 : /* --------------------------------- */
1118 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1119 0 : if(utlstr == NULL)
1120 : {
1121 0 : HEpush(DFE_NOSPACE,"SWmapinfo", __FILE__, __LINE__);
1122 0 : return(-1);
1123 : }
1124 : /* Initialize return values */
1125 0 : *offset = -1;
1126 0 : *increment = -1;
1127 :
1128 : /* Check Swath ID */
1129 0 : status = SWchkswid(swathID, "SWmapinfo", &fid, &sdInterfaceID, &swVgrpID);
1130 :
1131 0 : if (status == 0)
1132 : {
1133 : /* Get swath name */
1134 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
1135 :
1136 : /* Get pointers to "DimensionMap" section within SM */
1137 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
1138 : "DimensionMap", metaptrs);
1139 0 : if(metabuf == NULL)
1140 : {
1141 0 : free(utlstr);
1142 0 : return(-1);
1143 : }
1144 :
1145 : /* Search for mapping - GeoDim/DataDim (surrounded by quotes) */
1146 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s%s%s", "\t\t\t\tGeoDimension=\"", geodim,
1147 : "\"\n\t\t\t\tDataDimension=\"", datadim, "\"\n");
1148 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1149 :
1150 : /*
1151 : * If mapping found within swath structure then get offset and
1152 : * increment value
1153 : */
1154 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1155 : {
1156 : /* Get Offset */
1157 0 : statmeta = EHgetmetavalue(metaptrs, "Offset", utlstr);
1158 0 : if (statmeta == 0)
1159 : {
1160 0 : *offset = atoi(utlstr);
1161 : }
1162 : else
1163 : {
1164 0 : status = -1;
1165 0 : HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__);
1166 0 : HEreport("\"Offset\" string not found in metadata.\n");
1167 : }
1168 :
1169 :
1170 : /* Get Increment */
1171 0 : statmeta = EHgetmetavalue(metaptrs, "Increment", utlstr);
1172 0 : if (statmeta == 0)
1173 : {
1174 0 : *increment = atoi(utlstr);
1175 : }
1176 : else
1177 : {
1178 0 : status = -1;
1179 0 : HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__);
1180 0 : HEreport("\"Increment\" string not found in metadata.\n");
1181 : }
1182 : }
1183 : else
1184 : {
1185 0 : status = -1;
1186 0 : HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__);
1187 0 : HEreport("Mapping \"%s/%s\" not found.\n", geodim, datadim);
1188 : }
1189 :
1190 0 : free(metabuf);
1191 : }
1192 0 : free(utlstr);
1193 0 : return (status);
1194 : }
1195 :
1196 :
1197 :
1198 :
1199 : /*----------------------------------------------------------------------------|
1200 : | BEGIN_PROLOG |
1201 : | |
1202 : | FUNCTION: SWidxmapinfo |
1203 : | |
1204 : | DESCRIPTION: Returns l_indexed mapping information |
1205 : | |
1206 : | |
1207 : | Return Value Type Units Description |
1208 : | ============ ====== ========= ===================================== |
1209 : | gsize int32 Number of l_index values (sz of geo dim) |
1210 : | |
1211 : | INPUTS: |
1212 : | swathID int32 swath structure id |
1213 : | geodim char geolocation dimension name |
1214 : | datadim char data dimension name |
1215 : | |
1216 : | |
1217 : | OUTPUTS: |
1218 : | l_index int32 array of l_index values |
1219 : | |
1220 : | NOTES: |
1221 : | |
1222 : | |
1223 : | Date Programmer Description |
1224 : | ====== ============ ================================================= |
1225 : | Jun 96 Joel Gales Original Programmer |
1226 : | |
1227 : | END_PROLOG |
1228 : -----------------------------------------------------------------------------*/
1229 : int32
1230 0 : SWidxmapinfo(int32 swathID, const char *geodim, const char *datadim, int32 l_index[])
1231 : {
1232 : intn status; /* routine return status variable */
1233 :
1234 : int32 fid; /* HDF-EOS file ID */
1235 : int32 sdInterfaceID; /* HDF SDS interface ID */
1236 : int32 swVgrpID; /* Swath root Vgroup ID */
1237 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1238 : int32 vgid; /* Swath Attributes Vgroup ID */
1239 : int32 vdataID; /* Index Mapping Vdata ID */
1240 0 : int32 gsize = -1; /* Size of geo dim */
1241 :
1242 : char utlbuf[256];/* Utility buffer */
1243 :
1244 :
1245 : /* Check Swath ID */
1246 0 : status = SWchkswid(swathID, "SWidxmapinfo",
1247 : &fid, &sdInterfaceID, &swVgrpID);
1248 :
1249 0 : if (status == 0)
1250 : {
1251 : /* Find Index Mapping Vdata with Swath Attributes Vgroup */
1252 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%s%s%s", "INDXMAP:", geodim, "/", datadim);
1253 0 : vgid = SWXSwath[swathID % idOffset].VIDTable[2];
1254 0 : vdataID = EHgetid(fid, vgid, utlbuf, 1, "r");
1255 :
1256 : /* If found then get geodim size & read l_index mapping values */
1257 0 : if (vdataID != -1)
1258 : {
1259 0 : gsize = SWdiminfo(swathID, geodim);
1260 :
1261 0 : VSsetfields(vdataID, "Index");
1262 0 : VSread(vdataID, (uint8 *) l_index, 1, FULL_INTERLACE);
1263 0 : VSdetach(vdataID);
1264 : }
1265 : else
1266 : {
1267 : /*status = -1;*/
1268 0 : HEpush(DFE_GENAPP, "SWidxmapinfo", __FILE__, __LINE__);
1269 0 : HEreport("Index Mapping \"%s\" not found.\n", utlbuf);
1270 : }
1271 : }
1272 0 : return (gsize);
1273 : }
1274 :
1275 :
1276 :
1277 :
1278 : /*----------------------------------------------------------------------------|
1279 : | BEGIN_PROLOG |
1280 : | |
1281 : | FUNCTION: SWcompinfo |
1282 : | |
1283 : | DESCRIPTION: |
1284 : | |
1285 : | |
1286 : | Return Value Type Units Description |
1287 : | ============ ====== ========= ===================================== |
1288 : | status intn |
1289 : | |
1290 : | INPUTS: |
1291 : | swathID int32 |
1292 : | compcode int32 |
1293 : | compparm intn |
1294 : | |
1295 : | |
1296 : | OUTPUTS: |
1297 : | None |
1298 : | |
1299 : | NOTES: |
1300 : | |
1301 : | |
1302 : | Date Programmer Description |
1303 : | ====== ============ ================================================= |
1304 : | Oct 96 Joel Gales Original Programmer |
1305 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1306 : | |
1307 : | END_PROLOG |
1308 : -----------------------------------------------------------------------------*/
1309 : intn
1310 0 : SWcompinfo(int32 swathID, const char *fieldname, int32 * compcode, intn compparm[])
1311 : {
1312 : intn i; /* Loop Index */
1313 : intn status; /* routine return status variable */
1314 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1315 :
1316 : int32 fid; /* HDF-EOS file ID */
1317 : int32 sdInterfaceID; /* HDF SDS interface ID */
1318 : int32 swVgrpID; /* Swath root Vgroup ID */
1319 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1320 :
1321 : char *metabuf; /* Pointer to structural metadata (SM) */
1322 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1323 : char swathname[80]; /* Swath Name */
1324 : char *utlstr; /* Utility string */
1325 :
1326 0 : const char *HDFcomp[5] = {"HDFE_COMP_NONE", "HDFE_COMP_RLE",
1327 : "HDFE_COMP_NBIT", "HDFE_COMP_SKPHUFF",
1328 : "HDFE_COMP_DEFLATE"}; /* Compression Codes */
1329 :
1330 : /* Allocate space for utility string */
1331 : /* --------------------------------- */
1332 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1333 0 : if(utlstr == NULL)
1334 : {
1335 0 : HEpush(DFE_NOSPACE,"SWcompinfo", __FILE__, __LINE__);
1336 0 : return(-1);
1337 : }
1338 :
1339 : /* Check Swath ID */
1340 0 : status = SWchkswid(swathID, "SWcompinfo",
1341 : &fid, &sdInterfaceID, &swVgrpID);
1342 :
1343 0 : if (status == 0)
1344 : {
1345 : /* Get swath name */
1346 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
1347 :
1348 : /* Get pointers to "DataField" section within SM */
1349 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
1350 : "DataField", metaptrs);
1351 0 : if(metabuf == NULL)
1352 : {
1353 0 : free(utlstr);
1354 0 : return(-1);
1355 : }
1356 : /* Search for field */
1357 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
1358 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1359 :
1360 : /* If not found then search in "GeoField" section */
1361 0 : if (metaptrs[0] > metaptrs[1] || metaptrs[0] == NULL)
1362 : {
1363 0 : free(metabuf);
1364 :
1365 : /* Get pointers to "GeoField" section within SM */
1366 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
1367 : "GeoField", metaptrs);
1368 0 : if(metabuf == NULL)
1369 : {
1370 0 : free(utlstr);
1371 0 : return(-1);
1372 : }
1373 : /* Search for field */
1374 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
1375 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1376 : }
1377 :
1378 :
1379 : /* If field found and user wants compression code ... */
1380 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1381 : {
1382 0 : if (compcode != NULL)
1383 : {
1384 : /* Set endptr at end of field's definition entry */
1385 0 : metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT");
1386 :
1387 : /* Get compression type */
1388 0 : statmeta = EHgetmetavalue(metaptrs, "CompressionType", utlstr);
1389 :
1390 : /*
1391 : * Default is no compression if "CompressionType" string not
1392 : * in metadata
1393 : */
1394 0 : *compcode = HDFE_COMP_NONE;
1395 :
1396 : /* If compression code is found ... */
1397 0 : if (statmeta == 0)
1398 : {
1399 : /* Loop through compression types until match */
1400 0 : for (i = 0; i < 5; i++)
1401 : {
1402 0 : if (strcmp(utlstr, HDFcomp[i]) == 0)
1403 : {
1404 0 : *compcode = i;
1405 0 : break;
1406 : }
1407 : }
1408 : }
1409 : }
1410 :
1411 : /* If user wants compression parameters ... */
1412 0 : if (compparm != NULL && compcode != NULL)
1413 : {
1414 : /* Initialize to zero */
1415 0 : for (i = 0; i < 4; i++)
1416 : {
1417 0 : compparm[i] = 0;
1418 : }
1419 :
1420 : /*
1421 : * Get compression parameters if NBIT or DEFLATE compression
1422 : */
1423 0 : if (*compcode == HDFE_COMP_NBIT)
1424 : {
1425 : statmeta =
1426 0 : EHgetmetavalue(metaptrs, "CompressionParams", utlstr);
1427 0 : if (statmeta == 0)
1428 : {
1429 0 : sscanf(utlstr, "(%d,%d,%d,%d)",
1430 : &compparm[0], &compparm[1],
1431 : &compparm[2], &compparm[3]);
1432 : }
1433 : else
1434 : {
1435 0 : status = -1;
1436 0 : HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__);
1437 0 : HEreport(
1438 : "\"CompressionParams\" string not found in metadata.\n");
1439 : }
1440 : }
1441 0 : else if (*compcode == HDFE_COMP_DEFLATE)
1442 : {
1443 : statmeta =
1444 0 : EHgetmetavalue(metaptrs, "DeflateLevel", utlstr);
1445 0 : if (statmeta == 0)
1446 : {
1447 0 : sscanf(utlstr, "%d", &compparm[0]);
1448 : }
1449 : else
1450 : {
1451 0 : status = -1;
1452 0 : HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__);
1453 0 : HEreport(
1454 : "\"DeflateLevel\" string not found in metadata.\n");
1455 : }
1456 : }
1457 : }
1458 : }
1459 : else
1460 : {
1461 0 : HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__);
1462 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
1463 : }
1464 :
1465 0 : free(metabuf);
1466 : }
1467 0 : free(utlstr);
1468 :
1469 0 : return (status);
1470 : }
1471 :
1472 :
1473 :
1474 : /*----------------------------------------------------------------------------|
1475 : | BEGIN_PROLOG |
1476 : | |
1477 : | FUNCTION: SWfinfo |
1478 : | |
1479 : | DESCRIPTION: Returns field info |
1480 : | |
1481 : | |
1482 : | Return Value Type Units Description |
1483 : | ============ ====== ========= ===================================== |
1484 : | status intn return status (0) SUCCEED, (-1) FAIL |
1485 : | |
1486 : | INPUTS: |
1487 : | swathID int32 swath structure id |
1488 : | fieldtype const char fieldtype (geo or data) |
1489 : | fieldname const char name of field |
1490 : | |
1491 : | |
1492 : | OUTPUTS: |
1493 : | rank int32 rank of field (# of dims) |
1494 : | dims int32 field dimensions |
1495 : | numbertype int32 field number type |
1496 : | dimlist char field dimension list |
1497 : | |
1498 : | NOTES: |
1499 : | |
1500 : | |
1501 : | Date Programmer Description |
1502 : | ====== ============ ================================================= |
1503 : | Jun 96 Joel Gales Original Programmer |
1504 : | Aug 96 Joel Gales Make metadata ODL compliant |
1505 : | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue |
1506 : | |
1507 : | END_PROLOG |
1508 : -----------------------------------------------------------------------------*/
1509 : static int32
1510 0 : SWfinfo(int32 swathID, const char *fieldtype, const char *fieldname,
1511 : int32 *rank, int32 dims[], int32 *numbertype, char *dimlist)
1512 :
1513 : {
1514 : intn i; /* Loop index */
1515 : intn j; /* Loop index */
1516 : intn status; /* routine return status variable */
1517 0 : intn statmeta = 0; /* EHgetmetavalue return status */
1518 :
1519 : int32 fid; /* HDF-EOS file ID */
1520 : int32 sdInterfaceID; /* HDF SDS interface ID */
1521 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1522 : int32 fsize; /* field size in bytes */
1523 0 : int32 ndims = 0; /* Number of dimensions */
1524 : int32 slen[8]; /* Length of each entry in parsed string */
1525 : int32 dum; /* Dummy variable */
1526 : int32 vdataID; /* 1d field vdata ID */
1527 :
1528 : uint8 *buf; /* One-Dim field buffer */
1529 :
1530 : char *metabuf; /* Pointer to structural metadata (SM) */
1531 : char *metaptrs[2];/* Pointers to begin and end of SM section */
1532 : char swathname[80]; /* Swath Name */
1533 : char *utlstr; /* Utility string */
1534 : char *ptr[8]; /* String pointers for parsed string */
1535 : char dimstr[64]; /* Individual dimension entry string */
1536 :
1537 :
1538 : /* Allocate space for utility string */
1539 : /* --------------------------------- */
1540 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
1541 0 : if(utlstr == NULL)
1542 : {
1543 0 : HEpush(DFE_NOSPACE,"SWfinfo", __FILE__, __LINE__);
1544 0 : return(-1);
1545 : }
1546 :
1547 : /* Initialize rank and numbertype to -1 (error) */
1548 : /* -------------------------------------------- */
1549 0 : *rank = -1;
1550 0 : *numbertype = -1;
1551 :
1552 : /* Get HDF-EOS file ID and SDS interface ID */
1553 0 : status = SWchkswid(swathID, "SWfinfo", &fid, &sdInterfaceID, &dum);
1554 :
1555 : /* Get swath name */
1556 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
1557 :
1558 : /* Get pointers to appropriate "Field" section within SM */
1559 0 : if (strcmp(fieldtype, "Geolocation Fields") == 0)
1560 : {
1561 0 : metabuf = EHmetagroup(sdInterfaceID, swathname, "s",
1562 : "GeoField", metaptrs);
1563 :
1564 0 : if(metabuf == NULL)
1565 : {
1566 0 : free(utlstr);
1567 0 : return(-1);
1568 : }
1569 : }
1570 : else
1571 : {
1572 0 : metabuf = EHmetagroup(sdInterfaceID, swathname, "s",
1573 : "DataField", metaptrs);
1574 0 : if(metabuf == NULL)
1575 : {
1576 0 : free(utlstr);
1577 0 : return(-1);
1578 : }
1579 : }
1580 :
1581 :
1582 : /* Search for field */
1583 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n");
1584 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
1585 :
1586 : /* If field found ... */
1587 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
1588 : {
1589 : /* Get DataType string */
1590 0 : statmeta = EHgetmetavalue(metaptrs, "DataType", utlstr);
1591 :
1592 : /* Convert to numbertype code */
1593 0 : if (statmeta == 0)
1594 0 : *numbertype = EHnumstr(utlstr);
1595 : else
1596 : {
1597 0 : status = -1;
1598 0 : HEpush(DFE_GENAPP, "SWfinfo", __FILE__, __LINE__);
1599 0 : HEreport("\"DataType\" string not found in metadata.\n");
1600 : }
1601 :
1602 :
1603 : /*
1604 : * Get DimList string and trim off leading and trailing parens "()"
1605 : */
1606 0 : statmeta = EHgetmetavalue(metaptrs, "DimList", utlstr);
1607 :
1608 0 : if (statmeta == 0)
1609 : {
1610 0 : memmove(utlstr, utlstr + 1, strlen(utlstr) - 2);
1611 0 : utlstr[strlen(utlstr) - 2] = 0;
1612 :
1613 : /* Parse trimmed DimList string and get rank */
1614 0 : ndims = EHparsestr(utlstr, ',', ptr, slen);
1615 0 : *rank = ndims;
1616 : }
1617 : else
1618 : {
1619 0 : status = -1;
1620 0 : HEpush(DFE_GENAPP, "SWfinfo", __FILE__, __LINE__);
1621 0 : HEreport("\"DimList\" string not found in metadata.\n");
1622 : }
1623 :
1624 : /* If dimension list is desired by user then initialize length to 0 */
1625 0 : if (dimlist != NULL)
1626 : {
1627 0 : dimlist[0] = 0;
1628 : }
1629 :
1630 : /*
1631 : * Copy each entry in DimList and remove leading and trailing quotes,
1632 : * Get dimension sizes and concatenate dimension names to dimension
1633 : * list
1634 : */
1635 0 : for (i = 0; i < ndims; i++)
1636 : {
1637 0 : memcpy(dimstr, ptr[i] + 1, slen[i] - 2);
1638 0 : dimstr[slen[i] - 2] = 0;
1639 0 : dims[i] = SWdiminfo(swathID, dimstr);
1640 0 : if (dimlist != NULL)
1641 : {
1642 0 : if (i > 0)
1643 : {
1644 0 : strcat(dimlist, ",");
1645 : }
1646 0 : strcat(dimlist, dimstr);
1647 : }
1648 :
1649 : }
1650 :
1651 :
1652 : /* Appendable Field Section */
1653 : /* ------------------------ */
1654 0 : if (dims[0] == 0)
1655 : {
1656 : /* One-Dimensional Field */
1657 0 : if (*rank == 1)
1658 : {
1659 : /* Get vdata ID */
1660 0 : status = SW1dfldsrch(fid, swathID, fieldname, "r",
1661 : &dum, &vdataID, &dum);
1662 :
1663 : /* Get actual size of field */
1664 0 : dims[0] = VSelts(vdataID);
1665 :
1666 : /*
1667 : * If size=1 then check where actual record of
1668 : * "initialization" record
1669 : */
1670 0 : if (dims[0] == 1)
1671 : {
1672 : /* Get record size and read 1st record */
1673 0 : fsize = VSsizeof(vdataID, (char *)fieldname);
1674 0 : buf = (uint8 *) calloc(fsize, 1);
1675 0 : if(buf == NULL)
1676 : {
1677 0 : HEpush(DFE_NOSPACE,"SWfinfo", __FILE__, __LINE__);
1678 0 : free(utlstr);
1679 0 : return(-1);
1680 : }
1681 0 : VSsetfields(vdataID, fieldname);
1682 0 : VSseek(vdataID, 0);
1683 0 : VSread(vdataID, (uint8 *) buf, 1, FULL_INTERLACE);
1684 :
1685 : /* Sum up "bytes" in record */
1686 0 : for (i = 0, j = 0; i < fsize; i++)
1687 : {
1688 0 : j += buf[i];
1689 : }
1690 :
1691 : /*
1692 : * If filled with 255 then "initialization" record,
1693 : * actual number of records = 0
1694 : */
1695 0 : if (j == 255 * fsize)
1696 : {
1697 0 : dims[0] = 0;
1698 : }
1699 :
1700 0 : free(buf);
1701 : }
1702 : /* Detach from 1d field */
1703 0 : VSdetach(vdataID);
1704 : }
1705 : else
1706 : {
1707 : /* Get actual size of Multi-Dimensional Field */
1708 0 : status = SWSDfldsrch(swathID, sdInterfaceID, fieldname,
1709 : &dum, &dum, &dum, &dum, dims,
1710 : &dum);
1711 : }
1712 : }
1713 : }
1714 0 : free(metabuf);
1715 :
1716 0 : if (*rank == -1)
1717 : {
1718 0 : status = -1;
1719 : }
1720 0 : free(utlstr);
1721 :
1722 0 : return (status);
1723 : }
1724 :
1725 :
1726 :
1727 :
1728 :
1729 : /*----------------------------------------------------------------------------|
1730 : | BEGIN_PROLOG |
1731 : | |
1732 : | FUNCTION: SWfieldinfo |
1733 : | |
1734 : | DESCRIPTION: Wrapper around SWfinfo |
1735 : | |
1736 : | |
1737 : | Return Value Type Units Description |
1738 : | ============ ====== ========= ===================================== |
1739 : | status intn return status (0) SUCCEED, (-1) FAIL |
1740 : | |
1741 : | INPUTS: |
1742 : | swathID int32 swath structure id |
1743 : | fieldname const char name of field |
1744 : | |
1745 : | |
1746 : | OUTPUTS: |
1747 : | rank int32 rank of field (# of dims) |
1748 : | dims int32 field dimensions |
1749 : | numbertype int32 field number type |
1750 : | dimlist char field dimension list |
1751 : | |
1752 : | NOTES: |
1753 : | |
1754 : | |
1755 : | Date Programmer Description |
1756 : | ====== ============ ================================================= |
1757 : | Jun 96 Joel Gales Original Programmer |
1758 : | |
1759 : | END_PROLOG |
1760 : -----------------------------------------------------------------------------*/
1761 : intn
1762 0 : SWfieldinfo(int32 swathID, const char *fieldname, int32 * rank, int32 dims[],
1763 : int32 * numbertype, char *dimlist)
1764 :
1765 : {
1766 : intn status; /* routine return status variable */
1767 :
1768 : int32 fid; /* HDF-EOS file ID */
1769 : int32 sdInterfaceID; /* HDF SDS interface ID */
1770 : int32 swVgrpID; /* Swath root Vgroup ID */
1771 :
1772 :
1773 : /* Check for valid swath id */
1774 0 : status = SWchkswid(swathID, "SWfieldinfo", &fid,
1775 : &sdInterfaceID, &swVgrpID);
1776 0 : if (status == 0)
1777 : {
1778 : /* Check for field within Geolocatation Fields */
1779 0 : status = SWfinfo(swathID, "Geolocation Fields", fieldname,
1780 : rank, dims, numbertype, dimlist);
1781 :
1782 : /* If not there then check within Data Fields */
1783 0 : if (status == -1)
1784 : {
1785 0 : status = SWfinfo(swathID, "Data Fields", fieldname,
1786 : rank, dims, numbertype, dimlist);
1787 : }
1788 :
1789 : /* If not there either then can't be found */
1790 0 : if (status == -1)
1791 : {
1792 0 : HEpush(DFE_GENAPP, "SWfieldinfo", __FILE__, __LINE__);
1793 0 : HEreport("Fieldname \"%s\" not found.\n", fieldname);
1794 : }
1795 : }
1796 0 : return (status);
1797 : }
1798 :
1799 :
1800 :
1801 :
1802 :
1803 :
1804 : /*----------------------------------------------------------------------------|
1805 : | BEGIN_PROLOG |
1806 : | |
1807 : | FUNCTION: SWdefdimmap |
1808 : | |
1809 : | DESCRIPTION: Defines mapping between geolocation and data dimensions |
1810 : | |
1811 : | |
1812 : | Return Value Type Units Description |
1813 : | ============ ====== ========= ===================================== |
1814 : | status intn return status (0) SUCCEED, (-1) FAIL |
1815 : | |
1816 : | INPUTS: |
1817 : | swathID int32 swath structure ID |
1818 : | geodim char Geolocation dimension |
1819 : | datadim char Data dimension |
1820 : | offset int32 Mapping offset |
1821 : | increment int32 Mapping increment |
1822 : | |
1823 : | OUTPUTS: |
1824 : | None |
1825 : | |
1826 : | NOTES: |
1827 : | |
1828 : | |
1829 : | Date Programmer Description |
1830 : | ====== ============ ================================================= |
1831 : | Jun 96 Joel Gales Original Programmer |
1832 : | |
1833 : | END_PROLOG |
1834 : -----------------------------------------------------------------------------*/
1835 : intn
1836 0 : SWdefdimmap(int32 swathID, const char *geodim, const char *datadim, int32 offset,
1837 : int32 increment)
1838 :
1839 : {
1840 : intn status; /* routine return status variable */
1841 :
1842 : int32 fid; /* HDF-EOS file ID */
1843 : int32 sdInterfaceID; /* HDF SDS interface ID */
1844 : int32 size; /* Size of geo dim */
1845 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1846 : int32 dum; /* Dummy variable */
1847 : int32 metadata[2];/* Offset & Increment (passed to metadata) */
1848 :
1849 : char mapname[80];/* Mapping name (geodim/datadim) */
1850 : char swathname[80]; /* Swath name */
1851 :
1852 : /* Check Swath ID */
1853 0 : status = SWchkswid(swathID, "SWdefdimmap", &fid, &sdInterfaceID, &dum);
1854 :
1855 0 : if (status == 0)
1856 : {
1857 :
1858 : /* Search Dimension Vdata for dimension entries */
1859 : /* -------------------------------------------- */
1860 0 : size = SWdiminfo(swathID, geodim);
1861 0 : if (size == -1)
1862 : {
1863 0 : status = -1;
1864 0 : HEpush(DFE_GENAPP, "SWdefdimmap", __FILE__, __LINE__);
1865 0 : HEreport("Geolocation dimension name: \"%s\" not found.\n",
1866 : geodim);
1867 : }
1868 : /* Data Dimension Search */
1869 : /* --------------------- */
1870 0 : if (status == 0)
1871 : {
1872 0 : size = SWdiminfo(swathID, datadim);
1873 0 : if (size == -1)
1874 : {
1875 0 : status = -1;
1876 0 : HEpush(DFE_GENAPP, "SWdefdimmap", __FILE__, __LINE__);
1877 0 : HEreport("Data dimension name: \"%s\" not found.\n",
1878 : datadim);
1879 : }
1880 : }
1881 :
1882 : /* Write Dimension Map to Structural MetaData */
1883 : /* ------------------------------------------ */
1884 0 : if (status == 0)
1885 : {
1886 0 : snprintf(mapname, sizeof(mapname), "%s%s%s", geodim, "/", datadim);
1887 0 : metadata[0] = offset;
1888 0 : metadata[1] = increment;
1889 :
1890 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
1891 0 : status = EHinsertmeta(sdInterfaceID, swathname, "s", 1L,
1892 : mapname, metadata);
1893 :
1894 : }
1895 : }
1896 0 : return (status);
1897 : }
1898 :
1899 :
1900 :
1901 : /*----------------------------------------------------------------------------|
1902 : | BEGIN_PROLOG |
1903 : | |
1904 : | FUNCTION: SWdefidxmap |
1905 : | |
1906 : | DESCRIPTION: Defines l_indexed (non-linear) mapping between geolocation |
1907 : | and data dimensions |
1908 : | |
1909 : | |
1910 : | Return Value Type Units Description |
1911 : | ============ ====== ========= ===================================== |
1912 : | status intn return status (0) SUCCEED, (-1) FAIL |
1913 : | |
1914 : | INPUTS: |
1915 : | swathID int32 swath structure ID |
1916 : | geodim char Geolocation dimension |
1917 : | datadim char Data dimension |
1918 : | l_index int32 Index mapping array |
1919 : | |
1920 : | OUTPUTS: |
1921 : | None |
1922 : | |
1923 : | NOTES: |
1924 : | |
1925 : | |
1926 : | Date Programmer Description |
1927 : | ====== ============ ================================================= |
1928 : | Jun 96 Joel Gales Original Programmer |
1929 : | |
1930 : | END_PROLOG |
1931 : -----------------------------------------------------------------------------*/
1932 : intn
1933 0 : SWdefidxmap(int32 swathID, const char *geodim, const char *datadim, int32 l_index[])
1934 :
1935 : {
1936 : intn status; /* routine return status variable */
1937 :
1938 : int32 fid; /* HDF-EOS file ID */
1939 : int32 sdInterfaceID; /* HDF SDS interface ID */
1940 : int32 attrVgrpID; /* Swath attribute ID */
1941 : int32 vdataID; /* Mapping Index Vdata ID */
1942 : int32 gsize; /* Size of geo dim */
1943 : int32 dsize; /* Size of data dim */
1944 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
1945 : int32 dum; /* Dummy variable */
1946 :
1947 : uint8 *buf; /* Vdata field buffer */
1948 :
1949 : char mapname[80];/* Mapping name (geodim/datadim) */
1950 : char swathname[80]; /* Swath name */
1951 : char utlbuf[256];/* Utility buffer */
1952 :
1953 :
1954 : /* Check Swath ID */
1955 0 : status = SWchkswid(swathID, "SWdefidxmap", &fid, &sdInterfaceID, &dum);
1956 0 : if (status == 0)
1957 : {
1958 : /* Search Dimension Vdata for dimension entries */
1959 : /* -------------------------------------------- */
1960 :
1961 : /* Geo Dimension Search */
1962 : /* -------------------- */
1963 :
1964 0 : gsize = SWdiminfo(swathID, geodim);
1965 :
1966 0 : if (gsize == -1)
1967 : {
1968 0 : status = -1;
1969 0 : HEpush(DFE_GENAPP, "SWdefidxmap", __FILE__, __LINE__);
1970 0 : HEreport("Geolocation dimension name: \"%s\" not found.\n",
1971 : geodim);
1972 : }
1973 : /* Data Dimension Search */
1974 : /* --------------------- */
1975 0 : if (status == 0)
1976 : {
1977 0 : dsize = SWdiminfo(swathID, datadim);
1978 0 : if (dsize == -1)
1979 : {
1980 0 : status = -1;
1981 0 : HEpush(DFE_GENAPP, "SWdefidxmap", __FILE__, __LINE__);
1982 0 : HEreport("Data dimension name: \"%s\" not found.\n",
1983 : datadim);
1984 : }
1985 : }
1986 : /* Define Index Vdata and Store Index Array */
1987 : /* ---------------------------------------- */
1988 0 : if (status == 0)
1989 : {
1990 : /* Get attribute Vgroup ID and allocate data buffer */
1991 : /* ------------------------------------------------ */
1992 0 : attrVgrpID = SWXSwath[swathID % idOffset].VIDTable[2];
1993 0 : buf = (uint8 *) calloc(4 * gsize, 1);
1994 0 : if(buf == NULL)
1995 : {
1996 0 : HEpush(DFE_NOSPACE,"SWdefidxmap", __FILE__, __LINE__);
1997 0 : return(-1);
1998 : }
1999 :
2000 : /* Name: "INDXMAP:" + geodim + "/" + datadim */
2001 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%s%s%s", "INDXMAP:", geodim, "/", datadim);
2002 :
2003 0 : vdataID = VSattach(fid, -1, "w");
2004 0 : VSsetname(vdataID, utlbuf);
2005 :
2006 : /* Attribute Class */
2007 0 : VSsetclass(vdataID, "Attr0.0");
2008 :
2009 : /* Fieldname is "Index" */
2010 0 : VSfdefine(vdataID, "Index", DFNT_INT32, gsize);
2011 0 : VSsetfields(vdataID, "Index");
2012 0 : memcpy(buf, l_index, 4 * gsize);
2013 :
2014 : /* Write to vdata and free data buffer */
2015 0 : VSwrite(vdataID, buf, 1, FULL_INTERLACE);
2016 0 : free(buf);
2017 :
2018 : /* Insert in Attribute Vgroup and detach Vdata */
2019 0 : Vinsert(attrVgrpID, vdataID);
2020 0 : VSdetach(vdataID);
2021 :
2022 :
2023 : /* Write to Structural Metadata */
2024 0 : snprintf(mapname, sizeof(mapname), "%s%s%s", geodim, "/", datadim);
2025 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
2026 0 : status = EHinsertmeta(sdInterfaceID, swathname, "s", 2L,
2027 : mapname, &dum);
2028 :
2029 : }
2030 : }
2031 0 : return (status);
2032 :
2033 : }
2034 :
2035 :
2036 : /*----------------------------------------------------------------------------|
2037 : | BEGIN_PROLOG |
2038 : | |
2039 : | FUNCTION: SWdefcomp |
2040 : | |
2041 : | DESCRIPTION: Defines compression type and parameters |
2042 : | |
2043 : | |
2044 : | Return Value Type Units Description |
2045 : | ============ ====== ========= ===================================== |
2046 : | status intn return status (0) SUCCEED, (-1) FAIL |
2047 : | |
2048 : | INPUTS: |
2049 : | swathID int32 swath structure ID |
2050 : | compcode int32 compression code |
2051 : | compparm intn compression parameters |
2052 : | |
2053 : | OUTPUTS: |
2054 : | None |
2055 : | |
2056 : | NOTES: |
2057 : | |
2058 : | |
2059 : | Date Programmer Description |
2060 : | ====== ============ ================================================= |
2061 : | Sep 96 Joel Gales Original Programmer |
2062 : | |
2063 : | END_PROLOG |
2064 : -----------------------------------------------------------------------------*/
2065 : intn
2066 0 : SWdefcomp(int32 swathID, int32 compcode, intn compparm[])
2067 : {
2068 0 : intn status = 0; /* routine return status variable */
2069 :
2070 : int32 fid; /* HDF-EOS file id */
2071 : int32 sdInterfaceID; /* HDF SDS interface ID */
2072 : int32 swVgrpID; /* Swath root Vgroup ID */
2073 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2074 : int32 sID; /* swathID - offset */
2075 :
2076 :
2077 : /* Check for valid swath id */
2078 0 : status = SWchkswid(swathID, "SWdefcomp", &fid, &sdInterfaceID, &swVgrpID);
2079 :
2080 0 : if (status == 0)
2081 : {
2082 0 : sID = swathID % idOffset;
2083 :
2084 : /* Set compression code in compression external array */
2085 0 : SWXSwath[sID].compcode = compcode;
2086 :
2087 0 : switch (compcode)
2088 : {
2089 : /* Set NBIT compression parameters in compression external array */
2090 0 : case HDFE_COMP_NBIT:
2091 :
2092 0 : SWXSwath[sID].compparm[0] = compparm[0];
2093 0 : SWXSwath[sID].compparm[1] = compparm[1];
2094 0 : SWXSwath[sID].compparm[2] = compparm[2];
2095 0 : SWXSwath[sID].compparm[3] = compparm[3];
2096 :
2097 0 : break;
2098 :
2099 : /* Set GZIP compression parameter in compression external array */
2100 0 : case HDFE_COMP_DEFLATE:
2101 :
2102 0 : SWXSwath[sID].compparm[0] = compparm[0];
2103 :
2104 0 : break;
2105 :
2106 : }
2107 0 : }
2108 :
2109 0 : return (status);
2110 : }
2111 :
2112 : /*----------------------------------------------------------------------------|
2113 : | BEGIN_PROLOG |
2114 : | |
2115 : | FUNCTION: SWdefinefield |
2116 : | |
2117 : | DESCRIPTION: Defines geolocation or data field within swath structure |
2118 : | |
2119 : | |
2120 : | Return Value Type Units Description |
2121 : | ============ ====== ========= ===================================== |
2122 : | status intn return status (0) SUCCEED, (-1) FAIL |
2123 : | |
2124 : | INPUTS: |
2125 : | swathID int32 swath structure ID |
2126 : | fieldtype char geo/data fieldtype |
2127 : | fieldname char fieldname |
2128 : | dimlist char Dimension list (comma-separated list) |
2129 : | numbertype int32 field type |
2130 : | merge int32 merge code |
2131 : | |
2132 : | |
2133 : | OUTPUTS: |
2134 : | None |
2135 : | |
2136 : | NOTES: |
2137 : | |
2138 : | |
2139 : | Date Programmer Description |
2140 : | ====== ============ ================================================= |
2141 : | Jun 96 Joel Gales Original Programmer |
2142 : | Aug 96 Joel Gales Check name for length |
2143 : | Sep 96 Joel Gales Make string array "dimbuf" dynamic |
2144 : | Oct 96 Joel Gales Make sure total length of "merged" Vdata < 64 |
2145 : | Jun 03 Abe Taaheri Supplied cast comp_coder_t in call to SDsetcompress |
2146 : | |
2147 : | END_PROLOG |
2148 : -----------------------------------------------------------------------------*/
2149 : static intn
2150 0 : SWdefinefield(int32 swathID, const char *fieldtype, const char *fieldname, const char *dimlist,
2151 : int32 numbertype, int32 merge)
2152 :
2153 : {
2154 : intn i; /* Loop index */
2155 : intn status; /* routine return status variable */
2156 : intn found; /* utility found flag */
2157 0 : intn foundNT = 0;/* found number type flag */
2158 0 : intn foundAllDim = 1; /* found all dimensions flag */
2159 0 : intn first = 1; /* first entry flag */
2160 : intn fac; /* Geo (-1), Data (+1) field factor */
2161 0 : int32 cnt = 0;
2162 :
2163 : int32 fid; /* HDF-EOS file ID */
2164 0 : int32 vdataID = 0; /* Vdata ID */
2165 : int32 vgid; /* Geo/Data field Vgroup ID */
2166 : int32 sdInterfaceID; /* HDF SDS interface ID */
2167 : int32 sdid; /* SDS object ID */
2168 : int32 dimid; /* SDS dimension ID */
2169 : int32 recSize; /* Vdata record size */
2170 : int32 swVgrpID; /* Swath root Vgroup ID */
2171 : int32 dims[8]; /* Dimension size array */
2172 : int32 dimsize; /* Dimension size */
2173 0 : int32 rank = 0; /* Field rank */
2174 : int32 slen[32]; /* String length array */
2175 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2176 : int32 compcode; /* Compression code */
2177 : int32 sID; /* SwathID - offset */
2178 :
2179 : uint8 *oneDbuf; /* Vdata record buffer */
2180 : char *dimbuf; /* Dimension buffer */
2181 : char *comma; /* Pointer to comma */
2182 : char *dimcheck; /* Dimension check buffer */
2183 : char utlbuf[512];/* Utility buffer */
2184 : char utlbuf2[256]; /* Utility buffer 2 */
2185 : char *ptr[32]; /* String pointer array */
2186 : char swathname[80]; /* Swath name */
2187 : char errbuf1[128]; /* Error message buffer 1 */
2188 : char errbuf2[128]; /* Error message buffer 2 */
2189 : char compparmbuf[128]; /* Compression parameter string buffer */
2190 :
2191 0 : const char *HDFcomp[5] = {"HDFE_COMP_NONE", "HDFE_COMP_RLE",
2192 : "HDFE_COMP_NBIT", "HDFE_COMP_SKPHUFF",
2193 : "HDFE_COMP_DEFLATE"};
2194 : /* Compression code names */
2195 :
2196 0 : uint16 good_number[10] = {3, 4, 5, 6, 20, 21, 22, 23, 24, 25};
2197 : /* Valid number types */
2198 : comp_info c_info; /* Compression parameter structure */
2199 :
2200 :
2201 :
2202 : /* Setup error message strings */
2203 : /* --------------------------- */
2204 0 : strcpy(errbuf1, "SWXSDname array too small.\nPlease increase ");
2205 0 : strcat(errbuf1, "size of HDFE_NAMBUFSIZE in \"HdfEosDef.h\".\n");
2206 0 : strcpy(errbuf2, "SWXSDdims array too small.\nPlease increase ");
2207 0 : strcat(errbuf2, "size of HDFE_DIMBUFSIZE in \"HdfEosDef.h\".\n");
2208 :
2209 :
2210 :
2211 : /*
2212 : * Check for proper swath ID and return HDF-EOS file ID, SDinterface ID,
2213 : * and swath root Vgroup ID
2214 : */
2215 0 : status = SWchkswid(swathID, "SWdefinefield",
2216 : &fid, &sdInterfaceID, &swVgrpID);
2217 :
2218 :
2219 0 : if (status == 0)
2220 : {
2221 : /* Remove offset from swath ID & get swathname */
2222 0 : sID = swathID % idOffset;
2223 0 : Vgetname(swVgrpID, swathname);
2224 :
2225 : /* Allocate space for dimbuf, copy dimlist into it, & append comma */
2226 0 : dimbuf = (char *) calloc(strlen(dimlist) + 64, 1);
2227 0 : if(dimbuf == NULL)
2228 : {
2229 0 : HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__);
2230 0 : return(-1);
2231 : }
2232 0 : strcpy(dimbuf, dimlist);
2233 0 : strcat(dimbuf, ",");
2234 :
2235 : /* Find comma */
2236 0 : comma = strchr(dimbuf, ',');
2237 :
2238 :
2239 : /*
2240 : * Loop through entries in dimension list to make sure they are
2241 : * defined in swath
2242 : */
2243 0 : while (comma != NULL)
2244 : {
2245 : /* Copy dimension list entry to dimcheck */
2246 0 : dimcheck = (char *) calloc(comma - dimbuf + 1, 1);
2247 0 : if(dimcheck == NULL)
2248 : {
2249 0 : HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__);
2250 0 : free(dimbuf);
2251 0 : return(-1);
2252 : }
2253 0 : memcpy(dimcheck, dimbuf, comma - dimbuf);
2254 :
2255 : /* Get dimension size */
2256 0 : dimsize = SWdiminfo(swathID, dimcheck);
2257 :
2258 : /* if != -1 then sent found flag, store size and increment rank */
2259 0 : if (dimsize != -1)
2260 : {
2261 0 : dims[rank] = dimsize;
2262 0 : rank++;
2263 : }
2264 : else
2265 : {
2266 : /*
2267 : * If dimension list entry not found - set error return
2268 : * status, append name to utility buffer for error report
2269 : */
2270 0 : status = -1;
2271 0 : foundAllDim = 0;
2272 0 : if (first == 1)
2273 : {
2274 0 : strcpy(utlbuf, dimcheck);
2275 : }
2276 : else
2277 : {
2278 0 : strcat(utlbuf, ",");
2279 0 : strcat(utlbuf, dimcheck);
2280 : }
2281 0 : first = 0;
2282 : }
2283 :
2284 : /*
2285 : * Go to next dimension entry, find next comma, & free up
2286 : * dimcheck buffer
2287 : */
2288 0 : *comma = '\0'; /* zero out first comma */
2289 0 : comma++;
2290 0 : comma = strchr(comma, ',');
2291 0 : if (comma != NULL)
2292 : {
2293 0 : for (i=0; i<(intn)strlen(dimcheck) + 1; i++)
2294 : {
2295 0 : dimbuf++;
2296 0 : cnt++;
2297 : }
2298 : }
2299 0 : free(dimcheck);
2300 : }
2301 0 : for(i=0; i<cnt; i++)
2302 0 : dimbuf--;
2303 :
2304 0 : free(dimbuf);
2305 :
2306 :
2307 : /* Check that UNLIMITED dimension is first dimension if present */
2308 : /* ------------------------------------------------------------ */
2309 0 : if (status == 0)
2310 : {
2311 0 : for (i = 0; i < rank; i++)
2312 : {
2313 0 : if (dims[i] == 0 && i != 0)
2314 : {
2315 0 : status = -1;
2316 0 : HEpush(DFE_GENAPP, "SWdefinefield", __FILE__, __LINE__);
2317 0 : HEreport("UNLIMITED dimension must be first dimension.\n");
2318 : }
2319 : }
2320 : }
2321 :
2322 : /* Check fieldname length */
2323 : /* ---------------------- */
2324 0 : if (status == 0)
2325 : {
2326 : /* ((intn) strlen(fieldname) > MAX_NC_NAME - 7)
2327 : ** this was changed because HDF4.1r3 made a change in the
2328 : ** hlimits.h file. We have notified NCSA and asked to have
2329 : ** it made the same as in previous versions of HDF
2330 : ** see ncr 26314. DaW Apr 2000
2331 : */
2332 :
2333 0 : if (((intn) strlen(fieldname) > VSNAMELENMAX && rank == 1) ||
2334 0 : ((intn) strlen(fieldname) > (256 - 7) && rank > 1))
2335 : {
2336 0 : status = -1;
2337 0 : HEpush(DFE_GENAPP, "SWdefinefield", __FILE__, __LINE__);
2338 0 : HEreport("Fieldname \"%s\" too long.\n", fieldname);
2339 : }
2340 : }
2341 :
2342 : /* Check for valid numbertype */
2343 : /* -------------------------- */
2344 0 : if (status == 0)
2345 : {
2346 0 : for (i = 0; i < 10; i++)
2347 : {
2348 0 : if (numbertype == good_number[i])
2349 : {
2350 0 : foundNT = 1;
2351 : }
2352 : }
2353 :
2354 0 : if (foundNT == 0)
2355 : {
2356 0 : HEpush(DFE_BADNUMTYPE, "SWdefinefield", __FILE__, __LINE__);
2357 0 : HEreport("Invalid number type: %d (%s).\n",
2358 : numbertype, fieldname);
2359 0 : status = -1;
2360 : }
2361 : }
2362 :
2363 :
2364 : /* Define Field */
2365 : /* ------------ */
2366 0 : if (status == 0)
2367 : {
2368 : /* Set factor & get Field Vgroup id */
2369 : /* -------------------------------- */
2370 0 : if (strcmp(fieldtype, "Geolocation Fields") == 0)
2371 : {
2372 0 : fac = -1;
2373 0 : vgid = SWXSwath[sID].VIDTable[0];
2374 : }
2375 : else
2376 : {
2377 0 : fac = +1;
2378 0 : vgid = SWXSwath[sID].VIDTable[1];
2379 : }
2380 : /*
2381 : * Note: "fac" is used to distinguish geo fields from data fields
2382 : * so that they are not merged together
2383 : */
2384 :
2385 :
2386 : /* One D Fields */
2387 : /* ------------ */
2388 0 : if (rank == 1)
2389 : {
2390 : /* No Compression for 1D (Vdata) fields */
2391 0 : compcode = HDFE_COMP_NONE;
2392 :
2393 :
2394 : /* If field non-appendable and merge set to AUTOMERGE ... */
2395 0 : if (dims[0] != 0 && merge == HDFE_AUTOMERGE)
2396 : {
2397 0 : i = 0;
2398 0 : found = 0;
2399 :
2400 : /* Loop through previous entries in 1d combination array */
2401 0 : while (SWX1dcomb[3 * i] != 0)
2402 : {
2403 : /* Get name of previous 1d combined field */
2404 0 : vdataID = SWX1dcomb[3 * i + 2];
2405 0 : VSgetname(vdataID, utlbuf);
2406 :
2407 : /*
2408 : * If dimension, field type (geo/data), and swath
2409 : * structure if current entry match a previous entry
2410 : * and combined name is less than max allowed then
2411 : * set "found" flag and exit loop
2412 : */
2413 0 : if (SWX1dcomb[3 * i] == fac * dims[0] &&
2414 0 : SWX1dcomb[3 * i + 1] == swVgrpID &&
2415 0 : (intn) strlen(utlbuf) +
2416 0 : (intn) strlen(fieldname) + 1 <=
2417 : VSNAMELENMAX)
2418 : {
2419 0 : found = 1;
2420 0 : break;
2421 : }
2422 : /* Increment loop index */
2423 0 : i++;
2424 : }
2425 :
2426 :
2427 0 : if (found == 0)
2428 : {
2429 : /*
2430 : * If no matching entry found then start new Vdata
2431 : * and store dimension size, swath root Vgroup ID,
2432 : * field Vdata and fieldname in external array
2433 : * "SWX1dcomb"
2434 : */
2435 0 : vdataID = VSattach(fid, -1, "w");
2436 0 : SWX1dcomb[3 * i] = fac * dims[0];
2437 0 : SWX1dcomb[3 * i + 1] = swVgrpID;
2438 0 : SWX1dcomb[3 * i + 2] = vdataID;
2439 0 : VSsetname(vdataID, fieldname);
2440 : }
2441 : else
2442 : {
2443 : /*
2444 : * If match then concatenate current fieldname to
2445 : * previous matching fieldnames.
2446 : */
2447 0 : strcat(utlbuf, ",");
2448 0 : strcat(utlbuf, fieldname);
2449 0 : VSsetname(vdataID, utlbuf);
2450 : }
2451 :
2452 : /* Define field as field within Vdata */
2453 0 : VSfdefine(vdataID, fieldname, numbertype, 1);
2454 0 : Vinsert(vgid, vdataID);
2455 :
2456 : }
2457 : else
2458 : {
2459 : /* 1d No Merge Section */
2460 :
2461 : /* Get new vdata ID and establish field within Vdata */
2462 0 : vdataID = VSattach(fid, -1, "w");
2463 0 : VSsetname(vdataID, fieldname);
2464 0 : VSfdefine(vdataID, fieldname, numbertype, 1);
2465 0 : VSsetfields(vdataID, fieldname);
2466 :
2467 0 : recSize = VSsizeof(vdataID, (char*) fieldname);
2468 0 : if (dims[0] == 0)
2469 : {
2470 : /*
2471 : * If appendable field then write single record
2472 : * filled with 255
2473 : */
2474 0 : oneDbuf = (uint8 *) calloc(recSize, 1);
2475 0 : if(oneDbuf == NULL)
2476 : {
2477 0 : HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__);
2478 0 : return(-1);
2479 : }
2480 0 : for (i = 0; i < recSize; i++)
2481 0 : oneDbuf[i] = 255;
2482 0 : VSwrite(vdataID, oneDbuf, 1, FULL_INTERLACE);
2483 : }
2484 : else
2485 : {
2486 : /*
2487 : * If non-appendable then write entire field with
2488 : * blank records
2489 : */
2490 0 : oneDbuf = (uint8 *) calloc(recSize, dims[0]);
2491 0 : if(oneDbuf == NULL)
2492 : {
2493 0 : HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__);
2494 0 : return(-1);
2495 : }
2496 0 : VSwrite(vdataID, oneDbuf, dims[0], FULL_INTERLACE);
2497 : }
2498 0 : free(oneDbuf);
2499 :
2500 : /* Insert Vdata into field Vgroup & detach */
2501 0 : Vinsert(vgid, vdataID);
2502 0 : VSdetach(vdataID);
2503 :
2504 : } /* End No Merge Section */
2505 :
2506 : } /* End 1d field Section */
2507 : else
2508 : {
2509 : /* SDS Interface (Multi-dim fields) */
2510 : /* -------------------------------- */
2511 :
2512 : /* Get current compression code */
2513 0 : compcode = SWXSwath[sID].compcode;
2514 :
2515 : /*
2516 : * If rank is less than or equal to 3 (and greater than 1)
2517 : * and AUTOMERGE is set and the first dimension is not
2518 : * appendable and the compression code is set to none then
2519 : * ...
2520 : */
2521 0 : if (rank <= 3 && merge == HDFE_AUTOMERGE && dims[0] != 0
2522 0 : && compcode == HDFE_COMP_NONE)
2523 : {
2524 : /* Find first empty slot in external combination array */
2525 : /* --------------------------------------------------- */
2526 0 : i = 0;
2527 0 : while (SWXSDcomb[5 * i] != 0)
2528 : {
2529 0 : i++;
2530 : }
2531 :
2532 : /*
2533 : * Store dimensions (with geo/data factor), swath root
2534 : * Vgroup ID, and number type in external combination
2535 : * array "SWXSDcomb"
2536 : */
2537 :
2538 0 : if (rank == 2)
2539 : {
2540 : /* If 2-dim field then set lowest dimension to +/- 1 */
2541 0 : SWXSDcomb[5 * i] = fac;
2542 0 : SWXSDcomb[5 * i + 1] = fac * dims[0];
2543 0 : SWXSDcomb[5 * i + 2] = fac * dims[1];
2544 : }
2545 : else
2546 : {
2547 0 : SWXSDcomb[5 * i] = fac * dims[0];
2548 0 : SWXSDcomb[5 * i + 1] = fac * dims[1];
2549 0 : SWXSDcomb[5 * i + 2] = fac * dims[2];
2550 : }
2551 :
2552 0 : SWXSDcomb[5 * i + 3] = swVgrpID;
2553 0 : SWXSDcomb[5 * i + 4] = numbertype;
2554 :
2555 :
2556 : /* Concatenate fieldname with combined name string */
2557 : /* ----------------------------------------------- */
2558 0 : if ((intn) strlen(SWXSDname) +
2559 0 : (intn) strlen(fieldname) + 2 < HDFE_NAMBUFSIZE)
2560 : {
2561 0 : strcat(SWXSDname, fieldname);
2562 0 : strcat(SWXSDname, ",");
2563 : }
2564 : else
2565 : {
2566 : /* SWXSDname array too small! */
2567 : /* -------------------------- */
2568 0 : HEpush(DFE_GENAPP, "SWdefinefield",
2569 : __FILE__, __LINE__);
2570 0 : HEreport(errbuf1);
2571 0 : status = -1;
2572 0 : return (status);
2573 : }
2574 :
2575 :
2576 :
2577 : /*
2578 : * If 2-dim field then set lowest dimension (in 3-dim
2579 : * array) to "ONE"
2580 : */
2581 0 : if (rank == 2)
2582 : {
2583 0 : if ((intn) strlen(SWXSDdims) + 5 < HDFE_DIMBUFSIZE)
2584 : {
2585 0 : strcat(SWXSDdims, "ONE,");
2586 : }
2587 : else
2588 : {
2589 : /* SWXSDdims array too small! */
2590 : /* -------------------------- */
2591 0 : HEpush(DFE_GENAPP, "SWdefinefield",
2592 : __FILE__, __LINE__);
2593 0 : HEreport(errbuf2);
2594 0 : status = -1;
2595 0 : return (status);
2596 : }
2597 :
2598 : }
2599 :
2600 : /*
2601 : * Concatenate field dimlist to merged dimlist and
2602 : * separate fields with semi-colon.
2603 : */
2604 0 : if ((intn) strlen(SWXSDdims) +
2605 0 : (intn) strlen(dimlist) + 2 < HDFE_DIMBUFSIZE)
2606 : {
2607 0 : strcat(SWXSDdims, dimlist);
2608 0 : strcat(SWXSDdims, ";");
2609 : }
2610 : else
2611 : {
2612 : /* SWXSDdims array too small! */
2613 : /* -------------------------- */
2614 0 : HEpush(DFE_GENAPP, "SWdefinefield",
2615 : __FILE__, __LINE__);
2616 0 : HEreport(errbuf2);
2617 0 : status = -1;
2618 0 : return (status);
2619 : }
2620 :
2621 : } /* End Multi-Dim Merge Section */
2622 : else
2623 : {
2624 : /* Multi-Dim No Merge Section */
2625 : /* ========================== */
2626 :
2627 : /* Create SDS dataset */
2628 : /* ------------------ */
2629 0 : sdid = SDcreate(sdInterfaceID, fieldname,
2630 : numbertype, rank, dims);
2631 :
2632 :
2633 : /* Store Dimension Names in SDS */
2634 : /* ---------------------------- */
2635 0 : rank = EHparsestr(dimlist, ',', ptr, slen);
2636 0 : for (i = 0; i < rank; i++)
2637 : {
2638 : /* Dimension name = Swathname:Dimname */
2639 0 : memcpy(utlbuf, ptr[i], slen[i]);
2640 0 : utlbuf[slen[i]] = 0;
2641 0 : strcat(utlbuf, ":");
2642 0 : strcat(utlbuf, swathname);
2643 :
2644 0 : dimid = SDgetdimid(sdid, i);
2645 0 : SDsetdimname(dimid, utlbuf);
2646 : }
2647 :
2648 :
2649 : /* Setup compression parameters */
2650 0 : if (compcode == HDFE_COMP_NBIT)
2651 : {
2652 0 : c_info.nbit.nt = numbertype;
2653 0 : c_info.nbit.sign_ext = SWXSwath[sID].compparm[0];
2654 0 : c_info.nbit.fill_one = SWXSwath[sID].compparm[1];
2655 0 : c_info.nbit.start_bit = SWXSwath[sID].compparm[2];
2656 0 : c_info.nbit.bit_len = SWXSwath[sID].compparm[3];
2657 : }
2658 0 : else if (compcode == HDFE_COMP_SKPHUFF)
2659 : {
2660 0 : c_info.skphuff.skp_size = (intn) DFKNTsize(numbertype);
2661 : }
2662 0 : else if (compcode == HDFE_COMP_DEFLATE)
2663 : {
2664 0 : c_info.deflate.level = SWXSwath[sID].compparm[0];
2665 : }
2666 :
2667 : /* If field is compressed then call SDsetcompress */
2668 : /* ---------------------------------------------- */
2669 0 : if (compcode != HDFE_COMP_NONE)
2670 : {
2671 0 : /* status = */ SDsetcompress(sdid, (comp_coder_t) compcode, &c_info);
2672 : }
2673 :
2674 :
2675 : /* Attach to Vgroup */
2676 : /* ---------------- */
2677 0 : Vaddtagref(vgid, DFTAG_NDG, SDidtoref(sdid));
2678 :
2679 :
2680 : /* Store SDS dataset IDs */
2681 : /* --------------------- */
2682 0 : if (SWXSwath[sID].nSDS > 0)
2683 : {
2684 0 : SWXSwath[sID].sdsID = (int32 *)
2685 0 : realloc((void *) SWXSwath[sID].sdsID,
2686 0 : (SWXSwath[sID].nSDS + 1) * 4);
2687 0 : if(SWXSwath[sID].sdsID == NULL)
2688 : {
2689 0 : HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__);
2690 0 : return(-1);
2691 : }
2692 :
2693 : }
2694 : else
2695 : {
2696 0 : SWXSwath[sID].sdsID = (int32 *) calloc(1, 4);
2697 0 : if(SWXSwath[sID].sdsID == NULL)
2698 : {
2699 0 : HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__);
2700 0 : return(-1);
2701 : }
2702 : }
2703 0 : SWXSwath[sID].sdsID[SWXSwath[sID].nSDS] = sdid;
2704 0 : SWXSwath[sID].nSDS++;
2705 :
2706 : } /* End Multi-Dim No Merge Section */
2707 :
2708 : } /* End Multi-Dim Section */
2709 :
2710 :
2711 :
2712 : /* Setup metadata string */
2713 : /* --------------------- */
2714 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%s%s", fieldname, ":", dimlist);
2715 :
2716 :
2717 : /* Setup compression metadata */
2718 : /* -------------------------- */
2719 0 : if (compcode != HDFE_COMP_NONE)
2720 : {
2721 0 : snprintf(utlbuf2, sizeof(utlbuf2),
2722 : "%s%s",
2723 : ":\n\t\t\t\tCompressionType=", HDFcomp[compcode]);
2724 :
2725 0 : switch (compcode)
2726 : {
2727 0 : case HDFE_COMP_NBIT:
2728 :
2729 0 : snprintf(compparmbuf, sizeof(compparmbuf),
2730 : "%s%d,%d,%d,%d%s",
2731 : "\n\t\t\t\tCompressionParams=(",
2732 : SWXSwath[sID].compparm[0],
2733 : SWXSwath[sID].compparm[1],
2734 : SWXSwath[sID].compparm[2],
2735 : SWXSwath[sID].compparm[3], ")");
2736 0 : strcat(utlbuf2, compparmbuf);
2737 0 : break;
2738 :
2739 :
2740 0 : case HDFE_COMP_DEFLATE:
2741 :
2742 0 : snprintf(compparmbuf, sizeof(compparmbuf),
2743 : "%s%d",
2744 : "\n\t\t\t\tDeflateLevel=",
2745 : SWXSwath[sID].compparm[0]);
2746 0 : strcat(utlbuf2, compparmbuf);
2747 0 : break;
2748 : }
2749 :
2750 : /* Concatenate compression parameters with compression code */
2751 0 : strcat(utlbuf, utlbuf2);
2752 : }
2753 :
2754 :
2755 : /* Insert field metadata within File Structural Metadata */
2756 : /* ----------------------------------------------------- */
2757 0 : if (strcmp(fieldtype, "Geolocation Fields") == 0)
2758 : {
2759 0 : status = EHinsertmeta(sdInterfaceID, swathname, "s", 3L,
2760 : utlbuf, &numbertype);
2761 : }
2762 : else
2763 : {
2764 0 : status = EHinsertmeta(sdInterfaceID, swathname, "s", 4L,
2765 : utlbuf, &numbertype);
2766 : }
2767 :
2768 : }
2769 : }
2770 :
2771 : /* If all dimensions not found then report error */
2772 : /* --------------------------------------------- */
2773 0 : if (foundAllDim == 0)
2774 : {
2775 0 : HEpush(DFE_GENAPP, "SWdefinefield", __FILE__, __LINE__);
2776 0 : HEreport("Dimension(s): \"%s\" not found (%s).\n",
2777 : utlbuf, fieldname);
2778 0 : status = -1;
2779 : }
2780 :
2781 0 : return (status);
2782 : }
2783 :
2784 :
2785 :
2786 :
2787 : /*----------------------------------------------------------------------------|
2788 : | BEGIN_PROLOG |
2789 : | |
2790 : | FUNCTION: SWdefgeofield |
2791 : | |
2792 : | DESCRIPTION: Defines geolocation field within swath structure (wrapper) |
2793 : | |
2794 : | |
2795 : | Return Value Type Units Description |
2796 : | ============ ====== ========= ===================================== |
2797 : | status intn return status (0) SUCCEED, (-1) FAIL |
2798 : | |
2799 : | INPUTS: |
2800 : | swathID int32 swath structure ID |
2801 : | fieldname char fieldname |
2802 : | dimlist char Dimension list (comma-separated list) |
2803 : | numbertype int32 field type |
2804 : | merge int32 merge code |
2805 : | |
2806 : | OUTPUTS: |
2807 : | None |
2808 : | |
2809 : | NOTES: |
2810 : | |
2811 : | |
2812 : | Date Programmer Description |
2813 : | ====== ============ ================================================= |
2814 : | Jun 96 Joel Gales Original Programmer |
2815 : | |
2816 : | END_PROLOG |
2817 : -----------------------------------------------------------------------------*/
2818 : intn
2819 0 : SWdefgeofield(int32 swathID, const char *fieldname, const char *dimlist,
2820 : int32 numbertype, int32 merge)
2821 : {
2822 : intn status; /* routine return status variable */
2823 :
2824 : /* Call SWdefinefield routine */
2825 : /* -------------------------- */
2826 0 : status = SWdefinefield(swathID, "Geolocation Fields", fieldname, dimlist,
2827 : numbertype, merge);
2828 :
2829 0 : return (status);
2830 : }
2831 :
2832 :
2833 :
2834 :
2835 : /*----------------------------------------------------------------------------|
2836 : | BEGIN_PROLOG |
2837 : | |
2838 : | FUNCTION: SWdefdatafield |
2839 : | |
2840 : | DESCRIPTION: Defines data field within swath structure (wrapper) |
2841 : | |
2842 : | |
2843 : | Return Value Type Units Description |
2844 : | ============ ====== ========= ===================================== |
2845 : | status intn return status (0) SUCCEED, (-1) FAIL |
2846 : | |
2847 : | INPUTS: |
2848 : | swathID int32 swath structure ID |
2849 : | fieldname char fieldname |
2850 : | dimlist char Dimension list (comma-separated list) |
2851 : | numbertype int32 field type |
2852 : | merge int32 merge code |
2853 : | |
2854 : | OUTPUTS: |
2855 : | None |
2856 : | |
2857 : | NOTES: |
2858 : | |
2859 : | |
2860 : | Date Programmer Description |
2861 : | ====== ============ ================================================= |
2862 : | Jun 96 Joel Gales Original Programmer |
2863 : | |
2864 : | END_PROLOG |
2865 : -----------------------------------------------------------------------------*/
2866 : intn
2867 0 : SWdefdatafield(int32 swathID, const char *fieldname, const char *dimlist,
2868 : int32 numbertype, int32 merge)
2869 : {
2870 : intn status; /* routine return status variable */
2871 :
2872 : /* Call SWdefinefield routine */
2873 : /* -------------------------- */
2874 0 : status = SWdefinefield(swathID, "Data Fields", fieldname, dimlist,
2875 : numbertype, merge);
2876 :
2877 0 : return (status);
2878 : }
2879 :
2880 :
2881 :
2882 :
2883 :
2884 : /*----------------------------------------------------------------------------|
2885 : | BEGIN_PROLOG |
2886 : | |
2887 : | FUNCTION: SWwritegeometa |
2888 : | |
2889 : | DESCRIPTION: Defines structural metadata for pre-existing geolocation |
2890 : | field within swath structure |
2891 : | |
2892 : | |
2893 : | Return Value Type Units Description |
2894 : | ============ ====== ========= ===================================== |
2895 : | status intn return status (0) SUCCEED, (-1) FAIL |
2896 : | |
2897 : | INPUTS: |
2898 : | swathID int32 swath structure ID |
2899 : | fieldname char fieldname |
2900 : | dimlist char Dimension list (comma-separated list) |
2901 : | numbertype int32 field type |
2902 : | |
2903 : | |
2904 : | OUTPUTS: |
2905 : | None |
2906 : | |
2907 : | NOTES: |
2908 : | |
2909 : | |
2910 : | Date Programmer Description |
2911 : | ====== ============ ================================================= |
2912 : | Jun 96 Joel Gales Original Programmer |
2913 : | |
2914 : | END_PROLOG |
2915 : -----------------------------------------------------------------------------*/
2916 : intn
2917 0 : SWwritegeometa(int32 swathID, const char *fieldname, const char *dimlist,
2918 : int32 numbertype)
2919 : {
2920 0 : intn status = 0; /* routine return status variable */
2921 :
2922 : int32 sdInterfaceID; /* HDF SDS interface ID */
2923 : int32 dum; /* dummy variable */
2924 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2925 :
2926 : char utlbuf[256];/* Utility buffer */
2927 : char swathname[80]; /* Swath name */
2928 :
2929 0 : status = SWchkswid(swathID, "SWwritegeometa", &dum, &sdInterfaceID,
2930 : &dum);
2931 :
2932 0 : if (status == 0)
2933 : {
2934 : /* Setup and write field metadata */
2935 : /* ------------------------------ */
2936 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%s%s", fieldname, ":", dimlist);
2937 :
2938 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
2939 0 : status = EHinsertmeta(sdInterfaceID, swathname, "s", 3L,
2940 : utlbuf, &numbertype);
2941 : }
2942 :
2943 0 : return (status);
2944 : }
2945 :
2946 :
2947 :
2948 :
2949 : /*----------------------------------------------------------------------------|
2950 : | BEGIN_PROLOG |
2951 : | |
2952 : | FUNCTION: SWwritedatameta |
2953 : | |
2954 : | DESCRIPTION: Defines structural metadata for pre-existing data |
2955 : | field within swath structure |
2956 : | |
2957 : | |
2958 : | Return Value Type Units Description |
2959 : | ============ ====== ========= ===================================== |
2960 : | status intn return status (0) SUCCEED, (-1) FAIL |
2961 : | |
2962 : | INPUTS: |
2963 : | swathID int32 swath structure ID |
2964 : | fieldname char fieldname |
2965 : | dimlist char Dimension list (comma-separated list) |
2966 : | numbertype int32 field type |
2967 : | |
2968 : | |
2969 : | OUTPUTS: |
2970 : | None |
2971 : | |
2972 : | NOTES: |
2973 : | |
2974 : | |
2975 : | Date Programmer Description |
2976 : | ====== ============ ================================================= |
2977 : | Jun 96 Joel Gales Original Programmer |
2978 : | |
2979 : | END_PROLOG |
2980 : -----------------------------------------------------------------------------*/
2981 : intn
2982 0 : SWwritedatameta(int32 swathID, const char *fieldname, const char *dimlist,
2983 : int32 numbertype)
2984 : {
2985 0 : intn status = 0; /* routine return status variable */
2986 :
2987 : int32 sdInterfaceID; /* HDF SDS interface ID */
2988 : int32 dum; /* dummy variable */
2989 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
2990 :
2991 : char utlbuf[256];/* Utility buffer */
2992 : char swathname[80]; /* Swath name */
2993 :
2994 0 : status = SWchkswid(swathID, "SWwritedatameta", &dum, &sdInterfaceID,
2995 : &dum);
2996 :
2997 0 : if (status == 0)
2998 : {
2999 : /* Setup and write field metadata */
3000 : /* ------------------------------ */
3001 0 : snprintf(utlbuf, sizeof(utlbuf), "%s%s%s", fieldname, ":", dimlist);
3002 :
3003 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
3004 0 : status = EHinsertmeta(sdInterfaceID, swathname, "s", 4L,
3005 : utlbuf, &numbertype);
3006 : }
3007 0 : return (status);
3008 : }
3009 :
3010 :
3011 :
3012 : /*----------------------------------------------------------------------------|
3013 : | BEGIN_PROLOG |
3014 : | |
3015 : | FUNCTION: SWwrrdattr |
3016 : | |
3017 : | DESCRIPTION: |
3018 : | |
3019 : | |
3020 : | Return Value Type Units Description |
3021 : | ============ ====== ========= ===================================== |
3022 : | status intn return status (0) SUCCEED, (-1) FAIL |
3023 : | |
3024 : | INPUTS: |
3025 : | swathID int32 swath structure ID |
3026 : | attrname char attribute name |
3027 : | numbertype int32 attribute HDF numbertype |
3028 : | count int32 Number of attribute elements |
3029 : | wrcode char Read/Write Code "w/r" |
3030 : | datbuf void I/O buffer |
3031 : | |
3032 : | OUTPUTS: |
3033 : | datbuf |
3034 : | |
3035 : | NOTES: |
3036 : | |
3037 : | |
3038 : | Date Programmer Description |
3039 : | ====== ============ ================================================= |
3040 : | Jun 96 Joel Gales Original Programmer |
3041 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
3042 : | |
3043 : | END_PROLOG |
3044 : -----------------------------------------------------------------------------*/
3045 : static intn
3046 0 : SWwrrdattr(int32 swathID, const char *attrname, int32 numbertype, int32 count,
3047 : const char *wrcode, VOIDP datbuf)
3048 :
3049 : {
3050 : intn status; /* routine return status variable */
3051 :
3052 : int32 fid; /* HDF-EOS file ID */
3053 : int32 attrVgrpID; /* Swath attribute ID */
3054 : int32 dum; /* dummy variable */
3055 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
3056 :
3057 : /* Check Swath id */
3058 0 : status = SWchkswid(swathID, "SWwrrdattr", &fid, &dum, &dum);
3059 :
3060 0 : if (status == 0)
3061 : {
3062 : /* Get attribute Vgroup ID and call EHattr to perform I/O */
3063 : /* ------------------------------------------------------ */
3064 0 : attrVgrpID = SWXSwath[swathID % idOffset].VIDTable[2];
3065 0 : status = EHattr(fid, attrVgrpID, attrname, numbertype, count,
3066 : wrcode, datbuf);
3067 : }
3068 0 : return (status);
3069 : }
3070 :
3071 :
3072 :
3073 : /*----------------------------------------------------------------------------|
3074 : | BEGIN_PROLOG |
3075 : | |
3076 : | FUNCTION: SWwriteattr |
3077 : | |
3078 : | DESCRIPTION: Writes/updates attribute in a swath. |
3079 : | |
3080 : | |
3081 : | Return Value Type Units Description |
3082 : | ============ ====== ========= ===================================== |
3083 : | status intn return status (0) SUCCEED, (-1) FAIL |
3084 : | |
3085 : | INPUTS: |
3086 : | swathID int32 swath structure ID |
3087 : | attrname char attribute name |
3088 : | numbertype int32 attribute HDF numbertype |
3089 : | count int32 Number of attribute elements |
3090 : | datbuf void I/O buffer |
3091 : | |
3092 : | OUTPUTS: |
3093 : | None |
3094 : | |
3095 : | NOTES: |
3096 : | |
3097 : | |
3098 : | Date Programmer Description |
3099 : | ====== ============ ================================================= |
3100 : | Jun 96 Joel Gales Original Programmer |
3101 : | |
3102 : | END_PROLOG |
3103 : -----------------------------------------------------------------------------*/
3104 : intn
3105 0 : SWwriteattr(int32 swathID, const char *attrname, int32 numbertype, int32 count,
3106 : VOIDP datbuf)
3107 : {
3108 0 : intn status = 0; /* routine return status variable */
3109 :
3110 : /* Call SWwrrdattr routine to write attribute */
3111 : /* ------------------------------------------ */
3112 0 : status = SWwrrdattr(swathID, attrname, numbertype, count, "w", datbuf);
3113 :
3114 0 : return (status);
3115 : }
3116 :
3117 :
3118 :
3119 : /*----------------------------------------------------------------------------|
3120 : | BEGIN_PROLOG |
3121 : | |
3122 : | FUNCTION: SWreadattr |
3123 : | |
3124 : | DESCRIPTION: Reads attribute from a swath. |
3125 : | |
3126 : | |
3127 : | Return Value Type Units Description |
3128 : | ============ ====== ========= ===================================== |
3129 : | status intn return status (0) SUCCEED, (-1) FAIL |
3130 : | |
3131 : | INPUTS: |
3132 : | swathID int32 swath structure ID |
3133 : | attrname char attribute name |
3134 : | |
3135 : | OUTPUTS: |
3136 : | datbuf void I/O buffer |
3137 : | |
3138 : | NOTES: |
3139 : | |
3140 : | |
3141 : | Date Programmer Description |
3142 : | ====== ============ ================================================= |
3143 : | Jun 96 Joel Gales Original Programmer |
3144 : | |
3145 : | END_PROLOG |
3146 : -----------------------------------------------------------------------------*/
3147 : intn
3148 0 : SWreadattr(int32 swathID, const char *attrname, VOIDP datbuf)
3149 : {
3150 0 : intn status = 0; /* routine return status variable */
3151 0 : int32 dum = 0; /* dummy variable */
3152 :
3153 : /* Call SWwrrdattr routine to read attribute */
3154 : /* ----------------------------------------- */
3155 0 : status = SWwrrdattr(swathID, attrname, dum, dum, "r", datbuf);
3156 :
3157 0 : return (status);
3158 : }
3159 :
3160 :
3161 :
3162 :
3163 :
3164 : /*----------------------------------------------------------------------------|
3165 : | BEGIN_PROLOG |
3166 : | |
3167 : | FUNCTION: SWattrinfo |
3168 : | |
3169 : | DESCRIPTION: |
3170 : | |
3171 : | |
3172 : | Return Value Type Units Description |
3173 : | ============ ====== ========= ===================================== |
3174 : | status intn return status (0) SUCCEED, (-1) FAIL |
3175 : | |
3176 : | INPUTS: |
3177 : | swathID int32 swath structure ID |
3178 : | attrname char attribute name |
3179 : | |
3180 : | OUTPUTS: |
3181 : | numbertype int32 attribute HDF numbertype |
3182 : | count int32 Number of attribute elements |
3183 : | |
3184 : | |
3185 : | OUTPUTS: |
3186 : | None |
3187 : | |
3188 : | NOTES: |
3189 : | |
3190 : | |
3191 : | Date Programmer Description |
3192 : | ====== ============ ================================================= |
3193 : | Jun 96 Joel Gales Original Programmer |
3194 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
3195 : | |
3196 : | END_PROLOG |
3197 : -----------------------------------------------------------------------------*/
3198 : intn
3199 0 : SWattrinfo(int32 swathID, const char *attrname, int32 * numbertype, int32 * count)
3200 : {
3201 0 : intn status = 0; /* routine return status variable */
3202 :
3203 : int32 fid; /* HDF-EOS file ID */
3204 : int32 attrVgrpID; /* Swath attribute ID */
3205 : int32 dum; /* dummy variable */
3206 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
3207 :
3208 : /* Check for valid swath ID */
3209 : /* ------------------------ */
3210 0 : status = SWchkswid(swathID, "SWattrinfo", &fid, &dum, &dum);
3211 :
3212 0 : if (status == 0)
3213 : {
3214 : /* Get attribute Vgroup ID and call EHattrinfo */
3215 : /* ------------------------------------------- */
3216 0 : attrVgrpID = SWXSwath[swathID % idOffset].VIDTable[2];
3217 :
3218 0 : status = EHattrinfo(fid, attrVgrpID, attrname, numbertype,
3219 : count);
3220 : }
3221 0 : return (status);
3222 : }
3223 :
3224 :
3225 :
3226 :
3227 :
3228 :
3229 : /*----------------------------------------------------------------------------|
3230 : | BEGIN_PROLOG |
3231 : | |
3232 : | FUNCTION: SWinqattrs |
3233 : | |
3234 : | DESCRIPTION: |
3235 : | |
3236 : | |
3237 : | Return Value Type Units Description |
3238 : | ============ ====== ========= ===================================== |
3239 : | nattr int32 Number of attributes in swath struct |
3240 : | |
3241 : | INPUTS: |
3242 : | swath ID int32 swath structure ID |
3243 : | |
3244 : | OUTPUTS: |
3245 : | attrnames char Attribute names in swath struct |
3246 : | (Comma-separated list) |
3247 : | strbufsize int32 Attributes name list string length |
3248 : | |
3249 : | OUTPUTS: |
3250 : | None |
3251 : | |
3252 : | NOTES: |
3253 : | |
3254 : | |
3255 : | Date Programmer Description |
3256 : | ====== ============ ================================================= |
3257 : | Jun 96 Joel Gales Original Programmer |
3258 : | Oct 96 Joel Gales Initialize nattr |
3259 : | Oct 96 Joel Gales Get Attribute Vgroup ID from external array |
3260 : | |
3261 : | END_PROLOG |
3262 : -----------------------------------------------------------------------------*/
3263 : int32
3264 0 : SWinqattrs(int32 swathID, char *attrnames, int32 * strbufsize)
3265 : {
3266 : intn status; /* routine return status variable */
3267 :
3268 : int32 fid; /* HDF-EOS file ID */
3269 : int32 attrVgrpID; /* Swath attribute ID */
3270 : int32 dum; /* dummy variable */
3271 0 : int32 nattr = 0; /* Number of attributes */
3272 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
3273 :
3274 : /* Check Swath id */
3275 0 : status = SWchkswid(swathID, "SWinqattrs", &fid, &dum, &dum);
3276 :
3277 0 : if (status == 0)
3278 : {
3279 : /* Get attribute Vgroup ID and call EHattrcat */
3280 : /* ------------------------------------------ */
3281 0 : attrVgrpID = SWXSwath[swathID % idOffset].VIDTable[2];
3282 :
3283 0 : nattr = EHattrcat(fid, attrVgrpID, attrnames, strbufsize);
3284 : }
3285 :
3286 0 : return (nattr);
3287 : }
3288 :
3289 : #define REMQUOTE(x) do { \
3290 : char* l_x = x; \
3291 : const size_t l_x_len = strlen(l_x); \
3292 : if (l_x_len >= 2 && l_x[0] == '"' && l_x[l_x_len - 1] == '"') {\
3293 : memmove(l_x, l_x + 1, l_x_len - 2); \
3294 : l_x[l_x_len - 2] = 0; \
3295 : } \
3296 : } while(0)
3297 :
3298 :
3299 : /*----------------------------------------------------------------------------|
3300 : | BEGIN_PROLOG |
3301 : | |
3302 : | FUNCTION: SWinqdims |
3303 : | |
3304 : | DESCRIPTION: Returns dimension names and values defined in swath structure |
3305 : | |
3306 : | |
3307 : | Return Value Type Units Description |
3308 : | ============ ====== ========= ===================================== |
3309 : | nDim int32 Number of defined dimensions |
3310 : | |
3311 : | INPUTS: |
3312 : | swathID int32 swath structure ID |
3313 : | |
3314 : | OUTPUTS: |
3315 : | dimnames char Dimension names (comma-separated) |
3316 : | dims int32 Dimension values |
3317 : | |
3318 : | NOTES: |
3319 : | |
3320 : | |
3321 : | Date Programmer Description |
3322 : | ====== ============ ================================================= |
3323 : | Jun 96 Joel Gales Original Programmer |
3324 : | Aug 96 Joel Gales Make metadata ODL compliant |
3325 : | Feb 97 Joel Gales Set nDim to -1 if status = -1 |
3326 : | |
3327 : | END_PROLOG |
3328 : -----------------------------------------------------------------------------*/
3329 : int32
3330 0 : SWinqdims(int32 swathID, char *dimnames, int32 dims[])
3331 :
3332 : {
3333 : intn status; /* routine return status variable */
3334 :
3335 : int32 fid; /* HDF-EOS file ID */
3336 : int32 sdInterfaceID; /* HDF SDS interface ID */
3337 : int32 swVgrpID; /* Swath root Vgroup ID */
3338 : int32 size; /* Dimension size */
3339 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
3340 0 : int32 nDim = 0; /* Number of dimensions */
3341 :
3342 : char *metabuf; /* Pointer to structural metadata (SM) */
3343 : char *metaptrs[2];/* Pointers to begin and end of SM section */
3344 : char swathname[80]; /* Swath Name */
3345 : char *utlstr; /* Utility string */
3346 :
3347 :
3348 : /* Allocate space for utility string */
3349 : /* --------------------------------- */
3350 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
3351 0 : if(utlstr == NULL)
3352 : {
3353 0 : HEpush(DFE_NOSPACE,"SWinqdims", __FILE__, __LINE__);
3354 0 : return(-1);
3355 : }
3356 :
3357 : /* Check for valid swath id */
3358 0 : status = SWchkswid(swathID, "SWinqdims", &fid, &sdInterfaceID, &swVgrpID);
3359 :
3360 0 : if (status == 0)
3361 : {
3362 : /* If dimension names or sizes are desired ... */
3363 : /* ------------------------------------------- */
3364 0 : if (dimnames != NULL || dims != NULL)
3365 : {
3366 : /* Get swath name */
3367 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
3368 :
3369 : /* Get pointers to "Dimension" section within SM */
3370 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
3371 : "Dimension", metaptrs);
3372 0 : if(metabuf == NULL)
3373 : {
3374 0 : free(utlstr);
3375 0 : return(-1);
3376 : }
3377 : /* If dimension names are desired then "clear" name buffer */
3378 0 : if (dimnames != NULL)
3379 : {
3380 0 : dimnames[0] = 0;
3381 : }
3382 :
3383 :
3384 : /* Begin loop through dimension entries in metadata */
3385 : /* ------------------------------------------------ */
3386 : while (1)
3387 : {
3388 : /* Search for OBJECT string */
3389 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
3390 :
3391 : /* If found within "Dimension" metadata section ... */
3392 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
3393 : {
3394 : /* Get Dimension Name (if desired) */
3395 0 : if (dimnames != NULL)
3396 : {
3397 : /* Check 1st for old meta data then new */
3398 : /* ------------------------------------ */
3399 0 : EHgetmetavalue(metaptrs, "OBJECT", utlstr);
3400 :
3401 : /*
3402 : * If OBJECT value begins with double quote then old
3403 : * metadata, dimension name is OBJECT value.
3404 : * Otherwise search for "DimensionName" string
3405 : */
3406 0 : if (utlstr[0] != '"')
3407 : {
3408 0 : metaptrs[0] =
3409 0 : strstr(metaptrs[0], "\t\t\t\tDimensionName=");
3410 0 : EHgetmetavalue(metaptrs, "DimensionName", utlstr);
3411 : }
3412 :
3413 : /* Strip off double quotes */
3414 : /* ----------------------- */
3415 0 : REMQUOTE(utlstr);
3416 :
3417 : /* If not first name then add comma delimiter */
3418 0 : if (nDim > 0)
3419 : {
3420 0 : strcat(dimnames, ",");
3421 : }
3422 : /* Add dimension name to dimension list */
3423 0 : strcat(dimnames, utlstr);
3424 : }
3425 :
3426 : /* Get Dimension Size (if desired) */
3427 0 : if (dims != NULL)
3428 : {
3429 0 : EHgetmetavalue(metaptrs, "Size", utlstr);
3430 0 : size = atoi(utlstr);
3431 0 : dims[nDim] = size;
3432 : }
3433 : /* Increment number of dimensions */
3434 0 : nDim++;
3435 : }
3436 : else
3437 : /* No more dimensions found */
3438 : {
3439 : break;
3440 : }
3441 : }
3442 0 : free(metabuf);
3443 : }
3444 : }
3445 :
3446 :
3447 : /* Set nDim to -1 if error status exists */
3448 : /* ------------------------------------- */
3449 0 : if (status == -1)
3450 : {
3451 0 : nDim = -1;
3452 : }
3453 0 : free(utlstr);
3454 :
3455 0 : return (nDim);
3456 : }
3457 :
3458 :
3459 :
3460 :
3461 :
3462 : /*----------------------------------------------------------------------------|
3463 : | BEGIN_PROLOG |
3464 : | |
3465 : | FUNCTION: SWinqmaps |
3466 : | |
3467 : | DESCRIPTION: Returns dimension mappings and offsets and increments |
3468 : | |
3469 : | |
3470 : | Return Value Type Units Description |
3471 : | ============ ====== ========= ===================================== |
3472 : | nMap int32 Number of dimension mappings |
3473 : | |
3474 : | INPUTS: |
3475 : | swathID int32 swath structure ID |
3476 : | |
3477 : | OUTPUTS: |
3478 : | dimmaps char dimension mappings (comma-separated) |
3479 : | offset int32 array of offsets |
3480 : | increment int32 array of increments |
3481 : | |
3482 : | NOTES: |
3483 : | |
3484 : | |
3485 : | Date Programmer Description |
3486 : | ====== ============ ================================================= |
3487 : | Jun 96 Joel Gales Original Programmer |
3488 : | Aug 96 Joel Gales Make metadata ODL compliant |
3489 : | Feb 97 Joel Gales Set nMap to -1 if status = -1 |
3490 : | |
3491 : | END_PROLOG |
3492 : -----------------------------------------------------------------------------*/
3493 : int32
3494 0 : SWinqmaps(int32 swathID, char *dimmaps, int32 offset[], int32 increment[])
3495 :
3496 : {
3497 : intn status; /* routine return status variable */
3498 :
3499 : int32 fid; /* HDF-EOS file ID */
3500 : int32 sdInterfaceID; /* HDF SDS interface ID */
3501 : int32 swVgrpID; /* Swath root Vgroup ID */
3502 : int32 off; /* Mapping Offset */
3503 : int32 incr; /* Mapping Increment */
3504 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
3505 0 : int32 nMap = 0; /* Number of mappings */
3506 :
3507 : char *metabuf; /* Pointer to structural metadata (SM) */
3508 : char *metaptrs[2];/* Pointers to begin and end of SM section */
3509 : char swathname[80]; /* Swath Name */
3510 : char *utlstr; /* Utility string */
3511 :
3512 :
3513 : /* Allocate space for utility string */
3514 : /* --------------------------------- */
3515 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
3516 0 : if(utlstr == NULL)
3517 : {
3518 0 : HEpush(DFE_NOSPACE,"SWinqmaps", __FILE__, __LINE__);
3519 0 : return(-1);
3520 : }
3521 :
3522 : /* Check for valid swath id */
3523 0 : status = SWchkswid(swathID, "SWinqmaps", &fid, &sdInterfaceID, &swVgrpID);
3524 0 : if (status == 0)
3525 : {
3526 : /* If mapping names or offsets or increments desired ... */
3527 : /* ----------------------------------------------------- */
3528 0 : if (dimmaps != NULL || offset != NULL || increment != NULL)
3529 : {
3530 :
3531 : /* Get swath name */
3532 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
3533 :
3534 : /* Get pointers to "DimensionMap" section within SM */
3535 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
3536 : "DimensionMap", metaptrs);
3537 0 : if(metabuf == NULL)
3538 : {
3539 0 : free(utlstr);
3540 0 : return(-1);
3541 : }
3542 : /* If mapping names are desired then "clear" name buffer */
3543 0 : if (dimmaps != NULL)
3544 : {
3545 0 : dimmaps[0] = 0;
3546 : }
3547 :
3548 : /* Begin loop through mapping entries in metadata */
3549 : /* ---------------------------------------------- */
3550 : while (1)
3551 : {
3552 : /* Search for OBJECT string */
3553 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
3554 :
3555 : /* If found within "DimensionMap" metadata section ... */
3556 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
3557 : {
3558 : /* Get Geo & Data Dimensions (if desired) */
3559 0 : if (dimmaps != NULL)
3560 : {
3561 : /* Get Geo Dim, remove quotes, add "/" */
3562 0 : EHgetmetavalue(metaptrs, "GeoDimension", utlstr);
3563 0 : REMQUOTE(utlstr);
3564 0 : strcat(utlstr, "/");
3565 :
3566 : /* If not first map then add comma delimiter. */
3567 0 : if (nMap > 0)
3568 : {
3569 0 : strcat(dimmaps, ",");
3570 : }
3571 :
3572 : /* Add to map list */
3573 0 : strcat(dimmaps, utlstr);
3574 :
3575 : /* Get Data Dim, remove quotes */
3576 0 : EHgetmetavalue(metaptrs, "DataDimension", utlstr);
3577 0 : REMQUOTE(utlstr);
3578 :
3579 : /* Add to map list */
3580 0 : strcat(dimmaps, utlstr);
3581 : }
3582 :
3583 : /* Get Offset (if desired) */
3584 0 : if (offset != NULL)
3585 : {
3586 0 : EHgetmetavalue(metaptrs, "Offset", utlstr);
3587 0 : off = atoi(utlstr);
3588 0 : offset[nMap] = off;
3589 : }
3590 :
3591 : /* Get Increment (if desired) */
3592 0 : if (increment != NULL)
3593 : {
3594 0 : EHgetmetavalue(metaptrs, "Increment", utlstr);
3595 0 : incr = atoi(utlstr);
3596 0 : increment[nMap] = incr;
3597 : }
3598 :
3599 : /* Increment number of maps */
3600 0 : nMap++;
3601 : }
3602 : else
3603 : /* No more mappings found */
3604 : {
3605 : break;
3606 : }
3607 : }
3608 0 : free(metabuf);
3609 : }
3610 : }
3611 :
3612 :
3613 : /* Set nMap to -1 if error status exists */
3614 : /* ------------------------------------- */
3615 0 : if (status == -1)
3616 : {
3617 0 : nMap = -1;
3618 : }
3619 0 : free(utlstr);
3620 :
3621 0 : return (nMap);
3622 : }
3623 :
3624 :
3625 :
3626 :
3627 :
3628 : /*----------------------------------------------------------------------------|
3629 : | BEGIN_PROLOG |
3630 : | |
3631 : | FUNCTION: SWinqidxmaps |
3632 : | |
3633 : | DESCRIPTION: Returns l_indexed mappings and l_index sizes |
3634 : | |
3635 : | |
3636 : | Return Value Type Units Description |
3637 : | ============ ====== ========= ===================================== |
3638 : | nMap int32 Number of l_indexed dimension mappings |
3639 : | |
3640 : | INPUTS: |
3641 : | swathID int32 swath structure ID |
3642 : | |
3643 : | OUTPUTS: |
3644 : | idxmaps char l_indexed dimension mappings |
3645 : | (comma-separated) |
3646 : | idxsizes int32 Number of elements in each mapping |
3647 : | |
3648 : | |
3649 : | NOTES: |
3650 : | |
3651 : | |
3652 : | Date Programmer Description |
3653 : | ====== ============ ================================================= |
3654 : | Jun 96 Joel Gales Original Programmer |
3655 : | Aug 96 Joel Gales Make metadata ODL compliant |
3656 : | Feb 97 Joel Gales Set nMap to -1 if status = -1 |
3657 : | |
3658 : | END_PROLOG |
3659 : -----------------------------------------------------------------------------*/
3660 : int32
3661 0 : SWinqidxmaps(int32 swathID, char *idxmaps, int32 idxsizes[])
3662 :
3663 : {
3664 : intn status; /* routine return status variable */
3665 :
3666 : int32 fid; /* HDF-EOS file ID */
3667 : int32 sdInterfaceID; /* HDF SDS interface ID */
3668 : int32 swVgrpID; /* Swath root Vgroup ID */
3669 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
3670 0 : int32 nMap = 0; /* Number of mappings */
3671 :
3672 : char *metabuf; /* Pointer to structural metadata (SM) */
3673 : char *metaptrs[2];/* Pointers to begin and end of SM section */
3674 : char swathname[80]; /* Swath Name */
3675 : char *utlstr; /* Utility string */
3676 : char *slash; /* Pointer to slash */
3677 :
3678 :
3679 : /* Allocate space for utility string */
3680 : /* --------------------------------- */
3681 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
3682 0 : if(utlstr == NULL)
3683 : {
3684 0 : HEpush(DFE_NOSPACE,"SWinqidxmaps", __FILE__, __LINE__);
3685 0 : return(-1);
3686 : }
3687 : /* Check for valid swath id */
3688 0 : status = SWchkswid(swathID, "SWinqidxmaps", &fid,
3689 : &sdInterfaceID, &swVgrpID);
3690 :
3691 0 : if (status == 0)
3692 : {
3693 : /* If mapping names or l_index sizes desired ... */
3694 : /* ------------------------------------------- */
3695 0 : if (idxmaps != NULL || idxsizes != NULL)
3696 : {
3697 : /* Get swath name */
3698 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
3699 :
3700 : /* Get pointers to "IndexDimensionMap" section within SM */
3701 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
3702 : "IndexDimensionMap", metaptrs);
3703 0 : if(metabuf == NULL)
3704 : {
3705 0 : free(utlstr);
3706 0 : return(-1);
3707 : }
3708 : /* If mapping names are desired then "clear" name buffer */
3709 0 : if (idxmaps != NULL)
3710 : {
3711 0 : idxmaps[0] = 0;
3712 : }
3713 :
3714 : /* Begin loop through mapping entries in metadata */
3715 : /* ---------------------------------------------- */
3716 : while (1)
3717 : {
3718 : /* Search for OBJECT string */
3719 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
3720 :
3721 : /* If found within "IndexDimensionMap" metadata section ... */
3722 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
3723 : {
3724 : /* Get Geo & Data Dimensions and # of indices */
3725 0 : if (idxmaps != NULL)
3726 : {
3727 : /* Get Geo Dim, remove quotes, add "/" */
3728 0 : EHgetmetavalue(metaptrs, "GeoDimension", utlstr);
3729 0 : REMQUOTE(utlstr);
3730 0 : strcat(utlstr, "/");
3731 :
3732 : /* If not first map then add comma delimiter. */
3733 0 : if (nMap > 0)
3734 : {
3735 0 : strcat(idxmaps, ",");
3736 : }
3737 :
3738 : /* Add to map list */
3739 0 : strcat(idxmaps, utlstr);
3740 :
3741 :
3742 : /* Get Index size (if desired) */
3743 0 : if (idxsizes != NULL)
3744 : {
3745 : /* Parse off geo dimension and find its size */
3746 0 : slash = strchr(utlstr, '/');
3747 0 : *slash = 0;
3748 0 : idxsizes[nMap] = SWdiminfo(swathID, utlstr);
3749 : }
3750 :
3751 :
3752 : /* Get Data Dim, remove quotes */
3753 0 : EHgetmetavalue(metaptrs, "DataDimension", utlstr);
3754 0 : REMQUOTE(utlstr);
3755 :
3756 : /* Add to map list */
3757 0 : strcat(idxmaps, utlstr);
3758 : }
3759 :
3760 : /* Increment number of maps */
3761 0 : nMap++;
3762 : }
3763 : else
3764 : /* No more mappings found */
3765 : {
3766 : break;
3767 : }
3768 : }
3769 0 : free(metabuf);
3770 : }
3771 : }
3772 :
3773 :
3774 : /* Set nMap to -1 if error status exists */
3775 : /* ------------------------------------- */
3776 0 : if (status == -1)
3777 : {
3778 0 : nMap = -1;
3779 : }
3780 0 : free(utlstr);
3781 :
3782 0 : return (nMap);
3783 : }
3784 :
3785 :
3786 :
3787 :
3788 : /*----------------------------------------------------------------------------|
3789 : | BEGIN_PROLOG |
3790 : | |
3791 : | FUNCTION: SWinqfields |
3792 : | |
3793 : | DESCRIPTION: Returns fieldnames, ranks and numbertypes defined in swath. |
3794 : | |
3795 : | |
3796 : | Return Value Type Units Description |
3797 : | ============ ====== ========= ===================================== |
3798 : | nFld int32 Number of (geo/data) fields in swath |
3799 : | |
3800 : | INPUTS: |
3801 : | swathID int32 swath structure ID |
3802 : | fieldtype char field type (geo or data) |
3803 : | |
3804 : | |
3805 : | OUTPUTS: |
3806 : | fieldlist char Field names (comma-separated) |
3807 : | rank int32 Array of ranks |
3808 : | numbertype int32 Array of HDF number types |
3809 : | |
3810 : | NOTES: |
3811 : | |
3812 : | |
3813 : | Date Programmer Description |
3814 : | ====== ============ ================================================= |
3815 : | Jun 96 Joel Gales Original Programmer |
3816 : | Aug 96 Joel Gales Make metadata ODL compliant |
3817 : | Feb 97 Joel Gales Set nFld to -1 if status = -1 |
3818 : | |
3819 : | END_PROLOG |
3820 : -----------------------------------------------------------------------------*/
3821 : static int32
3822 0 : SWinqfields(int32 swathID, const char *fieldtype, char *fieldlist, int32 rank[],
3823 : int32 numbertype[])
3824 :
3825 : {
3826 : intn status; /* routine return status variable */
3827 :
3828 : int32 fid; /* HDF-EOS file ID */
3829 : int32 sdInterfaceID; /* HDF SDS interface ID */
3830 : int32 swVgrpID; /* Swath root Vgroup ID */
3831 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
3832 0 : int32 nFld = 0; /* Number of mappings */
3833 : int32 slen[8]; /* String length array */
3834 :
3835 : char *metabuf; /* Pointer to structural metadata (SM) */
3836 : char *metaptrs[2];/* Pointers to begin and end of SM section */
3837 : char swathname[80]; /* Swath Name */
3838 : char *utlstr; /* Utility string */
3839 : char *utlstr2; /* Utility string 2 */
3840 : char *ptr[8]; /* String pointer array */
3841 :
3842 :
3843 : /* Allocate space for utility string */
3844 : /* --------------------------------- */
3845 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
3846 0 : if(utlstr == NULL)
3847 : {
3848 0 : HEpush(DFE_NOSPACE,"SWinqfields", __FILE__, __LINE__);
3849 0 : return(-1);
3850 : }
3851 :
3852 0 : utlstr2 = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
3853 0 : if(utlstr2 == NULL)
3854 : {
3855 0 : HEpush(DFE_NOSPACE,"SWinqfields", __FILE__, __LINE__);
3856 0 : free(utlstr);
3857 0 : return(-1);
3858 : }
3859 :
3860 : /* Check for valid swath id */
3861 0 : status = SWchkswid(swathID, "SWinqfields",
3862 : &fid, &sdInterfaceID, &swVgrpID);
3863 :
3864 0 : if (status == 0)
3865 : {
3866 : /* If field names, ranks, or number types desired ... */
3867 : /* --------------------------------------------------- */
3868 0 : if (fieldlist != NULL || rank != NULL || numbertype != NULL)
3869 : {
3870 : /* Get swath name */
3871 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
3872 :
3873 : /* Get pointers to "GeoField" or "DataField" section within SM */
3874 0 : if (strcmp(fieldtype, "Geolocation Fields") == 0)
3875 : {
3876 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
3877 : "GeoField", metaptrs);
3878 0 : if(metabuf == NULL)
3879 : {
3880 0 : free(utlstr);
3881 0 : free(utlstr2);
3882 0 : return(-1);
3883 : }
3884 0 : strcpy(utlstr2, "GeoFieldName");
3885 : }
3886 : else
3887 : {
3888 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
3889 : "DataField", metaptrs);
3890 0 : if(metabuf == NULL)
3891 : {
3892 0 : free(utlstr);
3893 0 : free(utlstr2);
3894 0 : return(-1);
3895 : }
3896 0 : strcpy(utlstr2, "DataFieldName");
3897 : }
3898 :
3899 :
3900 : /* If field names are desired then "clear" name buffer */
3901 0 : if (fieldlist != NULL)
3902 : {
3903 0 : fieldlist[0] = 0;
3904 : }
3905 :
3906 :
3907 : /* Begin loop through mapping entries in metadata */
3908 : /* ---------------------------------------------- */
3909 : while (1)
3910 : {
3911 : /* Search for OBJECT string */
3912 0 : metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT=");
3913 :
3914 : /* If found within "Geo" or "Data" Field metadata section .. */
3915 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
3916 : {
3917 : /* Get Fieldnames (if desired) */
3918 0 : if (fieldlist != NULL)
3919 : {
3920 : /* Check 1st for old meta data then new */
3921 : /* ------------------------------------ */
3922 0 : EHgetmetavalue(metaptrs, "OBJECT", utlstr);
3923 :
3924 : /*
3925 : * If OBJECT value begins with double quote then old
3926 : * metadata, field name is OBJECT value. Otherwise
3927 : * search for "GeoFieldName" or "DataFieldName"
3928 : * string
3929 : */
3930 :
3931 0 : if (utlstr[0] != '"')
3932 : {
3933 0 : strcpy(utlstr, "\t\t\t\t");
3934 0 : strcat(utlstr, utlstr2);
3935 0 : strcat(utlstr, "=");
3936 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
3937 0 : EHgetmetavalue(metaptrs, utlstr2, utlstr);
3938 : }
3939 :
3940 : /* Strip off double quotes */
3941 : /* ----------------------- */
3942 0 : REMQUOTE(utlstr);
3943 :
3944 :
3945 : /* Add to fieldlist */
3946 : /* ---------------- */
3947 0 : if (nFld > 0)
3948 : {
3949 0 : strcat(fieldlist, ",");
3950 : }
3951 0 : strcat(fieldlist, utlstr);
3952 :
3953 : }
3954 : /* Get Numbertype */
3955 0 : if (numbertype != NULL)
3956 : {
3957 0 : EHgetmetavalue(metaptrs, "DataType", utlstr);
3958 0 : numbertype[nFld] = EHnumstr(utlstr);
3959 : }
3960 : /*
3961 : * Get Rank (if desired) by counting # of dimensions in
3962 : * "DimList" string
3963 : */
3964 0 : if (rank != NULL)
3965 : {
3966 0 : EHgetmetavalue(metaptrs, "DimList", utlstr);
3967 0 : rank[nFld] = EHparsestr(utlstr, ',', ptr, slen);
3968 : }
3969 : /* Increment number of fields */
3970 0 : nFld++;
3971 : }
3972 : else
3973 : /* No more fields found */
3974 : {
3975 : break;
3976 : }
3977 : }
3978 0 : free(metabuf);
3979 : }
3980 : }
3981 :
3982 : /* Set nFld to -1 if error status exists */
3983 : /* ------------------------------------- */
3984 0 : if (status == -1)
3985 : {
3986 0 : nFld = -1;
3987 : }
3988 :
3989 0 : free(utlstr);
3990 0 : free(utlstr2);
3991 :
3992 0 : return (nFld);
3993 : }
3994 :
3995 :
3996 :
3997 :
3998 : /*----------------------------------------------------------------------------|
3999 : | BEGIN_PROLOG |
4000 : | |
4001 : | FUNCTION: SWinqgeofields |
4002 : | |
4003 : | DESCRIPTION: Inquires about geo fields in swath |
4004 : | |
4005 : | |
4006 : | Return Value Type Units Description |
4007 : | ============ ====== ========= ===================================== |
4008 : | nflds int32 Number of geo fields in swath |
4009 : | |
4010 : | INPUTS: |
4011 : | swathID int32 swath structure ID |
4012 : | |
4013 : | OUTPUTS: |
4014 : | fieldlist char Field names (comma-separated) |
4015 : | rank int32 Array of ranks |
4016 : | numbertype int32 Array of HDF number types |
4017 : | |
4018 : | NOTES: |
4019 : | |
4020 : | |
4021 : | Date Programmer Description |
4022 : | ====== ============ ================================================= |
4023 : | Jun 96 Joel Gales Original Programmer |
4024 : | |
4025 : | END_PROLOG |
4026 : -----------------------------------------------------------------------------*/
4027 : int32
4028 0 : SWinqgeofields(int32 swathID, char *fieldlist, int32 rank[],
4029 : int32 numbertype[])
4030 : {
4031 :
4032 : int32 nflds; /* Number of Geolocation fields */
4033 :
4034 : /* Call "SWinqfields" routine */
4035 : /* -------------------------- */
4036 0 : nflds = SWinqfields(swathID, "Geolocation Fields", fieldlist, rank,
4037 : numbertype);
4038 :
4039 0 : return (nflds);
4040 :
4041 : }
4042 :
4043 :
4044 :
4045 :
4046 : /*----------------------------------------------------------------------------|
4047 : | BEGIN_PROLOG |
4048 : | |
4049 : | FUNCTION: SWinqdatafields |
4050 : | |
4051 : | DESCRIPTION: Inquires about data fields in swath |
4052 : | |
4053 : | |
4054 : | Return Value Type Units Description |
4055 : | ============ ====== ========= ===================================== |
4056 : | nflds int32 Number of data fields in swath |
4057 : | |
4058 : | INPUTS: |
4059 : | swathID int32 swath structure ID |
4060 : | |
4061 : | OUTPUTS: |
4062 : | fieldlist char Field names (comma-separated) |
4063 : | rank int32 Array of ranks |
4064 : | numbertype int32 Array of HDF number types |
4065 : | |
4066 : | NOTES: |
4067 : | |
4068 : | |
4069 : | Date Programmer Description |
4070 : | ====== ============ ================================================= |
4071 : | Jun 96 Joel Gales Original Programmer |
4072 : | |
4073 : | END_PROLOG |
4074 : -----------------------------------------------------------------------------*/
4075 : int32
4076 0 : SWinqdatafields(int32 swathID, char *fieldlist, int32 rank[],
4077 : int32 numbertype[])
4078 : {
4079 :
4080 : int32 nflds; /* Number of Data fields */
4081 :
4082 : /* Call "SWinqfields" routine */
4083 : /* -------------------------- */
4084 0 : nflds = SWinqfields(swathID, "Data Fields", fieldlist, rank,
4085 : numbertype);
4086 :
4087 0 : return (nflds);
4088 :
4089 : }
4090 :
4091 :
4092 :
4093 :
4094 : /*----------------------------------------------------------------------------|
4095 : | BEGIN_PROLOG |
4096 : | |
4097 : | FUNCTION: SWnentries |
4098 : | |
4099 : | DESCRIPTION: Returns number of entries and string buffer size |
4100 : | |
4101 : | |
4102 : | Return Value Type Units Description |
4103 : | ============ ====== ========= ===================================== |
4104 : | nEntries int32 Number of entries |
4105 : | |
4106 : | INPUTS: |
4107 : | swathID int32 swath structure ID |
4108 : | entrycode int32 Entry code |
4109 : | HDFE_NENTDIM (0) |
4110 : | HDFE_NENTMAP (1) |
4111 : | HDFE_NENTIMAP (2) |
4112 : | HDFE_NENTGFLD (3) |
4113 : | HDFE_NENTDFLD (4) |
4114 : | |
4115 : | |
4116 : | OUTPUTS: |
4117 : | strbufsize int32 Length of comma-separated list |
4118 : | (Does not include null-terminator |
4119 : | |
4120 : | NOTES: |
4121 : | |
4122 : | |
4123 : | Date Programmer Description |
4124 : | ====== ============ ================================================= |
4125 : | Jun 96 Joel Gales Original Programmer |
4126 : | Aug 96 Joel Gales Make metadata ODL compliant |
4127 : | Feb 97 Joel Gales Set nEntries to -1 if status = -1 |
4128 : | |
4129 : | END_PROLOG |
4130 : -----------------------------------------------------------------------------*/
4131 : int32
4132 0 : SWnentries(int32 swathID, int32 entrycode, int32 * strbufsize)
4133 :
4134 : {
4135 : intn status; /* routine return status variable */
4136 : intn i; /* Loop index */
4137 :
4138 : int32 fid; /* HDF-EOS file ID */
4139 : int32 sdInterfaceID; /* HDF SDS interface ID */
4140 : int32 swVgrpID; /* Swath root Vgroup ID */
4141 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
4142 0 : int32 nEntries = 0; /* Number of entries */
4143 : int32 metaflag; /* Old (0), New (1) metadata flag) */
4144 0 : int32 nVal = 0; /* Number of strings to search for */
4145 :
4146 0 : char *metabuf = NULL; /* Pointer to structural metadata (SM) */
4147 : char *metaptrs[2]; /* Pointers to begin and end of SM section */
4148 : char swathname[80]; /* Swath Name */
4149 : char *utlstr; /* Utility string */
4150 : char valName[2][32]; /* Strings to search for */
4151 :
4152 : /* Allocate space for utility string */
4153 : /* --------------------------------- */
4154 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
4155 0 : if(utlstr == NULL)
4156 : {
4157 0 : HEpush(DFE_NOSPACE,"SWnemtries", __FILE__, __LINE__);
4158 0 : return(-1);
4159 : }
4160 : /* Check for valid swath id */
4161 : /* ------------------------ */
4162 0 : status = SWchkswid(swathID, "SWnentries", &fid, &sdInterfaceID, &swVgrpID);
4163 :
4164 0 : if (status == 0)
4165 : {
4166 : /* Get swath name */
4167 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
4168 :
4169 : /* Zero out string buffer size */
4170 0 : *strbufsize = 0;
4171 :
4172 :
4173 : /*
4174 : * Get pointer to relevant section within SM and Get names of
4175 : * metadata strings to inquire about
4176 : */
4177 0 : switch (entrycode)
4178 : {
4179 0 : case HDFE_NENTDIM:
4180 : /* Dimensions */
4181 : {
4182 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
4183 : "Dimension", metaptrs);
4184 0 : if(metabuf == NULL)
4185 : {
4186 0 : free(utlstr);
4187 0 : return(-1);
4188 : }
4189 0 : nVal = 1;
4190 0 : strcpy(&valName[0][0], "DimensionName");
4191 : }
4192 0 : break;
4193 :
4194 0 : case HDFE_NENTMAP:
4195 : /* Dimension Maps */
4196 : {
4197 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
4198 : "DimensionMap", metaptrs);
4199 0 : if(metabuf == NULL)
4200 : {
4201 0 : free(utlstr);
4202 0 : return(-1);
4203 : }
4204 0 : nVal = 2;
4205 0 : strcpy(&valName[0][0], "GeoDimension");
4206 0 : strcpy(&valName[1][0], "DataDimension");
4207 : }
4208 0 : break;
4209 :
4210 0 : case HDFE_NENTIMAP:
4211 : /* Indexed Dimension Maps */
4212 : {
4213 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
4214 : "IndexDimensionMap", metaptrs);
4215 0 : if(metabuf == NULL)
4216 : {
4217 0 : free(utlstr);
4218 0 : return(-1);
4219 : }
4220 0 : nVal = 2;
4221 0 : strcpy(&valName[0][0], "GeoDimension");
4222 0 : strcpy(&valName[1][0], "DataDimension");
4223 : }
4224 0 : break;
4225 :
4226 0 : case HDFE_NENTGFLD:
4227 : /* Geolocation Fields */
4228 : {
4229 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
4230 : "GeoField", metaptrs);
4231 0 : if(metabuf == NULL)
4232 : {
4233 0 : free(utlstr);
4234 0 : return(-1);
4235 : }
4236 0 : nVal = 1;
4237 0 : strcpy(&valName[0][0], "GeoFieldName");
4238 : }
4239 0 : break;
4240 :
4241 0 : case HDFE_NENTDFLD:
4242 : /* Data Fields */
4243 : {
4244 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
4245 : "DataField", metaptrs);
4246 0 : if(metabuf == NULL)
4247 : {
4248 0 : free(utlstr);
4249 0 : return(-1);
4250 : }
4251 0 : nVal = 1;
4252 0 : strcpy(&valName[0][0], "DataFieldName");
4253 : }
4254 0 : break;
4255 : }
4256 :
4257 :
4258 : /*
4259 : * Check for presence of 'GROUP="' string If found then old metadata,
4260 : * search on OBJECT string
4261 : */
4262 0 : if (metabuf)
4263 : {
4264 0 : metaflag = (strstr(metabuf, "GROUP=\"") == NULL) ? 1 : 0;
4265 0 : if (metaflag == 0)
4266 : {
4267 0 : nVal = 1;
4268 0 : strcpy(&valName[0][0], "\t\tOBJECT");
4269 : }
4270 :
4271 :
4272 : /* Begin loop through entries in metadata */
4273 : /* -------------------------------------- */
4274 : while (1)
4275 : {
4276 : /* Search for first string */
4277 0 : strcpy(utlstr, &valName[0][0]);
4278 0 : strcat(utlstr, "=");
4279 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
4280 :
4281 : /* If found within relevant metadata section ... */
4282 0 : if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL)
4283 : {
4284 0 : for (i = 0; i < nVal; i++)
4285 : {
4286 : /*
4287 : * Get all string values Don't count quotes
4288 : */
4289 0 : EHgetmetavalue(metaptrs, &valName[i][0], utlstr);
4290 0 : *strbufsize += (int32)strlen(utlstr) - 2;
4291 : }
4292 : /* Increment number of entries */
4293 0 : nEntries++;
4294 :
4295 : /* Go to end of OBJECT */
4296 0 : metaptrs[0] = strstr(metaptrs[0], "END_OBJECT");
4297 : }
4298 : else
4299 : /* No more entries found */
4300 : {
4301 : break;
4302 : }
4303 : }
4304 0 : free(metabuf);
4305 : }
4306 :
4307 :
4308 : /* Count comma separators & slashes (if mappings) */
4309 : /* ---------------------------------------------- */
4310 0 : if (nEntries > 0)
4311 : {
4312 0 : *strbufsize += nEntries - 1;
4313 0 : *strbufsize += (nVal - 1) * nEntries;
4314 : }
4315 : }
4316 :
4317 :
4318 : /* Set nEntries to -1 if error status exists */
4319 : /* ----------------------------------------- */
4320 0 : if (status == -1)
4321 0 : nEntries = -1;
4322 :
4323 0 : free(utlstr);
4324 :
4325 0 : return (nEntries);
4326 : }
4327 :
4328 :
4329 :
4330 :
4331 :
4332 : /*----------------------------------------------------------------------------|
4333 : | BEGIN_PROLOG |
4334 : | |
4335 : | FUNCTION: SWinqswath |
4336 : | |
4337 : | DESCRIPTION: Returns number and names of swath structures in file |
4338 : | |
4339 : | |
4340 : | Return Value Type Units Description |
4341 : | ============ ====== ========= ===================================== |
4342 : | nSwath int32 Number of swath structures in file |
4343 : | |
4344 : | INPUTS: |
4345 : | filename char HDF-EOS filename |
4346 : | |
4347 : | OUTPUTS: |
4348 : | swathlist char List of swath names (comma-separated) |
4349 : | strbufsize int32 Length of swathlist |
4350 : | |
4351 : | NOTES: |
4352 : | |
4353 : | |
4354 : | Date Programmer Description |
4355 : | ====== ============ ================================================= |
4356 : | Jun 96 Joel Gales Original Programmer |
4357 : | |
4358 : | END_PROLOG |
4359 : -----------------------------------------------------------------------------*/
4360 : int32
4361 4 : SWinqswath(const char *filename, char *swathlist, int32 * strbufsize)
4362 : {
4363 : int32 nSwath; /* Number of swath structures in file */
4364 :
4365 : /* Call "EHinquire" routine */
4366 : /* ------------------------ */
4367 4 : nSwath = EHinquire(filename, "SWATH", swathlist, strbufsize);
4368 :
4369 4 : return (nSwath);
4370 : }
4371 :
4372 :
4373 :
4374 : /*----------------------------------------------------------------------------|
4375 : | BEGIN_PROLOG |
4376 : | |
4377 : | FUNCTION: SW1dfldsrch |
4378 : | |
4379 : | DESCRIPTION: Retrieves information about a 1D field |
4380 : | |
4381 : | |
4382 : | Return Value Type Units Description |
4383 : | ============ ====== ========= ===================================== |
4384 : | status intn return status (0) SUCCEED, (-1) FAIL |
4385 : | |
4386 : | INPUTS: |
4387 : | fid int32 HDF-EOS file ID |
4388 : | swathID int32 swath structure ID |
4389 : | fieldname const char field name |
4390 : | access const char Access code (w/r) |
4391 : | |
4392 : | |
4393 : | OUTPUTS: |
4394 : | vgidout int32 Field (geo/data) vgroup ID |
4395 : | vdataIDout int32 Field Vdata ID |
4396 : | fldtype int32 Field type |
4397 : | |
4398 : | NOTES: |
4399 : | |
4400 : | |
4401 : | Date Programmer Description |
4402 : | ====== ============ ================================================= |
4403 : | Jun 96 Joel Gales Original Programmer |
4404 : | |
4405 : | END_PROLOG |
4406 : -----------------------------------------------------------------------------*/
4407 : static intn
4408 0 : SW1dfldsrch(int32 fid, int32 swathID, const char *fieldname, const char *i_access,
4409 : int32 * vgidout, int32 * vdataIDout, int32 * fldtype)
4410 :
4411 : {
4412 0 : intn status = 0; /* routine return status variable */
4413 :
4414 : int32 sID; /* SwathID - offset */
4415 : int32 vgid; /* Swath Geo or Data Vgroup ID */
4416 : int32 vdataID; /* 1d field vdata */
4417 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
4418 :
4419 :
4420 : /* Compute "reduced" swath ID */
4421 : /* -------------------------- */
4422 0 : sID = swathID % idOffset;
4423 :
4424 :
4425 : /* Get Geolocation Vgroup id and 1D field name Vdata id */
4426 : /* ---------------------------------------------------- */
4427 0 : vgid = SWXSwath[sID].VIDTable[0];
4428 0 : vdataID = EHgetid(fid, vgid, fieldname, 1, i_access);
4429 0 : *fldtype = 0;
4430 :
4431 :
4432 : /*
4433 : * If name not found in Geolocation Vgroup then detach Geolocation Vgroup
4434 : * and search in Data Vgroup
4435 : */
4436 0 : if (vdataID == -1)
4437 : {
4438 0 : vgid = SWXSwath[sID].VIDTable[1];;
4439 0 : vdataID = EHgetid(fid, vgid, fieldname, 1, i_access);
4440 0 : *fldtype = 1;
4441 :
4442 : /* If field also not found in Data Vgroup then set error status */
4443 : /* ------------------------------------------------------------ */
4444 0 : if (vdataID == -1)
4445 : {
4446 0 : status = -1;
4447 0 : vgid = -1;
4448 0 : vdataID = -1;
4449 : }
4450 : }
4451 0 : *vgidout = vgid;
4452 0 : *vdataIDout = vdataID;
4453 :
4454 0 : return (status);
4455 : }
4456 :
4457 :
4458 :
4459 :
4460 :
4461 : /*----------------------------------------------------------------------------|
4462 : | BEGIN_PROLOG |
4463 : | |
4464 : | FUNCTION: SWSDfldsrch |
4465 : | |
4466 : | DESCRIPTION: Retrieves information SDS field |
4467 : | |
4468 : | |
4469 : | Return Value Type Units Description |
4470 : | ============ ====== ========= ===================================== |
4471 : | status intn return status (0) SUCCEED, (-1) FAIL |
4472 : | |
4473 : | INPUTS: |
4474 : | swathID int32 swath structure ID |
4475 : | sdInterfaceID int32 SD interface ID |
4476 : | fieldname const char field name |
4477 : | |
4478 : | |
4479 : | OUTPUTS: |
4480 : | sdid int32 SD element ID |
4481 : | rankSDS int32 Rank of SDS |
4482 : | rankFld int32 True rank of field (merging) |
4483 : | offset int32 Offset of field within merged field |
4484 : | dims int32 Dimensions of field |
4485 : | solo int32 Solo field flag |
4486 : | |
4487 : | NOTES: |
4488 : | |
4489 : | |
4490 : | Date Programmer Description |
4491 : | ====== ============ ================================================= |
4492 : | Jun 96 Joel Gales Original Programmer |
4493 : | Aug 96 Joel Gales Make metadata ODL compliant |
4494 : | |
4495 : | END_PROLOG |
4496 : -----------------------------------------------------------------------------*/
4497 : static intn
4498 0 : SWSDfldsrch(int32 swathID, int32 sdInterfaceID, const char *fieldname,
4499 : int32 * sdid, int32 * rankSDS, int32 * rankFld, int32 * offset,
4500 : int32 dims[], int32 * solo)
4501 : {
4502 : intn i; /* Loop index */
4503 0 : intn status = -1;/* routine return status variable */
4504 :
4505 : int32 sID; /* SwathID - offset */
4506 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
4507 : int32 dum; /* Dummy variable */
4508 : int32 dums[128]; /* Dummy array */
4509 : int32 attrIndex; /* Attribute l_index */
4510 :
4511 : char name[2048]; /* Merged-Field Names */
4512 : char swathname[80]; /* Swath Name */
4513 : char *utlstr; /* Utility string */
4514 : char *metabuf; /* Pointer to structural metadata (SM) */
4515 : char *metaptrs[2];/* Pointers to begin and end of SM section */
4516 : char *oldmetaptr; /* Pointer within SM section */
4517 :
4518 :
4519 : /* Allocate space for utility string */
4520 : /* --------------------------------- */
4521 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
4522 0 : if(utlstr == NULL)
4523 : {
4524 0 : HEpush(DFE_NOSPACE,"SWSDfldsrch", __FILE__, __LINE__);
4525 0 : return(-1);
4526 : }
4527 : /* Set solo flag to 0 (no) */
4528 : /* ----------------------- */
4529 0 : *solo = 0;
4530 :
4531 :
4532 : /* Compute "reduced" swath ID */
4533 : /* -------------------------- */
4534 0 : sID = swathID % idOffset;
4535 :
4536 :
4537 : /* Loop through all SDSs in swath */
4538 : /* ------------------------------ */
4539 0 : for (i = 0; i < SWXSwath[sID].nSDS; i++)
4540 : {
4541 : /* If active SDS ... */
4542 : /* ----------------- */
4543 0 : if (SWXSwath[sID].sdsID[i] != 0)
4544 : {
4545 : /* Get SDS ID, name, rankSDS, and dimensions */
4546 : /* ----------------------------------------- */
4547 0 : *sdid = SWXSwath[sID].sdsID[i];
4548 0 : SDgetinfo(*sdid, name, rankSDS, dims, &dum, &dum);
4549 0 : *rankFld = *rankSDS;
4550 :
4551 : /* If merged field ... */
4552 : /* ------------------- */
4553 0 : if (strstr(name, "MRGFLD_") == &name[0])
4554 : {
4555 : /* Get swath name */
4556 : /* -------------- */
4557 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
4558 :
4559 :
4560 : /* Get pointers to "MergedFields" section within SM */
4561 : /* ------------------------------------------------ */
4562 0 : metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s",
4563 : "MergedFields", metaptrs);
4564 0 : if(metabuf == NULL)
4565 : {
4566 0 : free(utlstr);
4567 0 : return(-1);
4568 : }
4569 :
4570 : /* Store metaptr in order to recover */
4571 : /* --------------------------------- */
4572 0 : oldmetaptr = metaptrs[0];
4573 :
4574 :
4575 : /* Search for Merged field name */
4576 : /* ---------------------------- */
4577 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%.480s%s", "MergedFieldName=\"",
4578 : name, "\"\n");
4579 0 : metaptrs[0] = strstr(metaptrs[0], utlstr);
4580 :
4581 :
4582 : /* If not found check for old metadata */
4583 : /* ----------------------------------- */
4584 0 : if (metaptrs[0] == NULL)
4585 : {
4586 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%.480s%s", "OBJECT=\"", name, "\"\n");
4587 0 : metaptrs[0] = strstr(oldmetaptr, utlstr);
4588 : }
4589 :
4590 :
4591 : /* Get field list and strip off leading and trailing quotes */
4592 0 : EHgetmetavalue(metaptrs, "FieldList", name); /* not return status --xhua */
4593 0 : memmove(name, name + 1, strlen(name) - 2);
4594 0 : name[strlen(name) - 2] = 0;
4595 :
4596 : /* Search for desired field within merged field list */
4597 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"");
4598 0 : dum = EHstrwithin(utlstr, name, ',');
4599 :
4600 0 : free(metabuf);
4601 : }
4602 : else
4603 : {
4604 : /* If solo (unmerged) check if SDS name matches fieldname */
4605 : /* ------------------------------------------------------ */
4606 0 : dum = EHstrwithin(fieldname, name, ',');
4607 0 : if (dum != -1)
4608 : {
4609 0 : *solo = 1;
4610 0 : *offset = 0;
4611 : }
4612 : }
4613 :
4614 :
4615 : /* If field found ... */
4616 : /* ------------------ */
4617 0 : if (dum != -1)
4618 : {
4619 0 : status = 0;
4620 :
4621 : /* If merged field ... */
4622 : /* ------------------- */
4623 0 : if (*solo == 0)
4624 : {
4625 : /* Get "Field Offsets" SDS attribute l_index */
4626 : /* --------------------------------------- */
4627 0 : attrIndex = SDfindattr(*sdid, "Field Offsets");
4628 :
4629 : /*
4630 : * If attribute exists then get offset of desired field
4631 : * within merged field
4632 : */
4633 0 : if (attrIndex != -1)
4634 : {
4635 0 : SDreadattr(*sdid, attrIndex, (VOIDP) dums);
4636 0 : *offset = dums[dum];
4637 : }
4638 :
4639 :
4640 : /* Get "Field Dims" SDS attribute l_index */
4641 : /* ------------------------------------ */
4642 0 : attrIndex = SDfindattr(*sdid, "Field Dims");
4643 :
4644 : /*
4645 : * If attribute exists then get 0th dimension of desired
4646 : * field within merged field
4647 : */
4648 0 : if (attrIndex != -1)
4649 : {
4650 0 : SDreadattr(*sdid, attrIndex, (VOIDP) dums);
4651 0 : dims[0] = dums[dum];
4652 :
4653 : /* If this dimension = 1 then field is really 2 dim */
4654 : /* ------------------------------------------------ */
4655 0 : if (dums[dum] == 1)
4656 : {
4657 0 : *rankFld = 2;
4658 : }
4659 : }
4660 : }
4661 :
4662 :
4663 : /* Break out of SDS loop */
4664 : /* --------------------- */
4665 0 : break;
4666 : } /* End of found field section */
4667 : }
4668 : else
4669 : {
4670 : /* First non-active SDS signifies no more, break out of SDS loop */
4671 : /* ------------------------------------------------------------- */
4672 0 : break;
4673 : }
4674 : }
4675 :
4676 0 : free(utlstr);
4677 :
4678 0 : return (status);
4679 : }
4680 :
4681 :
4682 :
4683 :
4684 :
4685 : /*----------------------------------------------------------------------------|
4686 : | BEGIN_PROLOG |
4687 : | |
4688 : | FUNCTION: SWwrrdfield |
4689 : | |
4690 : | DESCRIPTION: Writes/Reads fields |
4691 : | |
4692 : | |
4693 : | Return Value Type Units Description |
4694 : | ============ ====== ========= ===================================== |
4695 : | status intn return status (0) SUCCEED, (-1) FAIL |
4696 : | |
4697 : | INPUTS: |
4698 : | swathID int32 swath structure ID |
4699 : | fieldname const char fieldname |
4700 : | code const char Write/Read code (w/r) |
4701 : | start int32 start array |
4702 : | stride int32 stride array |
4703 : | edge int32 edge array |
4704 : | datbuf void data buffer for read |
4705 : | |
4706 : | |
4707 : | OUTPUTS: |
4708 : | datbuf void data buffer for write |
4709 : | |
4710 : | NOTES: |
4711 : | |
4712 : | |
4713 : | Date Programmer Description |
4714 : | ====== ============ ================================================= |
4715 : | Jun 96 Joel Gales Original Programmer |
4716 : | Feb 97 Joel Gales Stride = 1 HDF compression workaround |
4717 : | |
4718 : | END_PROLOG |
4719 : -----------------------------------------------------------------------------*/
4720 : static intn
4721 0 : SWwrrdfield(int32 swathID, const char *fieldname, const char *code,
4722 : int32 start[], int32 stride[], int32 edge[], VOIDP datbuf)
4723 :
4724 : {
4725 : intn i; /* Loop index */
4726 0 : intn status = 0; /* routine return status variable */
4727 :
4728 : int32 fid; /* HDF-EOS file ID */
4729 : int32 sdInterfaceID; /* HDF SDS interface ID */
4730 : int32 vgid; /* Swath Geo or Data Vgroup ID */
4731 : int32 sdid; /* SDS ID */
4732 : int32 dum; /* Dummy variable */
4733 : int32 rankSDS; /* Rank of SDS */
4734 : int32 rankFld; /* Rank of field */
4735 :
4736 : int32 vdataID; /* 1d field vdata */
4737 : int32 recsize; /* Vdata record size */
4738 : int32 fldsize; /* Field size */
4739 : int32 nrec; /* Number of records in Vdata */
4740 :
4741 : int32 offset[8]; /* I/O offset (start) */
4742 : int32 incr[8]; /* I/O increment (stride) */
4743 : int32 count[8]; /* I/O count (edge) */
4744 : int32 dims[8]; /* Field/SDS dimensions */
4745 : int32 mrgOffset; /* Merged field offset */
4746 : int32 nflds; /* Number of fields in Vdata */
4747 : int32 strideOne; /* Strides = 1 flag */
4748 :
4749 : uint8 *buf; /* I/O (transfer) buffer */
4750 : uint8 *fillbuf; /* Fill value buffer */
4751 :
4752 : char attrName[80]; /* Name of fill value attribute */
4753 : char *ptr[64]; /* String pointer array */
4754 : char fieldlist[256]; /* Vdata field list */
4755 :
4756 :
4757 : /* Check for valid swath ID */
4758 : /* ------------------------ */
4759 0 : status = SWchkswid(swathID, "SWwrrdfield", &fid, &sdInterfaceID, &dum);
4760 :
4761 :
4762 0 : if (status == 0)
4763 : {
4764 :
4765 : /* Check whether fieldname is in SDS (multi-dim field) */
4766 : /* --------------------------------------------------- */
4767 0 : status = SWSDfldsrch(swathID, sdInterfaceID, fieldname, &sdid,
4768 : &rankSDS, &rankFld, &mrgOffset, dims, &dum);
4769 :
4770 : /* Multi-Dimensional Field Section */
4771 : /* ------------------------------- */
4772 0 : if (status != -1)
4773 : {
4774 : /* Set I/O offset Section */
4775 : /* ---------------------- */
4776 :
4777 : /*
4778 : * If start == NULL (default) set I/O offset of 0th field to
4779 : * offset within merged field (if any) and the rest to 0
4780 : */
4781 0 : if (start == NULL)
4782 : {
4783 0 : for (i = 0; i < rankSDS; i++)
4784 : {
4785 0 : offset[i] = 0;
4786 : }
4787 0 : offset[0] = mrgOffset;
4788 : }
4789 : else
4790 : {
4791 : /*
4792 : * ... otherwise set I/O offset to user values, adjusting the
4793 : * 0th field with the merged field offset (if any)
4794 : */
4795 0 : if (rankFld == rankSDS)
4796 : {
4797 0 : for (i = 0; i < rankSDS; i++)
4798 : {
4799 0 : offset[i] = start[i];
4800 : }
4801 0 : offset[0] += mrgOffset;
4802 : }
4803 : else
4804 : {
4805 : /*
4806 : * If field really 2-dim merged in 3-dim field then set
4807 : * 0th field offset to merge offset and then next two to
4808 : * the user values
4809 : */
4810 0 : for (i = 0; i < rankFld; i++)
4811 : {
4812 0 : offset[i + 1] = start[i];
4813 : }
4814 0 : offset[0] = mrgOffset;
4815 : }
4816 : }
4817 :
4818 :
4819 :
4820 : /* Set I/O stride Section */
4821 : /* ---------------------- */
4822 :
4823 : /*
4824 : * If stride == NULL (default) set I/O stride to 1
4825 : */
4826 0 : if (stride == NULL)
4827 : {
4828 0 : for (i = 0; i < rankSDS; i++)
4829 : {
4830 0 : incr[i] = 1;
4831 : }
4832 : }
4833 : else
4834 : {
4835 : /*
4836 : * ... otherwise set I/O stride to user values
4837 : */
4838 0 : if (rankFld == rankSDS)
4839 : {
4840 0 : for (i = 0; i < rankSDS; i++)
4841 : {
4842 0 : incr[i] = stride[i];
4843 : }
4844 : }
4845 : else
4846 : {
4847 : /*
4848 : * If field really 2-dim merged in 3-dim field then set
4849 : * 0th field stride to 1 and then next two to the user
4850 : * values.
4851 : */
4852 0 : for (i = 0; i < rankFld; i++)
4853 : {
4854 0 : incr[i + 1] = stride[i];
4855 : }
4856 0 : incr[0] = 1;
4857 : }
4858 : }
4859 :
4860 :
4861 :
4862 : /* Set I/O count Section */
4863 : /* --------------------- */
4864 :
4865 : /*
4866 : * If edge == NULL (default) set I/O count to number of remaining
4867 : * entries (dims - start) / increment. Note that 0th field
4868 : * offset corrected for merged field offset (if any).
4869 : */
4870 0 : if (edge == NULL)
4871 : {
4872 0 : for (i = 1; i < rankSDS; i++)
4873 : {
4874 0 : count[i] = (dims[i] - offset[i]) / incr[i];
4875 : }
4876 0 : count[0] = (dims[0] - (offset[0] - mrgOffset)) / incr[0];
4877 : }
4878 : else
4879 : {
4880 : /*
4881 : * ... otherwise set I/O count to user values
4882 : */
4883 0 : if (rankFld == rankSDS)
4884 : {
4885 0 : for (i = 0; i < rankSDS; i++)
4886 : {
4887 0 : count[i] = edge[i];
4888 : }
4889 : }
4890 : else
4891 : {
4892 : /*
4893 : * If field really 2-dim merged in 3-dim field then set
4894 : * 0th field count to 1 and then next two to the user
4895 : * values.
4896 : */
4897 0 : for (i = 0; i < rankFld; i++)
4898 : {
4899 0 : count[i + 1] = edge[i];
4900 : }
4901 0 : count[0] = 1;
4902 : }
4903 : }
4904 :
4905 : /* Perform I/O with relevant HDF I/O routine */
4906 : /* ----------------------------------------- */
4907 0 : if (strcmp(code, "w") == 0)
4908 : {
4909 : /* Set strideOne to true (1) */
4910 : /* ------------------------- */
4911 0 : strideOne = 1;
4912 :
4913 :
4914 : /* If incr[i] != 1 set strideOne to false (0) */
4915 : /* ------------------------------------------ */
4916 0 : for (i = 0; i < rankSDS; i++)
4917 : {
4918 0 : if (incr[i] != 1)
4919 : {
4920 0 : strideOne = 0;
4921 0 : break;
4922 : }
4923 : }
4924 :
4925 :
4926 : /*
4927 : * If strideOne is true use NULL parameter for stride. This
4928 : * is a work-around to HDF compression problem
4929 : */
4930 0 : if (strideOne == 1)
4931 : {
4932 0 : status = SDwritedata(sdid, offset, NULL, count,
4933 : (VOIDP) datbuf);
4934 : }
4935 : else
4936 : {
4937 0 : status = SDwritedata(sdid, offset, incr, count,
4938 : (VOIDP) datbuf);
4939 : }
4940 : }
4941 : else
4942 : {
4943 0 : status = SDreaddata(sdid, offset, incr, count,
4944 : (VOIDP) datbuf);
4945 : }
4946 : } /* End of Multi-Dimensional Field Section */
4947 : else
4948 : {
4949 :
4950 : /* One-Dimensional Field Section */
4951 : /* ----------------------------- */
4952 :
4953 : /* Check fieldname within 1d field Vgroups */
4954 : /* --------------------------------------- */
4955 0 : status = SW1dfldsrch(fid, swathID, fieldname, code,
4956 : &vgid, &vdataID, &dum);
4957 :
4958 0 : if (status != -1)
4959 : {
4960 :
4961 : /* Get number of records */
4962 : /* --------------------- */
4963 0 : nrec = VSelts(vdataID);
4964 :
4965 :
4966 : /* Set offset, increment, & count */
4967 : /* ------------------------------ */
4968 0 : offset[0] = (start == NULL) ? 0 : start[0];
4969 0 : incr[0] = (stride == NULL) ? 1 : stride[0];
4970 0 : count[0] = (edge == NULL)
4971 0 : ? (nrec - offset[0]) / incr[0]
4972 0 : : edge[0];
4973 :
4974 :
4975 :
4976 : /* Write Section */
4977 : /* ------------- */
4978 0 : if (strcmp(code, "w") == 0)
4979 : {
4980 : /* Get size of field and setup fill buffer */
4981 : /* --------------------------------------- */
4982 0 : fldsize = VSsizeof(vdataID, (char *)fieldname);
4983 0 : fillbuf = (uint8 *) calloc(fldsize, 1);
4984 0 : if(fillbuf == NULL)
4985 : {
4986 0 : HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__);
4987 0 : return(-1);
4988 : }
4989 :
4990 : /* Get size of record in Vdata and setup I/O buffer */
4991 : /* ------------------------------------------------ */
4992 0 : VSQueryvsize(vdataID, &recsize);
4993 0 : buf = (uint8 *) calloc(recsize, count[0] * incr[0]);
4994 0 : if(buf == NULL)
4995 : {
4996 0 : HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__);
4997 0 : return(-1);
4998 : }
4999 :
5000 :
5001 : /* Get names and number of fields in each record */
5002 : /* ---------------------------------------------- */
5003 0 : VSgetfields(vdataID, fieldlist);
5004 0 : dum = EHstrwithin(fieldname, fieldlist, ',');
5005 0 : nflds = EHparsestr(fieldlist, ',', ptr, NULL);
5006 :
5007 :
5008 : /* Get Merged Field Offset (if any) */
5009 : /* -------------------------------- */
5010 0 : if (nflds > 1)
5011 : {
5012 0 : if (dum > 0)
5013 : {
5014 0 : *(ptr[dum] - 1) = 0;
5015 0 : mrgOffset = VSsizeof(vdataID, fieldlist);
5016 0 : *(ptr[dum] - 1) = ',';
5017 : }
5018 : else
5019 : {
5020 0 : mrgOffset = 0;
5021 : }
5022 :
5023 : /* Read records to recover previously written data */
5024 0 : /* status = */ VSsetfields(vdataID, fieldlist);
5025 0 : /* status = */ VSseek(vdataID, offset[0]);
5026 0 : nrec = VSread(vdataID, buf, count[0] * incr[0],
5027 : FULL_INTERLACE);
5028 : }
5029 : else
5030 : {
5031 0 : mrgOffset = 0;
5032 : }
5033 :
5034 :
5035 :
5036 : /* Fill buffer with "Fill" value (if any) */
5037 : /* -------------------------------------- */
5038 0 : snprintf( attrName, sizeof(attrName), "_FV_%s", fieldname);
5039 :
5040 0 : status = SWreadattr(swathID, attrName, (char *) fillbuf);
5041 0 : if (status == 0)
5042 : {
5043 0 : for (i = 0; i < count[0] * incr[0]; i++)
5044 : {
5045 0 : memcpy(buf + i * recsize + mrgOffset,
5046 : fillbuf, fldsize);
5047 : }
5048 : }
5049 :
5050 :
5051 : /* Write new data into buffer */
5052 : /* -------------------------- */
5053 0 : if (incr[0] == 1 && nflds == 1)
5054 : {
5055 0 : memcpy(buf, datbuf, count[0] * recsize);
5056 : }
5057 : else
5058 : {
5059 0 : for (i = 0; i < count[0]; i++)
5060 : {
5061 0 : memcpy(buf + i * recsize * incr[0] + mrgOffset,
5062 0 : (uint8 *) datbuf + i * fldsize, fldsize);
5063 : }
5064 : }
5065 :
5066 :
5067 : /* If append read last record */
5068 : /* -------------------------- */
5069 0 : if (offset[0] == nrec)
5070 : {
5071 : /* abe added "status =" to next line 8/8/97 */
5072 0 : status = VSseek(vdataID, offset[0] - 1);
5073 0 : VSread(vdataID, fillbuf, 1, FULL_INTERLACE);
5074 : }
5075 : else
5076 : {
5077 0 : status = VSseek(vdataID, offset[0]);
5078 : }
5079 :
5080 :
5081 : /* Write data into Vdata */
5082 : /* --------------------- */
5083 0 : nrec = VSwrite(vdataID, buf, count[0] * incr[0],
5084 : FULL_INTERLACE);
5085 :
5086 0 : free(fillbuf);
5087 0 : if (status > 0)
5088 0 : status = 0;
5089 :
5090 : } /* End Write Section */
5091 : else
5092 : {
5093 : /* Read Section */
5094 : /* ------------ */
5095 0 : status = VSsetfields(vdataID, fieldname);
5096 0 : fldsize = VSsizeof(vdataID, (char *)fieldname);
5097 0 : buf = (uint8 *) calloc(fldsize, count[0] * incr[0]);
5098 0 : if(buf == NULL)
5099 : {
5100 0 : HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__);
5101 0 : return(-1);
5102 : }
5103 :
5104 0 : (void) VSseek(vdataID, offset[0]);
5105 0 : (void) VSread(vdataID, buf, count[0] * incr[0],
5106 : FULL_INTERLACE);
5107 :
5108 :
5109 : /* Copy from input buffer to returned data buffer */
5110 : /* ---------------------------------------------- */
5111 0 : if (incr[0] == 1)
5112 : {
5113 0 : memcpy(datbuf, buf, count[0] * fldsize);
5114 : }
5115 : else
5116 : {
5117 0 : for (i = 0; i < count[0]; i++)
5118 : {
5119 0 : memcpy((uint8 *) datbuf + i * fldsize,
5120 0 : buf + i * fldsize * incr[0], fldsize);
5121 : }
5122 : }
5123 :
5124 : } /* End Read Section */
5125 :
5126 0 : free(buf);
5127 0 : VSdetach(vdataID);
5128 : }
5129 : else
5130 : {
5131 0 : HEpush(DFE_GENAPP, "SWwrrdfield", __FILE__, __LINE__);
5132 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
5133 : }
5134 : } /* End One-D Field Section */
5135 :
5136 : }
5137 0 : return (status);
5138 : }
5139 :
5140 :
5141 :
5142 : /*----------------------------------------------------------------------------|
5143 : | BEGIN_PROLOG |
5144 : | |
5145 : | FUNCTION: SWwritefield |
5146 : | |
5147 : | DESCRIPTION: Writes data to field |
5148 : | |
5149 : | |
5150 : | Return Value Type Units Description |
5151 : | ============ ====== ========= ===================================== |
5152 : | status intn return status (0) SUCCEED, (-1) FAIL |
5153 : | |
5154 : | INPUTS: |
5155 : | swathID int32 swath structure ID |
5156 : | fieldname char fieldname |
5157 : | start int32 start array |
5158 : | stride int32 stride array |
5159 : | edge int32 edge array |
5160 : | |
5161 : | |
5162 : | OUTPUTS: |
5163 : | data void data buffer for write |
5164 : | |
5165 : | NOTES: |
5166 : | |
5167 : | |
5168 : | Date Programmer Description |
5169 : | ====== ============ ================================================= |
5170 : | Jun 96 Joel Gales Original Programmer |
5171 : | |
5172 : | END_PROLOG |
5173 : -----------------------------------------------------------------------------*/
5174 : intn
5175 0 : SWwritefield(int32 swathID, const char *fieldname,
5176 : int32 start[], int32 stride[], int32 edge[], VOIDP data)
5177 :
5178 : {
5179 0 : intn status = 0; /* routine return status variable */
5180 :
5181 0 : status = SWwrrdfield(swathID, fieldname, "w", start, stride, edge,
5182 : data);
5183 0 : return (status);
5184 : }
5185 :
5186 :
5187 :
5188 :
5189 :
5190 :
5191 : /*----------------------------------------------------------------------------|
5192 : | BEGIN_PROLOG |
5193 : | |
5194 : | FUNCTION: SWreadfield |
5195 : | |
5196 : | DESCRIPTION: Reads data from field |
5197 : | |
5198 : | Return Value Type Units Description |
5199 : | ============ ====== ========= ===================================== |
5200 : | status intn return status (0) SUCCEED, (-1) FAIL |
5201 : | |
5202 : | INPUTS: |
5203 : | swathID int32 swath structure ID |
5204 : | fieldname const char fieldname |
5205 : | start int32 start array |
5206 : | stride int32 stride array |
5207 : | edge int32 edge array |
5208 : | buffer void data buffer for read |
5209 : | |
5210 : | |
5211 : | OUTPUTS: |
5212 : | None |
5213 : | |
5214 : | NOTES: |
5215 : | |
5216 : | |
5217 : | Date Programmer Description |
5218 : | ====== ============ ================================================= |
5219 : | Jun 96 Joel Gales Original Programmer |
5220 : | |
5221 : | END_PROLOG |
5222 : -----------------------------------------------------------------------------*/
5223 : intn
5224 0 : SWreadfield(int32 swathID, const char *fieldname,
5225 : int32 start[], int32 stride[], int32 edge[], VOIDP buffer)
5226 :
5227 : {
5228 0 : intn status = 0; /* routine return status variable */
5229 :
5230 0 : status = SWwrrdfield(swathID, fieldname, "r", start, stride, edge,
5231 : buffer);
5232 0 : return (status);
5233 : }
5234 :
5235 :
5236 :
5237 :
5238 : /*----------------------------------------------------------------------------|
5239 : | BEGIN_PROLOG |
5240 : | |
5241 : | FUNCTION: SWdefboxregion |
5242 : | |
5243 : | DESCRIPTION: Finds swath cross tracks within area of interest and returns |
5244 : | region ID |
5245 : | |
5246 : | |
5247 : | Return Value Type Units Description |
5248 : | ============ ====== ========= ===================================== |
5249 : | regionID int32 Region ID |
5250 : | |
5251 : | INPUTS: |
5252 : | swathID int32 Swath structure ID |
5253 : | cornerlon float64 dec deg Longitude of opposite corners of box |
5254 : | cornerlat float64 dec deg Latitude of opposite corners of box |
5255 : | mode int32 Search mode |
5256 : | HDFE_MIDPOINT - Use midpoint of Xtrack |
5257 : | HDFE_ENDPOINT - Use endpoints of Xtrack |
5258 : | HDFE_ANYPOINT - Use all points of Xtrack|
5259 : | |
5260 : | OUTPUTS: |
5261 : | None |
5262 : | |
5263 : | NOTES: |
5264 : | |
5265 : | |
5266 : | Date Programmer Description |
5267 : | ====== ============ ================================================= |
5268 : | Jun 96 Joel Gales Original Programmer |
5269 : | Oct 96 Joel Gales Add ability to handle regions crossing date line |
5270 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
5271 : | Jul 98 Abe Taaheri Fixed core dump in SWregioninfo associated with |
5272 : | SWXRegion[k]->nRegions exceeding MAXNREGIONS in |
5273 : | this function |
5274 : | Aug 99 Abe Taaheri Fixed the code so that all cross tracks or all |
5275 : | points on the along track that fall inside the box |
5276 : | are identified. At the same time added code to |
5277 : | function "updatescene" to reject cases where there |
5278 : | is single cross track in the box (for LANDSAT) |
5279 : | Jun 03 Abe Taaheri Added a few lines to report error and return -1 if |
5280 : | regionID exceeded NSWATHREGN |
5281 : | Mar 04 Abe Taaheri Added recognition for GeodeticLatitude |
5282 : | |
5283 : | END_PROLOG |
5284 : -----------------------------------------------------------------------------*/
5285 : int32
5286 0 : SWdefboxregion(int32 swathID, float64 cornerlon[], float64 cornerlat[],
5287 : int32 mode)
5288 : {
5289 : intn i; /* Loop index */
5290 0 : intn j = 0; /* Loop index */
5291 : intn k; /* Loop index */
5292 :
5293 : intn status; /* routine return status variable */
5294 : intn statLon; /* Status from SWfieldinfo for longitude */
5295 : intn statLat; /* Status from SWfieldinfo for latitude */
5296 0 : intn statCoLat = -1; /* Status from SWfieldinfo for
5297 : * Colatitude */
5298 0 : intn statGeodeticLat = -1; /* Status from SWfieldinfo for
5299 : * GeodeticLatitude */
5300 :
5301 0 : uint8 found = 0; /* Found flag */
5302 : uint8 *flag; /* Pointer to track flag array */
5303 0 : intn validReg = -1; /* -1 is invalid validReg */
5304 :
5305 : int32 fid; /* HDF-EOS file ID */
5306 : int32 sdInterfaceID; /* HDF SDS interface ID */
5307 : int32 swVgrpID; /* Swath Vgroup ID */
5308 : int32 rank; /* Rank of geolocation fields */
5309 : int32 nt; /* Number type of geolocation fields */
5310 : int32 dims[8]; /* Dimensions of geolocation fields */
5311 : int32 nElem; /* Number of elements to read */
5312 : int32 bndflag; /* +/-180 longitude boundary flag */
5313 : int32 lonTest; /* Longitude test flag */
5314 : int32 latTest; /* Latitude test flag */
5315 : int32 start[2]; /* Start array (read) */
5316 0 : int32 stride[2] = {1, 1}; /* Stride array (read) */
5317 : int32 edge[2]; /* Edge array (read) */
5318 0 : int32 regionID = -1; /* Region ID (return) */
5319 : int32 anyStart[2];/* ANYPOINT start array (read) */
5320 : int32 anyEdge[2]; /* ANYPOINT edge array (read) */
5321 :
5322 : float32 temp32; /* Temporary float32 variable */
5323 :
5324 : float64 lonTestVal; /* Longitude test value */
5325 : float64 latTestVal; /* Latitude test value */
5326 : float64 temp64; /* Temporary float64 variable */
5327 :
5328 : char *lonArr; /* Longitude data array */
5329 : char *latArr; /* Latitude data array */
5330 : char dimlist[256]; /* Dimension list (geolocation
5331 : * fields) */
5332 : char latName[17];/* Latitude field name */
5333 :
5334 :
5335 : /* Check for valid swath ID */
5336 : /* ------------------------ */
5337 0 : status = SWchkswid(swathID, "SWdefboxregion", &fid, &sdInterfaceID,
5338 : &swVgrpID);
5339 :
5340 :
5341 : /* Inclusion mode must be between 0 and 2 */
5342 : /* -------------------------------------- */
5343 0 : if (mode < 0 || mode > 2)
5344 : {
5345 0 : status = -1;
5346 0 : HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__);
5347 0 : HEreport("Improper Inclusion Mode: %d.\n", mode);
5348 : }
5349 :
5350 :
5351 0 : if (status == 0)
5352 : {
5353 : /* Get "Longitude" field info */
5354 : /* -------------------------- */
5355 0 : statLon = SWfieldinfo(swathID, "Longitude", &rank, dims, &nt, dimlist);
5356 0 : if (statLon != 0)
5357 : {
5358 0 : status = -1;
5359 0 : HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__);
5360 0 : HEreport("\"Longitude\" field not found.\n");
5361 : }
5362 :
5363 : /* Get "Latitude" field info */
5364 : /* -------------------------- */
5365 0 : statLat = SWfieldinfo(swathID, "Latitude", &rank, dims, &nt, dimlist);
5366 0 : if (statLat != 0)
5367 : {
5368 : /* If not found check for "Colatitude" field info */
5369 : /* ---------------------------------------------- */
5370 0 : statCoLat = SWfieldinfo(swathID, "Colatitude", &rank, dims, &nt,
5371 : dimlist);
5372 0 : if (statCoLat != 0)
5373 : {
5374 : /* Check again for Geodeticlatitude */
5375 0 : statGeodeticLat = SWfieldinfo(swathID,
5376 : "GeodeticLatitude", &rank,
5377 : dims, &nt, dimlist);
5378 0 : if (statGeodeticLat != 0)
5379 : {
5380 : /* Neither "Latitude" nor "Colatitude" nor
5381 : "GeodeticLatitude" field found */
5382 : /* ----------------------------------------------- */
5383 0 : status = -1;
5384 0 : HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__);
5385 0 : HEreport(
5386 : "Neither \"Latitude\" nor \"Colatitude\" nor \"GeodeticLatitude\" fields found.\n");
5387 : }
5388 : else
5389 : {
5390 : /* Latitude field is "GeodeticLatitude" */
5391 : /* ------------------------------ */
5392 0 : strcpy(latName, "GeodeticLatitude");
5393 : }
5394 : }
5395 : else
5396 : {
5397 : /* Latitude field is "Colatitude" */
5398 : /* ------------------------------ */
5399 0 : strcpy(latName, "Colatitude");
5400 : }
5401 : }
5402 : else
5403 : {
5404 : /* Latitude field is "Latitude" */
5405 : /* ---------------------------- */
5406 0 : strcpy(latName, "Latitude");
5407 : }
5408 :
5409 :
5410 0 : if (status == 0)
5411 : {
5412 : /* Search along entire "Track" dimension from beginning to end */
5413 : /* ----------------------------------------------------------- */
5414 0 : start[0] = 0;
5415 0 : edge[0] = dims[0];
5416 :
5417 :
5418 : /* If 1D geolocation fields then set mode to MIDPOINT */
5419 : /* -------------------------------------------------- */
5420 0 : if (rank == 1)
5421 : {
5422 0 : mode = HDFE_MIDPOINT;
5423 : }
5424 :
5425 :
5426 0 : switch (mode)
5427 : {
5428 : /* If MIDPOINT search single point in middle of "CrossTrack" */
5429 : /* --------------------------------------------------------- */
5430 0 : case HDFE_MIDPOINT:
5431 :
5432 0 : start[1] = dims[1] / 2;
5433 0 : edge[1] = 1;
5434 :
5435 0 : break;
5436 :
5437 : /* If ENDPOINT search 2 points at either end of "CrossTrack" */
5438 : /* --------------------------------------------------------- */
5439 0 : case HDFE_ENDPOINT:
5440 :
5441 0 : start[1] = 0;
5442 0 : stride[1] = dims[1] - 1;
5443 0 : edge[1] = 2;
5444 :
5445 0 : break;
5446 :
5447 : /* If ANYPOINT do initial MIDPOINT search */
5448 : /* -------------------------------------- */
5449 0 : case HDFE_ANYPOINT:
5450 :
5451 0 : start[1] = dims[1] / 2;
5452 0 : edge[1] = 1;
5453 :
5454 0 : break;
5455 : }
5456 :
5457 :
5458 : /* Compute number of elements */
5459 : /* -------------------------- */
5460 0 : nElem = edge[0] * edge[1];
5461 :
5462 :
5463 : /* Allocate space for longitude and latitude (float64) */
5464 : /* --------------------------------------------------- */
5465 0 : lonArr = (char *) calloc(nElem, sizeof(float64));
5466 0 : if(lonArr == NULL)
5467 : {
5468 0 : HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__);
5469 0 : return(-1);
5470 : }
5471 :
5472 0 : latArr = (char *) calloc(nElem, sizeof(float64));
5473 0 : if(latArr == NULL)
5474 : {
5475 0 : HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__);
5476 0 : free(lonArr);
5477 0 : return(-1);
5478 : }
5479 :
5480 :
5481 : /* Allocate space for flag array (uint8) */
5482 : /* ------------------------------------- */
5483 0 : flag = (uint8 *) calloc(edge[0] + 1, 1);
5484 0 : if(flag == NULL)
5485 : {
5486 0 : HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__);
5487 0 : free(lonArr);
5488 0 : free(latArr);
5489 0 : return(-1);
5490 : }
5491 :
5492 :
5493 : /* Read Longitude and Latitude fields */
5494 : /* ---------------------------------- */
5495 0 : status = SWreadfield(swathID, "Longitude",
5496 : start, stride, edge, lonArr);
5497 0 : status = SWreadfield(swathID, latName,
5498 : start, stride, edge, latArr);
5499 :
5500 :
5501 :
5502 : /*
5503 : * If geolocation fields are FLOAT32 then cast each entry as
5504 : * FLOAT64
5505 : */
5506 0 : if (nt == DFNT_FLOAT32)
5507 : {
5508 0 : for (i = nElem - 1; i >= 0; i--)
5509 : {
5510 0 : memcpy(&temp32, lonArr + 4 * i, 4);
5511 0 : temp64 = (float64) temp32;
5512 0 : memcpy(lonArr + 8 * i, &temp64, 8);
5513 :
5514 0 : memcpy(&temp32, latArr + 4 * i, 4);
5515 0 : temp64 = (float64) temp32;
5516 0 : memcpy(latArr + 8 * i, &temp64, 8);
5517 : }
5518 : }
5519 :
5520 :
5521 : /* Set boundary flag */
5522 : /* ----------------- */
5523 :
5524 : /*
5525 : * This variable is set to 1 if the region of interest crosses
5526 : * the +/- 180 longitude boundary
5527 : */
5528 0 : bndflag = (cornerlon[0] < cornerlon[1]) ? 0 : 1;
5529 :
5530 :
5531 :
5532 : /* Main Search Loop */
5533 : /* ---------------- */
5534 :
5535 : /* For each track ... */
5536 : /* ------------------ */
5537 :
5538 0 : for (i = 0; i < edge[0]; i++)
5539 : {
5540 : /* For each value from Cross Track ... */
5541 : /* ----------------------------------- */
5542 0 : for (j = 0; j < edge[1]; j++)
5543 : {
5544 : /* Read in single lon & lat values from data buffers */
5545 : /* ------------------------------------------------- */
5546 0 : memcpy(&lonTestVal, &lonArr[8 * (i * edge[1] + j)], 8);
5547 0 : memcpy(&latTestVal, &latArr[8 * (i * edge[1] + j)], 8);
5548 :
5549 :
5550 : /* If longitude value > 180 convert to -180 to 180 range */
5551 : /* ----------------------------------------------------- */
5552 0 : if (lonTestVal > 180)
5553 : {
5554 0 : lonTestVal = lonTestVal - 360;
5555 : }
5556 :
5557 : /* If Colatitude value convert to latitude value */
5558 : /* --------------------------------------------- */
5559 0 : if (statCoLat == 0)
5560 : {
5561 0 : latTestVal = 90 - latTestVal;
5562 : }
5563 :
5564 :
5565 : /* Test if lat value is within range */
5566 : /* --------------------------------- */
5567 0 : latTest = (latTestVal >= cornerlat[0] &&
5568 0 : latTestVal <= cornerlat[1]);
5569 :
5570 :
5571 0 : if (bndflag == 1)
5572 : {
5573 : /*
5574 : * If boundary flag set test whether longitude value
5575 : * is outside region and then flip
5576 : */
5577 0 : lonTest = (lonTestVal >= cornerlon[1] &&
5578 0 : lonTestVal <= cornerlon[0]);
5579 0 : lonTest = 1 - lonTest;
5580 : }
5581 : else
5582 : {
5583 0 : lonTest = (lonTestVal >= cornerlon[0] &&
5584 0 : lonTestVal <= cornerlon[1]);
5585 : }
5586 :
5587 :
5588 : /*
5589 : * If both longitude and latitude are within region set
5590 : * flag on for this track
5591 : */
5592 0 : if (lonTest + latTest == 2)
5593 : {
5594 0 : flag[i] = 1;
5595 0 : found = 1;
5596 0 : break;
5597 : }
5598 : }
5599 : }
5600 :
5601 :
5602 :
5603 : /* ANYPOINT search */
5604 : /* --------------- */
5605 0 : if (mode == HDFE_ANYPOINT && rank > 1)
5606 : {
5607 0 : free(lonArr);
5608 0 : free(latArr);
5609 :
5610 : /* Allocate space for an entire single cross track */
5611 : /* ----------------------------------------------- */
5612 0 : lonArr = (char *) calloc(dims[1], sizeof(float64));
5613 0 : if(lonArr == NULL)
5614 : {
5615 0 : HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__);
5616 0 : return(-1);
5617 : }
5618 :
5619 0 : latArr = (char *) calloc(dims[1], sizeof(float64));
5620 0 : if(latArr == NULL)
5621 : {
5622 0 : HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__);
5623 0 : free(lonArr);
5624 0 : return(-1);
5625 : }
5626 :
5627 :
5628 : /* Setup start and edge */
5629 : /* -------------------- */
5630 0 : anyStart[1] = 0;
5631 0 : anyEdge[0] = 1;
5632 0 : anyEdge[1] = dims[1];
5633 :
5634 :
5635 : /* For each track starting from 0 */
5636 : /* ------------------------------ */
5637 0 : for (i = 0; i < edge[0]; i++)
5638 : {
5639 :
5640 : /* If cross track not in region (with MIDPOINT search ... */
5641 : /* ------------------------------------------------------ */
5642 0 : if (flag[i] == 0)
5643 : {
5644 : /* Setup track start */
5645 : /* ----------------- */
5646 0 : anyStart[0] = i;
5647 :
5648 :
5649 : /* Read in lon and lat values for cross track */
5650 : /* ------------------------------------------ */
5651 0 : status = SWreadfield(swathID, "Longitude",
5652 : anyStart, NULL, anyEdge, lonArr);
5653 0 : status = SWreadfield(swathID, latName,
5654 : anyStart, NULL, anyEdge, latArr);
5655 :
5656 :
5657 :
5658 : /*
5659 : * If geolocation fields are FLOAT32 then cast each
5660 : * entry as FLOAT64
5661 : */
5662 0 : if (nt == DFNT_FLOAT32)
5663 : {
5664 0 : for (j = dims[1] - 1; j >= 0; j--)
5665 : {
5666 0 : memcpy(&temp32, lonArr + 4 * j, 4);
5667 0 : temp64 = (float64) temp32;
5668 0 : memcpy(lonArr + 8 * j, &temp64, 8);
5669 :
5670 0 : memcpy(&temp32, latArr + 4 * j, 4);
5671 0 : temp64 = (float64) temp32;
5672 0 : memcpy(latArr + 8 * j, &temp64, 8);
5673 : }
5674 : }
5675 :
5676 :
5677 : /* For each value from Cross Track ... */
5678 : /* ----------------------------------- */
5679 0 : for (j = 0; j < dims[1]; j++)
5680 : {
5681 : /* Read in single lon & lat values from buffers */
5682 : /* -------------------------------------------- */
5683 0 : memcpy(&lonTestVal, &lonArr[8 * j], 8);
5684 0 : memcpy(&latTestVal, &latArr[8 * j], 8);
5685 :
5686 :
5687 : /* If lon value > 180 convert to -180 - 180 range */
5688 : /* ---------------------------------------------- */
5689 0 : if (lonTestVal > 180)
5690 : {
5691 0 : lonTestVal = lonTestVal - 360;
5692 : }
5693 :
5694 : /* If Colatitude value convert to latitude value */
5695 : /* --------------------------------------------- */
5696 0 : if (statCoLat == 0)
5697 : {
5698 0 : latTestVal = 90 - latTestVal;
5699 : }
5700 :
5701 :
5702 : /* Test if lat value is within range */
5703 : /* --------------------------------- */
5704 0 : latTest = (latTestVal >= cornerlat[0] &&
5705 0 : latTestVal <= cornerlat[1]);
5706 :
5707 :
5708 0 : if (bndflag == 1)
5709 : {
5710 : /*
5711 : * If boundary flag set test whether
5712 : * longitude value is outside region and then
5713 : * flip
5714 : */
5715 0 : lonTest = (lonTestVal >= cornerlon[1] &&
5716 0 : lonTestVal <= cornerlon[0]);
5717 0 : lonTest = 1 - lonTest;
5718 : }
5719 : else
5720 : {
5721 0 : lonTest = (lonTestVal >= cornerlon[0] &&
5722 0 : lonTestVal <= cornerlon[1]);
5723 : }
5724 :
5725 :
5726 : /*
5727 : * If both longitude and latitude are within
5728 : * region set flag on for this track
5729 : */
5730 0 : if (lonTest + latTest == 2)
5731 : {
5732 0 : flag[i] = 1;
5733 0 : found = 1;
5734 0 : break;
5735 : }
5736 : }
5737 : }
5738 : }
5739 : }
5740 :
5741 : /* If within region setup Region Structure */
5742 : /* --------------------------------------- */
5743 0 : if (found == 1)
5744 : {
5745 : /* For all entries in SWXRegion array ... */
5746 : /* -------------------------------------- */
5747 0 : for (k = 0; k < NSWATHREGN; k++)
5748 : {
5749 : /* If empty region ... */
5750 : /* ------------------- */
5751 0 : if (SWXRegion[k] == 0)
5752 : {
5753 : /* Allocate space for region entry */
5754 : /* ------------------------------- */
5755 0 : SWXRegion[k] = (struct swathRegion *)
5756 0 : calloc(1, sizeof(struct swathRegion));
5757 0 : if(SWXRegion[k] == NULL)
5758 : {
5759 0 : HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__);
5760 0 : return(-1);
5761 : }
5762 :
5763 : /* Store file and swath ID */
5764 : /* ----------------------- */
5765 0 : SWXRegion[k]->fid = fid;
5766 0 : SWXRegion[k]->swathID = swathID;
5767 :
5768 :
5769 : /* Set Start & Stop Vertical arrays to -1 */
5770 : /* -------------------------------------- */
5771 0 : for (j = 0; j < 8; j++)
5772 : {
5773 0 : SWXRegion[k]->StartVertical[j] = -1;
5774 0 : SWXRegion[k]->StopVertical[j] = -1;
5775 0 : SWXRegion[k]->StartScan[j] = -1;
5776 0 : SWXRegion[k]->StopScan[j] = -1;
5777 : }
5778 :
5779 :
5780 : /* Set region ID */
5781 : /* ------------- */
5782 0 : regionID = k;
5783 0 : break;
5784 : }
5785 : }
5786 0 : if (k >= NSWATHREGN)
5787 : {
5788 0 : HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__);
5789 0 : HEreport(
5790 : "regionID exceeded NSWATHREGN.\n");
5791 0 : return (-1);
5792 : }
5793 :
5794 : /* Find start and stop of regions */
5795 : /* ------------------------------ */
5796 :
5797 : /* Subtract previous flag value from current one */
5798 : /* --------------------------------------------- */
5799 :
5800 : /*
5801 : * Transition points will have flag value (+1) start or
5802 : * (255 = (uint8) -1) stop of region
5803 : */
5804 0 : for (i = edge[0]; i > 0; i--)
5805 : {
5806 0 : flag[i] -= flag[i - 1];
5807 : }
5808 :
5809 :
5810 0 : for (i = 0; i <= edge[0]; i++)
5811 : {
5812 : /* Start of region */
5813 : /* --------------- */
5814 0 : if (flag[i] == 1)
5815 : {
5816 : /* Increment (multiple) region counter */
5817 : /* ----------------------------------- */
5818 0 : j = ++SWXRegion[k]->nRegions;
5819 :
5820 : /* if SWXRegion[k]->nRegions greater than MAXNREGIONS */
5821 : /* free allocated memory and return FAIL */
5822 :
5823 0 : if ((SWXRegion[k]->nRegions) > MAXNREGIONS)
5824 : {
5825 0 : HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__);
5826 0 : HEreport("SWXRegion[%d]->nRegions exceeds MAXNREGIONS= %d.\n", k, MAXNREGIONS);
5827 0 : free(lonArr);
5828 0 : free(latArr);
5829 0 : free(flag);
5830 0 : return(-1);
5831 : }
5832 :
5833 0 : SWXRegion[k]->StartRegion[j - 1] = i;
5834 : }
5835 :
5836 : /* End of region */
5837 : /* ------------- */
5838 0 : if (flag[i] == 255)
5839 : {
5840 0 : SWXRegion[k]->StopRegion[j - 1] = i - 1;
5841 0 : validReg = 0;
5842 : }
5843 : }
5844 : }
5845 0 : free(lonArr);
5846 0 : free(latArr);
5847 0 : free(flag);
5848 : }
5849 : }
5850 0 : if(validReg==0)
5851 : {
5852 0 : return (regionID);
5853 : }
5854 : else
5855 : {
5856 0 : return (-1);
5857 : }
5858 :
5859 : }
5860 :
5861 :
5862 :
5863 :
5864 : /*----------------------------------------------------------------------------|
5865 : | BEGIN_PROLOG |
5866 : | |
5867 : | FUNCTION: SWregionl_index |
5868 : | |
5869 : | DESCRIPTION: Finds swath cross tracks within area of interest and returns |
5870 : | region l_index and region ID |
5871 : | |
5872 : | |
5873 : | Return Value Type Units Description |
5874 : | ============ ====== ========= ===================================== |
5875 : | regionID int32 Region ID |
5876 : | |
5877 : | INPUTS: |
5878 : | swathID int32 Swath structure ID |
5879 : | cornerlon float64 dec deg Longitude of opposite corners of box |
5880 : | cornerlat float64 dec deg Latitude of opposite corners of box |
5881 : | mode int32 Search mode |
5882 : | HDFE_MIDPOINT - Use midpoint of Xtrack |
5883 : | HDFE_ENDPOINT - Use endpoints of Xtrack |
5884 : | HDFE_ANYPOINT - Use all points of Xtrack|
5885 : | |
5886 : | OUTPUTS: |
5887 : | geodim char geolocation track dimension |
5888 : | idxrange int32 indices of region for along track dim. |
5889 : | |
5890 : | NOTES: |
5891 : | |
5892 : | |
5893 : | Date Programmer Description |
5894 : | ====== ============ ================================================= |
5895 : | Jun 96 Joel Gales Original Programmer |
5896 : | Oct 96 Joel Gales Add ability to handle regions crossing date line |
5897 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
5898 : | Nov 97 Daw Add multiple vertical subsetting capability |
5899 : | END_PROLOG |
5900 : -----------------------------------------------------------------------------*/
5901 : int32
5902 0 : SWregionindex(int32 swathID, float64 cornerlon[], float64 cornerlat[],
5903 : int32 mode, char *geodim, int32 idxrange[])
5904 : {
5905 : intn i; /* Loop index */
5906 : intn j; /* Loop index */
5907 : intn k; /* Loop index */
5908 :
5909 0 : intn l=0; /* Loop index */
5910 0 : intn tmpVal = 0; /* temp value for start region Delyth Jones*/
5911 : /*intn j1; */ /* Loop index */
5912 : intn status; /* routine return status variable */
5913 : intn mapstatus; /* status for type of mapping */
5914 : intn statLon; /* Status from SWfieldinfo for longitude */
5915 : intn statLat; /* Status from SWfieldinfo for latitude */
5916 0 : intn statCoLat = -1; /* Status from SWfieldinfo for
5917 : * Colatitude */
5918 0 : intn statGeodeticLat = -1; /* Status from SWfieldinfo for
5919 : * GeodeticLatitude */
5920 :
5921 0 : uint8 found = 0; /* Found flag */
5922 : uint8 *flag; /* Pointer to track flag array */
5923 0 : intn validReg = -1; /* -1 is invalid validReg */
5924 :
5925 : int32 fid; /* HDF-EOS file ID */
5926 : int32 sdInterfaceID; /* HDF SDS interface ID */
5927 : int32 swVgrpID; /* Swath Vgroup ID */
5928 : int32 rank; /* Rank of geolocation fields */
5929 : int32 nt; /* Number type of geolocation fields */
5930 : int32 dims[8]; /* Dimensions of geolocation fields */
5931 : int32 nElem; /* Number of elements to read */
5932 : int32 bndflag; /* +/-180 longitude boundary flag */
5933 : int32 lonTest; /* Longitude test flag */
5934 : int32 latTest; /* Latitude test flag */
5935 : int32 start[2]; /* Start array (read) */
5936 0 : int32 stride[2] = {1, 1}; /* Stride array (read) */
5937 : int32 edge[2]; /* Edge array (read) */
5938 0 : int32 regionID = -1; /* Region ID (return) */
5939 : int32 anyStart[2];/* ANYPOINT start array (read) */
5940 : int32 anyEdge[2]; /* ANYPOINT edge array (read) */
5941 :
5942 : float32 temp32; /* Temporary float32 variable */
5943 :
5944 : float64 lonTestVal; /* Longitude test value */
5945 : float64 latTestVal; /* Latitude test value */
5946 : float64 temp64; /* Temporary float64 variable */
5947 :
5948 : char *lonArr; /* Longitude data array */
5949 : char *latArr; /* Latitude data array */
5950 : char dimlist[256]; /* Dimension list (geolocation
5951 : * fields) */
5952 : char latName[17];/* Latitude field name */
5953 :
5954 :
5955 : /* Check for valid swath ID */
5956 : /* ------------------------ */
5957 0 : status = SWchkswid(swathID, "SWregionl_index", &fid, &sdInterfaceID,
5958 : &swVgrpID);
5959 :
5960 :
5961 : /* Inclusion mode must be between 0 and 2 */
5962 : /* -------------------------------------- */
5963 0 : if (mode < 0 || mode > 2)
5964 : {
5965 0 : status = -1;
5966 0 : HEpush(DFE_GENAPP, "SWregionl_index", __FILE__, __LINE__);
5967 0 : HEreport("Improper Inclusion Mode: %d.\n", mode);
5968 : }
5969 :
5970 :
5971 0 : if (status == 0)
5972 : {
5973 : /* Get "Longitude" field info */
5974 : /* -------------------------- */
5975 0 : statLon = SWfieldinfo(swathID, "Longitude", &rank, dims, &nt, dimlist);
5976 0 : if (statLon != 0)
5977 : {
5978 0 : status = -1;
5979 0 : HEpush(DFE_GENAPP, "SWregionl_index", __FILE__, __LINE__);
5980 0 : HEreport("\"Longitude\" field not found.\n");
5981 : }
5982 :
5983 : /* Get "Latitude" field info */
5984 : /* -------------------------- */
5985 0 : statLat = SWfieldinfo(swathID, "Latitude", &rank, dims, &nt, dimlist);
5986 0 : if (statLat != 0)
5987 : {
5988 : /* If not found check for "Colatitude" field info */
5989 : /* ---------------------------------------------- */
5990 0 : statCoLat = SWfieldinfo(swathID, "Colatitude", &rank, dims, &nt,
5991 : dimlist);
5992 0 : if (statCoLat != 0)
5993 : {
5994 : /* Check again for Geodeticlatitude */
5995 0 : statGeodeticLat = SWfieldinfo(swathID,
5996 : "GeodeticLatitude", &rank,
5997 : dims, &nt, dimlist);
5998 0 : if (statGeodeticLat != 0)
5999 : {
6000 : /* Neither "Latitude" nor "Colatitude" field found */
6001 : /* ----------------------------------------------- */
6002 0 : status = -1;
6003 0 : HEpush(DFE_GENAPP, "SWregionl_index", __FILE__, __LINE__);
6004 0 : HEreport(
6005 : "Neither \"Latitude\" nor \"Colatitude\" fields found.\n");
6006 : }
6007 : else
6008 : {
6009 : /* Latitude field is "Colatitude" */
6010 : /* ------------------------------ */
6011 0 : strcpy(latName, "GeodeticLatitude");
6012 : }
6013 : }
6014 : else
6015 : {
6016 : /* Latitude field is "Colatitude" */
6017 : /* ------------------------------ */
6018 0 : strcpy(latName, "Colatitude");
6019 : }
6020 : }
6021 : else
6022 : {
6023 : /* Latitude field is "Latitude" */
6024 : /* ---------------------------- */
6025 0 : strcpy(latName, "Latitude");
6026 : }
6027 :
6028 : /* This line modifies the dimlist variable so only the along-track */
6029 : /* dimension remains. */
6030 : /* --------------------------------------------------------------- */
6031 0 : (void) strtok(dimlist,",");
6032 0 : mapstatus = SWgeomapinfo(swathID,dimlist);
6033 0 : (void) strcpy(geodim,dimlist);
6034 :
6035 0 : if (status == 0)
6036 : {
6037 : /* Search along entire "Track" dimension from beginning to end */
6038 : /* ----------------------------------------------------------- */
6039 0 : start[0] = 0;
6040 0 : edge[0] = dims[0];
6041 :
6042 :
6043 : /* If 1D geolocation fields then set mode to MIDPOINT */
6044 : /* -------------------------------------------------- */
6045 0 : if (rank == 1)
6046 : {
6047 0 : mode = HDFE_MIDPOINT;
6048 : }
6049 :
6050 :
6051 0 : switch (mode)
6052 : {
6053 : /* If MIDPOINT search single point in middle of "CrossTrack" */
6054 : /* --------------------------------------------------------- */
6055 0 : case HDFE_MIDPOINT:
6056 :
6057 0 : start[1] = dims[1] / 2;
6058 0 : edge[1] = 1;
6059 :
6060 0 : break;
6061 :
6062 : /* If ENDPOINT search 2 points at either end of "CrossTrack" */
6063 : /* --------------------------------------------------------- */
6064 0 : case HDFE_ENDPOINT:
6065 :
6066 0 : start[1] = 0;
6067 0 : stride[1] = dims[1] - 1;
6068 0 : edge[1] = 2;
6069 :
6070 0 : break;
6071 :
6072 : /* If ANYPOINT do initial MIDPOINT search */
6073 : /* -------------------------------------- */
6074 0 : case HDFE_ANYPOINT:
6075 :
6076 0 : start[1] = dims[1] / 2;
6077 0 : edge[1] = 1;
6078 :
6079 0 : break;
6080 : }
6081 :
6082 :
6083 : /* Compute number of elements */
6084 : /* -------------------------- */
6085 0 : nElem = edge[0] * edge[1];
6086 :
6087 :
6088 : /* Allocate space for longitude and latitude (float64) */
6089 : /* --------------------------------------------------- */
6090 0 : lonArr = (char *) calloc(nElem, sizeof(float64));
6091 0 : if(lonArr == NULL)
6092 : {
6093 0 : HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__);
6094 0 : return(-1);
6095 : }
6096 :
6097 0 : latArr = (char *) calloc(nElem, sizeof(float64));
6098 0 : if(latArr == NULL)
6099 : {
6100 0 : HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__);
6101 0 : free(lonArr);
6102 0 : return(-1);
6103 : }
6104 :
6105 :
6106 : /* Allocate space for flag array (uint8) */
6107 : /* ------------------------------------- */
6108 0 : flag = (uint8 *) calloc(edge[0] + 1, 1);
6109 0 : if(flag == NULL)
6110 : {
6111 0 : HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__);
6112 0 : free(lonArr);
6113 0 : free(latArr);
6114 0 : return(-1);
6115 : }
6116 :
6117 :
6118 : /* Read Longitude and Latitude fields */
6119 : /* ---------------------------------- */
6120 0 : status = SWreadfield(swathID, "Longitude",
6121 : start, stride, edge, lonArr);
6122 0 : status = SWreadfield(swathID, latName,
6123 : start, stride, edge, latArr);
6124 :
6125 :
6126 :
6127 : /*
6128 : * If geolocation fields are FLOAT32 then cast each entry as
6129 : * FLOAT64
6130 : */
6131 0 : if (nt == DFNT_FLOAT32)
6132 : {
6133 0 : for (i = nElem - 1; i >= 0; i--)
6134 : {
6135 0 : memcpy(&temp32, lonArr + 4 * i, 4);
6136 0 : temp64 = (float64) temp32;
6137 0 : memcpy(lonArr + 8 * i, &temp64, 8);
6138 :
6139 0 : memcpy(&temp32, latArr + 4 * i, 4);
6140 0 : temp64 = (float64) temp32;
6141 0 : memcpy(latArr + 8 * i, &temp64, 8);
6142 : }
6143 : }
6144 :
6145 :
6146 : /* Set boundary flag */
6147 : /* ----------------- */
6148 :
6149 : /*
6150 : * This variable is set to 1 if the region of interest crosses
6151 : * the +/- 180 longitude boundary
6152 : */
6153 0 : bndflag = (cornerlon[0] < cornerlon[1]) ? 0 : 1;
6154 :
6155 :
6156 :
6157 : /* Main Search Loop */
6158 : /* ---------------- */
6159 :
6160 : /* For each track ... */
6161 : /* ------------------ */
6162 0 : for (i = 0; i < edge[0]; i++)
6163 : {
6164 : /* For each value from Cross Track ... */
6165 : /* ----------------------------------- */
6166 0 : for (j = 0; j < edge[1]; j++)
6167 : {
6168 : /* Read in single lon & lat values from data buffers */
6169 : /* ------------------------------------------------- */
6170 0 : memcpy(&lonTestVal, &lonArr[8 * (i * edge[1] + j)], 8);
6171 0 : memcpy(&latTestVal, &latArr[8 * (i * edge[1] + j)], 8);
6172 :
6173 :
6174 : /* If longitude value > 180 convert to -180 to 180 range */
6175 : /* ----------------------------------------------------- */
6176 0 : if (lonTestVal > 180)
6177 : {
6178 0 : lonTestVal = lonTestVal - 360;
6179 : }
6180 :
6181 : /* If Colatitude value convert to latitude value */
6182 : /* --------------------------------------------- */
6183 0 : if (statCoLat == 0)
6184 : {
6185 0 : latTestVal = 90 - latTestVal;
6186 : }
6187 :
6188 :
6189 : /* Test if lat value is within range */
6190 : /* --------------------------------- */
6191 0 : latTest = (latTestVal >= cornerlat[0] &&
6192 0 : latTestVal <= cornerlat[1]);
6193 :
6194 :
6195 0 : if (bndflag == 1)
6196 : {
6197 : /*
6198 : * If boundary flag set test whether longitude value
6199 : * is outside region and then flip
6200 : */
6201 0 : lonTest = (lonTestVal >= cornerlon[1] &&
6202 0 : lonTestVal <= cornerlon[0]);
6203 0 : lonTest = 1 - lonTest;
6204 : }
6205 : else
6206 : {
6207 0 : lonTest = (lonTestVal >= cornerlon[0] &&
6208 0 : lonTestVal <= cornerlon[1]);
6209 : }
6210 :
6211 :
6212 : /*
6213 : * If both longitude and latitude are within region set
6214 : * flag on for this track
6215 : */
6216 0 : if (lonTest + latTest == 2)
6217 : {
6218 0 : flag[i] = 1;
6219 0 : found = 1;
6220 0 : break;
6221 : }
6222 : }
6223 : }
6224 :
6225 :
6226 :
6227 : /* ANYPOINT search */
6228 : /* --------------- */
6229 0 : if (mode == HDFE_ANYPOINT && rank > 1)
6230 : {
6231 0 : free(lonArr);
6232 0 : free(latArr);
6233 :
6234 : /* Allocate space for an entire single cross track */
6235 : /* ----------------------------------------------- */
6236 0 : lonArr = (char *) calloc(dims[1], sizeof(float64));
6237 0 : if(lonArr == NULL)
6238 : {
6239 0 : HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__);
6240 0 : return(-1);
6241 : }
6242 0 : latArr = (char *) calloc(dims[1], sizeof(float64));
6243 0 : if(latArr == NULL)
6244 : {
6245 0 : HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__);
6246 0 : free(lonArr);
6247 0 : return(-1);
6248 : }
6249 :
6250 : /* Setup start and edge */
6251 : /* -------------------- */
6252 0 : anyStart[1] = 0;
6253 0 : anyEdge[0] = 1;
6254 0 : anyEdge[1] = dims[1];
6255 :
6256 :
6257 : /* For each track ... */
6258 : /* ------------------ */
6259 0 : for (i = 0; i < edge[0]; i++)
6260 : {
6261 :
6262 : /* If cross track not in region (with MIDPOINT search ... */
6263 : /* ------------------------------------------------------ */
6264 0 : if (flag[i] == 0)
6265 : {
6266 : /* Setup track start */
6267 : /* ----------------- */
6268 0 : anyStart[0] = i;
6269 :
6270 :
6271 : /* Read in lon and lat values for cross track */
6272 : /* ------------------------------------------ */
6273 0 : status = SWreadfield(swathID, "Longitude",
6274 : anyStart, NULL, anyEdge, lonArr);
6275 0 : status = SWreadfield(swathID, latName,
6276 : anyStart, NULL, anyEdge, latArr);
6277 :
6278 :
6279 :
6280 : /*
6281 : * If geolocation fields are FLOAT32 then cast each
6282 : * entry as FLOAT64
6283 : */
6284 0 : if (nt == DFNT_FLOAT32)
6285 : {
6286 0 : for (j = dims[1] - 1; j >= 0; j--)
6287 : {
6288 0 : memcpy(&temp32, lonArr + 4 * j, 4);
6289 0 : temp64 = (float64) temp32;
6290 0 : memcpy(lonArr + 8 * j, &temp64, 8);
6291 :
6292 0 : memcpy(&temp32, latArr + 4 * j, 4);
6293 0 : temp64 = (float64) temp32;
6294 0 : memcpy(latArr + 8 * j, &temp64, 8);
6295 : }
6296 : }
6297 :
6298 :
6299 : /* For each value from Cross Track ... */
6300 : /* ----------------------------------- */
6301 0 : for (j = 0; j < dims[1]; j++)
6302 : {
6303 : /* Read in single lon & lat values from buffers */
6304 : /* -------------------------------------------- */
6305 0 : memcpy(&lonTestVal, &lonArr[8 * j], 8);
6306 0 : memcpy(&latTestVal, &latArr[8 * j], 8);
6307 :
6308 :
6309 : /* If lon value > 180 convert to -180 - 180 range */
6310 : /* ---------------------------------------------- */
6311 0 : if (lonTestVal > 180)
6312 : {
6313 0 : lonTestVal = lonTestVal - 360;
6314 : }
6315 :
6316 : /* If Colatitude value convert to latitude value */
6317 : /* --------------------------------------------- */
6318 0 : if (statCoLat == 0)
6319 : {
6320 0 : latTestVal = 90 - latTestVal;
6321 : }
6322 :
6323 :
6324 : /* Test if lat value is within range */
6325 : /* --------------------------------- */
6326 0 : latTest = (latTestVal >= cornerlat[0] &&
6327 0 : latTestVal <= cornerlat[1]);
6328 :
6329 :
6330 0 : if (bndflag == 1)
6331 : {
6332 : /*
6333 : * If boundary flag set test whether
6334 : * longitude value is outside region and then
6335 : * flip
6336 : */
6337 0 : lonTest = (lonTestVal >= cornerlon[1] &&
6338 0 : lonTestVal <= cornerlon[0]);
6339 0 : lonTest = 1 - lonTest;
6340 : }
6341 : else
6342 : {
6343 0 : lonTest = (lonTestVal >= cornerlon[0] &&
6344 0 : lonTestVal <= cornerlon[1]);
6345 : }
6346 :
6347 :
6348 : /*
6349 : * If both longitude and latitude are within
6350 : * region set flag on for this track
6351 : */
6352 0 : if (lonTest + latTest == 2)
6353 : {
6354 0 : flag[i] = 1;
6355 0 : found = 1;
6356 0 : break;
6357 : }
6358 : }
6359 : }
6360 : }
6361 : }
6362 : /*
6363 : for (j1 = 0; j1 < edge[0]; j1++)
6364 : {
6365 : idxrange[j1] = (int32) flag[j1];
6366 : }
6367 : */
6368 : /* If within region setup Region Structure */
6369 : /* --------------------------------------- */
6370 0 : if (found == 1)
6371 : {
6372 : /* For all entries in SWXRegion array ... */
6373 : /* -------------------------------------- */
6374 0 : for (k = 0; k < NSWATHREGN; k++)
6375 : {
6376 : /* If empty region ... */
6377 : /* ------------------- */
6378 0 : if (SWXRegion[k] == 0)
6379 : {
6380 : /* Allocate space for region entry */
6381 : /* ------------------------------- */
6382 0 : SWXRegion[k] = (struct swathRegion *)
6383 0 : calloc(1, sizeof(struct swathRegion));
6384 0 : if(SWXRegion[k] == NULL)
6385 : {
6386 0 : HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__);
6387 0 : return(-1);
6388 : }
6389 :
6390 : /* Store file and swath ID */
6391 : /* ----------------------- */
6392 0 : SWXRegion[k]->fid = fid;
6393 0 : SWXRegion[k]->swathID = swathID;
6394 :
6395 :
6396 : /* Set Start & Stop Vertical arrays to -1 */
6397 : /* -------------------------------------- */
6398 0 : for (j = 0; j < 8; j++)
6399 : {
6400 0 : SWXRegion[k]->StartVertical[j] = -1;
6401 0 : SWXRegion[k]->StopVertical[j] = -1;
6402 0 : SWXRegion[k]->StartScan[j] = -1;
6403 0 : SWXRegion[k]->StopScan[j] = -1;
6404 : }
6405 :
6406 :
6407 : /* Set region ID */
6408 : /* ------------- */
6409 0 : regionID = k;
6410 0 : break;
6411 : }
6412 : }
6413 0 : if (k >= NSWATHREGN)
6414 : {
6415 0 : HEpush(DFE_GENAPP, "SWregionl_index", __FILE__, __LINE__);
6416 0 : HEreport(
6417 : "regionID exceeded NSWATHREGN.\n");
6418 0 : return (-1);
6419 : }
6420 :
6421 : /* Find start and stop of regions */
6422 : /* ------------------------------ */
6423 :
6424 : /* Subtract previous flag value from current one */
6425 : /* --------------------------------------------- */
6426 :
6427 : /*
6428 : * Transition points will have flag value (+1) start or
6429 : * (255 = (uint8) -1) stop of region
6430 : */
6431 0 : for (i = edge[0]; i > 0; i--)
6432 : {
6433 0 : flag[i] -= flag[i - 1];
6434 : }
6435 :
6436 :
6437 0 : for (i = 0; i <= edge[0]; i++)
6438 : {
6439 : /* Start of region */
6440 : /* --------------- */
6441 0 : if (flag[i] == 1)
6442 : {
6443 : /* Delyth Jones Moved the increment of the region down
6444 : to next if statement j = ++SWXRegion[k]->nRegions; */
6445 :
6446 : /* using temp value, if not equal to stop region
6447 : invalid region otherwise ok Delyth Jones */
6448 0 : tmpVal = i+1;
6449 : }
6450 :
6451 : /* End of region */
6452 : /* ------------- */
6453 0 : if (flag[i] == 255)
6454 : {
6455 0 : if( tmpVal!=i )
6456 : {
6457 : /* Increment (multiple) region counter */
6458 : /* ----------------------------------- */
6459 0 : j = ++SWXRegion[k]->nRegions;
6460 :
6461 0 : if (mapstatus == 2)
6462 : {
6463 0 : l = i;
6464 0 : if ((tmpVal-1) % 2 == 1)
6465 : {
6466 0 : tmpVal = tmpVal + 1;
6467 : }
6468 :
6469 0 : if ((l-1) % 2 == 0)
6470 : {
6471 0 : l = l - 1;
6472 : }
6473 : }
6474 0 : SWXRegion[k]->StartRegion[j - 1] = tmpVal-1;
6475 0 : idxrange[0] = tmpVal - 1;
6476 0 : SWXRegion[k]->StopRegion[j - 1] = l - 1;
6477 0 : idxrange[1] = l - 1;
6478 0 : validReg = 0;
6479 : }
6480 : }
6481 :
6482 : }
6483 :
6484 : }
6485 0 : free(lonArr);
6486 0 : free(latArr);
6487 0 : free(flag);
6488 : }
6489 : }
6490 0 : if(validReg==0)
6491 : {
6492 0 : return (regionID);
6493 : }
6494 : else
6495 : {
6496 0 : return (-1);
6497 : }
6498 :
6499 : }
6500 :
6501 :
6502 :
6503 : /*----------------------------------------------------------------------------|
6504 : | BEGIN_PROLOG |
6505 : | |
6506 : | FUNCTION: SWdeftimeperiod |
6507 : | |
6508 : | DESCRIPTION: Finds swath cross tracks observed during time period and |
6509 : | returns period ID |
6510 : | |
6511 : | region ID |
6512 : | DESCRIPTION: |
6513 : | |
6514 : | |
6515 : | Return Value Type Units Description |
6516 : | ============ ====== ========= ===================================== |
6517 : | periodID int32 (Period ID) or (-1) if failed |
6518 : | |
6519 : | INPUTS: |
6520 : | swathID int32 Swath structure ID |
6521 : | starttime float64 TAI sec Start of time period |
6522 : | stoptime float64 TAI sec Stop of time period |
6523 : | mode int32 Search mode |
6524 : | HDFE_MIDPOINT - Use midpoint of Xtrack |
6525 : | HDFE_ENDPOINT - Use endpoints of Xtrack |
6526 : | |
6527 : | OUTPUTS: |
6528 : | None |
6529 : | |
6530 : | NOTES: |
6531 : | |
6532 : | |
6533 : | Date Programmer Description |
6534 : | ====== ============ ================================================= |
6535 : | Jun 96 Joel Gales Original Programmer |
6536 : | |
6537 : | END_PROLOG |
6538 : -----------------------------------------------------------------------------*/
6539 : int32
6540 0 : SWdeftimeperiod(int32 swathID, float64 starttime, float64 stoptime,
6541 : int32 mode)
6542 : {
6543 :
6544 : intn i; /* Loop index */
6545 : intn j; /* Loop index */
6546 0 : intn k = 0; /* Loop index */
6547 : intn status; /* routine return status variable */
6548 : intn statTime; /* Status from SWfieldinfo for time */
6549 :
6550 0 : uint8 found = 0; /* Found flag */
6551 :
6552 : int32 fid; /* HDF-EOS file ID */
6553 : int32 sdInterfaceID; /* HDF SDS interface ID */
6554 : int32 swVgrpID; /* Swath Vgroup ID */
6555 : int32 rank; /* Rank of geolocation fields */
6556 : int32 nt; /* Number type of geolocation fields */
6557 : int32 dims[8]; /* Dimensions of geolocation fields */
6558 : int32 start[2]; /* Start array (read) */
6559 0 : int32 stride[2] = {1, 1}; /* Stride array (read) */
6560 : int32 edge[2]; /* Edge array (read) */
6561 0 : int32 periodID = -1; /* Period ID (return) */
6562 : int32 dum; /* Dummy (loop) variable */
6563 :
6564 : float64 time64Test; /* Time test value */
6565 0 : float64 *time64 = NULL; /* Time data array */
6566 :
6567 : char dimlist[256]; /* Dimension list (geolocation fields) */
6568 :
6569 : /* Check for valid swath ID */
6570 : /* ------------------------ */
6571 0 : status = SWchkswid(swathID, "SWdeftimeperiod", &fid, &sdInterfaceID,
6572 : &swVgrpID);
6573 :
6574 0 : if (status == 0)
6575 : {
6576 : /* Get "Time" field info */
6577 : /* --------------------- */
6578 0 : statTime = SWfieldinfo(swathID, "Time", &rank, dims, &nt, dimlist);
6579 0 : if (statTime != 0)
6580 : {
6581 0 : status = -1;
6582 0 : HEpush(DFE_GENAPP, "SWdeftimeperiod", __FILE__, __LINE__);
6583 0 : HEreport("\"Time\" field not found.\n");
6584 : }
6585 :
6586 0 : if (status == 0)
6587 : {
6588 : /* Search along entire "Track" dimension from beginning to end */
6589 : /* ----------------------------------------------------------- */
6590 0 : start[0] = 0;
6591 0 : edge[0] = dims[0];
6592 :
6593 :
6594 : /* If 1D geolocation fields then set mode to MIDPOINT */
6595 : /* -------------------------------------------------- */
6596 0 : if (rank == 1)
6597 : {
6598 0 : mode = HDFE_MIDPOINT;
6599 : }
6600 :
6601 :
6602 0 : switch (mode)
6603 : {
6604 :
6605 : /* If MIDPOINT search single point in middle of "CrossTrack" */
6606 : /* --------------------------------------------------------- */
6607 0 : case HDFE_MIDPOINT:
6608 :
6609 0 : start[1] = dims[1] / 2;
6610 0 : edge[1] = 1;
6611 :
6612 :
6613 : /* Allocate space for time data */
6614 : /* ---------------------------- */
6615 0 : time64 = (float64 *) calloc(edge[0], 8);
6616 0 : if(time64 == NULL)
6617 : {
6618 0 : HEpush(DFE_NOSPACE,"SWdeftimeperiod", __FILE__, __LINE__);
6619 0 : return(-1);
6620 : }
6621 :
6622 :
6623 : /* Read "Time" field */
6624 : /* ----------------- */
6625 0 : status = SWreadfield(swathID, "Time",
6626 : start, NULL, edge, time64);
6627 0 : break;
6628 :
6629 :
6630 : /* If ENDPOINT search 2 points at either end of "CrossTrack" */
6631 : /* --------------------------------------------------------- */
6632 0 : case HDFE_ENDPOINT:
6633 0 : start[1] = 0;
6634 0 : stride[1] = dims[1] - 1;
6635 0 : edge[1] = 2;
6636 :
6637 :
6638 : /* Allocate space for time data */
6639 : /* ---------------------------- */
6640 0 : time64 = (float64 *) calloc(edge[0] * 2, 8);
6641 0 : if(time64 == NULL)
6642 : {
6643 0 : HEpush(DFE_NOSPACE,"SWdeftimeperiod", __FILE__, __LINE__);
6644 0 : return(-1);
6645 : }
6646 :
6647 : /* Read "Time" field */
6648 : /* ----------------- */
6649 0 : status = SWreadfield(swathID, "Time",
6650 : start, stride, edge, time64);
6651 0 : break;
6652 :
6653 : }
6654 :
6655 0 : if (time64)
6656 : {
6657 : /* For each track (from top) ... */
6658 : /* ----------------------------- */
6659 0 : for (i = 0; i < edge[0]; i++)
6660 : {
6661 : /* For each value from Cross Track ... */
6662 : /* ----------------------------------- */
6663 0 : for (j = 0; j < edge[1]; j++)
6664 : {
6665 :
6666 : /* Get time test value */
6667 : /* ------------------- */
6668 0 : time64Test = time64[i * edge[1] + j];
6669 :
6670 :
6671 : /* If within time period ... */
6672 : /* ------------------------- */
6673 0 : if (time64Test >= starttime &&
6674 : time64Test <= stoptime)
6675 : {
6676 : /* Set found flag */
6677 : /* -------------- */
6678 0 : found = 1;
6679 :
6680 :
6681 : /* For all entries in SWXRegion array ... */
6682 : /* -------------------------------------- */
6683 0 : for (k = 0; k < NSWATHREGN; k++)
6684 : {
6685 : /* If empty region ... */
6686 : /* ------------------- */
6687 0 : if (SWXRegion[k] == 0)
6688 : {
6689 : /* Allocate space for region entry */
6690 : /* ------------------------------- */
6691 0 : SWXRegion[k] = (struct swathRegion *)
6692 0 : calloc(1, sizeof(struct swathRegion));
6693 0 : if(SWXRegion[k] == NULL)
6694 : {
6695 0 : HEpush(DFE_NOSPACE,"SWdeftimeperiod", __FILE__, __LINE__);
6696 0 : return(-1);
6697 : }
6698 :
6699 : /* Store file and swath ID */
6700 : /* ----------------------- */
6701 0 : SWXRegion[k]->fid = fid;
6702 0 : SWXRegion[k]->swathID = swathID;
6703 :
6704 :
6705 : /* Set number of isolated regions to 1 */
6706 : /* ----------------------------------- */
6707 0 : SWXRegion[k]->nRegions = 1;
6708 :
6709 :
6710 : /* Set start of region to first track found */
6711 : /* ---------------------------------------- */
6712 0 : SWXRegion[k]->StartRegion[0] = i;
6713 :
6714 :
6715 : /* Set Start & Stop Vertical arrays to -1 */
6716 : /* -------------------------------------- */
6717 0 : for (dum = 0; dum < 8; dum++)
6718 : {
6719 0 : SWXRegion[k]->StartVertical[dum] = -1;
6720 0 : SWXRegion[k]->StopVertical[dum] = -1;
6721 0 : SWXRegion[k]->StartScan[dum] = -1;
6722 0 : SWXRegion[k]->StopScan[dum] = -1;
6723 : }
6724 :
6725 :
6726 : /* Set period ID */
6727 : /* ------------- */
6728 0 : periodID = k;
6729 :
6730 0 : break; /* Break from "k" loop */
6731 : }
6732 : }
6733 : }
6734 0 : if (found == 1)
6735 : {
6736 0 : break; /* Break from "j" loop */
6737 : }
6738 : }
6739 0 : if (found == 1)
6740 : {
6741 0 : break; /* Break from "i" loop */
6742 : }
6743 : }
6744 :
6745 :
6746 :
6747 : /* Clear found flag */
6748 : /* ---------------- */
6749 0 : found = 0;
6750 :
6751 :
6752 : /* For each track (from bottom) ... */
6753 : /* -------------------------------- */
6754 0 : for (i = edge[0] - 1; i >= 0; i--)
6755 : {
6756 : /* For each value from Cross Track ... */
6757 : /* ----------------------------------- */
6758 0 : for (j = 0; j < edge[1]; j++)
6759 : {
6760 :
6761 : /* Get time test value */
6762 : /* ------------------- */
6763 0 : time64Test = time64[i * edge[1] + j];
6764 :
6765 :
6766 : /* If within time period ... */
6767 : /* ------------------------- */
6768 0 : if (time64Test >= starttime &&
6769 : time64Test <= stoptime)
6770 : {
6771 : /* Set found flag */
6772 : /* -------------- */
6773 0 : found = 1;
6774 :
6775 : /* Set start of region to first track found */
6776 : /* ---------------------------------------- */
6777 0 : SWXRegion[k]->StopRegion[0] = i;
6778 :
6779 0 : break; /* Break from "j" loop */
6780 : }
6781 : }
6782 0 : if (found == 1)
6783 : {
6784 0 : break; /* Break from "i" loop */
6785 : }
6786 : }
6787 :
6788 0 : free(time64);
6789 : }
6790 : }
6791 : }
6792 :
6793 0 : return (periodID);
6794 : }
6795 :
6796 : /*----------------------------------------------------------------------------|
6797 : | BEGIN_PROLOG |
6798 : | |
6799 : | FUNCTION: SWextractregion |
6800 : | |
6801 : | DESCRIPTION: Retrieves data from specified region. |
6802 : | |
6803 : | |
6804 : | Return Value Type Units Description |
6805 : | ============ ====== ========= ===================================== |
6806 : | status intn return status (0) SUCCEED, (-1) FAIL |
6807 : | |
6808 : | INPUTS: |
6809 : | swathID int32 Swath structure ID |
6810 : | regionID int32 Region ID |
6811 : | fieldname char Fieldname |
6812 : | externalflag int32 External geolocation fields flag |
6813 : | HDFE_INTERNAL (0) |
6814 : | HDFE_EXTERNAL (1) |
6815 : | |
6816 : | OUTPUTS: |
6817 : | buffer void Data buffer containing subsetted region |
6818 : | |
6819 : | NOTES: |
6820 : | |
6821 : | |
6822 : | Date Programmer Description |
6823 : | ====== ============ ================================================= |
6824 : | Jun 96 Joel Gales Original Programmer |
6825 : | Aug 96 Joel Gales Add vertical subsetting |
6826 : | Oct 96 Joel Gales Mapping offset value not read from SWmapinfo |
6827 : | Dec 96 Joel Gales Vert Subset overwriting data buffer |
6828 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
6829 : | Mar 97 Joel Gales Add support for l_index mapping |
6830 : | Jul 99 DaW Add support for floating scene subsetting |
6831 : | Feb 03 Terry Haran/ |
6832 : | Abe Taaheri Forced map offset to 0 so that data is extracted |
6833 : | without offset consideration. This will preserve |
6834 : | original mapping between geofields and the data |
6835 : | field. |
6836 : | |
6837 : | END_PROLOG |
6838 : -----------------------------------------------------------------------------*/
6839 : intn
6840 0 : SWextractregion(int32 swathID, int32 regionID, const char *fieldname,
6841 : int32 externalflag, VOIDP buffer)
6842 :
6843 : {
6844 : intn i; /* Loop index */
6845 : intn j; /* Loop index */
6846 : intn k; /* Loop index */
6847 : intn l; /* Loop index */
6848 : intn status; /* routine return status variable */
6849 0 : intn long_status = 3; /* routine return status variable */
6850 : /* for longitude */
6851 0 : intn land_status = 3; /* Used for L7 float scene sub. */
6852 0 : intn statMap = -1; /* Status from SWmapinfo */
6853 :
6854 0 : uint8 found = 0; /* Found flag */
6855 0 : uint8 vfound = 0; /* Found flag for vertical subsetting*/
6856 : /* --- xhua */
6857 0 : uint8 scene_cnt = 0; /* Used for L7 float scene sub. */
6858 0 : uint8 detect_cnt = 0; /* Used to convert scan to scanline */
6859 : /* L7 float scene sub. */
6860 :
6861 : int32 fid; /* HDF-EOS file ID */
6862 : int32 sdInterfaceID; /* HDF SDS interface ID */
6863 : int32 swVgrpID; /* Swath Vgroup ID */
6864 :
6865 0 : int32 numtype = 0; /* Used for L7 float scene sub. */
6866 0 : int32 count = 0; /* Used for L7 float scene sub. */
6867 0 : int32 l_index = 0; /* Geo Dim Index */
6868 : int32 nDim; /* Number of dimensions */
6869 : int32 slen[64]; /* String length array */
6870 : int32 dum; /* Dummy variable */
6871 0 : int32 offset = 0; /* Mapping offset */
6872 0 : int32 incr = 0; /* Mapping increment */
6873 : int32 nXtrk; /* Number of cross tracks */
6874 0 : int32 scan_shift = 0; /* Used to take out partial scans */
6875 : int32 dumdims[8]; /* Dimensions from SWfieldinfo */
6876 : int32 start[8]; /* Start array for data read */
6877 : int32 edge[8]; /* Edge array for data read */
6878 : int32 dims[8]; /* Dimensions */
6879 0 : int32 rank = 0; /* Field rank */
6880 0 : int32 rk = 0; /* Field rank */
6881 0 : int32 ntype = 0; /* Field number type */
6882 0 : int32 bufOffset = 0; /* Output buffer offset */
6883 : int32 size; /* Size of data buffer */
6884 0 : int32 idxMapElem = -1; /* Number of l_index map elements */
6885 0 : int32 *idxmap = NULL; /* Pointer to l_index mapping array */
6886 :
6887 0 : int32 startscanline = 0;
6888 0 : int32 stopscanline = 0;
6889 0 : char *dfieldlist = (char *)NULL;
6890 0 : int32 strbufsize = 0;
6891 : int32 dfrank[8];
6892 : int32 numtype2[8];
6893 0 : uint16 *buffer2 = (uint16 *)NULL;
6894 0 : uint16 *tbuffer = (uint16 *)NULL;
6895 : int32 dims2[8];
6896 0 : int32 nt = 0;
6897 0 : int32 startscandim = -1;
6898 0 : int32 stopscandim = -1;
6899 0 : int32 rank2 = 0;
6900 :
6901 : char dimlist[256]; /* Dimension list */
6902 : char geodim[256];/* Geolocation field dimension list */
6903 : char tgeodim[256];/* Time field dimension list */
6904 : char dgeodim[256];/* Data field dimension list for subsetting */
6905 : char utlbuf[256];/* Utility buffer */
6906 : char *ptr[64]; /* String pointer array */
6907 :
6908 :
6909 :
6910 : /* Check for valid swath ID */
6911 : /* ------------------------ */
6912 0 : status = SWchkswid(swathID, "SWextractregion", &fid, &sdInterfaceID,
6913 : &swVgrpID);
6914 :
6915 :
6916 : /* Check for valid region ID */
6917 : /* ------------------------- */
6918 0 : if (status == 0)
6919 : {
6920 0 : if (regionID < 0 || regionID >= NSWATHREGN)
6921 : {
6922 0 : status = -1;
6923 0 : HEpush(DFE_RANGE, "SWextractregion", __FILE__, __LINE__);
6924 0 : HEreport("Invalid Region id: %d.\n", regionID);
6925 : }
6926 : }
6927 :
6928 :
6929 :
6930 : /* Check for active region ID */
6931 : /* -------------------------- */
6932 0 : if (status == 0)
6933 : {
6934 0 : if (SWXRegion[regionID] == 0)
6935 : {
6936 0 : status = -1;
6937 0 : HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__);
6938 0 : HEreport("Inactive Region ID: %d.\n", regionID);
6939 : }
6940 : }
6941 :
6942 :
6943 : /* This code checks for the attribute detector_count */
6944 : /* which is found in Landsat 7 files. It is used */
6945 : /* for some of the loops. */
6946 : /* ================================================= */
6947 0 : if (status == 0 && SWXRegion[regionID]->scanflag == 1)
6948 : {
6949 0 : land_status = SWattrinfo(swathID, "detector_count", &numtype, &count);
6950 0 : if (land_status == 0)
6951 0 : land_status = SWreadattr(swathID, "detector_count", &detect_cnt);
6952 : }
6953 :
6954 : /* Check that geo file and data file are same for INTERNAL subsetting */
6955 : /* ------------------------------------------------------------------ */
6956 0 : if (status == 0)
6957 : {
6958 0 : if (SWXRegion[regionID]->fid != fid && externalflag != HDFE_EXTERNAL)
6959 : {
6960 0 : status = -1;
6961 0 : HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__);
6962 0 : HEreport("Region is not defined for this file.\n");
6963 : }
6964 : }
6965 :
6966 :
6967 :
6968 : /* Check that geo swath and data swath are same for INTERNAL subsetting */
6969 : /* -------------------------------------------------------------------- */
6970 0 : if (status == 0)
6971 : {
6972 0 : if (SWXRegion[regionID]->swathID != swathID &&
6973 : externalflag != HDFE_EXTERNAL)
6974 : {
6975 0 : status = -1;
6976 0 : HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__);
6977 0 : HEreport("Region is not defined for this Swath.\n");
6978 : }
6979 : }
6980 :
6981 :
6982 :
6983 : /* Check for valid fieldname */
6984 : /* ------------------------- */
6985 0 : if (status == 0)
6986 : {
6987 :
6988 : /* Get data field info */
6989 : /* ------------------- */
6990 0 : status = SWfieldinfo(swathID, fieldname, &rank,
6991 : dims, &ntype, dimlist);
6992 :
6993 0 : if (status != 0)
6994 : {
6995 0 : status = -1;
6996 0 : HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__);
6997 0 : HEreport("Field \"%s\" Not Found.\n", fieldname);
6998 : }
6999 : }
7000 :
7001 :
7002 : /* No problems so proceed ... */
7003 : /* -------------------------- */
7004 0 : if (status == 0)
7005 : {
7006 :
7007 :
7008 : /* Initialize start and edge for all dimensions */
7009 : /* -------------------------------------------- */
7010 0 : for (j = 0; j < rank; j++)
7011 : {
7012 0 : start[j] = 0;
7013 0 : edge[j] = dims[j];
7014 : }
7015 :
7016 :
7017 : /* Vertical Subset */
7018 : /* --------------- */
7019 0 : for (j = 0; j < 8; j++)
7020 : {
7021 : /* If active vertical subset ... */
7022 : /* ----------------------------- */
7023 0 : if (SWXRegion[regionID]->StartVertical[j] != -1)
7024 : {
7025 :
7026 : /* Find vertical dimension within dimlist */
7027 : /* -------------------------------------- */
7028 0 : dum = EHstrwithin(SWXRegion[regionID]->DimNamePtr[j],
7029 : dimlist, ',');
7030 :
7031 : /* If dimension found ... */
7032 : /* ---------------------- */
7033 0 : if (dum != -1)
7034 : {
7035 : /* Compute start and edge for vertical dimension */
7036 : /* --------------------------------------------- */
7037 0 : vfound = 1; /* xhua */
7038 0 : start[dum] = SWXRegion[regionID]->StartVertical[j];
7039 0 : edge[dum] = SWXRegion[regionID]->StopVertical[j] -
7040 0 : SWXRegion[regionID]->StartVertical[j] + 1;
7041 : }
7042 : else
7043 : {
7044 : /* Vertical dimension not found */
7045 : /* ---------------------------- */
7046 0 : status = -1;
7047 0 : HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__);
7048 0 : HEreport("Vertical Dimension Not Found: \"%s\".\n",
7049 0 : SWXRegion[regionID]->DimNamePtr);
7050 : }
7051 : }
7052 : } /* End of Vertical Subset loop */
7053 :
7054 :
7055 :
7056 : /* No problems so proceed ... */
7057 : /* -------------------------- */
7058 0 : if (status == 0)
7059 : {
7060 : /* If non-vertical subset regions defined ... */
7061 : /* ------------------------------------------ */
7062 0 : if (SWXRegion[regionID]->nRegions > 0)
7063 : {
7064 :
7065 : /* Get geolocation dimension name */
7066 : /* ------------------------------ */
7067 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,
7068 : "Longitude", &dum,
7069 : dumdims, &dum, geodim);
7070 0 : long_status = status;
7071 :
7072 : /* If Time field being used, check for dimensions */
7073 : /* ---------------------------------------------- */
7074 0 : if (timeflag == 1)
7075 : {
7076 : /* code change to fix time subset bug for Landsat7 */
7077 :
7078 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,
7079 : "Time", &dum,
7080 : dumdims, &dum, tgeodim);
7081 :
7082 0 : if (strcmp(geodim, tgeodim) != 0)
7083 : {
7084 0 : strcpy(geodim, tgeodim);
7085 : }
7086 : }
7087 0 : timeflag = 0;
7088 :
7089 : /* If defscanregion being used, get dimensions */
7090 : /* of field being used */
7091 : /* ---------------------------------------------- */
7092 0 : if (SWXRegion[regionID]->scanflag == 1)
7093 : {
7094 0 : (void) SWnentries(SWXRegion[regionID]->swathID,4,&strbufsize);
7095 0 : dfieldlist = (char *)calloc(strbufsize + 1, sizeof(char));
7096 0 : (void) SWinqdatafields(SWXRegion[regionID]->swathID,dfieldlist,dfrank,numtype2);
7097 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,dfieldlist,&dum,dumdims,&dum,dgeodim);
7098 :
7099 : /* The dimensions have to be switched, because */
7100 : /* the mappings force a geodim and datadim */
7101 : /* so to find the mapping, the dimensions must */
7102 : /* be switched, but the subsetting will still */
7103 : /* be based on the correct dimensions */
7104 : /* ------------------------------------------- */
7105 0 : if (strcmp(dgeodim,dimlist) != 0 || long_status == -1)
7106 : {
7107 0 : strcpy(geodim,dimlist);
7108 0 : strcpy(dimlist,dgeodim);
7109 : }
7110 : }
7111 :
7112 :
7113 : /* Get "Track" (first) Dimension from geo dimlist */
7114 : /* ---------------------------------------------- */
7115 0 : nDim = EHparsestr(geodim, ',', ptr, slen);
7116 0 : geodim[slen[0]] = 0;
7117 :
7118 :
7119 : /* Parse Data Field Dimlist & find mapping */
7120 : /* --------------------------------------- */
7121 0 : nDim = EHparsestr(dimlist, ',', ptr, slen);
7122 :
7123 :
7124 : /* Loop through all dimensions and search for mapping */
7125 : /* -------------------------------------------------- */
7126 0 : for (i = 0; i < nDim; i++)
7127 : {
7128 0 : memcpy(utlbuf, ptr[i], slen[i]);
7129 0 : utlbuf[slen[i]] = 0;
7130 0 : statMap = SWmapinfo(swathID, geodim, utlbuf,
7131 : &offset, &incr);
7132 :
7133 :
7134 : /*
7135 : * Force offset to 0.
7136 : * We're not changing the mapping, so we want
7137 : * the original offset to apply to the subsetted data.
7138 : * Otherwise, bad things happen, such as subsetting
7139 : * past the end of the original data, and being unable
7140 : * to read the first <offset> elements of the
7141 : * original data.
7142 : * The offset is only important for aligning the
7143 : * data with interpolated (incr > 0) or decimated
7144 : * (incr < 0) geolocation information for the data.
7145 : */
7146 :
7147 0 : offset = 0;
7148 :
7149 :
7150 : /* Mapping found */
7151 : /* ------------- */
7152 0 : if (statMap == 0)
7153 : {
7154 0 : found = 1;
7155 0 : l_index = i;
7156 0 : break;
7157 : }
7158 : }
7159 :
7160 :
7161 : /* If mapping not found check for geodim within dimlist */
7162 : /* ---------------------------------------------------- */
7163 0 : if (found == 0)
7164 : {
7165 0 : l_index = EHstrwithin(geodim, dimlist, ',');
7166 :
7167 : /* Geo dimension found within subset field dimlist */
7168 : /* ----------------------------------------------- */
7169 0 : if (l_index != -1)
7170 : {
7171 0 : found = 1;
7172 0 : offset = 0;
7173 0 : incr = 1;
7174 : }
7175 : }
7176 :
7177 :
7178 :
7179 : /* If mapping not found check for l_indexed mapping */
7180 : /* ---------------------------------------------- */
7181 0 : if (found == 0)
7182 : {
7183 : /* Get size of geo dim & allocate space of l_index mapping */
7184 : /* ----------------------------------------------------- */
7185 0 : dum = SWdiminfo(swathID, geodim);
7186 :
7187 : /* For Landsat files, the l_index mapping has two values */
7188 : /* for each point, a left and right point. So for a 37 */
7189 : /* scene band file there are 2x2 points for each scene */
7190 : /* meaning, 2x2x37 = 148 values. The above function */
7191 : /* only returns the number of values in the track */
7192 : /* dimension. */
7193 : /* ----------------------------------------------------- */
7194 0 : if(land_status == 0)
7195 0 : if(strcmp(fieldname, "Latitude") == 0 ||
7196 0 : strcmp(fieldname, "Longitude") == 0)
7197 : {
7198 0 : dum = dum * 2;
7199 : }
7200 0 : idxmap = (int32 *) calloc(dum, sizeof(int32));
7201 0 : if(idxmap == NULL)
7202 : {
7203 0 : HEpush(DFE_NOSPACE,"SWextractregion", __FILE__, __LINE__);
7204 0 : return(-1);
7205 : }
7206 :
7207 : /* Loop through all dimensions and search for mapping */
7208 : /* -------------------------------------------------- */
7209 0 : for (i = 0; i < nDim; i++)
7210 : {
7211 0 : memcpy(utlbuf, ptr[i], slen[i]);
7212 0 : utlbuf[slen[i]] = 0;
7213 :
7214 : idxMapElem =
7215 0 : SWidxmapinfo(swathID, geodim, utlbuf, idxmap);
7216 :
7217 :
7218 : /* Mapping found */
7219 : /* ------------- */
7220 0 : if (idxMapElem != -1)
7221 : {
7222 0 : found = 1;
7223 0 : l_index = i;
7224 0 : break;
7225 : }
7226 : }
7227 : }
7228 :
7229 :
7230 : /* If regular mapping found ... */
7231 : /* ---------------------------- */
7232 0 : if (found == 1 && idxMapElem == -1)
7233 : {
7234 0 : for (k = 0; k < SWXRegion[regionID]->nRegions; k++)
7235 : {
7236 0 : if (k > 0)
7237 : {
7238 : /* Compute size in bytes of previous region */
7239 : /* ---------------------------------------- */
7240 0 : size = edge[0];
7241 0 : for (j = 1; j < rank; j++)
7242 : {
7243 0 : size *= edge[j];
7244 : }
7245 0 : size *= DFKNTsize(ntype);
7246 :
7247 :
7248 : /* Compute output buffer offset */
7249 : /* ---------------------------- */
7250 0 : bufOffset += size;
7251 : }
7252 : else
7253 : {
7254 : /* Initialize output buffer offset */
7255 : /* ------------------------------- */
7256 0 : bufOffset = 0;
7257 : }
7258 :
7259 :
7260 : /* Compute number of cross tracks in region */
7261 : /* ---------------------------------------- */
7262 0 : nXtrk = SWXRegion[regionID]->StopRegion[k] -
7263 0 : SWXRegion[regionID]->StartRegion[k] + 1;
7264 :
7265 :
7266 : /* Positive increment (geodim <= datadim) */
7267 : /* -------------------------------------- */
7268 0 : if (incr > 0)
7269 : {
7270 0 : if (SWXRegion[regionID]->scanflag == 1)
7271 : {
7272 0 : start[l_index] = SWXRegion[regionID]->StartRegion[k]/incr;
7273 0 : if(SWXRegion[regionID]->band8flag == 2 ||
7274 0 : SWXRegion[regionID]->band8flag == 3)
7275 : {
7276 0 : start[l_index] = (SWXRegion[regionID]->StartRegion[k]+detect_cnt)/incr;
7277 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,"scan_no",&rank,dims2,&nt,dimlist);
7278 0 : buffer2 = (uint16 *)calloc(dims2[0], sizeof(uint16));
7279 0 : status = SWreadfield(SWXRegion[regionID]->swathID,"scan_no",NULL,NULL,NULL,buffer2);
7280 0 : if(incr == 1)
7281 0 : start[l_index] = start[l_index] - (buffer2[0] * detect_cnt);
7282 : else
7283 0 : start[l_index] = start[l_index] - buffer2[0];
7284 0 : free(buffer2);
7285 : }
7286 0 : scan_shift = nXtrk % incr;
7287 0 : if(scan_shift != 0)
7288 0 : nXtrk = nXtrk - scan_shift;
7289 0 : edge[l_index] = nXtrk / incr;
7290 0 : if (nXtrk % incr != 0)
7291 0 : edge[l_index]++;
7292 0 : if(long_status == -1 || incr == 1)
7293 : {
7294 0 : if( detect_cnt == 0 )
7295 0 : return -1;
7296 0 : scan_shift = nXtrk % detect_cnt;
7297 0 : if(scan_shift != 0)
7298 0 : edge[l_index] = nXtrk - scan_shift;
7299 : }
7300 :
7301 : }
7302 : else
7303 : {
7304 0 : start[l_index] = SWXRegion[regionID]->StartRegion[k] * incr + offset;
7305 0 : edge[l_index] = nXtrk * incr - offset;
7306 : }
7307 : }
7308 : else
7309 : {
7310 : /* Negative increment (geodim > datadim) */
7311 : /* ------------------------------------- */
7312 0 : start[l_index] = SWXRegion[regionID]->StartRegion[k]
7313 0 : / (-incr) + offset;
7314 0 : edge[l_index] = nXtrk / (-incr);
7315 :
7316 : /*
7317 : * If Xtrk not exactly divisible by incr, round
7318 : * edge to next highest integer
7319 : */
7320 :
7321 0 : if (nXtrk % (-incr) != 0)
7322 : {
7323 0 : edge[l_index]++;
7324 : }
7325 : }
7326 :
7327 :
7328 : /* Read Data into output buffer */
7329 : /* ---------------------------- */
7330 0 : status = SWreadfield(swathID, fieldname,
7331 : start, NULL, edge,
7332 : (uint8 *) buffer + bufOffset);
7333 : }
7334 : }
7335 0 : else if (found == 1 && idxMapElem != -1)
7336 : {
7337 : /* Indexed Mapping */
7338 : /* --------------- */
7339 0 : for (k = 0; k < SWXRegion[regionID]->nRegions; k++)
7340 : {
7341 0 : if (k > 0)
7342 : {
7343 : /* Compute size in bytes of previous region */
7344 : /* ---------------------------------------- */
7345 0 : size = edge[0];
7346 0 : for (j = 1; j < rank; j++)
7347 : {
7348 0 : size *= edge[j];
7349 : }
7350 0 : size *= DFKNTsize(ntype);
7351 :
7352 :
7353 : /* Compute output buffer offset */
7354 : /* ---------------------------- */
7355 0 : bufOffset += size;
7356 : }
7357 : else
7358 : {
7359 : /* Initialize output buffer offset */
7360 : /* ------------------------------- */
7361 0 : bufOffset = 0;
7362 : }
7363 :
7364 :
7365 : /* Compute start & edge from l_index mappings */
7366 : /* ---------------------------------------- */
7367 0 : if (SWXRegion[regionID]->scanflag == 1 &&
7368 0 : (strcmp(fieldname, "Latitude") == 0 ||
7369 0 : strcmp(fieldname, "Longitude") == 0))
7370 : {
7371 0 : if (land_status == 0)
7372 0 : status = SWreadattr(swathID, "scene_count", &scene_cnt);
7373 0 : startscanline = SWXRegion[regionID]->StartRegion[k];
7374 0 : stopscanline = SWXRegion[regionID]->StopRegion[k];
7375 0 : if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3)
7376 : {
7377 0 : status = SWfieldinfo(swathID,"scan_no",&rk,dims2,&nt,dimlist);
7378 0 : tbuffer = (uint16 *)calloc(dims2[0], sizeof(uint16));
7379 0 : status =SWreadfield(swathID,"scan_no",NULL,NULL,NULL,tbuffer);
7380 0 : startscanline = startscanline - ((tbuffer[0] * detect_cnt) - detect_cnt);
7381 0 : stopscanline = stopscanline - ((tbuffer[0] * detect_cnt) - 1);
7382 : }
7383 0 : if(SWXRegion[regionID]->band8flag == 2 ||
7384 0 : SWXRegion[regionID]->band8flag == 3)
7385 : {
7386 0 : if(startscandim == -1)
7387 0 : if(startscanline < idxmap[0])
7388 : {
7389 0 : startscandim = 0;
7390 0 : start[l_index] = 0;
7391 0 : if(stopscanline > idxmap[scene_cnt * 2 - 1])
7392 : {
7393 0 : stopscandim = scene_cnt*2 - startscandim;
7394 0 : edge[l_index] = scene_cnt*2 - startscandim;
7395 : }
7396 : }
7397 : }
7398 0 : j = 0;
7399 0 : for (l = 0; l < scene_cnt; l++)
7400 : {
7401 0 : if(idxmap[j] <= startscanline && idxmap[j+1] >= startscanline)
7402 0 : if(startscandim == -1)
7403 : {
7404 0 : start[l_index] = j;
7405 0 : startscandim = j;
7406 : }
7407 0 : if(idxmap[j] <= stopscanline && idxmap[j+1] >= stopscanline)
7408 0 : if(startscandim != -1)
7409 : {
7410 0 : edge[l_index] = j - start[l_index] + 2;
7411 0 : stopscandim = j - start[l_index] + 1;
7412 : }
7413 0 : j = j + 2;
7414 : }
7415 0 : if(SWXRegion[regionID]->band8flag == 1 ||
7416 0 : SWXRegion[regionID]->band8flag == 2)
7417 : {
7418 0 : if(startscandim == -1)
7419 0 : if(startscanline < idxmap[0])
7420 : {
7421 0 : startscandim = 0;
7422 0 : start[l_index] = 0;
7423 : }
7424 0 : if(stopscandim == -1)
7425 0 : if(stopscanline > idxmap[scene_cnt * 2 - 1])
7426 : {
7427 0 : stopscandim = scene_cnt*2 - start[l_index];
7428 0 : edge[l_index] = scene_cnt*2 - start[l_index];
7429 : }
7430 : }
7431 0 : if(SWXRegion[regionID]->band8flag == 2)
7432 : {
7433 0 : if(startscandim == -1)
7434 0 : if(startscanline > idxmap[j - 1])
7435 : {
7436 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,"scan_no",&rank2,dims2,&nt,dimlist);
7437 0 : buffer2 = (uint16 *)calloc(dims2[0], sizeof(uint16));
7438 0 : status = SWreadfield(SWXRegion[regionID]->swathID,"scan_no",NULL,NULL,NULL,buffer2);
7439 0 : startscanline = startscanline - (buffer2[0] * detect_cnt);
7440 0 : stopscanline = stopscanline - (buffer2[0] * detect_cnt);
7441 0 : free(buffer2);
7442 0 : j = 0;
7443 0 : for (l = 0; l < scene_cnt; l++)
7444 : {
7445 0 : if(idxmap[j] <= startscanline && idxmap[j+1] >= startscanline)
7446 : {
7447 0 : start[l_index] = j;
7448 : }
7449 0 : if(idxmap[j] <= stopscanline && idxmap[j+1] >= stopscanline)
7450 0 : edge[l_index] = j - start[l_index] + 2;
7451 0 : j = j + 2;
7452 0 : if(idxmap[j] == 0 || idxmap[j+1] == 0)
7453 0 : l = scene_cnt;
7454 : }
7455 :
7456 : }
7457 : }
7458 :
7459 : }
7460 0 : else if(SWXRegion[regionID]->scanflag == 1 &&
7461 0 : (strcmp(fieldname, "scene_center_latitude") == 0 ||
7462 0 : strcmp(fieldname, "scene_center_longitude") == 0))
7463 : {
7464 0 : if (land_status == 0)
7465 0 : status = SWreadattr(swathID, "scene_count", &scene_cnt);
7466 0 : startscanline = SWXRegion[regionID]->StartRegion[k];
7467 0 : stopscanline = SWXRegion[regionID]->StopRegion[k];
7468 0 : if(startscanline < idxmap[0])
7469 : {
7470 0 : startscandim = 0;
7471 0 : start[l_index] = 0;
7472 : }
7473 0 : for (l = 0; l < scene_cnt-1; l++)
7474 : {
7475 0 : if(idxmap[l] <= startscanline && idxmap[l+1] >= startscanline)
7476 0 : if(startscandim == -1)
7477 : {
7478 0 : start[l_index] = l;
7479 0 : startscandim = l;
7480 : }
7481 0 : if(idxmap[l] <= stopscanline && idxmap[l+1] >= stopscanline)
7482 0 : if(stopscandim == -1)
7483 : {
7484 0 : edge[l_index] = l - start[l_index] + 2;
7485 0 : stopscandim = l + 1;
7486 : }
7487 : }
7488 0 : if(stopscandim == -1)
7489 : {
7490 0 : if(stopscanline > idxmap[scene_cnt - 1])
7491 : {
7492 0 : edge[l_index] = scene_cnt - start[l_index];
7493 0 : stopscandim = scene_cnt - 1;
7494 : }
7495 : }
7496 :
7497 0 : if(SWXRegion[regionID]->band8flag == 1)
7498 : {
7499 0 : if(stopscandim == -1)
7500 0 : if(stopscanline > idxmap[scene_cnt - 1])
7501 : {
7502 0 : edge[l_index] = scene_cnt - start[l_index];
7503 0 : stopscandim = scene_cnt -1;
7504 : }
7505 : }
7506 0 : if(SWXRegion[regionID]->band8flag == 2 ||
7507 0 : SWXRegion[regionID]->band8flag == 3)
7508 : {
7509 0 : if(startscandim == -1)
7510 : {
7511 0 : if(startscanline < idxmap[0])
7512 : {
7513 0 : startscandim = 0;
7514 0 : start[l_index] = 0;
7515 0 : edge[l_index] = stopscandim - startscandim + 1;
7516 : }
7517 : }
7518 0 : if(startscandim == -1)
7519 : {
7520 0 : startscanline = SWXRegion[regionID]->StartScan[k] * detect_cnt - detect_cnt;
7521 0 : stopscanline = SWXRegion[regionID]->StopScan[k] * detect_cnt - 1;
7522 0 : for (l = 0; l < scene_cnt-1; l++)
7523 : {
7524 0 : if(idxmap[l] <= startscanline && idxmap[l+1] >= startscanline)
7525 0 : start[l_index] = l;
7526 0 : if(idxmap[l] <= stopscanline && idxmap[l+1] >= stopscanline)
7527 0 : edge[l_index] = l - start[l_index] + 1;
7528 : }
7529 : }
7530 : }
7531 : }
7532 : else
7533 : {
7534 0 : if (SWXRegion[regionID]->scanflag == 1 &&
7535 0 : strcmp(fieldname,dfieldlist) == 0)
7536 : {
7537 0 : start[l_index] = SWXRegion[regionID]->StartRegion[k];
7538 0 : edge[l_index] = SWXRegion[regionID]->StopRegion[k] -
7539 0 : SWXRegion[regionID]->StartRegion[k] + 1;
7540 0 : if(SWXRegion[regionID]->band8flag == 2 ||
7541 0 : SWXRegion[regionID]->band8flag == 3 )
7542 : {
7543 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,"scan_no",&rank,dims2,&nt,dimlist);
7544 0 : buffer2 = (uint16 *)calloc(dims2[0], sizeof(uint16));
7545 0 : status = SWreadfield(SWXRegion[regionID]->swathID,"scan_no",NULL,NULL,NULL,buffer2);
7546 0 : start[l_index] = start[l_index] - (buffer2[0] * detect_cnt - detect_cnt);
7547 0 : free(buffer2);
7548 : }
7549 : }
7550 : else
7551 : {
7552 0 : start[l_index] = idxmap[SWXRegion[regionID]->StartRegion[k]];
7553 :
7554 0 : edge[l_index] = idxmap[SWXRegion[regionID]->StopRegion[k]] -
7555 0 : idxmap[SWXRegion[regionID]->StartRegion[k]] + 1;
7556 : }
7557 : }
7558 : /* Read Data into output buffer */
7559 : /* ---------------------------- */
7560 0 : status = SWreadfield(swathID, fieldname,
7561 : start, NULL, edge,
7562 : buffer);
7563 0 : if (SWXRegion[regionID]->scanflag == 1)
7564 : {
7565 :
7566 0 : if (strcmp(fieldname,"Longitude") == 0)
7567 : {
7568 0 : status = SWscan2longlat(swathID, fieldname, buffer, start,
7569 : edge, idxmap, startscanline, stopscanline);
7570 : }
7571 0 : if (strcmp(fieldname,"Latitude") == 0)
7572 : {
7573 0 : status = SWscan2longlat(swathID, fieldname, buffer, start,
7574 : edge, idxmap, startscanline, stopscanline);
7575 : }
7576 : }
7577 : }
7578 : }
7579 0 : else if(vfound == 1) /* Vertical subsetting */
7580 : { /* found previously, */
7581 0 : status = SWreadfield(swathID, fieldname, /* perform the vertical*/
7582 : start, NULL, edge, /* subsetting. */
7583 : (uint8 *) buffer); /* -- xhua */
7584 : }
7585 : else
7586 : {
7587 : /* Mapping not found */
7588 : /* ----------------- */
7589 0 : status = -1;
7590 0 : HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__);
7591 0 : HEreport("Mapping Not Defined for \"%s\" Dimension.\n",
7592 : geodim);
7593 : }
7594 : }
7595 : else
7596 : {
7597 : /* Read Data (Vert SS only) */
7598 : /* ------------------------ */
7599 0 : status = SWreadfield(swathID, fieldname,
7600 : start, NULL, edge,
7601 : (uint8 *) buffer);
7602 : }
7603 : }
7604 : }
7605 :
7606 : /* Free l_index mappings if applicable */
7607 : /* --------------------------------- */
7608 0 : if (idxmap != NULL)
7609 : {
7610 0 : free(idxmap);
7611 : }
7612 0 : if(dfieldlist != NULL)
7613 0 : free(dfieldlist);
7614 :
7615 0 : return (status);
7616 : }
7617 :
7618 :
7619 : /*----------------------------------------------------------------------------|
7620 : | BEGIN_PROLOG |
7621 : | |
7622 : | FUNCTION: SWscan2longlat |
7623 : | |
7624 : | DESCRIPTION: Convert scanline to Long/Lat for floating scene subsetting. |
7625 : | This will calculate/interpolate the long/lat for a given |
7626 : | scanline. |
7627 : | |
7628 : | |
7629 : | Return Value Type Units Description |
7630 : | ============ ====== ========= ===================================== |
7631 : | status intn return status (0) SUCCEED, (-1) FAIL |
7632 : | |
7633 : | INPUTS: |
7634 : | swathID int32 Swath structure ID |
7635 : | fieldname char Fieldname |
7636 : | buffer void Values to update |
7637 : | start int32 |
7638 : | edge int32 |
7639 : | idxmap int32 * Buffer of l_index mapping values |
7640 : | startscanline int32 Start of scan region |
7641 : | stopscanline int32 Stop of scan region |
7642 : | |
7643 : | OUTPUTS: |
7644 : | |
7645 : | NOTES: |
7646 : | |
7647 : | |
7648 : | Date Programmer Description |
7649 : | ====== ============ ================================================= |
7650 : | Jul 99 DaW Original Programmer |
7651 : | |
7652 : | END_PROLOG |
7653 : -----------------------------------------------------------------------------*/
7654 : static intn
7655 0 : SWscan2longlat(int32 swathID, const char *fieldname, VOIDP buffer, int32 start[],
7656 : int32 edge[], int32 *idxmap, int32 startscanline, int32 stopscanline)
7657 : {
7658 :
7659 : enum corner {UL, UR, LL, LR};
7660 0 : enum corner pos = UL;
7661 0 : enum corner pos2 = UL;
7662 :
7663 0 : uint8 scene_cnt = 0; /* Used to convert scan to scanline */
7664 : /* L7 float scene sub. */
7665 : float32 *buffer2;
7666 : float32 *bufferc;
7667 0 : float32 deg2rad = (float32)(M_PI/180.00);
7668 :
7669 0 : float32 p1_long = 0.0; /* point 1, longitude */
7670 0 : float32 p2_long = 0.0; /* point 2, longitude */
7671 0 : float32 pi_long = 0.0; /* interpolated point, longitude */
7672 0 : int32 scanline_p1 = 0;
7673 :
7674 0 : float32 p1_lat = 0.0; /* point 1, latitude */
7675 0 : float32 p2_lat = 0.0; /* point 2, latitude */
7676 0 : float32 pi_lat = 0.0; /* interpolated point, latitude */
7677 0 : int32 scanline_p2 = 0;
7678 :
7679 :
7680 0 : float32 x_p1 = 0.0; /* Cartesian coordinates */
7681 0 : float32 y_p1 = 0.0; /* point 1 */
7682 0 : float32 z_p1 = 0.0;
7683 :
7684 0 : float32 x_p2 = 0.0; /* Cartesian coordinates */
7685 0 : float32 y_p2 = 0.0; /* point 2 */
7686 0 : float32 z_p2 = 0.0;
7687 :
7688 0 : float32 x_pi = 0.0; /* Cartesian coordinates */
7689 0 : float32 y_pi = 0.0; /* interpolated point */
7690 0 : float32 z_pi = 0.0;
7691 0 : int32 scanline_pi = 0;
7692 :
7693 0 : intn status = -1;
7694 :
7695 0 : int i = 0;
7696 0 : int p1_long_l90_flag = 0;
7697 0 : int p1_long_g90_flag = 0;
7698 0 : int p2_long_l90_flag = 0;
7699 0 : int p2_long_g90_flag = 0;
7700 0 : int fieldflag = 0;
7701 :
7702 0 : int numofval = 0;
7703 :
7704 :
7705 :
7706 0 : numofval = edge[0] * 2;
7707 :
7708 :
7709 0 : buffer2 = (float32 *)calloc(numofval, sizeof(float32));
7710 0 : bufferc = (float32 *)calloc(numofval, sizeof(float32));
7711 0 : memmove(bufferc, buffer, numofval*sizeof(float32));
7712 :
7713 0 : (void) SWreadattr(swathID, "scene_count", &scene_cnt);
7714 :
7715 0 : if (strcmp(fieldname, "Longitude") == 0)
7716 : {
7717 0 : fieldflag = 1;
7718 0 : status = SWreadfield(swathID, "Latitude", start, NULL, edge, buffer2);
7719 : }
7720 0 : else if (strcmp(fieldname, "Latitude") == 0)
7721 : {
7722 0 : fieldflag = 2;
7723 0 : status = SWreadfield(swathID, "Longitude", start, NULL, edge, buffer2);
7724 : }
7725 :
7726 0 : for(i=0; i<4; i++)
7727 : {
7728 0 : switch(pos)
7729 : {
7730 0 : case UL:
7731 0 : if (fieldflag == 1)
7732 : {
7733 0 : p1_long = bufferc[0];
7734 0 : p2_long = bufferc[2];
7735 0 : p1_lat = buffer2[0];
7736 0 : p2_lat = buffer2[2];
7737 : }
7738 0 : if (fieldflag == 2)
7739 : {
7740 0 : p1_long = buffer2[0];
7741 0 : p2_long = buffer2[2];
7742 0 : p1_lat = bufferc[0];
7743 0 : p2_lat = bufferc[2];
7744 : }
7745 0 : scanline_p1 = idxmap[start[0]];
7746 0 : scanline_p2 = idxmap[start[0]+1];
7747 0 : scanline_pi = startscanline;
7748 0 : pos = UR;
7749 0 : break;
7750 0 : case UR:
7751 0 : if (fieldflag == 1)
7752 : {
7753 0 : p1_long = bufferc[1];
7754 0 : p2_long = bufferc[3];
7755 0 : p1_lat = buffer2[1];
7756 0 : p2_lat = buffer2[3];
7757 : }
7758 0 : if (fieldflag == 2)
7759 : {
7760 0 : p1_long = buffer2[1];
7761 0 : p2_long = buffer2[3];
7762 0 : p1_lat = bufferc[1];
7763 0 : p2_lat = bufferc[3];
7764 : }
7765 0 : scanline_p1 = idxmap[start[0]];
7766 0 : scanline_p2 = idxmap[start[0]+1];
7767 0 : scanline_pi = startscanline;
7768 0 : pos = LL;
7769 0 : break;
7770 0 : case LL:
7771 0 : if (fieldflag == 1)
7772 : {
7773 0 : p1_long = bufferc[numofval-4];
7774 0 : p2_long = bufferc[numofval-2];
7775 0 : p1_lat = buffer2[numofval-4];
7776 0 : p2_lat = buffer2[numofval-2];
7777 : }
7778 0 : if (fieldflag == 2)
7779 : {
7780 0 : p1_long = buffer2[numofval-4];
7781 0 : p2_long = buffer2[numofval-2];
7782 0 : p1_lat = bufferc[numofval-4];
7783 0 : p2_lat = bufferc[numofval-2];
7784 : }
7785 0 : scanline_p1 = idxmap[start[0] + edge[0] - 2];
7786 0 : scanline_p2 = idxmap[start[0] + edge[0] - 1];
7787 0 : scanline_pi = stopscanline;
7788 0 : pos = LR;
7789 0 : break;
7790 0 : case LR:
7791 0 : if (fieldflag == 1)
7792 : {
7793 0 : p1_long = bufferc[numofval-3];
7794 0 : p2_long = bufferc[numofval-1];
7795 0 : p1_lat = buffer2[numofval-3];
7796 0 : p2_lat = buffer2[numofval-1];
7797 : }
7798 0 : if (fieldflag == 2)
7799 : {
7800 0 : p1_long = buffer2[numofval-3];
7801 0 : p2_long = buffer2[numofval-1];
7802 0 : p1_lat = bufferc[numofval-3];
7803 0 : p2_lat = bufferc[numofval-1];
7804 : }
7805 0 : scanline_p1 = idxmap[start[0] + edge[0] - 2];
7806 0 : scanline_p2 = idxmap[start[0] + edge[0] - 1];
7807 0 : scanline_pi = stopscanline;
7808 0 : break;
7809 : }
7810 :
7811 :
7812 :
7813 0 : if (p1_long <= -90.0)
7814 : {
7815 0 : if (p2_long >= 90.0)
7816 : {
7817 0 : p1_long = p1_long + 180.0f;
7818 0 : p2_long = p2_long - 180.0f;
7819 0 : p1_long_l90_flag = 2;
7820 : }
7821 : else
7822 : {
7823 0 : p1_long = p1_long + 180.0f;
7824 0 : p1_long_l90_flag = 1;
7825 : }
7826 : }
7827 0 : if (p1_long >= 90.0 && p1_long_l90_flag != 2)
7828 : {
7829 0 : if(p2_long <= -90.0)
7830 : {
7831 0 : p1_long = p1_long - 180.0f;
7832 0 : p2_long = p2_long + 180.0f;
7833 0 : p1_long_g90_flag = 2;
7834 : }
7835 : else
7836 : {
7837 0 : p1_long = p1_long - 90.0f;
7838 0 : p1_long_g90_flag = 1;
7839 : }
7840 : }
7841 0 : if (p2_long <= -90.0)
7842 : {
7843 0 : if (p1_long < 0.0)
7844 : {
7845 0 : p2_long = p2_long + 90.0f;
7846 0 : p1_long = p1_long + 90.0f;
7847 0 : p2_long_l90_flag = 2;
7848 : }
7849 : else
7850 : {
7851 0 : p2_long = p2_long + 180.0f;
7852 0 : p2_long_l90_flag = 1;
7853 : }
7854 : }
7855 0 : if (p2_long >= 90.0 && p1_long_l90_flag != 2)
7856 : {
7857 0 : p2_long = p2_long - 90.0f;
7858 0 : p2_long_g90_flag = 1;
7859 : }
7860 :
7861 :
7862 0 : x_p1 = (float)(RADOE * cos((p1_long*deg2rad)) * sin((p1_lat*deg2rad)));
7863 0 : y_p1 = (float)(RADOE * sin((p1_long*deg2rad)) * sin((p1_lat*deg2rad)));
7864 0 : z_p1 = (float)(RADOE * cos((p1_lat*deg2rad)));
7865 :
7866 :
7867 0 : x_p2 = (float)(RADOE * cos((p2_long*deg2rad)) * sin((p2_lat*deg2rad)));
7868 0 : y_p2 = (float)(RADOE * sin((p2_long*deg2rad)) * sin((p2_lat*deg2rad)));
7869 0 : z_p2 = (float)(RADOE * cos((p2_lat*deg2rad)));
7870 :
7871 0 : x_pi = x_p1 + (x_p2 - x_p1)*(scanline_pi-scanline_p1)/(scanline_p2-scanline_p1);
7872 0 : y_pi = y_p1 + (y_p2 - y_p1)*(scanline_pi-scanline_p1)/(scanline_p2-scanline_p1);
7873 0 : z_pi = z_p1 + (z_p2 - z_p1)*(scanline_pi-scanline_p1)/(scanline_p2-scanline_p1);
7874 :
7875 0 : if (fieldflag == 1)
7876 : {
7877 0 : pi_long = (float)(atan(y_pi/x_pi)*180.0/M_PI);
7878 0 : if (p1_long_l90_flag == 1 || p2_long_l90_flag == 1)
7879 : {
7880 0 : pi_long = pi_long - 180.0f;
7881 0 : p1_long_l90_flag = 0;
7882 0 : p2_long_l90_flag = 0;
7883 : }
7884 0 : if (p1_long_g90_flag == 1 || p2_long_g90_flag == 1)
7885 : {
7886 0 : pi_long = pi_long + 90.0f;
7887 0 : p1_long_g90_flag = 0;
7888 0 : p2_long_g90_flag = 0;
7889 : }
7890 0 : if (p1_long_l90_flag == 2)
7891 : {
7892 0 : if (pi_long > 0.0)
7893 0 : pi_long = pi_long - 180.0f;
7894 0 : else if (pi_long < 0.0)
7895 0 : pi_long = pi_long + 180.0f;
7896 0 : p1_long_l90_flag = 0;
7897 : }
7898 0 : if (p1_long_g90_flag == 2)
7899 : {
7900 0 : if (pi_long > 0.0)
7901 0 : pi_long = pi_long - 180.0f;
7902 0 : else if (pi_long < 0.0)
7903 0 : pi_long = pi_long + 180.0f;
7904 0 : p1_long_g90_flag = 0;
7905 : }
7906 0 : if (p2_long_l90_flag == 2)
7907 : {
7908 0 : pi_long = pi_long - 90.0f;
7909 0 : p2_long_l90_flag = 0;
7910 : }
7911 :
7912 :
7913 :
7914 0 : switch(pos2)
7915 : {
7916 0 : case UL:
7917 0 : bufferc[0] = pi_long;
7918 0 : pos2 = UR;
7919 0 : break;
7920 0 : case UR:
7921 0 : bufferc[1] = pi_long;
7922 0 : pos2 = LL;
7923 0 : break;
7924 0 : case LL:
7925 0 : if(stopscanline > idxmap[scene_cnt*2 - 1])
7926 0 : break;
7927 0 : bufferc[numofval-2] = pi_long;
7928 0 : pos2 = LR;
7929 0 : break;
7930 0 : case LR:
7931 0 : if(stopscanline > idxmap[scene_cnt*2 - 1])
7932 0 : break;
7933 0 : bufferc[numofval-1] = pi_long;
7934 0 : break;
7935 : }
7936 :
7937 0 : }
7938 0 : if (fieldflag == 2)
7939 : {
7940 0 : pi_lat = (float)(atan((sqrt(x_pi*x_pi + y_pi*y_pi)/z_pi))*180.0/M_PI);
7941 0 : switch(pos2)
7942 : {
7943 0 : case UL:
7944 0 : bufferc[0] = pi_lat;
7945 0 : pos2 = UR;
7946 0 : break;
7947 0 : case UR:
7948 0 : bufferc[1] = pi_lat;
7949 0 : pos2 = LL;
7950 0 : break;
7951 0 : case LL:
7952 0 : if(stopscanline > idxmap[scene_cnt*2 - 1])
7953 0 : break;
7954 0 : bufferc[numofval-2] = pi_lat;
7955 0 : pos2 = LR;
7956 0 : break;
7957 0 : case LR:
7958 0 : if(stopscanline > idxmap[scene_cnt*2 - 1])
7959 0 : break;
7960 0 : bufferc[numofval-1] = pi_lat;
7961 0 : break;
7962 : }
7963 0 : }
7964 : }
7965 0 : memmove(buffer, bufferc, numofval*sizeof(float32));
7966 0 : free(buffer2);
7967 0 : free(bufferc);
7968 0 : return(status);
7969 : }
7970 :
7971 :
7972 : /*----------------------------------------------------------------------------|
7973 : | BEGIN_PROLOG |
7974 : | |
7975 : | FUNCTION: SWextractperiod |
7976 : | |
7977 : | DESCRIPTION: Retrieves data from specified period. |
7978 : | |
7979 : | |
7980 : | Return Value Type Units Description |
7981 : | ============ ====== ========= ===================================== |
7982 : | status intn return status (0) SUCCEED, (-1) FAIL |
7983 : | |
7984 : | INPUTS: |
7985 : | swathID int32 Swath structure ID |
7986 : | periodID int32 Period ID |
7987 : | fieldname char Fieldname |
7988 : | externalflag int32 External geolocation fields flag |
7989 : | HDFE_INTERNAL (0) |
7990 : | HDFE_EXTERNAL (1) |
7991 : | |
7992 : | OUTPUTS: |
7993 : | buffer void Data buffer containing subsetted region |
7994 : | |
7995 : | NOTES: |
7996 : | |
7997 : | |
7998 : | Date Programmer Description |
7999 : | ====== ============ ================================================= |
8000 : | Jun 96 Joel Gales Original Programmer |
8001 : | Jun 03 Abe Taaheri added clearing timeflag if SWextractregion fails |
8002 : | |
8003 : | END_PROLOG |
8004 : -----------------------------------------------------------------------------*/
8005 : intn
8006 0 : SWextractperiod(int32 swathID, int32 periodID, const char *fieldname,
8007 : int32 externalflag, VOIDP buffer)
8008 :
8009 : {
8010 : intn status; /* routine return status variable */
8011 :
8012 0 : timeflag = 1;
8013 :
8014 : /* Call SWextractregion routine */
8015 : /* ---------------------------- */
8016 0 : status = SWextractregion(swathID, periodID, fieldname, externalflag,
8017 : (char *) buffer);
8018 0 : if (status != 0) timeflag = 0; /*clear timeflag if SWextractregion failed*/
8019 0 : return (status);
8020 : }
8021 :
8022 :
8023 :
8024 :
8025 :
8026 :
8027 :
8028 : /*----------------------------------------------------------------------------|
8029 : | BEGIN_PROLOG |
8030 : | |
8031 : | FUNCTION: SWdupregion |
8032 : | |
8033 : | DESCRIPTION: Duplicates a region |
8034 : | |
8035 : | |
8036 : | Return Value Type Units Description |
8037 : | ============ ====== ========= ===================================== |
8038 : | newregionID int32 New region ID |
8039 : | |
8040 : | INPUTS: |
8041 : | oldregionID int32 Old region ID |
8042 : | |
8043 : | OUTPUTS: |
8044 : | None |
8045 : | |
8046 : | NOTES: |
8047 : | |
8048 : | |
8049 : | Date Programmer Description |
8050 : | ====== ============ ================================================= |
8051 : | Jan 97 Joel Gales Original Programmer |
8052 : | |
8053 : | END_PROLOG |
8054 : -----------------------------------------------------------------------------*/
8055 : int32
8056 0 : SWdupregion(int32 oldregionID)
8057 : {
8058 : intn i; /* Loop index */
8059 :
8060 0 : int32 newregionID = -1; /* New region ID */
8061 :
8062 :
8063 : /* Find first empty (inactive) region */
8064 : /* ---------------------------------- */
8065 0 : for (i = 0; i < NSWATHREGN; i++)
8066 : {
8067 0 : if (SWXRegion[i] == 0)
8068 : {
8069 : /* Allocate space for new swath region entry */
8070 : /* ----------------------------------------- */
8071 0 : SWXRegion[i] = (struct swathRegion *)
8072 0 : calloc(1, sizeof(struct swathRegion));
8073 0 : if(SWXRegion[i] == NULL)
8074 : {
8075 0 : HEpush(DFE_NOSPACE,"SWdupregion", __FILE__, __LINE__);
8076 0 : return(-1);
8077 : }
8078 :
8079 : /* Copy old region structure data to new region */
8080 : /* -------------------------------------------- */
8081 0 : *SWXRegion[i] = *SWXRegion[oldregionID];
8082 :
8083 :
8084 : /* Define new region ID */
8085 : /* -------------------- */
8086 0 : newregionID = i;
8087 :
8088 0 : break;
8089 : }
8090 : }
8091 :
8092 0 : return (newregionID);
8093 : }
8094 :
8095 :
8096 : /*----------------------------------------------------------------------------|
8097 : | BEGIN_PROLOG |
8098 : | |
8099 : | FUNCTION: SWregioninfo |
8100 : | |
8101 : | DESCRIPTION: Returns size of region in bytes |
8102 : | |
8103 : | |
8104 : | Return Value Type Units Description |
8105 : | ============ ====== ========= ===================================== |
8106 : | status intn return status (0) SUCCEED, (-1) FAIL |
8107 : | |
8108 : | INPUTS: |
8109 : | swathID int32 Swath structure ID |
8110 : | regionID int32 Region ID |
8111 : | fieldname char Fieldname |
8112 : | |
8113 : | |
8114 : | OUTPUTS: |
8115 : | ntype int32 field number type |
8116 : | rank int32 field rank |
8117 : | dims int32 dimensions of field region |
8118 : | size int32 size in bytes of field region |
8119 : | |
8120 : | NOTES: |
8121 : | |
8122 : | |
8123 : | Date Programmer Description |
8124 : | ====== ============ ================================================= |
8125 : | Jun 96 Joel Gales Original Programmer |
8126 : | Aug 96 Joel Gales Add vertical subsetting |
8127 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
8128 : | Mar 97 Joel Gales Add support for l_index mapping |
8129 : | Jul 99 DaW Add support for floating scene subsetting |
8130 : | |
8131 : | END_PROLOG |
8132 : -----------------------------------------------------------------------------*/
8133 : intn
8134 0 : SWregioninfo(int32 swathID, int32 regionID, const char *fieldname,
8135 : int32 * ntype, int32 * rank, int32 dims[], int32 * size)
8136 :
8137 : {
8138 : intn i; /* Loop index */
8139 : intn j; /* Loop index */
8140 : intn k; /* Loop index */
8141 0 : intn l = 0; /* Loop index */
8142 : intn status; /* routine return status variable */
8143 0 : intn long_status = 3; /* routine return status variable for longitude */
8144 0 : intn land_status = 3; /* Used for L7 float scene sub. */
8145 0 : intn statMap = -1; /* Status from SWmapinfo */
8146 :
8147 0 : uint8 found = 0; /* Found flag */
8148 0 : uint8 detect_cnt = 0; /* Used for L7 float scene sub. */
8149 :
8150 0 : int32 numtype = 0; /* Used for L7 float scene sub. */
8151 0 : int32 count = 0; /* Used for L7 float scene sub. */
8152 :
8153 :
8154 : int32 fid; /* HDF-EOS file ID */
8155 : int32 sdInterfaceID; /* HDF SDS interface ID */
8156 : int32 swVgrpID; /* Swath Vgroup ID */
8157 :
8158 0 : int32 l_index = 0; /* Geo Dim Index */
8159 : int32 nDim; /* Number of dimensions */
8160 : int32 slen[64]; /* String length array */
8161 : int32 dum; /* Dummy variable */
8162 0 : int32 incr = 0; /* Mapping increment */
8163 0 : int32 nXtrk = 0; /* Number of cross tracks */
8164 0 : int32 scan_shift = 0; /* Used to take out partial scans */
8165 0 : int32 startscandim = -1; /* Used for floating scene region size */
8166 0 : int32 stopscandim = -1; /* Used for floating scene region size */
8167 : int32 dumdims[8]; /* Dimensions from SWfieldinfo */
8168 0 : int32 idxMapElem = -1; /* Number of l_index map elements */
8169 0 : int32 *idxmap = NULL; /* Pointer to l_index mapping array */
8170 0 : int32 datafld = 0;
8171 :
8172 0 : uint8 scene_cnt = 0; /* Number of scenes in swath */
8173 0 : int32 startscanline = 0;
8174 0 : int32 stopscanline = 0;
8175 0 : char *dfieldlist = (char *)NULL;
8176 0 : int32 strbufsize = 0;
8177 : int32 dfrank[8];
8178 : int32 numtype2[8];
8179 0 : int32 rank2 = 0;
8180 0 : int32 rk = 0;
8181 : int32 dims2[8];
8182 0 : int32 nt = 0;
8183 0 : uint16 *buffer2 = (uint16 *)NULL;
8184 0 : uint16 *tbuffer = (uint16 *)NULL;
8185 :
8186 : char dimlist[256]; /* Dimension list */
8187 : char geodim[256];/* Geolocation field dimension list */
8188 : char tgeodim[256];/* Time Geolocation field dimension list */
8189 : char dgeodim[256];/* Data Subsetting field dimension list */
8190 : char utlbuf[256];/* Utility buffer */
8191 : char *ptr[64]; /* String pointer array */
8192 : static const char errMesg[] = "Vertical Dimension Not Found: \"%s\".\n";
8193 :
8194 :
8195 :
8196 : /* Set region size to -1 */
8197 : /* --------------------- */
8198 0 : *size = -1;
8199 :
8200 :
8201 : /* Check for valid swath ID */
8202 : /* ------------------------ */
8203 0 : status = SWchkswid(swathID, "SWregioninfo", &fid, &sdInterfaceID,
8204 : &swVgrpID);
8205 :
8206 :
8207 : /* Check for valid region ID */
8208 : /* ------------------------- */
8209 0 : if (status == 0)
8210 : {
8211 0 : if (regionID < 0 || regionID >= NSWATHREGN)
8212 : {
8213 0 : status = -1;
8214 0 : HEpush(DFE_RANGE, "SWregioninfo", __FILE__, __LINE__);
8215 0 : HEreport("Invalid Region id: %d.\n", regionID);
8216 : }
8217 : }
8218 :
8219 :
8220 :
8221 : /* Check for active region ID */
8222 : /* -------------------------- */
8223 0 : if (status == 0)
8224 : {
8225 0 : if (SWXRegion[regionID] == 0)
8226 : {
8227 0 : status = -1;
8228 0 : HEpush(DFE_GENAPP, "SWregioninfo", __FILE__, __LINE__);
8229 0 : HEreport("Inactive Region ID: %d.\n", regionID);
8230 : }
8231 : }
8232 :
8233 : /* This code checks for the attribute detector_count */
8234 : /* which is found in Landsat 7 files. It is used */
8235 : /* for some of the loops. */
8236 : /* ================================================= */
8237 0 : if (status == 0 && SWXRegion[regionID]->scanflag == 1)
8238 : {
8239 0 : land_status = SWattrinfo(swathID, "detector_count", &numtype, &count);
8240 0 : if (land_status == 0)
8241 : {
8242 0 : land_status = SWreadattr(swathID, "detector_count", &detect_cnt);
8243 0 : land_status = SWreadattr(swathID, "scene_count", &scene_cnt);
8244 :
8245 : }
8246 : }
8247 :
8248 :
8249 :
8250 :
8251 : /* Check for valid fieldname */
8252 : /* ------------------------- */
8253 0 : if (status == 0)
8254 : {
8255 : /* Get data field info */
8256 : /* ------------------- */
8257 0 : status = SWfieldinfo(swathID, fieldname, rank,
8258 : dims, ntype, dimlist);
8259 :
8260 0 : if (status != 0)
8261 : {
8262 0 : status = -1;
8263 0 : HEpush(DFE_GENAPP, "SWregioninfo", __FILE__, __LINE__);
8264 0 : HEreport("Field \"%s\" Not Found.\n", fieldname);
8265 : }
8266 : }
8267 :
8268 :
8269 :
8270 : /* No problems so proceed ... */
8271 : /* -------------------------- */
8272 0 : if (status == 0)
8273 : {
8274 : /* If non-vertical subset regions defined ... */
8275 : /* ------------------------------------------ */
8276 0 : if (SWXRegion[regionID]->nRegions > 0 || SWXRegion[regionID]->scanflag == 1)
8277 : {
8278 :
8279 : /* Get geolocation dimension name */
8280 : /* ------------------------------ */
8281 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,
8282 : "Longitude", &dum,
8283 : dumdims, &dum, geodim);
8284 0 : long_status = status;
8285 :
8286 : /* If Time field being used, check for dimensions */
8287 : /* ---------------------------------------------- */
8288 0 : if (timeflag == 1)
8289 : {
8290 : /* code change to fix time subset bug for Landsat7 */
8291 :
8292 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,
8293 : "Time", &dum,
8294 : dumdims, &dum, tgeodim);
8295 :
8296 0 : if (strcmp(geodim, tgeodim) != 0)
8297 : {
8298 0 : strcpy(geodim, tgeodim);
8299 : }
8300 0 : timeflag = 0;
8301 : }
8302 :
8303 : /* If defscanregion being used, get dimensions */
8304 : /* of field being used */
8305 : /* ---------------------------------------------- */
8306 0 : if (SWXRegion[regionID]->scanflag == 1)
8307 : {
8308 0 : (void) SWnentries(SWXRegion[regionID]->swathID,4,&strbufsize);
8309 0 : dfieldlist = (char *)calloc(strbufsize + 1, sizeof(char));
8310 0 : (void) SWinqdatafields(SWXRegion[regionID]->swathID,dfieldlist,dfrank,numtype2);
8311 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,dfieldlist,&dum,dumdims,&dum,dgeodim);
8312 :
8313 : /* The dimensions have to be switched, because */
8314 : /* the mappings force a geodim and datadim */
8315 : /* so to find the mapping, the dimensions must */
8316 : /* be switched, but the subsetting will still */
8317 : /* be based on the correct dimensions */
8318 : /* "long_status == -1" added for CAL file which */
8319 : /* doesn't have a Traditional geolocation field */
8320 : /* ---------------------------------------------- */
8321 0 : if (strcmp(dgeodim,dimlist) != 0 || long_status == -1)
8322 : {
8323 0 : strcpy(geodim,dimlist);
8324 0 : strcpy(dimlist,dgeodim);
8325 : }
8326 : }
8327 :
8328 :
8329 : /* Get "Track" (first) Dimension from geo dimlist */
8330 : /* ---------------------------------------------- */
8331 0 : nDim = EHparsestr(geodim, ',', ptr, slen);
8332 0 : geodim[slen[0]] = 0;
8333 :
8334 :
8335 : /* Parse Data Field Dimlist & find mapping */
8336 : /* --------------------------------------- */
8337 0 : nDim = EHparsestr(dimlist, ',', ptr, slen);
8338 :
8339 :
8340 : /* Loop through all dimensions and search for mapping */
8341 : /* -------------------------------------------------- */
8342 0 : for (i = 0; i < nDim; i++)
8343 : {
8344 0 : memcpy(utlbuf, ptr[i], slen[i]);
8345 0 : utlbuf[slen[i]] = 0;
8346 0 : statMap = SWmapinfo(swathID, geodim, utlbuf,
8347 : &dum, &incr);
8348 :
8349 : /* Mapping found */
8350 : /* ------------- */
8351 0 : if (statMap == 0)
8352 : {
8353 0 : found = 1;
8354 0 : l_index = i;
8355 0 : break;
8356 : }
8357 : }
8358 :
8359 :
8360 : /* If mapping not found check for geodim within dimlist */
8361 : /* ---------------------------------------------------- */
8362 0 : if (found == 0)
8363 : {
8364 0 : l_index = EHstrwithin(geodim, dimlist, ',');
8365 :
8366 : /* Geo dimension found within subset field dimlist */
8367 : /* ----------------------------------------------- */
8368 0 : if (l_index != -1)
8369 : {
8370 0 : found = 1;
8371 0 : incr = 1;
8372 : }
8373 : }
8374 :
8375 :
8376 :
8377 : /* If mapping not found check for l_indexed mapping */
8378 : /* ---------------------------------------------- */
8379 0 : if (found == 0)
8380 : {
8381 : /* Get size of geo dim & allocate space of l_index mapping */
8382 : /* ----------------------------------------------------- */
8383 0 : dum = SWdiminfo(swathID, geodim);
8384 0 : idxmap = (int32 *) calloc(dum, sizeof(int32));
8385 0 : if(idxmap == NULL)
8386 : {
8387 0 : HEpush(DFE_NOSPACE,"SWregioninfo", __FILE__, __LINE__);
8388 0 : return(-1);
8389 : }
8390 :
8391 : /* Loop through all dimensions and search for mapping */
8392 : /* -------------------------------------------------- */
8393 0 : for (i = 0; i < nDim; i++)
8394 : {
8395 0 : memcpy(utlbuf, ptr[i], slen[i]);
8396 0 : utlbuf[slen[i]] = 0;
8397 :
8398 0 : idxMapElem = SWidxmapinfo(swathID, geodim, utlbuf, idxmap);
8399 :
8400 :
8401 : /* Mapping found */
8402 : /* ------------- */
8403 0 : if (idxMapElem != -1)
8404 : {
8405 0 : found = 1;
8406 0 : l_index = i;
8407 0 : break;
8408 : }
8409 : }
8410 : }
8411 :
8412 :
8413 : /* Regular Mapping Found */
8414 : /* --------------------- */
8415 0 : if (found == 1 && idxMapElem == -1)
8416 : {
8417 0 : dims[l_index] = 0;
8418 :
8419 : /* Loop through all regions */
8420 : /* ------------------------ */
8421 0 : for (k = 0; k < SWXRegion[regionID]->nRegions; k++)
8422 : {
8423 : /* Get number of cross tracks in particular region */
8424 : /* ----------------------------------------------- */
8425 0 : nXtrk = SWXRegion[regionID]->StopRegion[k] -
8426 0 : SWXRegion[regionID]->StartRegion[k] + 1;
8427 :
8428 :
8429 : /* If increment is positive (geodim <= datadim) ... */
8430 : /* ------------------------------------------------ */
8431 0 : if (incr > 0)
8432 : {
8433 0 : if (SWXRegion[regionID]->scanflag == 1)
8434 : {
8435 0 : scan_shift = nXtrk % incr;
8436 0 : if(scan_shift != 0)
8437 0 : nXtrk = nXtrk - scan_shift;
8438 0 : dims[l_index] += nXtrk/incr;
8439 0 : if(long_status == -1 || incr == 1)
8440 : {
8441 0 : if( detect_cnt == 0 )
8442 0 : return -1;
8443 0 : scan_shift = nXtrk % detect_cnt;
8444 0 : if(scan_shift != 0)
8445 0 : dims[l_index] = nXtrk - scan_shift;
8446 : }
8447 : }
8448 : else
8449 : {
8450 0 : dims[l_index] += nXtrk * incr;
8451 : }
8452 : }
8453 : else
8454 : {
8455 : /* Negative increment (geodim > datadim) */
8456 : /* ------------------------------------- */
8457 0 : dims[l_index] += nXtrk / (-incr);
8458 :
8459 : /*
8460 : * If Xtrk not exactly divisible by incr, round dims
8461 : * to next highest integer
8462 : */
8463 0 : if (nXtrk % (-incr) != 0)
8464 : {
8465 0 : dims[l_index]++;
8466 : }
8467 : }
8468 : }
8469 : }
8470 0 : else if (found == 1 && idxMapElem != -1)
8471 : {
8472 :
8473 : /* Indexed Mapping */
8474 : /* --------------- */
8475 :
8476 0 : dims[l_index] = 0;
8477 :
8478 : /* Loop through all regions */
8479 : /* ------------------------ */
8480 0 : for (k = 0; k < SWXRegion[regionID]->nRegions; k++)
8481 : {
8482 0 : j = 0;
8483 0 : if(SWXRegion[regionID]->scanflag == 1)
8484 : {
8485 0 : startscanline = SWXRegion[regionID]->StartRegion[k];
8486 0 : stopscanline = SWXRegion[regionID]->StopRegion[k];
8487 0 : if (strcmp(fieldname,dfieldlist) == 0)
8488 : {
8489 0 : dims[l_index] = stopscanline - startscanline + 1;
8490 0 : datafld = 1;
8491 : }
8492 0 : if (strcmp(fieldname, "Latitude") == 0 ||
8493 0 : strcmp(fieldname, "Longitude") == 0)
8494 : {
8495 0 : if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3)
8496 : {
8497 0 : status = SWfieldinfo(swathID,"scan_no",&rk,dims2,&nt,dimlist);
8498 0 : tbuffer = (uint16 *)calloc(dims2[0], sizeof(uint16));
8499 0 : status =SWreadfield(swathID,"scan_no",NULL,NULL,NULL,tbuffer);
8500 0 : startscanline = startscanline - ((tbuffer[0] * detect_cnt) - detect_cnt);
8501 0 : stopscanline = stopscanline - ((tbuffer[0] * detect_cnt) - 1);
8502 : }
8503 0 : if(SWXRegion[regionID]->band8flag == 2 ||
8504 0 : SWXRegion[regionID]->band8flag == 3)
8505 : {
8506 0 : if(startscandim == -1)
8507 0 : if(startscanline < idxmap[0])
8508 : {
8509 0 : startscandim = 0;
8510 0 : dims[l_index] = 0;
8511 0 : if(stopscanline > idxmap[scene_cnt *2 - 1])
8512 : {
8513 0 : stopscandim = scene_cnt*2 - startscandim;
8514 0 : dims[l_index] = scene_cnt*2 - startscandim;
8515 : }
8516 : }
8517 : }
8518 0 : for (l = 0; l < scene_cnt; l++)
8519 : {
8520 0 : if(idxmap[j] <= startscanline && idxmap[j+1] >= startscanline)
8521 0 : if(startscandim == -1)
8522 : {
8523 0 : dims[l_index] = j;
8524 0 : startscandim = j;
8525 : }
8526 0 : if(idxmap[j] <= stopscanline && idxmap[j+1] >= stopscanline)
8527 0 : if(startscandim != -1)
8528 : {
8529 0 : dims[l_index] = j - startscandim + 2;
8530 0 : stopscandim = j + 1;
8531 : }
8532 0 : j = j + 2;
8533 0 : if(idxmap[j] == 0 || idxmap[j+1] == 0)
8534 0 : l = scene_cnt;
8535 : }
8536 0 : if(SWXRegion[regionID]->band8flag == 1 ||
8537 0 : SWXRegion[regionID]->band8flag == 2)
8538 : {
8539 0 : if(stopscandim == -1)
8540 0 : if(stopscanline > idxmap[scene_cnt * 2 - 1])
8541 : {
8542 0 : stopscandim = scene_cnt*2 - dims[l_index];
8543 0 : dims[l_index] = scene_cnt*2 - dims[l_index];
8544 : }
8545 : }
8546 0 : if(SWXRegion[regionID]->band8flag == 3)
8547 : {
8548 0 : if(startscandim == -1)
8549 0 : if(startscanline < idxmap[0])
8550 : {
8551 0 : startscandim = 0;
8552 0 : if(stopscandim != -1)
8553 0 : dims[l_index] = stopscandim - startscandim + 1;
8554 : }
8555 : }
8556 0 : if(SWXRegion[regionID]->band8flag == 2)
8557 : {
8558 0 : if(startscandim == -1)
8559 0 : if(startscanline > idxmap[j - 1])
8560 : {
8561 0 : status = SWfieldinfo(SWXRegion[regionID]->swathID,"scan_no",&rank2,dims2,&nt,dimlist);
8562 0 : buffer2 = (uint16 *)calloc(dims2[0], sizeof(uint16));
8563 0 : status = SWreadfield(SWXRegion[regionID]->swathID,"scan_no",NULL,NULL,NULL,buffer2);
8564 0 : startscanline = startscanline - (buffer2[0] * detect_cnt);
8565 0 : stopscanline = stopscanline - (buffer2[0] * detect_cnt);
8566 0 : free(buffer2);
8567 0 : j = 0;
8568 0 : for (l = 0; l < scene_cnt; l++)
8569 : {
8570 0 : if(idxmap[j] <= startscanline && idxmap[j+1] >= startscanline)
8571 : {
8572 0 : dims[l_index] = j;
8573 0 : startscandim = j;
8574 : }
8575 0 : if(idxmap[j] <= stopscanline && idxmap[j+1] >= stopscanline)
8576 0 : dims[l_index] = j - startscandim + 2;
8577 0 : j = j + 2;
8578 0 : if(idxmap[j] == 0 || idxmap[j+1] == 0)
8579 0 : l = scene_cnt;
8580 : }
8581 :
8582 : }
8583 : }
8584 : }
8585 0 : if (strcmp(fieldname, "scene_center_latitude") == 0 ||
8586 0 : strcmp(fieldname, "scene_center_longitude") == 0)
8587 : {
8588 0 : startscanline = SWXRegion[regionID]->StartRegion[k];
8589 0 : stopscanline = SWXRegion[regionID]->StopRegion[k];
8590 0 : if(startscanline < idxmap[0])
8591 : {
8592 0 : startscandim = 0;
8593 0 : dims[l_index] = 0;
8594 : }
8595 0 : for (l = 0; l < scene_cnt-1; l++)
8596 : {
8597 0 : if(idxmap[l] <= startscanline && idxmap[l+1] >= startscanline)
8598 0 : if(startscandim == -1)
8599 : {
8600 0 : dims[l_index] = l;
8601 0 : startscandim = l;
8602 : }
8603 0 : if(idxmap[l] <= stopscanline && idxmap[l+1] >= stopscanline)
8604 : {
8605 0 : dims[l_index] = l - startscandim + 2;
8606 0 : stopscandim = l + 1;
8607 : }
8608 : }
8609 0 : if(stopscandim == -1)
8610 : {
8611 0 : if(stopscanline > idxmap[scene_cnt - 1])
8612 : {
8613 0 : dims[l_index] = scene_cnt - startscandim;
8614 0 : stopscandim = scene_cnt - 1;
8615 : }
8616 : }
8617 0 : if(SWXRegion[regionID]->band8flag == 1)
8618 : {
8619 0 : if(stopscandim == -1)
8620 0 : if(stopscanline > idxmap[scene_cnt - 1])
8621 : {
8622 0 : dims[l_index] = scene_cnt - startscandim;
8623 0 : stopscandim = scene_cnt - 1;
8624 : }
8625 : }
8626 0 : if(SWXRegion[regionID]->band8flag == 2 ||
8627 0 : SWXRegion[regionID]->band8flag == 3)
8628 : {
8629 0 : if(startscandim == -1)
8630 : {
8631 0 : if(startscanline < idxmap[0])
8632 : {
8633 0 : startscandim = 0;
8634 0 : dims[l_index] = stopscandim - startscandim + 1;
8635 : }
8636 : }
8637 0 : if(startscandim == -1)
8638 : {
8639 0 : startscanline = SWXRegion[regionID]->StartScan[k] * detect_cnt;
8640 0 : stopscanline = SWXRegion[regionID]->StopScan[k] * detect_cnt;
8641 0 : for (l = 0; l < scene_cnt-1; l++)
8642 : {
8643 0 : if(idxmap[l] <= startscanline && idxmap[l+1] >= startscanline)
8644 0 : dims[l_index] = l;
8645 0 : if(idxmap[l] <= stopscanline && idxmap[l+1] >= stopscanline)
8646 0 : dims[l_index] = l - dims[l_index] + 1;
8647 : }
8648 : }
8649 : }
8650 : }
8651 : }
8652 : else
8653 : {
8654 0 : if (datafld != 1)
8655 : {
8656 : /* Get number of cross tracks in particular region */
8657 : /* ----------------------------------------------- */
8658 0 : nXtrk = idxmap[SWXRegion[regionID]->StopRegion[k]] -
8659 0 : idxmap[SWXRegion[regionID]->StartRegion[k]] + 1;
8660 :
8661 0 : dims[l_index] += nXtrk;
8662 : }
8663 : }
8664 : }
8665 : }
8666 : else
8667 : {
8668 : /* Mapping not found */
8669 : /* ----------------- */
8670 0 : status = -1;
8671 0 : HEpush(DFE_GENAPP, "SWregioninfo",
8672 : __FILE__, __LINE__);
8673 0 : HEreport(
8674 : "Mapping Not Defined for \"%s\" Dimension.\n",
8675 : geodim);
8676 : }
8677 : }
8678 :
8679 :
8680 :
8681 : /* Vertical Subset */
8682 : /* --------------- */
8683 0 : if (status == 0 || status == -1) /* check the vertical subset in any case -- xhua */
8684 : {
8685 0 : for (j = 0; j < 8; j++)
8686 : {
8687 : /* If active vertical subset ... */
8688 : /* ----------------------------- */
8689 0 : if (SWXRegion[regionID]->StartVertical[j] != -1)
8690 : {
8691 :
8692 : /* Find vertical dimension within dimlist */
8693 : /* -------------------------------------- */
8694 0 : l_index = EHstrwithin(SWXRegion[regionID]->DimNamePtr[j],
8695 : dimlist, ',');
8696 :
8697 : /* If dimension found ... */
8698 : /* ---------------------- */
8699 0 : if (l_index != -1)
8700 : {
8701 : /* Compute dimension size */
8702 : /* ---------------------- */
8703 0 : dims[l_index] =
8704 0 : SWXRegion[regionID]->StopVertical[j] -
8705 0 : SWXRegion[regionID]->StartVertical[j] + 1;
8706 : }
8707 : else
8708 : {
8709 : /* Vertical dimension not found */
8710 : /* ---------------------------- */
8711 0 : status = -1;
8712 0 : *size = -1;
8713 0 : HEpush(DFE_GENAPP, "SWregioninfo", __FILE__, __LINE__);
8714 0 : HEreport(errMesg, SWXRegion[regionID]->DimNamePtr[j]);
8715 : }
8716 : }
8717 : }
8718 :
8719 :
8720 :
8721 : /* Compute size of region data buffer */
8722 : /* ---------------------------------- */
8723 0 : if (status == 0)
8724 : {
8725 0 : if(idxMapElem == 1 && SWXRegion[regionID]->scanflag == 1 && land_status == 0)
8726 : {
8727 0 : if(startscandim == dims[0])
8728 0 : dims[0] = scene_cnt*2 - startscandim;
8729 : }
8730 :
8731 : /* Compute number of total elements */
8732 : /* -------------------------------- */
8733 0 : *size = dims[0];
8734 0 : for (j = 1; j < *rank; j++)
8735 : {
8736 0 : *size *= dims[j];
8737 : }
8738 :
8739 : /* Multiply by size in bytes of numbertype */
8740 : /* --------------------------------------- */
8741 0 : *size *= DFKNTsize(*ntype);
8742 : }
8743 : }
8744 : }
8745 :
8746 :
8747 :
8748 : /* Free l_index mappings if applicable */
8749 : /* --------------------------------- */
8750 0 : if (idxmap != NULL)
8751 : {
8752 0 : free(idxmap);
8753 : }
8754 0 : if(dfieldlist != NULL)
8755 0 : free(dfieldlist);
8756 :
8757 0 : return (status);
8758 : }
8759 :
8760 :
8761 :
8762 : /*----------------------------------------------------------------------------|
8763 : | BEGIN_PROLOG |
8764 : | |
8765 : | FUNCTION: SWperiodinfo |
8766 : | |
8767 : | DESCRIPTION: Returns size in bytes of region |
8768 : | |
8769 : | |
8770 : | Return Value Type Units Description |
8771 : | ============ ====== ========= ===================================== |
8772 : | status intn return status (0) SUCCEED, (-1) FAIL |
8773 : | |
8774 : | INPUTS: |
8775 : | swathID int32 Swath structure ID |
8776 : | periodID int32 Period ID |
8777 : | fieldname char Fieldname |
8778 : | |
8779 : | |
8780 : | OUTPUTS: |
8781 : | ntype int32 field number type |
8782 : | rank int32 field rank |
8783 : | dims int32 dimensions of field region |
8784 : | size int32 size in bytes of field region |
8785 : | |
8786 : | NOTES: |
8787 : | |
8788 : | |
8789 : | Date Programmer Description |
8790 : | ====== ============ ================================================= |
8791 : | Jun 96 Joel Gales Original Programmer |
8792 : | Jun 03 Abe Taaheri added clearing timeflag if SWregioninfo fails |
8793 : | |
8794 : | END_PROLOG |
8795 : -----------------------------------------------------------------------------*/
8796 : intn
8797 0 : SWperiodinfo(int32 swathID, int32 periodID, const char *fieldname,
8798 : int32 * ntype, int32 * rank, int32 dims[], int32 * size)
8799 : {
8800 : intn status; /* routine return status variable */
8801 :
8802 :
8803 0 : timeflag = 1;
8804 : /* Call SWregioninfo */
8805 : /* ----------------- */
8806 0 : status = SWregioninfo(swathID, periodID, fieldname, ntype, rank,
8807 : dims, size);
8808 0 : if (status != 0) timeflag = 0;/* clear timeflag if SWregioninfo failed */
8809 0 : return (status);
8810 : }
8811 :
8812 :
8813 :
8814 :
8815 :
8816 : /*----------------------------------------------------------------------------|
8817 : | BEGIN_PROLOG |
8818 : | |
8819 : | FUNCTION: SWdefvrtregion |
8820 : | |
8821 : | DESCRIPTION: Finds elements of a monotonic field within a given range. |
8822 : | |
8823 : | |
8824 : | Return Value Type Units Description |
8825 : | ============ ====== ========= ===================================== |
8826 : | regionID int32 Region ID |
8827 : | |
8828 : | INPUTS: |
8829 : | swathID int32 Swath structure ID |
8830 : | regionID int32 Region ID |
8831 : | vertObj char Vertical object to subset |
8832 : | range float64 Vertical subsetting range |
8833 : | |
8834 : | OUTPUTS: |
8835 : | None |
8836 : | |
8837 : | NOTES: |
8838 : | |
8839 : | |
8840 : | Date Programmer Description |
8841 : | ====== ============ ================================================= |
8842 : | Aug 96 Joel Gales Original Programmer |
8843 : | Dec 96 Joel Gales Add multiple vertical subsetting capability |
8844 : | May 97 Joel Gales Check for supported field types |
8845 : | |
8846 : | END_PROLOG |
8847 : -----------------------------------------------------------------------------*/
8848 :
8849 :
8850 : /* Macro to initialize swath region entry */
8851 : /* -------------------------------------- */
8852 :
8853 : /*
8854 : * 1) Find empty (inactive) region. 2) Allocate space for region entry. 3)
8855 : * Store file ID and swath ID. 4) Set region ID. 5) Initialize vertical
8856 : * subset entries to -1.
8857 : */
8858 :
8859 : #define SETSWTHREG \
8860 : \
8861 : for (k = 0; k < NSWATHREGN; k++) \
8862 : { \
8863 : if (SWXRegion[k] == 0) \
8864 : { \
8865 : SWXRegion[k] = (struct swathRegion *) \
8866 : calloc(1, sizeof(struct swathRegion)); \
8867 : SWXRegion[k]->fid = fid; \
8868 : SWXRegion[k]->swathID = swathID; \
8869 : regionID = k; \
8870 : for (j=0; j<8; j++) \
8871 : { \
8872 : SWXRegion[k]->StartVertical[j] = -1; \
8873 : SWXRegion[k]->StopVertical[j] = -1; \
8874 : SWXRegion[k]->StartScan[j] = -1; \
8875 : SWXRegion[k]->StopScan[j] = -1; \
8876 : SWXRegion[k]->band8flag = -1; \
8877 : } \
8878 : break; \
8879 : } \
8880 : }
8881 :
8882 :
8883 : /* Macro to fill vertical subset entry */
8884 : /* ----------------------------------- */
8885 :
8886 : /*
8887 : * 1) Find empty (inactive) vertical region. 2) Set start of vertical region.
8888 : * 3) Allocate space for name of vertical dimension. 4) Write vertical
8889 : * dimension name.
8890 : */
8891 :
8892 : #define FILLVERTREG \
8893 : for (j=0; j<8; j++) \
8894 : { \
8895 : if (SWXRegion[regionID]->StartVertical[j] == -1) \
8896 : { \
8897 : SWXRegion[regionID]->StartVertical[j] = i; \
8898 : SWXRegion[regionID]->DimNamePtr[j] = \
8899 : (char *) malloc(slen + 1); \
8900 : memcpy(SWXRegion[regionID]->DimNamePtr[j], \
8901 : dimlist, slen + 1); \
8902 : break; \
8903 : } \
8904 : } \
8905 :
8906 :
8907 :
8908 : int32
8909 0 : SWdefvrtregion(int32 swathID, int32 regionID, const char *vertObj, float64 range[])
8910 : {
8911 : intn i; /* Loop index */
8912 0 : intn j = 0; /* Loop index */
8913 : intn k; /* Loop index */
8914 : intn status; /* routine return status variable */
8915 :
8916 0 : uint8 found = 0; /* Found flag */
8917 :
8918 : int16 vertINT16; /* Temporary INT16 variable */
8919 :
8920 : int32 fid; /* HDF-EOS file ID */
8921 : int32 sdInterfaceID; /* HDF SDS interface ID */
8922 : int32 swVgrpID; /* Swath Vgroup ID */
8923 : int32 slen; /* String length */
8924 : int32 rank; /* Field rank */
8925 : int32 nt; /* Field numbertype */
8926 : int32 dims[8]; /* Field dimensions */
8927 : int32 size; /* Size of numbertype in bytes */
8928 : int32 vertINT32; /* Temporary INT32 variable */
8929 :
8930 : float32 vertFLT32; /* Temporary FLT32 variable */
8931 :
8932 : float64 vertFLT64; /* Temporary FLT64 variable */
8933 :
8934 : char *vertArr; /* Pointer to vertical field data buffer */
8935 : char dimlist[256]; /* Dimension list */
8936 :
8937 :
8938 : /* Check for valid swath ID */
8939 : /* ------------------------ */
8940 0 : status = SWchkswid(swathID, "SWdefvrtregion", &fid, &sdInterfaceID,
8941 : &swVgrpID);
8942 :
8943 0 : if (status == 0)
8944 : {
8945 : /* Copy first 4 characters of vertObj into dimlist */
8946 : /* ----------------------------------------------- */
8947 0 : memcpy(dimlist, vertObj, 4);
8948 0 : dimlist[4] = 0;
8949 :
8950 :
8951 :
8952 : /* If first 4 characters of vertObj = "DIM:" ... */
8953 : /* --------------------------------------------- */
8954 :
8955 : /* Vertical Object is dimension name */
8956 : /* --------------------------------- */
8957 0 : if (strcmp(dimlist, "DIM:") == 0)
8958 : {
8959 : /* Get string length of vertObj (minus "DIM:) */
8960 : /* ------------------------------------------ */
8961 0 : slen = (int)strlen(vertObj) - 4;
8962 :
8963 :
8964 : /* If regionID = -1 then setup swath region entry */
8965 : /* ---------------------------------------------- */
8966 0 : if (regionID == -1)
8967 : {
8968 0 : SETSWTHREG;
8969 : }
8970 :
8971 :
8972 : /* Find first empty (inactive) vertical subset entry */
8973 : /* ------------------------------------------------- */
8974 0 : for (j = 0; j < 8; j++)
8975 : {
8976 0 : if (SWXRegion[regionID]->StartVertical[j] == -1)
8977 : {
8978 : /* Store start & stop of vertical region */
8979 : /* ------------------------------------- */
8980 0 : SWXRegion[regionID]->StartVertical[j] = (int32) range[0];
8981 0 : SWXRegion[regionID]->StopVertical[j] = (int32) range[1];
8982 :
8983 : /* Store vertical dimension name */
8984 : /* ----------------------------- */
8985 0 : SWXRegion[regionID]->DimNamePtr[j] =
8986 0 : (char *) malloc(slen + 1);
8987 0 : if(SWXRegion[regionID]->DimNamePtr[j] == NULL)
8988 : {
8989 0 : HEpush(DFE_NOSPACE,"SWdefvrtregion", __FILE__, __LINE__);
8990 0 : return(-1);
8991 : }
8992 0 : memcpy(SWXRegion[regionID]->DimNamePtr[j],
8993 0 : vertObj + 4, slen + 1);
8994 0 : break;
8995 : }
8996 : }
8997 : }
8998 : else
8999 : {
9000 :
9001 : /* Vertical Object is fieldname */
9002 : /* ---------------------------- */
9003 :
9004 :
9005 : /* Check for valid fieldname */
9006 : /* ------------------------- */
9007 0 : status = SWfieldinfo(swathID, vertObj, &rank, dims, &nt,
9008 : dimlist);
9009 :
9010 0 : if (status != 0)
9011 : {
9012 0 : status = -1;
9013 0 : HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__);
9014 0 : HEreport("Vertical Field: \"%s\" not found.\n", vertObj);
9015 : }
9016 :
9017 :
9018 :
9019 : /* Check for supported field types */
9020 : /* ------------------------------- */
9021 0 : if (nt != DFNT_INT16 &&
9022 0 : nt != DFNT_INT32 &&
9023 0 : nt != DFNT_FLOAT32 &&
9024 0 : nt != DFNT_FLOAT64)
9025 : {
9026 0 : status = -1;
9027 0 : HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__);
9028 0 : HEreport("Fieldtype: %d not supported for vertical subsetting.\n", nt);
9029 : }
9030 :
9031 :
9032 :
9033 : /* Check that vertical dimension is 1D */
9034 : /* ----------------------------------- */
9035 0 : if (status == 0)
9036 : {
9037 0 : if (rank != 1)
9038 : {
9039 0 : status = -1;
9040 0 : HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__);
9041 0 : HEreport("Vertical Field: \"%s\" must be 1-dim.\n",
9042 : vertObj);
9043 : }
9044 : }
9045 :
9046 :
9047 : /* If no problems then continue */
9048 : /* ---------------------------- */
9049 0 : if (status == 0)
9050 : {
9051 : /* Get string length of vertical dimension */
9052 : /* --------------------------------------- */
9053 0 : slen = (int)strlen(dimlist);
9054 :
9055 :
9056 : /* Get size in bytes of vertical field numbertype */
9057 : /* ---------------------------------------------- */
9058 0 : size = DFKNTsize(nt);
9059 :
9060 :
9061 : /* Allocate space for vertical field */
9062 : /* --------------------------------- */
9063 0 : vertArr = (char *) calloc(dims[0], size);
9064 0 : if(vertArr == NULL)
9065 : {
9066 0 : HEpush(DFE_NOSPACE,"SWdefvrtregion", __FILE__, __LINE__);
9067 0 : return(-1);
9068 : }
9069 :
9070 : /* Read vertical field */
9071 : /* ------------------- */
9072 0 : status = SWreadfield(swathID, vertObj,
9073 : NULL, NULL, NULL, vertArr);
9074 :
9075 :
9076 :
9077 0 : switch (nt)
9078 : {
9079 0 : case DFNT_INT16:
9080 :
9081 0 : for (i = 0; i < dims[0]; i++)
9082 : {
9083 : /* Get single element of vertical field */
9084 : /* ------------------------------------ */
9085 0 : memcpy(&vertINT16, vertArr + i * size, size);
9086 :
9087 :
9088 : /* If within range ... */
9089 : /* ------------------- */
9090 0 : if (vertINT16 >= range[0] &&
9091 0 : vertINT16 <= range[1])
9092 : {
9093 : /* Set found flag */
9094 : /* -------------- */
9095 0 : found = 1;
9096 :
9097 :
9098 : /* If regionID=-1 then setup swath region entry */
9099 : /* -------------------------------------------- */
9100 0 : if (regionID == -1)
9101 : {
9102 0 : SETSWTHREG;
9103 : }
9104 :
9105 :
9106 : /* Fill-in vertical region entries */
9107 : /* ------------------------------- */
9108 0 : FILLVERTREG;
9109 :
9110 0 : break;
9111 : }
9112 : }
9113 :
9114 :
9115 : /* If found read from "bottom" of data field */
9116 : /* ----------------------------------------- */
9117 0 : if (found == 1)
9118 : {
9119 0 : for (i = dims[0] - 1; i >= 0; i--)
9120 : {
9121 : /* Get single element of vertical field */
9122 : /* ------------------------------------ */
9123 0 : memcpy(&vertINT16, vertArr + i * size, size);
9124 :
9125 :
9126 : /* If within range ... */
9127 : /* ------------------- */
9128 0 : if (vertINT16 >= range[0] &&
9129 0 : vertINT16 <= range[1])
9130 : {
9131 : /* Set end of vertical region */
9132 : /* -------------------------- */
9133 0 : SWXRegion[regionID]->StopVertical[j] = i;
9134 0 : break;
9135 : }
9136 : }
9137 : }
9138 : else
9139 : {
9140 : /* No vertical entries within region */
9141 : /* --------------------------------- */
9142 0 : status = -1;
9143 0 : HEpush(DFE_GENAPP, "SWdefvrtregion",
9144 : __FILE__, __LINE__);
9145 0 : HEreport("No vertical field entries within region.\n");
9146 : }
9147 0 : break;
9148 :
9149 :
9150 0 : case DFNT_INT32:
9151 :
9152 0 : for (i = 0; i < dims[0]; i++)
9153 : {
9154 : /* Get single element of vertical field */
9155 : /* ------------------------------------ */
9156 0 : memcpy(&vertINT32, vertArr + i * size, size);
9157 :
9158 :
9159 : /* If within range ... */
9160 : /* ------------------- */
9161 0 : if (vertINT32 >= range[0] &&
9162 0 : vertINT32 <= range[1])
9163 : {
9164 : /* Set found flag */
9165 : /* -------------- */
9166 0 : found = 1;
9167 :
9168 :
9169 : /* If regionID=-1 then setup swath region entry */
9170 : /* -------------------------------------------- */
9171 0 : if (regionID == -1)
9172 : {
9173 0 : SETSWTHREG;
9174 : }
9175 :
9176 :
9177 : /* Fill-in vertical region entries */
9178 : /* ------------------------------- */
9179 0 : FILLVERTREG;
9180 :
9181 0 : break;
9182 : }
9183 : }
9184 :
9185 :
9186 : /* If found read from "bottom" of data field */
9187 : /* ----------------------------------------- */
9188 0 : if (found == 1)
9189 : {
9190 0 : for (i = dims[0] - 1; i >= 0; i--)
9191 : {
9192 : /* Get single element of vertical field */
9193 : /* ------------------------------------ */
9194 0 : memcpy(&vertINT32, vertArr + i * size, size);
9195 :
9196 :
9197 : /* If within range ... */
9198 : /* ------------------- */
9199 0 : if (vertINT32 >= range[0] &&
9200 0 : vertINT32 <= range[1])
9201 : {
9202 : /* Set end of vertical region */
9203 : /* -------------------------- */
9204 0 : SWXRegion[regionID]->StopVertical[j] = i;
9205 0 : break;
9206 : }
9207 : }
9208 : }
9209 : else
9210 : {
9211 : /* No vertical entries within region */
9212 : /* --------------------------------- */
9213 0 : status = -1;
9214 0 : HEpush(DFE_GENAPP, "SWdefvrtregion",
9215 : __FILE__, __LINE__);
9216 0 : HEreport("No vertical field entries within region.\n");
9217 : }
9218 0 : break;
9219 :
9220 :
9221 0 : case DFNT_FLOAT32:
9222 :
9223 0 : for (i = 0; i < dims[0]; i++)
9224 : {
9225 : /* Get single element of vertical field */
9226 : /* ------------------------------------ */
9227 0 : memcpy(&vertFLT32, vertArr + i * size, size);
9228 :
9229 :
9230 : /* If within range ... */
9231 : /* ------------------- */
9232 0 : if (vertFLT32 >= range[0] &&
9233 0 : vertFLT32 <= range[1])
9234 : {
9235 : /* Set found flag */
9236 : /* -------------- */
9237 0 : found = 1;
9238 :
9239 :
9240 : /* If regionID=-1 then setup swath region entry */
9241 : /* -------------------------------------------- */
9242 0 : if (regionID == -1)
9243 : {
9244 0 : SETSWTHREG;
9245 : }
9246 :
9247 :
9248 : /* Fill-in vertical region entries */
9249 : /* ------------------------------- */
9250 0 : FILLVERTREG;
9251 :
9252 0 : break;
9253 : }
9254 : }
9255 :
9256 :
9257 : /* If found read from "bottom" of data field */
9258 : /* ----------------------------------------- */
9259 0 : if (found == 1)
9260 : {
9261 0 : for (i = dims[0] - 1; i >= 0; i--)
9262 : {
9263 : /* Get single element of vertical field */
9264 : /* ------------------------------------ */
9265 0 : memcpy(&vertFLT32, vertArr + i * size, size);
9266 :
9267 :
9268 : /* If within range ... */
9269 : /* ------------------- */
9270 0 : if (vertFLT32 >= range[0] &&
9271 0 : vertFLT32 <= range[1])
9272 : {
9273 : /* Set end of vertical region */
9274 : /* -------------------------- */
9275 0 : SWXRegion[regionID]->StopVertical[j] = i;
9276 0 : break;
9277 : }
9278 : }
9279 : }
9280 : else
9281 : {
9282 : /* No vertical entries within region */
9283 : /* --------------------------------- */
9284 0 : status = -1;
9285 0 : HEpush(DFE_GENAPP, "SWdefvrtregion",
9286 : __FILE__, __LINE__);
9287 0 : HEreport("No vertical field entries within region.\n");
9288 : }
9289 0 : break;
9290 :
9291 :
9292 0 : case DFNT_FLOAT64:
9293 :
9294 0 : for (i = 0; i < dims[0]; i++)
9295 : {
9296 : /* Get single element of vertical field */
9297 : /* ------------------------------------ */
9298 0 : memcpy(&vertFLT64, vertArr + i * size, size);
9299 :
9300 :
9301 : /* If within range ... */
9302 : /* ------------------- */
9303 0 : if (vertFLT64 >= range[0] &&
9304 0 : vertFLT64 <= range[1])
9305 : {
9306 : /* Set found flag */
9307 : /* -------------- */
9308 0 : found = 1;
9309 :
9310 :
9311 : /* If regionID=-1 then setup swath region entry */
9312 : /* -------------------------------------------- */
9313 0 : if (regionID == -1)
9314 : {
9315 0 : SETSWTHREG;
9316 : }
9317 :
9318 :
9319 : /* Fill-in vertical region entries */
9320 : /* ------------------------------- */
9321 0 : FILLVERTREG;
9322 :
9323 0 : break;
9324 : }
9325 : }
9326 :
9327 :
9328 : /* If found read from "bottom" of data field */
9329 : /* ----------------------------------------- */
9330 0 : if (found == 1)
9331 : {
9332 0 : for (i = dims[0] - 1; i >= 0; i--)
9333 : {
9334 : /* Get single element of vertical field */
9335 : /* ------------------------------------ */
9336 0 : memcpy(&vertFLT64, vertArr + i * size, size);
9337 :
9338 : /* If within range ... */
9339 : /* ------------------- */
9340 0 : if (vertFLT64 >= range[0] &&
9341 0 : vertFLT64 <= range[1])
9342 : {
9343 : /* Set end of vertical region */
9344 : /* -------------------------- */
9345 0 : SWXRegion[regionID]->StopVertical[j] = i;
9346 0 : break;
9347 : }
9348 : }
9349 : }
9350 : else
9351 : {
9352 : /* No vertical entries within region */
9353 : /* --------------------------------- */
9354 0 : status = -1;
9355 0 : HEpush(DFE_GENAPP, "SWdefvrtregion",
9356 : __FILE__, __LINE__);
9357 0 : HEreport("No vertical field entries within region.\n");
9358 : }
9359 0 : break;
9360 :
9361 : } /* End of switch */
9362 0 : free(vertArr);
9363 : }
9364 : }
9365 : }
9366 :
9367 :
9368 : /* Set regionID to -1 if bad return status */
9369 : /* --------------------------------------- */
9370 0 : if (status == -1)
9371 : {
9372 0 : regionID = -1;
9373 : }
9374 :
9375 :
9376 0 : return (regionID);
9377 : }
9378 :
9379 :
9380 :
9381 : /*----------------------------------------------------------------------------|
9382 : | BEGIN_PROLOG |
9383 : | |
9384 : | FUNCTION: SWdefscanregion |
9385 : | |
9386 : | DESCRIPTION: Initialize the region structure for Landsat 7 float scene |
9387 : | subset |
9388 : | |
9389 : | |
9390 : | Return Value Type Units Description |
9391 : | ============ ====== ========= ===================================== |
9392 : | regionID int32 Region ID |
9393 : | |
9394 : | INPUTS: |
9395 : | swathID int32 Swath structure ID |
9396 : | fieldname char Field name to subset |
9397 : | range float64 subsetting range |
9398 : | mode int32 HDFE_ENDPOINT, HDFE_MIDPOINT or |
9399 : | HDFE_ANYPOINT |
9400 : | |
9401 : | OUTPUTS: |
9402 : | regionID int32 Region ID |
9403 : | |
9404 : | NOTES: |
9405 : | |
9406 : | |
9407 : | Date Programmer Description |
9408 : | ====== ============ ================================================= |
9409 : | Jul 99 DaW Original Programmer |
9410 : | |
9411 : | END_PROLOG |
9412 : -----------------------------------------------------------------------------*/
9413 : int32
9414 0 : SWdefscanregion(int32 swathID, const char *fieldname, float64 range[], CPL_UNUSED int32 mode)
9415 : {
9416 : intn j; /* Loop index */
9417 : intn k; /* Loop index */
9418 : intn status; /* routine return status variable */
9419 0 : intn land_status = 3; /* routine return status variable */
9420 0 : intn band81flag = 0;
9421 0 : intn band82flag = 0;
9422 0 : intn band83flag = 0;
9423 0 : uint8 detect_cnt = 0; /* Used to convert scan to scanline */
9424 : /* L7 float scene sub. */
9425 0 : uint8 scene_cnt = 0;
9426 :
9427 :
9428 0 : int32 nmtype = 0; /* Used for L7 float scene sub. */
9429 0 : int32 count = 0; /* Used for L7 float scene sub. */
9430 : int32 fid; /* HDF-EOS file ID */
9431 : int32 sdInterfaceID; /* HDF SDS interface ID */
9432 : int32 swVgrpID; /* Swath Vgroup ID */
9433 : int32 slen; /* String length */
9434 : int32 dfrank[8]; /* data fields rank */
9435 : int32 rank; /* Field rank */
9436 : int32 numtype[8]; /* number type of data fields */
9437 : int32 nt; /* Field numbertype */
9438 : int32 dims[8]; /* Field dimensions */
9439 : int32 dims2[8]; /* Field dimensions */
9440 0 : int32 strbufsize = 0; /* string buffer size */
9441 0 : int32 tmprange0 = 0;
9442 :
9443 :
9444 0 : uint16 *buffer = (uint16 *)NULL;
9445 0 : int32 *idxmap = (int32 *)NULL;
9446 :
9447 0 : int32 dimsize = 0;
9448 :
9449 0 : int32 regionID = -1; /* Region ID (return) */
9450 :
9451 0 : float64 scan[2] = {0,0};
9452 0 : float64 original_scan[2] = {0,0};
9453 :
9454 : char dimlist[256]; /* Dimension list */
9455 : char swathname[80];
9456 0 : char *dfieldlist = (char *)NULL; /* data field list */
9457 0 : char *tfieldname = (char *)NULL; /* temp field buffer */
9458 0 : char *band81 = (char *)NULL;
9459 0 : char *band82 = (char *)NULL;
9460 0 : char *band83 = (char *)NULL;
9461 :
9462 :
9463 : /* Check for valid swath ID */
9464 : /* ------------------------ */
9465 0 : status = SWchkswid(swathID, "SWdefscanregion", &fid, &sdInterfaceID,
9466 : &swVgrpID);
9467 :
9468 : /* This code checks for the attribute detector_count */
9469 : /* which is found in Landsat 7 files. It is used */
9470 : /* for some of the loops. The other code checks if */
9471 : /* one scan is requested. */
9472 : /* ================================================= */
9473 0 : land_status = SWattrinfo(swathID, "detector_count", &nmtype, &count);
9474 0 : if (land_status == 0)
9475 : {
9476 0 : scan[0] = range[0];
9477 0 : scan[1] = range[1];
9478 0 : original_scan[0] = range[0];
9479 0 : original_scan[1] = range[1];
9480 :
9481 0 : land_status = SWreadattr(swathID, "scene_count", &scene_cnt);
9482 0 : land_status = SWreadattr(swathID, "detector_count", &detect_cnt);
9483 0 : if (range[0] == range[1])
9484 : {
9485 0 : range[0] = range[0] * detect_cnt - detect_cnt;
9486 0 : range[1] = range[0] + detect_cnt - 1;
9487 : }
9488 : else
9489 : {
9490 0 : range[0] = range[0] * detect_cnt - detect_cnt;
9491 0 : range[1] = range[1] * detect_cnt - 1;
9492 : }
9493 :
9494 0 : Vgetname(SWXSwath[0].IDTable, swathname);
9495 0 : band81 = strstr(swathname, "B81");
9496 0 : if (band81 != (char *)NULL)
9497 0 : band81flag = 1;
9498 0 : band82 = strstr(swathname, "B82");
9499 0 : if (band82 != (char *)NULL)
9500 0 : band82flag = 1;
9501 0 : band83 = strstr(swathname, "B83");
9502 0 : if (band83 != (char *)NULL)
9503 0 : band83flag = 1;
9504 : }
9505 :
9506 :
9507 : /* If fieldname is null then subsetting Landsat 7 */
9508 : /* floating scene. Get data field name, assume */
9509 : /* only one data field in swath */
9510 : /* ---------------------------------------------- */
9511 :
9512 0 : if (fieldname == (char *)NULL)
9513 : {
9514 0 : (void) SWnentries(swathID, 4, &strbufsize);
9515 0 : dfieldlist = (char *)calloc(strbufsize + 1, sizeof(char));
9516 0 : (void) SWinqdatafields(swathID, dfieldlist, dfrank, numtype);
9517 0 : tfieldname = (char *)calloc(strbufsize + 1, sizeof(char));
9518 0 : strcpy(tfieldname, dfieldlist);
9519 : }
9520 : else
9521 : {
9522 0 : slen = (int)strlen(fieldname);
9523 0 : tfieldname = (char *)calloc(slen + 1, sizeof(char));
9524 0 : strcpy(tfieldname, fieldname);
9525 : }
9526 :
9527 : /* Check for valid fieldname */
9528 : /* ------------------------- */
9529 0 : status = SWfieldinfo(swathID, tfieldname, &rank, dims, &nt,
9530 : dimlist);
9531 :
9532 0 : if (status != 0)
9533 : {
9534 0 : status = -1;
9535 0 : HEpush(DFE_GENAPP, "SWdefscanregion", __FILE__, __LINE__);
9536 0 : HEreport("Field: \"%s\" not found.\n", tfieldname);
9537 : }
9538 :
9539 :
9540 : /* Check if input range values are within range of */
9541 : /* data field */
9542 : /* ----------------------------------------------- */
9543 0 : if(status == 0)
9544 : {
9545 0 : status = SWfieldinfo(swathID, "scan_no", &rank, dims2, &nt, dimlist);
9546 0 : buffer = (uint16 *)calloc(dims2[0], sizeof(uint16));
9547 0 : status = SWreadfield(swathID,"scan_no", NULL, NULL, NULL, buffer);
9548 0 : if(scan[0] > buffer[dims2[0]-1])
9549 : {
9550 0 : HEpush(DFE_GENAPP, "SWdefscanregion", __FILE__, __LINE__);
9551 0 : HEreport("Range values not within bounds of data field\n");
9552 0 : free(buffer);
9553 0 : buffer = (uint16 *)NULL;
9554 0 : if (dfieldlist != NULL)
9555 0 : free(dfieldlist);
9556 0 : free(tfieldname);
9557 0 : return(-1);
9558 : }
9559 0 : if(scan[0] < buffer[0])
9560 : {
9561 0 : if(scan[1] < buffer[0])
9562 : {
9563 0 : HEpush(DFE_GENAPP, "SWdefscanregion", __FILE__, __LINE__);
9564 0 : HEreport("Range values not within bounds of data field\n");
9565 0 : free(buffer);
9566 0 : buffer = (uint16 *)NULL;
9567 0 : if (dfieldlist != NULL)
9568 0 : free(dfieldlist);
9569 0 : free(tfieldname);
9570 0 : return(-1);
9571 : }
9572 : else
9573 : {
9574 0 : scan[0] = buffer[0];
9575 0 : range[0] = scan[0] * detect_cnt - detect_cnt;
9576 : }
9577 : }
9578 0 : if(scan[1] > buffer[dims2[0] - 1])
9579 : {
9580 0 : scan[1] = buffer[dims2[0] - 1];
9581 0 : range[1] = scan[1] * detect_cnt - 1;
9582 : }
9583 : }
9584 :
9585 0 : if(status == 0)
9586 : {
9587 0 : dimsize = SWdiminfo(swathID, "GeoTrack");
9588 0 : if(dimsize > 0)
9589 : {
9590 0 : idxmap = (int32 *)calloc(dimsize, sizeof(int32));
9591 0 : (void) SWidxmapinfo(swathID, "GeoTrack", "ScanLineTrack", idxmap);
9592 0 : tmprange0 = (int32)range[0];
9593 0 : if(band82flag != 1 && band83flag != 1)
9594 : {
9595 0 : if (range[1] > idxmap[scene_cnt*2 - 1])
9596 : {
9597 0 : range[1] = idxmap[scene_cnt*2 - 1];
9598 0 : HEreport("Data length compared to geolocation length\n");
9599 : }
9600 : }
9601 0 : if(band82flag == 1 || band83flag == 1)
9602 : {
9603 0 : tmprange0 = (int32)(range[0] - (buffer[0] * detect_cnt - detect_cnt));
9604 : }
9605 0 : if(tmprange0 >= idxmap[scene_cnt * 2 - 1])
9606 : {
9607 0 : HEpush(DFE_GENAPP, "SWdefscanregion", __FILE__, __LINE__);
9608 0 : HEreport(
9609 : "Range values not within bounds of Latitude/Longitude field(s)\n");
9610 0 : if (dfieldlist != NULL)
9611 0 : free(dfieldlist);
9612 0 : free(tfieldname);
9613 0 : free(buffer);
9614 0 : free(idxmap);
9615 0 : return(-1);
9616 : }
9617 : }
9618 : }
9619 :
9620 0 : if (status == 0)
9621 : {
9622 0 : slen = (int)strlen(tfieldname);
9623 :
9624 0 : SETSWTHREG;
9625 :
9626 : /* Find first empty (inactive) vertical subset entry */
9627 : /* ------------------------------------------------- */
9628 0 : for (j = 0; j < 8; j++)
9629 : {
9630 0 : if (SWXRegion[regionID]->StartVertical[j] == -1)
9631 : {
9632 : /* Store start & stop of region */
9633 : /* ------------------------------------- */
9634 0 : SWXRegion[regionID]->StartScan[j] = (int32) original_scan[0];
9635 0 : SWXRegion[regionID]->StopScan[j] = (int32) original_scan[1];
9636 0 : SWXRegion[regionID]->StartRegion[j] = (int32) range[0];
9637 0 : SWXRegion[regionID]->StopRegion[j] = (int32) range[1];
9638 0 : ++SWXRegion[regionID]->nRegions;
9639 0 : SWXRegion[regionID]->scanflag = 1;
9640 0 : if(band81flag == 1)
9641 0 : SWXRegion[regionID]->band8flag = 1;
9642 0 : if(band82flag == 1)
9643 0 : SWXRegion[regionID]->band8flag = 2;
9644 0 : if(band83flag == 1)
9645 0 : SWXRegion[regionID]->band8flag = 3;
9646 0 : break;
9647 : }
9648 : }
9649 : }
9650 :
9651 :
9652 : /* Set regionID to -1 if bad return status */
9653 : /* --------------------------------------- */
9654 0 : if (status == -1)
9655 : {
9656 0 : regionID = -1;
9657 : }
9658 :
9659 0 : if (dfieldlist != NULL)
9660 0 : free(dfieldlist);
9661 0 : free(tfieldname);
9662 0 : if (buffer != NULL)
9663 0 : free(buffer);
9664 0 : if (idxmap != NULL)
9665 0 : free(idxmap);
9666 :
9667 0 : return (regionID);
9668 : }
9669 :
9670 :
9671 : /*----------------------------------------------------------------------------|
9672 : | BEGIN_PROLOG |
9673 : | |
9674 : | FUNCTION: SWsetfillvalue |
9675 : | |
9676 : | DESCRIPTION: Sets fill value for the specified field. |
9677 : | |
9678 : | |
9679 : | Return Value Type Units Description |
9680 : | ============ ====== ========= ===================================== |
9681 : | status intn return status (0) SUCCEED, (-1) FAIL |
9682 : | |
9683 : | INPUTS: |
9684 : | swathID int32 swath structure ID |
9685 : | fieldname char field name |
9686 : | fillval void fill value |
9687 : | |
9688 : | OUTPUTS: |
9689 : | None |
9690 : | |
9691 : | NOTES: |
9692 : | |
9693 : | |
9694 : | Date Programmer Description |
9695 : | ====== ============ ================================================= |
9696 : | Jun 96 Joel Gales Original Programmer |
9697 : | |
9698 : | END_PROLOG |
9699 : -----------------------------------------------------------------------------*/
9700 : intn
9701 0 : SWsetfillvalue(int32 swathID, const char *fieldname, VOIDP fillval)
9702 : {
9703 : intn status; /* routine return status variable */
9704 :
9705 : int32 fid; /* HDF-EOS file ID */
9706 : int32 sdInterfaceID; /* HDF SDS interface ID */
9707 : int32 swVgrpID; /* Swath root Vgroup ID */
9708 : int32 sdid; /* SDS id */
9709 : int32 nt; /* Number type */
9710 : int32 dims[8]; /* Dimensions array */
9711 : int32 dum; /* Dummy variable */
9712 : int32 solo; /* "Solo" (non-merged) field flag */
9713 :
9714 : char name[80]; /* Fill value "attribute" name */
9715 :
9716 : /* Check for valid swath ID and get SDS interface ID */
9717 0 : status = SWchkswid(swathID, "SWsetfillvalue",
9718 : &fid, &sdInterfaceID, &swVgrpID);
9719 :
9720 0 : if (status == 0)
9721 : {
9722 : /* Get field info */
9723 0 : status = SWfieldinfo(swathID, fieldname, &dum, dims, &nt, NULL);
9724 :
9725 0 : if (status == 0)
9726 : {
9727 : /* Get SDS ID and solo flag */
9728 0 : status = SWSDfldsrch(swathID, sdInterfaceID, fieldname,
9729 : &sdid, &dum, &dum, &dum,
9730 : dims, &solo);
9731 :
9732 : /* If unmerged field then call HDF set field routine */
9733 0 : if (solo == 1)
9734 : {
9735 0 : /* status = */ SDsetfillvalue(sdid, fillval);
9736 : }
9737 :
9738 : /*
9739 : * Store fill value in attribute. Name is given by fieldname
9740 : * prepended with "_FV_"
9741 : */
9742 0 : strcpy(name, "_FV_");
9743 0 : strcat(name, fieldname);
9744 0 : status = SWwriteattr(swathID, name, nt, 1, fillval);
9745 : }
9746 : else
9747 : {
9748 0 : HEpush(DFE_GENAPP, "SWsetfillvalue", __FILE__, __LINE__);
9749 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
9750 : }
9751 : }
9752 0 : return (status);
9753 : }
9754 :
9755 :
9756 :
9757 :
9758 :
9759 : /*----------------------------------------------------------------------------|
9760 : | BEGIN_PROLOG |
9761 : | |
9762 : | FUNCTION: SWgetfillvalue |
9763 : | |
9764 : | DESCRIPTION: Retrieves fill value for a specified field. |
9765 : | |
9766 : | |
9767 : | Return Value Type Units Description |
9768 : | ============ ====== ========= ===================================== |
9769 : | status intn return status (0) SUCCEED, (-1) FAIL |
9770 : | |
9771 : | INPUTS: |
9772 : | swathID int32 swath structure ID |
9773 : | fieldname char field name |
9774 : | |
9775 : | OUTPUTS: |
9776 : | fillval void fill value |
9777 : | |
9778 : | NOTES: |
9779 : | |
9780 : | |
9781 : | Date Programmer Description |
9782 : | ====== ============ ================================================= |
9783 : | Jun 96 Joel Gales Original Programmer |
9784 : | |
9785 : | END_PROLOG |
9786 : -----------------------------------------------------------------------------*/
9787 : intn
9788 0 : SWgetfillvalue(int32 swathID, const char *fieldname, VOIDP fillval)
9789 : {
9790 : intn status; /* routine return status variable */
9791 :
9792 : int32 nt; /* Number type */
9793 : int32 dims[8]; /* Dimensions array */
9794 : int32 dum; /* Dummy variable */
9795 :
9796 : char name[80]; /* Fill value "attribute" name */
9797 :
9798 : /* Check for valid swath ID */
9799 0 : status = SWchkswid(swathID, "SWgetfillvalue", &dum, &dum, &dum);
9800 :
9801 0 : if (status == 0)
9802 : {
9803 : /* Get field info */
9804 0 : status = SWfieldinfo(swathID, fieldname, &dum, dims, &nt, NULL);
9805 :
9806 0 : if (status == 0)
9807 : {
9808 : /* Read fill value attribute */
9809 0 : strcpy(name, "_FV_");
9810 0 : strcat(name, fieldname);
9811 0 : status = SWreadattr(swathID, name, fillval);
9812 : }
9813 : else
9814 : {
9815 0 : HEpush(DFE_GENAPP, "SWgetfillvalue", __FILE__, __LINE__);
9816 0 : HEreport("Fieldname \"%s\" does not exist.\n", fieldname);
9817 : }
9818 :
9819 : }
9820 0 : return (status);
9821 : }
9822 :
9823 :
9824 : /*----------------------------------------------------------------------------|
9825 : | BEGIN_PROLOG |
9826 : | |
9827 : | FUNCTION: SWdetach |
9828 : | |
9829 : | DESCRIPTION: Detaches swath structure and performs housekeeping |
9830 : | |
9831 : | |
9832 : | Return Value Type Units Description |
9833 : | ============ ====== ========= ===================================== |
9834 : | status intn return status (0) SUCCEED, (-1) FAIL |
9835 : | |
9836 : | INPUTS: |
9837 : | swathID int32 swath structure ID |
9838 : | |
9839 : | |
9840 : | OUTPUTS: |
9841 : | None |
9842 : | |
9843 : | NOTES: |
9844 : | |
9845 : | |
9846 : | Date Programmer Description |
9847 : | ====== ============ ================================================= |
9848 : | Jun 96 Joel Gales Original Programmer |
9849 : | Aug 96 Joel Gales Cleanup Region External Structure |
9850 : | Sep 96 Joel Gales Setup dim names for SDsetdimnane in dimbuf1 rather |
9851 : | than utlstr |
9852 : | Nov 96 Joel Gales Call SWchkgdid to check for proper swath ID |
9853 : | Dec 96 Joel Gales Add multiple vertical subsetting garbage collection |
9854 : | |
9855 : | END_PROLOG |
9856 : -----------------------------------------------------------------------------*/
9857 : intn
9858 0 : SWdetach(int32 swathID)
9859 :
9860 : {
9861 : intn i; /* Loop index */
9862 : intn j; /* Loop index */
9863 : intn k; /* Loop index */
9864 0 : intn status = 0; /* routine return status variable */
9865 0 : intn statusFill = 0; /* return status from SWgetfillvalue */
9866 :
9867 : uint8 *buf; /* Buffer for blank (initial) 1D records */
9868 :
9869 : int32 vdataID; /* Vdata ID */
9870 : int32 *namelen; /* Pointer to name string length array */
9871 : int32 *dimlen; /* Pointer to dim string length array */
9872 : int32 slen1[3]; /* String length array 1 */
9873 : int32 slen2[3]; /* String length array 2 */
9874 : int32 nflds; /* Number of fields */
9875 : int32 match[5]; /* Merged field match array */
9876 : int32 cmbfldcnt; /* Number of fields combined */
9877 : int32 sdid; /* SDS ID */
9878 : int32 vgid; /* Vgroup ID */
9879 : int32 dims[3]; /* Dimension array */
9880 : int32 *offset; /* Pointer to merged field offset array */
9881 : int32 *indvdims; /* Pointer to merged field size array */
9882 : int32 sdInterfaceID; /* SDS interface ID */
9883 : int32 sID; /* Swath ID - offset */
9884 : int32 nflds0; /* Number of fields */
9885 : int32 *namelen0; /* Pointer to name string length array */
9886 : int32 rank; /* Rank of merged field */
9887 : int32 truerank; /* True rank of merged field */
9888 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
9889 : int32 dum; /* Dummy variable */
9890 :
9891 : char *nambuf; /* Pointer to name buffer */
9892 : char **nameptr; /* Pointer to name string pointer array */
9893 : char **dimptr; /* Pointer to dim string pointer array */
9894 : char **nameptr0; /* Pointer to name string pointer array */
9895 : char *ptr1[3]; /* String pointer array */
9896 : char *ptr2[3]; /* String pointer array */
9897 : char dimbuf1[128]; /* Dimension buffer 1 */
9898 : char dimbuf2[128]; /* Dimension buffer 2 */
9899 : char swathname[VGNAMELENMAX + 1]; /* Swath name */
9900 : char *utlbuf; /* Utility buffer */
9901 : char fillval[32];/* Fill value buffer */
9902 :
9903 : /* Check for proper swath ID and get SD interface ID */
9904 : /* ------------------------------------------------- */
9905 0 : status = SWchkswid(swathID, "SWdetach", &dum, &sdInterfaceID, &dum);
9906 :
9907 0 : if (status == 0)
9908 : {
9909 : /* Subtract off swath ID offset and get swath name */
9910 : /* ----------------------------------------------- */
9911 0 : sID = swathID % idOffset;
9912 0 : Vgetname(SWXSwath[sID].IDTable, swathname);
9913 :
9914 :
9915 : /* Create 1D "orphaned" fields */
9916 : /* --------------------------- */
9917 0 : i = 0;
9918 :
9919 : /* Find "active" entries in 1d combination array */
9920 : /* --------------------------------------------- */
9921 0 : while (SWX1dcomb[3 * i] != 0)
9922 : {
9923 : /* For fields defined within swath... */
9924 : /* ---------------------------------- */
9925 0 : if (SWX1dcomb[3 * i + 1] == SWXSwath[sID].IDTable)
9926 : {
9927 : /* Get dimension size and vdata ID */
9928 : /* ------------------------------- */
9929 0 : dims[0] = abs(SWX1dcomb[3 * i]);
9930 0 : vdataID = SWX1dcomb[3 * i + 2];
9931 :
9932 : /* Get fieldname (= vdata name) */
9933 : /* ---------------------------- */
9934 0 : nambuf = (char *) calloc(VSNAMELENMAX + 1, 1);
9935 0 : if(nambuf == NULL)
9936 : {
9937 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
9938 0 : return(-1);
9939 : }
9940 :
9941 0 : VSgetname(vdataID, nambuf);
9942 :
9943 : /* Set field within vdata */
9944 : /* ---------------------- */
9945 0 : VSsetfields(vdataID, nambuf);
9946 :
9947 : /* Write (blank) records */
9948 : /* --------------------- */
9949 0 : buf = (uint8 *) calloc(VSsizeof(vdataID, nambuf), dims[0]);
9950 0 : if(buf == NULL)
9951 : {
9952 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
9953 0 : free(nambuf);
9954 0 : return(-1);
9955 : }
9956 0 : VSwrite(vdataID, buf, dims[0], FULL_INTERLACE);
9957 :
9958 0 : free(buf);
9959 0 : free(nambuf);
9960 :
9961 : /* Detach Vdata */
9962 : /* ------------ */
9963 0 : VSdetach(vdataID);
9964 : }
9965 0 : i++;
9966 : }
9967 :
9968 :
9969 : /* SDS combined fields */
9970 : /* ------------------- */
9971 0 : if (strlen(SWXSDname) == 0)
9972 : {
9973 0 : nflds = 0;
9974 :
9975 : /* Allocate "dummy" arrays so free() doesn't bomb later */
9976 : /* ---------------------------------------------------- */
9977 0 : nameptr = (char **) calloc(1, sizeof(char *));
9978 0 : if(nameptr == NULL)
9979 : {
9980 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
9981 0 : return(-1);
9982 : }
9983 0 : namelen = (int32 *) calloc(1, sizeof(int32));
9984 0 : if(namelen == NULL)
9985 : {
9986 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
9987 0 : free(nameptr);
9988 0 : return(-1);
9989 : }
9990 0 : nameptr0 = (char **) calloc(1, sizeof(char *));
9991 0 : if(nameptr0 == NULL)
9992 : {
9993 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
9994 0 : free(nameptr);
9995 0 : free(namelen);
9996 0 : return(-1);
9997 : }
9998 0 : namelen0 = (int32 *) calloc(1, sizeof(int32));
9999 0 : if(namelen0 == NULL)
10000 : {
10001 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10002 0 : free(nameptr);
10003 0 : free(namelen);
10004 0 : free(nameptr0);
10005 0 : return(-1);
10006 : }
10007 0 : dimptr = (char **) calloc(1, sizeof(char *));
10008 0 : if(dimptr == NULL)
10009 : {
10010 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10011 0 : free(nameptr);
10012 0 : free(namelen);
10013 0 : free(nameptr0);
10014 0 : free(namelen0);
10015 0 : return(-1);
10016 : }
10017 0 : dimlen = (int32 *) calloc(1, sizeof(int32));
10018 0 : if(dimlen == NULL)
10019 : {
10020 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10021 0 : free(nameptr);
10022 0 : free(namelen);
10023 0 : free(nameptr0);
10024 0 : free(namelen0);
10025 0 : free(dimptr);
10026 0 : return(-1);
10027 : }
10028 0 : offset = (int32 *) calloc(1, sizeof(int32));
10029 0 : if(offset == NULL)
10030 : {
10031 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10032 0 : free(nameptr);
10033 0 : free(namelen);
10034 0 : free(nameptr0);
10035 0 : free(namelen0);
10036 0 : free(dimptr);
10037 0 : free(dimlen);
10038 0 : return(-1);
10039 : }
10040 0 : indvdims = (int32 *) calloc(1, sizeof(int32));
10041 0 : if(indvdims == NULL)
10042 : {
10043 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10044 0 : free(nameptr);
10045 0 : free(namelen);
10046 0 : free(nameptr0);
10047 0 : free(namelen0);
10048 0 : free(dimptr);
10049 0 : free(dimlen);
10050 0 : free(offset);
10051 0 : return(-1);
10052 : }
10053 : }
10054 : else
10055 : {
10056 : /*
10057 : * "Trim Off" trailing "," and ";" in SWXSDname & SWXSDdims
10058 : * respectively
10059 : */
10060 0 : SWXSDname[strlen(SWXSDname) - 1] = 0;
10061 0 : SWXSDdims[strlen(SWXSDdims) - 1] = 0;
10062 :
10063 :
10064 : /* Get number of fields from SWXSDname string */
10065 : /* ------------------------------------------ */
10066 0 : nflds = EHparsestr(SWXSDname, ',', NULL, NULL);
10067 :
10068 :
10069 : /* Allocate space for various dynamic arrays */
10070 : /* ----------------------------------------- */
10071 0 : nameptr = (char **) calloc(nflds, sizeof(char *));
10072 0 : if(nameptr == NULL)
10073 : {
10074 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10075 0 : return(-1);
10076 : }
10077 0 : namelen = (int32 *) calloc(nflds, sizeof(int32));
10078 0 : if(namelen == NULL)
10079 : {
10080 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10081 0 : free(nameptr);
10082 0 : return(-1);
10083 : }
10084 0 : nameptr0 = (char **) calloc(nflds, sizeof(char *));
10085 0 : if(nameptr0 == NULL)
10086 : {
10087 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10088 0 : free(nameptr);
10089 0 : free(namelen);
10090 0 : return(-1);
10091 : }
10092 0 : namelen0 = (int32 *) calloc(nflds, sizeof(int32));
10093 0 : if(namelen0 == NULL)
10094 : {
10095 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10096 0 : free(nameptr);
10097 0 : free(namelen);
10098 0 : free(nameptr0);
10099 0 : return(-1);
10100 : }
10101 0 : dimptr = (char **) calloc(nflds, sizeof(char *));
10102 0 : if(dimptr == NULL)
10103 : {
10104 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10105 0 : free(nameptr);
10106 0 : free(namelen);
10107 0 : free(nameptr0);
10108 0 : free(namelen0);
10109 0 : return(-1);
10110 : }
10111 0 : dimlen = (int32 *) calloc(nflds, sizeof(int32));
10112 0 : if(dimlen == NULL)
10113 : {
10114 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10115 0 : free(nameptr);
10116 0 : free(namelen);
10117 0 : free(nameptr0);
10118 0 : free(namelen0);
10119 0 : free(dimptr);
10120 0 : return(-1);
10121 : }
10122 0 : offset = (int32 *) calloc(nflds, sizeof(int32));
10123 0 : if(offset == NULL)
10124 : {
10125 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10126 0 : free(nameptr);
10127 0 : free(namelen);
10128 0 : free(nameptr0);
10129 0 : free(namelen0);
10130 0 : free(dimptr);
10131 0 : free(dimlen);
10132 0 : return(-1);
10133 : }
10134 0 : indvdims = (int32 *) calloc(nflds, sizeof(int32));
10135 0 : if(indvdims == NULL)
10136 : {
10137 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10138 0 : free(nameptr);
10139 0 : free(namelen);
10140 0 : free(nameptr0);
10141 0 : free(namelen0);
10142 0 : free(dimptr);
10143 0 : free(dimlen);
10144 0 : free(offset);
10145 0 : return(-1);
10146 : }
10147 :
10148 :
10149 : /* Parse SWXSDname and SWXSDdims strings */
10150 : /* ------------------------------------- */
10151 0 : nflds = EHparsestr(SWXSDname, ',', nameptr, namelen);
10152 0 : nflds = EHparsestr(SWXSDdims, ';', dimptr, dimlen);
10153 : }
10154 :
10155 :
10156 : /* Loop through all the fields */
10157 : /* --------------------------- */
10158 0 : for (i = 0; i < nflds; i++)
10159 : {
10160 : /* If active entry and field is within swath to be detached ... */
10161 : /* ------------------------------------------------------------ */
10162 0 : if (SWXSDcomb[5 * i] != 0 &&
10163 0 : SWXSDcomb[5 * i + 3] == SWXSwath[sID].IDTable)
10164 : {
10165 0 : nambuf = (char *) calloc(strlen(SWXSDname) + 1, 1);
10166 0 : if(nambuf == NULL)
10167 : {
10168 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10169 0 : return(-1);
10170 : }
10171 0 : utlbuf = (char *) calloc(2 * strlen(SWXSDname) + 7, 1);
10172 0 : if(utlbuf == NULL)
10173 : {
10174 0 : HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__);
10175 0 : free(nambuf);
10176 0 : return(-1);
10177 : }
10178 : /* Zero out dimbuf1 */
10179 : /* ---------------- */
10180 0 : for (k = 0; k < (intn)sizeof(dimbuf1); k++)
10181 : {
10182 0 : dimbuf1[k] = 0;
10183 : }
10184 :
10185 :
10186 : /* Load array to match, name & parse dims */
10187 : /* -------------------------------------- */
10188 0 : memcpy(match, &SWXSDcomb[5 * i], 20);
10189 0 : memcpy(nambuf, nameptr[i], namelen[i]);
10190 :
10191 0 : memcpy(dimbuf1, dimptr[i], dimlen[i]);
10192 0 : dum = EHparsestr(dimbuf1, ',', ptr1, slen1);
10193 :
10194 :
10195 : /* Separate combined (first) dimension from others */
10196 : /* ----------------------------------------------- */
10197 0 : dimbuf1[slen1[0]] = 0;
10198 :
10199 0 : offset[0] = 0;
10200 0 : indvdims[0] = abs(match[0]);
10201 :
10202 : /*
10203 : * Loop through remaining fields to check for matches with
10204 : * current one
10205 : */
10206 0 : for (j = i + 1, cmbfldcnt = 0; j < nflds; j++)
10207 : {
10208 0 : if (SWXSDcomb[5 * j] != 0)
10209 : {
10210 : /* Zero out dimbuf2 */
10211 : /* ---------------- */
10212 0 : for (k = 0; k < (intn)sizeof(dimbuf2); k++)
10213 : {
10214 0 : dimbuf2[k] = 0;
10215 : }
10216 :
10217 : /*
10218 : * Parse the dimensions and separate first for this
10219 : * entry
10220 : */
10221 0 : memcpy(dimbuf2, dimptr[j], dimlen[j]);
10222 0 : dum = EHparsestr(dimbuf2, ',', ptr2, slen2);
10223 0 : dimbuf2[slen2[0]] = 0;
10224 :
10225 :
10226 : /*
10227 : * If 2nd & 3rd dimension values and names (1st and
10228 : * 2nd for rank=2 array), swath ID, and numbertype
10229 : * are equal, then these fields can be combined.
10230 : */
10231 0 : if (match[1] == SWXSDcomb[5 * j + 1] &&
10232 0 : match[2] == SWXSDcomb[5 * j + 2] &&
10233 0 : match[3] == SWXSDcomb[5 * j + 3] &&
10234 0 : match[4] == SWXSDcomb[5 * j + 4] &&
10235 0 : strcmp(dimbuf1 + slen1[0] + 1,
10236 0 : dimbuf2 + slen2[0] + 1) == 0)
10237 : {
10238 : /* Add to combined dimension size */
10239 : /* ------------------------------ */
10240 0 : match[0] += SWXSDcomb[5 * j];
10241 :
10242 : /* Concatenate name */
10243 : /* ---------------- */
10244 0 : strcat(nambuf, ",");
10245 0 : memcpy(nambuf + strlen(nambuf),
10246 0 : nameptr[j], namelen[j]);
10247 :
10248 : /*
10249 : * Increment number of merged fields, store
10250 : * individual dims and dim offsets
10251 : */
10252 0 : cmbfldcnt++;
10253 0 : indvdims[cmbfldcnt] = abs(SWXSDcomb[5 * j]);
10254 0 : offset[cmbfldcnt] = offset[cmbfldcnt - 1] +
10255 0 : indvdims[cmbfldcnt - 1];
10256 :
10257 : /* Delete this field from combination list */
10258 : /* --------------------------------------- */
10259 0 : SWXSDcomb[5 * j] = 0;
10260 : }
10261 : }
10262 : }
10263 :
10264 :
10265 : /* Create SDS */
10266 : /* ---------- */
10267 :
10268 : /* Parse names string */
10269 : /* ------------------ */
10270 0 : nflds0 = EHparsestr(nambuf, ',', nameptr0, namelen0);
10271 :
10272 0 : if (abs(match[0]) == 1)
10273 : {
10274 : /* Two Dimensional Array (no merging has occurred) */
10275 : /* ---------------------------------------------- */
10276 0 : dims[0] = abs(match[1]);
10277 0 : dims[1] = abs(match[2]);
10278 :
10279 : /* Create SDS */
10280 : /* ---------- */
10281 0 : rank = 2;
10282 0 : sdid = SDcreate(sdInterfaceID, nambuf,
10283 0 : SWXSDcomb[5 * i + 4], 2, dims);
10284 : }
10285 : else
10286 : {
10287 : /* Three Dimensional Array */
10288 : /* ----------------------- */
10289 0 : dims[0] = abs(match[0]);
10290 0 : dims[1] = abs(match[1]);
10291 0 : dims[2] = abs(match[2]);
10292 :
10293 0 : rank = 3;
10294 :
10295 : /*
10296 : * If merged fields then form string consisting of
10297 : * "MRGFLD_" + 1st field in merge + ":" + entire merged
10298 : * field list and store in utlbuf. Then write to
10299 : * MergedField metadata section
10300 : */
10301 0 : if (cmbfldcnt > 0)
10302 : {
10303 0 : strcpy(utlbuf, "MRGFLD_");
10304 0 : memcpy(utlbuf + 7, nameptr0[0], namelen0[0]);
10305 0 : utlbuf[7 + namelen0[0]] = 0;
10306 0 : strcat(utlbuf, ":");
10307 0 : strcat(utlbuf, nambuf);
10308 :
10309 0 : status = EHinsertmeta(sdInterfaceID, swathname, "s",
10310 : 6L, utlbuf, NULL);
10311 : }
10312 : else
10313 : {
10314 : /*
10315 : * If not merged field then store field name in
10316 : * utlbuf
10317 : */
10318 0 : strcpy(utlbuf, nambuf);
10319 : }
10320 :
10321 : /* Create SDS */
10322 : /* ---------- */
10323 0 : sdid = SDcreate(sdInterfaceID, utlbuf,
10324 0 : SWXSDcomb[5 * i + 4], 3, dims);
10325 :
10326 :
10327 : /*
10328 : * If merged field then store dimensions and offsets as
10329 : * SD attributes
10330 : */
10331 0 : if (cmbfldcnt > 0)
10332 : {
10333 0 : SDsetattr(sdid, "Field Dims", DFNT_INT32,
10334 : cmbfldcnt + 1, (VOIDP) indvdims);
10335 :
10336 0 : SDsetattr(sdid, "Field Offsets", DFNT_INT32,
10337 : cmbfldcnt + 1, (VOIDP) offset);
10338 : }
10339 : }
10340 :
10341 :
10342 :
10343 : /* Register Dimensions in SDS */
10344 : /* -------------------------- */
10345 0 : for (k = 0; k < rank; k++)
10346 : {
10347 0 : if (rank == 2)
10348 : {
10349 : /* Copy k+1th dimension into dimbuf2 if rank = 2 */
10350 : /* --------------------------------------------- */
10351 0 : memcpy(dimbuf2, ptr1[k + 1], slen1[k + 1]);
10352 0 : dimbuf2[slen1[k + 1]] = 0;
10353 : }
10354 : else
10355 : {
10356 : /* Copy kth dimension into dimbuf2 if rank > 2 */
10357 : /* ------------------------------------------- */
10358 0 : memcpy(dimbuf2, ptr1[k], slen1[k]);
10359 0 : dimbuf2[slen1[k]] = 0;
10360 : }
10361 :
10362 : /*
10363 : * If first dimension and merged field then generate
10364 : * dimension name consisting of "MRGDIM:" + swathname +
10365 : * dimension size
10366 : */
10367 0 : if (k == 0 && cmbfldcnt > 0)
10368 : {
10369 0 : snprintf(dimbuf2, sizeof(dimbuf2), "%s%s_%ld", "MRGDIM:",
10370 0 : swathname, (long)dims[0]);
10371 : }
10372 : else
10373 : {
10374 : /* Otherwise concatenate swathname to dim name */
10375 : /* ------------------------------------------- */
10376 0 : strcat(dimbuf2, ":");
10377 0 : strcat(dimbuf2, swathname);
10378 : }
10379 :
10380 : /* Register dimensions using "SDsetdimname" */
10381 : /* ---------------------------------------- */
10382 0 : SDsetdimname(SDgetdimid(sdid, k), (char *) dimbuf2);
10383 : }
10384 :
10385 :
10386 :
10387 : /* Write Fill Value */
10388 : /* ---------------- */
10389 0 : for (k = 0; k < nflds0; k++)
10390 : {
10391 : /* Check if fill values has been set */
10392 : /* --------------------------------- */
10393 0 : memcpy(utlbuf, nameptr0[k], namelen0[k]);
10394 0 : utlbuf[namelen[k]] = 0;
10395 0 : statusFill = SWgetfillvalue(swathID, utlbuf, fillval);
10396 :
10397 0 : if (statusFill == 0)
10398 : {
10399 : /*
10400 : * If merged field then fill value must be stored
10401 : * manually using EHfillfld
10402 : */
10403 0 : if (cmbfldcnt > 0)
10404 : {
10405 0 : dims[0] = indvdims[k];
10406 0 : truerank = (dims[0] == 1) ? 2 : 3;
10407 0 : EHfillfld(sdid, rank, truerank,
10408 0 : DFKNTsize(match[4]), offset[k],
10409 : dims, fillval);
10410 : }
10411 : /*
10412 : * If single field then just use the HDF set fill
10413 : * function
10414 : */
10415 : else
10416 : {
10417 0 : status = SDsetfillvalue(sdid, fillval);
10418 : }
10419 : }
10420 : }
10421 :
10422 :
10423 : /*
10424 : * Insert SDS within the appropriate Vgroup (geo or data) and
10425 : * "detach" newly-created SDS
10426 : */
10427 0 : vgid = (match[0] < 0)
10428 : ? SWXSwath[sID].VIDTable[0]
10429 0 : : SWXSwath[sID].VIDTable[1];
10430 :
10431 0 : Vaddtagref(vgid, DFTAG_NDG, SDidtoref(sdid));
10432 0 : SDendaccess(sdid);
10433 :
10434 0 : free(nambuf);
10435 0 : free(utlbuf);
10436 : }
10437 : }
10438 :
10439 :
10440 :
10441 : /* "Contract" 1dcomb array */
10442 : /* ----------------------- */
10443 0 : i = 0;
10444 0 : while (SWX1dcomb[3 * i] != 0)
10445 : {
10446 0 : if (SWX1dcomb[3 * i + 1] == SWXSwath[sID].IDTable)
10447 : {
10448 0 : memcpy(&SWX1dcomb[3 * i],
10449 0 : &SWX1dcomb[3 * (i + 1)],
10450 0 : (512 - i - 1) * 3 * 4);
10451 : }
10452 : else
10453 0 : i++;
10454 : }
10455 :
10456 :
10457 : /* "Contract" SDcomb array */
10458 : /* ----------------------- */
10459 0 : for (i = 0; i < nflds; i++)
10460 : {
10461 0 : if (SWXSDcomb[5 * i + 3] == SWXSwath[sID].IDTable)
10462 : {
10463 0 : if (i == (nflds - 1))
10464 : {
10465 0 : SWXSDcomb[5 * i] = 0;
10466 0 : *(nameptr[i] - (nflds != 1)) = 0;
10467 0 : *(dimptr[i] - (nflds != 1)) = 0;
10468 : }
10469 : else
10470 : {
10471 0 : memmove(&SWXSDcomb[5 * i],
10472 0 : &SWXSDcomb[5 * (i + 1)],
10473 0 : (512 - i - 1) * 5 * 4);
10474 :
10475 0 : memmove(nameptr[i],
10476 0 : nameptr[i + 1],
10477 0 : nameptr[0] + 2048 - nameptr[i + 1] - 1);
10478 :
10479 0 : memmove(dimptr[i],
10480 0 : dimptr[i + 1],
10481 0 : dimptr[0] + 2048 * 2 - dimptr[i + 1] - 1);
10482 : }
10483 :
10484 0 : i--;
10485 0 : nflds = EHparsestr(SWXSDname, ',', nameptr, namelen);
10486 0 : nflds = EHparsestr(SWXSDdims, ';', dimptr, dimlen);
10487 : }
10488 : }
10489 :
10490 :
10491 : /* Replace trailing delimiters on SWXSDname & SWXSDdims */
10492 : /* ---------------------------------------------------- */
10493 0 : if (nflds != 0)
10494 : {
10495 0 : strcat(SWXSDname, ",");
10496 0 : strcat(SWXSDdims, ";");
10497 : }
10498 :
10499 :
10500 :
10501 : /* Free up a bunch of dynamically allocated arrays */
10502 : /* ----------------------------------------------- */
10503 0 : free(nameptr);
10504 0 : free(namelen);
10505 0 : free(nameptr0);
10506 0 : free(namelen0);
10507 0 : free(dimptr);
10508 0 : free(dimlen);
10509 0 : free(offset);
10510 0 : free(indvdims);
10511 :
10512 :
10513 :
10514 :
10515 : /* "Detach" from previously attached SDSs */
10516 : /* -------------------------------------- */
10517 0 : for (k = 0; k < SWXSwath[sID].nSDS; k++)
10518 : {
10519 0 : SDendaccess(SWXSwath[sID].sdsID[k]);
10520 : }
10521 0 : free(SWXSwath[sID].sdsID);
10522 0 : SWXSwath[sID].sdsID = 0;
10523 0 : SWXSwath[sID].nSDS = 0;
10524 :
10525 :
10526 : /* Detach Swath Vgroups */
10527 : /* -------------------- */
10528 0 : Vdetach(SWXSwath[sID].VIDTable[0]);
10529 0 : Vdetach(SWXSwath[sID].VIDTable[1]);
10530 0 : Vdetach(SWXSwath[sID].VIDTable[2]);
10531 0 : Vdetach(SWXSwath[sID].IDTable);
10532 :
10533 :
10534 : /* Delete entries from External Arrays */
10535 : /* ----------------------------------- */
10536 0 : SWXSwath[sID].active = 0;
10537 0 : SWXSwath[sID].VIDTable[0] = 0;
10538 0 : SWXSwath[sID].VIDTable[1] = 0;
10539 0 : SWXSwath[sID].VIDTable[2] = 0;
10540 0 : SWXSwath[sID].IDTable = 0;
10541 0 : SWXSwath[sID].fid = 0;
10542 :
10543 :
10544 : /* Free Region Pointers */
10545 : /* -------------------- */
10546 0 : for (k = 0; k < NSWATHREGN; k++)
10547 : {
10548 0 : if (SWXRegion[k] != 0 &&
10549 0 : SWXRegion[k]->swathID == swathID)
10550 : {
10551 0 : for (i = 0; i < 8; i++)
10552 : {
10553 0 : if (SWXRegion[k]->DimNamePtr[i] != 0)
10554 : {
10555 0 : free(SWXRegion[k]->DimNamePtr[i]);
10556 : }
10557 : }
10558 :
10559 0 : free(SWXRegion[k]);
10560 0 : SWXRegion[k] = 0;
10561 : }
10562 : }
10563 :
10564 : }
10565 0 : return (status);
10566 : }
10567 :
10568 : /*----------------------------------------------------------------------------|
10569 : | BEGIN_PROLOG |
10570 : | |
10571 : | FUNCTION: SWclose |
10572 : | |
10573 : | DESCRIPTION: Closes HDF-EOS file |
10574 : | |
10575 : | |
10576 : | Return Value Type Units Description |
10577 : | ============ ====== ========= ===================================== |
10578 : | status intn return status (0) SUCCEED, (-1) FAIL |
10579 : | |
10580 : | INPUTS: |
10581 : | fid int32 File ID |
10582 : | |
10583 : | OUTPUTS: |
10584 : | None |
10585 : | |
10586 : | NOTES: |
10587 : | |
10588 : | |
10589 : | Date Programmer Description |
10590 : | ====== ============ ================================================= |
10591 : | Jun 96 Joel Gales Original Programmer |
10592 : | |
10593 : | END_PROLOG |
10594 : -----------------------------------------------------------------------------*/
10595 : intn
10596 4 : SWclose(int32 fid)
10597 :
10598 : {
10599 4 : intn status = 0; /* routine return status variable */
10600 :
10601 : /* Call EHclose to perform file close */
10602 : /* ---------------------------------- */
10603 4 : status = EHclose(fid);
10604 :
10605 4 : return (status);
10606 : }
10607 :
10608 : /*----------------------------------------------------------------------------|
10609 : | BEGIN_PROLOG |
10610 : | |
10611 : | FUNCTION: SWupdatescene |
10612 : | |
10613 : | DESCRIPTION: Updates the StartRegion and StopRegion values |
10614 : | for a specified region. |
10615 : | |
10616 : | |
10617 : | Return Value Type Units Description |
10618 : | ============ ====== ========= ===================================== |
10619 : | status intn return status (0) SUCCEED, (-1) FAIL |
10620 : | |
10621 : | INPUTS: |
10622 : | swathID int32 Swath structure ID |
10623 : | regionID int32 Region ID |
10624 : | |
10625 : | NOTES: |
10626 : | |
10627 : | Date Programmer Description |
10628 : | ====== ============ ================================================= |
10629 : | Nov 98 Xinmin Hua Original developing |
10630 : | Aug 99 Abe Taaheri Added code to exclude regions that have the same |
10631 : | start and stop. |
10632 : | |
10633 : | END_PROLOG |
10634 : -----------------------------------------------------------------------------*/
10635 : intn
10636 0 : SWupdatescene(int32 swathID, int32 regionID)
10637 : {
10638 : intn k; /* Loop index */
10639 : int32 status; /* routine return status variable */
10640 :
10641 : int32 fid; /* HDF-EOS file ID */
10642 : int32 sdInterfaceID; /* HDF SDS interface ID */
10643 : int32 swVgrpID; /* Swath Vgroup ID */
10644 :
10645 : int32 startReg; /* Indexed start region */
10646 : int32 stopReg; /* Indexed stop region */
10647 : int32 l_index[MAXNREGIONS]; /* to store indices when stop and
10648 : start are different */
10649 :
10650 : int32 ind; /* l_index */
10651 : int32 tempnRegions; /* temp number of regions */
10652 :
10653 0 : memset(l_index, 0, sizeof(int32) * MAXNREGIONS);
10654 :
10655 : /* Check for valid swath ID */
10656 : /* ------------------------ */
10657 0 : status = SWchkswid(swathID, "SWupdatescene", &fid, &sdInterfaceID,
10658 : &swVgrpID);
10659 :
10660 :
10661 : /* Check for valid region ID */
10662 : /* ------------------------- */
10663 0 : if (status == 0)
10664 : {
10665 0 : if (regionID < 0 || regionID >= NSWATHREGN)
10666 : {
10667 0 : status = -1;
10668 0 : HEpush(DFE_RANGE, "SWupdatescene", __FILE__, __LINE__);
10669 0 : HEreport("Invalid Region id: %d.\n", regionID);
10670 : }
10671 : }
10672 :
10673 : /* Check for active region ID */
10674 : /* -------------------------- */
10675 0 : if (status == 0)
10676 : {
10677 0 : if (SWXRegion[regionID] == 0)
10678 : {
10679 0 : status = -1;
10680 0 : HEpush(DFE_GENAPP, "SWupdatescene", __FILE__, __LINE__);
10681 0 : HEreport("Inactive Region ID: %d.\n", regionID);
10682 : }
10683 : }
10684 :
10685 0 : if (status == 0)
10686 : {
10687 0 : tempnRegions = SWXRegion[regionID]->nRegions;
10688 0 : ind =0;
10689 :
10690 0 : for (k = 0; k < SWXRegion[regionID]->nRegions; k++)
10691 : {
10692 0 : startReg = SWXRegion[regionID]->StartRegion[k];
10693 0 : stopReg = SWXRegion[regionID]->StopRegion[k];
10694 0 : if(startReg == stopReg)
10695 : {
10696 : /* reduce number of regions by 1, if tempnRegions is 0 issue
10697 : error and break from loop*/
10698 0 : tempnRegions -= 1;
10699 :
10700 0 : if(tempnRegions == 0)
10701 : {
10702 : /* first free allocated memory for SWXRegion[regionID]
10703 : in the function SWdefboxregion and make regionID
10704 : inactive */
10705 0 : free(SWXRegion[regionID]);
10706 0 : SWXRegion[regionID] = 0;
10707 0 : status = -1;
10708 0 : HEpush(DFE_GENAPP, "SWupdatescene", __FILE__, __LINE__);
10709 0 : HEreport("Inactive Region ID: %d.\n", regionID);
10710 0 : break;
10711 : }
10712 : }
10713 : else
10714 : {
10715 : /* store l_index number of regions that have different start and
10716 : stop */
10717 0 : l_index[ind] = k;
10718 0 : ind += 1;
10719 : }
10720 : }
10721 0 : if (status != 0)
10722 : {
10723 0 : return (status);
10724 : }
10725 : else
10726 : {
10727 0 : SWXRegion[regionID]->nRegions = tempnRegions;
10728 : }
10729 : /* keep starts and stops that are different in the structure */
10730 0 : for (k = 0; k < SWXRegion[regionID]->nRegions; k++)
10731 : {
10732 0 : SWXRegion[regionID]->StartRegion[k] =
10733 0 : SWXRegion[regionID]->StartRegion[l_index[k]];
10734 0 : SWXRegion[regionID]->StopRegion[k] =
10735 0 : SWXRegion[regionID]->StopRegion[l_index[k]];
10736 : }
10737 :
10738 : }
10739 :
10740 :
10741 0 : if (status == 0)
10742 : {
10743 :
10744 0 : for (k = 0; k < SWXRegion[regionID]->nRegions; k++)
10745 : {
10746 :
10747 0 : startReg = SWXRegion[regionID]->StartRegion[k];
10748 0 : stopReg = SWXRegion[regionID]->StopRegion[k];
10749 :
10750 0 : if(startReg % 2 == 1) {
10751 :
10752 0 : SWXRegion[regionID]->StartRegion[k] = ++startReg;
10753 :
10754 : }
10755 0 : if(stopReg % 2 == 0) {
10756 :
10757 0 : SWXRegion[regionID]->StopRegion[k] = --stopReg;
10758 :
10759 : }
10760 :
10761 : }
10762 :
10763 : }
10764 :
10765 0 : return(status);
10766 :
10767 : }
10768 :
10769 : /*----------------------------------------------------------------------------|
10770 : | BEGIN_PROLOG |
10771 : | |
10772 : | FUNCTION: SWupdateidxmap |
10773 : | |
10774 : | DESCRIPTION: Updates the map l_index for a specified region. |
10775 : | |
10776 : | |
10777 : | Return Value Type Units Description |
10778 : | ============ ====== ========= ===================================== |
10779 : | nout int32 return Number of elements in output |
10780 : | l_index array if SUCCEED, (-1) FAIL |
10781 : | |
10782 : | INPUTS: |
10783 : | swathID int32 Swath structure ID |
10784 : | regionID int32 Region ID |
10785 : | l_indexin int32 array of l_index values |
10786 : | |
10787 : | OUTPUTS: |
10788 : | l_indexout int32 array of l_index values |
10789 : | indices int32 array of start and stop in region |
10790 : | |
10791 : | NOTES: |
10792 : | |
10793 : | |
10794 : | Date Programmer Description |
10795 : | ====== ============ ================================================= |
10796 : | Aug 97 Abe Taaheri Original Programmer |
10797 : | AUG 97 Abe Taaheri Add support for l_index mapping |
10798 : | Sep 99 DaW Add support for Floating Scene Subsetting Landsat 7 |
10799 : | |
10800 : | END_PROLOG |
10801 : -----------------------------------------------------------------------------*/
10802 : int32
10803 0 : SWupdateidxmap(int32 swathID, int32 regionID, int32 l_indexin[], int32 l_indexout[], int32 indicies[])
10804 : {
10805 : intn i; /* Loop index */
10806 : intn j; /* Loop index */
10807 : intn k; /* Loop index */
10808 : int32 status; /* routine return status variable */
10809 0 : int32 land_status = 3; /* routine return status variable */
10810 :
10811 : int32 fid; /* HDF-EOS file ID */
10812 : int32 sdInterfaceID; /* HDF SDS interface ID */
10813 : int32 swVgrpID; /* Swath Vgroup ID */
10814 :
10815 0 : int32 numtype = 0; /* Used for L7 float scene sub. */
10816 0 : int32 count = 0; /* Used for L7 float scene sub. */
10817 :
10818 0 : int32 startReg = 0; /* Indexed start region */
10819 0 : int32 stopReg = 0; /* Indexed stop region */
10820 0 : int32 nout=-1; /* Number of elements in output l_index array */
10821 0 : int32 indexoffset = 0;
10822 0 : uint8 scene_cnt = 0; /* Used for L7 float scene sub. */
10823 0 : uint8 detect_cnt = 0; /* Used to convert scan to scanline */
10824 0 : intn gtflag = 0;
10825 0 : intn ngtflag = 0;
10826 0 : int32 *buffer1 = (int32 *)NULL;
10827 0 : int32 *buffer2 = (int32 *)NULL;
10828 :
10829 : /* Check for valid swath ID */
10830 : /* ------------------------ */
10831 0 : status = SWchkswid(swathID, "SWupdateidxmap", &fid, &sdInterfaceID,
10832 : &swVgrpID);
10833 :
10834 :
10835 : /* Check for valid region ID */
10836 : /* ------------------------- */
10837 0 : if (status == 0)
10838 : {
10839 0 : if (regionID < 0 || regionID >= NSWATHREGN)
10840 : {
10841 0 : status = -1;
10842 0 : HEpush(DFE_RANGE, "SWupdateidxmap", __FILE__, __LINE__);
10843 0 : HEreport("Invalid Region id: %d.\n", regionID);
10844 : }
10845 : }
10846 :
10847 : /* Check for active region ID */
10848 : /* -------------------------- */
10849 0 : if (status == 0)
10850 : {
10851 0 : if (SWXRegion[regionID] == 0)
10852 : {
10853 0 : status = -1;
10854 0 : HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__);
10855 0 : HEreport("Inactive Region ID: %d.\n", regionID);
10856 : }
10857 : }
10858 :
10859 0 : if (status == 0)
10860 : {
10861 : /* Loop through all regions */
10862 : /* ------------------------ */
10863 0 : for (k = 0; k < SWXRegion[regionID]->nRegions; k++)
10864 : {
10865 :
10866 : /* fix overlap l_index mapping problem for Landsat 7 */
10867 :
10868 0 : startReg = SWXRegion[regionID]->StartRegion[k];
10869 0 : stopReg = SWXRegion[regionID]->StopRegion[k];
10870 :
10871 :
10872 0 : if(SWXRegion[regionID]->scanflag == 1)
10873 : {
10874 0 : indicies[0] = -1;
10875 0 : indicies[1] = -1;
10876 0 : j = 0;
10877 : /* This code checks for the attribute detector_count */
10878 : /* which is found in Landsat 7 files. It is used */
10879 : /* for some of the loops. */
10880 : /* ================================================= */
10881 0 : land_status = SWattrinfo(swathID, "scene_count", &numtype, &count);
10882 0 : if (land_status == 0)
10883 : {
10884 0 : land_status = SWreadattr(swathID, "scene_count", &scene_cnt);
10885 0 : land_status = SWreadattr(swathID, "detector_count", &detect_cnt);
10886 : }
10887 :
10888 :
10889 : /* calculate the offsets first */
10890 0 : buffer1 = (int32 *)calloc(74, sizeof(int32));
10891 0 : buffer2 = (int32 *)calloc(74, sizeof(int32));
10892 :
10893 0 : status = SWidxmapinfo(swathID,"GeoTrack",
10894 : "ScanLineTrack", (int32*)buffer1);
10895 0 : status = SWidxmapinfo(swathID,"UpperTrack",
10896 : "ScanLineTrack", (int32*)buffer2);
10897 :
10898 0 : indexoffset = buffer2[0] - buffer1[0];
10899 0 : free(buffer1);
10900 0 : free(buffer2);
10901 :
10902 0 : if(SWXRegion[regionID]->band8flag == -1)
10903 : {
10904 0 : for(i=0; i<scene_cnt;i++)
10905 : {
10906 0 : if(l_indexin[j] <= startReg && l_indexin[j+1] >= startReg)
10907 0 : if(indicies[0] == -1)
10908 0 : indicies[0] = j;
10909 0 : if(l_indexin[j] <= stopReg && l_indexin[j+1] >= stopReg)
10910 0 : indicies[1] = j + 1;
10911 0 : j = j + 2;
10912 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
10913 0 : i = scene_cnt;
10914 : }
10915 0 : if(indicies[0] == -1)
10916 : {
10917 0 : if(startReg <= l_indexin[0])
10918 0 : indicies[0] = 0;
10919 : }
10920 0 : if(indicies[0] == -1)
10921 : {
10922 0 : j = 0;
10923 0 : for(i=0; i<scene_cnt; i++)
10924 : {
10925 0 : if(l_indexin[j] <= startReg && l_indexin[j+1] >= startReg)
10926 0 : if(indicies[0] == -1)
10927 0 : indicies[0] = j;
10928 0 : j = j + 1;
10929 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
10930 0 : i = scene_cnt;
10931 : }
10932 : }
10933 0 : if(indicies[1] == -1)
10934 : {
10935 0 : j = 0;
10936 0 : for(i=0; i<scene_cnt; i++)
10937 : {
10938 0 : if(l_indexin[j] <= stopReg && l_indexin[j+1] >= stopReg)
10939 0 : if(indicies[1] == -1)
10940 0 : indicies[1] = j + 1;
10941 0 : j = j + 1;
10942 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
10943 0 : i = scene_cnt;
10944 : }
10945 : }
10946 0 : if(indicies[1] == -1)
10947 0 : if(stopReg > l_indexin[scene_cnt - 1])
10948 0 : indicies[1] = scene_cnt - 1;
10949 : }
10950 :
10951 : /* This section of code handles exceptions in Landsat 7 */
10952 : /* data. The Band 8 data - multiple files, data gaps */
10953 : /* ===================================================== */
10954 0 : if(SWXRegion[regionID]->band8flag == 1 ||
10955 0 : SWXRegion[regionID]->band8flag == 2 ||
10956 0 : SWXRegion[regionID]->band8flag == 3)
10957 : {
10958 0 : j = 0;
10959 0 : for(i=0; i<scene_cnt; i++)
10960 : {
10961 0 : j = j + 2;
10962 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
10963 : {
10964 0 : if(l_indexin[j] == 0)
10965 0 : gtflag = 1;
10966 : else
10967 0 : ngtflag = 1;
10968 0 : i = scene_cnt;
10969 : }
10970 : }
10971 0 : j = 0;
10972 0 : if(gtflag == 1)
10973 : {
10974 0 : for(i=0; i<scene_cnt; i++)
10975 : {
10976 0 : if( startReg >= (l_indexin[j] + indexoffset - detect_cnt) &&
10977 0 : startReg <= (l_indexin[j+1] + indexoffset - detect_cnt) )
10978 0 : if(indicies[0] == -1)
10979 0 : indicies[0] = j;
10980 0 : if( stopReg >= (l_indexin[j] + indexoffset - detect_cnt ) &&
10981 0 : stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) )
10982 0 : indicies[1] = j + 1;
10983 0 : j = j + 2;
10984 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
10985 0 : i = scene_cnt;
10986 : }
10987 0 : if(SWXRegion[regionID]->band8flag == 1)
10988 : {
10989 0 : if(indicies[1] == -1)
10990 0 : if(stopReg > (l_indexin[j - 1] + indexoffset - detect_cnt))
10991 0 : indicies[1] = j - 1;
10992 : }
10993 0 : if(SWXRegion[regionID]->band8flag == 2 ||
10994 0 : SWXRegion[regionID]->band8flag == 3)
10995 : {
10996 :
10997 0 : if(startReg >= (l_indexin[j - 1] + indexoffset - detect_cnt))
10998 : {
10999 0 : indicies[0] = -1;
11000 0 : indicies[1] = -1;
11001 : /* status = SWfieldinfo(swathID, "scan_no", &rank, dims2, &nt, dimlist);
11002 : buffer = (uint16 *)calloc(dims2[0], sizeof(uint16));
11003 : status = SWreadfield(swathID,"scan_no", NULL, NULL, NULL, buffer);
11004 : indexoffset = buffer[0] * detect_cnt;
11005 : free(buffer);
11006 : startReg = startReg - (indexoffset - detect_cnt);
11007 : stopReg = stopReg - (indexoffset - 1); */
11008 0 : j = 0;
11009 0 : for(i=0; i<scene_cnt; i++)
11010 : {
11011 0 : if( startReg >= (l_indexin[j] + indexoffset - detect_cnt) &&
11012 0 : startReg <= (l_indexin[j+1] + indexoffset - detect_cnt) )
11013 0 : if(indicies[0] == -1)
11014 0 : indicies[0] = j;
11015 0 : if( stopReg >= (l_indexin[j] + indexoffset - detect_cnt ) &&
11016 0 : stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) )
11017 0 : indicies[1] = j + 1;
11018 0 : j = j + 2;
11019 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
11020 0 : i = scene_cnt;
11021 : }
11022 : }
11023 :
11024 0 : if(indicies[0] == -1)
11025 : {
11026 0 : j = 0;
11027 0 : for(i=0; i<scene_cnt; i++)
11028 : {
11029 0 : if( startReg >= (l_indexin[j] + indexoffset - detect_cnt) &&
11030 0 : startReg <= (l_indexin[j+1] + indexoffset - detect_cnt) )
11031 0 : if(indicies[0] == -1)
11032 0 : indicies[0] = j;
11033 :
11034 0 : j = j + 2;
11035 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
11036 0 : i = scene_cnt;
11037 : }
11038 : }
11039 0 : if(indicies[1] == -1)
11040 0 : if(stopReg > (l_indexin[j - 1] + indexoffset - detect_cnt) )
11041 0 : indicies[1] = j - 1;
11042 : }
11043 0 : if(indicies[1] == -1)
11044 : {
11045 0 : j = 0;
11046 0 : for(i=0; i<scene_cnt; i++)
11047 : {
11048 0 : if( stopReg >= (l_indexin[j] + indexoffset - detect_cnt ) &&
11049 0 : stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) )
11050 0 : indicies[1] = j;
11051 0 : j = j + 2;
11052 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
11053 0 : i = scene_cnt;
11054 : }
11055 : }
11056 : }
11057 :
11058 0 : if(ngtflag == 1)
11059 : {
11060 0 : for(i=0; i<scene_cnt; i++)
11061 : {
11062 0 : if( startReg >= l_indexin[j] && startReg <= l_indexin[j+1])
11063 0 : if(indicies[0] == -1)
11064 0 : indicies[0] = j;
11065 0 : if( stopReg >= l_indexin[j] && stopReg <= l_indexin[j+1])
11066 0 : indicies[1] = j + 1;
11067 0 : j = j + 2;
11068 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
11069 0 : i = scene_cnt;
11070 : }
11071 0 : if(SWXRegion[regionID]->band8flag == 2)
11072 : {
11073 0 : if(startReg >= l_indexin[j] )
11074 : {
11075 0 : if(indicies[0] == -1)
11076 0 : indicies[0] = j;
11077 0 : if(indicies[1] == -1)
11078 0 : indicies[1] = j;
11079 : }
11080 0 : if(indicies[0] == -1)
11081 0 : if(startReg <= l_indexin[0])
11082 0 : indicies[0] = 0;
11083 0 : if(indicies[1] == -1)
11084 0 : if(stopReg > l_indexin[j])
11085 0 : indicies[1] = j;
11086 : }
11087 0 : if(indicies[0] == -1)
11088 : {
11089 0 : j = 0;
11090 0 : for(i=0; i<scene_cnt; i++)
11091 : {
11092 0 : if( startReg >= l_indexin[j] && startReg <= l_indexin[j+1])
11093 0 : indicies[0] = j;
11094 0 : j = j + 2;
11095 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
11096 0 : i = scene_cnt;
11097 : }
11098 : }
11099 0 : if(indicies[1] == -1)
11100 : {
11101 0 : j = 0;
11102 0 : for(i=0; i<scene_cnt; i++)
11103 : {
11104 0 : if( stopReg >= l_indexin[j] && stopReg <= l_indexin[j+1])
11105 0 : indicies[1] = j;
11106 0 : j = j + 2;
11107 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
11108 0 : i = scene_cnt;
11109 : }
11110 : }
11111 0 : if(indicies[1] == -1)
11112 : {
11113 0 : if(stopReg > l_indexin[j])
11114 0 : indicies[1] = j;
11115 : }
11116 : }
11117 0 : if(indicies[0] == -1)
11118 : {
11119 0 : if(startReg <= (l_indexin[0]+ indexoffset - detect_cnt) )
11120 0 : indicies[0] = 0;
11121 0 : if(indicies[1] == -1)
11122 0 : if(stopReg > (l_indexin[j] + indexoffset - detect_cnt))
11123 0 : indicies[1] = j;
11124 : }
11125 : }
11126 0 : if (indicies[1] == -1)
11127 : {
11128 0 : if(SWXRegion[regionID]->band8flag == 2 ||
11129 0 : SWXRegion[regionID]->band8flag == 3)
11130 : {
11131 0 : if(stopReg < (l_indexin[0] + indexoffset - detect_cnt))
11132 : {
11133 : /*status = SWfieldinfo(swathID, "scan_no", &rank, dims2, &nt, dimlist);
11134 : buffer = (uint16 *)calloc(dims2[0], sizeof(uint16));
11135 : status = SWreadfield(swathID,"scan_no", NULL, NULL, NULL, buffer);
11136 : indexoffset = buffer[0] * detect_cnt;
11137 : free(buffer);
11138 : startReg = startReg + (indexoffset - detect_cnt);
11139 : stopReg = stopReg + (indexoffset - 1); */
11140 0 : if(stopReg >= (l_indexin[scene_cnt - 1] + indexoffset - detect_cnt))
11141 : {
11142 0 : indicies[1] = scene_cnt - 1;
11143 : }
11144 : else
11145 : {
11146 0 : j = 0;
11147 0 : for(i=0;i<scene_cnt;i++)
11148 : {
11149 0 : if( stopReg >= (l_indexin[j] + indexoffset - detect_cnt ) &&
11150 0 : stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) )
11151 0 : indicies[1] = j;
11152 0 : j = j + 2;
11153 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
11154 0 : i = scene_cnt;
11155 : }
11156 : }
11157 : }
11158 :
11159 0 : if(startReg > (l_indexin[j - 1] + indexoffset - detect_cnt ))
11160 : {
11161 0 : indicies[0] = -1;
11162 0 : indicies[1] = -1;
11163 : /*status = SWfieldinfo(swathID, "scan_no", &rank, dims2, &nt, dimlist);
11164 : buffer = (uint16 *)calloc(dims2[0], sizeof(uint16));
11165 : status = SWreadfield(swathID,"scan_no", NULL, NULL, NULL, buffer);
11166 : indexoffset = buffer[0] * detect_cnt;
11167 : free(buffer);
11168 : startReg = startReg - (indexoffset - detect_cnt);
11169 : stopReg = stopReg - (indexoffset - 1);*/
11170 0 : j = 0;
11171 0 : for(i=0; i<scene_cnt; i++)
11172 : {
11173 0 : if( startReg >= (l_indexin[j] + indexoffset - detect_cnt) &&
11174 0 : startReg <= (l_indexin[j+1] + indexoffset - detect_cnt) )
11175 0 : if(indicies[0] == -1)
11176 0 : indicies[0] = j;
11177 0 : if( stopReg >= (l_indexin[j] + indexoffset - detect_cnt ) &&
11178 0 : stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) )
11179 0 : indicies[1] = j + 1;
11180 0 : j = j + 2;
11181 0 : if(l_indexin[j] == 0 || l_indexin[j+1] == 0)
11182 0 : i = scene_cnt;
11183 : }
11184 0 : if(indicies[0] == -1)
11185 0 : if(startReg < (l_indexin[0] + indexoffset - detect_cnt))
11186 0 : indicies[0] = 0;
11187 0 : if(indicies[1] == -1)
11188 0 : if(stopReg > (l_indexin[j - 1] + indexoffset - detect_cnt))
11189 0 : indicies[1] = j - 1;
11190 : }
11191 : }
11192 : }
11193 : } /* end of if for floating scene update */
11194 : else
11195 : {
11196 : /* If start of region is odd then increment */
11197 : /* ---------------------------------------- */
11198 0 : if (startReg % 2 == 1)
11199 : {
11200 0 : startReg++;
11201 : }
11202 :
11203 : /* If end of region is even then decrement */
11204 : /* --------------------------------------- */
11205 0 : if (stopReg % 2 == 0)
11206 : {
11207 0 : stopReg--;
11208 : }
11209 :
11210 0 : indicies[0]=startReg;
11211 0 : indicies[1]=stopReg;
11212 : }
11213 : }
11214 :
11215 0 : if (l_indexout != NULL)
11216 : {
11217 0 : if(SWXRegion[regionID]->scanflag == 1)
11218 : {
11219 0 : nout = (indicies[1] - indicies[0] + 1);
11220 0 : j = 0;
11221 0 : if (nout == 1)
11222 0 : l_indexout[0] = l_indexin[indicies[0]];
11223 0 : for(i=0; i<nout;i++)
11224 : {
11225 0 : l_indexout[i] = l_indexin[indicies[0] + i];
11226 : }
11227 : }
11228 : else
11229 : {
11230 : /* get new l_index values */
11231 : /* ==================== */
11232 0 : for(i = startReg; i <= stopReg ; i++)
11233 : {
11234 0 : l_indexout[i-startReg] = l_indexin[i];
11235 : }
11236 0 : nout = (stopReg - startReg) + 1;
11237 : }
11238 : }
11239 : else
11240 : {
11241 0 : nout = indicies[1] - indicies[0] + 1;
11242 : }
11243 : }
11244 :
11245 :
11246 0 : if(status == -1)
11247 : {
11248 0 : return(status);
11249 : }
11250 : else
11251 : {
11252 0 : return(nout);
11253 : }
11254 :
11255 : }
11256 :
11257 :
11258 :
11259 : /*----------------------------------------------------------------------------|
11260 : | BEGIN_PROLOG |
11261 : | |
11262 : | FUNCTION: SWgeomapinfo |
11263 : | |
11264 : | DESCRIPTION: Returns mapping information for dimension |
11265 : | |
11266 : | |
11267 : | Return Value Type Units Description |
11268 : | ============ ====== ========= ===================================== |
11269 : | status intn 2 for l_indexed mapping, 1 for regular |
11270 : | mapping, 0 if the dimension is not |
11271 : | and (-1) FAIL |
11272 : | |
11273 : | INPUTS: |
11274 : | swathID int32 swath structure id |
11275 : | geodim char geolocation dimension name |
11276 : | |
11277 : | OUTPUTS: |
11278 : | |
11279 : | NONE |
11280 : | |
11281 : | NOTES: |
11282 : | |
11283 : | |
11284 : | Date Programmer Description |
11285 : | ====== ============ ================================================= |
11286 : | Aug 97 Abe Taaheri Original Programmer |
11287 : | Sept 97 DaW Modified return value so errors can be trapped |
11288 : | |
11289 : | END_PROLOG |
11290 : -----------------------------------------------------------------------------*/
11291 : intn
11292 0 : SWgeomapinfo(int32 swathID, const char *geodim)
11293 :
11294 : {
11295 : intn status; /* routine return status variable */
11296 :
11297 : int32 fid; /* HDF-EOS file ID */
11298 : int32 sdInterfaceID; /* HDF SDS interface ID */
11299 : int32 swVgrpID; /* Swath root Vgroup ID */
11300 0 : int32 idOffset = SWIDOFFSET; /* Swath ID offset */
11301 :
11302 : char *metabufr; /* Pointer to structural metadata (SM) */
11303 : char *metabufi; /* Pointer to structural metadata (SM) */
11304 : char *metaptrsr[2];/* Pointers to begin and end of SM section */
11305 : char *metaptrsi[2];/* Pointers to begin and end of SM section */
11306 : char swathname[80]; /* Swath Name */
11307 : char *utlstrr; /* Utility string */
11308 : char *utlstri; /* Utility string */
11309 :
11310 :
11311 : /* Allocate space for utility string */
11312 : /* --------------------------------- */
11313 0 : utlstrr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
11314 0 : if(utlstrr == NULL)
11315 : {
11316 0 : HEpush(DFE_NOSPACE,"SWgeomapinfo", __FILE__, __LINE__);
11317 0 : return(-1);
11318 : }
11319 0 : utlstri = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char));
11320 0 : if(utlstri == NULL)
11321 : {
11322 0 : HEpush(DFE_NOSPACE,"SWgeomapinfo", __FILE__, __LINE__);
11323 0 : free(utlstrr);
11324 0 : return(-1);
11325 : }
11326 0 : status = -1;
11327 :
11328 : /* Check for valid swath id */
11329 0 : status = SWchkswid(swathID, "SWgeomapinfo", &fid, &sdInterfaceID, &swVgrpID);
11330 0 : if (status == 0)
11331 : {
11332 : /* Get swath name */
11333 0 : Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname);
11334 :
11335 : /* Get pointers to "DimensionMap" section within SM */
11336 0 : metabufr = EHmetagroup(sdInterfaceID, swathname, "s",
11337 : "DimensionMap", metaptrsr);
11338 :
11339 0 : if(metabufr == NULL)
11340 : {
11341 0 : free(utlstrr);
11342 0 : free(utlstri);
11343 0 : return(-1);
11344 : }
11345 : /* Search for mapping - GeoDim/DataDim (surrounded by quotes) */
11346 0 : snprintf(utlstrr, UTLSTR_MAX_SIZE, "%s%s%s", "\t\t\t\tGeoDimension=\"", geodim,
11347 : "\"\n\t\t\t\tDataDimension=");
11348 0 : metaptrsr[0] = strstr(metaptrsr[0], utlstrr);
11349 :
11350 : /* Get pointers to "IndexDimensionMap" section within SM */
11351 0 : metabufi = EHmetagroup(sdInterfaceID, swathname, "s",
11352 : "IndexDimensionMap", metaptrsi);
11353 0 : if(metabufi == NULL)
11354 : {
11355 0 : free(utlstrr);
11356 0 : free(utlstri);
11357 0 : return(-1);
11358 : }
11359 : /* Search for mapping - GeoDim/DataDim (surrounded by quotes) */
11360 0 : snprintf(utlstri, UTLSTR_MAX_SIZE, "%s%s%s", "\t\t\t\tGeoDimension=\"", geodim,
11361 : "\"\n\t\t\t\tDataDimension=");
11362 0 : metaptrsi[0] = strstr(metaptrsi[0], utlstri);
11363 :
11364 : /*
11365 : ** If regular mapping found add 1 to status
11366 : ** If l_indexed mapping found add 2
11367 : */
11368 0 : if (metaptrsr[0] < metaptrsr[1] && metaptrsr[0] != NULL)
11369 : {
11370 0 : status = status + 1;
11371 : }
11372 :
11373 0 : if (metaptrsi[0] < metaptrsi[1] && metaptrsi[0] != NULL)
11374 : {
11375 0 : status = status + 2;
11376 : }
11377 :
11378 0 : free(metabufr);
11379 0 : free(metabufi);
11380 : }
11381 :
11382 0 : free(utlstrr);
11383 0 : free(utlstri);
11384 :
11385 0 : return (status);
11386 : }
11387 :
11388 : /*----------------------------------------------------------------------------|
11389 : | BEGIN_PROLOG |
11390 : | |
11391 : | FUNCTION: SWsdid |
11392 : | |
11393 : | DESCRIPTION: Returns SD element ID for swath field |
11394 : | |
11395 : | |
11396 : | Return Value Type Units Description |
11397 : | ============ ====== ========= ===================================== |
11398 : | status intn return status (0) SUCCEED, (-1) FAIL |
11399 : | |
11400 : | INPUTS: |
11401 : | swathID int32 swath structure ID |
11402 : | fieldname const char field name |
11403 : | |
11404 : | |
11405 : | OUTPUTS: |
11406 : | sdid int32 SD element ID |
11407 : | |
11408 : | NOTES: |
11409 : | |
11410 : | |
11411 : | Date Programmer Description |
11412 : | ====== ============ ================================================= |
11413 : | Oct 07 Andrey Kiselev Original Programmer |
11414 : | |
11415 : | END_PROLOG |
11416 : -----------------------------------------------------------------------------*/
11417 : intn
11418 0 : SWsdid(int32 swathID, const char *fieldname, int32 *sdid)
11419 : {
11420 : intn status; /* routine return status variable */
11421 : int32 fid; /* HDF-EOS file ID */
11422 : int32 sdInterfaceID; /* HDF SDS interface ID */
11423 : int32 dum; /* Dummy variable */
11424 : int32 dims[H4_MAX_VAR_DIMS]; /* Field/SDS dimensions */
11425 :
11426 0 : status = SWchkswid(swathID, "SWsdid", &fid, &sdInterfaceID, &dum);
11427 0 : if (status != -1)
11428 : {
11429 0 : status = SWSDfldsrch(swathID, sdInterfaceID, fieldname,
11430 : sdid, &dum, &dum, &dum, dims, &dum);
11431 : }
11432 :
11433 0 : return (status);
11434 : }
|
