peak_icv_tone_curve_correction_module.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/pipeline/modules/peak_common_imodule.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_tone_curve_correction.h>
 
namespace peak
{
namespace pipeline
{
namespace features
{
class GammaFeature;
class DigitalBlackFeature;
} // namespace features
 
namespace detail
{
 
class ToneCurveCorrectionModule : public modules::IModule
{
public:
    ToneCurveCorrectionModule();
 
    ~ToneCurveCorrectionModule() override;
 
    ToneCurveCorrectionModule(const ToneCurveCorrectionModule& other) = delete;
 
    ToneCurveCorrectionModule(ToneCurveCorrectionModule&& other) noexcept;
 
    ToneCurveCorrectionModule& operator=(const ToneCurveCorrectionModule& other) = delete;
 
    ToneCurveCorrectionModule& operator=(ToneCurveCorrectionModule&& other) noexcept;
 
    void Serialize(peak::common::serialization::IArchive& archive) const override;
 
    void Deserialize(const peak::common::serialization::IArchive& archive) override;
 
    void SetEnabled(bool enabled) override;
 
    PEAK_COMMON_NO_DISCARD bool IsEnabled() const override;
 
    PEAK_COMMON_NO_DISCARD const char* GetType() const override;
 
    void ResetToDefault() override;
 
    void SetGamma(float gamma);
 
    PEAK_COMMON_NO_DISCARD float GetGamma() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::IntervalF GetGammaRange() const;
 
    void SetDigitalBlack(float digitalBlack);
 
    PEAK_COMMON_NO_DISCARD float GetDigitalBlack() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::IntervalF GetDigitalBlackRange() 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:
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    friend class features::GammaFeature;
    friend class features::DigitalBlackFeature;
#endif
 
    PEAK_COMMON_NO_DISCARD float FetchGamma() const;
    void ApplyGamma(float value) const;
    PEAK_COMMON_NO_DISCARD float FetchDigitalBlack() const;
    void ApplyDigitalBlack(float value) const;
    void SetGammaEnabled(bool enabled);
    void SetDigitalBlackEnabled(bool enabled);
    PEAK_COMMON_NO_DISCARD bool IsGammaEnabled() const;
    PEAK_COMMON_NO_DISCARD bool IsDigitalBlackEnabled() const;
 
    static constexpr int moduleVersion{ 1 };
    static constexpr auto gammaKey{ "Gamma" };
    static constexpr auto digitalBlackKey{ "DigitalBlack" };
 
    static constexpr auto gammaDefault = 1.0F;
    static constexpr auto digitalBlackDefault = 0.0F;
 
    peak_icv_tone_curve_correction_handle m_handle{};
    bool m_gammaEnabled{ true };
    bool m_digitalBlackEnabled{ true };
 
    float m_gamma{ gammaDefault };
    float m_digitalBlack{ digitalBlackDefault };
};
 
inline ToneCurveCorrectionModule::ToneCurveCorrectionModule()
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&]() {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_Create(&m_handle);
    });
}
 
inline ToneCurveCorrectionModule::~ToneCurveCorrectionModule()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_Destroy(m_handle);
    }
}
 
inline ToneCurveCorrectionModule::ToneCurveCorrectionModule(ToneCurveCorrectionModule&& other) noexcept
{
    m_handle = std::exchange(other.m_handle, nullptr);
    m_gammaEnabled = other.m_gammaEnabled;
    m_gamma = other.m_gamma;
    m_digitalBlackEnabled = other.m_digitalBlackEnabled;
    m_digitalBlack = other.m_digitalBlack;
}
 
inline ToneCurveCorrectionModule& ToneCurveCorrectionModule::operator=(ToneCurveCorrectionModule&& other) noexcept
{
    if (this != &other)
    {
        if (m_handle != nullptr)
        {
            peak::icv::detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_Destroy(m_handle);
            });
        }
 
        m_handle = std::exchange(other.m_handle, nullptr);
        m_gammaEnabled = other.m_gammaEnabled;
        m_gamma = other.m_gamma;
        m_digitalBlackEnabled = other.m_digitalBlackEnabled;
        m_digitalBlack = other.m_digitalBlack;
    }
 
    return *this;
}
 
inline void ToneCurveCorrectionModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    archive.SetInt("Version", moduleVersion);
 
    const auto gammaArchive = archive.CreateArchive();
    const auto digitalBlackArchive = archive.CreateArchive();
 
    gammaArchive->SetBool("Enabled", m_gammaEnabled);
    digitalBlackArchive->SetBool("Enabled", m_digitalBlackEnabled);
 
    gammaArchive->SetDouble("Value", m_gamma);
    digitalBlackArchive->SetDouble("Value", m_digitalBlack);
 
    archive.SetArchive(gammaKey, gammaArchive);
    archive.SetArchive(digitalBlackKey, digitalBlackArchive);
}
 
inline void ToneCurveCorrectionModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
 
    detail::ValidateVersion(version, GetType());
 
    const auto gammaArchive = archive.GetArchive(gammaKey);
    const auto digitalBlackArchive = archive.GetArchive(digitalBlackKey);
 
    m_gammaEnabled = gammaArchive->GetBool("Enabled");
    m_digitalBlackEnabled = digitalBlackArchive->GetBool("Enabled");
 
    m_gamma = static_cast<float>(gammaArchive->GetDouble("Value"));
    m_digitalBlack = static_cast<float>(digitalBlackArchive->GetDouble("Value"));
 
    ApplyGamma(m_gammaEnabled ? m_gamma : gammaDefault);
    ApplyDigitalBlack(m_digitalBlackEnabled ? m_digitalBlack : digitalBlackDefault);
}
 
