peak_ipl_pixel_format.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_ipl/backend/peak_ipl_backend.h>
#include <peak_ipl/exception/peak_ipl_exception.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>
 
#include <cstddef>
#include <cstdint>
 
namespace peak
{
namespace ipl
{
 
class PixelFormat final
{
public:
    PixelFormat()
        : m_name(peak::ipl::PixelFormatName::Invalid)
    {}
 
    PixelFormat(peak::ipl::PixelFormatName name); // NOLINT (note: implicitly used by Image...)
 
 
    ~PixelFormat() = default;
 
    PixelFormat(PixelFormat&& other) = default;
 
    PixelFormat(const PixelFormat& other) = default;
 
    PixelFormat& operator=(const PixelFormat& other) = default;
 
    PixelFormat& operator=(PixelFormat&& other) = default;
 
    PEAK_IPL_NO_DISCARD std::string Name() const
    {
        return peak::ipl::ToString(m_name);
    }
 
    PEAK_IPL_NO_DISCARD peak::ipl::PixelFormatName PixelFormatName() const
    {
        return m_name;
    }
 
    PEAK_IPL_NO_DISCARD bool operator==(const PixelFormat& other) const
    {
        return m_name == other.m_name;
    }
 
    PEAK_IPL_NO_DISCARD size_t NumSignificantBitsPerChannel() const;
 
    PEAK_IPL_NO_DISCARD size_t NumStorageBitsPerChannel() const;
 
    PEAK_IPL_NO_DISCARD size_t NumChannels() const;
 
    PEAK_IPL_NO_DISCARD uint32_t MaximumValuePerChannel() const;
 
    PEAK_IPL_NO_DISCARD size_t NumSignificantBitsPerPixel() const;
 
    PEAK_IPL_NO_DISCARD size_t NumStorageBitsPerPixel() const;
 
 
    PEAK_IPL_NO_DISCARD peak::ipl::Endianness Endianness() const;
 
    PEAK_IPL_NO_DISCARD uint64_t CalculateStorageSizeOfPixels(uint64_t numPixels) const;
 
    PEAK_IPL_NO_DISCARD bool IsPacked() const;
 
    PEAK_IPL_NO_DISCARD bool IsBayered() const;
 
    PEAK_IPL_NO_DISCARD bool IsYUV() const;
 
    PEAK_IPL_NO_DISCARD bool IsCoord3D() const;
 
    PEAK_IPL_NO_DISCARD bool IsFloat() const;
 
    PEAK_IPL_NO_DISCARD peak::ipl::BayerPattern BayerPattern() const;
    
 
private:
    peak::ipl::PixelFormatName m_name{};
};
 
inline PixelFormat::PixelFormat(peak::ipl::PixelFormatName name)
    : m_name(name)
{}
 
inline size_t PixelFormat::NumSignificantBitsPerChannel() const
{
    size_t numSignificantBitsPerChannel = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumSignificantBitsPerChannel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numSignificantBitsPerChannel);
    });
 
    return numSignificantBitsPerChannel;
}
 
inline size_t PixelFormat::NumStorageBitsPerChannel() const
{
    size_t numStorageBitsPerChannel = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumStorageBitsPerChannel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numStorageBitsPerChannel);
    });
 
    return numStorageBitsPerChannel;
}
 
inline size_t PixelFormat::NumChannels() const
{
    size_t numChannels = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumChannels(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numChannels);
    });
 
    return numChannels;
}
 
inline uint32_t PixelFormat::MaximumValuePerChannel() const
{
    uint32_t maximumValuePerChannel = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetMaximumValuePerChannel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &maximumValuePerChannel);
    });
 
    return maximumValuePerChannel;
}
 
inline size_t PixelFormat::NumSignificantBitsPerPixel() const
{
    size_t numSignificantBitsPerPixel = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumSignificantBitsPerPixel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numSignificantBitsPerPixel);
    });
 
    return numSignificantBitsPerPixel;
}
 
inline size_t PixelFormat::NumStorageBitsPerPixel() const
{
    size_t numStorageBitsPerPixel = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetNumStorageBitsPerPixel(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), &numStorageBitsPerPixel);
    });
 
    return numStorageBitsPerPixel;
}
 
inline peak::ipl::Endianness PixelFormat::Endianness() const
{
    peak::ipl::Endianness endianness = peak::ipl::Endianness::LittleEndian;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetEndianness(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_ENDIANNESS*>(&endianness));
    });
 
    return endianness;
}
 
inline uint64_t PixelFormat::CalculateStorageSizeOfPixels(uint64_t numPixels) const
{
    uint64_t sizeOfPixels = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_CalculateStorageSizeOfPixels(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), numPixels, &sizeOfPixels);
    });
 
    return sizeOfPixels;
}
 
inline bool PixelFormat::IsPacked() const
{
    bool isPacked = false;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_IsPacked(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BOOL8*>(&isPacked));
    });
 
    return isPacked;
}
 
inline bool PixelFormat::IsBayered() const
{
    bool isPacked = false;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_IsBayered(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BOOL8*>(&isPacked));
    });
 
    return isPacked;
}
 
inline bool PixelFormat::IsYUV() const
{
    auto result{ false };
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_IsYUV(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BOOL8*>(&result));
    });
 
    return result;
}
 
inline bool PixelFormat::IsCoord3D() const
{
    auto result{ false };
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_IsCoord3D(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BOOL8*>(&result));
    });
 
    return result;
}
 
inline bool PixelFormat::IsFloat() const
{
    auto result{ false };
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_IsFloat(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BOOL8*>(&result));
    });
 
    return result;
}
 
inline peak::ipl::BayerPattern PixelFormat::BayerPattern() const
{
    peak::ipl::BayerPattern pattern = peak::ipl::BayerPattern::Unknown;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_PixelFormat_GetBayerPattern(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(m_name), reinterpret_cast<PEAK_IPL_BAYER_PATTERN*>(&pattern));
    });
 
    return pattern;
}
 
} /* namespace ipl */
} /* namespace peak */