niftkSingleViewerWidgetState.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 niftkSingleViewerWidgetState_h
#define niftkSingleViewerWidgetState_h

#include <niftkSingleViewerWidget.h>

#include <QTest>

#include <mitkGlobalInteraction.h>


namespace niftk
{

static bool EqualsWithTolerance1(const mitk::Point3D& worldPosition1, const mitk::Point3D& worldPosition2, double tolerance = 0.001)
{
  return std::abs(worldPosition1[0] - worldPosition2[0]) < tolerance
      && std::abs(worldPosition1[1] - worldPosition2[1]) < tolerance
      && std::abs(worldPosition1[2] - worldPosition2[2]) < tolerance;
}

static bool EqualsWithTolerance(const mitk::Vector2D& cursorPosition1, const mitk::Vector2D& cursorPosition2, double tolerance = 0.01)
{
  return std::abs(cursorPosition1[0] - cursorPosition2[0]) < tolerance
      && std::abs(cursorPosition1[1] - cursorPosition2[1]) < tolerance;
}

class SingleViewerWidgetState : public itk::Object
{
public:

  mitkClassMacroItkParent(SingleViewerWidgetState, itk::Object)
  mitkNewMacro1Param(SingleViewerWidgetState, const SingleViewerWidget*)
  mitkNewMacro1Param(SingleViewerWidgetState, Self::Pointer)

  itkGetConstMacro(TimeGeometry, const mitk::TimeGeometry*);

  itkSetObjectMacro(TimeGeometry, mitk::TimeGeometry);

  itkGetConstMacro(Orientation, WindowOrientation);

  itkSetMacro(Orientation, WindowOrientation);

  itkGetConstMacro(WindowLayout, WindowLayout);

  itkSetMacro(WindowLayout, WindowLayout);

  itkGetConstMacro(SelectedRenderWindow, QmitkRenderWindow*);

  itkSetObjectMacro(SelectedRenderWindow, QmitkRenderWindow);

  itkGetConstMacro(TimeStep, unsigned);

  itkSetMacro(TimeStep, unsigned);

  itkGetConstMacro(SelectedPosition, mitk::Point3D);

  itkSetMacro(SelectedPosition, mitk::Point3D);

  itkGetConstMacro(CursorPositions, std::vector<mitk::Vector2D>);

  void SetCursorPositions(const std::vector<mitk::Vector2D>& cursorPositions)
  {
    this->m_CursorPositions = cursorPositions;
  }

  itkGetConstMacro(ScaleFactors, std::vector<double>);

  void SetScaleFactors(const std::vector<double>& scaleFactors)
  {
    m_ScaleFactors = scaleFactors;
  }

  itkGetConstMacro(CursorPositionBinding, bool);

  itkSetMacro(CursorPositionBinding, bool);

  itkGetConstMacro(ScaleFactorBinding, bool);

  itkSetMacro(ScaleFactorBinding, bool);

  bool EqualsWithTolerance(const std::vector<mitk::Vector2D>& cursorPositions1, const std::vector<mitk::Vector2D>& cursorPositions2, double tolerance = 0.001) const
  {
    std::vector<QmitkRenderWindow*> renderWindows = m_Viewer->GetRenderWindows();
    for (int i = 0; i < 3; ++i)
    {
      if (renderWindows[i]->isVisible() && !niftk::EqualsWithTolerance(cursorPositions1[i], cursorPositions2[i], tolerance))
      {
        return false;
      }
    }
    return true;
  }

  bool EqualsWithTolerance(const std::vector<double>& scaleFactors1, const std::vector<double>& scaleFactors2, double tolerance = 0.001) const
  {
    std::vector<QmitkRenderWindow*> renderWindows = m_Viewer->GetRenderWindows();
    for (int i = 0; i < 3; ++i)
    {
      if (renderWindows[i]->isVisible() && !niftk::EqualsWithTolerance(scaleFactors1[i], scaleFactors2[i], tolerance))
      {
        return false;
      }
    }
    return true;
  }

  bool operator==(const SingleViewerWidgetState& otherState) const
  {
    return
        this->GetTimeGeometry() == otherState.GetTimeGeometry()
        && this->GetOrientation() == otherState.GetOrientation()
        && this->GetWindowLayout() == otherState.GetWindowLayout()
        && this->GetSelectedRenderWindow() == otherState.GetSelectedRenderWindow()
        && this->GetTimeStep() == otherState.GetTimeStep()
        && niftk::EqualsWithTolerance1(this->GetSelectedPosition(), otherState.GetSelectedPosition(), 0.001)
        && this->EqualsWithTolerance(this->GetCursorPositions(), otherState.GetCursorPositions(), 0.01)
        && this->EqualsWithTolerance(this->GetScaleFactors(), otherState.GetScaleFactors(), 0.01)
        && this->GetCursorPositionBinding() == otherState.GetCursorPositionBinding()
        && this->GetScaleFactorBinding() == otherState.GetScaleFactorBinding();
  }