inline void ToneCurveCorrectionModule::SetEnabled(bool enabled)
{
    SetGammaEnabled(enabled);
    SetDigitalBlackEnabled(enabled);
}
 
inline bool ToneCurveCorrectionModule::IsEnabled() const
{
    return m_gammaEnabled || m_digitalBlackEnabled;
}
 
inline const char* ToneCurveCorrectionModule::GetType() const
{
    return "ToneCurveCorrection";
}
 
inline void ToneCurveCorrectionModule::ResetToDefault()
{
    ApplyGamma(gammaDefault);
    m_gamma = gammaDefault;
    ApplyDigitalBlack(digitalBlackDefault);
    m_digitalBlack = digitalBlackDefault;
}
 
inline float ToneCurveCorrectionModule::GetGamma() const
{
    if (!m_gammaEnabled)
    {
        return m_gamma;
    }
 
    return FetchGamma();
}
 
inline peak::common::IntervalF ToneCurveCorrectionModule::GetGammaRange() const
{
    peak_common_interval_f cRange{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_GetGammaRange(m_handle, &cRange);
    });
 
    return peak::common::detail::BackendAccessor<peak::common::IntervalF>::CreateInstance(cRange);
}
 
inline peak::common::IntervalF ToneCurveCorrectionModule::GetDigitalBlackRange() const
{
    peak_common_interval_f cRange{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_GetDigitalBlackRange(m_handle, &cRange);
    });
 
    return peak::common::detail::BackendAccessor<peak::common::IntervalF>::CreateInstance(cRange);
}
 
inline void ToneCurveCorrectionModule::SetGamma(const float gamma)
{
    m_gamma = gamma;
 
    if (m_gammaEnabled)
    {
        ApplyGamma(gamma);
    }
}
 
inline float ToneCurveCorrectionModule::GetDigitalBlack() const
{
    if (!m_digitalBlackEnabled)
    {
        return m_digitalBlack;
    }
    return FetchDigitalBlack();
}
 
inline void ToneCurveCorrectionModule::SetDigitalBlack(const float digitalBlack)
{
    m_digitalBlack = digitalBlack;
 
    if (m_digitalBlackEnabled)
    {
        ApplyDigitalBlack(digitalBlack);
    }
}
 
inline peak::icv::Image ToneCurveCorrectionModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any ToneCurveCorrectionModule::Process(const peak::common::Any& input) const
{
    auto needsProcessing = [&] {
        bool value{};
        peak::icv::detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_NeedsProcessing(m_handle, &value);
        });
        return value;
    };
 
    if (!IsEnabled() || !needsProcessing())
    {
        return input;
    }
 
    const auto& inputImage = input.AnyCast<peak::icv::Image>();
 
    const auto pixelFormat = inputImage.GetPixelFormat();
    const auto info = peak::common::PixelFormatInfo(pixelFormat);
    const auto isSupportedMonoImage = pixelFormat == peak::common::PixelFormat::Mono8
        || pixelFormat == peak::common::PixelFormat::Mono10 || pixelFormat == peak::common::PixelFormat::Mono12
        || pixelFormat == peak::common::PixelFormat::Mono16;
    const auto isColorImage = info.HasChannel(peak::common::Channel::Red) && info.HasChannel(peak::common::Channel::Green)
        && info.HasChannel(peak::common::Channel::Blue);
    const auto isSupportedColorImage = isColorImage && pixelFormat != peak::common::PixelFormat::RGB10p32
        && pixelFormat != peak::common::PixelFormat::BGR10p32;
    if (!isSupportedMonoImage && !isSupportedColorImage)
    {
        return input;
    }
 
    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_ToneCurveCorrection_ProcessInplace(m_handle, inputImageHandle);
    });
 
    return peak::common::Any{ inputImage };
}
 
inline float ToneCurveCorrectionModule::FetchGamma() const
{
    float value{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_GetGamma(m_handle, &value);
    });
    return value;
}
 
inline void ToneCurveCorrectionModule::ApplyGamma(float value) const
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_SetGamma(m_handle, value);
    });
}
 
inline float ToneCurveCorrectionModule::FetchDigitalBlack() const
{
    float value{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_GetDigitalBlack(m_handle, &value);
    });
    return value;
}
 
inline void ToneCurveCorrectionModule::ApplyDigitalBlack(float value) const
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ToneCurveCorrection_SetDigitalBlack(m_handle, value);
    });
}
 
inline void ToneCurveCorrectionModule::SetGammaEnabled(bool enabled)
{
    m_gammaEnabled = enabled;
 
    ApplyGamma(enabled ? m_gamma : gammaDefault);
}
 
inline void ToneCurveCorrectionModule::SetDigitalBlackEnabled(bool enabled)
{
    m_digitalBlackEnabled = enabled;
 
    ApplyDigitalBlack(enabled ? m_digitalBlack : digitalBlackDefault);
}
 
inline bool ToneCurveCorrectionModule::IsGammaEnabled() const
{
    return m_gammaEnabled;
}
 
inline bool ToneCurveCorrectionModule::IsDigitalBlackEnabled() const
{
    return m_digitalBlackEnabled;
}
 
} // namespace detail
} // namespace pipeline 
} // namespace peak