OGRGeometryAdapter.hpp

Go to the documentation of this file.

#pragma once
#include <fishnet/Option.hpp>
#include <fishnet/Vec2D.hpp>
#include "OGRAdapterBase.hpp"
#include "OGRRingAdapter.hpp"
#include "OGRPolygonAdapter.hpp"
#include "OGRMultiPolygonAdapter.hpp"
 
namespace fishnet::geometry{
 
class OGRGeometryAdapter;
 
template<typename G>
concept OGRLayerGeometry =
       std::same_as<G, Vec2DReal>
    || std::same_as<G, OGRRingAdapter>
    || std::same_as<G, OGRPolygonAdapter>
    || std::same_as<G, OGRMultiPolygonAdapter>
    || std::same_as<G, OGRGeometryAdapter>;
 
template<typename G>
concept OGRWritableGeometry = IPoint<G> || Shape<G> || DynamicGeometry<G>;
 
namespace __impl{
    // overload set used only in an unevaluated context (@see NarrowTarget below) to compute which
    // concrete adapter narrowTo() should produce for a given G: itself for one of the adapters (or
    // Vec2DReal), otherwise whichever adapter models the same kind of shape as G
    template<OGRLayerGeometry G>
    G narrowTargetOf();
 
    template<typename G> requires (not OGRLayerGeometry<G>) && IRing<G>
    OGRRingAdapter narrowTargetOf();
 
    template<typename G> requires (not OGRLayerGeometry<G>) && IPolygon<G>
    OGRPolygonAdapter narrowTargetOf();
 
    template<typename G> requires (not OGRLayerGeometry<G>) && IMultiPolygon<G>
    OGRMultiPolygonAdapter narrowTargetOf();
}
 
template<typename G>
using NarrowTarget = decltype(__impl::narrowTargetOf<G>());
 
class OGRGeometryAdapter: public OGRAdapterBase<OGRGeometry>{
private:
    using Base = OGRAdapterBase<OGRGeometry>;
public:
    using numeric_type = double;
 
    OGRGeometryAdapter(OGRUniquePtr<OGRGeometry> && geometryPtr):Base(std::move(geometryPtr)) {}
 
    OGRGeometryAdapter(const OGRRingAdapter & ring):Base(OGRUniquePtr<OGRGeometry>(ring.raw()->getExteriorRing()->clone())) {}
 
    OGRGeometryAdapter(const OGRPolygonAdapter & polygon):Base(OGRUniquePtr<OGRGeometry>(polygon.raw()->clone())) {}
 
    OGRGeometryAdapter(const OGRMultiPolygonAdapter & multiPolygon):Base(OGRUniquePtr<OGRGeometry>(multiPolygon.raw()->clone())) {}
 
    OGRGeometryAdapter(OGRRingAdapter && ring):Base(std::move(ring).releaseGeometry()) {}
 
    OGRGeometryAdapter(OGRPolygonAdapter && polygon):Base(std::move(polygon).releaseGeometry()) {}
 
    OGRGeometryAdapter(OGRMultiPolygonAdapter && multiPolygon):Base(std::move(multiPolygon).releaseGeometry()) {}
 
    OGRGeometryAdapter(const IRing auto & ring):OGRGeometryAdapter(OGRRingAdapter(ring)) {}
 
    OGRGeometryAdapter(const IPolygon auto & polygon):OGRGeometryAdapter(OGRPolygonAdapter(polygon)) {}
 
    OGRGeometryAdapter(const IMultiPolygon auto & multiPolygon):OGRGeometryAdapter(OGRMultiPolygonAdapter(multiPolygon)) {}
 
    GeometryType geometryType() const noexcept {
        return GeometryTypeWKBAdapter::fromWKB(wkbFlatten(geomPtr->getGeometryType()));
    }
 
    bool isEmpty() const noexcept {
        return geomPtr->IsEmpty();
    }
 
    bool isRing() const noexcept {
        auto wkbType = wkbFlatten(geomPtr->getGeometryType());
        return (wkbType == wkbLineString || wkbType == wkbLinearRing)
            && not isEmpty() && geomPtr->toLineString()->getNumPoints() >= 3;
    }
 
    bool isPolygon() const noexcept {
        return wkbFlatten(geomPtr->getGeometryType()) == wkbPolygon && not isEmpty();
    }
 
    bool isMultiPolygon() const noexcept {
        return wkbFlatten(geomPtr->getGeometryType()) == wkbMultiPolygon && not isEmpty();
    }
 
    bool isPoint() const noexcept {
        return wkbFlatten(geomPtr->getGeometryType()) == wkbPoint && not isEmpty();
    }
 
