peak_ipl_lut.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_image.hpp>
#include <peak_ipl/types/peak_ipl_pixel_format.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>

 
namespace peak
{
namespace ipl
{
 
class Image;

class Lut final
{
public:
    enum class Channel
    {
        Red = 0,
        Green = 1,
        Blue = 2,
        All = 3
    };

    enum class Selector
    {
        Lut_8Bit = 0,
        Lut_10Bit = 1,
        Lut_12Bit = 2,
        Lut_16Bit = 3
    };

    enum class Preset
    {
        Identity = 0,
        Inverse = 1,
        Jet = 2,
        Hot = 3,
        Rainbow = 4,
        OnlyRed = 5,
        OnlyGreen = 6,
        OnlyBlue = 7,
        DigitalGain2 = 8,
        DigitalBlack25Percent = 9,
        Binarize = 10
    };

    Lut();
    
    ~Lut();

    Lut(const Lut& other);

    Lut& operator=(const Lut& other);

    Lut(Lut&& other) noexcept;

    Lut& operator=(Lut&& other) noexcept;

    PEAK_IPL_NO_DISCARD uint32_t LutValue(Selector selector, Channel channel, uint32_t index) const;

    void SetLutValue(Selector selector, Channel channel, uint32_t index, uint32_t value);

    PEAK_IPL_NO_DISCARD std::vector<uint32_t> AllLutValues(Selector selector, Channel channel) const;

    void SetAllLutValues(Selector selector, Channel channel, const std::vector<uint32_t>& values);

    void SetLutPreset(Selector selector, Preset preset);

    PEAK_IPL_NO_DISCARD bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;

    void ProcessInPlace(Image& image) const;

    PEAK_IPL_NO_DISCARD Image Process(const Image& inputImage) const;
 
private:
    PEAK_IPL_LUT_HANDLE m_backendHandle{};
};
 
inline Lut::Lut()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_Construct(&m_backendHandle); });
}
 
inline Lut::~Lut()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_Destruct(m_backendHandle);
    }
}
 
inline Lut::Lut(Lut&& other) noexcept
{
    *this = std::move(other);
}
 
inline Lut::Lut(const Lut& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline Lut& Lut::operator=(const Lut& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline Lut& Lut::operator=(Lut&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_Destruct(m_backendHandle);
        }
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }
 
    return *this;
}
 
inline uint32_t Lut::LutValue(Selector selector, Channel channel, uint32_t index) const
{
    uint32_t value = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_GetLutValue(
            m_backendHandle, static_cast<PEAK_IPL_LUT_SELECTOR>(selector), static_cast<PEAK_IPL_LUT_CHANNEL>(channel), index, &value);
    });
 
    return value;
}
 
inline void Lut::SetLutValue(Selector selector, Channel channel, uint32_t index, uint32_t value)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_SetLutValue(m_backendHandle,
            static_cast<PEAK_IPL_LUT_SELECTOR>(selector), static_cast<PEAK_IPL_LUT_CHANNEL>(channel), index, value);
    });
}
 
inline std::vector<uint32_t> Lut::AllLutValues(Selector selector, Channel channel) const
{
    size_t numLutValues = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_GetAllLutValues(m_backendHandle,
            static_cast<PEAK_IPL_LUT_SELECTOR>(selector), static_cast<PEAK_IPL_LUT_CHANNEL>(channel), nullptr, &numLutValues);
    });
 
    std::vector<uint32_t> vector(numLutValues);
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_GetAllLutValues(m_backendHandle,
            static_cast<PEAK_IPL_LUT_SELECTOR>(selector), static_cast<PEAK_IPL_LUT_CHANNEL>(channel), 
            reinterpret_cast<uint32_t*>(vector.data()), &numLutValues);
    });
 
    return vector;
}
 
inline void Lut::SetAllLutValues(Selector selector, Channel channel, const std::vector<uint32_t>& vector)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_SetAllLutValues(m_backendHandle,
            static_cast<PEAK_IPL_LUT_SELECTOR>(selector), static_cast<PEAK_IPL_LUT_CHANNEL>(channel),
            reinterpret_cast<const uint32_t*>(vector.data()), vector.size());
    });
}
 
inline void Lut::SetLutPreset(Selector selector, Preset preset)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_SetLutPreset(
            m_backendHandle, static_cast<PEAK_IPL_LUT_SELECTOR>(selector), static_cast<PEAK_IPL_LUT_PRESET>(preset));
    });
}
 
inline bool Lut::IsPixelFormatSupported(PixelFormatName pixelFormatName) const
{
    PEAK_IPL_BOOL8 isPixelFormatSupported = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_IsPixelFormatSupported(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormatName),
            reinterpret_cast<PEAK_IPL_BOOL8*>(&isPixelFormatSupported));
    });
 
    return isPixelFormatSupported > 0;
}
 
inline void Lut::ProcessInPlace(Image& image) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_ProcessInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image));
    });
}
 
inline Image Lut::Process(const Image& inputImage) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Lut_Process(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
} /* namespace ipl */
} /* namespace peak */