peak_common_pixel_format.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/detail/peak_common_defines.hpp>
#include <peak_common/exceptions/peak_common_exceptions.hpp>
#include <peak_common/types/geometry/peak_common_size.hpp>
#include <peak_common/types/peak_common_channel.hpp>
#include <peak_common_c/types/peak_common_pixel_format.h>
#include <unordered_map>
#include <algorithm>
#include <array>
#include <cstdint>
#include <ostream>
#include <string>
#include <vector>
 
namespace peak
{
namespace common
{
 
// clang-format off
enum class PixelFormat : uint64_t
{
    BayerGR8 = PEAK_COMMON_PIXEL_FORMAT_BAYER_GR_8,                                       
    BayerGR10 = PEAK_COMMON_PIXEL_FORMAT_BAYER_GR_10,                                     
    BayerGR12 = PEAK_COMMON_PIXEL_FORMAT_BAYER_GR_12,                                     
 
    BayerRG8 = PEAK_COMMON_PIXEL_FORMAT_BAYER_RG_8,                                       
    BayerRG10 = PEAK_COMMON_PIXEL_FORMAT_BAYER_RG_10,                                     
    BayerRG12 = PEAK_COMMON_PIXEL_FORMAT_BAYER_RG_12,                                     
 
    BayerGB8 = PEAK_COMMON_PIXEL_FORMAT_BAYER_GB_8,                                       
    BayerGB10 = PEAK_COMMON_PIXEL_FORMAT_BAYER_GB_10,                                     
    BayerGB12 = PEAK_COMMON_PIXEL_FORMAT_BAYER_GB_12,                                     
 
    BayerBG8 = PEAK_COMMON_PIXEL_FORMAT_BAYER_BG_8,                                       
    BayerBG10 = PEAK_COMMON_PIXEL_FORMAT_BAYER_BG_10,                                     
    BayerBG12 = PEAK_COMMON_PIXEL_FORMAT_BAYER_BG_12,                                     
 
    Mono8 = PEAK_COMMON_PIXEL_FORMAT_MONO_8,                                              
    Mono10 = PEAK_COMMON_PIXEL_FORMAT_MONO_10,                                            
    Mono12 = PEAK_COMMON_PIXEL_FORMAT_MONO_12,                                            
    Mono16 = PEAK_COMMON_PIXEL_FORMAT_MONO_16,                                            
 
    Confidence8 = PEAK_COMMON_PIXEL_FORMAT_CONFIDENCE_8,                                  
    Confidence16 = PEAK_COMMON_PIXEL_FORMAT_CONFIDENCE_16,                                
 
    Coord3D_C8 = PEAK_COMMON_PIXEL_FORMAT_COORD3D_C8,                                     
    Coord3D_C16 = PEAK_COMMON_PIXEL_FORMAT_COORD3D_C16,                                   
    Coord3D_C32f = PEAK_COMMON_PIXEL_FORMAT_COORD3D_C32F,                                 
 
    Coord3D_ABC32f = PEAK_COMMON_PIXEL_FORMAT_COORD3D_ABC32F,                             
 
    YUV420_8_YY_UV_SemiplanarIDS = PEAK_COMMON_PIXEL_FORMAT_YUV420_8_YY_UV_SemiplanarIDS, 
    YUV420_8_YY_VU_SemiplanarIDS = PEAK_COMMON_PIXEL_FORMAT_YUV420_8_YY_VU_SemiplanarIDS, 
 
    YUV422_8_UYVY = PEAK_COMMON_PIXEL_FORMAT_YUV422_8_UYVY,                               
 
    RGB8 = PEAK_COMMON_PIXEL_FORMAT_RGB_8,                                                
    RGB10 = PEAK_COMMON_PIXEL_FORMAT_RGB_10,                                              
    RGB12 = PEAK_COMMON_PIXEL_FORMAT_RGB_12,                                              
 
    BGR8 = PEAK_COMMON_PIXEL_FORMAT_BGR_8,                                                
    BGR10 = PEAK_COMMON_PIXEL_FORMAT_BGR_10,                                              
    BGR12 = PEAK_COMMON_PIXEL_FORMAT_BGR_12,                                              
 
    RGBa8 = PEAK_COMMON_PIXEL_FORMAT_RGBA_8,                                              
    RGBa10 = PEAK_COMMON_PIXEL_FORMAT_RGBA_10,                                            
    RGBa12 = PEAK_COMMON_PIXEL_FORMAT_RGBA_12,                                            
 
    BGRa8 = PEAK_COMMON_PIXEL_FORMAT_BGRA_8,                                              
    BGRa10 = PEAK_COMMON_PIXEL_FORMAT_BGRA_10,                                            
    BGRa12 = PEAK_COMMON_PIXEL_FORMAT_BGRA_12,                                            
 
    BayerBG10p = PEAK_COMMON_PIXEL_FORMAT_BAYER_BG_10_PACKED,                             
    BayerBG12p = PEAK_COMMON_PIXEL_FORMAT_BAYER_BG_12_PACKED,                             
 
    BayerGB10p = PEAK_COMMON_PIXEL_FORMAT_BAYER_GB_10_PACKED,                             
    BayerGB12p = PEAK_COMMON_PIXEL_FORMAT_BAYER_GB_12_PACKED,                             
 
    BayerGR10p = PEAK_COMMON_PIXEL_FORMAT_BAYER_GR_10_PACKED,                             
    BayerGR12p = PEAK_COMMON_PIXEL_FORMAT_BAYER_GR_12_PACKED,                             
 
    BayerRG10p = PEAK_COMMON_PIXEL_FORMAT_BAYER_RG_10_PACKED,                             
    BayerRG12p = PEAK_COMMON_PIXEL_FORMAT_BAYER_RG_12_PACKED,                             
 
    Mono10p = PEAK_COMMON_PIXEL_FORMAT_MONO_10_PACKED,                                    
    Mono12p = PEAK_COMMON_PIXEL_FORMAT_MONO_12_PACKED,                                    
 
    RGB10p32 = PEAK_COMMON_PIXEL_FORMAT_RGB_10_PACKED_32,                                 
    BGR10p32 = PEAK_COMMON_PIXEL_FORMAT_BGR_10_PACKED_32,                                 
 
    BayerRG10g40IDS = PEAK_COMMON_PIXEL_FORMAT_BAYER_RG_10_GROUPED_40_IDS,                
    BayerGB10g40IDS = PEAK_COMMON_PIXEL_FORMAT_BAYER_GB_10_GROUPED_40_IDS,                
    BayerGR10g40IDS = PEAK_COMMON_PIXEL_FORMAT_BAYER_GR_10_GROUPED_40_IDS,                
    BayerBG10g40IDS = PEAK_COMMON_PIXEL_FORMAT_BAYER_BG_10_GROUPED_40_IDS,                
 
    BayerRG12g24IDS = PEAK_COMMON_PIXEL_FORMAT_BAYER_RG_12_GROUPED_24_IDS,                
    BayerGB12g24IDS = PEAK_COMMON_PIXEL_FORMAT_BAYER_GB_12_GROUPED_24_IDS,                
    BayerGR12g24IDS = PEAK_COMMON_PIXEL_FORMAT_BAYER_GR_12_GROUPED_24_IDS,                
    BayerBG12g24IDS = PEAK_COMMON_PIXEL_FORMAT_BAYER_BG_12_GROUPED_24_IDS,                
 
    Mono10g40IDS = PEAK_COMMON_PIXEL_FORMAT_MONO_10_GROUPED_40_IDS,                       
    Mono12g24IDS = PEAK_COMMON_PIXEL_FORMAT_MONO_12_GROUPED_24_IDS                        
};
 
// clang-format on
 
class PixelFormatInfo
{
public:
    explicit PixelFormatInfo(peak::common::PixelFormat pixelFormat);
 
    explicit PixelFormatInfo(const std::string& name);
 
    template <typename T = size_t>
    PEAK_COMMON_NO_DISCARD T GetMinimumValuePerChannel() const;
 
    template <typename T = size_t>
    PEAK_COMMON_NO_DISCARD T GetMaximumValuePerChannel() const;
 
    PEAK_COMMON_NO_DISCARD size_t GetStorageBitsPerPixel() const;
 
    PEAK_COMMON_NO_DISCARD size_t GetStorageBitsPerChannel() const;
 
    PEAK_COMMON_NO_DISCARD std::string GetName() const;
 
    PEAK_COMMON_NO_DISCARD std::vector<Channel> GetChannels() const;
 
