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
 *
 **********************************************************************/
 
#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/platform.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 <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 IntersectionMatrix;
                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
};
 
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 Geometry* clone() const=0;
 
        virtual ~Geometry();
 
 
        const GeometryFactory* getFactory() const { return _factory; }
 
        void setUserData(void* newUserData) { _userData=newUserData; }
 
        void* getUserData() const { return _userData; }
 
        /*
         * \brief
         * Returns the ID of the Spatial Reference System used by the
         * <code>Geometry</code>.
         *
         * GEOS supports Spatial Reference System information in the simple way
         * defined in the SFS. A Spatial Reference System ID (SRID) is present
         * in each <code>Geometry</code> object. <code>Geometry</code>
         * provides basic accessor operations for this field, but no others.
         * The SRID is represented as an integer.
         *
         * @return the ID of the coordinate space in which the
         * <code>Geometry</code> is defined.
         *
         */
        virtual int getSRID() const { return SRID; }
 
        /*
         * Sets the ID of the Spatial Reference System used by the
         * <code>Geometry</code>.
         */
        virtual void setSRID(int newSRID) { SRID=newSRID; }
 
        const PrecisionModel* getPrecisionModel() const;
 
        virtual const Coordinate* getCoordinate() const=0; //Abstract
 
        virtual 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 int getCoordinateDimension() const=0; //Abstract
 
        virtual Geometry* getBoundary() const=0; //Abstract
 
        virtual int getBoundaryDimension() const=0; //Abstract
 
        virtual 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;
 
        virtual bool relate(const Geometry *g,
                        const std::string& intersectionPattern) const;
 
        bool relate(const Geometry& g, const std::string& intersectionPattern) const
        {
                return relate(&g, intersectionPattern);
        }
 
        virtual IntersectionMatrix* relate(const Geometry *g) const;
        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;
 
        //
        virtual Geometry* buffer(double distance) const;
 
        //
        virtual Geometry* buffer(double distance,int quadrantSegments) const;
 
        virtual Geometry* buffer(double distance, int quadrantSegments,
                        int endCapStyle) const;
 
        virtual Geometry* convexHull() const;
 
        virtual Geometry* reverse() const=0;
 
        virtual Geometry* intersection(const Geometry *other) const;
 
        Geometry* Union(const Geometry *other) const;
                // throw(IllegalArgumentException *, TopologyException *);
 
  Ptr Union() const;
                // throw(IllegalArgumentException *, TopologyException *);
 
        virtual Geometry* difference(const Geometry *other) const;
 
        virtual 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 Point* getCentroid() const;
 
        //
        virtual bool getCentroid(Coordinate& ret) const;
 
        virtual Point* getInteriorPoint() const;
 
        /*
         * \brief
         * Notifies this Geometry that its Coordinates have been changed
         * by an external party (using a CoordinateFilter, for example).
         */
        virtual void geometryChanged();
 
        void geometryChangedAction();
 
protected:
 
        mutable std::unique_ptr<Envelope> envelope;
 
        static bool hasNonEmptyElements(const std::vector<Geometry *>* geometries);
 
        static bool hasNullElements(const CoordinateSequence* list);
 
        static bool hasNullElements(const std::vector<Geometry *>* lrs);
 
//      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;
 
        bool equal(const Coordinate& a, const Coordinate& b,
                        double tolerance) const;
        int SRID;
 
        //Geometry* toInternalGeometry(const Geometry *g) const;
 
        //Geometry* fromInternalGeometry(const Geometry *g) const;
 
        //virtual bool isRectangle() const { return false; } -- moved to public
 
        Geometry(const Geometry &geom);
 
        Geometry(const GeometryFactory *factory);
 
private:
 
        int getClassSortIndex() const;
 
        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);
};
 
 
std::string geosversion();
 
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