mitkRenderWindowBridge.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkRenderWindowBridge_h
#define mitkRenderWindowBridge_h
 
#include <MitkRESTAPIExports.h>
#include <mitkAnatomicalPlanes.h>
#include <mitkPoint.h>
#include <mitkStorageThreadDispatcherBase.h>
#include <mitkVector.h>
#include <mitkWeakPointer.h>
 
#include <functional>
#include <mutex>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>
#include <vector>
 
namespace mitk
{
  enum class ScreenshotFormat
  {
    Png,
    Jpeg
  };
 
  struct WorldBounds
  {
    Point3D minPosition;
    Point3D maxPosition;
 
    WorldBounds() : minPosition(), maxPosition() {}
  };
 
  struct SelectedPositionInfo
  {
    Point3D position;
 
    std::optional<WorldBounds> bounds;
 
    SelectedPositionInfo() : position() {}
  };
 
  class MITKRESTAPI_EXPORT RenderWindowBridgeNoEditorException : public std::runtime_error
  {
  public:
    using std::runtime_error::runtime_error;
  };
 
  class MITKRESTAPI_EXPORT RenderWindowBridgeUnknownWindowException : public std::runtime_error
  {
  public:
    using std::runtime_error::runtime_error;
  };
 
  class MITKRESTAPI_EXPORT RenderWindowBridgeUnsupportedOperationException : public std::runtime_error
  {
  public:
    using std::runtime_error::runtime_error;
  };
 
  class MITKRESTAPI_EXPORT RenderWindowBridgeRendererUnavailableException : public std::runtime_error
  {
  public:
    using std::runtime_error::runtime_error;
  };
 
  struct EditorInfo
  {
    std::string alias;
    std::string pluginId;
    bool active = false;
    // Window identifiers exposed by the editor. For MxN, this is the
    // canonical fully-qualified `id` field of each window leaf in the v2
    // layout document (e.g. `mxn__widget0`): the same string used as the
    // URL path segment for sub-resources. For StdMulti, the engine-fixed
    // names (axial / sagittal / coronal / 3d). Empty when !active.
    std::vector<std::string> windowIds;
  };
 
  enum class WindowKind
  {
    TwoD,
    ThreeD
  };
 
  MITKRESTAPI_EXPORT const char* WindowKindToString(WindowKind kind);
 
  MITKRESTAPI_EXPORT const char* AnatomicalPlaneToV2String(AnatomicalPlane plane);
 
  MITKRESTAPI_EXPORT AnatomicalPlane ParseV2ViewDirection(const std::string& s);
 
  struct WindowInfo
  {
    std::string                    id; // "axial" | "sagittal" | "coronal" | "3d"
    WindowKind                     kind = WindowKind::TwoD;
    std::optional<AnatomicalPlane> viewDirection;
  };
 
  struct MxNWindowInfo
  {
    std::string                    id;             // canonical fully-qualified window id
    std::optional<std::string>     displayName;    // human-readable label; nullopt when absent
    WindowKind                     kind = WindowKind::TwoD;
    std::optional<AnatomicalPlane> viewDirection;  // always set for 2D cells under v2; nullopt reserved for v3 3D cells. Mapped to v2 strings via AnatomicalPlaneToV2String when present.
    std::string                    selectionGroup; // links.selection group label
  };
 
  struct CameraState
  {
    Point3D position;
    Point3D focalPoint;
    Vector3D viewUp;
    std::optional<double> parallelScale;    // 2D windows only
    std::optional<double> perspectiveAngle; // 3D windows only
 
    CameraState() : position(), focalPoint(), viewUp() {}
  };
 
  struct CameraPatch
  {
    std::optional<Point3D>     position;
    std::optional<Point3D>     focalPoint;
    std::optional<Vector3D>    viewUp;
    std::optional<double>      parallelScale;
    std::optional<double>      perspectiveAngle;
    std::optional<std::string> standardView; // applied first if present
  };
 
  struct SliceBounds
  {
    unsigned int steps = 0;
    Point3D minPosition;
    Point3D maxPosition;
    bool hasPositions = false; // false if no geometry loaded
 
    SliceBounds() : minPosition(), maxPosition() {}
  };
 
  struct SliceState
  {
    unsigned int step = 0;
    Point3D position;
    SliceBounds bounds;
 
    SliceState() : position() {}
  };
 
  class MITKRESTAPI_EXPORT RenderWindowBridge
  {
  public:
    using ScreenshotProvider =
      std::function<std::vector<unsigned char>(
        std::optional<std::pair<int, int>> size,
        ScreenshotFormat format)>;
 
    using PositionGetter = std::function<SelectedPositionInfo()>;
 
    using PositionSetter = std::function<void(const Point3D& pos)>;
 
