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;

    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 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 */