目录

​

vtkDataObject  

vtkDataObject类子类

vtkAbstractElectronicData 

vtkAnnotation

 vtkAnnotationLayers

vtkArrayData***

vtkBSPCuts

 vtkCompositeDataSet

vtkDataSet

vtkGenericDataSet

vtkGraph

vtkHyperTreeGrid 

 vtkPiecewiseFunction

vtkSelection

vtkTable 

vtkAbstractAccumulator 

vtkAbstractArrayMeasurement 

vtkImageStencilData 

---

 

图 vtkSelection继承关系

vtkDataObject  

/**
 * @class   vtkDataObject
 * @brief   general representation of visualization data
 *
 * vtkDataObject is an general representation of visualization data. It serves
 * to encapsulate instance variables and methods for visualization network
 * execution, as well as representing data consisting of a field (i.e., just
 * an unstructured pile of data). This is to be compared with a vtkDataSet,
 * which is data with geometric and/or topological structure.
 *
 * vtkDataObjects are used to represent arbitrary repositories of data via the
 * vtkFieldData instance variable. These data must be eventually mapped into a
 * concrete subclass of vtkDataSet before they can actually be displayed.
 *
 * @sa
 * vtkDataSet vtkFieldData vtkDataObjectToDataSetFilter
 * vtkFieldDataToAttributeDataFilter
 */

*vtkDataObject是可视化数据的一般表示。

它用于封装用于可视化网络执行的实例变量和方法，以及表示由字段组成的数据（即，只是一堆非结构化数据）。这将与vtkDataSet进行比较，vtkDataSet是具有几何和/或拓扑结构的数据。

*vtkDataObjects通过vtkFieldData实例变量表示任意数据存储库。

这些数据必须最终映射到vtkDataSet的一个具体子类中，然后才能真正显示出来。

vtkDataObject类子类

vtkAbstractElectronicData 

/**
 * @class   vtkAbstractElectronicData
 * @brief   Provides access to and storage of
 * chemical electronic data
 *
 */

 提供化学电子数据的存取和存储

vtkAnnotation

/**
 * @class   vtkAnnotation
 * @brief   Stores a collection of annotation artifacts.
 *
 *
 * vtkAnnotation is a collection of annotation properties along with
 * an associated selection indicating the portion of data the annotation
 * refers to.
 *
 * @par Thanks:
 * Timothy M. Shead (tshead@sandia.gov) at Sandia National Laboratories
 * contributed code to this class.
 */

*vtkAnnotation是注释属性的集合，以及指示注释引用的数据部分的关联选择。*

*Timothy M. Shead(tshead@sandia.gov)桑迪亚国家实验室为这个课程贡献了代码。

 vtkAnnotationLayers

/**
 * @class   vtkAnnotationLayers
 * @brief   Stores a ordered collection of annotation sets
 *
 *
 * vtkAnnotationLayers stores a vector of annotation layers. Each layer
 * may contain any number of vtkAnnotation objects. The ordering of the
 * layers introduces a prioritization of annotations. Annotations in
 * higher layers may obscure annotations in lower layers.
 */

*vtkAnnotationLayers存储注释层的向量。

每一层可以包含任意数量的vtkAnnotation 对象。

层的排序引入了注释的优先级排序。较高层中的注释可能会模糊较低层中的注释。

vtkArrayData***

/**
 * @class   vtkArrayData
 * @brief   Pipeline data object that contains multiple vtkArray objects.
 *
 *
 * Because vtkArray cannot be stored as attributes of data objects (yet), a "carrier"
 * object is needed to pass vtkArray through the pipeline.  vtkArrayData acts as a
 * container of zero-to-many vtkArray instances, which can be retrieved via a zero-based
 * index.  Note that a collection of arrays stored in vtkArrayData may-or-may-not have related
 * types, dimensions, or extents.
 *
 * @sa
 * vtkArrayDataAlgorithm, vtkArray
 *
 * @par Thanks:
 * Developed by Timothy M. Shead (tshead@sandia.gov) at Sandia National Laboratories.
 */

 *@class vtkArrayData类

*@brief Pipeline数据对象，包含多个vtkArray对象。