    PEAK_COMMON_NO_DISCARD size_t GetAllocatedBitsPerPixel() const;
 
    PEAK_COMMON_NO_DISCARD bool HasIntensityChannel() const;
 
    PEAK_COMMON_NO_DISCARD size_t GetChannelIndex(Channel channel) const;
 
    PEAK_COMMON_NO_DISCARD size_t GetNumberOfChannels() const;
 
    PEAK_COMMON_NO_DISCARD bool IsSingleChannel() const;
 
    PEAK_COMMON_NO_DISCARD bool HasChannel(Channel channel) const;
 
    PEAK_COMMON_NO_DISCARD peak::common::PixelFormat GetPixelFormat() const;
 
    PEAK_COMMON_NO_DISCARD size_t GetSizeInBytes(const Size& size) const;
 
private:
    peak::common::PixelFormat m_pixelFormat;
};
 
inline std::ostream& operator<<(std::ostream& os, PixelFormat pixelFormat)
{
    PixelFormatInfo info(pixelFormat);
    os << info.GetName();
    return os;
}
 
namespace detail
{
 
template <peak::common::PixelFormat pixelFormat>
struct PixelFormatTraits;
 
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::Mono8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Mono8";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 8;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::Mono10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Mono10";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::Mono12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Mono12";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::Mono16>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Mono16";
    }
 
    static constexpr size_t storageBitsPerPixel = 16;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::RGB8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Red, Channel::Green, Channel::Blue };
    }
 
    static constexpr auto Name()
    {
        return "RGB8";
    }
 
    static constexpr size_t storageBitsPerPixel = 24;
    static constexpr size_t allocatedBitsPerPixel = 24;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::RGBa8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 4> Channels()
    {
        return { Channel::Red, Channel::Green, Channel::Blue, Channel::Alpha };
    }
 
    static constexpr auto Name()
    {
        return "RGBa8";
    }
 
    static constexpr size_t storageBitsPerPixel = 32;
    static constexpr size_t allocatedBitsPerPixel = 32;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::BGR8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Blue, Channel::Green, Channel::Red };
    }
 
    static constexpr auto Name()
    {
        return "BGR8";
    }
 
    static constexpr size_t storageBitsPerPixel = 24;
    static constexpr size_t allocatedBitsPerPixel = 24;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::BGRa8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 4> Channels()
    {
        return { Channel::Blue, Channel::Green, Channel::Red, Channel::Alpha };
    }
 
    static constexpr auto Name()
    {
        return "BGRa8";
    }
 
    static constexpr size_t storageBitsPerPixel = 32;
    static constexpr size_t allocatedBitsPerPixel = 32;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::Coord3D_ABC32f>
{
    using underlying_type = float;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::X, Channel::Y, Channel::Z };
    }
 
    static constexpr auto Name()
    {
        return "Coord3D_ABC32f";
    }
 
    static constexpr size_t storageBitsPerPixel = 96;
    static constexpr size_t allocatedBitsPerPixel = 96;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<peak::common::PixelFormat::Coord3D_C32f>
{
    using underlying_type = float;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Coord3D_C32f";
    }
 
    static constexpr size_t storageBitsPerPixel = 32;
    static constexpr size_t allocatedBitsPerPixel = 32;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::Mono10p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Mono10p";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::Mono12p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Mono12p";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::RGB10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Red, Channel::Green, Channel::Blue };
    }
 
    static constexpr auto Name()
    {
        return "RGB10";
    }
 
    static constexpr size_t storageBitsPerPixel = 30;
    static constexpr size_t allocatedBitsPerPixel = 48;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::RGB12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Red, Channel::Green, Channel::Blue };
    }
 
    static constexpr auto Name()
    {
        return "RGB12";
    }
 
    static constexpr size_t storageBitsPerPixel = 36;
    static constexpr size_t allocatedBitsPerPixel = 48;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::RGBa10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 4> Channels()
    {
        return { Channel::Red, Channel::Green, Channel::Blue, Channel::Alpha };
    }
 
    static constexpr auto Name()
    {
        return "RGBa10";
    }
 
    static constexpr size_t storageBitsPerPixel = 40;
    static constexpr size_t allocatedBitsPerPixel = 64;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::RGBa12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 4> Channels()
    {
        return { Channel::Red, Channel::Green, Channel::Blue, Channel::Alpha };
    }
 
    static constexpr auto Name()
    {
        return "RGBa12";
    }
 
    static constexpr size_t storageBitsPerPixel = 48;
    static constexpr size_t allocatedBitsPerPixel = 64;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BGR10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Blue, Channel::Green, Channel::Red };
    }
 
    static constexpr auto Name()
    {
        return "BGR10";
    }
 
    static constexpr size_t storageBitsPerPixel = 30;
    static constexpr size_t allocatedBitsPerPixel = 48;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BGR12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Blue, Channel::Green, Channel::Red };
    }
 
    static constexpr auto Name()
    {
        return "BGR12";
    }
 
    static constexpr size_t storageBitsPerPixel = 36;
    static constexpr size_t allocatedBitsPerPixel = 48;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BGRa10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 4> Channels()
    {
        return { Channel::Blue, Channel::Green, Channel::Red, Channel::Alpha };
    }
 
    static constexpr auto Name()
    {
        return "BGRa10";
    }
 
    static constexpr size_t storageBitsPerPixel = 40;
    static constexpr size_t allocatedBitsPerPixel = 64;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BGRa12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 4> Channels()
    {
        return { Channel::Blue, Channel::Green, Channel::Red, Channel::Alpha };
    }
 
    static constexpr auto Name()
    {
        return "BGRa12";
    }
 
    static constexpr size_t storageBitsPerPixel = 48;
    static constexpr size_t allocatedBitsPerPixel = 64;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::RGB10p32>
{
    using underlying_type = uint32_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Red, Channel::Green, Channel::Blue };
    }
 
    static constexpr auto Name()
    {
        return "RGB10p32";
    }
 
    static constexpr size_t storageBitsPerPixel = 30;
    static constexpr size_t allocatedBitsPerPixel = 32;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BGR10p32>
{
    using underlying_type = uint32_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Blue, Channel::Green, Channel::Red };
    }
 
    static constexpr auto Name()
    {
        return "BGR10p32";
    }
 
    static constexpr size_t storageBitsPerPixel = 30;
    static constexpr size_t allocatedBitsPerPixel = 32;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGR8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGR8";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 8;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGR10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGR10";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGR12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGR12";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerRG8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerRG8";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 8;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerRG10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerRG10";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerRG12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerRG12";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGB8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGB8";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 8;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGB10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGB10";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGB12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGB12";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerBG8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerBG8";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 8;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerBG10>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerBG10";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerBG12>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerBG12";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGR10p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGR10p";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGR12p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGR12p";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerRG10p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerRG10p";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerRG12p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerRG12p";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGB10p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGB10p";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGB12p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGB12p";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerBG10p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerBG10p";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerBG12p>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerBG12p";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::Confidence8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Confidence8";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 8;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::Confidence16>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Confidence16";
    }
 
    static constexpr size_t storageBitsPerPixel = 16;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::Coord3D_C8>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Coord3D_C8";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 8;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::Coord3D_C16>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Coord3D_C16";
    }
 
    static constexpr size_t storageBitsPerPixel = 16;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerBG10g40IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerBG10g40IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerBG12g24IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerBG12g24IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGB10g40IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGB10g40IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGB12g24IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGB12g24IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGR10g40IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGR10g40IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerGR12g24IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerGR12g24IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerRG10g40IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerRG10g40IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::BayerRG12g24IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Bayer };
    }
 
    static constexpr auto Name()
    {
        return "BayerRG12g24IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Intensity, Channel::Intensity, Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "YUV420_8_YY_UV_SemiplanarIDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = true;
};
 
template <>
struct PixelFormatTraits<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Intensity, Channel::Intensity, Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "YUV420_8_YY_VU_SemiplanarIDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = true;
};
 
template <>
struct PixelFormatTraits<PixelFormat::YUV422_8_UYVY>
{
    using underlying_type = uint8_t;
 
    static constexpr std::array<Channel, 3> Channels()
    {
        return { Channel::Intensity, Channel::Intensity, Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "YUV422_8_UYVY";
    }
 
    static constexpr size_t storageBitsPerPixel = 8;
    static constexpr size_t allocatedBitsPerPixel = 16;
    static constexpr bool isPacked = false;
    static constexpr bool isYUV = true;
};
 
template <>
struct PixelFormatTraits<PixelFormat::Mono10g40IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Mono10g40IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 10;
    static constexpr size_t allocatedBitsPerPixel = 10;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <>
struct PixelFormatTraits<PixelFormat::Mono12g24IDS>
{
    using underlying_type = uint16_t;
 
