GEOS  3.8.0dev
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 std::string geosversion();
952 
958 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
virtual int getSRID() const
Returns the ID of the Spatial Reference System used by the Geometry.
Definition: Geometry.h:265
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
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
GEOS_DLL 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
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
virtual std::size_t getNumGeometries() const
Definition: Geometry.h:310
std::string geosversion()
Return current GEOS version.
GeometryTypeId
Geometry types.
Definition: Geometry.h:75
bool covers(const Geometry *g) const
Returns true if this geometry covers the specified geometry.
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.
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
void * getUserData() const
Gets the user data object for this geometry, if any.
Definition: Geometry.h:249
const GeometryFactory * getFactory() const
Gets the factory which contains the context in which this geometry was created.
Definition: Geometry.h:218
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:66
std::vector< Geometry * > NonConstVect
A vector of non-const Geometry pointers.
Definition: Geometry.h:198
virtual bool isDimensionStrict(Dimension::DimensionType d) const
Checks whether this Geometry consists only of components having dimension d.
Definition: Geometry.h:348
Basic namespace for all GEOS functionalities.
Definition: IndexedNestedRingTester.h:25
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
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
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
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
DimensionType
Definition: Dimension.h:31
bool coveredBy(const Geometry *g) const
Tests whether this geometry is covered by the specified geometry.
Definition: Geometry.h:573
Definition: GeometryComponentFilter.h:43