*因为vtkArray还不能存储为数据对象的属性，所以需要一个“carrier”对象来通过管道传递vtkArray。

vtkArrayData充当包含零到多个vtkArray实例的容器，可以通过基于零的索引检索这些实例。

请注意，存储在vtkArrayData中的数组集合可能具有也可能不具有相关的类型、维度或范围。

*由Timothy M。谢德(tshead@sandia.gov)在桑迪亚国家实验室。

vtkArrayDataAlgorithm, vtkArray

vtkBSPCuts

/**
 * @class   vtkBSPCuts
 * @brief   This class represents an axis-aligned Binary Spatial
 *    Partitioning of a 3D space.
 *
 *
 *    This class converts between the vtkKdTree
 *    representation of a tree of vtkKdNodes (used by vtkDistributedDataFilter)
 *    and a compact array representation that might be provided by a
 *    graph partitioning library like Zoltan.  Such a representation
 *    could be used in message passing.
 *
 * @sa
 *      vtkKdTree vtkKdNode vtkDistributedDataFilter
 */

*这个类在vtkkdodes树的vtkKdTree表示（由vtkDistributedDataFilter使用）和一个紧凑的数组表示（可能由Zoltan这样的图分区库提供）之间进行转换。

这种表示可以用于消息传递。

vtkKdTree vtkKdNode vtkDistributedDataFilter

 vtkCompositeDataSet

/**
 * @class   vtkCompositeDataSet
 * @brief   abstract superclass for composite
 * (multi-block or AMR) datasets
 *
 * vtkCompositeDataSet is an abstract class that represents a collection
 * of datasets (including other composite datasets). It
 * provides an interface to access the datasets through iterators.
 * vtkCompositeDataSet provides methods that are used by subclasses to store the
 * datasets.
 * vtkCompositeDataSet provides the datastructure for a full tree
 * representation. Subclasses provide the semantics for it and control how
 * this tree is built.
 *
 * @sa
 * vtkCompositeDataIterator
 */

 复合（多块或AMR）数据集的抽象超类

*vtkCompositeDataSet是一个抽象类，它表示一组数据集（包括其他复合数据集）。

它提供了一个通过迭代器访问数据集的接口。

*vtkCompositeDataSet提供子类用来存储数据集的方法。

*vtkCompositeDataSet提供完整树表示的数据结构。

子类为它提供语义，并控制如何构建这棵树。

 vtkCompositeDataIterator

vtkDataSet

/**
 * @class   vtkDataSet
 * @brief   abstract class to specify dataset behavior
 *
 * vtkDataSet is an abstract class that specifies an interface for dataset
 * objects. vtkDataSet also provides methods to provide information about
 * the data, such as center, bounding box, and representative length.
 *
 * In vtk a dataset consists of a structure (geometry and topology) and
 * attribute data. The structure is defined implicitly or explicitly as
 * a collection of cells. The geometry of the structure is contained in
 * point coordinates plus the cell interpolation functions. The topology
 * of the dataset structure is defined by cell types and how the cells
 * share their defining points.
 *
 * Attribute data in vtk is either point data (data at points) or cell data
 * (data at cells). Typically filters operate on point data, but some may
 * operate on cell data, both cell and point data, either one, or none.
 *
 * @sa
 * vtkPointSet vtkStructuredPoints vtkStructuredGrid vtkUnstructuredGrid
 * vtkRectilinearGrid vtkPolyData vtkPointData vtkCellData
 * vtkDataObject vtkFieldData
 */

用于指定数据集行为的抽象类

*

*vtkDataSet是一个抽象类，用于指定数据集对象的接口。

vtkDataSet还提供了一些方法来提供有关数据的信息，例如中心、边界框和代表长度。

*

*在vtk中，数据集由结构（几何和拓扑）和属性数据组成。

结构被隐式或显式地定义为单元格的集合。

结构的几何图形包含在点坐标和单元插值函数中。

数据集结构的拓扑由单元类型和单元如何共享其定义点来定义。

*

*vtk中的属性数据是点数据（点处的数据）或单元数据（单元处的数据）。

通常情况下，过滤器对点数据进行操作，但有些过滤器可能对单元数据进行操作，单元数据和点数据可以是一个，也可以是无。

