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/CircularArcIntersector.h>
#include <geos/algorithm/LineIntersector.h>
#include <geos/geom/CoordinateSequence.h>
#include <geos/geom/CircularArc.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/Polygon.h>
#include <geos/geom/SimpleCurve.h>
#include <geos/noding/ArcIntersectionAdder.h>
#include <geos/noding/IntersectionAdder.h>
#include <geos/noding/Noder.h>
#include <geos/noding/SegmentString.h>
#include <geos/operation/overlayng/Edge.h>
#include <geos/operation/overlayng/EdgeSourceInfo.h>
#include <geos/operation/overlayng/LineLimiter.h>
#include <geos/operation/overlayng/RingClipper.h>
 
 
#include <geos/export.h>
#include <array>
#include <memory>
#include <deque>
 
 
 
namespace geos {      // geos.
namespace operation { // geos.operation
namespace overlayng { // geos.operation.overlayng
 
class GEOS_DLL EdgeNodingBuilder {
    using PrecisionModel = geos::geom::PrecisionModel;
    using Envelope = geos::geom::Envelope;
    using GeometryCollection = geos::geom::GeometryCollection;
    using Surface = geos::geom::Surface;
    using Polygon = geos::geom::Polygon;
    using CoordinateSequence = geos::geom::CoordinateSequence;
    using CompoundCurve = geos::geom::CompoundCurve;
    using CircularString = geos::geom::CircularString;
    using LinearRing = geos::geom::LinearRing;
    using LineString = geos::geom::LineString;
    using Geometry = geos::geom::Geometry;
    using SimpleCurve = geos::geom::SimpleCurve;
    using Curve = geos::geom::Curve;
 
private:
 
    // Constants
    static constexpr int MIN_LIMIT_PTS = 20;
    static constexpr bool IS_NODING_VALIDATED = true;
 
    // Members
    const PrecisionModel* pm;
    std::vector<noding::PathString*> inputEdges;
    noding::Noder* customNoder;
    std::array<bool, 2> hasEdges;
    const Envelope* clipEnv;
    std::unique_ptr<RingClipper> clipper;
    std::unique_ptr<LineLimiter> limiter;
 
    // For use in createFloatingPrecisionNoder()
    algorithm::LineIntersector lineInt;
    algorithm::CircularArcIntersector arcInt;
    noding::IntersectionAdder intAdder;
    noding::ArcIntersectionAdder arcIntAdder;
    std::unique_ptr<noding::Noder> internalNoder;
    std::unique_ptr<noding::Noder> spareInternalNoder;
    // EdgeSourceInfo*, Edge* owned by EdgeNodingBuilder, stored in deque
    std::deque<EdgeSourceInfo> edgeSourceInfoQue;
    std::deque<Edge> edgeQue;
    bool inputHasZ;
    bool inputHasM;
    bool inputHasCurves;
 
    noding::Noder* getNoder();
    static std::unique_ptr<noding::Noder> createFixedPrecisionNoder(const PrecisionModel* pm);
    std::unique_ptr<noding::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 Surface* poly, uint8_t geomIndex);
    void addPolygonRing(const Curve* ring, bool isHole, uint8_t geomIndex);
    void addSimpleCurve(const SimpleCurve* line, uint8_t geomIndex);
    void addCompoundCurve(const CompoundCurve* line, uint8_t geomIndex);
 
    void addCurve(const std::shared_ptr<const CoordinateSequence>& pts, const std::vector<geom::CircularArc>& arcs, uint8_t geomIndex);
    void addLine(const std::shared_ptr<const CoordinateSequence>& pts, uint8_t geomIndex);
 
    void addEdge(const std::shared_ptr<const CoordinateSequence>& cas, const EdgeSourceInfo* info);
    void addCurvedEdge(const std::shared_ptr<const CoordinateSequence>& cas, const std::vector<geom::CircularArc>& arcs, 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) const;
 
    bool isToBeLimited(const LineString* line) const;
 
    std::vector<std::unique_ptr<CoordinateSequence>>& limit(const LineString* line) const;
 
    std::shared_ptr<const CoordinateSequence> clip(const LineString* ring) const;
 
    static std::shared_ptr<const CoordinateSequence> removeRepeatedPoints(const LineString* line);
 
    static int computeDepthDelta(const CoordinateSequence* ringCoords, bool isHole);
 
    void add(const Geometry* g, uint8_t geomIndex);
 
    std::vector<Edge*> node(const std::vector<noding::PathString*>& segStrings);
    std::vector<Edge*> createEdges(std::vector<std::unique_ptr<noding::PathString>> &segStrings);
 
 
public:
 
    EdgeNodingBuilder(const PrecisionModel* p_pm, noding::Noder* p_customNoder)
        : pm(p_pm)
        , customNoder(p_customNoder)
        , hasEdges{{false,false}}
        , clipEnv(nullptr)
        , intAdder(lineInt)
        , arcIntAdder(arcInt)
        , inputHasZ(false)
        , inputHasM(false)
        , inputHasCurves(false)
        {};
 
    ~EdgeNodingBuilder();
 
    void setClipEnvelope(const Envelope* clipEnv);
 
    bool hasEdgesFor(uint8_t geomIndex) const;
 
    std::vector<Edge*> build(const Geometry* geom0, const Geometry* geom1);
 
    // Declare type as noncopyable
    EdgeNodingBuilder(const EdgeNodingBuilder& other) = delete;
    EdgeNodingBuilder& operator=(const EdgeNodingBuilder& rhs) = delete;
};
 
 
} // namespace geos.operation.overlayng
} // namespace geos.operation
} // namespace geos