/******************************************************************************
* $Id: ogr_geometry.h 33631 2016-03-04 06:28:09Z goatbar $
*
* Project: OpenGIS Simple Features Reference Implementation
* Purpose: Classes for manipulating simple features that is not specific
* to a particular interface technology.
* Author: Frank Warmerdam, warmerdam@pobox.com
*
******************************************************************************
* Copyright (c) 1999, Frank Warmerdam
* Copyright (c) 2008-2014, Even Rouault <even dot rouault at mines-paris dot org>
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
****************************************************************************/
#ifndef OGR_GEOMETRY_H_INCLUDED
#define OGR_GEOMETRY_H_INCLUDED
#include "ogr_core.h"
#include "ogr_spatialref.h"
/**
* \file ogr_geometry.h
*
* Simple feature geometry classes.
*/
/**
* Simple container for a position.
*/
class OGRRawPoint
{
public:
OGRRawPoint()
{
x = y = 0.0;
}
OGRRawPoint(double xIn, double yIn) : x(xIn), y(yIn) {}
double x;
double y;
};
typedef struct GEOSGeom_t *GEOSGeom;
typedef struct GEOSContextHandle_HS *GEOSContextHandle_t;
class OGRPoint;
class OGRCurve;
class OGRCompoundCurve;
class OGRLinearRing;
class OGRLineString;
class OGRSurface;
class OGRCurvePolygon;
class OGRPolygon;
class OGRMultiSurface;
class OGRMultiPolygon;
class OGRMultiCurve;
class OGRMultiLineString;
typedef OGRLineString* (*OGRCurveCasterToLineString)(OGRCurve*);
typedef OGRLinearRing* (*OGRCurveCasterToLinearRing)(OGRCurve*);
typedef OGRPolygon* (*OGRSurfaceCasterToPolygon)(OGRSurface*);
typedef OGRCurvePolygon* (*OGRSurfaceCasterToCurvePolygon)(OGRSurface*);
/************************************************************************/
/* OGRGeometry */
/************************************************************************/
/**
* Abstract base class for all geometry classes.
*
* Some spatial analysis methods require that OGR is built on the GEOS library
* to work properly. The precise meaning of methods that describe spatial relationships
* between geometries is described in the SFCOM, or other simple features interface
* specifications, like "OpenGIS® Implementation Specification for
* Geographic information - Simple feature access - Part 1: Common architecture"
* (<a href="http://www.opengeospatial.org/standards/sfa">OGC 06-103r4</a>)
*
* In GDAL 2.0, the hierarchy of classes has been extended with
* <a href="https://portal.opengeospatial.org/files/?artifact_id=32024">
* (working draft) ISO SQL/MM Part 3 (ISO/IEC 13249-3)</a> curve geometries :
* CIRCULARSTRING (OGRCircularString), COMPOUNDCURVE (OGRCompoundCurve),
* CURVEPOLYGON (OGRCurvePolygon), MULTICURVE (OGRMultiCurve) and MULTISURFACE (OGRMultiSurface).
*
*/
class CPL_DLL OGRGeometry
{
private:
OGRSpatialReference * poSRS; // may be NULL
protected:
friend class OGRCurveCollection;
unsigned int flags;
OGRErr importPreambuleFromWkt( char ** ppszInput,
int* pbHasZ, int* pbHasM,
bool* pbIsEmpty );
OGRErr importCurveCollectionFromWkt( char ** ppszInput,
int bAllowEmptyComponent,
int bAllowLineString,
int bAllowCurve,
int bAllowCompoundCurve,
OGRErr (*pfnAddCurveDirectly)(OGRGeometry* poSelf, OGRCurve* poCurve) );
OGRErr importPreambuleFromWkb( unsigned char * pabyData,
int nSize,
OGRwkbByteOrder& eByteOrder,
OGRwkbVariant eWkbVariant );
OGRErr importPreambuleOfCollectionFromWkb(
unsigned char * pabyData,
int& nSize,
int& nDataOffset,
OGRwkbByteOrder& eByteOrder,
int nMinSubGeomSize,
int& nGeomCount,
OGRwkbVariant eWkbVariant );
OGRErr PointOnSurfaceInternal( OGRPoint * poPoint ) const;
public:
/************************************************************************/
/* Bit flags for OGRGeometry */
/* The OGR_G_NOT_EMPTY_POINT is used *only* for points. */
/* Do not use these outside of the core. */
/* Use Is3D, IsMeasured, set3D, and setMeasured instead */
/************************************************************************/
static const unsigned int OGR_G_NOT_EMPTY_POINT = 0x1;
static const unsigned int OGR_G_3D = 0x2;
static const unsigned int OGR_G_MEASURED = 0x4;
OGRGeometry();
OGRGeometry( const OGRGeometry& other );
virtual ~OGRGeometry();
OGRGeometry& operator=( const OGRGeometry& other );
// standard IGeometry
virtual int getDimension() const = 0;
virtual int getCoordinateDimension() const;
int CoordinateDimension() const;
virtual OGRBoolean IsEmpty() const;
virtual OGRBoolean IsValid() const;
virtual OGRBoolean IsSimple() const;
OGRBoolean Is3D() const { return flags & OGR_G_3D; }
OGRBoolean IsMeasured() const { return flags & OGR_G_MEASURED; }
virtual OGRBoolean IsRing() const;
virtual void empty() = 0;
virtual OGRGeometry *clone() const CPL_WARN_UNUSED_RESULT = 0;
virtual void getEnvelope( OGREnvelope * psEnvelope ) const = 0;
virtual void getEnvelope( OGREnvelope3D * psEnvelope ) const = 0;
// IWks Interface
virtual int WkbSize() const = 0;
virtual OGRErr importFromWkb( unsigned char *, int=-1, OGRwkbVariant=wkbVariantOldOgc )=0;
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const = 0;
virtual OGRErr importFromWkt( char ** ppszInput ) = 0;
virtual OGRErr exportToWkt( char ** ppszDstText, OGRwkbVariant=wkbVariantOldOgc ) const = 0;
// non-standard
virtual OGRwkbGeometryType getGeometryType() const = 0;
OGRwkbGeometryType getIsoGeometryType() const;
virtual const char *getGeometryName() const = 0;
virtual void dumpReadable( FILE *, const char * = NULL, char** papszOptions = NULL ) const;
virtual void flattenTo2D() = 0;
virtual char * exportToGML( const char* const * papszOptions = NULL ) const;
virtual char * exportToKML() const;
virtual char * exportToJson() const;
static GEOSContextHandle_t createGEOSContext();
static void freeGEOSContext(GEOSContextHandle_t hGEOSCtxt);
virtual GEOSGeom exportToGEOS(GEOSContextHandle_t hGEOSCtxt) const CPL_WARN_UNUSED_RESULT;
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
virtual OGRGeometry* getCurveGeometry(const char* const* papszOptions = NULL) const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry* getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const CPL_WARN_UNUSED_RESULT;
virtual void closeRings();
virtual void setCoordinateDimension( int nDimension );
virtual void set3D( OGRBoolean bIs3D );
virtual void setMeasured( OGRBoolean bIsMeasured );
void assignSpatialReference( OGRSpatialReference * poSR );
OGRSpatialReference *getSpatialReference( void ) const { return poSRS; }
virtual OGRErr transform( OGRCoordinateTransformation *poCT ) = 0;
OGRErr transformTo( OGRSpatialReference *poSR );
virtual void segmentize(double dfMaxLength);
// ISpatialRelation
virtual OGRBoolean Intersects( const OGRGeometry * ) const;
virtual OGRBoolean Equals( OGRGeometry * ) const = 0;
virtual OGRBoolean Disjoint( const OGRGeometry * ) const;
virtual OGRBoolean Touches( const OGRGeometry * ) const;
virtual OGRBoolean Crosses( const OGRGeometry * ) const;
virtual OGRBoolean Within( const OGRGeometry * ) const;
virtual OGRBoolean Contains( const OGRGeometry * ) const;
virtual OGRBoolean Overlaps( const OGRGeometry * ) const;
// virtual OGRBoolean Relate( const OGRGeometry *, const char * ) const;
// virtual OGRGeometry *LocateAlong( double mValue ) const;
// virtual OGRGeometry *LocateBetween( double mStart, double mEnd ) const;
virtual OGRGeometry *Boundary() const CPL_WARN_UNUSED_RESULT;
virtual double Distance( const OGRGeometry * ) const ;
virtual OGRGeometry *ConvexHull() const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry *Buffer( double dfDist, int nQuadSegs = 30 ) const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry *Intersection( const OGRGeometry *) const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry *Union( const OGRGeometry * ) const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry *UnionCascaded() const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry *Difference( const OGRGeometry * ) const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry *SymDifference( const OGRGeometry * ) const CPL_WARN_UNUSED_RESULT;
virtual OGRErr Centroid( OGRPoint * poPoint ) const;
virtual OGRGeometry *Simplify(double dTolerance) const CPL_WARN_UNUSED_RESULT;
OGRGeometry *SimplifyPreserveTopology(double dTolerance) const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry *DelaunayTriangulation(double dfTolerance, int bOnlyEdges) const CPL_WARN_UNUSED_RESULT;
virtual OGRGeometry *Polygonize() const CPL_WARN_UNUSED_RESULT;
// backward compatibility to non-standard method names.
OGRBoolean Intersect( OGRGeometry * ) const CPL_WARN_DEPRECATED("Non standard method. Use Intersects() instead");
OGRBoolean Equal( OGRGeometry * ) const CPL_WARN_DEPRECATED("Non standard method. Use Equals() instead");
OGRGeometry *SymmetricDifference( const OGRGeometry * ) const CPL_WARN_DEPRECATED("Non standard method. Use SymDifference() instead");
OGRGeometry *getBoundary() const CPL_WARN_DEPRECATED("Non standard method. Use Boundary() instead");
// Special HACK for DB2 7.2 support
static int bGenerate_DB2_V72_BYTE_ORDER;
virtual void swapXY();
static OGRGeometry* CastToIdentity(OGRGeometry* poGeom) { return poGeom; }
static OGRGeometry* CastToError(OGRGeometry* poGeom);
};
/************************************************************************/
/* OGRPoint */
/************************************************************************/
/**
* Point class.
*
* Implements SFCOM IPoint methods.
*/
class CPL_DLL OGRPoint : public OGRGeometry
{
double x;
double y;
double z;
double m;
public:
OGRPoint();
OGRPoint( double x, double y );
OGRPoint( double x, double y, double z );
OGRPoint( double x, double y, double z, double m );
OGRPoint( const OGRPoint& other );
virtual ~OGRPoint();
OGRPoint& operator=( const OGRPoint& other );
// IWks Interface
virtual int WkbSize() const;
virtual OGRErr importFromWkb( unsigned char *, int=-1, OGRwkbVariant=wkbVariantOldOgc );
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char ** ppszDstText, OGRwkbVariant=wkbVariantOldOgc ) const;
// IGeometry
virtual int getDimension() const;
virtual OGRGeometry *clone() const;
virtual void empty();
virtual void getEnvelope( OGREnvelope * psEnvelope ) const;
virtual void getEnvelope( OGREnvelope3D * psEnvelope ) const;
virtual OGRBoolean IsEmpty() const { return !(flags & OGR_G_NOT_EMPTY_POINT); }
// IPoint
double getX() const { return x; }
double getY() const { return y; }
double getZ() const { return z; }
double getM() const { return m; }
// Non standard
virtual void setCoordinateDimension( int nDimension );
void setX( double xIn ) { x = xIn; flags |= OGR_G_NOT_EMPTY_POINT; }
void setY( double yIn ) { y = yIn; flags |= OGR_G_NOT_EMPTY_POINT; }
void setZ( double zIn ) { z = zIn; flags |= (OGR_G_NOT_EMPTY_POINT | OGR_G_3D); }
void setM( double mIn ) { m = mIn; flags |= (OGR_G_NOT_EMPTY_POINT | OGR_G_MEASURED); }
// ISpatialRelation
virtual OGRBoolean Equals( OGRGeometry * ) const;
virtual OGRBoolean Intersects( const OGRGeometry * ) const;
virtual OGRBoolean Within( const OGRGeometry * ) const;
// Non standard from OGRGeometry
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRErr transform( OGRCoordinateTransformation *poCT );
virtual void flattenTo2D();
virtual void swapXY();
};
/************************************************************************/
/* OGRPointIterator */
/************************************************************************/
/**
* Interface for a point iterator.
*
* @since GDAL 2.0
*/
class CPL_DLL OGRPointIterator
{
public:
virtual ~OGRPointIterator();
virtual OGRBoolean getNextPoint(OGRPoint* p) = 0;
static void destroy(OGRPointIterator*);
};
/************************************************************************/
/* OGRCurve */
/************************************************************************/
/**
* Abstract curve base class for OGRLineString, OGRCircularString and
* OGRCompoundCurve
*/
class CPL_DLL OGRCurve : public OGRGeometry
{
protected:
OGRCurve();
OGRCurve( const OGRCurve& other );
virtual OGRCurveCasterToLineString GetCasterToLineString() const = 0;
virtual OGRCurveCasterToLinearRing GetCasterToLinearRing() const = 0;
friend class OGRCurvePolygon;
friend class OGRCompoundCurve;
virtual int ContainsPoint( const OGRPoint* p ) const;
virtual double get_AreaOfCurveSegments() const = 0;
public:
virtual ~OGRCurve();
OGRCurve& operator=( const OGRCurve& other );
// ICurve methods
virtual double get_Length() const = 0;
virtual void StartPoint(OGRPoint *) const = 0;
virtual void EndPoint(OGRPoint *) const = 0;
virtual int get_IsClosed() const;
virtual void Value( double, OGRPoint * ) const = 0;
virtual OGRLineString* CurveToLine(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const = 0;
virtual int getDimension() const;
// non standard
virtual int getNumPoints() const = 0;
virtual OGRPointIterator* getPointIterator() const = 0;
virtual OGRBoolean IsConvex() const;
virtual double get_Area() const = 0;
static OGRCompoundCurve* CastToCompoundCurve(OGRCurve* puCurve);
static OGRLineString* CastToLineString(OGRCurve* poCurve);
static OGRLinearRing* CastToLinearRing(OGRCurve* poCurve);
};
/************************************************************************/
/* OGRSimpleCurve */
/************************************************************************/
/**
* Abstract curve base class for OGRLineString and OGRCircularString
*
* Note: this class does not exist in SQL/MM standard and exists for
* implementation convenience.
*
* @since GDAL 2.0
*/
class CPL_DLL OGRSimpleCurve: public OGRCurve
{
protected:
friend class OGRGeometry;
int nPointCount;
OGRRawPoint *paoPoints;
double *padfZ;
double *padfM;
void Make3D();
void Make2D();
void RemoveM();
void AddM();
OGRErr importFromWKTListOnly( char ** ppszInput, int bHasZ, int bHasM,
OGRRawPoint*& paoPointsIn, int& nMaxPoints,
double*& padfZIn );
virtual double get_LinearArea() const;
OGRSimpleCurve();
OGRSimpleCurve( const OGRSimpleCurve& other );
public:
virtual ~OGRSimpleCurve();
OGRSimpleCurve& operator=( const OGRSimpleCurve& other );
// IWks Interface
virtual int WkbSize() const;
virtual OGRErr importFromWkb( unsigned char *, int = -1, OGRwkbVariant=wkbVariantOldOgc );
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char ** ppszDstText, OGRwkbVariant=wkbVariantOldOgc ) const;
// IGeometry interface
virtual OGRGeometry *clone() const;
virtual void empty();
virtual void getEnvelope( OGREnvelope * psEnvelope ) const;
virtual void getEnvelope( OGREnvelope3D * psEnvelope ) const;
virtual OGRBoolean IsEmpty() const;
// ICurve methods
virtual double get_Length() const;
virtual void StartPoint(OGRPoint *) const;
virtual void EndPoint(OGRPoint *) const;
virtual void Value( double, OGRPoint * ) const;
virtual double Project(const OGRPoint *) const;
virtual OGRLineString* getSubLine(double, double, int) const;
// ILineString methods
virtual int getNumPoints() const { return nPointCount; }
void getPoint( int, OGRPoint * ) const;
double getX( int i ) const { return paoPoints[i].x; }
double getY( int i ) const { return paoPoints[i].y; }
double getZ( int i ) const;
double getM( int i ) const;
// ISpatialRelation
virtual OGRBoolean Equals( OGRGeometry * ) const;
// non standard.
virtual void setCoordinateDimension( int nDimension );
virtual void set3D( OGRBoolean bIs3D );
virtual void setMeasured( OGRBoolean bIsMeasured );
void setNumPoints( int nNewPointCount, int bZeroizeNewContent = TRUE );
void setPoint( int, OGRPoint * );
void setPoint( int, double, double );
void setZ( int, double );
void setM( int, double );
void setPoint( int, double, double, double );
void setPointM( int, double, double, double );
void setPoint( int, double, double, double, double );
void setPoints( int, OGRRawPoint *, double * = NULL );
void setPointsM( int, OGRRawPoint *, double * );
void setPoints( int, OGRRawPoint *, double *, double * );
void setPoints( int, double * padfX, double * padfY,
double *padfZIn = NULL );
void setPointsM( int, double * padfX, double * padfY,
double *padfMIn = NULL );
void setPoints( int, double * padfX, double * padfY,
double *padfZIn, double *padfMIn );
void addPoint( OGRPoint * );
void addPoint( double, double );
void addPoint( double, double, double );
void addPointM( double, double, double );
void addPoint( double, double, double, double );
void getPoints( OGRRawPoint *, double * = NULL ) const;
void getPoints( OGRRawPoint *, double *, double * ) const;
void getPoints( void* pabyX, int nXStride,
void* pabyY, int nYStride,
void* pabyZ = NULL, int nZStride = 0 ) const;
void getPoints( void* pabyX, int nXStride,
void* pabyY, int nYStride,
void* pabyZ, int nZStride,
void* pabyM, int nMStride ) const;
void addSubLineString( const OGRLineString *,
int nStartVertex = 0, int nEndVertex = -1 );
void reversePoints( void );
virtual OGRPointIterator* getPointIterator() const;
// non-standard from OGRGeometry
virtual OGRErr transform( OGRCoordinateTransformation *poCT );
virtual void flattenTo2D();
virtual void segmentize(double dfMaxLength);
virtual void swapXY();
};
/************************************************************************/
/* OGRLineString */
/************************************************************************/
/**
* Concrete representation of a multi-vertex line.
*
* Note: for implementation convenience, we make it inherit from OGRSimpleCurve whereas
* SFSQL and SQL/MM only make it inherits from OGRCurve.
*/
class CPL_DLL OGRLineString : public OGRSimpleCurve
{
protected:
static OGRLineString* TransferMembersAndDestroy(
OGRLineString* poSrc,
OGRLineString* poDst);
static OGRLinearRing* CastToLinearRing(OGRLineString* poLS);
virtual OGRCurveCasterToLineString GetCasterToLineString() const;
virtual OGRCurveCasterToLinearRing GetCasterToLinearRing() const;
virtual double get_AreaOfCurveSegments() const;
public:
OGRLineString();
OGRLineString(const OGRLineString& other);
virtual ~OGRLineString();
OGRLineString& operator=(const OGRLineString& other);
virtual OGRLineString* CurveToLine(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
virtual OGRGeometry* getCurveGeometry(const char* const* papszOptions = NULL) const;
virtual double get_Area() const;
// non-standard from OGRGeometry
virtual OGRwkbGeometryType getGeometryType() const;
virtual const char *getGeometryName() const;
};
/************************************************************************/
/* OGRLinearRing */
/************************************************************************/
/**
* Concrete representation of a closed ring.
*
* This class is functionally equivalent to an OGRLineString, but has a
* separate identity to maintain alignment with the OpenGIS simple feature
* data model. It exists to serve as a component of an OGRPolygon.
*
* The OGRLinearRing has no corresponding free standing well known binary
* representation, so importFromWkb() and exportToWkb() will not actually
* work. There is a non-standard GDAL WKT representation though.
*
* Because OGRLinearRing is not a "proper" free standing simple features
* object, it cannot be directly used on a feature via SetGeometry(), and
* cannot generally be used with GEOS for operations like Intersects().
* Instead the polygon should be used, or the OGRLinearRing should be
* converted to an OGRLineString for such operations.
*
* Note: this class exists in SFSQL 1.2, but not in ISO SQL/MM Part 3.
*/
class CPL_DLL OGRLinearRing : public OGRLineString
{
protected:
friend class OGRPolygon;
// These are not IWks compatible ... just a convenience for OGRPolygon.
virtual int _WkbSize( int _flags ) const;
virtual OGRErr _importFromWkb( OGRwkbByteOrder, int _flags,
unsigned char *, int=-1 );
virtual OGRErr _exportToWkb( OGRwkbByteOrder, int _flags,
unsigned char * ) const;
static OGRLineString* CastToLineString(OGRLinearRing* poLR);
virtual OGRCurveCasterToLineString GetCasterToLineString() const;
virtual OGRCurveCasterToLinearRing GetCasterToLinearRing() const;
public:
OGRLinearRing();
OGRLinearRing(const OGRLinearRing& other);
OGRLinearRing( OGRLinearRing * );
virtual ~OGRLinearRing();
OGRLinearRing& operator=(const OGRLinearRing& other);
// Non standard.
virtual const char *getGeometryName() const;
virtual OGRGeometry *clone() const;
virtual int isClockwise() const;
virtual void reverseWindingOrder();
virtual void closeRings();
OGRBoolean isPointInRing(const OGRPoint* pt, int bTestEnvelope = TRUE) const;
OGRBoolean isPointOnRingBoundary(const OGRPoint* pt, int bTestEnvelope = TRUE) const;
// IWks Interface - Note this isn't really a first class object
// for the purposes of WKB form. These methods always fail since this
// object can't be serialized on its own.
virtual int WkbSize() const;
virtual OGRErr importFromWkb( unsigned char *, int=-1, OGRwkbVariant=wkbVariantOldOgc );
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const;
};
/************************************************************************/
/* OGRCircularString */
/************************************************************************/
/**
* Concrete representation of a circular string, that is to say a curve made
* of one or several arc circles.
*
* Note: for implementation convenience, we make it inherit from OGRSimpleCurve whereas
* SQL/MM only makes it inherits from OGRCurve.
*
* Compatibility: ISO SQL/MM Part 3.
*
* @since GDAL 2.0
*/
class CPL_DLL OGRCircularString : public OGRSimpleCurve
{
private:
void ExtendEnvelopeWithCircular( OGREnvelope * psEnvelope ) const;
OGRBoolean IsValidFast() const;
int IsFullCircle( double& cx, double& cy, double& square_R ) const;
protected:
virtual OGRCurveCasterToLineString GetCasterToLineString() const;
virtual OGRCurveCasterToLinearRing GetCasterToLinearRing() const;
virtual int ContainsPoint( const OGRPoint* p ) const;
virtual double get_AreaOfCurveSegments() const;
public:
OGRCircularString();
OGRCircularString(const OGRCircularString& other);
virtual ~OGRCircularString();
OGRCircularString& operator=(const OGRCircularString& other);
// IWks Interface
virtual OGRErr importFromWkb( unsigned char *, int = -1, OGRwkbVariant=wkbVariantOldOgc );
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char ** ppszDstText, OGRwkbVariant=wkbVariantOldOgc ) const;
// IGeometry interface
virtual OGRBoolean IsValid() const;
virtual void getEnvelope( OGREnvelope * psEnvelope ) const;
virtual void getEnvelope( OGREnvelope3D * psEnvelope ) const;
// ICurve methods
virtual double get_Length() const;
virtual OGRLineString* CurveToLine(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
virtual void Value( double, OGRPoint * ) const;
virtual double get_Area() const;
// non-standard from OGRGeometry
virtual OGRwkbGeometryType getGeometryType() const;
virtual const char *getGeometryName() const;
virtual void segmentize(double dfMaxLength);
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
virtual OGRGeometry* getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
};
/************************************************************************/
/* OGRCurveCollection */
/************************************************************************/
/**
* Utility class to store a collection of curves. Used as a member of
* OGRCompoundCurve and OGRCurvePolygon.
*
* This class is only exported because of linking issues. It should never
* be directly used.
*
* @since GDAL 2.0
*/
class CPL_DLL OGRCurveCollection
{
protected:
friend class OGRCompoundCurve;
friend class OGRCurvePolygon;
friend class OGRPolygon;
int nCurveCount;
OGRCurve **papoCurves;
public:
OGRCurveCollection();
OGRCurveCollection(const OGRCurveCollection& other);
~OGRCurveCollection();
OGRCurveCollection& operator=(const OGRCurveCollection& other);
void empty(OGRGeometry* poGeom);
OGRBoolean IsEmpty() const;
void getEnvelope( OGREnvelope * psEnvelope ) const;
void getEnvelope( OGREnvelope3D * psEnvelope ) const;
OGRErr addCurveDirectly( OGRGeometry* poGeom, OGRCurve* poCurve,
int bNeedRealloc );
int WkbSize() const;
OGRErr importPreambuleFromWkb( OGRGeometry* poGeom,
unsigned char * pabyData,
int& nSize,
int& nDataOffset,
OGRwkbByteOrder& eByteOrder,
int nMinSubGeomSize,
OGRwkbVariant eWkVariant );
OGRErr importBodyFromWkb( OGRGeometry* poGeom,
unsigned char * pabyData,
int nSize,
int nDataOffset,
int bAcceptCompoundCurve,
OGRErr (*pfnAddCurveDirectlyFromWkb)(OGRGeometry* poGeom, OGRCurve* poCurve),
OGRwkbVariant eWkVariant );
OGRErr exportToWkt( const OGRGeometry* poGeom, char ** ppszDstText ) const;
OGRErr exportToWkb( const OGRGeometry* poGeom, OGRwkbByteOrder,
unsigned char *, OGRwkbVariant eWkbVariant ) const;
OGRBoolean Equals(OGRCurveCollection *poOCC) const;
void setCoordinateDimension( OGRGeometry* poGeom, int nNewDimension );
void set3D( OGRGeometry* poGeom, OGRBoolean bIs3D );
void setMeasured( OGRGeometry* poGeom, OGRBoolean bIsMeasured );
int getNumCurves() const;
OGRCurve *getCurve( int );
const OGRCurve *getCurve( int ) const;
OGRCurve *stealCurve( int );
OGRErr transform( OGRGeometry* poGeom,
OGRCoordinateTransformation *poCT );
void flattenTo2D(OGRGeometry* poGeom);
void segmentize(double dfMaxLength);
void swapXY();
OGRBoolean hasCurveGeometry(int bLookForNonLinear) const;
};
/************************************************************************/
/* OGRCompoundCurve */
/************************************************************************/
/**
* Concrete representation of a compound curve, made of curves: OGRLineString
* and OGRCircularString. Each curve is connected by its first point to
* the last point of the previous curve.
*
* Compatibility: ISO SQL/MM Part 3.
*
* @since GDAL 2.0
*/
class CPL_DLL OGRCompoundCurve : public OGRCurve
{
private:
OGRCurveCollection oCC;
OGRErr addCurveDirectlyInternal( OGRCurve* poCurve,
double dfToleranceEps,
int bNeedRealloc );
static OGRErr addCurveDirectlyFromWkt( OGRGeometry* poSelf, OGRCurve* poCurve );
static OGRErr addCurveDirectlyFromWkb( OGRGeometry* poSelf, OGRCurve* poCurve );
OGRLineString* CurveToLineInternal(double dfMaxAngleStepSizeDegrees,
const char* const* papszOptions,
int bIsLinearRing) const;
protected:
static OGRLineString* CastToLineString(OGRCompoundCurve* poCC);
static OGRLinearRing* CastToLinearRing(OGRCompoundCurve* poCC);
virtual OGRCurveCasterToLineString GetCasterToLineString() const;
virtual OGRCurveCasterToLinearRing GetCasterToLinearRing() const;
public:
OGRCompoundCurve();
OGRCompoundCurve(const OGRCompoundCurve& other);
virtual ~OGRCompoundCurve();
OGRCompoundCurve& operator=(const OGRCompoundCurve& other);
// IWks Interface
virtual int WkbSize() const;
virtual OGRErr importFromWkb( unsigned char *, int = -1, OGRwkbVariant=wkbVariantOldOgc );
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char ** ppszDstText, OGRwkbVariant=wkbVariantOldOgc ) const;
// IGeometry interface
virtual OGRGeometry *clone() const;
virtual void empty();
virtual void getEnvelope( OGREnvelope * psEnvelope ) const;
virtual void getEnvelope( OGREnvelope3D * psEnvelope ) const;
virtual OGRBoolean IsEmpty() const;
// ICurve methods
virtual double get_Length() const;
virtual void StartPoint(OGRPoint *) const;
virtual void EndPoint(OGRPoint *) const;
virtual void Value( double, OGRPoint * ) const;
virtual OGRLineString* CurveToLine(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
virtual int getNumPoints() const;
virtual double get_AreaOfCurveSegments() const;
virtual double get_Area() const;
// ISpatialRelation
virtual OGRBoolean Equals( OGRGeometry * ) const;
// ICompoundCurve method
int getNumCurves() const;
OGRCurve *getCurve( int );
const OGRCurve *getCurve( int ) const;
// non standard.
virtual void setCoordinateDimension( int nDimension );
virtual void set3D( OGRBoolean bIs3D );
virtual void setMeasured( OGRBoolean bIsMeasured );
OGRErr addCurve( OGRCurve*, double dfToleranceEps = 1e-14 );
OGRErr addCurveDirectly( OGRCurve*, double dfToleranceEps = 1e-14 );
OGRCurve *stealCurve( int );
virtual OGRPointIterator* getPointIterator() const;
// non-standard from OGRGeometry
virtual OGRwkbGeometryType getGeometryType() const;
virtual const char *getGeometryName() const;
virtual OGRErr transform( OGRCoordinateTransformation *poCT );
virtual void flattenTo2D();
virtual void segmentize(double dfMaxLength);
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
virtual OGRGeometry* getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
virtual void swapXY();
};
/************************************************************************/
/* OGRSurface */
/************************************************************************/
/**
* Abstract base class for 2 dimensional objects like polygons or curve polygons.
*/
class CPL_DLL OGRSurface : public OGRGeometry
{
protected:
virtual OGRSurfaceCasterToPolygon GetCasterToPolygon() const = 0;
virtual OGRSurfaceCasterToCurvePolygon GetCasterToCurvePolygon() const = 0;
public:
virtual double get_Area() const = 0;
virtual OGRErr PointOnSurface( OGRPoint * poPoint ) const = 0;
static OGRPolygon* CastToPolygon(OGRSurface* poSurface);
static OGRCurvePolygon* CastToCurvePolygon(OGRSurface* poSurface);
};
/************************************************************************/
/* OGRCurvePolygon */
/************************************************************************/
/**
* Concrete class representing curve polygons.
*
* Note that curve polygons consist of one outer (curve) ring, and zero or
* more inner rings. A curve polygon cannot represent disconnected
* regions (such as multiple islands in a political body). The
* OGRMultiSurface must be used for this.
*
* Compatibility: ISO SQL/MM Part 3.
*
* @since GDAL 2.0
*/
class CPL_DLL OGRCurvePolygon : public OGRSurface
{
private:
OGRBoolean ContainsPoint( const OGRPoint* p ) const;
virtual int checkRing( OGRCurve * poNewRing ) const;
OGRErr addRingDirectlyInternal( OGRCurve* poCurve, int bNeedRealloc );
static OGRErr addCurveDirectlyFromWkt( OGRGeometry* poSelf, OGRCurve* poCurve );
static OGRErr addCurveDirectlyFromWkb( OGRGeometry* poSelf, OGRCurve* poCurve );
protected:
friend class OGRPolygon;
OGRCurveCollection oCC;
static OGRPolygon* CastToPolygon(OGRCurvePolygon* poCP);
virtual OGRSurfaceCasterToPolygon GetCasterToPolygon() const;
virtual OGRSurfaceCasterToCurvePolygon GetCasterToCurvePolygon() const;
public:
OGRCurvePolygon();
OGRCurvePolygon(const OGRCurvePolygon&);
virtual ~OGRCurvePolygon();
OGRCurvePolygon& operator=(const OGRCurvePolygon& other);
// Non standard (OGRGeometry).
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRGeometry *clone() const;
virtual void empty();
virtual OGRErr transform( OGRCoordinateTransformation *poCT );
virtual void flattenTo2D();
virtual OGRBoolean IsEmpty() const;
virtual void segmentize(double dfMaxLength);
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
virtual OGRGeometry* getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
// ISurface Interface
virtual double get_Area() const;
virtual OGRErr PointOnSurface( OGRPoint * poPoint ) const;
// IWks Interface
virtual int WkbSize() const;
virtual OGRErr importFromWkb( unsigned char *, int = -1, OGRwkbVariant=wkbVariantOldOgc );
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char ** ppszDstText, OGRwkbVariant eWkbVariant = wkbVariantOldOgc ) const;
// IGeometry
virtual int getDimension() const;
virtual void getEnvelope( OGREnvelope * psEnvelope ) const;
virtual void getEnvelope( OGREnvelope3D * psEnvelope ) const;
// ICurvePolygon
virtual OGRPolygon* CurvePolyToPoly(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
// ISpatialRelation
virtual OGRBoolean Equals( OGRGeometry * ) const;
virtual OGRBoolean Intersects( const OGRGeometry * ) const;
virtual OGRBoolean Contains( const OGRGeometry * ) const;
// Non standard
virtual void setCoordinateDimension( int nDimension );
virtual void set3D( OGRBoolean bIs3D );
virtual void setMeasured( OGRBoolean bIsMeasured );
OGRErr addRing( OGRCurve * );
OGRErr addRingDirectly( OGRCurve * );
OGRCurve *getExteriorRingCurve();
const OGRCurve *getExteriorRingCurve() const;
int getNumInteriorRings() const;
OGRCurve *getInteriorRingCurve( int );
const OGRCurve *getInteriorRingCurve( int ) const;
OGRCurve *stealExteriorRingCurve();
virtual void swapXY();
};
/************************************************************************/
/* OGRPolygon */
/************************************************************************/
/**
* Concrete class representing polygons.
*
* Note that the OpenGIS simple features polygons consist of one outer
* ring (linearring), and zero or more inner rings. A polygon cannot represent disconnected
* regions (such as multiple islands in a political body). The
* OGRMultiPolygon must be used for this.
*/
class CPL_DLL OGRPolygon : public OGRCurvePolygon
{
protected:
friend class OGRMultiSurface;
virtual int checkRing( OGRCurve * poNewRing ) const;
OGRErr importFromWKTListOnly( char ** ppszInput, int bHasZ, int bHasM,
OGRRawPoint*& paoPoints, int& nMaxPoints,
double*& padfZ );
static OGRCurvePolygon* CastToCurvePolygon(OGRPolygon* poPoly);
virtual OGRSurfaceCasterToPolygon GetCasterToPolygon() const;
virtual OGRSurfaceCasterToCurvePolygon GetCasterToCurvePolygon() const;
public:
OGRPolygon();
OGRPolygon(const OGRPolygon& other);
virtual ~OGRPolygon();
OGRPolygon& operator=(const OGRPolygon& other);
// Non standard (OGRGeometry).
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
virtual OGRGeometry* getCurveGeometry(const char* const* papszOptions = NULL) const;
virtual OGRGeometry* getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
// ISurface Interface
virtual OGRErr PointOnSurface( OGRPoint * poPoint ) const;
// IWks Interface
virtual int WkbSize() const;
virtual OGRErr importFromWkb( unsigned char *, int = -1, OGRwkbVariant=wkbVariantOldOgc );
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char ** ppszDstText, OGRwkbVariant=wkbVariantOldOgc ) const;
// ICurvePolygon
virtual OGRPolygon* CurvePolyToPoly(double dfMaxAngleStepSizeDegrees = 0,
const char* const* papszOptions = NULL) const;
OGRLinearRing *getExteriorRing();
const OGRLinearRing *getExteriorRing() const;
OGRLinearRing *getInteriorRing( int );
const OGRLinearRing *getInteriorRing( int ) const;
OGRLinearRing *stealExteriorRing();
OGRLinearRing *stealInteriorRing(int);
OGRBoolean IsPointOnSurface( const OGRPoint * ) const;
virtual void closeRings();
};
/************************************************************************/
/* OGRGeometryCollection */
/************************************************************************/
/**
* A collection of 1 or more geometry objects.
*
* All geometries must share a common spatial reference system, and
* Subclasses may impose additional restrictions on the contents.
*/
class CPL_DLL OGRGeometryCollection : public OGRGeometry
{
OGRErr importFromWkbInternal( unsigned char * pabyData, int nSize, int nRecLevel,
OGRwkbVariant );
OGRErr importFromWktInternal( char **ppszInput, int nRecLevel );
protected:
int nGeomCount;
OGRGeometry **papoGeoms;
OGRErr exportToWktInternal( char ** ppszDstText,
OGRwkbVariant eWkbVariant,
const char* pszSkipPrefix ) const;
virtual OGRBoolean isCompatibleSubType( OGRwkbGeometryType ) const;
static OGRGeometryCollection* TransferMembersAndDestroy(OGRGeometryCollection* poSrc,
OGRGeometryCollection* poDst);
public:
OGRGeometryCollection();
OGRGeometryCollection(const OGRGeometryCollection& other);
virtual ~OGRGeometryCollection();
OGRGeometryCollection& operator=(const OGRGeometryCollection& other);
// Non standard (OGRGeometry).
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRGeometry *clone() const;
virtual void empty();
virtual OGRErr transform( OGRCoordinateTransformation *poCT );
virtual void flattenTo2D();
virtual OGRBoolean IsEmpty() const;
virtual void segmentize(double dfMaxLength);
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
virtual OGRGeometry* getCurveGeometry(const char* const* papszOptions = NULL) const;
virtual OGRGeometry* getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0, const char* const* papszOptions = NULL) const;
// IWks Interface
virtual int WkbSize() const;
virtual OGRErr importFromWkb( unsigned char *, int = -1, OGRwkbVariant=wkbVariantOldOgc );
virtual OGRErr exportToWkb( OGRwkbByteOrder, unsigned char *, OGRwkbVariant=wkbVariantOldOgc ) const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char ** ppszDstText, OGRwkbVariant=wkbVariantOldOgc ) const;
virtual double get_Length() const;
virtual double get_Area() const;
// IGeometry methods
virtual int getDimension() const;
virtual void getEnvelope( OGREnvelope * psEnvelope ) const;
virtual void getEnvelope( OGREnvelope3D * psEnvelope ) const;
// IGeometryCollection
int getNumGeometries() const;
OGRGeometry *getGeometryRef( int );
const OGRGeometry *getGeometryRef( int ) const;
// ISpatialRelation
virtual OGRBoolean Equals( OGRGeometry * ) const;
// Non standard
virtual void setCoordinateDimension( int nDimension );
virtual void set3D( OGRBoolean bIs3D );
virtual void setMeasured( OGRBoolean bIsMeasured );
virtual OGRErr addGeometry( const OGRGeometry * );
virtual OGRErr addGeometryDirectly( OGRGeometry * );
virtual OGRErr removeGeometry( int iIndex, int bDelete = TRUE );
void closeRings();
virtual void swapXY();
};
/************************************************************************/
/* OGRMultiSurface */
/************************************************************************/
/**
* A collection of non-overlapping OGRSurface.
*
* @since GDAL 2.0
*/
class CPL_DLL OGRMultiSurface : public OGRGeometryCollection
{
protected:
virtual OGRBoolean isCompatibleSubType( OGRwkbGeometryType ) const;
public:
OGRMultiSurface();
OGRMultiSurface(const OGRMultiSurface& other);
virtual ~OGRMultiSurface();
OGRMultiSurface& operator=(const OGRMultiSurface& other);
// Non standard (OGRGeometry).
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char **, OGRwkbVariant=wkbVariantOldOgc ) const;
// IMultiSurface methods
virtual OGRErr PointOnSurface( OGRPoint * poPoint ) const;
// IGeometry methods
virtual int getDimension() const;
// Non standard
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
static OGRMultiPolygon* CastToMultiPolygon(OGRMultiSurface* poMS);
};
/************************************************************************/
/* OGRMultiPolygon */
/************************************************************************/
/**
* A collection of non-overlapping OGRPolygon.
*/
class CPL_DLL OGRMultiPolygon : public OGRMultiSurface
{
protected:
virtual OGRBoolean isCompatibleSubType( OGRwkbGeometryType ) const;
public:
OGRMultiPolygon();
OGRMultiPolygon(const OGRMultiPolygon& other);
virtual ~OGRMultiPolygon();
OGRMultiPolygon& operator=(const OGRMultiPolygon& other);
// Non standard (OGRGeometry).
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRErr exportToWkt( char **, OGRwkbVariant=wkbVariantOldOgc ) const;
// IMultiSurface methods
virtual OGRErr PointOnSurface( OGRPoint * poPoint ) const;
// Non standard
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
static OGRMultiSurface* CastToMultiSurface(OGRMultiPolygon* poMP);
};
/************************************************************************/
/* OGRMultiPoint */
/************************************************************************/
/**
* A collection of OGRPoint.
*/
class CPL_DLL OGRMultiPoint : public OGRGeometryCollection
{
private:
OGRErr importFromWkt_Bracketed( char **, int bHasM, int bHasZ );
protected:
virtual OGRBoolean isCompatibleSubType( OGRwkbGeometryType ) const;
public:
OGRMultiPoint();
OGRMultiPoint(const OGRMultiPoint& other);
virtual ~OGRMultiPoint();
OGRMultiPoint& operator=(const OGRMultiPoint& other);
// Non standard (OGRGeometry).
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char **, OGRwkbVariant=wkbVariantOldOgc ) const;
// IGeometry methods
virtual int getDimension() const;
// Non standard
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
};
/************************************************************************/
/* OGRMultiCurve */
/************************************************************************/
/**
* A collection of OGRCurve.
*
* @since GDAL 2.0
*/
class CPL_DLL OGRMultiCurve : public OGRGeometryCollection
{
protected:
static OGRErr addCurveDirectlyFromWkt( OGRGeometry* poSelf, OGRCurve* poCurve );
virtual OGRBoolean isCompatibleSubType( OGRwkbGeometryType ) const;
public:
OGRMultiCurve();
OGRMultiCurve(const OGRMultiCurve& other);
virtual ~OGRMultiCurve();
OGRMultiCurve& operator=(const OGRMultiCurve& other);
// Non standard (OGRGeometry).
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRErr importFromWkt( char ** );
virtual OGRErr exportToWkt( char **, OGRwkbVariant=wkbVariantOldOgc ) const;
// IGeometry methods
virtual int getDimension() const;
// Non standard
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
static OGRMultiLineString* CastToMultiLineString(OGRMultiCurve* poMC);
};
/************************************************************************/
/* OGRMultiLineString */
/************************************************************************/
/**
* A collection of OGRLineString.
*/
class CPL_DLL OGRMultiLineString : public OGRMultiCurve
{
protected:
virtual OGRBoolean isCompatibleSubType( OGRwkbGeometryType ) const;
public:
OGRMultiLineString();
OGRMultiLineString(const OGRMultiLineString& other);
virtual ~OGRMultiLineString();
OGRMultiLineString& operator=(const OGRMultiLineString& other);
// Non standard (OGRGeometry).
virtual const char *getGeometryName() const;
virtual OGRwkbGeometryType getGeometryType() const;
virtual OGRErr exportToWkt( char **, OGRwkbVariant=wkbVariantOldOgc ) const;
// Non standard
virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
static OGRMultiCurve* CastToMultiCurve(OGRMultiLineString* poMLS);
};
/************************************************************************/
/* OGRGeometryFactory */
/************************************************************************/
/**
* Create geometry objects from well known text/binary.
*/
class CPL_DLL OGRGeometryFactory
{
static OGRErr createFromFgfInternal( unsigned char *pabyData,
OGRSpatialReference * poSR,
OGRGeometry **ppoReturn,
int nBytes,
int *pnBytesConsumed,
int nRecLevel );
public:
static OGRErr createFromWkb( unsigned char *, OGRSpatialReference *,
OGRGeometry **, int = -1, OGRwkbVariant=wkbVariantOldOgc );
static OGRErr createFromWkt( char **, OGRSpatialReference *,
OGRGeometry ** );
static OGRErr createFromFgf( unsigned char *, OGRSpatialReference *,
OGRGeometry **, int = -1, int * = NULL );
static OGRGeometry *createFromGML( const char * );
static OGRGeometry *createFromGEOS( GEOSContextHandle_t hGEOSCtxt, GEOSGeom );
static void destroyGeometry( OGRGeometry * );
static OGRGeometry *createGeometry( OGRwkbGeometryType );
static OGRGeometry * forceToPolygon( OGRGeometry * );
static OGRGeometry * forceToLineString( OGRGeometry *, bool bOnlyInOrder = true );
static OGRGeometry * forceToMultiPolygon( OGRGeometry * );
static OGRGeometry * forceToMultiPoint( OGRGeometry * );
static OGRGeometry * forceToMultiLineString( OGRGeometry * );
static OGRGeometry * forceTo( OGRGeometry* poGeom,
OGRwkbGeometryType eTargetType,
const char*const* papszOptions = NULL );
static OGRGeometry * organizePolygons( OGRGeometry **papoPolygons,
int nPolygonCount,
int *pbResultValidGeometry,
const char **papszOptions = NULL);
static int haveGEOS();
static OGRGeometry* transformWithOptions( const OGRGeometry* poSrcGeom,
OGRCoordinateTransformation *poCT,
char** papszOptions );
static OGRGeometry*
approximateArcAngles( double dfX, double dfY, double dfZ,
double dfPrimaryRadius, double dfSecondaryAxis,
double dfRotation,
double dfStartAngle, double dfEndAngle,
double dfMaxAngleStepSizeDegrees );
static int GetCurveParmeters(double x0, double y0,
double x1, double y1,
double x2, double y2,
double& R, double& cx, double& cy,
double& alpha0, double& alpha1, double& alpha2 );
static OGRLineString* curveToLineString( double x0, double y0, double z0,
double x1, double y1, double z1,
double x2, double y2, double z2,
int bHasZ,
double dfMaxAngleStepSizeDegrees,
const char*const* papszOptions = NULL );
static OGRCurve* curveFromLineString(const OGRLineString* poLS,
const char*const* papszOptions = NULL);
};
OGRwkbGeometryType CPL_DLL OGRFromOGCGeomType( const char *pszGeomType );
const char CPL_DLL * OGRToOGCGeomType( OGRwkbGeometryType eGeomType );
/* Prepared geometry API (needs GEOS >= 3.1.0) */
typedef struct _OGRPreparedGeometry OGRPreparedGeometry;
int OGRHasPreparedGeometrySupport();
OGRPreparedGeometry* OGRCreatePreparedGeometry( const OGRGeometry* poGeom );
void OGRDestroyPreparedGeometry( OGRPreparedGeometry* poPreparedGeom );
int OGRPreparedGeometryIntersects( const OGRPreparedGeometry* poPreparedGeom,
const OGRGeometry* poOtherGeom );
int OGRPreparedGeometryContains( const OGRPreparedGeometry* poPreparedGeom,
const OGRGeometry* poOtherGeom );
#endif /* ndef OGR_GEOMETRY_H_INCLUDED */