peak_ipl_sharpness.hpp

Go to the documentation of this file.

#pragma once

#include <peak_ipl/backend/peak_ipl_backend.h>
#include <peak_ipl/exception/peak_ipl_exception.hpp>
#include <peak_ipl/types/peak_ipl_rect.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>
#include <peak_ipl/types/peak_ipl_image.hpp>

#include <type_traits>
#include <algorithm>
#include <cstdint>
#include <iterator>
#include <vector>

namespace peak
{
namespace ipl
{
enum class PixelFormatName;
class Sharpness final
{
public:
    Sharpness();
    
    ~Sharpness();

    Sharpness(const Sharpness& other);

    Sharpness& operator=(const Sharpness& other);

    Sharpness(Sharpness&& other) noexcept;

    Sharpness& operator=(Sharpness&& other) noexcept;

    enum class SharpnessAlgorithm : uint16_t
    {
        Tenengrad, 
        MeanScore, 
        HistogramVariance, 
        Sobel 
    };

    enum class SharpnessROIWeight : uint16_t
    {
        Weak = 0x0021, 
        Medium = 0x0042, 
        Strong = 0x0063 
    };

    struct SharpnessROI
    {
#if !defined(__cpp_aggregate_nsdmi)
        SharpnessROI() = default;
        SharpnessROI(Rect2D rect, uint8_t xSamplingInterval, uint8_t ySamplingInterval, SharpnessROIWeight weight) :
            rect(std::move(rect)), xSamplingInterval(xSamplingInterval), ySamplingInterval(ySamplingInterval), weight(weight) {}
#endif
        Rect2D rect{ 0, 0, 0, 0 }; 
        uint8_t xSamplingInterval{ 1 }; 
        uint8_t ySamplingInterval{ 1 }; 
        SharpnessROIWeight weight{ SharpnessROIWeight::Medium }; 
    };

    using SharpnessROIList = std::vector<SharpnessROI>;

    inline double Measure(const Image& image);

    PEAK_IPL_NO_DISCARD inline bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;

    PEAK_IPL_NO_DISCARD inline std::vector<PixelFormatName> SupportedPixelFormats() const;

    inline void SetAlgorithm(SharpnessAlgorithm algorithm);

    PEAK_IPL_NO_DISCARD inline SharpnessAlgorithm Algorithm() const;

    PEAK_IPL_NO_DISCARD inline Size2D ROIMinSize() const;

    inline void SetROIs(const SharpnessROIList& rois);

    inline void SetROI(const SharpnessROI& roi);

    inline void SetROI(const Rect2D& roi);

    PEAK_IPL_NO_DISCARD inline SharpnessROIList ROIs() const;

private:
    PEAK_IPL_SHARPNESS_HANDLE m_backendHandle{};
};

inline Sharpness::Sharpness()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_Construct(&m_backendHandle); });
}

inline Sharpness::~Sharpness()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_Destruct(m_backendHandle);
    }
}

inline Sharpness::Sharpness(const Sharpness& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_Acquire(other.m_backendHandle); });
    }

    m_backendHandle = other.m_backendHandle;
}

inline Sharpness& Sharpness::operator=(const Sharpness& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_Destruct(m_backendHandle);
        }

        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_Acquire(other.m_backendHandle); });
        }
    }

    m_backendHandle = other.m_backendHandle;

    return *this;
}

inline Sharpness::Sharpness(Sharpness&& other) noexcept
{
    *this = std::move(other);
}

inline Sharpness& Sharpness::operator=(Sharpness&& other) noexcept
{
    if (this != &other)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_Destruct(m_backendHandle);
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }

    return *this;
}

inline double Sharpness::Measure(const Image& image)
{
    double calculated_value;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_Measure(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image), &calculated_value);
    });

    return calculated_value;
}

inline bool Sharpness::IsPixelFormatSupported(PixelFormatName pixelFormatName) const
{
    PEAK_IPL_BOOL8 isPixelFormatSupported = 0;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_GetIsPixelFormatSupported(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormatName),
            reinterpret_cast<PEAK_IPL_BOOL8*>(&isPixelFormatSupported));
    });

    return isPixelFormatSupported > 0;
}

