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
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 
281  const PrecisionModel* getPrecisionModel() const;
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
337  isRectangle() const
338  {
339  return false;
340  }
341 
343  virtual Dimension::DimensionType getDimension() const = 0; //Abstract
344 
346  virtual bool hasDimension(Dimension::DimensionType d) const {
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 ||
374  t == GEOS_MULTILINESTRING ||
375  t == GEOS_MULTIPOLYGON;
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 
880 protected:
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 
954 protected:
955 
956  virtual int getSortIndex() const = 0;
957 
958 
959 private:
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 
981 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
982 
983 struct GEOS_DLL GeometryGreaterThen {
984  bool operator()(const Geometry* first, const Geometry* second);
985 };
986 
987 
989 GEOS_DLL std::string geosversion();
990 
996 GEOS_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
1001 struct 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 Geometry filter to the Geometry.
Definition: GeometryFilter.h:45
void * getUserData() const
Gets the user data object for this geometry, if any.
Definition: Geometry.h:247
a linestring
Definition: Geometry.h:77
a collection of heterogeneus geometries
Definition: Geometry.h:89
a collection of linestrings
Definition: Geometry.h:85
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
std::unique_ptr< Geometry > clone() const
Make a deep-copy of this Geometry.
Definition: Geometry.h:202
Interface for classes which provide operations that can be applied to the coordinates in a Coordinate...
Definition: CoordinateSequenceFilter.h:55
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:90
const GeometryFactory * getFactory() const
Gets the factory which contains the context in which this geometry was created.
Definition: Geometry.h:216
std::string geosversion()
Return current GEOS version.
GeometryTypeId
Geometry types.
Definition: Geometry.h:73
virtual bool isDimensionStrict(Dimension::DimensionType d) const
Checks whether this Geometry consists only of components having dimension d.
Definition: Geometry.h:351
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:186
Geometry classes support the concept of applying a coordinate filter to every coordinate in the Geome...
Definition: CoordinateFilter.h:43
a collection of points
Definition: Geometry.h:83
std::string jtsport()
Return the version of JTS this GEOS release has been ported from.
virtual int getSRID() const
Returns the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:263
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
Dimension value of a curve (1).
Definition: Dimension.h:43
Dimension value of a surface (2).
Definition: Dimension.h:46
virtual bool isRectangle() const
Polygon overrides to check for actual rectangle.
Definition: Geometry.h:337
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
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:65
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
std::vector< Geometry * > NonConstVect
A vector of non-const Geometry pointers.
Definition: Geometry.h:196
Basic namespace for all GEOS functionalities.
Definition: Angle.h:25
bool coveredBy(const Geometry *g) const
Tests whether this geometry is covered by the specified geometry.
Definition: Geometry.h:597
virtual void setSRID(int newSRID)
Sets the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:272
a polygon
Definition: Geometry.h:81
a linear ring (linestring with 1st point == last point)
Definition: Geometry.h:79
virtual bool hasDimension(Dimension::DimensionType d) const
Checks whether any component of this geometry has dimension d.
Definition: Geometry.h:346
static bool hasNullElements(const std::vector< T > *geometries)
Returns true if the vector contains any null elements.
Definition: Geometry.h:898
a point
Definition: Geometry.h:75
Dimension value of a point (0).
Definition: Dimension.h:40
virtual std::size_t getNumGeometries() const
Definition: Geometry.h:308
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:56
static bool hasNonEmptyElements(const std::vector< T > *geometries)
Returns true if the array contains any non-empty Geometrys.
Definition: Geometry.h:889
bool covers(const Geometry *g) const
Returns true if this geometry covers the specified geometry.
std::unique_ptr< Geometry > Ptr
An unique_ptr of Geometry.
Definition: Geometry.h:199
a collection of polygons
Definition: Geometry.h:87
std::vector< const Geometry * > ConstVect
A vector of const Geometry pointers.
Definition: Geometry.h:193
DimensionType
Definition: Dimension.h:29
Definition: GeometryComponentFilter.h:41