peak_icv_color_matrix_transformation_module.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/pipeline/modules/peak_common_iautofeature_module.hpp>
#include <peak_common/pipeline/modules/peak_common_imodule.hpp>
#include <peak_common/types/peak_common_range.hpp>
#include <peak_icv/pipeline/detail/peak_icv_pipeline_utils.hpp>
#include <peak_icv/pipeline/types/peak_icv_chromatic_adaption_algorithm.hpp>
#include <peak_icv/pipeline/types/peak_icv_color_correction_matrix.hpp>
#include <peak_icv/pipeline/types/peak_icv_color_space.hpp>
#include <peak_icv/types/peak_icv_image.hpp>
 
namespace peak
{
namespace pipeline
{
namespace features
{
class ChromaticAdaptionFeature;
class SaturationFeature;
class ColorCorrectionFeature;
} // namespace features
 
namespace detail
{
 
class ColorMatrixTransformationModule : public modules::IModule
{
public:
    ColorMatrixTransformationModule();
 
    ~ColorMatrixTransformationModule() override;
 
    ColorMatrixTransformationModule(const ColorMatrixTransformationModule& other) = delete;
 
    ColorMatrixTransformationModule(ColorMatrixTransformationModule&& other) noexcept;
 
    ColorMatrixTransformationModule& operator=(const ColorMatrixTransformationModule& other) = delete;
 
    ColorMatrixTransformationModule& operator=(ColorMatrixTransformationModule&& 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 SetMatrix(const ColorCorrectionMatrix& matrix);
 
    PEAK_COMMON_NO_DISCARD ColorCorrectionMatrix GetMatrix() const;
 
    void SetSaturation(float saturation);
 
    PEAK_COMMON_NO_DISCARD float GetSaturation() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::IntervalF GetSaturationRange() 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;
 
    void SetAutoFeatureModule(const std::shared_ptr<modules::IAutoFeature>& module);
 
    PEAK_COMMON_NO_DISCARD ColorCorrectionMatrix GetEffectiveMatrix() const;
 
    void SetChromaticAdaptionAlgorithm(ChromaticAdaptionAlgorithm algorithm);
 
    PEAK_COMMON_NO_DISCARD ChromaticAdaptionAlgorithm GetChromaticAdaptionAlgorithm() const;
 
    void SetTargetColorSpace(ColorSpace colorSpace);
 
    PEAK_COMMON_NO_DISCARD ColorSpace GetTargetColorSpace() const;
 
    void SetColorTemperature(uint32_t temperature);
 
    PEAK_COMMON_NO_DISCARD uint32_t GetColorTemperature() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::RangeU GetColorTemperatureRange() const;
 
    void ResetColorTemperature() const;
 
    PEAK_COMMON_NO_DISCARD bool HasColorTemperature() const;
 
    void SetChromaticAdaptionEnabled(bool enabled);
 
    PEAK_COMMON_NO_DISCARD bool IsChromaticAdaptionEnabled() const;
 
    void SetSaturationEnabled(bool enabled);
 
    PEAK_COMMON_NO_DISCARD bool IsSaturationEnabled() const;
 
    void SetColorCorrectionEnabled(bool enabled);
 
    PEAK_COMMON_NO_DISCARD bool IsColorCorrectionEnabled() const;
 
    void ResetChromaticAdaption();
 
private:
    void UpdateMatrixInAutoFeatureModule() const;
 
    static constexpr auto saturationKey = "Saturation";
    static constexpr auto matrixKey = "ColorCorrection";
    static constexpr auto chromaticAdaptionKey = "ChromaticAdaption";
 
    peak_icv_color_matrix_transformation_handle m_handle{};
 
    std::shared_ptr<modules::IAutoFeature> m_autoFeatureModule;
};
 
inline ColorMatrixTransformationModule::ColorMatrixTransformationModule()
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&]() {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_Create(&m_handle);
    });
}
 
inline ColorMatrixTransformationModule::~ColorMatrixTransformationModule()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_Destroy(m_handle);
    }
}
 
