BitquadAttributeComputer.hpp

#pragma once
 
#include "AttributeComputerDomain.hpp"
#include "AttributeComputerFamily.hpp"
#include "../detail/AttributeKernelSupport.hpp"
#include "detail/BitquadAttributeMaterialization.hpp"
#include "detail/BitquadLocalEventComputation.hpp"
 
#include <array>
#include <numbers>
#include <span>
#include <stdexcept>
#include <string_view>
 
namespace mmcfilters::attributes::computers {
 
class BitquadAttributeComputer {
public:
    static constexpr std::string_view familyName = "bitquad";
 
    static constexpr AttributeComputerFamily family = AttributeComputerFamily::Bitquad;
 
    static constexpr AttributeComputerDomain domain = AttributeComputerDomain::Topology;
 
    inline static constexpr std::array<Attribute, 9> producedAttributes{
        BITQUADS_AREA,
        BITQUADS_NUMBER_EULER,
        BITQUADS_NUMBER_HOLES,
        BITQUADS_PERIMETER,
        BITQUADS_PERIMETER_CONTINUOUS,
        BITQUADS_CIRCULARITY,
        BITQUADS_PERIMETER_AVERAGE,
        BITQUADS_LENGTH_AVERAGE,
        BITQUADS_WIDTH_AVERAGE};
 
    template <std::floating_point Real>
    static void compute(const AttributeComputeContext<Real>& context) {
        requireAttributeBufferShape(context.tree, context.buffer, context.attrNames);
        const auto familyDeltas = detail::BitquadLocalEventComputation::computeBitquadFamilyDeltas(context.tree);
        const auto familyCounts = detail::BitquadLocalEventComputation::aggregateBitquadFamilyDeltas(context.tree, familyDeltas);
        detail::BitquadAttributeMaterialization::materializeAttributesFromBitquadFamilyCounts(
            context.tree,
            familyCounts,
            context.buffer,
            context.attrNames,
            context.requestedAttributes);
    }
 
    template<std::floating_point Real, AltitudeValue T>
    static void compute(const AltitudeAttributeComputeContext<Real, T>& context) {
        requireAttributeBufferShape(context.tree, context.buffer, context.attrNames);
        const auto familyDeltas = detail::BitquadLocalEventComputation::computeBitquadFamilyDeltas(context.tree);
        const auto familyCounts = detail::BitquadLocalEventComputation::aggregateBitquadFamilyDeltas(context.tree, familyDeltas);
        detail::BitquadAttributeMaterialization::materializeAttributesFromBitquadFamilyCounts(
            context.tree,
            context.altitude,
            familyCounts,
            context.buffer,
            context.attrNames,
            context.requestedAttributes);
    }
 
    template <std::floating_point Real>
    static void computeUnitRows(const UnitAttributeComputeContext<Real>& context) {
        requireUnitAttributeBufferShape(context.tree, context.unitProperParts, context.buffer, context.attrNames);
        const AdjacencyRelation* adjacency = context.tree.getAdjacencyRelation();
        if (adjacency == nullptr) {
            throw std::invalid_argument("Local-event BitQuads attributes require an adjacency relation.");
        }
 
        const bool is4Connectivity = adjacency->is4connectivity();
        auto unitValue = [&](Attribute attribute) -> Real {
            if (is4Connectivity) {
                switch (attribute) {
                    case BITQUADS_AREA: return Real{0};
                    case BITQUADS_NUMBER_EULER: return Real{1};
                    case BITQUADS_NUMBER_HOLES: return Real{0};
                    case BITQUADS_PERIMETER: return Real{0};
                    case BITQUADS_PERIMETER_CONTINUOUS: return Real{0};
                    case BITQUADS_CIRCULARITY: return Real{0};
                    case BITQUADS_PERIMETER_AVERAGE: return Real{0};
                    case BITQUADS_LENGTH_AVERAGE: return Real{0};
                    case BITQUADS_WIDTH_AVERAGE: return Real{0};
                    default: break;
                }
            }
 
            switch (attribute) {
                case BITQUADS_AREA: return Real{1};
                case BITQUADS_NUMBER_EULER: return Real{0};
                case BITQUADS_NUMBER_HOLES: return Real{1};
                case BITQUADS_PERIMETER: return Real{4};
                case BITQUADS_PERIMETER_CONTINUOUS: return Real{8} / Real{3};
                case BITQUADS_CIRCULARITY: return Real{9} * std::numbers::pi_v<Real> / Real{16};
                case BITQUADS_PERIMETER_AVERAGE: return Real{0};
                case BITQUADS_LENGTH_AVERAGE: return Real{0};
                case BITQUADS_WIDTH_AVERAGE: return static_cast<Real>(0.75);
                default: break;
            }
            throw std::runtime_error("Unsupported local-event BitQuads unit attribute.");
        };
 
        constexpr std::array<Attribute, 9> unitAttributes{
            BITQUADS_AREA,
            BITQUADS_NUMBER_EULER,
            BITQUADS_NUMBER_HOLES,
            BITQUADS_PERIMETER,
            BITQUADS_PERIMETER_CONTINUOUS,
            BITQUADS_CIRCULARITY,
            BITQUADS_PERIMETER_AVERAGE,
            BITQUADS_LENGTH_AVERAGE,
            BITQUADS_WIDTH_AVERAGE};
 
        for (Attribute attribute : unitAttributes) {
            if (!requestsAttribute(context.requestedAttributes, attribute)) {
                continue;
            }
            const Real value = unitValue(attribute);
            for (NodeId leafIndex = 0; leafIndex < static_cast<NodeId>(context.unitProperParts.size()); ++leafIndex) {
                context.buffer[context.attrNames.linearIndex(leafIndex, attribute)] = value;
            }
        }
    }
};
 
} // namespace mmcfilters::attributes::computers