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 );
}
bool VSIOSSHandleHelper::GetConfiguration(CSLConstList papszOptions,
CPLString& osSecretAccessKey,
CPLString& osAccessKeyId)
{
osSecretAccessKey = CSLFetchNameValueDef(papszOptions,
"OSS_SECRET_ACCESS_KEY",
CPLGetConfigOption("OSS_SECRET_ACCESS_KEY", ""));
if( !osSecretAccessKey.empty() )
{
osAccessKeyId = CSLFetchNameValueDef(papszOptions,
"OSS_ACCESS_KEY_ID",
CPLGetConfigOption("OSS_ACCESS_KEY_ID", ""));
if( osAccessKeyId.empty() )
{
VSIError(VSIE_AWSInvalidCredentials,
"OSS_ACCESS_KEY_ID configuration option not defined");
return false;
}
return true;
}
VSIError(VSIE_AWSInvalidCredentials,
"OSS_SECRET_ACCESS_KEY configuration option not defined");
return false;
}
char *OGR_G_ExportToGMLEx( OGRGeometryH hGeometry, char** papszOptions )
{
char *pszText;
int nLength = 0, nMaxLength = 1;
if( hGeometry == NULL )
return CPLStrdup( "" );
pszText = (char *) CPLMalloc(nMaxLength);
pszText[0] = '\0';
const char* pszFormat = CSLFetchNameValue(papszOptions, "FORMAT");
if (pszFormat && EQUAL(pszFormat, "GML3"))
{
const char* pszLineStringElement = CSLFetchNameValue(papszOptions, "GML3_LINESTRING_ELEMENT");
int bLineStringAsCurve = (pszLineStringElement && EQUAL(pszLineStringElement, "curve"));
int bLongSRS = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "GML3_LONGSRS", "YES"));
const char* pszGMLId = CSLFetchNameValue(papszOptions, "GMLID");
const char* pszSRSDimensionLoc = CSLFetchNameValueDef(papszOptions,"SRSDIMENSION_LOC","POSLIST");
char** papszSRSDimensionLoc = CSLTokenizeString2(pszSRSDimensionLoc, ",", 0);
int nSRSDimensionLocFlags = 0;
for(int i=0; papszSRSDimensionLoc[i] != NULL; i++)
{
if( EQUAL(papszSRSDimensionLoc[i], "POSLIST") )
nSRSDimensionLocFlags |= SRSDIM_LOC_POSLIST;
else if( EQUAL(papszSRSDimensionLoc[i], "GEOMETRY") )
nSRSDimensionLocFlags |= SRSDIM_LOC_GEOMETRY;
else
CPLDebug("OGR", "Unrecognized location for srsDimension : %s",
papszSRSDimensionLoc[i]);
}
CSLDestroy(papszSRSDimensionLoc);
if( !OGR2GML3GeometryAppend( (OGRGeometry *) hGeometry, NULL, &pszText,
&nLength, &nMaxLength, FALSE, bLongSRS,
bLineStringAsCurve, pszGMLId, nSRSDimensionLocFlags, FALSE ))
{
CPLFree( pszText );
return NULL;
}
else
return pszText;
}
if( !OGR2GMLGeometryAppend( (OGRGeometry *) hGeometry, &pszText,
&nLength, &nMaxLength, FALSE ))
{
CPLFree( pszText );
return NULL;
}
else
return pszText;
}
CPLString VSIOSSHandleHelper::GetSignedURL(CSLConstList papszOptions)
{
GIntBig nStartDate = static_cast<GIntBig>(time(nullptr));
const char* pszStartDate = CSLFetchNameValue(papszOptions, "START_DATE");
if( pszStartDate )
{
int nYear, nMonth, nDay, nHour, nMin, nSec;
if( sscanf(pszStartDate, "%04d%02d%02dT%02d%02d%02dZ",
&nYear, &nMonth, &nDay, &nHour, &nMin, &nSec) == 6 )
{
struct tm brokendowntime;
brokendowntime.tm_year = nYear - 1900;
brokendowntime.tm_mon = nMonth - 1;
brokendowntime.tm_mday = nDay;
brokendowntime.tm_hour = nHour;
brokendowntime.tm_min = nMin;
brokendowntime.tm_sec = nSec;
nStartDate = CPLYMDHMSToUnixTime(&brokendowntime);
}
}
GIntBig nExpiresIn = nStartDate + atoi(
CSLFetchNameValueDef(papszOptions, "EXPIRATION_DELAY", "3600"));
CPLString osExpires(CSLFetchNameValueDef(papszOptions, "EXPIRES",
CPLSPrintf(CPL_FRMT_GIB, nExpiresIn)));
CPLString osVerb(CSLFetchNameValueDef(papszOptions, "VERB", "GET"));
CPLString osCanonicalizedResource( m_osBucket.empty() ? CPLString("/") :
"/" + m_osBucket + "/" + m_osObjectKey );
CPLString osStringToSign;
osStringToSign += osVerb + "\n";
osStringToSign += "\n";
osStringToSign += "\n";
osStringToSign += osExpires + "\n";
// osStringToSign += ; // osCanonicalizedHeaders;
osStringToSign += osCanonicalizedResource;
#ifdef DEBUG_VERBOSE
CPLDebug("OSS", "osStringToSign = %s", osStringToSign.c_str());
#endif
CPLString osSignature(GetSignature(osStringToSign, m_osSecretAccessKey));
ResetQueryParameters();
// Note: https://www.alibabacloud.com/help/doc-detail/31952.htm?spm=a3c0i.o32002en.b99.294.6d70a0fc7cRJfJ is wrong on the name of the OSSAccessKeyId parameter !
AddQueryParameter("OSSAccessKeyId", m_osAccessKeyId);
AddQueryParameter("Expires", osExpires);
AddQueryParameter("Signature", osSignature);
return m_osURL;
}
OGRGeoJSONWriteLayer::OGRGeoJSONWriteLayer( const char* pszName,
OGRwkbGeometryType eGType,
char** papszOptions,
OGRGeoJSONDataSource* poDS )
: poDS_( poDS ), poFeatureDefn_(new OGRFeatureDefn( pszName ) ), nOutCounter_( 0 )
{
bWriteBBOX = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "WRITE_BBOX", "FALSE"));
bBBOX3D = FALSE;
poFeatureDefn_->Reference();
poFeatureDefn_->SetGeomType( eGType );
SetDescription( poFeatureDefn_->GetName() );
nCoordPrecision = atoi(CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"));
}
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);
}
CPLErr GNMGenericNetwork::CheckLayerDriver(const char* pszDefaultDriverName,
char **papszOptions)
{
if(NULL == m_poLayerDriver)
{
const char* pszDriverName = CSLFetchNameValueDef(papszOptions,
GNM_MD_FORMAT,
pszDefaultDriverName);
if(!CheckStorageDriverSupport(pszDriverName))
{
CPLError( CE_Failure, CPLE_IllegalArg, "%s driver not supported as network storage",
pszDriverName );
return CE_Failure;
}
m_poLayerDriver = GetGDALDriverManager()->GetDriverByName(pszDriverName );
if(NULL == m_poLayerDriver)
{
CPLError( CE_Failure, CPLE_IllegalArg, "%s driver not available",
pszDriverName );
return CE_Failure;
}
}
return CE_None;
}
static void GDALGeoLocRescale(char**& papszMD, const char* pszItem,
double dfRatio, double dfDefaultVal)
{
double dfVal = CPLAtofM(CSLFetchNameValueDef(papszMD, pszItem,
CPLSPrintf("%.18g", dfDefaultVal)));
dfVal *= dfRatio;
papszMD = CSLSetNameValue(papszMD, pszItem, CPLSPrintf("%.18g", dfVal));
}
void *CPLCreateZip( const char *pszZipFilename, char **papszOptions )
{
(void) papszOptions;
int bAppend = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "APPEND", "FALSE"));
return cpl_zipOpen( pszZipFilename, bAppend ? APPEND_STATUS_ADDINZIP : APPEND_STATUS_CREATE);
}
OGRGMELayer::OGRGMELayer(OGRGMEDataSource* poDS,
const char* pszTableName,
char ** papszOptions)
{
CPLDebug("GME", "Creating new layer %s", pszTableName);
this->poDS = poDS;
poSRS = new OGRSpatialReference(SRS_WKT_WGS84);
poFeatureDefn = NULL;
current_feature_page = NULL;
bDirty = false;
iBatchPatchSize = 50;
bCreateTablePending = true;
osTableName = pszTableName;
osProjectId = CSLFetchNameValue( papszOptions, "projectId" );
osDraftACL = CSLFetchNameValueDef( papszOptions, "draftAccessList", "Map Editors" );
osPublishedACL = CSLFetchNameValueDef( papszOptions, "publishedAccessList", "Map Viewers" );
// TODO: support tags and description
}
OGRLayer * OGRJMLDataset::ICreateLayer( const char * pszLayerName,
CPL_UNUSED OGRSpatialReference *poSRS,
CPL_UNUSED OGRwkbGeometryType eType,
char ** papszOptions )
{
if (!bWriteMode || poLayer != NULL)
return NULL;
int bAddRGBField = CSLTestBoolean(
CSLFetchNameValueDef(papszOptions, "CREATE_R_G_B_FIELD", "YES"));
int bAddOGRStyleField = CSLTestBoolean(
CSLFetchNameValueDef(papszOptions, "CREATE_OGR_STYLE_FIELD", "NO"));
int bClassicGML = CSLTestBoolean(
CSLFetchNameValueDef(papszOptions, "CLASSIC_GML", "NO"));
poLayer = new OGRJMLWriterLayer( pszLayerName, this, fp,
bAddRGBField, bAddOGRStyleField,
bClassicGML);
return poLayer;
}
int GDALGeorefPamDataset::GetPAMGeorefSrcIndex()
{
if( !m_bGotPAMGeorefSrcIndex )
{
m_bGotPAMGeorefSrcIndex = true;
const char* pszGeorefSources = CSLFetchNameValueDef( papszOpenOptions,
"GEOREF_SOURCES",
CPLGetConfigOption("GDAL_GEOREF_SOURCES", "PAM,OTHER") );
char** papszTokens = CSLTokenizeString2(pszGeorefSources, ",", 0);
m_nPAMGeorefSrcIndex = CSLFindString(papszTokens, "PAM");
CSLDestroy(papszTokens);
}
return m_nPAMGeorefSrcIndex;
}
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"));
}
bool CPLJSONDocument::LoadUrl(const std::string & /*osUrl*/, char ** /*papszOptions*/,
GDALProgressFunc /*pfnProgress*/,
void * /*pProgressArg*/)
#endif // HAVE_CURL
{
#ifdef HAVE_CURL
int nDepth = atoi( CSLFetchNameValueDef( papszOptions, "JSON_DEPTH", "10") );
JsonContext ctx = { nullptr, json_tokener_new_ex(nDepth), 0 };
CPLHTTPFetchWriteFunc pWriteFunc = CPLJSONWriteFunction;
CPLHTTPResult *psResult = CPLHTTPFetchEx( osUrl.c_str(), papszOptions,
pfnProgress, pProgressArg,
pWriteFunc, &ctx );
bool bResult = true;
if( psResult->nStatus != 0 /*CURLE_OK*/ )
{
bResult = false;
}
CPLHTTPDestroyResult( psResult );
enum json_tokener_error jerr;
if ((jerr = json_tokener_get_error(ctx.pTokener)) != json_tokener_success) {
CPLError(CE_Failure, CPLE_AppDefined, "JSON error: %s\n",
json_tokener_error_desc(jerr));
bResult = false;
}
else {
if( m_poRootJsonObject )
json_object_put( TO_JSONOBJ(m_poRootJsonObject) );
m_poRootJsonObject = ctx.pObject;
}
json_tokener_free(ctx.pTokener);
return bResult;
#else
return false;
#endif
}
// 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;
}
}
CPLVirtualMem *RawRasterBand::GetVirtualMemAuto( GDALRWFlag eRWFlag,
int *pnPixelSpace,
GIntBig *pnLineSpace,
char **papszOptions )
{
CPLAssert(pnPixelSpace);
CPLAssert(pnLineSpace);
vsi_l_offset nSize = (vsi_l_offset)(nRasterYSize - 1) * nLineOffset +
(nRasterXSize - 1) * nPixelOffset + GDALGetDataTypeSize(eDataType) / 8;
if( !bIsVSIL || VSIFGetNativeFileDescriptorL(fpRawL) == NULL ||
!CPLIsVirtualMemFileMapAvailable() || (eDataType != GDT_Byte && !bNativeOrder) ||
(size_t)nSize != nSize || nPixelOffset < 0 || nLineOffset < 0 ||
CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "USE_DEFAULT_IMPLEMENTATION", "NO")) )
{
return GDALRasterBand::GetVirtualMemAuto(eRWFlag, pnPixelSpace,
pnLineSpace, papszOptions);
}
FlushCache();
CPLVirtualMem* pVMem = CPLVirtualMemFileMapNew(
fpRawL, nImgOffset, nSize,
(eRWFlag == GF_Write) ? VIRTUALMEM_READWRITE : VIRTUALMEM_READONLY,
NULL, NULL);
if( pVMem == NULL )
{
return GDALRasterBand::GetVirtualMemAuto(eRWFlag, pnPixelSpace,
pnLineSpace, papszOptions);
}
else
{
*pnPixelSpace = nPixelOffset;
*pnLineSpace = nLineOffset;
return pVMem;
}
}
char *OGR_G_ExportToGMLEx( OGRGeometryH hGeometry, char** papszOptions )
{
char *pszText;
int nLength = 0, nMaxLength = 1;
if( hGeometry == NULL )
return CPLStrdup( "" );
pszText = (char *) CPLMalloc(nMaxLength);
pszText[0] = '\0';
const char* pszFormat = CSLFetchNameValue(papszOptions, "FORMAT");
if (pszFormat && EQUAL(pszFormat, "GML3"))
{
const char* pszLineStringElement = CSLFetchNameValue(papszOptions, "GML3_LINESTRING_ELEMENT");
int bLineStringAsCurve = (pszLineStringElement && EQUAL(pszLineStringElement, "curve"));
int bLongSRS = CSLTestBoolean(CSLFetchNameValueDef(papszOptions, "GML3_LONGSRS", "YES"));
const char* pszGMLId = CSLFetchNameValue(papszOptions, "GMLID");
if( !OGR2GML3GeometryAppend( (OGRGeometry *) hGeometry, NULL, &pszText,
&nLength, &nMaxLength, FALSE, bLongSRS, bLineStringAsCurve, pszGMLId ))
{
CPLFree( pszText );
return NULL;
}
else
return pszText;
}
if( !OGR2GMLGeometryAppend( (OGRGeometry *) hGeometry, &pszText,
&nLength, &nMaxLength, FALSE ))
{
CPLFree( pszText );
return NULL;
}
else
return pszText;
}
char* OGR_G_ExportToJsonEx( OGRGeometryH hGeometry, char** papszOptions )
{
VALIDATE_POINTER1( hGeometry, "OGR_G_ExportToJson", NULL );
OGRGeometry* poGeometry = (OGRGeometry*) (hGeometry);
int nCoordPrecision = atoi(CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"));
json_object* poObj = NULL;
poObj = OGRGeoJSONWriteGeometry( poGeometry, nCoordPrecision );
if( NULL != poObj )
{
char* pszJson = CPLStrdup( json_object_to_json_string( poObj ) );
/* Release JSON tree. */
json_object_put( poObj );
return pszJson;
}
/* Translation failed */
return NULL;
}
int OGRAmigoCloudDataSource::Open( const char * pszFilename,
char** papszOpenOptionsIn,
int bUpdateIn )
{
bReadWrite = CPL_TO_BOOL(bUpdateIn);
pszName = CPLStrdup( pszFilename );
if( CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID") )
pszProjetctId = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID"));
else
{
pszProjetctId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));
char* pchSpace = strchr(pszProjetctId, ' ');
if( pchSpace )
*pchSpace = '\0';
if( pszProjetctId[0] == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing projetc id");
return FALSE;
}
}
osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "API_KEY",
CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));
CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");
bUseHTTPS = CPLTestBool(CPLGetConfigOption("AMIGOCLOUD_HTTPS", "YES"));
OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");
if( poSchemaLayer )
{
OGRFeature* poFeat = poSchemaLayer->GetNextFeature();
if( poFeat )
{
if( poFeat->GetFieldCount() == 1 )
{
osCurrentSchema = poFeat->GetFieldAsString(0);
}
delete poFeat;
}
ReleaseResultSet(poSchemaLayer);
}
if( osCurrentSchema.size() == 0 )
return FALSE;
if (osDatasets.size() != 0)
{
char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);
for(int i=0;papszTables && papszTables[i];i++)
{
papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));
papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);
}
CSLDestroy(papszTables);
return TRUE;
}
return TRUE;
}
GDALDataset *
WEBPDataset::CreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
/* -------------------------------------------------------------------- */
/* WEBP library initialization */
/* -------------------------------------------------------------------- */
WebPPicture sPicture;
if (!WebPPictureInit(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureInit() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Some some rudimentary checks */
/* -------------------------------------------------------------------- */
if( nXSize > 16383 || nYSize > 16383 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP maximum image dimensions are 16383 x 16383.");
return NULL;
}
if( nBands != 3
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
&& nBands != 4
#endif
)
{
CPLError( CE_Failure, CPLE_NotSupported,
"WEBP driver doesn't support %d bands. Must be 3 (RGB) "
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
"or 4 (RGBA) "
#endif
"bands.",
nBands );
return NULL;
}
GDALDataType eDT = poSrcDS->GetRasterBand(1)->GetRasterDataType();
if( eDT != GDT_Byte )
{
CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported,
"WEBP driver doesn't support data type %s. "
"Only eight bit byte bands supported.",
GDALGetDataTypeName(
poSrcDS->GetRasterBand(1)->GetRasterDataType()) );
if (bStrict)
return NULL;
}
/* -------------------------------------------------------------------- */
/* What options has the user selected? */
/* -------------------------------------------------------------------- */
float fQuality = 75.0f;
const char* pszQUALITY = CSLFetchNameValue(papszOptions, "QUALITY");
if( pszQUALITY != NULL )
{
fQuality = (float) CPLAtof(pszQUALITY);
if( fQuality < 0.0f || fQuality > 100.0f )
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "QUALITY", pszQUALITY);
return NULL;
}
}
WebPPreset nPreset = WEBP_PRESET_DEFAULT;
const char* pszPRESET = CSLFetchNameValueDef(papszOptions, "PRESET", "DEFAULT");
if (EQUAL(pszPRESET, "DEFAULT"))
nPreset = WEBP_PRESET_DEFAULT;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "PHOTO"))
nPreset = WEBP_PRESET_PHOTO;
else if (EQUAL(pszPRESET, "PICTURE"))
nPreset = WEBP_PRESET_PICTURE;
else if (EQUAL(pszPRESET, "DRAWING"))
nPreset = WEBP_PRESET_DRAWING;
else if (EQUAL(pszPRESET, "ICON"))
nPreset = WEBP_PRESET_ICON;
else if (EQUAL(pszPRESET, "TEXT"))
nPreset = WEBP_PRESET_TEXT;
else
{
CPLError( CE_Failure, CPLE_IllegalArg,
"%s=%s is not a legal value.", "PRESET", pszPRESET );
return NULL;
}
WebPConfig sConfig;
if (!WebPConfigInitInternal(&sConfig, nPreset, fQuality, WEBP_ENCODER_ABI_VERSION))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPConfigInit() failed");
return NULL;
}
#define FETCH_AND_SET_OPTION_INT(name, fieldname, minval, maxval) \
{ \
const char* pszVal = CSLFetchNameValue(papszOptions, name); \
if (pszVal != NULL) \
{ \
sConfig.fieldname = atoi(pszVal); \
if (sConfig.fieldname < minval || sConfig.fieldname > maxval) \
{ \
CPLError( CE_Failure, CPLE_IllegalArg, \
"%s=%s is not a legal value.", name, pszVal ); \
return NULL; \
} \
} \
}
FETCH_AND_SET_OPTION_INT("TARGETSIZE", target_size, 0, INT_MAX);
const char* pszPSNR = CSLFetchNameValue(papszOptions, "PSNR");
if (pszPSNR)
{
sConfig.target_PSNR = CPLAtof(pszPSNR);
if (sConfig.target_PSNR < 0)
{
CPLError( CE_Failure, CPLE_IllegalArg,
"PSNR=%s is not a legal value.", pszPSNR );
return NULL;
}
}
FETCH_AND_SET_OPTION_INT("METHOD", method, 0, 6);
FETCH_AND_SET_OPTION_INT("SEGMENTS", segments, 1, 4);
FETCH_AND_SET_OPTION_INT("SNS_STRENGTH", sns_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_STRENGTH", filter_strength, 0, 100);
FETCH_AND_SET_OPTION_INT("FILTER_SHARPNESS", filter_sharpness, 0, 7);
FETCH_AND_SET_OPTION_INT("FILTER_TYPE", filter_type, 0, 1);
FETCH_AND_SET_OPTION_INT("AUTOFILTER", autofilter, 0, 1);
FETCH_AND_SET_OPTION_INT("PASS", pass, 1, 10);
FETCH_AND_SET_OPTION_INT("PREPROCESSING", preprocessing, 0, 1);
FETCH_AND_SET_OPTION_INT("PARTITIONS", partitions, 0, 3);
#if WEBP_ENCODER_ABI_VERSION >= 0x0002
FETCH_AND_SET_OPTION_INT("PARTITION_LIMIT", partition_limit, 0, 100);
#endif
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sConfig.lossless = CSLFetchBoolean(papszOptions, "LOSSLESS", FALSE);
if (sConfig.lossless)
sPicture.use_argb = 1;
#endif
if (!WebPValidateConfig(&sConfig))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPValidateConfig() failed");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Allocate memory */
/* -------------------------------------------------------------------- */
GByte *pabyBuffer;
pabyBuffer = (GByte *) VSIMalloc( nBands * nXSize * nYSize );
if (pabyBuffer == NULL)
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create the dataset. */
/* -------------------------------------------------------------------- */
VSILFILE *fpImage;
fpImage = VSIFOpenL( pszFilename, "wb" );
if( fpImage == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Unable to create WEBP file %s.\n",
pszFilename );
VSIFree(pabyBuffer);
return NULL;
}
WebPUserData sUserData;
sUserData.fp = fpImage;
sUserData.pfnProgress = pfnProgress ? pfnProgress : GDALDummyProgress;
sUserData.pProgressData = pProgressData;
/* -------------------------------------------------------------------- */
/* WEBP library settings */
/* -------------------------------------------------------------------- */
sPicture.width = nXSize;
sPicture.height = nYSize;
sPicture.writer = WEBPDatasetWriter;
sPicture.custom_ptr = &sUserData;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
sPicture.progress_hook = WEBPDatasetProgressHook;
#endif
if (!WebPPictureAlloc(&sPicture))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureAlloc() failed");
VSIFree(pabyBuffer);
VSIFCloseL( fpImage );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Acquire source imagery. */
/* -------------------------------------------------------------------- */
CPLErr eErr = CE_None;
eErr = poSrcDS->RasterIO( GF_Read, 0, 0, nXSize, nYSize,
pabyBuffer, nXSize, nYSize, GDT_Byte,
nBands, NULL,
nBands, nBands * nXSize, 1, NULL );
/* -------------------------------------------------------------------- */
/* Import and write to file */
/* -------------------------------------------------------------------- */
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
if (eErr == CE_None && nBands == 4)
{
if (!WebPPictureImportRGBA(&sPicture, pabyBuffer, nBands * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGBA() failed");
eErr = CE_Failure;
}
}
else
#endif
if (eErr == CE_None &&
!WebPPictureImportRGB(&sPicture, pabyBuffer, nBands * nXSize))
{
CPLError(CE_Failure, CPLE_AppDefined, "WebPPictureImportRGB() failed");
eErr = CE_Failure;
}
if (eErr == CE_None && !WebPEncode(&sConfig, &sPicture))
{
const char* pszErrorMsg = NULL;
#if WEBP_ENCODER_ABI_VERSION >= 0x0100
switch(sPicture.error_code)
{
case VP8_ENC_ERROR_OUT_OF_MEMORY: pszErrorMsg = "Out of memory"; break;
case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY: pszErrorMsg = "Out of memory while flushing bits"; break;
case VP8_ENC_ERROR_NULL_PARAMETER: pszErrorMsg = "A pointer parameter is NULL"; break;
case VP8_ENC_ERROR_INVALID_CONFIGURATION: pszErrorMsg = "Configuration is invalid"; break;
case VP8_ENC_ERROR_BAD_DIMENSION: pszErrorMsg = "Picture has invalid width/height"; break;
case VP8_ENC_ERROR_PARTITION0_OVERFLOW: pszErrorMsg = "Partition is bigger than 512k. Try using less SEGMENTS, or increase PARTITION_LIMIT value"; break;
case VP8_ENC_ERROR_PARTITION_OVERFLOW: pszErrorMsg = "Partition is bigger than 16M"; break;
case VP8_ENC_ERROR_BAD_WRITE: pszErrorMsg = "Error while flusing bytes"; break;
case VP8_ENC_ERROR_FILE_TOO_BIG: pszErrorMsg = "File is bigger than 4G"; break;
case VP8_ENC_ERROR_USER_ABORT: pszErrorMsg = "User interrupted"; break;
default: break;
}
#endif
if (pszErrorMsg)
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed : %s", pszErrorMsg);
else
CPLError(CE_Failure, CPLE_AppDefined, "WebPEncode() failed");
eErr = CE_Failure;
}
/* -------------------------------------------------------------------- */
/* Cleanup and close. */
/* -------------------------------------------------------------------- */
CPLFree( pabyBuffer );
WebPPictureFree(&sPicture);
VSIFCloseL( fpImage );
if( eErr != CE_None )
{
VSIUnlink( pszFilename );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Re-open dataset, and copy any auxiliary pam information. */
/* -------------------------------------------------------------------- */
GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly);
/* If outputing to stdout, we can't reopen it, so we'll return */
/* a fake dataset to make the caller happy */
CPLPushErrorHandler(CPLQuietErrorHandler);
WEBPDataset *poDS = (WEBPDataset*) WEBPDataset::Open( &oOpenInfo );
CPLPopErrorHandler();
if( poDS )
{
poDS->CloneInfo( poSrcDS, GCIF_PAM_DEFAULT );
return poDS;
}
return NULL;
}
int OGRCSVDataSource::OpenTable( const char * pszFilename,
char** papszOpenOptions,
const char* pszNfdcRunwaysGeomField,
const char* pszGeonamesGeomFieldPrefix)
{
/* -------------------------------------------------------------------- */
/* Open the file. */
/* -------------------------------------------------------------------- */
VSILFILE * fp;
if( bUpdate )
fp = VSIFOpenL( pszFilename, "rb+" );
else
fp = VSIFOpenL( pszFilename, "rb" );
if( fp == NULL )
{
CPLError( CE_Warning, CPLE_OpenFailed,
"Failed to open %s, %s.",
pszFilename, VSIStrerror( errno ) );
return FALSE;
}
if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL &&
strstr(pszFilename, "/vsizip/") == NULL )
fp = (VSILFILE*) VSICreateBufferedReaderHandle((VSIVirtualHandle*)fp);
CPLString osLayerName = CPLGetBasename(pszFilename);
CPLString osExt = CPLGetExtension(pszFilename);
if( strncmp(pszFilename, "/vsigzip/", 9) == 0 && EQUAL(osExt, "gz") )
{
if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".csv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "csv";
}
else if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".tsv.gz") )
{
osLayerName = osLayerName.substr(0, osLayerName.size() - 4);
osExt = "tsv";
}
}
/* -------------------------------------------------------------------- */
/* Read and parse a line. Did we get multiple fields? */
/* -------------------------------------------------------------------- */
const char* pszLine = CPLReadLineL( fp );
if (pszLine == NULL)
{
VSIFCloseL( fp );
return FALSE;
}
char chDelimiter = CSVDetectSeperator(pszLine);
if( chDelimiter != '\t' && strchr(pszLine, '\t') != NULL )
{
/* Force the delimiter to be TAB for a .tsv file that has a tabulation */
/* in its first line */
if( EQUAL(osExt, "tsv") )
{
chDelimiter = '\t';
}
else
{
for(int bDontHonourStrings=0; bDontHonourStrings<=1; bDontHonourStrings++)
{
// Read the first 2 lines to see if they have the same number of fields, if using tabulation
VSIRewindL( fp );
char** papszTokens = OGRCSVReadParseLineL( fp, '\t', bDontHonourStrings );
int nTokens1 = CSLCount(papszTokens);
CSLDestroy(papszTokens);
papszTokens = OGRCSVReadParseLineL( fp, '\t', bDontHonourStrings );
int nTokens2 = CSLCount(papszTokens);
CSLDestroy(papszTokens);
if( nTokens1 >= 2 && nTokens1 == nTokens2 )
{
chDelimiter = '\t';
break;
}
}
}
}
VSIRewindL( fp );
#if 0
const char *pszDelimiter = CSLFetchNameValueDef( papszOpenOptions, "SEPARATOR", "AUTO");
if( !EQUAL(pszDelimiter, "AUTO") )
{
if (EQUAL(pszDelimiter, "COMMA"))
chDelimiter = ',';
else if (EQUAL(pszDelimiter, "SEMICOLON"))
chDelimiter = ';';
else if (EQUAL(pszDelimiter, "TAB"))
chDelimiter = '\t';
else if (EQUAL(pszDelimiter, "SPACE"))
chDelimiter = ' ';
else
{
CPLError( CE_Warning, CPLE_AppDefined,
"SEPARATOR=%s not understood, use one of COMMA, SEMICOLON, SPACE or TAB.",
pszDelimiter );
}
}
#endif
/* GNIS specific */
if (pszGeonamesGeomFieldPrefix != NULL &&
strchr(pszLine, '|') != NULL)
chDelimiter = '|';
char **papszFields = OGRCSVReadParseLineL( fp, chDelimiter, FALSE );
if( CSLCount(papszFields) < 2 )
{
VSIFCloseL( fp );
CSLDestroy( papszFields );
return FALSE;
}
VSIRewindL( fp );
CSLDestroy( papszFields );
/* -------------------------------------------------------------------- */
/* Create a layer. */
/* -------------------------------------------------------------------- */
nLayers++;
papoLayers = (OGRCSVLayer **) CPLRealloc(papoLayers,
sizeof(void*) * nLayers);
if (pszNfdcRunwaysGeomField != NULL)
{
osLayerName += "_";
osLayerName += pszNfdcRunwaysGeomField;
}
else if (pszGeonamesGeomFieldPrefix != NULL &&
!EQUAL(pszGeonamesGeomFieldPrefix, ""))
{
osLayerName += "_";
osLayerName += pszGeonamesGeomFieldPrefix;
}
if (EQUAL(pszFilename, "/vsistdin/"))
osLayerName = "layer";
papoLayers[nLayers-1] =
new OGRCSVLayer( osLayerName, fp, pszFilename, FALSE, bUpdate,
chDelimiter );
papoLayers[nLayers-1]->BuildFeatureDefn( pszNfdcRunwaysGeomField,
pszGeonamesGeomFieldPrefix,
papszOpenOptions );
return TRUE;
}
GDALDataset *KEADataset::CreateCopy( const char * pszFilename, GDALDataset *pSrcDs,
CPL_UNUSED int bStrict, char ** papszParmList,
GDALProgressFunc pfnProgress, void *pProgressData )
{
// get the data out of the input dataset
int nXSize = pSrcDs->GetRasterXSize();
int nYSize = pSrcDs->GetRasterYSize();
int nBands = pSrcDs->GetRasterCount();
GDALDataType eType = (nBands == 0) ? GDT_Unknown : pSrcDs->GetRasterBand(1)->GetRasterDataType();
H5::H5File *keaImgH5File = CreateLL( pszFilename, nXSize, nYSize, nBands,
eType, papszParmList );
if( keaImgH5File == NULL )
return NULL;
bool bThematic = CSLTestBoolean(CSLFetchNameValueDef( papszParmList, "THEMATIC", "FALSE" ));
try
{
// create the imageio
kealib::KEAImageIO *pImageIO = new kealib::KEAImageIO();
// open the file
pImageIO->openKEAImageHeader( keaImgH5File );
// copy file
if( !KEACopyFile( pSrcDs, pImageIO, pfnProgress, pProgressData) )
{
delete pImageIO;
return NULL;
}
// close it
try
{
pImageIO->close();
}
catch (kealib::KEAIOException &e)
{
}
delete pImageIO;
// now open it again - because the constructor loads all the info
// in we need to copy the data first....
keaImgH5File = kealib::KEAImageIO::openKeaH5RW( pszFilename );
// and wrap it in a dataset
KEADataset *pDataset = new KEADataset( keaImgH5File, GA_Update );
pDataset->SetDescription( pszFilename );
// set all to thematic if asked - overrides whatever set by CopyFile
if( bThematic )
{
for( int nCount = 0; nCount < nBands; nCount++ )
{
GDALRasterBand *pBand = pDataset->GetRasterBand(nCount+1);
pBand->SetMetadataItem("LAYER_TYPE", "thematic");
}
}
for( int nCount = 0; nCount < nBands; nCount++ )
{
pDataset->GetRasterBand(nCount+1)->SetColorInterpretation(
pSrcDs->GetRasterBand(nCount+1)->GetColorInterpretation());
}
// KEA has no concept of per-dataset mask band for now.
for( int nCount = 0; nCount < nBands; nCount++ )
{
if( pSrcDs->GetRasterBand(nCount+1)->GetMaskFlags() == 0 ) // Per-band mask
{
pDataset->GetRasterBand(nCount+1)->CreateMaskBand(0);
GDALRasterBandCopyWholeRaster(
(GDALRasterBandH)pSrcDs->GetRasterBand(nCount+1)->GetMaskBand(),
(GDALRasterBandH)pDataset->GetRasterBand(nCount+1)->GetMaskBand(),
NULL, NULL, NULL);
}
}
return pDataset;
}
catch (kealib::KEAException &e)
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Attempt to create file `%s' failed. Error: %s\n",
pszFilename, e.what() );
return NULL;
}
}
static GDALDataset *
EpsilonDatasetCreateCopy( const char * pszFilename, GDALDataset *poSrcDS,
CPL_UNUSED int bStrict, char ** papszOptions,
GDALProgressFunc pfnProgress, void * pProgressData )
{
int nBands = poSrcDS->GetRasterCount();
if ((nBands != 1 && nBands != 3) ||
(nBands > 0 && poSrcDS->GetRasterBand(1)->GetColorTable() != NULL))
{
CPLError(CE_Failure, CPLE_NotSupported,
"The EPSILON driver only supports 1 band (grayscale) "
"or 3 band (RGB) data");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Fetch and check creation options */
/* -------------------------------------------------------------------- */
int nBlockXSize =
atoi(CSLFetchNameValueDef(papszOptions, "BLOCKXSIZE", "256"));
int nBlockYSize =
atoi(CSLFetchNameValueDef(papszOptions, "BLOCKYSIZE", "256"));
if ((nBlockXSize != 32 && nBlockXSize != 64 && nBlockXSize != 128 &&
nBlockXSize != 256 && nBlockXSize != 512 && nBlockXSize != 1024) ||
(nBlockYSize != 32 && nBlockYSize != 64 && nBlockYSize != 128 &&
nBlockYSize != 256 && nBlockYSize != 512 && nBlockYSize != 1024))
{
CPLError(CE_Failure, CPLE_NotSupported,
"Block size must be a power of 2 between 32 et 1024");
return NULL;
}
const char* pszFilter =
CSLFetchNameValueDef(papszOptions, "FILTER", "daub97lift");
char** papszFBID = eps_get_fb_info(EPS_FB_ID);
char** papszFBIDIter = papszFBID;
int bFound = FALSE;
int nIndexFB = 0;
while(papszFBIDIter && *papszFBIDIter && !bFound)
{
if (strcmp(*papszFBIDIter, pszFilter) == 0)
bFound = TRUE;
else
nIndexFB ++;
papszFBIDIter ++;
}
eps_free_fb_info(papszFBID);
if (!bFound)
{
CPLError(CE_Failure, CPLE_NotSupported, "FILTER='%s' not supported",
pszFilter);
return NULL;
}
int eMode = EPS_MODE_OTLPF;
const char* pszMode = CSLFetchNameValueDef(papszOptions, "MODE", "OTLPF");
if (EQUAL(pszMode, "NORMAL"))
eMode = EPS_MODE_NORMAL;
else if (EQUAL(pszMode, "OTLPF"))
eMode = EPS_MODE_OTLPF;
else
{
CPLError(CE_Failure, CPLE_NotSupported, "MODE='%s' not supported",
pszMode);
return NULL;
}
char** papszFBType = eps_get_fb_info(EPS_FB_TYPE);
int bIsBiOrthogonal = EQUAL(papszFBType[nIndexFB], "biorthogonal");
eps_free_fb_info(papszFBType);
if (eMode == EPS_MODE_OTLPF && !bIsBiOrthogonal)
{
CPLError(CE_Failure, CPLE_NotSupported,
"MODE=OTLPF can only be used with biorthogonal filters. "
"Use MODE=NORMAL instead");
return NULL;
}
int bRasterliteOutput =
CPLTestBool(CSLFetchNameValueDef(papszOptions,
"RASTERLITE_OUTPUT", "NO"));
int nYRatio = EPS_Y_RT;
int nCbRatio = EPS_Cb_RT;
int nCrRatio = EPS_Cr_RT;
int eResample;
if (CPLTestBool(CSLFetchNameValueDef(papszOptions,
"RGB_RESAMPLE", "YES")))
eResample = EPS_RESAMPLE_420;
else
eResample = EPS_RESAMPLE_444;
const char* pszTarget = CSLFetchNameValueDef(papszOptions, "TARGET", "96");
double dfReductionFactor = 1 - CPLAtof(pszTarget) / 100;
if (dfReductionFactor > 1)
dfReductionFactor = 1;
else if (dfReductionFactor < 0)
dfReductionFactor = 0;
/* -------------------------------------------------------------------- */
/* Open file */
/* -------------------------------------------------------------------- */
VSILFILE* fp = VSIFOpenL(pszFilename, "wb");
if (fp == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot create %s", pszFilename);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Compute number of blocks, block size, etc... */
/* -------------------------------------------------------------------- */
int nXSize = poSrcDS->GetRasterXSize();
int nYSize = poSrcDS->GetRasterYSize();
if (eMode == EPS_MODE_OTLPF)
{
nBlockXSize ++;
nBlockYSize ++;
}
int nXBlocks = (nXSize + nBlockXSize - 1) / nBlockXSize;
int nYBlocks = (nYSize + nBlockYSize - 1) / nBlockYSize;
int nBlocks = nXBlocks * nYBlocks;
int nUncompressedFileSize = nXSize * nYSize * nBands;
int nUncompressedBlockSize = nUncompressedFileSize / nBlocks;
int nTargetBlockSize = (int) (dfReductionFactor * nUncompressedBlockSize);
if (nBands == 1)
nTargetBlockSize = MAX (nTargetBlockSize, EPS_MIN_GRAYSCALE_BUF + 1);
else
nTargetBlockSize = MAX (nTargetBlockSize, EPS_MIN_TRUECOLOR_BUF + 1);
/* -------------------------------------------------------------------- */
/* Allocate work buffers */
/* -------------------------------------------------------------------- */
GByte* pabyBuffer = (GByte*)VSIMalloc3(nBlockXSize, nBlockYSize, nBands);
if (pabyBuffer == NULL)
{
VSIFCloseL(fp);
return NULL;
}
GByte* pabyOutBuf = (GByte*)VSIMalloc(nTargetBlockSize);
if (pabyOutBuf == NULL)
{
VSIFree(pabyBuffer);
VSIFCloseL(fp);
return NULL;
}
GByte** apapbyRawBuffer[3];
int i, j;
for(i=0;i<nBands;i++)
{
apapbyRawBuffer[i] = (GByte**) VSIMalloc(sizeof(GByte*) * nBlockYSize);
for(j=0;j<nBlockYSize;j++)
{
apapbyRawBuffer[i][j] =
pabyBuffer + (i * nBlockXSize + j) * nBlockYSize;
}
}
if (bRasterliteOutput)
{
const char* pszHeader = RASTERLITE_WAVELET_HEADER;
VSIFWriteL(pszHeader, 1, strlen(pszHeader) + 1, fp);
}
/* -------------------------------------------------------------------- */
/* Iterate over blocks */
/* -------------------------------------------------------------------- */
int nBlockXOff, nBlockYOff;
CPLErr eErr = CE_None;
for(nBlockYOff = 0;
eErr == CE_None && nBlockYOff < nYBlocks; nBlockYOff ++)
{
for(nBlockXOff = 0;
eErr == CE_None && nBlockXOff < nXBlocks; nBlockXOff ++)
{
int bMustMemset = FALSE;
int nReqXSize = nBlockXSize, nReqYSize = nBlockYSize;
if ((nBlockXOff+1) * nBlockXSize > nXSize)
{
bMustMemset = TRUE;
nReqXSize = nXSize - nBlockXOff * nBlockXSize;
}
if ((nBlockYOff+1) * nBlockYSize > nYSize)
{
bMustMemset = TRUE;
nReqYSize = nYSize - nBlockYOff * nBlockYSize;
}
if (bMustMemset)
memset(pabyBuffer, 0, nBands * nBlockXSize * nBlockYSize);
eErr = poSrcDS->RasterIO(GF_Read,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
nReqXSize, nReqYSize,
pabyBuffer,
nReqXSize, nReqYSize,
GDT_Byte, nBands, NULL,
1,
nBlockXSize,
nBlockXSize * nBlockYSize, NULL);
int nOutBufSize = nTargetBlockSize;
if (eErr == CE_None && nBands == 1)
{
if (EPS_OK != eps_encode_grayscale_block(apapbyRawBuffer[0],
nXSize, nYSize,
nReqXSize, nReqYSize,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
pabyOutBuf, &nOutBufSize,
(char*) pszFilter, eMode))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Error occurred when encoding block (%d, %d)",
nBlockXOff, nBlockYOff);
eErr = CE_Failure;
}
}
else if (eErr == CE_None)
{
if (EPS_OK != eps_encode_truecolor_block(
apapbyRawBuffer[0],
apapbyRawBuffer[1],
apapbyRawBuffer[2],
nXSize, nYSize,
nReqXSize, nReqYSize,
nBlockXOff * nBlockXSize,
nBlockYOff * nBlockYSize,
eResample,
pabyOutBuf, &nOutBufSize,
nYRatio, nCbRatio, nCrRatio,
(char*) pszFilter, eMode))
{
CPLError(CE_Failure, CPLE_AppDefined,
"Error occurred when encoding block (%d, %d)",
nBlockXOff, nBlockYOff);
eErr = CE_Failure;
}
}
if (eErr == CE_None)
{
if ((int)VSIFWriteL(pabyOutBuf, 1, nOutBufSize, fp) !=
nOutBufSize)
eErr = CE_Failure;
char chEPSMarker = EPS_MARKER;
VSIFWriteL(&chEPSMarker, 1, 1, fp);
if (pfnProgress && !pfnProgress(
1.0 * (nBlockYOff * nXBlocks + nBlockXOff + 1) / nBlocks,
NULL, pProgressData))
{
eErr = CE_Failure;
}
}
}
}
if (bRasterliteOutput)
{
const char* pszFooter = RASTERLITE_WAVELET_FOOTER;
VSIFWriteL(pszFooter, 1, strlen(pszFooter) + 1, fp);
}
/* -------------------------------------------------------------------- */
/* Cleanup work buffers */
/* -------------------------------------------------------------------- */
for(i=0;i<nBands;i++)
{
VSIFree(apapbyRawBuffer[i]);
}
VSIFree(pabyOutBuf);
VSIFree(pabyBuffer);
VSIFCloseL(fp);
if (eErr != CE_None)
return NULL;
/* -------------------------------------------------------------------- */
/* Reopen the dataset, unless asked for not (Rasterlite optim) */
/* -------------------------------------------------------------------- */
return (GDALDataset*) GDALOpen(pszFilename, GA_ReadOnly);
}
OGRLayer *
OGRShapeDataSource::ICreateLayer( const char * pszLayerName,
OGRSpatialReference *poSRS,
OGRwkbGeometryType eType,
char ** papszOptions )
{
SHPHandle hSHP;
DBFHandle hDBF;
int nShapeType;
/* To ensure that existing layers are created */
GetLayerCount();
/* -------------------------------------------------------------------- */
/* Check that the layer doesn't already exist. */
/* -------------------------------------------------------------------- */
if (GetLayerByName(pszLayerName) != NULL)
{
CPLError( CE_Failure, CPLE_AppDefined, "Layer '%s' already exists",
pszLayerName);
return NULL;
}
/* -------------------------------------------------------------------- */
/* Verify we are in update mode. */
/* -------------------------------------------------------------------- */
if( !bDSUpdate )
{
CPLError( CE_Failure, CPLE_NoWriteAccess,
"Data source %s opened read-only.\n"
"New layer %s cannot be created.\n",
pszName, pszLayerName );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Figure out what type of layer we need. */
/* -------------------------------------------------------------------- */
if( eType == wkbUnknown || eType == wkbLineString )
nShapeType = SHPT_ARC;
else if( eType == wkbPoint )
nShapeType = SHPT_POINT;
else if( eType == wkbPolygon )
nShapeType = SHPT_POLYGON;
else if( eType == wkbMultiPoint )
nShapeType = SHPT_MULTIPOINT;
else if( eType == wkbPoint25D )
nShapeType = SHPT_POINTZ;
else if( eType == wkbLineString25D )
nShapeType = SHPT_ARCZ;
else if( eType == wkbMultiLineString )
nShapeType = SHPT_ARC;
else if( eType == wkbMultiLineString25D )
nShapeType = SHPT_ARCZ;
else if( eType == wkbPolygon25D )
nShapeType = SHPT_POLYGONZ;
else if( eType == wkbMultiPolygon )
nShapeType = SHPT_POLYGON;
else if( eType == wkbMultiPolygon25D )
nShapeType = SHPT_POLYGONZ;
else if( eType == wkbMultiPoint25D )
nShapeType = SHPT_MULTIPOINTZ;
else if( eType == wkbNone )
nShapeType = SHPT_NULL;
else
nShapeType = -1;
/* -------------------------------------------------------------------- */
/* Has the application overridden this with a special creation */
/* option? */
/* -------------------------------------------------------------------- */
const char *pszOverride = CSLFetchNameValue( papszOptions, "SHPT" );
if( pszOverride == NULL )
/* ignore */;
else if( EQUAL(pszOverride,"POINT") )
{
nShapeType = SHPT_POINT;
eType = wkbPoint;
}
else if( EQUAL(pszOverride,"ARC") )
{
nShapeType = SHPT_ARC;
eType = wkbLineString;
}
else if( EQUAL(pszOverride,"POLYGON") )
{
nShapeType = SHPT_POLYGON;
eType = wkbPolygon;
}
else if( EQUAL(pszOverride,"MULTIPOINT") )
{
nShapeType = SHPT_MULTIPOINT;
eType = wkbMultiPoint;
}
else if( EQUAL(pszOverride,"POINTZ") )
{
nShapeType = SHPT_POINTZ;
eType = wkbPoint25D;
}
else if( EQUAL(pszOverride,"ARCZ") )
{
nShapeType = SHPT_ARCZ;
eType = wkbLineString25D;
}
else if( EQUAL(pszOverride,"POLYGONZ") )
{
nShapeType = SHPT_POLYGONZ;
eType = wkbPolygon25D;
}
else if( EQUAL(pszOverride,"MULTIPOINTZ") )
{
nShapeType = SHPT_MULTIPOINTZ;
eType = wkbMultiPoint25D;
}
else if( EQUAL(pszOverride,"NONE") || EQUAL(pszOverride,"NULL") )
{
nShapeType = SHPT_NULL;
eType = wkbNone;
}
else
{
CPLError( CE_Failure, CPLE_NotSupported,
"Unknown SHPT value of `%s' passed to Shapefile layer\n"
"creation. Creation aborted.\n",
pszOverride );
return NULL;
}
if( nShapeType == -1 )
{
CPLError( CE_Failure, CPLE_NotSupported,
"Geometry type of `%s' not supported in shapefiles.\n"
"Type can be overridden with a layer creation option\n"
"of SHPT=POINT/ARC/POLYGON/MULTIPOINT/POINTZ/ARCZ/POLYGONZ/MULTIPOINTZ.\n",
OGRGeometryTypeToName(eType) );
return NULL;
}
/* -------------------------------------------------------------------- */
/* What filename do we use, excluding the extension? */
/* -------------------------------------------------------------------- */
char *pszFilenameWithoutExt;
if( bSingleFileDataSource && nLayers == 0 )
{
char *pszPath = CPLStrdup(CPLGetPath(pszName));
char *pszFBasename = CPLStrdup(CPLGetBasename(pszName));
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszPath, pszFBasename, NULL));
CPLFree( pszFBasename );
CPLFree( pszPath );
}
else if( bSingleFileDataSource )
{
/* This is a very weird use case : the user creates/open a datasource */
/* made of a single shapefile 'foo.shp' and wants to add a new layer */
/* to it, 'bar'. So we create a new shapefile 'bar.shp' in the same */
/* directory as 'foo.shp' */
/* So technically, we will not be any longer a single file */
/* datasource ... Ahem ahem */
char *pszPath = CPLStrdup(CPLGetPath(pszName));
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszPath,pszLayerName,NULL));
CPLFree( pszPath );
}
else
pszFilenameWithoutExt = CPLStrdup(CPLFormFilename(pszName,pszLayerName,NULL));
/* -------------------------------------------------------------------- */
/* Create the shapefile. */
/* -------------------------------------------------------------------- */
char *pszFilename;
int b2GBLimit = CSLTestBoolean(CSLFetchNameValueDef( papszOptions, "2GB_LIMIT", "FALSE" ));
if( nShapeType != SHPT_NULL )
{
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "shp" ));
hSHP = SHPCreateLL( pszFilename, nShapeType, (SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
if( hSHP == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open Shapefile `%s'.\n",
pszFilename );
CPLFree( pszFilename );
CPLFree( pszFilenameWithoutExt );
return NULL;
}
SHPSetFastModeReadObject( hSHP, TRUE );
CPLFree( pszFilename );
}
else
hSHP = NULL;
/* -------------------------------------------------------------------- */
/* Has a specific LDID been specified by the caller? */
/* -------------------------------------------------------------------- */
const char *pszLDID = CSLFetchNameValue( papszOptions, "ENCODING" );
/* -------------------------------------------------------------------- */
/* Create a DBF file. */
/* -------------------------------------------------------------------- */
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "dbf" ));
if( pszLDID != NULL )
hDBF = DBFCreateLL( pszFilename, pszLDID, (SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
else
hDBF = DBFCreateLL( pszFilename, "LDID/87",(SAHooks*) VSI_SHP_GetHook(b2GBLimit) );
if( hDBF == NULL )
{
CPLError( CE_Failure, CPLE_OpenFailed,
"Failed to open Shape DBF file `%s'.\n",
pszFilename );
CPLFree( pszFilename );
CPLFree( pszFilenameWithoutExt );
SHPClose(hSHP);
return NULL;
}
CPLFree( pszFilename );
/* -------------------------------------------------------------------- */
/* Create the .prj file, if required. */
/* -------------------------------------------------------------------- */
if( poSRS != NULL )
{
char *pszWKT = NULL;
CPLString osPrjFile = CPLFormFilename( NULL, pszFilenameWithoutExt, "prj");
VSILFILE *fp;
/* the shape layer needs it's own copy */
poSRS = poSRS->Clone();
poSRS->morphToESRI();
if( poSRS->exportToWkt( &pszWKT ) == OGRERR_NONE
&& (fp = VSIFOpenL( osPrjFile, "wt" )) != NULL )
{
VSIFWriteL( pszWKT, strlen(pszWKT), 1, fp );
VSIFCloseL( fp );
}
CPLFree( pszWKT );
poSRS->morphFromESRI();
}
/* -------------------------------------------------------------------- */
/* Create the layer object. */
/* -------------------------------------------------------------------- */
OGRShapeLayer *poLayer;
/* OGRShapeLayer constructor expects a filename with an extension (that could be */
/* random actually), otherwise this is going to cause problems with layer */
/* names that have a dot (not speaking about the one before the shp) */
pszFilename = CPLStrdup(CPLFormFilename( NULL, pszFilenameWithoutExt, "shp" ));
poLayer = new OGRShapeLayer( this, pszFilename, hSHP, hDBF, poSRS, TRUE, TRUE,
eType );
CPLFree( pszFilenameWithoutExt );
CPLFree( pszFilename );
poLayer->SetResizeAtClose( CSLFetchBoolean( papszOptions, "RESIZE", FALSE ) );
poLayer->CreateSpatialIndexAtClose( CSLFetchBoolean( papszOptions, "SPATIAL_INDEX", FALSE ) );
poLayer->SetModificationDate(
CSLFetchNameValue( papszOptions, "DBF_DATE_LAST_UPDATE" ) );
/* -------------------------------------------------------------------- */
/* Add layer to data source layer list. */
/* -------------------------------------------------------------------- */
AddLayer(poLayer);
return poLayer;
}
int OGRAmigoCloudDataSource::Open( const char * pszFilename,
char** papszOpenOptionsIn,
int bUpdateIn )
{
bReadWrite = CPL_TO_BOOL(bUpdateIn);
pszName = CPLStrdup( pszFilename );
pszProjectId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:"));
char* pchSpace = strchr(pszProjectId, ' ');
if( pchSpace )
*pchSpace = '\0';
if( pszProjectId[0] == 0 )
{
CPLError(CE_Failure, CPLE_AppDefined, "Missing project id");
return FALSE;
}
osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "AMIGOCLOUD_API_KEY",
CPLGetConfigOption("AMIGOCLOUD_API_KEY", ""));
if (osAPIKey.empty())
{
osAPIKey = OGRAMIGOCLOUDGetOptionValue(pszFilename, "AMIGOCLOUD_API_KEY");
}
if (osAPIKey.empty())
{
CPLError(CE_Failure, CPLE_AppDefined, "AMIGOCLOUD_API_KEY is not defined.\n");
return FALSE;
}
OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()");
if( poSchemaLayer )
{
OGRFeature* poFeat = poSchemaLayer->GetNextFeature();
if( poFeat )
{
if( poFeat->GetFieldCount() == 1 )
{
osCurrentSchema = poFeat->GetFieldAsString(0);
}
delete poFeat;
}
ReleaseResultSet(poSchemaLayer);
}
if( osCurrentSchema.empty() )
return FALSE;
CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets");
if (!osDatasets.empty())
{
char** papszTables = CSLTokenizeString2(osDatasets, ",", 0);
for(int i=0;papszTables && papszTables[i];i++)
{
papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc(
papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*));
papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]);
}
CSLDestroy(papszTables);
// If OVERWRITE: YES, truncate the layer.
if( nLayers==1 &&
CPLFetchBool(papszOpenOptionsIn, "OVERWRITE", false) )
{
TruncateDataset(papoLayers[0]->GetTableName());
}
return TRUE;
} else {
// If 'datasets' word is in the filename, but no dataset id specified,
// print the list of available datasets
if(std::string(pszFilename).find("datasets") != std::string::npos)
ListDatasets();
}
return TRUE;
}
OGRLayer *GNMGenericNetwork::GetPath(GNMGFID nStartFID, GNMGFID nEndFID,
GNMGraphAlgorithmType eAlgorithm, char **papszOptions)
{
if(!m_bIsGraphLoaded && LoadGraph() != CE_None)
{
return NULL;
}
GDALDriver* poMEMDrv =
OGRSFDriverRegistrar::GetRegistrar()->GetDriverByName("Memory");
if (poMEMDrv == NULL)
{
CPLError(CE_Failure, CPLE_AppDefined, "Cannot load 'Memory' driver");
return NULL;
}
GDALDataset* poMEMDS =
poMEMDrv->Create("dummy_name", 0, 0, 0, GDT_Unknown, NULL);
OGRSpatialReference oDstSpaRef(GetProjectionRef());
OGRLayer* poMEMLayer = poMEMDS->CreateLayer(GetAlgorithmName(eAlgorithm,
true), &oDstSpaRef, wkbGeometryCollection, NULL);
OGRGNMWrappedResultLayer* poResLayer =
new OGRGNMWrappedResultLayer(poMEMDS, poMEMLayer);
const bool bReturnEdges = CPLFetchBool(papszOptions, GNM_MD_FETCHEDGES, true);
const bool bReturnVertices = CPLFetchBool(papszOptions, GNM_MD_FETCHVERTEX, true);
switch (eAlgorithm)
{
case GATDijkstraShortestPath:
{
GNMPATH path = m_oGraph.DijkstraShortestPath(nStartFID, nEndFID);
// fill features in result layer
FillResultLayer(poResLayer, path, 1, bReturnVertices, bReturnEdges);
}
break;
case GATKShortestPath:
{
int nK = atoi(CSLFetchNameValueDef(papszOptions, GNM_MD_NUM_PATHS,
"1"));
CPLDebug("GNM", "Search %d path(s)", nK);
std::vector<GNMPATH> paths = m_oGraph.KShortestPaths(nStartFID,
nEndFID, nK);
// fill features in result layer
for(size_t i = 0; i < paths.size(); ++i)
{
FillResultLayer(poResLayer, paths[i], static_cast<int>(i + 1), bReturnVertices,
bReturnEdges);
}
}
break;
case GATConnectedComponents:
{
GNMVECTOR anEmitters;
if(NULL != papszOptions)
{
char** papszEmitter = CSLFetchNameValueMultiple(papszOptions, GNM_MD_EMITTER);
for(int i = 0; papszEmitter[i] != NULL; ++i)
{
GNMGFID nEmitter = atol(papszEmitter[i]);
anEmitters.push_back(nEmitter);
}
CSLDestroy(papszEmitter);
}
if(nStartFID != -1)
{
anEmitters.push_back(nStartFID);
}
if(nStartFID != -1)
{
anEmitters.push_back(nEndFID);
}
GNMPATH path = m_oGraph.ConnectedComponents(anEmitters);
// fill features in result layer
FillResultLayer(poResLayer, path, 1, bReturnVertices, bReturnEdges);
}
break;
}
return poResLayer;
}
OGRLayer *OGRCouchDBDataSource::ICreateLayer( const char *pszNameIn,
OGRSpatialReference *poSpatialRef,
OGRwkbGeometryType eGType,
char ** papszOptions )
{
if( !bReadWrite )
{
CPLError(CE_Failure, CPLE_AppDefined, "Operation not available in read-only mode");
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we already have this layer? If so, should we blow it */
/* away? */
/* -------------------------------------------------------------------- */
for( int iLayer = 0; iLayer < nLayers; iLayer++ )
{
if( EQUAL(pszNameIn,papoLayers[iLayer]->GetName()) )
{
if( CSLFetchNameValue( papszOptions, "OVERWRITE" ) != NULL
&& !EQUAL(CSLFetchNameValue(papszOptions,"OVERWRITE"),"NO") )
{
DeleteLayer( pszNameIn );
break;
}
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Layer %s already exists, CreateLayer failed.\n"
"Use the layer creation option OVERWRITE=YES to "
"replace it.",
pszNameIn );
return NULL;
}
}
}
char* pszEscapedName = CPLEscapeString(pszNameIn, -1, CPLES_URL);
CPLString osEscapedName = pszEscapedName;
CPLFree(pszEscapedName);
/* -------------------------------------------------------------------- */
/* Create "database" */
/* -------------------------------------------------------------------- */
CPLString osURI;
osURI = "/";
osURI += osEscapedName;
json_object* poAnswerObj = PUT(osURI, NULL);
if (poAnswerObj == NULL)
return NULL;
if( !IsOK(poAnswerObj, "Layer creation failed") )
{
json_object_put(poAnswerObj);
return NULL;
}
json_object_put(poAnswerObj);
/* -------------------------------------------------------------------- */
/* Create "spatial index" */
/* -------------------------------------------------------------------- */
int nUpdateSeq = 0;
if (eGType != wkbNone)
{
osURI = "/";
osURI += osEscapedName;
osURI += "/_design/ogr_spatial";
CPLString osContent("{ \"spatial\": { \"spatial\" : \"function(doc) { if (doc.geometry && doc.geometry.coordinates && doc.geometry.coordinates.length != 0) { emit(doc.geometry, null); } } \" } }");
poAnswerObj = PUT(osURI, osContent);
if( IsOK(poAnswerObj, "Spatial index creation failed") )
nUpdateSeq ++;
json_object_put(poAnswerObj);
}
/* -------------------------------------------------------------------- */
/* Create validation function */
/* -------------------------------------------------------------------- */
const char* pszUpdatePermissions = CSLFetchNameValueDef(papszOptions, "UPDATE_PERMISSIONS", "LOGGED_USER");
CPLString osValidation;
if (EQUAL(pszUpdatePermissions, "LOGGED_USER"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) { if(!userCtx.name) { throw({forbidden: \\\"Please log in first.\\\"}); } }\" }";
}
else if (EQUAL(pszUpdatePermissions, "ALL"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) { }\" }";
}
else if (EQUAL(pszUpdatePermissions, "ADMIN"))
{
osValidation = "{\"validate_doc_update\": \"function(new_doc, old_doc, userCtx) {if (userCtx.roles.indexOf('_admin') === -1) { throw({forbidden: \\\"No changes allowed except by admin.\\\"}); } }\" }";
}
else if (STARTS_WITH(pszUpdatePermissions, "function("))
{
osValidation = "{\"validate_doc_update\": \"";
osValidation += pszUpdatePermissions;
osValidation += "\"}";
}
if (!osValidation.empty() )
{
osURI = "/";
osURI += osEscapedName;
osURI += "/_design/ogr_validation";
poAnswerObj = PUT(osURI, osValidation);
if( IsOK(poAnswerObj, "Validation function creation failed") )
nUpdateSeq ++;
json_object_put(poAnswerObj);
}
const bool bGeoJSONDocument =
CPLTestBool(CSLFetchNameValueDef(papszOptions, "GEOJSON", "TRUE"));
int nCoordPrecision = atoi(CSLFetchNameValueDef(papszOptions, "COORDINATE_PRECISION", "-1"));
OGRCouchDBTableLayer* poLayer = new OGRCouchDBTableLayer(this, pszNameIn);
if (nCoordPrecision != -1)
poLayer->SetCoordinatePrecision(nCoordPrecision);
poLayer->SetInfoAfterCreation(eGType, poSpatialRef,
nUpdateSeq, bGeoJSONDocument);
papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*));
papoLayers[nLayers ++] = poLayer;
return poLayer;
}
int OGRTABDataSource::Create( const char * pszName, char **papszOptions )
{
CPLAssert(m_pszName == nullptr);
m_pszName = CPLStrdup(pszName);
m_papszOptions = CSLDuplicate(papszOptions);
m_bUpdate = TRUE;
const char *pszOpt = CSLFetchNameValue(papszOptions, "FORMAT");
if( pszOpt != nullptr && EQUAL(pszOpt, "MIF") )
m_bCreateMIF = TRUE;
else if( EQUAL(CPLGetExtension(pszName),"mif") ||
EQUAL(CPLGetExtension(pszName),"mid") )
m_bCreateMIF = TRUE;
if( (pszOpt = CSLFetchNameValue(papszOptions,"SPATIAL_INDEX_MODE")) != nullptr )
{
if( EQUAL(pszOpt, "QUICK") )
m_bQuickSpatialIndexMode = TRUE;
else if( EQUAL(pszOpt, "OPTIMIZED") )
m_bQuickSpatialIndexMode = FALSE;
}
m_nBlockSize = atoi(CSLFetchNameValueDef(papszOptions, "BLOCKSIZE", "512"));
// Create a new empty directory.
VSIStatBufL sStat;
if( strlen(CPLGetExtension(pszName)) == 0 )
{
if( VSIStatL( pszName, &sStat ) == 0 )
{
if( !VSI_ISDIR(sStat.st_mode) )
{
CPLError(CE_Failure, CPLE_OpenFailed,
"Attempt to create dataset named %s,\n"
"but that is an existing file.",
pszName);
return FALSE;
}
}
else
{
if( VSIMkdir(pszName, 0755) != 0 )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Unable to create directory %s.",
pszName);
return FALSE;
}
}
m_pszDirectory = CPLStrdup(pszName);
}
// Create a new single file.
else
{
IMapInfoFile *poFile = nullptr;
const char *pszEncoding( CSLFetchNameValue( papszOptions, "ENCODING" ) );
const char *pszCharset( IMapInfoFile::EncodingToCharset( pszEncoding ) );
if( m_bCreateMIF )
{
poFile = new MIFFile;
if( poFile->Open(m_pszName, TABWrite, FALSE, pszCharset) != 0 )
{
delete poFile;
return FALSE;
}
}
else
{
TABFile *poTabFile = new TABFile;
if( poTabFile->Open(m_pszName, TABWrite, FALSE,
m_nBlockSize, pszCharset) != 0 )
{
delete poTabFile;
return FALSE;
}
poFile = poTabFile;
}
m_nLayerCount = 1;
m_papoLayers = static_cast<IMapInfoFile **>(CPLMalloc(sizeof(void *)));
m_papoLayers[0] = poFile;
m_pszDirectory = CPLStrdup(CPLGetPath(pszName));
m_bSingleFile = TRUE;
}
return TRUE;
}
int OGROCIDataSource::Open( const char * pszNewName,
char** papszOpenOptionsIn,
int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 && poSession == NULL );
/* -------------------------------------------------------------------- */
/* Verify Oracle prefix. */
/* -------------------------------------------------------------------- */
if( !STARTS_WITH_CI(pszNewName,"OCI:") )
{
if( !bTestOpen )
{
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not conform to Oracle OCI driver naming convention,"
" OCI:*\n", pszNewName );
}
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Try to parse out name, password and database name. */
/* -------------------------------------------------------------------- */
char *pszUserid;
const char *pszPassword = "";
const char *pszDatabase = "";
char **papszTableList = NULL;
const char *pszWorkspace = "";
int i;
if( pszNewName[4] == '\0' )
{
pszUserid = CPLStrdup(CSLFetchNameValueDef(papszOpenOptionsIn, "USER", ""));
pszPassword = CSLFetchNameValueDef(papszOpenOptionsIn, "PASSWORD", "");
pszDatabase = CSLFetchNameValueDef(papszOpenOptionsIn, "DBNAME", "");
const char* pszTables = CSLFetchNameValue(papszOpenOptionsIn, "TABLES");
if( pszTables )
papszTableList = CSLTokenizeStringComplex(pszTables, ",", TRUE, FALSE );
pszWorkspace = CSLFetchNameValueDef(papszOpenOptions, "WORKSPACE", "");
}
else
{
pszUserid = CPLStrdup( pszNewName + 4 );
// Is there a table list?
for( i = static_cast<int>(strlen(pszUserid))-1; i > 1; i-- )
{
if( pszUserid[i] == ':' )
{
papszTableList = CSLTokenizeStringComplex( pszUserid+i+1, ",",
TRUE, FALSE );
pszUserid[i] = '\0';
break;
}
if( pszUserid[i] == '/' || pszUserid[i] == '@' )
break;
}
for( i = 0;
pszUserid[i] != '\0' && pszUserid[i] != '/' && pszUserid[i] != '@';
i++ ) {}
if( pszUserid[i] == '/' )
{
pszUserid[i++] = '\0';
pszPassword = pszUserid + i;
for( ; pszUserid[i] != '\0' && pszUserid[i] != '@'; i++ ) {}
}
if( pszUserid[i] == '@' )
{
pszUserid[i++] = '\0';
pszDatabase = pszUserid + i;
}
}
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
CPLDebug( "OCI", "Userid=%s, Password=%s, Database=%s",
pszUserid, pszPassword, pszDatabase );
if( EQUAL(pszDatabase, "") &&
EQUAL(pszPassword, "") &&
EQUAL(pszUserid, "") )
{
/* Use username/password OS Authentication and ORACLE_SID database */
poSession = OGRGetOCISession( "/", "", "" );
}
else
{
poSession = OGRGetOCISession( pszUserid, pszPassword, pszDatabase );
}
if( poSession == NULL )
{
CPLFree(pszUserid);
CSLDestroy(papszTableList);
return FALSE;
}
if( ! EQUAL(pszWorkspace, "") )
{
OGROCIStringBuf oValidateCmd;
OGROCIStatement oValidateStmt( GetSession() );
oValidateCmd.Append( "call DBMS_WM.GotoWorkspace('" );
oValidateCmd.Append( pszWorkspace );
oValidateCmd.Append( "')" );
oValidateStmt.Execute( oValidateCmd.GetString() );
}
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* If no list of target tables was provided, collect a list of */
/* spatial tables now. */
/* -------------------------------------------------------------------- */
if( papszTableList == NULL )
{
OGROCIStatement oGetTables( poSession );
if( oGetTables.Execute(
"SELECT TABLE_NAME, OWNER FROM ALL_SDO_GEOM_METADATA" )
== CE_None )
{
char **papszRow;
while( (papszRow = oGetTables.SimpleFetchRow()) != NULL )
{
char szFullTableName[100];
if( EQUAL(papszRow[1],pszUserid) )
strcpy( szFullTableName, papszRow[0] );
else
snprintf( szFullTableName, sizeof(szFullTableName), "%s.%s",
papszRow[1], papszRow[0] );
if( CSLFindString( papszTableList, szFullTableName ) == -1 )
papszTableList = CSLAddString( papszTableList,
szFullTableName );
}
}
}
CPLFree( pszUserid );
/* -------------------------------------------------------------------- */
/* Open all the selected tables or views. */
/* -------------------------------------------------------------------- */
for( i = 0; papszTableList != NULL && papszTableList[i] != NULL; i++ )
{
OpenTable( papszTableList[i], -1, bUpdate, FALSE, papszOpenOptionsIn );
}
CSLDestroy( papszTableList );
return TRUE;
}
