mitkSliceNavigationController.h

Go to the documentation of this file.

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

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
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 or http://www.mitk.org for details.

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

#ifndef SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F
#define SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F

#include "mitkBaseController.h"
#include "mitkMessage.h"
#include "mitkRenderingManager.h"
#include "mitkTimeGeometry.h"
#include <MitkCoreExports.h>
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
#include "mitkDataStorage.h"
#include "mitkRestorePlanePositionOperation.h"
#include <itkCommand.h>
#include <sstream>
// DEPRECATED
#include <mitkTimeSlicedGeometry.h>

namespace mitk
{
#define mitkTimeSlicedGeometryEventMacro(classname, super)                                                             \
  class MITKCORE_EXPORT DEPRECATED(classname) : public super                                                           \
  {                                                                                                                    \
  public:                                                                                                              \
    typedef classname Self;                                                                                            \
    typedef super Superclass;                                                                                          \
    classname(TimeGeometry *aTimeGeometry, unsigned int aPos) : Superclass(aTimeGeometry, aPos) {}                     \
    virtual ~classname() {}                                                                                            \
    virtual const char *GetEventName() const { return #classname; }                                                    \
    virtual bool CheckEvent(const ::itk::EventObject *e) const { return dynamic_cast<const Self *>(e); }               \
    virtual ::itk::EventObject *MakeObject() const { return new Self(GetTimeGeometry(), GetPos()); }                   \
  private:                                                                                                             \
    void operator=(const Self &);                                                                                      \
  }

#define mitkTimeGeometryEventMacro(classname, super)                                                                   \
  class MITKCORE_EXPORT classname : public super                                                                       \
  {                                                                                                                    \
  public:                                                                                                              \
    typedef classname Self;                                                                                            \
    typedef super Superclass;                                                                                          \
    classname(TimeGeometry *aTimeGeometry, unsigned int aPos) : Superclass(aTimeGeometry, aPos) {}                     \
    virtual ~classname() {}                                                                                            \
    virtual const char *GetEventName() const { return #classname; }                                                    \
    virtual bool CheckEvent(const ::itk::EventObject *e) const { return dynamic_cast<const Self *>(e); }               \
    virtual ::itk::EventObject *MakeObject() const { return new Self(GetTimeGeometry(), GetPos()); }                   \
  private:                                                                                                             \
    void operator=(const Self &);                                                                                      \
  }

  class PlaneGeometry;
  class BaseGeometry;
  class BaseRenderer;

  class MITKCORE_EXPORT SliceNavigationController : public BaseController
  {
  public:
    mitkClassMacro(SliceNavigationController, BaseController);
    // itkFactorylessNewMacro(Self)
    // mitkNewMacro1Param(Self, const char *);
    itkNewMacro(Self);
    // itkCloneMacro(Self)

    enum ViewDirection
    {
      Axial,
      Sagittal,
      Frontal,
      Original
    };

    void SetInputWorldGeometry3D(const mitk::BaseGeometry *geometry);
    itkGetConstObjectMacro(InputWorldGeometry3D, mitk::BaseGeometry);

    DEPRECATED(void SetInputWorldGeometry(const mitk::TimeSlicedGeometry *geometry));
    DEPRECATED(TimeSlicedGeometry *GetInputWorldGeometry());

    void SetInputWorldTimeGeometry(const mitk::TimeGeometry *geometry);
    itkGetConstObjectMacro(InputWorldTimeGeometry, mitk::TimeGeometry);

    itkGetConstObjectMacro(CreatedWorldGeometry, mitk::TimeGeometry);

    itkSetEnumMacro(ViewDirection, ViewDirection);
    itkGetEnumMacro(ViewDirection, ViewDirection);

    itkSetEnumMacro(DefaultViewDirection, ViewDirection);
    itkGetEnumMacro(DefaultViewDirection, ViewDirection);

    const char *GetViewDirectionAsString() const;

    virtual void SetViewDirectionToDefault();

    virtual void Update();

    virtual void Update(ViewDirection viewDirection, bool top = true, bool frontside = true, bool rotated = false);

    virtual void SendCreatedWorldGeometry();

    virtual void SendCreatedWorldGeometryUpdate();

    virtual void SendSlice();

    virtual void SendTime();

    itkSetObjectMacro(RenderingManager, RenderingManager);
    mitk::RenderingManager *GetRenderingManager() const;

#pragma GCC visibility push(default)
    itkEventMacro(UpdateEvent, itk::AnyEvent);
#pragma GCC visibility pop

    class MITKCORE_EXPORT TimeGeometryEvent : public itk::AnyEvent
    {
    public:
      typedef TimeGeometryEvent Self;
      typedef itk::AnyEvent Superclass;

      TimeGeometryEvent(TimeGeometry *aTimeGeometry, unsigned int aPos) : m_TimeGeometry(aTimeGeometry), m_Pos(aPos) {}
      virtual ~TimeGeometryEvent() {}
      virtual const char *GetEventName() const override { return "TimeGeometryEvent"; }
      virtual bool CheckEvent(const ::itk::EventObject *e) const override { return dynamic_cast<const Self *>(e); }
      virtual ::itk::EventObject *MakeObject() const override { return new Self(m_TimeGeometry, m_Pos); }
      TimeGeometry *GetTimeGeometry() const { return m_TimeGeometry; }
      unsigned int GetPos() const { return m_Pos; }
    private:
      TimeGeometry::Pointer m_TimeGeometry;
      unsigned int m_Pos;
      // TimeGeometryEvent(const Self&);
      void operator=(const Self &); // just hide
    };

    DEPRECATED(typedef TimeGeometryEvent TimeSlicedGeometryEvent);

    mitkTimeGeometryEventMacro(GeometrySendEvent, TimeGeometryEvent);
    mitkTimeGeometryEventMacro(GeometryUpdateEvent, TimeGeometryEvent);
    mitkTimeGeometryEventMacro(GeometryTimeEvent, TimeGeometryEvent);
    mitkTimeGeometryEventMacro(GeometrySliceEvent, TimeGeometryEvent);

    template <typename T>
    void ConnectGeometrySendEvent(T *receiver)
    {
      typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
      ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
      eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometry);
      unsigned long tag = AddObserver(GeometrySendEvent(nullptr, 0), eventReceptorCommand);
      m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
    }

    template <typename T>
    void ConnectGeometryUpdateEvent(T *receiver)
    {
      typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
      ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
      eventReceptorCommand->SetCallbackFunction(receiver, &T::UpdateGeometry);
      unsigned long tag = AddObserver(GeometryUpdateEvent(nullptr, 0), eventReceptorCommand);
      m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
    }

    template <typename T>
    void ConnectGeometrySliceEvent(T *receiver, bool connectSendEvent = true)
    {
      typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
      ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
      eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometrySlice);
      unsigned long tag = AddObserver(GeometrySliceEvent(nullptr, 0), eventReceptorCommand);
      m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
      if (connectSendEvent)
        ConnectGeometrySendEvent(receiver);
    }

    template <typename T>
    void ConnectGeometryTimeEvent(T *receiver, bool connectSendEvent = true)
    {
      typedef typename itk::ReceptorMemberCommand<T>::Pointer ReceptorMemberCommandPointer;
      ReceptorMemberCommandPointer eventReceptorCommand = itk::ReceptorMemberCommand<T>::New();
      eventReceptorCommand->SetCallbackFunction(receiver, &T::SetGeometryTime);
      unsigned long tag = AddObserver(GeometryTimeEvent(nullptr, 0), eventReceptorCommand);
      m_ReceiverToObserverTagsMap[static_cast<void *>(receiver)].push_back(tag);
      if (connectSendEvent)
        ConnectGeometrySendEvent(receiver);
    }

    template <typename T>
    void ConnectGeometryEvents(T *receiver)
    {
      // connect sendEvent only once
      ConnectGeometrySliceEvent(receiver, false);
      ConnectGeometryTimeEvent(receiver);
    }

    // use a templated method to get the right offset when casting to void*
    template <typename T>
    void Disconnect(T *receiver)
    {
      auto i = m_ReceiverToObserverTagsMap.find(static_cast<void *>(receiver));
      if (i == m_ReceiverToObserverTagsMap.end())
        return;
      const std::list<unsigned long> &tags = i->second;
      for (auto tagIter = tags.begin(); tagIter != tags.end(); ++tagIter)
      {
        RemoveObserver(*tagIter);
      }
      m_ReceiverToObserverTagsMap.erase(i);
    }

    Message<> crosshairPositionEvent;

    virtual void SetGeometry(const itk::EventObject &geometrySliceEvent);

    virtual void SetGeometrySlice(const itk::EventObject &geometrySliceEvent);

    virtual void SetGeometryTime(const itk::EventObject &geometryTimeEvent);

    void SelectSliceByPoint(const mitk::Point3D &point);

    mitk::TimeGeometry *GetCreatedWorldGeometry();

    const mitk::BaseGeometry *GetCurrentGeometry3D();

    const mitk::PlaneGeometry *GetCurrentPlaneGeometry();

    void SetRenderer(BaseRenderer *renderer);

    BaseRenderer *GetRenderer() const;

    void ReorientSlices(const mitk::Point3D &point, const mitk::Vector3D &normal);

    void ReorientSlices(const mitk::Point3D &point, const mitk::Vector3D &axisVec0, const mitk::Vector3D &axisVec1);

    void ExecuteOperation(Operation *operation) override;

    itkSetMacro(SliceLocked, bool);
    itkGetMacro(SliceLocked, bool);
    itkBooleanMacro(SliceLocked);

    itkSetMacro(SliceRotationLocked, bool);
    itkGetMacro(SliceRotationLocked, bool);
    itkBooleanMacro(SliceRotationLocked);

    void AdjustSliceStepperRange();

  protected:
    SliceNavigationController();
    virtual ~SliceNavigationController();

    mitk::BaseGeometry::ConstPointer m_InputWorldGeometry3D;
    mitk::TimeGeometry::ConstPointer m_InputWorldTimeGeometry;

    mitk::TimeGeometry::Pointer m_CreatedWorldGeometry;

    ViewDirection m_ViewDirection;
    ViewDirection m_DefaultViewDirection;

    mitk::RenderingManager::Pointer m_RenderingManager;

    mitk::BaseRenderer *m_Renderer;

    itkSetMacro(Top, bool);
    itkGetMacro(Top, bool);
    itkBooleanMacro(Top);

    itkSetMacro(FrontSide, bool);
    itkGetMacro(FrontSide, bool);
    itkBooleanMacro(FrontSide);

    itkSetMacro(Rotated, bool);
    itkGetMacro(Rotated, bool);
    itkBooleanMacro(Rotated);

    bool m_Top;
    bool m_FrontSide;
    bool m_Rotated;

    bool m_BlockUpdate;

    bool m_SliceLocked;
    bool m_SliceRotationLocked;
    unsigned int m_OldPos;

    typedef std::map<void *, std::list<unsigned long>> ObserverTagsMapType;
    ObserverTagsMapType m_ReceiverToObserverTagsMap;
  };

} // namespace mitk

#endif /* SLICENAVIGATIONCONTROLLER_H_HEADER_INCLUDED_C1C55A2F */