peak_icv_image.hpp

Go to the documentation of this file.

 
#pragma once
 
 
#include <peak_common/types/geometry/peak_common_rectangle.hpp>
#include <peak_common/types/geometry/peak_common_size.hpp>
#include <peak_common/types/peak_common_pixel_format.hpp>
#include <peak_icv/algorithms/transformations/peak_icv_interpolation.hpp>
#include <peak_icv/utils/peak_icv_backend_accessor.hpp>
#include <memory>
 
#ifdef WITH_peak_ipl
#    include <peak_ipl/types/peak_ipl_image.hpp>
#endif
 
#include <peak_common/types/peak_common_iimageview.hpp>
 
struct peak_icv_image_info;
struct peak_icv_image;
using peak_icv_image_handle = peak_icv_image*;
 
namespace peak
{
namespace icv
{
 
class ImageWriter;
 
class Image : private detail::IBackendAccessible<Image>
{
public:
#ifdef WITH_peak_ipl
    Image(const peak::ipl::Image& image); // NOLINT
#endif
 
    explicit Image(const peak::common::IImageView& imageView);
 
    explicit Image(const std::string& path);
 
    explicit Image(const std::string& path, peak::common::PixelFormat name);
 
    Image(peak::common::PixelFormat pixelFormat, uint8_t* buffer, size_t bufferSize, const peak::common::Size& imageSize);
 
    Image(peak::common::PixelFormat pixelFormat, const peak::common::Size& imageSize);
 
    Image(const Image& other);
 
    Image(Image&& other) noexcept;
 
    Image& operator=(const Image& other);
 
    Image& operator=(Image&& other) noexcept;
 
    ~Image() override;
 
    bool operator==(const Image& rhs) const;
 
    PEAK_COMMON_NO_DISCARD Image Copy() const;
 
    PEAK_COMMON_NO_DISCARD peak::common::Size GetSize() const;
 
    PEAK_COMMON_NO_DISCARD uint8_t* GetData() const;
 
    PEAK_COMMON_NO_DISCARD size_t GetSizeInBytes() const;
 
    PEAK_COMMON_NO_DISCARD size_t GetBytesPerLine() const;
 
 
    PEAK_COMMON_NO_DISCARD peak::common::PixelFormat GetPixelFormat() const;
 
    PEAK_COMMON_NO_DISCARD Region GetRegion() const;
 
    void SetRegion(const Region& region) const;
 
    void ResetRegion() const;
 
    template <typename DataType>
    PEAK_COMMON_NO_DISCARD DataType* At(size_t x, size_t y) const
    {
        return reinterpret_cast<DataType*>(m_buffer + (x + y * m_size.GetWidth()) * m_pixelFormatInfo.GetAllocatedBitsPerPixel() / 8);
    }
 
    PEAK_COMMON_NO_DISCARD peak::icv::Image ConvertPixelFormat(peak::common::PixelFormat pixelFormat) const;
 
    PEAK_COMMON_NO_DISCARD peak::icv::Image ConvertPixelFormatWithFactor(
        peak::common::PixelFormat pixelFormat, const double factor) const;
 
    PEAK_COMMON_NO_DISCARD std::vector<Image> Deinterleave() const;
 
    void SetMetadata(const peak::common::Metadata& metadata);
 
    PEAK_COMMON_NO_DISCARD peak::common::Metadata GetMetadata() const;
 
    PEAK_COMMON_NO_DISCARD Image Subtract(const Image& subtrahend) const;
 
    PEAK_COMMON_NO_DISCARD Image operator-(const Image& subtrahend) const;
 
    PEAK_COMMON_NO_DISCARD Image Crop(const peak::common::Rectangle& rect) const;
 
    PEAK_COMMON_NO_DISCARD Image Scale(
        const peak::common::Size& targetImageSize, const Interpolation& interpolation = Interpolation::NearestNeighbor) const;
 
#ifdef WITH_peak_ipl
    operator peak::ipl::Image() const; // NOLINT
#endif
 
protected:
    PEAK_COMMON_NO_DISCARD detail::handle_of_t<Image> GetHandle() const override;
 
private:
    friend peak::common::detail::BackendAccessor<Image>;
    friend ImageWriter;
 
    explicit Image(peak_icv_image_handle imageHandle);
    Image(peak_icv_image_handle handle, peak_icv_image_info info);
 
    static peak::common::Metadata AddCaptureInformationDataToMetadata(
        peak_icv_capture_information captureInformationC, peak::common::Metadata metadata);
 
    static peak_icv_image_handle CreateFromFile(const std::string& path);
    static peak_icv_image_handle CreateFromFile(const std::string& path, peak::common::PixelFormat name);
    static peak_icv_image_info CreateFromHandle(peak_icv_image_handle handle);
    static peak_icv_image_handle CreateFromSize(peak::common::PixelFormat pixelFormat, const peak::common::Size& size);
    static peak_icv_image_handle CreateFromBuffer(
        peak::common::PixelFormat pixelFormat, const peak::common::Size& size, const uint8_t* buffer, size_t bufferSize);
    static peak_icv_image_handle CreateFromImageView(const peak::common::IImageView& imageView);
 
#ifdef WITH_peak_ipl
    PEAK_COMMON_NO_DISCARD peak::ipl::Image GetIPLImage() const;
#endif
 
    peak_icv_image_handle m_imageHandle{};
    peak::common::Size m_size;
    uint8_t* m_buffer;
    peak::common::PixelFormatInfo m_pixelFormatInfo;
    mutable std::unique_ptr<peak::common::Metadata> m_metaData; // mutable because we cache it in getter function
 
#ifdef WITH_peak_ipl
    mutable peak::ipl::Image m_image;
#endif
};
} /* namespace icv */
} /* namespace peak */
 
#include <peak_icv/types/detail/peak_icv_image.ipp>