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:
        explicit ImageLabelItem(QQuickItem *parent = nullptr);


        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)));
        }


        Q_INVOKABLE QPointF MapImageToView(const QPointF &imagePoint) const
        {
          return CvbToQt(dispatcher_->MapImageToView(QtToCvb(imagePoint)));
        }


        Q_INVOKABLE QPointF MapTargetToImage(const QPointF &targetPoint) const
        {
          return CvbToQt(dispatcher_->MapTargetToImage(QtToCvb(targetPoint)));
        }


        Q_INVOKABLE QPointF MapImageToTarget(const QPointF &imagePoint) const
        {
          return CvbToQt(dispatcher_->MapImageToTarget(QtToCvb(imagePoint)));
        }
 
      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_ = std::make_unique<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);
        }


        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));
 
          const auto pixel = image->GetPixel(hoverPositionInt);
          return QVector<double>(pixel.begin(), pixel.end());
        }


        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()));
          }
        }
        
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
#define geometryChangeFuncName geometryChange
#else
#define geometryChangeFuncName geometryChanged
#endif
 
        void geometryChangeFuncName(const QRectF &newGeometry, const QRectF &oldGeometry) override
        {
          auto tmpNewGemotry = QtToCvb(newGeometry);
          if (tmpNewGemotry != dispatcher_->ViewRect())
            dispatcher_->UpdateViewRect(tmpNewGemotry, [&]() { NotifyViewRect(); });
 
          QQuickPaintedItem::geometryChangeFuncName(newGeometry, oldGeometry);
 
          if (dispatcher_->UploadMode() == UI::UploadMode::Viewport && image_)
            Refresh();
        }
 
        void wheelEvent(QWheelEvent *event) override
        {
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
          const QPointF pos = event->position();
#else
          const QPointF pos = event->pos();
#endif
          SetViewAnchor(pos);  // globalPosition is buggy, will only work after resize 
          auto numDegrees = event->angleDelta().y();
 
          if (numDegrees <= -15)
            TryZoomOut();
          else if (numDegrees >= 15)
            TryZoomIn();
        }
 
        void mouseMoveEvent(QMouseEvent *event) override
        {
          if (event->buttons() & Qt::LeftButton)
          {
#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
            const QPointF pos = event->position();
#else
            const QPointF pos = event->pos();
#endif
            auto currentPos = QtToCvb(pos);  // globalPos is buggy, will only work after resize
            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->position()));
          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);
      }
 
    }  // namespace Quick
 
    using ImageLabelItem  = Quick::ImageLabelItem;
    using ImageController = Quick::ImageController;
    using ImageViewItem   = Quick::ImageViewItem;
 
  }  // namespace UI
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb