vtkMRMLSubjectHierarchyNode.h

Go to the documentation of this file.

/*==============================================================================

  Program: 3D Slicer

  Copyright (c) Laboratory for Percutaneous Surgery (PerkLab)
  Queen's University, Kingston, ON, Canada. All Rights Reserved.

  See COPYRIGHT.txt
  or http://www.slicer.org/copyright/copyright.txt for details.

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.

  This file was originally developed by Csaba Pinter, PerkLab, Queen's University
  and was supported through the Applied Cancer Research Unit program of Cancer Care
  Ontario with funds provided by the Ontario Ministry of Health and Long-Term Care

==============================================================================*/

// .NAME vtkMRMLSubjectHierarchyNode
// .SECTION Description
// MRML node to represent subject hierarchy tree
//

#ifndef __vtkMRMLSubjectHierarchyNode_h
#define __vtkMRMLSubjectHierarchyNode_h

// MRML includes
#include <vtkMRMLNode.h>
#include <vtkMRMLSubjectHierarchyConstants.h>

class vtkCallbackCommand;
class vtkMRMLTransformNode;

class VTK_MRML_EXPORT vtkMRMLSubjectHierarchyNode : public vtkMRMLNode
{
public:
  static const vtkIdType INVALID_ITEM_ID;

  // Separator characters for (de)serializing the UID and the attributes map
  static const std::string SUBJECTHIERARCHY_SEPARATOR;
  static const std::string SUBJECTHIERARCHY_NAME_VALUE_SEPARATOR;

  // Attribute name to identify subject hierarchy 2.0 nodes in scene MRML files
  static const std::string SUBJECTHIERARCHY_VERSION_ATTRIBUTE_NAME;

  enum
  {
    SubjectHierarchyItemAddedEvent = 62000,
    SubjectHierarchyItemAboutToBeRemovedEvent,
    SubjectHierarchyItemRemovedEvent,
    SubjectHierarchyItemModifiedEvent,
    SubjectHierarchyItemUIDAddedEvent,
    SubjectHierarchyItemOwnerPluginSearchRequested,
    SubjectHierarchyStartResolveEvent,
    SubjectHierarchyEndResolveEvent
  };

public:
  static vtkMRMLSubjectHierarchyNode *New();
  vtkTypeMacro(vtkMRMLSubjectHierarchyNode,vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent) VTK_OVERRIDE;

  virtual vtkMRMLNode* CreateNodeInstance() VTK_OVERRIDE;

  virtual void ReadItemFromXML(const char** atts);
  virtual void WriteXML(ostream& of, int indent) VTK_OVERRIDE;
  virtual void WriteNodeBodyXML(ostream& of, int indent) VTK_OVERRIDE;

  virtual void Copy(vtkMRMLNode *node) VTK_OVERRIDE;

  virtual const char* GetNodeTagName() VTK_OVERRIDE;

// Get/Set methods
public:
  static vtkMRMLSubjectHierarchyNode* GetSubjectHierarchyNode(vtkMRMLScene* scene);

  vtkIdType GetSceneItemID();
  vtkMRMLNode* GetItemDataNode(vtkIdType itemID);
  void SetItemName(vtkIdType itemID, std::string name);
  std::string GetItemName(vtkIdType itemID);
  void SetItemLevel(vtkIdType itemID, std::string level);
  std::string GetItemLevel(vtkIdType itemID);
  void SetItemOwnerPluginName(vtkIdType itemID, std::string ownerPluginName);
  std::string GetItemOwnerPluginName(vtkIdType itemID);
  void SetItemExpanded(vtkIdType itemID, bool expanded);
  bool GetItemExpanded(vtkIdType itemID);

  void SetItemUID(vtkIdType itemID, std::string uidName, std::string uidValue);
  std::string GetItemUID(vtkIdType itemID, std::string uidName);

  void SetItemAttribute(vtkIdType itemID, std::string attributeName, std::string attributeValue);
  bool RemoveItemAttribute(vtkIdType itemID, std::string attributeName);
  std::string GetItemAttribute(vtkIdType itemID, std::string attributeName);
  std::vector<std::string> GetItemAttributeNames(vtkIdType itemID);
  bool HasItemAttribute(vtkIdType itemID, std::string attributeName);

  void ItemModified(vtkIdType itemID);

