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_interval.hpp>
#include <peak_ipl/types/peak_ipl_pixel_format.hpp>
#include <peak_ipl/types/peak_ipl_simple_types.hpp>
 
#include <cstddef>
#include <cstdint>
#include <utility>
#include <type_traits>
 
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);
    
    Image& operator=(const Image& other);

    Image(Image&& other) noexcept;

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

    PEAK_IPL_NO_DISCARD size_t Width() const;

    PEAK_IPL_NO_DISCARD size_t Height() const;

    PEAK_IPL_NO_DISCARD peak::ipl::Size2D Size() const;

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

    template<typename T, typename = std::enable_if_t<std::is_arithmetic<T>::value>>
    PEAK_IPL_NO_DISCARD T* PixelPointer(size_t xPos, size_t yPos) const
    {
       return reinterpret_cast<T*>(PixelPointer(xPos, yPos));
    }

    PEAK_IPL_NO_DISCARD size_t ByteCount() const;

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

    PEAK_IPL_NO_DISCARD uint8_t* Data() const;

    template<typename T, typename = std::enable_if_t<std::is_arithmetic<T>::value>>
    PEAK_IPL_NO_DISCARD T* Data() const
    {
       return reinterpret_cast<T*>(Data());
    }

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

    PEAK_IPL_NO_DISCARD Image ConvertToWithFactor(const peak::ipl::PixelFormat& outputPixelFormat,
        double factor, double offset = 0.0, peak::ipl::ConversionMode conversionMode = peak::ipl::ConversionMode::Fast) const;

    PEAK_IPL_NO_DISCARD Image ConvertToWithFactor(const peak::ipl::PixelFormat& outputPixelFormat,
        uint8_t* outputImageBuffer, size_t outputImageBufferSize, double factor, double offset = 0.0,
        peak::ipl::ConversionMode conversionMode = peak::ipl::ConversionMode::Fast) const;

    inline Image ConvertToFromInterval(const peak::ipl::PixelFormat& outputPixelFormat, const peak::ipl::Interval<double>& interval,
                                       peak::ipl::ConversionMode conversionMode = peak::ipl::ConversionMode::Fast) const;

    inline Image ConvertToFromInterval(const peak::ipl::PixelFormat& outputPixelFormat, uint8_t* outputImageBuffer,
                                       size_t outputImageBufferSize, const peak::ipl::Interval<double>& interval, peak::ipl::ConversionMode conversionMode = peak::ipl::ConversionMode::Fast) const;

    template <typename Integer1, typename Integer2,
        typename std::enable_if_t<std::is_integral<Integer1>::value, int> = 0,
        typename std::enable_if_t<std::is_integral<Integer2>::value, int> = 0>
    PEAK_IPL_NO_DISCARD inline Image Scale(Integer1 width, Integer2 height, peak::ipl::InterpolationAlgorithm algorithm=InterpolationAlgorithm::linear) const
    {
        return Scale(peak::ipl::Size2D{static_cast<std::size_t>(width), static_cast<std::size_t>(height)}, algorithm);
    }

    PEAK_IPL_NO_DISCARD Image Scale(const peak::ipl::Size2D& size, peak::ipl::InterpolationAlgorithm algorithm=InterpolationAlgorithm::linear) const;

    PEAK_IPL_NO_DISCARD Image Scale(const peak::ipl::ScaleFactor& factor, peak::ipl::InterpolationAlgorithm algorithm=InterpolationAlgorithm::linear) const;

    template<typename FloatingPoint1, typename FloatingPoint2,
        typename std::enable_if_t<std::is_floating_point<FloatingPoint1>::value, int> = 0,
        typename std::enable_if_t<std::is_floating_point<FloatingPoint2>::value, int> = 0>
    PEAK_IPL_NO_DISCARD inline Image Scale(FloatingPoint1 scaleFactorX, FloatingPoint2 scaleFactorY, peak::ipl::InterpolationAlgorithm algorithm=InterpolationAlgorithm::linear) const
    {
        return Scale(peak::ipl::ScaleFactor{static_cast<double>(scaleFactorX), static_cast<double>(scaleFactorY)}, algorithm);
    }

    void ScaleInto(const peak::ipl::Size2D& size, uint8_t* buffer, std::size_t bufferSize, peak::ipl::InterpolationAlgorithm algorithm=InterpolationAlgorithm::linear) const;

    PEAK_IPL_NO_DISCARD Image Crop(const peak::ipl::Point2D& pos, const peak::ipl::Size2D& size) const;

    PEAK_IPL_NO_DISCARD Image Crop(const peak::ipl::Size2D& size) const;

    PEAK_IPL_NO_DISCARD Image Clone() const;

    PEAK_IPL_NO_DISCARD bool Empty() const;

    PEAK_IPL_NO_DISCARD uint64_t Timestamp() const;

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

    PEAK_IPL_NO_DISCARD bool operator!=(const Image& img) const;
 
private:
    friend ImageBackendAccessor;
 
    explicit Image(PEAK_IPL_IMAGE_HANDLE imageHandle, bool acquireReference=false);
 
    PEAK_IPL_IMAGE_HANDLE m_backendHandle{};
};
 
} /* namespace ipl */
} /* namespace peak */
 
namespace
{

class ImageBackendAccessor
{
public:
    PEAK_IPL_NO_DISCARD static PEAK_IPL_IMAGE_HANDLE BackendHandle(const peak::ipl::Image& image)
    {
        return image.m_backendHandle;
    }

