mitkDataStorage.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 mitkDataStorage_h
#define mitkDataStorage_h
 
#include <itkObject.h>
#include <itkVectorContainer.h>
#include <mitkDataNode.h>
#include <mitkGeometry3D.h>
#include <mitkMessage.h>
#include <MitkCoreExports.h>
#include <map>
#include <mutex>
 
namespace mitk
{
  class NodePredicateBase;
  class DataNode;
  class BaseRenderer;
 
  class MITKCORE_EXPORT DataStorage : public itk::Object
  {
  public:
    mitkClassMacroItkParent(DataStorage, itk::Object);
 
    typedef itk::VectorContainer<unsigned int, DataNode::Pointer> SetOfObjects;
 
    typedef itk::VectorContainer<unsigned int, DataNode::ConstPointer> ConstSetOfObjects;
 
    virtual void Add(DataNode *node, const DataStorage::SetOfObjects *parents = nullptr) = 0;
 
    void Add(DataNode *node, DataNode *parent);
 
    void Add(DataNode *node, const ConstSetOfObjects *parents);
 
    virtual void Remove(const DataNode *node) = 0;
 
    virtual bool Exists(const DataNode *node) const = 0;
 
    void Remove(const DataStorage::SetOfObjects *nodes);
 
    void Remove(const ConstSetOfObjects *nodes);
 
    SetOfObjects::ConstPointer GetSubset(const NodePredicateBase *condition) const;
 
    virtual SetOfObjects::ConstPointer GetSources(const DataNode *node,
                                                  const NodePredicateBase *condition = nullptr,
                                                  bool onlyDirectSources = true) const = 0;
 
    virtual SetOfObjects::ConstPointer GetDerivations(const DataNode *node,
                                                      const NodePredicateBase *condition = nullptr,
                                                      bool onlyDirectDerivations = true) const = 0;
 
    virtual SetOfObjects::ConstPointer GetAll() const = 0;
 
    DataNode *GetNode(const NodePredicateBase *condition = nullptr) const;
 
    DataNode *GetNamedNode(const char *name) const;
 
    DataNode *GetNamedNode(const std::string& name) const { return this->GetNamedNode(name.c_str()); }
 
    DataNode *GetNamedDerivedNode(const char *name,
                                  const DataNode *sourceNode,
                                  bool onlyDirectDerivations = true) const;
 
    template <class DataType>
    DataType *GetNamedObject(const char *name) const
    {
      if (name == nullptr)
        return nullptr;
      DataNode *n = this->GetNamedNode(name);
      if (n == nullptr)
        return nullptr;
      else
        return dynamic_cast<DataType *>(n->GetData());
    }
 
    template <class DataType>
    DataType *GetNamedObject(const std::string& name) const
    {
      return this->GetNamedObject<DataType>(name.c_str());
    }
 
    template <class DataType>
    DataType *GetNamedDerivedObject(const char *name,
                                    const DataNode *sourceNode,
                                    bool onlyDirectDerivations = true) const
    {
      if (name == nullptr)
        return nullptr;
      DataNode *n = this->GetNamedDerivedNode(name, sourceNode, onlyDirectDerivations);
      if (n == nullptr)
        return nullptr;
      else
        return dynamic_cast<DataType *>(n->GetData());
    }
 
    std::string GetUniqueName(const std::string& name, const DataNode* sourceNode = nullptr, bool onlyDirectDerivations = true) const;
 
    const DataNode::GroupTagList GetGroupTags() const;
 
    mutable std::mutex m_MutexOne;
 
    typedef Message1<const DataNode*> DataStorageEvent;
 
    DataStorageEvent AddNodeEvent;
 
    DataStorageEvent RemoveNodeEvent;
 
    DataStorageEvent ChangedNodeEvent;
 
    DataStorageEvent DeleteNodeEvent;
 
    DataStorageEvent InteractorChangedNodeEvent;
 
    TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const SetOfObjects *input,
                                                         const char *boolPropertyKey = nullptr,
                                                         const BaseRenderer *renderer = nullptr,
                                                         const char *boolPropertyKey2 = nullptr) const;
 
    TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const ConstSetOfObjects *input,
                                                         const char *boolPropertyKey = nullptr,
                                                         const BaseRenderer *renderer = nullptr,
                                                         const char *boolPropertyKey2 = nullptr) const;
 
    TimeGeometry::ConstPointer ComputeBoundingGeometry3D(const char *boolPropertyKey = nullptr,
                                                         const BaseRenderer *renderer = nullptr,
                                                         const char *boolPropertyKey2 = nullptr) const;
 
    TimeGeometry::ConstPointer ComputeVisibleBoundingGeometry3D(const BaseRenderer *renderer = nullptr,
                                                                const char *boolPropertyKey = nullptr);
 
    BoundingBox::Pointer ComputeBoundingBox(const char *boolPropertyKey = nullptr,
                                            const BaseRenderer *renderer = nullptr,
                                            const char *boolPropertyKey2 = nullptr);
 
    BoundingBox::Pointer ComputeVisibleBoundingBox(const BaseRenderer *renderer = nullptr,
                                                   const char *boolPropertyKey = nullptr)
    {
      return ComputeBoundingBox("visible", renderer, boolPropertyKey);
    }
 
    TimeBounds ComputeTimeBounds(const char *boolPropertyKey,
                                 const BaseRenderer *renderer,
                                 const char *boolPropertyKey2);
 
    TimeBounds ComputeTimeBounds(const BaseRenderer *renderer, const char *boolPropertyKey)
    {
      return ComputeTimeBounds("visible", renderer, boolPropertyKey);
    }
 
    void BlockNodeModifiedEvents(bool block);
 
  protected:
    //##Documentation
    //## @brief  EmitAddNodeEvent emits the AddNodeEvent
    //##
    //## This method should be called by subclasses to emit the AddNodeEvent
    void EmitAddNodeEvent(const DataNode *node);
 
    //##Documentation
    //## @brief  EmitRemoveNodeEvent emits the RemoveNodeEvent
    //##
    //## This method should be called by subclasses to emit the RemoveNodeEvent
    void EmitRemoveNodeEvent(const DataNode *node);
 
    void OnNodeInteractorChanged(itk::Object *caller, const itk::EventObject &event);
 
    //##Documentation
    //## @brief  OnNodeModified listens to modified events of DataNodes.
    //##
    //## The node is hidden behind the caller parameter, which has to be casted first.
    //## If the cast succeeds the ChangedNodeEvent is emitted with this node.
    void OnNodeModifiedOrDeleted(const itk::Object *caller, const itk::EventObject &event);
 
    //##Documentation
    //## @brief  Adds a Modified-Listener to the given Node.
    void AddListeners(const DataNode *_Node);
 
    //##Documentation
    //## @brief  Removes a Modified-Listener from the given Node.
    void RemoveListeners(const DataNode *_Node);
 
    //##Documentation
    //## @brief  Saves Modified-Observer Tags for each node in order to remove the event listeners again.
    std::map<const DataNode *, unsigned long> m_NodeModifiedObserverTags;
 
    std::map<const DataNode *, unsigned long> m_NodeInteractorChangedObserverTags;
 
    //##Documentation
    //## @brief  Saves Delete-Observer Tags for each node in order to remove the event listeners again.
    std::map<const DataNode *, unsigned long> m_NodeDeleteObserverTags;
 
    //##Documentation
    //## @brief If this class changes nodes itself, set this to TRUE in order
    //## to suppress NodeChangedEvent to be emitted.
    bool m_BlockNodeModifiedEvents;
 
    DataStorage();
    ~DataStorage() override;
 
    //##Documentation
    //## @brief Filters a SetOfObjects by the condition. If no condition is provided, the original set is returned
    SetOfObjects::ConstPointer FilterSetOfObjects(const SetOfObjects *set, const NodePredicateBase *condition) const;
 
    //##Documentation
    //## @brief Prints the contents of the DataStorage to os. Do not call directly, call ->Print() instead
    void PrintSelf(std::ostream &os, itk::Indent indent) const override;
  };
 
  MITKCORE_EXPORT DataNode::Pointer FindTopmostVisibleNode(const DataStorage::SetOfObjects::ConstPointer nodes,
                                                           const Point3D worldPosition,
                                                           const TimePointType timePoint,
                                                           const BaseRenderer* baseRender);
} // namespace mitk
 
#endif