detail_ui.hpp

#pragma once
 
#include "../../global.hpp"
#include "../../size_2d.hpp"
#include "../../point_2d.hpp"
#include "../../rect_lt.hpp"
#include "../../image.hpp"
 
#ifndef CVB_NO_QT5
 
#  ifdef _MSC_VER
#    pragma warning(push, 1)
#    pragma warning(disable : 4005)
#  endif
#  include <QtGlobal>
#  include <QObject>
#  ifdef _MSC_VER
#    pragma warning(pop)
#  endif
 
#endif
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  namespace UI
  {
 
#ifndef CVB_NO_QT5
    Q_NAMESPACE
#endif

    enum class UploadMode
    {
      Image,
      Viewport
    };
#ifndef CVB_NO_QT5
    Q_ENUM_NS(UploadMode)
#endif

    enum class ZoomID
    {
      Invalid,
      Custom,
      Panorama,
      Factor1,
      Factor2,
      Factor4,
      Factor8,
      Factor16,
      Factor32,
      Factor64,
      Factor128,
 
    };
#ifndef CVB_NO_QT5
    Q_ENUM_NS(ZoomID)
#endif

    enum class AutoRefresh
    {
      On,
      Off
    };

    enum class LabelScale
    {
      /*
       * The image view label will scale/zoom like the image (usefully to mark dimensions).
       */
      On,
      /*
       *  The image view label will ignore image scale/zoom operations.
       */
      Off
    };
#ifndef CVB_NO_QT5
    Q_ENUM_NS(LabelScale)
#endif


    struct ZoomDescriptor final
    {
 
#ifndef CVB_NO_QT5
      Q_GADGET
#endif
    public:
      ZoomID ID = ZoomID::Invalid;
      double Factor = std::numeric_limits<double>::quiet_NaN();
 
      ZoomDescriptor() = default;


      bool operator==(const ZoomDescriptor &zoomDescriptor) const noexcept
      {
        return ID == zoomDescriptor.ID && Factor == zoomDescriptor.Factor;
      }


      bool operator!=(const ZoomDescriptor &zoomDescriptor) const noexcept
      {
        return !(*this == zoomDescriptor);
      }


      explicit ZoomDescriptor(ZoomID id) noexcept
          : ID(id)
      {
        switch (id)
        {
          default:
          case ZoomID::Invalid:
          case ZoomID::Custom:
          case ZoomID::Panorama:
            break;
 
          case ZoomID::Factor1:
            Factor = 1.0;
            break;
 
          case ZoomID::Factor2:
            Factor = 2.0;
            break;
 
          case ZoomID::Factor4:
            Factor = 4.0;
            break;
 
          case ZoomID::Factor8:
            Factor = 8.0;
            break;
 
          case ZoomID::Factor16:
            Factor = 16.0;
            break;
 
          case ZoomID::Factor32:
            Factor = 32.0;
            break;
 
          case ZoomID::Factor64:
            Factor = 64.0;
            break;
 
          case ZoomID::Factor128:
            Factor = 128.0;
            break;
        }
      }


      explicit ZoomDescriptor(double customFactor) noexcept
          : ID(ZoomID::Custom)
          , Factor(customFactor)
      {
      }
    };
 
    namespace Private
    {
 
      class IImageView
      {
        friend class ZoomHandler;
 
      public:
        IImageView(const IImageView &other)            = delete;
        IImageView &operator=(const IImageView &other) = delete;
        IImageView(IImageView &&other)                 = delete;
        IImageView &operator=(IImageView &&other)      = delete;
        virtual ~IImageView()                          = default;
 
      protected:
        IImageView() noexcept = default;
 
        virtual Size2D<double> ViewSize() const noexcept  = 0;
        virtual Size2D<double> ImageSize() const noexcept = 0;
 
        virtual void ApplyZoom(double factor) = 0;
      };
 
      class ZoomHandler
      {
      public:
        explicit ZoomHandler(class IImageView &view) noexcept
            : view_(view)
        {
          std::vector<UI::ZoomDescriptor> defaultDescriptorList(8);
          defaultDescriptorList[0] = Cvb::UI::ZoomDescriptor(ZoomID::Factor1);
          defaultDescriptorList[1] = Cvb::UI::ZoomDescriptor(ZoomID::Factor2);
          defaultDescriptorList[2] = Cvb::UI::ZoomDescriptor(ZoomID::Factor4);
          defaultDescriptorList[3] = Cvb::UI::ZoomDescriptor(ZoomID::Factor8);
          defaultDescriptorList[4] = Cvb::UI::ZoomDescriptor(ZoomID::Factor16);
          defaultDescriptorList[5] = Cvb::UI::ZoomDescriptor(ZoomID::Factor32);
          defaultDescriptorList[6] = Cvb::UI::ZoomDescriptor(ZoomID::Factor64);
          defaultDescriptorList[7] = Cvb::UI::ZoomDescriptor(ZoomID::Factor128);
 
          defaultDescriptorList_.swap(defaultDescriptorList);
 
          panoramaDescriptor_.ID = ZoomID::Panorama;
          currentZoomDescriptor_ = panoramaDescriptor_;  // NOLINT(cppcoreguidelines-prefer-member-initializer)
        }
 
        ZoomHandler(const ZoomHandler &other)            = delete;
        ZoomHandler &operator=(const ZoomHandler &other) = delete;
        ZoomHandler(ZoomHandler &&other)                 = delete;
        ZoomHandler &operator=(ZoomHandler &&other)      = delete;
        ~ZoomHandler()                                   = default;
 
        void UpdatePanoramaFactor() noexcept
        {
          auto viewportSize = view_.ViewSize();
          auto sceneSize    = view_.ImageSize();
          if ((viewportSize_ == viewportSize && sceneSize_ == sceneSize)
              || (sceneSize.Width() < 1 || sceneSize.Height() < 1))
            return;
 
          viewportSize_ = viewportSize;
          sceneSize_    = sceneSize;
#ifdef min
#  undef min
#endif
          double panoramaFactor =
              std::min(viewportSize_.Width() / sceneSize_.Width(), viewportSize_.Height() / sceneSize_.Height());
 
          panoramaDescriptor_.Factor = panoramaFactor;
          if (currentZoomDescriptor_.ID == ZoomID::Panorama)
          {
            currentZoomDescriptor_ = panoramaDescriptor_;
            Apply();
          }
        }
 
        struct ZoomDescriptor ZoomDescriptor() const noexcept
        {
          return currentZoomDescriptor_;
        }
 
        bool TryZoomIn() noexcept
        {
          struct ZoomDescriptor result;
 
          for (auto descriptor : defaultDescriptorList_)
          {
            if (descriptor.Factor > currentZoomDescriptor_.Factor
                && (result.ID == ZoomID::Invalid || descriptor.Factor < result.Factor))
              result = descriptor;
          }
 
          if (panoramaDescriptor_.Factor > currentZoomDescriptor_.Factor
              && (result.ID == ZoomID::Invalid || panoramaDescriptor_.Factor < result.Factor))
            result = panoramaDescriptor_;
 
          if (result.ID == ZoomID::Invalid)
            return false;
 
          currentZoomDescriptor_ = result;
          Apply();
          return true;
        }
 
        bool TryZoomOut() noexcept
        {
          struct ZoomDescriptor result;
 
          for (auto descriptor : defaultDescriptorList_)
          {
            if (descriptor.Factor < currentZoomDescriptor_.Factor
                && (result.ID == ZoomID::Invalid || descriptor.Factor > result.Factor))
              result = descriptor;
          }
 
          if (panoramaDescriptor_.Factor < currentZoomDescriptor_.Factor
              && (result.ID == ZoomID::Invalid || panoramaDescriptor_.Factor > result.Factor))
            result = panoramaDescriptor_;
 
          if (result.ID == ZoomID::Invalid)
            return false;
 
          currentZoomDescriptor_ = result;
          Apply();
          return true;
        }
 
        void SetZoomDescriptor(struct ZoomDescriptor zoomDescriptor) noexcept
        {
 
          currentZoomDescriptor_ = zoomDescriptor;
          Apply();
        }
 
      private:
        enum class RenderDescriptor
        {
          AsyncImageUploadGl,          // 1 0 no rendering, no upload
          AsyncImageUploadRaster,      // 2  1 no render, upload image in acquisitions thread
          AsyncImageRepaintGl,         // 3 1 waits for render, upload image in UI thread (image must be shared)
          AsyncImageRepaintRaster,     // 4 1 waits for render, upload image in acquisitions thread
          AsyncImageScheduleGl,        // 5 1 schedules rendering, upload image in UI thread (image must be shared)
          AsyncImageScheduleRaster,    // 6 1 schedules rendering, upload image in acquisitions thread
          AsyncViewportUploadGl,       // 7 0 equal to AsyncImageUploadGl
          AsyncViewportUploadRaster,   // 8 1 no rendering, upload viewport (image must be shared)
          AsyncViewportRepaintGl,      // 9 1 waits for render, upload viewport in UI thread (image must be shared)
          AsyncViewportRepaintRaster,  // 10 1 waits for render, upload viewport in Acquisition thread (image must be
                                       // shared)
          AsyncViewportScheduleGl,      // 11 1 schedules rendering, upload viewport in UI thread (image must be shared)
          AsyncViewportScheduleRaster,  // 12 1 schedule for render, upload viewport in Acquisition thread (image must
                                        // be shared)
          SyncImageUploadGl,        // 13 0 no rendering upload image into texture
          SyncImageUploadRaster,    // 14 0 no rendering upload image into QImage
          SyncImageRepaintGl,       // 15 -1 renders immediately, upload image into texture (measure render performance)
          SyncImageRepaintRaster,   // 16 -1 renders immediately, upload image into QImage (measure render performance)
          SyncImageScheduleGl,      // 17 1 schedules render, uploads image into texture
          SyncImageScheduleRaster,  // 18 1 schedules render, uploads image into QImage
          SyncViewportUploadGl,     // 19 0 no rendering, upload viewport into texture
          SyncViewportUploadRaster,  // 20 0 no rendering, upload viewport into QImage
          SyncViewportRepaintGl,     // 21 -1 renders immediately, upload viewport into texture (measure render
                                  // performance) (image must be shared)
          SyncViewportRepaintRaster,  // 22 -1 renders immediately, upload viewport into QImage (measure render
                                      // performance) (image must be shared)
          SyncViewportScheduleGl,      // 23 1 schedules render, uploads viewport into texture (image must be shared)
          SyncViewportScheduleRaster,  // 24 1 schedules render, uploads viewport into QImage (image must be shared)
        };
 
        void Apply() noexcept
        {
          if (currentZoomDescriptor_.ID == ZoomID::Invalid || std::isnan(currentZoomDescriptor_.Factor))
            return;
 
          view_.ApplyZoom(currentZoomDescriptor_.Factor);
        }
 
        IImageView &view_;
 
        Size2D<double> sceneSize_;
        Size2D<double> viewportSize_;
        std::vector<struct ZoomDescriptor> defaultDescriptorList_;
        struct ZoomDescriptor panoramaDescriptor_;
        struct ZoomDescriptor currentZoomDescriptor_;
      };
 
      struct BGRAComponents
      {
        std::uint8_t Blue  = 0;
        std::uint8_t Green = 0;
        std::uint8_t Red   = 0;
        std::uint8_t Alpha = 255;
      };
 
      struct RGBAComponents
      {
        std::uint8_t Red   = 0;
        std::uint8_t Green = 0;
        std::uint8_t Blue  = 0;
        std::uint8_t Alpha = 255;
      };
 
      template <class T>
      inline void CopyImageDataColorToColor(const Image &src, T *dst) noexcept
      {
        auto vpatR = src.Plane(0).Vpat();
        auto vpatG = src.Plane(1).Vpat();
        auto vpatB = src.Plane(2).Vpat();
 
        auto entrysR = vpatR.VpatPtr();
        auto entrysG = vpatG.VpatPtr();
        auto entrysB = vpatB.VpatPtr();
 
        auto baseR = vpatR.BasePtr();
        auto baseG = vpatG.BasePtr();
        auto baseB = vpatB.BasePtr();
 
        auto widht  = src.Width();
        auto height = src.Height();
 
        for (int h = 0; h < height; ++h)
        {
          auto lineOffsetR = baseR + entrysR[h].OffsetY;
          auto lineOffsetG = baseG + entrysG[h].OffsetY;
          auto lineOffsetB = baseB + entrysB[h].OffsetY;
          for (int w = 0; w < widht; ++w)
          {
            (*dst).Alpha = 255;
            (*dst).Red   = *reinterpret_cast<std::uint8_t *>(lineOffsetR + entrysR[w].OffsetX);
            (*dst).Green = *reinterpret_cast<std::uint8_t *>(lineOffsetG + entrysG[w].OffsetX);
            (*dst).Blue  = *reinterpret_cast<std::uint8_t *>(lineOffsetB + entrysB[w].OffsetX);
            ++dst;
          }
        }
      }
 
      template <class T>
      inline void CopyImageDataMonoToColor(const Image &src, T *dst) noexcept
      {
        auto vpat   = src.Plane(0).Vpat();
        auto entrys = vpat.VpatPtr();
        auto base   = vpat.BasePtr();
 
        auto widht  = src.Width();
        auto height = src.Height();
 
        for (int h = 0; h < height; ++h)
        {
          auto lineOffset = base + entrys[h].OffsetY;
          for (int w = 0; w < widht; ++w)
          {
            (*dst).Alpha = 255;
            auto value   = *reinterpret_cast<std::uint8_t *>(lineOffset + entrys[w].OffsetX);
            (*dst).Blue = (*dst).Green = (*dst).Red = value;
            ++dst;
          }
        }
      }
 
      inline void CopyImageDataMonoToMono(const Image &src, void *dst, int linePad) noexcept
      {
        auto dstMono = reinterpret_cast<std::uint8_t *>(dst);
        auto vpat    = src.Plane(0).Vpat();
        auto entrys  = vpat.VpatPtr();
        auto base    = vpat.BasePtr();
 
        auto widht  = src.Width();
        auto height = src.Height();
 
        for (int h = 0; h < height; ++h)
        {
          auto lineOffset = base + entrys[h].OffsetY;
          for (int w = 0; w < widht; ++w)
          {
            (*dstMono) = *reinterpret_cast<std::uint8_t *>(lineOffset + entrys[w].OffsetX);
            ++dstMono;
          }
          dstMono += linePad;
        }
      }
 
      inline void CopyImageDataMonoToBGRA(const Image &src, void *dst) noexcept
      {
        CopyImageDataMonoToColor(src, reinterpret_cast<BGRAComponents *>(dst));
      }
 
      inline void CopyImageDataMonoToRGBA(const Image &src, void *dst) noexcept
      {
        CopyImageDataMonoToColor(src, reinterpret_cast<RGBAComponents *>(dst));
      }
 
      inline void CopyImageDataRGBToBGRA(const Image &src, void *dst) noexcept
      {
        CopyImageDataColorToColor(src, reinterpret_cast<BGRAComponents *>(dst));
      }
 
      inline void CopyImageDataRGBToRGBA(const Image &src, void *dst) noexcept
      {
        CopyImageDataColorToColor(src, reinterpret_cast<RGBAComponents *>(dst));
      }
 
      class ImageViewDispatcher : public UI::Private::IImageView
      {
        friend class ImageViewDispatcherGuard;
 
      public:
        explicit ImageViewDispatcher(std::function<void()> notifyZoom)
            : zoomHandler_(*this)
            , notifyZoom_(notifyZoom)
        {
        }
 
        UI::ZoomID ZoomID() const noexcept
        {
          return zoomHandler_.ZoomDescriptor().ID;
        }
 
        void UpdateZoomID(UI::ZoomID id, std::function<void()> notify)
        {
          if (id == ZoomID())
            return;
 
          zoomHandler_.SetZoomDescriptor(ZoomDescriptor(id));
          notify();
        }
 
        void UpdateUploadMode(UI::UploadMode uploadMode, std::function<void()> notify)
        {
          if (uploadMode_ == uploadMode)
            return;
 
          {
            std::unique_lock<std::mutex> gurad(
                renderMutex_);  // prevent mixing upload modes during render (innermost mutex)
            uploadMode_ = uploadMode;
          }
          notify();
        }
 
        double ZoomFactor() const noexcept
        {
          return zoomHandler_.ZoomDescriptor().Factor;
        }
 
        void UpdateZoomFactor(double factor, std::function<void()> notify)
        {
          if (factor == ZoomFactor())
            return;
 
          zoomHandler_.SetZoomDescriptor(ZoomDescriptor(factor));
          notify();
        }
 
        Point2D<double> ImageAnchor() const noexcept
        {
          return imageAnchor_;
        }
 
        void UpdateImageAnchor(Point2D<double> imageAnchor, std::function<void()> notify)
        {
          if (imageAnchor_ == imageAnchor)
            return;
 
          imageAnchor_ = imageAnchor;
          notify();
        }
 
        Point2D<double> ViewAnchor() const noexcept
        {
          return viewAnchor_;
        }
 
        void UpdateViewAnchor(Point2D<double> viewAnchor, std::function<void()> notify)
        {
          if (viewAnchor_ == viewAnchor)
            return;
 
          viewAnchor_ = viewAnchor;
          notify();
        }
 
        Point2D<double> LastMousePosition() const noexcept
        {
          return *lastPos_;
        }
 
        Point2D<double> HoverPosition() const noexcept
        {
          return *hoverPosition_;
        }
 
        bool TryTranslate(Vector2D<double> translation, std::function<void()> notifySourceRect)
        {
          auto zoom = zoomHandler_.ZoomDescriptor().Factor;
 
          auto imageTranslation = translation / zoom;
          auto xRange           = imageRect_.Width() - sourceRect_.Width();
          auto yRange           = imageRect_.Height() - sourceRect_.Height();
 
          auto sourceCandidate = sourceRect_;
 
          auto translationCandidate = sourceCandidate.Location() - imageTranslation;
 
#ifdef min
#  undef min
#endif
#ifdef max
#  undef max
#endif
 
          // ensure min range
          translationCandidate.SetX(std::max(translationCandidate.X(), 0.0));
          translationCandidate.SetY(std::max(translationCandidate.Y(), 0.0));
 
          // ensure max range
          Point2D<double> location(std::min(xRange, translationCandidate.X()),
                                   std::min(yRange, translationCandidate.Y()));
          sourceCandidate.SetLocation(location);
 
          auto result = sourceRect_ != sourceCandidate;
          UpdateSourceRect(sourceCandidate, notifySourceRect);
          return result;
        }
 
        bool TryZoomIn(std::function<void()> notifyTargetRect, std::function<void()> notifySourceRect)
        {
          auto result = zoomHandler_.TryZoomIn();
          UpdateTargetSource(notifyTargetRect, notifySourceRect);
          return result;
        }
 
        bool TryZoomOut(std::function<void()> notifyTargetRect, std::function<void()> notifySourceRect)
        {
          auto result = zoomHandler_.TryZoomOut();
          UpdateTargetSource(notifyTargetRect, notifySourceRect);
          return result;
        }
 
        RectLT<double> ViewRect() const noexcept
        {
          return viewRect_;
        }
 
        RectLT<double> ImageRect() const noexcept
        {
          return imageRect_;
        }
 
        RectLT<double> SourceRect() const noexcept
        {
          return sourceRect_;
        }
 
        RectLT<double> TargetRect() const noexcept
        {
          return targetRect_;
        }
 
        void UpdateViewRect(RectLT<double> rect, std::function<void()> notify)
        {
          if (viewRect_ == rect)
            return;
          viewRect_ = rect;
          notify();
        }
 
        UI::UploadMode UploadMode() const noexcept
        {
          return uploadMode_;
        }
 
        Point2D<double> MapViewToTarget(Point2D<double> viewPoint) const
        {
          return viewPoint - targetRect_.Location();
        }
 
        Point2D<double> MapTargetToSource(Point2D<double> targetPoint) const
        {
          return targetPoint / zoomHandler_.ZoomDescriptor().Factor;
        }
 
        Point2D<double> MapSourceToImage(Point2D<double> sourcePoint) const
        {
          return sourcePoint + sourceRect_.Location();
        }
 
        Point2D<double> MapTargetToView(Point2D<double> targetPoint) const
        {
          return targetPoint + targetRect_.Location();
        }
 
        Point2D<double> MapSourceToTarget(Point2D<double> sourcePoint) const
        {
          return sourcePoint * zoomHandler_.ZoomDescriptor().Factor;
        }
 
        Point2D<double> MapImageToSource(Point2D<double> imagePoint) const
        {
          return imagePoint - sourceRect_.Location();
        }
 
        Point2D<double> MapViewToImage(Point2D<double> viewPoint) const
        {
          return MapSourceToImage(MapTargetToSource(MapViewToTarget(viewPoint)));
        }
 
        Point2D<double> MapImageToView(Point2D<double> imagePoint) const
        {
          return MapTargetToView(MapSourceToTarget(MapImageToSource(imagePoint)));
        }
 
        Point2D<double> MapTargetToImage(Point2D<double> targetPoint) const
        {
          return MapSourceToImage(MapTargetToSource(targetPoint));
        }
 
        Point2D<double> MapImageToTarget(Point2D<double> imagePoint) const
        {
          return MapSourceToTarget(MapImageToSource(imagePoint));
        }
 
        void UploadImage(const Image &image, std::function<void()> notifyImageRect)
        {
          std::unique_lock<std::mutex> guard(renderMutex_);
          UpdateImageRect(image, notifyImageRect);
 
          auto mappedImage = UpdateRenderTarget(image);
 
          if (uploadMode_ == UI::UploadMode::Image)
            CopyImageData(image);
          else if (mappedImage)
            CopyImageData(*mappedImage);
        }
 
        void CopyImageData(const Image &image) noexcept
        {
          switch (image.PlanesCount())
          {
            default:
              return;
 
            case 1:
              UI::Private::CopyImageDataMonoToBGRA(image, buffer_.data());
              return;
 
            case 3:
            case 4:  // RGBA8 support
              UI::Private::CopyImageDataRGBToBGRA(image, buffer_.data());
              return;
          }
        }
 
        void UpdateImageRect(const Cvb::Image &image, std::function<void()> notify)
        {
          RectLT<double> requestedImageRect(
              Point2D<double>(0.0, 0.0),
              Size2D<double>(static_cast<double>(image.Width()), static_cast<double>(image.Height())));
 
          if (imageRect_ == requestedImageRect)
            return;
 
          imageRect_ = requestedImageRect;
          notify();
        }
 
        void UpdateTargetRect(RectLT<double> rect, std::function<void()> notify)
        {
          if (targetRect_ == rect)
            return;
          targetRect_ = rect;
          notify();
        }
 
        void UpdateSourceRect(RectLT<double> rect, std::function<void()> notify)
        {
          if (sourceRect_ == rect)
            return;
          sourceRect_ = rect;
          notify();
        }
 
        void UpdateBuffer(Size2D<int> size)
        {
          bufferSize_ = size;
          std::vector<std::uint8_t>(static_cast<size_t>(bufferSize_.Width()) * static_cast<size_t>(bufferSize_.Height())
                                    * 4)
              .swap(buffer_);
        }
 
        std::unique_ptr<class Image> UpdateRenderTarget(const Cvb::Image &image)
        {
          if (uploadMode_ == UI::UploadMode::Image)
          {
            auto currentWidth  = image.Width();
            auto currentHeight = image.Height();
            if (bufferSize_ == Size2D<int>(currentWidth, currentHeight))
              return std::unique_ptr<class Image>();
 
            UpdateBuffer(Size2D<int>(currentWidth, currentHeight));
            return std::unique_ptr<class Image>();
          }
          else
          {
            // get the part of the image that is visible in as integer pixel coordinates (for some pixels only a tiny
            // part might be visible)
            auto sourceLeft   = std::max(static_cast<int>(std::floor(sourceRect_.Left())), 0);
            auto sourceTop    = std::max(static_cast<int>(std::floor(sourceRect_.Top())), 0);
            auto sourceRight  = std::min(static_cast<int>(std::ceil(sourceRect_.Right())), image.Width() - 1);
            auto sourceBottom = std::min(static_cast<int>(std::ceil(sourceRect_.Bottom())), image.Height() - 1);
            Size2D<int> sourceSize(sourceRight - sourceLeft, sourceBottom - sourceTop);
            Rect<int> sourceRect(Point2D<int>(sourceLeft, sourceTop), sourceSize);
 
            // validate source rectangle is positive
            if (sourceRect.Width() <= 0 || sourceRect.Height() <= 0)
              return std::unique_ptr<class Image>();
 
            // validate source rectangle is positive
            if (!targetRect_.IsValid())
              return std::unique_ptr<class Image>();
 
            Size2D<int> targetSize;
            if (sourceRect_.Width() <= targetRect_.Width())  // source pixel is bigger in target -> zoom
            {
              targetSize     = sourceRect.Size();
              sourceRectAdj_ = RectLT<double>(
                  Point2D<double>(sourceRect_.Left() - std::floor(sourceRect_.Left()),
                                  sourceRect_.Top() - std::floor(sourceRect_.Top())),
                  Size2D<double>(std::min(sourceRect_.Width(), static_cast<double>(sourceRect.Width())),
                                 std::min(sourceRect_.Height(), static_cast<double>(sourceRect.Height()))));
            }
            else
            {
              targetSize = Size2D<int>(static_cast<int>(targetRect_.Width()), static_cast<int>(targetRect_.Height()));
              sourceRectAdj_ =
                  RectLT<double>(Point2D<double>(0.0, 0.0), Size2D<double>(targetSize.Width(), targetSize.Height()));
            }
 
            if (targetSize.Width() <= 0 || targetSize.Height() <= 0)
              return std::unique_ptr<class Image>();
 
            auto mappedImage = image.Map(sourceRect, targetSize);
            if (bufferSize_ == Size2D<int>(targetSize.Width(), targetSize.Height()))
              return mappedImage;
 
            UpdateBuffer(targetSize);
            return mappedImage;
          }
        }
 
        Point2D<double> LimitPointToRect(Point2D<double> point, RectLT<double> rect)
        {
          auto result = point;
          if (result.X() < 0.0)
            result.SetX(0.0);
          else if (result.X() > rect.Width())
            result.SetX(rect.Width());
          if (result.Y() < 0.0)
            result.SetY(0.0);
          else if (result.Y() > rect.Height())
            result.SetY(rect.Height());
          return result;
        }
 
        void UpdateTargetSource(std::function<void()> notifyTargetRect, std::function<void()> notifySourceRect)
        {
          zoomHandler_.UpdatePanoramaFactor();
          auto zoom = zoomHandler_.ZoomDescriptor().Factor;
 
          auto contentWidth  = zoom * imageRect_.Width();
          auto contentHeight = zoom * imageRect_.Height();
 
          UpdateTargetRect(
              RectLT<double>(
                  Point2D<double>(
                      (contentWidth <= viewRect_.Width()) ? (viewRect_.Width() - contentWidth) / 2.0
                                                          : 0.0,  // if all the image content width fits into the view
                                                                  // port center it otherwise fill the target
                      (contentHeight <= viewRect_.Height()) ? (viewRect_.Height() - contentHeight) / 2.0
                                                            : 0.0),  // if all the image content height fits into the
                                                                     // view port center it otherwise fill the target
                  Size2D<double>((contentWidth < viewRect_.Width())
                                     ? contentWidth
                                     : viewRect_.Width(),  // if all the image content width fits into the view port
                                                           // draw all of it otherwise fill the viewport
                                 (contentHeight < viewRect_.Height()) ? contentHeight : viewRect_.Height())),
              notifyTargetRect);  // if all the image content height fits into the view port draw all of it otherwise
                                  // fill the viewport
 
          // The view port rectangle adjusted by the current zoom factor is our maximum candidate source rectangle
          auto sourceCandidate = viewRect_;  // TODO verify
          sourceCandidate.SetWidth(sourceCandidate.Width() / zoom);
          sourceCandidate.SetHeight(sourceCandidate.Height() / zoom);
 
          // However the source rectangle might be smaller as our candidate rectangle
          sourceCandidate.SetWidth(std::min(sourceCandidate.Width(), imageRect_.Width()));
          sourceCandidate.SetHeight(std::min(sourceCandidate.Height(), imageRect_.Height()));
 
          auto targetPoint = MapViewToTarget(viewAnchor_);
          targetPoint      = LimitPointToRect(targetPoint, targetRect_);
          auto sourcePoint = MapTargetToSource(targetPoint);
 
          auto offsetCandidate = imageAnchor_ - sourcePoint;
 
          // Valid range for offset
          auto xRange = imageRect_.Width() - sourceCandidate.Width();
          auto yRange = imageRect_.Height() - sourceCandidate.Height();
 
          // ancor point for zoom in the center of your image if possible
          auto xOffsetCandidate = offsetCandidate.X();
          auto yOffsetCandidate = offsetCandidate.Y();
 
          // ensure min range
          xOffsetCandidate = std::max(xOffsetCandidate, 0.0);
          yOffsetCandidate = std::max(yOffsetCandidate, 0.0);
 
          // ensure max range
          Point2D<double> location(std::min(xRange, xOffsetCandidate), std::min(yRange, yOffsetCandidate));
          sourceCandidate.SetLocation(location);
 
          UpdateSourceRect(sourceCandidate, notifySourceRect);
        }
 
        void UpdateHoverPosition(Point2D<double> point, std::function<void()> notify)
        {
          if (hoverPosition_ && *hoverPosition_ == point)
            return;
 
          hoverPosition_ = std::make_unique<Point2D<double>>(point);
          notify();
        }
 
        void InvalidateLastMousePosition() noexcept
        {
          lastPos_.reset();
        }
 
        void InvalidateLastMousePosition(Point2D<double> point) noexcept
        {
          lastPos_ = std::make_unique<Point2D<double>>(point);
        }
 
        bool IsLastMousePositionValid() const noexcept
        {
          return (lastPos_) ? true : false;
        }
 
        bool IsHoverPositionValid() const noexcept
        {
          return (hoverPosition_) ? true : false;
        }
 
        Size2D<double> ViewSize() const noexcept override
        {
          return viewRect_.Size();
        }
 
        Size2D<double> ImageSize() const noexcept override
        {
          return imageRect_.Size();
        }
 
        void ApplyZoom(double) override
        {
          notifyZoom_();
        }
 
        RectLT<double> SourceRectAdj() const noexcept
        {
          return sourceRectAdj_;
        }
 
        bool IsBufferValid() const noexcept
        {
          return (buffer_.size()) ? true : false;
        }
 
        std::uint8_t *Buffer() const noexcept
        {
          return buffer_.data();
        }
 
        Size2D<int> BufferSize() const noexcept
        {
          return bufferSize_;
        }
 
      private:
        RectLT<double> imageRect_;
        RectLT<double> viewRect_;
        RectLT<double> sourceRect_;
        RectLT<double> targetRect_;
 
        RectLT<double> sourceRectAdj_;
 
        Point2D<double> viewAnchor_;
        Point2D<double> imageAnchor_;
 
        std::mutex renderMutex_;
 
        UI::Private::ZoomHandler zoomHandler_;
 
        std::unique_ptr<Point2D<double>> lastPos_;
        std::unique_ptr<Point2D<double>> hoverPosition_;
 
        Cvb::UI::UploadMode uploadMode_ = UI::UploadMode::Image;
 
        mutable std::vector<std::uint8_t> buffer_;
        Size2D<int> bufferSize_;
 
        std::function<void()> notifyZoom_;
      };
 
      class ImageViewDispatcherGuard
      {
      public:
        explicit ImageViewDispatcherGuard(ImageViewDispatcher &dispatcher)
            : dispatcher_(dispatcher)
        {
          dispatcher_.renderMutex_.lock();
        }
 
        ImageViewDispatcherGuard(const ImageViewDispatcherGuard &other)            = delete;
        ImageViewDispatcherGuard &operator=(const ImageViewDispatcherGuard &other) = delete;
        ImageViewDispatcherGuard(ImageViewDispatcherGuard &&other)                 = delete;
        ImageViewDispatcherGuard &operator=(ImageViewDispatcherGuard &&other)      = delete;
        ~ImageViewDispatcherGuard()
        {
          dispatcher_.renderMutex_.unlock();
        }
 
      private:
        ImageViewDispatcher &dispatcher_;
      };
 
    }  // namespace Private
 
  }  // namespace UI
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb