GEOS 3.12.0
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
51namespace geos {
52namespace geom {
53class Coordinate;
54class CoordinateFilter;
55class CoordinateSequence;
56class CoordinateSequenceFilter;
57class GeometryComponentFilter;
58class GeometryFactory;
59class GeometryFilter;
60class PrecisionModel;
61class Point;
62class IntersectionMatrix;
63}
64namespace io { // geos.io
65class Unload;
66} // namespace geos.io
67}
68
69namespace geos { // geos
70namespace geom { // geos::geom
71
90};
91
92enum 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
186class GEOS_DLL Geometry {
187
188public:
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*
217 {
218 return _factory;
219 }
220
234 void
235 setUserData(void* newUserData)
236 {
237 _userData = newUserData;
238 }
239
246 void*
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
307 virtual std::size_t
309 {
310 return 1;
311 }
312
315 virtual const Geometry*
316 getGeometryN(std::size_t /*n*/) const
317 {
318 return this;
319 }
320
330 virtual bool isValid() const;
331
333 virtual bool isEmpty() const = 0; //Abstract
334
336 virtual bool
338 {
339 return false;
340 }
341
343 virtual Dimension::DimensionType getDimension() const = 0; //Abstract
344
347 return getDimension() == d;
348 }
349
352 return d == getDimension();
353 }
354
355 bool isPuntal() const {
356 return isDimensionStrict(Dimension::P);
357 }
358
359 bool isLineal() const {
360 return isDimensionStrict(Dimension::L);
361 }
362
363 bool isPolygonal() const {
364 return isDimensionStrict(Dimension::A);
365 }
366
367 bool isMixedDimension() const;
368 bool isMixedDimension(Dimension::DimensionType* baseDim) const;
369
370 bool isCollection() const {
371 int t = getGeometryTypeId();
372 return t == GEOS_GEOMETRYCOLLECTION ||
373 t == GEOS_MULTIPOINT ||
376 }
377
378 static GeometryTypeId multiTypeId(GeometryTypeId typeId) {
379 switch (typeId) {
380 case GEOS_POINT: return GEOS_MULTIPOINT;
382 case GEOS_POLYGON: return GEOS_MULTIPOLYGON;
383 default: return typeId;
384 }
385 }
386
388 virtual uint8_t getCoordinateDimension() const = 0; //Abstract
389
390 virtual bool hasZ() const = 0;
391
392 virtual bool hasM() const = 0;
393
410 virtual std::unique_ptr<Geometry> getBoundary() const = 0; //Abstract
411
413 virtual int getBoundaryDimension() const = 0; //Abstract
414
416 virtual std::unique_ptr<Geometry> getEnvelope() const;
417
422 virtual const Envelope* getEnvelopeInternal() const = 0;
423
440 virtual bool disjoint(const Geometry* other) const;
441
446 virtual bool touches(const Geometry* other) const;
447
449 virtual bool intersects(const Geometry* g) const;
450
473 virtual bool crosses(const Geometry* g) const;
474
479 virtual bool within(const Geometry* g) const;
480
482 virtual bool contains(const Geometry* g) const;
483
489 virtual bool overlaps(const Geometry* g) const;
490
505 bool relate(const Geometry* g,
506 const std::string& intersectionPattern) const;
507
508 bool
509 relate(const Geometry& g, const std::string& intersectionPattern) const
510 {
511 return relate(&g, intersectionPattern);
512 }
513
515 std::unique_ptr<IntersectionMatrix> relate(const Geometry* g) const;
516
517 std::unique_ptr<IntersectionMatrix> relate(const Geometry& g) const;
518
524 virtual bool equals(const Geometry* g) const;
525
564 bool covers(const Geometry* g) const;
565
596 bool
597 coveredBy(const Geometry* g) const
598 {
599 return g->covers(this);
600 }
601
602
604 virtual std::string toString() const;
605
606 virtual std::string toText() const;
607
612 std::unique_ptr<Geometry> buffer(double distance) const;
613
621 std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
622
659 std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
660 int endCapStyle) const;
661
665 virtual std::unique_ptr<Geometry> convexHull() const;
666
673 std::unique_ptr<Geometry> reverse() const { return std::unique_ptr<Geometry>(reverseImpl()); }
674
684 std::unique_ptr<Geometry> intersection(const Geometry* other) const;
685
695 std::unique_ptr<Geometry> Union(const Geometry* other) const;
696 // throw(IllegalArgumentException *, TopologyException *);
697
715 Ptr Union() const;
716 // throw(IllegalArgumentException *, TopologyException *);
717
728 std::unique_ptr<Geometry> difference(const Geometry* other) const;
729
739 std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
740
747 virtual bool equalsExact(const Geometry* other, double tolerance = 0)
748 const = 0; // Abstract
749
754 virtual bool equalsIdentical(const Geometry* other) const = 0;
755
756 virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
757 virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
758 virtual void apply_rw(GeometryFilter* filter);
759 virtual void apply_ro(GeometryFilter* filter) const;
760 virtual void apply_rw(GeometryComponentFilter* filter);
761 virtual void apply_ro(GeometryComponentFilter* filter) const;
762
771 virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
772
779 virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
780
790 template <class T>
791 void
793 {
794 for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
795 f.filter(getGeometryN(i));
796 }
797 }
798
804 virtual void normalize() = 0; //Abstract
805
807 virtual int compareTo(const Geometry* geom) const;
808
810 virtual double getArea() const;
811
813 virtual double getLength() const;
814
820 virtual double distance(const Geometry* g) const;
821
822
834 virtual bool isWithinDistance(const Geometry* geom,
835 double cDistance) const;
836
846 virtual std::unique_ptr<Point> getCentroid() const;
847
849 //
852 virtual bool getCentroid(CoordinateXY& ret) const;
853
864 std::unique_ptr<Point> getInteriorPoint() const;
865
871 virtual void geometryChanged();
872
878 virtual void geometryChangedAction() = 0;
879
880protected:
882 virtual Geometry* cloneImpl() const = 0;
883
885 virtual Geometry* reverseImpl() const = 0;
886
888 template<typename T>
889 static bool hasNonEmptyElements(const std::vector<T>* geometries) {
890 return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
891 }
892
894 static bool hasNullElements(const CoordinateSequence* list);
895
897 template<typename T>
898 static bool hasNullElements(const std::vector<T>* geometries) {
899 return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
900 }
901
902// static void reversePointOrder(CoordinateSequence* coordinates);
903// static Coordinate& minCoordinate(CoordinateSequence* coordinates);
904// static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
905// static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
906//
911 virtual bool isEquivalentClass(const Geometry* other) const;
912
913 static void checkNotGeometryCollection(const Geometry* g);
914
915 virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
916
917 int compare(std::vector<Coordinate> a, std::vector<Coordinate> b) const;
918
919 int compare(std::vector<Geometry*> a, std::vector<Geometry*> b) const;
920
921 int compare(const std::vector<std::unique_ptr<Geometry>> & a, const std::vector<std::unique_ptr<Geometry>> & b) const;
922
923 bool equal(const CoordinateXY& a, const CoordinateXY& b,
924 double tolerance) const;
925 int SRID;
926
927 Geometry(const Geometry& geom);
928
938 Geometry(const GeometryFactory* factory);
939
940 template<typename T>
941 static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
942 static_assert(std::is_base_of<Geometry, T>::value, "");
943 std::vector<std::unique_ptr<Geometry>> gv(v.size());
944 for (std::size_t i = 0; i < v.size(); i++) {
945 gv[i] = std::move(v[i]);
946 }
947 return gv;
948 }
949
950 static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<Geometry>> && v) {
951 return std::move(v);
952 }
953
954protected:
955
956 virtual int getSortIndex() const = 0;
957
958
959private:
960
961 class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
962 public:
963 void filter_rw(Geometry* geom) override;
964 };
965
966 static GeometryChangedFilter geometryChangedFilter;
967
972 const GeometryFactory* _factory;
973
974 void* _userData;
975};
976
981GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
982
983struct GEOS_DLL GeometryGreaterThen {
984 bool operator()(const Geometry* first, const Geometry* second);
985};
986
987
989GEOS_DLL std::string geosversion();
990
996GEOS_DLL std::string jtsport();
997
998// We use this instead of std::pair<unique_ptr<Geometry>> because C++11
999// forbids that construct:
1000// http://lwg.github.com/issues/lwg-closed.html#2068
1001struct GeomPtrPair {
1002 typedef std::unique_ptr<Geometry> GeomPtr;
1003 GeomPtr first;
1004 GeomPtr second;
1005};
1006
1007} // namespace geos::geom
1008} // namespace geos
1009
1010#ifdef _MSC_VER
1011#pragma warning(pop)
1012#endif
1013
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
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 std::unique_ptr< Geometry > getBoundary() const =0
Returns the boundary, or an empty geometry of appropriate dimension if this Geometry is empty.
virtual int getBoundaryDimension() const =0
Returns the dimension of this Geometrys inherent boundary.
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:792
virtual const CoordinateXY * getCoordinate() const =0
Returns a vertex of this Geometry, or NULL if this is the empty geometry.
virtual int compareTo(const Geometry *geom) const
Comparator for sorting 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< Geometry > reverse() const
Computes a new geometry which has all component coordinate sequences in reverse order (opposite orien...
Definition Geometry.h:673
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
const PrecisionModel * getPrecisionModel() const
Get the PrecisionModel used to create this Geometry.
std::unique_ptr< IntersectionMatrix > relate(const Geometry *g) const
Returns the DE-9IM intersection matrix for the two Geometrys.
virtual void geometryChangedAction()=0
Notifies this Geometry that its Coordinates have been changed by an external party.
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:351
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 std::unique_ptr< Geometry > convexHull() const
Returns the smallest convex Polygon that contains all the points in the Geometry.
virtual bool hasDimension(Dimension::DimensionType d) const
Checks whether any component of this geometry has dimension d.
Definition Geometry.h:346
virtual std::string getGeometryType() const =0
Return a string representation of this Geometry type.
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
std::unique_ptr< Point > getInteriorPoint() const
Computes an interior point of this Geometry.
std::unique_ptr< Geometry > intersection(const Geometry *other) const
Returns a Geometry representing the points shared by this Geometry and other.
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 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:316
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.
static bool hasNullElements(const CoordinateSequence *list)
Returns true if the CoordinateSequence contains any null elements.
virtual Geometry * reverseImpl() const =0
Make a geometry with coordinates in reverse order.
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.
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
const GeometryFactory * getFactory() const
Gets the factory which contains the context in which this geometry was created.
Definition Geometry.h:216
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*******,...
virtual std::unique_ptr< Geometry > getEnvelope() const
Returns this Geometrys bounding box.
virtual std::string toString() const
Returns the Well-known Text representation of this Geometry.
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 bool isValid() const
Tests the validity of this Geometry.
virtual Geometry * cloneImpl() const =0
Make a deep-copy 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:889
Ptr Union() const
Computes the union of all the elements of this geometry. Heterogeneous GeometryCollections are fully ...
void * getUserData() const
Gets the user data object for this geometry, if any.
Definition Geometry.h:247
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 bool disjoint(const Geometry *other) const
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.
std::unique_ptr< Geometry > buffer(double distance) const
virtual std::unique_ptr< Point > getCentroid() const
Computes the centroid of this Geometry.
bool coveredBy(const Geometry *g) const
Tests whether this geometry is covered by the specified geometry.
Definition Geometry.h:597
virtual std::unique_ptr< CoordinateSequence > getCoordinates() const =0
Returns this Geometry vertices. Caller takes ownership of the returned object.
std::unique_ptr< Geometry > Union(const Geometry *other) const
Returns a Geometry representing all the points in this Geometry and other.
virtual std::size_t getNumGeometries() const
Definition Geometry.h:308
std::unique_ptr< Geometry > clone() const
Make a deep-copy of this Geometry.
Definition Geometry.h:202
virtual double getArea() const
Returns the area of this Geometry.
virtual bool isRectangle() const
Polygon overrides to check for actual rectangle.
Definition Geometry.h:337
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 ...
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...
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 const Envelope * getEnvelopeInternal() const =0
Returns the minimum and maximum x and y values in this Geometry, or a null Envelope if this Geometry ...
static bool hasNullElements(const std::vector< T > *geometries)
Returns true if the vector contains any null elements.
Definition Geometry.h:898
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:90
@ GEOS_MULTILINESTRING
Definition geos_c.h:209
@ GEOS_GEOMETRYCOLLECTION
Definition geos_c.h:213
@ GEOS_POINT
Definition geos_c.h:199
@ GEOS_MULTIPOLYGON
Definition geos_c.h:211
@ GEOS_POLYGON
Definition geos_c.h:205
@ GEOS_MULTIPOINT
Definition geos_c.h:207
@ GEOS_LINESTRING
Definition geos_c.h:201
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 geos.h:39