peak_common_metadata_traits.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/types/geometry/peak_common_rectangle.hpp>
#include <peak_common/types/peak_common_metadata_key.hpp>
#include <array>
#include <cstdint>
 
namespace peak
{
namespace common
{
namespace detail
{
 
template <MetadataKey metadataKey>
struct MetadataKeyTraits;


template <>
struct MetadataKeyTraits<MetadataKey::DeviceTimestamp>
{
    using type = uint64_t;

    static constexpr const char* Name()
    {
        return "DeviceTimestamp";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::DeviceFrameID>
{
    using type = uint64_t;

    static constexpr const char* Name()
    {
        return "DeviceFrameID";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::BinningHorizontal>
{
    using type = uint64_t;

    static constexpr const char* Name()
    {
        return "BinningHorizontal";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::BinningVertical>
{
    using type = uint64_t;

    static constexpr const char* Name()
    {
        return "BinningVertical";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::Roi>
{
    using type = RectangleU;

    static constexpr const char* Name()
    {
        return "Roi";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::DeviceExposureTime>
{
    using type = double;

    static constexpr const char* Name()
    {
        return "DeviceExposureTime";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::DeviceExposureTimeSequence>
{
    using type = std::vector<double>;

    static constexpr const char* Name()
    {
        return "DeviceExposureTimeSequence";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::SystemTimestamp>
{
    using type = uint64_t;

    static constexpr const char* Name()
    {
        return "SystemTimestamp";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::DeviceGain>
{
    using type = double;

    static constexpr const char* Name()
    {
        return "DeviceGain";
    }
};

template <>
struct MetadataKeyTraits<MetadataKey::DeviceGainSequence>
{
    using type = std::vector<double>;

    static constexpr const char* Name()
    {
        return "DeviceGainSequence";
    }
};

constexpr std::array<MetadataKey, 10> allMetadataKeys{ MetadataKey::DeviceTimestamp, MetadataKey::DeviceFrameID,
    MetadataKey::BinningHorizontal, MetadataKey::BinningVertical, MetadataKey::Roi, MetadataKey::DeviceExposureTime,
    MetadataKey::SystemTimestamp, MetadataKey::DeviceExposureTimeSequence, MetadataKey::DeviceGain, MetadataKey::DeviceGainSequence };

template <typename T, typename Tuple>
struct is_in_tuple;
 
template <typename T>
struct is_in_tuple<T, std::tuple<>> : std::false_type
{};
 
template <typename T, typename First, typename... Rest>
struct is_in_tuple<T, std::tuple<First, Rest...>>
    : std::integral_constant<bool, std::is_same<T, First>::value || is_in_tuple<T, std::tuple<Rest...>>::value>
{};
 
template <typename T, typename Enable = void>
struct NormalizeType
{
    using type = T;
};
 
template <typename T>
struct NormalizeType<T, typename std::enable_if_t<!std::is_same<T, bool>::value && std::is_integral<T>::value && std::is_signed<T>::value>>
{
    using type = int64_t;
};
 
template <typename T>
struct NormalizeType<T, typename std::enable_if_t<std::is_floating_point<T>::value>>
{
    using type = double;
};
 
template <typename T>
struct NormalizeType<T, typename std::enable_if_t<!std::is_same<T, bool>::value && std::is_integral<T>::value && !std::is_signed<T>::value>>
{
    using type = uint64_t;
};
 
template <typename T>
using normalize_t = typename NormalizeType<typename std::decay_t<T>>::type;
 
} // namespace detail
} // namespace common 
} // namespace peak