CoverageEdge.h

 
 
 
/**********************************************************************
 *
 * GEOS - Geometry Engine Open Source
 * http://geos.osgeo.org
 *
 * Copyright (C) 2022 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/geom/CoordinateSequence.h>
#include <geos/geom/LineSegment.h>
#include <geos/util.h>
 
// Forward declarations
namespace geos {
namespace geom {
class Coordinate;
class LinearRing;
class LineString;
class MultiLineString;
class GeometryFactory;
}
}
 
using geos::geom::Coordinate;
using geos::geom::CoordinateSequence;
using geos::geom::GeometryFactory;
using geos::geom::LinearRing;
using geos::geom::LineString;
using geos::geom::LineSegment;
using geos::geom::MultiLineString;
 
namespace geos {      // geos.
namespace coverage { // geos.coverage
 
class GEOS_DLL CoverageEdge {
 
private:
 
    // Members
    std::unique_ptr<CoordinateSequence> m_pts;
    std::size_t m_ringCount ;
    bool m_isFreeRing = true;
 
    // Methods
 
    static std::unique_ptr<CoordinateSequence>
    extractEdgePoints(const CoordinateSequence& ring,
        std::size_t start, std::size_t end);
 
    static const Coordinate&
    findDistinctPoint(
        const CoordinateSequence& pts,
        std::size_t index,
        bool isForward,
        const Coordinate& pt);
 
 
public:
 
    CoverageEdge(std::unique_ptr<CoordinateSequence> && pts, bool isFreeRing)
        : m_pts(pts ? std::move(pts) : detail::make_unique<CoordinateSequence>())
        , m_ringCount(0)
        , m_isFreeRing(isFreeRing)
        {}
 
    static LineSegment key(
        const CoordinateSequence& ring);
 
    static LineSegment key(
        const CoordinateSequence& ring,
        std::size_t start,
        std::size_t end);
 
    static std::unique_ptr<CoverageEdge> createEdge(
        const CoordinateSequence& ring);
 
    static std::unique_ptr<CoverageEdge> createEdge(
        const CoordinateSequence& ring,
        std::size_t start,
        std::size_t end);
 
    static std::unique_ptr<MultiLineString> createLines(
        const std::vector<CoverageEdge*>& edges,
        const GeometryFactory* geomFactory);
 
    std::unique_ptr<LineString> toLineString(
        const GeometryFactory* geomFactory);
 
    /* public */
    void incRingCount()
    {
        m_ringCount++;
    }
 
    /* public */
    std::size_t getRingCount() const
    {
        return m_ringCount;
    }
 
    bool isFreeRing() const
    {
        return m_isFreeRing;
    }
 
    void setCoordinates(const CoordinateSequence* pts)
    {
        m_pts = pts->clone();
    }
 
    const CoordinateSequence* getCoordinates() const
    {
        return m_pts.get();
    }
 
    const Coordinate& getEndCoordinate() const
    {
        return m_pts->getAt(m_pts->size() - 1);
    }
 
    const Coordinate& getStartCoordinate() const
    {
        return m_pts->getAt(0);
    }
 
 
};
 
} // namespace geos.coverage
} // namespace geos