    static constexpr std::array<Channel, 1> Channels()
    {
        return { Channel::Intensity };
    }
 
    static constexpr auto Name()
    {
        return "Mono12g24IDS";
    }
 
    static constexpr size_t storageBitsPerPixel = 12;
    static constexpr size_t allocatedBitsPerPixel = 12;
    static constexpr bool isPacked = true;
    static constexpr bool isYUV = false;
};
 
template <typename T, bool isFloat>
struct ValueRangeHelper;
 
template <typename T>
struct ValueRangeHelper<T, false> // Integer
{
    static constexpr T Minimum(size_t)
    {
        return 0;
    }
 
    static constexpr T Maximum(size_t bitsPerChannel)
    {
        return static_cast<T>((1ULL << bitsPerChannel) - 1);
    }
};
 
template <typename T>
struct ValueRangeHelper<T, true> // Float
{
    static constexpr T Minimum(size_t)
    {
        return std::numeric_limits<T>::lowest();
    }
 
    static constexpr T Maximum(size_t)
    {
        return (std::numeric_limits<T>::max)();
    }
};
 
template <PixelFormat pixelFormat>
struct PixelFormatInfo
{
    using traits = PixelFormatTraits<pixelFormat>;
    using underlying_type = typename traits::underlying_type;
    static constexpr bool is_floating_point = std::is_floating_point<underlying_type>::value;
 
    static constexpr size_t storageBitsPerPixel = traits::storageBitsPerPixel;
    static constexpr size_t allocatedBitsPerPixel = traits::allocatedBitsPerPixel;
 
    static constexpr size_t storageBitsPerChannel = storageBitsPerPixel / traits::Channels().size();
 
    static constexpr underlying_type minimumValuePerChannel = ValueRangeHelper<underlying_type, is_floating_point>::Minimum(
        storageBitsPerChannel);
 
    static constexpr underlying_type maximumValuePerChannel = ValueRangeHelper<underlying_type, is_floating_point>::Maximum(
        storageBitsPerChannel);
 
    static constexpr auto Channels()
    {
        return traits::Channels();
    }
 
    static constexpr const char* Name()
    {
        return traits::Name();
    }
 
    static constexpr size_t GetSizeInBytes(const Size& size)
    {
        const auto area = static_cast<uint64_t>(size.GetWidth()) * size.GetHeight();
        return static_cast<size_t>(((area * PixelFormatInfo<pixelFormat>::allocatedBitsPerPixel) + 7) / 8);
    }
};
 
template <typename PixelFormatInfo>
inline auto ChannelsVector()
{
    constexpr auto arr = PixelFormatInfo::Channels();
    using T = typename std::decay_t<typename decltype(arr)::value_type>;
    return std::vector<T>(arr.begin(), arr.end());
}
 
 
} // namespace detail
 
inline PixelFormatInfo::PixelFormatInfo(peak::common::PixelFormat pixelFormat)
    : m_pixelFormat{ pixelFormat }
{}
 
inline PixelFormatInfo::PixelFormatInfo(const std::string& name)
{
    static const std::unordered_map<std::string, PixelFormat> map = {
        {                     detail::PixelFormatInfo<PixelFormat::BayerGR8>::Name(),                     PixelFormat::BayerGR8 },
        {                    detail::PixelFormatInfo<PixelFormat::BayerGR10>::Name(),                    PixelFormat::BayerGR10 },
        {                    detail::PixelFormatInfo<PixelFormat::BayerGR12>::Name(),                    PixelFormat::BayerGR12 },
        {                     detail::PixelFormatInfo<PixelFormat::BayerRG8>::Name(),                     PixelFormat::BayerRG8 },
        {                    detail::PixelFormatInfo<PixelFormat::BayerRG10>::Name(),                    PixelFormat::BayerRG10 },
        {                    detail::PixelFormatInfo<PixelFormat::BayerRG12>::Name(),                    PixelFormat::BayerRG12 },
        {                     detail::PixelFormatInfo<PixelFormat::BayerGB8>::Name(),                     PixelFormat::BayerGB8 },
        {                    detail::PixelFormatInfo<PixelFormat::BayerGB10>::Name(),                    PixelFormat::BayerGB10 },
        {                    detail::PixelFormatInfo<PixelFormat::BayerGB12>::Name(),                    PixelFormat::BayerGB12 },
        {                     detail::PixelFormatInfo<PixelFormat::BayerBG8>::Name(),                     PixelFormat::BayerBG8 },
        {                    detail::PixelFormatInfo<PixelFormat::BayerBG10>::Name(),                    PixelFormat::BayerBG10 },
        {                    detail::PixelFormatInfo<PixelFormat::BayerBG12>::Name(),                    PixelFormat::BayerBG12 },
        {                        detail::PixelFormatInfo<PixelFormat::Mono8>::Name(),                        PixelFormat::Mono8 },
        {                       detail::PixelFormatInfo<PixelFormat::Mono10>::Name(),                       PixelFormat::Mono10 },
        {                       detail::PixelFormatInfo<PixelFormat::Mono12>::Name(),                       PixelFormat::Mono12 },
        {                       detail::PixelFormatInfo<PixelFormat::Mono16>::Name(),                       PixelFormat::Mono16 },
        {                  detail::PixelFormatInfo<PixelFormat::Confidence8>::Name(),                  PixelFormat::Confidence8 },
        {                 detail::PixelFormatInfo<PixelFormat::Confidence16>::Name(),                 PixelFormat::Confidence16 },
        {                   detail::PixelFormatInfo<PixelFormat::Coord3D_C8>::Name(),                   PixelFormat::Coord3D_C8 },
        {                  detail::PixelFormatInfo<PixelFormat::Coord3D_C16>::Name(),                  PixelFormat::Coord3D_C16 },
        {                 detail::PixelFormatInfo<PixelFormat::Coord3D_C32f>::Name(),                 PixelFormat::Coord3D_C32f },
        {               detail::PixelFormatInfo<PixelFormat::Coord3D_ABC32f>::Name(),               PixelFormat::Coord3D_ABC32f },
        { detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>::Name(), PixelFormat::YUV420_8_YY_UV_SemiplanarIDS },
        { detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>::Name(), PixelFormat::YUV420_8_YY_VU_SemiplanarIDS },
        {                detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>::Name(),                PixelFormat::YUV422_8_UYVY },
        {                         detail::PixelFormatInfo<PixelFormat::RGB8>::Name(),                         PixelFormat::RGB8 },
        {                        detail::PixelFormatInfo<PixelFormat::RGB10>::Name(),                        PixelFormat::RGB10 },
        {                        detail::PixelFormatInfo<PixelFormat::RGB12>::Name(),                        PixelFormat::RGB12 },
        {                         detail::PixelFormatInfo<PixelFormat::BGR8>::Name(),                         PixelFormat::BGR8 },
        {                        detail::PixelFormatInfo<PixelFormat::BGR10>::Name(),                        PixelFormat::BGR10 },
        {                        detail::PixelFormatInfo<PixelFormat::BGR12>::Name(),                        PixelFormat::BGR12 },
        {                        detail::PixelFormatInfo<PixelFormat::RGBa8>::Name(),                        PixelFormat::RGBa8 },
        {                       detail::PixelFormatInfo<PixelFormat::RGBa10>::Name(),                       PixelFormat::RGBa10 },
        {                       detail::PixelFormatInfo<PixelFormat::RGBa12>::Name(),                       PixelFormat::RGBa12 },
        {                        detail::PixelFormatInfo<PixelFormat::BGRa8>::Name(),                        PixelFormat::BGRa8 },
        {                       detail::PixelFormatInfo<PixelFormat::BGRa10>::Name(),                       PixelFormat::BGRa10 },
        {                       detail::PixelFormatInfo<PixelFormat::BGRa12>::Name(),                       PixelFormat::BGRa12 },
        {                   detail::PixelFormatInfo<PixelFormat::BayerBG10p>::Name(),                   PixelFormat::BayerBG10p },
        {                   detail::PixelFormatInfo<PixelFormat::BayerBG12p>::Name(),                   PixelFormat::BayerBG12p },
        {                   detail::PixelFormatInfo<PixelFormat::BayerGB10p>::Name(),                   PixelFormat::BayerGB10p },
        {                   detail::PixelFormatInfo<PixelFormat::BayerGB12p>::Name(),                   PixelFormat::BayerGB12p },
        {                   detail::PixelFormatInfo<PixelFormat::BayerGR10p>::Name(),                   PixelFormat::BayerGR10p },
        {                   detail::PixelFormatInfo<PixelFormat::BayerGR12p>::Name(),                   PixelFormat::BayerGR12p },
        {                   detail::PixelFormatInfo<PixelFormat::BayerRG10p>::Name(),                   PixelFormat::BayerRG10p },
        {                   detail::PixelFormatInfo<PixelFormat::BayerRG12p>::Name(),                   PixelFormat::BayerRG12p },
        {                      detail::PixelFormatInfo<PixelFormat::Mono10p>::Name(),                      PixelFormat::Mono10p },
        {                      detail::PixelFormatInfo<PixelFormat::Mono12p>::Name(),                      PixelFormat::Mono12p },
        {                     detail::PixelFormatInfo<PixelFormat::RGB10p32>::Name(),                     PixelFormat::RGB10p32 },
        {                     detail::PixelFormatInfo<PixelFormat::BGR10p32>::Name(),                     PixelFormat::BGR10p32 },
        {              detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>::Name(),              PixelFormat::BayerRG10g40IDS },
        {              detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>::Name(),              PixelFormat::BayerGB10g40IDS },
        {              detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>::Name(),              PixelFormat::BayerGR10g40IDS },
        {              detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>::Name(),              PixelFormat::BayerBG10g40IDS },
        {              detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>::Name(),              PixelFormat::BayerRG12g24IDS },
        {              detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>::Name(),              PixelFormat::BayerGB12g24IDS },
        {              detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>::Name(),              PixelFormat::BayerGR12g24IDS },
        {              detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>::Name(),              PixelFormat::BayerBG12g24IDS },
        {                 detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>::Name(),                 PixelFormat::Mono10g40IDS },
        {                 detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>::Name(),                 PixelFormat::Mono12g24IDS }
    };
 
    const auto iter = map.find(name);
    if (iter == map.end())
    {
        throw InvalidParameterException("The given pixel format " + name + " is unkown!");
    }
    m_pixelFormat = iter->second;
}
 
