GEOS  3.10.1
GeometryFactory.h
1 /**********************************************************************
2  *
3  * GEOS - Geometry Engine Open Source
4  * http://geos.osgeo.org
5  *
6  * Copyright (C) 2011 Sandro Santilli <strk@kbt.io>
7  * Copyright (C) 2006 Refractions Research Inc.
8  *
9  * This is free software; you can redistribute and/or modify it under
10  * the terms of the GNU Lesser General Public Licence as published
11  * by the Free Software Foundation.
12  * See the COPYING file for more information.
13  *
14  **********************************************************************
15  *
16  * Last port: geom/GeometryFactory.java r320 (JTS-1.12)
17  *
18  **********************************************************************/
19 
20 #ifndef GEOS_GEOM_GEOMETRYFACTORY_H
21 #define GEOS_GEOM_GEOMETRYFACTORY_H
22 
23 #include <geos/geom/Geometry.h>
24 #include <geos/geom/GeometryCollection.h>
25 #include <geos/geom/MultiPoint.h>
26 #include <geos/geom/MultiLineString.h>
27 #include <geos/geom/MultiPolygon.h>
28 #include <geos/geom/PrecisionModel.h>
29 #include <geos/export.h>
30 #include <geos/inline.h>
31 #include <geos/util.h>
32 
33 #include <vector>
34 #include <memory>
35 #include <cassert>
36 #include <geos/util/IllegalArgumentException.h>
37 
38 namespace geos {
39 namespace geom {
40 class CoordinateSequenceFactory;
41 class Coordinate;
42 class CoordinateSequence;
43 class Envelope;
44 class Geometry;
45 class GeometryCollection;
46 class LineString;
47 class LinearRing;
48 class MultiLineString;
49 class MultiPoint;
50 class MultiPolygon;
51 class Polygon;
52 }
53 }
54 
55 namespace geos {
56 namespace geom { // geos::geom
57 
68 class GEOS_DLL GeometryFactory {
69 private:
70 
71  struct GeometryFactoryDeleter {
72  void
73  operator()(GeometryFactory* p) const
74  {
75  p->destroy();
76  }
77  };
78 
79 public:
80 
81  using Ptr = std::unique_ptr<GeometryFactory, GeometryFactoryDeleter>;
82 
88  static GeometryFactory::Ptr create();
89 
102  static GeometryFactory::Ptr create(const PrecisionModel* pm, int newSRID,
103  CoordinateSequenceFactory* nCoordinateSequenceFactory);
104 
111  static GeometryFactory::Ptr create(CoordinateSequenceFactory* nCoordinateSequenceFactory);
112 
121  static GeometryFactory::Ptr create(const PrecisionModel* pm);
122 
132  static GeometryFactory::Ptr create(const PrecisionModel* pm, int newSRID);
133 
139  static GeometryFactory::Ptr create(const GeometryFactory& gf);
140 
147  static const GeometryFactory*
148  getDefaultInstance();
149 
150 //Skipped a lot of list to array convertors
151 
152  Point* createPointFromInternalCoord(const Coordinate* coord,
153  const Geometry* exemplar) const;
154 
159  std::unique_ptr<Geometry> toGeometry(const Envelope* envelope) const;
160 
164  const PrecisionModel* getPrecisionModel() const;
165 
167  std::unique_ptr<Point> createPoint(std::size_t coordinateDimension = 2) const;
168 
170  Point* createPoint(const Coordinate& coordinate) const;
171 
173  Point* createPoint(CoordinateSequence* coordinates) const;
174 
176  Point* createPoint(const CoordinateSequence& coordinates) const;
177 
179  std::unique_ptr<GeometryCollection> createGeometryCollection() const;
180 
182  std::unique_ptr<Geometry> createEmptyGeometry() const;
183 
185  GeometryCollection* createGeometryCollection(
186  std::vector<Geometry*>* newGeoms) const;
187 
188  template<typename T>
189  std::unique_ptr<GeometryCollection> createGeometryCollection(
190  std::vector<std::unique_ptr<T>> && newGeoms) const {
191  // Can't use make_unique because constructor is protected
192  return std::unique_ptr<GeometryCollection>(new GeometryCollection(Geometry::toGeometryArray(std::move(newGeoms)), *this));
193  }
194 
196  GeometryCollection* createGeometryCollection(
197  const std::vector<const Geometry*>& newGeoms) const;
198 
200  std::unique_ptr<MultiLineString> createMultiLineString() const;
201 
203  MultiLineString* createMultiLineString(
204  std::vector<Geometry*>* newLines) const;
205 
207  MultiLineString* createMultiLineString(
208  const std::vector<const Geometry*>& fromLines) const;
209 
210  std::unique_ptr<MultiLineString> createMultiLineString(
211  std::vector<std::unique_ptr<LineString>> && fromLines) const;
212 
213  std::unique_ptr<MultiLineString> createMultiLineString(
214  std::vector<std::unique_ptr<Geometry>> && fromLines) const;
215 
217  std::unique_ptr<MultiPolygon> createMultiPolygon() const;
218 
220  MultiPolygon* createMultiPolygon(std::vector<Geometry*>* newPolys) const;
221 
223  MultiPolygon* createMultiPolygon(
224  const std::vector<const Geometry*>& fromPolys) const;
225 
226  std::unique_ptr<MultiPolygon> createMultiPolygon(
227  std::vector<std::unique_ptr<Polygon>> && fromPolys) const;
228 
229  std::unique_ptr<MultiPolygon> createMultiPolygon(
230  std::vector<std::unique_ptr<Geometry>> && fromPolys) const;
231 
233  std::unique_ptr<LinearRing> createLinearRing() const;
234 
236  LinearRing* createLinearRing(CoordinateSequence* newCoords) const;
237 
238  std::unique_ptr<LinearRing> createLinearRing(
239  std::unique_ptr<CoordinateSequence> && newCoords) const;
240 
242  LinearRing* createLinearRing(
243  const CoordinateSequence& coordinates) const;
244 
246  std::unique_ptr<MultiPoint> createMultiPoint() const;
247 
249  MultiPoint* createMultiPoint(std::vector<Geometry*>* newPoints) const;
250 
251  std::unique_ptr<MultiPoint> createMultiPoint(std::vector<std::unique_ptr<Point>> && newPoints) const;
252 
253  std::unique_ptr<MultiPoint> createMultiPoint(std::vector<std::unique_ptr<Geometry>> && newPoints) const;
254 
256  MultiPoint* createMultiPoint(
257  const std::vector<const Geometry*>& fromPoints) const;
258 
262  MultiPoint* createMultiPoint(
263  const CoordinateSequence& fromCoords) const;
264 
268  MultiPoint* createMultiPoint(
269  const std::vector<Coordinate>& fromCoords) const;
270 
272  std::unique_ptr<Polygon> createPolygon(std::size_t coordinateDimension = 2) const;
273 
275  Polygon* createPolygon(LinearRing* shell,
276  std::vector<LinearRing*>* holes) const;
277 
278  std::unique_ptr<Polygon> createPolygon(std::unique_ptr<LinearRing> && shell) const;
279 
280  std::unique_ptr<Polygon> createPolygon(std::unique_ptr<LinearRing> && shell,
281  std::vector<std::unique_ptr<LinearRing>> && holes) const;
282 
284  std::unique_ptr<Polygon> createPolygon(std::vector<Coordinate> && coords) const;
285 
287  Polygon* createPolygon(const LinearRing& shell,
288  const std::vector<LinearRing*>& holes) const;
289 
291  std::unique_ptr<LineString> createLineString(std::size_t coordinateDimension = 2) const;
292 
294  std::unique_ptr<LineString> createLineString(const LineString& ls) const;
295 
297  LineString* createLineString(CoordinateSequence* coordinates) const;
298 
299  std::unique_ptr<LineString> createLineString(
300  std::unique_ptr<CoordinateSequence> && coordinates) const;
301 
303  LineString* createLineString(
304  const CoordinateSequence& coordinates) const;
305 
313  std::unique_ptr<Geometry> createEmpty(int dimension) const;
314 
345  Geometry* buildGeometry(std::vector<Geometry*>* geoms) const;
346 
347  std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Geometry>> && geoms) const;
348 
349  std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Point>> && geoms) const;
350 
351  std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<LineString>> && geoms) const;
352 
353  std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Polygon>> && geoms) const;
354 
356  //
363  template <class T>
364  std::unique_ptr<Geometry>
365  buildGeometry(T from, T toofar) const
366  {
367  bool isHeterogeneous = false;
368  std::size_t count = 0;
369  int geomClass = -1;
370  for(T i = from; i != toofar; ++i) {
371  ++count;
372  const Geometry* g = *i;
373  if(geomClass < 0) {
374  geomClass = g->getSortIndex();
375  }
376  else if(geomClass != g->getSortIndex()) {
377  isHeterogeneous = true;
378  }
379  }
380 
381  // for the empty geometry, return an empty GeometryCollection
382  if(count == 0) {
383  return std::unique_ptr<Geometry>(createGeometryCollection());
384  }
385 
386  // for the single geometry, return a clone
387  if(count == 1) {
388  return (*from)->clone();
389  }
390 
391  // Now we know it is a collection
392 
393  // FIXME:
394  // Until we tweak all the createMulti* interfaces
395  // to support taking iterators we'll have to build
396  // a custom vector here.
397  std::vector<std::unique_ptr<Geometry>> fromGeoms;
398  for(T i = from; i != toofar; ++i) {
399  fromGeoms.push_back((*i)->clone());
400  }
401 
402  // for an heterogeneous ...
403  if(isHeterogeneous) {
404  return createGeometryCollection(std::move(fromGeoms));
405  }
406 
407  // At this point we know the collection is not hetereogenous.
408  switch((*from)->getDimension()) {
409  case Dimension::A: return createMultiPolygon(std::move(fromGeoms));
410  case Dimension::L: return createMultiLineString(std::move(fromGeoms));
411  case Dimension::P: return createMultiPoint(std::move(fromGeoms));
412  default:
413  throw geos::util::IllegalArgumentException(std::string("Invalid geometry type."));
414  }
415  }
416 
424  Geometry* buildGeometry(const std::vector<const Geometry*>& geoms) const;
425 
426  int getSRID() const;
427 
431  const CoordinateSequenceFactory* getCoordinateSequenceFactory() const;
432 
434  Geometry* createGeometry(const Geometry* g) const;
435 
437  void destroyGeometry(Geometry* g) const;
438 
445  void destroy();
446 
447 protected:
448 
454  GeometryFactory();
455 
468  GeometryFactory(const PrecisionModel* pm, int newSRID,
469  CoordinateSequenceFactory* nCoordinateSequenceFactory);
470 
477  GeometryFactory(CoordinateSequenceFactory* nCoordinateSequenceFactory);
478 
487  GeometryFactory(const PrecisionModel* pm);
488 
498  GeometryFactory(const PrecisionModel* pm, int newSRID);
499 
505  GeometryFactory(const GeometryFactory& gf);
506 
508  virtual ~GeometryFactory();
509 
510 private:
511 
512  PrecisionModel precisionModel;
513  int SRID;
514  const CoordinateSequenceFactory* coordinateListFactory;
515 
516  mutable int _refCount;
517  bool _autoDestroy;
518 
519  friend class Geometry;
520 
521  void addRef() const;
522  void dropRef() const;
523 
524 };
525 
526 } // namespace geos::geom
527 } // namespace geos
528 
529 #ifdef GEOS_INLINE
530 # include "geos/geom/GeometryFactory.inl"
531 #endif
532 
533 #endif // ndef GEOS_GEOM_GEOMETRYFACTORY_H
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:58
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:60
Definition: MultiPolygon.h:59
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:87
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:188
Indicates one or more illegal arguments.
Definition: IllegalArgumentException.h:34
Definition: LineString.h:68
Represents a linear polygon, which may include holes.
Definition: Polygon.h:64
Dimension value of a curve (1).
Definition: Dimension.h:45
Dimension value of a surface (2).
Definition: Dimension.h:48
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:68
Represents a collection of heterogeneous Geometry objects.
Definition: GeometryCollection.h:55
Basic namespace for all GEOS functionalities.
Definition: Angle.h:26
Definition: MultiPoint.h:54
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple...
Definition: LinearRing.h:57
Dimension value of a point (0).
Definition: Dimension.h:42
A factory to create concrete instances of CoordinateSequences.
Definition: CoordinateSequenceFactory.h:48
The internal representation of a list of coordinates inside a Geometry.
Definition: CoordinateSequence.h:58
Definition: Point.h:66
Models a collection of LineStrings.
Definition: MultiLineString.h:51
std::unique_ptr< Geometry > buildGeometry(T from, T toofar) const
See buildGeometry(std::vector<Geometry *>&) for semantics.
Definition: GeometryFactory.h:365