COASPMetadataGeorefGridItem::COASPMetadataGeorefGridItem(int nIdIn, int nPixelsIn,
int nLinesIn, double ndLatIn, double ndLongIn)
{
this->nId = nIdIn;
this->nPixels = nPixelsIn;
this->nLines = nLinesIn;
this->ndLat = ndLatIn;
this->ndLong = ndLongIn;
pszItemName = VSIStrdup("georef_grid");
}
COASPMetadataGeorefGridItem::COASPMetadataGeorefGridItem(int nId, int nPixels,
int nLines, double ndLat, double ndLong)
{
this->nId = nId;
this->nPixels = nPixels;
this->nLines = nLines;
this->ndLat = ndLat;
this->ndLong = ndLong;
this->pszItemName = VSIStrdup("georef_grid");
}
char *CPLStrdup( const char * pszString )
{
char *pszReturn;
if( pszString == NULL )
pszString = "";
pszReturn = VSIStrdup( pszString );
if( pszReturn == NULL )
{
CPLError( CE_Fatal, CPLE_OutOfMemory,
"CPLStrdup(): Out of memory allocating %d bytes.\n",
strlen(pszString) );
}
return( pszReturn );
}
GDALDataset *DOQ1Dataset::Open( GDALOpenInfo * poOpenInfo )
{
int nWidth, nHeight, nBandStorage, nBandTypes;
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the binary (ie. .bil) file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 212 )
return NULL;
/* -------------------------------------------------------------------- */
/* Attempt to extract a few key values from the header. */
/* -------------------------------------------------------------------- */
nWidth = (int) DOQGetField(poOpenInfo->pabyHeader + 150, 6);
nHeight = (int) DOQGetField(poOpenInfo->pabyHeader + 144, 6);
nBandStorage = (int) DOQGetField(poOpenInfo->pabyHeader + 162, 3);
nBandTypes = (int) DOQGetField(poOpenInfo->pabyHeader + 156, 3);
/* -------------------------------------------------------------------- */
/* Do these values look coherent for a DOQ file? It would be */
/* nice to do a more comprehensive test than this! */
/* -------------------------------------------------------------------- */
if( nWidth < 500 || nWidth > 25000
|| nHeight < 500 || nHeight > 25000
|| nBandStorage < 0 || nBandStorage > 4
|| nBandTypes < 1 || nBandTypes > 9 )
return NULL;
/* -------------------------------------------------------------------- */
/* Check the configuration. We don't currently handle all */
/* variations, only the common ones. */
/* -------------------------------------------------------------------- */
if( nBandTypes > 5 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"DOQ Data Type (%d) is not a supported configuration.\n",
nBandTypes );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The DOQ1 driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DOQ1Dataset *poDS;
poDS = new DOQ1Dataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
poDS->fpImage = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (poDS->fpImage == NULL)
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Compute layout of data. */
/* -------------------------------------------------------------------- */
int nSkipBytes, nBytesPerPixel=0, nBytesPerLine, i;
if( nBandTypes < 5 )
nBytesPerPixel = 1;
else if( nBandTypes == 5 )
nBytesPerPixel = 3;
nBytesPerLine = nBytesPerPixel * nWidth;
nSkipBytes = 4 * nBytesPerLine;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = nBytesPerPixel;
for( i = 0; i < poDS->nBands; i++ )
{
poDS->SetBand( i+1,
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + i, nBytesPerPixel, nBytesPerLine,
GDT_Byte, TRUE, TRUE ) );
}
/* -------------------------------------------------------------------- */
/* Set the description. */
/* -------------------------------------------------------------------- */
DOQGetDescription(poDS, poOpenInfo->pabyHeader);
/* -------------------------------------------------------------------- */
/* Establish the projection string. */
/* -------------------------------------------------------------------- */
if( ((int) DOQGetField(poOpenInfo->pabyHeader + 195, 3)) != 1 )
poDS->pszProjection = VSIStrdup("");
else
{
const char *pszDatumLong, *pszDatumShort;
const char *pszUnits;
int nZone;
nZone = (int) DOQGetField(poOpenInfo->pabyHeader + 198, 6);
if( ((int) DOQGetField(poOpenInfo->pabyHeader + 204, 3)) == 1 )
pszUnits = "UNIT[\"US survey foot\",0.304800609601219]";
else
pszUnits = "UNIT[\"metre\",1]";
switch( (int) DOQGetField(poOpenInfo->pabyHeader + 167, 2) )
{
case 1:
pszDatumLong = NAD27_DATUM;
pszDatumShort = "NAD 27";
break;
case 2:
pszDatumLong = WGS72_DATUM;
pszDatumShort = "WGS 72";
break;
case 3:
pszDatumLong = WGS84_DATUM;
pszDatumShort = "WGS 84";
break;
case 4:
pszDatumLong = NAD83_DATUM;
pszDatumShort = "NAD 83";
break;
default:
pszDatumLong = "DATUM[\"unknown\"]";
pszDatumShort = "unknown";
break;
}
poDS->pszProjection =
CPLStrdup(CPLSPrintf( UTM_FORMAT, pszDatumShort, nZone,
pszDatumLong, nZone * 6 - 183, pszUnits ));
}
/* -------------------------------------------------------------------- */
/* Read the georeferencing information. */
/* -------------------------------------------------------------------- */
unsigned char abyRecordData[500];
if( VSIFSeekL( poDS->fpImage, nBytesPerLine * 2, SEEK_SET ) != 0
|| VSIFReadL(abyRecordData,sizeof(abyRecordData),1,poDS->fpImage) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Header read error on %s.\n",
poOpenInfo->pszFilename );
delete poDS;
return NULL;
}
poDS->dfULX = DOQGetField( abyRecordData + 288, 24 );
poDS->dfULY = DOQGetField( abyRecordData + 312, 24 );
if( VSIFSeekL( poDS->fpImage, nBytesPerLine * 3, SEEK_SET ) != 0
|| VSIFReadL(abyRecordData,sizeof(abyRecordData),1,poDS->fpImage) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Header read error on %s.\n",
poOpenInfo->pszFilename );
delete poDS;
return NULL;
}
poDS->dfXPixelSize = DOQGetField( abyRecordData + 59, 12 );
poDS->dfYPixelSize = DOQGetField( abyRecordData + 71, 12 );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GXFHandle GXFOpen( const char * pszFilename )
{
FILE *fp;
GXFInfo_t *psGXF;
char szTitle[71];
char **papszList;
int nHeaderCount = 0;
/* -------------------------------------------------------------------- */
/* We open in binary to ensure that we can efficiently seek() */
/* to any location when reading scanlines randomly. If we */
/* opened as text we might still be able to seek(), but I */
/* believe that on Windows, the C library has to read through */
/* all the data to find the right spot taking into account DOS */
/* CRs. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( pszFilename, "rb" );
if( fp == NULL )
{
/* how to effectively communicate this error out? */
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open file: %s\n", pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the GXF Information object. */
/* -------------------------------------------------------------------- */
psGXF = (GXFInfo_t *) VSICalloc( sizeof(GXFInfo_t), 1 );
psGXF->fp = fp;
psGXF->dfTransformScale = 1.0;
psGXF->nSense = GXFS_LL_RIGHT;
psGXF->dfXPixelSize = 1.0;
psGXF->dfYPixelSize = 1.0;
psGXF->dfSetDummyTo = -1e12;
psGXF->dfUnitToMeter = 1.0;
psGXF->pszTitle = VSIStrdup("");
/* -------------------------------------------------------------------- */
/* Read the header, one line at a time. */
/* -------------------------------------------------------------------- */
while( (papszList = GXFReadHeaderValue( fp, szTitle)) != NULL && nHeaderCount < MAX_HEADER_COUNT )
{
if( EQUALN(szTitle,"#TITL",5) )
{
CPLFree( psGXF->pszTitle );
psGXF->pszTitle = CPLStrdup( papszList[0] );
}
else if( EQUALN(szTitle,"#POIN",5) )
{
psGXF->nRawXSize = atoi(papszList[0]);
}
else if( EQUALN(szTitle,"#ROWS",5) )
{
psGXF->nRawYSize = atoi(papszList[0]);
}
else if( EQUALN(szTitle,"#PTSE",5) )
{
psGXF->dfXPixelSize = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#RWSE",5) )
{
psGXF->dfYPixelSize = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#DUMM",5) )
{
memset( psGXF->szDummy, 0, sizeof(psGXF->szDummy));
strncpy( psGXF->szDummy, papszList[0], sizeof(psGXF->szDummy) - 1);
psGXF->dfSetDummyTo = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#XORI",5) )
{
psGXF->dfXOrigin = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#YORI",5) )
{
psGXF->dfYOrigin = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#ZMIN",5) )
{
psGXF->dfZMinimum = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#ZMAX",5) )
{
psGXF->dfZMaximum = CPLAtof(papszList[0]);
}
else if( EQUALN(szTitle,"#SENS",5) )
{
psGXF->nSense = atoi(papszList[0]);
}
else if( EQUALN(szTitle,"#MAP_PROJECTION",8) )
{
psGXF->papszMapProjection = papszList;
papszList = NULL;
}
else if( EQUALN(szTitle,"#MAP_D",5) )
{
psGXF->papszMapDatumTransform = papszList;
papszList = NULL;
}
else if( EQUALN(szTitle,"#UNIT",5) )
{
char **papszFields;
papszFields = CSLTokenizeStringComplex( papszList[0], ", ",
TRUE, TRUE );
if( CSLCount(papszFields) > 1 )
{
psGXF->pszUnitName = VSIStrdup( papszFields[0] );
psGXF->dfUnitToMeter = CPLAtof( papszFields[1] );
if( psGXF->dfUnitToMeter == 0.0 )
psGXF->dfUnitToMeter = 1.0;
}
CSLDestroy( papszFields );
}
else if( EQUALN(szTitle,"#TRAN",5) )
{
char **papszFields;
papszFields = CSLTokenizeStringComplex( papszList[0], ", ",
TRUE, TRUE );
if( CSLCount(papszFields) > 1 )
{
psGXF->dfTransformScale = CPLAtof(papszFields[0]);
psGXF->dfTransformOffset = CPLAtof(papszFields[1]);
}
if( CSLCount(papszFields) > 2 )
psGXF->pszTransformName = CPLStrdup( papszFields[2] );
CSLDestroy( papszFields );
}
else if( EQUALN(szTitle,"#GTYPE",5) )
{
psGXF->nGType = atoi(papszList[0]);
}
CSLDestroy( papszList );
nHeaderCount ++;
}
CSLDestroy( papszList );
/* -------------------------------------------------------------------- */
/* Did we find the #GRID? */
/* -------------------------------------------------------------------- */
if( !EQUALN(szTitle,"#GRID",5) )
{
GXFClose( psGXF );
CPLError( CE_Failure, CPLE_WrongFormat,
"Didn't parse through to #GRID successfully in.\n"
"file `%s'.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Allocate, and initialize the raw scanline offset array. */
/* -------------------------------------------------------------------- */
if( psGXF->nRawYSize <= 0 )
{
GXFClose( psGXF );
return NULL;
}
psGXF->panRawLineOffset = (long *)
VSICalloc( sizeof(long), psGXF->nRawYSize+1 );
if( psGXF->panRawLineOffset == NULL )
{
GXFClose( psGXF );
return NULL;
}
psGXF->panRawLineOffset[0] = VSIFTell( psGXF->fp );
/* -------------------------------------------------------------------- */
/* Update the zmin/zmax values to take into account #TRANSFORM */
/* information. */
/* -------------------------------------------------------------------- */
if( psGXF->dfZMinimum != 0.0 || psGXF->dfZMaximum != 0.0 )
{
psGXF->dfZMinimum = (psGXF->dfZMinimum * psGXF->dfTransformScale)
+ psGXF->dfTransformOffset;
psGXF->dfZMaximum = (psGXF->dfZMaximum * psGXF->dfTransformScale)
+ psGXF->dfTransformOffset;
}
return( (GXFHandle) psGXF );
}
GDALDataset *COASPDataset::Open( GDALOpenInfo *poOpenInfo )
{
if (!COASPDataset::Identify(poOpenInfo))
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The COASP driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* Create a fresh dataset for us to work with */
COASPDataset *poDS;
poDS = new COASPDataset();
if (poDS == NULL)
return NULL;
/* Steal the file pointer for the header */
poDS->fpHdr = poOpenInfo->fp;
poOpenInfo->fp = NULL;
/* Set the binary matrix file pointers to NULL, for now */
poDS->fpBinHH = NULL;
poDS->fpBinHV = NULL;
poDS->fpBinVH = NULL;
poDS->fpBinVV = NULL;
poDS->pszFileName = VSIStrdup(poOpenInfo->pszFilename);
/* determine the file name prefix */
const char *pszFilename;
char *pszBaseName = VSIStrdup(CPLGetBasename(poDS->pszFileName));
char *pszDir = VSIStrdup(CPLGetPath(poDS->pszFileName));
const char *pszExt = "rc";
int nNull = strlen(pszBaseName) - 1;
char *pszBase = (char *)CPLMalloc(nNull);
strncpy(pszBase, pszBaseName, nNull);
pszBase[nNull - 1] = '\0';
free(pszBaseName);
char *psChan = strstr(pszBase,"hh");;
if (psChan == NULL) {
psChan = strstr(pszBase, "hv");
}
if (psChan == NULL) {
psChan = strstr(pszBase, "vh");
}
if (psChan == NULL) {
psChan = strstr(pszBase, "vv");
}
if (psChan == NULL) {
CPLError(CE_Fatal, 1, "unable to recognize file as COASP.\n");
free(poDS->pszFileName);
free(pszBase);
free(pszDir);
delete poDS;
return NULL;
}
/* Read Metadata, set GCPs as is appropriate */
COASPMetadataReader *poReader = new COASPMetadataReader(
poDS->pszFileName);
/* Get Image X and Y widths */
poReader->GotoMetadataItem("number_lines");
COASPMetadataItem *poItem = poReader->GetNextItem();
char *nValue = poItem->GetItemValue();
poDS->nRasterYSize = atoi(nValue);
free(nValue);
poReader->GotoMetadataItem("number_samples");
poItem = poReader->GetNextItem();
nValue = poItem->GetItemValue();
poDS->nRasterXSize = atoi(nValue);
free(nValue);
/* Horizontal transmit, horizontal receive */
psChan[0] = 'h';
psChan[1] = 'h';
pszFilename = CPLFormFilename(pszDir, pszBase, pszExt);
poDS->fpBinHH = VSIFOpenL(pszFilename, "r");
if (poDS->fpBinHH != 0) {
/* Set raster band */
poDS->SetBand(1, new COASPRasterBand(poDS, GDT_CFloat32,
hh , poDS->fpBinHH));
}
/* Horizontal transmit, vertical receive */
psChan[0] = 'h';
psChan[1] = 'v';
pszFilename = CPLFormFilename(pszDir, pszBase, pszExt);
poDS->fpBinHV = VSIFOpenL(pszFilename, "r");
if (poDS->fpBinHV != 0) {
poDS->SetBand(2, new COASPRasterBand(poDS, GDT_CFloat32,
hv, poDS->fpBinHV));
}
/* Vertical transmit, horizontal receive */
psChan[0] = 'v';
psChan[1] = 'h';
pszFilename = CPLFormFilename(pszDir, pszBase, pszExt);
poDS->fpBinVH = VSIFOpenL(pszFilename, "r");
if (poDS->fpBinVH != 0) {
poDS->SetBand(3, new COASPRasterBand(poDS, GDT_CFloat32,
vh, poDS->fpBinVH));
}
/* Vertical transmit, vertical receive */
psChan[0] = 'v';
psChan[1] = 'v';
pszFilename = CPLFormFilename(pszDir, pszBase, pszExt);
poDS->fpBinVV = VSIFOpenL(pszFilename, "r");
if (poDS->fpBinVV != 0) {
poDS->SetBand(4, new COASPRasterBand(poDS, GDT_CFloat32,
vv, poDS->fpBinVV));
}
/* Oops, missing all the data? */
if (poDS->fpBinHH == NULL && poDS->fpBinHV == NULL
&& poDS->fpBinVH == NULL && poDS->fpBinVV == NULL)
{
CPLError(CE_Fatal,1,"Unable to find any data! Aborting.");
free(pszBase);
free(pszDir);
delete poDS;
return NULL;
}
if ( poDS->GetRasterCount() == 4 ) {
poDS->SetMetadataItem( "MATRIX_REPRESENTATION", "SCATTERING" );
}
free(pszBase);
free(pszDir);
poDS->nGCPCount = 0;
poDS->pasGCP = NULL;
delete poItem;
delete poReader;
return poDS;
}
char *COASPMetadataItem::GetItemValue()
{
return VSIStrdup(pszItemValue);
}
COASPMetadataItem::COASPMetadataItem(char *pszItemName, char *pszItemValue)
{
this->pszItemName = VSIStrdup(pszItemName);
this->pszItemValue = VSIStrdup(pszItemValue);
}
static
void OGRSQLiteREGEXPFunction(sqlite3_context *ctx, int argc, sqlite3_value **argv)
{
const char *re, *str;
pcre *p;
pcre_extra *e;
CPLAssert(argc == 2);
re = (const char *) sqlite3_value_text(argv[0]);
if (!re) {
sqlite3_result_error(ctx, "no regexp", -1);
return;
}
if( sqlite3_value_type(argv[1]) == SQLITE_NULL )
{
sqlite3_result_int(ctx, 0);
return;
}
str = (const char *) sqlite3_value_text(argv[1]);
if (!str) {
sqlite3_result_error(ctx, "no string", -1);
return;
}
/* simple LRU cache */
int i;
int found = 0;
cache_entry *cache = (cache_entry*) sqlite3_user_data(ctx);
CPLAssert(cache);
for (i = 0; i < CACHE_SIZE && cache[i].s; i++)
{
if (strcmp(re, cache[i].s) == 0) {
found = 1;
break;
}
}
if (found)
{
if (i > 0)
{
cache_entry c = cache[i];
memmove(cache + 1, cache, i * sizeof(cache_entry));
cache[0] = c;
}
}
else
{
cache_entry c;
const char *err;
int pos;
c.p = pcre_compile(re, 0, &err, &pos, NULL);
if (!c.p)
{
char *e2 = sqlite3_mprintf("%s: %s (offset %d)", re, err, pos);
sqlite3_result_error(ctx, e2, -1);
sqlite3_free(e2);
return;
}
c.e = pcre_study(c.p, 0, &err);
c.s = VSIStrdup(re);
if (!c.s)
{
sqlite3_result_error(ctx, "strdup: ENOMEM", -1);
pcre_free(c.p);
pcre_free(c.e);
return;
}
i = CACHE_SIZE - 1;
if (cache[i].s)
{
CPLFree(cache[i].s);
CPLAssert(cache[i].p);
pcre_free(cache[i].p);
pcre_free(cache[i].e);
}
memmove(cache + 1, cache, i * sizeof(cache_entry));
cache[0] = c;
}
p = cache[0].p;
e = cache[0].e;
int rc;
CPLAssert(p);
rc = pcre_exec(p, e, str, strlen(str), 0, 0, NULL, 0);
sqlite3_result_int(ctx, rc >= 0);
}
GDALDataset *PALSARJaxaDataset::Open( GDALOpenInfo * poOpenInfo ) {
/* Check that this actually is a JAXA PALSAR product */
if ( !PALSARJaxaDataset::Identify(poOpenInfo) )
return NULL;
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The JAXAPALSAR driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
PALSARJaxaDataset *poDS = new PALSARJaxaDataset();
/* Get the suffix of the filename, we'll need this */
char *pszSuffix = VSIStrdup( (char *)
(CPLGetFilename( poOpenInfo->pszFilename ) + 3) );
/* Try to read each of the polarizations */
char *pszImgFile = (char *)VSIMalloc(
strlen( CPLGetDirname( poOpenInfo->pszFilename ) ) +
strlen( pszSuffix ) + 8 );
int nBandNum = 1;
/* HH */
FILE *fpHH;
sprintf( pszImgFile, "%s%sIMG-HH%s",
CPLGetDirname(poOpenInfo->pszFilename), SEP_STRING, pszSuffix );
fpHH = VSIFOpenL( pszImgFile, "rb" );
if (fpHH != NULL) {
poDS->SetBand( nBandNum, new PALSARJaxaRasterBand( poDS, 0, fpHH ) );
nBandNum++;
}
/* HV */
FILE *fpHV;
sprintf( pszImgFile, "%s%sIMG-HV%s",
CPLGetDirname(poOpenInfo->pszFilename), SEP_STRING, pszSuffix );
fpHV = VSIFOpenL( pszImgFile, "rb" );
if (fpHV != NULL) {
poDS->SetBand( nBandNum, new PALSARJaxaRasterBand( poDS, 1, fpHV ) );
nBandNum++;
}
/* VH */
FILE *fpVH;
sprintf( pszImgFile, "%s%sIMG-VH%s",
CPLGetDirname(poOpenInfo->pszFilename), SEP_STRING, pszSuffix );
fpVH = VSIFOpenL( pszImgFile, "rb" );
if (fpVH != NULL) {
poDS->SetBand( nBandNum, new PALSARJaxaRasterBand( poDS, 2, fpVH ) );
nBandNum++;
}
/* VV */
FILE *fpVV;
sprintf( pszImgFile, "%s%sIMG-VV%s",
CPLGetDirname(poOpenInfo->pszFilename), SEP_STRING, pszSuffix );
fpVV = VSIFOpenL( pszImgFile, "rb" );
if (fpVV != NULL) {
poDS->SetBand( nBandNum, new PALSARJaxaRasterBand( poDS, 3, fpVV ) );
nBandNum++;
}
VSIFree( pszImgFile );
/* did we get at least one band? */
if (fpVV == NULL && fpVH == NULL && fpHV == NULL && fpHH == NULL) {
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find any image data. Aborting opening as PALSAR image.");
delete poDS;
return NULL;
}
/* read metadata from Leader file. */
char *pszLeaderFilename = (char *)VSIMalloc(
strlen( CPLGetDirname( poOpenInfo->pszFilename ) ) +
strlen(pszSuffix) + 5 );
sprintf( pszLeaderFilename, "%s%sLED%s",
CPLGetDirname( poOpenInfo->pszFilename ) , SEP_STRING, pszSuffix );
FILE *fpLeader = VSIFOpenL( pszLeaderFilename, "rb" );
/* check if the leader is actually present */
if (fpLeader != NULL) {
ReadMetadata(poDS, fpLeader);
VSIFCloseL(fpLeader);
}
VSIFree(pszLeaderFilename);
VSIFree( pszSuffix );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
COASPMetadataItem::COASPMetadataItem(char *pszItemName_, char *pszItemValue_)
{
pszItemName = VSIStrdup(pszItemName_);
pszItemValue = VSIStrdup(pszItemValue_);
}
