OffsetCurve.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/export.h>
#include <geos/geom/GeometryFactory.h>
#include <geos/index/chain/MonotoneChainSelectAction.h>
#include <geos/operation/buffer/BufferParameters.h>
 
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4251) // warning C4251: needs to have dll-interface to be used by clients of class
#endif
 
// Forward declarations
namespace geos {
namespace geom {
class Geometry;
class LineString;
class LinearRing;
class Polygon;
class CoordinateSequence;
class Coordinate;
}
namespace operation {
namespace buffer {
class SegmentMCIndex;
}
}
namespace index {
namespace chain {
class MonotoneChain;
}
}
}
 
using geos::geom::Geometry;
using geos::geom::GeometryFactory;
using geos::geom::LineString;
using geos::geom::LinearRing;
using geos::geom::Polygon;
using geos::geom::CoordinateSequence;
using geos::geom::Coordinate;
 
namespace geos {
namespace operation {
namespace buffer {
 
class GEOS_DLL OffsetCurve {
 
 
private:
 
    // Constants
    static constexpr int NEARNESS_FACTOR = 10000;
 
    // Members
    const Geometry& inputGeom;
    double distance;
    BufferParameters bufferParams;
    double matchDistance;
    const GeometryFactory* geomFactory;
 
    // Methods
 
    std::unique_ptr<LineString> computeCurve(const LineString& lineGeom, double distance);
 
    std::unique_ptr<LineString> offsetSegment(const CoordinateSequence* pts, double distance);
 
    static std::unique_ptr<Polygon> getBufferOriented(const LineString& geom, double distance, BufferParameters& bufParms);
 
    static std::unique_ptr<Polygon> extractMaxAreaPolygon(const Geometry& geom);
 
    static std::unique_ptr<LinearRing> extractLongestHole(const Polygon& poly);
 
    std::unique_ptr<LineString> computeCurve(
        const CoordinateSequence* bufferPts,
        std::vector<CoordinateSequence*>& rawOffsetList);
 
    int markMatchingSegments(const Coordinate& p0, const Coordinate& p1,
        SegmentMCIndex& segIndex, const CoordinateSequence* bufferPts,
        std::vector<bool>& isInCurve);
 
    static double subsegmentMatchFrac(const Coordinate& p0, const Coordinate& p1,
        const Coordinate& seg0, const Coordinate& seg1, double matchDistance);
 
    static void extractSection(const CoordinateSequence* ring, int iStartIndex,
            std::vector<bool>& isExtracted, std::vector<Coordinate>& extractedPoints);
 
    static std::size_t next(std::size_t i, std::size_t size);
 
 
    /* private */
    class MatchCurveSegmentAction : public index::chain::MonotoneChainSelectAction
    {
 
    private:
 
        const Coordinate& p0;
        const Coordinate& p1;
        const CoordinateSequence* bufferPts;
        double matchDistance;
        std::vector<bool>& isInCurve;
        double minFrac = -1;
        int minCurveIndex = -1;
 
    public:
 
        MatchCurveSegmentAction(
            const Coordinate& p_p0, const Coordinate& p_p1,
            const CoordinateSequence* p_bufferPts, double p_matchDistance,
            std::vector<bool>& p_isInCurve)
            : p0(p_p0)
            , p1(p_p1)
            , bufferPts(p_bufferPts)
            , matchDistance(p_matchDistance)
            , isInCurve(p_isInCurve)
            , minFrac(-1)
            , minCurveIndex(-1)
            {};
 
        void select(const index::chain::MonotoneChain& mc, std::size_t segIndex) override;
        void select(const geom::LineSegment& seg) override { (void)seg; return; };
 
        int getMinCurveIndex() { return minCurveIndex; }
    };
 
 
public:
 
    OffsetCurve(const Geometry& geom, double dist)
        : inputGeom(geom)
        , distance(dist)
        , matchDistance(std::abs(dist)/NEARNESS_FACTOR)
        , geomFactory(geom.getFactory())
        {};
 
    OffsetCurve(const Geometry& geom, double dist, BufferParameters& bp)
        : inputGeom(geom)
        , distance(dist)
        , bufferParams(bp)
        , matchDistance(std::abs(dist)/NEARNESS_FACTOR)
        , geomFactory(geom.getFactory())
        {};
 
    static std::unique_ptr<Geometry> getCurve(
        const Geometry& geom,
        double dist, int quadSegs, BufferParameters::JoinStyle joinStyle, double mitreLimit);
 
    static std::unique_ptr<Geometry> getCurve(const Geometry& geom, double dist);
    std::unique_ptr<Geometry> getCurve();
 
    static void rawOffset(const LineString& geom, double dist, BufferParameters& bufParams, std::vector<CoordinateSequence*>& lineList);
    static void rawOffset(const LineString& geom, double dist, std::vector<CoordinateSequence*>& lineList);
 
};
 
 
} // namespace geos::operation::buffer
} // namespace geos::operation
} // namespace geos
 
#ifdef _MSC_VER
#pragma warning(pop)
#endif