Slicer  5.3
Slicer is a multi-platform, free and open source software package for visualization and medical image computing
vtkMRMLScene.h
Go to the documentation of this file.
1 /*=auto=========================================================================
2 
3 Portions (c) Copyright 2005 Brigham and Women's Hospital (BWH) All Rights Reserved.
4 
5 See COPYRIGHT.txt
6 or http://www.slicer.org/copyright/copyright.txt for details.
7 
8 Program: 3D Slicer
9 Module: $RCSfile: vtkMRMLScene.h,v $
10 Date: $Date: 2006/03/17 15:10:09 $
11 Version: $Revision: 1.18 $
12 
13 =========================================================================auto=*/
14 
15 #ifndef __vtkMRMLScene_h
16 #define __vtkMRMLScene_h
17 
18 // MRML includes
19 #include "vtkMRML.h"
20 
21 // VTK includes
22 #include <vtkObject.h>
23 #include <vtkSmartPointer.h>
24 #include <vtkWeakPointer.h>
25 
26 // STD includes
27 #include <list>
28 #include <map>
29 #include <random>
30 #include <set>
31 #include <string>
32 #include <vector>
33 
34 class vtkCacheManager;
35 class vtkDataIOManager;
36 class vtkTagTable;
37 
38 class vtkCallbackCommand;
39 class vtkCollection;
40 class vtkGeneralTransform;
41 class vtkImageData;
42 class vtkURIHandler;
44 class vtkMRMLNode;
48 class vtkMRMLStorageNode;
49 
54 //
57 class VTK_MRML_EXPORT vtkMRMLScene : public vtkObject
58 {
63  friend class vtkMRMLSceneViewNode;
64 
65 public:
66  static vtkMRMLScene *New();
67  vtkTypeMacro(vtkMRMLScene, vtkObject);
68  void PrintSelf(ostream& os, vtkIndent indent) override;
69 
71  void SetURL(const char *url);
72 
74  const char *GetURL();
75 
77  void SetRootDirectory(const char *dir);
78 
80  const char *GetRootDirectory();
81 
86  int Connect(vtkMRMLMessageCollection* userMessages = nullptr);
87 
96  int Import(vtkMRMLMessageCollection* userMessages=nullptr);
97 
102  int Commit(const char* url=nullptr, vtkMRMLMessageCollection* userMessages=nullptr);
103 
109  void Clear(int removeSingletons=0);
110 
112  void ResetNodes();
113 
131  vtkMRMLNode* CreateNodeByClass(const char* className);
132 
153  void RegisterNodeClass(vtkMRMLNode* node, const char* tagName);
154 
159  void RegisterNodeClass(vtkMRMLNode* node);
160 
168  void RegisterAbstractNodeClass(std::string className, std::string typeDisplayName);
169 
171  const char* GetClassNameByTag(const char *tagName);
172 
174  const char* GetTagByClassName(const char *className);
175 
177  std::string GetTypeDisplayNameByClassName(std::string className);
178 
182  void AddDefaultNode(vtkMRMLNode* node);
183  vtkMRMLNode* GetDefaultNodeByClass(const char* className);
184 
186  void RemoveAllDefaultNodes();
187 
189  vtkCollection* GetNodes();
190 
203  vtkMRMLNode* AddNode(vtkMRMLNode *nodeToAdd);
204 
220  vtkMRMLNode* AddNewNodeByClass(std::string className, std::string nodeBaseName = "");
221 
229  vtkMRMLNode* AddNewNodeByClassWithID(std::string className, std::string nodeBaseName, std::string nodeID);
230 
232  vtkMRMLNode* CopyNode(vtkMRMLNode *n);
233 
237  void NodeAdded(vtkMRMLNode *n);
238  void NodeAdded() {this->NodeAdded(nullptr);}
239 
241  void RemoveNode(vtkMRMLNode *n);
242 
246  int IsNodePresent(vtkMRMLNode *n);
247 
255  void InitTraversal();
256 
264  vtkMRMLNode *GetNextNode();
265 
273  vtkMRMLNode *GetNextNodeByClass(const char* className);
274 
276  vtkCollection *GetNodesByName(const char* name);
277  vtkMRMLNode *GetFirstNodeByName(const char* name);
278 
290  vtkMRMLNode *GetFirstNode(const char* byName = nullptr, const char* byClass = nullptr,
291  const int* byHideFromEditors = nullptr,
292  bool exactNameMatch = true);
293 
295  vtkMRMLNode *GetNodeByID(const char* name);
296  vtkMRMLNode *GetNodeByID(std::string name);
297 
300  vtkCollection *GetNodesByClassByName(const char* className, const char* name);
301 
303  int GetNumberOfNodes();
304 
306  vtkMRMLNode* GetNthNode(int n);
307 
309  vtkMRMLNode* GetNthNodeByClass(int n, const char* className );
311  vtkMRMLNode* GetFirstNodeByClass(const char* className);
312 
314  int GetNumberOfNodesByClass(const char* className);
315 
317  int GetNodesByClass(const char *className, std::vector<vtkMRMLNode *> &nodes);
318 
320  vtkCollection* GetNodesByClass(const char *className);
321 
326  vtkMRMLNode* GetSingletonNode(const char* singletonTag, const char* className);
327 
334  vtkMRMLNode* GetSingletonNode(vtkMRMLNode* n);
335 
336  std::list<std::string> GetNodeClassesList();
337 
340  int GetNumberOfRegisteredNodeClasses();
343  vtkMRMLNode * GetNthRegisteredNodeClass(int n);
344 
348  bool IsNodeClassRegistered(const std::string& className);
349 
351  int GetNumberOfRegisteredAbstractNodeClasses();
352 
355  std::string GetNthRegisteredAbstractNodeClassName(int n);
356 
359  std::string GetNthRegisteredAbstractNodeTypeDisplayName(int n);
360 
364  std::string GenerateUniqueName(const std::string& baseName);
365 
370  const char* GetUniqueNameByString(const char* baseName);
371 
373  vtkMRMLNode* InsertAfterNode(vtkMRMLNode *item, vtkMRMLNode *newItem);
375  vtkMRMLNode* InsertBeforeNode(vtkMRMLNode *item, vtkMRMLNode *newItem);
376 
378  void SetUndoOn() {UndoFlag=true;}
379  void SetUndoOff() {UndoFlag=false;}
380  bool GetUndoFlag() {return UndoFlag;}
381  void SetUndoFlag(bool flag) {UndoFlag = flag;}
382 
384  void Undo();
385 
387  void Redo();
388 
390  void ClearUndoStack();
391 
393  void ClearRedoStack();
394 
396  int GetNumberOfUndoLevels() {return static_cast<int>(this->UndoStack.size());}
397 
399  int GetNumberOfRedoLevels() {return static_cast<int>(this->RedoStack.size());}
400 
402  void SaveStateForUndo();
403 
409  void SaveStateForUndo(vtkMRMLNode *node);
410 
416  void SaveStateForUndo(vtkCollection *nodes);
417  void SaveStateForUndo(std::vector<vtkMRMLNode *> nodes);
418 
425  void AddReferencedNodeID(const char *id, vtkMRMLNode *refrencingNode);
426  bool IsNodeReferencingNodeID(vtkMRMLNode* referencingNode, const char* id);
427 
434  vtkMRMLNode* GetNthReferencingNode(int n);
437  const char* GetNthReferencedID(int n);
438 
439  void RemoveReferencedNodeID(const char *id, vtkMRMLNode *refrencingNode);
440 
441  void RemoveNodeReferences(vtkMRMLNode *node);
442 
443  void RemoveReferencesToNode(vtkMRMLNode *node);
444 
452  void UpdateNodeReferences(vtkCollection* checkNodes=nullptr);
453 
454  void CopyNodeReferences(vtkMRMLScene *scene);
455 
456  void CopyNodeChangedIDs(vtkMRMLScene *scene);
457 
459  void UpdateNodeChangedIDs();
460 
461  void RemoveUnusedNodeReferences();
462 
463  bool IsReservedID(const std::string& id);
464 
465  void AddReservedID(const char *id);
466 
467  void RemoveReservedIDs();
468 
471  const char* GetChangedID(const char* id);
472 
487  vtkCollection* GetReferencedNodes(vtkMRMLNode *node, bool recursive=true);
488 
490  void GetReferencingNodes(vtkMRMLNode* referencedNode, std::vector<vtkMRMLNode *> &referencingNodes);
491 
498  void GetReferencedSubScene(vtkMRMLNode *node, vtkMRMLScene* newScene);
499 
500  int IsFilePathRelative(const char * filepath);
501 
508  vtkSetMacro(LoadFromXMLString,int);
509  vtkGetMacro(LoadFromXMLString,int);
510 
517  vtkSetMacro(SaveToXMLString,int);
518  vtkGetMacro(SaveToXMLString,int);
519 
520  vtkSetMacro(ReadDataOnLoad,int);
521  vtkGetMacro(ReadDataOnLoad,int);
522 
527  void SetSceneXMLString(const std::string &xmlString);
528 
533  const std::string& GetSceneXMLString();
534 
535  vtkMRMLSubjectHierarchyNode* GetSubjectHierarchyNode();
536 
537  vtkGetObjectMacro(CacheManager, vtkCacheManager);
538  virtual void SetCacheManager(vtkCacheManager*);
539  vtkGetObjectMacro(DataIOManager, vtkDataIOManager);
540  virtual void SetDataIOManager(vtkDataIOManager*);
541  vtkGetObjectMacro(URIHandlerCollection, vtkCollection);
542  virtual void SetURIHandlerCollection(vtkCollection*);
543  vtkGetObjectMacro(UserTagTable, vtkTagTable);
544  virtual void SetUserTagTable(vtkTagTable*);
545 
550  vtkURIHandler *FindURIHandler(const char *URI);
552  vtkURIHandler *FindURIHandlerByName (const char *name);
554  void AddURIHandler(vtkURIHandler *handler);
555 
592  {
593  BatchProcessState = 0x0001,
594  CloseState = 0x0002 | BatchProcessState,
595  ImportState = 0x0004 | BatchProcessState,
596  RestoreState = 0x0008 | BatchProcessState,
597  SaveState = 0x0010,
598  UndoState = 0x0020,
599  RedoState = 0x0040,
600  };
601 
609  int GetStates()const;
610 
612  inline bool IsBatchProcessing()const;
614  inline bool IsClosing()const;
616  inline bool IsImporting()const;
618  inline bool IsRestoring()const;
620  inline bool IsUndoing()const;
622  inline bool IsRedoing()const;
623 
658  void StartState(unsigned long state, int anticipatedMaxProgress = 0);
659 
668  void EndState(unsigned long state);
669 
671  void ProgressState(unsigned long state, int progress = 0);
672 
674  {
675  NodeAboutToBeAddedEvent = 0x2000,
680 
681  NewSceneEvent = 66030,
682  MetadataAddedEvent = 66032, // ### Slicer 4.5: Simplify - Do not explicitly set for backward compat. See issue #3472
685 
689  StateEvent = 0x2000,
690  StartEvent = 0x0100,
691  EndEvent = 0x0200,
692  ProgressEvent = 0x0400,
693 
694  StartBatchProcessEvent = StateEvent | StartEvent | BatchProcessState,
695  EndBatchProcessEvent = StateEvent | EndEvent | BatchProcessState,
696  ProgressBatchProcessEvent = StateEvent | ProgressEvent | BatchProcessState,
697 
698  StartCloseEvent = StateEvent | StartEvent | CloseState,
699  EndCloseEvent = StateEvent | EndEvent | CloseState,
700  ProgressCloseEvent = StateEvent | ProgressEvent | CloseState,
701 
702  StartImportEvent = StateEvent | StartEvent | ImportState,
703  EndImportEvent = StateEvent | EndEvent | ImportState,
704  ProgressImportEvent = StateEvent | EndEvent | ImportState,
705 
706  StartRestoreEvent = StateEvent | StartEvent | RestoreState,
707  EndRestoreEvent = StateEvent | EndEvent | RestoreState,
708  ProgressRestoreEvent = StateEvent | ProgressEvent | RestoreState,
709 
710  StartSaveEvent = StateEvent | StartEvent | SaveState,
711  EndSaveEvent = StateEvent | EndEvent | SaveState,
712  ProgressSaveEvent = StateEvent | ProgressEvent | SaveState,
713 
714  StartUndoEvent = StateEvent | StartEvent | UndoState,
715  EndUndoEvent = StateEvent | EndEvent | UndoState,
716  ProgressUndoEvent = StateEvent | ProgressEvent | UndoState,
717 
718  StartRedoEvent = StateEvent | StartEvent | RedoState,
719  EndRedoEvent = StateEvent | EndEvent | RedoState,
720  ProgressRedoEvent = StateEvent | ProgressEvent | RedoState,
721 
722  };
723 
725  vtkGetStringMacro(LastLoadedVersion);
726  vtkSetStringMacro(LastLoadedVersion);
727 
729  vtkGetStringMacro(LastLoadedExtensions);
730  vtkSetStringMacro(LastLoadedExtensions);
731 
733  vtkGetStringMacro(Version);
734  vtkSetStringMacro(Version);
735 
738  vtkGetStringMacro(Extensions);
739  vtkSetStringMacro(Extensions);
740 
743  static bool ParseVersion(const char* versionString, std::string& application, int& major, int& minor, int& patch, int& revision);
744 
746  void CopyRegisteredNodesToScene(vtkMRMLScene *scene);
747 
749  void CopySingletonNodesToScene(vtkMRMLScene *scene);
750 
752  void CopyDefaultNodesToScene(vtkMRMLScene *scene);
753 
757  bool GetModifiedSinceRead(vtkCollection* modifiedNodes=nullptr);
758 
760  vtkGetMacro(StoredTime, vtkMTimeType);
761 
768  bool GetStorableNodesModifiedSinceRead(vtkCollection* modifiedStorableNodes = nullptr);
769 
775  void SetStorableNodesModifiedSinceRead();
776 
779  static void SetStorableNodesModifiedSinceRead(vtkCollection* storableNodes);
780 
783  void SetMaximumNumberOfSavedUndoStates(int stackSize);
784  vtkGetMacro(MaximumNumberOfSavedUndoStates, int);
785 
791  bool WriteToMRB(const char* filename, vtkImageData* thumbnail=nullptr, vtkMRMLMessageCollection* userMessages=nullptr);
792 
796  bool ReadFromMRB(const char* fullName, bool clear=false, vtkMRMLMessageCollection* userMessages = nullptr);
797 
803  static std::string UnpackSlicerDataBundle(const char* sdbFilePath, const char* temporaryDirectory, vtkMRMLMessageCollection* userMessages=nullptr);
804 
810  bool SaveSceneToSlicerDataBundleDirectory(const char* sdbDir, vtkImageData* thumbnail=nullptr, vtkMRMLMessageCollection* userMessages=nullptr);
811 
813  void SaveSceneScreenshot(vtkImageData* thumbnail);
814 
824  static std::string PercentEncode(std::string s);
825 
831  static std::string CreateUniqueFileName(const std::string& filename, const std::string& knownExtension = "");
832 
833 protected:
834 
835  typedef std::map< std::string, std::set<std::string> > NodeReferencesType;
836 
837  vtkMRMLScene();
838  ~vtkMRMLScene() override;
839 
840  void PushIntoUndoStack();
841  void PushIntoRedoStack();
842 
843  void CopyNodeInUndoStack(vtkMRMLNode *node);
844  void CopyNodeInRedoStack(vtkMRMLNode *node);
845 
849  vtkMRMLNode* AddNodeNoNotify(vtkMRMLNode *n);
850 
854  void AddReferencedNodes(vtkMRMLNode *node, vtkCollection *refNodes, bool recursive=true);
855 
857  void RemoveInvalidNodeReferences(vtkCollection* checkNodes, const std::set<std::string> &validNodeIDs);
858 
860  static void SceneCallback(vtkObject *caller, unsigned long eid, void *clientData, void *callData);
861 
862  std::string GenerateUniqueID(vtkMRMLNode* node);
863  std::string GenerateUniqueID(const std::string& baseID);
864  int GetUniqueIDIndex(const std::string& baseID);
865  std::string BuildID(const std::string& baseID, int idIndex)const;
866 
868  std::string GenerateUniqueName(vtkMRMLNode* node);
869 
875  int GetUniqueNameIndex(const std::string& baseName);
876 
878  std::string BuildName(const std::string& baseName, int nameIndex)const;
879 
882  void UpdateNodeIDs();
883 
885  void AddNodeID(vtkMRMLNode *node);
886 
888  void RemoveNodeID(char *nodeID);
889 
891  void ClearNodeIDs();
892 
894  NodeReferencesType::iterator FindNodeReference(const char* referencedId, vtkMRMLNode* referencingNode);
895 
897  void TrimUndoStack();
898 
900  void ReserveNodeReferenceIDs(vtkMRMLNode* node);
901 
903  void GetNodeReferenceIDsFromUndoStack(std::set<std::string>& referenceIDs) const;
904 
906  bool IsNodeIDReservedByUndo(const std::string id) const;
907 
908  virtual void SetSubjectHierarchyNode(vtkMRMLSubjectHierarchyNode*);
909 
914  bool SaveStorableNodeToSlicerDataBundleDirectory(vtkMRMLStorableNode* storableNode, std::string& dataDir,
915  std::map<vtkMRMLStorageNode*, std::vector<std::string> > &originalStorageNodeFileNames, vtkMRMLMessageCollection* userMessages);
916 
917  vtkCollection* Nodes;
918 
920  vtkWeakPointer<vtkMRMLSubjectHierarchyNode> SubjectHierarchyNode;
921 
925  vtkCollection * URIHandlerCollection;
927 
928  std::vector<unsigned long> States;
929 
931  bool UndoFlag;
932 
933  std::list< vtkCollection* > UndoStack;
934  std::list< vtkCollection* > RedoStack;
935 
936  std::string URL;
937  std::string RootDirectory;
938 
939  std::map<std::string, int> UniqueIDs;
940  std::map<std::string, int> UniqueNames;
941  std::set<std::string> ReservedIDs;
942 
943  std::vector< vtkMRMLNode* > RegisteredNodeClasses;
944  std::vector< std::string > RegisteredNodeTags;
945  std::map< std::string, std::string > RegisteredAbstractNodeClassTypeDisplayNames; // map class name to type display name
946 
947  NodeReferencesType NodeReferences; // ReferencedIDs (string), ReferencingNodes (node pointer)
948  std::map< std::string, std::string > ReferencedIDChanges;
949  std::map< std::string, vtkSmartPointer<vtkMRMLNode> > NodeIDs;
950 
951  // Stores default nodes. If a class is created or reset (using CreateNodeByClass or Clear) and
952  // a default node is defined for it then the content of the default node will be used to initialize
953  // the class. It is useful for overriding default values that are set in a node's constructor.
954  std::map< std::string, vtkSmartPointer<vtkMRMLNode> > DefaultNodes;
955 
956  std::string SceneXMLString;
957 
959 
961 
963 
964  vtkMTimeType NodeIDsMTime;
965 
966  void RemoveAllNodes(bool removeSingletons);
967 
968  char* Version;
969  char* Extensions;
970 
973 
974  vtkCallbackCommand *DeleteEventCallback;
975 
976  std::default_random_engine RandomGenerator;
977 
978 private:
979 
980  vtkMRMLScene(const vtkMRMLScene&); // Not implemented
981  void operator=(const vtkMRMLScene&); // Not implemented
982 
986  int LoadIntoScene(vtkCollection* scene, vtkMRMLMessageCollection* userMessages=nullptr);
987 
989  vtkTimeStamp StoredTime;
990 };
991 
992 //------------------------------------------------------------------------------
994 {
995  return (this->GetStates() & vtkMRMLScene::BatchProcessState)
997 }
998 
999 //------------------------------------------------------------------------------
1001 {
1002  return (this->GetStates() & vtkMRMLScene::CloseState)
1004 }
1005 
1006 //------------------------------------------------------------------------------
1008 {
1009  return (this->GetStates() & vtkMRMLScene::ImportState)
1011 }
1012 
1013 //------------------------------------------------------------------------------
1015 {
1016  return (this->GetStates() & vtkMRMLScene::RestoreState)
1018 }
1019 
1020 //------------------------------------------------------------------------------
1022 {
1023  return (this->GetStates() & vtkMRMLScene::UndoState)
1025 }
1026 
1027 //------------------------------------------------------------------------------
1029 {
1030  return (this->GetStates() & vtkMRMLScene::RedoState)
1032 }
1033 
1034 #endif
int GetNodesByClass(const char *className, std::vector< vtkMRMLNode *> &nodes)
void NodeAdded()
Definition: vtkMRMLScene.h:238
char * LastLoadedVersion
Definition: vtkMRMLScene.h:971
int GetNumberOfRedoLevels()
returns number of redo steps in the history buffer
Definition: vtkMRMLScene.h:399
char * Version
Definition: vtkMRMLScene.h:968
void PrintSelf(ostream &os, vtkIndent indent) override
vtkWeakPointer< vtkMRMLSubjectHierarchyNode > SubjectHierarchyNode
subject hierarchy node
Definition: vtkMRMLScene.h:920
vtkCallbackCommand * DeleteEventCallback
Definition: vtkMRMLScene.h:974
bool IsImporting() const
Return true if the scene is in Import state, false otherwise.
std::map< std::string, vtkSmartPointer< vtkMRMLNode > > NodeIDs
Definition: vtkMRMLScene.h:949
vtkDataIOManager * DataIOManager
Definition: vtkMRMLScene.h:924
std::string URL
Definition: vtkMRMLScene.h:936
void SetUndoFlag(bool flag)
Definition: vtkMRMLScene.h:381
int MaximumNumberOfSavedUndoStates
Definition: vtkMRMLScene.h:930
vtkCollection * URIHandlerCollection
Definition: vtkMRMLScene.h:925
std::string RootDirectory
Definition: vtkMRMLScene.h:937
virtual bool GetModifiedSinceRead()
std::set< std::string > ReservedIDs
Definition: vtkMRMLScene.h:941
std::string SceneXMLString
Definition: vtkMRMLScene.h:956
int GetNumberOfUndoLevels()
returns number of undo steps in the history buffer
Definition: vtkMRMLScene.h:396
static vtkMRMLSceneViewNode * New()
bool IsRedoing() const
Return true if the scene is in Redo state (in the process of redoing node changes), false otherwise.
MRML node to represent a complete subject hierarchy tree.
void SetUndoOn()
Set undo on/off.
Definition: vtkMRMLScene.h:378
virtual void UpdateNodeReferences(const char *referenceRole=nullptr)
std::map< std::string, int > UniqueIDs
Definition: vtkMRMLScene.h:939
MRML node to represent a 3D surface model.
vtkCacheManager * CacheManager
data i/o handling members
Definition: vtkMRMLScene.h:923
A set of MRML Nodes that supports serialization and undo/redo.
Definition: vtkMRMLScene.h:57
char * LastLoadedExtensions
Definition: vtkMRMLScene.h:972
vtkMTimeType NodeIDsMTime
Definition: vtkMRMLScene.h:964
std::map< std::string, int > UniqueNames
Definition: vtkMRMLScene.h:940
char * Extensions
Definition: vtkMRMLScene.h:969
int GetNumberOfNodeReferences(const char *referenceRole)
Return the number of node IDs for a specific reference role (and nodes as they always have the same s...
int LoadFromXMLString
Definition: vtkMRMLScene.h:958
NodeReferencesType NodeReferences
Definition: vtkMRMLScene.h:947
std::vector< vtkMRMLNode *> RegisteredNodeClasses
Definition: vtkMRMLScene.h:943
void SetUndoOff()
Definition: vtkMRMLScene.h:379
A superclass for other storage nodes.
void operator=(const vtkMRMLSceneViewNode &)
vtkCollection * Nodes
Definition: vtkMRMLScene.h:917
std::list< vtkCollection *> UndoStack
Definition: vtkMRMLScene.h:933
friend class vtkMRMLScene
Definition: vtkMRMLNode.h:171
bool IsUndoing() const
Return true if the scene is in Undo state (in the process of undoing node changes), false otherwise.
std::map< std::string, std::string > ReferencedIDChanges
Definition: vtkMRMLScene.h:948
bool IsClosing() const
Return true if the scene is in Close state, false otherwise.
std::vector< std::string > RegisteredNodeTags
Definition: vtkMRMLScene.h:944
bool IsRestoring() const
Return true if the scene is in Restore state, false otherwise.
Abstract Superclass for all specific types of MRML nodes.
Definition: vtkMRMLNode.h:167
std::list< vtkCollection *> RedoStack
Definition: vtkMRMLScene.h:934
vtkTagTable * UserTagTable
Definition: vtkMRMLScene.h:926
int GetStates() const
Returns the current state of the scene.
std::vector< unsigned long > States
Definition: vtkMRMLScene.h:928
bool IsBatchProcessing() const
Return true if the scene is in BatchProcess state, false otherwise.
Definition: vtkMRMLScene.h:993
std::map< std::string, vtkSmartPointer< vtkMRMLNode > > DefaultNodes
Definition: vtkMRMLScene.h:954
std::map< std::string, std::set< std::string > > NodeReferencesType
Definition: vtkMRMLScene.h:835
std::default_random_engine RandomGenerator
Definition: vtkMRMLScene.h:976
bool GetUndoFlag()
Definition: vtkMRMLScene.h:380
std::map< std::string, std::string > RegisteredAbstractNodeClassTypeDisplayNames
Definition: vtkMRMLScene.h:945