vtkPointSet vtkStructuredPoints vtkStructuredGrid vtkUnstructuredGrid
 vtkRectilinearGrid vtkPolyData vtkPointData vtkCellData
 vtkDataObject vtkFieldData

vtkGenericDataSet

/**
 * @class   vtkGenericDataSet
 * @brief   defines dataset interface
 *
 * In VTK, spatial-temporal data is defined in terms of a dataset. The
 * dataset consists of geometry (e.g., points), topology (e.g., cells), and
 * attributes (e.g., scalars, vectors, etc.) vtkGenericDataSet is an abstract
 * class defining this abstraction.
 *
 * Since vtkGenericDataSet provides a general interface to manipulate data,
 * algorithms that process it tend to be slower than those specialized for a
 * particular data type. For this reason, there are concrete, non-abstract
 * subclasses that represent and provide access to data more efficiently.
 * Note that filters to process this dataset type are currently found in the
 * VTK/GenericFiltering/ subdirectory.
 *
 * Unlike the vtkDataSet class, vtkGenericDataSet provides a more flexible
 * interface including support for iterators. vtkGenericDataSet is also
 * designed to interface VTK to external simulation packages without the
 * penalty of copying memory (see VTK/GenericFiltering/README.html) for
 * more information. Thus vtkGenericDataSet plays a central role in the
 * adaptor framework.
 *
 * Please note that this class introduces the concepts of "boundary cells".
 * This refers to the boundaries of a cell (e.g., face of a tetrahedron)
 * which may in turn be represented as a cell. Boundary cells are derivative
 * topological features of cells, and are therefore never explicitly
 * represented in the dataset. Often in visualization algorithms, looping
 * over boundaries (edges or faces) is employed, while the actual dataset
 * cells may not traversed. Thus there are methods to loop over these
 * boundary cells.
 *
 * Finally, as a point of clarification, points are not the same as vertices.
 * Vertices refer to points, and points specify a position is space. Vertices
 * are a type of 0-D cell. Also, the concept of a DOFNode, which is where
 * coefficients for higher-order cells are kept, is a new concept introduced
 * by the adaptor framework (see vtkGenericAdaptorCell for more information).
 *
 * @sa
 * vtkGenericAdaptorCell vtkDataSet
 */

在VTK中，时空数据是根据数据集定义的。

数据集由几何（如点）、拓扑（如单元）和属性（如标量、向量等）组成。vtkGenericDataSet是定义这种抽象的抽象类。

*

*由于vtkGenericDataSet提供了一个通用接口来操作数据，因此处理数据的算法往往比为特定数据类型专门化的算法慢。

因此，有一些具体的、非抽象的子类可以更有效地表示和提供对数据的访问。

*请注意，处理此数据集类型的筛选器当前位于VTK/GenericFiltering/子目录中。

*

*与vtkDataSet类不同，vtkGenericDataSet提供了更灵活的接口，包括对迭代器的支持。

vtkGenericDataSet还设计用于将VTK连接到外部模拟包，而无需复制内存（请参阅VTK/GenericFiltering/README.html）以获取更多信息。因此，vtkGenericDataSet在适配器框架中起着核心作用。

*

*请注意，本课程介绍了“边界单元”的概念。

*这是指一个单元的边界（例如四面体的面），它又可以表示为一个单元。边界单元是单元的派生拓扑特征，因此从不在数据集中显

 vtkGenericAdaptorCell vtkDataSet

vtkGraph

