AreaComputer.hpp

#pragma once
 
#include "AttributeComputerDomain.hpp"
#include "AttributeComputerFamily.hpp"
#include "../detail/AttributeKernelSupport.hpp"
#include "../../trees/detail/TreeTraversalDetail.hpp"
#include "../../trees/MorphologicalTree.hpp"
 
#include <array>
#include <concepts>
#include <string_view>
 
namespace mmcfilters::attributes::computers {
 
class AreaComputer {
public:
    static constexpr std::string_view familyName = "area";
 
    static constexpr AttributeComputerFamily family = AttributeComputerFamily::Area;
 
    static constexpr AttributeComputerDomain domain = AttributeComputerDomain::Topology;
 
    inline static constexpr std::array<Attribute, 1> producedAttributes{AREA};
 
    template <std::floating_point Real>
    static void compute(const AttributeComputeContext<Real>& context) {
        computeImpl(context.tree, context.buffer, context.attrNames);
    }
 
private:
    template <std::floating_point Real>
    static void computeImpl(const MorphologicalTree& tree, std::span<Real> buffer, const AttributeNames& attrNames) {
        auto indexOfArea = [&](NodeId nodeId) { return attrNames.linearIndex(nodeId, AREA); };
        ::mmcfilters::detail::traversePostOrder(
            tree,
            tree.getRoot(),
            [&](NodeId nodeId) {
                buffer[indexOfArea(nodeId)] = static_cast<Real>(tree.getNumProperParts(nodeId));
            },
            [&](NodeId parentNodeId, NodeId childNodeId) {
                buffer[indexOfArea(parentNodeId)] += buffer[indexOfArea(childNodeId)];
            },
            [](NodeId) {});
    }
 
public:
    template <std::floating_point Real>
    static void computeUnitRows(const UnitAttributeComputeContext<Real>& context) {
        requireUnitAttributeBufferShape(context.tree, context.unitProperParts, context.buffer, context.attrNames);
        if (!requestsAttribute(context.requestedAttributes, AREA)) {
            return;
        }
        for (NodeId leafIndex = 0; leafIndex < static_cast<NodeId>(context.unitProperParts.size()); ++leafIndex) {
            context.buffer[context.attrNames.linearIndex(leafIndex, AREA)] = Real{1};
        }
    }
 
};
 
} // namespace mmcfilters::attributes::computers