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)
    {
        (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 */