niftkSingleViewerWidget.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/
 
#ifndef niftkSingleViewerWidget_h
#define niftkSingleViewerWidget_h

#include <niftkDnDDisplayExports.h>

#include <deque>

#include <mitkDataStorage.h>
#include <mitkBaseGeometry.h>
#include <mitkTimeGeometry.h>
#include <mitkRenderingManager.h>
#include <QmitkRenderWindow.h>

#include <QColor>
#include <QTime>
#include <QWidget>

#include "niftkDnDDisplayEnums.h"
#include "Interactions/niftkDnDDisplayInteractor.h"

class QGridLayout;


namespace niftk
{

class MultiWindowWidget;

class NIFTKDNDDISPLAY_EXPORT SingleViewerWidget : public QWidget
{

  Q_OBJECT

public:

  SingleViewerWidget(QWidget* parent = 0, mitk::RenderingManager* renderingManager = 0, const QString& name = "DnD-Viewer");
  virtual ~SingleViewerWidget();

  bool IsEnabled() const;

  void SetEnabled(bool enabled);

  bool IsFocused() const;

  void SetFocused();

  QmitkRenderWindow* GetSelectedRenderWindow() const;

  void SetSelectedRenderWindow(QmitkRenderWindow* renderWindow);

  std::vector<QmitkRenderWindow*> GetVisibleRenderWindows() const;

  const std::vector<QmitkRenderWindow*>& GetRenderWindows() const;

  QmitkRenderWindow* GetAxialWindow() const;

  QmitkRenderWindow* GetCoronalWindow() const;

  QmitkRenderWindow* GetSagittalWindow() const;

  QmitkRenderWindow* Get3DWindow() const;

  WindowOrientation GetOrientation() const;

  bool IsCursorVisible() const;

  void SetCursorVisible(bool visible);

  bool AreDirectionAnnotationsVisible() const;

  void SetDirectionAnnotationsVisible(bool visible);

  bool IsIntensityAnnotationVisible() const;

  void SetIntensityAnnotationVisible(bool visible);

  bool GetShow3DWindowIn2x2WindowLayout() const;

  void SetShow3DWindowIn2x2WindowLayout(bool enabled);

  void SetRememberSettingsPerWindowLayout(bool remember);

  bool GetRememberSettingsPerWindowLayout() const;

  void SetBackgroundColour(QColor colour);

  QColor GetBackgroundColour() const;

  int GetMaxSlice(WindowOrientation orientation) const;

  int GetMaxTimeStep() const;

  bool ContainsRenderWindow(QmitkRenderWindow *renderWindow) const;

  void SetVisibility(std::vector<mitk::DataNode*> nodes, bool visible);

  double GetMinMagnification() const;

  double GetMaxMagnification() const;

  void RequestUpdate();

  const mitk::TimeGeometry* GetTimeGeometry() const;

  void SetTimeGeometry(const mitk::TimeGeometry* timeGeometry);

  void SetBoundTimeGeometry(const mitk::TimeGeometry* timeGeometry);

  void SetBoundTimeGeometryActive(bool isBound);

  bool IsBoundTimeGeometryActive();

  int GetSelectedSlice(WindowOrientation orientation) const;

  void SetSelectedSlice(WindowOrientation orientation, int slice);

  int GetTimeStep() const;

  void SetTimeStep(int timeStep);

  WindowLayout GetWindowLayout() const;

  void SetWindowLayout(WindowLayout windowLayout);

  const mitk::Point3D& GetSelectedPosition() const;

  void SetSelectedPosition(const mitk::Point3D& selectedPosition);

  mitk::Vector2D GetCursorPosition(WindowOrientation orientation) const;

  void SetCursorPosition(WindowOrientation orientation, const mitk::Vector2D& cursorPosition);

  const std::vector<mitk::Vector2D>& GetCursorPositions() const;

  void SetCursorPositions(const std::vector<mitk::Vector2D>& cursorPositions);

  double GetScaleFactor(WindowOrientation orientation) const;

  void SetScaleFactor(WindowOrientation orientation, double scaleFactor);

  const std::vector<double>& GetScaleFactors() const;

  void SetScaleFactors(const std::vector<double>& scaleFactors);

  double GetMagnification(WindowOrientation orientation) const;

  void SetMagnification(WindowOrientation orientation, double magnification);

  bool IsLinkedNavigationEnabled() const;

  void SetLinkedNavigationEnabled(bool linkedNavigationEnabled);

  void SetDisplayInteractionsEnabled(bool enabled);

  bool AreDisplayInteractionsEnabled() const;

  bool GetCursorPositionBinding() const;

  void SetCursorPositionBinding(bool bound);

  bool GetScaleFactorBinding() const;

  void SetScaleFactorBinding(bool bound);

