ogr_geometry.h

Go to the documentation of this file.

/******************************************************************************
 *
 * 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 spatialys.com>
 *
 * SPDX-License-Identifier: MIT
 ****************************************************************************/
 
#ifndef OGR_GEOMETRY_H_INCLUDED
#define OGR_GEOMETRY_H_INCLUDED
 
#include "cpl_conv.h"
#include "cpl_json.h"
#include "gdal_fwd.h"
#include "ogr_core.h"
#include "ogr_geomcoordinateprecision.h"
#include "ogr_spatialref.h"
 
#include <climits>
#include <cmath>
#include <memory>
#include <utility>


enum class OGRWktFormat
{
    F,       
    G,       
    Default  
};

class CPL_DLL OGRWktOptions
{
  public:
    OGRwkbVariant variant = wkbVariantOldOgc;
    int xyPrecision;
    int zPrecision;
    int mPrecision;
    bool round;
    OGRWktFormat format = OGRWktFormat::Default;

    OGRWktOptions()
        : xyPrecision(getDefaultPrecision()), zPrecision(xyPrecision),
          mPrecision(zPrecision), round(getDefaultRound())
    {
    }

    OGRWktOptions(int xyPrecisionIn, bool roundIn)
        : xyPrecision(xyPrecisionIn), zPrecision(xyPrecision),
          mPrecision(zPrecision), round(roundIn)
    {
    }

    OGRWktOptions(const OGRWktOptions &) = default;

    static int getDefaultPrecision();

    static bool getDefaultRound();
};

class OGRRawPoint
{
  public:
    OGRRawPoint() : x(0.0), 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;
typedef void sfcgal_geometry_t;
 
class OGRPoint;
class OGRCurve;
class OGRCompoundCurve;
class OGRSimpleCurve;
class OGRLinearRing;
class OGRLineString;
class OGRCircularString;
class OGRSurface;
class OGRCurvePolygon;
class OGRPolygon;
class OGRMultiPoint;
class OGRMultiSurface;
class OGRMultiPolygon;
class OGRMultiCurve;
class OGRMultiLineString;
class OGRGeometryCollection;
class OGRTriangle;
class OGRPolyhedralSurface;
class OGRTriangulatedSurface;

typedef OGRLineString *(*OGRCurveCasterToLineString)(OGRCurve *);
typedef OGRLinearRing *(*OGRCurveCasterToLinearRing)(OGRCurve *);
 
typedef OGRPolygon *(*OGRSurfaceCasterToPolygon)(OGRSurface *);
typedef OGRCurvePolygon *(*OGRSurfaceCasterToCurvePolygon)(OGRSurface *);
typedef OGRMultiPolygon *(*OGRPolyhedralSurfaceCastToMultiPolygon)(
    OGRPolyhedralSurface *);


class CPL_DLL IOGRGeometryVisitor
{
  public:
    virtual ~IOGRGeometryVisitor();

    virtual void visit(OGRPoint *) = 0;
    virtual void visit(OGRLineString *) = 0;
    virtual void visit(OGRLinearRing *) = 0;
    virtual void visit(OGRPolygon *) = 0;
    virtual void visit(OGRMultiPoint *) = 0;
    virtual void visit(OGRMultiLineString *) = 0;
    virtual void visit(OGRMultiPolygon *) = 0;
    virtual void visit(OGRGeometryCollection *) = 0;
    virtual void visit(OGRCircularString *) = 0;
    virtual void visit(OGRCompoundCurve *) = 0;
    virtual void visit(OGRCurvePolygon *) = 0;
    virtual void visit(OGRMultiCurve *) = 0;
    virtual void visit(OGRMultiSurface *) = 0;
    virtual void visit(OGRTriangle *) = 0;
    virtual void visit(OGRPolyhedralSurface *) = 0;
    virtual void visit(OGRTriangulatedSurface *) = 0;
};

class CPL_DLL OGRDefaultGeometryVisitor : public IOGRGeometryVisitor
{
    void _visit(OGRSimpleCurve *poGeom);
 
  public:
    void visit(OGRPoint *) override
    {
    }
 
    void visit(OGRLineString *) override;
    void visit(OGRLinearRing *) override;
    void visit(OGRPolygon *) override;
    void visit(OGRMultiPoint *) override;
    void visit(OGRMultiLineString *) override;
    void visit(OGRMultiPolygon *) override;
    void visit(OGRGeometryCollection *) override;
    void visit(OGRCircularString *) override;
    void visit(OGRCompoundCurve *) override;
    void visit(OGRCurvePolygon *) override;
    void visit(OGRMultiCurve *) override;
    void visit(OGRMultiSurface *) override;
    void visit(OGRTriangle *) override;
    void visit(OGRPolyhedralSurface *) override;
    void visit(OGRTriangulatedSurface *) override;
};

class CPL_DLL IOGRConstGeometryVisitor
{
  public:
    virtual ~IOGRConstGeometryVisitor();

    virtual void visit(const OGRPoint *) = 0;
    virtual void visit(const OGRLineString *) = 0;
    virtual void visit(const OGRLinearRing *) = 0;
    virtual void visit(const OGRPolygon *) = 0;
    virtual void visit(const OGRMultiPoint *) = 0;
    virtual void visit(const OGRMultiLineString *) = 0;
    virtual void visit(const OGRMultiPolygon *) = 0;
    virtual void visit(const OGRGeometryCollection *) = 0;
    virtual void visit(const OGRCircularString *) = 0;
    virtual void visit(const OGRCompoundCurve *) = 0;
    virtual void visit(const OGRCurvePolygon *) = 0;
    virtual void visit(const OGRMultiCurve *) = 0;
    virtual void visit(const OGRMultiSurface *) = 0;
    virtual void visit(const OGRTriangle *) = 0;
    virtual void visit(const OGRPolyhedralSurface *) = 0;
    virtual void visit(const OGRTriangulatedSurface *) = 0;
};

class CPL_DLL OGRDefaultConstGeometryVisitor : public IOGRConstGeometryVisitor
{
    void _visit(const OGRSimpleCurve *poGeom);
 
  public:
    void visit(const OGRPoint *) override
    {
    }
 
    void visit(const OGRLineString *) override;
    void visit(const OGRLinearRing *) override;
    void visit(const OGRPolygon *) override;
    void visit(const OGRMultiPoint *) override;
    void visit(const OGRMultiLineString *) override;
    void visit(const OGRMultiPolygon *) override;
    void visit(const OGRGeometryCollection *) override;
    void visit(const OGRCircularString *) override;
    void visit(const OGRCompoundCurve *) override;
    void visit(const OGRCurvePolygon *) override;
    void visit(const OGRMultiCurve *) override;
    void visit(const OGRMultiSurface *) override;
    void visit(const OGRTriangle *) override;
    void visit(const OGRPolyhedralSurface *) override;
    void visit(const OGRTriangulatedSurface *) override;
};
 
/************************************************************************/
/*                   OGRGeomCoordinateBinaryPrecision                   */
/************************************************************************/

class CPL_DLL OGRGeomCoordinateBinaryPrecision
{
  public:
    int nXYBitPrecision =
        INT_MIN; 
    int nZBitPrecision =
        INT_MIN; 
    int nMBitPrecision =
        INT_MIN; 
 
    void SetFrom(const OGRGeomCoordinatePrecision &);
};
 
/************************************************************************/
/*                         OGRwkbExportOptions                          */
/************************************************************************/

struct CPL_DLL OGRwkbExportOptions
{
    OGRwkbByteOrder eByteOrder = wkbNDR;           
    OGRwkbVariant eWkbVariant = wkbVariantOldOgc;  
    OGRGeomCoordinateBinaryPrecision sPrecision{}; 
};
 
/************************************************************************/
/*                             OGRGeometry                              */
/************************************************************************/

 
class CPL_DLL OGRGeometry
{
  private:
    const OGRSpatialReference *poSRS = nullptr;  // may be NULL
 
  protected:
    friend class OGRCurveCollection;
 
    unsigned int flags = 0;
 
    OGRErr importPreambleFromWkt(const char **ppszInput, int *pbHasZ,
                                 int *pbHasM, bool *pbIsEmpty);
    OGRErr importCurveCollectionFromWkt(
        const char **ppszInput, int bAllowEmptyComponent, int bAllowLineString,
        int bAllowCurve, int bAllowCompoundCurve,
        OGRErr (*pfnAddCurveDirectly)(OGRGeometry *poSelf, OGRCurve *poCurve));
    OGRErr importPreambleFromWkb(const unsigned char *pabyData, size_t nSize,
                                 OGRwkbByteOrder &eByteOrder,
                                 OGRwkbVariant eWkbVariant);
    OGRErr importPreambleOfCollectionFromWkb(const unsigned char *pabyData,
                                             size_t &nSize, size_t &nDataOffset,
                                             OGRwkbByteOrder &eByteOrder,
                                             size_t nMinSubGeomSize,
                                             int &nGeomCount,
                                             OGRwkbVariant eWkbVariant);
    OGRErr PointOnSurfaceInternal(OGRPoint *poPoint) const;
    OGRBoolean IsSFCGALCompatible() const;
 
    void HomogenizeDimensionalityWith(OGRGeometry *poOtherGeom);
    std::string wktTypeString(OGRwkbVariant variant) 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);
    OGRGeometry(OGRGeometry &&other);
    virtual ~OGRGeometry();
 
    OGRGeometry &operator=(const OGRGeometry &other);
    OGRGeometry &operator=(OGRGeometry &&other);

    bool operator==(const OGRGeometry &other) const
    {
        return CPL_TO_BOOL(Equals(&other));
    }

    bool operator!=(const OGRGeometry &other) const
    {
        return !CPL_TO_BOOL(Equals(&other));
    }
 
    // Standard IGeometry.
    virtual int getDimension() const = 0;
    virtual int getCoordinateDimension() const;
    int CoordinateDimension() const;
    virtual OGRBoolean IsEmpty() const = 0;
    virtual OGRBoolean IsValid(std::string *posReason = nullptr) const;
    virtual OGRGeometry *MakeValid(CSLConstList papszOptions = nullptr) const;
    virtual OGRGeometry *Normalize() const;
    virtual OGRBoolean IsSimple() const;

    OGRBoolean Is3D() const
    {
        return (flags & OGR_G_3D) != 0;
    }

    OGRBoolean IsMeasured() const
    {
        return (flags & OGR_G_MEASURED) != 0;
    }
 
    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 size_t WkbSize() const = 0;
    OGRErr importFromWkb(const GByte *, size_t = static_cast<size_t>(-1),
                         OGRwkbVariant = wkbVariantOldOgc);
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) = 0;
    OGRErr exportToWkb(OGRwkbByteOrder, unsigned char *,
                       OGRwkbVariant = wkbVariantOldOgc) const;
    virtual OGRErr exportToWkb(unsigned char *,
                               const OGRwkbExportOptions * = nullptr) const = 0;
    virtual OGRErr importFromWkt(const char **ppszInput) = 0;
 
#ifndef DOXYGEN_XML
    OGRErr importFromWkt(char **ppszInput)
        CPL_WARN_DEPRECATED("Use importFromWkt(const char**) instead")
    {
        return importFromWkt(const_cast<const char **>(ppszInput));
    }
