# 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 vtkSelectionNode(__vtkmodules_vtkCommonCore.vtkObject): """ vtkSelectionNode - a node in a vtkSelection the defines the selection criteria. Superclass: vtkObject vtkSelectionNode helps define the selection criteria in a vtkSelection. vtkSelection can comprise of multiple such vtkSelectionNode instances that help define the selection. vtkSelectionNode has two components: a list of properties (stored in a vtkInformation) and a selection list (a vtkAbstractArray subclass). The properties help indicate how to interpret the values specified in a selection-list. The properties can be broadly classified into three categories: core, qualifiers, and information. The core properties must be specified other wise the vtkSelectionNode is not considered valid. These are `FIELD_TYPE` and `CONTENT_TYPE`. `FIELD_TYPE` defines what kinds of entities are being selected. Since selections are used to select items in a data-object, these correspond to things like cells, points, nodes, edges, rows, etc. Supported FIELD_TYPE values are defined in `vtkSelectionNode::SelectionField`. `CONTENT_TYPE` defines the how the selection is described. Supported values are `vtkSelectionNode::SelectionContent`. For example, if CONTENT_TYPE is `INDICES`, then selection is described as ids for entities being selected. The ids themselves will be specified using the selection list. Thus, the CONTENT_TYPE dictates what the selection list comprises. Qualifiers are used to further qualify the selection criteria. All qualifiers are optional. When present they restrict the selection. For example, when selecting elements from a composite-dataset, the `COMPOSITE_INDEX` qualifier can be specified of limit the selection to a specific dataset (or subtree). Information properties are simply for informative purposes and generally used to provide information about the selection when the selection is created. For example, `PIXEL_COUNT` is used to indicate how many screen pixels resulted in creation of this selection node. @section SelectionTypes Selection Types `CONTENT_TYPE` property is one of the required properties that helps describe how the selection is defined. To set the content type, one can access the properties store using `vtkSelectionNode::GetProperties()` and then set the `CONTENT_TYPE` using the `vtkSelectionNode::CONTENT_TYPE()` key or simply use `vtkSelectionNode::SetContentType`. * `vtkSelectionNode::GLOBALIDS`: indicates that the selection is defined using global ids. In VTK data-object, global ids are specified an `vtkIdTypeArray` added to a appropriate `vtkDataSetAttributes` and marked as global-ids using vtkDataSetAttributes API. Since global ids are expected to be unique for that element type over the entire dataset, it's a convenient way of defining selections. For this content-type, the selection list must be a single-component, `vtkIdTypeArray` that lists all the globals ids for the selected elements. * `vtkSelectionNode::PEDIGREEIDS`: similar to `GLOBALIDS` except uses pedigree ids instead of global ids. * `vtkSelectionNode::VALUES`: this type is used to define a selection based on array values. The selection list specifies the values to be selected. All elements with array values in the selection list are treated as selected. The qualifier COMPONENT_NUMBER is used to indicate which component to use for the checks. Use `-1` for magnitude. Current implementation does not support checking multiple-components or non-exact matches although support for both is conceivable in future. The selection list array name is used to specify the name of the array from the dataset to use for the checks. Thus, for defining a selection for a dataset where all `TEMP` values match those specified in the selection list, ensure that the selection list array's name is set to `TEMP` as well. * `vtkSelectionNode::INDICES`: this is similar to global ids except in this case the selection list is simply the VTK element id which is 0-based index of that element in the particular dataset. Often with this type of selection, additional qualifiers such as `COMPOSITE_INDEX`, `BLOCK_SELECTORS`, `PROCESS_ID` etc. are needed to correctly identify the chosen element(s) in case of composite or distributed datasets. * `vtkSelectionNode::FRUSTUM`: this type is used to define a frustum in world coordinates that identifies the selected elements. In this case, the selection list is a vtkDoubleArray with 32 values specifying the 8 frustum corners in homogeneous world coordinates. * `vtkSelectionNode::LOCATIONS`: this is used to select points (or cells) near (or containing) specified locations. The selection list is a 3-component vtkDoubleArray with coordinates for locations of interest. * `vtkSelectionNode::THRESHOLDS`: this type is used to define a selection based on array value ranges. This is akin to thresholding. All elements with values in the specified ranges are to be treated as selected. For this content-type, the selection-list is a 2-component `vtkDataArray`-subclass that specifies where each tuple defines the min and max values for a range. The selection list can have multiple tuples to define multiple ranges. Elements with values in any of the specified ranges are treated as selected. The selection list array name is used to specify the name of the array from the dataset to use for the checks. Thus, for defining a selection for a dataset where all `TEMP` values are within a range, ensure that the selection list array's name is set to `TEMP` as well. * `vtkSelectionNode::BLOCKS`: this type is used to select blocks in a composite dataset. The term blocks is used loosely here and can correspond to a block in a multiblock dataset or a partition in a partitioned-dataset. The selection list is an integral type vtkDataArray subclass that can be 1- or 2- component. If 1-component, it's interpreted as the composite-index (also called flat index) and can be applied to any composite-dataset to choose specific datasets. If 2-component, it's typically associated with vtkUniformGridAMR or vtkPartitionedDataSetCollection which support 2-tuple indexing to locate a dataset. * `vtkSelectionNode::BLOCK_SELECTORS`: this is similar to BLOCKS, however instead of using indices to select datasets, here, the selection list is a vtkStringArray which lists selector expressions to select blocks in the composite dataset. By default, the selector expressions are applied to a vtkDataAssembly generated from the composite dataset that represents its hierarchy (see `vtkDataAssembly::GenerateHierarchy`). However, in case of vtkPartitionedDataSetCollection, one can select any other data assembly associated with the vtkPartitionedDataSetCollection by naming the array with the name of the assembly. ote, currently vtkPartitionedDataSetCollection only supports a single vtkDataAssembly but this may change in the future. * `vtkSelectionNode::QUERY`: this type is primarily added for ParaView where selection expression is specified as a query string. This is likely to change in the future and hence applications are discouraged from using this type. @section Properties Properties Following a properties that can be used to qualify the selection. * `vtkSelectionNode::EPSILON()`: this is a qualifier that can be used to indicate a fuzz-factor when comparing values for equality. Currently, this is only used with content-type LOCATIONS, however, it can be expanded to other selection types in the future. * `vtkSelectionNode::CONTAINING_CELLS()`: this qualifier is intended to be used with field-type `POINT`. When present, it indicates that while the selection criteria selects a collection of points the selection should be formed using cell containing the chosen points. * `vtkSelectionNode::CONNECTED_LAYERS()`: a qualifier used to expand the definition of selected elements to connected elements for the specified number of layers. Layers can be positive or negative to grow or shrink the selection respectively. * `vtkSelectionNode::INVERSE()`: a qualifier that causes the selection to be inverted i.e. all elements not chosen by the criteria are to be treated as selected. * `vtkSelectionNode::COMPONENT_NUMBER()`: for VALUES and THRESHOLDS selection types, this qualifier identifies the array component of interest. -1 indicates magnitude. * `vtkSelectionNode::PROCESS_ID()`: limits the selection to a particular rank in a distributed environment. * `vtkSelectionNode::COMPOSITE_INDEX()`: a qualifier used to limit the selection to a specific composite index for a composite-dataset. * `vtkSelectionNode::ASSEMBLY_NAME()`, `vtkSelectionNode::SELECTORS()`: similar to composite index, except uses data-assembly and selectors to limit the selection to a subset of nodes in a composite-dataset. * `vtkSelectionNode::HIERARCHICAL_LEVEL()`, `vtkSelectionNode::HIERARCHICAL_INDEX()`: similar to composite index, except uses level and index for an AMR dataset so limit the selection to a specific AMR level or dataset. Following for properties that are primarily intended to provide additional information when the selection is created. * `vtkSelectionNode::ZBUFFER_VALUE()`: an information qualifier representing the z-depth for a particular selection when it was created. * `vtkSelectionNode::PIXEL_COUNT()`: a qualifier used to provide a count for the number of pixels that resulted in this selection. * `vtkSelectionNode::SOURCE()`, `vtkSelectionNode::SOURCE_ID()`: provides information about data producer or selection originator. The interpretation is very specific to the creator creating the selection and varies greatly with VTK. * `vtkSelectionNode::PROP(), `vtkSelectionNode::PROP_ID()`: similar to SOURCE/SOURCE_ID except is used to represent a rendering prop from which the selection was created. @warning No SelectionList is created by default. It should be assigned. @section SelectionFieldMismatch vtkSelectionNode::SelectionField and vtkDataSetAttribute::AttributeTypes Strictly speaking, vtkSelectionNode::SelectionField maps directly to vtkDataSetAttribute::AttributeTypes. However, the two enum values are not identical for historical reasons. Use `vtkSelectionNode::ConvertSelectionFieldToAttributeType` and `vtkSelectionNode::ConvertAttributeTypeToSelectionField` to convert between the two. """ def ASSEMBLY_NAME(self): # real signature unknown; restored from __doc__ """ ASSEMBLY_NAME() -> vtkInformationStringKey C++: static vtkInformationStringKey *ASSEMBLY_NAME() Keys for selector-based identification of blocks to choose from a composite dataset. `ASSEMBLY_NAME` identifies the name for the assembly to use and `SELECTORS` provide a list of node selectors applied to the chosen assembly. Use `vtkDataAssemblyUtilities::HierarchyName` as the assembly name to use the data hierarchy """ pass def COMPONENT_NUMBER(self): # real signature unknown; restored from __doc__ """ COMPONENT_NUMBER() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *COMPONENT_NUMBER() When ContentType==THRESHOLDS or ContentType==VALUES i.e. threshold and value based selections, it is possible pick the component number using this key. If none is specified, the 0th component is used. If any number less than 0 is specified, then the magnitude is used. """ pass def COMPOSITE_INDEX(self): # real signature unknown; restored from __doc__ """ COMPOSITE_INDEX() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *COMPOSITE_INDEX() Used to identify a node in composite datasets. """ pass def CONNECTED_LAYERS(self): # real signature unknown; restored from __doc__ """ CONNECTED_LAYERS() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *CONNECTED_LAYERS() When specified, this indicates how many layers of *connected* elements in addition to those chosen explicitly are being selected. Currently, this is only supported for cells and points. """ pass def CONTAINING_CELLS(self): # real signature unknown; restored from __doc__ """ CONTAINING_CELLS() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *CONTAINING_CELLS() This flag tells the extraction filter, when FIELD_TYPE==POINT, that it should also extract the cells that contain any of the extracted points. """ pass def CONTENT_TYPE(self): # real signature unknown; restored from __doc__ """ CONTENT_TYPE() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *CONTENT_TYPE() Get the (primary) property that describes the content of a selection node's data. This key takes on values from the SelectionContent enum. GetContentType() returns -1 if the content type is not set. \sa vtkSelectionNode::SelectionContent """ pass def ConvertAttributeTypeToSelectionField(self, val): # real signature unknown; restored from __doc__ """ ConvertAttributeTypeToSelectionField(val:int) -> int C++: static int ConvertAttributeTypeToSelectionField(int val) """ return 0 def ConvertSelectionFieldToAttributeType(self, val): # real signature unknown; restored from __doc__ """ ConvertSelectionFieldToAttributeType(val:int) -> int C++: static int ConvertSelectionFieldToAttributeType(int val) Methods to convert vtkSelectionNode::SelectionField to vtkDataSetAttribute::AttributeTypes and vice-versa. """ return 0 def DeepCopy(self, src): # real signature unknown; restored from __doc__ """ DeepCopy(self, src:vtkSelectionNode) -> None C++: virtual void DeepCopy(vtkSelectionNode *src) Copy properties, selection list and children of the input. """ pass def EPSILON(self): # real signature unknown; restored from __doc__ """ EPSILON() -> vtkInformationDoubleKey C++: static vtkInformationDoubleKey *EPSILON() For location selection of points, if distance is greater than this reject. """ pass def EqualProperties(self, other, fullcompare=True): # real signature unknown; restored from __doc__ """ EqualProperties(self, other:vtkSelectionNode, fullcompare:bool=True) -> bool C++: bool EqualProperties(vtkSelectionNode *other, bool fullcompare=true) Compares Properties of self and other to ensure that they are exactly same. """ return False def FIELD_TYPE(self): # real signature unknown; restored from __doc__ """ FIELD_TYPE() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *FIELD_TYPE() Controls whether cell, point, or field data determine what is inside and out. The default is CELL. Vertex and edge types are also available for graph classes. GetFieldType() returns -1 if the field type is not set. """ pass def GetContentType(self): # real signature unknown; restored from __doc__ """ GetContentType(self) -> int C++: virtual int GetContentType() """ return 0 def GetContentTypeAsString(self, type): # real signature unknown; restored from __doc__ """ GetContentTypeAsString(type:int) -> str C++: static const char *GetContentTypeAsString(int type) Get the content type as a string. """ return "" def GetFieldType(self): # real signature unknown; restored from __doc__ """ GetFieldType(self) -> int C++: virtual int GetFieldType() """ return 0 def GetFieldTypeAsString(self, type): # real signature unknown; restored from __doc__ """ GetFieldTypeAsString(type:int) -> str C++: static const char *GetFieldTypeAsString(int type) Get the field type as a string. """ return "" def GetFieldTypeFromString(self, type): # real signature unknown; restored from __doc__ """ GetFieldTypeFromString(type:str) -> int C++: static int GetFieldTypeFromString(const char *type) Get field type from string. Returns NUM_FIELD_TYPES if not found. """ return 0 def GetMTime(self): # real signature unknown; restored from __doc__ """ GetMTime(self) -> int C++: vtkMTimeType GetMTime() override; Return the MTime taking into account changes to the properties """ 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 GetProperties(self): # real signature unknown; restored from __doc__ """ GetProperties(self) -> vtkInformation C++: virtual vtkInformation *GetProperties() Returns the property map. """ pass def GetQueryString(self): # real signature unknown; restored from __doc__ """ GetQueryString(self) -> str C++: virtual char *GetQueryString() """ return "" def GetSelectionData(self): # real signature unknown; restored from __doc__ """ GetSelectionData(self) -> vtkDataSetAttributes C++: virtual vtkDataSetAttributes *GetSelectionData() """ return vtkDataSetAttributes def GetSelectionList(self): # real signature unknown; restored from __doc__ """ GetSelectionList(self) -> vtkAbstractArray C++: virtual vtkAbstractArray *GetSelectionList() """ pass def HIERARCHICAL_INDEX(self): # real signature unknown; restored from __doc__ """ HIERARCHICAL_INDEX() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *HIERARCHICAL_INDEX() """ pass def HIERARCHICAL_LEVEL(self): # real signature unknown; restored from __doc__ """ HIERARCHICAL_LEVEL() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *HIERARCHICAL_LEVEL() Used to identify a dataset in a hiererchical box dataset. """ pass def INDEXED_VERTICES(self): # real signature unknown; restored from __doc__ """ INDEXED_VERTICES() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *INDEXED_VERTICES() @deprecated no longer relevant. """ pass def Initialize(self): # real signature unknown; restored from __doc__ """ Initialize(self) -> None C++: virtual void Initialize() Restore data object to initial state, """ pass def INVERSE(self): # real signature unknown; restored from __doc__ """ INVERSE() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *INVERSE() This flag tells the extraction filter to exclude the selection. """ 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 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) -> vtkSelectionNode C++: vtkSelectionNode *NewInstance() """ return vtkSelectionNode def PIXEL_COUNT(self): # real signature unknown; restored from __doc__ """ PIXEL_COUNT() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *PIXEL_COUNT() A helper for visible cell selector, this is the number of pixels covered by the actor whose cells are listed in the selection. """ pass def PROCESS_ID(self): # real signature unknown; restored from __doc__ """ PROCESS_ID() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *PROCESS_ID() Process id the selection is on. """ pass def PROP(self): # real signature unknown; restored from __doc__ """ PROP() -> vtkInformationObjectBaseKey C++: static vtkInformationObjectBaseKey *PROP() Pointer to the prop the selection belongs to. """ pass def PROP_ID(self): # real signature unknown; restored from __doc__ """ PROP_ID() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *PROP_ID() ID of the prop the selection belongs to. What ID means is application specific. """ pass def SafeDownCast(self, o): # real signature unknown; restored from __doc__ """ SafeDownCast(o:vtkObjectBase) -> vtkSelectionNode C++: static vtkSelectionNode *SafeDownCast(vtkObjectBase *o) """ return vtkSelectionNode def SELECTORS(self): # real signature unknown; restored from __doc__ """ SELECTORS() -> vtkInformationStringVectorKey C++: static vtkInformationStringVectorKey *SELECTORS() """ pass def SetContentType(self, type): # real signature unknown; restored from __doc__ """ SetContentType(self, type:int) -> None C++: virtual void SetContentType(int type) Get or set the content type of the selection. This is the same as setting the CONTENT_TYPE() key on the property. """ pass def SetFieldType(self, type): # real signature unknown; restored from __doc__ """ SetFieldType(self, type:int) -> None C++: virtual void SetFieldType(int type) Get or set the field type of the selection. This is the same as setting the FIELD_TYPE() key on the property. """ pass def SetQueryString(self, _arg): # real signature unknown; restored from __doc__ """ SetQueryString(self, _arg:str) -> None C++: virtual void SetQueryString(const char *_arg) Set/Get the query expression string. """ pass def SetSelectionData(self, data): # real signature unknown; restored from __doc__ """ SetSelectionData(self, data:vtkDataSetAttributes) -> None C++: virtual void SetSelectionData(vtkDataSetAttributes *data) Sets the selection table. """ pass def SetSelectionList(self, __a): # real signature unknown; restored from __doc__ """ SetSelectionList(self, __a:vtkAbstractArray) -> None C++: virtual void SetSelectionList(vtkAbstractArray *) Get/Set the selection list. The selection list is the container that stores values that indicate the selected items. What these values correspond to depends on the `ContentType`. `ContentType` may also dictate the type and form of the selection list array. """ pass def ShallowCopy(self, src): # real signature unknown; restored from __doc__ """ ShallowCopy(self, src:vtkSelectionNode) -> None C++: virtual void ShallowCopy(vtkSelectionNode *src) Copy properties, selection list and children of the input. This is a shallow copy: selection lists and pointers in the properties are passed by reference. """ pass def SOURCE(self): # real signature unknown; restored from __doc__ """ SOURCE() -> vtkInformationObjectBaseKey C++: static vtkInformationObjectBaseKey *SOURCE() Pointer to the data or algorithm the selection belongs to. """ pass def SOURCE_ID(self): # real signature unknown; restored from __doc__ """ SOURCE_ID() -> vtkInformationIntegerKey C++: static vtkInformationIntegerKey *SOURCE_ID() ID of the data or algorithm the selection belongs to. What ID means is application specific. """ pass def SubtractSelectionList(self, other): # real signature unknown; restored from __doc__ """ SubtractSelectionList(self, other:vtkSelectionNode) -> None C++: void SubtractSelectionList(vtkSelectionNode *other) Subtracts the items in the selection list, other, from this selection list. Assumes that both selections have identical properties (i.e., test with EqualProperties before using). """ pass def UnionSelectionList(self, other): # real signature unknown; restored from __doc__ """ UnionSelectionList(self, other:vtkSelectionNode) -> None C++: void UnionSelectionList(vtkSelectionNode *other) Merges the selection list between self and the other. Assumes that both has identical properties. """ pass def ZBUFFER_VALUE(self): # real signature unknown; restored from __doc__ """ ZBUFFER_VALUE() -> vtkInformationDoubleKey C++: static vtkInformationDoubleKey *ZBUFFER_VALUE() If present, closest zbuffer value of this selection """ 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.""" BLOCKS = 7 BLOCK_SELECTORS = 8 CELL = 0 EDGE = 4 FIELD = 2 FRUSTUM = 4 GLOBALIDS = 0 INDICES = 3 LOCATIONS = 5 NUM_CONTENT_TYPES = 11 NUM_FIELD_TYPES = 6 PEDIGREEIDS = 1 POINT = 1 QUERY = 9 ROW = 5 SelectionContent = None # (!) real value is "" SelectionField = None # (!) real value is "" THRESHOLDS = 6 USER = 10 VALUES = 2 VERTEX = 3 __dict__ = None # (!) real value is 'mappingproxy({\'__vtkname__\': \'vtkSelectionNode\', \'IsTypeOf\': , \'IsA\': , \'SafeDownCast\': , \'NewInstance\': , \'GetNumberOfGenerationsFromBaseType\': , \'GetNumberOfGenerationsFromBase\': , \'Initialize\': , \'SetSelectionList\': , \'GetSelectionList\': , \'SetSelectionData\': , \'GetSelectionData\': , \'GetProperties\': , \'DeepCopy\': , \'ShallowCopy\': , \'GetMTime\': , \'CONTENT_TYPE\': , \'SetContentType\': , \'GetContentType\': , \'GetContentTypeAsString\': , \'FIELD_TYPE\': , \'SetFieldType\': , \'GetFieldType\': , \'GetFieldTypeAsString\': , \'GetFieldTypeFromString\': , \'ConvertSelectionFieldToAttributeType\': , \'ConvertAttributeTypeToSelectionField\': , \'SetQueryString\': , \'GetQueryString\': , \'EPSILON\': , \'ZBUFFER_VALUE\': , \'CONTAINING_CELLS\': , \'CONNECTED_LAYERS\': , \'COMPONENT_NUMBER\': , \'INVERSE\': , \'PIXEL_COUNT\': , \'SOURCE\': , \'SOURCE_ID\': , \'PROP\': , \'PROP_ID\': , \'PROCESS_ID\': , \'ASSEMBLY_NAME\': , \'SELECTORS\': , \'COMPOSITE_INDEX\': , \'HIERARCHICAL_LEVEL\': , \'HIERARCHICAL_INDEX\': , \'INDEXED_VERTICES\': , \'UnionSelectionList\': , \'SubtractSelectionList\': , \'EqualProperties\': , \'SelectionContent\': , \'SelectionField\': , \'GLOBALIDS\': 0, \'PEDIGREEIDS\': 1, \'VALUES\': 2, \'INDICES\': 3, \'FRUSTUM\': 4, \'LOCATIONS\': 5, \'THRESHOLDS\': 6, \'BLOCKS\': 7, \'BLOCK_SELECTORS\': 8, \'QUERY\': 9, \'USER\': 10, \'NUM_CONTENT_TYPES\': 11, \'CELL\': 0, \'POINT\': 1, \'FIELD\': 2, \'VERTEX\': 3, \'EDGE\': 4, \'ROW\': 5, \'NUM_FIELD_TYPES\': 6, \'__new__\': , \'__repr__\': , \'__str__\': , \'__getattribute__\': , \'__setattr__\': , \'__delattr__\': , \'__dict__\': , \'__this__\': , \'__doc__\': "vtkSelectionNode - a node in a vtkSelection the defines the selection\\ncriteria.\\n\\nSuperclass: vtkObject\\n\\nvtkSelectionNode helps define the selection criteria in a\\nvtkSelection. vtkSelection can comprise of multiple such\\nvtkSelectionNode instances that help define the selection.\\n\\nvtkSelectionNode has two components: a list of properties (stored in\\na vtkInformation) and a selection list (a vtkAbstractArray subclass).\\nThe properties help indicate how to interpret the values specified in\\na selection-list.\\n\\nThe properties can be broadly classified into three categories: core,\\nqualifiers, and information. The core properties must be specified\\nother wise the vtkSelectionNode is not considered valid. These are\\n`FIELD_TYPE` and `CONTENT_TYPE`. `FIELD_TYPE` defines what kinds of\\nentities are being selected. Since selections are used to select\\nitems in a data-object, these correspond to things like cells,\\npoints, nodes, edges, rows, etc. Supported FIELD_TYPE values are\\ndefined in `vtkSelectionNode::SelectionField`. `CONTENT_TYPE` defines\\nthe how the selection is described. Supported values are\\n`vtkSelectionNode::SelectionContent`. For example, if CONTENT_TYPE is\\n`INDICES`, then selection is described as ids for entities being\\nselected. The ids themselves will be specified using the selection\\nlist. Thus, the CONTENT_TYPE dictates what the selection list\\ncomprises.\\n\\nQualifiers are used to further qualify the selection criteria. All\\nqualifiers are optional. When present they restrict the selection.\\nFor example, when selecting elements from a composite-dataset, the\\n`COMPOSITE_INDEX` qualifier can be specified of limit the selection\\nto a specific dataset (or subtree).\\n\\nInformation properties are simply for informative purposes and\\ngenerally used to provide information about the selection when the\\nselection is created. For example, `PIXEL_COUNT` is used to indicate\\nhow many screen pixels resulted in creation of this selection node.\\n\\n@section SelectionTypes Selection Types\\n\\n`CONTENT_TYPE` property is one of the required properties that helps\\ndescribe how the selection is defined. To set the content type, one\\ncan access the properties store using\\n`vtkSelectionNode::GetProperties()` and then set the `CONTENT_TYPE`\\nusing the `vtkSelectionNode::CONTENT_TYPE()` key or simply use\\n`vtkSelectionNode::SetContentType`.\\n\\n* `vtkSelectionNode::GLOBALIDS`: indicates that the selection is\\n defined using global ids. In VTK data-object, global ids are\\n specified an `vtkIdTypeArray` added to a appropriate\\n `vtkDataSetAttributes` and marked as global-ids using\\n vtkDataSetAttributes API. Since global ids are expected to be\\n unique for that element type over the entire dataset, it\'s a\\n convenient way of defining selections. For this content-type, the\\n selection list must be a single-component, `vtkIdTypeArray` that\\n lists all the globals ids for the selected elements.\\n\\n* `vtkSelectionNode::PEDIGREEIDS`: similar to `GLOBALIDS` except uses\\n pedigree ids instead of global ids.\\n\\n* `vtkSelectionNode::VALUES`: this type is used to define a selection\\nbased on array values. The selection list specifies the values to be\\n selected. All elements with array values in the selection list are\\n treated as selected. The qualifier COMPONENT_NUMBER is used to\\n indicate which component to use for the checks. Use `-1` for\\n magnitude. Current implementation does not support checking\\n multiple-components or non-exact matches although support for both\\n is conceivable in future. The selection list array name is used to\\n specify the name of the array from the dataset to use for the\\n checks. Thus, for defining a selection for a dataset where all\\n `TEMP` values match those specified in the selection list, ensure\\n that the selection list array\'s name is set to `TEMP` as well.\\n\\n* `vtkSelectionNode::INDICES`: this is similar to global ids except\\n in this case the selection list is simply the VTK element id which\\n is 0-based index of that element in the particular dataset. Often\\n with this type of selection, additional qualifiers such as\\n `COMPOSITE_INDEX`, `BLOCK_SELECTORS`, `PROCESS_ID` etc. are needed\\n to correctly identify the chosen element(s) in case of composite or\\ndistributed datasets.\\n\\n* `vtkSelectionNode::FRUSTUM`: this type is used to define a frustum\\n in world coordinates that identifies the selected elements. In this\\ncase, the selection list is a vtkDoubleArray with 32 values\\n specifying the 8 frustum corners in homogeneous world coordinates.\\n\\n* `vtkSelectionNode::LOCATIONS`: this is used to select points (or\\n cells) near (or containing) specified locations. The selection list\\nis a 3-component vtkDoubleArray with coordinates for locations of\\n interest.\\n\\n* `vtkSelectionNode::THRESHOLDS`: this type is used to define a\\n selection based on array value ranges. This is akin to\\n thresholding. All elements with values in the specified ranges are\\n to be treated as selected. For this content-type, the\\n selection-list is a 2-component `vtkDataArray`-subclass that\\n specifies where each tuple defines the min and max values for a\\n range. The selection list can have multiple tuples to define\\n multiple ranges. Elements with values in any of the specified\\n ranges are treated as selected. The selection list array name is\\n used to specify the name of the array from the dataset to use for\\n the checks. Thus, for defining a selection for a dataset where all\\n `TEMP` values are within a range, ensure that the selection list\\n array\'s name is set to `TEMP` as well.\\n\\n* `vtkSelectionNode::BLOCKS`: this type is used to select blocks in a\\n composite dataset. The term blocks is used loosely here and can\\n correspond to a block in a multiblock dataset or a partition in a\\n partitioned-dataset. The selection list is an integral type\\n vtkDataArray subclass that can be 1- or 2- component. If\\n 1-component, it\'s interpreted as the composite-index (also called\\n flat index) and can be applied to any composite-dataset to choose\\n specific datasets. If 2-component, it\'s typically associated with\\n vtkUniformGridAMR or vtkPartitionedDataSetCollection which support\\n 2-tuple indexing to locate a dataset.\\n\\n* `vtkSelectionNode::BLOCK_SELECTORS`: this is similar to BLOCKS,\\n however instead of using indices to select datasets, here, the\\n selection list is a vtkStringArray which lists selector expressions\\nto select blocks in the composite dataset. By default, the selector\\n expressions are applied to a vtkDataAssembly generated from the\\n composite dataset that represents its hierarchy (see\\n `vtkDataAssembly::GenerateHierarchy`). However, in case of\\n vtkPartitionedDataSetCollection, one can select any other data\\n assembly associated with the vtkPartitionedDataSetCollection by\\n naming the array with the name of the assembly.\\n\\note, currently vtkPartitionedDataSetCollection only supports a single\\n vtkDataAssembly but this may change in the future.\\n\\n* `vtkSelectionNode::QUERY`: this type is primarily added for\\n ParaView where selection expression is specified as a query string.\\nThis is likely to change in the future and hence applications are\\n discouraged from using this type.\\n\\n@section Properties Properties\\n\\nFollowing a properties that can be used to qualify the selection.\\n\\n* `vtkSelectionNode::EPSILON()`: this is a qualifier that can be used\\nto indicate a fuzz-factor when comparing values for equality.\\n Currently, this is only used with content-type LOCATIONS, however,\\n it can be expanded to other selection types in the future.\\n\\n* `vtkSelectionNode::CONTAINING_CELLS()`: this qualifier is intended\\n to be used with field-type `POINT`. When present, it indicates that\\nwhile the selection criteria selects a collection of points the\\n selection should be formed using cell containing the chosen points.\\n\\n* `vtkSelectionNode::CONNECTED_LAYERS()`: a qualifier used to expand\\n the definition of selected elements to connected elements for the\\n specified number of layers. Layers can be positive or negative to\\n grow or shrink the selection respectively.\\n\\n* `vtkSelectionNode::INVERSE()`: a qualifier that causes the\\n selection to be inverted i.e. all elements not chosen by the\\n criteria are to be treated as selected.\\n\\n* `vtkSelectionNode::COMPONENT_NUMBER()`: for VALUES and THRESHOLDS\\n selection types, this qualifier identifies the array component of\\n interest. -1 indicates magnitude.\\n\\n* `vtkSelectionNode::PROCESS_ID()`: limits the selection to a\\n particular rank in a distributed environment.\\n\\n* `vtkSelectionNode::COMPOSITE_INDEX()`: a qualifier used to limit\\n the selection to a specific composite index for a\\n composite-dataset.\\n\\n* `vtkSelectionNode::ASSEMBLY_NAME()`,\\n `vtkSelectionNode::SELECTORS()`: similar to composite index, except\\nuses data-assembly and selectors to limit the selection to a subset\\n of nodes in a composite-dataset.\\n\\n* `vtkSelectionNode::HIERARCHICAL_LEVEL()`,\\n `vtkSelectionNode::HIERARCHICAL_INDEX()`: similar to composite\\n index, except uses level and index for an AMR dataset so limit the\\n selection to a specific AMR level or dataset.\\n\\nFollowing for properties that are primarily intended to provide\\nadditional information when the selection is created.\\n\\n* `vtkSelectionNode::ZBUFFER_VALUE()`: an information qualifier\\n representing the z-depth for a particular selection when it was\\n created.\\n\\n* `vtkSelectionNode::PIXEL_COUNT()`: a qualifier used to provide a\\n count for the number of pixels that resulted in this selection.\\n\\n* `vtkSelectionNode::SOURCE()`, `vtkSelectionNode::SOURCE_ID()`:\\n provides information about data producer or selection originator.\\n The interpretation is very specific to the creator creating the\\n selection and varies greatly with VTK.\\n\\n* `vtkSelectionNode::PROP(), `vtkSelectionNode::PROP_ID()`: similar\\n to SOURCE/SOURCE_ID except is used to represent a rendering prop\\n from which the selection was created.\\n\\n@warning\\nNo SelectionList is created by default. It should be assigned.\\n\\n@section SelectionFieldMismatch vtkSelectionNode::SelectionField and\\nvtkDataSetAttribute::AttributeTypes\\n\\nStrictly speaking, vtkSelectionNode::SelectionField maps directly to\\nvtkDataSetAttribute::AttributeTypes. However, the two enum values are\\nnot identical for historical reasons. Use\\n`vtkSelectionNode::ConvertSelectionFieldToAttributeType` and\\n`vtkSelectionNode::ConvertAttributeTypeToSelectionField` to convert\\nbetween the two.\\n\\n"})' __vtkname__ = 'vtkSelectionNode'