# encoding: utf-8 # module vtkmodules.vtkCommonDataModel # from C:\Users\xukai\Downloads\发票2\venv\Lib\site-packages\vtkmodules\vtkCommonDataModel.cp311-win_amd64.pyd # by generator 1.147 # no doc # imports import vtkmodules.vtkCommonCore as __vtkmodules_vtkCommonCore import vtkmodules.vtkCommonMath as __vtkmodules_vtkCommonMath import vtkmodules.vtkCommonTransforms as __vtkmodules_vtkCommonTransforms class vtkDataAssembly(__vtkmodules_vtkCommonCore.vtkObject): """ vtkDataAssembly - hierarchical representation to use with vtkPartitionedDataSetCollection Superclass: vtkObject vtkDataAssembly is a mechanism to represent hierarchical organization of items (or vtkPartitionedDataSet instances) in a vtkPartitionedDataSetCollection. vtkPartitionedDataSetCollection is similar to a vtkMultiBlockDataSet since it provides a means for putting together multiple non-composite datasets. However, vtkPartitionedDataSetCollection itself doesn't provide any mechanism to define relationships between items in the collections. That is done using vtkDataAssembly. @section Overview Overview At its core, vtkDataAssembly is simply a tree of nodes starting with the root node. Each node has a unique id and a string name (names need not be unique). On initialization with `vtkDataAssembly::Initialize`, an empty tree with a root node is created. The root node's id and name can be obtained using `vtkDataAssembly::GetRootNode` and `vtkDataAssembly::GetRootNodeName`. The root node's id is fixed (vtkDataAssembly::GetRootNode), however the name can be changed using `vtkDataAssembly::SetRootNodeName`. Child nodes can be added using `vtkDataAssembly::AddNode` or `vtkDataAssembly::AddNodes`, each of which returns the ids for every child node added. A non-root node can be removed using `vtkDataAssembly::RemoveNode`. Each node in the tree (including the root node) can have associated dataset indices. For a vtkDataAssembly associated with a vtkPartitionedDataSetCollection, these indices refer to the item index, or partitioned-dataset-index for items in the collection. Dataset indices can be specified using `vtkDataAssembly::AddDataSetIndex`, `vtkDataAssembly::AddDataSetIndices` and removed using `vtkDataAssembly::RemoveDataSetIndex`, `vtkDataAssembly::RemoveAllDataSetIndices`. `vtkDataAssembly::GetDataSetIndices` provides a mechanism to get the database indices associated with a node, and optionally, the entire subtree rooted at the chosen node. @section Searching Searching Each node in the vtkDataAssembly is assigned a unique id. `vtkDataAssembly::FindFirstNodeWithName` and `vtkDataAssembly::FindNodesWithName` can be used to get the id(s) for node(s) with given name. `vtkDataAssembly::SelectNodes` provides a more flexible mechanism to find nodes using name-based queries. Section@ref DataAssemblyPathQueries covers supported queries. @section Traversal Traversal `vtkDataAssemblyVisitor` defines a visitor API. An instance of a concretized `vtkDataAssemblyVisitor` subclass can be passed to `vtkDataAssembly::Visit` to traverse the data-assembly hierarchy either in depth-first or breadth-first order. @section DataAssemblyPathQueries Supported Path Queries `vtkDataAssembly::SelectNodes` can be used find nodes that match the specified query (or queries) using XPath 1.0 syntax. For example: * '/' is used as the path separator. If a node name has a `/` it must be escaped using `\` in the query. Note, escaping is not necessary when using `SetNodeName`/`GetNodeName`. * '/' selects the root node. * '/nodename' selects all child nodes of the root with the name 'nodename'. * '//nodename' selects all nodes with 'nodename' that are descendants of the root; thus, this this will traverse the entire tree. * '/nodename/' selects all child nodes of all nodes named 'nodename' under the root; thus, ending a query with '/' selects the children of the found nodes rather than the nodes themselves. * '/nodename1/nodename2' selects all nodes named 'nodename2' which are children of nodes with name 'nodename1' that are themselves children of the root node. * '//nodename1/nodename2' finds all nodes in the tree named 'nodename1' and then selects all children of these found nodes that are named 'nodename2'. @section Applications Applications The separation of dataset storage (vtkPartitionedDataSetCollection) and organization (vtkDataAssembly) enables development of algorithms that can expose APIs that are not tightly coupled to dataset storage. Together, vtkPartitionedDataSetCollection and vtkDataAssembly can be thought of as a different way of organizing data that was previously organized as a vtkMultiBlockDataSet. The advantage of the this newer approach is that filters can support specifying parameters using paths or path queries rather than composite indices. The composite indices suffered from the fact that they made no sense except for the specific vtkMultiBlockDataSet they were applied too. Thus, if the filters input was changed, the composite ids rarely made any sense and needed to be updated. Paths and path queries, however, do not suffer from this issue. """ def AddDataSetIndex(self, id, dataset_index): # real signature unknown; restored from __doc__ """ AddDataSetIndex(self, id:int, dataset_index:int) -> bool C++: bool AddDataSetIndex(int id, unsigned int dataset_index) Add a dataset index to a node. The node id can refer to any valid node in the assembly, including the root. While the same dataset can be added multiple times in the assembly, it cannot be added multiple times to the same node. Additional adds will fail. @returns true if addition succeeded else false. """ return False def AddDataSetIndexRange(self, id, index_start, count): # real signature unknown; restored from __doc__ """ AddDataSetIndexRange(self, id:int, index_start:int, count:int) -> bool C++: bool AddDataSetIndexRange(int id, unsigned int index_start, int count) Same as `AddDataSetIndices` except this supports adding a contiguous range of dataset indices in one go. @ returns true if any dataset index was successfully added. """ return False def AddDataSetIndices(self, id, dataset_indices, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ AddDataSetIndices(self, id:int, dataset_indices:(int, ...)) -> bool C++: bool AddDataSetIndices(int id, const std::vector &dataset_indices) Same as `AddDataSetIndex` except supports adding multiple dataset indices in one go. Note, a dataset index only gets added once. @returns true if any dataset index was successfully added. """ pass def AddNode(self, name, parent=0): # real signature unknown; restored from __doc__ """ AddNode(self, name:str, parent:int=0) -> int C++: int AddNode(const char *name, int parent=0) Adds a node to the assembly with the given name and returns its id. `parent` is the id for the parent node which defaults to the root node id (i.e. `GetRootNode`). If `parent` is invalid, the add will fail. @returns id of the newly added node on success, else -1. """ return 0 def AddNodes(self, names, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ AddNodes(self, names:(str, ...), parent:int=0) -> (int, ...) C++: std::vector AddNodes( const std::vector &names, int parent=0) Same as `AddNode` except allows adding multiple nodes in one go. If `parent` is invalid, the add will fail. @returns vectors of corresponding indices for each of the `names` added. """ pass def AddSubtree(self, parent, other, otherParent=0): # real signature unknown; restored from __doc__ """ AddSubtree(self, parent:int, other:vtkDataAssembly, otherParent:int=0) -> int C++: int AddSubtree(int parent, vtkDataAssembly *other, int otherParent=0) Add a subtree by copy the nodes from another tree starting with the specified parent index. """ return 0 def DeepCopy(self, other): # real signature unknown; restored from __doc__ """ DeepCopy(self, other:vtkDataAssembly) -> None C++: void DeepCopy(vtkDataAssembly *other) Deep copy the `other`. """ pass def FindFirstNodeWithName(self, name, traversal_order, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindFirstNodeWithName(self, name:str, traversal_order:int=...) -> int C++: int FindFirstNodeWithName(const char *name, int traversal_order=vtkDataAssembly::TraversalOrder::DepthFirst) Finds first node that is encountered in a breadth first traversal of the assembly with the given name. @returns the if of the node if found, else -1. """ pass def FindNodesWithName(self, name, sort_order, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ FindNodesWithName(self, name:str, sort_order:int=...) -> (int, ...) C++: std::vector FindNodesWithName(const char *name, int sort_order=vtkDataAssembly::TraversalOrder::DepthFirst) Finds all nodes with the given name. The nodes can be ordered depth first or breadth first, based on the `sort_order` flag. """ pass def GetAttribute(self, id, name, value): # real signature unknown; restored from __doc__ """ GetAttribute(self, id:int, name:str, value:int) -> bool C++: bool GetAttribute(int id, const char *name, int &value) GetAttribute(self, id:int, name:str, value:int) -> bool C++: bool GetAttribute(int id, const char *name, vtkIdType &value) """ return False def GetAttributeOrDefault(self, id, name, default_value): # real signature unknown; restored from __doc__ """ GetAttributeOrDefault(self, id:int, name:str, default_value:str) -> str C++: const char *GetAttributeOrDefault(int id, const char *name, const char *default_value) GetAttributeOrDefault(self, id:int, name:str, default_value:int) -> int C++: int GetAttributeOrDefault(int id, const char *name, int default_value) GetAttributeOrDefault(self, id:int, name:str, default_value:int) -> int C++: vtkIdType GetAttributeOrDefault(int id, const char *name, vtkIdType default_value) Get an attribute value. Returns the value associated with the node or the provided default value. """ return "" def GetChild(self, parent, index): # real signature unknown; restored from __doc__ """ GetChild(self, parent:int, index:int) -> int C++: int GetChild(int parent, int index) Returns the id for a child not at the given index, if valid, otherwise -1. """ return 0 def GetChildIndex(self, parent, child): # real signature unknown; restored from __doc__ """ GetChildIndex(self, parent:int, child:int) -> int C++: int GetChildIndex(int parent, int child) Returns the index for a child under a given. -1 if invalid. """ return 0 def GetChildNodes(self, parent, traverse_subtree=True, traversal_order, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetChildNodes(self, parent:int, traverse_subtree:bool=True, traversal_order:int=...) -> (int, ...) C++: std::vector GetChildNodes(int parent, bool traverse_subtree=true, int traversal_order=vtkDataAssembly::TraversalOrder::DepthFirst) Returns ids for all child nodes. If `traverse_subtree` is true (default), recursively builds the child node list. The traversal order can be specified using `traversal_order` flag; defaults to depth-first. @sa vtkDataAssembly::Visit, vtkDataAssemblyVisitor """ pass def GetDataSetIndices(self, id, traverse_subtree=True, traversal_order, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetDataSetIndices(self, id:int, traverse_subtree:bool=True, traversal_order:int=...) -> (int, ...) C++: std::vector GetDataSetIndices(int id, bool traverse_subtree=true, int traversal_order=vtkDataAssembly::TraversalOrder::DepthFirst) GetDataSetIndices(self, ids:(int, ...), traverse_subtree:bool=True, traversal_order:int=...) -> (int, ...) C++: std::vector GetDataSetIndices( const std::vector &ids, bool traverse_subtree=true, int traversal_order=vtkDataAssembly::TraversalOrder::DepthFirst) Returns the dataset indices associated with the node. If `traverse_subtree` is true (default), recursively builds the dataset indices list for the node and all its child nodes. Note, a dataset index will only appear once in the output even if it is encountered on multiple nodes in the subtree. When `traverse_subtree` is true, the traversal order can be specified using `traversal_order`. Defaults to depth-first. """ pass def GetFirstNodeByPath(self, path): # real signature unknown; restored from __doc__ """ GetFirstNodeByPath(self, path:str) -> int C++: int GetFirstNodeByPath(const char *path) Return a node id given the path. Returns `-1` if path is not valid. """ return 0 def GetNodeName(self, id): # real signature unknown; restored from __doc__ """ GetNodeName(self, id:int) -> str C++: const char *GetNodeName(int id) """ return "" def GetNodePath(self, id): # real signature unknown; restored from __doc__ """ GetNodePath(self, id:int) -> str C++: std::string GetNodePath(int id) Returns the path for a node. """ return "" def GetNumberOfChildren(self, parent): # real signature unknown; restored from __doc__ """ GetNumberOfChildren(self, parent:int) -> int C++: int GetNumberOfChildren(int parent) Returns the number of child nodes. @returns the number of child nodes for the parent node or 0 if the parent is invalid. """ return 0 def GetNumberOfGenerationsFromBase(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBase(self, type:str) -> int C++: vtkIdType GetNumberOfGenerationsFromBase(const char *type) override; Given the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetNumberOfGenerationsFromBaseType(self, type): # real signature unknown; restored from __doc__ """ GetNumberOfGenerationsFromBaseType(type:str) -> int C++: static vtkIdType GetNumberOfGenerationsFromBaseType( const char *type) Given a the name of a base class of this class type, return the distance of inheritance between this class type and the named class (how many generations of inheritance are there between this class and the named class). If the named class is not in this class's inheritance tree, return a negative value. Valid responses will always be nonnegative. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def GetParent(self, id): # real signature unknown; restored from __doc__ """ GetParent(self, id:int) -> int C++: int GetParent(int id) Returns the id for the parent node, if any. Returns -1 if the node is invalid or has no parent (i.e. is the root node). """ return 0 def GetRootNode(self): # real signature unknown; restored from __doc__ """ GetRootNode() -> int C++: static int GetRootNode() Returns the ID for the root node. This always returns 0. """ return 0 def GetRootNodeName(self): # real signature unknown; restored from __doc__ """ GetRootNodeName(self) -> str C++: const char *GetRootNodeName() """ return "" def HasAttribute(self, id, name): # real signature unknown; restored from __doc__ """ HasAttribute(self, id:int, name:str) -> bool C++: bool HasAttribute(int id, const char *name) Returns true if attribute with the given name is present on the chosen node. """ return False def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: void Initialize() Initializes the data-assembly. When a new vtkDataAssembly instance is created, it is in initialized form and it is not required to call this method to initialize it. """ pass def InitializeFromXML(self, xmlcontents): # real signature unknown; restored from __doc__ """ InitializeFromXML(self, xmlcontents:str) -> bool C++: bool InitializeFromXML(const char *xmlcontents) Initializes a data-assembly using an XML representation of the assembly. Returns true if the initialization was successful, otherwise the assembly is set a clean state and returns false. """ return False def IsA(self, type): # real signature unknown; restored from __doc__ """ IsA(self, type:str) -> int C++: vtkTypeBool IsA(const char *type) override; Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def IsNodeNameReserved(self, name): # real signature unknown; restored from __doc__ """ IsNodeNameReserved(name:str) -> bool C++: static bool IsNodeNameReserved(const char *name) Returns true for node names that are reserved. """ return False def IsNodeNameValid(self, name): # real signature unknown; restored from __doc__ """ IsNodeNameValid(name:str) -> bool C++: static bool IsNodeNameValid(const char *name) Validates a node name. """ return False def IsTypeOf(self, type): # real signature unknown; restored from __doc__ """ IsTypeOf(type:str) -> int C++: static vtkTypeBool IsTypeOf(const char *type) Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h. """ return 0 def MakeValidNodeName(self, name): # real signature unknown; restored from __doc__ """ MakeValidNodeName(name:str) -> str C++: static std::string MakeValidNodeName(const char *name) Converts any string to a string that is a valid node name. This is done by simply discarding any non-supported character. Additionally, if the first character is not a "_" or an alphabet, then the "_" is prepended. """ return "" def NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkDataAssembly C++: vtkDataAssembly *NewInstance() """ return vtkDataAssembly def RemoveAllDataSetIndices(self, id, traverse_subtree=True): # real signature unknown; restored from __doc__ """ RemoveAllDataSetIndices(self, id:int, traverse_subtree:bool=True) -> bool C++: bool RemoveAllDataSetIndices(int id, bool traverse_subtree=true) Clears all dataset indices from the node. If `traverse_subtree` is true (default), recursively removes all dataset indices from all the child nodes. @returns true on success, else returns false. """ return False def RemoveDataSetIndex(self, id, dataset_index): # real signature unknown; restored from __doc__ """ RemoveDataSetIndex(self, id:int, dataset_index:int) -> bool C++: bool RemoveDataSetIndex(int id, unsigned int dataset_index) Removes a dataset index from a node. @returns true if the removal was successful, else returns false. """ return False def RemoveNode(self, id): # real signature unknown; restored from __doc__ """ RemoveNode(self, id:int) -> bool C++: bool RemoveNode(int id) Removes a node from the assembly. The node identified by the id and all its children are removed. Root node cannot be removed. @returns true if removal was successful, false if the id is invalid or root node id. """ return False def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkDataAssembly C++: static vtkDataAssembly *SafeDownCast(vtkObjectBase *o) """ return vtkDataAssembly def SelectNodes(self, path_queries, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SelectNodes(self, path_queries:(str, ...), traversal_order:int=...) -> (int, ...) C++: std::vector SelectNodes( const std::vector &path_queries, int traversal_order=vtkDataAssembly::TraversalOrder::DepthFirst) Returns ids for nodes matching the path_queries. See Section@ref DataAssemblyPathQueries for supported query expressions. Will return an empty vector is no nodes match the requested query. @returns node ids matching the query in traversal order chosen using `traversal_order`. """ pass def SerializeToXML(self, indent): # real signature unknown; restored from __doc__ """ SerializeToXML(self, indent:vtkIndent) -> str C++: std::string SerializeToXML(vtkIndent indent) Saves the data-assembly as a XML. """ return "" def SetAttribute(self, id, name, value): # real signature unknown; restored from __doc__ """ SetAttribute(self, id:int, name:str, value:str) -> None C++: void SetAttribute(int id, const char *name, const char *value) SetAttribute(self, id:int, name:str, value:int) -> None C++: void SetAttribute(int id, const char *name, int value) SetAttribute(self, id:int, name:str, value:int) -> None C++: void SetAttribute(int id, const char *name, vtkIdType value) Set an attribute. Will replace an existing attribute with the same name if present. """ pass def SetNodeName(self, id, name): # real signature unknown; restored from __doc__ """ SetNodeName(self, id:int, name:str) -> None C++: void SetNodeName(int id, const char *name) Get/Set a node's name. If node id is invalid, `SetNodeName` will raise an error; `GetNodeName` will also raise an error and return nullptr. `SetNodeName` will raise an error if the name is not valid. Name cannot be empty or nullptr. """ pass def SetRootNodeName(self, name): # real signature unknown; restored from __doc__ """ SetRootNodeName(self, name:str) -> None C++: void SetRootNodeName(const char *name) Get/Set root node name. Defaults to DataAssembly. """ pass def SubsetCopy(self, other, selected_branches, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ SubsetCopy(self, other:vtkDataAssembly, selected_branches:(int, ...)) -> None C++: void SubsetCopy(vtkDataAssembly *other, const std::vector &selected_branches) Create a deep-copy of other by only passing the chosen branches. All other branches of the tree will be pruned. Note this method never affects the depth of the selected branches or dataset indices attached to any of the nodes in pruned output. """ pass def Visit(self, visitor, traversal_order, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ Visit(self, visitor:vtkDataAssemblyVisitor, traversal_order:int=...) -> None C++: void Visit(vtkDataAssemblyVisitor *visitor, int traversal_order=vtkDataAssembly::TraversalOrder::DepthFirst) Visit(self, id:int, visitor:vtkDataAssemblyVisitor, traversal_order:int=...) -> None C++: void Visit(int id, vtkDataAssemblyVisitor *visitor, int traversal_order=vtkDataAssembly::TraversalOrder::DepthFirst) Visit each node in the assembly for processing. The traversal order can be specified using `traversal_order` which defaults to depth-first. """ pass def __delattr__(self, *args, **kwargs): # real signature unknown """ Implement delattr(self, name). """ pass def __getattribute__(self, *args, **kwargs): # real signature unknown """ Return getattr(self, name). """ pass def __init__(self, *args, **kwargs): # real signature unknown pass @staticmethod # known case of __new__ def __new__(*args, **kwargs): # real signature unknown """ Create and return a new object. See help(type) for accurate signature. """ pass def __repr__(self, *args, **kwargs): # real signature unknown """ Return repr(self). """ pass def __setattr__(self, *args, **kwargs): # real signature unknown """ Implement setattr(self, name, value). """ pass def __str__(self, *args, **kwargs): # real signature unknown """ Return str(self). """ pass __this__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default """Pointer to the C++ object.""" BreadthFirst = 1 DepthFirst = 0 TraversalOrder = None # (!) real value is "" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkDataAssembly\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'Initialize\': , \'InitializeFromXML\': , \'SerializeToXML\': , \'GetRootNode\': , \'SetRootNodeName\': , \'GetRootNodeName\': , \'AddNode\': , \'AddNodes\': , \'AddSubtree\': , \'RemoveNode\': , \'SetNodeName\': , \'GetNodeName\': , \'GetNodePath\': , \'GetFirstNodeByPath\': , \'AddDataSetIndex\': , \'AddDataSetIndices\': , \'AddDataSetIndexRange\': , \'RemoveDataSetIndex\': , \'RemoveAllDataSetIndices\': , \'FindFirstNodeWithName\': , \'FindNodesWithName\': , \'GetChildNodes\': , \'GetNumberOfChildren\': , \'GetChild\': , \'GetChildIndex\': , \'GetParent\': , \'HasAttribute\': , \'SetAttribute\': , \'GetAttribute\': , \'GetAttributeOrDefault\': , \'Visit\': , \'GetDataSetIndices\': , \'SelectNodes\': , \'SubsetCopy\': , \'DeepCopy\': , \'IsNodeNameValid\': , \'MakeValidNodeName\': , \'IsNodeNameReserved\': , \'TraversalOrder\': , \'DepthFirst\': 0, \'BreadthFirst\': 1, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkDataAssembly - hierarchical representation to use with\\nvtkPartitionedDataSetCollection\\n\\nSuperclass: vtkObject\\n\\nvtkDataAssembly is a mechanism to represent hierarchical organization\\nof items (or vtkPartitionedDataSet instances) in a\\nvtkPartitionedDataSetCollection. vtkPartitionedDataSetCollection is\\nsimilar to a vtkMultiBlockDataSet since it provides a means for\\nputting together multiple non-composite datasets. However,\\nvtkPartitionedDataSetCollection itself doesn\'t provide any mechanism\\nto define relationships between items in the collections. That is\\ndone using vtkDataAssembly.\\n\\n@section Overview Overview\\n\\nAt its core, vtkDataAssembly is simply a tree of nodes starting with\\nthe root node. Each node has a unique id and a string name (names\\nneed not be unique). On initialization with\\n`vtkDataAssembly::Initialize`, an empty tree with a root node is\\ncreated. The root node\'s id and name can be obtained using\\n`vtkDataAssembly::GetRootNode` and\\n`vtkDataAssembly::GetRootNodeName`. The root node\'s id is fixed\\n(vtkDataAssembly::GetRootNode), however the name can be changed using\\n`vtkDataAssembly::SetRootNodeName`.\\n\\nChild nodes can be added using `vtkDataAssembly::AddNode` or\\n`vtkDataAssembly::AddNodes`, each of which returns the ids for every\\nchild node added. A non-root node can be removed using\\n`vtkDataAssembly::RemoveNode`.\\n\\nEach node in the tree (including the root node) can have associated\\ndataset indices. For a vtkDataAssembly associated with a\\nvtkPartitionedDataSetCollection, these indices refer to the item\\nindex, or partitioned-dataset-index for items in the collection.\\nDataset indices can be specified using\\n`vtkDataAssembly::AddDataSetIndex`,\\n`vtkDataAssembly::AddDataSetIndices` and removed using\\n`vtkDataAssembly::RemoveDataSetIndex`,\\n`vtkDataAssembly::RemoveAllDataSetIndices`.\\n`vtkDataAssembly::GetDataSetIndices` provides a mechanism to get the\\ndatabase indices associated with a node, and optionally, the entire\\nsubtree rooted at the chosen node.\\n\\n@section Searching Searching\\n\\nEach node in the vtkDataAssembly is assigned a unique id.\\n`vtkDataAssembly::FindFirstNodeWithName` and\\n`vtkDataAssembly::FindNodesWithName` can be used to get the id(s) for\\nnode(s) with given name.\\n\\n`vtkDataAssembly::SelectNodes` provides a more flexible mechanism to\\nfind nodes using name-based queries. Section@ref\\nDataAssemblyPathQueries covers supported queries.\\n\\n@section Traversal Traversal\\n\\n`vtkDataAssemblyVisitor` defines a visitor API. An instance of a\\nconcretized `vtkDataAssemblyVisitor` subclass can be passed to\\n`vtkDataAssembly::Visit` to traverse the data-assembly hierarchy\\neither in depth-first or breadth-first order.\\n\\n@section DataAssemblyPathQueries Supported Path Queries\\n\\n`vtkDataAssembly::SelectNodes` can be used find nodes that match the\\nspecified query (or queries) using XPath 1.0 syntax.\\n\\nFor example:\\n\\n* \'/\' is used as the path separator. If a node name has a `/` it must\\nbe escaped using `\\\\` in the query. Note, escaping is not necessary\\n when using `SetNodeName`/`GetNodeName`.\\n\\n* \'/\' selects the root node.\\n\\n* \'/nodename\' selects all child nodes of the root with the name\\n \'nodename\'.\\n\\n* \'//nodename\' selects all nodes with \'nodename\' that are descendants\\nof the root; thus, this this will traverse the entire tree.\\n\\n* \'/nodename/\' selects all child nodes of all nodes named \'nodename\'\\n under the root; thus, ending a query with \'/\' selects the children\\n of the found nodes rather than the nodes themselves.\\n\\n* \'/nodename1/nodename2\' selects all nodes named \'nodename2\' which\\n are children of nodes with name \'nodename1\' that are themselves\\n children of the root node.\\n\\n* \'//nodename1/nodename2\' finds all nodes in the tree named\\n \'nodename1\' and then selects all children of these found nodes that\\nare named \'nodename2\'.\\n\\n@section Applications Applications\\n\\nThe separation of dataset storage (vtkPartitionedDataSetCollection)\\nand organization (vtkDataAssembly) enables development of algorithms\\nthat can expose APIs that are not tightly coupled to dataset storage.\\nTogether, vtkPartitionedDataSetCollection and vtkDataAssembly can be\\nthought of as a different way of organizing data that was previously\\norganized as a vtkMultiBlockDataSet. The advantage of the this newer\\napproach is that filters can support specifying parameters using\\npaths or path queries rather than composite indices. The composite\\nindices suffered from the fact that they made no sense except for the\\nspecific vtkMultiBlockDataSet they were applied too. Thus, if the\\nfilters input was changed, the composite ids rarely made any sense\\nand needed to be updated. Paths and path queries, however, do not\\nsuffer from this issue.\\n\\n"})' __vtkname__ = 'vtkDataAssembly'