/**
 * @class   vtkGraph
 * @brief   Base class for graph data types.
 *
 *
 * vtkGraph is the abstract base class that provides all read-only API for graph
 * data types. A graph consists of a collection of vertices and a
 * collection of edges connecting pairs of vertices. The vtkDirectedGraph
 * subclass represents a graph whose edges have inherent order from source
 * vertex to target vertex, while vtkUndirectedGraph is a graph whose edges
 * have no inherent ordering.
 *
 * Graph vertices may be traversed in two ways. In the current implementation,
 * all vertices are assigned consecutive ids starting at zero, so they may
 * be traversed in a simple for loop from 0 to graph->GetNumberOfVertices() - 1.
 * You may alternately create a vtkVertexListIterator and call graph->GetVertices(it).
 * it->Next() will return the id of the next vertex, while it->HasNext() indicates
 * whether there are more vertices in the graph.
 * This is the preferred method, since in the future graphs may support filtering
 * or subsetting where the vertex ids may not be contiguous.
 *
 * Graph edges must be traversed through iterators. To traverse all edges
 * in a graph, create an instance of vtkEdgeListIterator and call graph->GetEdges(it).
 * it->Next() returns lightweight vtkEdgeType structures, which contain the public
 * fields Id, Source and Target. Id is the identifier for the edge, which may
 * be used to look up values in assiciated edge data arrays. Source and Target
 * store the ids of the source and target vertices of the edge. Note that the
 * edge list iterator DOES NOT necessarily iterate over edges in order of ascending
 * id. To traverse edges from wrapper code (Python, Java), use
 * it->NextGraphEdge() instead of it->Next().  This will return a heavyweight,
 * wrappable vtkGraphEdge object, which has the same fields as vtkEdgeType
 * accessible through getter methods.
 *
 * To traverse all edges outgoing from a vertex, create a vtkOutEdgeIterator and
 * call graph->GetOutEdges(v, it). it->Next() returns a lightweight vtkOutEdgeType
 * containing the fields Id and Target. The source of the edge is always the
 * vertex that was passed as an argument to GetOutEdges().
 * Incoming edges may be similarly traversed with vtkInEdgeIterator, which returns
 * vtkInEdgeType structures with Id and Source fields.
 * Both vtkOutEdgeIterator and vtkInEdgeIterator also provide the wrapper functions
 * NextGraphEdge() which return vtkGraphEdge objects.
 *
 * An additional iterator, vtkAdjacentVertexIterator can traverse outgoing vertices
 * directly, instead needing to parse through edges. Initialize the iterator by
 * calling graph->GetAdjacentVertices(v, it).
 *
 * vtkGraph has two instances of vtkDataSetAttributes for associated
 * vertex and edge data. It also has a vtkPoints instance which may store
 * x,y,z locations for each vertex. This is populated by filters such as
 * vtkGraphLayout and vtkAssignCoordinates.
 *
 * All graph types share the same implementation, so the structure of one
 * may be shared among multiple graphs, even graphs of different types.
 * Structures from vtkUndirectedGraph and vtkMutableUndirectedGraph may be
 * shared directly.  Structures from vtkDirectedGraph, vtkMutableDirectedGraph,
 * and vtkTree may be shared directly with the exception that setting a
 * structure to a tree requires that a "is a tree" test passes.
 *
 * For graph types that are known to be compatible, calling ShallowCopy()
 * or DeepCopy() will work as expected.  When the outcome of a conversion
 * is unknown (i.e. setting a graph to a tree), CheckedShallowCopy() and
 * CheckedDeepCopy() exist which are identical to ShallowCopy() and DeepCopy(),
 * except that instead of emitting an error for an incompatible structure,
 * the function returns false.  This allows you to programmatically check
 * structure compatibility without causing error messages.
 *
 * To construct a graph, use vtkMutableDirectedGraph or
 * vtkMutableUndirectedGraph. You may then use CheckedShallowCopy
 * to set the contents of a mutable graph type into one of the non-mutable
 * types vtkDirectedGraph, vtkUndirectedGraph.
 * To construct a tree, use vtkMutableDirectedGraph, with directed edges
 * which point from the parent to the child, then use CheckedShallowCopy
 * to set the structure to a vtkTree.
 *
 * @warning
 * All copy operations implement copy-on-write. The structures are initially
 * shared, but if one of the graphs is modified, the structure is copied
 * so that to the user they function as if they were deep copied. This means
 * that care must be taken if different threads are accessing different graph
 * instances that share the same structure. Race conditions may develop if
 * one thread is modifying the graph at the same time that another graph is
 * copying the structure.
 *
 * @par Vertex pedigree IDs:
 * The vertices in a vtkGraph can be associated with pedigree IDs
 * through GetVertexData()->SetPedigreeIds. In this case, there is a
 * 1-1 mapping between pedigree Ids and vertices. One can query the
 * vertex ID based on the pedigree ID using FindVertex, add new
 * vertices by pedigree ID with AddVertex, and add edges based on the
 * pedigree IDs of the source and target vertices. For example,
 * AddEdge("Here", "There") will find (or add) vertices with pedigree
 * ID "Here" and "There" and then introduce an edge from "Here" to
 * "There".
 *
 * @par Vertex pedigree IDs:
 * To configure the vtkGraph with a pedigree ID mapping, create a
 * vtkDataArray that will store the pedigree IDs and set that array as
 * the pedigree ID array for the vertices via
 * GetVertexData()->SetPedigreeIds().
 *
 *
 * @par Distributed graphs:
 * vtkGraph instances can be distributed across multiple machines, to
 * allow the construction and manipulation of graphs larger than a
 * single machine could handle. A distributed graph will typically be
 * distributed across many different nodes within a cluster, using the
 * Message Passing Interface (MPI) to allow those cluster nodes to
 * communicate.
 *
 * @par Distributed graphs:
 * An empty vtkGraph can be made into a distributed graph by attaching
 * an instance of a vtkDistributedGraphHelper via the
 * SetDistributedGraphHelper() method. To determine whether a graph is
 * distributed or not, call GetDistributedGraphHelper() and check
 * whether the result is non-nullptr. For a distributed graph, the number
 * of processors across which the graph is distributed can be
 * retrieved by extracting the value for the DATA_NUMBER_OF_PIECES key
 * in the vtkInformation object (retrieved by GetInformation())
 * associated with the graph. Similarly, the value corresponding to
 * the DATA_PIECE_NUMBER key of the vtkInformation object describes
 * which piece of the data this graph instance provides.
 *
 * @par Distributed graphs:
 * Distributed graphs behave somewhat differently from non-distributed
 * graphs, and will require special care. In a distributed graph, each
 * of the processors will contain a subset of the vertices in the
 * graph. That subset of vertices can be accessed via the
 * vtkVertexListIterator produced by GetVertices().
 * GetNumberOfVertices(), therefore, returns the number of vertices
 * stored locally: it does not account for vertices stored on other
 * processors. A vertex (or edge) is identified by both the rank of
 * its owning processor and by its index within that processor, both
 * of which are encoded within the vtkIdType value that describes that
 * vertex (or edge). The owning processor is a value between 0 and
 * P-1, where P is the number of processors across which the vtkGraph
 * has been distributed. The local index will be a value between 0 and
 * GetNumberOfVertices(), for vertices, or GetNumberOfEdges(), for
 * edges, and can be used to access the local parts of distributed
 * data arrays. When given a vtkIdType identifying a vertex, one can
 * determine the owner of the vertex with
 * vtkDistributedGraphHelper::GetVertexOwner() and the local index
 * with vtkDistributedGraphHelper::GetVertexIndex(). With edges, the
 * appropriate methods are vtkDistributedGraphHelper::GetEdgeOwner()
 * and vtkDistributedGraphHelper::GetEdgeIndex(), respectively. To
 * construct a vtkIdType representing either a vertex or edge given
 * only its owner and local index, use
 * vtkDistributedGraphHelper::MakeDistributedId().
 *
 * @par Distributed graphs:
 * The edges in a distributed graph are always stored on the
 * processors that own the vertices named by the edge. For example,
 * given a directed edge (u, v), the edge will be stored in the
 * out-edges list for vertex u on the processor that owns u, and in
 * the in-edges list for vertex v on the processor that owns v. This
 * "row-wise" decomposition of the graph means that, for any vertex
 * that is local to a processor, that processor can look at all of the
 * incoming and outgoing edges of the graph. Processors cannot,
 * however, access the incoming or outgoing edge lists of vertex owned
 * by other processors. Vertices owned by other processors will not be
 * encountered when traversing the vertex list via GetVertices(), but
 * may be encountered by traversing the in- and out-edge lists of
 * local vertices or the edge list.
 *
 * @par Distributed graphs:
 * Distributed graphs can have pedigree IDs for the vertices in the
 * same way that non-distributed graphs can. In this case, the
 * distribution of the vertices in the graph is based on pedigree
 * ID. For example, a vertex with the pedigree ID "Here" might land on
 * processor 0 while a vertex pedigree ID "There" would end up on
 * processor 3. By default, the pedigree IDs themselves are hashed to
 * give a random (and, hopefully, even) distribution of the
 * vertices. However, one can provide a different vertex distribution
 * function by calling
 * vtkDistributedGraphHelper::SetVertexPedigreeIdDistribution.  Once a
 * distributed graph has pedigree IDs, the no-argument AddVertex()
 * method can no longer be used. Additionally, once a vertex has a
 * pedigree ID, that pedigree ID should not be changed unless the user
 * can guarantee that the vertex distribution will still map that
 * vertex to the same processor where it already resides.
 *
 * @sa
 * vtkDirectedGraph vtkUndirectedGraph vtkMutableDirectedGraph
 * vtkMutableUndirectedGraph vtkTree vtkDistributedGraphHelper
 *
 * @par Thanks:
 * Thanks to Brian Wylie, Timothy Shead, Ken Moreland of Sandia National
 * Laboratories and Douglas Gregor of Indiana University for designing these
 * classes.
 */

