peak_ipl_binning.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 Binning final
{
public:
    enum class BinningMode : uint16_t
    {
        Average = 0,

        Sum = 1
    };

    Binning();

    ~Binning();

    Binning(const Binning& other);

    Binning& operator=(const Binning& other);

    Binning(Binning&& other) noexcept;

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

    void SetBinningX(uint8_t value);

    PEAK_IPL_NO_DISCARD uint8_t BinningX() const;

    void SetBinningY(uint8_t value);

    PEAK_IPL_NO_DISCARD uint8_t BinningY() const;

    PEAK_IPL_NO_DISCARD uint8_t BinningMin() const;

    PEAK_IPL_NO_DISCARD uint8_t BinningMax() const;

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

    void SetMode(BinningMode mode);

    PEAK_IPL_NO_DISCARD BinningMode Mode() const;

    PEAK_IPL_NO_DISCARD bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;

    PEAK_IPL_NO_DISCARD Image Process(const Image& inputImage) const;

private:
    PEAK_IPL_BINNING_HANDLE m_backendHandle{};
};

inline Binning::Binning()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_Construct(&m_backendHandle); });
}

inline Binning::~Binning()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_Destruct(m_backendHandle);
    }
}

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

    m_backendHandle = other.m_backendHandle;
}

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

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

    m_backendHandle = other.m_backendHandle;

    return *this;
}

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

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

    return *this;
}

inline void Binning::SetBinningX(uint8_t value)
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_SetBinningX(m_backendHandle, &value); });
}

inline void Binning::SetBinningY(uint8_t value)
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_SetBinningY(m_backendHandle, &value); });
}

inline uint8_t Binning::BinningX() const
{
    uint8_t value;

    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_GetBinningX(m_backendHandle, &value); });

    return value;
}

inline uint8_t Binning::BinningY() const
{
    uint8_t value;

    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_GetBinningY(m_backendHandle, &value); });

    return value;
}

inline uint8_t Binning::BinningMin() const
{
    uint8_t value;

    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_GetBinningMin(m_backendHandle, &value); });

    return value;
}

inline uint8_t Binning::BinningMax() const
{
    uint8_t value;

    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_GetBinningMax(m_backendHandle, &value); });

    return value;
}

inline Size2D Binning::ExpectedOutputSize(Size2D inputSize, PixelFormatName pixelFormat) const
{
    Size2D size{};
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_ExpectedOutputSize(m_backendHandle, &size.width, &size.height,
            inputSize.width, inputSize.height, static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormat));
    });

    return size;
}

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

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

    return isPixelFormatSupported > 0;
}

inline Image Binning::Process(const Image& inputImage) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_Process(
            m_backendHandle, ImageBackendAccessor::BackendHandle(inputImage), &outputImageHandle);
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

inline void Binning::SetMode(Binning::BinningMode mode)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_SetBinningMode(
            m_backendHandle, reinterpret_cast<PEAK_IPL_BINNINGMODE*>(&mode));
    });
}

inline Binning::BinningMode Binning::Mode() const
{
    BinningMode value;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Binning_GetBinningMode(
            m_backendHandle, reinterpret_cast<PEAK_IPL_BINNINGMODE*>(&value));
    });

    return value;
}


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