AreaComputer.hpp

#pragma once
 
#include "AttributeComputerDomain.hpp"
#include "AttributeComputerFamily.hpp"
#include "../detail/AttributeKernelSupport.hpp"
#include "../../trees/detail/TreeKernelAccess.hpp"
#include "../../utils/Contract.hpp"
#include "../../trees/MorphologicalTree.hpp"
 
#include <array>
#include <concepts>
#include <stdexcept>
#include <string_view>
 
namespace mmcfilters::attributes::computers {
 
namespace detail {
 
template <std::floating_point Real> inline void validateAreaContext(const AttributeComputeContext<Real>& context) {
    requireAttributeBufferShape(context.tree, context.buffer, context.attrNames);
    if (!context.attrNames.contains(Area)) {
        throw std::invalid_argument("AREA computation requires an AREA column in the output layout.");
    }
}
 
namespace kernel {
 
template <std::floating_point Real> inline void computeArea(const AttributeComputeContext<Real>& context) {
    const int stride = context.attrNames.NUM_ATTRIBUTES;
    const int offset = context.attrNames.indexMap.find(Area)->second;
    auto indexOfArea = [&](NodeId node) { return static_cast<std::size_t>(node * stride + offset); };
    ::mmcfilters::detail::TreeKernelAccess::traversePostOrder(
        context.tree, context.tree.root(),
        [&](NodeId node) {
            context.buffer[indexOfArea(node)] = static_cast<Real>(::mmcfilters::detail::TreeKernelAccess::properPartCardinality(context.tree, node));
        },
        [&](NodeId parent, NodeId child) { context.buffer[indexOfArea(parent)] += context.buffer[indexOfArea(child)]; }, [](NodeId) {});
}
 
} // namespace kernel
} // namespace detail
 
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) {
        MMCFILTERS_CONTRACT_CHECKED_ONLY(detail::validateAreaContext(context));
        detail::kernel::computeArea(context);
    }
 
  public:
    template <std::floating_point Real> static void computeUnitRows(const UnitAttributeComputeContext<Real>& context) {
        requireUnitAttributeBufferShape(context.tree, context.unitPixels, context.buffer, context.attrNames);
        computeUnitRowsEstablished(context);
    }
 
  private:
    template <class Computer, class Context> friend void mmcfilters::detail::kernel::computeUnitRows(const Context& context);
 
    template <std::floating_point Real> static void computeUnitRowsEstablished(const UnitAttributeComputeContext<Real>& context) {
        if (!requestsAttribute(context.requestedAttributes, Area)) {
            return;
        }
        for (NodeId leafIndex = 0; leafIndex < static_cast<NodeId>(context.unitPixels.size()); ++leafIndex) {
            context.buffer[context.attrNames.linearIndex(leafIndex, Area)] = Real{1};
        }
    }
};
 
} // namespace mmcfilters::attributes::computers