peak_ipl_image_converter.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_pixel_format.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>

#include <cstdint>
#include <utility>
#include <vector>

namespace peak
{
namespace ipl
{

class Image;

class ImageConverter final
{
public:
    ImageConverter();
    ~ImageConverter();
    ImageConverter(const ImageConverter& other) = delete;
    ImageConverter& operator=(const ImageConverter& other) = delete;
    ImageConverter(ImageConverter&& other) noexcept;
    ImageConverter& operator=(ImageConverter&& other) noexcept;

    ImageConverter(const peak::ipl::PixelFormat& inputPixelFormat,
        const peak::ipl::PixelFormat& outputPixelFormat, size_t width, size_t height, size_t imageCount = 5);

    void PreAllocateConversion(const peak::ipl::PixelFormat& inputPixelFormat,
        const peak::ipl::PixelFormat& outputPixelFormat, size_t width, size_t height, size_t imageCount = 5);

    peak::ipl::ConversionMode ConversionMode() const;

    void SetConversionMode(peak::ipl::ConversionMode conversionMode);

    std::vector<peak::ipl::PixelFormatName> SupportedOutputPixelFormatNames(
        const peak::ipl::PixelFormat& inputPixelFormat) const;

    Image Convert(const Image& inputImage, const peak::ipl::PixelFormat& outputPixelFormat) const;

    Image Convert(const Image& inputImage, const peak::ipl::PixelFormat& outputPixelFormat,
        uint8_t* outputImageBuffer, size_t outputImageBufferSize) const;

private:
    PEAK_IPL_IMAGE_CONVERTER_HANDLE m_backendHandle{};
};

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

#include <peak_ipl/types/peak_ipl_image.hpp>

namespace peak
{
namespace ipl
{

inline ImageConverter::ImageConverter()
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_Construct(&m_backendHandle); });
}

inline ImageConverter::ImageConverter(const peak::ipl::PixelFormat& inputPixelFormat,
    const peak::ipl::PixelFormat& outputPixelFormat, const size_t width, const size_t height, const size_t imageCount)
{
    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_Construct(&m_backendHandle); });
    PreAllocateConversion(inputPixelFormat, outputPixelFormat, width, height, imageCount);
}

inline ImageConverter::~ImageConverter()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_Destruct(m_backendHandle);
    }
}

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

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

    return *this;
}

inline void ImageConverter::PreAllocateConversion(const peak::ipl::PixelFormat& inputPixelFormat,
    const peak::ipl::PixelFormat& outputPixelFormat, const size_t width, const size_t height,
    const size_t imageCount)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_PreAllocateConversion(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(inputPixelFormat.PixelFormatName()),
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), width, height, imageCount);
    });
}

inline peak::ipl::ConversionMode ImageConverter::ConversionMode() const
{
    peak::ipl::ConversionMode conversionMode = peak::ipl::ConversionMode::Fast;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_GetConversionMode(
            m_backendHandle, reinterpret_cast<PEAK_IPL_CONVERSION_MODE*>(&conversionMode));
    });

    return conversionMode;
}

inline void ImageConverter::SetConversionMode(peak::ipl::ConversionMode conversionMode)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_SetConversionMode(
            m_backendHandle, static_cast<PEAK_IPL_CONVERSION_MODE>(conversionMode));
    });
}

inline std::vector<PixelFormatName> ImageConverter::SupportedOutputPixelFormatNames(
    const PixelFormat& inputPixelFormat) const
{
    size_t size = 0;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats(
            m_backendHandle, static_cast<PEAK_IPL_PIXEL_FORMAT>(inputPixelFormat.PixelFormatName()), nullptr, &size);
    });
    std::vector<PixelFormatName> supportedOutputPixelFormats(size);
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_GetSupportedOutputPixelFormats(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(inputPixelFormat.PixelFormatName()),
            reinterpret_cast<PEAK_IPL_PIXEL_FORMAT*>(supportedOutputPixelFormats.data()), &size);
    });

    return supportedOutputPixelFormats;
}

inline Image ImageConverter::Convert(const Image& inputImage, const PixelFormat& outputPixelFormat) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_Convert(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage),
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), &outputImageHandle);
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

inline Image ImageConverter::Convert(const Image& inputImage, const PixelFormat& outputPixelFormat,
    uint8_t* outputImageBuffer, size_t outputImageBufferSize) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_ConvertToBuffer(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage),
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), outputImageBuffer,
            outputImageBufferSize, &outputImageHandle);
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

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