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 vtkIdList;
class vtkMRMLDisplayNode;
class vtkMRMLTransformNode;
class vtkMRMLAbstractViewNode;

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,
    SubjectHierarchyItemDisplayModifiedEvent,
    SubjectHierarchyItemTransformModifiedEvent,
    SubjectHierarchyItemReparentedEvent,
    SubjectHierarchyItemChildrenReorderedEvent,
    SubjectHierarchyItemUIDAddedEvent,
    SubjectHierarchyItemOwnerPluginSearchRequested,
    SubjectHierarchyStartResolveEvent,
    SubjectHierarchyEndResolveEvent,
    SubjectHierarchyItemsShowInViewRequestedEvent,
  };

  struct SubjectHierarchyItemsShowInViewRequestedEventData
  {
    vtkIdList* itemIDsToShow = nullptr;
    vtkMRMLAbstractViewNode* viewNode = nullptr;
  };
 
public:
  static vtkMRMLSubjectHierarchyNode* New();
  vtkTypeMacro(vtkMRMLSubjectHierarchyNode, vtkMRMLNode);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  vtkMRMLNode* CreateNodeInstance() override;

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

  void Copy(vtkMRMLNode* node) override;

  const char* GetNodeTagName() 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);
  bool RemoveItemUID(vtkIdType itemID, std::string uidName);
  std::string GetItemUID(vtkIdType itemID, std::string uidName);
  std::vector<std::string> GetItemUIDNames(vtkIdType itemID);
  bool HasItemUID(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, const char* ownerPluginName = nullptr);
  vtkIdType CreateHierarchyItem(vtkIdType parentItemID, std::string name, std::string level, int positionUnderParent = -1);
  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, bool enableCircularCheck = true);
  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);

  bool ReorderItemChildren(vtkIdType parentItemID, vtkIdList* childIDs);
 
  // 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 GetItemByName(std::string name);

  void GetItemsByName(std::string name, vtkIdList* foundItemIds, bool contains = false);

  vtkIdType GetItemChildWithName(vtkIdType parentItemID, std::string name, bool recursive = false);

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

  vtkMRMLNode* GetParentDataNode(vtkMRMLNode* dataNode, bool recursive = false);
 
  // Utility functions
public:
  void SetDisplayVisibilityForBranch(vtkIdType itemID, int visible);
  int GetDisplayVisibilityForBranch(vtkIdType itemID);

  void SetItemDisplayVisibility(vtkIdType itemID, int visible);
  int GetItemDisplayVisibility(vtkIdType itemID);

  vtkMRMLDisplayNode* GetDisplayNodeForItem(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, bool includeParentItem = true, vtkMRMLTransformNode* exceptionNode = nullptr);

  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);

  static vtkMRMLSubjectHierarchyNode* ResolveSubjectHierarchy(vtkMRMLScene* scene);

  void ShowItemsInView(vtkIdList* itemIDs, vtkMRMLAbstractViewNode* viewNode);
 
protected:
  static void ItemEventCallback(vtkObject* caller, unsigned long eid, void* clientData, void* callData);
 
protected:
  vtkMRMLSubjectHierarchyNode();
  ~vtkMRMLSubjectHierarchyNode() override;
  vtkMRMLSubjectHierarchyNode(const vtkMRMLSubjectHierarchyNode&);
  void operator=(const vtkMRMLSubjectHierarchyNode&);
 
  class vtkInternal;
  vtkInternal* Internal;
  friend class vtkInternal;

  vtkSmartPointer<vtkCallbackCommand> ItemEventCallbackCommand;
};
 
#endif