Geometry.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2009 2011 Sandro Santilli <strk@kbt.io>
 * Copyright (C) 2005 2006 Refractions Research Inc.
 * Copyright (C) 2001-2002 Vivid Solutions Inc.
 *
 * This is free software; you can redistribute and/or modify it under
 * the terms of the GNU Lesser General Public Licence as published
 * by the Free Software Foundation.
 * See the COPYING file for more information.
 *
 **********************************************************************
 *
 * Last port: geom/Geometry.java rev. 1.112
 *
 **********************************************************************/
 
#pragma once
 
#ifndef USE_UNSTABLE_GEOS_CPP_API
#ifndef _MSC_VER
# warning "The GEOS C++ API is unstable, please use the C API instead"
# warning "HINT: #include geos_c.h"
#else
#pragma message("The GEOS C++ API is unstable, please use the C API instead")
#pragma message("HINT: #include geos_c.h")
#endif
#endif
 
#include <geos/export.h>
#include <geos/geom/Envelope.h>
#include <geos/geom/Dimension.h> // for Dimension::DimensionType
#include <geos/geom/GeometryComponentFilter.h> // for inheritance
#include <geos/geom/CoordinateSequence.h> // to materialize CoordinateSequence
#include <geos/util/Progress.h>
 
#include <algorithm>
#include <string>
#include <iostream>
#include <vector>
#include <memory>
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
#pragma warning(disable: 4355) // warning C4355: 'this' : used in base member initializer list
#endif
 
// Forward declarations
namespace geos {
namespace algorithm {
class CurveToLineParams;
class LineToCurveParams;
}
namespace geom {
class Coordinate;
class CoordinateFilter;
class CoordinateSequence;
class CoordinateSequenceFilter;
class GeometryComponentFilter;
class GeometryFactory;
class GeometryFilter;
class PrecisionModel;
class Point;
class IntersectionMatrix;
}
namespace io { // geos.io
} // namespace geos.io
}
 
namespace geos { // geos
namespace geom { // geos::geom
 
enum GeometryTypeId : int {
    GEOS_POINT,
    GEOS_LINESTRING,
    GEOS_LINEARRING,
    GEOS_POLYGON,
    GEOS_MULTIPOINT,
    GEOS_MULTILINESTRING,
    GEOS_MULTIPOLYGON,
    GEOS_GEOMETRYCOLLECTION,
    GEOS_CIRCULARSTRING,
    GEOS_COMPOUNDCURVE,
    GEOS_CURVEPOLYGON,
    GEOS_MULTICURVE,
    GEOS_MULTISURFACE,
};
 
enum GeometrySortIndex {
    SORTINDEX_POINT = 0,
    SORTINDEX_MULTIPOINT = 1,
    SORTINDEX_LINESTRING = 2,
    SORTINDEX_LINEARRING = 3,
    SORTINDEX_MULTILINESTRING = 4,
    SORTINDEX_POLYGON = 5,
    SORTINDEX_MULTIPOLYGON = 6,
    SORTINDEX_GEOMETRYCOLLECTION = 7,
    SORTINDEX_CIRCULARSTRING = 8,
    SORTINDEX_COMPOUNDCURVE = 9,
    SORTINDEX_CURVEPOLYGON = 10,
    SORTINDEX_MULTICURVE = 11,
    SORTINDEX_MULTISURFACE = 12,
};
 
class GEOS_DLL Geometry {
 
public:
 
    friend class GeometryFactory;
 
    using ConstVect = std::vector<const Geometry*>;
 
    using NonConstVect = std::vector<Geometry*>;
 
    using Ptr = std::unique_ptr<Geometry> ;
 
    std::unique_ptr<Geometry> clone() const { return std::unique_ptr<Geometry>(cloneImpl()); }
 
    virtual ~Geometry();
 
 
    const GeometryFactory*
    getFactory() const
    {
        return _factory;
    }
 
    void
    setUserData(void* newUserData)
    {
        _userData = newUserData;
    }
 
    void*
    getUserData() const
    {
        return _userData;
    }
 
    int getSRID() const
    {
        return SRID;
    }
 
    virtual void
    setSRID(int newSRID)
    {
        SRID = newSRID;
    }
 
    const PrecisionModel* getPrecisionModel() const;
 
    virtual const CoordinateXY* getCoordinate() const = 0; //Abstract
 
    virtual std::unique_ptr<CoordinateSequence> getCoordinates() const = 0; //Abstract
 
    virtual std::size_t getNumPoints() const = 0; //Abstract
 
    virtual bool isSimple() const;
 
    virtual std::string getGeometryType() const = 0; //Abstract
 
    virtual bool hasCurvedComponents() const;
 
