TPVWSimplifier.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 <queue>
 
#include <geos/index/strtree/TemplateSTRtree.h>
#include <geos/index/VertexSequencePackedRtree.h>
#include <geos/simplify/LinkedLine.h>
#include <geos/coverage/Corner.h>
#include <geos/export.h>
 
 
namespace geos {
namespace geom {
class Coordinate;
class CoordinateSequence;
class Envelope;
class Geometry;
class GeometryFactory;
class LineString;
class MultiLineString;
}
}
 
 
using geos::coverage::Corner;
using geos::geom::Coordinate;
using geos::geom::CoordinateSequence;
using geos::geom::Envelope;
using geos::geom::Geometry;
using geos::geom::GeometryFactory;
using geos::geom::LineString;
using geos::geom::MultiLineString;
using geos::index::VertexSequencePackedRtree;
using geos::index::strtree::TemplateSTRtree;
using geos::simplify::LinkedLine;
 
 
namespace geos {
namespace coverage { // geos::coverage
 
 
class GEOS_DLL TPVWSimplifier
{
 
public:
 
    // Prototype
    class EdgeIndex;
 
    /* private static */
    class Edge {
 
    public:
 
        // Members
        double areaTolerance;
        bool isFreeRing;
        const Envelope* envelope;
        std::size_t nbPts;
        LinkedLine linkedLine;
        VertexSequencePackedRtree vertexIndex;
        std::size_t minEdgeSize;
 
        Edge(const LineString* p_inputLine, bool p_isFreeRing, double p_areaTolerance);
 
        const Coordinate& getCoordinate(std::size_t index) const;
 
        const Envelope* getEnvelopeInternal() const;
 
        std::size_t size() const;
 
        std::unique_ptr<CoordinateSequence> simplify(EdgeIndex& edgeIndex);
 
        void createQueue(Corner::PriorityQueue& pq);
 
        void addCorner(std::size_t i, Corner::PriorityQueue& cornerQueue);
 
        bool isRemovable(Corner& corner, EdgeIndex& edgeIndex) const;
 
        bool hasIntersectingVertex(const Corner& corner,
            const Envelope& cornerEnv,
            const Edge& edge) const;
 
        std::vector<std::size_t> query(const Envelope& cornerEnv) const;
 
        void removeCorner(
            Corner& corner,
            Corner::PriorityQueue& cornerQueue);
 
    }; // Edge
 
    class EdgeIndex
    {
        public:
 
            TemplateSTRtree<const Edge*> index;
 
            void add(std::vector<Edge>& edges);
 
            std::vector<const Edge*> query(const Envelope& queryEnv);
 
    }; // EdgeIndex
 
 
    static std::unique_ptr<MultiLineString> simplify(
        const MultiLineString* lines,
        double distanceTolerance);
 
    static std::unique_ptr<MultiLineString> simplify(
        const MultiLineString* lines,
        std::vector<bool>& freeRings,
        const MultiLineString* constraintLines,
        double distanceTolerance);
 
    // Constructor
    TPVWSimplifier(const MultiLineString* lines,
        double distanceTolerance);
 
 
private:
 
    // Members
    const MultiLineString* inputLines;
    std::vector<bool> isFreeRing;
    double areaTolerance;
    const GeometryFactory* geomFactory;
    const MultiLineString* constraintLines;
 
 
    // Methods
    void setFreeRingIndices(std::vector<bool>& freeRing);
 
    void setConstraints(const MultiLineString* constraints);
 
    std::unique_ptr<MultiLineString> simplify();
 
    std::vector<Edge> createEdges(
        const MultiLineString* lines,
        std::vector<bool>& freeRing);
 
 
}; // TPVWSimplifier
 
 
} // geos::coverage
} // geos