AttributeComputation.hpp

#pragma once
 
#include "../utils/Image.hpp"
#include "../attributes/AttributeResultTypes.hpp"
#include "../trees/MorphologicalTree.hpp"
#include "../trees/WeightedMorphologicalTree.hpp"
#include "../trees/WeightedTreeView.hpp"
 
#include <concepts>
#include <span>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
namespace mmcfilters {
 
class AttributeComputation {
public:
 
    template <std::floating_point Real = float>
    [[nodiscard]] static ComputedAttributeData<Real> computeSingleTopologyAttribute(const MorphologicalTree& tree, AttributeOrGroup attr, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template <std::floating_point Real = float>
    [[nodiscard]] static ComputedAttributeData<Real> computeTopologyAttributes(const MorphologicalTree& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeSingleTopologyAttribute(const WeightedMorphologicalTree<T>& tree, AttributeOrGroup attr, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeSingleTopologyAttribute(const WeightedTreeView<T>& tree, AttributeOrGroup attr, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeTopologyAttributes(const WeightedMorphologicalTree<T>& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeTopologyAttributes(const WeightedTreeView<T>& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeSingleAttribute(const WeightedMorphologicalTree<T>& tree, AttributeOrGroup attr, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeSingleAttribute(const WeightedTreeView<T>& tree, AttributeOrGroup attr, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeDataWithDelta<Real> computeSingleAttributeWithDelta(const WeightedMorphologicalTree<T>& tree, Attribute attribute, AltitudeDiff<T> deltaStep, int radius, std::string padding="last-padding", NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeDataWithDelta<Real> computeSingleAttributeWithDelta(const WeightedTreeView<T>& tree, Attribute attribute, AltitudeDiff<T> deltaStep, int radius, std::string padding="last-padding", NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeAttributes(const WeightedMorphologicalTree<T>& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeAttributes(const WeightedTreeView<T>& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ComputedAttributeData<Real> computeAttributesFromAltitudeSpan(const WeightedTreeView<T>& weighted, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace = NodeIdSpace::MORPHOLOGICAL_TREE);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static std::vector<Real> projectNodeValuesToExportedHigra(const WeightedMorphologicalTree<T>& tree, const AttributeNames& attrNames, std::span<const Real> nodeValues);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static std::vector<Real> projectNodeValuesToExportedHigra(const WeightedMorphologicalTree<T>& tree, const AttributeNames& attrNames, const std::vector<Real>& nodeValues);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static std::vector<Real> projectNodeValuesToExportedHigra(const WeightedTreeView<T>& tree, const AttributeNames& attrNames, std::span<const Real> nodeValues);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static std::vector<Real> projectNodeValuesToExportedHigra(const WeightedTreeView<T>& tree, const AttributeNames& attrNames, const std::vector<Real>& nodeValues);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ImagePtr<Real> computeAttributeMapping(const WeightedMorphologicalTree<T>& tree, Attribute attribute);
 
    template<std::floating_point Real = float, AltitudeValue T>
    [[nodiscard]] static ImagePtr<Real> computeAttributeMapping(const WeightedTreeView<T>& tree, Attribute attribute);
 
};
 
} // namespace mmcfilters
 
 
 
#include "../attributes/detail/AttributeDeltaMaterialization.hpp"
#include "../attributes/detail/AttributePipeline.hpp"
#include "../attributes/detail/AttributeProjection.hpp"
 
 
 
namespace mmcfilters {
 
namespace detail {
 
template<std::floating_point OutputReal, std::floating_point InternalReal>
[[nodiscard]] inline ComputedAttributeData<OutputReal> castComputedAttributeData(ComputedAttributeData<InternalReal> computed) {
    if constexpr (std::is_same_v<OutputReal, InternalReal>) {
        return computed;
    } else {
        std::vector<OutputReal> output;
        output.reserve(computed.second.size());
        for (const InternalReal value : computed.second) {
            output.push_back(static_cast<OutputReal>(value));
        }
        return ComputedAttributeData<OutputReal>{
            std::move(computed.first),
            std::move(output),
            computed.nodeIdSpace};
    }
}
 
template<std::floating_point OutputReal, std::floating_point InternalReal>
[[nodiscard]] inline ComputedAttributeDataWithDelta<OutputReal> castComputedAttributeDataWithDelta(ComputedAttributeDataWithDelta<InternalReal> computed) {
    if constexpr (std::is_same_v<OutputReal, InternalReal>) {
        return computed;
    } else {
        std::vector<OutputReal> output;
        output.reserve(computed.second.size());
        for (const InternalReal value : computed.second) {
            output.push_back(static_cast<OutputReal>(value));
        }
        return ComputedAttributeDataWithDelta<OutputReal>{
            std::move(computed.first),
            std::move(output),
            computed.nodeIdSpace};
    }
}
 
template<std::floating_point OutputReal, std::floating_point InternalReal>
[[nodiscard]] inline std::vector<OutputReal> castAttributeValues(std::vector<InternalReal> values) {
    if constexpr (std::is_same_v<OutputReal, InternalReal>) {
        return values;
    } else {
        std::vector<OutputReal> output;
        output.reserve(values.size());
        for (const InternalReal value : values) {
            output.push_back(static_cast<OutputReal>(value));
        }
        return output;
    }
}
 
template<std::floating_point OutputReal, std::floating_point InternalReal>
[[nodiscard]] inline ImagePtr<OutputReal> mapNodeAttributeToImageCast(
    const MorphologicalTree& tree,
    const AttributeNames& attrNames,
    std::span<const InternalReal> nodeValues,
    Attribute attribute)
{
    ImagePtr<OutputReal> imgPtr = Image<OutputReal>::create(tree.getNumRowsOfImage(), tree.getNumColsOfImage());
    OutputReal* img = imgPtr->rawData();
    for (int p = 0; p < imgPtr->getSize(); ++p) {
        const NodeId nodeId = tree.getProperPartOwner(p);
        img[p] = static_cast<OutputReal>(nodeValues[attrNames.linearIndex(nodeId, attribute)]);
    }
    return imgPtr;
}
 
} // namespace detail
 
template <std::floating_point Real>
inline ComputedAttributeData<Real> AttributeComputation::computeSingleTopologyAttribute(const MorphologicalTree& tree, AttributeOrGroup attrOrGroup, NodeIdSpace outputSpace) {
    return detail::castComputedAttributeData<Real>(
        detail::materializeAttributesWithoutAltitude<double>(tree, {attrOrGroup}, outputSpace));
}
 
template <std::floating_point Real>
inline ComputedAttributeData<Real> AttributeComputation::computeTopologyAttributes(const MorphologicalTree& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace) {
    return detail::castComputedAttributeData<Real>(
        detail::materializeAttributesWithoutAltitude<double>(tree, attributes, outputSpace));
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeSingleTopologyAttribute(const WeightedMorphologicalTree<T>& tree, AttributeOrGroup attrOrGroup, NodeIdSpace outputSpace) {
    return computeSingleTopologyAttribute<Real>(tree.asView(), attrOrGroup, outputSpace);
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeSingleTopologyAttribute(const WeightedTreeView<T>& tree, AttributeOrGroup attrOrGroup, NodeIdSpace outputSpace) {
    tree.requireTopologyUnchanged("AttributeComputation::computeSingleTopologyAttribute");
    return detail::castComputedAttributeData<Real>(
        detail::materializeTopologyAttributeRequest<double>(
            tree.topology(),
            tree.altitude(),
            {attrOrGroup},
            detail::DependencyMapT<double>{},
            outputSpace));
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeTopologyAttributes(const WeightedMorphologicalTree<T>& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace) {
    return computeTopologyAttributes<Real>(tree.asView(), attributes, outputSpace);
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeTopologyAttributes(const WeightedTreeView<T>& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace) {
    tree.requireTopologyUnchanged("AttributeComputation::computeTopologyAttributes");
    return detail::castComputedAttributeData<Real>(
        detail::materializeTopologyAttributeRequest<double>(
            tree.topology(),
            tree.altitude(),
            attributes,
            detail::DependencyMapT<double>{},
            outputSpace));
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeSingleAttribute(const WeightedMorphologicalTree<T>& tree, AttributeOrGroup attrOrGroup, NodeIdSpace outputSpace) {
    return computeSingleAttribute<Real>(tree.asView(), attrOrGroup, outputSpace);
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeSingleAttribute(const WeightedTreeView<T>& tree, AttributeOrGroup attrOrGroup, NodeIdSpace outputSpace) {
    return computeAttributesFromAltitudeSpan<Real>(tree, {attrOrGroup}, outputSpace);
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeDataWithDelta<Real> AttributeComputation::computeSingleAttributeWithDelta(const WeightedMorphologicalTree<T>& tree, Attribute attribute, AltitudeDiff<T> deltaStep, int radius, std::string padding, NodeIdSpace outputSpace) {
    return computeSingleAttributeWithDelta<Real>(tree.asView(), attribute, deltaStep, radius, std::move(padding), outputSpace);
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeDataWithDelta<Real> AttributeComputation::computeSingleAttributeWithDelta(const WeightedTreeView<T>& tree, Attribute attribute, AltitudeDiff<T> deltaStep, int radius, std::string padding, NodeIdSpace outputSpace) {
    tree.requireTopologyUnchanged("AttributeComputation::computeSingleAttributeWithDelta");
    auto base = computeSingleAttribute<double>(tree, attribute, NodeIdSpace::MORPHOLOGICAL_TREE);
 
    return detail::castComputedAttributeDataWithDelta<Real>(
        detail::materializeSingleAttributeWithTypedDelta<double>(
            tree.topology(),
            tree.altitude(),
            std::move(base),
            attribute,
            deltaStep,
            radius,
            std::move(padding),
            outputSpace));
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeAttributes(const WeightedMorphologicalTree<T>& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace) {
    return computeAttributes<Real>(tree.asView(), attributes, outputSpace);
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeAttributes(const WeightedTreeView<T>& tree, const std::vector<AttributeOrGroup>& attributes, NodeIdSpace outputSpace) {
    tree.requireTopologyUnchanged("AttributeComputation::computeAttributes");
    return computeAttributesFromAltitudeSpan<Real>(tree, attributes, outputSpace);
}
 
template<std::floating_point Real, AltitudeValue T>
inline ComputedAttributeData<Real> AttributeComputation::computeAttributesFromAltitudeSpan(
    const WeightedTreeView<T>& weighted,
    const std::vector<AttributeOrGroup>& attributes,
    NodeIdSpace outputSpace) {
    weighted.requireTopologyUnchanged("AttributeComputation::computeAttributesFromAltitudeSpan");
    return detail::castComputedAttributeData<Real>(
        detail::materializeAttributes<double>(weighted.topology(), weighted.altitude(), attributes, outputSpace));
}
 
template<std::floating_point Real, AltitudeValue T>
inline std::vector<Real> AttributeComputation::projectNodeValuesToExportedHigra(
    const WeightedMorphologicalTree<T>& tree,
    const AttributeNames& attrNames,
    std::span<const Real> nodeValues) {
    return projectNodeValuesToExportedHigra<Real>(tree.asView(), attrNames, nodeValues);
}
 
template<std::floating_point Real, AltitudeValue T>
inline std::vector<Real> AttributeComputation::projectNodeValuesToExportedHigra(
    const WeightedMorphologicalTree<T>& tree,
    const AttributeNames& attrNames,
    const std::vector<Real>& nodeValues) {
    return projectNodeValuesToExportedHigra<Real>(tree, attrNames, std::span<const Real>(nodeValues));
}
 
template<std::floating_point Real, AltitudeValue T>
inline std::vector<Real> AttributeComputation::projectNodeValuesToExportedHigra(
    const WeightedTreeView<T>& tree,
    const AttributeNames& attrNames,
    std::span<const Real> nodeValues) {
    tree.topology().requireNotEditing("AttributeComputation::projectNodeValuesToExportedHigra");
    tree.requireTopologyUnchanged("AttributeComputation::projectNodeValuesToExportedHigra");
    if constexpr (std::is_same_v<Real, double>) {
        return detail::projectNodeValuesToExportedHigraTyped<double>(
            tree.topology(),
            tree.altitude(),
            attrNames,
            nodeValues);
    } else {
        std::vector<double> internalValues;
        internalValues.reserve(nodeValues.size());
        for (const Real value : nodeValues) {
            internalValues.push_back(static_cast<double>(value));
        }
        return detail::castAttributeValues<Real>(
            detail::projectNodeValuesToExportedHigraTyped<double>(
                tree.topology(),
                tree.altitude(),
                attrNames,
                std::span<const double>(internalValues)));
    }
}
 
template<std::floating_point Real, AltitudeValue T>
inline std::vector<Real> AttributeComputation::projectNodeValuesToExportedHigra(
    const WeightedTreeView<T>& tree,
    const AttributeNames& attrNames,
    const std::vector<Real>& nodeValues) {
    return projectNodeValuesToExportedHigra<Real>(tree, attrNames, std::span<const Real>(nodeValues));
}
 
template<std::floating_point Real, AltitudeValue T>
inline ImagePtr<Real> AttributeComputation::computeAttributeMapping(const WeightedMorphologicalTree<T>& tree, Attribute attribute) {
    auto [attrNames, buffer] = AttributeComputation::computeSingleAttribute<double>(tree, attribute, NodeIdSpace::MORPHOLOGICAL_TREE);
    return detail::mapNodeAttributeToImageCast<Real>(tree.topology(), attrNames, std::span<const double>(buffer), attribute);
}
 
template<std::floating_point Real, AltitudeValue T>
inline ImagePtr<Real> AttributeComputation::computeAttributeMapping(const WeightedTreeView<T>& tree, Attribute attribute) {
    tree.requireTopologyUnchanged("AttributeComputation::computeAttributeMapping");
    auto [attrNames, buffer] = AttributeComputation::computeSingleAttribute<double>(tree, attribute, NodeIdSpace::MORPHOLOGICAL_TREE);
    return detail::mapNodeAttributeToImageCast<Real>(tree.topology(), attrNames, std::span<const double>(buffer), attribute);
}
 
} // namespace mmcfilters