inline std::vector<PixelFormatName> Sharpness::SupportedPixelFormats() const
{
    size_t sizeOfData{};
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList(
            m_backendHandle, nullptr, &sizeOfData);
    });

    std::vector<PixelFormatName> formats(sizeOfData);
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_GetSupportedPixelFormatList(
            m_backendHandle, reinterpret_cast<PEAK_IPL_PIXEL_FORMAT*>(formats.data()), &sizeOfData);
    });

    return formats;
}

inline void Sharpness::SetAlgorithm(SharpnessAlgorithm algorithm)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_SetAlgorithm(
            m_backendHandle, static_cast<PEAK_IPL_SHARPNESS_ALGORITHM>(algorithm));
    });
}

inline Sharpness::SharpnessAlgorithm Sharpness::Algorithm() const
{
    SharpnessAlgorithm algorithm;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_GetAlgorithm(
            m_backendHandle, reinterpret_cast<PEAK_IPL_SHARPNESS_ALGORITHM*>(&algorithm));
    });

    return algorithm;
}

inline Size2D Sharpness::ROIMinSize() const
{
    PEAK_IPL_SIZE_2D size{};

    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_GetROIMinimumSize(m_backendHandle, &size); });

    return Size2D{ size.width, size.height };
}

inline void Sharpness::SetROIs(const SharpnessROIList& rois)
{
    ExecuteAndMapReturnCodes([&] {
        std::vector<PEAK_IPL_SHARPNESS_ROI> sharpness_rois{};

        std::transform(std::cbegin(rois), std::cend(rois), std::back_inserter(sharpness_rois), [](const auto roi) {
            return PEAK_IPL_SHARPNESS_ROI{ PEAK_IPL_RECT_2D{ { roi.rect.topLeft().x, roi.rect.topLeft().y },
                                              { roi.rect.size().width, roi.rect.size().height } },
                roi.xSamplingInterval, roi.ySamplingInterval,
                static_cast<std::underlying_type_t<SharpnessROIWeight>>(roi.weight) };
        });

        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_SetROIs(
            m_backendHandle, sharpness_rois.data(), sharpness_rois.size());
    });
}

inline void Sharpness::SetROI(const SharpnessROI& roi)
{
    SharpnessROIList rois{ roi };
    SetROIs(rois);
}

inline void Sharpness::SetROI(const Rect2D& roi)
{
    SharpnessROI sharpnessRoi{ roi, 1, 1, SharpnessROIWeight::Medium };
    SetROI(sharpnessRoi);
}

inline Sharpness::SharpnessROIList Sharpness::ROIs() const
{
    size_t roiListSize{};
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_GetROIs(m_backendHandle, nullptr, &roiListSize); });

    std::vector<PEAK_IPL_SHARPNESS_ROI> sharpness_rois(roiListSize);
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageSharpness_GetROIs(
            m_backendHandle, sharpness_rois.data(), &roiListSize);
    });

    SharpnessROIList rois{};

    std::transform(
        std::cbegin(sharpness_rois), std::cend(sharpness_rois), std::back_inserter(rois), [](const auto roi) {
            return SharpnessROI{ Rect2D{ roi.rect.position.x, roi.rect.position.y, roi.rect.size.width,
                                     roi.rect.size.height },
                roi.xSamplingInterval, roi.ySamplingInterval, static_cast<SharpnessROIWeight>(roi.weight) };
        });

    return rois;
}

inline bool operator==(const Sharpness::SharpnessROI& lhs, const Sharpness::SharpnessROI& rhs)
{
    return lhs.rect == rhs.rect && lhs.weight == rhs.weight && lhs.xSamplingInterval == rhs.xSamplingInterval
        && lhs.ySamplingInterval == rhs.ySamplingInterval;
}

inline bool operator!=(const Sharpness::SharpnessROI& lhs, const Sharpness::SharpnessROI& rhs)
{
    return !(lhs == rhs);
}

} /* namespace ipl */
} /* namespace peak */