OGRPolygonalAdapter.hpp

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <fishnet/IGeometry.hpp>
#include <fishnet/Segment.hpp>
#include <fishnet/Rectangle.hpp>
#include "OGRAdapterBase.hpp"
 
namespace fishnet::geometry{
 
class OGRPolygonalAdapter: public OGRAdapterBase<OGRPolygon>{
protected:
    using Base = OGRAdapterBase<OGRPolygon>;
 
    static OGRUniquePtr<OGRPolygon> emptyPolygon() {
        return OGRUniquePtr<OGRPolygon>(static_cast<OGRPolygon*>(OGRGeometryFactory::createGeometry(wkbPolygon)));
    }
 
    static OGRLinearRing toLinearRing(const IRing auto & ring) {
        OGRLinearRing ogrRing;
        for(const auto & point : ring.getPoints()){
            ogrRing.addPoint(point.getX(), point.getY());
        }
        ogrRing.closeRings();
        return ogrRing;
    }
 
    static OGRUniquePtr<OGRPolygon> toOGRPolygon(const IRing auto & ring) {
        auto polygon = emptyPolygon();
        auto boundary = toLinearRing(ring);
        polygon->addRing(&boundary);
        return polygon;
    }
 
    static OGRUniquePtr<OGRPolygon> toOGRPolygon(const IPolygon auto & polygon) {
        auto ogrPolygon = emptyPolygon();
        auto boundary = toLinearRing(polygon.getBoundary());
        ogrPolygon->addRing(&boundary);
        for(const auto & hole : polygon.getHoles()){
            auto ogrHole = toLinearRing(hole);
            ogrPolygon->addRing(&ogrHole);
        }
        return ogrPolygon;
    }
 
    static bool covers(const OGRGeometry & covering, const OGRGeometry & covered) {
        auto difference = OGRUniquePtr<OGRGeometry>(covered.Difference(&covering));
        return difference && difference->IsEmpty();
    }
 
    void canonicalize() noexcept {
        auto normalized = OGRUniquePtr<OGRGeometry>(geomPtr->Normalize());
        if(normalized && wkbFlatten(normalized->getGeometryType()) == wkbPolygon){
            geomPtr.reset(normalized.release()->toPolygon());
        }
    }
 
    bool envelopeOverlaps(const IPoint auto & lhs, const IPoint auto & rhs) const noexcept {
        OGREnvelope envelope;
        geomPtr->getEnvelope(&envelope);
        // NOTE: not std::minmax, which returns references to its arguments and would dangle here
        const double lhsX = lhs.getX(), rhsX = rhs.getX();
        const double lhsY = lhs.getY(), rhsY = rhs.getY();
        const double minX = std::min(lhsX, rhsX), maxX = std::max(lhsX, rhsX);
        const double minY = std::min(lhsY, rhsY), maxY = std::max(lhsY, rhsY);
        return maxX >= envelope.MinX && minX <= envelope.MaxX
            && maxY >= envelope.MinY && minY <= envelope.MaxY;
    }
 
    const OGRLinearRing * exteriorRing() const noexcept {
        return geomPtr->getExteriorRing();
    }
 
    struct Canonical{};
 
    OGRPolygonalAdapter(OGRUniquePtr<OGRPolygon> && polygonPtr, Canonical):Base(std::move(polygonPtr)) {}
 
    OGRPolygonalAdapter(OGRUniquePtr<OGRPolygon> && polygonPtr):Base(std::move(polygonPtr)) {
        geomPtr->closeRings();
        canonicalize();
    }
 
public:
 
    double area() const {
        return geomPtr->get_Area();
    }
 
    Rectangle<double> aaBB() const {
        OGREnvelope boundingBox;
        geomPtr->getEnvelope(&boundingBox);
        return Rectangle<double>(boundingBox.MinX, boundingBox.MaxY, boundingBox.MaxX, boundingBox.MinY);
    }
 
    bool isInside(const IPoint auto & point) const {
        OGRPoint ogrPoint(point.getX(), point.getY());
        return geomPtr->Contains(&ogrPoint);
    }
 
    bool isOnBoundary(const IPoint auto & point) const {
        OGRPoint ogrPoint(point.getX(), point.getY());
        return geomPtr->Touches(&ogrPoint);
    }
 
    bool isOutside(const IPoint auto & point) const {
        OGRPoint ogrPoint(point.getX(), point.getY());
        return geomPtr->Disjoint(&ogrPoint);
    }
 
    bool contains(const IPoint auto & point) const {
        OGRPoint ogrPoint(point.getX(), point.getY());
        return not geomPtr->Disjoint(&ogrPoint);
    }
 
    bool contains(const ISegment auto & segment) const {
        if(not segment.isValid())
            return contains(segment.p()); // a degenerate segment is contained if its point is
        if(not envelopeOverlaps(segment.p(), segment.q()))
            return false;
        OGRLineString ogrLine;
        ogrLine.addPoint(segment.p().getX(), segment.p().getY());
        ogrLine.addPoint(segment.q().getX(), segment.q().getY());
        return covers(*geomPtr, ogrLine);
    }
 
    bool contains(const IRing auto & ring) const {
        return geomPtr->Contains(toOGRPolygon(ring).get());
    }
 
    bool contains(const IPolygon auto & polygon) const {
        return geomPtr->Contains(toOGRPolygon(polygon).get());
    }
 
    bool contains(const OGRPolygonalAdapter & other) const {
        return geomPtr->Contains(other.geomPtr.get());
    }
};
}