peak_ipl_gain.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
{
class GainBackendAccessor;
}

 
namespace peak
{
namespace ipl
{

class Gain final
{
public:
    Gain();
    
    ~Gain();

    Gain(const Gain& other);

    Gain& operator=(const Gain& other);

    Gain(Gain&& other) noexcept;

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

    void SetMasterGainValue(float masterGainValue);

    PEAK_IPL_NO_DISCARD float MasterGainValue() const;

    PEAK_IPL_NO_DISCARD float MasterGainMin() const;

    PEAK_IPL_NO_DISCARD float MasterGainMax() const;

    void SetRedGainValue(float redGainValue);

    PEAK_IPL_NO_DISCARD float RedGainValue() const;

    PEAK_IPL_NO_DISCARD float RedGainMin() const;

    PEAK_IPL_NO_DISCARD float RedGainMax() const;

    void SetGreenGainValue(float greenGainValue);

    PEAK_IPL_NO_DISCARD float GreenGainValue() const;

    PEAK_IPL_NO_DISCARD float GreenGainMin() const;

    PEAK_IPL_NO_DISCARD float GreenGainMax() const;

    void SetBlueGainValue(float blueGainValue);

    PEAK_IPL_NO_DISCARD float BlueGainValue() const;

    PEAK_IPL_NO_DISCARD float BlueGainMin() const;

    PEAK_IPL_NO_DISCARD float BlueGainMax() 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:
    friend GainBackendAccessor;
    explicit Gain(PEAK_IPL_GAIN_HANDLE gainHandle) noexcept;
    PEAK_IPL_GAIN_HANDLE m_backendHandle{};
};
 
} /* namespace ipl */
} /* namespace peak */
 
namespace
{

class GainBackendAccessor
{
public:
    static PEAK_IPL_GAIN_HANDLE BackendHandle(const peak::ipl::Gain& gain)
    {
        return gain.m_backendHandle;
    }

    static peak::ipl::Gain CreateGain(PEAK_IPL_GAIN_HANDLE gainHandle)
    {
        return peak::ipl::Gain(gainHandle);
    }
};
 
} /* namespace */
 
namespace peak
{
namespace ipl
{
inline Gain::Gain()
{    
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_Construct(&m_backendHandle); });
}
 
inline Gain::Gain(PEAK_IPL_GAIN_HANDLE gainHandle) noexcept
    : m_backendHandle{ gainHandle }
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_Acquire(m_backendHandle); });
}
 
inline Gain::~Gain()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_Destruct(m_backendHandle);
    }
}
 
inline Gain::Gain(Gain&& other) noexcept
{
    *this = std::move(other);
}
 
inline Gain::Gain(const Gain& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline Gain& Gain::operator=(const Gain& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline Gain& Gain::operator=(Gain&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_Destruct(m_backendHandle);
        }
 
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }
 
    return *this;
}
inline void Gain::SetMasterGainValue(float masterGainValue)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_SetMasterGainValue(
            m_backendHandle, reinterpret_cast<float*>(&masterGainValue));
    });
}
inline float Gain::MasterGainValue() const
{
    float masterGainValue;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetMasterGainValue(
            m_backendHandle, reinterpret_cast<float*>(&masterGainValue));
    });
 
    return masterGainValue;
}
inline float Gain::MasterGainMin() const
{
    float masterGainMin;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetMasterGainMin(
            m_backendHandle, reinterpret_cast<float*>(&masterGainMin));
    });
 
    return masterGainMin;
}
inline float Gain::MasterGainMax() const
{
    float masterGainMax;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetMasterGainMax(
            m_backendHandle, reinterpret_cast<float*>(&masterGainMax));
    });
 
    return masterGainMax;
}
inline void Gain::SetRedGainValue(float redGainValue)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_SetRedGainValue(
            m_backendHandle, reinterpret_cast<float*>(&redGainValue));
    });
}
inline float Gain::RedGainValue() const
{
    float redGainValue;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetRedGainValue(
            m_backendHandle, reinterpret_cast<float*>(&redGainValue));
    });
 
    return redGainValue;
}
inline float Gain::RedGainMin() const
{
    float redGainMin;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetRedGainMin(m_backendHandle, reinterpret_cast<float*>(&redGainMin));
    });
 
    return redGainMin;
}
inline float Gain::RedGainMax() const
{
    float redGainMax;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetRedGainMax(m_backendHandle, reinterpret_cast<float*>(&redGainMax));
    });
 
    return redGainMax;
}
inline void Gain::SetGreenGainValue(float greenGainValue)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_SetGreenGainValue(
            m_backendHandle, reinterpret_cast<float*>(&greenGainValue));
    });
}
inline float Gain::GreenGainValue() const
{
    float greenGainValue;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetGreenGainValue(
            m_backendHandle, reinterpret_cast<float*>(&greenGainValue));
    });
 
    return greenGainValue;
}
inline float Gain::GreenGainMin() const
{
    float greenGainMin;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetGreenGainMin(
            m_backendHandle, reinterpret_cast<float*>(&greenGainMin));
    });
 
    return greenGainMin;
}
inline float Gain::GreenGainMax() const
{
    float greenGainMax;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetGreenGainMax(
            m_backendHandle, reinterpret_cast<float*>(&greenGainMax));
    });
 
    return greenGainMax;
}
inline void Gain::SetBlueGainValue(float blueGainValue)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_SetBlueGainValue(
            m_backendHandle, reinterpret_cast<float*>(&blueGainValue));
    });
}
inline float Gain::BlueGainValue() const
{
    float blueGainValue;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetBlueGainValue(
            m_backendHandle, reinterpret_cast<float*>(&blueGainValue));
    });
 
    return blueGainValue;
}
inline float Gain::BlueGainMin() const
{
    float blueGainMin;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetBlueGainMin(
            m_backendHandle, reinterpret_cast<float*>(&blueGainMin));
    });
 
    return blueGainMin;
}
inline float Gain::BlueGainMax() const
{
    float blueGainMax;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetBlueGainMax(
            m_backendHandle, reinterpret_cast<float*>(&blueGainMax));
    });
 
    return blueGainMax;
}
inline bool Gain::IsPixelFormatSupported(PixelFormatName pixelFormatName) const
{
    PEAK_IPL_BOOL8 isPixelFormatSupported = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_GetIsPixelFormatSupported(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormatName),
            reinterpret_cast<PEAK_IPL_BOOL8*>(&isPixelFormatSupported));
    });
 
    return isPixelFormatSupported > 0;
}
inline void Gain::ProcessInPlace(Image& image) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_ProcessInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image));
    });
}
inline Image Gain::Process(const Image& inputImage) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Gain_Process(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
} /* namespace ipl */
} /* namespace peak */