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*
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 *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;
}
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;
}
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;
}
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* 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());
}
if( poFeatureDefn->IsGeometryIgnored() )
poFeature->SetGeometryDirectly(NULL);
else
{
OGRGeometry* poGeom = poFeature->GetGeometryRef();
if( poGeom != NULL )
poGeom->assignSpatialReference(GetSpatialRef());
}
if( bPreserveSrcFID )
poFeature->SetFID(poSrcFeature->GetFID());
else
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 */
}
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 * cvct2gdal::CVCT2GDALFeature( VCTFeature * poVCTFeat, OGRFeatureDefn * poOGRFeatDefn )
{
OGRFeature * poOGRFeat = new OGRFeature ( poOGRFeatDefn );
OGRGeometry * poOGRGeometry = CVCT2GDALGeometry ( poVCTFeat->geometry );
poOGRFeat->SetGeometryDirectly ( poOGRGeometry );
CVCT2GDALWriteFields ( *poVCTFeat, *poOGRFeat );
return poOGRFeat;
}
OGRFeature *TigerPoint::GetFeature( int nRecordId,
int nX0, int nX1,
int nY0, int nY1 )
{
char achRecord[OGR_TIGER_RECBUF_LEN];
if( nRecordId < 0 || nRecordId >= nFeatures ) {
CPLError( CE_Failure, CPLE_FileIO,
"Request for out-of-range feature %d of %sP",
nRecordId, pszModule );
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Read the raw record data from the file. */
/* -------------------------------------------------------------------- */
if( fpPrimary == nullptr )
return nullptr;
if( VSIFSeekL( fpPrimary, nRecordId * nRecordLength, SEEK_SET ) != 0 ) {
CPLError( CE_Failure, CPLE_FileIO,
"Failed to seek to %d of %sP",
nRecordId * nRecordLength, pszModule );
return nullptr;
}
// Overflow cannot happen since psRTInfo->nRecordLength is unsigned
// char and sizeof(achRecord) == OGR_TIGER_RECBUF_LEN > 255
if( VSIFReadL( achRecord, psRTInfo->nRecordLength, 1, fpPrimary ) != 1 ) {
CPLError( CE_Failure, CPLE_FileIO,
"Failed to read record %d of %sP",
nRecordId, pszModule );
return nullptr;
}
/* -------------------------------------------------------------------- */
/* Set fields. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
SetFields( psRTInfo, poFeature, achRecord);
/* -------------------------------------------------------------------- */
/* Set geometry */
/* -------------------------------------------------------------------- */
const double dfX = atoi(GetField(achRecord, nX0, nX1)) / 1000000.0;
const double dfY = atoi(GetField(achRecord, nY0, nY1)) / 1000000.0;
if( dfX != 0.0 || dfY != 0.0 ) {
poFeature->SetGeometryDirectly( new OGRPoint( dfX, dfY ) );
}
return poFeature;
}
OGRFeature *OGRSEGUKOOALineLayer::GetNextRawFeature()
{
if (bEOF)
return NULL;
/* Merge points of base layer that have same value for attribute(0) */
/* into a single linestring */
OGRFeature* poFeature = NULL;
OGRLineString* poLS = NULL;
if (poNextBaseFeature == NULL)
poNextBaseFeature = poBaseLayer->GetNextFeature();
while(poNextBaseFeature != NULL)
{
if (poNextBaseFeature->IsFieldSet(0) &&
poNextBaseFeature->GetFieldAsString(0)[0] != '\0')
{
if (poFeature != NULL &&
strcmp(poFeature->GetFieldAsString(0),
poNextBaseFeature->GetFieldAsString(0)) != 0)
{
return poFeature;
}
OGRPoint* poPoint =
(OGRPoint*) poNextBaseFeature->GetGeometryRef();
if (poPoint != NULL)
{
if (poFeature == NULL)
{
poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFID(nNextFID ++);
poFeature->SetField(0,
poNextBaseFeature->GetFieldAsString(0));
poLS = new OGRLineString();
if (poBaseLayer->GetSpatialRef())
poLS->assignSpatialReference(
poBaseLayer->GetSpatialRef());
poFeature->SetGeometryDirectly(poLS);
}
poLS->addPoint(poPoint);
}
}
delete poNextBaseFeature;
poNextBaseFeature = poBaseLayer->GetNextFeature();
}
bEOF = TRUE;
return poFeature;
}
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_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_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 *OGRAeronavFAANAVAIDLayer::GetNextRawFeature()
{
char szBuffer[134];
while( true )
{
const char* pszLine = CPLReadLine2L(fpAeronavFAA, 134, nullptr);
if (pszLine == nullptr)
{
bEOF = true;
return nullptr;
}
if (strlen(pszLine) != 132)
continue;
if ( !(pszLine[psRecordDesc->nLatStartCol-1] == 'N' ||
pszLine[psRecordDesc->nLatStartCol-1] == 'S') )
continue;
if ( !(pszLine[psRecordDesc->nLonStartCol-1] == 'E' ||
pszLine[psRecordDesc->nLonStartCol-1] == 'W') )
continue;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetFID(nNextFID ++);
for( int i=0; i < psRecordDesc->nFields; i++ )
{
int nWidth = psRecordDesc->pasFields[i].nLastCol - psRecordDesc->pasFields[i].nStartCol + 1;
strncpy(szBuffer, pszLine + psRecordDesc->pasFields[i].nStartCol - 1, nWidth);
szBuffer[nWidth] = 0;
while(nWidth > 0 && szBuffer[nWidth - 1] == ' ')
{
szBuffer[nWidth - 1] = 0;
nWidth --;
}
if (nWidth != 0)
poFeature->SetField(i, szBuffer);
}
double dfLat = 0.0;
double dfLon = 0.0;
GetLatLon(pszLine + psRecordDesc->nLatStartCol - 1,
pszLine + psRecordDesc->nLonStartCol - 1,
dfLat,
dfLon);
OGRGeometry* poGeom = new OGRPoint(dfLon, dfLat);
poGeom->assignSpatialReference(poSRS);
poFeature->SetGeometryDirectly( poGeom );
return poFeature;
}
}
OGRFeature*
OGRXPlaneFIXLayer::AddFeature(const char* pszFixName,
double dfLat,
double dfLon)
{
int nCount = 0;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetGeometryDirectly( new OGRPoint( dfLon, dfLat ) );
poFeature->SetField( nCount++, pszFixName );
RegisterFeature(poFeature);
return poFeature;
}
/*!
\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* 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 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);
}
void add_segment(OGRLayer* layer, int change, const osmium::UndirectedSegment& segment) {
OGRFeature* feature = OGRFeature::CreateFeature(layer->GetLayerDefn());
auto linestring = new OGRLineString();
linestring->addPoint(segment.first().lon(), segment.first().lat());
linestring->addPoint(segment.second().lon(), segment.second().lat());
feature->SetGeometryDirectly(linestring);
feature->SetField("change", change);
if (layer->CreateFeature(feature) != OGRERR_NONE) {
std::cerr << "Failed to create feature on layer 'changes'.\n";
exit(return_code_fatal);
}
OGRFeature::DestroyFeature(feature);
}
OGRFeature *OGRNTFRasterLayer::GetFeature( long nFeatureId )
{
int iReqColumn, iReqRow;
/* -------------------------------------------------------------------- */
/* Is this in the range of legal feature ids (pixels)? */
/* -------------------------------------------------------------------- */
if( nFeatureId < 1
|| nFeatureId > poReader->GetRasterXSize()*poReader->GetRasterYSize() )
{
return NULL;
}
/* -------------------------------------------------------------------- */
/* Do we need to load a different column. */
/* -------------------------------------------------------------------- */
iReqColumn = (nFeatureId - 1) / poReader->GetRasterYSize();
iReqRow = nFeatureId - iReqColumn * poReader->GetRasterXSize() - 1;
if( iReqColumn != iColumnOffset )
{
iColumnOffset = iReqColumn;
if( poReader->ReadRasterColumn( iReqColumn, pafColumn ) != CE_None )
return NULL;
}
/* -------------------------------------------------------------------- */
/* Create a corresponding feature. */
/* -------------------------------------------------------------------- */
OGRFeature *poFeature = new OGRFeature( poFeatureDefn );
double *padfGeoTransform = poReader->GetGeoTransform();
poFeature->SetFID( nFeatureId );
// NOTE: unusual use of GeoTransform - the pixel origin is the
// bottom left corner!
poFeature->SetGeometryDirectly(
new OGRPoint( padfGeoTransform[0] + padfGeoTransform[1] * iReqColumn,
padfGeoTransform[3] + padfGeoTransform[5] * iReqRow,
pafColumn[iReqRow] ) );
poFeature->SetField( 0, pafColumn[iReqRow] );
return poFeature;
}
OGRFeature* GTMTrackLayer::GetNextFeature()
{
if( bError )
return nullptr;
while (poDS->hasNextTrack())
{
Track* poTrack = poDS->fetchNextTrack();
if (poTrack == nullptr)
{
CPLError(CE_Failure, CPLE_AppDefined,
"Could not read track. File probably corrupted");
bError = true;
return nullptr;
}
OGRFeature* poFeature = new OGRFeature( poFeatureDefn );
OGRLineString* lineString = new OGRLineString ();
for (int i = 0; i < poTrack->getNumPoints(); ++i)
{
const TrackPoint* psTrackPoint = poTrack->getPoint(i);
lineString->addPoint(psTrackPoint->x,
psTrackPoint->y);
}
if (poSRS)
lineString->assignSpatialReference(poSRS);
poFeature->SetField( NAME, poTrack->getName());
poFeature->SetField( TYPE, poTrack->getType());
poFeature->SetField( COLOR, poTrack->getColor());
poFeature->SetFID( nNextFID++ );
delete poTrack;
poFeature->SetGeometryDirectly(lineString);
if( (m_poFilterGeom == nullptr
|| FilterGeometry( poFeature->GetGeometryRef() ) )
&& (m_poAttrQuery == nullptr
|| m_poAttrQuery->Evaluate( poFeature )) )
return poFeature;
delete poFeature;
}
return nullptr;
}
void ShapefileWriter::_writeRelationPolygon(const ConstOsmMapPtr& map,
const shared_ptr<Relation> &relation, 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 (relation->getTags().contains(columns[i]))
{
QByteArray c = shpColumns[i].toAscii();
QByteArray v = relation->getTags()[columns[i]].toAscii();
poFeature->SetField(c.constData(), v.constData());
}
}
if (_includeInfo)
{
poFeature->SetField(_circularErrorIndex, relation->getCircularError());
}
// convert the geometry.
const shared_ptr<const Relation>& r = relation;
std::string wkt = ElementConverter(map).convertToGeometry(r)->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*
OGRXPlaneMarkerLayer::AddFeature(const char* pszAptICAO,
const char* pszRwyNum,
const char* pszSubType,
double dfLat,
double dfLon,
double dfEle,
double dfTrueHeading)
{
int nCount = 0;
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetGeometryDirectly( new OGRPoint( dfLon, dfLat ) );
poFeature->SetField( nCount++, pszAptICAO );
poFeature->SetField( nCount++, pszRwyNum );
poFeature->SetField( nCount++, pszSubType );
poFeature->SetField( nCount++, dfEle );
poFeature->SetField( nCount++, dfTrueHeading );
RegisterFeature(poFeature);
return poFeature;
}
OGRFeature*
OGRXPlaneAirwayIntersectionLayer::AddFeature(const char* pszIntersectionName,
double dfLat,
double dfLon)
{
OGRFeature* poFeature = new OGRFeature(poFeatureDefn);
poFeature->SetGeometryDirectly( new OGRPoint( dfLon, dfLat ) );
poFeature->SetField( 0, pszIntersectionName );
if (CPLHashSetLookup(poSet, poFeature) == NULL)
{
CPLHashSetInsert(poSet, poFeature->Clone());
RegisterFeature(poFeature);
return poFeature;
}
else
{
delete poFeature;
return NULL;
}
}
/*!
\brief Get feature (private)
\return pointer to OGRFeature or NULL not found
*/
OGRFeature *OGRVFKLayer::GetFeature(IVFKFeature *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);
poVFKFeature->LoadProperties(poOGRFeature);
/* 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 *OGROGDILayer::GetNextRawFeature()
{
ecs_Result *psResult;
int i;
OGRFeature *poFeature;
/* -------------------------------------------------------------------- */
/* Retrieve object from OGDI server and create new feature */
/* -------------------------------------------------------------------- */
psResult = cln_GetNextObject(m_nClientID);
if (! ECSSUCCESS(psResult))
{
// We probably reached EOF... keep track of shape count.
m_nTotalShapeCount = m_iNextShapeId - m_nFilteredOutShapes;
return NULL;
}
poFeature = new OGRFeature(m_poFeatureDefn);
poFeature->SetFID( m_iNextShapeId++ );
m_nFeaturesRead++;
/* -------------------------------------------------------------------- */
/* Process geometry */
/* -------------------------------------------------------------------- */
if (m_eFamily == Point)
{
ecs_Point *psPoint = &(ECSGEOM(psResult).point);
OGRPoint *poOGRPoint = new OGRPoint(psPoint->c.x, psPoint->c.y);
poOGRPoint->assignSpatialReference(m_poSpatialRef);
poFeature->SetGeometryDirectly(poOGRPoint);
}
else if (m_eFamily == Line)
{
ecs_Line *psLine = &(ECSGEOM(psResult).line);
OGRLineString *poOGRLine = new OGRLineString();
poOGRLine->setNumPoints( psLine->c.c_len );
for( i=0; i < (int) psLine->c.c_len; i++ )
{
poOGRLine->setPoint(i, psLine->c.c_val[i].x, psLine->c.c_val[i].y);
}
poOGRLine->assignSpatialReference(m_poSpatialRef);
poFeature->SetGeometryDirectly(poOGRLine);
}
else if (m_eFamily == Area)
{
ecs_Area *psArea = &(ECSGEOM(psResult).area);
OGRPolygon *poOGRPolygon = new OGRPolygon();
for(int iRing=0; iRing < (int) psArea->ring.ring_len; iRing++)
{
ecs_FeatureRing *psRing = &(psArea->ring.ring_val[iRing]);
OGRLinearRing *poOGRRing = new OGRLinearRing();
poOGRRing->setNumPoints( psRing->c.c_len );
for( i=0; i < (int) psRing->c.c_len; i++ )
{
poOGRRing->setPoint(i, psRing->c.c_val[i].x,
psRing->c.c_val[i].y);
}
poOGRPolygon->addRingDirectly(poOGRRing);
}
// __TODO__
// When OGR supports polygon centroids then we should carry them here
poOGRPolygon->assignSpatialReference(m_poSpatialRef);
poFeature->SetGeometryDirectly(poOGRPolygon);
}
else if (m_eFamily == Text)
{
// __TODO__
// For now text is treated as a point and string is lost
//
ecs_Text *psText = &(ECSGEOM(psResult).text);
OGRPoint *poOGRPoint = new OGRPoint(psText->c.x, psText->c.y);
poOGRPoint->assignSpatialReference(m_poSpatialRef);
poFeature->SetGeometryDirectly(poOGRPoint);
}
else
{
CPLAssert(FALSE);
}
/* -------------------------------------------------------------------- */
/* Set attributes */
/* -------------------------------------------------------------------- */
char *pszAttrList = ECSOBJECTATTR(psResult);
for( int iField = 0; iField < m_poFeatureDefn->GetFieldCount(); iField++ )
{
char *pszFieldStart;
int nNameLen;
char chSavedChar;
/* parse out the next attribute value */
if( !ecs_FindElement( pszAttrList, &pszFieldStart, &pszAttrList,
&nNameLen, NULL ) )
{
nNameLen = 0;
pszFieldStart = pszAttrList;
}
/* Skip any trailing white space (for string constants). */
if( nNameLen > 0 && pszFieldStart[nNameLen-1] == ' ' )
nNameLen--;
/* skip leading white space */
while( pszFieldStart[0] == ' ' && nNameLen > 0 )
{
pszFieldStart++;
nNameLen--;
}
/* zero terminate the single field value, but save the */
/* character we overwrote, so we can restore it when done. */
chSavedChar = pszFieldStart[nNameLen];
pszFieldStart[nNameLen] = '\0';
/* OGR takes care of all field type conversions for us! */
poFeature->SetField(iField, pszFieldStart);
pszFieldStart[nNameLen] = chSavedChar;
}
/* -------------------------------------------------------------------- */
/* Apply the text associated with text features if appropriate. */
/* -------------------------------------------------------------------- */
if( m_eFamily == Text )
{
poFeature->SetField( "text", ECSGEOM(psResult).text.desc );
}
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 *OGRNASLayer::GetNextFeature()
{
GMLFeature *poNASFeature = NULL;
OGRGeometry *poGeom = NULL;
if( iNextNASId == 0 )
ResetReading();
/* ==================================================================== */
/* Loop till we find and translate a feature meeting all our */
/* requirements. */
/* ==================================================================== */
while( TRUE )
{
/* -------------------------------------------------------------------- */
/* Cleanup last feature, and get a new raw nas feature. */
/* -------------------------------------------------------------------- */
delete poNASFeature;
delete poGeom;
poNASFeature = NULL;
poGeom = NULL;
poNASFeature = poDS->GetReader()->NextFeature();
if( poNASFeature == NULL )
return NULL;
/* -------------------------------------------------------------------- */
/* Is it of the proper feature class? */
/* -------------------------------------------------------------------- */
// We count reading low level NAS features as a feature read for
// work checking purposes, though at least we didn't necessary
// have to turn it into an OGRFeature.
m_nFeaturesRead++;
if( poNASFeature->GetClass() != poFClass )
continue;
iNextNASId++;
/* -------------------------------------------------------------------- */
/* Does it satisfy the spatial query, if there is one? */
/* -------------------------------------------------------------------- */
const CPLXMLNode* const * papsGeometry = poNASFeature->GetGeometryList();
if (papsGeometry[0] != NULL)
{
poGeom = (OGRGeometry*) OGR_G_CreateFromGMLTree(papsGeometry[0]);
// We assume the createFromNAS() function would have already
// reported the error.
if( poGeom == NULL )
{
delete poNASFeature;
return NULL;
}
if( m_poFilterGeom != NULL && !FilterGeometry( poGeom ) )
continue;
}
/* -------------------------------------------------------------------- */
/* Convert the whole feature into an OGRFeature. */
/* -------------------------------------------------------------------- */
int iField;
OGRFeature *poOGRFeature = new OGRFeature( GetLayerDefn() );
poOGRFeature->SetFID( iNextNASId );
for( iField = 0; iField < poFClass->GetPropertyCount(); iField++ )
{
const GMLProperty *psGMLProperty = poNASFeature->GetProperty( iField );
if( psGMLProperty == NULL || psGMLProperty->nSubProperties == 0 )
continue;
switch( poFClass->GetProperty(iField)->GetType() )
{
case GMLPT_Real:
{
poOGRFeature->SetField( iField, CPLAtof(psGMLProperty->papszSubProperties[0]) );
}
break;
case GMLPT_IntegerList:
{
int nCount = psGMLProperty->nSubProperties;
int *panIntList = (int *) CPLMalloc(sizeof(int) * nCount );
int i;
for( i = 0; i < nCount; i++ )
panIntList[i] = atoi(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iField, nCount, panIntList );
CPLFree( panIntList );
}
break;
case GMLPT_RealList:
{
int nCount = psGMLProperty->nSubProperties;
double *padfList = (double *)CPLMalloc(sizeof(double)*nCount);
int i;
for( i = 0; i < nCount; i++ )
padfList[i] = CPLAtof(psGMLProperty->papszSubProperties[i]);
poOGRFeature->SetField( iField, nCount, padfList );
CPLFree( padfList );
}
break;
case GMLPT_StringList:
{
poOGRFeature->SetField( iField, psGMLProperty->papszSubProperties );
}
break;
default:
poOGRFeature->SetField( iField, psGMLProperty->papszSubProperties[0] );
break;
}
}
/* -------------------------------------------------------------------- */
/* Test against the attribute query. */
/* -------------------------------------------------------------------- */
if( m_poAttrQuery != NULL
&& !m_poAttrQuery->Evaluate( poOGRFeature ) )
{
delete poOGRFeature;
continue;
}
/* -------------------------------------------------------------------- */
/* Wow, we got our desired feature. Return it. */
/* -------------------------------------------------------------------- */
delete poNASFeature;
poOGRFeature->SetGeometryDirectly( poGeom );
return poOGRFeature;
}
return NULL;
}
