static bool CPLHasLibXMLBug() { if (bHasLibXMLBug >= 0) return CPL_TO_BOOL(bHasLibXMLBug); static const char szLibXMLBugTester[] = "<schema targetNamespace=\"http://foo\" xmlns:foo=\"http://foo\" xmlns=\"http://www.w3.org/2001/XMLSchema\">" "<simpleType name=\"t1\">" "<list itemType=\"double\"/>" "</simpleType>" "<complexType name=\"t2\">" "<simpleContent>" "<extension base=\"foo:t1\"/>" "</simpleContent>" "</complexType>" "<complexType name=\"t3\">" "<simpleContent>" "<restriction base=\"foo:t2\">" "<length value=\"2\"/>" "</restriction>" "</simpleContent>" "</complexType>" "</schema>"; xmlSchemaParserCtxtPtr pSchemaParserCtxt; xmlSchemaPtr pSchema; pSchemaParserCtxt = xmlSchemaNewMemParserCtxt(szLibXMLBugTester, strlen(szLibXMLBugTester)); xmlSchemaSetParserErrors(pSchemaParserCtxt, CPLHasLibXMLBugWarningCallback, CPLHasLibXMLBugWarningCallback, NULL); pSchema = xmlSchemaParse(pSchemaParserCtxt); xmlSchemaFreeParserCtxt(pSchemaParserCtxt); bHasLibXMLBug = (pSchema == NULL); if (pSchema) xmlSchemaFree(pSchema); if (bHasLibXMLBug) { CPLDebug("CPL", "LibXML bug found (cf https://bugzilla.gnome.org/show_bug.cgi?id=630130). " "Will try to workaround for GML schemas."); } return CPL_TO_BOOL(bHasLibXMLBug); }
OGRFieldType GeoJSONStringPropertyToFieldType( json_object* poObject ) { if( poObject == NULL ) { return OFTString; } const char* pszStr = json_object_get_string( poObject ); OGRField sWrkField; CPLPushErrorHandler(CPLQuietErrorHandler); const bool bSuccess = CPL_TO_BOOL(OGRParseDate( pszStr, &sWrkField, 0 )); CPLPopErrorHandler(); CPLErrorReset(); if( bSuccess ) { const bool bHasDate = strchr( pszStr, '/' ) != NULL || strchr( pszStr, '-' ) != NULL; const bool bHasTime = strchr( pszStr, ':' ) != NULL; if( bHasDate && bHasTime ) return OFTDateTime; else if( bHasDate ) return OFTDate; else return OFTTime; // TODO: What if both are false? } return OFTString; }
static void AppendCoordinateList( OGRLineString *poLine, char **ppszText, size_t *pnLength, size_t *pnMaxLength ) { char szCoordinate[256]= { 0 }; const bool b3D = CPL_TO_BOOL(wkbHasZ(poLine->getGeometryType())); *pnLength += strlen(*ppszText + *pnLength); _GrowBuffer( *pnLength + 20, ppszText, pnMaxLength ); strcat( *ppszText + *pnLength, "<coordinates>" ); *pnLength += strlen(*ppszText + *pnLength); for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ ) { MakeKMLCoordinate( szCoordinate, sizeof(szCoordinate), poLine->getX(iPoint), poLine->getY(iPoint), poLine->getZ(iPoint), b3D ); _GrowBuffer( *pnLength + strlen(szCoordinate)+1, ppszText, pnMaxLength ); if( iPoint != 0 ) strcat( *ppszText + *pnLength, " " ); strcat( *ppszText + *pnLength, szCoordinate ); *pnLength += strlen(*ppszText + *pnLength); } _GrowBuffer( *pnLength + 20, ppszText, pnMaxLength ); strcat( *ppszText + *pnLength, "</coordinates>" ); *pnLength += strlen(*ppszText + *pnLength); }
VSILFILE *VSIFOpenExL( const char * pszFilename, const char * pszAccess, int bSetError ) { VSIFilesystemHandler *poFSHandler = VSIFileManager::GetHandler( pszFilename ); VSILFILE* fp = reinterpret_cast<VSILFILE *>( poFSHandler->Open( pszFilename, pszAccess, CPL_TO_BOOL(bSetError) ) ); VSIDebug4( "VSIFOpenExL(%s,%s,%d) = %p", pszFilename, pszAccess, bSetError, fp ); return fp; }
static void AppendCoordinateList( OGRLineString *poLine, VSILFILE* fp ) { const bool b3D = CPL_TO_BOOL(wkbHasZ(poLine->getGeometryType())); for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ ) { VSIFPrintfL(fp, "<COORD>"); VSIFPrintfL(fp, "<C1>%s</C1>", d2str(poLine->getX(iPoint))); VSIFPrintfL(fp, "<C2>%s</C2>", d2str(poLine->getY(iPoint))); if (b3D) VSIFPrintfL(fp, "<C3>%s</C3>", d2str(poLine->getZ(iPoint))); VSIFPrintfL(fp, "</COORD>\n"); } }
static void AppendCoordinateList( OGRLineString *poLine, OGRILI1DataSource *poDS ) { const bool b3D = CPL_TO_BOOL(wkbHasZ(poLine->getGeometryType())); for( int iPoint = 0; iPoint < poLine->getNumPoints(); iPoint++ ) { if (iPoint == 0) VSIFPrintfL( poDS->GetTransferFile(), "STPT" ); else VSIFPrintfL( poDS->GetTransferFile(), "LIPT" ); VSIFPrintfL( poDS->GetTransferFile(), " %s", d2str(poLine->getX(iPoint)) ); VSIFPrintfL( poDS->GetTransferFile(), " %s", d2str(poLine->getY(iPoint)) ); if( b3D ) VSIFPrintfL( poDS->GetTransferFile(), " %s", d2str(poLine->getZ(iPoint)) ); VSIFPrintfL( poDS->GetTransferFile(), "\n" ); } VSIFPrintfL( poDS->GetTransferFile(), "ELIN\n" ); }
OGRLayer *OGRVRTDataSource::InstantiateLayer( CPLXMLNode *psLTree, const char *pszVRTDirectory, int bUpdate, int nRecLevel ) { if( poLayerPool != nullptr && EQUAL(psLTree->pszValue,"OGRVRTLayer")) { PooledInitData *pData = (PooledInitData *)CPLMalloc(sizeof(PooledInitData)); pData->poDS = this; pData->psNode = psLTree; pData->pszVRTDirectory = CPLStrdup(pszVRTDirectory); pData->bUpdate = CPL_TO_BOOL(bUpdate); return new OGRProxiedLayer(poLayerPool, OGRVRTOpenProxiedLayer, OGRVRTFreeProxiedLayerUserData, pData); } return InstantiateLayerInternal(psLTree, pszVRTDirectory, bUpdate, nRecLevel); }
int OGRProj4CT::Transform( int nCount, double *x, double *y, double *z ) { int *pabSuccess = (int *) CPLMalloc(sizeof(int) * nCount ); bool bOverallSuccess = CPL_TO_BOOL(TransformEx( nCount, x, y, z, pabSuccess )); for( int i = 0; i < nCount; i++ ) { if( !pabSuccess[i] ) { bOverallSuccess = false; break; } } CPLFree( pabSuccess ); return bOverallSuccess; }
void GDALDefaultOverviews::Initialize( GDALDataset *poDSIn, const char * pszBasename, char **papszSiblingFiles, int bNameIsOVR ) { poDS = poDSIn; /* -------------------------------------------------------------------- */ /* If we were already initialized, destroy the old overview */ /* file handle. */ /* -------------------------------------------------------------------- */ if( poODS != NULL ) { GDALClose( poODS ); poODS = NULL; CPLDebug( "GDAL", "GDALDefaultOverviews::Initialize() called twice - " "this is odd and perhaps dangerous!" ); } /* -------------------------------------------------------------------- */ /* Store the initialization information for later use in */ /* OverviewScan() */ /* -------------------------------------------------------------------- */ bCheckedForOverviews = FALSE; CPLFree( pszInitName ); pszInitName = NULL; if( pszBasename != NULL ) pszInitName = CPLStrdup(pszBasename); bInitNameIsOVR = CPL_TO_BOOL(bNameIsOVR); CSLDestroy( papszInitSiblingFiles ); papszInitSiblingFiles = NULL; if( papszSiblingFiles != NULL ) papszInitSiblingFiles = CSLDuplicate(papszSiblingFiles); }
OGRErr OGRLinearRing::transform( OGRCoordinateTransformation *poCT ) { const bool bIsClosed = getNumPoints() > 2 && CPL_TO_BOOL(get_IsClosed()); OGRErr eErr = OGRLineString::transform(poCT); if( bIsClosed && eErr == OGRERR_NONE && !get_IsClosed() ) { CPLDebug("OGR", "Linearring is not closed after coordinate " "transformation. Forcing last point to be identical to " "first one"); // Force last point to be identical to first point. // This is a safety belt in case the reprojection of the same coordinate // isn't perfectly stable. This can for example happen in very rare cases // when reprojecting a cutline with a RPC transform with a DEM that // is a VRT whose sources are resampled... OGRPoint oStartPoint; StartPoint( &oStartPoint ); setPoint( getNumPoints()-1, &oStartPoint); } return eErr; }
int OGRGmtDataSource::Open( const char *pszFilename, int bUpdateIn ) { bUpdate = CPL_TO_BOOL( bUpdateIn ); OGRGmtLayer *poLayer = new OGRGmtLayer( pszFilename, bUpdate ); if( !poLayer->bValidFile ) { delete poLayer; return FALSE; } papoLayers = static_cast<OGRGmtLayer **>( CPLRealloc( papoLayers, (nLayers + 1) *sizeof(OGRGmtLayer*)) ); papoLayers[nLayers] = poLayer; nLayers ++; CPLFree (pszName); pszName = CPLStrdup( pszFilename ); return TRUE; }
OGRDataSource *OGRGeoconceptDriver::Open( const char* pszFilename, int bUpdate ) { #ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION /* -------------------------------------------------------------------- */ /* We will only consider .gxt and .txt files. */ /* -------------------------------------------------------------------- */ const char* pszExtension = CPLGetExtension(pszFilename); if( !EQUAL(pszExtension,"gxt") && !EQUAL(pszExtension,"txt") ) { return nullptr; } #endif OGRGeoconceptDataSource *poDS = new OGRGeoconceptDataSource(); if( !poDS->Open( pszFilename, true, CPL_TO_BOOL(bUpdate) ) ) { delete poDS; return nullptr; } return poDS; }
void OGRCloudantTableLayer::LoadMetadata() { if( bHasLoadedMetadata ) return; bHasLoadedMetadata = true; if (pszSpatialDDoc == nullptr) GetSpatialView(); if( pszSpatialDDoc == nullptr ) return; CPLString osURI("/"); osURI += osEscapedName; osURI += "/"; osURI += pszSpatialDDoc; json_object* poAnswerObj = poDS->GET(osURI); if (poAnswerObj == nullptr) return; if ( !json_object_is_type(poAnswerObj, json_type_object) ) { CPLError(CE_Failure, CPLE_AppDefined, "LoadMetadata() failed"); json_object_put(poAnswerObj); return; } json_object* poRev = CPL_json_object_object_get(poAnswerObj, "_rev"); const char* pszRev = json_object_get_string(poRev); if (pszRev) osMetadataRev = pszRev; json_object* poError = CPL_json_object_object_get(poAnswerObj, "error"); const char* pszError = json_object_get_string(poError); if (pszError && strcmp(pszError, "not_found") == 0) { json_object_put(poAnswerObj); return; } if (poDS->IsError(poAnswerObj, "LoadMetadata() failed")) { json_object_put(poAnswerObj); return; } json_object* poJsonSRS = CPL_json_object_object_get(poAnswerObj, "srsid"); const char* pszSRS = json_object_get_string(poJsonSRS); if (pszSRS != nullptr) { poSRS = new OGRSpatialReference(); if (poSRS->importFromURN(pszSRS) != OGRERR_NONE) { delete poSRS; poSRS = nullptr; } } json_object* poGeomType = CPL_json_object_object_get(poAnswerObj, "geomtype"); const char* pszGeomType = json_object_get_string(poGeomType); if (pszGeomType) { if (EQUAL(pszGeomType, "NONE")) { eGeomType = wkbNone; bExtentValid = true; } else { eGeomType = OGRFromOGCGeomType(pszGeomType); json_object* poIs25D = CPL_json_object_object_get(poAnswerObj, "is_25D"); if (poIs25D && json_object_get_boolean(poIs25D)) eGeomType = wkbSetZ(eGeomType); json_object* poExtent = CPL_json_object_object_get(poAnswerObj, "extent"); if (poExtent && json_object_get_type(poExtent) == json_type_object) { json_object* poBbox = CPL_json_object_object_get(poExtent, "bbox"); if (poBbox && json_object_get_type(poBbox) == json_type_array && json_object_array_length(poBbox) == 4 && OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 0)) && OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 1)) && OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 2)) && OGRCloudantIsNumericObject(json_object_array_get_idx(poBbox, 3))) { dfMinX = json_object_get_double(json_object_array_get_idx(poBbox, 0)); dfMinY = json_object_get_double(json_object_array_get_idx(poBbox, 1)); dfMaxX = json_object_get_double(json_object_array_get_idx(poBbox, 2)); dfMaxY = json_object_get_double(json_object_array_get_idx(poBbox, 3)); bExtentValid = true; bExtentSet = true; } } } } json_object* poGeoJSON = CPL_json_object_object_get(poAnswerObj, "geojson_documents"); if (poGeoJSON && json_object_is_type(poGeoJSON, json_type_boolean)) bGeoJSONDocument = CPL_TO_BOOL(json_object_get_boolean(poGeoJSON)); json_object* poFields = CPL_json_object_object_get(poAnswerObj, "fields"); if (poFields && json_object_is_type(poFields, json_type_array)) { poFeatureDefn = new OGRFeatureDefn( osName ); poFeatureDefn->Reference(); poFeatureDefn->SetGeomType(eGeomType); if( poFeatureDefn->GetGeomFieldCount() != 0 ) poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poSRS); OGRFieldDefn oFieldId("_id", OFTString); poFeatureDefn->AddFieldDefn(&oFieldId); OGRFieldDefn oFieldRev("_rev", OFTString); poFeatureDefn->AddFieldDefn(&oFieldRev); int nFields = json_object_array_length(poFields); for(int i=0;i<nFields;i++) { json_object* poField = json_object_array_get_idx(poFields, i); if (poField && json_object_is_type(poField, json_type_object)) { json_object* poName = CPL_json_object_object_get(poField, "name"); const char* pszName = json_object_get_string(poName); if (pszName) { json_object* poType = CPL_json_object_object_get(poField, "type"); const char* pszType = json_object_get_string(poType); OGRFieldType eType = OFTString; if (pszType) { if (strcmp(pszType, "integer") == 0) eType = OFTInteger; else if (strcmp(pszType, "integerlist") == 0) eType = OFTIntegerList; else if (strcmp(pszType, "real") == 0) eType = OFTReal; else if (strcmp(pszType, "reallist") == 0) eType = OFTRealList; else if (strcmp(pszType, "string") == 0) eType = OFTString; else if (strcmp(pszType, "stringlist") == 0) eType = OFTStringList; } OGRFieldDefn oField(pszName, eType); poFeatureDefn->AddFieldDefn(&oField); } } } } std::sort(aosIdsToFetch.begin(), aosIdsToFetch.end()); json_object_put(poAnswerObj); return; }
GDALDataset *FASTDataset::Open( GDALOpenInfo * poOpenInfo ) { if( poOpenInfo->nHeaderBytes < 1024) return NULL; if( !EQUALN((const char *) poOpenInfo->pabyHeader + 52, "ACQUISITION DATE =", 18) && !EQUALN((const char *) poOpenInfo->pabyHeader + 36, "ACQUISITION DATE =", 18) ) return NULL; /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ FASTDataset *poDS = new FASTDataset(); poDS->fpHeader = VSIFOpenL(poOpenInfo->pszFilename, "rb"); if (poDS->fpHeader == NULL) { delete poDS; return NULL; } poDS->pszFilename = poOpenInfo->pszFilename; poDS->pszDirname = CPLStrdup( CPLGetDirname( poOpenInfo->pszFilename ) ); /* -------------------------------------------------------------------- */ /* Read the administrative record. */ /* -------------------------------------------------------------------- */ char *pszHeader = static_cast<char *>( CPLMalloc( ADM_HEADER_SIZE + 1 ) ); size_t nBytesRead = 0; if( VSIFSeekL( poDS->fpHeader, 0, SEEK_SET ) >= 0 ) nBytesRead = VSIFReadL( pszHeader, 1, ADM_HEADER_SIZE, poDS->fpHeader ); if ( nBytesRead < ADM_MIN_HEADER_SIZE ) { CPLDebug( "FAST", "Header file too short. Reading failed" ); CPLFree(pszHeader); delete poDS; return NULL; } pszHeader[nBytesRead] = '\0'; // Read acquisition date char *pszTemp = GetValue( pszHeader, ACQUISITION_DATE, ACQUISITION_DATE_SIZE, TRUE ); if (pszTemp == NULL) { CPLDebug( "FAST", "Cannot get ACQUISITION_DATE, using empty value." ); pszTemp = CPLStrdup(""); } poDS->SetMetadataItem( "ACQUISITION_DATE", pszTemp ); CPLFree( pszTemp ); // Read satellite name (will read the first one only) pszTemp = GetValue( pszHeader, SATELLITE_NAME, SATELLITE_NAME_SIZE, TRUE ); if (pszTemp == NULL) { CPLDebug( "FAST", "Cannot get SATELLITE_NAME, using empty value." ); pszTemp = CPLStrdup( "" ); } poDS->SetMetadataItem( "SATELLITE", pszTemp ); if ( STARTS_WITH_CI(pszTemp, "LANDSAT") ) poDS->iSatellite = LANDSAT; // TODO(schwehr): Was this a bug that both are IRS? // else if ( STARTS_WITH_CI(pszTemp, "IRS") ) // poDS->iSatellite = IRS; else poDS->iSatellite = IRS; // TODO(schwehr): Should this be FAST_UNKNOWN? CPLFree( pszTemp ); // Read sensor name (will read the first one only) pszTemp = GetValue( pszHeader, SENSOR_NAME, SENSOR_NAME_SIZE, TRUE ); if (pszTemp == NULL) { CPLDebug( "FAST", "Cannot get SENSOR_NAME, using empty value." ); pszTemp = CPLStrdup(""); } poDS->SetMetadataItem( "SENSOR", pszTemp ); CPLFree( pszTemp ); // Read filenames poDS->nBands = 0; if (strstr( pszHeader, FILENAME ) == NULL) { if (strstr(pszHeader, "GENERATING AGENCY =EUROMAP")) { // If we don't find the FILENAME field, let's try with the Euromap // PAN / LISS3 / WIFS IRS filename convention. if ((EQUAL(poDS->GetMetadataItem("SATELLITE"), "IRS 1C") || EQUAL(poDS->GetMetadataItem("SATELLITE"), "IRS 1D")) && (EQUAL(poDS->GetMetadataItem("SENSOR"), "PAN") || EQUAL(poDS->GetMetadataItem("SENSOR"), "LISS3") || EQUAL(poDS->GetMetadataItem("SENSOR"), "WIFS"))) { poDS->TryEuromap_IRS_1C_1D_ChannelNameConvention(); } else if (EQUAL(poDS->GetMetadataItem("SATELLITE"), "CARTOSAT-1") && (EQUAL(poDS->GetMetadataItem("SENSOR"), "FORE") || EQUAL(poDS->GetMetadataItem("SENSOR"), "AFT"))) { // See appendix F in // http://www.euromap.de/download/p5fast_20050301.pdf const CPLString osSuffix = CPLGetExtension( poDS->pszFilename ); const char *papszBasenames[] = { "BANDF", "bandf", "BANDA", "banda" }; for ( int i = 0; i < 4; i++ ) { const CPLString osChannelFilename = CPLFormFilename( poDS->pszDirname, papszBasenames[i], osSuffix ); if( poDS->OpenChannel( osChannelFilename, 0 ) ) { poDS->nBands = 1; break; } } } else if( EQUAL(poDS->GetMetadataItem("SATELLITE"), "IRS P6") ) { // If BANDS_PRESENT="2345", the file bands are "BAND2.DAT", // "BAND3.DAT", etc. pszTemp = GetValue( pszHeader, BANDS_PRESENT, BANDS_PRESENT_SIZE, TRUE ); if (pszTemp) { for( int i=0; pszTemp[i] != '\0'; i++ ) { if( pszTemp[i] >= '2' && pszTemp[i] <= '5' ) { if( poDS->FOpenChannel( poDS->pszFilename, poDS->nBands, pszTemp[i] - '0')) poDS->nBands++; } } CPLFree( pszTemp ); } } } } // If the previous lookup for band files didn't success, fallback to the // standard way of finding them, either by the FILENAME field, either with // the usual patterns like bandX.dat, etc. if( !poDS->nBands ) { pszTemp = pszHeader; for ( int i = 0; i < 7; i++ ) { char *pszFilename = NULL ; if ( pszTemp ) pszTemp = strstr( pszTemp, FILENAME ); if ( pszTemp ) { // Skip the parameter name pszTemp += strlen(FILENAME); // Skip whitespaces and equal signs while ( *pszTemp == ' ' ) pszTemp++; while ( *pszTemp == '=' ) pszTemp++; pszFilename = CPLScanString( pszTemp, FILENAME_SIZE, TRUE, FALSE ); } else pszTemp = NULL; if ( poDS->FOpenChannel( pszFilename, poDS->nBands, poDS->nBands + 1 ) ) poDS->nBands++; if ( pszFilename ) CPLFree( pszFilename ); } } if ( !poDS->nBands ) { CPLError( CE_Failure, CPLE_NotSupported, "Failed to find and open band data files." ); CPLFree(pszHeader); delete poDS; return NULL; } // Read number of pixels/lines and bit depth pszTemp = GetValue( pszHeader, PIXELS, PIXELS_SIZE, FALSE ); if ( pszTemp ) { poDS->nRasterXSize = atoi( pszTemp ); CPLFree( pszTemp ); } else { CPLDebug( "FAST", "Failed to find number of pixels in line." ); CPLFree(pszHeader); delete poDS; return NULL; } pszTemp = GetValue( pszHeader, LINES1, LINES_SIZE, FALSE ); if ( !pszTemp ) pszTemp = GetValue( pszHeader, LINES2, LINES_SIZE, FALSE ); if ( pszTemp ) { poDS->nRasterYSize = atoi( pszTemp ); CPLFree( pszTemp ); } else { CPLDebug( "FAST", "Failed to find number of lines in raster." ); CPLFree(pszHeader); delete poDS; return NULL; } if (!GDALCheckDatasetDimensions(poDS->nRasterXSize, poDS->nRasterYSize)) { CPLFree(pszHeader); delete poDS; return NULL; } pszTemp = GetValue( pszHeader, BITS_PER_PIXEL, BITS_PER_PIXEL_SIZE, FALSE ); if ( pszTemp ) { switch( atoi(pszTemp) ) { case 8: default: poDS->eDataType = GDT_Byte; break; // For a strange reason, some Euromap products declare 10 bits // output, but are 16 bits. case 10: case 16: poDS->eDataType = GDT_UInt16; break; } CPLFree( pszTemp ); } else { poDS->eDataType = GDT_Byte; } /* -------------------------------------------------------------------- */ /* Read radiometric record. */ /* -------------------------------------------------------------------- */ const char *pszFirst = NULL; const char *pszSecond = NULL; // Read gains and biases. This is a trick! pszTemp = strstr( pszHeader, "BIASES" );// It may be "BIASES AND GAINS" // or "GAINS AND BIASES" const char* pszGains = strstr( pszHeader, "GAINS" ); if( pszTemp == NULL || pszGains == NULL ) { CPLDebug( "FAST", "No BIASES and/or GAINS" ); CPLFree( pszHeader ); delete poDS; return NULL; } if ( pszTemp > pszGains ) { pszFirst = "GAIN%d"; pszSecond = "BIAS%d"; } else { pszFirst = "BIAS%d"; pszSecond = "GAIN%d"; } // Now search for the first number occurrence after that string. for ( int i = 1; i <= poDS->nBands; i++ ) { char *pszValue = NULL; size_t nValueLen = VALUE_SIZE; pszTemp = strpbrk( pszTemp, "-.0123456789" ); if ( pszTemp ) { nValueLen = strspn( pszTemp, "+-.0123456789" ); pszValue = CPLScanString( pszTemp, static_cast<int>(nValueLen), TRUE, TRUE ); poDS->SetMetadataItem( CPLSPrintf(pszFirst, i ), pszValue ); CPLFree( pszValue ); } pszTemp += nValueLen; pszTemp = strpbrk( pszTemp, "-.0123456789" ); if ( pszTemp ) { nValueLen = strspn( pszTemp, "+-.0123456789" ); pszValue = CPLScanString( pszTemp, static_cast<int>(nValueLen), TRUE, TRUE ); poDS->SetMetadataItem( CPLSPrintf(pszSecond, i ), pszValue ); CPLFree( pszValue ); } pszTemp += nValueLen; } /* -------------------------------------------------------------------- */ /* Read geometric record. */ /* -------------------------------------------------------------------- */ // Coordinates of pixel's centers double dfULX = 0.0; double dfULY = 0.0; double dfURX = 0.0; double dfURY = 0.0; double dfLLX = 0.0; double dfLLY = 0.0; double dfLRX = 0.0; double dfLRY = 0.0; // Read projection name pszTemp = GetValue( pszHeader, PROJECTION_NAME, PROJECTION_NAME_SIZE, FALSE ); long iProjSys = 0; if ( pszTemp && !EQUAL( pszTemp, "" ) ) iProjSys = USGSMnemonicToCode( pszTemp ); else iProjSys = 1L; // UTM by default CPLFree( pszTemp ); // Read ellipsoid name pszTemp = GetValue( pszHeader, ELLIPSOID_NAME, ELLIPSOID_NAME_SIZE, FALSE ); long iDatum = 0; // Clarke, 1866 (NAD1927) by default. if ( pszTemp && !EQUAL( pszTemp, "" ) ) iDatum = USGSEllipsoidToCode( pszTemp ); CPLFree( pszTemp ); // Read zone number. pszTemp = GetValue( pszHeader, ZONE_NUMBER, ZONE_NUMBER_SIZE, FALSE ); long iZone = 0; if ( pszTemp && !EQUAL( pszTemp, "" ) ) iZone = atoi( pszTemp ); CPLFree( pszTemp ); // Read 15 USGS projection parameters double adfProjParms[15] = { 0.0 }; pszTemp = strstr( pszHeader, USGS_PARAMETERS ); if ( pszTemp && !EQUAL( pszTemp, "" ) ) { pszTemp += strlen( USGS_PARAMETERS ); for ( int i = 0; i < 15; i++ ) { pszTemp = strpbrk( pszTemp, "-.0123456789" ); if ( pszTemp ) adfProjParms[i] = CPLScanDouble( pszTemp, VALUE_SIZE ); pszTemp = strpbrk( pszTemp, " \t" ); } } // Coordinates should follow the word "PROJECTION", otherwise we can // be confused by other occurrences of the corner keywords. char *pszGeomRecord = strstr( pszHeader, "PROJECTION" ); // Read corner coordinates pszTemp = strstr( pszGeomRecord, CORNER_UPPER_LEFT ); if ( pszTemp && !EQUAL( pszTemp, "" ) ) { pszTemp += strlen( CORNER_UPPER_LEFT ) + 28; dfULX = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE ); pszTemp += CORNER_VALUE_SIZE + 1; dfULY = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE ); } pszTemp = strstr( pszGeomRecord, CORNER_UPPER_RIGHT ); if ( pszTemp && !EQUAL( pszTemp, "" ) ) { pszTemp += strlen( CORNER_UPPER_RIGHT ) + 28; dfURX = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE ); pszTemp += CORNER_VALUE_SIZE + 1; dfURY = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE ); } pszTemp = strstr( pszGeomRecord, CORNER_LOWER_LEFT ); if ( pszTemp && !EQUAL( pszTemp, "" ) ) { pszTemp += strlen( CORNER_LOWER_LEFT ) + 28; dfLLX = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE ); pszTemp += CORNER_VALUE_SIZE + 1; dfLLY = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE ); } pszTemp = strstr( pszGeomRecord, CORNER_LOWER_RIGHT ); if ( pszTemp && !EQUAL( pszTemp, "" ) ) { pszTemp += strlen( CORNER_LOWER_RIGHT ) + 28; dfLRX = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE ); pszTemp += CORNER_VALUE_SIZE + 1; dfLRY = CPLScanDouble( pszTemp, CORNER_VALUE_SIZE ); } if ( dfULX != 0.0 && dfULY != 0.0 && dfURX != 0.0 && dfURY != 0.0 && dfLLX != 0.0 && dfLLY != 0.0 && dfLRX != 0.0 && dfLRY != 0.0 ) { // Strip out zone number from the easting values, if either if ( dfULX >= 1000000.0 ) dfULX -= static_cast<double>( iZone ) * 1000000.0; if ( dfURX >= 1000000.0 ) dfURX -= static_cast<double>( iZone ) * 1000000.0; if ( dfLLX >= 1000000.0 ) dfLLX -= static_cast<double>( iZone ) * 1000000.0; if ( dfLRX >= 1000000.0 ) dfLRX -= static_cast<double>( iZone ) * 1000000.0; // In EOSAT FAST Rev C, the angles are in decimal degrees // otherwise they are in packed DMS format. const int bAnglesInPackedDMSFormat = strstr( pszHeader, "REV C" ) == NULL; // Create projection definition OGRSpatialReference oSRS; OGRErr eErr = oSRS.importFromUSGS( iProjSys, iZone, adfProjParms, iDatum, bAnglesInPackedDMSFormat ); if ( eErr != OGRERR_NONE ) CPLDebug( "FAST", "Import projection from USGS failed: %d", eErr ); oSRS.SetLinearUnits( SRS_UL_METER, 1.0 ); // Read datum name pszTemp = GetValue( pszHeader, DATUM_NAME, DATUM_NAME_SIZE, FALSE ); if ( pszTemp ) { if ( EQUAL( pszTemp, "WGS84" ) ) oSRS.SetWellKnownGeogCS( "WGS84" ); else if ( EQUAL( pszTemp, "NAD27" ) ) oSRS.SetWellKnownGeogCS( "NAD27" ); else if ( EQUAL( pszTemp, "NAD83" ) ) oSRS.SetWellKnownGeogCS( "NAD83" ); CPLFree( pszTemp ); } else { // Reasonable fallback oSRS.SetWellKnownGeogCS( "WGS84" ); } if ( poDS->pszProjection ) CPLFree( poDS->pszProjection ); eErr = oSRS.exportToWkt( &poDS->pszProjection ); if ( eErr != OGRERR_NONE ) CPLDebug("FAST", "Export projection to WKT USGS failed: %d", eErr); // Generate GCPs GDAL_GCP *pasGCPList = static_cast<GDAL_GCP *>( CPLCalloc( sizeof( GDAL_GCP ), 4 ) ); GDALInitGCPs( 4, pasGCPList ); CPLFree(pasGCPList[0].pszId); CPLFree(pasGCPList[1].pszId); CPLFree(pasGCPList[2].pszId); CPLFree(pasGCPList[3].pszId); /* Let's order the GCP in TL, TR, BR, BL order to benefit from the */ /* GDALGCPsToGeoTransform optimization */ pasGCPList[0].pszId = CPLStrdup("UPPER_LEFT"); pasGCPList[0].dfGCPX = dfULX; pasGCPList[0].dfGCPY = dfULY; pasGCPList[0].dfGCPZ = 0.0; pasGCPList[0].dfGCPPixel = 0.5; pasGCPList[0].dfGCPLine = 0.5; pasGCPList[1].pszId = CPLStrdup("UPPER_RIGHT"); pasGCPList[1].dfGCPX = dfURX; pasGCPList[1].dfGCPY = dfURY; pasGCPList[1].dfGCPZ = 0.0; pasGCPList[1].dfGCPPixel = poDS->nRasterXSize-0.5; pasGCPList[1].dfGCPLine = 0.5; pasGCPList[2].pszId = CPLStrdup("LOWER_RIGHT"); pasGCPList[2].dfGCPX = dfLRX; pasGCPList[2].dfGCPY = dfLRY; pasGCPList[2].dfGCPZ = 0.0; pasGCPList[2].dfGCPPixel = poDS->nRasterXSize-0.5; pasGCPList[2].dfGCPLine = poDS->nRasterYSize-0.5; pasGCPList[3].pszId = CPLStrdup("LOWER_LEFT"); pasGCPList[3].dfGCPX = dfLLX; pasGCPList[3].dfGCPY = dfLLY; pasGCPList[3].dfGCPZ = 0.0; pasGCPList[3].dfGCPPixel = 0.5; pasGCPList[3].dfGCPLine = poDS->nRasterYSize-0.5; // Calculate transformation matrix, if accurate const bool transform_ok = CPL_TO_BOOL( GDALGCPsToGeoTransform( 4, pasGCPList, poDS->adfGeoTransform, 0 ) ); if( !transform_ok ) { poDS->adfGeoTransform[0] = 0.0; poDS->adfGeoTransform[1] = 1.0; poDS->adfGeoTransform[2] = 0.0; poDS->adfGeoTransform[3] = 0.0; poDS->adfGeoTransform[4] = 0.0; poDS->adfGeoTransform[5] = 1.0; if ( poDS->pszProjection ) CPLFree( poDS->pszProjection ); poDS->pszProjection = CPLStrdup(""); } GDALDeinitGCPs(4, pasGCPList); CPLFree(pasGCPList); } /* -------------------------------------------------------------------- */ /* Create band information objects. */ /* -------------------------------------------------------------------- */ const int nPixelOffset = GDALGetDataTypeSize(poDS->eDataType) / 8; const int nLineOffset = poDS->nRasterXSize * nPixelOffset; for( int i = 1; i <= poDS->nBands; i++ ) { poDS->SetBand( i, new FASTRasterBand( poDS, i, poDS->fpChannels[i - 1], 0, nPixelOffset, nLineOffset, poDS->eDataType, TRUE)); } CPLFree( pszHeader ); /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML(); // opens overviews. poDS->oOvManager.Initialize(poDS, poDS->pszFilename); /* -------------------------------------------------------------------- */ /* Confirm the requested access is supported. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->eAccess == GA_Update ) { delete poDS; CPLError( CE_Failure, CPLE_NotSupported, "The FAST driver does not support update access to existing" " datasets." ); return NULL; } return poDS; }
void GDALDefaultOverviews::OverviewScan() { if( bCheckedForOverviews || poDS == NULL ) return; bCheckedForOverviews = true; CPLDebug( "GDAL", "GDALDefaultOverviews::OverviewScan()" ); /* -------------------------------------------------------------------- */ /* Open overview dataset if it exists. */ /* -------------------------------------------------------------------- */ if( pszInitName == NULL ) pszInitName = CPLStrdup(poDS->GetDescription()); if( !EQUAL(pszInitName,":::VIRTUAL:::") && GDALCanFileAcceptSidecarFile(pszInitName) ) { if( bInitNameIsOVR ) osOvrFilename = pszInitName; else osOvrFilename.Printf( "%s.ovr", pszInitName ); std::vector<char> achOvrFilename; achOvrFilename.resize(osOvrFilename.size() + 1); memcpy(&(achOvrFilename[0]), osOvrFilename.c_str(), osOvrFilename.size() + 1); bool bExists = CPL_TO_BOOL( CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) ); osOvrFilename = &achOvrFilename[0]; #if !defined(WIN32) if( !bInitNameIsOVR && !bExists && !papszInitSiblingFiles ) { osOvrFilename.Printf( "%s.OVR", pszInitName ); memcpy(&(achOvrFilename[0]), osOvrFilename.c_str(), osOvrFilename.size() + 1); bExists = CPL_TO_BOOL( CPLCheckForFile( &achOvrFilename[0], papszInitSiblingFiles ) ); osOvrFilename = &achOvrFilename[0]; if( !bExists ) osOvrFilename.Printf( "%s.ovr", pszInitName ); } #endif if( bExists ) { poODS = static_cast<GDALDataset *>( GDALOpenEx( osOvrFilename, GDAL_OF_RASTER | (poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0), NULL, NULL, papszInitSiblingFiles ) ); } } /* -------------------------------------------------------------------- */ /* We didn't find that, so try and find a corresponding aux */ /* file. Check that we are the dependent file of the aux */ /* file. */ /* */ /* We only use the .aux file for overviews if they already have */ /* overviews existing, or if USE_RRD is set true. */ /* -------------------------------------------------------------------- */ if( !poODS && !EQUAL(pszInitName,":::VIRTUAL:::") && GDALCanFileAcceptSidecarFile(pszInitName) ) { bool bTryFindAssociatedAuxFile = true; if( papszInitSiblingFiles ) { CPLString osAuxFilename = CPLResetExtension( pszInitName, "aux"); int iSibling = CSLFindString( papszInitSiblingFiles, CPLGetFilename(osAuxFilename) ); if( iSibling < 0 ) { osAuxFilename = pszInitName; osAuxFilename += ".aux"; iSibling = CSLFindString( papszInitSiblingFiles, CPLGetFilename(osAuxFilename) ); if( iSibling < 0 ) bTryFindAssociatedAuxFile = false; } } if( bTryFindAssociatedAuxFile ) { poODS = GDALFindAssociatedAuxFile( pszInitName, poDS->GetAccess(), poDS ); } if( poODS ) { const bool bUseRRD = CPLTestBool(CPLGetConfigOption("USE_RRD","NO")); bOvrIsAux = true; if( GetOverviewCount(1) == 0 && !bUseRRD ) { bOvrIsAux = false; GDALClose( poODS ); poODS = NULL; } else { osOvrFilename = poODS->GetDescription(); } } } /* -------------------------------------------------------------------- */ /* If we still don't have an overview, check to see if we have */ /* overview metadata referencing a remote (i.e. proxy) or local */ /* subdataset overview dataset. */ /* -------------------------------------------------------------------- */ if( poODS == NULL ) { const char *pszProxyOvrFilename = poDS->GetMetadataItem( "OVERVIEW_FILE", "OVERVIEWS" ); if( pszProxyOvrFilename != NULL ) { if( STARTS_WITH_CI(pszProxyOvrFilename, ":::BASE:::") ) { const CPLString osPath = CPLGetPath(poDS->GetDescription()); osOvrFilename = CPLFormFilename( osPath, pszProxyOvrFilename+10, NULL ); } else { osOvrFilename = pszProxyOvrFilename; } CPLPushErrorHandler(CPLQuietErrorHandler); poODS = static_cast<GDALDataset *>(GDALOpen(osOvrFilename, poDS->GetAccess())); CPLPopErrorHandler(); } } /* -------------------------------------------------------------------- */ /* If we have an overview dataset, then mark all the overviews */ /* with the base dataset Used later for finding overviews */ /* masks. Uggg. */ /* -------------------------------------------------------------------- */ if( poODS ) { const int nOverviewCount = GetOverviewCount(1); for( int iOver = 0; iOver < nOverviewCount; iOver++ ) { GDALRasterBand * const poBand = GetOverview( 1, iOver ); GDALDataset * const poOverDS = poBand != NULL ? poBand->GetDataset() : NULL; if( poOverDS != NULL ) { poOverDS->oOvManager.poBaseDS = poDS; poOverDS->oOvManager.poDS = poOverDS; } } } }
OGRErr OGRDXFLayer::CollectPolylinePath( OGRGeometryCollection *poGC, const double dfElevation ) { int nCode = 0; char szLineBuf[257]; DXFSmoothPolyline oSmoothPolyline; double dfBulge = 0.0; double dfX = 0.0; double dfY = 0.0; bool bHaveX = false; bool bHaveY = false; bool bIsClosed = false; int nVertexCount = -1; bool bHaveBulges = false; /* -------------------------------------------------------------------- */ /* Read the boundary path type. */ /* -------------------------------------------------------------------- */ while( (nCode = poDS->ReadValue(szLineBuf,sizeof(szLineBuf))) > 0 ) { if( nVertexCount > 0 && (int) oSmoothPolyline.size() == nVertexCount ) break; switch( nCode ) { case 93: nVertexCount = atoi(szLineBuf); break; case 72: bHaveBulges = CPL_TO_BOOL(atoi(szLineBuf)); break; case 73: bIsClosed = CPL_TO_BOOL(atoi(szLineBuf)); break; case 10: if( bHaveX && bHaveY ) { oSmoothPolyline.AddPoint(dfX, dfY, dfElevation, dfBulge); dfBulge = 0.0; bHaveY = false; } dfX = CPLAtof(szLineBuf); bHaveX = true; break; case 20: if( bHaveX && bHaveY ) { oSmoothPolyline.AddPoint( dfX, dfY, dfElevation, dfBulge ); dfBulge = 0.0; bHaveX = false; } dfY = CPLAtof(szLineBuf); bHaveY = true; if( bHaveX && bHaveY && !bHaveBulges ) { oSmoothPolyline.AddPoint( dfX, dfY, dfElevation, dfBulge ); dfBulge = 0.0; bHaveX = false; bHaveY = false; } break; case 42: dfBulge = CPLAtof(szLineBuf); if( bHaveX && bHaveY ) { oSmoothPolyline.AddPoint( dfX, dfY, dfElevation, dfBulge ); dfBulge = 0.0; bHaveX = false; bHaveY = false; } break; default: break; } } if( nCode < 0 ) { DXF_LAYER_READER_ERROR(); return OGRERR_FAILURE; } if( nCode != 10 && nCode != 20 && nCode != 42 ) poDS->UnreadValue(); if( bHaveX && bHaveY ) oSmoothPolyline.AddPoint(dfX, dfY, dfElevation, dfBulge); if( bIsClosed ) oSmoothPolyline.Close(); if(oSmoothPolyline.IsEmpty()) { return OGRERR_FAILURE; } poGC->addGeometryDirectly( oSmoothPolyline.Tesselate() ); /* -------------------------------------------------------------------- */ /* Skip through source boundary objects if present. */ /* -------------------------------------------------------------------- */ nCode = poDS->ReadValue(szLineBuf,sizeof(szLineBuf)); if( nCode != 97 ) { if (nCode < 0) return OGRERR_FAILURE; poDS->UnreadValue(); } else { int iObj, nObjCount = atoi(szLineBuf); for( iObj = 0; iObj < nObjCount; iObj++ ) { if (poDS->ReadValue( szLineBuf, sizeof(szLineBuf) ) < 0) return OGRERR_FAILURE; } } return OGRERR_NONE; }
GDALDataset *PNMDataset::Open( GDALOpenInfo * poOpenInfo ) { /* -------------------------------------------------------------------- */ /* Verify that this is a _raw_ ppm or pgm file. Note, we don't */ /* support ascii files, or pbm (1bit) files. */ /* -------------------------------------------------------------------- */ if( !Identify( poOpenInfo ) ) return nullptr; /* -------------------------------------------------------------------- */ /* Parse out the tokens from the header. */ /* -------------------------------------------------------------------- */ const char *pszSrc = reinterpret_cast<char *>( poOpenInfo->pabyHeader ); char szToken[512] = { '\0' }; int iToken = 0; int nWidth = -1; int nHeight = -1; int nMaxValue = -1; int iIn = 2; while( iIn < poOpenInfo->nHeaderBytes && iToken < 3 ) { unsigned int iOut = 0; szToken[0] = '\0'; while( iOut < sizeof(szToken) && iIn < poOpenInfo->nHeaderBytes ) { if( pszSrc[iIn] == '#' ) { while( iIn < poOpenInfo->nHeaderBytes - 1 && pszSrc[iIn] != 10 && pszSrc[iIn] != 13 ) iIn++; } if( iOut != 0 && isspace(static_cast<unsigned char>(pszSrc[iIn])) ) { szToken[iOut] = '\0'; if( iToken == 0 ) nWidth = atoi(szToken); else if( iToken == 1 ) nHeight = atoi(szToken); else if( iToken == 2 ) nMaxValue = atoi(szToken); iToken++; iIn++; break; } else if( !isspace(static_cast<unsigned char>(pszSrc[iIn])) ) { szToken[iOut++] = pszSrc[iIn]; } iIn++; } } CPLDebug( "PNM", "PNM header contains: width=%d, height=%d, maxval=%d", nWidth, nHeight, nMaxValue ); if( iToken != 3 || nWidth < 1 || nHeight < 1 || nMaxValue < 1 ) return nullptr; /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ PNMDataset *poDS = new PNMDataset(); /* -------------------------------------------------------------------- */ /* Capture some information from the file that is of interest. */ /* -------------------------------------------------------------------- */ poDS->nRasterXSize = nWidth; poDS->nRasterYSize = nHeight; // Borrow file pointer poDS->fpImage = poOpenInfo->fpL; poOpenInfo->fpL = nullptr; poDS->eAccess = poOpenInfo->eAccess; /* -------------------------------------------------------------------- */ /* Create band information objects. */ /* -------------------------------------------------------------------- */ #ifdef CPL_LSB const bool bMSBFirst = false; #else const bool bMSBFirst = true; #endif GDALDataType eDataType = GDT_Unknown; if ( nMaxValue < 256 ) eDataType = GDT_Byte; else eDataType = GDT_UInt16; const int iPixelSize = GDALGetDataTypeSizeBytes( eDataType ); if( poOpenInfo->pabyHeader[1] == '5' ) { if (nWidth > INT_MAX / iPixelSize) { CPLError( CE_Failure, CPLE_AppDefined, "Int overflow occurred."); delete poDS; return nullptr; } poDS->SetBand( 1, new RawRasterBand( poDS, 1, poDS->fpImage, iIn, iPixelSize, nWidth*iPixelSize, eDataType, bMSBFirst, RawRasterBand::OwnFP::NO ) ); poDS->GetRasterBand(1)->SetColorInterpretation( GCI_GrayIndex ); } else { if (nWidth > INT_MAX / (3 * iPixelSize)) { CPLError( CE_Failure, CPLE_AppDefined, "Int overflow occurred."); delete poDS; return nullptr; } poDS->SetBand( 1, new RawRasterBand( poDS, 1, poDS->fpImage, iIn, 3*iPixelSize, nWidth*3*iPixelSize, eDataType, bMSBFirst, RawRasterBand::OwnFP::NO )); poDS->SetBand( 2, new RawRasterBand( poDS, 2, poDS->fpImage, iIn+iPixelSize, 3*iPixelSize, nWidth*3*iPixelSize, eDataType, bMSBFirst, RawRasterBand::OwnFP::NO )); poDS->SetBand( 3, new RawRasterBand( poDS, 3, poDS->fpImage, iIn+2*iPixelSize, 3*iPixelSize, nWidth*3*iPixelSize, eDataType, bMSBFirst, RawRasterBand::OwnFP::NO )); poDS->GetRasterBand(1)->SetColorInterpretation( GCI_RedBand ); poDS->GetRasterBand(2)->SetColorInterpretation( GCI_GreenBand ); poDS->GetRasterBand(3)->SetColorInterpretation( GCI_BlueBand ); } /* -------------------------------------------------------------------- */ /* Check for world file. */ /* -------------------------------------------------------------------- */ poDS->bGeoTransformValid = CPL_TO_BOOL( GDALReadWorldFile( poOpenInfo->pszFilename, ".wld", poDS->adfGeoTransform ) ); /* -------------------------------------------------------------------- */ /* Initialize any PAM information. */ /* -------------------------------------------------------------------- */ poDS->SetDescription( poOpenInfo->pszFilename ); poDS->TryLoadXML(); /* -------------------------------------------------------------------- */ /* Check for overviews. */ /* -------------------------------------------------------------------- */ poDS->oOvManager.Initialize( poDS, poOpenInfo->pszFilename ); return poDS; }
int OGRCouchDBDataSource::Open( const char * pszFilename, int bUpdateIn) { bool bHTTP = STARTS_WITH(pszFilename, "http://") || STARTS_WITH(pszFilename, "https://"); if( !bHTTP && !STARTS_WITH_CI(pszFilename, "CouchDB:")) return FALSE; bReadWrite = CPL_TO_BOOL(bUpdateIn); pszName = CPLStrdup( pszFilename ); if( bHTTP ) osURL = pszFilename; else osURL = pszFilename + 8; if (!osURL.empty() && osURL.back() == '/') osURL.resize(osURL.size() - 1); const char* pszUserPwd = CPLGetConfigOption("COUCHDB_USERPWD", NULL); if (pszUserPwd) osUserPwd = pszUserPwd; if ((strstr(osURL, "/_design/") && strstr(osURL, "/_view/")) || strstr(osURL, "/_all_docs")) { return OpenView() != NULL; } /* If passed with http://useraccount.knownprovider.com/database, do not */ /* try to issue /all_dbs, but directly open the database */ const char* pszKnowProvider = strstr(osURL, ".iriscouch.com/"); if (pszKnowProvider != NULL && strchr(pszKnowProvider + strlen(".iriscouch.com/"), '/' ) == NULL) { return OpenDatabase() != NULL; } pszKnowProvider = strstr(osURL, ".cloudant.com/"); if (pszKnowProvider != NULL && strchr(pszKnowProvider + strlen(".cloudant.com/"), '/' ) == NULL) { return OpenDatabase() != NULL; } /* Get list of tables */ json_object* poAnswerObj = GET("/_all_dbs"); if (poAnswerObj == NULL) { if (!STARTS_WITH_CI(pszFilename, "CouchDB:")) CPLErrorReset(); return FALSE; } if ( !json_object_is_type(poAnswerObj, json_type_array) ) { if ( json_object_is_type(poAnswerObj, json_type_object) ) { json_object* poError = CPL_json_object_object_get(poAnswerObj, "error"); json_object* poReason = CPL_json_object_object_get(poAnswerObj, "reason"); const char* pszError = json_object_get_string(poError); const char* pszReason = json_object_get_string(poReason); if (pszError && pszReason && strcmp(pszError, "not_found") == 0 && strcmp(pszReason, "missing") == 0) { json_object_put(poAnswerObj); poAnswerObj = NULL; CPLErrorReset(); return OpenDatabase() != NULL; } } if (poAnswerObj) { IsError(poAnswerObj, "Database listing failed"); json_object_put(poAnswerObj); return FALSE; } } int nTables = json_object_array_length(poAnswerObj); for(int i=0;i<nTables;i++) { json_object* poAnswerObjDBName = json_object_array_get_idx(poAnswerObj, i); if ( json_object_is_type(poAnswerObjDBName, json_type_string) ) { const char* pszDBName = json_object_get_string(poAnswerObjDBName); if ( strcmp(pszDBName, "_users") != 0 && strcmp(pszDBName, "_replicator") != 0 ) { papoLayers = (OGRLayer**) CPLRealloc(papoLayers, (nLayers + 1) * sizeof(OGRLayer*)); papoLayers[nLayers ++] = new OGRCouchDBTableLayer(this, pszDBName); } } } json_object_put(poAnswerObj); return TRUE; }
int OGRSelafinDataSource::Open( const char * pszFilename, int bUpdateIn, int bCreate ) { // Check if a range is set and extract it and the filename. const char *pszc = pszFilename; if (*pszFilename==0) return FALSE; while (*pszc) ++pszc; if (*(pszc-1)==']') { --pszc; while (pszc!=pszFilename && *pszc!='[') pszc--; if (pszc==pszFilename) return FALSE; poRange.setRange(pszc); } pszName = CPLStrdup( pszFilename ); pszName[pszc-pszFilename]=0; bUpdate = CPL_TO_BOOL(bUpdateIn); if (bCreate && EQUAL(pszName, "/vsistdout/")) return TRUE; /* For writable /vsizip/, do nothing more */ if (bCreate && STARTS_WITH(pszName, "/vsizip/")) return TRUE; CPLString osFilename(pszName); CPLString osBaseFilename = CPLGetFilename(pszName); // Determine what sort of object this is. VSIStatBufL sStatBuf; if (VSIStatExL( osFilename, &sStatBuf, VSI_STAT_NATURE_FLAG ) != 0) return FALSE; // Is this a single Selafin file? if (VSI_ISREG(sStatBuf.st_mode)) return OpenTable( pszName ); // Is this a single a ZIP file with only a Selafin file inside ? if( STARTS_WITH(osFilename, "/vsizip/") && VSI_ISREG(sStatBuf.st_mode) ) { char** papszFiles = VSIReadDir(osFilename); if (CSLCount(papszFiles) != 1) { CSLDestroy(papszFiles); return FALSE; } osFilename = CPLFormFilename(osFilename, papszFiles[0], nullptr); CSLDestroy(papszFiles); return OpenTable( osFilename ); } #ifdef notdef // Otherwise it has to be a directory. if( !VSI_ISDIR(sStatBuf.st_mode) ) return FALSE; // Scan through for entries which look like Selafin files int nNotSelafinCount = 0, i; char **papszNames = VSIReadDir( osFilename ); for( i = 0; papszNames != NULL && papszNames[i] != NULL; i++ ) { CPLString oSubFilename = CPLFormFilename( osFilename, papszNames[i], NULL ); if( EQUAL(papszNames[i],".") || EQUAL(papszNames[i],"..") ) continue; if( VSIStatL( oSubFilename, &sStatBuf ) != 0 || !VSI_ISREG(sStatBuf.st_mode) ) { nNotSelafinCount++; continue; } if( !OpenTable( oSubFilename ) ) { CPLDebug("Selafin", "Cannot open %s", oSubFilename.c_str()); nNotSelafinCount++; continue; } } CSLDestroy( papszNames ); // We presume that this is indeed intended to be a Selafin datasource if over half the files were Selafin files. return nNotSelafinCount < nLayers; #else return FALSE; #endif }
/** * Runs an executable in another process (or fork the current process) * and return immediately. * * This function launches an executable and returns immediately, while letting * the sub-process to run asynchronously. * * It is implemented as CreateProcess() on Windows platforms, and fork()/exec() * on other platforms. * * On Unix, a pointer of function can be provided to run in the child process, * without exec()'ing a new executable. * * @param pfnMain the function to run in the child process (Unix only). * @param papszArgv argument list of the executable to run. papszArgv[0] is the * name of the executable. * @param bCreateInputPipe set to TRUE to create a pipe for the child input stream. * @param bCreateOutputPipe set to TRUE to create a pipe for the child output stream. * @param bCreateErrorPipe set to TRUE to create a pipe for the child error stream. * * @return a handle, that must be freed with CPLSpawnAsyncFinish() * * @since GDAL 1.10.0 */ CPLSpawnedProcess* CPLSpawnAsync(int (*pfnMain)(CPL_FILE_HANDLE, CPL_FILE_HANDLE), const char * const papszArgv[], int bCreateInputPipe, int bCreateOutputPipe, int bCreateErrorPipe, CPL_UNUSED char** papszOptions) { int pipe_in[2] = { -1, -1 }; int pipe_out[2] = { -1, -1 }; int pipe_err[2] = { -1, -1 }; bool bDup2In = CPL_TO_BOOL(bCreateInputPipe); bool bDup2Out = CPL_TO_BOOL(bCreateOutputPipe); bool bDup2Err = CPL_TO_BOOL(bCreateErrorPipe); if ((bCreateInputPipe && pipe(pipe_in)) || (bCreateOutputPipe && pipe(pipe_out)) || (bCreateErrorPipe && pipe(pipe_err))) { CPLError(CE_Failure, CPLE_AppDefined, "Could not create pipe"); return NULL; } char** papszArgvDup = CSLDuplicate( const_cast<char **>( papszArgv ) ); /* If we don't do any file actions, posix_spawnp() might be implemented */ /* efficiently as a vfork()/exec() pair (or if it is not available, we */ /* can use vfork()/exec()), so if the child is cooperative */ /* we pass the pipe handles as commandline arguments */ if( papszArgv != NULL ) { for( int i=0; papszArgvDup[i] != NULL; i++ ) { if( bCreateInputPipe && strcmp(papszArgvDup[i], "{pipe_in}") == 0 ) { CPLFree(papszArgvDup[i]); papszArgvDup[i] = CPLStrdup(CPLSPrintf("%d,%d", pipe_in[IN_FOR_PARENT], pipe_in[OUT_FOR_PARENT])); bDup2In = false; } else if( bCreateOutputPipe && strcmp(papszArgvDup[i], "{pipe_out}") == 0 ) { CPLFree(papszArgvDup[i]); papszArgvDup[i] = CPLStrdup(CPLSPrintf("%d,%d", pipe_out[OUT_FOR_PARENT], pipe_out[IN_FOR_PARENT])); bDup2Out = false; } else if( bCreateErrorPipe && strcmp(papszArgvDup[i], "{pipe_err}") == 0 ) { CPLFree(papszArgvDup[i]); papszArgvDup[i] = CPLStrdup(CPLSPrintf("%d,%d", pipe_err[OUT_FOR_PARENT], pipe_err[IN_FOR_PARENT])); bDup2Err = false; } } } #ifdef HAVE_POSIX_SPAWNP if( papszArgv != NULL ) { bool bHasActions = false; posix_spawn_file_actions_t actions; if( bDup2In ) { if( !bHasActions ) posix_spawn_file_actions_init(&actions); posix_spawn_file_actions_adddup2(&actions, pipe_in[IN_FOR_PARENT], fileno(stdin)); posix_spawn_file_actions_addclose(&actions, pipe_in[OUT_FOR_PARENT]); bHasActions = true; } if( bDup2Out ) { if( !bHasActions ) posix_spawn_file_actions_init(&actions); posix_spawn_file_actions_adddup2(&actions, pipe_out[OUT_FOR_PARENT], fileno(stdout)); posix_spawn_file_actions_addclose(&actions, pipe_out[IN_FOR_PARENT]); bHasActions = true; } if( bDup2Err ) { if( !bHasActions ) posix_spawn_file_actions_init(&actions); posix_spawn_file_actions_adddup2(&actions, pipe_err[OUT_FOR_PARENT], fileno(stderr)); posix_spawn_file_actions_addclose(&actions, pipe_err[IN_FOR_PARENT]); bHasActions = true; } pid_t pid; if( posix_spawnp(&pid, papszArgvDup[0], bHasActions ? &actions : NULL, NULL, reinterpret_cast<char* const*>( papszArgvDup ), environ) != 0 ) { if( bHasActions ) posix_spawn_file_actions_destroy(&actions); CPLError(CE_Failure, CPLE_AppDefined, "posix_spawnp() failed"); goto err; } CSLDestroy(papszArgvDup); /* Close unused end of pipe */ if( bCreateInputPipe ) close(pipe_in[IN_FOR_PARENT]); if( bCreateOutputPipe ) close(pipe_out[OUT_FOR_PARENT]); if( bCreateErrorPipe ) close(pipe_err[OUT_FOR_PARENT]); /* Ignore SIGPIPE */ #ifdef SIGPIPE std::signal( SIGPIPE, SIG_IGN ); #endif CPLSpawnedProcess *p = static_cast<CPLSpawnedProcess *>( CPLMalloc( sizeof(CPLSpawnedProcess) ) ); if( bHasActions ) memcpy(&p->actions, &actions, sizeof(actions)); p->bFreeActions = bHasActions; p->pid = pid; p->fin = pipe_out[IN_FOR_PARENT]; p->fout = pipe_in[OUT_FOR_PARENT]; p->ferr = pipe_err[IN_FOR_PARENT]; return p; } #endif // #ifdef HAVE_POSIX_SPAWNP pid_t pid; #ifdef HAVE_VFORK /* coverity[dead_error_line] */ if( papszArgv != NULL && !bDup2In && !bDup2Out && !bDup2Err ) { /* Workaround clang static analyzer warning about unsafe use of vfork */ pid_t (*p_vfork)(void) = vfork; pid = p_vfork(); } else #endif pid = fork(); if (pid == 0) { /* Close unused end of pipe */ if( bDup2In ) close(pipe_in[OUT_FOR_PARENT]); if( bDup2Out ) close(pipe_out[IN_FOR_PARENT]); if( bDup2Err ) close(pipe_err[IN_FOR_PARENT]); #ifndef HAVE_POSIX_SPAWNP if( papszArgv != NULL ) { if( bDup2In ) dup2(pipe_in[IN_FOR_PARENT], fileno(stdin)); if( bDup2Out ) dup2(pipe_out[OUT_FOR_PARENT], fileno(stdout)); if( bDup2Err ) dup2(pipe_err[OUT_FOR_PARENT], fileno(stderr)); execvp(papszArgvDup[0], (char* const*) papszArgvDup); _exit(1); } else #endif // HAVE_POSIX_SPAWNP { if( bCreateErrorPipe ) close(pipe_err[OUT_FOR_PARENT]); int nRet = 0; if (pfnMain != NULL) nRet = pfnMain((bCreateInputPipe) ? pipe_in[IN_FOR_PARENT] : fileno(stdin), (bCreateOutputPipe) ? pipe_out[OUT_FOR_PARENT] : fileno(stdout)); _exit(nRet); } } else if( pid > 0 ) { CSLDestroy(papszArgvDup); /* Close unused end of pipe */ if( bCreateInputPipe ) close(pipe_in[IN_FOR_PARENT]); if( bCreateOutputPipe ) close(pipe_out[OUT_FOR_PARENT]); if( bCreateErrorPipe ) close(pipe_err[OUT_FOR_PARENT]); /* Ignore SIGPIPE */ #ifdef SIGPIPE std::signal( SIGPIPE, SIG_IGN ); #endif CPLSpawnedProcess* p = static_cast<CPLSpawnedProcess *>( CPLMalloc( sizeof(CPLSpawnedProcess) ) ); #ifdef HAVE_POSIX_SPAWNP p->bFreeActions = FALSE; #endif p->pid = pid; p->fin = pipe_out[IN_FOR_PARENT]; p->fout = pipe_in[OUT_FOR_PARENT]; p->ferr = pipe_err[IN_FOR_PARENT]; return p; } else { CPLError(CE_Failure, CPLE_AppDefined, "Fork failed"); goto err; } err: CSLDestroy(papszArgvDup); for( int i = 0; i < 2; i++ ) { if (pipe_in[i] >= 0) close(pipe_in[i]); if (pipe_out[i] >= 0) close(pipe_out[i]); if (pipe_err[i] >= 0) close(pipe_err[i]); } return NULL; }
int OGRCSVDataSource::Open( const char * pszFilename, int bUpdateIn, int bForceOpen, char** papszOpenOptionsIn ) { pszName = CPLStrdup( pszFilename ); bUpdate = CPL_TO_BOOL(bUpdateIn); if( bUpdate && bForceOpen && EQUAL(pszFilename, "/vsistdout/") ) return TRUE; /* For writable /vsizip/, do nothing more */ if( bUpdate && bForceOpen && STARTS_WITH(pszFilename, "/vsizip/") ) return TRUE; CPLString osFilename(pszFilename); CPLString osBaseFilename = CPLGetFilename(pszFilename); CPLString osExt = GetRealExtension(osFilename); // pszFilename = NULL; bool bIgnoreExtension = STARTS_WITH_CI(osFilename, "CSV:"); bool bUSGeonamesFile = false; /* bool bGeonamesOrgFile = false; */ if (bIgnoreExtension) { osFilename = osFilename + 4; } // Those are *not* real .XLS files, but text file with tab as column // separator. if (EQUAL(osBaseFilename, "NfdcFacilities.xls") || EQUAL(osBaseFilename, "NfdcRunways.xls") || EQUAL(osBaseFilename, "NfdcRemarks.xls") || EQUAL(osBaseFilename, "NfdcSchedules.xls")) { if( bUpdate ) return FALSE; bIgnoreExtension = true; } else if ((STARTS_WITH_CI(osBaseFilename, "NationalFile_") || STARTS_WITH_CI(osBaseFilename, "POP_PLACES_") || STARTS_WITH_CI(osBaseFilename, "HIST_FEATURES_") || STARTS_WITH_CI(osBaseFilename, "US_CONCISE_") || STARTS_WITH_CI(osBaseFilename, "AllNames_") || STARTS_WITH_CI(osBaseFilename, "Feature_Description_History_") || STARTS_WITH_CI(osBaseFilename, "ANTARCTICA_") || STARTS_WITH_CI(osBaseFilename, "GOVT_UNITS_") || STARTS_WITH_CI(osBaseFilename, "NationalFedCodes_") || STARTS_WITH_CI(osBaseFilename, "AllStates_") || STARTS_WITH_CI(osBaseFilename, "AllStatesFedCodes_") || ( osBaseFilename.size() > 2 && STARTS_WITH_CI(osBaseFilename+2, "_Features_")) || ( osBaseFilename.size() > 2 && STARTS_WITH_CI(osBaseFilename+2, "_FedCodes_"))) && (EQUAL(osExt, "txt") || EQUAL(osExt, "zip")) ) { if( bUpdate ) return FALSE; bIgnoreExtension = true; bUSGeonamesFile = true; if (EQUAL(osExt, "zip") && strstr(osFilename, "/vsizip/") == NULL ) { osFilename = "/vsizip/" + osFilename; } } else if (EQUAL(osBaseFilename, "allCountries.txt") || EQUAL(osBaseFilename, "allCountries.zip")) { if( bUpdate ) return FALSE; bIgnoreExtension = true; /* bGeonamesOrgFile = true; */ if (EQUAL(osExt, "zip") && strstr(osFilename, "/vsizip/") == NULL ) { osFilename = "/vsizip/" + osFilename; } } /* -------------------------------------------------------------------- */ /* Determine what sort of object this is. */ /* -------------------------------------------------------------------- */ VSIStatBufL sStatBuf; if( VSIStatExL( osFilename, &sStatBuf, VSI_STAT_NATURE_FLAG ) != 0 ) return FALSE; /* -------------------------------------------------------------------- */ /* Is this a single CSV file? */ /* -------------------------------------------------------------------- */ if( VSI_ISREG(sStatBuf.st_mode) && (bIgnoreExtension || EQUAL(osExt,"csv") || EQUAL(osExt,"tsv")) ) { if (EQUAL(CPLGetFilename(osFilename), "NfdcFacilities.xls")) { return OpenTable( osFilename, papszOpenOptionsIn, "ARP"); } else if (EQUAL(CPLGetFilename(osFilename), "NfdcRunways.xls")) { OpenTable( osFilename, papszOpenOptionsIn, "BaseEndPhysical"); OpenTable( osFilename, papszOpenOptionsIn, "BaseEndDisplaced"); OpenTable( osFilename, papszOpenOptionsIn, "ReciprocalEndPhysical"); OpenTable( osFilename, papszOpenOptionsIn, "ReciprocalEndDisplaced"); return nLayers != 0; } else if (bUSGeonamesFile) { /* GNIS specific */ if (STARTS_WITH_CI(osBaseFilename, "NationalFedCodes_") || STARTS_WITH_CI(osBaseFilename, "AllStatesFedCodes_") || STARTS_WITH_CI(osBaseFilename, "ANTARCTICA_") || ( osBaseFilename.size() > 2 && STARTS_WITH_CI(osBaseFilename+2, "_FedCodes_"))) { OpenTable( osFilename, papszOpenOptionsIn, NULL, "PRIMARY"); } else if (STARTS_WITH_CI(osBaseFilename, "GOVT_UNITS_") || STARTS_WITH_CI(osBaseFilename, "Feature_Description_History_")) { OpenTable( osFilename, papszOpenOptionsIn, NULL, ""); } else { OpenTable( osFilename, papszOpenOptionsIn, NULL, "PRIM"); OpenTable( osFilename, papszOpenOptionsIn, NULL, "SOURCE"); } return nLayers != 0; } return OpenTable( osFilename, papszOpenOptionsIn ); } /* -------------------------------------------------------------------- */ /* Is this a single a ZIP file with only a CSV file inside ? */ /* -------------------------------------------------------------------- */ if( STARTS_WITH(osFilename, "/vsizip/") && EQUAL(osExt, "zip") && VSI_ISREG(sStatBuf.st_mode) ) { char** papszFiles = VSIReadDir(osFilename); if (CSLCount(papszFiles) != 1 || !EQUAL(CPLGetExtension(papszFiles[0]), "CSV")) { CSLDestroy(papszFiles); return FALSE; } osFilename = CPLFormFilename(osFilename, papszFiles[0], NULL); CSLDestroy(papszFiles); return OpenTable( osFilename, papszOpenOptionsIn ); } /* -------------------------------------------------------------------- */ /* Otherwise it has to be a directory. */ /* -------------------------------------------------------------------- */ if( !VSI_ISDIR(sStatBuf.st_mode) ) return FALSE; /* -------------------------------------------------------------------- */ /* Scan through for entries ending in .csv. */ /* -------------------------------------------------------------------- */ int nNotCSVCount = 0; char **papszNames = VSIReadDir( osFilename ); for( int i = 0; papszNames != NULL && papszNames[i] != NULL; i++ ) { CPLString oSubFilename = CPLFormFilename( osFilename, papszNames[i], NULL ); if( EQUAL(papszNames[i],".") || EQUAL(papszNames[i],"..") ) continue; if (EQUAL(CPLGetExtension(oSubFilename),"csvt")) continue; if( VSIStatL( oSubFilename, &sStatBuf ) != 0 || !VSI_ISREG(sStatBuf.st_mode) ) { nNotCSVCount++; continue; } if (EQUAL(CPLGetExtension(oSubFilename),"csv")) { if( !OpenTable( oSubFilename, papszOpenOptionsIn ) ) { CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str()); nNotCSVCount++; continue; } } /* GNIS specific */ else if ( strlen(papszNames[i]) > 2 && STARTS_WITH_CI(papszNames[i]+2, "_Features_") && EQUAL(CPLGetExtension(papszNames[i]), "txt") ) { bool bRet = OpenTable( oSubFilename, papszOpenOptionsIn, NULL, "PRIM"); bRet |= OpenTable( oSubFilename, papszOpenOptionsIn, NULL, "SOURCE"); if ( !bRet ) { CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str()); nNotCSVCount++; continue; } } /* GNIS specific */ else if ( strlen(papszNames[i]) > 2 && STARTS_WITH_CI(papszNames[i]+2, "_FedCodes_") && EQUAL(CPLGetExtension(papszNames[i]), "txt") ) { if ( !OpenTable( oSubFilename, papszOpenOptionsIn, NULL, "PRIMARY") ) { CPLDebug("CSV", "Cannot open %s", oSubFilename.c_str()); nNotCSVCount++; continue; } } else { nNotCSVCount++; continue; } } CSLDestroy( papszNames ); /* -------------------------------------------------------------------- */ /* We presume that this is indeed intended to be a CSV */ /* datasource if over half the files were .csv files. */ /* -------------------------------------------------------------------- */ return bForceOpen || nNotCSVCount < nLayers; }
int OGRProj4CT::InitializeNoLock( OGRSpatialReference * poSourceIn, OGRSpatialReference * poTargetIn ) { if( poSourceIn == NULL || poTargetIn == NULL ) return FALSE; poSRSSource = poSourceIn->Clone(); poSRSTarget = poTargetIn->Clone(); bSourceLatLong = CPL_TO_BOOL(poSRSSource->IsGeographic()); bTargetLatLong = CPL_TO_BOOL(poSRSTarget->IsGeographic()); /* -------------------------------------------------------------------- */ /* Setup source and target translations to radians for lat/long */ /* systems. */ /* -------------------------------------------------------------------- */ dfSourceToRadians = DEG_TO_RAD; bSourceWrap = false; dfSourceWrapLong = 0.0; if( bSourceLatLong ) { OGR_SRSNode *poUNITS = poSRSSource->GetAttrNode( "GEOGCS|UNIT" ); if( poUNITS && poUNITS->GetChildCount() >= 2 ) { dfSourceToRadians = CPLAtof(poUNITS->GetChild(1)->GetValue()); if( dfSourceToRadians == 0.0 ) dfSourceToRadians = DEG_TO_RAD; } } dfTargetFromRadians = RAD_TO_DEG; bTargetWrap = false; dfTargetWrapLong = 0.0; if( bTargetLatLong ) { OGR_SRSNode *poUNITS = poSRSTarget->GetAttrNode( "GEOGCS|UNIT" ); if( poUNITS && poUNITS->GetChildCount() >= 2 ) { double dfTargetToRadians = CPLAtof(poUNITS->GetChild(1)->GetValue()); if( dfTargetToRadians != 0.0 ) dfTargetFromRadians = 1 / dfTargetToRadians; } } /* -------------------------------------------------------------------- */ /* Preliminary logic to setup wrapping. */ /* -------------------------------------------------------------------- */ if( CPLGetConfigOption( "CENTER_LONG", NULL ) != NULL ) { bSourceWrap = true; bTargetWrap = true; dfSourceWrapLong = dfTargetWrapLong = CPLAtof(CPLGetConfigOption( "CENTER_LONG", "" )); CPLDebug( "OGRCT", "Wrap at %g.", dfSourceWrapLong ); } const char *pszCENTER_LONG = poSRSSource->GetExtension( "GEOGCS", "CENTER_LONG" ); if( pszCENTER_LONG != NULL ) { dfSourceWrapLong = CPLAtof(pszCENTER_LONG); bSourceWrap = true; CPLDebug( "OGRCT", "Wrap source at %g.", dfSourceWrapLong ); } pszCENTER_LONG = poSRSTarget->GetExtension( "GEOGCS", "CENTER_LONG" ); if( pszCENTER_LONG != NULL ) { dfTargetWrapLong = CPLAtof(pszCENTER_LONG); bTargetWrap = true; CPLDebug( "OGRCT", "Wrap target at %g.", dfTargetWrapLong ); } bCheckWithInvertProj = CPLTestBool(CPLGetConfigOption( "CHECK_WITH_INVERT_PROJ", "NO" )); // The threshold is experimental. Works well with the cases of ticket #2305. if( bSourceLatLong ) dfThreshold = CPLAtof(CPLGetConfigOption( "THRESHOLD", ".1" )); else // 1 works well for most projections, except for +proj=aeqd that // requires a tolerance of 10000. dfThreshold = CPLAtof(CPLGetConfigOption( "THRESHOLD", "10000" )); // OGRThreadSafety: The following variable is not a thread safety issue // since the only issue is incrementing while accessing which at worse // means debug output could be one "increment" late. static int nDebugReportCount = 0; char *pszSrcProj4Defn = NULL; if( poSRSSource->exportToProj4( &pszSrcProj4Defn ) != OGRERR_NONE ) { CPLFree( pszSrcProj4Defn ); return FALSE; } if( strlen(pszSrcProj4Defn) == 0 ) { CPLFree( pszSrcProj4Defn ); CPLError( CE_Failure, CPLE_AppDefined, "No PROJ.4 translation for source SRS, coordinate\n" "transformation initialization has failed." ); return FALSE; } char *pszDstProj4Defn = NULL; if( poSRSTarget->exportToProj4( &pszDstProj4Defn ) != OGRERR_NONE ) { CPLFree( pszSrcProj4Defn ); CPLFree( pszDstProj4Defn ); return FALSE; } if( strlen(pszDstProj4Defn) == 0 ) { CPLFree( pszSrcProj4Defn ); CPLFree( pszDstProj4Defn ); CPLError( CE_Failure, CPLE_AppDefined, "No PROJ.4 translation for destination SRS, coordinate\n" "transformation initialization has failed." ); return FALSE; } /* -------------------------------------------------------------------- */ /* Optimization to avoid useless nadgrids evaluation. */ /* For example when converting between WGS84 and WebMercator */ /* -------------------------------------------------------------------- */ if( pszSrcProj4Defn[strlen(pszSrcProj4Defn)-1] == ' ' ) pszSrcProj4Defn[strlen(pszSrcProj4Defn)-1] = 0; if( pszDstProj4Defn[strlen(pszDstProj4Defn)-1] == ' ' ) pszDstProj4Defn[strlen(pszDstProj4Defn)-1] = 0; char* pszNeedle = strstr(pszSrcProj4Defn, " "); if( pszNeedle ) memmove(pszNeedle, pszNeedle + 1, strlen(pszNeedle + 1)+1); pszNeedle = strstr(pszDstProj4Defn, " "); if( pszNeedle ) memmove(pszNeedle, pszNeedle + 1, strlen(pszNeedle + 1)+1); if( (strstr(pszSrcProj4Defn, "+datum=WGS84") != NULL || strstr(pszSrcProj4Defn, "+ellps=WGS84 +towgs84=0,0,0,0,0,0,0 ") != NULL) && strstr(pszDstProj4Defn, "+nadgrids=@null ") != NULL && strstr(pszDstProj4Defn, "+towgs84") == NULL ) { char* pszDst = strstr(pszSrcProj4Defn, "+towgs84=0,0,0,0,0,0,0 "); if( pszDst != NULL ) { char *pszSrc = pszDst + strlen("+towgs84=0,0,0,0,0,0,0 "); memmove(pszDst, pszSrc, strlen(pszSrc)+1); } else { memcpy(strstr(pszSrcProj4Defn, "+datum=WGS84"), "+ellps", 6); } pszDst = strstr(pszDstProj4Defn, "+nadgrids=@null "); char *pszSrc = pszDst + strlen("+nadgrids=@null "); memmove(pszDst, pszSrc, strlen(pszSrc)+1); pszDst = strstr(pszDstProj4Defn, "+wktext "); if( pszDst ) { pszSrc = pszDst + strlen("+wktext "); memmove(pszDst, pszSrc, strlen(pszSrc)+1); } //bWGS84ToWebMercator = // strcmp(pszSrcProj4Defn, "+proj=longlat +ellps=WGS84 +no_defs") == 0 && // strcmp(pszDstProj4Defn, "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +no_defs") == 0; } else if( (strstr(pszDstProj4Defn, "+datum=WGS84") != NULL || strstr(pszDstProj4Defn, "+ellps=WGS84 +towgs84=0,0,0,0,0,0,0 ") != NULL) && strstr(pszSrcProj4Defn, "+nadgrids=@null ") != NULL && strstr(pszSrcProj4Defn, "+towgs84") == NULL ) { char* pszDst = strstr(pszDstProj4Defn, "+towgs84=0,0,0,0,0,0,0 "); if( pszDst != NULL) { char* pszSrc = pszDst + strlen("+towgs84=0,0,0,0,0,0,0 "); memmove(pszDst, pszSrc, strlen(pszSrc)+1); } else memcpy(strstr(pszDstProj4Defn, "+datum=WGS84"), "+ellps", 6); pszDst = strstr(pszSrcProj4Defn, "+nadgrids=@null "); char* pszSrc = pszDst + strlen("+nadgrids=@null "); memmove(pszDst, pszSrc, strlen(pszSrc)+1); pszDst = strstr(pszSrcProj4Defn, "+wktext "); if( pszDst ) { pszSrc = pszDst + strlen("+wktext "); memmove(pszDst, pszSrc, strlen(pszSrc)+1); } bWebMercatorToWGS84 = strcmp(pszDstProj4Defn, "+proj=longlat +ellps=WGS84 +no_defs") == 0 && strcmp(pszSrcProj4Defn, "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 " "+x_0=0.0 +y_0=0 +k=1.0 +units=m +no_defs") == 0; } /* -------------------------------------------------------------------- */ /* Establish PROJ.4 handle for source if projection. */ /* -------------------------------------------------------------------- */ if( !bWebMercatorToWGS84 ) { if (pjctx) psPJSource = pfn_pj_init_plus_ctx( pjctx, pszSrcProj4Defn ); else psPJSource = pfn_pj_init_plus( pszSrcProj4Defn ); if( psPJSource == NULL ) { if( pjctx != NULL) { int l_pj_errno = pfn_pj_ctx_get_errno(pjctx); /* pfn_pj_strerrno not yet thread-safe in PROJ 4.8.0 */ CPLMutexHolderD(&hPROJMutex); CPLError( CE_Failure, CPLE_NotSupported, "Failed to initialize PROJ.4 with `%s'.\n%s", pszSrcProj4Defn, pfn_pj_strerrno(l_pj_errno) ); } else if( pfn_pj_get_errno_ref != NULL && pfn_pj_strerrno != NULL ) { int *p_pj_errno = pfn_pj_get_errno_ref(); CPLError( CE_Failure, CPLE_NotSupported, "Failed to initialize PROJ.4 with `%s'.\n%s", pszSrcProj4Defn, pfn_pj_strerrno(*p_pj_errno) ); } else { CPLError( CE_Failure, CPLE_NotSupported, "Failed to initialize PROJ.4 with `%s'.\n", pszSrcProj4Defn ); } } } if( nDebugReportCount < 10 ) CPLDebug( "OGRCT", "Source: %s", pszSrcProj4Defn ); if( !bWebMercatorToWGS84 && psPJSource == NULL ) { CPLFree( pszSrcProj4Defn ); CPLFree( pszDstProj4Defn ); return FALSE; } /* -------------------------------------------------------------------- */ /* Establish PROJ.4 handle for target if projection. */ /* -------------------------------------------------------------------- */ if( !bWebMercatorToWGS84 ) { if (pjctx) psPJTarget = pfn_pj_init_plus_ctx( pjctx, pszDstProj4Defn ); else psPJTarget = pfn_pj_init_plus( pszDstProj4Defn ); if( psPJTarget == NULL ) CPLError( CE_Failure, CPLE_NotSupported, "Failed to initialize PROJ.4 with `%s'.", pszDstProj4Defn ); } if( nDebugReportCount < 10 ) { CPLDebug( "OGRCT", "Target: %s", pszDstProj4Defn ); nDebugReportCount++; } if( !bWebMercatorToWGS84 && psPJTarget == NULL ) { CPLFree( pszSrcProj4Defn ); CPLFree( pszDstProj4Defn ); return FALSE; } /* Determine if we really have a transformation to do */ bIdentityTransform = strcmp(pszSrcProj4Defn, pszDstProj4Defn) == 0; #if 0 /* In case of identity transform, under the following conditions, */ /* we can also avoid transforming from degrees <--> radians. */ if( bIdentityTransform && bSourceLatLong && !bSourceWrap && bTargetLatLong && !bTargetWrap && fabs(dfSourceToRadians * dfTargetFromRadians - 1.0) < 1e-10 ) { // bSourceLatLong = false; // bTargetLatLong = false; } #endif CPLFree( pszSrcProj4Defn ); CPLFree( pszDstProj4Defn ); return TRUE; }
bool OGRCSVDataSource::OpenTable( const char * pszFilename, char** papszOpenOptionsIn, const char* pszNfdcRunwaysGeomField, const char* pszGeonamesGeomFieldPrefix) { /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ VSILFILE *fp = NULL; if( bUpdate ) fp = VSIFOpenL( pszFilename, "rb+" ); else fp = VSIFOpenL( pszFilename, "rb" ); if( fp == NULL ) { CPLError( CE_Warning, CPLE_OpenFailed, "Failed to open %s, %s.", pszFilename, VSIStrerror( errno ) ); return false; } if( !bUpdate && strstr(pszFilename, "/vsigzip/") == NULL && strstr(pszFilename, "/vsizip/") == NULL ) fp = reinterpret_cast<VSILFILE *>( VSICreateBufferedReaderHandle( reinterpret_cast<VSIVirtualHandle *>( fp ) ) ); CPLString osLayerName = CPLGetBasename(pszFilename); CPLString osExt = CPLGetExtension(pszFilename); if( STARTS_WITH(pszFilename, "/vsigzip/") && EQUAL(osExt, "gz") ) { if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".csv.gz") ) { osLayerName = osLayerName.substr(0, osLayerName.size() - 4); osExt = "csv"; } else if( strlen(pszFilename) > 7 && EQUAL(pszFilename + strlen(pszFilename) - 7, ".tsv.gz") ) { osLayerName = osLayerName.substr(0, osLayerName.size() - 4); osExt = "tsv"; } } /* -------------------------------------------------------------------- */ /* Read and parse a line. Did we get multiple fields? */ /* -------------------------------------------------------------------- */ const char* pszLine = CPLReadLineL( fp ); if (pszLine == NULL) { VSIFCloseL( fp ); return false; } char chDelimiter = CSVDetectSeperator(pszLine); if( chDelimiter != '\t' && strchr(pszLine, '\t') != NULL ) { // Force the delimiter to be TAB for a .tsv file that has a tabulation // in its first line */ if( EQUAL(osExt, "tsv") ) { chDelimiter = '\t'; } else { for( int nDontHonourStrings = 0; nDontHonourStrings <= 1; nDontHonourStrings++ ) { const bool bDontHonourStrings = CPL_TO_BOOL(nDontHonourStrings); // Read the first 2 lines to see if they have the same number // of fields, if using tabulation. VSIRewindL( fp ); char** papszTokens = OGRCSVReadParseLineL( fp, '\t', bDontHonourStrings ); int nTokens1 = CSLCount(papszTokens); CSLDestroy(papszTokens); papszTokens = OGRCSVReadParseLineL( fp, '\t', bDontHonourStrings ); int nTokens2 = CSLCount(papszTokens); CSLDestroy(papszTokens); if( nTokens1 >= 2 && nTokens1 == nTokens2 ) { chDelimiter = '\t'; break; } } } } VSIRewindL( fp ); #if 0 const char *pszDelimiter = CSLFetchNameValueDef( papszOpenOptionsIn, "SEPARATOR", "AUTO"); if( !EQUAL(pszDelimiter, "AUTO") ) { if (EQUAL(pszDelimiter, "COMMA")) chDelimiter = ','; else if (EQUAL(pszDelimiter, "SEMICOLON")) chDelimiter = ';'; else if (EQUAL(pszDelimiter, "TAB")) chDelimiter = '\t'; else if (EQUAL(pszDelimiter, "SPACE")) chDelimiter = ' '; else { CPLError( CE_Warning, CPLE_AppDefined, "SEPARATOR=%s not understood, use one of COMMA, " "SEMICOLON, SPACE or TAB.", pszDelimiter ); } } #endif /* GNIS specific */ if (pszGeonamesGeomFieldPrefix != NULL && strchr(pszLine, '|') != NULL) chDelimiter = '|'; char **papszFields = OGRCSVReadParseLineL( fp, chDelimiter, false ); if( CSLCount(papszFields) < 2 ) { VSIFCloseL( fp ); CSLDestroy( papszFields ); return false; } VSIRewindL( fp ); CSLDestroy( papszFields ); /* -------------------------------------------------------------------- */ /* Create a layer. */ /* -------------------------------------------------------------------- */ nLayers++; papoLayers = static_cast<OGRLayer **>( CPLRealloc( papoLayers, sizeof(void*) * nLayers ) ); if (pszNfdcRunwaysGeomField != NULL) { osLayerName += "_"; osLayerName += pszNfdcRunwaysGeomField; } else if (pszGeonamesGeomFieldPrefix != NULL && !EQUAL(pszGeonamesGeomFieldPrefix, "")) { osLayerName += "_"; osLayerName += pszGeonamesGeomFieldPrefix; } if (EQUAL(pszFilename, "/vsistdin/")) osLayerName = "layer"; OGRCSVLayer* poCSVLayer = new OGRCSVLayer( osLayerName, fp, pszFilename, FALSE, bUpdate, chDelimiter ); poCSVLayer->BuildFeatureDefn( pszNfdcRunwaysGeomField, pszGeonamesGeomFieldPrefix, papszOpenOptionsIn ); OGRLayer* poLayer = poCSVLayer; if( bUpdate ) { poLayer = new OGRCSVEditableLayer(poCSVLayer, papszOpenOptionsIn); } papoLayers[nLayers-1] = poLayer; return true; }
CPLErr VRTFilteredSource::RasterIO( GDALDataType eBandDataType, int nXOff, int nYOff, int nXSize, int nYSize, void *pData, int nBufXSize, int nBufYSize, GDALDataType eBufType, GSpacing nPixelSpace, GSpacing nLineSpace, GDALRasterIOExtraArg* psExtraArg ) { /* -------------------------------------------------------------------- */ /* For now we don't support filtered access to non-full */ /* resolution requests. Just collect the data directly without */ /* any operator. */ /* -------------------------------------------------------------------- */ if( nBufXSize != nXSize || nBufYSize != nYSize ) { return VRTComplexSource::RasterIO( eBandDataType, nXOff, nYOff, nXSize, nYSize, pData, nBufXSize, nBufYSize, eBufType, nPixelSpace, nLineSpace, psExtraArg ); } // The window we will actually request from the source raster band. double dfReqXOff = 0.0; double dfReqYOff = 0.0; double dfReqXSize = 0.0; double dfReqYSize = 0.0; int nReqXOff = 0; int nReqYOff = 0; int nReqXSize = 0; int nReqYSize = 0; // The window we will actual set _within_ the pData buffer. int nOutXOff = 0; int nOutYOff = 0; int nOutXSize = 0; int nOutYSize = 0; if( !GetSrcDstWindow( nXOff, nYOff, nXSize, nYSize, nBufXSize, nBufYSize, &dfReqXOff, &dfReqYOff, &dfReqXSize, &dfReqYSize, &nReqXOff, &nReqYOff, &nReqXSize, &nReqYSize, &nOutXOff, &nOutYOff, &nOutXSize, &nOutYSize ) ) return CE_None; pData = reinterpret_cast<GByte *>( pData ) + nPixelSpace * nOutXOff + nLineSpace * nOutYOff; /* -------------------------------------------------------------------- */ /* Determine the data type we want to request. We try to match */ /* the source or destination request, and if both those fail we */ /* fallback to the first supported type at least as expressive */ /* as the request. */ /* -------------------------------------------------------------------- */ GDALDataType eOperDataType = GDT_Unknown; if( IsTypeSupported( eBufType ) ) eOperDataType = eBufType; if( eOperDataType == GDT_Unknown && IsTypeSupported( m_poRasterBand->GetRasterDataType() ) ) eOperDataType = m_poRasterBand->GetRasterDataType(); if( eOperDataType == GDT_Unknown ) { for( int i = 0; i < m_nSupportedTypesCount; i++ ) { if( GDALDataTypeUnion( m_aeSupportedTypes[i], eBufType ) == m_aeSupportedTypes[i] ) { eOperDataType = m_aeSupportedTypes[i]; } } } if( eOperDataType == GDT_Unknown ) { eOperDataType = m_aeSupportedTypes[0]; for( int i = 1; i < m_nSupportedTypesCount; i++ ) { if( GDALGetDataTypeSize( m_aeSupportedTypes[i] ) > GDALGetDataTypeSize( eOperDataType ) ) { eOperDataType = m_aeSupportedTypes[i]; } } } /* -------------------------------------------------------------------- */ /* Allocate the buffer of data into which our imagery will be */ /* read, with the extra edge pixels as well. This will be the */ /* source data fed into the filter. */ /* -------------------------------------------------------------------- */ if( nOutXSize > INT_MAX - 2 * m_nExtraEdgePixels || nOutYSize > INT_MAX - 2 * m_nExtraEdgePixels ) { return CE_Failure; } const int nExtraXSize = nOutXSize + 2 * m_nExtraEdgePixels; const int nExtraYSize = nOutYSize + 2 * m_nExtraEdgePixels; GByte *pabyWorkData = static_cast<GByte *>( VSI_MALLOC3_VERBOSE( nExtraXSize, nExtraYSize, GDALGetDataTypeSizeBytes(eOperDataType)) ); if( pabyWorkData == nullptr ) { return CE_Failure; } const GPtrDiff_t nPixelOffset = GDALGetDataTypeSizeBytes( eOperDataType ); const GPtrDiff_t nLineOffset = nPixelOffset * nExtraXSize; memset( pabyWorkData, 0, nLineOffset * nExtraYSize ); /* -------------------------------------------------------------------- */ /* Allocate the output buffer in the same dimensions as the work */ /* buffer. This allows the filter process to write edge pixels */ /* if needed for two-pass (separable) filtering. */ /* -------------------------------------------------------------------- */ GByte *pabyOutData = static_cast<GByte *>( VSI_MALLOC3_VERBOSE( nExtraXSize, nExtraYSize, nPixelOffset ) ); if( pabyOutData == nullptr ) { CPLFree( pabyWorkData ); return CE_Failure; } /* -------------------------------------------------------------------- */ /* Figure out the extended window that we want to load. Note */ /* that we keep track of the file window as well as the amount */ /* we will need to edge fill past the edge of the source dataset. */ /* -------------------------------------------------------------------- */ int nFileXOff = nReqXOff - m_nExtraEdgePixels; int nFileYOff = nReqYOff - m_nExtraEdgePixels; int nFileXSize = nExtraXSize; int nFileYSize = nExtraYSize; int nTopFill = 0; int nLeftFill = 0; int nRightFill = 0; int nBottomFill = 0; if( nFileXOff < 0 ) { nLeftFill = -nFileXOff; nFileXOff = 0; nFileXSize -= nLeftFill; } if( nFileYOff < 0 ) { nTopFill = -nFileYOff; nFileYOff = 0; nFileYSize -= nTopFill; } if( nFileXOff + nFileXSize > m_poRasterBand->GetXSize() ) { nRightFill = nFileXOff + nFileXSize - m_poRasterBand->GetXSize(); nFileXSize -= nRightFill; } if( nFileYOff + nFileYSize > m_poRasterBand->GetYSize() ) { nBottomFill = nFileYOff + nFileYSize - m_poRasterBand->GetYSize(); nFileYSize -= nBottomFill; } /* -------------------------------------------------------------------- */ /* Load the data. */ /* -------------------------------------------------------------------- */ { const bool bIsComplex = CPL_TO_BOOL( GDALDataTypeIsComplex(eOperDataType) ); const CPLErr eErr = VRTComplexSource::RasterIOInternal<float>( nFileXOff, nFileYOff, nFileXSize, nFileYSize, pabyWorkData + nLineOffset * nTopFill + nPixelOffset * nLeftFill, nFileXSize, nFileYSize, eOperDataType, nPixelOffset, nLineOffset, psExtraArg, bIsComplex ? GDT_CFloat32 : GDT_Float32 ); if( eErr != CE_None ) { VSIFree( pabyWorkData ); VSIFree( pabyOutData ); return eErr; } } /* -------------------------------------------------------------------- */ /* Fill in missing areas. Note that we replicate the edge */ /* valid values out. We don't using "mirroring" which might be */ /* more suitable for some times of filters. We also don't mark */ /* these pixels as "nodata" though perhaps we should. */ /* -------------------------------------------------------------------- */ if( nLeftFill != 0 || nRightFill != 0 ) { for( int i = nTopFill; i < nExtraYSize - nBottomFill; i++ ) { if( nLeftFill != 0 ) GDALCopyWords( pabyWorkData + nPixelOffset * nLeftFill + i * nLineOffset, eOperDataType, 0, pabyWorkData + i * nLineOffset, eOperDataType, static_cast<int>(nPixelOffset), nLeftFill ); if( nRightFill != 0 ) GDALCopyWords( pabyWorkData + i * nLineOffset + nPixelOffset * (nExtraXSize - nRightFill - 1), eOperDataType, 0, pabyWorkData + i * nLineOffset + nPixelOffset * (nExtraXSize - nRightFill), eOperDataType, static_cast<int>(nPixelOffset), nRightFill ); } } for( int i = 0; i < nTopFill; i++ ) { memcpy( pabyWorkData + i * nLineOffset, pabyWorkData + nTopFill * nLineOffset, nLineOffset ); } for( int i = nExtraYSize - nBottomFill; i < nExtraYSize; i++ ) { memcpy( pabyWorkData + i * nLineOffset, pabyWorkData + (nExtraYSize - nBottomFill - 1) * nLineOffset, nLineOffset ); } /* -------------------------------------------------------------------- */ /* Filter the data. */ /* -------------------------------------------------------------------- */ const CPLErr eErr = FilterData( nExtraXSize, nExtraYSize, eOperDataType, pabyWorkData, pabyOutData ); VSIFree( pabyWorkData ); if( eErr != CE_None ) { VSIFree( pabyOutData ); return eErr; } /* -------------------------------------------------------------------- */ /* Copy from work buffer to target buffer. */ /* -------------------------------------------------------------------- */ GByte *pabySrcRow = pabyOutData + (nLineOffset + nPixelOffset) * m_nExtraEdgePixels; GByte *pabyDstRow = reinterpret_cast<GByte *>( pData ); for( int i = 0; i < nOutYSize; i++, pabySrcRow += nLineOffset, pabyDstRow += nLineSpace ) { GDALCopyWords( pabySrcRow, eOperDataType, static_cast<int>(nPixelOffset), pabyDstRow, eBufType, static_cast<int>(nPixelSpace), nOutXSize ); } VSIFree( pabyOutData ); return CE_None; }
int OGRAmigoCloudDataSource::Open( const char * pszFilename, char** papszOpenOptionsIn, int bUpdateIn ) { bReadWrite = CPL_TO_BOOL(bUpdateIn); pszName = CPLStrdup( pszFilename ); pszProjectId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:")); char* pchSpace = strchr(pszProjectId, ' '); if( pchSpace ) *pchSpace = '\0'; if( pszProjectId[0] == 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Missing project id"); return FALSE; } osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "AMIGOCLOUD_API_KEY", CPLGetConfigOption("AMIGOCLOUD_API_KEY", "")); if (osAPIKey.empty()) { osAPIKey = OGRAMIGOCLOUDGetOptionValue(pszFilename, "AMIGOCLOUD_API_KEY"); } if (osAPIKey.empty()) { CPLError(CE_Failure, CPLE_AppDefined, "AMIGOCLOUD_API_KEY is not defined.\n"); return FALSE; } OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()"); if( poSchemaLayer ) { OGRFeature* poFeat = poSchemaLayer->GetNextFeature(); if( poFeat ) { if( poFeat->GetFieldCount() == 1 ) { osCurrentSchema = poFeat->GetFieldAsString(0); } delete poFeat; } ReleaseResultSet(poSchemaLayer); } if( osCurrentSchema.empty() ) return FALSE; CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets"); if (!osDatasets.empty()) { char** papszTables = CSLTokenizeString2(osDatasets, ",", 0); for(int i=0;papszTables && papszTables[i];i++) { papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc( papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*)); papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]); } CSLDestroy(papszTables); // If OVERWRITE: YES, truncate the layer. if( nLayers==1 && CPLFetchBool(papszOpenOptionsIn, "OVERWRITE", false) ) { TruncateDataset(papoLayers[0]->GetTableName()); } return TRUE; } else { // If 'datasets' word is in the filename, but no dataset id specified, // print the list of available datasets if(std::string(pszFilename).find("datasets") != std::string::npos) ListDatasets(); } return TRUE; }
int OGRS57DataSource::Open( const char * pszFilename ) { pszName = CPLStrdup( pszFilename ); /* -------------------------------------------------------------------- */ /* Setup reader options. */ /* -------------------------------------------------------------------- */ char **papszReaderOptions = NULL; if( GetOption(S57O_LNAM_REFS) == NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_LNAM_REFS, "ON" ); else papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_LNAM_REFS, GetOption(S57O_LNAM_REFS) ); if( GetOption(S57O_UPDATES) != NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_UPDATES, GetOption(S57O_UPDATES)); if( GetOption(S57O_SPLIT_MULTIPOINT) != NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_SPLIT_MULTIPOINT, GetOption(S57O_SPLIT_MULTIPOINT) ); if( GetOption(S57O_ADD_SOUNDG_DEPTH) != NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_ADD_SOUNDG_DEPTH, GetOption(S57O_ADD_SOUNDG_DEPTH)); if( GetOption(S57O_PRESERVE_EMPTY_NUMBERS) != NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_PRESERVE_EMPTY_NUMBERS, GetOption(S57O_PRESERVE_EMPTY_NUMBERS) ); if( GetOption(S57O_RETURN_PRIMITIVES) != NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_RETURN_PRIMITIVES, GetOption(S57O_RETURN_PRIMITIVES) ); if( GetOption(S57O_RETURN_LINKAGES) != NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_RETURN_LINKAGES, GetOption(S57O_RETURN_LINKAGES) ); if( GetOption(S57O_RETURN_DSID) != NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_RETURN_DSID, GetOption(S57O_RETURN_DSID) ); if( GetOption(S57O_RECODE_BY_DSSI) != NULL ) papszReaderOptions = CSLSetNameValue( papszReaderOptions, S57O_RECODE_BY_DSSI, GetOption(S57O_RECODE_BY_DSSI) ); S57Reader *poModule = new S57Reader( pszFilename ); int bRet = poModule->SetOptions( papszReaderOptions ); CSLDestroy( papszReaderOptions ); if( !bRet ) { delete poModule; return FALSE; } /* -------------------------------------------------------------------- */ /* Try opening. */ /* */ /* Eventually this should check for catalogs, and if found */ /* instantiate a whole series of modules. */ /* -------------------------------------------------------------------- */ if( !poModule->Open( TRUE ) ) { delete poModule; return FALSE; } bool bSuccess = true; nModules = 1; papoModules = static_cast<S57Reader **>( CPLMalloc(sizeof(void*)) ); papoModules[0] = poModule; /* -------------------------------------------------------------------- */ /* Add the header layers if they are called for. */ /* -------------------------------------------------------------------- */ if( GetOption( S57O_RETURN_DSID ) == NULL || CPLTestBool(GetOption( S57O_RETURN_DSID )) ) { OGRFeatureDefn *poDefn = S57GenerateDSIDFeatureDefn(); AddLayer( new OGRS57Layer( this, poDefn ) ); } /* -------------------------------------------------------------------- */ /* Add the primitive layers if they are called for. */ /* -------------------------------------------------------------------- */ if( GetOption( S57O_RETURN_PRIMITIVES ) != NULL ) { OGRFeatureDefn *poDefn = S57GenerateVectorPrimitiveFeatureDefn( RCNM_VI, poModule->GetOptionFlags()); AddLayer( new OGRS57Layer( this, poDefn ) ); poDefn = S57GenerateVectorPrimitiveFeatureDefn( RCNM_VC, poModule->GetOptionFlags()); AddLayer( new OGRS57Layer( this, poDefn ) ); poDefn = S57GenerateVectorPrimitiveFeatureDefn( RCNM_VE, poModule->GetOptionFlags()); AddLayer( new OGRS57Layer( this, poDefn ) ); poDefn = S57GenerateVectorPrimitiveFeatureDefn( RCNM_VF, poModule->GetOptionFlags()); AddLayer( new OGRS57Layer( this, poDefn ) ); } /* -------------------------------------------------------------------- */ /* Initialize a layer for each type of geometry. Eventually */ /* we will do this by object class. */ /* -------------------------------------------------------------------- */ if( OGRS57Driver::GetS57Registrar() == NULL ) { OGRFeatureDefn *poDefn = S57GenerateGeomFeatureDefn( wkbPoint, poModule->GetOptionFlags() ); AddLayer( new OGRS57Layer( this, poDefn ) ); poDefn = S57GenerateGeomFeatureDefn( wkbLineString, poModule->GetOptionFlags() ); AddLayer( new OGRS57Layer( this, poDefn ) ); poDefn = S57GenerateGeomFeatureDefn( wkbPolygon, poModule->GetOptionFlags() ); AddLayer( new OGRS57Layer( this, poDefn ) ); poDefn = S57GenerateGeomFeatureDefn( wkbNone, poModule->GetOptionFlags() ); AddLayer( new OGRS57Layer( this, poDefn ) ); } /* -------------------------------------------------------------------- */ /* Initialize a feature definition for each class that actually */ /* occurs in the dataset. */ /* -------------------------------------------------------------------- */ else { poClassContentExplorer = new S57ClassContentExplorer( OGRS57Driver::GetS57Registrar() ); for( int iModule = 0; iModule < nModules; iModule++ ) papoModules[iModule]->SetClassBased( OGRS57Driver::GetS57Registrar(), poClassContentExplorer ); std::vector<int> anClassCount; for( int iModule = 0; iModule < nModules; iModule++ ) { bSuccess &= CPL_TO_BOOL( papoModules[iModule]->CollectClassList(anClassCount) ); } bool bGeneric = false; for( unsigned int iClass = 0; iClass < anClassCount.size(); iClass++ ) { if( anClassCount[iClass] > 0 ) { OGRFeatureDefn *poDefn = S57GenerateObjectClassDefn( OGRS57Driver::GetS57Registrar(), poClassContentExplorer, iClass, poModule->GetOptionFlags() ); if( poDefn != NULL ) AddLayer( new OGRS57Layer( this, poDefn, anClassCount[iClass] ) ); else { bGeneric = true; CPLDebug( "S57", "Unable to find definition for OBJL=%d\n", iClass ); } } } if( bGeneric ) { OGRFeatureDefn *poDefn = S57GenerateGeomFeatureDefn( wkbUnknown, poModule->GetOptionFlags() ); AddLayer( new OGRS57Layer( this, poDefn ) ); } } /* -------------------------------------------------------------------- */ /* Attach the layer definitions to each of the readers. */ /* -------------------------------------------------------------------- */ for( int iModule = 0; iModule < nModules; iModule++ ) { for( int iLayer = 0; iLayer < nLayers; iLayer++ ) { papoModules[iModule]->AddFeatureDefn( papoLayers[iLayer]->GetLayerDefn() ); } } return bSuccess; }
int OGRAmigoCloudDataSource::Open( const char * pszFilename, char** papszOpenOptionsIn, int bUpdateIn ) { bReadWrite = CPL_TO_BOOL(bUpdateIn); pszName = CPLStrdup( pszFilename ); if( CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID") ) pszProjetctId = CPLStrdup(CSLFetchNameValue(papszOpenOptionsIn, "PROJECTID")); else { pszProjetctId = CPLStrdup(pszFilename + strlen("AMIGOCLOUD:")); char* pchSpace = strchr(pszProjetctId, ' '); if( pchSpace ) *pchSpace = '\0'; if( pszProjetctId[0] == 0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Missing projetc id"); return FALSE; } } osAPIKey = CSLFetchNameValueDef(papszOpenOptionsIn, "API_KEY", CPLGetConfigOption("AMIGOCLOUD_API_KEY", "")); CPLString osDatasets = OGRAMIGOCLOUDGetOptionValue(pszFilename, "datasets"); bUseHTTPS = CPLTestBool(CPLGetConfigOption("AMIGOCLOUD_HTTPS", "YES")); OGRLayer* poSchemaLayer = ExecuteSQLInternal("SELECT current_schema()"); if( poSchemaLayer ) { OGRFeature* poFeat = poSchemaLayer->GetNextFeature(); if( poFeat ) { if( poFeat->GetFieldCount() == 1 ) { osCurrentSchema = poFeat->GetFieldAsString(0); } delete poFeat; } ReleaseResultSet(poSchemaLayer); } if( osCurrentSchema.size() == 0 ) return FALSE; if (osDatasets.size() != 0) { char** papszTables = CSLTokenizeString2(osDatasets, ",", 0); for(int i=0;papszTables && papszTables[i];i++) { papoLayers = (OGRAmigoCloudTableLayer**) CPLRealloc( papoLayers, (nLayers + 1) * sizeof(OGRAmigoCloudTableLayer*)); papoLayers[nLayers ++] = new OGRAmigoCloudTableLayer(this, papszTables[i]); } CSLDestroy(papszTables); return TRUE; } return TRUE; }
bool OGRShapeDataSource::Open( GDALOpenInfo* poOpenInfo, bool bTestOpen, bool bForceSingleFileDataSource ) { CPLAssert( nLayers == 0 ); const char * pszNewName = poOpenInfo->pszFilename; const bool bUpdate = poOpenInfo->eAccess == GA_Update; papszOpenOptions = CSLDuplicate( poOpenInfo->papszOpenOptions ); pszName = CPLStrdup( pszNewName ); bDSUpdate = bUpdate; bSingleFileDataSource = CPL_TO_BOOL(bForceSingleFileDataSource); /* -------------------------------------------------------------------- */ /* If bSingleFileDataSource is TRUE we don't try to do anything */ /* else. */ /* This is only utilized when the OGRShapeDriver::Create() */ /* method wants to create a stub OGRShapeDataSource for a */ /* single shapefile. The driver will take care of creating the */ /* file by calling ICreateLayer(). */ /* -------------------------------------------------------------------- */ if( bSingleFileDataSource ) return true; /* -------------------------------------------------------------------- */ /* Is the given path a directory or a regular file? */ /* -------------------------------------------------------------------- */ if( !poOpenInfo->bStatOK ) { if( !bTestOpen ) CPLError( CE_Failure, CPLE_AppDefined, "%s is neither a file or directory, Shape access failed.", pszNewName ); return false; } /* -------------------------------------------------------------------- */ /* Build a list of filenames we figure are Shape files. */ /* -------------------------------------------------------------------- */ if( !poOpenInfo->bIsDirectory ) { if( !OpenFile( pszNewName, bUpdate ) ) { if( !bTestOpen ) CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open shapefile %s. " "It may be corrupt or read-only file accessed in " "update mode.", pszNewName ); return false; } bSingleFileDataSource = true; return true; } else { char **papszCandidates = VSIReadDir( pszNewName ); const int nCandidateCount = CSLCount( papszCandidates ); bool bMightBeOldCoverage = false; std::set<CPLString> osLayerNameSet; for( int iCan = 0; iCan < nCandidateCount; iCan++ ) { const char *pszCandidate = papszCandidates[iCan]; const char *pszLayerName = CPLGetBasename(pszCandidate); CPLString osLayerName(pszLayerName); #ifdef WIN32 // On Windows, as filenames are case insensitive, a shapefile layer // can be made of foo.shp and FOO.DBF, so to detect unique layer // names, put them upper case in the unique set used for detection. osLayerName.toupper(); #endif if( EQUAL(pszCandidate,"ARC") ) bMightBeOldCoverage = true; if( strlen(pszCandidate) < 4 || !EQUAL(pszCandidate+strlen(pszCandidate)-4,".shp") ) continue; char *pszFilename = CPLStrdup(CPLFormFilename(pszNewName, pszCandidate, NULL)); osLayerNameSet.insert(osLayerName); #ifdef IMMEDIATE_OPENING if( !OpenFile( pszFilename, bUpdate ) && !bTestOpen ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open shapefile %s. " "It may be corrupt or read-only file accessed in " "update mode.", pszFilename ); CPLFree( pszFilename ); CSLDestroy( papszCandidates ); return false; } #else oVectorLayerName.push_back(pszFilename); #endif CPLFree( pszFilename ); } // Try and .dbf files without apparent associated shapefiles. for( int iCan = 0; iCan < nCandidateCount; iCan++ ) { const char *pszCandidate = papszCandidates[iCan]; const char *pszLayerName = CPLGetBasename(pszCandidate); CPLString osLayerName(pszLayerName); #ifdef WIN32 osLayerName.toupper(); #endif // We don't consume .dbf files in a directory that looks like // an old style Arc/Info (for PC?) that unless we found at least // some shapefiles. See Bug 493. if( bMightBeOldCoverage && osLayerNameSet.size() == 0 ) continue; if( strlen(pszCandidate) < 4 || !EQUAL(pszCandidate+strlen(pszCandidate)-4, ".dbf") ) continue; if( osLayerNameSet.find(osLayerName) != osLayerNameSet.end() ) continue; // We don't want to access .dbf files with an associated .tab // file, or it will never get recognised as a mapinfo dataset. bool bFoundTAB = false; for( int iCan2 = 0; iCan2 < nCandidateCount; iCan2++ ) { const char *pszCandidate2 = papszCandidates[iCan2]; if( EQUALN(pszCandidate2, pszLayerName, strlen(pszLayerName)) && EQUAL(pszCandidate2 + strlen(pszLayerName), ".tab") ) bFoundTAB = true; } if( bFoundTAB ) continue; char *pszFilename = CPLStrdup(CPLFormFilename(pszNewName, pszCandidate, NULL)); osLayerNameSet.insert(osLayerName); #ifdef IMMEDIATE_OPENING if( !OpenFile( pszFilename, bUpdate ) && !bTestOpen ) { CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open dbf file %s. " "It may be corrupt or read-only file accessed in " "update mode.", pszFilename ); CPLFree( pszFilename ); CSLDestroy( papszCandidates ); return false; } #else oVectorLayerName.push_back(pszFilename); #endif CPLFree( pszFilename ); } CSLDestroy( papszCandidates ); #ifdef IMMEDIATE_OPENING const int nDirLayers = nLayers; #else const int nDirLayers = static_cast<int>(oVectorLayerName.size()); #endif CPLErrorReset(); return nDirLayers > 0 || !bTestOpen; } }
OGRLayer * OGRCouchDBDataSource::ExecuteSQLStats( const char *pszSQLCommand ) { swq_select sSelectInfo; if( sSelectInfo.preparse( pszSQLCommand ) != CE_None ) { return NULL; } if (sSelectInfo.table_count != 1) { return NULL; } swq_table_def *psTableDef = &sSelectInfo.table_defs[0]; if( psTableDef->data_source != NULL ) { return NULL; } OGRCouchDBLayer* _poSrcLayer = (OGRCouchDBLayer* )GetLayerByName( psTableDef->table_name ); if (_poSrcLayer == NULL) { return NULL; } if (_poSrcLayer->GetLayerType() != COUCHDB_TABLE_LAYER) return NULL; OGRCouchDBTableLayer* poSrcLayer = (OGRCouchDBTableLayer* ) _poSrcLayer; int nFieldCount = poSrcLayer->GetLayerDefn()->GetFieldCount(); swq_field_list sFieldList; memset( &sFieldList, 0, sizeof(sFieldList) ); sFieldList.table_count = sSelectInfo.table_count; sFieldList.table_defs = sSelectInfo.table_defs; sFieldList.count = 0; sFieldList.names = static_cast<char **>( CPLMalloc( sizeof(char *) * nFieldCount )); sFieldList.types = static_cast<swq_field_type *>( CPLMalloc( sizeof(swq_field_type) * nFieldCount )); sFieldList.table_ids = static_cast<int *>( CPLMalloc( sizeof(int) * nFieldCount )); sFieldList.ids = static_cast<int *>( CPLMalloc( sizeof(int) * nFieldCount )); PointerAutoFree oHolderNames(sFieldList.names); PointerAutoFree oHolderTypes(sFieldList.types); PointerAutoFree oHolderTableIds(sFieldList.table_ids); PointerAutoFree oHolderIds(sFieldList.ids); for( int iField = 0; iField < poSrcLayer->GetLayerDefn()->GetFieldCount(); iField++ ) { OGRFieldDefn *poFDefn=poSrcLayer->GetLayerDefn()->GetFieldDefn(iField); int iOutField = sFieldList.count++; sFieldList.names[iOutField] = (char *) poFDefn->GetNameRef(); if( poFDefn->GetType() == OFTInteger ) sFieldList.types[iOutField] = SWQ_INTEGER; else if( poFDefn->GetType() == OFTReal ) sFieldList.types[iOutField] = SWQ_FLOAT; else if( poFDefn->GetType() == OFTString ) sFieldList.types[iOutField] = SWQ_STRING; else sFieldList.types[iOutField] = SWQ_OTHER; sFieldList.table_ids[iOutField] = 0; sFieldList.ids[iOutField] = iField; } CPLString osLastFieldName; for( int iField = 0; iField < sSelectInfo.result_columns; iField++ ) { swq_col_def *psColDef = sSelectInfo.column_defs + iField; if (psColDef->field_name == NULL) return NULL; if (strcmp(psColDef->field_name, "*") != 0) { if (osLastFieldName.empty()) osLastFieldName = psColDef->field_name; else if (strcmp(osLastFieldName, psColDef->field_name) != 0) return NULL; if (poSrcLayer->GetLayerDefn()->GetFieldIndex(psColDef->field_name) == -1) return NULL; } if (!(psColDef->col_func == SWQCF_AVG || psColDef->col_func == SWQCF_MIN || psColDef->col_func == SWQCF_MAX || psColDef->col_func == SWQCF_COUNT || psColDef->col_func == SWQCF_SUM)) return NULL; if (psColDef->distinct_flag) /* TODO: could perhaps be relaxed */ return NULL; } if (osLastFieldName.empty()) return NULL; /* Normalize field name */ int nIndex = poSrcLayer->GetLayerDefn()->GetFieldIndex(osLastFieldName); osLastFieldName = poSrcLayer->GetLayerDefn()->GetFieldDefn(nIndex)->GetNameRef(); /* -------------------------------------------------------------------- */ /* Finish the parse operation. */ /* -------------------------------------------------------------------- */ if( sSelectInfo.parse( &sFieldList, NULL ) != CE_None ) { return NULL; } if (sSelectInfo.join_defs != NULL || sSelectInfo.where_expr != NULL || sSelectInfo.order_defs != NULL || sSelectInfo.query_mode != SWQM_SUMMARY_RECORD) { return NULL; } for( int iField = 0; iField < sSelectInfo.result_columns; iField++ ) { swq_col_def *psColDef = sSelectInfo.column_defs + iField; if (psColDef->field_index == -1) { if (psColDef->col_func == SWQCF_COUNT) continue; return NULL; } if (psColDef->field_type != SWQ_INTEGER && psColDef->field_type != SWQ_FLOAT) { return NULL; } } const bool bFoundFilter = CPL_TO_BOOL( poSrcLayer->HasFilterOnFieldOrCreateIfNecessary(osLastFieldName)); if( !bFoundFilter ) return NULL; CPLString osURI = "/"; osURI += poSrcLayer->GetName(); osURI += "/_design/ogr_filter_"; osURI += osLastFieldName; osURI += "/_view/filter?reduce=true"; json_object* poAnswerObj = GET(osURI); json_object* poRows = NULL; if (!(poAnswerObj != NULL && json_object_is_type(poAnswerObj, json_type_object) && (poRows = CPL_json_object_object_get(poAnswerObj, "rows")) != NULL && json_object_is_type(poRows, json_type_array))) { json_object_put(poAnswerObj); return NULL; } int nLength = json_object_array_length(poRows); if (nLength != 1) { json_object_put(poAnswerObj); return NULL; } json_object* poRow = json_object_array_get_idx(poRows, 0); if (!(poRow && json_object_is_type(poRow, json_type_object))) { json_object_put(poAnswerObj); return NULL; } json_object* poValue = CPL_json_object_object_get(poRow, "value"); if (!(poValue != NULL && json_object_is_type(poValue, json_type_object))) { json_object_put(poAnswerObj); return NULL; } json_object* poSum = CPL_json_object_object_get(poValue, "sum"); json_object* poCount = CPL_json_object_object_get(poValue, "count"); json_object* poMin = CPL_json_object_object_get(poValue, "min"); json_object* poMax = CPL_json_object_object_get(poValue, "max"); if (poSum != NULL && (json_object_is_type(poSum, json_type_int) || json_object_is_type(poSum, json_type_double)) && poCount != NULL && (json_object_is_type(poCount, json_type_int) || json_object_is_type(poCount, json_type_double)) && poMin != NULL && (json_object_is_type(poMin, json_type_int) || json_object_is_type(poMin, json_type_double)) && poMax != NULL && (json_object_is_type(poMax, json_type_int) || json_object_is_type(poMax, json_type_double)) ) { double dfSum = json_object_get_double(poSum); int nCount = json_object_get_int(poCount); double dfMin = json_object_get_double(poMin); double dfMax = json_object_get_double(poMax); json_object_put(poAnswerObj); //CPLDebug("CouchDB", "sum=%f, count=%d, min=%f, max=%f", // dfSum, nCount, dfMin, dfMax); OGRFeatureDefn* poFeatureDefn = new OGRFeatureDefn(poSrcLayer->GetName()); poFeatureDefn->Reference(); for( int iField = 0; iField < sSelectInfo.result_columns; iField++ ) { swq_col_def *psColDef = sSelectInfo.column_defs + iField; OGRFieldDefn oFDefn( "", OFTInteger ); if( psColDef->field_alias != NULL ) { oFDefn.SetName(psColDef->field_alias); } else { const swq_operation *op = swq_op_registrar::GetOperator( (swq_op) psColDef->col_func ); oFDefn.SetName( CPLSPrintf( "%s_%s", op->pszName, psColDef->field_name ) ); } if( psColDef->col_func == SWQCF_COUNT ) oFDefn.SetType( OFTInteger ); else if (psColDef->field_type == SWQ_INTEGER) oFDefn.SetType( OFTInteger ); else if (psColDef->field_type == SWQ_FLOAT) oFDefn.SetType( OFTReal ); poFeatureDefn->AddFieldDefn(&oFDefn); } OGRFeature* poFeature = new OGRFeature(poFeatureDefn); for( int iField = 0; iField < sSelectInfo.result_columns; iField++ ) { swq_col_def *psColDef = sSelectInfo.column_defs + iField; switch(psColDef->col_func) { case SWQCF_AVG: if (nCount) poFeature->SetField(iField, dfSum / nCount); break; case SWQCF_MIN: poFeature->SetField(iField, dfMin); break; case SWQCF_MAX: poFeature->SetField(iField, dfMax); break; case SWQCF_COUNT: poFeature->SetField(iField, nCount); break; case SWQCF_SUM: poFeature->SetField(iField, dfSum); break; default: break; } } poFeature->SetFID(0); OGRCouchDBOneLineLayer* poAnswerLayer = new OGRCouchDBOneLineLayer(); poAnswerLayer->poFeatureDefn = poFeatureDefn; poAnswerLayer->poFeature = poFeature; return poAnswerLayer; } json_object_put(poAnswerObj); return NULL; }
int GDALDefaultOverviews::HaveMaskFile( char ** papszSiblingFiles, const char *pszBasename ) { /* -------------------------------------------------------------------- */ /* Have we already checked for masks? */ /* -------------------------------------------------------------------- */ if( bCheckedForMask ) return poMaskDS != NULL; if( papszSiblingFiles == NULL ) papszSiblingFiles = papszInitSiblingFiles; /* -------------------------------------------------------------------- */ /* Are we an overview? If so we need to find the corresponding */ /* overview in the base files mask file (if there is one). */ /* -------------------------------------------------------------------- */ if( poBaseDS != NULL && poBaseDS->oOvManager.HaveMaskFile() ) { GDALRasterBand * const poBaseBand = poBaseDS->GetRasterBand(1); GDALRasterBand * poBaseMask = poBaseBand != NULL ? poBaseBand->GetMaskBand() : NULL; const int nOverviewCount = poBaseMask != NULL ? poBaseMask->GetOverviewCount() : 0; for( int iOver = 0; iOver < nOverviewCount; iOver++ ) { GDALRasterBand * const poOverBand = poBaseMask->GetOverview( iOver ); if( poOverBand == NULL ) continue; if( poOverBand->GetXSize() == poDS->GetRasterXSize() && poOverBand->GetYSize() == poDS->GetRasterYSize() ) { poMaskDS = poOverBand->GetDataset(); break; } } bCheckedForMask = true; bOwnMaskDS = false; CPLAssert( poMaskDS != poDS ); return poMaskDS != NULL; } /* -------------------------------------------------------------------- */ /* Are we even initialized? If not, we apparently don't want */ /* to support overviews and masks. */ /* -------------------------------------------------------------------- */ if( poDS == NULL ) return FALSE; /* -------------------------------------------------------------------- */ /* Check for .msk file. */ /* -------------------------------------------------------------------- */ bCheckedForMask = true; if( pszBasename == NULL ) pszBasename = poDS->GetDescription(); // Don't bother checking for masks of masks. if( EQUAL(CPLGetExtension(pszBasename),"msk") ) return FALSE; if( !GDALCanFileAcceptSidecarFile(pszBasename) ) return FALSE; CPLString osMskFilename; osMskFilename.Printf( "%s.msk", pszBasename ); std::vector<char> achMskFilename; achMskFilename.resize(osMskFilename.size() + 1); memcpy(&(achMskFilename[0]), osMskFilename.c_str(), osMskFilename.size() + 1); bool bExists = CPL_TO_BOOL( CPLCheckForFile( &achMskFilename[0], papszSiblingFiles ) ); osMskFilename = &achMskFilename[0]; #if !defined(WIN32) if( !bExists && !papszSiblingFiles ) { osMskFilename.Printf( "%s.MSK", pszBasename ); memcpy(&(achMskFilename[0]), osMskFilename.c_str(), osMskFilename.size() + 1); bExists = CPL_TO_BOOL( CPLCheckForFile( &achMskFilename[0], papszSiblingFiles ) ); osMskFilename = &achMskFilename[0]; } #endif if( !bExists ) return FALSE; /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ poMaskDS = static_cast<GDALDataset *>( GDALOpenEx( osMskFilename, GDAL_OF_RASTER | (poDS->GetAccess() == GA_Update ? GDAL_OF_UPDATE : 0), NULL, NULL, papszInitSiblingFiles )); CPLAssert( poMaskDS != poDS ); if( poMaskDS == NULL ) return FALSE; bOwnMaskDS = true; return TRUE; }