    using EditorListProvider = std::function<std::vector<EditorInfo>()>;
 
    using StdMultiWindowListProvider = std::function<std::vector<WindowInfo>()>;
 
    using StdMultiEditorScreenshotProvider =
      std::function<std::vector<unsigned char>(
        std::optional<std::pair<int, int>> size,
        ScreenshotFormat format)>;
 
    using StdMultiWindowScreenshotProvider =
      std::function<std::vector<unsigned char>(
        const std::string& windowId,
        std::optional<std::pair<int, int>> size,
        ScreenshotFormat format)>;
 
    using StdMultiCameraGetter = std::function<CameraState(const std::string& windowId)>;
 
    using StdMultiCameraSetter = std::function<void(const std::string& windowId, const CameraPatch& patch)>;
 
    using StdMultiSelectedSliceGetter = std::function<SliceState(const std::string& windowId)>;
 
    using StdMultiSelectedSliceStepSetter = std::function<void(const std::string& windowId, unsigned int step)>;
 
    using MxNWindowListProvider = std::function<std::vector<MxNWindowInfo>()>;
 
    using MxNEditorScreenshotProvider =
      std::function<std::vector<unsigned char>(
        std::optional<std::pair<int, int>> size,
        ScreenshotFormat format)>;
 
    using MxNWindowScreenshotProvider =
      std::function<std::vector<unsigned char>(
        const std::string& windowId,
        std::optional<std::pair<int, int>> size,
        ScreenshotFormat format)>;
 
    using MxNCameraGetter = std::function<CameraState(const std::string& windowId)>;
 
    using MxNCameraSetter = std::function<void(const std::string& windowId, const CameraPatch& patch)>;
 
    using MxNSelectedSliceGetter = std::function<SliceState(const std::string& windowId)>;
 
    using MxNSelectedSliceStepSetter = std::function<void(const std::string& windowId, unsigned int step)>;
 
    using MxNSelectedPositionGetter =
      std::function<SelectedPositionInfo(const std::string& windowId)>;
 
    using MxNSelectedPositionSetter =
      std::function<void(const std::string& windowId, const Point3D& position)>;
 
    using MxNLayoutGetter = std::function<std::string()>;
 
    using MxNLayoutSetter = std::function<std::string(const std::string& layoutJson)>;
 
    void SetDispatcher(StorageThreadDispatcherBase* dispatcher);
 
    void SetScreenshotProvider(ScreenshotProvider provider);
 
    void SetPositionGetter(PositionGetter getter);
 
    void SetPositionSetter(PositionSetter setter);
 
    void SetEditorListProvider(EditorListProvider provider);
 
    void SetStdMultiWindowListProvider(StdMultiWindowListProvider provider);
 
    void SetStdMultiEditorScreenshotProvider(StdMultiEditorScreenshotProvider provider);
 
    void SetStdMultiWindowScreenshotProvider(StdMultiWindowScreenshotProvider provider);
 
    void SetStdMultiCameraGetter(StdMultiCameraGetter getter);
 
    void SetStdMultiCameraSetter(StdMultiCameraSetter setter);
 
    void SetStdMultiSelectedSliceGetter(StdMultiSelectedSliceGetter getter);
 
    void SetStdMultiSelectedSliceStepSetter(StdMultiSelectedSliceStepSetter setter);
 
    void SetMxNWindowListProvider(MxNWindowListProvider provider);
 
    void SetMxNEditorScreenshotProvider(MxNEditorScreenshotProvider provider);
 
    void SetMxNWindowScreenshotProvider(MxNWindowScreenshotProvider provider);
 
    void SetMxNCameraGetter(MxNCameraGetter getter);
 
    void SetMxNCameraSetter(MxNCameraSetter setter);
 
    void SetMxNSelectedSliceGetter(MxNSelectedSliceGetter getter);
 
    void SetMxNSelectedSliceStepSetter(MxNSelectedSliceStepSetter setter);
 
    void SetMxNSelectedPositionGetter(MxNSelectedPositionGetter getter);
 
    void SetMxNSelectedPositionSetter(MxNSelectedPositionSetter setter);
 
    void SetMxNLayoutGetter(MxNLayoutGetter getter);
 
    void SetMxNLayoutSetter(MxNLayoutSetter setter);
 
    void ResetCallbacks();
 
    bool HasScreenshotProvider() const;
 
    bool HasPositionGetter() const;
 
    bool HasPositionSetter() const;
 
    bool HasEditorListProvider() const;
    bool HasStdMultiWindowListProvider() const;
    bool HasStdMultiEditorScreenshotProvider() const;
    bool HasStdMultiWindowScreenshotProvider() const;
    bool HasStdMultiCameraGetter() const;
    bool HasStdMultiCameraSetter() const;
    bool HasStdMultiSelectedSliceGetter() const;
    bool HasStdMultiSelectedSliceStepSetter() const;
 