inline ColorMatrixTransformationModule::ColorMatrixTransformationModule(ColorMatrixTransformationModule&& other) noexcept
{
    m_handle = std::exchange(other.m_handle, nullptr);
}
 
inline ColorMatrixTransformationModule& ColorMatrixTransformationModule::operator=(ColorMatrixTransformationModule&& other) noexcept
{
    if (this != &other)
    {
        if (m_handle != nullptr)
        {
            peak::icv::detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_Destroy(m_handle);
            });
        }
 
        m_handle = std::exchange(other.m_handle, nullptr);
    }
 
    return *this;
}
 
inline void ColorMatrixTransformationModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    archive.SetInt("Version", 2);
 
    const auto saturationArchive = archive.CreateArchive();
    saturationArchive->SetBool("Enabled", IsSaturationEnabled());
    saturationArchive->SetDouble("Value", GetSaturation());
    archive.SetArchive(saturationKey, saturationArchive);
 
    const auto matrixArchive = archive.CreateArchive();
    matrixArchive->SetBool("Enabled", IsColorCorrectionEnabled());
 
    const auto colorCorrectionMatrix = GetMatrix();
    colorCorrectionMatrix.Serialize(*matrixArchive);
    archive.SetArchive(matrixKey, matrixArchive);
 
    const auto chromaticAdaption = archive.CreateArchive();
    chromaticAdaption->SetBool("Enabled", IsChromaticAdaptionEnabled());
    chromaticAdaption->SetString("Algorithm", ToString(GetChromaticAdaptionAlgorithm()));
    chromaticAdaption->SetString("TargetColorSpace", ToString(GetTargetColorSpace()));
    if (HasColorTemperature())
    {
        chromaticAdaption->SetInt("ColorTemperature", GetColorTemperature());
    }
    archive.SetArchive(chromaticAdaptionKey, chromaticAdaption);
}
 
inline void ColorMatrixTransformationModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
 
    detail::ValidateVersion(version, GetType());
 
    const auto saturationArchive = archive.GetArchive(saturationKey);
    const auto matrixArchive = archive.GetArchive(matrixKey);
 
    SetSaturationEnabled(saturationArchive->GetBool("Enabled"));
    SetColorCorrectionEnabled(matrixArchive->GetBool("Enabled"));
 
    ColorCorrectionMatrix matrix{ "Matrix", ColorCorrectionMatrix::Identity() };
    matrix.Deserialize(*matrixArchive);
    SetMatrix(matrix);
 
    SetSaturation(static_cast<float>(saturationArchive->GetDouble("Value")));
 
    if (version >= 2)
    {
        const auto chromaticAdaptionArchive = archive.GetArchive(chromaticAdaptionKey);
        if (chromaticAdaptionArchive->HasKey("ColorTemperature"))
        {
            SetColorTemperature(static_cast<uint32_t>(chromaticAdaptionArchive->GetInt("ColorTemperature")));
        }
        else
        {
            ResetColorTemperature();
        }
        SetTargetColorSpace(ToColorSpace(chromaticAdaptionArchive->GetString("TargetColorSpace")));
        SetChromaticAdaptionAlgorithm(ToChromaticAdaptionAlgorithm(chromaticAdaptionArchive->GetString("Algorithm")));
        SetChromaticAdaptionEnabled(chromaticAdaptionArchive->GetBool("Enabled"));
    }
    else
    {
        ResetChromaticAdaption();
    }
}
 
inline void ColorMatrixTransformationModule::SetEnabled(bool enabled)
{
    SetColorCorrectionEnabled(enabled);
    SetSaturationEnabled(enabled);
    SetChromaticAdaptionEnabled(enabled);
 
    UpdateMatrixInAutoFeatureModule();
}
 
inline bool ColorMatrixTransformationModule::IsEnabled() const
{
    return IsColorCorrectionEnabled() || IsSaturationEnabled() || IsChromaticAdaptionEnabled();
}
 
