peak_ipl_gamma_corrector.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 GammaCorrector final
{
public:
    GammaCorrector();
    
    ~GammaCorrector();

    GammaCorrector(const GammaCorrector& other);

    GammaCorrector& operator=(const GammaCorrector& other);

    GammaCorrector(GammaCorrector&& other) noexcept;

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

    void SetGammaCorrectionValue(float gammaValue);

    PEAK_IPL_NO_DISCARD float GammaCorrectionValue() const;

    PEAK_IPL_NO_DISCARD float GammaCorrectionMin() const;

    PEAK_IPL_NO_DISCARD float GammaCorrectionMax() const;

    void SetDigitalBlack(float digitalBlackValue);

    PEAK_IPL_NO_DISCARD float DigitalBlack() const;

    PEAK_IPL_NO_DISCARD float DigitalBlackMin() const;

    PEAK_IPL_NO_DISCARD float DigitalBlackMax() const;

    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_GAMMA_CORRECTOR_HANDLE m_backendHandle{};
};
 
inline GammaCorrector::GammaCorrector()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_Construct(&m_backendHandle); });
}
 
inline GammaCorrector::~GammaCorrector()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_Destruct(m_backendHandle);
    }
}
 
inline GammaCorrector::GammaCorrector(GammaCorrector&& other) noexcept
{
    *this = std::move(other);
}
 
inline GammaCorrector::GammaCorrector(const GammaCorrector& other)
{
 
 
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline GammaCorrector& GammaCorrector::operator=(const GammaCorrector& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline GammaCorrector& GammaCorrector::operator=(GammaCorrector&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_Destruct(m_backendHandle);
        }
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }
 
    return *this;
}
 
inline void GammaCorrector::SetGammaCorrectionValue(float gammaValue)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_SetGammaCorrectionValue(
            m_backendHandle, reinterpret_cast<float*>(&gammaValue));
    });
}
 
inline float GammaCorrector::GammaCorrectionValue() const
{
    float gammaValue;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_GetGammaCorrectionValue(
            m_backendHandle, reinterpret_cast<float*>(&gammaValue));
    });
 
    return gammaValue;
}
 
inline float GammaCorrector::GammaCorrectionMin() const
{
    float gammaMin;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_GetGammaCorrectionMin(
            m_backendHandle, reinterpret_cast<float*>(&gammaMin));
    });
 
    return gammaMin;
}
 
inline float GammaCorrector::GammaCorrectionMax() const
{
    float gammaMax;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_GetGammaCorrectionMax(
            m_backendHandle, reinterpret_cast<float*>(&gammaMax));
    });
 
    return gammaMax;
}
 
inline void GammaCorrector::SetDigitalBlack(float digitalBlackValue)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_SetDigitalBlack(
            m_backendHandle, reinterpret_cast<float*>(&digitalBlackValue));
    });
}
 
inline float GammaCorrector::DigitalBlack() const
{
    float digitalBlackValue;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_GetDigitalBlack(
            m_backendHandle, reinterpret_cast<float*>(&digitalBlackValue));
    });
 
    return digitalBlackValue;
}
 
inline float GammaCorrector::DigitalBlackMin() const
{
    float digitalBlackMin;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_GetDigitalBlackMin(
            m_backendHandle, reinterpret_cast<float*>(&digitalBlackMin));
    });
 
    return digitalBlackMin;
}
 
inline float GammaCorrector::DigitalBlackMax() const
{
    float digitalBlackMax;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_GetDigitalBlackMax(
            m_backendHandle, reinterpret_cast<float*>(&digitalBlackMax));
    });
 
    return digitalBlackMax;
}
 
inline bool GammaCorrector::IsPixelFormatSupported(PixelFormatName pixelFormatName) const
{
    PEAK_IPL_BOOL8 isPixelFormatSupported = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_GetIsPixelFormatSupported(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormatName),
            reinterpret_cast<PEAK_IPL_BOOL8*>(&isPixelFormatSupported));
    });
 
    return isPixelFormatSupported > 0;
}
 
inline void GammaCorrector::ProcessInPlace(Image& image) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_ProcessInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image));
    });
}
 
inline Image GammaCorrector::Process(const Image& inputImage) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_GammaCorrector_Process(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
} /* namespace ipl */
} /* namespace peak */