MorphologicalTreeSemantics.hpp

Go to the documentation of this file.

#pragma once
 
#include "../utils/Common.hpp"
#include "../utils/RegularGridAdjacency2D.hpp"
 
#include <utility>
#include <stdexcept>
#include <variant>
 
namespace mmcfilters {
 
enum class MorphologicalTreeKind {
    Generic,
    MaxTree,
    MinTree,
    TreeOfShapes,
    UnrestrictedResidualTree,
    SaturatedResidualTree
};
 
enum class NodeAltitudeOrder {
    Increasing,
    Decreasing,
    Unconstrained
};
 
struct NoConstructionContext {};
 
struct SharedAdjacencyContext {
    RegularGridAdjacency2D adjacency; 
};
 
struct SaturatedResidualContext {
    RegularGridAdjacency2D adjacency; 
    PixelId infinityPixel = 0;        
};
 
struct ComplementaryAdjacencies {
    RegularGridAdjacency2D minAdjacency; 
    RegularGridAdjacency2D maxAdjacency; 
};
 
struct SelfDualSpanImmersion {};
 
enum class ComplementaryPairing { Min4Max8, Min8Max4 };
 
struct CanonicalComplementaryGridImmersion {
    ComplementaryPairing pairing = ComplementaryPairing::Min4Max8; 
};
 
struct ComplementaryGridImmersion {
    ComplementaryAdjacencies complementaryAdjacencies; 
};
 
using TreeOfShapesImmersion = std::variant<CanonicalComplementaryGridImmersion, ComplementaryGridImmersion, SelfDualSpanImmersion>;
 
enum class TopographicDomainExtension { ExteriorRing, None };
 
enum class TopographicAltitudeEncoding { UInt8, ExactDoubled };
 
struct TopographicConvention {
    TreeOfShapesImmersion immersion = CanonicalComplementaryGridImmersion{}; 
    TopographicDomainExtension domainExtension = TopographicDomainExtension::None; 
    PixelId infinityPixel = 0; 
    TopographicAltitudeEncoding altitudeEncoding = TopographicAltitudeEncoding::UInt8; 
};
 
inline TopographicConvention selfDualSpanConvention(TopographicDomainExtension domainExtension = TopographicDomainExtension::ExteriorRing,
                                                    PixelId infinityPixel = 0,
                                                    TopographicAltitudeEncoding altitudeEncoding = TopographicAltitudeEncoding::ExactDoubled) {
    return TopographicConvention{SelfDualSpanImmersion{}, domainExtension, infinityPixel, altitudeEncoding};
}
 
using MorphologicalTreeConstructionContext =
    std::variant<NoConstructionContext, SharedAdjacencyContext, SaturatedResidualContext, TopographicConvention>;
 
struct MorphologicalTreeSemantics {
    MorphologicalTreeKind kind = MorphologicalTreeKind::Generic; 
    NodeAltitudeOrder nodeAltitudeOrder = NodeAltitudeOrder::Unconstrained; 
    MorphologicalTreeConstructionContext constructionContext = NoConstructionContext{}; 
};
 
inline NodeAltitudeOrder defaultNodeAltitudeOrder(MorphologicalTreeKind kind) noexcept {
    switch (kind) {
    case MorphologicalTreeKind::MaxTree:
        return NodeAltitudeOrder::Increasing;
    case MorphologicalTreeKind::MinTree:
        return NodeAltitudeOrder::Decreasing;
    case MorphologicalTreeKind::Generic:
    case MorphologicalTreeKind::TreeOfShapes:
    case MorphologicalTreeKind::UnrestrictedResidualTree:
    case MorphologicalTreeKind::SaturatedResidualTree:
        return NodeAltitudeOrder::Unconstrained;
    }
    return NodeAltitudeOrder::Unconstrained;
}
 
inline MorphologicalTreeSemantics makeMorphologicalTreeSemantics(
    MorphologicalTreeKind kind,
    MorphologicalTreeConstructionContext constructionContext = NoConstructionContext{}) {
    return MorphologicalTreeSemantics{kind, defaultNodeAltitudeOrder(kind), std::move(constructionContext)};
}
 
inline void validateMorphologicalTreeSemantics(const MorphologicalTreeSemantics& semantics) {
    if (semantics.kind != MorphologicalTreeKind::Generic && semantics.nodeAltitudeOrder != defaultNodeAltitudeOrder(semantics.kind)) {
        throw std::invalid_argument("Morphological-tree kind and node-altitude order are incompatible.");
    }
    if (std::holds_alternative<NoConstructionContext>(semantics.constructionContext)) {
        return;
    }
    if (std::holds_alternative<SharedAdjacencyContext>(semantics.constructionContext)) {
        if (semantics.kind == MorphologicalTreeKind::Generic || semantics.kind == MorphologicalTreeKind::MaxTree ||
            semantics.kind == MorphologicalTreeKind::MinTree || semantics.kind == MorphologicalTreeKind::UnrestrictedResidualTree) {
            return;
        }
        throw std::invalid_argument("SharedAdjacencyContext is incompatible with the declared morphological-tree kind.");
    }
    if (std::holds_alternative<SaturatedResidualContext>(semantics.constructionContext)) {
        if (semantics.kind == MorphologicalTreeKind::SaturatedResidualTree) {
            return;
        }
        throw std::invalid_argument("SaturatedResidualContext requires SaturatedResidualTree kind.");
    }
    if (std::holds_alternative<TopographicConvention>(semantics.constructionContext)) {
        if (semantics.kind == MorphologicalTreeKind::TreeOfShapes) {
            return;
        }
        throw std::invalid_argument("TopographicConvention requires TreeOfShapes kind.");
    }
    throw std::invalid_argument("Unsupported morphological-tree construction context.");
}
 
} // namespace mmcfilters