  inline bool operator!=(const SingleViewerWidgetState& otherState) const
  {
    return !(*this == otherState);
  }

  void PrintDifference(SingleViewerWidgetState::Pointer otherState, std::ostream & os = std::cout, itk::Indent indent = 0) const
  {
    if (this->GetTimeGeometry() != otherState->GetTimeGeometry())
    {
      os << indent << "Time geometry: " << this->GetTimeGeometry() << " ; " << otherState->GetTimeGeometry() << std::endl;
    }
    if (this->GetOrientation() != otherState->GetOrientation())
    {
      os << indent << "Orientation: " << this->GetOrientation() << " ; " << otherState->GetOrientation() << std::endl;
    }
    if (this->GetWindowLayout() != otherState->GetWindowLayout())
    {
      os << indent << "Window layout: " << this->GetWindowLayout() << " ; " << otherState->GetWindowLayout() << std::endl;
    }
    if (this->GetSelectedRenderWindow() != otherState->GetSelectedRenderWindow())
    {
      os << indent << "Selected render window: " << this->GetSelectedRenderWindow() << " ; " << otherState->GetOrientation() << std::endl;
    }
    if (this->GetTimeStep() != otherState->GetTimeStep())
    {
      os << indent << "Time step: " << this->GetTimeStep() << " ; " << otherState->GetTimeStep() << std::endl;
    }
    if (!niftk::EqualsWithTolerance1(this->GetSelectedPosition(), otherState->GetSelectedPosition(), 0.001))
    {
      os << indent << "Selected position: " << this->GetSelectedPosition() << ", " << otherState->GetSelectedPosition() << std::endl;
    }
    if (!this->EqualsWithTolerance(this->GetCursorPositions(), otherState->GetCursorPositions(), 0.01))
    {
      std::vector<mitk::Vector2D> otherStateCursorPositions = otherState->GetCursorPositions();
      os << indent << "Cursor positions:" << std::endl;
      os << indent << "    " << m_CursorPositions[0] << ", " << otherStateCursorPositions[0] << std::endl;
      os << indent << "    " << m_CursorPositions[1] << ", " << otherStateCursorPositions[1] << std::endl;
      os << indent << "    " << m_CursorPositions[2] << ", " << otherStateCursorPositions[2] << std::endl;
    }
    if (!this->EqualsWithTolerance(this->GetScaleFactors(), otherState->GetScaleFactors(), 0.01))
    {
      std::vector<double> otherStateScaleFactors = otherState->GetScaleFactors();
      os << indent << "Scale factors:" << std::endl;
      os << indent << "    " << m_ScaleFactors[0] << ", " << otherStateScaleFactors[0] << std::endl;
      os << indent << "    " << m_ScaleFactors[1] << ", " << otherStateScaleFactors[1] << std::endl;
      os << indent << "    " << m_ScaleFactors[2] << ", " << otherStateScaleFactors[2] << std::endl;
    }
    if (this->GetCursorPositionBinding() != otherState->GetCursorPositionBinding())
    {
      os << indent << "Cursor position binding: " << this->GetCursorPositionBinding() << " ; " << otherState->GetCursorPositionBinding() << std::endl;
    }
    if (this->GetScaleFactorBinding() != otherState->GetScaleFactorBinding())
    {
      os << indent << "Scale factor binding: " << this->GetScaleFactorBinding() << " ; " << otherState->GetScaleFactorBinding() << std::endl;
    }
  }