template <>
inline float PixelFormatInfo::GetMaximumValuePerChannel<float>() const
{
    switch (m_pixelFormat)
    {
    case peak::common::PixelFormat::Coord3D_ABC32f:
        return detail::PixelFormatInfo<peak::common::PixelFormat::Coord3D_ABC32f>::maximumValuePerChannel;
    case peak::common::PixelFormat::Coord3D_C32f:
        return detail::PixelFormatInfo<peak::common::PixelFormat::Coord3D_C32f>::maximumValuePerChannel;
    default:
        throw InvalidParameterException(
            "The template does not match the data type of pixel format " + GetName() + "! Use size_t as template argument.");
    }
}
 
template <>
inline size_t PixelFormatInfo::GetMaximumValuePerChannel<size_t>() const
{
    switch (m_pixelFormat)
    {
    case PixelFormat::Mono8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono8>::maximumValuePerChannel;
    case PixelFormat::Mono10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10>::maximumValuePerChannel;
    case PixelFormat::Mono12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12>::maximumValuePerChannel;
    case PixelFormat::Mono16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono16>::maximumValuePerChannel;
    case PixelFormat::Mono10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10p>::maximumValuePerChannel;
    case PixelFormat::Mono12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12p>::maximumValuePerChannel;
    case PixelFormat::RGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB8>::maximumValuePerChannel;
    case PixelFormat::RGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10>::maximumValuePerChannel;
    case PixelFormat::RGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB12>::maximumValuePerChannel;
    case PixelFormat::RGBa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa8>::maximumValuePerChannel;
    case PixelFormat::RGBa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa10>::maximumValuePerChannel;
    case PixelFormat::RGBa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa12>::maximumValuePerChannel;
    case PixelFormat::BGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR8>::maximumValuePerChannel;
    case PixelFormat::BGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10>::maximumValuePerChannel;
    case PixelFormat::BGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR12>::maximumValuePerChannel;
    case PixelFormat::BGRa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa8>::maximumValuePerChannel;
    case PixelFormat::BGRa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa10>::maximumValuePerChannel;
    case PixelFormat::BGRa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa12>::maximumValuePerChannel;
    case PixelFormat::RGB10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10p32>::maximumValuePerChannel;
    case PixelFormat::BGR10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10p32>::maximumValuePerChannel;
    case PixelFormat::BayerGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR8>::maximumValuePerChannel;
    case PixelFormat::BayerGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10>::maximumValuePerChannel;
    case PixelFormat::BayerGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12>::maximumValuePerChannel;
    case PixelFormat::BayerRG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG8>::maximumValuePerChannel;
    case PixelFormat::BayerRG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10>::maximumValuePerChannel;
    case PixelFormat::BayerRG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12>::maximumValuePerChannel;
    case PixelFormat::BayerGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB8>::maximumValuePerChannel;
    case PixelFormat::BayerGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10>::maximumValuePerChannel;
    case PixelFormat::BayerGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12>::maximumValuePerChannel;
    case PixelFormat::BayerBG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG8>::maximumValuePerChannel;
    case PixelFormat::BayerBG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10>::maximumValuePerChannel;
    case PixelFormat::BayerBG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12>::maximumValuePerChannel;
    case PixelFormat::BayerBG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10p>::maximumValuePerChannel;
    case PixelFormat::BayerBG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12p>::maximumValuePerChannel;
    case PixelFormat::BayerGB10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10p>::maximumValuePerChannel;
    case PixelFormat::BayerGB12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12p>::maximumValuePerChannel;
    case PixelFormat::BayerGR10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10p>::maximumValuePerChannel;
    case PixelFormat::BayerGR12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12p>::maximumValuePerChannel;
    case PixelFormat::BayerRG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10p>::maximumValuePerChannel;
    case PixelFormat::BayerRG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12p>::maximumValuePerChannel;
    case PixelFormat::Confidence8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence8>::maximumValuePerChannel;
    case PixelFormat::Confidence16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence16>::maximumValuePerChannel;
    case PixelFormat::Coord3D_C8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C8>::maximumValuePerChannel;
    case PixelFormat::Coord3D_C16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C16>::maximumValuePerChannel;
    case PixelFormat::BayerBG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>::maximumValuePerChannel;
    case PixelFormat::BayerBG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>::maximumValuePerChannel;
    case PixelFormat::BayerGB10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>::maximumValuePerChannel;
    case PixelFormat::BayerGB12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>::maximumValuePerChannel;
    case PixelFormat::BayerGR10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>::maximumValuePerChannel;
    case PixelFormat::BayerGR12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>::maximumValuePerChannel;
    case PixelFormat::BayerRG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>::maximumValuePerChannel;
    case PixelFormat::BayerRG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>::maximumValuePerChannel;
    case PixelFormat::Mono10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>::maximumValuePerChannel;
    case PixelFormat::Mono12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>::maximumValuePerChannel;
    case PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>::maximumValuePerChannel;
    case PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>::maximumValuePerChannel;
    case PixelFormat::YUV422_8_UYVY:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>::maximumValuePerChannel;
    default:
        throw InvalidParameterException(
            "The template does not match the data type of pixel format " + GetName() + "! Use float as template argument.");
    }
}
 
/* @cond HIDE_FROM_DOXYGEN */
template <typename T>
T PixelFormatInfo::GetMaximumValuePerChannel() const
{
    static_assert(true, "The given template type is not supported! Only size_t and float can be used.");
}
 
/* @endcond */
 
template <>
inline float PixelFormatInfo::GetMinimumValuePerChannel<float>() const
{
    switch (m_pixelFormat)
    {
    case peak::common::PixelFormat::Coord3D_ABC32f:
        return detail::PixelFormatInfo<peak::common::PixelFormat::Coord3D_ABC32f>::minimumValuePerChannel;
    case peak::common::PixelFormat::Coord3D_C32f:
        return detail::PixelFormatInfo<peak::common::PixelFormat::Coord3D_C32f>::minimumValuePerChannel;
    default:
        throw InvalidParameterException(
            "The template does not match the data type of pixel format " + GetName() + "! Use size_t as template argument.");
    }
}
 
