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 "MaxDistExactComputer.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, MaxDistComputer,
                                              MaxDistExactComputer>;
 
using AltitudeAttributeComputers = std::tuple<VolumeComputer, GrayLevelStatsComputer>;
 
using RegisteredAttributeComputers =
    std::tuple<AreaComputer, BoundingBoxComputer, TreeTopologyComputer, CentralMomentsComputer, HuMomentsComputer, MomentBasedAttributeComputer,
               BitquadAttributeComputer, ContourSideAttributeComputer, VolumeComputer, GrayLevelStatsComputer, MaxDistComputer,
               MaxDistExactComputer>;
 
} // namespace mmcfilters::attributes::computers