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) = delete;
    GammaCorrector& operator=(const GammaCorrector& other) = delete;
    GammaCorrector(GammaCorrector&& other) noexcept;
    GammaCorrector& operator=(GammaCorrector&& other) noexcept;

    void SetGammaCorrectionValue(float gammaValue);

    float GammaCorrectionValue() const;

    float GammaCorrectionMin() const;

    float GammaCorrectionMax() const;

    bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;

    void ProcessInPlace(Image& image) const;

    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::operator=(GammaCorrector&& other) noexcept
{
    if (this != &other)
    {
        (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 */