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)
 *
 **********************************************************************/
 
#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/export.h>
#include <geos/inline.h>
 
#include <vector>
#include <memory>
#include <cassert>
 
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 Point;
                class Polygon;
                class PrecisionModel;
        }
}
 
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, int newSRID,
                CoordinateSequenceFactory *nCoordinateSequenceFactory);
 
        static GeometryFactory::Ptr create(CoordinateSequenceFactory *nCoordinateSequenceFactory);
 
        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 convertors
 
        Point* createPointFromInternalCoord(const Coordinate* coord,
                        const Geometry *exemplar) const;
 
        //
        Geometry* toGeometry(const Envelope* envelope) const;
 
        const PrecisionModel* getPrecisionModel() const;
 
        Point* createPoint() const;
 
        Point* createPoint(const Coordinate& coordinate) const;
 
        Point* createPoint(CoordinateSequence *coordinates) const;
 
        Point* createPoint(const CoordinateSequence &coordinates) const;
 
        GeometryCollection* createGeometryCollection() const;
 
        Geometry* createEmptyGeometry() const;
 
        GeometryCollection* createGeometryCollection(
                        std::vector<Geometry *> *newGeoms) const;
 
        GeometryCollection* createGeometryCollection(
                        const std::vector<Geometry *> &newGeoms) const;
 
        MultiLineString* createMultiLineString() const;
 
        MultiLineString* createMultiLineString(
                        std::vector<Geometry *> *newLines) const;
 
        MultiLineString* createMultiLineString(
                        const std::vector<Geometry *> &fromLines) const;
 
        MultiPolygon* createMultiPolygon() const;
 
        MultiPolygon* createMultiPolygon(std::vector<Geometry *> *newPolys) const;
 
        MultiPolygon* createMultiPolygon(
                        const std::vector<Geometry *> &fromPolys) const;
 
        LinearRing* createLinearRing() const;
 
        LinearRing* createLinearRing(CoordinateSequence* newCoords) const;
 
        std::unique_ptr<Geometry> createLinearRing(
                        std::unique_ptr<CoordinateSequence> newCoords) const;
 
        LinearRing* createLinearRing(
                        const CoordinateSequence& coordinates) const;
 
        MultiPoint* createMultiPoint() const;
 
        MultiPoint* createMultiPoint(std::vector<Geometry *> *newPoints) const;
 
        MultiPoint* createMultiPoint(
                        const std::vector<Geometry *> &fromPoints) const;
 
        MultiPoint* createMultiPoint(
                        const CoordinateSequence &fromCoords) const;
 
        MultiPoint* createMultiPoint(
                        const std::vector<Coordinate> &fromCoords) const;
 
        Polygon* createPolygon() const;
 
        Polygon* createPolygon(LinearRing *shell,
                        std::vector<Geometry *> *holes) const;
 
        Polygon* createPolygon(const LinearRing &shell,
                        const std::vector<Geometry *> &holes) const;
 
        LineString* createLineString() const;
 
        std::unique_ptr<LineString> createLineString(const LineString& ls) const;
 
        LineString* createLineString(CoordinateSequence* coordinates) const;
 
        std::unique_ptr<Geometry> createLineString(
                        std::unique_ptr<CoordinateSequence> coordinates) const;
 
        LineString* createLineString(
                        const CoordinateSequence& coordinates) const;
 
        Geometry* buildGeometry(std::vector<Geometry *> *geoms) const;
 
  //
  template <class T>
        std::unique_ptr<Geometry> buildGeometry(T from, T toofar) const
  {
    bool isHeterogeneous = false;
    size_t count = 0;
    int geomClass = -1;
    for (T i=from; i != toofar; ++i)
    {
      ++count;
      const Geometry* g = *i;
      if ( geomClass < 0 ) {
        geomClass = g->getClassSortIndex();
      }
      else if ( geomClass != g->getClassSortIndex() ) {
        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 std::unique_ptr<Geometry>( (*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<Geometry*> fromGeoms;
    for (T i=from; i != toofar; ++i) {
      const Geometry* g = *i;
      fromGeoms.push_back(const_cast<Geometry*>(g));
    }
 
 
    // for an heterogeneous ...
    if ( isHeterogeneous ) {
      return std::unique_ptr<Geometry>( createGeometryCollection(fromGeoms) );
    }
 
    // At this point we know the collection is not hetereogenous.
    if ( dynamic_cast<const Polygon*>(*from) ) {
      return std::unique_ptr<Geometry>( createMultiPolygon(fromGeoms) );
    } else if ( dynamic_cast<const LineString*>(*from) ) {
      return std::unique_ptr<Geometry>( createMultiLineString(fromGeoms) );
    } else if ( dynamic_cast<const Point*>(*from) ) {
      return std::unique_ptr<Geometry>( createMultiPoint(fromGeoms) );
    }
    // FIXME: Why not to throw an exception? --mloskot
    assert(0); // buildGeomtry encountered an unkwnon geometry type
    return std::unique_ptr<Geometry>(); // nullptr
  }
 
        Geometry* buildGeometry(const std::vector<Geometry *> &geoms) const;
 
        int getSRID() const;
 
        const CoordinateSequenceFactory* getCoordinateSequenceFactory() const;
 
        Geometry* createGeometry(const Geometry *g) const;
 
        void destroyGeometry(Geometry *g) const;
 
  //
        void destroy();
 
protected:
 
        GeometryFactory();
 
        GeometryFactory(const PrecisionModel *pm, int newSRID,
                CoordinateSequenceFactory *nCoordinateSequenceFactory);
 
        GeometryFactory(CoordinateSequenceFactory *nCoordinateSequenceFactory);
 
        GeometryFactory(const PrecisionModel *pm);
 
        GeometryFactory(const PrecisionModel* pm, int newSRID);
 
        GeometryFactory(const GeometryFactory &gf);
 
        virtual ~GeometryFactory();
 
private:
 
        const 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