template <>
inline size_t PixelFormatInfo::GetMinimumValuePerChannel<size_t>() const
{
    switch (m_pixelFormat)
    {
    case PixelFormat::Mono8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono8>::minimumValuePerChannel;
    case PixelFormat::Mono10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10>::minimumValuePerChannel;
    case PixelFormat::Mono12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12>::minimumValuePerChannel;
    case PixelFormat::Mono16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono16>::minimumValuePerChannel;
    case PixelFormat::Mono10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10p>::minimumValuePerChannel;
    case PixelFormat::Mono12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12p>::minimumValuePerChannel;
    case PixelFormat::RGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB8>::minimumValuePerChannel;
    case PixelFormat::RGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10>::minimumValuePerChannel;
    case PixelFormat::RGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB12>::minimumValuePerChannel;
    case PixelFormat::RGBa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa8>::minimumValuePerChannel;
    case PixelFormat::RGBa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa10>::minimumValuePerChannel;
    case PixelFormat::RGBa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa12>::minimumValuePerChannel;
    case PixelFormat::BGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR8>::minimumValuePerChannel;
    case PixelFormat::BGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10>::minimumValuePerChannel;
    case PixelFormat::BGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR12>::minimumValuePerChannel;
    case PixelFormat::BGRa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa8>::minimumValuePerChannel;
    case PixelFormat::BGRa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa10>::minimumValuePerChannel;
    case PixelFormat::BGRa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa12>::minimumValuePerChannel;
    case PixelFormat::RGB10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10p32>::minimumValuePerChannel;
    case PixelFormat::BGR10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10p32>::minimumValuePerChannel;
    case PixelFormat::BayerGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR8>::minimumValuePerChannel;
    case PixelFormat::BayerGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10>::minimumValuePerChannel;
    case PixelFormat::BayerGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12>::minimumValuePerChannel;
    case PixelFormat::BayerRG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG8>::minimumValuePerChannel;
    case PixelFormat::BayerRG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10>::minimumValuePerChannel;
    case PixelFormat::BayerRG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12>::minimumValuePerChannel;
    case PixelFormat::BayerGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB8>::minimumValuePerChannel;
    case PixelFormat::BayerGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10>::minimumValuePerChannel;
    case PixelFormat::BayerGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12>::minimumValuePerChannel;
    case PixelFormat::BayerBG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG8>::minimumValuePerChannel;
    case PixelFormat::BayerBG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10>::minimumValuePerChannel;
    case PixelFormat::BayerBG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12>::minimumValuePerChannel;
    case PixelFormat::BayerBG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10p>::minimumValuePerChannel;
    case PixelFormat::BayerBG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12p>::minimumValuePerChannel;
    case PixelFormat::BayerGB10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10p>::minimumValuePerChannel;
    case PixelFormat::BayerGB12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12p>::minimumValuePerChannel;
    case PixelFormat::BayerGR10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10p>::minimumValuePerChannel;
    case PixelFormat::BayerGR12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12p>::minimumValuePerChannel;
    case PixelFormat::BayerRG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10p>::minimumValuePerChannel;
    case PixelFormat::BayerRG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12p>::minimumValuePerChannel;
    case PixelFormat::Confidence8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence8>::minimumValuePerChannel;
    case PixelFormat::Confidence16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence16>::minimumValuePerChannel;
    case PixelFormat::Coord3D_C8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C8>::minimumValuePerChannel;
    case PixelFormat::Coord3D_C16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C16>::minimumValuePerChannel;
    case PixelFormat::BayerBG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>::minimumValuePerChannel;
    case PixelFormat::BayerBG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>::minimumValuePerChannel;
    case PixelFormat::BayerGB10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>::minimumValuePerChannel;
    case PixelFormat::BayerGB12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>::minimumValuePerChannel;
    case PixelFormat::BayerGR10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>::minimumValuePerChannel;
    case PixelFormat::BayerGR12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>::minimumValuePerChannel;
    case PixelFormat::BayerRG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>::minimumValuePerChannel;
    case PixelFormat::BayerRG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>::minimumValuePerChannel;
    case PixelFormat::Mono10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>::minimumValuePerChannel;
    case PixelFormat::Mono12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>::minimumValuePerChannel;
    case PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>::minimumValuePerChannel;
    case PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>::minimumValuePerChannel;
    case PixelFormat::YUV422_8_UYVY:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>::minimumValuePerChannel;
    default:
        throw InvalidParameterException(
            "The template does not match the data type of pixel format " + GetName() + "! Use float as template argument.");
    }
}
 
/* @cond HIDE_FROM_DOXYGEN */
template <typename T>
T PixelFormatInfo::GetMinimumValuePerChannel() const
{
    static_assert(true, "The given template type is not supported! Only size_t and float can be used.");
}
 
/* @endcond */
 
inline size_t PixelFormatInfo::GetStorageBitsPerPixel() const
{
    switch (m_pixelFormat)
    {
    case PixelFormat::Mono8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono8>::storageBitsPerPixel;
    case PixelFormat::Mono10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10>::storageBitsPerPixel;
    case PixelFormat::Mono12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12>::storageBitsPerPixel;
    case PixelFormat::Mono16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono16>::storageBitsPerPixel;
    case PixelFormat::Mono10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10p>::storageBitsPerPixel;
    case PixelFormat::Mono12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12p>::storageBitsPerPixel;
    case PixelFormat::RGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB8>::storageBitsPerPixel;
    case PixelFormat::RGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10>::storageBitsPerPixel;
    case PixelFormat::RGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB12>::storageBitsPerPixel;
    case PixelFormat::RGBa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa8>::storageBitsPerPixel;
    case PixelFormat::RGBa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa10>::storageBitsPerPixel;
    case PixelFormat::RGBa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa12>::storageBitsPerPixel;
    case PixelFormat::BGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR8>::storageBitsPerPixel;
    case PixelFormat::BGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10>::storageBitsPerPixel;
    case PixelFormat::BGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR12>::storageBitsPerPixel;
    case PixelFormat::BGRa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa8>::storageBitsPerPixel;
    case PixelFormat::BGRa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa10>::storageBitsPerPixel;
    case PixelFormat::BGRa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa12>::storageBitsPerPixel;
    case PixelFormat::RGB10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10p32>::storageBitsPerPixel;
    case PixelFormat::BGR10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10p32>::storageBitsPerPixel;
    case PixelFormat::BayerGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR8>::storageBitsPerPixel;
    case PixelFormat::BayerGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10>::storageBitsPerPixel;
    case PixelFormat::BayerGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12>::storageBitsPerPixel;
    case PixelFormat::BayerRG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG8>::storageBitsPerPixel;
    case PixelFormat::BayerRG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10>::storageBitsPerPixel;
    case PixelFormat::BayerRG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12>::storageBitsPerPixel;
    case PixelFormat::BayerGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB8>::storageBitsPerPixel;
    case PixelFormat::BayerGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10>::storageBitsPerPixel;
    case PixelFormat::BayerGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12>::storageBitsPerPixel;
    case PixelFormat::BayerBG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG8>::storageBitsPerPixel;
    case PixelFormat::BayerBG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10>::storageBitsPerPixel;
    case PixelFormat::BayerBG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12>::storageBitsPerPixel;
    case PixelFormat::BayerBG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10p>::storageBitsPerPixel;
    case PixelFormat::BayerBG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12p>::storageBitsPerPixel;
    case PixelFormat::BayerGB10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10p>::storageBitsPerPixel;
    case PixelFormat::BayerGB12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12p>::storageBitsPerPixel;
    case PixelFormat::BayerGR10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10p>::storageBitsPerPixel;
    case PixelFormat::BayerGR12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12p>::storageBitsPerPixel;
    case PixelFormat::BayerRG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10p>::storageBitsPerPixel;
    case PixelFormat::BayerRG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12p>::storageBitsPerPixel;
    case PixelFormat::Confidence8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence8>::storageBitsPerPixel;
    case PixelFormat::Confidence16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence16>::storageBitsPerPixel;
    case PixelFormat::Coord3D_C8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C8>::storageBitsPerPixel;
    case PixelFormat::Coord3D_C16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C16>::storageBitsPerPixel;
    case PixelFormat::Coord3D_C32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C32f>::storageBitsPerPixel;
    case PixelFormat::Coord3D_ABC32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_ABC32f>::storageBitsPerPixel;
    case PixelFormat::BayerBG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>::storageBitsPerPixel;
    case PixelFormat::BayerBG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>::storageBitsPerPixel;
    case PixelFormat::BayerGB10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>::storageBitsPerPixel;
    case PixelFormat::BayerGB12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>::storageBitsPerPixel;
    case PixelFormat::BayerGR10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>::storageBitsPerPixel;
    case PixelFormat::BayerGR12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>::storageBitsPerPixel;
    case PixelFormat::BayerRG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>::storageBitsPerPixel;
    case PixelFormat::BayerRG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>::storageBitsPerPixel;
    case PixelFormat::Mono10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>::storageBitsPerPixel;
    case PixelFormat::Mono12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>::storageBitsPerPixel;
    case PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>::storageBitsPerPixel;
    case PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>::storageBitsPerPixel;
    case PixelFormat::YUV422_8_UYVY:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>::storageBitsPerPixel;
    default:
        const auto pixelFormatValue = static_cast<typename std::underlying_type<decltype(m_pixelFormat)>::type>(m_pixelFormat);
        throw InvalidParameterException(
            "The given pixel format with the integer value of " + std::to_string(pixelFormatValue) + " is unknown!");
    }
}
 
