/********************************************************************** * * GEOS - Geometry Engine Open Source * http://geos.osgeo.org * * Copyright (C) 2011 Sandro Santilli <strk@kbt.io> * Copyright (C) 2006 Refractions Research Inc. * * This is free software; you can redistribute and/or modify it under * the terms of the GNU Lesser General Public Licence as published * by the Free Software Foundation. * See the COPYING file for more information. * ********************************************************************** * * Last port: geom/GeometryFactory.java r320 (JTS-1.12) * **********************************************************************/ #ifndef GEOS_GEOM_GEOMETRYFACTORY_H #define GEOS_GEOM_GEOMETRYFACTORY_H #include <geos/geom/Geometry.h> #include <geos/geom/GeometryCollection.h> #include <geos/geom/MultiPoint.h> #include <geos/geom/MultiLineString.h> #include <geos/geom/MultiPolygon.h> #include <geos/geom/PrecisionModel.h> #include <geos/export.h> #include <geos/inline.h> #include <geos/util.h> #include <vector> #include <memory> #include <cassert> #include <geos/util/IllegalArgumentException.h> namespace geos { namespace geom { class CoordinateSequenceFactory; class Coordinate; class CoordinateSequence; class Envelope; class Geometry; class GeometryCollection; class LineString; class LinearRing; class MultiLineString; class MultiPoint; class MultiPolygon; class Polygon; } } namespace geos { namespace geom { // geos::geom /** * \brief * Supplies a set of utility methods for building Geometry objects * from CoordinateSequence or other Geometry objects. * * Note that the factory constructor methods do <b>not</b> change the input * coordinates in any way. * In particular, they are not rounded to the supplied <tt>PrecisionModel</tt>. * It is assumed that input Coordinates meet the given precision. */ class GEOS_DLL GeometryFactory { private: struct GeometryFactoryDeleter { void operator()(GeometryFactory* p) const { p->destroy(); } }; public: using Ptr = std::unique_ptr<GeometryFactory, GeometryFactoryDeleter>; /** * \brief * Constructs a GeometryFactory that generates Geometries having a * floating PrecisionModel and a spatial-reference ID of 0. */ static GeometryFactory::Ptr create(); /** * \brief * Constructs a GeometryFactory that generates Geometries having * the given PrecisionModel, spatial-reference ID, and * CoordinateSequence implementation. * * NOTES: * (1) the given PrecisionModel is COPIED * (2) the CoordinateSequenceFactory is NOT COPIED * and must be available for the whole lifetime * of the GeometryFactory */ static GeometryFactory::Ptr create(const PrecisionModel* pm, int newSRID, CoordinateSequenceFactory* nCoordinateSequenceFactory); /** * \brief * Constructs a GeometryFactory that generates Geometries having the * given CoordinateSequence implementation, a double-precision floating * PrecisionModel and a spatial-reference ID of 0. */ static GeometryFactory::Ptr create(CoordinateSequenceFactory* nCoordinateSequenceFactory); /** * \brief * Constructs a GeometryFactory that generates Geometries having * the given PrecisionModel and the default CoordinateSequence * implementation. * * @param pm the PrecisionModel to use */ static GeometryFactory::Ptr create(const PrecisionModel* pm); /** * \brief * Constructs a GeometryFactory that generates Geometries having * the given {@link PrecisionModel} and spatial-reference ID, * and the default CoordinateSequence implementation. * * @param pm the PrecisionModel to use, will be copied internally * @param newSRID the SRID to use */ static GeometryFactory::Ptr create(const PrecisionModel* pm, int newSRID); /** * \brief Copy constructor * * @param gf the GeometryFactory to clone from */ static GeometryFactory::Ptr create(const GeometryFactory& gf); /** * \brief * Return a pointer to the default GeometryFactory. * This is a global shared object instantiated * using default constructor. */ static const GeometryFactory* getDefaultInstance(); //Skipped a lot of list to array convertors Point* createPointFromInternalCoord(const Coordinate* coord, const Geometry* exemplar) const; /// Converts an Envelope to a Geometry. /// /// Returned Geometry can be a Point, a Polygon or an EMPTY geom. /// std::unique_ptr<Geometry> toGeometry(const Envelope* envelope) const; /// \brief /// Returns the PrecisionModel that Geometries created by this /// factory will be associated with. const PrecisionModel* getPrecisionModel() const; /// Creates an EMPTY Point std::unique_ptr<Point> createPoint(std::size_t coordinateDimension = 2) const; /// Creates a Point using the given Coordinate Point* createPoint(const Coordinate& coordinate) const; /// Creates a Point taking ownership of the given CoordinateSequence Point* createPoint(CoordinateSequence* coordinates) const; /// Creates a Point with a deep-copy of the given CoordinateSequence. Point* createPoint(const CoordinateSequence& coordinates) const; /// Construct an EMPTY GeometryCollection std::unique_ptr<GeometryCollection> createGeometryCollection() const; /// Construct the EMPTY Geometry std::unique_ptr<Geometry> createEmptyGeometry() const; /// Construct a GeometryCollection taking ownership of given arguments GeometryCollection* createGeometryCollection( std::vector<Geometry*>* newGeoms) const; template<typename T> std::unique_ptr<GeometryCollection> createGeometryCollection( std::vector<std::unique_ptr<T>> && newGeoms) const { // Can't use make_unique because constructor is protected return std::unique_ptr<GeometryCollection>(new GeometryCollection(Geometry::toGeometryArray(std::move(newGeoms)), *this)); } /// Constructs a GeometryCollection with a deep-copy of args GeometryCollection* createGeometryCollection( const std::vector<const Geometry*>& newGeoms) const; /// Construct an EMPTY MultiLineString std::unique_ptr<MultiLineString> createMultiLineString() const; /// Construct a MultiLineString taking ownership of given arguments MultiLineString* createMultiLineString( std::vector<Geometry*>* newLines) const; /// Construct a MultiLineString with a deep-copy of given arguments MultiLineString* createMultiLineString( const std::vector<const Geometry*>& fromLines) const; std::unique_ptr<MultiLineString> createMultiLineString( std::vector<std::unique_ptr<LineString>> && fromLines) const; std::unique_ptr<MultiLineString> createMultiLineString( std::vector<std::unique_ptr<Geometry>> && fromLines) const; /// Construct an EMPTY MultiPolygon std::unique_ptr<MultiPolygon> createMultiPolygon() const; /// Construct a MultiPolygon taking ownership of given arguments MultiPolygon* createMultiPolygon(std::vector<Geometry*>* newPolys) const; /// Construct a MultiPolygon with a deep-copy of given arguments MultiPolygon* createMultiPolygon( const std::vector<const Geometry*>& fromPolys) const; std::unique_ptr<MultiPolygon> createMultiPolygon( std::vector<std::unique_ptr<Polygon>> && fromPolys) const; std::unique_ptr<MultiPolygon> createMultiPolygon( std::vector<std::unique_ptr<Geometry>> && fromPolys) const; /// Construct an EMPTY LinearRing std::unique_ptr<LinearRing> createLinearRing() const; /// Construct a LinearRing taking ownership of given arguments LinearRing* createLinearRing(CoordinateSequence* newCoords) const; std::unique_ptr<LinearRing> createLinearRing( std::unique_ptr<CoordinateSequence> && newCoords) const; /// Construct a LinearRing with a deep-copy of given arguments LinearRing* createLinearRing( const CoordinateSequence& coordinates) const; /// Constructs an EMPTY <code>MultiPoint</code>. std::unique_ptr<MultiPoint> createMultiPoint() const; /// Construct a MultiPoint taking ownership of given arguments MultiPoint* createMultiPoint(std::vector<Geometry*>* newPoints) const; std::unique_ptr<MultiPoint> createMultiPoint(std::vector<std::unique_ptr<Point>> && newPoints) const; std::unique_ptr<MultiPoint> createMultiPoint(std::vector<std::unique_ptr<Geometry>> && newPoints) const; /// Construct a MultiPoint with a deep-copy of given arguments MultiPoint* createMultiPoint( const std::vector<const Geometry*>& fromPoints) const; /// \brief /// Construct a MultiPoint containing a Point geometry /// for each Coordinate in the given list. MultiPoint* createMultiPoint( const CoordinateSequence& fromCoords) const; /// \brief /// Construct a MultiPoint containing a Point geometry /// for each Coordinate in the given vector. MultiPoint* createMultiPoint( const std::vector<Coordinate>& fromCoords) const; /// Construct an EMPTY Polygon std::unique_ptr<Polygon> createPolygon(std::size_t coordinateDimension = 2) const; /// Construct a Polygon taking ownership of given arguments Polygon* createPolygon(LinearRing* shell, std::vector<LinearRing*>* holes) const; std::unique_ptr<Polygon> createPolygon(std::unique_ptr<LinearRing> && shell) const; std::unique_ptr<Polygon> createPolygon(std::unique_ptr<LinearRing> && shell, std::vector<std::unique_ptr<LinearRing>> && holes) const; /// Construct a Polygon from a Coordinate vector, taking ownership of the vector std::unique_ptr<Polygon> createPolygon(std::vector<Coordinate> && coords) const; /// Construct a Polygon with a deep-copy of given arguments Polygon* createPolygon(const LinearRing& shell, const std::vector<LinearRing*>& holes) const; /// Construct an EMPTY LineString std::unique_ptr<LineString> createLineString(std::size_t coordinateDimension = 2) const; /// Copy a LineString std::unique_ptr<LineString> createLineString(const LineString& ls) const; /// Construct a LineString taking ownership of given argument LineString* createLineString(CoordinateSequence* coordinates) const; std::unique_ptr<LineString> createLineString( std::unique_ptr<CoordinateSequence> && coordinates) const; /// Construct a LineString with a deep-copy of given argument LineString* createLineString( const CoordinateSequence& coordinates) const; /** * Creates an empty atomic geometry of the given dimension. * If passed a dimension of -1 will create an empty {@link GeometryCollection}. * * @param dimension the required dimension (-1, 0, 1 or 2) * @return an empty atomic geometry of given dimension */ std::unique_ptr<Geometry> createEmpty(int dimension) const; /** * Build an appropriate <code>Geometry</code>, <code>MultiGeometry</code>, or * <code>GeometryCollection</code> to contain the <code>Geometry</code>s in * it. * * For example: * * - If <code>geomList</code> contains a single <code>Polygon</code>, * the <code>Polygon</code> is returned. * - If <code>geomList</code> contains several <code>Polygon</code>s, a * <code>MultiPolygon</code> is returned. * - If <code>geomList</code> contains some <code>Polygon</code>s and * some <code>LineString</code>s, a <code>GeometryCollection</code> is * returned. * - If <code>geomList</code> is empty, an empty * <code>GeometryCollection</code> is returned * . * * Note that this method does not "flatten" Geometries in the input, * and hence if any MultiGeometries are contained in the input a * GeometryCollection containing them will be returned. * * @param geoms the <code>Geometry</code>s to combine * * @return A <code>Geometry</code> of the "smallest", "most type-specific" * class that can contain the elements of <code>geomList</code>. * * NOTE: the returned Geometry will take ownership of the * given vector AND its elements */ Geometry* buildGeometry(std::vector<Geometry*>* geoms) const; std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Geometry>> && geoms) const; std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Point>> && geoms) const; std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<LineString>> && geoms) const; std::unique_ptr<Geometry> buildGeometry(std::vector<std::unique_ptr<Polygon>> && geoms) const; /// See buildGeometry(std::vector<Geometry *>&) for semantics // /// Will clone the geometries accessible trough the iterator. /// /// @tparam T an iterator yielding something which casts to const Geometry* /// @param from start iterator /// @param toofar end iterator /// template <class T> std::unique_ptr<Geometry> buildGeometry(T from, T toofar) const { bool isHeterogeneous = false; std::size_t count = 0; int geomClass = -1; for(T i = from; i != toofar; ++i) { ++count; const Geometry* g = *i; if(geomClass < 0) { geomClass = g->getSortIndex(); } else if(geomClass != g->getSortIndex()) { isHeterogeneous = true; } } // for the empty geometry, return an empty GeometryCollection if(count == 0) { return std::unique_ptr<Geometry>(createGeometryCollection()); } // for the single geometry, return a clone if(count == 1) { return (*from)->clone(); } // Now we know it is a collection // FIXME: // Until we tweak all the createMulti* interfaces // to support taking iterators we'll have to build // a custom vector here. std::vector<std::unique_ptr<Geometry>> fromGeoms; for(T i = from; i != toofar; ++i) { fromGeoms.push_back((*i)->clone()); } // for an heterogeneous ... if(isHeterogeneous) { return createGeometryCollection(std::move(fromGeoms)); } // At this point we know the collection is not hetereogenous. switch((*from)->getDimension()) { case Dimension::A: return createMultiPolygon(std::move(fromGeoms)); case Dimension::L: return createMultiLineString(std::move(fromGeoms)); case Dimension::P: return createMultiPoint(std::move(fromGeoms)); default: throw geos::util::IllegalArgumentException(std::string("Invalid geometry type.")); } } /** \brief * This function does the same thing of the omonimouse function * taking vector pointer instead of reference. * * The difference is that this version will copy needed data * leaving ownership to the caller. */ Geometry* buildGeometry(const std::vector<const Geometry*>& geoms) const; int getSRID() const; /// \brief /// Returns the CoordinateSequenceFactory associated /// with this GeometryFactory const CoordinateSequenceFactory* getCoordinateSequenceFactory() const; /// Returns a clone of given Geometry. Geometry* createGeometry(const Geometry* g) const; /// Destroy a Geometry, or release it void destroyGeometry(Geometry* g) const; /// Request that the instance is deleted. /// /// It will really be deleted only after last child Geometry is /// deleted. Do not use the instance anymore after calling this function /// (unless you're a live child!). /// void destroy(); protected: /** * \brief * Constructs a GeometryFactory that generates Geometries having a * floating PrecisionModel and a spatial-reference ID of 0. */ GeometryFactory(); /** * \brief * Constructs a GeometryFactory that generates Geometries having * the given PrecisionModel, spatial-reference ID, and * CoordinateSequence implementation. * * NOTES: * (1) the given PrecisionModel is COPIED * (2) the CoordinateSequenceFactory is NOT COPIED * and must be available for the whole lifetime * of the GeometryFactory */ GeometryFactory(const PrecisionModel* pm, int newSRID, CoordinateSequenceFactory* nCoordinateSequenceFactory); /** * \brief * Constructs a GeometryFactory that generates Geometries having the * given CoordinateSequence implementation, a double-precision floating * PrecisionModel and a spatial-reference ID of 0. */ GeometryFactory(CoordinateSequenceFactory* nCoordinateSequenceFactory); /** * \brief * Constructs a GeometryFactory that generates Geometries having * the given PrecisionModel and the default CoordinateSequence * implementation. * * @param pm the PrecisionModel to use */ GeometryFactory(const PrecisionModel* pm); /** * \brief * Constructs a GeometryFactory that generates Geometries having * the given {@link PrecisionModel} and spatial-reference ID, * and the default CoordinateSequence implementation. * * @param pm the PrecisionModel to use, will be copied internally * @param newSRID the SRID to use */ GeometryFactory(const PrecisionModel* pm, int newSRID); /** * \brief Copy constructor * * @param gf the GeometryFactory to clone from */ GeometryFactory(const GeometryFactory& gf); /// Destructor virtual ~GeometryFactory(); private: PrecisionModel precisionModel; int SRID; const CoordinateSequenceFactory* coordinateListFactory; mutable int _refCount; bool _autoDestroy; friend class Geometry; void addRef() const; void dropRef() const; }; } // namespace geos::geom } // namespace geos #ifdef GEOS_INLINE # include "geos/geom/GeometryFactory.inl" #endif #endif // ndef GEOS_GEOM_GEOMETRYFACTORY_H