Geometry.h

Go to the documentation of this file.

/**********************************************************************
 *
 * 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
 *
 **********************************************************************/

#ifndef GEOS_GEOM_GEOMETRY_H
#define GEOS_GEOM_GEOMETRY_H

#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/inline.h>
#include <geos/geom/Envelope.h>
#include <geos/geom/Dimension.h> // for Dimension::DimensionType
#include <geos/geom/GeometryComponentFilter.h> // for inheritance
#include <geos/geom/IntersectionMatrix.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 geom {
class Coordinate;
class CoordinateFilter;
class CoordinateSequence;
class CoordinateSequenceFilter;
class GeometryComponentFilter;
class GeometryFactory;
class GeometryFilter;
class PrecisionModel;
class Point;
}
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> ;

    virtual std::unique_ptr<Geometry> clone() const = 0;

    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
    {
        return relate(&g);
    }

    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;

    virtual std::unique_ptr<Geometry> reverse() const = 0;

    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;

    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 (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

#endif // ndef GEOS_GEOM_GEOMETRY_H