GeometryFactory.h
/**********************************************************************
*
* 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)
*
**********************************************************************/
#pragma once
#include <geos/geom/Geometry.h>
#include <geos/geom/GeometryCollection.h>
#include <geos/geom/GeometryFactory.h>
#include <geos/geom/MultiPoint.h>
#include <geos/geom/MultiLineString.h>
#include <geos/geom/MultiPolygon.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/geom/Polygon.h>
#include <geos/util/IllegalArgumentException.h>
#include <geos/export.h>
#include <vector>
#include <memory>
#include <cassert>
namespace geos {
namespace geom {
class Coordinate;
class CircularString;
class CompoundCurve;
class CoordinateSequence;
class Envelope;
class Geometry;
class GeometryCollection;
class LineString;
class LinearRing;
class MultiLineString;
class MultiCurve;
class MultiPoint;
class MultiPolygon;
class MultiSurface;
class CurvePolygon;
}
}
namespace geos {
namespace geom { // geos::geom
class GEOS_DLL GeometryFactory {
private:
struct GeometryFactoryDeleter {
void
operator()(GeometryFactory* p) const
{
p->destroy();
}
};
public:
using Ptr = std::unique_ptr<GeometryFactory, GeometryFactoryDeleter>;
static GeometryFactory::Ptr create();
static GeometryFactory::Ptr create(const PrecisionModel* pm);
static GeometryFactory::Ptr create(const PrecisionModel* pm, int newSRID);
static GeometryFactory::Ptr create(const GeometryFactory& gf);
static const GeometryFactory*
getDefaultInstance();
//Skipped a lot of list to array converters
static std::unique_ptr<Point> createPointFromInternalCoord(const Coordinate* coord,
const Geometry* exemplar);
std::unique_ptr<Geometry> toGeometry(const Envelope* envelope) const;
const PrecisionModel* getPrecisionModel() const
{
return &precisionModel;
};
std::unique_ptr<Point> createPoint(std::size_t coordinateDimension = 2) const;
std::unique_ptr<Point> createPoint(bool hasZ, bool hasM) const;
std::unique_ptr<Point> createPoint(const Coordinate& coordinate) const;
std::unique_ptr<Point> createPoint(const CoordinateXY& coordinate) const;
std::unique_ptr<Point> createPoint(const CoordinateXYM& coordinate) const;
std::unique_ptr<Point> createPoint(const CoordinateXYZM& coordinate) const;
std::unique_ptr<Point> createPoint(std::unique_ptr<CoordinateSequence>&& coordinates) const;
std::unique_ptr<Point> createPoint(const CoordinateSequence& coordinates) const;
std::unique_ptr<GeometryCollection> createGeometryCollection() const;
std::unique_ptr<Geometry> createEmptyGeometry(GeometryTypeId type = GEOS_GEOMETRYCOLLECTION, bool hasZ=false, bool hasM=false) 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));
}
std::unique_ptr<GeometryCollection> createGeometryCollection(
const std::vector<const Geometry*>& newGeoms) const;
std::unique_ptr<MultiLineString> createMultiLineString() const;
std::unique_ptr<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;
std::unique_ptr<MultiCurve> createMultiCurve() const;
std::unique_ptr<MultiCurve> createMultiCurve(
std::vector<std::unique_ptr<Geometry>> && fromCurves) const;
std::unique_ptr<MultiCurve> createMultiCurve(
std::vector<std::unique_ptr<Curve>> && fromCurves) const;
std::unique_ptr<MultiPolygon> createMultiPolygon() const;
std::unique_ptr<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;
std::unique_ptr<MultiSurface> createMultiSurface() const;
std::unique_ptr<MultiSurface> createMultiSurface(
std::vector<std::unique_ptr<Geometry>> && from) const;
std::unique_ptr<MultiSurface> createMultiSurface(
std::vector<std::unique_ptr<Surface>> && from) const;
std::unique_ptr<LinearRing> createLinearRing(std::size_t coordinateDimension = 2) const;
std::unique_ptr<LinearRing> createLinearRing(bool hasZ, bool hasM) const;
std::unique_ptr<LinearRing> createLinearRing(
std::unique_ptr<CoordinateSequence> && newCoords) const;
std::unique_ptr<LinearRing> createLinearRing(
const CoordinateSequence& coordinates) const;
std::unique_ptr<MultiPoint> createMultiPoint() const;
template<typename T>
std::unique_ptr<MultiPoint> createMultiPoint(const T& fromCoords) const
{
std::vector<std::unique_ptr<Geometry>> pts;
pts.reserve(fromCoords.size());
for (const auto& c : fromCoords) {
pts.emplace_back(createPoint(c));
}
return createMultiPoint(std::move(pts));
}
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;
std::unique_ptr<MultiPoint> createMultiPoint(
const std::vector<const Geometry*>& fromPoints) const;
std::unique_ptr<MultiPoint> createMultiPoint(
const CoordinateSequence& fromCoords) const;
std::unique_ptr<Polygon> createPolygon(std::size_t coordinateDimension = 2) const;
std::unique_ptr<Polygon> createPolygon(bool hasZ, bool hasM) 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;
std::unique_ptr<Polygon> createPolygon(CoordinateSequence && coords) const;
Polygon* createPolygon(const LinearRing& shell,
const std::vector<LinearRing*>& holes) const;
std::unique_ptr<CurvePolygon> createCurvePolygon(bool hasZ, bool hasM) const;
std::unique_ptr<CurvePolygon> createCurvePolygon(std::unique_ptr<Curve>&& shell) const;
std::unique_ptr<CurvePolygon> createCurvePolygon(std::unique_ptr<Curve>&& shell,
std::vector<std::unique_ptr<Curve>> && holes) const;
std::unique_ptr<LineString> createLineString(std::size_t coordinateDimension = 2) const;
std::unique_ptr<LineString> createLineString(bool hasZ, bool hasM) const;
std::unique_ptr<LineString> createLineString(const LineString& ls) const;
std::unique_ptr<LineString> createLineString(
std::unique_ptr<CoordinateSequence> && coordinates) const;
std::unique_ptr<LineString> createLineString(
const CoordinateSequence& coordinates) const;
std::unique_ptr<CircularString> createCircularString(bool hasZ, bool hasM) const;
std::unique_ptr<CircularString> createCircularString(const CircularString& ls) const;
std::unique_ptr<CircularString> createCircularString(
std::unique_ptr<CoordinateSequence> && coordinates) const;
std::unique_ptr<CircularString> createCircularString(
const CoordinateSequence& coordinates) const;
std::unique_ptr<CompoundCurve> createCompoundCurve() const;
std::unique_ptr<CompoundCurve> createCompoundCurve(std::vector<std::unique_ptr<SimpleCurve>>&&) const;
std::unique_ptr<Geometry> createEmpty(int dimension) const;
std::unique_ptr<Geometry> createEmpty(GeometryTypeId typeId) const;
std::unique_ptr<Geometry> createMulti(std::unique_ptr<Geometry> && geom) 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;
//
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."));
}
}
std::unique_ptr<Geometry> buildGeometry(const std::vector<const Geometry*>& geoms) const;
int getSRID() const
{
return SRID;
};
std::unique_ptr<Geometry> createGeometry(const Geometry* g) const;
void destroyGeometry(Geometry* g) const;
void destroy();
protected:
GeometryFactory();
GeometryFactory(const PrecisionModel* pm);
GeometryFactory(const PrecisionModel* pm, int newSRID);
GeometryFactory(const GeometryFactory& gf);
virtual ~GeometryFactory();
private:
PrecisionModel precisionModel;
int SRID;
mutable int _refCount;
bool _autoDestroy;
friend class Geometry;
void addRef() const;
void dropRef() const;
};
} // namespace geos::geom
} // namespace geos
geos::geom::CoordinateSequence
The internal representation of a list of coordinates inside a Geometry.
Definition CoordinateSequence.h:56
geos::geom::Coordinate
Coordinate is the lightweight class used to store coordinates.
Definition Coordinate.h:217
geos::geom::Dimension::A
@ A
Dimension value of a surface (2).
Definition Dimension.h:46
geos::geom::Dimension::L
@ L
Dimension value of a curve (1).
Definition Dimension.h:43
geos::geom::Dimension::P
@ P
Dimension value of a point (0).
Definition Dimension.h:40
geos::geom::Envelope
An Envelope defines a rectangulare region of the 2D coordinate plane.
Definition Envelope.h:59
geos::geom::GeometryCollection
Represents a collection of heterogeneous Geometry objects.
Definition GeometryCollection.h:51
geos::geom::GeometryFactory::createMultiPolygon
std::unique_ptr< MultiPolygon > createMultiPolygon(std::vector< std::unique_ptr< Polygon > > &&fromPolys) const
Construct a MultiPolygon taking ownership of given arguments.
geos::geom::GeometryFactory::create
static GeometryFactory::Ptr create(const PrecisionModel *pm)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and the defaul...
geos::geom::GeometryFactory::getDefaultInstance
static const GeometryFactory * getDefaultInstance()
Return a pointer to the default GeometryFactory. This is a global shared object instantiated using de...
geos::geom::GeometryFactory::createGeometry
std::unique_ptr< Geometry > createGeometry(const Geometry *g) const
Returns a clone of given Geometry.
geos::geom::GeometryFactory::createPoint
std::unique_ptr< Point > createPoint(const CoordinateSequence &coordinates) const
Creates a Point with a deep-copy of the given CoordinateSequence.
geos::geom::GeometryFactory::create
static GeometryFactory::Ptr create()
Constructs a GeometryFactory that generates Geometries having a floating PrecisionModel and a spatial...
geos::geom::GeometryFactory::GeometryFactory
GeometryFactory(const PrecisionModel *pm)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and the defaul...
geos::geom::GeometryFactory::createMultiPoint
std::unique_ptr< MultiPoint > createMultiPoint() const
Constructs an EMPTY MultiPoint.
geos::geom::GeometryFactory::createPoint
std::unique_ptr< Point > createPoint(std::size_t coordinateDimension=2) const
Creates an EMPTY Point.
geos::geom::GeometryFactory::createMultiSurface
std::unique_ptr< MultiSurface > createMultiSurface(std::vector< std::unique_ptr< Geometry > > &&from) const
Construct a MultiSurface taking ownership of given arguments.
geos::geom::GeometryFactory::createCircularString
std::unique_ptr< CircularString > createCircularString(std::unique_ptr< CoordinateSequence > &&coordinates) const
Construct a CircularString taking ownership of given argument.
geos::geom::GeometryFactory::createMultiPolygon
std::unique_ptr< MultiPolygon > createMultiPolygon() const
Construct an EMPTY MultiPolygon.
geos::geom::GeometryFactory::createLineString
std::unique_ptr< LineString > createLineString(const CoordinateSequence &coordinates) const
Construct a LineString with a deep-copy of given argument.
geos::geom::GeometryFactory::createMultiSurface
std::unique_ptr< MultiSurface > createMultiSurface() const
Construct an EMPTY MultiSurface.
geos::geom::GeometryFactory::getPrecisionModel
const PrecisionModel * getPrecisionModel() const
Returns the PrecisionModel that Geometries created by this factory will be associated with.
Definition GeometryFactory.h:143
geos::geom::GeometryFactory::createGeometryCollection
std::unique_ptr< GeometryCollection > createGeometryCollection() const
Construct an EMPTY GeometryCollection.
geos::geom::GeometryFactory::createGeometryCollection
std::unique_ptr< GeometryCollection > createGeometryCollection(const std::vector< const Geometry * > &newGeoms) const
Constructs a GeometryCollection with a deep-copy of args.
geos::geom::GeometryFactory::createLineString
std::unique_ptr< LineString > createLineString(const LineString &ls) const
Copy a LineString.
geos::geom::GeometryFactory::createCircularString
std::unique_ptr< CircularString > createCircularString(const CoordinateSequence &coordinates) const
Construct a CircularString with a deep-copy of given argument.
geos::geom::GeometryFactory::createLineString
std::unique_ptr< LineString > createLineString(std::size_t coordinateDimension=2) const
Construct an EMPTY LineString.
geos::geom::GeometryFactory::createLineString
std::unique_ptr< LineString > createLineString(std::unique_ptr< CoordinateSequence > &&coordinates) const
Construct a LineString taking ownership of given argument.
geos::geom::GeometryFactory::createEmptyGeometry
std::unique_ptr< Geometry > createEmptyGeometry(GeometryTypeId type=GEOS_GEOMETRYCOLLECTION, bool hasZ=false, bool hasM=false) const
Construct the EMPTY Geometry.
geos::geom::GeometryFactory::createMultiLineString
std::unique_ptr< MultiLineString > createMultiLineString(const std::vector< const Geometry * > &fromLines) const
Construct a MultiLineString with a deep-copy of given arguments.
geos::geom::GeometryFactory::destroyGeometry
void destroyGeometry(Geometry *g) const
Destroy a Geometry, or release it.
geos::geom::GeometryFactory::createMultiPoint
std::unique_ptr< MultiPoint > createMultiPoint(const CoordinateSequence &fromCoords) const
Construct a MultiPoint containing a Point geometry for each Coordinate in the given list.
geos::geom::GeometryFactory::createCompoundCurve
std::unique_ptr< CompoundCurve > createCompoundCurve(std::vector< std::unique_ptr< SimpleCurve > > &&) const
Construct a CompoundCurve taking ownership of given argument.
geos::geom::GeometryFactory::createMultiLineString
std::unique_ptr< MultiLineString > createMultiLineString(std::vector< std::unique_ptr< LineString > > &&fromLines) const
Construct a MultiLineString taking ownership of given arguments.
geos::geom::GeometryFactory::createMultiCurve
std::unique_ptr< MultiCurve > createMultiCurve() const
Construct an EMPTY MultiCurve.
geos::geom::GeometryFactory::createGeometryCollection
std::unique_ptr< GeometryCollection > createGeometryCollection(std::vector< std::unique_ptr< T > > &&newGeoms) const
Construct a GeometryCollection taking ownership of given arguments.
Definition GeometryFactory.h:172
geos::geom::GeometryFactory::createMultiCurve
std::unique_ptr< MultiCurve > createMultiCurve(std::vector< std::unique_ptr< Geometry > > &&fromCurves) const
Construct a MultiCurve taking ownership of given arguments.
geos::geom::GeometryFactory::createLinearRing
std::unique_ptr< LinearRing > createLinearRing(std::size_t coordinateDimension=2) const
Construct an EMPTY LinearRing.
geos::geom::GeometryFactory::createPolygon
Polygon * createPolygon(const LinearRing &shell, const std::vector< LinearRing * > &holes) const
Construct a Polygon with a deep-copy of given arguments.
geos::geom::GeometryFactory::createEmpty
std::unique_ptr< Geometry > createEmpty(int dimension) const
geos::geom::GeometryFactory::createMultiLineString
std::unique_ptr< MultiLineString > createMultiLineString() const
Construct an EMPTY MultiLineString.
geos::geom::GeometryFactory::GeometryFactory
GeometryFactory(const PrecisionModel *pm, int newSRID)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and spatial-re...
geos::geom::GeometryFactory::~GeometryFactory
virtual ~GeometryFactory()
Destructor.
geos::geom::GeometryFactory::createCurvePolygon
std::unique_ptr< CurvePolygon > createCurvePolygon(std::unique_ptr< Curve > &&shell) const
Construct a CurvePolygon taking ownership of given arguments.
geos::geom::GeometryFactory::createPoint
std::unique_ptr< Point > createPoint(std::unique_ptr< CoordinateSequence > &&coordinates) const
Creates a Point taking ownership of the given CoordinateSequence.
geos::geom::GeometryFactory::createMultiPoint
std::unique_ptr< MultiPoint > createMultiPoint(const std::vector< const Geometry * > &fromPoints) const
Construct a MultiPoint with a deep-copy of given arguments.
geos::geom::GeometryFactory::createPoint
std::unique_ptr< Point > createPoint(const Coordinate &coordinate) const
Creates a Point using the given Coordinate.
geos::geom::GeometryFactory::createPolygon
std::unique_ptr< Polygon > createPolygon(std::unique_ptr< LinearRing > &&shell) const
Construct a Polygon taking ownership of given arguments.
geos::geom::GeometryFactory::buildGeometry
std::unique_ptr< Geometry > buildGeometry(std::vector< std::unique_ptr< Geometry > > &&geoms) const
geos::geom::GeometryFactory::create
static GeometryFactory::Ptr create(const GeometryFactory &gf)
Copy constructor.
geos::geom::GeometryFactory::createPolygon
std::unique_ptr< Polygon > createPolygon(CoordinateSequence &&coords) const
Construct a Polygon from a Coordinate vector, taking ownership of the vector.
geos::geom::GeometryFactory::createCompoundCurve
std::unique_ptr< CompoundCurve > createCompoundCurve() const
Construct an EMPTY CompoundCurve.
geos::geom::GeometryFactory::createCircularString
std::unique_ptr< CircularString > createCircularString(const CircularString &ls) const
Copy a CircularString.
geos::geom::GeometryFactory::buildGeometry
std::unique_ptr< 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...
geos::geom::GeometryFactory::createCurvePolygon
std::unique_ptr< CurvePolygon > createCurvePolygon(bool hasZ, bool hasM) const
Construct an EMPTY CurvePolygon.
geos::geom::GeometryFactory::createPolygon
std::unique_ptr< Polygon > createPolygon(std::size_t coordinateDimension=2) const
Construct an EMPTY Polygon.
geos::geom::GeometryFactory::createCircularString
std::unique_ptr< CircularString > createCircularString(bool hasZ, bool hasM) const
Construct an EMPTY CircularString.
geos::geom::GeometryFactory::createLinearRing
std::unique_ptr< LinearRing > createLinearRing(std::unique_ptr< CoordinateSequence > &&newCoords) const
Construct a LinearRing taking ownership of given arguments.
geos::geom::GeometryFactory::GeometryFactory
GeometryFactory(const GeometryFactory &gf)
Copy constructor.
geos::geom::GeometryFactory::GeometryFactory
GeometryFactory()
Constructs a GeometryFactory that generates Geometries having a floating PrecisionModel and a spatial...
geos::geom::GeometryFactory::create
static GeometryFactory::Ptr create(const PrecisionModel *pm, int newSRID)
Constructs a GeometryFactory that generates Geometries having the given PrecisionModel and spatial-re...
geos::geom::GeometryFactory::createEmpty
std::unique_ptr< Geometry > createEmpty(GeometryTypeId typeId) const
geos::geom::GeometryFactory::createMultiPoint
std::unique_ptr< MultiPoint > createMultiPoint(std::vector< std::unique_ptr< Point > > &&newPoints) const
Construct a MultiPoint taking ownership of given arguments.
geos::geom::GeometryFactory::createLinearRing
std::unique_ptr< LinearRing > createLinearRing(const CoordinateSequence &coordinates) const
Construct a LinearRing with a deep-copy of given arguments.
geos::geom::GeometryFactory::destroy
void destroy()
geos::geom::GeometryFactory::createMultiPolygon
std::unique_ptr< MultiPolygon > createMultiPolygon(const std::vector< const Geometry * > &fromPolys) const
Construct a MultiPolygon with a deep-copy of given arguments.
geos::geom::GeometryFactory::toGeometry
std::unique_ptr< Geometry > toGeometry(const Envelope *envelope) const
geos::geom::GeometryFactory::buildGeometry
std::unique_ptr< Geometry > buildGeometry(T from, T toofar) const
See buildGeometry(std::vector<Geometry *>&) for semantics.
Definition GeometryFactory.h:400
geos::geom::Geometry
Basic implementation of Geometry, constructed and destructed by GeometryFactory.
Definition Geometry.h:196
geos::geom::LineString
Definition LineString.h:66
geos::geom::LinearRing
Models an OGC SFS LinearRing. A LinearRing is a LineString which is both closed and simple.
Definition LinearRing.h:54
geos::geom::MultiLineString
Models a collection of LineStrings.
Definition MultiLineString.h:49
geos::geom::MultiPoint
Definition MultiPoint.h:50
geos::geom::MultiPolygon
Definition MultiPolygon.h:58
geos::geom::Polygon
Represents a linear polygon, which may include holes.
Definition Polygon.h:61
geos::geom::PrecisionModel
Specifies the precision model of the Coordinate in a Geometry.
Definition PrecisionModel.h:87
geos::util::IllegalArgumentException
Indicates one or more illegal arguments.
Definition IllegalArgumentException.h:33
geos::geom
Definition Angle.h:26
geos::geom::GeometryTypeId
GeometryTypeId
Geometry types.
Definition Geometry.h:73
geos::geom::GEOS_GEOMETRYCOLLECTION
@ GEOS_GEOMETRYCOLLECTION
a collection of heterogeneus geometries
Definition Geometry.h:89
geos
Basic namespace for all GEOS functionalities.
Definition geos.h:38