static
void OGR2SQLITE_ogr_geocode(sqlite3_context* pContext,
int argc, sqlite3_value** argv)
{
OGRSQLiteExtensionData* poModule =
(OGRSQLiteExtensionData*) sqlite3_user_data(pContext);
if( argc < 1 || sqlite3_value_type (argv[0]) != SQLITE_TEXT )
{
sqlite3_result_null (pContext);
return;
}
const char* pszQuery = (const char*)sqlite3_value_text(argv[0]);
CPLString osField = "geometry";
if( argc >= 2 && sqlite3_value_type (argv[1]) == SQLITE_TEXT )
{
osField = (const char*)sqlite3_value_text(argv[1]);
}
int i;
char** papszOptions = NULL;
for(i = 2; i < argc; i++)
{
if( sqlite3_value_type (argv[i]) == SQLITE_TEXT )
{
papszOptions = CSLAddString(papszOptions,
(const char*)sqlite3_value_text(argv[i]));
}
}
OGRGeocodingSessionH hSession = poModule->GetGeocodingSession();
if( hSession == NULL )
{
hSession = OGRGeocodeCreateSession(papszOptions);
if( hSession == NULL )
{
sqlite3_result_null (pContext);
CSLDestroy(papszOptions);
return;
}
poModule->SetGeocodingSession(hSession);
}
if( osField == "raw" )
papszOptions = CSLAddString(papszOptions, "RAW_FEATURE=YES");
if( CSLFindString(papszOptions, "LIMIT") == -1 )
papszOptions = CSLAddString(papszOptions, "LIMIT=1");
OGRLayerH hLayer = OGRGeocode(hSession, pszQuery, NULL, papszOptions);
OGR2SQLITE_ogr_geocode_set_result(pContext, hLayer, osField);
CSLDestroy(papszOptions);
return;
}
static
void OGR2SQLITE_IgnoreAllFieldsExceptGeometry(OGRLayer* poLayer)
{
char** papszIgnored = NULL;
papszIgnored = CSLAddString(papszIgnored, "OGR_STYLE");
OGRFeatureDefn* poFeatureDefn = poLayer->GetLayerDefn();
for(int i=0; i < poFeatureDefn->GetFieldCount(); i++)
{
papszIgnored = CSLAddString(papszIgnored,
poFeatureDefn->GetFieldDefn(i)->GetNameRef());
}
poLayer->SetIgnoredFields((const char**)papszIgnored);
CSLDestroy(papszIgnored);
}
SEXP wkt_to_p4s(SEXP wkt, SEXP esri) {
OGRSpatialReference hSRS = NULL;
char *pszSRS_P4 = NULL;
char **ppszInput = NULL;
SEXP ans;
ppszInput = CSLAddString(ppszInput, CHAR(STRING_ELT(wkt, 0)));
installErrorHandler();
if (hSRS.importFromWkt(ppszInput) != OGRERR_NONE) {
uninstallErrorHandlerAndTriggerError();
error("Can't parse WKT-style parameter string");
}
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
if (INTEGER_POINTER(esri)[0] == 1) hSRS.morphFromESRI();
hSRS.exportToProj4(&pszSRS_P4);
uninstallErrorHandlerAndTriggerError();
PROTECT(ans=NEW_CHARACTER(1));
SET_STRING_ELT(ans, 0, COPY_TO_USER_STRING(pszSRS_P4));
UNPROTECT(1);
return(ans);
}
void EIRDataset::ResetKeyValue( const char *pszKey, const char *pszValue )
{
int i;
char szNewLine[82];
if( strlen(pszValue) > 65 )
{
CPLAssert( strlen(pszValue) <= 65 );
return;
}
sprintf( szNewLine, "%-15s%s", pszKey, pszValue );
for( i = CSLCount(papszHDR)-1; i >= 0; i-- )
{
if( EQUALN(papszHDR[i],szNewLine,strlen(pszKey)+1 ) )
{
if( strcmp(papszHDR[i],szNewLine) != 0 )
{
CPLFree( papszHDR[i] );
papszHDR[i] = CPLStrdup( szNewLine );
bHDRDirty = TRUE;
}
return;
}
}
bHDRDirty = TRUE;
papszHDR = CSLAddString( papszHDR, szNewLine );
}
CPLErr GDALMultiDomainMetadata::SetMetadata( char **papszMetadata,
const char *pszDomain )
{
if( pszDomain == NULL )
pszDomain = "";
int iDomain = CSLFindString( papszDomainList, pszDomain );
if( iDomain == -1 )
{
int nDomainCount;
papszDomainList = CSLAddString( papszDomainList, pszDomain );
nDomainCount = CSLCount( papszDomainList );
papoMetadataLists = (CPLStringList **)
CPLRealloc( papoMetadataLists, sizeof(void*)*(nDomainCount+1) );
papoMetadataLists[nDomainCount] = NULL;
papoMetadataLists[nDomainCount-1] = new CPLStringList();
iDomain = nDomainCount-1;
}
papoMetadataLists[iDomain]->Assign( CSLDuplicate( papszMetadata ) );
// we want to mark name/value pair domains as being sorted for fast
// access.
if( !EQUALN(pszDomain,"xml:",4) && !EQUAL(pszDomain, "SUBDATASETS") )
papoMetadataLists[iDomain]->Sort();
return CE_None;
}
void CopyBandInfo( GDALRasterBand * poSrcBand, GDALRasterBand * poDstBand, int bCopyNoData )
{
int bSuccess;
double dfNoData;
char** papszMetadata = poSrcBand->GetMetadata();
char** papszMetadataNew = NULL;
for( int i = 0; papszMetadata != NULL && papszMetadata[i] != NULL; i++ )
{
if (strncmp(papszMetadata[i], "STATISTICS_", 11) != 0)
papszMetadataNew = CSLAddString(papszMetadataNew, papszMetadata[i]);
}
poDstBand->SetMetadata( papszMetadataNew );
CSLDestroy(papszMetadataNew);
poDstBand->SetColorTable( poSrcBand->GetColorTable() );
poDstBand->SetColorInterpretation(poSrcBand->GetColorInterpretation());
if( strlen(poSrcBand->GetDescription()) > 0 )
poDstBand->SetDescription( poSrcBand->GetDescription() );
if (bCopyNoData)
{
dfNoData = poSrcBand->GetNoDataValue( &bSuccess );
if( bSuccess )
poDstBand->SetNoDataValue( dfNoData );
}
poDstBand->SetCategoryNames( poSrcBand->GetCategoryNames() );
if( !EQUAL(poSrcBand->GetUnitType(),"") )
poDstBand->SetUnitType( poSrcBand->GetUnitType() );
}
bool OGRAmigoCloudDataSource::RunDELETE(const char*pszURL)
{
CPLString osURL(pszURL);
/* -------------------------------------------------------------------- */
/* Provide the API Key */
/* -------------------------------------------------------------------- */
if( !osAPIKey.empty() )
{
if(osURL.find("?") == std::string::npos)
osURL += "?token=";
else
osURL += "&token=";
osURL += osAPIKey;
}
char** papszOptions=nullptr;
CPLString osPOSTFIELDS("CUSTOMREQUEST=DELETE");
papszOptions = CSLAddString(papszOptions, osPOSTFIELDS);
papszOptions = CSLAddString(papszOptions, GetUserAgentOption().c_str());
CPLHTTPResult * psResult = CPLHTTPFetch( osURL.c_str(), papszOptions);
CSLDestroy(papszOptions);
if( psResult == nullptr )
return false;
if (psResult->pszContentType &&
strncmp(psResult->pszContentType, "text/html", 9) == 0)
{
CPLDebug( "AMIGOCLOUD", "RunDELETE HTML Response:%s", psResult->pabyData );
CPLError(CE_Failure, CPLE_AppDefined,
"HTML error page returned by server:%s", psResult->pabyData);
CPLHTTPDestroyResult(psResult);
return false;
}
if (psResult->pszErrBuf != nullptr && psResult->pabyData != nullptr )
{
CPLError( CE_Failure, CPLE_AppDefined, "DELETE Response: %s", psResult->pabyData );
}
else if ( psResult->nStatus != 0)
{
CPLDebug( "AMIGOCLOUD", "DELETE Error Status:%d", psResult->nStatus );
}
CPLHTTPDestroyResult(psResult);
return true;
}
void CPLPushFinderLocation( const char *pszLocation )
{
CPLFinderInit();
papszFinderLocations = CSLAddString( papszFinderLocations,
pszLocation );
}
char* OGRCouchDBDataSource::GetETag(const char* pszURI)
{
// make a head request and only return the etag response header
char* pszEtag = NULL;
char **papszTokens;
char** papszOptions = NULL;
bMustCleanPersistant = TRUE;
papszOptions = CSLAddString(papszOptions, CPLSPrintf("PERSISTENT=CouchDB:%p", this));
papszOptions = CSLAddString(papszOptions, "HEADERS=Content-Type: application/json");
papszOptions = CSLAddString(papszOptions, "NO_BODY=1");
if (osUserPwd.size())
{
CPLString osUserPwdOption("USERPWD=");
osUserPwdOption += osUserPwd;
papszOptions = CSLAddString(papszOptions, osUserPwdOption);
}
CPLDebug("CouchDB", "HEAD %s", pszURI);
CPLString osFullURL(osURL);
osFullURL += pszURI;
CPLPushErrorHandler(CPLQuietErrorHandler);
CPLHTTPResult * psResult = CPLHTTPFetch( osFullURL, papszOptions);
CPLPopErrorHandler();
CSLDestroy(papszOptions);
if (psResult == NULL)
return NULL;
if (CSLFetchNameValue(psResult->papszHeaders, "Etag") != NULL)
{
papszTokens =
CSLTokenizeString2( CSLFetchNameValue(psResult->papszHeaders, "Etag"), "\"\r\n", 0 );
pszEtag = CPLStrdup(papszTokens[0]);
CSLDestroy( papszTokens );
}
CPLHTTPDestroyResult(psResult);
return pszEtag;
}
void CPLPushFinderLocation( const char *pszLocation )
{
FindFileTLS* pTLSData = CPLFinderInit();
pTLSData->papszFinderLocations = CSLAddString( pTLSData->papszFinderLocations,
pszLocation );
}
void OGRTigerDataSource::AddModule( const char *pszModule )
{
if( CheckModule( pszModule ) )
return;
papszModules = CSLAddString( papszModules, pszModule );
nModules++;
}
CPLHTTPResult * OGRGFTDataSource::RunSQL(const char* pszUnescapedSQL)
{
CPLString osSQL("POSTFIELDS=sql=");
/* Do post escaping */
for(int i=0;pszUnescapedSQL[i] != 0;i++)
{
const int ch = ((unsigned char*)pszUnescapedSQL)[i];
if (ch != '&' && ch >= 32 && ch < 128)
osSQL += (char)ch;
else
osSQL += CPLSPrintf("%%%02X", ch);
}
/* -------------------------------------------------------------------- */
/* Provide the API Key - used to rate limit access (see */
/* GFT_APIKEY config) */
/* -------------------------------------------------------------------- */
osSQL += "&key=";
osSQL += osAPIKey;
/* -------------------------------------------------------------------- */
/* Force old style CSV output from calls - maybe we want to */
/* migrate to JSON output at some point? */
/* -------------------------------------------------------------------- */
osSQL += "&alt=csv";
/* -------------------------------------------------------------------- */
/* Collection the header options and execute request. */
/* -------------------------------------------------------------------- */
char** papszOptions = CSLAddString(AddHTTPOptions(), osSQL);
CPLHTTPResult * psResult = CPLHTTPFetch( GetAPIURL(), papszOptions);
CSLDestroy(papszOptions);
/* -------------------------------------------------------------------- */
/* Check for some error conditions and report. HTML Messages */
/* are transformed info failure. */
/* -------------------------------------------------------------------- */
if (psResult && psResult->pszContentType &&
strncmp(psResult->pszContentType, "text/html", 9) == 0)
{
CPLDebug( "GFT", "RunSQL HTML Response:%s", psResult->pabyData );
CPLError(CE_Failure, CPLE_AppDefined,
"HTML error page returned by server");
CPLHTTPDestroyResult(psResult);
psResult = NULL;
}
if (psResult && psResult->pszErrBuf != NULL)
{
CPLDebug( "GFT", "RunSQL Error Message:%s", psResult->pszErrBuf );
}
else if (psResult && psResult->nStatus != 0)
{
CPLDebug( "GFT", "RunSQL Error Status:%d", psResult->nStatus );
}
return psResult;
}
bool wxGISDataset::Rename(const wxString &sNewName, ITrackCancel* const pTrackCancel)
{
wxCriticalSectionLocker locker(m_CritSect);
Close();
CPLString szDirPath = CPLGetPath(m_sPath);
CPLString szName = CPLGetBasename(m_sPath);
CPLString szNewName(ClearExt(sNewName).mb_str(wxConvUTF8));
char** papszFileList = GetFileList();
papszFileList = CSLAddString( papszFileList, m_sPath );
if(!papszFileList)
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("No files to rename"), wxNOT_FOUND, enumGISMessageErr);
return false;
}
char **papszNewFileList = NULL;
for(int i = 0; papszFileList[i] != NULL; ++i )
{
CPLString szNewPath(CPLFormFilename(szDirPath, szNewName, GetExtension(papszFileList[i], szName)));
papszNewFileList = CSLAddString(papszNewFileList, szNewPath);
if(!RenameFile(papszFileList[i], papszNewFileList[i], pTrackCancel))
{
// Try to put the ones we moved back.
for( --i; i >= 0; i-- )
RenameFile( papszNewFileList[i], papszFileList[i]);
CSLDestroy( papszFileList );
CSLDestroy( papszNewFileList );
return false;
}
}
m_sPath = CPLString(CPLFormFilename(szDirPath, szNewName, CPLGetExtension(m_sPath)));
CSLDestroy( papszFileList );
CSLDestroy( papszNewFileList );
return true;
}
bool wxGISDataset::Move(const CPLString &szDestPath, ITrackCancel* const pTrackCancel)
{
wxCriticalSectionLocker locker(m_CritSect);
Close();
char** papszFileList = GetFileList();
papszFileList = CSLAddString( papszFileList, m_sPath );
if(!papszFileList)
{
if(pTrackCancel)
pTrackCancel->PutMessage(_("No files to move"), wxNOT_FOUND, enumGISMessageErr);
return false;
}
CPLString szFileName = CPLGetBasename(GetUniqPath(m_sPath, szDestPath, CPLGetBasename(m_sPath)));
char** papszMovedFileList = NULL;
for(int i = 0; papszFileList[i] != NULL; ++i )
{
CPLString szNewDestFileName(CPLFormFilename(szDestPath, szFileName, GetExtension(papszFileList[i], szFileName)));
papszMovedFileList = CSLAddString(papszMovedFileList, szNewDestFileName);
if(!MoveFile(szNewDestFileName, papszFileList[i], pTrackCancel))
{
// Try to put the ones we moved back.
pTrackCancel->Reset();
for( --i; i >= 0; i-- )
MoveFile( papszFileList[i], papszMovedFileList[i]);
CSLDestroy( papszFileList );
CSLDestroy( papszMovedFileList );
return false;
}
}
m_sPath = CPLFormFilename(szDestPath, CPLGetFilename(m_sPath), NULL);
CSLDestroy( papszFileList );
CSLDestroy( papszMovedFileList );
return true;
}
void wxGxArchiveFolder::LoadChildren(void)
{
if(m_bIsChildrenLoaded)
return;
char **papszItems = CPLReadDir(m_sPath);
if(papszItems == NULL)
return;
char **papszFileList = NULL;
//remove unused items
for(int i = CSLCount(papszItems) - 1; i >= 0; i-- )
{
if( wxGISEQUAL(papszItems[i],".") || wxGISEQUAL(papszItems[i],"..") )
continue;
CPLString szFileName = m_sPath;
szFileName += "/";
szFileName += papszItems[i];
VSIStatBufL BufL;
int ret = VSIStatL(szFileName, &BufL);
if(ret == 0)
{
if(VSI_ISDIR(BufL.st_mode))
{
wxString sCharset(wxT("cp-866"));
wxGISAppConfig oConfig = GetConfig();
if(oConfig.IsOk())
sCharset = oConfig.Read(enumGISHKCU, wxString(wxT("wxGISCommon/zip/charset")), sCharset);
wxString sFileName(papszItems[i], wxCSConv(sCharset));
GetArchiveFolder(this, sFileName, szFileName);
}
else
{
papszFileList = CSLAddString( papszFileList, szFileName );
}
}
}
CSLDestroy( papszItems );
//load names
wxGxCatalog *pCatalog = wxDynamicCast(GetGxCatalog(), wxGxCatalog);
if(pCatalog)
{
wxArrayLong ChildrenIds;
pCatalog->CreateChildren(this, papszFileList, ChildrenIds);
for(size_t i = 0; i < ChildrenIds.GetCount(); ++i)
pCatalog->ObjectAdded(ChildrenIds[i]);
}
CSLDestroy( papszFileList );
m_bIsChildrenLoaded = true;
}
OGRErr OGRDXFWriterLayer::WriteCore( OGRFeature *poFeature )
{
/* -------------------------------------------------------------------- */
/* Write out an entity id. I'm not sure why this is critical, */
/* but it seems that VoloView will just quietly fail to open */
/* dxf files without entity ids set on most/all entities. */
/* Also, for reasons I don't understand these ids seem to have */
/* to start somewhere around 0x50 hex (80 decimal). */
/* -------------------------------------------------------------------- */
poFeature->SetFID( poDS->WriteEntityID(fp,(int)poFeature->GetFID()) );
/* -------------------------------------------------------------------- */
/* For now we assign everything to the default layer - layer */
/* "0" - if there is no layer property on the source features. */
/* -------------------------------------------------------------------- */
const char *pszLayer = poFeature->GetFieldAsString( "Layer" );
if( pszLayer == nullptr || strlen(pszLayer) == 0 )
{
WriteValue( 8, "0" );
}
else
{
CPLString osSanitizedLayer(pszLayer);
// Replaced restricted characters with underscore
// See http://docs.autodesk.com/ACD/2010/ENU/AutoCAD%202010%20User%20Documentation/index.html?url=WS1a9193826455f5ffa23ce210c4a30acaf-7345.htm,topicNumber=d0e41665
const char achForbiddenChars[] = {
'<', '>', '/', '\\', '"', ':', ';', '?', '*', '|', '=', '\'' };
for( size_t i = 0; i < CPL_ARRAYSIZE(achForbiddenChars); ++i )
{
osSanitizedLayer.replaceAll( achForbiddenChars[i], '_' );
}
// also remove newline characters (#15067)
osSanitizedLayer.replaceAll( "\r\n", "_" );
osSanitizedLayer.replaceAll( '\r', '_' );
osSanitizedLayer.replaceAll( '\n', '_' );
const char *pszExists =
poDS->oHeaderDS.LookupLayerProperty( osSanitizedLayer, "Exists" );
if( (pszExists == nullptr || strlen(pszExists) == 0)
&& CSLFindString( poDS->papszLayersToCreate, osSanitizedLayer ) == -1 )
{
poDS->papszLayersToCreate =
CSLAddString( poDS->papszLayersToCreate, osSanitizedLayer );
}
WriteValue( 8, osSanitizedLayer );
}
return OGRERR_NONE;
}
void OGRPGDumpLayer::SetOverrideColumnTypes( const char* pszOverrideColumnTypes )
{
if( pszOverrideColumnTypes == NULL )
return;
const char* pszIter = pszOverrideColumnTypes;
CPLString osCur;
while(*pszIter != '\0')
{
if( *pszIter == '(' )
{
/* Ignore commas inside ( ) pair */
while(*pszIter != '\0')
{
if( *pszIter == ')' )
{
osCur += *pszIter;
pszIter ++;
break;
}
osCur += *pszIter;
pszIter ++;
}
if( *pszIter == '\0')
break;
}
if( *pszIter == ',' )
{
papszOverrideColumnTypes = CSLAddString(papszOverrideColumnTypes, osCur);
osCur = "";
}
else
osCur += *pszIter;
pszIter ++;
}
if( osCur.size() )
papszOverrideColumnTypes = CSLAddString(papszOverrideColumnTypes, osCur);
}
SEXP
RGDAL_CreateDataset(SEXP sxpDriver, SEXP sDim, SEXP sType,
SEXP sOpts, SEXP sFile) {
GDALDriver *pDriver = getGDALDriverPtr(sxpDriver);
GDALDataset *pDataset;
const char *filename = asString(sFile);
int i/*, n*/;
char **papszCreateOptions = NULL;
#ifdef RGDALDEBUG
Rprintf("Opening dataset: %s\n", filename);
// fflush(stderr);
#endif
if (filename == NULL) error("Invalid file name\n");
GDALDataType eGDALType = (GDALDataType) asInteger(sType);
installErrorHandler();
for (i=0; i < length(sOpts); i++) papszCreateOptions = CSLAddString(
papszCreateOptions, CHAR(STRING_ELT(sOpts, i)) );
#ifdef RGDALDEBUG
for (i=0; i < CSLCount(papszCreateOptions); i++)
Rprintf("option %d: %s\n", i, CSLGetField(papszCreateOptions, i));
#endif
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
pDataset = pDriver->Create(filename,
INTEGER(sDim)[0],
INTEGER(sDim)[1],
INTEGER(sDim)[2],
eGDALType, papszCreateOptions);
uninstallErrorHandlerAndTriggerError();
installErrorHandler();
CSLDestroy(papszCreateOptions);
uninstallErrorHandlerAndTriggerError();
if (pDataset == NULL) error("Unable to create dataset\n");
installErrorHandler();
pDataset->SetDescription(filename);
uninstallErrorHandlerAndTriggerError();
SEXP sxpHandle = R_MakeExternalPtr((void *) pDataset,
mkChar("GDAL Dataset"),
R_NilValue);
return(sxpHandle);
}
OGRGFTDataSource::~OGRGFTDataSource()
{
for( int i = 0; i < nLayers; i++ )
delete papoLayers[i];
CPLFree( papoLayers );
if (bMustCleanPersistant)
{
char** papszOptions = CSLAddString(NULL, CPLSPrintf("CLOSE_PERSISTENT=GFT:%p", this));
CPLHTTPFetch( GetAPIURL(), papszOptions);
CSLDestroy(papszOptions);
}
CPLFree( pszName );
}
SEXP
RGDAL_CopyDataset(SEXP sxpDataset, SEXP sxpDriver,
SEXP sxpStrict, SEXP sxpOpts,
SEXP sxpFile) {
GDALDataset *pDataset = getGDALDatasetPtr(sxpDataset);
char **papszCreateOptions = NULL;
int i;
const char *filename = asString(sxpFile);
if (filename == NULL) error("Invalid filename\n");
GDALDriver *pDriver = getGDALDriverPtr(sxpDriver);
installErrorHandler();
for (i=0; i < length(sxpOpts); i++) papszCreateOptions = CSLAddString(
papszCreateOptions, CHAR(STRING_ELT(sxpOpts, i)) );
uninstallErrorHandlerAndTriggerError();
#ifdef RGDALDEBUG
installErrorHandler();
for (i=0; i < CSLCount(papszCreateOptions); i++)
Rprintf("option %d: %s\n", i, CSLGetField(papszCreateOptions, i));
uninstallErrorHandlerAndTriggerError();
#endif
installErrorHandler();
GDALDataset *pDatasetCopy = pDriver->CreateCopy(filename,
pDataset, asInteger(sxpStrict),
papszCreateOptions, NULL, NULL);
uninstallErrorHandlerAndTriggerError();
if (pDatasetCopy == NULL) error("Dataset copy failed\n");
installErrorHandler();
CSLDestroy(papszCreateOptions);
uninstallErrorHandlerAndTriggerError();
SEXP sxpHandle = R_MakeExternalPtr((void *) pDatasetCopy,
mkChar("GDAL Dataset"),
R_NilValue);
return(sxpHandle);
}
SEXP
RGDAL_SetCategoryNames(SEXP sxpRasterBand, SEXP sxpNames) {
GDALRasterBand *pRasterBand = getGDALRasterPtr(sxpRasterBand);
char **nameList = NULL;
int i;
for (i = 0; i < length(sxpNames); ++i)
nameList = CSLAddString(nameList, asString(sxpNames, i));
CPLErr err = pRasterBand->SetCategoryNames(nameList);
if (err == CE_Failure) warning("Failed to set category names");
return(sxpRasterBand);
}
OGRAmigoCloudDataSource::~OGRAmigoCloudDataSource()
{
for( int i = 0; i < nLayers; i++ )
delete papoLayers[i];
CPLFree( papoLayers );
if( bMustCleanPersistent )
{
char** papszOptions = nullptr;
papszOptions = CSLSetNameValue(papszOptions, "CLOSE_PERSISTENT", CPLSPrintf("AMIGOCLOUD:%p", this));
papszOptions = CSLAddString(papszOptions, GetUserAgentOption().c_str());
CPLHTTPDestroyResult( CPLHTTPFetch( GetAPIURL(), papszOptions) );
CSLDestroy(papszOptions);
}
CPLFree( pszName );
CPLFree(pszProjectId);
}
SEXP
RGDAL_SetMetadata(SEXP sxpObj, SEXP sxpMetadataList) {
void *pGDALObj = getGDALObjPtr(sxpObj);
SEXP sxpNames = getAttrib(sxpMetadataList, R_NamesSymbol);
char **metadata = (char **) CPLCalloc(1, sizeof(char *));
const char *name, *value;
if (isNull(sxpNames)) {
int i;
for (i = 0; i < length(sxpMetadataList); ++i) {
value = asString(VECTOR_ELT(sxpMetadataList, i));
CSLAddString(metadata, value);
}
} else {
int i;
for (i = 0; i < length(sxpMetadataList); ++i) {
name = asString(sxpNames, i);
value = asString(VECTOR_ELT(sxpMetadataList, i));
CSLAddNameValue(metadata, name, value);
}
}
CPLErr err = ((GDALMajorObject *)pGDALObj)->SetMetadata(metadata, NULL);
if (err == CE_Failure) warning("Failed to set metadata\n");
return(sxpObj);
}
OGRErr OGRDXFWriterLayer::WriteCore( OGRFeature *poFeature )
{
/* -------------------------------------------------------------------- */
/* Write out an entity id. I'm not sure why this is critical, */
/* but it seems that VoloView will just quietly fail to open */
/* dxf files without entity ids set on most/all entities. */
/* Also, for reasons I don't understand these ids seem to have */
/* to start somewhere around 0x50 hex (80 decimal). */
/* -------------------------------------------------------------------- */
poFeature->SetFID( poDS->WriteEntityID(fp,(int)poFeature->GetFID()) );
/* -------------------------------------------------------------------- */
/* For now we assign everything to the default layer - layer */
/* "0" - if there is no layer property on the source features. */
/* -------------------------------------------------------------------- */
const char *pszLayer = poFeature->GetFieldAsString( "Layer" );
if( pszLayer == NULL || strlen(pszLayer) == 0 )
{
WriteValue( 8, "0" );
}
else
{
const char *pszExists =
poDS->oHeaderDS.LookupLayerProperty( pszLayer, "Exists" );
if( (pszExists == NULL || strlen(pszExists) == 0)
&& CSLFindString( poDS->papszLayersToCreate, pszLayer ) == -1 )
{
poDS->papszLayersToCreate =
CSLAddString( poDS->papszLayersToCreate, pszLayer );
}
WriteValue( 8, pszLayer );
}
return OGRERR_NONE;
}
int OGRPGeoDataSource::Open( const char * pszNewName, int bUpdate,
CPL_UNUSED int bTestOpen )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* If this is the name of an MDB file, then construct the */
/* appropriate connection string. Otherwise clip of PGEO: to */
/* get the DSN. */
/* */
/* -------------------------------------------------------------------- */
char *pszDSN;
const char* pszOptionName = "";
const char* pszDSNStringTemplate = NULL;
if( EQUALN(pszNewName,"PGEO:",5) )
pszDSN = CPLStrdup( pszNewName + 5 );
else
{
pszOptionName = "PGEO_DRIVER_TEMPLATE";
pszDSNStringTemplate = CPLGetConfigOption( pszOptionName, NULL );
if( pszDSNStringTemplate == NULL )
{
pszOptionName = "";
pszDSNStringTemplate = "DRIVER=Microsoft Access Driver (*.mdb);DBQ=%s";
}
if (!CheckDSNStringTemplate(pszDSNStringTemplate))
{
CPLError( CE_Failure, CPLE_AppDefined,
"Illegal value for PGEO_DRIVER_TEMPLATE option");
return FALSE;
}
pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
sprintf( pszDSN, pszDSNStringTemplate, pszNewName );
}
/* -------------------------------------------------------------------- */
/* Initialize based on the DSN. */
/* -------------------------------------------------------------------- */
CPLDebug( "PGeo", "EstablishSession(%s)", pszDSN );
if( !oSession.EstablishSession( pszDSN, NULL, NULL ) )
{
int bError = TRUE;
if( !EQUALN(pszNewName,"PGEO:",5) )
{
// Trying with another template (#5594)
pszDSNStringTemplate = "DRIVER=Microsoft Access Driver (*.mdb, *.accdb);DBQ=%s";
CPLFree( pszDSN );
pszDSN = (char *) CPLMalloc(strlen(pszNewName)+strlen(pszDSNStringTemplate)+100);
sprintf( pszDSN, pszDSNStringTemplate, pszNewName );
CPLDebug( "PGeo", "EstablishSession(%s)", pszDSN );
if( oSession.EstablishSession( pszDSN, NULL, NULL ) )
{
bError = FALSE;
}
}
if( bError )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize ODBC connection to DSN for %s,\n"
"%s", pszDSN, oSession.GetLastError() );
CPLFree( pszDSN );
return FALSE;
}
}
CPLFree( pszDSN );
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Collect list of tables and their supporting info from */
/* GDB_GeomColumns. */
/* -------------------------------------------------------------------- */
std::vector<char **> apapszGeomColumns;
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT TableName, FieldName, ShapeType, ExtentLeft, ExtentRight, ExtentBottom, ExtentTop, SRID, HasZ FROM GDB_GeomColumns" );
if( !oStmt.ExecuteSQL() )
{
CPLDebug( "PGEO",
"SELECT on GDB_GeomColumns fails, perhaps not a personal geodatabase?\n%s",
oSession.GetLastError() );
return FALSE;
}
while( oStmt.Fetch() )
{
int i, iNew = apapszGeomColumns.size();
char **papszRecord = NULL;
for( i = 0; i < 9; i++ )
papszRecord = CSLAddString( papszRecord,
oStmt.GetColData(i) );
apapszGeomColumns.resize(iNew+1);
apapszGeomColumns[iNew] = papszRecord;
}
/* -------------------------------------------------------------------- */
/* Create a layer for each spatial table. */
/* -------------------------------------------------------------------- */
unsigned int iTable;
papoLayers = (OGRPGeoLayer **) CPLCalloc(apapszGeomColumns.size(),
sizeof(void*));
for( iTable = 0; iTable < apapszGeomColumns.size(); iTable++ )
{
char **papszRecord = apapszGeomColumns[iTable];
OGRPGeoTableLayer *poLayer;
poLayer = new OGRPGeoTableLayer( this );
if( poLayer->Initialize( papszRecord[0], // TableName
papszRecord[1], // FieldName
atoi(papszRecord[2]), // ShapeType
CPLAtof(papszRecord[3]), // ExtentLeft
CPLAtof(papszRecord[4]), // ExtentRight
CPLAtof(papszRecord[5]), // ExtentBottom
CPLAtof(papszRecord[6]), // ExtentTop
atoi(papszRecord[7]), // SRID
atoi(papszRecord[8])) // HasZ
!= CE_None )
{
delete poLayer;
}
else
papoLayers[nLayers++] = poLayer;
CSLDestroy( papszRecord );
}
return TRUE;
}
json_object* OGRCouchDBDataSource::REQUEST(const char* pszVerb,
const char* pszURI,
const char* pszData)
{
bMustCleanPersistent = true;
char** papszOptions = NULL;
papszOptions = CSLAddString(papszOptions, CPLSPrintf("PERSISTENT=CouchDB:%p", this));
CPLString osCustomRequest("CUSTOMREQUEST=");
osCustomRequest += pszVerb;
papszOptions = CSLAddString(papszOptions, osCustomRequest);
CPLString osPOSTFIELDS("POSTFIELDS=");
if (pszData)
osPOSTFIELDS += pszData;
papszOptions = CSLAddString(papszOptions, osPOSTFIELDS);
papszOptions = CSLAddString(papszOptions, "HEADERS=Content-Type: application/json");
if (!osUserPwd.empty() )
{
CPLString osUserPwdOption("USERPWD=");
osUserPwdOption += osUserPwd;
papszOptions = CSLAddString(papszOptions, osUserPwdOption);
}
CPLDebug("CouchDB", "%s %s", pszVerb, pszURI);
CPLString osFullURL(osURL);
osFullURL += pszURI;
CPLPushErrorHandler(CPLQuietErrorHandler);
CPLHTTPResult * psResult = CPLHTTPFetch( osFullURL, papszOptions);
CPLPopErrorHandler();
CSLDestroy(papszOptions);
if (psResult == NULL)
return NULL;
const char* pszServer = CSLFetchNameValue(psResult->papszHeaders, "Server");
if (pszServer == NULL || !STARTS_WITH_CI(pszServer, "CouchDB"))
{
CPLHTTPDestroyResult(psResult);
return NULL;
}
if (psResult->nDataLen == 0)
{
CPLHTTPDestroyResult(psResult);
return NULL;
}
json_object* jsobj = NULL;
const char* pszText = reinterpret_cast<const char*>(psResult->pabyData);
if( !OGRJSonParse(pszText, &jsobj, true) )
{
CPLHTTPDestroyResult(psResult);
return NULL;
}
CPLHTTPDestroyResult(psResult);
return jsobj;
}
int OGRMSSQLSpatialDataSource::Open( const char * pszNewName, int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 );
if( !EQUALN(pszNewName,"MSSQL:",6) )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not conform to MSSSQLSpatial naming convention,"
" MSSQL:*\n", pszNewName );
return FALSE;
}
/* Determine if the connection string contains specific values */
char* pszTableSpec = NULL;
char* pszGeometryFormat = NULL;
char* pszConnectionName = CPLStrdup(pszNewName + 6);
int nCurrent, nNext, nTerm;
nCurrent = nNext = nTerm = strlen(pszConnectionName);
while (nCurrent > 0)
{
--nCurrent;
if (pszConnectionName[nCurrent] == ';')
{
nNext = nCurrent;
continue;
}
if (ParseValue(&pszCatalog, pszConnectionName, "database=",
nCurrent, nNext, nTerm, FALSE))
continue;
if (ParseValue(&pszTableSpec, pszConnectionName, "tables=",
nCurrent, nNext, nTerm, TRUE))
continue;
if (ParseValue(&pszGeometryFormat, pszConnectionName,
"geometryformat=", nCurrent, nNext, nTerm, TRUE))
{
if (EQUALN(pszGeometryFormat, "wkb",3))
nGeometryFormat = MSSQLGEOMETRY_WKB;
else if (EQUALN(pszGeometryFormat,"wkt",3))
nGeometryFormat = MSSQLGEOMETRY_WKT;
else if (EQUALN(pszGeometryFormat,"native",3))
nGeometryFormat = MSSQLGEOMETRY_NATIVE;
else
{
CPLError( CE_Failure, CPLE_AppDefined,
"Invalid geometry type specified: %s,"
" MSSQL:*\n", pszGeometryFormat );
CPLFree(pszTableSpec);
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
return FALSE;
}
CPLFree(pszGeometryFormat);
pszGeometryFormat = NULL;
continue;
}
}
/* Determine if the connection string contains the catalog portion */
if( pszCatalog == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"'%s' does not contain the 'database' portion\n", pszNewName );
CPLFree(pszTableSpec);
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
return FALSE;
}
pszName = CPLStrdup(pszNewName);
char **papszTableNames=NULL;
char **papszSchemaNames=NULL;
char **papszGeomColumnNames=NULL;
char **papszCoordDimensions=NULL;
char **papszSRIds=NULL;
/* Determine if the connection string contains the TABLES portion */
if( pszTableSpec != NULL )
{
char **papszTableList;
int i;
papszTableList = CSLTokenizeString2( pszTableSpec, ",", 0 );
for( i = 0; i < CSLCount(papszTableList); i++ )
{
char **papszQualifiedParts;
// Get schema and table name
papszQualifiedParts = CSLTokenizeString2( papszTableList[i],
".", 0 );
/* Find the geometry column name if specified */
if( CSLCount( papszQualifiedParts ) >= 1 )
{
char* pszGeomColumnName = NULL;
char* pos = strchr(papszQualifiedParts[CSLCount( papszQualifiedParts ) - 1], '(');
if (pos != NULL)
{
*pos = '\0';
pszGeomColumnName = pos+1;
int len = strlen(pszGeomColumnName);
if (len > 0)
pszGeomColumnName[len - 1] = '\0';
}
papszGeomColumnNames = CSLAddString( papszGeomColumnNames,
pszGeomColumnName ? pszGeomColumnName : "");
}
if( CSLCount( papszQualifiedParts ) == 2 )
{
papszSchemaNames = CSLAddString( papszSchemaNames,
papszQualifiedParts[0] );
papszTableNames = CSLAddString( papszTableNames,
papszQualifiedParts[1] );
}
else if( CSLCount( papszQualifiedParts ) == 1 )
{
papszSchemaNames = CSLAddString( papszSchemaNames, "dbo");
papszTableNames = CSLAddString( papszTableNames,
papszQualifiedParts[0] );
}
CSLDestroy(papszQualifiedParts);
}
CSLDestroy(papszTableList);
}
CPLFree(pszTableSpec);
/* Initialize the SQL Server connection. */
CPLDebug( "OGR_MSSQLSpatial", "EstablishSession(Connection:\"%s\")", pszConnectionName);
if( !oSession.EstablishSession( CPLSPrintf("DRIVER=SQL Server;%s", pszConnectionName), "", "" ) )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Unable to initialize connection to the server for %s,\n"
"%s", pszNewName, oSession.GetLastError() );
CSLDestroy( papszTableNames );
CSLDestroy( papszSchemaNames );
CSLDestroy( papszGeomColumnNames );
CSLDestroy( papszCoordDimensions );
CSLDestroy( papszSRIds );
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
return FALSE;
}
char** papszTypes = NULL;
/* Determine the available tables if not specified. */
if (papszTableNames == NULL)
{
CPLODBCStatement oStmt( &oSession );
oStmt.Append( "SELECT f_table_schema, f_table_name, f_geometry_column, coord_dimension, srid, geometry_type FROM dbo.geometry_columns");
if( oStmt.ExecuteSQL() )
{
while( oStmt.Fetch() )
{
papszSchemaNames =
CSLAddString( papszSchemaNames, oStmt.GetColData(0) );
papszTableNames =
CSLAddString( papszTableNames, oStmt.GetColData(1) );
papszGeomColumnNames =
CSLAddString( papszGeomColumnNames, oStmt.GetColData(2) );
papszCoordDimensions =
CSLAddString( papszCoordDimensions, oStmt.GetColData(3) );
papszSRIds =
CSLAddString( papszSRIds, oStmt.GetColData(4) );
papszTypes =
CSLAddString( papszTypes, oStmt.GetColData(5) );
}
}
}
int nSRId, nCoordDimension;
OGRwkbGeometryType eType;
for( int iTable = 0;
papszTableNames != NULL && papszTableNames[iTable] != NULL;
iTable++ )
{
if (papszSRIds != NULL)
nSRId = atoi(papszSRIds[iTable]);
else
nSRId = -1;
if (papszCoordDimensions != NULL)
nCoordDimension = atoi(papszCoordDimensions[iTable]);
else
nCoordDimension = 2;
if (papszTypes != NULL)
eType = OGRFromOGCGeomType(papszTypes[iTable]);
else
eType = wkbUnknown;
if( strlen(papszGeomColumnNames[iTable]) > 0 )
OpenTable( papszSchemaNames[iTable], papszTableNames[iTable], papszGeomColumnNames[iTable],
nCoordDimension, nSRId, eType, bUpdate );
else
OpenTable( papszSchemaNames[iTable], papszTableNames[iTable], NULL,
nCoordDimension, nSRId, eType, bUpdate );
}
CSLDestroy( papszTableNames );
CSLDestroy( papszSchemaNames );
CSLDestroy( papszGeomColumnNames );
CSLDestroy( papszCoordDimensions );
CSLDestroy( papszSRIds );
CSLDestroy( papszTypes );
CPLFree(pszGeometryFormat);
CPLFree(pszConnectionName);
bDSUpdate = bUpdate;
return TRUE;
}
json_object* OGRAmigoCloudDataSource::RunDELETE(const char*pszURL)
{
CPLString osURL(pszURL);
/* -------------------------------------------------------------------- */
/* Provide the API Key */
/* -------------------------------------------------------------------- */
if( osAPIKey.size() > 0 )
{
osURL += "?token=";
osURL += osAPIKey;
}
char** papszOptions=NULL;
CPLString osPOSTFIELDS("CUSTOMREQUEST=DELETE");
papszOptions = CSLAddString(papszOptions, osPOSTFIELDS);
CPLHTTPResult * psResult = CPLHTTPFetch( osURL.c_str(), papszOptions);
CSLDestroy(papszOptions);
if( psResult == NULL )
return NULL;
if (psResult->pszContentType &&
strncmp(psResult->pszContentType, "text/html", 9) == 0)
{
CPLDebug( "AMIGOCLOUD", "RunDELETE HTML Response:%s", psResult->pabyData );
CPLError(CE_Failure, CPLE_AppDefined,
"HTML error page returned by server:%s", psResult->pabyData);
CPLHTTPDestroyResult(psResult);
return NULL;
}
if (psResult->pszErrBuf != NULL)
{
CPLDebug( "AMIGOCLOUD", "RunDELETE Error Message:%s", psResult->pszErrBuf );
}
else if ( psResult->nStatus != 0)
{
CPLDebug( "AMIGOCLOUD", "RunDELETE Error Status:%d", psResult->nStatus );
}
if( psResult->pabyData == NULL )
{
CPLHTTPDestroyResult(psResult);
return NULL;
}
CPLDebug( "AMIGOCLOUD", "RunDELETE Response:%s", psResult->pabyData );
json_tokener* jstok = NULL;
json_object* poObj = NULL;
jstok = json_tokener_new();
poObj = json_tokener_parse_ex(jstok, (const char*) psResult->pabyData, -1);
if( jstok->err != json_tokener_success)
{
CPLError( CE_Failure, CPLE_AppDefined,
"JSON parsing error: %s (at offset %d)",
json_tokener_error_desc(jstok->err), jstok->char_offset);
json_tokener_free(jstok);
CPLHTTPDestroyResult(psResult);
return NULL;
}
json_tokener_free(jstok);
CPLHTTPDestroyResult(psResult);
if( poObj != NULL )
{
if( json_object_get_type(poObj) == json_type_object )
{
json_object* poError = CPL_json_object_object_get(poObj, "error");
if( poError != NULL && json_object_get_type(poError) == json_type_array &&
json_object_array_length(poError) > 0 )
{
poError = json_object_array_get_idx(poError, 0);
if( poError != NULL && json_object_get_type(poError) == json_type_string )
{
CPLError(CE_Failure, CPLE_AppDefined,
"Error returned by server : %s", json_object_get_string(poError));
json_object_put(poObj);
return NULL;
}
}
}
else
{
json_object_put(poObj);
return NULL;
}
}
return poObj;
}
int OGRMySQLDataSource::Open( const char * pszNewName, int bUpdate,
int bTestOpen )
{
CPLAssert( nLayers == 0 );
/* -------------------------------------------------------------------- */
/* Verify MySQL prefix. */
/* -------------------------------------------------------------------- */
if( !EQUALN(pszNewName,"MYSQL:",6) )
{
if( !bTestOpen )
CPLError( CE_Failure, CPLE_AppDefined,
"%s does not conform to MySQL naming convention,"
" MYSQL:dbname[, user=..][,password=..][,host=..][,port=..][tables=table;table;...]",
pszNewName );
return FALSE;
}
/* -------------------------------------------------------------------- */
/* Use options process to get .my.cnf file contents. */
/* -------------------------------------------------------------------- */
int nPort = 0, i;
char **papszTableNames=NULL;
std::string oHost, oPassword, oUser, oDB;
char *apszArgv[2] = { (char*) "org", NULL };
char **papszArgv = apszArgv;
int nArgc = 1;
const char *client_groups[] = {"client", "ogr", NULL };
my_init(); // I hope there is no problem with calling this multiple times!
load_defaults( "my", client_groups, &nArgc, &papszArgv );
for( i = 0; i < nArgc; i++ )
{
if( EQUALN(papszArgv[i],"--user="******"--host=",7) )
oHost = papszArgv[i] + 7;
else if( EQUALN(papszArgv[i],"--password="******"--port=",7) )
nPort = atoi(papszArgv[i] + 7);
}
// cleanup
free_defaults( papszArgv );
/* -------------------------------------------------------------------- */
/* Parse out connection information. */
/* -------------------------------------------------------------------- */
char **papszItems = CSLTokenizeString2( pszNewName+6, ",",
CSLT_HONOURSTRINGS );
if( CSLCount(papszItems) < 1 )
{
CSLDestroy( papszItems );
CPLError( CE_Failure, CPLE_AppDefined,
"MYSQL: request missing databasename." );
return FALSE;
}
oDB = papszItems[0];
for( i = 1; papszItems[i] != NULL; i++ )
{
if( EQUALN(papszItems[i],"user="******"password="******"host=",5) )
oHost = papszItems[i] + 5;
else if( EQUALN(papszItems[i],"port=",5) )
nPort = atoi(papszItems[i] + 5);
else if( EQUALN(papszItems[i],"tables=",7) )
{
papszTableNames = CSLTokenizeStringComplex(
papszItems[i] + 7, ";", FALSE, FALSE );
}
else
CPLError( CE_Warning, CPLE_AppDefined,
"'%s' in MYSQL datasource definition not recognised and ignored.", papszItems[i] );
}
CSLDestroy( papszItems );
/* -------------------------------------------------------------------- */
/* Try to establish connection. */
/* -------------------------------------------------------------------- */
hConn = mysql_init( NULL );
if( hConn == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"mysql_init() failed." );
}
/* -------------------------------------------------------------------- */
/* Set desired options on the connection: charset and timeout. */
/* -------------------------------------------------------------------- */
if( hConn )
{
const char *pszTimeoutLength =
CPLGetConfigOption( "MYSQL_TIMEOUT", "0" );
unsigned int timeout = atoi(pszTimeoutLength);
mysql_options(hConn, MYSQL_OPT_CONNECT_TIMEOUT, (char*)&timeout);
mysql_options(hConn, MYSQL_SET_CHARSET_NAME, "utf8" );
}
/* -------------------------------------------------------------------- */
/* Perform connection. */
/* -------------------------------------------------------------------- */
if( hConn
&& mysql_real_connect( hConn,
oHost.length() ? oHost.c_str() : NULL,
oUser.length() ? oUser.c_str() : NULL,
oPassword.length() ? oPassword.c_str() : NULL,
oDB.length() ? oDB.c_str() : NULL,
nPort, NULL, CLIENT_INTERACTIVE ) == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"MySQL connect failed for: %s\n%s",
pszNewName + 6, mysql_error( hConn ) );
mysql_close( hConn );
hConn = NULL;
}
if( hConn == NULL )
{
CSLDestroy( papszTableNames );
return FALSE;
}
pszName = CPLStrdup( pszNewName );
bDSUpdate = bUpdate;
/* -------------------------------------------------------------------- */
/* Get a list of available tables. */
/* -------------------------------------------------------------------- */
if( papszTableNames == NULL )
{
MYSQL_RES *hResultSet;
MYSQL_ROW papszRow;
if( mysql_query( hConn, "SHOW TABLES" ) )
{
ReportError( "SHOW TABLES Failed" );
return FALSE;
}
hResultSet = mysql_store_result( hConn );
if( hResultSet == NULL )
{
ReportError( "mysql_store_result() failed on SHOW TABLES result.");
return FALSE;
}
while( (papszRow = mysql_fetch_row( hResultSet )) != NULL )
{
if( papszRow[0] == NULL )
continue;
if( EQUAL(papszRow[0],"spatial_ref_sys")
|| EQUAL(papszRow[0],"geometry_columns") )
continue;
papszTableNames = CSLAddString(papszTableNames, papszRow[0] );
}
mysql_free_result( hResultSet );
}
/* -------------------------------------------------------------------- */
/* Get the schema of the available tables. */
/* -------------------------------------------------------------------- */
int iRecord;
for( iRecord = 0;
papszTableNames != NULL && papszTableNames[iRecord] != NULL;
iRecord++ )
{
// FIXME: This should be fixed to deal with tables
// for which we can't open because the name is bad/
OpenTable( papszTableNames[iRecord], bUpdate, FALSE );
}
CSLDestroy( papszTableNames );
return nLayers > 0 || bUpdate;
}
int main( int argc, char ** argv )
{
GDALDatasetH hDataset, hOutDS;
int i;
const char *pszSource=NULL, *pszDest=NULL, *pszFormat = "GTiff";
GDALDriverH hDriver;
GDALDataType eOutputType = GDT_Unknown;
char **papszCreateOptions = NULL;
GDALProgressFunc pfnProgress = GDALTermProgress;
int nLUTBins = 256;
const char *pszMethod = "minmax";
// double dfStdDevMult = 0.0;
double *padfScaleMin = NULL;
double *padfScaleMax = NULL;
int **papanLUTs = NULL;
int iBand;
const char *pszConfigFile = NULL;
/* Check strict compilation and runtime library version as we use C++ API */
if (! GDAL_CHECK_VERSION(argv[0]))
exit(1);
/* -------------------------------------------------------------------- */
/* Register standard GDAL drivers, and process generic GDAL */
/* command options. */
/* -------------------------------------------------------------------- */
GDALAllRegister();
argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 );
if( argc < 1 )
exit( -argc );
/* -------------------------------------------------------------------- */
/* Handle command line arguments. */
/* -------------------------------------------------------------------- */
for( i = 1; i < argc; i++ )
{
if( EQUAL(argv[i], "--utility_version") )
{
printf("%s was compiled against GDAL %s and is running against GDAL %s\n",
argv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME"));
return 0;
}
else if( EQUAL(argv[i],"-of") && i < argc-1 )
pszFormat = argv[++i];
else if( EQUAL(argv[i],"-ot") && i < argc-1 )
{
int iType;
for( iType = 1; iType < GDT_TypeCount; iType++ )
{
if( GDALGetDataTypeName((GDALDataType)iType) != NULL
&& EQUAL(GDALGetDataTypeName((GDALDataType)iType),
argv[i+1]) )
{
eOutputType = (GDALDataType) iType;
}
}
if( eOutputType == GDT_Unknown )
{
printf( "Unknown output pixel type: %s\n", argv[i+1] );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
i++;
}
else if( EQUALN(argv[i],"-s_nodata",9) )
{
// TODO
i += 1;
}
else if( EQUAL(argv[i],"-co") && i < argc-1 )
{
papszCreateOptions = CSLAddString( papszCreateOptions, argv[++i] );
}
else if( EQUALN(argv[i],"-src_scale",10) && i < argc-2)
{
// TODO
i += 2;
}
else if( EQUALN(argv[i],"-dst_scale",10) && i < argc-2 )
{
// TODO
i += 2;
}
else if( EQUAL(argv[i],"-config") && i < argc-1 )
{
pszConfigFile = argv[++i];
}
else if( EQUAL(argv[i],"-equalize") )
{
pszMethod = "equalize";
}
else if( EQUAL(argv[i],"-quiet") )
{
pfnProgress = GDALDummyProgress;
}
else if( argv[i][0] == '-' )
{
printf( "Option %s incomplete, or not recognised.\n\n",
argv[i] );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
else if( pszSource == NULL )
{
pszSource = argv[i];
}
else if( pszDest == NULL )
{
pszDest = argv[i];
}
else
{
printf( "Too many command options.\n\n" );
Usage();
GDALDestroyDriverManager();
exit( 2 );
}
}
if( pszSource == NULL )
{
Usage();
GDALDestroyDriverManager();
exit( 10 );
}
/* -------------------------------------------------------------------- */
/* Attempt to open source file. */
/* -------------------------------------------------------------------- */
hDataset = GDALOpenShared( pszSource, GA_ReadOnly );
if( hDataset == NULL )
{
fprintf( stderr,
"GDALOpen failed - %d\n%s\n",
CPLGetLastErrorNo(), CPLGetLastErrorMsg() );
GDALDestroyDriverManager();
exit( 1 );
}
int nBandCount = GDALGetRasterCount(hDataset);
/* -------------------------------------------------------------------- */
/* Find the output driver. */
/* -------------------------------------------------------------------- */
hDriver = GDALGetDriverByName( pszFormat );
if( hDriver == NULL )
{
int iDr;
printf( "Output driver `%s' not recognised.\n", pszFormat );
printf( "The following format drivers are configured and support output:\n" );
for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )
{
GDALDriverH hDriver = GDALGetDriver(iDr);
if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) != NULL
|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATECOPY,
NULL ) != NULL )
{
printf( " %s: %s\n",
GDALGetDriverShortName( hDriver ),
GDALGetDriverLongName( hDriver ) );
}
}
printf( "\n" );
Usage();
GDALClose( hDataset );
GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
exit( 1 );
}
/* -------------------------------------------------------------------- */
/* If histogram equalization is requested, do it now. */
/* -------------------------------------------------------------------- */
if( EQUAL(pszMethod,"equalize") )
{
ComputeEqualizationLUTs( hDataset, nLUTBins,
&padfScaleMin, &padfScaleMax,
&papanLUTs, pfnProgress );
}
/* -------------------------------------------------------------------- */
/* If we have a config file, assume it is for input and read */
/* it. */
/* -------------------------------------------------------------------- */
else if( pszConfigFile != NULL )
{
char **papszLines = CSLLoad( pszConfigFile );
if( CSLCount(papszLines) == 0 )
exit( 1 );
if( CSLCount(papszLines) != nBandCount )
{
fprintf( stderr, "Did not get %d lines in config file as expected.\n", nBandCount );
exit( 1 );
}
padfScaleMin = (double *) CPLCalloc(nBandCount,sizeof(double));
padfScaleMax = (double *) CPLCalloc(nBandCount,sizeof(double));
for( iBand = 0; iBand < nBandCount; iBand++ )
{
int iLUT;
char **papszTokens = CSLTokenizeString( papszLines[iBand] );
if( CSLCount(papszTokens) < 3
|| atoi(papszTokens[0]) != iBand+1 )
{
fprintf( stderr, "Line %d seems to be corrupt.\n", iBand+1 );
exit( 1 );
}
// Process scale min/max
padfScaleMin[iBand] = atof(papszTokens[1]);
padfScaleMax[iBand] = atof(papszTokens[2]);
if( CSLCount(papszTokens) == 3 )
continue;
// process lut
if( iBand == 0 )
{
nLUTBins = CSLCount(papszTokens) - 3;
papanLUTs = (int **) CPLCalloc(sizeof(int*),nBandCount);
}
papanLUTs[iBand] = (int *) CPLCalloc(nLUTBins,sizeof(int));
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
papanLUTs[iBand][iLUT] = atoi(papszTokens[iLUT+3]);
CSLDestroy( papszTokens );
}
}
/* -------------------------------------------------------------------- */
/* If there is no destination, just report the scaling values */
/* and luts. */
/* -------------------------------------------------------------------- */
if( pszDest == NULL )
{
FILE *fpConfig = stdout;
if( pszConfigFile )
fpConfig = fopen( pszConfigFile, "w" );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
fprintf( fpConfig, "%d:Band ", iBand+1 );
if( padfScaleMin != NULL )
fprintf( fpConfig, "%g:ScaleMin %g:ScaleMax ",
padfScaleMin[iBand], padfScaleMax[iBand] );
if( papanLUTs )
{
int iLUT;
for( iLUT = 0; iLUT < nLUTBins; iLUT++ )
fprintf( fpConfig, "%d ", papanLUTs[iBand][iLUT] );
}
fprintf( fpConfig, "\n" );
}
if( pszConfigFile )
fclose( fpConfig );
exit( 0 );
}
if (padfScaleMin == NULL || padfScaleMax == NULL)
{
fprintf( stderr, "-equalize or -config filename command line options must be specified.\n");
exit(1);
}
/* ==================================================================== */
/* Create a virtual dataset. */
/* ==================================================================== */
VRTDataset *poVDS;
EnhanceCBInfo *pasEInfo = (EnhanceCBInfo *)
CPLCalloc(nBandCount, sizeof(EnhanceCBInfo));
/* -------------------------------------------------------------------- */
/* Make a virtual clone. */
/* -------------------------------------------------------------------- */
poVDS = new VRTDataset( GDALGetRasterXSize(hDataset),
GDALGetRasterYSize(hDataset) );
if( GDALGetGCPCount(hDataset) == 0 )
{
const char *pszProjection;
double adfGeoTransform[6];
pszProjection = GDALGetProjectionRef( hDataset );
if( pszProjection != NULL && strlen(pszProjection) > 0 )
poVDS->SetProjection( pszProjection );
if( GDALGetGeoTransform( hDataset, adfGeoTransform ) == CE_None )
poVDS->SetGeoTransform( adfGeoTransform );
}
else
{
poVDS->SetGCPs( GDALGetGCPCount(hDataset),
GDALGetGCPs(hDataset),
GDALGetGCPProjection( hDataset ) );
}
poVDS->SetMetadata( ((GDALDataset*)hDataset)->GetMetadata() );
for( iBand = 0; iBand < nBandCount; iBand++ )
{
VRTSourcedRasterBand *poVRTBand;
GDALRasterBand *poSrcBand;
GDALDataType eBandType;
poSrcBand = ((GDALDataset *) hDataset)->GetRasterBand(iBand+1);
/* -------------------------------------------------------------------- */
/* Select output data type to match source. */
/* -------------------------------------------------------------------- */
if( eOutputType == GDT_Unknown )
eBandType = GDT_Byte;
else
eBandType = eOutputType;
/* -------------------------------------------------------------------- */
/* Create this band. */
/* -------------------------------------------------------------------- */
poVDS->AddBand( eBandType, NULL );
poVRTBand = (VRTSourcedRasterBand *) poVDS->GetRasterBand( iBand+1 );
/* -------------------------------------------------------------------- */
/* Create a function based source with info on how to apply the */
/* enhancement. */
/* -------------------------------------------------------------------- */
pasEInfo[iBand].poSrcBand = poSrcBand;
pasEInfo[iBand].eWrkType = eBandType;
pasEInfo[iBand].dfScaleMin = padfScaleMin[iBand];
pasEInfo[iBand].dfScaleMax = padfScaleMax[iBand];
pasEInfo[iBand].nLUTBins = nLUTBins;
if( papanLUTs )
pasEInfo[iBand].panLUT = papanLUTs[iBand];
poVRTBand->AddFuncSource( EnhancerCallback, pasEInfo + iBand );
/* -------------------------------------------------------------------- */
/* copy over some other information of interest. */
/* -------------------------------------------------------------------- */
poVRTBand->CopyCommonInfoFrom( poSrcBand );
}
/* -------------------------------------------------------------------- */
/* Write to the output file using CopyCreate(). */
/* -------------------------------------------------------------------- */
hOutDS = GDALCreateCopy( hDriver, pszDest, (GDALDatasetH) poVDS,
FALSE, papszCreateOptions,
pfnProgress, NULL );
if( hOutDS != NULL )
GDALClose( hOutDS );
GDALClose( (GDALDatasetH) poVDS );
GDALClose( hDataset );
/* -------------------------------------------------------------------- */
/* Cleanup and exit. */
/* -------------------------------------------------------------------- */
GDALDumpOpenDatasets( stderr );
GDALDestroyDriverManager();
CSLDestroy( argv );
CSLDestroy( papszCreateOptions );
exit( 0 );
}
