BitquadAttributeComputer.hpp

#pragma once
 
#include "AttributeComputerDomain.hpp"
#include "AttributeComputerFamily.hpp"
#include "../detail/AttributeKernelSupport.hpp"
#include "detail/BitquadAttributeProjection.hpp"
#include "detail/BitquadFiniteWindowComputation.hpp"
#include "../../trees/TreeAltitudeAlgorithms.hpp"
#include "../../trees/MorphologicalTree.hpp"
#include "../../utils/Contract.hpp"
 
#include <array>
#include <numbers>
#include <span>
#include <stdexcept>
#include <string_view>
#include <vector>
 
namespace mmcfilters::attributes::computers {
 
namespace detail {
 
inline void validateBitquadAdjacency(const MorphologicalTree& tree, bool altitudeAvailable) {
    static_cast<void>(makeBitquadConnectivityPolicy(tree, altitudeAvailable));
}
 
template <std::floating_point Real> inline void validateBitquadContext(const AttributeComputeContext<Real>& context) {
    requireAttributeBufferShape(context.tree, context.buffer, context.attrNames);
    requireRequestedAttributeColumns(context);
    local_attributes::detail::validateFiniteWindowLocalAttributeInput(context.tree);
    validateBitquadAdjacency(context.tree, false);
}
 
template <std::floating_point Real, AltitudeValue T> inline void validateBitquadContext(const AltitudeAttributeComputeContext<Real, T>& context) {
    requireAttributeBufferShape(context.tree, context.buffer, context.attrNames);
    requireRequestedAttributeColumns(context);
    local_attributes::detail::validateFiniteWindowLocalAttributeInput(context.tree);
    validateBitquadAdjacency(context.tree, true);
    TreeAltitudeAlgorithms::validateNodeAltitudeBufferShape(context.tree, context.altitude);
 
    const BitquadConnectivityPolicy connectivityPolicy = makeBitquadConnectivityPolicy(context.tree, true);
    if (!connectivityPolicy.requiresShapePolarity()) {
        return;
    }
    for (NodeId node : context.tree.aliveNodeIds()) {
        static_cast<void>(shapePolarity(context.tree, context.altitude, node));
    }
}
 
} // namespace detail
 
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{
        BitquadArea,        BitquadNumberEuler,      BitquadNumberHoles,   BitquadPerimeter,    BitquadPerimeterContinuous,
        BitquadCircularity, BitquadPerimeterAverage, BitquadLengthAverage, BitquadWidthAverage};
 
    template <std::floating_point Real> static void compute(const AttributeComputeContext<Real>& context) {
        const detail::BitquadRequest request = detail::BitquadRequest::from(context.requestedAttributes);
        MMCFILTERS_CONTRACT_CHECKED_ONLY(detail::validateBitquadContext(context));
        if (!request.any()) {
            return;
        }
        const std::vector<detail::BitquadFamilyCounts> familyCounts = detail::kernel::computeBitquadFamilyCounts(context.tree);
        const detail::BitquadConnectivityPolicy connectivityPolicy = detail::makeBitquadConnectivityPolicy(context.tree, false);
        detail::BitquadAttributeProjection::materializeBitquadAttributes(context.tree, std::span<const detail::BitquadFamilyCounts>(familyCounts),
                                                                         connectivityPolicy, context.buffer, context.attrNames, context.requestedAttributes);
    }
 
    template <std::floating_point Real, AltitudeValue T> static void compute(const AltitudeAttributeComputeContext<Real, T>& context) {
        const detail::BitquadRequest request = detail::BitquadRequest::from(context.requestedAttributes);
        MMCFILTERS_CONTRACT_CHECKED_ONLY(detail::validateBitquadContext(context));
        if (!request.any()) {
            return;
        }
        const std::vector<detail::BitquadFamilyCounts> familyCounts = detail::kernel::computeBitquadFamilyCounts(context.tree);
        const detail::BitquadConnectivityPolicy connectivityPolicy = detail::makeBitquadConnectivityPolicy(context.tree, true);
        detail::BitquadAttributeProjection::materializeBitquadAttributes(context.tree, context.altitude,
                                                                         std::span<const detail::BitquadFamilyCounts>(familyCounts), connectivityPolicy,
                                                                         context.buffer, context.attrNames, context.requestedAttributes);
    }
 
    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) {
        const RegularGridAdjacency2D* adjacency = context.tree.constructionAdjacency();
        if (adjacency == nullptr) {
            throw std::invalid_argument("Bitquad attributes require an adjacency relation.");
        }
        if (!adjacency->isCanonical4Or8Connectivity()) {
            throw std::invalid_argument("Bitquad attributes require canonical 4- or 8-connectivity.");
        }
 
        const bool is4Connectivity = adjacency->is4connectivity();
        auto unitValue = [&](Attribute attribute) -> Real {
            if (is4Connectivity) {
                switch (attribute) {
                case BitquadArea:
                    return Real{0};
                case BitquadNumberEuler:
                    return Real{1};
                case BitquadNumberHoles:
                    return Real{0};
                case BitquadPerimeter:
                    return Real{0};
                case BitquadPerimeterContinuous:
                    return Real{0};
                case BitquadCircularity:
                    return Real{0};
                case BitquadPerimeterAverage:
                    return Real{0};
                case BitquadLengthAverage:
                    return Real{0};
                case BitquadWidthAverage:
                    return Real{0};
                default:
                    break;
                }
            }
 
            switch (attribute) {
            case BitquadArea:
                return Real{1};
            case BitquadNumberEuler:
                return Real{0};
            case BitquadNumberHoles:
                return Real{1};
            case BitquadPerimeter:
                return Real{4};
            case BitquadPerimeterContinuous:
                return Real{8} / Real{3};
            case BitquadCircularity:
                return Real{9} * std::numbers::pi_v<Real> / Real{16};
            case BitquadPerimeterAverage:
                return Real{0};
            case BitquadLengthAverage:
                return Real{0};
            case BitquadWidthAverage:
                return static_cast<Real>(0.75);
            default:
                break;
            }
            throw std::runtime_error("Unsupported finite-window Bitquad unit attribute.");
        };
 
        constexpr std::array<Attribute, 9> unitAttributes{
            BitquadArea,        BitquadNumberEuler,      BitquadNumberHoles,   BitquadPerimeter,    BitquadPerimeterContinuous,
            BitquadCircularity, BitquadPerimeterAverage, BitquadLengthAverage, BitquadWidthAverage};
 
        for (Attribute attribute : unitAttributes) {
            if (!requestsAttribute(context.requestedAttributes, attribute)) {
                continue;
            }
            const Real value = unitValue(attribute);
            for (NodeId leafIndex = 0; leafIndex < static_cast<NodeId>(context.unitPixels.size()); ++leafIndex) {
                context.buffer[context.attrNames.linearIndex(leafIndex, attribute)] = value;
            }
        }
    }
};
 
} // namespace mmcfilters::attributes::computers