peak_icv_image.ipp

Go to the documentation of this file.

 
#pragma once
 
#include <peak_common/types/peak_common_metadata.hpp>
#include <peak_icv/types/peak_icv_region.hpp>
#include <peak_icv/utils/peak_icv_metadata_conversion.hpp>
#include <algorithm>
#include <cstring>
#include <utility>
 
namespace peak
{
namespace icv
{
inline peak_icv_image_handle Image::CreateFromFile(const std::string& path)
{
    peak_icv_image_handle handle{};
    detail::ExecuteAndMapReturnCodes([&]() {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_CreateFromFile(&handle, path.c_str());
    });
    return handle;
}
 
inline peak_icv_image_handle Image::CreateFromFile(const std::string& path, peak::common::PixelFormat name)
{
    peak_icv_image_handle handle{};
    detail::ExecuteAndMapReturnCodes([&]() {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_CreateFromFileWithPixelFormat(
            &handle, path.c_str(), static_cast<peak_common_pixel_format>(name));
    });
    return handle;
}
 
inline peak_icv_image_info Image::CreateFromHandle(peak_icv_image_handle handle)
{
    peak_icv_image_info imageInfo{};
    detail::ExecuteAndMapReturnCodes([&]() {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_GetInfo(handle, &imageInfo, sizeof(imageInfo));
    });
 
    return imageInfo;
}
 
inline peak_icv_image_handle Image::CreateFromSize(peak::common::PixelFormat pixelFormat, const peak::common::Size& size)
{
    peak_icv_image_handle handle{};
    detail::ExecuteAndMapReturnCodes([&]() {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_Create(
            &handle, static_cast<peak_common_pixel_format>(pixelFormat), { size.GetWidth(), size.GetHeight() });
    });
    return handle;
}
 
inline peak_icv_image_handle Image::CreateFromBuffer(
    peak::common::PixelFormat pixelFormat, const peak::common::Size& size, const uint8_t* buffer, size_t bufferSize)
{
    peak_icv_image_handle handle{};
    detail::ExecuteAndMapReturnCodes([&]() {
        peak_icv_image_info info{ static_cast<peak_common_pixel_format>(pixelFormat), { size.GetWidth(), size.GetHeight() }, bufferSize,
            const_cast<uint8_t*>(buffer) };
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_CreateFromImageInfo(&handle, info, sizeof(info));
    });
    return handle;
}
 
inline peak::common::Metadata Image::AddCaptureInformationDataToMetadata(
    peak_icv_capture_information captureInformationC, peak::common::Metadata metadata)
{
    metadata.SetValueByKey<peak::common::MetadataKey::DeviceTimestamp>(captureInformationC.relative_timestamp);
    metadata.SetValueByName<decltype(captureInformationC.binning_factor.x)>(
        "BinningHorizontal", std::move(captureInformationC.binning_factor.x));
    metadata.SetValueByName<decltype(captureInformationC.binning_factor.y)>(
        "BinningVertical", std::move(captureInformationC.binning_factor.y));
    return metadata;
}
 
inline Image::Image(peak_icv_image_handle handle, peak_icv_image_info info)
    : m_imageHandle{ handle }
    , m_size{ info.size.width, info.size.height }
    , m_buffer{ info.buffer }
    , m_pixelFormatInfo{ static_cast<peak::common::PixelFormat>(info.pixelFormat) }
{}
 
#if WITH_peak_ipl
inline Image::Image(const peak::ipl::Image& image)
    : Image(CreateFromBuffer(static_cast<peak::common::PixelFormat>(image.PixelFormat().PixelFormatName()),
          peak::common::Size{ static_cast<uint32_t>(image.Width()), static_cast<uint32_t>(image.Height()) }, image.Data(),
          image.ByteCount()))
{
    peak_icv_capture_information captureInformationC{ { 1, 1 }, image.Timestamp(), {} };
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_SetCaptureInformation(m_imageHandle, captureInformationC, sizeof(captureInformationC));
    });
 
    m_metaData = std::make_unique<peak::common::Metadata>(
        AddCaptureInformationDataToMetadata(captureInformationC, peak::common::Metadata{}));
    m_image = image;
}
#endif
 
inline Image::Image(const peak::common::IImageView& imageView)
    : Image(CreateFromBuffer(imageView.GetPixelFormat(), imageView.GetSize(), imageView.GetData(), imageView.GetSizeInBytes()))
{
    const auto metadata = imageView.GetMetadata();
    SetMetadata(*metadata);
}
 