inline size_t PixelFormatInfo::GetStorageBitsPerChannel() const
{
    switch (m_pixelFormat)
    {
    case PixelFormat::Mono8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono8>::storageBitsPerChannel;
    case PixelFormat::Mono10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10>::storageBitsPerChannel;
    case PixelFormat::Mono12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12>::storageBitsPerChannel;
    case PixelFormat::Mono16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono16>::storageBitsPerChannel;
    case PixelFormat::Mono10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10p>::storageBitsPerChannel;
    case PixelFormat::Mono12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12p>::storageBitsPerChannel;
    case PixelFormat::RGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB8>::storageBitsPerChannel;
    case PixelFormat::RGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10>::storageBitsPerChannel;
    case PixelFormat::RGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB12>::storageBitsPerChannel;
    case PixelFormat::RGBa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa8>::storageBitsPerChannel;
    case PixelFormat::RGBa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa10>::storageBitsPerChannel;
    case PixelFormat::RGBa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa12>::storageBitsPerChannel;
    case PixelFormat::BGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR8>::storageBitsPerChannel;
    case PixelFormat::BGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10>::storageBitsPerChannel;
    case PixelFormat::BGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR12>::storageBitsPerChannel;
    case PixelFormat::BGRa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa8>::storageBitsPerChannel;
    case PixelFormat::BGRa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa10>::storageBitsPerChannel;
    case PixelFormat::BGRa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa12>::storageBitsPerChannel;
    case PixelFormat::RGB10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10p32>::storageBitsPerChannel;
    case PixelFormat::BGR10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10p32>::storageBitsPerChannel;
    case PixelFormat::BayerGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR8>::storageBitsPerChannel;
    case PixelFormat::BayerGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10>::storageBitsPerChannel;
    case PixelFormat::BayerGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12>::storageBitsPerChannel;
    case PixelFormat::BayerRG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG8>::storageBitsPerChannel;
    case PixelFormat::BayerRG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10>::storageBitsPerChannel;
    case PixelFormat::BayerRG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12>::storageBitsPerChannel;
    case PixelFormat::BayerGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB8>::storageBitsPerChannel;
    case PixelFormat::BayerGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10>::storageBitsPerChannel;
    case PixelFormat::BayerGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12>::storageBitsPerChannel;
    case PixelFormat::BayerBG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG8>::storageBitsPerChannel;
    case PixelFormat::BayerBG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10>::storageBitsPerChannel;
    case PixelFormat::BayerBG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12>::storageBitsPerChannel;
    case PixelFormat::BayerBG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10p>::storageBitsPerChannel;
    case PixelFormat::BayerBG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12p>::storageBitsPerChannel;
    case PixelFormat::BayerGB10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10p>::storageBitsPerChannel;
    case PixelFormat::BayerGB12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12p>::storageBitsPerChannel;
    case PixelFormat::BayerGR10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10p>::storageBitsPerChannel;
    case PixelFormat::BayerGR12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12p>::storageBitsPerChannel;
    case PixelFormat::BayerRG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10p>::storageBitsPerChannel;
    case PixelFormat::BayerRG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12p>::storageBitsPerChannel;
    case PixelFormat::Confidence8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence8>::storageBitsPerChannel;
    case PixelFormat::Confidence16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence16>::storageBitsPerChannel;
    case PixelFormat::Coord3D_C8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C8>::storageBitsPerChannel;
    case PixelFormat::Coord3D_C16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C16>::storageBitsPerChannel;
    case PixelFormat::Coord3D_C32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C32f>::storageBitsPerChannel;
    case PixelFormat::Coord3D_ABC32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_ABC32f>::storageBitsPerChannel;
    case PixelFormat::BayerBG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>::storageBitsPerChannel;
    case PixelFormat::BayerBG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>::storageBitsPerChannel;
    case PixelFormat::BayerGB10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>::storageBitsPerChannel;
    case PixelFormat::BayerGB12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>::storageBitsPerChannel;
    case PixelFormat::BayerGR10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>::storageBitsPerChannel;
    case PixelFormat::BayerGR12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>::storageBitsPerChannel;
    case PixelFormat::BayerRG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>::storageBitsPerChannel;
    case PixelFormat::BayerRG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>::storageBitsPerChannel;
    case PixelFormat::Mono10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>::storageBitsPerChannel;
    case PixelFormat::Mono12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>::storageBitsPerChannel;
    case PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>::storageBitsPerChannel;
    case PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>::storageBitsPerChannel;
    case PixelFormat::YUV422_8_UYVY:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>::storageBitsPerChannel;
    default:
        const auto pixelFormatValue = static_cast<typename std::underlying_type<decltype(m_pixelFormat)>::type>(m_pixelFormat);
        throw InvalidParameterException(
            "The given pixel format with the integer value of " + std::to_string(pixelFormatValue) + " is unknown!");
    }
}
 
inline std::string PixelFormatInfo::GetName() const
{
    switch (m_pixelFormat)
    {
    case PixelFormat::Mono8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono8>::Name();
    case PixelFormat::Mono10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10>::Name();
    case PixelFormat::Mono12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12>::Name();
    case PixelFormat::Mono16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono16>::Name();
    case PixelFormat::Mono10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10p>::Name();
    case PixelFormat::Mono12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12p>::Name();
    case PixelFormat::RGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB8>::Name();
    case PixelFormat::RGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10>::Name();
    case PixelFormat::RGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB12>::Name();
    case PixelFormat::RGBa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa8>::Name();
    case PixelFormat::RGBa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa10>::Name();
    case PixelFormat::RGBa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa12>::Name();
    case PixelFormat::BGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR8>::Name();
    case PixelFormat::BGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10>::Name();
    case PixelFormat::BGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR12>::Name();
    case PixelFormat::BGRa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa8>::Name();
    case PixelFormat::BGRa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa10>::Name();
    case PixelFormat::BGRa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa12>::Name();
    case PixelFormat::RGB10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10p32>::Name();
    case PixelFormat::BGR10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10p32>::Name();
    case PixelFormat::BayerGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR8>::Name();
    case PixelFormat::BayerGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10>::Name();
    case PixelFormat::BayerGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12>::Name();
    case PixelFormat::BayerRG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG8>::Name();
    case PixelFormat::BayerRG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10>::Name();
    case PixelFormat::BayerRG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12>::Name();
    case PixelFormat::BayerGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB8>::Name();
    case PixelFormat::BayerGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10>::Name();
    case PixelFormat::BayerGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12>::Name();
    case PixelFormat::BayerBG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG8>::Name();
    case PixelFormat::BayerBG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10>::Name();
    case PixelFormat::BayerBG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12>::Name();
    case PixelFormat::BayerBG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10p>::Name();
    case PixelFormat::BayerBG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12p>::Name();
    case PixelFormat::BayerGB10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10p>::Name();
    case PixelFormat::BayerGB12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12p>::Name();
    case PixelFormat::BayerGR10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10p>::Name();
    case PixelFormat::BayerGR12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12p>::Name();
    case PixelFormat::BayerRG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10p>::Name();
    case PixelFormat::BayerRG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12p>::Name();
    case PixelFormat::Confidence8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence8>::Name();
    case PixelFormat::Confidence16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence16>::Name();
    case PixelFormat::Coord3D_C8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C8>::Name();
    case PixelFormat::Coord3D_C16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C16>::Name();
    case PixelFormat::Coord3D_C32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C32f>::Name();
    case PixelFormat::Coord3D_ABC32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_ABC32f>::Name();
    case PixelFormat::BayerBG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>::Name();
    case PixelFormat::BayerBG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>::Name();
    case PixelFormat::BayerGB10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>::Name();
    case PixelFormat::BayerGB12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>::Name();
    case PixelFormat::BayerGR10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>::Name();
    case PixelFormat::BayerGR12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>::Name();
    case PixelFormat::BayerRG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>::Name();
    case PixelFormat::BayerRG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>::Name();
    case PixelFormat::Mono10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>::Name();
    case PixelFormat::Mono12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>::Name();
    case PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>::Name();
    case PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>::Name();
    case PixelFormat::YUV422_8_UYVY:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>::Name();
    default:
        const auto pixelFormatValue = static_cast<typename std::underlying_type<decltype(m_pixelFormat)>::type>(m_pixelFormat);
        throw InvalidParameterException(
            "The given pixel format with the integer value of " + std::to_string(pixelFormatValue) + " is unknown!");
    }
}
 
