int OGRCSVDataSource::OpenTable( const char * pszFilename )
{
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
FILE * fp;
if( bUpdate )
fp = VSIFOpen( pszFilename, "rb+" );
else
fp = VSIFOpen( pszFilename, "rb" );
if( fp == NULL )
{
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, %s.",
pszFilename, VSIStrerror( errno ) );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Read and parse a line. Did we get multiple fields? */
/* -------------------------------------------------------------------- */
const char* pszLine = CPLReadLine( fp );
if (pszLine == NULL)
{
VSIFClose( fp );
return FALSE;
}
char chDelimiter = CSVDetectSeperator(pszLine);
VSIRewind( fp );
char **papszFields = CSVReadParseLine2( fp, chDelimiter );
if( CSLCount(papszFields) < 2 )
{
VSIFClose( fp );
CSLDestroy( papszFields );
return FALSE;
}
VSIRewind( fp );
CSLDestroy( papszFields );
/* -------------------------------------------------------------------- */
/* Create a layer. */
/* -------------------------------------------------------------------- */
nLayers++;
papoLayers = (OGRCSVLayer **) CPLRealloc(papoLayers,
sizeof(void*) * nLayers);
papoLayers[nLayers-1] =
new OGRCSVLayer( CPLGetBasename(pszFilename), fp, pszFilename, FALSE, bUpdate, chDelimiter );
return TRUE;
}
int MIDDATAFile::Rewind()
{
if (m_fp == NULL || m_eAccessMode == TABWrite)
return -1;
else
{
VSIRewind(m_fp);
SetEof(VSIFEof(m_fp));
}
return 0;
}
/**********************************************************************
* E00ReadRewind()
*
* Rewind the E00ReadPtr. Allows to start another read pass on the
* input file.
**********************************************************************/
void E00ReadRewind(E00ReadPtr psInfo)
{
CPLErrorReset();
psInfo->szInBuf[0] = psInfo->szOutBuf[0] = '\0';
psInfo->iInBufPtr = 0;
psInfo->nInputLineNo = 0;
if (psInfo->pfnReadRewind == NULL)
VSIRewind(psInfo->fp);
else
psInfo->pfnReadRewind(psInfo->pRefData);
psInfo->bEOF = 0;
}
void OGRXPlaneReader::Rewind()
{
if (fp != NULL)
{
VSIRewind(fp);
CPLReadLine(fp);
CPLReadLine(fp);
nLineNumber = 2;
CSLDestroy(papszTokens);
papszTokens = NULL;
bEOF = FALSE;
}
}
int CSVGetFieldId( FILE * fp, const char * pszFieldName )
{
char **papszFields;
int i;
CPLAssert( fp != NULL && pszFieldName != NULL );
VSIRewind( fp );
papszFields = CSVReadParseLine( fp );
for( i = 0; papszFields != NULL && papszFields[i] != NULL; i++ )
{
if( EQUAL(papszFields[i],pszFieldName) )
{
CSLDestroy( papszFields );
return i;
}
}
CSLDestroy( papszFields );
return -1;
}
void BSBDataset::ScanForGCPsNos( const char *pszFilename )
{
char **Tokens;
const char *geofile;
const char *extension;
int fileGCPCount=0;
extension = CPLGetExtension(pszFilename);
// pseudointelligently try and guess whether we want a .geo or a .GEO
if (extension[1] == 'O')
{
geofile = CPLResetExtension( pszFilename, "GEO");
} else {
geofile = CPLResetExtension( pszFilename, "geo");
}
FILE *gfp = VSIFOpen( geofile, "r" ); // Text files
if( gfp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Couldn't find a matching .GEO file: %s", geofile );
return;
}
char *thisLine = (char *) CPLMalloc( 80 ); // FIXME
// Count the GCPs (reference points) and seek the file pointer 'gfp' to the starting point
while (fgets(thisLine, 80, gfp))
{
if( EQUALN(thisLine, "Point", 5) )
fileGCPCount++;
}
VSIRewind( gfp );
// Memory has not been allocated to fileGCPCount yet
pasGCPList = (GDAL_GCP *) CPLCalloc(sizeof(GDAL_GCP),fileGCPCount+1);
while (fgets(thisLine, 80, gfp))
{
if( EQUALN(thisLine, "Point", 5) )
{
// got a point line, turn it into a gcp
Tokens = CSLTokenizeStringComplex(thisLine, "= ", FALSE, FALSE);
if (CSLCount(Tokens) >= 5)
{
GDALInitGCPs( 1, pasGCPList + nGCPCount );
pasGCPList[nGCPCount].dfGCPX = atof(Tokens[1]);
pasGCPList[nGCPCount].dfGCPY = atof(Tokens[2]);
pasGCPList[nGCPCount].dfGCPPixel = atof(Tokens[4]);
pasGCPList[nGCPCount].dfGCPLine = atof(Tokens[3]);
CPLFree( pasGCPList[nGCPCount].pszId );
char szName[50];
sprintf( szName, "GCP_%d", nGCPCount+1 );
pasGCPList[nGCPCount].pszId = CPLStrdup( szName );
nGCPCount++;
}
CSLDestroy(Tokens);
}
}
CPLFree(thisLine);
VSIFClose(gfp);
}
DGNHandle DGNOpen( const char * pszFilename, int bUpdate )
{
DGNInfo *psDGN;
FILE *fp;
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( bUpdate )
fp = VSIFOpen( pszFilename, "rb+" );
else
fp = VSIFOpen( pszFilename, "rb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to open `%s' for read access.\n",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Verify the format ... add later. */
/* -------------------------------------------------------------------- */
GByte abyHeader[512];
VSIFRead( abyHeader, 1, sizeof(abyHeader), fp );
if( !DGNTestOpen( abyHeader, sizeof(abyHeader) ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File `%s' does not have expected DGN header.\n",
pszFilename );
VSIFClose( fp );
return NULL;
}
VSIRewind( fp );
/* -------------------------------------------------------------------- */
/* Create the info structure. */
/* -------------------------------------------------------------------- */
psDGN = (DGNInfo *) CPLCalloc(sizeof(DGNInfo),1);
psDGN->fp = fp;
psDGN->next_element_id = 0;
psDGN->got_tcb = FALSE;
psDGN->scale = 1.0;
psDGN->origin_x = 0.0;
psDGN->origin_y = 0.0;
psDGN->origin_z = 0.0;
psDGN->index_built = FALSE;
psDGN->element_count = 0;
psDGN->element_index = NULL;
psDGN->got_bounds = FALSE;
if( abyHeader[0] == 0xC8 )
psDGN->dimension = 3;
else
psDGN->dimension = 2;
psDGN->has_spatial_filter = FALSE;
psDGN->sf_converted_to_uor = FALSE;
psDGN->select_complex_group = FALSE;
psDGN->in_complex_group = FALSE;
return (DGNHandle) psDGN;
}
GDALOpenInfo::GDALOpenInfo( const char * pszFilenameIn, GDALAccess eAccessIn,
char **papszSiblingsIn )
{
/* -------------------------------------------------------------------- */
/* Ensure that C: is treated as C:\ so we can stat it on */
/* Windows. Similar to what is done in CPLStat(). */
/* -------------------------------------------------------------------- */
#ifdef WIN32
if( strlen(pszFilenameIn) == 2 && pszFilenameIn[1] == ':' )
{
char szAltPath[10];
strcpy( szAltPath, pszFilenameIn );
strcat( szAltPath, "\\" );
pszFilename = CPLStrdup( szAltPath );
}
else
#endif
pszFilename = CPLStrdup( pszFilenameIn );
/* -------------------------------------------------------------------- */
/* Initialize. */
/* -------------------------------------------------------------------- */
nHeaderBytes = 0;
pabyHeader = NULL;
bIsDirectory = FALSE;
bStatOK = FALSE;
eAccess = eAccessIn;
fp = NULL;
/* -------------------------------------------------------------------- */
/* Collect information about the file. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStat;
if( VSIStatL( pszFilename, &sStat ) == 0 )
{
bStatOK = TRUE;
if( VSI_ISREG( sStat.st_mode ) )
{
pabyHeader = (GByte *) CPLCalloc(1025,1);
fp = VSIFOpen( pszFilename, "rb" );
if( fp != NULL )
{
nHeaderBytes = (int) VSIFRead( pabyHeader, 1, 1024, fp );
VSIRewind( fp );
}
/* XXX: ENOENT is used to catch the case of virtual filesystem
* when we do not have a real file with such a name. Under some
* circumstances EINVAL reported instead of ENOENT in Windows
* (for filenames containing colon, e.g. "smth://name").
* See also: #2437 */
else if( errno == 27 /* "File to large" */
|| errno == ENOENT || errno == EINVAL
#ifdef EOVERFLOW
|| errno == EOVERFLOW
#else
|| errno == 75 /* Linux EOVERFLOW */
|| errno == 79 /* Solaris EOVERFLOW */
#endif
)
{
fp = VSIFOpenL( pszFilename, "rb" );
if( fp != NULL )
{
nHeaderBytes = (int) VSIFReadL( pabyHeader, 1, 1024, fp );
VSIFCloseL( fp );
fp = NULL;
}
}
}
else if( VSI_ISDIR( sStat.st_mode ) )
bIsDirectory = TRUE;
}
/* -------------------------------------------------------------------- */
/* Capture sibling list either from passed in values, or by */
/* scanning for them. */
/* -------------------------------------------------------------------- */
if( papszSiblingsIn != NULL )
{
papszSiblingFiles = CSLDuplicate( papszSiblingsIn );
}
else if( bStatOK && !bIsDirectory )
{
if( CSLTestBoolean(
CPLGetConfigOption( "GDAL_DISABLE_READDIR_ON_OPEN", "NO" )) )
{
/* skip reading the directory */
papszSiblingFiles = NULL;
}
else
{
CPLString osDir = CPLGetDirname( pszFilename );
papszSiblingFiles = VSIReadDir( osDir );
}
}
else
papszSiblingFiles = NULL;
}
GDALOpenInfo::GDALOpenInfo(const char *pszFilenameIn, GDALAccess eAccessIn,
char **papszSiblingsIn)
{
/* -------------------------------------------------------------------- */
/* Ensure that C: is treated as C:\ so we can stat it on */
/* Windows. Similar to what is done in CPLStat(). */
/* -------------------------------------------------------------------- */
#ifdef WIN32
if (strlen(pszFilenameIn) == 2 && pszFilenameIn[1] == ':')
{
char szAltPath[10];
strcpy(szAltPath, pszFilenameIn);
strcat(szAltPath, "\\");
pszFilename = CPLStrdup(szAltPath);
}
else
#endif
pszFilename = CPLStrdup(pszFilenameIn);
/* -------------------------------------------------------------------- */
/* Initialize. */
/* -------------------------------------------------------------------- */
nHeaderBytes = 0;
pabyHeader = NULL;
bIsDirectory = FALSE;
bStatOK = FALSE;
eAccess = eAccessIn;
fp = NULL;
#ifdef HAVE_READLINK
int bHasRetried = FALSE;
#endif
/* -------------------------------------------------------------------- */
/* Collect information about the file. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStat;
#ifdef HAVE_READLINK
retry:
#endif
if (VSIStatExL(pszFilename, &sStat,
VSI_STAT_EXISTS_FLAG | VSI_STAT_NATURE_FLAG) == 0)
{
bStatOK = TRUE;
if (VSI_ISREG(sStat.st_mode))
{
pabyHeader = (GByte*) CPLCalloc(1025, 1);
fp = VSIFOpen(pszFilename, "rb");
if (fp != NULL)
{
nHeaderBytes = (int) VSIFRead(pabyHeader, 1, 1024, fp);
VSIRewind(fp);
}
/* XXX: ENOENT is used to catch the case of virtual filesystem
* when we do not have a real file with such a name. Under some
* circumstances EINVAL reported instead of ENOENT in Windows
* (for filenames containing colon, e.g. "smth://name").
* See also: #2437 */
else if (errno == 27 /* "File to large" */
|| errno == ENOENT || errno == EINVAL
#ifdef EOVERFLOW
|| errno == EOVERFLOW
#else
|| errno == 75 /* Linux EOVERFLOW */
|| errno == 79 /* Solaris EOVERFLOW */
#endif
)
{
VSILFILE *fpL = VSIFOpenL(pszFilename, "rb");
if (fpL != NULL)
{
nHeaderBytes = (int) VSIFReadL(pabyHeader, 1, 1024, fpL);
VSIFCloseL(fpL);
}
}
}
else if (VSI_ISDIR(sStat.st_mode))
bIsDirectory = TRUE;
}
#ifdef HAVE_READLINK
else if (!bHasRetried)
{
/* If someone creates a file with "ln -sf /vsicurl/http://download.osgeo.org/gdal/data/gtiff/utm.tif my_remote_utm.tif" */
/* we will be able to open it by passing my_remote_utm.tif */
/* This helps a lot for GDAL based readers that only provide file explorers to open datasets */
char szPointerFilename[2048];
int nBytes = readlink(pszFilename, szPointerFilename, sizeof(szPointerFilename));
if (nBytes != -1)
{
szPointerFilename[MIN(nBytes, (int)sizeof(szPointerFilename) - 1)] = 0;
CPLFree(pszFilename);
pszFilename = CPLStrdup(szPointerFilename);
papszSiblingsIn = NULL;
bHasRetried = TRUE;
goto retry;
}
}
#endif
/* -------------------------------------------------------------------- */
/* Capture sibling list either from passed in values, or by */
/* scanning for them. */
/* -------------------------------------------------------------------- */
if (papszSiblingsIn != NULL)
{
papszSiblingFiles = CSLDuplicate(papszSiblingsIn);
}
else if (bStatOK && !bIsDirectory)
{
const char *pszOptionVal =
CPLGetConfigOption("GDAL_DISABLE_READDIR_ON_OPEN", "NO");
if (EQUAL(pszOptionVal, "EMPTY_DIR"))
{
papszSiblingFiles = CSLAddString(NULL, CPLGetFilename(pszFilename));
}
else if (CSLTestBoolean(pszOptionVal))
{
/* skip reading the directory */
papszSiblingFiles = NULL;
}
else
{
CPLString osDir = CPLGetDirname(pszFilename);
papszSiblingFiles = VSIReadDir(osDir);
}
}
else
papszSiblingFiles = NULL;
}
static void CSVIngest( const char *pszFilename )
{
CSVTable *psTable = CSVAccess( pszFilename );
int nFileLen, i, nMaxLineCount, iLine = 0;
char *pszThisLine;
if( psTable->pszRawData != NULL )
return;
/* -------------------------------------------------------------------- */
/* Ingest whole file. */
/* -------------------------------------------------------------------- */
VSIFSeek( psTable->fp, 0, SEEK_END );
nFileLen = VSIFTell( psTable->fp );
VSIRewind( psTable->fp );
psTable->pszRawData = (char *) CPLMalloc(nFileLen+1);
if( (int) VSIFRead( psTable->pszRawData, 1, nFileLen, psTable->fp )
!= nFileLen )
{
CPLFree( psTable->pszRawData );
psTable->pszRawData = NULL;
CPLError( CE_Failure, CPLE_FileIO, "Read of file %s failed.",
psTable->pszFilename );
return;
}
psTable->pszRawData[nFileLen] = '\0';
/* -------------------------------------------------------------------- */
/* Get count of newlines so we can allocate line array. */
/* -------------------------------------------------------------------- */
nMaxLineCount = 0;
for( i = 0; i < nFileLen; i++ )
{
if( psTable->pszRawData[i] == 10 )
nMaxLineCount++;
}
psTable->papszLines = (char **) CPLCalloc(sizeof(char*),nMaxLineCount);
/* -------------------------------------------------------------------- */
/* Build a list of record pointers into the raw data buffer */
/* based on line terminators. Zero terminate the line */
/* strings. */
/* -------------------------------------------------------------------- */
/* skip header line */
pszThisLine = CSVFindNextLine( psTable->pszRawData );
while( pszThisLine != NULL && iLine < nMaxLineCount )
{
psTable->papszLines[iLine++] = pszThisLine;
pszThisLine = CSVFindNextLine( pszThisLine );
}
psTable->nLineCount = iLine;
/* -------------------------------------------------------------------- */
/* Allocate and populate index array. Ensure they are in */
/* ascending order so that binary searches can be done on the */
/* array. */
/* -------------------------------------------------------------------- */
psTable->panLineIndex = (int *) CPLMalloc(sizeof(int)*psTable->nLineCount);
for( i = 0; i < psTable->nLineCount; i++ )
{
psTable->panLineIndex[i] = atoi(psTable->papszLines[i]);
if( i > 0 && psTable->panLineIndex[i] < psTable->panLineIndex[i-1] )
{
CPLFree( psTable->panLineIndex );
psTable->panLineIndex = NULL;
break;
}
}
psTable->iLastLine = -1;
/* -------------------------------------------------------------------- */
/* We should never need the file handle against, so close it. */
/* -------------------------------------------------------------------- */
VSIFClose( psTable->fp );
psTable->fp = NULL;
}
GDALDataset *IDADataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Is this an IDA file? */
/* -------------------------------------------------------------------- */
int nXSize, nYSize;
GIntBig nExpectedFileSize, nActualFileSize;
if( poOpenInfo->fp == NULL )
return NULL;
if( poOpenInfo->nHeaderBytes < 512 )
return NULL;
// projection legal?
if( poOpenInfo->pabyHeader[23] > 10 )
return NULL;
// imagetype legal?
if( (poOpenInfo->pabyHeader[22] > 14
&& poOpenInfo->pabyHeader[22] < 100)
|| (poOpenInfo->pabyHeader[22] > 114
&& poOpenInfo->pabyHeader[22] != 200 ) )
return NULL;
nXSize = poOpenInfo->pabyHeader[30] + poOpenInfo->pabyHeader[31] * 256;
nYSize = poOpenInfo->pabyHeader[32] + poOpenInfo->pabyHeader[33] * 256;
if( nXSize == 0 || nYSize == 0 )
return NULL;
// The file just be exactly the image size + header size in length.
nExpectedFileSize = nXSize * nYSize + 512;
VSIFSeek( poOpenInfo->fp, 0, SEEK_END );
nActualFileSize = VSIFTell( poOpenInfo->fp );
VSIRewind( poOpenInfo->fp );
if( nActualFileSize != nExpectedFileSize )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
IDADataset *poDS = new IDADataset();
memcpy( poDS->abyHeader, poOpenInfo->pabyHeader, 512 );
/* -------------------------------------------------------------------- */
/* Parse various values out of the header. */
/* -------------------------------------------------------------------- */
poDS->nImageType = poOpenInfo->pabyHeader[22];
poDS->nProjection = poOpenInfo->pabyHeader[23];
poDS->nRasterYSize = poOpenInfo->pabyHeader[30]
+ poOpenInfo->pabyHeader[31] * 256;
poDS->nRasterXSize = poOpenInfo->pabyHeader[32]
+ poOpenInfo->pabyHeader[33] * 256;
strncpy( poDS->szTitle, (const char *) poOpenInfo->pabyHeader+38, 80 );
poDS->szTitle[80] = '\0';
int nLastTitleChar = strlen(poDS->szTitle)-1;
while( nLastTitleChar > -1
&& (poDS->szTitle[nLastTitleChar] == 10
|| poDS->szTitle[nLastTitleChar] == 13
|| poDS->szTitle[nLastTitleChar] == ' ') )
poDS->szTitle[nLastTitleChar--] = '\0';
poDS->dfLatCenter = tp2c( poOpenInfo->pabyHeader + 120 );
poDS->dfLongCenter = tp2c( poOpenInfo->pabyHeader + 126 );
poDS->dfXCenter = tp2c( poOpenInfo->pabyHeader + 132 );
poDS->dfYCenter = tp2c( poOpenInfo->pabyHeader + 138 );
poDS->dfDX = tp2c( poOpenInfo->pabyHeader + 144 );
poDS->dfDY = tp2c( poOpenInfo->pabyHeader + 150 );
poDS->dfParallel1 = tp2c( poOpenInfo->pabyHeader + 156 );
poDS->dfParallel2 = tp2c( poOpenInfo->pabyHeader + 162 );
poDS->ProcessGeoref();
poDS->SetMetadataItem( "TITLE", poDS->szTitle );
/* -------------------------------------------------------------------- */
/* Handle various image types. */
/* -------------------------------------------------------------------- */
/*
GENERIC = 0
FEW S NDVI = 1
EROS NDVI = 6
ARTEMIS CUTOFF = 10
ARTEMIS RECODE = 11
ARTEMIS NDVI = 12
ARTEMIS FEWS = 13
ARTEMIS NEWNASA = 14
GENERIC DIFF = 100
FEW S NDVI DIFF = 101
EROS NDVI DIFF = 106
ARTEMIS CUTOFF DIFF = 110
ARTEMIS RECODE DIFF = 111
ARTEMIS NDVI DIFF = 112
ARTEMIS FEWS DIFF = 113
ARTEMIS NEWNASA DIFF = 114
CALCULATED =200
*/
poDS->nMissing = 0;
switch( poDS->nImageType )
{
case 1:
poDS->SetMetadataItem( "IMAGETYPE", "1, FEWS NDVI" );
poDS->dfM = 1/256.0;
poDS->dfB = -82/256.0;
break;
case 6:
poDS->SetMetadataItem( "IMAGETYPE", "6, EROS NDVI" );
poDS->dfM = 1/100.0;
poDS->dfB = -100/100.0;
break;
case 10:
poDS->SetMetadataItem( "IMAGETYPE", "10, ARTEMIS CUTOFF" );
poDS->dfM = 1.0;
poDS->dfB = 0.0;
poDS->nMissing = 254;
break;
case 11:
poDS->SetMetadataItem( "IMAGETYPE", "11, ARTEMIS RECODE" );
poDS->dfM = 4.0;
poDS->dfB = 0.0;
poDS->nMissing = 254;
break;
case 12: /* ANDVI */
poDS->SetMetadataItem( "IMAGETYPE", "12, ARTEMIS NDVI" );
poDS->dfM = 4/500.0;
poDS->dfB = -3/500.0 - 1.0;
poDS->nMissing = 254;
break;
case 13: /* AFEWS */
poDS->SetMetadataItem( "IMAGETYPE", "13, ARTEMIS FEWS" );
poDS->dfM = 1/256.0;
poDS->dfB = -82/256.0;
poDS->nMissing = 254;
break;
case 14: /* NEWNASA */
poDS->SetMetadataItem( "IMAGETYPE", "13, ARTEMIS NEWNASA" );
poDS->dfM = 0.75/250.0;
poDS->dfB = 0.0;
poDS->nMissing = 254;
break;
case 101: /* NDVI_DIFF (FEW S) */
poDS->dfM = 1/128.0;
poDS->dfB = -1.0;
poDS->nMissing = 0;
break;
case 106: /* EROS_DIFF */
poDS->dfM = 1/50.0;
poDS->dfB = -128/50.0;
poDS->nMissing = 0;
break;
case 110: /* CUTOFF_DIFF */
poDS->dfM = 2.0;
poDS->dfB = -128*2;
poDS->nMissing = 254;
break;
case 111: /* RECODE_DIFF */
poDS->dfM = 8;
poDS->dfB = -128*8;
poDS->nMissing = 254;
break;
case 112: /* ANDVI_DIFF */
poDS->dfM = 8/1000.0;
poDS->dfB = (-128*8)/1000.0;
poDS->nMissing = 254;
break;
case 113: /* AFEWS_DIFF */
poDS->dfM = 1/128.0;
poDS->dfB = -1;
poDS->nMissing = 254;
break;
case 114: /* NEWNASA_DIFF */
poDS->dfM = 0.75/125.0;
poDS->dfB = -128*poDS->dfM;
poDS->nMissing = 254;
break;
case 200:
/* we use the values from the header */
poDS->dfM = tp2c( poOpenInfo->pabyHeader + 171 );
poDS->dfB = tp2c( poOpenInfo->pabyHeader + 177 );
poDS->nMissing = poOpenInfo->pabyHeader[170];
break;
default:
poDS->dfM = 1.0;
poDS->dfB = 0.0;
break;
}
/* -------------------------------------------------------------------- */
/* Create the band. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
{
poDS->fpRaw = poOpenInfo->fp;
poOpenInfo->fp = NULL;
}
else
{
poDS->fpRaw = VSIFOpen( poOpenInfo->pszFilename, "rb+" );
poDS->eAccess = GA_Update;
if( poDS->fpRaw == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s for write access.",
poOpenInfo->pszFilename );
return NULL;
}
}
poDS->SetBand( 1, new IDARasterBand( poDS, poDS->fpRaw,
poDS->nRasterXSize ) );
/* -------------------------------------------------------------------- */
/* Check for a color table. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->ReadColorTable();
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}