inline const char* ColorMatrixTransformationModule::GetType() const
{
    return "ColorMatrixTransformation";
}
 
inline void ColorMatrixTransformationModule::ResetToDefault()
{
    SetMatrix(ColorCorrectionMatrix::Identity());
    SetSaturation(1.0F);
 
    ResetChromaticAdaption();
 
    UpdateMatrixInAutoFeatureModule();
}
 
inline ColorCorrectionMatrix ColorMatrixTransformationModule::GetMatrix() const
{
    ColorCorrectionMatrix colorCorrectionMatrix{ "Matrix", ColorCorrectionMatrix::Identity() };
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_GetColorCorrectionMatrix(
            m_handle, reinterpret_cast<peak_icv_color_correction_matrix*>(&colorCorrectionMatrix.At(0, 0)));
    });
 
    return colorCorrectionMatrix;
}
 
inline void ColorMatrixTransformationModule::SetMatrix(const ColorCorrectionMatrix& matrix)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_SetColorCorrectionMatrix(
            m_handle, *reinterpret_cast<const peak_icv_color_correction_matrix*>(&matrix.At(0, 0)));
    });
 
    if (IsColorCorrectionEnabled())
    {
        UpdateMatrixInAutoFeatureModule();
    }
}
 
inline void ColorMatrixTransformationModule::SetSaturation(float saturation)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_SetSaturation(m_handle, saturation);
    });
    if (IsSaturationEnabled())
    {
        UpdateMatrixInAutoFeatureModule();
    }
}
 
PEAK_COMMON_NO_DISCARD inline float ColorMatrixTransformationModule::GetSaturation() const
{
    float saturation;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_GetSaturation(m_handle, &saturation);
    });
    return saturation;
}
 
PEAK_COMMON_NO_DISCARD inline peak::common::IntervalF ColorMatrixTransformationModule::GetSaturationRange() const
{
    peak_common_interval_f intervalF;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_GetSaturationRange(m_handle, &intervalF);
    });
 
    return { intervalF.minimum, intervalF.maximum };
}
 
inline peak::icv::Image ColorMatrixTransformationModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any ColorMatrixTransformationModule::Process(const peak::common::Any& input) const
{
    auto needsProcessing = [&] {
        bool value{};
        peak::icv::detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_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 peak::common::PixelFormatInfo info(pixelFormat);
    const auto isColorImage = info.HasChannel(peak::common::Channel::Red) && info.HasChannel(peak::common::Channel::Green)
        && info.HasChannel(peak::common::Channel::Blue);
    if (!isColorImage || info.IsPacked())
    {
        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_ColorMatrixTransformation_ProcessInplace(m_handle, inputImageHandle);
    });
 
    return peak::common::Any{ inputImage };
}
 
inline void ColorMatrixTransformationModule::UpdateMatrixInAutoFeatureModule() const
{
    if (m_autoFeatureModule != nullptr)
    {
        std::array<float, 9> data{};
 
        const auto matrix = GetEffectiveMatrix();
        std::copy(matrix.cbegin(), matrix.cend(), data.begin());
 
        m_autoFeatureModule->SetColorCorrectionMatrix(data);
    }
}
 
inline void ColorMatrixTransformationModule::SetAutoFeatureModule(const std::shared_ptr<modules::IAutoFeature>& module)
{
    m_autoFeatureModule = module;
    UpdateMatrixInAutoFeatureModule();
}
 
inline ColorCorrectionMatrix ColorMatrixTransformationModule::GetEffectiveMatrix() const
{
    ColorCorrectionMatrix matrix{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_GetEffectiveMatrix(
            m_handle, reinterpret_cast<peak_icv_color_correction_matrix*>(&matrix.At(0, 0)));
    });
    return matrix;
}
 
inline void ColorMatrixTransformationModule::SetSaturationEnabled(bool enabled)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_Saturation_SetEnabled(m_handle, enabled);
    });
    UpdateMatrixInAutoFeatureModule();
}
 
