VSIOSSHandleHelper* VSIOSSHandleHelper::BuildFromURI( const char* pszURI,
const char* pszFSPrefix,
bool bAllowNoObject,
CSLConstList papszOptions )
{
CPLString osSecretAccessKey;
CPLString osAccessKeyId;
if( !GetConfiguration(papszOptions, osSecretAccessKey, osAccessKeyId) )
{
return nullptr;
}
const CPLString osEndpoint = CSLFetchNameValueDef(papszOptions,
"OSS_ENDPOINT",
CPLGetConfigOption("OSS_ENDPOINT", "oss-us-east-1.aliyuncs.com"));
CPLString osBucket;
CPLString osObjectKey;
if( pszURI != nullptr && pszURI[0] != '\0' &&
!GetBucketAndObjectKey(pszURI, pszFSPrefix, bAllowNoObject,
osBucket, osObjectKey) )
{
return nullptr;
}
const bool bUseHTTPS = CPLTestBool(CPLGetConfigOption("OSS_HTTPS", "YES"));
const bool bIsValidNameForVirtualHosting =
osBucket.find('.') == std::string::npos;
const bool bUseVirtualHosting = CPLTestBool(
CPLGetConfigOption("OSS_VIRTUAL_HOSTING",
bIsValidNameForVirtualHosting ? "TRUE" : "FALSE"));
return new VSIOSSHandleHelper(osSecretAccessKey, osAccessKeyId,
osEndpoint,
osBucket, osObjectKey, bUseHTTPS,
bUseVirtualHosting);
}
static GDALDataset* OGRGeoJSONDriverOpen( GDALOpenInfo* poOpenInfo )
{
GeoJSONSourceType nSrcType;
if( OGRGeoJSONDriverIdentifyInternal(poOpenInfo, nSrcType) == FALSE )
return NULL;
OGRGeoJSONDataSource* poDS
= new OGRGeoJSONDataSource();
/* -------------------------------------------------------------------- */
/* Processing configuration options. */
/* -------------------------------------------------------------------- */
// TODO: Currently, options are based on environment variables.
// This is workaround for not yet implemented Andrey's concept
// described in document 'RFC 10: OGR Open Parameters'.
poDS->SetGeometryTranslation( OGRGeoJSONDataSource::eGeometryPreserve );
const char* pszOpt = CPLGetConfigOption("GEOMETRY_AS_COLLECTION", NULL);
if( NULL != pszOpt && STARTS_WITH_CI(pszOpt, "YES") )
{
poDS->SetGeometryTranslation(
OGRGeoJSONDataSource::eGeometryAsCollection );
}
poDS->SetAttributesTranslation( OGRGeoJSONDataSource::eAttributesPreserve );
pszOpt = CPLGetConfigOption("ATTRIBUTES_SKIP", NULL);
if( NULL != pszOpt && STARTS_WITH_CI(pszOpt, "YES") )
{
poDS->SetAttributesTranslation(
OGRGeoJSONDataSource::eAttributesSkip );
}
/* -------------------------------------------------------------------- */
/* Open and start processing GeoJSON datasource to OGR objects. */
/* -------------------------------------------------------------------- */
if( !poDS->Open( poOpenInfo, nSrcType ) )
{
delete poDS;
poDS = NULL;
}
if( poDS != NULL && poDS->HasOtherPages() )
{
const char* pszFSP = CSLFetchNameValue(poOpenInfo->papszOpenOptions,
"FEATURE_SERVER_PAGING");
bool bHasResultOffset = CPLURLGetValue( poOpenInfo->pszFilename,
"resultOffset").size() > 0;
if( (!bHasResultOffset && (pszFSP == NULL || CPLTestBool(pszFSP))) ||
(bHasResultOffset && pszFSP != NULL && CPLTestBool(pszFSP)) )
{
return new OGRESRIFeatureServiceDataset(poOpenInfo->pszFilename,
poDS);
}
}
return poDS;
}
int OGRMDBDataSource::Open( const char * pszNewName )
{
CPLAssert( nLayers == 0 );
pszName = CPLStrdup( pszNewName );
if (!env.Init())
return FALSE;
poDB = OGRMDBDatabase::Open(&env, pszNewName);
if (!poDB)
return FALSE;
poDB->FetchTableNames();
/* Is it a ESRI Personal Geodatabase ? */
OGRMDBTable* poGDB_GeomColumns = poDB->GetTable("GDB_GeomColumns");
if (poGDB_GeomColumns && !CPLTestBool(CPLGetConfigOption("MDB_RAW", "OFF")))
{
int nRet = OpenGDB(poGDB_GeomColumns);
delete poGDB_GeomColumns;
return nRet;
}
delete poGDB_GeomColumns;
/* Is it a Geomedia warehouse ? */
OGRMDBTable* poGAliasTable = poDB->GetTable("GAliasTable");
if (poGAliasTable && !CPLTestBool(CPLGetConfigOption("MDB_RAW", "OFF")))
{
int nRet = OpenGeomediaWarehouse(poGAliasTable);
delete poGAliasTable;
return nRet;
}
delete poGAliasTable;
/* Well, no, just a regular MDB */
int nTables = (int) poDB->apoTableNames.size();
for(int i=0;i<nTables;i++)
{
OGRMDBTable* poTable = poDB->GetTable(poDB->apoTableNames[i]);
if (poTable == NULL)
continue;
OGRMDBLayer* poLayer = new OGRMDBLayer( this, poTable );
if( poLayer->BuildFeatureDefn() != CE_None )
{
delete poLayer;
continue;
}
papoLayers = (OGRMDBLayer**)CPLRealloc(papoLayers, (nLayers+1) * sizeof(OGRMDBLayer*));
papoLayers[nLayers++] = poLayer;
}
return TRUE;
}
static CPLLockType GetLockType()
{
static int nLockType = -1;
if( nLockType < 0 )
{
const char* pszLockType =
CPLGetConfigOption("GDAL_RB_LOCK_TYPE", "ADAPTIVE");
if( EQUAL(pszLockType, "ADAPTIVE") )
nLockType = LOCK_ADAPTIVE_MUTEX;
else if( EQUAL(pszLockType, "RECURSIVE") )
nLockType = LOCK_RECURSIVE_MUTEX;
else if( EQUAL(pszLockType, "SPIN") )
nLockType = LOCK_SPIN;
else
{
CPLError(
CE_Warning, CPLE_NotSupported,
"GDAL_RB_LOCK_TYPE=%s not supported. Falling back to ADAPTIVE",
pszLockType);
nLockType = LOCK_ADAPTIVE_MUTEX;
}
bDebugContention = CPLTestBool(
CPLGetConfigOption("GDAL_RB_LOCK_DEBUG_CONTENTION", "NO"));
}
return (CPLLockType) nLockType;
}
int CPLGetExecPath( char *pszPathBuf, int nMaxLength )
{
if( CPLTestBool( CPLGetConfigOption( "GDAL_FILENAME_IS_UTF8", "YES" ) ) )
{
wchar_t *pwszPathBuf = static_cast<wchar_t *>(
CPLCalloc(nMaxLength + 1, sizeof(wchar_t)));
if( GetModuleFileNameW( nullptr, pwszPathBuf, nMaxLength ) == 0 )
{
CPLFree( pwszPathBuf );
return FALSE;
}
else
{
char *pszDecoded =
CPLRecodeFromWChar(pwszPathBuf, CPL_ENC_UCS2, CPL_ENC_UTF8);
strncpy( pszPathBuf, pszDecoded, nMaxLength );
CPLFree( pszDecoded );
CPLFree( pwszPathBuf );
return TRUE;
}
}
else
{
if( GetModuleFileNameA( nullptr, pszPathBuf, nMaxLength ) == 0 )
return FALSE;
else
return TRUE;
}
}
static
void* OGRSQLiteRegisterRegExpFunction(sqlite3*
#ifdef HAVE_PCRE
hDB
#endif
)
{
#ifdef HAVE_PCRE
/* For debugging purposes mostly */
if( !CPLTestBool(CPLGetConfigOption("OGR_SQLITE_REGEXP", "YES")) )
return nullptr;
/* Check if we really need to define our own REGEXP function */
int rc = sqlite3_exec(hDB, "SELECT 'a' REGEXP 'a'", nullptr, nullptr, nullptr);
if( rc == SQLITE_OK )
{
CPLDebug("SQLITE", "REGEXP already available");
return nullptr;
}
cache_entry *cache = (cache_entry*) CPLCalloc(CACHE_SIZE, sizeof(cache_entry));
sqlite3_create_function(hDB, "REGEXP", 2, SQLITE_UTF8, cache,
OGRSQLiteREGEXPFunction, nullptr, nullptr);
/* To clear the error flag */
sqlite3_exec(hDB, "SELECT 1", nullptr, nullptr, nullptr);
return cache;
#else // HAVE_PCRE
return nullptr;
#endif // HAVE_PCRE
}
CPLErr GDALDefaultOverviews::CleanOverviews()
{
// Anything to do?
if( poODS == NULL )
return CE_None;
// Delete the overview file(s).
GDALDriver *poOvrDriver = poODS->GetDriver();
GDALClose( poODS );
poODS = NULL;
const CPLErr eErr = poOvrDriver != NULL ?
poOvrDriver->Delete( osOvrFilename ) : CE_None;
// Reset the saved overview filename.
if( !EQUAL(poDS->GetDescription(),":::VIRTUAL:::") )
{
const bool bUseRRD = CPLTestBool(CPLGetConfigOption("USE_RRD","NO"));
if( bUseRRD )
osOvrFilename = CPLResetExtension( poDS->GetDescription(), "aux" );
else
osOvrFilename.Printf( "%s.ovr", poDS->GetDescription() );
}
else
{
osOvrFilename = "";
}
return eErr;
}
DTEDDataset::DTEDDataset() :
pszFilename(CPLStrdup("unknown")),
psDTED(nullptr),
bVerifyChecksum(CPLTestBool(
CPLGetConfigOption("DTED_VERIFY_CHECKSUM", "NO"))),
pszProjection(CPLStrdup(""))
{}
OGRUKOOAP190Layer::OGRUKOOAP190Layer( const char* pszFilename,
VSILFILE* fpIn ) :
poSRS(nullptr),
fp(fpIn),
bUseEastingNorthingAsGeometry(CPLTestBool(
CPLGetConfigOption("UKOOAP190_USE_EASTING_NORTHING", "NO"))),
nYear(0)
{
nNextFID = 0;
bEOF = false;
poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbPoint );
for( int i = 0;
i < static_cast<int>(sizeof(UKOOAP190Fields) /
sizeof(UKOOAP190Fields[0]));
i++ )
{
OGRFieldDefn oField( UKOOAP190Fields[i].pszName,
UKOOAP190Fields[i].eType );
poFeatureDefn->AddFieldDefn( &oField );
}
ParseHeaders();
poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS);
}
OGRSEGP1Layer::OGRSEGP1Layer( const char* pszFilename,
VSILFILE* fpIn,
int nLatitudeColIn ) :
poSRS(nullptr),
fp(fpIn),
nLatitudeCol(nLatitudeColIn),
bUseEastingNorthingAsGeometry(CPLTestBool(
CPLGetConfigOption("SEGP1_USE_EASTING_NORTHING", "NO")))
{
nNextFID = 0;
bEOF = false;
poFeatureDefn = new OGRFeatureDefn( CPLGetBasename(pszFilename) );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbPoint );
for(int i=0;i<(int)(sizeof(SEGP1Fields)/sizeof(SEGP1Fields[0]));i++)
{
OGRFieldDefn oField( SEGP1Fields[i].pszName,
SEGP1Fields[i].eType );
poFeatureDefn->AddFieldDefn( &oField );
}
OGRSEGP1Layer::ResetReading();
}
bool OGRCouchDBDataSource::IsOK(json_object* poAnswerObj,
const char* pszErrorMsg)
{
if ( poAnswerObj == NULL ||
!json_object_is_type(poAnswerObj, json_type_object) )
{
CPLError(CE_Failure, CPLE_AppDefined, "%s",
pszErrorMsg);
return false;
}
json_object* poOK = CPL_json_object_object_get(poAnswerObj, "ok");
if ( !poOK )
{
IsError(poAnswerObj, pszErrorMsg);
return false;
}
const char* pszOK = json_object_get_string(poOK);
if ( !pszOK || !CPLTestBool(pszOK) )
{
CPLError(CE_Failure, CPLE_AppDefined, "%s", pszErrorMsg);
return false;
}
return true;
}
OGRGeoJSONSeqWriteLayer::OGRGeoJSONSeqWriteLayer(
OGRGeoJSONSeqDataSource* poDS,
const char* pszName,
CSLConstList papszOptions,
OGRCoordinateTransformation* poCT):
m_poDS(poDS)
{
SetDescription(pszName);
m_poFeatureDefn = new OGRFeatureDefn(pszName);
m_poFeatureDefn->Reference();
m_poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(
OGRSpatialReference::GetWGS84SRS());
m_poCT = poCT;
m_oWriteOptions.SetRFC7946Settings();
m_oWriteOptions.SetIDOptions(papszOptions);
m_oWriteOptions.nCoordPrecision = atoi(
CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "7"));
m_oWriteOptions.nSignificantFigures = atoi(
CSLFetchNameValueDef(papszOptions, "SIGNIFICANT_FIGURES", "-1"));
m_bRS = EQUAL(CPLGetExtension(poDS->GetDescription()), "GEOJSONS");
const char* pszRS = CSLFetchNameValue(papszOptions, "RS");
if( pszRS )
{
m_bRS = CPLTestBool(pszRS);
}
}
/*
* Open()
*/
bool OGRNGWDataset::Open( const std::string &osUrlIn,
const std::string &osResourceIdIn, char **papszOpenOptionsIn,
bool bUpdateIn, int nOpenFlagsIn )
{
osUrl = osUrlIn;
osResourceId = osResourceIdIn;
bReadWrite = bUpdateIn;
osUserPwd = CSLFetchNameValueDef( papszOpenOptionsIn, "USERPWD",
CPLGetConfigOption("NGW_USERPWD", ""));
nBatchSize = atoi( CSLFetchNameValueDef( papszOpenOptionsIn,
"BATCH_SIZE", CPLGetConfigOption("NGW_BATCH_SIZE", "-1") ) );
nPageSize = atoi( CSLFetchNameValueDef(papszOpenOptionsIn, "PAGE_SIZE",
CPLGetConfigOption("NGW_PAGE_SIZE", "-1") ) );
if( nPageSize == 0 )
{
nPageSize = -1;
}
nCacheExpires = atoi( CSLFetchNameValueDef(papszOpenOptionsIn, "CACHE_EXPIRES",
CPLGetConfigOption("NGW_CACHE_EXPIRES", "604800") ) );
nCacheMaxSize = atoi( CSLFetchNameValueDef(papszOpenOptionsIn, "CACHE_MAX_SIZE",
CPLGetConfigOption("NGW_CACHE_MAX_SIZE", "67108864") ) );
bExtInNativeData = CPLFetchBool( papszOpenOptionsIn, "NATIVE_DATA",
CPLTestBool( CPLGetConfigOption("NGW_NATIVE_DATA", "NO") ) );
return Init( nOpenFlagsIn );
}
const char *DTEDDataset::_GetProjectionRef()
{
// get xml and aux SR first
const char* pszPrj = GDALPamDataset::_GetProjectionRef();
const char* pszVertDatum;
if(pszPrj && strlen(pszPrj) > 0)
return pszPrj;
if (pszProjection && strlen(pszProjection) > 0)
return pszProjection;
pszPrj = GetMetadataItem( "DTED_HorizontalDatum");
if (EQUAL(pszPrj, "WGS84"))
{
pszVertDatum = GetMetadataItem("DTED_VerticalDatum");
if (EQUAL(pszVertDatum, "MSL") &&
CPLTestBool( CPLGetConfigOption("REPORT_COMPD_CS", "NO") ) )
{
return "COMPD_CS[\"WGS 84 + EGM96 geoid height\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\",6378137,298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\",0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\",0.0174532925199433, AUTHORITY[\"EPSG\",\"9122\"]],AXIS[\"Latitude\",NORTH],AXIS[\"Longitude\",EAST], AUTHORITY[\"EPSG\",\"4326\"]], VERT_CS[\"EGM96 geoid height\", VERT_DATUM[\"EGM96 geoid\",2005, AUTHORITY[\"EPSG\",\"5171\"]], UNIT[\"metre\",1, AUTHORITY[\"EPSG\",\"9001\"]], AXIS[\"Up\",UP], AUTHORITY[\"EPSG\",\"5773\"]]]";
}
else
{
return SRS_WKT_WGS84_LAT_LONG;
}
}
else if (EQUAL(pszPrj, "WGS72"))
{
static bool bWarned = false;
if (!bWarned)
{
bWarned = true;
CPLError( CE_Warning, CPLE_AppDefined,
"The DTED file %s indicates WGS72 as horizontal datum. \n"
"As this is outdated nowadays, you should contact your data producer to get data georeferenced in WGS84.\n"
"In some cases, WGS72 is a wrong indication and the georeferencing is really WGS84. In that case\n"
"you might consider doing 'gdal_translate -of DTED -mo \"DTED_HorizontalDatum=WGS84\" src.dtX dst.dtX' to\n"
"fix the DTED file.\n"
"No more warnings will be issued in this session about this operation.", GetFileName() );
}
return "GEOGCS[\"WGS 72\",DATUM[\"WGS_1972\",SPHEROID[\"WGS 72\",6378135,298.26]],PRIMEM[\"Greenwich\",0],UNIT[\"degree\",0.0174532925199433],AXIS[\"Latitude\",NORTH],AXIS[\"Longitude\",EAST],AUTHORITY[\"EPSG\",\"4322\"]]";
}
else
{
static bool bWarned = false;
if (!bWarned)
{
bWarned = true;
CPLError( CE_Warning, CPLE_AppDefined,
"The DTED file %s indicates %s as horizontal datum, which is not recognized by the DTED driver. \n"
"The DTED driver is going to consider it as WGS84.\n"
"No more warnings will be issued in this session about this operation.", GetFileName(), pszPrj );
}
return SRS_WKT_WGS84_LAT_LONG;
}
}
void *CPLGetSymbol( const char * pszLibrary, const char * pszSymbolName )
{
void *pLibrary = nullptr;
void *pSymbol = nullptr;
// Avoid error boxes to pop up (#5211, #5525).
UINT uOldErrorMode =
SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
#if defined(_MSC_VER) || __MSVCRT_VERSION__ >= 0x0601
if( CPLTestBool( CPLGetConfigOption( "GDAL_FILENAME_IS_UTF8", "YES" ) ) )
{
wchar_t *pwszFilename =
CPLRecodeToWChar( pszLibrary, CPL_ENC_UTF8, CPL_ENC_UCS2 );
pLibrary = LoadLibraryW(pwszFilename);
CPLFree( pwszFilename );
}
else
#endif
{
pLibrary = LoadLibraryA(pszLibrary);
}
if( pLibrary <= (void*)HINSTANCE_ERROR )
{
LPVOID lpMsgBuf = nullptr;
int nLastError = GetLastError();
// Restore old error mode.
SetErrorMode(uOldErrorMode);
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
| FORMAT_MESSAGE_IGNORE_INSERTS,
nullptr, nLastError,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
reinterpret_cast<LPTSTR>(&lpMsgBuf), 0, nullptr );
CPLError( CE_Failure, CPLE_AppDefined,
"Can't load requested DLL: %s\n%d: %s",
pszLibrary, nLastError, static_cast<const char *>(lpMsgBuf) );
return nullptr;
}
// Restore old error mode.
SetErrorMode(uOldErrorMode);
pSymbol = reinterpret_cast<void *>(GetProcAddress( static_cast<HINSTANCE>(pLibrary), pszSymbolName ));
if( pSymbol == nullptr )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Can't find requested entry point: %s", pszSymbolName );
return nullptr;
}
return( pSymbol );
}
static bool CPLGetXMLBoolValue(CPLXMLNode* psNode,
const char* pszKey,
bool bDefault)
{
const char* pszVal = CPLGetXMLValue(psNode, pszKey, NULL);
if( pszVal )
return CPLTestBool(pszVal);
else
return bDefault;
}
OGRGMLLayer::OGRGMLLayer( const char * pszName,
bool bWriterIn,
OGRGMLDataSource *poDSIn )
{
iNextGMLId = 0;
nTotalGMLCount = -1;
bInvalidFIDFound = false;
pszFIDPrefix = NULL;
bFaceHoleNegative = false;
poDS = poDSIn;
if ( STARTS_WITH_CI(pszName, "ogr:") )
poFeatureDefn = new OGRFeatureDefn( pszName+4 );
else
poFeatureDefn = new OGRFeatureDefn( pszName );
SetDescription( poFeatureDefn->GetName() );
poFeatureDefn->Reference();
poFeatureDefn->SetGeomType( wkbNone );
bWriter = bWriterIn;
bSameSRS = false;
/* -------------------------------------------------------------------- */
/* Reader's should get the corresponding GMLFeatureClass and */
/* cache it. */
/* -------------------------------------------------------------------- */
if( !bWriter )
poFClass = poDS->GetReader()->GetClass( pszName );
else
poFClass = NULL;
hCacheSRS = GML_BuildOGRGeometryFromList_CreateCache();
/* Compatibility option. Not advertized, because hopefully won't be needed */
/* Just put here in provision... */
bUseOldFIDFormat = CPLTestBool(CPLGetConfigOption("GML_USE_OLD_FID_FORMAT", "FALSE"));
/* Must be in synced in OGR_G_CreateFromGML(), OGRGMLLayer::OGRGMLLayer() and GMLReader::GMLReader() */
bFaceHoleNegative = CPLTestBool(CPLGetConfigOption("GML_FACE_HOLE_NEGATIVE", "NO"));
}
OGRShapeDataSource::OGRShapeDataSource() :
papoLayers(NULL),
nLayers(0),
pszName(NULL),
bDSUpdate(false),
bSingleFileDataSource(false),
poPool(new OGRLayerPool()),
b2GBLimit(CPLTestBool(CPLGetConfigOption("SHAPE_2GB_LIMIT", "FALSE"))),
papszOpenOptions(NULL)
{}
int OGRXLSDataSource::Open( const char * pszFilename, int bUpdateIn)
{
if (bUpdateIn)
{
return FALSE;
}
#ifdef _WIN32
if( CPLTestBool( CPLGetConfigOption( "GDAL_FILENAME_IS_UTF8", "YES" ) ) )
pszName = CPLRecode( pszFilename, CPL_ENC_UTF8, CPLString().Printf( "CP%d", GetACP() ) );
else
pszName = CPLStrdup( pszFilename );
#else
pszName = CPLStrdup( pszFilename );
#endif
// --------------------------------------------------------------------
// Does this appear to be a .xls file?
// --------------------------------------------------------------------
/* Open only for getting info. To get cell values, we have to use freexl_open */
if (freexl_open_info (pszName, &xlshandle) != FREEXL_OK)
return FALSE;
unsigned int nSheets = 0;
if (freexl_get_info (xlshandle, FREEXL_BIFF_SHEET_COUNT, &nSheets) != FREEXL_OK)
return FALSE;
for(unsigned short i=0; i<(unsigned short)nSheets; i++)
{
freexl_select_active_worksheet(xlshandle, i);
const char* pszSheetname = NULL;
if (freexl_get_worksheet_name(xlshandle, i, &pszSheetname) != FREEXL_OK)
return FALSE;
unsigned int nRows = 0;
unsigned short nCols = 0;
if (freexl_worksheet_dimensions(xlshandle, &nRows, &nCols) != FREEXL_OK)
return FALSE;
/* Skip empty sheets */
if (nRows == 0)
continue;
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = new OGRXLSLayer(this, pszSheetname, i, (int)nRows, nCols);
}
freexl_close(xlshandle);
xlshandle = NULL;
return TRUE;
}
const char *SRTMHGTDataset::GetProjectionRef()
{
if (CPLTestBool( CPLGetConfigOption("REPORT_COMPD_CS", "NO") ) )
{
return "COMPD_CS[\"WGS 84 + EGM96 geoid height\", GEOGCS[\"WGS 84\", DATUM[\"WGS_1984\", SPHEROID[\"WGS 84\",6378137,298.257223563, AUTHORITY[\"EPSG\",\"7030\"]], AUTHORITY[\"EPSG\",\"6326\"]], PRIMEM[\"Greenwich\",0, AUTHORITY[\"EPSG\",\"8901\"]], UNIT[\"degree\",0.0174532925199433, AUTHORITY[\"EPSG\",\"9122\"]], AUTHORITY[\"EPSG\",\"4326\"]], VERT_CS[\"EGM96 geoid height\", VERT_DATUM[\"EGM96 geoid\",2005, AUTHORITY[\"EPSG\",\"5171\"]], UNIT[\"metre\",1, AUTHORITY[\"EPSG\",\"9001\"]], AXIS[\"Up\",UP], AUTHORITY[\"EPSG\",\"5773\"]]]";
}
else
{
return SRS_WKT_WGS84;
}
}
OGRDXFWriterLayer::OGRDXFWriterLayer( OGRDXFWriterDS *poDSIn, VSILFILE *fpIn ) :
fp(fpIn),
poFeatureDefn(nullptr), // TODO(schwehr): Can I move the new here?
poDS(poDSIn)
{
nNextAutoID = 1;
bWriteHatch = CPLTestBool(CPLGetConfigOption("DXF_WRITE_HATCH", "YES"));
poFeatureDefn = new OGRFeatureDefn( "entities" );
poFeatureDefn->Reference();
OGRDXFDataSource::AddStandardFields( poFeatureDefn,
ODFM_IncludeBlockFields );
}
OGRGeoJSONWriteLayer::OGRGeoJSONWriteLayer( const char* pszName,
OGRwkbGeometryType eGType,
char** papszOptions,
bool bWriteFC_BBOXIn,
OGRCoordinateTransformation* poCT,
OGRGeoJSONDataSource* poDS ) :
poDS_(poDS),
poFeatureDefn_(new OGRFeatureDefn( pszName )),
nOutCounter_(0),
bWriteBBOX(CPLTestBool(
CSLFetchNameValueDef(papszOptions, "WRITE_BBOX", "FALSE"))),
bBBOX3D(false),
bWriteFC_BBOX(bWriteFC_BBOXIn),
nCoordPrecision_(atoi(
CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"))),
nSignificantFigures_(atoi(
CSLFetchNameValueDef(papszOptions, "SIGNIFICANT_FIGURES", "-1"))),
bRFC7946_(CPLTestBool(
CSLFetchNameValueDef(papszOptions, "RFC7946", "FALSE"))),
poCT_(poCT)
{
poFeatureDefn_->Reference();
poFeatureDefn_->SetGeomType( eGType );
SetDescription( poFeatureDefn_->GetName() );
if( bRFC7946_ && nCoordPrecision_ < 0 )
nCoordPrecision_ = 7;
oWriteOptions_.bWriteBBOX = bWriteBBOX;
oWriteOptions_.nCoordPrecision = nCoordPrecision_;
oWriteOptions_.nSignificantFigures = nSignificantFigures_;
if( bRFC7946_ )
{
oWriteOptions_.SetRFC7946Settings();
}
oWriteOptions_.SetIDOptions(papszOptions);
oWriteOptions_.bAllowNonFiniteValues = CPLTestBool(
CSLFetchNameValueDef(papszOptions, "WRITE_NON_FINITE_VALUES", "FALSE"));
}
CPLErr VRTRasterBand::SetMetadataItem( const char *pszName,
const char *pszValue,
const char *pszDomain )
{
reinterpret_cast<VRTDataset *>( poDS )->SetNeedsFlush();
if( EQUAL(pszName,"HideNoDataValue") )
{
m_bHideNoDataValue = CPLTestBool( pszValue );
return CE_None;
}
return GDALRasterBand::SetMetadataItem( pszName, pszValue, pszDomain );
}
DTEDRasterBand::DTEDRasterBand( DTEDDataset *poDSIn, int nBandIn ) :
bNoDataSet(TRUE),
dfNoDataValue(static_cast<double>(DTED_NODATA_VALUE))
{
poDS = poDSIn;
nBand = nBandIn;
eDataType = GDT_Int16;
/* For some applications, it may be valuable to consider the whole DTED */
/* file as single block, as the column orientation doesn't fit very well */
/* with some scanline oriented algorithms */
/* Of course you need to have a big enough case size, particularly for DTED 2 */
/* datasets */
nBlockXSize = CPLTestBool(CPLGetConfigOption("GDAL_DTED_SINGLE_BLOCK", "NO")) ?
poDS->GetRasterXSize() : 1;
nBlockYSize = poDS->GetRasterYSize();
}
OGRErr OGRSpatialReference::Validate()
{
/* -------------------------------------------------------------------- */
/* Validate root node. */
/* -------------------------------------------------------------------- */
if( poRoot == NULL )
{
CPLDebug( "OGRSpatialReference::Validate",
"No root pointer.\n" );
return OGRERR_CORRUPT_DATA;
}
OGRErr eErr = Validate(poRoot);
/* Even if hand-validation has succeeded, try a more formal validation */
/* using the CT spec grammar */
static int bUseCTGrammar = -1;
if( bUseCTGrammar < 0 )
bUseCTGrammar = CPLTestBool(CPLGetConfigOption("OSR_USE_CT_GRAMMAR", "TRUE"));
if( eErr == OGRERR_NONE && bUseCTGrammar )
{
osr_cs_wkt_parse_context sContext;
char* pszWKT = NULL;
exportToWkt(&pszWKT);
sContext.pszInput = pszWKT;
sContext.pszLastSuccess = pszWKT;
sContext.pszNext = pszWKT;
sContext.szErrorMsg[0] = '\0';
if( osr_cs_wkt_parse(&sContext) != 0 )
{
CPLDebug( "OGRSpatialReference::Validate", "%s",
sContext.szErrorMsg );
eErr = OGRERR_CORRUPT_DATA;
}
CPLFree(pszWKT);
}
return eErr;
}
/*!
\brief VFKReaderSQLite destructor
*/
VFKReaderSQLite::~VFKReaderSQLite()
{
/* close tmp SQLite DB */
if (SQLITE_OK != sqlite3_close(m_poDB)) {
CPLError(CE_Failure, CPLE_AppDefined,
"Closing SQLite DB failed\n %s",
sqlite3_errmsg(m_poDB));
}
CPLDebug("OGR-VFK", "Internal DB (%s) closed",
m_pszDBname);
/* delete tmp SQLite DB if requested */
if (CPLTestBool(CPLGetConfigOption("OGR_VFK_DB_DELETE", "NO"))) {
CPLDebug("OGR-VFK", "Internal DB (%s) deleted",
m_pszDBname);
VSIUnlink(m_pszDBname);
}
delete[] m_pszDBname;
}
SHPHandle OGRShapeDataSource::DS_SHPOpen( const char * pszShapeFile,
const char * pszAccess )
{
// Do lazy shx loading for /vsicurl/
if( STARTS_WITH(pszShapeFile, "/vsicurl/") &&
strcmp(pszAccess, "r") == 0 )
pszAccess = "rl";
const bool bRestoreSHX =
CPLTestBool( CPLGetConfigOption("SHAPE_RESTORE_SHX", "FALSE") );
SHPHandle hSHP =
SHPOpenLLEx( pszShapeFile, pszAccess,
const_cast<SAHooks *>(VSI_SHP_GetHook(b2GBLimit)),
bRestoreSHX );
if( hSHP != NULL )
SHPSetFastModeReadObject( hSHP, TRUE );
return hSHP;
}
// static function- pointer set in driver
GDALDataset *KEADataset::Create( const char * pszFilename,
int nXSize, int nYSize, int nBands,
GDALDataType eType,
char ** papszParmList )
{
H5::H5File *keaImgH5File = CreateLL( pszFilename, nXSize, nYSize, nBands,
eType, papszParmList );
if( keaImgH5File == NULL )
return NULL;
bool bThematic =
CPLTestBool(CSLFetchNameValueDef( papszParmList, "THEMATIC", "FALSE" ));
try
{
// create our dataset object
KEADataset *pDataset = new KEADataset( keaImgH5File, GA_Update );
pDataset->SetDescription( pszFilename );
// set all to thematic if asked
if( bThematic )
{
for( int nCount = 0; nCount < nBands; nCount++ )
{
GDALRasterBand *pBand = pDataset->GetRasterBand(nCount+1);
pBand->SetMetadataItem("LAYER_TYPE", "thematic");
}
}
return pDataset;
}
catch (kealib::KEAIOException &e)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed. Error: %s\n",
pszFilename, e.what() );
return NULL;
}
}
void TigerFileBase::AddFieldDefns(const TigerRecordInfo *psRTInfoIn,
OGRFeatureDefn *poFeatureDefnIn)
{
OGRFieldDefn oField("",OFTInteger);
int i, bLFieldHack;
bLFieldHack =
CPLTestBool( CPLGetConfigOption( "TIGER_LFIELD_AS_STRING", "NO" ) );
for (i=0; i<psRTInfoIn->nFieldCount; ++i) {
if (psRTInfoIn->pasFields[i].bDefine) {
OGRFieldType eFT = (OGRFieldType)psRTInfoIn->pasFields[i].OGRtype;
if( bLFieldHack
&& psRTInfoIn->pasFields[i].cFmt == 'L'
&& psRTInfoIn->pasFields[i].cType == 'N' )
eFT = OFTString;
oField.Set( psRTInfoIn->pasFields[i].pszFieldName, eFT,
psRTInfoIn->pasFields[i].nLen );
poFeatureDefnIn->AddFieldDefn( &oField );
}
}
}
GDALDataset * AAIGDataset::CreateCopy(
const char *pszFilename, GDALDataset *poSrcDS,
int /* bStrict */,
char **papszOptions,
GDALProgressFunc pfnProgress, void *pProgressData )
{
const int nBands = poSrcDS->GetRasterCount();
const int nXSize = poSrcDS->GetRasterXSize();
const int nYSize = poSrcDS->GetRasterYSize();
// Some rudimentary checks.
if( nBands != 1 )
{
CPLError(CE_Failure, CPLE_NotSupported,
"AAIG driver doesn't support %d bands. Must be 1 band.",
nBands);
return nullptr;
}
if( !pfnProgress(0.0, nullptr, pProgressData) )
return nullptr;
// Create the dataset.
VSILFILE *fpImage = VSIFOpenL(pszFilename, "wt");
if( fpImage == nullptr )
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Unable to create file %s.",
pszFilename);
return nullptr;
}
// Write ASCII Grid file header.
double adfGeoTransform[6] = {};
char szHeader[2000] = {};
const char *pszForceCellsize =
CSLFetchNameValue(papszOptions, "FORCE_CELLSIZE");
poSrcDS->GetGeoTransform(adfGeoTransform);
if( std::abs(adfGeoTransform[1] + adfGeoTransform[5]) < 0.0000001 ||
std::abs(adfGeoTransform[1]-adfGeoTransform[5]) < 0.0000001 ||
(pszForceCellsize && CPLTestBool(pszForceCellsize)) )
{
CPLsnprintf(
szHeader, sizeof(szHeader),
"ncols %d\n"
"nrows %d\n"
"xllcorner %.12f\n"
"yllcorner %.12f\n"
"cellsize %.12f\n",
nXSize, nYSize,
adfGeoTransform[0],
adfGeoTransform[3] - nYSize * adfGeoTransform[1],
adfGeoTransform[1]);
}
else
{
if( pszForceCellsize == nullptr )
CPLError(CE_Warning, CPLE_AppDefined,
"Producing a Golden Surfer style file with DX and DY "
"instead of CELLSIZE since the input pixels are "
"non-square. Use the FORCE_CELLSIZE=TRUE creation "
"option to force use of DX for even though this will "
"be distorted. Most ASCII Grid readers (ArcGIS "
"included) do not support the DX and DY parameters.");
CPLsnprintf(
szHeader, sizeof(szHeader),
"ncols %d\n"
"nrows %d\n"
"xllcorner %.12f\n"
"yllcorner %.12f\n"
"dx %.12f\n"
"dy %.12f\n",
nXSize, nYSize,
adfGeoTransform[0],
adfGeoTransform[3] + nYSize * adfGeoTransform[5],
adfGeoTransform[1],
fabs(adfGeoTransform[5]));
}
// Builds the format string used for printing float values.
char szFormatFloat[32] = { '\0' };
strcpy(szFormatFloat, " %.20g");
const char *pszDecimalPrecision =
CSLFetchNameValue(papszOptions, "DECIMAL_PRECISION");
const char *pszSignificantDigits =
CSLFetchNameValue(papszOptions, "SIGNIFICANT_DIGITS");
bool bIgnoreSigDigits = false;
if( pszDecimalPrecision && pszSignificantDigits )
{
CPLError(CE_Warning, CPLE_AppDefined,
"Conflicting precision arguments, using DECIMAL_PRECISION");
bIgnoreSigDigits = true;
}
int nPrecision;
if ( pszSignificantDigits && !bIgnoreSigDigits )
{
nPrecision = atoi(pszSignificantDigits);
if (nPrecision >= 0)
snprintf(szFormatFloat, sizeof(szFormatFloat), " %%.%dg",
nPrecision);
CPLDebug("AAIGrid", "Setting precision format: %s", szFormatFloat);
}
else if( pszDecimalPrecision )
{
nPrecision = atoi(pszDecimalPrecision);
if ( nPrecision >= 0 )
snprintf(szFormatFloat, sizeof(szFormatFloat), " %%.%df",
nPrecision);
CPLDebug("AAIGrid", "Setting precision format: %s", szFormatFloat);
}
// Handle nodata (optionally).
GDALRasterBand *poBand = poSrcDS->GetRasterBand(1);
const bool bReadAsInt =
poBand->GetRasterDataType() == GDT_Byte ||
poBand->GetRasterDataType() == GDT_Int16 ||
poBand->GetRasterDataType() == GDT_UInt16 ||
poBand->GetRasterDataType() == GDT_Int32;
// Write `nodata' value to header if it is exists in source dataset
int bSuccess = FALSE;
const double dfNoData = poBand->GetNoDataValue(&bSuccess);
if ( bSuccess )
{
snprintf(szHeader + strlen(szHeader),
sizeof(szHeader) - strlen(szHeader), "%s", "NODATA_value ");
if( bReadAsInt )
snprintf(szHeader + strlen(szHeader),
sizeof(szHeader) - strlen(szHeader), "%d",
static_cast<int>(dfNoData));
else
CPLsnprintf(szHeader + strlen(szHeader),
sizeof(szHeader) - strlen(szHeader),
szFormatFloat, dfNoData);
snprintf(szHeader + strlen(szHeader),
sizeof(szHeader) - strlen(szHeader), "%s", "\n");
}
if( VSIFWriteL(szHeader, strlen(szHeader), 1, fpImage) != 1)
{
CPL_IGNORE_RET_VAL(VSIFCloseL(fpImage));
return nullptr;
}
// Loop over image, copying image data.
// Write scanlines to output file
int *panScanline = bReadAsInt
? static_cast<int *>(CPLMalloc(
nXSize * GDALGetDataTypeSizeBytes(GDT_Int32)))
: nullptr;
double *padfScanline =
bReadAsInt ? nullptr
: static_cast<double *>(CPLMalloc(
nXSize * GDALGetDataTypeSizeBytes(GDT_Float64)));
CPLErr eErr = CE_None;
bool bHasOutputDecimalDot = false;
for( int iLine = 0; eErr == CE_None && iLine < nYSize; iLine++ )
{
CPLString osBuf;
eErr = poBand->RasterIO(
GF_Read, 0, iLine, nXSize, 1,
bReadAsInt ? reinterpret_cast<void *>(panScanline) :
reinterpret_cast<void *>(padfScanline),
nXSize, 1, bReadAsInt ? GDT_Int32 : GDT_Float64,
0, 0, nullptr);
if( bReadAsInt )
{
for ( int iPixel = 0; iPixel < nXSize; iPixel++ )
{
snprintf(szHeader, sizeof(szHeader),
" %d", panScanline[iPixel]);
osBuf += szHeader;
if( (iPixel & 1023) == 0 || iPixel == nXSize - 1 )
{
if ( VSIFWriteL(osBuf, static_cast<int>(osBuf.size()), 1,
fpImage) != 1 )
{
eErr = CE_Failure;
CPLError(CE_Failure, CPLE_AppDefined,
"Write failed, disk full?");
break;
}
osBuf = "";
}
}
}
else
{
for ( int iPixel = 0; iPixel < nXSize; iPixel++ )
{
CPLsnprintf(szHeader, sizeof(szHeader),
szFormatFloat, padfScanline[iPixel]);
// Make sure that as least one value has a decimal point (#6060)
if( !bHasOutputDecimalDot )
{
if( strchr(szHeader, '.') || strchr(szHeader, 'e') ||
strchr(szHeader, 'E') )
{
bHasOutputDecimalDot = true;
}
else if( !CPLIsInf(padfScanline[iPixel]) &&
!CPLIsNan(padfScanline[iPixel]) )
{
strcat(szHeader, ".0");
bHasOutputDecimalDot = true;
}
}
osBuf += szHeader;
if( (iPixel & 1023) == 0 || iPixel == nXSize - 1 )
{
if ( VSIFWriteL(osBuf, static_cast<int>(osBuf.size()), 1,
fpImage) != 1 )
{
eErr = CE_Failure;
CPLError(CE_Failure, CPLE_AppDefined,
"Write failed, disk full?");
break;
}
osBuf = "";
}
}
}
if( VSIFWriteL("\n", 1, 1, fpImage) != 1 )
eErr = CE_Failure;
if( eErr == CE_None &&
!pfnProgress((iLine + 1) / static_cast<double>(nYSize), nullptr,
pProgressData) )
{
eErr = CE_Failure;
CPLError(CE_Failure, CPLE_UserInterrupt,
"User terminated CreateCopy()");
}
}
CPLFree(panScanline);
CPLFree(padfScanline);
if( VSIFCloseL(fpImage) != 0 )
eErr = CE_Failure;
if( eErr != CE_None )
return nullptr;
// Try to write projection file.
const char *pszOriginalProjection = poSrcDS->GetProjectionRef();
if( !EQUAL(pszOriginalProjection, "") )
{
char *pszDirname = CPLStrdup(CPLGetPath(pszFilename));
char *pszBasename = CPLStrdup(CPLGetBasename(pszFilename));
char *pszPrjFilename =
CPLStrdup(CPLFormFilename(pszDirname, pszBasename, "prj"));
VSILFILE *fp = VSIFOpenL(pszPrjFilename, "wt");
if (fp != nullptr)
{
OGRSpatialReference oSRS;
oSRS.importFromWkt(pszOriginalProjection);
oSRS.morphToESRI();
char *pszESRIProjection = nullptr;
oSRS.exportToWkt(&pszESRIProjection);
CPL_IGNORE_RET_VAL(VSIFWriteL(pszESRIProjection, 1,
strlen(pszESRIProjection), fp));
CPL_IGNORE_RET_VAL(VSIFCloseL(fp));
CPLFree(pszESRIProjection);
}
else
{
CPLError(CE_Failure, CPLE_FileIO, "Unable to create file %s.",
pszPrjFilename);
}
CPLFree(pszDirname);
CPLFree(pszBasename);
CPLFree(pszPrjFilename);
}
// Re-open dataset, and copy any auxiliary pam information.
// If writing to stdout, we can't reopen it, so return
// a fake dataset to make the caller happy.
CPLPushErrorHandler(CPLQuietErrorHandler);
GDALPamDataset *poDS =
reinterpret_cast<GDALPamDataset *>(GDALOpen(pszFilename, GA_ReadOnly));
CPLPopErrorHandler();
if (poDS)
{
poDS->CloneInfo(poSrcDS, GCIF_PAM_DEFAULT);
return poDS;
}
CPLErrorReset();
AAIGDataset *poAAIG_DS = new AAIGDataset();
poAAIG_DS->nRasterXSize = nXSize;
poAAIG_DS->nRasterYSize = nYSize;
poAAIG_DS->nBands = 1;
poAAIG_DS->SetBand(1, new AAIGRasterBand(poAAIG_DS, 1));
return poAAIG_DS;
}