    virtual bool hasCurvedTypes() const;
 
    virtual GeometryTypeId getGeometryTypeId() const = 0; //Abstract
 
    virtual std::size_t
    getNumGeometries() const
    {
        return 1;
    }
 
    virtual const Geometry*
    getGeometryN(std::size_t /*n*/) const
    {
        return this;
    }
 
    std::unique_ptr<Geometry> getLinearized(const algorithm::CurveToLineParams& params) const
    {
        return std::unique_ptr<Geometry>(getLinearizedImpl(params));
    }
 
    std::unique_ptr<Geometry> getCurved(const algorithm::LineToCurveParams& params) const
    {
        return std::unique_ptr<Geometry>(getCurvedImpl(params));
    }
 
    bool isValid() const;
 
    virtual bool isEmpty() const = 0; //Abstract
 
    virtual bool
    isRectangle() const
    {
        return false;
    }
 
    virtual Dimension::DimensionType getDimension() const = 0; //Abstract
 
    virtual bool hasDimension(Dimension::DimensionType d) const {
        return getDimension() == d;
    }
 
    virtual bool isDimensionStrict(Dimension::DimensionType d) const {
        return d == getDimension();
    }
 
    bool isPuntal() const {
        return isDimensionStrict(Dimension::P);
    }
 
    bool isLineal() const {
        return isDimensionStrict(Dimension::L);
    }
 
    bool isPolygonal() const {
        return isDimensionStrict(Dimension::A);
    }
 
    bool isMixedDimension() const;
    bool isMixedDimension(Dimension::DimensionType* baseDim) const;
 
    bool isCollection() const {
        int t = getGeometryTypeId();
        return t == GEOS_GEOMETRYCOLLECTION ||
               t == GEOS_MULTIPOINT ||
               t == GEOS_MULTILINESTRING ||
               t == GEOS_MULTIPOLYGON ||
               t == GEOS_MULTICURVE ||
               t == GEOS_MULTISURFACE;
    }
 
    static GeometryTypeId multiTypeId(GeometryTypeId typeId) {
        switch (typeId) {
            case GEOS_POINT: return GEOS_MULTIPOINT;
            case GEOS_LINESTRING: return GEOS_MULTILINESTRING;
            case GEOS_POLYGON: return GEOS_MULTIPOLYGON;
            case GEOS_CIRCULARSTRING:
            case GEOS_COMPOUNDCURVE: return GEOS_MULTICURVE;
            case GEOS_CURVEPOLYGON: return GEOS_MULTISURFACE;
            default: return typeId;
        }
    }
 
    virtual uint8_t getCoordinateDimension() const = 0; //Abstract
 
    virtual bool hasZ() const = 0;
 
    virtual bool hasM() const = 0;
 
    virtual std::unique_ptr<Geometry> getBoundary() const = 0; //Abstract
 
    virtual int getBoundaryDimension() const = 0; //Abstract
 
    virtual std::unique_ptr<Geometry> getEnvelope() const;
 
    virtual const Envelope* getEnvelopeInternal() const = 0;
 
    virtual bool disjoint(const Geometry* other) const;
 
    virtual bool touches(const Geometry* other) const;
 
    virtual bool intersects(const Geometry* g) const;
 
    virtual bool crosses(const Geometry* g) const;
 
    virtual bool within(const Geometry* g) const;
 
    virtual bool contains(const Geometry* g) const;
 
    virtual bool overlaps(const Geometry* g) const;
 
    bool relate(const Geometry* g,
                        const std::string& intersectionPattern) const;
 
    bool
    relate(const Geometry& g, const std::string& intersectionPattern) const
    {
        return relate(&g, intersectionPattern);
    }
 
    std::unique_ptr<IntersectionMatrix> relate(const Geometry* g) const;
 
    std::unique_ptr<IntersectionMatrix> relate(const Geometry& g) const;
 
    bool equals(const Geometry* g) const;
 
    bool covers(const Geometry* g) const;
 
    bool coveredBy(const Geometry* g) const;
 
 
    virtual std::string toString() const;
 
    virtual std::string toText() const;
 
    std::unique_ptr<Geometry> buffer(double distance) const;
 
    std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
 
    std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
                             int endCapStyle) const;
 
    virtual std::unique_ptr<Geometry> convexHull() const;
 
    std::unique_ptr<Geometry> reverse() const { return std::unique_ptr<Geometry>(reverseImpl()); }
 
    std::unique_ptr<Geometry> intersection(const Geometry* other) const;
 
    std::unique_ptr<Geometry> Union(const Geometry* other) const;
    // throw(IllegalArgumentException *, TopologyException *);
 
