GEOS  3.13.0dev
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 #pragma once
22 
23 #ifndef USE_UNSTABLE_GEOS_CPP_API
24 #ifndef _MSC_VER
25 # warning "The GEOS C++ API is unstable, please use the C API instead"
26 # warning "HINT: #include geos_c.h"
27 #else
28 #pragma message("The GEOS C++ API is unstable, please use the C API instead")
29 #pragma message("HINT: #include geos_c.h")
30 #endif
31 #endif
32 
33 #include <geos/export.h>
34 #include <geos/geom/Envelope.h>
35 #include <geos/geom/Dimension.h> // for Dimension::DimensionType
36 #include <geos/geom/GeometryComponentFilter.h> // for inheritance
37 
38 #include <algorithm>
39 #include <string>
40 #include <iostream>
41 #include <vector>
42 #include <memory>
43 
44 #ifdef _MSC_VER
45 #pragma warning(push)
46 #pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
47 #pragma warning(disable: 4355) // warning C4355: 'this' : used in base member initializer list
48 #endif
49 
50 // Forward declarations
51 namespace geos {
52 namespace geom {
53 class Coordinate;
54 class CoordinateFilter;
55 class CoordinateSequence;
56 class CoordinateSequenceFilter;
57 class GeometryComponentFilter;
58 class GeometryFactory;
59 class GeometryFilter;
60 class PrecisionModel;
61 class Point;
62 class IntersectionMatrix;
63 }
64 namespace io { // geos.io
65 class Unload;
66 } // namespace geos.io
67 }
68 
69 namespace geos { // geos
70 namespace geom { // geos::geom
71 
90 };
91 
92 enum GeometrySortIndex {
93  SORTINDEX_POINT = 0,
94  SORTINDEX_MULTIPOINT = 1,
95  SORTINDEX_LINESTRING = 2,
96  SORTINDEX_LINEARRING = 3,
97  SORTINDEX_MULTILINESTRING = 4,
98  SORTINDEX_POLYGON = 5,
99  SORTINDEX_MULTIPOLYGON = 6,
100  SORTINDEX_GEOMETRYCOLLECTION = 7
101 };
102 
186 class GEOS_DLL Geometry {
187 
188 public:
189 
190  friend class GeometryFactory;
191 
193  using ConstVect = std::vector<const Geometry*>;
194 
196  using NonConstVect = std::vector<Geometry*>;
197 
199  using Ptr = std::unique_ptr<Geometry> ;
200 
202  std::unique_ptr<Geometry> clone() const { return std::unique_ptr<Geometry>(cloneImpl()); }
203 
205  virtual ~Geometry();
206 
207 
215  const GeometryFactory*
216  getFactory() const
217  {
218  return _factory;
219  }
220 
234  void
235  setUserData(void* newUserData)
236  {
237  _userData = newUserData;
238  }
239 
246  void*
247  getUserData() const
248  {
249  return _userData;
250  }
251 
262  virtual int
263  getSRID() const
264  {
265  return SRID;
266  }
267 
271  virtual void
272  setSRID(int newSRID)
273  {
274  SRID = newSRID;
275  }
276 
282 
284  virtual const CoordinateXY* getCoordinate() const = 0; //Abstract
285 
291  virtual std::unique_ptr<CoordinateSequence> getCoordinates() const = 0; //Abstract
292 
294  virtual std::size_t getNumPoints() const = 0; //Abstract
295 
297  virtual bool isSimple() const;
298 
300  virtual std::string getGeometryType() const = 0; //Abstract
301 
303  virtual GeometryTypeId getGeometryTypeId() const = 0; //Abstract
304 
312  virtual std::size_t
314  {
315  return 1;
316  }
317 
320  virtual const Geometry*
321  getGeometryN(std::size_t /*n*/) const
322  {
323  return this;
324  }
325 
335  virtual bool isValid() const;
336 
338  virtual bool isEmpty() const = 0; //Abstract
339 
341  virtual bool
342  isRectangle() const
343  {
344  return false;
345  }
346 
348  virtual Dimension::DimensionType getDimension() const = 0; //Abstract
349 
351  virtual bool hasDimension(Dimension::DimensionType d) const {
352  return getDimension() == d;
353  }
354 
357  return d == getDimension();
358  }
359 
360  bool isPuntal() const {
361  return isDimensionStrict(Dimension::P);
362  }
363 
364  bool isLineal() const {
365  return isDimensionStrict(Dimension::L);
366  }
367 
368  bool isPolygonal() const {
369  return isDimensionStrict(Dimension::A);
370  }
371 
372  bool isMixedDimension() const;
373  bool isMixedDimension(Dimension::DimensionType* baseDim) const;
374 
375  bool isCollection() const {
376  int t = getGeometryTypeId();
377  return t == GEOS_GEOMETRYCOLLECTION ||
378  t == GEOS_MULTIPOINT ||
379  t == GEOS_MULTILINESTRING ||
380  t == GEOS_MULTIPOLYGON;
381  }
382 
383  static GeometryTypeId multiTypeId(GeometryTypeId typeId) {
384  switch (typeId) {
385  case GEOS_POINT: return GEOS_MULTIPOINT;
387  case GEOS_POLYGON: return GEOS_MULTIPOLYGON;
388  default: return typeId;
389  }
390  }
391 
393  virtual uint8_t getCoordinateDimension() const = 0; //Abstract
394 
395  virtual bool hasZ() const = 0;
396 
397  virtual bool hasM() const = 0;
398 
415  virtual std::unique_ptr<Geometry> getBoundary() const = 0; //Abstract
416 
418  virtual int getBoundaryDimension() const = 0; //Abstract
419 
421  virtual std::unique_ptr<Geometry> getEnvelope() const;
422 
427  virtual const Envelope* getEnvelopeInternal() const = 0;
428 
445  virtual bool disjoint(const Geometry* other) const;
446 
451  virtual bool touches(const Geometry* other) const;
452 
454  virtual bool intersects(const Geometry* g) const;
455 
478  virtual bool crosses(const Geometry* g) const;
479 
484  virtual bool within(const Geometry* g) const;
485 
487  virtual bool contains(const Geometry* g) const;
488 
494  virtual bool overlaps(const Geometry* g) const;
495 
510  bool relate(const Geometry* g,
511  const std::string& intersectionPattern) const;
512 
513  bool
514  relate(const Geometry& g, const std::string& intersectionPattern) const
515  {
516  return relate(&g, intersectionPattern);
517  }
518 
520  std::unique_ptr<IntersectionMatrix> relate(const Geometry* g) const;
521 
522  std::unique_ptr<IntersectionMatrix> relate(const Geometry& g) const;
523 
529  virtual bool equals(const Geometry* g) const;
530 
569  bool covers(const Geometry* g) const;
570 
601  bool
602  coveredBy(const Geometry* g) const
603  {
604  return g->covers(this);
605  }
606 
607 
609  virtual std::string toString() const;
610 
611  virtual std::string toText() const;
612 
617  std::unique_ptr<Geometry> buffer(double distance) const;
618 
626  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
627 
664  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
665  int endCapStyle) const;
666 
670  virtual std::unique_ptr<Geometry> convexHull() const;
671 
678  std::unique_ptr<Geometry> reverse() const { return std::unique_ptr<Geometry>(reverseImpl()); }
679 
689  std::unique_ptr<Geometry> intersection(const Geometry* other) const;
690 
700  std::unique_ptr<Geometry> Union(const Geometry* other) const;
701  // throw(IllegalArgumentException *, TopologyException *);
702 
720  Ptr Union() const;
721  // throw(IllegalArgumentException *, TopologyException *);
722 
733  std::unique_ptr<Geometry> difference(const Geometry* other) const;
734 
744  std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
745 
752  virtual bool equalsExact(const Geometry* other, double tolerance = 0)
753  const = 0; // Abstract
754 
759  virtual bool equalsIdentical(const Geometry* other) const = 0;
760 
761  virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
762  virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
763  virtual void apply_rw(GeometryFilter* filter);
764  virtual void apply_ro(GeometryFilter* filter) const;
765  virtual void apply_rw(GeometryComponentFilter* filter);
766  virtual void apply_ro(GeometryComponentFilter* filter) const;
767 
776  virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
777 
784  virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
785 
795  template <class T>
796  void
798  {
799  for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
800  f.filter(getGeometryN(i));
801  }
802  }
803 
809  virtual void normalize() = 0; //Abstract
810 
812  virtual int compareTo(const Geometry* geom) const;
813 
815  virtual double getArea() const;
816 
818  virtual double getLength() const;
819 
825  virtual double distance(const Geometry* g) const;
826 
827 
839  virtual bool isWithinDistance(const Geometry* geom,
840  double cDistance) const;
841 
851  virtual std::unique_ptr<Point> getCentroid() const;
852 
854  //
857  virtual bool getCentroid(CoordinateXY& ret) const;
858 
869  std::unique_ptr<Point> getInteriorPoint() const;
870 
876  virtual void geometryChanged();
877 
883  virtual void geometryChangedAction() = 0;
884 
885 protected:
887  virtual Geometry* cloneImpl() const = 0;
888 
890  virtual Geometry* reverseImpl() const = 0;
891 
893  template<typename T>
894  static bool hasNonEmptyElements(const std::vector<T>* geometries) {
895  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
896  }
897 
899  static bool hasNullElements(const CoordinateSequence* list);
900 
902  template<typename T>
903  static bool hasNullElements(const std::vector<T>* geometries) {
904  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
905  }
906 
907 // static void reversePointOrder(CoordinateSequence* coordinates);
908 // static Coordinate& minCoordinate(CoordinateSequence* coordinates);
909 // static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
910 // static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
911 //
916  virtual bool isEquivalentClass(const Geometry* other) const;
917 
918  static void checkNotGeometryCollection(const Geometry* g);
919 
920  virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
921 
922  int compare(std::vector<Coordinate> a, std::vector<Coordinate> b) const;
923 
924  int compare(std::vector<Geometry*> a, std::vector<Geometry*> b) const;
925 
926  int compare(const std::vector<std::unique_ptr<Geometry>> & a, const std::vector<std::unique_ptr<Geometry>> & b) const;
927 
928  bool equal(const CoordinateXY& a, const CoordinateXY& b,
929  double tolerance) const;
930  int SRID;
931 
932  Geometry(const Geometry& geom);
933 
943  Geometry(const GeometryFactory* factory);
944 
945  template<typename T>
946  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
947  static_assert(std::is_base_of<Geometry, T>::value, "");
948  std::vector<std::unique_ptr<Geometry>> gv(v.size());
949  for (std::size_t i = 0; i < v.size(); i++) {
950  gv[i] = std::move(v[i]);
951  }
952  return gv;
953  }
954 
955  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<Geometry>> && v) {
956  return std::move(v);
957  }
958 
959 protected:
960 
961  virtual int getSortIndex() const = 0;
962 
963 
964 private:
965 
966  class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
967  public:
968  void filter_rw(Geometry* geom) override;
969  };
970 
971  static GeometryChangedFilter geometryChangedFilter;
972 
977  const GeometryFactory* _factory;
978 
979  void* _userData;
980 };
981 
986 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
987 
988 struct GEOS_DLL GeometryGreaterThen {
989  bool operator()(const Geometry* first, const Geometry* second);
990 };
991 
992 
994 GEOS_DLL std::string geosversion();
995 
1001 GEOS_DLL std::string jtsport();
1002 
1003 // We use this instead of std::pair<unique_ptr<Geometry>> because C++11
1004 // forbids that construct:
1005 // http://lwg.github.com/issues/lwg-closed.html#2068
1006 struct GeomPtrPair {
1007  typedef std::unique_ptr<Geometry> GeomPtr;
1008  GeomPtr first;
1009  GeomPtr second;
1010 };
1011 
1012 } // namespace geos::geom
1013 } // namespace geos
1014 
1015 #ifdef _MSC_VER
1016 #pragma warning(pop)
1017 #endif
1018 
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:55
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
DimensionType
Definition: Dimension.h:29
@ A
Dimension value of a surface (2).
Definition: Dimension.h:46
@ L
Dimension value of a curve (1).
Definition: Dimension.h:43
@ P
Dimension value of a point (0).
Definition: Dimension.h:40
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:58
Definition: GeometryComponentFilter.h:41
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:65
Geometry classes support the concept of applying a Geometry filter to the Geometry.
Definition: GeometryFilter.h:45
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:186
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.
virtual Geometry * cloneImpl() const =0
Make a deep-copy of this Geometry.
virtual bool equalsIdentical(const Geometry *other) const =0
Returns true if the two geometries are of the same type and their vertices corresponding by index are...
std::vector< Geometry * > NonConstVect
A vector of non-const Geometry pointers.
Definition: Geometry.h:196
void applyComponentFilter(T &f) const
Apply a filter to each component of this geometry. The filter is expected to provide a ....
Definition: Geometry.h:797
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*.
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...
virtual void geometryChangedAction()=0
Notifies this Geometry that its Coordinates have been changed by an external party.
const GeometryFactory * getFactory() const
Gets the factory which contains the context in which this geometry was created.
Definition: Geometry.h:216
virtual const Envelope * getEnvelopeInternal() const =0
Returns the minimum and maximum x and y values in this Geometry, or a null Envelope if this Geometry ...
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:356
virtual void normalize()=0
virtual void apply_ro(CoordinateSequenceFilter &filter) const =0
virtual bool intersects(const Geometry *g) const
Returns true if disjoint returns false.
virtual bool crosses(const Geometry *g) const
virtual GeometryTypeId getGeometryTypeId() const =0
Return an integer representation of this Geometry type.
virtual bool hasDimension(Dimension::DimensionType d) const
Checks whether any component of this geometry has dimension d.
Definition: Geometry.h:351
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 or XYM, 4=XYZM).
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
virtual bool getCentroid(CoordinateXY &ret) const
Computes the centroid of this Geometry as a Coordinate.
std::unique_ptr< Geometry > Ptr
An unique_ptr of Geometry.
Definition: Geometry.h:199
virtual Geometry * reverseImpl() const =0
Make a geometry with coordinates in reverse order.
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:247
virtual bool within(const Geometry *g) const
Returns true if the DE-9IM intersection matrix for the two Geometrys is T*F**F***.
virtual const CoordinateXY * getCoordinate() const =0
Returns a vertex of this Geometry, or NULL if this is the empty geometry.
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:235
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:193
virtual int getSRID() const
Returns the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:263
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:894
Ptr Union() const
Computes the union of all the elements of this geometry. Heterogeneous GeometryCollections are fully ...
std::unique_ptr< Geometry > reverse() const
Computes a new geometry which has all component coordinate sequences in reverse order (opposite orien...
Definition: Geometry.h:678
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:602
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.
std::unique_ptr< Geometry > clone() const
Make a deep-copy of this Geometry.
Definition: Geometry.h:202
virtual std::size_t getNumGeometries() const
Returns the number of geometries in this collection, or 1 if this is not a collection.
Definition: Geometry.h:313
virtual double getArea() const
Returns the area of this 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:342
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:321
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:903
virtual void setSRID(int newSRID)
Sets the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:272
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:88
GeometryTypeId
Geometry types.
Definition: Geometry.h:73
@ GEOS_MULTILINESTRING
a collection of linestrings
Definition: Geometry.h:85
@ GEOS_LINEARRING
a linear ring (linestring with 1st point == last point)
Definition: Geometry.h:79
@ GEOS_GEOMETRYCOLLECTION
a collection of heterogeneus geometries
Definition: Geometry.h:89
@ GEOS_POINT
a point
Definition: Geometry.h:75
@ GEOS_LINESTRING
a linestring
Definition: Geometry.h:77
@ GEOS_POLYGON
a polygon
Definition: Geometry.h:81
@ GEOS_MULTIPOLYGON
a collection of polygons
Definition: Geometry.h:87
@ GEOS_MULTIPOINT
a collection of points
Definition: Geometry.h:83
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: Angle.h:25