AttributeReconstructionFilters.hpp

#pragma once
 
#include "NodeDecisionMasks.hpp"
#include "../trees/TreeAltitudeAlgorithms.hpp"
#include "../trees/ValuedMorphologicalTree.hpp"
#include "../trees/ValuedMorphologicalTreeView.hpp"
#include "../trees/detail/TreeKernelAccess.hpp"
#include "../utils/CommittedImageAccess.hpp"
#include "../utils/Contract.hpp"
 
#include <algorithm>
#include <cmath>
#include <concepts>
#include <span>
#include <stack>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
 
namespace mmcfilters {
 
struct DirectReconstruction {};
 
struct SubtractiveResidueModulation {};
 
namespace detail::attribute_filtering {
 
inline void requireNodePreservationMaskShape(const MorphologicalTree& tree, const NodePreservationMask& nodePreservationMask, const char* context) {
    MMCFILTERS_CONTRACT_REQUIRE(
        nodePreservationMask.size() == static_cast<std::size_t>(tree.numInternalNodeSlots()),
        throw std::invalid_argument(std::string(context) + " nodePreservationMask size must match the internal node slot count."));
}
 
template <std::floating_point Real>
inline void requireNodePreservationScores(const MorphologicalTree& tree, std::span<const Real> nodePreservationScores, const char* context) {
    MMCFILTERS_CONTRACT_REQUIRE(
        nodePreservationScores.size() == static_cast<std::size_t>(tree.numInternalNodeSlots()),
        throw std::invalid_argument(std::string(context) + " nodePreservationScores size must match the internal node slot count."));
    if constexpr (contract::validationsEnabled) {
        for (std::size_t index = 0; index < nodePreservationScores.size(); ++index) {
            const Real score = nodePreservationScores[index];
            if (!std::isfinite(score) || score < Real{0} || score > Real{1}) {
                throw std::invalid_argument(std::string(context) + " requires every nodePreservationScore to be finite and in [0, 1].");
            }
        }
    }
}
 
template <AltitudeValue T>
[[nodiscard]] inline ImagePtr<T> applyDirectReconstruction(ValuedMorphologicalTreeView<T> valuedTree,
                                                         const NodePreservationMask& nodePreservationMask) {
    const char* context = "DirectAttributeFilter::applyDirectAttributeFilter";
    valuedTree.requireTopologyUnchanged(context);
    const MorphologicalTree& tree = valuedTree.topology();
    tree.requireNotEditing(context);
    requireNodePreservationMaskShape(tree, nodePreservationMask, context);
    MMCFILTERS_CONTRACT_REQUIRE(nodePreservationMask[static_cast<std::size_t>(tree.root())],
                                throw std::invalid_argument(std::string(context) + " requires the root node to be preserved."));
    const std::span<const T> nodeAltitudes = valuedTree.nodeAltitudes();
    std::vector<T> reconstructedNodeAltitudes(static_cast<std::size_t>(tree.numInternalNodeSlots()), T{});
    const NodeId root = tree.root();
    reconstructedNodeAltitudes[static_cast<std::size_t>(root)] = nodeAltitudes[static_cast<std::size_t>(root)];
 
    std::stack<NodeId> pending;
    pending.push(root);
    while (!pending.empty()) {
        const NodeId nodeId = pending.top();
        pending.pop();
        for (NodeId childId : detail::TreeKernelAccess::children(tree, nodeId)) {
            reconstructedNodeAltitudes[static_cast<std::size_t>(childId)] =
                nodePreservationMask[static_cast<std::size_t>(childId)] ? nodeAltitudes[static_cast<std::size_t>(childId)]
                                                                       : reconstructedNodeAltitudes[static_cast<std::size_t>(nodeId)];
            pending.push(childId);
        }
    }
 
    ImagePtr<T> output = CommittedImageAccess::create<T>(tree.numRows(), tree.numColumns());
    T* pixels = output->rawData();
    for (NodeId nodeId : tree.aliveNodeIds()) {
        for (PixelId pixel : detail::TreeKernelAccess::properParts(tree, nodeId)) {
            pixels[pixel] = reconstructedNodeAltitudes[static_cast<std::size_t>(nodeId)];
        }
    }
    return output;
}
 
template <AltitudeValue T>
[[nodiscard]] inline AltitudeDifference<T> nodeResidueEstablished(const MorphologicalTree& tree, std::span<const T> nodeAltitudes, NodeId nodeId) {
    const auto altitude = static_cast<AltitudeDifference<T>>(nodeAltitudes[static_cast<std::size_t>(nodeId)]);
    if (nodeId == tree.root()) {
        return altitude;
    }
    const NodeId parent = TreeKernelAccess::nodeParent(tree, nodeId);
    return altitude - static_cast<AltitudeDifference<T>>(nodeAltitudes[static_cast<std::size_t>(parent)]);
}
 
template <class Contribution>
[[nodiscard]] inline ImagePtr<Contribution> reconstructNodeContributionsEstablished(const MorphologicalTree& tree,
                                                                                    std::span<const Contribution> nodeContributions) {
    const auto pixelValues = tree_altitude::reconstructNodeContributionValuesEstablished(tree, nodeContributions);
    ImagePtr<Contribution> output = CommittedImageAccess::create<Contribution>(tree.numRows(), tree.numColumns());
    std::copy(pixelValues.begin(), pixelValues.end(), output->rawData());
    return output;
}
 
template <AltitudeValue T>
[[nodiscard]] inline std::vector<AltitudeDifference<T>> computeGatedNodeContributions(
    ValuedMorphologicalTreeView<T> valuedTree, const NodePreservationMask& nodePreservationMask) {
    const char* context = "SubtractiveAttributeFilter::applySubtractiveAttributeFilter";
    const MorphologicalTree& tree = valuedTree.topology();
    tree.requireNotEditing(context);
    requireNodePreservationMaskShape(tree, nodePreservationMask, context);
    const auto nodeAltitudes = valuedTree.nodeAltitudes();
    std::vector<AltitudeDifference<T>> nodeContributions(static_cast<std::size_t>(tree.numInternalNodeSlots()), AltitudeDifference<T>{});
    for (NodeId nodeId : tree.aliveNodeIds()) {
        if (nodePreservationMask[static_cast<std::size_t>(nodeId)]) {
            const auto contribution = nodeResidueEstablished(tree, nodeAltitudes, nodeId);
            tree_altitude::requireFiniteNodeContribution(contribution, context);
            nodeContributions[static_cast<std::size_t>(nodeId)] = contribution;
        }
    }
    return nodeContributions;
}
 
template <AltitudeValue T, std::floating_point Real>
[[nodiscard]] inline std::vector<Real> computeSoftNodeContributions(ValuedMorphologicalTreeView<T> valuedTree,
                                                                    std::span<const Real> nodePreservationScores) {
    const char* context = "SoftSubtractiveAttributeFilter::applySoftSubtractiveAttributeFilter";
    const MorphologicalTree& tree = valuedTree.topology();
    tree.requireNotEditing(context);
    requireNodePreservationScores(tree, nodePreservationScores, context);
    const auto nodeAltitudes = valuedTree.nodeAltitudes();
    std::vector<Real> nodeContributions(static_cast<std::size_t>(tree.numInternalNodeSlots()), Real{});
    for (NodeId nodeId : tree.aliveNodeIds()) {
        const Real contribution =
            static_cast<Real>(nodeResidueEstablished(tree, nodeAltitudes, nodeId)) * nodePreservationScores[static_cast<std::size_t>(nodeId)];
        tree_altitude::requireFiniteNodeContribution(contribution, context);
        nodeContributions[static_cast<std::size_t>(nodeId)] = contribution;
    }
    return nodeContributions;
}
 
} // namespace detail::attribute_filtering
 
template <AltitudeValue T> class DirectAttributeFilter {
  private:
    ValuedMorphologicalTreeView<T> valuedTree_; 
 
  public:
    using ReconstructionPolicy = DirectReconstruction;
 
    explicit DirectAttributeFilter(ValuedMorphologicalTreeView<T> valuedTree) : valuedTree_(valuedTree) {}
 
    explicit DirectAttributeFilter(const ValuedMorphologicalTree<T>& valuedTree) : valuedTree_(valuedTree.asView()) {}
 
    [[nodiscard]] ImagePtr<T> applyDirectAttributeFilter(const NodePreservationMask& nodePreservationMask) const {
        return detail::attribute_filtering::applyDirectReconstruction(valuedTree_, nodePreservationMask);
    }
};
 
template <AltitudeValue T> class SubtractiveAttributeFilter {
  private:
    ValuedMorphologicalTreeView<T> valuedTree_; 
 
  public:
    using ReconstructionPolicy = SubtractiveResidueModulation;
 
    using OutputValue = AltitudeDifference<T>;
 
    explicit SubtractiveAttributeFilter(ValuedMorphologicalTreeView<T> valuedTree) : valuedTree_(valuedTree) {}
 
    explicit SubtractiveAttributeFilter(const ValuedMorphologicalTree<T>& valuedTree) : valuedTree_(valuedTree.asView()) {}
 
    [[nodiscard]] ImagePtr<OutputValue> applySubtractiveAttributeFilter(const NodePreservationMask& nodePreservationMask) const {
        valuedTree_.requireTopologyUnchanged("SubtractiveAttributeFilter::applySubtractiveAttributeFilter");
        const std::vector<OutputValue> nodeContributions = detail::attribute_filtering::computeGatedNodeContributions(valuedTree_, nodePreservationMask);
        return detail::attribute_filtering::reconstructNodeContributionsEstablished(
            valuedTree_.topology(), std::span<const OutputValue>(nodeContributions));
    }
};
 
template <AltitudeValue T, std::floating_point Real = float> class SoftSubtractiveAttributeFilter {
  private:
    ValuedMorphologicalTreeView<T> valuedTree_; 
 
  public:
    using ReconstructionPolicy = SubtractiveResidueModulation;
 
    explicit SoftSubtractiveAttributeFilter(ValuedMorphologicalTreeView<T> valuedTree) : valuedTree_(valuedTree) {}
 
    explicit SoftSubtractiveAttributeFilter(const ValuedMorphologicalTree<T>& valuedTree) : valuedTree_(valuedTree.asView()) {}
 
    [[nodiscard]] ImagePtr<Real> applySoftSubtractiveAttributeFilter(std::span<const Real> nodePreservationScores) const {
        valuedTree_.requireTopologyUnchanged("SoftSubtractiveAttributeFilter::applySoftSubtractiveAttributeFilter");
        const std::vector<Real> nodeContributions = detail::attribute_filtering::computeSoftNodeContributions(valuedTree_, nodePreservationScores);
        return detail::attribute_filtering::reconstructNodeContributionsEstablished(
            valuedTree_.topology(), std::span<const Real>(nodeContributions));
    }
};
 
template <AltitudeValue T>
[[nodiscard]] inline ImagePtr<T> applyDirectAttributeFilter(ValuedMorphologicalTreeView<T> valuedTree,
                                                            const NodePreservationMask& nodePreservationMask) {
    return DirectAttributeFilter<T>(valuedTree).applyDirectAttributeFilter(nodePreservationMask);
}
 
template <AltitudeValue T>
[[nodiscard]] inline ImagePtr<T> applyDirectAttributeFilter(const ValuedMorphologicalTree<T>& valuedTree,
                                                            const NodePreservationMask& nodePreservationMask) {
    return DirectAttributeFilter<T>(valuedTree).applyDirectAttributeFilter(nodePreservationMask);
}
 
template <AltitudeValue T>
[[nodiscard]] inline ImagePtr<AltitudeDifference<T>> applySubtractiveAttributeFilter(
    ValuedMorphologicalTreeView<T> valuedTree, const NodePreservationMask& nodePreservationMask) {
    return SubtractiveAttributeFilter<T>(valuedTree).applySubtractiveAttributeFilter(nodePreservationMask);
}
 
template <AltitudeValue T>
[[nodiscard]] inline ImagePtr<AltitudeDifference<T>> applySubtractiveAttributeFilter(
    const ValuedMorphologicalTree<T>& valuedTree, const NodePreservationMask& nodePreservationMask) {
    return SubtractiveAttributeFilter<T>(valuedTree).applySubtractiveAttributeFilter(nodePreservationMask);
}
 
template <AltitudeValue T, std::floating_point Real>
[[nodiscard]] inline ImagePtr<Real> applySoftSubtractiveAttributeFilter(ValuedMorphologicalTreeView<T> valuedTree,
                                                                        std::span<const Real> nodePreservationScores) {
    return SoftSubtractiveAttributeFilter<T, Real>(valuedTree).applySoftSubtractiveAttributeFilter(nodePreservationScores);
}
 
template <AltitudeValue T, std::floating_point Real>
[[nodiscard]] inline ImagePtr<Real> applySoftSubtractiveAttributeFilter(const ValuedMorphologicalTree<T>& valuedTree,
                                                                        std::span<const Real> nodePreservationScores) {
    return SoftSubtractiveAttributeFilter<T, Real>(valuedTree).applySoftSubtractiveAttributeFilter(nodePreservationScores);
}
 
} // namespace mmcfilters