inline std::vector<Channel> PixelFormatInfo::GetChannels() const
{
    switch (m_pixelFormat)
    {
    case PixelFormat::Mono8:
        return { detail::ChannelsVector<detail::PixelFormatInfo<peak::common::PixelFormat::Mono8>>() };
    case PixelFormat::Mono10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Mono10>>() };
    case PixelFormat::Mono12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Mono12>>() };
    case PixelFormat::Mono16:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Mono16>>() };
    case PixelFormat::Mono10p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Mono10p>>() };
    case PixelFormat::Mono12p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Mono12p>>() };
    case PixelFormat::RGB8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::RGB8>>() };
    case PixelFormat::RGB10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::RGB10>>() };
    case PixelFormat::RGB12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::RGB12>>() };
    case PixelFormat::RGBa8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::RGBa8>>() };
    case PixelFormat::RGBa10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::RGBa10>>() };
    case PixelFormat::RGBa12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::RGBa12>>() };
    case PixelFormat::BGR8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BGR8>>() };
    case PixelFormat::BGR10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BGR10>>() };
    case PixelFormat::BGR12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BGR12>>() };
    case PixelFormat::BGRa8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BGRa8>>() };
    case PixelFormat::BGRa10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BGRa10>>() };
    case PixelFormat::BGRa12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BGRa12>>() };
    case PixelFormat::RGB10p32:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::RGB10p32>>() };
    case PixelFormat::BGR10p32:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BGR10p32>>() };
    case PixelFormat::BayerGR8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR8>>() };
    case PixelFormat::BayerGR10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10>>() };
    case PixelFormat::BayerGR12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12>>() };
    case PixelFormat::BayerRG8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG8>>() };
    case PixelFormat::BayerRG10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10>>() };
    case PixelFormat::BayerRG12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12>>() };
    case PixelFormat::BayerGB8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB8>>() };
    case PixelFormat::BayerGB10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10>>() };
    case PixelFormat::BayerGB12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12>>() };
    case PixelFormat::BayerBG8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG8>>() };
    case PixelFormat::BayerBG10:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10>>() };
    case PixelFormat::BayerBG12:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12>>() };
    case PixelFormat::BayerBG10p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10p>>() };
    case PixelFormat::BayerBG12p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12p>>() };
    case PixelFormat::BayerGB10p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10p>>() };
    case PixelFormat::BayerGB12p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12p>>() };
    case PixelFormat::BayerGR10p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10p>>() };
    case PixelFormat::BayerGR12p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12p>>() };
    case PixelFormat::BayerRG10p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10p>>() };
    case PixelFormat::BayerRG12p:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12p>>() };
    case PixelFormat::Confidence8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Confidence8>>() };
    case PixelFormat::Confidence16:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Confidence16>>() };
    case PixelFormat::Coord3D_C8:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C8>>() };
    case PixelFormat::Coord3D_C16:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C16>>() };
    case PixelFormat::Coord3D_C32f:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C32f>>() };
    case PixelFormat::Coord3D_ABC32f:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_ABC32f>>() };
    case PixelFormat::BayerBG10g40IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>>() };
    case PixelFormat::BayerBG12g24IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>>() };
    case PixelFormat::BayerGB10g40IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>>() };
    case PixelFormat::BayerGB12g24IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>>() };
    case PixelFormat::BayerGR10g40IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>>() };
    case PixelFormat::BayerGR12g24IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>>() };
    case PixelFormat::BayerRG10g40IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>>() };
    case PixelFormat::BayerRG12g24IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>>() };
    case PixelFormat::Mono10g40IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>>() };
    case PixelFormat::Mono12g24IDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>>() };
    case PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>>() };
    case PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>>() };
    case PixelFormat::YUV422_8_UYVY:
        return { detail::ChannelsVector<peak::common::detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>>() };
    default:
        const auto pixelFormatValue = static_cast<typename std::underlying_type<decltype(m_pixelFormat)>::type>(m_pixelFormat);
        throw InvalidParameterException(
            "The given pixel format with the integer value of " + std::to_string(pixelFormatValue) + " is unknown!");
    }
}
 
inline size_t PixelFormatInfo::GetAllocatedBitsPerPixel() const
{
    switch (m_pixelFormat)
    {
    case PixelFormat::Mono8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono8>::allocatedBitsPerPixel;
    case PixelFormat::Mono10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10>::allocatedBitsPerPixel;
    case PixelFormat::Mono12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12>::allocatedBitsPerPixel;
    case PixelFormat::Mono16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono16>::allocatedBitsPerPixel;
    case PixelFormat::Mono10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10p>::allocatedBitsPerPixel;
    case PixelFormat::Mono12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12p>::allocatedBitsPerPixel;
    case PixelFormat::RGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB8>::allocatedBitsPerPixel;
    case PixelFormat::RGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10>::allocatedBitsPerPixel;
    case PixelFormat::RGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB12>::allocatedBitsPerPixel;
    case PixelFormat::RGBa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa8>::allocatedBitsPerPixel;
    case PixelFormat::RGBa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa10>::allocatedBitsPerPixel;
    case PixelFormat::RGBa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa12>::allocatedBitsPerPixel;
    case PixelFormat::BGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR8>::allocatedBitsPerPixel;
    case PixelFormat::BGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10>::allocatedBitsPerPixel;
    case PixelFormat::BGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR12>::allocatedBitsPerPixel;
    case PixelFormat::BGRa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa8>::allocatedBitsPerPixel;
    case PixelFormat::BGRa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa10>::allocatedBitsPerPixel;
    case PixelFormat::BGRa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa12>::allocatedBitsPerPixel;
    case PixelFormat::RGB10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10p32>::allocatedBitsPerPixel;
    case PixelFormat::BGR10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10p32>::allocatedBitsPerPixel;
    case PixelFormat::BayerGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR8>::allocatedBitsPerPixel;
    case PixelFormat::BayerGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10>::allocatedBitsPerPixel;
    case PixelFormat::BayerGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12>::allocatedBitsPerPixel;
    case PixelFormat::BayerRG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG8>::allocatedBitsPerPixel;
    case PixelFormat::BayerRG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10>::allocatedBitsPerPixel;
    case PixelFormat::BayerRG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12>::allocatedBitsPerPixel;
    case PixelFormat::BayerGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB8>::allocatedBitsPerPixel;
    case PixelFormat::BayerGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10>::allocatedBitsPerPixel;
    case PixelFormat::BayerGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12>::allocatedBitsPerPixel;
    case PixelFormat::BayerBG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG8>::allocatedBitsPerPixel;
    case PixelFormat::BayerBG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10>::allocatedBitsPerPixel;
    case PixelFormat::BayerBG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12>::allocatedBitsPerPixel;
    case PixelFormat::BayerBG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10p>::allocatedBitsPerPixel;
    case PixelFormat::BayerBG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12p>::allocatedBitsPerPixel;
    case PixelFormat::BayerGB10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10p>::allocatedBitsPerPixel;
    case PixelFormat::BayerGB12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12p>::allocatedBitsPerPixel;
    case PixelFormat::BayerGR10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10p>::allocatedBitsPerPixel;
    case PixelFormat::BayerGR12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12p>::allocatedBitsPerPixel;
    case PixelFormat::BayerRG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10p>::allocatedBitsPerPixel;
    case PixelFormat::BayerRG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12p>::allocatedBitsPerPixel;
    case PixelFormat::Confidence8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence8>::allocatedBitsPerPixel;
    case PixelFormat::Confidence16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence16>::allocatedBitsPerPixel;
    case PixelFormat::Coord3D_C8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C8>::allocatedBitsPerPixel;
    case PixelFormat::Coord3D_C16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C16>::allocatedBitsPerPixel;
    case PixelFormat::Coord3D_C32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C32f>::allocatedBitsPerPixel;
    case PixelFormat::Coord3D_ABC32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_ABC32f>::allocatedBitsPerPixel;
    case PixelFormat::BayerBG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>::allocatedBitsPerPixel;
    case PixelFormat::BayerBG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>::allocatedBitsPerPixel;
    case PixelFormat::BayerGB10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>::allocatedBitsPerPixel;
    case PixelFormat::BayerGB12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>::allocatedBitsPerPixel;
    case PixelFormat::BayerGR10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>::allocatedBitsPerPixel;
    case PixelFormat::BayerGR12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>::allocatedBitsPerPixel;
    case PixelFormat::BayerRG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>::allocatedBitsPerPixel;
    case PixelFormat::BayerRG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>::allocatedBitsPerPixel;
    case PixelFormat::Mono10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>::allocatedBitsPerPixel;
    case PixelFormat::Mono12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>::allocatedBitsPerPixel;
    case PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>::allocatedBitsPerPixel;
    case PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>::allocatedBitsPerPixel;
    case PixelFormat::YUV422_8_UYVY:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>::allocatedBitsPerPixel;
    default:
        const auto pixelFormatValue = static_cast<typename std::underlying_type<decltype(m_pixelFormat)>::type>(m_pixelFormat);
        throw InvalidParameterException(
            "The given pixel format with the integer value of " + std::to_string(pixelFormatValue) + " is unknown!");
    }
}
 