    bool HasMxNWindowListProvider() const;
    bool HasMxNEditorScreenshotProvider() const;
    bool HasMxNWindowScreenshotProvider() const;
    bool HasMxNCameraGetter() const;
    bool HasMxNCameraSetter() const;
    bool HasMxNSelectedSliceGetter() const;
    bool HasMxNSelectedSliceStepSetter() const;
    bool HasMxNSelectedPositionGetter() const;
    bool HasMxNSelectedPositionSetter() const;
    bool HasMxNLayoutGetter() const;
    bool HasMxNLayoutSetter() const;
 
    std::vector<unsigned char> TakeScreenshot(
      std::optional<std::pair<int, int>> size,
      ScreenshotFormat format) const;
 
    SelectedPositionInfo GetSelectedPosition() const;
 
    void SetSelectedPosition(const Point3D& pos) const;
 
    std::vector<EditorInfo> ListEditors() const;
 
    std::vector<WindowInfo> ListStdMultiWindows() const;
 
    std::vector<unsigned char> TakeStdMultiEditorScreenshot(
      std::optional<std::pair<int, int>> size,
      ScreenshotFormat format) const;
 
    std::vector<unsigned char> TakeStdMultiWindowScreenshot(
      const std::string& windowId,
      std::optional<std::pair<int, int>> size,
      ScreenshotFormat format) const;
 
    CameraState GetStdMultiCamera(const std::string& windowId) const;
    void SetStdMultiCamera(const std::string& windowId, const CameraPatch& patch) const;
    SliceState GetStdMultiSelectedSlice(const std::string& windowId) const;
    void SetStdMultiSelectedSliceStep(const std::string& windowId, unsigned int step) const;
 
    std::vector<MxNWindowInfo> ListMxNWindows() const;
 
    std::vector<unsigned char> TakeMxNEditorScreenshot(
      std::optional<std::pair<int, int>> size,
      ScreenshotFormat format) const;
 
    std::vector<unsigned char> TakeMxNWindowScreenshot(
      const std::string& windowId,
      std::optional<std::pair<int, int>> size,
      ScreenshotFormat format) const;
 
    CameraState GetMxNCamera(const std::string& windowId) const;
 
    void SetMxNCamera(const std::string& windowId, const CameraPatch& patch) const;
 
    SliceState GetMxNSelectedSlice(const std::string& windowId) const;
 
    void SetMxNSelectedSliceStep(const std::string& windowId, unsigned int step) const;
 
    SelectedPositionInfo GetMxNSelectedPosition(const std::string& windowId) const;
 
    void SetMxNSelectedPosition(const std::string& windowId, const Point3D& position) const;
 
    std::string GetMxNLayout() const;
 
    std::string SetMxNLayout(const std::string& layoutJson) const;
 
  private:
    ScreenshotProvider m_ScreenshotProvider;
    PositionGetter m_PositionGetter;
    PositionSetter m_PositionSetter;
    EditorListProvider m_EditorListProvider;
    StdMultiWindowListProvider m_StdMultiWindowListProvider;
    StdMultiEditorScreenshotProvider m_StdMultiEditorScreenshotProvider;
    StdMultiWindowScreenshotProvider m_StdMultiWindowScreenshotProvider;
    StdMultiCameraGetter m_StdMultiCameraGetter;
    StdMultiCameraSetter m_StdMultiCameraSetter;
    StdMultiSelectedSliceGetter m_StdMultiSelectedSliceGetter;
    StdMultiSelectedSliceStepSetter m_StdMultiSelectedSliceStepSetter;
    MxNWindowListProvider m_MxNWindowListProvider;
    MxNEditorScreenshotProvider m_MxNEditorScreenshotProvider;
    MxNWindowScreenshotProvider m_MxNWindowScreenshotProvider;
    MxNCameraGetter m_MxNCameraGetter;
    MxNCameraSetter m_MxNCameraSetter;
    MxNSelectedSliceGetter m_MxNSelectedSliceGetter;
    MxNSelectedSliceStepSetter m_MxNSelectedSliceStepSetter;
    MxNSelectedPositionGetter m_MxNSelectedPositionGetter;
    MxNSelectedPositionSetter m_MxNSelectedPositionSetter;
    MxNLayoutGetter m_MxNLayoutGetter;
    MxNLayoutSetter m_MxNLayoutSetter;
    mutable std::mutex m_Mutex;
    WeakPointer<StorageThreadDispatcherBase> m_Dispatcher;
  };
}
 
#endif