  void Check() const
  {
    if (m_Viewer->IsFocused())
    {
      QmitkRenderWindow* selectedRenderWindow = m_Viewer->GetSelectedRenderWindow();
      if (!selectedRenderWindow)
      {
        MITK_INFO << "ERROR: Invalid state. The viewer is selected but there is no selected render window.";
        MITK_INFO << Self::ConstPointer(this);
        QFAIL("Invalid state. The viewer is selected but there is no selected render window.");
      }
      if (qApp->focusWidget() && !selectedRenderWindow->hasFocus())
      {
        MITK_INFO << "ERROR: Invalid state. The viewer is selected but the selected render window has not got the Qt key focus.";
        MITK_INFO << Self::ConstPointer(this);
        QFAIL("Invalid state. The viewer is selected but the selected render window has not got the Qt key focus.");
      }
      if (mitk::GlobalInteraction::GetInstance()->GetFocus() != selectedRenderWindow->GetRenderer())
      {
        MITK_INFO << "ERROR: Invalid state. The viewer is selected but the selected render window has not got the MITK interaction focus.";
        MITK_INFO << Self::ConstPointer(this);
        QFAIL("Invalid state. The viewer is selected but the selected render window has not got the MITK interaction focus.");
      }
    }
    else
    {
      QmitkRenderWindow* selectedRenderWindow = m_Viewer->GetSelectedRenderWindow();
      if (!selectedRenderWindow)
      {
        MITK_INFO << "ERROR: Invalid state. The viewer is selected but there is no selected render window.";
        MITK_INFO << Self::ConstPointer(this);
        QFAIL("Invalid state. The viewer is selected but there is no selected render window.");
      }
      if (m_Viewer->GetAxialWindow()->hasFocus()
          || m_Viewer->GetSagittalWindow()->hasFocus()
          || m_Viewer->GetCoronalWindow()->hasFocus()
          || m_Viewer->Get3DWindow()->hasFocus()
          || m_Viewer->hasFocus())
      {
        MITK_INFO << "ERROR: Invalid state. The viewer has the Qt focus, although it is not selected.";
        MITK_INFO << Self::ConstPointer(this);
        QFAIL("Invalid state. The viewer has the Qt focus, although it is not selected.");
      }
      mitk::BaseRenderer* focusedRenderer = mitk::GlobalInteraction::GetInstance()->GetFocus();
      if (focusedRenderer == m_Viewer->GetAxialWindow()->GetRenderer()
          || focusedRenderer == m_Viewer->GetSagittalWindow()->GetRenderer()
          || focusedRenderer == m_Viewer->GetCoronalWindow()->GetRenderer()
          || focusedRenderer == m_Viewer->Get3DWindow()->GetRenderer())
      {
        MITK_INFO << "ERROR: Invalid state. The viewer has the MITK interaction focus, although it is not selected.";
        MITK_INFO << Self::ConstPointer(this);
        QFAIL("Invalid state. The viewer has the MITK interaction focus, although it is not selected.");
      }
    }


    int axialSliceIndex = m_Viewer->GetSelectedSlice(WINDOW_ORIENTATION_AXIAL);
    int sagittalSliceIndex = m_Viewer->GetSelectedSlice(WINDOW_ORIENTATION_SAGITTAL);
    int coronalSliceIndex = m_Viewer->GetSelectedSlice(WINDOW_ORIENTATION_CORONAL);

    int axialMaxSliceIndex = m_Viewer->GetMaxSlice(WINDOW_ORIENTATION_AXIAL);
    int sagittalMaxSliceIndex = m_Viewer->GetMaxSlice(WINDOW_ORIENTATION_SAGITTAL);
    int coronalMaxSliceIndex = m_Viewer->GetMaxSlice(WINDOW_ORIENTATION_CORONAL);

    mitk::SliceNavigationController* axialSnc = m_Viewer->GetAxialWindow()->GetSliceNavigationController();
    mitk::SliceNavigationController* sagittalSnc = m_Viewer->GetSagittalWindow()->GetSliceNavigationController();
    mitk::SliceNavigationController* coronalSnc = m_Viewer->GetCoronalWindow()->GetSliceNavigationController();

    QVERIFY(axialMaxSliceIndex == axialSnc->GetSlice()->GetSteps() - 1);
    QVERIFY(sagittalMaxSliceIndex == sagittalSnc->GetSlice()->GetSteps() - 1);
    QVERIFY(coronalMaxSliceIndex == coronalSnc->GetSlice()->GetSteps() - 1);

    int axialSncPos = axialSnc->GetSlice()->GetPos();
    int sagittalSncPos = sagittalSnc->GetSlice()->GetPos();
    int coronalSncPos = coronalSnc->GetSlice()->GetPos();

    int expectedAxialSliceIndex = m_UpDirections[2] > 0 ? axialSncPos : axialMaxSliceIndex - axialSncPos;
    int expectedSagittalSliceIndex = m_UpDirections[0] > 0 ? sagittalSncPos : sagittalMaxSliceIndex - sagittalSncPos;
    int expectedCoronalSliceIndex = m_UpDirections[1] > 0 ? coronalSncPos : coronalMaxSliceIndex - coronalSncPos;

    if (axialSliceIndex != expectedAxialSliceIndex
        || sagittalSliceIndex != expectedSagittalSliceIndex
        || coronalSliceIndex != expectedCoronalSliceIndex)
    {
//      MITK_INFO << "ERROR: Invalid state. The selected slice indices do not match in the viewer and in the SNCs.";
//      MITK_INFO << "Axial slice index: " << axialSliceIndex << " ; SNC position: " << axialSncPos
//                << " ; max index: " << axialMaxSliceIndex << " ; flipped: " << m_UpDirections[2];
//      MITK_INFO << "Sagittal slice index: " << sagittalSliceIndex << " ; SNC position: " << sagittalSncPos
//                << " ; max index: " << sagittalMaxSliceIndex << " ; flipped: " << m_UpDirections[0];
//      MITK_INFO << "Coronal slice index: " << coronalSliceIndex << " ; SNC position: " << coronalSncPos
//                << " ; max index: " << coronalMaxSliceIndex << " ; flipped: " << m_UpDirections[1];
//      MITK_INFO << Self::ConstPointer(this);
//      QFAIL("Invalid state. The selected slice indices do not match in the viewer and in the SNCs.");
    }
  }

protected:

