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;

    Message1<std::string> ToolErrorMessage;
    Message1<std::string> GeneralToolMessage;

    mitkClassMacroItkParent(ToolManager, itk::Object);
    mitkNewMacro1Param(ToolManager, DataStorage *);

    const ToolVectorTypeConst GetTools();

    int GetToolID(const Tool *tool);

    /*
      \param id The tool of interest.
      Counting starts with 0.
    */
    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();

    /*
      \brief Set a list of data/images as reference objects.
    */
    void SetReferenceData(DataVectorType);

    /*
      \brief Set single data item/image as reference object.
    */
    void SetReferenceData(DataNode *);

    /*
      \brief Set a list of data/images as working objects.
    */
    void SetWorkingData(DataVectorType);

    /*
      \brief Set single data item/image as working object.
    */
    void SetWorkingData(DataNode *);

    /*
      \brief Set a list of data/images as roi objects.
    */
    void SetRoiData(DataVectorType);

    /*
      \brief Set a single data item/image as roi object.
    */
    void SetRoiData(DataNode *);

    /*
      \brief Get the list of reference data.
    */
    DataVectorType GetReferenceData();

    /*
      \brief Get the current reference data.
      \warning If there is a list of items, this method will only return the first list item.
    */
    DataNode *GetReferenceData(int);

    /*
      \brief Get the list of working data.
    */
    DataVectorType GetWorkingData();

    /*
      \brief Get the current working data.
      \warning If there is a list of items, this method will only return the first list item.
    */
    DataNode *GetWorkingData(unsigned int);

    /*
     \brief Get the current roi data
     */
    DataVectorType GetRoiData();

    /*
     \brief Get the roi data at position idx
     */
    DataNode *GetRoiData(int idx);

    DataStorage *GetDataStorage();
    void SetDataStorage(DataStorage &storage);

    /*
      \brief Tell that someone is using tools.
      GUI elements should call this when they become active. This method increases an internal "client count".
     */
    void RegisterClient();

    /*
      \brief Tell that someone is NOT using tools.
      GUI elements should call this when they become active. This method increases an internal "client count".
     */
    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);

    /*
     \brief Connected to tool's messages

     This method just resends error messages coming from any of the tools. This way clients (GUIs) only have to observe
     one message.
     */
    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);
  };

} // namespace

#endif