void EnvisatDataset::CollectDSDMetadata()
{
char *pszDSName, *pszFilename;
int iDSD;
for( iDSD = 0;
EnvisatFile_GetDatasetInfo( hEnvisatFile, iDSD, &pszDSName, NULL,
&pszFilename, NULL, NULL, NULL, NULL ) == SUCCESS;
iDSD++ )
{
if( pszFilename == NULL
|| strlen(pszFilename) == 0
|| EQUALN(pszFilename,"NOT USED",8)
|| EQUALN(pszFilename," ",8))
continue;
char szKey[128], szTrimmedName[128];
int i;
strcpy( szKey, "DS_" );
strcat( szKey, pszDSName );
// strip trailing spaces.
for( i = strlen(szKey)-1; i && szKey[i] == ' '; i-- )
szKey[i] = '\0';
// convert spaces into underscores.
for( i = 0; szKey[i] != '\0'; i++ )
{
if( szKey[i] == ' ' )
szKey[i] = '_';
}
strcat( szKey, "_NAME" );
strcpy( szTrimmedName, pszFilename );
for( i = strlen(szTrimmedName)-1; i && szTrimmedName[i] == ' '; i--)
szTrimmedName[i] = '\0';
SetMetadataItem( szKey, szTrimmedName );
}
}
int EnvisatFile_GetCurrentLength( EnvisatFile *self )
{
int length;
int ds;
int ds_offset;
int ds_size;
length = MPH_SIZE
+ EnvisatFile_GetKeyValueAsInt( self, MPH, "SPH_SIZE", 0 );
for( ds = 0;
EnvisatFile_GetDatasetInfo( self, ds, NULL, NULL, NULL,
&ds_offset, &ds_size, NULL, NULL )
!= FAILURE;
ds++ )
{
if( ds_offset != 0 && (ds_offset+ds_size) > length )
length = ds_offset + ds_size;
}
return length;
}
GDALDataset *EnvisatDataset::Open( GDALOpenInfo * poOpenInfo )
{
EnvisatFile *hEnvisatFile;
/* -------------------------------------------------------------------- */
/* Check the header. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 8 )
return NULL;
if( !EQUALN((const char *) poOpenInfo->pabyHeader, "PRODUCT=",8) )
return NULL;
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
int ds_index;
if( EnvisatFile_Open( &hEnvisatFile, poOpenInfo->pszFilename, "r" )
== FAILURE )
return NULL;
/* -------------------------------------------------------------------- */
/* Find a Mesurement type dataset to use as our reference */
/* raster band. */
/* -------------------------------------------------------------------- */
int dsr_size, num_dsr, ds_offset, bNative;
char *pszDSType;
for( ds_index = 0; TRUE; ds_index++ )
{
if( EnvisatFile_GetDatasetInfo( hEnvisatFile, ds_index,
NULL, &pszDSType, NULL,
&ds_offset, NULL,
&num_dsr, &dsr_size ) == FAILURE )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to find \"MDS1\" measurement datatset in Envisat file." );
EnvisatFile_Close( hEnvisatFile );
return NULL;
}
/* Have we found what we are looking for? A Measurement ds. */
if( EQUAL(pszDSType,"M") )
break;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
EnvisatFile_Close( hEnvisatFile );
CPLError( CE_Failure, CPLE_NotSupported,
"The ENVISAT driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
EnvisatDataset *poDS;
poDS = new EnvisatDataset();
poDS->hEnvisatFile = hEnvisatFile;
/* -------------------------------------------------------------------- */
/* Setup image definition. */
/* -------------------------------------------------------------------- */
const char *pszDataType, *pszSampleType, *pszProduct;
GDALDataType eDataType;
int nPrefixBytes;
EnvisatFile_GetDatasetInfo( hEnvisatFile, ds_index,
NULL, NULL, NULL, &ds_offset, NULL,
&num_dsr, &dsr_size );
poDS->nRasterXSize = EnvisatFile_GetKeyValueAsInt( hEnvisatFile, SPH,
"LINE_LENGTH", 0 );
poDS->nRasterYSize = num_dsr;
poDS->eAccess = GA_ReadOnly;
pszProduct = EnvisatFile_GetKeyValueAsString( hEnvisatFile, MPH,
"PRODUCT", "" );
pszDataType = EnvisatFile_GetKeyValueAsString( hEnvisatFile, SPH,
"DATA_TYPE", "" );
pszSampleType = EnvisatFile_GetKeyValueAsString( hEnvisatFile, SPH,
"SAMPLE_TYPE", "" );
if( EQUAL(pszDataType,"FLT32") && EQUALN(pszSampleType,"COMPLEX",7))
eDataType = GDT_CFloat32;
else if( EQUAL(pszDataType,"FLT32") )
eDataType = GDT_Float32;
else if( EQUAL(pszDataType,"UWORD") )
eDataType = GDT_UInt16;
else if( EQUAL(pszDataType,"SWORD") && EQUALN(pszSampleType,"COMPLEX",7) )
eDataType = GDT_CInt16;
else if( EQUAL(pszDataType,"SWORD") )
eDataType = GDT_Int16;
else if( EQUALN(pszProduct,"ATS_TOA_1",8) )
{
/* all 16bit data, no line length provided */
eDataType = GDT_Int16;
poDS->nRasterXSize = (dsr_size - 20) / 2;
}
else if( poDS->nRasterXSize == 0 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Envisat product format not recognised. Assuming 8bit\n"
"with no per-record prefix data. Results may be useless!" );
eDataType = GDT_Byte;
poDS->nRasterXSize = dsr_size;
}
else
{
if( dsr_size >= 2 * poDS->nRasterXSize )
eDataType = GDT_UInt16;
else
eDataType = GDT_Byte;
}
#ifdef CPL_LSB
bNative = FALSE;
#else
bNative = TRUE;
#endif
nPrefixBytes = dsr_size -
((GDALGetDataTypeSize(eDataType) / 8) * poDS->nRasterXSize);
/* -------------------------------------------------------------------- */
/* Fail out if we didn't get non-zero sizes. */
/* -------------------------------------------------------------------- */
if( poDS->nRasterXSize < 1 || poDS->nRasterYSize < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to determine organization of dataset. It would\n"
"appear this is an Envisat dataset, but an unsupported\n"
"data product. Unable to utilize." );
delete poDS;
return NULL;
}
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( poDS->fpImage == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to collect GCPs. */
/* -------------------------------------------------------------------- */
/* -------------------------------------------------------------------- */
/* Scan for all datasets matching the reference dataset. */
/* -------------------------------------------------------------------- */
int num_dsr2, dsr_size2, iBand = 0;
const char *pszDSName;
char szBandName[128];
bool bMiltiChannel;
for( ds_index = 0;
EnvisatFile_GetDatasetInfo( hEnvisatFile, ds_index,
(char **) &pszDSName, NULL, NULL,
&ds_offset, NULL,
&num_dsr2, &dsr_size2 ) == SUCCESS;
ds_index++ )
{
if( !EQUAL(pszDSType,"M") || num_dsr2 != num_dsr )
continue;
if( EQUALN(pszProduct,"MER",3) && (pszProduct[8] == '2') &&
( (strstr(pszDSName, "MDS(16)") != NULL) ||
(strstr(pszDSName, "MDS(19)") != NULL)) )
bMiltiChannel = true;
else
bMiltiChannel = false;
if( (dsr_size2 == dsr_size) && !bMiltiChannel )
{
poDS->SetBand( iBand+1,
new RawRasterBand( poDS, iBand+1, poDS->fpImage,
ds_offset + nPrefixBytes,
GDALGetDataTypeSize(eDataType) / 8,
dsr_size,
eDataType, bNative, TRUE ) );
iBand++;
poDS->GetRasterBand(iBand)->SetDescription( pszDSName );
}
/* -------------------------------------------------------------------- */
/* Handle MERIS Level 2 datasets with data type different from */
/* the one declared in the SPH */
/* -------------------------------------------------------------------- */
else if( EQUALN(pszProduct,"MER",3) &&
(strstr(pszDSName, "Flags") != NULL) )
{
if (pszProduct[8] == '1')
{
// Flags
poDS->SetBand( iBand+1,
new RawRasterBand( poDS, iBand+1, poDS->fpImage,
ds_offset + nPrefixBytes, 3,
dsr_size, GDT_Byte, bNative, TRUE ) );
iBand++;
poDS->GetRasterBand(iBand)->SetDescription( pszDSName );
// Detector indices
poDS->SetBand( iBand+1,
new RawRasterBand( poDS, iBand+1, poDS->fpImage,
ds_offset + nPrefixBytes + 1,
3, dsr_size, GDT_Int16,
bNative, TRUE ) );
iBand++;
const char *pszSuffix = strstr( pszDSName, "MDS" );
if ( pszSuffix != NULL)
sprintf( szBandName, "Detector index %s", pszSuffix );
else
sprintf( szBandName, "Detector index" );
poDS->GetRasterBand(iBand)->SetDescription( szBandName );
}
else if ( (pszProduct[8] == '2') &&
(dsr_size2 >= 3 * poDS->nRasterXSize ) )
{
int nFlagPrefixBytes = dsr_size2 - 3 * poDS->nRasterXSize;
poDS->SetBand( iBand+1,
new MerisL2FlagBand( poDS, iBand+1, poDS->fpImage,
ds_offset, nFlagPrefixBytes ) );
iBand++;
poDS->GetRasterBand(iBand)->SetDescription( pszDSName );
}
}
else if( EQUALN(pszProduct,"MER",3) && (pszProduct[8] == '2') )
{
int nPrefixBytes2, nSubBands, nSubBandIdx, nSubBandOffset;
int nPixelSize = 1;
GDALDataType eDataType2 = GDT_Byte;
nSubBands = dsr_size2 / poDS->nRasterXSize;
if( (nSubBands < 1) || (nSubBands > 3) )
nSubBands = 0;
nPrefixBytes2 = dsr_size2 -
(nSubBands * nPixelSize * poDS->nRasterXSize);
for (nSubBandIdx = 0; nSubBandIdx < nSubBands; ++nSubBandIdx)
{
nSubBandOffset =
ds_offset + nPrefixBytes2 + nSubBandIdx * nPixelSize;
poDS->SetBand( iBand+1,
new RawRasterBand( poDS, iBand+1, poDS->fpImage,
nSubBandOffset,
nPixelSize * nSubBands,
dsr_size2, eDataType2, bNative, TRUE ) );
iBand++;
if (nSubBands > 1)
{
sprintf( szBandName, "%s (%d)", pszDSName, nSubBandIdx );
poDS->GetRasterBand(iBand)->SetDescription( szBandName );
}
else
poDS->GetRasterBand(iBand)->SetDescription( pszDSName );
}
}
}
/* -------------------------------------------------------------------- */
/* Collect metadata. */
/* -------------------------------------------------------------------- */
poDS->CollectMetadata( MPH );
poDS->CollectMetadata( SPH );
poDS->CollectDSDMetadata();
poDS->CollectADSMetadata();
if( EQUALN(pszProduct,"MER",3) )
poDS->ScanForGCPs_MERIS();
else
poDS->ScanForGCPs_ASAR();
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
void EnvisatDataset::CollectADSMetadata()
{
int nDSIndex, nNumDsr, nDSRSize;
int nRecord;
const char *pszDSName, *pszDSType, *pszDSFilename;
const char *pszProduct;
char *pszRecord;
char szPrefix[128], szKey[128], szValue[1024];
int i;
CPLErr ret;
const EnvisatRecordDescr *pRecordDescr = NULL;
const EnvisatFieldDescr *pField;
pszProduct = EnvisatFile_GetKeyValueAsString( hEnvisatFile, MPH,
"PRODUCT", "" );
for( nDSIndex = 0;
EnvisatFile_GetDatasetInfo( hEnvisatFile, nDSIndex,
(char **) &pszDSName,
(char **) &pszDSType,
(char **) &pszDSFilename,
NULL, NULL,
&nNumDsr, &nDSRSize ) == SUCCESS;
++nDSIndex )
{
if( EQUALN(pszDSFilename,"NOT USED",8) || (nNumDsr <= 0) )
continue;
if( !EQUAL(pszDSType,"A") && !EQUAL(pszDSType,"G") )
continue;
for ( nRecord = 0; nRecord < nNumDsr; ++nRecord )
{
strncpy( szPrefix, pszDSName, sizeof(szPrefix) - 1);
szPrefix[sizeof(szPrefix) - 1] = '\0';
// strip trailing spaces
for( i = strlen(szPrefix)-1; i && szPrefix[i] == ' '; --i )
szPrefix[i] = '\0';
// convert spaces into underscores
for( i = 0; szPrefix[i] != '\0'; i++ )
{
if( szPrefix[i] == ' ' )
szPrefix[i] = '_';
}
pszRecord = (char *) CPLMalloc(nDSRSize+1);
if( EnvisatFile_ReadDatasetRecord( hEnvisatFile, nDSIndex, nRecord,
pszRecord ) == FAILURE )
{
CPLFree( pszRecord );
return;
}
pRecordDescr = EnvisatFile_GetRecordDescriptor(pszProduct, pszDSName);
if (pRecordDescr)
{
pField = pRecordDescr->pFields;
while ( pField && pField->szName )
{
ret = EnvisatFile_GetFieldAsString(pszRecord, nDSRSize,
pField, szValue);
if ( ret == CE_None )
{
if (nNumDsr == 1)
sprintf(szKey, "%s_%s", szPrefix, pField->szName);
else
// sprintf(szKey, "%s_%02d_%s", szPrefix, nRecord,
sprintf(szKey, "%s_%d_%s", szPrefix, nRecord,
pField->szName);
SetMetadataItem(szKey, szValue, "RECORDS");
}
// silently ignore conversion errors
++pField;
}
}
CPLFree( pszRecord );
}
}
}
void EnvisatDataset::ScanForGCPs_MERIS()
{
int nDatasetIndex, nNumDSR, nDSRSize, iRecord;
/* -------------------------------------------------------------------- */
/* Do we have a meaningful geolocation grid? Seach for a */
/* DS_TYPE=A and a name containing "geolocation" or "tie */
/* points". */
/* -------------------------------------------------------------------- */
nDatasetIndex = EnvisatFile_GetDatasetIndex( hEnvisatFile,
"Tie points ADS" );
if( nDatasetIndex == -1 )
return;
if( EnvisatFile_GetDatasetInfo( hEnvisatFile, nDatasetIndex,
NULL, NULL, NULL, NULL, NULL,
&nNumDSR, &nDSRSize ) != SUCCESS )
return;
if( nNumDSR == 0 )
return;
/* -------------------------------------------------------------------- */
/* Figure out the tiepoint space, and how many we have. */
/* -------------------------------------------------------------------- */
int nLinesPerTiePoint, nSamplesPerTiePoint;
int nTPPerLine, nTPPerColumn = nNumDSR;
if( nNumDSR == 0 )
return;
nLinesPerTiePoint =
EnvisatFile_GetKeyValueAsInt( hEnvisatFile, SPH,
"LINES_PER_TIE_PT", 0 );
nSamplesPerTiePoint =
EnvisatFile_GetKeyValueAsInt( hEnvisatFile, SPH,
"SAMPLES_PER_TIE_PT", 0 );
if( nLinesPerTiePoint == 0 || nSamplesPerTiePoint == 0 )
return;
nTPPerLine = (GetRasterXSize() + nSamplesPerTiePoint - 1)
/ nSamplesPerTiePoint;
if( (GetRasterYSize() + nLinesPerTiePoint - 1)
/ nLinesPerTiePoint != nTPPerColumn )
{
CPLDebug( "EnvisatDataset", "Got %d instead of %d nTPPerColumn.",
(GetRasterYSize()+nLinesPerTiePoint-1)/nLinesPerTiePoint,
nTPPerColumn );
return;
}
if( 50*nTPPerLine + 13 != nDSRSize )
{
CPLDebug( "EnvisatDataset",
"DSRSize=%d instead of expected %d for tiepoints ADS.",
nDSRSize, 50*nTPPerLine + 13 );
return;
}
/* -------------------------------------------------------------------- */
/* Collect the first GCP set from each record. */
/* -------------------------------------------------------------------- */
GByte *pabyRecord = (GByte *) CPLMalloc(nDSRSize);
int iGCP;
GUInt32 unValue;
nGCPCount = 0;
pasGCPList = (GDAL_GCP *)
CPLCalloc(sizeof(GDAL_GCP),nNumDSR * nTPPerLine);
for( iRecord = 0; iRecord < nNumDSR; iRecord++ )
{
if( EnvisatFile_ReadDatasetRecord( hEnvisatFile, nDatasetIndex,
iRecord, pabyRecord ) != SUCCESS )
continue;
memcpy( &unValue, pabyRecord + 13, 4 );
for( iGCP = 0; iGCP < nTPPerLine; iGCP++ )
{
char szId[128];
GDALInitGCPs( 1, pasGCPList + nGCPCount );
CPLFree( pasGCPList[nGCPCount].pszId );
sprintf( szId, "%d", nGCPCount+1 );
pasGCPList[nGCPCount].pszId = CPLStrdup( szId );
memcpy( &unValue, pabyRecord + 13 + nTPPerLine*4 + iGCP*4, 4 );
pasGCPList[nGCPCount].dfGCPX =
((int)CPL_MSBWORD32(unValue))*0.000001;
memcpy( &unValue, pabyRecord + 13 + iGCP*4, 4 );
pasGCPList[nGCPCount].dfGCPY =
((int)CPL_MSBWORD32(unValue))*0.000001;
pasGCPList[nGCPCount].dfGCPZ = 0.0;
pasGCPList[nGCPCount].dfGCPLine = iRecord*nLinesPerTiePoint + 0.5;
pasGCPList[nGCPCount].dfGCPPixel = iGCP*nSamplesPerTiePoint + 0.5;
nGCPCount++;
}
}
CPLFree( pabyRecord );
}
void EnvisatDataset::ScanForGCPs_ASAR()
{
int nDatasetIndex, nNumDSR, nDSRSize, iRecord;
/* -------------------------------------------------------------------- */
/* Do we have a meaningful geolocation grid? */
/* -------------------------------------------------------------------- */
nDatasetIndex = EnvisatFile_GetDatasetIndex( hEnvisatFile,
"GEOLOCATION GRID ADS" );
if( nDatasetIndex == -1 )
return;
if( EnvisatFile_GetDatasetInfo( hEnvisatFile, nDatasetIndex,
NULL, NULL, NULL, NULL, NULL,
&nNumDSR, &nDSRSize ) != SUCCESS )
return;
if( nNumDSR == 0 || nDSRSize != 521 )
return;
/* -------------------------------------------------------------------- */
/* Collect the first GCP set from each record. */
/* -------------------------------------------------------------------- */
GByte abyRecord[521];
int nRange=0, nSample, iGCP, nRangeOffset=0;
GUInt32 unValue;
nGCPCount = 0;
pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),(nNumDSR+1) * 11);
for( iRecord = 0; iRecord < nNumDSR; iRecord++ )
{
if( EnvisatFile_ReadDatasetRecord( hEnvisatFile, nDatasetIndex,
iRecord, abyRecord ) != SUCCESS )
continue;
memcpy( &unValue, abyRecord + 13, 4 );
nRange = CPL_MSBWORD32( unValue ) + nRangeOffset;
if((iRecord>1) && (int(pasGCPList[nGCPCount-1].dfGCPLine+0.5) > nRange))
{
int delta = (int) (pasGCPList[nGCPCount-1].dfGCPLine -
pasGCPList[nGCPCount-12].dfGCPLine);
nRange = int(pasGCPList[nGCPCount-1].dfGCPLine+0.5) + delta;
nRangeOffset = nRange-1;
}
for( iGCP = 0; iGCP < 11; iGCP++ )
{
char szId[128];
GDALInitGCPs( 1, pasGCPList + nGCPCount );
CPLFree( pasGCPList[nGCPCount].pszId );
sprintf( szId, "%d", nGCPCount+1 );
pasGCPList[nGCPCount].pszId = CPLStrdup( szId );
memcpy( &unValue, abyRecord + 25 + iGCP*4, 4 );
nSample = CPL_MSBWORD32(unValue);
memcpy( &unValue, abyRecord + 25 + 176 + iGCP*4, 4 );
pasGCPList[nGCPCount].dfGCPX = ((int)CPL_MSBWORD32(unValue))*0.000001;
memcpy( &unValue, abyRecord + 25 + 132 + iGCP*4, 4 );
pasGCPList[nGCPCount].dfGCPY = ((int)CPL_MSBWORD32(unValue))*0.000001;
pasGCPList[nGCPCount].dfGCPZ = 0.0;
pasGCPList[nGCPCount].dfGCPLine = nRange - 0.5;
pasGCPList[nGCPCount].dfGCPPixel = nSample - 0.5;
nGCPCount++;
}
}
/* -------------------------------------------------------------------- */
/* We also collect the bottom GCPs from the last granule. */
/* -------------------------------------------------------------------- */
memcpy( &unValue, abyRecord + 17, 4 );
nRange = nRange + CPL_MSBWORD32( unValue ) - 1;
for( iGCP = 0; iGCP < 11; iGCP++ )
{
char szId[128];
GDALInitGCPs( 1, pasGCPList + nGCPCount );
CPLFree( pasGCPList[nGCPCount].pszId );
sprintf( szId, "%d", nGCPCount+1 );
pasGCPList[nGCPCount].pszId = CPLStrdup( szId );
memcpy( &unValue, abyRecord + 279 + iGCP*4, 4 );
nSample = CPL_MSBWORD32(unValue);
memcpy( &unValue, abyRecord + 279 + 176 + iGCP*4, 4 );
pasGCPList[nGCPCount].dfGCPX = ((int)CPL_MSBWORD32(unValue))*0.000001;
memcpy( &unValue, abyRecord + 279 + 132 + iGCP*4, 4 );
pasGCPList[nGCPCount].dfGCPY = ((int)CPL_MSBWORD32(unValue))*0.000001;
pasGCPList[nGCPCount].dfGCPZ = 0.0;
pasGCPList[nGCPCount].dfGCPLine = nRange - 0.5;
pasGCPList[nGCPCount].dfGCPPixel = nSample - 0.5;
nGCPCount++;
}
}
void EnvisatDataset::ScanForGCPs_MERIS()
{
int nDatasetIndex, nNumDSR, nDSRSize;
bool isBrowseProduct ;
/* -------------------------------------------------------------------- */
/* Do we have a meaningful geolocation grid? Seach for a */
/* DS_TYPE=A and a name containing "geolocation" or "tie */
/* points". */
/* -------------------------------------------------------------------- */
nDatasetIndex = EnvisatFile_GetDatasetIndex( hEnvisatFile,
"Tie points ADS" );
if( nDatasetIndex == -1 )
return;
if( EnvisatFile_GetDatasetInfo( hEnvisatFile, nDatasetIndex,
NULL, NULL, NULL, NULL, NULL,
&nNumDSR, &nDSRSize ) != SUCCESS )
return;
if( nNumDSR == 0 )
return;
/* -------------------------------------------------------------------- */
/* Figure out the tiepoint space, and how many we have. */
/* -------------------------------------------------------------------- */
int nLinesPerTiePoint, nSamplesPerTiePoint;
int nTPPerLine, nTPPerColumn = nNumDSR;
if( nNumDSR == 0 )
return;
nLinesPerTiePoint =
EnvisatFile_GetKeyValueAsInt( hEnvisatFile, SPH,
"LINES_PER_TIE_PT", 0 );
nSamplesPerTiePoint =
EnvisatFile_GetKeyValueAsInt( hEnvisatFile, SPH,
"SAMPLES_PER_TIE_PT", 0 );
if( nLinesPerTiePoint == 0 || nSamplesPerTiePoint == 0 )
return;
nTPPerLine = (GetRasterXSize() + nSamplesPerTiePoint - 1)
/ nSamplesPerTiePoint;
/* -------------------------------------------------------------------- */
/* Find a Mesurement type dataset to use as a reference raster */
/* band. */
/* -------------------------------------------------------------------- */
int nMDSIndex;
for( nMDSIndex = 0; TRUE; nMDSIndex++ )
{
char *pszDSType;
if( EnvisatFile_GetDatasetInfo( hEnvisatFile, nMDSIndex,
NULL, &pszDSType, NULL, NULL, NULL, NULL, NULL ) == FAILURE )
{
CPLDebug("EnvisatDataset",
"Unable to find MDS in Envisat file.") ;
return ;
}
if( EQUAL(pszDSType,"M") ) break;
}
/* -------------------------------------------------------------------- */
/* Get subset of TP ADS records matching the MDS records */
/* -------------------------------------------------------------------- */
/* get the MDS line sampling time interval */
TimeDelta tdMDSSamplingInterval( 0 , 0 ,
EnvisatFile_GetKeyValueAsInt( hEnvisatFile, SPH,
"LINE_TIME_INTERVAL", 0 ) );
/* get range of TiePoint ADS records matching the measurements */
ADSRangeLastAfter arTP( *hEnvisatFile , nDatasetIndex,
nMDSIndex , tdMDSSamplingInterval ) ;
/* check if there are any TPs to be used */
if ( arTP.getDSRCount() <= 0 )
{
CPLDebug( "EnvisatDataset" , "No tiepoint covering "
"the measurement records." ) ;
return; /* No TPs - no extraction. */
}
/* check if TPs cover the whole range of MDSRs */
if(( arTP.getFirstOffset() < 0 )||( arTP.getLastOffset() < 0 ))
{
CPLDebug( "EnvisatDataset" , "The tiepoints do not cover "
"whole range of measurement records." ) ;
/* Not good but we can still extract some of the TPS, can we? */
}
/* check TP records spacing */
if ((1+(arTP.getFirstOffset()+arTP.getLastOffset()+GetRasterYSize()-1)
/ nLinesPerTiePoint ) != arTP.getDSRCount() )
{
CPLDebug( "EnvisatDataset", "Not enough tieponts per column! "
"received=%d expected=%d", nTPPerColumn ,
1 + (arTP.getFirstOffset()+arTP.getLastOffset()+
GetRasterYSize()-1) / nLinesPerTiePoint ) ;
return; /* That is far more serious - we risk missplaces TPs. */
}
if ( 50*nTPPerLine + 13 == nDSRSize ) /* regular product */
{
isBrowseProduct = false ;
}
else if ( 8*nTPPerLine + 13 == nDSRSize ) /* browse product */
{
/* although BPs are rare there is no reason not to support them */
isBrowseProduct = true ;
}
else
{
CPLDebug( "EnvisatDataset", "Unexpectd size of 'Tie points ADS' !"
" received=%d expected=%d or %d" , nDSRSize ,
50*nTPPerLine+13, 8*nTPPerLine+13 ) ;
return;
}
/* -------------------------------------------------------------------- */
/* Collect the first GCP set from each record. */
/* -------------------------------------------------------------------- */
GByte *pabyRecord = (GByte *) CPLMalloc(nDSRSize-13);
int iGCP;
GUInt32 *tpLat = ((GUInt32*)pabyRecord) + nTPPerLine*0 ; /* latitude */
GUInt32 *tpLon = ((GUInt32*)pabyRecord) + nTPPerLine*1 ; /* longitude */
GUInt32 *tpLtc = ((GUInt32*)pabyRecord) + nTPPerLine*4 ; /* lat. DEM correction */
GUInt32 *tpLnc = ((GUInt32*)pabyRecord) + nTPPerLine*5 ; /* lon. DEM correction */
nGCPCount = 0;
pasGCPList = (GDAL_GCP *) CPLCalloc( sizeof(GDAL_GCP),
arTP.getDSRCount() * nTPPerLine );
for( int ir = 0 ; ir < arTP.getDSRCount() ; ir++ )
{
int iRecord = ir + arTP.getFirstIndex() ;
double dfGCPLine = 0.5 +
( iRecord*nLinesPerTiePoint - arTP.getFirstOffset() ) ;
if( EnvisatFile_ReadDatasetRecordChunk( hEnvisatFile, nDatasetIndex,
iRecord , pabyRecord, 13 , -1 ) != SUCCESS )
continue;
for( iGCP = 0; iGCP < nTPPerLine; iGCP++ )
{
char szId[128];
GDALInitGCPs( 1, pasGCPList + nGCPCount );
CPLFree( pasGCPList[nGCPCount].pszId );
sprintf( szId, "%d", nGCPCount+1 );
pasGCPList[nGCPCount].pszId = CPLStrdup( szId );
#define INT32(x) ((GInt32)CPL_MSBWORD32(x))
pasGCPList[nGCPCount].dfGCPX = 1e-6*INT32(tpLon[iGCP]) ;
pasGCPList[nGCPCount].dfGCPY = 1e-6*INT32(tpLat[iGCP]) ;
pasGCPList[nGCPCount].dfGCPZ = 0.0;
if( !isBrowseProduct ) /* add DEM corrections */
{
pasGCPList[nGCPCount].dfGCPX += 1e-6*INT32(tpLnc[iGCP]) ;
pasGCPList[nGCPCount].dfGCPY += 1e-6*INT32(tpLtc[iGCP]) ;
}
#undef INT32
pasGCPList[nGCPCount].dfGCPLine = dfGCPLine ;
pasGCPList[nGCPCount].dfGCPPixel = iGCP*nSamplesPerTiePoint + 0.5;
nGCPCount++;
}
}
CPLFree( pabyRecord );
}
int main( int argc, char ** argv )
{
EnvisatFile *es_file;
int ds_index;
int ds_offset, ds_size, num_dsr, dsr_size, i_record;
if( argc != 2 )
{
printf( "Usage: dumpgeo filename\n" );
exit( 1 );
}
if( EnvisatFile_Open( &es_file, argv[1], "r" ) != 0 )
{
printf( "EnvisatFile_Open(%s) failed.\n", argv[1] );
exit( 2 );
}
ds_index = EnvisatFile_GetDatasetIndex( es_file, "GEOLOCATION GRID ADS" );
if( ds_index == -1 )
{
printf( "Can't find geolocation grid ads.\n" );
exit( 3 );
}
EnvisatFile_GetDatasetInfo( es_file,
ds_index, NULL, NULL, NULL,
&ds_offset, &ds_size,
&num_dsr, &dsr_size );
if( ds_offset == 0 )
{
printf( "No data for geolocation grid ads.\n" );
exit( 4 );
}
CPLAssert( dsr_size == 521 );
for( i_record = 0; i_record < num_dsr; i_record++ )
{
GByte abyRecord[521];
GUInt32 unValue;
float fValue;
int sample;
EnvisatFile_ReadDatasetRecord( es_file, ds_index, i_record,
abyRecord );
printf( "<====================== Record %d ==================>\n",
i_record );
/* field 1 */
CPL_SWAP32PTR( abyRecord + 0 );
CPL_SWAP32PTR( abyRecord + 4 );
CPL_SWAP32PTR( abyRecord + 8 );
printf( "start line: mjd_days = %d, sec = %d, msec = %d\n",
((int *) abyRecord)[0],
((unsigned int *) abyRecord)[1],
((unsigned int *) abyRecord)[2] );
/* field 2 */
printf( "Attachment flag = %d\n", abyRecord[12] );
/* field 3 */
memcpy( &unValue, abyRecord + 13, 4 );
printf( "range line (first in granule) = %d\n",
CPL_SWAP32( unValue ) );
/* field 4 */
memcpy( &unValue, abyRecord + 17, 4 );
printf( "lines in granule = %d\n", CPL_SWAP32( unValue ) );
/* field 5 */
memcpy( &fValue, abyRecord + 21, 4 );
CPL_SWAP32PTR( &fValue );
printf( "track heading (first line) = %f\n", fValue );
/* field 6 */
printf( "first line of granule:\n" );
for( sample = 0; sample < 11; sample++ )
{
memcpy( &unValue, abyRecord + 25 + sample*4, 4 );
printf( " sample=%d ", CPL_SWAP32(unValue) );
memcpy( &fValue, abyRecord + 25 + 44 + sample * 4, 4 );
CPL_SWAP32PTR( &fValue );
printf( "time=%g ", fValue );
memcpy( &fValue, abyRecord + 25 + 88 + sample * 4, 4 );
CPL_SWAP32PTR( &fValue );
printf( "angle=%g ", fValue );
memcpy( &unValue, abyRecord + 25 + 132 + sample*4, 4 );
printf( "(%.9f,", ((int) CPL_SWAP32(unValue)) * 0.000001 );
memcpy( &unValue, abyRecord + 25 + 176 + sample*4, 4 );
printf( "%.9f)\n", ((int) CPL_SWAP32(unValue)) * 0.000001 );
}
/* field 8 */
CPL_SWAP32PTR( abyRecord + 267 );
CPL_SWAP32PTR( abyRecord + 271 );
CPL_SWAP32PTR( abyRecord + 275 );
printf( "end line: mjd_days = %d, sec = %d, msec = %d\n",
((int *) (abyRecord + 267))[0],
((unsigned int *) (abyRecord + 267))[1],
((unsigned int *) (abyRecord + 267))[2] );
/* field 9 */
printf( "final line of granule:\n" );
for( sample = 0; sample < 11; sample++ )
{
memcpy( &unValue, abyRecord + 279 + sample*4, 4 );
printf( " sample=%d ", CPL_SWAP32(unValue) );
memcpy( &fValue, abyRecord + 279 + 44 + sample * 4, 4 );
CPL_SWAP32PTR( &fValue );
printf( "time=%g ", fValue );
memcpy( &fValue, abyRecord + 279 + 88 + sample * 4, 4 );
CPL_SWAP32PTR( &fValue );
printf( "angle=%g ", fValue );
memcpy( &unValue, abyRecord + 279 + 132 + sample*4, 4 );
printf( "(%.9f,", ((int) CPL_SWAP32(unValue)) * 0.000001 );
memcpy( &unValue, abyRecord + 279 + 176 + sample*4, 4 );
printf( "%.9f)\n", ((int) CPL_SWAP32(unValue)) * 0.000001 );
}
}
EnvisatFile_Close( es_file );
exit( 0 );
}
DataSet( EnvisatFile & envfile , int index ) :
envfile(envfile), index(index), nrec(0)
{
EnvisatFile_GetDatasetInfo( &envfile, index, NULL, NULL, NULL,
NULL , NULL, &nrec, NULL ) ;
}
