# 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 vtkHyperTree(__vtkmodules_vtkCommonCore.vtkObject): """ vtkHyperTree - A data object structured as a tree. Superclass: vtkObject An hypertree grid is a dataobject containing a rectilinear grid of elements that can be either null or a hypertree. An hypertree is a dataobject describing a decomposition tree. A VERTICE is an element of this tree. A NODE, also called COARSE cell, is a specific vertice which is refined and than has either exactly f^d children, where f in {2,3} is the branching factor, the same value for all trees in this hypertree grid, and d in {1,2,3} is the spatial dimension. It is called coarse because there are smaller child cells. A LEAF, also called FINE cell, is a vertice without children, not refined. It is called fine because in the same space there are no finer cells. In a tree, we can find coarse cells smaller than fine cell but not in the same space. Such trees have particular names for f=2: - bintree (d=1), - quadtree (d=2), - octree (d=3). The original octree class name came from the following paper: @ARTICLE{yau-srihari-1983, author={Mann-May Yau and Sargur N. Srihari}, title={A Hierarchical Data Structure for Multidimensional Digital Images}, journal={Communications of the ACM}, month={July}, year={1983}, volume={26}, number={7}, pages={504--515} } Attributes are associated with (all) cells, not with points. The attributes that are associated with coarses, it's used for LoD (Level-of-Detail). The attributes on coarse cells can be given by the code or/and computed by the use of a specific filter exploiting the values from its children (which can be leaves or not). The geometry is implicitly given by the size of the root node on each axis and position of the origin. In fact, in 3D, the geometry is then not limited to a cube but can have a rectangular shape. By construction, an hypertree is efficient in memory usage. The LoD feature allows for quick culling of part of the dataobject. This is an abstract class used as a superclass by a custom templated compact class. Other versions of this code could be made available to meet other needs without questioning cursors and filters. All methods are pure virtual. This is done to hide templates. @par Case octree with f=2, d=3: For each node (coarse cell), 8 children are encoded in a child index (from 0 to 7) in the following orientation described in hypertree grid. It is easy to access each child as a cell of a grid. Note also that the binary representation is relevant, each bit codes a side: bit 0 encodes -x side (0) or +x side (1) bit 1 encodes -y side (0) or +y side (1) bit 2 encodes -z side (0) or +z side (1) -z side is first, in counter-clockwise order: 0: -y -x sides 1: -y +x sides 2: +y -x sides 3: +y +x sides +z side is last, in counter-clockwise order: 4: -y -x sides 5: -y +x sides 6: +y -x sides 7: +y +x sides +y +-+-+ ^ |2|3| | +-+-+ O +z +-> +x |0|1| +-+-+ +y +-+-+ ^ |6|7| | +-+-+ 1 +z +-> +x |4|5| +-+-+ @par Case quadtree with f=2, d=2: Just use 2 bits. +y +-+-+ ^ |2|3| | +-+-+ +-> +x |0|1| +-+-+ @par Case bintree with f=2, d=1: Just use 1 bits. O+-> +x It's more difficult with f=3. @par Thanks: This class was written by Philippe Pebay, Joachim Pouderoux, and Charles Law, Kitware 2013 This class was modified by Guenole Harel and Jacques-Bernard Lekien 2014 This class was modified by Philippe Pebay, 2016 Among others, this class was simplified, optimized (memory), documented and completed for to improve IO XML by Jacques-Bernard Lekien 2018-19 This work was supported by Commissariat a l'Energie Atomique CEA, DAM, DIF, F-91297 Arpajon, France. """ def BuildFromBreadthFirstOrderDescriptor(self, descriptor, numberOfBits, startIndex=0): # real signature unknown; restored from __doc__ """ BuildFromBreadthFirstOrderDescriptor(self, descriptor:vtkBitArray, numberOfBits:int, startIndex:int=0) -> None C++: virtual void BuildFromBreadthFirstOrderDescriptor( vtkBitArray *descriptor, vtkIdType numberOfBits, vtkIdType startIndex=0) This method builds the indexing of this tree given a breadth first order descriptor. This descriptor is the same bit array that would be created by `ComputeBreadthFirstOrderDescriptor`. The current tree is ready to use after calling this method. @param descriptor is a binary descriptor, in breadth first order, that describes the tree topology. If vertex of index `id` in breadth first order has children, then the corresponding value in `descriptor` is one. Otherwise, it is set to zero. Remember that arrays are appended, meaning that the index in `descriptor` corresponding to `id` in the current tree would be the size of `descriptor` before calling this method, plus `id`. @param numberOfBits: Number of bits to be read in the descriptor to build the tree. Remember that the last depth of the tree is not encoded in the descriptor, as we know that they are full of zeros (because leaves have no children). @param startIndex: Input descriptor is being read starting at this index. """ pass def ComputeBreadthFirstOrderDescriptor(self, inputMask, numberOfVerticesPerDepth, descriptor, breadthFirstIdMap): # real signature unknown; restored from __doc__ """ ComputeBreadthFirstOrderDescriptor(self, inputMask:vtkBitArray, numberOfVerticesPerDepth:vtkTypeInt64Array, descriptor:vtkBitArray, breadthFirstIdMap:vtkIdList) -> None C++: virtual void ComputeBreadthFirstOrderDescriptor( vtkBitArray *inputMask, vtkTypeInt64Array *numberOfVerticesPerDepth, vtkBitArray *descriptor, vtkIdList *breadthFirstIdMap) This method computes the breadth first order descriptor of the current tree. It takes as input the input mask `inputMask` which should be provided by the `vtkHyperTreeGrid` in which this `vtkHyperTree` lies. In addition to computing the descriptor, it computes the mapping between the current memory layout of this tree with the breadth first order version of it. Outputs are `numberOfVerticesPerDepth`, `descriptor` and `breadthFirstIdMap`. Each of those arrays are appended with new data, so one can create one unique big array for an entire `vtkHyperTreeGrid` concatenating breadth first order description and mapping of concatenated trees. @param inputMask the mask provided by `vtkHyperTreeGrid`. @param numberOfVerticesPerDepth is self explanatory: from depth 0 to the maximum depth of the tree, it stores the number of vertices at each depth. If the input tree has masked subtrees such that getting rid of those subtrees reduces the depth, then `numberOfVerticesPerDepth` will take this smaller depth into account rather than adding zeros. In other words, `numberOfVerticesPerDepth` cannot have zero values. @param descriptor is a binary descriptor, in breadth first order, that describes the tree topology. If vertex of index `id` in breadth first order has children, then the corresponding value in `descriptor` is one. Otherwise, it is set to zero. Remember that arrays are appended, meaning that the index in `descriptor` corresponding to `id` in the current tree would be the size of `descriptor` before calling this method, plus `id`. @param breadthFirstIdMap maps breadth first ordering to curre ... [Truncated] """ pass def CopyStructure(self, ht): # real signature unknown; restored from __doc__ """ CopyStructure(self, ht:vtkHyperTree) -> None C++: void CopyStructure(vtkHyperTree *ht) Copy the structure by sharing the decomposition description of the tree. \pre ht_exist: ht!=nullptr """ pass def CreateInstance(self, branchFactor, dimension): # real signature unknown; restored from __doc__ """ CreateInstance(branchFactor:int, dimension:int) -> vtkHyperTree C++: static vtkHyperTree *CreateInstance( unsigned char branchFactor, unsigned char dimension) Return an instance of an implementation of a hypertree for given branch factor and dimension. Other versions of this code could be made available to meet other needs without questioning cursors and filters. Since an instance, an other instance can be creating by call the method Freeze (by default, nothing more, instance currently is returning). """ return vtkHyperTree def Freeze(self, mode): # real signature unknown; restored from __doc__ """ Freeze(self, mode:str) -> vtkHyperTree C++: virtual vtkHyperTree *Freeze(const char *mode) Return a freeze instance (a priori compact but potentially unmodifiable). This method is calling by the Squeeze method of hypertree grid. The mode parameter will allow to propose different instances. Today, there is none, the freeze call does not do anything. """ return vtkHyperTree def GetActualMemorySize(self): # real signature unknown; restored from __doc__ """ GetActualMemorySize(self) -> int C++: unsigned int GetActualMemorySize() Return memory used in kibibytes (1024 bytes). NB: Ignore the attribute array because its size is added by the data set. """ return 0 def GetActualMemorySizeBytes(self): # real signature unknown; restored from __doc__ """ GetActualMemorySizeBytes(self) -> int C++: virtual unsigned long GetActualMemorySizeBytes() Return memory used in bytes. NB: Ignore the attribute array because its size is added by the data set. """ return 0 def GetBranchFactor(self): # real signature unknown; restored from __doc__ """ GetBranchFactor(self) -> int C++: int GetBranchFactor() Return the branch factor of the tree. """ return 0 def GetDimension(self): # real signature unknown; restored from __doc__ """ GetDimension(self) -> int C++: int GetDimension() Return the spatial dimension of the tree. """ return 0 def GetElderChildIndex(self, index_parent): # real signature unknown; restored from __doc__ """ GetElderChildIndex(self, index_parent:int) -> int C++: virtual vtkIdType GetElderChildIndex( unsigned int index_parent) Return the elder child index, local index node of first child, of node, coarse cell, identified by index_parent. \pre not_valid_index_parent Public only for entry: vtkHyperTreeGridEntry, vtkHyperTreeGridGeometryEntry, vtkHyperTreeGridGeometryLevelEntry """ return 0 def GetElderChildIndexArray(self, nbElements): # real signature unknown; restored from __doc__ """ GetElderChildIndexArray(self, nbElements:int) -> Pointer C++: virtual const unsigned int *GetElderChildIndexArray( size_t &nbElements) Return the elder child index array, internals of the tree structure Should be used with great care, for consulting and not modifying. """ pass def GetGlobalIndexFromLocal(self, index): # real signature unknown; restored from __doc__ """ GetGlobalIndexFromLocal(self, index:int) -> int C++: virtual vtkIdType GetGlobalIndexFromLocal(vtkIdType index) Get the global id of a local node identified by index. Use the explicit mapping function if available or the implicit mapping build with start global index. \pre not_valid_index \pre not_positive_start_index (case implicit global index mapping) \pre not_positive_global_index (case explicit global index mapping) """ return 0 def GetGlobalIndexStart(self): # real signature unknown; restored from __doc__ """ GetGlobalIndexStart(self) -> int C++: vtkIdType GetGlobalIndexStart() Get the start global index for the current tree for implicit global index mapping. """ return 0 def GetGlobalNodeIndexMax(self): # real signature unknown; restored from __doc__ """ GetGlobalNodeIndexMax(self) -> int C++: virtual vtkIdType GetGlobalNodeIndexMax() Return the maximum value reached by global index mapping (implicit or explicit). """ return 0 def GetNumberOfChildren(self): # real signature unknown; restored from __doc__ """ GetNumberOfChildren(self) -> int C++: vtkIdType GetNumberOfChildren() Return the number of children per node of the tree. This value is branchfactoring scale spatial dimension (f^d). """ 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 GetNumberOfLeaves(self): # real signature unknown; restored from __doc__ """ GetNumberOfLeaves(self) -> int C++: vtkIdType GetNumberOfLeaves() Return the number of leaf (fine) in the tree. """ return 0 def GetNumberOfLevels(self): # real signature unknown; restored from __doc__ """ GetNumberOfLevels(self) -> int C++: unsigned int GetNumberOfLevels() Return the number of levels. """ return 0 def GetNumberOfNodes(self): # real signature unknown; restored from __doc__ """ GetNumberOfNodes(self) -> int C++: vtkIdType GetNumberOfNodes() Return the number of nodes (coarse) in the tree. """ return 0 def GetNumberOfVertices(self): # real signature unknown; restored from __doc__ """ GetNumberOfVertices(self) -> int C++: vtkIdType GetNumberOfVertices() Return the number of all vertices (coarse and fine) in the tree. """ return 0 def GetScale(self, s, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ """ GetScale(self, s:[float, float, float]) -> None C++: void GetScale(double s[3]) GetScale(self, d:int) -> float C++: double GetScale(unsigned int d) Set/Get scale of the tree in each direction for the ground level (0). """ pass def GetTreeIndex(self): # real signature unknown; restored from __doc__ """ GetTreeIndex(self) -> int C++: vtkIdType GetTreeIndex() """ return 0 def HasScales(self): # real signature unknown; restored from __doc__ """ HasScales(self) -> bool C++: bool HasScales() Return the existence scales. """ return False def Initialize(self, branchFactor, dimension, numberOfChildren): # real signature unknown; restored from __doc__ """ Initialize(self, branchFactor:int, dimension:int, numberOfChildren:int) -> None C++: void Initialize(unsigned char branchFactor, unsigned char dimension, unsigned char numberOfChildren) Restore the initial state: only one vertice is then a leaf: the root cell for the hypertree. @param branchFactor @param dimension @param numberOfChildren """ pass def InitializeForReader(self, numberOfLevels, nbVertices, nbVerticesOfLastLevel, isParent, isMasked, outIsMasked): # real signature unknown; restored from __doc__ """ InitializeForReader(self, numberOfLevels:int, nbVertices:int, nbVerticesOfLastLevel:int, isParent:vtkBitArray, isMasked:vtkBitArray, outIsMasked:vtkBitArray) -> None C++: virtual void InitializeForReader(vtkIdType numberOfLevels, vtkIdType nbVertices, vtkIdType nbVerticesOfLastLevel, vtkBitArray *isParent, vtkBitArray *isMasked, vtkBitArray *outIsMasked) Restore a state from read data, without using a cursor Call after create hypertree with initialize. @param numberOfLevels: the maximum number of levels. @param nbVertices: the number of vertices of the future tree (coarse and leaves), fixed either the information loading (for load reduction) or defined by the fixed level of reader. @param nbVerticesOfLastLevel: the number of vertices of last valid level. @param isParent: a binary decomposition tree by level with constraint all describe children. It is useless to declare all the latest values to False, especially the last level may not be defined. @param isMasked: a binary mask corresponding. It is useless to declare all the latest values to False. @param outIsMasked: the mask of hypertree grid including this hypertree which is a vtkBitArray. """ pass 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 IsGlobalIndexImplicit(self): # real signature unknown; restored from __doc__ """ IsGlobalIndexImplicit(self) -> bool C++: virtual bool IsGlobalIndexImplicit() Return if implicit global index mapping has been used. If true, the initialize has been done by SetGlobalIndexStart (one call by hypertree). If false, the initialize has been done by SetGlobalIndexFromLocal (one call by cell of hypertree). GetGlobalIndexFromLocel get the good value of global index mapping for one cell what ever the initialize metho used. """ return False def IsLeaf(self, index): # real signature unknown; restored from __doc__ """ IsLeaf(self, index:int) -> bool C++: virtual bool IsLeaf(vtkIdType index) Return if a vertice identified by index in tree as being leaf. \pre not_valid_index """ return False def IsTerminalNode(self, index): # real signature unknown; restored from __doc__ """ IsTerminalNode(self, index:int) -> bool C++: virtual bool IsTerminalNode(vtkIdType index) Return if a vertice identified by index in tree as a terminal node. For this, all childrens mus be all leaves. \pre not_valid_index \pre not_valid_child_index """ 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 NewInstance(self): # real signature unknown; restored from __doc__ """ NewInstance(self) -> vtkHyperTree C++: vtkHyperTree *NewInstance() """ return vtkHyperTree def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkHyperTree C++: static vtkHyperTree *SafeDownCast(vtkObjectBase *o) """ return vtkHyperTree def SetGlobalIndexFromLocal(self, index, global_): # real signature unknown; restored from __doc__ """ SetGlobalIndexFromLocal(self, index:int, global_:int) -> None C++: virtual void SetGlobalIndexFromLocal(vtkIdType index, vtkIdType global) Set the mapping between a node index in tree and a explicit global index mapping. This global index mapping permits to access a value of field for a cell, in explicit, the index depend of order values. For this tree, in debug, assert is calling if tried call SetGlobalIndexStart. \pre not_global_index_from_local_if_use_global_index_start """ pass def SetGlobalIndexStart(self, start): # real signature unknown; restored from __doc__ """ SetGlobalIndexStart(self, start:int) -> None C++: virtual void SetGlobalIndexStart(vtkIdType start) Set the start implicit global index mapping for the first cell in the current tree. The implicit global index mapping of a node will be computed by this start index + the node index (local offset in tree). The node index begin by 0, the origin cell in tree. The follow values are organizing by fatrie as i to i+NumberOfChildren, for all children of one coarse cell, i is 1+8*s with s in integer. The order of fatrie depend of order to call SubdivideLeaf. This global index mapping permits to access a value of field for a cell, in implicit, the order values depends of implicit order linking with the order build of this tree. WARNING: See of hypertree grid, for to use a implicit global index mapping, you have to build hypertree by hypertree without to recome in hypertree also build. For this tree, in debug, assert is calling if tried call SetGlobalIndexFromLocal. \pre not_global_index_start_if_use_global_index_from_local """ pass def SetTreeIndex(self, treeIndex): # real signature unknown; restored from __doc__ """ SetTreeIndex(self, treeIndex:int) -> None C++: void SetTreeIndex(vtkIdType treeIndex) Set/Get tree index in hypertree grid. Services for internal use between hypertree grid and hypertree. """ pass def SubdivideLeaf(self, index, level): # real signature unknown; restored from __doc__ """ SubdivideLeaf(self, index:int, level:int) -> None C++: virtual void SubdivideLeaf(vtkIdType index, unsigned int level) Subdivide a vertice, only if its a leaf. \pre not_valide_index \pre not_leaf """ 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.""" __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkHyperTree\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'Initialize\': , \'InitializeForReader\': , \'BuildFromBreadthFirstOrderDescriptor\': , \'ComputeBreadthFirstOrderDescriptor\': , \'CopyStructure\': , \'Freeze\': , \'SetTreeIndex\': , \'GetTreeIndex\': , \'GetNumberOfLevels\': , \'GetNumberOfVertices\': , \'GetNumberOfNodes\': , \'GetNumberOfLeaves\': , \'GetBranchFactor\': , \'GetDimension\': , \'GetNumberOfChildren\': , \'GetScale\': , \'CreateInstance\': , \'GetActualMemorySizeBytes\': , \'GetActualMemorySize\': , \'IsGlobalIndexImplicit\': , \'SetGlobalIndexStart\': , \'GetGlobalIndexStart\': , \'SetGlobalIndexFromLocal\': , \'GetGlobalIndexFromLocal\': , \'GetGlobalNodeIndexMax\': , \'IsLeaf\': , \'SubdivideLeaf\': , \'IsTerminalNode\': , \'GetElderChildIndex\': , \'GetElderChildIndexArray\': , \'HasScales\': , \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkHyperTree - A data object structured as a tree.\\n\\nSuperclass: vtkObject\\n\\nAn hypertree grid is a dataobject containing a rectilinear grid of\\nelements that can be either null or a hypertree. An hypertree is a\\ndataobject describing a decomposition tree. A VERTICE is an element\\nof this tree. A NODE, also called COARSE cell, is a specific vertice\\nwhich is refined and than has either exactly f^d children, where f in\\n{2,3} is the branching factor, the same value for all trees in this\\nhypertree grid, and d in {1,2,3} is the spatial dimension. It is\\ncalled coarse because there are smaller child cells. A LEAF, also\\ncalled FINE cell, is a vertice without children, not refined. It is\\ncalled fine because in the same space there are no finer cells. In a\\ntree, we can find coarse cells smaller than fine cell but not in the\\nsame space.\\n\\nSuch trees have particular names for f=2:\\n- bintree (d=1),\\n- quadtree (d=2),\\n- octree (d=3).\\n\\nThe original octree class name came from the following paper:\\n @ARTICLE{yau-srihari-1983,\\n author={Mann-May Yau and Sargur N. Srihari},\\n title={A Hierarchical Data Structure for Multidimensional Digital Images},\\n journal={Communications of the ACM},\\n month={July},\\n year={1983},\\n volume={26},\\n number={7},\\n pages={504--515}\\n }\\n \\n\\nAttributes are associated with (all) cells, not with points. The\\nattributes that are associated with coarses, it\'s used for LoD\\n(Level-of-Detail). The attributes on coarse cells can be given by the\\ncode or/and computed by the use of a specific filter exploiting the\\nvalues from its children (which can be leaves or not).\\n\\nThe geometry is implicitly given by the size of the root node on each\\naxis and position of the origin. In fact, in 3D, the geometry is then\\nnot limited to a cube but can have a rectangular shape.\\n\\nBy construction, an hypertree is efficient in memory usage. The LoD\\nfeature allows for quick culling of part of the dataobject.\\n\\nThis is an abstract class used as a superclass by a custom templated\\ncompact class. Other versions of this code could be made available to\\nmeet other needs without questioning cursors and filters. All methods\\nare pure virtual. This is done to hide templates.\\n\\n@par Case octree with f=2, d=3: For each node (coarse cell), 8\\nchildren are encoded in a child index (from 0 to 7) in the following\\norientation described in hypertree grid. It is easy to access each\\nchild as a cell of a grid. Note also that the binary representation\\nis relevant, each bit codes a side: bit 0 encodes -x side (0) or +x\\nside (1) bit 1 encodes -y side (0) or +y side (1) bit 2 encodes -z\\nside (0) or +z side (1)\\n-z side is first, in counter-clockwise order: 0: -y -x sides 1: -y +x\\nsides 2: +y -x sides 3: +y +x sides +z side is last, in\\n counter-clockwise order: 4: -y -x sides 5: -y +x sides 6: +y -x\\n sides 7: +y +x sides\\n +y\\n +-+-+ ^\\n |2|3| |\\n +-+-+ O +z +-> +x\\n |0|1|\\n +-+-+\\n +y\\n +-+-+ ^\\n |6|7| |\\n +-+-+ 1 +z +-> +x\\n |4|5|\\n +-+-+\\n \\n\\n@par Case quadtree with f=2, d=2: Just use 2 bits.\\n +y\\n +-+-+ ^\\n |2|3| |\\n +-+-+ +-> +x\\n |0|1|\\n +-+-+\\n \\n\\n@par Case bintree with f=2, d=1: Just use 1 bits.\\n O+-> +x\\n \\n\\nIt\'s more difficult with f=3.\\n\\n@par Thanks: This class was written by Philippe Pebay, Joachim\\nPouderoux, and Charles Law, Kitware 2013 This class was modified by\\nGuenole Harel and Jacques-Bernard Lekien 2014 This class was modified\\nby Philippe Pebay, 2016 Among others, this class was simplified,\\noptimized (memory), documented and completed for to improve IO XML by\\nJacques-Bernard Lekien 2018-19 This work was supported by\\nCommissariat a l\'Energie Atomique CEA, DAM, DIF, F-91297 Arpajon,\\nFrance.\\n\\n"})' __vtkname__ = 'vtkHyperTree'