void OGRGeoJSONLayer::AddFeature( OGRFeature* poFeature ) { CPLAssert( NULL != poFeature ); // NOTE - mloskot: // Features may not be sorted according to FID values. // TODO: Should we check if feature already exists? // TODO: Think about sync operation, upload, etc. OGRFeature* poNewFeature = NULL; poNewFeature = poFeature->Clone(); if( -1 == poNewFeature->GetFID() ) { int nFID = static_cast<int>(seqFeatures_.size()); poNewFeature->SetFID( nFID ); // TODO - mlokot: We need to redesign creation of FID column int nField = poNewFeature->GetFieldIndex( DefaultFIDColumn ); if( -1 != nField && GetLayerDefn()->GetFieldDefn(nField)->GetType() == OFTInteger ) { poNewFeature->SetField( nField, nFID ); } } if( (GIntBig)(int)poNewFeature->GetFID() != poNewFeature->GetFID() ) SetMetadataItem(OLMD_FID64, "YES"); seqFeatures_.push_back( poNewFeature ); }
int FGdbDataSource::FixIndexes() { int bRet = TRUE; if( m_pConnection && m_pConnection->IsFIDHackInProgress() ) { m_pConnection->CloseGeodatabase(); char* apszDrivers[2]; apszDrivers[0] = (char*) "OpenFileGDB"; apszDrivers[1] = NULL; const char* pszSystemCatalog = CPLFormFilename(m_osFSName, "a00000001.gdbtable", NULL); GDALDataset* poOpenFileGDBDS = (GDALDataset*) GDALOpenEx(pszSystemCatalog, GDAL_OF_VECTOR, apszDrivers, NULL, NULL); if( poOpenFileGDBDS == NULL || poOpenFileGDBDS->GetLayer(0) == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot open %s with OpenFileGDB driver. " "Should not happen. Some layers will be corrupted", pszSystemCatalog); bRet = FALSE; } else { OGRLayer* poLayer = poOpenFileGDBDS->GetLayer(0); size_t count = m_layers.size(); for(size_t i = 0; i < count; ++i ) { if( m_layers[i]->m_oMapOGRFIDToFGDBFID.size() == 0) continue; CPLString osFilter = "name = '"; osFilter += m_layers[i]->GetName(); osFilter += "'"; poLayer->SetAttributeFilter(osFilter); poLayer->ResetReading(); OGRFeature* poF = poLayer->GetNextFeature(); if( poF == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot find filename for layer %s", m_layers[i]->GetName()); bRet = FALSE; } else { if( !m_layers[i]->EditIndexesForFIDHack(CPLFormFilename(m_osFSName, CPLSPrintf("a%08x", (int)poF->GetFID()), NULL)) ) { bRet = FALSE; } } delete poF; } } GDALClose(poOpenFileGDBDS); m_pConnection->SetFIDHackInProgress(FALSE); } return bRet; }
CPLErr GNMGenericNetwork::DisconnectFeatures(GNMGFID nSrcGFID, GNMGFID nTgtGFID, GNMGFID nConGFID) { if(!m_bIsGraphLoaded && LoadGraph() != CE_None) { return CE_Failure; } OGRFeature *poFeature = FindConnection(nSrcGFID, nTgtGFID, nConGFID); if (poFeature == NULL) { CPLError( CE_Failure, CPLE_AppDefined, "The connection not exist" ); return CE_Failure; } if (m_poGraphLayer->DeleteFeature(poFeature->GetFID()) != OGRERR_NONE) { OGRFeature::DestroyFeature(poFeature); return CE_Failure; } OGRFeature::DestroyFeature(poFeature); // update graph m_oGraph.DeleteEdge(nConGFID); return CE_None; }
OGRFeature *OGRAVCBinLayer::GetNextFeature() { if( bNeedReset ) ResetReading(); OGRFeature *poFeature = GetFeature( -3 ); // Skip universe polygon. if( poFeature != NULL && poFeature->GetFID() == 1 && psSection->eType == AVCFilePAL ) { OGRFeature::DestroyFeature( poFeature ); poFeature = GetFeature( -3 ); } while( poFeature != NULL && ((m_poAttrQuery != NULL && !m_poAttrQuery->Evaluate( poFeature ) ) || !FilterGeometry( poFeature->GetGeometryRef() ) ) ) { OGRFeature::DestroyFeature( poFeature ); poFeature = GetFeature( -3 ); } if( poFeature == NULL ) ResetReading(); return poFeature; }
OGRFeature *OGRDGNLayer::GetFeature( long nFeatureId ) { OGRFeature *poFeature; DGNElemCore *psElement; if( !DGNGotoElement( hDGN, nFeatureId ) ) return NULL; // We should likely clear the spatial search region as it affects // DGNReadElement() but I will defer that for now. psElement = DGNReadElement( hDGN ); poFeature = ElementToFeature( psElement ); DGNFreeElement( hDGN, psElement ); if( poFeature == NULL ) return NULL; if( poFeature->GetFID() != nFeatureId ) { delete poFeature; return NULL; } return poFeature; }
void Raster::CSVWriteVectorValues(OGRLayer * poLayer, const char * psFieldName, const char * sRasterOutputPath){ // use the filename with CSV added onto the end. QFileInfo sOutputFileInfo(sRasterOutputPath); QDir sNewDir = QDir(sOutputFileInfo.absolutePath()); QString sCSVFullPath = sNewDir.filePath(sOutputFileInfo.completeBaseName() + ".csv"); QFile csvFile(sCSVFullPath); if (csvFile.open(QFile::WriteOnly|QFile::Truncate)) { QTextStream stream(&csvFile); // Write CSV file header stream << "\"index\", " << "\""<< psFieldName << "\""<< "\n"; // this writes first line with two columns OGRFeature *poFeature; poLayer->ResetReading(); poLayer->SetSpatialFilter(NULL); while( (poFeature = poLayer->GetNextFeature()) != NULL){ const char * sFieldVal = poFeature->GetFieldAsString(psFieldName); // write line to file stream << poFeature->GetFID() << ", " << "\"" << sFieldVal << "\"" << "\n"; // this writes first line with two columns OGRFeature::DestroyFeature( poFeature ); } csvFile.close(); } return; }
OGRErr OGRLayerWithTransaction::ICreateFeature( OGRFeature *poFeature ) { if( !m_poDecoratedLayer ) return OGRERR_FAILURE; OGRFeature* poSrcFeature = new OGRFeature(m_poDecoratedLayer->GetLayerDefn()); poSrcFeature->SetFrom(poFeature); poSrcFeature->SetFID(poFeature->GetFID()); OGRErr eErr = m_poDecoratedLayer->CreateFeature(poSrcFeature); poFeature->SetFID(poSrcFeature->GetFID()); delete poSrcFeature; return eErr; }
OGRFeature* OGRESRIFeatureServiceLayer::GetNextFeature() { while( TRUE ) { int bWasInFirstPage = !bOtherPage; OGRFeature* poSrcFeat = poDS->GetUnderlyingLayer()->GetNextFeature(); if( poSrcFeat == NULL ) { if( !poDS->LoadNextPage() ) return NULL; poSrcFeat = poDS->GetUnderlyingLayer()->GetNextFeature(); if( poSrcFeat == NULL ) return NULL; bOtherPage = TRUE; } if( bOtherPage && bWasInFirstPage && poSrcFeat->GetFID() == 0 && nLastFID == nFeaturesRead - 1 ) { bUseSequentialFID = TRUE; } OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetFrom(poSrcFeat); if( bUseSequentialFID ) poFeature->SetFID(nFeaturesRead); else poFeature->SetFID(poSrcFeat->GetFID()); nLastFID = poFeature->GetFID(); nFeaturesRead ++; delete poSrcFeat; if((m_poFilterGeom == NULL || FilterGeometry( poFeature->GetGeometryRef() ) ) && (m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) ) { return poFeature; } delete poFeature; } }
OGRFeature * OGRLayerWithTransaction::GetFeature( GIntBig nFID ) { if( !m_poDecoratedLayer ) return NULL; OGRFeature* poSrcFeature = m_poDecoratedLayer->GetFeature(nFID); if( !poSrcFeature ) return NULL; OGRFeature* poFeature = new OGRFeature(GetLayerDefn()); poFeature->SetFrom(poSrcFeature); poFeature->SetFID(poSrcFeature->GetFID()); delete poSrcFeature; return poFeature; }
OGRFeature *OGRILI1Layer::GetFeatureRef( GIntBig nFID ) { ResetReading(); OGRFeature *poFeature = nullptr; while( (poFeature = GetNextFeatureRef()) != nullptr ) { if( poFeature->GetFID() == nFID ) return poFeature; } return nullptr; }
OGRFeature *OGRILI1Layer::GetFeatureRef( long nFID ) { OGRFeature *poFeature; ResetReading(); while( (poFeature = GetNextFeatureRef()) != NULL ) { if( poFeature->GetFID() == nFID ) return poFeature; } return NULL; }
OGRFeature* OGRGeoJSONSeqLayer::GetNextFeature() { while( true ) { auto poObject = GetNextObject(); if( !poObject ) return nullptr; OGRFeature* poFeature; auto type = OGRGeoJSONGetType(poObject); if( type == GeoJSONObject::eFeature ) { poFeature = m_oReader.ReadFeature( this, poObject, m_osFeatureBuffer.c_str() ); json_object_put(poObject); } else if( type == GeoJSONObject::eFeatureCollection || type == GeoJSONObject::eUnknown ) { json_object_put(poObject); continue; } else { OGRGeometry* poGeom = m_oReader.ReadGeometry(poObject, GetSpatialRef()); json_object_put(poObject); if( !poGeom ) { continue; } poFeature = new OGRFeature(m_poFeatureDefn); poFeature->SetGeometryDirectly(poGeom); } if( poFeature->GetFID() == OGRNullFID ) { poFeature->SetFID(m_nNextFID); m_nNextFID ++; } if( (m_poFilterGeom == nullptr || FilterGeometry(poFeature->GetGeomFieldRef(m_iGeomFieldFilter)) ) && (m_poAttrQuery == nullptr || m_poAttrQuery->Evaluate(poFeature)) ) { return poFeature; } delete poFeature; } }
void GDALClusterNeighbourhood::run() { ngView.createIndex(name_id1); leadingView.resetReading(); OGRFeature * f; std::map<int, int> visited; int marker = 0; while (f = leadingView.getNextFeature()) { int id = f->GetFID(); visited[id] = -1; } while (f = leadingView.getNextFeature()) { int id = f->GetFID(); if (visited[id] > 0) continue; marker++; getNext(id, marker, visited); } while (f = leadingView.getNextFeature()) { int id = f->GetFID(); f->SetField("cluster_id", visited[id]); } }
OGRFeature *OGRLayer::GetFeature( long nFID ) { OGRFeature *poFeature; ResetReading(); while( (poFeature = GetNextFeature()) != NULL ) { if( poFeature->GetFID() == nFID ) return poFeature; else delete poFeature; } return NULL; }
void RainWaterHarvestingOptions::run() { DM::Logger(DM::Debug) << "Init CD3"; if (!initmodel()) return; DM::Logger(DM::Debug) << "Init CD3 done"; OGRFeature * p; this->parcels.resetReading(); int counter = 0; while(p = this->parcels.getNextFeature()) { counter++; //Create Raintanks //Input Vectors std::vector<double> non_potable_demand_daily; std::vector<double> run_off_roof_daily; std::vector<double> outdoor_demand_daily; DM::DMFeature::GetDoubleList(p, "non_potable_demand_daily", non_potable_demand_daily); DM::DMFeature::GetDoubleList(p, "run_off_roof_daily", run_off_roof_daily); DM::DMFeature::GetDoubleList(p, "outdoor_demand_daily", outdoor_demand_daily); for (int i = 0; i < this->storage_volume_tank.size(); i++){ OGRFeature * rwht = rwhts.createFeature(); rwht->SetField("parcel_id", (int)p->GetFID()); this->createTankOption(rwht, QString::fromStdString(storage_volume_tank[i]).toDouble(), run_off_roof_daily, outdoor_demand_daily, non_potable_demand_daily); } double non_potable_demand = 0; double outdoor_demand = 0; for (int i = 0; i < outdoor_demand_daily.size(); i++) { outdoor_demand+=outdoor_demand_daily[i]; non_potable_demand+=non_potable_demand_daily[i]; } p->SetField("annual_outdoor_demand", outdoor_demand); p->SetField("annual_non_potable_demand", non_potable_demand); if (counter % 100000 == 0){ DM::Logger(DM::Standard) << counter; this->parcels.syncAlteredFeatures(); this->parcels.syncReadFeatures(); this->rwhts.syncAlteredFeatures(); this->parcels.setNextByIndex(counter); } } }
OGRErr OGRUnionLayer::ICreateFeature( OGRFeature* poFeature ) { if( osSourceLayerFieldName.size() == 0 ) { CPLError(CE_Failure, CPLE_NotSupported, "CreateFeature() not supported when SourceLayerFieldName is not set"); return OGRERR_FAILURE; } if( poFeature->GetFID() != OGRNullFID ) { CPLError(CE_Failure, CPLE_NotSupported, "CreateFeature() not supported when FID is set"); return OGRERR_FAILURE; } if( !poFeature->IsFieldSet(0) ) { CPLError(CE_Failure, CPLE_NotSupported, "CreateFeature() not supported when '%s' field is not set", osSourceLayerFieldName.c_str()); return OGRERR_FAILURE; } const char* pszSrcLayerName = poFeature->GetFieldAsString(0); for(int i=0;i<nSrcLayers;i++) { if( strcmp(pszSrcLayerName, papoSrcLayers[i]->GetName()) == 0) { pabModifiedLayers[i] = TRUE; OGRFeature* poSrcFeature = new OGRFeature(papoSrcLayers[i]->GetLayerDefn()); poSrcFeature->SetFrom(poFeature, TRUE); OGRErr eErr = papoSrcLayers[i]->CreateFeature(poSrcFeature); if( eErr == OGRERR_NONE ) poFeature->SetFID(poSrcFeature->GetFID()); delete poSrcFeature; return eErr; } } CPLError(CE_Failure, CPLE_NotSupported, "CreateFeature() not supported : '%s' source layer does not exist", pszSrcLayerName); return OGRERR_FAILURE; }
void GDALParcelSplit::run() { cityblocks.resetReading(); OGRFeature *poFeature; this->counter_added = 0; QThreadPool pool; while( (poFeature = cityblocks.getNextFeature()) != NULL ) { char* geo; poFeature->GetGeometryRef()->exportToWkt(&geo); //Geo destroyed by worker ParcelSplitWorker * ps = new ParcelSplitWorker(poFeature->GetFID(), this, this->width, this->target_length, this->splitFirst, geo); pool.start(ps); } pool.waitForDone(); this->generated = counter_added; }
OGRFeature* OGROpenFileGDBSimpleSQLLayer::GetFeature( GIntBig nFeatureId ) { OGRFeature* poSrcFeature = poBaseLayer->GetFeature(nFeatureId); if( poSrcFeature == NULL ) return NULL; if( poFeatureDefn == poBaseLayer->GetLayerDefn() ) return poSrcFeature; else { OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetFrom(poSrcFeature); poFeature->SetFID(poSrcFeature->GetFID()); delete poSrcFeature; return poFeature; } }
bool LoadShapes(GDALDataset* dataset, QueryIntermediateData& qid) { OGRLayer* waterLayer = dataset->GetLayerByName("water"); if (!waterLayer) return true; // requested layer may not be present in requested dataset waterLayer->ResetReading(); OGRFeature* feature; while ((feature = waterLayer->GetNextFeature()) != NULL) { auto geo = feature->GetGeometryRef(); auto featureId = feature->GetFID(); if (qid.transform) { if (geo->transform(qid.transform) != OGRERR_NONE) { continue; } } if (geo->getGeometryType() == wkbMultiPolygon) { auto mp = (OGRMultiPolygon*)geo; const int numPolys = mp->getNumGeometries(); for (int p = 0; p < numPolys; p++) { auto poly = new Polygon((OGRPolygon*)mp->getGeometryRef(p), featureId); qid.waterPolyQuadtree.Insert(poly); qid.waterPolygons.push_back(poly); } } else if (geo->getGeometryType() == wkbPolygon) { auto poly = new Polygon((OGRPolygon*)geo, featureId); qid.waterPolyQuadtree.Insert(poly); qid.waterPolygons.push_back(poly); } OGRFeature::DestroyFeature(feature); } return true; }
CPLErr GNMGenericNetwork::DisconnectAll() { if(!m_bIsGraphLoaded && LoadGraph() != CE_None) { return CE_Failure; } // delete everything from m_pGraphLayer OGRFeature *poFeature; m_poGraphLayer->ResetReading(); while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL) { CPL_IGNORE_RET_VAL(m_poGraphLayer->DeleteFeature(poFeature->GetFID())); OGRFeature::DestroyFeature( poFeature ); } m_oGraph.Clear(); return CE_None; }
CPLErr GNMGenericNetwork::DeleteAllRules() { CPLString soFilter; soFilter.Printf("%s LIKE '%s%%'", GNM_SYSFIELD_PARAMNAME, GNM_MD_RULE); m_poMetadataLayer->SetAttributeFilter(soFilter); m_poMetadataLayer->ResetReading(); OGRFeature *poFeature; std::vector<GIntBig> aFIDs; while((poFeature = m_poMetadataLayer->GetNextFeature()) != NULL) { aFIDs.push_back(poFeature->GetFID()); OGRFeature::DestroyFeature(poFeature); } m_poMetadataLayer->SetAttributeFilter(NULL); for(size_t i = 0; i < aFIDs.size(); ++i) { CPL_IGNORE_RET_VAL(m_poMetadataLayer->DeleteFeature(aFIDs[i])); } return CE_None; }
CPLErr GNMGenericNetwork::DisconnectFeaturesWithId(GNMGFID nFID) { if(!m_bIsGraphLoaded && LoadGraph() != CE_None) { return CE_Failure; } CPLString soFilter; soFilter.Printf("%s = " GNMGFIDFormat " or %s = " GNMGFIDFormat " or %s = " GNMGFIDFormat, GNM_SYSFIELD_SOURCE, nFID, GNM_SYSFIELD_TARGET, nFID, GNM_SYSFIELD_CONNECTOR, nFID); CPLDebug("GNM", "Set attribute filter: %s", soFilter.c_str()); m_poGraphLayer->SetAttributeFilter(soFilter); m_poGraphLayer->ResetReading(); OGRFeature* poFeature; while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL) { if(m_poGraphLayer->DeleteFeature(poFeature->GetFID()) != CE_None) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Failed to remove feature connection." ); return CE_Failure; } OGRFeature::DestroyFeature( poFeature ); } m_poGraphLayer->SetAttributeFilter(NULL); m_oGraph.DeleteEdge(nFID); m_oGraph.DeleteVertex(nFID); return CE_None; }
OGRFeature *OGRGeoconceptLayer::GetNextFeature() { OGRFeature* poFeature = NULL; for( ;; ) { if( !(poFeature= (OGRFeature*)ReadNextFeature_GCIO(_gcFeature)) ) { /* * As several features are embed in the Geoconcept file, * when reaching the end of the feature type, resetting * the reader would allow reading other features : * ogrinfo -ro export.gxt FT1 FT2 ... * will be all features for all features types ! */ Rewind_GCIO(GetSubTypeGCHandle_GCIO(_gcFeature),NULL); break; } if( (m_poFilterGeom == NULL || FilterGeometry( poFeature->GetGeometryRef() ) ) && (m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) ) { break; } delete poFeature; } CPLDebug( "GEOCONCEPT", "FID : %ld\n" "%s : %s", poFeature? poFeature->GetFID():-1L, poFeature && poFeature->GetFieldCount()>0? poFeature->GetFieldDefnRef(0)->GetNameRef():"-", poFeature && poFeature->GetFieldCount()>0? poFeature->GetFieldAsString(0):""); return poFeature; }
OGRFeature *OGRFMELayerCached::GetNextFeature() { OGRFeature *poFeature; while( TRUE ) { poFeature = ReadNextIndexFeature(); if( poFeature != NULL ) nPreviousFeature = poFeature->GetFID(); else break; if( m_poAttrQuery == NULL || poIndex == NULL || m_poAttrQuery->Evaluate( poFeature ) ) break; delete poFeature; } return poFeature; }
OGRFeature *OGRMDBLayer::GetNextRawFeature() { OGRErr err = OGRERR_NONE; if( !poMDBTable->GetNextRow() ) return NULL; /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ int iField; OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); if( pszFIDColumn != NULL && poMDBTable->GetColumnIndex(pszFIDColumn) > -1 ) poFeature->SetFID( poMDBTable->GetColumnAsInt(poMDBTable->GetColumnIndex(pszFIDColumn)) ); else poFeature->SetFID( iNextShapeId ); iNextShapeId++; m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Set the fields. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { int iSrcField = panFieldOrdinals[iField]-1; char *pszValue = poMDBTable->GetColumnAsString( iSrcField ); OGRFieldType eType = poFeature->GetFieldDefnRef(iField)->GetType(); if( pszValue == NULL ) /* no value */; else if( eType == OFTBinary ) { int nBytes = 0; GByte* pData = poMDBTable->GetColumnAsBinary( iSrcField, &nBytes); poFeature->SetField( iField, nBytes, pData ); CPLFree(pData); } else if ( eType == OFTInteger && EQUAL(pszValue, "true")) { poFeature->SetField( iField, 1 ); } else { poFeature->SetField( iField, pszValue ); } CPLFree(pszValue); } if( !(m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) ) return poFeature; /* -------------------------------------------------------------------- */ /* Try to extract a geometry. */ /* -------------------------------------------------------------------- */ if( eGeometryType == MDB_GEOM_PGEO && iGeomColumn >= 0) { int nBytes = 0; GByte* pData = poMDBTable->GetColumnAsBinary( iGeomColumn, &nBytes); OGRGeometry *poGeom = NULL; if( pData != NULL ) { err = OGRCreateFromShapeBin( pData, &poGeom, nBytes ); if( OGRERR_NONE != err ) { CPLDebug( "MDB", "Translation shape binary to OGR geometry failed (FID=%ld)", (long)poFeature->GetFID() ); } } CPLFree(pData); if( poGeom != NULL && OGRERR_NONE == err ) { poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } else if( eGeometryType == MDB_GEOM_GEOMEDIA && iGeomColumn >= 0) { int nBytes = 0; GByte* pData = poMDBTable->GetColumnAsBinary( iGeomColumn, &nBytes); OGRGeometry *poGeom = NULL; if( pData != NULL ) { err = OGRCreateFromGeomedia( pData, &poGeom, nBytes ); if( OGRERR_NONE != err ) { CPLDebug( "MDB", "Translation geomedia binary to OGR geometry failed (FID=%ld)", (long)poFeature->GetFID() ); } } CPLFree(pData); if( poGeom != NULL && OGRERR_NONE == err ) { poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } return poFeature; }
OGRFeature *OGRPGeoLayer::GetNextRawFeature() { OGRErr err = OGRERR_NONE; if( GetStatement() == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* If we are marked to restart then do so, and fetch a record. */ /* -------------------------------------------------------------------- */ if( !poStmt->Fetch() ) { delete poStmt; poStmt = NULL; return NULL; } /* -------------------------------------------------------------------- */ /* Create a feature from the current result. */ /* -------------------------------------------------------------------- */ int iField; OGRFeature *poFeature = new OGRFeature( poFeatureDefn ); if( pszFIDColumn != NULL && poStmt->GetColId(pszFIDColumn) > -1 ) poFeature->SetFID( atoi(poStmt->GetColData(poStmt->GetColId(pszFIDColumn))) ); else poFeature->SetFID( iNextShapeId ); iNextShapeId++; m_nFeaturesRead++; /* -------------------------------------------------------------------- */ /* Set the fields. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < poFeatureDefn->GetFieldCount(); iField++ ) { int iSrcField = panFieldOrdinals[iField]-1; const char *pszValue = poStmt->GetColData( iSrcField ); if( pszValue == NULL ) /* no value */; else if( poFeature->GetFieldDefnRef(iField)->GetType() == OFTBinary ) poFeature->SetField( iField, poStmt->GetColDataLength(iSrcField), (GByte *) pszValue ); else poFeature->SetField( iField, pszValue ); } /* -------------------------------------------------------------------- */ /* Try to extract a geometry. */ /* -------------------------------------------------------------------- */ if( pszGeomColumn != NULL ) { int iField = poStmt->GetColId( pszGeomColumn ); GByte *pabyShape = (GByte *) poStmt->GetColData( iField ); int nBytes = poStmt->GetColDataLength(iField); OGRGeometry *poGeom = NULL; if( pabyShape != NULL ) { err = OGRCreateFromShapeBin( pabyShape, &poGeom, nBytes ); if( OGRERR_NONE != err ) { CPLDebug( "PGeo", "Translation shape binary to OGR geometry failed (FID=%ld)", (long)poFeature->GetFID() ); } } if( poGeom != NULL && OGRERR_NONE == err ) { poGeom->assignSpatialReference( poSRS ); poFeature->SetGeometryDirectly( poGeom ); } } return poFeature; }
feature_ptr ogr_featureset::next() { if (count_ == 0) { // Reset the layer reading on the first feature read // this is a hack, but needed due to https://github.com/mapnik/mapnik/issues/2048 // Proper solution is to avoid storing layer state in featureset layer_.ResetReading(); } OGRFeature *poFeature; while ((poFeature = layer_.GetNextFeature()) != nullptr) { // ogr feature ids start at 0, so add one to stay // consistent with other mapnik datasources that start at 1 mapnik::value_integer feature_id = (poFeature->GetFID() + 1); feature_ptr feature(feature_factory::create(ctx_,feature_id)); OGRGeometry* geom = poFeature->GetGeometryRef(); if (geom && ! geom->IsEmpty()) { auto geom_corrected = ogr_converter::convert_geometry(geom); mapnik::geometry::correct(geom_corrected); feature->set_geometry(std::move(geom_corrected)); } else { MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: Feature with null geometry=" << poFeature->GetFID(); OGRFeature::DestroyFeature( poFeature ); continue; } ++count_; int fld_count = layerdef_->GetFieldCount(); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = layerdef_->GetFieldDefn(i); const OGRFieldType type_oid = fld->GetType(); const std::string fld_name = fld->GetNameRef(); switch (type_oid) { case OFTInteger: { feature->put<mapnik::value_integer>( fld_name, poFeature->GetFieldAsInteger(i)); break; } #if GDAL_VERSION_MAJOR >= 2 case OFTInteger64: { feature->put<mapnik::value_integer>( fld_name, poFeature->GetFieldAsInteger64(i)); break; } #endif case OFTReal: { feature->put( fld_name, poFeature->GetFieldAsDouble(i)); break; } case OFTString: case OFTWideString: // deprecated ! { feature->put( fld_name, tr_->transcode(poFeature->GetFieldAsString(i))); break; } case OFTIntegerList: #if GDAL_VERSION_MAJOR >= 2 case OFTInteger64List: #endif case OFTRealList: case OFTStringList: case OFTWideStringList: // deprecated ! { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; break; } case OFTBinary: { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; //feature->put(name,feat->GetFieldAsBinary (i, size)); break; } case OFTDate: case OFTTime: case OFTDateTime: // unhandled ! { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; break; } default: // unknown { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unknown type_oid=" << type_oid; break; } } } OGRFeature::DestroyFeature( poFeature ); return feature; } MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: " << count_ << " features"; return feature_ptr(); }
feature_ptr ogr_featureset::next() { OGRFeature *poFeature; while ((poFeature = layer_.GetNextFeature()) != NULL) { // ogr feature ids start at 0, so add one to stay // consistent with other mapnik datasources that start at 1 const int feature_id = (poFeature->GetFID() + 1); feature_ptr feature(feature_factory::create(ctx_,feature_id)); OGRGeometry* geom = poFeature->GetGeometryRef(); if (geom && ! geom->IsEmpty()) { ogr_converter::convert_geometry(geom, feature); } else { MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: Feature with null geometry=" << poFeature->GetFID(); OGRFeature::DestroyFeature( poFeature ); continue; } ++count_; int fld_count = layerdef_->GetFieldCount(); for (int i = 0; i < fld_count; i++) { OGRFieldDefn* fld = layerdef_->GetFieldDefn(i); const OGRFieldType type_oid = fld->GetType(); const std::string fld_name = fld->GetNameRef(); switch (type_oid) { case OFTInteger: { feature->put( fld_name, poFeature->GetFieldAsInteger(i)); break; } case OFTReal: { feature->put( fld_name, poFeature->GetFieldAsDouble(i)); break; } case OFTString: case OFTWideString: // deprecated ! { UnicodeString ustr = tr_->transcode(poFeature->GetFieldAsString(i)); feature->put( fld_name, ustr); break; } case OFTIntegerList: case OFTRealList: case OFTStringList: case OFTWideStringList: // deprecated ! { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; break; } case OFTBinary: { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; //feature->put(name,feat->GetFieldAsBinary (i, size)); break; } case OFTDate: case OFTTime: case OFTDateTime: // unhandled ! { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unhandled type_oid=" << type_oid; break; } default: // unknown { MAPNIK_LOG_WARN(ogr) << "ogr_featureset: Unknown type_oid=" << type_oid; break; } } } OGRFeature::DestroyFeature( poFeature ); return feature; } MAPNIK_LOG_DEBUG(ogr) << "ogr_featureset: " << count_ << " features"; return feature_ptr(); }
/* 1 3 0 2 */ void CShapefileLayer::DrawPointLayer() { m_pLayer_->ResetReading(); if (m_PointStore_.m_PointRecorderVector_.empty()) { //第一次读取 PointInfoStore::PointRecorder_ theRecorder; theRecorder.bAdd_ = false; //新增加 theRecorder.bChanged_ = false; //坐标位置改变 theRecorder.bDelete_ = false; //删除 theRecorder.bEdit_ = false; //编辑过的 OGRFeature* pFeature = m_pLayer_->GetNextFeature(); while (pFeature) { OGRGeometry* theGeometry = pFeature->GetGeometryRef(); OGRPoint* thePoint = (OGRPoint*)theGeometry; theRecorder.iFid_ = pFeature->GetFID(); theRecorder.pointx_ = thePoint->getX(); theRecorder.pointy_ = thePoint->getY(); m_PointStore_.m_PointRecorderVector_.push_back(theRecorder); OGRFeature::DestroyFeature(pFeature); pFeature = m_pLayer_->GetNextFeature(); } } int PointNumber = m_PointStore_.m_PointRecorderVector_.size(); PointInfoStore::PointRecorder_ theCurrentPoint; std::vector<Vertex> theVertexVector; Vertex verts[6]; int showWidth = m_Style->m_ImageWidth_; int showHeight = m_Style->m_ImageHeight_; if(m_Height > 0 && m_Width > 0) { showWidth = m_Width; showHeight = m_Height; } //组装数据 for (int i = 0; i < PointNumber; i++) //遍历 { int pix = 0; int piy = 0; theCurrentPoint = m_PointStore_.m_PointRecorderVector_[i]; ProjectionToPix(theCurrentPoint.pointx_, theCurrentPoint.pointy_, pix, piy); if(pix > 0 && pix < m_CtrlWidth && piy < m_CtrlHeight && piy > 0) { //0 verts[0].tu = 0; verts[0].tv = 0; verts[0].loc[0] = pix - showWidth / 2; verts[0].loc[1] = piy - showHeight / 2; verts[0].loc[2] = g_Zlocation; theVertexVector.push_back(verts[0]); //1 verts[1].tu = 0; verts[1].tv = 1; verts[1].loc[0] = pix - showWidth / 2; verts[1].loc[1] = piy + showHeight / 2; verts[1].loc[2] = g_Zlocation; theVertexVector.push_back(verts[1]); //2 verts[2].tu = 1; verts[2].tv = 0; verts[2].loc[0] = pix + showWidth / 2; verts[2].loc[1] = piy - showHeight / 2; verts[2].loc[2] = g_Zlocation; theVertexVector.push_back(verts[2]); //2 verts[3].tu = 1; verts[3].tv = 0; verts[3].loc[0] = pix + showWidth / 2; verts[3].loc[1] = piy - showHeight / 2; verts[3].loc[2] = g_Zlocation; theVertexVector.push_back(verts[3]); //1 verts[4].tu = 0; verts[4].tv = 1; verts[4].loc[0] = pix - showWidth / 2; verts[4].loc[1] = piy + showHeight / 2; verts[4].loc[2] = g_Zlocation; theVertexVector.push_back(verts[4]); //3 verts[5].tu = 1; verts[5].tv = 1; verts[5].loc[0] = pix + showWidth / 2; verts[5].loc[1] = piy + showHeight / 2; verts[5].loc[2] = g_Zlocation; theVertexVector.push_back(verts[5]); } } //绘制 CMarkerElement theElement; theElement.m_Style = m_Style; theElement.RenderManyUseOgles(theVertexVector); }
OGRErr GNMGenericNetwork::DeleteLayer(int nIndex) { if(nIndex < 0 || nIndex >= (int)m_apoLayers.size()) return OGRERR_FAILURE; const char* pszLayerName = m_apoLayers[nIndex]->GetName(); OGRFeature *poFeature; std::set<GNMGFID> anGFIDs; std::set<GNMGFID>::iterator it; // remove layer GFID's from Features layer m_poFeaturesLayer->ResetReading(); while ((poFeature = m_poFeaturesLayer->GetNextFeature()) != NULL) { const char *pFeatureClass = poFeature->GetFieldAsString( GNM_SYSFIELD_LAYERNAME); if(EQUAL(pFeatureClass, pszLayerName)) { anGFIDs.insert(poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_GFID)); CPL_IGNORE_RET_VAL(m_poFeaturesLayer->DeleteFeature(poFeature->GetFID())); } OGRFeature::DestroyFeature(poFeature); } // remove GFID's from graph layer m_poGraphLayer->ResetReading(); while ((poFeature = m_poGraphLayer->GetNextFeature()) != NULL) { GNMGFID nGFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_SOURCE); it = anGFIDs.find(nGFID); if( it != anGFIDs.end()) { CPL_IGNORE_RET_VAL(m_poGraphLayer->DeleteFeature(poFeature->GetFID())); OGRFeature::DestroyFeature(poFeature); continue; } nGFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_TARGET); it = anGFIDs.find(nGFID); if( it != anGFIDs.end()) { CPL_IGNORE_RET_VAL(m_poGraphLayer->DeleteFeature(poFeature->GetFID())); OGRFeature::DestroyFeature(poFeature); continue; } nGFID = poFeature->GetFieldAsGNMGFID(GNM_SYSFIELD_CONNECTOR); it = anGFIDs.find(nGFID); if( it != anGFIDs.end()) { CPL_IGNORE_RET_VAL(m_poGraphLayer->DeleteFeature(poFeature->GetFID())); OGRFeature::DestroyFeature(poFeature); continue; } OGRFeature::DestroyFeature(poFeature); } // remove connected rules for(size_t i = m_asRules.size(); i > 0; --i) { if(EQUAL(m_asRules[i - 1].GetSourceLayerName(), pszLayerName)) { m_asRules.erase(m_asRules.begin() + i - 1); m_bIsRulesChanged = true; } else if(EQUAL(m_asRules[i - 1].GetTargetLayerName(), pszLayerName)) { m_asRules.erase(m_asRules.begin() + i - 1); m_bIsRulesChanged = true; } else if(EQUAL(m_asRules[i - 1].GetConnectorLayerName(), pszLayerName)) { m_asRules.erase(m_asRules.begin() + i - 1); m_bIsRulesChanged = true; } } delete m_apoLayers[nIndex]; // remove from array m_apoLayers.erase (m_apoLayers.begin() + nIndex); return OGRERR_NONE; }