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 ); }