GEOS  3.8.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 #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
54 namespace geos {
55 namespace geom {
56 class Coordinate;
57 class CoordinateFilter;
58 class CoordinateSequence;
59 class CoordinateSequenceFilter;
60 class GeometryComponentFilter;
61 class GeometryFactory;
62 class GeometryFilter;
63 class PrecisionModel;
64 class Point;
65 }
66 namespace io { // geos.io
67 class Unload;
68 } // namespace geos.io
69 }
70 
71 namespace geos {
72 namespace geom { // geos::geom
73 
92 };
93 
94 enum 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 
188 class GEOS_DLL Geometry {
189 
190 public:
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*
218  getFactory() const
219  {
220  return _factory;
221  }
222 
236  void
237  setUserData(void* newUserData)
238  {
239  _userData = newUserData;
240  }
241 
248  void*
249  getUserData() const
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 
283  const PrecisionModel* getPrecisionModel() const;
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
339  isRectangle() const
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 
365  virtual int getCoordinateDimension() const = 0; //Abstract
366 
383  virtual std::unique_ptr<Geometry> getBoundary() const = 0; //Abstract
384 
386  virtual int getBoundaryDimension() const = 0; //Abstract
387 
389  virtual std::unique_ptr<Geometry> getEnvelope() const;
390 
395  virtual const Envelope* getEnvelopeInternal() const;
396 
413  virtual bool disjoint(const Geometry* other) const;
414 
419  virtual bool touches(const Geometry* other) const;
420 
422  virtual bool intersects(const Geometry* g) const;
423 
446  virtual bool crosses(const Geometry* g) const;
447 
452  virtual bool within(const Geometry* g) const;
453 
455  virtual bool contains(const Geometry* g) const;
456 
462  virtual bool overlaps(const Geometry* g) const;
463 
478  bool relate(const Geometry* g,
479  const std::string& intersectionPattern) const;
480 
481  bool
482  relate(const Geometry& g, const std::string& intersectionPattern) const
483  {
484  return relate(&g, intersectionPattern);
485  }
486 
488  std::unique_ptr<IntersectionMatrix> relate(const Geometry* g) const;
489 
490  std::unique_ptr<IntersectionMatrix> relate(const Geometry& g) const
491  {
492  return relate(&g);
493  }
494 
500  virtual bool equals(const Geometry* g) const;
501 
540  bool covers(const Geometry* g) const;
541 
572  bool
573  coveredBy(const Geometry* g) const
574  {
575  return g->covers(this);
576  }
577 
578 
580  virtual std::string toString() const;
581 
582  virtual std::string toText() const;
583 
588  std::unique_ptr<Geometry> buffer(double distance) const;
589 
597  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments) const;
598 
635  std::unique_ptr<Geometry> buffer(double distance, int quadrantSegments,
636  int endCapStyle) const;
637 
641  virtual std::unique_ptr<Geometry> convexHull() const;
642 
649  virtual std::unique_ptr<Geometry> reverse() const = 0;
650 
660  std::unique_ptr<Geometry> intersection(const Geometry* other) const;
661 
671  std::unique_ptr<Geometry> Union(const Geometry* other) const;
672  // throw(IllegalArgumentException *, TopologyException *);
673 
691  Ptr Union() const;
692  // throw(IllegalArgumentException *, TopologyException *);
693 
704  std::unique_ptr<Geometry> difference(const Geometry* other) const;
705 
715  std::unique_ptr<Geometry> symDifference(const Geometry* other) const;
716 
721  virtual bool equalsExact(const Geometry* other, double tolerance = 0)
722  const = 0; //Abstract
723 
724  virtual void apply_rw(const CoordinateFilter* filter) = 0; //Abstract
725  virtual void apply_ro(CoordinateFilter* filter) const = 0; //Abstract
726  virtual void apply_rw(GeometryFilter* filter);
727  virtual void apply_ro(GeometryFilter* filter) const;
728  virtual void apply_rw(GeometryComponentFilter* filter);
729  virtual void apply_ro(GeometryComponentFilter* filter) const;
730 
739  virtual void apply_rw(CoordinateSequenceFilter& filter) = 0;
740 
747  virtual void apply_ro(CoordinateSequenceFilter& filter) const = 0;
748 
758  template <class T>
759  void
761  {
762  for(std::size_t i = 0, n = getNumGeometries(); i < n; ++i) {
763  f.filter(getGeometryN(i));
764  }
765  }
766 
768  virtual void normalize() = 0; //Abstract
769 
770  virtual int compareTo(const Geometry* geom) const;
771 
776  virtual double distance(const Geometry* g) const;
777 
779  virtual double getArea() const;
780 
782  virtual double getLength() const;
783 
795  virtual bool isWithinDistance(const Geometry* geom,
796  double cDistance) const;
797 
807  virtual std::unique_ptr<Point> getCentroid() const;
808 
810  //
813  virtual bool getCentroid(Coordinate& ret) const;
814 
825  std::unique_ptr<Point> getInteriorPoint() const;
826 
832  virtual void geometryChanged();
833 
839  void geometryChangedAction();
840 
841 protected:
842 
844  mutable std::unique_ptr<Envelope> envelope;
845 
847  template<typename T>
848  static bool hasNonEmptyElements(const std::vector<T>* geometries) {
849  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return !g->isEmpty(); });
850  }
851 
853  static bool hasNullElements(const CoordinateSequence* list);
854 
856  template<typename T>
857  static bool hasNullElements(const std::vector<T>* geometries) {
858  return std::any_of(geometries->begin(), geometries->end(), [](const T& g) { return g == nullptr; });
859  }
860 
861 // static void reversePointOrder(CoordinateSequence* coordinates);
862 // static Coordinate& minCoordinate(CoordinateSequence* coordinates);
863 // static void scroll(CoordinateSequence* coordinates,Coordinate* firstCoordinate);
864 // static int indexOf(Coordinate* coordinate,CoordinateSequence* coordinates);
865 //
870  virtual bool isEquivalentClass(const Geometry* other) const;
871 
872  static void checkNotGeometryCollection(const Geometry* g);
873  // throw(IllegalArgumentException *);
874 
875  //virtual void checkEqualSRID(Geometry *other);
876 
877  //virtual void checkEqualPrecisionModel(Geometry *other);
878 
879  virtual Envelope::Ptr computeEnvelopeInternal() const = 0; //Abstract
880 
881  virtual int compareToSameClass(const Geometry* geom) const = 0; //Abstract
882 
883  int compare(std::vector<Coordinate> a, std::vector<Coordinate> b) const;
884 
885  int compare(std::vector<Geometry*> a, std::vector<Geometry*> b) const;
886 
887  int compare(const std::vector<std::unique_ptr<Geometry>> & a, const std::vector<std::unique_ptr<Geometry>> & b) const;
888 
889  bool equal(const Coordinate& a, const Coordinate& b,
890  double tolerance) const;
891  int SRID;
892 
893  Geometry(const Geometry& geom);
894 
904  Geometry(const GeometryFactory* factory);
905 
906  template<typename T>
907  static std::vector<std::unique_ptr<Geometry>> toGeometryArray(std::vector<std::unique_ptr<T>> && v) {
908  static_assert(std::is_base_of<Geometry, T>::value, "");
909  std::vector<std::unique_ptr<Geometry>> gv(v.size());
910  for (size_t i = 0; i < v.size(); i++) {
911  gv[i] = std::move(v[i]);
912  }
913  return gv;
914  }
915 
916 protected:
917 
918  virtual int getSortIndex() const = 0;
919 
920 
921 private:
922 
923  class GEOS_DLL GeometryChangedFilter : public GeometryComponentFilter {
924  public:
925  void filter_rw(Geometry* geom) override;
926  };
927 
928  static GeometryChangedFilter geometryChangedFilter;
929 
934  const GeometryFactory* _factory;
935 
936  void* _userData;
937 };
938 
943 GEOS_DLL std::ostream& operator<< (std::ostream& os, const Geometry& geom);
944 
945 struct GEOS_DLL GeometryGreaterThen {
946  bool operator()(const Geometry* first, const Geometry* second);
947 };
948 
949 
951 GEOS_DLL std::string geosversion();
952 
958 GEOS_DLL std::string jtsport();
959 
960 // We use this instead of std::pair<unique_ptr<Geometry>> because C++11
961 // forbids that construct:
962 // http://lwg.github.com/issues/lwg-closed.html#2068
963 struct GeomPtrPair {
964  typedef std::unique_ptr<Geometry> GeomPtr;
965  GeomPtr first;
966  GeomPtr second;
967 };
968 
969 } // namespace geos::geom
970 } // namespace geos
971 
972 #ifdef _MSC_VER
973 #pragma warning(pop)
974 #endif
975 
976 #endif // ndef GEOS_GEOM_GEOMETRY_H
Geometry classes support the concept of applying a Geometry filter to the Geometry.
Definition: GeometryFilter.h:47
void * getUserData() const
Gets the user data object for this geometry, if any.
Definition: Geometry.h:249
a linestring
Definition: Geometry.h:79
a collection of heterogeneus geometries
Definition: Geometry.h:91
a collection of linestrings
Definition: Geometry.h:87
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:60
void applyComponentFilter(T &f) const
Apply a filter to each component of this geometry. The filter is expected to provide a ....
Definition: Geometry.h:760
Interface for classes which provide operations that can be applied to the coordinates in a Coordinate...
Definition: CoordinateSequenceFilter.h:57
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:87
const GeometryFactory * getFactory() const
Gets the factory which contains the context in which this geometry was created.
Definition: Geometry.h:218
std::string geosversion()
Return current GEOS version.
GeometryTypeId
Geometry types.
Definition: Geometry.h:75
virtual bool isDimensionStrict(Dimension::DimensionType d) const
Checks whether this Geometry consists only of components having dimension d.
Definition: Geometry.h:348
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:188
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:85
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:265
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
Dimension value of a curve (1).
Definition: Dimension.h:45
Dimension value of a surface (2).
Definition: Dimension.h:48
std::ostream & operator<<(std::ostream &os, const Coordinate &c)
Output function.
virtual bool isRectangle() const
Polygon overrides to check for actual rectangle.
Definition: Geometry.h:339
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:68
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
std::vector< Geometry * > NonConstVect
A vector of non-const Geometry pointers.
Definition: Geometry.h:198
Basic namespace for all GEOS functionalities.
Definition: IndexedNestedRingTester.h:25
bool coveredBy(const Geometry *g) const
Tests whether this geometry is covered by the specified geometry.
Definition: Geometry.h:573
virtual void setSRID(int newSRID)
Sets the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:274
a polygon
Definition: Geometry.h:83
a linear ring (linestring with 1st point == last point)
Definition: Geometry.h:81
static bool hasNullElements(const std::vector< T > *geometries)
Returns true if the vector contains any null elements.
Definition: Geometry.h:857
a point
Definition: Geometry.h:77
Dimension value of a point (0).
Definition: Dimension.h:42
virtual std::size_t getNumGeometries() const
Definition: Geometry.h:310
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:58
static bool hasNonEmptyElements(const std::vector< T > *geometries)
Returns true if the array contains any non-empty Geometrys.
Definition: Geometry.h:848
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:201
a collection of polygons
Definition: Geometry.h:89
std::unique_ptr< Envelope > envelope
The bounding box of this Geometry.
Definition: Geometry.h:844
std::vector< const Geometry * > ConstVect
A vector of const Geometry pointers.
Definition: Geometry.h:195
DimensionType
Definition: Dimension.h:31
Definition: GeometryComponentFilter.h:43