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 <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 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
class Unload;
} // namespace geos.io
}
 
namespace geos {
namespace geom { // geos::geom
 
enum GeometryTypeId {
    GEOS_POINT,
    GEOS_LINESTRING,
    GEOS_LINEARRING,
    GEOS_POLYGON,
    GEOS_MULTIPOINT,
    GEOS_MULTILINESTRING,
    GEOS_MULTIPOLYGON,
    GEOS_GEOMETRYCOLLECTION
};
 
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
};
 
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;
    }
 
    virtual int
    getSRID() const
    {
        return SRID;
    }
 
    virtual void
    setSRID(int newSRID)
    {
        SRID = newSRID;
    }
 
    const PrecisionModel* getPrecisionModel() const;
 
    virtual const Coordinate* 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 GeometryTypeId getGeometryTypeId() const = 0; //Abstract
 
    virtual std::size_t
    getNumGeometries() const
    {
        return 1;
    }
 
    virtual const Geometry*
    getGeometryN(std::size_t /*n*/) const
    {
        return this;
    }
 
    virtual bool isValid() const;
 
    virtual bool isEmpty() const = 0; //Abstract
 
    virtual bool
    isRectangle() const
    {
        return false;
    }
 
    virtual Dimension::DimensionType getDimension() const = 0; //Abstract
 
    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 isCollection() const {
        int t = getGeometryTypeId();
        return t == GEOS_GEOMETRYCOLLECTION ||
               t == GEOS_MULTIPOINT ||
               t == GEOS_MULTILINESTRING ||
               t == GEOS_MULTIPOLYGON;
    }
 
    virtual uint8_t getCoordinateDimension() const = 0; //Abstract
 
    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;
 
    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;
 
    virtual bool equals(const Geometry* g) const;
 
    bool covers(const Geometry* g) const;
 
    bool
    coveredBy(const Geometry* g) const
    {
        return g->covers(this);
    }
 
 
    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() const;
    // throw(IllegalArgumentException *, TopologyException *);
 
    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 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
 
    virtual int compareTo(const Geometry* geom) const;
 
    virtual double distance(const Geometry* g) const;
 
    virtual double getArea() const;
 
    virtual double getLength() const;
 
    virtual bool isWithinDistance(const Geometry* geom,
                                  double cDistance) const;
 
    virtual std::unique_ptr<Point> getCentroid() const;
 
    //
    virtual bool getCentroid(Coordinate& ret) const;
 
    std::unique_ptr<Point> getInteriorPoint() const;
 
    virtual void geometryChanged();
 
    void geometryChangedAction();
 
protected:
 
    mutable std::unique_ptr<Envelope> envelope;
 
    virtual Geometry* cloneImpl() const = 0;
 
    virtual Geometry* reverseImpl() 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);
    // throw(IllegalArgumentException *);
 
    //virtual void checkEqualSRID(Geometry *other);
 
    //virtual void checkEqualPrecisionModel(Geometry *other);
 
    virtual Envelope::Ptr computeEnvelopeInternal() const = 0; //Abstract
 
    virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
 
    int compare(std::vector<Coordinate> a, std::vector<Coordinate> b) const;
 
    int compare(std::vector<Geometry*> a, std::vector<Geometry*> b) const;
 
    int compare(const std::vector<std::unique_ptr<Geometry>> & a, const std::vector<std::unique_ptr<Geometry>> & b) const;
 
    bool equal(const Coordinate& a, const Coordinate& 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;
    }
 
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