GEOS  3.13.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 #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 #include <geos/geom/CoordinateSequence.h> // to materialize CoordinateSequence
38 
39 #include <algorithm>
40 #include <string>
41 #include <iostream>
42 #include <vector>
43 #include <memory>
44 
45 #ifdef _MSC_VER
46 #pragma warning(push)
47 #pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
48 #pragma warning(disable: 4355) // warning C4355: 'this' : used in base member initializer list
49 #endif
50 
51 // Forward declarations
52 namespace geos {
53 namespace geom {
54 class Coordinate;
55 class CoordinateFilter;
56 class CoordinateSequence;
57 class CoordinateSequenceFilter;
58 class GeometryComponentFilter;
59 class GeometryFactory;
60 class GeometryFilter;
61 class PrecisionModel;
62 class Point;
63 class IntersectionMatrix;
64 }
65 namespace io { // geos.io
66 class Unload;
67 } // namespace geos.io
68 }
69 
70 namespace geos { // geos
71 namespace geom { // geos::geom
72 
74 enum GeometryTypeId : int {
91  GEOS_CIRCULARSTRING,
92  GEOS_COMPOUNDCURVE,
93  GEOS_CURVEPOLYGON,
94  GEOS_MULTICURVE,
95  GEOS_MULTISURFACE,
96 };
97 
98 enum GeometrySortIndex {
99  SORTINDEX_POINT = 0,
100  SORTINDEX_MULTIPOINT = 1,
101  SORTINDEX_LINESTRING = 2,
102  SORTINDEX_LINEARRING = 3,
103  SORTINDEX_MULTILINESTRING = 4,
104  SORTINDEX_POLYGON = 5,
105  SORTINDEX_MULTIPOLYGON = 6,
106  SORTINDEX_GEOMETRYCOLLECTION = 7,
107  SORTINDEX_CIRCULARSTRING = 8,
108  SORTINDEX_COMPOUNDCURVE = 9,
109  SORTINDEX_CURVEPOLYGON = 10,
110  SORTINDEX_MULTICURVE = 11,
111  SORTINDEX_MULTISURFACE = 12,
112 };
113 
197 class GEOS_DLL Geometry {
198 
199 public:
200 
201  friend class GeometryFactory;
202 
204  using ConstVect = std::vector<const Geometry*>;
205 
207  using NonConstVect = std::vector<Geometry*>;
208 
210  using Ptr = std::unique_ptr<Geometry> ;
211 
213  std::unique_ptr<Geometry> clone() const { return std::unique_ptr<Geometry>(cloneImpl()); }
214 
216  virtual ~Geometry();
217 
218 
226  const GeometryFactory*
227  getFactory() const
228  {
229  return _factory;
230  }
231 
245  void
246  setUserData(void* newUserData)
247  {
248  _userData = newUserData;
249  }
250 
257  void*
258  getUserData() const
259  {
260  return _userData;
261  }
262 
273  virtual int
274  getSRID() const
275  {
276  return SRID;
277  }
278 
282  virtual void
283  setSRID(int newSRID)
284  {
285  SRID = newSRID;
286  }
287 
293 
295  virtual const CoordinateXY* getCoordinate() const = 0; //Abstract
296 
302  virtual std::unique_ptr<CoordinateSequence> getCoordinates() const = 0; //Abstract
303 
305  virtual std::size_t getNumPoints() const = 0; //Abstract
306 
308  virtual bool isSimple() const;
309 
311  virtual std::string getGeometryType() const = 0; //Abstract
312 
314  virtual bool hasCurvedComponents() const;
315 
317  virtual GeometryTypeId getGeometryTypeId() const = 0; //Abstract
318 
326  virtual std::size_t
328  {
329  return 1;
330  }
331 
334  virtual const Geometry*
335  getGeometryN(std::size_t /*n*/) const
336  {
337  return this;
338  }
339 
349  virtual bool isValid() const;
350 
352  virtual bool isEmpty() const = 0; //Abstract
353 
355  virtual bool
356  isRectangle() const
357  {
358  return false;
359  }
360 
362  virtual Dimension::DimensionType getDimension() const = 0; //Abstract
363 
365  virtual bool hasDimension(Dimension::DimensionType d) const {
366  return getDimension() == d;
367  }
368 
371  return d == getDimension();
372  }
373 
374  bool isPuntal() const {
375  return isDimensionStrict(Dimension::P);
376  }
377 
378  bool isLineal() const {
379  return isDimensionStrict(Dimension::L);
380  }
381 
382  bool isPolygonal() const {
383  return isDimensionStrict(Dimension::A);
384  }
385 
386  bool isMixedDimension() const;
387  bool isMixedDimension(Dimension::DimensionType* baseDim) const;
388 
389  bool isCollection() const {
390  int t = getGeometryTypeId();
391  return t == GEOS_GEOMETRYCOLLECTION ||
392  t == GEOS_MULTIPOINT ||
393  t == GEOS_MULTILINESTRING ||
394  t == GEOS_MULTIPOLYGON;
395  }
396 
397  static GeometryTypeId multiTypeId(GeometryTypeId typeId) {
398  switch (typeId) {
399  case GEOS_POINT: return GEOS_MULTIPOINT;
401  case GEOS_POLYGON: return GEOS_MULTIPOLYGON;
402  default: return typeId;
403  }
404  }
405 
407  virtual uint8_t getCoordinateDimension() const = 0; //Abstract
408 
409  virtual bool hasZ() const = 0;
410 
411  virtual bool hasM() const = 0;
412 
429  virtual std::unique_ptr<Geometry> getBoundary() const = 0; //Abstract
430 
432  virtual int getBoundaryDimension() const = 0; //Abstract
433 
435  virtual std::unique_ptr<Geometry> getEnvelope() const;
436 
441  virtual const Envelope* getEnvelopeInternal() const = 0;
442 
459  virtual bool disjoint(const Geometry* other) const;
460 
465  virtual bool touches(const Geometry* other) const;
466 
468  virtual bool intersects(const Geometry* g) const;
469 
492  virtual bool crosses(const Geometry* g) const;
493 
498  virtual bool within(const Geometry* g) const;
499 
501  virtual bool contains(const Geometry* g) const;
502 
508  virtual bool overlaps(const Geometry* g) const;
509 
524  bool relate(const Geometry* g,
525  const std::string& intersectionPattern) const;
526 
527  bool
528  relate(const Geometry& g, const std::string& intersectionPattern) const
529  {
530  return relate(&g, intersectionPattern);
531  }
532 
534  std::unique_ptr<IntersectionMatrix> relate(const Geometry* g) const;
535 
536  std::unique_ptr<IntersectionMatrix> relate(const Geometry& g) const;
537 
543  virtual bool equals(const Geometry* g) const;
544 
583  bool covers(const Geometry* g) const;
584 
615  bool coveredBy(const Geometry* g) const;
616 
617 
619  virtual std::string toString() const;
620 
621  virtual std::string toText() const;
622 
627  std::unique_ptr<Geometry> buffer(double distance) const;
628 
636  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
637 
674  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
675  int endCapStyle) const;
676 
680  virtual std::unique_ptr<Geometry> convexHull() const;
681 
688  std::unique_ptr<Geometry> reverse() const { return std::unique_ptr<Geometry>(reverseImpl()); }
689 
699  std::unique_ptr<Geometry> intersection(const Geometry* other) const;
700 
710  std::unique_ptr<Geometry> Union(const Geometry* other) const;
711  // throw(IllegalArgumentException *, TopologyException *);
712 
730  Ptr Union() const;
731  // throw(IllegalArgumentException *, TopologyException *);
732 
743  std::unique_ptr<Geometry> difference(const Geometry* other) const;
744 
754  std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
755 
762  virtual bool equalsExact(const Geometry* other, double tolerance = 0)
763  const = 0; // Abstract
764 
769  virtual bool equalsIdentical(const Geometry* other) const = 0;
770 
771  virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
772  virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
773  virtual void apply_rw(GeometryFilter* filter);
774  virtual void apply_ro(GeometryFilter* filter) const;
775  virtual void apply_rw(GeometryComponentFilter* filter);
776  virtual void apply_ro(GeometryComponentFilter* filter) const;
777 
786  virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
787 
794  virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
795 
805  template <class T>
806  void
808  {
809  for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
810  f.filter(getGeometryN(i));
811  }
812  }
813 
819  virtual void normalize() = 0; //Abstract
820 
822  virtual int compareTo(const Geometry* geom) const;
823 
825  virtual double getArea() const;
826 
828  virtual double getLength() const;
829 
835  virtual double distance(const Geometry* g) const;
836 
837 
849  virtual bool isWithinDistance(const Geometry* geom,
850  double cDistance) const;
851 
861  virtual std::unique_ptr<Point> getCentroid() const;
862 
864  //
867  virtual bool getCentroid(CoordinateXY& ret) const;
868 
879  std::unique_ptr<Point> getInteriorPoint() const;
880 
886  virtual void geometryChanged();
887 
893  virtual void geometryChangedAction() = 0;
894 
895 protected:
897  virtual Geometry* cloneImpl() const = 0;
898 
900  virtual Geometry* reverseImpl() const = 0;
901 
903  template<typename T>
904  static bool hasNonEmptyElements(const std::vector<T>* geometries) {
905  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
906  }
907 
909  static bool hasNullElements(const CoordinateSequence* list);
910 
912  template<typename T>
913  static bool hasNullElements(const std::vector<T>* geometries) {
914  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
915  }
916 
917 // static void reversePointOrder(CoordinateSequence* coordinates);
918 // static Coordinate& minCoordinate(CoordinateSequence* coordinates);
919 // static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
920 // static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
921 //
926  virtual bool isEquivalentClass(const Geometry* other) const;
927 
928  static void checkNotGeometryCollection(const Geometry* g);
929 
930  virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
931 
932  template<typename T>
933  static int compare(const T& a, const T& b)
934  {
935  std::size_t i = 0;
936  std::size_t j = 0;
937  while(i < a.size() && j < b.size()) {
938  const auto& aGeom = *a[i];
939  const auto& bGeom = *b[j];
940 
941  int comparison = aGeom.compareTo(&bGeom);
942  if(comparison != 0) {
943  return comparison;
944  }
945 
946  i++;
947  j++;
948  }
949 
950  if(i < a.size()) {
951  return 1;
952  }
953 
954  if(j < b.size()) {
955  return -1;
956  }
957 
958  return 0;
959  }
960 
961  bool equal(const CoordinateXY& a, const CoordinateXY& b,
962  double tolerance) const;
963  int SRID;
964 
965  Geometry(const Geometry& geom);
966 
976  Geometry(const GeometryFactory* factory);
977 
978  template<typename T>
979  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
980  static_assert(std::is_base_of<Geometry, T>::value, "");
981  std::vector<std::unique_ptr<Geometry>> gv(v.size());
982  for (std::size_t i = 0; i < v.size(); i++) {
983  gv[i] = std::move(v[i]);
984  }
985  return gv;
986  }
987 
988  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<Geometry>> && v) {
989  return std::move(v);
990  }
991 
992 protected:
993 
994  virtual int getSortIndex() const = 0;
995 
996 
997 private:
998 
999  class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
1000  public:
1001  void filter_rw(Geometry* geom) override;
1002  };
1003 
1004  static GeometryChangedFilter geometryChangedFilter;
1005 
1010  const GeometryFactory* _factory;
1011 
1012  void* _userData;
1013 };
1014 
1019 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
1020 
1021 struct GEOS_DLL GeometryGreaterThen {
1022  bool operator()(const Geometry* first, const Geometry* second);
1023 };
1024 
1025 
1027 GEOS_DLL std::string geosversion();
1028 
1034 GEOS_DLL std::string jtsport();
1035 
1036 // We use this instead of std::pair<unique_ptr<Geometry>> because C++11
1037 // forbids that construct:
1038 // http://lwg.github.com/issues/lwg-closed.html#2068
1039 struct GeomPtrPair {
1040  typedef std::unique_ptr<Geometry> GeomPtr;
1041  GeomPtr first;
1042  GeomPtr second;
1043 };
1044 
1045 } // namespace geos::geom
1046 } // namespace geos
1047 
1048 #ifdef _MSC_VER
1049 #pragma warning(pop)
1050 #endif
1051 
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:59
Definition: GeometryComponentFilter.h:41
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:70
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:197
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:207
void applyComponentFilter(T &f) const
Apply a filter to each component of this geometry. The filter is expected to provide a ....
Definition: Geometry.h:807
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:227
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:370
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:365
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:210
virtual Geometry * reverseImpl() const =0
Make a geometry with coordinates in reverse order.
virtual bool hasCurvedComponents() const
Returns whether the Geometry contains curved components.
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:258
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:246
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:204
virtual int getSRID() const
Returns the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:274
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:904
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:688
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.
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:213
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:327
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:356
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:335
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:913
virtual void setSRID(int newSRID)
Sets the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:283
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:88
std::string jtsport()
Return the version of JTS this GEOS release has been ported from.
std::string geosversion()
Return current GEOS version.
GeometryTypeId
Geometry types.
Definition: Geometry.h:74
@ GEOS_MULTILINESTRING
a collection of linestrings
Definition: Geometry.h:86
@ GEOS_LINEARRING
a linear ring (linestring with 1st point == last point)
Definition: Geometry.h:80
@ GEOS_GEOMETRYCOLLECTION
a collection of heterogeneus geometries
Definition: Geometry.h:90
@ GEOS_POINT
a point
Definition: Geometry.h:76
@ GEOS_LINESTRING
a linestring
Definition: Geometry.h:78
@ GEOS_POLYGON
a polygon
Definition: Geometry.h:82
@ GEOS_MULTIPOLYGON
a collection of polygons
Definition: Geometry.h:88
@ GEOS_MULTIPOINT
a collection of points
Definition: Geometry.h:84
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25