GEOS  3.9.1
Geometry.h
1 /**********************************************************************
2  *
3  * GEOS - Geometry Engine Open Source
4  * http://geos.osgeo.org
5  *
6  * Copyright (C) 2009 2011 Sandro Santilli <strk@kbt.io>
7  * Copyright (C) 2005 2006 Refractions Research Inc.
8  * Copyright (C) 2001-2002 Vivid Solutions Inc.
9  *
10  * This is free software; you can redistribute and/or modify it under
11  * the terms of the GNU Lesser General Public Licence as published
12  * by the Free Software Foundation.
13  * See the COPYING file for more information.
14  *
15  **********************************************************************
16  *
17  * Last port: geom/Geometry.java rev. 1.112
18  *
19  **********************************************************************/
20 
21 #ifndef GEOS_GEOM_GEOMETRY_H
22 #define GEOS_GEOM_GEOMETRY_H
23 
24 #ifndef USE_UNSTABLE_GEOS_CPP_API
25 #ifndef _MSC_VER
26 # warning "The GEOS C++ API is unstable, please use the C API instead"
27 # warning "HINT: #include geos_c.h"
28 #else
29 #pragma message("The GEOS C++ API is unstable, please use the C API instead")
30 #pragma message("HINT: #include geos_c.h")
31 #endif
32 #endif
33 
34 #include <geos/export.h>
35 #include <geos/inline.h>
36 #include <geos/geom/Envelope.h>
37 #include <geos/geom/Dimension.h> // for Dimension::DimensionType
38 #include <geos/geom/GeometryComponentFilter.h> // for inheritance
39 #include <geos/geom/IntersectionMatrix.h>
40 
41 #include <algorithm>
42 #include <string>
43 #include <iostream>
44 #include <vector>
45 #include <memory>
46 
47 #ifdef _MSC_VER
48 #pragma warning(push)
49 #pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
50 #pragma warning(disable: 4355) // warning C4355: 'this' : used in base member initializer list
51 #endif
52 
53 // Forward declarations
54 namespace geos {
55 namespace geom {
56 class Coordinate;
57 class CoordinateFilter;
58 class CoordinateSequence;
59 class CoordinateSequenceFilter;
60 class GeometryComponentFilter;
61 class GeometryFactory;
62 class GeometryFilter;
63 class PrecisionModel;
64 class Point;
65 }
66 namespace io { // geos.io
67 class Unload;
68 } // namespace geos.io
69 }
70 
71 namespace geos {
72 namespace geom { // geos::geom
73 
92 };
93 
94 enum GeometrySortIndex {
95  SORTINDEX_POINT = 0,
96  SORTINDEX_MULTIPOINT = 1,
97  SORTINDEX_LINESTRING = 2,
98  SORTINDEX_LINEARRING = 3,
99  SORTINDEX_MULTILINESTRING = 4,
100  SORTINDEX_POLYGON = 5,
101  SORTINDEX_MULTIPOLYGON = 6,
102  SORTINDEX_GEOMETRYCOLLECTION = 7
103 };
104 
188 class GEOS_DLL Geometry {
189 
190 public:
191 
192  friend class GeometryFactory;
193 
195  using ConstVect = std::vector<const Geometry*>;
196 
198  using NonConstVect = std::vector<Geometry*>;
199 
201  using Ptr = std::unique_ptr<Geometry> ;
202 
204  virtual std::unique_ptr<Geometry> clone() const = 0;
205 
207  virtual ~Geometry();
208 
209 
217  const GeometryFactory*
218  getFactory() const
219  {
220  return _factory;
221  }
222 
236  void
237  setUserData(void* newUserData)
238  {
239  _userData = newUserData;
240  }
241 
248  void*
249  getUserData() const
250  {
251  return _userData;
252  }
253 
264  virtual int
265  getSRID() const
266  {
267  return SRID;
268  }
269 
273  virtual void
274  setSRID(int newSRID)
275  {
276  SRID = newSRID;
277  }
278 
284 
286  virtual const Coordinate* getCoordinate() const = 0; //Abstract
287 
293  virtual std::unique_ptr<CoordinateSequence> getCoordinates() const = 0; //Abstract
294 
296  virtual std::size_t getNumPoints() const = 0; //Abstract
297 
299  virtual bool isSimple() const;
300 
302  virtual std::string getGeometryType() const = 0; //Abstract
303 
305  virtual GeometryTypeId getGeometryTypeId() const = 0; //Abstract
306 
309  virtual std::size_t
311  {
312  return 1;
313  }
314 
317  virtual const Geometry*
318  getGeometryN(std::size_t /*n*/) const
319  {
320  return this;
321  }
322 
332  virtual bool isValid() const;
333 
335  virtual bool isEmpty() const = 0; //Abstract
336 
338  virtual bool
339  isRectangle() const
340  {
341  return false;
342  }
343 
345  virtual Dimension::DimensionType getDimension() const = 0; //Abstract
346 
349  return d == getDimension();
350  }
351 
352  bool isPuntal() const {
353  return isDimensionStrict(Dimension::P);
354  }
355 
356  bool isLineal() const {
357  return isDimensionStrict(Dimension::L);
358  }
359 
360  bool isPolygonal() const {
361  return isDimensionStrict(Dimension::A);
362  }
363 
364  bool isCollection() const {
365  int t = getGeometryTypeId();
366  return t == GEOS_GEOMETRYCOLLECTION ||
367  t == GEOS_MULTIPOINT ||
368  t == GEOS_MULTILINESTRING ||
369  t == GEOS_MULTIPOLYGON;
370  }
371 
373  virtual uint8_t getCoordinateDimension() const = 0; //Abstract
374 
391  virtual std::unique_ptr<Geometry> getBoundary() const = 0; //Abstract
392 
394  virtual int getBoundaryDimension() const = 0; //Abstract
395 
397  virtual std::unique_ptr<Geometry> getEnvelope() const;
398 
403  virtual const Envelope* getEnvelopeInternal() const;
404 
421  virtual bool disjoint(const Geometry* other) const;
422 
427  virtual bool touches(const Geometry* other) const;
428 
430  virtual bool intersects(const Geometry* g) const;
431 
454  virtual bool crosses(const Geometry* g) const;
455 
460  virtual bool within(const Geometry* g) const;
461 
463  virtual bool contains(const Geometry* g) const;
464 
470  virtual bool overlaps(const Geometry* g) const;
471 
486  bool relate(const Geometry* g,
487  const std::string& intersectionPattern) const;
488 
489  bool
490  relate(const Geometry& g, const std::string& intersectionPattern) const
491  {
492  return relate(&g, intersectionPattern);
493  }
494 
496  std::unique_ptr<IntersectionMatrix> relate(const Geometry* g) const;
497 
498  std::unique_ptr<IntersectionMatrix> relate(const Geometry& g) const
499  {
500  return relate(&g);
501  }
502 
508  virtual bool equals(const Geometry* g) const;
509 
548  bool covers(const Geometry* g) const;
549 
580  bool
581  coveredBy(const Geometry* g) const
582  {
583  return g->covers(this);
584  }
585 
586 
588  virtual std::string toString() const;
589 
590  virtual std::string toText() const;
591 
596  std::unique_ptr<Geometry> buffer(double distance) const;
597 
605  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
606 
643  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
644  int endCapStyle) const;
645 
649  virtual std::unique_ptr<Geometry> convexHull() const;
650 
657  virtual std::unique_ptr<Geometry> reverse() const = 0;
658 
668  std::unique_ptr<Geometry> intersection(const Geometry* other) const;
669 
679  std::unique_ptr<Geometry> Union(const Geometry* other) const;
680  // throw(IllegalArgumentException *, TopologyException *);
681 
699  Ptr Union() const;
700  // throw(IllegalArgumentException *, TopologyException *);
701 
712  std::unique_ptr<Geometry> difference(const Geometry* other) const;
713 
723  std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
724 
729  virtual bool equalsExact(const Geometry* other, double tolerance = 0)
730  const = 0; // Abstract
731 
732  virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
733  virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
734  virtual void apply_rw(GeometryFilter* filter);
735  virtual void apply_ro(GeometryFilter* filter) const;
736  virtual void apply_rw(GeometryComponentFilter* filter);
737  virtual void apply_ro(GeometryComponentFilter* filter) const;
738 
747  virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
748 
755  virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
756 
766  template <class T>
767  void
769  {
770  for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
771  f.filter(getGeometryN(i));
772  }
773  }
774 
780  virtual void normalize() = 0; //Abstract
781 
783  virtual int compareTo(const Geometry* geom) const;
784 
789  virtual double distance(const Geometry* g) const;
790 
792  virtual double getArea() const;
793 
795  virtual double getLength() const;
796 
808  virtual bool isWithinDistance(const Geometry* geom,
809  double cDistance) const;
810 
820  virtual std::unique_ptr<Point> getCentroid() const;
821 
823  //
826  virtual bool getCentroid(Coordinate& ret) const;
827 
838  std::unique_ptr<Point> getInteriorPoint() const;
839 
845  virtual void geometryChanged();
846 
853 
854 protected:
855 
857  mutable std::unique_ptr<Envelope> envelope;
858 
860  template<typename T>
861  static bool hasNonEmptyElements(const std::vector<T>* geometries) {
862  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
863  }
864 
866  static bool hasNullElements(const CoordinateSequence* list);
867 
869  template<typename T>
870  static bool hasNullElements(const std::vector<T>* geometries) {
871  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
872  }
873 
874 // static void reversePointOrder(CoordinateSequence* coordinates);
875 // static Coordinate& minCoordinate(CoordinateSequence* coordinates);
876 // static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
877 // static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
878 //
883  virtual bool isEquivalentClass(const Geometry* other) const;
884 
885  static void checkNotGeometryCollection(const Geometry* g);
886  // throw(IllegalArgumentException *);
887 
888  //virtual void checkEqualSRID(Geometry *other);
889 
890  //virtual void checkEqualPrecisionModel(Geometry *other);
891 
892  virtual Envelope::Ptr computeEnvelopeInternal() const = 0; //Abstract
893 
894  virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
895 
896  int compare(std::vector<Coordinate> a, std::vector<Coordinate> b) const;
897 
898  int compare(std::vector<Geometry*> a, std::vector<Geometry*> b) const;
899 
900  int compare(const std::vector<std::unique_ptr<Geometry>> & a, const std::vector<std::unique_ptr<Geometry>> & b) const;
901 
902  bool equal(const Coordinate& a, const Coordinate& b,
903  double tolerance) const;
904  int SRID;
905 
906  Geometry(const Geometry& geom);
907 
917  Geometry(const GeometryFactory* factory);
918 
919  template<typename T>
920  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
921  static_assert(std::is_base_of<Geometry, T>::value, "");
922  std::vector<std::unique_ptr<Geometry>> gv(v.size());
923  for (size_t i = 0; i < v.size(); i++) {
924  gv[i] = std::move(v[i]);
925  }
926  return gv;
927  }
928 
929 protected:
930 
931  virtual int getSortIndex() const = 0;
932 
933 
934 private:
935 
936  class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
937  public:
938  void filter_rw(Geometry* geom) override;
939  };
940 
941  static GeometryChangedFilter geometryChangedFilter;
942 
947  const GeometryFactory* _factory;
948 
949  void* _userData;
950 };
951 
956 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
957 
958 struct GEOS_DLL GeometryGreaterThen {
959  bool operator()(const Geometry* first, const Geometry* second);
960 };
961 
962 
964 GEOS_DLL std::string geosversion();
965 
971 GEOS_DLL std::string jtsport();
972 
973 // We use this instead of std::pair<unique_ptr<Geometry>> because C++11
974 // forbids that construct:
975 // http://lwg.github.com/issues/lwg-closed.html#2068
976 struct GeomPtrPair {
977  typedef std::unique_ptr<Geometry> GeomPtr;
978  GeomPtr first;
979  GeomPtr second;
980 };
981 
982 } // namespace geos::geom
983 } // namespace geos
984 
985 #ifdef _MSC_VER
986 #pragma warning(pop)
987 #endif
988 
989 #endif // ndef GEOS_GEOM_GEOMETRY_H
Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geome...
Definition: CoordinateFilter.h:43
Interface for classes which provide operations that can be applied to the coordinates in a Coordinate...
Definition: CoordinateSequenceFilter.h:57
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:58
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:60
DimensionType
Definition: Dimension.h:31
@ A
Dimension value of a surface (2).
Definition: Dimension.h:48
@ L
Dimension value of a curve (1).
Definition: Dimension.h:45
@ P
Dimension value of a point (0).
Definition: Dimension.h:42
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:58
Definition: GeometryComponentFilter.h:43
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:68
Geometry classes support the concept of applying a Geometry filter to the Geometry.
Definition: GeometryFilter.h:47
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:188
virtual int getBoundaryDimension() const =0
Returns the dimension of this Geometrys inherent boundary.
std::unique_ptr< IntersectionMatrix > relate(const Geometry *g) const
Returns the DE-9IM intersection matrix for the two Geometrys.
std::vector< Geometry * > NonConstVect
A vector of non-const Geometry pointers.
Definition: Geometry.h:198
void applyComponentFilter(T &f) const
Apply a filter to each component of this geometry. The filter is expected to provide a ....
Definition: Geometry.h:768
virtual int compareTo(const Geometry *geom) const
Comparator for sorting geometry.
virtual ~Geometry()
Destroy Geometry and all components.
virtual bool equals(const Geometry *g) const
Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**FFF*.
void geometryChangedAction()
Notifies this Geometry that its Coordinates have been changed by an external party.
virtual void apply_rw(CoordinateSequenceFilter &filter)=0
std::unique_ptr< Geometry > buffer(double distance, int quadrantSegments) const
Returns a buffer region around this Geometry having the given width and with a specified number of se...
const GeometryFactory * getFactory() const
Gets the factory which contains the context in which this geometry was created.
Definition: Geometry.h:218
virtual bool equalsExact(const Geometry *other, double tolerance=0) const =0
Returns true iff the two Geometrys are of the same type and their vertices corresponding by index are...
virtual bool isDimensionStrict(Dimension::DimensionType d) const
Checks whether this Geometry consists only of components having dimension d.
Definition: Geometry.h:348
virtual void normalize()=0
std::unique_ptr< Envelope > envelope
The bounding box of this Geometry.
Definition: Geometry.h:857
virtual void apply_ro(CoordinateSequenceFilter &filter) const =0
virtual bool intersects(const Geometry *g) const
Returns true if disjoint returns false.
virtual const Envelope * getEnvelopeInternal() const
Returns the minimum and maximum x and y values in this Geometry, or a null Envelope if this Geometry ...
virtual bool crosses(const Geometry *g) const
virtual GeometryTypeId getGeometryTypeId() const =0
Return an integer representation of this Geometry type.
virtual std::unique_ptr< Geometry > getBoundary() const =0
Returns the boundary, or an empty geometry of appropriate dimension if this Geometry is empty.
virtual std::string getGeometryType() const =0
Return a string representation of this Geometry type.
const PrecisionModel * getPrecisionModel() const
Get the PrecisionModel used to create this Geometry.
virtual uint8_t getCoordinateDimension() const =0
Returns the coordinate dimension of this Geometry (2=XY, 3=XYZ, 4=XYZM in future).
virtual bool isWithinDistance(const Geometry *geom, double cDistance) const
Tests whether the distance from this Geometry to another is less than or equal to a specified value.
virtual double getLength() const
Returns the length of this Geometry.
virtual double distance(const Geometry *g) const
Returns the minimum distance between this Geometry and the Geometry g.
virtual std::unique_ptr< Geometry > reverse() const =0
Computes a new geometry which has all component coordinate sequences in reverse order (opposite orien...
std::unique_ptr< Geometry > Ptr
An unique_ptr of Geometry.
Definition: Geometry.h:201
virtual bool getCentroid(Coordinate &ret) const
Computes the centroid of this Geometry as a Coordinate.
virtual std::unique_ptr< Geometry > clone() const =0
Make a deep-copy of this Geometry.
virtual std::unique_ptr< Point > getCentroid() const
Computes the centroid of this Geometry.
virtual std::unique_ptr< CoordinateSequence > getCoordinates() const =0
Returns this Geometry vertices. Caller takes ownership of the returned object.
void * getUserData() const
Gets the user data object for this geometry, if any.
Definition: Geometry.h:249
virtual bool within(const Geometry *g) const
Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**F***.
virtual std::size_t getNumPoints() const =0
Returns the count of this Geometrys vertices.
virtual std::unique_ptr< Geometry > getEnvelope() const
Returns this Geometrys bounding box.
static bool hasNullElements(const CoordinateSequence *list)
Returns true if the CoordinateSequence contains any null elements.
void setUserData(void *newUserData)
A simple scheme for applications to add their own custom data to a Geometry. An example use might be ...
Definition: Geometry.h:237
virtual bool isEmpty() const =0
Returns whether or not the set of points in this Geometry is empty.
std::unique_ptr< Geometry > buffer(double distance) const
std::unique_ptr< Geometry > intersection(const Geometry *other) const
Returns a Geometry representing the points shared by this Geometry and other.
bool relate(const Geometry *g, const std::string &intersectionPattern) const
Returns true if the elements in the DE-9IM intersection matrix for the two Geometrys match the elemen...
Geometry(const GeometryFactory *factory)
Construct a geometry with the given GeometryFactory.
std::vector< const Geometry * > ConstVect
A vector of const Geometry pointers.
Definition: Geometry.h:195
virtual int getSRID() const
Returns the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:265
virtual bool touches(const Geometry *other) const
Returns true if the DE-9IM intersection matrix for the two Geometrys is FT*******,...
std::unique_ptr< Geometry > Union(const Geometry *other) const
Returns a Geometry representing all the points in this Geometry and other.
virtual std::string toString() const
Returns the Well-known Text representation of this Geometry.
virtual bool isValid() const
Tests the validity of this Geometry.
virtual bool isSimple() const
Returns false if the Geometry not simple.
static bool hasNonEmptyElements(const std::vector< T > *geometries)
Returns true if the array contains any non-empty Geometrys.
Definition: Geometry.h:861
Ptr Union() const
Computes the union of all the elements of this geometry. Heterogeneous GeometryCollections are fully ...
virtual bool disjoint(const Geometry *other) const
std::unique_ptr< Geometry > buffer(double distance, int quadrantSegments, int endCapStyle) const
Computes a buffer area around this geometry having the given width and with a specified accuracy of a...
virtual bool contains(const Geometry *g) const
Returns true if other.within(this) returns true.
virtual bool isEquivalentClass(const Geometry *other) const
Returns whether the two Geometrys are equal, from the point of view of the equalsExact method.
bool coveredBy(const Geometry *g) const
Tests whether this geometry is covered by the specified geometry.
Definition: Geometry.h:581
std::unique_ptr< Geometry > difference(const Geometry *other) const
Returns a Geometry representing the points making up this Geometry that do not make up other.
virtual std::size_t getNumGeometries() const
Definition: Geometry.h:310
virtual double getArea() const
Returns the area of this Geometry.
virtual const Coordinate * getCoordinate() const =0
Returns a vertex of this Geometry, or NULL if this is the empty geometry.
std::unique_ptr< Geometry > symDifference(const Geometry *other) const
Returns a set combining the points in this Geometry not in other, and the points in other not in this...
std::unique_ptr< Point > getInteriorPoint() const
Computes an interior point of this Geometry.
virtual bool isRectangle() const
Polygon overrides to check for actual rectangle.
Definition: Geometry.h:339
virtual bool overlaps(const Geometry *g) const
Returns true if the DE-9IM intersection matrix for the two Geometrys is T*T***T** (for two points or ...
virtual const Geometry * getGeometryN(std::size_t) const
Returns a pointer to the nth Geometry in this collection (or self if this is not a collection)
Definition: Geometry.h:318
bool covers(const Geometry *g) const
Returns true if this geometry covers the specified geometry.
virtual Dimension::DimensionType getDimension() const =0
Returns the dimension of this Geometry (0=point, 1=line, 2=surface)
virtual void geometryChanged()
Notifies this Geometry that its Coordinates have been changed by an external party (using a Coordinat...
virtual std::unique_ptr< Geometry > convexHull() const
Returns the smallest convex Polygon that contains all the points in the Geometry.
static bool hasNullElements(const std::vector< T > *geometries)
Returns true if the vector contains any null elements.
Definition: Geometry.h:870
virtual void setSRID(int newSRID)
Sets the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:274
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:87
std::ostream & operator<<(std::ostream &os, const Coordinate &c)
Output function.
GeometryTypeId
Geometry types.
Definition: Geometry.h:75
@ GEOS_MULTILINESTRING
a collection of linestrings
Definition: Geometry.h:87
@ GEOS_LINEARRING
a linear ring (linestring with 1st point == last point)
Definition: Geometry.h:81
@ GEOS_GEOMETRYCOLLECTION
a collection of heterogeneus geometries
Definition: Geometry.h:91
@ GEOS_POINT
a point
Definition: Geometry.h:77
@ GEOS_LINESTRING
a linestring
Definition: Geometry.h:79
@ GEOS_POLYGON
a polygon
Definition: Geometry.h:83
@ GEOS_MULTIPOLYGON
a collection of polygons
Definition: Geometry.h:89
@ GEOS_MULTIPOINT
a collection of points
Definition: Geometry.h:85
std::string jtsport()
Return the version of JTS this GEOS release has been ported from.
std::string geosversion()
Return current GEOS version.
Basic namespace for all GEOS functionalities.
Definition: IndexedNestedRingTester.h:26