OGRBoolean OGRLineString::Equal( OGRGeometry * poOther )
{
OGRLineString *poOLine = (OGRLineString *) poOther;
if( poOther == this )
return TRUE;
if( poOther->getGeometryType() != getGeometryType() )
return FALSE;
// we should eventually test the SRS.
if( getNumPoints() != poOLine->getNumPoints() )
return FALSE;
for( int iPoint = 1; iPoint < getNumPoints(); iPoint++ )
{
if( getX(iPoint) != poOLine->getX(iPoint)
|| getY(iPoint) != poOLine->getY(iPoint)
|| getZ(iPoint) != poOLine->getZ(iPoint) )
return FALSE;
}
return TRUE;
}
OGRGeometry *
NTFStrokeArcToOGRGeometry_Angles( double dfCenterX, double dfCenterY,
double dfRadius,
double dfStartAngle, double dfEndAngle,
int nVertexCount )
{
OGRLineString *poLine = new OGRLineString;
nVertexCount = std::max(2, nVertexCount);
const double dfSlice = (dfEndAngle-dfStartAngle)/(nVertexCount-1);
poLine->setNumPoints( nVertexCount );
for( int iPoint = 0; iPoint < nVertexCount; iPoint++ )
{
const double dfAngle = (dfStartAngle + iPoint * dfSlice) * M_PI / 180.0;
const double dfArcX = dfCenterX + cos(dfAngle) * dfRadius;
const double dfArcY = dfCenterY + sin(dfAngle) * dfRadius;
poLine->setPoint( iPoint, dfArcX, dfArcY );
}
return poLine;
}
double OGR_G_GetZ( OGRGeometryH hGeom, int i )
{
VALIDATE_POINTER1( hGeom, "OGR_G_GetZ", 0 );
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbPoint:
{
if( i == 0 )
return ((OGRPoint *) hGeom)->getZ();
else
{
CPLError(CE_Failure, CPLE_NotSupported, "Only i == 0 is supported");
return 0.0;
}
}
case wkbLineString:
{
OGRLineString* poLS = (OGRLineString *) hGeom;
if (i < 0 || i >= poLS->getNumPoints())
{
CPLError(CE_Failure, CPLE_NotSupported, "Index out of bounds");
return 0.0;
}
return poLS->getZ( i );
}
default:
CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
return 0.0;
}
}
//! @cond Doxygen_Suppress
OGRLineString* OGRCompoundCurve::CastToLineString( OGRCompoundCurve* poCC )
{
for( int i = 0; i < poCC->oCC.nCurveCount; i++ )
{
poCC->oCC.papoCurves[i] =
OGRCurve::CastToLineString(poCC->oCC.papoCurves[i]);
if( poCC->oCC.papoCurves[i] == NULL )
{
delete poCC;
return NULL;
}
}
if( poCC->oCC.nCurveCount == 1 )
{
OGRLineString* poLS = (OGRLineString*) poCC->oCC.papoCurves[0];
poLS->assignSpatialReference(poCC->getSpatialReference());
poCC->oCC.papoCurves[0] = NULL;
delete poCC;
return poLS;
}
OGRLineString* poLS = poCC->CurveToLineInternal(0, NULL, FALSE);
delete poCC;
return poLS;
}
int OGR_G_GetPoints( OGRGeometryH hGeom,
void* pabyX, int nXStride,
void* pabyY, int nYStride,
void* pabyZ, int nZStride)
{
VALIDATE_POINTER1( hGeom, "OGR_G_GetPoints", 0 );
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbPoint:
{
if (pabyX) *((double*)pabyX) = ((OGRPoint *)hGeom)->getX();
if (pabyY) *((double*)pabyY) = ((OGRPoint *)hGeom)->getY();
if (pabyZ) *((double*)pabyZ) = ((OGRPoint *)hGeom)->getZ();
return 1;
}
break;
case wkbLineString:
{
OGRLineString* poLS = (OGRLineString *) hGeom;
poLS->getPoints(pabyX, nXStride, pabyY, nYStride, pabyZ, nZStride);
return poLS->getNumPoints();
}
break;
default:
CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
return 0;
break;
}
}
double OGRCircularString::get_Area() const
{
if( IsEmpty() || !get_IsClosed() )
return 0;
double cx = 0.0;
double cy = 0.0;
double square_R = 0.0;
if( IsFullCircle(cx, cy, square_R) )
{
return M_PI * square_R;
}
// Optimization for convex rings.
if( IsConvex() )
{
// Compute area of shape without the circular segments.
double dfArea = get_LinearArea();
// Add the area of the spherical segments.
dfArea += get_AreaOfCurveSegments();
return dfArea;
}
OGRLineString* poLS = CurveToLine();
const double dfArea = poLS->get_Area();
delete poLS;
return dfArea;
}
void GDALCalculateLength::run()
{
OGRFeature * f;
vc.resetReading();
while( f = vc.getNextFeature() ) {
OGRLineString* geo = (OGRLineString*)f->GetGeometryRef();
f->SetField("length", geo->get_Length());
}
}
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;
}
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;
}
OGRLineString* make()
{
OGRLineString* poLineString = new OGRLineString();
poLineString->addPoint(1.0, 2.0, 3.0);
poLineString->addPoint(1.1, 2.1, 3.1);
poLineString->addPoint(1.2, 2.2, 3.2);
return poLineString;
}
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_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;
}
void wxGISRubberEnvelope::OnMouseUp(wxMouseEvent& event)
{
IDisplayTransformation* pDT = m_pCachedDisplay->GetDisplayTransformation();
wxPoint Points[2];
Points[0] = wxPoint(m_StartX, m_StartY);
Points[1] = wxPoint(event.GetX(), event.GetY());
OGRRawPoint* pOGRPoints = pDT->TransformCoordDC2World(Points, 2);
OGRLineString* pLine = new OGRLineString();
pLine->setPoints(2, pOGRPoints);
m_pRetGeom = static_cast<OGRGeometry*>(pLine);
delete [] pOGRPoints;
OnUnlock();
}
/*!
\brief Load geometry (linestring SBP layer)
\todo Really needed?
\return TRUE on success or FALSE on failure
*/
bool VFKFeature::LoadGeometryLineStringSBP()
{
int id, idxId, idxBp_Id, idxPCB, ipcb;
VFKDataBlock *poDataBlockPoints;
VFKFeature *poPoint, *poLine;
OGRLineString OGRLine;
poDataBlockPoints = (VFKDataBlock *) m_poDataBlock->GetReader()->GetDataBlock("SOBR");
if (!poDataBlockPoints)
return FALSE;
idxId = poDataBlockPoints->GetPropertyIndex("ID");
idxBp_Id = m_poDataBlock->GetPropertyIndex("BP_ID");
idxPCB = m_poDataBlock->GetPropertyIndex("PORADOVE_CISLO_BODU");
if (idxId < 0 || idxBp_Id < 0 || idxPCB < 0)
return false;
poLine = this;
while (TRUE)
{
id = poLine->GetProperty(idxBp_Id)->GetValueI();
ipcb = poLine->GetProperty(idxPCB)->GetValueI();
if (OGRLine.getNumPoints() > 0 && ipcb == 1)
{
m_poDataBlock->GetPreviousFeature(); /* push back */
break;
}
poPoint = poDataBlockPoints->GetFeature(idxId, id);
if (!poPoint)
{
continue;
}
OGRPoint *pt = (OGRPoint *) poPoint->GetGeometry();
OGRLine.addPoint(pt);
poLine = (VFKFeature *) m_poDataBlock->GetNextFeature();
if (!poLine)
break;
};
OGRLine.setCoordinateDimension(2); /* force 2D */
SetGeometry(&OGRLine);
/* reset reading */
poDataBlockPoints->ResetReading();
return TRUE;
}
bool OGRGRASSLayer::SetSpatialMatch()
{
CPLDebug ( "GRASS", "SetSpatialMatch" );
if ( !paSpatialMatch )
{
paSpatialMatch = (char *) CPLMalloc ( nTotalCount );
}
memset ( paSpatialMatch, 0x0, nTotalCount );
OGRGeometry *geom;
OGRLineString *lstring = new OGRLineString();
lstring->setNumPoints ( 5 );
geom = lstring;
for ( int i = 0; i < nTotalCount; i++ ) {
int cidx = paFeatureIndex[i];
int cat, type, id;
Vect_cidx_get_cat_by_index ( poMap, iLayerIndex, cidx, &cat, &type, &id );
BOUND_BOX box;
switch ( type )
{
case GV_POINT:
case GV_LINE:
case GV_BOUNDARY:
Vect_get_line_box ( poMap, id, &box );
break;
case GV_AREA:
Vect_get_area_box ( poMap, id, &box );
break;
}
lstring->setPoint( 0, box.W, box.N, 0. );
lstring->setPoint( 1, box.W, box.S, 0. );
lstring->setPoint( 2, box.E, box.S, 0. );
lstring->setPoint( 3, box.E, box.N, 0. );
lstring->setPoint( 4, box.W, box.N, 0. );
if ( FilterGeometry(geom) ) {
CPLDebug ( "GRASS", "Feature %d in filter", i );
paSpatialMatch[i] = 1;
}
}
delete lstring;
return true;
}
OGRGeometry *OGRLineString::clone()
{
OGRLineString *poNewLineString;
poNewLineString = new OGRLineString();
poNewLineString->assignSpatialReference( getSpatialReference() );
poNewLineString->setPoints( nPointCount, paoPoints, padfZ );
// notdef: not 3D
return poNewLineString;
}
void OGR_G_GetPoint( OGRGeometryH hGeom, int i,
double *pdfX, double *pdfY, double *pdfZ )
{
VALIDATE_POINTER0( hGeom, "OGR_G_GetPoint" );
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbPoint:
{
if( i == 0 )
{
*pdfX = ((OGRPoint *)hGeom)->getX();
*pdfY = ((OGRPoint *)hGeom)->getY();
if( pdfZ != NULL )
*pdfZ = ((OGRPoint *)hGeom)->getZ();
}
else
{
CPLError(CE_Failure, CPLE_NotSupported, "Only i == 0 is supported");
}
}
break;
case wkbLineString:
case wkbCircularString:
{
OGRLineString* poLS = (OGRLineString *) hGeom;
if (i < 0 || i >= poLS->getNumPoints())
{
CPLError(CE_Failure, CPLE_NotSupported, "Index out of bounds");
*pdfX = *pdfY = 0;
if( pdfZ != NULL )
*pdfZ = 0;
}
else
{
*pdfX = poLS->getX( i );
*pdfY = poLS->getY( i );
if( pdfZ != NULL )
*pdfZ = poLS->getZ( i );
}
}
break;
default:
CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
break;
}
}
void wxSimpleFillSymbol::DrawPolygon(OGRPolygon* pPoly, IDisplay* pwxGISDisplay)
{
IDisplayTransformation* pDisplayTransformation = pwxGISDisplay->GetDisplayTransformation();
int NumInteriorRings = pPoly->getNumInteriorRings();
OGRLinearRing *pRing = pPoly->getExteriorRing();
OGRLineString *pLStr = (OGRLineString*)pRing;
int nPointCount = pLStr->getNumPoints();
if(nPointCount > 2)
{
if(NumInteriorRings == 0)
{
OGRRawPoint* pOGRRawPoints = new OGRRawPoint[nPointCount];
pLStr->getPoints(pOGRRawPoints);
wxPoint* pPoints = pDisplayTransformation->TransformCoordWorld2DC(pOGRRawPoints, nPointCount);
delete[](pOGRRawPoints);
pwxGISDisplay->DrawPolygon(nPointCount, pPoints);
delete[](pPoints);
}
else
{
int *nN = new int[NumInteriorRings + 1];
nN[0] = nPointCount;
int jPoint(nPointCount);
for(int iPart = 0; iPart < NumInteriorRings; iPart++)
{
pRing = pPoly->getInteriorRing(iPart);
OGRLineString *pLStrInt = (OGRLineString*)pRing;
nPointCount = pLStrInt->getNumPoints();
jPoint += (nN[iPart + 1] = nPointCount > 2 ? nPointCount/* + 1*/ : 0);
}
wxPoint *pFullPoints = new wxPoint[jPoint];
OGRRawPoint* pOGRRawPoints = new OGRRawPoint[nN[0]];
pLStr->getPoints(pOGRRawPoints);
int counter(0);
pDisplayTransformation->TransformCoordWorld2DC(pOGRRawPoints, nN[0], &pFullPoints[counter]);
delete[](pOGRRawPoints);
counter += nN[0];
for(int iPart = 0; iPart < NumInteriorRings; iPart++)
{
pRing = pPoly->getInteriorRing(iPart);
OGRLineString *pLStrInt = (OGRLineString*)pRing;
pOGRRawPoints = new OGRRawPoint[nN[iPart + 1]];
pLStrInt->getPoints(pOGRRawPoints);
pDisplayTransformation->TransformCoordWorld2DC(pOGRRawPoints, nN[iPart + 1], &pFullPoints[counter]);
delete[](pOGRRawPoints);
counter += nN[iPart + 1];
}
pwxGISDisplay->DrawPolyPolygon(NumInteriorRings + 1, nN, pFullPoints, 0, 0, wxODDEVEN_RULE);
delete[](pFullPoints);
delete[](nN);
}
}
}
void CPL_DLL OGR_G_SetPoints( OGRGeometryH hGeom, int nPointsIn,
void* pabyX, int nXStride,
void* pabyY, int nYStride,
void* pabyZ, int nZStride )
{
VALIDATE_POINTER0( hGeom, "OGR_G_SetPoints" );
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbPoint:
{
((OGRPoint *) hGeom)->setX( pabyX ? *( (double *)pabyX ) : 0.0 );
((OGRPoint *) hGeom)->setY( pabyY ? *( (double *)pabyY ) : 0.0 );
((OGRPoint *) hGeom)->setZ( pabyZ ? *( (double *)pabyZ ) : 0.0 );
break;
}
case wkbLineString:
case wkbCircularString:
{
OGRLineString* poLine = (OGRLineString *) hGeom;
if( nXStride == 0 && nYStride == 0 && nZStride == 0 )
{
poLine->setPoints( nPointsIn, (double *)pabyX, (double *)pabyY, (double *)pabyZ );
}
else
{
double x, y, z;
x = y = z = 0;
poLine->setNumPoints( nPointsIn );
for (int i = 0; i < nPointsIn; ++i)
{
if( pabyX ) x = *(double*)((char*)pabyX + i * nXStride);
if( pabyY ) y = *(double*)((char*)pabyY + i * nYStride);
if( pabyZ ) z = *(double*)((char*)pabyZ + i * nZStride);
poLine->setPoint( i, x, y, z );
}
}
break;
}
default:
CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
break;
}
}
void OGRSOSIDataSource::buildOGRLineString(int nNumCoo, long iSerial) {
if (papoBuiltGeometries[iSerial] != NULL) {
return;
}
OGRLineString *poLS = new OGRLineString();
poLS->setNumPoints(nNumCoo);
int i;
double dfEast = 0, dfNorth = 0;
for (i=1; i<=nNumCoo; i++) {
LC_GetTK(i, &dfEast, &dfNorth);
poLS->setPoint(i-1, dfEast, dfNorth);
}
papoBuiltGeometries[iSerial] = poLS;
}
OGRPoint GetTangetPoint(OGRLineString &line, double dfDist)
{
double dfLength = line.get_Length();
OGRPoint ptBeg, ptEnd;
line.StartPoint(&ptBeg);
line.EndPoint(&ptEnd);
double dx = ptEnd.getX() - ptBeg.getX();
double dy = ptEnd.getY() - ptBeg.getY();
double ux = dfDist * dx / dfLength;
double uy = dfDist * dy / dfLength;
OGRPoint resultPoint(ptEnd.getX() - uy, ptEnd.getY() + ux);
return resultPoint;
}
inline Minerva::Common::Coordinates::RefPtr convertAndTransform ( const OGRLineString& line, OGRCoordinateTransformation* transform, double verticalOffset )
{
const int numPoints ( line.getNumPoints() );
Minerva::Common::Coordinates::RefPtr coordinates ( new Minerva::Common::Coordinates );
coordinates->reserve ( numPoints );
OGRPoint point;
for ( int i = 0; i < numPoints; ++i )
{
line.getPoint ( i, &point );
Minerva::Common::Coordinates::value_type v ( Helper::convertAndTransform ( point, transform, verticalOffset ) );
coordinates->addPoint ( v[0], v[1], v[2] );
}
return coordinates;
}
int OGR_G_GetPointCount( OGRGeometryH hGeom )
{
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbPoint:
return 1;
case wkbLineString:
{
OGRLineString *poLine = (OGRLineString *) hGeom;
return poLine->getNumPoints();
}
default:
return 0;
}
}
void OGR_G_SetPointCount( OGRGeometryH hGeom, int nNewPointCount )
{
VALIDATE_POINTER0( hGeom, "OGR_G_SetPointCount" );
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbLineString:
{
OGRLineString *poLine = (OGRLineString *) hGeom;
poLine->setNumPoints( nNewPointCount );
break;
}
default:
CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
break;
}
}
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;
}
OGRLineString* OGRCompoundCurve::CurveToLineInternal(double dfMaxAngleStepSizeDegrees,
const char* const* papszOptions,
int bIsLinearRing) const
{
OGRLineString* poLine;
if( bIsLinearRing )
poLine = new OGRLinearRing();
else
poLine = new OGRLineString();
poLine->assignSpatialReference(getSpatialReference());
for( int iGeom = 0; iGeom < oCC.nCurveCount; iGeom++ )
{
OGRLineString* poSubLS = oCC.papoCurves[iGeom]->CurveToLine(dfMaxAngleStepSizeDegrees,
papszOptions);
poLine->addSubLineString(poSubLS, (iGeom == 0) ? 0 : 1);
delete poSubLS;
}
return poLine;
}
OGRLineString* OGRCircularString::CurveToLine(
double dfMaxAngleStepSizeDegrees, const char* const* papszOptions ) const
{
OGRLineString* poLine = new OGRLineString();
poLine->assignSpatialReference(getSpatialReference());
const bool bHasZ = getCoordinateDimension() == 3;
for( int i = 0; i < nPointCount - 2; i += 2 )
{
OGRLineString* poArc = OGRGeometryFactory::curveToLineString(
paoPoints[i].x, paoPoints[i].y, padfZ ? padfZ[i] : 0.0,
paoPoints[i+1].x, paoPoints[i+1].y, padfZ ? padfZ[i+1] : 0.0,
paoPoints[i+2].x, paoPoints[i+2].y, padfZ ? padfZ[i+2] : 0.0,
bHasZ,
dfMaxAngleStepSizeDegrees,
papszOptions);
poLine->addSubLineString(poArc, (i == 0) ? 0 : 1);
delete poArc;
}
return poLine;
}
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;
}
OGRLineString* OGRMSSQLGeometryParser::ReadLineString(int iShape)
{
int iFigure, iPoint, iNextPoint, i;
iFigure = FigureOffset(iShape);
OGRLineString* poLineString = new OGRLineString();
iPoint = PointOffset(iFigure);
iNextPoint = NextPointOffset(iFigure);
poLineString->setNumPoints(iNextPoint - iPoint);
i = 0;
while (iPoint < iNextPoint)
{
if (nColType == MSSQLCOLTYPE_GEOGRAPHY)
{
if ( chProps & SP_HASZVALUES )
poLineString->setPoint(i, ReadY(iPoint), ReadX(iPoint), ReadZ(iPoint) );
else
poLineString->setPoint(i, ReadY(iPoint), ReadX(iPoint) );
}
else
{
if ( chProps & SP_HASZVALUES )
poLineString->setPoint(i, ReadX(iPoint), ReadY(iPoint), ReadZ(iPoint) );
else
poLineString->setPoint(i, ReadX(iPoint), ReadY(iPoint) );
}
++iPoint;
++i;
}
return poLineString;
}
int OGR_G_GetPointCount( OGRGeometryH hGeom )
{
VALIDATE_POINTER1( hGeom, "OGR_G_GetPointCount", 0 );
switch( wkbFlatten(((OGRGeometry *) hGeom)->getGeometryType()) )
{
case wkbPoint:
return 1;
case wkbLineString:
{
OGRLineString *poLine = (OGRLineString *) hGeom;
return poLine->getNumPoints();
}
default:
// autotest/pymod/ogrtest.py calls this method on any geometry. So keep silent
//CPLError(CE_Failure, CPLE_NotSupported, "Incompatible geometry for operation");
return 0;
}
}
