peak_ipl_edge_enhancement.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_simple_types.hpp>
#include <peak_ipl/types/peak_ipl_range.hpp>
#include <peak_ipl/types/peak_ipl_image.hpp>
 
#include <type_traits>
#include <algorithm>
#include <cstdint>
#include <iterator>
#include <vector>
 
namespace peak
{
namespace ipl
{
class Image;
enum class PixelFormatName;
class EdgeEnhancement final
{
public:
    EdgeEnhancement();
    
    ~EdgeEnhancement();
 
    EdgeEnhancement(const EdgeEnhancement& other);
 
    EdgeEnhancement& operator=(const EdgeEnhancement& other);
 
    EdgeEnhancement(EdgeEnhancement&& other) noexcept;
 
    EdgeEnhancement& operator=(EdgeEnhancement&& other) noexcept;
 
    inline void ProcessInPlace(Image& image) const;
 
    PEAK_IPL_NO_DISCARD inline Image Process(const Image& image) const;
 
    PEAK_IPL_NO_DISCARD inline bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;
 
    inline void SetFactor(std::uint32_t factor);
 
    PEAK_IPL_NO_DISCARD inline std::uint32_t Factor() const;
 
    PEAK_IPL_NO_DISCARD inline std::uint32_t DefaultFactor() const;
 
    PEAK_IPL_NO_DISCARD inline peak::ipl::Range<std::uint32_t> Range() const;
 
private:
    PEAK_IPL_EDGE_ENHANCEMENT_HANDLE m_backendHandle{};
};
 
inline EdgeEnhancement::EdgeEnhancement()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_Construct(&m_backendHandle); });
}
 
inline EdgeEnhancement::~EdgeEnhancement()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_Destruct(m_backendHandle);
    }
}
 
inline EdgeEnhancement::EdgeEnhancement(EdgeEnhancement&& other) noexcept
{
    *this = std::move(other);
}
 
inline EdgeEnhancement::EdgeEnhancement(const EdgeEnhancement& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline EdgeEnhancement& EdgeEnhancement::operator=(const EdgeEnhancement& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline EdgeEnhancement& EdgeEnhancement::operator=(EdgeEnhancement&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_Destruct(m_backendHandle);
        }
 
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }
 
    return *this;
}
 
inline void EdgeEnhancement::ProcessInPlace(Image& image) const
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_ProcessInPlace(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image));
    });
}
 
inline Image EdgeEnhancement::Process(const Image& image) const
{
    PEAK_IPL_IMAGE_HANDLE handle{};
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_Process(
            m_backendHandle, ImageBackendAccessor::BackendHandle(image), &handle);
    });
 
    return ImageBackendAccessor::CreateImage(handle);
}
 
inline bool EdgeEnhancement::IsPixelFormatSupported(PixelFormatName pixelFormatName) const
{
    PEAK_IPL_BOOL8 isPixelFormatSupported = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_IsPixelFormatSupported(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormatName), &isPixelFormatSupported);
    });
 
    return isPixelFormatSupported != 0;
}
 
inline void EdgeEnhancement::SetFactor(std::uint32_t factor)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_SetFactor(
            m_backendHandle, factor);
    });
}
 
inline uint32_t EdgeEnhancement::Factor() const
{
    uint32_t factor{};
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_GetFactor(
            m_backendHandle, &factor);
    });
 
    return factor;
}
 
inline uint32_t EdgeEnhancement::DefaultFactor() const
{
    uint32_t factor{};
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_GetDefaultFactor(
            m_backendHandle, &factor);
    });
 
    return factor;
}
 
inline Range<std::uint32_t> EdgeEnhancement::Range() const
{
    PEAK_IPL_RANGE range{};
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_EdgeEnhancement_GetFactorRange(
            m_backendHandle, &range);
    });
 
    return { range.min, range.max, range.inc };
}
 
} /* namespace ipl */
} /* namespace peak */