int OGRGMLDataSource::Open( const char * pszNewName, int bTestOpen )
{
FILE *fp;
char szHeader[1000];
/* -------------------------------------------------------------------- */
/* Open the source file. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( pszNewName, "r" );
if( fp == NULL )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open GML file `%s'.",
pszNewName );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* If we aren't sure it is GML, load a header chunk and check */
/* for signs it is GML */
/* -------------------------------------------------------------------- */
if( bTestOpen )
{
size_t nRead = VSIFRead( szHeader, 1, sizeof(szHeader), fp );
if (nRead <= 0)
{
VSIFClose( fp );
return FALSE;
}
szHeader[MIN(nRead, sizeof(szHeader))-1] = '\0';
/* -------------------------------------------------------------------- */
/* Check for a UTF-8 BOM and skip if found */
/* */
/* TODO: BOM is variable-lenght parameter and depends on encoding. */
/* Add BOM detection for other encodings. */
/* -------------------------------------------------------------------- */
// Used to skip to actual beginning of XML data
char* szPtr = szHeader;
if( ( (unsigned char)szHeader[0] == 0xEF )
&& ( (unsigned char)szHeader[1] == 0xBB )
&& ( (unsigned char)szHeader[2] == 0xBF) )
{
szPtr += 3;
}
/* -------------------------------------------------------------------- */
/* Here, we expect the opening chevrons of GML tree root element */
/* -------------------------------------------------------------------- */
if( szPtr[0] != '<'
|| strstr(szPtr,"opengis.net/gml") == NULL )
{
VSIFClose( fp );
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* We assume now that it is GML. Close and instantiate a */
/* GMLReader on it. */
/* -------------------------------------------------------------------- */
VSIFClose( fp );
poReader = CreateGMLReader();
if( poReader == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File %s appears to be GML but the GML reader can't\n"
"be instantiated, likely because Xerces or Expat support wasn't\n"
"configured in.",
pszNewName );
return FALSE;
}
poReader->SetSourceFile( pszNewName );
pszName = CPLStrdup( pszNewName );
/* -------------------------------------------------------------------- */
/* Can we find a GML Feature Schema (.gfs) for the input file? */
/* -------------------------------------------------------------------- */
const char *pszGFSFilename;
VSIStatBuf sGFSStatBuf, sGMLStatBuf;
int bHaveSchema = FALSE;
pszGFSFilename = CPLResetExtension( pszNewName, "gfs" );
if( CPLStat( pszGFSFilename, &sGFSStatBuf ) == 0 )
{
CPLStat( pszNewName, &sGMLStatBuf );
if( sGMLStatBuf.st_mtime > sGFSStatBuf.st_mtime )
{
CPLDebug( "GML",
"Found %s but ignoring because it appears\n"
"be older than the associated GML file.",
pszGFSFilename );
}
else
{
bHaveSchema = poReader->LoadClasses( pszGFSFilename );
}
}
/* -------------------------------------------------------------------- */
/* Can we find an xsd which might conform to tbe GML3 Level 0 */
/* profile? We really ought to look for it based on the rules */
/* schemaLocation in the GML feature collection but for now we */
/* just hopes it is in the same director with the same name. */
/* -------------------------------------------------------------------- */
const char *pszXSDFilename;
if( !bHaveSchema )
{
pszXSDFilename = CPLResetExtension( pszNewName, "xsd" );
if( CPLStat( pszXSDFilename, &sGMLStatBuf ) == 0 )
{
bHaveSchema = poReader->ParseXSD( pszXSDFilename );
}
}
/* -------------------------------------------------------------------- */
/* Force a first pass to establish the schema. Eventually we */
/* will have mechanisms for remembering the schema and related */
/* information. */
/* -------------------------------------------------------------------- */
if( !bHaveSchema && !poReader->PrescanForSchema( TRUE ) )
{
// we assume an errors have been reported.
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Save the schema file if possible. Don't make a fuss if we */
/* can't ... could be read-only directory or something. */
/* -------------------------------------------------------------------- */
if( !bHaveSchema && !poReader->HasStoppedParsing())
{
FILE *fp = NULL;
pszGFSFilename = CPLResetExtension( pszNewName, "gfs" );
if( CPLStat( pszGFSFilename, &sGFSStatBuf ) != 0
&& (fp = VSIFOpen( pszGFSFilename, "wt" )) != NULL )
{
VSIFClose( fp );
poReader->SaveClasses( pszGFSFilename );
}
else
{
CPLDebug("GML",
"Not saving %s files already exists or can't be created.",
pszGFSFilename );
}
}
/* -------------------------------------------------------------------- */
/* Translate the GMLFeatureClasses into layers. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRGMLLayer **)
CPLCalloc( sizeof(OGRGMLLayer *), poReader->GetClassCount());
nLayers = 0;
while( nLayers < poReader->GetClassCount() )
{
papoLayers[nLayers] = TranslateGMLSchema(poReader->GetClass(nLayers));
nLayers++;
}
return TRUE;
}
/**
* Captures Geolocation information from a COSMO-SKYMED
* file.
* The geoid will always be WGS84
* The projection type may be UTM or UPS, depending on the
* latitude from the center of the image.
* @param iProductType type of CSK subproduct, see HDF5CSKProduct
*/
void HDF5ImageDataset::CaptureCSKGeolocation(int iProductType)
{
// Set the ellipsoid to WGS84.
oSRS.SetWellKnownGeogCS( "WGS84" );
if(iProductType == PROD_CSK_L1C||iProductType == PROD_CSK_L1D)
{
double *dfProjFalseEastNorth = NULL;
double *dfProjScaleFactor = NULL;
double *dfCenterCoord = NULL;
// Check if all the metadata attributes are present.
if(HDF5ReadDoubleAttr("Map Projection False East-North", &dfProjFalseEastNorth) == CE_Failure||
HDF5ReadDoubleAttr("Map Projection Scale Factor", &dfProjScaleFactor) == CE_Failure||
HDF5ReadDoubleAttr("Map Projection Centre", &dfCenterCoord) == CE_Failure||
GetMetadataItem("Projection_ID") == NULL)
{
pszProjection = CPLStrdup("");
pszGCPProjection = CPLStrdup("");
CPLError( CE_Failure, CPLE_OpenFailed,
"The CSK hdf5 file geolocation information is "
"malformed\n" );
}
else
{
// Fetch projection Type.
CPLString osProjectionID = GetMetadataItem("Projection_ID");
//If the projection is UTM
if(EQUAL(osProjectionID,"UTM"))
{
// @TODO: use SetUTM
oSRS.SetProjCS(SRS_PT_TRANSVERSE_MERCATOR);
oSRS.SetTM(dfCenterCoord[0],
dfCenterCoord[1],
dfProjScaleFactor[0],
dfProjFalseEastNorth[0],
dfProjFalseEastNorth[1]);
}
else
{
//TODO Test! I didn't had any UPS projected files to test!
//If the projection is UPS
if(EQUAL(osProjectionID,"UPS"))
{
oSRS.SetProjCS(SRS_PT_POLAR_STEREOGRAPHIC);
oSRS.SetPS(dfCenterCoord[0],
dfCenterCoord[1],
dfProjScaleFactor[0],
dfProjFalseEastNorth[0],
dfProjFalseEastNorth[1]);
}
}
//Export Projection to Wkt.
//In case of error then clean the projection
if (oSRS.exportToWkt(&pszProjection) != OGRERR_NONE)
pszProjection = CPLStrdup("");
CPLFree(dfCenterCoord);
CPLFree(dfProjScaleFactor);
CPLFree(dfProjFalseEastNorth);
}
}
else
{
//Export GCPProjection to Wkt.
//In case of error then clean the projection
if(oSRS.exportToWkt(&pszGCPProjection) != OGRERR_NONE)
pszGCPProjection = CPLStrdup("");
}
}
int OGRMySQLDataSource::Open( const char * pszNewName, int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* Verify MySQL prefix. */
/* -------------------------------------------------------------------- */
if( !EQUALN(pszNewName,"MYSQL:",6) )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not conform to MySQL naming convention,"
" MYSQL:dbname[, user=..][,password=..][,host=..][,port=..][tables=table;table;...]",
pszNewName );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Use options process to get .my.cnf file contents. */
/* -------------------------------------------------------------------- */
int nPort = 0, i;
char **papszTableNames=NULL;
std::string oHost, oPassword, oUser, oDB;
char *apszArgv[2] = { (char*) "org", NULL };
char **papszArgv = apszArgv;
int nArgc = 1;
const char *client_groups[] = {"client", "ogr", NULL };
my_init(); // I hope there is no problem with calling this multiple times!
load_defaults( "my", client_groups, &nArgc, &papszArgv );
for( i = 0; i < nArgc; i++ )
{
if( EQUALN(papszArgv[i],"--user="******"--host=",7) )
oHost = papszArgv[i] + 7;
else if( EQUALN(papszArgv[i],"--password="******"--port=",7) )
nPort = atoi(papszArgv[i] + 7);
}
// cleanup
free_defaults( papszArgv );
/* -------------------------------------------------------------------- */
/* Parse out connection information. */
/* -------------------------------------------------------------------- */
char **papszItems = CSLTokenizeString2( pszNewName+6, ",",
CSLT_HONOURSTRINGS );
if( CSLCount(papszItems) < 1 )
{
CSLDestroy( papszItems );
CPLError( CE_Failure, CPLE_AppDefined,
"MYSQL: request missing databasename." );
return FALSE;
}
oDB = papszItems[0];
for( i = 1; papszItems[i] != NULL; i++ )
{
if( EQUALN(papszItems[i],"user="******"password="******"host=",5) )
oHost = papszItems[i] + 5;
else if( EQUALN(papszItems[i],"port=",5) )
nPort = atoi(papszItems[i] + 5);
else if( EQUALN(papszItems[i],"tables=",7) )
{
papszTableNames = CSLTokenizeStringComplex(
papszItems[i] + 7, ";", FALSE, FALSE );
}
else
CPLError( CE_Warning, CPLE_AppDefined,
"'%s' in MYSQL datasource definition not recognised and ignored.", papszItems[i] );
}
CSLDestroy( papszItems );
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
hConn = mysql_init( NULL );
if( hConn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"mysql_init() failed." );
}
/* -------------------------------------------------------------------- */
/* Set desired options on the connection: charset and timeout. */
/* -------------------------------------------------------------------- */
if( hConn )
{
const char *pszTimeoutLength =
CPLGetConfigOption( "MYSQL_TIMEOUT", "0" );
unsigned int timeout = atoi(pszTimeoutLength);
mysql_options(hConn, MYSQL_OPT_CONNECT_TIMEOUT, (char*)&timeout);
mysql_options(hConn, MYSQL_SET_CHARSET_NAME, "utf8" );
}
/* -------------------------------------------------------------------- */
/* Perform connection. */
/* -------------------------------------------------------------------- */
if( hConn
&& mysql_real_connect( hConn,
oHost.length() ? oHost.c_str() : NULL,
oUser.length() ? oUser.c_str() : NULL,
oPassword.length() ? oPassword.c_str() : NULL,
oDB.length() ? oDB.c_str() : NULL,
nPort, NULL, CLIENT_INTERACTIVE ) == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"MySQL connect failed for: %s\n%s",
pszNewName + 6, mysql_error( hConn ) );
mysql_close( hConn );
hConn = NULL;
}
if( hConn == NULL )
{
CSLDestroy( papszTableNames );
return FALSE;
}
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
MYSQL_RES *hResultSet;
MYSQL_ROW papszRow;
if( mysql_query( hConn, "SHOW TABLES" ) )
{
ReportError( "SHOW TABLES Failed" );
return FALSE;
}
hResultSet = mysql_store_result( hConn );
if( hResultSet == NULL )
{
ReportError( "mysql_store_result() failed on SHOW TABLES result.");
return FALSE;
}
while( (papszRow = mysql_fetch_row( hResultSet )) != NULL )
{
if( papszRow[0] == NULL )
continue;
if( EQUAL(papszRow[0],"spatial_ref_sys")
|| EQUAL(papszRow[0],"geometry_columns") )
continue;
papszTableNames = CSLAddString(papszTableNames, papszRow[0] );
}
mysql_free_result( hResultSet );
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
// FIXME: This should be fixed to deal with tables
// for which we can't open because the name is bad/
OpenTable( papszTableNames[iRecord], bUpdate, FALSE );
}
CSLDestroy( papszTableNames );
return nLayers > 0 || bUpdate;
}
OGRLayer *
OGRMySQLDataSource::CreateLayer( const char * pszLayerNameIn,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
MYSQL_RES *hResult=NULL;
char szCommand[1024];
const char *pszGeometryType;
const char *pszGeomColumnName;
const char *pszExpectedFIDName;
char *pszLayerName;
int nDimension = 3; // MySQL only supports 2d currently
/* -------------------------------------------------------------------- */
/* Make sure there isn't an active transaction already. */
/* -------------------------------------------------------------------- */
InterruptLongResult();
if( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) )
pszLayerName = LaunderName( pszLayerNameIn );
else
pszLayerName = CPLStrdup( pszLayerNameIn );
if( wkbFlatten(eType) == eType )
nDimension = 2;
CPLDebug("MYSQL","Creating layer %s.", pszLayerName);
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( iLayer );
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszLayerName );
CPLFree( pszLayerName );
return NULL;
}
}
}
pszGeomColumnName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME" );
if (!pszGeomColumnName)
pszGeomColumnName="SHAPE";
pszExpectedFIDName = CSLFetchNameValue( papszOptions, "MYSQL_FID" );
if (!pszExpectedFIDName)
pszExpectedFIDName="OGR_FID";
CPLDebug("MYSQL","Geometry Column Name %s.", pszGeomColumnName);
CPLDebug("MYSQL","FID Column Name %s.", pszExpectedFIDName);
if( wkbFlatten(eType) == wkbNone )
{
sprintf( szCommand,
"CREATE TABLE `%s` ( "
" %s INT UNIQUE NOT NULL AUTO_INCREMENT )",
pszLayerName, pszExpectedFIDName );
}
else
{
sprintf( szCommand,
"CREATE TABLE `%s` ( "
" %s INT UNIQUE NOT NULL AUTO_INCREMENT, "
" %s GEOMETRY NOT NULL )",
pszLayerName, pszExpectedFIDName, pszGeomColumnName );
}
if( CSLFetchNameValue( papszOptions, "ENGINE" ) != NULL )
{
strcat( szCommand, " ENGINE = " );
strcat( szCommand, CSLFetchNameValue( papszOptions, "ENGINE" ) );
}
if( !mysql_query(GetConn(), szCommand ) )
{
if( mysql_field_count( GetConn() ) == 0 )
CPLDebug("MYSQL","Created table %s.", pszLayerName);
else
{
ReportError( szCommand );
return NULL;
}
}
else
{
ReportError( szCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
// Calling this does no harm
InitializeMetadataTables();
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
int nSRSId = -1;
if( poSRS != NULL )
nSRSId = FetchSRSId( poSRS );
/* -------------------------------------------------------------------- */
/* Sometimes there is an old crufty entry in the geometry_columns */
/* table if things were not properly cleaned up before. We make */
/* an effort to clean out such cruft. */
/* */
/* -------------------------------------------------------------------- */
sprintf( szCommand,
"DELETE FROM geometry_columns WHERE f_table_name = '%s'",
pszLayerName );
if( mysql_query(GetConn(), szCommand ) )
{
ReportError( szCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
/* -------------------------------------------------------------------- */
/* Attempt to add this table to the geometry_columns table, if */
/* it is a spatial layer. */
/* -------------------------------------------------------------------- */
if( eType != wkbNone )
{
int nCoordDimension;
if( eType == wkbFlatten(eType) )
nCoordDimension = 2;
else
nCoordDimension = 3;
switch( wkbFlatten(eType) )
{
case wkbPoint:
pszGeometryType = "POINT";
break;
case wkbLineString:
pszGeometryType = "LINESTRING";
break;
case wkbPolygon:
pszGeometryType = "POLYGON";
break;
case wkbMultiPoint:
pszGeometryType = "MULTIPOINT";
break;
case wkbMultiLineString:
pszGeometryType = "MULTILINESTRING";
break;
case wkbMultiPolygon:
pszGeometryType = "MULTIPOLYGON";
break;
case wkbGeometryCollection:
pszGeometryType = "GEOMETRYCOLLECTION";
break;
default:
pszGeometryType = "GEOMETRY";
break;
}
if( nSRSId == -1 )
sprintf( szCommand,
"INSERT INTO geometry_columns "
" (F_TABLE_NAME, "
" F_GEOMETRY_COLUMN, "
" COORD_DIMENSION, "
" TYPE) values "
" ('%s', '%s', %d, '%s')",
pszLayerName,
pszGeomColumnName,
nCoordDimension,
pszGeometryType );
else
sprintf( szCommand,
"INSERT INTO geometry_columns "
" (F_TABLE_NAME, "
" F_GEOMETRY_COLUMN, "
" COORD_DIMENSION, "
" SRID, "
" TYPE) values "
" ('%s', '%s', %d, %d, '%s')",
pszLayerName,
pszGeomColumnName,
nCoordDimension,
nSRSId,
pszGeometryType );
if( mysql_query(GetConn(), szCommand ) )
{
ReportError( szCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
}
/* -------------------------------------------------------------------- */
/* Create the spatial index. */
/* */
/* We're doing this before we add geometry and record to the table */
/* so this may not be exactly the best way to do it. */
/* -------------------------------------------------------------------- */
const char *pszSI = CSLFetchNameValue( papszOptions, "SPATIAL_INDEX" );
if( eType != wkbNone && (pszSI == NULL || CSLTestBoolean(pszSI)) )
{
sprintf( szCommand,
"ALTER TABLE `%s` ADD SPATIAL INDEX(`%s`) ",
pszLayerName,
pszGeomColumnName);
if( mysql_query(GetConn(), szCommand ) )
{
ReportError( szCommand );
return NULL;
}
// make sure to attempt to free results of successful queries
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRMySQLTableLayer *poLayer;
OGRErr eErr;
poLayer = new OGRMySQLTableLayer( this, pszLayerName, TRUE, nSRSId );
eErr = poLayer->Initialize(pszLayerName);
if (eErr == OGRERR_FAILURE)
return NULL;
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRMySQLLayer **)
CPLRealloc( papoLayers, sizeof(OGRMySQLLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszLayerName );
return poLayer;
}
CPLErr OGRIDBLayer::BuildFeatureDefn( const char *pszLayerName,
ITCursor *poCurr )
{
poFeatureDefn = new OGRFeatureDefn( pszLayerName );
SetDescription( poFeatureDefn->GetName() );
const ITTypeInfo * poInfo = poCurr->RowType();
int nRawColumns = poInfo->ColumnCount();
poFeatureDefn->Reference();
for( int iCol = 0; iCol < nRawColumns; iCol++ )
{
const char * pszColName = poInfo->ColumnName(iCol);
const ITTypeInfo * poTI = poInfo->ColumnType(iCol);
const char * pszTypName = poTI->Name();
OGRFieldDefn oField( pszColName, OFTString );
oField.SetWidth( MAX(0,poTI->Bound()) );
if ( pszGeomColumn != NULL && EQUAL(pszColName,pszGeomColumn) )
continue;
if ( EQUALN("st_", pszTypName, 3) && pszGeomColumn == NULL )
{
// We found spatial column!
pszGeomColumn = CPLStrdup(pszColName);
if ( EQUAL("st_point", pszTypName) )
poFeatureDefn->SetGeomType( wkbPoint );
else if ( EQUAL("st_linestring", pszTypName) )
poFeatureDefn->SetGeomType( wkbLineString );
else if ( EQUAL("st_polygon", pszTypName) )
poFeatureDefn->SetGeomType( wkbPolygon );
else if ( EQUAL("st_multipoint", pszTypName) )
poFeatureDefn->SetGeomType( wkbMultiPoint );
else if ( EQUAL("st_multilinestring", pszTypName) )
poFeatureDefn->SetGeomType( wkbMultiLineString );
else if ( EQUAL("st_multipolygon", pszTypName) )
poFeatureDefn->SetGeomType( wkbMultiPolygon );
continue;
}
// Check other field types
if ( EQUAL( pszTypName, "blob" ) ||
EQUAL( pszTypName, "byte" ) ||
EQUAL( pszTypName, "opaque" ) ||
EQUAL( pszTypName, "text" ) ||
EQUALN( pszTypName, "list", 4 ) ||
EQUALN( pszTypName, "collection", 10 ) ||
EQUALN( pszTypName, "row", 3 ) ||
EQUALN( pszTypName, "set", 3 ) )
{
CPLDebug( "OGR_IDB", "'%s' column type not supported yet. Column '%s'",
pszTypName, pszColName );
continue;
}
if ( EQUALN( pszTypName, "st_", 3 ) )
{
oField.SetType( OFTBinary );
}
else if ( EQUAL( pszTypName, "date" ) )
{
oField.SetType( OFTDate );
}
else if ( EQUAL( pszTypName, "datetime" ) )
{
oField.SetType( OFTDateTime );
}
else if ( EQUAL( pszTypName, "decimal" ) ||
EQUAL( pszTypName, "money" ) ||
EQUAL( pszTypName, "float" ) ||
EQUAL( pszTypName, "smallfloat" ) )
{
oField.SetType( OFTReal );
oField.SetPrecision( MAX( 0, poTI->Scale() ) ); // -1 for numeric
}
else if ( EQUAL( pszTypName, "integer" ) ||
EQUAL( pszTypName, "serial" ) )
{
oField.SetType( OFTInteger );
// 10 as hardcoded max int32 value length + 1 sig bit
oField.SetWidth( 11 );
}
else if ( EQUAL( pszTypName, "smallint" ) )
{
oField.SetType( OFTInteger );
// 5 as hardcoded max int16 value length + 1 sig bit
oField.SetWidth( 6 );
}
else
{
// leave as string:
// *char, character, character varing, *varchar
// interval. int8, serial8
}
poFeatureDefn->AddFieldDefn( &oField );
}
/* -------------------------------------------------------------------- */
/* If we don't already have an FID, check if there is a special */
/* FID named column available. */
/* -------------------------------------------------------------------- */
if( pszFIDColumn == NULL )
{
const char *pszOGR_FID = CPLGetConfigOption("IDB_OGR_FID","OGR_FID");
if( poFeatureDefn->GetFieldIndex( pszOGR_FID ) != -1 )
pszFIDColumn = CPLStrdup(pszOGR_FID);
}
if( pszFIDColumn != NULL )
CPLDebug( "OGR_IDB", "Using column %s as FID for table %s.",
pszFIDColumn, poFeatureDefn->GetName() );
else
CPLDebug( "OGR_IDB", "Table %s has no identified FID column.",
poFeatureDefn->GetName() );
return CE_None;
}
int S57ClassRegistrar::LoadInfo( const char * pszDirectory,
const char * pszProfile,
int bReportErr )
{
FILE *fp;
char szTargetFile[1024];
if( pszDirectory == NULL )
pszDirectory = CPLGetConfigOption("S57_CSV",NULL);
/* ==================================================================== */
/* Read the s57objectclasses file. */
/* ==================================================================== */
if( pszProfile == NULL )
pszProfile = CPLGetConfigOption( "S57_PROFILE", "" );
if( EQUAL(pszProfile, "Additional_Military_Layers") )
{
sprintf( szTargetFile, "s57objectclasses_%s.csv", "aml" );
}
else if ( EQUAL(pszProfile, "Inland_Waterways") )
{
sprintf( szTargetFile, "s57objectclasses_%s.csv", "iw" );
}
else if( strlen(pszProfile) > 0 )
{
sprintf( szTargetFile, "s57objectclasses_%s.csv", pszProfile );
}
else
{
strcpy( szTargetFile, "s57objectclasses.csv" );
}
if( !FindFile( szTargetFile, pszDirectory, bReportErr, &fp ) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Skip the line defining the column titles. */
/* -------------------------------------------------------------------- */
const char * pszLine = ReadLine( fp );
if( !EQUAL(pszLine,
"\"Code\",\"ObjectClass\",\"Acronym\",\"Attribute_A\","
"\"Attribute_B\",\"Attribute_C\",\"Class\",\"Primitives\"" ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"s57objectclasses columns don't match expected format!\n" );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Read and form string list. */
/* -------------------------------------------------------------------- */
CSLDestroy( papszClassesInfo );
papszClassesInfo = (char **) CPLCalloc(sizeof(char *),MAX_CLASSES);
nClasses = 0;
while( nClasses < MAX_CLASSES
&& (pszLine = ReadLine(fp)) != NULL )
{
papszClassesInfo[nClasses] = CPLStrdup(pszLine);
if( papszClassesInfo[nClasses] == NULL )
break;
nClasses++;
}
if( nClasses == MAX_CLASSES )
CPLError( CE_Warning, CPLE_AppDefined,
"MAX_CLASSES exceeded in S57ClassRegistrar::LoadInfo().\n" );
/* -------------------------------------------------------------------- */
/* Cleanup, and establish state. */
/* -------------------------------------------------------------------- */
if( fp != NULL )
VSIFClose( fp );
iCurrentClass = -1;
if( nClasses == 0 )
return FALSE;
/* ==================================================================== */
/* Read the attributes list. */
/* ==================================================================== */
if( EQUAL(pszProfile, "Additional_Military_Layers") )
{
sprintf( szTargetFile, "s57attributes_%s.csv", "aml" );
}
else if ( EQUAL(pszProfile, "Inland_Waterways") )
{
sprintf( szTargetFile, "s57attributes_%s.csv", "iw" );
}
else if( strlen(pszProfile) > 0 )
{
sprintf( szTargetFile, "s57attributes_%s.csv", pszProfile );
}
else
{
strcpy( szTargetFile, "s57attributes.csv" );
}
if( !FindFile( szTargetFile, pszDirectory, bReportErr, &fp ) )
return FALSE;
/* -------------------------------------------------------------------- */
/* Skip the line defining the column titles. */
/* -------------------------------------------------------------------- */
pszLine = ReadLine( fp );
if( !EQUAL(pszLine,
"\"Code\",\"Attribute\",\"Acronym\",\"Attributetype\",\"Class\"") )
{
CPLError( CE_Failure, CPLE_AppDefined,
"s57attributes columns don't match expected format!\n" );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Prepare arrays for the per-attribute information. */
/* -------------------------------------------------------------------- */
nAttrMax = MAX_ATTRIBUTES-1;
papszAttrNames = (char **) CPLCalloc(sizeof(char *),MAX_ATTRIBUTES);
papszAttrAcronym = (char **) CPLCalloc(sizeof(char *),MAX_ATTRIBUTES);
//papapszAttrValues = (char ***) CPLCalloc(sizeof(char **),MAX_ATTRIBUTES);
pachAttrType = (char *) CPLCalloc(sizeof(char),MAX_ATTRIBUTES);
pachAttrClass = (char *) CPLCalloc(sizeof(char),MAX_ATTRIBUTES);
panAttrIndex = (int *) CPLCalloc(sizeof(int),MAX_ATTRIBUTES);
/* -------------------------------------------------------------------- */
/* Read and form string list. */
/* -------------------------------------------------------------------- */
int iAttr;
while( (pszLine = ReadLine(fp)) != NULL )
{
char **papszTokens = CSLTokenizeStringComplex( pszLine, ",",
TRUE, TRUE );
if( CSLCount(papszTokens) < 5 )
{
CPLAssert( FALSE );
continue;
}
iAttr = atoi(papszTokens[0]);
if( iAttr < 0 || iAttr >= nAttrMax
|| papszAttrNames[iAttr] != NULL )
{
CPLDebug( "S57", "Duplicate definition for attribute %d:%s",
iAttr, papszTokens[2] );
continue;
}
papszAttrNames[iAttr] = CPLStrdup(papszTokens[1]);
papszAttrAcronym[iAttr] = CPLStrdup(papszTokens[2]);
pachAttrType[iAttr] = papszTokens[3][0];
pachAttrClass[iAttr] = papszTokens[4][0];
CSLDestroy( papszTokens );
}
if( fp != NULL )
VSIFClose( fp );
/* -------------------------------------------------------------------- */
/* Build unsorted index of attributes. */
/* -------------------------------------------------------------------- */
nAttrCount = 0;
for( iAttr = 0; iAttr < nAttrMax; iAttr++ )
{
if( papszAttrAcronym[iAttr] != NULL )
panAttrIndex[nAttrCount++] = iAttr;
}
/* -------------------------------------------------------------------- */
/* Sort index by acronym. */
/* -------------------------------------------------------------------- */
int bModified;
do
{
bModified = FALSE;
for( iAttr = 0; iAttr < nAttrCount-1; iAttr++ )
{
if( strcmp(papszAttrAcronym[panAttrIndex[iAttr]],
papszAttrAcronym[panAttrIndex[iAttr+1]]) > 0 )
{
int nTemp;
nTemp = panAttrIndex[iAttr];
panAttrIndex[iAttr] = panAttrIndex[iAttr+1];
panAttrIndex[iAttr+1] = nTemp;
bModified = TRUE;
}
}
} while( bModified );
return TRUE;
}
void DTEDDataset::SetFileName(const char* pszFilenameIn)
{
CPLFree(this->pszFilename);
this->pszFilename = CPLStrdup(pszFilenameIn);
}
int OGRMySQLDataSource::Open( const char * pszNewName, char** papszOpenOptionsIn,
int bUpdate )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* Use options process to get .my.cnf file contents. */
/* -------------------------------------------------------------------- */
int nPort = 0;
char **papszTableNames=NULL;
std::string oHost, oPassword, oUser, oDB;
CPLString osNewName(pszNewName);
const char* apszOpenOptions[] = { "dbname", "port", "user", "password",
"host", "tables"
};
for(int i=0; i <(int)(sizeof(apszOpenOptions)/sizeof(char*)); i++)
{
const char* pszVal = CSLFetchNameValue(papszOpenOptionsIn, apszOpenOptions[i]);
if( pszVal )
{
if( osNewName[osNewName.size()-1] != ':' )
osNewName += ",";
if( i > 0 )
{
osNewName += apszOpenOptions[i];
osNewName += "=";
}
if( EQUAL(apszOpenOptions[i], "tables") )
{
for( ; *pszVal; ++pszVal )
{
if( *pszVal == ',' )
osNewName += ";";
else
osNewName += *pszVal;
}
}
else
osNewName += pszVal;
}
}
/* -------------------------------------------------------------------- */
/* Parse out connection information. */
/* -------------------------------------------------------------------- */
char **papszItems = CSLTokenizeString2( osNewName+6, ",",
CSLT_HONOURSTRINGS );
if( CSLCount(papszItems) < 1 )
{
CSLDestroy( papszItems );
CPLError( CE_Failure, CPLE_AppDefined,
"MYSQL: request missing databasename." );
return FALSE;
}
oDB = papszItems[0];
for( int i = 1; papszItems[i] != NULL; i++ )
{
if( STARTS_WITH_CI(papszItems[i], "user="******"password="******"host=") )
oHost = papszItems[i] + 5;
else if( STARTS_WITH_CI(papszItems[i], "port=") )
nPort = atoi(papszItems[i] + 5);
else if( STARTS_WITH_CI(papszItems[i], "tables=") )
{
CSLDestroy(papszTableNames);
papszTableNames = CSLTokenizeStringComplex(
papszItems[i] + 7, ";", FALSE, FALSE );
}
else
CPLError( CE_Warning, CPLE_AppDefined,
"'%s' in MYSQL datasource definition not recognised and ignored.", papszItems[i] );
}
CSLDestroy( papszItems );
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
hConn = mysql_init( NULL );
if( hConn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"mysql_init() failed." );
}
/* -------------------------------------------------------------------- */
/* Set desired options on the connection: charset and timeout. */
/* -------------------------------------------------------------------- */
if( hConn )
{
const char *pszTimeoutLength =
CPLGetConfigOption( "MYSQL_TIMEOUT", "0" );
unsigned int timeout = atoi(pszTimeoutLength);
mysql_options(hConn, MYSQL_OPT_CONNECT_TIMEOUT, (char*)&timeout);
mysql_options(hConn, MYSQL_SET_CHARSET_NAME, "utf8" );
}
/* -------------------------------------------------------------------- */
/* Perform connection. */
/* -------------------------------------------------------------------- */
if( hConn
&& mysql_real_connect( hConn,
oHost.length() ? oHost.c_str() : NULL,
oUser.length() ? oUser.c_str() : NULL,
oPassword.length() ? oPassword.c_str() : NULL,
oDB.length() ? oDB.c_str() : NULL,
nPort, NULL, CLIENT_INTERACTIVE ) == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"MySQL connect failed for: %s\n%s",
pszNewName + 6, mysql_error( hConn ) );
mysql_close( hConn );
hConn = NULL;
}
if( hConn == NULL )
{
CSLDestroy( papszTableNames );
return FALSE;
}
else
{
// Enable automatic reconnection
// Must be called after mysql_real_connect() on MySQL < 5.0.19
// and at any point on more recent versions.
my_bool reconnect = 1;
mysql_options(hConn, MYSQL_OPT_RECONNECT, &reconnect);
}
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
MYSQL_RES *hResultSet;
MYSQL_ROW papszRow;
if( mysql_query( hConn, "SHOW TABLES" ) )
{
ReportError( "SHOW TABLES Failed" );
return FALSE;
}
hResultSet = mysql_store_result( hConn );
if( hResultSet == NULL )
{
ReportError( "mysql_store_result() failed on SHOW TABLES result.");
return FALSE;
}
while( (papszRow = mysql_fetch_row( hResultSet )) != NULL )
{
if( papszRow[0] == NULL )
continue;
if( EQUAL(papszRow[0],"spatial_ref_sys")
|| EQUAL(papszRow[0],"geometry_columns") )
continue;
papszTableNames = CSLAddString(papszTableNames, papszRow[0] );
}
mysql_free_result( hResultSet );
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
// FIXME: This should be fixed to deal with tables
// for which we can't open because the name is bad/
OpenTable( papszTableNames[iRecord], bUpdate );
}
CSLDestroy( papszTableNames );
return nLayers > 0 || bUpdate;
}
GDALDataset *ISIS3Dataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* Does this look like a CUBE dataset? */
/* -------------------------------------------------------------------- */
if( !Identify( poOpenInfo ) )
return NULL;
/* -------------------------------------------------------------------- */
/* Open the file using the large file API. */
/* -------------------------------------------------------------------- */
VSILFILE *fpQube = VSIFOpenL( poOpenInfo->pszFilename, "rb" );
if( fpQube == NULL )
return NULL;
ISIS3Dataset *poDS;
poDS = new ISIS3Dataset();
if( ! poDS->oKeywords.Ingest( fpQube, 0 ) )
{
VSIFCloseL( fpQube );
delete poDS;
return NULL;
}
VSIFCloseL( fpQube );
/* -------------------------------------------------------------------- */
/* Assume user is pointing to label (ie .lbl) file for detached option */
/* -------------------------------------------------------------------- */
// Image can be inline or detached and point to an image name
// the Format can be Tiled or Raw
// Object = Core
// StartByte = 65537
// Format = Tile
// TileSamples = 128
// TileLines = 128
//OR-----
// Object = Core
// StartByte = 1
// ^Core = r0200357_detatched.cub
// Format = BandSequential
//OR-----
// Object = Core
// StartByte = 1
// ^Core = r0200357_detached_tiled.cub
// Format = Tile
// TileSamples = 128
// TileLines = 128
/* -------------------------------------------------------------------- */
/* What file contains the actual data? */
/* -------------------------------------------------------------------- */
const char *pszCore = poDS->GetKeyword( "IsisCube.Core.^Core" );
CPLString osQubeFile;
if( EQUAL(pszCore,"") )
osQubeFile = poOpenInfo->pszFilename;
else
{
CPLString osPath = CPLGetPath( poOpenInfo->pszFilename );
osQubeFile = CPLFormFilename( osPath, pszCore, NULL );
poDS->osExternalCube = osQubeFile;
}
/* -------------------------------------------------------------------- */
/* Check if file an ISIS3 header file? Read a few lines of text */
/* searching for something starting with nrows or ncols. */
/* -------------------------------------------------------------------- */
GDALDataType eDataType = GDT_Byte;
OGRSpatialReference oSRS;
int nRows = -1;
int nCols = -1;
int nBands = 1;
int nSkipBytes = 0;
int tileSizeX = 0;
int tileSizeY = 0;
double dfULXMap=0.5;
double dfULYMap = 0.5;
double dfXDim = 1.0;
double dfYDim = 1.0;
double scaleFactor = 1.0;
double dfNoData = 0.0;
int bNoDataSet = FALSE;
char chByteOrder = 'M'; //default to MSB
char szLayout[32] = "BandSequential"; //default to band seq.
const char *target_name; //planet name
//projection parameters
const char *map_proj_name;
int bProjectionSet = TRUE;
char proj_target_name[200];
char geog_name[60];
char datum_name[60];
char sphere_name[60];
char bIsGeographic = TRUE;
double semi_major = 0.0;
double semi_minor = 0.0;
double iflattening = 0.0;
double center_lat = 0.0;
double center_lon = 0.0;
double first_std_parallel = 0.0;
double second_std_parallel = 0.0;
double radLat, localRadius;
VSILFILE *fp;
/************* Skipbytes *****************************/
nSkipBytes = atoi(poDS->GetKeyword("IsisCube.Core.StartByte","")) - 1;
/******* Grab format type (BandSequential, Tiled) *******/
const char *value;
value = poDS->GetKeyword( "IsisCube.Core.Format", "" );
if (EQUAL(value,"Tile") ) { //Todo
strcpy(szLayout,"Tiled");
/******* Get Tile Sizes *********/
tileSizeX = atoi(poDS->GetKeyword("IsisCube.Core.TileSamples",""));
tileSizeY = atoi(poDS->GetKeyword("IsisCube.Core.TileLines",""));
if (tileSizeX <= 0 || tileSizeY <= 0)
{
CPLError( CE_Failure, CPLE_OpenFailed, "Wrong tile dimensions : %d x %d",
tileSizeX, tileSizeY);
delete poDS;
return NULL;
}
}
else if (EQUAL(value,"BandSequential") )
strcpy(szLayout,"BSQ");
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout not supported. Abort\n\n", value);
delete poDS;
return NULL;
}
/*********** Grab samples lines band ************/
nCols = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Samples",""));
nRows = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Lines",""));
nBands = atoi(poDS->GetKeyword("IsisCube.Core.Dimensions.Bands",""));
/****** Grab format type - ISIS3 only supports 8,U16,S16,32 *****/
const char *itype;
itype = poDS->GetKeyword( "IsisCube.Core.Pixels.Type" );
if (EQUAL(itype,"UnsignedByte") ) {
eDataType = GDT_Byte;
dfNoData = NULL1;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"UnsignedWord") ) {
eDataType = GDT_UInt16;
dfNoData = NULL1;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"SignedWord") ) {
eDataType = GDT_Int16;
dfNoData = NULL2;
bNoDataSet = TRUE;
}
else if (EQUAL(itype,"Real") || EQUAL(value,"") ) {
eDataType = GDT_Float32;
dfNoData = NULL3;
bNoDataSet = TRUE;
}
else {
CPLError( CE_Failure, CPLE_OpenFailed,
"%s layout type not supported. Abort\n\n", itype);
delete poDS;
return NULL;
}
/*********** Grab samples lines band ************/
value = poDS->GetKeyword( "IsisCube.Core.Pixels.ByteOrder");
if (EQUAL(value,"Lsb"))
chByteOrder = 'I';
/*********** Grab Cellsize ************/
value = poDS->GetKeyword("IsisCube.Mapping.PixelResolution");
if (strlen(value) > 0 ) {
dfXDim = CPLAtof(value); /* values are in meters */
dfYDim = -CPLAtof(value);
}
/*********** Grab UpperLeftCornerY ************/
value = poDS->GetKeyword("IsisCube.Mapping.UpperLeftCornerY");
if (strlen(value) > 0) {
dfULYMap = CPLAtof(value);
}
/*********** Grab UpperLeftCornerX ************/
value = poDS->GetKeyword("IsisCube.Mapping.UpperLeftCornerX");
if( strlen(value) > 0 ) {
dfULXMap = CPLAtof(value);
}
/*********** Grab TARGET_NAME ************/
/**** This is the planets name i.e. Mars ***/
target_name = poDS->GetKeyword("IsisCube.Mapping.TargetName");
/*********** Grab MAP_PROJECTION_TYPE ************/
map_proj_name =
poDS->GetKeyword( "IsisCube.Mapping.ProjectionName");
/*********** Grab SEMI-MAJOR ************/
semi_major =
CPLAtof(poDS->GetKeyword( "IsisCube.Mapping.EquatorialRadius"));
/*********** Grab semi-minor ************/
semi_minor =
CPLAtof(poDS->GetKeyword( "IsisCube.Mapping.PolarRadius"));
/*********** Grab CENTER_LAT ************/
center_lat =
CPLAtof(poDS->GetKeyword( "IsisCube.Mapping.CenterLatitude"));
/*********** Grab CENTER_LON ************/
center_lon =
CPLAtof(poDS->GetKeyword( "IsisCube.Mapping.CenterLongitude"));
/*********** Grab 1st std parallel ************/
first_std_parallel =
CPLAtof(poDS->GetKeyword( "IsisCube.Mapping.FirstStandardParallel"));
/*********** Grab 2nd std parallel ************/
second_std_parallel =
CPLAtof(poDS->GetKeyword( "IsisCube.Mapping.SecondStandardParallel"));
/*********** Grab scaleFactor ************/
scaleFactor =
CPLAtof(poDS->GetKeyword( "IsisCube.Mapping.scaleFactor", "1.0"));
/*** grab LatitudeType = Planetographic ****/
// Need to further study how ocentric/ographic will effect the gdal library
// So far we will use this fact to define a sphere or ellipse for some
// projections
// Frank - may need to talk this over
value = poDS->GetKeyword("IsisCube.Mapping.LatitudeType");
if (EQUAL( value, "Planetocentric" ))
bIsGeographic = FALSE;
//Set oSRS projection and parameters
//############################################################
//ISIS3 Projection types
// Equirectangular
// LambertConformal
// Mercator
// ObliqueCylindrical //Todo
// Orthographic
// PolarStereographic
// SimpleCylindrical
// Sinusoidal
// TransverseMercator
#ifdef DEBUG
CPLDebug( "ISIS3", "using projection %s", map_proj_name);
#endif
if ((EQUAL( map_proj_name, "Equirectangular" )) ||
(EQUAL( map_proj_name, "SimpleCylindrical" )) ) {
oSRS.OGRSpatialReference::SetEquirectangular2 ( 0.0, center_lon, center_lat, 0, 0 );
} else if (EQUAL( map_proj_name, "Orthographic" )) {
oSRS.OGRSpatialReference::SetOrthographic ( center_lat, center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "Sinusoidal" )) {
oSRS.OGRSpatialReference::SetSinusoidal ( center_lon, 0, 0 );
} else if (EQUAL( map_proj_name, "Mercator" )) {
oSRS.OGRSpatialReference::SetMercator ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "PolarStereographic" )) {
oSRS.OGRSpatialReference::SetPS ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "TransverseMercator" )) {
oSRS.OGRSpatialReference::SetTM ( center_lat, center_lon, scaleFactor, 0, 0 );
} else if (EQUAL( map_proj_name, "LambertConformal" )) {
oSRS.OGRSpatialReference::SetLCC ( first_std_parallel, second_std_parallel, center_lat, center_lon, 0, 0 );
} else {
CPLDebug( "ISIS3",
"Dataset projection %s is not supported. Continuing...",
map_proj_name );
bProjectionSet = FALSE;
}
if (bProjectionSet) {
//Create projection name, i.e. MERCATOR MARS and set as ProjCS keyword
strcpy(proj_target_name, map_proj_name);
strcat(proj_target_name, " ");
strcat(proj_target_name, target_name);
oSRS.SetProjCS(proj_target_name); //set ProjCS keyword
//The geographic/geocentric name will be the same basic name as the body name
//'GCS' = Geographic/Geocentric Coordinate System
strcpy(geog_name, "GCS_");
strcat(geog_name, target_name);
//The datum name will be the same basic name as the planet
strcpy(datum_name, "D_");
strcat(datum_name, target_name);
strcpy(sphere_name, target_name);
//strcat(sphere_name, "_IAU_IAG"); //Might not be IAU defined so don't add
//calculate inverse flattening from major and minor axis: 1/f = a/(a-b)
if ((semi_major - semi_minor) < 0.0000001)
iflattening = 0;
else
iflattening = semi_major / (semi_major - semi_minor);
//Set the body size but take into consideration which proj is being used to help w/ proj4 compatibility
//The use of a Sphere, polar radius or ellipse here is based on how ISIS does it internally
if ( ( (EQUAL( map_proj_name, "Stereographic" ) && (fabs(center_lat) == 90)) ) ||
(EQUAL( map_proj_name, "PolarStereographic" )) )
{
if (bIsGeographic) {
//Geograpraphic, so set an ellipse
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere using the semi-minor axis. I hope...
strcat(sphere_name, "_polarRadius");
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_minor, 0.0,
"Reference_Meridian", 0.0 );
}
}
else if ( (EQUAL( map_proj_name, "SimpleCylindrical" )) ||
(EQUAL( map_proj_name, "Orthographic" )) ||
(EQUAL( map_proj_name, "Stereographic" )) ||
(EQUAL( map_proj_name, "Sinusoidal" )) ) {
//isis uses the sphereical equation for these projections so force a sphere
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
else if (EQUAL( map_proj_name, "Equirectangular" )) {
//Calculate localRadius using ISIS3 simple elliptical method
// not the more standard Radius of Curvature method
//PI = 4 * atan(1);
radLat = center_lat * PI / 180; // in radians
localRadius = semi_major * semi_minor / sqrt(pow(semi_minor*cos(radLat),2)
+ pow(semi_major*sin(radLat),2) );
strcat(sphere_name, "_localRadius");
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
localRadius, 0.0,
"Reference_Meridian", 0.0 );
}
else {
//All other projections: Mercator, Transverse Mercator, Lambert Conformal, etc.
//Geographic, so set an ellipse
if (bIsGeographic) {
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, iflattening,
"Reference_Meridian", 0.0 );
} else {
//Geocentric, so force a sphere. I hope...
oSRS.SetGeogCS( geog_name, datum_name, sphere_name,
semi_major, 0.0,
"Reference_Meridian", 0.0 );
}
}
// translate back into a projection string.
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
/* END ISIS3 Label Read */
/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
/* -------------------------------------------------------------------- */
/* Is the CUB detached - if so, reset name to binary file? */
/* -------------------------------------------------------------------- */
#ifdef notdef
// Frank - is this correct?
//The extension already added on so don't add another. But is this needed?
char *pszPath = CPLStrdup( CPLGetPath( poOpenInfo->pszFilename ) );
char *pszName = CPLStrdup( CPLGetBasename( poOpenInfo->pszFilename ) );
if (bIsDetached)
pszCUBFilename = CPLFormCIFilename( pszPath, detachedCub, "" );
#endif
/* -------------------------------------------------------------------- */
/* Did we get the required keywords? If not we return with */
/* this never having been considered to be a match. This isn't */
/* an error! */
/* -------------------------------------------------------------------- */
if( nRows < 1 || nCols < 1 || nBands < 1 )
{
delete poDS;
return NULL;
}
/* -------------------------------------------------------------------- */
/* Capture some information from the file that is of interest. */
/* -------------------------------------------------------------------- */
poDS->nRasterXSize = nCols;
poDS->nRasterYSize = nRows;
/* -------------------------------------------------------------------- */
/* Open target binary file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_ReadOnly )
poDS->fpImage = VSIFOpenL( osQubeFile, "r" );
else
poDS->fpImage = VSIFOpenL( osQubeFile, "r+" );
if( poDS->fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open %s with write permission.\n%s",
osQubeFile.c_str(),
VSIStrerror( errno ) );
delete poDS;
return NULL;
}
poDS->eAccess = poOpenInfo->eAccess;
/* -------------------------------------------------------------------- */
/* Compute the line offset. */
/* -------------------------------------------------------------------- */
int nItemSize = GDALGetDataTypeSize(eDataType)/8;
int nLineOffset=0, nPixelOffset=0, nBandOffset=0;
if( EQUAL(szLayout,"BSQ") )
{
nPixelOffset = nItemSize;
nLineOffset = nPixelOffset * nCols;
nBandOffset = nLineOffset * nRows;
}
else /* Tiled */
{
}
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
int i;
#ifdef CPL_LSB
int bNativeOrder = !(chByteOrder == 'M');
#else
int bNativeOrder = (chByteOrder == 'M');
#endif
for( i = 0; i < nBands; i++ )
{
GDALRasterBand *poBand;
if( EQUAL(szLayout,"Tiled") )
{
poBand = new ISISTiledBand( poDS, poDS->fpImage, i+1, eDataType,
tileSizeX, tileSizeY,
nSkipBytes, 0, 0,
bNativeOrder );
}
else
{
poBand =
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + nBandOffset * i,
nPixelOffset, nLineOffset, eDataType,
#ifdef CPL_LSB
chByteOrder == 'I' || chByteOrder == 'L',
#else
chByteOrder == 'M',
#endif
TRUE );
}
poDS->SetBand( i+1, poBand );
if( bNoDataSet )
((GDALPamRasterBand *) poBand)->SetNoDataValue( dfNoData );
// Set offset/scale values at the PAM level.
poBand->SetOffset(
CPLAtofM(poDS->GetKeyword("IsisCube.Core.Pixels.Base","0.0")));
poBand->SetScale(
CPLAtofM(poDS->GetKeyword("IsisCube.Core.Pixels.Multiplier","1.0")));
}
/* -------------------------------------------------------------------- */
/* Check for a .prj file. For ISIS3 I would like to keep this in */
/* -------------------------------------------------------------------- */
CPLString osPath, osName;
osPath = CPLGetPath( poOpenInfo->pszFilename );
osName = CPLGetBasename(poOpenInfo->pszFilename);
const char *pszPrjFile = CPLFormCIFilename( osPath, osName, "prj" );
fp = VSIFOpenL( pszPrjFile, "r" );
if( fp != NULL )
{
char **papszLines;
OGRSpatialReference oSRS;
VSIFCloseL( fp );
papszLines = CSLLoad( pszPrjFile );
if( oSRS.importFromESRI( papszLines ) == OGRERR_NONE )
{
char *pszResult = NULL;
oSRS.exportToWkt( &pszResult );
poDS->osProjection = pszResult;
CPLFree( pszResult );
}
CSLDestroy( papszLines );
}
if( dfULYMap != 0.5 || dfULYMap != 0.5 || dfXDim != 1.0 || dfYDim != 1.0 )
{
poDS->bGotTransform = TRUE;
poDS->adfGeoTransform[0] = dfULXMap;
poDS->adfGeoTransform[1] = dfXDim;
poDS->adfGeoTransform[2] = 0.0;
poDS->adfGeoTransform[3] = dfULYMap;
poDS->adfGeoTransform[4] = 0.0;
poDS->adfGeoTransform[5] = dfYDim;
}
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "cbw",
poDS->adfGeoTransform );
if( !poDS->bGotTransform )
poDS->bGotTransform =
GDALReadWorldFile( poOpenInfo->pszFilename, "wld",
poDS->adfGeoTransform );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return( poDS );
}
OGRDGNLayer::OGRDGNLayer( const char * pszName, DGNHandle hDGN,
int bUpdate )
{
this->hDGN = hDGN;
this->bUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Work out what link format we are using. */
/* -------------------------------------------------------------------- */
OGRFieldType eLinkFieldType;
pszLinkFormat = (char *) CPLGetConfigOption( "DGN_LINK_FORMAT", "FIRST" );
if( EQUAL(pszLinkFormat,"FIRST") )
eLinkFieldType = OFTInteger;
else if( EQUAL(pszLinkFormat,"LIST") )
eLinkFieldType = OFTIntegerList;
else if( EQUAL(pszLinkFormat,"STRING") )
eLinkFieldType = OFTString;
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"DGN_LINK_FORMAT=%s, but only FIRST, LIST or STRING supported.",
pszLinkFormat );
pszLinkFormat = (char *) "FIRST";
eLinkFieldType = OFTInteger;
}
pszLinkFormat = CPLStrdup(pszLinkFormat);
/* -------------------------------------------------------------------- */
/* Create the feature definition. */
/* -------------------------------------------------------------------- */
poFeatureDefn = new OGRFeatureDefn( pszName );
poFeatureDefn->Reference();
OGRFieldDefn oField( "", OFTInteger );
/* -------------------------------------------------------------------- */
/* Element type */
/* -------------------------------------------------------------------- */
oField.SetName( "Type" );
oField.SetType( OFTInteger );
oField.SetWidth( 2 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* Level number. */
/* -------------------------------------------------------------------- */
oField.SetName( "Level" );
oField.SetType( OFTInteger );
oField.SetWidth( 2 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* graphic group */
/* -------------------------------------------------------------------- */
oField.SetName( "GraphicGroup" );
oField.SetType( OFTInteger );
oField.SetWidth( 4 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* ColorIndex */
/* -------------------------------------------------------------------- */
oField.SetName( "ColorIndex" );
oField.SetType( OFTInteger );
oField.SetWidth( 3 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* Weight */
/* -------------------------------------------------------------------- */
oField.SetName( "Weight" );
oField.SetType( OFTInteger );
oField.SetWidth( 2 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* Style */
/* -------------------------------------------------------------------- */
oField.SetName( "Style" );
oField.SetType( OFTInteger );
oField.SetWidth( 1 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* EntityNum */
/* -------------------------------------------------------------------- */
oField.SetName( "EntityNum" );
oField.SetType( eLinkFieldType );
oField.SetWidth( 0 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* MSLink */
/* -------------------------------------------------------------------- */
oField.SetName( "MSLink" );
oField.SetType( eLinkFieldType );
oField.SetWidth( 0 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* Text */
/* -------------------------------------------------------------------- */
oField.SetName( "Text" );
oField.SetType( OFTString );
oField.SetWidth( 0 );
oField.SetPrecision( 0 );
poFeatureDefn->AddFieldDefn( &oField );
/* -------------------------------------------------------------------- */
/* Create template feature for evaluating simple expressions. */
/* -------------------------------------------------------------------- */
bHaveSimpleQuery = FALSE;
poEvalFeature = new OGRFeature( poFeatureDefn );
/* TODO: I am intending to keep track of simple attribute queries (ones
using only FID, Type and Level and short circuiting their operation
based on the index. However, there are some complexities with
complex elements, and spatial queries that have caused me to put it
off for now.
*/
}
int OGRARCGENDataSource::Open( const char * pszFilename, int bUpdateIn)
{
if (bUpdateIn)
{
return FALSE;
}
pszName = CPLStrdup( pszFilename );
// --------------------------------------------------------------------
// Does this appear to be a Arc/Info generate file?
// --------------------------------------------------------------------
VSILFILE* fp = VSIFOpenL(pszFilename, "rb");
if (fp == NULL)
return FALSE;
/* Check that the first line is compatible with a generate file */
/* and in particular contain >= 32 && <= 127 bytes */
char szFirstLine[256+1];
int nRet = VSIFReadL(szFirstLine, 1, 256, fp);
szFirstLine[nRet] = '\0';
int i;
int bFoundEOL = FALSE;
for(i=0;szFirstLine[i] != '\0';i++)
{
if (szFirstLine[i] == '\n' || szFirstLine[i] == '\r')
{
bFoundEOL = TRUE;
szFirstLine[i] = '\0';
break;
}
if (szFirstLine[i] < 32)
{
VSIFCloseL(fp);
return FALSE;
}
}
if (!bFoundEOL)
{
VSIFCloseL(fp);
return FALSE;
}
char** papszTokens = CSLTokenizeString2( szFirstLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
if (nTokens != 1 && nTokens != 3 && nTokens != 4)
{
VSIFCloseL(fp);
CSLDestroy(papszTokens);
return FALSE;
}
for(int i=0;i<nTokens;i++)
{
if( CPLGetValueType(papszTokens[i]) == CPL_VALUE_STRING )
{
VSIFCloseL(fp);
CSLDestroy(papszTokens);
return FALSE;
}
}
CSLDestroy(papszTokens);
/* Go to end of file, and count the number of END keywords */
/* If there's 1, it's a point layer */
/* If there's 2, it's a linestring or polygon layer */
VSIFSeekL( fp, 0, SEEK_END );
vsi_l_offset nSize = VSIFTellL(fp);
if (nSize < 10)
{
VSIFCloseL(fp);
return FALSE;
}
char szBuffer[10+1];
VSIFSeekL( fp, nSize - 10, SEEK_SET );
VSIFReadL( szBuffer, 1, 10, fp );
szBuffer[10] = '\0';
VSIFSeekL( fp, 0, SEEK_SET );
OGRwkbGeometryType eType;
const char* szPtr = szBuffer;
const char* szEnd = strstr(szPtr, "END");
if (szEnd == NULL) szEnd = strstr(szPtr, "end");
if (szEnd == NULL)
{
VSIFCloseL(fp);
return FALSE;
}
szPtr = szEnd + 3;
szEnd = strstr(szPtr, "END");
if (szEnd == NULL) szEnd = strstr(szPtr, "end");
if (szEnd == NULL)
{
const char* pszLine = CPLReadLine2L(fp,256,NULL);
if (pszLine == NULL)
{
VSIFCloseL(fp);
return FALSE;
}
char** papszTokens = CSLTokenizeString2( pszLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
CSLDestroy(papszTokens);
if (nTokens == 3)
eType = wkbPoint;
else if (nTokens == 4)
eType = wkbPoint25D;
else
{
VSIFCloseL(fp);
return FALSE;
}
}
else
{
int nLineNumber = 0;
eType = wkbUnknown;
CPLString osFirstX, osFirstY;
CPLString osLastX, osLastY;
int bIs3D = FALSE;
const char* pszLine;
while((pszLine = CPLReadLine2L(fp,256,NULL)) != NULL)
{
nLineNumber ++;
if (nLineNumber == 2)
{
char** papszTokens = CSLTokenizeString2( pszLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
if (nTokens == 2 || nTokens == 3)
{
if (nTokens == 3)
bIs3D = TRUE;
osFirstX = papszTokens[0];
osFirstY = papszTokens[1];
}
CSLDestroy(papszTokens);
if (nTokens != 2 && nTokens != 3)
break;
}
else if (nLineNumber > 2)
{
if (EQUAL(pszLine, "END"))
{
if (osFirstX.compare(osLastX) == 0 &&
osFirstY.compare(osLastY) == 0)
eType = (bIs3D) ? wkbPolygon25D : wkbPolygon;
else
eType = (bIs3D) ? wkbLineString25D : wkbLineString;
break;
}
char** papszTokens = CSLTokenizeString2( pszLine, " ,", 0 );
int nTokens = CSLCount(papszTokens);
if (nTokens == 2 || nTokens == 3)
{
osLastX = papszTokens[0];
osLastY = papszTokens[1];
}
CSLDestroy(papszTokens);
if (nTokens != 2 && nTokens != 3)
break;
}
}
if (eType == wkbUnknown)
{
VSIFCloseL(fp);
return FALSE;
}
}
VSIFSeekL( fp, 0, SEEK_SET );
nLayers = 1;
papoLayers = (OGRLayer**) CPLMalloc(sizeof(OGRLayer*));
papoLayers[0] = new OGRARCGENLayer(pszName, fp, eType);
return TRUE;
}
RPFToc* RPFTOCReadFromBuffer(const char* pszFilename, VSILFILE* fp, const char* tocHeader)
{
tocHeader += 1; /* skip endian */
tocHeader += 2; /* skip header length */
tocHeader += 12; /* skip file name : this should be A.TOC (padded) */
tocHeader += 1; /* skip new */
tocHeader += 15; /* skip standard_num */
tocHeader += 8; /* skip standard_date */
tocHeader += 1; /* skip classification */
tocHeader += 2; /* skip country */
tocHeader += 2; /* skip release */
unsigned int locationSectionPhysicalLocation;
memcpy(&locationSectionPhysicalLocation, tocHeader, sizeof(unsigned int));
CPL_MSBPTR32(&locationSectionPhysicalLocation);
if( VSIFSeekL( fp, locationSectionPhysicalLocation, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to locationSectionPhysicalLocation at offset %d.",
locationSectionPhysicalLocation );
return NULL;
}
int nSections;
NITFLocation* pasLocations = NITFReadRPFLocationTable(fp, &nSections);
unsigned int boundaryRectangleSectionSubHeaderPhysIndex = 0;
unsigned int boundaryRectangleTablePhysIndex = 0;
unsigned int frameFileIndexSectionSubHeaderPhysIndex = 0;
unsigned int frameFileIndexSubsectionPhysIndex = 0;
for( int i = 0; i < nSections; i++ )
{
if (pasLocations[i].nLocId == LID_BoundaryRectangleSectionSubheader)
{
boundaryRectangleSectionSubHeaderPhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_BoundaryRectangleTable)
{
boundaryRectangleTablePhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_FrameFileIndexSectionSubHeader)
{
frameFileIndexSectionSubHeaderPhysIndex = pasLocations[i].nLocOffset;
}
else if (pasLocations[i].nLocId == LID_FrameFileIndexSubsection)
{
frameFileIndexSubsectionPhysIndex = pasLocations[i].nLocOffset;
}
}
CPLFree(pasLocations);
if (boundaryRectangleSectionSubHeaderPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_BoundaryRectangleSectionSubheader." );
return NULL;
}
if (boundaryRectangleTablePhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_BoundaryRectangleTable." );
return NULL;
}
if (frameFileIndexSectionSubHeaderPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_FrameFileIndexSectionSubHeader." );
return NULL;
}
if (frameFileIndexSubsectionPhysIndex == 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Can't find LID_FrameFileIndexSubsection." );
return NULL;
}
if( VSIFSeekL( fp, boundaryRectangleSectionSubHeaderPhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to boundaryRectangleSectionSubHeaderPhysIndex at offset %d.",
boundaryRectangleSectionSubHeaderPhysIndex );
return NULL;
}
unsigned int boundaryRectangleTableOffset;
bool bOK = VSIFReadL( &boundaryRectangleTableOffset, sizeof(boundaryRectangleTableOffset), 1, fp) == 1;
CPL_MSBPTR32( &boundaryRectangleTableOffset );
unsigned short boundaryRectangleCount;
bOK &= VSIFReadL( &boundaryRectangleCount, sizeof(boundaryRectangleCount), 1, fp) == 1;
CPL_MSBPTR16( &boundaryRectangleCount );
if( !bOK || VSIFSeekL( fp, boundaryRectangleTablePhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to boundaryRectangleTablePhysIndex at offset %d.",
boundaryRectangleTablePhysIndex );
return NULL;
}
RPFToc* toc = reinterpret_cast<RPFToc *>( CPLMalloc( sizeof( RPFToc ) ) );
toc->nEntries = boundaryRectangleCount;
toc->entries = reinterpret_cast<RPFTocEntry *>(
CPLMalloc( boundaryRectangleCount * sizeof(RPFTocEntry) ) );
memset(toc->entries, 0, boundaryRectangleCount * sizeof(RPFTocEntry));
for( int i = 0; i < toc->nEntries; i++ )
{
toc->entries[i].isOverviewOrLegend = 0;
bOK &= VSIFReadL( toc->entries[i].type, 1, 5, fp) == 5;
toc->entries[i].type[5] = 0;
RPFTOCTrim(toc->entries[i].type);
bOK &= VSIFReadL( toc->entries[i].compression, 1, 5, fp) == 5;
toc->entries[i].compression[5] = 0;
RPFTOCTrim(toc->entries[i].compression);
bOK &= VSIFReadL( toc->entries[i].scale, 1, 12, fp) == 12;
toc->entries[i].scale[12] = 0;
RPFTOCTrim(toc->entries[i].scale);
if (toc->entries[i].scale[0] == '1' &&
toc->entries[i].scale[1] == ':')
{
memmove(toc->entries[i].scale,
toc->entries[i].scale+2,
strlen(toc->entries[i].scale+2)+1);
}
bOK &= VSIFReadL( toc->entries[i].zone, 1, 1, fp) == 1;
toc->entries[i].zone[1] = 0;
RPFTOCTrim(toc->entries[i].zone);
bOK &= VSIFReadL( toc->entries[i].producer, 1, 5, fp) == 5;
toc->entries[i].producer[5] = 0;
RPFTOCTrim(toc->entries[i].producer);
bOK &= VSIFReadL( &toc->entries[i].nwLat, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].nwLat);
bOK &= VSIFReadL( &toc->entries[i].nwLong, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].nwLong);
bOK &= VSIFReadL( &toc->entries[i].swLat, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].swLat);
bOK &= VSIFReadL( &toc->entries[i].swLong, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].swLong);
bOK &= VSIFReadL( &toc->entries[i].neLat, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].neLat);
bOK &= VSIFReadL( &toc->entries[i].neLong, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].neLong);
bOK &= VSIFReadL( &toc->entries[i].seLat, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].seLat);
bOK &= VSIFReadL( &toc->entries[i].seLong, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].seLong);
bOK &= VSIFReadL( &toc->entries[i].vertResolution, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].vertResolution);
bOK &= VSIFReadL( &toc->entries[i].horizResolution, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].horizResolution);
bOK &= VSIFReadL( &toc->entries[i].vertInterval, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].vertInterval);
bOK &= VSIFReadL( &toc->entries[i].horizInterval, sizeof(double), 1, fp) == 1;
CPL_MSBPTR64( &toc->entries[i].horizInterval);
bOK &= VSIFReadL( &toc->entries[i].nVertFrames, sizeof(int), 1, fp) == 1;
CPL_MSBPTR32( &toc->entries[i].nVertFrames );
bOK &= VSIFReadL( &toc->entries[i].nHorizFrames, sizeof(int), 1, fp) == 1;
CPL_MSBPTR32( &toc->entries[i].nHorizFrames );
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
toc->entries[i].nVertFrames = 0;
toc->entries[i].nHorizFrames = 0;
RPFTOCFree(toc);
return NULL;
}
if( toc->entries[i].nHorizFrames == 0 ||
toc->entries[i].nVertFrames == 0 ||
toc->entries[i].nHorizFrames > INT_MAX / toc->entries[i].nVertFrames )
{
toc->entries[i].frameEntries = NULL;
}
else
{
toc->entries[i].frameEntries = reinterpret_cast<RPFTocFrameEntry*>(
VSI_CALLOC_VERBOSE( toc->entries[i].nVertFrames * toc->entries[i].nHorizFrames,
sizeof(RPFTocFrameEntry) ) );
}
if (toc->entries[i].frameEntries == NULL)
{
toc->entries[i].nVertFrames = 0;
toc->entries[i].nHorizFrames = 0;
RPFTOCFree(toc);
return NULL;
}
CPLDebug("RPFTOC", "[%d] type=%s, compression=%s, scale=%s, zone=%s, producer=%s, nVertFrames=%d, nHorizFrames=%d",
i, toc->entries[i].type, toc->entries[i].compression, toc->entries[i].scale,
toc->entries[i].zone, toc->entries[i].producer, toc->entries[i].nVertFrames, toc->entries[i].nHorizFrames);
}
if( VSIFSeekL( fp, frameFileIndexSectionSubHeaderPhysIndex, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSectionSubHeaderPhysIndex at offset %d.",
frameFileIndexSectionSubHeaderPhysIndex );
RPFTOCFree(toc);
return NULL;
}
/* Skip 1 byte security classification */
bOK &= VSIFSeekL( fp, 1, SEEK_CUR ) == 0;
unsigned int frameIndexTableOffset;
bOK &= VSIFReadL( &frameIndexTableOffset, sizeof(frameIndexTableOffset), 1, fp) == 1;
CPL_MSBPTR32( &frameIndexTableOffset );
unsigned int nFrameFileIndexRecords;
bOK &= VSIFReadL( &nFrameFileIndexRecords, sizeof(nFrameFileIndexRecords), 1, fp) == 1;
CPL_MSBPTR32( &nFrameFileIndexRecords );
unsigned short nFrameFilePathnameRecords;
bOK &= VSIFReadL( &nFrameFilePathnameRecords, sizeof(nFrameFilePathnameRecords), 1, fp) == 1;
CPL_MSBPTR16( &nFrameFilePathnameRecords );
unsigned short frameFileIndexRecordLength;
bOK &= VSIFReadL( &frameFileIndexRecordLength, sizeof(frameFileIndexRecordLength), 1, fp) == 1;
CPL_MSBPTR16( &frameFileIndexRecordLength );
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return NULL;
}
int newBoundaryId = 0;
for( int i = 0; i < static_cast<int>( nFrameFileIndexRecords ); i++ )
{
if( VSIFSeekL( fp, frameFileIndexSubsectionPhysIndex + frameFileIndexRecordLength * i, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to frameFileIndexSubsectionPhysIndex(%d) at offset %d.",
i, frameFileIndexSubsectionPhysIndex + frameFileIndexRecordLength * i);
RPFTOCFree(toc);
return NULL;
}
unsigned short boundaryId;
if( VSIFReadL( &boundaryId, sizeof(boundaryId), 1, fp) != 1 )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return NULL;
}
CPL_MSBPTR16( &boundaryId );
if (i == 0 && boundaryId == 0)
newBoundaryId = 1;
if (newBoundaryId == 0)
boundaryId--;
if (boundaryId >= toc->nEntries)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad boundary id (%d) for frame file index %d.",
boundaryId, i);
RPFTOCFree(toc);
return NULL;
}
RPFTocEntry* entry = &toc->entries[boundaryId];
entry->boundaryId = boundaryId;
unsigned short frameRow;
bOK &= VSIFReadL( &frameRow, sizeof(frameRow), 1, fp) == 1;
CPL_MSBPTR16( &frameRow );
unsigned short frameCol;
bOK &= VSIFReadL( &frameCol, sizeof(frameCol), 1, fp) == 1;
CPL_MSBPTR16( &frameCol );
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return NULL;
}
if (newBoundaryId == 0)
{
frameRow--;
frameCol--;
}
else
{
/* Trick so that frames are numbered north to south */
frameRow = (unsigned short)((entry->nVertFrames-1) - frameRow);
}
if (frameRow >= entry->nVertFrames)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad row num (%d) for frame file index %d.",
frameRow, i);
RPFTOCFree(toc);
return NULL;
}
if (frameCol >= entry->nHorizFrames)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Bad col num (%d) for frame file index %d.",
frameCol, i);
RPFTOCFree(toc);
return NULL;
}
RPFTocFrameEntry* frameEntry
= &entry->frameEntries[frameRow * entry->nHorizFrames + frameCol ];
frameEntry->frameRow = frameRow;
frameEntry->frameCol = frameCol;
if (frameEntry->exists)
{
CPLError( CE_Warning, CPLE_AppDefined,
"Frame entry(%d,%d) for frame file index %d was already found.",
frameRow, frameCol, i);
CPLFree(frameEntry->directory);
frameEntry->directory = NULL;
CPLFree(frameEntry->fullFilePath);
frameEntry->fullFilePath = NULL;
frameEntry->exists = 0;
}
unsigned int offsetFrameFilePathName;
bOK &= VSIFReadL( &offsetFrameFilePathName, sizeof(offsetFrameFilePathName), 1, fp) == 1;
CPL_MSBPTR32( &offsetFrameFilePathName );
bOK &= VSIFReadL( frameEntry->filename, 1, 12, fp) == 12;
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return NULL;
}
frameEntry->filename[12] = '\0';
/* Check if the filename is an overview or legend */
for( int j = 0; j < 12; j++ )
{
if (strcmp(&(frameEntry->filename[j]),".OVR") == 0 ||
strcmp(&(frameEntry->filename[j]),".ovr") == 0 ||
strcmp(&(frameEntry->filename[j]),".LGD") == 0 ||
strcmp(&(frameEntry->filename[j]),".lgd") == 0)
{
entry->isOverviewOrLegend = TRUE;
break;
}
}
/* Extract series code */
if (entry->seriesAbbreviation == NULL)
{
const NITFSeries* series = NITFGetSeriesInfo(frameEntry->filename);
if (series)
{
entry->seriesAbbreviation = series->abbreviation;
entry->seriesName = series->name;
}
}
/* Get file geo reference */
bOK &= VSIFReadL( frameEntry->georef, 1, 6, fp) == 6;
frameEntry->georef[6] = '\0';
/* Go to start of pathname record */
/* New path_off offset from start of frame file index section of TOC?? */
/* Add pathoffset wrt frame file index table subsection (loc[3]) */
if( !bOK || VSIFSeekL( fp, frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName, SEEK_SET ) != 0)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Invalid TOC file. Unable to seek to "
"frameFileIndexSubsectionPhysIndex + "
"offsetFrameFilePathName(%d) at offset %d.",
i, frameFileIndexSubsectionPhysIndex + offsetFrameFilePathName);
RPFTOCFree(toc);
return NULL;
}
unsigned short pathLength;
bOK &= VSIFReadL( &pathLength, sizeof(pathLength), 1, fp) == 1;
CPL_MSBPTR16( &pathLength );
/* if nFrameFileIndexRecords == 65535 and pathLength == 65535 for each record,
this leads to 4 GB allocation... Protect against this case */
if (!bOK || pathLength > 256)
{
CPLError( CE_Failure, CPLE_NotSupported,
"Path length is big : %d. Probably corrupted TOC file.",
static_cast<int>( pathLength ) );
RPFTOCFree(toc);
return NULL;
}
frameEntry->directory = reinterpret_cast<char *>( CPLMalloc(pathLength+1) );
bOK &= VSIFReadL( frameEntry->directory, 1, pathLength, fp) == pathLength;
if( !bOK )
{
CPLError(CE_Failure, CPLE_FileIO, "I/O error");
RPFTOCFree(toc);
return NULL;
}
frameEntry->directory[pathLength] = 0;
if (pathLength > 0 && frameEntry->directory[pathLength-1] == '/')
frameEntry->directory[pathLength-1] = 0;
if (frameEntry->directory[0] == '.' && frameEntry->directory[1] == '/')
{
memmove(frameEntry->directory, frameEntry->directory+2, strlen(frameEntry->directory+2)+1);
// Some A.TOC have subdirectory names like ".//X/" ... (#5979)
// Check if it was not intended to be "./X/" instead.
VSIStatBufL sStatBuf;
if( frameEntry->directory[0] == '/' &&
VSIStatL(CPLFormFilename(CPLGetDirname(pszFilename), frameEntry->directory+1, NULL), &sStatBuf) == 0 &&
VSI_ISDIR(sStatBuf.st_mode) )
{
memmove(frameEntry->directory, frameEntry->directory+1, strlen(frameEntry->directory+1)+1);
}
}
{
char* baseDir = CPLStrdup(CPLGetDirname(pszFilename));
VSIStatBufL sStatBuf;
char* subdir;
if (CPLIsFilenameRelative(frameEntry->directory) == FALSE)
subdir = CPLStrdup(frameEntry->directory);
else if (frameEntry->directory[0] == '.' && frameEntry->directory[1] == 0)
subdir = CPLStrdup(baseDir);
else
subdir = CPLStrdup(CPLFormFilename(baseDir, frameEntry->directory, NULL));
#if !defined(_WIN32) && !defined(_WIN32_CE)
if( VSIStatL( subdir, &sStatBuf ) != 0 && strlen(subdir) > strlen(baseDir) && subdir[strlen(baseDir)] != 0)
{
char* c = subdir + strlen(baseDir)+1;
while(*c)
{
if (*c >= 'A' && *c <= 'Z')
*c += 'a' - 'A';
c++;
}
}
#endif
frameEntry->fullFilePath = CPLStrdup(CPLFormFilename(
subdir,
frameEntry->filename, NULL));
if( VSIStatL( frameEntry->fullFilePath, &sStatBuf ) != 0 )
{
#if !defined(_WIN32) && !defined(_WIN32_CE)
char* c = frameEntry->fullFilePath + strlen(subdir)+1;
while(*c)
{
if (*c >= 'A' && *c <= 'Z')
*c += 'a' - 'A';
c++;
}
if( VSIStatL( frameEntry->fullFilePath, &sStatBuf ) != 0 )
#endif
{
frameEntry->fileExists = 0;
CPLError( CE_Warning, CPLE_AppDefined,
"File %s does not exist.", frameEntry->fullFilePath );
}
#if !defined(_WIN32) && !defined(_WIN32_CE)
else
{
frameEntry->fileExists = 1;
}
#endif
}
else
{
frameEntry->fileExists = 1;
}
CPLFree(subdir);
CPLFree(baseDir);
}
CPLDebug("RPFTOC", "Entry %d : %s,%s (%d, %d)", boundaryId, frameEntry->directory, frameEntry->filename, frameRow, frameCol);
frameEntry->exists = 1;
}
return toc;
}
static GDALDataset *OGRSQLiteDriverOpen( GDALOpenInfo* poOpenInfo )
{
if( OGRSQLiteDriverIdentify(poOpenInfo) == FALSE )
return NULL;
/* -------------------------------------------------------------------- */
/* Check VirtualShape:xxx.shp syntax */
/* -------------------------------------------------------------------- */
int nLen = (int) strlen(poOpenInfo->pszFilename);
if (EQUALN(poOpenInfo->pszFilename, "VirtualShape:", strlen( "VirtualShape:" )) &&
nLen > 4 && EQUAL(poOpenInfo->pszFilename + nLen - 4, ".SHP"))
{
OGRSQLiteDataSource *poDS;
poDS = new OGRSQLiteDataSource();
char** papszOptions = CSLAddString(NULL, "SPATIALITE=YES");
int nRet = poDS->Create( ":memory:", papszOptions );
poDS->SetDescription(poOpenInfo->pszFilename);
CSLDestroy(papszOptions);
if (!nRet)
{
delete poDS;
return NULL;
}
char* pszSQLiteFilename = CPLStrdup(poOpenInfo->pszFilename + strlen( "VirtualShape:" ));
GDALDataset* poSQLiteDS = (GDALDataset*) GDALOpenEx(pszSQLiteFilename,
GDAL_OF_VECTOR, NULL, NULL, NULL);
if (poSQLiteDS == NULL)
{
CPLFree(pszSQLiteFilename);
delete poDS;
return NULL;
}
delete poSQLiteDS;
char* pszLastDot = strrchr(pszSQLiteFilename, '.');
if (pszLastDot)
*pszLastDot = '\0';
const char* pszTableName = CPLGetBasename(pszSQLiteFilename);
char* pszSQL = CPLStrdup(CPLSPrintf("CREATE VIRTUAL TABLE %s USING VirtualShape(%s, CP1252, -1)",
pszTableName, pszSQLiteFilename));
poDS->ExecuteSQL(pszSQL, NULL, NULL);
CPLFree(pszSQL);
CPLFree(pszSQLiteFilename);
poDS->SetUpdate(FALSE);
return poDS;
}
/* -------------------------------------------------------------------- */
/* We think this is really an SQLite database, go ahead and try */
/* and open it. */
/* -------------------------------------------------------------------- */
OGRSQLiteDataSource *poDS;
poDS = new OGRSQLiteDataSource();
if( !poDS->Open( poOpenInfo->pszFilename, poOpenInfo->eAccess == GA_Update,
poOpenInfo->papszOpenOptions ) )
{
delete poDS;
return NULL;
}
else
return poDS;
}
int OGRGMLDataSource::Create( const char *pszFilename,
char **papszOptions )
{
if( fpOutput != NULL || poReader != NULL )
{
CPLAssert( FALSE );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Create the output file. */
/* -------------------------------------------------------------------- */
pszName = CPLStrdup( pszFilename );
if( EQUAL(pszFilename,"stdout") )
fpOutput = stdout;
else
fpOutput = VSIFOpen( pszFilename, "wt+" );
if( fpOutput == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to create GML file %s.",
pszFilename );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Write out "standard" header. */
/* -------------------------------------------------------------------- */
VSIFPrintf( fpOutput, "%s",
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" );
nSchemaInsertLocation = VSIFTell( fpOutput );
VSIFPrintf( fpOutput, "%s",
"<ogr:FeatureCollection\n" );
/* -------------------------------------------------------------------- */
/* Write out schema info if provided in creation options. */
/* -------------------------------------------------------------------- */
const char *pszSchemaURI = CSLFetchNameValue(papszOptions,"XSISCHEMAURI");
const char *pszSchemaOpt = CSLFetchNameValue( papszOptions, "XSISCHEMA" );
if( pszSchemaURI != NULL )
{
VSIFPrintf( fpOutput,
" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
" xsi:schemaLocation=\"%s\"\n",
CSLFetchNameValue( papszOptions, "XSISCHEMAURI" ) );
}
else if( pszSchemaOpt == NULL || EQUAL(pszSchemaOpt,"EXTERNAL") )
{
char *pszBasename = CPLStrdup(CPLGetBasename( pszName ));
VSIFPrintf( fpOutput,
" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
" xsi:schemaLocation=\"http://ogr.maptools.org/ %s\"\n",
CPLResetExtension( pszBasename, "xsd" ) );
CPLFree( pszBasename );
}
VSIFPrintf( fpOutput, "%s",
" xmlns:ogr=\"http://ogr.maptools.org/\"\n" );
VSIFPrintf( fpOutput, "%s",
" xmlns:gml=\"http://www.opengis.net/gml\">\n" );
/* -------------------------------------------------------------------- */
/* Should we initialize an area to place the boundedBy element? */
/* We will need to seek back to fill it in. */
/* -------------------------------------------------------------------- */
if( CSLFetchBoolean( papszOptions, "BOUNDEDBY", TRUE ) )
{
nBoundedByLocation = VSIFTell( fpOutput );
if( nBoundedByLocation != -1 )
VSIFPrintf( fpOutput, "%280s\n", "" );
}
else
nBoundedByLocation = -1;
return TRUE;
}
void GDALDefaultOverviews::OverviewScan()
{
if( bCheckedForOverviews || poDS == nullptr )
return;
bCheckedForOverviews = true;
static thread_local int nAntiRecursionCounter = 0;
// arbitrary number. 32 should be enough to handle a .ovr.ovr.ovr...
if( nAntiRecursionCounter == 64 )
return;
++nAntiRecursionCounter;
CPLDebug( "GDAL", "GDALDefaultOverviews::OverviewScan()" );
/* -------------------------------------------------------------------- */
/* Open overview dataset if it exists. */
/* -------------------------------------------------------------------- */
if( pszInitName == nullptr )
pszInitName = CPLStrdup(poDS->GetDescription());
if( !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
if( bInitNameIsOVR )
osOvrFilename = pszInitName;
else
osOvrFilename.Printf( "%s.ovr", pszInitName );
std::vector<char> achOvrFilename;
achOvrFilename.resize(osOvrFilename.size() + 1);
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bool bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
#if !defined(WIN32)
if( !bInitNameIsOVR && !bExists && !papszInitSiblingFiles )
{
osOvrFilename.Printf( "%s.OVR", pszInitName );
memcpy(&(achOvrFilename[0]),
osOvrFilename.c_str(),
osOvrFilename.size() + 1);
bExists = CPL_TO_BOOL(
CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) );
osOvrFilename = &achOvrFilename[0];
if( !bExists )
osOvrFilename.Printf( "%s.ovr", pszInitName );
}
#endif
if( bExists )
{
poODS = GDALDataset::Open(
osOvrFilename,
GDAL_OF_RASTER |
(poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0),
nullptr, nullptr, papszInitSiblingFiles );
}
}
/* -------------------------------------------------------------------- */
/* We didn't find that, so try and find a corresponding aux */
/* file. Check that we are the dependent file of the aux */
/* file. */
/* */
/* We only use the .aux file for overviews if they already have */
/* overviews existing, or if USE_RRD is set true. */
/* -------------------------------------------------------------------- */
if( !poODS && !EQUAL(pszInitName,":::VIRTUAL:::") &&
GDALCanFileAcceptSidecarFile(pszInitName) )
{
bool bTryFindAssociatedAuxFile = true;
if( papszInitSiblingFiles )
{
CPLString osAuxFilename = CPLResetExtension( pszInitName, "aux");
int iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
{
osAuxFilename = pszInitName;
osAuxFilename += ".aux";
iSibling = CSLFindString( papszInitSiblingFiles,
CPLGetFilename(osAuxFilename) );
if( iSibling < 0 )
bTryFindAssociatedAuxFile = false;
}
}
if( bTryFindAssociatedAuxFile )
{
poODS = GDALFindAssociatedAuxFile( pszInitName, poDS->GetAccess(),
poDS );
}
if( poODS )
{
const bool bUseRRD = CPLTestBool(CPLGetConfigOption("USE_RRD","NO"));
bOvrIsAux = true;
if( GetOverviewCount(1) == 0 && !bUseRRD )
{
bOvrIsAux = false;
GDALClose( poODS );
poODS = nullptr;
}
else
{
osOvrFilename = poODS->GetDescription();
}
}
}
/* -------------------------------------------------------------------- */
/* If we still don't have an overview, check to see if we have */
/* overview metadata referencing a remote (i.e. proxy) or local */
/* subdataset overview dataset. */
/* -------------------------------------------------------------------- */
if( poODS == nullptr )
{
const char *pszProxyOvrFilename =
poDS->GetMetadataItem( "OVERVIEW_FILE", "OVERVIEWS" );
if( pszProxyOvrFilename != nullptr )
{
if( STARTS_WITH_CI(pszProxyOvrFilename, ":::BASE:::") )
{
const CPLString osPath = CPLGetPath(poDS->GetDescription());
osOvrFilename =
CPLFormFilename( osPath, pszProxyOvrFilename+10, nullptr );
}
else
{
osOvrFilename = pszProxyOvrFilename;
}
CPLPushErrorHandler(CPLQuietErrorHandler);
poODS = GDALDataset::Open(osOvrFilename,
GDAL_OF_RASTER | (poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE: 0));
CPLPopErrorHandler();
}
}
/* -------------------------------------------------------------------- */
/* If we have an overview dataset, then mark all the overviews */
/* with the base dataset Used later for finding overviews */
/* masks. Uggg. */
/* -------------------------------------------------------------------- */
if( poODS )
{
const int nOverviewCount = GetOverviewCount(1);
for( int iOver = 0; iOver < nOverviewCount; iOver++ )
{
GDALRasterBand * const poBand = GetOverview( 1, iOver );
GDALDataset * const poOverDS = poBand != nullptr ?
poBand->GetDataset() : nullptr;
if( poOverDS != nullptr )
{
poOverDS->oOvManager.poBaseDS = poDS;
poOverDS->oOvManager.poDS = poOverDS;
}
}
}
--nAntiRecursionCounter;
}
int OGRVRTDataSource::Initialize( CPLXMLNode *psTree, const char *pszNewName,
int bUpdate )
{
CPLAssert( nLayers == 0 );
this->psTree = psTree;
/* -------------------------------------------------------------------- */
/* Set name, and capture the directory path so we can use it */
/* for relative datasources. */
/* -------------------------------------------------------------------- */
CPLString osVRTDirectory = CPLGetPath( pszNewName );
pszName = CPLStrdup( pszNewName );
/* -------------------------------------------------------------------- */
/* Look for the OGRVRTDataSource node, it might be after an */
/* <xml> node. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psVRTDSXML = CPLGetXMLNode( psTree, "=OGRVRTDataSource" );
if( psVRTDSXML == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Did not find the <OGRVRTDataSource> node in the root of the document,\n"
"this is not really an OGR VRT." );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Determine if we must proxy layers. */
/* -------------------------------------------------------------------- */
int nOGRVRTLayerCount = CountOGRVRTLayers(psVRTDSXML);
int nMaxSimultaneouslyOpened = atoi(CPLGetConfigOption("OGR_VRT_MAX_OPENED", "100"));
if( nMaxSimultaneouslyOpened < 1 )
nMaxSimultaneouslyOpened = 1;
if( nOGRVRTLayerCount > nMaxSimultaneouslyOpened )
poLayerPool = new OGRLayerPool(nMaxSimultaneouslyOpened);
/* -------------------------------------------------------------------- */
/* Apply any dataset level metadata. */
/* -------------------------------------------------------------------- */
oMDMD.XMLInit( psVRTDSXML, TRUE );
/* -------------------------------------------------------------------- */
/* Look for layers. */
/* -------------------------------------------------------------------- */
CPLXMLNode *psLTree;
for( psLTree=psVRTDSXML->psChild; psLTree != NULL; psLTree=psLTree->psNext )
{
if( psLTree->eType != CXT_Element )
continue;
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRLayer *poLayer = InstanciateLayer(psLTree, osVRTDirectory, bUpdate);
if( poLayer == NULL )
continue;
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
nLayers ++;
papoLayers = (OGRLayer **)
CPLRealloc( papoLayers, sizeof(OGRLayer *) * nLayers );
papoLayers[nLayers-1] = poLayer;
paeLayerType = (OGRLayerType*)
CPLRealloc( paeLayerType, sizeof(int) * nLayers );
if( poLayerPool != NULL && EQUAL(psLTree->pszValue,"OGRVRTLayer"))
{
paeLayerType[nLayers - 1] = OGR_VRT_PROXIED_LAYER;
}
else if( EQUAL(psLTree->pszValue,"OGRVRTLayer") )
{
paeLayerType[nLayers - 1] = OGR_VRT_LAYER;
}
else
{
paeLayerType[nLayers - 1] = OGR_VRT_OTHER_LAYER;
}
}
return TRUE;
}
int OGRIdrisiDataSource::Open( const char * pszFilename )
{
pszName = CPLStrdup( pszFilename );
VSILFILE* fpVCT = VSIFOpenL(pszFilename, "rb");
if (fpVCT == NULL)
return FALSE;
char* pszWTKString = NULL;
// --------------------------------------------------------------------
// Look for .vdc file
// --------------------------------------------------------------------
const char* pszVDCFilename = CPLResetExtension(pszFilename, "vdc");
VSILFILE* fpVDC = VSIFOpenL(pszVDCFilename, "rb");
if (fpVDC == NULL)
{
pszVDCFilename = CPLResetExtension(pszFilename, "VDC");
fpVDC = VSIFOpenL(pszVDCFilename, "rb");
}
char** papszVDC = NULL;
if (fpVDC != NULL)
{
VSIFCloseL(fpVDC);
fpVDC = NULL;
CPLPushErrorHandler(CPLQuietErrorHandler);
papszVDC = CSLLoad2(pszVDCFilename, 1024, 256, NULL);
CPLPopErrorHandler();
CPLErrorReset();
}
OGRwkbGeometryType eType = wkbUnknown;
if (papszVDC != NULL)
{
CSLSetNameValueSeparator( papszVDC, ":" );
const char *pszVersion = CSLFetchNameValue( papszVDC, "file format " );
if( pszVersion == NULL || !EQUAL( pszVersion, "IDRISI Vector A.1" ) )
{
CSLDestroy( papszVDC );
VSIFCloseL(fpVCT);
return FALSE;
}
const char *pszRefSystem
= CSLFetchNameValue( papszVDC, "ref. system " );
const char *pszRefUnits = CSLFetchNameValue( papszVDC, "ref. units " );
if (pszRefSystem != NULL && pszRefUnits != NULL)
IdrisiGeoReference2Wkt( pszFilename, pszRefSystem, pszRefUnits,
&pszWTKString);
}
GByte chType;
if (VSIFReadL(&chType, 1, 1, fpVCT) != 1)
{
VSIFCloseL(fpVCT);
CSLDestroy( papszVDC );
return FALSE;
}
if (chType == 1)
eType = wkbPoint;
else if (chType == 2)
eType = wkbLineString;
else if (chType == 3)
eType = wkbPolygon;
else
{
CPLError( CE_Failure, CPLE_AppDefined, "Unsupport geometry type : %d",
static_cast<int>(chType) );
VSIFCloseL(fpVCT);
CSLDestroy( papszVDC );
return FALSE;
}
const char *pszMinX = CSLFetchNameValue( papszVDC, "min. X " );
const char *pszMaxX = CSLFetchNameValue( papszVDC, "max. X " );
const char *pszMinY = CSLFetchNameValue( papszVDC, "min. Y " );
const char *pszMaxY = CSLFetchNameValue( papszVDC, "max. Y " );
OGRIdrisiLayer* poLayer = new OGRIdrisiLayer(pszFilename,
CPLGetBasename(pszFilename),
fpVCT, eType, pszWTKString);
papoLayers = static_cast<OGRLayer**>( CPLMalloc(sizeof(OGRLayer*)) );
papoLayers[nLayers ++] = poLayer;
if( pszMinX != NULL && pszMaxX != NULL && pszMinY != NULL &&
pszMaxY != NULL)
{
poLayer->SetExtent(
CPLAtof(pszMinX), CPLAtof(pszMinY), CPLAtof(pszMaxX),
CPLAtof(pszMaxY) );
}
CPLFree(pszWTKString);
CSLDestroy( papszVDC );
return TRUE;
}
int OGRILI1DataSource::Open( const char * pszNewName, int bTestOpen )
{
FILE *fp;
char szHeader[1000];
std::string osBasename, osModelFilename;
if (strlen(pszNewName) == 0)
{
return FALSE;
}
char **filenames = CSLTokenizeString2( pszNewName, ",", 0 );
osBasename = filenames[0];
if( CSLCount(filenames) > 1 )
osModelFilename = filenames[1];
CSLDestroy( filenames );
/* -------------------------------------------------------------------- */
/* Open the source file. */
/* -------------------------------------------------------------------- */
fp = VSIFOpen( osBasename.c_str(), "r" );
if( fp == NULL )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open ILI1 file `%s'.",
pszNewName );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* If we aren't sure it is ILI1, load a header chunk and check */
/* for signs it is ILI1 */
/* -------------------------------------------------------------------- */
if( bTestOpen )
{
int nLen = (int)VSIFRead( szHeader, 1, sizeof(szHeader), fp );
if (nLen == sizeof(szHeader))
szHeader[sizeof(szHeader)-1] = '\0';
else
szHeader[nLen] = '\0';
if( strstr(szHeader,"SCNT") == NULL )
{
VSIFClose( fp );
return FALSE;
}
}
/* -------------------------------------------------------------------- */
/* We assume now that it is ILI1. Close and instantiate a */
/* ILI1Reader on it. */
/* -------------------------------------------------------------------- */
VSIFClose( fp );
poReader = CreateILI1Reader();
if( poReader == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"File %s appears to be ILI1 but the ILI1 reader can't\n"
"be instantiated, likely because Xerces support wasn't\n"
"configured in.",
pszNewName );
return FALSE;
}
poReader->OpenFile( osBasename.c_str() );
pszName = CPLStrdup( osBasename.c_str() );
if (osModelFilename.length() > 0 )
poReader->ReadModel( poImdReader, osModelFilename.c_str(), this );
if( getenv( "ARC_DEGREES" ) != NULL ) {
//No better way to pass arguments to the reader (it could even be an -lco arg)
poReader->SetArcDegrees( atof( getenv("ARC_DEGREES") ) );
}
//Parse model and read data - without surface joing and polygonizing
poReader->ReadFeatures();
return TRUE;
}
DTEDDataset::DTEDDataset() : psDTED(NULL)
{
pszFilename = CPLStrdup("unknown");
pszProjection = CPLStrdup("");
bVerifyChecksum = CPLTestBool(CPLGetConfigOption("DTED_VERIFY_CHECKSUM", "NO"));
}
swq_expr_node *SWQGeneralEvaluator( swq_expr_node *node,
swq_expr_node **sub_node_values )
{
swq_expr_node *poRet = NULL;
/* -------------------------------------------------------------------- */
/* Floating point operations. */
/* -------------------------------------------------------------------- */
if( sub_node_values[0]->field_type == SWQ_FLOAT
|| (node->nSubExprCount > 1
&& sub_node_values[1]->field_type == SWQ_FLOAT) )
{
poRet = new swq_expr_node(0);
poRet->field_type = node->field_type;
if( SWQ_IS_INTEGER(sub_node_values[0]->field_type) )
sub_node_values[0]->float_value = (double) sub_node_values[0]->int_value;
if( node->nSubExprCount > 1 &&
SWQ_IS_INTEGER(sub_node_values[1]->field_type) )
sub_node_values[1]->float_value = (double)sub_node_values[1]->int_value;
if( node->nOperation != SWQ_ISNULL )
{
for( int i = 0; i < node->nSubExprCount; i++ )
{
if( sub_node_values[i]->is_null )
{
if( poRet->field_type == SWQ_BOOLEAN )
{
poRet->int_value = FALSE;
return poRet;
}
else if( poRet->field_type == SWQ_FLOAT )
{
poRet->float_value = 0;
poRet->is_null = 1;
return poRet;
}
else if( SWQ_IS_INTEGER(poRet->field_type) ||
node->nOperation == SWQ_MODULUS )
{
poRet->field_type = SWQ_INTEGER;
poRet->int_value = 0;
poRet->is_null = 1;
return poRet;
}
}
}
}
switch( (swq_op) node->nOperation )
{
case SWQ_EQ:
poRet->int_value = sub_node_values[0]->float_value
== sub_node_values[1]->float_value;
break;
case SWQ_NE:
poRet->int_value = sub_node_values[0]->float_value
!= sub_node_values[1]->float_value;
break;
case SWQ_GT:
poRet->int_value = sub_node_values[0]->float_value
> sub_node_values[1]->float_value;
break;
case SWQ_LT:
poRet->int_value = sub_node_values[0]->float_value
< sub_node_values[1]->float_value;
break;
case SWQ_GE:
poRet->int_value = sub_node_values[0]->float_value
>= sub_node_values[1]->float_value;
break;
case SWQ_LE:
poRet->int_value = sub_node_values[0]->float_value
<= sub_node_values[1]->float_value;
break;
case SWQ_IN:
{
int i;
poRet->int_value = 0;
for( i = 1; i < node->nSubExprCount; i++ )
{
if( sub_node_values[0]->float_value
== sub_node_values[i]->float_value )
{
poRet->int_value = 1;
break;
}
}
}
break;
case SWQ_BETWEEN:
poRet->int_value = sub_node_values[0]->float_value
>= sub_node_values[1]->float_value &&
sub_node_values[0]->float_value
<= sub_node_values[2]->float_value;
break;
case SWQ_ISNULL:
poRet->int_value = sub_node_values[0]->is_null;
break;
case SWQ_ADD:
poRet->float_value = sub_node_values[0]->float_value
+ sub_node_values[1]->float_value;
break;
case SWQ_SUBTRACT:
poRet->float_value = sub_node_values[0]->float_value
- sub_node_values[1]->float_value;
break;
case SWQ_MULTIPLY:
poRet->float_value = sub_node_values[0]->float_value
* sub_node_values[1]->float_value;
break;
case SWQ_DIVIDE:
if( sub_node_values[1]->float_value == 0 )
poRet->float_value = INT_MAX;
else
poRet->float_value = sub_node_values[0]->float_value
/ sub_node_values[1]->float_value;
break;
case SWQ_MODULUS:
{
GIntBig nRight = (GIntBig) sub_node_values[1]->float_value;
poRet->field_type = SWQ_INTEGER;
if (nRight == 0)
poRet->int_value = INT_MAX;
else
poRet->int_value = ((GIntBig) sub_node_values[0]->float_value)
% nRight;
break;
}
default:
CPLAssert( FALSE );
delete poRet;
poRet = NULL;
break;
}
}
/* -------------------------------------------------------------------- */
/* integer/boolean operations. */
/* -------------------------------------------------------------------- */
else if( SWQ_IS_INTEGER(sub_node_values[0]->field_type)
|| sub_node_values[0]->field_type == SWQ_BOOLEAN )
{
poRet = new swq_expr_node(0);
poRet->field_type = node->field_type;
if( node->nOperation != SWQ_ISNULL )
{
for( int i = 0; i < node->nSubExprCount; i++ )
{
if( sub_node_values[i]->is_null )
{
if( poRet->field_type == SWQ_BOOLEAN )
{
poRet->int_value = FALSE;
return poRet;
}
else if( SWQ_IS_INTEGER(poRet->field_type) )
{
poRet->int_value = 0;
poRet->is_null = 1;
return poRet;
}
}
}
}
switch( (swq_op) node->nOperation )
{
case SWQ_AND:
poRet->int_value = sub_node_values[0]->int_value
&& sub_node_values[1]->int_value;
break;
case SWQ_OR:
poRet->int_value = sub_node_values[0]->int_value
|| sub_node_values[1]->int_value;
break;
case SWQ_NOT:
poRet->int_value = !sub_node_values[0]->int_value;
break;
case SWQ_EQ:
poRet->int_value = sub_node_values[0]->int_value
== sub_node_values[1]->int_value;
break;
case SWQ_NE:
poRet->int_value = sub_node_values[0]->int_value
!= sub_node_values[1]->int_value;
break;
case SWQ_GT:
poRet->int_value = sub_node_values[0]->int_value
> sub_node_values[1]->int_value;
break;
case SWQ_LT:
poRet->int_value = sub_node_values[0]->int_value
< sub_node_values[1]->int_value;
break;
case SWQ_GE:
poRet->int_value = sub_node_values[0]->int_value
>= sub_node_values[1]->int_value;
break;
case SWQ_LE:
poRet->int_value = sub_node_values[0]->int_value
<= sub_node_values[1]->int_value;
break;
case SWQ_IN:
{
poRet->int_value = 0;
for( int i = 1; i < node->nSubExprCount; i++ )
{
if( sub_node_values[0]->int_value
== sub_node_values[i]->int_value )
{
poRet->int_value = 1;
break;
}
}
}
break;
case SWQ_BETWEEN:
poRet->int_value = sub_node_values[0]->int_value
>= sub_node_values[1]->int_value &&
sub_node_values[0]->int_value
<= sub_node_values[2]->int_value;
break;
case SWQ_ISNULL:
poRet->int_value = sub_node_values[0]->is_null;
break;
case SWQ_ADD:
poRet->int_value = sub_node_values[0]->int_value
+ sub_node_values[1]->int_value;
break;
case SWQ_SUBTRACT:
poRet->int_value = sub_node_values[0]->int_value
- sub_node_values[1]->int_value;
break;
case SWQ_MULTIPLY:
poRet->int_value = sub_node_values[0]->int_value
* sub_node_values[1]->int_value;
break;
case SWQ_DIVIDE:
if( sub_node_values[1]->int_value == 0 )
poRet->int_value = INT_MAX;
else
poRet->int_value = sub_node_values[0]->int_value
/ sub_node_values[1]->int_value;
break;
case SWQ_MODULUS:
if( sub_node_values[1]->int_value == 0 )
poRet->int_value = INT_MAX;
else
poRet->int_value = sub_node_values[0]->int_value
% sub_node_values[1]->int_value;
break;
default:
CPLAssert( FALSE );
delete poRet;
poRet = NULL;
break;
}
}
/* -------------------------------------------------------------------- */
/* String operations. */
/* -------------------------------------------------------------------- */
else
{
poRet = new swq_expr_node(0);
poRet->field_type = node->field_type;
if( node->nOperation != SWQ_ISNULL )
{
for( int i = 0; i < node->nSubExprCount; i++ )
{
if( sub_node_values[i]->is_null )
{
if( poRet->field_type == SWQ_BOOLEAN )
{
poRet->int_value = FALSE;
return poRet;
}
else if( poRet->field_type == SWQ_STRING )
{
poRet->string_value = CPLStrdup("");
poRet->is_null = 1;
return poRet;
}
}
}
}
switch( (swq_op) node->nOperation )
{
case SWQ_EQ:
{
/* When comparing timestamps, the +00 at the end might be discarded */
/* if the other member has no explicit timezone */
if( (sub_node_values[0]->field_type == SWQ_TIMESTAMP ||
sub_node_values[0]->field_type == SWQ_STRING) &&
(sub_node_values[1]->field_type == SWQ_TIMESTAMP ||
sub_node_values[1]->field_type == SWQ_STRING) &&
strlen(sub_node_values[0]->string_value) > 3 &&
strlen(sub_node_values[1]->string_value) > 3 &&
(strcmp(sub_node_values[0]->string_value + strlen(sub_node_values[0]->string_value)-3, "+00") == 0 &&
sub_node_values[1]->string_value[strlen(sub_node_values[1]->string_value)-3] == ':') )
{
poRet->int_value =
EQUALN(sub_node_values[0]->string_value,
sub_node_values[1]->string_value,
strlen(sub_node_values[1]->string_value));
}
else if( (sub_node_values[0]->field_type == SWQ_TIMESTAMP ||
sub_node_values[0]->field_type == SWQ_STRING) &&
(sub_node_values[1]->field_type == SWQ_TIMESTAMP ||
sub_node_values[1]->field_type == SWQ_STRING) &&
strlen(sub_node_values[0]->string_value) > 3 &&
strlen(sub_node_values[1]->string_value) > 3 &&
(sub_node_values[0]->string_value[strlen(sub_node_values[0]->string_value)-3] == ':') &&
strcmp(sub_node_values[1]->string_value + strlen(sub_node_values[1]->string_value)-3, "+00") == 0)
{
poRet->int_value =
EQUALN(sub_node_values[0]->string_value,
sub_node_values[1]->string_value,
strlen(sub_node_values[0]->string_value));
}
else
{
poRet->int_value =
strcasecmp(sub_node_values[0]->string_value,
sub_node_values[1]->string_value) == 0;
}
break;
}
case SWQ_NE:
poRet->int_value =
strcasecmp(sub_node_values[0]->string_value,
sub_node_values[1]->string_value) != 0;
break;
case SWQ_GT:
poRet->int_value =
strcasecmp(sub_node_values[0]->string_value,
sub_node_values[1]->string_value) > 0;
break;
case SWQ_LT:
poRet->int_value =
strcasecmp(sub_node_values[0]->string_value,
sub_node_values[1]->string_value) < 0;
break;
case SWQ_GE:
poRet->int_value =
strcasecmp(sub_node_values[0]->string_value,
sub_node_values[1]->string_value) >= 0;
break;
case SWQ_LE:
poRet->int_value =
strcasecmp(sub_node_values[0]->string_value,
sub_node_values[1]->string_value) <= 0;
break;
case SWQ_IN:
{
int i;
poRet->int_value = 0;
for( i = 1; i < node->nSubExprCount; i++ )
{
if( strcasecmp(sub_node_values[0]->string_value,
sub_node_values[i]->string_value) == 0 )
{
poRet->int_value = 1;
break;
}
}
}
break;
case SWQ_BETWEEN:
poRet->int_value =
strcasecmp(sub_node_values[0]->string_value,
sub_node_values[1]->string_value) >= 0 &&
strcasecmp(sub_node_values[0]->string_value,
sub_node_values[2]->string_value) <= 0;
break;
case SWQ_LIKE:
{
char chEscape = '\0';
if( node->nSubExprCount == 3 )
chEscape = sub_node_values[2]->string_value[0];
poRet->int_value = swq_test_like(sub_node_values[0]->string_value,
sub_node_values[1]->string_value,
chEscape);
break;
}
case SWQ_ISNULL:
poRet->int_value = sub_node_values[0]->is_null;
break;
case SWQ_CONCAT:
case SWQ_ADD:
{
CPLString osResult = sub_node_values[0]->string_value;
for( int i = 1; i < node->nSubExprCount; i++ )
osResult += sub_node_values[i]->string_value;
poRet->string_value = CPLStrdup(osResult);
poRet->is_null = sub_node_values[0]->is_null;
break;
}
case SWQ_SUBSTR:
{
int nOffset, nSize;
const char *pszSrcStr = sub_node_values[0]->string_value;
if( SWQ_IS_INTEGER(sub_node_values[1]->field_type) )
nOffset = (int)sub_node_values[1]->int_value;
else if( sub_node_values[1]->field_type == SWQ_FLOAT )
nOffset = (int) sub_node_values[1]->float_value;
else
nOffset = 0;
if( node->nSubExprCount < 3 )
nSize = 100000;
else if( SWQ_IS_INTEGER(sub_node_values[2]->field_type) )
nSize = (int)sub_node_values[2]->int_value;
else if( sub_node_values[2]->field_type == SWQ_FLOAT )
nSize = (int) sub_node_values[2]->float_value;
else
nSize = 0;
int nSrcStrLen = (int)strlen(pszSrcStr);
/* In SQL, the first character is at offset 1 */
/* And 0 is considered as 1 */
if (nOffset > 0)
nOffset --;
/* Some implementations allow negative offsets, to start */
/* from the end of the string */
else if( nOffset < 0 )
{
if( nSrcStrLen + nOffset >= 0 )
nOffset = nSrcStrLen + nOffset;
else
nOffset = 0;
}
if( nSize < 0 || nOffset > nSrcStrLen )
{
nOffset = 0;
nSize = 0;
}
else if( nOffset + nSize > nSrcStrLen )
nSize = nSrcStrLen - nOffset;
CPLString osResult = pszSrcStr + nOffset;
if( (int)osResult.size() > nSize )
osResult.resize( nSize );
poRet->string_value = CPLStrdup(osResult);
poRet->is_null = sub_node_values[0]->is_null;
break;
}
case SWQ_HSTORE_GET_VALUE:
{
const char *pszHStore = sub_node_values[0]->string_value;
const char *pszSearchedKey = sub_node_values[1]->string_value;
char* pszRet = OGRHStoreGetValue(pszHStore, pszSearchedKey);
poRet->string_value = pszRet ? pszRet : CPLStrdup("");
poRet->is_null = (pszRet == NULL);
break;
}
default:
CPLAssert( FALSE );
delete poRet;
poRet = NULL;
break;
}
}
return poRet;
}
GDALDataset *DTEDDataset::Open( GDALOpenInfo * poOpenInfo )
{
if (!Identify(poOpenInfo) || poOpenInfo->fpL == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Try opening the dataset. */
/* -------------------------------------------------------------------- */
VSILFILE* fp = poOpenInfo->fpL;
poOpenInfo->fpL = NULL;
DTEDInfo *psDTED
= DTEDOpenEx( fp, poOpenInfo->pszFilename,
(poOpenInfo->eAccess == GA_Update) ? "rb+" : "rb", TRUE );
if( psDTED == NULL )
return( NULL );
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DTEDDataset *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( int 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 );
}
char *CPLRecodeFromWCharIconv( const wchar_t *pwszSource,
const char *pszSrcEncoding,
const char *pszDstEncoding )
{
/* -------------------------------------------------------------------- */
/* What is the source length. */
/* -------------------------------------------------------------------- */
size_t nSrcLen = 0;
while ( pwszSource[nSrcLen] != 0 )
nSrcLen++;
/* -------------------------------------------------------------------- */
/* iconv() does not support wchar_t so we need to repack the */
/* characters according to the width of a character in the */
/* source encoding. For instance if wchar_t is 4 bytes but our */
/* source is UTF16 then we need to pack down into 2 byte */
/* characters before passing to iconv(). */
/* -------------------------------------------------------------------- */
int nTargetCharWidth = CPLEncodingCharSize( pszSrcEncoding );
if( nTargetCharWidth < 1 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Recode from %s with CPLRecodeFromWChar() failed because"
" the width of characters in the encoding are not known.",
pszSrcEncoding );
return CPLStrdup("");
}
GByte *pszIconvSrcBuf = (GByte*) CPLCalloc((nSrcLen+1),nTargetCharWidth);
for( unsigned int iSrc = 0; iSrc <= nSrcLen; iSrc++ )
{
if( nTargetCharWidth == 1 )
pszIconvSrcBuf[iSrc] = (GByte) pwszSource[iSrc];
else if( nTargetCharWidth == 2 )
((short *)pszIconvSrcBuf)[iSrc] = (short) pwszSource[iSrc];
else if( nTargetCharWidth == 4 )
((GInt32 *)pszIconvSrcBuf)[iSrc] = pwszSource[iSrc];
}
/* -------------------------------------------------------------------- */
/* Create the iconv() translation object. */
/* -------------------------------------------------------------------- */
iconv_t sConv;
sConv = iconv_open( pszDstEncoding, pszSrcEncoding );
if ( sConv == (iconv_t)-1 )
{
CPLFree( pszIconvSrcBuf );
CPLError( CE_Warning, CPLE_AppDefined,
"Recode from %s to %s failed with the error: \"%s\".",
pszSrcEncoding, pszDstEncoding, strerror(errno) );
return CPLStrdup( "" );
}
/* -------------------------------------------------------------------- */
/* XXX: There is a portability issue: iconv() function could be */
/* declared differently on different platforms. The second */
/* argument could be declared as char** (as POSIX defines) or */
/* as a const char**. Handle it with the ICONV_CPP_CONST macro here. */
/* -------------------------------------------------------------------- */
ICONV_CPP_CONST char *pszSrcBuf = (ICONV_CPP_CONST char *) pszIconvSrcBuf;
/* iconv expects a number of bytes, not characters */
nSrcLen *= sizeof(wchar_t);
/* -------------------------------------------------------------------- */
/* Allocate destination buffer. */
/* -------------------------------------------------------------------- */
size_t nDstCurLen = MAX(CPL_RECODE_DSTBUF_SIZE, nSrcLen + 1);
size_t nDstLen = nDstCurLen;
char *pszDestination = (char *)CPLCalloc( nDstCurLen, sizeof(char) );
char *pszDstBuf = pszDestination;
while ( nSrcLen > 0 )
{
size_t nConverted =
iconv( sConv, &pszSrcBuf, &nSrcLen, &pszDstBuf, &nDstLen );
if ( nConverted == (size_t)-1 )
{
if ( errno == EILSEQ )
{
// Skip the invalid sequence in the input string.
nSrcLen--;
pszSrcBuf += sizeof(wchar_t);
if (!bHaveWarned2)
{
bHaveWarned2 = true;
CPLError(CE_Warning, CPLE_AppDefined,
"One or several characters couldn't be converted correctly from %s to %s.\n"
"This warning will not be emitted anymore",
pszSrcEncoding, pszDstEncoding);
}
continue;
}
else if ( errno == E2BIG )
{
// We are running out of the output buffer.
// Dynamically increase the buffer size.
size_t nTmp = nDstCurLen;
nDstCurLen *= 2;
pszDestination =
(char *)CPLRealloc( pszDestination, nDstCurLen );
pszDstBuf = pszDestination + nTmp - nDstLen;
nDstLen += nDstCurLen - nTmp;
continue;
}
else
break;
}
}
pszDestination[nDstCurLen - nDstLen] = '\0';
iconv_close( sConv );
CPLFree( pszIconvSrcBuf );
return pszDestination;
}
static GDALDataset *
VRTCreateCopy( const char * pszFilename,
GDALDataset *poSrcDS,
int bStrict,
char ** papszOptions,
CPL_UNUSED GDALProgressFunc pfnProgress,
CPL_UNUSED void * pProgressData )
{
VRTDataset *poVRTDS = NULL;
(void) bStrict;
(void) papszOptions;
CPLAssert( NULL != poSrcDS );
/* -------------------------------------------------------------------- */
/* If the source dataset is a virtual dataset then just write */
/* it to disk as a special case to avoid extra layers of */
/* indirection. */
/* -------------------------------------------------------------------- */
if( poSrcDS->GetDriver() != NULL &&
EQUAL(poSrcDS->GetDriver()->GetDescription(),"VRT") )
{
/* -------------------------------------------------------------------- */
/* Convert tree to a single block of XML text. */
/* -------------------------------------------------------------------- */
char *pszVRTPath = CPLStrdup(CPLGetPath(pszFilename));
((VRTDataset *) poSrcDS)->UnsetPreservedRelativeFilenames();
CPLXMLNode *psDSTree = ((VRTDataset *) poSrcDS)->SerializeToXML( pszVRTPath );
char *pszXML = CPLSerializeXMLTree( psDSTree );
CPLDestroyXMLNode( psDSTree );
CPLFree( pszVRTPath );
/* -------------------------------------------------------------------- */
/* Write to disk. */
/* -------------------------------------------------------------------- */
GDALDataset* pCopyDS = NULL;
if( 0 != strlen( pszFilename ) )
{
VSILFILE *fpVRT = NULL;
fpVRT = VSIFOpenL( pszFilename, "wb" );
if (fpVRT == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Cannot create %s", pszFilename);
CPLFree( pszXML );
return NULL;
}
VSIFWriteL( pszXML, 1, strlen(pszXML), fpVRT );
VSIFCloseL( fpVRT );
pCopyDS = (GDALDataset *) GDALOpen( pszFilename, GA_Update );
}
else
{
/* No destination file is given, so pass serialized XML directly. */
pCopyDS = (GDALDataset *) GDALOpen( pszXML, GA_Update );
}
CPLFree( pszXML );
return pCopyDS;
}
/* -------------------------------------------------------------------- */
/* Create the virtual dataset. */
/* -------------------------------------------------------------------- */
poVRTDS = (VRTDataset *)
VRTDataset::Create( pszFilename,
poSrcDS->GetRasterXSize(),
poSrcDS->GetRasterYSize(),
0, GDT_Byte, NULL );
if (poVRTDS == NULL)
return NULL;
/* -------------------------------------------------------------------- */
/* Do we have a geotransform? */
/* -------------------------------------------------------------------- */
double adfGeoTransform[6];
if( poSrcDS->GetGeoTransform( adfGeoTransform ) == CE_None )
{
poVRTDS->SetGeoTransform( adfGeoTransform );
}
/* -------------------------------------------------------------------- */
/* Copy projection */
/* -------------------------------------------------------------------- */
poVRTDS->SetProjection( poSrcDS->GetProjectionRef() );
/* -------------------------------------------------------------------- */
/* Emit dataset level metadata. */
/* -------------------------------------------------------------------- */
poVRTDS->SetMetadata( poSrcDS->GetMetadata() );
/* -------------------------------------------------------------------- */
/* Copy any special domains that should be transportable. */
/* -------------------------------------------------------------------- */
char **papszMD;
papszMD = poSrcDS->GetMetadata( "RPC" );
if( papszMD )
poVRTDS->SetMetadata( papszMD, "RPC" );
papszMD = poSrcDS->GetMetadata( "IMD" );
if( papszMD )
poVRTDS->SetMetadata( papszMD, "IMD" );
papszMD = poSrcDS->GetMetadata( "GEOLOCATION" );
if( papszMD )
poVRTDS->SetMetadata( papszMD, "GEOLOCATION" );
/* -------------------------------------------------------------------- */
/* GCPs */
/* -------------------------------------------------------------------- */
if( poSrcDS->GetGCPCount() > 0 )
{
poVRTDS->SetGCPs( poSrcDS->GetGCPCount(),
poSrcDS->GetGCPs(),
poSrcDS->GetGCPProjection() );
}
/* -------------------------------------------------------------------- */
/* Loop over all the bands. */
/* -------------------------------------------------------------------- */
for( int iBand = 0; iBand < poSrcDS->GetRasterCount(); iBand++ )
{
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( iBand+1 );
/* -------------------------------------------------------------------- */
/* Create the band with the appropriate band type. */
/* -------------------------------------------------------------------- */
poVRTDS->AddBand( poSrcBand->GetRasterDataType(), NULL );
VRTSourcedRasterBand *poVRTBand =
(VRTSourcedRasterBand *) poVRTDS->GetRasterBand( iBand+1 );
/* -------------------------------------------------------------------- */
/* Setup source mapping. */
/* -------------------------------------------------------------------- */
poVRTBand->AddSimpleSource( poSrcBand );
/* -------------------------------------------------------------------- */
/* Emit various band level metadata. */
/* -------------------------------------------------------------------- */
poVRTBand->CopyCommonInfoFrom( poSrcBand );
/* -------------------------------------------------------------------- */
/* Add specific mask band. */
/* -------------------------------------------------------------------- */
if ( (poSrcBand->GetMaskFlags() & (GMF_PER_DATASET | GMF_ALL_VALID | GMF_NODATA)) == 0)
{
VRTSourcedRasterBand* poVRTMaskBand = new VRTSourcedRasterBand(poVRTDS, 0,
poSrcBand->GetMaskBand()->GetRasterDataType(),
poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize());
poVRTMaskBand->AddMaskBandSource( poSrcBand );
poVRTBand->SetMaskBand( poVRTMaskBand );
}
}
/* -------------------------------------------------------------------- */
/* Add dataset mask band */
/* -------------------------------------------------------------------- */
if (poSrcDS->GetRasterCount() != 0 &&
poSrcDS->GetRasterBand(1) != NULL &&
poSrcDS->GetRasterBand(1)->GetMaskFlags() == GMF_PER_DATASET)
{
GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand(1);
VRTSourcedRasterBand* poVRTMaskBand = new VRTSourcedRasterBand(poVRTDS, 0,
poSrcBand->GetMaskBand()->GetRasterDataType(),
poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize());
poVRTMaskBand->AddMaskBandSource( poSrcBand );
poVRTDS->SetMaskBand( poVRTMaskBand );
}
poVRTDS->FlushCache();
return poVRTDS;
}
char *CPLRecodeIconv( const char *pszSource,
const char *pszSrcEncoding,
const char *pszDstEncoding )
{
iconv_t sConv;
sConv = iconv_open( pszDstEncoding, pszSrcEncoding );
if ( sConv == (iconv_t)-1 )
{
CPLError( CE_Warning, CPLE_AppDefined,
"Recode from %s to %s failed with the error: \"%s\".",
pszSrcEncoding, pszDstEncoding, strerror(errno) );
return CPLStrdup(pszSource);
}
/* -------------------------------------------------------------------- */
/* XXX: There is a portability issue: iconv() function could be */
/* declared differently on different platforms. The second */
/* argument could be declared as char** (as POSIX defines) or */
/* as a const char**. Handle it with the ICONV_CPP_CONST macro here. */
/* -------------------------------------------------------------------- */
ICONV_CPP_CONST char *pszSrcBuf = (ICONV_CPP_CONST char *)pszSource;
size_t nSrcLen = strlen( pszSource );
size_t nDstCurLen = MAX(CPL_RECODE_DSTBUF_SIZE, nSrcLen + 1);
size_t nDstLen = nDstCurLen;
char *pszDestination = (char *)CPLCalloc( nDstCurLen, sizeof(char) );
char *pszDstBuf = pszDestination;
while ( nSrcLen > 0 )
{
size_t nConverted =
iconv( sConv, &pszSrcBuf, &nSrcLen, &pszDstBuf, &nDstLen );
if ( nConverted == (size_t)-1 )
{
if ( errno == EILSEQ )
{
// Skip the invalid sequence in the input string.
if (!bHaveWarned1)
{
bHaveWarned1 = true;
CPLError(CE_Warning, CPLE_AppDefined,
"One or several characters couldn't be converted correctly from %s to %s.\n"
"This warning will not be emitted anymore",
pszSrcEncoding, pszDstEncoding);
}
nSrcLen--, pszSrcBuf++;
continue;
}
else if ( errno == E2BIG )
{
// We are running out of the output buffer.
// Dynamically increase the buffer size.
size_t nTmp = nDstCurLen;
nDstCurLen *= 2;
pszDestination =
(char *)CPLRealloc( pszDestination, nDstCurLen );
pszDstBuf = pszDestination + nTmp - nDstLen;
nDstLen += nDstCurLen - nTmp;
continue;
}
else
break;
}
}
pszDestination[nDstCurLen - nDstLen] = '\0';
iconv_close( sConv );
return pszDestination;
}
OGRFeatureDefn *OGRMySQLTableLayer::ReadTableDefinition( const char *pszTable )
{
MYSQL_RES *hResult;
CPLString osCommand;
/* -------------------------------------------------------------------- */
/* Fire off commands to get back the schema of the table. */
/* -------------------------------------------------------------------- */
osCommand.Printf("DESCRIBE `%s`", pszTable );
pszGeomColumnTable = CPLStrdup(pszTable);
if( mysql_query( poDS->GetConn(), osCommand ) )
{
poDS->ReportError( "DESCRIBE Failed" );
return NULL;
}
hResult = mysql_store_result( poDS->GetConn() );
if( hResult == NULL )
{
poDS->ReportError( "mysql_store_result() failed on DESCRIBE result." );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Parse the returned table information. */
/* -------------------------------------------------------------------- */
OGRFeatureDefn *poDefn = new OGRFeatureDefn( pszTable );
char **papszRow;
OGRwkbGeometryType eForcedGeomType = wkbUnknown;
int bGeomColumnNotNullable = FALSE;
poDefn->Reference();
while( (papszRow = mysql_fetch_row( hResult )) != NULL )
{
const char *pszType;
OGRFieldDefn oField( papszRow[0], OFTString);
int nLenType;
pszType = papszRow[1];
if( pszType == NULL )
continue;
nLenType = (int)strlen(pszType);
if( EQUAL(pszType,"varbinary")
|| (nLenType>=4 && EQUAL(pszType+nLenType-4,"blob")))
{
oField.SetType( OFTBinary );
}
else if( EQUAL(pszType,"varchar")
|| (nLenType>=4 && EQUAL(pszType+nLenType-4,"enum"))
|| (nLenType>=3 && EQUAL(pszType+nLenType-3,"set")) )
{
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType, "char") )
{
oField.SetType( OFTString );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 2)
{
/* width is the second */
oField.SetWidth(atoi(papszTokens[1]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTString );
}
if(nLenType>=4 && EQUAL(pszType+nLenType-4,"text"))
{
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType,"varchar") )
{
/*
pszType is usually in the form "varchar(15)"
so we'll split it up and get the width and precision
*/
oField.SetType( OFTString );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 2)
{
/* width is the second */
oField.SetWidth(atoi(papszTokens[1]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTString );
}
else if( STARTS_WITH_CI(pszType, "int") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "tinyint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "smallint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "mediumint") )
{
oField.SetType( OFTInteger );
}
else if( STARTS_WITH_CI(pszType, "bigint") )
{
oField.SetType( OFTInteger64 );
}
else if( STARTS_WITH_CI(pszType, "decimal") )
{
/*
pszType is usually in the form "decimal(15,2)"
so we'll split it up and get the width and precision
*/
oField.SetType( OFTReal );
char ** papszTokens;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 3)
{
/* width is the second and precision is the third */
oField.SetWidth(atoi(papszTokens[1]));
oField.SetPrecision(atoi(papszTokens[2]));
}
CSLDestroy( papszTokens );
}
else if( STARTS_WITH_CI(pszType, "float") )
{
oField.SetType( OFTReal );
}
else if( EQUAL(pszType,"double") )
{
oField.SetType( OFTReal );
}
else if( STARTS_WITH_CI(pszType, "double") )
{
// double can also be double(15,2)
// so we'll handle this case here after
// we check for just a regular double
// without a width and precision specified
char ** papszTokens=NULL;
papszTokens = CSLTokenizeString2(pszType,"(),",0);
if (CSLCount(papszTokens) >= 3)
{
/* width is the second and precision is the third */
oField.SetWidth(atoi(papszTokens[1]));
oField.SetPrecision(atoi(papszTokens[2]));
}
CSLDestroy( papszTokens );
oField.SetType( OFTReal );
}
else if( EQUAL(pszType,"decimal") )
{
oField.SetType( OFTReal );
}
else if( EQUAL(pszType, "date") )
{
oField.SetType( OFTDate );
}
else if( EQUAL(pszType, "time") )
{
oField.SetType( OFTTime );
}
else if( EQUAL(pszType, "datetime")
|| EQUAL(pszType, "timestamp") )
{
oField.SetType( OFTDateTime );
}
else if( EQUAL(pszType, "year") )
{
oField.SetType( OFTString );
oField.SetWidth( 10 );
}
else if( EQUAL(pszType, "geometry") ||
OGRFromOGCGeomType(pszType) != wkbUnknown)
{
if (pszGeomColumn == NULL)
{
pszGeomColumn = CPLStrdup(papszRow[0]);
eForcedGeomType = OGRFromOGCGeomType(pszType);
bGeomColumnNotNullable = ( papszRow[2] != NULL && EQUAL(papszRow[2], "NO") );
}
else
{
CPLDebug("MYSQL",
"Ignoring %s as geometry column. Another one(%s) has already been found before",
papszRow[0], pszGeomColumn);
}
continue;
}
// Is this an integer primary key field?
if( !bHasFid && papszRow[3] != NULL && EQUAL(papszRow[3],"PRI")
&& (oField.GetType() == OFTInteger || oField.GetType() == OFTInteger64) )
{
bHasFid = TRUE;
pszFIDColumn = CPLStrdup(oField.GetNameRef());
if( oField.GetType() == OFTInteger64 )
SetMetadataItem(OLMD_FID64, "YES");
continue;
}
// Is not nullable ?
if( papszRow[2] != NULL && EQUAL(papszRow[2], "NO") )
oField.SetNullable(FALSE);
// Has default ?
const char* pszDefault = papszRow[4];
if( pszDefault != NULL )
{
if( !EQUAL(pszDefault, "NULL") &&
!STARTS_WITH_CI(pszDefault, "CURRENT_") &&
pszDefault[0] != '(' &&
pszDefault[0] != '\'' &&
CPLGetValueType(pszDefault) == CPL_VALUE_STRING )
{
int nYear, nMonth, nDay, nHour, nMinute;
float fSecond;
if( oField.GetType() == OFTDateTime &&
sscanf(pszDefault, "%d-%d-%d %d:%d:%f", &nYear, &nMonth, &nDay,
&nHour, &nMinute, &fSecond) == 6 )
{
oField.SetDefault(CPLSPrintf("'%04d/%02d/%02d %02d:%02d:%02d'",
nYear, nMonth, nDay, nHour, nMinute, (int)(fSecond+0.5)));
}
else
{
CPLString osDefault("'");
char* pszTmp = CPLEscapeString(pszDefault, -1, CPLES_SQL);
osDefault += pszTmp;
CPLFree(pszTmp);
osDefault += "'";
oField.SetDefault(osDefault);
}
}
else
{
oField.SetDefault(pszDefault);
}
}
poDefn->AddFieldDefn( &oField );
}
// set to none for now... if we have a geometry column it will be set layer.
poDefn->SetGeomType( wkbNone );
if( hResult != NULL )
{
mysql_free_result( hResult );
hResultSet = NULL;
}
if( bHasFid )
CPLDebug( "MySQL", "table %s has FID column %s.",
pszTable, pszFIDColumn );
else
CPLDebug( "MySQL",
"table %s has no FID column, FIDs will not be reliable!",
pszTable );
if (pszGeomColumn)
{
char* pszType=NULL;
// set to unknown first
poDefn->SetGeomType( wkbUnknown );
osCommand = "SELECT type, coord_dimension FROM geometry_columns WHERE f_table_name='";
osCommand += pszTable;
osCommand += "'";
hResult = NULL;
if( !mysql_query( poDS->GetConn(), osCommand ) )
hResult = mysql_store_result( poDS->GetConn() );
papszRow = NULL;
if( hResult != NULL )
papszRow = mysql_fetch_row( hResult );
if( papszRow != NULL && papszRow[0] != NULL )
{
pszType = papszRow[0];
OGRwkbGeometryType l_nGeomType = OGRFromOGCGeomType(pszType);
if( papszRow[1] != NULL && atoi(papszRow[1]) == 3 )
l_nGeomType = wkbSetZ(l_nGeomType);
poDefn->SetGeomType( l_nGeomType );
}
else if (eForcedGeomType != wkbUnknown)
poDefn->SetGeomType(eForcedGeomType);
if( bGeomColumnNotNullable )
poDefn->GetGeomFieldDefn(0)->SetNullable(FALSE);
if( hResult != NULL )
mysql_free_result( hResult ); //Free our query results for finding type.
hResult = NULL;
}
// Fetch the SRID for this table now
nSRSId = FetchSRSId();
return poDefn;
}
static int GDAL_IMD_AA2R( char ***ppapszIMD )
{
char **papszIMD = *ppapszIMD;
/* -------------------------------------------------------------------- */
/* Verify that we have a new format file. */
/* -------------------------------------------------------------------- */
const char *pszValue = CSLFetchNameValue( papszIMD, "version" );
if( pszValue == NULL )
return FALSE;
if( EQUAL(pszValue,"\"R\"") )
return TRUE;
if( !EQUAL(pszValue,"\"AA\"") )
{
CPLDebug( "IMD", "The file is not the expected 'version = \"AA\"' format.\nProceeding, but file may be corrupted." );
}
/* -------------------------------------------------------------------- */
/* Fix the version line. */
/* -------------------------------------------------------------------- */
papszIMD = CSLSetNameValue( papszIMD, "version", "\"R\"" );
/* -------------------------------------------------------------------- */
/* remove a bunch of fields. */
/* -------------------------------------------------------------------- */
int iKey;
static const char *apszToRemove[] = {
"productCatalogId",
"childCatalogId",
"productType",
"numberOfLooks",
"effectiveBandwidth",
"mode",
"scanDirection",
"cloudCover",
"productGSD",
NULL };
for( iKey = 0; apszToRemove[iKey] != NULL; iKey++ )
{
int iTarget = CSLFindName( papszIMD, apszToRemove[iKey] );
if( iTarget != -1 )
papszIMD = CSLRemoveStrings( papszIMD, iTarget, 1, NULL );
}
/* -------------------------------------------------------------------- */
/* Replace various min/mean/max with just the mean. */
/* -------------------------------------------------------------------- */
static const char *keylist[] = {
"CollectedRowGSD",
"CollectedColGSD",
"SunAz",
"SunEl",
"SatAz",
"SatEl",
"InTrackViewAngle",
"CrossTrackViewAngle",
"OffNadirViewAngle",
NULL };
for( iKey = 0; keylist[iKey] != NULL; iKey++ )
{
CPLString osTarget;
int iTarget;
osTarget.Printf( "IMAGE_1.min%s", keylist[iKey] );
iTarget = CSLFindName( papszIMD, osTarget );
if( iTarget != -1 )
papszIMD = CSLRemoveStrings( papszIMD, iTarget, 1, NULL );
osTarget.Printf( "IMAGE_1.max%s", keylist[iKey] );
iTarget = CSLFindName( papszIMD, osTarget );
if( iTarget != -1 )
papszIMD = CSLRemoveStrings( papszIMD, iTarget, 1, NULL );
osTarget.Printf( "IMAGE_1.mean%s", keylist[iKey] );
iTarget = CSLFindName( papszIMD, osTarget );
if( iTarget != -1 )
{
CPLString osValue = CSLFetchNameValue( papszIMD, osTarget );
CPLString osLine;
osTarget.Printf( "IMAGE_1.%c%s",
tolower(keylist[iKey][0]),
keylist[iKey]+1 );
osLine = osTarget + "=" + osValue;
CPLFree( papszIMD[iTarget] );
papszIMD[iTarget] = CPLStrdup(osLine);
}
}
*ppapszIMD = papszIMD;
return TRUE;
}
/**
* Retrieves and stores the GCPs from a COSMO-SKYMED dataset
* It only retrieves the GCPs for L0, L1A and L1B products
* for L1C and L1D products, geotransform is provided.
* The GCPs provided will be the Image's corners.
* @param iProductType type of CSK product @see HDF5CSKProductEnum
*/
void HDF5ImageDataset::CaptureCSKGCPs(int iProductType)
{
//Only retrieve GCPs for L0,L1A and L1B products
if(iProductType == PROD_CSK_L0||iProductType == PROD_CSK_L1A||
iProductType == PROD_CSK_L1B)
{
nGCPCount = 4;
pasGCPList = static_cast<GDAL_GCP *>( CPLCalloc(sizeof(GDAL_GCP),4) );
CPLString osCornerName[4];
double pdCornerPixel[4] = {0.0, 0.0, 0.0, 0.0};
double pdCornerLine[4] = {0.0, 0.0, 0.0, 0.0};
const char * const pszSubdatasetName = GetSubdatasetName();
//Load the subdataset name first
for( int i=0; i < 4; i++ )
osCornerName[i] = pszSubdatasetName;
//Load the attribute name, and raster coordinates for
//all the corners
osCornerName[0] += "/Top Left Geodetic Coordinates";
pdCornerPixel[0] = 0;
pdCornerLine[0] = 0;
osCornerName[1] += "/Top Right Geodetic Coordinates";
pdCornerPixel[1] = GetRasterXSize();
pdCornerLine[1] = 0;
osCornerName[2] += "/Bottom Left Geodetic Coordinates";
pdCornerPixel[2] = 0;
pdCornerLine[2] = GetRasterYSize();
osCornerName[3] += "/Bottom Right Geodetic Coordinates";
pdCornerPixel[3] = GetRasterXSize();
pdCornerLine[3] = GetRasterYSize();
//For all the image's corners
for( int i=0;i<4;i++)
{
GDALInitGCPs( 1, pasGCPList + i );
CPLFree( pasGCPList[i].pszId );
pasGCPList[i].pszId = NULL;
double *pdCornerCoordinates = NULL;
// Retrieve the attributes.
if(HDF5ReadDoubleAttr(osCornerName[i].c_str(),
&pdCornerCoordinates) == CE_Failure)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Error retrieving CSK GCPs\n" );
// Free on failure, e.g. in case of QLK subdataset.
for( i = 0; i < 4; i++ )
{
if( pasGCPList[i].pszId )
CPLFree( pasGCPList[i].pszId );
if( pasGCPList[i].pszInfo )
CPLFree( pasGCPList[i].pszInfo );
}
CPLFree( pasGCPList );
pasGCPList = NULL;
nGCPCount = 0;
break;
}
//Fill the GCPs name
pasGCPList[i].pszId = CPLStrdup( osCornerName[i].c_str() );
//Fill the coordinates
pasGCPList[i].dfGCPX = pdCornerCoordinates[1];
pasGCPList[i].dfGCPY = pdCornerCoordinates[0];
pasGCPList[i].dfGCPZ = pdCornerCoordinates[2];
pasGCPList[i].dfGCPPixel = pdCornerPixel[i];
pasGCPList[i].dfGCPLine = pdCornerLine[i];
//Free the returned coordinates
CPLFree(pdCornerCoordinates);
}
}
}
GDALDataset *DOQ2Dataset::Open( GDALOpenInfo * poOpenInfo )
{
/* -------------------------------------------------------------------- */
/* We assume the user is pointing to the binary (i.e. .bil) file. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->nHeaderBytes < 212 )
return NULL;
if(! STARTS_WITH_CI( reinterpret_cast<char *>( poOpenInfo->pabyHeader ),
"BEGIN_USGS_DOQ_HEADER" ) )
return NULL;
VSILFILE* fp = VSIFOpenL(poOpenInfo->pszFilename, "rb");
if (fp == NULL)
return NULL;
int nLineCount = 0;
int nBytesPerPixel = 0;
int nWidth = 0;
int nHeight = 0;
int nBandStorage = 0;
int nBandTypes = 0;
const char *pszDatumLong = NULL;
const char *pszDatumShort = NULL;
const char *pszUnits = NULL;
char *pszQuadname = NULL;
char *pszQuadquad = NULL;
char *pszState = NULL;
int nZone = 0;
int nProjType = 0;
int nSkipBytes = 0;
int nBandCount = 0;
double dfULXMap=0.0;
double dfULYMap = 0.0;
double dfXDim = 0.0;
double dfYDim = 0.0;
char **papszMetadata = NULL;
/* read and discard the first line */
CPL_IGNORE_RET_VAL(CPLReadLineL( fp ));
const char *pszLine = NULL;
while( (pszLine = CPLReadLineL( fp )) != NULL )
{
nLineCount++;
if( EQUAL(pszLine,"END_USGS_DOQ_HEADER") )
break;
char **papszTokens = CSLTokenizeString( pszLine );
if( CSLCount( papszTokens ) < 2 )
{
CSLDestroy( papszTokens );
break;
}
if( EQUAL( papszTokens[0], "SAMPLES_AND_LINES" ) &&
CSLCount( papszTokens ) >= 3 )
{
nWidth = atoi(papszTokens[1]);
nHeight = atoi(papszTokens[2]);
}
else if( EQUAL(papszTokens[0],"BYTE_COUNT") )
{
nSkipBytes = atoi(papszTokens[1]);
}
else if( EQUAL( papszTokens[0], "XY_ORIGIN" ) &&
CSLCount( papszTokens ) >= 3 )
{
dfULXMap = CPLAtof(papszTokens[1]);
dfULYMap = CPLAtof(papszTokens[2]);
}
else if( EQUAL( papszTokens[0], "HORIZONTAL_RESOLUTION" ) )
{
dfXDim = CPLAtof(papszTokens[1]);
dfYDim = dfXDim;
}
else if( EQUAL(papszTokens[0], "BAND_ORGANIZATION") )
{
if( EQUAL(papszTokens[1], "SINGLE FILE") )
nBandStorage = 1;
if( EQUAL(papszTokens[1], "BSQ") )
nBandStorage = 1;
if( EQUAL(papszTokens[1], "BIL") )
nBandStorage = 1;
if( EQUAL(papszTokens[1], "BIP") )
nBandStorage = 4;
}
else if( EQUAL(papszTokens[0], "BAND_CONTENT") )
{
if( EQUAL(papszTokens[1], "BLACK&WHITE") )
nBandTypes = 1;
else if( EQUAL(papszTokens[1], "COLOR") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1], "RGB") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1], "RED") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1], "GREEN") )
nBandTypes = 5;
else if( EQUAL(papszTokens[1], "BLUE") )
nBandTypes = 5;
nBandCount++;
}
else if( EQUAL(papszTokens[0], "BITS_PER_PIXEL") )
{
nBytesPerPixel = atoi(papszTokens[1]) / 8;
}
else if( EQUAL(papszTokens[0], "HORIZONTAL_COORDINATE_SYSTEM") )
{
if( EQUAL(papszTokens[1], "UTM") )
nProjType = 1;
else if( EQUAL(papszTokens[1], "SPCS") )
nProjType = 2;
else if( EQUAL(papszTokens[1], "GEOGRAPHIC") )
nProjType = 0;
}
else if( EQUAL(papszTokens[0], "COORDINATE_ZONE") )
{
nZone = atoi(papszTokens[1]);
}
else if( EQUAL(papszTokens[0], "HORIZONTAL_UNITS") )
{
if( EQUAL(papszTokens[1], "METERS") )
pszUnits = "UNIT[\"metre\",1]";
else if( EQUAL(papszTokens[1], "FEET") )
pszUnits = "UNIT[\"US survey foot\",0.304800609601219]";
}
else if( EQUAL(papszTokens[0],"HORIZONTAL_DATUM") )
{
if( EQUAL(papszTokens[1], "NAD27") )
{
pszDatumLong = NAD27_DATUM;
pszDatumShort = "NAD 27";
}
else if( EQUAL(papszTokens[1]," WGS72") )
{
pszDatumLong = WGS72_DATUM;
pszDatumShort = "WGS 72";
}
else if( EQUAL(papszTokens[1], "WGS84") )
{
pszDatumLong = WGS84_DATUM;
pszDatumShort = "WGS 84";
}
else if( EQUAL(papszTokens[1], "NAD83") )
{
pszDatumLong = NAD83_DATUM;
pszDatumShort = "NAD 83";
}
else
{
pszDatumLong = "DATUM[\"unknown\"]";
pszDatumShort = "unknown";
}
}
else
{
/* we want to generically capture all the other metadata */
CPLString osMetaDataValue;
for( int iToken = 1; papszTokens[iToken] != NULL; iToken++ )
{
if( EQUAL(papszTokens[iToken],"*") )
continue;
if( iToken > 1 )
osMetaDataValue += " " ;
osMetaDataValue += papszTokens[iToken];
}
papszMetadata = CSLAddNameValue( papszMetadata,
papszTokens[0],
osMetaDataValue );
}
CSLDestroy( papszTokens );
}
CPLReadLineL( NULL );
/* -------------------------------------------------------------------- */
/* Do these values look coherent for a DOQ file? It would be */
/* nice to do a more comprehensive test than this! */
/* -------------------------------------------------------------------- */
if( nWidth < 500 || nWidth > 25000
|| nHeight < 500 || nHeight > 25000
|| nBandStorage < 0 || nBandStorage > 4
|| nBandTypes < 1 || nBandTypes > 9 )
{
CSLDestroy( papszMetadata );
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return NULL;
}
/* -------------------------------------------------------------------- */
/* Check the configuration. We don't currently handle all */
/* variations, only the common ones. */
/* -------------------------------------------------------------------- */
if( nBandTypes > 5 )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"DOQ Data Type (%d) is not a supported configuration.",
nBandTypes );
CSLDestroy( papszMetadata );
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return NULL;
}
/* -------------------------------------------------------------------- */
/* Confirm the requested access is supported. */
/* -------------------------------------------------------------------- */
if( poOpenInfo->eAccess == GA_Update )
{
CSLDestroy( papszMetadata );
CPLError( CE_Failure, CPLE_NotSupported,
"The DOQ2 driver does not support update access to existing"
" datasets." );
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding GDALDataset. */
/* -------------------------------------------------------------------- */
DOQ2Dataset *poDS = new DOQ2Dataset();
poDS->nRasterXSize = nWidth;
poDS->nRasterYSize = nHeight;
poDS->SetMetadata( papszMetadata );
CSLDestroy( papszMetadata );
papszMetadata = NULL;
poDS->fpImage = fp;
/* -------------------------------------------------------------------- */
/* Compute layout of data. */
/* -------------------------------------------------------------------- */
if( nBandCount < 2 )
nBandCount = nBytesPerPixel;
else
nBytesPerPixel *= nBandCount;
const int nBytesPerLine = nBytesPerPixel * nWidth;
/* -------------------------------------------------------------------- */
/* Create band information objects. */
/* -------------------------------------------------------------------- */
CPLErrorReset();
for( int i = 0; i < nBandCount; i++ )
{
poDS->SetBand( i+1,
new RawRasterBand( poDS, i+1, poDS->fpImage,
nSkipBytes + i, nBytesPerPixel, nBytesPerLine,
GDT_Byte, TRUE, TRUE ) );
if( CPLGetLastErrorType() != CE_None )
{
delete poDS;
CPLFree( pszQuadname );
CPLFree( pszQuadquad );
CPLFree( pszState );
return NULL;
}
}
if (nProjType == 1)
{
poDS->pszProjection =
CPLStrdup( CPLSPrintf(
UTM_FORMAT, pszDatumShort ? pszDatumShort : "", nZone,
pszDatumLong ? pszDatumLong : "",
nZone >= 1 && nZone <= 60 ? nZone * 6 - 183 : 0,
pszUnits ? pszUnits : "" ) );
}
else
{
poDS->pszProjection = CPLStrdup("");
}
poDS->dfULX = dfULXMap;
poDS->dfULY = dfULYMap;
poDS->dfXPixelSize = dfXDim;
poDS->dfYPixelSize = dfYDim;
CPLFree( pszQuadname );
CPLFree( pszQuadquad );
CPLFree( pszState );
/* -------------------------------------------------------------------- */
/* Initialize any PAM information. */
/* -------------------------------------------------------------------- */
poDS->SetDescription( poOpenInfo->pszFilename );
poDS->TryLoadXML();
/* -------------------------------------------------------------------- */
/* Check for overviews. */
/* -------------------------------------------------------------------- */
poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename );
return poDS;
}
OGRSpatialReference *OGRMySQLDataSource::FetchSRS( int nId )
{
char szCommand[128];
char **papszRow;
MYSQL_RES *hResult;
if( nId < 0 )
return NULL;
/* -------------------------------------------------------------------- */
/* First, we look through our SRID cache, is it there? */
/* -------------------------------------------------------------------- */
int i;
for( i = 0; i < nKnownSRID; i++ )
{
if( panSRID[i] == nId )
return papoSRS[i];
}
OGRSpatialReference *poSRS = NULL;
// make sure to attempt to free any old results
hResult = mysql_store_result( GetConn() );
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
sprintf( szCommand,
"SELECT srtext FROM spatial_ref_sys WHERE srid = %d",
nId );
if( !mysql_query( GetConn(), szCommand ) )
hResult = mysql_store_result( GetConn() );
char *pszWKT = NULL;
papszRow = NULL;
if( hResult != NULL )
papszRow = mysql_fetch_row( hResult );
if( papszRow != NULL && papszRow[0] != NULL )
{
pszWKT = CPLStrdup(papszRow[0]);
}
if( hResult != NULL )
mysql_free_result( hResult );
hResult = NULL;
poSRS = new OGRSpatialReference();
char* pszWKTOri = pszWKT;
if( pszWKT == NULL || poSRS->importFromWkt( &pszWKT ) != OGRERR_NONE )
{
delete poSRS;
CPLFree(pszWKTOri);
poSRS = NULL;
}
CPLFree(pszWKTOri);
/* -------------------------------------------------------------------- */
/* Add to the cache. */
/* -------------------------------------------------------------------- */
panSRID = (int *) CPLRealloc(panSRID,sizeof(int) * (nKnownSRID+1) );
papoSRS = (OGRSpatialReference **)
CPLRealloc(papoSRS, sizeof(void*) * (nKnownSRID + 1) );
panSRID[nKnownSRID] = nId;
papoSRS[nKnownSRID] = poSRS;
nKnownSRID ++;
return poSRS;
}
OGRLayer *
OGRPGDumpDataSource::ICreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
CPLString osCommand;
const char *pszGeomType = NULL;
char *pszTableName = NULL;
char *pszSchemaName = NULL;
int bHavePostGIS = TRUE;
int GeometryTypeFlags = 0;
const char* pszFIDColumnNameIn = CSLFetchNameValue(papszOptions, "FID");
CPLString osFIDColumnName, osFIDColumnNameEscaped;
if (pszFIDColumnNameIn == NULL)
osFIDColumnName = "ogc_fid";
else
{
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
{
char* pszLaunderedFid = OGRPGCommonLaunderName(pszFIDColumnNameIn, "PGDump");
osFIDColumnName = pszLaunderedFid;
CPLFree(pszLaunderedFid);
}
else
{
osFIDColumnName = pszFIDColumnNameIn;
}
}
osFIDColumnNameEscaped = OGRPGDumpEscapeColumnName(osFIDColumnName);
if (STARTS_WITH(pszLayerName, "pg"))
{
CPLError(CE_Warning, CPLE_AppDefined,
"The layer name should not begin by 'pg' as it is a reserved prefix");
}
//bHavePostGIS = CSLFetchBoolean(papszOptions,"POSTGIS", TRUE);
int bCreateTable = CSLFetchBoolean(papszOptions,"CREATE_TABLE", TRUE);
int bCreateSchema = CSLFetchBoolean(papszOptions,"CREATE_SCHEMA", TRUE);
const char* pszDropTable = CSLFetchNameValueDef(papszOptions,"DROP_TABLE", "IF_EXISTS");
if( OGR_GT_HasZ((OGRwkbGeometryType)eType) )
GeometryTypeFlags |= OGRGeometry::OGR_G_3D;
if( OGR_GT_HasM((OGRwkbGeometryType)eType) )
GeometryTypeFlags |= OGRGeometry::OGR_G_MEASURED;
int ForcedGeometryTypeFlags = -1;
const char* pszDim = CSLFetchNameValue( papszOptions, "DIM");
if( pszDim != NULL )
{
if( EQUAL(pszDim, "XY") || EQUAL(pszDim, "2") )
{
GeometryTypeFlags = 0;
ForcedGeometryTypeFlags = GeometryTypeFlags;
}
else if( EQUAL(pszDim, "XYZ") || EQUAL(pszDim, "3") )
{
GeometryTypeFlags = OGRGeometry::OGR_G_3D;
ForcedGeometryTypeFlags = GeometryTypeFlags;
}
else if( EQUAL(pszDim, "XYM") )
{
GeometryTypeFlags = OGRGeometry::OGR_G_MEASURED;
ForcedGeometryTypeFlags = GeometryTypeFlags;
}
else if( EQUAL(pszDim, "XYZM") || EQUAL(pszDim, "4") )
{
GeometryTypeFlags = OGRGeometry::OGR_G_3D | OGRGeometry::OGR_G_MEASURED;
ForcedGeometryTypeFlags = GeometryTypeFlags;
}
else
{
CPLError(CE_Failure, CPLE_AppDefined, "Invalid value for DIM");
}
}
const int nDimension = 2 + ((GeometryTypeFlags & OGRGeometry::OGR_G_3D) ? 1 : 0)
+ ((GeometryTypeFlags & OGRGeometry::OGR_G_MEASURED) ? 1 : 0);
/* Should we turn layers with None geometry type as Unknown/GEOMETRY */
/* so they are still recorded in geometry_columns table ? (#4012) */
int bNoneAsUnknown = CPLTestBool(CSLFetchNameValueDef(
papszOptions, "NONE_AS_UNKNOWN", "NO"));
if (bNoneAsUnknown && eType == wkbNone)
eType = wkbUnknown;
else if (eType == wkbNone)
bHavePostGIS = FALSE;
int bExtractSchemaFromLayerName = CPLTestBool(CSLFetchNameValueDef(
papszOptions, "EXTRACT_SCHEMA_FROM_LAYER_NAME", "YES"));
/* Postgres Schema handling:
Extract schema name from input layer name or passed with -lco SCHEMA.
Set layer name to "schema.table" or to "table" if schema == current_schema()
Usage without schema name is backwards compatible
*/
const char* pszDotPos = strstr(pszLayerName,".");
if ( pszDotPos != NULL && bExtractSchemaFromLayerName )
{
int length = static_cast<int>(pszDotPos - pszLayerName);
pszSchemaName = (char*)CPLMalloc(length+1);
strncpy(pszSchemaName, pszLayerName, length);
pszSchemaName[length] = '\0';
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = OGRPGCommonLaunderName( pszDotPos + 1, "PGDump" ); //skip "."
else
pszTableName = CPLStrdup( pszDotPos + 1 ); //skip "."
}
else
{
pszSchemaName = NULL;
if( CSLFetchBoolean(papszOptions,"LAUNDER", TRUE) )
pszTableName = OGRPGCommonLaunderName( pszLayerName, "PGDump" ); //skip "."
else
pszTableName = CPLStrdup( pszLayerName ); //skip "."
}
LogCommit();
/* -------------------------------------------------------------------- */
/* Set the default schema for the layers. */
/* -------------------------------------------------------------------- */
if( CSLFetchNameValue( papszOptions, "SCHEMA" ) != NULL )
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup(CSLFetchNameValue( papszOptions, "SCHEMA" ));
if (bCreateSchema)
{
osCommand.Printf("CREATE SCHEMA \"%s\"", pszSchemaName);
Log(osCommand);
}
}
if ( pszSchemaName == NULL)
{
pszSchemaName = CPLStrdup("public");
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? */
/* -------------------------------------------------------------------- */
int iLayer;
for( iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszLayerName,papoLayers[iLayer]->GetLayerDefn()->GetName()) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n",
pszLayerName );
CPLFree( pszTableName );
CPLFree( pszSchemaName );
return NULL;
}
}
if (bCreateTable && (EQUAL(pszDropTable, "YES") ||
EQUAL(pszDropTable, "ON") ||
EQUAL(pszDropTable, "TRUE") ||
EQUAL(pszDropTable, "IF_EXISTS")))
{
if (EQUAL(pszDropTable, "IF_EXISTS"))
osCommand.Printf("DROP TABLE IF EXISTS \"%s\".\"%s\" CASCADE", pszSchemaName, pszTableName );
else
osCommand.Printf("DROP TABLE \"%s\".\"%s\" CASCADE", pszSchemaName, pszTableName );
Log(osCommand);
}
/* -------------------------------------------------------------------- */
/* Handle the GEOM_TYPE option. */
/* -------------------------------------------------------------------- */
pszGeomType = CSLFetchNameValue( papszOptions, "GEOM_TYPE" );
if( pszGeomType == NULL )
{
pszGeomType = "geometry";
}
if( !EQUAL(pszGeomType,"geometry") && !EQUAL(pszGeomType, "geography"))
{
CPLError( CE_Failure, CPLE_AppDefined,
"GEOM_TYPE in PostGIS enabled databases must be 'geometry' or 'geography'.\n"
"Creation of layer %s with GEOM_TYPE %s has failed.",
pszLayerName, pszGeomType );
CPLFree( pszTableName );
CPLFree( pszSchemaName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Try to get the SRS Id of this spatial reference system, */
/* adding tot the srs table if needed. */
/* -------------------------------------------------------------------- */
int nUnknownSRSId = -1;
const char* pszPostgisVersion = CSLFetchNameValue( papszOptions, "POSTGIS_VERSION" );
int nPostGISMajor = 1;
int nPostGISMinor = 5;
if( pszPostgisVersion != NULL && atoi(pszPostgisVersion) >= 2 )
{
nPostGISMajor = atoi(pszPostgisVersion);
if( strchr(pszPostgisVersion, '.') )
nPostGISMinor = atoi(strchr(pszPostgisVersion, '.')+1);
else
nPostGISMinor = 0;
nUnknownSRSId = 0;
}
int nSRSId = nUnknownSRSId;
int nForcedSRSId = -2;
if( CSLFetchNameValue( papszOptions, "SRID") != NULL )
{
nSRSId = atoi(CSLFetchNameValue( papszOptions, "SRID"));
nForcedSRSId = nSRSId;
}
else
{
if (poSRS)
{
const char* pszAuthorityName = poSRS->GetAuthorityName(NULL);
if( pszAuthorityName != NULL && EQUAL( pszAuthorityName, "EPSG" ) )
{
/* Assume the EPSG Id is the SRS ID. Might be a wrong guess ! */
nSRSId = atoi( poSRS->GetAuthorityCode(NULL) );
}
else
{
const char* pszGeogCSName = poSRS->GetAttrValue("GEOGCS");
if (pszGeogCSName != NULL && EQUAL(pszGeogCSName, "GCS_WGS_1984"))
nSRSId = 4326;
}
}
}
CPLString osEscapedTableNameSingleQuote = OGRPGDumpEscapeString(pszTableName);
const char* pszEscapedTableNameSingleQuote = osEscapedTableNameSingleQuote.c_str();
const char *pszGeometryType = OGRToOGCGeomType(eType);
const char *pszGFldName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME");
if( bHavePostGIS && !EQUAL(pszGeomType, "geography"))
{
if( pszGFldName == NULL )
pszGFldName = "wkb_geometry";
if( nPostGISMajor < 2 )
{
/* Sometimes there is an old cruft entry in the geometry_columns
* table if things were not properly cleaned up before. We make
* an effort to clean out such cruft.
* Note: PostGIS 2.0 defines geometry_columns as a view (no clean up is needed)
*/
osCommand.Printf(
"DELETE FROM geometry_columns WHERE f_table_name = %s AND f_table_schema = '%s'",
pszEscapedTableNameSingleQuote, pszSchemaName );
if (bCreateTable)
Log(osCommand);
}
}
LogStartTransaction();
/* -------------------------------------------------------------------- */
/* Create a basic table with the FID. Also include the */
/* geometry if this is not a PostGIS enabled table. */
/* -------------------------------------------------------------------- */
int bFID64 = CSLFetchBoolean(papszOptions, "FID64", FALSE);
const char* pszSerialType = bFID64 ? "BIGSERIAL": "SERIAL";
CPLString osCreateTable;
int bTemporary = CSLFetchBoolean( papszOptions, "TEMPORARY", FALSE );
if (bTemporary)
{
CPLFree(pszSchemaName);
pszSchemaName = CPLStrdup("pg_temp_1");
osCreateTable.Printf("CREATE TEMPORARY TABLE \"%s\"", pszTableName);
}
else
osCreateTable.Printf("CREATE TABLE%s \"%s\".\"%s\"",
CSLFetchBoolean( papszOptions, "UNLOGGED", FALSE ) ? " UNLOGGED": "",
pszSchemaName, pszTableName);
if( !bHavePostGIS )
{
if (eType == wkbNone)
osCommand.Printf(
"%s ( "
" %s %s, "
" CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszTableName, osFIDColumnNameEscaped.c_str() );
else
osCommand.Printf(
"%s ( "
" %s %s, "
" WKB_GEOMETRY %s, "
" CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszGeomType, pszTableName, osFIDColumnNameEscaped.c_str() );
}
else if ( EQUAL(pszGeomType, "geography") )
{
if( CSLFetchNameValue( papszOptions, "GEOMETRY_NAME") != NULL )
pszGFldName = CSLFetchNameValue( papszOptions, "GEOMETRY_NAME");
else
pszGFldName = "the_geog";
const char *suffix = "";
if( (GeometryTypeFlags & OGRGeometry::OGR_G_MEASURED) && (GeometryTypeFlags & OGRGeometry::OGR_G_3D) )
{
suffix = "ZM";
}
else if( (GeometryTypeFlags & OGRGeometry::OGR_G_MEASURED) )
{
suffix = "M";
}
else if( (GeometryTypeFlags & OGRGeometry::OGR_G_3D) )
{
suffix = "Z";
}
if (nSRSId)
osCommand.Printf(
"%s ( %s %s, \"%s\" geography(%s%s,%d), CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszGFldName, pszGeometryType, suffix, nSRSId, pszTableName, osFIDColumnNameEscaped.c_str() );
else
osCommand.Printf(
"%s ( %s %s, \"%s\" geography(%s%s), CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszGFldName, pszGeometryType, suffix, pszTableName, osFIDColumnNameEscaped.c_str() );
}
else
{
osCommand.Printf(
"%s ( %s %s, CONSTRAINT \"%s_pk\" PRIMARY KEY (%s) )",
osCreateTable.c_str(), osFIDColumnNameEscaped.c_str(), pszSerialType, pszTableName, osFIDColumnNameEscaped.c_str() );
}
if (bCreateTable)
Log(osCommand);
/* -------------------------------------------------------------------- */
/* Eventually we should be adding this table to a table of */
/* "geometric layers", capturing the WKT projection, and */
/* perhaps some other housekeeping. */
/* -------------------------------------------------------------------- */
if( bCreateTable && bHavePostGIS && !EQUAL(pszGeomType, "geography"))
{
const char *suffix = "";
if( GeometryTypeFlags == static_cast<int>(OGRGeometry::OGR_G_MEASURED) &&
wkbFlatten(eType) != wkbUnknown )
{
suffix = "M";
}
osCommand.Printf(
"SELECT AddGeometryColumn('%s',%s,'%s',%d,'%s%s',%d)",
pszSchemaName, pszEscapedTableNameSingleQuote, pszGFldName,
nSRSId, pszGeometryType, suffix, nDimension );
Log(osCommand);
}
const char *pszSI = CSLFetchNameValue( papszOptions, "SPATIAL_INDEX" );
int bCreateSpatialIndex = ( pszSI == NULL || CPLTestBool(pszSI) );
if( bCreateTable && bHavePostGIS && bCreateSpatialIndex )
{
/* -------------------------------------------------------------------- */
/* Create the spatial index. */
/* */
/* We're doing this before we add geometry and record to the table */
/* so this may not be exactly the best way to do it. */
/* -------------------------------------------------------------------- */
osCommand.Printf("CREATE INDEX \"%s_%s_geom_idx\" "
"ON \"%s\".\"%s\" "
"USING GIST (\"%s\")",
pszTableName, pszGFldName, pszSchemaName, pszTableName, pszGFldName);
Log(osCommand);
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRPGDumpLayer *poLayer;
int bWriteAsHex = !CSLFetchBoolean(papszOptions,"WRITE_EWKT_GEOM",FALSE);
poLayer = new OGRPGDumpLayer( this, pszSchemaName, pszTableName,
osFIDColumnName, bWriteAsHex, bCreateTable );
poLayer->SetLaunderFlag( CSLFetchBoolean(papszOptions,"LAUNDER",TRUE) );
poLayer->SetPrecisionFlag( CSLFetchBoolean(papszOptions,"PRECISION",TRUE));
const char* pszOverrideColumnTypes = CSLFetchNameValue( papszOptions, "COLUMN_TYPES" );
poLayer->SetOverrideColumnTypes(pszOverrideColumnTypes);
poLayer->SetUnknownSRSId(nUnknownSRSId);
poLayer->SetForcedSRSId(nForcedSRSId);
poLayer->SetCreateSpatialIndexFlag(bCreateSpatialIndex);
poLayer->SetPostGISVersion(nPostGISMajor, nPostGISMinor);
poLayer->SetForcedGeometryTypeFlags(ForcedGeometryTypeFlags);
const char* pszDescription = CSLFetchNameValue(papszOptions, "DESCRIPTION");
if( pszDescription != NULL )
poLayer->SetForcedDescription( pszDescription );
if( bHavePostGIS )
{
OGRGeomFieldDefn oTmp( pszGFldName, eType );
OGRPGDumpGeomFieldDefn *poGeomField =
new OGRPGDumpGeomFieldDefn(&oTmp);
poGeomField->nSRSId = nSRSId;
poGeomField->GeometryTypeFlags = GeometryTypeFlags;
poLayer->GetLayerDefn()->AddGeomFieldDefn(poGeomField, FALSE);
}
else if( pszGFldName )
poLayer->SetGeometryFieldName(pszGFldName);
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
papoLayers = (OGRPGDumpLayer **)
CPLRealloc( papoLayers, sizeof(OGRPGDumpLayer *) * (nLayers+1) );
papoLayers[nLayers++] = poLayer;
CPLFree( pszTableName );
CPLFree( pszSchemaName );
return poLayer;
}