inline Image::Image(const std::string& path)
    : Image{ CreateFromFile(path) }
{}
 
inline Image::Image(const std::string& path, peak::common::PixelFormat name)
    : Image{ CreateFromFile(path, name) }
{}
 
inline Image::Image(peak::common::PixelFormat pixelFormat, uint8_t* buffer, size_t bufferSize, const peak::common::Size& imageSize)
    : Image{ CreateFromBuffer(pixelFormat, imageSize, buffer, bufferSize),
        { static_cast<peak_common_pixel_format>(pixelFormat), { imageSize.GetWidth(), imageSize.GetHeight() }, bufferSize, buffer } }
{}
 
inline Image::Image(peak::common::PixelFormat pixelFormat, const peak::common::Size& imageSize)
    : Image{ CreateFromSize(pixelFormat, imageSize) }
{}
 
inline Image::Image(peak_icv_image_handle imageHandle)
    : Image{ imageHandle, CreateFromHandle(imageHandle) }
{}
 
inline Image::Image(const Image& other)
    : Image{ other.m_imageHandle, CreateFromHandle(other.m_imageHandle) }
{
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_IncreaseUseCount(other.m_imageHandle);
    });
#if WITH_peak_ipl
    m_image = other.m_image;
#endif
}
 
inline Image::Image(Image&& other) noexcept
    : Image{ other.m_imageHandle, CreateFromHandle(other.m_imageHandle) }
{
 
#if WITH_peak_ipl
    m_image = std::move(other.m_image);
#endif
    other.m_imageHandle = nullptr;
}
 
inline Image& Image::operator=(const Image& other)
{
    if (this->m_imageHandle != other.m_imageHandle)
    {
        if (m_imageHandle)
        {
            detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_Destroy(m_imageHandle);
            });
        }
 
        detail::ExecuteAndMapReturnCodes([&] {
            return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_IncreaseUseCount(other.m_imageHandle);
        });
        m_imageHandle = other.m_imageHandle;
        m_size = other.m_size;
        m_pixelFormatInfo = other.m_pixelFormatInfo;
        m_buffer = other.m_buffer;
#if WITH_peak_ipl
        m_image = other.m_image;
#endif
    }
 
    return *this;
}
 
inline Image& Image::operator=(Image&& other) noexcept
{
    if (this->m_imageHandle != other.m_imageHandle)
    {
        if (m_imageHandle)
        {
            detail::ExecuteAndMapReturnCodes([&] {
                return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_Destroy(m_imageHandle);
            });
        }
 
        m_imageHandle = std::exchange(other.m_imageHandle, nullptr);
        m_size = other.m_size;
        m_pixelFormatInfo = other.m_pixelFormatInfo;
        m_buffer = std::exchange(other.m_buffer, nullptr);
#if WITH_peak_ipl
        m_image = std::move(other.m_image);
#endif
    }
 
    return *this;
}
 
inline Image::~Image()
{
    if (m_imageHandle != nullptr)
    {
        PEAK_ICV_C_ABI_PREFIX peak_icv_Image_Destroy(m_imageHandle);
    }
}
 
inline bool Image::operator==(const Image& rhs) const
{
    if (rhs.GetSizeInBytes() != this->GetSizeInBytes())
    {
        return false;
    }
    if (rhs.GetSize() != this->GetSize())
    {
        return false;
    }
    if (rhs.GetPixelFormat() != this->GetPixelFormat())
    {
        return false;
    }
    if (rhs.GetRegion() != this->GetRegion())
    {
        return false;
    }
    bool isSame{};
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_Compare(
            m_imageHandle, peak::common::detail::BackendAccessor<Image>::BackendHandle(rhs), &isSame);
    });
    return isSame;
}
 
inline Image Image::Copy() const
{
    Image tmpImg(m_pixelFormatInfo.GetPixelFormat(), m_size);
#if _MSC_VER
    memcpy_s(tmpImg.GetData(), tmpImg.GetSizeInBytes(), GetData(), GetSizeInBytes());
#else
    std::memcpy(tmpImg.GetData(), GetData(), GetSizeInBytes());
#endif
    return tmpImg;
}
 
inline peak::common::Size Image::GetSize() const
{
    return m_size;
}
 
inline uint8_t* Image::GetData() const
{
    return m_buffer;
}
 
inline size_t Image::GetSizeInBytes() const
{
    return m_pixelFormatInfo.GetSizeInBytes(m_size);
}
 
inline size_t Image::GetBytesPerLine() const
{
    return GetSizeInBytes() / m_size.GetHeight();
}
 
inline detail::handle_of_t<Image> Image::GetHandle() const
{
    return m_imageHandle;
}
 
inline peak::common::PixelFormat Image::GetPixelFormat() const
{
    return m_pixelFormatInfo.GetPixelFormat();
}
 
#if WITH_peak_ipl
inline peak::ipl::Image Image::GetIPLImage() const
{
    if (!m_image.Empty())
    {
        return m_image;
    }
 
    PEAK_IPL_IMAGE_HANDLE imageHandle{};
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_GetIPLImage(m_imageHandle, &imageHandle);
    });
 
    return ImageBackendAccessor::CreateImage(imageHandle);
}
#endif
 
inline experimental::Region Image::GetRegion() const
{
    experimental::Region region;
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_GetRegion(
            m_imageHandle, peak::common::detail::BackendAccessor<experimental::Region>::BackendHandleAddress(region));
    });
    return region;
}
 
inline void Image::SetRegion(const experimental::Region& region) const
{
    const peak_icv_region_handle regionHandle = peak::common::detail::BackendAccessor<experimental::Region>::BackendHandle(region);
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_SetRegion(m_imageHandle, regionHandle);
    });
}
 
inline void Image::ResetRegion() const
{
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_ResetRegion(m_imageHandle);
    });
}
 
inline Image Image::ConvertPixelFormat(peak::common::PixelFormat pixelFormat) const
{
    Image outputImage(pixelFormat, GetSize());
    const auto imageHandle = peak::common::detail::BackendAccessor<Image>::BackendHandle(outputImage);
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_ConvertPixelFormat(
            m_imageHandle, static_cast<peak_common_pixel_format>(pixelFormat), imageHandle);
    });
    return outputImage;
}
 
inline void Image::SetMetadata(const peak::common::Metadata& metadata)
{
    auto captureInformationC = peak::icv::detail::CreateCCaptureInformationFromMetadata(metadata);
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_SetCaptureInformation(m_imageHandle, captureInformationC, sizeof(captureInformationC));
    });
 
    m_metaData = std::make_unique<peak::common::Metadata>(AddCaptureInformationDataToMetadata(captureInformationC, metadata));
}
 
inline peak::common::Metadata Image::GetMetadata() const
{
 
    peak_icv_capture_information captureInformationC;
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_GetCaptureInformation(
            m_imageHandle, &captureInformationC, sizeof(captureInformationC));
    });
 
    if (!m_metaData)
    {
        m_metaData = std::make_unique<peak::common::Metadata>(
            AddCaptureInformationDataToMetadata(captureInformationC, peak::common::Metadata{}));
    }
    else
    {
        m_metaData = std::make_unique<peak::common::Metadata>(AddCaptureInformationDataToMetadata(captureInformationC, *m_metaData));
    }
 
 
    return *m_metaData;
}
 
inline Image Image::Subtract(const peak::icv::Image& subtrahend) const
{
    Image difference{ GetPixelFormat(), GetSize() };
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_Subtract(GetHandle(), subtrahend.GetHandle(), difference.GetHandle());
    });
 
 
    return difference;
}
 
inline Image Image::operator-(const peak::icv::Image& subtrahend) const
{
    return Subtract(subtrahend);
}
 
inline Image Image::Crop(const peak::common::Rectangle& rect) const
{
    Image croppedImage{ GetPixelFormat(), { rect.GetWidth(), rect.GetHeight() } };
 
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_Crop(GetHandle(), croppedImage.GetHandle(),
            peak::common::detail::BackendAccessor<peak::common::Rectangle>::CreateCType(rect));
    });
    return croppedImage;
}
 
inline Image Image::Scale(const peak::common::Size& targetImageSize, const Interpolation& interpolation) const
{
    Image scaledImage{ GetPixelFormat(), targetImageSize };
    detail::ExecuteAndMapReturnCodes([&] {
        return PEAK_ICV_C_ABI_PREFIX peak_icv_Image_Scale(
            GetHandle(), scaledImage.GetHandle(), static_cast<peak_icv_interpolation>(interpolation));
    });
    return scaledImage;
}
 
#if WITH_peak_ipl
inline Image::operator peak::ipl::Image() const
{
    return GetIPLImage();
}
#endif
} /* namespace icv */
} /* namespace peak */