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