int main(int nArgc, char* papszArgv[]) { const char *pszFilename = NULL, *pszOutFilename = NULL; DDFModule oModule; /* -------------------------------------------------------------------- */ /* Check arguments. */ /* -------------------------------------------------------------------- */ for( int iArg = 1; iArg < nArgc; iArg++ ) { if( pszFilename == NULL ) pszFilename = papszArgv[iArg]; else if( pszOutFilename == NULL ) pszOutFilename = papszArgv[iArg]; else { pszFilename = NULL; break; } } if( pszFilename == NULL ) { printf( "Usage: 8211createfromxml filename.xml outfilename\n" ); exit( 1 ); } CPLXMLNode* poRoot = CPLParseXMLFile( pszFilename ); if( poRoot == NULL ) { fprintf(stderr, "Cannot parse XML file '%s'\n", pszFilename); exit( 1 ); } CPLXMLNode* poXMLDDFModule = CPLSearchXMLNode(poRoot, "=DDFModule"); if( poXMLDDFModule == NULL ) { fprintf(stderr, "Cannot find DDFModule node in XML file '%s'\n", pszFilename); exit( 1 ); } /* Compute the size of the DDFField tag */ CPLXMLNode* psIter = poXMLDDFModule->psChild; int nSizeFieldTag = 0; while( psIter != NULL ) { if( psIter->eType == CXT_Element && strcmp(psIter->pszValue, "DDFFieldDefn") == 0 ) { const char* pszTag = CPLGetXMLValue(psIter, "tag", ""); if( nSizeFieldTag == 0 ) nSizeFieldTag = (int)strlen(pszTag); else if( nSizeFieldTag != (int)strlen(pszTag) ) { fprintf(stderr, "All fields have not the same tag size\n"); exit( 1 ); } } psIter = psIter->psNext; } char chInterchangeLevel = '3'; char chLeaderIden = 'L'; char chCodeExtensionIndicator = 'E'; char chVersionNumber = '1'; char chAppIndicator = ' '; const char *pszExtendedCharSet = " ! "; int nSizeFieldLength = 3; int nSizeFieldPos = 4; chInterchangeLevel = CPLGetXMLValue(poXMLDDFModule, "_interchangeLevel", CPLSPrintf("%c", chInterchangeLevel))[0]; chLeaderIden = CPLGetXMLValue(poXMLDDFModule, "_leaderIden", CPLSPrintf("%c", chLeaderIden))[0]; chCodeExtensionIndicator = CPLGetXMLValue(poXMLDDFModule, "_inlineCodeExtensionIndicator", CPLSPrintf("%c", chCodeExtensionIndicator))[0]; chVersionNumber = CPLGetXMLValue(poXMLDDFModule, "_versionNumber", CPLSPrintf("%c", chVersionNumber))[0]; chAppIndicator = CPLGetXMLValue(poXMLDDFModule, "_appIndicator", CPLSPrintf("%c", chAppIndicator))[0]; char szExtendedCharSet[4]; snprintf(szExtendedCharSet, sizeof(szExtendedCharSet), "%s", CPLGetXMLValue(poXMLDDFModule, "_extendedCharSet", pszExtendedCharSet)); pszExtendedCharSet = szExtendedCharSet; nSizeFieldLength = atoi(CPLGetXMLValue(poXMLDDFModule, "_sizeFieldLength", CPLSPrintf("%d", nSizeFieldLength))); nSizeFieldPos = atoi(CPLGetXMLValue(poXMLDDFModule, "_sizeFieldPos", CPLSPrintf("%d", nSizeFieldPos))); nSizeFieldTag = atoi(CPLGetXMLValue(poXMLDDFModule, "_sizeFieldTag", CPLSPrintf("%d", nSizeFieldTag))); oModule.Initialize(chInterchangeLevel, chLeaderIden, chCodeExtensionIndicator, chVersionNumber, chAppIndicator, pszExtendedCharSet, nSizeFieldLength, nSizeFieldPos, nSizeFieldTag); oModule.SetFieldControlLength(atoi(CPLGetXMLValue(poXMLDDFModule, "_fieldControlLength", CPLSPrintf("%d", oModule.GetFieldControlLength())))); int bCreated = FALSE; /* Create DDFFieldDefn and DDFRecord elements */ psIter = poXMLDDFModule->psChild; while( psIter != NULL ) { if( psIter->eType == CXT_Element && strcmp(psIter->pszValue, "DDFFieldDefn") == 0 ) { DDFFieldDefn* poFDefn = new DDFFieldDefn(); DDF_data_struct_code eStructCode = dsc_elementary; const char* pszStructCode = CPLGetXMLValue(psIter, "dataStructCode", ""); if( strcmp(pszStructCode, "elementary") == 0 ) eStructCode = dsc_elementary; else if( strcmp(pszStructCode, "vector") == 0 ) eStructCode = dsc_vector; else if( strcmp(pszStructCode, "array") == 0 ) eStructCode = dsc_array; else if( strcmp(pszStructCode, "concatenated") == 0 ) eStructCode = dsc_concatenated; DDF_data_type_code eTypeCode = dtc_char_string; const char* pszTypeCode = CPLGetXMLValue(psIter, "dataTypeCode", ""); if( strcmp(pszTypeCode, "char_string") == 0 ) eTypeCode = dtc_char_string; else if( strcmp(pszTypeCode, "implicit_point") == 0 ) eTypeCode = dtc_implicit_point; else if( strcmp(pszTypeCode, "explicit_point") == 0 ) eTypeCode = dtc_explicit_point; else if( strcmp(pszTypeCode, "explicit_point_scaled") == 0 ) eTypeCode = dtc_explicit_point_scaled; else if( strcmp(pszTypeCode, "char_bit_string") == 0 ) eTypeCode = dtc_char_bit_string; else if( strcmp(pszTypeCode, "bit_string") == 0 ) eTypeCode = dtc_bit_string; else if( strcmp(pszTypeCode, "mixed_data_type") == 0 ) eTypeCode = dtc_mixed_data_type; const char* pszFormatControls = CPLGetXMLValue(psIter, "formatControls", NULL); if( eStructCode != dsc_elementary ) pszFormatControls = NULL; const char* pszArrayDescr = CPLGetXMLValue(psIter, "arrayDescr", ""); if( eStructCode == dsc_vector ) pszArrayDescr = ""; else if( eStructCode == dsc_array ) pszArrayDescr = "*"; poFDefn->Create( CPLGetXMLValue(psIter, "tag", ""), CPLGetXMLValue(psIter, "fieldName", ""), pszArrayDescr, eStructCode, eTypeCode, pszFormatControls ); CPLXMLNode* psSubIter = psIter->psChild; while( psSubIter != NULL ) { if( psSubIter->eType == CXT_Element && strcmp(psSubIter->pszValue, "DDFSubfieldDefn") == 0 ) { poFDefn->AddSubfield( CPLGetXMLValue(psSubIter, "name", ""), CPLGetXMLValue(psSubIter, "format", "") ); } psSubIter = psSubIter->psNext; } pszFormatControls = CPLGetXMLValue(psIter, "formatControls", NULL); if( pszFormatControls ) poFDefn->SetFormatControls(pszFormatControls); oModule.AddField( poFDefn ); } else if( psIter->eType == CXT_Element && strcmp(psIter->pszValue, "DDFRecord") == 0 ) { //const bool bFirstRecord = !bCreated; if( !bCreated ) { oModule.Create( pszOutFilename ); bCreated = TRUE; } DDFRecord *poRec = new DDFRecord( &oModule ); std::map<std::string, int> oMapField; //if( !bFirstRecord ) // poRec->SetReuseHeader(atoi(CPLGetXMLValue(psIter, "reuseHeader", CPLSPrintf("%d", poRec->GetReuseHeader())))); poRec->SetSizeFieldLength(atoi(CPLGetXMLValue(psIter, "_sizeFieldLength", CPLSPrintf("%d", poRec->GetSizeFieldLength())))); poRec->SetSizeFieldPos(atoi(CPLGetXMLValue(psIter, "_sizeFieldPos", CPLSPrintf("%d", poRec->GetSizeFieldPos())))); poRec->SetSizeFieldTag(atoi(CPLGetXMLValue(psIter, "_sizeFieldTag", CPLSPrintf("%d", poRec->GetSizeFieldTag())))); CPLXMLNode* psSubIter = psIter->psChild; while( psSubIter != NULL ) { if( psSubIter->eType == CXT_Element && strcmp(psSubIter->pszValue, "DDFField") == 0 ) { const char* pszFieldName = CPLGetXMLValue(psSubIter, "name", ""); DDFFieldDefn* poFieldDefn = oModule.FindFieldDefn( pszFieldName ); if( poFieldDefn == NULL ) { fprintf(stderr, "Can't find field '%s'\n", pszFieldName ); exit(1); } int nFieldOcc = oMapField[pszFieldName]; oMapField[pszFieldName] ++ ; DDFField *poField = poRec->AddField( poFieldDefn ); const char* pszValue = CPLGetXMLValue(psSubIter, "value", NULL); if( pszValue != NULL && STARTS_WITH(pszValue, "0x") ) { pszValue += 2; int nDataLen = (int)strlen(pszValue) / 2; char* pabyData = (char*) malloc(nDataLen); for(int i=0;i<nDataLen;i++) { char c; int nHigh, nLow; c = pszValue[2*i]; if( c >= 'A' && c <= 'F' ) nHigh = 10 + c - 'A'; else nHigh = c - '0'; c = pszValue[2*i + 1]; if( c >= 'A' && c <= 'F' ) nLow = 10 + c - 'A'; else nLow = c - '0'; pabyData[i] = (nHigh << 4) + nLow; } poRec->SetFieldRaw( poField, nFieldOcc, (const char *) pabyData, nDataLen ); free(pabyData); } else { CPLXMLNode* psSubfieldIter = psSubIter->psChild; std::map<std::string, int> oMapSubfield; while( psSubfieldIter != NULL ) { if( psSubfieldIter->eType == CXT_Element && strcmp(psSubfieldIter->pszValue, "DDFSubfield") == 0 ) { const char* pszSubfieldName = CPLGetXMLValue(psSubfieldIter, "name", ""); const char* pszSubfieldType = CPLGetXMLValue(psSubfieldIter, "type", ""); const char* pszSubfieldValue = CPLGetXMLValue(psSubfieldIter, NULL, ""); int nOcc = oMapSubfield[pszSubfieldName]; oMapSubfield[pszSubfieldName] ++ ; if( strcmp(pszSubfieldType, "float") == 0 ) { poRec->SetFloatSubfield( pszFieldName, nFieldOcc, pszSubfieldName, nOcc, CPLAtof(pszSubfieldValue) ); } else if( strcmp(pszSubfieldType, "integer") == 0 ) { poRec->SetIntSubfield( pszFieldName, nFieldOcc, pszSubfieldName, nOcc, atoi(pszSubfieldValue) ); } else if( strcmp(pszSubfieldType, "string") == 0 ) { poRec->SetStringSubfield( pszFieldName, nFieldOcc, pszSubfieldName, nOcc, pszSubfieldValue ); } else if( strcmp(pszSubfieldType, "binary") == 0 && STARTS_WITH(pszSubfieldValue, "0x") ) { pszSubfieldValue += 2; int nDataLen = (int)strlen(pszSubfieldValue) / 2; char* pabyData = (char*) malloc(nDataLen); for(int i=0;i<nDataLen;i++) { char c; int nHigh, nLow; c = pszSubfieldValue[2*i]; if( c >= 'A' && c <= 'F' ) nHigh = 10 + c - 'A'; else nHigh = c - '0'; c = pszSubfieldValue[2*i + 1]; if( c >= 'A' && c <= 'F' ) nLow = 10 + c - 'A'; else nLow = c - '0'; pabyData[i] = (nHigh << 4) + nLow; } poRec->SetStringSubfield( pszFieldName, nFieldOcc, pszSubfieldName, nOcc, pabyData, nDataLen ); free(pabyData); } } psSubfieldIter = psSubfieldIter->psNext; } } } psSubIter = psSubIter->psNext; } poRec->Write(); delete poRec; } psIter = psIter->psNext; } CPLDestroyXMLNode(poRoot); oModule.Close(); return 0; }
/** * LoadMetadata() */ void GDALMDReaderKompsat::LoadMetadata() { if(m_bIsMetadataLoad) return; if(!m_osIMDSourceFilename.empty()) { m_papszIMDMD = ReadTxtToList( ); } if(!m_osRPBSourceFilename.empty()) { m_papszRPCMD = GDALLoadRPCFile( m_osRPBSourceFilename ); } m_papszDEFAULTMD = CSLAddNameValue(m_papszDEFAULTMD, MD_NAME_MDTYPE, "KARI"); m_bIsMetadataLoad = true; const char* pszSatId1 = CSLFetchNameValue(m_papszIMDMD, "AUX_SATELLITE_NAME"); const char* pszSatId2 = CSLFetchNameValue(m_papszIMDMD, "AUX_SATELLITE_SENSOR"); if(nullptr != pszSatId1 && nullptr != pszSatId2) { m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_SATELLITE, CPLSPrintf( "%s %s", CPLStripQuotes(pszSatId1).c_str(), CPLStripQuotes(pszSatId2).c_str())); } else if(nullptr != pszSatId1 && nullptr == pszSatId2) { m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_SATELLITE, CPLStripQuotes(pszSatId1)); } else if(nullptr == pszSatId1 && nullptr != pszSatId2) { m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_SATELLITE, CPLStripQuotes(pszSatId2)); } const char* pszCloudCover = CSLFetchNameValue(m_papszIMDMD, "AUX_CLOUD_STATUS"); if(nullptr != pszCloudCover) { int nCC = atoi(pszCloudCover); if(nCC > 100 || nCC < 0) { m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER, MD_CLOUDCOVER_NA); } else { m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_CLOUDCOVER, CPLSPrintf("%d", nCC)); } } const char* pszDate = CSLFetchNameValue(m_papszIMDMD, "AUX_STRIP_ACQ_DATE_UT"); if(nullptr != pszDate) { const char* pszTime = CSLFetchNameValue(m_papszIMDMD, "AUX_STRIP_ACQ_START_UT"); if(nullptr == pszTime) pszTime = "000000.000000"; char buffer[80]; time_t timeMid = GetAcquisitionTimeFromString(CPLSPrintf( "%sT%s", pszDate, pszTime)); strftime (buffer, 80, MD_DATETIMEFORMAT, localtime(&timeMid)); m_papszIMAGERYMD = CSLAddNameValue(m_papszIMAGERYMD, MD_NAME_ACQDATETIME, buffer); } }
GDALDataset *CALSDataset::CreateCopy( const char *pszFilename, GDALDataset *poSrcDS, int bStrict, char ** /* papszOptionsUnused */, GDALProgressFunc pfnProgress, void *pProgressData ) { if( poSrcDS->GetRasterCount() == 0 || (bStrict && poSrcDS->GetRasterCount() != 1) ) { CPLError( CE_Failure, CPLE_NotSupported, "CALS driver only supports single band raster."); return NULL; } if( poSrcDS->GetRasterBand(1)->GetMetadataItem("NBITS", "IMAGE_STRUCTURE") == NULL || !EQUAL(poSrcDS->GetRasterBand(1)->GetMetadataItem("NBITS", "IMAGE_STRUCTURE"), "1") ) { CPLError( (bStrict) ? CE_Failure : CE_Warning, CPLE_NotSupported, "CALS driver only supports 1-bit."); if( bStrict ) return NULL; } if( poSrcDS->GetRasterXSize() > 999999 || poSrcDS->GetRasterYSize() > 999999 ) { CPLError( CE_Failure, CPLE_NotSupported, "CALS driver only supports datasets with dimension <= 999999."); return NULL; } GDALDriver* poGTiffDrv = (GDALDriver*)GDALGetDriverByName("GTiff"); if( poGTiffDrv == NULL ) { CPLError( CE_Failure, CPLE_NotSupported, "CALS driver needs GTiff driver."); return NULL; } /* Write a in-memory TIFF with just the TIFF header to figure out */ /* how large it will be */ CPLString osTmpFilename(CPLSPrintf("/vsimem/cals/tmp_%p", poSrcDS)); char** papszOptions = NULL; papszOptions = CSLSetNameValue(papszOptions, "COMPRESS", "CCITTFAX4"); papszOptions = CSLSetNameValue(papszOptions, "NBITS", "1"); papszOptions = CSLSetNameValue(papszOptions, "BLOCKYSIZE", CPLSPrintf("%d", poSrcDS->GetRasterYSize())); papszOptions = CSLSetNameValue(papszOptions, "SPARSE_OK", "YES"); GDALDataset* poDS = poGTiffDrv->Create(osTmpFilename, poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize(), 1, GDT_Byte, papszOptions); if( poDS == NULL ) { // Should not happen normally (except if CCITTFAX4 not available) CSLDestroy(papszOptions); return NULL; } const char INITIAL_PADDING[] = "12345"; poDS->SetMetadataItem("TIFFTAG_DOCUMENTNAME", INITIAL_PADDING); // to adjust padding GDALClose(poDS); VSIStatBufL sStat; if( VSIStatL(osTmpFilename, &sStat) != 0 ) { // Shoudln't happen really... Just to make Coverity happy CSLDestroy(papszOptions); return NULL; } int nTIFFHeaderSize = static_cast<int>(sStat.st_size); VSIUnlink(osTmpFilename); /* Redo the same thing, but this time write it to the output file */ /* and use a variable TIFF tag (TIFFTAG_DOCUMENTNAME) to enlarge the */ /* header + the variable TIFF tag so that they are 2048 bytes large */ char szBuffer[2048+1]; szBuffer[2048] = 0; memset(szBuffer, 'X', 2048 - nTIFFHeaderSize + strlen(INITIAL_PADDING)); szBuffer[2048 - nTIFFHeaderSize + strlen(INITIAL_PADDING)] = 0; GDALDataset* poTmpDS = new CALSWrapperSrcDataset(poSrcDS, szBuffer); poDS = poGTiffDrv->CreateCopy(pszFilename, poTmpDS, FALSE, papszOptions, pfnProgress, pProgressData ); delete poTmpDS; CSLDestroy(papszOptions); if( poDS == NULL ) return NULL; delete poDS; // Now replace the TIFF header by the CALS header ! VSILFILE* fp = VSIFOpenL(pszFilename, "rb+"); if( fp == NULL ) return NULL; // Shoudln't happen normally memset(szBuffer, ' ', 2048); CPLString osField; osField = "srcdocid: NONE"; memcpy(szBuffer, osField, osField.size()); osField = "dstdocid: NONE"; memcpy(szBuffer + 128, osField, osField.size()); osField = "txtfilid: NONE"; memcpy(szBuffer + 128*2, osField, osField.size()); osField = "figid: NONE"; memcpy(szBuffer + 128*3, osField, osField.size()); osField = "srcgph: NONE"; memcpy(szBuffer + 128*4, osField, osField.size()); osField = "doccls: NONE"; memcpy(szBuffer + 128*5, osField, osField.size()); osField = "rtype: 1"; memcpy(szBuffer + 128*6, osField, osField.size()); int nAngle1 = 0, nAngle2 = 270; const char* pszPixelPath = poSrcDS->GetMetadataItem("PIXEL_PATH"); const char* pszLineProgression = poSrcDS->GetMetadataItem("LINE_PROGRESSION"); if( pszPixelPath && pszLineProgression ) { nAngle1 = atoi(pszPixelPath); nAngle2 = atoi(pszLineProgression); } osField = CPLSPrintf("rorient: %03d,%03d", nAngle1, nAngle2); memcpy(szBuffer + 128*7, osField, osField.size()); osField = CPLSPrintf("rpelcnt: %06d,%06d", poSrcDS->GetRasterXSize(), poSrcDS->GetRasterYSize()); memcpy(szBuffer + 128*8, osField, osField.size()); int nDensity = 200; const char* pszXRes = poSrcDS->GetMetadataItem("TIFFTAG_XRESOLUTION"); const char* pszYRes = poSrcDS->GetMetadataItem("TIFFTAG_YRESOLUTION"); const char* pszResUnit = poSrcDS->GetMetadataItem("TIFFTAG_RESOLUTIONUNIT"); if( pszXRes && pszYRes && pszResUnit && EQUAL(pszXRes, pszYRes) && atoi(pszResUnit) == 2 ) { nDensity = atoi(pszXRes); if( nDensity < 1 || nDensity > 9999 ) nDensity = 200; } osField = CPLSPrintf("rdensty: %04d", nDensity); memcpy(szBuffer + 128*9, osField, osField.size()); osField = "notes: NONE"; memcpy(szBuffer + 128*10, osField, osField.size()); VSIFWriteL(szBuffer, 1, 2048, fp); VSIFCloseL(fp); GDALOpenInfo oOpenInfo(pszFilename, GA_ReadOnly, NULL); return Open(&oOpenInfo); }
int OGROpenFileGDBDataSource::Open( const char* pszFilename ) { FileGDBTable oTable; m_pszName = CPLStrdup(pszFilename); m_osDirName = pszFilename; int nInterestTable = -1; const char* pszFilenameWithoutPath = CPLGetFilename(pszFilename); if( strlen(pszFilenameWithoutPath) == strlen("a00000000.gdbtable") && pszFilenameWithoutPath[0] == 'a' && sscanf(pszFilenameWithoutPath, "a%08x.gdbtable", &nInterestTable) == 1 ) { m_osDirName = CPLGetPath(m_osDirName); } else { nInterestTable = -1; } if( EQUAL(CPLGetExtension(m_osDirName), "zip") && strncmp(m_osDirName, "/vsizip/", strlen("/vsizip/")) != 0 ) { m_osDirName = "/vsizip/" + m_osDirName; } else if( EQUAL(CPLGetExtension(m_osDirName), "tar") && strncmp(m_osDirName, "/vsitar/", strlen("/vsitar/")) != 0 ) { m_osDirName = "/vsitar/" + m_osDirName; } if( strncmp(m_osDirName, "/vsizip/", strlen("/vsizip/")) == 0 || strncmp(m_osDirName, "/vsitar/", strlen("/vsitar/")) == 0) { /* Look for one subdirectory ending with .gdb extension */ char** papszDir = CPLReadDir(m_osDirName); int iCandidate = -1; for( int i=0; papszDir && papszDir[i] != NULL; i++ ) { VSIStatBufL sStat; if( EQUAL(CPLGetExtension(papszDir[i]), "gdb") && VSIStatL( CPLSPrintf("%s/%s", m_osDirName.c_str(), papszDir[i]), &sStat ) == 0 && VSI_ISDIR(sStat.st_mode) ) { if( iCandidate < 0 ) iCandidate = i; else { iCandidate = -1; break; } } } if( iCandidate >= 0 ) { m_osDirName += "/"; m_osDirName += papszDir[iCandidate]; } CSLDestroy(papszDir); } m_papszFiles = VSIReadDir(m_osDirName); /* Explore catalog table */ const char* psza00000001 = CPLFormFilename(m_osDirName, "a00000001", "gdbtable"); if( !FileExists(psza00000001) || !oTable.Open(psza00000001) ) { if( nInterestTable >= 0 && FileExists(m_pszName) ) { const char* pszLyrName = CPLSPrintf("a%08x", nInterestTable); OGROpenFileGDBLayer* poLayer = new OGROpenFileGDBLayer( m_pszName, pszLyrName, "", ""); const char* pszTablX = CPLResetExtension(m_pszName, "gdbtablx"); if( (!FileExists(pszTablX) && poLayer->GetLayerDefn()->GetFieldCount() == 0 && poLayer->GetFeatureCount() == 0) || !poLayer->IsValidLayerDefn() ) { delete poLayer; return FALSE; } m_apoLayers.push_back(poLayer); return TRUE; } return FALSE; } if( !(oTable.GetFieldCount() >= 2 && oTable.GetField(0)->GetName() == "Name" && oTable.GetField(0)->GetType() == FGFT_STRING && oTable.GetField(1)->GetName() == "FileFormat" && (oTable.GetField(1)->GetType() == FGFT_INT16 || oTable.GetField(1)->GetType() == FGFT_INT32) ) ) { return FALSE; } int iGDBItems = -1; /* V10 */ int iGDBFeatureClasses = -1; /* V9.X */ int iGDBObjectClasses = -1; /* V9.X */ int i; std::vector<std::string> aosTableNames; for(i=0;i<oTable.GetTotalRecordCount();i++) { if( !oTable.SelectRow(i) ) { if( oTable.HasGotError() ) break; aosTableNames.push_back(""); continue; } const OGRField* psField = oTable.GetFieldValue(0); if( psField != NULL ) { aosTableNames.push_back(psField->String); if( strcmp(psField->String, "GDB_Items") == 0 ) { iGDBItems = i; } else if( strcmp(psField->String, "GDB_FeatureClasses") == 0 ) { iGDBFeatureClasses = i; } else if( strcmp(psField->String, "GDB_ObjectClasses") == 0 ) { iGDBObjectClasses = i; } m_osMapNameToIdx[psField->String] = 1 + i; } else { aosTableNames.push_back(""); } } oTable.Close(); if( iGDBItems >= 0 ) { int bRet = OpenFileGDBv10(iGDBItems, nInterestTable); if( !bRet ) return FALSE; } else if( iGDBFeatureClasses >= 0 && iGDBObjectClasses >= 0 ) { int bRet = OpenFileGDBv9(iGDBFeatureClasses, iGDBObjectClasses, nInterestTable); if( !bRet ) return FALSE; } else { CPLError(CE_Failure, CPLE_AppDefined, "No GDB_Items nor GDB_FeatureClasses table"); return FALSE; } if( m_apoLayers.size() == 0 && nInterestTable >= 0 ) { if( FileExists(m_pszName) ) { const char* pszLyrName; if( nInterestTable <= (int)aosTableNames.size() && aosTableNames[nInterestTable-1].size() != 0 ) pszLyrName = aosTableNames[nInterestTable-1].c_str(); else pszLyrName = CPLSPrintf("a%08x", nInterestTable); m_apoLayers.push_back(new OGROpenFileGDBLayer( m_pszName, pszLyrName, "", "")); } else { return FALSE; } } return TRUE; }
CPLErr OGRSQLiteViewLayer::Initialize( const char *pszViewName, const char *pszViewGeometry, const char *pszViewRowid, const char *pszUnderlyingTableName, const char *pszUnderlyingGeometryColumn, int bSpatialiteLoaded) { int rc; sqlite3 *hDB = poDS->GetDB(); OGRSQLiteLayer* poUnderlyingLayer = (OGRSQLiteLayer*) poDS->GetLayerByName(pszUnderlyingTableName); if (poUnderlyingLayer == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find underlying layer %s for view %s", pszUnderlyingTableName, pszViewName); return CE_Failure; } if ( !poUnderlyingLayer->IsTableLayer() ) { CPLError(CE_Failure, CPLE_AppDefined, "Underlying layer %s for view %s is not a regular table", pszUnderlyingTableName, pszViewName); return CE_Failure; } const char* pszRealUnderlyingGeometryColumn = poUnderlyingLayer->GetGeometryColumn(); if ( pszRealUnderlyingGeometryColumn == NULL || !EQUAL(pszRealUnderlyingGeometryColumn, pszUnderlyingGeometryColumn) ) { CPLError(CE_Failure, CPLE_AppDefined, "Underlying layer %s for view %s has not expected geometry column name (%s instead of %s)", pszUnderlyingTableName, pszViewName, pszRealUnderlyingGeometryColumn ? pszRealUnderlyingGeometryColumn : "(null)", pszUnderlyingGeometryColumn); return CE_Failure; } osGeomColumn = pszViewGeometry; eGeomFormat = OSGF_SpatiaLite; CPLFree( pszFIDColumn ); pszFIDColumn = CPLStrdup( pszViewRowid ); osUnderlyingTableName = pszUnderlyingTableName; osUnderlyingGeometryColumn = pszUnderlyingGeometryColumn; poSRS = poUnderlyingLayer->GetSpatialRef(); if (poSRS) poSRS->Reference(); this->bHasSpatialIndex = poUnderlyingLayer->HasSpatialIndex(); this->bSpatialiteLoaded = bSpatialiteLoaded; //this->bHasM = bHasM; pszEscapedTableName = CPLStrdup(OGRSQLiteEscape(pszViewName)); pszEscapedUnderlyingTableName = CPLStrdup(OGRSQLiteEscape(pszUnderlyingTableName)); CPLErr eErr; sqlite3_stmt *hColStmt = NULL; const char *pszSQL; /* -------------------------------------------------------------------- */ /* Get the column definitions for this table. */ /* -------------------------------------------------------------------- */ hColStmt = NULL; pszSQL = CPLSPrintf( "SELECT %s, * FROM '%s' LIMIT 1", pszFIDColumn, pszEscapedTableName ); rc = sqlite3_prepare( hDB, pszSQL, strlen(pszSQL), &hColStmt, NULL ); if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "Unable to query table %s for column definitions : %s.", pszViewName, sqlite3_errmsg(hDB) ); return CE_Failure; } rc = sqlite3_step( hColStmt ); if ( rc != SQLITE_DONE && rc != SQLITE_ROW ) { CPLError( CE_Failure, CPLE_AppDefined, "In Initialize(): sqlite3_step(%s):\n %s", pszSQL, sqlite3_errmsg(hDB) ); sqlite3_finalize( hColStmt ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Collect the rest of the fields. */ /* -------------------------------------------------------------------- */ eErr = BuildFeatureDefn( pszViewName, hColStmt ); sqlite3_finalize( hColStmt ); if( eErr != CE_None ) return eErr; /* -------------------------------------------------------------------- */ /* Set the geometry type if we know it. */ /* -------------------------------------------------------------------- */ poFeatureDefn->SetGeomType( poUnderlyingLayer->GetGeomType() ); return CE_None; }
OGRFeature *OGRGFTLayer::BuildFeatureFromSQL(const char* pszLine) { OGRFeature* poFeature = new OGRFeature(poFeatureDefn); char** papszTokens = OGRGFTCSVSplitLine(pszLine, ','); int nTokens = CSLCount(papszTokens); CPLString osFID; int nAttrOffset = 0; int iROWID = -1; if (bFirstTokenIsFID) { osFID = papszTokens[0]; nAttrOffset = 1; } else { iROWID = poFeatureDefn->GetFieldIndex("rowid"); if (iROWID < 0) iROWID = poFeatureDefn->GetFieldIndex("ROWID"); } int nFieldCount = poFeatureDefn->GetFieldCount(); if (nTokens == nFieldCount + bHiddenGeometryField + nAttrOffset) { for(int i=0;i<nFieldCount+bHiddenGeometryField;i++) { const char* pszVal = papszTokens[i+nAttrOffset]; if (pszVal[0]) { if (i<nFieldCount) poFeature->SetField(i, pszVal); if (i == iGeometryField && i != iLatitudeField) { if (pszVal[0] == '-' || (pszVal[0] >= '0' && pszVal[0] <= '9')) { char** papszLatLon = CSLTokenizeString2(pszVal, " ,", 0); if (CSLCount(papszLatLon) == 2 && CPLGetValueType(papszLatLon[0]) != CPL_VALUE_STRING && CPLGetValueType(papszLatLon[1]) != CPL_VALUE_STRING) { OGRPoint* poPoint = new OGRPoint(atof( papszLatLon[1]), atof( papszLatLon[0])); poPoint->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoint); } CSLDestroy(papszLatLon); } else if (strstr(pszVal, "<Point>") || strstr(pszVal, "<LineString>") || strstr(pszVal, "<Polygon>")) { OGRGeometry* poGeom = ParseKMLGeometry(pszVal); if (poGeom) { poGeom->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poGeom); } } } else if (i == iROWID) { osFID = pszVal; } } } if (iLatitudeField >= 0 && iLongitudeField >= 0) { const char* pszLat = papszTokens[iLatitudeField+nAttrOffset]; const char* pszLong = papszTokens[iLongitudeField+nAttrOffset]; if (pszLat[0] != 0 && pszLong[0] != 0 && CPLGetValueType(pszLat) != CPL_VALUE_STRING && CPLGetValueType(pszLong) != CPL_VALUE_STRING) { OGRPoint* poPoint = new OGRPoint(atof(pszLong), atof(pszLat)); poPoint->assignSpatialReference(poSRS); poFeature->SetGeometryDirectly(poPoint); } } } else { CPLDebug("GFT", "Only %d columns for feature %s", nTokens, osFID.c_str()); } CSLDestroy(papszTokens); int nFID = atoi(osFID); if (strcmp(CPLSPrintf("%d", nFID), osFID.c_str()) == 0) poFeature->SetFID(nFID); else poFeature->SetFID(nNextInSeq); return poFeature; }
int OGROpenFileGDBDataSource::OpenFileGDBv10(int iGDBItems, int nInterestTable) { FileGDBTable oTable; int i; CPLDebug("OpenFileGDB", "FileGDB v10 or later"); if( !oTable.Open(CPLFormFilename(m_osDirName, CPLSPrintf("a%08x.gdbtable", iGDBItems + 1), NULL)) ) return FALSE; int iName = oTable.GetFieldIdx("Name"); int iDefinition = oTable.GetFieldIdx("Definition"); int iDocumentation = oTable.GetFieldIdx("Documentation"); if( iName < 0 || iDefinition < 0 || iDocumentation < 0 || oTable.GetField(iName)->GetType() != FGFT_STRING || oTable.GetField(iDefinition)->GetType() != FGFT_XML || oTable.GetField(iDocumentation)->GetType() != FGFT_XML ) { CPLError(CE_Failure, CPLE_AppDefined, "Wrong structure for GDB_Items table"); return FALSE; } int nCandidateLayers = 0, nLayersSDC = 0; for(i=0;i<oTable.GetTotalRecordCount();i++) { if( !oTable.SelectRow(i) ) { if( oTable.HasGotError() ) break; continue; } const OGRField* psField = oTable.GetFieldValue(iDefinition); if( psField != NULL && (strstr(psField->String, "DEFeatureClassInfo") != NULL || strstr(psField->String, "DETableInfo") != NULL) ) { CPLString osDefinition(psField->String); psField = oTable.GetFieldValue(iDocumentation); CPLString osDocumentation( psField != NULL ? psField->String : "" ); psField = oTable.GetFieldValue(iName); if( psField != NULL ) { AddLayer( psField->String, nInterestTable, nCandidateLayers, nLayersSDC, osDefinition, osDocumentation, NULL, wkbUnknown ); } } } if( m_apoLayers.size() == 0 && nCandidateLayers > 0 && nCandidateLayers == nLayersSDC ) return FALSE; return TRUE; }
CPLXMLNode *WCTSCollectKVPRequest() { char **papszParmList; /* -------------------------------------------------------------------- */ /* Parse the query string. */ /* -------------------------------------------------------------------- */ if( getenv("QUERY_STRING") == NULL ) WCTSEmitServiceException( "QUERY_STRING not set." ); papszParmList = CSLTokenizeString2( getenv("QUERY_STRING"), "&", CSLT_PRESERVEESCAPES ); /* -------------------------------------------------------------------- */ /* Un-url-encode the items. */ /* -------------------------------------------------------------------- */ int i; for( i = 0; papszParmList != NULL && papszParmList[i] != NULL; i++ ) { char *pszNewValue = CPLUnescapeString( papszParmList[i], NULL, CPLES_URL ); CPLFree( papszParmList[i] ); papszParmList[i] = pszNewValue; } /* -------------------------------------------------------------------- */ /* Check for REQUEST */ /* -------------------------------------------------------------------- */ const char *pszVersion = CSLFetchNameValue(papszParmList,"VERSION"); const char *pszRequest = CSLFetchNameValue(papszParmList,"REQUEST"); if( pszRequest == NULL ) WCTSEmitServiceException( "REQUEST not provided in KVP URL." ); /* -------------------------------------------------------------------- */ /* Handle GetCapabilities */ /* -------------------------------------------------------------------- */ else if( EQUAL(pszRequest,"GetCapabilities") ) { CPLXMLNode *psRequest = CPLCreateXMLNode( NULL, CXT_Element, "GetCapabilities" ); if( pszVersion != NULL ) { CPLCreateXMLNode( CPLCreateXMLNode( psRequest, CXT_Attribute, "version" ), CXT_Text, pszVersion ); } if( CSLFetchNameValue(papszParmList,"SERVICE") != NULL ) { CPLCreateXMLNode( CPLCreateXMLNode( psRequest, CXT_Attribute, "service" ), CXT_Text, CSLFetchNameValue(papszParmList,"SERVICE") ); } return psRequest; } /* ==================================================================== */ /* Handle IsTransformable */ /* ==================================================================== */ else if( EQUAL(pszRequest,"IsTransformable") ) { CPLXMLNode *psRequest = CPLCreateXMLNode( NULL, CXT_Element, "IsTransformable" ); /* -------------------------------------------------------------------- */ /* Translate the source crs. */ /* -------------------------------------------------------------------- */ CPLAddXMLChild( CPLCreateXMLNode( psRequest, CXT_Element, "SourceCRS" ), WCTSAuthId2crsId( papszParmList, "SOURCECRS" ) ); /* -------------------------------------------------------------------- */ /* Translate the destination crs. */ /* -------------------------------------------------------------------- */ CPLAddXMLChild( CPLCreateXMLNode( psRequest, CXT_Element, "TargetCRS" ), WCTSAuthId2crsId( papszParmList, "TARGETCRS" ) ); /* -------------------------------------------------------------------- */ /* Handle version. */ /* -------------------------------------------------------------------- */ if( pszVersion != NULL ) { CPLCreateXMLNode( CPLCreateXMLNode( psRequest, CXT_Attribute, "version" ), CXT_Text, pszVersion ); } /* -------------------------------------------------------------------- */ /* geometric primitive. */ /* -------------------------------------------------------------------- */ if( CSLFetchNameValue(papszParmList,"GEOMETRICPRIMITIVE") != NULL ) { CPLCreateXMLElementAndValue( psRequest, "GeometricPrimitive", CSLFetchNameValue(papszParmList,"GEOMETRICPRIMITIVE") ); } /* Add COVERAGETYPE and COVERAGEINTERPOLATIONMETHOD layer? */ return psRequest; } /* -------------------------------------------------------------------- */ /* Unrecognised. */ /* -------------------------------------------------------------------- */ else WCTSEmitServiceException( CPLSPrintf( "Unrecognised REQUEST value (%.500s).", pszRequest) ); return NULL; }
OGRSpatialReference * WCTSImportCoordinateReferenceSystem( CPLXMLNode *psXMLCRS ) { CPLStripXMLNamespace( psXMLCRS->psChild, NULL, TRUE ); /* ==================================================================== */ /* Try to find a direct crsID as per old specification. */ /* ==================================================================== */ const char *pszCode = CPLGetXMLValue( psXMLCRS, "crsID.code", NULL ); const char *pszCodeSpace = CPLGetXMLValue( psXMLCRS, "crsID.codeSpace", NULL ); if( pszCode != NULL && pszCodeSpace != NULL ) { /* -------------------------------------------------------------------- */ /* Get the EPSG code, and verify that it is in the EPSG */ /* codeSpace. */ /* -------------------------------------------------------------------- */ OGRSpatialReference oSRS; if( EQUAL(pszCodeSpace,"EPSG") ) { int nEPSGCode = atoi(pszCode); if( nEPSGCode == 0 ) { WCTSEmitServiceException( "Failed to decode CoordinateReferenceSystem with missing,\n" "or zero crsID.code" ); } CPLErrorReset(); if( oSRS.importFromEPSG( nEPSGCode ) != OGRERR_NONE ) { if( strlen(CPLGetLastErrorMsg()) > 0 ) WCTSEmitServiceException( CPLGetLastErrorMsg() ); else WCTSEmitServiceException( CPLSPrintf( "OGRSpatialReference::importFromEPSG(%d) " "failed. Is this a defined EPSG code?", nEPSGCode ) ); } } /* -------------------------------------------------------------------- */ /* Handle AUTO case. */ /* -------------------------------------------------------------------- */ else if( EQUAL(pszCodeSpace,"AUTO") ) { if( oSRS.importFromWMSAUTO( pszCode ) != OGRERR_NONE ) { if( strlen(CPLGetLastErrorMsg()) > 0 ) WCTSEmitServiceException( CPLGetLastErrorMsg() ); else WCTSEmitServiceException( CPLSPrintf( "OGRSpatialReference::importFromWMSAUTO(%s) " "failed. Is this a defined EPSG code?", pszCode ) ); } } /* -------------------------------------------------------------------- */ /* Otherwise blow a gasket. */ /* -------------------------------------------------------------------- */ else { WCTSEmitServiceException( "Failed to decode CoordinateReferenceSystem with missing,\n" "or non-EPSG crsID.codeSpace" ); } /* -------------------------------------------------------------------- */ /* Translate into an OGRSpatialReference from EPSG code. */ /* -------------------------------------------------------------------- */ return oSRS.Clone(); } /* ==================================================================== */ /* Try to import a projectedCRS or geographicCRS. */ /* ==================================================================== */ if( CPLGetXMLNode( psXMLCRS, "ProjectedCRS" ) != NULL || CPLGetXMLNode( psXMLCRS, "GeographicCRS" ) != NULL ) { #ifdef DISABLE_USER_DEFINED_CRS WCTSEmitServiceException( "User defined ProjectedCRS and GeographicCRS support\n" "disabled for security reasons." ); #else char *pszSerializedForm; OGRSpatialReference oSRS; pszSerializedForm = CPLSerializeXMLTree( psXMLCRS->psChild ); if( oSRS.importFromXML( pszSerializedForm ) != OGRERR_NONE ) { CPLFree( pszSerializedForm ); if( strlen(CPLGetLastErrorMsg()) > 0 ) WCTSEmitServiceException( CPLGetLastErrorMsg() ); else WCTSEmitServiceException( "Failed to import CRS" ); } CPLFree( pszSerializedForm ); return oSRS.Clone(); #endif } /* -------------------------------------------------------------------- */ /* We don't seem to recognise a CRS here. */ /* -------------------------------------------------------------------- */ WCTSEmitServiceException( "Unable to identify CRS in one of SourceCRS or TargetCRS elements" ); return NULL; }
CPLString swq_expr_node::UnparseOperationFromUnparsedSubExpr(char** apszSubExpr) { CPLString osExpr; /* -------------------------------------------------------------------- */ /* Put things together in a fashion depending on the operator. */ /* -------------------------------------------------------------------- */ const swq_operation *poOp = swq_op_registrar::GetOperator( static_cast<swq_op>(nOperation) ); if( poOp == nullptr && nOperation != SWQ_CUSTOM_FUNC ) { CPLAssert( false ); return osExpr; } switch( nOperation ) { // Binary infix operators. case SWQ_OR: case SWQ_AND: case SWQ_EQ: case SWQ_NE: case SWQ_GT: case SWQ_LT: case SWQ_GE: case SWQ_LE: case SWQ_LIKE: case SWQ_ADD: case SWQ_SUBTRACT: case SWQ_MULTIPLY: case SWQ_DIVIDE: case SWQ_MODULUS: CPLAssert( nSubExprCount >= 2 ); if( papoSubExpr[0]->eNodeType == SNT_COLUMN || papoSubExpr[0]->eNodeType == SNT_CONSTANT ) { osExpr += apszSubExpr[0]; } else { osExpr += "("; osExpr += apszSubExpr[0]; osExpr += ")"; } osExpr += " "; osExpr += poOp->pszName; osExpr += " "; if( papoSubExpr[1]->eNodeType == SNT_COLUMN || papoSubExpr[1]->eNodeType == SNT_CONSTANT ) { osExpr += apszSubExpr[1]; } else { osExpr += "("; osExpr += apszSubExpr[1]; osExpr += ")"; } if( nOperation == SWQ_LIKE && nSubExprCount == 3 ) osExpr += CPLSPrintf( " ESCAPE (%s)", apszSubExpr[2] ); break; case SWQ_NOT: CPLAssert( nSubExprCount == 1 ); osExpr.Printf( "NOT (%s)", apszSubExpr[0] ); break; case SWQ_ISNULL: CPLAssert( nSubExprCount == 1 ); osExpr.Printf( "%s IS NULL", apszSubExpr[0] ); break; case SWQ_IN: osExpr.Printf( "%s IN (", apszSubExpr[0] ); for( int i = 1; i < nSubExprCount; i++ ) { if( i > 1 ) osExpr += ","; osExpr += "("; osExpr += apszSubExpr[i]; osExpr += ")"; } osExpr += ")"; break; case SWQ_BETWEEN: CPLAssert( nSubExprCount == 3 ); osExpr.Printf( "%s %s (%s) AND (%s)", apszSubExpr[0], poOp->pszName, apszSubExpr[1], apszSubExpr[2] ); break; case SWQ_CAST: osExpr = "CAST("; for( int i = 0; i < nSubExprCount; i++ ) { if( i == 1 ) osExpr += " AS "; else if( i > 2 ) osExpr += ", "; const int nLen = static_cast<int>(strlen(apszSubExpr[i])); if( (i == 1 && (apszSubExpr[i][0] == '\'' && nLen > 2 && apszSubExpr[i][nLen-1] == '\'')) || (i == 2 && EQUAL(apszSubExpr[1], "'GEOMETRY")) ) { apszSubExpr[i][nLen-1] = '\0'; osExpr += apszSubExpr[i] + 1; } else osExpr += apszSubExpr[i]; if( i == 1 && nSubExprCount > 2) osExpr += "("; else if( i > 1 && i == nSubExprCount - 1 ) osExpr += ")"; } osExpr += ")"; break; default: // function style. if( nOperation != SWQ_CUSTOM_FUNC ) osExpr.Printf( "%s(", poOp->pszName ); else osExpr.Printf( "%s(", string_value ); for( int i = 0; i < nSubExprCount; i++ ) { if( i > 0 ) osExpr += ","; osExpr += "("; osExpr += apszSubExpr[i]; osExpr += ")"; } osExpr += ")"; break; } return osExpr; }
GDALDataset *DTEDDataset::Open( GDALOpenInfo * poOpenInfo ) { if (!Identify(poOpenInfo) || poOpenInfo->fpL == nullptr ) return nullptr; /* -------------------------------------------------------------------- */ /* Try opening the dataset. */ /* -------------------------------------------------------------------- */ VSILFILE* fp = poOpenInfo->fpL; poOpenInfo->fpL = nullptr; DTEDInfo *psDTED = DTEDOpenEx( fp, poOpenInfo->pszFilename, (poOpenInfo->eAccess == GA_Update) ? "rb+" : "rb", TRUE ); if( psDTED == nullptr ) return nullptr; /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ DTEDDataset *poDS = new DTEDDataset(); poDS->SetFileName(poOpenInfo->pszFilename); poDS->eAccess = poOpenInfo->eAccess; poDS->psDTED = psDTED; /* -------------------------------------------------------------------- */ /* Capture some information from the file that is of interest. */ /* -------------------------------------------------------------------- */ poDS->nRasterXSize = psDTED->nXSize; poDS->nRasterYSize = psDTED->nYSize; if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize)) { delete poDS; return nullptr; } /* -------------------------------------------------------------------- */ /* Create band information objects. */ /* -------------------------------------------------------------------- */ poDS->nBands = 1; for( int i = 0; i < poDS->nBands; i++ ) poDS->SetBand( i+1, new DTEDRasterBand( poDS, i+1 ) ); /* -------------------------------------------------------------------- */ /* Collect any metadata available. */ /* -------------------------------------------------------------------- */ char *pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTACCURACY_UHL ); poDS->SetMetadataItem( "DTED_VerticalAccuracy_UHL", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTACCURACY_ACC ); poDS->SetMetadataItem( "DTED_VerticalAccuracy_ACC", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_SECURITYCODE_UHL ); poDS->SetMetadataItem( "DTED_SecurityCode_UHL", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_SECURITYCODE_DSI ); poDS->SetMetadataItem( "DTED_SecurityCode_DSI", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_UNIQUEREF_UHL ); poDS->SetMetadataItem( "DTED_UniqueRef_UHL", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_UNIQUEREF_DSI ); poDS->SetMetadataItem( "DTED_UniqueRef_DSI", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_DATA_EDITION ); poDS->SetMetadataItem( "DTED_DataEdition", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_MATCHMERGE_VERSION ); poDS->SetMetadataItem( "DTED_MatchMergeVersion", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_MAINT_DATE ); poDS->SetMetadataItem( "DTED_MaintenanceDate", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_MATCHMERGE_DATE ); poDS->SetMetadataItem( "DTED_MatchMergeDate", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_MAINT_DESCRIPTION ); poDS->SetMetadataItem( "DTED_MaintenanceDescription", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_PRODUCER ); poDS->SetMetadataItem( "DTED_Producer", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_VERTDATUM ); poDS->SetMetadataItem( "DTED_VerticalDatum", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_HORIZDATUM ); poDS->SetMetadataItem( "DTED_HorizontalDatum", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_DIGITIZING_SYS ); poDS->SetMetadataItem( "DTED_DigitizingSystem", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_COMPILATION_DATE ); poDS->SetMetadataItem( "DTED_CompilationDate", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_HORIZACCURACY ); poDS->SetMetadataItem( "DTED_HorizontalAccuracy", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_REL_HORIZACCURACY ); poDS->SetMetadataItem( "DTED_RelHorizontalAccuracy", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_REL_VERTACCURACY ); poDS->SetMetadataItem( "DTED_RelVerticalAccuracy", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_ORIGINLAT ); poDS->SetMetadataItem( "DTED_OriginLatitude", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_ORIGINLONG ); poDS->SetMetadataItem( "DTED_OriginLongitude", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_NIMA_DESIGNATOR ); poDS->SetMetadataItem( "DTED_NimaDesignator", pszValue ); CPLFree( pszValue ); pszValue = DTEDGetMetadata( psDTED, DTEDMD_PARTIALCELL_DSI ); poDS->SetMetadataItem( "DTED_PartialCellIndicator", pszValue ); CPLFree( pszValue ); poDS->SetMetadataItem( GDALMD_AREA_OR_POINT, GDALMD_AOP_POINT ); /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML( poOpenInfo->GetSiblingFiles() ); // if no SR in xml, try aux const char* pszPrj = poDS->GDALPamDataset::_GetProjectionRef(); if( !pszPrj || strlen(pszPrj) == 0 ) { int bTryAux = TRUE; if( poOpenInfo->GetSiblingFiles() != nullptr && CSLFindString(poOpenInfo->GetSiblingFiles(), CPLResetExtension(CPLGetFilename(poOpenInfo->pszFilename), "aux")) < 0 && CSLFindString(poOpenInfo->GetSiblingFiles(), CPLSPrintf("%s.aux", CPLGetFilename(poOpenInfo->pszFilename))) < 0 ) bTryAux = FALSE; if( bTryAux ) { GDALDataset* poAuxDS = GDALFindAssociatedAuxFile( poOpenInfo->pszFilename, GA_ReadOnly, poDS ); if( poAuxDS ) { pszPrj = poAuxDS->GetProjectionRef(); if( pszPrj && strlen(pszPrj) > 0 ) { CPLFree( poDS->pszProjection ); poDS->pszProjection = CPLStrdup(pszPrj); } GDALClose( poAuxDS ); } } } /* -------------------------------------------------------------------- */ /* Support overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename, poOpenInfo->GetSiblingFiles() ); return poDS; }
char *swq_expr_node::Unparse( swq_field_list *field_list, char chColumnQuote ) { CPLString osExpr; /* -------------------------------------------------------------------- */ /* Handle constants. */ /* -------------------------------------------------------------------- */ if( eNodeType == SNT_CONSTANT ) { if( is_null ) return CPLStrdup("NULL"); if( field_type == SWQ_INTEGER || field_type == SWQ_INTEGER64 || field_type == SWQ_BOOLEAN ) osExpr.Printf( CPL_FRMT_GIB, int_value ); else if( field_type == SWQ_FLOAT ) { osExpr.Printf( "%.15g", float_value ); // Make sure this is interpreted as a floating point value // and not as an integer later. if( strchr(osExpr, '.') == nullptr && strchr(osExpr, 'e') == nullptr && strchr(osExpr, 'E') == nullptr ) osExpr += '.'; } else { osExpr = Quote( string_value ); } return CPLStrdup(osExpr); } /* -------------------------------------------------------------------- */ /* Handle columns. */ /* -------------------------------------------------------------------- */ if( eNodeType == SNT_COLUMN ) { if( field_list == nullptr ) { if( table_name ) osExpr.Printf( "%s.%s", QuoteIfNecessary(table_name, chColumnQuote).c_str(), QuoteIfNecessary(string_value, chColumnQuote).c_str() ); else osExpr.Printf( "%s", QuoteIfNecessary(string_value, chColumnQuote).c_str() ); } else if( field_index != -1 && table_index < field_list->table_count && table_index > 0 ) { // We deliberately browse through the list starting from the end // This is for the case where the FID column exists both as // FID and then real_fid_name. We want real_fid_name to be used for( int i = field_list->count - 1; i >= 0; i-- ) { if( field_list->table_ids[i] == table_index && field_list->ids[i] == field_index ) { osExpr.Printf( "%s.%s", QuoteIfNecessary(field_list->table_defs[table_index].table_name, chColumnQuote).c_str(), QuoteIfNecessary(field_list->names[i], chColumnQuote).c_str() ); break; } } } else if( field_index != -1 ) { // We deliberately browse through the list starting from the end // This is for the case where the FID column exists both as // FID and then real_fid_name. We want real_fid_name to be used for( int i = field_list->count - 1; i >= 0; i-- ) { if( field_list->table_ids[i] == table_index && field_list->ids[i] == field_index ) { osExpr.Printf( "%s", QuoteIfNecessary(field_list->names[i], chColumnQuote).c_str() ); break; } } } if( osExpr.empty() ) { return CPLStrdup(CPLSPrintf("%c%c", chColumnQuote, chColumnQuote)); } // The string is just alphanum and not a reserved SQL keyword, // no needs to quote and escape. return CPLStrdup(osExpr.c_str()); } /* -------------------------------------------------------------------- */ /* Operation - start by unparsing all the subexpressions. */ /* -------------------------------------------------------------------- */ std::vector<char*> apszSubExpr; for( int i = 0; i < nSubExprCount; i++ ) apszSubExpr.push_back( papoSubExpr[i]->Unparse(field_list, chColumnQuote) ); osExpr = UnparseOperationFromUnparsedSubExpr(&apszSubExpr[0]); /* -------------------------------------------------------------------- */ /* cleanup subexpressions. */ /* -------------------------------------------------------------------- */ for( int i = 0; i < nSubExprCount; i++ ) CPLFree( apszSubExpr[i] ); return CPLStrdup( osExpr.c_str() ); }
CPLString OGRSQLiteViewLayer::GetSpatialWhere(int iGeomCol, OGRGeometry* poFilterGeom) { if (HasLayerDefnError() || poFeatureDefn == NULL || iGeomCol < 0 || iGeomCol >= poFeatureDefn->GetGeomFieldCount()) return ""; if( poFilterGeom != NULL && bHasSpatialIndex ) { OGREnvelope sEnvelope; poFilterGeom->getEnvelope( &sEnvelope ); /* We first check that the spatial index table exists */ if (!bHasCheckedSpatialIndexTable) { bHasCheckedSpatialIndexTable = TRUE; char **papszResult; int nRowCount, nColCount; char *pszErrMsg = NULL; CPLString osSQL; osSQL.Printf("SELECT name FROM sqlite_master " "WHERE name='idx_%s_%s'", pszEscapedUnderlyingTableName, OGRSQLiteEscape(osUnderlyingGeometryColumn).c_str()); int rc = sqlite3_get_table( poDS->GetDB(), osSQL.c_str(), &papszResult, &nRowCount, &nColCount, &pszErrMsg ); if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "Error: %s", pszErrMsg ); sqlite3_free( pszErrMsg ); bHasSpatialIndex = FALSE; } else { if (nRowCount != 1) { bHasSpatialIndex = FALSE; } sqlite3_free_table(papszResult); } } if (bHasSpatialIndex) { return FormatSpatialFilterFromRTree(poFilterGeom, CPLSPrintf("\"%s\"", OGRSQLiteEscapeName(pszFIDColumn).c_str()), pszEscapedUnderlyingTableName, OGRSQLiteEscape(osUnderlyingGeometryColumn).c_str()); } else { CPLDebug("SQLITE", "Count not find idx_%s_%s layer. Disabling spatial index", pszEscapedUnderlyingTableName, osUnderlyingGeometryColumn.c_str()); } } if( poFilterGeom != NULL && poDS->IsSpatialiteLoaded() ) { return FormatSpatialFilterFromMBR(poFilterGeom, OGRSQLiteEscapeName(poFeatureDefn->GetGeomFieldDefn(iGeomCol)->GetNameRef()).c_str()); } return ""; }
CPLErr OGRSQLiteViewLayer::EstablishFeatureDefn() { int rc; sqlite3 *hDB = poDS->GetDB(); sqlite3_stmt *hColStmt = NULL; const char *pszSQL; OGRSQLiteLayer* poUnderlyingLayer = GetUnderlyingLayer(); if (poUnderlyingLayer == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find underlying layer %s for view %s", osUnderlyingTableName.c_str(), pszViewName); return CE_Failure; } if ( !poUnderlyingLayer->IsTableLayer() ) { CPLError(CE_Failure, CPLE_AppDefined, "Underlying layer %s for view %s is not a regular table", osUnderlyingTableName.c_str(), pszViewName); return CE_Failure; } int nUnderlyingLayerGeomFieldIndex = poUnderlyingLayer->GetLayerDefn()->GetGeomFieldIndex(osUnderlyingGeometryColumn); if ( nUnderlyingLayerGeomFieldIndex < 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Underlying layer %s for view %s has not expected geometry column name %s", osUnderlyingTableName.c_str(), pszViewName, osUnderlyingGeometryColumn.c_str()); return CE_Failure; } this->bHasSpatialIndex = poUnderlyingLayer->HasSpatialIndex(nUnderlyingLayerGeomFieldIndex); /* -------------------------------------------------------------------- */ /* Get the column definitions for this table. */ /* -------------------------------------------------------------------- */ hColStmt = NULL; pszSQL = CPLSPrintf( "SELECT \"%s\", * FROM '%s' LIMIT 1", OGRSQLiteEscapeName(pszFIDColumn).c_str(), pszEscapedTableName ); rc = sqlite3_prepare( hDB, pszSQL, strlen(pszSQL), &hColStmt, NULL ); if( rc != SQLITE_OK ) { CPLError( CE_Failure, CPLE_AppDefined, "Unable to query table %s for column definitions : %s.", pszViewName, sqlite3_errmsg(hDB) ); return CE_Failure; } rc = sqlite3_step( hColStmt ); if ( rc != SQLITE_DONE && rc != SQLITE_ROW ) { CPLError( CE_Failure, CPLE_AppDefined, "In Initialize(): sqlite3_step(%s):\n %s", pszSQL, sqlite3_errmsg(hDB) ); sqlite3_finalize( hColStmt ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Collect the rest of the fields. */ /* -------------------------------------------------------------------- */ std::set<CPLString> aosGeomCols; std::set<CPLString> aosIgnoredCols; aosGeomCols.insert(osGeomColumn); BuildFeatureDefn( pszViewName, hColStmt, aosGeomCols, aosIgnoredCols ); sqlite3_finalize( hColStmt ); /* -------------------------------------------------------------------- */ /* Set the properties of the geometry column. */ /* -------------------------------------------------------------------- */ if( poFeatureDefn->GetGeomFieldCount() != 0 ) { OGRSQLiteGeomFieldDefn* poSrcGeomFieldDefn = poUnderlyingLayer->myGetLayerDefn()->myGetGeomFieldDefn(nUnderlyingLayerGeomFieldIndex); OGRSQLiteGeomFieldDefn* poGeomFieldDefn = poFeatureDefn->myGetGeomFieldDefn(0); poGeomFieldDefn->SetType(poSrcGeomFieldDefn->GetType()); poGeomFieldDefn->SetSpatialRef(poSrcGeomFieldDefn->GetSpatialRef()); poGeomFieldDefn->nSRSId = poSrcGeomFieldDefn->nSRSId; if( eGeomFormat != OSGF_None ) poGeomFieldDefn->eGeomFormat = eGeomFormat; } return CE_None; }
static void ReportOnLayer( OGRLayer * poLayer, int bVerbose ) { OGRFeatureDefn *poDefn = poLayer->GetLayerDefn(); /* -------------------------------------------------------------------- */ /* Report various overall information. */ /* -------------------------------------------------------------------- */ printf( "\n" ); printf( "Layer name: %s\n", poLayer->GetName() ); if( bVerbose ) { int nGeomFieldCount = poLayer->GetLayerDefn()->GetGeomFieldCount(); if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); printf( "Geometry (%s): %s\n", poGFldDefn->GetNameRef(), OGRGeometryTypeToName( poGFldDefn->GetType() ) ); } } else { printf( "Geometry: %s\n", OGRGeometryTypeToName( poLayer->GetGeomType() ) ); } printf( "Feature Count: " CPL_FRMT_GIB "\n", poLayer->GetFeatureCount() ); OGREnvelope oExt; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { if (poLayer->GetExtent(iGeom, &oExt, TRUE) == OGRERR_NONE) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); CPLprintf("Extent (%s): (%f, %f) - (%f, %f)\n", poGFldDefn->GetNameRef(), oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } } } else if ( poLayer->GetExtent(&oExt, TRUE) == OGRERR_NONE) { CPLprintf("Extent: (%f, %f) - (%f, %f)\n", oExt.MinX, oExt.MinY, oExt.MaxX, oExt.MaxY); } char *pszWKT; if( nGeomFieldCount > 1 ) { for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); OGRSpatialReference* poSRS = poGFldDefn->GetSpatialRef(); if( poSRS == nullptr ) pszWKT = CPLStrdup( "(unknown)" ); else { poSRS->exportToPrettyWkt( &pszWKT ); } printf( "SRS WKT (%s):\n%s\n", poGFldDefn->GetNameRef(), pszWKT ); CPLFree( pszWKT ); } } else { if( poLayer->GetSpatialRef() == nullptr ) pszWKT = CPLStrdup( "(unknown)" ); else { poLayer->GetSpatialRef()->exportToPrettyWkt( &pszWKT ); } printf( "Layer SRS WKT:\n%s\n", pszWKT ); CPLFree( pszWKT ); } if( strlen(poLayer->GetFIDColumn()) > 0 ) printf( "FID Column = %s\n", poLayer->GetFIDColumn() ); for(int iGeom = 0;iGeom < nGeomFieldCount; iGeom ++ ) { OGRGeomFieldDefn* poGFldDefn = poLayer->GetLayerDefn()->GetGeomFieldDefn(iGeom); if( nGeomFieldCount == 1 && EQUAL(poGFldDefn->GetNameRef(), "") && poGFldDefn->IsNullable() ) break; printf( "Geometry Column "); if( nGeomFieldCount > 1 ) printf("%d ", iGeom + 1); if( !poGFldDefn->IsNullable() ) printf("NOT NULL "); printf("= %s\n", poGFldDefn->GetNameRef() ); } for( int iAttr = 0; iAttr < poDefn->GetFieldCount(); iAttr++ ) { OGRFieldDefn *poField = poDefn->GetFieldDefn( iAttr ); const char* pszType = (poField->GetSubType() != OFSTNone) ? CPLSPrintf("%s(%s)", poField->GetFieldTypeName( poField->GetType() ), poField->GetFieldSubTypeName(poField->GetSubType())) : poField->GetFieldTypeName( poField->GetType() ); printf( "%s: %s (%d.%d)", poField->GetNameRef(), pszType, poField->GetWidth(), poField->GetPrecision() ); if( !poField->IsNullable() ) printf(" NOT NULL"); if( poField->GetDefault() != nullptr ) printf(" DEFAULT %s", poField->GetDefault() ); printf( "\n" ); } } /* -------------------------------------------------------------------- */ /* Read, and dump features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature = nullptr; while( (poFeature = poLayer->GetNextFeature()) != nullptr ) { poFeature->DumpReadable( nullptr ); OGRFeature::DestroyFeature( poFeature ); } }
GDALDataset *IntergraphDataset::Open( GDALOpenInfo *poOpenInfo ) { if( poOpenInfo->nHeaderBytes < 1024 ) { return NULL; } // -------------------------------------------------------------------- // Assign Header Information // -------------------------------------------------------------------- INGR_HeaderOne hHeaderOne; INGR_HeaderOneDiskToMem( &hHeaderOne, (GByte*) poOpenInfo->pabyHeader); // -------------------------------------------------------------------- // Check Header Type (HTC) Version // -------------------------------------------------------------------- if( hHeaderOne.HeaderType.Version != INGR_HEADER_VERSION ) { return NULL; } // -------------------------------------------------------------------- // Check Header Type (HTC) 2D / 3D Flag // -------------------------------------------------------------------- if( ( hHeaderOne.HeaderType.Is2Dor3D != INGR_HEADER_2D ) && ( hHeaderOne.HeaderType.Is2Dor3D != INGR_HEADER_3D ) ) { return NULL; } // -------------------------------------------------------------------- // Check Header Type (HTC) Type Flag // -------------------------------------------------------------------- if( hHeaderOne.HeaderType.Type != INGR_HEADER_TYPE ) { return NULL; } // -------------------------------------------------------------------- // Check Grid File Version (VER) // -------------------------------------------------------------------- if( hHeaderOne.GridFileVersion != 1 && hHeaderOne.GridFileVersion != 2 && hHeaderOne.GridFileVersion != 3 ) { return NULL; } // -------------------------------------------------------------------- // Check Words To Follow (WTC) Minimum Value // -------------------------------------------------------------------- if( hHeaderOne.WordsToFollow < 254 ) { return NULL; } // -------------------------------------------------------------------- // Check Words To Follow (WTC) Integrity // -------------------------------------------------------------------- float fHeaderBlocks = (float) ( hHeaderOne.WordsToFollow + 2 ) / 256; if( ( fHeaderBlocks - (int) fHeaderBlocks ) != 0.0 ) { return NULL; } // -------------------------------------------------------------------- // Get Data Type Code (DTC) => Format Type // -------------------------------------------------------------------- INGR_Format eFormat = (INGR_Format) hHeaderOne.DataTypeCode; // -------------------------------------------------------------------- // We need to scan around the file, so we open it now. // -------------------------------------------------------------------- VSILFILE *fp; if( poOpenInfo->eAccess == GA_ReadOnly ) { fp = VSIFOpenL( poOpenInfo->pszFilename, "rb" ); } else { fp = VSIFOpenL( poOpenInfo->pszFilename, "r+b" ); } if( fp == NULL ) { CPLError( CE_Failure, CPLE_OpenFailed, "%s", VSIStrerror( errno ) ); return NULL; } // -------------------------------------------------------------------- // Get Format Type from the tile directory // -------------------------------------------------------------------- if( hHeaderOne.DataTypeCode == TiledRasterData ) { INGR_TileHeader hTileDir; int nOffset = 2 + ( 2 * ( hHeaderOne.WordsToFollow + 1 ) ); GByte abyBuffer[SIZEOF_TDIR]; if( (VSIFSeekL( fp, nOffset, SEEK_SET ) == -1 ) || (VSIFReadL( abyBuffer, 1, SIZEOF_TDIR, fp ) == 0) ) { VSIFCloseL( fp ); CPLError( CE_Failure, CPLE_AppDefined, "Error reading tiles header" ); return NULL; } INGR_TileHeaderDiskToMem( &hTileDir, abyBuffer ); if( ! ( hTileDir.ApplicationType == 1 && hTileDir.SubTypeCode == 7 && ( hTileDir.WordsToFollow % 4 ) == 0 && hTileDir.PacketVersion == 1 && hTileDir.Identifier == 1 ) ) { CPLError( CE_Failure, CPLE_AppDefined, "Cannot recognize tiles header info"); VSIFCloseL( fp ); return NULL; } eFormat = (INGR_Format) hTileDir.DataTypeCode; } // -------------------------------------------------------------------- // Check Scannable Flag // -------------------------------------------------------------------- /* if (hHeaderOne.ScannableFlag == HasLineHeader) { CPLError( CE_Failure, CPLE_AppDefined, "Intergraph Raster Scannable Line Header not supported yet" ); VSIFCloseL( fp ); return NULL; } */ // -------------------------------------------------------------------- // Check supported Format Type // -------------------------------------------------------------------- if( eFormat != ByteInteger && eFormat != WordIntegers && eFormat != Integers32Bit && eFormat != FloatingPoint32Bit && eFormat != FloatingPoint64Bit && eFormat != RunLengthEncoded && eFormat != RunLengthEncodedC && eFormat != CCITTGroup4 && eFormat != AdaptiveRGB && eFormat != Uncompressed24bit && eFormat != AdaptiveGrayScale && eFormat != ContinuousTone && eFormat != JPEGGRAY && eFormat != JPEGRGB && eFormat != JPEGCYMK ) { CPLError( CE_Failure, CPLE_AppDefined, "Intergraph Raster Format %d ( \"%s\" ) not supported", hHeaderOne.DataTypeCode, INGR_GetFormatName( (uint16) eFormat ) ); VSIFCloseL( fp ); return NULL; } // ----------------------------------------------------------------- // Create a corresponding GDALDataset // ----------------------------------------------------------------- IntergraphDataset *poDS; poDS = new IntergraphDataset(); poDS->eAccess = poOpenInfo->eAccess; poDS->pszFilename = CPLStrdup( poOpenInfo->pszFilename ); poDS->fp = fp; // -------------------------------------------------------------------- // Get X Size from Pixels Per Line (PPL) // -------------------------------------------------------------------- poDS->nRasterXSize = hHeaderOne.PixelsPerLine; // -------------------------------------------------------------------- // Get Y Size from Number of Lines (NOL) // -------------------------------------------------------------------- poDS->nRasterYSize = hHeaderOne.NumberOfLines; if (poDS->nRasterXSize <= 0 || poDS->nRasterYSize <= 0) { CPLError( CE_Failure, CPLE_AppDefined, "Invalid dimensions : %d x %d", poDS->nRasterXSize, poDS->nRasterYSize); delete poDS; return NULL; } // -------------------------------------------------------------------- // Get Geo Transformation from Homogeneous Transformation Matrix (TRN) // -------------------------------------------------------------------- INGR_GetTransMatrix( &hHeaderOne, poDS->adfGeoTransform ); // -------------------------------------------------------------------- // Set Metadata Information // -------------------------------------------------------------------- poDS->SetMetadataItem( "VERSION", CPLSPrintf ( "%d", hHeaderOne.GridFileVersion ), "IMAGE_STRUCTURE" ); poDS->SetMetadataItem( "RESOLUTION", CPLSPrintf ( "%d", (hHeaderOne.DeviceResolution < 0)?-hHeaderOne.DeviceResolution:1) ); // -------------------------------------------------------------------- // Create Band Information // -------------------------------------------------------------------- int nBands = 0; int nBandOffset = 0; GByte abyBuf[MAX(SIZEOF_HDR1,SIZEOF_HDR2_A)]; do { VSIFSeekL( poDS->fp, nBandOffset, SEEK_SET ); VSIFReadL( abyBuf, 1, SIZEOF_HDR1, poDS->fp ); INGR_HeaderOneDiskToMem( &poDS->hHeaderOne, abyBuf ); VSIFReadL( abyBuf, 1, SIZEOF_HDR2_A, poDS->fp ); INGR_HeaderTwoADiskToMem( &poDS->hHeaderTwo, abyBuf ); switch( eFormat ) { case JPEGRGB: case JPEGCYMK: { IntergraphBitmapBand* poBand; nBands++; poDS->SetBand( nBands, poBand = new IntergraphBitmapBand( poDS, nBands, nBandOffset, 1 )); if (poBand->pabyBMPBlock == NULL) { delete poDS; return NULL; } nBands++; poDS->SetBand( nBands, poBand = new IntergraphBitmapBand( poDS, nBands, nBandOffset, 2 )); if (poBand->pabyBMPBlock == NULL) { delete poDS; return NULL; } nBands++; poDS->SetBand( nBands, poBand = new IntergraphBitmapBand( poDS, nBands, nBandOffset, 3 )); if (poBand->pabyBMPBlock == NULL) { delete poDS; return NULL; } break; } case JPEGGRAY: case CCITTGroup4: { IntergraphBitmapBand* poBand; nBands++; poDS->SetBand( nBands, poBand = new IntergraphBitmapBand( poDS, nBands, nBandOffset )); if (poBand->pabyBMPBlock == NULL) { delete poDS; return NULL; } break; } case RunLengthEncoded: case RunLengthEncodedC: case AdaptiveGrayScale: { IntergraphRLEBand* poBand; nBands++; poDS->SetBand( nBands, poBand = new IntergraphRLEBand( poDS, nBands, nBandOffset )); if (poBand->pabyBlockBuf == NULL || poBand->pabyRLEBlock == NULL) { delete poDS; return NULL; } break; } case AdaptiveRGB: case ContinuousTone: { IntergraphRLEBand* poBand; nBands++; poDS->SetBand( nBands, poBand = new IntergraphRLEBand( poDS, nBands, nBandOffset, 1 )); if (poBand->pabyBlockBuf == NULL || poBand->pabyRLEBlock == NULL) { delete poDS; return NULL; } nBands++; poDS->SetBand( nBands, poBand = new IntergraphRLEBand( poDS, nBands, nBandOffset, 2 )); if (poBand->pabyBlockBuf == NULL || poBand->pabyRLEBlock == NULL) { delete poDS; return NULL; } nBands++; poDS->SetBand( nBands, poBand = new IntergraphRLEBand( poDS, nBands, nBandOffset, 3 )); if (poBand->pabyBlockBuf == NULL || poBand->pabyRLEBlock == NULL) { delete poDS; return NULL; } break; } case Uncompressed24bit: { IntergraphRGBBand* poBand; nBands++; poDS->SetBand( nBands, poBand = new IntergraphRGBBand( poDS, nBands, nBandOffset, 1 )); if (poBand->pabyBlockBuf == NULL) { delete poDS; return NULL; } nBands++; poDS->SetBand( nBands, poBand = new IntergraphRGBBand( poDS, nBands, nBandOffset, 2 )); if (poBand->pabyBlockBuf == NULL) { delete poDS; return NULL; } nBands++; poDS->SetBand( nBands, poBand = new IntergraphRGBBand( poDS, nBands, nBandOffset, 3 )); if (poBand->pabyBlockBuf == NULL) { delete poDS; return NULL; } break; } default: { IntergraphRasterBand* poBand; nBands++; poDS->SetBand( nBands, poBand = new IntergraphRasterBand( poDS, nBands, nBandOffset )); if (poBand->pabyBlockBuf == NULL) { delete poDS; return NULL; } } } // ---------------------------------------------------------------- // Get next band offset from Catenated File Pointer (CFP) // ---------------------------------------------------------------- nBandOffset = poDS->hHeaderTwo.CatenatedFilePointer; } while( nBandOffset != 0 ); poDS->nBands = nBands; // -------------------------------------------------------------------- // Initialize any PAM information // -------------------------------------------------------------------- poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Check for external overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename ); return ( poDS ); }
MAIN_START(nArgc, papszArgv) { int bQuiet = FALSE; const char *pszDataSource = nullptr; GNMGFID nFromFID = -1; GNMGFID nToFID = -1; int nK = 1; const char *pszDataset = nullptr; const char *pszFormat = "ESRI Shapefile"; const char *pszLayer = nullptr; GNMNetwork *poDS = nullptr; OGRLayer* poResultLayer = nullptr; char **papszDSCO = nullptr, **papszLCO = nullptr, **papszALO = nullptr; operation stOper = op_unknown; int nRet = 0; // Check strict compilation and runtime library version as we use C++ API if (! GDAL_CHECK_VERSION(papszArgv[0])) exit(1); EarlySetConfigOptions(nArgc, papszArgv); /* -------------------------------------------------------------------- */ /* Register format(s). */ /* -------------------------------------------------------------------- */ GDALAllRegister(); /* -------------------------------------------------------------------- */ /* Processing command line arguments. */ /* -------------------------------------------------------------------- */ nArgc = GDALGeneralCmdLineProcessor( nArgc, &papszArgv, GDAL_OF_GNM ); if( nArgc < 1 ) { exit( -nArgc ); } for( int iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[1], "--utility_version") ) { printf("%s was compiled against GDAL %s and is running against GDAL %s\n", papszArgv[0], GDAL_RELEASE_NAME, GDALVersionInfo("RELEASE_NAME")); CSLDestroy( papszArgv ); return 0; } else if( EQUAL(papszArgv[iArg],"--help") ) { Usage(); } else if ( EQUAL(papszArgv[iArg], "--long-usage") ) { Usage(FALSE); } else if( EQUAL(papszArgv[iArg],"-q") || EQUAL(papszArgv[iArg],"-quiet") ) { bQuiet = TRUE; } else if( EQUAL(papszArgv[iArg],"dijkstra") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(2); stOper = op_dijkstra; nFromFID = atoi(papszArgv[++iArg]); nToFID = atoi(papszArgv[++iArg]); } else if( EQUAL(papszArgv[iArg],"kpaths") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(3); stOper = op_kpaths; nFromFID = atoi(papszArgv[++iArg]); nToFID = atoi(papszArgv[++iArg]); nK = atoi(papszArgv[++iArg]); } else if( EQUAL(papszArgv[iArg],"resource") ) { stOper = op_resource; } else if( EQUAL(papszArgv[iArg],"-ds") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszDataset = papszArgv[++iArg]; } else if( (EQUAL(papszArgv[iArg],"-f") || EQUAL(papszArgv[iArg],"-of")) ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszFormat = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-l") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszLayer = papszArgv[++iArg]; } else if( EQUAL(papszArgv[iArg],"-dsco") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); papszDSCO = CSLAddString(papszDSCO, papszArgv[++iArg] ); } else if( EQUAL(papszArgv[iArg],"-lco") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); papszLCO = CSLAddString(papszLCO, papszArgv[++iArg] ); } else if( EQUAL(papszArgv[iArg],"-alo") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); papszALO = CSLAddString(papszALO, papszArgv[++iArg] ); } else if( papszArgv[iArg][0] == '-' ) { Usage(CPLSPrintf("Unknown option name '%s'", papszArgv[iArg])); } else if( pszDataSource == nullptr ) pszDataSource = papszArgv[iArg]; } // do the work //////////////////////////////////////////////////////////////// if(stOper == op_dijkstra) { if(pszDataSource == nullptr) Usage("No network dataset provided"); if(nFromFID == -1 || nToFID == -1) Usage("Invalid input from or to identificators"); // open poDS = (GNMNetwork*) GDALOpenEx( pszDataSource, GDAL_OF_UPDATE | GDAL_OF_GNM, nullptr, nullptr, nullptr ); if(nullptr == poDS) { fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource); nRet = 1; goto exit; } poResultLayer = poDS->GetPath(nFromFID, nToFID, GATDijkstraShortestPath, papszALO); if(nullptr == pszDataset) { ReportOnLayer(poResultLayer, bQuiet == FALSE); } else { if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat, pszLayer, papszDSCO, papszLCO, bQuiet) != OGRERR_NONE) { nRet = 1; goto exit; } } } else if(stOper == op_kpaths) { if(pszDataSource == nullptr) Usage("No network dataset provided"); if(nFromFID == -1 || nToFID == -1) Usage("Invalid input from or to identificators"); // open poDS = (GNMNetwork*) GDALOpenEx( pszDataSource, GDAL_OF_UPDATE | GDAL_OF_GNM, nullptr, nullptr, nullptr ); if(nullptr == poDS) { fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource); nRet = 1; goto exit; } if(CSLFindName(papszALO, GNM_MD_NUM_PATHS) == -1) { CPLDebug("GNM", "No K in options, add %d value", nK); papszALO = CSLAddNameValue(papszALO, GNM_MD_NUM_PATHS, CPLSPrintf("%d", nK)); } poResultLayer = poDS->GetPath(nFromFID, nToFID, GATKShortestPath, papszALO); if(nullptr == pszDataset) { ReportOnLayer(poResultLayer, bQuiet == FALSE); } else { if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat, pszLayer, papszDSCO, papszLCO, bQuiet) != OGRERR_NONE) { nRet = 1; goto exit; } } } else if(stOper == op_resource) { if(pszDataSource == nullptr) Usage("No network dataset provided"); // open poDS = (GNMNetwork*) GDALOpenEx( pszDataSource, GDAL_OF_UPDATE | GDAL_OF_GNM, nullptr, nullptr, nullptr ); if(nullptr == poDS) { fprintf( stderr, "\nFailed to open network at %s\n", pszDataSource); nRet = 1; goto exit; } poResultLayer = poDS->GetPath(nFromFID, nToFID, GATConnectedComponents, papszALO); if(nullptr == pszDataset) { ReportOnLayer(poResultLayer, bQuiet == FALSE); } else { if(CreateAndFillOutputDataset(poResultLayer, pszDataset, pszFormat, pszLayer, papszDSCO, papszLCO, bQuiet) != OGRERR_NONE) { nRet = 1; goto exit; } } } else { printf("\nNeed an operation. See help what you can do with gnmanalyse:\n"); Usage(); } exit: CSLDestroy(papszDSCO); CSLDestroy(papszLCO); CSLDestroy(papszALO); CSLDestroy( papszArgv ); if(poResultLayer != nullptr) poDS->ReleaseResultSet(poResultLayer); if( poDS != nullptr ) GDALClose(poDS); GDALDestroyDriverManager(); return nRet; }
int OGRGFTResultLayer::RunSQL() { CPLString osChangedSQL(osSQL); int bHasSetLimit = FALSE; OGRGFTTableLayer* poTableLayer = NULL; OGRFeatureDefn* poTableDefn = NULL; CPLString osTableId; if (STARTS_WITH_CI(osSQL.c_str(), "SELECT")) { size_t nPosFROM = osSQL.ifind(" FROM "); if (nPosFROM == std::string::npos) { CPLError(CE_Failure, CPLE_AppDefined, "RunSQL() failed. Missing FROM in SELECT"); return FALSE; } CPLString osReminder; nPosFROM += 6; osTableId = OGRGFTExtractTableID(osSQL.c_str() + nPosFROM, osReminder); poTableLayer = (OGRGFTTableLayer*) poDS->GetLayerByName(osTableId); if (poTableLayer != NULL) poTableDefn = poTableLayer->GetLayerDefn(); if (poTableLayer != NULL && poTableLayer->GetTableId().size() && !EQUAL(osTableId, poTableLayer->GetTableId())) { osChangedSQL = osSQL; osChangedSQL.resize(nPosFROM); osChangedSQL += poTableLayer->GetTableId(); osChangedSQL += osReminder; osSQL = osChangedSQL; CPLDebug("GFT", "Patching table name (%s) to table id (%s)", osTableId.c_str(), poTableLayer->GetTableId().c_str()); } int nFeaturesToFetch = GetFeaturesToFetch(); if (osSQL.ifind(" OFFSET ") == std::string::npos && osSQL.ifind(" LIMIT ") == std::string::npos && nFeaturesToFetch > 0) { osChangedSQL += CPLSPrintf(" LIMIT %d", nFeaturesToFetch); bHasSetLimit = TRUE; } } else { bGotAllRows = bEOF = TRUE; poFeatureDefn->SetGeomType( wkbNone ); } CPLHTTPResult * psResult = poDS->RunSQL(osChangedSQL); if (psResult == NULL) return FALSE; char* pszLine = (char*) psResult->pabyData; if (pszLine == NULL || psResult->pszErrBuf != NULL) { CPLError(CE_Failure, CPLE_AppDefined, "RunSQL() failed"); CPLHTTPDestroyResult(psResult); return FALSE; } if (STARTS_WITH_CI(osSQL.c_str(), "SELECT") || EQUAL(osSQL.c_str(), "SHOW TABLES") || STARTS_WITH_CI(osSQL.c_str(), "DESCRIBE")) { ParseCSVResponse(pszLine, aosRows); if (aosRows.size() > 0) { char** papszTokens = OGRGFTCSVSplitLine(aosRows[0], ','); for(int i=0;papszTokens && papszTokens[i];i++) { CPLString osLaunderedColName(LaunderColName(papszTokens[i])); int iIndex = (poTableDefn) ? poTableDefn->GetFieldIndex(osLaunderedColName) : -1; if (iIndex >= 0) { poFeatureDefn->AddFieldDefn(poTableDefn->GetFieldDefn(iIndex)); if (iIndex == poTableLayer->GetGeometryFieldIndex()) iGeometryField = i; if (iIndex == poTableLayer->GetLatitudeFieldIndex()) iLatitudeField = i; if (iIndex == poTableLayer->GetLongitudeFieldIndex()) iLongitudeField = i; } else { OGRFieldType eType = OFTString; if (EQUAL(osLaunderedColName, "COUNT()")) eType = OFTInteger; OGRFieldDefn oFieldDefn(osLaunderedColName, eType); poFeatureDefn->AddFieldDefn(&oFieldDefn); } } CSLDestroy(papszTokens); aosRows.erase(aosRows.begin()); } if (iLatitudeField >= 0 && iLongitudeField >= 0) { iGeometryField = iLatitudeField; poFeatureDefn->SetGeomType( wkbPoint ); } if (bHasSetLimit) bGotAllRows = bEOF = (int)aosRows.size() < GetFeaturesToFetch(); else bGotAllRows = bEOF = TRUE; } SetGeomFieldName(); CPLHTTPDestroyResult(psResult); return TRUE; }
GDALDataset *SAGADataset::CreateCopy( const char *pszFilename, GDALDataset *poSrcDS, int bStrict, char **papszOptions, GDALProgressFunc pfnProgress, void *pProgressData ) { if( pfnProgress == NULL ) pfnProgress = GDALDummyProgress; int nBands = poSrcDS->GetRasterCount(); if (nBands == 0) { CPLError( CE_Failure, CPLE_NotSupported, "SAGA driver does not support source dataset with zero band.\n"); return NULL; } else if (nBands > 1) { if( bStrict ) { CPLError( CE_Failure, CPLE_NotSupported, "Unable to create copy, SAGA Binary Grid " "format only supports one raster band.\n" ); return NULL; } else CPLError( CE_Warning, CPLE_NotSupported, "SAGA Binary Grid format only supports one " "raster band, first band will be copied.\n" ); } GDALRasterBand *poSrcBand = poSrcDS->GetRasterBand( 1 ); char** papszCreateOptions = NULL; papszCreateOptions = CSLSetNameValue(papszCreateOptions, "FILL_NODATA", "NO"); int bHasNoDataValue = FALSE; double dfNoDataValue = poSrcBand->GetNoDataValue(&bHasNoDataValue); if (bHasNoDataValue) papszCreateOptions = CSLSetNameValue(papszCreateOptions, "NODATA_VALUE", CPLSPrintf("%.16g", dfNoDataValue)); GDALDataset* poDstDS = Create(pszFilename, poSrcBand->GetXSize(), poSrcBand->GetYSize(), 1, poSrcBand->GetRasterDataType(), papszCreateOptions); CSLDestroy(papszCreateOptions); if (poDstDS == NULL) return NULL; /* -------------------------------------------------------------------- */ /* Copy band data. */ /* -------------------------------------------------------------------- */ CPLErr eErr; eErr = GDALDatasetCopyWholeRaster( (GDALDatasetH) poSrcDS, (GDALDatasetH) poDstDS, NULL, pfnProgress, pProgressData ); if (eErr == CE_Failure) { delete poDstDS; return NULL; } double adfGeoTransform[6]; poSrcDS->GetGeoTransform( adfGeoTransform ); poDstDS->SetGeoTransform( adfGeoTransform ); return poDstDS; }
int main( int argc, char ** argv ) { /* Check that we are running against at least GDAL 1.4 (probably older in fact !) */ /* Note to developers : if we use newer API, please change the requirement */ if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400) { fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, " "which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME); exit(1); } /* -------------------------------------------------------------------- */ /* Generic arg processing. */ /* -------------------------------------------------------------------- */ GDALAllRegister(); GDALSetCacheMax( 100000000 ); argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); if( argc < 1 ) exit( -argc ); /* -------------------------------------------------------------------- */ /* Parse arguments. */ /* -------------------------------------------------------------------- */ int i; const char *pszOutFile = NULL; const char *pszInFile = NULL; int nMaxNonBlack = 2; int nNearDist = 15; int bNearWhite = FALSE; int bSetAlpha = FALSE; int bSetMask = FALSE; const char* pszDriverName = "HFA"; int bFormatExplicitlySet = FALSE; char** papszCreationOptions = NULL; int bQuiet = FALSE; Colors oColors; 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], "--help") ) Usage(); else if( EQUAL(argv[i], "-o") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszOutFile = argv[++i]; } else if( EQUAL(argv[i], "-of") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszDriverName = argv[++i]; bFormatExplicitlySet = TRUE; } else if( EQUAL(argv[i], "-white") ) { bNearWhite = TRUE; } /***** -color c1,c2,c3...cn *****/ else if( EQUAL(argv[i], "-color") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); Color oColor; /***** tokenize the arg on , *****/ char **papszTokens; papszTokens = CSLTokenizeString2( argv[++i], ",", 0 ); /***** loop over the tokens *****/ int iToken; for( iToken = 0; papszTokens && papszTokens[iToken]; iToken++ ) { /***** ensure the token is an int and add it to the color *****/ if ( IsInt( papszTokens[iToken] ) ) oColor.push_back( atoi( papszTokens[iToken] ) ); else { CPLError(CE_Failure, CPLE_AppDefined, "Colors must be valid integers." ); CSLDestroy( papszTokens ); exit(1); } } CSLDestroy( papszTokens ); /***** check if the number of bands is consistent *****/ if ( oColors.size() > 0 && oColors.front().size() != oColor.size() ) { CPLError(CE_Failure, CPLE_AppDefined, "ERROR: all -color args must have the same number of values.\n" ); exit(1); } /***** add the color to the colors *****/ oColors.push_back( oColor ); } else if( EQUAL(argv[i], "-nb") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); nMaxNonBlack = atoi(argv[++i]); } else if( EQUAL(argv[i], "-near") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); nNearDist = atoi(argv[++i]); } else if( EQUAL(argv[i], "-setalpha") ) bSetAlpha = TRUE; else if( EQUAL(argv[i], "-setmask") ) bSetMask = TRUE; else if( EQUAL(argv[i], "-q") || EQUAL(argv[i], "-quiet") ) bQuiet = TRUE; else if( EQUAL(argv[i], "-co") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); papszCreationOptions = CSLAddString(papszCreationOptions, argv[++i]); } else if( argv[i][0] == '-' ) Usage(CPLSPrintf("Unknown option name '%s'", argv[i])); else if( pszInFile == NULL ) pszInFile = argv[i]; else Usage("Too many command options."); } if( pszInFile == NULL ) Usage("No input file specified."); if( pszOutFile == NULL ) pszOutFile = pszInFile; /* -------------------------------------------------------------------- */ /* Open input file. */ /* -------------------------------------------------------------------- */ GDALDatasetH hInDS, hOutDS = NULL; int nXSize, nYSize, nBands; if( pszOutFile == pszInFile ) hInDS = hOutDS = GDALOpen( pszInFile, GA_Update ); else hInDS = GDALOpen( pszInFile, GA_ReadOnly ); if( hInDS == NULL ) exit( 1 ); nXSize = GDALGetRasterXSize( hInDS ); nYSize = GDALGetRasterYSize( hInDS ); nBands = GDALGetRasterCount( hInDS ); int nDstBands = nBands; if( hOutDS != NULL && papszCreationOptions != NULL) { CPLError(CE_Warning, CPLE_AppDefined, "Warning: creation options are ignored when writing to an existing file."); } /* -------------------------------------------------------------------- */ /* Do we need to create output file? */ /* -------------------------------------------------------------------- */ if( hOutDS == NULL ) { GDALDriverH hDriver = GDALGetDriverByName( pszDriverName ); if (hDriver == NULL) exit(1); if (!bQuiet && !bFormatExplicitlySet) CheckExtensionConsistency(pszOutFile, pszDriverName); if (bSetAlpha) { /***** fixme there should be a way to preserve alpha band data not in the collar *****/ if (nBands == 4) nBands --; else nDstBands ++; } if (bSetMask) { if (nBands == 4) nDstBands = nBands = 3; } hOutDS = GDALCreate( hDriver, pszOutFile, nXSize, nYSize, nDstBands, GDT_Byte, papszCreationOptions ); if( hOutDS == NULL ) exit( 1 ); double adfGeoTransform[6]; if( GDALGetGeoTransform( hInDS, adfGeoTransform ) == CE_None ) { GDALSetGeoTransform( hOutDS, adfGeoTransform ); GDALSetProjection( hOutDS, GDALGetProjectionRef( hInDS ) ); } } else { if (bSetAlpha) { if (nBands != 4 && (nBands < 2 || GDALGetRasterColorInterpretation(GDALGetRasterBand(hOutDS, nBands)) != GCI_AlphaBand)) { CPLError(CE_Failure, CPLE_AppDefined, "Last band is not an alpha band."); exit(1); } nBands --; } if (bSetMask) { if (nBands == 4) nDstBands = nBands = 3; } } /***** set a color if there are no colors set? *****/ if ( oColors.size() == 0) { Color oColor; /***** loop over the bands to get the right number of values *****/ int iBand; for (iBand = 0; iBand < nBands ; iBand++) { /***** black or white? *****/ if (bNearWhite) oColor.push_back(255); else oColor.push_back(0); } /***** add the color to the colors *****/ oColors.push_back(oColor); } /***** does the number of bands match the number of color values? *****/ if ( (int)oColors.front().size() != nBands ) { CPLError( CE_Failure, CPLE_AppDefined, "-color args must have the same number of values as the non alpha input band count.\n" ); exit(1); } /***** check the input and output datasets are the same size *****/ if (GDALGetRasterXSize(hOutDS) != nXSize || GDALGetRasterYSize(hOutDS) != nYSize) { CPLError(CE_Failure, CPLE_AppDefined, "The dimensions of the output dataset don't match " "the dimensions of the input dataset."); exit(1); } int iBand; for( iBand = 0; iBand < nBands; iBand++ ) { GDALRasterBandH hBand = GDALGetRasterBand(hInDS, iBand+1); if (GDALGetRasterDataType(hBand) != GDT_Byte) { CPLError(CE_Warning, CPLE_AppDefined, "Band %d is not of type GDT_Byte. It can lead to unexpected results.", iBand+1); } if (GDALGetRasterColorTable(hBand) != NULL) { CPLError(CE_Warning, CPLE_AppDefined, "Band %d has a color table, which is ignored by nearblack. " "It can lead to unexpected results.", iBand+1); } } GDALRasterBandH hMaskBand = NULL; if (bSetMask) { /***** if there isn't already a mask band on the output file create one *****/ if ( GMF_PER_DATASET != GDALGetMaskFlags( GDALGetRasterBand(hOutDS, 1) ) ) { if ( CE_None != GDALCreateDatasetMaskBand(hOutDS, GMF_PER_DATASET) ) { CPLError(CE_Failure, CPLE_AppDefined, "Failed to create mask band on output DS"); bSetMask = FALSE; } } if (bSetMask) { hMaskBand = GDALGetMaskBand(GDALGetRasterBand(hOutDS, 1)); } } /* -------------------------------------------------------------------- */ /* Allocate a line buffer. */ /* -------------------------------------------------------------------- */ GByte *pabyLine; GByte *pabyMask=NULL; int *panLastLineCounts; pabyLine = (GByte *) CPLMalloc(nXSize * nDstBands); if (bSetMask) pabyMask = (GByte *) CPLMalloc(nXSize); panLastLineCounts = (int *) CPLCalloc(sizeof(int),nXSize); /* -------------------------------------------------------------------- */ /* Processing data one line at a time. */ /* -------------------------------------------------------------------- */ int iLine; for( iLine = 0; iLine < nYSize; iLine++ ) { CPLErr eErr; eErr = GDALDatasetRasterIO( hInDS, GF_Read, 0, iLine, nXSize, 1, pabyLine, nXSize, 1, GDT_Byte, nBands, NULL, nDstBands, nXSize * nDstBands, 1 ); if( eErr != CE_None ) break; if (bSetAlpha) { int iCol; for(iCol = 0; iCol < nXSize; iCol ++) { pabyLine[iCol * nDstBands + nDstBands - 1] = 255; } } if (bSetMask) { int iCol; for(iCol = 0; iCol < nXSize; iCol ++) { pabyMask[iCol] = 255; } } ProcessLine( pabyLine, pabyMask, 0, nXSize-1, nBands, nDstBands, nNearDist, nMaxNonBlack, bNearWhite, &oColors, panLastLineCounts, TRUE, // bDoHorizontalCheck TRUE, // bDoVerticalCheck FALSE // bBottomUp ); ProcessLine( pabyLine, pabyMask, nXSize-1, 0, nBands, nDstBands, nNearDist, nMaxNonBlack, bNearWhite, &oColors, panLastLineCounts, TRUE, // bDoHorizontalCheck FALSE, // bDoVerticalCheck FALSE // bBottomUp ); eErr = GDALDatasetRasterIO( hOutDS, GF_Write, 0, iLine, nXSize, 1, pabyLine, nXSize, 1, GDT_Byte, nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 ); if( eErr != CE_None ) break; /***** write out the mask band line *****/ if (bSetMask) { eErr = GDALRasterIO ( hMaskBand, GF_Write, 0, iLine, nXSize, 1, pabyMask, nXSize, 1, GDT_Byte, 0, 0 ); if( eErr != CE_None ) { CPLError(CE_Warning, CPLE_AppDefined, "ERROR writeing out line to mask band."); break; } } if (!bQuiet) GDALTermProgress( 0.5 * ((iLine+1) / (double) nYSize), NULL, NULL ); } /* -------------------------------------------------------------------- */ /* Now process from the bottom back up .*/ /* -------------------------------------------------------------------- */ memset( panLastLineCounts, 0, sizeof(int) * nXSize); for( iLine = nYSize-1; iLine >= 0; iLine-- ) { CPLErr eErr; eErr = GDALDatasetRasterIO( hOutDS, GF_Read, 0, iLine, nXSize, 1, pabyLine, nXSize, 1, GDT_Byte, nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 ); if( eErr != CE_None ) break; /***** read the mask band line back in *****/ if (bSetMask) { eErr = GDALRasterIO ( hMaskBand, GF_Read, 0, iLine, nXSize, 1, pabyMask, nXSize, 1, GDT_Byte, 0, 0 ); if( eErr != CE_None ) break; } ProcessLine( pabyLine, pabyMask, 0, nXSize-1, nBands, nDstBands, nNearDist, nMaxNonBlack, bNearWhite, &oColors, panLastLineCounts, TRUE, // bDoHorizontalCheck TRUE, // bDoVerticalCheck TRUE // bBottomUp ); ProcessLine( pabyLine, pabyMask, nXSize-1, 0, nBands, nDstBands, nNearDist, nMaxNonBlack, bNearWhite, &oColors, panLastLineCounts, TRUE, // bDoHorizontalCheck FALSE, // bDoVerticalCheck TRUE // bBottomUp ); eErr = GDALDatasetRasterIO( hOutDS, GF_Write, 0, iLine, nXSize, 1, pabyLine, nXSize, 1, GDT_Byte, nDstBands, NULL, nDstBands, nXSize * nDstBands, 1 ); if( eErr != CE_None ) break; /***** write out the mask band line *****/ if (bSetMask) { eErr = GDALRasterIO ( hMaskBand, GF_Write, 0, iLine, nXSize, 1, pabyMask, nXSize, 1, GDT_Byte, 0, 0 ); if( eErr != CE_None ) break; } if (!bQuiet) GDALTermProgress( 0.5 + 0.5 * (nYSize-iLine) / (double) nYSize, NULL, NULL ); } CPLFree(pabyLine); if (bSetMask) CPLFree(pabyMask); CPLFree( panLastLineCounts ); GDALClose( hOutDS ); if( hInDS != hOutDS ) GDALClose( hInDS ); GDALDumpOpenDatasets( stderr ); CSLDestroy( argv ); CSLDestroy( papszCreationOptions ); GDALDestroyDriverManager(); return 0; }
int OGROpenFileGDBDataSource::OpenFileGDBv9(int iGDBFeatureClasses, int iGDBObjectClasses, int nInterestTable) { FileGDBTable oTable; int i; CPLDebug("OpenFileGDB", "FileGDB v9"); /* Fetch names of layers */ if( !oTable.Open(CPLFormFilename(m_osDirName, CPLSPrintf("a%08x", iGDBObjectClasses + 1), "gdbtable")) ) return FALSE; int iName = oTable.GetFieldIdx("Name"); int iCLSID = oTable.GetFieldIdx("CLSID"); if( iName < 0 || oTable.GetField(iName)->GetType() != FGFT_STRING || iCLSID < 0 || oTable.GetField(iCLSID)->GetType() != FGFT_STRING ) { CPLError(CE_Failure, CPLE_AppDefined, "Wrong structure for GDB_ObjectClasses table"); return FALSE; } std::vector< std::string > aosName; int nCandidateLayers = 0, nLayersSDC = 0; for(i=0;i<oTable.GetTotalRecordCount();i++) { if( !oTable.SelectRow(i) ) { if( oTable.HasGotError() ) break; aosName.push_back( "" ); continue; } const OGRField* psField = oTable.GetFieldValue(iName); if( psField != NULL ) { std::string osName(psField->String); psField = oTable.GetFieldValue(iCLSID); if( psField != NULL ) { /* Is it a non-spatial table ? */ if( strcmp(psField->String, "{7A566981-C114-11D2-8A28-006097AFF44E}") == 0 ) { aosName.push_back( "" ); AddLayer( osName, nInterestTable, nCandidateLayers, nLayersSDC, "", "", NULL, wkbNone ); } else { /* We should perhaps also check that the CLSID is the one of a spatial table */ aosName.push_back( osName ); } } } } oTable.Close(); /* Find tables that are spatial layers */ if( !oTable.Open(CPLFormFilename(m_osDirName, CPLSPrintf("a%08x", iGDBFeatureClasses + 1), "gdbtable")) ) return FALSE; int iObjectClassID = oTable.GetFieldIdx("ObjectClassID"); int iGeometryType = oTable.GetFieldIdx("GeometryType"); int iShapeField = oTable.GetFieldIdx("ShapeField"); if( iObjectClassID < 0 || iGeometryType < 0 || iShapeField < 0 || oTable.GetField(iObjectClassID)->GetType() != FGFT_INT32 || oTable.GetField(iGeometryType)->GetType() != FGFT_INT32 || oTable.GetField(iShapeField)->GetType() != FGFT_STRING ) { CPLError(CE_Failure, CPLE_AppDefined, "Wrong structure for GDB_FeatureClasses table"); return FALSE; } for(i=0;i<oTable.GetTotalRecordCount();i++) { if( !oTable.SelectRow(i) ) { if( oTable.HasGotError() ) break; continue; } const OGRField* psField; psField = oTable.GetFieldValue(iGeometryType); if( psField == NULL ) continue; int nGeomType = psField->Integer; OGRwkbGeometryType eGeomType = wkbUnknown; switch( nGeomType ) { case FGTGT_NONE: /* doesn't make sense ! */ break; case FGTGT_POINT: eGeomType = wkbPoint; break; case FGTGT_MULTIPOINT: eGeomType = wkbMultiPoint; break; case FGTGT_LINE: eGeomType = wkbMultiLineString; break; case FGTGT_POLYGON: eGeomType = wkbMultiPolygon; break; case FGTGT_MULTIPATCH: eGeomType = wkbMultiPolygon; break; } psField = oTable.GetFieldValue(iShapeField); if( psField == NULL ) continue; CPLString osGeomFieldName(psField->String); psField = oTable.GetFieldValue(iObjectClassID); if( psField == NULL ) continue; int idx = psField->Integer; if( psField != NULL && idx > 0 && idx <= (int)aosName.size() && aosName[idx-1].size() > 0 ) { const std::string osName(aosName[idx-1]); AddLayer( osName, nInterestTable, nCandidateLayers, nLayersSDC, "", "", osGeomFieldName.c_str(), eGeomType); } } if( m_apoLayers.size() == 0 && nCandidateLayers > 0 && nCandidateLayers == nLayersSDC ) return FALSE; return TRUE; }
static void OGR2SQLITE_ogr_datasource_load_layers(sqlite3_context* pContext, int argc, sqlite3_value** argv) { sqlite3* hDB = (sqlite3*) sqlite3_user_data(pContext); if( (argc < 1 || argc > 3) || sqlite3_value_type (argv[0]) != SQLITE_TEXT ) { sqlite3_result_int (pContext, 0); return; } const char* pszDataSource = (const char*) sqlite3_value_text(argv[0]); int bUpdate = FALSE; if( argc >= 2 ) { if( sqlite3_value_type(argv[1]) != SQLITE_INTEGER ) { sqlite3_result_int (pContext, 0); return; } bUpdate = sqlite3_value_int(argv[1]); } const char* pszPrefix = NULL; if( argc >= 3 ) { if( sqlite3_value_type(argv[2]) != SQLITE_TEXT ) { sqlite3_result_int (pContext, 0); return; } pszPrefix = (const char*) sqlite3_value_text(argv[2]); } OGRDataSource* poDS = (OGRDataSource*)OGROpenShared(pszDataSource, bUpdate, NULL); if( poDS == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot open %s", pszDataSource); sqlite3_result_int (pContext, 0); return; } CPLString osEscapedDataSource = OGRSQLiteEscape(pszDataSource); for(int i=0;i<poDS->GetLayerCount();i++) { const char* pszLayerName = poDS->GetLayer(i)->GetName(); CPLString osEscapedLayerName = OGRSQLiteEscape(pszLayerName); CPLString osTableName; if( pszPrefix != NULL ) { osTableName = pszPrefix; osTableName += "_"; osTableName += OGRSQLiteEscapeName(pszLayerName); } else { osTableName = OGRSQLiteEscapeName(pszLayerName); } char* pszErrMsg = NULL; if( sqlite3_exec(hDB, CPLSPrintf( "CREATE VIRTUAL TABLE \"%s\" USING VirtualOGR('%s', %d, '%s')", osTableName.c_str(), osEscapedDataSource.c_str(), bUpdate, osEscapedLayerName.c_str()), NULL, NULL, &pszErrMsg) != SQLITE_OK ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot create table \"%s\" : %s", osTableName.c_str(), pszErrMsg); sqlite3_free(pszErrMsg); } } poDS->Release(); sqlite3_result_int (pContext, 1); }
OGRLayer* OGROpenFileGDBDataSource::ExecuteSQL( const char *pszSQLCommand, OGRGeometry *poSpatialFilter, const char *pszDialect ) { /* -------------------------------------------------------------------- */ /* Special case GetLayerDefinition */ /* -------------------------------------------------------------------- */ if (EQUALN(pszSQLCommand, "GetLayerDefinition ", strlen("GetLayerDefinition "))) { OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*) GetLayerByName(pszSQLCommand + strlen("GetLayerDefinition ")); if (poLayer) { OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer( "LayerDefinition", poLayer->GetXMLDefinition().c_str() ); return poRet; } else return NULL; } /* -------------------------------------------------------------------- */ /* Special case GetLayerMetadata */ /* -------------------------------------------------------------------- */ if (EQUALN(pszSQLCommand, "GetLayerMetadata ", strlen("GetLayerMetadata "))) { OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*) GetLayerByName(pszSQLCommand + strlen("GetLayerMetadata ")); if (poLayer) { OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer( "LayerMetadata", poLayer->GetXMLDocumentation().c_str() ); return poRet; } else return NULL; } /* -------------------------------------------------------------------- */ /* Special case GetLayerAttrIndexUse (only for debugging purposes) */ /* -------------------------------------------------------------------- */ if (EQUALN(pszSQLCommand, "GetLayerAttrIndexUse ", strlen("GetLayerAttrIndexUse "))) { OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*) GetLayerByName(pszSQLCommand + strlen("GetLayerAttrIndexUse ")); if (poLayer) { OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer( "LayerAttrIndexUse", CPLSPrintf("%d", poLayer->GetAttrIndexUse()) ); return poRet; } else return NULL; } /* -------------------------------------------------------------------- */ /* Special case GetLayerSpatialIndexState (only for debugging purposes) */ /* -------------------------------------------------------------------- */ if (EQUALN(pszSQLCommand, "GetLayerSpatialIndexState ", strlen("GetLayerSpatialIndexState "))) { OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*) GetLayerByName(pszSQLCommand + strlen("GetLayerSpatialIndexState ")); if (poLayer) { OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer( "LayerSpatialIndexState", CPLSPrintf("%d", poLayer->GetSpatialIndexState()) ); return poRet; } else return NULL; } /* -------------------------------------------------------------------- */ /* Special case GetLastSQLUsedOptimizedImplementation (only for debugging purposes) */ /* -------------------------------------------------------------------- */ if (EQUAL(pszSQLCommand, "GetLastSQLUsedOptimizedImplementation")) { OGRLayer* poRet = new OGROpenFileGDBSingleFeatureLayer( "GetLastSQLUsedOptimizedImplementation", CPLSPrintf("%d", bLastSQLUsedOptimizedImplementation) ); return poRet; } bLastSQLUsedOptimizedImplementation = FALSE; /* -------------------------------------------------------------------- */ /* Special cases for SQL optimizations */ /* -------------------------------------------------------------------- */ if( EQUALN(pszSQLCommand, "SELECT ", strlen("SELECT ")) && (pszDialect == NULL || EQUAL(pszDialect, "") || EQUAL(pszDialect, "OGRSQL")) && CSLTestBoolean(CPLGetConfigOption("OPENFILEGDB_USE_INDEX", "YES")) ) { swq_select oSelect; if( oSelect.preparse(pszSQLCommand) != OGRERR_NONE ) return NULL; /* -------------------------------------------------------------------- */ /* MIN/MAX/SUM/AVG/COUNT optimization */ /* -------------------------------------------------------------------- */ if( oSelect.join_count == 0 && oSelect.poOtherSelect == NULL && oSelect.table_count == 1 && oSelect.order_specs == 0 && oSelect.query_mode != SWQM_DISTINCT_LIST ) { OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*)GetLayerByName( oSelect.table_defs[0].table_name); if( poLayer ) { OGRMemLayer* poMemLayer = NULL; int i; for(i = 0; i < oSelect.result_columns; i ++ ) { swq_col_func col_func = oSelect.column_defs[i].col_func; if( !(col_func == SWQCF_MIN || col_func == SWQCF_MAX || col_func == SWQCF_COUNT || col_func == SWQCF_AVG || col_func == SWQCF_SUM) ) break; if( oSelect.column_defs[i].field_name == NULL ) break; if( oSelect.column_defs[i].distinct_flag ) break; if( oSelect.column_defs[i].target_type != SWQ_OTHER ) break; int idx = poLayer->GetLayerDefn()->GetFieldIndex( oSelect.column_defs[i].field_name); if( idx < 0 ) break; OGRFieldDefn* poFieldDefn = poLayer->GetLayerDefn()->GetFieldDefn(idx); if( col_func == SWQCF_SUM && poFieldDefn->GetType() == OFTDateTime ) break; int eOutOGRType = -1; int nCount = 0; double dfSum = 0.0; const OGRField* psField = NULL; OGRField sField; if( col_func == SWQCF_MIN || col_func == SWQCF_MAX ) { psField = poLayer->GetMinMaxValue( poFieldDefn, col_func == SWQCF_MIN, eOutOGRType); if( eOutOGRType < 0 ) break; } else { double dfMin = 0.0, dfMax = 0.0; if( !poLayer->GetMinMaxSumCount(poFieldDefn, dfMin, dfMax, dfSum, nCount) ) break; psField = &sField; if( col_func == SWQCF_AVG ) { if( nCount == 0 ) { eOutOGRType = OFTReal; psField = NULL; } else { if( poFieldDefn->GetType() == OFTDateTime ) { eOutOGRType = OFTDateTime; FileGDBDoubleDateToOGRDate(dfSum / nCount, &sField); } else { eOutOGRType = OFTReal; sField.Real = dfSum / nCount; } } } else if( col_func == SWQCF_COUNT ) { sField.Integer = nCount; eOutOGRType = OFTInteger; } else { sField.Real = dfSum; eOutOGRType = OFTReal; } } if( poMemLayer == NULL ) { poMemLayer = new OGRMemLayer("SELECT", NULL, wkbNone); OGRFeature* poFeature = new OGRFeature(poMemLayer->GetLayerDefn()); poMemLayer->CreateFeature(poFeature); delete poFeature; } const char* pszMinMaxFieldName = CPLSPrintf( "%s_%s", (col_func == SWQCF_MIN) ? "MIN" : (col_func == SWQCF_MAX) ? "MAX" : (col_func == SWQCF_AVG) ? "AVG" : (col_func == SWQCF_SUM) ? "SUM" : "COUNT", oSelect.column_defs[i].field_name); OGRFieldDefn oFieldDefn(pszMinMaxFieldName, (OGRFieldType) eOutOGRType); poMemLayer->CreateField(&oFieldDefn); if( psField != NULL ) { OGRFeature* poFeature = poMemLayer->GetFeature(0); poFeature->SetField(oFieldDefn.GetNameRef(), (OGRField*) psField); poMemLayer->SetFeature(poFeature); delete poFeature; } } if( i != oSelect.result_columns ) { delete poMemLayer; } else { CPLDebug("OpenFileGDB", "Using optimized MIN/MAX/SUM/AVG/COUNT implementation"); bLastSQLUsedOptimizedImplementation = TRUE; return poMemLayer; } } } /* -------------------------------------------------------------------- */ /* ORDER BY optimization */ /* -------------------------------------------------------------------- */ if( oSelect.join_count == 0 && oSelect.poOtherSelect == NULL && oSelect.table_count == 1 && oSelect.order_specs == 1 && oSelect.query_mode != SWQM_DISTINCT_LIST ) { OGROpenFileGDBLayer* poLayer = (OGROpenFileGDBLayer*)GetLayerByName( oSelect.table_defs[0].table_name); if( poLayer != NULL && poLayer->HasIndexForField(oSelect.order_defs[0].field_name) ) { OGRErr eErr = OGRERR_NONE; if( oSelect.where_expr != NULL ) { /* The where must be a simple comparison on the column */ /* that is used for ordering */ if( oSelect.where_expr->eNodeType == SNT_OPERATION && OGROpenFileGDBIsComparisonOp(oSelect.where_expr->nOperation) && oSelect.where_expr->nOperation != SWQ_NE && oSelect.where_expr->nSubExprCount == 2 && (oSelect.where_expr->papoSubExpr[0]->eNodeType == SNT_COLUMN || oSelect.where_expr->papoSubExpr[0]->eNodeType == SNT_CONSTANT) && oSelect.where_expr->papoSubExpr[0]->field_type == SWQ_STRING && EQUAL(oSelect.where_expr->papoSubExpr[0]->string_value, oSelect.order_defs[0].field_name) && oSelect.where_expr->papoSubExpr[1]->eNodeType == SNT_CONSTANT ) { /* ok */ } else eErr = OGRERR_FAILURE; } if( eErr == OGRERR_NONE ) { int i; for(i = 0; i < oSelect.result_columns; i ++ ) { if( oSelect.column_defs[i].col_func != SWQCF_NONE ) break; if( oSelect.column_defs[i].field_name == NULL ) break; if( oSelect.column_defs[i].distinct_flag ) break; if( oSelect.column_defs[i].target_type != SWQ_OTHER ) break; if( strcmp(oSelect.column_defs[i].field_name, "*") != 0 && poLayer->GetLayerDefn()->GetFieldIndex( oSelect.column_defs[i].field_name) < 0 ) break; } if( i != oSelect.result_columns ) eErr = OGRERR_FAILURE; } if( eErr == OGRERR_NONE ) { int op = -1; swq_expr_node* poValue = NULL; if( oSelect.where_expr != NULL ) { op = oSelect.where_expr->nOperation; poValue = oSelect.where_expr->papoSubExpr[1]; } FileGDBIterator *poIter = poLayer->BuildIndex( oSelect.order_defs[0].field_name, oSelect.order_defs[0].ascending_flag, op, poValue); /* Check that they are no NULL values */ if( oSelect.where_expr == NULL && poIter->GetRowCount() != poLayer->GetFeatureCount(FALSE) ) { delete poIter; poIter = NULL; } if( poIter != NULL ) { CPLDebug("OpenFileGDB", "Using OGROpenFileGDBSimpleSQLLayer"); bLastSQLUsedOptimizedImplementation = TRUE; return new OGROpenFileGDBSimpleSQLLayer(poLayer, poIter, oSelect.result_columns, oSelect.column_defs); } } } } } return OGRDataSource::ExecuteSQL(pszSQLCommand, poSpatialFilter, pszDialect); }
int OGRDODSSequenceLayer::BuildFields( BaseType *poFieldVar, const char *pszPathToVar, const char *pszPathToSequence ) { OGRFieldDefn oField( "", OFTInteger ); /* -------------------------------------------------------------------- */ /* Setup field name, including path if non-local. */ /* -------------------------------------------------------------------- */ if( pszPathToVar == NULL ) oField.SetName( poFieldVar->name().c_str() ); else oField.SetName( CPLSPrintf( "%s.%s", pszPathToVar, poFieldVar->name().c_str() ) ); /* -------------------------------------------------------------------- */ /* Capture this field definition. */ /* -------------------------------------------------------------------- */ switch( poFieldVar->type() ) { case dods_byte_c: case dods_int16_c: case dods_uint16_c: case dods_int32_c: case dods_uint32_c: if( pszPathToSequence ) oField.SetType( OFTIntegerList ); else oField.SetType( OFTInteger ); break; case dods_float32_c: case dods_float64_c: if( pszPathToSequence ) oField.SetType( OFTRealList ); else oField.SetType( OFTReal ); break; case dods_str_c: case dods_url_c: if( pszPathToSequence ) oField.SetType( OFTStringList ); else oField.SetType( OFTString ); break; case dods_sequence_c: { Sequence *seq = dynamic_cast<Sequence *>( poFieldVar ); Sequence::Vars_iter v_i; // We don't support a 3rd level of sequence nesting. if( pszPathToSequence != NULL ) return FALSE; // We don't explore down into the target sequence if we // are recursing from a supersequence. if( poFieldVar == this->poTargetVar ) return FALSE; for( v_i = seq->var_begin(); v_i != seq->var_end(); v_i++ ) { BuildFields( *v_i, oField.GetNameRef(), oField.GetNameRef() ); } } return FALSE; default: return FALSE; } /* -------------------------------------------------------------------- */ /* Add field to feature defn, and capture mapping. */ /* -------------------------------------------------------------------- */ poFeatureDefn->AddFieldDefn( &oField ); papoFields = (OGRDODSFieldDefn **) CPLRealloc( papoFields, sizeof(void*) * poFeatureDefn->GetFieldCount()); papoFields[poFeatureDefn->GetFieldCount()-1] = new OGRDODSFieldDefn(); papoFields[poFeatureDefn->GetFieldCount()-1]->Initialize( OGRDODSGetVarPath(poFieldVar).c_str(), "dds", poTargetVar, poSuperSeq ); if( pszPathToSequence ) papoFields[poFeatureDefn->GetFieldCount()-1]->pszPathToSequence = CPLStrdup( pszPathToSequence ); return TRUE; }
static GMLFeatureClass* GMLParseFeatureType(CPLXMLNode *psSchemaNode, const char* pszName, CPLXMLNode *psComplexType) { /* -------------------------------------------------------------------- */ /* Grab the sequence of extensions greatgrandchild. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psAttrSeq = CPLGetXMLNode( psComplexType, "complexContent.extension.sequence" ); if( psAttrSeq == NULL ) { return NULL; } /* -------------------------------------------------------------------- */ /* We are pretty sure this going to be a valid Feature class */ /* now, so create it. */ /* -------------------------------------------------------------------- */ GMLFeatureClass *poClass = new GMLFeatureClass( pszName ); /* -------------------------------------------------------------------- */ /* Loop over each of the attribute elements being defined for */ /* this feature class. */ /* -------------------------------------------------------------------- */ CPLXMLNode *psAttrDef; int nAttributeIndex = 0; bool bGotUnrecognizedType = false; for( psAttrDef = psAttrSeq->psChild; psAttrDef != NULL; psAttrDef = psAttrDef->psNext ) { if( strcmp(psAttrDef->pszValue,"group") == 0 ) { /* Too complex schema for us. Aborts parsing */ delete poClass; return NULL; } /* Parse stuff like : <xs:choice> <xs:element ref="gml:polygonProperty"/> <xs:element ref="gml:multiPolygonProperty"/> </xs:choice> as found in https://downloadagiv.blob.core.windows.net/overstromingsgebieden-en-oeverzones/2014_01/Overstromingsgebieden_en_oeverzones_2014_01_GML.zip */ if( strcmp(psAttrDef->pszValue,"choice") == 0 ) { CPLXMLNode* psChild = psAttrDef->psChild; bool bPolygon = false; bool bMultiPolygon = false; for( ; psChild; psChild = psChild->psNext ) { if( psChild->eType != CXT_Element ) continue; if( strcmp(psChild->pszValue,"element") == 0 ) { const char* pszRef = CPLGetXMLValue( psChild, "ref", NULL ); if( pszRef != NULL ) { if( strcmp(pszRef, "gml:polygonProperty") == 0 ) bPolygon = true; else if( strcmp(pszRef, "gml:multiPolygonProperty") == 0 ) bMultiPolygon = true; else { delete poClass; return NULL; } } else { delete poClass; return NULL; } } } if( bPolygon && bMultiPolygon ) { poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( "", "", wkbMultiPolygon, nAttributeIndex, true ) ); nAttributeIndex ++; } continue; } if( !EQUAL(psAttrDef->pszValue,"element") ) continue; /* MapServer WFS writes element type as an attribute of element */ /* not as a simpleType definition */ const char* pszType = CPLGetXMLValue( psAttrDef, "type", NULL ); const char* pszElementName = CPLGetXMLValue( psAttrDef, "name", NULL ); bool bNullable = EQUAL(CPLGetXMLValue( psAttrDef, "minOccurs", "1" ), "0"); const char* pszMaxOccurs = CPLGetXMLValue( psAttrDef, "maxOccurs", NULL ); if (pszType != NULL) { const char* pszStrippedNSType = StripNS(pszType); int nWidth = 0, nPrecision = 0; GMLPropertyType gmlType = GMLPT_Untyped; if (EQUAL(pszStrippedNSType, "string") || EQUAL(pszStrippedNSType, "Character")) gmlType = GMLPT_String; /* TODO: Would be nice to have a proper date type */ else if (EQUAL(pszStrippedNSType, "date") || EQUAL(pszStrippedNSType, "dateTime")) gmlType = GMLPT_String; else if (EQUAL(pszStrippedNSType, "real") || EQUAL(pszStrippedNSType, "double") || EQUAL(pszStrippedNSType, "decimal")) gmlType = GMLPT_Real; else if (EQUAL(pszStrippedNSType, "float") ) gmlType = GMLPT_Float; else if (EQUAL(pszStrippedNSType, "int") || EQUAL(pszStrippedNSType, "integer")) gmlType = GMLPT_Integer; else if (EQUAL(pszStrippedNSType, "long")) gmlType = GMLPT_Integer64; else if (EQUAL(pszStrippedNSType, "short") ) gmlType = GMLPT_Short; else if (EQUAL(pszStrippedNSType, "boolean") ) gmlType = GMLPT_Boolean; else if (strcmp(pszType, "gml:FeaturePropertyType") == 0 ) { gmlType = GMLPT_FeatureProperty; } else if (STARTS_WITH(pszType, "gml:")) { const AssocNameType* psIter = apsPropertyTypes; while(psIter->pszName) { if (strncmp(pszType + 4, psIter->pszName, strlen(psIter->pszName)) == 0) { OGRwkbGeometryType eType = psIter->eType; /* Look if there's a comment restricting to subclasses */ if( psAttrDef->psNext != NULL && psAttrDef->psNext->eType == CXT_Comment ) { if( strstr(psAttrDef->psNext->pszValue, "restricted to Polygon") ) eType = wkbPolygon; else if( strstr(psAttrDef->psNext->pszValue, "restricted to LineString") ) eType = wkbLineString; else if( strstr(psAttrDef->psNext->pszValue, "restricted to MultiPolygon") ) eType = wkbMultiPolygon; else if( strstr(psAttrDef->psNext->pszValue, "restricted to MultiLineString") ) eType = wkbMultiLineString; } poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( pszElementName, pszElementName, eType, nAttributeIndex, bNullable ) ); nAttributeIndex ++; break; } psIter ++; } if (psIter->pszName == NULL) { /* Can be a non geometry gml type */ /* Too complex schema for us. Aborts parsing */ delete poClass; return NULL; } if (poClass->GetGeometryPropertyCount() == 0) bGotUnrecognizedType = true; continue; } /* Integraph stuff */ else if (strcmp(pszType, "G:Point_MultiPointPropertyType") == 0 || strcmp(pszType, "gmgml:Point_MultiPointPropertyType") == 0) { poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( pszElementName, pszElementName, wkbMultiPoint, nAttributeIndex, bNullable ) ); nAttributeIndex ++; continue; } else if (strcmp(pszType, "G:LineString_MultiLineStringPropertyType") == 0 || strcmp(pszType, "gmgml:LineString_MultiLineStringPropertyType") == 0) { poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( pszElementName, pszElementName, wkbMultiLineString, nAttributeIndex, bNullable ) ); nAttributeIndex ++; continue; } else if (strcmp(pszType, "G:Polygon_MultiPolygonPropertyType") == 0 || strcmp(pszType, "gmgml:Polygon_MultiPolygonPropertyType") == 0 || strcmp(pszType, "gmgml:Polygon_Surface_MultiSurface_CompositeSurfacePropertyType") == 0) { poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( pszElementName, pszElementName, wkbMultiPolygon, nAttributeIndex, bNullable ) ); nAttributeIndex ++; continue; } /* ERDAS Apollo stuff (like in http://apollo.erdas.com/erdas-apollo/vector/WORLDWIDE?SERVICE=WFS&VERSION=1.0.0&REQUEST=DescribeFeatureType&TYPENAME=wfs:cntry98) */ else if (strcmp(pszType, "wfs:MixedPolygonPropertyType") == 0) { poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( pszElementName, pszElementName, wkbMultiPolygon, nAttributeIndex, bNullable) ); nAttributeIndex ++; continue; } else { gmlType = GMLPT_Untyped; if ( ! LookForSimpleType(psSchemaNode, pszStrippedNSType, &gmlType, &nWidth, &nPrecision) ) { /* Too complex schema for us. Aborts parsing */ delete poClass; return NULL; } } if (pszElementName == NULL) pszElementName = "unnamed"; const char* pszPropertyName = pszElementName; if( gmlType == GMLPT_FeatureProperty ) { pszPropertyName = CPLSPrintf("%s_href", pszElementName); } GMLPropertyDefn *poProp = new GMLPropertyDefn( pszPropertyName, pszElementName ); if( pszMaxOccurs != NULL && strcmp(pszMaxOccurs, "1") != 0 ) gmlType = GetListTypeFromSingleType(gmlType); poProp->SetType( gmlType ); poProp->SetWidth( nWidth ); poProp->SetPrecision( nPrecision ); poProp->SetNullable( bNullable ); if (poClass->AddProperty( poProp ) < 0) delete poProp; else nAttributeIndex ++; continue; } // For now we skip geometries .. fixup later. CPLXMLNode* psSimpleType = CPLGetXMLNode( psAttrDef, "simpleType" ); if( psSimpleType == NULL ) { const char* pszRef = CPLGetXMLValue( psAttrDef, "ref", NULL ); /* FME .xsd */ if (pszRef != NULL && STARTS_WITH(pszRef, "gml:")) { const AssocNameType* psIter = apsRefTypes; while(psIter->pszName) { if (strncmp(pszRef + 4, psIter->pszName, strlen(psIter->pszName)) == 0) { if (poClass->GetGeometryPropertyCount() > 0) { OGRwkbGeometryType eNewType = psIter->eType; OGRwkbGeometryType eOldType = (OGRwkbGeometryType)poClass->GetGeometryProperty(0)->GetType(); if ((eNewType == wkbMultiPoint && eOldType == wkbPoint) || (eNewType == wkbMultiLineString && eOldType == wkbLineString) || (eNewType == wkbMultiPolygon && eOldType == wkbPolygon)) { poClass->GetGeometryProperty(0)->SetType(eNewType); } else { CPLDebug("GML", "Geometry field already found ! Ignoring the following ones"); } } else { poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( pszElementName, pszElementName, psIter->eType, nAttributeIndex, true ) ); nAttributeIndex ++; } break; } psIter ++; } if (psIter->pszName == NULL) { /* Can be a non geometry gml type */ /* Too complex schema for us. Aborts parsing */ delete poClass; return NULL; } if (poClass->GetGeometryPropertyCount() == 0) bGotUnrecognizedType = true; continue; } /* Parse stuff like the following found in http://199.29.1.81:8181/miwfs/GetFeature.ashx?REQUEST=GetFeature&MAXFEATURES=1&SERVICE=WFS&VERSION=1.0.0&TYPENAME=miwfs:World : <xs:element name="Obj" minOccurs="0" maxOccurs="1"> <xs:complexType> <xs:sequence> <xs:element ref="gml:_Geometry"/> </xs:sequence> </xs:complexType> </xs:element> */ CPLXMLNode* l_psComplexType = GetSingleChildElement( psAttrDef, "complexType" ); CPLXMLNode* psComplexTypeSequence = GetSingleChildElement( l_psComplexType, "sequence" ); CPLXMLNode* psComplexTypeSequenceElement = GetSingleChildElement( psComplexTypeSequence, "element" ); if( pszElementName != NULL && CheckMinMaxOccursCardinality(psAttrDef) && psComplexTypeSequenceElement != NULL && CheckMinMaxOccursCardinality(psComplexTypeSequence) && strcmp(CPLGetXMLValue( psComplexTypeSequenceElement, "ref", "" ), "gml:_Geometry") == 0 ) { poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( pszElementName, pszElementName, wkbUnknown, nAttributeIndex, bNullable ) ); nAttributeIndex ++; continue; } else { /* Too complex schema for us. Aborts parsing */ delete poClass; return NULL; } } if (pszElementName == NULL) pszElementName = "unnamed"; GMLPropertyDefn *poProp = new GMLPropertyDefn( pszElementName, pszElementName ); GMLPropertyType eType = GMLPT_Untyped; int nWidth = 0, nPrecision = 0; GetSimpleTypeProperties(psSimpleType, &eType, &nWidth, &nPrecision); if( pszMaxOccurs != NULL && strcmp(pszMaxOccurs, "1") != 0 ) eType = GetListTypeFromSingleType(eType); poProp->SetType( eType ); poProp->SetWidth( nWidth ); poProp->SetPrecision( nPrecision ); poProp->SetNullable( bNullable ); if (poClass->AddProperty( poProp ) < 0) delete poProp; else nAttributeIndex ++; } /* If we have found an unknown types, let's be on the side of caution and */ /* create a geometry field */ if( poClass->GetGeometryPropertyCount() == 0 && bGotUnrecognizedType ) { poClass->AddGeometryProperty( new GMLGeometryPropertyDefn( "", "", wkbUnknown, -1, true ) ); } /* -------------------------------------------------------------------- */ /* Class complete, add to reader class list. */ /* -------------------------------------------------------------------- */ poClass->SetSchemaLocked( true ); return poClass; }
int Gdal_Contour(maps*& conf,maps*& inputs,maps*& outputs) #endif { fprintf(stderr,"DEBUG HELLO %f %d\n",__FILE__,__LINE__); fflush(stderr); GDALDatasetH hSrcDS; int i, b3D = FALSE, bNoDataSet = FALSE, bIgnoreNoData = FALSE; int nBandIn = 1; double dfInterval = 0.0, dfNoData = 0.0, dfOffset = 0.0; const char *pszSrcFilename = NULL; const char *pszDstFilename = NULL; const char *pszElevAttrib = NULL; const char *pszFormat = "ESRI Shapefile"; char **papszDSCO = NULL, **papszLCO = NULL; double adfFixedLevels[1000]; int nFixedLevelCount = 0; const char *pszNewLayerName = "contour"; int bQuiet = FALSE; GDALProgressFunc pfnProgress = NULL; fprintf(stderr,"DEBUG HELLO %f %d\n",__FILE__,__LINE__); fflush(stderr); #ifndef ZOO_SERVICE /* Check that we are running against at least GDAL 1.4 */ /* Note to developers : if we use newer API, please change the requirement */ if (atoi(GDALVersionInfo("VERSION_NUM")) < 1400) { fprintf(stderr, "At least, GDAL >= 1.4.0 is required for this version of %s, " "which was compiled against GDAL %s\n", argv[0], GDAL_RELEASE_NAME); exit(1); } #endif GDALAllRegister(); OGRRegisterAll(); #ifndef ZOO_SERVICE argc = GDALGeneralCmdLineProcessor( argc, &argv, 0 ); /* -------------------------------------------------------------------- */ /* Parse 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], "--help") ) Usage(); else if( EQUAL(argv[i],"-a") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszElevAttrib = argv[++i]; } else if( EQUAL(argv[i],"-off") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); dfOffset = atof(argv[++i]); } else if( EQUAL(argv[i],"-i") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); dfInterval = atof(argv[++i]); } else if( EQUAL(argv[i],"-fl") ) { if( i >= argc-1 ) Usage(CPLSPrintf("%s option requires at least 1 argument", argv[i])); while( i < argc-1 && nFixedLevelCount < (int)(sizeof(adfFixedLevels)/sizeof(double)) && ArgIsNumeric(argv[i+1]) ) adfFixedLevels[nFixedLevelCount++] = atof(argv[++i]); } else if( EQUAL(argv[i],"-b") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); nBandIn = atoi(argv[++i]); } else if( EQUAL(argv[i],"-f") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszFormat = argv[++i]; } else if( EQUAL(argv[i],"-dsco") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); papszDSCO = CSLAddString(papszDSCO, argv[++i] ); } else if( EQUAL(argv[i],"-lco") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); papszLCO = CSLAddString(papszLCO, argv[++i] ); } else if( EQUAL(argv[i],"-3d") ) { b3D = TRUE; } else if( EQUAL(argv[i],"-snodata") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); bNoDataSet = TRUE; dfNoData = atof(argv[++i]); } else if( EQUAL(argv[i],"-nln") ) { CHECK_HAS_ENOUGH_ADDITIONAL_ARGS(1); pszNewLayerName = argv[++i]; } else if( EQUAL(argv[i],"-inodata") ) { bIgnoreNoData = TRUE; } else if ( EQUAL(argv[i],"-q") || EQUAL(argv[i],"-quiet") ) { bQuiet = TRUE; } else if( pszSrcFilename == NULL ) { pszSrcFilename = argv[i]; } else if( pszDstFilename == NULL ) { pszDstFilename = argv[i]; } else Usage("Too many command options."); } #else bQuiet = TRUE; bIgnoreNoData = TRUE; map* tmpMap=NULL; tmpMap=NULL; tmpMap=getMapFromMaps(inputs,"a","value"); if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){ pszElevAttrib = strdup(tmpMap->value); } tmpMap=getMapFromMaps(inputs,"off","value"); if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){ dfOffset = atof(tmpMap->value); } tmpMap=getMapFromMaps(inputs,"i","value"); if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){ dfInterval = atof(tmpMap->value); } tmpMap=getMapFromMaps(inputs,"b","value"); if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){ nBandIn = atoi(tmpMap->value); } tmpMap=getMapFromMaps(inputs,"InputDSN","value"); if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){ pszSrcFilename = strdup(tmpMap->value); } tmpMap=getMapFromMaps(inputs,"OutputDSN","value"); if(tmpMap!=NULL && strncmp(tmpMap->value,"NULL",4)!=0){ pszDstFilename = strdup(tmpMap->value); } #endif if( dfInterval == 0.0 && nFixedLevelCount == 0 ) { Usage("Neither -i nor -fl are specified."); } if (pszSrcFilename == NULL) { Usage("Missing source filename."); } if (pszDstFilename == NULL) { Usage("Missing destination filename."); } if (!bQuiet) pfnProgress = GDALTermProgress; /* -------------------------------------------------------------------- */ /* Open source raster file. */ /* -------------------------------------------------------------------- */ GDALRasterBandH hBand; hSrcDS = GDALOpen( pszSrcFilename, GA_ReadOnly ); if( hSrcDS == NULL ){ #ifndef ZOO_SERVICE exit( 2 ); #else setMapInMaps(conf,"lenv","message","Unable to open the file"); #endif } hBand = GDALGetRasterBand( hSrcDS, nBandIn ); if( hBand == NULL ) { #ifndef ZOO_SERVICE CPLError( CE_Failure, CPLE_AppDefined, "Band %d does not exist on dataset.", nBandIn ); exit(2); #else char tmp[1024]; sprintf(tmp,"Band %d does not exist on dataset.",nBandIn); setMapInMaps(conf,"lenv","message",tmp); return SERVICE_FAILED; #endif } if( !bNoDataSet && !bIgnoreNoData ) dfNoData = GDALGetRasterNoDataValue( hBand, &bNoDataSet ); /* -------------------------------------------------------------------- */ /* Try to get a coordinate system from the raster. */ /* -------------------------------------------------------------------- */ OGRSpatialReferenceH hSRS = NULL; const char *pszWKT = GDALGetProjectionRef( hSrcDS ); if( pszWKT != NULL && strlen(pszWKT) != 0 ) hSRS = OSRNewSpatialReference( pszWKT ); /* -------------------------------------------------------------------- */ /* Create the outputfile. */ /* -------------------------------------------------------------------- */ OGRDataSourceH hDS; OGRSFDriverH hDriver = OGRGetDriverByName( pszFormat ); OGRFieldDefnH hFld; OGRLayerH hLayer; if( hDriver == NULL ) { #ifndef ZOO_SERVICE fprintf( stderr, "Unable to find format driver named %s.\n", pszFormat ); exit( 10 ); #else char tmp[1024]; sprintf( tmp, "Unable to find format driver named %s.\n", pszFormat ); setMapInMaps(conf,"lenv","message",tmp); return SERVICE_FAILED; #endif } hDS = OGR_Dr_CreateDataSource( hDriver, pszDstFilename, papszDSCO ); if( hDS == NULL ){ #ifndef ZOO_SERVICE exit( 1 ); #else setMapInMaps(conf,"lenv","message","Unable to create the file"); return SERVICE_FAILED; #endif } hLayer = OGR_DS_CreateLayer( hDS, pszNewLayerName, hSRS, b3D ? wkbLineString25D : wkbLineString, papszLCO ); if( hLayer == NULL ) exit( 1 ); hFld = OGR_Fld_Create( "ID", OFTInteger ); OGR_Fld_SetWidth( hFld, 8 ); OGR_L_CreateField( hLayer, hFld, FALSE ); OGR_Fld_Destroy( hFld ); if( pszElevAttrib ) { hFld = OGR_Fld_Create( pszElevAttrib, OFTReal ); OGR_Fld_SetWidth( hFld, 12 ); OGR_Fld_SetPrecision( hFld, 3 ); OGR_L_CreateField( hLayer, hFld, FALSE ); OGR_Fld_Destroy( hFld ); } /* -------------------------------------------------------------------- */ /* Invoke. */ /* -------------------------------------------------------------------- */ CPLErr eErr; eErr = GDALContourGenerate( hBand, dfInterval, dfOffset, nFixedLevelCount, adfFixedLevels, bNoDataSet, dfNoData, hLayer, OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hLayer ), "ID" ), (pszElevAttrib == NULL) ? -1 : OGR_FD_GetFieldIndex( OGR_L_GetLayerDefn( hLayer ), pszElevAttrib ), pfnProgress, NULL ); OGR_DS_Destroy( hDS ); GDALClose( hSrcDS ); if (hSRS) OSRDestroySpatialReference( hSRS ); #ifndef ZOO_SERVICE CSLDestroy( argv ); CSLDestroy( papszDSCO ); CSLDestroy( papszLCO ); GDALDestroyDriverManager(); OGRCleanupAll(); return 0; #else GDALDestroyDriverManager(); OGRCleanupAll(); char tmp[1024]; sprintf(tmp,"File %s successfully created.",pszDstFilename); setMapInMaps(outputs,"Result","value",tmp); return SERVICE_SUCCEEDED; #endif }
GDALDataset *CALSDataset::Open( GDALOpenInfo * poOpenInfo ) { if (!Identify(poOpenInfo) || poOpenInfo->fpL == NULL ) return NULL; const char* pszRPelCnt = strstr((const char*) poOpenInfo->pabyHeader, "rpelcnt:"); int nXSize, nYSize; if( sscanf(pszRPelCnt+strlen("rpelcnt:"),"%d,%d",&nXSize,&nYSize) != 2 || nXSize <= 0 || nYSize <= 0 ) return NULL; const char* pszOrient = strstr((const char*) poOpenInfo->pabyHeader, "rorient:"); int nAngle1, nAngle2; if( sscanf(pszOrient+strlen("rorient:"),"%d,%d",&nAngle1,&nAngle2) != 2 ) return NULL; const char* pszDensity = strstr((const char*) poOpenInfo->pabyHeader, "rdensty:"); int nDensity = 0; if( pszDensity ) sscanf(pszDensity+strlen("rdensty:"), "%d", &nDensity); VSIFSeekL(poOpenInfo->fpL, 0, SEEK_END); int nFAX4BlobSize = (int)VSIFTellL(poOpenInfo->fpL) - 2048; if( nFAX4BlobSize < 0 ) return NULL; CALSDataset* poDS = new CALSDataset(); poDS->nRasterXSize = nXSize; poDS->nRasterYSize = nYSize; // Create a TIFF header for a single-strip CCITTFAX4 file poDS->osTIFFHeaderFilename = CPLSPrintf("/vsimem/cals/header_%p.tiff", poDS); VSILFILE* fp = VSIFOpenL(poDS->osTIFFHeaderFilename, "wb"); const int nTagCount = 10; const int nHeaderSize = 4 + 4 + 2 + nTagCount * 12 + 4; WriteLEInt16(fp, TIFF_LITTLEENDIAN); /* TIFF little-endian signature */ WriteLEInt16(fp, 42); // TIFF classic WriteLEInt32(fp, 8); /* Offset of IFD0 */ WriteLEInt16(fp, nTagCount); /* Number of entries */ WriteTIFFTAG(fp, TIFFTAG_IMAGEWIDTH, TIFF_LONG, nXSize); WriteTIFFTAG(fp, TIFFTAG_IMAGELENGTH, TIFF_LONG, nYSize); WriteTIFFTAG(fp, TIFFTAG_BITSPERSAMPLE, TIFF_SHORT, 1); WriteTIFFTAG(fp, TIFFTAG_COMPRESSION, TIFF_SHORT, COMPRESSION_CCITTFAX4); WriteTIFFTAG(fp, TIFFTAG_PHOTOMETRIC, TIFF_SHORT, PHOTOMETRIC_MINISWHITE); WriteTIFFTAG(fp, TIFFTAG_STRIPOFFSETS, TIFF_LONG, nHeaderSize); WriteTIFFTAG(fp, TIFFTAG_SAMPLESPERPIXEL, TIFF_SHORT, 1); WriteTIFFTAG(fp, TIFFTAG_ROWSPERSTRIP, TIFF_LONG, nYSize); WriteTIFFTAG(fp, TIFFTAG_STRIPBYTECOUNTS, TIFF_LONG, nFAX4BlobSize); WriteTIFFTAG(fp, TIFFTAG_PLANARCONFIG, TIFF_SHORT, PLANARCONFIG_CONTIG); WriteLEInt32(fp, 0); /* Offset of next IFD */ VSIFCloseL(fp); // Create a /vsisparse/ description file assembling the TIFF header // with the FAX4 codestream that starts at offset 2048 of the CALS file poDS->osSparseFilename = CPLSPrintf("/vsimem/cals/sparse_%p.xml", poDS); fp = VSIFOpenL(poDS->osSparseFilename, "wb"); CPLAssert(fp); VSIFPrintfL(fp, "<VSISparseFile>" "<Length>%d</Length>" "<SubfileRegion>" "<Filename relative='0'>%s</Filename>" "<DestinationOffset>0</DestinationOffset>" "<SourceOffset>0</SourceOffset>" "<RegionLength>%d</RegionLength>" "</SubfileRegion>" "<SubfileRegion>" "<Filename relative='0'>%s</Filename>" "<DestinationOffset>%d</DestinationOffset>" "<SourceOffset>%d</SourceOffset>" "<RegionLength>%d</RegionLength>" "</SubfileRegion>" "</VSISparseFile>", nHeaderSize + nFAX4BlobSize, poDS->osTIFFHeaderFilename.c_str(), nHeaderSize, poOpenInfo->pszFilename, nHeaderSize, 2048, nFAX4BlobSize); VSIFCloseL(fp); poDS->poUnderlyingDS = (GDALDataset*) GDALOpenEx( CPLSPrintf("/vsisparse/%s", poDS->osSparseFilename.c_str()), GDAL_OF_RASTER | GDAL_OF_INTERNAL, NULL, NULL, NULL); if( poDS->poUnderlyingDS == NULL ) { delete poDS; return NULL; } if( nAngle1 != 0 || nAngle2 != 270 ) { poDS->SetMetadataItem("PIXEL_PATH", CPLSPrintf("%d", nAngle1)); poDS->SetMetadataItem("LINE_PROGRESSION", CPLSPrintf("%d", nAngle2)); } if( nDensity != 0 ) { poDS->SetMetadataItem("TIFFTAG_XRESOLUTION", CPLSPrintf("%d", nDensity)); poDS->SetMetadataItem("TIFFTAG_YRESOLUTION", CPLSPrintf("%d", nDensity)); poDS->SetMetadataItem("TIFFTAG_RESOLUTIONUNIT", "2 (pixels/inch)"); } poDS->SetBand(1, new CALSRasterBand(poDS)); /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML( poOpenInfo->GetSiblingFiles() ); /* -------------------------------------------------------------------- */ /* Open overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename, poOpenInfo->GetSiblingFiles() ); return( poDS ); }
IntergraphRasterBand::IntergraphRasterBand( IntergraphDataset *poDS, int nBand, int nBandOffset, GDALDataType eType ) { this->poColorTable = new GDALColorTable(); this->poDS = poDS; this->nBand = nBand != 0 ? nBand : poDS->nBands; this->nTiles = 0; this->eDataType = eType; this->pabyBlockBuf = NULL; this->pahTiles = NULL; this->nRGBIndex = 0; this->nBandStart = nBandOffset; this->bTiled = FALSE; // -------------------------------------------------------------------- // Get Header Info // -------------------------------------------------------------------- memcpy(&hHeaderOne, &poDS->hHeaderOne, sizeof(hHeaderOne)); memcpy(&hHeaderTwo, &poDS->hHeaderTwo, sizeof(hHeaderTwo)); // -------------------------------------------------------------------- // Get the image start from Words to Follow (WTF) // -------------------------------------------------------------------- nDataOffset = nBandOffset + 2 + ( 2 * ( hHeaderOne.WordsToFollow + 1 ) ); // -------------------------------------------------------------------- // Get Color Tabel from Color Table Type (CTV) // -------------------------------------------------------------------- uint32 nEntries = hHeaderTwo.NumberOfCTEntries; if( nEntries > 0 ) { switch ( hHeaderTwo.ColorTableType ) { case EnvironVColorTable: INGR_GetEnvironVColors( poDS->fp, nBandOffset, nEntries, poColorTable ); if (poColorTable->GetColorEntryCount() == 0) return; break; case IGDSColorTable: INGR_GetIGDSColors( poDS->fp, nBandOffset, nEntries, poColorTable ); if (poColorTable->GetColorEntryCount() == 0) return; break; default: CPLDebug( "INGR", "Wrong Color table type (%d), number of colors (%d)", hHeaderTwo.ColorTableType, nEntries ); } } // -------------------------------------------------------------------- // Set Dimension // -------------------------------------------------------------------- nRasterXSize = hHeaderOne.PixelsPerLine; nRasterYSize = hHeaderOne.NumberOfLines; nBlockXSize = nRasterXSize; nBlockYSize = 1; // -------------------------------------------------------------------- // Get tile directory // -------------------------------------------------------------------- this->eFormat = (INGR_Format) hHeaderOne.DataTypeCode; this->bTiled = (hHeaderOne.DataTypeCode == TiledRasterData); if( bTiled ) { nTiles = INGR_GetTileDirectory( poDS->fp, nDataOffset, nRasterXSize, nRasterYSize, &hTileDir, &pahTiles ); if (nTiles == 0) return; eFormat = (INGR_Format) hTileDir.DataTypeCode; // ---------------------------------------------------------------- // Set blocks dimensions based on tiles // ---------------------------------------------------------------- nBlockXSize = MIN( hTileDir.TileSize, (uint32) nRasterXSize ); nBlockYSize = MIN( hTileDir.TileSize, (uint32) nRasterYSize ); } if (nBlockXSize <= 0 || nBlockYSize <= 0) { pabyBlockBuf = NULL; CPLError(CE_Failure, CPLE_AppDefined, "Invalid block dimensions"); return; } // -------------------------------------------------------------------- // Incomplete tiles have Block Offset greater than: // -------------------------------------------------------------------- nFullBlocksX = ( nRasterXSize / nBlockXSize ); nFullBlocksY = ( nRasterYSize / nBlockYSize ); // -------------------------------------------------------------------- // Get the Data Type from Format // -------------------------------------------------------------------- this->eDataType = INGR_GetDataType( (uint16) eFormat ); // -------------------------------------------------------------------- // Allocate buffer for a Block of data // -------------------------------------------------------------------- nBlockBufSize = nBlockXSize * nBlockYSize * GDALGetDataTypeSize( eDataType ) / 8; pabyBlockBuf = (GByte*) VSIMalloc3( nBlockXSize, nBlockYSize, GDALGetDataTypeSize( eDataType ) / 8); if (pabyBlockBuf == NULL) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot allocate %d bytes", nBlockBufSize); return; } // -------------------------------------------------------------------- // More Metadata Information // -------------------------------------------------------------------- SetMetadataItem( "FORMAT", INGR_GetFormatName( (uint16) eFormat ), "IMAGE_STRUCTURE" ); if( bTiled ) { SetMetadataItem( "TILESSIZE", CPLSPrintf ("%d", hTileDir.TileSize), "IMAGE_STRUCTURE" ); } else { SetMetadataItem( "TILED", "NO", "IMAGE_STRUCTURE" ); } SetMetadataItem( "ORIENTATION", INGR_GetOrientation( hHeaderOne.ScanlineOrientation ), "IMAGE_STRUCTURE" ); if( eFormat == PackedBinary || eFormat == RunLengthEncoded || eFormat == CCITTGroup4 ) { SetMetadataItem( "NBITS", "1", "IMAGE_STRUCTURE" ); } }
CPLErr GeoRasterRasterBand::SetDefaultRAT( const GDALRasterAttributeTable *poRAT ) { GeoRasterDataset* poGDS = (GeoRasterDataset*) poDS; if( ! poRAT ) { return CE_Failure; } if( poDefaultRAT ) { delete poDefaultRAT; } poDefaultRAT = poRAT->Clone(); // ---------------------------------------------------------- // Format Table description // ---------------------------------------------------------- char szName[OWTEXT]; char szDescription[OWTEXT]; int iCol = 0; strcpy( szDescription, "( ID NUMBER" ); for( iCol = 0; iCol < poRAT->GetColumnCount(); iCol++ ) { strcpy( szName, poRAT->GetNameOfCol( iCol ) ); if( EQUAL( szName, "histogram" ) ) { return CE_None; } strcpy( szDescription, CPLSPrintf( "%s, %s", szDescription, szName ) ); if( poRAT->GetTypeOfCol( iCol ) == GFT_Integer ) { strcpy( szDescription, CPLSPrintf( "%s NUMBER", szDescription ) ); } if( poRAT->GetTypeOfCol( iCol ) == GFT_Real ) { strcpy( szDescription, CPLSPrintf( "%s FLOAT", szDescription ) ); } if( poRAT->GetTypeOfCol( iCol ) == GFT_String ) { strcpy( szDescription, CPLSPrintf( "%s VARCHAR2(128)", szDescription ) ); } } strcpy( szDescription, CPLSPrintf( "%s )", szDescription ) ); // ---------------------------------------------------------- // Create VAT named based on RDT and RID and Layer (nBand) // ---------------------------------------------------------- if( ! pszVATName ) { pszVATName = CPLStrdup( CPLSPrintf( "RAT_%s_%d_%d", poGeoRaster->pszDataTable, poGeoRaster->nRasterId, nBand ) ); } // ---------------------------------------------------------- // Create VAT table // ---------------------------------------------------------- OWStatement* poStmt = poGeoRaster->poConnection->CreateStatement( CPLSPrintf( "DECLARE\n" " TAB VARCHAR2(68) := UPPER(:1);\n" " CNT NUMBER := 0;\n" "BEGIN\n" " EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM USER_TABLES\n" " WHERE TABLE_NAME = :1' INTO CNT USING TAB;\n" "\n" " IF NOT CNT = 0 THEN\n" " EXECUTE IMMEDIATE 'DROP TABLE '||TAB||' PURGE';\n" " END IF;\n" "\n" " EXECUTE IMMEDIATE 'CREATE TABLE '||TAB||' %s';\n" "END;", szDescription ) ); poStmt->Bind( pszVATName ); if( ! poStmt->Execute() ) { delete poStmt; CPLError( CE_Failure, CPLE_AppDefined, "Create VAT Table Error!" ); return CE_Failure; } delete poStmt; // ---------------------------------------------------------- // Insert Data to VAT // ---------------------------------------------------------- int iEntry = 0; int nEntryCount = poRAT->GetRowCount(); int nColunsCount = poRAT->GetColumnCount(); char szInsert[OWTEXT]; CPLString osInserts = "DECLARE\n" " GR1 SDO_GEORASTER := NULL;\n" "BEGIN\n"; for( iEntry = 0; iEntry < nEntryCount; iEntry++ ) { szInsert[0] = '\0'; strcat( szInsert, CPLSPrintf ( " INSERT INTO %s VALUES (%d", pszVATName, iEntry ) ); for( iCol = 0; iCol < nColunsCount; iCol++ ) { if( poRAT->GetTypeOfCol( iCol ) == GFT_String ) { strcat( szInsert, CPLSPrintf ( ", '%s'", poRAT->GetValueAsString( iEntry, iCol ) ) ); } if( poRAT->GetTypeOfCol( iCol ) == GFT_Integer || poRAT->GetTypeOfCol( iCol ) == GFT_Real ) { strcat( szInsert, CPLSPrintf ( ", %s", poRAT->GetValueAsString( iEntry, iCol ) ) ); } } strcat( szInsert, ");\n" ); osInserts += szInsert; } osInserts += CPLSPrintf( " SELECT %s INTO GR1 FROM %s T WHERE\n" " T.%s.RasterDataTable = '%s' AND\n" " T.%s.RasterId = %d FOR UPDATE;\n" " SDO_GEOR.setVAT(GR1, %d, '%s');\n" " UPDATE %s T SET %s = GR1 WHERE\n" " T.%s.RasterDataTable = '%s' AND\n" " T.%s.RasterId = %d;\n" "END;", poGeoRaster->pszColumn, poGeoRaster->pszTable, poGeoRaster->pszColumn, poGeoRaster->pszDataTable, poGeoRaster->pszColumn, poGeoRaster->nRasterId, nBand, pszVATName, poGeoRaster->pszTable, poGeoRaster->pszColumn, poGeoRaster->pszColumn, poGeoRaster->pszDataTable, poGeoRaster->pszColumn, poGeoRaster->nRasterId ); poStmt = poGeoRaster->poConnection->CreateStatement( osInserts.c_str() ); if( ! poStmt->Execute() ) { CPLError( CE_Failure, CPLE_AppDefined, "Insert/registering VAT Error!" ); return CE_Failure; } delete poStmt; poGDS->poGeoRaster->SetVAT( nBand, pszVATName ); return CE_None; }
/** * GDALMDReaderPleiades() */ GDALMDReaderPleiades::GDALMDReaderPleiades(const char *pszPath, char **papszSiblingFiles) : GDALMDReaderBase(pszPath, papszSiblingFiles), m_osBaseFilename( pszPath ), m_osIMDSourceFilename( CPLString() ), m_osRPBSourceFilename( CPLString() ) { const char* pszBaseName = CPLGetBasename(pszPath); size_t nBaseNameLen = strlen(pszBaseName); if( nBaseNameLen < 4 || nBaseNameLen > 511 ) return; const char* pszDirName = CPLGetDirname(pszPath); CPLString osIMDSourceFilename = CPLFormFilename( pszDirName, CPLSPrintf("DIM_%s", pszBaseName + 4), "XML" ); CPLString osRPBSourceFilename = CPLFormFilename( pszDirName, CPLSPrintf("RPC_%s", pszBaseName + 4), "XML" ); // find last underline char sBaseName[512]; size_t nLastUnderline = 0; for(size_t i = 4; i < nBaseNameLen; i++) { sBaseName[i - 4] = pszBaseName[i]; if(pszBaseName[i] == '_') nLastUnderline = i - 4U; } sBaseName[nLastUnderline] = 0; if (CPLCheckForFile(&osIMDSourceFilename[0], papszSiblingFiles)) { m_osIMDSourceFilename = osIMDSourceFilename; } else { osIMDSourceFilename = CPLFormFilename( pszDirName, CPLSPrintf("DIM_%s", sBaseName), "XML" ); if (CPLCheckForFile(&osIMDSourceFilename[0], papszSiblingFiles)) { m_osIMDSourceFilename = osIMDSourceFilename; } } if (CPLCheckForFile(&osRPBSourceFilename[0], papszSiblingFiles)) { m_osRPBSourceFilename = osRPBSourceFilename; } else { osRPBSourceFilename = CPLFormFilename( pszDirName, CPLSPrintf("RPC_%s", sBaseName), "XML" ); if (CPLCheckForFile(&osRPBSourceFilename[0], papszSiblingFiles)) { m_osRPBSourceFilename = osRPBSourceFilename; } } if( !m_osIMDSourceFilename.empty() ) CPLDebug( "MDReaderPleiades", "IMD Filename: %s", m_osIMDSourceFilename.c_str() ); if( !m_osRPBSourceFilename.empty() ) CPLDebug( "MDReaderPleiades", "RPB Filename: %s", m_osRPBSourceFilename.c_str() ); }