OGRFeature* OGRUnionLayer::TranslateFromSrcLayer(OGRFeature* poSrcFeature) { CPLAssert(panMap != NULL); CPLAssert(iCurLayer >= 0 && iCurLayer < nSrcLayers); OGRFeature* poFeature = new OGRFeature(poFeatureDefn); poFeature->SetFrom(poSrcFeature, panMap, TRUE); if( osSourceLayerFieldName.size() && !poFeatureDefn->GetFieldDefn(0)->IsIgnored() ) { poFeature->SetField(0, papoSrcLayers[iCurLayer]->GetName()); } for(int i=0;i<poFeatureDefn->GetGeomFieldCount();i++) { if( poFeatureDefn->GetGeomFieldDefn(i)->IsIgnored() ) poFeature->SetGeomFieldDirectly(i, NULL); else { OGRGeometry* poGeom = poFeature->GetGeomFieldRef(i); if( poGeom != NULL ) { poGeom->assignSpatialReference( poFeatureDefn->GetGeomFieldDefn(i)->GetSpatialRef()); } } } if( bPreserveSrcFID ) poFeature->SetFID(poSrcFeature->GetFID()); else poFeature->SetFID(nNextFID ++); return poFeature; }
bool V2vProj::Compute(const data::VectorBarral * barrel) { OGRDataSource * poSourceDs = VectorOpen(barrel->GetSrcDataSource().c_str(), GA_ReadOnly); ON_SCOPE_EXIT([&]() {OGRDataSource::DestroyDataSource(poSourceDs); }); OGRDataSource * poOutputDs = VectorOpen(barrel->GetDstDataSource().c_str(), GA_Update); ON_SCOPE_EXIT([&]() {OGRDataSource::DestroyDataSource(poOutputDs); }); OGRLayer * poSrcLayer = poSourceDs->GetLayerByName( barrel->GetSrcLayer().c_str()); OGRLayer * poDstLayer = poOutputDs->GetLayerByName( barrel->GetDstLayer().c_str()); OGRSpatialReference * poSourceSRS = poSrcLayer->GetSpatialRef(); OGRCoordinateTransformation * poCT = poCT = OGRCreateCoordinateTransformation( poSourceSRS, m_ogrSr); OGRFeatureDefn * poDstFeatureDefn = poDstLayer->GetLayerDefn(); auto features = barrel->GetFeatures(); std::for_each(begin(features), end(features) , [&](int fid) { poSrcLayer->GetFeature(fid); OGRFeature * poDstFeature = OGRFeature::CreateFeature(poDstFeatureDefn); ON_SCOPE_EXIT([&]() {OGRFeature::DestroyFeature(poDstFeature); }); poDstFeature->SetFrom(poSrcLayer->GetFeature(fid)); OGRGeometry * poDstGeometry = poDstFeature->GetGeometryRef(); OGRGeometry * poReprojectedGeom = OGRGeometryFactory::transformWithOptions( poDstGeometry, poCT, NULL); poDstFeature->SetGeometryDirectly(poReprojectedGeom); poDstLayer->CreateFeature(poDstFeature); }); return true; }
OGRErr OGRLayerWithTransaction::ISetFeature( 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->SetFeature(poSrcFeature); delete poSrcFeature; return eErr; }
OGRErr OGRUnionLayer::ISetFeature( OGRFeature* poFeature ) { if( !bPreserveSrcFID ) { CPLError(CE_Failure, CPLE_NotSupported, "SetFeature() not supported when PreserveSrcFID is OFF"); return OGRERR_FAILURE; } if( osSourceLayerFieldName.size() == 0 ) { CPLError(CE_Failure, CPLE_NotSupported, "SetFeature() not supported when SourceLayerFieldName is not set"); return OGRERR_FAILURE; } if( poFeature->GetFID() == OGRNullFID ) { CPLError(CE_Failure, CPLE_NotSupported, "SetFeature() not supported when FID is not set"); return OGRERR_FAILURE; } if( !poFeature->IsFieldSet(0) ) { CPLError(CE_Failure, CPLE_NotSupported, "SetFeature() 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); poSrcFeature->SetFID(poFeature->GetFID()); OGRErr eErr = papoSrcLayers[i]->SetFeature(poSrcFeature); delete poSrcFeature; return eErr; } } CPLError(CE_Failure, CPLE_NotSupported, "SetFeature() not supported : '%s' source layer does not exist", pszSrcLayerName); return OGRERR_FAILURE; }
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* 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; } }
OGRFeature *OGRWarpedLayer::SrcFeatureToWarpedFeature(OGRFeature* poSrcFeature) { OGRFeature* poFeature = new OGRFeature(GetLayerDefn()); poFeature->SetFrom(poSrcFeature); poFeature->SetFID(poSrcFeature->GetFID()); OGRGeometry* poGeom = poFeature->GetGeomFieldRef(m_iGeomField); if( poGeom == NULL ) return poFeature; if( poGeom->transform(m_poCT) != OGRERR_NONE ) { delete poFeature->StealGeometry(m_iGeomField); } return poFeature; }
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 *OGRWarpedLayer::WarpedFeatureToSrcFeature(OGRFeature* poFeature) { OGRFeature* poSrcFeature = new OGRFeature(m_poDecoratedLayer->GetLayerDefn()); poSrcFeature->SetFrom(poFeature); poSrcFeature->SetFID(poFeature->GetFID()); OGRGeometry* poGeom = poSrcFeature->GetGeomFieldRef(m_iGeomField); if( poGeom != NULL ) { if( m_poReversedCT == NULL ) { delete poSrcFeature; return NULL; } if( poGeom->transform(m_poReversedCT) != OGRERR_NONE ) { delete poSrcFeature; return NULL; } } return poSrcFeature; }
OGRFeature *OGRDWGBlocksLayer::GetNextUnfilteredFeature() { OGRFeature *poFeature = NULL; /* -------------------------------------------------------------------- */ /* Are we out of features? */ /* -------------------------------------------------------------------- */ if( oIt == poDS->GetBlockMap().end() ) return NULL; /* -------------------------------------------------------------------- */ /* Are we done reading the current blocks features? */ /* -------------------------------------------------------------------- */ DWGBlockDefinition *psBlock = &(oIt->second); unsigned int nSubFeatureCount = psBlock->apoFeatures.size(); if( psBlock->poGeometry != NULL ) nSubFeatureCount++; if( iNextSubFeature >= nSubFeatureCount ) { oIt++; iNextSubFeature = 0; if( oIt == poDS->GetBlockMap().end() ) return NULL; psBlock = &(oIt->second); } /* -------------------------------------------------------------------- */ /* Is this a geometry based block? */ /* -------------------------------------------------------------------- */ if( psBlock->poGeometry != NULL && iNextSubFeature == psBlock->apoFeatures.size() ) { poFeature = new OGRFeature( poFeatureDefn ); poFeature->SetGeometry( psBlock->poGeometry ); iNextSubFeature++; } /* -------------------------------------------------------------------- */ /* Otherwise duplicate the next sub-feature. */ /* -------------------------------------------------------------------- */ else { poFeature = new OGRFeature( poFeatureDefn ); poFeature->SetFrom( psBlock->apoFeatures[iNextSubFeature] ); iNextSubFeature++; } /* -------------------------------------------------------------------- */ /* Set FID and block name. */ /* -------------------------------------------------------------------- */ poFeature->SetFID( iNextFID++ ); poFeature->SetField( "BlockName", oIt->first.c_str() ); m_nFeaturesRead++; return poFeature; }
OGRErr OGRCSVEditableLayerSynchronizer::EditableSyncToDisk(OGRLayer* poEditableLayer, OGRLayer** ppoDecoratedLayer) { CPLAssert( m_poCSVLayer == *ppoDecoratedLayer ); CPLString osLayerName(m_poCSVLayer->GetName()); CPLString osFilename(m_poCSVLayer->GetFilename()); const bool bCreateCSVT = m_poCSVLayer->GetCreateCSVT(); CPLString osCSVTFilename(CPLResetExtension(osFilename, "csvt")); VSIStatBufL sStatBuf; const bool bHasCSVT = VSIStatL(osCSVTFilename, &sStatBuf) == 0; CPLString osTmpFilename(osFilename); CPLString osTmpCSVTFilename(osFilename); if( VSIStatL(osFilename, &sStatBuf) == 0 ) { osTmpFilename += "_ogr_tmp.csv"; osTmpCSVTFilename += "_ogr_tmp.csvt"; } const char chDelimiter = m_poCSVLayer->GetDelimiter(); OGRCSVLayer* poCSVTmpLayer = new OGRCSVLayer( osLayerName, NULL, osTmpFilename, true, true, chDelimiter ); poCSVTmpLayer->BuildFeatureDefn(NULL, NULL, m_papszOpenOptions); poCSVTmpLayer->SetCRLF( m_poCSVLayer->GetCRLF() ); poCSVTmpLayer->SetCreateCSVT( bCreateCSVT || bHasCSVT ); poCSVTmpLayer->SetWriteBOM( m_poCSVLayer->GetWriteBOM() ); if( m_poCSVLayer->GetGeometryFormat() == OGR_CSV_GEOM_AS_WKT ) poCSVTmpLayer->SetWriteGeometry( wkbNone, OGR_CSV_GEOM_AS_WKT, NULL ); OGRErr eErr = OGRERR_NONE; OGRFeatureDefn* poEditableFDefn = poEditableLayer->GetLayerDefn(); for( int i=0; eErr == OGRERR_NONE && i < poEditableFDefn->GetFieldCount(); i++ ) { OGRFieldDefn oFieldDefn(poEditableFDefn->GetFieldDefn(i)); int iGeomFieldIdx = 0; if( (EQUAL(oFieldDefn.GetNameRef(), "WKT") && (iGeomFieldIdx = poEditableFDefn->GetGeomFieldIndex("")) >= 0) || (iGeomFieldIdx = poEditableFDefn->GetGeomFieldIndex(oFieldDefn.GetNameRef())) >= 0 ) { OGRGeomFieldDefn oGeomFieldDefn( poEditableFDefn->GetGeomFieldDefn(iGeomFieldIdx) ); eErr = poCSVTmpLayer->CreateGeomField( &oGeomFieldDefn ); } else { eErr = poCSVTmpLayer->CreateField( &oFieldDefn ); } } const bool bHasXY = ( !m_poCSVLayer->GetXField().empty() && !m_poCSVLayer->GetYField().empty() ); const bool bHasZ = ( !m_poCSVLayer->GetZField().empty() ); if( bHasXY && !CPLFetchBool(m_papszOpenOptions, "KEEP_GEOM_COLUMNS", true) ) { if( poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetXField()) < 0 ) { OGRFieldDefn oFieldDefn(m_poCSVLayer->GetXField(), OFTReal); if( eErr == OGRERR_NONE ) eErr = poCSVTmpLayer->CreateField( &oFieldDefn ); } if( poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetYField()) < 0 ) { OGRFieldDefn oFieldDefn(m_poCSVLayer->GetYField(), OFTReal); if( eErr == OGRERR_NONE ) eErr = poCSVTmpLayer->CreateField( &oFieldDefn ); } if( bHasZ && poCSVTmpLayer->GetLayerDefn()->GetFieldIndex(m_poCSVLayer->GetZField()) < 0 ) { OGRFieldDefn oFieldDefn(m_poCSVLayer->GetZField(), OFTReal); if( eErr == OGRERR_NONE ) eErr = poCSVTmpLayer->CreateField( &oFieldDefn ); } } int nFirstGeomColIdx = 0; if( m_poCSVLayer->HasHiddenWKTColumn() ) { poCSVTmpLayer->SetWriteGeometry( poEditableFDefn->GetGeomFieldDefn(0)->GetType(), OGR_CSV_GEOM_AS_WKT, poEditableFDefn->GetGeomFieldDefn(0)->GetNameRef()); nFirstGeomColIdx = 1; } if( !(poEditableFDefn->GetGeomFieldCount() == 1 && bHasXY) ) { for( int i=nFirstGeomColIdx; eErr == OGRERR_NONE && i < poEditableFDefn->GetGeomFieldCount(); i++ ) { OGRGeomFieldDefn oGeomFieldDefn( poEditableFDefn->GetGeomFieldDefn(i) ); if( poCSVTmpLayer->GetLayerDefn()->GetGeomFieldIndex(oGeomFieldDefn.GetNameRef()) >= 0 ) continue; eErr = poCSVTmpLayer->CreateGeomField( &oGeomFieldDefn ); } } OGRFeature* poFeature = NULL; poEditableLayer->ResetReading(); while( eErr == OGRERR_NONE && (poFeature = poEditableLayer->GetNextFeature()) != NULL ) { OGRFeature* poNewFeature = new OGRFeature( poCSVTmpLayer->GetLayerDefn() ); poNewFeature->SetFrom(poFeature); if( bHasXY ) { OGRGeometry* poGeom = poFeature->GetGeometryRef(); if( poGeom != NULL && wkbFlatten(poGeom->getGeometryType()) == wkbPoint ) { poNewFeature->SetField( m_poCSVLayer->GetXField(), static_cast<OGRPoint*>(poGeom)->getX()); poNewFeature->SetField( m_poCSVLayer->GetYField(), static_cast<OGRPoint*>(poGeom)->getY()); if( bHasZ ) { poNewFeature->SetField( m_poCSVLayer->GetZField(), static_cast<OGRPoint*>(poGeom)->getZ()); } } } eErr = poCSVTmpLayer->CreateFeature(poNewFeature); delete poFeature; delete poNewFeature; } delete poCSVTmpLayer; if( eErr != OGRERR_NONE ) { CPLError(CE_Failure, CPLE_AppDefined, "Error while creating %s", osTmpFilename.c_str()); VSIUnlink( osTmpFilename ); VSIUnlink( CPLResetExtension(osTmpFilename, "csvt") ); return eErr; } delete m_poCSVLayer; if( osFilename != osTmpFilename ) { CPLString osTmpOriFilename(osFilename + ".ogr_bak"); CPLString osTmpOriCSVTFilename(osCSVTFilename + ".ogr_bak"); if( VSIRename( osFilename, osTmpOriFilename ) != 0 || (bHasCSVT && VSIRename( osCSVTFilename, osTmpOriCSVTFilename ) != 0 ) || VSIRename( osTmpFilename, osFilename) != 0 || (bHasCSVT && VSIRename( osTmpCSVTFilename, osCSVTFilename ) != 0) ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot rename files"); *ppoDecoratedLayer = NULL; m_poCSVLayer = NULL; return OGRERR_FAILURE; } VSIUnlink( osTmpOriFilename ); if( bHasCSVT ) VSIUnlink( osTmpOriCSVTFilename ); } VSILFILE* fp = VSIFOpenL( osFilename, "rb+" ); if( fp == NULL ) { CPLError(CE_Failure, CPLE_AppDefined, "Cannot reopen updated %s", osFilename.c_str()); *ppoDecoratedLayer = NULL; m_poCSVLayer = NULL; return OGRERR_FAILURE; } m_poCSVLayer = new OGRCSVLayer( osLayerName, fp, osFilename, false, /* new */ true, /* update */ chDelimiter ); m_poCSVLayer->BuildFeatureDefn(NULL, NULL, m_papszOpenOptions); *ppoDecoratedLayer = m_poCSVLayer; return OGRERR_NONE; }
OGRLayer *OGRDataSource::CopyLayer( OGRLayer *poSrcLayer, const char *pszNewName, char **papszOptions ) { OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn(); OGRLayer *poDstLayer = NULL; /* -------------------------------------------------------------------- */ /* Create the layer. */ /* -------------------------------------------------------------------- */ if( !TestCapability( ODsCCreateLayer ) ) { CPLError( CE_Failure, CPLE_NotSupported, "This datasource does not support creation of layers." ); return NULL; } CPLErrorReset(); poDstLayer = CreateLayer( pszNewName, poSrcLayer->GetSpatialRef(), poSrcDefn->GetGeomType(), papszOptions ); if( poDstLayer == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Add fields. Default to copy all field. */ /* If only a subset of all fields requested, then output only */ /* the selected fields, and in the order that they were */ /* selected. */ /* -------------------------------------------------------------------- */ int iField; for( iField = 0; iField < poSrcDefn->GetFieldCount(); iField++ ) poDstLayer->CreateField( poSrcDefn->GetFieldDefn(iField) ); /* -------------------------------------------------------------------- */ /* Transfer features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poSrcLayer->ResetReading(); while( TRUE ) { OGRFeature *poDstFeature = NULL; poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) break; CPLErrorReset(); poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { delete poFeature; CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %d from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); return poDstLayer; } poDstFeature->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); CPLErrorReset(); if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poDstFeature ); return poDstLayer; } OGRFeature::DestroyFeature( poDstFeature ); } return poDstLayer; }
OGRErr OGRGeoJSONWriteLayer::ICreateFeature( OGRFeature* poFeature ) { VSILFILE* fp = poDS_->GetOutputFile(); OGRFeature* poFeatureToWrite; if( poCT_ != nullptr || bRFC7946_ ) { poFeatureToWrite = new OGRFeature(poFeatureDefn_); poFeatureToWrite->SetFrom( poFeature ); poFeatureToWrite->SetFID( poFeature->GetFID() ); OGRGeometry* poGeometry = poFeatureToWrite->GetGeometryRef(); if( poGeometry ) { const char* const apszOptions[] = { "WRAPDATELINE=YES", nullptr }; OGRGeometry* poNewGeom = OGRGeometryFactory::transformWithOptions( poGeometry, poCT_, const_cast<char**>(apszOptions), oTransformCache_); if( poNewGeom == nullptr ) { delete poFeatureToWrite; return OGRERR_FAILURE; } OGREnvelope sEnvelope; poNewGeom->getEnvelope(&sEnvelope); if( sEnvelope.MinX < -180.0 || sEnvelope.MaxX > 180.0 || sEnvelope.MinY < -90.0 || sEnvelope.MaxY > 90.0 ) { CPLError(CE_Failure, CPLE_AppDefined, "Geometry extent outside of [-180.0,180.0]x[-90.0,90.0] bounds"); delete poFeatureToWrite; return OGRERR_FAILURE; } poFeatureToWrite->SetGeometryDirectly( poNewGeom ); } } else { poFeatureToWrite = poFeature; } json_object* poObj = OGRGeoJSONWriteFeature( poFeatureToWrite, oWriteOptions_ ); CPLAssert( nullptr != poObj ); if( nOutCounter_ > 0 ) { /* Separate "Feature" entries in "FeatureCollection" object. */ VSIFPrintfL( fp, ",\n" ); } VSIFPrintfL( fp, "%s", json_object_to_json_string( poObj ) ); json_object_put( poObj ); ++nOutCounter_; OGRGeometry* poGeometry = poFeatureToWrite->GetGeometryRef(); if( bWriteFC_BBOX && poGeometry != nullptr && !poGeometry->IsEmpty() ) { OGREnvelope3D sEnvelope = OGRGeoJSONGetBBox( poGeometry, oWriteOptions_ ); if( poGeometry->getCoordinateDimension() == 3 ) bBBOX3D = true; if( !sEnvelopeLayer.IsInit() ) { sEnvelopeLayer = sEnvelope; } else if( oWriteOptions_.bBBOXRFC7946 ) { const bool bEnvelopeCrossAM = ( sEnvelope.MinX > sEnvelope.MaxX ); const bool bEnvelopeLayerCrossAM = ( sEnvelopeLayer.MinX > sEnvelopeLayer.MaxX ); if( bEnvelopeCrossAM ) { if( bEnvelopeLayerCrossAM ) { sEnvelopeLayer.MinX = std::min(sEnvelopeLayer.MinX, sEnvelope.MinX); sEnvelopeLayer.MaxX = std::max(sEnvelopeLayer.MaxX, sEnvelope.MaxX); } else { if( sEnvelopeLayer.MinX > 0 ) { sEnvelopeLayer.MinX = std::min(sEnvelopeLayer.MinX, sEnvelope.MinX); sEnvelopeLayer.MaxX = sEnvelope.MaxX; } else if( sEnvelopeLayer.MaxX < 0 ) { sEnvelopeLayer.MaxX = std::max(sEnvelopeLayer.MaxX, sEnvelope.MaxX); sEnvelopeLayer.MinX = sEnvelope.MinX; } else { sEnvelopeLayer.MinX = -180.0; sEnvelopeLayer.MaxX = 180.0; } } } else if( bEnvelopeLayerCrossAM ) { if( sEnvelope.MinX > 0 ) { sEnvelopeLayer.MinX = std::min(sEnvelopeLayer.MinX, sEnvelope.MinX); } else if( sEnvelope.MaxX < 0 ) { sEnvelopeLayer.MaxX = std::max(sEnvelopeLayer.MaxX, sEnvelope.MaxX); } else { sEnvelopeLayer.MinX = -180.0; sEnvelopeLayer.MaxX = 180.0; } } else { sEnvelopeLayer.MinX = std::min(sEnvelopeLayer.MinX, sEnvelope.MinX); sEnvelopeLayer.MaxX = std::max(sEnvelopeLayer.MaxX, sEnvelope.MaxX); } sEnvelopeLayer.MinY = std::min(sEnvelopeLayer.MinY, sEnvelope.MinY); sEnvelopeLayer.MaxY = std::max(sEnvelopeLayer.MaxY, sEnvelope.MaxY); } else { sEnvelopeLayer.Merge(sEnvelope); } } if( poFeatureToWrite != poFeature ) delete poFeatureToWrite; return OGRERR_NONE; }
void OGRILI1Layer::PolygonizeAreaLayer() { if (poAreaLineLayer == 0) return; //add all lines from poAreaLineLayer to collection OGRGeometryCollection *gc = new OGRGeometryCollection(); poAreaLineLayer->ResetReading(); while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef()) gc->addGeometry(feature->GetGeometryRef()); //polygonize lines CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries()); poAreaLineLayer = 0; OGRMultiPolygon* polys = Polygonize( gc , false); CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries()); if (polys->getNumGeometries() != poAreaReferenceLayer->GetFeatureCount()) { CPLDebug( "OGR_ILI", "Feature count of layer %s: %d", poAreaReferenceLayer->GetLayerDefn()->GetName(), GetFeatureCount()); CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix"); delete polys; polys = Polygonize( gc, true ); //try again with crossing line fix } delete gc; //associate polygon feature with data row according to centroid #if defined(HAVE_GEOS) int i; OGRPolygon emptyPoly; GEOSGeom *ahInGeoms = NULL; CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName()); ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*),polys->getNumGeometries()); for( i = 0; i < polys->getNumGeometries(); i++ ) { ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS(); if (!GEOSisValid(ahInGeoms[i])) ahInGeoms[i] = NULL; } poAreaReferenceLayer->ResetReading(); while (OGRFeature *feature = poAreaReferenceLayer->GetNextFeatureRef()) { OGRGeometry* geomRef = feature->GetGeometryRef(); if( !geomRef ) { continue; } GEOSGeom point = (GEOSGeom)(geomRef->exportToGEOS()); for (i = 0; i < polys->getNumGeometries(); i++ ) { if (ahInGeoms[i] && GEOSWithin(point, ahInGeoms[i])) { OGRFeature* areaFeature = new OGRFeature(poFeatureDefn); areaFeature->SetFrom(feature); areaFeature->SetGeometry( polys->getGeometryRef(i) ); AddFeature(areaFeature); break; } } if (i == polys->getNumGeometries()) { CPLDebug( "OGR_ILI", "Association between area and point failed."); feature->SetGeometry( &emptyPoly ); } GEOSGeom_destroy( point ); } for( i = 0; i < polys->getNumGeometries(); i++ ) GEOSGeom_destroy( ahInGeoms[i] ); CPLFree( ahInGeoms ); #endif poAreaLineLayer = 0; delete polys; }
OGRLayer *OGRDataSource::CopyLayer( OGRLayer *poSrcLayer, const char *pszNewName, char **papszOptions ) { OGRFeatureDefn *poSrcDefn = poSrcLayer->GetLayerDefn(); OGRLayer *poDstLayer = NULL; /* -------------------------------------------------------------------- */ /* Create the layer. */ /* -------------------------------------------------------------------- */ if( !TestCapability( ODsCCreateLayer ) ) { CPLError( CE_Failure, CPLE_NotSupported, "This datasource does not support creation of layers." ); return NULL; } CPLErrorReset(); poDstLayer = CreateLayer( pszNewName, poSrcLayer->GetSpatialRef(), poSrcDefn->GetGeomType(), papszOptions ); if( poDstLayer == NULL ) return NULL; /* -------------------------------------------------------------------- */ /* Add fields. Default to copy all field. */ /* If only a subset of all fields requested, then output only */ /* the selected fields, and in the order that they were */ /* selected. */ /* -------------------------------------------------------------------- */ int iField; for( iField = 0; iField < poSrcDefn->GetFieldCount(); iField++ ) poDstLayer->CreateField( poSrcDefn->GetFieldDefn(iField) ); /* -------------------------------------------------------------------- */ /* Check if the destination layer supports transactions and set a */ /* default number of features in a single transaction. */ /* -------------------------------------------------------------------- */ int nGroupTransactions = 0; if( poDstLayer->TestCapability( OLCTransactions ) ) nGroupTransactions = 128; /* -------------------------------------------------------------------- */ /* Transfer features. */ /* -------------------------------------------------------------------- */ OGRFeature *poFeature; poSrcLayer->ResetReading(); if( nGroupTransactions <= 0 ) { while( TRUE ) { OGRFeature *poDstFeature = NULL; poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) break; CPLErrorReset(); poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( poDstFeature->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { delete poFeature; CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %ld from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); return poDstLayer; } poDstFeature->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); CPLErrorReset(); if( poDstLayer->CreateFeature( poDstFeature ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poDstFeature ); return poDstLayer; } OGRFeature::DestroyFeature( poDstFeature ); } } else { int i, bStopTransfer = FALSE, bStopTransaction = FALSE; int nFeatCount = 0; // Number of features in the temporary array int nFeaturesToAdd = 0; while( !bStopTransfer ) { OGRFeature **papoDstFeature = (OGRFeature **)CPLCalloc(sizeof(OGRFeature *), nGroupTransactions); /* -------------------------------------------------------------------- */ /* Fill the array with features */ /* -------------------------------------------------------------------- */ for( nFeatCount = 0; nFeatCount < nGroupTransactions; nFeatCount++ ) { poFeature = poSrcLayer->GetNextFeature(); if( poFeature == NULL ) { bStopTransfer = 1; break; } CPLErrorReset(); papoDstFeature[nFeatCount] = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); if( papoDstFeature[nFeatCount]->SetFrom( poFeature, TRUE ) != OGRERR_NONE ) { OGRFeature::DestroyFeature( poFeature ); CPLError( CE_Failure, CPLE_AppDefined, "Unable to translate feature %ld from layer %s.\n", poFeature->GetFID(), poSrcDefn->GetName() ); bStopTransfer = TRUE; break; } papoDstFeature[nFeatCount]->SetFID( poFeature->GetFID() ); OGRFeature::DestroyFeature( poFeature ); } nFeaturesToAdd = nFeatCount; CPLErrorReset(); bStopTransaction = FALSE; while( !bStopTransaction ) { bStopTransaction = TRUE; poDstLayer->StartTransaction(); for( i = 0; i < nFeaturesToAdd; i++ ) { if( poDstLayer->CreateFeature( papoDstFeature[i] ) != OGRERR_NONE ) { nFeaturesToAdd = i; bStopTransfer = TRUE; bStopTransaction = FALSE; } } if( bStopTransaction ) poDstLayer->CommitTransaction(); else poDstLayer->RollbackTransaction(); } for( i = 0; i < nFeatCount; i++ ) OGRFeature::DestroyFeature( papoDstFeature[i] ); } } return poDstLayer; }
bool GdaCache::CacheLayer(std::string ext_ds_name, OGRLayerProxy* ext_layer_proxy) { OGRLayer* poSrcLayer = ext_layer_proxy->layer; // get information from current layer: geomtype, layer_name // (NOTE: we don't consider coodinator system and translation here) OGRFeatureDefn *poSrcFDefn = poSrcLayer->GetLayerDefn(); int eGType = poSrcFDefn->GetGeomType(); const char* pszNewLayerName = poSrcLayer->GetName(); int bForceToPolygon = FALSE; int bForceToMultiPolygon = FALSE; int bForceToMultiLineString = FALSE; if( wkbFlatten(eGType) == wkbPolygon ) bForceToPolygon = TRUE; else if( wkbFlatten(eGType) == wkbMultiPolygon ) bForceToMultiPolygon = TRUE; else if( wkbFlatten(eGType) == wkbMultiLineString ) bForceToMultiLineString = TRUE; //Setup coordinate transformation if we need it. OGRCoordinateTransformation *poCT = NULL; bool bTransform = FALSE; OGRSpatialReference *poSourceSRS = NULL; // todo OGRSpatialReference *poOutputSRS = new OGRSpatialReference("EPSG:4326"); // Cache char *papszLCO[] = {"OVERWRITE=yes","FORMAT=Spatialite"}; std::string cache_layer_name = ext_ds_name + "_"+ext_layer_proxy->name; OGRDataSource *poDstDS = cach_ds_proxy->ds; OGRLayer *poDstLayer = poDstDS->CreateLayer(cache_layer_name.c_str(), poOutputSRS, (OGRwkbGeometryType)eGType, papszLCO); if (poDstLayer == NULL) { // raise create cache failed. return false; } // Process Layer style table poDstLayer->SetStyleTable( poSrcLayer->GetStyleTable () ); // Add fields. here to copy all field. int nSrcFieldCount = poSrcFDefn->GetFieldCount(); int iField; OGRFeatureDefn *poDstFDefn = poDstLayer->GetLayerDefn(); for( iField = 0; iField < nSrcFieldCount; iField++ ) { OGRFieldDefn* poSrcFieldDefn = poSrcFDefn->GetFieldDefn(iField); OGRFieldDefn oFieldDefn( poSrcFieldDefn ); // The field may have been already created at layer creation if (poDstLayer->CreateField( &oFieldDefn ) == OGRERR_NONE) { // now that we've created a field, GetLayerDefn() won't return NULL if (poDstFDefn == NULL) poDstFDefn = poDstLayer->GetLayerDefn(); } } // Transfer feature from Source Layer to Dest Layer OGRFeature *poFeature; GIntBig nFeaturesWritten = 0; poSrcLayer->ResetReading(); while (poFeature = poSrcLayer->GetNextFeature()) { OGRFeature *poDstFeature = OGRFeature::CreateFeature( poDstLayer->GetLayerDefn() ); poDstFeature->SetFrom(poFeature); OGRGeometry *poDstGeometry = poDstFeature->GetGeometryRef(); if (poDstGeometry != NULL) { if( bForceToPolygon ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToPolygon( poDstFeature->StealGeometry())); } else if( bForceToMultiPolygon ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToMultiPolygon( poDstFeature->StealGeometry() ) ); } else if ( bForceToMultiLineString ) { poDstFeature->SetGeometryDirectly( OGRGeometryFactory::forceToMultiLineString( poDstFeature->StealGeometry() ) ); } } if( poDstLayer->CreateFeature( poDstFeature ) == OGRERR_NONE ) { nFeaturesWritten ++; } OGRFeature::DestroyFeature( poDstFeature ); OGRFeature::DestroyFeature( poFeature ); } OGRDataSource::DestroyDataSource(poDstDS); // XXX // delete poDstLayer; return true; }