vtkHyperTreeGrid 

/**
 * @class   vtkHyperTreeGrid
 * @brief   A dataset containing a grid of vtkHyperTree instances
 * arranged as a rectilinear grid.
 *
 *
 * An hypertree grid is a dataset containing a rectilinear grid of root nodes,
 * each of which can be refined as a vtkHyperTree grid. This organization of the
 * root nodes allows for the definition of tree-based AMR grids that do not have
 * uniform geometry.
 * Some filters can be applied on this dataset: contour, outline, geometry.
 *
 * JB A valider la suite
 * The order and number of points must match that specified by the dimensions
 * of the grid. The point order increases in i fastest (from 0<=i<dims[0]),
 * then j (0<=j<dims[1]), then k (0<=k<dims[2]) where dims[] are the
 * dimensions of the grid in the i-j-k topological directions. The number of
 * points is dims[0]*dims[1]*dims[2]. The same is true for the cells of the
 * grid. The order and number of cells must match that specified by the
 * dimensions of the grid. The cell order increases in i fastest (from
 * 0<=i<(dims[0]-1)), then j (0<=j<(dims[1]-1)), then k (0<=k<(dims[2]-1))
 * The number of cells is (dims[0]-1)*(dims[1]-1)*(dims[2]-1).
 * JB
 * Dimensions : number of points by direction of rectilinear grid
 * CellDims : number of cells by directions of rectilinear grid
 * (1 for each dimensions 1)
 *
 * @warning
 * It is not a spatial search object. If you are looking for this kind of
 * octree see vtkCellLocator instead.
 * Extent support is not finished yet.
 *
 * @sa
 * vtkHyperTree vtkRectilinearGrid
 *
 * @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 rewritten by Philippe Pebay, 2016
 * This class was modified by Jacques-Bernard Lekien 2018
 * This work was supported by Commissariat a l'Energie Atomique
 * CEA, DAM, DIF, F-91297 Arpajon, France.
 */

 vtkPiecewiseFunction