#endif
 
    OGRErr exportToWkt(char **ppszDstText,
                       OGRwkbVariant = wkbVariantOldOgc) const;

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const = 0;
 
    // Non-standard.
    virtual OGRwkbGeometryType getGeometryType() const = 0;
    OGRwkbGeometryType getIsoGeometryType() const;
    virtual const char *getGeometryName() const = 0;
    void dumpReadable(FILE *, const char * = nullptr,
                      CSLConstList papszOptions = nullptr) const;
    std::string dumpReadable(const char * = nullptr,
                             CSLConstList papszOptions = nullptr) const;
    virtual void flattenTo2D() = 0;
    virtual char *exportToGML(const char *const *papszOptions = nullptr) const;
    virtual char *exportToKML() const;
    virtual char *exportToJson(CSLConstList papszOptions = nullptr) const;

    virtual void accept(IOGRGeometryVisitor *visitor) = 0;

    virtual void accept(IOGRConstGeometryVisitor *visitor) const = 0;
 
    static GEOSContextHandle_t createGEOSContext();
    static void freeGEOSContext(GEOSContextHandle_t hGEOSCtxt);
    GEOSGeom
    exportToGEOS(GEOSContextHandle_t hGEOSCtxt, bool bRemoveEmptyParts = false,
                 bool bAddPointsIfNeeded = false) const CPL_WARN_UNUSED_RESULT;
    virtual OGRBoolean hasCurveGeometry(int bLookForNonLinear = FALSE) const;
    virtual OGRGeometry *getCurveGeometry(
        const char *const *papszOptions = nullptr) const CPL_WARN_UNUSED_RESULT;
    virtual OGRGeometry *getLinearGeometry(
        double dfMaxAngleStepSizeDegrees = 0,
        const char *const *papszOptions = nullptr) const CPL_WARN_UNUSED_RESULT;
 
    void roundCoordinates(const OGRGeomCoordinatePrecision &sPrecision);
    void
    roundCoordinatesIEEE754(const OGRGeomCoordinateBinaryPrecision &options);
 
    // SFCGAL interfacing methods.
    static sfcgal_geometry_t *OGRexportToSFCGAL(const OGRGeometry *poGeom);
    static OGRGeometry *SFCGALexportToOGR(const sfcgal_geometry_t *_geometry);
    virtual void closeRings();
 
    virtual bool setCoordinateDimension(int nDimension);
    virtual bool set3D(OGRBoolean bIs3D);
    virtual bool setMeasured(OGRBoolean bIsMeasured);
 
    virtual void assignSpatialReference(const OGRSpatialReference *poSR);
 
    const OGRSpatialReference *getSpatialReference(void) const
    {
        return poSRS;
    }
 
    virtual OGRErr transform(OGRCoordinateTransformation *poCT) = 0;
    OGRErr transformTo(const OGRSpatialReference *poSR);
 
    virtual bool segmentize(double dfMaxLength);
 
    // ISpatialRelation
    virtual OGRBoolean Intersects(const OGRGeometry *) const;
    virtual OGRBoolean Equals(const OGRGeometry *) const = 0;
    OGRBoolean Disjoint(const OGRGeometry *) const;
    OGRBoolean Touches(const OGRGeometry *) const;
    OGRBoolean Crosses(const OGRGeometry *) const;
    virtual OGRBoolean Within(const OGRGeometry *) const;
    virtual OGRBoolean Contains(const OGRGeometry *) const;
    OGRBoolean Overlaps(const OGRGeometry *) const;
 
    OGRGeometry *Boundary() const CPL_WARN_UNUSED_RESULT;
 
    double Distance(const OGRGeometry *) const;
 
    OGRGeometry *ConvexHull() const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *ConcaveHull(double dfRatio,
                             bool bAllowHoles) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *
    ConcaveHullOfPolygons(double dfLengthRatio, bool bIsTight,
                          bool bAllowHoles) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *Buffer(double dfDist,
                        int nQuadSegs = 30) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *
    BufferEx(double dfDist,
             CSLConstList papszOptions) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *Intersection(const OGRGeometry *) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *Union(const OGRGeometry *) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *UnionCascaded() const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *UnaryUnion() const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *Difference(const OGRGeometry *) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *
    SymDifference(const OGRGeometry *) const CPL_WARN_UNUSED_RESULT;
 
    OGRErr Centroid(OGRPoint *poPoint) const;
 
    OGRGeometry *Simplify(double dTolerance) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *
    SimplifyPreserveTopology(double dTolerance) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *
    DelaunayTriangulation(double dfTolerance,
                          int bOnlyEdges) const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *
    ConstrainedDelaunayTriangulation() const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *Polygonize() const CPL_WARN_UNUSED_RESULT;
 
    OGRGeometry *BuildArea() const CPL_WARN_UNUSED_RESULT;
 
    double Distance3D(const OGRGeometry *poOtherGeom) const;
 
    OGRGeometry *SetPrecision(double dfGridSize, int nFlags) const;
 
    virtual bool hasEmptyParts() const;
    virtual void removeEmptyParts();

    // 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();
 
    bool IsRectangle() const;

    static OGRGeometry *CastToIdentity(OGRGeometry *poGeom)
    {
        return poGeom;
    }
 
    static OGRGeometry *CastToError(OGRGeometry *poGeom);


    static inline OGRGeometryH ToHandle(OGRGeometry *poGeom)
    {
        return reinterpret_cast<OGRGeometryH>(poGeom);
    }

    static inline OGRGeometry *FromHandle(OGRGeometryH hGeom)
    {
        return reinterpret_cast<OGRGeometry *>(hGeom);
    }

    inline OGRPoint *toPoint()
    {
        return cpl::down_cast<OGRPoint *>(this);
    }

    inline const OGRPoint *toPoint() const
    {
        return cpl::down_cast<const OGRPoint *>(this);
    }

    inline OGRCurve *toCurve()
    {
        return cpl::down_cast<OGRCurve *>(this);
    }

    inline const OGRCurve *toCurve() const
    {
        return cpl::down_cast<const OGRCurve *>(this);
    }

    inline OGRSimpleCurve *toSimpleCurve()
    {
        return cpl::down_cast<OGRSimpleCurve *>(this);
    }

    inline const OGRSimpleCurve *toSimpleCurve() const
    {
        return cpl::down_cast<const OGRSimpleCurve *>(this);
    }

    inline OGRLineString *toLineString()
    {
        return cpl::down_cast<OGRLineString *>(this);
    }

    inline const OGRLineString *toLineString() const
    {
        return cpl::down_cast<const OGRLineString *>(this);
    }

    inline OGRLinearRing *toLinearRing()
    {
        return cpl::down_cast<OGRLinearRing *>(this);
    }

    inline const OGRLinearRing *toLinearRing() const
    {
        return cpl::down_cast<const OGRLinearRing *>(this);
    }

    inline OGRCircularString *toCircularString()
    {
        return cpl::down_cast<OGRCircularString *>(this);
    }

    inline const OGRCircularString *toCircularString() const
    {
        return cpl::down_cast<const OGRCircularString *>(this);
    }

    inline OGRCompoundCurve *toCompoundCurve()
    {
        return cpl::down_cast<OGRCompoundCurve *>(this);
    }

    inline const OGRCompoundCurve *toCompoundCurve() const
    {
        return cpl::down_cast<const OGRCompoundCurve *>(this);
    }

    inline OGRSurface *toSurface()
    {
        return cpl::down_cast<OGRSurface *>(this);
    }

    inline const OGRSurface *toSurface() const
    {
        return cpl::down_cast<const OGRSurface *>(this);
    }

    inline OGRPolygon *toPolygon()
    {
        return cpl::down_cast<OGRPolygon *>(this);
    }

    inline const OGRPolygon *toPolygon() const
    {
        return cpl::down_cast<const OGRPolygon *>(this);
    }

    inline OGRTriangle *toTriangle()
    {
        return cpl::down_cast<OGRTriangle *>(this);
    }

    inline const OGRTriangle *toTriangle() const
    {
        return cpl::down_cast<const OGRTriangle *>(this);
    }

    inline OGRCurvePolygon *toCurvePolygon()
    {
        return cpl::down_cast<OGRCurvePolygon *>(this);
    }

    inline const OGRCurvePolygon *toCurvePolygon() const
    {
        return cpl::down_cast<const OGRCurvePolygon *>(this);
    }

    inline OGRGeometryCollection *toGeometryCollection()
    {
        return cpl::down_cast<OGRGeometryCollection *>(this);
    }

    inline const OGRGeometryCollection *toGeometryCollection() const
    {
        return cpl::down_cast<const OGRGeometryCollection *>(this);
    }

    inline OGRMultiPoint *toMultiPoint()
    {
        return cpl::down_cast<OGRMultiPoint *>(this);
    }

    inline const OGRMultiPoint *toMultiPoint() const
    {
        return cpl::down_cast<const OGRMultiPoint *>(this);
    }

    inline OGRMultiLineString *toMultiLineString()
    {
        return cpl::down_cast<OGRMultiLineString *>(this);
    }

    inline const OGRMultiLineString *toMultiLineString() const
    {
        return cpl::down_cast<const OGRMultiLineString *>(this);
    }

    inline OGRMultiPolygon *toMultiPolygon()
    {
        return cpl::down_cast<OGRMultiPolygon *>(this);
    }

    inline const OGRMultiPolygon *toMultiPolygon() const
    {
        return cpl::down_cast<const OGRMultiPolygon *>(this);
    }

    inline OGRMultiCurve *toMultiCurve()
    {
        return cpl::down_cast<OGRMultiCurve *>(this);
    }

    inline const OGRMultiCurve *toMultiCurve() const
    {
        return cpl::down_cast<const OGRMultiCurve *>(this);
    }

    inline OGRMultiSurface *toMultiSurface()
    {
        return cpl::down_cast<OGRMultiSurface *>(this);
    }

    inline const OGRMultiSurface *toMultiSurface() const
    {
        return cpl::down_cast<const OGRMultiSurface *>(this);
    }

    inline OGRPolyhedralSurface *toPolyhedralSurface()
    {
        return cpl::down_cast<OGRPolyhedralSurface *>(this);
    }

    inline const OGRPolyhedralSurface *toPolyhedralSurface() const
    {
        return cpl::down_cast<const OGRPolyhedralSurface *>(this);
    }

    inline OGRTriangulatedSurface *toTriangulatedSurface()
    {
        return cpl::down_cast<OGRTriangulatedSurface *>(this);
    }

    inline const OGRTriangulatedSurface *toTriangulatedSurface() const
    {
        return cpl::down_cast<const OGRTriangulatedSurface *>(this);
    }
};

struct CPL_DLL OGRGeometryUniquePtrDeleter
{
    void operator()(OGRGeometry *) const;
};


typedef std::unique_ptr<OGRGeometry, OGRGeometryUniquePtrDeleter>
    OGRGeometryUniquePtr;

#define OGR_FORBID_DOWNCAST_TO(name)                                           \
    inline OGR##name *to##name() = delete;                                     \
    inline const OGR##name *to##name() const = delete;
 
#define OGR_FORBID_DOWNCAST_TO_POINT OGR_FORBID_DOWNCAST_TO(Point)
#define OGR_FORBID_DOWNCAST_TO_CURVE OGR_FORBID_DOWNCAST_TO(Curve)
#define OGR_FORBID_DOWNCAST_TO_SIMPLE_CURVE OGR_FORBID_DOWNCAST_TO(SimpleCurve)
#define OGR_FORBID_DOWNCAST_TO_LINESTRING OGR_FORBID_DOWNCAST_TO(LineString)
#define OGR_FORBID_DOWNCAST_TO_LINEARRING OGR_FORBID_DOWNCAST_TO(LinearRing)
#define OGR_FORBID_DOWNCAST_TO_CIRCULARSTRING                                  \
    OGR_FORBID_DOWNCAST_TO(CircularString)
#define OGR_FORBID_DOWNCAST_TO_COMPOUNDCURVE                                   \
    OGR_FORBID_DOWNCAST_TO(CompoundCurve)
#define OGR_FORBID_DOWNCAST_TO_SURFACE OGR_FORBID_DOWNCAST_TO(Surface)
#define OGR_FORBID_DOWNCAST_TO_CURVEPOLYGON OGR_FORBID_DOWNCAST_TO(CurvePolygon)
#define OGR_FORBID_DOWNCAST_TO_POLYGON OGR_FORBID_DOWNCAST_TO(Polygon)
#define OGR_FORBID_DOWNCAST_TO_TRIANGLE OGR_FORBID_DOWNCAST_TO(Triangle)
#define OGR_FORBID_DOWNCAST_TO_MULTIPOINT OGR_FORBID_DOWNCAST_TO(MultiPoint)
#define OGR_FORBID_DOWNCAST_TO_MULTICURVE OGR_FORBID_DOWNCAST_TO(MultiCurve)
#define OGR_FORBID_DOWNCAST_TO_MULTILINESTRING                                 \
    OGR_FORBID_DOWNCAST_TO(MultiLineString)
