OGRAdapterBase.hpp

Go to the documentation of this file.

#pragma once
#include <gdal/ogr_geometry.h>
#include <memory>
#include <cassert>
#include <fishnet/GeometryBase.hpp>
 
namespace fishnet::geometry::__impl{
 
enum class OGROwnership {
    geometry,   
    shellOnly,  
    none        
};
 
struct OGRGeometryDeleter {
    OGROwnership ownership = OGROwnership::geometry;
 
    void operator()(OGRGeometry* geom) const {
        if(not geom || ownership == OGROwnership::none)
            return;
        if(ownership == OGROwnership::shellOnly){
            // hand the borrowed rings back before the shell around them is destroyed, otherwise
            // the shell would take the rings of their actual owner with it
            auto * shell = geom->toPolygon();
            for(int i = shell->getNumInteriorRings(); i >= 0; --i)
                shell->removeRing(i, false);
        }
        OGRGeometryFactory::destroyGeometry(geom);
    }
};
} // namespace fishnet::geometry::__impl
 
namespace fishnet::geometry{
 
template<typename T>
using OGRUniquePtr = std::unique_ptr<T, __impl::OGRGeometryDeleter>;
 
namespace __impl{
 
template<typename T>
static OGRUniquePtr<T> borrow(T * geometry) noexcept {
    return OGRUniquePtr<T>(geometry, OGRGeometryDeleter{OGROwnership::none});
}
 
static OGRUniquePtr<OGRPolygon> borrowRingAsPolygon(OGRLinearRing * ring) noexcept {
    auto * shell = static_cast<OGRPolygon*>(OGRGeometryFactory::createGeometry(wkbPolygon));
    shell->addRingDirectly(ring);
    return OGRUniquePtr<OGRPolygon>(shell, OGRGeometryDeleter{OGROwnership::shellOnly});
}
} // namespace __impl
 
template<typename T> requires std::is_base_of_v<OGRGeometry, T>
class OGRAdapterBase{
protected:
    OGRUniquePtr<T> geomPtr;
public:
    using numeric_type = double;
 
    OGRAdapterBase(OGRUniquePtr<T> && geomPtr):geomPtr(std::move(geomPtr)){
        assert(this->geomPtr != nullptr);
    }
 
    OGRAdapterBase(OGRAdapterBase && other) noexcept : geomPtr(std::move(other.geomPtr)) {}
 
    OGRAdapterBase(const OGRAdapterBase & other): geomPtr(OGRUniquePtr<T>(static_cast<T*>(other.geomPtr->clone()))) {}
 
    OGRAdapterBase& operator=(const OGRAdapterBase & other){
        if(this != &other){
            geomPtr = OGRUniquePtr<T>(static_cast<T*>(other.geomPtr->clone()));
        }
        return *this;
    }
    OGRAdapterBase& operator=(OGRAdapterBase && other) noexcept {
        if(this != &other){
            geomPtr = std::move(other.geomPtr);
        }
        return *this;
    }
 
    bool operator==(const OGRAdapterBase & other) const noexcept{
        if(this->geomPtr == other.geomPtr) return true; // same pointer, same object
        return geomPtr->Equals(other.geomPtr.get());
    }
 
    T * raw() const noexcept{
        return geomPtr.get();
    }
 
    size_t hash() const noexcept {
        size_t nSize = geomPtr->WkbSize();
        std::vector<unsigned char> pabyData(nSize);
        geomPtr->exportToWkb(pabyData.data());
        std::string_view bytes(reinterpret_cast<const char*>(pabyData.data()), nSize);
        return std::hash<std::string_view>{}(bytes);
    }
 
    std::string toString() const{
        return geomPtr->exportToWkt();
    }
};
class GeometryTypeWKBAdapter{
public:
    static OGRwkbGeometryType toWKB(GeometryType type){
        switch (type)
        {
            case geometry::GeometryType::POINT: return wkbPoint;
            case geometry::GeometryType::POLYGON: return wkbPolygon;
            case geometry::GeometryType::RING: return wkbLinearRing;
            case geometry::GeometryType::MULTIPOLYGON: return wkbMultiPolygon;
        default:
            throw std::invalid_argument("Geometry type: "+std::to_string(type)+" could not be converted into wkb format");
        }
    }
    static geometry::GeometryType fromWKB(OGRwkbGeometryType type){
        switch(type){
            case wkbPoint: return geometry::GeometryType::POINT;
            // OGR has no WKB type of its own for a linear ring and reports it as a line string
            case wkbLinearRing:
            case wkbLineString: return geometry::GeometryType::RING;
            case wkbPolygon: return geometry::GeometryType::POLYGON;
            case wkbMultiPolygon: return geometry::GeometryType::MULTIPOLYGON;
            default: throw std::invalid_argument("wkbGeometryType could not be converted into a Fishnet geometry type");
        }
    }
};
} // namespace fishnet::geometry