static tsize_t
_tiffWriteProc(thandle_t th, tdata_t buf, tsize_t size)
{
GDALTiffHandle* psGTH = (GDALTiffHandle*) th;
// If we have a write buffer and are at end of file, then accumulate
// the bytes until the buffer is full
if( psGTH->bAtEndOfFile && psGTH->abyWriteBuffer )
{
const GByte* pabyData = (const GByte*) buf;
tsize_t nRemainingBytes = size;
while( TRUE )
{
if( psGTH->nWriteBufferSize + nRemainingBytes <= BUFFER_SIZE )
{
memcpy( psGTH->abyWriteBuffer + psGTH->nWriteBufferSize,
pabyData, nRemainingBytes );
psGTH->nWriteBufferSize += nRemainingBytes;
psGTH->nExpectedPos += size;
return size;
}
int nAppendable = BUFFER_SIZE - psGTH->nWriteBufferSize;
memcpy( psGTH->abyWriteBuffer + psGTH->nWriteBufferSize, pabyData,
nAppendable );
tsize_t nRet = VSIFWriteL( psGTH->abyWriteBuffer, 1, BUFFER_SIZE, psGTH->fpL );
psGTH->nWriteBufferSize = 0;
if( nRet != BUFFER_SIZE )
{
TIFFErrorExt( th, "_tiffWriteProc", "%s", VSIStrerror( errno ) );
return 0;
}
pabyData += nAppendable;
nRemainingBytes -= nAppendable;
}
}
tsize_t nRet = VSIFWriteL( buf, 1, size, psGTH->fpL );
if (nRet < size)
{
TIFFErrorExt( th, "_tiffWriteProc", "%s", VSIStrerror( errno ) );
}
if( psGTH->bAtEndOfFile )
{
psGTH->nExpectedPos += nRet;
}
return nRet;
}
CPLErr TerragenRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff,
void* pImage )
{
//CPLAssert( sizeof(float) == sizeof(GInt32) );
CPLAssert( nBlockXOff == 0 );
CPLAssert( pImage != NULL );
TerragenDataset& ds = *(TerragenDataset *) poDS;
/* -------------------------------------------------------------------- */
/* Seek to scanline.
Terragen is a bottom-top format, so we have to
invert the row location.
-------------------------------------------------------------------- */
const size_t rowbytes = nBlockXSize * sizeof(GInt16);
if(0 != VSIFSeekL(
ds.m_fp,
ds.m_nDataOffset +
(ds.GetRasterYSize() -1 - nBlockYOff) * rowbytes,
SEEK_SET))
{
CPLError( CE_Failure, CPLE_FileIO,
"Terragen Seek failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Read the scanline into the line buffer. */
/* -------------------------------------------------------------------- */
if( VSIFReadL( pImage, rowbytes, 1, ds.m_fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Terragen read failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Swap on MSB platforms. */
/* -------------------------------------------------------------------- */
#ifdef CPL_MSB
GDALSwapWords( pImage, sizeof(GInt16), nRasterXSize, sizeof(GInt16) );
#endif
return CE_None;
}
OGRErr OGRShapeLayer::DropSpatialIndex()
{
if( !CheckForQIX() )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Layer %s has no spatial index, DROP SPATIAL INDEX failed.",
poFeatureDefn->GetName() );
return OGRERR_FAILURE;
}
VSIFClose( fpQIX );
fpQIX = NULL;
bCheckedForQIX = FALSE;
const char *pszQIXFilename;
pszQIXFilename = CPLResetExtension( pszFullName, "qix" );
CPLDebug( "SHAPE", "Unlinking index file %s", pszQIXFilename );
if( VSIUnlink( pszQIXFilename ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to delete file %s.\n%s",
pszQIXFilename, VSIStrerror( errno ) );
return OGRERR_FAILURE;
}
else
return OGRERR_NONE;
}
CPLErr LAN4BitRasterBand::IReadBlock( CPL_UNUSED int nBlockXOff,
int nBlockYOff,
void * pImage )
{
LANDataset *poLAN_DS = reinterpret_cast<LANDataset *>( poDS );
CPLAssert( nBlockXOff == 0 );
/* -------------------------------------------------------------------- */
/* Seek to profile. */
/* -------------------------------------------------------------------- */
const vsi_l_offset nOffset =
ERD_HEADER_SIZE
+ (static_cast<vsi_l_offset>(nBlockYOff) * nRasterXSize * poLAN_DS->GetRasterCount()) / 2
+ (static_cast<vsi_l_offset>(nBand - 1) * nRasterXSize) / 2;
if( VSIFSeekL( poLAN_DS->fpImage, nOffset, SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"LAN Seek failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Read the profile. */
/* -------------------------------------------------------------------- */
if( VSIFReadL( pImage, 1, nRasterXSize/2, poLAN_DS->fpImage ) !=
(size_t) nRasterXSize / 2 )
{
CPLError( CE_Failure, CPLE_FileIO,
"LAN Read failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Convert 4bit to 8bit. */
/* -------------------------------------------------------------------- */
for( int i = nRasterXSize-1; i >= 0; i-- )
{
if( (i & 0x01) != 0 )
reinterpret_cast<GByte *>( pImage )[i] = ((GByte *) pImage)[i/2] & 0x0f;
else
reinterpret_cast<GByte *>( pImage )[i] = (((GByte *) pImage)[i/2] & 0xf0)/16;
}
return CE_None;
}
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;
}
static tsize_t
_tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
{
tsize_t nRet = VSIFWriteL( buf, 1, size, (VSILFILE *) fd );
if (nRet < size)
{
TIFFErrorExt( fd, "_tiffWriteProc", "%s", VSIStrerror( errno ) );
}
return nRet;
}
static toff_t
_tiffSeekProc(thandle_t fd, toff_t off, int whence)
{
if( VSIFSeekL( (VSILFILE *) fd, off, whence ) == 0 )
return (toff_t) VSIFTellL( (VSILFILE *) fd );
else
{
TIFFErrorExt( fd, "_tiffSeekProc", "%s", VSIStrerror( errno ) );
return (toff_t) -1;
}
}
static toff_t
_tiffSeekProc( thandle_t th, toff_t off, int whence )
{
VSILFILE* fp = (VSILFILE*)th;
if( VSIFSeekL( fp, off, whence ) != 0 )
{
TIFFErrorExt( th, "_tiffSeekProc", "%s", VSIStrerror( errno ) );
return (toff_t)( -1 );
}
return VSIFTellL( fp );
}
int OGRILI1DataSource::Create( const char *pszFilename,
char **papszOptions )
{
std::string osBasename, osModelFilename;
char **filenames = CSLTokenizeString2( pszFilename, ",", 0 );
osBasename = filenames[0];
if( CSLCount(filenames) > 1 )
osModelFilename = filenames[1];
CSLDestroy( filenames );
/* -------------------------------------------------------------------- */
/* Create the empty file. */
/* -------------------------------------------------------------------- */
fpTransfer = VSIFOpen( osBasename.c_str(), "w+b" );
if( fpTransfer == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create %s:\n%s",
osBasename.c_str(), VSIStrerror( errno ) );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Parse model */
/* -------------------------------------------------------------------- */
if( osModelFilename.length() == 0 )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Creating Interlis transfer file without model definition." );
} else {
poImdReader->ReadModel(osModelFilename.c_str());
}
pszTopic = CPLStrdup(poImdReader->mainTopicName.c_str());
/* -------------------------------------------------------------------- */
/* Write headers */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpTransfer, "SCNT\n" );
VSIFPrintf( fpTransfer, "OGR/GDAL %s, INTERLIS Driver\n", GDAL_RELEASE_NAME );
VSIFPrintf( fpTransfer, "////\n" );
VSIFPrintf( fpTransfer, "MTID INTERLIS1\n" );
const char* modelname = poImdReader->mainModelName.c_str();
VSIFPrintf( fpTransfer, "MODL %s\n", modelname );
return TRUE;
}
int ISIS2Dataset::WriteRaster(CPLString osFilename,
bool includeLabel,
GUIntBig iRecords,
GUIntBig iLabelRecords,
CPL_UNUSED GDALDataType eType,
CPL_UNUSED const char * pszInterleaving)
{
CPLString pszAccess("wb");
if(includeLabel)
pszAccess = "ab";
VSILFILE *fpBin = VSIFOpenL( osFilename, pszAccess.c_str() );
if( fpBin == nullptr ) {
CPLError( CE_Failure, CPLE_FileIO,
"Failed to create %s:\n%s",
osFilename.c_str(), VSIStrerror( errno ) );
return FALSE;
}
GUIntBig nSize = iRecords * RECORD_SIZE;
CPLDebug("ISIS2","nSize = %i", static_cast<int>(nSize));
if(includeLabel)
nSize = iLabelRecords * RECORD_SIZE + nSize;
// write last byte
const GByte byZero(0);
if(VSIFSeekL( fpBin, nSize-1, SEEK_SET ) != 0 ||
VSIFWriteL( &byZero, 1, 1, fpBin ) != 1) {
CPLError( CE_Failure, CPLE_FileIO,
"Failed to write %s:\n%s",
osFilename.c_str(), VSIStrerror( errno ) );
VSIFCloseL( fpBin );
return FALSE;
}
VSIFCloseL( fpBin );
return TRUE;
}
HFAEntry* HFAEntry::New( HFAInfo_t * psHFAIn, GUInt32 nPos,
HFAEntry * poParentIn, HFAEntry * poPrevIn )
{
HFAEntry* poEntry = new HFAEntry;
poEntry->psHFA = psHFAIn;
poEntry->nFilePos = nPos;
poEntry->poParent = poParentIn;
poEntry->poPrev = poPrevIn;
/* -------------------------------------------------------------------- */
/* Read the entry information from the file. */
/* -------------------------------------------------------------------- */
GInt32 anEntryNums[6] = {};
if( VSIFSeekL( poEntry->psHFA->fp, poEntry->nFilePos, SEEK_SET ) == -1
|| VSIFReadL( anEntryNums, sizeof(GInt32), 6, poEntry->psHFA->fp ) < 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"VSIFReadL(%p,6*4) @ %d failed in HFAEntry().\n%s",
poEntry->psHFA->fp, poEntry->nFilePos, VSIStrerror( errno ) );
delete poEntry;
return NULL;
}
for( int i = 0; i < 6; i++ )
HFAStandard( 4, anEntryNums + i );
poEntry->nNextPos = anEntryNums[0];
poEntry->nChildPos = anEntryNums[3];
poEntry->nDataPos = anEntryNums[4];
poEntry->nDataSize = anEntryNums[5];
/* -------------------------------------------------------------------- */
/* Read the name, and type. */
/* -------------------------------------------------------------------- */
if( VSIFReadL( poEntry->szName, 1, 64, poEntry->psHFA->fp ) < 1
|| VSIFReadL( poEntry->szType, 1, 32, poEntry->psHFA->fp ) < 1 )
{
poEntry->szName[sizeof(poEntry->szName)-1] = '\0';
poEntry->szType[sizeof(poEntry->szType)-1] = '\0';
CPLError( CE_Failure, CPLE_FileIO,
"VSIFReadL() failed in HFAEntry()." );
delete poEntry;
return NULL;
}
poEntry->szName[sizeof(poEntry->szName)-1] = '\0';
poEntry->szType[sizeof(poEntry->szType)-1] = '\0';
return poEntry;
}
size_t VSIUnixStdioHandle::Read( void * pBuffer, size_t nSize, size_t nCount )
{
/* -------------------------------------------------------------------- */
/* If a fwrite() is followed by an fread(), the POSIX rules are */
/* that some of the write may still be buffered and lost. We */
/* are required to do a seek between to force flushing. So we */
/* keep careful track of what happened last to know if we */
/* skipped a flushing seek that we may need to do now. */
/* -------------------------------------------------------------------- */
if( bLastOpWrite )
VSI_FSEEK64( fp, nOffset, SEEK_SET );
/* -------------------------------------------------------------------- */
/* Perform the read. */
/* -------------------------------------------------------------------- */
size_t nResult = fread( pBuffer, nSize, nCount, fp );
int nError = errno;
VSIDebug4( "VSIUnixStdioHandle::Read(%p,%ld,%ld) = %ld",
fp, (long)nSize, (long)nCount, (long)nResult );
errno = nError;
/* -------------------------------------------------------------------- */
/* Update current offset. */
/* -------------------------------------------------------------------- */
#ifdef VSI_COUNT_BYTES_READ
nTotalBytesRead += nSize * nResult;
#endif
nOffset += nSize * nResult;
bLastOpWrite = FALSE;
bLastOpRead = TRUE;
if (nResult != nCount)
{
errno = 0;
vsi_l_offset nNewOffset = VSI_FTELL64( fp );
if( errno == 0 ) /* ftell() can fail if we are end of file with a pipe */
nOffset = nNewOffset;
else
CPLDebug("VSI", "%s", VSIStrerror(errno));
bAtEOF = feof(fp);
}
return nResult;
}
static toff_t
_tiffSeekProc(thandle_t th, toff_t off, int whence)
{
GDALTiffHandle* psGTH = (GDALTiffHandle*) th;
/* Optimization: if we are already at end, then no need to */
/* issue a VSIFSeekL() */
if( whence == SEEK_END )
{
if( psGTH->bAtEndOfFile )
{
return (toff_t) psGTH->nExpectedPos;
}
if( VSIFSeekL( psGTH->fpL, off, whence ) != 0 )
{
TIFFErrorExt( th, "_tiffSeekProc", "%s", VSIStrerror( errno ) );
return (toff_t) -1;
}
psGTH->bAtEndOfFile = TRUE;
psGTH->nExpectedPos = VSIFTellL( psGTH->fpL );
return (toff_t) (psGTH->nExpectedPos);
}
GTHFlushBuffer(th);
psGTH->bAtEndOfFile = FALSE;
psGTH->nExpectedPos = 0;
if( VSIFSeekL( psGTH->fpL, off, whence ) == 0 )
return (toff_t) VSIFTellL( psGTH->fpL );
else
{
TIFFErrorExt( th, "_tiffSeekProc", "%s", VSIStrerror( errno ) );
return (toff_t) -1;
}
}
/*
* Open a TIFF file for read/writing.
*/
TIFF*
TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
int i, a_out;
char szAccess[32];
VSILFILE *fp;
TIFF *tif;
char *pszAccess = szAccess;
a_out = 0;
pszAccess[0] = '\0';
for( i = 0; mode[i] != '\0'; i++ )
{
if( mode[i] == 'r'
|| mode[i] == 'w'
|| mode[i] == '+'
|| mode[i] == 'a' )
{
szAccess[a_out++] = mode[i];
szAccess[a_out] = '\0';
}
}
strcat( szAccess, "b" );
fp = VSIFOpenL( name, szAccess );
if (fp == NULL) {
if( errno >= 0 )
TIFFError(module,"%s: %s", name, VSIStrerror( errno ) );
else
TIFFError(module, "%s: Cannot open", name);
return ((TIFF *)0);
}
tif = TIFFClientOpen(name, mode,
(thandle_t) fp,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffMapProc, _tiffUnmapProc);
if( tif != NULL )
tif->tif_fd = 0;
else
CPL_IGNORE_RET_VAL_INT(VSIFCloseL( fp ));
return tif;
}
static int GTHFlushBuffer(thandle_t th)
{
GDALTiffHandle* psGTH = (GDALTiffHandle*) th;
int bRet = TRUE;
if( psGTH->abyWriteBuffer && psGTH->nWriteBufferSize )
{
tsize_t nRet = VSIFWriteL( psGTH->abyWriteBuffer, 1, psGTH->nWriteBufferSize, psGTH->fpL );
bRet = (nRet == psGTH->nWriteBufferSize);
if( !bRet )
{
TIFFErrorExt( th, "_tiffWriteProc", "%s", VSIStrerror( errno ) );
}
psGTH->nWriteBufferSize = 0;
}
return bRet;
}
/*
* Open a TIFF file for read/writing.
*/
TIFF* VSI_TIFFOpen(const char* name, const char* mode)
{
static const char module[] = "TIFFOpen";
int i, a_out;
char access[32];
VSILFILE *fp;
TIFF *tif;
a_out = 0;
access[0] = '\0';
for( i = 0; mode[i] != '\0'; i++ )
{
if( mode[i] == 'r'
|| mode[i] == 'w'
|| mode[i] == '+'
|| mode[i] == 'a' )
{
access[a_out++] = mode[i];
access[a_out] = '\0';
}
}
strcat( access, "b" );
fp = VSIFOpenL( name, access );
if (fp == NULL) {
if( errno >= 0 )
TIFFError(module,"%s: %s", name, VSIStrerror( errno ) );
else
TIFFError(module, "%s: Cannot open", name);
return ((TIFF *)0);
}
tif = XTIFFClientOpen(name, mode,
(thandle_t) fp,
_tiffReadProc, _tiffWriteProc,
_tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
_tiffMapProc, _tiffUnmapProc);
if( tif == NULL )
VSIFCloseL( fp );
return tif;
}
/* which would be an undesired effect... */
CPLErr VRTDataset::Delete( const char * pszFilename )
{
GDALDriverH hDriver = GDALIdentifyDriver(pszFilename, NULL);
if (hDriver && EQUAL(GDALGetDriverShortName(hDriver), "VRT"))
{
if( VSIUnlink( pszFilename ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Deleting %s failed:\n%s",
pszFilename,
VSIStrerror(errno) );
return CE_Failure;
}
return CE_None;
}
else
return CE_Failure;
}
OGRDataSource *OGRCSVDriver::CreateDataSource( const char * pszName,
char ** /* papszOptions */ )
{
/* -------------------------------------------------------------------- */
/* First, ensure there isn't any such file yet. */
/* -------------------------------------------------------------------- */
VSIStatBuf sStatBuf;
if( VSIStat( pszName, &sStatBuf ) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"It seems a file system object called '%s' already exists.",
pszName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a directory. */
/* -------------------------------------------------------------------- */
if( VSIMkdir( pszName, 0755 ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to create directory %s:\n%s",
pszName, VSIStrerror( errno ) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Force it to open as a datasource. */
/* -------------------------------------------------------------------- */
OGRCSVDataSource *poDS = new OGRCSVDataSource();
if( !poDS->Open( pszName, TRUE, TRUE ) )
{
delete poDS;
return NULL;
}
return poDS;
}
int OGRCSVDataSource::OpenTable( const char * pszFilename,
char** papszOpenOptions,
const char* pszNfdcRunwaysGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
VSILFILE * fp;
if( bUpdate )
fp = VSIFOpenL( pszFilename, "rb+" );
else
fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL )
{
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, %s.",
pszFilename, VSIStrerror( errno ) );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL &&
strstr(pszFilename, "/vsizip/") == NULL )
fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
CPLString osLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( strncmp(pszFilename, "/vsigzip/", 9) == 0 && EQUAL(osExt, "gz") )
{
if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".csv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "csv";
}
else if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".tsv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "tsv";
}
}
/* -------------------------------------------------------------------- */
/* Read and parse a line. Did we get multiple fields? */
/* -------------------------------------------------------------------- */
const char* pszLine = CPLReadLineL( fp );
if (pszLine == NULL)
{
VSIFCloseL( fp );
return FALSE;
}
char chDelimiter = CSVDetectSeperator(pszLine);
if( chDelimiter != '\t' && strchr(pszLine, '\t') != NULL )
{
/* Force the delimiter to be TAB for a .tsv file that has a tabulation */
/* in its first line */
if( EQUAL(osExt, "tsv") )
{
chDelimiter = '\t';
}
else
{
for(int bDontHonourStrings=0; bDontHonourStrings<=1; bDontHonourStrings++)
{
// Read the first 2 lines to see if they have the same number of fields, if using tabulation
VSIRewindL( fp );
char** papszTokens = OGRCSVReadParseLineL( fp, '\t', bDontHonourStrings );
int nTokens1 = CSLCount(papszTokens);
CSLDestroy(papszTokens);
papszTokens = OGRCSVReadParseLineL( fp, '\t', bDontHonourStrings );
int nTokens2 = CSLCount(papszTokens);
CSLDestroy(papszTokens);
if( nTokens1 >= 2 && nTokens1 == nTokens2 )
{
chDelimiter = '\t';
break;
}
}
}
}
VSIRewindL( fp );
#if 0
const char *pszDelimiter = CSLFetchNameValueDef( papszOpenOptions, "SEPARATOR", "AUTO");
if( !EQUAL(pszDelimiter, "AUTO") )
{
if (EQUAL(pszDelimiter, "COMMA"))
chDelimiter = ',';
else if (EQUAL(pszDelimiter, "SEMICOLON"))
chDelimiter = ';';
else if (EQUAL(pszDelimiter, "TAB"))
chDelimiter = '\t';
else if (EQUAL(pszDelimiter, "SPACE"))
chDelimiter = ' ';
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"SEPARATOR=%s not understood, use one of COMMA, SEMICOLON, SPACE or TAB.",
pszDelimiter );
}
}
#endif
/* GNIS specific */
if (pszGeonamesGeomFieldPrefix != NULL &&
strchr(pszLine, '|') != NULL)
chDelimiter = '|';
char **papszFields = OGRCSVReadParseLineL( fp, chDelimiter, FALSE );
if( CSLCount(papszFields) < 2 )
{
VSIFCloseL( fp );
CSLDestroy( papszFields );
return FALSE;
}
VSIRewindL( fp );
CSLDestroy( papszFields );
/* -------------------------------------------------------------------- */
/* Create a layer. */
/* -------------------------------------------------------------------- */
nLayers++;
papoLayers = (OGRCSVLayer **) CPLRealloc(papoLayers,
sizeof(void*) * nLayers);
if (pszNfdcRunwaysGeomField != NULL)
{
osLayerName += "_";
osLayerName += pszNfdcRunwaysGeomField;
}
else if (pszGeonamesGeomFieldPrefix != NULL &&
!EQUAL(pszGeonamesGeomFieldPrefix, ""))
{
osLayerName += "_";
osLayerName += pszGeonamesGeomFieldPrefix;
}
if (EQUAL(pszFilename, "/vsistdin/"))
osLayerName = "layer";
papoLayers[nLayers-1] =
new OGRCSVLayer( osLayerName, fp, pszFilename, FALSE, bUpdate,
chDelimiter );
papoLayers[nLayers-1]->BuildFeatureDefn( pszNfdcRunwaysGeomField,
pszGeonamesGeomFieldPrefix,
papszOpenOptions );
return TRUE;
}
OGRErr OGRShapeLayer::Repack()
{
if( !bUpdateAccess )
{
CPLError( CE_Failure, CPLE_AppDefined,
"The REPACK operation is not permitted on a read-only shapefile." );
return OGRERR_FAILURE;
}
if( hDBF == NULL )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Attempt to repack a shapefile with no .dbf file not supported.");
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Build a list of records to be dropped. */
/* -------------------------------------------------------------------- */
int *panRecordsToDelete = (int *)
CPLMalloc(sizeof(int)*(nTotalShapeCount+1));
int nDeleteCount = 0;
int iShape = 0;
OGRErr eErr = OGRERR_NONE;
for( iShape = 0; iShape < nTotalShapeCount; iShape++ )
{
if( DBFIsRecordDeleted( hDBF, iShape ) )
panRecordsToDelete[nDeleteCount++] = iShape;
}
panRecordsToDelete[nDeleteCount] = -1;
/* -------------------------------------------------------------------- */
/* If there are no records marked for deletion, we take no */
/* action. */
/* -------------------------------------------------------------------- */
if( nDeleteCount == 0 )
{
CPLFree( panRecordsToDelete );
return OGRERR_NONE;
}
/* -------------------------------------------------------------------- */
/* Find existing filenames with exact case (see #3293). */
/* -------------------------------------------------------------------- */
CPLString osDirname(CPLGetPath(pszFullName));
CPLString osBasename(CPLGetBasename(pszFullName));
CPLString osDBFName, osSHPName, osSHXName;
char **papszCandidates = CPLReadDir( osDirname );
int i = 0;
while(papszCandidates != NULL && papszCandidates[i] != NULL)
{
CPLString osCandidateBasename = CPLGetBasename(papszCandidates[i]);
CPLString osCandidateExtension = CPLGetExtension(papszCandidates[i]);
if (osCandidateBasename.compare(osBasename) == 0)
{
if (EQUAL(osCandidateExtension, "dbf"))
osDBFName = CPLFormFilename(osDirname, papszCandidates[i], NULL);
else if (EQUAL(osCandidateExtension, "shp"))
osSHPName = CPLFormFilename(osDirname, papszCandidates[i], NULL);
else if (EQUAL(osCandidateExtension, "shx"))
osSHXName = CPLFormFilename(osDirname, papszCandidates[i], NULL);
}
i++;
}
CSLDestroy(papszCandidates);
papszCandidates = NULL;
if (osDBFName.size() == 0)
{
/* Should not happen, really */
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Cleanup any existing spatial index. It will become */
/* meaningless when the fids change. */
/* -------------------------------------------------------------------- */
if( CheckForQIX() )
DropSpatialIndex();
/* -------------------------------------------------------------------- */
/* Create a new dbf file, matching the old. */
/* -------------------------------------------------------------------- */
DBFHandle hNewDBF = NULL;
CPLString oTempFile(CPLFormFilename(osDirname, osBasename, NULL));
oTempFile += "_packed.dbf";
hNewDBF = DBFCloneEmpty( hDBF, oTempFile );
if( hNewDBF == NULL )
{
CPLFree( panRecordsToDelete );
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create temp file %s.",
oTempFile.c_str() );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Copy over all records that are not deleted. */
/* -------------------------------------------------------------------- */
int iDestShape = 0;
int iNextDeletedShape = 0;
for( iShape = 0;
iShape < nTotalShapeCount && eErr == OGRERR_NONE;
iShape++ )
{
if( panRecordsToDelete[iNextDeletedShape] == iShape )
iNextDeletedShape++;
else
{
void *pTuple = (void *) DBFReadTuple( hDBF, iShape );
if( pTuple == NULL )
eErr = OGRERR_FAILURE;
else if( !DBFWriteTuple( hNewDBF, iDestShape++, pTuple ) )
eErr = OGRERR_FAILURE;
}
}
if( eErr != OGRERR_NONE )
{
CPLFree( panRecordsToDelete );
VSIUnlink( oTempFile );
return eErr;
}
/* -------------------------------------------------------------------- */
/* Cleanup the old .dbf and rename the new one. */
/* -------------------------------------------------------------------- */
DBFClose( hDBF );
DBFClose( hNewDBF );
hDBF = hNewDBF = NULL;
VSIUnlink( osDBFName );
if( VSIRename( oTempFile, osDBFName ) != 0 )
{
CPLDebug( "Shape", "Can not rename DBF file: %s", VSIStrerror( errno ) );
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Now create a shapefile matching the old one. */
/* -------------------------------------------------------------------- */
if( hSHP != NULL )
{
SHPHandle hNewSHP = NULL;
if (osSHPName.size() == 0 || osSHXName.size() == 0)
{
/* Should not happen, really */
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
oTempFile = CPLFormFilename(osDirname, osBasename, NULL);
oTempFile += "_packed.shp";
hNewSHP = SHPCreate( oTempFile, hSHP->nShapeType );
if( hNewSHP == NULL )
{
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Copy over all records that are not deleted. */
/* -------------------------------------------------------------------- */
iNextDeletedShape = 0;
for( iShape = 0;
iShape < nTotalShapeCount && eErr == OGRERR_NONE;
iShape++ )
{
if( panRecordsToDelete[iNextDeletedShape] == iShape )
iNextDeletedShape++;
else
{
SHPObject *hObject;
hObject = SHPReadObject( hSHP, iShape );
if( hObject == NULL )
eErr = OGRERR_FAILURE;
else if( SHPWriteObject( hNewSHP, -1, hObject ) == -1 )
eErr = OGRERR_FAILURE;
if( hObject )
SHPDestroyObject( hObject );
}
}
if( eErr != OGRERR_NONE )
{
CPLFree( panRecordsToDelete );
VSIUnlink( CPLResetExtension( oTempFile, "shp" ) );
VSIUnlink( CPLResetExtension( oTempFile, "shx" ) );
return eErr;
}
/* -------------------------------------------------------------------- */
/* Cleanup the old .shp/.shx and rename the new one. */
/* -------------------------------------------------------------------- */
SHPClose( hSHP );
SHPClose( hNewSHP );
hSHP = hNewSHP = NULL;
VSIUnlink( osSHPName );
VSIUnlink( osSHXName );
oTempFile = CPLResetExtension( oTempFile, "shp" );
if( VSIRename( oTempFile, osSHPName ) != 0 )
{
CPLDebug( "Shape", "Can not rename SHP file: %s", VSIStrerror( errno ) );
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
oTempFile = CPLResetExtension( oTempFile, "shx" );
if( VSIRename( oTempFile, osSHXName ) != 0 )
{
CPLDebug( "Shape", "Can not rename SHX file: %s", VSIStrerror( errno ) );
CPLFree( panRecordsToDelete );
return OGRERR_FAILURE;
}
}
CPLFree( panRecordsToDelete );
panRecordsToDelete = NULL;
/* -------------------------------------------------------------------- */
/* Reopen the shapefile */
/* */
/* We do not need to reimplement OGRShapeDataSource::OpenFile() here */
/* with the fully featured error checking. */
/* If all operations above succeeded, then all necessery files are */
/* in the right place and accessible. */
/* -------------------------------------------------------------------- */
CPLAssert( NULL == hSHP );
CPLAssert( NULL == hDBF && NULL == hNewDBF );
CPLPushErrorHandler( CPLQuietErrorHandler );
const char* pszAccess = NULL;
if( bUpdateAccess )
pszAccess = "r+";
else
pszAccess = "r";
hSHP = SHPOpen ( CPLResetExtension( pszFullName, "shp" ) , pszAccess );
hDBF = DBFOpen ( CPLResetExtension( pszFullName, "dbf" ) , pszAccess );
CPLPopErrorHandler();
if( NULL == hSHP || NULL == hDBF )
{
CPLString osMsg(CPLGetLastErrorMsg());
CPLError( CE_Failure, CPLE_OpenFailed, "%s", osMsg.c_str() );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Update total shape count. */
/* -------------------------------------------------------------------- */
nTotalShapeCount = hDBF->nRecords;
return OGRERR_NONE;
}
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 );
}
int OGRSelafinDataSource::OpenTable(const char * pszFilename) {
//CPLDebug("Selafin","OpenTable(%s,%i)",pszFilename,bUpdate);
// Open the file
VSILFILE * fp;
if( bUpdate ) {
// We have to implement this locking feature for write access because the same file may hold several layers, and some programs (like QGIS) open each layer in a single datasource,
// so the same file might be opened several times for write access
if (TakeLock(pszFilename)==0) {
CPLError(CE_Failure,CPLE_OpenFailed,"Failed to open %s for write access, lock file found %s.",pszFilename,pszLockName);
return FALSE;
}
fp = VSIFOpenL( pszFilename, "rb+" );
} else fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL ) {
CPLError( CE_Warning, CPLE_OpenFailed, "Failed to open %s, %s.", pszFilename, VSIStrerror( errno ) );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL && strstr(pszFilename, "/vsizip/") == NULL ) fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
// Quickly check if the file is in Selafin format, before actually starting to read to make it faster
char szBuf[9];
VSIFReadL(szBuf,1,4,fp);
if (szBuf[0]!=0 || szBuf[1]!=0 || szBuf[2]!=0 || szBuf[3]!=0x50) {
VSIFCloseL(fp);
return FALSE;
}
VSIFSeekL(fp,84,SEEK_SET);
VSIFReadL(szBuf,1,8,fp);
if (szBuf[0]!=0 || szBuf[1]!=0 || szBuf[2]!=0 || szBuf[3]!=0x50 || szBuf[4]!=0 || szBuf[5]!=0 || szBuf[6]!=0 || szBuf[7]!=8) {
VSIFCloseL(fp);
return FALSE;
}
/* VSIFSeekL(fp,76,SEEK_SET);
VSIFReadL(szBuf,1,8,fp);
if (STRNCASECMP(szBuf,"Seraphin",8)!=0 && STRNCASECMP(szBuf,"Serafin",7)!=0) {
VSIFCloseL(fp);
return FALSE;
} */
// Get layer base name
CPLString osBaseLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( STARTS_WITH(pszFilename, "/vsigzip/") && EQUAL(osExt, "gz") ) {
size_t nPos=std::string::npos;
if (strlen(pszFilename)>3) nPos=osExt.find_last_of('.',strlen(pszFilename)-4);
if (nPos!=std::string::npos) {
osExt=osExt.substr(nPos+1,strlen(pszFilename)-4-nPos);
osBaseLayerName=osBaseLayerName.substr(0,nPos);
} else {
osExt="";
}
}
// Read header of file to get common information for all layers
poHeader=Selafin::read_header(fp,pszFilename);
if (poHeader==NULL) {
VSIFCloseL(fp);
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open %s, wrong format.\n", pszFilename);
return FALSE;
}
if (poHeader->nEpsg!=0) {
poSpatialRef=new OGRSpatialReference();
if (poSpatialRef->importFromEPSG(poHeader->nEpsg)!=OGRERR_NONE) {
CPLError( CE_Warning, CPLE_AppDefined, "EPSG %d not found. Could not set datasource SRS.\n", poHeader->nEpsg);
delete poSpatialRef;
poSpatialRef=NULL;
}
}
// Create two layers for each selected time step: one for points, the other for elements
int nNewLayers;
poRange.setMaxValue(poHeader->nSteps);
nNewLayers=static_cast<int>(poRange.getSize());
if (EQUAL(pszFilename, "/vsistdin/")) osBaseLayerName = "layer";
CPLString osLayerName;
papoLayers = (OGRSelafinLayer **) CPLRealloc(papoLayers, sizeof(void*) * (nLayers+nNewLayers));
for (size_t j=0;j<2;++j) {
SelafinTypeDef eType=(j==0)?POINTS:ELEMENTS;
for (int i=0;i<poHeader->nSteps;++i) {
if (poRange.contains(eType,i)) {
char szTemp[30];
double dfTime;
if (VSIFSeekL(fp,poHeader->getPosition(i)+4,SEEK_SET)!=0 || Selafin::read_float(fp,dfTime)==0) {
VSIFCloseL(fp);
CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open %s, wrong format.\n", pszFilename);
return FALSE;
}
if (poHeader->panStartDate==NULL) snprintf(szTemp,29,"%d",i); else {
struct tm sDate;
memset(&sDate, 0, sizeof(sDate));
sDate.tm_year=poHeader->panStartDate[0]-1900;
sDate.tm_mon=poHeader->panStartDate[1]-1;
sDate.tm_mday=poHeader->panStartDate[2];
sDate.tm_hour=poHeader->panStartDate[3];
sDate.tm_min=poHeader->panStartDate[4];
sDate.tm_sec=poHeader->panStartDate[5]+(int)dfTime;
mktime(&sDate);
strftime(szTemp,29,"%Y_%m_%d_%H_%M_%S",&sDate);
}
if (eType==POINTS) osLayerName=osBaseLayerName+"_p"+szTemp; else osLayerName=osBaseLayerName+"_e"+szTemp;
papoLayers[nLayers++] = new OGRSelafinLayer( osLayerName, bUpdate, poSpatialRef, poHeader,i,eType);
//poHeader->nRefCount++;
}
}
}
// Free allocated variables and exit
return TRUE;
}
int OGRCSVDataSource::OpenTable( const char * pszFilename,
const char* pszNfdcRunwaysGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
VSILFILE * fp;
if( bUpdate )
fp = VSIFOpenL( pszFilename, "rb+" );
else
fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL )
{
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, %s.",
pszFilename, VSIStrerror( errno ) );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL &&
strstr(pszFilename, "/vsizip/") == NULL )
fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
CPLString osLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( strncmp(pszFilename, "/vsigzip/", 9) == 0 && EQUAL(osExt, "gz") )
{
if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".csv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "csv";
}
else if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".tsv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "tsv";
}
}
/* -------------------------------------------------------------------- */
/* Read and parse a line. Did we get multiple fields? */
/* -------------------------------------------------------------------- */
const char* pszLine = CPLReadLineL( fp );
if (pszLine == NULL)
{
VSIFCloseL( fp );
return FALSE;
}
char chDelimiter = CSVDetectSeperator(pszLine);
/* Force the delimiter to be TAB for a .tsv file that has a tabulation */
/* in its first line */
if( EQUAL(osExt, "tsv") && chDelimiter != '\t' &&
strchr(pszLine, '\t') != NULL )
{
chDelimiter = '\t';
}
VSIRewindL( fp );
/* GNIS specific */
if (pszGeonamesGeomFieldPrefix != NULL &&
strchr(pszLine, '|') != NULL)
chDelimiter = '|';
char **papszFields = OGRCSVReadParseLineL( fp, chDelimiter, FALSE );
if( CSLCount(papszFields) < 2 )
{
VSIFCloseL( fp );
CSLDestroy( papszFields );
return FALSE;
}
VSIRewindL( fp );
CSLDestroy( papszFields );
/* -------------------------------------------------------------------- */
/* Create a layer. */
/* -------------------------------------------------------------------- */
nLayers++;
papoLayers = (OGRCSVLayer **) CPLRealloc(papoLayers,
sizeof(void*) * nLayers);
if (pszNfdcRunwaysGeomField != NULL)
{
osLayerName += "_";
osLayerName += pszNfdcRunwaysGeomField;
}
else if (pszGeonamesGeomFieldPrefix != NULL &&
!EQUAL(pszGeonamesGeomFieldPrefix, ""))
{
osLayerName += "_";
osLayerName += pszGeonamesGeomFieldPrefix;
}
if (EQUAL(pszFilename, "/vsistdin/"))
osLayerName = "layer";
papoLayers[nLayers-1] =
new OGRCSVLayer( osLayerName, fp, pszFilename, FALSE, bUpdate,
chDelimiter, pszNfdcRunwaysGeomField, pszGeonamesGeomFieldPrefix );
return TRUE;
}
OGRErr OGRCSVLayer::WriteHeader()
{
if( !bNew )
return OGRERR_NONE;
/* -------------------------------------------------------------------- */
/* Write field names if we haven't written them yet. */
/* Write .csvt file if needed */
/* -------------------------------------------------------------------- */
bNew = FALSE;
bHasFieldNames = TRUE;
for(int iFile=0;iFile<((bCreateCSVT) ? 2 : 1);iFile++)
{
VSILFILE* fpCSVT = NULL;
if (bCreateCSVT && iFile == 0)
{
char* pszDirName = CPLStrdup(CPLGetDirname(pszFilename));
char* pszBaseName = CPLStrdup(CPLGetBasename(pszFilename));
fpCSVT = VSIFOpenL(CPLFormFilename(pszDirName, pszBaseName, ".csvt"), "wb");
CPLFree(pszDirName);
CPLFree(pszBaseName);
}
else
{
if( strncmp(pszFilename, "/vsistdout/", 11) == 0 ||
strncmp(pszFilename, "/vsizip/", 8) == 0 )
fpCSV = VSIFOpenL( pszFilename, "wb" );
else
fpCSV = VSIFOpenL( pszFilename, "w+b" );
if( fpCSV == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create %s:\n%s",
pszFilename, VSIStrerror( errno ) );
return OGRERR_FAILURE;
}
}
if (bWriteBOM && fpCSV)
{
VSIFWriteL("\xEF\xBB\xBF", 1, 3, fpCSV);
}
if (eGeometryFormat == OGR_CSV_GEOM_AS_WKT)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%s", "WKT");
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "String");
if (poFeatureDefn->GetFieldCount() > 0)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XYZ)
{
if (fpCSV) VSIFPrintfL( fpCSV, "X%cY%cZ", chDelimiter, chDelimiter);
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real,Real");
if (poFeatureDefn->GetFieldCount() > 0)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_XY)
{
if (fpCSV) VSIFPrintfL( fpCSV, "X%cY", chDelimiter);
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real");
if (poFeatureDefn->GetFieldCount() > 0)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
}
else if (eGeometryFormat == OGR_CSV_GEOM_AS_YX)
{
if (fpCSV) VSIFPrintfL( fpCSV, "Y%cX", chDelimiter);
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", "Real,Real");
if (poFeatureDefn->GetFieldCount() > 0)
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
}
for( int iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ )
{
char *pszEscaped;
if( iField > 0 )
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
if (fpCSVT) VSIFPrintfL( fpCSVT, "%s", ",");
}
pszEscaped =
CPLEscapeString( poFeatureDefn->GetFieldDefn(iField)->GetNameRef(),
-1, CPLES_CSV );
if (fpCSV) VSIFPrintfL( fpCSV, "%s", pszEscaped );
CPLFree( pszEscaped );
if (fpCSVT)
{
switch( poFeatureDefn->GetFieldDefn(iField)->GetType() )
{
case OFTInteger: VSIFPrintfL( fpCSVT, "%s", "Integer"); break;
case OFTReal: VSIFPrintfL( fpCSVT, "%s", "Real"); break;
case OFTDate: VSIFPrintfL( fpCSVT, "%s", "Date"); break;
case OFTTime: VSIFPrintfL( fpCSVT, "%s", "Time"); break;
case OFTDateTime: VSIFPrintfL( fpCSVT, "%s", "DateTime"); break;
default: VSIFPrintfL( fpCSVT, "%s", "String"); break;
}
int nWidth = poFeatureDefn->GetFieldDefn(iField)->GetWidth();
int nPrecision = poFeatureDefn->GetFieldDefn(iField)->GetPrecision();
if (nWidth != 0)
{
if (nPrecision != 0)
VSIFPrintfL( fpCSVT, "(%d.%d)", nWidth, nPrecision);
else
VSIFPrintfL( fpCSVT, "(%d)", nWidth);
}
}
}
/* The CSV driver will not recognize single column tables, so add */
/* a fake second blank field */
if( poFeatureDefn->GetFieldCount() == 1 )
{
if (fpCSV) VSIFPrintfL( fpCSV, "%c", chDelimiter );
}
if( bUseCRLF )
{
if (fpCSV) VSIFPutcL( 13, fpCSV );
if (fpCSVT) VSIFPutcL( 13, fpCSVT );
}
if (fpCSV) VSIFPutcL( '\n', fpCSV );
if (fpCSVT) VSIFPutcL( '\n', fpCSVT );
if (fpCSVT) VSIFCloseL(fpCSVT);
}
if (fpCSV == NULL)
return OGRERR_FAILURE;
else
return OGRERR_NONE;
}
int OGRGeneralCmdLineProcessor( int nArgc, char ***ppapszArgv, int nOptions )
{
char **papszReturn = NULL;
int iArg;
char **papszArgv = *ppapszArgv;
(void) nOptions;
/* -------------------------------------------------------------------- */
/* Preserve the program name. */
/* -------------------------------------------------------------------- */
papszReturn = CSLAddString( papszReturn, papszArgv[0] );
/* ==================================================================== */
/* Loop over all arguments. */
/* ==================================================================== */
for( iArg = 1; iArg < nArgc; iArg++ )
{
/* -------------------------------------------------------------------- */
/* --version */
/* -------------------------------------------------------------------- */
if( EQUAL(papszArgv[iArg],"--version") )
{
printf( "%s\n", GDALVersionInfo( "--version" ) );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* --license */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--license") )
{
printf( "%s\n", GDALVersionInfo( "LICENSE" ) );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* --config */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--config") )
{
if( iArg + 2 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--config option given without a key and value argument." );
CSLDestroy( papszReturn );
return -1;
}
CPLSetConfigOption( papszArgv[iArg+1], papszArgv[iArg+2] );
iArg += 2;
}
/* -------------------------------------------------------------------- */
/* --mempreload */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--mempreload") )
{
int i;
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--mempreload option given without directory path.");
CSLDestroy( papszReturn );
return -1;
}
char **papszFiles = CPLReadDir( papszArgv[iArg+1] );
if( CSLCount(papszFiles) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--mempreload given invalid or empty directory.");
CSLDestroy( papszReturn );
return -1;
}
for( i = 0; papszFiles[i] != NULL; i++ )
{
CPLString osOldPath, osNewPath;
if( EQUAL(papszFiles[i],".") || EQUAL(papszFiles[i],"..") )
continue;
osOldPath = CPLFormFilename( papszArgv[iArg+1],
papszFiles[i], NULL );
osNewPath.Printf( "/vsimem/%s", papszFiles[i] );
CPLDebug( "VSI", "Preloading %s to %s.",
osOldPath.c_str(), osNewPath.c_str() );
if( CPLCopyFile( osNewPath, osOldPath ) != 0 )
return -1;
}
CSLDestroy( papszFiles );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --debug */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--debug") )
{
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--debug option given without debug level." );
CSLDestroy( papszReturn );
return -1;
}
CPLSetConfigOption( "CPL_DEBUG", papszArgv[iArg+1] );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --optfile */
/* */
/* Annoyingly the options inserted by --optfile will *not* be */
/* processed properly if they are general options. */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--optfile") )
{
const char *pszLine;
FILE *fpOptFile;
if( iArg + 1 >= nArgc )
{
CPLError( CE_Failure, CPLE_AppDefined,
"--optfile option given without filename." );
CSLDestroy( papszReturn );
return -1;
}
fpOptFile = VSIFOpen( papszArgv[iArg+1], "rb" );
if( fpOptFile == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to open optfile '%s'.\n%s",
papszArgv[iArg+1], VSIStrerror( errno ) );
CSLDestroy( papszReturn );
return -1;
}
while( (pszLine = CPLReadLine( fpOptFile )) != NULL )
{
char **papszTokens;
int i;
if( pszLine[0] == '#' || strlen(pszLine) == 0 )
continue;
papszTokens = CSLTokenizeString( pszLine );
for( i = 0; papszTokens != NULL && papszTokens[i] != NULL; i++)
papszReturn = CSLAddString( papszReturn, papszTokens[i] );
CSLDestroy( papszTokens );
}
VSIFClose( fpOptFile );
iArg += 1;
}
/* -------------------------------------------------------------------- */
/* --formats */
/* -------------------------------------------------------------------- */
#ifdef OGR_ENABLED
else if( EQUAL(papszArgv[iArg], "--formats") )
{
int iDr;
printf( "Supported Formats:\n" );
OGRSFDriverRegistrar *poR = OGRSFDriverRegistrar::GetRegistrar();
for( iDr = 0; iDr < poR->GetDriverCount(); iDr++ )
{
OGRSFDriver *poDriver = poR->GetDriver(iDr);
if( poDriver->TestCapability( ODrCCreateDataSource ) )
printf( " -> \"%s\" (read/write)\n",
poDriver->GetName() );
else
printf( " -> \"%s\" (readonly)\n",
poDriver->GetName() );
}
CSLDestroy( papszReturn );
return 0;
}
#endif /* OGR_ENABLED */
/* -------------------------------------------------------------------- */
/* --locale */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--locale") && iArg < nArgc-1 )
{
setlocale( LC_ALL, papszArgv[++iArg] );
}
/* -------------------------------------------------------------------- */
/* --pause - "hit enter" pause useful to connect a debugger. */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--pause") )
{
char szLine[81];
printf( "Hit <ENTER> to continue.\n" );
fgets( szLine, sizeof(szLine), stdin );
}
/* -------------------------------------------------------------------- */
/* --help-general */
/* -------------------------------------------------------------------- */
else if( EQUAL(papszArgv[iArg],"--help-general") )
{
printf( "Generic GDAL/OGR utility command options:\n" );
printf( " --version: report version of GDAL/OGR in use.\n" );
printf( " --license: report GDAL/OGR license info.\n" );
#ifdef OGR_ENABLED
printf( " --formats: report all configured format drivers.\n" );
#endif /* OGR_ENABLED */
printf( " --optfile filename: expand an option file into the argument list.\n" );
printf( " --config key value: set system configuration option.\n" );
printf( " --debug [on/off/value]: set debug level.\n" );
printf( " --help-general: report detailed help on general options.\n" );
CSLDestroy( papszReturn );
return 0;
}
/* -------------------------------------------------------------------- */
/* carry through unrecognised options. */
/* -------------------------------------------------------------------- */
else
{
papszReturn = CSLAddString( papszReturn, papszArgv[iArg] );
}
}
*ppapszArgv = papszReturn;
return CSLCount( *ppapszArgv );
}
void GDALPamProxyDB::SaveDB()
{
/* -------------------------------------------------------------------- */
/* Open the database relating original names to proxy .aux.xml */
/* file names. */
/* -------------------------------------------------------------------- */
CPLString osDBName =
CPLFormFilename( osProxyDBDir, "gdal_pam_proxy", "dat" );
void *hLock = CPLLockFile( osDBName, 1.0 );
// proceed even if lock fails - we need CPLBreakLockFile()!
if( hLock == NULL )
{
CPLError( CE_Warning, CPLE_AppDefined,
"GDALPamProxyDB::SaveDB() - Failed to lock %s file, proceeding anyways.",
osDBName.c_str() );
}
FILE *fpDB = VSIFOpenL( osDBName, "w" );
if( fpDB == NULL )
{
if( hLock )
CPLUnlockFile( hLock );
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to save %s Pam Proxy DB.\n%s",
osDBName.c_str(),
VSIStrerror( errno ) );
return;
}
/* -------------------------------------------------------------------- */
/* Write header. */
/* -------------------------------------------------------------------- */
GByte abyHeader[100];
memset( abyHeader, ' ', sizeof(abyHeader) );
strncpy( (char *) abyHeader, "GDAL_PROXY", 10 );
sprintf( (char *) abyHeader + 10, "%9d", nUpdateCounter );
VSIFWriteL( abyHeader, 1, 100, fpDB );
/* -------------------------------------------------------------------- */
/* Write names. */
/* -------------------------------------------------------------------- */
unsigned int i;
for( i = 0; i < aosOriginalFiles.size(); i++ )
{
size_t nBytesWritten;
const char *pszProxyFile;
VSIFWriteL( aosOriginalFiles[i].c_str(), 1,
strlen(aosOriginalFiles[i].c_str())+1, fpDB );
pszProxyFile = CPLGetFilename(aosProxyFiles[i]);
nBytesWritten = VSIFWriteL( pszProxyFile, 1,
strlen(pszProxyFile)+1, fpDB );
if( nBytesWritten != strlen(pszProxyFile)+1 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Failed to write complete %s Pam Proxy DB.\n%s",
osDBName.c_str(),
VSIStrerror( errno ) );
VSIFCloseL( fpDB );
VSIUnlink( osDBName );
return;
}
}
VSIFCloseL( fpDB );
if( hLock )
CPLUnlockFile( hLock );
}
CPLErr LevellerRasterBand::IReadBlock( int nBlockXOff, int nBlockYOff,
void* pImage )
{
CPLAssert( sizeof(float) == sizeof(GInt32) );
CPLAssert( nBlockXOff == 0 );
CPLAssert( pImage != NULL );
LevellerDataset *poGDS = (LevellerDataset *) poDS;
/* -------------------------------------------------------------------- */
/* Seek to scanline. */
/* -------------------------------------------------------------------- */
const size_t rowbytes = nBlockXSize * sizeof(float);
if(0 != VSIFSeekL(
poGDS->m_fp,
poGDS->m_nDataOffset + nBlockYOff * rowbytes,
SEEK_SET))
{
CPLError( CE_Failure, CPLE_FileIO,
".bt Seek failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Read the scanline into the image buffer. */
/* -------------------------------------------------------------------- */
if( VSIFReadL( pImage, rowbytes, 1, poGDS->m_fp ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Leveller read failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Swap on MSB platforms. */
/* -------------------------------------------------------------------- */
#ifdef CPL_MSB
GDALSwapWords( pImage, 4, nRasterXSize, 4 );
#endif
/* -------------------------------------------------------------------- */
/* Convert from legacy-format fixed-point if necessary. */
/* -------------------------------------------------------------------- */
float* pf = (float*)pImage;
if(poGDS->m_version < 6)
{
GInt32* pi = (int*)pImage;
for(size_t i = 0; i < (size_t)nBlockXSize; i++)
pf[i] = (float)pi[i] / 65536;
}
#if 0
/* -------------------------------------------------------------------- */
/* Convert raw elevations to realworld elevs. */
/* -------------------------------------------------------------------- */
for(size_t i = 0; i < nBlockXSize; i++)
pf[i] *= poGDS->m_dWorldscale; //this->GetScale();
#endif
return CE_None;
}
OGRLayer *
OGRGmtDataSource::CreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
/* -------------------------------------------------------------------- */
/* Establish the geometry type. Note this logic */
/* -------------------------------------------------------------------- */
const char *pszGeom;
switch( wkbFlatten(eType) )
{
case wkbPoint:
pszGeom = " @GPOINT";
break;
case wkbLineString:
pszGeom = " @GLINESTRING";
break;
case wkbPolygon:
pszGeom = " @GPOLYGON";
break;
case wkbMultiPoint:
pszGeom = " @GMULTIPOINT";
break;
case wkbMultiLineString:
pszGeom = " @GMULTILINESTRING";
break;
case wkbMultiPolygon:
pszGeom = " @GMULTIPOLYGON";
break;
default:
pszGeom = "";
break;
}
/* -------------------------------------------------------------------- */
/* If this is the first layer for this datasource, and if the */
/* datasource name ends in .gmt we will override the provided */
/* layer name with the name from the gmt. */
/* -------------------------------------------------------------------- */
CPLString osPath = CPLGetPath( pszName );
CPLString osFilename;
if( EQUAL(CPLGetExtension(pszName),"gmt") )
osFilename = pszName;
else
osFilename = CPLFormFilename( osPath, pszLayerName, "gmt" );
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
FILE *fp = VSIFOpenL( osFilename, "w" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"open(%s) failed: %s",
osFilename.c_str(), VSIStrerror(errno) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Write out header. */
/* -------------------------------------------------------------------- */
VSIFPrintfL( fp, "# @VGMT1.0%s\n", pszGeom );
VSIFPrintfL( fp, "# REGION_STUB \n" );
/* -------------------------------------------------------------------- */
/* Write the projection, if possible. */
/* -------------------------------------------------------------------- */
if( poSRS != NULL )
{
char *pszValue = NULL;
if( poSRS->IsProjected()
&& poSRS->GetAuthorityName("PROJCS")
&& EQUAL(poSRS->GetAuthorityName("PROJCS"),"EPSG") )
{
VSIFPrintfL( fp, "# @Je%s\n",
poSRS->GetAuthorityCode("PROJCS") );
}
else if( poSRS->IsGeographic()
&& poSRS->GetAuthorityName("GEOGCS")
&& EQUAL(poSRS->GetAuthorityName("GEOGCS"),"EPSG") )
{
VSIFPrintfL( fp, "# @Je%s\n",
poSRS->GetAuthorityCode("GEOGCS") );
}
if( poSRS->exportToProj4( &pszValue ) == OGRERR_NONE )
{
VSIFPrintfL( fp, "# @Jp\"%s\"\n", pszValue );
CPLFree( pszValue );
pszValue = NULL;
}
if( poSRS->exportToWkt( &pszValue ) == OGRERR_NONE )
{
char *pszEscapedWkt = CPLEscapeString( pszValue, -1,
CPLES_BackslashQuotable );
VSIFPrintfL( fp, "# @Jw\"%s\"\n", pszEscapedWkt );
CPLFree( pszValue );
CPLFree( pszEscapedWkt );
pszValue = NULL;
}
}
/* -------------------------------------------------------------------- */
/* Finish header and close. */
/* -------------------------------------------------------------------- */
VSIFCloseL( fp );
/* -------------------------------------------------------------------- */
/* Return open layer handle. */
/* -------------------------------------------------------------------- */
if( Open( osFilename, TRUE ) )
return papoLayers[nLayers-1];
else
return NULL;
}
GDALDataset *
GIFDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
int bInterlace = FALSE;
/* -------------------------------------------------------------------- */
/* Check for interlaced option. */
/* -------------------------------------------------------------------- */
bInterlace = CSLFetchBoolean(papszOptions, "INTERLACING", FALSE);
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if( nBands != 1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver only supports one band images.\n" );
return NULL;
}
if (nXSize > 65535 || nYSize > 65535)
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver only supports datasets up to 65535x65535 size.\n" );
return NULL;
}
if( poSrcDS->GetRasterBand(1)->GetRasterDataType() != GDT_Byte
&& bStrict )
{
CPLError( CE_Failure, CPLE_NotSupported,
"GIF driver doesn't support data type %s. "
"Only eight bit bands supported.\n",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the output file. */
/* -------------------------------------------------------------------- */
GifFileType *hGifFile;
VSILFILE *fp;
fp = VSIFOpenL( pszFilename, "wb" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create %s:\n%s",
pszFilename, VSIStrerror( errno ) );
return NULL;
}
#if defined(GIFLIB_MAJOR) && GIFLIB_MAJOR >= 5
int nError;
hGifFile = EGifOpen( fp, VSIGIFWriteFunc, &nError );
#else
hGifFile = EGifOpen( fp, VSIGIFWriteFunc );
#endif
if( hGifFile == NULL )
{
VSIFCloseL( fp );
CPLError( CE_Failure, CPLE_OpenFailed,
"EGifOpenFilename(%s) failed. Does file already exist?",
pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Prepare colortable. */
/* -------------------------------------------------------------------- */
GDALRasterBand *poBand = poSrcDS->GetRasterBand(1);
ColorMapObject *psGifCT;
int iColor;
if( poBand->GetColorTable() == NULL )
{
psGifCT = GifMakeMapObject( 256, NULL );
for( iColor = 0; iColor < 256; iColor++ )
{
psGifCT->Colors[iColor].Red = (GifByteType) iColor;
psGifCT->Colors[iColor].Green = (GifByteType) iColor;
psGifCT->Colors[iColor].Blue = (GifByteType) iColor;
}
}
else
{
GDALColorTable *poCT = poBand->GetColorTable();
int nFullCount = 1;
while( nFullCount < poCT->GetColorEntryCount() )
nFullCount = nFullCount * 2;
psGifCT = GifMakeMapObject( nFullCount, NULL );
for( iColor = 0; iColor < poCT->GetColorEntryCount(); iColor++ )
{
GDALColorEntry sEntry;
poCT->GetColorEntryAsRGB( iColor, &sEntry );
psGifCT->Colors[iColor].Red = (GifByteType) sEntry.c1;
psGifCT->Colors[iColor].Green = (GifByteType) sEntry.c2;
psGifCT->Colors[iColor].Blue = (GifByteType) sEntry.c3;
}
for( ; iColor < nFullCount; iColor++ )
{
psGifCT->Colors[iColor].Red = 0;
psGifCT->Colors[iColor].Green = 0;
psGifCT->Colors[iColor].Blue = 0;
}
}
/* -------------------------------------------------------------------- */
/* Setup parameters. */
/* -------------------------------------------------------------------- */
if (EGifPutScreenDesc(hGifFile, nXSize, nYSize,
psGifCT->ColorCount, 255, psGifCT) == GIF_ERROR)
{
GifFreeMapObject(psGifCT);
GDALPrintGifError(hGifFile, "Error writing gif file.");
GIFAbstractDataset::myEGifCloseFile(hGifFile);
VSIFCloseL( fp );
return NULL;
}
GifFreeMapObject(psGifCT);
psGifCT = NULL;
/* Support for transparency */
int bNoDataValue;
double noDataValue = poBand->GetNoDataValue(&bNoDataValue);
if (bNoDataValue && noDataValue >= 0 && noDataValue <= 255)
{
unsigned char extensionData[4];
extensionData[0] = 1; /* Transparent Color Flag */
extensionData[1] = 0;
extensionData[2] = 0;
extensionData[3] = (unsigned char)noDataValue;
EGifPutExtension(hGifFile, 0xf9, 4, extensionData);
}
if (EGifPutImageDesc(hGifFile, 0, 0, nXSize, nYSize, bInterlace, NULL) == GIF_ERROR )
{
GDALPrintGifError(hGifFile, "Error writing gif file.");
GIFAbstractDataset::myEGifCloseFile(hGifFile);
VSIFCloseL( fp );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Loop over image, copying image data. */
/* -------------------------------------------------------------------- */
CPLErr eErr;
GDALPamDataset *poDS;
GByte *pabyScanline;
pabyScanline = (GByte *) CPLMalloc( nXSize );
if( !pfnProgress( 0.0, NULL, pProgressData ) )
eErr = CE_Failure;
if( !bInterlace )
{
for( int iLine = 0; iLine < nYSize; iLine++ )
{
eErr = poBand->RasterIO( GF_Read, 0, iLine, nXSize, 1,
pabyScanline, nXSize, 1, GDT_Byte,
nBands, nBands * nXSize );
if( eErr != CE_None || EGifPutLine( hGifFile, pabyScanline, nXSize ) == GIF_ERROR )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error writing gif file." );
goto error;
}
if( !pfnProgress( (iLine + 1) * 1.0 / nYSize, NULL, pProgressData ) )
{
goto error;
}
}
}
else
{
int i, j;
int nLinesRead = 0;
int nLinesToRead = 0;
for ( i = 0; i < 4; i++)
{
for (j = InterlacedOffset[i]; j < nYSize; j += InterlacedJumps[i])
{
nLinesToRead ++;
}
}
/* Need to perform 4 passes on the images: */
for ( i = 0; i < 4; i++)
{
for (j = InterlacedOffset[i]; j < nYSize; j += InterlacedJumps[i])
{
eErr= poBand->RasterIO( GF_Read, 0, j, nXSize, 1,
pabyScanline, nXSize, 1, GDT_Byte,
1, nXSize );
if (eErr != CE_None || EGifPutLine(hGifFile, pabyScanline, nXSize) == GIF_ERROR)
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error writing gif file." );
goto error;
}
nLinesRead ++;
if( !pfnProgress( nLinesRead * 1.0 / nYSize, NULL, pProgressData ) )
{
goto error;
}
}
}
}
CPLFree( pabyScanline );
pabyScanline = NULL;
/* -------------------------------------------------------------------- */
/* cleanup */
/* -------------------------------------------------------------------- */
if (GIFAbstractDataset::myEGifCloseFile(hGifFile) == GIF_ERROR)
{
CPLError( CE_Failure, CPLE_AppDefined,
"EGifCloseFile() failed.\n" );
hGifFile = NULL;
goto error;
}
hGifFile = NULL;
VSIFCloseL( fp );
fp = NULL;
/* -------------------------------------------------------------------- */
/* Do we need a world file? */
/* -------------------------------------------------------------------- */
if( CSLFetchBoolean( papszOptions, "WORLDFILE", FALSE ) )
{
double adfGeoTransform[6];
if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None )
GDALWriteWorldFile( pszFilename, "wld", adfGeoTransform );
}
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxilary pam information. */
/* -------------------------------------------------------------------- */
/* If outputing to stdout, we can't reopen it, so we'll return */
/* a fake dataset to make the caller happy */
CPLPushErrorHandler(CPLQuietErrorHandler);
poDS = (GDALPamDataset*) GDALOpen(pszFilename, GA_ReadOnly);
CPLPopErrorHandler();
if (poDS)
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
else
{
CPLErrorReset();
GIFDataset* poGIF_DS = new GIFDataset();
poGIF_DS->nRasterXSize = nXSize;
poGIF_DS->nRasterYSize = nYSize;
for(int i=0;i<nBands;i++)
poGIF_DS->SetBand( i+1, new GIFRasterBand( poGIF_DS, i+1, NULL, 0 ) );
return poGIF_DS;
}
error:
if (hGifFile)
GIFAbstractDataset::myEGifCloseFile(hGifFile);
if (fp)
VSIFCloseL( fp );
if (pabyScanline)
CPLFree( pabyScanline );
return NULL;
}
CPLErr BTRasterBand::IWriteBlock( int nBlockXOff,
CPL_UNUSED int nBlockYOff,
void * pImage )
{
CPLAssert( nBlockYOff == 0 );
const int nDataSize = GDALGetDataTypeSizeBytes( eDataType );
/* -------------------------------------------------------------------- */
/* Seek to profile. */
/* -------------------------------------------------------------------- */
if( VSIFSeekL( fpImage,
256 + nBlockXOff * nDataSize * nRasterYSize,
SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
".bt Seek failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Allocate working buffer. */
/* -------------------------------------------------------------------- */
GByte *pabyWrkBlock =
static_cast<GByte *>( CPLMalloc(nDataSize * nRasterYSize) );
/* -------------------------------------------------------------------- */
/* Vertical flip data into work buffer, since GDAL expects */
/* values from top to bottom, but in .bt they are bottom to */
/* top. */
/* -------------------------------------------------------------------- */
for( int i = 0; i < nRasterYSize; i++ )
{
memcpy( pabyWrkBlock + (nRasterYSize - i - 1) * nDataSize,
reinterpret_cast<GByte *>(pImage) + i * nDataSize, nDataSize );
}
/* -------------------------------------------------------------------- */
/* Swap on MSB platforms. */
/* -------------------------------------------------------------------- */
#ifdef CPL_MSB
GDALSwapWords( pabyWrkBlock, nDataSize, nRasterYSize, nDataSize );
#endif
/* -------------------------------------------------------------------- */
/* Read the profile. */
/* -------------------------------------------------------------------- */
if( VSIFWriteL( pabyWrkBlock, nDataSize, nRasterYSize, fpImage ) !=
static_cast<size_t>( nRasterYSize ) )
{
CPLFree( pabyWrkBlock );
CPLError( CE_Failure, CPLE_FileIO,
".bt Write failed:%s", VSIStrerror( errno ) );
return CE_Failure;
}
CPLFree( pabyWrkBlock );
return CE_None;
}
