int GDALJP2Metadata::ReadAndParse( const char *pszFilename )
{
VSILFILE *fpLL;
fpLL = VSIFOpenL( pszFilename, "rb" );
if( fpLL == NULL )
{
CPLDebug( "GDALJP2Metadata", "Could not even open %s.",
pszFilename );
return FALSE;
}
ReadBoxes( fpLL );
VSIFCloseL( fpLL );
/* -------------------------------------------------------------------- */
/* Try JP2GeoTIFF, GML and finally MSIG to get something. */
/* -------------------------------------------------------------------- */
if( !ParseJP2GeoTIFF() && !ParseGMLCoverageDesc() )
ParseMSIG();
/* -------------------------------------------------------------------- */
/* If we still don't have a geotransform, look for a world */
/* file. */
/* -------------------------------------------------------------------- */
if( !bHaveGeoTransform )
{
bHaveGeoTransform =
GDALReadWorldFile( pszFilename, NULL, adfGeoTransform )
|| GDALReadWorldFile( pszFilename, ".wld", adfGeoTransform );
}
/* -------------------------------------------------------------------- */
/* Return success either either of projection or geotransform */
/* or gcps. */
/* -------------------------------------------------------------------- */
return bHaveGeoTransform
|| nGCPCount > 0
|| (pszProjection != NULL && strlen(pszProjection) > 0);
}
GDALDataset *EIRDataset::Open( GDALOpenInfo * poOpenInfo )
{
int i;
VSILFILE *fp;
const char * pszLine;
if( !Identify( poOpenInfo ) )
return NULL;
fp = VSIFOpenL( poOpenInfo->pszFilename, "r" );
if( fp == NULL )
return NULL;
/* header example and description
IMAGINE_RAW_FILE // must be on first line, by itself
WIDTH 581 // number of columns in the image
HEIGHT 695 // number of rows in the image
NUM_LAYERS 3 // number of spectral bands in the image; default 1
PIXEL_FILES raw8_3n_ui_sanjack.bl // raster file
// default: same name with no extension
FORMAT BIL // BIL BIP BSQ; default BIL
DATATYPE U8 // U1 U2 U4 U8 U16 U32 S16 S32 F32 F64; default U8
BYTE_ORDER // LSB MSB; required for U16 U32 S16 S32 F32 F64
DATA_OFFSET // start of image data in raster file; default 0 bytes
END_RAW_FILE // end RAW file - stop reading
For a true color image with three bands (R, G, B) stored using 8 bits
for each pixel in each band, DATA_TYPE equals U8 and NUM_LAYERS equals
3 for a total of 24 bits per pixel.
Note that the current version of ERDAS Raw Raster Reader/Writer does
not support the LAYER_SKIP_BYTES, RECORD_SKIP_BYTES, TILE_WIDTH and
TILE_HEIGHT directives. Since the reader does not read the PIXEL_FILES
directive, the reader always assumes that the raw binary file is the
dataset, and the name of this file is the name of the header without the
extension. Currently, the reader does not support multiple raw binary
files in one dataset or a single file with both the header and the raw
binary data at the same time.
*/
bool bDone = FALSE;
int nRows = -1, nCols = -1, nBands = 1;
int nSkipBytes = 0;
int nLineCount = 0;
GDALDataType eDataType = GDT_Byte;
int nBits = 8;
char chByteOrder = 'M';
char szLayout[10] = "BIL";
char **papszHDR = NULL;
// default raster file: same name with no extension
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
CPLString osName = CPLGetBasename( poOpenInfo->pszFilename );
CPLString osRasterFilename = CPLFormCIFilename( osPath, osName, "" );
// parse the header file
while( !bDone && (pszLine = CPLReadLineL( fp )) != NULL )
{
char **papszTokens;
nLineCount++;
if ( (nLineCount == 1) && !EQUAL(pszLine,"IMAGINE_RAW_FILE") ) {
return NULL;
}
if ( (nLineCount > 50) || EQUAL(pszLine,"END_RAW_FILE") ) {
bDone = TRUE;
break;
}
if( strlen(pszLine) > 1000 )
break;
papszHDR = CSLAddString( papszHDR, pszLine );
papszTokens = CSLTokenizeStringComplex( pszLine, " \t", TRUE, FALSE );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
continue;
}
if( EQUAL(papszTokens[0],"WIDTH") )
{
nCols = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"HEIGHT") )
{
nRows = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"NUM_LAYERS") )
{
nBands = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0],"PIXEL_FILES") )
{
osRasterFilename = CPLFormCIFilename( osPath, papszTokens[1], "" );
}
else if( EQUAL(papszTokens[0],"FORMAT") )
{
strncpy( szLayout, papszTokens[1], sizeof(szLayout) );
szLayout[sizeof(szLayout)-1] = '\0';
}
else if( EQUAL(papszTokens[0],"DATATYPE")
|| EQUAL(papszTokens[0],"DATA_TYPE") )
{
if ( EQUAL(papszTokens[1], "U1")
|| EQUAL(papszTokens[1], "U2")
|| EQUAL(papszTokens[1], "U4")
|| EQUAL(papszTokens[1], "U8") ) {
nBits = 8;
eDataType = GDT_Byte;
}
else if( EQUAL(papszTokens[1], "U16") ) {
nBits = 16;
eDataType = GDT_UInt16;
}
else if( EQUAL(papszTokens[1], "U32") ) {
nBits = 32;
eDataType = GDT_UInt32;
}
else if( EQUAL(papszTokens[1], "S16") ) {
nBits = 16;
eDataType = GDT_Int16;
}
else if( EQUAL(papszTokens[1], "S32") ) {
nBits = 32;
eDataType = GDT_Int32;
}
else if( EQUAL(papszTokens[1], "F32") ) {
nBits = 32;
eDataType = GDT_Float32;
}
else if( EQUAL(papszTokens[1], "F64") ) {
nBits = 64;
eDataType = GDT_Float64;
}
else {
CPLError( CE_Failure, CPLE_NotSupported,
"EIR driver does not support DATATYPE %s.",
papszTokens[1] );
CSLDestroy( papszTokens );
CSLDestroy( papszHDR );
VSIFCloseL( fp );
return NULL;
}
}
else if( EQUAL(papszTokens[0],"BYTE_ORDER") )
{
// M for MSB, L for LSB
chByteOrder = (char) toupper(papszTokens[1][0]);
}
else if( EQUAL(papszTokens[0],"DATA_OFFSET") )
{
nSkipBytes = atoi(papszTokens[1]); // TBD: is this mapping right?
}
CSLDestroy( papszTokens );
}
VSIFCloseL( fp );
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows == -1 || nCols == -1 )
{
CSLDestroy( papszHDR );
return NULL;
}
if (!GDALCheckDatasetDimensions(nCols, nRows) ||
!GDALCheckBandCount(nBands, FALSE))
{
CSLDestroy( papszHDR );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CSLDestroy( papszHDR );
CPLError( CE_Failure, CPLE_NotSupported,
"The EIR driver does not support update access to existing"
" datasets.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
EIRDataset *poDS;
poDS = new EIRDataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
poDS->papszHDR = papszHDR;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
poDS->fpImage = VSIFOpenL( osRasterFilename.c_str(), "rb" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s.\n%s",
osRasterFilename.c_str(), VSIStrerror( errno ) );
delete poDS;
return NULL;
}
poDS->papszExtraFiles =
CSLAddString( poDS->papszExtraFiles,
osRasterFilename );
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nPixelOffset, nLineOffset;
vsi_l_offset nBandOffset;
if( EQUAL(szLayout,"BIP") )
{
nPixelOffset = nItemSize * nBands;
nLineOffset = nPixelOffset * nCols;
nBandOffset = (vsi_l_offset)nItemSize;
}
else if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = nPixelOffset * nCols;
nBandOffset = (vsi_l_offset)nLineOffset * nRows;
}
else /* assume BIL */
{
nPixelOffset = nItemSize;
nLineOffset = nItemSize * nBands * nCols;
nBandOffset = (vsi_l_offset)nItemSize * nCols;
}
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->PamInitialize();
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = nBands;
for( i = 0; i < poDS->nBands; i++ )
{
RawRasterBand *poBand;
poBand =
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
nBits);
poDS->SetBand( i+1, poBand );
}
/* -------------------------------------------------------------------- */
/* look for a worldfile */
/* -------------------------------------------------------------------- */
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, 0,
poDS->adfGeoTransform );
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset *BTDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Verify that this is some form of binterr file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 256)
return NULL;
if( !STARTS_WITH((const char *) poOpenInfo->pabyHeader, "binterr") )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
BTDataset *poDS = new BTDataset();
memcpy( poDS->abyHeader, poOpenInfo->pabyHeader, 256 );
/* -------------------------------------------------------------------- */
/* Get the version. */
/* -------------------------------------------------------------------- */
char szVersion[4] = {};
strncpy( szVersion, (char *) (poDS->abyHeader + 7), 3 );
szVersion[3] = '\0';
poDS->nVersionCode = static_cast<int>(CPLAtof(szVersion) * 10);
/* -------------------------------------------------------------------- */
/* Extract core header information, being careful about the */
/* version. */
/* -------------------------------------------------------------------- */
GInt32 nIntTemp = 0;
memcpy( &nIntTemp, poDS->abyHeader + 10, 4 );
poDS->nRasterXSize = CPL_LSBWORD32( nIntTemp );
memcpy( &nIntTemp, poDS->abyHeader + 14, 4 );
poDS->nRasterYSize = CPL_LSBWORD32( nIntTemp );
if( !GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) )
{
delete poDS;
return NULL;
}
GInt16 nDataSize = 0;
memcpy( &nDataSize, poDS->abyHeader+18, 2 );
nDataSize = CPL_LSBWORD16( nDataSize );
GDALDataType eType = GDT_Unknown;
if( poDS->abyHeader[20] != 0 && nDataSize == 4 )
eType = GDT_Float32;
else if( poDS->abyHeader[20] == 0 && nDataSize == 4 )
eType = GDT_Int32;
else if( poDS->abyHeader[20] == 0 && nDataSize == 2 )
eType = GDT_Int16;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
".bt file data type unknown, got datasize=%d.",
nDataSize );
delete poDS;
return NULL;
}
/*
rcg, apr 7/06: read offset 62 for vert. units.
If zero, assume 1.0 as per spec.
*/
memcpy( &poDS->m_fVscale, poDS->abyHeader + 62, 4 );
CPL_LSBPTR32(&poDS->m_fVscale);
if(poDS->m_fVscale == 0.0f)
poDS->m_fVscale = 1.0f;
/* -------------------------------------------------------------------- */
/* Try to read a .prj file if it is indicated. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
if( poDS->nVersionCode >= 12 && poDS->abyHeader[60] != 0 )
{
const char *pszPrjFile = CPLResetExtension( poOpenInfo->pszFilename,
"prj" );
VSILFILE *fp = VSIFOpenL( pszPrjFile, "rt" );
if( fp != NULL )
{
const int nBufMax = 10000;
char *pszBuffer = static_cast<char *>(CPLMalloc(nBufMax));
const int nBytes =
static_cast<int>(VSIFReadL( pszBuffer, 1, nBufMax-1, fp ));
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
pszBuffer[nBytes] = '\0';
char *pszBufPtr = pszBuffer;
if( oSRS.importFromWkt( &pszBufPtr ) != OGRERR_NONE )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unable to parse .prj file, "
"coordinate system missing." );
}
CPLFree( pszBuffer );
}
}
/* -------------------------------------------------------------------- */
/* If we didn't find a .prj file, try to use internal info. */
/* -------------------------------------------------------------------- */
if( oSRS.GetRoot() == NULL )
{
GInt16 nUTMZone = 0;
memcpy( &nUTMZone, poDS->abyHeader + 24, 2 );
nUTMZone = CPL_LSBWORD16( nUTMZone );
GInt16 nDatum = 0;
memcpy( &nDatum, poDS->abyHeader + 26, 2 );
nDatum = CPL_LSBWORD16( nDatum );
GInt16 nHUnits = 0;
memcpy( &nHUnits, poDS->abyHeader + 22, 2 );
nHUnits = CPL_LSBWORD16( nHUnits );
if( nUTMZone != 0 )
oSRS.SetUTM( std::abs(static_cast<int>(nUTMZone)), nUTMZone > 0 );
else if( nHUnits != 0 )
oSRS.SetLocalCS( "Unknown" );
if( nHUnits == 1 )
oSRS.SetLinearUnits( SRS_UL_METER, 1.0 );
else if( nHUnits == 2 )
oSRS.SetLinearUnits( SRS_UL_FOOT, CPLAtof(SRS_UL_FOOT_CONV) );
else if( nHUnits == 3 )
oSRS.SetLinearUnits( SRS_UL_US_FOOT, CPLAtof(SRS_UL_US_FOOT_CONV) );
// Translate some of the more obvious old USGS datum codes
if( nDatum == 0 )
nDatum = 6201;
else if( nDatum == 1 )
nDatum = 6209;
else if( nDatum == 2 )
nDatum = 6210;
else if( nDatum == 3 )
nDatum = 6202;
else if( nDatum == 4 )
nDatum = 6203;
else if( nDatum == 6 )
nDatum = 6222;
else if( nDatum == 7 )
nDatum = 6230;
else if( nDatum == 13 )
nDatum = 6267;
else if( nDatum == 14 )
nDatum = 6269;
else if( nDatum == 17 )
nDatum = 6277;
else if( nDatum == 19 )
nDatum = 6284;
else if( nDatum == 21 )
nDatum = 6301;
else if( nDatum == 22 )
nDatum = 6322;
else if( nDatum == 23 )
nDatum = 6326;
if( !oSRS.IsLocal() )
{
if( nDatum >= 6000 )
{
char szName[32];
snprintf( szName, sizeof(szName), "EPSG:%d", nDatum-2000 );
oSRS.SetWellKnownGeogCS( szName );
}
else
oSRS.SetWellKnownGeogCS( "WGS84" );
}
}
/* -------------------------------------------------------------------- */
/* Convert coordinate system back to WKT. */
/* -------------------------------------------------------------------- */
if( oSRS.GetRoot() != NULL )
oSRS.exportToWkt( &poDS->pszProjection );
/* -------------------------------------------------------------------- */
/* Get georeferencing bounds. */
/* -------------------------------------------------------------------- */
if( poDS->nVersionCode >= 11 )
{
double dfLeft = 0.0;
memcpy( &dfLeft, poDS->abyHeader + 28, 8 );
CPL_LSBPTR64( &dfLeft );
double dfRight = 0.0;
memcpy( &dfRight, poDS->abyHeader + 36, 8 );
CPL_LSBPTR64( &dfRight );
double dfBottom = 0.0;
memcpy( &dfBottom, poDS->abyHeader + 44, 8 );
CPL_LSBPTR64( &dfBottom );
double dfTop = 0.0;
memcpy( &dfTop, poDS->abyHeader + 52, 8 );
CPL_LSBPTR64( &dfTop );
poDS->adfGeoTransform[0] = dfLeft;
poDS->adfGeoTransform[1] = (dfRight - dfLeft) / poDS->nRasterXSize;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = dfTop;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = (dfBottom - dfTop) / poDS->nRasterYSize;
poDS->bGeoTransformValid = TRUE;
}
/* -------------------------------------------------------------------- */
/* Re-open the file with the desired access. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
else
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to re-open %s within BT driver.\n",
poOpenInfo->pszFilename );
delete poDS;
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Create band information objects */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1, new BTRasterBand( poDS, poDS->fpImage, eType ) );
#ifdef notdef
poDS->bGeoTransformValid =
GDALReadWorldFile( poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform );
#endif
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
GDALDataset *LANDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the header (.pcb) file. */
/* Does this appear to be a pcb file? */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < ERD_HEADER_SIZE )
return NULL;
if( !STARTS_WITH_CI( reinterpret_cast<char *>(poOpenInfo->pabyHeader),
"HEADER" )
&& !STARTS_WITH_CI( reinterpret_cast<char *>(poOpenInfo->pabyHeader),
"HEAD74" ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
LANDataset *poDS = new LANDataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Adopt the openinfo file pointer for use with this file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
else
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
if( poDS->fpImage == NULL )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we need to byte swap the headers to local machine order? */
/* -------------------------------------------------------------------- */
int bBigEndian = poOpenInfo->pabyHeader[8] == 0;
memcpy( poDS->pachHeader, poOpenInfo->pabyHeader, ERD_HEADER_SIZE );
#ifdef CPL_LSB
const int bNeedSwap = bBigEndian;
#else
const int bNeedSwap = !bBigEndian;
#endif
if( bNeedSwap )
{
CPL_SWAP16PTR( poDS->pachHeader + 6 );
CPL_SWAP16PTR( poDS->pachHeader + 8 );
CPL_SWAP32PTR( poDS->pachHeader + 16 );
CPL_SWAP32PTR( poDS->pachHeader + 20 );
CPL_SWAP32PTR( poDS->pachHeader + 24 );
CPL_SWAP32PTR( poDS->pachHeader + 28 );
CPL_SWAP16PTR( poDS->pachHeader + 88 );
CPL_SWAP16PTR( poDS->pachHeader + 90 );
CPL_SWAP16PTR( poDS->pachHeader + 106 );
CPL_SWAP32PTR( poDS->pachHeader + 108 );
CPL_SWAP32PTR( poDS->pachHeader + 112 );
CPL_SWAP32PTR( poDS->pachHeader + 116 );
CPL_SWAP32PTR( poDS->pachHeader + 120 );
CPL_SWAP32PTR( poDS->pachHeader + 124 );
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
if( STARTS_WITH_CI(poDS->pachHeader,"HEADER") )
{
float fTmp = 0.0;
memcpy(&fTmp, poDS->pachHeader + 16, 4);
CPL_LSBPTR32(&fTmp);
poDS->nRasterXSize = (int) fTmp;
memcpy(&fTmp, poDS->pachHeader + 20, 4);
CPL_LSBPTR32(&fTmp);
poDS->nRasterYSize = (int) fTmp;
}
else
{
GInt32 nTmp = 0;
memcpy(&nTmp, poDS->pachHeader + 16, 4);
CPL_LSBPTR32(&nTmp);
poDS->nRasterXSize = nTmp;
memcpy(&nTmp, poDS->pachHeader + 20, 4);
CPL_LSBPTR32(&nTmp);
poDS->nRasterYSize = nTmp;
}
GInt16 nTmp16 = 0;
memcpy(&nTmp16, poDS->pachHeader + 6, 2);
CPL_LSBPTR16(&nTmp16);
int nPixelOffset = 0;
GDALDataType eDataType = GDT_Unknown;
if( nTmp16 == 0 )
{
eDataType = GDT_Byte;
nPixelOffset = 1;
}
else if( nTmp16 == 1 ) // 4 bit
{
eDataType = GDT_Byte;
nPixelOffset = -1;
}
else if( nTmp16 == 2 )
{
nPixelOffset = 2;
eDataType = GDT_Int16;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unsupported pixel type (%d).",
nTmp16 );
delete poDS;
return NULL;
}
memcpy(&nTmp16, poDS->pachHeader + 8, 2);
CPL_LSBPTR16(&nTmp16);
const int nBandCount = nTmp16;
if( !GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(nBandCount, FALSE) )
{
delete poDS;
return NULL;
}
if( nPixelOffset != -1 &&
poDS->nRasterXSize > INT_MAX / (nPixelOffset * nBandCount) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Int overflow occurred." );
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information object. */
/* -------------------------------------------------------------------- */
CPLErrorReset();
for( int iBand = 1; iBand <= nBandCount; iBand++ )
{
if( nPixelOffset == -1 ) /* 4 bit case */
poDS->SetBand( iBand,
new LAN4BitRasterBand( poDS, iBand ) );
else
poDS->SetBand(
iBand,
new RawRasterBand( poDS, iBand, poDS->fpImage,
ERD_HEADER_SIZE + (iBand-1)
* nPixelOffset * poDS->nRasterXSize,
nPixelOffset,
poDS->nRasterXSize*nPixelOffset*nBandCount,
eDataType, !bNeedSwap, TRUE ));
if( CPLGetLastErrorType() != CE_None )
{
delete poDS;
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->CheckForStatistics();
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
/* -------------------------------------------------------------------- */
/* Try to interpret georeferencing. */
/* -------------------------------------------------------------------- */
float fTmp = 0.0;
memcpy(&fTmp, poDS->pachHeader + 112, 4);
CPL_LSBPTR32(&fTmp);
poDS->adfGeoTransform[0] = fTmp;
memcpy(&fTmp, poDS->pachHeader + 120, 4);
CPL_LSBPTR32(&fTmp);
poDS->adfGeoTransform[1] = fTmp;
poDS->adfGeoTransform[2] = 0.0;
memcpy(&fTmp, poDS->pachHeader + 116, 4);
CPL_LSBPTR32(&fTmp);
poDS->adfGeoTransform[3] = fTmp;
poDS->adfGeoTransform[4] = 0.0;
memcpy(&fTmp, poDS->pachHeader + 124, 4);
CPL_LSBPTR32(&fTmp);
poDS->adfGeoTransform[5] = - fTmp;
// adjust for center of pixel vs. top left corner of pixel.
poDS->adfGeoTransform[0] -= poDS->adfGeoTransform[1] * 0.5;
poDS->adfGeoTransform[3] -= poDS->adfGeoTransform[5] * 0.5;
/* -------------------------------------------------------------------- */
/* If we didn't get any georeferencing, try for a worldfile. */
/* -------------------------------------------------------------------- */
if( poDS->adfGeoTransform[1] == 0.0
|| poDS->adfGeoTransform[5] == 0.0 )
{
if( !GDALReadWorldFile( poOpenInfo->pszFilename, NULL,
poDS->adfGeoTransform ) )
GDALReadWorldFile( poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform );
}
/* -------------------------------------------------------------------- */
/* Try to come up with something for the coordinate system. */
/* -------------------------------------------------------------------- */
memcpy(&nTmp16, poDS->pachHeader + 88, 2);
CPL_LSBPTR16(&nTmp16);
int nCoordSys = nTmp16;
if( nCoordSys == 0 )
{
poDS->pszProjection = CPLStrdup(SRS_WKT_WGS84);
}
else if( nCoordSys == 1 )
{
poDS->pszProjection =
CPLStrdup( "LOCAL_CS[\"UTM - Zone Unknown\",UNIT[\"Meter\",1]]" );
}
else if( nCoordSys == 2 )
{
poDS->pszProjection =
CPLStrdup(
"LOCAL_CS[\"State Plane - Zone Unknown\","
"UNIT[\"US survey foot\",0.3048006096012192]]" );
}
else
{
poDS->pszProjection =
CPLStrdup( "LOCAL_CS[\"Unknown\",UNIT[\"Meter\",1]]" );
}
/* -------------------------------------------------------------------- */
/* Check for a trailer file with a colormap in it. */
/* -------------------------------------------------------------------- */
char *pszPath = CPLStrdup( CPLGetPath(poOpenInfo->pszFilename) );
char *pszBasename = CPLStrdup( CPLGetBasename(poOpenInfo->pszFilename) );
const char *pszTRLFilename =
CPLFormCIFilename( pszPath, pszBasename, "trl" );
VSILFILE *fpTRL = VSIFOpenL( pszTRLFilename, "rb" );
if( fpTRL != NULL )
{
char szTRLData[896] = { '\0' };
CPL_IGNORE_RET_VAL(VSIFReadL( szTRLData, 1, 896, fpTRL ));
CPL_IGNORE_RET_VAL(VSIFCloseL( fpTRL ));
GDALColorTable *poCT = new GDALColorTable();
for( int iColor = 0; iColor < 256; iColor++ )
{
GDALColorEntry sEntry = { 0, 0, 0, 0};
sEntry.c2 = reinterpret_cast<GByte *>(szTRLData)[iColor+128];
sEntry.c1 = reinterpret_cast<GByte *>(szTRLData)[iColor+128+256];
sEntry.c3 = reinterpret_cast<GByte *>(szTRLData)[iColor+128+512];
sEntry.c4 = 255;
poCT->SetColorEntry( iColor, &sEntry );
// Only 16 colors in 4bit files.
if( nPixelOffset == -1 && iColor == 15 )
break;
}
poDS->GetRasterBand(1)->SetColorTable( poCT );
poDS->GetRasterBand(1)->SetColorInterpretation( GCI_PaletteIndex );
delete poCT;
}
CPLFree( pszPath );
CPLFree( pszBasename );
return poDS;
}
void PDSDataset::ParseSRS()
{
const char *pszFilename = GetDescription();
/* ==================================================================== */
/* Get the geotransform. */
/* ==================================================================== */
/*********** Grab Cellsize ************/
//example:
//MAP_SCALE = 14.818 <KM/PIXEL>
//added search for unit (only checks for CM, KM - defaults to Meters)
const char *value;
//Georef parameters
double dfULXMap=0.5;
double dfULYMap = 0.5;
double dfXDim = 1.0;
double dfYDim = 1.0;
double xulcenter = 0.0;
double yulcenter = 0.0;
value = GetKeyword("IMAGE_MAP_PROJECTION.MAP_SCALE");
if (strlen(value) > 0 ) {
dfXDim = atof(value);
dfYDim = atof(value) * -1;
CPLString unit = GetKeywordUnit("IMAGE_MAP_PROJECTION.MAP_SCALE",2); //KM
//value = GetKeywordUnit("IMAGE_MAP_PROJECTION.MAP_SCALE",3); //PIXEL
if((EQUAL(unit,"M")) || (EQUAL(unit,"METER")) || (EQUAL(unit,"METERS"))) {
// do nothing
}
else if (EQUAL(unit,"CM")) {
// convert from cm to m
dfXDim = dfXDim / 100.0;
dfYDim = dfYDim / 100.0;
} else {
//defaults to convert km to m
dfXDim = dfXDim * 1000.0;
dfYDim = dfYDim * 1000.0;
}
}
/* -------------------------------------------------------------------- */
/* Calculate upper left corner of pixel in meters from the */
/* upper left center pixel sample/line offsets. It doesn't */
/* mean the defaults will work for every PDS image, as these */
/* values are used inconsistantly. Thus we have included */
/* conversion options to allow the user to override the */
/* documented PDS3 default. Jan. 2011, for known mapping issues */
/* see GDAL PDS page or mapping within ISIS3 source (USGS) */
/* $ISIS3DATA/base/translations/pdsProjectionLineSampToXY.def */
/* -------------------------------------------------------------------- */
// defaults should be correct for what is documented in the PDS3 standard
double dfSampleOffset_Shift;
double dfLineOffset_Shift;
double dfSampleOffset_Mult;
double dfLineOffset_Mult;
dfSampleOffset_Shift =
atof(CPLGetConfigOption( "PDS_SampleProjOffset_Shift", "-0.5" ));
dfLineOffset_Shift =
atof(CPLGetConfigOption( "PDS_LineProjOffset_Shift", "-0.5" ));
dfSampleOffset_Mult =
atof(CPLGetConfigOption( "PDS_SampleProjOffset_Mult", "-1.0") );
dfLineOffset_Mult =
atof( CPLGetConfigOption( "PDS_LineProjOffset_Mult", "1.0") );
/*********** Grab LINE_PROJECTION_OFFSET ************/
value = GetKeyword("IMAGE_MAP_PROJECTION.LINE_PROJECTION_OFFSET");
if (strlen(value) > 0) {
yulcenter = atof(value);
dfULYMap = ((yulcenter + dfLineOffset_Shift) * -dfYDim * dfLineOffset_Mult);
//notice dfYDim is negative here which is why it is again negated here
}
/*********** Grab SAMPLE_PROJECTION_OFFSET ************/
value = GetKeyword("IMAGE_MAP_PROJECTION.SAMPLE_PROJECTION_OFFSET");
if( strlen(value) > 0 ) {
xulcenter = atof(value);
dfULXMap = ((xulcenter + dfSampleOffset_Shift) * dfXDim * dfSampleOffset_Mult);
}
/* ==================================================================== */
/* Get the coordinate system. */
/* ==================================================================== */
int bProjectionSet = TRUE;
double semi_major = 0.0;
double semi_minor = 0.0;
double iflattening = 0.0;
double center_lat = 0.0;
double center_lon = 0.0;
double first_std_parallel = 0.0;
double second_std_parallel = 0.0;
OGRSpatialReference oSRS;
/*********** Grab TARGET_NAME ************/
/**** This is the planets name i.e. MARS ***/
CPLString target_name = GetKeyword("TARGET_NAME");
CleanString( target_name );
/********** Grab MAP_PROJECTION_TYPE *****/
CPLString map_proj_name =
GetKeyword( "IMAGE_MAP_PROJECTION.MAP_PROJECTION_TYPE");
CleanString( map_proj_name );
/****** Grab semi_major & convert to KM ******/
semi_major =
atof(GetKeyword( "IMAGE_MAP_PROJECTION.A_AXIS_RADIUS")) * 1000.0;
/****** Grab semi-minor & convert to KM ******/
semi_minor =
atof(GetKeyword( "IMAGE_MAP_PROJECTION.C_AXIS_RADIUS")) * 1000.0;
/*********** Grab CENTER_LAT ************/
center_lat =
atof(GetKeyword( "IMAGE_MAP_PROJECTION.CENTER_LATITUDE"));
/*********** Grab CENTER_LON ************/
center_lon =
atof(GetKeyword( "IMAGE_MAP_PROJECTION.CENTER_LONGITUDE"));
/********** Grab 1st std parallel *******/
first_std_parallel =
atof(GetKeyword( "IMAGE_MAP_PROJECTION.FIRST_STANDARD_PARALLEL"));
/********** Grab 2nd std parallel *******/
second_std_parallel =
atof(GetKeyword( "IMAGE_MAP_PROJECTION.SECOND_STANDARD_PARALLEL"));
/*** grab PROJECTION_LATITUDE_TYPE = "PLANETOCENTRIC" ****/
// Need to further study how ocentric/ographic will effect the gdal library.
// So far we will use this fact to define a sphere or ellipse for some projections
// Frank - may need to talk this over
char bIsGeographic = TRUE;
value = GetKeyword("IMAGE_MAP_PROJECTION.COORDINATE_SYSTEM_NAME");
if (EQUAL( value, "PLANETOCENTRIC" ))
bIsGeographic = FALSE;
/** Set oSRS projection and parameters --- all PDS supported types added if apparently supported in oSRS
"AITOFF", ** Not supported in GDAL??
"ALBERS",
"BONNE",
"BRIESEMEISTER", ** Not supported in GDAL??
"CYLINDRICAL EQUAL AREA",
"EQUIDISTANT",
"EQUIRECTANGULAR",
"GNOMONIC",
"HAMMER", ** Not supported in GDAL??
"HENDU", ** Not supported in GDAL??
"LAMBERT AZIMUTHAL EQUAL AREA",
"LAMBERT CONFORMAL",
"MERCATOR",
"MOLLWEIDE",
"OBLIQUE CYLINDRICAL",
"ORTHOGRAPHIC",
"SIMPLE CYLINDRICAL",
"SINUSOIDAL",
"STEREOGRAPHIC",
"TRANSVERSE MERCATOR",
"VAN DER GRINTEN", ** Not supported in GDAL??
"WERNER" ** Not supported in GDAL??
**/
CPLDebug( "PDS","using projection %s\n\n", map_proj_name.c_str());
if ((EQUAL( map_proj_name, "EQUIRECTANGULAR" )) ||
(EQUAL( map_proj_name, "SIMPLE_CYLINDRICAL" )) ||
(EQUAL( map_proj_name, "EQUIDISTANT" )) ) {
oSRS.SetEquirectangular2 ( 0.0, center_lon, center_lat, 0, 0 );
} else if (EQUAL( map_proj_name, "ORTHOGRAPHIC" )) {
oSRS.SetOrthographic ( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "SINUSOIDAL" )) {
oSRS.SetSinusoidal ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "MERCATOR" )) {
oSRS.SetMercator ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "STEREOGRAPHIC" )) {
oSRS.SetStereographic ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "POLAR_STEREOGRAPHIC")) {
oSRS.SetPS ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "TRANSVERSE_MERCATOR" )) {
oSRS.SetTM ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "LAMBERT_CONFORMAL_CONIC" )) {
oSRS.SetLCC ( first_std_parallel, second_std_parallel,
center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "LAMBERT_AZIMUTHAL_EQUAL_AREA" )) {
oSRS.SetLAEA( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "CYLINDRICAL_EQUAL_AREA" )) {
oSRS.SetCEA ( first_std_parallel, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "MOLLWEIDE" )) {
oSRS.SetMollweide ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "ALBERS" )) {
oSRS.SetACEA ( first_std_parallel, second_std_parallel,
center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "BONNE" )) {
oSRS.SetBonne ( first_std_parallel, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "GNOMONIC" )) {
oSRS.SetGnomonic ( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "OBLIQUE_CYLINDRICAL" )) {
// hope Swiss Oblique Cylindrical is the same
oSRS.SetSOC ( center_lat, center_lon, 0, 0 );
} else {
CPLDebug( "PDS",
"Dataset projection %s is not supported. Continuing...",
map_proj_name.c_str() );
bProjectionSet = FALSE;
}
if (bProjectionSet) {
//Create projection name, i.e. MERCATOR MARS and set as ProjCS keyword
CPLString proj_target_name = map_proj_name + " " + target_name;
oSRS.SetProjCS(proj_target_name); //set ProjCS keyword
//The geographic/geocentric name will be the same basic name as the body name
//'GCS' = Geographic/Geocentric Coordinate System
CPLString geog_name = "GCS_" + target_name;
//The datum and sphere names will be the same basic name aas the planet
CPLString datum_name = "D_" + target_name;
CPLString sphere_name = target_name; // + "_IAU_IAG"); //Might not be IAU defined so don't add
//calculate inverse flattening from major and minor axis: 1/f = a/(a-b)
if ((semi_major - semi_minor) < 0.0000001)
iflattening = 0;
else
iflattening = semi_major / (semi_major - semi_minor);
//Set the body size but take into consideration which proj is being used to help w/ compatibility
//Notice that most PDS projections are spherical based on the fact that ISIS/PICS are spherical
//Set the body size but take into consideration which proj is being used to help w/ proj4 compatibility
//The use of a Sphere, polar radius or ellipse here is based on how ISIS does it internally
if ( ( (EQUAL( map_proj_name, "STEREOGRAPHIC" ) && (fabs(center_lat) == 90)) ) ||
(EQUAL( map_proj_name, "POLAR_STEREOGRAPHIC" )))
{
if (bIsGeographic) {
//Geograpraphic, so set an ellipse
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere using the semi-minor axis. I hope...
sphere_name += "_polarRadius";
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_minor, 0.0,
"Reference_Meridian", 0.0 );
}
}
else if ( (EQUAL( map_proj_name, "SIMPLE_CYLINDRICAL" )) ||
(EQUAL( map_proj_name, "EQUIDISTANT" )) ||
(EQUAL( map_proj_name, "ORTHOGRAPHIC" )) ||
(EQUAL( map_proj_name, "STEREOGRAPHIC" )) ||
(EQUAL( map_proj_name, "SINUSOIDAL" )) ) {
//isis uses the spherical equation for these projections so force a sphere
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
else if (EQUAL( map_proj_name, "EQUIRECTANGULAR" )) {
//isis uses local radius as a sphere, which is pre-calculated in the PDS label as the semi-major
sphere_name += "_localRadius";
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
else {
//All other projections: Mercator, Transverse Mercator, Lambert Conformal, etc.
//Geographic, so set an ellipse
if (bIsGeographic) {
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere. I hope...
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
}
// translate back into a projection string.
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
osProjection = pszResult;
CPLFree( pszResult );
}
/* ==================================================================== */
/* Check for a .prj and world file to override the georeferencing. */
/* ==================================================================== */
{
CPLString osPath, osName;
VSILFILE *fp;
osPath = CPLGetPath( pszFilename );
osName = CPLGetBasename(pszFilename);
const char *pszPrjFile = CPLFormCIFilename( osPath, osName, "prj" );
fp = VSIFOpenL( pszPrjFile, "r" );
if( fp != NULL )
{
char **papszLines;
OGRSpatialReference oSRS;
VSIFCloseL( fp );
papszLines = CSLLoad( pszPrjFile );
if( oSRS.importFromESRI( papszLines ) == OGRERR_NONE )
{
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
osProjection = pszResult;
CPLFree( pszResult );
}
CSLDestroy( papszLines );
}
}
if( dfULYMap != 0.5 || dfULYMap != 0.5 || dfXDim != 1.0 || dfYDim != 1.0 )
{
bGotTransform = TRUE;
adfGeoTransform[0] = dfULXMap;
adfGeoTransform[1] = dfXDim;
adfGeoTransform[2] = 0.0;
adfGeoTransform[3] = dfULYMap;
adfGeoTransform[4] = 0.0;
adfGeoTransform[5] = dfYDim;
}
if( !bGotTransform )
bGotTransform =
GDALReadWorldFile( pszFilename, "psw",
adfGeoTransform );
if( !bGotTransform )
bGotTransform =
GDALReadWorldFile( pszFilename, "wld",
adfGeoTransform );
}
GDALDataset* SGIDataset::Open(GDALOpenInfo* poOpenInfo)
{
/* -------------------------------------------------------------------- */
/* First we check to see if the file has the expected header */
/* bytes. */
/* -------------------------------------------------------------------- */
if(poOpenInfo->nHeaderBytes < 12)
return NULL;
ImageRec tmpImage;
memcpy(&tmpImage, poOpenInfo->pabyHeader, 12);
tmpImage.Swap();
if(tmpImage.imagic != 474)
return NULL;
if (tmpImage.type != 0 && tmpImage.type != 1)
return NULL;
if (tmpImage.bpc != 1 && tmpImage.bpc != 2)
return NULL;
if (tmpImage.dim != 1 && tmpImage.dim != 2 && tmpImage.dim != 3)
return NULL;
if(tmpImage.bpc != 1)
{
CPLError(CE_Failure, CPLE_NotSupported,
"The SGI driver only supports 1 byte channel values.\n");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
SGIDataset* poDS;
poDS = new SGIDataset();
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Open the file using the large file api. */
/* -------------------------------------------------------------------- */
if( poDS->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL(poOpenInfo->pszFilename, "rb");
else
poDS->fpImage = VSIFOpenL(poOpenInfo->pszFilename, "rb+");
if(poDS->fpImage == NULL)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"VSIFOpenL(%s) failed unexpectedly in sgidataset.cpp\n%s",
poOpenInfo->pszFilename,
VSIStrerror( errno ) );
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read pre-image data after ensuring the file is rewound. */
/* -------------------------------------------------------------------- */
VSIFSeekL(poDS->fpImage, 0, SEEK_SET);
if(VSIFReadL((void*)(&(poDS->image)), 1, 12, poDS->fpImage) != 12)
{
CPLError(CE_Failure, CPLE_OpenFailed, "file read error while reading header in sgidataset.cpp");
delete poDS;
return NULL;
}
poDS->image.Swap();
poDS->image.file = poDS->fpImage;
poDS->image.fileName = poOpenInfo->pszFilename;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = poDS->image.xsize;
poDS->nRasterYSize = poDS->image.ysize;
if (poDS->nRasterXSize <= 0 || poDS->nRasterYSize <= 0)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Invalid image dimensions : %d x %d", poDS->nRasterXSize, poDS->nRasterYSize);
delete poDS;
return NULL;
}
poDS->nBands = MAX(1,poDS->image.zsize);
if (poDS->nBands > 256)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Too many bands : %d", poDS->nBands);
delete poDS;
return NULL;
}
int numItems = (int(poDS->image.bpc) == 1) ? 256 : 65536;
poDS->image.tmp = (unsigned char*)VSICalloc(poDS->image.xsize,numItems);
if (poDS->image.tmp == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read RLE Pointer tables. */
/* -------------------------------------------------------------------- */
if(int(poDS->image.type) == 1) // RLE compressed
{
int x = poDS->image.ysize * poDS->nBands * sizeof(GUInt32);
poDS->image.rowStart = (GUInt32*)VSIMalloc2(poDS->image.ysize, poDS->nBands * sizeof(GUInt32));
poDS->image.rowSize = (GInt32*)VSIMalloc2(poDS->image.ysize, poDS->nBands * sizeof(GUInt32));
if (poDS->image.rowStart == NULL || poDS->image.rowSize == NULL)
{
CPLError(CE_Failure, CPLE_OutOfMemory, "Out of memory");
delete poDS;
return NULL;
}
memset(poDS->image.rowStart, 0, x);
memset(poDS->image.rowSize, 0, x);
poDS->image.rleEnd = 512 + (2 * x);
VSIFSeekL(poDS->fpImage, 512, SEEK_SET);
if((int) VSIFReadL(poDS->image.rowStart, 1, x, poDS->image.file) != x)
{
delete poDS;
CPLError(CE_Failure, CPLE_OpenFailed,
"file read error while reading start positions in sgidataset.cpp");
return NULL;
}
if((int) VSIFReadL(poDS->image.rowSize, 1, x, poDS->image.file) != x)
{
delete poDS;
CPLError(CE_Failure, CPLE_OpenFailed,
"file read error while reading row lengths in sgidataset.cpp");
return NULL;
}
ConvertLong(poDS->image.rowStart, x/(int)sizeof(GUInt32));
ConvertLong((GUInt32*)poDS->image.rowSize, x/(int)sizeof(GInt32));
}
else // uncompressed.
{
poDS->image.rowStart = NULL;
poDS->image.rowSize = NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
for(int iBand = 0; iBand < poDS->nBands; iBand++)
poDS->SetBand(iBand+1, new SGIRasterBand(poDS, iBand+1));
/* -------------------------------------------------------------------- */
/* Check for world file. */
/* -------------------------------------------------------------------- */
poDS->bGeoTransformValid =
GDALReadWorldFile(poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform);
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription(poOpenInfo->pszFilename);
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
GDALDataset *PNMDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Verify that this is a _raw_ ppm or pgm file. Note, we don't */
/* support ascii files, or pbm (1bit) files. */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Parse out the tokens from the header. */
/* -------------------------------------------------------------------- */
const char *pszSrc = (const char *) poOpenInfo->pabyHeader;
char szToken[512];
int iIn, iToken = 0, nWidth =-1, nHeight=-1, nMaxValue=-1;
unsigned int iOut;
iIn = 2;
while( iIn < poOpenInfo->nHeaderBytes && iToken < 3 )
{
iOut = 0;
szToken[0] = '\0';
while( iOut < sizeof(szToken) && iIn < poOpenInfo->nHeaderBytes )
{
if( pszSrc[iIn] == '#' )
{
while( pszSrc[iIn] != 10 && pszSrc[iIn] != 13
&& iIn < poOpenInfo->nHeaderBytes - 1 )
iIn++;
}
if( iOut != 0 && isspace((unsigned char)pszSrc[iIn]) )
{
szToken[iOut] = '\0';
if( iToken == 0 )
nWidth = atoi(szToken);
else if( iToken == 1 )
nHeight = atoi(szToken);
else if( iToken == 2 )
nMaxValue = atoi(szToken);
iToken++;
iIn++;
break;
}
else if( !isspace((unsigned char)pszSrc[iIn]) )
{
szToken[iOut++] = pszSrc[iIn];
}
iIn++;
}
}
CPLDebug( "PNM", "PNM header contains: width=%d, height=%d, maxval=%d",
nWidth, nHeight, nMaxValue );
if( iToken != 3 || nWidth < 1 || nHeight < 1 || nMaxValue < 1 )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
PNMDataset *poDS;
poDS = new PNMDataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
/* -------------------------------------------------------------------- */
/* Open file */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
else
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to re-open %s within PNM driver.\n",
poOpenInfo->pszFilename );
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int bMSBFirst = TRUE, iPixelSize;
GDALDataType eDataType;
#ifdef CPL_LSB
bMSBFirst = FALSE;
#endif
if ( nMaxValue < 256 )
eDataType = GDT_Byte;
else
eDataType = GDT_UInt16;
iPixelSize = GDALGetDataTypeSize( eDataType ) / 8;
if( poOpenInfo->pabyHeader[1] == '5' )
{
if (nWidth > INT_MAX / iPixelSize)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Int overflow occured.");
delete poDS;
return NULL;
}
poDS->SetBand(
1, new RawRasterBand( poDS, 1, poDS->fpImage, iIn, iPixelSize,
nWidth*iPixelSize, eDataType, bMSBFirst, TRUE ));
poDS->GetRasterBand(1)->SetColorInterpretation( GCI_GrayIndex );
}
else
{
if (nWidth > INT_MAX / (3 * iPixelSize))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Int overflow occured.");
delete poDS;
return NULL;
}
poDS->SetBand(
1, new RawRasterBand( poDS, 1, poDS->fpImage, iIn, 3*iPixelSize,
nWidth*3*iPixelSize, eDataType, bMSBFirst, TRUE ));
poDS->SetBand(
2, new RawRasterBand( poDS, 2, poDS->fpImage, iIn+iPixelSize,
3*iPixelSize, nWidth*3*iPixelSize,
eDataType, bMSBFirst, TRUE ));
poDS->SetBand(
3, new RawRasterBand( poDS, 3, poDS->fpImage, iIn+2*iPixelSize,
3*iPixelSize, nWidth*3*iPixelSize,
eDataType, bMSBFirst, TRUE ));
poDS->GetRasterBand(1)->SetColorInterpretation( GCI_RedBand );
poDS->GetRasterBand(2)->SetColorInterpretation( GCI_GreenBand );
poDS->GetRasterBand(3)->SetColorInterpretation( GCI_BlueBand );
}
/* -------------------------------------------------------------------- */
/* Check for world file. */
/* -------------------------------------------------------------------- */
poDS->bGeoTransformValid =
GDALReadWorldFile( poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset *ISIS2Dataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does this look like a CUBE or an IMAGE Primary Data Object? */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the file using the large file API. */
/* -------------------------------------------------------------------- */
VSILFILE *fpQube = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpQube == NULL )
return NULL;
ISIS2Dataset *poDS;
poDS = new ISIS2Dataset();
if( ! poDS->oKeywords.Ingest( fpQube, 0 ) )
{
VSIFCloseL( fpQube );
delete poDS;
return NULL;
}
VSIFCloseL( fpQube );
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the label (ie. .lab) file. */
/* -------------------------------------------------------------------- */
// QUBE can be inline or detached and point to an image name
// ^QUBE = 76
// ^QUBE = ("ui31s015.img",6441<BYTES>) - has another label on the image
// ^QUBE = "ui31s015.img" - which implies no label or skip value
const char *pszQube = poDS->GetKeyword( "^QUBE" );
GUIntBig nQube = 0;
int bByteLocation = FALSE;
CPLString osTargetFile = poOpenInfo->pszFilename;
if( pszQube[0] == '"' )
{
CPLString osTPath = CPLGetPath(poOpenInfo->pszFilename);
CPLString osFilename = pszQube;
poDS->CleanString( osFilename );
osTargetFile = CPLFormCIFilename( osTPath, osFilename, NULL );
poDS->osExternalCube = osTargetFile;
}
else if( pszQube[0] == '(' )
{
CPLString osTPath = CPLGetPath(poOpenInfo->pszFilename);
CPLString osFilename = poDS->GetKeywordSub("^QUBE",1,"");
poDS->CleanString( osFilename );
osTargetFile = CPLFormCIFilename( osTPath, osFilename, NULL );
poDS->osExternalCube = osTargetFile;
nQube = atoi(poDS->GetKeywordSub("^QUBE",2,"1"));
if( strstr(poDS->GetKeywordSub("^QUBE",2,"1"),"<BYTES>") != NULL )
bByteLocation = true;
}
else
{
nQube = atoi(pszQube);
if( strstr(pszQube,"<BYTES>") != NULL )
bByteLocation = true;
}
/* -------------------------------------------------------------------- */
/* Check if file an ISIS2 header file? Read a few lines of text */
/* searching for something starting with nrows or ncols. */
/* -------------------------------------------------------------------- */
GDALDataType eDataType = GDT_Byte;
OGRSpatialReference oSRS;
//image parameters
int nRows, nCols, nBands = 1;
GUIntBig nSkipBytes = 0;
int itype;
int s_ix, s_iy, s_iz; // check SUFFIX_ITEMS params.
int record_bytes;
int bNoDataSet = FALSE;
char chByteOrder = 'M'; //default to MSB
//Georef parameters
double dfULXMap=0.5;
double dfULYMap = 0.5;
double dfXDim = 1.0;
double dfYDim = 1.0;
double dfNoData = 0.0;
double xulcenter = 0.0;
double yulcenter = 0.0;
//projection parameters
int bProjectionSet = TRUE;
double semi_major = 0.0;
double semi_minor = 0.0;
double iflattening = 0.0;
double center_lat = 0.0;
double center_lon = 0.0;
double first_std_parallel = 0.0;
double second_std_parallel = 0.0;
VSILFILE *fp;
/* -------------------------------------------------------------------- */
/* Checks to see if this is valid ISIS2 cube */
/* SUFFIX_ITEM tag in .cub file should be (0,0,0); no side-planes */
/* -------------------------------------------------------------------- */
s_ix = atoi(poDS->GetKeywordSub( "QUBE.SUFFIX_ITEMS", 1 ));
s_iy = atoi(poDS->GetKeywordSub( "QUBE.SUFFIX_ITEMS", 2 ));
s_iz = atoi(poDS->GetKeywordSub( "QUBE.SUFFIX_ITEMS", 3 ));
if( s_ix != 0 || s_iy != 0 || s_iz != 0 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"*** ISIS 2 cube file has invalid SUFFIX_ITEMS parameters:\n"
"*** gdal isis2 driver requires (0, 0, 0), thus no sideplanes or backplanes\n"
"found: (%i, %i, %i)\n\n", s_ix, s_iy, s_iz );
delete poDS;
return NULL;
}
/**************** end SUFFIX_ITEM check ***********************/
/*********** Grab layout type (BSQ, BIP, BIL) ************/
// AXIS_NAME = (SAMPLE,LINE,BAND)
/***********************************************************/
const char *value;
char szLayout[10] = "BSQ"; //default to band seq.
value = poDS->GetKeyword( "QUBE.AXIS_NAME", "" );
if (EQUAL(value,"(SAMPLE,LINE,BAND)") )
strcpy(szLayout,"BSQ");
else if (EQUAL(value,"(BAND,LINE,SAMPLE)") )
strcpy(szLayout,"BIP");
else if (EQUAL(value,"(SAMPLE,BAND,LINE)") || EQUAL(value,"") )
strcpy(szLayout,"BSQ");
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
delete poDS;
return NULL;
}
/*********** Grab samples lines band ************/
nCols = atoi(poDS->GetKeywordSub("QUBE.CORE_ITEMS",1));
nRows = atoi(poDS->GetKeywordSub("QUBE.CORE_ITEMS",2));
nBands = atoi(poDS->GetKeywordSub("QUBE.CORE_ITEMS",3));
/*********** Grab Qube record bytes **********/
record_bytes = atoi(poDS->GetKeyword("RECORD_BYTES"));
if (nQube > 0 && bByteLocation )
nSkipBytes = (nQube - 1);
else if( nQube > 0 )
nSkipBytes = (nQube - 1) * record_bytes;
else
nSkipBytes = 0;
/*********** Grab samples lines band ************/
CPLString osCoreItemType = poDS->GetKeyword( "QUBE.CORE_ITEM_TYPE" );
if( (EQUAL(osCoreItemType,"PC_INTEGER")) ||
(EQUAL(osCoreItemType,"PC_UNSIGNED_INTEGER")) ||
(EQUAL(osCoreItemType,"PC_REAL")) ) {
chByteOrder = 'I';
}
/******** Grab format type - isis2 only supports 8,16,32 *******/
itype = atoi(poDS->GetKeyword("QUBE.CORE_ITEM_BYTES",""));
switch(itype) {
case 1 :
eDataType = GDT_Byte;
dfNoData = NULL1;
bNoDataSet = TRUE;
break;
case 2 :
if( strstr(osCoreItemType,"UNSIGNED") != NULL )
{
dfNoData = 0;
eDataType = GDT_UInt16;
}
else
{
dfNoData = NULL2;
eDataType = GDT_Int16;
}
bNoDataSet = TRUE;
break;
case 4 :
eDataType = GDT_Float32;
dfNoData = NULL3;
bNoDataSet = TRUE;
break;
case 8 :
eDataType = GDT_Float64;
dfNoData = NULL3;
bNoDataSet = TRUE;
break;
default :
CPLError( CE_Failure, CPLE_AppDefined,
"Itype of %d is not supported in ISIS 2.",
itype);
delete poDS;
return NULL;
}
/*********** Grab Cellsize ************/
value = poDS->GetKeyword("QUBE.IMAGE_MAP_PROJECTION.MAP_SCALE");
if (strlen(value) > 0 ) {
dfXDim = (float) atof(value) * 1000.0; /* convert from km to m */
dfYDim = (float) atof(value) * 1000.0 * -1;
}
/*********** Grab LINE_PROJECTION_OFFSET ************/
value = poDS->GetKeyword("QUBE.IMAGE_MAP_PROJECTION.LINE_PROJECTION_OFFSET");
if (strlen(value) > 0) {
yulcenter = (float) atof(value);
yulcenter = ((yulcenter) * dfYDim);
dfULYMap = yulcenter - (dfYDim/2);
}
/*********** Grab SAMPLE_PROJECTION_OFFSET ************/
value = poDS->GetKeyword("QUBE.IMAGE_MAP_PROJECTION.SAMPLE_PROJECTION_OFFSET");
if( strlen(value) > 0 ) {
xulcenter = (float) atof(value);
xulcenter = ((xulcenter) * dfXDim);
dfULXMap = xulcenter - (dfXDim/2);
}
/*********** Grab TARGET_NAME ************/
/**** This is the planets name i.e. MARS ***/
CPLString target_name = poDS->GetKeyword("QUBE.TARGET_NAME");
/*********** Grab MAP_PROJECTION_TYPE ************/
CPLString map_proj_name =
poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.MAP_PROJECTION_TYPE");
poDS->CleanString( map_proj_name );
/*********** Grab SEMI-MAJOR ************/
semi_major =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.A_AXIS_RADIUS")) * 1000.0;
/*********** Grab semi-minor ************/
semi_minor =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.C_AXIS_RADIUS")) * 1000.0;
/*********** Grab CENTER_LAT ************/
center_lat =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.CENTER_LATITUDE"));
/*********** Grab CENTER_LON ************/
center_lon =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.CENTER_LONGITUDE"));
/*********** Grab 1st std parallel ************/
first_std_parallel =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.FIRST_STANDARD_PARALLEL"));
/*********** Grab 2nd std parallel ************/
second_std_parallel =
atof(poDS->GetKeyword( "QUBE.IMAGE_MAP_PROJECTION.SECOND_STANDARD_PARALLEL"));
/*** grab PROJECTION_LATITUDE_TYPE = "PLANETOCENTRIC" ****/
// Need to further study how ocentric/ographic will effect the gdal library.
// So far we will use this fact to define a sphere or ellipse for some projections
// Frank - may need to talk this over
char bIsGeographic = TRUE;
value = poDS->GetKeyword("CUBE.IMAGE_MAP_PROJECTION.PROJECTION_LATITUDE_TYPE");
if (EQUAL( value, "\"PLANETOCENTRIC\"" ))
bIsGeographic = FALSE;
CPLDebug("ISIS2","using projection %s", map_proj_name.c_str() );
//Set oSRS projection and parameters
if ((EQUAL( map_proj_name, "EQUIRECTANGULAR_CYLINDRICAL" )) ||
(EQUAL( map_proj_name, "EQUIRECTANGULAR" )) ||
(EQUAL( map_proj_name, "SIMPLE_CYLINDRICAL" )) ) {
oSRS.OGRSpatialReference::SetEquirectangular2 ( 0.0, center_lon, center_lat, 0, 0 );
} else if (EQUAL( map_proj_name, "ORTHOGRAPHIC" )) {
oSRS.OGRSpatialReference::SetOrthographic ( center_lat, center_lon, 0, 0 );
} else if ((EQUAL( map_proj_name, "SINUSOIDAL" )) ||
(EQUAL( map_proj_name, "SINUSOIDAL_EQUAL-AREA" ))) {
oSRS.OGRSpatialReference::SetSinusoidal ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "MERCATOR" )) {
oSRS.OGRSpatialReference::SetMercator ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "POLAR_STEREOGRAPHIC" )) {
oSRS.OGRSpatialReference::SetPS ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "TRANSVERSE_MERCATOR" )) {
oSRS.OGRSpatialReference::SetTM ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "LAMBERT_CONFORMAL_CONIC" )) {
oSRS.OGRSpatialReference::SetLCC ( first_std_parallel, second_std_parallel, center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "") ) {
/* no projection */
bProjectionSet = FALSE;
} else {
CPLDebug( "ISIS2",
"Dataset projection %s is not supported. Continuing...",
map_proj_name.c_str() );
bProjectionSet = FALSE;
}
if (bProjectionSet) {
//Create projection name, i.e. MERCATOR MARS and set as ProjCS keyword
CPLString proj_target_name = map_proj_name + " " + target_name;
oSRS.SetProjCS(proj_target_name); //set ProjCS keyword
//The geographic/geocentric name will be the same basic name as the body name
//'GCS' = Geographic/Geocentric Coordinate System
CPLString geog_name = "GCS_" + target_name;
//The datum and sphere names will be the same basic name aas the planet
CPLString datum_name = "D_" + target_name;
CPLString sphere_name = target_name; // + "_IAU_IAG"); //Might not be IAU defined so don't add
//calculate inverse flattening from major and minor axis: 1/f = a/(a-b)
if ((semi_major - semi_minor) < 0.0000001)
iflattening = 0;
else
iflattening = semi_major / (semi_major - semi_minor);
//Set the body size but take into consideration which proj is being used to help w/ proj4 compatibility
//The use of a Sphere, polar radius or ellipse here is based on how ISIS does it internally
if ( ( (EQUAL( map_proj_name, "STEREOGRAPHIC" ) && (fabs(center_lat) == 90)) ) ||
(EQUAL( map_proj_name, "POLAR_STEREOGRAPHIC" )))
{
if (bIsGeographic) {
//Geograpraphic, so set an ellipse
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere using the semi-minor axis. I hope...
sphere_name += "_polarRadius";
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_minor, 0.0,
"Reference_Meridian", 0.0 );
}
}
else if ( (EQUAL( map_proj_name, "SIMPLE_CYLINDRICAL" )) ||
(EQUAL( map_proj_name, "ORTHOGRAPHIC" )) ||
(EQUAL( map_proj_name, "STEREOGRAPHIC" )) ||
(EQUAL( map_proj_name, "SINUSOIDAL_EQUAL-AREA" )) ||
(EQUAL( map_proj_name, "SINUSOIDAL" )) ) {
//isis uses the sphereical equation for these projections so force a sphere
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
else if ((EQUAL( map_proj_name, "EQUIRECTANGULAR_CYLINDRICAL" )) ||
(EQUAL( map_proj_name, "EQUIRECTANGULAR" )) ) {
//Calculate localRadius using ISIS3 simple elliptical method
// not the more standard Radius of Curvature method
//PI = 4 * atan(1);
double radLat, localRadius;
if (center_lon == 0) { //No need to calculate local radius
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
} else {
radLat = center_lat * PI / 180; // in radians
localRadius = semi_major * semi_minor / sqrt(pow(semi_minor*cos(radLat),2)
+ pow(semi_major*sin(radLat),2) );
sphere_name += "_localRadius";
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
localRadius, 0.0,
"Reference_Meridian", 0.0 );
CPLDebug( "ISIS2", "local radius: %f", localRadius);
}
}
else {
//All other projections: Mercator, Transverse Mercator, Lambert Conformal, etc.
//Geographic, so set an ellipse
if (bIsGeographic) {
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere. I hope...
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
}
// translate back into a projection string.
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
/* END ISIS2 Label Read */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows < 1 || nCols < 1 || nBands < 1 )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( osTargetFile, "rb" );
else
poDS->fpImage = VSIFOpenL( osTargetFile, "r+b" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s with write permission.\n%s",
osTargetFile.c_str(), VSIStrerror( errno ) );
delete poDS;
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nLineOffset, nPixelOffset, nBandOffset;
if( EQUAL(szLayout,"BIP") )
{
nPixelOffset = nItemSize * nBands;
nLineOffset = nPixelOffset * nCols;
nBandOffset = nItemSize;
}
else if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = nPixelOffset * nCols;
nBandOffset = nLineOffset * nRows;
}
else /* assume BIL */
{
nPixelOffset = nItemSize;
nLineOffset = nItemSize * nBands * nCols;
nBandOffset = nItemSize * nCols;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int i;
poDS->nBands = nBands;;
for( i = 0; i < poDS->nBands; i++ )
{
RawRasterBand *poBand;
poBand =
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
TRUE );
if( bNoDataSet )
poBand->SetNoDataValue( dfNoData );
poDS->SetBand( i+1, poBand );
// Set offset/scale values at the PAM level.
poBand->SetOffset(
CPLAtofM(poDS->GetKeyword("QUBE.CORE_BASE","0.0")));
poBand->SetScale(
CPLAtofM(poDS->GetKeyword("QUBE.CORE_MULTIPLIER","1.0")));
}
/* -------------------------------------------------------------------- */
/* Check for a .prj file. For isis2 I would like to keep this in */
/* -------------------------------------------------------------------- */
CPLString osPath, osName;
osPath = CPLGetPath( poOpenInfo->pszFilename );
osName = CPLGetBasename(poOpenInfo->pszFilename);
const char *pszPrjFile = CPLFormCIFilename( osPath, osName, "prj" );
fp = VSIFOpenL( pszPrjFile, "r" );
if( fp != NULL )
{
char **papszLines;
OGRSpatialReference oSRS;
VSIFCloseL( fp );
papszLines = CSLLoad( pszPrjFile );
if( oSRS.importFromESRI( papszLines ) == OGRERR_NONE )
{
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
CSLDestroy( papszLines );
}
if( dfULYMap != 0.5 || dfULYMap != 0.5 || dfXDim != 1.0 || dfYDim != 1.0 )
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = dfULXMap;
poDS->adfGeoTransform[1] = dfXDim;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = dfULYMap;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = dfYDim;
}
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "cbw",
poDS->adfGeoTransform );
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset* SGIDataset::Open(GDALOpenInfo* poOpenInfo)
{
/* -------------------------------------------------------------------- */
/* First we check to see if the file has the expected header */
/* bytes. */
/* -------------------------------------------------------------------- */
if(poOpenInfo->nHeaderBytes < 12 || poOpenInfo->fpL == nullptr )
return nullptr;
ImageRec tmpImage;
memcpy(&tmpImage.imagic, poOpenInfo->pabyHeader + 0, 2);
memcpy(&tmpImage.type, poOpenInfo->pabyHeader + 2, 1);
memcpy(&tmpImage.bpc, poOpenInfo->pabyHeader + 3, 1);
memcpy(&tmpImage.dim, poOpenInfo->pabyHeader + 4, 2);
memcpy(&tmpImage.xsize, poOpenInfo->pabyHeader + 6, 2);
memcpy(&tmpImage.ysize, poOpenInfo->pabyHeader + 8, 2);
memcpy(&tmpImage.zsize, poOpenInfo->pabyHeader + 10, 2);
tmpImage.Swap();
if(tmpImage.imagic != 474)
return nullptr;
if (tmpImage.type != 0 && tmpImage.type != 1)
return nullptr;
if (tmpImage.bpc != 1 && tmpImage.bpc != 2)
return nullptr;
if (tmpImage.dim != 1 && tmpImage.dim != 2 && tmpImage.dim != 3)
return nullptr;
if(tmpImage.bpc != 1)
{
CPLError(CE_Failure, CPLE_NotSupported,
"The SGI driver only supports 1 byte channel values.\n");
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
SGIDataset* poDS = new SGIDataset();
poDS->eAccess = poOpenInfo->eAccess;
poDS->fpImage = poOpenInfo->fpL;
poOpenInfo->fpL = nullptr;
/* -------------------------------------------------------------------- */
/* Read pre-image data after ensuring the file is rewound. */
/* -------------------------------------------------------------------- */
VSIFSeekL(poDS->fpImage, 0, SEEK_SET);
if(VSIFReadL(reinterpret_cast<void*>( &(poDS->image) ),
1, 12, poDS->fpImage)
!= 12)
{
CPLError(CE_Failure, CPLE_OpenFailed, "file read error while reading header in sgidataset.cpp");
delete poDS;
return nullptr;
}
poDS->image.Swap();
poDS->image.file = poDS->fpImage;
poDS->image.fileName = poOpenInfo->pszFilename;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = poDS->image.xsize;
poDS->nRasterYSize = poDS->image.ysize;
if (poDS->nRasterXSize <= 0 || poDS->nRasterYSize <= 0)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Invalid image dimensions : %d x %d", poDS->nRasterXSize, poDS->nRasterYSize);
delete poDS;
return nullptr;
}
poDS->nBands = std::max(static_cast<GUInt16>(1), poDS->image.zsize);
if (poDS->nBands > 256)
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Too many bands : %d", poDS->nBands);
delete poDS;
return nullptr;
}
const int numItems
= (static_cast<int>( poDS->image.bpc ) == 1) ? 256 : 65536;
if( poDS->image.xsize > INT_MAX / numItems )
{
delete poDS;
return nullptr;
}
poDS->image.tmpSize = poDS->image.xsize * numItems;
poDS->image.tmp = (unsigned char*)VSI_CALLOC_VERBOSE(poDS->image.xsize,numItems);
if (poDS->image.tmp == nullptr)
{
delete poDS;
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Read RLE Pointer tables. */
/* -------------------------------------------------------------------- */
if( static_cast<int>( poDS->image.type ) == 1 ) // RLE compressed
{
const size_t x = static_cast<size_t>(poDS->image.ysize) * poDS->nBands * sizeof(GUInt32);
poDS->image.rowStart = reinterpret_cast<GUInt32*>(
VSI_MALLOC2_VERBOSE(poDS->image.ysize, poDS->nBands * sizeof(GUInt32) ) );
poDS->image.rowSize = reinterpret_cast<GInt32 *>(
VSI_MALLOC2_VERBOSE(poDS->image.ysize, poDS->nBands * sizeof(GUInt32) ) );
if (poDS->image.rowStart == nullptr || poDS->image.rowSize == nullptr)
{
delete poDS;
return nullptr;
}
memset(poDS->image.rowStart, 0, x);
memset(poDS->image.rowSize, 0, x);
poDS->image.rleEnd = static_cast<GUInt32>(512 + (2 * x));
VSIFSeekL(poDS->fpImage, 512, SEEK_SET);
if( VSIFReadL(poDS->image.rowStart, 1, x, poDS->image.file ) != x )
{
delete poDS;
CPLError(CE_Failure, CPLE_OpenFailed,
"file read error while reading start positions in sgidataset.cpp");
return nullptr;
}
if( VSIFReadL(poDS->image.rowSize, 1, x, poDS->image.file) != x)
{
delete poDS;
CPLError(CE_Failure, CPLE_OpenFailed,
"file read error while reading row lengths in sgidataset.cpp");
return nullptr;
}
ConvertLong(poDS->image.rowStart,
static_cast<int>(x / static_cast<int>( sizeof(GUInt32))) );
ConvertLong(reinterpret_cast<GUInt32 *>( poDS->image.rowSize ),
static_cast<int>(x / static_cast<int>( sizeof(GInt32) )) );
}
else // uncompressed.
{
poDS->image.rowStart = nullptr;
poDS->image.rowSize = nullptr;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
for(int iBand = 0; iBand < poDS->nBands; iBand++)
poDS->SetBand(iBand+1, new SGIRasterBand(poDS, iBand+1));
/* -------------------------------------------------------------------- */
/* Check for world file. */
/* -------------------------------------------------------------------- */
poDS->bGeoTransformValid =
GDALReadWorldFile(poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform);
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription(poOpenInfo->pszFilename);
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
GDALDataset *VICARDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does this look like a VICAR dataset? */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the file using the large file API. */
/* -------------------------------------------------------------------- */
VSILFILE *fpQube = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpQube == NULL )
return NULL;
VICARDataset *poDS = new VICARDataset();
if( ! poDS->oKeywords.Ingest( fpQube, poOpenInfo->pabyHeader ) ) {
VSIFCloseL( fpQube );
delete poDS;
return NULL;
}
VSIFCloseL( fpQube );
/***** CHECK ENDIANNESS **************/
const char *value = poDS->GetKeyword( "INTFMT" );
if (!EQUAL(value,"LOW") ) {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
delete poDS;
return FALSE;
}
value = poDS->GetKeyword( "REALFMT" );
if (!EQUAL(value,"RIEEE") ) {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
delete poDS;
return FALSE;
}
char chByteOrder = 'M';
value = poDS->GetKeyword( "BREALFMT" );
if (EQUAL(value,"VAX") ) {
chByteOrder = 'I';
}
/************ CHECK INSTRUMENT *****************/
/************ ONLY HRSC TESTED *****************/
bool bIsDTM = false;
value = poDS->GetKeyword( "DTM.DTM_OFFSET" );
if (!EQUAL(value,"") ) {
bIsDTM = true;
}
value = poDS->GetKeyword( "BLTYPE" );
if (!EQUAL(value,"M94_HRSC") && !bIsDTM ) {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s instrument not tested. Continue with caution!\n\n", value);
}
/*********** Grab layout type (BSQ, BIP, BIL) ************/
char szLayout[10] = "BSQ"; //default to band seq.
value = poDS->GetKeyword( "ORG" );
if (!EQUAL(value,"BSQ") )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
delete poDS;
return FALSE;
}
strcpy(szLayout,"BSQ");
const int nCols = atoi(poDS->GetKeyword("NS"));
const int nRows = atoi(poDS->GetKeyword("NL"));
const int nBands = atoi(poDS->GetKeyword("NB"));
/*********** Grab record bytes **********/
int nSkipBytes = atoi(poDS->GetKeyword("NBB"));
GDALDataType eDataType = GDT_Byte;
double dfNoData = 0.0;
if (EQUAL( poDS->GetKeyword( "FORMAT" ), "BYTE" )) {
eDataType = GDT_Byte;
dfNoData = NULL1;
}
else if (EQUAL( poDS->GetKeyword( "FORMAT" ), "HALF" )) {
eDataType = GDT_Int16;
dfNoData = NULL2;
chByteOrder = 'I';
}
else if (EQUAL( poDS->GetKeyword( "FORMAT" ), "FULL" )) {
eDataType = GDT_UInt32;
dfNoData = 0;
}
else if (EQUAL( poDS->GetKeyword( "FORMAT" ), "REAL" )) {
eDataType = GDT_Float32;
dfNoData = NULL3;
chByteOrder = 'I';
}
else {
CPLError( CE_Failure, CPLE_AppDefined,
"Could not find known VICAR label entries!\n");
delete poDS;
return NULL;
}
if( nRows < 1 || nCols < 1 || nBands < 1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File %s appears to be a VICAR file, but failed to find some "
"required keywords.",
poDS->GetDescription() );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
double dfULXMap=0.5;
double dfULYMap = 0.5;
double dfXDim = 1.0;
double dfYDim = 1.0;
double xulcenter = 0.0;
double yulcenter = 0.0;
value = poDS->GetKeyword("MAP.MAP_SCALE");
if (strlen(value) > 0 ) {
dfXDim = CPLAtof(value);
dfYDim = CPLAtof(value) * -1;
dfXDim = dfXDim * 1000.0;
dfYDim = dfYDim * 1000.0;
}
double dfSampleOffset_Shift =
CPLAtof(CPLGetConfigOption( "PDS_SampleProjOffset_Shift", "-0.5" ));
double dfLineOffset_Shift =
CPLAtof(CPLGetConfigOption( "PDS_LineProjOffset_Shift", "-0.5" ));
double dfSampleOffset_Mult =
CPLAtof(CPLGetConfigOption( "PDS_SampleProjOffset_Mult", "-1.0") );
double dfLineOffset_Mult =
CPLAtof( CPLGetConfigOption( "PDS_LineProjOffset_Mult", "1.0") );
/*********** Grab LINE_PROJECTION_OFFSET ************/
value = poDS->GetKeyword("MAP.LINE_PROJECTION_OFFSET");
if (strlen(value) > 0) {
yulcenter = CPLAtof(value);
dfULYMap = ((yulcenter + dfLineOffset_Shift) * -dfYDim * dfLineOffset_Mult);
}
/*********** Grab SAMPLE_PROJECTION_OFFSET ************/
value = poDS->GetKeyword("MAP.SAMPLE_PROJECTION_OFFSET");
if( strlen(value) > 0 ) {
xulcenter = CPLAtof(value);
dfULXMap = ((xulcenter + dfSampleOffset_Shift) * dfXDim * dfSampleOffset_Mult);
}
/* ==================================================================== */
/* Get the coordinate system. */
/* ==================================================================== */
bool bProjectionSet = true;
/*********** Grab TARGET_NAME ************/
/**** This is the planets name i.e. MARS ***/
const CPLString target_name = poDS->GetKeyword("MAP.TARGET_NAME");
/********** Grab MAP_PROJECTION_TYPE *****/
const CPLString map_proj_name
= poDS->GetKeyword( "MAP.MAP_PROJECTION_TYPE");
/****** Grab semi_major & convert to KM ******/
const double semi_major
= CPLAtof(poDS->GetKeyword( "MAP.A_AXIS_RADIUS")) * 1000.0;
/****** Grab semi-minor & convert to KM ******/
const double semi_minor
= CPLAtof(poDS->GetKeyword( "MAP.C_AXIS_RADIUS")) * 1000.0;
/*********** Grab CENTER_LAT ************/
const double center_lat =
CPLAtof(poDS->GetKeyword( "MAP.CENTER_LATITUDE"));
/*********** Grab CENTER_LON ************/
const double center_lon
= CPLAtof(poDS->GetKeyword( "MAP.CENTER_LONGITUDE"));
/********** Grab 1st std parallel *******/
const double first_std_parallel =
CPLAtof(poDS->GetKeyword( "MAP.FIRST_STANDARD_PARALLEL"));
/********** Grab 2nd std parallel *******/
const double second_std_parallel =
CPLAtof(poDS->GetKeyword( "MAP.SECOND_STANDARD_PARALLEL"));
/*** grab PROJECTION_LATITUDE_TYPE = "PLANETOCENTRIC" ****/
// Need to further study how ocentric/ographic will effect the gdal library.
// So far we will use this fact to define a sphere or ellipse for some projections
// Frank - may need to talk this over
bool bIsGeographic = true;
value = poDS->GetKeyword("MAP.COORDINATE_SYSTEM_NAME");
if (EQUAL( value, "PLANETOCENTRIC" ))
bIsGeographic = false;
/** Set oSRS projection and parameters --- all PDS supported types added if apparently supported in oSRS
"AITOFF", ** Not supported in GDAL??
"ALBERS",
"BONNE",
"BRIESEMEISTER", ** Not supported in GDAL??
"CYLINDRICAL EQUAL AREA",
"EQUIDISTANT",
"EQUIRECTANGULAR",
"GNOMONIC",
"HAMMER", ** Not supported in GDAL??
"HENDU", ** Not supported in GDAL??
"LAMBERT AZIMUTHAL EQUAL AREA",
"LAMBERT CONFORMAL",
"MERCATOR",
"MOLLWEIDE",
"OBLIQUE CYLINDRICAL",
"ORTHOGRAPHIC",
"SIMPLE CYLINDRICAL",
"SINUSOIDAL",
"STEREOGRAPHIC",
"TRANSVERSE MERCATOR",
"VAN DER GRINTEN", ** Not supported in GDAL??
"WERNER" ** Not supported in GDAL??
**/
CPLDebug( "PDS", "using projection %s\n\n", map_proj_name.c_str());
OGRSpatialReference oSRS;
if ((EQUAL( map_proj_name, "EQUIRECTANGULAR" )) ||
(EQUAL( map_proj_name, "SIMPLE_CYLINDRICAL" )) ||
(EQUAL( map_proj_name, "EQUIDISTANT" )) ) {
oSRS.SetEquirectangular2 ( 0.0, center_lon, center_lat, 0, 0 );
} else if (EQUAL( map_proj_name, "ORTHOGRAPHIC" )) {
oSRS.SetOrthographic ( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "SINUSOIDAL" )) {
oSRS.SetSinusoidal ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "MERCATOR" )) {
oSRS.SetMercator ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "STEREOGRAPHIC" )) {
oSRS.SetStereographic ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "POLAR_STEREOGRAPHIC")) {
oSRS.SetPS ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "TRANSVERSE_MERCATOR" )) {
oSRS.SetTM ( center_lat, center_lon, 1, 0, 0 );
} else if (EQUAL( map_proj_name, "LAMBERT_CONFORMAL_CONIC" )) {
oSRS.SetLCC ( first_std_parallel, second_std_parallel,
center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "LAMBERT_AZIMUTHAL_EQUAL_AREA" )) {
oSRS.SetLAEA( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "CYLINDRICAL_EQUAL_AREA" )) {
oSRS.SetCEA ( first_std_parallel, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "MOLLWEIDE" )) {
oSRS.SetMollweide ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "ALBERS" )) {
oSRS.SetACEA ( first_std_parallel, second_std_parallel,
center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "BONNE" )) {
oSRS.SetBonne ( first_std_parallel, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "GNOMONIC" )) {
oSRS.SetGnomonic ( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "OBLIQUE_CYLINDRICAL" )) {
// hope Swiss Oblique Cylindrical is the same
oSRS.SetSOC ( center_lat, center_lon, 0, 0 );
} else {
CPLDebug( "VICAR",
"Dataset projection %s is not supported. Continuing...",
map_proj_name.c_str() );
bProjectionSet = false;
}
if (bProjectionSet) {
//Create projection name, i.e. MERCATOR MARS and set as ProjCS keyword
CPLString proj_target_name = map_proj_name + " " + target_name;
oSRS.SetProjCS(proj_target_name); //set ProjCS keyword
//The geographic/geocentric name will be the same basic name as the body name
//'GCS' = Geographic/Geocentric Coordinate System
CPLString geog_name = "GCS_" + target_name;
//The datum and sphere names will be the same basic name aas the planet
CPLString datum_name = "D_" + target_name;
CPLString sphere_name = target_name; // + "_IAU_IAG"); //Might not be IAU defined so don't add
//calculate inverse flattening from major and minor axis: 1/f = a/(a-b)
double iflattening = 0.0;
if ((semi_major - semi_minor) < 0.0000001)
iflattening = 0;
else
iflattening = semi_major / (semi_major - semi_minor);
//Set the body size but take into consideration which proj is being used to help w/ compatibility
//Notice that most PDS projections are spherical based on the fact that ISIS/PICS are spherical
//Set the body size but take into consideration which proj is being used to help w/ proj4 compatibility
//The use of a Sphere, polar radius or ellipse here is based on how ISIS does it internally
if ( ( (EQUAL( map_proj_name, "STEREOGRAPHIC" ) && (fabs(center_lat) == 90)) ) ||
(EQUAL( map_proj_name, "POLAR_STEREOGRAPHIC" )))
{
if (bIsGeographic) {
//Geograpraphic, so set an ellipse
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere using the semi-minor axis. I hope...
sphere_name += "_polarRadius";
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_minor, 0.0,
"Reference_Meridian", 0.0 );
}
}
else if ( (EQUAL( map_proj_name, "SIMPLE_CYLINDRICAL" )) ||
(EQUAL( map_proj_name, "EQUIDISTANT" )) ||
(EQUAL( map_proj_name, "ORTHOGRAPHIC" )) ||
(EQUAL( map_proj_name, "STEREOGRAPHIC" )) ||
(EQUAL( map_proj_name, "SINUSOIDAL" )) ) {
//isis uses the spherical equation for these projections so force a sphere
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
else if (EQUAL( map_proj_name, "EQUIRECTANGULAR" )) {
//isis uses local radius as a sphere, which is pre-calculated in the PDS label as the semi-major
sphere_name += "_localRadius";
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
else
{
//All other projections: Mercator, Transverse Mercator, Lambert Conformal, etc.
//Geographic, so set an ellipse
if (bIsGeographic) {
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
}
else
{
//Geocentric, so force a sphere. I hope...
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
}
// translate back into a projection string.
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = dfULXMap;
poDS->adfGeoTransform[1] = dfXDim;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = dfULYMap;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = dfYDim;
}
CPLString osQubeFile = poOpenInfo->pszFilename;
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( osQubeFile, "psw",
poDS->adfGeoTransform );
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( osQubeFile, "wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( osQubeFile, "r" );
else
poDS->fpImage = VSIFOpenL( osQubeFile, "r+" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s with write permission.\n%s",
osQubeFile.c_str(),
VSIStrerror( errno ) );
delete poDS;
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Compute the line offsets. */
/* -------------------------------------------------------------------- */
const long int nItemSize = GDALGetDataTypeSize(eDataType)/8;
const long int nPixelOffset = nItemSize;
const long int nLineOffset = nPixelOffset * nCols + atoi(poDS->GetKeyword("NBB")) ;
const long int nBandOffset = nLineOffset * nRows;
nSkipBytes = atoi(poDS->GetKeyword("LBLSIZE"));
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
for( int i = 0; i < nBands; i++ )
{
GDALRasterBand *poBand
= new RawRasterBand( poDS, i+1, poDS->fpImage, nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
TRUE );
poDS->SetBand( i+1, poBand );
poBand->SetNoDataValue( dfNoData );
if (bIsDTM) {
poBand->SetScale( (double) CPLAtof(poDS->GetKeyword( "DTM.DTM_SCALING_FACTOR") ) );
poBand->SetOffset( (double) CPLAtof(poDS->GetKeyword( "DTM.DTM_OFFSET") ) );
const char* pszMin = poDS->GetKeyword( "DTM.DTM_MINIMUM_DN", NULL );
const char* pszMax = poDS->GetKeyword( "DTM.DTM_MAXIMUM_DN", NULL );
if (pszMin != NULL && pszMax != NULL )
poBand->SetStatistics(CPLAtofM(pszMin),CPLAtofM(pszMax),0,0);
const char* pszNoData = poDS->GetKeyword( "DTM.DTM_MISSING_DN", NULL );
if (pszNoData != NULL )
poBand->SetNoDataValue( CPLAtofM(pszNoData) );
} else if (EQUAL( poDS->GetKeyword( "BLTYPE"), "M94_HRSC" )) {
float scale=CPLAtof(poDS->GetKeyword("DLRTO8.REFLECTANCE_SCALING_FACTOR","-1."));
if (scale < 0.) {
scale = CPLAtof(poDS->GetKeyword( "HRCAL.REFLECTANCE_SCALING_FACTOR","1."));
}
poBand->SetScale( scale );
float offset=CPLAtof(poDS->GetKeyword("DLRTO8.REFLECTANCE_OFFSET","-1."));
if (offset < 0.) {
offset = CPLAtof(poDS->GetKeyword( "HRCAL.REFLECTANCE_OFFSET","0."));
}
poBand->SetOffset( offset );
}
const char* pszMin = poDS->GetKeyword( "STATISTICS.MINIMUM", NULL );
const char* pszMax = poDS->GetKeyword( "STATISTICS.MAXIMUM", NULL );
const char* pszMean = poDS->GetKeyword( "STATISTICS.MEAN", NULL );
const char* pszStdDev = poDS->GetKeyword( "STATISTICS.STANDARD_DEVIATION", NULL );
if (pszMin != NULL && pszMax != NULL && pszMean != NULL && pszStdDev != NULL )
poBand->SetStatistics(CPLAtofM(pszMin),CPLAtofM(pszMax),CPLAtofM(pszMean),CPLAtofM(pszStdDev));
}
/* -------------------------------------------------------------------- */
/* Instrument-specific keywords as metadata. */
/* -------------------------------------------------------------------- */
/****************** HRSC ******************************/
if (EQUAL( poDS->GetKeyword( "BLTYPE"), "M94_HRSC" ) ) {
poDS->SetMetadataItem( "SPACECRAFT_NAME", poDS->GetKeyword( "M94_INSTRUMENT.INSTRUMENT_HOST_NAME") );
poDS->SetMetadataItem( "PRODUCT_TYPE", poDS->GetKeyword( "TYPE"));
if (EQUAL( poDS->GetKeyword( "M94_INSTRUMENT.DETECTOR_ID"), "MEX_HRSC_SRC" )) {
static const char *apszKeywords[] = {
"M94_ORBIT.IMAGE_TIME",
"FILE.EVENT_TYPE",
"FILE.PROCESSING_LEVEL_ID",
"M94_INSTRUMENT.DETECTOR_ID",
"M94_CAMERAS.EXPOSURE_DURATION",
"HRCONVER.INSTRUMENT_TEMPERATURE", NULL
};
for( int i = 0; apszKeywords[i] != NULL; i++ ) {
const char *pszKeywordValue = poDS->GetKeyword( apszKeywords[i] );
if( pszKeywordValue != NULL )
poDS->SetMetadataItem( apszKeywords[i], pszKeywordValue );
}
} else {
static const char *apszKeywords[] = {
"M94_ORBIT.START_TIME", "M94_ORBIT.STOP_TIME",
"M94_INSTRUMENT.DETECTOR_ID",
"M94_CAMERAS.MACROPIXEL_SIZE",
"FILE.EVENT_TYPE",
"M94_INSTRUMENT.MISSION_PHASE_NAME",
"HRORTHO.SPICE_FILE_NAME",
"HRCONVER.MISSING_FRAMES", "HRCONVER.OVERFLOW_FRAMES", "HRCONVER.ERROR_FRAMES",
"HRFOOT.BEST_GROUND_SAMPLING_DISTANCE",
"DLRTO8.RADIANCE_SCALING_FACTOR", "DLRTO8.RADIANCE_OFFSET",
"DLRTO8.REFLECTANCE_SCALING_FACTOR", "DLRTO8.REFLECTANCE_OFFSET",
"HRCAL.RADIANCE_SCALING_FACTOR", "HRCAL.RADIANCE_OFFSET",
"HRCAL.REFLECTANCE_SCALING_FACTOR", "HRCAL.REFLECTANCE_OFFSET",
"HRORTHO.DTM_NAME", "HRORTHO.EXTORI_FILE_NAME", "HRORTHO.GEOMETRIC_CALIB_FILE_NAME",
NULL
};
for( int i = 0; apszKeywords[i] != NULL; i++ ) {
const char *pszKeywordValue = poDS->GetKeyword( apszKeywords[i], NULL );
if( pszKeywordValue != NULL )
poDS->SetMetadataItem( apszKeywords[i], pszKeywordValue );
}
}
}
if (bIsDTM && EQUAL( poDS->GetKeyword( "MAP.TARGET_NAME"), "MARS" )) {
poDS->SetMetadataItem( "SPACECRAFT_NAME", "MARS_EXPRESS" );
poDS->SetMetadataItem( "PRODUCT_TYPE", "DTM");
static const char *apszKeywords[] = {
"DTM.DTM_MISSING_DN", "DTM.DTM_OFFSET", "DTM.DTM_SCALING_FACTOR", "DTM.DTM_A_AXIS_RADIUS",
"DTM.DTM_B_AXIS_RADIUS", "DTM.DTM_C_AXIS_RADIUS", "DTM.DTM_DESC", "DTM.DTM_MINIMUM_DN",
"DTM.DTM_MAXIMUM_DN", NULL };
for( int i = 0; apszKeywords[i] != NULL; i++ ) {
const char *pszKeywordValue = poDS->GetKeyword( apszKeywords[i] );
if( pszKeywordValue != NULL )
poDS->SetMetadataItem( apszKeywords[i], pszKeywordValue );
}
}
/****************** DAWN ******************************/
else if (EQUAL( poDS->GetKeyword( "INSTRUMENT_ID"), "FC2" )) {
poDS->SetMetadataItem( "SPACECRAFT_NAME", "DAWN" );
static const char *apszKeywords[] = {"ORBIT_NUMBER","FILTER_NUMBER",
"FRONT_DOOR_STATUS",
"FIRST_LINE",
"FIRST_LINE_SAMPLE",
"PRODUCER_INSTITUTION_NAME",
"SOURCE_FILE_NAME",
"PROCESSING_LEVEL_ID",
"TARGET_NAME",
"LIMB_IN_IMAGE",
"POLE_IN_IMAGE",
"REFLECTANCE_SCALING_FACTOR",
"SPICE_FILE_NAME",
"SPACECRAFT_CENTRIC_LATITUDE",
"SPACECRAFT_EASTERN_LONGITUDE",
"FOOTPRINT_POSITIVE_LONGITUDE",
NULL };
for( int i = 0; apszKeywords[i] != NULL; i++ ) {
const char *pszKeywordValue = poDS->GetKeyword( apszKeywords[i] );
if( pszKeywordValue != NULL )
poDS->SetMetadataItem( apszKeywords[i], pszKeywordValue );
}
}
else if (bIsDTM && EQUAL( poDS->GetKeyword( "TARGET_NAME"), "VESTA" )) {
poDS->SetMetadataItem( "SPACECRAFT_NAME", "DAWN" );
poDS->SetMetadataItem( "PRODUCT_TYPE", "DTM");
static const char *apszKeywords[] = {
"DTM_MISSING_DN", "DTM_OFFSET", "DTM_SCALING_FACTOR", "DTM_A_AXIS_RADIUS",
"DTM_B_AXIS_RADIUS", "DTM_C_AXIS_RADIUS", "DTM_MINIMUM_DN",
"DTM_MAXIMUM_DN", "MAP_PROJECTION_TYPE", "COORDINATE_SYSTEM_NAME",
"POSITIVE_LONGITUDE_DIRECTION", "MAP_SCALE",
"CENTER_LONGITUDE", "LINE_PROJECTION_OFFSET", "SAMPLE_PROJECTION_OFFSET",
NULL };
for( int i = 0; apszKeywords[i] != NULL; i++ ) {
const char *pszKeywordValue = poDS->GetKeyword( apszKeywords[i] );
if( pszKeywordValue != NULL )
poDS->SetMetadataItem( apszKeywords[i], pszKeywordValue );
}
}
/* -------------------------------------------------------------------- */
/* END Instrument-specific keywords as metadata. */
/* -------------------------------------------------------------------- */
if (EQUAL(poDS->GetKeyword( "EOL"), "1" ))
poDS->SetMetadataItem( "END-OF-DATASET_LABEL", "PRESENT" );
poDS->SetMetadataItem( "CONVERSION_DETAILS", "http://www.lpi.usra.edu/meetings/lpsc2014/pdf/1088.pdf" );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
GDALDataset *BIGGIFDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( !Identify( poOpenInfo ) )
return NULL;
if( poOpenInfo->eAccess == GA_Update )
{
CPLError( CE_Failure, CPLE_NotSupported,
"The GIF driver does not support update access to existing"
" files.\n" );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
VSILFILE *fp;
fp = VSIFOpenL( poOpenInfo->pszFilename, "r" );
if( fp == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
BIGGIFDataset *poDS;
poDS = new BIGGIFDataset();
poDS->fp = fp;
poDS->eAccess = GA_ReadOnly;
if( poDS->ReOpen() == CE_Failure )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = poDS->hGifFile->SavedImages[0].ImageDesc.Width;
poDS->nRasterYSize = poDS->hGifFile->SavedImages[0].ImageDesc.Height;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1,
new BIGGifRasterBand( poDS,
poDS->hGifFile->SBackGroundColor ));
/* -------------------------------------------------------------------- */
/* Check for world file. */
/* -------------------------------------------------------------------- */
poDS->bGeoTransformValid =
GDALReadWorldFile( poOpenInfo->pszFilename, NULL,
poDS->adfGeoTransform )
|| GDALReadWorldFile( poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Support overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
GDALDataset *PNMDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Verify that this is a _raw_ ppm or pgm file. Note, we don't */
/* support ascii files, or pbm (1bit) files. */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return nullptr;
/* -------------------------------------------------------------------- */
/* Parse out the tokens from the header. */
/* -------------------------------------------------------------------- */
const char *pszSrc = reinterpret_cast<char *>( poOpenInfo->pabyHeader );
char szToken[512] = { '\0' };
int iToken = 0;
int nWidth = -1;
int nHeight = -1;
int nMaxValue = -1;
int iIn = 2;
while( iIn < poOpenInfo->nHeaderBytes && iToken < 3 )
{
unsigned int iOut = 0;
szToken[0] = '\0';
while( iOut < sizeof(szToken) && iIn < poOpenInfo->nHeaderBytes )
{
if( pszSrc[iIn] == '#' )
{
while( iIn < poOpenInfo->nHeaderBytes - 1 &&
pszSrc[iIn] != 10 && pszSrc[iIn] != 13 )
iIn++;
}
if( iOut != 0 && isspace(static_cast<unsigned char>(pszSrc[iIn])) )
{
szToken[iOut] = '\0';
if( iToken == 0 )
nWidth = atoi(szToken);
else if( iToken == 1 )
nHeight = atoi(szToken);
else if( iToken == 2 )
nMaxValue = atoi(szToken);
iToken++;
iIn++;
break;
}
else if( !isspace(static_cast<unsigned char>(pszSrc[iIn])) )
{
szToken[iOut++] = pszSrc[iIn];
}
iIn++;
}
}
CPLDebug( "PNM", "PNM header contains: width=%d, height=%d, maxval=%d",
nWidth, nHeight, nMaxValue );
if( iToken != 3 || nWidth < 1 || nHeight < 1 || nMaxValue < 1 )
return nullptr;
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
PNMDataset *poDS = new PNMDataset();
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
// Borrow file pointer
poDS->fpImage = poOpenInfo->fpL;
poOpenInfo->fpL = nullptr;
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
#ifdef CPL_LSB
const bool bMSBFirst = false;
#else
const bool bMSBFirst = true;
#endif
GDALDataType eDataType = GDT_Unknown;
if ( nMaxValue < 256 )
eDataType = GDT_Byte;
else
eDataType = GDT_UInt16;
const int iPixelSize = GDALGetDataTypeSizeBytes( eDataType );
if( poOpenInfo->pabyHeader[1] == '5' )
{
if (nWidth > INT_MAX / iPixelSize)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Int overflow occurred.");
delete poDS;
return nullptr;
}
poDS->SetBand(
1, new RawRasterBand( poDS, 1, poDS->fpImage, iIn, iPixelSize,
nWidth*iPixelSize, eDataType, bMSBFirst,
RawRasterBand::OwnFP::NO ) );
poDS->GetRasterBand(1)->SetColorInterpretation( GCI_GrayIndex );
}
else
{
if (nWidth > INT_MAX / (3 * iPixelSize))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Int overflow occurred.");
delete poDS;
return nullptr;
}
poDS->SetBand(
1, new RawRasterBand( poDS, 1, poDS->fpImage, iIn, 3*iPixelSize,
nWidth*3*iPixelSize, eDataType, bMSBFirst,
RawRasterBand::OwnFP::NO ));
poDS->SetBand(
2, new RawRasterBand( poDS, 2, poDS->fpImage, iIn+iPixelSize,
3*iPixelSize, nWidth*3*iPixelSize,
eDataType, bMSBFirst,
RawRasterBand::OwnFP::NO ));
poDS->SetBand(
3, new RawRasterBand( poDS, 3, poDS->fpImage, iIn+2*iPixelSize,
3*iPixelSize, nWidth*3*iPixelSize,
eDataType, bMSBFirst,
RawRasterBand::OwnFP::NO ));
poDS->GetRasterBand(1)->SetColorInterpretation( GCI_RedBand );
poDS->GetRasterBand(2)->SetColorInterpretation( GCI_GreenBand );
poDS->GetRasterBand(3)->SetColorInterpretation( GCI_BlueBand );
}
/* -------------------------------------------------------------------- */
/* Check for world file. */
/* -------------------------------------------------------------------- */
poDS->bGeoTransformValid =
CPL_TO_BOOL(
GDALReadWorldFile( poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform ) );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
GDALDataset *ISIS3Dataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does this look like a CUBE dataset? */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the file using the large file API. */
/* -------------------------------------------------------------------- */
VSILFILE *fpQube = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpQube == NULL )
return NULL;
ISIS3Dataset *poDS;
poDS = new ISIS3Dataset();
if( ! poDS->oKeywords.Ingest( fpQube, 0 ) )
{
VSIFCloseL( fpQube );
delete poDS;
return NULL;
}
VSIFCloseL( fpQube );
/* -------------------------------------------------------------------- */
/* Assume user is pointing to label (ie .lbl) file for detached option */
/* -------------------------------------------------------------------- */
// Image can be inline or detached and point to an image name
// the Format can be Tiled or Raw
// Object = Core
// StartByte = 65537
// Format = Tile
// TileSamples = 128
// TileLines = 128
//OR-----
// Object = Core
// StartByte = 1
// ^Core = r0200357_detatched.cub
// Format = BandSequential
//OR-----
// Object = Core
// StartByte = 1
// ^Core = r0200357_detached_tiled.cub
// Format = Tile
// TileSamples = 128
// TileLines = 128
/* -------------------------------------------------------------------- */
/* What file contains the actual data? */
/* -------------------------------------------------------------------- */
const char *pszCore = poDS->GetKeyword( "IsisCube.Core.^Core" );
CPLString osQubeFile;
if( EQUAL(pszCore,"") )
osQubeFile = poOpenInfo->pszFilename;
else
{
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
osQubeFile = CPLFormFilename( osPath, pszCore, NULL );
poDS->osExternalCube = osQubeFile;
}
/* -------------------------------------------------------------------- */
/* Check if file an ISIS3 header file? Read a few lines of text */
/* searching for something starting with nrows or ncols. */
/* -------------------------------------------------------------------- */
GDALDataType eDataType = GDT_Byte;
OGRSpatialReference oSRS;
int nRows = -1;
int nCols = -1;
int nBands = 1;
int nSkipBytes = 0;
int tileSizeX = 0;
int tileSizeY = 0;
double dfULXMap=0.5;
double dfULYMap = 0.5;
double dfXDim = 1.0;
double dfYDim = 1.0;
double scaleFactor = 1.0;
double dfNoData = 0.0;
int bNoDataSet = FALSE;
char chByteOrder = 'M'; //default to MSB
char szLayout[32] = "BandSequential"; //default to band seq.
const char *target_name; //planet name
//projection parameters
const char *map_proj_name;
int bProjectionSet = TRUE;
char proj_target_name[200];
char geog_name[60];
char datum_name[60];
char sphere_name[60];
char bIsGeographic = TRUE;
double semi_major = 0.0;
double semi_minor = 0.0;
double iflattening = 0.0;
float center_lat = 0.0;
float center_lon = 0.0;
float first_std_parallel = 0.0;
float second_std_parallel = 0.0;
double radLat, localRadius;
VSILFILE *fp;
/************* Skipbytes *****************************/
nSkipBytes = atoi(poDS->GetKeyword("IsisCube.Core.StartByte","")) - 1;
/******* Grab format type (BandSequential, Tiled) *******/
const char *value;
value = poDS->GetKeyword( "IsisCube.Core.Format", "" );
if (EQUAL(value,"Tile") ) { //Todo
strcpy(szLayout,"Tiled");
/******* Get Tile Sizes *********/
tileSizeX = atoi(poDS->GetKeyword("IsisCube.Core.TileSamples",""));
tileSizeY = atoi(poDS->GetKeyword("IsisCube.Core.TileLines",""));
if (tileSizeX <= 0 || tileSizeY <= 0)
{
CPLError( CE_Failure, CPLE_OpenFailed, "Wrong tile dimensions : %d x %d",
tileSizeX, tileSizeY);
delete poDS;
return NULL;
}
}
else if (EQUAL(value,"BandSequential") )
strcpy(szLayout,"BSQ");
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
delete poDS;
return NULL;
}
/*********** Grab samples lines band ************/
nCols = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Samples",""));
nRows = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Lines",""));
nBands = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Bands",""));
/****** Grab format type - ISIS3 only supports 8,U16,S16,32 *****/
const char *itype;
itype = poDS->GetKeyword( "IsisCube.Core.Pixels.Type" );
if (EQUAL(itype,"UnsignedByte") ) {
eDataType = GDT_Byte;
dfNoData = NULL1;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"UnsignedWord") ) {
eDataType = GDT_UInt16;
dfNoData = NULL1;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"SignedWord") ) {
eDataType = GDT_Int16;
dfNoData = NULL2;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"Real") || EQUAL(value,"") ) {
eDataType = GDT_Float32;
dfNoData = NULL3;
bNoDataSet = TRUE;
}
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout type not supported. Abort\n\n", itype);
delete poDS;
return NULL;
}
/*********** Grab samples lines band ************/
value = poDS->GetKeyword( "IsisCube.Core.Pixels.ByteOrder");
if (EQUAL(value,"Lsb"))
chByteOrder = 'I';
/*********** Grab Cellsize ************/
value = poDS->GetKeyword("IsisCube.Mapping.PixelResolution");
if (strlen(value) > 0 ) {
dfXDim = atof(value); /* values are in meters */
dfYDim = -atof(value);
}
/*********** Grab UpperLeftCornerY ************/
value = poDS->GetKeyword("IsisCube.Mapping.UpperLeftCornerY");
if (strlen(value) > 0) {
dfULYMap = atof(value);
}
/*********** Grab UpperLeftCornerX ************/
value = poDS->GetKeyword("IsisCube.Mapping.UpperLeftCornerX");
if( strlen(value) > 0 ) {
dfULXMap = atof(value);
}
/*********** Grab TARGET_NAME ************/
/**** This is the planets name i.e. Mars ***/
target_name = poDS->GetKeyword("IsisCube.Mapping.TargetName");
/*********** Grab MAP_PROJECTION_TYPE ************/
map_proj_name =
poDS->GetKeyword( "IsisCube.Mapping.ProjectionName");
/*********** Grab SEMI-MAJOR ************/
semi_major =
atof(poDS->GetKeyword( "IsisCube.Mapping.EquatorialRadius"));
/*********** Grab semi-minor ************/
semi_minor =
atof(poDS->GetKeyword( "IsisCube.Mapping.PolarRadius"));
/*********** Grab CENTER_LAT ************/
center_lat =
atof(poDS->GetKeyword( "IsisCube.Mapping.CenterLatitude"));
/*********** Grab CENTER_LON ************/
center_lon =
atof(poDS->GetKeyword( "IsisCube.Mapping.CenterLongitude"));
/*********** Grab 1st std parallel ************/
first_std_parallel =
atof(poDS->GetKeyword( "IsisCube.Mapping.FirstStandardParallel"));
/*********** Grab 2nd std parallel ************/
second_std_parallel =
atof(poDS->GetKeyword( "IsisCube.Mapping.SecondStandardParallel"));
/*********** Grab scaleFactor ************/
scaleFactor =
atof(poDS->GetKeyword( "IsisCube.Mapping.scaleFactor"));
/*** grab LatitudeType = Planetographic ****/
// Need to further study how ocentric/ographic will effect the gdal library
// So far we will use this fact to define a sphere or ellipse for some
// projections
// Frank - may need to talk this over
value = poDS->GetKeyword("IsisCube.Mapping.LatitudeType");
if (EQUAL( value, "\"Planetocentric\"" ))
bIsGeographic = FALSE;
//Set oSRS projection and parameters
//############################################################
//ISIS3 Projection types
// Equirectangular
// LambertConformal
// Mercator
// ObliqueCylindrical //Todo
// Orthographic
// PolarStereographic
// SimpleCylindrical
// Sinusoidal
// TransverseMercator
#ifdef DEBUG
CPLDebug( "ISIS3", "using projection %s", map_proj_name);
#endif
if ((EQUAL( map_proj_name, "Equirectangular" )) ||
(EQUAL( map_proj_name, "SimpleCylindrical" )) ) {
oSRS.OGRSpatialReference::SetEquirectangular2 ( 0.0, center_lon, center_lat, 0, 0 );
} else if (EQUAL( map_proj_name, "Orthographic" )) {
oSRS.OGRSpatialReference::SetOrthographic ( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "Sinusoidal" )) {
oSRS.OGRSpatialReference::SetSinusoidal ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "Mercator" )) {
oSRS.OGRSpatialReference::SetMercator ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "PolarStereographic" )) {
oSRS.OGRSpatialReference::SetPS ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "TransverseMercator" )) {
oSRS.OGRSpatialReference::SetTM ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "LambertConformal" )) {
oSRS.OGRSpatialReference::SetLCC ( first_std_parallel, second_std_parallel, center_lat, center_lon, 0, 0 );
} else {
CPLDebug( "ISIS3",
"Dataset projection %s is not supported. Continuing...",
map_proj_name );
bProjectionSet = FALSE;
}
if (bProjectionSet) {
//Create projection name, i.e. MERCATOR MARS and set as ProjCS keyword
strcpy(proj_target_name, map_proj_name);
strcat(proj_target_name, " ");
strcat(proj_target_name, target_name);
oSRS.SetProjCS(proj_target_name); //set ProjCS keyword
//The geographic/geocentric name will be the same basic name as the body name
//'GCS' = Geographic/Geocentric Coordinate System
strcpy(geog_name, "GCS_");
strcat(geog_name, target_name);
//The datum name will be the same basic name as the planet
strcpy(datum_name, "D_");
strcat(datum_name, target_name);
strcpy(sphere_name, target_name);
//strcat(sphere_name, "_IAU_IAG"); //Might not be IAU defined so don't add
//calculate inverse flattening from major and minor axis: 1/f = a/(a-b)
if ((semi_major - semi_minor) < 0.0000001)
iflattening = 0;
else
iflattening = semi_major / (semi_major - semi_minor);
//Set the body size but take into consideration which proj is being used to help w/ proj4 compatibility
//The use of a Sphere, polar radius or ellipse here is based on how ISIS does it internally
if ( ( (EQUAL( map_proj_name, "Stereographic" ) && (fabs(center_lat) == 90)) ) ||
(EQUAL( map_proj_name, "PolarStereographic" )) )
{
if (bIsGeographic) {
//Geograpraphic, so set an ellipse
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere using the semi-minor axis. I hope...
strcat(sphere_name, "_polarRadius");
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_minor, 0.0,
"Reference_Meridian", 0.0 );
}
}
else if ( (EQUAL( map_proj_name, "SimpleCylindrical" )) ||
(EQUAL( map_proj_name, "Orthographic" )) ||
(EQUAL( map_proj_name, "Stereographic" )) ||
(EQUAL( map_proj_name, "Sinusoidal" )) ) {
//isis uses the sphereical equation for these projections so force a sphere
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
else if (EQUAL( map_proj_name, "Equirectangular" )) {
//Calculate localRadius using ISIS3 simple elliptical method
// not the more standard Radius of Curvature method
//PI = 4 * atan(1);
radLat = center_lat * PI / 180; // in radians
localRadius = semi_major * semi_minor / sqrt(pow(semi_minor*cos(radLat),2)
+ pow(semi_major*sin(radLat),2) );
strcat(sphere_name, "_localRadius");
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
localRadius, 0.0,
"Reference_Meridian", 0.0 );
}
else {
//All other projections: Mercator, Transverse Mercator, Lambert Conformal, etc.
//Geographic, so set an ellipse
if (bIsGeographic) {
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere. I hope...
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
}
// translate back into a projection string.
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
/* END ISIS3 Label Read */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* -------------------------------------------------------------------- */
/* Is the CUB detached - if so, reset name to binary file? */
/* -------------------------------------------------------------------- */
#ifdef notdef
// Frank - is this correct?
//The extension already added on so don't add another. But is this needed?
char *pszPath = CPLStrdup( CPLGetPath( poOpenInfo->pszFilename ) );
char *pszName = CPLStrdup( CPLGetBasename( poOpenInfo->pszFilename ) );
if (bIsDetached)
pszCUBFilename = CPLFormCIFilename( pszPath, detachedCub, "" );
#endif
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows < 1 || nCols < 1 || nBands < 1 )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( osQubeFile, "r" );
else
poDS->fpImage = VSIFOpenL( osQubeFile, "r+" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s with write permission.\n%s",
osQubeFile.c_str(),
VSIStrerror( errno ) );
delete poDS;
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nLineOffset=0, nPixelOffset=0, nBandOffset=0;
if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = nPixelOffset * nCols;
nBandOffset = nLineOffset * nRows;
}
else /* Tiled */
{
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int i;
#ifdef CPL_LSB
int bNativeOrder = !(chByteOrder == 'M');
#else
int bNativeOrder = (chByteOrder == 'M');
#endif
for( i = 0; i < nBands; i++ )
{
GDALRasterBand *poBand;
if( EQUAL(szLayout,"Tiled") )
{
poBand = new ISISTiledBand( poDS, poDS->fpImage, i+1, eDataType,
tileSizeX, tileSizeY,
nSkipBytes, 0, 0,
bNativeOrder );
}
else
{
poBand =
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
TRUE );
}
poDS->SetBand( i+1, poBand );
if( bNoDataSet )
((GDALPamRasterBand *) poBand)->SetNoDataValue( dfNoData );
// Set offset/scale values at the PAM level.
poBand->SetOffset(
CPLAtofM(poDS->GetKeyword("IsisCube.Core.Pixels.Base","0.0")));
poBand->SetScale(
CPLAtofM(poDS->GetKeyword("IsisCube.Core.Pixels.Multiplier","1.0")));
}
/* -------------------------------------------------------------------- */
/* Check for a .prj file. For ISIS3 I would like to keep this in */
/* -------------------------------------------------------------------- */
CPLString osPath, osName;
osPath = CPLGetPath( poOpenInfo->pszFilename );
osName = CPLGetBasename(poOpenInfo->pszFilename);
const char *pszPrjFile = CPLFormCIFilename( osPath, osName, "prj" );
fp = VSIFOpenL( pszPrjFile, "r" );
if( fp != NULL )
{
char **papszLines;
OGRSpatialReference oSRS;
VSIFCloseL( fp );
papszLines = CSLLoad( pszPrjFile );
if( oSRS.importFromESRI( papszLines ) == OGRERR_NONE )
{
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
CSLDestroy( papszLines );
}
if( dfULYMap != 0.5 || dfULYMap != 0.5 || dfXDim != 1.0 || dfYDim != 1.0 )
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = dfULXMap;
poDS->adfGeoTransform[1] = dfXDim;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = dfULYMap;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = dfYDim;
}
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "cbw",
poDS->adfGeoTransform );
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}