/**
 * @class   vtkPiecewiseFunction
 * @brief   Defines a 1D piecewise function.
 *
 *
 * Defines a piecewise function mapping. This mapping allows the addition
 * of control points, and allows the user to control the function between
 * the control points. A piecewise hermite curve is used between control
 * points, based on the sharpness and midpoint parameters. A sharpness of
 * 0 yields a piecewise linear function and a sharpness of 1 yields a
 * piecewise constant function. The midpoint is the normalized distance
 * between control points at which the curve reaches the median Y value.
 * The midpoint and sharpness values specified when adding a node are used
 * to control the transition to the next node (the last node's values are
 * ignored) Outside the range of nodes, the values are 0 if Clamping is off,
 * or the nearest node point if Clamping is on. Using the legacy methods for
 * adding points  (which do not have Sharpness and Midpoint parameters)
 * will default to Midpoint = 0.5 (halfway between the control points) and
 * Sharpness = 0.0 (linear).
 */

vtkSelection

/**
 * @class vtkSelection
 * @brief data object that represents a "selection" in VTK.
 *
 * vtkSelection is a data object that represents a selection definition. It is
 * used to define the elements that are selected. The criteria of the selection
 * is defined using one or more vtkSelectionNode instances. Parameters of the
 * vtkSelectionNode define what kind of elements are being selected
 * (vtkSelectionNode::GetFieldType), how the selection criteria is defined
 * (vtkSelectionNode::GetContentType), etc.
 *
 * Filters like vtkExtractSelection, vtkExtractDataArraysOverTime can be used to
 * extract the selected elements from a dataset.
 *
 * @section CombiningSelection Combining Selections
 *
 * When a vtkSelection contains multiple vtkSelectionNode instances, the
 * selection defined is a union of all the elements identified by each of the
 * nodes.
 *
 * Optionally, one can use `vtkSelection::SetExpression` to define a boolean
 * expression to build arbitrarily complex combinations. The expression can be
 * defined using names assigned to the selection nodes when the nodes are added
 * to vtkSelection (either explicitly or automatically).
 *
 * @sa
 * vtkSelectionNode
 */

