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 <peak_ipl/types/peak_ipl_range.hpp>
#include <peak_ipl/types/peak_ipl_interval.hpp>
#include <cstdint>
#include <utility>
#include <vector>

namespace peak
{
namespace ipl
{
 
class Image;

class ImageConverter final
{
public:
    ImageConverter();
    
    ~ImageConverter();

    ImageConverter(const ImageConverter& other);

    ImageConverter& operator=(const ImageConverter& other);

    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_NO_DISCARD peak::ipl::ConversionMode ConversionMode() const;

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

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

    PEAK_IPL_NO_DISCARD 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;

    PEAK_IPL_NO_DISCARD Image Convert(const Image& inputImage, const peak::ipl::PixelFormat& outputPixelFormat,
        double factor, double offset = 0.0) const;

    PEAK_IPL_NO_DISCARD Image Convert(const Image& inputImage, const peak::ipl::PixelFormat& outputPixelFormat,
        uint8_t* outputImageBuffer, size_t outputImageBufferSize, double factor, double offset = 0.0) const;

    PEAK_IPL_NO_DISCARD Image Convert(const Image& inputImage, const peak::ipl::PixelFormat& outputPixelFormat,
        peak::ipl::Interval<double> interval) const;

    PEAK_IPL_NO_DISCARD Image Convert(const Image& inputImage, const peak::ipl::PixelFormat& outputPixelFormat,
        uint8_t* outputImageBuffer, size_t outputImageBufferSize, peak::ipl::Interval<double> interval) 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(const ImageConverter& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline ImageConverter& ImageConverter::operator=(const ImageConverter& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes(
                [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline ImageConverter::ImageConverter(ImageConverter&& other) noexcept
{
    *this = std::move(other);
}
 
inline ImageConverter& ImageConverter::operator=(ImageConverter&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (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);
}
 
inline Image ImageConverter::Convert(const Image& inputImage, const PixelFormat& outputPixelFormat, peak::ipl::Interval<double> interval) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_ConvertFromInterval(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage),
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), interval.Start(),
            interval.End(), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image ImageConverter::Convert(const Image& inputImage, const PixelFormat& outputPixelFormat,
    uint8_t* outputImageBuffer, size_t outputImageBufferSize, peak::ipl::Interval<double> interval) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_ConvertToBufferFromInterval(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage), interval.Start(), interval.End(),
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), outputImageBuffer,
            outputImageBufferSize, &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image ImageConverter::Convert(
    const Image& inputImage, const PixelFormat& outputPixelFormat, double factor, double offset) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_ConvertWithFactorAndOffset(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage),
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), factor, offset, &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image ImageConverter::Convert(const Image& inputImage, const PixelFormat& outputPixelFormat,
    uint8_t* outputImageBuffer, size_t outputImageBufferSize, double factor, double offset) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_ImageConverter_ConvertToBufferWithFactorAndOffset(m_backendHandle,
            ImageBackendAccessor::BackendHandle(inputImage), factor, offset,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), outputImageBuffer,
            outputImageBufferSize, &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
} /* namespace ipl */
} /* namespace peak */