    PEAK_IPL_NO_DISCARD static peak::ipl::Image CreateImage(PEAK_IPL_IMAGE_HANDLE imageHandle)
    {
        return peak::ipl::Image(imageHandle, false);
    }

    PEAK_IPL_NO_DISCARD static peak::ipl::Image CreateImageReference(PEAK_IPL_IMAGE_HANDLE imageHandle)
    {
        return peak::ipl::Image(imageHandle, true);
    }
};
 
} /* namespace */
 
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, bool acquireReference)
    : m_backendHandle(imageHandle)
{
    if (acquireReference && m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Acquire(m_backendHandle); });
    }
}
 
inline Image::~Image()
{
    if (m_backendHandle)
    {
        (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Destruct(m_backendHandle);
    }
}
 
inline Image::Image(const Image& other)
{
    if (other.m_backendHandle)
    {
        ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Acquire(other.m_backendHandle); });
    }
 
    m_backendHandle = other.m_backendHandle;
}
 
inline Image& Image::operator=(const Image& other)
{
    if (this != &other)
    {
        if (m_backendHandle)
        {
            (void)PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Destruct(m_backendHandle);
        }
 
        if (other.m_backendHandle)
        {
            ExecuteAndMapReturnCodes([&] { return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Acquire(other.m_backendHandle); });
        }
    }
 
    m_backendHandle = other.m_backendHandle;
 
    return *this;
}
 
inline Image::Image(Image&& other) noexcept
{
    *this = std::move(other);
}
 
inline Image& Image::operator=(Image&& other) noexcept
{
    if (this != &other)
    {
        if (m_backendHandle != nullptr)
        {
            (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 peak::ipl::Size2D Image::Size() const
{
    return {Width(), 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::ConvertToWithFactor(
    const peak::ipl::PixelFormat& outputPixelFormat, double factor, double offset, peak::ipl::ConversionMode conversionMode) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_ConvertToWithFactorAndOffset(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), factor, offset,
            static_cast<PEAK_IPL_CONVERSION_MODE>(conversionMode), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image Image::ConvertToWithFactor(
    const peak::ipl::PixelFormat& outputPixelFormat, uint8_t* outputImageBuffer, size_t outputImageBufferSize,
    double factor, double offset, peak::ipl::ConversionMode conversionMode) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_ConvertToBufferWithFactorAndOffset(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), factor, offset, outputImageBuffer, outputImageBufferSize,
            static_cast<PEAK_IPL_CONVERSION_MODE>(conversionMode), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image Image::ConvertToFromInterval(const peak::ipl::PixelFormat& outputPixelFormat,
                                          const peak::ipl::Interval<double>& interval, peak::ipl::ConversionMode conversionMode) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_ConvertToFromInterval(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), interval.Start(), interval.End(),
            static_cast<PEAK_IPL_CONVERSION_MODE>(conversionMode), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image Image::ConvertToFromInterval(const peak::ipl::PixelFormat& outputPixelFormat,
                                          uint8_t* outputImageBuffer, size_t outputImageBufferSize, const peak::ipl::Interval<double>& interval,
                                          peak::ipl::ConversionMode conversionMode) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_ConvertToBufferFromInterval(m_backendHandle,
            static_cast<PEAK_IPL_PIXEL_FORMAT>(outputPixelFormat.PixelFormatName()), interval.Start(), interval.End(), outputImageBuffer,
            outputImageBufferSize, static_cast<PEAK_IPL_CONVERSION_MODE>(conversionMode), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image Image::Scale(const Size2D& size, peak::ipl::InterpolationAlgorithm algorithm) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    const PEAK_IPL_SIZE_2D size_in{size.width, size.height};
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Scale(m_backendHandle, &size_in, static_cast<PEAK_IPL_INTERPOLATION_ALGORITHM>(algorithm), &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image Image::Scale(const ScaleFactor& factor, peak::ipl::InterpolationAlgorithm algorithm) const
{
    return Scale(Size2D{static_cast<size_t>(static_cast<double>(Width()) * factor.x), static_cast<size_t>(static_cast<double>(Height()) * factor.y)}, algorithm);
}
 
inline void Image::ScaleInto(const Size2D& size, uint8_t* buffer, std::size_t bufferSize, peak::ipl::InterpolationAlgorithm algorithm) const
{
    const PEAK_IPL_SIZE_2D size_in{size.width, size.height};
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_ScaleInto(m_backendHandle, &size_in, buffer, bufferSize, static_cast<PEAK_IPL_INTERPOLATION_ALGORITHM>(algorithm));
    });
}
 
 
inline Image Image::Crop(const Point2D& pos, const Size2D& size) const
{
    PEAK_IPL_IMAGE_HANDLE outputImageHandle = nullptr;
    const PEAK_IPL_POINT_2D pos_in{pos.x, pos.y};
    const PEAK_IPL_SIZE_2D size_in{size.width, size.height};
 
    ExecuteAndMapReturnCodes([&] {
        return PEAK_IPL_C_ABI_PREFIX PEAK_IPL_Image_Crop(m_backendHandle, &pos_in, &size_in, &outputImageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(outputImageHandle);
}
 
inline Image Image::Crop(const Size2D& size) const
{
    return Crop({0,0}, size);
}
 
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 */