  void RequestOwnerPluginSearch(vtkIdType itemID);
  void RequestOwnerPluginSearch(vtkMRMLNode* dataNode);

  static vtkIdType GetInvalidItemID() { return INVALID_ITEM_ID; }

  void SetItemDataNode(vtkIdType itemID, vtkMRMLNode* dataNode);

// Hierarchy related methods
public:
  vtkIdType CreateItem(vtkIdType parentItemID, vtkMRMLNode* dataNode);
  vtkIdType CreateHierarchyItem(vtkIdType parentItemID, std::string name, std::string level);
  vtkIdType CreateSubjectItem(vtkIdType parentItemID, std::string name);
  vtkIdType CreateStudyItem(vtkIdType parentItemID, std::string name);
  vtkIdType CreateFolderItem(vtkIdType parentItemID, std::string name);

  bool RemoveItem(vtkIdType itemID, bool removeDataNode=true, bool recursive=true);
  bool RemoveItemChildren(vtkIdType itemID, bool removeDataNodes=true, bool recursive=true);
  void RemoveAllItems(bool removeDataNode=false);

  void SetItemParent(vtkIdType itemID, vtkIdType parentItemID);
  vtkIdType GetItemParent(vtkIdType itemID);
  int GetItemPositionUnderParent(vtkIdType itemID);
  vtkIdType GetItemByPositionUnderParent(vtkIdType parentItemID, int position);

  void GetItemChildren(vtkIdType itemID, std::vector<vtkIdType>& childIDs, bool recursive=false);
  void GetItemChildren(vtkIdType itemID, vtkIdList* childIDs, bool recursive=false);

  bool ReparentItemByDataNode(vtkIdType itemID, vtkMRMLNode* newParentNode);
  bool MoveItem(vtkIdType itemID, vtkIdType beforeItemID);

// Item finder methods
public:
  vtkIdType GetItemByUID(const char* uidName, const char* uidValue);

  vtkIdType GetItemByUIDList(const char* uidName, const char* uidValue);

  vtkIdType GetItemByDataNode(vtkMRMLNode* dataNode);

  vtkIdType GetItemChildWithName(vtkIdType parentItemID, std::string name);

  void GetDataNodesInBranch(vtkIdType itemID, vtkCollection* dataNodeCollection, const char* childClass=NULL);

  vtkMRMLNode* GetParentDataNode(vtkMRMLNode* dataNode, bool recursive=false);

// Utility functions
public:
  void SetDisplayVisibilityForBranch(vtkIdType itemID, int visible);

  int GetDisplayVisibilityForBranch(vtkIdType itemID);

  bool IsItemLevel(vtkIdType itemID, std::string level);

  bool IsItemVirtualBranchParent(vtkIdType itemID);

  std::string GetAttributeFromItemAncestor(vtkIdType itemID, std::string attributeName, std::string level="");

  vtkIdType GetItemAncestorAtLevel(vtkIdType itemID, std::string level);

  bool IsAnyNodeInBranchTransformed(vtkIdType itemID, vtkMRMLTransformNode* exceptionNode=NULL);

  static void DeserializeUIDList(std::string uidListString, std::vector<std::string>& deserializedUIDList);

  std::vector<vtkIdType> GetItemsReferencedFromItemByDICOM(vtkIdType itemID);
  void GetItemsReferencedFromItemByDICOM(vtkIdType itemID, vtkIdList* referencingIdList);

  std::vector<vtkIdType> GetItemsReferencingItemByDICOM(vtkIdType itemID);
  void GetItemsReferencingItemByDICOM(vtkIdType itemID, vtkIdList* referencingIdList);

  std::string GenerateUniqueItemName(std::string name);

  int GetNumberOfItems();

  int GetNumberOfItemChildren(vtkIdType itemID, bool recursive=false);

  void PrintItem(vtkIdType itemID, ostream& os, vtkIndent indent);

protected:
  static void ItemEventCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);

protected:
  vtkMRMLSubjectHierarchyNode();
  ~vtkMRMLSubjectHierarchyNode();
  vtkMRMLSubjectHierarchyNode(const vtkMRMLSubjectHierarchyNode&);
  void operator=(const vtkMRMLSubjectHierarchyNode&);

  class vtkInternal;
  vtkInternal* Internal;
  friend class vtkInternal;

  vtkSmartPointer<vtkCallbackCommand> ItemEventCallbackCommand;
};

#endif