CPLErr GNMGenericNetwork::ReconnectFeatures(GNMGFID nSrcGFID, GNMGFID nTgtGFID,
GNMGFID nConGFID, double dfCost,
double dfInvCost, GNMDirection eDir)
{
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;
}
poFeature->SetField( GNM_SYSFIELD_COST, dfCost );
poFeature->SetField( GNM_SYSFIELD_INVCOST, dfInvCost );
poFeature->SetField( GNM_SYSFIELD_DIRECTION, eDir );
if( m_poGraphLayer->SetFeature( poFeature ) != OGRERR_NONE )
{
OGRFeature::DestroyFeature( poFeature );
CPLError( CE_Failure, CPLE_AppDefined, "Failed to update feature." );
return CE_Failure;
}
OGRFeature::DestroyFeature( poFeature );
// update graph
m_oGraph.ChangeEdge(nConGFID, dfCost, dfInvCost);
return CE_None;
}
int cvct2gdal::CVCT2GDALWriteFields ( VCTFeature & oVCTFeat, OGRFeature & oOGRFeat )
{
AttrParser attr ( poVCTFile, poVCTDataSource );
char ** papszFields = attr.Parse ( oVCTFeat.fields );
int idx = 0;
for ( auto iter = oVCTFeat.featuredefn->fielddefnlist.begin();
iter != oVCTFeat.featuredefn->fielddefnlist.end();
++iter, ++idx )
{
switch ( CVCT2GDALFieldType ( iter->type ) )
{
case OFTInteger:
oOGRFeat.SetField ( iter->name.c_str(), atoi ( papszFields[idx] ) );
break;
case OFTReal:
oOGRFeat.SetField ( iter->name.c_str(), atof( papszFields[idx] ) );
break;
case OFTString:
oOGRFeat.SetField ( iter->name.c_str(), papszFields[idx] );
break;
default:
oOGRFeat.SetField ( iter->name.c_str(), papszFields[idx] );
break;
}
}
return 0;
}
void GNMGenericNetwork::SaveRules()
{
if(!m_bIsRulesChanged)
return;
if(DeleteAllRules() != CE_None)
return;
OGRFeature *poFeature;
for(int i = 0; i < (int)m_asRules.size(); ++i)
{
poFeature = OGRFeature::CreateFeature(m_poMetadataLayer->GetLayerDefn());
poFeature->SetField(GNM_SYSFIELD_PARAMNAME, CPLSPrintf("%s%d",
GNM_MD_RULE, i + 1));
poFeature->SetField(GNM_SYSFIELD_PARAMVALUE, m_asRules[i]);
if(m_poMetadataLayer->CreateFeature(poFeature) != OGRERR_NONE)
{
CPLError( CE_Failure, CPLE_AppDefined, "Write rule '%s' failed",
m_asRules[i].c_str());
// TODO: do we need interrupt here?
//OGRFeature::DestroyFeature( poFeature );
// return CE_Failure;
}
OGRFeature::DestroyFeature(poFeature);
}
}
void area(const osmium::Area& area) {
const char* building = area.tags()["building"];
if (building) {
try {
std::unique_ptr<OGRMultiPolygon> ogr_polygon = m_factory.create_multipolygon(area);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_polygon->GetLayerDefn());
feature->SetGeometry(ogr_polygon.get());
feature->SetField("id", static_cast<int>(area.id()));
feature->SetField("type", building);
std::string type = "";
if (area.from_way()) {
type += "w";
} else {
type += "r";
}
feature->SetField("type", type.c_str());
if (m_layer_polygon->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
} catch (osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for area " << area.id() << " created from " << (area.from_way() ? "way" : "relation") << " with id=" << area.orig_id() << ".\n";
}
}
}
void node(const osmium::Node& node) {
const char* label = node.tags().get_value_by_key("label");
if (label) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_labels->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
feature->SetField("label", label);
if (m_layer_labels->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
} else {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_nodes->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
if (m_layer_nodes->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
}
}
void node(const shared_ptr<Osmium::OSM::Node const>& node) {
if (!node->tags().empty()) {
std::string tags = Osmium::filter_and_accumulate(node->tags(), m_filter, std::string(), m_tohstore);
if (!tags.empty()) {
try {
Osmium::Geometry::Point point(*node);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_point->GetLayerDefn());
OGRPoint* ogrpoint = Osmium::Geometry::create_ogr_geometry(point);
feature->SetGeometry(ogrpoint);
feature->SetField("id", boost::lexical_cast<std::string>(node->id()).c_str());
feature->SetField("tags", tags.c_str());
if (m_layer_point->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
delete ogrpoint;
} catch (Osmium::Geometry::IllegalGeometry) {
std::cerr << "Ignoring illegal geometry for node " << node->id() << ".\n";
}
}
}
}
OGRFeature* GTMWaypointLayer::GetNextFeature()
{
if( bError )
return nullptr;
while (poDS->hasNextWaypoint())
{
Waypoint* poWaypoint = poDS->fetchNextWaypoint();
if (poWaypoint == nullptr)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Could not read waypoint. File probably corrupted");
bError = true;
return nullptr;
}
OGRFeature* poFeature = new OGRFeature( poFeatureDefn );
double altitude = poWaypoint->getAltitude();
if (altitude == 0.0)
poFeature->SetGeometryDirectly(new OGRPoint
(poWaypoint->getLongitude(),
poWaypoint->getLatitude()));
else
poFeature->SetGeometryDirectly(new OGRPoint
(poWaypoint->getLongitude(),
poWaypoint->getLatitude(),
altitude));
if (poSRS)
poFeature->GetGeometryRef()->assignSpatialReference(poSRS);
poFeature->SetField( NAME, poWaypoint->getName());
poFeature->SetField( COMMENT, poWaypoint->getComment());
poFeature->SetField( ICON, poWaypoint->getIcon());
GIntBig wptdate = poWaypoint->getDate();
if (wptdate != 0)
{
struct tm brokendownTime;
CPLUnixTimeToYMDHMS(wptdate, &brokendownTime);
poFeature->SetField( DATE,
brokendownTime.tm_year + 1900,
brokendownTime.tm_mon + 1,
brokendownTime.tm_mday,
brokendownTime.tm_hour,
brokendownTime.tm_min,
static_cast<float>(brokendownTime.tm_sec));
}
poFeature->SetFID( nNextFID++ );
delete poWaypoint;
if( (m_poFilterGeom == nullptr
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == nullptr
|| m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
return nullptr;
}
OGRFeature *OGROpenAirLabelLayer::GetNextRawFeature()
{
const char* pszLine;
double dfLat = 0, dfLon = 0;
int bHasCoord = FALSE;
while(TRUE)
{
pszLine = CPLReadLine2L(fpOpenAir, 1024, NULL);
if (pszLine == NULL)
return NULL;
if (pszLine[0] == '*' || pszLine[0] == '\0')
continue;
if (EQUALN(pszLine, "AC ", 3))
{
if (osCLASS.size() != 0)
{
osNAME = "";
osCEILING = "";
osFLOOR = "";
}
osCLASS = pszLine + 3;
}
else if (EQUALN(pszLine, "AN ", 3))
osNAME = pszLine + 3;
else if (EQUALN(pszLine, "AH ", 3))
osCEILING = pszLine + 3;
else if (EQUALN(pszLine, "AL ", 3))
osFLOOR = pszLine + 3;
else if (EQUALN(pszLine, "AT ", 3))
{
bHasCoord = OGROpenAirGetLatLon(pszLine + 3, dfLat, dfLon);
break;
}
}
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetField(0, osCLASS.c_str());
poFeature->SetField(1, osNAME.c_str());
poFeature->SetField(2, osFLOOR.c_str());
poFeature->SetField(3, osCEILING.c_str());
CPLString osStyle;
osStyle.Printf("LABEL(t:\"%s\")", osNAME.c_str());
poFeature->SetStyleString(osStyle.c_str());
if (bHasCoord)
{
OGRPoint* poPoint = new OGRPoint(dfLon, dfLat);
poPoint->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly(poPoint);
}
poFeature->SetFID(nNextFID++);
return poFeature;
}
OGRFeature *OGRKMLLayer::GetNextFeature()
{
#ifndef HAVE_EXPAT
return NULL;
#else
/* -------------------------------------------------------------------- */
/* Loop till we find a feature matching our criteria. */
/* -------------------------------------------------------------------- */
KML *poKMLFile = poDS_->GetKMLFile();
if( poKMLFile == NULL )
return NULL;
poKMLFile->selectLayer(nLayerNumber_);
while( true )
{
Feature *poFeatureKML = NULL;
poFeatureKML = poKMLFile->getFeature(iNextKMLId_++, nLastAsked, nLastCount);
if(poFeatureKML == NULL)
return NULL;
CPLAssert( poFeatureKML != NULL );
OGRFeature *poFeature = new OGRFeature( poFeatureDefn_ );
if(poFeatureKML->poGeom)
{
poFeature->SetGeometryDirectly(poFeatureKML->poGeom);
poFeatureKML->poGeom = NULL;
}
// Add fields
poFeature->SetField( poFeatureDefn_->GetFieldIndex("Name"), poFeatureKML->sName.c_str() );
poFeature->SetField( poFeatureDefn_->GetFieldIndex("Description"), poFeatureKML->sDescription.c_str() );
poFeature->SetFID( iNextKMLId_ - 1 );
// Clean up
delete poFeatureKML;
if( poFeature->GetGeometryRef() != NULL && poSRS_ != NULL)
{
poFeature->GetGeometryRef()->assignSpatialReference( poSRS_ );
}
/* Check spatial/attribute filters */
if ((m_poFilterGeom == NULL || FilterGeometry( poFeature->GetGeometryRef() ) ) &&
(m_poAttrQuery == NULL || m_poAttrQuery->Evaluate( poFeature )) )
{
// Return the feature
return poFeature;
}
else
{
delete poFeature;
}
}
#endif /* HAVE_EXPAT */
}
void OgrWriter::_addFeature(OGRLayer* layer, shared_ptr<Feature> f, shared_ptr<Geometry> g)
{
OGRFeature* poFeature = OGRFeature::CreateFeature( layer->GetLayerDefn() );
// set all the column values.
const QVariantMap& vm = f->getValues();
for (QVariantMap::const_iterator it = vm.constBegin(); it != vm.constEnd(); ++it)
{
const QVariant& v = it.value();
QByteArray ba = it.key().toUtf8();
// If the field DOESN'T exist in the output layer, skip it.
if (poFeature->GetFieldIndex(ba.constData()) == -1)
{
continue;
}
switch (v.type())
{
case QVariant::Invalid:
poFeature->UnsetField(poFeature->GetFieldIndex(ba.constData()));
break;
case QVariant::Int:
poFeature->SetField(ba.constData(), v.toInt());
break;
case QVariant::Double:
poFeature->SetField(ba.constData(), v.toDouble());
break;
case QVariant::String:
{
QByteArray vba = v.toString().toUtf8();
poFeature->SetField(ba.constData(), vba.constData());
break;
}
default:
strictError("Can't convert the provided value into an OGR value. (" + v.toString() + ")");
return;
}
}
// convert the geometry.
shared_ptr<GeometryCollection> gc = dynamic_pointer_cast<GeometryCollection>(g);
if (gc.get() != 0)
{
for (size_t i = 0; i < gc->getNumGeometries(); i++)
{
const Geometry* child = gc->getGeometryN(i);
_addFeatureToLayer(layer, f, child, poFeature);
}
}
else
{
_addFeatureToLayer(layer, f, g.get(), poFeature);
}
OGRFeature::DestroyFeature(poFeature);
}
OGRErr OGRGnmLayer::CreateFeature (OGRFeature *poFeature)
{
// Check for obligatory attributes' correct values.
int temp;
temp = poFeature->GetFieldAsInteger("is_blocked");
if (temp != GNM_FEATURE_BLOCKED &&
temp != GNM_FEATURE_UNBLOCKED)
{
// Set initial value if incoming value is incorrect.
poFeature->SetField("is_blocked", GNM_FEATURE_UNBLOCKED);
}
temp = poFeature->GetFieldAsInteger("direction");
if (temp != GNM_FEATURE_STRAIGHT_DIRECTION &&
temp != GNM_FEATURE_REVERSE_DIRECTION &&
temp != GNM_FEATURE_DOUBLE_DIRECTION)
{
// Set initial value if incoming value is incorrect.
poFeature->SetField("direction", GNM_FEATURE_DOUBLE_DIRECTION);
}
/*
// Set feature unique ID.
long id = parentDataSrc->getNextFeatureId();
OGRErr err = poFeature->SetFID(id);
poFeature->SetFID(id);
// Add feature's id and layer name to the id relation table.
OGRLayer *poLr = parentDataSrc->getInnerDataSource()->GetLayerByName("network_ids");
OGRFeature *poFt;
poFt = OGRFeature::CreateFeature(poLr->GetLayerDefn());
const char* layerName = this->GetName();
poFt->SetField("layer_name", layerName);
poFt->SetFID(id);
if(poLr->CreateFeature(poFt) != OGRERR_NONE) return OGRERR_FAILURE;
*/
// Create feature.
OGRErr err = geoLayer->CreateFeature(poFeature);
if (err != OGRERR_NONE)
return OGRERR_FAILURE;
// Add to relation table info about new feature.
const char* lrNm = this->GetName();
long ftGId = parentDataSrc->getNextFeatureId();
long ftLId = poFeature->GetFID();
OGRLayer *poLr = parentDataSrc->getInnerDataSource()->GetLayerByName("network_ids");
OGRFeature *poFt;
poFt = OGRFeature::CreateFeature(poLr->GetLayerDefn());
poFt->SetField("id_global", ftGId);
poFt->SetField("layer_name", lrNm);
poFt->SetField("id_local", ftLId);
if(poLr->CreateFeature(poFt) != OGRERR_NONE)
return OGRERR_FAILURE;
OGRFeature::DestroyFeature(poFt);
return OGRERR_NONE;
}
OGRFeature*
OGRXPlaneAirwaySegmentLayer::AddFeature(const char* pszAirwaySegmentName,
const char* pszFirstPointName,
const char* pszSecondPointName,
double dfLat1,
double dfLon1,
double dfLat2,
double dfLon2,
int bIsHigh,
int nBaseFL,
int nTopFL)
{
int nCount = 0;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
if (fabs(dfLon1 - dfLon2) < 270)
{
OGRLineString* lineString = new OGRLineString();
lineString->addPoint(dfLon1, dfLat1);
lineString->addPoint(dfLon2, dfLat2);
poFeature->SetGeometryDirectly( lineString );
}
else
{
/* Crossing antemeridian */
OGRMultiLineString* multiLineString = new OGRMultiLineString();
OGRLineString* lineString1 = new OGRLineString();
OGRLineString* lineString2 = new OGRLineString();
double dfLatInt;
lineString1->addPoint(dfLon1, dfLat1);
if (dfLon1 < dfLon2)
{
dfLatInt = dfLat1 + (dfLat2 - dfLat1) * (-180 - dfLon1) / ((dfLon2 - 360) - dfLon1);
lineString1->addPoint(-180, dfLatInt);
lineString2->addPoint(180, dfLatInt);
}
else
{
dfLatInt = dfLat1 + (dfLat2 - dfLat1) * (180 - dfLon1) / ((dfLon2 + 360) - dfLon1);
lineString1->addPoint(180, dfLatInt);
lineString2->addPoint(-180, dfLatInt);
}
lineString2->addPoint(dfLon2, dfLat2);
multiLineString->addGeometryDirectly( lineString1 );
multiLineString->addGeometryDirectly( lineString2 );
poFeature->SetGeometryDirectly( multiLineString );
}
poFeature->SetField( nCount++, pszAirwaySegmentName );
poFeature->SetField( nCount++, pszFirstPointName );
poFeature->SetField( nCount++, pszSecondPointName );
poFeature->SetField( nCount++, bIsHigh );
poFeature->SetField( nCount++, nBaseFL );
poFeature->SetField( nCount++, nTopFL );
RegisterFeature(poFeature);
return poFeature;
}
OGRFeature* create_line_feature(const Osmium::OSM::Way* way, OGRLayer* layer) {
OGRFeature* feature = OGRFeature::CreateFeature(layer->GetLayerDefn());
Osmium::Geometry::LineString linestring(*way);
OGRLineString* ogrgeom = Osmium::Geometry::create_ogr_geometry(linestring);
ogrgeom->transform(m_transformation);
feature->SetGeometryDirectly(ogrgeom);
sprintf(longint, "%ld", way->id());
feature->SetField("osm_id", longint);
feature->SetField("z_order", calculate_z_order(way));
feature->SetField("way_area", 0);
return feature;
}
OGRFeature* create_point_feature(const Osmium::OSM::Node* node) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_point->GetLayerDefn());
Osmium::Geometry::Point point(*node);
OGRPoint* ogrgeom = Osmium::Geometry::create_ogr_geometry(point);
ogrgeom->transform(m_transformation);
feature->SetGeometryDirectly(ogrgeom);
sprintf(longint, "%ld", node->id());
feature->SetField("osm_id", longint);
feature->SetField("z_order", calculate_z_order(node));
feature->SetField("way_area", 0);
return feature;
}
OGRFeature* create_area_feature(const shared_ptr<Osmium::OSM::Area const>& area)
{
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_polygon->GetLayerDefn());
Osmium::Geometry::MultiPolygon mp(*area);
OGRMultiPolygon* ogrgeom = Osmium::Geometry::create_ogr_geometry(mp);
ogrgeom->transform(m_transformation);
feature->SetGeometryDirectly(ogrgeom);
sprintf(longint, "%ld", area->from_way() ? area->orig_id() : -area->orig_id());
feature->SetField("osm_id", longint);
feature->SetField("z_order", calculate_z_order(area.get()));
feature->SetField("way_area", ogrgeom->get_Area());
return feature;
}
OGRFeature * OGRSQLiteSingleFeatureLayer::GetNextFeature()
{
if (iNextShapeId != 0)
return NULL;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
if (pszVal)
poFeature->SetField(0, pszVal);
else
poFeature->SetField(0, nVal);
poFeature->SetFID(iNextShapeId ++);
return poFeature;
}
OGRFeature *OGRNASRelationLayer::GetNextFeature()
{
if( !bPopulated )
poDS->PopulateRelations();
/* ==================================================================== */
/* Loop till we find and translate a feature meeting all our */
/* requirements. */
/* ==================================================================== */
while( TRUE )
{
// out of features?
if( iNextFeature >= (int) aoRelationCollection.size() )
return NULL;
/* -------------------------------------------------------------------- */
/* The from/type/to values are stored in a packed string with */
/* \0 separators for compactness. Split out components. */
/* -------------------------------------------------------------------- */
const char *pszFromID, *pszType, *pszToID;
pszFromID = aoRelationCollection[iNextFeature].c_str();
pszType = pszFromID + strlen(pszFromID) + 1;
pszToID = pszType + strlen(pszType) + 1;
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Translate values into an OGRFeature. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
poFeature->SetField( 0, pszFromID );
poFeature->SetField( 1, pszType );
poFeature->SetField( 2, pszToID );
poFeature->SetFID( iNextFeature++ );
/* -------------------------------------------------------------------- */
/* Test against the attribute query. */
/* -------------------------------------------------------------------- */
if( m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poFeature ) )
delete poFeature;
else
return poFeature;
}
return NULL;
}
/*!
\brief Get feature (private)
\return pointer to OGRFeature
\return NULL not found
*/
OGRFeature *OGRVFKLayer::GetFeature(VFKFeature *poVFKFeature)
{
OGRGeometry *poGeom;
/* skip feature with unknown geometry type */
if (poVFKFeature->GetGeometryType() == wkbUnknown)
return NULL;
/* get features geometry */
poGeom = CreateGeometry(poVFKFeature);
if (poGeom != NULL)
poGeom->assignSpatialReference(poSRS);
/* does it satisfy the spatial query, if there is one? */
if (m_poFilterGeom != NULL && poGeom && !FilterGeometry(poGeom)) {
return NULL;
}
/* convert the whole feature into an OGRFeature */
OGRFeature *poOGRFeature = new OGRFeature(GetLayerDefn());
poOGRFeature->SetFID(poVFKFeature->GetFID());
// poOGRFeature->SetFID(++m_iNextFeature);
for (int iField = 0; iField < poDataBlock->GetPropertyCount(); iField++) {
if (poVFKFeature->GetProperty(iField)->IsNull())
continue;
OGRFieldType fType = poOGRFeature->GetDefnRef()->GetFieldDefn(iField)->GetType();
if (fType == OFTInteger)
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueI());
else if (fType == OFTReal)
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueD());
else
poOGRFeature->SetField(iField,
poVFKFeature->GetProperty(iField)->GetValueS());
}
/* test against the attribute query */
if (m_poAttrQuery != NULL &&
!m_poAttrQuery->Evaluate(poOGRFeature)) {
delete poOGRFeature;
return NULL;
}
if (poGeom)
poOGRFeature->SetGeometryDirectly(poGeom->clone());
return poOGRFeature;
}
OGRFeature*
OGRXPlaneGSLayer::AddFeature(const char* pszNavaidID,
const char* pszAptICAO,
const char* pszRwyNum,
double dfLat,
double dfLon,
double dfEle,
double dfFreq,
double dfRange,
double dfTrueHeading,
double dfSlope)
{
int nCount = 0;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetGeometryDirectly( new OGRPoint( dfLon, dfLat ) );
poFeature->SetField( nCount++, pszNavaidID );
poFeature->SetField( nCount++, pszAptICAO );
poFeature->SetField( nCount++, pszRwyNum );
poFeature->SetField( nCount++, dfEle );
poFeature->SetField( nCount++, dfFreq );
poFeature->SetField( nCount++, dfRange );
poFeature->SetField( nCount++, dfTrueHeading );
poFeature->SetField( nCount++, dfSlope );
RegisterFeature(poFeature);
return poFeature;
}
void write_point(const char* problem_type, osmium::object_id_type id1, osmium::object_id_type id2, osmium::Location location) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_perror->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_ogr_factory.create_point(location);
feature->SetGeometry(ogr_point.get());
feature->SetField("id1", static_cast<double>(id1));
feature->SetField("id2", static_cast<double>(id2));
feature->SetField("problem_type", problem_type);
if (m_layer_perror->CreateFeature(feature) != OGRERR_NONE) {
std::runtime_error("Failed to create feature on layer 'perrors'");
}
OGRFeature::DestroyFeature(feature);
}
void area(const osmium::Area& area) {
if (m_first_out) {
m_out << "[\n";
m_first_out = false;
} else {
m_out << ",\n";
}
m_out << "{\n \"test_id\": " << (area.orig_id() / 1000) << ",\n \"area_id\": " << area.id() << ",\n \"from_id\": " << area.orig_id() << ",\n \"from_type\": \"" << (area.from_way() ? "way" : "relation") << "\",\n \"wkt\": \"";
try {
std::string wkt = m_wkt_factory.create_multipolygon(area);
m_out << wkt << "\",\n \"tags\": {";
auto tagmap = create_map(area.tags());
bool first = true;
for (auto& tag : tagmap) {
if (first) {
first = false;
} else {
m_out << ", ";
}
m_out << '"' << tag.first << "\": \"" << tag.second << '"';
}
m_out << "}\n}";
} catch (osmium::geometry_error&) {
m_out << "INVALID\"\n}";
}
try {
std::unique_ptr<OGRMultiPolygon> ogr_polygon = m_ogr_factory.create_multipolygon(area);
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_polygon->GetLayerDefn());
feature->SetGeometry(ogr_polygon.get());
feature->SetField("id", static_cast<int>(area.orig_id()));
std::string from_type;
if (area.from_way()) {
from_type = "w";
} else {
from_type = "r";
}
feature->SetField("from_type", from_type.c_str());
if (m_layer_polygon->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
} catch (osmium::geometry_error&) {
std::cerr << "Ignoring illegal geometry for area " << area.id() << " created from " << (area.from_way() ? "way" : "relation") << " with id=" << area.orig_id() << ".\n";
}
}
OGRFeature *OGRXLSLayer::GetNextRawFeature()
{
if (nNextFID == nRows)
return nullptr;
const void* xlshandle = poDS->GetXLSHandle();
if (xlshandle == nullptr)
return nullptr;
freexl_select_active_worksheet(xlshandle, (unsigned short)iSheet);
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
FreeXL_CellValue sCellValue;
for(unsigned short i=0;i<(unsigned short )poFeatureDefn->GetFieldCount(); i++)
{
if (freexl_get_cell_value(xlshandle, nNextFID, i, &sCellValue) == FREEXL_OK)
{
switch (sCellValue.type)
{
case FREEXL_CELL_INT:
poFeature->SetField(i, sCellValue.value.int_value);
break;
case FREEXL_CELL_DOUBLE:
poFeature->SetField(i, sCellValue.value.double_value);
break;
case FREEXL_CELL_TEXT:
case FREEXL_CELL_SST_TEXT:
poFeature->SetField(i, sCellValue.value.text_value);
break;
case FREEXL_CELL_DATE:
case FREEXL_CELL_DATETIME:
case FREEXL_CELL_TIME:
poFeature->SetField(i, sCellValue.value.text_value);
break;
case FREEXL_CELL_NULL:
break;
default:
CPLDebug("XLS", "Unknown cell type = %d", sCellValue.type);
break;
}
}
}
poFeature->SetFID(nNextFID + 1);
nNextFID ++;
return poFeature;
}
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;
}
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 );
}
}
seqFeatures_.push_back( poNewFeature );
}
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);
}
}
}
void ShapefileWriter::_writeWayPolygon(const ConstOsmMapPtr &map, const shared_ptr<Way> &way,
OGRLayer *poLayer, const QStringList& columns, const QStringList &shpColumns)
{
OGRFeature* poFeature = OGRFeature::CreateFeature( poLayer->GetLayerDefn() );
// set all the column values.
for (int i = 0; i < columns.size(); i++)
{
if (way->getTags().contains(columns[i]))
{
QByteArray c = shpColumns[i].toAscii();
QByteArray v = way->getTags()[columns[i]].toUtf8();
poFeature->SetField(c.constData(), v.constData());
}
}
if (_includeInfo)
{
poFeature->SetField(_circularErrorIndex, way->getCircularError());
}
// convert the geometry.
shared_ptr<Geometry> p = ElementConverter(map).convertToGeometry(way);
if (p->getGeometryTypeId() != GEOS_POLYGON)
{
throw InternalErrorException("Expected a polygon geometry, but got a: " +
toString(p->getGeometryType()));
}
std::string wkt = p->toString();
char* t = (char*)wkt.data();
OGRGeometry* geom;
if (OGRGeometryFactory::createFromWkt(&t, poLayer->GetSpatialRef(), &geom) != OGRERR_NONE)
{
throw HootException(QString("Error parsing WKT (%1)").arg(QString::fromStdString(wkt)));
}
if (poFeature->SetGeometryDirectly(geom) != OGRERR_NONE)
{
throw HootException(QString("Error setting geometry"));
}
if (poLayer->CreateFeature(poFeature) != OGRERR_NONE)
{
throw HootException(QString("Error creating feature"));
}
OGRFeature::DestroyFeature(poFeature);
}
OGRFeature *TigerAltName::GetFeature( int nRecordId )
{
char achRecord[OGR_TIGER_RECBUF_LEN];
if( nRecordId < 0 || nRecordId >= nFeatures )
{
CPLError( CE_Failure, CPLE_FileIO,
"Request for out-of-range feature %d of %s4",
nRecordId, pszModule );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Read the raw record data from the file. */
/* -------------------------------------------------------------------- */
if( fpPrimary == NULL )
return NULL;
if( VSIFSeekL( fpPrimary, nRecordId * nRecordLength, SEEK_SET ) != 0 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %s4",
nRecordId * nRecordLength, pszModule );
return NULL;
}
if( VSIFReadL( achRecord, psRTInfo->nRecordLength, 1, fpPrimary ) != 1 )
{
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read record %d of %s4",
nRecordId, pszModule );
return NULL;
}
/* -------------------------------------------------------------------- */
/* Set fields. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
int anFeatList[5];
int nFeatCount=0;
SetFields( psRTInfo, poFeature, achRecord );
for( int iFeat = 0; iFeat < 5; iFeat++ )
{
const char * pszFieldText;
pszFieldText = GetField( achRecord, 19 + iFeat*8, 26 + iFeat*8 );
if( *pszFieldText != '\0' )
anFeatList[nFeatCount++] = atoi(pszFieldText);
}
poFeature->SetField( "FEAT", nFeatCount, anFeatList );
return poFeature;
}
void node(const osmium::Node& node) {
const char* amenity = node.tags()["amenity"];
if (amenity && !strcmp(amenity, "post_box")) {
OGRFeature* feature = OGRFeature::CreateFeature(m_layer_point->GetLayerDefn());
std::unique_ptr<OGRPoint> ogr_point = m_factory.create_point(node);
feature->SetGeometry(ogr_point.get());
feature->SetField("id", static_cast<double>(node.id()));
feature->SetField("operator", node.tags()["operator"]);
if (m_layer_point->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature.\n";
exit(1);
}
OGRFeature::DestroyFeature(feature);
}
}
OGRFeature*
OGRXPlaneDMELayer::AddFeature(const char* pszNavaidID,
const char* pszNavaidName,
const char* pszSubType,
double dfLat,
double dfLon,
double dfEle,
double dfFreq,
double dfRange,
double dfBias)
{
int nCount = 0;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetGeometryDirectly( new OGRPoint( dfLon, dfLat ) );
poFeature->SetField( nCount++, pszNavaidID );
poFeature->SetField( nCount++, pszNavaidName );
poFeature->SetField( nCount++, pszSubType );
poFeature->SetField( nCount++, dfEle );
poFeature->SetField( nCount++, dfFreq );
poFeature->SetField( nCount++, dfRange );
poFeature->SetField( nCount++, dfBias );
RegisterFeature(poFeature);
return poFeature;
}
OGRFeature *OGRSEGUKOOALineLayer::GetNextRawFeature()
{
if( bEOF )
return nullptr;
/* Merge points of base layer that have same value for attribute(0) */
/* into a single linestring */
OGRFeature* poFeature = nullptr;
OGRLineString* poLS = nullptr;
if (poNextBaseFeature == nullptr)
poNextBaseFeature = poBaseLayer->GetNextFeature();
while(poNextBaseFeature != nullptr)
{
if (poNextBaseFeature->IsFieldSetAndNotNull(0) &&
poNextBaseFeature->GetFieldAsString(0)[0] != '\0')
{
if (poFeature != nullptr &&
strcmp(poFeature->GetFieldAsString(0),
poNextBaseFeature->GetFieldAsString(0)) != 0)
{
poFeature->SetGeometryDirectly(poLS);
return poFeature;
}
OGRGeometry* poGeom =
poNextBaseFeature->GetGeometryRef();
OGRPoint* poPoint = poGeom ? poGeom->toPoint(): nullptr;
if (poPoint != nullptr)
{
if (poFeature == nullptr)
{
poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFID(nNextFID ++);
poFeature->SetField(0,
poNextBaseFeature->GetFieldAsString(0));
poLS = new OGRLineString();
if (poBaseLayer->GetSpatialRef())
poLS->assignSpatialReference(
poBaseLayer->GetSpatialRef());
}
poLS->addPoint(poPoint);
}
}
delete poNextBaseFeature;
poNextBaseFeature = poBaseLayer->GetNextFeature();
}
bEOF = true;
if( poFeature )
poFeature->SetGeometryDirectly(poLS);
return poFeature;
}
