peak_ipl_image.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 <cstddef>
#include <cstdint>
#include <utility>

namespace
{
class ImageBackendAccessor;
}

namespace peak
{
namespace ipl
{

class Image
{
public:
    Image();
    Image(const peak::ipl::PixelFormat& pixelFormat, size_t width, size_t height);
    Image(
        const peak::ipl::PixelFormat& pixelFormat, uint8_t* buffer, size_t bufferSize, size_t width, size_t height);
    Image(const peak::ipl::PixelFormat& pixelFormat, size_t width, size_t height, uint64_t timestamp_ns);
    Image(
        const peak::ipl::PixelFormat& pixelFormat, uint8_t* buffer, size_t bufferSize, size_t width, size_t height, uint64_t timestamp_ns);
    ~Image();
    Image(const Image& other) = delete;
    Image& operator=(const Image& other) = delete;
    Image(Image&& other) noexcept;
    Image& operator=(Image&& other) noexcept;

    size_t Width() const;

    size_t Height() const;

    uint8_t* PixelPointer(size_t xPos, size_t yPos) const;

    size_t ByteCount() const;

    peak::ipl::PixelFormat PixelFormat() const;

    uint8_t* Data() const;

    Image ConvertTo(const peak::ipl::PixelFormat& outputPixelFormat,
        peak::ipl::ConversionMode conversionMode = peak::ipl::ConversionMode::Fast) const;

    Image ConvertTo(const peak::ipl::PixelFormat& outputPixelFormat, uint8_t* outputImageBuffer,
        size_t outputImageBufferSize,
        peak::ipl::ConversionMode conversionMode = peak::ipl::ConversionMode::Fast) const;

    Image Clone() const;

    bool Empty() const;

    uint64_t Timestamp() const;

    bool operator==(const Image& img) const;

    bool operator!=(const Image& img) const;

private:
    friend ImageBackendAccessor;
    explicit Image(PEAK_IPL_IMAGE_HANDLE imageHandle) noexcept;
    PEAK_IPL_IMAGE_HANDLE m_backendHandle{};
};

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

namespace
{

// helper class to access the C-backend of the Image, which are hidden from the public interface
class ImageBackendAccessor
{
public:
    static PEAK_IPL_IMAGE_HANDLE BackendHandle(const peak::ipl::Image& image)
    {
        return image.m_backendHandle;
    }
    static peak::ipl::Image CreateImage(PEAK_IPL_IMAGE_HANDLE imageHandle)
    {
        return peak::ipl::Image(imageHandle);
    }
};

} /* namespace */

#include <peak_ipl/algorithm/peak_ipl_image_converter.hpp>

namespace peak
{
namespace ipl
{

inline Image::Image()
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Construct(PEAK_IPL_PIXEL_FORMAT_INVALID, 0, 0, &m_backendHandle);
    });
}

inline Image::Image(const peak::ipl::PixelFormat& pixelFormat, size_t width, size_t height)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Construct(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormat.PixelFormatName()), width, height, &m_backendHandle);
    });
}

inline Image::Image(
    const peak::ipl::PixelFormat& pixelFormat, uint8_t* buffer, size_t bufferSize, size_t width, size_t height)
{
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_ConstructFromBuffer(
            static_cast<PEAK_IPL_PIXEL_FORMAT>(pixelFormat.PixelFormatName()), buffer, bufferSize, width, height,
            &m_backendHandle);
    });
}

inline Image::Image(const peak::ipl::PixelFormat& pixelFormat, size_t width, size_t height, uint64_t timestamp_ns) :
    Image::Image(pixelFormat, width, height)
{
        ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_SetTimestamp(m_backendHandle, timestamp_ns);
    });
}

inline Image::Image(
    const peak::ipl::PixelFormat& pixelFormat, uint8_t* buffer, size_t bufferSize, size_t width, size_t height, uint64_t timestamp_ns) :
    Image::Image(pixelFormat, buffer, bufferSize, width, height)
{
 ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_SetTimestamp(m_backendHandle, timestamp_ns);
    });
}

inline Image::Image(PEAK_IPL_IMAGE_HANDLE imageHandle) noexcept
    : m_backendHandle(imageHandle)
{}

inline Image::~Image()
{
    (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Destruct(m_backendHandle);
}

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

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

    return *this;
}

inline size_t Image::Width() const
{
    size_t width = 0;

    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_GetWidth(m_backendHandle, &width); });

    return width;
}

inline size_t Image::Height() const
{
    size_t height = 0;

    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_GetHeight(m_backendHandle, &height); });

    return height;
}

inline uint8_t* Image::PixelPointer(size_t xPos, size_t yPos) const
{
    uint8_t* pixelPosition = nullptr;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_GetPixelPointer(m_backendHandle, xPos, yPos, &pixelPosition);
    });

    return pixelPosition;
}

inline size_t Image::ByteCount() const
{
    size_t byteCount = 0;

    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_GetByteCount(m_backendHandle, &byteCount); });

    return byteCount;
}

inline peak::ipl::PixelFormat Image::PixelFormat() const
{
    peak::ipl::PixelFormatName pixelFormatName = PixelFormatName::Invalid;

    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_GetPixelFormat(
            m_backendHandle, reinterpret_cast<PEAK_IPL_PIXEL_FORMAT*>(&pixelFormatName));
    });

    return peak::ipl::PixelFormat{ pixelFormatName };
}

inline uint8_t* Image::Data() const
{
    uint8_t* data = nullptr;

    ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_GetData(m_backendHandle, &data); });

    return data;
}

inline Image Image::ConvertTo(
    const peak::ipl::PixelFormat& outputPixelFormat, peak::ipl::ConversionMode conversionMode) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_ConvertTo(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()),
            static_cast<PEAK_IPL_CONVERSION_MODE>(conversionMode), &outputImageHandle);
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

inline Image Image::ConvertTo(const peak::ipl::PixelFormat& outputPixelFormat, uint8_t* outputImageBuffer,
    size_t outputImageBufferSize, peak::ipl::ConversionMode conversionMode) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_ConvertToBuffer(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), outputImageBuffer,
            outputImageBufferSize, static_cast<PEAK_IPL_CONVERSION_MODE>(conversionMode), &outputImageHandle);
    });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

inline Image Image::Clone() const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes(
        [&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Clone(m_backendHandle, &outputImageHandle); });

    return ImageBackendAccessor::CreateImage(outputImageHandle);
}

inline bool Image::Empty() const
{
    return (m_backendHandle == nullptr) || (PixelFormat().PixelFormatName() == PixelFormatName::Invalid);
}

inline uint64_t Image::Timestamp() const
{
    uint64_t timestamp_ns;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_GetTimestamp(m_backendHandle, &timestamp_ns);
    });

    return timestamp_ns;
}

inline bool Image::operator==(const peak::ipl::Image& img) const
{
    if (img.ByteCount() != this->ByteCount())
    {
        return false;
    }
    if (img.Width() != this->Width())
    {
        return false;
    }
    if (img.Height() != this->Height())
    {
        return false;
    }
    if (img.PixelFormat().PixelFormatName() != this->PixelFormat().PixelFormatName())
    {
        return false;
    }
    if (img.Timestamp() != this->Timestamp())
    {
        return false;
    }

    return memcmp(img.Data(), this->Data(), img.ByteCount()) == 0;
}

inline bool Image::operator!=(const peak::ipl::Image& img) const
{
    return !(*this == img);
}

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