  void FitToDisplay(double scaleFactor = 0.0);

  std::vector<mitk::DataNode*> GetWidgetPlanes();

  int GetSliceUpDirection(WindowOrientation orientation) const;

  void SetDefaultSingleWindowLayout(WindowLayout windowLayout);

  void SetDefaultMultiWindowLayout(WindowLayout windowLayout);

  void MoveSlice(WindowOrientation orientation, int delta, bool restart = false);

  void ToggleMultiWindowLayout();

  void ToggleCursorVisibility();

  void ToggleDirectionAnnotations();

  void ToggleIntensityAnnotation();

  bool BlockUpdate(bool blocked);

signals:

  void NodesDropped(std::vector<mitk::DataNode*> nodes);

  void SelectedPositionChanged(const mitk::Point3D& selectedPosition);

  void TimeStepChanged(int timeStep);

  void CursorPositionChanged(WindowOrientation orientation, const mitk::Vector2D& cursorPosition);

  void ScaleFactorChanged(WindowOrientation orientation, double scaleFactor);

  void CursorPositionBindingChanged(bool bound);

  void ScaleFactorBindingChanged(bool bound);

  void WindowLayoutChanged(WindowLayout windowLayout);

  void TimeGeometryChanged(const mitk::TimeGeometry* timeGeometry);

  void CursorVisibilityChanged(bool visible);

  void DirectionAnnotationsVisibilityChanged(bool visible);

  void IntensityAnnotationVisibilityChanged(bool visible);

public slots:

  virtual void OnNodesDropped(QmitkRenderWindow *renderWindow, std::vector<mitk::DataNode*> nodes);

protected:

  virtual void paintEvent(QPaintEvent* event) override;

protected slots:

  virtual void OnWindowLayoutChanged(WindowLayout windowLayout);

  virtual void OnSelectedPositionChanged(const mitk::Point3D& selectedPosition);

  virtual void OnCursorPositionChanged(int orientation, const mitk::Vector2D& cursorPosition);

  virtual void OnScaleFactorChanged(int orientation, double scaleFactor);

  virtual void OnCursorPositionBindingChanged();

  virtual void OnScaleFactorBindingChanged();

private:

  inline int Index(int index) const
  {
    return (index << 1) + m_IsBoundTimeGeometryActive;
  }

  void ResetLastPositions();

  mitk::Vector2D GetCentrePosition(int windowIndex);

  std::vector<mitk::Vector2D> GetCentrePositions();

  mitk::Vector2D GetCursorPositionFromCentre(int windowIndex, const mitk::Vector2D& centrePosition);

  std::vector<mitk::Vector2D> GetCursorPositionsFromCentres(const std::vector<mitk::Vector2D>& centrePositions);

  mitk::RenderingManager::Pointer m_RenderingManager;

  QGridLayout* m_GridLayout;
  MultiWindowWidget* m_MultiWidget;

  bool m_IsBoundTimeGeometryActive;
  mitk::TimeGeometry::ConstPointer m_TimeGeometry;       // This comes from which ever image is dropped, so not visible outside this class.
  mitk::TimeGeometry::ConstPointer m_BoundTimeGeometry;  // Passed in, when we do "bind", so shared amongst multiple windows.

  double m_MinimumMagnification;         // Passed in as constructor arguments, so this class unaware of where it came from.
  double m_MaximumMagnification;         // Passed in as constructor arguments, so this class unaware of where it came from.

  WindowLayout m_WindowLayout;

  mitk::Point3D m_SelectedPositions[WINDOW_LAYOUT_NUMBER * 2];

  std::vector<mitk::Vector2D> m_CentrePositions[WINDOW_LAYOUT_NUMBER * 2];

  std::vector<double> m_ScaleFactors[WINDOW_LAYOUT_NUMBER * 2];

  bool m_CursorPositionBinding[WINDOW_LAYOUT_NUMBER * 2];

  bool m_ScaleFactorBinding[WINDOW_LAYOUT_NUMBER * 2];

  bool m_GeometryInitialised;

  bool m_WindowLayoutInitialised[WINDOW_LAYOUT_NUMBER * 2];

  std::deque<mitk::Point3D> m_LastSelectedPositions;

  std::deque<QTime> m_LastSelectedPositionTimes;

  std::deque<std::vector<mitk::Vector2D> > m_LastCursorPositions;

  std::deque<QTime> m_LastCursorPositionTimes;

  bool m_RememberSettingsPerWindowLayout;

  WindowLayout m_SingleWindowLayout;
  WindowLayout m_MultiWindowLayout;

  DnDDisplayInteractor::Pointer m_DisplayInteractor;

  us::ServiceRegistrationU m_DisplayInteractorService;
};

}

#endif