 _ClassInfo | ClassInfo is for classes, structs, unions, and namespaces |
 _EnumInfo | EnumInfo is for enums Constants are at the same level as the Enum, not inside it |
 _FileInfo | FileInfo is for header files |
 _FunctionInfo | FunctionInfo is for functions and methods |
 _HierarchyEntry | This file contains utility functions for loading and parsing a VTK hierarchy file |
 _HierarchyInfo | All the entries from a hierarchy file |
 _ItemInfo | ItemInfo just contains an index |
 _MacroInfo | Struct to describe a preprocessor symbol |
 _OptionInfo | VtkParseMain.h provides argument parsing for the wrapper executables |
 _PreprocessInfo | Contains all symbols defined thus far (including those defined in any included header files) |
 _StringCache | StringCache provides a simple way of allocating strings centrally |
 _TemplateInfo | TemplateInfo holds template definitions |
 _UsingInfo | UsingInfo is for using directives |
 _ValueInfo | ValueInfo is for typedefs, constants, variables, function parameters, and return values |
 _vtkTclVoidFuncArg | |
 adjacency_graph_tag | |
  boost::vtkGraph_traversal_category | |
 vtkStatisticsAlgorithm::AssessFunctor | |
  vtkKMeansAssessFunctor | |
  vtkMultiCorrelativeAssessFunctor | |
 bidirectional_graph_tag | |
  boost::vtkGraph_traversal_category | |
 vtkTemporalStreamTracer::bounds | |
 BSPNode | |
 vtkMergeFields::Component | |
 vtkSplitField::Component | |
 vtkMaskFields::CopyFieldFlag | |
 DataSetsTypeBase | |
  vtkCompositeInterpolatedVelocityFieldDataSetsType | |
 boost::edge_bundle_type< vtkGraph * > | |
  boost::edge_bundle_type< vtkDirectedGraph * > | |
   boost::edge_bundle_type< vtkMutableDirectedGraph * > | |
   boost::edge_bundle_type< vtkMutableDirectedGraph *const > | |
  boost::edge_bundle_type< vtkDirectedGraph *const > | |
  boost::edge_bundle_type< vtkUndirectedGraph * > | |
   boost::edge_bundle_type< vtkMutableUndirectedGraph * > | |
   boost::edge_bundle_type< vtkMutableUndirectedGraph *const > | |
  boost::edge_bundle_type< vtkUndirectedGraph *const > | |
 edge_list_graph_tag | |
  boost::vtkGraph_traversal_category | |
 boost::edge_property< vtkGraph * > | |
 boost::edge_property_type< vtkGraph * > | |
  boost::edge_property_type< vtkDirectedGraph * > | |
   boost::edge_property_type< vtkMutableDirectedGraph * > | |
   boost::edge_property_type< vtkMutableDirectedGraph *const > | |
  boost::edge_property_type< vtkDirectedGraph *const > | |
  boost::edge_property_type< vtkUndirectedGraph * > | |
   boost::edge_property_type< vtkMutableUndirectedGraph * > | |
   boost::edge_property_type< vtkMutableUndirectedGraph *const > | |
  boost::edge_property_type< vtkUndirectedGraph *const > | |
 vtkQuadricDecimation::ErrorQuadric | |
 boost::graph_traits< vtkGraph * > | |
  boost::graph_traits< vtkDirectedGraph * > | |
   boost::graph_traits< const vtkDirectedGraph * > | |
   boost::graph_traits< vtkDirectedGraph *const > | |
   boost::graph_traits< vtkMutableDirectedGraph * > | |
    boost::graph_traits< const vtkMutableDirectedGraph * > | |
    boost::graph_traits< vtkMutableDirectedGraph *const > | |
   boost::graph_traits< vtkTree * > | |
    boost::graph_traits< const vtkTree * > | |
    boost::graph_traits< vtkTree *const > | |
  boost::graph_traits< vtkUndirectedGraph * > | |
   boost::graph_traits< const vtkUndirectedGraph * > | |
   boost::graph_traits< vtkMutableUndirectedGraph * > | |
    boost::graph_traits< const vtkMutableUndirectedGraph * > | |
    boost::graph_traits< vtkMutableUndirectedGraph *const > | |
   boost::graph_traits< vtkUndirectedGraph *const > | |
 boost::hash< vtkEdgeType > | |
 vtkGenericStreamTracer::IntervalInformation | |
 vtkStreamTracer::IntervalInformation | |
 iterator_facade | |
  boost::vtk_edge_iterator | |
  boost::vtk_in_edge_pointer_iterator | |
  boost::vtk_out_edge_pointer_iterator | |
  boost::vtk_vertex_iterator | |
 IVFDataSetInfo | |
 vtkDecimatePro::LocalTri | |
 vtkDecimatePro::LocalVertex | |
 vtkMultiThreshold::NormKey | A class with comparison operator used to index input array norms used in threshold rules |
 vtkRearrangeFields::Operation | |
 vtkParticleTracerBaseNamespace::ParticleInformation | |
 vtkTemporalStreamTracerNamespace::ParticleInformation | |
 ParticlePathFilterInternal | |
 vtkQuadricClustering::PointQuadric | |
 vtkParticleTracerBaseNamespace::Position | |
 vtkTemporalStreamTracerNamespace::Position | |
 boost::graph::parallel::process_group_type< vtkGraph * > | |
  boost::graph::parallel::process_group_type< vtkDirectedGraph * > | |
   boost::graph::parallel::process_group_type< vtkDirectedGraph *const > | |
  boost::graph::parallel::process_group_type< vtkUndirectedGraph * > | |
   boost::graph::parallel::process_group_type< vtkUndirectedGraph *const > | |
 boost::property_map< vtkGraph *, edge_global_t > | |
 boost::property_map< vtkGraph *, edge_index_t > | |
  boost::property_map< vtkDirectedGraph *, edge_index_t > | |
   boost::property_map< vtkDirectedGraph *const, edge_index_t > | |
  boost::property_map< vtkUndirectedGraph *, edge_index_t > | |
   boost::property_map< vtkUndirectedGraph *const, edge_index_t > | |
 boost::property_map< vtkGraph *, vertex_global_t > | |
 boost::property_map< vtkGraph *, vertex_index_t > | |
  boost::property_map< vtkDirectedGraph *, vertex_index_t > | |
   boost::property_map< vtkDirectedGraph *const, vertex_index_t > | |
  boost::property_map< vtkUndirectedGraph *, vertex_index_t > | |
   boost::property_map< vtkUndirectedGraph *const, vertex_index_t > | |
 boost::property_map< vtkGraph *, vertex_local_t > | |
 boost::property_map< vtkGraph *, vertex_owner_t > | |
 boost::property_traits< typename > | |
 boost::property_traits< vtkAbstractArray * > | |
 boost::property_traits< vtkDataArray * > | |
 boost::property_traits< vtkEdgeGlobalMap > | |
 boost::property_traits< vtkGraphEdgeMap > | |
 boost::property_traits< vtkGraphIndexMap > | |
 boost::property_traits< vtkVertexGlobalMap > | |
 boost::property_traits< vtkVertexLocalMap > | |
 boost::property_traits< vtkVertexOwnerMap > | |
 QObject | |
  vtkQtView | Superclass for Qt widget-based views |
   vtkQtAnnotationView | A VTK view that displays the annotations on its annotation link |
   vtkQtListView | A VTK view based on a Qt List view |
   vtkQtRecordView | Superclass for QAbstractItemView-based views |
   vtkQtTableView | A VTK view based on a Qt Table view |
   vtkQtTreeView | A VTK view based on a Qt tree view |
 vtkPParticleTracerBase::RemoteParticleInfo | |
 vtkMultiThreshold::Set | A base class for representing threshold sets |
  vtkMultiThreshold::BooleanSet | A subset of a mesh represented as a boolean set operation |
  vtkMultiThreshold::Interval | A subset of a mesh represented by a range of acceptable attribute values |
 StreaklineFilterInternal | |
 vtkStreamer::StreamArray | |
 vtkStreamer::StreamPoint | |
 vtkDecimatePro::TriArray | |
 vector | |
  IVFCacheList | |
 boost::vertex_bundle_type< vtkGraph * > | |
  boost::vertex_bundle_type< vtkDirectedGraph * > | |
   boost::vertex_bundle_type< vtkMutableDirectedGraph * > | |
   boost::vertex_bundle_type< vtkMutableDirectedGraph *const > | |
  boost::vertex_bundle_type< vtkDirectedGraph *const > | |
  boost::vertex_bundle_type< vtkUndirectedGraph * > | |
   boost::vertex_bundle_type< vtkMutableUndirectedGraph * > | |
   boost::vertex_bundle_type< vtkMutableUndirectedGraph *const > | |
  boost::vertex_bundle_type< vtkUndirectedGraph *const > | |
 vertex_list_graph_tag | |
  boost::vtkGraph_traversal_category | |
 boost::vertex_property< vtkGraph * > | |
 boost::vertex_property_type< vtkGraph * > | |
  boost::vertex_property_type< vtkDirectedGraph * > | |
   boost::vertex_property_type< vtkMutableDirectedGraph * > | |
   boost::vertex_property_type< vtkMutableDirectedGraph *const > | |
  boost::vertex_property_type< vtkDirectedGraph *const > | |
  boost::vertex_property_type< vtkUndirectedGraph * > | |
   boost::vertex_property_type< vtkMutableUndirectedGraph * > | |
   boost::vertex_property_type< vtkMutableUndirectedGraph *const > | |
  boost::vertex_property_type< vtkUndirectedGraph *const > | |
 vtkDecimatePro::VertexArray | |
 vtkView::ViewProgressEventCallData | |
 vtkAbstractCellLocator | |
  vtkCellTreeLocator | This class implements the data structures, construction algorithms for fast cell location presented in "Fast, Memory-Efficient Cell