    Option<Vec2DReal> toPoint() const {
        if(not isPoint())
            return {};
        const auto * point = geomPtr->toPoint();
        return Vec2DReal(point->getX(), point->getY());
    }
 
    Option<OGRRingAdapter> toRing() const {
        if(not isRing())
            return {};
        const auto * lineString = geomPtr->toLineString();
        auto ring = OGRUniquePtr<OGRLinearRing>(static_cast<OGRLinearRing*>(OGRGeometryFactory::createGeometry(wkbLinearRing)));
        for(int i = 0; i < lineString->getNumPoints(); ++i){
            ring->addPoint(lineString->getX(i), lineString->getY(i));
        }
        return OGRRingAdapter(std::move(ring));
    }
 
    Option<OGRPolygonAdapter> toPolygon() const & {
        if(not isPolygon())
            return {};
        return OGRPolygonAdapter(OGRUniquePtr<OGRPolygon>(geomPtr->toPolygon()->clone()));
    }
 
    Option<OGRPolygonAdapter> toPolygon() && {
        if(not isPolygon())
            return {};
        auto deleter = geomPtr.get_deleter(); // whoever owns the geometry keeps owning it
        auto * released = geomPtr.release();
        return OGRPolygonAdapter(OGRUniquePtr<OGRPolygon>(released->toPolygon(), deleter));
    }
 
    Option<OGRMultiPolygonAdapter> toMultiPolygon() const & {
        if(not isMultiPolygon())
            return {};
        return OGRMultiPolygonAdapter(OGRUniquePtr<OGRMultiPolygon>(geomPtr->toMultiPolygon()->clone()));
    }
 
    Option<OGRMultiPolygonAdapter> toMultiPolygon() && {
        if(not isMultiPolygon())
            return {};
        auto deleter = geomPtr.get_deleter();
        auto * released = geomPtr.release();
        return OGRMultiPolygonAdapter(OGRUniquePtr<OGRMultiPolygon>(released->toMultiPolygon(), deleter));
    }
 
 
    template<typename G> requires OGRLayerGeometry<G> || Shape<G>
    Option<NarrowTarget<G>> narrowTo() const & {
        using Target = NarrowTarget<G>;
        // a point is read out by value and a ring is rebuilt from the points either way, so neither
        // gains anything from copying the whole geometry first
        if constexpr (std::same_as<Target, Vec2DReal>)
            return toPoint();
        else if constexpr (std::same_as<Target, OGRRingAdapter>)
            return toRing();
        else
            return OGRGeometryAdapter(*this).narrowTo<G>();
    }
 
 
    template<typename G> requires OGRLayerGeometry<G> || Shape<G>
    Option<NarrowTarget<G>> narrowTo() && {
        using Target = NarrowTarget<G>;
        if constexpr (std::same_as<Target, OGRGeometryAdapter>){
            return std::move(*this); // a layer which takes anything has nothing to narrow
        } else if constexpr (std::same_as<Target, Vec2DReal>){
            return toPoint();
        } else if constexpr (std::same_as<Target, OGRRingAdapter>){
            return toRing();
        } else if constexpr (std::same_as<Target, OGRPolygonAdapter>){
            if(auto polygon = std::move(*this).toPolygon())
                return polygon;
            auto multiPolygon = std::move(*this).toMultiPolygon();
            if(not multiPolygon || multiPolygon.value().size() != 1)
                return {};
            auto polygons = multiPolygon.value().getPolygons();
            return *std::ranges::begin(polygons);
        } else if constexpr (std::same_as<Target, OGRMultiPolygonAdapter>){
            if(auto multiPolygon = std::move(*this).toMultiPolygon())
                return multiPolygon;
            auto polygon = std::move(*this).toPolygon();
            if(not polygon)
                return {};
            std::vector<OGRPolygonAdapter> parts;
            parts.push_back(std::move(polygon.value()));
            return OGRMultiPolygonAdapter(parts, true);
        } else {
            static_assert(false, "narrowTo has no case for this geometry: a type was added to "
                "OGRLayerGeometry without saying how an OGR geometry is narrowed to it");
        }
    }
};
 
static_assert(OGRWritableGeometry<OGRPolygonAdapter>);
static_assert(OGRWritableGeometry<OGRGeometryAdapter>);
static_assert(OGRLayerGeometry<Vec2DReal>);
static_assert(OGRLayerGeometry<OGRRingAdapter>);
static_assert(OGRLayerGeometry<OGRPolygonAdapter>);
static_assert(OGRLayerGeometry<OGRMultiPolygonAdapter>);
static_assert(OGRLayerGeometry<OGRGeometryAdapter>);
}