inline bool PixelFormatInfo::HasIntensityChannel() const
{
    return HasChannel(Channel::Intensity);
}
 
inline size_t PixelFormatInfo::GetChannelIndex(Channel channel) const
{
    const auto channels = this->GetChannels();
    const auto it = std::find(channels.cbegin(), channels.cend(), channel);
    if (it == channels.end())
    {
        throw InvalidParameterException("The given channel is not part of the pixel format " + GetName() + '!');
    }
 
    return static_cast<size_t>(std::distance(channels.begin(), it));
}
 
inline size_t PixelFormatInfo::GetNumberOfChannels() const
{
    return this->GetChannels().size();
}
 
inline bool PixelFormatInfo::IsSingleChannel() const
{
    return GetNumberOfChannels() == 1;
}
 
inline bool PixelFormatInfo::HasChannel(Channel channel) const
{
    const auto channels = this->GetChannels();
    return std::find(channels.cbegin(), channels.cend(), channel) != channels.cend();
}
 
inline peak::common::PixelFormat PixelFormatInfo::GetPixelFormat() const
{
    return m_pixelFormat;
}
 
inline size_t PixelFormatInfo::GetSizeInBytes(const Size& size) const
{
    switch (m_pixelFormat)
    {
    case PixelFormat::Mono8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono8>::GetSizeInBytes(size);
    case PixelFormat::Mono10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10>::GetSizeInBytes(size);
    case PixelFormat::Mono12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12>::GetSizeInBytes(size);
    case PixelFormat::Mono16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono16>::GetSizeInBytes(size);
    case PixelFormat::Mono10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10p>::GetSizeInBytes(size);
    case PixelFormat::Mono12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12p>::GetSizeInBytes(size);
    case PixelFormat::RGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB8>::GetSizeInBytes(size);
    case PixelFormat::RGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10>::GetSizeInBytes(size);
    case PixelFormat::RGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB12>::GetSizeInBytes(size);
    case PixelFormat::RGBa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa8>::GetSizeInBytes(size);
    case PixelFormat::RGBa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa10>::GetSizeInBytes(size);
    case PixelFormat::RGBa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGBa12>::GetSizeInBytes(size);
    case PixelFormat::BGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR8>::GetSizeInBytes(size);
    case PixelFormat::BGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10>::GetSizeInBytes(size);
    case PixelFormat::BGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR12>::GetSizeInBytes(size);
    case PixelFormat::BGRa8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa8>::GetSizeInBytes(size);
    case PixelFormat::BGRa10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa10>::GetSizeInBytes(size);
    case PixelFormat::BGRa12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGRa12>::GetSizeInBytes(size);
    case PixelFormat::RGB10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::RGB10p32>::GetSizeInBytes(size);
    case PixelFormat::BGR10p32:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BGR10p32>::GetSizeInBytes(size);
    case PixelFormat::BayerGR8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR8>::GetSizeInBytes(size);
    case PixelFormat::BayerGR10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10>::GetSizeInBytes(size);
    case PixelFormat::BayerGR12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12>::GetSizeInBytes(size);
    case PixelFormat::BayerRG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG8>::GetSizeInBytes(size);
    case PixelFormat::BayerRG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10>::GetSizeInBytes(size);
    case PixelFormat::BayerRG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12>::GetSizeInBytes(size);
    case PixelFormat::BayerGB8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB8>::GetSizeInBytes(size);
    case PixelFormat::BayerGB10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10>::GetSizeInBytes(size);
    case PixelFormat::BayerGB12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12>::GetSizeInBytes(size);
    case PixelFormat::BayerBG8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG8>::GetSizeInBytes(size);
    case PixelFormat::BayerBG10:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10>::GetSizeInBytes(size);
    case PixelFormat::BayerBG12:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12>::GetSizeInBytes(size);
    case PixelFormat::BayerBG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10p>::GetSizeInBytes(size);
    case PixelFormat::BayerBG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12p>::GetSizeInBytes(size);
    case PixelFormat::BayerGB10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10p>::GetSizeInBytes(size);
    case PixelFormat::BayerGB12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12p>::GetSizeInBytes(size);
    case PixelFormat::BayerGR10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10p>::GetSizeInBytes(size);
    case PixelFormat::BayerGR12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12p>::GetSizeInBytes(size);
    case PixelFormat::BayerRG10p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10p>::GetSizeInBytes(size);
    case PixelFormat::BayerRG12p:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12p>::GetSizeInBytes(size);
    case PixelFormat::Confidence8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence8>::GetSizeInBytes(size);
    case PixelFormat::Confidence16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Confidence16>::GetSizeInBytes(size);
    case PixelFormat::Coord3D_C8:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C8>::GetSizeInBytes(size);
    case PixelFormat::Coord3D_C16:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C16>::GetSizeInBytes(size);
    case PixelFormat::Coord3D_C32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_C32f>::GetSizeInBytes(size);
    case PixelFormat::Coord3D_ABC32f:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Coord3D_ABC32f>::GetSizeInBytes(size);
    case PixelFormat::BayerBG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG10g40IDS>::GetSizeInBytes(size);
    case PixelFormat::BayerBG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerBG12g24IDS>::GetSizeInBytes(size);
    case PixelFormat::BayerGB10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB10g40IDS>::GetSizeInBytes(size);
    case PixelFormat::BayerGB12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGB12g24IDS>::GetSizeInBytes(size);
    case PixelFormat::BayerGR10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR10g40IDS>::GetSizeInBytes(size);
    case PixelFormat::BayerGR12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerGR12g24IDS>::GetSizeInBytes(size);
    case PixelFormat::BayerRG10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG10g40IDS>::GetSizeInBytes(size);
    case PixelFormat::BayerRG12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::BayerRG12g24IDS>::GetSizeInBytes(size);
    case PixelFormat::Mono10g40IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono10g40IDS>::GetSizeInBytes(size);
    case PixelFormat::Mono12g24IDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::Mono12g24IDS>::GetSizeInBytes(size);
    case PixelFormat::YUV420_8_YY_UV_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_UV_SemiplanarIDS>::GetSizeInBytes(size);
    case PixelFormat::YUV420_8_YY_VU_SemiplanarIDS:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV420_8_YY_VU_SemiplanarIDS>::GetSizeInBytes(size);
    case PixelFormat::YUV422_8_UYVY:
        return peak::common::detail::PixelFormatInfo<PixelFormat::YUV422_8_UYVY>::GetSizeInBytes(size);
    default:
        const auto pixelFormatValue = static_cast<typename std::underlying_type<decltype(m_pixelFormat)>::type>(m_pixelFormat);
        throw InvalidParameterException(
            "The given pixel format with the integer value of " + std::to_string(pixelFormatValue) + " is unknown!");
    }
}
 
 
} // namespace common 
} // namespace peak