niftkSingleViewerWidgetTest.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 niftkSingleViewerWidgetTest_h
#define niftkSingleViewerWidgetTest_h

#include <QObject>

#include <niftkAtomicStateTransitionTester.cxx>

#include <niftkSingleViewerWidgetState.h>

#include <vector>

namespace mitk
{
class DataNode;
}

class QmitkRenderWindow;


namespace niftk
{
class SingleViewerWidget;
class SingleViewerWidgetTestClassPrivate;


class SingleViewerWidgetTestClass: public QObject
{
  Q_OBJECT

public:

  enum WorldAxes { SagittalAxis, CoronalAxis, AxialAxis };

  typedef AtomicStateTransitionTester<const SingleViewerWidget*, SingleViewerWidgetState> ViewerStateTester;
  typedef SingleViewerWidgetState ViewerState;
  typedef SingleViewerWidgetTestClass Self;

  explicit SingleViewerWidgetTestClass();

  virtual ~SingleViewerWidgetTestClass();

  std::string GetFileName() const;

  void SetFileName(const std::string& fileName);

  bool GetInteractiveMode() const;

  void SetInteractiveMode(bool interactiveMode);

  static mitk::Point3D GetWorldOrigin(const mitk::BaseGeometry* geometry);

  static mitk::Vector3D GetWorldUpDirections(const mitk::BaseGeometry* geometry);

  static std::vector<int> GetWorldAxes(const mitk::Geometry3D* geometry);

  static mitk::Point3D GetWorldBottomLeftBackCorner(const mitk::BaseGeometry* geometry);

  static QPoint GetPointAtCursorPosition(QmitkRenderWindow *renderWindow, const mitk::Vector2D& cursorPosition);

  static mitk::Vector2D GetDisplayPositionAtPoint(QmitkRenderWindow *renderWindow, const QPoint& point);

  mitk::Point3D GetWorldPositionAtDisplayPosition(int orientation, const mitk::Vector2D& displayPosition);

  mitk::Vector2D GetDisplayPositionAtWorldPosition(int orientation, const mitk::Point3D& worldPosition);

  mitk::Vector2D GetCentrePosition(int windowIndex);

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

  double GetVoxelCentreCoordinate(int axis, double coordinate);

  mitk::Point3D GetVoxelCentrePosition(const mitk::Point3D& position);

  bool Equals(const mitk::Point3D& selectedPosition1, const mitk::Point3D& selectedPosition2, double tolerance = -1.0);

  static bool Equals(const mitk::Vector2D& cursorPosition1, const mitk::Vector2D& cursorPosition2, double tolerance = 0.01);

  bool Equals(const std::vector<mitk::Vector2D>& cursorPositions1, const std::vector<mitk::Vector2D>& cursorPositions2, double tolerance = 0.01);

  mitk::Point3D GetRandomWorldPosition() const;

  static mitk::Vector2D GetRandomDisplayPosition();

  static std::vector<mitk::Vector2D> GetRandomDisplayPositions(std::size_t size = std::size_t(3));

  static double GetRandomScaleFactor();

  static std::vector<double> GetRandomScaleFactors(std::size_t size = std::size_t(3));

  void SetRandomPositions();

private slots:

  void initTestCase();

  void cleanupTestCase();

  void init();

  void cleanup();

  void testViewer();

  void testSetSelectedSlice2();

  void testGetTimeGeometry();

  void testSetTimeGeometry();

  void testGetOrientation();

  void testGetSelectedPosition();

  void testSetSelectedPosition();

  void testGetSelectedSlice();

  void testSetSelectedSlice();

  void testGetCursorPosition();

  void testSetCursorPosition();

  void testGetCursorPositions();

  void testSetCursorPositions();

  void testGetWindowLayout();

  void testGetSelectedRenderWindow();

  void testSetSelectedRenderWindow();

  void testSetWindowLayout();

  void testRememberPositionsPerWindowLayout();

  void testSelectPositionByInteraction();

  void testChangeSliceByMouseInteraction();

  void testChangeSliceByKeyInteraction();

  void testSelectRenderWindowByInteraction();

  void testSelectSliceThroughSliceNavigationController();

  void testSelectPositionThroughSliceNavigationController();

  void testCursorPositionBinding();

  void testScaleFactorBinding();

  void testCursorPositionAndScaleFactorBinding();

private:

  void DropNodes(QmitkRenderWindow* renderWindow, const std::vector<mitk::DataNode*>& nodes);

  static void MouseWheel(QWidget* window, Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
                         QPoint point, int delta, Qt::Orientation orientation = Qt::Vertical);

  QScopedPointer<SingleViewerWidgetTestClassPrivate> d_ptr;

  Q_DECLARE_PRIVATE(SingleViewerWidgetTestClass)
  Q_DISABLE_COPY(SingleViewerWidgetTestClass)
};

}

int niftkSingleViewerWidgetTest(int argc, char* argv[]);

#endif