  SingleViewerWidgetState(const SingleViewerWidget* viewer)
  : itk::Object()
  , m_Viewer(viewer)
  , m_TimeGeometry(viewer->GetTimeGeometry())
  , m_Orientation(viewer->GetOrientation())
  , m_WindowLayout(viewer->GetWindowLayout())
  , m_SelectedRenderWindow(viewer->GetSelectedRenderWindow())
  , m_TimeStep(viewer->GetTimeStep())
  , m_SelectedPosition(viewer->GetSelectedPosition())
  , m_CursorPositions(viewer->GetCursorPositions())
  , m_ScaleFactors(viewer->GetScaleFactors())
  , m_CursorPositionBinding(viewer->GetCursorPositionBinding())
  , m_ScaleFactorBinding(viewer->GetScaleFactorBinding())
  {
    m_UpDirections[0] = m_Viewer->GetSliceUpDirection(WINDOW_ORIENTATION_SAGITTAL);
    m_UpDirections[1] = m_Viewer->GetSliceUpDirection(WINDOW_ORIENTATION_CORONAL);
    m_UpDirections[2] = m_Viewer->GetSliceUpDirection(WINDOW_ORIENTATION_AXIAL);
  }

  SingleViewerWidgetState(Self::Pointer otherState)
  : itk::Object()
  , m_Viewer(otherState->m_Viewer)
  , m_TimeGeometry(otherState->GetTimeGeometry())
  , m_Orientation(otherState->GetOrientation())
  , m_WindowLayout(otherState->GetWindowLayout())
  , m_SelectedRenderWindow(otherState->GetSelectedRenderWindow())
  , m_TimeStep(otherState->GetTimeStep())
  , m_SelectedPosition(otherState->GetSelectedPosition())
  , m_CursorPositions(otherState->GetCursorPositions())
  , m_ScaleFactors(otherState->GetScaleFactors())
  , m_CursorPositionBinding(otherState->GetCursorPositionBinding())
  , m_ScaleFactorBinding(otherState->GetScaleFactorBinding())
  , m_UpDirections(otherState->m_UpDirections)
  {
  }

  virtual ~SingleViewerWidgetState()
  {
  }

  virtual void PrintSelf(std::ostream & os, itk::Indent indent) const override
  {
//    os << indent << "time geometry: " << m_TimeGeometry << std::endl;
    os << indent << "orientation: " << m_Orientation << std::endl;
    os << indent << "window layout: " << m_WindowLayout << std::endl;
    if (m_SelectedRenderWindow)
    {
      os << indent << "selected render window: " << m_SelectedRenderWindow << ", " << m_SelectedRenderWindow->GetRenderer()->GetName() << std::endl;
    }
    else
    {
      os << indent << "selected render window: none" << std::endl;
    }
    os << indent << "time step: " << m_TimeStep << std::endl;
    os << indent << "selected position: " << m_SelectedPosition << std::endl;
    os << indent << "cursor positions: " << m_CursorPositions[0] << ", " << m_CursorPositions[1] << ", " << m_CursorPositions[2] << std::endl;
    os << indent << "scale factors: " << m_ScaleFactors[0] << ", " << m_ScaleFactors[1] << ", " << m_ScaleFactors[2] << std::endl;
    os << indent << "cursor position binding: " << m_CursorPositionBinding << std::endl;
    os << indent << "scale factor binding: " << m_ScaleFactorBinding << std::endl;
  }

private:

  const SingleViewerWidget* m_Viewer;

  const mitk::TimeGeometry* m_TimeGeometry;

  WindowOrientation m_Orientation;

  WindowLayout m_WindowLayout;

  QmitkRenderWindow* m_SelectedRenderWindow;

  unsigned m_TimeStep;

  mitk::Point3D m_SelectedPosition;

  std::vector<mitk::Vector2D> m_CursorPositions;

  std::vector<double> m_ScaleFactors;

  bool m_CursorPositionBinding;

  bool m_ScaleFactorBinding;

  mitk::Vector3D m_UpDirections;
};

}

#endif