peak_icv_hotpixel_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/geometry/peak_common_point.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_hotpixel_correction.h>
 
namespace peak
{
namespace pipeline
{
 
namespace detail
{
 
class HotpixelCorrectionModule : public modules::IModule
{
public:
    HotpixelCorrectionModule();
 
    ~HotpixelCorrectionModule() override;
 
    HotpixelCorrectionModule(const HotpixelCorrectionModule& other) = delete;
 
    HotpixelCorrectionModule(HotpixelCorrectionModule&& other) noexcept;
 
    HotpixelCorrectionModule& operator=(const HotpixelCorrectionModule& other) = delete;
 
    HotpixelCorrectionModule& operator=(HotpixelCorrectionModule&& other) noexcept;
 
    void SetEnabled(bool enabled) override;
 
    PEAK_COMMON_NO_DISCARD bool IsEnabled() const override;
 
    PEAK_COMMON_NO_DISCARD const char* GetType() const override;
 
    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 Serialize(peak::common::serialization::IArchive& archive) const override;
 
 
    void Deserialize(const peak::common::serialization::IArchive& archive) override;
 
    void SetList(const std::vector<peak::common::Point>& hotpixels);
 
    PEAK_COMMON_NO_DISCARD std::vector<peak::common::Point> GetList() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::IntervalU GetSensitivityRange() const;
 
    void Detect(const peak::icv::Image& image, uint32_t sensitivity = 3, float gainFactor = 1.0F);
 
    void ResetToDefault() override;
 
private:
    static constexpr int moduleVersion = 1;
 
    peak_icv_hotpixel_correction_handle m_handle{};
    bool m_enabled{ true };
};
 
inline const char* HotpixelCorrectionModule::GetType() const
{
    return "HotpixelCorrection";
}
 
inline HotpixelCorrectionModule::HotpixelCorrectionModule()
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&]() {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Create(&m_handle);
    });
}
 
inline HotpixelCorrectionModule::~HotpixelCorrectionModule()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Destroy(m_handle);
    }
}
 
inline HotpixelCorrectionModule::HotpixelCorrectionModule(HotpixelCorrectionModule&& other) noexcept
{
    m_handle = std::exchange(other.m_handle, nullptr);
    m_enabled = other.m_enabled;
}
 
inline HotpixelCorrectionModule& HotpixelCorrectionModule::operator=(HotpixelCorrectionModule&& other) noexcept
{
    if (this != &other)
    {
        if (m_handle != nullptr)
        {
            peak::icv::detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Destroy(m_handle);
            });
        }
 
        m_handle = std::exchange(other.m_handle, nullptr);
        m_enabled = other.m_enabled;
    }
 
    return *this;
}
 
inline void HotpixelCorrectionModule::SetEnabled(bool enabled)
{
    m_enabled = enabled;
}
 
inline bool HotpixelCorrectionModule::IsEnabled() const
{
    return m_enabled;
}
 
inline void HotpixelCorrectionModule::Serialize(peak::common::serialization::IArchive& archive) const
{
    const auto hotpixels = GetList();
    std::vector<std::shared_ptr<peak::common::serialization::IArchive>> archivePoints;
    archivePoints.reserve(hotpixels.size());
 
    std::transform(std::cbegin(hotpixels), std::cend(hotpixels), std::back_inserter(archivePoints), [&archive](const auto& point) {
        auto archivePoint = archive.CreateArchive();
        archivePoint->SetInt("X", point.GetX());
        archivePoint->SetInt("Y", point.GetY());
        return archivePoint;
    });
    archive.SetArchiveArray("HotpixelList", archivePoints);
 
    archive.SetInt("Version", moduleVersion);
    archive.SetBool("Enabled", IsEnabled());
}
 
inline void HotpixelCorrectionModule::Deserialize(const peak::common::serialization::IArchive& archive)
{
    const auto version = archive.GetInt("Version");
    detail::ValidateVersion(version, GetType());
 
    SetEnabled(archive.GetBool("Enabled"));
 
    const auto archivePoints = archive.GetArchiveArray("HotpixelList");
    std::vector<peak::common::Point> list;
    list.reserve(archivePoints.size());
    std::transform(std::cbegin(archivePoints), std::cend(archivePoints), std::back_inserter(list), [](const auto& archive) {
        return peak::common::Point{ static_cast<int32_t>(archive->GetInt("X")), static_cast<int32_t>(archive->GetInt("Y")) };
    });
 
    SetList(list);
}
 
inline void HotpixelCorrectionModule::SetList(const std::vector<peak::common::Point>& hotpixels)
{
    if (hotpixels.empty())
    {
        peak::icv::detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_ResetList(m_handle);
        });
    }
    std::vector<peak_common_point> cPoints;
    cPoints.reserve(hotpixels.size());
    std::transform(hotpixels.cbegin(), hotpixels.cend(), std::back_inserter(cPoints), [](const peak::common::Point& cppPoint) {
        return peak_common_point{ cppPoint.GetX(), cppPoint.GetY() };
    });
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_SetList(m_handle, cPoints.data(), cPoints.size());
    });
}
 
inline std::vector<peak::common::Point> HotpixelCorrectionModule::GetList() const
{
    size_t count = 0;
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_GetList_GetCount(m_handle, &count);
    });
    if (count == 0)
    {
        return {};
    }
 
    std::vector<peak_common_point> cList(count);
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_GetList(m_handle, cList.data(), count);
    });
 
    std::vector<peak::common::Point> cppList{};
    cppList.reserve(count);
    std::transform(cList.begin(), cList.end(), std::back_inserter(cppList), [](const peak_common_point& cPoint) {
        return peak::common::Point{ cPoint.x, cPoint.y };
    });
 
    return cppList;
}
 
inline void HotpixelCorrectionModule::Detect(const peak::icv::Image& image, uint32_t sensitivity, float gainFactor)
{
    auto* const inputImageHandle = peak::common::detail::BackendAccessor<peak::icv::Image>::BackendHandle(image);
 
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Detect(m_handle, inputImageHandle, sensitivity, gainFactor);
    });
}
 
inline void HotpixelCorrectionModule::ResetToDefault()
{
    SetList({});
}
 
inline peak::icv::Image HotpixelCorrectionModule::Process(const peak::icv::Image& input) const
{
    return Process(peak::common::Any(input)).AnyCast<peak::icv::Image>();
}
 
inline peak::common::Any HotpixelCorrectionModule::Process(const peak::common::Any& input) const
{
    auto needsProcessing = [&] {
        size_t count{};
        peak::icv::detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_GetList_GetCount(m_handle, &count);
        });
        return count > 0;
    };
 
    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_HotpixelCorrection_ProcessInplace(m_handle, inputImageHandle);
    });
 
    return peak::common::Any{ inputImage };
}
 
inline peak::common::IntervalU HotpixelCorrectionModule::GetSensitivityRange() const
{
    peak_common_interval_u cRange{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_GetSensitivityRange(m_handle, &cRange);
    });
 
    return peak::common::detail::BackendAccessor<peak::common::IntervalU>::CreateInstance(cRange);
}
 
} // namespace detail
} // namespace pipeline 
} // namespace peak