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) = delete;
    Binning& operator=(const Binning& other) = delete;
    Binning(Binning&& other) noexcept;
    Binning& operator=(Binning&& other) noexcept;

    void SetBinningX(uint8_t value);
    
    uint8_t BinningX() const;

    void SetBinningY(uint8_t value);
    
    uint8_t BinningY() const;

    uint8_t BinningMin() const;
    uint8_t BinningMax() const;

    Size2D ExpectedOutputSize(Size2D inputSize, PixelFormatName pixelFormat) const;

    void SetMode(BinningMode mode);

    BinningMode Mode() const;

    bool IsPixelFormatSupported(PixelFormatName pixelFormatName) const;

    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_C_ABI_PREFIX PEAK_IPL_Binning_Destruct(m_backendHandle);
    }
}
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 */