peak_icv_hotpixel_detection.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/types/peak_common_interval.hpp>
#include <peak_icv/types/peak_icv_image.hpp>
#include <peak_icv_c/algorithms/filters/peak_icv_median_filter.h>
#include <peak_icv_c/algorithms/preprocessing/peak_icv_hotpixel_correction.h>
#include <utility>
 
namespace peak
{
namespace icv
{
 
class HotpixelDetection
{
public:
    HotpixelDetection();
 
    ~HotpixelDetection();
 
    HotpixelDetection(const HotpixelDetection& other);
 
    HotpixelDetection(HotpixelDetection&& other) noexcept;
 
    HotpixelDetection& operator=(const HotpixelDetection& other);
 
    HotpixelDetection& operator=(HotpixelDetection&& other) noexcept;
 
    PEAK_COMMON_NO_DISCARD std::vector<peak::common::Point> Detect(const Image& image) const;
 
    void SetSensitivity(uint32_t sensitivity);
 
    uint32_t GetSensitivity() const;
 
    peak::common::IntervalU GetSensitivityRange();
 
    void SetGainFactor(float gainFactor);
 
    float GetGainFactor() const;
 
private:
    peak_icv_hotpixel_correction_handle m_handle{};
    uint32_t m_sensitivity = 3;
    float m_gainFactor = 1.0F;
};
 
inline std::vector<peak::common::Point> HotpixelDetection::Detect(const Image& image) const
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Detect(
            m_handle, peak::common::detail::BackendAccessor<Image>::BackendHandle(image), m_sensitivity, m_gainFactor);
    });
 
    size_t hotpixelCount{};
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_GetList_GetCount(m_handle, &hotpixelCount);
    });
 
    if (hotpixelCount == 0)
    {
        return {};
    }
 
    std::vector<peak_common_point> hotpixelsC(hotpixelCount);
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_GetList(m_handle, hotpixelsC.data(), hotpixelCount);
    });
 
    std::vector<peak::common::Point> hotpixelsCpp;
    hotpixelsCpp.reserve(hotpixelCount);
    std::transform(hotpixelsC.begin(), hotpixelsC.end(), std::back_inserter(hotpixelsCpp), [](peak_common_point pointC) {
        return peak::common::detail::BackendAccessor<peak::common::Point>::CreateInstance(pointC);
    });
 
    return hotpixelsCpp;
}
 
inline HotpixelDetection::HotpixelDetection()
{
    peak::icv::detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Create(&m_handle);
    });
}
 
inline HotpixelDetection::HotpixelDetection(const HotpixelDetection& other)
{
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_IncreaseUseCount(other.m_handle);
    });
    m_handle = other.m_handle;
    m_gainFactor = other.m_gainFactor;
    m_sensitivity = other.m_sensitivity;
}
 
inline HotpixelDetection::HotpixelDetection(HotpixelDetection&& other) noexcept
{
    m_handle = other.m_handle;
    other.m_handle = nullptr;
 
    m_sensitivity = std::move(other.m_sensitivity);
    m_gainFactor = std::move(other.m_gainFactor);
}
 
inline HotpixelDetection& HotpixelDetection::operator=(const HotpixelDetection& other)
{
    if (m_handle != other.m_handle)
    {
        if (m_handle != nullptr)
        {
            detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Destroy(m_handle);
            });
        }
 
        detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_IncreaseUseCount(other.m_handle);
        });
        m_handle = other.m_handle;
        m_gainFactor = other.m_gainFactor;
        m_sensitivity = other.m_sensitivity;
    }
 
    return *this;
}
 
inline HotpixelDetection& HotpixelDetection::operator=(HotpixelDetection&& other) noexcept
{
    if (m_handle != other.m_handle)
    {
        if (m_handle != nullptr)
        {
            detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Destroy(m_handle);
            });
        }
 
        m_handle = other.m_handle;
        other.m_handle = nullptr;
        m_sensitivity = std::move(other.m_sensitivity);
        m_gainFactor = std::move(other.m_gainFactor);
    }
 
    return *this;
}
 
inline HotpixelDetection::~HotpixelDetection()
{
    if (m_handle != nullptr)
    {
        std::ignore = PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_Destroy(m_handle);
    }
}
 
inline void HotpixelDetection::SetSensitivity(uint32_t sensitivity)
{
    const auto range = GetSensitivityRange();
 
    if (sensitivity < range.GetMinimum() || sensitivity > range.GetMaximum())
    {
        throw OutOfRangeException("The given sensitivity is out of range. Check GetSensitivityRange() function for the valid range.");
    }
 
    m_sensitivity = sensitivity;
}
 
inline uint32_t HotpixelDetection::GetSensitivity() const
{
    return m_sensitivity;
}
 
inline peak::common::IntervalU HotpixelDetection::GetSensitivityRange()
{
    peak_common_interval_u sensitivityRange;
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Preprocessing_HotpixelCorrection_GetSensitivityRange(m_handle, &sensitivityRange);
    });
 
    return peak::common::detail::BackendAccessor<peak::common::IntervalU>::CreateInstance(sensitivityRange);
}
 
inline void HotpixelDetection::SetGainFactor(float gainFactor)
{
    m_gainFactor = gainFactor;
}
 
inline float HotpixelDetection::GetGainFactor() const
{
    return m_gainFactor;
}
 
} /* namespace icv */
} /* namespace peak */