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_Included
#define mitkToolManager_h_Included

#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 *GetDataStorage();
    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