IsSimpleOp.h

/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2001-2002 Vivid Solutions Inc.
 * Copyright (C) 2009 Sandro Santilli <strk@kbt.io>
 * Copyright (C) 2005-2006 Refractions Research Inc.
 * 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 <memory>
 
#include <geos/algorithm/LineIntersector.h>
#include <geos/algorithm/BoundaryNodeRule.h>
#include <geos/geom/CoordinateArraySequence.h>
#include <geos/noding/SegmentIntersector.h>
 
// Forward declarations
namespace geos {
namespace noding {
class SegmentString;
class BasicSegmentString;
}
namespace algorithm {
class BoundaryNodeRule;
}
namespace geom {
class LineString;
class LinearRing;
class MultiLineString;
class MultiPoint;
class Geometry;
class Polygon;
class GeometryCollection;
}
}
 
 
namespace geos {      // geos
namespace operation { // geos.operation
namespace valid {     // geos.operation.valid
 
class GEOS_DLL IsSimpleOp {
 
private:
 
    const geom::Geometry& inputGeom;
    bool isClosedEndpointsInInterior = true;
    bool isFindAllLocations = false;
    bool isSimpleResult = false;
    std::vector<geom::Coordinate> nonSimplePts;
    bool computed = false;
 
    void compute();
 
    bool computeSimple(const geom::Geometry& geom);
 
    bool isSimpleMultiPoint(const geom::MultiPoint& mp);
 
    bool isSimplePolygonal(const geom::Geometry& geom);
 
    bool isSimpleGeometryCollection(const geom::Geometry& geom);
 
    bool isSimpleLinearGeometry(const geom::Geometry& geom);
 
    static std::vector<std::unique_ptr<geos::geom::CoordinateArraySequence>>
        removeRepeatedPts(const geom::Geometry& geom);
 
    static std::vector<std::unique_ptr<noding::SegmentString>>
        createSegmentStrings(std::vector<std::unique_ptr<geos::geom::CoordinateArraySequence>>& seqs);
 
    class NonSimpleIntersectionFinder : public noding::SegmentIntersector
    {
 
    private:
 
        bool isClosedEndpointsInInterior;
        bool isFindAll = false;
 
        std::vector<geom::Coordinate>& intersectionPts;
        algorithm::LineIntersector li;
 
        // bool hasInteriorInt;
        // bool hasInteriorVertexInt;
        // bool hasEqualSegments;
        // bool hasInteriorEndpointInt;
 
        bool findIntersection(
            noding::SegmentString* ss0, std::size_t segIndex0,
            noding::SegmentString* ss1, std::size_t segIndex1,
            const geom::Coordinate& p00, const geom::Coordinate& p01,
            const geom::Coordinate& p10, const geom::Coordinate& p11);
 
        bool isIntersectionEndpoint(
            const noding::SegmentString* ss, std::size_t ssIndex,
            const algorithm::LineIntersector& li, std::size_t liSegmentIndex) const;
 
        std::size_t intersectionVertexIndex(
            const algorithm::LineIntersector& li, std::size_t segmentIndex) const;
 
    public:
 
        NonSimpleIntersectionFinder(
            bool p_isClosedEndpointsInInterior,
            bool p_isFindAll,
            std::vector<geom::Coordinate>& p_intersectionPts)
        : isClosedEndpointsInInterior(p_isClosedEndpointsInInterior)
        , isFindAll(p_isFindAll)
        , intersectionPts(p_intersectionPts)
        {};
 
        bool hasIntersection() const;
 
        void processIntersections(
            noding::SegmentString* ss0, std::size_t segIndex0,
            noding::SegmentString* ss1, std::size_t segIndex1) override;
 
        bool isDone() const override;
 
    }; // NonSimpleIntersectionFinder
 
 
public:
 
    IsSimpleOp(const geom::Geometry* geom)
        : IsSimpleOp(*geom)
        {};
 
    IsSimpleOp(const geom::Geometry& geom)
        : IsSimpleOp(geom, algorithm::BoundaryNodeRule::getBoundaryRuleMod2())
        {};
 
    IsSimpleOp(const geom::Geometry& geom, const algorithm::BoundaryNodeRule& p_boundaryNodeRule)
        : inputGeom(geom)
        , isClosedEndpointsInInterior(! p_boundaryNodeRule.isInBoundary(2))
        , isFindAllLocations(false)
        , computed(false)
        {};
 
    static bool isSimple(const geom::Geometry& geom);
 
    static bool isSimple(const geom::Geometry* geom) {
        if (!geom) return false;
        return isSimple(*geom);
    }
 
    geom::Coordinate getNonSimpleLocation(const geom::Geometry& geom);
 
    void setFindAllLocations(bool isFindAll);
 
    bool isSimple();
 
    geom::Coordinate getNonSimpleLocation();
 
    const std::vector<geom::Coordinate>& getNonSimpleLocations();
 
 
 
}; // IsSimpleOp
 
 
} // namespace geos.operation.valid
} // namespace geos.operation
} // namespace geos