location in Unstructured Grids for Visualization" by Christop Garth and Kenneth I. Joy in VisWeek, 2011 |
  vtkModifiedBSPTree | Generate axis aligned BBox tree for raycasting and other Locator based searches |
  vtkOBBTree | Generate oriented bounding box (OBB) tree |
 vtkAbstractElectronicData | |
  vtkOpenQubeElectronicData | Provides access to and storage of electronic data calculated by OpenQube |
  vtkProgrammableElectronicData | Provides access to and storage of user-generated vtkImageData that describes electrons |
 vtkAlgorithm | |
  vtkImageStencilAlgorithm | Producer of vtkImageStencilData |
   vtkImageStencilSource | Generate an image stencil |
    vtkImplicitFunctionToImageStencil | Clip an image with a function |
    vtkLassoStencilSource | Create a stencil from a contour |
    vtkPolyDataToImageStencil | Use polydata to mask an image |
    vtkROIStencilSource | Create simple mask shapes |
   vtkImageToImageStencil | Clip an image with a mask image |
  vtkMoleculeAlgorithm | Superclass for algorithms that operate on vtkMolecules |
   vtkCMLMoleculeReader | Read a CML file and output a vtkMolecule object |
   vtkSimpleBondPerceiver | Create a simple guess of a molecule's topology |
  vtkPieceRequestFilter | Sets the piece request for upstream filters |
  vtkRenderLargeImage | Use tiling to generate a large rendering |
  vtkStreamerBase | Superclass for filters that stream input pipeline |
   vtkPolyDataStreamer | Streamer appends input pieces to the output |
  vtkTemporalDataSetCache | Cache time steps |
  vtkTemporalFractal | A source to test AMR data object |
  vtkTemporalShiftScale | Modify the time range/steps of temporal data |
  vtkTemporalSnapToTimeStep | Modify the time range/steps of temporal data |
  vtkTransformToGrid | Create a grid for a vtkGridTransform |
 vtkAnnotationLayersAlgorithm | |
  vtkAnnotationLink | An algorithm for linking annotations among objects |
 vtkArrayDataAlgorithm | |
  vtkArrayNorm | Computes L-norms along one dimension of an array |
  vtkBoostLogWeighting | Given an arbitrary-dimension array of doubles, replaces each value x with one of: |
  vtkBoostRandomSparseArraySource | Generates a sparse N-way array containing random values |
  vtkDiagonalMatrixSource | Generates a sparse or dense square matrix with user-specified values for the diagonal, superdiagonal, and subdiagonal |
  vtkExtractArray | Given a vtkArrayData object containing one-or-more vtkArray instances, produces a vtkArrayData containing just one vtkArray, indentified by index |
  vtkMatricizeArray | Convert an array of arbitrary dimensions to a matrix |
  vtkNormalizeMatrixVectors | Given a sparse input matrix, produces a sparse output matrix with each vector normalized to unit length with respect to a p-norm (default p=2) |
  vtkTableToArray | Converts a vtkTable to a matrix |
  vtkTableToSparseArray | Converts a vtkTable into a sparse array |
  vtkTransposeMatrix | Computes the transpose of an input matrix |
 vtkBlockDistribution | A helper class that manages a block distribution of N elements of data |
 vtkBridgeExport | Manage Windows system differences |
 vtkCellTreeLocator::vtkCellTree | |
 vtkCellTreeLocator::vtkCellTreeNode | |
 vtkCommand | |
  vtkJavaCommand | |
  vtkPythonCommand | |
  vtkTclCommand | |
  vtkTest::ErrorObserver | |
 vtkCompositeDataSetAlgorithm | |
  vtkAppendCompositeDataLeaves | Appends one or more composite datasets with the same structure together into a single output composite dataset |
  vtkExtractPiece | |
 vtkContextItem | |
  vtkGraphItem | A 2D graphics item for rendering a graph |
  vtkTreeHeatmapItem | A 2D graphics item for rendering a tree and an associated heatmap |
 vtkContourHelper | A utility class used by various contour filters |
 vtkDataObject | |
  vtkImageStencilData | Efficient description of an image stencil |
 vtkDataObjectAlgorithm | |
  vtkAreaContourSpectrumFilter | Compute an approximation of the area contour signature (evolution of the area of the input surface along an arc of the Reeb graph) |
  vtkDataObjectGenerator | Produces simple (composite or atomic) data sets for testing |
  vtkDataSetToDataObjectFilter | Map dataset into data object (i.e., a field) |
  vtkDistributedDataFilter | Distribute data among processors |
  vtkExtractSelectionBase | Abstract base class for all extract selection filters |
   vtkExtractSelectedBlock | |
   vtkExtractSelectedFrustum | Returns the portion of the input dataset that lies within a selection frustum |
   vtkExtractSelectedIds | Extract a list of cells from a dataset |
   vtkExtractSelectedLocations | Extract cells within a dataset that contain the locations listen in the vtkSelection |
   vtkExtractSelectedThresholds | Extract a cells or points from a dataset that have values within a set of thresholds |
   vtkExtractSelection | Extract a subset from a vtkDataSet |
   vtkProbeSelectedLocations | Similar to vtkExtractSelectedLocations except that it interpolates the point attributes at the probe locations |
  vtkGenerateIndexArray | |
  vtkImageDataToUniformGrid | Convert vtkImageData to vtkUniformGrid |
  vtkPassArrays | Passes a subset of arrays to the output |
  vtkProgrammableDataObjectSource | Generate source data object via a user-specified function |
  vtkRCalculatorFilter | |
  vtkReebGraphSurfaceSkeletonFilter | Compute a skeletal embedding of the Reeb graph of a scalar field defined on a triangulated surface (vtkPolyData) |
  vtkReebGraphVolumeSkeletonFilter | Compute a skeletal embedding of the Reeb graph of a scalar field defined on a tetrahedral mesh (vtkUnstructuredGrid) |
  vtkReflectionFilter | Reflects a data set across a plane |
   vtkPReflectionFilter | Parallel version of vtkReflectionFilter |
  vtkStringToCategory | Creates a category array from a string array |
  vtkStringToNumeric | Converts string arrays to numeric arrays |
  vtkVolumeContourSpectrumFilter | Compute an approximation of the volume contour signature (evolution of the volume of the input tet-mesh along an arc of the Reeb graph) |
 vtkDataReader | |
  vtkOpenQubeMoleculeSource | Read a OpenQube readable file and output a vtkMolecule object |
 vtkDataSetAlgorithm | |
  vtkArrayCalculator | Perform mathematical operations on data in field data arrays |
  vtkAttributeDataToFieldDataFilter | Map attribute data to field data |
  vtkBrownianPoints | Assign random vector to points |
  vtkCellDataToPointData | Map cell data to point data |
   vtkPCellDataToPointData | Compute point arrays from cell arrays |
  vtkCellDerivatives | Compute derivatives of scalars and vectors |
  vtkCellQuality | Calculate functions of quality of the elements of a mesh |
  vtkDataObjectToDataSetFilter | Map field data to concrete dataset |
  vtkDataSetGradient | Computes scalar field gradient |
  vtkDataSetGradientPrecompute | |
  vtkDicer | Abstract superclass to divide dataset into pieces |
   vtkOBBDicer | Divide dataset into spatially aggregated pieces |
  vtkElevationFilter | Generate scalars along a specified direction |
  vtkExtractTensorComponents | Extract parts of tensor and create a scalar, vector, normal, or texture coordinates |
  vtkExtractVectorComponents | Extract components of vector as separate scalars |
  vtkFieldDataToAttributeDataFilter | Map field data to dataset attribute data |
  vtkGenericProbeFilter | Sample data values at specified point locations |
  vtkGradientFilter | A general filter for gradient estimation |
  vtkHyperOctreeDepth | Assign tree depth attribute to each cell |
  vtkHyperOctreeLimiter | Limit the tree's depth, averaging data from lower level branches into the new leaves at the cut points |
  vtkIdFilter | Generate scalars or field data from point and cell ids |
  vtkImplicitTextureCoords | Generate 1D, 2D, or 3D texture coordinates based on implicit function(s) |
  vtkInterpolateDataSetAttributes | Interpolate scalars, vectors, etc. and other dataset attributes |
  vtkMaskFields | Allow control of which fields get passed to the output |
  vtkMatrixMathFilter | Calculate functions of quality of the elements of a mesh |
  vtkMergeDataObjectFilter | Merge dataset and data object field to create dataset with attribute data |
  vtkMergeFields | Merge multiple fields into one |
  vtkMergeFilter | Extract separate components of data from different datasets |
  vtkMeshQuality | Calculate functions of quality of the elements |
  vtkPassThroughFilter | Filter which shallow copies it's input to it's output |
  vtkPieceScalars | Sets all cell scalars from the update piece |
  vtkPointDataToCellData | Map point data to cell data |
  vtkProbeFilter | Sample data values at specified point locations |
   vtkCompositeDataProbeFilter | Subclass of vtkProbeFilter which supports composite datasets in the input |
    vtkPProbeFilter | Probe dataset in parallel |
  vtkProbePolyhedron | Probe/interpolate data values in the interior, exterior or of the surface of a closed, manifold polyhedron |
  vtkProcessIdScalars | Sets cell or point scalars to the processor rank |
  vtkProgrammableAttributeDataFilter | Manipulate attribute (cell and point) data via a user-specified function |
  vtkProgrammableSource | Generate source dataset via a user-specified function |
  vtkProjectedTexture | Assign texture coordinates for a projected texture |
  vtkQuadraturePointInterpolator | |
  vtkQuadratureSchemeDictionaryGenerator | |
  vtkRandomAttributeGenerator | Generate and create random data attributes |
  vtkRearrangeFields | Move/copy fields between field data, point data and cell data |
  vtkSelectEnclosedPoints | Mark points as to whether they are inside a closed surface |
  vtkSimpleElevationFilter | Generate scalars along a specified direction |
  vtkSplitField | Split a field into single component fields |
  vtkTextureMapToCylinder | Generate texture coordinates by mapping points to cylinder |
  vtkTextureMapToPlane | Generate texture coordinates by mapping points to plane |
  vtkTextureMapToSphere | Generate texture coordinates by mapping points to sphere |
  vtkThresholdTextureCoords | Compute 1D, 2D, or 3D texture coordinates based on scalar threshold |
  vtkTransformTextureCoords | Transform (scale, rotate, translate) texture coordinates |
  vtkVectorDot | Generate scalars from dot product of vectors and normals (e.g., show displacement plot) |
  vtkVectorNorm | Generate scalars from Euclidean norm of vectors |
 vtkDescriptiveStatisticsGnu | A class for univariate descriptive statistics using R to calculate p-values |
 vtkDijkstraGraphInternals | Helper class due to PIMPL excess |
 vtkDirectedGraph | |
 vtkDirectedGraphAlgorithm | |
  vtkBoostDividedEdgeBundling | Layout graph edges in directed edge bundles |
  vtkPipelineGraphSource | Graph constructed from a VTK pipeline |
  vtkPolyDataToReebGraphFilter | Generate a Reeb graph from a scalar field defined on a vtkPolyData |
  vtkReebGraphSimplificationFilter | Simplify an input Reeb graph |
  vtkReebGraphToJoinSplitTreeFilter | Converts a given Reeb graph either to a join tree or a split tree (respectively the connectivity of the sub- and sur- level sets). Note: if you want to use simplification filters, do so on the input Reeb graph first |
  vtkUnstructuredGridToReebGraphFilter | Generate a Reeb graph from a scalar field defined on a vtkUnstructuredGrid |
 vtkDistributedEdgePropertyMapType< DataArray > | |
 vtkDistributedGraphHelper | |
  vtkPBGLDistributedGraphHelper | End namespace boost::graph::distributed |
 vtkDistributedVertexPropertyMapType< DataArray > | |
 boost::vtkEdgeGlobalMap | |
 vtkFastGeomQuadStruct | |
 vtkFunctionSet | |
  vtkAbstractInterpolatedVelocityField | An abstract class for obtaining the interpolated velocity values at a point |
   vtkAMRInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point in AMR data |
   vtkCompositeInterpolatedVelocityField | An abstract class for obtaining the interpolated velocity values at a point |
    vtkCellLocatorInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point |
    vtkInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point |
  vtkCachingInterpolatedVelocityField | Interface for obtaining interpolated velocity values |
  vtkTemporalInterpolatedVelocityField | A helper class for interpolating between times during particle tracing |
 vtkGenericAdaptorCell | |
  vtkBridgeCell | Implementation of vtkGenericAdaptorCell |
 vtkGenericCellIterator | |
  vtkBridgeCellIterator | Implementation of vtkGenericCellIterator. It is just an example that show how to implement the Generic API. It is also used for testing and evaluating the Generic framework |
  vtkBridgeCellIteratorStrategy | Interface used by vtkBridgeCellIterator vtkBridgeCellIterator has different behaviors depending on the way it is initialized. vtkBridgeCellIteratorStrategy is the interface for one of those behaviors. Concrete classes are vtkBridgeCellIteratorOnDataSet, vtkBridgeCellIteratorOnDataSetBoundaries, vtkBridgeCellIteratorOnCellBoundaries, vtkBridgeCellIteratorOnCellNeighbors, |
   vtkBridgeCellIteratorOnCellList | Iterate over a list of cells defined on a dataset. See InitWithCells() |
   vtkBridgeCellIteratorOnDataSet | Iterate over cells of a dataset |
   vtkBridgeCellIteratorOne | Iterate over one cell only of a dataset |
 vtkGenericDataSet | |
  vtkBridgeDataSet | Implementation of vtkGenericDataSet |
 vtkGenericPointIterator | |
  vtkBridgePointIterator | Implementation of vtkGenericPointIterator |
  vtkBridgePointIteratorOnCell | Implementation of vtkGenericPointIterator |
  vtkBridgePointIteratorOnDataSet | Implementation of vtkGenericPointIterator |
  vtkBridgePointIteratorOne | Iterate over one point of a dataset |
 vtkGraphAlgorithm | |
  vtkBoostBetweennessClustering | Implements graph clustering based on edge betweenness centrality |
  vtkBoostBrandesCentrality | Compute Brandes betweenness centrality on a vtkGraph |
  vtkBoostBreadthFirstSearch | Boost breadth_first_search on a vtkGraph |
  vtkBoostConnectedComponents | Find the connected components of a graph |
  vtkBoostExtractLargestComponent | Extract the largest connected component of a graph |
  vtkCollapseGraph | "Collapses" vertices onto their neighbors |
  vtkCollapseVerticesByArray | Collapse the graph given a vertex array |
  vtkCollectGraph | Collect distributed graph |
  vtkEdgeLayout | Layout graph edges |
  vtkExtractSelectedGraph | Return a subgraph of a vtkGraph |
  vtkGraphHierarchicalBundleEdges | Layout graph arcs in bundles |
  vtkGraphLayout | Layout a graph in 2 or 3 dimensions |
  vtkGraphWeightFilter | Base class for filters that weight graph edges |
   vtkGraphWeightEuclideanDistanceFilter | Weights the edges of a graph based on the Euclidean distance between the points |
  vtkKCoreDecomposition | Compute the k-core decomposition of the input graph |
  vtkKCoreLayout | Produces a layout for a graph labeled with K-Core information |
  vtkMergeGraphs | Combines two graphs |
  vtkPBGLBreadthFirstSearch | Breadth-first search on a distributed vtkGraph |
  vtkPBGLCollapseGraph | Collapse multiple vertices into a single vertex |
  vtkPBGLCollapseParallelEdges | Collapse multiple vertices into a single vertex |
  vtkPBGLCollectGraph | Collects all of the pieces of a distributed vtkGraph into a single, non-distributed vtkGraph |
  vtkPBGLConnectedComponents | Compute connected components for a distributed vtkGraph. For directed graphs, this computes the connected components; for undirected graphs, this computes the strongly-connected components |
  vtkPBGLGraphSQLReader | Read a vtkGraph from a database |
  vtkPBGLMinimumSpanningTree | Minimum spanning tree of a distributed vtkGraph |
  vtkPBGLRandomGraphSource | Generates a distributed graph with random edges |
  vtkPBGLRMATGraphSource | Distributed graph with random edges built accorting to the recursive matrix (R-MAT) model |
  vtkPBGLShortestPaths | Compute the shortest paths from the origin vertex to all other vertices in a distributed vtkGraph |
  vtkPBGLVertexColoring | Compute a vertex coloring for a distributed, undirected vtkGraph, where each vertex has a color distinct from the colors of its adjacent vertices |
  vtkPerturbCoincidentVertices | Perturbs vertices that are coincident |
  vtkRandomGraphSource | Graph with random edges |
  vtkRemoveIsolatedVertices | Remove vertices of a vtkGraph with degree zero |
  vtkSplineGraphEdges | Subsample graph edges to make smooth curves |
  vtkStreamGraph | Combines two graphs |
  vtkTableToGraph | Convert a vtkTable into a vtkGraph |
  vtkThresholdGraph | Returns a subgraph of a vtkGraph |
  vtkTreeDifferenceFilter | Compare two trees |
  vtkVertexDegree | Adds an attribute array with the degree of each vertex |
 boost::vtkGraphEdgeMap | |
 boost::vtkGraphEdgePropertyMapHelper< PMap > | |
 boost::vtkGraphIndexMap | |
 boost::vtkGraphPropertyMapMultiplier< PMap > | |
 vtkHyperOctreeAlgorithm | |
  vtkHyperOctreeFractalSource | Create an octree from a fractal. hyperoctree |
  vtkHyperOctreeSampleFunction | Sample an implicit function over an hyperoctree |
 vtkHyperOctreePointsGrabber | |
  vtkHyperOctreeClipCutPointsGrabber | A concrete implementation of vtkHyperOctreePointsGrabber used by vtkClipHyperOctree and vtkHyperOctreeCutter |
 vtkHyperTreeGridAlgorithm | |
  vtkHyperTreeGridSource | Create a synthetic grid of hypertrees |
 vtkImage2DIslandPixel | |
 vtkImageAlgorithm | |
  vtkBooleanTexture | Generate 2D texture map based on combinations of inside, outside, and on region boundary |
  vtkExtractVOI | Select piece (e.g., volume of interest) and/or subsample structured points dataset |
  vtkFastSplatter | A splatter optimized for splatting single kernels |
  vtkGaussianSplatter | Splat points into a volume with an elliptical, Gaussian distribution |
  vtkHyperOctreeToUniformGridFilter | Flat the octree into a uniform grid |
  vtkImageAccumulate | Generalized histograms up to 3 dimensions |
  vtkImageCacheFilter | Caches multiple vtkImageData objects |
  vtkImageCanvasSource2D | Paints on a canvas |
  vtkImageChangeInformation | Modify spacing, origin and extent |
  vtkImageClip | Reduces the image extent of the input |
  vtkImageDataStreamer | Initiates streaming on image data |
   vtkMemoryLimitImageDataStreamer | Initiates streaming on image data |
  vtkImageEllipsoidSource | Create a binary image of an ellipsoid |
  vtkImageGaussianSource | Create an image with Gaussian pixel values |
  vtkImageGridSource | Create an image of a grid |
  vtkImageIslandRemoval2D | Removes small clusters in masks |
  vtkImageMandelbrotSource | Mandelbrot image |
  vtkImageNoiseSource | Create an image filled with noise |
  vtkImageOpenClose3D | Will perform opening or closing |
  vtkImageQuantizeRGBToIndex | Generalized histograms up to 4 dimensions |
  vtkImageSeedConnectivity | SeedConnectivity with user defined seeds |
  vtkImageSinusoidSource | Create an image with sinusoidal pixel values |
  vtkImageStencilToImage | Convert an image stencil into an image |
  vtkImageThresholdConnectivity | Flood fill an image region |
  vtkImageTranslateExtent | Changes extent, nothing else |
  vtkImplicitModeller | Compute distance from input geometry on structured point dataset |
  vtkPointLoad | Compute stress tensors given point load on semi-infinite domain |
  vtkRTAnalyticSource | Create an image for regression testing |
  vtkSampleFunction | Sample an implicit function over a structured point set |
  vtkShepardMethod | Sample unstructured points onto structured points using the method of Shepard |
  vtkSurfaceReconstructionFilter | Reconstructs a surface from unorganized points |
  vtkTransmitImageDataPiece | For parallel processing, restrict IO to the first process in the cluste.r |
  vtkTriangularTexture | Generate 2D triangular texture map |
  vtkVoxelModeller | Convert an arbitrary dataset to a voxel representation |
 vtkImageBSplineInternals | BSpline code from P. Thevenaz |
 vtkImageComplex | |
 vtkImageConnectorSeed | |
 vtkImageInPlaceFilter | |
  vtkImageCursor3D | Paints a cursor on top of an image or volume |
 vtkImageStencilIterator< DType > | Image region iterator |
 vtkImageStencilRaster | |
 vtkImplicitFunction | |
  vtkImplicitPolyDataDistance | |
 vtkInteractorStyle | |
  vtkContextInteractorStyle | An interactor for chart views It observes the user events (mouse events) and propagates them to the scene. If the scene doesn't eat the event, it is propagated to the interactor style superclass |
 vtkInteractorStyleImage | |
  vtkInteractorStyleTreeMapHover | An interactor style for a tree map view |
 vtkInteractorStyleRubberBand2D | |
  vtkInteractorStyleAreaSelectHover | An interactor style for an area tree view |
 vtkInterpolationInfo | |
  vtkInterpolationWeights | |
 vtkInterpolationMath | |
 vtkInterpolatorInternals | Internals for vtkImageInterpolator |
 vtkJavaVoidFuncArg | |
 vtkKdTree | |
  vtkPKdTree | Build a k-d tree decomposition of a list of points |
 vtkMapper | |
  vtkMoleculeMapper | Mapper that draws vtkMolecule objects |
 vtkMultiBlockDataSetAlgorithm | |
  vtkAMRCutPlane | |
  vtkAMRResampleFilter | |
  vtkAMRToMultiBlockFilter | |
  vtkBlockIdScalars | Generates scalars from blocks |
  vtkDataSetGhostGenerator | |
   vtkPDataSetGhostGenerator | |
    vtkPStructuredGridGhostDataGenerator | |
    vtkPUniformGridGhostDataGenerator | |
   vtkStructuredGridGhostDataGenerator | |
   vtkUniformGridGhostDataGenerator | |
  vtkExtractArraysOverTime | Extracts a selection over time |
   vtkPExtractArraysOverTime | Extract point or cell data over time (parallel) |
  vtkExtractBlock | Extracts blocks from a multiblock dataset |
  vtkExtractCTHPart | Generates surface of an CTH volume fraction |
  vtkExtractDataSets | Extracts a number of datasets |
   vtkHierarchicalDataExtractDataSets | Extract a number of datasets |
  vtkExtractLevel | Extract levels between min and max from a hierarchical box dataset |
   vtkHierarchicalDataExtractLevel | Extact levels between min and max |
  vtkMultiBlockDataGroupFilter | Collects multiple inputs into one multi-group dataset |
  vtkMultiBlockMergeFilter | Merges multiblock inputs into a single multiblock output |
  vtkMultiThreshold | Threshold cells within multiple intervals |
  vtkPCAAnalysisFilter | Performs principal component analysis of a set of aligned pointsets |
  vtkProcrustesAlignmentFilter | Aligns a set of pointsets together |
  vtkQuadRotationalExtrusionFilter | Sweep polygonal data creating "skirt" from free edges and lines, and lines from vertices |
  vtkRectilinearGridPartitioner | |
  vtkSpatialRepresentationFilter | Generate polygonal model of spatial search object (i.e., a vtkLocator) |
  vtkStructuredGridPartitioner | |
  vtkYoungsMaterialInterface | Reconstructs material interfaces |
   vtkPYoungsMaterialInterface | Parallel reconstruction of material interfaces |
 vtkMultiTimeStepAlgorithm | |
  vtkTemporalInterpolator | Interpolate datasets between time steps to produce a new dataset |
 vtkNonOverlappingAMRAlgorithm | |
  vtkNonOverlappingAMRLevelIdScalars | Generate scalars from levels |
 vtkOBBNode | |
 vtkObject | |
  vtkAbstractGridConnectivity | |
   vtkStructuredAMRGridConnectivity | |
   vtkStructuredGridConnectivity | |
    vtkPStructuredGridConnectivity | |
  vtkAbstractImageInterpolator | Interpolate data values from images |
   vtkImageBSplineInterpolator | Perform b-spline interpolation on images |
   vtkImageInterpolator | Interpolate data values from images |
   vtkImageSincInterpolator | Perform sinc interpolation on images |
  vtkAMRUtilities | |
  vtkAreaLayoutStrategy | Abstract superclass for all area layout strategies |
   vtkStackedTreeLayoutStrategy | Lays out tree in stacked boxes or rings |
   vtkTreeMapLayoutStrategy | Abstract superclass for all tree map layout strategies |
    vtkBoxLayoutStrategy | Tree map layout that puts vertices in square-ish boxes |
    vtkSliceAndDiceLayoutStrategy | Horizontal and vertical slicing tree map layout |
    vtkSquarifyLayoutStrategy | Uses the squarify tree map layout algorithm |
  vtkBlueObeliskData | Contains chemical data from the Blue Obelisk Data Repository |
  vtkCirclePackLayoutStrategy | Abstract superclass for all circle packing layout strategies |
   vtkCirclePackFrontChainLayoutStrategy | Layout a vtkTree into packed circles using the front chain algorithm |
  vtkCoincidentPoints | Octree of labels |
  vtkDSPFilterDefinition | Used by the Exodus readers |
  vtkDSPFilterGroup | Used by the Exodus readers |
  vtkEdgeLayoutStrategy | Abstract superclass for all edge layout strategies |
   vtkArcParallelEdgeStrategy | Routes parallel edges as arcs |
   vtkGeoEdgeStrategy | Layout graph edges on a globe as arcs |
   vtkPassThroughEdgeStrategy | Passes edge routing information through |
  vtkEdgeSubdivisionCriterion | How to decide whether a linear approximation to nonlinear geometry or field should be subdivided |
   vtkDataSetEdgeSubdivisionCriterion | Subclass of vtkEdgeSubdivisionCriterion for vtkDataSet objects |
  vtkExecutionTimer | Time filter execution |
  vtkGeoMath | Useful geographic calculations |
  vtkGhostArray | |
  vtkGraphLayoutStrategy | Abstract superclass for all graph layout strategies |
   vtkAssignCoordinatesLayoutStrategy | Uses array values to set vertex locations |
   vtkAttributeClustering2DLayoutStrategy | Simple fast 2D graph layout |
   vtkCircularLayoutStrategy | Places vertices around a circle |
   vtkClustering2DLayoutStrategy | Simple fast 2D graph layout |
   vtkCommunity2DLayoutStrategy | Simple fast 2D graph layout that looks for a community array on it's input and strengthens edges within a community and weakens edges not within the community |
   vtkConeLayoutStrategy | Produce a cone-tree layout for a forest |
   vtkConstrained2DLayoutStrategy | Simple fast 2D graph layout that looks for a 'constraint' array (vtkDoubleArray). Any entry in the constraint array will indicate the level of impedance a node has to the force calculations during the layout optimization. The array is assumed to be normalized between zero and one, with one being totally constrained, so no force will be applied to the node (i.e. no movement), and zero being full range of movement (no constraints) |
   vtkCosmicTreeLayoutStrategy | Tree layout strategy reminiscent of astronomical systems |
   vtkFast2DLayoutStrategy | Simple fast 2D graph layout |
   vtkForceDirectedLayoutStrategy | Force directed graph layout algorithm |
   vtkPassThroughLayoutStrategy | Layout strategy that does absolutely nothing |
   vtkRandomLayoutStrategy | Randomly places vertices in 2 or 3 dimensions |
   vtkSimple2DLayoutStrategy | Simple 2D graph layout |
   vtkSimple3DCirclesStrategy | Places vertices on circles in 3D |
   vtkSpanTreeLayoutStrategy | |
   vtkTreeLayoutStrategy | Hierarchical layout |
   vtkTreeOrbitLayoutStrategy | Hierarchical orbital layout |
  vtkHierarchicalGraphPipeline | Helper class for rendering graphs superimposed on a tree |
  vtkImageConnector | Create a binary image of a sphere |
  vtkIncrementalForceLayout | Incremental force-directed layout |
  vtkKMeansDistanceFunctor | Measure distance from k-means cluster centers |
   vtkKMeansDistanceFunctorCalculator | Measure distance from k-means cluster centers using a user-specified expression |
  vtkMergeCells | Merges any number of vtkDataSets back into a single vtkUnstructuredGrid |
  vtkMutableGraphHelper | Helper class for building a directed or directed graph |
  vtkPeriodicTable | Access to information about the elements |
  vtkPipelineSize | Compute the memory required by a pipeline |
  vtkRAdapter | This is a utility class to convert VTK array data and VTK tables to and from Gnu R S expression (SEXP) data structures. It is used with the R .Call interface and the embedded R interpreter |
  vtkRInterface | |
  vtkSliceCubes | Generate isosurface(s) from volume four slices at a time |
  vtkStreamingTessellator | An algorithm that refines an initial simplicial tessellation using edge subdivision |
  vtkTesting | Unified VTK regression testing framework |
   vtkRegressionTester | |
  vtkView | The superclass for all views |
   vtkQtView | Superclass for Qt widget-based views |
   vtkRenderViewBase | A base view containing a renderer |
    vtkContextView | View of the vtkContextScene |
    vtkRenderView | A view containing a renderer |
     vtkGeoView | A 3D geospatial view |
     vtkGeoView2D | A 2D geospatial view |
     vtkGraphLayoutView | Lays out and displays a graph |
      vtkHierarchicalGraphView | Accepts a graph and a hierarchy - currently a tree - and provides a hierarchy-aware display. Currently, this means displaying the hierarchy using a tree layout, then rendering the graph vertices as leaves of the tree with curved graph edges between leaves |
     vtkParallelCoordinatesView | View to be used with vtkParallelCoordinatesRepresentation |
     vtkTreeAreaView | Accepts a graph and a hierarchy - currently a tree - and provides a hierarchy-aware display. Currently, this means displaying the hierarchy using a tree ring layout, then rendering the graph vertices as leaves of the tree with curved graph edges between leaves |
      vtkIcicleView | Displays a tree in a stacked "icicle" view |
      vtkTreeMapView | Displays a tree as a tree map |
      vtkTreeRingView | Displays a tree in concentric rings |
  vtkViewTheme | Sets theme colors for a graphical view |
  vtkViewUpdater | Updates views automatically |
 vtkOverlappingAMRAlgorithm | |
  vtkAMRGaussianPulseSource | |
  vtkAMRSliceFilter | |
  vtkImageToAMR | Filter to convert any vtkImageData to a vtkOverlappingAMR |
  vtkOverlappingAMRLevelIdScalars | Generate scalars from levels |
   vtkLevelIdScalars | |
    vtkHierarchicalDataLevelFilter | Generate scalars from levels |
 vtkPassInputTypeAlgorithm | |
  vtkAddMembershipArray | Add an array to the output indicating membership within an input selection |
  vtkApplyColors | Apply colors to a data set |
  vtkApplyIcons | Apply icons to a data set |
  vtkAssignAttribute | Labels a field as an attribute |
  vtkAssignCoordinates | Given two(or three) arrays take the values in those arrays and simply assign them to the coordinates of the vertices |
  vtkConvertSelectionDomain | Convert a selection from one domain to another |
  vtkDataRepresentation | The superclass for all representations |
   vtkEmptyRepresentation | |
   vtkQtTableRepresentation | Set up a vtkTable in a Qt model |
   vtkRenderedRepresentation | |
    vtkParallelCoordinatesRepresentation | Data representation that takes generic multivariate data and produces a parallel coordinates plot |
     vtkParallelCoordinatesHistogramRepresentation | Data representation that takes generic multivariate data and produces a parallel coordinates plot. This plot optionally can draw a histogram-based plot summary |
    vtkRenderedGraphRepresentation | |
     vtkRenderedHierarchyRepresentation | |
    vtkRenderedSurfaceRepresentation | Displays a geometric dataset as a surface |
    vtkRenderedTreeAreaRepresentation | |
  vtkPassThrough | Shallow copies the input into the output |
  vtkProgrammableFilter | User-programmable filter |
  vtkRemoveHiddenData | Removes the rows/edges/vertices of input data flagged by ann |
  vtkTemporalStatistics | Compute statistics of point or cell data as it changes over time |
  vtkTransferAttributes | Transfer data from a graph representation to a tree representation using direct mapping or pedigree ids |
 vtkPBGLGraphAdapter | Adapter to the Parallel Boost Graph Library (http://www.osl.iu.edu/research/pbgl) |
 vtkPKMeansStatisitcs | A class for parallel k means clustering |
 vtkPointSetAlgorithm | |
  vtkCenterOfMass | Find the center of mass of a set of points |
  vtkDeformPointSet | Use a control polyhedron to deform an input vtkPointSet |
  vtkExtractDataOverTime | Extract point data from a time sequence for a specified point id |
  vtkProjectSphereFilter | A filter to 'unroll' a sphere. The unroll longitude is -180 |
   vtkPProjectSphereFilter | A filter to 'unroll' a sphere. The unroll longitude is -180 |
  vtkTransformFilter | Transform points and associated normals and vectors |
  vtkWarpLens | Deform geometry by applying lens distortion |
  vtkWarpScalar | Deform geometry with scalar data |
  vtkWarpTo | Deform geometry by warping towards a point |
  vtkWarpVector | Deform geometry with vector data |
  vtkWeightedTransformFilter | Transform based on per-point or per-cell weighting functions |
 vtkPolyDataAlgorithm | |
  vtkAppendPoints | Appends points of one or more vtkPolyData data sets |
  vtkAppendPolyData | Appends one or more polygonal datasets together |
  vtkApproximatingSubdivisionFilter | Generate a subdivision surface using an Approximating Scheme |
   vtkLoopSubdivisionFilter | Generate a subdivision surface using the Loop Scheme |
  vtkArcSource | Create an arc between two end points |
  vtkArrowSource | Appends a cylinder to a cone to form an arrow |
  vtkAxes | Create an x-y-z axes |
  vtkBandedPolyDataContourFilter | Generate filled contours for vtkPolyData |
  vtkBooleanOperationPolyDataFilter | |
  vtkButtonSource | Abstract class for creating various button types |
   vtkEllipticalButtonSource | Create a ellipsoidal-shaped button |
   vtkRectangularButtonSource | Create a rectangular button |
  vtkCellCenters | Generate points at center of cells |
  vtkCirclePackToPolyData | Converts a tree to a polygonal data representing a circle packing of the hierarchy |
  vtkCleanPolyData | Merge duplicate points, and/or remove unused points and/or remove degenerate cells |
   vtkQuantizePolyDataPoints | Quantizes x,y,z coordinates of points |
  vtkClipClosedSurface | Clip a closed surface with a plane collection |
  vtkClipConvexPolyData | Clip any dataset with user-specified implicit function or input scalar data |
  vtkClipPolyData | Clip polygonal data with user-specified implicit function or input scalar data |
  vtkCollectPolyData | Collect distributed polydata |
  vtkCompositeDataGeometryFilter | Extract geometry from multi-group data |
   vtkHierarchicalDataSetGeometryFilter | Extract geometry from hierarchical data |
  vtkConeSource | Generate polygonal cone |
  vtkContourFilter | Generate isosurfaces/isolines from scalar values |
  vtkContourGrid | Generate isosurfaces/isolines from scalar values (specialized for unstructured grids) |
  vtkContourTriangulator | Fill all 2D contours to create polygons |
  vtkConvexHull2D | Produce filled convex hulls around a set of points |
  vtkCubeSource | Create a polygonal representation of a cube |
  vtkCursor2D | Generate a 2D cursor representation |
  vtkCursor3D | Generate a 3D cursor representation |
  vtkCurvatures | Compute curvatures (Gauss and mean) of a Polydata object |
  vtkCutMaterial | Automatically computes the cut plane for a material array pair |
  vtkCutter | Cut vtkDataSet with user-specified implicit function |
   vtkCompositeCutter | Cut composite data sets with user-specified implicit function |
  vtkCylinderSource | Generate a cylinder centered at origin |
  vtkDataSetSurfaceFilter | Extracts outer (polygonal) surface |
  vtkDecimatePolylineFilter | Reduce the number of lines in a polyline |
  vtkDecimatePro | Reduce the number of triangles in a mesh |
  vtkDelaunay2D | Create 2D Delaunay triangulation of input points |
  vtkDensifyPolyData | Densify the input by adding points at the centroid |
  vtkDepthSortPolyData | Sort poly data along camera view direction |
  vtkDiskSource | Create a disk with hole in center |
  vtkDistancePolyDataFilter | |
  vtkDuplicatePolyData | For distributed tiled displays |
  vtkEarthSource | Create the continents of the Earth as a sphere |
  vtkEdgeCenters | Generate points at center of edges |
  vtkEdgePoints | Generate points on isosurface |
  vtkExtractEdges | Extract cell edges from any type of data |
  vtkExtractPolyDataGeometry | Extract vtkPolyData cells that lies either entirely inside or outside of a specified implicit function |
  vtkExtractPolyDataPiece | Return specified piece, including specified number of ghost levels |
  vtkExtractSelectedPolyDataIds | Extract a list of cells from a polydata |
  vtkFacetReader | Reads a dataset in Facet format |
  vtkFeatureEdges | Extract boundary, non-manifold, and/or sharp edges from polygonal data |
  vtkFillHolesFilter | Identify and fill holes in meshes |
  vtkFrustumSource | Create a polygonal representation of a frustum |
  vtkGenericContourFilter | Generate isocontours from input dataset |
  vtkGenericCutter | Cut a vtkGenericDataSet with an implicit function or scalar data |
  vtkGenericGeometryFilter | Extract geometry from data (or convert data to polygonal type) |
  vtkGenericGlyph3DFilter | Copy oriented and scaled glyph geometry to every input point |
  vtkGenericOutlineFilter | Create wireframe outline for arbitrary generic data set |
  vtkGenericStreamTracer | Streamline generator |
  vtkGeodesicPath | Abstract base for classes that generate a geodesic path |
   vtkGraphGeodesicPath | Abstract base for classes that generate a geodesic path on a graph (mesh) |
    vtkDijkstraGraphGeodesicPath | Dijkstra algorithm to compute the graph geodesic |
     vtkDijkstraImageGeodesicPath | Dijkstra algorithm to compute the graph geodesic |
  vtkGeometryFilter | Extract geometry from data (or convert data to polygonal type) |
  vtkGlyph3D | Copy oriented and scaled glyph geometry to every input point |
   vtkGlyph2D | Copy oriented and scaled glyph geometry to every input point (2D specialization) |
  vtkGlyphSource2D | Create 2D glyphs represented by vtkPolyData |
  vtkGraphAnnotationLayersFilter | Produce filled convex hulls around subsets of vertices in a vtkGraph |
  vtkGraphLayoutFilter | Nice layout of undirected graphs in 3D |
  vtkGraphToPoints | Convert a vtkGraph a set of points |
  vtkGraphToPolyData | Convert a vtkGraph to vtkPolyData |
  vtkGreedyTerrainDecimation | Reduce height field (represented as image) to reduced TIN |
  vtkGridSynchronizedTemplates3D | Generate isosurface from structured grids |
  vtkHedgeHog | Create oriented lines from vector data |
  vtkHull | Produce an n-sided convex hull |
  vtkHyperOctreeContourFilter | Generate isosurfaces/isolines from scalar values |
  vtkHyperOctreeCutter | Cut vtkHyperOctree with user-specified implicit function |
  vtkHyperOctreeDualGridContourFilter | Generate isosurfaces/isolines from scalar values |
  vtkHyperOctreeSurfaceFilter | Extracts outer (polygonal) surface |
  vtkHyperStreamline | Generate hyperstreamline in arbitrary dataset |
  vtkHyperTreeGridAxisCut | Axis aligned hyper tree grid cut |
  vtkHyperTreeGridGeometry | Hyper tree grid outer surface |
  vtkIconGlyphFilter | Filter that generates a polydata consisting of quads with texture coordinates referring to a set of icons within a sheet of icons |
  vtkImageDataGeometryFilter | Extract geometry for structured points |
   vtkStructuredPointsGeometryFilter | Obsolete class |
  vtkImageMarchingCubes | Generate isosurface(s) from volume/images |
  vtkImageToPolyDataFilter | Generate linear primitives (vtkPolyData) from an image |
  vtkInterpolatingSubdivisionFilter | Generate a subdivision surface using an Interpolating Scheme |
   vtkButterflySubdivisionFilter | Generate a subdivision surface using the Butterfly Scheme |
   vtkLinearSubdivisionFilter | Generate a subdivision surface using the Linear Scheme |
  vtkIntersectionPolyDataFilter | |
  vtkLinearExtrusionFilter | Sweep polygonal data creating a "skirt" from free edges and lines, and lines from vertices |
   vtkPLinearExtrusionFilter | Subclass that handles piece invariance |
  vtkLineSource | Create a line defined by two end points |
  vtkLinkEdgels | Links edgels together to form digital curves |
  vtkMarchingContourFilter | Generate isosurfaces/isolines from scalar values |
  vtkMarchingCubes | Generate isosurface(s) from volume |
   vtkDiscreteMarchingCubes | Generate object boundaries from labelled volumes |
  vtkMarchingSquares | Generate isoline(s) from structured points set |
  vtkMaskPoints | Selectively filter points |
   vtkPMaskPoints | Parallel Mask Points |
  vtkMaskPolyData | Sample subset of input polygonal data cells |
  vtkMassProperties | Estimate volume, area, shape index of triangle mesh |
  vtkMoleculeToPolyDataFilter | Abstract filter class |
   vtkMoleculeToAtomBallFilter | Generate polydata with spheres representing atoms |
   vtkMoleculeToBondStickFilter | Generate polydata with cylinders representing bonds |
  vtkOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
  vtkOutlineFilter | Create wireframe outline for arbitrary data set |
  vtkOutlineSource | Create wireframe outline around bounding box |
   vtkOutlineCornerSource | Create wireframe outline corners around bounding box |
  vtkParametricFunctionSource | Tessellate parametric functions |
  vtkParticleTracerBase | A particle tracer for vector fields |
   vtkParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
   vtkParticleTracer | A Parallel Particle tracer for unsteady vector fields |
   vtkPParticleTracerBase | |
    vtkPParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
    vtkPParticleTracer | A Parallel Particle tracer for unsteady vector fields |
    vtkPStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
   vtkStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
  vtkPlaneSource | Create an array of quadrilaterals located in a plane |
  vtkPlatonicSolidSource | Produce polygonal Platonic solids |
  vtkPointSource | Create a random cloud of points |
  vtkPolyDataConnectivityFilter | Extract polygonal data based on geometric connectivity |
  vtkPolyDataNormals | Compute normals for polygonal mesh |
   vtkPPolyDataNormals | Compute normals for polygonal mesh |
  vtkPolyDataPointSampler | Generate points from vtkPolyData |
  vtkPolyDataSilhouette | Sort polydata along camera view direction |
  vtkPOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
  vtkPOutlineFilter | Create wireframe outline for arbitrary data set |
  vtkProgrammableGlyphFilter | Control the generation and placement of glyphs at input points |
  vtkProjectedTerrainPath | Project a polyline onto a terrain |
  vtkProteinRibbonFilter | Generates protein ribbons |
  vtkQuadraturePointsGenerator | |
  vtkQuadricClustering | Reduce the number of triangles in a mesh |
  vtkQuadricDecimation | Reduce the number of triangles in a mesh |
  vtkRectilinearGridGeometryFilter | Extract geometry for a rectilinear grid |
  vtkRectilinearGridOutlineFilter | Create wireframe outline for a rectilinear grid |
  vtkRectilinearSynchronizedTemplates | Generate isosurface from rectilinear grid |
  vtkRecursiveDividingCubes | Create points laying on isosurface (using recursive approach) |
  vtkRegularPolygonSource | Create a regular, n-sided polygon and/or polyline |
  vtkReverseSense | Reverse the ordering of polygonal cells and/or vertex normals |
  vtkRibbonFilter | Create oriented ribbons from lines defined in polygonal dataset |
  vtkRotationalExtrusionFilter | Sweep polygonal data creating "skirt" from free edges and lines, and lines from vertices |
  vtkRuledSurfaceFilter | Generates a surface from a set of lines |
  vtkSectorSource | Create a sector of a disk |
  vtkSelectPolyData | Select portion of polygonal mesh; generate selection scalars |
  vtkShrinkPolyData | Shrink cells composing PolyData |
  vtkSmoothPolyDataFilter | Adjust point positions using Laplacian smoothing |
  vtkSpherePuzzle | Create a polygonal sphere centered at the origin |
  vtkSpherePuzzleArrows | Visualize permutation of the sphere puzzle |
  vtkSphereSource | Create a polygonal sphere centered at the origin |
   vtkPSphereSource | Sphere source that supports pieces |
  vtkSplineFilter | Generate uniformly subdivided polylines from a set of input polyline using a vtkSpline |
  vtkStreamer | Abstract object implements integration of massless particle through vector field |
   vtkStreamLine | Generate streamline in arbitrary dataset |
    vtkDashedStreamLine | Generate constant-time dashed streamline in arbitrary dataset |
   vtkStreamPoints | Generate points along streamer separated by constant time increment |
  vtkStreamTracer | Streamline generator |
   vtkPStreamTracer | Parallel streamline generators |
   vtkTemporalStreamTracer | A Parallel Particle tracer for unsteady vector fields |
    vtkPTemporalStreamTracer | |
  vtkStripper | Create triangle strips and/or poly-lines |
  vtkStructuredGridGeometryFilter | Extract geometry for structured grid |
  vtkStructuredGridOutlineFilter | Create wireframe outline for structured grid |
  vtkSubPixelPositionEdgels | Adjust edgel locations based on gradients |
  vtkSuperquadricSource | Create a polygonal superquadric centered at the origin |
  vtkSynchronizedTemplates2D | Generate isoline(s) from a structured points set |
  vtkSynchronizedTemplates3D | Generate isosurface from structured points |
   vtkSynchronizedTemplatesCutter3D | Generate cut surface from structured points |
  vtkTableToPolyData | Filter used to convert a vtkTable to a vtkPolyData consisting of vertices |
  vtkTemporalPathLineFilter | Generate a Polydata Pointset from any Dataset |
  vtkTensorGlyph | Scale and orient glyph(s) according to tensor eigenvalues and eigenvectors |
  vtkTessellatedBoxSource | Create a polygonal representation of a box with a given level of subdivision |
  vtkTextSource | Create polygonal text |
  vtkTexturedSphereSource | Create a sphere centered at the origin |
  vtkThresholdPoints | Extracts points whose scalar value satisfies threshold criterion |
  vtkTransformPolyDataFilter | Transform points and associated normals and vectors for polygonal dataset |
  vtkTransmitPolyDataPiece | Return specified piece, including specified number of ghost levels |
  vtkTreeMapToPolyData | Converts a tree to a polygonal data representing a tree map |
  vtkTreeRingToPolyData | Converts a tree to a polygonal data representing radial space filling tree |
  vtkTriangleFilter | Convert input polygons and strips to triangles |
  vtkTriangularTCoords | 2D texture coordinates based for triangles |
  vtkTubeFilter | Filter that generates tubes around lines |
  vtkUncertaintyTubeFilter | Generate uncertainty tubes along a polyline |
  vtkVertexGlyphFilter | Make a vtkPolyData with a vertex on each point |
  vtkVoxelContoursToSurfaceFilter | Create surface from contours |
  vtkWindowedSincPolyDataFilter | Adjust point positions using a windowed sinc function interpolation kernel |
 vtkPOutlineFilterInternals | Create wireframe outline (or corners) for arbitrary data set |
 vtkPythonArgs | |
 vtkPythonOverload | Created in June 2010 by David Gobbi, originally in vtkPythonUtil |
 vtkPythonUtil | |
 vtkRectilinearGridAlgorithm | |
  vtkExtractRectilinearGrid | Extract a sub grid (VOI) from the structured rectilinear dataset |
  vtkRectilinearGridClip | Reduces the image extent of the input |
  vtkTransmitRectilinearGridPiece | For parallel processing, restrict IO to the first process in the cluster |
 vtkRenderWindowInteractor | |
  vtkTestingInteractor | A RenderWindowInteractor for testing |
 vtkSelectionAlgorithm | |
  vtkAppendSelection | Appends one or more selections together |
  vtkBoostKruskalMinimumSpanningTree | Contructs a minimum spanning tree from a graph and the weighting array |
  vtkCellDistanceSelector | Select neighbor cells up to a distance |
  vtkComputeHistogram2DOutliers | Compute the outliers in a set of 2D histograms and extract the corresponding row data |
   vtkPComputeHistogram2DOutliers | Extract outlier rows from a vtkTable based on input 2D histograms, in parallel |
  vtkConvertSelection | Convert a selection from one type to another |
  vtkExpandSelectedGraph | Expands a selection set of a vtkGraph |
  vtkKdTreeSelector | Selects point ids using a kd-tree |
  vtkLinearSelector | Select cells intersecting a line (possibly broken) |
  vtkSelectionSource | Generate selection from given set of ids vtkSelectionSource generates a vtkSelection from a set of (piece id, cell id) pairs. It will only generate the selection values that match UPDATE_PIECE_NUMBER (i.e. piece == UPDATE_PIECE_NUMBER) |
 vtkSimpleImageToImageFilter | |
  vtkSimpleImageFilterExample | Simple example of an image-image filter |
 vtkSpline | |
  vtkSCurveSpline | Computes an interpolating spline using a a SCurve basis |
 vtkStatisticsAlgorithmPrivate | |
 vtkStructuredGridAlgorithm | |
  vtkBlankStructuredGrid | Translate point attribute data into a blanking field |
  vtkBlankStructuredGridWithImage | Blank a structured grid with an image |
  vtkExtractGrid | Select piece (e.g., volume of interest) and/or subsample structured grid dataset |
  vtkImageDataToPointSet | Converts a vtkImageData to a vtkPointSet |
  vtkRectilinearGridToPointSet | Converts a vtkRectilinearGrid to a vtkPointSet |
  vtkStructuredGridClip | Reduces the image extent of the input |
  vtkTableToStructuredGrid | Converts vtkTable to a vtkStructuredGrid |
   vtkPTableToStructuredGrid | VtkTableToStructuredGrid specialization which handles distribution of the input table |
  vtkTransmitStructuredGridPiece | For parallel processing, restrict IO to the first process in the cluster |
 vtkStructuredNeighbor | |
  vtkStructuredAMRNeighbor | |
 vtkTableAlgorithm | |
  vtkAdjacencyMatrixToEdgeTable | |
  vtkArrayToTable | Converts one- and two-dimensional vtkArrayData objects to vtkTable |
  vtkBivariateLinearTableThreshold | Performs line-based thresholding for vtkTable data |
   vtkPBivariateLinearTableThreshold | Performs line-based thresholding for vtkTable data in parallel |
  vtkBoostSplitTableField | "Splits" one-or-more table fields by duplicating rows containing delimited data |
  vtkCollectTable | Collect distributed table |
  vtkDataObjectToTable | Extract field data as a table |
  vtkDotProductSimilarity | Compute dot-product similarity metrics |
  vtkExtractSelectedRows | Return selected rows of a table |
  vtkExtractTemporalFieldData | Extract temporal arrays from input field data |
  vtkMergeColumns | Merge two columns into a single column |
  vtkMergeTables | Combine two tables |
  vtkRRandomTableSource | Generates vtkTables with columns of random numbers using Gnu R |
  vtkSparseArrayToTable | Converts a sparse array to a vtkTable |
  vtkSplitColumnComponents | Split multicomponent table columns |
  vtkStatisticsAlgorithm | Base class for statistics algorithms |
   vtkAutoCorrelativeStatistics | A class for univariate auto-correlative statistics |
    vtkPAutoCorrelativeStatistics | A class for parallel auto-correlative statistics |
   vtkContingencyStatistics | A class for bivariate correlation contigency tables, conditional probabilities, and information entropy |
    vtkContingencyStatisticsGnuR | A class for bivariate correlation contigency tables, conditional probabilities, and information entropy. The p-value are calculated using R |
    vtkPContingencyStatistics | A class for parallel bivariate contingency statistics |
   vtkCorrelativeStatistics | A class for bivariate linear correlation |
    vtkCorrelativeStatisticsGnuR | A class for bivariate linear correlation using R to calculate the p-values |
    vtkPCorrelativeStatistics | A class for parallel bivariate correlative statistics |
   vtkDescriptiveStatistics | A class for univariate descriptive statistics |
    vtkDescriptiveStatisticsGnuR | |
    vtkPDescriptiveStatistics | A class for parallel univariate descriptive statistics |
   vtkExtractHistogram2D | Compute a 2D histogram between two columns of an input vtkTable |
    vtkPExtractHistogram2D | Compute a 2D histogram between two columns of an input vtkTable in parallel |
   vtkKMeansStatistics | A class for KMeans clustering |
    vtkPKMeansStatistics | |
   vtkMultiCorrelativeStatistics | A class for multivariate linear correlation |
    vtkPCAStatistics | A class for multivariate principal component analysis |
     vtkPCAStatisticsGnuR | A class for multivariate principal component analysis using R to calculate p-values |
     vtkPPCAStatistics | A class for parallel principal component analysis |
    vtkPMultiCorrelativeStatistics | A class for parallel bivariate correlative statistics |
   vtkOrderStatistics | A class for univariate order statistics |
    vtkPOrderStatistics | A class for parallel univariate order statistics |
   vtkPairwiseExtractHistogram2D | Compute a 2D histogram between all adjacent columns of an input vtkTable |
    vtkPPairwiseExtractHistogram2D | Compute a 2D histogram between all adjacent columns of an input vtkTable in parallel |
  vtkStreamingStatistics | A class for using the statistics filters in a streaming mode |
  vtkTableFFT | FFT for table columns |
  vtkThresholdTable | Thresholds table rows |
 vtkTclCommandArgStruct | |
 vtkTclCommandStruct | |
 vtkTclInterpStruct | |
 vtkTestUtilities | Utility functions used for regression testing |
 vtkThreadedImageAlgorithm | |
  vtkImageAppend | Collects data from multiple inputs into one image |
  vtkImageAppendComponents | Collects components from two inputs into one output |
  vtkImageBlend | Blend images together using alpha or opacity |
  vtkImageBSplineCoefficients | Convert image to b-spline knots |
  vtkImageButterworthHighPass | Frequency domain high pass |
  vtkImageButterworthLowPass | Frequency domain Low pass |
  vtkImageCast | Image Data type Casting Filter |
  vtkImageCheckerboard | Show two images at once using a checkboard pattern |
  vtkImageConvolve | Convolution of an image with a kernel |
  vtkImageCorrelation | Correlation imageof the two inputs |
  vtkImageDifference | Compares images for regression tests |
  vtkImageDivergence | Divergence of a vector field |
  vtkImageDotProduct | Dot product of two vector images |
  vtkImageEuclideanToPolar | Converts 2D Euclidean coordinates to polar |
  vtkImageExtractComponents | Outputs a single component |
  vtkImageGaussianSmooth | Performs a gaussian convolution |
  vtkImageGradient | Computes the gradient vector |
  vtkImageGradientMagnitude | Computes magnitude of the gradient |
  vtkImageHistogram | Compute the histogram for an image |
   vtkImageHistogramStatistics | Compute statistics for an image |
  vtkImageHSIToRGB | Converts HSI components to RGB |
  vtkImageHSVToRGB | Converts HSV components to RGB |
  vtkImageIdealHighPass | Simple frequency domain band pass |
  vtkImageIdealLowPass | Simple frequency domain band pass |
  vtkImageIterateFilter | Multiple executes per update |
   vtkImageDecomposeFilter | Filters that execute axes in series |
    vtkImageCityBlockDistance | 1,2 or 3D distance map |
    vtkImageEuclideanDistance | Computes 3D Euclidean DT |
    vtkImageFourierCenter | Shifts constant frequency to center for display |
    vtkImageFourierFilter | Superclass that implements complex numbers |
     vtkImageFFT | Fast Fourier Transform |
     vtkImageRFFT | Reverse Fast Fourier Transform |
    vtkImageSeparableConvolution | 3 1D convolutions on an image |
   vtkImageSkeleton2D | Skeleton of 2D images |
  vtkImageLaplacian | Computes divergence of gradient |
  vtkImageLogarithmicScale | Passes each pixel through log function |
  vtkImageLogic | And, or, xor, nand, nor, not |
  vtkImageLuminance | Computes the luminance of the input |
  vtkImageMagnify | Magnify an image by an integer value |
  vtkImageMagnitude | Colapses components with magnitude function. |
  vtkImageMapToColors | Map the input image through a lookup table |
   vtkImageMapToRGBA | Map the input image through a lookup table |
   vtkImageMapToWindowLevelColors | Map the input image through a lookup table and window / level it |
  vtkImageMask | Combines a mask and an image |
  vtkImageMaskBits | Applies a bit-mask pattern to each component |
  vtkImageMathematics | Add, subtract, multiply, divide, invert, sin, cos, exp, log |
  vtkImageNonMaximumSuppression | Performs non-maximum suppression |
  vtkImageNormalize | Normalizes that scalar components for each point |
  vtkImagePadFilter | Super class for filters that fill in extra pixels |
   vtkImageConstantPad | Makes image larger by padding with constant |
   vtkImageMirrorPad | Extra pixels are filled by mirror images |
   vtkImageWrapPad | Makes an image larger by wrapping existing data |
  vtkImageRectilinearWipe | Make a rectilinear combination of two images |
  vtkImageResize | High-quality image resizing filter |
  vtkImageReslice | Reslices a volume along a new set of axes |
   vtkImageFlip | This flips an axis of an image. Right becomes left .. |
   vtkImagePermute | Permutes axes of input |
   vtkImageResample | Resamples an image to be larger or smaller |
   vtkImageResliceToColors | Reslice and produce color scalars |
   vtkImageSlabReslice | Thick slab reformat through data |
  vtkImageRGBToHSI | Converts RGB components to HSI |
  vtkImageRGBToHSV | Converts RGB components to HSV |
  vtkImageShiftScale | Shift and scale an input image |
  vtkImageShrink3D | Subsamples an image |
  vtkImageSlab | Combine image slices to form a slab image |
  vtkImageSpatialAlgorithm | Filters that operate on pixel neighborhoods |
   vtkImageAnisotropicDiffusion2D | Edge preserving smoothing |
   vtkImageAnisotropicDiffusion3D | Edge preserving smoothing |
   vtkImageContinuousDilate3D | Dilate implemented as a maximum |
   vtkImageContinuousErode3D | Erosion implemented as a minimum |
   vtkImageDilateErode3D | Dilates one value and erodes another |
   vtkImageHybridMedian2D | Median filter that preserves lines and corners |
   vtkImageMedian3D | Median Filter |
   vtkImageRange3D | Max - min of a circular neighborhood |
   vtkImageSobel2D | Computes a vector field using sobel functions |
   vtkImageSobel3D | Computes a vector field using sobel functions |
   vtkImageVariance3D | Variance in a neighborhood |
  vtkImageStencil | Combine images via a cookie-cutter operation |
  vtkImageThreshold | Flexible threshold |
  vtkImageWeightedSum | Adds any number of images, weighting each according to the weight set using this->SetWeights(i,w) |
 vtkTimeSource | Creates a simple time varying data set |
 vtkTreeAlgorithm | |
  vtkAreaLayout | Layout a vtkTree into a tree map |
  vtkBoostBreadthFirstSearchTree | Contructs a BFS tree from a graph |
  vtkBoostPrimMinimumSpanningTree | Contructs a minimum spanning tree from a graph, start node, and the weighting array |
  vtkCirclePackLayout | Layout a vtkTree as a circle packing |
  vtkExtractSelectedTree | Return a subtree from a vtkTree |
  vtkGroupLeafVertices | Filter that expands a tree, categorizing leaf vertices |
  vtkNetworkHierarchy | Filter that takes a graph and makes a tree out of the network ip addresses in that graph |
  vtkPruneTreeFilter | Prune a subtree out of a vtkTree |
  vtkStrahlerMetric | Compute Strahler metric for a tree |
  vtkTableToTreeFilter | Filter that converts a vtkTable to a vtkTree |
  vtkTreeFieldAggregator | Aggregate field values from the leaves up the tree |
  vtkTreeLevelsFilter | Adds level and leaf fields to a vtkTree |
  vtkTreeMapLayout | Layout a vtkTree into a tree map |
 vtkTryDowncastHelper1< TargetT, FunctorT > | |
 vtkTryDowncastHelper2< TargetT, FunctorT > | |
 vtkTryDowncastHelper3< TargetT, FunctorT > | |
 vtkUndirectedGraphAlgorithm | |
  vtkBoostBiconnectedComponents | Find the biconnected components of a graph |
 vtkUnstructuredGridAlgorithm | |
  vtkAppendFilter | Appends one or more datasets together into a single unstructured grid |
  vtkBoxClipDataSet | Clip an unstructured grid |
  vtkClipDataSet | Clip any dataset with user-specified implicit function or input scalar data |
  vtkClipHyperOctree | Clip an hyperoctree with user-specified implicit function or input scalar data |
  vtkClipVolume | Clip volume data with user-specified implicit function or input scalar data |
  vtkConnectivityFilter | Extract data based on geometric connectivity |
  vtkDataSetTriangleFilter | Triangulate any type of dataset |
  vtkDelaunay3D | Create 3D Delaunay triangulation of input points |
  vtkExtractCells | Subset a vtkDataSet to create a vtkUnstructuredGrid |
  vtkExtractGeometry | Extract cells that lie either entirely inside or outside of a specified implicit function |
  vtkExtractUnstructuredGrid | Extract subset of unstructured grid geometry |
  vtkExtractUnstructuredGridPiece | Return specified piece, including specified number of ghost levels |
   vtkExtractUserDefinedPiece | Return user specified piece with ghost cells |
  vtkGenericClip | Clip any dataset with an implicit function or scalar data |
  vtkGenericDataSetTessellator | Tessellates generic, higher-order datasets into linear cells |
  vtkHyperTreeGridToUnstructuredGrid | Convert hyper tree grid to unstructured grid |
  vtkPCosmoHaloFinder | Find halos within a cosmology data file |
  vtkPCosmoReader | Read a binary cosmology data file |
  vtkRectilinearGridToTetrahedra | Create a Tetrahedral mesh from a RectilinearGrid |
  vtkRotationFilter | Duplicates a data set by rotation about an axis |
  vtkShrinkFilter | Shrink cells composing an arbitrary data set |
  vtkSubdivideTetra | Subdivide one tetrahedron into twelve for every tetra |
  vtkTableBasedClipDataSet | Clip any dataset with a user-specified implicit function or an input scalar point data array |
  vtkTessellatorFilter | Approximate nonlinear FEM elements with simplices |
  vtkThreshold | Extracts cells where scalar value in cell satisfies threshold criterion |
  vtkTimeSourceExample | |
  vtkTransmitUnstructuredGridPiece | Return specified piece, including specified number of ghost levels |
  vtkUnstructuredGridGeometryFilter | Extract geometry from an unstructured grid |
 vtkVariantBoostSerialization | Serialization support for vtkVariant and vtkVariantArray using the Boost.Serialization library |
 boost::vtkVertexGlobalMap | |
 boost::vtkVertexLocalMap | |
 boost::vtkVertexOwnerMap | |
 vtkWarpTransform | |
  vtkBSplineTransform | Cubic b-spline deformation transformation |
  vtkGridTransform | Nonlinear warp transformation |
 vtkXMLParser | |
  vtkBlueObeliskDataParser | Fill a vtkBlueObeliskData container with data from the BODR XML dataset |