mitkToolManager.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 mitkToolManager_h
#define mitkToolManager_h
 
#include "mitkDataNode.h"
#include "mitkDataStorage.h"
#include "mitkTool.h"
#include "mitkWeakPointer.h"
#include <MitkSegmentationExports.h>
 
#pragma GCC visibility push(default)
#include <itkEventObject.h>
#pragma GCC visibility pop
 
#include <vector>
 
namespace mitk
{
  class Image;
  class PlaneGeometry;
 
  class MITKSEGMENTATION_EXPORT ToolManager : public itk::Object
  {
  public:
    typedef std::vector<Tool::Pointer> ToolVectorType;
    typedef std::vector<Tool::ConstPointer> ToolVectorTypeConst;
    typedef std::vector<DataNode *> DataVectorType; // has to be observed for delete events!
    typedef std::map<DataNode *, unsigned long> NodeTagMapType;
 
    Message<> NodePropertiesChanged;
    Message<> NewNodesGenerated;
    Message1<DataVectorType *> NewNodeObjectsGenerated;
 
    Message<> ActiveToolChanged;
    Message<> ReferenceDataChanged;
    Message<> WorkingDataChanged;
    Message<> RoiDataChanged;
    Message<> SelectedTimePointChanged;
 
    Message1<std::string> ToolErrorMessage;
    Message1<std::string> GeneralToolMessage;
 
    mitkClassMacroItkParent(ToolManager, itk::Object);
    mitkNewMacro1Param(ToolManager, DataStorage *);
 
    const ToolVectorTypeConst GetTools();
 
    int GetToolID(const Tool *tool);
 
    Tool *GetToolById(int id);
 
    bool ActivateTool(int id);
 
    template <class T>
    int GetToolIdByToolType()
    {
      int id = 0;
      for (auto iter = m_Tools.begin(); iter != m_Tools.end(); ++iter, ++id)
      {
        if (dynamic_cast<T *>(iter->GetPointer()))
        {
          return id;
        }
      }
      return -1;
    }
 
    int GetActiveToolID();
 
    Tool *GetActiveTool();
 
    void SetReferenceData(DataVectorType);
 
    void SetReferenceData(DataNode *);
 
    void SetWorkingData(DataVectorType);
 
    void SetWorkingData(DataNode *);
 
    void SetRoiData(DataVectorType);
 
    void SetRoiData(DataNode *);
 
    DataVectorType GetReferenceData();
 
    DataNode *GetReferenceData(int);
 
    DataVectorType GetWorkingData();
 
    DataNode *GetWorkingData(unsigned int);
 
    DataVectorType GetRoiData();
 
    DataNode *GetRoiData(int idx);
 
    DataStorage::Pointer GetDataStorage() const;
    void SetDataStorage(DataStorage &storage);
 
    TimePointType GetCurrentTimePoint() const;
 
    void RegisterClient();
 
    void UnregisterClient();
 
    void InitializeTools();
 
    void OnOneOfTheReferenceDataDeletedConst(const itk::Object *caller, const itk::EventObject &e);
    void OnOneOfTheReferenceDataDeleted(itk::Object *caller, const itk::EventObject &e);
 
    void OnOneOfTheWorkingDataDeletedConst(const itk::Object *caller, const itk::EventObject &e);
    void OnOneOfTheWorkingDataDeleted(itk::Object *caller, const itk::EventObject &e);
 
    void OnOneOfTheRoiDataDeletedConst(const itk::Object *caller, const itk::EventObject &e);
    void OnOneOfTheRoiDataDeleted(itk::Object *caller, const itk::EventObject &e);
 
    void OnToolErrorMessage(std::string s);
    void OnGeneralToolMessage(std::string s);
 
  protected:
    ToolManager(DataStorage *storage); // purposely hidden
    ~ToolManager() override;
 
    ToolVectorType m_Tools;
 
    Tool *m_ActiveTool;
    int m_ActiveToolID;
    us::ServiceRegistration<InteractionEventObserver> m_ActiveToolRegistration;
 
    DataVectorType m_ReferenceData;
    NodeTagMapType m_ReferenceDataObserverTags;
 
    DataVectorType m_WorkingData;
    NodeTagMapType m_WorkingDataObserverTags;
 
    DataVectorType m_RoiData;
    NodeTagMapType m_RoiDataObserverTags;
 
    int m_RegisteredClients;
 
    WeakPointer<DataStorage> m_DataStorage;
 
    void OnNodeRemoved(const mitk::DataNode *node);
 
    void OnTimeChangedConst(const itk::Object* caller, const itk::EventObject& e);
    void OnTimeChanged(itk::Object* caller, const itk::EventObject& e);
 
    void EnsureTimeObservation();
    void StopTimeObservation();
 
  private:
    TimePointType m_LastTimePoint = 0;
    unsigned long m_TimePointObserverTag = 0;
    WeakPointer<SliceNavigationController> m_CurrentTimeNavigationController;
  };
 
} // namespace
 
#endif