image_view_item.hpp

#pragma once
 
#include <atomic>
 
#pragma warning(push)
#pragma warning(disable : 4251)
#pragma warning(disable : 4172)
#pragma warning(disable : 4127) // const expr
#pragma warning(disable : 4800)
 
#include <QQuickPaintedItem>
#include <QPainter>
#include <QtGlobal>
 
 
 
 
#pragma warning(pop)
 
#include "ui.hpp"
#include "../image.hpp"
 
namespace Cvb
{
 
CVB_BEGIN_INLINE_NS
 
namespace UI
{
 
namespace Quick
{
 
 
class ImageViewItem;
 
 
class ImageLabelItem
  : public QQuickItem
{
  Q_OBJECT
 
  Q_PROPERTY(double imageX MEMBER imageX_ READ ImageX WRITE SetImageX NOTIFY NotifyImageX);
  Q_PROPERTY(double imageY MEMBER imageY_ READ ImageY WRITE SetImageY NOTIFY NotifyImageY);
 
  Q_PROPERTY(int labelScale MEMBER labelScale_ READ LabelScale WRITE SetLabelScale NOTIFY NotifyLabelScale);
 
  Q_PROPERTY(ImageViewItem* imageView READ ImageView WRITE SetImageView NOTIFY NotifyImageView)
 
  public:
 
    ImageLabelItem(QQuickItem *parent = nullptr);
 
    ~ImageLabelItem() = default;
 
 
 
    template<class T>
    static void Register(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
    {
      qmlRegisterType<T>(uri, versionMajor, versionMinor, qmlName);
      qmlRegisterUncreatableMetaObject(Cvb::UI::staticMetaObject, uri, versionMajor, versionMinor, "LabelScale", "CVB: cannot object for enumerations");
    }
 
 
 
    static void Register()
    {
      Register<ImageLabelItem>("CvbQuick", 1, 0, "ImageLabel");
    }
 
 
    double ImageX() const noexcept
    {
      return imageX_;
    }
 
 
    void SetImageX(double imageX)
    {
      if (imageX_ == imageX)
        return;
 
      imageX_ = imageX;
      NotifyImageX();
    }
 
 
    double ImageY() const noexcept
    {
      return imageY_;
    }
 
 
    void SetImageY(double imageY)
    {
      if (imageY_ == imageY)
        return;
 
      imageY_ = imageY;
      NotifyImageY();
    }
 
    // needed put not for public use!
    ImageViewItem* ImageView()
    {
      return view_;
    }
 
 
    void SetImageView(ImageViewItem * view)
    {
      if (view_ == view)
        return;
 
      view_ = view;
      NotifyImageView();
    }
 
 
    int LabelScale() const noexcept
    {
      return static_cast<int>(labelScale_);
    }
 
 
    void SetLabelScale(int labelScale)
    {
      if (labelScale_ == static_cast<UI::LabelScale>(labelScale))
        return;
 
      labelScale_ = static_cast<UI::LabelScale>(labelScale);
      NotifyLabelScale();
    }
 
 
 
 
  private Q_SLOTS:
 
    void OnImageXChanged();
 
    void OnImageYChanged();
 
    void OnImageViewChanged();
 
    void OnLabelScaleChanged();
 
  Q_SIGNALS:
 
    void NotifyImageX();
    void NotifyImageY();
    void NotifyImageView();
    void NotifyLabelScale();
 
  private:
 
    void SetupConnections();
 
    double imageX_ = 0.0;
    double imageY_ = 0.0;
 
    UI::LabelScale labelScale_ = UI::LabelScale::Off;
 
    ImageViewItem* view_ = nullptr;
};
 
 
class ImageController
  : public QObject
{
  Q_OBJECT
 
    Q_PROPERTY(int width READ Width NOTIFY NotifyRefreshImage)
    Q_PROPERTY(int height READ Height NOTIFY NotifyRefreshImage)
    Q_PROPERTY(int planesCount READ PlanesCount NOTIFY NotifyRefreshImage)
 
  public:
 
 
    ImagePtr Image() const
    {
      std::unique_lock<std::mutex> guard(imageMutex_);
      return image_;
    }
 
 
    void ReleaseRefreshShare() noexcept
    {
      std::unique_lock<std::mutex> guard(imageMutex_);
      UnregisterEventImageDataUpdated();
      image_.reset();
    }
 
 
 
    void Refresh(const ImagePtr & image, AutoRefresh autoRefresh = AutoRefresh::Off)
    {
      if (!image)
        return;
 
      std::unique_lock<std::mutex> guard(imageMutex_);
      UnregisterEventImageDataUpdated();
      image_ = image;
 
      if (autoRefresh == AutoRefresh::On)
        eventCookieDataUpdated_ = image_->RegisterEventPixelContentChanged([&](const class Image &, Rect<int>)
      {
        Refresh();
      });
 
      NotifyRefreshImage();
    }
 
 
    void Refresh()
    {
      if (!image_)
        return;
 
      std::unique_lock<std::mutex> guard(refreshMutex_);
      NotifyRefresh();
    }
 
 
    int Width() const noexcept
    {
      if (!image_)
        return 0;
      return image_->Width();
    }
 
 
    int Height() const noexcept
    {
      if (!image_)
        return 0;
      return image_->Height();
    }
 
 
    int PlanesCount() const noexcept
    {
      if (!image_)
        return 0;
      return image_->PlanesCount();
    }
 
  private:
 
    void UnregisterEventImageDataUpdated() noexcept
    {
      if (image_)
        image_->UnregisterEventPixelContentChanged(eventCookieDataUpdated_);
    }
 
 
    EventCookie eventCookieDataUpdated_;
 
    ImagePtr image_;
 
    mutable std::mutex imageMutex_;
    mutable std::mutex refreshMutex_;
 
  Q_SIGNALS:
 
    void NotifyRefresh();
    void NotifyRefreshImage();
};
 
 
 
class ImageViewItem
  : public QQuickPaintedItem
 
{
 
#pragma region
 
  Q_OBJECT
 
  Q_PROPERTY(QRectF imageRect READ ImageRect NOTIFY NotifyImageRect)
  Q_PROPERTY(QRectF viewRect READ ViewRect NOTIFY NotifyViewRect)
  Q_PROPERTY(QRectF sourceRect READ SourceRect NOTIFY NotifySourceRect)
  Q_PROPERTY(QRectF targetRect READ TargetRect NOTIFY NotifyTargetRect)
 
  Q_PROPERTY(QObject* image READ Image WRITE SetImage NOTIFY NotifyImage)
 
  Q_PROPERTY(int zoomID READ ZoomID WRITE SetZoomID NOTIFY NotifyZoom)
  Q_PROPERTY(double zoomFactor READ ZoomFactor WRITE SetZoomFactor NOTIFY NotifyZoom)
 
  Q_PROPERTY(QPointF viewAnchor READ ViewAnchor WRITE SetViewAnchor NOTIFY NotifyViewAnchor)
  Q_PROPERTY(QPointF imageAnchor READ ImageAnchor WRITE SetImageAnchor NOTIFY NotifyImageAnchor)
 
  Q_PROPERTY(QVector<double> hoverPixel READ HoverPixel NOTIFY NotifyHover)
  Q_PROPERTY(QPointF hoverPosition READ HoverPosition NOTIFY NotifyHover)
 
  Q_PROPERTY(int uploadMode READ UploadMode WRITE SetUploadMode NOTIFY NotifyUploadMode)
 
  public:
 
 
 
    Q_INVOKABLE bool TryZoomIn()
    {
      auto result = dispatcher_->TryZoomIn([&]()
      {
        NotifyTargetRect();
      },
      [&]
      {
        NotifySourceRect();
      });
      update();
      if (result)
      {
        NotifyZoom();
        if (dispatcher_->UploadMode() == UI::UploadMode::Viewport)
          Refresh();
      }
      return result;
 
    }
 
 
    Q_INVOKABLE bool TryZoomOut()
    {
      auto result = dispatcher_->TryZoomOut([&]()
      {
        NotifyTargetRect();
      },
        [&]
      {
        NotifySourceRect();
      });
      update();
      if (result)
      {
        NotifyZoom();
 
        if (dispatcher_->UploadMode() == UI::UploadMode::Viewport)
          Refresh();
      }
      return result;
 
    }
 
 
    Q_INVOKABLE bool TryTranslate(const QPointF &translation)
    {
      auto result = dispatcher_->TryTranslate(QtToCvb(translation), [&]()
      {
        NotifySourceRect();
      });
      if (dispatcher_->UploadMode() == UI::UploadMode::Viewport)
        Refresh();
      else
        update();
      return result;
    }
 
 
 
    Q_INVOKABLE QPointF MapViewToTarget(const QPointF& viewPoint) const
    {
      return CvbToQt(dispatcher_->MapViewToTarget(QtToCvb(viewPoint)));
    }
 
 
    Q_INVOKABLE QPointF MapTargetToSource(const QPointF& targetPoint) const
    {
      return CvbToQt(dispatcher_->MapTargetToSource(QtToCvb(targetPoint)));
    }
 
 
    Q_INVOKABLE QPointF MapSourceToImage(const QPointF& sourcePoint) const
    {
      return CvbToQt(dispatcher_->MapSourceToImage(QtToCvb(sourcePoint)));
    }
 
 
    Q_INVOKABLE QPointF MapTargetToView(const QPointF& targetPoint) const
    {
      return CvbToQt(dispatcher_->MapTargetToView(QtToCvb(targetPoint)));
    }
 
 
    Q_INVOKABLE QPointF MapSourceToTarget(const QPointF& sourcePoint) const
    {
      return CvbToQt(dispatcher_->MapSourceToTarget(QtToCvb(sourcePoint)));
    }
 
 
    Q_INVOKABLE QPointF MapImageToSource(const QPointF& imagePoint) const
    {
      return CvbToQt(dispatcher_->MapImageToSource(QtToCvb(imagePoint)));
    }
 
 
    Q_INVOKABLE QPointF MapViewToImage(const QPointF& viewPoint) const
    {
      return CvbToQt(dispatcher_->MapViewToImage(QtToCvb(viewPoint)));
    }
 
  public Q_SLOTS:
 
 
 
      void Refresh()
      {
        if (!image_)
          return;
 
        auto image = image_->Image();
        if (!image)
          return;
 
        dispatcher_->UploadImage(*image,
          [&]()
          {
            NotifyImageRect();
          });
        update();
      }
 
 
#pragma endregion QML Interface
 
 
#pragma region
 
  public:
 
    explicit ImageViewItem(QQuickItem *parent = nullptr)
      : QQuickPaintedItem(parent)
    {
      dispatcher_.reset(new Private::ImageViewDispatcher([&]()
      {
        NotifyZoom();
      }));
 
 
      setClip(true);
      setAcceptedMouseButtons(Qt::AllButtons);
      setAcceptHoverEvents(true);
      connect(this, &ImageViewItem::NotifyImage, this, &ImageViewItem::Refresh);
      connect(this, &ImageViewItem::NotifyViewRect, this, &ImageViewItem::OnViewRectChanged);
      connect(this, &ImageViewItem::NotifyImageRect, this, &ImageViewItem::OnImageRectChanged);
      connect(this, &ImageViewItem::NotifyZoom, this, &ImageViewItem::OnZoomIDChanged);
      connect(this, &ImageViewItem::NotifyZoom, this, &ImageViewItem::OnZoomFactorChanged);
      connect(this, &ImageViewItem::NotifyViewAnchor, this, &ImageViewItem::OnViewAnchorChnaged);
    }
 
    ~ImageViewItem() = default;
 
 
    template<class T>
    static void Register(const char *uri, int versionMajor, int versionMinor, const char *qmlName)
    {
      qmlRegisterType<T>(uri, versionMajor, versionMinor, qmlName);
      qmlRegisterUncreatableMetaObject(Cvb::UI::staticMetaObject, uri, versionMajor, versionMinor, "ZoomID", "CVB: cannot object for enumerations");
      qmlRegisterUncreatableMetaObject(Cvb::UI::staticMetaObject, uri, versionMajor, versionMinor, "UploadMode", "CVB: cannot object for enumerations");
    }
 
 
    static void Register()
    {
      Register<ImageViewItem>("CvbQuick", 1, 0, "ImageView");
    }
 
#pragma endregion CTor/DTor/Register
 
#pragma region
 
 
 
    QRectF ImageRect() const noexcept
    {
      return CvbToQt(dispatcher_->ImageRect());
    }
 
 
 
    QRectF ViewRect() const noexcept
    {
      return CvbToQt(dispatcher_->ViewRect());
    }
 
 
    QRectF TargetRect() const noexcept
    {
      return CvbToQt(dispatcher_->TargetRect());
    }
 
 
 
    QRectF SourceRect() const noexcept
    {
      return CvbToQt(dispatcher_->SourceRect());
    }
 
    // needed put not for public use!
    QObject* Image() const
    {
      return image_;
    }
 
 
 
    int ZoomID() const
    {
      return static_cast<int>(dispatcher_->ZoomID());
    }
 
 
    void SetZoomID(int id)
    {
      dispatcher_->UpdateZoomID(static_cast<UI::ZoomID>(id),
        [&]()
        {
          NotifyZoom();
      });
 
    }
 
 
    double ZoomFactor() const
    {
      return dispatcher_->ZoomFactor();
    }
 
 
    void SetZoomFactor(double factor)
    {
      dispatcher_->UpdateZoomFactor(factor,
        [&]()
        {
          NotifyZoom();
      });
    }
 
 
    void SetImage(QObject* image)
    {
      if (!image)
        return;
 
 
      image_ = dynamic_cast<ImageController*>(image);
      if (!image_)
        return;
      connect(image_, &ImageController::NotifyRefresh, this, &ImageViewItem::Refresh);
      connect(image_, &ImageController::NotifyRefreshImage, this, &ImageViewItem::Refresh);
      NotifyImage();
    }
 
 
    QPointF ViewAnchor() const noexcept
    {
      return CvbToQt(dispatcher_->ViewAnchor());
    }
 
 
    void SetViewAnchor(const QPointF & viewAnchor)
    {
      dispatcher_->UpdateViewAnchor(QtToCvb(viewAnchor),
        [&]()
        {
          NotifyViewAnchor();
        });
    }
 
 
    QPointF ImageAnchor() const noexcept
    {
      return CvbToQt(dispatcher_->ImageAnchor());
    }
 
 
    void SetImageAnchor(const QPointF & imageAnchor)
    {
      dispatcher_->UpdateImageAnchor(QtToCvb(imageAnchor),
        [&]()
        {
          NotifyImageAnchor();
        });
    }
 
 
    QVector<double> HoverPixel() const
    {
      if (!image_)
        return QVector<double>();
 
      auto image = image_->Image();
      if (!image || !dispatcher_->IsHoverPositionValid())
        return QVector<double>();
 
      auto hoverPosition = dispatcher_->HoverPosition();
      Point2D<int> hoverPositionInt(static_cast<int>(std::floor(hoverPosition.X())),
        static_cast<int>(std::floor(hoverPosition.Y())));
      // here we can get image width/height as max so we filter it
 
      if (hoverPositionInt.X() == image->Width())
        hoverPositionInt.SetX(static_cast<int>(hoverPosition.X() - 1.0));
      if (hoverPositionInt.Y() == image->Height())
        hoverPositionInt.SetY(static_cast<int>(hoverPosition.Y() - 1.0));
 
      return QVector<double>::fromStdVector(image->GetPixel(hoverPositionInt));
    }
 
 
 
    QPointF HoverPosition() const noexcept
    {
      if (!dispatcher_->IsHoverPositionValid())
        return QPointF();
 
      return CvbToQt(dispatcher_->HoverPosition());
    }
 
 
    int UploadMode() const noexcept
    {
      return static_cast<int>(dispatcher_->UploadMode());
 
    }
 
 
    void SetUploadMode(int uploadMode)
    {
      dispatcher_->UpdateUploadMode(static_cast<UI::UploadMode>(uploadMode),
        [&]()
      {
        NotifyUploadMode();
      });
    }
 
#pragma endregion Properties
 
#pragma region
 
  private Q_SLOTS:
 
 
 
 
    void OnViewRectChanged()
    {
      UpdateTargetSource();
    }
 
    void OnImageRectChanged()
    {
      UpdateTargetSource();
    }
 
    void OnZoomFactorChanged()
    {
      UpdateTargetSource();
      update();
    }
 
 
    void OnZoomIDChanged()
    {
      UpdateTargetSource();
      update();
    }
 
 
    void OnViewAnchorChnaged()
    {
      auto targetPoint = dispatcher_->MapViewToTarget(dispatcher_->ViewAnchor());
      targetPoint = dispatcher_->LimitPointToRect(targetPoint, dispatcher_->TargetRect());
 
      auto sourcePoint = dispatcher_->MapTargetToSource(targetPoint);
      auto imagePoint = dispatcher_->MapSourceToImage(sourcePoint);
 
      dispatcher_->UpdateImageAnchor(imagePoint,
        [&]()
      {
        NotifyImageAnchor();
      });
    }
 
 
 
 
#pragma endregion Slots
 
#pragma region
 
    private:
 
 
    void UpdateTargetSource()
    {
      dispatcher_->UpdateTargetSource(
      [&]()
      {
        NotifyTargetRect();
      },
        [&]()
      {
        NotifySourceRect();
      });
    }
 
    QImage ScreenImage() const noexcept
    {
      auto data = dispatcher_->Buffer();
      auto size = dispatcher_->BufferSize();
 
      return QImage(data, size.Width(), size.Height(), QImage::Format_ARGB32_Premultiplied);
    }
 
 
#pragma endregion Helper
 
 
#pragma region
 
 
 
    void paint(QPainter *painter) override
    {
 
 
      Private::ImageViewDispatcherGuard guard(*dispatcher_);
      if (!dispatcher_->IsBufferValid())
        return;
 
      auto screenImage = ScreenImage();
 
      if (dispatcher_->UploadMode() == UI::UploadMode::Image)
      {
 
 
 
        painter->drawImage(CvbToQt(dispatcher_->TargetRect()),
          screenImage,
          CvbToQt(dispatcher_->SourceRect()));
      }
      else
      {
        auto image = image_->Image();
        if (!image)
          return;
 
 
 
 
 
 
 
        painter->drawImage(CvbToQt(dispatcher_->TargetRect()),
          screenImage,
          CvbToQt(dispatcher_->SourceRectAdj()));
      }
    }
 
    void geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) override
    {
      auto tmpNewGemotry = QtToCvb(newGeometry);
      if (tmpNewGemotry != dispatcher_->ViewRect())
        dispatcher_->UpdateViewRect(tmpNewGemotry, [&]() { NotifyViewRect(); });
 
 
 
      QQuickPaintedItem::geometryChanged(newGeometry, oldGeometry);
 
      if (dispatcher_->UploadMode() == UI::UploadMode::Viewport
        && image_)
        Refresh();
    }
 
    void wheelEvent(QWheelEvent *event) override
    {
      SetViewAnchor(mapFromGlobal(event->globalPosF()));
      auto numDegrees = event->angleDelta().y();
 
      if (numDegrees <= -15)
        TryZoomOut();
      else if (numDegrees >= 15)
        TryZoomIn();
    }
 
    void mouseMoveEvent(QMouseEvent *event) override
    {
      if (event->buttons() & Qt::LeftButton)
      {
        auto currentPos = QtToCvb(mapFromGlobal(event->globalPos()));
        if (!dispatcher_->IsLastMousePositionValid())
        {
          dispatcher_->InvalidateLastMousePosition(currentPos);
          return;
        }
 
        TryTranslate(CvbToQt(currentPos - dispatcher_->LastMousePosition()));
        dispatcher_->InvalidateLastMousePosition(currentPos);
      }
 
    }
 
    void mouseReleaseEvent(QMouseEvent *) override
    {
      dispatcher_->InvalidateLastMousePosition();
    }
 
    void mousePressEvent(QMouseEvent *) override
    {
       // do nothing just prevent the default implementation from ignoring the event
    }
 
 
    void hoverMoveEvent(QHoverEvent *event) override
    {
      auto hoverPosition = dispatcher_->MapViewToImage(QtToCvb(event->posF()));
      if (!dispatcher_->ImageRect().Contains(hoverPosition))
        return;
 
      dispatcher_->UpdateHoverPosition(hoverPosition,
      [&]()
      {
        NotifyHover();
      });
    }
 
 
 
 
#pragma endregion Reimplemented from Qt
 
 
#pragma region
 
    std::unique_ptr<UI::Private::ImageViewDispatcher> dispatcher_;
 
    ImageController* image_ = nullptr;
 
 
 
#pragma endregion Members
 
#pragma region
 
    Q_SIGNALS:
 
      void NotifyImageRect();
      void NotifyViewRect();
      void NotifySourceRect();
      void NotifyTargetRect();
 
      void NotifyImage();
 
      void NotifyZoom();
 
      void NotifyViewAnchor();
      void NotifyImageAnchor();
 
      void NotifyHover();
 
 
      void NotifyUploadMode();
 
#pragma endregion Notify
 
};
 
inline ImageLabelItem::ImageLabelItem(QQuickItem *parent)
  : QQuickItem(parent)
{
  setTransformOrigin(QQuickItem::TopLeft);
  connect(this, &ImageLabelItem::NotifyImageView, this, &ImageLabelItem::OnImageViewChanged);
}
 
 
inline void ImageLabelItem::OnImageXChanged()
{
  if (!view_)
    return;
 
  auto sourceRect = view_->SourceRect();
  auto sourceX = imageX_ - sourceRect.x();
  auto targetX = sourceX * view_->ZoomFactor();
  auto targetRect = view_->TargetRect();
  auto viewX = targetX + targetRect.x();
 
  setX(viewX);
}
 
inline void ImageLabelItem::OnImageYChanged()
{
  if (!view_)
    return;
 
  auto sourceRect = view_->SourceRect();
  auto sourceY = imageY_ - sourceRect.y();
  auto targetY = sourceY * view_->ZoomFactor();
  auto targetRect = view_->TargetRect();
  auto viewY = targetY + targetRect.y();
 
  setY(viewY);
}
 
inline void ImageLabelItem::OnImageViewChanged()
{
  SetupConnections();
  OnImageXChanged();
  OnImageYChanged();
  OnLabelScaleChanged();
}
 
inline void ImageLabelItem::OnLabelScaleChanged()
{
  if (labelScale_ == UI::LabelScale::Off)
  {
    setScale(1.0);
    return;
  }
 
  if (!view_)
    return;
 
  setScale(view_->ZoomFactor());
 
}
 
 
inline void ImageLabelItem::SetupConnections()
{
  if (!view_)
    return;
 
  connect(this, &ImageLabelItem::NotifyImageX, this, &ImageLabelItem::OnImageXChanged);
  connect(this, &ImageLabelItem::NotifyImageY, this, &ImageLabelItem::OnImageYChanged);
  connect(this, &ImageLabelItem::NotifyLabelScale, this, &ImageLabelItem::OnLabelScaleChanged);
 
  connect(view_, &ImageViewItem::NotifySourceRect, this, &ImageLabelItem::OnImageXChanged);
  connect(view_, &ImageViewItem::NotifySourceRect, this, &ImageLabelItem::OnImageYChanged);
  connect(view_, &ImageViewItem::NotifyTargetRect, this, &ImageLabelItem::OnImageXChanged);
  connect(view_, &ImageViewItem::NotifyTargetRect, this, &ImageLabelItem::OnImageYChanged);
  connect(view_, &ImageViewItem::NotifyZoom, this, &ImageLabelItem::OnImageXChanged);
  connect(view_, &ImageViewItem::NotifyZoom, this, &ImageLabelItem::OnImageYChanged);
 
  connect(view_, &ImageViewItem::NotifyZoom, this, &ImageLabelItem::OnLabelScaleChanged);
}
 
}
 
using ImageLabelItem = Quick::ImageLabelItem;
using ImageController = Quick::ImageController;
using ImageViewItem = Quick::ImageViewItem;
 
 
 
}
 
 
 
 
CVB_END_INLINE_NS
 
}