OGRPolygonAdapter.hpp

Go to the documentation of this file.

#pragma once
#include <vector>
#include <fishnet/IGeometry.hpp>
#include <fishnet/Rectangle.hpp>
#include <fishnet/Polygon.hpp>
#include <fishnet/PolygonDistance.hpp>
#include "OGRPolygonalAdapter.hpp"
#include "OGRRingAdapter.hpp"
 
namespace fishnet::geometry{
 
class OGRPolygonAdapter: public OGRPolygonalAdapter{
private:
    OGRPolygonAdapter(OGRUniquePtr<OGRPolygon> && polygonPtr, Canonical canonical)
        :OGRPolygonalAdapter(std::move(polygonPtr), canonical) {}
 
    static OGRPolygonAdapter fromCanonicalPolygon(const OGRPolygon & polygon) {
        return OGRPolygonAdapter(OGRUniquePtr<OGRPolygon>(polygon.clone()), Canonical{});
    }
 
    static OGRPolygonAdapter borrowed(OGRPolygon * polygon) {
        return OGRPolygonAdapter(__impl::borrow(polygon), Canonical{});
    }
 
    OGRRingAdapter borrowedBoundary() const {
        return OGRRingAdapter::borrowed(geomPtr->getExteriorRing());
    }
 
    auto borrowedHoles() const -> fishnet::util::forward_range_of<OGRRingAdapter> auto {
        return std::ranges::views::iota(0, geomPtr->getNumInteriorRings())
            | std::ranges::views::transform([this](int i){
                return OGRRingAdapter::borrowed(geomPtr->getInteriorRing(i));
            });
    }
 
    friend class OGRMultiPolygonAdapter;
    friend class OGRGeometryAdapter;
 
    OGRUniquePtr<OGRGeometry> releaseGeometry() && noexcept {
        auto deleter = geomPtr.get_deleter();
        return OGRUniquePtr<OGRGeometry>(geomPtr.release(), deleter);
    }
 
public:
    using OGRPolygonalAdapter::contains;
    using numeric_type = double;
    static constexpr GeometryType type = GeometryType::POLYGON;
 
    OGRPolygonAdapter(OGRUniquePtr<OGRPolygon> && polygonPtr):OGRPolygonalAdapter(std::move(polygonPtr)) {}
 
    OGRPolygonAdapter(IPolygon auto const & polygon):OGRPolygonalAdapter(toOGRPolygon(polygon)) {}
 
    OGRRingAdapter getBoundary() const {
        return OGRRingAdapter::fromCanonicalRing(*exteriorRing());
    }
 
    std::vector<OGRRingAdapter> getHoles() const {
        std::vector<OGRRingAdapter> holes;
        holes.reserve(static_cast<size_t>(geomPtr->getNumInteriorRings()));
        for(int i = 0; i < geomPtr->getNumInteriorRings(); ++i){
            holes.emplace_back(OGRRingAdapter::fromCanonicalHole(*geomPtr->getInteriorRing(i)));
        }
        return holes;
    }
 
    bool isSimple() const {
        return geomPtr->getNumInteriorRings() == 0;
    }
 
    Polygon<double> toNative() const {
        std::vector<Ring<double>> holes;
        holes.reserve(static_cast<size_t>(geomPtr->getNumInteriorRings()));
        for(const auto & hole : getHoles()){
            holes.push_back(hole.toNative());
        }
        return Polygon<double>(getBoundary().toNative(), holes, true);
    }
 
    Vec2DReal centroid() const {
        auto boundary = borrowedBoundary();
        auto accumulatedArea = boundary.area();
        for(const auto & hole : borrowedHoles()){
            accumulatedArea -= hole.area();
        }
        auto accumulatedCentroid = boundary.centroid() * (boundary.area() / accumulatedArea);
        for(const auto & hole : borrowedHoles()){
            accumulatedCentroid = accumulatedCentroid + hole.centroid() * (-hole.area() / accumulatedArea);
        }
        return accumulatedCentroid;
    }
 
    bool containsInHole(const IPoint auto & point) const {
        return std::ranges::any_of(borrowedHoles(), [&point](const auto & hole){return hole.contains(point);});
    }
 
    bool containsInHole(const IPolygon auto & other) const {
        auto otherBoundary = other.getBoundary();
        return std::ranges::any_of(borrowedHoles(), [&otherBoundary](const auto & hole){return hole.contains(otherBoundary);});
    }
 
    bool intersects(const LinearGeometry auto & linearFeature) const {
        if(borrowedBoundary().intersects(linearFeature))
            return true;
        return std::ranges::any_of(borrowedHoles(), [&linearFeature](const auto & hole){return hole.intersects(linearFeature);});
    }
 
    std::unordered_set<Vec2DReal> intersections(const LinearGeometry auto & linearFeature) const {
        std::unordered_set<Vec2DReal> intersectionSet;
        for(const auto & point : borrowedBoundary().intersections(linearFeature)){
            intersectionSet.insert(point);
        }
        for(const auto & hole : borrowedHoles()){
            for(const auto & point : hole.intersections(linearFeature)){
                intersectionSet.insert(point);
            }
        }
        return intersectionSet;
    }
 
    bool crosses(const IPolygon auto & other) const {
        if(not this->aaBB().overlap(other.aaBB()))
            return false; // polygons whose bounding boxes are apart cannot share a single point
        if(containsInHole(other))
            return false;
        auto otherBoundary = other.getBoundary();
        if(borrowedBoundary().crosses(otherBoundary))
            return true;
        return std::ranges::any_of(borrowedHoles(), [&otherBoundary](const auto & hole){return hole.crosses(otherBoundary);});
    }
 
    bool touches(const IPolygon auto & other) const {
        if(not this->aaBB().overlap(other.aaBB()))
            return false; // polygons whose bounding boxes are apart cannot touch
        if(this->crosses(other))
            return false;
        auto otherBoundary = other.getBoundary();
        if(borrowedBoundary().touches(otherBoundary))
            return true;
        return std::ranges::any_of(borrowedHoles(), [&otherBoundary](const auto & hole){
            // a hole fully contains the other polygon and touches it at least at one point
            return hole.contains(otherBoundary) && std::ranges::any_of(otherBoundary.getPoints(),[&hole](const auto & p){
                return hole.isOnBoundary(p);
            });
        });
    }
 
    double distance(const IPolygon auto & other) const {
        // polygons whose bounding boxes are apart can neither contain nor touch each other, so
        // the gap between their boundaries is all there is left to compute
        if(this->aaBB().overlap(other.aaBB())){
            if(this->contains(other))
                return 0;
            if(this->touches(other))
                return 0;
        }
        auto otherBoundary = other.getBoundary();
        for(const auto & hole : borrowedHoles()){
            if(hole.contains(otherBoundary)){
                return shapeDistance(hole, otherBoundary);
            }
        }
        return borrowedBoundary().distance(otherBoundary);
    }
 
    double distance(const OGRPolygonAdapter & other) const {
        return geomPtr->Distance(other.geomPtr.get());
    }
};
static_assert(IPolygon<OGRPolygonAdapter>);
static_assert(Shape<OGRPolygonAdapter>);
}