AttributeComputerRegistry.hpp

Go to the documentation of this file.

#pragma once
 
#include "AttributeComputerDomain.hpp"
#include "AttributeComputerFamily.hpp"
#include "AreaComputer.hpp"
#include "BitquadAttributeComputer.hpp"
#include "BoundingBoxComputer.hpp"
#include "ContourSideAttributeComputer.hpp"
#include "GrayLevelStatsComputer.hpp"
#include "MaxDistComputer.hpp"
#include "MomentBasedAttributeComputer.hpp"
#include "TreeTopologyComputer.hpp"
#include "VolumeComputer.hpp"
 
#include <algorithm>
#include <array>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <string_view>
#include <type_traits>
#include <tuple>
#include <vector>
 
namespace mmcfilters::attributes::computers {
 
namespace detail {
 
template <class T>
struct IsAttributeArray : std::false_type {};
 
template <std::size_t N>
struct IsAttributeArray<std::array<Attribute, N>> : std::true_type {};
 
template <class T>
inline constexpr bool IsAttributeArrayV = IsAttributeArray<std::remove_cvref_t<T>>::value;
 
} // namespace detail
 
template <class Computer>
concept AttributeComputerProducesAttributes =
    requires {
        Computer::producedAttributes;
    } &&
    detail::IsAttributeArrayV<decltype(Computer::producedAttributes)>;
 
template <class Computer>
concept AttributeComputer =
    AttributeComputerProducesAttributes<Computer> &&
    requires {
        { Computer::familyName } -> std::convertible_to<std::string_view>;
        { Computer::family } -> std::convertible_to<AttributeComputerFamily>;
        { Computer::domain } -> std::convertible_to<AttributeComputerDomain>;
    };
 
template <class Computer, class Real = float>
concept TopologyAttributeComputer =
    std::floating_point<Real> &&
    AttributeComputer<Computer> &&
    Computer::domain == AttributeComputerDomain::Topology &&
    requires(
        const AttributeComputeContext<Real>& context,
        const UnitAttributeComputeContext<Real>& unitContext) {
        { Computer::compute(context) } -> std::same_as<void>;
        { Computer::computeUnitRows(unitContext) } -> std::same_as<void>;
    };
 
template <class Computer, class Real = float, class T = std::uint8_t>
concept AltitudeAttributeComputer =
    std::floating_point<Real> &&
    AltitudeValue<T> &&
    AttributeComputer<Computer> &&
    Computer::domain == AttributeComputerDomain::Altitude &&
    requires(
        const AltitudeAttributeComputeContext<Real, T>& context,
        const AltitudeUnitAttributeComputeContext<Real, T>& unitContext) {
        { Computer::compute(context) } -> std::same_as<void>;
        { Computer::computeUnitRows(unitContext) } -> std::same_as<void>;
    };
 
template <AttributeComputer Computer>
[[nodiscard]] constexpr bool producesAttribute(Attribute attribute) noexcept
{
    const auto& attributes = Computer::producedAttributes;
    return std::find(attributes.begin(), attributes.end(), attribute) != attributes.end();
}
 
template <AttributeComputer Computer>
[[nodiscard]] constexpr std::size_t numProducedAttributes() noexcept
{
    return Computer::producedAttributes.size();
}
 
template <AttributeComputer Computer>
[[nodiscard]] std::vector<Attribute> runtimeProducedAttributes()
{
    const auto& attributes = Computer::producedAttributes;
    return {attributes.begin(), attributes.end()};
}
 
using TopologyAttributeComputers = std::tuple<
    AreaComputer,
    BoundingBoxComputer,
    TreeTopologyComputer,
    CentralMomentsComputer,
    HuMomentsComputer,
    MomentBasedAttributeComputer,
    BitquadAttributeComputer,
    ContourSideAttributeComputer>;
 
using AltitudeAttributeComputers = std::tuple<
    VolumeComputer,
    GrayLevelStatsComputer,
    MaxDistComputer>;
 
using RegisteredAttributeComputers = std::tuple<
    AreaComputer,
    BoundingBoxComputer,
    TreeTopologyComputer,
    CentralMomentsComputer,
    HuMomentsComputer,
    MomentBasedAttributeComputer,
    BitquadAttributeComputer,
    ContourSideAttributeComputer,
    VolumeComputer,
    GrayLevelStatsComputer,
    MaxDistComputer>;
 
} // namespace mmcfilters::attributes::computers