double OGRCompoundCurve::get_Area() const
{
if( IsEmpty() || !get_IsClosed() )
return 0;
// Optimization for convex rings.
if( IsConvex() )
{
// Compute area of shape without the circular segments.
OGRPointIterator* poIter = getPointIterator();
OGRLineString oLS;
oLS.setNumPoints( getNumPoints() );
OGRPoint p;
for( int i = 0; poIter->getNextPoint(&p); i++ )
{
oLS.setPoint( i, p.getX(), p.getY() );
}
double dfArea = oLS.get_Area();
delete poIter;
// Add the area of the spherical segments.
dfArea += get_AreaOfCurveSegments();
return dfArea;
}
OGRLineString* poLS = CurveToLine();
double dfArea = poLS->get_Area();
delete poLS;
return dfArea;
}
OGRPoint *getARCCenter(OGRPoint *ptStart, OGRPoint *ptArc, OGRPoint *ptEnd) {
// FIXME precision
double bx = ptStart->getX(); double by = ptStart->getY();
double cx = ptArc->getX(); double cy = ptArc->getY();
double dx = ptEnd->getX(); double dy = ptEnd->getY();
double temp, bc, cd, det, x, y;
temp = cx*cx+cy*cy;
bc = (bx*bx + by*by - temp)/2.0;
cd = (temp - dx*dx - dy*dy)/2.0;
det = (bx-cx)*(cy-dy)-(cx-dx)*(by-cy);
OGRPoint *center = new OGRPoint();
if (fabs(det) < 1.0e-6) { // could not determin the determinante: too small
return center;
}
det = 1/det;
x = (bc*(cy-dy)-cd*(by-cy))*det;
y = ((bx-cx)*cd-(cx-dx)*bc)*det;
center->setX(x);
center->setY(y);
return center;
}
OGRErr TigerPoint::CreateFeature( OGRFeature *poFeature,
int pointIndex)
{
char szRecord[OGR_TIGER_RECBUF_LEN];
OGRPoint *poPoint = poFeature->GetGeometryRef()->toPoint();
if( !SetWriteModule( m_pszFileCode, psRTInfo->nRecordLength+2, poFeature ) )
return OGRERR_FAILURE;
memset( szRecord, ' ', psRTInfo->nRecordLength );
WriteFields( psRTInfo, poFeature, szRecord );
if( poPoint != nullptr
&& (poPoint->getGeometryType() == wkbPoint
|| poPoint->getGeometryType() == wkbPoint25D) ) {
WritePoint( szRecord, pointIndex, poPoint->getX(), poPoint->getY() );
} else {
if (bRequireGeom) {
return OGRERR_FAILURE;
}
}
WriteRecord( szRecord, psRTInfo->nRecordLength, m_pszFileCode );
return OGRERR_NONE;
}
featureset_ptr ogr_datasource::features_at_point(coord2d const& pt) const
{
if (!is_bound_) bind();
if (dataset_ && layer_.is_valid())
{
OGRLayer* layer = layer_.layer();
if (indexed_)
{
filter_at_point filter(pt);
return featureset_ptr(new ogr_index_featureset<filter_at_point> (*dataset_,
*layer,
filter,
index_name_,
desc_.get_encoding(),
multiple_geometries_));
}
else
{
OGRPoint point;
point.setX (pt.x);
point.setY (pt.y);
return featureset_ptr(new ogr_featureset (*dataset_,
*layer,
point,
desc_.get_encoding(),
multiple_geometries_));
}
}
return featureset_ptr();
}
osg::Geometry* multiPointToDrawable(OGRMultiPoint* mpoint) const
{
osg::Geometry* geom = new osg::Geometry;
osg::Geometry* pointGeom = new osg::Geometry();
osg::Vec3Array* vertices = new osg::Vec3Array();
vertices->reserve(mpoint->getNumGeometries());
for (int i = 0; i < mpoint->getNumGeometries(); i++ )
{
OGRGeometry* ogrGeom = mpoint->getGeometryRef(i);
OGRwkbGeometryType ogrGeomType = ogrGeom->getGeometryType();
if (wkbPoint != ogrGeomType && wkbPoint25D != ogrGeomType)
continue; // skip
OGRPoint* points = static_cast<OGRPoint*>(ogrGeom);
vertices->push_back(osg::Vec3(points->getX(), points->getY(), points->getZ()));
}
pointGeom->setVertexArray(vertices);
pointGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::POINTS, 0, vertices->size()));
if (pointGeom->getVertexArray())
{
OSG_INFO << "osgOgrFeature::multiPointToDrawable " << geom->getVertexArray()->getNumElements() << " vertexes"<< std::endl;
}
return pointGeom;
}
OGRBoolean OGRPoint::Equals( OGRGeometry * poOther ) const
{
if( poOther== this )
return TRUE;
if( poOther->getGeometryType() != getGeometryType() )
return FALSE;
OGRPoint *poOPoint = dynamic_cast<OGRPoint *>(poOther);
if( poOPoint == NULL )
{
CPLError(CE_Fatal, CPLE_AppDefined,
"dynamic_cast failed. Expected OGRPoint.");
return FALSE;
}
if( flags != poOPoint->flags )
return FALSE;
if( IsEmpty() )
return TRUE;
// Should eventually test the SRS.
if( poOPoint->getX() != getX()
|| poOPoint->getY() != getY()
|| poOPoint->getZ() != getZ() )
return FALSE;
return TRUE;
}
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;
}
static unsigned long HashAirwayIntersectionFeatureFunc(const void* _feature)
{
OGRFeature* feature = (OGRFeature*)_feature;
OGRPoint* point = (OGRPoint*) feature->GetGeometryRef();
unsigned long hash = CPLHashSetHashStr((unsigned char*)feature->GetFieldAsString(0));
const double x = point->getX();
const double y = point->getY();
return hash ^ OGRXPlaneAirwayHashDouble(x) ^ OGRXPlaneAirwayHashDouble(y);
}
ogrfeature(const xyh point):
poFeature(OGRFeature::CreateFeature( poLayer->getLayerDefn() ))
{
poFeature->SetField( "Height", point.value);
OGRPoint pt; // destroy ??
pt.setX( point.row );
pt.setY( point.col );
poFeature->SetGeometry( &pt );
}
OGRGeometry *OGRPoint::clone() const
{
OGRPoint *poNewPoint = new OGRPoint( x, y, z );
poNewPoint->assignSpatialReference( getSpatialReference() );
return poNewPoint;
}
bool GDALSpatialLinking::checkCentroid(OGRGeometry* geo, OGRGeometry * lead_geo)
{
OGRPoint ct;
if (int error = geo->Centroid(&ct) != OGRERR_NONE) {
DM::Logger(DM::Warning) << "error calculationg ct " << error;
return false;
}
return ct.Within(lead_geo);
}
OGRErr GTMWaypointLayer::CreateFeature (OGRFeature *poFeature)
{
FILE* fp = poDS->getOutputFP();
if (fp == NULL)
return CE_Failure;
OGRGeometry *poGeom = poFeature->GetGeometryRef();
if ( poGeom == NULL )
{
CPLError( CE_Failure, CPLE_AppDefined,
"Features without geometry not supported by GTM writer in waypoints layer." );
return OGRERR_FAILURE;
}
if (NULL != poCT)
{
poGeom = poGeom->clone();
poGeom->transform( poCT );
}
switch( poGeom->getGeometryType() )
{
case wkbPoint:
case wkbPoint25D:
{
OGRPoint* point = (OGRPoint*)poGeom;
double lat = point->getY();
double lon = point->getX();
CheckAndFixCoordinatesValidity(lat, lon);
poDS->checkBounds((float)lat, (float)lon);
writeDouble(fp, lat);
writeDouble(fp, lon);
float altitude = 0.0;
if (poGeom->getGeometryType() == wkbPoint25D)
altitude = (float) point->getZ();
WriteFeatureAttributes(poFeature, altitude);
break;
}
default:
{
CPLError( CE_Failure, CPLE_NotSupported,
"Geometry type of `%s' not supported for 'waypoint' element.\n",
OGRGeometryTypeToName(poGeom->getGeometryType()) );
return OGRERR_FAILURE;
}
}
if (NULL != poCT)
delete poGeom;
return OGRERR_NONE;
}
OGRGeometry *OGRPoint::clone() const
{
OGRPoint *poNewPoint = new OGRPoint( x, y, z );
poNewPoint->assignSpatialReference( getSpatialReference() );
poNewPoint->setCoordinateDimension( nCoordDimension );
return poNewPoint;
}
void GeometryPainter::_convertRingToQPolygon(const OGRLinearRing* ring, QPolygonF& qp,
const QMatrix& m)
{
OGRPoint p;
qp.resize(ring->getNumPoints());
for (int i = 0; i < ring->getNumPoints(); i++)
{
ring->getPoint(i, &p);
qp[i] = QPointF(m.map(QPointF(p.getX(), p.getY())) - QPointF(0.5, 0.5));
}
}
void Shape::readRing(OGRLinearRing* ring, ShapePart& shapePart) {
shapePart.points.resize(ring->getNumPoints());
for (int j = 0; j < ring->getNumPoints(); ++j) {
OGRPoint point;
ring->getPoint(j, &point);
shapePart.points[j].x = point.getX();
shapePart.points[j].y = point.getY();
updateBounds(&point);
}
}
void Shape::readLineString(OGRLineString* lineString, ShapeObject& shapeObject) {
shapeObject.parts.resize(1);
shapeObject.parts[0].points.resize(lineString->getNumPoints());
for (int i = 0; i < lineString->getNumPoints(); ++i) {
OGRPoint point;
lineString->getPoint(i, &point);
shapeObject.parts[0].points[i].x = point.getX();
shapeObject.parts[0].points[i].y = point.getY();
updateBounds(&point);
}
}
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;
}
OGRGeometry *OGRPoint::clone() const
{
OGRPoint *poNewPoint = new (std::nothrow) OGRPoint( x, y, z, m );
if( poNewPoint == NULL )
return NULL;
poNewPoint->assignSpatialReference( getSpatialReference() );
poNewPoint->flags = flags;
return poNewPoint;
}
inline Usul::Math::Vec3d convertAndTransform ( const OGRPoint& point, OGRCoordinateTransformation* transform, double verticalOffset )
{
// Declare the point.
Usul::Math::Vec3d p ( point.getX(), point.getY(), point.getZ() + verticalOffset );
// Transform the point.
if ( 0x0 != transform )
{
transform->Transform ( 1, &p[0], &p[1], &p[2] );
}
return p;
}
osg::Geometry* linearRingToDrawable(OGRLinearRing* ring) const
{
osg::Geometry* contourGeom = new osg::Geometry();
osg::Vec3Array* vertices = new osg::Vec3Array();
OGRPoint point;
for(int j = 0; j < ring->getNumPoints(); j++)
{
ring->getPoint(j, &point);
vertices->push_back(osg::Vec3(point.getX(), point.getY(),point.getZ()));
}
contourGeom->setVertexArray(vertices);
contourGeom->addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINE_LOOP, 0, vertices->size()));
return contourGeom;
}
void OGRLinearRing::reverseWindingOrder()
{
int pos = 0;
OGRPoint tempPoint;
for( int i = 0; i < nPointCount / 2; i++ )
{
getPoint( i, &tempPoint );
pos = nPointCount - i - 1;
setPoint( i, getX(pos), getY(pos), getZ(pos) );
setPoint( pos, tempPoint.getX(), tempPoint.getY(), tempPoint.getZ() );
}
}
OGRErr OGRDXFWriterLayer::WriteINSERT( OGRFeature *poFeature )
{
WriteValue( 0, "INSERT" );
WriteCore( poFeature );
WriteValue( 100, "AcDbEntity" );
WriteValue( 100, "AcDbBlockReference" );
WriteValue( 2, poFeature->GetFieldAsString("BlockName") );
/* -------------------------------------------------------------------- */
/* Write location. */
/* -------------------------------------------------------------------- */
OGRPoint *poPoint = (OGRPoint *) poFeature->GetGeometryRef();
WriteValue( 10, poPoint->getX() );
if( !WriteValue( 20, poPoint->getY() ) )
return OGRERR_FAILURE;
if( poPoint->getGeometryType() == wkbPoint25D )
{
if( !WriteValue( 30, poPoint->getZ() ) )
return OGRERR_FAILURE;
}
/* -------------------------------------------------------------------- */
/* Write scaling. */
/* -------------------------------------------------------------------- */
int nScaleCount;
const double *padfScale =
poFeature->GetFieldAsDoubleList( "BlockScale", &nScaleCount );
if( nScaleCount == 3 )
{
WriteValue( 41, padfScale[0] );
WriteValue( 42, padfScale[1] );
WriteValue( 43, padfScale[2] );
}
/* -------------------------------------------------------------------- */
/* Write rotation. */
/* -------------------------------------------------------------------- */
double dfAngle = poFeature->GetFieldAsDouble( "BlockAngle" );
if( dfAngle != 0.0 )
{
WriteValue( 50, dfAngle ); // degrees
}
return OGRERR_NONE;
}
void GeometryPainter::drawLineString(QPainter& pt, const OGRLineString* lineString,
const QMatrix& m)
{
QPolygonF a(lineString->getNumPoints());
OGRPoint point;
for (int j = 0; j < lineString->getNumPoints(); j++)
{
lineString->getPoint(j, &point);
a[j] = QPointF(m.map(QPointF(point.getX(), point.getY())) - QPointF(0.5, 0.5));
}
pt.drawPolyline(a);
}
int OGRPolygon::PointOnSurface( OGRPoint *poPoint ) const
{
if( poPoint == NULL )
return OGRERR_FAILURE;
#ifndef HAVE_GEOS
return OGRERR_FAILURE;
#else
GEOSGeom hThisGeosGeom = NULL;
GEOSGeom hOtherGeosGeom = NULL;
hThisGeosGeom = exportToGEOS();
if( hThisGeosGeom != NULL )
{
hOtherGeosGeom = GEOSPointOnSurface( hThisGeosGeom );
GEOSGeom_destroy( hThisGeosGeom );
if( hOtherGeosGeom == NULL )
return OGRERR_FAILURE;
OGRGeometry *poInsidePointGeom = (OGRGeometry *)
OGRGeometryFactory::createFromGEOS( hOtherGeosGeom );
GEOSGeom_destroy( hOtherGeosGeom );
if (poInsidePointGeom == NULL)
return OGRERR_FAILURE;
if (wkbFlatten(poInsidePointGeom->getGeometryType()) != wkbPoint)
{
delete poInsidePointGeom;
return OGRERR_FAILURE;
}
OGRPoint *poInsidePoint = (OGRPoint *) poInsidePointGeom;
poPoint->setX( poInsidePoint->getX() );
poPoint->setY( poInsidePoint->getY() );
delete poInsidePointGeom;
return OGRERR_NONE;
}
else
{
return OGRERR_FAILURE;
}
#endif /* HAVE_GEOS */
}
void wxGISSimpleCircleSymbol::Draw(const wxGISGeometry &Geometry, int nLevel)
{
if (!Geometry.IsOk() || !m_pDisplay)
return;
OGRwkbGeometryType eGeomType = wkbFlatten(Geometry.GetType());
if (eGeomType != wkbMultiPoint)
return;
OGREnvelope Env;
OGRGeometry *pGeom = Geometry;
OGRMultiPoint* pMPT = (OGRMultiPoint*)pGeom;
OGRPoint* pCenterPt = (OGRPoint*)pMPT->getGeometryRef(0);
OGRPoint* pOriginPt = (OGRPoint*)pMPT->getGeometryRef(1);
double dfRadius = sqrt((pCenterPt->getX() - pOriginPt->getX())*(pCenterPt->getX() - pOriginPt->getX()) + (pCenterPt->getY() - pOriginPt->getY())*(pCenterPt->getY() - pOriginPt->getY()));
Env.MaxX = pCenterPt->getX() + dfRadius;
Env.MinX = pCenterPt->getX() - dfRadius;
Env.MaxY = pCenterPt->getY() + dfRadius;
Env.MinY = pCenterPt->getY() - dfRadius;
if (!m_pDisplay->CanDraw(Env))
return;
wxCriticalSectionLocker lock(m_pDisplay->GetLock());
if (!m_pDisplay->CheckDrawAsPoint(Env, m_pLineSymbol->GetWidth()))
{
if (!m_pDisplay->DrawCircle(pCenterPt->getX(), pCenterPt->getY(), 0, 0, dfRadius))
{
return;
}
if (m_Color.Alpha() > 0)
{
switch (m_eFillRule)
{
case enumGISFillRuleWinding:
m_pDisplay->SetFillRule(CAIRO_FILL_RULE_WINDING);
break;
case enumGISFillRuleOdd:
m_pDisplay->SetFillRule(CAIRO_FILL_RULE_EVEN_ODD);
break;
}
m_pDisplay->SetColor(m_Color);
m_pDisplay->FillPreserve();
}
}
m_pLineSymbol->SetStyleToDisplay();
m_pDisplay->Stroke();
}
void wxGISSimpleMarkerSymbol::Draw(const wxGISGeometry &Geometry, int nLevel)
{
if(!Geometry.IsOk() ||!m_pDisplay)
return;
OGRwkbGeometryType eGeomType = wkbFlatten(Geometry.GetType());
if(eGeomType != wkbPoint && eGeomType != wkbMultiPoint)
return;
OGREnvelope Env = Geometry.GetEnvelope();
if(!m_pDisplay->CanDraw(Env))
return;
OGRGeometry *pGeom = Geometry;
if(eGeomType == wkbMultiPoint)
{
OGRGeometryCollection* pOGRGeometryCollection = (OGRGeometryCollection*)pGeom;
for(int i = 0; i < pOGRGeometryCollection->getNumGeometries(); ++i)
Draw(wxGISGeometry(pOGRGeometryCollection->getGeometryRef(i), false));
return;
}
wxCriticalSectionLocker lock(m_pDisplay->GetLock());
OGRPoint* pPoint = (OGRPoint*)pGeom;
if(m_dfOutlineSize)
{
if(!m_pDisplay->DrawPointFast(pPoint->getX(), pPoint->getY()))
{
return;
}
m_pDisplay->SetColor(m_OutlineColor);
m_pDisplay->SetLineWidth( m_dfSize + m_dfOutlineSize + m_dfOutlineSize);
m_pDisplay->Stroke();
}
if(!m_pDisplay->DrawPointFast(pPoint->getX(), pPoint->getY()))
{
return;
}
m_pDisplay->SetColor(m_Color);
m_pDisplay->SetLineWidth( m_dfSize );
m_pDisplay->SetLineCap(CAIRO_LINE_CAP_ROUND);
m_pDisplay->Stroke();
}
void wxSimpleMarkerSymbol::Draw(OGRGeometry* pGeometry, IDisplay* pwxGISDisplay)
{
IDisplayTransformation* pDisplayTransformation = pwxGISDisplay->GetDisplayTransformation();
OGRwkbGeometryType type = wkbFlatten(pGeometry->getGeometryType());
switch(type)
{
case wkbPoint:
{
OGRPoint *pPoint = (OGRPoint*)pGeometry;
OGRRawPoint Point;
Point.x = pPoint->getX();
Point.y = pPoint->getY();
wxPoint* pPoints = pDisplayTransformation->TransformCoordWorld2DC(&Point, 1);
pwxGISDisplay->SetBrush(m_Brush);
pwxGISDisplay->SetPen(m_Pen);
pwxGISDisplay->DrawCircle(pPoints[0].x, pPoints[0].y, m_Size);
delete[](pPoints);
}
break;
case wkbPolygon:
case wkbMultiPolygon:
case wkbLineString:
case wkbLinearRing:
case wkbMultiPoint:
case wkbMultiLineString:
case wkbGeometryCollection:
{
OGREnvelope sEnvelope;
pGeometry->getEnvelope(&sEnvelope);
//
//
OGRRawPoint Point;
Point.x = sEnvelope.MinX;
Point.y = sEnvelope.MinY;
wxPoint* pPoints = pDisplayTransformation->TransformCoordWorld2DC(&Point, 1);
pwxGISDisplay->SetBrush(m_Brush);
pwxGISDisplay->SetPen(m_Pen);
pwxGISDisplay->DrawPoint(pPoints[0].x, pPoints[0].y);
delete[](pPoints);
}
break;
case wkbUnknown:
case wkbNone:
default:
break;
}
}
void MSN_Helper::LoadSamples(Config &config, Matrix &mat)
{
if(config.bShapefile)
{
OGRRegisterAll();
string pLayerName = StringGetFileName(config.sSamples);
OGRDataSource* poDS = OGRSFDriverRegistrar::Open(config.sSamples.c_str(),FALSE);
OGRLayer* poLayer = poDS->GetLayerByName(pLayerName.c_str());
config.nSamples = poLayer->GetFeatureCount();
mat.Resize(config.nSamples, 4);
OGRPoint *poPoint;
OGRFeature * pFeature =poLayer->GetNextFeature();
for(unsigned long i=1; i<=config.nSamples; i++)
{
//样本取值字段名为value，double型
poPoint = (OGRPoint *)pFeature->GetGeometryRef();
mat[i][1] = poPoint->getX();
mat[i][2] = poPoint->getY();
mat[i][3] = pFeature->GetFieldAsInteger("stratum");
mat[i][4] = pFeature->GetFieldAsDouble("value");
pFeature = poLayer->GetNextFeature();
}
OGRDataSource::DestroyDataSource( poDS );
}
else
{
double x, y, v, stratum;
string sline;
ifstream infile(config.sSamples.c_str());
infile >> config.nSamples;
mat.Resize(config.nSamples, 4);
for(unsigned long i=1; i<=config.nSamples; i++)
{
infile >> x >> y >> stratum >> v;
mat[i][1] = x;
mat[i][2] = y;
mat[i][3] = stratum;
mat[i][4] = v;
}
infile.close();
}
}
void GDALAddComponentViewContainer::run()
{
int counter = 0;
for (int i = 0; i < elements; i++) {
OGRFeature * f = this->components.createFeature();
f->SetField("persons", "that is me");
OGRPoint pt;
pt.setX( i );
pt.setY( i );
f->SetGeometry(&pt);
if (counter == 100000) {
counter = 0;
}
counter++;
}
}
featureset_ptr ogr_datasource::features_at_point(coord2d const& pt, double tol) const
{
if (!is_bound_) bind();
#ifdef MAPNIK_STATS
mapnik::progress_timer __stats__(std::clog, "ogr_datasource::features_at_point");
#endif
if (dataset_ && layer_.is_valid())
{
std::vector<attribute_descriptor> const& desc_ar = desc_.get_descriptors();
// feature context (schema)
mapnik::context_ptr ctx = boost::make_shared<mapnik::context_type>();
std::vector<attribute_descriptor>::const_iterator itr = desc_ar.begin();
std::vector<attribute_descriptor>::const_iterator end = desc_ar.end();
for (; itr!=end; ++itr) ctx->push(itr->get_name());
OGRLayer* layer = layer_.layer();
if (indexed_)
{
filter_at_point filter(pt);
return featureset_ptr(new ogr_index_featureset<filter_at_point> (ctx,
*layer,
filter,
index_name_,
desc_.get_encoding()));
}
else
{
OGRPoint point;
point.setX (pt.x);
point.setY (pt.y);
return featureset_ptr(new ogr_featureset (ctx,
*layer,
point,
desc_.get_encoding()));
}
}
return featureset_ptr();
}
