EdgeNodingBuilder.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2020 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.
 *
 **********************************************************************
 *
 * Last port: operation/overlayng/EdgeNodingBuilder.java 6ef89b096
 *
 **********************************************************************/
 
#pragma once
 
#include <geos/algorithm/LineIntersector.h>
#include <geos/algorithm/Orientation.h>
#include <geos/geom/Coordinate.h>
#include <geos/geom/CoordinateArraySequence.h>
#include <geos/geom/CoordinateSequence.h>
#include <geos/geom/Envelope.h>
#include <geos/geom/Geometry.h>
#include <geos/geom/GeometryCollection.h>
#include <geos/geom/LinearRing.h>
#include <geos/geom/LineString.h>
#include <geos/geom/MultiLineString.h>
#include <geos/geom/MultiPolygon.h>
#include <geos/geom/Polygon.h>
#include <geos/noding/IntersectionAdder.h>
#include <geos/noding/MCIndexNoder.h>
#include <geos/noding/Noder.h>
#include <geos/noding/NodedSegmentString.h>
#include <geos/noding/SegmentString.h>
#include <geos/noding/ValidatingNoder.h>
#include <geos/noding/snapround/SnapRoundingNoder.h>
#include <geos/operation/overlayng/Edge.h>
#include <geos/operation/overlayng/EdgeSourceInfo.h>
#include <geos/operation/overlayng/InputGeometry.h>
#include <geos/operation/overlayng/LineLimiter.h>
#include <geos/operation/overlayng/OverlayUtil.h>
#include <geos/operation/overlayng/RingClipper.h>
#include <geos/operation/valid/RepeatedPointRemover.h>
 
 
#include <geos/export.h>
#include <array>
#include <memory>
#include <deque>
 
using namespace geos::geom;
using namespace geos::noding;
using geos::noding::snapround::SnapRoundingNoder;
using geos::algorithm::LineIntersector;
 
 
namespace geos {      // geos.
namespace operation { // geos.operation
namespace overlayng { // geos.operation.overlayng
 
class GEOS_DLL EdgeNodingBuilder {
 
private:
 
    // Constants
    static constexpr int MIN_LIMIT_PTS = 20;
    static constexpr bool IS_NODING_VALIDATED = true;
 
    // Members
    const PrecisionModel* pm;
    std::unique_ptr<std::vector<SegmentString*>> inputEdges;
    Noder* customNoder;
    std::array<bool, 2> hasEdges;
    const Envelope* clipEnv;
    std::unique_ptr<RingClipper> clipper;
    std::unique_ptr<LineLimiter> limiter;
 
    // For use in createFloatingPrecisionNoder()
    LineIntersector lineInt;
    IntersectionAdder intAdder;
    std::unique_ptr<Noder> internalNoder;
    std::unique_ptr<Noder> spareInternalNoder;
    // EdgeSourceInfo*, Edge* owned by EdgeNodingBuilder, stored in deque
    std::deque<EdgeSourceInfo> edgeSourceInfoQue;
    std::deque<Edge> edgeQue;
 
    Noder* getNoder();
    static std::unique_ptr<Noder> createFixedPrecisionNoder(const PrecisionModel* pm);
    std::unique_ptr<Noder> createFloatingPrecisionNoder(bool doValidation);
 
 
    void addCollection(const GeometryCollection* gc, uint8_t geomIndex);
    void addGeometryCollection(const GeometryCollection* gc, uint8_t geomIndex, int expectedDim);
    void addPolygon(const Polygon* poly, uint8_t geomIndex);
    void addPolygonRing(const LinearRing* ring, bool isHole, uint8_t geomIndex);
    void addLine(const LineString* line, uint8_t geomIndex);
    void addLine(std::unique_ptr<CoordinateArraySequence>& pts, uint8_t geomIndex);
    void addEdge(std::unique_ptr<std::vector<Coordinate>> pts, const EdgeSourceInfo* info);
    void addEdge(std::unique_ptr<CoordinateArraySequence>& cas, const EdgeSourceInfo* info);
 
    // Create a EdgeSourceInfo* owned by EdgeNodingBuilder
    const EdgeSourceInfo* createEdgeSourceInfo(uint8_t index, int depthDelta, bool isHole);
    const EdgeSourceInfo* createEdgeSourceInfo(uint8_t index);
 
    bool isClippedCompletely(const Envelope* env);
 
    bool isToBeLimited(const LineString* line) const;
 
    std::vector<std::unique_ptr<CoordinateArraySequence>>& limit(const LineString* line);
 
    std::unique_ptr<CoordinateArraySequence> clip(const LinearRing* line);
 
    static std::unique_ptr<CoordinateArraySequence> removeRepeatedPoints(const LineString* line);
 
    static int computeDepthDelta(const LinearRing* ring, bool isHole);
 
    void add(const Geometry* g, uint8_t geomIndex);
 
    std::vector<Edge*> node(std::vector<SegmentString*>* segStrings);
    std::vector<Edge*> createEdges(std::vector<SegmentString*>* segStrings);
 
 
public:
 
    EdgeNodingBuilder(const PrecisionModel* p_pm, Noder* p_customNoder)
        : pm(p_pm)
        , inputEdges(new std::vector<SegmentString*>)
        , customNoder(p_customNoder)
        , hasEdges{{false,false}}
        , clipEnv(nullptr)
        , intAdder(lineInt)
        {};
 
    ~EdgeNodingBuilder()
    {
        for (SegmentString* ss: *inputEdges) {
            delete ss;
        }
    }
 
    void setClipEnvelope(const Envelope* clipEnv);
 
    // returns newly allocated vector and segmentstrings
    // std::vector<SegmentString*>* node();
 
    bool hasEdgesFor(uint8_t geomIndex) const;
 
    std::vector<Edge*> build(const Geometry* geom0, const Geometry* geom1);
 
 
 
};
 
 
} // namespace geos.operation.overlayng
} // namespace geos.operation
} // namespace geos