inline void ColorMatrixTransformationModule::SetColorCorrectionEnabled(bool enabled)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ColorCorrection_SetEnabled(m_handle, enabled);
    });
    UpdateMatrixInAutoFeatureModule();
}
 
inline bool ColorMatrixTransformationModule::IsSaturationEnabled() const
{
    bool enabled;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_Saturation_IsEnabled(m_handle, &enabled);
    });
    return enabled;
}
 
inline bool ColorMatrixTransformationModule::IsColorCorrectionEnabled() const
{
    bool enabled;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ColorCorrection_IsEnabled(m_handle, &enabled);
    });
    return enabled;
}
 
inline ChromaticAdaptionAlgorithm ColorMatrixTransformationModule::GetChromaticAdaptionAlgorithm() const
{
    peak_icv_chromatic_adaption_algorithm algorithm;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetAlgorithm(m_handle, &algorithm);
    });
    return static_cast<ChromaticAdaptionAlgorithm>(algorithm);
}
 
inline ColorSpace ColorMatrixTransformationModule::GetTargetColorSpace() const
{
    peak_icv_color_space colorSpace;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetTargetColorSpace(
            m_handle, &colorSpace);
    });
    return static_cast<ColorSpace>(colorSpace);
}
 
inline void ColorMatrixTransformationModule::SetChromaticAdaptionAlgorithm(ChromaticAdaptionAlgorithm algorithm)
{
    const auto cAlgorithm = static_cast<peak_icv_chromatic_adaption_algorithm>(algorithm);
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetAlgorithm(m_handle, cAlgorithm);
    });
    UpdateMatrixInAutoFeatureModule();
}
 
inline void ColorMatrixTransformationModule::SetTargetColorSpace(ColorSpace colorSpace)
{
    const auto cColorSpace = static_cast<peak_icv_color_space>(colorSpace);
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetTargetColorSpace(
            m_handle, cColorSpace);
    });
    UpdateMatrixInAutoFeatureModule();
}
 
inline peak::common::RangeU ColorMatrixTransformationModule::GetColorTemperatureRange() const
{
    peak_common_range_u cRange{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetColorTemperatureRange(
            m_handle, &cRange);
    });
 
    return peak::common::detail::BackendAccessor<peak::common::RangeU>::CreateInstance({ cRange });
}
 
inline void ColorMatrixTransformationModule::SetColorTemperature(const uint32_t temperature)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetColorTemperature(
            m_handle, temperature);
    });
    UpdateMatrixInAutoFeatureModule();
}
 
inline bool ColorMatrixTransformationModule::HasColorTemperature() const
{
    bool value;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_HasColorTemperature(
            m_handle, &value);
    });
    return value;
}
 
inline uint32_t ColorMatrixTransformationModule::GetColorTemperature() const
{
    uint32_t temperature{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_GetColorTemperature(
            m_handle, &temperature);
    });
    return temperature;
}
 
inline void ColorMatrixTransformationModule::ResetColorTemperature() const
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_ResetColorTemperature(m_handle);
    });
    UpdateMatrixInAutoFeatureModule();
}
 
inline void ColorMatrixTransformationModule::SetChromaticAdaptionEnabled(const bool enabled)
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_SetEnabled(m_handle, enabled);
    });
    UpdateMatrixInAutoFeatureModule();
}
 
inline bool ColorMatrixTransformationModule::IsChromaticAdaptionEnabled() const
{
    bool enabled;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_ColorMatrixTransformation_ChromaticAdaption_IsEnabled(m_handle, &enabled);
    });
    return enabled;
}
 
inline void ColorMatrixTransformationModule::ResetChromaticAdaption()
{
    ResetColorTemperature();
    SetChromaticAdaptionAlgorithm(ChromaticAdaptionAlgorithm::Bradford);
    SetTargetColorSpace(ColorSpace::SRGB_D65);
}
 
} // namespace detail
} // namespace pipeline 
} // namespace peak