decl_image.hpp

#pragma once
 
#include <algorithm>
#include <array>
#include <cstddef>
#include <functional>
#include <list>
#include <memory>
#include <mutex>
#include <new>
#include <stdexcept>
#include <system_error>
#include <utility>
 
#include "../_cexports/c_img.h"
#include "../_cexports/c_pixfmtcnv.h"
 
#include "../global.hpp"
 
#include "../affine_matrix_2d.hpp"
#include "../area_2d.hpp"
#include "../data_type.hpp"
#include "../pfnc_format.hpp"
#include "../rect.hpp"
#include "../string.hpp"
 
#include "../utilities/system_info.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  class ImagePlane;
 
  template <>
  inline HandleGuard<Image>::HandleGuard(void *handle) noexcept
      : HandleGuard<Image>(handle, [](void *handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }


  class Image
  {
    friend ImagePlane;
    friend Device;
 
  public:
    using GuardType = HandleGuard<Image>;


    static std::unique_ptr<Image> Load(const String &fileName);


    static std::unique_ptr<Image> Create(Size2D<int> size, int numPlanes = 1,
                                         DataType dataType = DataType::Int8BppUnsigned())
    {
      return Create(size.Width(), size.Height(), numPlanes, dataType);
    }
    static std::unique_ptr<Image> Create(Size2D<int> size, int numPlanes = 1, {…}


    static std::unique_ptr<Image> Create(int width, int height, int numPlanes = 1,
                                         DataType dataType = DataType::Int8BppUnsigned());


    template <class RANGE>
    static typename TypedRange<std::unique_ptr<Image>, ImagePtr, RANGE>::type FromImages(MappingOption mapping,
                                                                                         const RANGE &images)
    {
      auto rangeAdapter = MakeRangeAdapter<ImagePtr>(images);
      std::vector<void *> handles;
      handles.reserve(rangeAdapter.Size());
      for (const auto &image : images)
        handles.emplace_back(image->Handle());
      return FromImageHandles(mapping, handles);
    }
    static typename TypedRange<std::unique_ptr<Image>, ImagePtr, RANGE>::type FromImages(MappingOption mapping, {…}


    template <class... IMAGES>
    static typename VarArgRange<std::unique_ptr<Image>, const Image &, IMAGES...>::type
    FromImages(MappingOption mapping, const IMAGES &...images)
    {
      std::array<void *, sizeof...(IMAGES)> handles = {images.Handle()...};
      return FromImageHandles(mapping, handles);
    }
    FromImages(MappingOption mapping, const IMAGES &...images) {…}


    template <class RANGE>
    static typename TypedRange<std::unique_ptr<Image>, ImagePlane, RANGE>::type FromPlanes(MappingOption mapping,
                                                                                           const RANGE &planes);
 
#ifdef PLANES
#  undef PLANES
#endif

    template <class... PLANES>
    static typename VarArgRange<std::unique_ptr<Image>, ImagePlane &&, PLANES...>::type
    FromPlanes(MappingOption mapping, PLANES &&...planes);


    static std::unique_ptr<Image> FromHandle(HandleGuard<Image> &&guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      auto image = std::unique_ptr<Image>(new Image(std::move(guard)));
      return image;
    }
    static std::unique_ptr<Image> FromHandle(HandleGuard<Image> &&guard) {…}


    template <class T, class... ARGS>
    static std::unique_ptr<T> FromHandle(HandleGuard<Image> &&guard, ARGS &&...args)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
 
      static_assert(std::is_base_of<Image, T>::value, "CVB: Type must be derived from Image");
      auto image = std::unique_ptr<T>(new T(std::move(guard), std::forward<ARGS>(args)...));
      return image;
    }
    static std::unique_ptr<T> FromHandle(HandleGuard<Image> &&guard, ARGS &&...args) {…}


    explicit Image(Size2D<int> size, int numPlanes = 1, DataType dataType = DataType::Int8BppUnsigned())
        : Image(size.Width(), size.Height(), numPlanes, dataType)
    {
    }
    explicit Image(Size2D<int> size, int numPlanes = 1, DataType dataType = DataType::Int8BppUnsigned()) {…}


    Image(int width, int height, int numPlanes = 1, DataType dataType = DataType::Int8BppUnsigned())
        : Image(std::move(*Create(width, height, numPlanes, dataType)))
    {
    }
    Image(int width, int height, int numPlanes = 1, DataType dataType = DataType::Int8BppUnsigned()) {…}


    explicit Image(const String &fileName)
        : Image(std::move(*Load(fileName)))
    {
    }
    explicit Image(const String &fileName) {…}
 
    Image(const Image &other)            = delete;
    Image &operator=(const Image &other) = delete;
 
    virtual ~Image() = default;


    void *Handle() const noexcept
    {
      return handle_.Handle();
    }
    void *Handle() const noexcept {…}


    int PlanesCount() const noexcept
    {
      return static_cast<int>(CExports::ImageDimension(Handle()));
    }
    int PlanesCount() const noexcept {…}


    bool PlaneDataTypesIdentical() const noexcept
    {
      if (PlanesCount() == 1)
        return true;
 
      auto dataTypePlane0 = DataType::FromNativeDescriptor(static_cast<int>(CExports::ImageDatatype(Handle(), 0)));
      for (int i = 1; i < PlanesCount(); ++i)
        if (DataType::FromNativeDescriptor(
                static_cast<int>(CExports::ImageDatatype(Handle(), static_cast<CExports::cvbdim_t>(i))))
            != dataTypePlane0)
          return false;
      return true;
    }
    bool PlaneDataTypesIdentical() const noexcept {…}


    ImagePlane Plane(int plane) const;


    std::vector<ImagePlane> Planes() const noexcept;


    std::vector<double> GetPixel(Point2D<int> position) const;


    int Height() const noexcept
    {
      return static_cast<int>(CExports::ImageHeight(Handle()));
    }
    int Height() const noexcept {…}


    int Width() const noexcept
    {
      return static_cast<int>(CExports::ImageWidth(Handle()));
    }
    int Width() const noexcept {…}


    Cvb::ColorModel ColorModel() const noexcept
    {
      return static_cast<Cvb::ColorModel>(CExports::ImageColorModel(Handle()));
    }
    Cvb::ColorModel ColorModel() const noexcept {…}


    void Save(const String &fileName) const;


    void Save(const String &fileName, double quality) const;


    std::unique_ptr<Image> Map(Rect<int> rect) const
    {
      return Map(rect, rect.Size());
    }
    std::unique_ptr<Image> Map(Rect<int> rect) const {…}


    std::unique_ptr<Image> Map(Rect<int> sourceRect, Size2D<int> targetSize) const;


    std::unique_ptr<Image> Map(RotationMap rotation) const;


    std::unique_ptr<Image> Clone() const;


    void Copy(Image &targetImage, Rect<int> sourceRect, Point2D<int> targetPosition) const
    {
      if (!CVB_CALL_CAPI(CopyImageRectPlanes(Handle(), targetImage.Handle(), sourceRect.Left(), sourceRect.Top(),
                                             sourceRect.Right(), sourceRect.Bottom(), targetPosition.X(),
                                             targetPosition.Y())))
        Utilities::SystemInfo::ThrowLastError();
    }
    void Copy(Image &targetImage, Rect<int> sourceRect, Point2D<int> targetPosition) const {…}


    void Copy(Image &targetImage) const
    {
      Copy(targetImage, Bounds(), Point2D<int>());
      targetImage.RaisePixelContentChanged();
    }
    void Copy(Image &targetImage) const {…}


    Size2D<int> Size() const noexcept
    {
      return Size2D<int>(Width(), Height());
    }
    Size2D<int> Size() const noexcept {…}


    Rect<int> Bounds() const noexcept
    {
      return Rect<int>(Point2D<int>(), Size());
    }
    Rect<int> Bounds() const noexcept {…}


    void RaisePixelContentChanged() const
    {
      RaisePixelContentChanged(Bounds());
    }
    void RaisePixelContentChanged() const {…}


    void RaisePixelContentChanged(Rect<int> rect) const
    {
      pixelContentChangedCarrierContainer_.Call<void(const Image &, Rect<int>)>(*this, rect);
    }
    void RaisePixelContentChanged(Rect<int> rect) const {…}


    EventCookie RegisterEventPixelContentChanged(std::function<void(const Image &, Rect<int>)> handler)
    {
      auto carrier = Internal::CbCarrier<void(const Image &, Rect<int>)>::Create(handler);
      return pixelContentChangedCarrierContainer_.Register(carrier);
    }
    EventCookie RegisterEventPixelContentChanged(std::function<void(const Image &, Rect<int>)> handler) {…}


    void UnregisterEventPixelContentChanged(EventCookie eventCookie) noexcept
    {
      pixelContentChangedCarrierContainer_.Unregister(eventCookie);
    }
    void UnregisterEventPixelContentChanged(EventCookie eventCookie) noexcept {…}


    Point2D<double> ImageToPixelCoordinates(Point2D<double> point) const noexcept
    {
      double x = std::numeric_limits<double>::quiet_NaN();
      double y = std::numeric_limits<double>::quiet_NaN();
      CExports::ImageToPixel(Handle(), point.X(), point.Y(), x, y);
      return Point2D<double>(x, y);
    }
    Point2D<double> ImageToPixelCoordinates(Point2D<double> point) const noexcept {…}


    Area2D ImageToPixelCoordinates(Area2D area) const noexcept
    {
      Area2D retval;
      CExports::ImageAreaToPixel(Handle(), *reinterpret_cast<CExports::TArea *>(&area),
                                 reinterpret_cast<CExports::TArea &>(retval));
      return retval;
    }
    Area2D ImageToPixelCoordinates(Area2D area) const noexcept {…}


    Point2D<double> PixelToImageCoordinates(Point2D<double> point) const noexcept
    {
      double x = std::numeric_limits<double>::quiet_NaN();
      double y = std::numeric_limits<double>::quiet_NaN();
      CExports::PixelToImage(Handle(), point.X(), point.Y(), x, y);
      return Point2D<double>(x, y);
    }
    Point2D<double> PixelToImageCoordinates(Point2D<double> point) const noexcept {…}


    Area2D PixelToImageCoordinates(Area2D area) const noexcept
    {
      Area2D retval;
      CExports::PixelAreaToImage(Handle(), *reinterpret_cast<CExports::TArea *>(&area),
                                 reinterpret_cast<CExports::TArea &>(retval));
      return retval;
    }
    Area2D PixelToImageCoordinates(Area2D area) const noexcept {…}


    AffineMatrix2D CoordinateSystem() const noexcept
    {
      AffineMatrix2D retval;
      CVB_CALL_CAPI(GetImageCoordinates(Handle(), reinterpret_cast<CExports::TCoordinateMap &>(retval)));
      return retval;
    }
    AffineMatrix2D CoordinateSystem() const noexcept {…}


    void SetCoordinateSystem(AffineMatrix2D affineMatrix) noexcept
    {
      CVB_CALL_CAPI(SetImageCoordinates(Handle(), *reinterpret_cast<CExports::TCoordinateMap *>(&affineMatrix)));
    }
    void SetCoordinateSystem(AffineMatrix2D affineMatrix) noexcept {…}


    static std::unique_ptr<Image> FromPixelFormat(const Cvb::Size2D<int> &size, Cvb::PfncFormat format)
    {
      return FromPixelFormat(size.Width(), size.Height(), format);
    }
    static std::unique_ptr<Image> FromPixelFormat(const Cvb::Size2D<int> &size, Cvb::PfncFormat format) {…}


    static std::unique_ptr<Image> FromPixelFormat(int width, int height, Cvb::PfncFormat format)
    {
      return Internal::DoResCallObjectOut<Image>([&](void *&image) {
        return CVB_CALL_CAPI(
            CVPFCreateImageFromPFNCValue(static_cast<Cvb::CExports::cvbuint32_t>(format), width, height, image));
      });
    }
    static std::unique_ptr<Image> FromPixelFormat(int width, int height, Cvb::PfncFormat format) {…}
 
  protected:
    explicit Image(HandleGuard<Image> &&guard) noexcept
        : handle_(std::move(guard))
    {
    }
 
    void Detach() noexcept
    {
      handle_.Release();
    }
 
    void ResetHandle(void *newHandle) noexcept
    {
      handle_.Reset(newHandle);
    }
 
  private:
    Image(Image &&other) noexcept
        : handle_(std::move(other.handle_))
        , pixelContentChangedCarrierContainer_(std::move(other.pixelContentChangedCarrierContainer_))
    {
    }
 
    Image &operator=(Image &&other) noexcept = delete;
 
    void IncreaseRefCount() const noexcept
    {
      CVB_CALL_CAPI(ShareObject(Handle()));
    }
 
    template <class RANGE>
    static typename TypedRange<std::unique_ptr<Image>, void *, RANGE>::type FromImageHandles(MappingOption mapping,
                                                                                             const RANGE &range)
    {
      return Internal::DoBoolCallObjectOut<Image>([&](void *&handle) {
        auto rangeAdapter = MakeRangeAdapter<void *>(range);
        return CVB_CALL_CAPI(CreateConcatenatedImage(rangeAdapter.Data(), rangeAdapter.Size(),
                                                     mapping == MappingOption::LinkPixels, handle));
      });
    }
 
    HandleGuard<Image> handle_;
 
    mutable std::mutex handlerMutex_;
 
    Internal::CarrierContainer pixelContentChangedCarrierContainer_;
  };
  class Image {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb