static CPLErr PAuxDelete( const char * pszBasename )
{
VSILFILE *fp = VSIFOpenL( CPLResetExtension( pszBasename, "aux" ), "r" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset, there is no .aux file.",
pszBasename );
return CE_Failure;
}
const char *pszLine = CPLReadLineL( fp );
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
if( pszLine == NULL || !STARTS_WITH_CI(pszLine, "AuxilaryTarget") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a PAux dataset,\n"
"the .aux file does not start with AuxilaryTarget",
pszBasename );
return CE_Failure;
}
if( VSIUnlink( pszBasename ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"OS unlinking file %s.", pszBasename );
return CE_Failure;
}
VSIUnlink( CPLResetExtension( pszBasename, "aux" ) );
return CE_None;
}
OGRErr OGRMILayerAttrIndex::Initialize( const char *pszIndexPathIn,
OGRLayer *poLayerIn )
{
if( poLayerIn == poLayer )
return OGRERR_NONE;
/* -------------------------------------------------------------------- */
/* Capture input information and form static pathnames. */
/* -------------------------------------------------------------------- */
poLayer = poLayerIn;
pszIndexPath = CPLStrdup( pszIndexPathIn );
pszMetadataFilename = CPLStrdup(
CPLResetExtension( pszIndexPathIn, "idm" ) );
pszMIINDFilename = CPLStrdup(CPLResetExtension( pszIndexPathIn, "ind" ));
/* -------------------------------------------------------------------- */
/* If a metadata file already exists, load it. */
/* -------------------------------------------------------------------- */
OGRErr eErr;
VSIStatBuf sStat;
if( VSIStat( pszMetadataFilename, &sStat ) == 0 )
{
eErr = LoadConfigFromXML();
if( eErr != OGRERR_NONE )
return eErr;
}
return OGRERR_NONE;
}
OGRSpatialReference *OGRShapeLayer::GetSpatialRef()
{
if (bSRSSet)
return poSRS;
bSRSSet = TRUE;
/* -------------------------------------------------------------------- */
/* Is there an associated .prj file we can read? */
/* -------------------------------------------------------------------- */
const char *pszPrjFile = CPLResetExtension( pszFullName, "prj" );
char **papszLines;
char* apszOptions[] = { (char*)"EMIT_ERROR_IF_CANNOT_OPEN_FILE=FALSE", NULL };
papszLines = CSLLoad2( pszPrjFile, -1, -1, apszOptions );
if (papszLines == NULL)
{
pszPrjFile = CPLResetExtension( pszFullName, "PRJ" );
papszLines = CSLLoad2( pszPrjFile, -1, -1, apszOptions );
}
if( papszLines != NULL )
{
poSRS = new OGRSpatialReference();
if( poSRS->importFromESRI( papszLines ) != OGRERR_NONE )
{
delete poSRS;
poSRS = NULL;
}
CSLDestroy( papszLines );
}
return poSRS;
}
CPLString GetWorldFilePath(const CPLString &soPath)
{
//1. thirst and last char from ext and third char set w (e.g. jpw)
CPLString sExt = CPLGetExtension(soPath);
CPLString sNewExt;
sNewExt += sExt[0];
sNewExt += sExt[sExt.size() - 1];
sNewExt += 'w';
CPLString szPath = (char*)CPLResetExtension(soPath, sNewExt);
if(CPLCheckForFile((char*)szPath.c_str(), NULL))
return szPath;
//4. add wx to ext
sNewExt += 'x';
szPath = (char*)CPLResetExtension(soPath, sNewExt);
if(CPLCheckForFile((char*)szPath.c_str(), NULL))
return szPath;
//2. wld
szPath = (char*)CPLResetExtension(soPath, "wld");
if(CPLCheckForFile((char*)szPath.c_str(), NULL))
return szPath;
//3. add w to ext
szPath = soPath + CPLString("w");
if(CPLCheckForFile((char*)szPath.c_str(), NULL))
return szPath;
return CPLString();
}
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;
}
if( !bSbnSbxDeleted )
{
const char *pszIndexFilename;
const char papszExt[2][4] = { "sbn", "sbx" };
int i;
for( i = 0; i < 2; i++ )
{
pszIndexFilename = CPLResetExtension( pszFullName, papszExt[i] );
CPLDebug( "SHAPE", "Trying to unlink index file %s", pszIndexFilename );
if( VSIUnlink( pszIndexFilename ) != 0 )
{
CPLDebug( "SHAPE",
"Failed to delete file %s.\n%s",
pszIndexFilename, VSIStrerror( errno ) );
}
}
}
bSbnSbxDeleted = TRUE;
return OGRERR_NONE;
}
OGRErr OGRShapeDataSource::DeleteLayer( int iLayer )
{
char *pszFilename;
/* -------------------------------------------------------------------- */
/* Verify we are in update mode. */
/* -------------------------------------------------------------------- */
if( !bDSUpdate )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Data source %s opened read-only.\n"
"Layer %d cannot be deleted.\n",
pszName, iLayer );
return OGRERR_FAILURE;
}
if( iLayer < 0 || iLayer >= nLayers )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %d not in legal range of 0 to %d.",
iLayer, nLayers-1 );
return OGRERR_FAILURE;
}
OGRShapeLayer* poLayerToDelete = (OGRShapeLayer*) papoLayers[iLayer];
pszFilename = CPLStrdup(poLayerToDelete->GetFullName());
delete poLayerToDelete;
while( iLayer < nLayers - 1 )
{
papoLayers[iLayer] = papoLayers[iLayer+1];
iLayer++;
}
nLayers--;
VSIUnlink( CPLResetExtension(pszFilename, "shp") );
VSIUnlink( CPLResetExtension(pszFilename, "shx") );
VSIUnlink( CPLResetExtension(pszFilename, "dbf") );
VSIUnlink( CPLResetExtension(pszFilename, "prj") );
VSIUnlink( CPLResetExtension(pszFilename, "qix") );
CPLFree( pszFilename );
return OGRERR_NONE;
}
CPLErr GDALDefaultOverviews::CleanOverviews()
{
// Anything to do?
if( poODS == NULL )
return CE_None;
// Delete the overview file(s).
GDALDriver *poOvrDriver = poODS->GetDriver();
GDALClose( poODS );
poODS = NULL;
const CPLErr eErr = poOvrDriver != NULL ?
poOvrDriver->Delete( osOvrFilename ) : CE_None;
// Reset the saved overview filename.
if( !EQUAL(poDS->GetDescription(),":::VIRTUAL:::") )
{
const bool bUseRRD = CPLTestBool(CPLGetConfigOption("USE_RRD","NO"));
if( bUseRRD )
osOvrFilename = CPLResetExtension( poDS->GetDescription(), "aux" );
else
osOvrFilename.Printf( "%s.ovr", poDS->GetDescription() );
}
else
{
osOvrFilename = "";
}
return eErr;
}
OGRErr OGRSXFDriver::DeleteDataSource(const char* pszName)
{
int iExt;
//TODO: add more extensions if aplicable
static const char *apszExtensions[] = { "szf", "rsc", "SZF", "RSC", NULL };
VSIStatBufL sStatBuf;
if (VSIStatL(pszName, &sStatBuf) != 0)
{
CPLError(CE_Failure, CPLE_AppDefined,
"%s does not appear to be a valid sxf file.",
pszName);
return OGRERR_FAILURE;
}
for (iExt = 0; apszExtensions[iExt] != NULL; iExt++)
{
const char *pszFile = CPLResetExtension(pszName,
apszExtensions[iExt]);
if (VSIStatL(pszFile, &sStatBuf) == 0)
VSIUnlink(pszFile);
}
return OGRERR_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;
}
OGRErr OGRGeoconceptDriver::DeleteDataSource( const char *pszDataSource )
{
int iExt;
VSIStatBuf sStatBuf;
static const char *apszExtensions[] =
{ "gxt", "txt", "gct", "gcm", "gcr", NULL };
if( VSIStat( pszDataSource, &sStatBuf ) != 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not appear to be a file or directory.",
pszDataSource );
return OGRERR_FAILURE;
}
if( VSI_ISREG(sStatBuf.st_mode)
&& (
EQUAL(CPLGetExtension(pszDataSource),"gxt") ||
EQUAL(CPLGetExtension(pszDataSource),"txt")
) )
{
for( iExt=0; apszExtensions[iExt] != NULL; iExt++ )
{
const char *pszFile = CPLResetExtension(pszDataSource,
apszExtensions[iExt] );
if( VSIStat( pszFile, &sStatBuf ) == 0 )
VSIUnlink( pszFile );
}
}
else if( VSI_ISDIR(sStatBuf.st_mode) )
{
char **papszDirEntries = CPLReadDir( pszDataSource );
int iFile;
for( iFile = 0;
papszDirEntries != NULL && papszDirEntries[iFile] != NULL;
iFile++ )
{
if( CSLFindString( (char **) apszExtensions,
CPLGetExtension(papszDirEntries[iFile])) != -1)
{
VSIUnlink( CPLFormFilename( pszDataSource,
papszDirEntries[iFile],
NULL ) );
}
}
CSLDestroy( papszDirEntries );
VSIRmdir( pszDataSource );
}
return OGRERR_NONE;
}
OGRErr OGRShapeLayer::CreateSpatialIndex( int nMaxDepth )
{
/* -------------------------------------------------------------------- */
/* If we have an existing spatial index, blow it away first. */
/* -------------------------------------------------------------------- */
if( CheckForQIX() )
DropSpatialIndex();
bCheckedForQIX = FALSE;
/* -------------------------------------------------------------------- */
/* Build a quadtree structure for this file. */
/* -------------------------------------------------------------------- */
SHPTree *psTree;
SyncToDisk();
psTree = SHPCreateTree( hSHP, 2, nMaxDepth, NULL, NULL );
if( NULL == psTree )
{
// TODO - mloskot: Is it better to return OGRERR_NOT_ENOUGH_MEMORY?
CPLDebug( "SHAPE",
"Index creation failure. Likely, memory allocation error." );
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Trim unused nodes from the tree. */
/* -------------------------------------------------------------------- */
SHPTreeTrimExtraNodes( psTree );
/* -------------------------------------------------------------------- */
/* Dump tree to .qix file. */
/* -------------------------------------------------------------------- */
char *pszQIXFilename;
pszQIXFilename = CPLStrdup(CPLResetExtension( pszFullName, "qix" ));
CPLDebug( "SHAPE", "Creating index file %s", pszQIXFilename );
SHPWriteTree( psTree, pszQIXFilename );
CPLFree( pszQIXFilename );
/* -------------------------------------------------------------------- */
/* cleanup */
/* -------------------------------------------------------------------- */
SHPDestroyTree( psTree );
CheckForQIX();
return OGRERR_NONE;
}
int OGRShapeLayer::CheckForQIX()
{
const char *pszQIXFilename;
if( bCheckedForQIX )
return fpQIX != NULL;
pszQIXFilename = CPLResetExtension( pszFullName, "qix" );
fpQIX = VSIFOpen( pszQIXFilename, "rb" );
bCheckedForQIX = TRUE;
return fpQIX != NULL;
}
void OGROpenFileGDBDataSource::AddLayer( const CPLString& osName,
int nInterestTable,
int& nCandidateLayers,
int& nLayersSDC,
const CPLString& osDefinition,
const CPLString& osDocumentation,
const char* pszGeomName,
OGRwkbGeometryType eGeomType )
{
std::map<std::string, int>::const_iterator oIter =
m_osMapNameToIdx.find(osName);
int idx = 0;
if( oIter != m_osMapNameToIdx.end() )
idx = oIter->second;
if( idx > 0 && (nInterestTable < 0 || nInterestTable == idx) )
{
const char* pszFilename = CPLFormFilename(
m_osDirName, CPLSPrintf("a%08x", idx), "gdbtable");
if( FileExists(pszFilename) )
{
nCandidateLayers ++;
if( m_papszFiles != NULL )
{
const char* pszSDC = CPLResetExtension(pszFilename, "gdbtable.sdc");
if( FileExists(pszSDC) )
{
nLayersSDC ++;
CPLError(CE_Warning, CPLE_AppDefined,
"%s layer has a %s file whose format is unhandled",
osName.c_str(), pszSDC);
return;
}
}
m_apoLayers.push_back(
new OGROpenFileGDBLayer(pszFilename,
osName,
osDefinition,
osDocumentation,
pszGeomName, eGeomType));
}
}
}
CPLErr SAGADataset::SetProjection( const char *pszSRS )
{
/* -------------------------------------------------------------------- */
/* Reset coordinate system on the dataset. */
/* -------------------------------------------------------------------- */
CPLFree( pszProjection );
pszProjection = CPLStrdup( pszSRS );
if( strlen(pszSRS) == 0 )
return CE_None;
/* -------------------------------------------------------------------- */
/* Convert to ESRI WKT. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS( pszSRS );
char *pszESRI_SRS = NULL;
oSRS.morphToESRI();
oSRS.exportToWkt( &pszESRI_SRS );
/* -------------------------------------------------------------------- */
/* Write to .prj file. */
/* -------------------------------------------------------------------- */
CPLString osPrjFilename = CPLResetExtension( GetDescription(), "prj" );
VSILFILE *fp;
fp = VSIFOpenL( osPrjFilename.c_str(), "wt" );
if( fp != NULL )
{
VSIFWriteL( pszESRI_SRS, 1, strlen(pszESRI_SRS), fp );
VSIFWriteL( (void *) "\n", 1, 1, fp );
VSIFCloseL( fp );
}
CPLFree( pszESRI_SRS );
return CE_None;
}
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 *PAuxDataset::Open( GDALOpenInfo * poOpenInfo )
{
if( poOpenInfo->nHeaderBytes < 1 )
return NULL;
/* -------------------------------------------------------------------- */
/* If this is an .aux file, fetch out and form the name of the */
/* file it references. */
/* -------------------------------------------------------------------- */
CPLString osTarget = poOpenInfo->pszFilename;
if( EQUAL(CPLGetExtension( poOpenInfo->pszFilename ),"aux")
&& STARTS_WITH_CI((const char *) poOpenInfo->pabyHeader, "AuxilaryTarget: "))
{
char szAuxTarget[1024];
const char *pszSrc = reinterpret_cast<const char *>(
poOpenInfo->pabyHeader+16 );
int i = 0;
for( ;
pszSrc[i] != 10 && pszSrc[i] != 13 && pszSrc[i] != '\0'
&& i < static_cast<int>( sizeof(szAuxTarget) ) - 1;
i++ )
{
szAuxTarget[i] = pszSrc[i];
}
szAuxTarget[i] = '\0';
char *pszPath = CPLStrdup(CPLGetPath(poOpenInfo->pszFilename));
osTarget = CPLFormFilename(pszPath, szAuxTarget, NULL);
CPLFree(pszPath);
}
/* -------------------------------------------------------------------- */
/* Now we need to tear apart the filename to form a .aux */
/* filename. */
/* -------------------------------------------------------------------- */
CPLString osAuxFilename = CPLResetExtension(osTarget,"aux");
/* -------------------------------------------------------------------- */
/* Do we have a .aux file? */
/* -------------------------------------------------------------------- */
char** papszSiblingFiles = poOpenInfo->GetSiblingFiles();
if( papszSiblingFiles != NULL
&& CSLFindString( papszSiblingFiles,
CPLGetFilename(osAuxFilename) ) == -1 )
{
return NULL;
}
VSILFILE *fp = VSIFOpenL( osAuxFilename, "r" );
if( fp == NULL )
{
osAuxFilename = CPLResetExtension(osTarget,"AUX");
fp = VSIFOpenL( osAuxFilename, "r" );
}
if( fp == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Is this file a PCI .aux file? Check the first line for the */
/* telltale AuxilaryTarget keyword. */
/* */
/* At this point we should be verifying that it refers to our */
/* binary file, but that is a pretty involved test. */
/* -------------------------------------------------------------------- */
const char *pszLine = CPLReadLineL( fp );
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
if( pszLine == NULL
|| (!STARTS_WITH_CI(pszLine, "AuxilaryTarget")
&& !STARTS_WITH_CI(pszLine, "AuxiliaryTarget")) )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
PAuxDataset *poDS = new PAuxDataset();
/* -------------------------------------------------------------------- */
/* Load the .aux file into a string list suitable to be */
/* searched with CSLFetchNameValue(). */
/* -------------------------------------------------------------------- */
poDS->papszAuxLines = CSLLoad( osAuxFilename );
poDS->pszAuxFilename = CPLStrdup(osAuxFilename);
/* -------------------------------------------------------------------- */
/* Find the RawDefinition line to establish overall parameters. */
/* -------------------------------------------------------------------- */
pszLine = CSLFetchNameValue(poDS->papszAuxLines, "RawDefinition");
// It seems PCI now writes out .aux files without RawDefinition in
// some cases. See bug 947.
if( pszLine == NULL )
{
delete poDS;
return NULL;
}
char **papszTokens = CSLTokenizeString(pszLine);
if( CSLCount(papszTokens) < 3 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"RawDefinition missing or corrupt in %s.",
poOpenInfo->pszFilename );
delete poDS;
CSLDestroy( papszTokens );
return NULL;
}
poDS->nRasterXSize = atoi(papszTokens[0]);
poDS->nRasterYSize = atoi(papszTokens[1]);
poDS->nBands = atoi(papszTokens[2]);
poDS->eAccess = poOpenInfo->eAccess;
CSLDestroy( papszTokens );
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) ||
!GDALCheckBandCount(poDS->nBands, FALSE))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
poDS->fpImage = VSIFOpenL( osTarget, "rb+" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s is missing or read-only, check permissions.",
osTarget.c_str() );
delete poDS;
return NULL;
}
}
else
{
poDS->fpImage = VSIFOpenL( osTarget, "rb" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"File %s is missing or unreadable.",
osTarget.c_str() );
delete poDS;
return NULL;
}
}
/* -------------------------------------------------------------------- */
/* Collect raw definitions of each channel and create */
/* corresponding bands. */
/* -------------------------------------------------------------------- */
int iBand = 0;
for( int i = 0; i < poDS->nBands; i++ )
{
char szDefnName[32];
snprintf( szDefnName, sizeof(szDefnName), "ChanDefinition-%d", i+1 );
pszLine = CSLFetchNameValue(poDS->papszAuxLines, szDefnName);
if (pszLine == NULL)
{
continue;
}
papszTokens = CSLTokenizeString(pszLine);
if( CSLCount(papszTokens) < 4 )
{
// Skip the band with broken description
CSLDestroy( papszTokens );
continue;
}
GDALDataType eType;
if( EQUAL(papszTokens[0],"16U") )
eType = GDT_UInt16;
else if( EQUAL(papszTokens[0],"16S") )
eType = GDT_Int16;
else if( EQUAL(papszTokens[0],"32R") )
eType = GDT_Float32;
else
eType = GDT_Byte;
int bNative = TRUE;
if( CSLCount(papszTokens) > 4 )
{
#ifdef CPL_LSB
bNative = EQUAL(papszTokens[4],"Swapped");
#else
bNative = EQUAL(papszTokens[4],"Unswapped");
#endif
}
const vsi_l_offset nBandOffset = CPLScanUIntBig(papszTokens[1],
static_cast<int>(strlen(papszTokens[1])));
const int nPixelOffset = atoi(papszTokens[2]);
const int nLineOffset = atoi(papszTokens[3]);
if (nPixelOffset <= 0 || nLineOffset <= 0)
{
// Skip the band with broken offsets
CSLDestroy( papszTokens );
continue;
}
poDS->SetBand( iBand+1,
new PAuxRasterBand( poDS, iBand+1, poDS->fpImage,
nBandOffset,
nPixelOffset,
nLineOffset, eType, bNative ) );
iBand++;
CSLDestroy( papszTokens );
}
poDS->nBands = iBand;
/* -------------------------------------------------------------------- */
/* Get the projection. */
/* -------------------------------------------------------------------- */
const char *pszMapUnits = CSLFetchNameValue( poDS->papszAuxLines, "MapUnits" );
const char *pszProjParms = CSLFetchNameValue( poDS->papszAuxLines, "ProjParms" );
if( pszMapUnits != NULL )
poDS->pszProjection = poDS->PCI2WKT( pszMapUnits, pszProjParms );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( osTarget );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, osTarget );
poDS->ScanForGCPs();
poDS->bAuxUpdated = FALSE;
return( poDS );
}
bool wxGxPrjFactory::GetChildren(wxGxObject* pParent, char** &pFileNames, wxArrayLong & pChildrenIds)
{
bool bCheckNames = CSLCount(pFileNames) < CHECK_DUBLES_MAX_COUNT;
for(int i = CSLCount(pFileNames) - 1; i >= 0; i-- )
{
CPLString szExt = CPLGetExtension(pFileNames[i]);
wxGxObject* pGxObj = NULL;
if(wxGISEQUAL(szExt, "prj"))
{
bool bAdd = true;
for(int j = 0; prj_notadd_exts[j] != NULL; ++j )
{
if(CPLCheckForFile((char*)CPLResetExtension(pFileNames[i], prj_notadd_exts[j]), NULL))
{
bAdd = false;
break;
}
}
if(bAdd)
{
pGxObj = GetGxObject(pParent, GetConvName(pFileNames[i]), pFileNames[i], enumESRIPrjFile, bCheckNames);
}
pFileNames = CSLRemoveStrings( pFileNames, i, 1, NULL );
}
else if(wxGISEQUAL(szExt, "qpj"))
{
bool bAdd = true;
for(int j = 0; prj_notadd_exts[j] != NULL; ++j )
{
if(CPLCheckForFile((char*)CPLResetExtension(pFileNames[i], prj_notadd_exts[j]), NULL))
{
bAdd = false;
break;
}
}
if(bAdd)
{
pGxObj = GetGxObject(pParent, GetConvName(pFileNames[i]), pFileNames[i], enumQPJfile, bCheckNames);
}
pFileNames = CSLRemoveStrings( pFileNames, i, 1, NULL );
}
else if(wxGISEQUAL(szExt, "spr"))
{
pGxObj = GetGxObject(pParent, GetConvName(pFileNames[i]), pFileNames[i], enumSPRfile, bCheckNames);
pFileNames = CSLRemoveStrings( pFileNames, i, 1, NULL );
}
if(pGxObj)
{
pChildrenIds.Add(pGxObj->GetId());
pGxObj = NULL;
}
}
return true;
}
OGRLayer *
OGRCSVDataSource::ICreateLayer( const char *pszLayerName,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
/* -------------------------------------------------------------------- */
/* Verify we are in update mode. */
/* -------------------------------------------------------------------- */
if( !bUpdate )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Data source %s opened read-only.\n"
"New layer %s cannot be created.",
pszName, pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Verify that the datasource is a directory. */
/* -------------------------------------------------------------------- */
VSIStatBufL sStatBuf;
if( STARTS_WITH(pszName, "/vsizip/"))
{
/* Do nothing */
}
else if( !EQUAL(pszName, "/vsistdout/") &&
(VSIStatL( pszName, &sStatBuf ) != 0
|| !VSI_ISDIR( sStatBuf.st_mode )) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create csv layer (file) against a "
"non-directory datasource." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* What filename would we use? */
/* -------------------------------------------------------------------- */
CPLString osFilename;
if( osDefaultCSVName != "" )
{
osFilename = CPLFormFilename( pszName, osDefaultCSVName, NULL );
osDefaultCSVName = "";
}
else
{
osFilename = CPLFormFilename( pszName, pszLayerName, "csv" );
}
/* -------------------------------------------------------------------- */
/* Does this directory/file already exist? */
/* -------------------------------------------------------------------- */
if( VSIStatL( osFilename, &sStatBuf ) == 0 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Attempt to create layer %s, but %s already exists.",
pszLayerName, osFilename.c_str() );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the empty file. */
/* -------------------------------------------------------------------- */
const char *pszDelimiter = CSLFetchNameValue( papszOptions, "SEPARATOR");
char chDelimiter = ',';
if (pszDelimiter != NULL)
{
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 );
}
}
/* -------------------------------------------------------------------- */
/* Create a layer. */
/* -------------------------------------------------------------------- */
OGRCSVLayer* poCSVLayer = new OGRCSVLayer( pszLayerName, NULL, osFilename,
true, true, chDelimiter );
poCSVLayer->BuildFeatureDefn();
/* -------------------------------------------------------------------- */
/* Was a particular CRLF order requested? */
/* -------------------------------------------------------------------- */
const char *pszCRLFFormat = CSLFetchNameValue( papszOptions, "LINEFORMAT");
bool bUseCRLF = false;
if( pszCRLFFormat == NULL )
{
#ifdef WIN32
bUseCRLF = true;
#endif
}
else if( EQUAL(pszCRLFFormat, "CRLF") )
{
bUseCRLF = true;
}
else if( EQUAL(pszCRLFFormat, "LF") )
{
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"LINEFORMAT=%s not understood, use one of CRLF or LF.",
pszCRLFFormat );
#ifdef WIN32
bUseCRLF = true;
#endif
}
poCSVLayer->SetCRLF( bUseCRLF );
/* -------------------------------------------------------------------- */
/* Should we write the geometry ? */
/* -------------------------------------------------------------------- */
const char *pszGeometry = CSLFetchNameValue( papszOptions, "GEOMETRY");
if( bEnableGeometryFields )
{
poCSVLayer->SetWriteGeometry(eGType, OGR_CSV_GEOM_AS_WKT,
CSLFetchNameValueDef(papszOptions, "GEOMETRY_NAME", "WKT"));
}
else if (pszGeometry != NULL)
{
if (EQUAL(pszGeometry, "AS_WKT"))
{
poCSVLayer->SetWriteGeometry(eGType, OGR_CSV_GEOM_AS_WKT,
CSLFetchNameValueDef(papszOptions, "GEOMETRY_NAME", "WKT"));
}
else if (EQUAL(pszGeometry, "AS_XYZ") ||
EQUAL(pszGeometry, "AS_XY") ||
EQUAL(pszGeometry, "AS_YX"))
{
if (eGType == wkbUnknown || wkbFlatten(eGType) == wkbPoint)
{
poCSVLayer->SetWriteGeometry(
eGType,
EQUAL(pszGeometry, "AS_XYZ") ? OGR_CSV_GEOM_AS_XYZ :
EQUAL(pszGeometry, "AS_XY") ? OGR_CSV_GEOM_AS_XY :
OGR_CSV_GEOM_AS_YX);
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Geometry type %s is not compatible with "
"GEOMETRY=AS_XYZ.",
OGRGeometryTypeToName(eGType) );
}
}
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unsupported value %s for creation option GEOMETRY",
pszGeometry );
}
}
/* -------------------------------------------------------------------- */
/* Should we create a CSVT file ? */
/* -------------------------------------------------------------------- */
const char *pszCreateCSVT = CSLFetchNameValue( papszOptions, "CREATE_CSVT");
if (pszCreateCSVT && CPLTestBool(pszCreateCSVT))
{
poCSVLayer->SetCreateCSVT(true);
/* -------------------------------------------------------------------- */
/* Create .prj file */
/* -------------------------------------------------------------------- */
if( poSpatialRef != NULL && osFilename != "/vsistdout/" )
{
char* pszWKT = NULL;
poSpatialRef->exportToWkt(&pszWKT);
if( pszWKT )
{
VSILFILE* fpPRJ
= VSIFOpenL(CPLResetExtension(osFilename, "prj"), "wb");
if( fpPRJ )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL(fpPRJ, "%s\n", pszWKT));
VSIFCloseL(fpPRJ);
}
CPLFree(pszWKT);
}
}
}
/* -------------------------------------------------------------------- */
/* Should we write a UTF8 BOM ? */
/* -------------------------------------------------------------------- */
const char *pszWriteBOM = CSLFetchNameValue( papszOptions, "WRITE_BOM");
if( pszWriteBOM )
poCSVLayer->SetWriteBOM(CPLTestBool(pszWriteBOM));
nLayers++;
papoLayers = static_cast<OGRLayer **>(
CPLRealloc( papoLayers, sizeof(void*) * nLayers ) );
OGRLayer* poLayer = poCSVLayer;
if( osFilename != "/vsistdout/" )
poLayer = new OGRCSVEditableLayer(poCSVLayer, NULL);
papoLayers[nLayers-1] = poLayer;
return poLayer;
}
int main( int nArgc, char ** papszArgv )
{
// register drivers
GDALAllRegister();
if( nArgc < 2 )
return EXIT_FAILURE;
double dfaCornersX[5] = {0};
double dfaCornersY[5] = {0};
CPLString sFileName;
// parse input values
for( int iArg = 1; iArg < nArgc; iArg++ )
{
if( EQUAL(papszArgv[iArg],"-nw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[1] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[1] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-ne"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[2] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[2] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-se"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[3] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[3] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-sw"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[4] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[4] = CPLAtofM(pszCoord);
}
else if( EQUAL(papszArgv[iArg],"-c"))
{
CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2);
const char* pszCoord = papszArgv[++iArg];
dfaCornersY[0] = CPLAtofM(pszCoord);
pszCoord = papszArgv[++iArg];
dfaCornersX[0] = CPLAtofM(pszCoord);
}
else if(sFileName.empty())
sFileName = papszArgv[iArg];
}
OGRSpatialReference oOGRSpatialReference(SRS_WKT_WGS84);
int nZoneNo = ceil( (180.0 + dfaCornersX[0]) / 6.0 );
OGRSpatialReference oDstSpatialReference(SRS_WKT_WGS84);
oDstSpatialReference.SetUTM(nZoneNo, dfaCornersY[0] > 0);
// transform coordinates from WGS84 to UTM
OGRCoordinateTransformation *poCT = OGRCreateCoordinateTransformation( &oOGRSpatialReference, &oDstSpatialReference);
if(!poCT)
{
Usage("get coordinate transformation failed");
return EXIT_FAILURE;
}
int nResult = poCT->Transform(5, dfaCornersX, dfaCornersY, NULL);
if(!nResult)
{
Usage("transformation failed");
return EXIT_FAILURE;
}
// open input dataset
GDALDataset *poSrcDataset = (GDALDataset *) GDALOpen( sFileName, GA_ReadOnly ); // GA_Update
char* pszSpaRefDef = NULL;
if( oDstSpatialReference.exportToWkt(&pszSpaRefDef) != OGRERR_NONE)
{
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
return EXIT_FAILURE;
}
// search point along image
// add GCP to opened raster
OGRPoint ptCenter(dfaCornersX[0], dfaCornersY[0]);
OGRPoint pt1(dfaCornersX[1], dfaCornersY[1]); // NW Cormer
OGRPoint pt2(dfaCornersX[2], dfaCornersY[2]); // NE Corner
OGRPoint pt3(dfaCornersX[3], dfaCornersY[3]); // SE Corner
OGRPoint pt4(dfaCornersX[4], dfaCornersY[4]); // SW Corner
int nGCPCount = 0;
OGREnvelope DstEnv;
GDAL_GCP *paGSPs = PrepareGCP(sFileName, &pt1, &pt2, &pt3, &pt4, &ptCenter, oDstSpatialReference, poSrcDataset->GetRasterXSize(), poSrcDataset->GetRasterYSize(), nGCPCount, DstEnv);
if(poSrcDataset->SetGCPs(nGCPCount, paGSPs, pszSpaRefDef) != CE_None)
{
Usage( "Set GCPs failed" );
return EXIT_FAILURE;
}
// create warper
char **papszTO = NULL;
papszTO = CSLSetNameValue( papszTO, "METHOD", "GCP_TPS" );
papszTO = CSLSetNameValue( papszTO, "NUM_THREADS", "4" );
papszTO = CSLSetNameValue( papszTO, "DST_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "SRC_SRS", pszSpaRefDef );
papszTO = CSLSetNameValue( papszTO, "INSERT_CENTER_LONG", "FALSE" );
GDALDriver *poOutputDriver = (GDALDriver *) GDALGetDriverByName( "GTiff" );
CPLSetConfigOption( "CHECK_WITH_INVERT_PROJ", "TRUE" );
void* hTransformArg = GDALCreateGenImgProjTransformer2( poSrcDataset, NULL, papszTO );
GDALTransformerInfo* psInfo = (GDALTransformerInfo*)hTransformArg;
double adfThisGeoTransform[6];
double adfExtent[4];
int nThisPixels, nThisLines;
// suggest the raster output size
if( GDALSuggestedWarpOutput2( poSrcDataset, psInfo->pfnTransform, hTransformArg, adfThisGeoTransform, &nThisPixels, &nThisLines, adfExtent, 0 ) != CE_None )
{
Usage( "Suggest Output failed" );
return EXIT_FAILURE;
}
adfThisGeoTransform[0] = DstEnv.MinX;
adfThisGeoTransform[3] = DstEnv.MaxY;
int nPixels = (int) ((DstEnv.MaxX - DstEnv.MinX) / adfThisGeoTransform[1] + 0.5);
int nLines = (int) ((DstEnv.MaxY - DstEnv.MinY) / -adfThisGeoTransform[5] + 0.5);
GDALSetGenImgProjTransformerDstGeoTransform( hTransformArg, adfThisGeoTransform);
// create new raster
CPLString sOutputRasterPath = CPLResetExtension(sFileName, "tif");
GDALDataset *poDstDataset = poOutputDriver->Create(sOutputRasterPath, nPixels, nLines, poSrcDataset->GetRasterCount(), GDT_Byte, NULL );
if( NULL == poDstDataset )
{
Usage( "Create Output failed" );
return EXIT_FAILURE;
}
poDstDataset->SetProjection( pszSpaRefDef );
poDstDataset->SetGeoTransform( adfThisGeoTransform );
#ifdef APRROX_MAXERROR
hTransformArg = GDALCreateApproxTransformer( GDALGenImgProjTransform, hTransformArg, APRROX_MAXERROR);
GDALTransformerFunc pfnTransformer = GDALApproxTransform;
GDALApproxTransformerOwnsSubtransformer(hTransformArg, TRUE);
#else
GDALTransformerFunc pfnTransformer = GDALGenImgProjTransform;
#endif // APRROX_MAXERROR
// warp
GDALWarpOptions *psWO = GDALCreateWarpOptions();
psWO->eWorkingDataType = GDT_Byte;
psWO->eResampleAlg = GRA_NearestNeighbour;
psWO->hSrcDS = poSrcDataset;
psWO->hDstDS = poDstDataset;
psWO->pfnTransformer = pfnTransformer;
psWO->pTransformerArg = hTransformArg;
psWO->pfnProgress = GDALTermProgress;
psWO->nBandCount = poSrcDataset->GetRasterCount();
psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount*sizeof(int));
for(int i = 0; i < psWO->nBandCount; ++i )
{
psWO->panSrcBands[i] = i+1;
psWO->panDstBands[i] = i+1;
}
GDALWarpOperation oWO;
if( oWO.Initialize( psWO ) == CE_None )
{
#ifdef MULTI
if( oWO.ChunkAndWarpMulti( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#else //MULTI
if( oWO.ChunkAndWarpImage( 0, 0, poDstDataset->GetRasterXSize(), poDstDataset->GetRasterYSize() ) != CE_None)
#endif //MULTI
{
const char* err = CPLGetLastErrorMsg();
Usage( CPLSPrintf("Warp failed.%s", err) );
return EXIT_FAILURE;
}
}
// cleanup
GDALDestroyWarpOptions( psWO );
CSLDestroy( papszTO );
CPLFree( pszSpaRefDef );
GDALClose( (GDALDatasetH) poSrcDataset );
GDALClose( (GDALDatasetH) poDstDataset );
GDALDestroyDriverManager();
return EXIT_SUCCESS;
}
GDAL_GCP * PrepareGCP(const CPLString& sFileName, OGRPoint *pt1, OGRPoint *pt2, OGRPoint *pt3, OGRPoint *pt4, OGRPoint *ptCenter, const OGRSpatialReference &oDstOGRSpatialReference, const int nRasterSizeX, const int nRasterSizeY, int &nGCPCount, OGREnvelope &DstEnv)
{
// to meters
double dfFocusM = dfFocus / 100;
double dfFilmHalfHeightM = dfFilmHeight / 200;
double dfRatio = dfFilmHalfHeightM / dfFocusM;
//create center point and line of scene
OGRPoint ptShortSideBeg = GetCenterOfLine(pt1, pt4);
OGRPoint ptShortSideEnd = GetCenterOfLine(pt2, pt3);
OGRLineString lnTmp;
lnTmp.addPoint(&ptShortSideBeg);
lnTmp.addPoint(&ptShortSideEnd);
lnTmp.Value(lnTmp.Project(pt1), &ptShortSideBeg);
lnTmp.Value(lnTmp.Project(pt2), &ptShortSideEnd);
double dfDist1 = pt1->Distance(pt2);
double dfDist2 = pt2->Distance(pt3);
double dfDist3 = pt3->Distance(pt4);
double dfDist4 = pt4->Distance(pt1);
double dfHalfWidth = (dfDist2 + dfDist4) / 4;
double dfHalfHeight = (dfDist1 + dfDist3) / 4;
double dfAltitudeAtSide = (dfHalfWidth * dfFocusM) / dfFilmHalfHeightM;
double dfAltitudeAtSceneCenter = sqrt( dfAltitudeAtSide * dfAltitudeAtSide - dfHalfHeight * dfHalfHeight);
double dfAltitude = dfAltitudeAtSceneCenter * cos(dfMountAngleRad); // 145 - 220 km
double dfDistCenter = dfAltitudeAtSceneCenter * sin(dfMountAngleRad);
OGRLineString lnCenterLeft;
lnCenterLeft.addPoint(&ptShortSideBeg);
lnCenterLeft.addPoint(ptCenter);
OGRPoint ptSatCenter = GetTangetPoint(lnCenterLeft, dfDistCenter);
std::vector<OGRPoint> aPt1, aPt2;
int nTotalGCPCount = ((SEGMENT_STEPS + 1) * 2);
GDAL_GCP *paGSPs = (GDAL_GCP *) CPLMalloc (nTotalGCPCount * sizeof(GDAL_GCP));
GDALInitGCPs(nTotalGCPCount, paGSPs);
double dfImageStepLen = double(nRasterSizeX) / SEGMENT_STEPS;
double dfImageCenterX = 0;
OGRLineString lnCenter;
lnCenter.addPoint(&ptShortSideBeg);
lnCenter.addPoint(ptCenter);
lnCenter.addPoint(&ptShortSideEnd);
double dfCenterLineLen = lnCenter.get_Length();
double dfStepLen = dfCenterLineLen / SEGMENT_STEPS;
double dfCenterLineHalfLen = dfCenterLineLen / 2;
for(double i = 0; i <= dfCenterLineLen; i += dfStepLen)
{
OGRPoint ptTmp;
lnCenter.Value(i, &ptTmp);
double dfDist = fabs(dfCenterLineHalfLen - i);
double dfWidthTmp = GetWidthForHeight(dfAltitudeAtSceneCenter, dfDist, dfRatio);
OGRLineString lnTmpLine;
lnTmpLine.addPoint(ptCenter);
lnTmpLine.addPoint(&ptTmp);
int direction = 1;
if(dfCenterLineHalfLen < i)
direction = -1;
OGRPoint ptUp = GetTangetPoint(lnTmpLine, dfWidthTmp * direction);
OGRPoint ptDown = GetTangetPoint(lnTmpLine, -dfWidthTmp * direction);
//OGRPoint ptUp = GetValue(dfWidthTmp, lnTmpLine);
//OGRPoint ptDown = GetValue(-dfWidthTmp, lnTmpLine);
aPt1.push_back(ptUp);
aPt2.push_back(ptDown);
paGSPs[nGCPCount].dfGCPLine = 0;
paGSPs[nGCPCount].dfGCPPixel = dfImageCenterX;
paGSPs[nGCPCount].dfGCPX = ptDown.getX();
paGSPs[nGCPCount].dfGCPY = ptDown.getY();
paGSPs[nGCPCount].dfGCPZ = dfMeanHeight;
paGSPs[nGCPCount].pszId = CPLStrdup(CPLSPrintf("pt%d", nGCPCount));
nGCPCount++;
paGSPs[nGCPCount].dfGCPLine = nRasterSizeY;
paGSPs[nGCPCount].dfGCPPixel = dfImageCenterX;
paGSPs[nGCPCount].dfGCPX = ptUp.getX();
paGSPs[nGCPCount].dfGCPY = ptUp.getY();
paGSPs[nGCPCount].dfGCPZ = dfMeanHeight;
paGSPs[nGCPCount].pszId = CPLStrdup(CPLSPrintf("pt%d", nGCPCount));
nGCPCount++;
dfImageCenterX += dfImageStepLen;
}
// add points to polygon
OGRLinearRing Ring;
for(int i = 0; i < aPt1.size(); ++i)
Ring.addPoint(aPt1[i].getX(), aPt1[i].getY());
for(int i = aPt2.size() - 1; i >= 0; --i)
Ring.addPoint(aPt2[i].getX(), aPt2[i].getY());
Ring.closeRings();
OGRPolygon Rgn;
Rgn.addRingDirectly((OGRCurve*)Ring.clone());
Rgn.assignSpatialReference(oDstOGRSpatialReference.Clone());
Rgn.flattenTo2D();
Rgn.getEnvelope(&DstEnv);
SaveGeometry(CPLResetExtension(sFileName, "shp"), Rgn, oDstOGRSpatialReference);
return paGSPs;
}
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);
}
CPLErr BTDataset::SetProjection( const char *pszNewProjection )
{
CPLErr eErr = CE_None;
CPLFree( pszProjection );
pszProjection = CPLStrdup( pszNewProjection );
bHeaderModified = TRUE;
/* -------------------------------------------------------------------- */
/* Parse projection. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS( pszProjection );
GInt16 nShortTemp = 0;
/* -------------------------------------------------------------------- */
/* Linear units. */
/* -------------------------------------------------------------------- */
if( oSRS.IsGeographic() )
{
// nShortTemp = 0;
}
else
{
const double dfLinear = oSRS.GetLinearUnits();
if( std::abs(dfLinear - 0.3048) < 0.0000001 )
nShortTemp = 2;
else if( std::abs(dfLinear - CPLAtof(SRS_UL_US_FOOT_CONV))
< 0.00000001 )
nShortTemp = 3;
else
nShortTemp = 1;
}
nShortTemp = CPL_LSBWORD16( 1 );
memcpy( abyHeader + 22, &nShortTemp, 2 );
/* -------------------------------------------------------------------- */
/* UTM Zone */
/* -------------------------------------------------------------------- */
int bNorth = FALSE;
nShortTemp = (GInt16) oSRS.GetUTMZone( &bNorth );
if( bNorth )
nShortTemp = -nShortTemp;
nShortTemp = CPL_LSBWORD16( nShortTemp );
memcpy( abyHeader + 24, &nShortTemp, 2 );
/* -------------------------------------------------------------------- */
/* Datum */
/* -------------------------------------------------------------------- */
if( oSRS.GetAuthorityName( "GEOGCS|DATUM" ) != NULL
&& EQUAL(oSRS.GetAuthorityName( "GEOGCS|DATUM" ),"EPSG") )
nShortTemp = static_cast<GInt16>(
atoi(oSRS.GetAuthorityCode( "GEOGCS|DATUM" )) + 2000);
else
nShortTemp = -2;
nShortTemp = CPL_LSBWORD16( nShortTemp ); /* datum unknown */
memcpy( abyHeader + 26, &nShortTemp, 2 );
/* -------------------------------------------------------------------- */
/* Write out the projection to a .prj file. */
/* -------------------------------------------------------------------- */
const char *pszPrjFile = CPLResetExtension( GetDescription(), "prj" );
VSILFILE * fp = VSIFOpenL( pszPrjFile, "wt" );
if( fp != NULL )
{
CPL_IGNORE_RET_VAL(VSIFPrintfL( fp, "%s\n", pszProjection ));
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
abyHeader[60] = 1;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to write out .prj file." );
eErr = CE_Failure;
}
return eErr;
}
CPLErr GDALWriteIMDFile( const char *pszFilename, char **papszMD )
{
CPLString osRPBFilename = CPLResetExtension( pszFilename, "IMD" );
/* -------------------------------------------------------------------- */
/* Read file and parse. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( osRPBFilename, "w" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create %s for writing.\n%s",
osRPBFilename.c_str(), CPLGetLastErrorMsg() );
return CE_Failure;
}
/* ==================================================================== */
/* -------------------------------------------------------------------- */
/* Loop through all values writing. */
/* -------------------------------------------------------------------- */
/* ==================================================================== */
int iKey;
CPLString osCurSection;
for( iKey = 0; papszMD[iKey] != NULL; iKey++ )
{
char *pszRawKey = NULL;
const char *pszValue = CPLParseNameValue( papszMD[iKey], &pszRawKey );
CPLString osKeySection, osKeyItem;
char *pszDot = strchr(pszRawKey,'.');
/* -------------------------------------------------------------------- */
/* Split stuff like BAND_P.ULLon into section and item. */
/* -------------------------------------------------------------------- */
if( pszDot == NULL )
{
osKeyItem = pszRawKey;
}
else
{
osKeyItem = pszDot+1;
*pszDot = '\0';
osKeySection = pszRawKey;
}
CPLFree( pszRawKey );
/* -------------------------------------------------------------------- */
/* Close and/or start sections as needed. */
/* -------------------------------------------------------------------- */
if( osCurSection.size() && !EQUAL(osCurSection,osKeySection) )
VSIFPrintfL( fp, "END_GROUP = %s\n", osCurSection.c_str() );
if( osKeySection.size() && !EQUAL(osCurSection,osKeySection) )
VSIFPrintfL( fp, "BEGIN_GROUP = %s\n", osKeySection.c_str() );
osCurSection = osKeySection;
/* -------------------------------------------------------------------- */
/* Print out simple item. */
/* -------------------------------------------------------------------- */
if( osCurSection.size() )
VSIFPrintfL( fp, "\t%s = ", osKeyItem.c_str() );
else
VSIFPrintfL( fp, "%s = ", osKeyItem.c_str() );
if( pszValue[0] != '(' )
VSIFPrintfL( fp, "%s;\n", pszValue );
else
GDALWriteIMDMultiLine( fp, pszValue );
}
/* -------------------------------------------------------------------- */
/* Close off. */
/* -------------------------------------------------------------------- */
if( osCurSection.size() )
VSIFPrintfL( fp, "END_GROUP = %s\n", osCurSection.c_str() );
VSIFPrintfL( fp, "END;\n" );
VSIFCloseL( fp );
return CE_None;
}
/*!
\brief VFKReaderSQLite constructor
*/
VFKReaderSQLite::VFKReaderSQLite(const char *pszFilename) : VFKReader(pszFilename)
{
const char *pszDbNameConf;
CPLString osDbName;
CPLString osCommand;
VSIStatBufL sStatBufDb, sStatBufVfk;
/* open tmp SQLite DB (re-use DB file if already exists) */
pszDbNameConf = CPLGetConfigOption("OGR_VFK_DB_NAME", NULL);
if (pszDbNameConf) {
osDbName = pszDbNameConf;
}
else {
osDbName = CPLResetExtension(m_pszFilename, "db");
}
size_t nLen = osDbName.length();
if( nLen > 2048 )
{
nLen = 2048;
osDbName.resize(nLen);
}
m_pszDBname = new char [nLen+1];
std::strncpy(m_pszDBname, osDbName.c_str(), nLen);
m_pszDBname[nLen] = 0;
CPLDebug("OGR-VFK", "Using internal DB: %s",
m_pszDBname);
if (CPLTestBool(CPLGetConfigOption("OGR_VFK_DB_SPATIAL", "YES")))
m_bSpatial = TRUE; /* build geometry from DB */
else
m_bSpatial = FALSE; /* store also geometry in DB */
m_bNewDb = TRUE;
if (VSIStatL(osDbName, &sStatBufDb) == 0) {
if (CPLTestBool(CPLGetConfigOption("OGR_VFK_DB_OVERWRITE", "NO"))) {
m_bNewDb = TRUE; /* overwrite existing DB */
CPLDebug("OGR-VFK", "Internal DB (%s) already exists and will be overwritten",
m_pszDBname);
VSIUnlink(osDbName);
}
else {
if (VSIStatL(pszFilename, &sStatBufVfk) == 0 &&
sStatBufVfk.st_mtime > sStatBufDb.st_mtime) {
CPLDebug("OGR-VFK",
"Found %s but ignoring because it appears\n"
"be older than the associated VFK file.",
osDbName.c_str());
m_bNewDb = TRUE;
VSIUnlink(osDbName);
}
else {
m_bNewDb = FALSE; /* re-use existing DB */
}
}
}
/*
if (m_bNewDb) {
CPLError(CE_Warning, CPLE_AppDefined,
"INFO: No internal SQLite DB found. Reading VFK data may take some time...");
}
*/
CPLDebug("OGR-VFK", "New DB: %s Spatial: %s",
m_bNewDb ? "yes" : "no", m_bSpatial ? "yes" : "no");
if (SQLITE_OK != sqlite3_open(osDbName, &m_poDB)) {
CPLError(CE_Failure, CPLE_AppDefined,
"Creating SQLite DB failed");
}
else {
char* pszErrMsg = NULL;
CPL_IGNORE_RET_VAL(sqlite3_exec(m_poDB, "PRAGMA synchronous = OFF", NULL, NULL, &pszErrMsg));
sqlite3_free(pszErrMsg);
}
if (m_bNewDb) {
/* new DB, create support metadata tables */
osCommand.Printf("CREATE TABLE %s (file_name text, table_name text, num_records integer, "
"num_features integer, num_geometries integer, table_defn text)",
VFK_DB_TABLE);
ExecuteSQL(osCommand.c_str());
/* header table */
osCommand.Printf("CREATE TABLE %s (key text, value text)", VFK_DB_HEADER);
ExecuteSQL(osCommand.c_str());
}
}
OGRErr OGRCSVEditableLayerSynchronizer::EditableSyncToDisk(OGRLayer* poEditableLayer,
OGRLayer** ppoDecoratedLayer)
{
CPLAssert( m_poCSVLayer == *ppoDecoratedLayer );
CPLString osLayerName(m_poCSVLayer->GetName());
CPLString osFilename(m_poCSVLayer->GetFilename());
const bool bCreateCSVT = m_poCSVLayer->GetCreateCSVT();
CPLString osCSVTFilename(CPLResetExtension(osFilename, "csvt"));
VSIStatBufL sStatBuf;
const bool bHasCSVT = VSIStatL(osCSVTFilename, &sStatBuf) == 0;
CPLString osTmpFilename(osFilename);
CPLString osTmpCSVTFilename(osFilename);
if( VSIStatL(osFilename, &sStatBuf) == 0 )
{
osTmpFilename += "_ogr_tmp.csv";
osTmpCSVTFilename += "_ogr_tmp.csvt";
}
const char chDelimiter = m_poCSVLayer->GetDelimiter();
OGRCSVLayer* poCSVTmpLayer = new OGRCSVLayer( osLayerName, NULL,
osTmpFilename,
true, true, chDelimiter );
poCSVTmpLayer->BuildFeatureDefn(NULL, NULL, m_papszOpenOptions);
poCSVTmpLayer->SetCRLF( m_poCSVLayer->GetCRLF() );
poCSVTmpLayer->SetCreateCSVT( bCreateCSVT || bHasCSVT );
poCSVTmpLayer->SetWriteBOM( m_poCSVLayer->GetWriteBOM() );
if( m_poCSVLayer->GetGeometryFormat() == OGR_CSV_GEOM_AS_WKT )
poCSVTmpLayer->SetWriteGeometry( wkbNone, OGR_CSV_GEOM_AS_WKT, NULL );
OGRErr eErr = OGRERR_NONE;
OGRFeatureDefn* poEditableFDefn = poEditableLayer->GetLayerDefn();
for( int i=0; eErr == OGRERR_NONE &&
i < poEditableFDefn->GetFieldCount(); i++ )
{
OGRFieldDefn oFieldDefn(poEditableFDefn->GetFieldDefn(i));
int iGeomFieldIdx = 0;
if( (EQUAL(oFieldDefn.GetNameRef(), "WKT") &&
(iGeomFieldIdx = poEditableFDefn->GetGeomFieldIndex("")) >= 0) ||
(iGeomFieldIdx = poEditableFDefn->GetGeomFieldIndex(oFieldDefn.GetNameRef())) >= 0 )
{
OGRGeomFieldDefn oGeomFieldDefn(
poEditableFDefn->GetGeomFieldDefn(iGeomFieldIdx) );
eErr = poCSVTmpLayer->CreateGeomField( &oGeomFieldDefn );
}
else
{
eErr = poCSVTmpLayer->CreateField( &oFieldDefn );
}
}
const bool bHasXY = ( !m_poCSVLayer->GetXField().empty() &&
!m_poCSVLayer->GetYField().empty() );
const bool bHasZ = ( !m_poCSVLayer->GetZField().empty() );
if( bHasXY && !CPLFetchBool(m_papszOpenOptions, "KEEP_GEOM_COLUMNS", true) )
{
if( poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetXField()) < 0 )
{
OGRFieldDefn oFieldDefn(m_poCSVLayer->GetXField(), OFTReal);
if( eErr == OGRERR_NONE )
eErr = poCSVTmpLayer->CreateField( &oFieldDefn );
}
if( poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetYField()) < 0 )
{
OGRFieldDefn oFieldDefn(m_poCSVLayer->GetYField(), OFTReal);
if( eErr == OGRERR_NONE )
eErr = poCSVTmpLayer->CreateField( &oFieldDefn );
}
if( bHasZ && poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetZField()) < 0 )
{
OGRFieldDefn oFieldDefn(m_poCSVLayer->GetZField(), OFTReal);
if( eErr == OGRERR_NONE )
eErr = poCSVTmpLayer->CreateField( &oFieldDefn );
}
}
int nFirstGeomColIdx = 0;
if( m_poCSVLayer->HasHiddenWKTColumn() )
{
poCSVTmpLayer->SetWriteGeometry(
poEditableFDefn->GetGeomFieldDefn(0)->GetType(),
OGR_CSV_GEOM_AS_WKT,
poEditableFDefn->GetGeomFieldDefn(0)->GetNameRef());
nFirstGeomColIdx = 1;
}
if( !(poEditableFDefn->GetGeomFieldCount() == 1 && bHasXY) )
{
for( int i=nFirstGeomColIdx; eErr == OGRERR_NONE &&
i < poEditableFDefn->GetGeomFieldCount(); i++ )
{
OGRGeomFieldDefn oGeomFieldDefn( poEditableFDefn->GetGeomFieldDefn(i) );
if( poCSVTmpLayer->GetLayerDefn()->GetGeomFieldIndex(oGeomFieldDefn.GetNameRef()) >= 0 )
continue;
eErr = poCSVTmpLayer->CreateGeomField( &oGeomFieldDefn );
}
}
OGRFeature* poFeature = NULL;
poEditableLayer->ResetReading();
while( eErr == OGRERR_NONE &&
(poFeature = poEditableLayer->GetNextFeature()) != NULL )
{
OGRFeature* poNewFeature = new OGRFeature( poCSVTmpLayer->GetLayerDefn() );
poNewFeature->SetFrom(poFeature);
if( bHasXY )
{
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL && wkbFlatten(poGeom->getGeometryType()) == wkbPoint )
{
poNewFeature->SetField( m_poCSVLayer->GetXField(),
static_cast<OGRPoint*>(poGeom)->getX());
poNewFeature->SetField( m_poCSVLayer->GetYField(),
static_cast<OGRPoint*>(poGeom)->getY());
if( bHasZ )
{
poNewFeature->SetField( m_poCSVLayer->GetZField(),
static_cast<OGRPoint*>(poGeom)->getZ());
}
}
}
eErr = poCSVTmpLayer->CreateFeature(poNewFeature);
delete poFeature;
delete poNewFeature;
}
delete poCSVTmpLayer;
if( eErr != OGRERR_NONE )
{
CPLError(CE_Failure, CPLE_AppDefined, "Error while creating %s",
osTmpFilename.c_str());
VSIUnlink( osTmpFilename );
VSIUnlink( CPLResetExtension(osTmpFilename, "csvt") );
return eErr;
}
delete m_poCSVLayer;
if( osFilename != osTmpFilename )
{
CPLString osTmpOriFilename(osFilename + ".ogr_bak");
CPLString osTmpOriCSVTFilename(osCSVTFilename + ".ogr_bak");
if( VSIRename( osFilename, osTmpOriFilename ) != 0 ||
(bHasCSVT && VSIRename( osCSVTFilename, osTmpOriCSVTFilename ) != 0 ) ||
VSIRename( osTmpFilename, osFilename) != 0 ||
(bHasCSVT && VSIRename( osTmpCSVTFilename, osCSVTFilename ) != 0) )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot rename files");
*ppoDecoratedLayer = NULL;
m_poCSVLayer = NULL;
return OGRERR_FAILURE;
}
VSIUnlink( osTmpOriFilename );
if( bHasCSVT )
VSIUnlink( osTmpOriCSVTFilename );
}
VSILFILE* fp = VSIFOpenL( osFilename, "rb+" );
if( fp == NULL )
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot reopen updated %s",
osFilename.c_str());
*ppoDecoratedLayer = NULL;
m_poCSVLayer = NULL;
return OGRERR_FAILURE;
}
m_poCSVLayer = new OGRCSVLayer( osLayerName, fp,
osFilename,
false, /* new */
true, /* update */
chDelimiter );
m_poCSVLayer->BuildFeatureDefn(NULL, NULL, m_papszOpenOptions);
*ppoDecoratedLayer = m_poCSVLayer;
return OGRERR_NONE;
}
int OGRIdrisiLayer::Detect_AVL_ADC(const char* pszFilename)
{
// --------------------------------------------------------------------
// Look for .adc file
// --------------------------------------------------------------------
const char* pszADCFilename = CPLResetExtension(pszFilename, "adc");
VSILFILE* fpADC = VSIFOpenL(pszADCFilename, "rb");
if (fpADC == NULL)
{
pszADCFilename = CPLResetExtension(pszFilename, "ADC");
fpADC = VSIFOpenL(pszADCFilename, "rb");
}
char** papszADC = NULL;
if (fpADC != NULL)
{
VSIFCloseL(fpADC);
fpADC = NULL;
CPLPushErrorHandler(CPLQuietErrorHandler);
papszADC = CSLLoad2(pszADCFilename, 1024, 256, NULL);
CPLPopErrorHandler();
CPLErrorReset();
}
if (papszADC == NULL)
return FALSE;
CSLSetNameValueSeparator( papszADC, ":" );
const char *pszVersion = CSLFetchNameValue( papszADC, "file format " );
if( pszVersion == NULL || !EQUAL( pszVersion, "IDRISI Values A.1" ) )
{
CSLDestroy( papszADC );
return FALSE;
}
const char *pszFileType = CSLFetchNameValue( papszADC, "file type " );
if( pszFileType == NULL || !EQUAL( pszFileType, "ascii" ) )
{
CPLDebug("IDRISI", ".adc file found, but file type != ascii");
CSLDestroy( papszADC );
return FALSE;
}
const char* pszRecords = CSLFetchNameValue( papszADC, "records " );
if( pszRecords == NULL || atoi(pszRecords) != (int)nTotalFeatures )
{
CPLDebug("IDRISI", ".adc file found, but 'records' not found or not "
"consistent with feature number declared in .vdc");
CSLDestroy( papszADC );
return FALSE;
}
const char* pszFields = CSLFetchNameValue( papszADC, "fields " );
if( pszFields == NULL || atoi(pszFields) <= 1 )
{
CPLDebug("IDRISI", ".adc file found, but 'fields' not found or invalid");
CSLDestroy( papszADC );
return FALSE;
}
// --------------------------------------------------------------------
// Look for .avl file
// --------------------------------------------------------------------
const char* pszAVLFilename = CPLResetExtension(pszFilename, "avl");
fpAVL = VSIFOpenL(pszAVLFilename, "rb");
if (fpAVL == NULL)
{
pszAVLFilename = CPLResetExtension(pszFilename, "AVL");
fpAVL = VSIFOpenL(pszAVLFilename, "rb");
}
if (fpAVL == NULL)
{
CSLDestroy( papszADC );
return FALSE;
}
// --------------------------------------------------------------------
// Build layer definition
// --------------------------------------------------------------------
int iCurField;
char szKey[32];
iCurField = 0;
sprintf(szKey, "field %d ", iCurField);
char** papszIter = papszADC;
const char* pszLine;
int bFieldFound = FALSE;
CPLString osFieldName;
while((pszLine = *papszIter) != NULL)
{
//CPLDebug("IDRISI", "%s", pszLine);
if (strncmp(pszLine, szKey, strlen(szKey)) == 0)
{
const char* pszColon = strchr(pszLine, ':');
if (pszColon)
{
osFieldName = pszColon + 1;
bFieldFound = TRUE;
}
}
else if (bFieldFound &&
strncmp(pszLine, "data type :", strlen("data type :")) == 0)
{
const char* pszFieldType = pszLine + strlen("data type :");
OGRFieldDefn oFieldDefn(osFieldName.c_str(),
EQUAL(pszFieldType, "integer") ? OFTInteger :
EQUAL(pszFieldType, "real") ? OFTReal : OFTString);
if( iCurField == 0 && oFieldDefn.GetType() != OFTInteger )
{
CSLDestroy( papszADC );
return FALSE;
}
if( iCurField != 0 )
poFeatureDefn->AddFieldDefn( &oFieldDefn );
iCurField ++;
sprintf(szKey, "field %d ", iCurField);
}
papszIter++;
}
CSLDestroy(papszADC);
return TRUE;
}
GDALDataset *DTEDDataset::Open( GDALOpenInfo * poOpenInfo )
{
int i;
DTEDInfo *psDTED;
if (!Identify(poOpenInfo) || poOpenInfo->fpL == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = poOpenInfo->fpL;
poOpenInfo->fpL = NULL;
psDTED = DTEDOpenEx( fp, poOpenInfo->pszFilename,
(poOpenInfo->eAccess == GA_Update) ? "rb+" : "rb", TRUE );
if( psDTED == NULL )
return( NULL );
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DTEDDataset *poDS;
poDS = new DTEDDataset();
poDS->SetFileName(poOpenInfo->pszFilename);
poDS->eAccess = poOpenInfo->eAccess;
poDS->psDTED = psDTED;
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = psDTED->nXSize;
poDS->nRasterYSize = psDTED->nYSize;
if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize))
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
poDS->nBands = 1;
for( i = 0; i < poDS->nBands; i++ )
poDS->SetBand( i+1, new DTEDRasterBand( poDS, i+1 ) );
/* -------------------------------------------------------------------- */
/* Collect any metadata available. */
/* -------------------------------------------------------------------- */
char *pszValue;
pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTACCURACY_UHL );
poDS->SetMetadataItem( "DTED_VerticalAccuracy_UHL", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTACCURACY_ACC );
poDS->SetMetadataItem( "DTED_VerticalAccuracy_ACC", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_SECURITYCODE_UHL );
poDS->SetMetadataItem( "DTED_SecurityCode_UHL", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_SECURITYCODE_DSI );
poDS->SetMetadataItem( "DTED_SecurityCode_DSI", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_UNIQUEREF_UHL );
poDS->SetMetadataItem( "DTED_UniqueRef_UHL", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_UNIQUEREF_DSI );
poDS->SetMetadataItem( "DTED_UniqueRef_DSI", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_DATA_EDITION );
poDS->SetMetadataItem( "DTED_DataEdition", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_MATCHMERGE_VERSION );
poDS->SetMetadataItem( "DTED_MatchMergeVersion", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_MAINT_DATE );
poDS->SetMetadataItem( "DTED_MaintenanceDate", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_MATCHMERGE_DATE );
poDS->SetMetadataItem( "DTED_MatchMergeDate", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_MAINT_DESCRIPTION );
poDS->SetMetadataItem( "DTED_MaintenanceDescription", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_PRODUCER );
poDS->SetMetadataItem( "DTED_Producer", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTDATUM );
poDS->SetMetadataItem( "DTED_VerticalDatum", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_HORIZDATUM );
poDS->SetMetadataItem( "DTED_HorizontalDatum", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_DIGITIZING_SYS );
poDS->SetMetadataItem( "DTED_DigitizingSystem", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_COMPILATION_DATE );
poDS->SetMetadataItem( "DTED_CompilationDate", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_HORIZACCURACY );
poDS->SetMetadataItem( "DTED_HorizontalAccuracy", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_REL_HORIZACCURACY );
poDS->SetMetadataItem( "DTED_RelHorizontalAccuracy", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_REL_VERTACCURACY );
poDS->SetMetadataItem( "DTED_RelVerticalAccuracy", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_ORIGINLAT );
poDS->SetMetadataItem( "DTED_OriginLatitude", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_ORIGINLONG );
poDS->SetMetadataItem( "DTED_OriginLongitude", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_NIMA_DESIGNATOR );
poDS->SetMetadataItem( "DTED_NimaDesignator", pszValue );
CPLFree( pszValue );
pszValue = DTEDGetMetadata( psDTED, DTEDMD_PARTIALCELL_DSI );
poDS->SetMetadataItem( "DTED_PartialCellIndicator", pszValue );
CPLFree( pszValue );
poDS->SetMetadataItem( GDALMD_AREA_OR_POINT, GDALMD_AOP_POINT );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML( poOpenInfo->GetSiblingFiles() );
// if no SR in xml, try aux
const char* pszPrj = poDS->GDALPamDataset::GetProjectionRef();
if( !pszPrj || strlen(pszPrj) == 0 )
{
int bTryAux = TRUE;
if( poOpenInfo->GetSiblingFiles() != NULL &&
CSLFindString(poOpenInfo->GetSiblingFiles(), CPLResetExtension(CPLGetFilename(poOpenInfo->pszFilename), "aux")) < 0 &&
CSLFindString(poOpenInfo->GetSiblingFiles(), CPLSPrintf("%s.aux", CPLGetFilename(poOpenInfo->pszFilename))) < 0 )
bTryAux = FALSE;
if( bTryAux )
{
GDALDataset* poAuxDS = GDALFindAssociatedAuxFile( poOpenInfo->pszFilename, GA_ReadOnly, poDS );
if( poAuxDS )
{
pszPrj = poAuxDS->GetProjectionRef();
if( pszPrj && strlen(pszPrj) > 0 )
{
CPLFree( poDS->pszProjection );
poDS->pszProjection = CPLStrdup(pszPrj);
}
GDALClose( poAuxDS );
}
}
}
/* -------------------------------------------------------------------- */
/* Support overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename,
poOpenInfo->GetSiblingFiles() );
return( poDS );
}
GDALDataset *BTDataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Verify that this is some form of binterr file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 256)
return NULL;
if( !STARTS_WITH((const char *) poOpenInfo->pabyHeader, "binterr") )
return NULL;
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
BTDataset *poDS = new BTDataset();
memcpy( poDS->abyHeader, poOpenInfo->pabyHeader, 256 );
/* -------------------------------------------------------------------- */
/* Get the version. */
/* -------------------------------------------------------------------- */
char szVersion[4] = {};
strncpy( szVersion, (char *) (poDS->abyHeader + 7), 3 );
szVersion[3] = '\0';
poDS->nVersionCode = static_cast<int>(CPLAtof(szVersion) * 10);
/* -------------------------------------------------------------------- */
/* Extract core header information, being careful about the */
/* version. */
/* -------------------------------------------------------------------- */
GInt32 nIntTemp = 0;
memcpy( &nIntTemp, poDS->abyHeader + 10, 4 );
poDS->nRasterXSize = CPL_LSBWORD32( nIntTemp );
memcpy( &nIntTemp, poDS->abyHeader + 14, 4 );
poDS->nRasterYSize = CPL_LSBWORD32( nIntTemp );
if( !GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize) )
{
delete poDS;
return NULL;
}
GInt16 nDataSize = 0;
memcpy( &nDataSize, poDS->abyHeader+18, 2 );
nDataSize = CPL_LSBWORD16( nDataSize );
GDALDataType eType = GDT_Unknown;
if( poDS->abyHeader[20] != 0 && nDataSize == 4 )
eType = GDT_Float32;
else if( poDS->abyHeader[20] == 0 && nDataSize == 4 )
eType = GDT_Int32;
else if( poDS->abyHeader[20] == 0 && nDataSize == 2 )
eType = GDT_Int16;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
".bt file data type unknown, got datasize=%d.",
nDataSize );
delete poDS;
return NULL;
}
/*
rcg, apr 7/06: read offset 62 for vert. units.
If zero, assume 1.0 as per spec.
*/
memcpy( &poDS->m_fVscale, poDS->abyHeader + 62, 4 );
CPL_LSBPTR32(&poDS->m_fVscale);
if(poDS->m_fVscale == 0.0f)
poDS->m_fVscale = 1.0f;
/* -------------------------------------------------------------------- */
/* Try to read a .prj file if it is indicated. */
/* -------------------------------------------------------------------- */
OGRSpatialReference oSRS;
if( poDS->nVersionCode >= 12 && poDS->abyHeader[60] != 0 )
{
const char *pszPrjFile = CPLResetExtension( poOpenInfo->pszFilename,
"prj" );
VSILFILE *fp = VSIFOpenL( pszPrjFile, "rt" );
if( fp != NULL )
{
const int nBufMax = 10000;
char *pszBuffer = static_cast<char *>(CPLMalloc(nBufMax));
const int nBytes =
static_cast<int>(VSIFReadL( pszBuffer, 1, nBufMax-1, fp ));
CPL_IGNORE_RET_VAL(VSIFCloseL( fp ));
pszBuffer[nBytes] = '\0';
char *pszBufPtr = pszBuffer;
if( oSRS.importFromWkt( &pszBufPtr ) != OGRERR_NONE )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Unable to parse .prj file, "
"coordinate system missing." );
}
CPLFree( pszBuffer );
}
}
/* -------------------------------------------------------------------- */
/* If we didn't find a .prj file, try to use internal info. */
/* -------------------------------------------------------------------- */
if( oSRS.GetRoot() == NULL )
{
GInt16 nUTMZone = 0;
memcpy( &nUTMZone, poDS->abyHeader + 24, 2 );
nUTMZone = CPL_LSBWORD16( nUTMZone );
GInt16 nDatum = 0;
memcpy( &nDatum, poDS->abyHeader + 26, 2 );
nDatum = CPL_LSBWORD16( nDatum );
GInt16 nHUnits = 0;
memcpy( &nHUnits, poDS->abyHeader + 22, 2 );
nHUnits = CPL_LSBWORD16( nHUnits );
if( nUTMZone != 0 )
oSRS.SetUTM( std::abs(static_cast<int>(nUTMZone)), nUTMZone > 0 );
else if( nHUnits != 0 )
oSRS.SetLocalCS( "Unknown" );
if( nHUnits == 1 )
oSRS.SetLinearUnits( SRS_UL_METER, 1.0 );
else if( nHUnits == 2 )
oSRS.SetLinearUnits( SRS_UL_FOOT, CPLAtof(SRS_UL_FOOT_CONV) );
else if( nHUnits == 3 )
oSRS.SetLinearUnits( SRS_UL_US_FOOT, CPLAtof(SRS_UL_US_FOOT_CONV) );
// Translate some of the more obvious old USGS datum codes
if( nDatum == 0 )
nDatum = 6201;
else if( nDatum == 1 )
nDatum = 6209;
else if( nDatum == 2 )
nDatum = 6210;
else if( nDatum == 3 )
nDatum = 6202;
else if( nDatum == 4 )
nDatum = 6203;
else if( nDatum == 6 )
nDatum = 6222;
else if( nDatum == 7 )
nDatum = 6230;
else if( nDatum == 13 )
nDatum = 6267;
else if( nDatum == 14 )
nDatum = 6269;
else if( nDatum == 17 )
nDatum = 6277;
else if( nDatum == 19 )
nDatum = 6284;
else if( nDatum == 21 )
nDatum = 6301;
else if( nDatum == 22 )
nDatum = 6322;
else if( nDatum == 23 )
nDatum = 6326;
if( !oSRS.IsLocal() )
{
if( nDatum >= 6000 )
{
char szName[32];
snprintf( szName, sizeof(szName), "EPSG:%d", nDatum-2000 );
oSRS.SetWellKnownGeogCS( szName );
}
else
oSRS.SetWellKnownGeogCS( "WGS84" );
}
}
/* -------------------------------------------------------------------- */
/* Convert coordinate system back to WKT. */
/* -------------------------------------------------------------------- */
if( oSRS.GetRoot() != NULL )
oSRS.exportToWkt( &poDS->pszProjection );
/* -------------------------------------------------------------------- */
/* Get georeferencing bounds. */
/* -------------------------------------------------------------------- */
if( poDS->nVersionCode >= 11 )
{
double dfLeft = 0.0;
memcpy( &dfLeft, poDS->abyHeader + 28, 8 );
CPL_LSBPTR64( &dfLeft );
double dfRight = 0.0;
memcpy( &dfRight, poDS->abyHeader + 36, 8 );
CPL_LSBPTR64( &dfRight );
double dfBottom = 0.0;
memcpy( &dfBottom, poDS->abyHeader + 44, 8 );
CPL_LSBPTR64( &dfBottom );
double dfTop = 0.0;
memcpy( &dfTop, poDS->abyHeader + 52, 8 );
CPL_LSBPTR64( &dfTop );
poDS->adfGeoTransform[0] = dfLeft;
poDS->adfGeoTransform[1] = (dfRight - dfLeft) / poDS->nRasterXSize;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = dfTop;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = (dfBottom - dfTop) / poDS->nRasterYSize;
poDS->bGeoTransformValid = TRUE;
}
/* -------------------------------------------------------------------- */
/* Re-open the file with the desired access. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb+" );
else
poDS->fpImage = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to re-open %s within BT driver.\n",
poOpenInfo->pszFilename );
delete poDS;
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Create band information objects */
/* -------------------------------------------------------------------- */
poDS->SetBand( 1, new BTRasterBand( poDS, poDS->fpImage, eType ) );
#ifdef notdef
poDS->bGeoTransformValid =
GDALReadWorldFile( poOpenInfo->pszFilename, ".wld",
poDS->adfGeoTransform );
#endif
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
CPLErr GDALWriteRPBFile( const char *pszFilename, char **papszMD )
{
CPLString osRPBFilename = CPLResetExtension( pszFilename, "RPB" );
/* -------------------------------------------------------------------- */
/* Read file and parse. */
/* -------------------------------------------------------------------- */
VSILFILE *fp = VSIFOpenL( osRPBFilename, "w" );
if( fp == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create %s for writing.\n%s",
osRPBFilename.c_str(), CPLGetLastErrorMsg() );
return CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Write the prefix information. */
/* -------------------------------------------------------------------- */
VSIFPrintfL( fp, "%s", "satId = \"QB02\";\n" );
VSIFPrintfL( fp, "%s", "bandId = \"P\";\n" );
VSIFPrintfL( fp, "%s", "SpecId = \"RPC00B\";\n" );
VSIFPrintfL( fp, "%s", "BEGIN_GROUP = IMAGE\n" );
VSIFPrintfL( fp, "%s", "\terrBias = 0.0;\n" );
VSIFPrintfL( fp, "%s", "\terrRand = 0.0;\n" );
/* -------------------------------------------------------------------- */
/* Write RPC values from our RPC metadata. */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; apszRPBMap[i] != NULL; i += 2 )
{
const char *pszRPBVal = CSLFetchNameValue( papszMD, apszRPBMap[i] );
const char *pszRPBTag;
if( pszRPBVal == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field missing in metadata, %s file not written.",
apszRPBMap[i], osRPBFilename.c_str() );
VSIFCloseL( fp );
VSIUnlink( osRPBFilename );
return CE_Failure;
}
pszRPBTag = apszRPBMap[i+1];
if( EQUALN(pszRPBTag,"IMAGE.",6) )
pszRPBTag += 6;
if( strstr(apszRPBMap[i], "COEF" ) == NULL )
{
VSIFPrintfL( fp, "\t%s = %s;\n", pszRPBTag, pszRPBVal );
}
else
{
// Reformat in brackets with commas over multiple lines.
VSIFPrintfL( fp, "\t%s = (\n", pszRPBTag );
char **papszItems = CSLTokenizeStringComplex( pszRPBVal, " ,",
FALSE, FALSE );
if( CSLCount(papszItems) != 20 )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s field is corrupt (not 20 values), %s file not written.\n%s = %s",
apszRPBMap[i], osRPBFilename.c_str(),
apszRPBMap[i], pszRPBVal );
VSIFCloseL( fp );
VSIUnlink( osRPBFilename );
CSLDestroy( papszItems );
return CE_Failure;
}
int j;
for( j = 0; j < 20; j++ )
{
if( j < 19 )
VSIFPrintfL( fp, "\t\t\t%s,\n", papszItems[j] );
else
VSIFPrintfL( fp, "\t\t\t%s);\n", papszItems[j] );
}
CSLDestroy( papszItems );
}
}
/* -------------------------------------------------------------------- */
/* Write end part */
/* -------------------------------------------------------------------- */
VSIFPrintfL( fp, "%s", "END_GROUP = IMAGE\n" );
VSIFPrintfL( fp, "END;\n" );
VSIFCloseL( fp );
return CE_None;
}
int OGRShapeDataSource::OpenFile( const char *pszNewName, int bUpdate,
int bTestOpen )
{
SHPHandle hSHP;
DBFHandle hDBF;
const char *pszExtension = CPLGetExtension( pszNewName );
(void) bTestOpen;
if( !EQUAL(pszExtension,"shp") && !EQUAL(pszExtension,"shx")
&& !EQUAL(pszExtension,"dbf") )
return FALSE;
/* -------------------------------------------------------------------- */
/* SHPOpen() should include better (CPL based) error reporting, */
/* and we should be trying to distinquish at this point whether */
/* failure is a result of trying to open a non-shapefile, or */
/* whether it was a shapefile and we want to report the error */
/* up. */
/* */
/* Care is taken to suppress the error and only reissue it if */
/* we think it is appropriate. */
/* -------------------------------------------------------------------- */
CPLPushErrorHandler( CPLQuietErrorHandler );
if( bUpdate )
hSHP = DS_SHPOpen( pszNewName, "r+" );
else
hSHP = DS_SHPOpen( pszNewName, "r" );
CPLPopErrorHandler();
if( hSHP == NULL
&& (!EQUAL(CPLGetExtension(pszNewName),"dbf")
|| strstr(CPLGetLastErrorMsg(),".shp") == NULL) )
{
CPLString osMsg = CPLGetLastErrorMsg();
CPLError( CE_Failure, CPLE_OpenFailed, "%s", osMsg.c_str() );
return FALSE;
}
CPLErrorReset();
/* -------------------------------------------------------------------- */
/* Open the .dbf file, if it exists. To open a dbf file, the */
/* filename has to either refer to a successfully opened shp */
/* file or has to refer to the actual .dbf file. */
/* -------------------------------------------------------------------- */
if( hSHP != NULL || EQUAL(CPLGetExtension(pszNewName),"dbf") )
{
if( bUpdate )
{
hDBF = DS_DBFOpen( pszNewName, "r+" );
if( hSHP != NULL && hDBF == NULL )
{
for(int i=0;i<2;i++)
{
VSIStatBufL sStat;
const char* pszDBFName = CPLResetExtension(pszNewName,
(i == 0 ) ? "dbf" : "DBF");
VSILFILE* fp = NULL;
if( VSIStatExL( pszDBFName, &sStat, VSI_STAT_EXISTS_FLAG) == 0 )
{
fp = VSIFOpenL(pszDBFName, "r+");
if (fp == NULL)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"%s exists, but cannot be opened in update mode",
pszDBFName );
SHPClose(hSHP);
return FALSE;
}
VSIFCloseL(fp);
break;
}
}
}
}
else
hDBF = DS_DBFOpen( pszNewName, "r" );
}
else
hDBF = NULL;
if( hDBF == NULL && hSHP == NULL )
return FALSE;
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRShapeLayer *poLayer;
poLayer = new OGRShapeLayer( this, pszNewName, hSHP, hDBF, NULL, FALSE, bUpdate,
wkbNone );
poLayer->SetModificationDate(
CSLFetchNameValue( papszOpenOptions, "DBF_DATE_LAST_UPDATE" ) );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
AddLayer(poLayer);
return TRUE;
}