peak_ipl_hotpixel_correction.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_ipl/backend/peak_ipl_backend.h>
 
#include <cstdint>
#include <vector>
 
namespace peak
{
namespace ipl
{
 
class Image;
struct Point2D;
 
 
 
class HotpixelCorrection final
{
public:
    enum class SensitivityLevel
    {
        Invalid,
        SensitivityLevel1,
        SensitivityLevel2,
        SensitivityLevel3, 
        SensitivityLevel4,
        SensitivityLevel5,
    };
 
    HotpixelCorrection();
    
    ~HotpixelCorrection();
 
    HotpixelCorrection(const HotpixelCorrection& other);
 
    HotpixelCorrection& operator=(const HotpixelCorrection& other);
 
    HotpixelCorrection(HotpixelCorrection&& other) noexcept;
 
    HotpixelCorrection& operator=(HotpixelCorrection&& other) noexcept;
 
    void SetSensitivity(SensitivityLevel sensitivityLevel = SensitivityLevel::SensitivityLevel3);
 
    PEAK_IPL_NO_DISCARD SensitivityLevel Sensitivity() const;
 
    void SetGainFactorPercent(uint32_t gainFactorPercent = 100);
 
    PEAK_IPL_NO_DISCARD uint32_t GainFactorPercent() const;
 
    PEAK_IPL_NO_DISCARD std::vector<Point2D> Detect(const Image& inputImage) const;
 
    PEAK_IPL_NO_DISCARD Image Correct(const Image& inputImage, const std::vector<Point2D>& hotpixels) const;
 
    Image& CorrectInPlace(Image& inputImage, const std::vector<Point2D>& hotpixels) const;
 
    PEAK_IPL_NO_DISCARD Image CorrectAdaptive(const Image& inputImage);
 
    Image& CorrectAdaptiveInPlace(Image& inputImage);
 
private:
    PEAK_IPL_ADAPTIVE_HOTPIXEL_CORRECTOR_HANDLE m_backendHandle{};
};
 
} /* namespace ipl */
} /* namespace peak */
 
#include <peak_ipl/types/peak_ipl_image.hpp>
 
namespace peak
{
namespace ipl
{
 
inline HotpixelCorrection::HotpixelCorrection()
{
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_Construct(&m_backendHandle); });
 
    // make sure default params are set
    SetSensitivity();
    SetGainFactorPercent();
}
 
inline HotpixelCorrection::~HotpixelCorrection()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(m_backendHandle);
    }
}
 
inline HotpixelCorrection::HotpixelCorrection(const HotpixelCorrection& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline HotpixelCorrection& HotpixelCorrection::operator=(const HotpixelCorrection& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline HotpixelCorrection::HotpixelCorrection(HotpixelCorrection&& other) noexcept
{
    *this = std::move(other);
}
 
inline HotpixelCorrection& HotpixelCorrection::operator=(HotpixelCorrection&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_Destruct(m_backendHandle);
        }
 
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }
 
    return *this;
}
 
inline void HotpixelCorrection::SetSensitivity(SensitivityLevel sensitivityLevel)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_SetSensitivity(
            m_backendHandle, static_cast<PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY>(sensitivityLevel));
    });
}
 
inline HotpixelCorrection::SensitivityLevel HotpixelCorrection::Sensitivity() const
{
    PEAK_IPL_HOTPIXELCORRECTION_SENSITIVITY sensitivityLevel;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_GetSensitivity(
            m_backendHandle, &sensitivityLevel);
    });
 
    return static_cast<SensitivityLevel>(sensitivityLevel);
}
 
inline void HotpixelCorrection::SetGainFactorPercent(uint32_t gainFactorPercent)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_SetGainFactorPercent(
            m_backendHandle, gainFactorPercent);
    });
}
 
inline uint32_t HotpixelCorrection::GainFactorPercent() const
{
    uint32_t gainFactorPercent;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_GetGainFactorPercent(
            m_backendHandle, &gainFactorPercent);
    });
 
    return gainFactorPercent;
}
 
inline std::vector<Point2D> HotpixelCorrection::Detect(const Image& inputImage) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_Detect(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage));
    });
 
    size_t size = 0;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(m_backendHandle, nullptr, &size);
    });
    std::vector<Point2D> hotpixels(size);
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_GetHotpixels(
            m_backendHandle, reinterpret_cast<PEAK_IPL_POINT_2D*>(hotpixels.data()), &size);
    });
 
    return hotpixels;
}
 
inline Image HotpixelCorrection::Correct(const Image& inputImage, const std::vector<Point2D>& hotpixels) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_Correct(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage),
            reinterpret_cast<const PEAK_IPL_POINT_2D*>(hotpixels.data()), hotpixels.size(), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image& HotpixelCorrection::CorrectInPlace(Image& inputImage, const std::vector<Point2D>& hotpixels) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_CorrectInPlace(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage),
            reinterpret_cast<const PEAK_IPL_POINT_2D*>(hotpixels.data()), hotpixels.size());
    });
 
    return inputImage;
}
 
inline Image HotpixelCorrection::CorrectAdaptive(const Image& inputImage)
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptive(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image& HotpixelCorrection::CorrectAdaptiveInPlace(Image& inputImage)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_AdaptiveHotpixelCorrector_CorrectAdaptiveInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage));
    });
 
    return inputImage;
}
 
 
} /* namespace ipl */
} /* namespace peak */