表示VTK中的“选择”的数据对象。

*vtkSelection是表示选择定义的数据对象。它用于定义选定的图元。选择的条件是使用一个或多个vtkSelectionNode实例定义的。vtkSelectionNode的参数定义要选择的元素类型（vtkSelectionNode:：GetFieldType）、如何定义选择条件（vtkSelectionNode:：GetContentType）等。

*vtkExtractSelection、vtkextractdataraystimeout等过滤器可用于从数据集中提取选定的元素。

*@节组合选择组合选择*

*当vtkSelection包含多个vtkSelectionNode实例时，定义的选择是由每个节点标识的所有元素的并集。*

*或者，可以使用“vtkSelection:：SetExpression”定义布尔表达式来构建任意复杂的组合。在将节点添加到vtkSelection（显式或自动）时，可以使用指定给选择节点的名称来定义表达式。

vtkTable 

/**
 * @class   vtkTable
 * @brief   A table, which contains similar-typed columns of data
 *
 *
 * vtkTable is a basic data structure for storing columns of data.
 * Internally, columns are stored in a vtkDataSetAttributes structure called
 * RowData. However, using the vtkTable API additionally ensures that every column
 * has the same number of entries, and provides row access (using vtkVariantArray)
 * and single entry access (using vtkVariant).
 *
 * The field data inherited from vtkDataObject may be used to store metadata
 * related to the table.
 *
 * @warning
 * You should use the vtkTable API to change the table data. Performing
 * operations on the object returned by GetRowData() may
 * yield unexpected results. vtkTable does allow the user to set the field
 * data using SetRowData(); the number of rows in the table is determined
 * by the number of tuples in the first array (it is assumed that all arrays
 * are the same length).
 *
 * @warning
 * Each column added with AddColumn <b>must</b> have its name set to a unique,
 * non-empty string in order for GetValue() to function properly.
 *
 * @par Thanks:
 * Thanks to Patricia Crossno, Ken Moreland, Andrew Wilson and Brian Wylie from
 * Sandia National Laboratories for their help in developing this class API.
 */

*vtkTable是用于存储数据列的基本数据结构。

*在内部，列存储在名为RowData的vtkDataSetAttributes结构中。但是，使用vtkTable API还可以确保每一列的条目数相同，并提供行访问（使用vtkVariantArray）和单条目访问（使用vtkVariant）。

*

*从vtkDataObject继承的字段数据可用于存储与表相关的元数据。

*

*@警告

*您应该使用vtkTable API来更改表数据。对GetRowData（）返回的对象执行操作可能会产生意外的结果。

vtkTable允许用户使用SetRowData（）设置字段数据；

表中的行数由第一个数组中的元组数决定（假定所有数组的长度相同）。

*

*@警告

*使用AddColumn<b>添加的每个列必须将其名称设置为唯一的非空字符串，以便GetValue（）正常工作。

*

*@par谢谢：

*感谢Sandia国家实验室的Patricia Crossno、Ken Moreland、Andrew Wilson和Brian Wylie在开发此类API方面的帮助 

vtkAbstractAccumulator 