#define OGR_FORBID_DOWNCAST_TO_MULTISURFACE OGR_FORBID_DOWNCAST_TO(MultiSurface)
#define OGR_FORBID_DOWNCAST_TO_MULTIPOLYGON OGR_FORBID_DOWNCAST_TO(MultiPolygon)
#define OGR_FORBID_DOWNCAST_TO_GEOMETRYCOLLECTION                              \
    OGR_FORBID_DOWNCAST_TO(GeometryCollection)
#define OGR_FORBID_DOWNCAST_TO_POLYHEDRALSURFACE                               \
    OGR_FORBID_DOWNCAST_TO(PolyhedralSurface)
#define OGR_FORBID_DOWNCAST_TO_TIN OGR_FORBID_DOWNCAST_TO(TriangulatedSurface)
 
#define OGR_ALLOW_UPCAST_TO(name)                                              \
    inline OGR##name *to##name()                                               \
    {                                                                          \
        return this;                                                           \
    }                                                                          \
    inline const OGR##name *to##name() const                                   \
    {                                                                          \
        return this;                                                           \
    }
 
#ifndef SUPPRESS_OGR_ALLOW_CAST_TO_THIS_WARNING
#define CAST_TO_THIS_WARNING CPL_WARN_DEPRECATED("Casting to this is useless")
#else
#define CAST_TO_THIS_WARNING
#endif
 
#define OGR_ALLOW_CAST_TO_THIS(name)                                           \
    inline OGR##name *to##name() CAST_TO_THIS_WARNING                          \
    {                                                                          \
        return this;                                                           \
    }                                                                          \
    inline const OGR##name *to##name() const CAST_TO_THIS_WARNING              \
    {                                                                          \
        return this;                                                           \
    }
 
#define OGR_FORBID_DOWNCAST_TO_ALL_CURVES                                      \
    OGR_FORBID_DOWNCAST_TO_CURVE                                               \
    OGR_FORBID_DOWNCAST_TO_SIMPLE_CURVE                                        \
    OGR_FORBID_DOWNCAST_TO_LINESTRING                                          \
    OGR_FORBID_DOWNCAST_TO_LINEARRING                                          \
    OGR_FORBID_DOWNCAST_TO_CIRCULARSTRING                                      \
    OGR_FORBID_DOWNCAST_TO_COMPOUNDCURVE
 
#define OGR_FORBID_DOWNCAST_TO_ALL_SURFACES                                    \
    OGR_FORBID_DOWNCAST_TO_SURFACE                                             \
    OGR_FORBID_DOWNCAST_TO_CURVEPOLYGON                                        \
    OGR_FORBID_DOWNCAST_TO_POLYGON                                             \
    OGR_FORBID_DOWNCAST_TO_TRIANGLE                                            \
    OGR_FORBID_DOWNCAST_TO_POLYHEDRALSURFACE                                   \
    OGR_FORBID_DOWNCAST_TO_TIN
 
#define OGR_FORBID_DOWNCAST_TO_ALL_SINGLES                                     \
    OGR_FORBID_DOWNCAST_TO_POINT                                               \
    OGR_FORBID_DOWNCAST_TO_ALL_CURVES                                          \
    OGR_FORBID_DOWNCAST_TO_ALL_SURFACES
 
#define OGR_FORBID_DOWNCAST_TO_ALL_MULTI                                       \
    OGR_FORBID_DOWNCAST_TO_GEOMETRYCOLLECTION                                  \
    OGR_FORBID_DOWNCAST_TO_MULTIPOINT                                          \
    OGR_FORBID_DOWNCAST_TO_MULTICURVE                                          \
    OGR_FORBID_DOWNCAST_TO_MULTILINESTRING                                     \
    OGR_FORBID_DOWNCAST_TO_MULTISURFACE                                        \
    OGR_FORBID_DOWNCAST_TO_MULTIPOLYGON

 
