PolygonHullSimplifier.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2021 Paul Ramsey <pramsey@cleverelephant.ca>
 *
 * 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.
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/geom/Geometry.h>
#include <geos/util/IllegalArgumentException.h>
#include <geos/simplify/RingHull.h>
 
 
namespace geos {
namespace geom {
class GeometryFactory;
class LinearRing;
class MultiPolygon;
class Polygon;
}
namespace algorithm {
namespace hull {
class RingHullIndex;
}
}
}
 
 
using geos::geom::Envelope;
using geos::geom::Geometry;
using geos::geom::GeometryFactory;
using geos::geom::LinearRing;
using geos::geom::MultiPolygon;
using geos::geom::Polygon;
 
 
namespace geos {
namespace simplify { // geos::simplify
 
class GEOS_DLL PolygonHullSimplifier
{
 
public:
 
    PolygonHullSimplifier(const Geometry* geom, bool bOuter)
        : inputGeom(geom)
        , geomFactory(geom->getFactory())
        , isOuter(bOuter)
        , vertexNumFraction(-1.0)
        , areaDeltaRatio(-1.0)
    {
        if (!geom->isPolygonal()) {
            throw util::IllegalArgumentException("Input geometry must be polygonal");
        }
    };
 
    static std::unique_ptr<Geometry> hull(
        const Geometry* geom,
        bool isOuter,
        double vertexNumFraction);
 
    static std::unique_ptr<Geometry> hullByAreaDelta(
        const Geometry* geom,
        bool isOuter,
        double areaDeltaRatio);
 
 
    void setVertexNumFraction(double p_vertexNumFraction);
    void setAreaDeltaRatio(double p_areaDeltaRatio);
 
    std::unique_ptr<Geometry> getResult();
 
 
 
private:
 
    // Members
    const Geometry* inputGeom;
    const GeometryFactory* geomFactory;
    bool isOuter;
    double vertexNumFraction;
    double areaDeltaRatio;
    // Allocate the RingHull* in here so they are cleaned
    // up with PolygonHullSimplifier
    std::vector<std::unique_ptr<RingHull>> ringStore;
 
    std::unique_ptr<Geometry> computeMultiPolygonAll(const MultiPolygon* multiPoly);
    std::unique_ptr<Geometry> computeMultiPolygonEach(const MultiPolygon* multiPoly);
    std::unique_ptr<Polygon> computePolygon(const Polygon* poly);
 
    std::vector<RingHull*> initPolygon(const Polygon* poly,
        RingHullIndex& hullIndex);
 
    double ringArea(const Polygon* poly) const;
 
    RingHull* createRingHull(
        const LinearRing* ring,
        bool isOuter,
        double areaTotal,
        RingHullIndex& hullIndex);
 
    std::unique_ptr<Polygon> polygonHull(
        const Polygon* poly,
        std::vector<RingHull*>& ringHulls,
        RingHullIndex& hullIndex) const;
 
    PolygonHullSimplifier(const PolygonHullSimplifier&) = delete;
    PolygonHullSimplifier& operator=(const PolygonHullSimplifier&) = delete;
 
}; // PolygonHullSimplifier
 
 
} // geos::simplify
} // geos