/***************************************************************************** * $Id: SWapi.c 6ef13199b493973da285decbfcd5e2a763954b97 2018-06-07 05:46:42 -0400 luzpaz $ * * This module has a number of additions and improvements over the original * implementation to be suitable for usage in GDAL HDF driver. * * Andrey Kiselev is responsible for all the changes. ****************************************************************************/ /* Copyright (C) 1996 Hughes and Applied Research Corporation Permission to use, modify, and distribute this software and its documentation for any purpose without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation. */ /***************************************************************************** REVISIONS: Aug 31, 1999 Abe Taaheri Changed memory allocation for utility strings to the size of UTLSTR_MAX_SIZE. Added error check for memory unavailability in several functions. Added check for NULL metabuf returned from EHmeta... functions. NULL pointer returned from EHmeta... functions indicate that memory could not be allocated for metabuf. June 05, 2003 Abe Taaheri / Bruce Beaumont Changed MAXNREGIONS to 1024 to support MOPITT data Supplied cast for compcode in call to SDsetcompress to avoid compiler error Removed declaration for unused variable rstatus in SWwrrdfield Removed initialization code for unused variables in SWwrrdfield Removed declaration for unused variable tmpVal in SWdefboxregion Added code in SWdefboxregion to check for l_index k exceeding NSWATHREGN to avoid overwriting memory Removed declaration for unused variable retchar in SWregionl_index Removed initialization code for unused variables in SWregionl_index Removed declarations for unused variables tstatus, nfields, nflgs, and swathname in SWextractregion Removed initialization code for unused variables in SWextractregion Removed declaration for unused variable land_status in SWscan2longlat Removed initialization code for unused variables in SWscan2longlat Added clear (0) of timeflag in SWextractperiod if return status from SWextractregion is non-zero Removed declarations for unused variables tstatus, scandim, ndfields, ndflds, and swathname in SWregioninfo Removed initialization code for unused variables in SWregioninfo Added clear (0) of timeflag in SWperiodinfo if return status from SWregioninfo is non-zero Removed declarations for unused variables size, nfields, nflds, nswath, idxsz, cornerlon, and cornerlat in SWdefscanregion Removed initialization code for unused variables in SWdefscanregion Removed declarations for unused variables dims2, rank, nt, swathname, dimlist, and buffer in SWupdateidxmap Removed declaration for unused variable statmeta in SWgeomapinfo ******************************************************************************/ #include "cpl_port.h" /* for M_PI */ #include "cpl_string.h" /* for CPLsnprintf */ #include "mfhdf.h" #include "hcomp.h" #include "HdfEosDef.h" #include #include "hdf4compat.h" #define SWIDOFFSET 1048576 static int32 SWX1dcomb[512*3]; static int32 SWXSDcomb[512*5]; static char SWXSDname[HDFE_NAMBUFSIZE]; static char SWXSDdims[HDFE_DIMBUFSIZE]; /* This flag was added to allow the Time field to have different Dimensions ** than Longitude and Latitude and still be used for subsetting ** 23 June,1997 DaW */ static intn timeflag = 0; /* Added for routine that converts scanline to Lat/long ** for floating scene subsetting ** Jul 1999 DaW */ #define RADOE 6371.0 /* Radius of Earth in Km */ #define NSWATH 200 /* Swath Structure External Arrays */ struct swathStructure { int32 active; int32 IDTable; int32 VIDTable[3]; int32 fid; int32 nSDS; int32 *sdsID; int32 compcode; intn compparm[5]; int32 tilecode; int32 tilerank; int32 tiledims[8]; }; static struct swathStructure SWXSwath[NSWATH]; #define NSWATHREGN 256 #define MAXNREGIONS 1024 struct swathRegion { int32 fid; int32 swathID; int32 nRegions; int32 StartRegion[MAXNREGIONS]; int32 StopRegion[MAXNREGIONS]; int32 StartVertical[8]; int32 StopVertical[8]; int32 StartScan[8]; int32 StopScan[8]; char *DimNamePtr[8]; intn band8flag; intn scanflag; }; static struct swathRegion *SWXRegion[NSWATHREGN]; /* define a macro for the string size of the utility strings. The value of 80 in previous version of this code was resulting in core dump (Array Bounds Write and Array Bounds Read problem in SWfinfo function and the functions called from there) for 7-8 dimensional fields where the string length for "DimList" can exceed 80 characters, including " and commas in the string. The length now is 512 which seems to be more than enough to avoid the problem mentioned above. */ #define UTLSTR_MAX_SIZE 512 /* Swath Prototypes (internal routines) */ static intn SWchkswid(int32, const char *, int32 *, int32 *, int32 *); static int32 SWfinfo(int32, const char *, const char *, int32 *, int32 [], int32 *, char *); static intn SWdefinefield(int32, const char *, const char *, const char *, int32, int32); static intn SWwrrdattr(int32, const char *, int32, int32, const char *, VOIDP); static intn SW1dfldsrch(int32, int32, const char *, const char *, int32 *, int32 *, int32 *); static intn SWSDfldsrch(int32, int32, const char *, int32 *, int32 *, int32 *, int32 *, int32 [], int32 *); static intn SWwrrdfield(int32, const char *, const char *, int32 [], int32 [], int32 [], VOIDP); static int32 SWinqfields(int32, const char *, char *, int32 [], int32 []); static intn SWscan2longlat(int32, const char *, VOIDP, int32 [], int32 [], int32 *, int32, int32); /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWopen | | | | DESCRIPTION: | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | fid int32 HDF-EOS file ID | | | | INPUTS: | | filename char Filename | | access intn HDF access code | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWopen(const char *filename, intn i_access) { int32 fid /* HDF-EOS file ID */ ; /* Call EHopen to perform file access */ /* ---------------------------------- */ fid = EHopen(filename, i_access); return (fid); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWcreate | | | | DESCRIPTION: Creates a new swath structure and returns swath ID | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | swathID int32 Swath structure ID | | | | INPUTS: | | fid int32 File ID | | swathname char Swath structure name | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Sep 96 Joel Gales Check swath name for length | | Mar 97 Joel Gales Enlarge utlbuf to 512 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWcreate(int32 fid, const char *swathname) { intn i; /* Loop index */ intn nswathopen = 0; /* # of swath structures open */ intn status = 0; /* routine return status variable */ uint8 l_access; /* Read/Write file access code */ int32 HDFfid; /* HDF file id */ int32 vgRef; /* Vgroup reference number */ int32 vgid[4]; /* Vgroup ID array */ int32 swathID = -1; /* HDF-EOS swath ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 nSwath = 0; /* Swath counter */ char name[80]; /* Vgroup name */ char class[80]; /* Vgroup class */ char errbuf[256];/* Buffer for error message */ char utlbuf[512];/* Utility buffer */ char utlbuf2[32];/* Utility buffer 2 */ /* * Check HDF-EOS file ID, get back HDF file ID, SD interface ID and * access code */ status = EHchkfid(fid, swathname, &HDFfid, &sdInterfaceID, &l_access); /* Check swathname for length */ /* -------------------------- */ if ((intn) strlen(swathname) > VGNAMELENMAX) { status = -1; HEpush(DFE_GENAPP, "SWcreate", __FILE__, __LINE__); HEreport("Swathname \"%s\" must be less than %d characters.\n", swathname, VGNAMELENMAX); } if (status == 0) { /* Determine number of swaths currently opened */ /* ------------------------------------------- */ for (i = 0; i < NSWATH; i++) { nswathopen += SWXSwath[i].active; } /* Setup file interface */ /* -------------------- */ if (nswathopen < NSWATH) { /* Check that swath has not been previously opened */ /* ----------------------------------------------- */ vgRef = -1; while (1) { vgRef = Vgetid(HDFfid, vgRef); /* If no more Vgroups then exist while loop */ /* ---------------------------------------- */ if (vgRef == -1) { break; } /* Get name and class of Vgroup */ /* ---------------------------- */ vgid[0] = Vattach(HDFfid, vgRef, "r"); Vgetname(vgid[0], name); Vgetclass(vgid[0], class); Vdetach(vgid[0]); /* If SWATH then increment # swath counter */ /* --------------------------------------- */ if (strcmp(class, "SWATH") == 0) { nSwath++; } /* If swath already exist, return error */ /* ------------------------------------ */ if (strcmp(name, swathname) == 0 && strcmp(class, "SWATH") == 0) { status = -1; HEpush(DFE_GENAPP, "SWcreate", __FILE__, __LINE__); HEreport("\"%s\" already exists.\n", swathname); break; } } if (status == 0) { /* Create Root Vgroup for Swath */ /* ---------------------------- */ vgid[0] = Vattach(HDFfid, -1, "w"); /* Set Name and Class (SWATH) */ /* -------------------------- */ Vsetname(vgid[0], swathname); Vsetclass(vgid[0], "SWATH"); /* Create Geolocation Fields Vgroup */ /* -------------------------------- */ vgid[1] = Vattach(HDFfid, -1, "w"); Vsetname(vgid[1], "Geolocation Fields"); Vsetclass(vgid[1], "SWATH Vgroup"); Vinsert(vgid[0], vgid[1]); /* Create Data Fields Vgroup */ /* ------------------------- */ vgid[2] = Vattach(HDFfid, -1, "w"); Vsetname(vgid[2], "Data Fields"); Vsetclass(vgid[2], "SWATH Vgroup"); Vinsert(vgid[0], vgid[2]); /* Create Attributes Vgroup */ /* ------------------------ */ vgid[3] = Vattach(HDFfid, -1, "w"); Vsetname(vgid[3], "Swath Attributes"); Vsetclass(vgid[3], "SWATH Vgroup"); Vinsert(vgid[0], vgid[3]); /* Establish Swath in Structural MetaData Block */ /* -------------------------------------------- */ snprintf(utlbuf, sizeof(utlbuf), "%s%ld%s%s%s", "\tGROUP=SWATH_", (long)nSwath + 1, "\n\t\tSwathName=\"", swathname, "\"\n"); strcat(utlbuf, "\t\tGROUP=Dimension\n"); strcat(utlbuf, "\t\tEND_GROUP=Dimension\n"); strcat(utlbuf, "\t\tGROUP=DimensionMap\n"); strcat(utlbuf, "\t\tEND_GROUP=DimensionMap\n"); strcat(utlbuf, "\t\tGROUP=IndexDimensionMap\n"); strcat(utlbuf, "\t\tEND_GROUP=IndexDimensionMap\n"); strcat(utlbuf, "\t\tGROUP=GeoField\n"); strcat(utlbuf, "\t\tEND_GROUP=GeoField\n"); strcat(utlbuf, "\t\tGROUP=DataField\n"); strcat(utlbuf, "\t\tEND_GROUP=DataField\n"); strcat(utlbuf, "\t\tGROUP=MergedFields\n"); strcat(utlbuf, "\t\tEND_GROUP=MergedFields\n"); CPLsnprintf(utlbuf2, sizeof(utlbuf2), "%s%ld%s", "\tEND_GROUP=SWATH_", (long)nSwath + 1, "\n"); strcat(utlbuf, utlbuf2); status = EHinsertmeta(sdInterfaceID, "", "s", 1001L, utlbuf, NULL); } } else { /* Too many files opened */ /* --------------------- */ status = -1; strcpy(errbuf, "No more than %d swaths may be open simultaneously"); strcat(errbuf, " (%s)"); HEpush(DFE_DENIED, "SWcreate", __FILE__, __LINE__); HEreport(errbuf, NSWATH, swathname); } /* Assign swathID # & Load swath and SWXSwath table entries */ /* -------------------------------------------------------- */ if (status == 0) { for (i = 0; i < NSWATH; i++) { if (SWXSwath[i].active == 0) { /* * Set swathID, Set swath entry active, Store root Vgroup * ID, Store sub Vgroup IDs, Store HDF-EOS file ID */ swathID = i + idOffset; SWXSwath[i].active = 1; SWXSwath[i].IDTable = vgid[0]; SWXSwath[i].VIDTable[0] = vgid[1]; SWXSwath[i].VIDTable[1] = vgid[2]; SWXSwath[i].VIDTable[2] = vgid[3]; SWXSwath[i].fid = fid; status = 0; break; } } } } return (swathID); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWattach | | | | DESCRIPTION: Attaches to an existing swath within the file. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | swathID int32 swath structure ID | | | | INPUTS: | | fid int32 HDF-EOS file ID | | swathname char swath structure name | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Apr 99 David Wynne Modified test for memory allocation check when no | | SDSs are in the Swath, NCR22513 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWattach(int32 fid, const char *swathname) { intn i; /* Loop index */ intn j; /* Loop index */ intn nswathopen = 0; /* # of swath structures open */ intn status; /* routine return status variable */ uint8 acs; /* Read/Write file access code */ int32 HDFfid; /* HDF file id */ int32 vgRef; /* Vgroup reference number */ int32 vgid[4]; /* Vgroup ID array */ int32 swathID = -1; /* HDF-EOS swath ID */ int32 *tags; /* Pnt to Vgroup object tags array */ int32 *refs; /* Pnt to Vgroup object refs array */ int32 dum; /* dummy variable */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 nObjects; /* # of objects in Vgroup */ int32 nSDS; /* SDS counter */ int32 l_index; /* SDS l_index */ int32 sdid; /* SDS object ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ char name[80]; /* Vgroup name */ char class[80]; /* Vgroup class */ char errbuf[256];/* Buffer for error message */ char acsCode[1]; /* Read/Write access char: "r/w" */ /* Check HDF-EOS file ID, get back HDF file ID and access code */ /* ----------------------------------------------------------- */ status = EHchkfid(fid, swathname, &HDFfid, &dum, &acs); if (status == 0) { /* Convert numeric access code to character */ /* ---------------------------------------- */ acsCode[0] = (acs == 1) ? 'w' : 'r'; /* Determine number of swaths currently opened */ /* ------------------------------------------- */ for (i = 0; i < NSWATH; i++) { nswathopen += SWXSwath[i].active; } /* If room for more ... */ /* -------------------- */ if (nswathopen < NSWATH) { /* Search Vgroups for Swath */ /* ------------------------ */ vgRef = -1; while (1) { vgRef = Vgetid(HDFfid, vgRef); /* If no more Vgroups then exist while loop */ /* ---------------------------------------- */ if (vgRef == -1) { break; } /* Get name and class of Vgroup */ /* ---------------------------- */ vgid[0] = Vattach(HDFfid, vgRef, "r"); Vgetname(vgid[0], name); Vgetclass(vgid[0], class); /* * If Vgroup with swathname and class SWATH found, load * tables */ if (strcmp(name, swathname) == 0 && strcmp(class, "SWATH") == 0) { /* Attach to "Fields" and "Swath Attributes" Vgroups */ /* ------------------------------------------------- */ tags = (int32 *) malloc(sizeof(int32) * 3); if(tags == NULL) { HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__); return(-1); } refs = (int32 *) malloc(sizeof(int32) * 3); if(refs == NULL) { HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__); free(tags); return(-1); } Vgettagrefs(vgid[0], tags, refs, 3); vgid[1] = Vattach(HDFfid, refs[0], acsCode); vgid[2] = Vattach(HDFfid, refs[1], acsCode); vgid[3] = Vattach(HDFfid, refs[2], acsCode); free(tags); free(refs); /* Setup External Arrays */ /* --------------------- */ for (i = 0; i < NSWATH; i++) { /* Find empty entry in array */ /* ------------------------- */ if (SWXSwath[i].active == 0) { /* * Set swathID, Set swath entry active, Store * root Vgroup ID, Store sub Vgroup IDs, Store * HDF-EOS file ID */ swathID = i + idOffset; SWXSwath[i].active = 1; SWXSwath[i].IDTable = vgid[0]; SWXSwath[i].VIDTable[0] = vgid[1]; SWXSwath[i].VIDTable[1] = vgid[2]; SWXSwath[i].VIDTable[2] = vgid[3]; SWXSwath[i].fid = fid; break; } } /* Get SDS interface ID */ /* -------------------- */ status = SWchkswid(swathID, "SWattach", &dum, &sdInterfaceID, &dum); /* Access swath "Geolocation" SDS */ /* ------------------------------ */ /* Get # of entries within this Vgroup & search for SDS */ /* ---------------------------------------------------- */ nObjects = Vntagrefs(vgid[1]); if (nObjects > 0) { /* Get tag and ref # for Geolocation Vgroup objects */ /* ------------------------------------------------ */ tags = (int32 *) malloc(sizeof(int32) * nObjects); if(tags == NULL) { HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__); return(-1); } refs = (int32 *) malloc(sizeof(int32) * nObjects); if(refs == NULL) { HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__); free(tags); return(-1); } Vgettagrefs(vgid[1], tags, refs, nObjects); /* Count number of SDS & allocate SDS ID array */ /* ------------------------------------------- */ nSDS = 0; for (j = 0; j < nObjects; j++) { if (tags[j] == DFTAG_NDG) { nSDS++; } } SWXSwath[i].sdsID = (int32 *) calloc(nSDS, 4); if(SWXSwath[i].sdsID == NULL && nSDS != 0) { HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__); free(tags); free(refs); return(-1); } nSDS = 0; /* Fill SDS ID array */ /* ----------------- */ for (j = 0; j < nObjects; j++) { /* If object is SDS then get id */ /* ---------------------------- */ if (tags[j] == DFTAG_NDG) { l_index = SDreftoindex(sdInterfaceID, refs[j]); sdid = SDselect(sdInterfaceID, l_index); SWXSwath[i].sdsID[nSDS] = sdid; nSDS++; SWXSwath[i].nSDS++; } } free(tags); free(refs); } /* Access swath "Data" SDS */ /* ----------------------- */ /* Get # of entries within this Vgroup & search for SDS */ /* ---------------------------------------------------- */ nObjects = Vntagrefs(vgid[2]); if (nObjects > 0) { /* Get tag and ref # for Data Vgroup objects */ /* ----------------------------------------- */ tags = (int32 *) malloc(sizeof(int32) * nObjects); if(tags == NULL) { HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__); return(-1); } refs = (int32 *) malloc(sizeof(int32) * nObjects); if(refs == NULL) { HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__); free(tags); return(-1); } Vgettagrefs(vgid[2], tags, refs, nObjects); /* Count number of SDS & allocate SDS ID array */ /* ------------------------------------------- */ nSDS = 0; for (j = 0; j < nObjects; j++) { if (tags[j] == DFTAG_NDG) { nSDS++; } } SWXSwath[i].sdsID = (int32 *) realloc((void *) SWXSwath[i].sdsID, (SWXSwath[i].nSDS + nSDS) * 4); if(SWXSwath[i].sdsID == NULL && nSDS != 0) { HEpush(DFE_NOSPACE,"SWattach", __FILE__, __LINE__); return(-1); } /* Fill SDS ID array */ /* ----------------- */ for (j = 0; j < nObjects; j++) { /* If object is SDS then get id */ /* ---------------------------- */ if (tags[j] == DFTAG_NDG) { l_index = SDreftoindex(sdInterfaceID, refs[j]); sdid = SDselect(sdInterfaceID, l_index); SWXSwath[i].sdsID[SWXSwath[i].nSDS] = sdid; SWXSwath[i].nSDS++; } } free(tags); free(refs); } break; } /* Detach Vgroup if not desired Swath */ /* ---------------------------------- */ Vdetach(vgid[0]); } /* If Swath not found then set up error message */ /* -------------------------------------------- */ if (swathID == -1) { HEpush(DFE_RANGE, "SWattach", __FILE__, __LINE__); HEreport("Swath: \"%s\" does not exist within HDF file.\n", swathname); } } else { /* Too many files opened */ /* --------------------- */ swathID = -1; strcpy(errbuf, "No more than %d swaths may be open simultaneously"); strcat(errbuf, " (%s)"); HEpush(DFE_DENIED, "SWattach", __FILE__, __LINE__); HEreport(errbuf, NSWATH, swathname); } } return (swathID); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWchkswid | | | | DESCRIPTION: Checks for valid swathID and returns file ID, SDS ID, and | | swath Vgroup ID | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | routname char Name of routine calling SWchkswid | | | | OUTPUTS: | | fid int32 File ID | | sdInterfaceID int32 SDS interface ID | | swVgrpID int32 swath Vgroup ID | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static intn SWchkswid(int32 swathID, const char *routname, int32 * fid, int32 * sdInterfaceID, int32 * swVgrpID) { intn status = 0; /* routine return status variable */ uint8 l_access; /* Read/Write access code */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ char message1[] = "Invalid swath id: %d in routine \"%s\". ID must be >= %d and < %d.\n"; char message2[] = "Swath id %d in routine \"%s\" not active.\n"; /* Check for valid swath id */ /* ------------------------ */ if (swathID < idOffset || swathID >= NSWATH + idOffset) { status = -1; HEpush(DFE_RANGE, "SWchkswid", __FILE__, __LINE__); HEreport(message1, swathID, routname, idOffset, NSWATH + idOffset); } else { /* Check for active swath ID */ /* ------------------------- */ if (SWXSwath[swathID % idOffset].active == 0) { status = -1; HEpush(DFE_GENAPP, "SWchkswid", __FILE__, __LINE__); HEreport(message2, swathID, routname); } else { /* Get file & SDS ids and Swath Vgroup */ /* ----------------------------------- */ status = EHchkfid(SWXSwath[swathID % idOffset].fid, " ", fid, sdInterfaceID, &l_access); *swVgrpID = SWXSwath[swathID % idOffset].IDTable; } } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefdim | | | | DESCRIPTION: Defines numerical value of dimension | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | dimname char Dimension name to define | | dim int32 Dimension value | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Dec 96 Joel Gales Check that dim value >= 0 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWdefdim(int32 swathID, char *dimname, int32 dim) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file id */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ char swathname[80] /* Swath name */ ; /* Check for valid swath id */ /* ------------------------ */ status = SWchkswid(swathID, "SWdefdim", &fid, &sdInterfaceID, &swVgrpID); /* Make sure dimension >= 0 */ /* ------------------------ */ if (dim < 0) { status = -1; HEpush(DFE_GENAPP, "SWdefdim", __FILE__, __LINE__); HEreport("Dimension value for \"%s\" less than zero: %d.\n", dimname, dim); } /* Write Dimension to Structural MetaData */ /* -------------------------------------- */ if (status == 0) { Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); status = EHinsertmeta(sdInterfaceID, swathname, "s", 0L, dimname, &dim); } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdiminfo | | | | DESCRIPTION: Returns size in bytes of named dimension | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | size int32 Size of dimension | | | | INPUTS: | | swathID int32 swath structure id | | dimname char Dimension name | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWdiminfo(int32 swathID, const char *dimname) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 size; /* Dimension size */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWdiminfo", __FILE__, __LINE__); return(-1); } /* Initialize return value */ size = -1; /* Check Swath ID */ status = SWchkswid(swathID, "SWdiminfo", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Get pointers to "Dimension" section within SM */ metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "Dimension", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } /* Search for dimension name (surrounded by quotes) */ snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", dimname, "\"\n"); metaptrs[0] = strstr(metaptrs[0], utlstr); /* * If dimension found within swath structure then get dimension value */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { /* Set endptr at end of dimension definition entry */ metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT"); status = EHgetmetavalue(metaptrs, "Size", utlstr); if (status == 0) { size = atoi(utlstr); } else { HEpush(DFE_GENAPP, "SWdiminfo", __FILE__, __LINE__); HEreport("\"Size\" string not found in metadata.\n"); } } else { HEpush(DFE_GENAPP, "SWdiminfo", __FILE__, __LINE__); HEreport("Dimension \"%s\" not found.\n", dimname); } free(metabuf); } free(utlstr); return (size); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWmapinfo | | | | DESCRIPTION: Returns dimension mapping information | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure id | | geodim char geolocation dimension name | | datadim char data dimension name | | | | OUTPUTS: | | offset int32 mapping offset | | increment int32 mapping increment | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWmapinfo(int32 swathID, const char *geodim, const char *datadim, int32 * offset, int32 * increment) { intn status; /* routine return status variable */ intn statmeta = 0; /* EHgetmetavalue return status */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWmapinfo", __FILE__, __LINE__); return(-1); } /* Initialize return values */ *offset = -1; *increment = -1; /* Check Swath ID */ status = SWchkswid(swathID, "SWmapinfo", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Get pointers to "DimensionMap" section within SM */ metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "DimensionMap", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } /* Search for mapping - GeoDim/DataDim (surrounded by quotes) */ snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s%s%s", "\t\t\t\tGeoDimension=\"", geodim, "\"\n\t\t\t\tDataDimension=\"", datadim, "\"\n"); metaptrs[0] = strstr(metaptrs[0], utlstr); /* * If mapping found within swath structure then get offset and * increment value */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { /* Get Offset */ statmeta = EHgetmetavalue(metaptrs, "Offset", utlstr); if (statmeta == 0) { *offset = atoi(utlstr); } else { status = -1; HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__); HEreport("\"Offset\" string not found in metadata.\n"); } /* Get Increment */ statmeta = EHgetmetavalue(metaptrs, "Increment", utlstr); if (statmeta == 0) { *increment = atoi(utlstr); } else { status = -1; HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__); HEreport("\"Increment\" string not found in metadata.\n"); } } else { status = -1; HEpush(DFE_GENAPP, "SWmapinfo", __FILE__, __LINE__); HEreport("Mapping \"%s/%s\" not found.\n", geodim, datadim); } free(metabuf); } free(utlstr); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWidxmapinfo | | | | DESCRIPTION: Returns l_indexed mapping information | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | gsize int32 Number of l_index values (sz of geo dim) | | | | INPUTS: | | swathID int32 swath structure id | | geodim char geolocation dimension name | | datadim char data dimension name | | | | | | OUTPUTS: | | l_index int32 array of l_index values | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWidxmapinfo(int32 swathID, const char *geodim, const char *datadim, int32 l_index[]) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 vgid; /* Swath Attributes Vgroup ID */ int32 vdataID; /* Index Mapping Vdata ID */ int32 gsize = -1; /* Size of geo dim */ char utlbuf[256];/* Utility buffer */ /* Check Swath ID */ status = SWchkswid(swathID, "SWidxmapinfo", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Find Index Mapping Vdata with Swath Attributes Vgroup */ snprintf(utlbuf, sizeof(utlbuf), "%s%s%s%s", "INDXMAP:", geodim, "/", datadim); vgid = SWXSwath[swathID % idOffset].VIDTable[2]; vdataID = EHgetid(fid, vgid, utlbuf, 1, "r"); /* If found then get geodim size & read l_index mapping values */ if (vdataID != -1) { gsize = SWdiminfo(swathID, geodim); VSsetfields(vdataID, "Index"); VSread(vdataID, (uint8 *) l_index, 1, FULL_INTERLACE); VSdetach(vdataID); } else { /*status = -1;*/ HEpush(DFE_GENAPP, "SWidxmapinfo", __FILE__, __LINE__); HEreport("Index Mapping \"%s\" not found.\n", utlbuf); } } return (gsize); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWcompinfo | | | | DESCRIPTION: | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn | | | | INPUTS: | | swathID int32 | | compcode int32 | | compparm intn | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Oct 96 Joel Gales Original Programmer | | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWcompinfo(int32 swathID, const char *fieldname, int32 * compcode, intn compparm[]) { intn i; /* Loop Index */ intn status; /* routine return status variable */ intn statmeta = 0; /* EHgetmetavalue return status */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ const char *HDFcomp[5] = {"HDFE_COMP_NONE", "HDFE_COMP_RLE", "HDFE_COMP_NBIT", "HDFE_COMP_SKPHUFF", "HDFE_COMP_DEFLATE"}; /* Compression Codes */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWcompinfo", __FILE__, __LINE__); return(-1); } /* Check Swath ID */ status = SWchkswid(swathID, "SWcompinfo", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Get pointers to "DataField" section within SM */ metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "DataField", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } /* Search for field */ snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n"); metaptrs[0] = strstr(metaptrs[0], utlstr); /* If not found then search in "GeoField" section */ if (metaptrs[0] > metaptrs[1] || metaptrs[0] == NULL) { free(metabuf); /* Get pointers to "GeoField" section within SM */ metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "GeoField", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } /* Search for field */ snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n"); metaptrs[0] = strstr(metaptrs[0], utlstr); } /* If field found and user wants compression code ... */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { if (compcode != NULL) { /* Set endptr at end of field's definition entry */ metaptrs[1] = strstr(metaptrs[0], "\t\t\tEND_OBJECT"); /* Get compression type */ statmeta = EHgetmetavalue(metaptrs, "CompressionType", utlstr); /* * Default is no compression if "CompressionType" string not * in metadata */ *compcode = HDFE_COMP_NONE; /* If compression code is found ... */ if (statmeta == 0) { /* Loop through compression types until match */ for (i = 0; i < 5; i++) { if (strcmp(utlstr, HDFcomp[i]) == 0) { *compcode = i; break; } } } } /* If user wants compression parameters ... */ if (compparm != NULL && compcode != NULL) { /* Initialize to zero */ for (i = 0; i < 4; i++) { compparm[i] = 0; } /* * Get compression parameters if NBIT or DEFLATE compression */ if (*compcode == HDFE_COMP_NBIT) { statmeta = EHgetmetavalue(metaptrs, "CompressionParams", utlstr); if (statmeta == 0) { sscanf(utlstr, "(%d,%d,%d,%d)", &compparm[0], &compparm[1], &compparm[2], &compparm[3]); } else { status = -1; HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__); HEreport( "\"CompressionParams\" string not found in metadata.\n"); } } else if (*compcode == HDFE_COMP_DEFLATE) { statmeta = EHgetmetavalue(metaptrs, "DeflateLevel", utlstr); if (statmeta == 0) { sscanf(utlstr, "%d", &compparm[0]); } else { status = -1; HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__); HEreport( "\"DeflateLevel\" string not found in metadata.\n"); } } } } else { HEpush(DFE_GENAPP, "SWcompinfo", __FILE__, __LINE__); HEreport("Fieldname \"%s\" not found.\n", fieldname); } free(metabuf); } free(utlstr); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWfinfo | | | | DESCRIPTION: Returns field info | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure id | | fieldtype const char fieldtype (geo or data) | | fieldname const char name of field | | | | | | OUTPUTS: | | rank int32 rank of field (# of dims) | | dims int32 field dimensions | | numbertype int32 field number type | | dimlist char field dimension list | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Jan 97 Joel Gales Check for metadata error status from EHgetmetavalue | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static int32 SWfinfo(int32 swathID, const char *fieldtype, const char *fieldname, int32 *rank, int32 dims[], int32 *numbertype, char *dimlist) { intn i; /* Loop index */ intn j; /* Loop index */ intn status; /* routine return status variable */ intn statmeta = 0; /* EHgetmetavalue return status */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 fsize; /* field size in bytes */ int32 ndims = 0; /* Number of dimensions */ int32 slen[8]; /* Length of each entry in parsed string */ int32 dum; /* Dummy variable */ int32 vdataID; /* 1d field vdata ID */ uint8 *buf; /* One-Dim field buffer */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ char *ptr[8]; /* String pointers for parsed string */ char dimstr[64]; /* Individual dimension entry string */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWfinfo", __FILE__, __LINE__); return(-1); } /* Initialize rank and numbertype to -1 (error) */ /* -------------------------------------------- */ *rank = -1; *numbertype = -1; /* Get HDF-EOS file ID and SDS interface ID */ status = SWchkswid(swathID, "SWfinfo", &fid, &sdInterfaceID, &dum); /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Get pointers to appropriate "Field" section within SM */ if (strcmp(fieldtype, "Geolocation Fields") == 0) { metabuf = EHmetagroup(sdInterfaceID, swathname, "s", "GeoField", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } } else { metabuf = EHmetagroup(sdInterfaceID, swathname, "s", "DataField", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } } /* Search for field */ snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\"\n"); metaptrs[0] = strstr(metaptrs[0], utlstr); /* If field found ... */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { /* Get DataType string */ statmeta = EHgetmetavalue(metaptrs, "DataType", utlstr); /* Convert to numbertype code */ if (statmeta == 0) *numbertype = EHnumstr(utlstr); else { status = -1; HEpush(DFE_GENAPP, "SWfinfo", __FILE__, __LINE__); HEreport("\"DataType\" string not found in metadata.\n"); } /* * Get DimList string and trim off leading and trailing parens "()" */ statmeta = EHgetmetavalue(metaptrs, "DimList", utlstr); if (statmeta == 0) { memmove(utlstr, utlstr + 1, strlen(utlstr) - 2); utlstr[strlen(utlstr) - 2] = 0; /* Parse trimmed DimList string and get rank */ ndims = EHparsestr(utlstr, ',', ptr, slen); *rank = ndims; } else { status = -1; HEpush(DFE_GENAPP, "SWfinfo", __FILE__, __LINE__); HEreport("\"DimList\" string not found in metadata.\n"); } /* If dimension list is desired by user then initialize length to 0 */ if (dimlist != NULL) { dimlist[0] = 0; } /* * Copy each entry in DimList and remove leading and trailing quotes, * Get dimension sizes and concatenate dimension names to dimension * list */ for (i = 0; i < ndims; i++) { memcpy(dimstr, ptr[i] + 1, slen[i] - 2); dimstr[slen[i] - 2] = 0; dims[i] = SWdiminfo(swathID, dimstr); if (dimlist != NULL) { if (i > 0) { strcat(dimlist, ","); } strcat(dimlist, dimstr); } } /* Appendable Field Section */ /* ------------------------ */ if (dims[0] == 0) { /* One-Dimensional Field */ if (*rank == 1) { /* Get vdata ID */ status = SW1dfldsrch(fid, swathID, fieldname, "r", &dum, &vdataID, &dum); /* Get actual size of field */ dims[0] = VSelts(vdataID); /* * If size=1 then check where actual record of * "initialization" record */ if (dims[0] == 1) { /* Get record size and read 1st record */ fsize = VSsizeof(vdataID, (char *)fieldname); buf = (uint8 *) calloc(fsize, 1); if(buf == NULL) { HEpush(DFE_NOSPACE,"SWfinfo", __FILE__, __LINE__); free(utlstr); return(-1); } VSsetfields(vdataID, fieldname); VSseek(vdataID, 0); VSread(vdataID, (uint8 *) buf, 1, FULL_INTERLACE); /* Sum up "bytes" in record */ for (i = 0, j = 0; i < fsize; i++) { j += buf[i]; } /* * If filled with 255 then "initialization" record, * actual number of records = 0 */ if (j == 255 * fsize) { dims[0] = 0; } free(buf); } /* Detach from 1d field */ VSdetach(vdataID); } else { /* Get actual size of Multi-Dimensional Field */ status = SWSDfldsrch(swathID, sdInterfaceID, fieldname, &dum, &dum, &dum, &dum, dims, &dum); } } } free(metabuf); if (*rank == -1) { status = -1; } free(utlstr); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWfieldinfo | | | | DESCRIPTION: Wrapper around SWfinfo | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure id | | fieldname const char name of field | | | | | | OUTPUTS: | | rank int32 rank of field (# of dims) | | dims int32 field dimensions | | numbertype int32 field number type | | dimlist char field dimension list | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWfieldinfo(int32 swathID, const char *fieldname, int32 * rank, int32 dims[], int32 * numbertype, char *dimlist) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ /* Check for valid swath id */ status = SWchkswid(swathID, "SWfieldinfo", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Check for field within Geolocatation Fields */ status = SWfinfo(swathID, "Geolocation Fields", fieldname, rank, dims, numbertype, dimlist); /* If not there then check within Data Fields */ if (status == -1) { status = SWfinfo(swathID, "Data Fields", fieldname, rank, dims, numbertype, dimlist); } /* If not there either then can't be found */ if (status == -1) { HEpush(DFE_GENAPP, "SWfieldinfo", __FILE__, __LINE__); HEreport("Fieldname \"%s\" not found.\n", fieldname); } } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefdimmap | | | | DESCRIPTION: Defines mapping between geolocation and data dimensions | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | geodim char Geolocation dimension | | datadim char Data dimension | | offset int32 Mapping offset | | increment int32 Mapping increment | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWdefdimmap(int32 swathID, const char *geodim, const char *datadim, int32 offset, int32 increment) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 size; /* Size of geo dim */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 dum; /* Dummy variable */ int32 metadata[2];/* Offset & Increment (passed to metadata) */ char mapname[80];/* Mapping name (geodim/datadim) */ char swathname[80]; /* Swath name */ /* Check Swath ID */ status = SWchkswid(swathID, "SWdefdimmap", &fid, &sdInterfaceID, &dum); if (status == 0) { /* Search Dimension Vdata for dimension entries */ /* -------------------------------------------- */ size = SWdiminfo(swathID, geodim); if (size == -1) { status = -1; HEpush(DFE_GENAPP, "SWdefdimmap", __FILE__, __LINE__); HEreport("Geolocation dimension name: \"%s\" not found.\n", geodim); } /* Data Dimension Search */ /* --------------------- */ if (status == 0) { size = SWdiminfo(swathID, datadim); if (size == -1) { status = -1; HEpush(DFE_GENAPP, "SWdefdimmap", __FILE__, __LINE__); HEreport("Data dimension name: \"%s\" not found.\n", datadim); } } /* Write Dimension Map to Structural MetaData */ /* ------------------------------------------ */ if (status == 0) { snprintf(mapname, sizeof(mapname), "%s%s%s", geodim, "/", datadim); metadata[0] = offset; metadata[1] = increment; Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); status = EHinsertmeta(sdInterfaceID, swathname, "s", 1L, mapname, metadata); } } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefidxmap | | | | DESCRIPTION: Defines l_indexed (non-linear) mapping between geolocation | | and data dimensions | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | geodim char Geolocation dimension | | datadim char Data dimension | | l_index int32 Index mapping array | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWdefidxmap(int32 swathID, const char *geodim, const char *datadim, int32 l_index[]) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 attrVgrpID; /* Swath attribute ID */ int32 vdataID; /* Mapping Index Vdata ID */ int32 gsize; /* Size of geo dim */ int32 dsize; /* Size of data dim */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 dum; /* Dummy variable */ uint8 *buf; /* Vdata field buffer */ char mapname[80];/* Mapping name (geodim/datadim) */ char swathname[80]; /* Swath name */ char utlbuf[256];/* Utility buffer */ /* Check Swath ID */ status = SWchkswid(swathID, "SWdefidxmap", &fid, &sdInterfaceID, &dum); if (status == 0) { /* Search Dimension Vdata for dimension entries */ /* -------------------------------------------- */ /* Geo Dimension Search */ /* -------------------- */ gsize = SWdiminfo(swathID, geodim); if (gsize == -1) { status = -1; HEpush(DFE_GENAPP, "SWdefidxmap", __FILE__, __LINE__); HEreport("Geolocation dimension name: \"%s\" not found.\n", geodim); } /* Data Dimension Search */ /* --------------------- */ if (status == 0) { dsize = SWdiminfo(swathID, datadim); if (dsize == -1) { status = -1; HEpush(DFE_GENAPP, "SWdefidxmap", __FILE__, __LINE__); HEreport("Data dimension name: \"%s\" not found.\n", datadim); } } /* Define Index Vdata and Store Index Array */ /* ---------------------------------------- */ if (status == 0) { /* Get attribute Vgroup ID and allocate data buffer */ /* ------------------------------------------------ */ attrVgrpID = SWXSwath[swathID % idOffset].VIDTable[2]; buf = (uint8 *) calloc(4 * gsize, 1); if(buf == NULL) { HEpush(DFE_NOSPACE,"SWdefidxmap", __FILE__, __LINE__); return(-1); } /* Name: "INDXMAP:" + geodim + "/" + datadim */ snprintf(utlbuf, sizeof(utlbuf), "%s%s%s%s", "INDXMAP:", geodim, "/", datadim); vdataID = VSattach(fid, -1, "w"); VSsetname(vdataID, utlbuf); /* Attribute Class */ VSsetclass(vdataID, "Attr0.0"); /* Fieldname is "Index" */ VSfdefine(vdataID, "Index", DFNT_INT32, gsize); VSsetfields(vdataID, "Index"); memcpy(buf, l_index, 4 * gsize); /* Write to vdata and free data buffer */ VSwrite(vdataID, buf, 1, FULL_INTERLACE); free(buf); /* Insert in Attribute Vgroup and detach Vdata */ Vinsert(attrVgrpID, vdataID); VSdetach(vdataID); /* Write to Structural Metadata */ snprintf(mapname, sizeof(mapname), "%s%s%s", geodim, "/", datadim); Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); status = EHinsertmeta(sdInterfaceID, swathname, "s", 2L, mapname, &dum); } } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefcomp | | | | DESCRIPTION: Defines compression type and parameters | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | compcode int32 compression code | | compparm intn compression parameters | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Sep 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWdefcomp(int32 swathID, int32 compcode, intn compparm[]) { intn status = 0; /* routine return status variable */ int32 fid; /* HDF-EOS file id */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 sID; /* swathID - offset */ /* Check for valid swath id */ status = SWchkswid(swathID, "SWdefcomp", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { sID = swathID % idOffset; /* Set compression code in compression external array */ SWXSwath[sID].compcode = compcode; switch (compcode) { /* Set NBIT compression parameters in compression external array */ case HDFE_COMP_NBIT: SWXSwath[sID].compparm[0] = compparm[0]; SWXSwath[sID].compparm[1] = compparm[1]; SWXSwath[sID].compparm[2] = compparm[2]; SWXSwath[sID].compparm[3] = compparm[3]; break; /* Set GZIP compression parameter in compression external array */ case HDFE_COMP_DEFLATE: SWXSwath[sID].compparm[0] = compparm[0]; break; } } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefinefield | | | | DESCRIPTION: Defines geolocation or data field within swath structure | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldtype char geo/data fieldtype | | fieldname char fieldname | | dimlist char Dimension list (comma-separated list) | | numbertype int32 field type | | merge int32 merge code | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Check name for length | | Sep 96 Joel Gales Make string array "dimbuf" dynamic | | Oct 96 Joel Gales Make sure total length of "merged" Vdata < 64 | | Jun 03 Abe Taaheri Supplied cast comp_coder_t in call to SDsetcompress | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static intn SWdefinefield(int32 swathID, const char *fieldtype, const char *fieldname, const char *dimlist, int32 numbertype, int32 merge) { intn i; /* Loop index */ intn status; /* routine return status variable */ intn found; /* utility found flag */ intn foundNT = 0;/* found number type flag */ intn foundAllDim = 1; /* found all dimensions flag */ intn first = 1; /* first entry flag */ intn fac; /* Geo (-1), Data (+1) field factor */ int32 cnt = 0; int32 fid; /* HDF-EOS file ID */ int32 vdataID = 0; /* Vdata ID */ int32 vgid; /* Geo/Data field Vgroup ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 sdid; /* SDS object ID */ int32 dimid; /* SDS dimension ID */ int32 recSize; /* Vdata record size */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 dims[8]; /* Dimension size array */ int32 dimsize; /* Dimension size */ int32 rank = 0; /* Field rank */ int32 slen[32]; /* String length array */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 compcode; /* Compression code */ int32 sID; /* SwathID - offset */ uint8 *oneDbuf; /* Vdata record buffer */ char *dimbuf; /* Dimension buffer */ char *comma; /* Pointer to comma */ char *dimcheck; /* Dimension check buffer */ char utlbuf[512];/* Utility buffer */ char utlbuf2[256]; /* Utility buffer 2 */ char *ptr[32]; /* String pointer array */ char swathname[80]; /* Swath name */ char errbuf1[128]; /* Error message buffer 1 */ char errbuf2[128]; /* Error message buffer 2 */ char compparmbuf[128]; /* Compression parameter string buffer */ const char *HDFcomp[5] = {"HDFE_COMP_NONE", "HDFE_COMP_RLE", "HDFE_COMP_NBIT", "HDFE_COMP_SKPHUFF", "HDFE_COMP_DEFLATE"}; /* Compression code names */ uint16 good_number[10] = {3, 4, 5, 6, 20, 21, 22, 23, 24, 25}; /* Valid number types */ comp_info c_info; /* Compression parameter structure */ /* Setup error message strings */ /* --------------------------- */ strcpy(errbuf1, "SWXSDname array too small.\nPlease increase "); strcat(errbuf1, "size of HDFE_NAMBUFSIZE in \"HdfEosDef.h\".\n"); strcpy(errbuf2, "SWXSDdims array too small.\nPlease increase "); strcat(errbuf2, "size of HDFE_DIMBUFSIZE in \"HdfEosDef.h\".\n"); /* * Check for proper swath ID and return HDF-EOS file ID, SDinterface ID, * and swath root Vgroup ID */ status = SWchkswid(swathID, "SWdefinefield", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Remove offset from swath ID & get swathname */ sID = swathID % idOffset; Vgetname(swVgrpID, swathname); /* Allocate space for dimbuf, copy dimlist into it, & append comma */ dimbuf = (char *) calloc(strlen(dimlist) + 64, 1); if(dimbuf == NULL) { HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__); return(-1); } strcpy(dimbuf, dimlist); strcat(dimbuf, ","); /* Find comma */ comma = strchr(dimbuf, ','); /* * Loop through entries in dimension list to make sure they are * defined in swath */ while (comma != NULL) { /* Copy dimension list entry to dimcheck */ dimcheck = (char *) calloc(comma - dimbuf + 1, 1); if(dimcheck == NULL) { HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__); free(dimbuf); return(-1); } memcpy(dimcheck, dimbuf, comma - dimbuf); /* Get dimension size */ dimsize = SWdiminfo(swathID, dimcheck); /* if != -1 then sent found flag, store size and increment rank */ if (dimsize != -1) { dims[rank] = dimsize; rank++; } else { /* * If dimension list entry not found - set error return * status, append name to utility buffer for error report */ status = -1; foundAllDim = 0; if (first == 1) { strcpy(utlbuf, dimcheck); } else { strcat(utlbuf, ","); strcat(utlbuf, dimcheck); } first = 0; } /* * Go to next dimension entry, find next comma, & free up * dimcheck buffer */ *comma = '\0'; /* zero out first comma */ comma++; comma = strchr(comma, ','); if (comma != NULL) { for (i=0; i<(intn)strlen(dimcheck) + 1; i++) { dimbuf++; cnt++; } } free(dimcheck); } for(i=0; i MAX_NC_NAME - 7) ** this was changed because HDF4.1r3 made a change in the ** hlimits.h file. We have notified NCSA and asked to have ** it made the same as in previous versions of HDF ** see ncr 26314. DaW Apr 2000 */ if (((intn) strlen(fieldname) > VSNAMELENMAX && rank == 1) || ((intn) strlen(fieldname) > (256 - 7) && rank > 1)) { status = -1; HEpush(DFE_GENAPP, "SWdefinefield", __FILE__, __LINE__); HEreport("Fieldname \"%s\" too long.\n", fieldname); } } /* Check for valid numbertype */ /* -------------------------- */ if (status == 0) { for (i = 0; i < 10; i++) { if (numbertype == good_number[i]) { foundNT = 1; } } if (foundNT == 0) { HEpush(DFE_BADNUMTYPE, "SWdefinefield", __FILE__, __LINE__); HEreport("Invalid number type: %d (%s).\n", numbertype, fieldname); status = -1; } } /* Define Field */ /* ------------ */ if (status == 0) { /* Set factor & get Field Vgroup id */ /* -------------------------------- */ if (strcmp(fieldtype, "Geolocation Fields") == 0) { fac = -1; vgid = SWXSwath[sID].VIDTable[0]; } else { fac = +1; vgid = SWXSwath[sID].VIDTable[1]; } /* * Note: "fac" is used to distinguish geo fields from data fields * so that they are not merged together */ /* One D Fields */ /* ------------ */ if (rank == 1) { /* No Compression for 1D (Vdata) fields */ compcode = HDFE_COMP_NONE; /* If field non-appendable and merge set to AUTOMERGE ... */ if (dims[0] != 0 && merge == HDFE_AUTOMERGE) { i = 0; found = 0; /* Loop through previous entries in 1d combination array */ while (SWX1dcomb[3 * i] != 0) { /* Get name of previous 1d combined field */ vdataID = SWX1dcomb[3 * i + 2]; VSgetname(vdataID, utlbuf); /* * If dimension, field type (geo/data), and swath * structure if current entry match a previous entry * and combined name is less than max allowed then * set "found" flag and exit loop */ if (SWX1dcomb[3 * i] == fac * dims[0] && SWX1dcomb[3 * i + 1] == swVgrpID && (intn) strlen(utlbuf) + (intn) strlen(fieldname) + 1 <= VSNAMELENMAX) { found = 1; break; } /* Increment loop index */ i++; } if (found == 0) { /* * If no matching entry found then start new Vdata * and store dimension size, swath root Vgroup ID, * field Vdata and fieldname in external array * "SWX1dcomb" */ vdataID = VSattach(fid, -1, "w"); SWX1dcomb[3 * i] = fac * dims[0]; SWX1dcomb[3 * i + 1] = swVgrpID; SWX1dcomb[3 * i + 2] = vdataID; VSsetname(vdataID, fieldname); } else { /* * If match then concatenate current fieldname to * previous matching fieldnames. */ strcat(utlbuf, ","); strcat(utlbuf, fieldname); VSsetname(vdataID, utlbuf); } /* Define field as field within Vdata */ VSfdefine(vdataID, fieldname, numbertype, 1); Vinsert(vgid, vdataID); } else { /* 1d No Merge Section */ /* Get new vdata ID and establish field within Vdata */ vdataID = VSattach(fid, -1, "w"); VSsetname(vdataID, fieldname); VSfdefine(vdataID, fieldname, numbertype, 1); VSsetfields(vdataID, fieldname); recSize = VSsizeof(vdataID, (char*) fieldname); if (dims[0] == 0) { /* * If appendable field then write single record * filled with 255 */ oneDbuf = (uint8 *) calloc(recSize, 1); if(oneDbuf == NULL) { HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__); return(-1); } for (i = 0; i < recSize; i++) oneDbuf[i] = 255; VSwrite(vdataID, oneDbuf, 1, FULL_INTERLACE); } else { /* * If non-appendable then write entire field with * blank records */ oneDbuf = (uint8 *) calloc(recSize, dims[0]); if(oneDbuf == NULL) { HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__); return(-1); } VSwrite(vdataID, oneDbuf, dims[0], FULL_INTERLACE); } free(oneDbuf); /* Insert Vdata into field Vgroup & detach */ Vinsert(vgid, vdataID); VSdetach(vdataID); } /* End No Merge Section */ } /* End 1d field Section */ else { /* SDS Interface (Multi-dim fields) */ /* -------------------------------- */ /* Get current compression code */ compcode = SWXSwath[sID].compcode; /* * If rank is less than or equal to 3 (and greater than 1) * and AUTOMERGE is set and the first dimension is not * appendable and the compression code is set to none then * ... */ if (rank <= 3 && merge == HDFE_AUTOMERGE && dims[0] != 0 && compcode == HDFE_COMP_NONE) { /* Find first empty slot in external combination array */ /* --------------------------------------------------- */ i = 0; while (SWXSDcomb[5 * i] != 0) { i++; } /* * Store dimensions (with geo/data factor), swath root * Vgroup ID, and number type in external combination * array "SWXSDcomb" */ if (rank == 2) { /* If 2-dim field then set lowest dimension to +/- 1 */ SWXSDcomb[5 * i] = fac; SWXSDcomb[5 * i + 1] = fac * dims[0]; SWXSDcomb[5 * i + 2] = fac * dims[1]; } else { SWXSDcomb[5 * i] = fac * dims[0]; SWXSDcomb[5 * i + 1] = fac * dims[1]; SWXSDcomb[5 * i + 2] = fac * dims[2]; } SWXSDcomb[5 * i + 3] = swVgrpID; SWXSDcomb[5 * i + 4] = numbertype; /* Concatenate fieldname with combined name string */ /* ----------------------------------------------- */ if ((intn) strlen(SWXSDname) + (intn) strlen(fieldname) + 2 < HDFE_NAMBUFSIZE) { strcat(SWXSDname, fieldname); strcat(SWXSDname, ","); } else { /* SWXSDname array too small! */ /* -------------------------- */ HEpush(DFE_GENAPP, "SWdefinefield", __FILE__, __LINE__); HEreport(errbuf1); status = -1; return (status); } /* * If 2-dim field then set lowest dimension (in 3-dim * array) to "ONE" */ if (rank == 2) { if ((intn) strlen(SWXSDdims) + 5 < HDFE_DIMBUFSIZE) { strcat(SWXSDdims, "ONE,"); } else { /* SWXSDdims array too small! */ /* -------------------------- */ HEpush(DFE_GENAPP, "SWdefinefield", __FILE__, __LINE__); HEreport(errbuf2); status = -1; return (status); } } /* * Concatenate field dimlist to merged dimlist and * separate fields with semi-colon. */ if ((intn) strlen(SWXSDdims) + (intn) strlen(dimlist) + 2 < HDFE_DIMBUFSIZE) { strcat(SWXSDdims, dimlist); strcat(SWXSDdims, ";"); } else { /* SWXSDdims array too small! */ /* -------------------------- */ HEpush(DFE_GENAPP, "SWdefinefield", __FILE__, __LINE__); HEreport(errbuf2); status = -1; return (status); } } /* End Multi-Dim Merge Section */ else { /* Multi-Dim No Merge Section */ /* ========================== */ /* Create SDS dataset */ /* ------------------ */ sdid = SDcreate(sdInterfaceID, fieldname, numbertype, rank, dims); /* Store Dimension Names in SDS */ /* ---------------------------- */ rank = EHparsestr(dimlist, ',', ptr, slen); for (i = 0; i < rank; i++) { /* Dimension name = Swathname:Dimname */ memcpy(utlbuf, ptr[i], slen[i]); utlbuf[slen[i]] = 0; strcat(utlbuf, ":"); strcat(utlbuf, swathname); dimid = SDgetdimid(sdid, i); SDsetdimname(dimid, utlbuf); } /* Setup compression parameters */ if (compcode == HDFE_COMP_NBIT) { c_info.nbit.nt = numbertype; c_info.nbit.sign_ext = SWXSwath[sID].compparm[0]; c_info.nbit.fill_one = SWXSwath[sID].compparm[1]; c_info.nbit.start_bit = SWXSwath[sID].compparm[2]; c_info.nbit.bit_len = SWXSwath[sID].compparm[3]; } else if (compcode == HDFE_COMP_SKPHUFF) { c_info.skphuff.skp_size = (intn) DFKNTsize(numbertype); } else if (compcode == HDFE_COMP_DEFLATE) { c_info.deflate.level = SWXSwath[sID].compparm[0]; } /* If field is compressed then call SDsetcompress */ /* ---------------------------------------------- */ if (compcode != HDFE_COMP_NONE) { /* status = */ SDsetcompress(sdid, (comp_coder_t) compcode, &c_info); } /* Attach to Vgroup */ /* ---------------- */ Vaddtagref(vgid, DFTAG_NDG, SDidtoref(sdid)); /* Store SDS dataset IDs */ /* --------------------- */ if (SWXSwath[sID].nSDS > 0) { SWXSwath[sID].sdsID = (int32 *) realloc((void *) SWXSwath[sID].sdsID, (SWXSwath[sID].nSDS + 1) * 4); if(SWXSwath[sID].sdsID == NULL) { HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__); return(-1); } } else { SWXSwath[sID].sdsID = (int32 *) calloc(1, 4); if(SWXSwath[sID].sdsID == NULL) { HEpush(DFE_NOSPACE,"SWdefinefield", __FILE__, __LINE__); return(-1); } } SWXSwath[sID].sdsID[SWXSwath[sID].nSDS] = sdid; SWXSwath[sID].nSDS++; } /* End Multi-Dim No Merge Section */ } /* End Multi-Dim Section */ /* Setup metadata string */ /* --------------------- */ snprintf(utlbuf, sizeof(utlbuf), "%s%s%s", fieldname, ":", dimlist); /* Setup compression metadata */ /* -------------------------- */ if (compcode != HDFE_COMP_NONE) { snprintf(utlbuf2, sizeof(utlbuf2), "%s%s", ":\n\t\t\t\tCompressionType=", HDFcomp[compcode]); switch (compcode) { case HDFE_COMP_NBIT: snprintf(compparmbuf, sizeof(compparmbuf), "%s%d,%d,%d,%d%s", "\n\t\t\t\tCompressionParams=(", SWXSwath[sID].compparm[0], SWXSwath[sID].compparm[1], SWXSwath[sID].compparm[2], SWXSwath[sID].compparm[3], ")"); strcat(utlbuf2, compparmbuf); break; case HDFE_COMP_DEFLATE: snprintf(compparmbuf, sizeof(compparmbuf), "%s%d", "\n\t\t\t\tDeflateLevel=", SWXSwath[sID].compparm[0]); strcat(utlbuf2, compparmbuf); break; } /* Concatenate compression parameters with compression code */ strcat(utlbuf, utlbuf2); } /* Insert field metadata within File Structural Metadata */ /* ----------------------------------------------------- */ if (strcmp(fieldtype, "Geolocation Fields") == 0) { status = EHinsertmeta(sdInterfaceID, swathname, "s", 3L, utlbuf, &numbertype); } else { status = EHinsertmeta(sdInterfaceID, swathname, "s", 4L, utlbuf, &numbertype); } } } /* If all dimensions not found then report error */ /* --------------------------------------------- */ if (foundAllDim == 0) { HEpush(DFE_GENAPP, "SWdefinefield", __FILE__, __LINE__); HEreport("Dimension(s): \"%s\" not found (%s).\n", utlbuf, fieldname); status = -1; } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefgeofield | | | | DESCRIPTION: Defines geolocation field within swath structure (wrapper) | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname char fieldname | | dimlist char Dimension list (comma-separated list) | | numbertype int32 field type | | merge int32 merge code | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWdefgeofield(int32 swathID, const char *fieldname, const char *dimlist, int32 numbertype, int32 merge) { intn status; /* routine return status variable */ /* Call SWdefinefield routine */ /* -------------------------- */ status = SWdefinefield(swathID, "Geolocation Fields", fieldname, dimlist, numbertype, merge); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefdatafield | | | | DESCRIPTION: Defines data field within swath structure (wrapper) | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname char fieldname | | dimlist char Dimension list (comma-separated list) | | numbertype int32 field type | | merge int32 merge code | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWdefdatafield(int32 swathID, const char *fieldname, const char *dimlist, int32 numbertype, int32 merge) { intn status; /* routine return status variable */ /* Call SWdefinefield routine */ /* -------------------------- */ status = SWdefinefield(swathID, "Data Fields", fieldname, dimlist, numbertype, merge); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWwritegeometa | | | | DESCRIPTION: Defines structural metadata for pre-existing geolocation | | field within swath structure | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname char fieldname | | dimlist char Dimension list (comma-separated list) | | numbertype int32 field type | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWwritegeometa(int32 swathID, const char *fieldname, const char *dimlist, int32 numbertype) { intn status = 0; /* routine return status variable */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 dum; /* dummy variable */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ char utlbuf[256];/* Utility buffer */ char swathname[80]; /* Swath name */ status = SWchkswid(swathID, "SWwritegeometa", &dum, &sdInterfaceID, &dum); if (status == 0) { /* Setup and write field metadata */ /* ------------------------------ */ snprintf(utlbuf, sizeof(utlbuf), "%s%s%s", fieldname, ":", dimlist); Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); status = EHinsertmeta(sdInterfaceID, swathname, "s", 3L, utlbuf, &numbertype); } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWwritedatameta | | | | DESCRIPTION: Defines structural metadata for pre-existing data | | field within swath structure | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname char fieldname | | dimlist char Dimension list (comma-separated list) | | numbertype int32 field type | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWwritedatameta(int32 swathID, const char *fieldname, const char *dimlist, int32 numbertype) { intn status = 0; /* routine return status variable */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 dum; /* dummy variable */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ char utlbuf[256];/* Utility buffer */ char swathname[80]; /* Swath name */ status = SWchkswid(swathID, "SWwritedatameta", &dum, &sdInterfaceID, &dum); if (status == 0) { /* Setup and write field metadata */ /* ------------------------------ */ snprintf(utlbuf, sizeof(utlbuf), "%s%s%s", fieldname, ":", dimlist); Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); status = EHinsertmeta(sdInterfaceID, swathname, "s", 4L, utlbuf, &numbertype); } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWwrrdattr | | | | DESCRIPTION: | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | attrname char attribute name | | numbertype int32 attribute HDF numbertype | | count int32 Number of attribute elements | | wrcode char Read/Write Code "w/r" | | datbuf void I/O buffer | | | | OUTPUTS: | | datbuf | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Oct 96 Joel Gales Get Attribute Vgroup ID from external array | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static intn SWwrrdattr(int32 swathID, const char *attrname, int32 numbertype, int32 count, const char *wrcode, VOIDP datbuf) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 attrVgrpID; /* Swath attribute ID */ int32 dum; /* dummy variable */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ /* Check Swath id */ status = SWchkswid(swathID, "SWwrrdattr", &fid, &dum, &dum); if (status == 0) { /* Get attribute Vgroup ID and call EHattr to perform I/O */ /* ------------------------------------------------------ */ attrVgrpID = SWXSwath[swathID % idOffset].VIDTable[2]; status = EHattr(fid, attrVgrpID, attrname, numbertype, count, wrcode, datbuf); } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWwriteattr | | | | DESCRIPTION: Writes/updates attribute in a swath. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | attrname char attribute name | | numbertype int32 attribute HDF numbertype | | count int32 Number of attribute elements | | datbuf void I/O buffer | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWwriteattr(int32 swathID, const char *attrname, int32 numbertype, int32 count, VOIDP datbuf) { intn status = 0; /* routine return status variable */ /* Call SWwrrdattr routine to write attribute */ /* ------------------------------------------ */ status = SWwrrdattr(swathID, attrname, numbertype, count, "w", datbuf); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWreadattr | | | | DESCRIPTION: Reads attribute from a swath. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | attrname char attribute name | | | | OUTPUTS: | | datbuf void I/O buffer | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWreadattr(int32 swathID, const char *attrname, VOIDP datbuf) { intn status = 0; /* routine return status variable */ int32 dum = 0; /* dummy variable */ /* Call SWwrrdattr routine to read attribute */ /* ----------------------------------------- */ status = SWwrrdattr(swathID, attrname, dum, dum, "r", datbuf); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWattrinfo | | | | DESCRIPTION: | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | attrname char attribute name | | | | OUTPUTS: | | numbertype int32 attribute HDF numbertype | | count int32 Number of attribute elements | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Oct 96 Joel Gales Get Attribute Vgroup ID from external array | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWattrinfo(int32 swathID, const char *attrname, int32 * numbertype, int32 * count) { intn status = 0; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 attrVgrpID; /* Swath attribute ID */ int32 dum; /* dummy variable */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWattrinfo", &fid, &dum, &dum); if (status == 0) { /* Get attribute Vgroup ID and call EHattrinfo */ /* ------------------------------------------- */ attrVgrpID = SWXSwath[swathID % idOffset].VIDTable[2]; status = EHattrinfo(fid, attrVgrpID, attrname, numbertype, count); } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWinqattrs | | | | DESCRIPTION: | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nattr int32 Number of attributes in swath struct | | | | INPUTS: | | swath ID int32 swath structure ID | | | | OUTPUTS: | | attrnames char Attribute names in swath struct | | (Comma-separated list) | | strbufsize int32 Attributes name list string length | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Oct 96 Joel Gales Initialize nattr | | Oct 96 Joel Gales Get Attribute Vgroup ID from external array | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWinqattrs(int32 swathID, char *attrnames, int32 * strbufsize) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 attrVgrpID; /* Swath attribute ID */ int32 dum; /* dummy variable */ int32 nattr = 0; /* Number of attributes */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ /* Check Swath id */ status = SWchkswid(swathID, "SWinqattrs", &fid, &dum, &dum); if (status == 0) { /* Get attribute Vgroup ID and call EHattrcat */ /* ------------------------------------------ */ attrVgrpID = SWXSwath[swathID % idOffset].VIDTable[2]; nattr = EHattrcat(fid, attrVgrpID, attrnames, strbufsize); } return (nattr); } #define REMQUOTE \ \ memmove(utlstr, utlstr + 1, strlen(utlstr) - 2); \ utlstr[strlen(utlstr) - 2] = 0; /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWinqdims | | | | DESCRIPTION: Returns dimension names and values defined in swath structure | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nDim int32 Number of defined dimensions | | | | INPUTS: | | swathID int32 swath structure ID | | | | OUTPUTS: | | dimnames char Dimension names (comma-separated) | | dims int32 Dimension values | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Feb 97 Joel Gales Set nDim to -1 if status = -1 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWinqdims(int32 swathID, char *dimnames, int32 dims[]) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 size; /* Dimension size */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 nDim = 0; /* Number of dimensions */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWinqdims", __FILE__, __LINE__); return(-1); } /* Check for valid swath id */ status = SWchkswid(swathID, "SWinqdims", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* If dimension names or sizes are desired ... */ /* ------------------------------------------- */ if (dimnames != NULL || dims != NULL) { /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Get pointers to "Dimension" section within SM */ metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "Dimension", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } /* If dimension names are desired then "clear" name buffer */ if (dimnames != NULL) { dimnames[0] = 0; } /* Begin loop through dimension entries in metadata */ /* ------------------------------------------------ */ while (1) { /* Search for OBJECT string */ metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT="); /* If found within "Dimension" metadata section ... */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { /* Get Dimension Name (if desired) */ if (dimnames != NULL) { /* Check 1st for old meta data then new */ /* ------------------------------------ */ EHgetmetavalue(metaptrs, "OBJECT", utlstr); /* * If OBJECT value begins with double quote then old * metadata, dimension name is OBJECT value. * Otherwise search for "DimensionName" string */ if (utlstr[0] != '"') { metaptrs[0] = strstr(metaptrs[0], "\t\t\t\tDimensionName="); EHgetmetavalue(metaptrs, "DimensionName", utlstr); } /* Strip off double quotes */ /* ----------------------- */ REMQUOTE /* If not first name then add comma delimiter */ if (nDim > 0) { strcat(dimnames, ","); } /* Add dimension name to dimension list */ strcat(dimnames, utlstr); } /* Get Dimension Size (if desired) */ if (dims != NULL) { EHgetmetavalue(metaptrs, "Size", utlstr); size = atoi(utlstr); dims[nDim] = size; } /* Increment number of dimensions */ nDim++; } else /* No more dimensions found */ { break; } } free(metabuf); } } /* Set nDim to -1 if error status exists */ /* ------------------------------------- */ if (status == -1) { nDim = -1; } free(utlstr); return (nDim); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWinqmaps | | | | DESCRIPTION: Returns dimension mappings and offsets and increments | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nMap int32 Number of dimension mappings | | | | INPUTS: | | swathID int32 swath structure ID | | | | OUTPUTS: | | dimmaps char dimension mappings (comma-separated) | | offset int32 array of offsets | | increment int32 array of increments | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Feb 97 Joel Gales Set nMap to -1 if status = -1 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWinqmaps(int32 swathID, char *dimmaps, int32 offset[], int32 increment[]) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 off; /* Mapping Offset */ int32 incr; /* Mapping Increment */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 nMap = 0; /* Number of mappings */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWinqmaps", __FILE__, __LINE__); return(-1); } /* Check for valid swath id */ status = SWchkswid(swathID, "SWinqmaps", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* If mapping names or offsets or increments desired ... */ /* ----------------------------------------------------- */ if (dimmaps != NULL || offset != NULL || increment != NULL) { /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Get pointers to "DimensionMap" section within SM */ metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "DimensionMap", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } /* If mapping names are desired then "clear" name buffer */ if (dimmaps != NULL) { dimmaps[0] = 0; } /* Begin loop through mapping entries in metadata */ /* ---------------------------------------------- */ while (1) { /* Search for OBJECT string */ metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT="); /* If found within "DimensionMap" metadata section ... */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { /* Get Geo & Data Dimensions (if desired) */ if (dimmaps != NULL) { /* Get Geo Dim, remove quotes, add "/" */ EHgetmetavalue(metaptrs, "GeoDimension", utlstr); REMQUOTE strcat(utlstr, "/"); /* If not first map then add comma delimiter. */ if (nMap > 0) { strcat(dimmaps, ","); } /* Add to map list */ strcat(dimmaps, utlstr); /* Get Data Dim, remove quotes */ EHgetmetavalue(metaptrs, "DataDimension", utlstr); REMQUOTE /* Add to map list */ strcat(dimmaps, utlstr); } /* Get Offset (if desired) */ if (offset != NULL) { EHgetmetavalue(metaptrs, "Offset", utlstr); off = atoi(utlstr); offset[nMap] = off; } /* Get Increment (if desired) */ if (increment != NULL) { EHgetmetavalue(metaptrs, "Increment", utlstr); incr = atoi(utlstr); increment[nMap] = incr; } /* Increment number of maps */ nMap++; } else /* No more mappings found */ { break; } } free(metabuf); } } /* Set nMap to -1 if error status exists */ /* ------------------------------------- */ if (status == -1) { nMap = -1; } free(utlstr); return (nMap); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWinqidxmaps | | | | DESCRIPTION: Returns l_indexed mappings and l_index sizes | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nMap int32 Number of l_indexed dimension mappings | | | | INPUTS: | | swathID int32 swath structure ID | | | | OUTPUTS: | | idxmaps char l_indexed dimension mappings | | (comma-separated) | | idxsizes int32 Number of elements in each mapping | | | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Feb 97 Joel Gales Set nMap to -1 if status = -1 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWinqidxmaps(int32 swathID, char *idxmaps, int32 idxsizes[]) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 nMap = 0; /* Number of mappings */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ char *slash; /* Pointer to slash */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWinqidxmaps", __FILE__, __LINE__); return(-1); } /* Check for valid swath id */ status = SWchkswid(swathID, "SWinqidxmaps", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* If mapping names or l_index sizes desired ... */ /* ------------------------------------------- */ if (idxmaps != NULL || idxsizes != NULL) { /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Get pointers to "IndexDimensionMap" section within SM */ metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "IndexDimensionMap", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } /* If mapping names are desired then "clear" name buffer */ if (idxmaps != NULL) { idxmaps[0] = 0; } /* Begin loop through mapping entries in metadata */ /* ---------------------------------------------- */ while (1) { /* Search for OBJECT string */ metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT="); /* If found within "IndexDimensionMap" metadata section ... */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { /* Get Geo & Data Dimensions and # of indices */ if (idxmaps != NULL) { /* Get Geo Dim, remove quotes, add "/" */ EHgetmetavalue(metaptrs, "GeoDimension", utlstr); REMQUOTE strcat(utlstr, "/"); /* If not first map then add comma delimiter. */ if (nMap > 0) { strcat(idxmaps, ","); } /* Add to map list */ strcat(idxmaps, utlstr); /* Get Index size (if desired) */ if (idxsizes != NULL) { /* Parse off geo dimension and find its size */ slash = strchr(utlstr, '/'); *slash = 0; idxsizes[nMap] = SWdiminfo(swathID, utlstr); } /* Get Data Dim, remove quotes */ EHgetmetavalue(metaptrs, "DataDimension", utlstr); REMQUOTE /* Add to map list */ strcat(idxmaps, utlstr); } /* Increment number of maps */ nMap++; } else /* No more mappings found */ { break; } } free(metabuf); } } /* Set nMap to -1 if error status exists */ /* ------------------------------------- */ if (status == -1) { nMap = -1; } free(utlstr); return (nMap); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWinqfields | | | | DESCRIPTION: Returns fieldnames, ranks and numbertypes defined in swath. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nFld int32 Number of (geo/data) fields in swath | | | | INPUTS: | | swathID int32 swath structure ID | | fieldtype char field type (geo or data) | | | | | | OUTPUTS: | | fieldlist char Field names (comma-separated) | | rank int32 Array of ranks | | numbertype int32 Array of HDF number types | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Feb 97 Joel Gales Set nFld to -1 if status = -1 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static int32 SWinqfields(int32 swathID, const char *fieldtype, char *fieldlist, int32 rank[], int32 numbertype[]) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 nFld = 0; /* Number of mappings */ int32 slen[8]; /* String length array */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ char *utlstr2; /* Utility string 2 */ char *ptr[8]; /* String pointer array */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWinqfields", __FILE__, __LINE__); return(-1); } utlstr2 = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr2 == NULL) { HEpush(DFE_NOSPACE,"SWinqfields", __FILE__, __LINE__); free(utlstr); return(-1); } /* Check for valid swath id */ status = SWchkswid(swathID, "SWinqfields", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* If field names, ranks, or number types desired ... */ /* --------------------------------------------------- */ if (fieldlist != NULL || rank != NULL || numbertype != NULL) { /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Get pointers to "GeoField" or "DataField" section within SM */ if (strcmp(fieldtype, "Geolocation Fields") == 0) { metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "GeoField", metaptrs); if(metabuf == NULL) { free(utlstr); free(utlstr2); return(-1); } strcpy(utlstr2, "GeoFieldName"); } else { metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "DataField", metaptrs); if(metabuf == NULL) { free(utlstr); free(utlstr2); return(-1); } strcpy(utlstr2, "DataFieldName"); } /* If field names are desired then "clear" name buffer */ if (fieldlist != NULL) { fieldlist[0] = 0; } /* Begin loop through mapping entries in metadata */ /* ---------------------------------------------- */ while (1) { /* Search for OBJECT string */ metaptrs[0] = strstr(metaptrs[0], "\t\tOBJECT="); /* If found within "Geo" or "Data" Field metadata section .. */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { /* Get Fieldnames (if desired) */ if (fieldlist != NULL) { /* Check 1st for old meta data then new */ /* ------------------------------------ */ EHgetmetavalue(metaptrs, "OBJECT", utlstr); /* * If OBJECT value begins with double quote then old * metadata, field name is OBJECT value. Otherwise * search for "GeoFieldName" or "DataFieldName" * string */ if (utlstr[0] != '"') { strcpy(utlstr, "\t\t\t\t"); strcat(utlstr, utlstr2); strcat(utlstr, "="); metaptrs[0] = strstr(metaptrs[0], utlstr); EHgetmetavalue(metaptrs, utlstr2, utlstr); } /* Strip off double quotes */ /* ----------------------- */ REMQUOTE /* Add to fieldlist */ /* ---------------- */ if (nFld > 0) { strcat(fieldlist, ","); } strcat(fieldlist, utlstr); } /* Get Numbertype */ if (numbertype != NULL) { EHgetmetavalue(metaptrs, "DataType", utlstr); numbertype[nFld] = EHnumstr(utlstr); } /* * Get Rank (if desired) by counting # of dimensions in * "DimList" string */ if (rank != NULL) { EHgetmetavalue(metaptrs, "DimList", utlstr); rank[nFld] = EHparsestr(utlstr, ',', ptr, slen); } /* Increment number of fields */ nFld++; } else /* No more fields found */ { break; } } free(metabuf); } } /* Set nFld to -1 if error status exists */ /* ------------------------------------- */ if (status == -1) { nFld = -1; } free(utlstr); free(utlstr2); return (nFld); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWinqgeofields | | | | DESCRIPTION: Inquires about geo fields in swath | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nflds int32 Number of geo fields in swath | | | | INPUTS: | | swathID int32 swath structure ID | | | | OUTPUTS: | | fieldlist char Field names (comma-separated) | | rank int32 Array of ranks | | numbertype int32 Array of HDF number types | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWinqgeofields(int32 swathID, char *fieldlist, int32 rank[], int32 numbertype[]) { int32 nflds; /* Number of Geolocation fields */ /* Call "SWinqfields" routine */ /* -------------------------- */ nflds = SWinqfields(swathID, "Geolocation Fields", fieldlist, rank, numbertype); return (nflds); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWinqdatafields | | | | DESCRIPTION: Inquires about data fields in swath | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nflds int32 Number of data fields in swath | | | | INPUTS: | | swathID int32 swath structure ID | | | | OUTPUTS: | | fieldlist char Field names (comma-separated) | | rank int32 Array of ranks | | numbertype int32 Array of HDF number types | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWinqdatafields(int32 swathID, char *fieldlist, int32 rank[], int32 numbertype[]) { int32 nflds; /* Number of Data fields */ /* Call "SWinqfields" routine */ /* -------------------------- */ nflds = SWinqfields(swathID, "Data Fields", fieldlist, rank, numbertype); return (nflds); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWnentries | | | | DESCRIPTION: Returns number of entries and string buffer size | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nEntries int32 Number of entries | | | | INPUTS: | | swathID int32 swath structure ID | | entrycode int32 Entry code | | HDFE_NENTDIM (0) | | HDFE_NENTMAP (1) | | HDFE_NENTIMAP (2) | | HDFE_NENTGFLD (3) | | HDFE_NENTDFLD (4) | | | | | | OUTPUTS: | | strbufsize int32 Length of comma-separated list | | (Does not include null-terminator | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | Feb 97 Joel Gales Set nEntries to -1 if status = -1 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWnentries(int32 swathID, int32 entrycode, int32 * strbufsize) { intn status; /* routine return status variable */ intn i; /* Loop index */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 nEntries = 0; /* Number of entries */ int32 metaflag; /* Old (0), New (1) metadata flag) */ int32 nVal = 0; /* Number of strings to search for */ char *metabuf = NULL; /* Pointer to structural metadata (SM) */ char *metaptrs[2]; /* Pointers to begin and end of SM section */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ char valName[2][32]; /* Strings to search for */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWnemtries", __FILE__, __LINE__); return(-1); } /* Check for valid swath id */ /* ------------------------ */ status = SWchkswid(swathID, "SWnentries", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Get swath name */ Vgetname(SWXSwath[swathID % idOffset].IDTable, swathname); /* Zero out string buffer size */ *strbufsize = 0; /* * Get pointer to relevant section within SM and Get names of * metadata strings to inquire about */ switch (entrycode) { case HDFE_NENTDIM: /* Dimensions */ { metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "Dimension", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } nVal = 1; strcpy(&valName[0][0], "DimensionName"); } break; case HDFE_NENTMAP: /* Dimension Maps */ { metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "DimensionMap", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } nVal = 2; strcpy(&valName[0][0], "GeoDimension"); strcpy(&valName[1][0], "DataDimension"); } break; case HDFE_NENTIMAP: /* Indexed Dimension Maps */ { metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "IndexDimensionMap", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } nVal = 2; strcpy(&valName[0][0], "GeoDimension"); strcpy(&valName[1][0], "DataDimension"); } break; case HDFE_NENTGFLD: /* Geolocation Fields */ { metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "GeoField", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } nVal = 1; strcpy(&valName[0][0], "GeoFieldName"); } break; case HDFE_NENTDFLD: /* Data Fields */ { metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "DataField", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } nVal = 1; strcpy(&valName[0][0], "DataFieldName"); } break; } /* * Check for presence of 'GROUP="' string If found then old metadata, * search on OBJECT string */ if (metabuf) { metaflag = (strstr(metabuf, "GROUP=\"") == NULL) ? 1 : 0; if (metaflag == 0) { nVal = 1; strcpy(&valName[0][0], "\t\tOBJECT"); } /* Begin loop through entries in metadata */ /* -------------------------------------- */ while (1) { /* Search for first string */ strcpy(utlstr, &valName[0][0]); strcat(utlstr, "="); metaptrs[0] = strstr(metaptrs[0], utlstr); /* If found within relevant metadata section ... */ if (metaptrs[0] < metaptrs[1] && metaptrs[0] != NULL) { for (i = 0; i < nVal; i++) { /* * Get all string values Don't count quotes */ EHgetmetavalue(metaptrs, &valName[i][0], utlstr); *strbufsize += (int32)strlen(utlstr) - 2; } /* Increment number of entries */ nEntries++; /* Go to end of OBJECT */ metaptrs[0] = strstr(metaptrs[0], "END_OBJECT"); } else /* No more entries found */ { break; } } free(metabuf); } /* Count comma separators & slashes (if mappings) */ /* ---------------------------------------------- */ if (nEntries > 0) { *strbufsize += nEntries - 1; *strbufsize += (nVal - 1) * nEntries; } } /* Set nEntries to -1 if error status exists */ /* ----------------------------------------- */ if (status == -1) nEntries = -1; free(utlstr); return (nEntries); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWinqswath | | | | DESCRIPTION: Returns number and names of swath structures in file | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nSwath int32 Number of swath structures in file | | | | INPUTS: | | filename char HDF-EOS filename | | | | OUTPUTS: | | swathlist char List of swath names (comma-separated) | | strbufsize int32 Length of swathlist | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWinqswath(const char *filename, char *swathlist, int32 * strbufsize) { int32 nSwath; /* Number of swath structures in file */ /* Call "EHinquire" routine */ /* ------------------------ */ nSwath = EHinquire(filename, "SWATH", swathlist, strbufsize); return (nSwath); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SW1dfldsrch | | | | DESCRIPTION: Retrieves information about a 1D field | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | fid int32 HDF-EOS file ID | | swathID int32 swath structure ID | | fieldname const char field name | | access const char Access code (w/r) | | | | | | OUTPUTS: | | vgidout int32 Field (geo/data) vgroup ID | | vdataIDout int32 Field Vdata ID | | fldtype int32 Field type | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static intn SW1dfldsrch(int32 fid, int32 swathID, const char *fieldname, const char *i_access, int32 * vgidout, int32 * vdataIDout, int32 * fldtype) { intn status = 0; /* routine return status variable */ int32 sID; /* SwathID - offset */ int32 vgid; /* Swath Geo or Data Vgroup ID */ int32 vdataID; /* 1d field vdata */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ /* Compute "reduced" swath ID */ /* -------------------------- */ sID = swathID % idOffset; /* Get Geolocation Vgroup id and 1D field name Vdata id */ /* ---------------------------------------------------- */ vgid = SWXSwath[sID].VIDTable[0]; vdataID = EHgetid(fid, vgid, fieldname, 1, i_access); *fldtype = 0; /* * If name not found in Geolocation Vgroup then detach Geolocation Vgroup * and search in Data Vgroup */ if (vdataID == -1) { vgid = SWXSwath[sID].VIDTable[1];; vdataID = EHgetid(fid, vgid, fieldname, 1, i_access); *fldtype = 1; /* If field also not found in Data Vgroup then set error status */ /* ------------------------------------------------------------ */ if (vdataID == -1) { status = -1; vgid = -1; vdataID = -1; } } *vgidout = vgid; *vdataIDout = vdataID; return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWSDfldsrch | | | | DESCRIPTION: Retrieves information SDS field | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | sdInterfaceID int32 SD interface ID | | fieldname const char field name | | | | | | OUTPUTS: | | sdid int32 SD element ID | | rankSDS int32 Rank of SDS | | rankFld int32 True rank of field (merging) | | offset int32 Offset of field within merged field | | dims int32 Dimensions of field | | solo int32 Solo field flag | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Make metadata ODL compliant | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static intn SWSDfldsrch(int32 swathID, int32 sdInterfaceID, const char *fieldname, int32 * sdid, int32 * rankSDS, int32 * rankFld, int32 * offset, int32 dims[], int32 * solo) { intn i; /* Loop index */ intn status = -1;/* routine return status variable */ int32 sID; /* SwathID - offset */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 dum; /* Dummy variable */ int32 dums[128]; /* Dummy array */ int32 attrIndex; /* Attribute l_index */ char name[2048]; /* Merged-Field Names */ char swathname[80]; /* Swath Name */ char *utlstr; /* Utility string */ char *metabuf; /* Pointer to structural metadata (SM) */ char *metaptrs[2];/* Pointers to begin and end of SM section */ char *oldmetaptr; /* Pointer within SM section */ /* Allocate space for utility string */ /* --------------------------------- */ utlstr = (char *) calloc(UTLSTR_MAX_SIZE, sizeof(char)); if(utlstr == NULL) { HEpush(DFE_NOSPACE,"SWSDfldsrch", __FILE__, __LINE__); return(-1); } /* Set solo flag to 0 (no) */ /* ----------------------- */ *solo = 0; /* Compute "reduced" swath ID */ /* -------------------------- */ sID = swathID % idOffset; /* Loop through all SDSs in swath */ /* ------------------------------ */ for (i = 0; i < SWXSwath[sID].nSDS; i++) { /* If active SDS ... */ /* ----------------- */ if (SWXSwath[sID].sdsID[i] != 0) { /* Get SDS ID, name, rankSDS, and dimensions */ /* ----------------------------------------- */ *sdid = SWXSwath[sID].sdsID[i]; SDgetinfo(*sdid, name, rankSDS, dims, &dum, &dum); *rankFld = *rankSDS; /* If merged field ... */ /* ------------------- */ if (strstr(name, "MRGFLD_") == &name[0]) { /* Get swath name */ /* -------------- */ Vgetname(SWXSwath[sID].IDTable, swathname); /* Get pointers to "MergedFields" section within SM */ /* ------------------------------------------------ */ metabuf = (char *) EHmetagroup(sdInterfaceID, swathname, "s", "MergedFields", metaptrs); if(metabuf == NULL) { free(utlstr); return(-1); } /* Store metaptr in order to recover */ /* --------------------------------- */ oldmetaptr = metaptrs[0]; /* Search for Merged field name */ /* ---------------------------- */ snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%.480s%s", "MergedFieldName=\"", name, "\"\n"); metaptrs[0] = strstr(metaptrs[0], utlstr); /* If not found check for old metadata */ /* ----------------------------------- */ if (metaptrs[0] == NULL) { snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%.480s%s", "OBJECT=\"", name, "\"\n"); metaptrs[0] = strstr(oldmetaptr, utlstr); } /* Get field list and strip off leading and trailing quotes */ EHgetmetavalue(metaptrs, "FieldList", name); /* not return status --xhua */ memmove(name, name + 1, strlen(name) - 2); name[strlen(name) - 2] = 0; /* Search for desired field within merged field list */ snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s%s", "\"", fieldname, "\""); dum = EHstrwithin(utlstr, name, ','); free(metabuf); } else { /* If solo (unmerged) check if SDS name matches fieldname */ /* ------------------------------------------------------ */ dum = EHstrwithin(fieldname, name, ','); if (dum != -1) { *solo = 1; *offset = 0; } } /* If field found ... */ /* ------------------ */ if (dum != -1) { status = 0; /* If merged field ... */ /* ------------------- */ if (*solo == 0) { /* Get "Field Offsets" SDS attribute l_index */ /* --------------------------------------- */ attrIndex = SDfindattr(*sdid, "Field Offsets"); /* * If attribute exists then get offset of desired field * within merged field */ if (attrIndex != -1) { SDreadattr(*sdid, attrIndex, (VOIDP) dums); *offset = dums[dum]; } /* Get "Field Dims" SDS attribute l_index */ /* ------------------------------------ */ attrIndex = SDfindattr(*sdid, "Field Dims"); /* * If attribute exists then get 0th dimension of desired * field within merged field */ if (attrIndex != -1) { SDreadattr(*sdid, attrIndex, (VOIDP) dums); dims[0] = dums[dum]; /* If this dimension = 1 then field is really 2 dim */ /* ------------------------------------------------ */ if (dums[dum] == 1) { *rankFld = 2; } } } /* Break out of SDS loop */ /* --------------------- */ break; } /* End of found field section */ } else { /* First non-active SDS signifies no more, break out of SDS loop */ /* ------------------------------------------------------------- */ break; } } free(utlstr); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWwrrdfield | | | | DESCRIPTION: Writes/Reads fields | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname const char fieldname | | code const char Write/Read code (w/r) | | start int32 start array | | stride int32 stride array | | edge int32 edge array | | datbuf void data buffer for read | | | | | | OUTPUTS: | | datbuf void data buffer for write | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Feb 97 Joel Gales Stride = 1 HDF compression workaround | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static intn SWwrrdfield(int32 swathID, const char *fieldname, const char *code, int32 start[], int32 stride[], int32 edge[], VOIDP datbuf) { intn i; /* Loop index */ intn status = 0; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 vgid; /* Swath Geo or Data Vgroup ID */ int32 sdid; /* SDS ID */ int32 dum; /* Dummy variable */ int32 rankSDS; /* Rank of SDS */ int32 rankFld; /* Rank of field */ int32 vdataID; /* 1d field vdata */ int32 recsize; /* Vdata record size */ int32 fldsize; /* Field size */ int32 nrec; /* Number of records in Vdata */ int32 offset[8]; /* I/O offset (start) */ int32 incr[8]; /* I/O increment (stride) */ int32 count[8]; /* I/O count (edge) */ int32 dims[8]; /* Field/SDS dimensions */ int32 mrgOffset; /* Merged field offset */ int32 nflds; /* Number of fields in Vdata */ int32 strideOne; /* Strides = 1 flag */ uint8 *buf; /* I/O (transfer) buffer */ uint8 *fillbuf; /* Fill value buffer */ char attrName[80]; /* Name of fill value attribute */ char *ptr[64]; /* String pointer array */ char fieldlist[256]; /* Vdata field list */ /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWwrrdfield", &fid, &sdInterfaceID, &dum); if (status == 0) { /* Check whether fieldname is in SDS (multi-dim field) */ /* --------------------------------------------------- */ status = SWSDfldsrch(swathID, sdInterfaceID, fieldname, &sdid, &rankSDS, &rankFld, &mrgOffset, dims, &dum); /* Multi-Dimensional Field Section */ /* ------------------------------- */ if (status != -1) { /* Set I/O offset Section */ /* ---------------------- */ /* * If start == NULL (default) set I/O offset of 0th field to * offset within merged field (if any) and the rest to 0 */ if (start == NULL) { for (i = 0; i < rankSDS; i++) { offset[i] = 0; } offset[0] = mrgOffset; } else { /* * ... otherwise set I/O offset to user values, adjusting the * 0th field with the merged field offset (if any) */ if (rankFld == rankSDS) { for (i = 0; i < rankSDS; i++) { offset[i] = start[i]; } offset[0] += mrgOffset; } else { /* * If field really 2-dim merged in 3-dim field then set * 0th field offset to merge offset and then next two to * the user values */ for (i = 0; i < rankFld; i++) { offset[i + 1] = start[i]; } offset[0] = mrgOffset; } } /* Set I/O stride Section */ /* ---------------------- */ /* * If stride == NULL (default) set I/O stride to 1 */ if (stride == NULL) { for (i = 0; i < rankSDS; i++) { incr[i] = 1; } } else { /* * ... otherwise set I/O stride to user values */ if (rankFld == rankSDS) { for (i = 0; i < rankSDS; i++) { incr[i] = stride[i]; } } else { /* * If field really 2-dim merged in 3-dim field then set * 0th field stride to 1 and then next two to the user * values. */ for (i = 0; i < rankFld; i++) { incr[i + 1] = stride[i]; } incr[0] = 1; } } /* Set I/O count Section */ /* --------------------- */ /* * If edge == NULL (default) set I/O count to number of remaining * entries (dims - start) / increment. Note that 0th field * offset corrected for merged field offset (if any). */ if (edge == NULL) { for (i = 1; i < rankSDS; i++) { count[i] = (dims[i] - offset[i]) / incr[i]; } count[0] = (dims[0] - (offset[0] - mrgOffset)) / incr[0]; } else { /* * ... otherwise set I/O count to user values */ if (rankFld == rankSDS) { for (i = 0; i < rankSDS; i++) { count[i] = edge[i]; } } else { /* * If field really 2-dim merged in 3-dim field then set * 0th field count to 1 and then next two to the user * values. */ for (i = 0; i < rankFld; i++) { count[i + 1] = edge[i]; } count[0] = 1; } } /* Perform I/O with relevant HDF I/O routine */ /* ----------------------------------------- */ if (strcmp(code, "w") == 0) { /* Set strideOne to true (1) */ /* ------------------------- */ strideOne = 1; /* If incr[i] != 1 set strideOne to false (0) */ /* ------------------------------------------ */ for (i = 0; i < rankSDS; i++) { if (incr[i] != 1) { strideOne = 0; break; } } /* * If strideOne is true use NULL parameter for stride. This * is a work-around to HDF compression problem */ if (strideOne == 1) { status = SDwritedata(sdid, offset, NULL, count, (VOIDP) datbuf); } else { status = SDwritedata(sdid, offset, incr, count, (VOIDP) datbuf); } } else { status = SDreaddata(sdid, offset, incr, count, (VOIDP) datbuf); } } /* End of Multi-Dimensional Field Section */ else { /* One-Dimensional Field Section */ /* ----------------------------- */ /* Check fieldname within 1d field Vgroups */ /* --------------------------------------- */ status = SW1dfldsrch(fid, swathID, fieldname, code, &vgid, &vdataID, &dum); if (status != -1) { /* Get number of records */ /* --------------------- */ nrec = VSelts(vdataID); /* Set offset, increment, & count */ /* ------------------------------ */ offset[0] = (start == NULL) ? 0 : start[0]; incr[0] = (stride == NULL) ? 1 : stride[0]; count[0] = (edge == NULL) ? (nrec - offset[0]) / incr[0] : edge[0]; /* Write Section */ /* ------------- */ if (strcmp(code, "w") == 0) { /* Get size of field and setup fill buffer */ /* --------------------------------------- */ fldsize = VSsizeof(vdataID, (char *)fieldname); fillbuf = (uint8 *) calloc(fldsize, 1); if(fillbuf == NULL) { HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__); return(-1); } /* Get size of record in Vdata and setup I/O buffer */ /* ------------------------------------------------ */ VSQueryvsize(vdataID, &recsize); buf = (uint8 *) calloc(recsize, count[0] * incr[0]); if(buf == NULL) { HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__); return(-1); } /* Get names and number of fields in each record */ /* ---------------------------------------------- */ VSgetfields(vdataID, fieldlist); dum = EHstrwithin(fieldname, fieldlist, ','); nflds = EHparsestr(fieldlist, ',', ptr, NULL); /* Get Merged Field Offset (if any) */ /* -------------------------------- */ if (nflds > 1) { if (dum > 0) { *(ptr[dum] - 1) = 0; mrgOffset = VSsizeof(vdataID, fieldlist); *(ptr[dum] - 1) = ','; } else { mrgOffset = 0; } /* Read records to recover previously written data */ /* status = */ VSsetfields(vdataID, fieldlist); /* status = */ VSseek(vdataID, offset[0]); nrec = VSread(vdataID, buf, count[0] * incr[0], FULL_INTERLACE); } else { mrgOffset = 0; } /* Fill buffer with "Fill" value (if any) */ /* -------------------------------------- */ snprintf( attrName, sizeof(attrName), "_FV_%s", fieldname); status = SWreadattr(swathID, attrName, (char *) fillbuf); if (status == 0) { for (i = 0; i < count[0] * incr[0]; i++) { memcpy(buf + i * recsize + mrgOffset, fillbuf, fldsize); } } /* Write new data into buffer */ /* -------------------------- */ if (incr[0] == 1 && nflds == 1) { memcpy(buf, datbuf, count[0] * recsize); } else { for (i = 0; i < count[0]; i++) { memcpy(buf + i * recsize * incr[0] + mrgOffset, (uint8 *) datbuf + i * fldsize, fldsize); } } /* If append read last record */ /* -------------------------- */ if (offset[0] == nrec) { /* abe added "status =" to next line 8/8/97 */ status = VSseek(vdataID, offset[0] - 1); VSread(vdataID, fillbuf, 1, FULL_INTERLACE); } else { status = VSseek(vdataID, offset[0]); } /* Write data into Vdata */ /* --------------------- */ nrec = VSwrite(vdataID, buf, count[0] * incr[0], FULL_INTERLACE); free(fillbuf); if (status > 0) status = 0; } /* End Write Section */ else { /* Read Section */ /* ------------ */ status = VSsetfields(vdataID, fieldname); fldsize = VSsizeof(vdataID, (char *)fieldname); buf = (uint8 *) calloc(fldsize, count[0] * incr[0]); if(buf == NULL) { HEpush(DFE_NOSPACE,"SWwrrdfield", __FILE__, __LINE__); return(-1); } (void) VSseek(vdataID, offset[0]); (void) VSread(vdataID, buf, count[0] * incr[0], FULL_INTERLACE); /* Copy from input buffer to returned data buffer */ /* ---------------------------------------------- */ if (incr[0] == 1) { memcpy(datbuf, buf, count[0] * fldsize); } else { for (i = 0; i < count[0]; i++) { memcpy((uint8 *) datbuf + i * fldsize, buf + i * fldsize * incr[0], fldsize); } } } /* End Read Section */ free(buf); VSdetach(vdataID); } else { HEpush(DFE_GENAPP, "SWwrrdfield", __FILE__, __LINE__); HEreport("Fieldname \"%s\" does not exist.\n", fieldname); } } /* End One-D Field Section */ } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWwritefield | | | | DESCRIPTION: Writes data to field | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname char fieldname | | start int32 start array | | stride int32 stride array | | edge int32 edge array | | | | | | OUTPUTS: | | data void data buffer for write | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWwritefield(int32 swathID, const char *fieldname, int32 start[], int32 stride[], int32 edge[], VOIDP data) { intn status = 0; /* routine return status variable */ status = SWwrrdfield(swathID, fieldname, "w", start, stride, edge, data); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWreadfield | | | | DESCRIPTION: Reads data from field | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname const char fieldname | | start int32 start array | | stride int32 stride array | | edge int32 edge array | | buffer void data buffer for read | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWreadfield(int32 swathID, const char *fieldname, int32 start[], int32 stride[], int32 edge[], VOIDP buffer) { intn status = 0; /* routine return status variable */ status = SWwrrdfield(swathID, fieldname, "r", start, stride, edge, buffer); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefboxregion | | | | DESCRIPTION: Finds swath cross tracks within area of interest and returns | | region ID | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | regionID int32 Region ID | | | | INPUTS: | | swathID int32 Swath structure ID | | cornerlon float64 dec deg Longitude of opposite corners of box | | cornerlat float64 dec deg Latitude of opposite corners of box | | mode int32 Search mode | | HDFE_MIDPOINT - Use midpoint of Xtrack | | HDFE_ENDPOINT - Use endpoints of Xtrack | | HDFE_ANYPOINT - Use all points of Xtrack| | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Oct 96 Joel Gales Add ability to handle regions crossing date line | | Dec 96 Joel Gales Add multiple vertical subsetting capability | | Jul 98 Abe Taaheri Fixed core dump in SWregioninfo associated with | | SWXRegion[k]->nRegions exceeding MAXNREGIONS in | | this function | | Aug 99 Abe Taaheri Fixed the code so that all cross tracks or all | | points on the along track that fall inside the box | | are identified. At the same time added code to | | function "updatescene" to reject cases where there | | is single cross track in the box (for LANDSAT) | | Jun 03 Abe Taaheri Added a few lines to report error and return -1 if | | regionID exceeded NSWATHREGN | | Mar 04 Abe Taaheri Added recognition for GeodeticLatitude | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWdefboxregion(int32 swathID, float64 cornerlon[], float64 cornerlat[], int32 mode) { intn i; /* Loop index */ intn j = 0; /* Loop index */ intn k; /* Loop index */ intn status; /* routine return status variable */ intn statLon; /* Status from SWfieldinfo for longitude */ intn statLat; /* Status from SWfieldinfo for latitude */ intn statCoLat = -1; /* Status from SWfieldinfo for * Colatitude */ intn statGeodeticLat = -1; /* Status from SWfieldinfo for * GeodeticLatitude */ uint8 found = 0; /* Found flag */ uint8 *flag; /* Pointer to track flag array */ intn validReg = -1; /* -1 is invalid validReg */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 rank; /* Rank of geolocation fields */ int32 nt; /* Number type of geolocation fields */ int32 dims[8]; /* Dimensions of geolocation fields */ int32 nElem; /* Number of elements to read */ int32 bndflag; /* +/-180 longitude boundary flag */ int32 lonTest; /* Longitude test flag */ int32 latTest; /* Latitude test flag */ int32 start[2]; /* Start array (read) */ int32 stride[2] = {1, 1}; /* Stride array (read) */ int32 edge[2]; /* Edge array (read) */ int32 regionID = -1; /* Region ID (return) */ int32 anyStart[2];/* ANYPOINT start array (read) */ int32 anyEdge[2]; /* ANYPOINT edge array (read) */ float32 temp32; /* Temporary float32 variable */ float64 lonTestVal; /* Longitude test value */ float64 latTestVal; /* Latitude test value */ float64 temp64; /* Temporary float64 variable */ char *lonArr; /* Longitude data array */ char *latArr; /* Latitude data array */ char dimlist[256]; /* Dimension list (geolocation * fields) */ char latName[17];/* Latitude field name */ /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWdefboxregion", &fid, &sdInterfaceID, &swVgrpID); /* Inclusion mode must be between 0 and 2 */ /* -------------------------------------- */ if (mode < 0 || mode > 2) { status = -1; HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__); HEreport("Improper Inclusion Mode: %d.\n", mode); } if (status == 0) { /* Get "Longitude" field info */ /* -------------------------- */ statLon = SWfieldinfo(swathID, "Longitude", &rank, dims, &nt, dimlist); if (statLon != 0) { status = -1; HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__); HEreport("\"Longitude\" field not found.\n"); } /* Get "Latitude" field info */ /* -------------------------- */ statLat = SWfieldinfo(swathID, "Latitude", &rank, dims, &nt, dimlist); if (statLat != 0) { /* If not found check for "Colatitude" field info */ /* ---------------------------------------------- */ statCoLat = SWfieldinfo(swathID, "Colatitude", &rank, dims, &nt, dimlist); if (statCoLat != 0) { /* Check again for Geodeticlatitude */ statGeodeticLat = SWfieldinfo(swathID, "GeodeticLatitude", &rank, dims, &nt, dimlist); if (statGeodeticLat != 0) { /* Neither "Latitude" nor "Colatitude" nor "GeodeticLatitude" field found */ /* ----------------------------------------------- */ status = -1; HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__); HEreport( "Neither \"Latitude\" nor \"Colatitude\" nor \"GeodeticLatitude\" fields found.\n"); } else { /* Latitude field is "GeodeticLatitude" */ /* ------------------------------ */ strcpy(latName, "GeodeticLatitude"); } } else { /* Latitude field is "Colatitude" */ /* ------------------------------ */ strcpy(latName, "Colatitude"); } } else { /* Latitude field is "Latitude" */ /* ---------------------------- */ strcpy(latName, "Latitude"); } if (status == 0) { /* Search along entire "Track" dimension from beginning to end */ /* ----------------------------------------------------------- */ start[0] = 0; edge[0] = dims[0]; /* If 1D geolocation fields then set mode to MIDPOINT */ /* -------------------------------------------------- */ if (rank == 1) { mode = HDFE_MIDPOINT; } switch (mode) { /* If MIDPOINT search single point in middle of "CrossTrack" */ /* --------------------------------------------------------- */ case HDFE_MIDPOINT: start[1] = dims[1] / 2; edge[1] = 1; break; /* If ENDPOINT search 2 points at either end of "CrossTrack" */ /* --------------------------------------------------------- */ case HDFE_ENDPOINT: start[1] = 0; stride[1] = dims[1] - 1; edge[1] = 2; break; /* If ANYPOINT do initial MIDPOINT search */ /* -------------------------------------- */ case HDFE_ANYPOINT: start[1] = dims[1] / 2; edge[1] = 1; break; } /* Compute number of elements */ /* -------------------------- */ nElem = edge[0] * edge[1]; /* Allocate space for longitude and latitude (float64) */ /* --------------------------------------------------- */ lonArr = (char *) calloc(nElem, sizeof(float64)); if(lonArr == NULL) { HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__); return(-1); } latArr = (char *) calloc(nElem, sizeof(float64)); if(latArr == NULL) { HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__); free(lonArr); return(-1); } /* Allocate space for flag array (uint8) */ /* ------------------------------------- */ flag = (uint8 *) calloc(edge[0] + 1, 1); if(flag == NULL) { HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__); free(lonArr); free(latArr); return(-1); } /* Read Longitude and Latitude fields */ /* ---------------------------------- */ status = SWreadfield(swathID, "Longitude", start, stride, edge, lonArr); status = SWreadfield(swathID, latName, start, stride, edge, latArr); /* * If geolocation fields are FLOAT32 then cast each entry as * FLOAT64 */ if (nt == DFNT_FLOAT32) { for (i = nElem - 1; i >= 0; i--) { memcpy(&temp32, lonArr + 4 * i, 4); temp64 = (float64) temp32; memcpy(lonArr + 8 * i, &temp64, 8); memcpy(&temp32, latArr + 4 * i, 4); temp64 = (float64) temp32; memcpy(latArr + 8 * i, &temp64, 8); } } /* Set boundary flag */ /* ----------------- */ /* * This variable is set to 1 if the region of interest crosses * the +/- 180 longitude boundary */ bndflag = (cornerlon[0] < cornerlon[1]) ? 0 : 1; /* Main Search Loop */ /* ---------------- */ /* For each track ... */ /* ------------------ */ for (i = 0; i < edge[0]; i++) { /* For each value from Cross Track ... */ /* ----------------------------------- */ for (j = 0; j < edge[1]; j++) { /* Read in single lon & lat values from data buffers */ /* ------------------------------------------------- */ memcpy(&lonTestVal, &lonArr[8 * (i * edge[1] + j)], 8); memcpy(&latTestVal, &latArr[8 * (i * edge[1] + j)], 8); /* If longitude value > 180 convert to -180 to 180 range */ /* ----------------------------------------------------- */ if (lonTestVal > 180) { lonTestVal = lonTestVal - 360; } /* If Colatitude value convert to latitude value */ /* --------------------------------------------- */ if (statCoLat == 0) { latTestVal = 90 - latTestVal; } /* Test if lat value is within range */ /* --------------------------------- */ latTest = (latTestVal >= cornerlat[0] && latTestVal <= cornerlat[1]); if (bndflag == 1) { /* * If boundary flag set test whether longitude value * is outside region and then flip */ lonTest = (lonTestVal >= cornerlon[1] && lonTestVal <= cornerlon[0]); lonTest = 1 - lonTest; } else { lonTest = (lonTestVal >= cornerlon[0] && lonTestVal <= cornerlon[1]); } /* * If both longitude and latitude are within region set * flag on for this track */ if (lonTest + latTest == 2) { flag[i] = 1; found = 1; break; } } } /* ANYPOINT search */ /* --------------- */ if (mode == HDFE_ANYPOINT && rank > 1) { free(lonArr); free(latArr); /* Allocate space for an entire single cross track */ /* ----------------------------------------------- */ lonArr = (char *) calloc(dims[1], sizeof(float64)); if(lonArr == NULL) { HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__); return(-1); } latArr = (char *) calloc(dims[1], sizeof(float64)); if(latArr == NULL) { HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__); free(lonArr); return(-1); } /* Setup start and edge */ /* -------------------- */ anyStart[1] = 0; anyEdge[0] = 1; anyEdge[1] = dims[1]; /* For each track starting from 0 */ /* ------------------------------ */ for (i = 0; i < edge[0]; i++) { /* If cross track not in region (with MIDPOINT search ... */ /* ------------------------------------------------------ */ if (flag[i] == 0) { /* Setup track start */ /* ----------------- */ anyStart[0] = i; /* Read in lon and lat values for cross track */ /* ------------------------------------------ */ status = SWreadfield(swathID, "Longitude", anyStart, NULL, anyEdge, lonArr); status = SWreadfield(swathID, latName, anyStart, NULL, anyEdge, latArr); /* * If geolocation fields are FLOAT32 then cast each * entry as FLOAT64 */ if (nt == DFNT_FLOAT32) { for (j = dims[1] - 1; j >= 0; j--) { memcpy(&temp32, lonArr + 4 * j, 4); temp64 = (float64) temp32; memcpy(lonArr + 8 * j, &temp64, 8); memcpy(&temp32, latArr + 4 * j, 4); temp64 = (float64) temp32; memcpy(latArr + 8 * j, &temp64, 8); } } /* For each value from Cross Track ... */ /* ----------------------------------- */ for (j = 0; j < dims[1]; j++) { /* Read in single lon & lat values from buffers */ /* -------------------------------------------- */ memcpy(&lonTestVal, &lonArr[8 * j], 8); memcpy(&latTestVal, &latArr[8 * j], 8); /* If lon value > 180 convert to -180 - 180 range */ /* ---------------------------------------------- */ if (lonTestVal > 180) { lonTestVal = lonTestVal - 360; } /* If Colatitude value convert to latitude value */ /* --------------------------------------------- */ if (statCoLat == 0) { latTestVal = 90 - latTestVal; } /* Test if lat value is within range */ /* --------------------------------- */ latTest = (latTestVal >= cornerlat[0] && latTestVal <= cornerlat[1]); if (bndflag == 1) { /* * If boundary flag set test whether * longitude value is outside region and then * flip */ lonTest = (lonTestVal >= cornerlon[1] && lonTestVal <= cornerlon[0]); lonTest = 1 - lonTest; } else { lonTest = (lonTestVal >= cornerlon[0] && lonTestVal <= cornerlon[1]); } /* * If both longitude and latitude are within * region set flag on for this track */ if (lonTest + latTest == 2) { flag[i] = 1; found = 1; break; } } } } } /* If within region setup Region Structure */ /* --------------------------------------- */ if (found == 1) { /* For all entries in SWXRegion array ... */ /* -------------------------------------- */ for (k = 0; k < NSWATHREGN; k++) { /* If empty region ... */ /* ------------------- */ if (SWXRegion[k] == 0) { /* Allocate space for region entry */ /* ------------------------------- */ SWXRegion[k] = (struct swathRegion *) calloc(1, sizeof(struct swathRegion)); if(SWXRegion[k] == NULL) { HEpush(DFE_NOSPACE,"SWdefboxregion", __FILE__, __LINE__); return(-1); } /* Store file and swath ID */ /* ----------------------- */ SWXRegion[k]->fid = fid; SWXRegion[k]->swathID = swathID; /* Set Start & Stop Vertical arrays to -1 */ /* -------------------------------------- */ for (j = 0; j < 8; j++) { SWXRegion[k]->StartVertical[j] = -1; SWXRegion[k]->StopVertical[j] = -1; SWXRegion[k]->StartScan[j] = -1; SWXRegion[k]->StopScan[j] = -1; } /* Set region ID */ /* ------------- */ regionID = k; break; } } if (k >= NSWATHREGN) { HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__); HEreport( "regionID exceeded NSWATHREGN.\n"); return (-1); } /* Find start and stop of regions */ /* ------------------------------ */ /* Subtract previous flag value from current one */ /* --------------------------------------------- */ /* * Transition points will have flag value (+1) start or * (255 = (uint8) -1) stop of region */ for (i = edge[0]; i > 0; i--) { flag[i] -= flag[i - 1]; } for (i = 0; i <= edge[0]; i++) { /* Start of region */ /* --------------- */ if (flag[i] == 1) { /* Increment (multiple) region counter */ /* ----------------------------------- */ j = ++SWXRegion[k]->nRegions; /* if SWXRegion[k]->nRegions greater than MAXNREGIONS */ /* free allocated memory and return FAIL */ if ((SWXRegion[k]->nRegions) > MAXNREGIONS) { HEpush(DFE_GENAPP, "SWdefboxregion", __FILE__, __LINE__); HEreport("SWXRegion[%d]->nRegions exceeds MAXNREGIONS= %d.\n", k, MAXNREGIONS); free(lonArr); free(latArr); free(flag); return(-1); } SWXRegion[k]->StartRegion[j - 1] = i; } /* End of region */ /* ------------- */ if (flag[i] == 255) { SWXRegion[k]->StopRegion[j - 1] = i - 1; validReg = 0; } } } free(lonArr); free(latArr); free(flag); } } if(validReg==0) { return (regionID); } else { return (-1); } } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWregionl_index | | | | DESCRIPTION: Finds swath cross tracks within area of interest and returns | | region l_index and region ID | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | regionID int32 Region ID | | | | INPUTS: | | swathID int32 Swath structure ID | | cornerlon float64 dec deg Longitude of opposite corners of box | | cornerlat float64 dec deg Latitude of opposite corners of box | | mode int32 Search mode | | HDFE_MIDPOINT - Use midpoint of Xtrack | | HDFE_ENDPOINT - Use endpoints of Xtrack | | HDFE_ANYPOINT - Use all points of Xtrack| | | | OUTPUTS: | | geodim char geolocation track dimension | | idxrange int32 indices of region for along track dim. | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Oct 96 Joel Gales Add ability to handle regions crossing date line | | Dec 96 Joel Gales Add multiple vertical subsetting capability | | Nov 97 Daw Add multiple vertical subsetting capability | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWregionindex(int32 swathID, float64 cornerlon[], float64 cornerlat[], int32 mode, char *geodim, int32 idxrange[]) { intn i; /* Loop index */ intn j; /* Loop index */ intn k; /* Loop index */ intn l=0; /* Loop index */ intn tmpVal = 0; /* temp value for start region Delyth Jones*/ /*intn j1; */ /* Loop index */ intn status; /* routine return status variable */ intn mapstatus; /* status for type of mapping */ intn statLon; /* Status from SWfieldinfo for longitude */ intn statLat; /* Status from SWfieldinfo for latitude */ intn statCoLat = -1; /* Status from SWfieldinfo for * Colatitude */ intn statGeodeticLat = -1; /* Status from SWfieldinfo for * GeodeticLatitude */ uint8 found = 0; /* Found flag */ uint8 *flag; /* Pointer to track flag array */ intn validReg = -1; /* -1 is invalid validReg */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 rank; /* Rank of geolocation fields */ int32 nt; /* Number type of geolocation fields */ int32 dims[8]; /* Dimensions of geolocation fields */ int32 nElem; /* Number of elements to read */ int32 bndflag; /* +/-180 longitude boundary flag */ int32 lonTest; /* Longitude test flag */ int32 latTest; /* Latitude test flag */ int32 start[2]; /* Start array (read) */ int32 stride[2] = {1, 1}; /* Stride array (read) */ int32 edge[2]; /* Edge array (read) */ int32 regionID = -1; /* Region ID (return) */ int32 anyStart[2];/* ANYPOINT start array (read) */ int32 anyEdge[2]; /* ANYPOINT edge array (read) */ float32 temp32; /* Temporary float32 variable */ float64 lonTestVal; /* Longitude test value */ float64 latTestVal; /* Latitude test value */ float64 temp64; /* Temporary float64 variable */ char *lonArr; /* Longitude data array */ char *latArr; /* Latitude data array */ char dimlist[256]; /* Dimension list (geolocation * fields) */ char latName[17];/* Latitude field name */ /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWregionl_index", &fid, &sdInterfaceID, &swVgrpID); /* Inclusion mode must be between 0 and 2 */ /* -------------------------------------- */ if (mode < 0 || mode > 2) { status = -1; HEpush(DFE_GENAPP, "SWregionl_index", __FILE__, __LINE__); HEreport("Improper Inclusion Mode: %d.\n", mode); } if (status == 0) { /* Get "Longitude" field info */ /* -------------------------- */ statLon = SWfieldinfo(swathID, "Longitude", &rank, dims, &nt, dimlist); if (statLon != 0) { status = -1; HEpush(DFE_GENAPP, "SWregionl_index", __FILE__, __LINE__); HEreport("\"Longitude\" field not found.\n"); } /* Get "Latitude" field info */ /* -------------------------- */ statLat = SWfieldinfo(swathID, "Latitude", &rank, dims, &nt, dimlist); if (statLat != 0) { /* If not found check for "Colatitude" field info */ /* ---------------------------------------------- */ statCoLat = SWfieldinfo(swathID, "Colatitude", &rank, dims, &nt, dimlist); if (statCoLat != 0) { /* Check again for Geodeticlatitude */ statGeodeticLat = SWfieldinfo(swathID, "GeodeticLatitude", &rank, dims, &nt, dimlist); if (statGeodeticLat != 0) { /* Neither "Latitude" nor "Colatitude" field found */ /* ----------------------------------------------- */ status = -1; HEpush(DFE_GENAPP, "SWregionl_index", __FILE__, __LINE__); HEreport( "Neither \"Latitude\" nor \"Colatitude\" fields found.\n"); } else { /* Latitude field is "Colatitude" */ /* ------------------------------ */ strcpy(latName, "GeodeticLatitude"); } } else { /* Latitude field is "Colatitude" */ /* ------------------------------ */ strcpy(latName, "Colatitude"); } } else { /* Latitude field is "Latitude" */ /* ---------------------------- */ strcpy(latName, "Latitude"); } /* This line modifies the dimlist variable so only the along-track */ /* dimension remains. */ /* --------------------------------------------------------------- */ (void) strtok(dimlist,","); mapstatus = SWgeomapinfo(swathID,dimlist); (void) strcpy(geodim,dimlist); if (status == 0) { /* Search along entire "Track" dimension from beginning to end */ /* ----------------------------------------------------------- */ start[0] = 0; edge[0] = dims[0]; /* If 1D geolocation fields then set mode to MIDPOINT */ /* -------------------------------------------------- */ if (rank == 1) { mode = HDFE_MIDPOINT; } switch (mode) { /* If MIDPOINT search single point in middle of "CrossTrack" */ /* --------------------------------------------------------- */ case HDFE_MIDPOINT: start[1] = dims[1] / 2; edge[1] = 1; break; /* If ENDPOINT search 2 points at either end of "CrossTrack" */ /* --------------------------------------------------------- */ case HDFE_ENDPOINT: start[1] = 0; stride[1] = dims[1] - 1; edge[1] = 2; break; /* If ANYPOINT do initial MIDPOINT search */ /* -------------------------------------- */ case HDFE_ANYPOINT: start[1] = dims[1] / 2; edge[1] = 1; break; } /* Compute number of elements */ /* -------------------------- */ nElem = edge[0] * edge[1]; /* Allocate space for longitude and latitude (float64) */ /* --------------------------------------------------- */ lonArr = (char *) calloc(nElem, sizeof(float64)); if(lonArr == NULL) { HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__); return(-1); } latArr = (char *) calloc(nElem, sizeof(float64)); if(latArr == NULL) { HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__); free(lonArr); return(-1); } /* Allocate space for flag array (uint8) */ /* ------------------------------------- */ flag = (uint8 *) calloc(edge[0] + 1, 1); if(flag == NULL) { HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__); free(lonArr); free(latArr); return(-1); } /* Read Longitude and Latitude fields */ /* ---------------------------------- */ status = SWreadfield(swathID, "Longitude", start, stride, edge, lonArr); status = SWreadfield(swathID, latName, start, stride, edge, latArr); /* * If geolocation fields are FLOAT32 then cast each entry as * FLOAT64 */ if (nt == DFNT_FLOAT32) { for (i = nElem - 1; i >= 0; i--) { memcpy(&temp32, lonArr + 4 * i, 4); temp64 = (float64) temp32; memcpy(lonArr + 8 * i, &temp64, 8); memcpy(&temp32, latArr + 4 * i, 4); temp64 = (float64) temp32; memcpy(latArr + 8 * i, &temp64, 8); } } /* Set boundary flag */ /* ----------------- */ /* * This variable is set to 1 if the region of interest crosses * the +/- 180 longitude boundary */ bndflag = (cornerlon[0] < cornerlon[1]) ? 0 : 1; /* Main Search Loop */ /* ---------------- */ /* For each track ... */ /* ------------------ */ for (i = 0; i < edge[0]; i++) { /* For each value from Cross Track ... */ /* ----------------------------------- */ for (j = 0; j < edge[1]; j++) { /* Read in single lon & lat values from data buffers */ /* ------------------------------------------------- */ memcpy(&lonTestVal, &lonArr[8 * (i * edge[1] + j)], 8); memcpy(&latTestVal, &latArr[8 * (i * edge[1] + j)], 8); /* If longitude value > 180 convert to -180 to 180 range */ /* ----------------------------------------------------- */ if (lonTestVal > 180) { lonTestVal = lonTestVal - 360; } /* If Colatitude value convert to latitude value */ /* --------------------------------------------- */ if (statCoLat == 0) { latTestVal = 90 - latTestVal; } /* Test if lat value is within range */ /* --------------------------------- */ latTest = (latTestVal >= cornerlat[0] && latTestVal <= cornerlat[1]); if (bndflag == 1) { /* * If boundary flag set test whether longitude value * is outside region and then flip */ lonTest = (lonTestVal >= cornerlon[1] && lonTestVal <= cornerlon[0]); lonTest = 1 - lonTest; } else { lonTest = (lonTestVal >= cornerlon[0] && lonTestVal <= cornerlon[1]); } /* * If both longitude and latitude are within region set * flag on for this track */ if (lonTest + latTest == 2) { flag[i] = 1; found = 1; break; } } } /* ANYPOINT search */ /* --------------- */ if (mode == HDFE_ANYPOINT && rank > 1) { free(lonArr); free(latArr); /* Allocate space for an entire single cross track */ /* ----------------------------------------------- */ lonArr = (char *) calloc(dims[1], sizeof(float64)); if(lonArr == NULL) { HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__); return(-1); } latArr = (char *) calloc(dims[1], sizeof(float64)); if(latArr == NULL) { HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__); free(lonArr); return(-1); } /* Setup start and edge */ /* -------------------- */ anyStart[1] = 0; anyEdge[0] = 1; anyEdge[1] = dims[1]; /* For each track ... */ /* ------------------ */ for (i = 0; i < edge[0]; i++) { /* If cross track not in region (with MIDPOINT search ... */ /* ------------------------------------------------------ */ if (flag[i] == 0) { /* Setup track start */ /* ----------------- */ anyStart[0] = i; /* Read in lon and lat values for cross track */ /* ------------------------------------------ */ status = SWreadfield(swathID, "Longitude", anyStart, NULL, anyEdge, lonArr); status = SWreadfield(swathID, latName, anyStart, NULL, anyEdge, latArr); /* * If geolocation fields are FLOAT32 then cast each * entry as FLOAT64 */ if (nt == DFNT_FLOAT32) { for (j = dims[1] - 1; j >= 0; j--) { memcpy(&temp32, lonArr + 4 * j, 4); temp64 = (float64) temp32; memcpy(lonArr + 8 * j, &temp64, 8); memcpy(&temp32, latArr + 4 * j, 4); temp64 = (float64) temp32; memcpy(latArr + 8 * j, &temp64, 8); } } /* For each value from Cross Track ... */ /* ----------------------------------- */ for (j = 0; j < dims[1]; j++) { /* Read in single lon & lat values from buffers */ /* -------------------------------------------- */ memcpy(&lonTestVal, &lonArr[8 * j], 8); memcpy(&latTestVal, &latArr[8 * j], 8); /* If lon value > 180 convert to -180 - 180 range */ /* ---------------------------------------------- */ if (lonTestVal > 180) { lonTestVal = lonTestVal - 360; } /* If Colatitude value convert to latitude value */ /* --------------------------------------------- */ if (statCoLat == 0) { latTestVal = 90 - latTestVal; } /* Test if lat value is within range */ /* --------------------------------- */ latTest = (latTestVal >= cornerlat[0] && latTestVal <= cornerlat[1]); if (bndflag == 1) { /* * If boundary flag set test whether * longitude value is outside region and then * flip */ lonTest = (lonTestVal >= cornerlon[1] && lonTestVal <= cornerlon[0]); lonTest = 1 - lonTest; } else { lonTest = (lonTestVal >= cornerlon[0] && lonTestVal <= cornerlon[1]); } /* * If both longitude and latitude are within * region set flag on for this track */ if (lonTest + latTest == 2) { flag[i] = 1; found = 1; break; } } } } } /* for (j1 = 0; j1 < edge[0]; j1++) { idxrange[j1] = (int32) flag[j1]; } */ /* If within region setup Region Structure */ /* --------------------------------------- */ if (found == 1) { /* For all entries in SWXRegion array ... */ /* -------------------------------------- */ for (k = 0; k < NSWATHREGN; k++) { /* If empty region ... */ /* ------------------- */ if (SWXRegion[k] == 0) { /* Allocate space for region entry */ /* ------------------------------- */ SWXRegion[k] = (struct swathRegion *) calloc(1, sizeof(struct swathRegion)); if(SWXRegion[k] == NULL) { HEpush(DFE_NOSPACE,"SWregionl_index", __FILE__, __LINE__); return(-1); } /* Store file and swath ID */ /* ----------------------- */ SWXRegion[k]->fid = fid; SWXRegion[k]->swathID = swathID; /* Set Start & Stop Vertical arrays to -1 */ /* -------------------------------------- */ for (j = 0; j < 8; j++) { SWXRegion[k]->StartVertical[j] = -1; SWXRegion[k]->StopVertical[j] = -1; SWXRegion[k]->StartScan[j] = -1; SWXRegion[k]->StopScan[j] = -1; } /* Set region ID */ /* ------------- */ regionID = k; break; } } if (k >= NSWATHREGN) { HEpush(DFE_GENAPP, "SWregionl_index", __FILE__, __LINE__); HEreport( "regionID exceeded NSWATHREGN.\n"); return (-1); } /* Find start and stop of regions */ /* ------------------------------ */ /* Subtract previous flag value from current one */ /* --------------------------------------------- */ /* * Transition points will have flag value (+1) start or * (255 = (uint8) -1) stop of region */ for (i = edge[0]; i > 0; i--) { flag[i] -= flag[i - 1]; } for (i = 0; i <= edge[0]; i++) { /* Start of region */ /* --------------- */ if (flag[i] == 1) { /* Delyth Jones Moved the increment of the region down to next if statement j = ++SWXRegion[k]->nRegions; */ /* using temp value, if not equal to stop region invalid region otherwise ok Delyth Jones */ tmpVal = i+1; } /* End of region */ /* ------------- */ if (flag[i] == 255) { if( tmpVal!=i ) { /* Increment (multiple) region counter */ /* ----------------------------------- */ j = ++SWXRegion[k]->nRegions; if (mapstatus == 2) { l = i; if ((tmpVal-1) % 2 == 1) { tmpVal = tmpVal + 1; } if ((l-1) % 2 == 0) { l = l - 1; } } SWXRegion[k]->StartRegion[j - 1] = tmpVal-1; idxrange[0] = tmpVal - 1; SWXRegion[k]->StopRegion[j - 1] = l - 1; idxrange[1] = l - 1; validReg = 0; } } } } free(lonArr); free(latArr); free(flag); } } if(validReg==0) { return (regionID); } else { return (-1); } } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdeftimeperiod | | | | DESCRIPTION: Finds swath cross tracks observed during time period and | | returns period ID | | | | region ID | | DESCRIPTION: | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | periodID int32 (Period ID) or (-1) if failed | | | | INPUTS: | | swathID int32 Swath structure ID | | starttime float64 TAI sec Start of time period | | stoptime float64 TAI sec Stop of time period | | mode int32 Search mode | | HDFE_MIDPOINT - Use midpoint of Xtrack | | HDFE_ENDPOINT - Use endpoints of Xtrack | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWdeftimeperiod(int32 swathID, float64 starttime, float64 stoptime, int32 mode) { intn i; /* Loop index */ intn j; /* Loop index */ intn k = 0; /* Loop index */ intn status; /* routine return status variable */ intn statTime; /* Status from SWfieldinfo for time */ uint8 found = 0; /* Found flag */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 rank; /* Rank of geolocation fields */ int32 nt; /* Number type of geolocation fields */ int32 dims[8]; /* Dimensions of geolocation fields */ int32 start[2]; /* Start array (read) */ int32 stride[2] = {1, 1}; /* Stride array (read) */ int32 edge[2]; /* Edge array (read) */ int32 periodID = -1; /* Period ID (return) */ int32 dum; /* Dummy (loop) variable */ float64 time64Test; /* Time test value */ float64 *time64 = NULL; /* Time data array */ char dimlist[256]; /* Dimension list (geolocation fields) */ /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWdeftimeperiod", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Get "Time" field info */ /* --------------------- */ statTime = SWfieldinfo(swathID, "Time", &rank, dims, &nt, dimlist); if (statTime != 0) { status = -1; HEpush(DFE_GENAPP, "SWdeftimeperiod", __FILE__, __LINE__); HEreport("\"Time\" field not found.\n"); } if (status == 0) { /* Search along entire "Track" dimension from beginning to end */ /* ----------------------------------------------------------- */ start[0] = 0; edge[0] = dims[0]; /* If 1D geolocation fields then set mode to MIDPOINT */ /* -------------------------------------------------- */ if (rank == 1) { mode = HDFE_MIDPOINT; } switch (mode) { /* If MIDPOINT search single point in middle of "CrossTrack" */ /* --------------------------------------------------------- */ case HDFE_MIDPOINT: start[1] = dims[1] / 2; edge[1] = 1; /* Allocate space for time data */ /* ---------------------------- */ time64 = (float64 *) calloc(edge[0], 8); if(time64 == NULL) { HEpush(DFE_NOSPACE,"SWdeftimeperiod", __FILE__, __LINE__); return(-1); } /* Read "Time" field */ /* ----------------- */ status = SWreadfield(swathID, "Time", start, NULL, edge, time64); break; /* If ENDPOINT search 2 points at either end of "CrossTrack" */ /* --------------------------------------------------------- */ case HDFE_ENDPOINT: start[1] = 0; stride[1] = dims[1] - 1; edge[1] = 2; /* Allocate space for time data */ /* ---------------------------- */ time64 = (float64 *) calloc(edge[0] * 2, 8); if(time64 == NULL) { HEpush(DFE_NOSPACE,"SWdeftimeperiod", __FILE__, __LINE__); return(-1); } /* Read "Time" field */ /* ----------------- */ status = SWreadfield(swathID, "Time", start, stride, edge, time64); break; } if (time64) { /* For each track (from top) ... */ /* ----------------------------- */ for (i = 0; i < edge[0]; i++) { /* For each value from Cross Track ... */ /* ----------------------------------- */ for (j = 0; j < edge[1]; j++) { /* Get time test value */ /* ------------------- */ time64Test = time64[i * edge[1] + j]; /* If within time period ... */ /* ------------------------- */ if (time64Test >= starttime && time64Test <= stoptime) { /* Set found flag */ /* -------------- */ found = 1; /* For all entries in SWXRegion array ... */ /* -------------------------------------- */ for (k = 0; k < NSWATHREGN; k++) { /* If empty region ... */ /* ------------------- */ if (SWXRegion[k] == 0) { /* Allocate space for region entry */ /* ------------------------------- */ SWXRegion[k] = (struct swathRegion *) calloc(1, sizeof(struct swathRegion)); if(SWXRegion[k] == NULL) { HEpush(DFE_NOSPACE,"SWdeftimeperiod", __FILE__, __LINE__); return(-1); } /* Store file and swath ID */ /* ----------------------- */ SWXRegion[k]->fid = fid; SWXRegion[k]->swathID = swathID; /* Set number of isolated regions to 1 */ /* ----------------------------------- */ SWXRegion[k]->nRegions = 1; /* Set start of region to first track found */ /* ---------------------------------------- */ SWXRegion[k]->StartRegion[0] = i; /* Set Start & Stop Vertical arrays to -1 */ /* -------------------------------------- */ for (dum = 0; dum < 8; dum++) { SWXRegion[k]->StartVertical[dum] = -1; SWXRegion[k]->StopVertical[dum] = -1; SWXRegion[k]->StartScan[dum] = -1; SWXRegion[k]->StopScan[dum] = -1; } /* Set period ID */ /* ------------- */ periodID = k; break; /* Break from "k" loop */ } } } if (found == 1) { break; /* Break from "j" loop */ } } if (found == 1) { break; /* Break from "i" loop */ } } /* Clear found flag */ /* ---------------- */ found = 0; /* For each track (from bottom) ... */ /* -------------------------------- */ for (i = edge[0] - 1; i >= 0; i--) { /* For each value from Cross Track ... */ /* ----------------------------------- */ for (j = 0; j < edge[1]; j++) { /* Get time test value */ /* ------------------- */ time64Test = time64[i * edge[1] + j]; /* If within time period ... */ /* ------------------------- */ if (time64Test >= starttime && time64Test <= stoptime) { /* Set found flag */ /* -------------- */ found = 1; /* Set start of region to first track found */ /* ---------------------------------------- */ SWXRegion[k]->StopRegion[0] = i; break; /* Break from "j" loop */ } } if (found == 1) { break; /* Break from "i" loop */ } } free(time64); } } } return (periodID); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWextractregion | | | | DESCRIPTION: Retrieves data from specified region. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 Swath structure ID | | regionID int32 Region ID | | fieldname char Fieldname | | externalflag int32 External geolocation fields flag | | HDFE_INTERNAL (0) | | HDFE_EXTERNAL (1) | | | | OUTPUTS: | | buffer void Data buffer containing subsetted region | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Add vertical subsetting | | Oct 96 Joel Gales Mapping offset value not read from SWmapinfo | | Dec 96 Joel Gales Vert Subset overwriting data buffer | | Dec 96 Joel Gales Add multiple vertical subsetting capability | | Mar 97 Joel Gales Add support for l_index mapping | | Jul 99 DaW Add support for floating scene subsetting | | Feb 03 Terry Haran/ | | Abe Taaheri Forced map offset to 0 so that data is extracted | | without offset consideration. This will preserve | | original mapping between geofields and the data | | field. | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWextractregion(int32 swathID, int32 regionID, const char *fieldname, int32 externalflag, VOIDP buffer) { intn i; /* Loop index */ intn j; /* Loop index */ intn k; /* Loop index */ intn l; /* Loop index */ intn status; /* routine return status variable */ intn long_status = 3; /* routine return status variable */ /* for longitude */ intn land_status = 3; /* Used for L7 float scene sub. */ intn statMap = -1; /* Status from SWmapinfo */ uint8 found = 0; /* Found flag */ uint8 vfound = 0; /* Found flag for vertical subsetting*/ /* --- xhua */ uint8 scene_cnt = 0; /* Used for L7 float scene sub. */ uint8 detect_cnt = 0; /* Used to convert scan to scanline */ /* L7 float scene sub. */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 numtype = 0; /* Used for L7 float scene sub. */ int32 count = 0; /* Used for L7 float scene sub. */ int32 l_index = 0; /* Geo Dim Index */ int32 nDim; /* Number of dimensions */ int32 slen[64]; /* String length array */ int32 dum; /* Dummy variable */ int32 offset = 0; /* Mapping offset */ int32 incr = 0; /* Mapping increment */ int32 nXtrk; /* Number of cross tracks */ int32 scan_shift = 0; /* Used to take out partial scans */ int32 dumdims[8]; /* Dimensions from SWfieldinfo */ int32 start[8]; /* Start array for data read */ int32 edge[8]; /* Edge array for data read */ int32 dims[8]; /* Dimensions */ int32 rank = 0; /* Field rank */ int32 rk = 0; /* Field rank */ int32 ntype = 0; /* Field number type */ int32 bufOffset = 0; /* Output buffer offset */ int32 size; /* Size of data buffer */ int32 idxMapElem = -1; /* Number of l_index map elements */ int32 *idxmap = NULL; /* Pointer to l_index mapping array */ int32 startscanline = 0; int32 stopscanline = 0; char *dfieldlist = (char *)NULL; int32 strbufsize = 0; int32 dfrank[8]; int32 numtype2[8]; uint16 *buffer2 = (uint16 *)NULL; uint16 *tbuffer = (uint16 *)NULL; int32 dims2[8]; int32 nt = 0; int32 startscandim = -1; int32 stopscandim = -1; int32 rank2 = 0; char dimlist[256]; /* Dimension list */ char geodim[256];/* Geolocation field dimension list */ char tgeodim[256];/* Time field dimension list */ char dgeodim[256];/* Data field dimension list for subsetting */ char utlbuf[256];/* Utility buffer */ char *ptr[64]; /* String pointer array */ /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWextractregion", &fid, &sdInterfaceID, &swVgrpID); /* Check for valid region ID */ /* ------------------------- */ if (status == 0) { if (regionID < 0 || regionID >= NSWATHREGN) { status = -1; HEpush(DFE_RANGE, "SWextractregion", __FILE__, __LINE__); HEreport("Invalid Region id: %d.\n", regionID); } } /* Check for active region ID */ /* -------------------------- */ if (status == 0) { if (SWXRegion[regionID] == 0) { status = -1; HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__); HEreport("Inactive Region ID: %d.\n", regionID); } } /* This code checks for the attribute detector_count */ /* which is found in Landsat 7 files. It is used */ /* for some of the loops. */ /* ================================================= */ if (SWXRegion[regionID]->scanflag == 1) { land_status = SWattrinfo(swathID, "detector_count", &numtype, &count); if (land_status == 0) land_status = SWreadattr(swathID, "detector_count", &detect_cnt); } /* Check that geo file and data file are same for INTERNAL subsetting */ /* ------------------------------------------------------------------ */ if (status == 0) { if (SWXRegion[regionID]->fid != fid && externalflag != HDFE_EXTERNAL) { status = -1; HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__); HEreport("Region is not defined for this file.\n"); } } /* Check that geo swath and data swath are same for INTERNAL subsetting */ /* -------------------------------------------------------------------- */ if (status == 0) { if (SWXRegion[regionID]->swathID != swathID && externalflag != HDFE_EXTERNAL) { status = -1; HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__); HEreport("Region is not defined for this Swath.\n"); } } /* Check for valid fieldname */ /* ------------------------- */ if (status == 0) { /* Get data field info */ /* ------------------- */ status = SWfieldinfo(swathID, fieldname, &rank, dims, &ntype, dimlist); if (status != 0) { status = -1; HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__); HEreport("Field \"%s\" Not Found.\n", fieldname); } } /* No problems so proceed ... */ /* -------------------------- */ if (status == 0) { /* Initialize start and edge for all dimensions */ /* -------------------------------------------- */ for (j = 0; j < rank; j++) { start[j] = 0; edge[j] = dims[j]; } /* Vertical Subset */ /* --------------- */ for (j = 0; j < 8; j++) { /* If active vertical subset ... */ /* ----------------------------- */ if (SWXRegion[regionID]->StartVertical[j] != -1) { /* Find vertical dimension within dimlist */ /* -------------------------------------- */ dum = EHstrwithin(SWXRegion[regionID]->DimNamePtr[j], dimlist, ','); /* If dimension found ... */ /* ---------------------- */ if (dum != -1) { /* Compute start and edge for vertical dimension */ /* --------------------------------------------- */ vfound = 1; /* xhua */ start[dum] = SWXRegion[regionID]->StartVertical[j]; edge[dum] = SWXRegion[regionID]->StopVertical[j] - SWXRegion[regionID]->StartVertical[j] + 1; } else { /* Vertical dimension not found */ /* ---------------------------- */ status = -1; HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__); HEreport("Vertical Dimension Not Found: \"%s\".\n", SWXRegion[regionID]->DimNamePtr); } } } /* End of Vertical Subset loop */ /* No problems so proceed ... */ /* -------------------------- */ if (status == 0) { /* If non-vertical subset regions defined ... */ /* ------------------------------------------ */ if (SWXRegion[regionID]->nRegions > 0) { /* Get geolocation dimension name */ /* ------------------------------ */ status = SWfieldinfo(SWXRegion[regionID]->swathID, "Longitude", &dum, dumdims, &dum, geodim); long_status = status; /* If Time field being used, check for dimensions */ /* ---------------------------------------------- */ if (timeflag == 1) { /* code change to fix time subset bug for Landsat7 */ status = SWfieldinfo(SWXRegion[regionID]->swathID, "Time", &dum, dumdims, &dum, tgeodim); if (strcmp(geodim, tgeodim) != 0) { strcpy(geodim, tgeodim); } } timeflag = 0; /* If defscanregion being used, get dimensions */ /* of field being used */ /* ---------------------------------------------- */ if (SWXRegion[regionID]->scanflag == 1) { (void) SWnentries(SWXRegion[regionID]->swathID,4,&strbufsize); dfieldlist = (char *)calloc(strbufsize + 1, sizeof(char)); (void) SWinqdatafields(SWXRegion[regionID]->swathID,dfieldlist,dfrank,numtype2); status = SWfieldinfo(SWXRegion[regionID]->swathID,dfieldlist,&dum,dumdims,&dum,dgeodim); /* The dimensions have to be switched, because */ /* the mappings force a geodim and datadim */ /* so to find the mapping, the dimensions must */ /* be switched, but the subsetting will still */ /* be based on the correct dimensions */ /* ------------------------------------------- */ if (strcmp(dgeodim,dimlist) != 0 || long_status == -1) { strcpy(geodim,dimlist); strcpy(dimlist,dgeodim); } } /* Get "Track" (first) Dimension from geo dimlist */ /* ---------------------------------------------- */ nDim = EHparsestr(geodim, ',', ptr, slen); geodim[slen[0]] = 0; /* Parse Data Field Dimlist & find mapping */ /* --------------------------------------- */ nDim = EHparsestr(dimlist, ',', ptr, slen); /* Loop through all dimensions and search for mapping */ /* -------------------------------------------------- */ for (i = 0; i < nDim; i++) { memcpy(utlbuf, ptr[i], slen[i]); utlbuf[slen[i]] = 0; statMap = SWmapinfo(swathID, geodim, utlbuf, &offset, &incr); /* * Force offset to 0. * We're not changing the mapping, so we want * the original offset to apply to the subsetted data. * Otherwise, bad things happen, such as subsetting * past the end of the original data, and being unable * to read the first elements of the * original data. * The offset is only important for aligning the * data with interpolated (incr > 0) or decimated * (incr < 0) geolocation information for the data. */ offset = 0; /* Mapping found */ /* ------------- */ if (statMap == 0) { found = 1; l_index = i; break; } } /* If mapping not found check for geodim within dimlist */ /* ---------------------------------------------------- */ if (found == 0) { l_index = EHstrwithin(geodim, dimlist, ','); /* Geo dimension found within subset field dimlist */ /* ----------------------------------------------- */ if (l_index != -1) { found = 1; offset = 0; incr = 1; } } /* If mapping not found check for l_indexed mapping */ /* ---------------------------------------------- */ if (found == 0) { /* Get size of geo dim & allocate space of l_index mapping */ /* ----------------------------------------------------- */ dum = SWdiminfo(swathID, geodim); /* For Landsat files, the l_index mapping has two values */ /* for each point, a left and right point. So for a 37 */ /* scene band file there are 2x2 points for each scene */ /* meaning, 2x2x37 = 148 values. The above function */ /* only returns the number of values in the track */ /* dimension. */ /* ----------------------------------------------------- */ if(land_status == 0) if(strcmp(fieldname, "Latitude") == 0 || strcmp(fieldname, "Longitude") == 0) { dum = dum * 2; } idxmap = (int32 *) calloc(dum, sizeof(int32)); if(idxmap == NULL) { HEpush(DFE_NOSPACE,"SWextractregion", __FILE__, __LINE__); return(-1); } /* Loop through all dimensions and search for mapping */ /* -------------------------------------------------- */ for (i = 0; i < nDim; i++) { memcpy(utlbuf, ptr[i], slen[i]); utlbuf[slen[i]] = 0; idxMapElem = SWidxmapinfo(swathID, geodim, utlbuf, idxmap); /* Mapping found */ /* ------------- */ if (idxMapElem != -1) { found = 1; l_index = i; break; } } } /* If regular mapping found ... */ /* ---------------------------- */ if (found == 1 && idxMapElem == -1) { for (k = 0; k < SWXRegion[regionID]->nRegions; k++) { if (k > 0) { /* Compute size in bytes of previous region */ /* ---------------------------------------- */ size = edge[0]; for (j = 1; j < rank; j++) { size *= edge[j]; } size *= DFKNTsize(ntype); /* Compute output buffer offset */ /* ---------------------------- */ bufOffset += size; } else { /* Initialize output buffer offset */ /* ------------------------------- */ bufOffset = 0; } /* Compute number of cross tracks in region */ /* ---------------------------------------- */ nXtrk = SWXRegion[regionID]->StopRegion[k] - SWXRegion[regionID]->StartRegion[k] + 1; /* Positive increment (geodim <= datadim) */ /* -------------------------------------- */ if (incr > 0) { if (SWXRegion[regionID]->scanflag == 1) { start[l_index] = SWXRegion[regionID]->StartRegion[k]/incr; if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { start[l_index] = (SWXRegion[regionID]->StartRegion[k]+detect_cnt)/incr; status = SWfieldinfo(SWXRegion[regionID]->swathID,"scan_no",&rank,dims2,&nt,dimlist); buffer2 = (uint16 *)calloc(dims2[0], sizeof(uint16)); status = SWreadfield(SWXRegion[regionID]->swathID,"scan_no",NULL,NULL,NULL,buffer2); if(incr == 1) start[l_index] = start[l_index] - (buffer2[0] * detect_cnt); else start[l_index] = start[l_index] - buffer2[0]; free(buffer2); } scan_shift = nXtrk % incr; if(scan_shift != 0) nXtrk = nXtrk - scan_shift; edge[l_index] = nXtrk / incr; if (nXtrk % incr != 0) edge[l_index]++; if(long_status == -1 || incr == 1) { if( detect_cnt == 0 ) return -1; scan_shift = nXtrk % detect_cnt; if(scan_shift != 0) edge[l_index] = nXtrk - scan_shift; } } else { start[l_index] = SWXRegion[regionID]->StartRegion[k] * incr + offset; edge[l_index] = nXtrk * incr - offset; } } else { /* Negative increment (geodim > datadim) */ /* ------------------------------------- */ start[l_index] = SWXRegion[regionID]->StartRegion[k] / (-incr) + offset; edge[l_index] = nXtrk / (-incr); /* * If Xtrk not exactly divisible by incr, round * edge to next highest integer */ if (nXtrk % (-incr) != 0) { edge[l_index]++; } } /* Read Data into output buffer */ /* ---------------------------- */ status = SWreadfield(swathID, fieldname, start, NULL, edge, (uint8 *) buffer + bufOffset); } } else if (found == 1 && idxMapElem != -1) { /* Indexed Mapping */ /* --------------- */ for (k = 0; k < SWXRegion[regionID]->nRegions; k++) { if (k > 0) { /* Compute size in bytes of previous region */ /* ---------------------------------------- */ size = edge[0]; for (j = 1; j < rank; j++) { size *= edge[j]; } size *= DFKNTsize(ntype); /* Compute output buffer offset */ /* ---------------------------- */ bufOffset += size; } else { /* Initialize output buffer offset */ /* ------------------------------- */ bufOffset = 0; } /* Compute start & edge from l_index mappings */ /* ---------------------------------------- */ if (SWXRegion[regionID]->scanflag == 1 && (strcmp(fieldname, "Latitude") == 0 || strcmp(fieldname, "Longitude") == 0)) { if (land_status == 0) status = SWreadattr(swathID, "scene_count", &scene_cnt); startscanline = SWXRegion[regionID]->StartRegion[k]; stopscanline = SWXRegion[regionID]->StopRegion[k]; if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { status = SWfieldinfo(swathID,"scan_no",&rk,dims2,&nt,dimlist); tbuffer = (uint16 *)calloc(dims2[0], sizeof(uint16)); status =SWreadfield(swathID,"scan_no",NULL,NULL,NULL,tbuffer); startscanline = startscanline - ((tbuffer[0] * detect_cnt) - detect_cnt); stopscanline = stopscanline - ((tbuffer[0] * detect_cnt) - 1); } if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { if(startscandim == -1) if(startscanline < idxmap[0]) { startscandim = 0; start[l_index] = 0; if(stopscanline > idxmap[scene_cnt * 2 - 1]) { stopscandim = scene_cnt*2 - startscandim; edge[l_index] = scene_cnt*2 - startscandim; } } } j = 0; for (l = 0; l < scene_cnt; l++) { if(idxmap[j] <= startscanline && idxmap[j+1] >= startscanline) if(startscandim == -1) { start[l_index] = j; startscandim = j; } if(idxmap[j] <= stopscanline && idxmap[j+1] >= stopscanline) if(startscandim != -1) { edge[l_index] = j - start[l_index] + 2; stopscandim = j - start[l_index] + 1; } j = j + 2; } if(SWXRegion[regionID]->band8flag == 1 || SWXRegion[regionID]->band8flag == 2) { if(startscandim == -1) if(startscanline < idxmap[0]) { startscandim = 0; start[l_index] = 0; } if(stopscandim == -1) if(stopscanline > idxmap[scene_cnt * 2 - 1]) { stopscandim = scene_cnt*2 - start[l_index]; edge[l_index] = scene_cnt*2 - start[l_index]; } } if(SWXRegion[regionID]->band8flag == 2) { if(startscandim == -1) if(startscanline > idxmap[j - 1]) { status = SWfieldinfo(SWXRegion[regionID]->swathID,"scan_no",&rank2,dims2,&nt,dimlist); buffer2 = (uint16 *)calloc(dims2[0], sizeof(uint16)); status = SWreadfield(SWXRegion[regionID]->swathID,"scan_no",NULL,NULL,NULL,buffer2); startscanline = startscanline - (buffer2[0] * detect_cnt); stopscanline = stopscanline - (buffer2[0] * detect_cnt); free(buffer2); j = 0; for (l = 0; l < scene_cnt; l++) { if(idxmap[j] <= startscanline && idxmap[j+1] >= startscanline) { start[l_index] = j; } if(idxmap[j] <= stopscanline && idxmap[j+1] >= stopscanline) edge[l_index] = j - start[l_index] + 2; j = j + 2; if(idxmap[j] == 0 || idxmap[j+1] == 0) l = scene_cnt; } } } } else if(SWXRegion[regionID]->scanflag == 1 && (strcmp(fieldname, "scene_center_latitude") == 0 || strcmp(fieldname, "scene_center_longitude") == 0)) { if (land_status == 0) status = SWreadattr(swathID, "scene_count", &scene_cnt); startscanline = SWXRegion[regionID]->StartRegion[k]; stopscanline = SWXRegion[regionID]->StopRegion[k]; if(startscanline < idxmap[0]) { startscandim = 0; start[l_index] = 0; } for (l = 0; l < scene_cnt-1; l++) { if(idxmap[l] <= startscanline && idxmap[l+1] >= startscanline) if(startscandim == -1) { start[l_index] = l; startscandim = l; } if(idxmap[l] <= stopscanline && idxmap[l+1] >= stopscanline) if(stopscandim == -1) { edge[l_index] = l - start[l_index] + 2; stopscandim = l + 1; } } if(stopscandim == -1) { if(stopscanline > idxmap[scene_cnt - 1]) { edge[l_index] = scene_cnt - start[l_index]; stopscandim = scene_cnt - 1; } } if(SWXRegion[regionID]->band8flag == 1) { if(stopscandim == -1) if(stopscanline > idxmap[scene_cnt - 1]) { edge[l_index] = scene_cnt - start[l_index]; stopscandim = scene_cnt -1; } } if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { if(startscandim == -1) { if(startscanline < idxmap[0]) { startscandim = 0; start[l_index] = 0; edge[l_index] = stopscandim - startscandim + 1; } } if(startscandim == -1) { startscanline = SWXRegion[regionID]->StartScan[k] * detect_cnt - detect_cnt; stopscanline = SWXRegion[regionID]->StopScan[k] * detect_cnt - 1; for (l = 0; l < scene_cnt-1; l++) { if(idxmap[l] <= startscanline && idxmap[l+1] >= startscanline) start[l_index] = l; if(idxmap[l] <= stopscanline && idxmap[l+1] >= stopscanline) edge[l_index] = l - start[l_index] + 1; } } } } else { if (SWXRegion[regionID]->scanflag == 1 && strcmp(fieldname,dfieldlist) == 0) { start[l_index] = SWXRegion[regionID]->StartRegion[k]; edge[l_index] = SWXRegion[regionID]->StopRegion[k] - SWXRegion[regionID]->StartRegion[k] + 1; if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3 ) { status = SWfieldinfo(SWXRegion[regionID]->swathID,"scan_no",&rank,dims2,&nt,dimlist); buffer2 = (uint16 *)calloc(dims2[0], sizeof(uint16)); status = SWreadfield(SWXRegion[regionID]->swathID,"scan_no",NULL,NULL,NULL,buffer2); start[l_index] = start[l_index] - (buffer2[0] * detect_cnt - detect_cnt); free(buffer2); } } else { start[l_index] = idxmap[SWXRegion[regionID]->StartRegion[k]]; edge[l_index] = idxmap[SWXRegion[regionID]->StopRegion[k]] - idxmap[SWXRegion[regionID]->StartRegion[k]] + 1; } } /* Read Data into output buffer */ /* ---------------------------- */ status = SWreadfield(swathID, fieldname, start, NULL, edge, buffer); if (SWXRegion[regionID]->scanflag == 1) { if (strcmp(fieldname,"Longitude") == 0) { status = SWscan2longlat(swathID, fieldname, buffer, start, edge, idxmap, startscanline, stopscanline); } if (strcmp(fieldname,"Latitude") == 0) { status = SWscan2longlat(swathID, fieldname, buffer, start, edge, idxmap, startscanline, stopscanline); } } } } else if(vfound == 1) /* Vertical subsetting */ { /* found previously, */ status = SWreadfield(swathID, fieldname, /* perform the vertical*/ start, NULL, edge, /* subsetting. */ (uint8 *) buffer); /* -- xhua */ } else { /* Mapping not found */ /* ----------------- */ status = -1; HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__); HEreport("Mapping Not Defined for \"%s\" Dimension.\n", geodim); } } else { /* Read Data (Vert SS only) */ /* ------------------------ */ status = SWreadfield(swathID, fieldname, start, NULL, edge, (uint8 *) buffer); } } } /* Free l_index mappings if applicable */ /* --------------------------------- */ if (idxmap != NULL) { free(idxmap); } if(dfieldlist != NULL) free(dfieldlist); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWscan2longlat | | | | DESCRIPTION: Convert scanline to Long/Lat for floating scene subsetting. | | This will calculate/interpolate the long/lat for a given | | scanline. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 Swath structure ID | | fieldname char Fieldname | | buffer void Values to update | | start int32 | | edge int32 | | idxmap int32 * Buffer of l_index mapping values | | startscanline int32 Start of scan region | | stopscanline int32 Stop of scan region | | | | OUTPUTS: | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jul 99 DaW Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ static intn SWscan2longlat(int32 swathID, const char *fieldname, VOIDP buffer, int32 start[], int32 edge[], int32 *idxmap, int32 startscanline, int32 stopscanline) { enum corner {UL, UR, LL, LR}; enum corner pos = UL; enum corner pos2 = UL; uint8 scene_cnt = 0; /* Used to convert scan to scanline */ /* L7 float scene sub. */ float32 *buffer2; float32 *bufferc; float32 deg2rad = (float32)(M_PI/180.00); float32 p1_long = 0.0; /* point 1, longitude */ float32 p2_long = 0.0; /* point 2, longitude */ float32 pi_long = 0.0; /* interpolated point, longitude */ int32 scanline_p1 = 0; float32 p1_lat = 0.0; /* point 1, latitude */ float32 p2_lat = 0.0; /* point 2, latitude */ float32 pi_lat = 0.0; /* interpolated point, latitude */ int32 scanline_p2 = 0; float32 x_p1 = 0.0; /* Cartesian coordinates */ float32 y_p1 = 0.0; /* point 1 */ float32 z_p1 = 0.0; float32 x_p2 = 0.0; /* Cartesian coordinates */ float32 y_p2 = 0.0; /* point 2 */ float32 z_p2 = 0.0; float32 x_pi = 0.0; /* Cartesian coordinates */ float32 y_pi = 0.0; /* interpolated point */ float32 z_pi = 0.0; int32 scanline_pi = 0; intn status = -1; int i = 0; int p1_long_l90_flag = 0; int p1_long_g90_flag = 0; int p2_long_l90_flag = 0; int p2_long_g90_flag = 0; int fieldflag = 0; int numofval = 0; numofval = edge[0] * 2; buffer2 = (float32 *)calloc(numofval, sizeof(float32)); bufferc = (float32 *)calloc(numofval, sizeof(float32)); memmove(bufferc, buffer, numofval*sizeof(float32)); (void) SWreadattr(swathID, "scene_count", &scene_cnt); if (strcmp(fieldname, "Longitude") == 0) { fieldflag = 1; status = SWreadfield(swathID, "Latitude", start, NULL, edge, buffer2); } else if (strcmp(fieldname, "Latitude") == 0) { fieldflag = 2; status = SWreadfield(swathID, "Longitude", start, NULL, edge, buffer2); } for(i=0; i<4; i++) { switch(pos) { case UL: if (fieldflag == 1) { p1_long = bufferc[0]; p2_long = bufferc[2]; p1_lat = buffer2[0]; p2_lat = buffer2[2]; } if (fieldflag == 2) { p1_long = buffer2[0]; p2_long = buffer2[2]; p1_lat = bufferc[0]; p2_lat = bufferc[2]; } scanline_p1 = idxmap[start[0]]; scanline_p2 = idxmap[start[0]+1]; scanline_pi = startscanline; pos = UR; break; case UR: if (fieldflag == 1) { p1_long = bufferc[1]; p2_long = bufferc[3]; p1_lat = buffer2[1]; p2_lat = buffer2[3]; } if (fieldflag == 2) { p1_long = buffer2[1]; p2_long = buffer2[3]; p1_lat = bufferc[1]; p2_lat = bufferc[3]; } scanline_p1 = idxmap[start[0]]; scanline_p2 = idxmap[start[0]+1]; scanline_pi = startscanline; pos = LL; break; case LL: if (fieldflag == 1) { p1_long = bufferc[numofval-4]; p2_long = bufferc[numofval-2]; p1_lat = buffer2[numofval-4]; p2_lat = buffer2[numofval-2]; } if (fieldflag == 2) { p1_long = buffer2[numofval-4]; p2_long = buffer2[numofval-2]; p1_lat = bufferc[numofval-4]; p2_lat = bufferc[numofval-2]; } scanline_p1 = idxmap[start[0] + edge[0] - 2]; scanline_p2 = idxmap[start[0] + edge[0] - 1]; scanline_pi = stopscanline; pos = LR; break; case LR: if (fieldflag == 1) { p1_long = bufferc[numofval-3]; p2_long = bufferc[numofval-1]; p1_lat = buffer2[numofval-3]; p2_lat = buffer2[numofval-1]; } if (fieldflag == 2) { p1_long = buffer2[numofval-3]; p2_long = buffer2[numofval-1]; p1_lat = bufferc[numofval-3]; p2_lat = bufferc[numofval-1]; } scanline_p1 = idxmap[start[0] + edge[0] - 2]; scanline_p2 = idxmap[start[0] + edge[0] - 1]; scanline_pi = stopscanline; break; } if (p1_long <= -90.0) { if (p2_long >= 90.0) { p1_long = p1_long + 180.0f; p2_long = p2_long - 180.0f; p1_long_l90_flag = 2; } else { p1_long = p1_long + 180.0f; p1_long_l90_flag = 1; } } if (p1_long >= 90.0 && p1_long_l90_flag != 2) { if(p2_long <= -90.0) { p1_long = p1_long - 180.0f; p2_long = p2_long + 180.0f; p1_long_g90_flag = 2; } else { p1_long = p1_long - 90.0f; p1_long_g90_flag = 1; } } if (p2_long <= -90.0) { if (p1_long < 0.0) { p2_long = p2_long + 90.0f; p1_long = p1_long + 90.0f; p2_long_l90_flag = 2; } else { p2_long = p2_long + 180.0f; p2_long_l90_flag = 1; } } if (p2_long >= 90.0 && p1_long_l90_flag != 2) { p2_long = p2_long - 90.0f; p2_long_g90_flag = 1; } x_p1 = (float)(RADOE * cos((p1_long*deg2rad)) * sin((p1_lat*deg2rad))); y_p1 = (float)(RADOE * sin((p1_long*deg2rad)) * sin((p1_lat*deg2rad))); z_p1 = (float)(RADOE * cos((p1_lat*deg2rad))); x_p2 = (float)(RADOE * cos((p2_long*deg2rad)) * sin((p2_lat*deg2rad))); y_p2 = (float)(RADOE * sin((p2_long*deg2rad)) * sin((p2_lat*deg2rad))); z_p2 = (float)(RADOE * cos((p2_lat*deg2rad))); x_pi = x_p1 + (x_p2 - x_p1)*(scanline_pi-scanline_p1)/(scanline_p2-scanline_p1); y_pi = y_p1 + (y_p2 - y_p1)*(scanline_pi-scanline_p1)/(scanline_p2-scanline_p1); z_pi = z_p1 + (z_p2 - z_p1)*(scanline_pi-scanline_p1)/(scanline_p2-scanline_p1); if (fieldflag == 1) { pi_long = (float)(atan(y_pi/x_pi)*180.0/M_PI); if (p1_long_l90_flag == 1 || p2_long_l90_flag == 1) { pi_long = pi_long - 180.0f; p1_long_l90_flag = 0; p2_long_l90_flag = 0; } if (p1_long_g90_flag == 1 || p2_long_g90_flag == 1) { pi_long = pi_long + 90.0f; p1_long_g90_flag = 0; p2_long_g90_flag = 0; } if (p1_long_l90_flag == 2) { if (pi_long > 0.0) pi_long = pi_long - 180.0f; else if (pi_long < 0.0) pi_long = pi_long + 180.0f; p1_long_l90_flag = 0; } if (p1_long_g90_flag == 2) { if (pi_long > 0.0) pi_long = pi_long - 180.0f; else if (pi_long < 0.0) pi_long = pi_long + 180.0f; p1_long_g90_flag = 0; } if (p2_long_l90_flag == 2) { pi_long = pi_long - 90.0f; p2_long_l90_flag = 0; } switch(pos2) { case UL: bufferc[0] = pi_long; pos2 = UR; break; case UR: bufferc[1] = pi_long; pos2 = LL; break; case LL: if(stopscanline > idxmap[scene_cnt*2 - 1]) break; bufferc[numofval-2] = pi_long; pos2 = LR; break; case LR: if(stopscanline > idxmap[scene_cnt*2 - 1]) break; bufferc[numofval-1] = pi_long; break; } } if (fieldflag == 2) { pi_lat = (float)(atan((sqrt(x_pi*x_pi + y_pi*y_pi)/z_pi))*180.0/M_PI); switch(pos2) { case UL: bufferc[0] = pi_lat; pos2 = UR; break; case UR: bufferc[1] = pi_lat; pos2 = LL; break; case LL: if(stopscanline > idxmap[scene_cnt*2 - 1]) break; bufferc[numofval-2] = pi_lat; pos2 = LR; break; case LR: if(stopscanline > idxmap[scene_cnt*2 - 1]) break; bufferc[numofval-1] = pi_lat; break; } } } memmove(buffer, bufferc, numofval*sizeof(float32)); free(buffer2); free(bufferc); return(status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWextractperiod | | | | DESCRIPTION: Retrieves data from specified period. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 Swath structure ID | | periodID int32 Period ID | | fieldname char Fieldname | | externalflag int32 External geolocation fields flag | | HDFE_INTERNAL (0) | | HDFE_EXTERNAL (1) | | | | OUTPUTS: | | buffer void Data buffer containing subsetted region | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Jun 03 Abe Taaheri added clearing timeflag if SWextractregion fails | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWextractperiod(int32 swathID, int32 periodID, const char *fieldname, int32 externalflag, VOIDP buffer) { intn status; /* routine return status variable */ timeflag = 1; /* Call SWextractregion routine */ /* ---------------------------- */ status = SWextractregion(swathID, periodID, fieldname, externalflag, (char *) buffer); if (status != 0) timeflag = 0; /*clear timeflag if SWextractregion failed*/ return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdupregion | | | | DESCRIPTION: Duplicates a region | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | newregionID int32 New region ID | | | | INPUTS: | | oldregionID int32 Old region ID | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jan 97 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWdupregion(int32 oldregionID) { intn i; /* Loop index */ int32 newregionID = -1; /* New region ID */ /* Find first empty (inactive) region */ /* ---------------------------------- */ for (i = 0; i < NSWATHREGN; i++) { if (SWXRegion[i] == 0) { /* Allocate space for new swath region entry */ /* ----------------------------------------- */ SWXRegion[i] = (struct swathRegion *) calloc(1, sizeof(struct swathRegion)); if(SWXRegion[i] == NULL) { HEpush(DFE_NOSPACE,"SWdupregion", __FILE__, __LINE__); return(-1); } /* Copy old region structure data to new region */ /* -------------------------------------------- */ *SWXRegion[i] = *SWXRegion[oldregionID]; /* Define new region ID */ /* -------------------- */ newregionID = i; break; } } return (newregionID); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWregioninfo | | | | DESCRIPTION: Returns size of region in bytes | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 Swath structure ID | | regionID int32 Region ID | | fieldname char Fieldname | | | | | | OUTPUTS: | | ntype int32 field number type | | rank int32 field rank | | dims int32 dimensions of field region | | size int32 size in bytes of field region | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Add vertical subsetting | | Dec 96 Joel Gales Add multiple vertical subsetting capability | | Mar 97 Joel Gales Add support for l_index mapping | | Jul 99 DaW Add support for floating scene subsetting | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWregioninfo(int32 swathID, int32 regionID, const char *fieldname, int32 * ntype, int32 * rank, int32 dims[], int32 * size) { intn i; /* Loop index */ intn j; /* Loop index */ intn k; /* Loop index */ intn l = 0; /* Loop index */ intn status; /* routine return status variable */ intn long_status = 3; /* routine return status variable for longitude */ intn land_status = 3; /* Used for L7 float scene sub. */ intn statMap = -1; /* Status from SWmapinfo */ uint8 found = 0; /* Found flag */ uint8 detect_cnt = 0; /* Used for L7 float scene sub. */ int32 numtype = 0; /* Used for L7 float scene sub. */ int32 count = 0; /* Used for L7 float scene sub. */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 l_index = 0; /* Geo Dim Index */ int32 nDim; /* Number of dimensions */ int32 slen[64]; /* String length array */ int32 dum; /* Dummy variable */ int32 incr = 0; /* Mapping increment */ int32 nXtrk = 0; /* Number of cross tracks */ int32 scan_shift = 0; /* Used to take out partial scans */ int32 startscandim = -1; /* Used for floating scene region size */ int32 stopscandim = -1; /* Used for floating scene region size */ int32 dumdims[8]; /* Dimensions from SWfieldinfo */ int32 idxMapElem = -1; /* Number of l_index map elements */ int32 *idxmap = NULL; /* Pointer to l_index mapping array */ int32 datafld = 0; uint8 scene_cnt = 0; /* Number of scenes in swath */ int32 startscanline = 0; int32 stopscanline = 0; char *dfieldlist = (char *)NULL; int32 strbufsize = 0; int32 dfrank[8]; int32 numtype2[8]; int32 rank2 = 0; int32 rk = 0; int32 dims2[8]; int32 nt = 0; uint16 *buffer2 = (uint16 *)NULL; uint16 *tbuffer = (uint16 *)NULL; char dimlist[256]; /* Dimension list */ char geodim[256];/* Geolocation field dimension list */ char tgeodim[256];/* Time Geolocation field dimension list */ char dgeodim[256];/* Data Subsetting field dimension list */ char utlbuf[256];/* Utility buffer */ char *ptr[64]; /* String pointer array */ static const char errMesg[] = "Vertical Dimension Not Found: \"%s\".\n"; /* Set region size to -1 */ /* --------------------- */ *size = -1; /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWregioninfo", &fid, &sdInterfaceID, &swVgrpID); /* Check for valid region ID */ /* ------------------------- */ if (status == 0) { if (regionID < 0 || regionID >= NSWATHREGN) { status = -1; HEpush(DFE_RANGE, "SWregioninfo", __FILE__, __LINE__); HEreport("Invalid Region id: %d.\n", regionID); } } /* Check for active region ID */ /* -------------------------- */ if (status == 0) { if (SWXRegion[regionID] == 0) { status = -1; HEpush(DFE_GENAPP, "SWregioninfo", __FILE__, __LINE__); HEreport("Inactive Region ID: %d.\n", regionID); } } /* This code checks for the attribute detector_count */ /* which is found in Landsat 7 files. It is used */ /* for some of the loops. */ /* ================================================= */ if (SWXRegion[regionID]->scanflag == 1) { land_status = SWattrinfo(swathID, "detector_count", &numtype, &count); if (land_status == 0) { land_status = SWreadattr(swathID, "detector_count", &detect_cnt); land_status = SWreadattr(swathID, "scene_count", &scene_cnt); } } /* Check for valid fieldname */ /* ------------------------- */ if (status == 0) { /* Get data field info */ /* ------------------- */ status = SWfieldinfo(swathID, fieldname, rank, dims, ntype, dimlist); if (status != 0) { status = -1; HEpush(DFE_GENAPP, "SWregioninfo", __FILE__, __LINE__); HEreport("Field \"%s\" Not Found.\n", fieldname); } } /* No problems so proceed ... */ /* -------------------------- */ if (status == 0) { /* If non-vertical subset regions defined ... */ /* ------------------------------------------ */ if (SWXRegion[regionID]->nRegions > 0 || SWXRegion[regionID]->scanflag == 1) { /* Get geolocation dimension name */ /* ------------------------------ */ status = SWfieldinfo(SWXRegion[regionID]->swathID, "Longitude", &dum, dumdims, &dum, geodim); long_status = status; /* If Time field being used, check for dimensions */ /* ---------------------------------------------- */ if (timeflag == 1) { /* code change to fix time subset bug for Landsat7 */ status = SWfieldinfo(SWXRegion[regionID]->swathID, "Time", &dum, dumdims, &dum, tgeodim); if (strcmp(geodim, tgeodim) != 0) { strcpy(geodim, tgeodim); } timeflag = 0; } /* If defscanregion being used, get dimensions */ /* of field being used */ /* ---------------------------------------------- */ if (SWXRegion[regionID]->scanflag == 1) { (void) SWnentries(SWXRegion[regionID]->swathID,4,&strbufsize); dfieldlist = (char *)calloc(strbufsize + 1, sizeof(char)); (void) SWinqdatafields(SWXRegion[regionID]->swathID,dfieldlist,dfrank,numtype2); status = SWfieldinfo(SWXRegion[regionID]->swathID,dfieldlist,&dum,dumdims,&dum,dgeodim); /* The dimensions have to be switched, because */ /* the mappings force a geodim and datadim */ /* so to find the mapping, the dimensions must */ /* be switched, but the subsetting will still */ /* be based on the correct dimensions */ /* "long_status == -1" added for CAL file which */ /* doesn't have a Traditional geolocation field */ /* ---------------------------------------------- */ if (strcmp(dgeodim,dimlist) != 0 || long_status == -1) { strcpy(geodim,dimlist); strcpy(dimlist,dgeodim); } } /* Get "Track" (first) Dimension from geo dimlist */ /* ---------------------------------------------- */ nDim = EHparsestr(geodim, ',', ptr, slen); geodim[slen[0]] = 0; /* Parse Data Field Dimlist & find mapping */ /* --------------------------------------- */ nDim = EHparsestr(dimlist, ',', ptr, slen); /* Loop through all dimensions and search for mapping */ /* -------------------------------------------------- */ for (i = 0; i < nDim; i++) { memcpy(utlbuf, ptr[i], slen[i]); utlbuf[slen[i]] = 0; statMap = SWmapinfo(swathID, geodim, utlbuf, &dum, &incr); /* Mapping found */ /* ------------- */ if (statMap == 0) { found = 1; l_index = i; break; } } /* If mapping not found check for geodim within dimlist */ /* ---------------------------------------------------- */ if (found == 0) { l_index = EHstrwithin(geodim, dimlist, ','); /* Geo dimension found within subset field dimlist */ /* ----------------------------------------------- */ if (l_index != -1) { found = 1; incr = 1; } } /* If mapping not found check for l_indexed mapping */ /* ---------------------------------------------- */ if (found == 0) { /* Get size of geo dim & allocate space of l_index mapping */ /* ----------------------------------------------------- */ dum = SWdiminfo(swathID, geodim); idxmap = (int32 *) calloc(dum, sizeof(int32)); if(idxmap == NULL) { HEpush(DFE_NOSPACE,"SWregioninfo", __FILE__, __LINE__); return(-1); } /* Loop through all dimensions and search for mapping */ /* -------------------------------------------------- */ for (i = 0; i < nDim; i++) { memcpy(utlbuf, ptr[i], slen[i]); utlbuf[slen[i]] = 0; idxMapElem = SWidxmapinfo(swathID, geodim, utlbuf, idxmap); /* Mapping found */ /* ------------- */ if (idxMapElem != -1) { found = 1; l_index = i; break; } } } /* Regular Mapping Found */ /* --------------------- */ if (found == 1 && idxMapElem == -1) { dims[l_index] = 0; /* Loop through all regions */ /* ------------------------ */ for (k = 0; k < SWXRegion[regionID]->nRegions; k++) { /* Get number of cross tracks in particular region */ /* ----------------------------------------------- */ nXtrk = SWXRegion[regionID]->StopRegion[k] - SWXRegion[regionID]->StartRegion[k] + 1; /* If increment is positive (geodim <= datadim) ... */ /* ------------------------------------------------ */ if (incr > 0) { if (SWXRegion[regionID]->scanflag == 1) { scan_shift = nXtrk % incr; if(scan_shift != 0) nXtrk = nXtrk - scan_shift; dims[l_index] += nXtrk/incr; if(long_status == -1 || incr == 1) { if( detect_cnt == 0 ) return -1; scan_shift = nXtrk % detect_cnt; if(scan_shift != 0) dims[l_index] = nXtrk - scan_shift; } } else { dims[l_index] += nXtrk * incr; } } else { /* Negative increment (geodim > datadim) */ /* ------------------------------------- */ dims[l_index] += nXtrk / (-incr); /* * If Xtrk not exactly divisible by incr, round dims * to next highest integer */ if (nXtrk % (-incr) != 0) { dims[l_index]++; } } } } else if (found == 1 && idxMapElem != -1) { /* Indexed Mapping */ /* --------------- */ dims[l_index] = 0; /* Loop through all regions */ /* ------------------------ */ for (k = 0; k < SWXRegion[regionID]->nRegions; k++) { j = 0; if(SWXRegion[regionID]->scanflag == 1) { startscanline = SWXRegion[regionID]->StartRegion[k]; stopscanline = SWXRegion[regionID]->StopRegion[k]; if (strcmp(fieldname,dfieldlist) == 0) { dims[l_index] = stopscanline - startscanline + 1; datafld = 1; } if (strcmp(fieldname, "Latitude") == 0 || strcmp(fieldname, "Longitude") == 0) { if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { status = SWfieldinfo(swathID,"scan_no",&rk,dims2,&nt,dimlist); tbuffer = (uint16 *)calloc(dims2[0], sizeof(uint16)); status =SWreadfield(swathID,"scan_no",NULL,NULL,NULL,tbuffer); startscanline = startscanline - ((tbuffer[0] * detect_cnt) - detect_cnt); stopscanline = stopscanline - ((tbuffer[0] * detect_cnt) - 1); } if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { if(startscandim == -1) if(startscanline < idxmap[0]) { startscandim = 0; dims[l_index] = 0; if(stopscanline > idxmap[scene_cnt *2 - 1]) { stopscandim = scene_cnt*2 - startscandim; dims[l_index] = scene_cnt*2 - startscandim; } } } for (l = 0; l < scene_cnt; l++) { if(idxmap[j] <= startscanline && idxmap[j+1] >= startscanline) if(startscandim == -1) { dims[l_index] = j; startscandim = j; } if(idxmap[j] <= stopscanline && idxmap[j+1] >= stopscanline) if(startscandim != -1) { dims[l_index] = j - startscandim + 2; stopscandim = j + 1; } j = j + 2; if(idxmap[j] == 0 || idxmap[j+1] == 0) l = scene_cnt; } if(SWXRegion[regionID]->band8flag == 1 || SWXRegion[regionID]->band8flag == 2) { if(stopscandim == -1) if(stopscanline > idxmap[scene_cnt * 2 - 1]) { stopscandim = scene_cnt*2 - dims[l_index]; dims[l_index] = scene_cnt*2 - dims[l_index]; } } if(SWXRegion[regionID]->band8flag == 3) { if(startscandim == -1) if(startscanline < idxmap[0]) { startscandim = 0; if(stopscandim != -1) dims[l_index] = stopscandim - startscandim + 1; } } if(SWXRegion[regionID]->band8flag == 2) { if(startscandim == -1) if(startscanline > idxmap[j - 1]) { status = SWfieldinfo(SWXRegion[regionID]->swathID,"scan_no",&rank2,dims2,&nt,dimlist); buffer2 = (uint16 *)calloc(dims2[0], sizeof(uint16)); status = SWreadfield(SWXRegion[regionID]->swathID,"scan_no",NULL,NULL,NULL,buffer2); startscanline = startscanline - (buffer2[0] * detect_cnt); stopscanline = stopscanline - (buffer2[0] * detect_cnt); free(buffer2); j = 0; for (l = 0; l < scene_cnt; l++) { if(idxmap[j] <= startscanline && idxmap[j+1] >= startscanline) { dims[l_index] = j; startscandim = j; } if(idxmap[j] <= stopscanline && idxmap[j+1] >= stopscanline) dims[l_index] = j - startscandim + 2; j = j + 2; if(idxmap[j] == 0 || idxmap[j+1] == 0) l = scene_cnt; } } } } if (strcmp(fieldname, "scene_center_latitude") == 0 || strcmp(fieldname, "scene_center_longitude") == 0) { startscanline = SWXRegion[regionID]->StartRegion[k]; stopscanline = SWXRegion[regionID]->StopRegion[k]; if(startscanline < idxmap[0]) { startscandim = 0; dims[l_index] = 0; } for (l = 0; l < scene_cnt-1; l++) { if(idxmap[l] <= startscanline && idxmap[l+1] >= startscanline) if(startscandim == -1) { dims[l_index] = l; startscandim = l; } if(idxmap[l] <= stopscanline && idxmap[l+1] >= stopscanline) { dims[l_index] = l - startscandim + 2; stopscandim = l + 1; } } if(stopscandim == -1) { if(stopscanline > idxmap[scene_cnt - 1]) { dims[l_index] = scene_cnt - startscandim; stopscandim = scene_cnt - 1; } } if(SWXRegion[regionID]->band8flag == 1) { if(stopscandim == -1) if(stopscanline > idxmap[scene_cnt - 1]) { dims[l_index] = scene_cnt - startscandim; stopscandim = scene_cnt - 1; } } if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { if(startscandim == -1) { if(startscanline < idxmap[0]) { startscandim = 0; dims[l_index] = stopscandim - startscandim + 1; } } if(startscandim == -1) { startscanline = SWXRegion[regionID]->StartScan[k] * detect_cnt; stopscanline = SWXRegion[regionID]->StopScan[k] * detect_cnt; for (l = 0; l < scene_cnt-1; l++) { if(idxmap[l] <= startscanline && idxmap[l+1] >= startscanline) dims[l_index] = l; if(idxmap[l] <= stopscanline && idxmap[l+1] >= stopscanline) dims[l_index] = l - dims[l_index] + 1; } } } } } else { if (datafld != 1) { /* Get number of cross tracks in particular region */ /* ----------------------------------------------- */ nXtrk = idxmap[SWXRegion[regionID]->StopRegion[k]] - idxmap[SWXRegion[regionID]->StartRegion[k]] + 1; dims[l_index] += nXtrk; } } } } else { /* Mapping not found */ /* ----------------- */ status = -1; HEpush(DFE_GENAPP, "SWregioninfo", __FILE__, __LINE__); HEreport( "Mapping Not Defined for \"%s\" Dimension.\n", geodim); } } /* Vertical Subset */ /* --------------- */ if (status == 0 || status == -1) /* check the vertical subset in any case -- xhua */ { for (j = 0; j < 8; j++) { /* If active vertical subset ... */ /* ----------------------------- */ if (SWXRegion[regionID]->StartVertical[j] != -1) { /* Find vertical dimension within dimlist */ /* -------------------------------------- */ l_index = EHstrwithin(SWXRegion[regionID]->DimNamePtr[j], dimlist, ','); /* If dimension found ... */ /* ---------------------- */ if (l_index != -1) { /* Compute dimension size */ /* ---------------------- */ dims[l_index] = SWXRegion[regionID]->StopVertical[j] - SWXRegion[regionID]->StartVertical[j] + 1; } else { /* Vertical dimension not found */ /* ---------------------------- */ status = -1; *size = -1; HEpush(DFE_GENAPP, "SWregioninfo", __FILE__, __LINE__); HEreport(errMesg, SWXRegion[regionID]->DimNamePtr[j]); } } } /* Compute size of region data buffer */ /* ---------------------------------- */ if (status == 0) { if(idxMapElem == 1 && SWXRegion[regionID]->scanflag == 1 && land_status == 0) { if(startscandim == dims[0]) dims[0] = scene_cnt*2 - startscandim; } /* Compute number of total elements */ /* -------------------------------- */ *size = dims[0]; for (j = 1; j < *rank; j++) { *size *= dims[j]; } /* Multiply by size in bytes of numbertype */ /* --------------------------------------- */ *size *= DFKNTsize(*ntype); } } } /* Free l_index mappings if applicable */ /* --------------------------------- */ if (idxmap != NULL) { free(idxmap); } if(dfieldlist != NULL) free(dfieldlist); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWperiodinfo | | | | DESCRIPTION: Returns size in bytes of region | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 Swath structure ID | | periodID int32 Period ID | | fieldname char Fieldname | | | | | | OUTPUTS: | | ntype int32 field number type | | rank int32 field rank | | dims int32 dimensions of field region | | size int32 size in bytes of field region | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Jun 03 Abe Taaheri added clearing timeflag if SWregioninfo fails | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWperiodinfo(int32 swathID, int32 periodID, const char *fieldname, int32 * ntype, int32 * rank, int32 dims[], int32 * size) { intn status; /* routine return status variable */ timeflag = 1; /* Call SWregioninfo */ /* ----------------- */ status = SWregioninfo(swathID, periodID, fieldname, ntype, rank, dims, size); if (status != 0) timeflag = 0;/* clear timeflag if SWregioninfo failed */ return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefvrtregion | | | | DESCRIPTION: Finds elements of a monotonic field within a given range. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | regionID int32 Region ID | | | | INPUTS: | | swathID int32 Swath structure ID | | regionID int32 Region ID | | vertObj char Vertical object to subset | | range float64 Vertical subsetting range | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Aug 96 Joel Gales Original Programmer | | Dec 96 Joel Gales Add multiple vertical subsetting capability | | May 97 Joel Gales Check for supported field types | | | | END_PROLOG | -----------------------------------------------------------------------------*/ /* Macro to initialize swath region entry */ /* -------------------------------------- */ /* * 1) Find empty (inactive) region. 2) Allocate space for region entry. 3) * Store file ID and swath ID. 4) Set region ID. 5) Initialize vertical * subset entries to -1. */ #define SETSWTHREG \ \ for (k = 0; k < NSWATHREGN; k++) \ { \ if (SWXRegion[k] == 0) \ { \ SWXRegion[k] = (struct swathRegion *) \ calloc(1, sizeof(struct swathRegion)); \ SWXRegion[k]->fid = fid; \ SWXRegion[k]->swathID = swathID; \ regionID = k; \ for (j=0; j<8; j++) \ { \ SWXRegion[k]->StartVertical[j] = -1; \ SWXRegion[k]->StopVertical[j] = -1; \ SWXRegion[k]->StartScan[j] = -1; \ SWXRegion[k]->StopScan[j] = -1; \ SWXRegion[k]->band8flag = -1; \ } \ break; \ } \ } /* Macro to fill vertical subset entry */ /* ----------------------------------- */ /* * 1) Find empty (inactive) vertical region. 2) Set start of vertical region. * 3) Allocate space for name of vertical dimension. 4) Write vertical * dimension name. */ #define FILLVERTREG \ for (j=0; j<8; j++) \ { \ if (SWXRegion[regionID]->StartVertical[j] == -1) \ { \ SWXRegion[regionID]->StartVertical[j] = i; \ SWXRegion[regionID]->DimNamePtr[j] = \ (char *) malloc(slen + 1); \ memcpy(SWXRegion[regionID]->DimNamePtr[j], \ dimlist, slen + 1); \ break; \ } \ } \ int32 SWdefvrtregion(int32 swathID, int32 regionID, const char *vertObj, float64 range[]) { intn i; /* Loop index */ intn j = 0; /* Loop index */ intn k; /* Loop index */ intn status; /* routine return status variable */ uint8 found = 0; /* Found flag */ int16 vertINT16; /* Temporary INT16 variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 slen; /* String length */ int32 rank; /* Field rank */ int32 nt; /* Field numbertype */ int32 dims[8]; /* Field dimensions */ int32 size; /* Size of numbertype in bytes */ int32 vertINT32; /* Temporary INT32 variable */ float32 vertFLT32; /* Temporary FLT32 variable */ float64 vertFLT64; /* Temporary FLT64 variable */ char *vertArr; /* Pointer to vertical field data buffer */ char dimlist[256]; /* Dimension list */ /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWdefvrtregion", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Copy first 4 characters of vertObj into dimlist */ /* ----------------------------------------------- */ memcpy(dimlist, vertObj, 4); dimlist[4] = 0; /* If first 4 characters of vertObj = "DIM:" ... */ /* --------------------------------------------- */ /* Vertical Object is dimension name */ /* --------------------------------- */ if (strcmp(dimlist, "DIM:") == 0) { /* Get string length of vertObj (minus "DIM:) */ /* ------------------------------------------ */ slen = (int)strlen(vertObj) - 4; /* If regionID = -1 then setup swath region entry */ /* ---------------------------------------------- */ if (regionID == -1) { SETSWTHREG; } /* Find first empty (inactive) vertical subset entry */ /* ------------------------------------------------- */ for (j = 0; j < 8; j++) { if (SWXRegion[regionID]->StartVertical[j] == -1) { /* Store start & stop of vertical region */ /* ------------------------------------- */ SWXRegion[regionID]->StartVertical[j] = (int32) range[0]; SWXRegion[regionID]->StopVertical[j] = (int32) range[1]; /* Store vertical dimension name */ /* ----------------------------- */ SWXRegion[regionID]->DimNamePtr[j] = (char *) malloc(slen + 1); if(SWXRegion[regionID]->DimNamePtr[j] == NULL) { HEpush(DFE_NOSPACE,"SWdefvrtregion", __FILE__, __LINE__); return(-1); } memcpy(SWXRegion[regionID]->DimNamePtr[j], vertObj + 4, slen + 1); break; } } } else { /* Vertical Object is fieldname */ /* ---------------------------- */ /* Check for valid fieldname */ /* ------------------------- */ status = SWfieldinfo(swathID, vertObj, &rank, dims, &nt, dimlist); if (status != 0) { status = -1; HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__); HEreport("Vertical Field: \"%s\" not found.\n", vertObj); } /* Check for supported field types */ /* ------------------------------- */ if (nt != DFNT_INT16 && nt != DFNT_INT32 && nt != DFNT_FLOAT32 && nt != DFNT_FLOAT64) { status = -1; HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__); HEreport("Fieldtype: %d not supported for vertical subsetting.\n", nt); } /* Check that vertical dimension is 1D */ /* ----------------------------------- */ if (status == 0) { if (rank != 1) { status = -1; HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__); HEreport("Vertical Field: \"%s\" must be 1-dim.\n", vertObj); } } /* If no problems then continue */ /* ---------------------------- */ if (status == 0) { /* Get string length of vertical dimension */ /* --------------------------------------- */ slen = (int)strlen(dimlist); /* Get size in bytes of vertical field numbertype */ /* ---------------------------------------------- */ size = DFKNTsize(nt); /* Allocate space for vertical field */ /* --------------------------------- */ vertArr = (char *) calloc(dims[0], size); if(vertArr == NULL) { HEpush(DFE_NOSPACE,"SWdefvrtregion", __FILE__, __LINE__); return(-1); } /* Read vertical field */ /* ------------------- */ status = SWreadfield(swathID, vertObj, NULL, NULL, NULL, vertArr); switch (nt) { case DFNT_INT16: for (i = 0; i < dims[0]; i++) { /* Get single element of vertical field */ /* ------------------------------------ */ memcpy(&vertINT16, vertArr + i * size, size); /* If within range ... */ /* ------------------- */ if (vertINT16 >= range[0] && vertINT16 <= range[1]) { /* Set found flag */ /* -------------- */ found = 1; /* If regionID=-1 then setup swath region entry */ /* -------------------------------------------- */ if (regionID == -1) { SETSWTHREG; } /* Fill-in vertical region entries */ /* ------------------------------- */ FILLVERTREG; break; } } /* If found read from "bottom" of data field */ /* ----------------------------------------- */ if (found == 1) { for (i = dims[0] - 1; i >= 0; i--) { /* Get single element of vertical field */ /* ------------------------------------ */ memcpy(&vertINT16, vertArr + i * size, size); /* If within range ... */ /* ------------------- */ if (vertINT16 >= range[0] && vertINT16 <= range[1]) { /* Set end of vertical region */ /* -------------------------- */ SWXRegion[regionID]->StopVertical[j] = i; break; } } } else { /* No vertical entries within region */ /* --------------------------------- */ status = -1; HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__); HEreport("No vertical field entries within region.\n"); } break; case DFNT_INT32: for (i = 0; i < dims[0]; i++) { /* Get single element of vertical field */ /* ------------------------------------ */ memcpy(&vertINT32, vertArr + i * size, size); /* If within range ... */ /* ------------------- */ if (vertINT32 >= range[0] && vertINT32 <= range[1]) { /* Set found flag */ /* -------------- */ found = 1; /* If regionID=-1 then setup swath region entry */ /* -------------------------------------------- */ if (regionID == -1) { SETSWTHREG; } /* Fill-in vertical region entries */ /* ------------------------------- */ FILLVERTREG; break; } } /* If found read from "bottom" of data field */ /* ----------------------------------------- */ if (found == 1) { for (i = dims[0] - 1; i >= 0; i--) { /* Get single element of vertical field */ /* ------------------------------------ */ memcpy(&vertINT32, vertArr + i * size, size); /* If within range ... */ /* ------------------- */ if (vertINT32 >= range[0] && vertINT32 <= range[1]) { /* Set end of vertical region */ /* -------------------------- */ SWXRegion[regionID]->StopVertical[j] = i; break; } } } else { /* No vertical entries within region */ /* --------------------------------- */ status = -1; HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__); HEreport("No vertical field entries within region.\n"); } break; case DFNT_FLOAT32: for (i = 0; i < dims[0]; i++) { /* Get single element of vertical field */ /* ------------------------------------ */ memcpy(&vertFLT32, vertArr + i * size, size); /* If within range ... */ /* ------------------- */ if (vertFLT32 >= range[0] && vertFLT32 <= range[1]) { /* Set found flag */ /* -------------- */ found = 1; /* If regionID=-1 then setup swath region entry */ /* -------------------------------------------- */ if (regionID == -1) { SETSWTHREG; } /* Fill-in vertical region entries */ /* ------------------------------- */ FILLVERTREG; break; } } /* If found read from "bottom" of data field */ /* ----------------------------------------- */ if (found == 1) { for (i = dims[0] - 1; i >= 0; i--) { /* Get single element of vertical field */ /* ------------------------------------ */ memcpy(&vertFLT32, vertArr + i * size, size); /* If within range ... */ /* ------------------- */ if (vertFLT32 >= range[0] && vertFLT32 <= range[1]) { /* Set end of vertical region */ /* -------------------------- */ SWXRegion[regionID]->StopVertical[j] = i; break; } } } else { /* No vertical entries within region */ /* --------------------------------- */ status = -1; HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__); HEreport("No vertical field entries within region.\n"); } break; case DFNT_FLOAT64: for (i = 0; i < dims[0]; i++) { /* Get single element of vertical field */ /* ------------------------------------ */ memcpy(&vertFLT64, vertArr + i * size, size); /* If within range ... */ /* ------------------- */ if (vertFLT64 >= range[0] && vertFLT64 <= range[1]) { /* Set found flag */ /* -------------- */ found = 1; /* If regionID=-1 then setup swath region entry */ /* -------------------------------------------- */ if (regionID == -1) { SETSWTHREG; } /* Fill-in vertical region entries */ /* ------------------------------- */ FILLVERTREG; break; } } /* If found read from "bottom" of data field */ /* ----------------------------------------- */ if (found == 1) { for (i = dims[0] - 1; i >= 0; i--) { /* Get single element of vertical field */ /* ------------------------------------ */ memcpy(&vertFLT64, vertArr + i * size, size); /* If within range ... */ /* ------------------- */ if (vertFLT64 >= range[0] && vertFLT64 <= range[1]) { /* Set end of vertical region */ /* -------------------------- */ SWXRegion[regionID]->StopVertical[j] = i; break; } } } else { /* No vertical entries within region */ /* --------------------------------- */ status = -1; HEpush(DFE_GENAPP, "SWdefvrtregion", __FILE__, __LINE__); HEreport("No vertical field entries within region.\n"); } break; } /* End of switch */ free(vertArr); } } } /* Set regionID to -1 if bad return status */ /* --------------------------------------- */ if (status == -1) { regionID = -1; } return (regionID); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdefscanregion | | | | DESCRIPTION: Initialize the region structure for Landsat 7 float scene | | subset | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | regionID int32 Region ID | | | | INPUTS: | | swathID int32 Swath structure ID | | fieldname char Field name to subset | | range float64 subsetting range | | mode int32 HDFE_ENDPOINT, HDFE_MIDPOINT or | | HDFE_ANYPOINT | | | | OUTPUTS: | | regionID int32 Region ID | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jul 99 DaW Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWdefscanregion(int32 swathID, const char *fieldname, float64 range[], CPL_UNUSED int32 mode) { intn j; /* Loop index */ intn k; /* Loop index */ intn status; /* routine return status variable */ intn land_status = 3; /* routine return status variable */ intn band81flag = 0; intn band82flag = 0; intn band83flag = 0; uint8 detect_cnt = 0; /* Used to convert scan to scanline */ /* L7 float scene sub. */ uint8 scene_cnt = 0; int32 nmtype = 0; /* Used for L7 float scene sub. */ int32 count = 0; /* Used for L7 float scene sub. */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 slen; /* String length */ int32 dfrank[8]; /* data fields rank */ int32 rank; /* Field rank */ int32 numtype[8]; /* number type of data fields */ int32 nt; /* Field numbertype */ int32 dims[8]; /* Field dimensions */ int32 dims2[8]; /* Field dimensions */ int32 strbufsize = 0; /* string buffer size */ int32 tmprange0 = 0; uint16 *buffer = (uint16 *)NULL; int32 *idxmap = (int32 *)NULL; int32 dimsize = 0; int32 regionID = -1; /* Region ID (return) */ float64 scan[2] = {0,0}; float64 original_scan[2] = {0,0}; char dimlist[256]; /* Dimension list */ char swathname[80]; char *dfieldlist = (char *)NULL; /* data field list */ char *tfieldname = (char *)NULL; /* temp field buffer */ char *band81 = (char *)NULL; char *band82 = (char *)NULL; char *band83 = (char *)NULL; /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWdefscanregion", &fid, &sdInterfaceID, &swVgrpID); /* This code checks for the attribute detector_count */ /* which is found in Landsat 7 files. It is used */ /* for some of the loops. The other code checks if */ /* one scan is requested. */ /* ================================================= */ land_status = SWattrinfo(swathID, "detector_count", &nmtype, &count); if (land_status == 0) { scan[0] = range[0]; scan[1] = range[1]; original_scan[0] = range[0]; original_scan[1] = range[1]; land_status = SWreadattr(swathID, "scene_count", &scene_cnt); land_status = SWreadattr(swathID, "detector_count", &detect_cnt); if (range[0] == range[1]) { range[0] = range[0] * detect_cnt - detect_cnt; range[1] = range[0] + detect_cnt - 1; } else { range[0] = range[0] * detect_cnt - detect_cnt; range[1] = range[1] * detect_cnt - 1; } Vgetname(SWXSwath[0].IDTable, swathname); band81 = strstr(swathname, "B81"); if (band81 != (char *)NULL) band81flag = 1; band82 = strstr(swathname, "B82"); if (band82 != (char *)NULL) band82flag = 1; band83 = strstr(swathname, "B83"); if (band83 != (char *)NULL) band83flag = 1; } /* If fieldname is null then subsetting Landsat 7 */ /* floating scene. Get data field name, assume */ /* only one data field in swath */ /* ---------------------------------------------- */ if (fieldname == (char *)NULL) { (void) SWnentries(swathID, 4, &strbufsize); dfieldlist = (char *)calloc(strbufsize + 1, sizeof(char)); (void) SWinqdatafields(swathID, dfieldlist, dfrank, numtype); tfieldname = (char *)calloc(strbufsize + 1, sizeof(char)); strcpy(tfieldname, dfieldlist); } else { slen = (int)strlen(fieldname); tfieldname = (char *)calloc(slen + 1, sizeof(char)); strcpy(tfieldname, fieldname); } /* Check for valid fieldname */ /* ------------------------- */ status = SWfieldinfo(swathID, tfieldname, &rank, dims, &nt, dimlist); if (status != 0) { status = -1; HEpush(DFE_GENAPP, "SWdefscanregion", __FILE__, __LINE__); HEreport("Field: \"%s\" not found.\n", tfieldname); } /* Check if input range values are within range of */ /* data field */ /* ----------------------------------------------- */ if(status == 0) { status = SWfieldinfo(swathID, "scan_no", &rank, dims2, &nt, dimlist); buffer = (uint16 *)calloc(dims2[0], sizeof(uint16)); status = SWreadfield(swathID,"scan_no", NULL, NULL, NULL, buffer); if(scan[0] > buffer[dims2[0]-1]) { HEpush(DFE_GENAPP, "SWdefscanregion", __FILE__, __LINE__); HEreport("Range values not within bounds of data field\n"); free(buffer); buffer = (uint16 *)NULL; if (dfieldlist != NULL) free(dfieldlist); free(tfieldname); return(-1); } if(scan[0] < buffer[0]) { if(scan[1] < buffer[0]) { HEpush(DFE_GENAPP, "SWdefscanregion", __FILE__, __LINE__); HEreport("Range values not within bounds of data field\n"); free(buffer); buffer = (uint16 *)NULL; if (dfieldlist != NULL) free(dfieldlist); free(tfieldname); return(-1); } else { scan[0] = buffer[0]; range[0] = scan[0] * detect_cnt - detect_cnt; } } if(scan[1] > buffer[dims2[0] - 1]) { scan[1] = buffer[dims2[0] - 1]; range[1] = scan[1] * detect_cnt - 1; } } if(status == 0) { dimsize = SWdiminfo(swathID, "GeoTrack"); if(dimsize > 0) { idxmap = (int32 *)calloc(dimsize, sizeof(int32)); (void) SWidxmapinfo(swathID, "GeoTrack", "ScanLineTrack", idxmap); tmprange0 = (int32)range[0]; if(band82flag != 1 && band83flag != 1) { if (range[1] > idxmap[scene_cnt*2 - 1]) { range[1] = idxmap[scene_cnt*2 - 1]; HEreport("Data length compared to geolocation length\n"); } } if(band82flag == 1 || band83flag == 1) { tmprange0 = (int32)(range[0] - (buffer[0] * detect_cnt - detect_cnt)); } if(tmprange0 >= idxmap[scene_cnt * 2 - 1]) { HEpush(DFE_GENAPP, "SWdefscanregion", __FILE__, __LINE__); HEreport( "Range values not within bounds of Latitude/Longitude field(s)\n"); if (dfieldlist != NULL) free(dfieldlist); free(tfieldname); free(buffer); free(idxmap); return(-1); } } } if (status == 0) { slen = (int)strlen(tfieldname); SETSWTHREG; /* Find first empty (inactive) vertical subset entry */ /* ------------------------------------------------- */ for (j = 0; j < 8; j++) { if (SWXRegion[regionID]->StartVertical[j] == -1) { /* Store start & stop of region */ /* ------------------------------------- */ SWXRegion[regionID]->StartScan[j] = (int32) original_scan[0]; SWXRegion[regionID]->StopScan[j] = (int32) original_scan[1]; SWXRegion[regionID]->StartRegion[j] = (int32) range[0]; SWXRegion[regionID]->StopRegion[j] = (int32) range[1]; ++SWXRegion[regionID]->nRegions; SWXRegion[regionID]->scanflag = 1; if(band81flag == 1) SWXRegion[regionID]->band8flag = 1; if(band82flag == 1) SWXRegion[regionID]->band8flag = 2; if(band83flag == 1) SWXRegion[regionID]->band8flag = 3; break; } } } /* Set regionID to -1 if bad return status */ /* --------------------------------------- */ if (status == -1) { regionID = -1; } if (dfieldlist != NULL) free(dfieldlist); free(tfieldname); if (buffer != NULL) free(buffer); if (idxmap != NULL) free(idxmap); return (regionID); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWsetfillvalue | | | | DESCRIPTION: Sets fill value for the specified field. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname char field name | | fillval void fill value | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWsetfillvalue(int32 swathID, const char *fieldname, VOIDP fillval) { intn status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath root Vgroup ID */ int32 sdid; /* SDS id */ int32 nt; /* Number type */ int32 dims[8]; /* Dimensions array */ int32 dum; /* Dummy variable */ int32 solo; /* "Solo" (non-merged) field flag */ char name[80]; /* Fill value "attribute" name */ /* Check for valid swath ID and get SDS interface ID */ status = SWchkswid(swathID, "SWsetfillvalue", &fid, &sdInterfaceID, &swVgrpID); if (status == 0) { /* Get field info */ status = SWfieldinfo(swathID, fieldname, &dum, dims, &nt, NULL); if (status == 0) { /* Get SDS ID and solo flag */ status = SWSDfldsrch(swathID, sdInterfaceID, fieldname, &sdid, &dum, &dum, &dum, dims, &solo); /* If unmerged field then call HDF set field routine */ if (solo == 1) { /* status = */ SDsetfillvalue(sdid, fillval); } /* * Store fill value in attribute. Name is given by fieldname * prepended with "_FV_" */ strcpy(name, "_FV_"); strcat(name, fieldname); status = SWwriteattr(swathID, name, nt, 1, fillval); } else { HEpush(DFE_GENAPP, "SWsetfillvalue", __FILE__, __LINE__); HEreport("Fieldname \"%s\" does not exist.\n", fieldname); } } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWgetfillvalue | | | | DESCRIPTION: Retrieves fill value for a specified field. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | fieldname char field name | | | | OUTPUTS: | | fillval void fill value | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWgetfillvalue(int32 swathID, const char *fieldname, VOIDP fillval) { intn status; /* routine return status variable */ int32 nt; /* Number type */ int32 dims[8]; /* Dimensions array */ int32 dum; /* Dummy variable */ char name[80]; /* Fill value "attribute" name */ /* Check for valid swath ID */ status = SWchkswid(swathID, "SWgetfillvalue", &dum, &dum, &dum); if (status == 0) { /* Get field info */ status = SWfieldinfo(swathID, fieldname, &dum, dims, &nt, NULL); if (status == 0) { /* Read fill value attribute */ strcpy(name, "_FV_"); strcat(name, fieldname); status = SWreadattr(swathID, name, fillval); } else { HEpush(DFE_GENAPP, "SWgetfillvalue", __FILE__, __LINE__); HEreport("Fieldname \"%s\" does not exist.\n", fieldname); } } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWdetach | | | | DESCRIPTION: Detachs swath structure and performs housekeeping | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 swath structure ID | | | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | Aug 96 Joel Gales Cleanup Region External Structure | | Sep 96 Joel Gales Setup dim names for SDsetdimnane in dimbuf1 rather | | than utlstr | | Nov 96 Joel Gales Call SWchkgdid to check for proper swath ID | | Dec 96 Joel Gales Add multiple vertical subsetting garbage collection | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWdetach(int32 swathID) { intn i; /* Loop index */ intn j; /* Loop index */ intn k; /* Loop index */ intn status = 0; /* routine return status variable */ intn statusFill = 0; /* return status from SWgetfillvalue */ uint8 *buf; /* Buffer for blank (initial) 1D records */ int32 vdataID; /* Vdata ID */ int32 *namelen; /* Pointer to name string length array */ int32 *dimlen; /* Pointer to dim string length array */ int32 slen1[3]; /* String length array 1 */ int32 slen2[3]; /* String length array 2 */ int32 nflds; /* Number of fields */ int32 match[5]; /* Merged field match array */ int32 cmbfldcnt; /* Number of fields combined */ int32 sdid; /* SDS ID */ int32 vgid; /* Vgroup ID */ int32 dims[3]; /* Dimension array */ int32 *offset; /* Pointer to merged field offset array */ int32 *indvdims; /* Pointer to merged field size array */ int32 sdInterfaceID; /* SDS interface ID */ int32 sID; /* Swath ID - offset */ int32 nflds0; /* Number of fields */ int32 *namelen0; /* Pointer to name string length array */ int32 rank; /* Rank of merged field */ int32 truerank; /* True rank of merged field */ int32 idOffset = SWIDOFFSET; /* Swath ID offset */ int32 dum; /* Dummy variable */ char *nambuf; /* Pointer to name buffer */ char **nameptr; /* Pointer to name string pointer array */ char **dimptr; /* Pointer to dim string pointer array */ char **nameptr0; /* Pointer to name string pointer array */ char *ptr1[3]; /* String pointer array */ char *ptr2[3]; /* String pointer array */ char dimbuf1[128]; /* Dimension buffer 1 */ char dimbuf2[128]; /* Dimension buffer 2 */ char swathname[VGNAMELENMAX + 1]; /* Swath name */ char *utlbuf; /* Utility buffer */ char fillval[32];/* Fill value buffer */ /* Check for proper swath ID and get SD interface ID */ /* ------------------------------------------------- */ status = SWchkswid(swathID, "SWdetach", &dum, &sdInterfaceID, &dum); if (status == 0) { /* Subtract off swath ID offset and get swath name */ /* ----------------------------------------------- */ sID = swathID % idOffset; Vgetname(SWXSwath[sID].IDTable, swathname); /* Create 1D "orphaned" fields */ /* --------------------------- */ i = 0; /* Find "active" entries in 1d combination array */ /* --------------------------------------------- */ while (SWX1dcomb[3 * i] != 0) { /* For fields defined within swath... */ /* ---------------------------------- */ if (SWX1dcomb[3 * i + 1] == SWXSwath[sID].IDTable) { /* Get dimension size and vdata ID */ /* ------------------------------- */ dims[0] = abs(SWX1dcomb[3 * i]); vdataID = SWX1dcomb[3 * i + 2]; /* Get fieldname (= vdata name) */ /* ---------------------------- */ nambuf = (char *) calloc(VSNAMELENMAX + 1, 1); if(nambuf == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); return(-1); } VSgetname(vdataID, nambuf); /* Set field within vdata */ /* ---------------------- */ VSsetfields(vdataID, nambuf); /* Write (blank) records */ /* --------------------- */ buf = (uint8 *) calloc(VSsizeof(vdataID, nambuf), dims[0]); if(buf == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nambuf); return(-1); } VSwrite(vdataID, buf, dims[0], FULL_INTERLACE); free(buf); free(nambuf); /* Detach Vdata */ /* ------------ */ VSdetach(vdataID); } i++; } /* SDS combined fields */ /* ------------------- */ if (strlen(SWXSDname) == 0) { nflds = 0; /* Allocate "dummy" arrays so free() doesn't bomb later */ /* ---------------------------------------------------- */ nameptr = (char **) calloc(1, sizeof(char *)); if(nameptr == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); return(-1); } namelen = (int32 *) calloc(1, sizeof(int32)); if(namelen == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); return(-1); } nameptr0 = (char **) calloc(1, sizeof(char *)); if(nameptr0 == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); return(-1); } namelen0 = (int32 *) calloc(1, sizeof(int32)); if(namelen0 == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); return(-1); } dimptr = (char **) calloc(1, sizeof(char *)); if(dimptr == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); free(namelen0); return(-1); } dimlen = (int32 *) calloc(1, sizeof(int32)); if(dimlen == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); free(namelen0); free(dimptr); return(-1); } offset = (int32 *) calloc(1, sizeof(int32)); if(offset == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); free(namelen0); free(dimptr); free(dimlen); return(-1); } indvdims = (int32 *) calloc(1, sizeof(int32)); if(indvdims == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); free(namelen0); free(dimptr); free(dimlen); free(offset); return(-1); } } else { /* * "Trim Off" trailing "," and ";" in SWXSDname & SWXSDdims * respectively */ SWXSDname[strlen(SWXSDname) - 1] = 0; SWXSDdims[strlen(SWXSDdims) - 1] = 0; /* Get number of fields from SWXSDname string */ /* ------------------------------------------ */ nflds = EHparsestr(SWXSDname, ',', NULL, NULL); /* Allocate space for various dynamic arrays */ /* ----------------------------------------- */ nameptr = (char **) calloc(nflds, sizeof(char *)); if(nameptr == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); return(-1); } namelen = (int32 *) calloc(nflds, sizeof(int32)); if(namelen == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); return(-1); } nameptr0 = (char **) calloc(nflds, sizeof(char *)); if(nameptr0 == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); return(-1); } namelen0 = (int32 *) calloc(nflds, sizeof(int32)); if(namelen0 == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); return(-1); } dimptr = (char **) calloc(nflds, sizeof(char *)); if(dimptr == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); free(namelen0); return(-1); } dimlen = (int32 *) calloc(nflds, sizeof(int32)); if(dimlen == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); free(namelen0); free(dimptr); return(-1); } offset = (int32 *) calloc(nflds, sizeof(int32)); if(offset == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); free(namelen0); free(dimptr); free(dimlen); return(-1); } indvdims = (int32 *) calloc(nflds, sizeof(int32)); if(indvdims == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nameptr); free(namelen); free(nameptr0); free(namelen0); free(dimptr); free(dimlen); free(offset); return(-1); } /* Parse SWXSDname and SWXSDdims strings */ /* ------------------------------------- */ nflds = EHparsestr(SWXSDname, ',', nameptr, namelen); nflds = EHparsestr(SWXSDdims, ';', dimptr, dimlen); } /* Loop through all the fields */ /* --------------------------- */ for (i = 0; i < nflds; i++) { /* If active entry and field is within swath to be detached ... */ /* ------------------------------------------------------------ */ if (SWXSDcomb[5 * i] != 0 && SWXSDcomb[5 * i + 3] == SWXSwath[sID].IDTable) { nambuf = (char *) calloc(strlen(SWXSDname) + 1, 1); if(nambuf == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); return(-1); } utlbuf = (char *) calloc(2 * strlen(SWXSDname) + 7, 1); if(utlbuf == NULL) { HEpush(DFE_NOSPACE,"SWdetach", __FILE__, __LINE__); free(nambuf); return(-1); } /* Zero out dimbuf1 */ /* ---------------- */ for (k = 0; k < (intn)sizeof(dimbuf1); k++) { dimbuf1[k] = 0; } /* Load array to match, name & parse dims */ /* -------------------------------------- */ memcpy(match, &SWXSDcomb[5 * i], 20); memcpy(nambuf, nameptr[i], namelen[i]); memcpy(dimbuf1, dimptr[i], dimlen[i]); dum = EHparsestr(dimbuf1, ',', ptr1, slen1); /* Separate combined (first) dimension from others */ /* ----------------------------------------------- */ dimbuf1[slen1[0]] = 0; offset[0] = 0; indvdims[0] = abs(match[0]); /* * Loop through remaining fields to check for matches with * current one */ for (j = i + 1, cmbfldcnt = 0; j < nflds; j++) { if (SWXSDcomb[5 * j] != 0) { /* Zero out dimbuf2 */ /* ---------------- */ for (k = 0; k < (intn)sizeof(dimbuf2); k++) { dimbuf2[k] = 0; } /* * Parse the dimensions and separate first for this * entry */ memcpy(dimbuf2, dimptr[j], dimlen[j]); dum = EHparsestr(dimbuf2, ',', ptr2, slen2); dimbuf2[slen2[0]] = 0; /* * If 2nd & 3rd dimension values and names (1st and * 2nd for rank=2 array), swath ID, and numbertype * are equal, then these fields can be combined. */ if (match[1] == SWXSDcomb[5 * j + 1] && match[2] == SWXSDcomb[5 * j + 2] && match[3] == SWXSDcomb[5 * j + 3] && match[4] == SWXSDcomb[5 * j + 4] && strcmp(dimbuf1 + slen1[0] + 1, dimbuf2 + slen2[0] + 1) == 0) { /* Add to combined dimension size */ /* ------------------------------ */ match[0] += SWXSDcomb[5 * j]; /* Concatenate name */ /* ---------------- */ strcat(nambuf, ","); memcpy(nambuf + strlen(nambuf), nameptr[j], namelen[j]); /* * Increment number of merged fields, store * individual dims and dim offsets */ cmbfldcnt++; indvdims[cmbfldcnt] = abs(SWXSDcomb[5 * j]); offset[cmbfldcnt] = offset[cmbfldcnt - 1] + indvdims[cmbfldcnt - 1]; /* Delete this field from combination list */ /* --------------------------------------- */ SWXSDcomb[5 * j] = 0; } } } /* Create SDS */ /* ---------- */ /* Parse names string */ /* ------------------ */ nflds0 = EHparsestr(nambuf, ',', nameptr0, namelen0); if (abs(match[0]) == 1) { /* Two Dimensional Array (no merging has occurred) */ /* ---------------------------------------------- */ dims[0] = abs(match[1]); dims[1] = abs(match[2]); /* Create SDS */ /* ---------- */ rank = 2; sdid = SDcreate(sdInterfaceID, nambuf, SWXSDcomb[5 * i + 4], 2, dims); } else { /* Three Dimensional Array */ /* ----------------------- */ dims[0] = abs(match[0]); dims[1] = abs(match[1]); dims[2] = abs(match[2]); rank = 3; /* * If merged fields then form string consisting of * "MRGFLD_" + 1st field in merge + ":" + entire merged * field list and store in utlbuf. Then write to * MergedField metadata section */ if (cmbfldcnt > 0) { strcpy(utlbuf, "MRGFLD_"); memcpy(utlbuf + 7, nameptr0[0], namelen0[0]); utlbuf[7 + namelen0[0]] = 0; strcat(utlbuf, ":"); strcat(utlbuf, nambuf); status = EHinsertmeta(sdInterfaceID, swathname, "s", 6L, utlbuf, NULL); } else { /* * If not merged field then store field name in * utlbuf */ strcpy(utlbuf, nambuf); } /* Create SDS */ /* ---------- */ sdid = SDcreate(sdInterfaceID, utlbuf, SWXSDcomb[5 * i + 4], 3, dims); /* * If merged field then store dimensions and offsets as * SD attributes */ if (cmbfldcnt > 0) { SDsetattr(sdid, "Field Dims", DFNT_INT32, cmbfldcnt + 1, (VOIDP) indvdims); SDsetattr(sdid, "Field Offsets", DFNT_INT32, cmbfldcnt + 1, (VOIDP) offset); } } /* Register Dimensions in SDS */ /* -------------------------- */ for (k = 0; k < rank; k++) { if (rank == 2) { /* Copy k+1th dimension into dimbuf2 if rank = 2 */ /* --------------------------------------------- */ memcpy(dimbuf2, ptr1[k + 1], slen1[k + 1]); dimbuf2[slen1[k + 1]] = 0; } else { /* Copy kth dimension into dimbuf2 if rank > 2 */ /* ------------------------------------------- */ memcpy(dimbuf2, ptr1[k], slen1[k]); dimbuf2[slen1[k]] = 0; } /* * If first dimension and merged field then generate * dimension name consisting of "MRGDIM:" + swathname + * dimension size */ if (k == 0 && cmbfldcnt > 0) { snprintf(dimbuf2, sizeof(dimbuf2), "%s%s_%ld", "MRGDIM:", swathname, (long)dims[0]); } else { /* Otherwise concatenate swathname to dim name */ /* ------------------------------------------- */ strcat(dimbuf2, ":"); strcat(dimbuf2, swathname); } /* Register dimensions using "SDsetdimname" */ /* ---------------------------------------- */ SDsetdimname(SDgetdimid(sdid, k), (char *) dimbuf2); } /* Write Fill Value */ /* ---------------- */ for (k = 0; k < nflds0; k++) { /* Check if fill values has been set */ /* --------------------------------- */ memcpy(utlbuf, nameptr0[k], namelen0[k]); utlbuf[namelen[k]] = 0; statusFill = SWgetfillvalue(swathID, utlbuf, fillval); if (statusFill == 0) { /* * If merged field then fill value must be stored * manually using EHfillfld */ if (cmbfldcnt > 0) { dims[0] = indvdims[k]; truerank = (dims[0] == 1) ? 2 : 3; EHfillfld(sdid, rank, truerank, DFKNTsize(match[4]), offset[k], dims, fillval); } /* * If single field then just use the HDF set fill * function */ else { status = SDsetfillvalue(sdid, fillval); } } } /* * Insert SDS within the appropriate Vgroup (geo or data) and * "detach" newly-created SDS */ vgid = (match[0] < 0) ? SWXSwath[sID].VIDTable[0] : SWXSwath[sID].VIDTable[1]; Vaddtagref(vgid, DFTAG_NDG, SDidtoref(sdid)); SDendaccess(sdid); free(nambuf); free(utlbuf); } } /* "Contract" 1dcomb array */ /* ----------------------- */ i = 0; while (SWX1dcomb[3 * i] != 0) { if (SWX1dcomb[3 * i + 1] == SWXSwath[sID].IDTable) { memcpy(&SWX1dcomb[3 * i], &SWX1dcomb[3 * (i + 1)], (512 - i - 1) * 3 * 4); } else i++; } /* "Contract" SDcomb array */ /* ----------------------- */ for (i = 0; i < nflds; i++) { if (SWXSDcomb[5 * i + 3] == SWXSwath[sID].IDTable) { if (i == (nflds - 1)) { SWXSDcomb[5 * i] = 0; *(nameptr[i] - (nflds != 1)) = 0; *(dimptr[i] - (nflds != 1)) = 0; } else { memmove(&SWXSDcomb[5 * i], &SWXSDcomb[5 * (i + 1)], (512 - i - 1) * 5 * 4); memmove(nameptr[i], nameptr[i + 1], nameptr[0] + 2048 - nameptr[i + 1] - 1); memmove(dimptr[i], dimptr[i + 1], dimptr[0] + 2048 * 2 - dimptr[i + 1] - 1); } i--; nflds = EHparsestr(SWXSDname, ',', nameptr, namelen); nflds = EHparsestr(SWXSDdims, ';', dimptr, dimlen); } } /* Replace trailing delimiters on SWXSDname & SWXSDdims */ /* ---------------------------------------------------- */ if (nflds != 0) { strcat(SWXSDname, ","); strcat(SWXSDdims, ";"); } /* Free up a bunch of dynamically allocated arrays */ /* ----------------------------------------------- */ free(nameptr); free(namelen); free(nameptr0); free(namelen0); free(dimptr); free(dimlen); free(offset); free(indvdims); /* "Detach" from previously attached SDSs */ /* -------------------------------------- */ for (k = 0; k < SWXSwath[sID].nSDS; k++) { SDendaccess(SWXSwath[sID].sdsID[k]); } free(SWXSwath[sID].sdsID); SWXSwath[sID].sdsID = 0; SWXSwath[sID].nSDS = 0; /* Detach Swath Vgroups */ /* -------------------- */ Vdetach(SWXSwath[sID].VIDTable[0]); Vdetach(SWXSwath[sID].VIDTable[1]); Vdetach(SWXSwath[sID].VIDTable[2]); Vdetach(SWXSwath[sID].IDTable); /* Delete entries from External Arrays */ /* ----------------------------------- */ SWXSwath[sID].active = 0; SWXSwath[sID].VIDTable[0] = 0; SWXSwath[sID].VIDTable[1] = 0; SWXSwath[sID].VIDTable[2] = 0; SWXSwath[sID].IDTable = 0; SWXSwath[sID].fid = 0; /* Free Region Pointers */ /* -------------------- */ for (k = 0; k < NSWATHREGN; k++) { if (SWXRegion[k] != 0 && SWXRegion[k]->swathID == swathID) { for (i = 0; i < 8; i++) { if (SWXRegion[k]->DimNamePtr[i] != 0) { free(SWXRegion[k]->DimNamePtr[i]); } } free(SWXRegion[k]); SWXRegion[k] = 0; } } } return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWclose | | | | DESCRIPTION: Closes HDF-EOS file | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | fid int32 File ID | | | | OUTPUTS: | | None | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Jun 96 Joel Gales Original Programmer | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWclose(int32 fid) { intn status = 0; /* routine return status variable */ /* Call EHclose to perform file close */ /* ---------------------------------- */ status = EHclose(fid); return (status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWupdatescene | | | | DESCRIPTION: Updates the StartRegion and StopRegion values | | for a specified region. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | status intn return status (0) SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 Swath structure ID | | regionID int32 Region ID | | | | NOTES: | | | | Date Programmer Description | | ====== ============ ================================================= | | Nov 98 Xinmin Hua Original developing | | Aug 99 Abe Taaheri Added code to exclude regions that have the same | | start and stop. | | | | END_PROLOG | -----------------------------------------------------------------------------*/ intn SWupdatescene(int32 swathID, int32 regionID) { intn k; /* Loop index */ int32 status; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 startReg; /* Indexed start region */ int32 stopReg; /* Indexed stop region */ int32 l_index[MAXNREGIONS]; /* to store indices when stop and start are different */ int32 ind; /* l_index */ int32 tempnRegions; /* temp number of regions */ memset(l_index, 0, sizeof(int32) * MAXNREGIONS); /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWupdatescene", &fid, &sdInterfaceID, &swVgrpID); /* Check for valid region ID */ /* ------------------------- */ if (status == 0) { if (regionID < 0 || regionID >= NSWATHREGN) { status = -1; HEpush(DFE_RANGE, "SWupdatescene", __FILE__, __LINE__); HEreport("Invalid Region id: %d.\n", regionID); } } /* Check for active region ID */ /* -------------------------- */ if (status == 0) { if (SWXRegion[regionID] == 0) { status = -1; HEpush(DFE_GENAPP, "SWupdatescene", __FILE__, __LINE__); HEreport("Inactive Region ID: %d.\n", regionID); } } if (status == 0) { tempnRegions = SWXRegion[regionID]->nRegions; ind =0; for (k = 0; k < SWXRegion[regionID]->nRegions; k++) { startReg = SWXRegion[regionID]->StartRegion[k]; stopReg = SWXRegion[regionID]->StopRegion[k]; if(startReg == stopReg) { /* reduce number of regions by 1, if tempnRegions is 0 issue error and break from loop*/ tempnRegions -= 1; if(tempnRegions == 0) { /* first free allocated memory for SWXRegion[regionID] in the function SWdefboxregion and make regionID inactive */ free(SWXRegion[regionID]); SWXRegion[regionID] = 0; status = -1; HEpush(DFE_GENAPP, "SWupdatescene", __FILE__, __LINE__); HEreport("Inactive Region ID: %d.\n", regionID); break; } } else { /* store l_index number of regions that have different start and stop */ l_index[ind] = k; ind += 1; } } if (status != 0) { return (status); } else { SWXRegion[regionID]->nRegions = tempnRegions; } /* keep starts and stops that are different in the structure */ for (k = 0; k < SWXRegion[regionID]->nRegions; k++) { SWXRegion[regionID]->StartRegion[k] = SWXRegion[regionID]->StartRegion[l_index[k]]; SWXRegion[regionID]->StopRegion[k] = SWXRegion[regionID]->StopRegion[l_index[k]]; } } if (status == 0) { for (k = 0; k < SWXRegion[regionID]->nRegions; k++) { startReg = SWXRegion[regionID]->StartRegion[k]; stopReg = SWXRegion[regionID]->StopRegion[k]; if(startReg % 2 == 1) { SWXRegion[regionID]->StartRegion[k] = ++startReg; } if(stopReg % 2 == 0) { SWXRegion[regionID]->StopRegion[k] = --stopReg; } } } return(status); } /*----------------------------------------------------------------------------| | BEGIN_PROLOG | | | | FUNCTION: SWupdateidxmap | | | | DESCRIPTION: Updates the map l_index for a specified region. | | | | | | Return Value Type Units Description | | ============ ====== ========= ===================================== | | nout int32 return Number of elements in output | | l_index array if SUCCEED, (-1) FAIL | | | | INPUTS: | | swathID int32 Swath structure ID | | regionID int32 Region ID | | l_indexin int32 array of l_index values | | | | OUTPUTS: | | l_indexout int32 array of l_index values | | indices int32 array of start and stop in region | | | | NOTES: | | | | | | Date Programmer Description | | ====== ============ ================================================= | | Aug 97 Abe Taaheri Original Programmer | | AUG 97 Abe Taaheri Add support for l_index mapping | | Sep 99 DaW Add support for Floating Scene Subsetting Landsat 7 | | | | END_PROLOG | -----------------------------------------------------------------------------*/ int32 SWupdateidxmap(int32 swathID, int32 regionID, int32 l_indexin[], int32 l_indexout[], int32 indicies[]) { intn i; /* Loop index */ intn j; /* Loop index */ intn k; /* Loop index */ int32 status; /* routine return status variable */ int32 land_status = 3; /* routine return status variable */ int32 fid; /* HDF-EOS file ID */ int32 sdInterfaceID; /* HDF SDS interface ID */ int32 swVgrpID; /* Swath Vgroup ID */ int32 numtype = 0; /* Used for L7 float scene sub. */ int32 count = 0; /* Used for L7 float scene sub. */ int32 startReg = 0; /* Indexed start region */ int32 stopReg = 0; /* Indexed stop region */ int32 nout=-1; /* Number of elements in output l_index array */ int32 indexoffset = 0; uint8 scene_cnt = 0; /* Used for L7 float scene sub. */ uint8 detect_cnt = 0; /* Used to convert scan to scanline */ intn gtflag = 0; intn ngtflag = 0; int32 *buffer1 = (int32 *)NULL; int32 *buffer2 = (int32 *)NULL; /* Check for valid swath ID */ /* ------------------------ */ status = SWchkswid(swathID, "SWupdateidxmap", &fid, &sdInterfaceID, &swVgrpID); /* Check for valid region ID */ /* ------------------------- */ if (status == 0) { if (regionID < 0 || regionID >= NSWATHREGN) { status = -1; HEpush(DFE_RANGE, "SWupdateidxmap", __FILE__, __LINE__); HEreport("Invalid Region id: %d.\n", regionID); } } /* Check for active region ID */ /* -------------------------- */ if (status == 0) { if (SWXRegion[regionID] == 0) { status = -1; HEpush(DFE_GENAPP, "SWextractregion", __FILE__, __LINE__); HEreport("Inactive Region ID: %d.\n", regionID); } } if (status == 0) { /* Loop through all regions */ /* ------------------------ */ for (k = 0; k < SWXRegion[regionID]->nRegions; k++) { /* fix overlap l_index mapping problem for Landsat 7 */ startReg = SWXRegion[regionID]->StartRegion[k]; stopReg = SWXRegion[regionID]->StopRegion[k]; if(SWXRegion[regionID]->scanflag == 1) { indicies[0] = -1; indicies[1] = -1; j = 0; /* This code checks for the attribute detector_count */ /* which is found in Landsat 7 files. It is used */ /* for some of the loops. */ /* ================================================= */ land_status = SWattrinfo(swathID, "scene_count", &numtype, &count); if (land_status == 0) { land_status = SWreadattr(swathID, "scene_count", &scene_cnt); land_status = SWreadattr(swathID, "detector_count", &detect_cnt); } /* calculate the offsets first */ buffer1 = (int32 *)calloc(74, sizeof(int32)); buffer2 = (int32 *)calloc(74, sizeof(int32)); status = SWidxmapinfo(swathID,"GeoTrack", "ScanLineTrack", (int32*)buffer1); status = SWidxmapinfo(swathID,"UpperTrack", "ScanLineTrack", (int32*)buffer2); indexoffset = buffer2[0] - buffer1[0]; free(buffer1); free(buffer2); if(SWXRegion[regionID]->band8flag == -1) { for(i=0; i= startReg) if(indicies[0] == -1) indicies[0] = j; if(l_indexin[j] <= stopReg && l_indexin[j+1] >= stopReg) indicies[1] = j + 1; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } if(indicies[0] == -1) { if(startReg <= l_indexin[0]) indicies[0] = 0; } if(indicies[0] == -1) { j = 0; for(i=0; i= startReg) if(indicies[0] == -1) indicies[0] = j; j = j + 1; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } } if(indicies[1] == -1) { j = 0; for(i=0; i= stopReg) if(indicies[1] == -1) indicies[1] = j + 1; j = j + 1; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } } if(indicies[1] == -1) if(stopReg > l_indexin[scene_cnt - 1]) indicies[1] = scene_cnt - 1; } /* This section of code handles exceptions in Landsat 7 */ /* data. The Band 8 data - multiple files, data gaps */ /* ===================================================== */ if(SWXRegion[regionID]->band8flag == 1 || SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { j = 0; for(i=0; i= (l_indexin[j] + indexoffset - detect_cnt) && startReg <= (l_indexin[j+1] + indexoffset - detect_cnt) ) if(indicies[0] == -1) indicies[0] = j; if( stopReg >= (l_indexin[j] + indexoffset - detect_cnt ) && stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) ) indicies[1] = j + 1; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } if(SWXRegion[regionID]->band8flag == 1) { if(indicies[1] == -1) if(stopReg > (l_indexin[j - 1] + indexoffset - detect_cnt)) indicies[1] = j - 1; } if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { if(startReg >= (l_indexin[j - 1] + indexoffset - detect_cnt)) { indicies[0] = -1; indicies[1] = -1; /* status = SWfieldinfo(swathID, "scan_no", &rank, dims2, &nt, dimlist); buffer = (uint16 *)calloc(dims2[0], sizeof(uint16)); status = SWreadfield(swathID,"scan_no", NULL, NULL, NULL, buffer); indexoffset = buffer[0] * detect_cnt; free(buffer); startReg = startReg - (indexoffset - detect_cnt); stopReg = stopReg - (indexoffset - 1); */ j = 0; for(i=0; i= (l_indexin[j] + indexoffset - detect_cnt) && startReg <= (l_indexin[j+1] + indexoffset - detect_cnt) ) if(indicies[0] == -1) indicies[0] = j; if( stopReg >= (l_indexin[j] + indexoffset - detect_cnt ) && stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) ) indicies[1] = j + 1; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } } if(indicies[0] == -1) { j = 0; for(i=0; i= (l_indexin[j] + indexoffset - detect_cnt) && startReg <= (l_indexin[j+1] + indexoffset - detect_cnt) ) if(indicies[0] == -1) indicies[0] = j; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } } if(indicies[1] == -1) if(stopReg > (l_indexin[j - 1] + indexoffset - detect_cnt) ) indicies[1] = j - 1; } if(indicies[1] == -1) { j = 0; for(i=0; i= (l_indexin[j] + indexoffset - detect_cnt ) && stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) ) indicies[1] = j; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } } } if(ngtflag == 1) { for(i=0; i= l_indexin[j] && startReg <= l_indexin[j+1]) if(indicies[0] == -1) indicies[0] = j; if( stopReg >= l_indexin[j] && stopReg <= l_indexin[j+1]) indicies[1] = j + 1; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } if(SWXRegion[regionID]->band8flag == 2) { if(startReg >= l_indexin[j] ) { if(indicies[0] == -1) indicies[0] = j; if(indicies[1] == -1) indicies[1] = j; } if(indicies[0] == -1) if(startReg <= l_indexin[0]) indicies[0] = 0; if(indicies[1] == -1) if(stopReg > l_indexin[j]) indicies[1] = j; } if(indicies[0] == -1) { j = 0; for(i=0; i= l_indexin[j] && startReg <= l_indexin[j+1]) indicies[0] = j; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } } if(indicies[1] == -1) { j = 0; for(i=0; i= l_indexin[j] && stopReg <= l_indexin[j+1]) indicies[1] = j; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } } if(indicies[1] == -1) { if(stopReg > l_indexin[j]) indicies[1] = j; } } if(indicies[0] == -1) { if(startReg <= (l_indexin[0]+ indexoffset - detect_cnt) ) indicies[0] = 0; if(indicies[1] == -1) if(stopReg > (l_indexin[j] + indexoffset - detect_cnt)) indicies[1] = j; } } if (indicies[1] == -1) { if(SWXRegion[regionID]->band8flag == 2 || SWXRegion[regionID]->band8flag == 3) { if(stopReg < (l_indexin[0] + indexoffset - detect_cnt)) { /*status = SWfieldinfo(swathID, "scan_no", &rank, dims2, &nt, dimlist); buffer = (uint16 *)calloc(dims2[0], sizeof(uint16)); status = SWreadfield(swathID,"scan_no", NULL, NULL, NULL, buffer); indexoffset = buffer[0] * detect_cnt; free(buffer); startReg = startReg + (indexoffset - detect_cnt); stopReg = stopReg + (indexoffset - 1); */ if(stopReg >= (l_indexin[scene_cnt - 1] + indexoffset - detect_cnt)) { indicies[1] = scene_cnt - 1; } else { j = 0; for(i=0;i= (l_indexin[j] + indexoffset - detect_cnt ) && stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) ) indicies[1] = j; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } } } if(startReg > (l_indexin[j - 1] + indexoffset - detect_cnt )) { indicies[0] = -1; indicies[1] = -1; /*status = SWfieldinfo(swathID, "scan_no", &rank, dims2, &nt, dimlist); buffer = (uint16 *)calloc(dims2[0], sizeof(uint16)); status = SWreadfield(swathID,"scan_no", NULL, NULL, NULL, buffer); indexoffset = buffer[0] * detect_cnt; free(buffer); startReg = startReg - (indexoffset - detect_cnt); stopReg = stopReg - (indexoffset - 1);*/ j = 0; for(i=0; i= (l_indexin[j] + indexoffset - detect_cnt) && startReg <= (l_indexin[j+1] + indexoffset - detect_cnt) ) if(indicies[0] == -1) indicies[0] = j; if( stopReg >= (l_indexin[j] + indexoffset - detect_cnt ) && stopReg <= (l_indexin[j+1] + indexoffset - detect_cnt ) ) indicies[1] = j + 1; j = j + 2; if(l_indexin[j] == 0 || l_indexin[j+1] == 0) i = scene_cnt; } if(indicies[0] == -1) if(startReg < (l_indexin[0] + indexoffset - detect_cnt)) indicies[0] = 0; if(indicies[1] == -1) if(stopReg > (l_indexin[j - 1] + indexoffset - detect_cnt)) indicies[1] = j - 1; } } } } /* end of if for floating scene update */ else { /* If start of region is odd then increment */ /* ---------------------------------------- */ if (startReg % 2 == 1) { startReg++; } /* If end of region is even then decrement */ /* --------------------------------------- */ if (stopReg % 2 == 0) { stopReg--; } indicies[0]=startReg; indicies[1]=stopReg; } } if (l_indexout != NULL) { if(SWXRegion[regionID]->scanflag == 1) { nout = (indicies[1] - indicies[0] + 1); j = 0; if (nout == 1) l_indexout[0] = l_indexin[indicies[0]]; for(i=0; i