peak_ipl_decimation.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_image.hpp>
#include <peak_ipl/types/peak_ipl_pixel_format.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>

 
namespace peak
{
namespace ipl
{
 
class Decimation final
{
public:
    Decimation();
    
    ~Decimation();

    Decimation(const Decimation& other);

    Decimation& operator=(const Decimation& other);

    Decimation(Decimation&& other) noexcept;

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

    void SetDecimationX(uint8_t value);

    PEAK_IPL_NO_DISCARD uint8_t DecimationX() const;

    void SetDecimationY(uint8_t value);

    PEAK_IPL_NO_DISCARD uint8_t DecimationY() const;

    PEAK_IPL_NO_DISCARD uint8_t DecimationMin() const;
    PEAK_IPL_NO_DISCARD uint8_t DecimationMax() const;

    PEAK_IPL_NO_DISCARD Size2D ExpectedOutputSize(Size2D inputSize, PixelFormatName pixelFormat) const;

    PEAK_IPL_NO_DISCARD bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;

    PEAK_IPL_NO_DISCARD Image Process(const Image& inputImage) const;
 
private:
    PEAK_IPL_DECIMATION_HANDLE m_backendHandle{};
};
 
inline Decimation::Decimation()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_Construct(&m_backendHandle); });
}
 
inline Decimation::~Decimation()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_Destruct(m_backendHandle);
    }
}
 
inline Decimation::Decimation(const Decimation& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline Decimation& Decimation::operator=(const Decimation& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline Decimation::Decimation(Decimation&& other) noexcept
{
    *this = std::move(other);
}
 
inline Decimation& Decimation::operator=(Decimation&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_Destruct(m_backendHandle);
        }
 
        m_backendHandle = other.m_backendHandle;
        other.m_backendHandle = nullptr;
    }
 
    return *this;
}
 
inline void Decimation::SetDecimationX(uint8_t value)
{
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_SetDecimationX(m_backendHandle, &value); });
}
 
inline void Decimation::SetDecimationY(uint8_t value)
{
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_SetDecimationY(m_backendHandle, &value); });
}
 
inline uint8_t Decimation::DecimationX() const
{
    uint8_t value;
 
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_GetDecimationX(m_backendHandle, &value); });
 
    return value;
}
 
inline uint8_t Decimation::DecimationY() const
{
    uint8_t value;
 
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_GetDecimationY(m_backendHandle, &value); });
 
    return value;
}
 
inline uint8_t Decimation::DecimationMin() const
{
    uint8_t value;
 
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_GetDecimationMin(m_backendHandle, &value); });
 
    return value;
}
 
inline uint8_t Decimation::DecimationMax() const
{
    uint8_t value;
 
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_GetDecimationMax(m_backendHandle, &value); });
 
    return value;
}
 
inline Size2D Decimation::ExpectedOutputSize(Size2D inputSize, PixelFormatName pixelFormat) const
{
    Size2D size{};
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_ExpectedOutputSize(m_backendHandle, &size.width, &size.height,
            inputSize.width, inputSize.height, static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormat));
    });
 
    return size;
}
 
inline bool Decimation::IsPixelFormatSupported(PixelFormatName pixelFormatName) const
{
    PEAK_IPL_BOOL8 isPixelFormatSupported = 0;
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_IsPixelformatSupported(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormatName),
            reinterpret_cast<PEAK_IPL_BOOL8*>(&isPixelFormatSupported));
    });
 
    return isPixelFormatSupported > 0;
}
 
inline Image Decimation::Process(const Image& inputImage) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Decimation_Process(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
} /* namespace ipl */
} /* namespace peak */