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