    Ptr Union(geos::util::ProgressFunction* progressFunction) const;
    // throw(IllegalArgumentException *, TopologyException *);
 
    Ptr Union() const
    {
        geos::util::ProgressFunction* progressFunction = nullptr;
        return Union(progressFunction);
    }
 
    std::unique_ptr<Geometry> difference(const Geometry* other) const;
 
    std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
 
    virtual bool equalsExact(const Geometry* other, double tolerance = 0)
        const = 0; // Abstract
 
    virtual bool equalsIdentical(const Geometry* other) const = 0;
 
    virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
    virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
    virtual void apply_rw(GeometryFilter* filter);
    virtual void apply_ro(GeometryFilter* filter) const;
    virtual void apply_rw(GeometryComponentFilter* filter);
    virtual void apply_ro(GeometryComponentFilter* filter) const;
 
    virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
 
    virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
 
    template <class T>
    void
    applyComponentFilter(T& f) const
    {
        for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
            f.filter(getGeometryN(i));
        }
    }
 
    virtual void normalize() = 0; //Abstract
 
    int compareTo(const Geometry* geom) const;
 
    virtual double getArea() const;
 
    virtual double getLength() const;
 
    virtual double distance(const Geometry* g) const;
 
 
    virtual bool isWithinDistance(const Geometry* geom,
                                  double cDistance) const;
 
    virtual std::unique_ptr<Point> getCentroid() const;
 
    //
    virtual bool getCentroid(CoordinateXY& ret) const;
 
    std::unique_ptr<Point> getInteriorPoint() const;
 
    void geometryChanged();
 
    virtual void geometryChangedAction() = 0;
 
protected:
    virtual Geometry* cloneImpl() const = 0;
 
    virtual Geometry* reverseImpl() const = 0;
 
    virtual Geometry* getLinearizedImpl(const algorithm::CurveToLineParams&) const = 0;
 
    virtual Geometry* getCurvedImpl(const algorithm::LineToCurveParams&) const = 0;
 
    template<typename T>
    static bool hasNonEmptyElements(const std::vector<T>* geometries) {
        return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
    }
 
    static bool hasNullElements(const CoordinateSequence* list);
 
    template<typename T>
    static bool hasNullElements(const std::vector<T>* geometries) {
        return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
    }
 
//      static void reversePointOrder(CoordinateSequence* coordinates);
//      static Coordinate& minCoordinate(CoordinateSequence* coordinates);
//      static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
//      static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
//
    virtual bool isEquivalentClass(const Geometry* other) const;
 
    static void checkNotGeometryCollection(const Geometry* g);
 
    virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
 
    template<typename T>
    static int compare(const T& a, const T& b)
    {
        std::size_t i = 0;
        std::size_t j = 0;
        while(i < a.size() && j < b.size()) {
            const auto& aGeom = *a[i];
            const auto& bGeom = *b[j];
 
            int comparison = aGeom.compareTo(&bGeom);
            if(comparison != 0) {
                return comparison;
            }
 
            i++;
            j++;
        }
 
        if(i < a.size()) {
            return 1;
        }
 
        if(j < b.size()) {
            return -1;
        }
 
        return 0;
    }
 
    bool equal(const CoordinateXY& a, const CoordinateXY& b,
               double tolerance) const;
    int SRID;
 
    Geometry(const Geometry& geom);
 
    Geometry(const GeometryFactory* factory);
 
    template<typename T>
    static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
        static_assert(std::is_base_of<Geometry, T>::value, "");
        std::vector<std::unique_ptr<Geometry>> gv(v.size());
        for (std::size_t i = 0; i < v.size(); i++) {
            gv[i] = std::move(v[i]);
        }
        return gv;
    }
 
    static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<Geometry>> && v) {
        return std::move(v);
    }
 
protected:
 
    virtual int getSortIndex() const = 0;
 
 
private:
 
    class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
    public:
        void filter_rw(Geometry* geom) override;
    };
 
    static GeometryChangedFilter geometryChangedFilter;
 
    const GeometryFactory* _factory;
 
    void* _userData;
};
 
GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
 
struct GEOS_DLL GeometryGreaterThen {
    bool operator()(const Geometry* first, const Geometry* second);
};
 
 
GEOS_DLL std::string geosversion();
 
GEOS_DLL std::string jtsport();
 
// We use this instead of std::pair<unique_ptr<Geometry>> because C++11
// forbids that construct:
// http://lwg.github.com/issues/lwg-closed.html#2068
struct GeomPtrPair {
    typedef std::unique_ptr<Geometry> GeomPtr;
    GeomPtr first;
    GeomPtr second;
};
 
} // namespace geos::geom
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif