mitkSliceNavigationController.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 mitkSliceNavigationController_h
#define mitkSliceNavigationController_h
 
#include <MitkCoreExports.h>
 
#include <mitkBaseController.h>
#include <mitkMessage.h>
#include <mitkAnatomicalPlanes.h>
#include <mitkRenderingManager.h>
#include <mitkRestorePlanePositionOperation.h>
#include <mitkTimeGeometry.h>
 
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
 
#include <itkCommand.h>
 
namespace mitk
{
#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);
    itkNewMacro(Self);
 
    void SetInputWorldTimeGeometry(const TimeGeometry* geometry);
    itkGetConstObjectMacro(InputWorldTimeGeometry, TimeGeometry);
 
    itkGetConstObjectMacro(CreatedWorldGeometry, TimeGeometry);
    itkGetObjectMacro(CreatedWorldGeometry, TimeGeometry);
 
    itkSetEnumMacro(ViewDirection, AnatomicalPlane);
    itkGetEnumMacro(ViewDirection, AnatomicalPlane);
 
    itkSetEnumMacro(DefaultViewDirection, AnatomicalPlane);
    itkGetEnumMacro(DefaultViewDirection, AnatomicalPlane);
 
    const char *GetViewDirectionAsString() const;
 
    virtual void SetViewDirectionToDefault();
 
    virtual void Update();
 
    virtual void Update(AnatomicalPlane viewDirection, bool top = true, bool frontside = true, bool rotated = false);
 
    virtual void SendCreatedWorldGeometry();
 
    virtual void SendCreatedWorldGeometryUpdate();
 
    virtual void SendSlice();
 
    virtual void SendTime();
 
    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) {}
      ~TimeGeometryEvent() override {}
      const char* GetEventName() const override { return "TimeGeometryEvent"; }
      bool CheckEvent(const ::itk::EventObject* e) const override { return dynamic_cast<const Self*>(e); }
      ::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
    };
 
 
    mitkTimeGeometryEventMacro(GeometrySendEvent, TimeGeometryEvent);
    mitkTimeGeometryEventMacro(GeometryUpdateEvent, TimeGeometryEvent);
    mitkTimeGeometryEventMacro(GeometryTimeEvent, TimeGeometryEvent);
    mitkTimeGeometryEventMacro(GeometrySliceEvent, TimeGeometryEvent);
 
    template <typename T>
    void ConnectGeometrySendEvent(T* receiver)
    {
      auto 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)
    {
      auto 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)
    {
      auto 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);
    }
 
    template <typename T>
    void ConnectGeometryTimeEvent(T* receiver)
    {
      auto 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);
    }
 
    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);
    }
 
    Message1<const Point3D&> SetCrosshairEvent;
 
    virtual void SetGeometry(const itk::EventObject& geometrySliceEvent);
 
    virtual void SetGeometrySlice(const itk::EventObject& geometrySliceEvent);
 
    virtual void SetGeometryTime(const itk::EventObject& geometryTimeEvent);
 
    void SelectSliceByPoint(const Point3D& point);
 
    const BaseGeometry* GetCurrentGeometry3D();
 
    const PlaneGeometry* GetCurrentPlaneGeometry();
 
    itkSetObjectMacro(Renderer, BaseRenderer);
    itkGetMacro(Renderer, BaseRenderer*);
 
    void ReorientSlices(const Point3D& point, const Vector3D& normal);
 
    void ReorientSlices(const Point3D& point, const Vector3D& axisVec0, const 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();
 
    TimeStepType GetSelectedTimeStep() const;
 
    TimePointType GetSelectedTimePoint() const;
 
  protected:
 
    SliceNavigationController();
    ~SliceNavigationController() override;
 
    void CreateWorldGeometry(bool top, bool frontside, bool rotated);
 
    TimeGeometry::ConstPointer m_InputWorldTimeGeometry;
    TimeGeometry::Pointer m_CreatedWorldGeometry;
 
    AnatomicalPlane m_ViewDirection;
    AnatomicalPlane m_DefaultViewDirection;
 
    RenderingManager::Pointer m_RenderingManager;
 
    BaseRenderer* m_Renderer;
 
    bool m_BlockUpdate;
 
    bool m_SliceLocked;
    bool m_SliceRotationLocked;
 
    typedef std::map<void*, std::list<unsigned long>> ObserverTagsMapType;
    ObserverTagsMapType m_ReceiverToObserverTagsMap;
  };
 
} // namespace mitk
 
#endif