GeometryTransformer.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/util/GeometryTransformer.java r320 (JTS-1.12)
 *
 **********************************************************************/
 
#pragma once
 
 
#include <geos/export.h>
#include <geos/geom/Coordinate.h> // destructor visibility for vector
#include <geos/geom/Geometry.h> // destructor visibility for unique_ptr
#include <geos/geom/CoordinateSequence.h> // destructor visibility for unique_ptr
 
#include <memory> // for unique_ptr
#include <vector>
 
// Forward declarations
namespace geos {
namespace geom {
class Geometry;
class GeometryFactory;
class Point;
class LinearRing;
class LineString;
class Polygon;
class MultiPoint;
class MultiPolygon;
class MultiLineString;
class GeometryCollection;
class CircularString;
class CompoundCurve;
class CurvePolygon;
class MultiCurve;
class MultiSurface;
namespace util {
//class GeometryEditorOperation;
}
}
}
 
 
namespace geos {
namespace geom { // geos.geom
namespace util { // geos.geom.util
 
class GEOS_DLL GeometryTransformer {
 
public:
 
    GeometryTransformer();
 
    virtual ~GeometryTransformer() = default;
 
    std::unique_ptr<Geometry> transform(const Geometry* nInputGeom);
 
    void setSkipTransformedInvalidInteriorRings(bool b);
 
protected:
 
    const GeometryFactory* factory;
 
    virtual CoordinateSequence::Ptr transformCoordinates(
        const CoordinateSequence* coords,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformPoint(
        const Point* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformMultiPoint(
        const MultiPoint* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformLinearRing(
        const LinearRing* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformLineString(
        const LineString* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformCircularString(
        const CircularString* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformCompoundCurve(
        const CompoundCurve* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformMultiLineString(
        const MultiLineString* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformPolygon(
        const Polygon* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformCurvePolygon(
        const CurvePolygon* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformMultiPolygon(
        const MultiPolygon* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformMultiCurve(
        const MultiCurve* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformMultiSurface(
        const MultiSurface* geom,
        const Geometry* parent);
 
    virtual Geometry::Ptr transformGeometryCollection(
        const GeometryCollection* geom,
        const Geometry* parent);
 
private:
 
    const Geometry* inputGeom;
 
    // these could eventually be exposed to clients
    bool pruneEmptyGeometry;
 
    bool preserveGeometryCollectionType;
 
    // bool preserveCollections;
 
    bool preserveType;
 
    bool skipTransformedInvalidInteriorRings;
 
    // Declare type as noncopyable
    GeometryTransformer(const GeometryTransformer& other) = delete;
    GeometryTransformer& operator=(const GeometryTransformer& rhs) = delete;
};
 
 
} // namespace geos.geom.util
} // namespace geos.geom
} // namespace geos