/**
 * @class   vtkAbstractAccumulator
 * @brief   accumulates input data given a certain pattern
 *
 * Given input values, this class accumulates data following a certain pattern.
 * This class is typically used for array measurement inside of
 * vtkAbstractArrayMeasurement. It allows to compute estimates
 * over the array while adding values into it on the fly,
 * with the ability of computing the wanted measure in O(1)
 * at any state of the accumulator.
 *
 * Unless specified otherwise, adding a value is constant in time, as well as merging
 * accumulators of the same type.
 *
 */

给定特定模式的累积输入数据

*给定输入值，该类按照特定模式累积数据。

*此类通常用于vtkAbstractArrayMeasurement内部的阵列测量。它允许计算数组上的估计值，同时动态地向数组中添加值，

具有在累加器的任何状态下计算O（1）中所需测度的能力。

*除非另有规定，否则添加值在时间上是恒定的，以及合并相同类型的累加器。 

vtkAbstractArrayMeasurement 

/**
 * @class   vtkAbstractArrayMeasurement
 * @brief   measures quantities on arrays of values
 *
 * Given an array of data, it computes the wanted quantity over the array.
 * Data can be fed using the whole array as input, or value by value,
 * or by merging two vtkAbstractArrayMeasurement*.
 * The complexity depends on the array of vtkAbstractAccumulator*
 * used to compute the measurement. Given n inputs, if f(n) is the
 * worst complexity given used accumulators, the complexity of inserting
 * data is O(n f(n)), and the complexity for measuring already
 * inserted data is O(1), unless said otherwise.
 * Merging complexity depends on the vtkAbstractAccumulator* used.
 *
 * @note The macro vtkArrayMeasurementMacro(thisClass) assumes that each subclass
 * of vtkAbstractArrayMeasurement implements the following static methods and attributes:
 * \\code{.cpp}
 * static constexpr vtkIdType MinimumNumberOfAccumulatedData;
 * static constexpr vtkIdType NumberOfAccumulators;
 * static bool IsMeasurable(vtkIdType, double);
 * static bool Measure(vtkAbstractAccumulator**, vtkIdType, double, double&);
 * static std::vector<vtkAbstractAccumulator*> NewAccumulators();
 * \\endcode
 *
 * This macro implements the override version of each corresponding pure virtual method of this
 * class.
 *
 */

*给定一个数据数组，它计算数组上所需的数量。

*可以使用整个数组作为输入，或者逐值输入，或者合并两个vtkabstractarraymeasement*来输入数据。

*复杂性取决于用于计算测量值的vtkAbstractAccumulator数组。给定n个输入，如果f（n）是给定已用累加器的最差复杂度，则插入数据的复杂度为O（n f（n）），并且测量已插入数据的复杂度为O（1），除非另有说明。

*合并的复杂性取决于使用的vtkAbstractAccumulator*。

*@请注意，宏vtkArrayMeasurementMacro（thisClass）假定vtkabstractarraymeasement的每个子类实现以下静态方法和属性：

\\code{.cpp}
 * static constexpr vtkIdType MinimumNumberOfAccumulatedData;
 * static constexpr vtkIdType NumberOfAccumulators;
 * static bool IsMeasurable(vtkIdType, double);
 * static bool Measure(vtkAbstractAccumulator**, vtkIdType, double, double&);
 * static std::vector<vtkAbstractAccumulator*> NewAccumulators();
 * \\endcode

*此宏实现此类的每个对应纯虚拟方法的重写版本。 

vtkImageStencilData 

/**
 * @class   vtkImageStencilData
 * @brief   efficient description of an image stencil
 *
 * vtkImageStencilData describes an image stencil in a manner which is
 * efficient both in terms of speed and storage space.  The stencil extents
 * are stored for each x-row across the image (multiple extents per row if
 * necessary) and can be retrieved via the GetNextExtent() method.
 * @sa
 * vtkImageStencilSource vtkImageStencil
 */

图像模板的有效描述

*vtkImageStencilData以在速度和存储空间方面都有效的方式描述图像模板。

模具范围存储在图像的每一个x行中（如果需要，每行有多个范围），可以通过getNextEvent（）方法进行检索。

 vtkImageStencilSource vtkImageStencil