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 {};
 
struct ComplementaryGridImmersion {
    ComplementaryAdjacencies complementaryAdjacencies; 
};
 
using TreeOfShapesImmersion = std::variant<SelfDualSpanImmersion, ComplementaryGridImmersion>;
 
enum class TopographicDomainExtension { ExteriorRing, None };
 
struct TopographicConvention {
    TreeOfShapesImmersion immersion = SelfDualSpanImmersion{}; 
    TopographicDomainExtension domainExtension = TopographicDomainExtension::ExteriorRing; 
    PixelId infinityPixel = 0; 
};
 
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