peak_icv_gain_module.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/pipeline/modules/peak_common_igain_module.hpp>
#include <peak_common/types/peak_common_interval.hpp>
#include <peak_icv/pipeline/detail/peak_icv_pipeline_utils.hpp>
#include <peak_icv/types/peak_icv_image.hpp>
#include <peak_icv_c/algorithms/preprocessing/peak_icv_gain.h>
 
namespace peak
{
namespace pipeline
{
 
namespace detail
{
 
class GainModule final : public modules::IGain
{
public:
    GainModule();
 
    ~GainModule() override;
 
    GainModule(const GainModule& other) = delete;
 
    GainModule(GainModule&& other) noexcept;
 
    GainModule& operator=(const GainModule& other) = delete;
 
    GainModule& operator=(GainModule&& other) noexcept;
 
    void SetEnabled(bool enabled) override;
 
    PEAK_COMMON_NO_DISCARD bool IsEnabled() const override;
 
    void Serialize(peak::common::serialization::IArchive& archive) const override;
 
 
    void Deserialize(const peak::common::serialization::IArchive& archive) override;
 
    PEAK_COMMON_NO_DISCARD const char* GetType() const override;
 
    void ResetToDefault() override;
 
    void SetMaster(float value) override;
 
    PEAK_COMMON_NO_DISCARD float GetMaster() const override;
 
    void SetRed(float value) override;
 
    PEAK_COMMON_NO_DISCARD float GetRed() const override;
 
    void SetGreen(float value) override;
 
    PEAK_COMMON_NO_DISCARD float GetGreen() const override;
 
    void SetBlue(float value) override;
 
    PEAK_COMMON_NO_DISCARD float GetBlue() const override;
 
    PEAK_COMMON_NO_DISCARD peak::common::IntervalF GetRange() const;
 
    PEAK_COMMON_NO_DISCARD peak::icv::Image Process(const peak::icv::Image& input) const;
 
    PEAK_COMMON_NO_DISCARD peak::common::Any Process(const peak::common::Any& input) const override;
 
private:
    void Apply(peak_icv_gain_type type, float value) const;
 
    PEAK_COMMON_NO_DISCARD float Fetch(peak_icv_gain_type type) const;
 
    static constexpr int moduleVersion = 1;
    static constexpr auto masterGainKey = "MasterGain";
    static constexpr auto redGainKey = "RedGain";
    static constexpr auto greenGainKey = "GreenGain";
    static constexpr auto blueGainKey = "BlueGain";
 
    peak_icv_gain_handle m_handle{};
    bool m_enabled{ true };
};
 
inline GainModule::GainModule()
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&]() {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Gain_Create(&m_handle);
    });
}
 
inline GainModule::~GainModule()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Gain_Destroy(m_handle);
    }
}
 
inline GainModule::GainModule(GainModule&& other) noexcept
{
    m_handle = std::exchange(other.m_handle, nullptr);
    m_enabled = other.m_enabled;
}
 
inline GainModule& GainModule::operator=(GainModule&& other) noexcept
{
    if (this != &other)
    {
        if (m_handle != nullptr)
        {
            peak::icv::detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Gain_Destroy(m_handle);
            });
        }
 
        m_handle = std::exchange(other.m_handle, nullptr);
        m_enabled = other.m_enabled;
    }
 
    return *this;
}
 
inline void GainModule::SetEnabled(const bool enabled)
{
    m_enabled = enabled;
}
 
inline bool GainModule::IsEnabled() const
{
    return m_enabled;
}
 
inline void GainModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    archive.SetInt("Version", moduleVersion);
    archive.SetBool("Enabled", IsEnabled());
 
    archive.SetDouble(masterGainKey, Fetch(PEAK_ICV_GAIN_TYPE_MASTER));
    archive.SetDouble(redGainKey, Fetch(PEAK_ICV_GAIN_TYPE_RED));
    archive.SetDouble(greenGainKey, Fetch(PEAK_ICV_GAIN_TYPE_GREEN));
    archive.SetDouble(blueGainKey, Fetch(PEAK_ICV_GAIN_TYPE_BLUE));
}
 
inline void GainModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
    detail::ValidateVersion(version, GetType());
 
    SetEnabled(archive.GetBool("Enabled"));
 
    Apply(PEAK_ICV_GAIN_TYPE_MASTER, static_cast<float>(archive.GetDouble(masterGainKey)));
 
    Apply(PEAK_ICV_GAIN_TYPE_RED, static_cast<float>(archive.GetDouble(redGainKey)));
    Apply(PEAK_ICV_GAIN_TYPE_GREEN, static_cast<float>(archive.GetDouble(greenGainKey)));
    Apply(PEAK_ICV_GAIN_TYPE_BLUE, static_cast<float>(archive.GetDouble(blueGainKey)));
}
 
inline const char* GainModule::GetType() const
{
    return "Gain";
}
 
inline void GainModule::ResetToDefault()
{
    Apply(PEAK_ICV_GAIN_TYPE_MASTER, 1.0F);
 
    Apply(PEAK_ICV_GAIN_TYPE_RED, 1.0F);
    Apply(PEAK_ICV_GAIN_TYPE_GREEN, 1.0F);
    Apply(PEAK_ICV_GAIN_TYPE_BLUE, 1.0F);
}
 
inline void GainModule::SetMaster(const float value)
{
    Apply(PEAK_ICV_GAIN_TYPE_MASTER, value);
}
 
inline float GainModule::GetMaster() const
{
    return Fetch(PEAK_ICV_GAIN_TYPE_MASTER);
}
 
inline void GainModule::SetRed(const float value)
{
    Apply(PEAK_ICV_GAIN_TYPE_RED, value);
}
 
inline float GainModule::GetRed() const
{
    return Fetch(PEAK_ICV_GAIN_TYPE_RED);
}
 
inline void GainModule::SetGreen(const float value)
{
    Apply(PEAK_ICV_GAIN_TYPE_GREEN, value);
}
 
inline float GainModule::GetGreen() const
{
    return Fetch(PEAK_ICV_GAIN_TYPE_GREEN);
}
 
inline void GainModule::SetBlue(const float value)
{
    Apply(PEAK_ICV_GAIN_TYPE_BLUE, value);
}
 
inline float GainModule::GetBlue() const
{
    return Fetch(PEAK_ICV_GAIN_TYPE_BLUE);
}
 
inline peak::common::IntervalF GainModule::GetRange() const
{
    peak_common_interval_f cRange{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Gain_GetRange(m_handle, &cRange);
    });
 
    return { cRange.minimum, cRange.maximum };
}
 
inline peak::icv::Image GainModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any GainModule::Process(const peak::common::Any& input) const
{
    auto needsProcessing = [&] {
        bool value{};
        peak::icv::detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Gain_NeedsProcessing(m_handle, &value);
        });
        return value;
    };
 
    if (!IsEnabled() || !needsProcessing())
    {
        return input;
    }
 
    const auto& inputImage = input.AnyCast<peak::icv::Image>();
    auto* const inputImageHandle = peak::common::detail::BackendAccessor<peak::icv::Image>::BackendHandle(inputImage);
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Gain_ProcessInplace(m_handle, inputImageHandle);
    });
 
    return peak::common::Any{ inputImage };
}
 
inline void GainModule::Apply(peak_icv_gain_type type, const float value) const
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Gain_SetValue(m_handle, type, value);
    });
}
 
inline float GainModule::Fetch(peak_icv_gain_type type) const
{
    float value{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_Gain_GetValue(m_handle, type, &value);
    });
    return value;
}
 
} // namespace detail
} // namespace pipeline 
} // namespace peak