ContourSideAttributeComputer.hpp

#pragma once
 
#include "AttributeComputerDomain.hpp"
#include "AttributeComputerFamily.hpp"
#include "../detail/AttributeKernelSupport.hpp"
#include "detail/ContourSideAttributeMaterialization.hpp"
#include "detail/ContourSideFiniteWindowComputation.hpp"
#include "../../utils/Contract.hpp"
 
#include <array>
#include <concepts>
#include <span>
#include <string_view>
 
namespace mmcfilters::attributes::computers {
 
namespace detail {
 
namespace kernel {
 
template <std::floating_point Real>
inline void computeContourSideAttributes(const AttributeComputeContext<Real>& context, const ContourSideRequest& request) {
    if (!request.any()) {
        return;
    }
 
    const std::vector<ContourSideCounts> sideCounts = computeContourSideCounts(context.tree);
    materializeContourSideAttributes(context, request, sideCounts);
}
 
} // namespace kernel
 
template <std::floating_point Real> inline void validateContourSideContext(const AttributeComputeContext<Real>& context) {
    requireAttributeBufferShape(context.tree, context.buffer, context.attrNames);
    requireRequestedAttributeColumns(context);
    local_attributes::detail::validateFiniteWindowLocalAttributeInput(context.tree);
}
 
} // namespace detail
 
class ContourSideAttributeComputer {
  public:
    static constexpr std::string_view familyName = "contour-side";
 
    static constexpr AttributeComputerFamily family = AttributeComputerFamily::ContourSide;
 
    static constexpr AttributeComputerDomain domain = AttributeComputerDomain::Topology;
 
    inline static constexpr std::array<Attribute, 6> producedAttributes{ContourPixels,    ContourPerimeter, ContourSideNorth,
                                                                        ContourSideWest, ContourSideEast, ContourSideSouth};
 
    template <std::floating_point Real> static void compute(const AttributeComputeContext<Real>& context) {
        const detail::ContourSideRequest request = detail::ContourSideRequest::from(context.requestedAttributes);
        MMCFILTERS_CONTRACT_CHECKED_ONLY(detail::validateContourSideContext(context));
        detail::kernel::computeContourSideAttributes(context, request);
    }
 
  public:
    template <std::floating_point Real> static void computeUnitRows(const UnitAttributeComputeContext<Real>& context) {
        detail::ContourSideAttributeMaterialization::materializeUnitContourSideAttributes(context.tree, context.unitPixels, context.buffer,
                                                                                          context.attrNames, context.requestedAttributes);
    }
};
 
} // namespace mmcfilters::attributes::computers