OGRRingAdapter.hpp

Go to the documentation of this file.

#pragma once
#include <fishnet/IGeometry.hpp>
#include <fishnet/Segment.hpp>
#include <fishnet/Rectangle.hpp>
#include <fishnet/RingIntersection.hpp>
#include <fishnet/PolygonDistance.hpp>
#include <fishnet/CollectionConcepts.hpp>
#include "OGRPolygonalAdapter.hpp"
 
namespace fishnet::geometry{
 
class OGRRingAdapter: public OGRPolygonalAdapter{
private:
    static OGRUniquePtr<OGRPolygon> asPolygon(OGRUniquePtr<OGRLinearRing> && ringPtr) {
        ringPtr->closeRings();
        auto polygon = emptyPolygon();
        polygon->addRingDirectly(ringPtr.release());
        return polygon;
    }
 
    OGRRingAdapter(OGRUniquePtr<OGRPolygon> && polygonPtr, Canonical canonical)
        :OGRPolygonalAdapter(std::move(polygonPtr), canonical) {}
 
    static OGRRingAdapter fromCanonicalRing(const OGRLinearRing & ring) {
        auto polygon = emptyPolygon();
        polygon->addRingDirectly(ring.clone());
        return OGRRingAdapter(std::move(polygon), Canonical{});
    }
 
    static OGRRingAdapter fromCanonicalHole(const OGRLinearRing & hole) {
        auto ring = OGRUniquePtr<OGRLinearRing>(hole.clone());
        ring->reversePoints();
        auto polygon = emptyPolygon();
        polygon->addRingDirectly(ring.release());
        return OGRRingAdapter(std::move(polygon), Canonical{});
    }
 
 
    static OGRRingAdapter borrowed(OGRLinearRing * ring) {
        return OGRRingAdapter(__impl::borrowRingAsPolygon(ring), Canonical{});
    }
 
    friend class OGRPolygonAdapter;
    friend class OGRGeometryAdapter;
 
    int openPointCount() const {
        return std::max(0, exteriorRing()->getNumPoints() - 1);
    }
 
    OGRUniquePtr<OGRGeometry> releaseGeometry() && noexcept {
        auto * ring = geomPtr->getExteriorRing();
        geomPtr->removeRing(0, false); // detach without deleting; the emptied shell is discarded with this adapter
        return OGRUniquePtr<OGRGeometry>(ring);
    }
 
public:
    using OGRPolygonalAdapter::contains;
 
    using numeric_type = double;
    static constexpr GeometryType type = GeometryType::RING;
 
    OGRRingAdapter(OGRUniquePtr<OGRLinearRing> && ringPtr):OGRPolygonalAdapter(asPolygon(std::move(ringPtr))) {}
 
    OGRRingAdapter(OGRUniquePtr<OGRPolygon> && polygonPtr):OGRPolygonalAdapter(std::move(polygonPtr)) {}
 
    OGRRingAdapter(IRing auto const & ring):OGRPolygonalAdapter(toOGRPolygon(ring)) {}
 
    auto getSegments() const & -> fishnet::util::forward_range_of<fishnet::geometry::Segment<double>> auto {
        return std::ranges::views::iota(0, openPointCount())
            | std::ranges::views::transform([this](int i) {
                const auto * ring = exteriorRing();
                Vec2DReal p1 {ring->getX(i), ring->getY(i)};
                Vec2DReal p2 {ring->getX(i + 1), ring->getY(i + 1)};
                return Segment<double>(p1, p2);
            });
    }
 
    std::vector<fishnet::geometry::Segment<double>> getSegments() const && {
        return fishnet::util::toVector(this->getSegments());
    }
 
    auto getPoints() const & -> fishnet::util::forward_range_of<fishnet::geometry::Vec2DReal> auto {
        return std::ranges::views::iota(0, openPointCount())
            | std::ranges::views::transform([this](int i) {
                const auto * ring = exteriorRing();
                return Vec2DReal(ring->getX(i), ring->getY(i));
            });
    }
 
    std::vector<fishnet::geometry::Vec2DReal> getPoints() const && {
        return fishnet::util::toVector(this->getPoints());
    }
 
    const OGRRingAdapter & getBoundary() const{
        return *this;
    }
 
    Ring<double> toNative() const {
        return Ring<double>(getPoints(), true);
    }
 
    std::vector<OGRRingAdapter> getHoles() const{
        return {};
    }
 
    Vec2DReal centroid() const {
        Vec2DReal sum {0,0};
        size_t count = 0;
        for(const auto & point : getPoints()){
            sum = sum + point;
            ++count;
        }
        return sum / static_cast<double>(count);
    }
 
    bool intersects(const LinearGeometry auto & linearFeature) const{
        return ringIntersects(*this, linearFeature);
    }
 
    std::unordered_set<Vec2DReal> intersections(const LinearGeometry auto & linearFeature) const{
        auto intersectionRange = this->getSegments()
            | std::views::transform([&linearFeature](const auto & segment){return segment.intersection(linearFeature);})
            | std::views::filter([](const auto & optIntersection){return optIntersection.has_value();})
            | std::views::transform([](const auto & optIntersection){return optIntersection.value();});
        return std::unordered_set<Vec2D<double>> {std::ranges::begin(intersectionRange), std::ranges::end(intersectionRange)};
    }
 
    bool crosses(const IRing auto & other) const{
        if(not this->aaBB().overlap(other.aaBB()))
            return false;
        return std::ranges::any_of(this->getSegments(),[&other](const auto & s){return other.intersects(s);})
            || std::ranges::any_of(other.getSegments(),[this](const auto & s){return this->intersects(s);});
    }
 
    bool touches(const IRing auto & other) const{
        if(not this->aaBB().overlap(other.aaBB()))
            return false;
        if(this->crosses(other)) 
            return false;
        if(this->contains(other) || other.contains(*this)) return false;
        for(const auto & p : other.getPoints()){
            if(this->isOnBoundary(p)) return true;
        }
        return false;
    }
 
    double distance(const IRing auto & other) const{
        if(this->contains(other) or other.contains(*this) or this->crosses(other))
             return 0;
        return shapeDistance(*this,other);
    }
 
    double distance(const OGRRingAdapter & other) const{
        return geomPtr->Distance(other.geomPtr.get());
    }
};
static_assert(IRing<OGRRingAdapter>);
}