GEOS 3.9.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
38namespace geos {
39namespace geom {
40class CoordinateSequenceFactory;
41class Coordinate;
42class CoordinateSequence;
43class Envelope;
44class Geometry;
45class GeometryCollection;
46class LineString;
47class LinearRing;
48class MultiLineString;
49class MultiPoint;
50class MultiPolygon;
51class Polygon;
52}
53}
54
55namespace geos {
56namespace geom { // geos::geom
57
68class GEOS_DLL GeometryFactory {
69private:
70
71 struct GeometryFactoryDeleter {
72 void
73 operator()(GeometryFactory* p) const
74 {
75 p->destroy();
76 }
77 };
78
79public:
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*
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
165
167 std::unique_ptr<Point> createPoint(std::size_t coordinateDimension = 2) const;
168
170 Point* createPoint(const Coordinate& coordinate) const;
171
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
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
197 const std::vector<const Geometry*>& newGeoms) const;
198
200 std::unique_ptr<MultiLineString> createMultiLineString() const;
201
204 std::vector<Geometry*>* newLines) const;
205
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
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
237
238 std::unique_ptr<LinearRing> createLinearRing(
239 std::unique_ptr<CoordinateSequence> && newCoords) const;
240
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
257 const std::vector<const Geometry*>& fromPoints) const;
258
263 const CoordinateSequence& fromCoords) const;
264
269 const std::vector<Coordinate>& fromCoords) const;
270
272 std::unique_ptr<Polygon> createPolygon(std::size_t coordinateDimension = 2) const;
273
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
285 const std::vector<LinearRing*>& holes) const;
286
288 std::unique_ptr<LineString> createLineString(std::size_t coordinateDimension = 2) const;
289
291 std::unique_ptr<LineString> createLineString(const LineString& ls) const;
292
295
296 std::unique_ptr<LineString> createLineString(
297 std::unique_ptr<CoordinateSequence> && coordinates) const;
298
301 const CoordinateSequence& coordinates) const;
302
310 std::unique_ptr<Geometry> createEmpty(int dimension) const;
311
342 Geometry* buildGeometry(std::vector<Geometry*>* geoms) const;
343
344 std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Geometry>> && geoms) const;
345
346 std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Point>> && geoms) const;
347
348 std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<LineString>> && geoms) const;
349
350 std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Polygon>> && geoms) const;
351
353 //
360 template <class T>
361 std::unique_ptr<Geometry>
362 buildGeometry(T from, T toofar) const
363 {
364 bool isHeterogeneous = false;
365 size_t count = 0;
366 int geomClass = -1;
367 for(T i = from; i != toofar; ++i) {
368 ++count;
369 const Geometry* g = *i;
370 if(geomClass < 0) {
371 geomClass = g->getSortIndex();
372 }
373 else if(geomClass != g->getSortIndex()) {
374 isHeterogeneous = true;
375 }
376 }
377
378 // for the empty geometry, return an empty GeometryCollection
379 if(count == 0) {
380 return std::unique_ptr<Geometry>(createGeometryCollection());
381 }
382
383 // for the single geometry, return a clone
384 if(count == 1) {
385 return (*from)->clone();
386 }
387
388 // Now we know it is a collection
389
390 // FIXME:
391 // Until we tweak all the createMulti* interfaces
392 // to support taking iterators we'll have to build
393 // a custom vector here.
394 std::vector<std::unique_ptr<Geometry>> fromGeoms;
395 for(T i = from; i != toofar; ++i) {
396 fromGeoms.push_back((*i)->clone());
397 }
398
399 // for an heterogeneous ...
400 if(isHeterogeneous) {
401 return createGeometryCollection(std::move(fromGeoms));
402 }
403
404 // At this point we know the collection is not hetereogenous.
405 switch((*from)->getDimension()) {
406 case Dimension::A: return createMultiPolygon(std::move(fromGeoms));
407 case Dimension::L: return createMultiLineString(std::move(fromGeoms));
408 case Dimension::P: return createMultiPoint(std::move(fromGeoms));
409 default:
410 throw geos::util::IllegalArgumentException(std::string("Invalid geometry type."));
411 }
412 }
413
421 Geometry* buildGeometry(const std::vector<const Geometry*>& geoms) const;
422
423 int getSRID() const;
424
429
432
434 void destroyGeometry(Geometry* g) const;
435
442 void destroy();
443
444protected:
445
452
465 GeometryFactory(const PrecisionModel* pm, int newSRID,
466 CoordinateSequenceFactory* nCoordinateSequenceFactory);
467
474 GeometryFactory(CoordinateSequenceFactory* nCoordinateSequenceFactory);
475
485
495 GeometryFactory(const PrecisionModel* pm, int newSRID);
496
503
506
507private:
508
509 PrecisionModel precisionModel;
510 int SRID;
511 const CoordinateSequenceFactory* coordinateListFactory;
512
513 mutable int _refCount;
514 bool _autoDestroy;
515
516 friend class Geometry;
517
518 void addRef() const;
519 void dropRef() const;
520
521};
522
523} // namespace geos::geom
524} // namespace geos
525
526#ifdef GEOS_INLINE
527# include "geos/geom/GeometryFactory.inl"
528#endif
529
530#endif // ndef GEOS_GEOM_GEOMETRYFACTORY_H
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
Coordinate is the lightweight class used to store coordinates.
Definition: Coordinate.h:60
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition: Envelope.h:58
Represents a collection of heterogeneous Geometry objects.
Definition: GeometryCollection.h:55
Supplies a set of utility methods for building Geometry objects from CoordinateSequence or other Geom...
Definition: GeometryFactory.h:68
static GeometryFactory::Ptr create(const PrecisionModel *pm)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and the defaul...
static const GeometryFactory * getDefaultInstance()
Return a pointer to the default GeometryFactory. This is a global shared object instantiated using de...
std::unique_ptr< Geometry > createEmptyGeometry() const
Construct the EMPTY Geometry.
static GeometryFactory::Ptr create()
Constructs a GeometryFactory that generates Geometries having a floating PrecisionModel and a spatial...
GeometryFactory(const PrecisionModel *pm)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and the defaul...
Geometry * buildGeometry(std::vector< Geometry * > *geoms) const
std::unique_ptr< MultiPoint > createMultiPoint() const
Constructs an EMPTY MultiPoint.
Polygon * createPolygon(LinearRing *shell, std::vector< LinearRing * > *holes) const
Construct a Polygon taking ownership of given arguments.
GeometryCollection * createGeometryCollection(const std::vector< const Geometry * > &newGeoms) const
Constructs a GeometryCollection with a deep-copy of args.
std::unique_ptr< Point > createPoint(std::size_t coordinateDimension=2) const
Creates an EMPTY Point.
MultiPoint * createMultiPoint(std::vector< Geometry * > *newPoints) const
Construct a MultiPoint taking ownership of given arguments.
LineString * createLineString(const CoordinateSequence &coordinates) const
Construct a LineString with a deep-copy of given argument.
std::unique_ptr< MultiPolygon > createMultiPolygon() const
Construct an EMPTY MultiPolygon.
LineString * createLineString(CoordinateSequence *coordinates) const
Construct a LineString taking ownership of given argument.
Point * createPoint(const CoordinateSequence &coordinates) const
Creates a Point with a deep-copy of the given CoordinateSequence.
const PrecisionModel * getPrecisionModel() const
Returns the PrecisionModel that Geometries created by this factory will be associated with.
LinearRing * createLinearRing(const CoordinateSequence &coordinates) const
Construct a LinearRing with a deep-copy of given arguments.
std::unique_ptr< GeometryCollection > createGeometryCollection() const
Construct an EMPTY GeometryCollection.
MultiPoint * createMultiPoint(const std::vector< Coordinate > &fromCoords) const
Construct a MultiPoint containing a Point geometry for each Coordinate in the given vector.
std::unique_ptr< LinearRing > createLinearRing() const
Construct an EMPTY LinearRing.
std::unique_ptr< LineString > createLineString(const LineString &ls) const
Copy a LineString.
std::unique_ptr< LineString > createLineString(std::size_t coordinateDimension=2) const
Construct an EMPTY LineString.
GeometryFactory(CoordinateSequenceFactory *nCoordinateSequenceFactory)
Constructs a GeometryFactory that generates Geometries having the given CoordinateSequence implementa...
MultiPolygon * createMultiPolygon(const std::vector< const Geometry * > &fromPolys) const
Construct a MultiPolygon with a deep-copy of given arguments.
Point * createPoint(const Coordinate &coordinate) const
Creates a Point using the given Coordinate.
void destroyGeometry(Geometry *g) const
Destroy a Geometry, or release it.
static GeometryFactory::Ptr create(CoordinateSequenceFactory *nCoordinateSequenceFactory)
Constructs a GeometryFactory that generates Geometries having the given CoordinateSequence implementa...
Geometry * buildGeometry(const std::vector< const Geometry * > &geoms) const
This function does the same thing of the omonimouse function taking vector pointer instead of referen...
MultiPolygon * createMultiPolygon(std::vector< Geometry * > *newPolys) const
Construct a MultiPolygon taking ownership of given arguments.
GeometryFactory(const PrecisionModel *pm, int newSRID, CoordinateSequenceFactory *nCoordinateSequenceFactory)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel,...
Point * createPoint(CoordinateSequence *coordinates) const
Creates a Point taking ownership of the given CoordinateSequence.
GeometryCollection * createGeometryCollection(std::vector< Geometry * > *newGeoms) const
Construct a GeometryCollection taking ownership of given arguments.
Polygon * createPolygon(const LinearRing &shell, const std::vector< LinearRing * > &holes) const
Construct a Polygon with a deep-copy of given arguments.
std::unique_ptr< Geometry > createEmpty(int dimension) const
MultiPoint * createMultiPoint(const CoordinateSequence &fromCoords) const
Construct a MultiPoint containing a Point geometry for each Coordinate in the given list.
std::unique_ptr< MultiLineString > createMultiLineString() const
Construct an EMPTY MultiLineString.
GeometryFactory(const PrecisionModel *pm, int newSRID)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and spatial-re...
virtual ~GeometryFactory()
Destructor.
static GeometryFactory::Ptr create(const GeometryFactory &gf)
Copy constructor.
Geometry * createGeometry(const Geometry *g) const
Returns a clone of given Geometry.
MultiLineString * createMultiLineString(std::vector< Geometry * > *newLines) const
Construct a MultiLineString taking ownership of given arguments.
std::unique_ptr< Polygon > createPolygon(std::size_t coordinateDimension=2) const
Construct an EMPTY Polygon.
const CoordinateSequenceFactory * getCoordinateSequenceFactory() const
Returns the CoordinateSequenceFactory associated with this GeometryFactory.
GeometryFactory(const GeometryFactory &gf)
Copy constructor.
GeometryFactory()
Constructs a GeometryFactory that generates Geometries having a floating PrecisionModel and a spatial...
MultiLineString * createMultiLineString(const std::vector< const Geometry * > &fromLines) const
Construct a MultiLineString with a deep-copy of given arguments.
static GeometryFactory::Ptr create(const PrecisionModel *pm, int newSRID)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and spatial-re...
static GeometryFactory::Ptr create(const PrecisionModel *pm, int newSRID, CoordinateSequenceFactory *nCoordinateSequenceFactory)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel,...
LinearRing * createLinearRing(CoordinateSequence *newCoords) const
Construct a LinearRing taking ownership of given arguments.
MultiPoint * createMultiPoint(const std::vector< const Geometry * > &fromPoints) const
Construct a MultiPoint with a deep-copy of given arguments.
std::unique_ptr< Geometry > toGeometry(const Envelope *envelope) const
std::unique_ptr< Geometry > buildGeometry(T from, T toofar) const
See buildGeometry(std::vector<Geometry *>&) for semantics.
Definition: GeometryFactory.h:362
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition: Geometry.h:188
Definition: LineString.h:68
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition: LinearRing.h:54
Models a collection of LineStrings.
Definition: MultiLineString.h:51
Definition: MultiPoint.h:54
Definition: MultiPolygon.h:59
Definition: Point.h:66
Represents a linear polygon, which may include holes.
Definition: Polygon.h:64
Specifies the precision model of the Coordinate in a Geometry.
Definition: PrecisionModel.h:87
Indicates one or more illegal arguments.
Definition: IllegalArgumentException.h:34
Basic namespace for all GEOS functionalities.
Definition: IndexedNestedRingTester.h:26