/************************************************************************/
/*                               OGRPoint                               */
/************************************************************************/

 
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);
    OGRPoint(OGRPoint &&other) = default;
    static OGRPoint *createXYM(double x, double y, double m);
 
    OGRPoint &operator=(const OGRPoint &other);
    OGRPoint &operator=(OGRPoint &&other) = default;
 
    // IWks Interface
    size_t WkbSize() const override;
    OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                         size_t &nBytesConsumedOut) override;
    OGRErr exportToWkb(unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IGeometry
    int getDimension() const override;
    OGRPoint *clone() const override;
    void empty() override;
    void getEnvelope(OGREnvelope *psEnvelope) const override;
    void getEnvelope(OGREnvelope3D *psEnvelope) const override;
 
    OGRBoolean IsEmpty() const override
    {
        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
    bool setCoordinateDimension(int nDimension) override;

    void setX(double xIn)
    {
        x = xIn;
        if (std::isnan(x) || std::isnan(y))
            flags &= ~OGR_G_NOT_EMPTY_POINT;
        else
            flags |= OGR_G_NOT_EMPTY_POINT;
    }

    void setY(double yIn)
    {
        y = yIn;
        if (std::isnan(x) || std::isnan(y))
            flags &= ~OGR_G_NOT_EMPTY_POINT;
        else
            flags |= OGR_G_NOT_EMPTY_POINT;
    }

    void setZ(double zIn)
    {
        z = zIn;
        flags |= OGR_G_3D;
    }

    void setM(double mIn)
    {
        m = mIn;
        flags |= OGR_G_MEASURED;
    }
 
    // ISpatialRelation
    OGRBoolean Equals(const OGRGeometry *) const override;
    OGRBoolean Intersects(const OGRGeometry *) const override;
    OGRBoolean Within(const OGRGeometry *) const override;
 
    // Non standard from OGRGeometry
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRErr transform(OGRCoordinateTransformation *poCT) override;
    void flattenTo2D() override;
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    void swapXY() override;
 
    OGR_ALLOW_CAST_TO_THIS(Point)
    OGR_FORBID_DOWNCAST_TO_ALL_CURVES
    OGR_FORBID_DOWNCAST_TO_ALL_SURFACES
    OGR_FORBID_DOWNCAST_TO_ALL_MULTI
};
 
/************************************************************************/
/*                           OGRPointIterator                           */
/************************************************************************/

 
class CPL_DLL OGRPointIterator
{
  public:
    virtual ~OGRPointIterator();
    virtual OGRBoolean getNextPoint(OGRPoint *p) = 0;
 
    static void destroy(OGRPointIterator *);
};
 
/************************************************************************/
/*                               OGRCurve                               */
/************************************************************************/

 
class CPL_DLL OGRCurve : public OGRGeometry
{
  protected:
    OGRCurve() = default;
    OGRCurve(const OGRCurve &other) = default;
    OGRCurve(OGRCurve &&other) = default;
 
    virtual OGRCurveCasterToLineString GetCasterToLineString() const = 0;
    virtual OGRCurveCasterToLinearRing GetCasterToLinearRing() const = 0;
 
    friend class OGRCurvePolygon;
    friend class OGRCompoundCurve;
    virtual int ContainsPoint(const OGRPoint *p) const;
    virtual int IntersectsPoint(const OGRPoint *p) const;
    virtual double get_AreaOfCurveSegments() const = 0;
 
  private:
    class CPL_DLL ConstIterator
    {
        struct Private;
        std::unique_ptr<Private> m_poPrivate;
 
      public:
        ConstIterator(const OGRCurve *poSelf, bool bStart);
        ConstIterator(ConstIterator &&oOther) noexcept;
        ConstIterator &operator=(ConstIterator &&oOther);
        ~ConstIterator();
        const OGRPoint &operator*() const;
        ConstIterator &operator++();
        bool operator!=(const ConstIterator &it) const;
    };
 
    friend inline ConstIterator begin(const OGRCurve *);
    friend inline ConstIterator end(const OGRCurve *);
 
  public:
    OGRCurve &operator=(const OGRCurve &other);
    OGRCurve &operator=(OGRCurve &&other) = default;

    typedef OGRPoint ChildType;

    ConstIterator begin() const;
    ConstIterator end() const;
 
    // IGeometry
    OGRCurve *clone() const override = 0;
 
    // 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 = nullptr) const = 0;
    int getDimension() const override;
 
    // non standard
    virtual int getNumPoints() const = 0;
    virtual OGRPointIterator *getPointIterator() const = 0;
    virtual OGRBoolean IsConvex() const;
    virtual double get_Area() const = 0;
    virtual double get_GeodesicArea(
        const OGRSpatialReference *poSRSOverride = nullptr) const = 0;
    virtual double get_GeodesicLength(
        const OGRSpatialReference *poSRSOverride = nullptr) const = 0;
    virtual int isClockwise() const;
    virtual void reversePoints() = 0;

    inline OGRSimpleCurve *toSimpleCurve()
    {
        return cpl::down_cast<OGRSimpleCurve *>(this);
    }

    inline const OGRSimpleCurve *toSimpleCurve() const
    {
        return cpl::down_cast<const OGRSimpleCurve *>(this);
    }
 
    static OGRCompoundCurve *CastToCompoundCurve(OGRCurve *puCurve);
    static OGRLineString *CastToLineString(OGRCurve *poCurve);
    static OGRLinearRing *CastToLinearRing(OGRCurve *poCurve);
 
    OGR_FORBID_DOWNCAST_TO_POINT
    OGR_ALLOW_CAST_TO_THIS(Curve)
    OGR_FORBID_DOWNCAST_TO_ALL_SURFACES
    OGR_FORBID_DOWNCAST_TO_ALL_MULTI
};


inline OGRCurve::ConstIterator begin(const OGRCurve *poCurve)
{
    return poCurve->begin();
}

inline OGRCurve::ConstIterator end(const OGRCurve *poCurve)
{
    return poCurve->end();
}

 
/************************************************************************/
/*                           OGRIteratedPoint                           */
/************************************************************************/

class CPL_DLL OGRIteratedPoint : public OGRPoint
{
  private:
    friend class OGRSimpleCurve;
 
    OGRSimpleCurve *m_poCurve = nullptr;
    int m_nPos = 0;
 
    OGRIteratedPoint() = default;
 
    CPL_DISALLOW_COPY_ASSIGN(OGRIteratedPoint)
 
  public:
    void setX(double xIn);
    void setY(double yIn);
    void setZ(double zIn);
    void setM(double mIn);

    ~OGRIteratedPoint() override;
};
 
/************************************************************************/
/*                            OGRSimpleCurve                            */
/************************************************************************/

 
class CPL_DLL OGRSimpleCurve : public OGRCurve
{
  protected:
    friend class OGRGeometry;
 
    int nPointCount = 0;
    int m_nPointCapacity = 0;
    OGRRawPoint *paoPoints = nullptr;
    double *padfZ = nullptr;
    double *padfM = nullptr;
 
    bool Make3D();
    void Make2D();
    void RemoveM();
    bool AddM();
 
    OGRErr importFromWKTListOnly(const char **ppszInput, int bHasZ, int bHasM,
                                 OGRRawPoint *&paoPointsIn, int &nMaxPoints,
                                 double *&padfZIn);
 
    virtual double get_LinearArea() const;

    OGRSimpleCurve() = default;
 
    OGRSimpleCurve(const OGRSimpleCurve &other);
 
    OGRSimpleCurve(OGRSimpleCurve &&other);
 
  private:
    class CPL_DLL Iterator
    {
        struct Private;
        std::unique_ptr<Private> m_poPrivate;
        void update();
 
      public:
        Iterator(OGRSimpleCurve *poSelf, int nPos);
        Iterator(Iterator &&oOther) noexcept;  // declared but not defined.
                                               // Needed for gcc 5.4 at least
        ~Iterator();
        OGRIteratedPoint &operator*();
        Iterator &operator++();
        bool operator!=(const Iterator &it) const;
    };
 
    friend inline Iterator begin(OGRSimpleCurve *);
    friend inline Iterator end(OGRSimpleCurve *);
 
    class CPL_DLL ConstIterator
    {
        struct Private;
        std::unique_ptr<Private> m_poPrivate;
 
      public:
        ConstIterator(const OGRSimpleCurve *poSelf, int nPos);
        ConstIterator(
            ConstIterator &&oOther) noexcept;  // declared but not defined.
                                               // Needed for gcc 5.4 at least
        ~ConstIterator();
        const OGRPoint &operator*() const;
        ConstIterator &operator++();
        bool operator!=(const ConstIterator &it) const;
    };
 
    friend inline ConstIterator begin(const OGRSimpleCurve *);
    friend inline ConstIterator end(const OGRSimpleCurve *);
 
  public:
    ~OGRSimpleCurve() override;
 
    OGRSimpleCurve &operator=(const OGRSimpleCurve &other);
 
    OGRSimpleCurve &operator=(OGRSimpleCurve &&other);

    typedef OGRPoint ChildType;

    Iterator begin();
    Iterator end();
    ConstIterator begin() const;
    ConstIterator end() const;
 
    // IWks Interface.
    size_t WkbSize() const override;
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
    virtual OGRErr
    exportToWkb(unsigned char *,
                const OGRwkbExportOptions * = nullptr) const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IGeometry interface.
    void empty() override;
    void getEnvelope(OGREnvelope *psEnvelope) const override;
    void getEnvelope(OGREnvelope3D *psEnvelope) const override;
    OGRBoolean IsEmpty() const override;
    OGRSimpleCurve *clone() const override = 0;
 
    // ICurve methods.
    double get_Length() const override;
    void StartPoint(OGRPoint *) const override;
    void EndPoint(OGRPoint *) const override;
    void Value(double, OGRPoint *) const override;
    virtual double Project(const OGRPoint *) const;
    virtual OGRLineString *getSubLine(double, double, int) const;
 
    // ILineString methods.
    int getNumPoints() const override
    {
        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
    OGRBoolean Equals(const OGRGeometry *) const override;
 
    // non standard.
    bool setCoordinateDimension(int nDimension) override;
    bool set3D(OGRBoolean bIs3D) override;
    bool setMeasured(OGRBoolean bIsMeasured) override;
    bool setNumPoints(int nNewPointCount, int bZeroizeNewContent = TRUE);
    bool setPoint(int, OGRPoint *);
    bool setPoint(int, double, double);
    bool setZ(int, double);
    bool setM(int, double);
    bool setPoint(int, double, double, double);
    bool setPointM(int, double, double, double);
    bool setPoint(int, double, double, double, double);
    bool setPoints(int, const OGRRawPoint *, const double * = nullptr);
    bool setPointsM(int, const OGRRawPoint *, const double *);
    bool setPoints(int, const OGRRawPoint *, const double *, const double *);
    bool setPoints(int, const double *padfX, const double *padfY,
                   const double *padfZIn = nullptr);
    bool setPointsM(int, const double *padfX, const double *padfY,
                    const double *padfMIn = nullptr);
    bool setPoints(int, const double *padfX, const double *padfY,
                   const double *padfZIn, const double *padfMIn);
    bool addPoint(const OGRPoint *);
    bool addPoint(double, double);
    bool addPoint(double, double, double);
    bool addPointM(double, double, double);
    bool addPoint(double, double, double, double);
 
    bool removePoint(int);
 
    void getPoints(OGRRawPoint *, double * = nullptr) const;
    void getPoints(void *pabyX, int nXStride, void *pabyY, int nYStride,
                   void *pabyZ = nullptr, int nZStride = 0,
                   void *pabyM = nullptr, int nMStride = 0) const;
 
    void addSubLineString(const OGRLineString *, int nStartVertex = 0,
                          int nEndVertex = -1);
    void reversePoints() override;
    OGRPointIterator *getPointIterator() const override;
 
    // non-standard from OGRGeometry
    OGRErr transform(OGRCoordinateTransformation *poCT) override;
    void flattenTo2D() override;
    bool segmentize(double dfMaxLength) override;
 
    void swapXY() override;
 
    OGR_ALLOW_UPCAST_TO(Curve)
    OGR_ALLOW_CAST_TO_THIS(SimpleCurve)
};


inline OGRSimpleCurve::Iterator begin(OGRSimpleCurve *poCurve)
{
    return poCurve->begin();
}

inline OGRSimpleCurve::Iterator end(OGRSimpleCurve *poCurve)
{
    return poCurve->end();
}

inline OGRSimpleCurve::ConstIterator begin(const OGRSimpleCurve *poCurve)
{
    return poCurve->begin();
}

inline OGRSimpleCurve::ConstIterator end(const OGRSimpleCurve *poCurve)
{
    return poCurve->end();
}

 
/************************************************************************/
/*                            OGRLineString                             */
/************************************************************************/

 
class CPL_DLL OGRLineString : public OGRSimpleCurve
{
    // cppcheck-suppress unusedPrivateFunction
    static OGRLinearRing *CasterToLinearRing(OGRCurve *poCurve);
 
  protected:
    static OGRLineString *TransferMembersAndDestroy(OGRLineString *poSrc,
                                                    OGRLineString *poDst);
 
    OGRCurveCasterToLineString GetCasterToLineString() const override;
    OGRCurveCasterToLinearRing GetCasterToLinearRing() const override;
 
    double get_AreaOfCurveSegments() const override;
 
    static OGRLinearRing *CastToLinearRing(OGRLineString *poLS);
 
  public:
    OGRLineString() = default;
    OGRLineString(const OGRLineString &other);
    OGRLineString(OGRLineString &&other);
 
    OGRLineString &operator=(const OGRLineString &other);
    OGRLineString &operator=(OGRLineString &&other);
 
    OGRLineString *clone() const override;
    virtual OGRLineString *
    CurveToLine(double dfMaxAngleStepSizeDegrees = 0,
                const char *const *papszOptions = nullptr) const override;
    virtual OGRGeometry *
    getCurveGeometry(const char *const *papszOptions = nullptr) const override;
    double get_Area() const override;
    virtual double get_GeodesicArea(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
    virtual double get_GeodesicLength(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
 
    // Non-standard from OGRGeometry.
    OGRwkbGeometryType getGeometryType() const override;
    const char *getGeometryName() const override;
    int isClockwise() const override;

    inline OGRSimpleCurve *toUpperClass()
    {
        return this;
    }

    inline const OGRSimpleCurve *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    OGR_ALLOW_UPCAST_TO(SimpleCurve)
    OGR_ALLOW_CAST_TO_THIS(LineString)
};
 
/************************************************************************/
/*                            OGRLinearRing                             */
/************************************************************************/

 
class CPL_DLL OGRLinearRing : public OGRLineString
{
    static OGRLineString *CasterToLineString(OGRCurve *poCurve);
 
    // 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.
    size_t WkbSize() const override;
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
    OGRErr exportToWkb(unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const override;
 
  protected:
    friend class OGRPolygon;
    friend class OGRTriangle;
 
    // These are not IWks compatible ... just a convenience for OGRPolygon.
    virtual size_t _WkbSize(int _flags) const;
    virtual OGRErr _importFromWkb(OGRwkbByteOrder, int _flags,
                                  const unsigned char *, size_t,
                                  size_t &nBytesConsumedOut);
    virtual OGRErr _exportToWkb(int _flags, unsigned char *,
                                const OGRwkbExportOptions *) const;
 
    OGRCurveCasterToLineString GetCasterToLineString() const override;
    OGRCurveCasterToLinearRing GetCasterToLinearRing() const override;
 
    static OGRLineString *CastToLineString(OGRLinearRing *poLR);
 
  public:
    OGRLinearRing() = default;
    OGRLinearRing(const OGRLinearRing &other);
    OGRLinearRing(OGRLinearRing &&other) = default;
    explicit OGRLinearRing(const OGRLinearRing *);
 
    OGRLinearRing &operator=(const OGRLinearRing &other);
    OGRLinearRing &operator=(OGRLinearRing &&other) = default;
 
    // Non standard.
    const char *getGeometryName() const override;
    OGRLinearRing *clone() const override;

    void reverseWindingOrder()
        CPL_WARN_DEPRECATED("Use reversePoints() instead");
 
    void closeRings() override;
    OGRBoolean isPointInRing(const OGRPoint *pt,
                             int bTestEnvelope = TRUE) const;
    OGRBoolean isPointOnRingBoundary(const OGRPoint *pt,
                                     int bTestEnvelope = TRUE) const;
    OGRErr transform(OGRCoordinateTransformation *poCT) override;

    inline OGRLineString *toUpperClass()
    {
        return this;
    }

    inline const OGRLineString *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    OGR_ALLOW_UPCAST_TO(LineString)
    OGR_ALLOW_CAST_TO_THIS(LinearRing)
};
 
/************************************************************************/
/*                          OGRCircularString                           */
/************************************************************************/

 
class CPL_DLL OGRCircularString : public OGRSimpleCurve
{
  private:
    void ExtendEnvelopeWithCircular(OGREnvelope *psEnvelope) const;
    OGRBoolean IsValidFast(std::string *posReason = nullptr) const;
    int IsFullCircle(double &cx, double &cy, double &square_R) const;
 
  protected:
    OGRCurveCasterToLineString GetCasterToLineString() const override;
    OGRCurveCasterToLinearRing GetCasterToLinearRing() const override;
    int IntersectsPoint(const OGRPoint *p) const override;
    int ContainsPoint(const OGRPoint *p) const override;
    double get_AreaOfCurveSegments() const override;
 
  public:
    OGRCircularString() = default;
 
    OGRCircularString(const OGRCircularString &other);
    OGRCircularString(OGRCircularString &&other) = default;
 
    OGRCircularString &operator=(const OGRCircularString &other);
    OGRCircularString &operator=(OGRCircularString &&other) = default;
 
    // IWks Interface.
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
    OGRErr exportToWkb(unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IGeometry interface.
    OGRBoolean IsValid(std::string *posReason = nullptr) const override;
    void getEnvelope(OGREnvelope *psEnvelope) const override;
    void getEnvelope(OGREnvelope3D *psEnvelope) const override;
    OGRCircularString *clone() const override;
 
    // ICurve methods.
    double get_Length() const override;
    virtual OGRLineString *
    CurveToLine(double dfMaxAngleStepSizeDegrees = 0,
                const char *const *papszOptions = nullptr) const override;
    void Value(double, OGRPoint *) const override;
    double get_Area() const override;
    virtual double get_GeodesicArea(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
    virtual double get_GeodesicLength(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
 
    // Non-standard from OGRGeometry.
    OGRwkbGeometryType getGeometryType() const override;
    const char *getGeometryName() const override;
    bool segmentize(double dfMaxLength) override;
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;
    virtual OGRGeometry *
    getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
                      const char *const *papszOptions = nullptr) const override;

    inline OGRSimpleCurve *toUpperClass()
    {
        return this;
    }

    inline const OGRSimpleCurve *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    OGR_ALLOW_UPCAST_TO(SimpleCurve)
    OGR_ALLOW_CAST_TO_THIS(CircularString)
};
 
/************************************************************************/
/*                          OGRCurveCollection                          */
/************************************************************************/


class CPL_DLL OGRCurveCollection
{
  protected:
    friend class OGRCompoundCurve;
    friend class OGRCurvePolygon;
    friend class OGRPolygon;
    friend class OGRTriangle;
 
    int nCurveCount = 0;
    OGRCurve **papoCurves = nullptr;
 
  public:
    OGRCurveCollection() = default;
    OGRCurveCollection(const OGRCurveCollection &other);
    OGRCurveCollection(OGRCurveCollection &&other);
    ~OGRCurveCollection();
 
    OGRCurveCollection &operator=(const OGRCurveCollection &other);
    OGRCurveCollection &operator=(OGRCurveCollection &&other);

    typedef OGRCurve ChildType;

    OGRCurve **begin()
    {
        return papoCurves;
    }

    OGRCurve **end()
    {
        return papoCurves + nCurveCount;
    }

    const OGRCurve *const *begin() const
    {
        return papoCurves;
    }

    const OGRCurve *const *end() const
    {
        return papoCurves + nCurveCount;
    }
 
    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);
    size_t WkbSize() const;
    OGRErr importPreambleFromWkb(OGRGeometry *poGeom,
                                 const unsigned char *pabyData, size_t &nSize,
                                 size_t &nDataOffset,
                                 OGRwkbByteOrder &eByteOrder,
                                 size_t nMinSubGeomSize,
                                 OGRwkbVariant eWkbVariant);
    OGRErr
    importBodyFromWkb(OGRGeometry *poGeom, const unsigned char *pabyData,
                      size_t nSize, bool bAcceptCompoundCurve,
                      OGRErr (*pfnAddCurveDirectlyFromWkb)(OGRGeometry *poGeom,
                                                           OGRCurve *poCurve),
                      OGRwkbVariant eWkbVariant, size_t &nBytesConsumedOut);
    std::string exportToWkt(const OGRGeometry *geom, const OGRWktOptions &opts,
                            OGRErr *err) const;
    OGRErr exportToWkb(const OGRGeometry *poGeom, unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const;
    OGRBoolean Equals(const OGRCurveCollection *poOCC) const;
    bool setCoordinateDimension(OGRGeometry *poGeom, int nNewDimension);
    bool set3D(OGRGeometry *poGeom, OGRBoolean bIs3D);
    bool setMeasured(OGRGeometry *poGeom, OGRBoolean bIsMeasured);
    void assignSpatialReference(OGRGeometry *poGeom,
                                const OGRSpatialReference *poSR);
    int getNumCurves() const;
    OGRCurve *getCurve(int);
    const OGRCurve *getCurve(int) const;
    OGRCurve *stealCurve(int);
 
    OGRErr removeCurve(int iIndex, bool bDelete = true);
 
    bool hasEmptyParts() const;
    void removeEmptyParts();
 
    void reversePoints();
 
    OGRErr transform(OGRGeometry *poGeom, OGRCoordinateTransformation *poCT);
    void flattenTo2D(OGRGeometry *poGeom);
    bool segmentize(double dfMaxLength);
    void swapXY();
    OGRBoolean hasCurveGeometry(int bLookForNonLinear) const;
};

 
/************************************************************************/
/*                           OGRCompoundCurve                           */
/************************************************************************/

 
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;
    // cppcheck-suppress unusedPrivateFunction
    static OGRLineString *CasterToLineString(OGRCurve *poCurve);
    // cppcheck-suppress unusedPrivateFunction
    static OGRLinearRing *CasterToLinearRing(OGRCurve *poCurve);
 
  protected:
    static OGRLineString *CastToLineString(OGRCompoundCurve *poCC);
    static OGRLinearRing *CastToLinearRing(OGRCompoundCurve *poCC);
 
    OGRCurveCasterToLineString GetCasterToLineString() const override;
    OGRCurveCasterToLinearRing GetCasterToLinearRing() const override;
 
  public:
    OGRCompoundCurve() = default;
 
    OGRCompoundCurve(const OGRCompoundCurve &other);
    OGRCompoundCurve(OGRCompoundCurve &&other) = default;
 
    OGRCompoundCurve &operator=(const OGRCompoundCurve &other);
    OGRCompoundCurve &operator=(OGRCompoundCurve &&other) = default;

    typedef OGRCurve ChildType;

    ChildType **begin()
    {
        return oCC.begin();
    }

    ChildType **end()
    {
        return oCC.end();
    }

    const ChildType *const *begin() const
    {
        return oCC.begin();
    }

    const ChildType *const *end() const
    {
        return oCC.end();
    }
 
    // IWks Interface
    size_t WkbSize() const override;
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
    OGRErr exportToWkb(unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IGeometry interface.
    OGRCompoundCurve *clone() const override;
    void empty() override;
    void getEnvelope(OGREnvelope *psEnvelope) const override;
    void getEnvelope(OGREnvelope3D *psEnvelope) const override;
    OGRBoolean IsEmpty() const override;
 
    // ICurve methods.
    double get_Length() const override;
    void StartPoint(OGRPoint *) const override;
    void EndPoint(OGRPoint *) const override;
    void Value(double, OGRPoint *) const override;
    virtual OGRLineString *
    CurveToLine(double dfMaxAngleStepSizeDegrees = 0,
                const char *const *papszOptions = nullptr) const override;
 
    int getNumPoints() const override;
    double get_AreaOfCurveSegments() const override;
    double get_Area() const override;
    virtual double get_GeodesicArea(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
    virtual double get_GeodesicLength(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
 
    // ISpatialRelation.
    OGRBoolean Equals(const OGRGeometry *) const override;
 
    // ICompoundCurve method.
    int getNumCurves() const;
    OGRCurve *getCurve(int);
    const OGRCurve *getCurve(int) const;
 
    // Non-standard.
    bool setCoordinateDimension(int nDimension) override;
    bool set3D(OGRBoolean bIs3D) override;
    bool setMeasured(OGRBoolean bIsMeasured) override;
 
    virtual void
    assignSpatialReference(const OGRSpatialReference *poSR) override;

    static constexpr double DEFAULT_TOLERANCE_EPSILON = 1e-14;
 
    OGRErr addCurve(const OGRCurve *,
                    double dfToleranceEps = DEFAULT_TOLERANCE_EPSILON);
    OGRErr addCurveDirectly(OGRCurve *,
                            double dfToleranceEps = DEFAULT_TOLERANCE_EPSILON);
    OGRErr addCurve(std::unique_ptr<OGRCurve>,
                    double dfToleranceEps = DEFAULT_TOLERANCE_EPSILON);
    OGRCurve *stealCurve(int);
    OGRPointIterator *getPointIterator() const override;
    void reversePoints() override;
 
    // Non-standard from OGRGeometry.
    OGRwkbGeometryType getGeometryType() const override;
    const char *getGeometryName() const override;
    OGRErr transform(OGRCoordinateTransformation *poCT) override;
    void flattenTo2D() override;
    bool segmentize(double dfMaxLength) override;
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;
    virtual OGRGeometry *
    getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
                      const char *const *papszOptions = nullptr) const override;
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    void swapXY() override;
 
    bool hasEmptyParts() const override;
    void removeEmptyParts() override;
 
    OGR_ALLOW_UPCAST_TO(Curve)
    OGR_ALLOW_CAST_TO_THIS(CompoundCurve)
};


inline const OGRCompoundCurve::ChildType *const *
begin(const OGRCompoundCurve *poCurve)
{
    return poCurve->begin();
}

inline const OGRCompoundCurve::ChildType *const *
end(const OGRCompoundCurve *poCurve)
{
    return poCurve->end();
}

inline OGRCompoundCurve::ChildType **begin(OGRCompoundCurve *poCurve)
{
    return poCurve->begin();
}

inline OGRCompoundCurve::ChildType **end(OGRCompoundCurve *poCurve)
{
    return poCurve->end();
}

 
/************************************************************************/
/*                              OGRSurface                              */
/************************************************************************/

 
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 double get_GeodesicArea(
        const OGRSpatialReference *poSRSOverride = nullptr) const = 0;
    virtual double get_Length() const = 0;
    virtual double get_GeodesicLength(
        const OGRSpatialReference *poSRSOverride = nullptr) const = 0;
 
    virtual OGRErr PointOnSurface(OGRPoint *poPoint) const;
 
    OGRSurface *clone() const override = 0;

    static OGRPolygon *CastToPolygon(OGRSurface *poSurface);
    static OGRCurvePolygon *CastToCurvePolygon(OGRSurface *poSurface);
 
    OGR_FORBID_DOWNCAST_TO_POINT
    OGR_FORBID_DOWNCAST_TO_ALL_CURVES
    OGR_ALLOW_CAST_TO_THIS(Surface)
    OGR_FORBID_DOWNCAST_TO_ALL_MULTI
};
 
/************************************************************************/
/*                           OGRCurvePolygon                            */
/************************************************************************/

 
class CPL_DLL OGRCurvePolygon : public OGRSurface
{
    static OGRPolygon *CasterToPolygon(OGRSurface *poSurface);
 
  private:
    OGRBoolean IntersectsPoint(const OGRPoint *p) const;
    OGRBoolean ContainsPoint(const OGRPoint *p) const;
 
    virtual bool isRingCorrectType(const OGRCurve *poRing) const;
 
    virtual bool checkRing(const 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;
    friend class OGRTriangle;
    OGRCurveCollection oCC{};
 
    OGRSurfaceCasterToPolygon GetCasterToPolygon() const override;
    virtual OGRSurfaceCasterToCurvePolygon
    GetCasterToCurvePolygon() const override;

 
    static OGRPolygon *CastToPolygon(OGRCurvePolygon *poCP);
 
  public:
    OGRCurvePolygon() = default;
 
    OGRCurvePolygon(const OGRCurvePolygon &);
    OGRCurvePolygon(OGRCurvePolygon &&) = default;
 
    OGRCurvePolygon &operator=(const OGRCurvePolygon &other);
    OGRCurvePolygon &operator=(OGRCurvePolygon &&other) = default;

    typedef OGRCurve ChildType;

    ChildType **begin()
    {
        return oCC.begin();
    }

    ChildType **end()
    {
        return oCC.end();
    }

    const ChildType *const *begin() const
    {
        return oCC.begin();
    }

    const ChildType *const *end() const
    {
        return oCC.end();
    }
 
    // Non standard (OGRGeometry).
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRCurvePolygon *clone() const override;
    void empty() override;
    OGRErr transform(OGRCoordinateTransformation *poCT) override;
    void flattenTo2D() override;
    OGRBoolean IsEmpty() const override;
    bool segmentize(double dfMaxLength) override;
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;
    virtual OGRGeometry *
    getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
                      const char *const *papszOptions = nullptr) const override;
    virtual double get_GeodesicArea(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
    virtual double get_GeodesicLength(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
 
    // ISurface Interface
    double get_Area() const override;
 
    double get_Length() const override;
 
    // IWks Interface
    size_t WkbSize() const override;
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
    OGRErr exportToWkb(unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IGeometry
    int getDimension() const override;
    void getEnvelope(OGREnvelope *psEnvelope) const override;
    void getEnvelope(OGREnvelope3D *psEnvelope) const override;
 
    // ICurvePolygon
    virtual OGRPolygon *
    CurvePolyToPoly(double dfMaxAngleStepSizeDegrees = 0,
                    const char *const *papszOptions = nullptr) const;
 
    // ISpatialRelation
    OGRBoolean Equals(const OGRGeometry *) const override;
    OGRBoolean Intersects(const OGRGeometry *) const override;
    OGRBoolean Contains(const OGRGeometry *) const override;
 
    // Non standard
    bool setCoordinateDimension(int nDimension) override;
    bool set3D(OGRBoolean bIs3D) override;
    bool setMeasured(OGRBoolean bIsMeasured) override;
 
    virtual void
    assignSpatialReference(const OGRSpatialReference *poSR) override;
 
    virtual OGRErr addRing(const OGRCurve *);
    virtual OGRErr addRingDirectly(OGRCurve *);
    OGRErr addRing(std::unique_ptr<OGRCurve>);
 
    OGRCurve *getExteriorRingCurve();
    const OGRCurve *getExteriorRingCurve() const;
    int getNumInteriorRings() const;
    OGRCurve *getInteriorRingCurve(int);
    const OGRCurve *getInteriorRingCurve(int) const;
 
    OGRCurve *stealExteriorRingCurve();
 
    OGRErr removeRing(int iIndex, bool bDelete = true);
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    void swapXY() override;
 
    bool hasEmptyParts() const override;
    void removeEmptyParts() override;
 
    OGR_ALLOW_UPCAST_TO(Surface)
    OGR_ALLOW_CAST_TO_THIS(CurvePolygon)
};


inline const OGRCurvePolygon::ChildType *const *
begin(const OGRCurvePolygon *poGeom)
{
    return poGeom->begin();
}

inline const OGRCurvePolygon::ChildType *const *
end(const OGRCurvePolygon *poGeom)
{
    return poGeom->end();
}

inline OGRCurvePolygon::ChildType **begin(OGRCurvePolygon *poGeom)
{
    return poGeom->begin();
}

inline OGRCurvePolygon::ChildType **end(OGRCurvePolygon *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                              OGRPolygon                              */
/************************************************************************/

 
class CPL_DLL OGRPolygon : public OGRCurvePolygon
{
    static OGRCurvePolygon *CasterToCurvePolygon(OGRSurface *poSurface);
 
  protected:
    friend class OGRMultiSurface;
    friend class OGRPolyhedralSurface;
    friend class OGRTriangulatedSurface;
 
    bool isRingCorrectType(const OGRCurve *poRing) const override;
 
    bool checkRing(const OGRCurve *poNewRing) const override;
    virtual OGRErr importFromWKTListOnly(const char **ppszInput, int bHasZ,
                                         int bHasM, OGRRawPoint *&paoPoints,
                                         int &nMaxPoints, double *&padfZ);
 
    static OGRCurvePolygon *CastToCurvePolygon(OGRPolygon *poPoly);
 
    OGRSurfaceCasterToPolygon GetCasterToPolygon() const override;
    virtual OGRSurfaceCasterToCurvePolygon
    GetCasterToCurvePolygon() const override;
 
  public:
    OGRPolygon() = default;
 
    OGRPolygon(double x1, double y1, double x2, double y2);
 
    explicit OGRPolygon(const OGREnvelope &envelope);
 
    OGRPolygon(const OGRPolygon &other);
    OGRPolygon(OGRPolygon &&other) = default;
 
    OGRPolygon &operator=(const OGRPolygon &other);
    OGRPolygon &operator=(OGRPolygon &&other) = default;

    typedef OGRLinearRing ChildType;

    ChildType **begin()
    {
        return reinterpret_cast<ChildType **>(oCC.begin());
    }

    ChildType **end()
    {
        return reinterpret_cast<ChildType **>(oCC.end());
    }

    const ChildType *const *begin() const
    {
        return reinterpret_cast<const ChildType *const *>(oCC.begin());
    }

    const ChildType *const *end() const
    {
        return reinterpret_cast<const ChildType *const *>(oCC.end());
    }
 
    // Non-standard (OGRGeometry).
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRPolygon *clone() const override;
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;
    virtual OGRGeometry *
    getCurveGeometry(const char *const *papszOptions = nullptr) const override;
    virtual OGRGeometry *
    getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
                      const char *const *papszOptions = nullptr) const override;
 
    // IWks Interface.
    size_t WkbSize() const override;
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
    OGRErr exportToWkb(unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // ICurvePolygon.
    virtual OGRPolygon *
    CurvePolyToPoly(double dfMaxAngleStepSizeDegrees = 0,
                    const char *const *papszOptions = nullptr) const override;
 
    OGRLinearRing *getExteriorRing();
    const OGRLinearRing *getExteriorRing() const;
    virtual OGRLinearRing *getInteriorRing(int);
    virtual const OGRLinearRing *getInteriorRing(int) const;
 
    OGRLinearRing *stealExteriorRing();
    virtual OGRLinearRing *stealInteriorRing(int);
 
    OGRBoolean IsPointOnSurface(const OGRPoint *) const;

    inline OGRCurvePolygon *toUpperClass()
    {
        return this;
    }

    inline const OGRCurvePolygon *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    void closeRings() override;
 
    OGR_ALLOW_UPCAST_TO(CurvePolygon)
    OGR_ALLOW_CAST_TO_THIS(Polygon)
};


inline const OGRPolygon::ChildType *const *begin(const OGRPolygon *poGeom)
{
    return poGeom->begin();
}

inline const OGRPolygon::ChildType *const *end(const OGRPolygon *poGeom)
{
    return poGeom->end();
}

inline OGRPolygon::ChildType **begin(OGRPolygon *poGeom)
{
    return poGeom->begin();
}

inline OGRPolygon::ChildType **end(OGRPolygon *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                             OGRTriangle                              */
/************************************************************************/

 
class CPL_DLL OGRTriangle : public OGRPolygon
{
  private:
    // cppcheck-suppress unusedPrivateFunction
    static OGRPolygon *CasterToPolygon(OGRSurface *poSurface);
    bool quickValidityCheck() const;
 
  protected:
    OGRSurfaceCasterToPolygon GetCasterToPolygon() const override;
    virtual OGRErr importFromWKTListOnly(const char **ppszInput, int bHasZ,
                                         int bHasM, OGRRawPoint *&paoPoints,
                                         int &nMaxPoints,
                                         double *&padfZ) override;
 
  public:
    OGRTriangle() = default;
    OGRTriangle(const OGRPoint &p, const OGRPoint &q, const OGRPoint &r);
    OGRTriangle(const OGRTriangle &other);
    OGRTriangle(OGRTriangle &&other) = default;
    OGRTriangle(const OGRPolygon &other, OGRErr &eErr);
    OGRTriangle &operator=(const OGRTriangle &other);
    OGRTriangle &operator=(OGRTriangle &&other) = default;
 
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRTriangle *clone() const override;
 
    // IWks Interface.
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
 
    // New methods rewritten from OGRPolygon/OGRCurvePolygon/OGRGeometry.
    OGRErr addRingDirectly(OGRCurve *poNewRing) override;

    inline OGRPolygon *toUpperClass()
    {
        return this;
    }

    inline const OGRPolygon *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }

    static OGRGeometry *CastToPolygon(OGRGeometry *poGeom);
 
    OGR_ALLOW_UPCAST_TO(Polygon)
    OGR_ALLOW_CAST_TO_THIS(Triangle)
};
 
/************************************************************************/
/*                        OGRGeometryCollection                         */
/************************************************************************/

 
class CPL_DLL OGRGeometryCollection : public OGRGeometry
{
    OGRErr importFromWktInternal(const char **ppszInput, int nRecLevel);
 
  protected:
    int nGeomCount = 0;
    OGRGeometry **papoGeoms = nullptr;
 
    std::string
    exportToWktInternal(const OGRWktOptions &opts, OGRErr *err,
                        const std::string &exclude = std::string()) const;
    static OGRGeometryCollection *
    TransferMembersAndDestroy(OGRGeometryCollection *poSrc,
                              OGRGeometryCollection *poDst);
 
    OGRErr importFromWkbInternal(const unsigned char *pabyData, size_t nSize,
                                 int nRecLevel, OGRwkbVariant,
                                 size_t &nBytesConsumedOut);
    virtual OGRBoolean isCompatibleSubType(OGRwkbGeometryType) const;
 
  public:
    OGRGeometryCollection() = default;
 
    OGRGeometryCollection(const OGRGeometryCollection &other);
    OGRGeometryCollection(OGRGeometryCollection &&other);
    ~OGRGeometryCollection() override;
 
    OGRGeometryCollection &operator=(const OGRGeometryCollection &other);
    OGRGeometryCollection &operator=(OGRGeometryCollection &&other);

    typedef OGRGeometry ChildType;

    ChildType **begin()
    {
        return papoGeoms;
    }

    ChildType **end()
    {
        return papoGeoms + nGeomCount;
    }

    const ChildType *const *begin() const
    {
        return papoGeoms;
    }

    const ChildType *const *end() const
    {
        return papoGeoms + nGeomCount;
    }
 
    // Non standard (OGRGeometry).
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRGeometryCollection *clone() const override;
    void empty() override;
    OGRErr transform(OGRCoordinateTransformation *poCT) override;
    void flattenTo2D() override;
    OGRBoolean IsEmpty() const override;
    bool segmentize(double dfMaxLength) override;
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;
    virtual OGRGeometry *
    getCurveGeometry(const char *const *papszOptions = nullptr) const override;
    virtual OGRGeometry *
    getLinearGeometry(double dfMaxAngleStepSizeDegrees = 0,
                      const char *const *papszOptions = nullptr) const override;
    virtual double
    get_GeodesicArea(const OGRSpatialReference *poSRSOverride = nullptr) const;
    virtual double get_GeodesicLength(
        const OGRSpatialReference *poSRSOverride = nullptr) const;
 
    // IWks Interface
    size_t WkbSize() const override;
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
    OGRErr exportToWkb(unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    virtual double get_Length() const;
    virtual double get_Area() const;
 
    // IGeometry methods
    int getDimension() const override;
    void getEnvelope(OGREnvelope *psEnvelope) const override;
    void getEnvelope(OGREnvelope3D *psEnvelope) const override;
 
    // IGeometryCollection
    int getNumGeometries() const;
    OGRGeometry *getGeometryRef(int);
    const OGRGeometry *getGeometryRef(int) const;
 
    // ISpatialRelation
    OGRBoolean Equals(const OGRGeometry *) const override;
 
    // Non standard
    bool setCoordinateDimension(int nDimension) override;
    bool set3D(OGRBoolean bIs3D) override;
    bool setMeasured(OGRBoolean bIsMeasured) override;
    virtual OGRErr addGeometry(const OGRGeometry *);
    virtual OGRErr addGeometryDirectly(OGRGeometry *);
    OGRErr addGeometry(std::unique_ptr<OGRGeometry> geom);
    OGRErr addGeometryComponents(std::unique_ptr<OGRGeometryCollection> geom);
    virtual OGRErr removeGeometry(int iIndex, int bDelete = TRUE);
    std::unique_ptr<OGRGeometry> stealGeometry(int iIndex);
 
    bool hasEmptyParts() const override;
    void removeEmptyParts() override;
 
    virtual void
    assignSpatialReference(const OGRSpatialReference *poSR) override;
 
    void closeRings() override;
 
    void swapXY() override;
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    static OGRGeometryCollection *
    CastToGeometryCollection(OGRGeometryCollection *poSrc);
 
    OGR_FORBID_DOWNCAST_TO_POINT
    OGR_FORBID_DOWNCAST_TO_ALL_CURVES
    OGR_FORBID_DOWNCAST_TO_ALL_SURFACES
    OGR_ALLOW_CAST_TO_THIS(GeometryCollection)
};


inline const OGRGeometryCollection::ChildType *const *
begin(const OGRGeometryCollection *poGeom)
{
    return poGeom->begin();
}

inline const OGRGeometryCollection::ChildType *const *
end(const OGRGeometryCollection *poGeom)
{
    return poGeom->end();
}

inline OGRGeometryCollection::ChildType **begin(OGRGeometryCollection *poGeom)
{
    return poGeom->begin();
}

inline OGRGeometryCollection::ChildType **end(OGRGeometryCollection *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                           OGRMultiSurface                            */
/************************************************************************/

 
class CPL_DLL OGRMultiSurface : public OGRGeometryCollection
{
  protected:
    OGRBoolean isCompatibleSubType(OGRwkbGeometryType) const override;
 
  public:
    OGRMultiSurface() = default;
 
    OGRMultiSurface(const OGRMultiSurface &other);
    OGRMultiSurface(OGRMultiSurface &&other) = default;
 
    OGRMultiSurface &operator=(const OGRMultiSurface &other);
    OGRMultiSurface &operator=(OGRMultiSurface &&other) = default;

    typedef OGRSurface ChildType;

    ChildType **begin()
    {
        return reinterpret_cast<ChildType **>(papoGeoms);
    }

    ChildType **end()
    {
        return reinterpret_cast<ChildType **>(papoGeoms + nGeomCount);
    }

    const ChildType *const *begin() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms);
    }

    const ChildType *const *end() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms +
                                                          nGeomCount);
    }
 
    // Non standard (OGRGeometry).
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRMultiSurface *clone() const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IMultiSurface methods
    virtual OGRErr PointOnSurface(OGRPoint *poPoint) const;
 
    // IGeometry methods
    int getDimension() const override;
 
    // IGeometryCollection
    OGRSurface *getGeometryRef(int i)
    {
        return OGRGeometryCollection::getGeometryRef(i)->toSurface();
    }

    const OGRSurface *getGeometryRef(int i) const
    {
        return OGRGeometryCollection::getGeometryRef(i)->toSurface();
    }
 
    // Non standard
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;

    inline OGRGeometryCollection *toUpperClass()
    {
        return this;
    }

    inline const OGRGeometryCollection *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    static OGRMultiPolygon *CastToMultiPolygon(OGRMultiSurface *poMS);
 
    OGR_ALLOW_CAST_TO_THIS(MultiSurface)
    OGR_ALLOW_UPCAST_TO(GeometryCollection)
    OGR_FORBID_DOWNCAST_TO_MULTIPOINT
    OGR_FORBID_DOWNCAST_TO_MULTILINESTRING
    OGR_FORBID_DOWNCAST_TO_MULTICURVE
};


inline const OGRMultiSurface::ChildType *const *
begin(const OGRMultiSurface *poGeom)
{
    return poGeom->begin();
}

inline const OGRMultiSurface::ChildType *const *
end(const OGRMultiSurface *poGeom)
{
    return poGeom->end();
}

inline OGRMultiSurface::ChildType **begin(OGRMultiSurface *poGeom)
{
    return poGeom->begin();
}

inline OGRMultiSurface::ChildType **end(OGRMultiSurface *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                           OGRMultiPolygon                            */
/************************************************************************/

 
class CPL_DLL OGRMultiPolygon : public OGRMultiSurface
{
  protected:
    OGRBoolean isCompatibleSubType(OGRwkbGeometryType) const override;
    friend class OGRPolyhedralSurface;
    friend class OGRTriangulatedSurface;
 
  private:
    OGRErr _addGeometryWithExpectedSubGeometryType(
        const OGRGeometry *poNewGeom, OGRwkbGeometryType eSubGeometryType);
    OGRErr _addGeometryDirectlyWithExpectedSubGeometryType(
        OGRGeometry *poNewGeom, OGRwkbGeometryType eSubGeometryType);
 
  public:
    OGRMultiPolygon() = default;
 
    OGRMultiPolygon(const OGRMultiPolygon &other);
    OGRMultiPolygon(OGRMultiPolygon &&other) = default;
 
    OGRMultiPolygon &operator=(const OGRMultiPolygon &other);
    OGRMultiPolygon &operator=(OGRMultiPolygon &&other) = default;

    typedef OGRPolygon ChildType;

    ChildType **begin()
    {
        return reinterpret_cast<ChildType **>(papoGeoms);
    }

    ChildType **end()
    {
        return reinterpret_cast<ChildType **>(papoGeoms + nGeomCount);
    }

    const ChildType *const *begin() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms);
    }

    const ChildType *const *end() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms +
                                                          nGeomCount);
    }
 
    // IGeometryCollection
    OGRPolygon *getGeometryRef(int i)
    {
        return OGRGeometryCollection::getGeometryRef(i)->toPolygon();
    }

    const OGRPolygon *getGeometryRef(int i) const
    {
        return OGRGeometryCollection::getGeometryRef(i)->toPolygon();
    }
 
    // Non-standard (OGRGeometry).
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRMultiPolygon *clone() const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif
 
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // Non standard
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;

    inline OGRGeometryCollection *toUpperClass()
    {
        return this;
    }

    inline const OGRGeometryCollection *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    static OGRMultiSurface *CastToMultiSurface(OGRMultiPolygon *poMP);
 
    OGR_ALLOW_CAST_TO_THIS(MultiPolygon)
    OGR_ALLOW_UPCAST_TO(MultiSurface)
};


inline const OGRMultiPolygon::ChildType *const *
begin(const OGRMultiPolygon *poGeom)
{
    return poGeom->begin();
}

inline const OGRMultiPolygon::ChildType *const *
end(const OGRMultiPolygon *poGeom)
{
    return poGeom->end();
}

inline OGRMultiPolygon::ChildType **begin(OGRMultiPolygon *poGeom)
{
    return poGeom->begin();
}

inline OGRMultiPolygon::ChildType **end(OGRMultiPolygon *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                         OGRPolyhedralSurface                         */
/************************************************************************/

 
class CPL_DLL OGRPolyhedralSurface : public OGRSurface
{
  protected:
    friend class OGRTriangulatedSurface;
    OGRMultiPolygon oMP{};
    OGRSurfaceCasterToPolygon GetCasterToPolygon() const override;
    virtual OGRSurfaceCasterToCurvePolygon
    GetCasterToCurvePolygon() const override;
    virtual OGRBoolean isCompatibleSubType(OGRwkbGeometryType) const;
    virtual const char *getSubGeometryName() const;
    virtual OGRwkbGeometryType getSubGeometryType() const;
    std::string exportToWktInternal(const OGRWktOptions &opts,
                                    OGRErr *err) const;
 
    virtual OGRPolyhedralSurfaceCastToMultiPolygon
    GetCasterToMultiPolygon() const;
    static OGRMultiPolygon *CastToMultiPolygonImpl(OGRPolyhedralSurface *poPS);
 
  public:
    OGRPolyhedralSurface() = default;
 
    OGRPolyhedralSurface(const OGRPolyhedralSurface &other);
    OGRPolyhedralSurface(OGRPolyhedralSurface &&other) = default;
 
    OGRPolyhedralSurface &operator=(const OGRPolyhedralSurface &other);
    OGRPolyhedralSurface &operator=(OGRPolyhedralSurface &&other) = default;

    typedef OGRPolygon ChildType;

    ChildType **begin()
    {
        return oMP.begin();
    }

    ChildType **end()
    {
        return oMP.end();
    }

    const ChildType *const *begin() const
    {
        return oMP.begin();
    }

    const ChildType *const *end() const
    {
        return oMP.end();
    }
 
    // IWks Interface.
    size_t WkbSize() const override;
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;
    OGRErr exportToWkb(unsigned char *,
                       const OGRwkbExportOptions * = nullptr) const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IGeometry methods.
    int getDimension() const override;
 
    void empty() override;
 
    OGRPolyhedralSurface *clone() const override;
    void getEnvelope(OGREnvelope *psEnvelope) const override;
    void getEnvelope(OGREnvelope3D *psEnvelope) const override;
 
    void flattenTo2D() override;
    OGRErr transform(OGRCoordinateTransformation *) override;
    OGRBoolean Equals(const OGRGeometry *) const override;
    double get_Area() const override;
    virtual double get_GeodesicArea(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
    double get_Length() const override;
    virtual double get_GeodesicLength(
        const OGRSpatialReference *poSRSOverride = nullptr) const override;
 
    OGRErr PointOnSurface(OGRPoint *) const override;
 
    static OGRMultiPolygon *CastToMultiPolygon(OGRPolyhedralSurface *poPS);
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;
    virtual OGRErr addGeometry(const OGRGeometry *);
    OGRErr addGeometryDirectly(OGRGeometry *poNewGeom);
    OGRErr addGeometry(std::unique_ptr<OGRGeometry> poNewGeom);
 
    int getNumGeometries() const;
    OGRPolygon *getGeometryRef(int i);
    const OGRPolygon *getGeometryRef(int i) const;
 
    OGRBoolean IsEmpty() const override;
    bool setCoordinateDimension(int nDimension) override;
    bool set3D(OGRBoolean bIs3D) override;
    bool setMeasured(OGRBoolean bIsMeasured) override;
    void swapXY() override;
    OGRErr removeGeometry(int iIndex, int bDelete = TRUE);
 
    bool hasEmptyParts() const override;
    void removeEmptyParts() override;
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    virtual void
    assignSpatialReference(const OGRSpatialReference *poSR) override;
 
    OGR_ALLOW_CAST_TO_THIS(PolyhedralSurface)
    OGR_ALLOW_UPCAST_TO(Surface)
};


inline const OGRPolyhedralSurface::ChildType *const *
begin(const OGRPolyhedralSurface *poGeom)
{
    return poGeom->begin();
}

inline const OGRPolyhedralSurface::ChildType *const *
end(const OGRPolyhedralSurface *poGeom)
{
    return poGeom->end();
}

inline OGRPolyhedralSurface::ChildType **begin(OGRPolyhedralSurface *poGeom)
{
    return poGeom->begin();
}

inline OGRPolyhedralSurface::ChildType **end(OGRPolyhedralSurface *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                        OGRTriangulatedSurface                        */
/************************************************************************/

 
class CPL_DLL OGRTriangulatedSurface : public OGRPolyhedralSurface
{
  protected:
    OGRBoolean isCompatibleSubType(OGRwkbGeometryType) const override;
    const char *getSubGeometryName() const override;
    OGRwkbGeometryType getSubGeometryType() const override;
 
    virtual OGRPolyhedralSurfaceCastToMultiPolygon
    GetCasterToMultiPolygon() const override;
    static OGRMultiPolygon *CastToMultiPolygonImpl(OGRPolyhedralSurface *poPS);
 
  public:
    OGRTriangulatedSurface() = default;
 
    OGRTriangulatedSurface(const OGRTriangulatedSurface &other);
    OGRTriangulatedSurface(OGRTriangulatedSurface &&other) = default;
 
    OGRTriangulatedSurface &operator=(const OGRTriangulatedSurface &other);
    OGRTriangulatedSurface &operator=(OGRTriangulatedSurface &&other) = default;

    typedef OGRTriangle ChildType;

    ChildType **begin()
    {
        return reinterpret_cast<ChildType **>(oMP.begin());
    }

    ChildType **end()
    {
        return reinterpret_cast<ChildType **>(oMP.end());
    }

    const ChildType *const *begin() const
    {
        return reinterpret_cast<const ChildType *const *>(oMP.begin());
    }

    const ChildType *const *end() const
    {
        return reinterpret_cast<const ChildType *const *>(oMP.end());
    }
 
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRTriangulatedSurface *clone() const override;

    OGRTriangle *getGeometryRef(int i)
    {
        return OGRPolyhedralSurface::getGeometryRef(i)->toTriangle();
    }

    const OGRTriangle *getGeometryRef(int i) const
    {
        return OGRPolyhedralSurface::getGeometryRef(i)->toTriangle();
    }
 
    // IWks Interface.
    OGRErr addGeometry(const OGRGeometry *) override;
 
#ifndef DOXYGEN_XML
    using OGRPolyhedralSurface::addGeometry;
#endif

    inline OGRPolyhedralSurface *toUpperClass()
    {
        return this;
    }

    inline const OGRPolyhedralSurface *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    static OGRPolyhedralSurface *
    CastToPolyhedralSurface(OGRTriangulatedSurface *poTS);
 
    OGR_ALLOW_CAST_TO_THIS(TriangulatedSurface)
    OGR_ALLOW_UPCAST_TO(PolyhedralSurface)
};


inline const OGRTriangulatedSurface::ChildType *const *
begin(const OGRTriangulatedSurface *poGeom)
{
    return poGeom->begin();
}

inline const OGRTriangulatedSurface::ChildType *const *
end(const OGRTriangulatedSurface *poGeom)
{
    return poGeom->end();
}

inline OGRTriangulatedSurface::ChildType **begin(OGRTriangulatedSurface *poGeom)
{
    return poGeom->begin();
}

inline OGRTriangulatedSurface::ChildType **end(OGRTriangulatedSurface *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                            OGRMultiPoint                             */
/************************************************************************/

 
class CPL_DLL OGRMultiPoint : public OGRGeometryCollection
{
  private:
    OGRErr importFromWkt_Bracketed(const char **, int bHasM, int bHasZ);
 
  protected:
    OGRBoolean isCompatibleSubType(OGRwkbGeometryType) const override;
 
  public:
    OGRMultiPoint() = default;
 
    OGRMultiPoint(const OGRMultiPoint &other);
    OGRMultiPoint(OGRMultiPoint &&other) = default;
 
    OGRMultiPoint &operator=(const OGRMultiPoint &other);
    OGRMultiPoint &operator=(OGRMultiPoint &&other) = default;

    typedef OGRPoint ChildType;

    ChildType **begin()
    {
        return reinterpret_cast<ChildType **>(papoGeoms);
    }

    ChildType **end()
    {
        return reinterpret_cast<ChildType **>(papoGeoms + nGeomCount);
    }

    const ChildType *const *begin() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms);
    }

    const ChildType *const *end() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms +
                                                          nGeomCount);
    }
 
    // IGeometryCollection
    OGRPoint *getGeometryRef(int i)
    {
        return OGRGeometryCollection::getGeometryRef(i)->toPoint();
    }

    const OGRPoint *getGeometryRef(int i) const
    {
        return OGRGeometryCollection::getGeometryRef(i)->toPoint();
    }
 
    // Non-standard (OGRGeometry).
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRMultiPoint *clone() const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IGeometry methods.
    int getDimension() const override;

    inline OGRGeometryCollection *toUpperClass()
    {
        return this;
    }

    inline const OGRGeometryCollection *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    // Non-standard.
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;
 
    OGR_ALLOW_CAST_TO_THIS(MultiPoint)
    OGR_ALLOW_UPCAST_TO(GeometryCollection)
    OGR_FORBID_DOWNCAST_TO_MULTILINESTRING
    OGR_FORBID_DOWNCAST_TO_MULTICURVE
    OGR_FORBID_DOWNCAST_TO_MULTISURFACE
    OGR_FORBID_DOWNCAST_TO_MULTIPOLYGON
};


inline const OGRMultiPoint::ChildType *const *begin(const OGRMultiPoint *poGeom)
{
    return poGeom->begin();
}

inline const OGRMultiPoint::ChildType *const *end(const OGRMultiPoint *poGeom)
{
    return poGeom->end();
}

inline OGRMultiPoint::ChildType **begin(OGRMultiPoint *poGeom)
{
    return poGeom->begin();
}

inline OGRMultiPoint::ChildType **end(OGRMultiPoint *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                            OGRMultiCurve                             */
/************************************************************************/

 
class CPL_DLL OGRMultiCurve : public OGRGeometryCollection
{
  protected:
    static OGRErr addCurveDirectlyFromWkt(OGRGeometry *poSelf,
                                          OGRCurve *poCurve);
    OGRBoolean isCompatibleSubType(OGRwkbGeometryType) const override;
 
  public:
    OGRMultiCurve() = default;
 
    OGRMultiCurve(const OGRMultiCurve &other);
    OGRMultiCurve(OGRMultiCurve &&other) = default;
 
    OGRMultiCurve &operator=(const OGRMultiCurve &other);
    OGRMultiCurve &operator=(OGRMultiCurve &&other) = default;

    typedef OGRCurve ChildType;

    ChildType **begin()
    {
        return reinterpret_cast<ChildType **>(papoGeoms);
    }

    ChildType **end()
    {
        return reinterpret_cast<ChildType **>(papoGeoms + nGeomCount);
    }

    const ChildType *const *begin() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms);
    }

    const ChildType *const *end() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms +
                                                          nGeomCount);
    }
 
    // IGeometryCollection
    OGRCurve *getGeometryRef(int i)
    {
        return OGRGeometryCollection::getGeometryRef(i)->toCurve();
    }

    const OGRCurve *getGeometryRef(int i) const
    {
        return OGRGeometryCollection::getGeometryRef(i)->toCurve();
    }
 
    // Non standard (OGRGeometry).
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRMultiCurve *clone() const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::importFromWkt; 
#endif
 
    OGRErr importFromWkt(const char **) override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // IGeometry methods.
    int getDimension() const override;
 
    // Non-standard.
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;

    inline OGRGeometryCollection *toUpperClass()
    {
        return this;
    }

    inline const OGRGeometryCollection *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    static OGRMultiLineString *CastToMultiLineString(OGRMultiCurve *poMC);
 
    OGR_ALLOW_CAST_TO_THIS(MultiCurve)
    OGR_ALLOW_UPCAST_TO(GeometryCollection)
    OGR_FORBID_DOWNCAST_TO_MULTIPOINT
    OGR_FORBID_DOWNCAST_TO_MULTISURFACE
    OGR_FORBID_DOWNCAST_TO_MULTIPOLYGON
};


inline const OGRMultiCurve::ChildType *const *begin(const OGRMultiCurve *poGeom)
{
    return poGeom->begin();
}

inline const OGRMultiCurve::ChildType *const *end(const OGRMultiCurve *poGeom)
{
    return poGeom->end();
}

inline OGRMultiCurve::ChildType **begin(OGRMultiCurve *poGeom)
{
    return poGeom->begin();
}

inline OGRMultiCurve::ChildType **end(OGRMultiCurve *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                          OGRMultiLineString                          */
/************************************************************************/

 
class CPL_DLL OGRMultiLineString : public OGRMultiCurve
{
  protected:
    OGRBoolean isCompatibleSubType(OGRwkbGeometryType) const override;
 
  public:
    OGRMultiLineString() = default;
 
    OGRMultiLineString(const OGRMultiLineString &other);
    OGRMultiLineString(OGRMultiLineString &&other) = default;
 
    OGRMultiLineString &operator=(const OGRMultiLineString &other);
    OGRMultiLineString &operator=(OGRMultiLineString &&other) = default;

    typedef OGRLineString ChildType;

    ChildType **begin()
    {
        return reinterpret_cast<ChildType **>(papoGeoms);
    }

    ChildType **end()
    {
        return reinterpret_cast<ChildType **>(papoGeoms + nGeomCount);
    }

    const ChildType *const *begin() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms);
    }

    const ChildType *const *end() const
    {
        return reinterpret_cast<const ChildType *const *>(papoGeoms +
                                                          nGeomCount);
    }
 
    // IGeometryCollection
    OGRLineString *getGeometryRef(int i)
    {
        return OGRGeometryCollection::getGeometryRef(i)->toLineString();
    }

    const OGRLineString *getGeometryRef(int i) const
    {
        return OGRGeometryCollection::getGeometryRef(i)->toLineString();
    }
 
    // Non standard (OGRGeometry).
    const char *getGeometryName() const override;
    OGRwkbGeometryType getGeometryType() const override;
    OGRMultiLineString *clone() const override;
 
#ifndef DOXYGEN_XML
    using OGRGeometry::exportToWkt;
#endif
 
    virtual OGRErr importFromWkb(const unsigned char *, size_t, OGRwkbVariant,
                                 size_t &nBytesConsumedOut) override;

    virtual std::string exportToWkt(const OGRWktOptions &opts = OGRWktOptions(),
                                    OGRErr *err = nullptr) const override;
 
    // Non standard
    virtual OGRBoolean
    hasCurveGeometry(int bLookForNonLinear = FALSE) const override;

    inline OGRGeometryCollection *toUpperClass()
    {
        return this;
    }

    inline const OGRGeometryCollection *toUpperClass() const
    {
        return this;
    }
 
    void accept(IOGRGeometryVisitor *visitor) override
    {
        visitor->visit(this);
    }
 
    void accept(IOGRConstGeometryVisitor *visitor) const override
    {
        visitor->visit(this);
    }
 
    static OGRMultiCurve *CastToMultiCurve(OGRMultiLineString *poMLS);
 
    OGR_ALLOW_CAST_TO_THIS(MultiLineString)
    OGR_ALLOW_UPCAST_TO(MultiCurve)
    OGR_FORBID_DOWNCAST_TO_MULTIPOINT
    OGR_FORBID_DOWNCAST_TO_MULTISURFACE
    OGR_FORBID_DOWNCAST_TO_MULTIPOLYGON
};


inline const OGRMultiLineString::ChildType *const *
begin(const OGRMultiLineString *poGeom)
{
    return poGeom->begin();
}

inline const OGRMultiLineString::ChildType *const *
end(const OGRMultiLineString *poGeom)
{
    return poGeom->end();
}

inline OGRMultiLineString::ChildType **begin(OGRMultiLineString *poGeom)
{
    return poGeom->begin();
}

inline OGRMultiLineString::ChildType **end(OGRMultiLineString *poGeom)
{
    return poGeom->end();
}

 
/************************************************************************/
/*                          OGRGeometryFactory                          */
/************************************************************************/

 
class CPL_DLL OGRGeometryFactory
{
    static OGRErr createFromFgfInternal(const unsigned char *pabyData,
                                        OGRSpatialReference *poSR,
                                        OGRGeometry **ppoReturn, int nBytes,
                                        int *pnBytesConsumed, int nRecLevel);
 
  public:
    static OGRErr createFromWkb(const void *, const OGRSpatialReference *,
                                OGRGeometry **,
                                size_t = static_cast<size_t>(-1),
                                OGRwkbVariant = wkbVariantOldOgc);
    static OGRErr createFromWkb(const void *pabyData,
                                const OGRSpatialReference *, OGRGeometry **,
                                size_t nSize, OGRwkbVariant eVariant,
                                size_t &nBytesConsumedOut);
    static OGRErr createFromWkt(const char *, const OGRSpatialReference *,
                                OGRGeometry **);
    static OGRErr createFromWkt(const char **, const OGRSpatialReference *,
                                OGRGeometry **);
    static std::pair<std::unique_ptr<OGRGeometry>, OGRErr>
    createFromWkt(const char *, const OGRSpatialReference * = nullptr);

    static OGRErr createFromWkt(char **ppszInput,
                                const OGRSpatialReference *poSRS,
                                OGRGeometry **ppoGeom)
        CPL_WARN_DEPRECATED("Use createFromWkt(const char**, ...) instead")
    {
        return createFromWkt(const_cast<const char **>(ppszInput), poSRS,
                             ppoGeom);
    }
 
    static OGRErr createFromFgf(const void *, OGRSpatialReference *,
                                OGRGeometry **, int = -1, int * = nullptr);
    static OGRGeometry *createFromGML(const char *);
    static OGRGeometry *createFromGEOS(GEOSContextHandle_t hGEOSCtxt, GEOSGeom);
    static OGRGeometry *createFromGeoJson(const char *, int = -1);
    static OGRGeometry *createFromGeoJson(const CPLJSONObject &oJSONObject);
 
    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 = nullptr)
#ifndef DOXYGEN_SKIP
        CPL_WARN_DEPRECATED("Use variant that accepts and returns a "
                            "std::unique_ptr<OGRGeometry")
#endif
            ;
 
    static std::unique_ptr<OGRGeometry>
    forceTo(std::unique_ptr<OGRGeometry> poGeom, OGRwkbGeometryType eTargetType,
            const char *const *papszOptions = nullptr);
 
    static std::unique_ptr<OGRGeometry>
    makeCompatibleWith(std::unique_ptr<OGRGeometry>,
                       OGRwkbGeometryType eTargetType);
 
    static OGRGeometry *removeLowerDimensionSubGeoms(const OGRGeometry *poGeom);
 
    static std::unique_ptr<OGRGeometry>
    organizePolygons(std::vector<std::unique_ptr<OGRGeometry>> &apoPolygons,
                     bool *pbResultValidGeometry = nullptr,
                     CSLConstList papszOptions = nullptr);
 
    static OGRGeometry *organizePolygons(OGRGeometry **papoPolygons,
                                         int nPolygonCount,
                                         int *pbResultValidGeometry,
                                         CSLConstList papszOptions = nullptr)
#ifndef DOXYGEN_SKIP
        CPL_WARN_DEPRECATED("Use variant that accepts a "
                            "std::vector<std::unique_ptr<OGRGeometry>>&")
#endif
            ;
 
    static bool haveGEOS();

    class CPL_DLL TransformWithOptionsCache
    {
        friend class OGRGeometryFactory;
        struct Private;
        std::unique_ptr<Private> d;
 
      public:
        TransformWithOptionsCache();
        ~TransformWithOptionsCache();
    };

    static bool isTransformWithOptionsRegularTransform(
        const OGRSpatialReference *poSourceCRS,
        const OGRSpatialReference *poTargetCRS, CSLConstList papszOptions);
 
    static OGRGeometry *transformWithOptions(
        const OGRGeometry *poSrcGeom, OGRCoordinateTransformation *poCT,
        CSLConstList papszOptions,
        const TransformWithOptionsCache &cache = TransformWithOptionsCache());
 
    static double GetDefaultArcStepSize();
 
    static OGRGeometry *
    approximateArcAngles(double dfX, double dfY, double dfZ,
                         double dfPrimaryRadius, double dfSecondaryAxis,
                         double dfRotation, double dfStartAngle,
                         double dfEndAngle, double dfMaxAngleStepSizeDegrees,
                         const bool bUseMaxGap = false);
 
    static int GetCurveParameters(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 = nullptr);
    static OGRCurve *
    curveFromLineString(const OGRLineString *poLS,
                        const char *const *papszOptions = nullptr);
};
 
OGRwkbGeometryType CPL_DLL OGRFromOGCGeomType(const char *pszGeomType);
const char CPL_DLL *OGRToOGCGeomType(OGRwkbGeometryType eGeomType,
                                     bool bCamelCase = false,
                                     bool bAddZM = false,
                                     bool bSpaceBeforeZM = false);

typedef struct _OGRPreparedGeometry OGRPreparedGeometry;
 
struct CPL_DLL OGRPreparedGeometryUniquePtrDeleter
{
    void operator()(OGRPreparedGeometry *) const;
};


typedef std::unique_ptr<OGRPreparedGeometry,
                        OGRPreparedGeometryUniquePtrDeleter>
    OGRPreparedGeometryUniquePtr;
 
#endif /* ndef OGR_GEOMETRY_H_INCLUDED */