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
54namespace geos {
55namespace geom {
56class Coordinate;
57class CoordinateFilter;
58class CoordinateSequence;
59class CoordinateSequenceFilter;
60class GeometryComponentFilter;
61class GeometryFactory;
62class GeometryFilter;
63class PrecisionModel;
64class Point;
65}
66namespace io { // geos.io
67class Unload;
68} // namespace geos.io
69}
70
71namespace geos {
72namespace geom { // geos::geom
73
92};
93
94enum 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
188class GEOS_DLL Geometry {
189
190public:
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*
219 {
220 return _factory;
221 }
222
236 void
237 setUserData(void* newUserData)
238 {
239 _userData = newUserData;
240 }
241
248 void*
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
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 ||
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
854protected:
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
929protected:
930
931 virtual int getSortIndex() const = 0;
932
933
934private:
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
956GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
957
958struct GEOS_DLL GeometryGreaterThen {
959 bool operator()(const Geometry* first, const Geometry* second);
960};
961
962
964GEOS_DLL std::string geosversion();
965
971GEOS_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
976struct 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
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 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.
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.
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...
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
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 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
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< 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 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 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, 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.
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.
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 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
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.
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.
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
const GeometryFactory * getFactory() const
Gets the factory which contains the context in which this geometry was created.
Definition Geometry.h:218
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*******,...
virtual std::unique_ptr< Geometry > getEnvelope() const
Returns this Geometrys bounding box.
virtual const Coordinate * getCoordinate() const =0
Returns a vertex of this Geometry, or NULL if this is the empty geometry.
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 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 ...
void * getUserData() const
Gets the user data object for this geometry, if any.
Definition Geometry.h:249
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< Geometry > clone() const =0
Make a deep-copy of this Geometry.
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:581
virtual std::unique_ptr< CoordinateSequence > getCoordinates() const =0
Returns this Geometry vertices. Caller takes ownership of the returned object.
virtual const Envelope * getEnvelopeInternal() const
Returns the minimum and maximum x and y values in this Geometry, or a null Envelope if this Geometry ...
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:310
virtual double getArea() const
Returns the area 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 ...
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...
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
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.
std::ostream & operator<<(std::ostream &os, const Coordinate &c)
Output function.
Basic namespace for all GEOS functionalities.
Definition IndexedNestedRingTester.h:26