| vtkKdTree::_cellList | |
| _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 | |
| ActionFunction< TWidget > | |
| vtkAnimationCue::AnimationCueInfo | |
| vtkExodusIIReaderPrivate::ArrayInfoType | A struct to hold information about time-varying arrays |
| vtkExodusIIReaderPrivate::AssemblyInfoType | |
| vtkStatisticsAlgorithm::AssessFunctor | |
| vtkFieldData::BasicIterator | |
| vtkExodusIIWriter::Block | |
| vtkAMRDataInternals::Block | |
| vtkExodusIIReaderPrivate::BlockInfoType | A struct to hold information about Exodus blocks |
| vtkExodusIIReaderPrivate::BlockSetInfoType | A struct to hold information about Exodus blocks or sets (they have some members in common) |
| vtkMultiThreshold::BooleanSet | A subset of a mesh represented as a boolean set operation |
| vtkTemporalStreamTracer::bounds | |
| BSPNode | |
| vtkTextureImageCache< Key >::CacheData | |
| vtkTextureImageCache< Key >::CacheElement | |
| vtkMergeFields::Component | |
| vtkSplitField::Component | |
| vtkUnicodeString::const_iterator | |
| vtkFieldData::CopyFieldFlag | |
| vtkMaskFields::CopyFieldFlag | |
| vtkAVSucdReader::DataInfo | |
| vtkDispatcherCommon::DynamicCaster< To, From > | |
| boost::edge_bundle_type< vtkDirectedGraph * > | |
| boost::edge_bundle_type< vtkDirectedGraph *const > | |
| boost::edge_bundle_type< vtkGraph * > | |
| boost::edge_bundle_type< vtkMutableDirectedGraph * > | |
| boost::edge_bundle_type< vtkMutableDirectedGraph *const > | |
| boost::edge_bundle_type< vtkMutableUndirectedGraph * > | |
| boost::edge_bundle_type< vtkMutableUndirectedGraph *const > | |
| boost::edge_bundle_type< vtkUndirectedGraph * > | |
| boost::edge_bundle_type< vtkUndirectedGraph *const > | |
| boost::edge_property< vtkGraph * > | |
| boost::edge_property_type< vtkDirectedGraph * > | |
| boost::edge_property_type< vtkDirectedGraph *const > | |
| boost::edge_property_type< vtkGraph * > | |
| boost::edge_property_type< vtkMutableDirectedGraph * > | |
| boost::edge_property_type< vtkMutableDirectedGraph *const > | |
| boost::edge_property_type< vtkMutableUndirectedGraph * > | |
| boost::edge_property_type< vtkMutableUndirectedGraph *const > | |
| boost::edge_property_type< vtkUndirectedGraph * > | |
| boost::edge_property_type< vtkUndirectedGraph *const > | |
| vtkSLACReader::EdgeEndpoints | |
| vtkGenericEdgeTable::EdgeEntry | |
| vtkOStreamWrapper::EndlType | |
| vtkFreeTypeUtilities::Entry | |
| vtkTest::ErrorObserver | |
| vtkQuadricDecimation::ErrorQuadric | |
| vtkDataSetAttributes::FieldList | |
| vtkpiston::float4tofloat3 | |
| vtkX3DExporterFIWriterHelper::float_to_unsigned_int_to_bytes | |
| vtkDispatcherPrivate::Functor< R, Parm1 > | |
| vtkDoubleDispatcherPrivate::Functor< R, Parm1, Parm2 > | |
| vtkDispatcherPrivate::FunctorDispatcherHelper< BaseLhs, SomeLhs, RT, CastLhs, Fun > | |
| vtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, RT, CastLhs, CastRhs, Fun > | |
| vtkDispatcherPrivate::FunctorHandler< ParentFunctor, Fun > | |
| vtkDoubleDispatcherPrivate::FunctorHandler< ParentFunctor, Fun > | |
| vtkDispatcherPrivate::FunctorImpl< R, P1 > | |
| vtkDoubleDispatcherPrivate::FunctorImpl< R, P1, P2 > | |
| vtkDispatcherPrivate::FunctorRefDispatcherHelper< BaseLhs, SomeLhs, RT, CastLhs, Fun > | |
| vtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, RT, CastLhs, CastRhs, Fun > | |
| boost::graph_traits< const vtkDirectedGraph * > | |
| boost::graph_traits< const vtkMutableDirectedGraph * > | |
| boost::graph_traits< const vtkMutableUndirectedGraph * > | |
| boost::graph_traits< const vtkTree * > | |
| boost::graph_traits< const vtkUndirectedGraph * > | |
| boost::graph_traits< vtkDirectedGraph * > | |
| boost::graph_traits< vtkDirectedGraph *const > | |
| boost::graph_traits< vtkGraph * > | |
| boost::graph_traits< vtkMutableDirectedGraph * > | |
| boost::graph_traits< vtkMutableDirectedGraph *const > | |
| boost::graph_traits< vtkMutableUndirectedGraph * > | |
| boost::graph_traits< vtkMutableUndirectedGraph *const > | |
| boost::graph_traits< vtkTree * > | |
| boost::graph_traits< vtkTree *const > | |
| boost::graph_traits< vtkUndirectedGraph * > | |
| boost::graph_traits< vtkUndirectedGraph *const > | |
| boost::hash< vtkEdgeType > | |
| vtkInformationInternals::HashFun | |
| vtkDenseArray< T >::HeapMemoryBlock | |
| vtkLabelHierarchy::Implementation | |
| vtkUnstructuredGridBunykRayCastFunction::Intersection | |
| vtkMultiThreshold::Interval | A subset of a mesh represented by a range of acceptable attribute values |
| vtkStreamTracer::IntervalInformation | |
| vtkGenericStreamTracer::IntervalInformation | |
| vtkPriorityQueue::Item | |
| vtkFieldData::Iterator | |
| IVFCacheList | |
| IVFDataSetInfo | |
| vtkLabelHierarchy::Implementation::LabelSet | |
| vtkParallelRenderManager::LightInfo | |
| vtkCellLinks::Link | |
| vtkDecimatePro::LocalTri | |
| vtkDecimatePro::LocalVertex | |
| vtkExodusIIReaderPrivate::MapInfoType | A struct to hold information about Exodus maps |
| vtkExodusIIReaderPrivate::MaterialInfoType | |
| vtkDenseArray< T >::MemoryBlock | |
| vtkSLACReader::MidpointCoordinateMap | |
| vtkSLACReader::MidpointCoordinates | |
| vtkSLACReader::MidpointIdMap | |
| vtkPiston::minmax_binary_op< T > | |
| vtkPiston::minmax_pair< T > | |
| vtkPiston::minmax_unary_op< T > | |
| vtkChart::MouseActions | |
| vtkChart::MouseClickActions | |
| vtkSmartPointerBase::NoReference | |
| vtkWeakPointerBase::NoReference | |
| vtkMultiThreshold::NormKey | A class with comparison operator used to index input array norms used in threshold rules |
| vtkExodusIIReaderPrivate::ObjectInfoType | A struct to hold information about Exodus objects (blocks, sets, maps) |
| OffsetsManager | Helper class due to PIMPL excess |
| OffsetsManagerArray | |
| OffsetsManagerGroup | |
| vtkRearrangeFields::Operation | |
| vtkCommunicator::Operation | |
| vtkTextCodec::OutputIterator | |
| vtkObjectFactory::OverrideInformation | |
| vtkParticleTracerBaseNamespace::ParticleInformation | |
| vtkTemporalStreamTracerNamespace::ParticleInformation | |
| ParticlePathFilterInternal | |
| vtkExodusIIReaderPrivate::PartInfoType | A struct to hold information about Exodus blocks |
| vtkHardwareSelector::PixelInformation | |
| vtkGenericEdgeTable::PointEntry | |
| vtkQuadricClustering::PointQuadric | |
| vtkParticleTracerBaseNamespace::Position | |
| vtkTemporalStreamTracerNamespace::Position | |
| vtkLabelHierarchy::Implementation::PriorityComparator | |
| vtkOpenGLContextDevice2D::Private | |
| boost::graph::parallel::process_group_type< vtkDirectedGraph * > | |
| boost::graph::parallel::process_group_type< vtkDirectedGraph *const > | |
| boost::graph::parallel::process_group_type< vtkGraph * > | |
| boost::graph::parallel::process_group_type< vtkUndirectedGraph * > | |
| boost::graph::parallel::process_group_type< vtkUndirectedGraph *const > | |
| boost::property_map< vtkDirectedGraph *, edge_index_t > | |
| boost::property_map< vtkDirectedGraph *, vertex_index_t > | |
| boost::property_map< vtkDirectedGraph *const, edge_index_t > | |
| boost::property_map< vtkDirectedGraph *const, vertex_index_t > | |
| boost::property_map< vtkGraph *, edge_global_t > | |
| boost::property_map< vtkGraph *, edge_index_t > | |
| boost::property_map< vtkGraph *, vertex_global_t > | |
| boost::property_map< vtkGraph *, vertex_index_t > | |
| boost::property_map< vtkGraph *, vertex_local_t > | |
| boost::property_map< vtkGraph *, vertex_owner_t > | |
| boost::property_map< vtkUndirectedGraph *, edge_index_t > | |
| boost::property_map< vtkUndirectedGraph *, vertex_index_t > | |
| boost::property_map< vtkUndirectedGraph *const, edge_index_t > | |
| boost::property_map< vtkUndirectedGraph *const, vertex_index_t > | |
| 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 > | |
| ReferenceCountModel | |
| vtkPParticleTracerBase::RemoteParticleInfo | |
| vtkCompositePainter::RenderBlockState | |
| vtkParallelRenderManager::RendererInfo | |
| vtkSynchronizedRenderers::RendererInfo | |
| vtkParallelRenderManager::RenderWindowInfo | |
| vtkSynchronizedRenderWindows::RenderWindowInfo | |
| vtkMPICommunicator::Request | |
| vtkMultiThreshold::Set | A base class for representing threshold sets |
| vtkExodusIIReaderPrivate::SetInfoType | A struct to hold information about Exodus sets |
| vtkDenseArray< T >::StaticMemoryBlock | |
| StreaklineFilterInternal | |
| vtkStreamer::StreamArray | |
| vtkStreamer::StreamPoint | |
| tagBlock | |
| tagFlashReaderDoubleScalar | |
| tagFlashReaderIntegerScalar | |
| tagFlashReaderSimulationInformation | |
| tagFlashReaderSimulationParameters | |
| Test | |
| TextPropertyKey | |
| vtkMultiThreader::ThreadInfo | |
| vtkUnstructuredGridBunykRayCastFunction::Triangle | |
| vtkDecimatePro::TriArray | |
| vtkpiston::tuple2float3 | |
| vtkDispatcherCommon::TypeInfo | |
| vtkExodusIIWriter::VariableInfo | |
| vector | |
| boost::vertex_bundle_type< vtkDirectedGraph * > | |
| boost::vertex_bundle_type< vtkDirectedGraph *const > | |
| boost::vertex_bundle_type< vtkGraph * > | |
| boost::vertex_bundle_type< vtkMutableDirectedGraph * > | |
| boost::vertex_bundle_type< vtkMutableDirectedGraph *const > | |
| boost::vertex_bundle_type< vtkMutableUndirectedGraph * > | |
| boost::vertex_bundle_type< vtkMutableUndirectedGraph *const > | |
| boost::vertex_bundle_type< vtkUndirectedGraph * > | |
| boost::vertex_bundle_type< vtkUndirectedGraph *const > | |
| boost::vertex_property< vtkGraph * > | |
| boost::vertex_property_type< vtkDirectedGraph * > | |
| boost::vertex_property_type< vtkDirectedGraph *const > | |
| boost::vertex_property_type< vtkGraph * > | |
| boost::vertex_property_type< vtkMutableDirectedGraph * > | |
| boost::vertex_property_type< vtkMutableDirectedGraph *const > | |
| boost::vertex_property_type< vtkMutableUndirectedGraph * > | |
| boost::vertex_property_type< vtkMutableUndirectedGraph *const > | |
| boost::vertex_property_type< vtkUndirectedGraph * > | |
| boost::vertex_property_type< vtkUndirectedGraph *const > | |
| vtkDecimatePro::VertexArray | |
| vtkView::ViewProgressEventCallData | |
| vtk2DHistogramItem | 2D histogram item |
| vtk3DSImporter | Imports 3D Studio files |
| vtk3DWidget | Abstract superclass for 3D widgets |
| vtk__Int64Array | Dynamic, self-adjusting array of __int64 |
| boost::vtk_edge_iterator | |
| boost::vtk_in_edge_pointer_iterator | |
| boost::vtk_out_edge_pointer_iterator | |
| vtkpiston::vtk_polydata | |
| boost::vtk_vertex_iterator | |
| vtkABI | Manage macros for exporting symbols in the binary interface |
| vtkAbstractArray | Abstract superclass for all arrays |
| vtkAbstractCellLocator | Abstract base class for locators which find cells |
| vtkAbstractContextBufferId | 2D array of ids, used for picking |
| vtkAbstractContextItem | Base class for items that are part of a vtkContextScene |
| vtkAbstractElectronicData | Provides access to and storage of chemical electronic data |
| vtkAbstractGridConnectivity | |
| vtkAbstractImageInterpolator | Interpolate data values from images |
| vtkAbstractInterpolatedVelocityField | An abstract class for obtaining the interpolated velocity values at a point |
| vtkAbstractMapper | Abstract class specifies interface to map data |
| vtkAbstractMapper3D | Abstract class specifies interface to map 3D data |
| vtkAbstractParticleWriter | Abstract class to write particle data to file |
| vtkAbstractPicker | Define API for picking subclasses |
| vtkAbstractPointLocator | Abstract class to quickly locate points in 3-space |
| vtkAbstractPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D while maintaining a fixed orientation w.r.t the camera |
| vtkAbstractPropPicker | Abstract API for pickers that can pick an instance of vtkProp |
| vtkAbstractTransform | Superclass for all geometric transformations |
| vtkAbstractVolumeMapper | Abstract class for a volume mapper |
| vtkAbstractWidget | Define the API for widget / widget representation |
| vtkActor | Object (geometry & properties) in a rendered scene |
| vtkActor2D | Actor that draws 2D data |
| vtkActor2DCollection | List of 2D actors |
| vtkActorCollection | List of actors |
| vtkAddMembershipArray | Add an array to the output indicating membership within an input selection |
| vtkAdjacencyMatrixToEdgeTable | |
| vtkAdjacentVertexIterator | Iterates through adjacent vertices in a graph |
| vtkAffineRepresentation | Abstract class for representing affine transformation widgets |
| vtkAffineRepresentation2D | Represent 2D affine transformations |
| vtkAffineWidget | Perform affine transformations |
| vtkAlgorithm | Superclass for all sources, filters, and sinks in VTK |
| vtkAlgorithmOutput | Proxy object to connect input/output ports |
| vtkAmoebaMinimizer | Nonlinear optimization with a simplex |
| vtkAMRBaseParticlesReader | |
| vtkAMRBaseReader | |
| vtkAMRBox | Encloses a rectangular region of voxel like cells |
| vtkAMRCutPlane | |
| vtkAMRDataInternals | Container of vtkUniformGrid for an AMR data set |
| vtkAMRDataSetCache | |
| vtkAMREnzoParticlesReader | |
| vtkAMREnzoReader | |
| vtkAMREnzoReaderInternal | |
| vtkAMRFlashParticlesReader | |
| vtkAMRFlashReader | |
| vtkAMRFlashReaderInternal | |
| vtkAMRGaussianPulseSource | |
| vtkAMRInformation | Meta data that describes the structure of an AMR data set |
| vtkAMRInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point in AMR data |
| vtkAMRResampleFilter | |
| vtkAMRSliceFilter | |
| vtkAMRToMultiBlockFilter | |
| vtkAMRUtilities | |
| vtkAMRVolumeMapper | AMR class for a volume mapper |
| vtkAngleRepresentation | Represent the vtkAngleWidget |
| vtkAngleRepresentation2D | Represent the vtkAngleWidget |
| vtkAngleRepresentation3D | Represent the vtkAngleWidget |
| vtkAngleWidget | Measure the angle between two rays (defined by three points) |
| vtkAnimationCue | Seqin an animation |
| vtkAnimationScene | Animation scene manager |
| vtkAnnotatedCubeActor | 3D cube with face labels |
| vtkAnnotation | Stores a collection of annotation artifacts |
| vtkAnnotationLayers | Stores a ordered collection of annotation sets |
| vtkAnnotationLayersAlgorithm | Superclass for algorithms that produce only vtkAnnotationLayers as output |
| vtkAnnotationLink | An algorithm for linking annotations among objects |
| vtkAppendCompositeDataLeaves | Appends one or more composite datasets with the same structure together into a single output composite dataset |
| vtkAppendFilter | Appends one or more datasets together into a single unstructured grid |
| vtkAppendPoints | Appends points of one or more vtkPolyData data sets |
| vtkAppendPolyData | Appends one or more polygonal datasets together |
| vtkAppendSelection | Appends one or more selections together |
| vtkApplyColors | Apply colors to a data set |
| vtkApplyIcons | Apply icons to a data set |
| vtkApproximatingSubdivisionFilter | Generate a subdivision surface using an Approximating Scheme |
| vtkArcParallelEdgeStrategy | Routes parallel edges as arcs |
| vtkArcPlotter | Plot data along an arbitrary polyline |
| vtkArcSource | Create an arc between two end points |
| vtkAreaContourSpectrumFilter | Compute an approximation of the area contour signature (evolution of the area of the input surface along an arc of the Reeb graph) |
| vtkAreaLayout | Layout a vtkTree into a tree map |
| vtkAreaLayoutStrategy | Abstract superclass for all area layout strategies |
| vtkAreaPicker | Picks props behind a selection rectangle on a viewport |
| vtkArray | Abstract interface for N-dimensional arrays |
| vtkArrayCalculator | Perform mathematical operations on data in field data arrays |
| vtkArrayCoordinates | Stores coordinate into an N-way array |
| vtkArrayData | Pipeline data object that contains multiple vtkArray objects |
| vtkArrayDataAlgorithm | Superclass for algorithms that produce vtkArrayDatas as output |
| vtkArrayDataReader | Reads vtkArrayData written by vtkArrayDataWriter |
| vtkArrayDataWriter | Serialize vtkArrayData to a file or stream |
| vtkArrayExtents | Stores the number of dimensions and valid coordinate ranges along each dimension for vtkArray |
| vtkArrayExtentsList | Stores a collection of vtkArrayExtents objects |
| vtkArrayInterpolate | |
| vtkArrayIterator | Abstract superclass to iterate over elements in an vtkAbstractArray |
| vtkArrayIteratorIncludes | Centralize array iterator type includes required when using the vtkArrayIteratorTemplateMacro |
| vtkArrayIteratorTemplate< T > | Implementation template for a array iterator |
| vtkArrayNorm | Computes L-norms along one dimension of an array |
| vtkArrayPrint | Print arrays in different formats |
| vtkArrayRange | Stores a half-open range of array coordinates |
| vtkArrayReader | Reads sparse and dense vtkArray data written by vtkArrayWriter |
| vtkArraySort | Controls sorting of sparse array coordinates |
| vtkArrayToTable | Converts one- and two-dimensional vtkArrayData objects to vtkTable |
| vtkArrayWeights | Stores a collection of weighting factors |
| vtkArrayWriter | Serialize sparse and dense arrays to a file or stream |
| vtkArrowSource | Appends a cylinder to a cone to form an arrow |
| vtkASCIITextCodec | Class to read/write ascii text |
| vtkAssembly | Create hierarchies of vtkProp3Ds (transformable props) |
| vtkAssemblyNode | Represent a node in an assembly |
| vtkAssemblyPath | List of nodes that form an assembly path |
| vtkAssemblyPaths | List of lists of props representing an assembly hierarchy |
| 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 |
| vtkAssignCoordinatesLayoutStrategy | Uses array values to set vertex locations |
| vtkAtom | Convenience proxy for vtkMolecule |
| vtkAttributeClustering2DLayoutStrategy | Simple fast 2D graph layout |
| vtkAttributeDataToFieldDataFilter | Map attribute data to field data |
| vtkAttributesErrorMetric | Objects that compute attribute-based error during cell tessellation |
| vtkAutoCorrelativeStatistics | A class for univariate auto-correlative statistics |
| vtkAVIWriter | Writes Windows AVI files |
| vtkAVSucdReader | Reads a dataset in AVS "UCD" format |
| vtkAxes | Create an x-y-z axes |
| vtkAxesActor | 3D axes representation |
| vtkAxesTransformRepresentation | Represent the vtkAxesTransformWidget |
| vtkAxesTransformWidget | 3D widget for performing 3D transformations around an axes |
| vtkAxis | Takes care of drawing 2D axes |
| vtkAxisActor | Create an axis with tick marks and labels |
| vtkAxisActor2D | Create an axis with tick marks and labels |
| vtkAxisExtended | Octree-based spatial search object to quickly locate cells |
| vtkAxisFollower | Subclass of vtkFollower that ensures that data is always parallel to the axis defined by a vtkAxisActor |
| vtkBalloonRepresentation | Represent the vtkBalloonWidget |
| vtkBalloonWidget | Popup text balloons above instance of vtkProp when hovering occurs |
| vtkBandedPolyDataContourFilter | Generate filled contours for vtkPolyData |
| vtkBarChartActor | Create a bar chart from an array |
| vtkBase64InputStream | Reads base64-encoded input from a stream |
| vtkBase64OutputStream | Writes base64-encoded output to a stream |
| vtkBase64Utilities | Base64 encode and decode utilities |
| vtkBezierContourLineInterpolator | Interpolates supplied nodes with bezier line segments |
| vtkBiDimensionalRepresentation | Represent the vtkBiDimensionalWidget |
| vtkBiDimensionalRepresentation2D | Represent the vtkBiDimensionalWidget |
| vtkBiDimensionalWidget | Measure the bi-dimensional lengths of an object |
| vtkBiomTableReader | Read vtkTable from a .biom input file |
| vtkBiQuadraticQuad | Cell represents a parabolic, 9-node isoparametric quad |
| vtkBiQuadraticQuadraticHexahedron | Cell represents a biquadratic, 24-node isoparametric hexahedron |
| vtkBiQuadraticQuadraticWedge | Cell represents a parabolic, 18-node isoparametric wedge |
| vtkBiQuadraticTriangle | Cell represents a parabolic, isoparametric triangle |
| vtkBitArray | Dynamic, self-adjusting array of bits |
| vtkBitArrayIterator | Iterator for vtkBitArray. This iterator iterates over a vtkBitArray. It uses the double interface to get/set bit values |
| vtkBivariateLinearTableThreshold | Performs line-based thresholding for vtkTable data |
| vtkBlankStructuredGrid | Translate point attribute data into a blanking field |
| vtkBlankStructuredGridWithImage | Blank a structured grid with an image |
| vtkBlockDistribution | A helper class that manages a block distribution of N elements of data |
| vtkBlockIdScalars | Generates scalars from blocks |
| vtkBlockItem | VtkContextItem that draws a block (optional label) |
| vtkBlueObeliskData | Contains chemical data from the Blue Obelisk Data Repository |
| vtkBlueObeliskDataParser | Fill a vtkBlueObeliskData container with data from the BODR XML dataset |
| vtkBMPReader | Read Windows BMP files |
| vtkBMPWriter | Writes Windows BMP files |
| vtkBond | Convenience proxy for vtkMolecule |
| vtkBooleanOperationPolyDataFilter | |
| vtkBooleanTexture | Generate 2D texture map based on combinations of inside, outside, and on region boundary |
| vtkBoostBetweennessClustering | Implements graph clustering based on edge betweenness centrality |
| vtkBoostBiconnectedComponents | Find the biconnected components of a graph |
| vtkBoostBrandesCentrality | Compute Brandes betweenness centrality on a vtkGraph |
| vtkBoostBreadthFirstSearch | Boost breadth_first_search on a vtkGraph |
| vtkBoostBreadthFirstSearchTree | Contructs a BFS tree from a graph |
| vtkBoostConnectedComponents | Find the connected components of a graph |
| vtkBoostDividedEdgeBundling | Layout graph edges in directed edge bundles |
| vtkBoostExtractLargestComponent | Extract the largest connected component of a graph |
| vtkBoostKruskalMinimumSpanningTree | Contructs a minimum spanning tree from a graph and the weighting array |
| vtkBoostLogWeighting | Given an arbitrary-dimension array of doubles, replaces each value x with one of: |
| vtkBoostPrimMinimumSpanningTree | Contructs a minimum spanning tree from a graph, start node, and the weighting array |
| vtkBoostRandomSparseArraySource | Generates a sparse N-way array containing random values |
| vtkBoostSplitTableField | "Splits" one-or-more table fields by duplicating rows containing delimited data |
| vtkBorderRepresentation | Represent a vtkBorderWidget |
| vtkBorderWidget | Place a border around a 2D rectangular region |
| vtkBoundedPlanePointPlacer | Placer that constrains a handle to a finite plane |
| vtkBoundingBox | Fast Simple Class for dealing with 3D bounds |
| vtkBox | Implicit function for a bounding box |
| vtkBoxClipDataSet | Clip an unstructured grid |
| vtkBoxLayoutStrategy | Tree map layout that puts vertices in square-ish boxes |
| vtkBoxMuellerRandomSequence | Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform |
| vtkBoxRepresentation | Class defining the representation for the vtkBoxWidget2 |
| vtkBoxWidget | Orthogonal hexahedron 3D widget |
| vtkBoxWidget2 | 3D widget for manipulating a box |
| vtkBreakPoint | Utility function to debug with gdb and MPI |
| vtkBridgeAttribute | Implementation of vtkGenericAttribute |
| vtkBridgeCell | Implementation of vtkGenericAdaptorCell |
| 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 |
| vtkBridgeCellIteratorOnCellBoundaries | Iterate over boundary cells of a cell |
| 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 |
| 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, |
| vtkBridgeDataSet | Implementation of vtkGenericDataSet |
| vtkBridgeExport | Manage Windows system differences |
| vtkBridgePointIterator | Implementation of vtkGenericPointIterator |
| vtkBridgePointIteratorOnCell | Implementation of vtkGenericPointIterator |
| vtkBridgePointIteratorOnDataSet | Implementation of vtkGenericPointIterator |
| vtkBridgePointIteratorOne | Iterate over one point of a dataset |
| vtkBrokenLineWidget | 3D widget for manipulating a broken line |
| vtkBrownianPoints | Assign random vector to points |
| vtkBrush | Brush that fills shapes drawn by vtkContext2D |
| vtkBSPCuts | This class represents an axis-aligned Binary Spatial Partitioning of a 3D space |
| vtkBSPIntersections | Perform calculations (mostly intersection calculations) on regions of a 3D binary spatial partitioning |
| vtkBSplineTransform | Cubic b-spline deformation transformation |
| vtkButterflySubdivisionFilter | Generate a subdivision surface using the Butterfly Scheme |
| vtkButtonRepresentation | Abstract class defines the representation for a vtkButtonWidget |
| vtkButtonSource | Abstract class for creating various button types |
| vtkButtonWidget | Activate an n-state button |
| vtkByteSwap | Perform machine dependent byte swapping |
| vtkBYUReader | Read MOVIE.BYU polygon files |
| vtkBYUWriter | Write MOVIE.BYU files |
| vtkCachedStreamingDemandDrivenPipeline | |
| vtkCachingInterpolatedVelocityField | Interface for obtaining interpolated velocity values |
| vtkCallbackCommand | Supports function callbacks |
| vtkCamera | Virtual camera for 3D rendering |
| vtkCameraActor | Frustum to represent a camera |
| vtkCameraInterpolator | Interpolate a series of cameras to update a new camera |
| vtkCameraPass | Implement the camera render pass |
| vtkCameraRepresentation | Represent the vtkCameraWidget |
| vtkCameraWidget | 2D widget for saving a series of camera views |
| vtkCaptionActor2D | Draw text label associated with a point |
| vtkCaptionRepresentation | VtkCaptionWidget in the scene |
| vtkCaptionWidget | Widget for placing a caption (text plus leader) |
| vtkCarbonRenderWindow | Carbon OpenGL rendering window |
| vtkCarbonRenderWindowInteractor | Implements Carbon specific functions required by vtkRenderWindowInteractor |
| vtkCardinalSpline | Computes an interpolating spline using a a Cardinal basis |
| vtkDispatcherCommon::vtkCaster< To, From > | |
| vtkCastToConcrete | Works around type-checking limitations |
| vtkCell | Abstract class to specify cell behavior |
| vtkCell3D | Abstract class to specify 3D cell interface |
| vtkCellArray | Object to represent cell connectivity |
| vtkCellCenterDepthSort | A simple implementation of vtkCellDepthSort |
| vtkCellCenters | Generate points at center of cells |
| vtkCellCentersPointPlacer | Snaps points at the center of a cell |
| vtkCellData | Represent and manipulate cell attribute data |
| vtkCellDataToPointData | Map cell data to point data |
| vtkCellDerivatives | Compute derivatives of scalars and vectors |
| vtkCellDistanceSelector | Select neighbor cells up to a distance |
| vtkCellLinks | Object represents upward pointers from points to list of cells using each point |
| vtkCellLocator | Octree-based spatial search object to quickly locate cells |
| vtkCellLocatorInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point |
| vtkCellPicker | Ray-cast cell picker for all kinds of Prop3Ds |
| vtkCellQuality | Calculate functions of quality of the elements of a mesh |
| vtkCellTreeLocator::vtkCellTree | |
| 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 |
| vtkCellTreeLocator::vtkCellTreeNode | |
| vtkCellType | Define types of cells |
| vtkCellTypes | Object provides direct access to cells in vtkCellArray and type information |
| vtkCenteredSliderRepresentation | Provide the representation for a vtkCenteredSliderWidget |
| vtkCenteredSliderWidget | Set a value by manipulating a slider |
| vtkCenterOfMass | Find the center of mass of a set of points |
| vtkCGMWriter | Write polygonal data as a CGM file |
| vtkChacoGraphReader | Reads chaco graph files |
| vtkChacoReader | Read a Chaco file and create a vtkUnstructuredGrid |
| vtkCharArray | Dynamic, self-adjusting array of char |
| vtkChart | Factory class for drawing 2D charts |
| vtkChart2DHistogram | Chart for 2D histograms |
| vtkChartHistogram2D | |
| vtkChartLegend | Draw the chart legend |
| vtkChartMatrix | Container for a matrix of charts |
| vtkChartParallelCoordinates | Factory class for drawing 2D charts |
| vtkChartPie | Factory class for drawing pie charts |
| vtkChartPlotData | |
| vtkChartSelectionHelper | Helper functions for making selections in charts |
| vtkChartXY | Factory class for drawing XY charts |
| vtkChartXYZ | Factory class for drawing 3D XYZ charts |
| vtkCheckerboardRepresentation | Represent the vtkCheckerboardWidget |
| vtkCheckerboardWidget | Interactively set the number of divisions in 2D image checkerboard |
| vtkChooserPainter | Painter that selects painters to render primitives |
| vtkCirclePackFrontChainLayoutStrategy | Layout a vtkTree into packed circles using the front chain algorithm |
| vtkCirclePackLayout | Layout a vtkTree as a circle packing |
| vtkCirclePackLayoutStrategy | Abstract superclass for all circle packing layout strategies |
| vtkCirclePackToPolyData | Converts a tree to a polygonal data representing a circle packing of the hierarchy |
| vtkCircularLayoutStrategy | Places vertices around a circle |
| vtkCleanPolyData | Merge duplicate points, and/or remove unused points and/or remove degenerate cells |
| vtkClearZPass | Clear the depth buffer with a given value |
| vtkClientServerCompositePass | |
| vtkClientServerSynchronizedRenderers | |
| vtkClientSocket | Encapsulates a client socket |
| vtkClipClosedSurface | Clip a closed surface with a plane collection |
| vtkClipConvexPolyData | Clip any dataset with user-specified implicit function or input scalar data |
| 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 |
| vtkClipPlanesPainter | Abstract class defining interface for painter that manages clipping |
| vtkClipPolyData | Clip polygonal data with user-specified implicit function or input scalar data |
| vtkClipVolume | Clip volume data with user-specified implicit function or input scalar data |
| vtkClosedSurfacePointPlacer | PointPlacer to constrain validity within a set of convex planes |
| vtkClustering2DLayoutStrategy | Simple fast 2D graph layout |
| vtkCMLMoleculeReader | Read a CML file and output a vtkMolecule object |
| vtkCocoaGLView | Cocoa OpenGL rendering context |
| vtkCocoaMacOSXSDKCompatibility | Compatibility header |
| vtkCocoaRenderWindow | Cocoa OpenGL rendering window |
| vtkCocoaRenderWindowInteractor | Implements Cocoa specific functions required by vtkRenderWindowInteractor |
| vtkCocoaTkUtilities | Internal Tk Routines for Cocoa |
| vtkCoincidentPoints | Octree of labels |
| vtkCoincidentTopologyResolutionPainter | Painter that resolves conicident topology |
| vtkCollapseGraph | "Collapses" vertices onto their neighbors |
| vtkCollapseVerticesByArray | Collapse the graph given a vertex array |
| vtkCollectGraph | Collect distributed graph |
| vtkCollection | Create and manipulate unsorted lists of objects |
| vtkCollectionElement | |
| vtkCollectionIterator | Iterator through a vtkCollection |
| vtkCollectPolyData | Collect distributed polydata |
| vtkCollectTable | Collect distributed table |
| vtkColor | Templated type for storage of colors |
| vtkColor3< T > | |
| vtkColor3d | |
| vtkColor3f | |
| vtkColor3ub | |
| vtkColor4< T > | |
| vtkColor4d | |
| vtkColor4f | |
| vtkColor4ub | |
| vtkColorLegend | Legend item to display vtkScalarsToColors |
| vtkColorMaterialHelper | Helper to assist in simulating the ColorMaterial behaviour of the default OpenGL pipeline |
| vtkColorSeries | Stores a list of colors |
| vtkColorTransferControlPointsItem | Control points for vtkColorTransferFunction |
| vtkColorTransferFunction | Defines a transfer function for mapping a property to an RGB color value |
| vtkColorTransferFunctionItem | |
| vtkCommand | Superclass for callback/observer methods |
| vtkCommonInformationKeyManager | Manages key types in vtkCommon |
| vtkCommunicator | Used to send/receive messages in a multiprocess environment |
| 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 |
| vtkCompassRepresentation | Provide a compass |
| vtkCompassWidget | Set a value by manipulating something |
| vtkCompositeControlPointsItem | Control points for vtkCompositeFunction |
| vtkCompositeCutter | Cut composite data sets with user-specified implicit function |
| vtkCompositeDataDisplayAttributes | Rendering attributes for a multi-block dataset |
| vtkCompositeDataGeometryFilter | Extract geometry from multi-group data |
| vtkCompositeDataIterator | Superclass for composite data iterators |
| vtkCompositeDataPipeline | Executive supporting composite datasets |
| vtkCompositeDataProbeFilter | Subclass of vtkProbeFilter which supports composite datasets in the input |
| vtkCompositeDataReader | Read vtkCompositeDataSet data file |
| vtkCompositeDataSet | Abstract superclass for composite (multi-block or AMR) datasets |
| vtkCompositeDataSetAlgorithm | Superclass for algorithms that produce only vtkCompositeDataSet as output |
| vtkCompositeDataWriter | Legacy VTK file writer for vtkCompositeDataSet subclasses |
| vtkCompositedSynchronizedRenderers | |
| vtkCompositeInterpolatedVelocityField | An abstract class for obtaining the interpolated velocity values at a point |
| vtkCompositeInterpolatedVelocityFieldDataSetsType | |
| vtkCompositePainter | Painter that can be inserted before any vtkDataSet painting chain to handle composite datasets |
| vtkCompositePolyDataMapper | Class that renders hierarchical polygonal data |
| vtkCompositePolyDataMapper2 | Mapper for composite dataset consisting of polygonal data |
| vtkCompositer | Super class for composite algorthms |
| vtkCompositeRenderManager | An object to control sort-last parallel rendering |
| vtkCompositeRGBAPass | Blend RGBA buffers of processes |
| vtkCompositeTransferFunctionItem | |
| vtkCompositeZPass | Merge depth buffers of processes |
| vtkCompressCompositer | Implements compressed tree based compositing |
| vtkComputeHistogram2DOutliers | Compute the outliers in a set of 2D histograms and extract the corresponding row data |
| vtkComputingResources | Definition of computing resource (threads/kernels) |
| vtkConditionVariable | Mutual exclusion locking class |
| vtkCone | Implicit function for a cone |
| vtkConeLayoutStrategy | Produce a cone-tree layout for a forest |
| vtkConeSource | Generate polygonal cone |
| vtkConnectivityFilter | Extract data based on geometric connectivity |
| 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) |
| vtkConstrainedPointHandleRepresentation | Point representation constrained to a 2D plane |
| vtkContext2D | Class for drawing 2D primitives to a graphical context |
| vtkContext3D | Class for drawing 3D primitives to a graphical context |
| vtkContextActor | VtkProp derived object |
| vtkContextBufferId | 2D array of ids, used for picking |
| vtkContextClip | All children of this item are clipped by the specified area |
| vtkContextDevice2D | Abstract class for drawing 2D primitives |
| vtkContextDevice3D | Abstract class for drawing 3D primitives |
| 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 |
| vtkContextItem | Base class for items that are part of a vtkContextScene |
| vtkContextKeyEvent | Data structure to represent key events |
| vtkContextMapper2D | Abstract class for 2D context mappers |
| vtkContextMouseEvent | Data structure to represent mouse events |
| vtkContextPolygon | |
| vtkContextScene | Provides a 2D scene for vtkContextItem objects |
| vtkContextScenePrivate | Private implementation for scene/items |
| vtkContextTransform | All children of this item are transformed by the vtkTransform2D of this item |
| vtkContextView | View of the vtkContextScene |
| 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 |
| vtkContinuousValueWidget | Set a value by manipulating something |
| vtkContinuousValueWidgetRepresentation | Provide the representation for a continuous value |
| vtkContourFilter | Generate isosurfaces/isolines from scalar values |
| vtkContourGrid | Generate isosurfaces/isolines from scalar values (specialized for unstructured grids) |
| vtkContourHelper | A utility class used by various contour filters |
| vtkContourLineInterpolator | Defines API for interpolating/modifying nodes from a vtkContourRepresentation |
| vtkContourRepresentation | Represent the vtkContourWidget |
| vtkContourRepresentationInternals | |
| vtkContourRepresentationNode | |
| vtkContourRepresentationPoint | |
| vtkContourTriangulator | Fill all 2D contours to create polygons |
| vtkContourValues | Helper object to manage setting and generating contour values |
| vtkContourWidget | Create a contour with a set of points |
| vtkControlPointsItem | Abstract class for control points items |
| vtkConvertSelection | Convert a selection from one type to another |
| vtkConvertSelectionDomain | Convert a selection from one domain to another |
| vtkConvexHull2D | Produce filled convex hulls around a set of points |
| vtkConvexPointSet | 3D cell defined by a set of convex points |
| vtkCoordinate | Perform coordinate transformation, and represent position, in a variety of vtk coordinate systems |
| vtkCoreGraphicsGPUInfoList | Get GPUs VRAM information using CoreGraphics |
| vtkCornerAnnotation | Text annotation in four corners |
| vtkCorrelativeStatistics | A class for bivariate linear correlation |
| vtkCorrelativeStatisticsGnuR | A class for bivariate linear correlation using R to calculate the p-values |
| vtkCosmicTreeLayoutStrategy | Tree layout strategy reminiscent of astronomical systems |
| vtkCriticalSection | Critical section locking class |
| vtkCubeAxesActor | Create a plot of a bounding box edges - |
| vtkCubeAxesActor2D | Create a 2D plot of a bounding box edges - used for navigation |
| vtkCubeSource | Create a polygonal representation of a cube |
| vtkCubicLine | Cell represents a cubic , isoparametric 1D line |
| vtkCuller | Superclass for prop cullers |
| vtkCullerCollection | List of Cullers |
| 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 |
| vtkCylinder | Implicit function for a cylinder |
| vtkCylinderSource | Generate a cylinder centered at origin |
| vtkCylindricalTransform | Cylindrical to rectangular coords and back |
| vtkDashedStreamLine | Generate constant-time dashed streamline in arbitrary dataset |
| vtkDataArray | Abstract superclass for arrays of numeric data |
| vtkDataArrayCollection | Maintain an unordered list of dataarray objects |
| vtkDataArrayCollectionIterator | Iterator through a vtkDataArrayCollection |
| vtkDataArrayDispatcher< DefaultFunctorType, ReturnType > | Dispatch to functor vtkDataArrayType |
| vtkDataArrayDispatcherPointer< T > | |
| vtkDataArraySelection | Store on/off settings for data arrays for a vtkSource |
| vtkDataArrayTemplate< T > | Implementation template for vtkDataArray |
| vtkDatabaseToTableReader | Read an SQL table as a vtkTable |
| vtkDataCompressor | Abstract interface for data compression classes |
| vtkDataObject | General representation of visualization data |
| vtkDataObjectAlgorithm | Superclass for algorithms that produce only data object as output |
| vtkDataObjectCollection | Maintain an unordered list of data objects |
| vtkDataObjectGenerator | Produces simple (composite or atomic) data sets for testing |
| vtkDataObjectReader | Read vtk field data file |
| vtkDataObjectToDataSetFilter | Map field data to concrete dataset |
| vtkDataObjectToTable | Extract field data as a table |
| vtkDataObjectTree | Implementation for most abstract methods in the superclass vtkCompositeDataSet |
| vtkDataObjectTreeIndex | |
| vtkDataObjectTreeInternals | |
| vtkDataObjectTreeItem | |
| vtkDataObjectTreeIterator | Superclass for composite data iterators |
| vtkDataObjectTypes | |
| vtkDataObjectWriter | Write vtk field data |
| vtkDataReader | Helper superclass for objects that read vtk data files |
| vtkDataRepresentation | The superclass for all representations |
| vtkDataSet | Abstract class to specify dataset behavior |
| vtkDataSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| vtkDataSetAttributes | Represent and manipulate attribute data in a dataset |
| vtkDataSetCollection | Maintain an unordered list of dataset objects |
| vtkDataSetEdgeSubdivisionCriterion | Subclass of vtkEdgeSubdivisionCriterion for vtkDataSet objects |
| vtkDataSetGhostGenerator | |
| vtkDataSetGradient | Computes scalar field gradient |
| vtkDataSetGradientPrecompute | |
| vtkDataSetMapper | Map vtkDataSet and derived classes to graphics primitives |
| vtkDataSetReader | Class to read any type of vtk dataset |
| vtkDataSetSurfaceFilter | Extracts outer (polygonal) surface |
| vtkDataSetToDataObjectFilter | Map dataset into data object (i.e., a field) |
| vtkDataSetToPiston | Converts a DataSet to a PistonDataObject |
| vtkDataSetTriangleFilter | Triangulate any type of dataset |
| vtkDataSetWriter | Write any type of vtk dataset to file |
| vtkDataTransferHelper | Helper class that aids in transferring data between CPU memory and GPU memory |
| vtkDataWriter | Helper class for objects that write vtk data files |
| vtkDebugLeaks | Identify memory leaks at program termination |
| vtkDebugLeaksManager | Manages the vtkDebugLeaks singleton |
| vtkDebugLeaksObserver | |
| vtkDecimatePolylineFilter | Reduce the number of lines in a polyline |
| vtkDecimatePro | Reduce the number of triangles in a mesh |
| vtkDefaultPainter | Sets up a default chain of painters |
| vtkDefaultPass | Implement the basic render passes |
| vtkDeformPointSet | Use a control polyhedron to deform an input vtkPointSet |
| vtkDelaunay2D | Create 2D Delaunay triangulation of input points |
| vtkDelaunay3D | Create 3D Delaunay triangulation of input points |
| vtkDelimitedTextReader | Reads in delimited ascii or unicode text files and outputs a vtkTable data structure |
| vtkDelimitedTextWriter | Delimited text writer for vtkTable Writes a vtkTable as a delimited text file (such as CSV) |
| vtkDemandDrivenPipeline | Executive supporting on-demand execution |
| vtkDEMReader | Read a digital elevation model (DEM) file |
| vtkDenseArray< T > | Contiguous storage for N-way arrays |
| vtkDensifyPolyData | Densify the input by adding points at the centroid |
| vtkNetCDFCFReader::vtkDependentDimensionInfo | |
| vtkDepthPeelingPass | Implement an Order Independent Transparency render pass |
| vtkDepthSortPolyData | Sort poly data along camera view direction |
| vtkDescriptiveStatistics | A class for univariate descriptive statistics |
| vtkDescriptiveStatisticsGnu | A class for univariate descriptive statistics using R to calculate p-values |
| vtkDescriptiveStatisticsGnuR | |
| vtkDiagonalMatrixSource | Generates a sparse or dense square matrix with user-specified values for the diagonal, superdiagonal, and subdiagonal |
| vtkDicer | Abstract superclass to divide dataset into pieces |
| vtkDICOMImageReader | Reads some DICOM images |
| vtkDijkstraGraphGeodesicPath | Dijkstra algorithm to compute the graph geodesic |
| vtkDijkstraGraphInternals | Helper class due to PIMPL excess |
| vtkDijkstraImageContourLineInterpolator | Contour interpolator for placing points on an image |
| vtkDijkstraImageGeodesicPath | Dijkstra algorithm to compute the graph geodesic |
| vtkDIMACSGraphReader | Reads vtkGraph data from a DIMACS formatted file |
| vtkDIMACSGraphWriter | Write vtkGraph data to a DIMACS formatted file |
| vtkNetCDFCFReader::vtkDimensionInfo | |
| vtkDirectedAcyclicGraph | A rooted tree data structure |
| vtkDirectedGraph | A directed graph |
| vtkDirectedGraphAlgorithm | Superclass for algorithms that produce only directed graph as output |
| vtkDirectionEncoder | Encode a direction into a one or two byte value |
| vtkDirectory | OS independent class for access and manipulation of system directories |
| vtkDirectXGPUInfoList | Get GPUs VRAM information using DirectX |
| vtkDiscreteMarchingCubes | Generate object boundaries from labelled volumes |
| vtkDiscretizableColorTransferFunction | Combination of vtkColorTransferFunction and vtkLookupTable |
| vtkDiskSource | Create a disk with hole in center |
| vtkDispatcher< BaseLhs, ReturnType, CastingPolicy > | Dispatch to functor based on a pointer type |
| vtkDisplayListPainter | Abstract superclass for painter that builds/uses display lists |
| vtkDistancePolyDataFilter | |
| vtkDistanceRepresentation | Represent the vtkDistanceWidget |
| vtkDistanceRepresentation2D | Represent the vtkDistanceWidget |
| vtkDistanceRepresentation3D | Represent the vtkDistanceWidget |
| vtkDistanceToCamera | Calculates distance from points to the camera |
| vtkDistanceWidget | Measure the distance between two points |
| vtkDistributedDataFilter | Distribute data among processors |
| vtkDistributedEdgePropertyMapType< DataArray > | |
| vtkDistributedGraphHelper | Helper for the vtkGraph class that allows the graph to be distributed across multiple memory spaces |
| vtkDistributedVertexPropertyMapType< DataArray > | |
| vtkDotProductSimilarity | Compute dot-product similarity metrics |
| vtkDoubleArray | Dynamic, self-adjusting array of double |
| vtkDoubleDispatcher< BaseLhs, BaseRhs, ReturnType, CastingPolicy > | Dispatch to functor based on two pointer types |
| vtkDSPFilterDefinition | Used by the Exodus readers |
| vtkDSPFilterGroup | Used by the Exodus readers |
| vtkDummyCommunicator | Dummy controller for single process applications |
| vtkDummyController | Dummy controller for single process applications |
| vtkDummyGPUInfoList | Do thing during Probe() |
| vtkDuplicatePolyData | For distributed tiled displays |
| vtkDynamic2DLabelMapper | Draw text labels at 2D dataset points |
| vtkDynamicLoader | Class interface to system dynamic libraries |
| vtkEarthSource | Create the continents of the Earth as a sphere |
| vtkEdgeBase | |
| vtkEdgeCenters | Generate points at center of edges |
| boost::vtkEdgeGlobalMap | |
| vtkEdgeLayout | Layout graph edges |
| vtkEdgeLayoutStrategy | Abstract superclass for all edge layout strategies |
| vtkEdgeListIterator | Iterates through all edges in a graph |
| vtkEdgePoints | Generate points on isosurface |
| vtkEdgeSubdivisionCriterion | How to decide whether a linear approximation to nonlinear geometry or field should be subdivided |
| vtkEdgeTable | Keep track of edges (edge is pair of integer id's) |
| vtkEdgeType | |
| vtkElevationFilter | Generate scalars along a specified direction |
| vtkEllipsoidTensorProbeRepresentation | A concrete implementation of vtkTensorProbeRepresentation that renders tensors as ellipoids |
| vtkEllipticalButtonSource | Create a ellipsoidal-shaped button |
| vtkEmptyCell | Empty cell used as a place-holder during processing |
| vtkEmptyRepresentation | |
| vtkEncodedGradientEstimator | Superclass for gradient estimation |
| vtkEncodedGradientShader | Compute shading tables for encoded normals |
| vtkEnSight6BinaryReader | Class to read binary EnSight6 files |
| vtkEnSight6Reader | Class to read EnSight6 files |
| vtkEnSightGoldBinaryReader | Class to read binary EnSight Gold files |
| vtkEnSightGoldReader | Class to read EnSight Gold files |
| vtkEnSightMasterServerReader | Reader for compund EnSight files |
| vtkEnSightReader | Superclass for EnSight file readers |
| vtkEnSightWriter | Write vtk unstructured grid data as an EnSight file |
| vtkEnzoReaderBlock | |
| vtkEnzoReaderInternal | |
| vtkErrorCode | Superclass for error codes |
| vtkEvent | Complete specification of a VTK event including all modifiers |
| vtkEventForwarderCommand | Simple event forwarder command |
| vtkEventQtSlotConnect | Manage connections between VTK events and Qt slots |
| vtkExecutionScheduler | Scheduling execution with thread/computing resources distributing |
| vtkExecutionSchedulerManager | Manage the instantiation and deletion of the vtkExecutionScheduler singleton |
| vtkExecutionTimer | Time filter execution |
| vtkExecutive | Superclass for all pipeline executives in VTK |
| vtkExecutiveCollection | Maintain a list of executive objects |
| vtkExodusIICache | |
| vtkExodusIICacheEntry | |
| vtkExodusIICacheKey | |
| vtkExodusIIReader | Read exodus 2 files .ex2 |
| vtkExodusIIReaderIntPointCheck | This looks for integration-point variables whose names contain an element shape and digits specifying an integration point |
| vtkExodusIIReaderParser | Internal parser used by vtkExodusIIReader |
| vtkExodusIIReaderPrivate | This class holds metadata for an Exodus file |
| vtkExodusIIReaderScalarCheck | This always accepts a single array name as a scalar. It is the fallback for all other checkers |
| vtkExodusIIReaderTensorCheck | This looks for symmetric tensors of a given rank and dimension |
| vtkExodusIIReaderVariableCheck | Abstract base class for glomming arrays of variable names |
| vtkExodusIIReaderVectorCheck | This looks for n-D vectors whose names are identical except for a single final character |
| vtkExodusIIWriter | Write Exodus II files |
| vtkExodusModel | Exodus Model |
| vtkExpandSelectedGraph | Expands a selection set of a vtkGraph |
| vtkExplicitCell | Abstract superclass for cells requiring an explicit representation |
| vtkExporter | Abstract class to write a scene to a file |
| vtkExtentRCBPartitioner | |
| vtkExtentSplitter | Split an extent across other extents |
| vtkExtentTranslator | Generates a structured extent from unstructured |
| vtkExtractArray | Given a vtkArrayData object containing one-or-more vtkArray instances, produces a vtkArrayData containing just one vtkArray, indentified by index |
| vtkExtractArraysOverTime | Extracts a selection over time |
| vtkExtractBlock | Extracts blocks from a multiblock dataset |
| vtkExtractCells | Subset a vtkDataSet to create a vtkUnstructuredGrid |
| vtkExtractCTHPart | Generates surface of an CTH volume fraction |
| vtkExtractDataOverTime | Extract point data from a time sequence for a specified point id |
| vtkExtractDataSets | Extracts a number of datasets |
| vtkExtractEdges | Extract cell edges from any type of data |
| vtkExtractGeometry | Extract cells that lie either entirely inside or outside of a specified implicit function |
| vtkExtractGrid | Select piece (e.g., volume of interest) and/or subsample structured grid dataset |
| vtkExtractHistogram2D | Compute a 2D histogram between two columns of an input vtkTable |
| vtkExtractLevel | Extract levels between min and max from a hierarchical box dataset |
| vtkExtractPiece | |
| 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 |
| vtkExtractRectilinearGrid | Extract a sub grid (VOI) from the structured rectilinear dataset |
| vtkExtractSelectedBlock | |
| vtkExtractSelectedFrustum | Returns the portion of the input dataset that lies within a selection frustum |
| vtkExtractSelectedGraph | Return a subgraph of a vtkGraph |
| vtkExtractSelectedIds | Extract a list of cells from a dataset |
| vtkExtractSelectedLocations | Extract cells within a dataset that contain the locations listen in the vtkSelection |
| vtkExtractSelectedPolyDataIds | Extract a list of cells from a polydata |
| vtkExtractSelectedRows | Return selected rows of a table |
| vtkExtractSelectedThresholds | Extract a cells or points from a dataset that have values within a set of thresholds |
| vtkExtractSelectedTree | Return a subtree from a vtkTree |
| vtkExtractSelection | Extract a subset from a vtkDataSet |
| vtkExtractSelectionBase | Abstract base class for all extract selection filters |
| vtkExtractTemporalFieldData | Extract temporal arrays from input field data |
| vtkExtractTensorComponents | Extract parts of tensor and create a scalar, vector, normal, or texture coordinates |
| 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 |
| vtkExtractVectorComponents | Extract components of vector as separate scalars |
| vtkExtractVOI | Select piece (e.g., volume of interest) and/or subsample structured points dataset |
| vtkFacetReader | Reads a dataset in Facet format |
| vtkFacetWriter | Reads a dataset in Facet format |
| vtkFast2DLayoutStrategy | Simple fast 2D graph layout |
| vtkFastGeomQuadStruct | |
| vtkFastNumericConversion | Enables fast conversion of floating point to fixed point |
| vtkFastSplatter | A splatter optimized for splatting single kernels |
| vtkFeatureEdges | Extract boundary, non-manifold, and/or sharp edges from polygonal data |
| vtkFFMPEGWriter | Uses the FFMPEG library to write video files |
| vtkFieldData | Represent and manipulate fields of data |
| vtkFieldDataSerializer | |
| vtkFieldDataToAttributeDataFilter | Map field data to dataset attribute data |
| vtkFileOutputWindow | File Specific output window class |
| vtkFillHolesFilter | Identify and fill holes in meshes |
| vtkFilteringInformationKeyManager | Manages key types in vtkFiltering |
| vtkFiniteDifferenceGradientEstimator | Use finite differences to estimate gradient |
| vtkFixedPointRayCastImage | Helper class for a ray cast image |
| vtkFixedPointVolumeRayCastCompositeGOHelper | A helper that generates composite images for the volume ray cast mapper |
| vtkFixedPointVolumeRayCastCompositeGOShadeHelper | A helper that generates composite images for the volume ray cast mapper |
| vtkFixedPointVolumeRayCastCompositeHelper | A helper that generates composite images for the volume ray cast mapper |
| vtkFixedPointVolumeRayCastCompositeShadeHelper | A helper that generates composite images for the volume ray cast mapper |
| vtkFixedPointVolumeRayCastHelper | An abstract helper that generates images for the volume ray cast mapper |
| vtkFixedPointVolumeRayCastMapper | A fixed point mapper for volumes |
| vtkFixedPointVolumeRayCastMIPHelper | A helper that generates MIP images for the volume ray cast mapper |
| vtkFixedSizeHandleRepresentation | A marker that has the same size in pixels |
| vtkFixedSizeHandleRepresentation3D | |
| vtkFixedWidthTextReader | Reader for pulling in text files with fixed-width fields |
| vtkFlashReaderInternal | |
| vtkFloatArray | Dynamic, self-adjusting array of float |
| vtkFloatingPointExceptions | Deal with floating-point exceptions |
| vtkFLUENTReader | Reads a dataset in Fluent file format |
| vtkFocalPlaneContourRepresentation | Represent a contour drawn on the focal plane |
| vtkFocalPlanePointPlacer | |
| vtkFollower | Subclass of actor that always faces the camera |
| vtkFontConfigFreeTypeTools | Subclass of vtkFreeTypeTools that uses system installed fonts |
| vtkForceDirectedLayoutStrategy | Force directed graph layout algorithm |
| vtkFrameBufferObject | Internal class which encapsulates OpenGL frame buffer object. Not to be used directly |
| vtkFreeTypeLabelRenderStrategy | Renders labels with freetype |
| vtkFreeTypeStringToImage | Uses Qt to render the supplied text to an image |
| vtkFreeTypeTools | FreeType library support |
| vtkFreeTypeToolsCleanup | |
| vtkFreeTypeUtilities | FreeType library support |
| vtkFreeTypeUtilitiesCleanup | |
| vtkFrustumCoverageCuller | Cull props based on frustum coverage |
| vtkFrustumSource | Create a polygonal representation of a frustum |
| vtkFunctionParser | Parse and evaluate a mathematical expression |
| vtkFunctionSet | Abstract interface for sets of functions |
| vtkGAMBITReader | Reads a dataset in Fluent GAMBIT neutral file format |
| vtkGarbageCollector | Detect and break reference loops |
| vtkGarbageCollectorManager | Manages the vtkGarbageCollector singleton |
| vtkGaussianBlurPass | Implement a post-processing Gaussian blur render pass |
| vtkGaussianCubeReader | Read ASCII Gaussian Cube Data files |
| vtkGaussianRandomSequence | Gaussian sequence of pseudo random numbers |
| vtkGaussianSplatter | Splat points into a volume with an elliptical, Gaussian distribution |
| vtkGDALVectorReader | Read vector file formats using GDAL |
| vtkGeneralTransform | Allows operations on any transforms |
| vtkGenerateIndexArray | |
| vtkGenericAdaptorCell | Defines cell interface |
| vtkGenericAttribute | Abstract class defined API for attribute data |
| vtkGenericAttributeCollection | Collection of attributes |
| vtkGenericCell | Thread-safe access to cells |
| vtkGenericCellIterator | Iterator used to traverse cells |
| vtkGenericCellTessellator | Helper class to perform cell tessellation |
| vtkGenericClip | Clip any dataset with an implicit function or scalar data |
| vtkGenericContourFilter | Generate isocontours from input dataset |
| vtkGenericCutter | Cut a vtkGenericDataSet with an implicit function or scalar data |
| vtkGenericDataObjectReader | Class to read any type of vtk data object |
| vtkGenericDataObjectWriter | Writes any type of vtk data object to file |
| vtkGenericDataSet | Defines dataset interface |
| vtkGenericDataSetTessellator | Tessellates generic, higher-order datasets into linear cells |
| vtkGenericEdgeTable | Keep track of edges (defined by pair of integer id's) |
| vtkGenericEnSightReader | Class to read any type of EnSight files |
| vtkGenericGeometryFilter | Extract geometry from data (or convert data to polygonal type) |
| vtkGenericGlyph3DFilter | Copy oriented and scaled glyph geometry to every input point |
| vtkGenericInterpolatedVelocityField | Interface for obtaining interpolated velocity values |
| vtkGenericMovieWriter | Abstract movie writer class |
| vtkGenericOpenGLRenderWindow | Platform independent render window |
| vtkGenericOutlineFilter | Create wireframe outline for arbitrary generic data set |
| vtkGenericPointIterator | Iterator used to traverse points |
| vtkGenericProbeFilter | Sample data values at specified point locations |
| vtkGenericRenderWindowInteractor | Platform-independent programmable render window interactor |
| vtkGenericStreamTracer | Streamline generator |
| vtkGenericSubdivisionErrorMetric | Objects that compute error during cell tessellation |
| vtkGenericVertexAttributeMapping | Stores mapping for data arrays to generic vertex attributes |
| vtkGeoAdaptiveArcs | |
| vtkGeoAlignedImageRepresentation | A multi-resolution image tree |
| vtkGeoAlignedImageSource | Splits hi-res image into tiles |
| vtkGeoArcs | Layout graph edges on a globe as arcs |
| vtkGeoAssignCoordinates | Given latitude and longitude arrays, take the values in those arrays and convert them to x,y,z world coordinates |
| vtkGeoCamera | Geo interface to a camera |
| vtkGeodesicPath | Abstract base for classes that generate a geodesic path |
| vtkGeoEdgeStrategy | Layout graph edges on a globe as arcs |
| vtkGeoFileImageSource | A tiled image source on disk |
| vtkGeoFileTerrainSource | A source for tiled geometry on disk |
| vtkGeoGlobeSource | Spherical globe source |
| vtkGeoGraticule | Create a polygonal lat-long grid |
| vtkGeoImageNode | A node in a multi-resolution image tree |
| vtkGeoInteractorStyle | Interaction for a globe |
| vtkGeoMath | Useful geographic calculations |
| vtkGeometricErrorMetric | Objects that compute geometry-based error during cell tessellation |
| vtkGeometryFilter | Extract geometry from data (or convert data to polygonal type) |
| vtkGeoProjection | Represent a projection from a sphere to a plane |
| vtkGeoProjectionSource | A 2D geographic geometry source |
| vtkGeoRandomGraphSource | A geospatial graph with random edges |
| vtkGeoSampleArcs | Samples geospatial lines at regular intervals |
| vtkGeoSource | A multi-resolution geographic data source |
| vtkGeoSphereTransform | A transformation between long-lat-alt and rect coords |
| vtkGeoTerrain | A 3D terrain model for the globe |
| vtkGeoTerrain2D | A 2D terrain model for the globe |
| vtkGeoTerrainNode | |
| vtkGeoTransform | A transformation between two geographic coordinate systems |
| vtkGeoTreeNode | Stores data for a patch of the globe |
| vtkGeoTreeNodeCache | Manages a list of vtkGeoTreeNodes |
| vtkGeoView | A 3D geospatial view |
| vtkGeoView2D | A 2D geospatial view |
| vtkGESignaReader | Read GE Signa ximg files |
| vtkGhostArray | |
| vtkGL2PSContextDevice2D | Class for drawing 2D primitives using GL2PS |
| vtkGL2PSExporter | Export a scene as a PostScript file using GL2PS |
| vtkGL2PSUtilities | Helper functions for using GL2PS within VTK |
| vtkGlobeSource | Sphere patch with Lat/Long scalar array |
| vtkGlobFileNames | Find files that match a wildcard pattern |
| vtkGLSLShader | GLSL Shader |
| vtkGLSLShaderDeviceAdapter | Adapter to pass generic vertex attributes to the rendering pipeline to be used in a GLSL shader |
| vtkGLSLShaderDeviceAdapter2 | Adapter to pass generic vertex attributes to the rendering pipeline to be used in a vtkShaderProgram2 |
| vtkGLSLShaderProgram | GLSL Shader Program |
| vtkgluPickMatrix | Implement selected glu functionality |
| vtkGlyph2D | Copy oriented and scaled glyph geometry to every input point (2D specialization) |
| vtkGlyph3D | Copy oriented and scaled glyph geometry to every input point |
| vtkGlyph3DMapper | VtkGlyph3D on the GPU |
| vtkGlyphSource2D | Create 2D glyphs represented by vtkPolyData |
| vtkGPUInfo | Stores GPU VRAM information |
| vtkGPUInfoList | Stores the list of GPUs VRAM information |
| vtkGPUInfoListArray | Internal class vtkGPUInfoList |
| vtkGPUVolumeRayCastMapper | Ray casting performed on the GPU |
| vtkGradientFilter | A general filter for gradient estimation |
| vtkGraph | Base class for graph data types |
| boost::vtkGraph_traversal_category | |
| vtkGraphAlgorithm | Superclass for algorithms that produce only graph as output |
| vtkGraphAnnotationLayersFilter | Produce filled convex hulls around subsets of vertices in a vtkGraph |
| vtkGraphEdge | Representation of a single graph edge |
| boost::vtkGraphEdgeMap | |
| boost::vtkGraphEdgePropertyMapHelper< PMap > | |
| vtkGraphGeodesicPath | Abstract base for classes that generate a geodesic path on a graph (mesh) |
| vtkGraphHierarchicalBundleEdges | Layout graph arcs in bundles |
| vtkGraphicsFactory | |
| boost::vtkGraphIndexMap | |
| vtkGraphInternals | Internal representation of vtkGraph |
| vtkGraphItem | A 2D graphics item for rendering a graph |
| vtkGraphLayout | Layout a graph in 2 or 3 dimensions |
| vtkGraphLayoutFilter | Nice layout of undirected graphs in 3D |
| vtkGraphLayoutStrategy | Abstract superclass for all graph layout strategies |
| vtkGraphLayoutView | Lays out and displays a graph |
| vtkGraphMapper | Map vtkGraph and derived classes to graphics primitives |
| boost::vtkGraphPropertyMapMultiplier< PMap > | |
| vtkGraphReader | Read vtkGraph data file |
| vtkGraphToGlyphs | Create glyphs for graph vertices |
| vtkGraphToPoints | Convert a vtkGraph a set of points |
| vtkGraphToPolyData | Convert a vtkGraph to vtkPolyData |
| vtkGraphWeightEuclideanDistanceFilter | Weights the edges of a graph based on the Euclidean distance between the points |
| vtkGraphWeightFilter | Base class for filters that weight graph edges |
| vtkGraphWriter | Write vtkGraph data to a file |
| vtkGreedyTerrainDecimation | Reduce height field (represented as image) to reduced TIN |
| vtkGridSynchronizedTemplates3D | Generate isosurface from structured grids |
| vtkGridTransform | Nonlinear warp transformation |
| vtkGroupLeafVertices | Filter that expands a tree, categorizing leaf vertices |
| vtkHandleRepresentation | Abstract class for representing widget handles |
| vtkHandleWidget | General widget for moving handles |
| vtkHardwareSelectionPolyDataPainter | Painter used to render polydata for selection passes |
| vtkHardwareSelector | Manager for OpenGL-based selection |
| vtkHAVSVolumeMapper | Hardware-Assisted Visibility Sorting unstructured grid mapper |
| vtkHeap | Replacement for malloc/free and new/delete |
| vtkHedgeHog | Create oriented lines from vector data |
| vtkHexagonalPrism | 3D cell that represents a prism with hexagonal base |
| vtkHexahedron | Cell that represents a linear 3D hexahedron |
| vtkHierarchicalBoxDataIterator | |
| vtkHierarchicalBoxDataSet | Backwards compatibility class |
| vtkHierarchicalBoxDataSetAlgorithm | Superclass for algorithms that produce vtkHierarchicalBoxDataSet as output |
| vtkHierarchicalDataExtractDataSets | Extract a number of datasets |
| vtkHierarchicalDataExtractLevel | Extact levels between min and max |
| vtkHierarchicalDataLevelFilter | Generate scalars from levels |
| vtkHierarchicalDataSetGeometryFilter | Extract geometry from hierarchical data |
| vtkHierarchicalGraphPipeline | Helper class for rendering graphs superimposed on a tree |
| 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 |
| vtkHierarchicalPolyDataMapper | Class that renders hierarchical polygonal data |
| vtkHomogeneousTransform | Superclass for homogeneous transformations |
| vtkHoverWidget | Invoke a vtkTimerEvent when hovering |
| vtkHull | Produce an n-sided convex hull |
| vtkHyperOctree | A dataset structured as a tree where each node has exactly 2^n children |
| vtkHyperOctreeAlgorithm | Superclass for algorithms that produce only octree as output |
| vtkHyperOctreeClipCutPointsGrabber | A concrete implementation of vtkHyperOctreePointsGrabber used by vtkClipHyperOctree and vtkHyperOctreeCutter |
| vtkHyperOctreeContourFilter | Generate isosurfaces/isolines from scalar values |
| vtkHyperOctreeCursor | Objects that can traverse hyperoctree nodes |
| vtkHyperOctreeCutter | Cut vtkHyperOctree with user-specified implicit function |
| vtkHyperOctreeDepth | Assign tree depth attribute to each cell |
| vtkHyperOctreeDualGridContourFilter | Generate isosurfaces/isolines from scalar values |
| vtkHyperOctreeFractalSource | Create an octree from a fractal. hyperoctree |
| vtkHyperOctreeLightWeightCursor | |
| vtkHyperOctreeLimiter | Limit the tree's depth, averaging data from lower level branches into the new leaves at the cut points |
| vtkHyperOctreePointsGrabber | An object used by filters to store points computed on face or edge of an hyperoctant. It is an abstract class. vtkClipHyperOctree and vtkHyperOctreeCutter use vtkHyperOctreeClipCutPointsGrabber vtkHyperOctreeContourFilter use an internal one: vtkHyperOctreeContourFilterPointsGrabber |
| vtkHyperOctreeSampleFunction | Sample an implicit function over an hyperoctree |
| vtkHyperOctreeSurfaceFilter | Extracts outer (polygonal) surface |
| vtkHyperOctreeToUniformGridFilter | Flat the octree into a uniform grid |
| vtkHyperStreamline | Generate hyperstreamline in arbitrary dataset |
| vtkHyperTree | An object structured as a tree where each node has exactly either 2^n or 3^n children |
| vtkHyperTreeCursor | Objects that can traverse hypertree nodes |
| vtkHyperTreeGrid | A dataset containing a grid of vtkHyperTree instances arranged as a rectilinear grid |
| vtkHyperTreeGridAlgorithm | Superclass for algorithms that produce a hyper tree grid as output |
| vtkHyperTreeGridAxisCut | Axis aligned hyper tree grid cut |
| vtkHyperTreeGridGeometry | Hyper tree grid outer surface |
| vtkHyperTreeGridSource | Create a synthetic grid of hypertrees |
| vtkHyperTreeGrid::vtkHyperTreeGridSuperCursor | |
| vtkHyperTreeGridToUnstructuredGrid | Convert hyper tree grid to unstructured grid |
| vtkHyperTreeGrid::vtkHyperTreeIterator | |
| vtkHyperTreeGrid::vtkHyperTreeSimpleCursor | |
| vtkIcicleView | Displays a tree in a stacked "icicle" view |
| vtkIconGlyphFilter | Filter that generates a polydata consisting of quads with texture coordinates referring to a set of icons within a sheet of icons |
| vtkIdentityTransform | Transform that doesn't do anything |
| vtkIdFilter | Generate scalars or field data from point and cell ids |
| vtkIdList | List of point or cell ids |
| vtkIdListCollection | Maintain an unordered list of dataarray objects |
| vtkIdTypeArray | Dynamic, self-adjusting array of vtkIdType |
| vtkImage2DIslandPixel | |
| vtkImageAccumulate | Generalized histograms up to 3 dimensions |
| vtkImageActor | Draw an image in a rendered 3D scene |
| vtkImageActorPointPlacer | Converts 2D display positions to world positions such that they lie on an ImageActor |
| vtkImageAlgorithm | Generic algorithm superclass for image algs |
| vtkImageAnisotropicDiffusion2D | Edge preserving smoothing |
| vtkImageAnisotropicDiffusion3D | Edge preserving smoothing |
| 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 |
| vtkImageBSplineInternals | BSpline code from P. Thevenaz |
| vtkImageBSplineInterpolator | Perform b-spline interpolation on images |
| vtkImageButterworthHighPass | Frequency domain high pass |
| vtkImageButterworthLowPass | Frequency domain Low pass |
| vtkImageCacheFilter | Caches multiple vtkImageData objects |
| vtkImageCanvasSource2D | Paints on a canvas |
| vtkImageCast | Image Data type Casting Filter |
| vtkImageChangeInformation | Modify spacing, origin and extent |
| vtkImageCheckerboard | Show two images at once using a checkboard pattern |
| vtkImageCityBlockDistance | 1,2 or 3D distance map |
| vtkImageClip | Reduces the image extent of the input |
| vtkImageComplex | |
| vtkImageConnector | Create a binary image of a sphere |
| vtkImageConnectorSeed | |
| vtkImageConstantPad | Makes image larger by padding with constant |
| vtkImageContinuousDilate3D | Dilate implemented as a maximum |
| vtkImageContinuousErode3D | Erosion implemented as a minimum |
| vtkImageConvolve | Convolution of an image with a kernel |
| vtkImageCorrelation | Correlation imageof the two inputs |
| vtkImageCroppingRegionsWidget | Widget for cropping an image |
| vtkImageCursor3D | Paints a cursor on top of an image or volume |
| vtkImageData | Topologically and geometrically regular array of data |
| vtkImageDataGeometryFilter | Extract geometry for structured points |
| vtkImageDataLIC2D | |
| vtkImageDataLIC2DExtentTranslator | |
| vtkImageDataStreamer | Initiates streaming on image data |
| vtkImageDataToPointSet | Converts a vtkImageData to a vtkPointSet |
| vtkImageDataToUniformGrid | Convert vtkImageData to vtkUniformGrid |
| vtkImageDecomposeFilter | Filters that execute axes in series |
| vtkImageDifference | Compares images for regression tests |
| vtkImageDilateErode3D | Dilates one value and erodes another |
| vtkImageDivergence | Divergence of a vector field |
| vtkImageDotProduct | Dot product of two vector images |
| vtkImageEllipsoidSource | Create a binary image of an ellipsoid |
| vtkImageEuclideanDistance | Computes 3D Euclidean DT |
| vtkImageEuclideanToPolar | Converts 2D Euclidean coordinates to polar |
| vtkImageExport | Export VTK images to third-party systems |
| vtkImageExtractComponents | Outputs a single component |
| vtkImageFFT | Fast Fourier Transform |
| vtkImageFlip | This flips an axis of an image. Right becomes left .. |
| vtkImageFourierCenter | Shifts constant frequency to center for display |
| vtkImageFourierFilter | Superclass that implements complex numbers |
| vtkImageGaussianSmooth | Performs a gaussian convolution |
| vtkImageGaussianSource | Create an image with Gaussian pixel values |
| vtkImageGradient | Computes the gradient vector |
| vtkImageGradientMagnitude | Computes magnitude of the gradient |
| vtkImageGridSource | Create an image of a grid |
| 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 |
| vtkImageHybridMedian2D | Median filter that preserves lines and corners |
| vtkImageIdealHighPass | Simple frequency domain band pass |
| vtkImageIdealLowPass | Simple frequency domain band pass |
| vtkImageImport | Import data from a C array |
| vtkImageImportExecutive | |
| vtkImageInPlaceFilter | Filter that operates in place |
| vtkImageInterpolator | Interpolate data values from images |
| vtkImageIslandRemoval2D | Removes small clusters in masks |
| vtkImageItem | VtkContextItem that draws a supplied image in the scene |
| vtkImageIterateFilter | Multiple executes per update |
| vtkImageIterator< DType > | Simple image iterator |
| 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. |
| vtkImageMandelbrotSource | Mandelbrot image |
| vtkImageMapper | 2D image display |
| vtkImageMapper3D | Abstract class for mapping images to the screen |
| 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 |
| vtkImageMarchingCubes | Generate isosurface(s) from volume/images |
| 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 |
| vtkImageMedian3D | Median Filter |
| vtkImageMirrorPad | Extra pixels are filled by mirror images |
| vtkImageNoiseSource | Create an image filled with noise |
| vtkImageNonMaximumSuppression | Performs non-maximum suppression |
| vtkImageNormalize | Normalizes that scalar components for each point |
| vtkImageOpenClose3D | Will perform opening or closing |
| vtkImageOrthoPlanes | Connect three vtkImagePlaneWidgets together |
| vtkImagePadFilter | Super class for filters that fill in extra pixels |
| vtkImagePermute | Permutes axes of input |
| vtkImagePlaneWidget | 3D widget for reslicing image data |
| vtkImageProcessingPass | Convenient class for post-processing passes. render pass |
| vtkImageProgressIterator< DType > | Simple image iterator with progress |
| vtkImageProperty | Image display properties |
| vtkImageQuantizeRGBToIndex | Generalized histograms up to 4 dimensions |
| vtkImageRange3D | Max - min of a circular neighborhood |
| vtkImageReader | Superclass of transformable binary file readers |
| vtkImageReader2 | Superclass of binary file readers |
| vtkImageReader2Collection | Maintain a list of image readers |
| vtkImageReader2Factory | Superclass of binary file readers |
| vtkImageRectilinearWipe | Make a rectilinear combination of two images |
| vtkImageRenderManager | An object to control sort-first parallel rendering |
| vtkImageResample | Resamples an image to be larger or smaller |
| vtkImageResize | High-quality image resizing filter |
| vtkImageReslice | Reslices a volume along a new set of axes |
| vtkImageResliceMapper | Map a slice of a vtkImageData to the screen |
| vtkImageResliceToColors | Reslice and produce color scalars |
| vtkImageRFFT | Reverse Fast Fourier Transform |
| vtkImageRGBToHSI | Converts RGB components to HSI |
| vtkImageRGBToHSV | Converts RGB components to HSV |
| vtkImageSeedConnectivity | SeedConnectivity with user defined seeds |
| vtkImageSeparableConvolution | 3 1D convolutions on an image |
| vtkImageShiftScale | Shift and scale an input image |
| vtkImageShrink3D | Subsamples an image |
| vtkImageSincInterpolator | Perform sinc interpolation on images |
| vtkImageSinusoidSource | Create an image with sinusoidal pixel values |
| vtkImageSkeleton2D | Skeleton of 2D images |
| vtkImageSlab | Combine image slices to form a slab image |
| vtkImageSlabReslice | Thick slab reformat through data |
| vtkImageSlice | Image in a 3D scene |
| vtkImageSliceCollection | Sorted list of image slice objects |
| vtkImageSliceMapper | Map a slice of a vtkImageData to the screen |
| vtkImageSobel2D | Computes a vector field using sobel functions |
| vtkImageSobel3D | Computes a vector field using sobel functions |
| vtkImageSpatialAlgorithm | Filters that operate on pixel neighborhoods |
| vtkImageStack | Manages a stack of composited images |
| vtkImageStencil | Combine images via a cookie-cutter operation |
| vtkImageStencilAlgorithm | Producer of vtkImageStencilData |
| vtkImageStencilData | Efficient description of an image stencil |
| vtkImageStencilIterator< DType > | Image region iterator |
| vtkImageStencilRaster | |
| vtkImageStencilSource | Generate an image stencil |
| vtkImageStencilToImage | Convert an image stencil into an image |
| vtkImageThreshold | Flexible threshold |
| vtkImageThresholdConnectivity | Flood fill an image region |
| vtkImageToAMR | Filter to convert any vtkImageData to a vtkOverlappingAMR |
| vtkImageToImageStencil | Clip an image with a mask image |
| vtkImageToPolyDataFilter | Generate linear primitives (vtkPolyData) from an image |
| vtkImageToStructuredGrid | |
| vtkImageToStructuredPoints | Attaches image pipeline to VTK |
| vtkImageTracerWidget | 3D widget for tracing on planar props |
| vtkImageTranslateExtent | Changes extent, nothing else |
| vtkImageVariance3D | Variance in a neighborhood |
| vtkImageViewer | Display a 2d image |
| vtkImageViewer2 | Display a 2D image |
| vtkImageWeightedSum | Adds any number of images, weighting each according to the weight set using this->SetWeights(i,w) |
| vtkImageWrapPad | Makes an image larger by wrapping existing data |
| vtkImageWriter | Writes images to files |
| vtkImplicitBoolean | Implicit function consisting of boolean combinations of implicit functions |
| vtkImplicitDataSet | Treat a dataset as if it were an implicit function |
| vtkImplicitFunction | Abstract interface for implicit functions |
| vtkImplicitFunctionCollection | Maintain a list of implicit functions |
| vtkImplicitFunctionToImageStencil | Clip an image with a function |
| vtkImplicitHalo | Implicit function for an halo |
| vtkImplicitModeller | Compute distance from input geometry on structured point dataset |
| vtkImplicitPlaneRepresentation | Class defining the representation for a vtkImplicitPlaneWidget2 |
| vtkImplicitPlaneWidget | 3D widget for manipulating an infinite plane |
| vtkImplicitPlaneWidget2 | 3D widget for manipulating an infinite plane |
| vtkImplicitPolyDataDistance | |
| vtkImplicitSelectionLoop | Implicit function for a selection loop |
| vtkImplicitSum | Implicit sum of other implicit functions |
| vtkImplicitTextureCoords | Generate 1D, 2D, or 3D texture coordinates based on implicit function(s) |
| vtkImplicitVolume | Treat a volume as if it were an implicit function |
| vtkImplicitWindowFunction | Implicit function maps another implicit function to lie within a specified range |
| vtkImporter | Importer abstract class |
| vtkIncrementalForceLayout | Incremental force-directed layout |
| vtkIncrementalOctreeNode | Octree node constituting incremental octree (in support of both point location and point insertion) |
| vtkIncrementalOctreePointLocator | Incremental octree in support of both point location and point insertion |
| vtkIncrementalPointLocator | Abstract class in support of both point location and point insertion |
| vtkIndent | Simple class to control print indentation |
| vtkInEdgeIterator | Iterates through all incoming edges to a vertex |
| vtkInEdgeType | |
| vtkInformation | Store vtkAlgorithm input/output information |
| vtkInformationDataObjectKey | Key for vtkDataObject values |
| vtkInformationDoubleKey | Key for double values in vtkInformation |
| vtkInformationDoubleVectorKey | Key for double vector values |
| vtkInformationExecutivePortKey | Key for vtkExecutive/Port value pairs |
| vtkInformationExecutivePortVectorKey | Key for vtkExecutive/Port value pair vectors |
| vtkInformationIdTypeKey | Key for vtkIdType values in vtkInformation |
| vtkInformationInformationKey | Key for vtkInformation values |
| vtkInformationInformationVectorKey | Key for vtkInformation vectors |
| vtkInformationIntegerKey | Key for integer values in vtkInformation |
| vtkInformationIntegerPointerKey | Key for pointer to integer |
| vtkInformationIntegerVectorKey | Key for integer vector values |
| vtkInformationInternals | Internal structure for vtkInformation |
| vtkInformationIterator | Iterates over keys of an information object |
| vtkInformationKey | Superclass for vtkInformation keys |
| vtkInformationKeyVectorKey | Key for vector-of-keys values |
| vtkInformationObjectBaseKey | Key for vtkObjectBase values |
| vtkInformationObjectBaseVectorKey | Key for vtkObjectBase vector values |
| vtkInformationQuadratureSchemeDefinitionVectorKey | Key for vtkQuadratureSchemeDefinition vector values |
| vtkInformationRequestKey | Key for pointer to pointer |
| vtkInformationStringKey | Key for string values in vtkInformation |
| vtkInformationStringVectorKey | Key for String vector values |
| vtkInformationUnsignedLongKey | Key for unsigned long values in vtkInformation |
| vtkInformationVariantKey | Key for variant values in vtkInformation |
| vtkInformationVariantVectorKey | Key for variant vector values |
| vtkInformationVector | Store zero or more vtkInformation instances |
| vtkInitialValueProblemSolver | Integrate a set of ordinary differential equations (initial value problem) in time |
| vtkInputStream | Wraps a binary input stream with a VTK interface |
| vtkInstantiator | Create an instance of any VTK class from its name |
| vtkInstantiatorInitialize | |
| vtkIntArray | Dynamic, self-adjusting array of int |
| vtkInteractorEventRecorder | Record and play VTK events passing through a vtkRenderWindowInteractor |
| vtkInteractorObserver | Abstract superclass for classes observing events invoked by vtkRenderWindowInteractor |
| vtkInteractorStyle | Provide event-driven interface to the rendering window (defines trackball mode) |
| vtkInteractorStyleAreaSelectHover | An interactor style for an area tree view |
| vtkInteractorStyleDrawPolygon | Draw polygon during mouse move |
| vtkInteractorStyleFlight | Flight motion routines |
| vtkInteractorStyleImage | Interactive manipulation of the camera specialized for images |
| vtkInteractorStyleJoystickActor | Manipulate objects in the scene independently of one another |
| vtkInteractorStyleJoystickCamera | Interactive manipulation of the camera |
| vtkInteractorStyleRubberBand2D | A rubber band interactor for a 2D view |
| vtkInteractorStyleRubberBand3D | A rubber band interactor for a 3D view |
| vtkInteractorStyleRubberBandPick | Like TrackBallCamera, but this can pick props underneath a rubber band selection rectangle |
| vtkInteractorStyleRubberBandZoom | Zoom in by amount indicated by rubber band box |
| vtkInteractorStyleSwitch | Class to swap between interactory styles |
| vtkInteractorStyleSwitchBase | Dummy interface class |
| vtkInteractorStyleTerrain | Manipulate camera in scene with natural view up (e.g., terrain) |
| vtkInteractorStyleTrackball | Trackball motion control |
| vtkInteractorStyleTrackballActor | Manipulate objects in the scene independent of each other |
| vtkInteractorStyleTrackballCamera | Interactive manipulation of the camera |
| vtkInteractorStyleTreeMapHover | An interactor style for a tree map view |
| vtkInteractorStyleUnicam | Unicam navigation style |
| vtkInteractorStyleUser | Customizable interaction routines |
| vtkInterpolateDataSetAttributes | Interpolate scalars, vectors, etc. and other dataset attributes |
| vtkInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point |
| vtkInterpolatingSubdivisionFilter | Generate a subdivision surface using an Interpolating Scheme |
| vtkInterpolationInfo | |
| vtkInterpolationMath | |
| vtkInterpolationWeights | |
| vtkInterpolatorInternals | Internals for vtkImageInterpolator |
| vtkIntersectionPolyDataFilter | |
| vtkIOStream | Include C++ iostreams as used by VTK |
| vtkIOStreamFwd | Forward-declare C++ iostreams as used by VTK |
| vtkISIReader | Reader for ISI files |
| vtkIterativeClosestPointTransform | Implementation of the ICP algorithm |
| vtkIVExporter | Export a scene into OpenInventor 2.0 format |
| vtkIVWriter | Export polydata into OpenInventor 2.0 format |
| vtkJavaCommand | |
| vtkJavaScriptDataWriter | A Javascript data writer for vtkTable Writes a vtkTable into a Javascript data format |
| vtkJavaVoidFuncArg | |
| vtkJPEGReader | Read JPEG files |
| vtkJPEGWriter | Writes JPEG files |
| vtkKCoreDecomposition | Compute the k-core decomposition of the input graph |
| vtkKCoreLayout | Produces a layout for a graph labeled with K-Core information |
| vtkKdNode | This class represents a single spatial region in an 3D axis aligned binary spatial partitioning. It is assumed the region bounds some set of points. Regions are represented as nodes in a binary tree |
| vtkKdTree | Kd-tree spatial decomposition of a set of points |
| vtkKdTreePointLocator | Class to quickly locate points in 3-space |
| vtkKdTreeSelector | Selects point ids using a kd-tree |
| vtkKMeansAssessFunctor | |
| vtkKMeansDistanceFunctor | Measure distance from k-means cluster centers |
| vtkKMeansDistanceFunctorCalculator | Measure distance from k-means cluster centers using a user-specified expression |
| vtkKMeansStatistics | A class for KMeans clustering |
| vtkKochanekSpline | Computes an interpolating spline using a Kochanek basis |
| vtkLabeledDataMapper | Draw text labels at dataset points |
| vtkLabeledTreeMapDataMapper | Draw text labels on a tree map |
| vtkLabelHierarchy | Octree of labels |
| vtkLabelHierarchyAlgorithm | Superclass for algorithms that produce only label hierarchies as output |
| vtkLabelHierarchyCompositeIterator | Iterator over sub-iterators |
| vtkLabelHierarchyIterator | Iterator over vtkLabelHierarchy |
| vtkLabelPlacementMapper | Places and renders non-overlapping labels |
| vtkLabelPlacer | Place a prioritized hierarchy of labels in screen space |
| vtkLabelRenderStrategy | Superclass for label rendering implementations |
| vtkLabelSizeCalculator | |
| vtkLandmarkTransform | Linear transform specified by two corresponding point sets |
| vtkLargeInteger | Class for arbitrarily large ints |
| vtkLassoStencilSource | Create a stencil from a contour |
| vtkLeaderActor2D | Create a leader with optional label and arrows |
| vtkLegendBoxActor | Draw symbols with text |
| vtkLegendScaleActor | Annotate the render window with scale and distance information |
| vtkLevelIdScalars | |
| vtkLight | Virtual light for 3D rendering |
| vtkLightActor | Cone and a frustum to represent a spotlight |
| vtkLightCollection | List of lights |
| vtkLightingHelper | Helper to assist in simulating lighting similar to default OpenGL pipeline |
| vtkLightingPainter | Abstract class defining interface for painter that can handle lightin |
| vtkLightKit | Simple but quality lighting kit |
| vtkLightsPass | Implement the lights render pass |
| vtkLine | Cell represents a 1D line |
| vtkLinearContourLineInterpolator | Interpolates supplied nodes with line segments |
| vtkLinearExtrusionFilter | Sweep polygonal data creating a "skirt" from free edges and lines, and lines from vertices |
| vtkLinearSelector | Select cells intersecting a line (possibly broken) |
| vtkLinearSubdivisionFilter | Generate a subdivision surface using the Linear Scheme |
| vtkLinearTransform | Abstract superclass for linear transformations |
| vtkLineIntegralConvolution2D | GPU-based implementation of Line Integral Convolution (LIC) |
| vtkLineRepresentation | Class defining the representation for a vtkLineWidget2 |
| vtkLineSource | Create a line defined by two end points |
| vtkLinesPainter | Painter that paints lines |
| vtkLineWidget | 3D widget for manipulating a line |
| vtkLineWidget2 | 3D widget for manipulating a finite, straight line |
| vtkLinkEdgels | Links edgels together to form digital curves |
| vtkLocator | Abstract base class for objects that accelerate spatial searches |
| vtkLODActor | Actor that supports multiple levels of detail |
| vtkLODProp3D | Level of detail 3D prop |
| vtkLODProp3DEntry | |
| vtkLogLookupTable | Map scalars into colors using log (base 10) scale |
| vtkLogoRepresentation | Represent the vtkLogoWidget |
| vtkLogoWidget | 2D widget for placing and manipulating a logo |
| vtkLongArray | Dynamic, self-adjusting array of long |
| vtkLongLongArray | Dynamic, self-adjusting array of long long |
| vtkLookupTable | Map scalar values into colors via a lookup table |
| vtkLookupTableItem | |
| vtkLookupTableWithEnabling | A lookup table that allows for an optional array to be provided that specifies which scalars to "enable" and which to "disable" |
| vtkLoopSubdivisionFilter | Generate a subdivision surface using the Loop Scheme |
| vtkLSDynaPart | |
| vtkLSDynaPartCollection | |
| vtkLSDynaReader | Read LS-Dyna databases (d3plot) |
| vtkLSDynaSummaryParser | |
| vtkMapArrayValues | Map values in an input array to different values in an output array of (possibly) different type |
| vtkMapper | Abstract class specifies interface to map data to graphics primitives |
| vtkMapper2D | Abstract class specifies interface for objects which render 2D actors |
| vtkMapperCollection | List of mappers |
| vtkMarchingContourFilter | Generate isosurfaces/isolines from scalar values |
| vtkMarchingCubes | Generate isosurface(s) from volume |
| vtkMarchingCubesTriangleCases | |
| vtkMarchingSquares | Generate isoline(s) from structured points set |
| vtkMarchingSquaresLineCases | |
| vtkMarkerUtilities | Utilities for generating marker images |
| vtkMaskFields | Allow control of which fields get passed to the output |
| vtkMaskPoints | Selectively filter points |
| vtkMaskPolyData | Sample subset of input polygonal data cells |
| vtkMassProperties | Estimate volume, area, shape index of triangle mesh |
| vtkMaterialLibrary | Library for Materials |
| vtkMath | Performs common math operations |
| vtkMathTextFreeTypeTextRenderer | Default implementation of vtkTextRenderer |
| vtkMathTextUtilities | Abstract interface to equation rendering |
| vtkMathTextUtilitiesCleanup | |
| vtkMathUtilities | Templated utility math functions intended for internal use in tests etc |
| vtkMatplotlibMathTextUtilities | Access to MatPlotLib MathText rendering |
| vtkMatricizeArray | Convert an array of arbitrary dimensions to a matrix |
| vtkMatrix3x3 | Represent and manipulate 3x3 transformation matrices |
| vtkMatrix4x4 | Represent and manipulate 4x4 transformation matrices |
| vtkMatrixMathFilter | Calculate functions of quality of the elements of a mesh |
| vtkMatrixToHomogeneousTransform | Convert a matrix to a transform |
| vtkMatrixToLinearTransform | Convert a matrix to a transform |
| vtkMCubesReader | Read binary marching cubes file |
| vtkMCubesWriter | Write binary marching cubes file |
| vtkMeanValueCoordinatesInterpolator | Compute interpolation computes for closed triangular mesh |
| vtkMedicalImageProperties | Some medical image properties |
| vtkMedicalImageReader2 | VtkImageReader2 with medical meta data |
| vtkMemoryLimitImageDataStreamer | Initiates streaming on image data |
| vtkMergeCells | Merges any number of vtkDataSets back into a single vtkUnstructuredGrid |
| vtkMergeColumns | Merge two columns into a single column |
| 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 |
| vtkMergeGraphs | Combines two graphs |
| vtkMergePoints | Merge exactly coincident points |
| vtkMergeTables | Combine two tables |
| vtkMeshQuality | Calculate functions of quality of the elements |
| vtkMetaImageReader | Read binary UNC meta image data |
| vtkMetaImageWriter | Write a binary UNC meta image data |
| vtkMFCWindow | Class to display a VTK window in an MFC window |
| vtkMFIXReader | Reads a dataset in MFIX file format |
| vtkMILVideoSource | Matrox Imaging Library frame grabbers |
| vtkMINCImageAttributes | A container for a MINC image header |
| vtkMINCImageReader | A reader for MINC files |
| vtkMINCImageWriter | A writer for MINC files |
| vtkMinimalStandardRandomSequence | Park and Miller Sequence of pseudo random numbers |
| vtkMNIObjectReader | A reader for MNI surface mesh files |
| vtkMNIObjectWriter | A writer for MNI surface mesh files |
| vtkMNITagPointReader | A reader for MNI tag files |
| vtkMNITagPointWriter | A writer for MNI tag point files |
| vtkMNITransformReader | A reader for MNI transformation files |
| vtkMNITransformWriter | A writer for MNI transformation files |
| vtkModelMetadata | This class encapsulates the metadata that appear in mesh-based file formats but do not appear in vtkUnstructuredGrid. It can pack itself into the field arrays of a vtkUnstructuredGrid, and be unpacked by metadata aware filters and writers later on |
| vtkModifiedBSPTree | Generate axis aligned BBox tree for raycasting and other Locator based searches |
| vtkMolecule | Class describing a molecule |
| vtkMoleculeAlgorithm | Superclass for algorithms that operate on vtkMolecules |
| vtkMoleculeMapper | Mapper that draws vtkMolecule objects |
| vtkMoleculeReaderBase | Read Molecular Data files |
| vtkMoleculeToAtomBallFilter | Generate polydata with spheres representing atoms |
| vtkMoleculeToBondStickFilter | Generate polydata with cylinders representing bonds |
| vtkMoleculeToPolyDataFilter | Abstract filter class |
| vtkMPASReader | Read an MPAS netCDF file |
| vtkMPEG2Writer | Writes MPEG2 Movie files |
| vtkMPICommunicator | Class for creating user defined MPI communicators |
| vtkMPIController | Process communication using MPI |
| vtkMPIEventLog | Class for logging and timing |
| vtkMPIImageReader | |
| vtkMultiBlockDataGroupFilter | Collects multiple inputs into one multi-group dataset |
| vtkMultiBlockDataSet | Composite dataset that organizes datasets into blocks |
| vtkMultiBlockDataSetAlgorithm | Superclass for algorithms that produce only vtkMultiBlockDataSet as output |
| vtkMultiBlockMergeFilter | Merges multiblock inputs into a single multiblock output |
| vtkMultiBlockPLOT3DReader | Read PLOT3D data files |
| vtkMultiBlockPLOT3DReaderInternals | |
| vtkMultiCorrelativeAssessFunctor | |
| vtkMultiCorrelativeStatistics | A class for multivariate linear correlation |
| vtkMultiNewickTreeReader | Read multiple vtkTrees from Newick formatted file |
| vtkMultiPieceDataSet | Composite dataset to encapsulates pieces of dataset |
| vtkMultiProcessController | Multiprocessing communication superclass |
| vtkMultiProcessStream | Stream used to pass data across processes using vtkMultiProcessController |
| vtkMultiThreader | A class for performing multithreaded execution |
| vtkMultiThreshold | Threshold cells within multiple intervals |
| vtkMultiTimeStepAlgorithm | Superclass for algorithms that would like to make multiple time requests |
| vtkMutableDirectedGraph | An editable directed graph |
| vtkMutableGraphHelper | Helper class for building a directed or directed graph |
| vtkMutableUndirectedGraph | An editable undirected graph |
| vtkMutexLock | Mutual exclusion locking class |
| vtkMySQLDatabase | Maintain a connection to a MySQL database |
| vtkMySQLDatabasePrivate | |
| vtkMySQLQuery | VtkSQLQuery implementation for MySQL databases |
| vtkMySQLToTableReader | Read a MySQL table as a vtkTable |
| vtkNamedColors | A class holding colors and their names |
| vtkNetCDFCAMReader | Read unstructured NetCDF CAM files |
| vtkNetCDFCFReader | |
| vtkNetCDFPOPReader | Read NetCDF files .Author Joshua Wu 09.15.2009 |
| vtkNetCDFReader | |
| vtkNetworkHierarchy | Filter that takes a graph and makes a tree out of the network ip addresses in that graph |
| vtkNew< T > | Allocate and hold a VTK object |
| vtkNewickTreeReader | Read vtkTree from Newick formatted file |
| vtkNonLinearCell | Abstract superclass for non-linear cells |
| vtkNonMergingPointLocator | Direct / check-free point insertion |
| vtkNonOverlappingAMR | |
| vtkNonOverlappingAMRAlgorithm | |
| vtkNonOverlappingAMRLevelIdScalars | Generate scalars from levels |
| 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) |
| vtkNrrdReader | Read nrrd files file system |
| vtkOBBDicer | Divide dataset into spatially aggregated pieces |
| vtkOBBNode | |
| vtkOBBTree | Generate oriented bounding box (OBB) tree |
| vtkObject | Abstract base class for most VTK objects |
| vtkObjectBase | Abstract base class for most VTK objects |
| vtkObjectFactory | Abstract base class for vtkObjectFactories |
| vtkObjectFactoryCollection | Maintain a list of object factories |
| vtkOBJExporter | Export a scene into Wavefront format |
| vtkOBJReader | Read Wavefront .obj files |
| vtkObserverMediator | Manage contention for cursors and other resources |
| vtkOctreePointLocator | Octree spatial decomposition of a set of points |
| vtkOctreePointLocatorNode | Octree node that has 8 children each of equal size |
| vtkODBCDatabase | Maintain an ODBC connection to a SQL database |
| vtkODBCInternals | Simple class to hide ODBC structures |
| vtkODBCQuery | VtkSQLQuery implementation for ODBC connections to databases |
| vtkOggTheoraWriter | Uses the ogg and theora libraries to write video files |
| vtkOldStyleCallbackCommand | Supports legacy function callbacks for VTK |
| vtkOnePieceExtentTranslator | Returns the whole extent for any piece.. vtkOnePieceExtentTranslator returns the whole extent for any piece |
| vtkOOGLExporter | Export a scene into Geomview OOGL format |
| vtkOpaquePass | Render the opaque geometry with property key filtering |
| vtkOpenFOAMReader | Reads a dataset in OpenFOAM format |
| vtkOpenGL2ContextDevice2D | Class for drawing 2D primitives using OpenGL 2 |
| vtkOpenGL2ContextDevice2DPrivate | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| vtkOpenGLActor | OpenGL actor |
| vtkOpenGLBufferObjectState | |
| vtkOpenGLCamera | OpenGL camera |
| vtkOpenGLClipPlanesPainter | Painter that manages clipping |
| vtkOpenGLClipPlaneState | |
| vtkOpenGLCoincidentTopologyResolutionPainter | |
| vtkOpenGLComponentTransform | |
| vtkOpenGLCompositePainter | Composite painter for OpenGL |
| vtkOpenGLContextBufferId | 2D array of ids stored in VRAM |
| vtkOpenGLContextDevice2D | Class for drawing 2D primitives using OpenGL 1.1+ |
| vtkOpenGLContextDevice3D | OpenGL class drawing 3D primitives |
| vtkOpenGLDisplayListPainter | Display list painter using OpenGL |
| vtkOpenGLExtensionManager | Interface class for querying and using OpenGL extensions |
| vtkOpenGLFixePipelineState | |
| vtkOpenGLFreeTypeTextMapper | 2D Text annotation support |
| vtkOpenGLGL2PSHelper | Helper functionality for GL2PS exporting |
| vtkOpenGLGlyph3DMapper | VtkOpenGLGlyph3D on the GPU |
| vtkOpenGLGPUVolumeRayCastMapper | OpenGL subclass that draws the image to the screen |
| vtkOpenGLHardwareSupport | OpenGL rendering window |
| vtkOpenGLHAVSVolumeMapper | Hardware-Assisted Visibility Sorting unstructured grid mapper, OpenGL implementation |
| vtkOpenGLImageMapper | 2D image display support for OpenGL |
| vtkOpenGLImageSliceMapper | OpenGL mapper for image slice display |
| vtkOpenGLIndexPixelMapState | |
| vtkOpenGLLight | OpenGL light |
| vtkOpenGLLightingPainter | Painter that manages lighting |
| vtkOpenGLLightState | |
| vtkOpenGLMaterialState | |
| vtkOpenGLPainterDeviceAdapter | An adapter between a vtkPainter and a rendering device |
| vtkOpenGLPixelControl | |
| vtkOpenGLPolyDataMapper | PolyDataMapper for the OpenGL library |
| vtkOpenGLPolyDataMapper2D | 2D PolyData support for OpenGL |
| vtkOpenGLProgramState | |
| vtkOpenGLProjectedAAHexahedraMapper | OpenGL implementation of a volume mapper for axis-aligned hexahedra |
| vtkOpenGLProjectedPolyDataRayBounder | Open GL ray bounder |
| vtkOpenGLProjectedTetrahedraMapper | OpenGL implementation of PT |
| vtkOpenGLProperty | OpenGL property |
| vtkOpenGLRayCastImageDisplayHelper | OpenGL subclass that draws the image to the screen |
| vtkOpenGLRenderer | OpenGL renderer |
| vtkOpenGLRenderWindow | OpenGL rendering window |
| vtkOpenGLRepresentationPainter | Painter handling representation using OpenGL |
| vtkOpenGLRGBAPixelMapState | |
| vtkOpenGLScalarsToColorsPainter | Implementation of vtkScalarsToColorsPainter for OpenGL |
| vtkOpenGLShaderState | |
| vtkOpenGLState | Raw OpenGL State |
| vtkOpenGLTexGenState | |
| vtkOpenGLTexture | OpenGL texture map |
| vtkOpenGLTextureCoordinateProcessingUnit | |
| vtkOpenGLTextureImageState | |
| vtkOpenGLTextureImageUnit | |
| vtkOpenGLTextureImageUnitFixedPipelineState | |
| vtkOpenGLVolumeTextureMapper2D | Abstract class for a volume mapper |
| vtkOpenGLVolumeTextureMapper3D | Concrete implementation of 3D volume texture mapping |
| vtkOpenQubeElectronicData | Provides access to and storage of electronic data calculated by OpenQube |
| vtkOpenQubeMoleculeSource | Read a OpenQube readable file and output a vtkMolecule object |
| vtkOrderedTriangulator | Helper class to generate triangulations |
| vtkOrderStatistics | A class for univariate order statistics |
| vtkOrientationMarkerWidget | 2D widget for manipulating a marker prop |
| vtkOrientedGlyphContourRepresentation | Default representation for the contour widget |
| vtkOrientedGlyphFocalPlaneContourRepresentation | Contours constrained to a focal plane |
| vtkOrientedPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D while maintaining a fixed orientation w.r.t the camera |
| vtkOSOpenGLRenderWindow | OffScreen Mesa rendering window |
| vtkOStreamWrapper | Wrapper for C++ ostream. Internal VTK use only |
| vtkOStrStreamWrapper | Wrapper for ostrstream. Internal VTK use only |
| vtkOutEdgeIterator | Iterates through all outgoing edges from a vertex |
| vtkOutEdgeType | |
| vtkOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
| vtkOutlineCornerSource | Create wireframe outline corners around bounding box |
| vtkOutlineFilter | Create wireframe outline for arbitrary data set |
| vtkOutlineSource | Create wireframe outline around bounding box |
| vtkOutputStream | Wraps a binary output stream with a VTK interface |
| vtkOutputWindow | Base class for writing debug output to a console |
| vtkOutputWindowCleanup | |
| vtkOverlappingAMR | Hierarchical dataset of vtkUniformGrids |
| vtkOverlappingAMRAlgorithm | |
| vtkOverlappingAMRLevelIdScalars | Generate scalars from levels |
| vtkOverlayPass | Render the overlay geometry with property key filtering |
| vtkOverrideInformation | Factory object override information |
| vtkOverrideInformationCollection | Maintain a list of override information objects |
| vtkPainter | Abstract class for drawing poly data |
| vtkPainterDeviceAdapter | An adapter between a vtkPainter and a rendering device |
| vtkPainterPolyDataMapper | PolyDataMapper using painters |
| vtkPairwiseExtractHistogram2D | Compute a 2D histogram between all adjacent columns of an input vtkTable |
| vtkParallelCoordinatesActor | Create parallel coordinate display from input field |
| vtkParallelCoordinatesHistogramRepresentation | Data representation that takes generic multivariate data and produces a parallel coordinates plot. This plot optionally can draw a histogram-based plot summary |
| vtkParallelCoordinatesInteractorStyle | Interactive manipulation of the camera specialized for parallel coordinates |
| vtkParallelCoordinatesRepresentation | Data representation that takes generic multivariate data and produces a parallel coordinates plot |
| vtkParallelCoordinatesView | View to be used with vtkParallelCoordinatesRepresentation |
| vtkParallelopipedRepresentation | Default representation for vtkParallelopipedWidget |
| vtkParallelopipedWidget | Widget to manipulate 3D parallelopipeds |
| vtkParallelRenderManager | An object to control parallel rendering |
| vtkParametricBoy | Generate Boy's surface |
| vtkParametricConicSpiral | Generate conic spiral surfaces that resemble sea-shells |
| vtkParametricCrossCap | Generate a cross-cap |
| vtkParametricDini | Generate Dini's surface |
| vtkParametricEllipsoid | Generate an ellipsoid |
| vtkParametricEnneper | Generate Enneper's surface |
| vtkParametricFigure8Klein | Generate a figure-8 Klein bottle |
| vtkParametricFunction | Abstract interface for parametric functions |
| vtkParametricFunctionSource | Tessellate parametric functions |
| vtkParametricKlein | Generates a "classical" representation of a Klein bottle |
| vtkParametricMobius | Generate a Mobius strip |
| vtkParametricRandomHills | Generate a surface covered with randomly placed hills |
| vtkParametricRoman | Generate Steiner's Roman Surface |
| vtkParametricSpline | Parametric function for 1D interpolating splines |
| vtkParametricSuperEllipsoid | Generate a superellipsoid |
| vtkParametricSuperToroid | Generate a supertoroid |
| vtkParametricTorus | Generate a torus |
| vtkParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
| vtkParticleReader | Read ASCII or binary particle data and (optionally) one scalar value associated with each particle |
| vtkParticleTracer | A Parallel Particle tracer for unsteady vector fields |
| vtkParticleTracerBase | A particle tracer for vector fields |
| vtkPassArrays | Passes a subset of arrays to the output |
| vtkPassInputTypeAlgorithm | Superclass for algorithms that produce output of the same type as input |
| vtkPassThrough | Shallow copies the input into the output |
| vtkPassThroughEdgeStrategy | Passes edge routing information through |
| vtkPassThroughFilter | Filter which shallow copies it's input to it's output |
| vtkPassThroughLayoutStrategy | Layout strategy that does absolutely nothing |
| vtkPath | Concrete dataset representing a path defined by Bezier curves |
| vtkPAutoCorrelativeStatistics | A class for parallel auto-correlative statistics |
| 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 |
| vtkPBGLDistributedGraphHelper | End namespace boost::graph::distributed |
| vtkPBGLGraphAdapter | Adapter to the Parallel Boost Graph Library (http://www.osl.iu.edu/research/pbgl) |
| 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 |
| vtkPBivariateLinearTableThreshold | Performs line-based thresholding for vtkTable data in parallel |
| vtkPCAAnalysisFilter | Performs principal component analysis of a set of aligned pointsets |
| vtkPCAStatistics | A class for multivariate principal component analysis |
| vtkPCAStatisticsGnuR | A class for multivariate principal component analysis using R to calculate p-values |
| vtkPCellDataToPointData | Compute point arrays from cell arrays |
| vtkPChacoReader | Read Chaco files |
| vtkPComputeHistogram2DOutliers | Extract outlier rows from a vtkTable based on input 2D histograms, in parallel |
| vtkPContingencyStatistics | A class for parallel bivariate contingency statistics |
| vtkPCorrelativeStatistics | A class for parallel bivariate correlative statistics |
| vtkPCosmoHaloFinder | Find halos within a cosmology data file |
| vtkPCosmoReader | Read a binary cosmology data file |
| vtkPDataSetGhostGenerator | |
| vtkPDataSetReader | Manages reading pieces of a data set |
| vtkPDataSetWriter | Manages writing pieces of a data set |
| vtkPDBReader | Read Molecular Data files |
| vtkPDescriptiveStatistics | A class for parallel univariate descriptive statistics |
| vtkPen | Pen that draws the outlines of shapes drawn by vtkContext2D |
| vtkPentagonalPrism | 3D cell that represents a prism with pentagonal base |
| vtkPeriodicTable | Access to information about the elements |
| vtkPerlinNoise | Implicit function that implements Perlin noise |
| vtkPerspectiveTransform | Describes a 4x4 matrix transformation |
| vtkPerturbCoincidentVertices | Perturbs vertices that are coincident |
| vtkPExodusIIReader | Read Exodus II files (.exii) |
| vtkPExodusIIWriter | Write Exodus II files |
| vtkPExtractArraysOverTime | Extract point or cell data over time (parallel) |
| vtkPExtractHistogram2D | Compute a 2D histogram between two columns of an input vtkTable in parallel |
| vtkPHardwareSelector | VtkHardwareSelector useful for parallel rendering |
| vtkPicker | Superclass for 3D geometric pickers (uses ray cast) |
| vtkPickingManager | |
| vtkPieceRequestFilter | Sets the piece request for upstream filters |
| vtkPieceScalars | Sets all cell scalars from the update piece |
| vtkPiecewiseControlPointsItem | Control points for vtkPiecewiseFunction |
| vtkPiecewiseFunction | Defines a 1D piecewise function |
| vtkPiecewiseFunctionAlgorithm | Superclass for algorithms that produce only piecewise function as output |
| vtkPiecewiseFunctionItem | VtkPiecewiseFunctionItem internall uses vtkPlot::Color, white by default |
| vtkPiecewiseFunctionShiftScale | |
| vtkPiecewisePointHandleItem | VtkContextItem that draws handles around a point of a piecewise function |
| vtkPieChartActor | Create a pie chart from an array |
| vtkPImageWriter | Writes images to files |
| vtkPipelineGraphSource | Graph constructed from a VTK pipeline |
| vtkPipelineSize | Compute the memory required by a pipeline |
| vtkPistonAlgorithm | Superclass for algorithms that produce only PistonDataObjects |
| vtkPistonContour | A filter that contours on the GPU |
| vtkPistonDataObject | A GPU resident data set |
| vtkPistonDataWrangling | Miscellaneous conversion code |
| vtkPistonMapper | Draws vtkPistonDataObjects to the screen |
| vtkPistonMinMax | Computes scalar range on GPU for mapper |
| vtkPistonReference | Lower level handle on GPU resident data |
| vtkPistonScalarsColors | Color Mapping for piston results |
| vtkPistonSlice | A filter that slices on the GPU |
| vtkPistonSort | NVidia thrust filter example |
| vtkPistonThreshold | A filter that contours on the GPU |
| vtkPistonToDataSet | Converts a PistonDataObject to a DataSet |
| vtkPixel | Cell that represents an orthogonal quadrilateral |
| vtkPixelBufferObject | Abstracts an OpenGL pixel buffer object |
| vtkPKdTree | Build a k-d tree decomposition of a list of points |
| vtkPKMeansStatisitcs | A class for parallel k means clustering |
| vtkPKMeansStatistics | |
| vtkPlane | Perform various plane computations |
| vtkPlaneCollection | Maintain a list of planes |
| vtkPlanes | Implicit function for convex set of planes |
| vtkPlanesIntersection | A vtkPlanesIntersection object is a vtkPlanes object that can compute whether the arbitrary convex region bounded by it's planes intersects an axis-aligned box |
| vtkPlaneSource | Create an array of quadrilaterals located in a plane |
| vtkPlaneWidget | 3D widget for manipulating a finite plane |
| vtkPlatonicSolidSource | Produce polygonal Platonic solids |
| vtkPlaybackRepresentation | Represent the vtkPlaybackWidget |
| vtkPlaybackWidget | 2D widget for controlling a playback stream |
| vtkPLinearExtrusionFilter | Subclass that handles piece invariance |
| vtkPlot | Abstract class for 2D plots |
| vtkPlot3D | Abstract class for 3D plots |
| vtkPlot3DMetaReader | Reads meta-files points to PLOT3D files |
| vtkPlotBar | Class for drawing an XY plot given two columns from a vtkTable |
| vtkPlotGrid | Takes care of drawing the plot grid |
| vtkPlotHistogram2D | |
| vtkPlotLine | Class for drawing an XY line plot given two columns from a vtkTable |
| vtkPlotLine3D | Class for drawing an XYZ line plot given three columns from a vtkTable |
| vtkPlotParallelCoordinates | Class for drawing a parallel coordinate plot given columns from a vtkTable |
| vtkPlotPie | Class for drawing a Pie diagram |
| vtkPlotPoints | Class for drawing an points given two columns from a vtkTable |
| vtkPlotPoints3D | 3D scatter plot |
| vtkPlotStacked | Class for drawing an stacked polygon plot given an X, Ybase, Yextent in a vtkTable |
| vtkPlotSurface | 3D surface plot |
| vtkPLSDynaReader | Read LS-Dyna databases (d3plot) in parallel |
| vtkPLYReader | Read Stanford University PLY polygonal file format |
| vtkPLYWriter | Write Stanford PLY file format |
| vtkPMaskPoints | Parallel Mask Points |
| vtkPMultiCorrelativeStatistics | A class for parallel bivariate correlative statistics |
| vtkPNetCDFPOPReader | Read NetCDF files in parallel with MPI .Author Ross Miller 03.14.2011 |
| vtkPNGReader | Read PNG files |
| vtkPNGWriter | Writes PNG files |
| vtkPNMReader | Read pnm (i.e., portable anymap) files |
| vtkPNMWriter | Writes PNM (portable any map) files |
| vtkPNrrdReader | Read nrrd files efficiently from parallel file systems (and reasonably well elsewhere) |
| vtkPointData | Represent and manipulate point attribute data |
| vtkPointDataToCellData | Map point data to cell data |
| vtkPointHandleRepresentation2D | Represent the position of a point in display coordinates |
| vtkPointHandleRepresentation3D | Represent the position of a point in 3D space |
| vtkPointLoad | Compute stress tensors given point load on semi-infinite domain |
| vtkPointLocator | Quickly locate points in 3-space |
| vtkPointPicker | Select a point by shooting a ray into a graphics window |
| vtkPointPlacer | Abstract interface to translate 2D display positions to world coordinates |
| vtkPoints | Represent and manipulate 3D points |
| vtkPoints2D | Represent and manipulate 2D points |
| vtkPointSet | Abstract class for specifying dataset behavior |
| vtkPointSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| vtkPointSetToLabelHierarchy | Build a label hierarchy for a graph or point set |
| vtkPointSource | Create a random cloud of points |
| vtkPointsPainter | This painter paints verts |
| vtkPointsProjectedHull | Convex hull of the orthogonal projection of the vtkPoints in the 3 coordinate directions |
| vtkPointWidget | Position a point in 3D space |
| vtkPolarAxesActor | Create an actor of a polar axes - |
| vtkPolyData | Concrete dataset represents vertices, lines, polygons, and triangle strips |
| vtkPolyDataAlgorithm | Superclass for algorithms that produce only polydata as output |
| vtkPolyDataCollection | Maintain a list of polygonal data objects |
| vtkPolyDataConnectivityFilter | Extract polygonal data based on geometric connectivity |
| vtkPolyDataContourLineInterpolator | Contour interpolator for polygonal data |
| vtkPolyDataMapper | Map vtkPolyData to graphics primitives |
| vtkPolyDataMapper2D | Draw vtkPolyData onto the image plane |
| vtkPolyDataNormals | Compute normals for polygonal mesh |
| vtkPolyDataPainter | Abstract class for drawing poly data |
| vtkPolyDataPointPlacer | Base class to place points given constraints on polygonal data |
| vtkPolyDataPointSampler | Generate points from vtkPolyData |
| vtkPolyDataReader | Read vtk polygonal data file |
| vtkPolyDataSilhouette | Sort polydata along camera view direction |
| vtkPolyDataSourceWidget | Abstract PolyDataSource-based 3D widget |
| vtkPolyDataStreamer | Streamer appends input pieces to the output |
| vtkPolyDataToImageStencil | Use polydata to mask an image |
| vtkPolyDataToReebGraphFilter | Generate a Reeb graph from a scalar field defined on a vtkPolyData |
| vtkPolyDataWriter | Write vtk polygonal data |
| vtkPolygon | Cell that represents an n-sided polygon |
| vtkPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D space |
| vtkPolygonalSurfaceContourLineInterpolator | Contour interpolator for to place points on polygonal surfaces |
| vtkPolygonalSurfacePointPlacer | |
| vtkPolygonalSurfacePointPlacerNode | |
| vtkPolygonBuilder | |
| vtkPolygonsPainter | This painter paints polygons |
| vtkPolyhedron | 3D cell defined by a set of polygonal faces |
| vtkPolyLine | Cell represents a set of 1D lines |
| vtkPolynomialSolversUnivariate | Polynomial solvers |
| vtkPolyPlane | Implicit function that is generated by extrusion of a polyline along the Z axis |
| vtkPolyVertex | Cell represents a set of 0D vertices |
| vtkPOpenFOAMReader | Reads a decomposed dataset in OpenFOAM format |
| vtkPOrderStatistics | A class for parallel univariate order statistics |
| vtkPostgreSQLDatabase | Maintain a connection to a PostgreSQL database |
| vtkPostgreSQLDatabasePrivate | Internal details of a connection to a PostgreSQL database |
| vtkPostgreSQLQuery | VtkSQLQuery implementation for PostgreSQL databases |
| vtkPostgreSQLToTableReader | Read a PostgreSQL table as a vtkTable |
| vtkPostScriptWriter | Writes an image as a PostScript file |
| vtkPOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
| vtkPOutlineFilter | Create wireframe outline for arbitrary data set |
| vtkPOutlineFilterInternals | Create wireframe outline (or corners) for arbitrary data set |
| vtkPOVExporter | Export scene into povray format |
| vtkPPairwiseExtractHistogram2D | Compute a 2D histogram between all adjacent columns of an input vtkTable in parallel |
| vtkPParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
| vtkPParticleTracer | A Parallel Particle tracer for unsteady vector fields |
| vtkPParticleTracerBase | |
| vtkPPCAStatistics | A class for parallel principal component analysis |
| vtkPPolyDataNormals | Compute normals for polygonal mesh |
| vtkPProbeFilter | Probe dataset in parallel |
| vtkPProjectSphereFilter | A filter to 'unroll' a sphere. The unroll longitude is -180 |
| vtkPReflectionFilter | Parallel version of vtkReflectionFilter |
| vtkPrimitivePainter | Superclass for class that handle single privmitives |
| vtkPriorityQueue | List of ids arranged in priority order |
| vtkProbeFilter | Sample data values at specified point locations |
| vtkProbePolyhedron | Probe/interpolate data values in the interior, exterior or of the surface of a closed, manifold polyhedron |
| vtkProbeSelectedLocations | Similar to vtkExtractSelectedLocations except that it interpolates the point attributes at the probe locations |
| vtkProcess | Process that can be launched by a vtkMultiProcessController |
| vtkProcessGroup | A subgroup of processes from a communicator |
| vtkProcessIdScalars | Sets cell or point scalars to the processor rank |
| vtkProcessingUnitResource | |
| vtkProcrustesAlignmentFilter | Aligns a set of pointsets together |
| vtkProgrammableAttributeDataFilter | Manipulate attribute (cell and point) data via a user-specified function |
| vtkProgrammableDataObjectSource | Generate source data object via a user-specified function |
| vtkProgrammableElectronicData | Provides access to and storage of user-generated vtkImageData that describes electrons |
| vtkProgrammableFilter | User-programmable filter |
| vtkProgrammableGlyphFilter | Control the generation and placement of glyphs at input points |
| vtkProgrammableSource | Generate source dataset via a user-specified function |
| vtkProjectedAAHexahedraMapper | Volume mapper for axis-aligned hexahedra |
| vtkProjectedTerrainPath | Project a polyline onto a terrain |
| vtkProjectedTetrahedraMapper | Unstructured grid volume renderer |
| vtkProjectedTexture | Assign texture coordinates for a projected texture |
| vtkProjectSphereFilter | A filter to 'unroll' a sphere. The unroll longitude is -180 |
| vtkProp | Abstract superclass for all actors, volumes and annotations |
| vtkProp3D | 3D object for placement in a rendered scene |
| vtkProp3DButtonRepresentation | Defines a representation for a vtkButtonWidget |
| vtkProp3DCollection | List of 3D props |
| vtkProp3DFollower | VtkProp3D that always faces the camera |
| vtkPropAssembly | Create hierarchies of props |
| vtkPropCollection | List of Props |
| vtkProperty | Represent surface properties of a geometric object |
| vtkProperty2D | Represent surface properties of a 2D image |
| vtkPropPicker | Pick an actor/prop using graphics hardware |
| vtkProStarReader | Reads geometry in proSTAR (STARCD) file format |
| vtkProteinRibbonFilter | Generates protein ribbons |
| vtkPruneTreeFilter | Prune a subtree out of a vtkTree |
| vtkPSLACReader | |
| vtkPSphereSource | Sphere source that supports pieces |
| vtkPStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
| vtkPStreamTracer | Parallel streamline generators |
| vtkPStructuredGridConnectivity | |
| vtkPStructuredGridGhostDataGenerator | |
| vtkPTableToStructuredGrid | VtkTableToStructuredGrid specialization which handles distribution of the input table |
| vtkPTemporalStreamTracer | |
| vtkPUniformGridGhostDataGenerator | |
| vtkPWindBladeReader | Class for reading WindBlade data files |
| vtkPYoungsMaterialInterface | Parallel reconstruction of material interfaces |
| vtkPyramid | 3D cell that represents a linear pyramid |
| vtkPythonArgs | |
| vtkPythonCommand | |
| vtkPythonOverload | Created in June 2010 by David Gobbi, originally in vtkPythonUtil |
| vtkPythonUtil | |
| vtkQImageToImageSource | Create image data from a QImage |
| vtkQtAbstractModelAdapter | Superclass for Qt model adapters |
| vtkQtAnnotationLayersModelAdapter | Adapts annotations to a Qt item model |
| vtkQtAnnotationView | A VTK view that displays the annotations on its annotation link |
| vtkQtConnection | |
| vtkQtDebugLeaksModel | Model class that observes the vtkDebugLeaks singleton |
| vtkQtDebugLeaksView | View class to display contents of vtkQtDebugLeaksModel |
| vtkQtInitialization | Initializes a Qt application |
| vtkQtLabelRenderStrategy | Renders labels with Qt |
| vtkQtListView | A VTK view based on a Qt List view |
| vtkQtRecordView | Superclass for QAbstractItemView-based views |
| vtkQtRichTextView | Superclass for QAbstractItemView-based views |
| vtkQtSQLDatabase | Maintains a connection to an sql database |
| vtkQtSQLQuery | Query class associated with vtkQtSQLDatabase |
| vtkQtStringToImage | Uses Qt to render the supplied text to an image |
| vtkQtTableModelAdapter | Adapts a table to a Qt item model |
| vtkQtTableRepresentation | Set up a vtkTable in a Qt model |
| vtkQtTableView | A VTK view based on a Qt Table view |
| vtkQtTimePointUtility | Performs common time operations |
| vtkQtTreeModelAdapter | Adapts a tree to a Qt item model |
| vtkQtTreeRingLabelMapper | Draw text labels on a tree map |
| vtkQtTreeView | A VTK view based on a Qt tree view |
| vtkQtView | Superclass for Qt widget-based views |
| vtkQuad | Cell that represents a 2D quadrilateral |
| vtkQuadraticEdge | Cell represents a parabolic, isoparametric edge |
| vtkQuadraticHexahedron | Cell represents a parabolic, 20-node isoparametric hexahedron |
| vtkQuadraticLinearQuad | Cell represents a quadratic-linear, 6-node isoparametric quad |
| vtkQuadraticLinearWedge | Cell represents a, 12-node isoparametric wedge |
| vtkQuadraticPyramid | Cell represents a parabolic, 13-node isoparametric pyramid |
| vtkQuadraticQuad | Cell represents a parabolic, 8-node isoparametric quad |
| vtkQuadraticTetra | Cell represents a parabolic, 10-node isoparametric tetrahedron |
| vtkQuadraticTriangle | Cell represents a parabolic, isoparametric triangle |
| vtkQuadraticWedge | Cell represents a parabolic, 15-node isoparametric wedge |
| vtkQuadraturePointInterpolator | |
| vtkQuadraturePointsGenerator | |
| vtkQuadratureSchemeDefinition | |
| vtkQuadratureSchemeDictionaryGenerator | |
| vtkQuadric | Evaluate implicit quadric function |
| vtkQuadricClustering | Reduce the number of triangles in a mesh |
| vtkQuadricDecimation | Reduce the number of triangles in a mesh |
| vtkQuadricLODActor | Specific level-of-detail strategy using the quadric clustering decimation algorithm |
| vtkQuadRotationalExtrusionFilter | Sweep polygonal data creating "skirt" from free edges and lines, and lines from vertices |
| vtkQuantizePolyDataPoints | Quantizes x,y,z coordinates of points |
| vtkQuaternion< T > | Templated base type for storage of quaternions |
| vtkQuaterniond | |
| vtkQuaternionf | |
| vtkQuaternionInterpolator | Interpolate a quaternion |
| 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 |
| vtkRandomAttributeGenerator | Generate and create random data attributes |
| vtkRandomGraphSource | Graph with random edges |
| vtkRandomLayoutStrategy | Randomly places vertices in 2 or 3 dimensions |
| vtkRandomSequence | Sequence of random numbers |
| vtkSynchronizedRenderers::vtkRawImage | VtkRawImage can be used to make it easier to deal with images for compositing/communicating over client-server etc |
| vtkRayCastImageDisplayHelper | Helper class that draws the image to the screen |
| vtkRayCastRayInfo | |
| vtkRayCastStructures | Structure definitions for ray casting |
| vtkRCalculatorFilter | |
| vtkRearrangeFields | Move/copy fields between field data, point data and cell data |
| vtkRect< T > | Templated base type for storage of 2D rectangles |
| vtkRectangularButtonSource | Create a rectangular button |
| vtkRectd | |
| vtkRectf | |
| vtkRecti | |
| vtkRectilinearGrid | Dataset that is topologically regular with variable spacing in the three coordinate directions |
| vtkRectilinearGridAlgorithm | Superclass for algorithms that produce only rectilinear grid as output |
| vtkRectilinearGridClip | Reduces the image extent of the input |
| vtkRectilinearGridGeometryFilter | Extract geometry for a rectilinear grid |
| vtkRectilinearGridOutlineFilter | Create wireframe outline for a rectilinear grid |
| vtkRectilinearGridPartitioner | |
| vtkRectilinearGridReader | Read vtk rectilinear grid data file |
| vtkRectilinearGridToPointSet | Converts a vtkRectilinearGrid to a vtkPointSet |
| vtkRectilinearGridToTetrahedra | Create a Tetrahedral mesh from a RectilinearGrid |
| vtkRectilinearGridWriter | Write vtk rectilinear grid data file |
| vtkRectilinearSynchronizedTemplates | Generate isosurface from rectilinear grid |
| vtkRectilinearWipeRepresentation | Represent a vtkRectilinearWipeWidget |
| vtkRectilinearWipeWidget | Interactively control an instance of vtkImageRectilinearWipe filter |
| vtkRecursiveDividingCubes | Create points laying on isosurface (using recursive approach) |
| vtkRecursiveSphereDirectionEncoder | A direction encoder based on the recursive subdivision of an octahedron |
| vtkReebGraph | Reeb graph computation for PL scalar fields |
| vtkReebGraphSimplificationFilter | Simplify an input Reeb graph |
| vtkReebGraphSimplificationMetric | Abstract class for custom Reeb graph simplification metric design |
| vtkReebGraphSurfaceSkeletonFilter | Compute a skeletal embedding of the Reeb graph of a scalar field defined on a triangulated surface (vtkPolyData) |
| 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 |
| vtkReebGraphVolumeSkeletonFilter | Compute a skeletal embedding of the Reeb graph of a scalar field defined on a tetrahedral mesh (vtkUnstructuredGrid) |
| vtkReferenceCount | Obsolete / empty subclass of object |
| vtkReflectionFilter | Reflects a data set across a plane |
| vtkRegressionTester | |
| vtkRegularPolygonSource | Create a regular, n-sided polygon and/or polyline |
| vtkRemoveHiddenData | Removes the rows/edges/vertices of input data flagged by ann |
| vtkRemoveIsolatedVertices | Remove vertices of a vtkGraph with degree zero |
| vtkRenderedAreaPicker | Uses graphics hardware to picks props behind a selection rectangle on a viewport |
| vtkRenderedGraphRepresentation | |
| vtkRenderedHierarchyRepresentation | |
| vtkRenderedRepresentation | |
| vtkRenderedSurfaceRepresentation | Displays a geometric dataset as a surface |
| vtkRenderedTreeAreaRepresentation | |
| vtkRenderer | Abstract specification for renderers |
| vtkRendererCollection | List of renderers |
| vtkRendererDelegate | Render the props of a vtkRenderer |
| vtkRendererSource | Take a renderer into the pipeline |
| vtkRenderLargeImage | Use tiling to generate a large rendering |
| vtkRenderPass | Perform part of the rendering of a vtkRenderer |
| vtkRenderPassCollection | List of RenderPasses |
| vtkRenderState | Context in which a vtkRenderPass will render |
| vtkRenderView | A view containing a renderer |
| vtkRenderViewBase | A base view containing a renderer |
| vtkRenderWindow | Create a window for renderers to draw into |
| vtkRenderWindowCollection | List of RenderWindows |
| vtkRenderWindowInteractor | Platform-independent render window interaction including picking and frame rate control |
| vtkRepresentationPainter | Painter that handles representation |
| vtkResliceCursor | Geometry for a reslice cursor |
| vtkResliceCursorActor | Represent a reslice cursor |
| vtkResliceCursorLineRepresentation | Represent the vtkResliceCursorWidget |
| vtkResliceCursorPicker | Ray-cast cell picker for the reslice cursor |
| vtkResliceCursorPolyDataAlgorithm | Generates a 2D reslice cursor polydata |
| vtkResliceCursorRepresentation | Represent the vtkResliceCursorWidget |
| vtkResliceCursorThickLineRepresentation | Thick slab of the reslice cursor widget |
| vtkResliceCursorWidget | Represent a reslice cursor |
| vtkResliceImageViewer | Display an image along with a reslice cursor |
| vtkResliceImageViewerMeasurements | Manage measurements on a resliced image |
| vtkReverseSense | Reverse the ordering of polygonal cells and/or vertex normals |
| vtkRibbonFilter | Create oriented ribbons from lines defined in polygonal dataset |
| vtkRIBExporter | Export a scene into RenderMan RIB format |
| vtkRIBLight | RIP Light |
| vtkRIBProperty | RIP Property |
| vtkRInterface | |
| vtkRISReader | Reader for RIS files |
| vtkROIStencilSource | Create simple mask shapes |
| vtkRotationalExtrusionFilter | Sweep polygonal data creating "skirt" from free edges and lines, and lines from vertices |
| vtkRotationFilter | Duplicates a data set by rotation about an axis |
| vtkRowQuery | Abstract interface for queries that return row-oriented results |
| vtkRowQueryToTable | Executes an sql query and retrieves results into a table |
| vtkRRandomTableSource | Generates vtkTables with columns of random numbers using Gnu R |
| vtkRTAnalyticSource | Create an image for regression testing |
| vtkRTXMLPolyDataReader | Read RealTime VTK XML PolyData files |
| vtkRuledSurfaceFilter | Generates a surface from a set of lines |
| vtkRungeKutta2 | Integrate an initial value problem using 2nd order Runge-Kutta method |
| vtkRungeKutta4 | Integrate an initial value problem using 4th order Runge-Kutta method |
| vtkRungeKutta45 | Integrate an initial value problem using 5th order Runge-Kutta method with adaptive stepsize control |
| vtkSampleFunction | Sample an implicit function over a structured point set |
| vtkScalarBarActor | Create a scalar bar with labels |
| vtkScalarBarActorInternal | Internal state for the scalar bar actor shared with subclasses |
| vtkScalarBarBox | A structure to represent pixel coordinates for text or swatch bounds |
| vtkScalarBarRepresentation | Represent scalar bar for vtkScalarBarWidget |
| vtkScalarBarWidget | 2D widget for manipulating a scalar bar |
| vtkScalarsToColors | Superclass for mapping scalar values to colors |
| vtkScalarsToColorsItem | Abstract class for ScalarsToColors items |
| vtkScalarsToColorsPainter | Painter that converts scalars to colors. It enable/disables coloring state depending on the ScalarMode |
| vtkScalarTree | Organize data according to scalar values (used to accelerate contouring operations) |
| vtkScaledTextActor | Create text that will scale as needed |
| vtkScatterPlotMatrix | Container for a matrix of charts |
| vtkScenePicker | Picks an entire viewport at one shot |
| vtkSCurveSpline | Computes an interpolating spline using a a SCurve basis |
| vtkSectorSource | Create a sector of a disk |
| vtkSeedRepresentation | Represent the vtkSeedWidget |
| vtkSeedWidget | Place multiple seed points |
| vtkSelectEnclosedPoints | Mark points as to whether they are inside a closed surface |
| vtkSelection | A node in a selection tree. Used to store selection results |
| vtkSelectionAlgorithm | Superclass for algorithms that produce only Selection as output |
| vtkSelectionNode | A node in a selection tree. Used to store selection results |
| 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) |
| vtkSelectPolyData | Select portion of polygonal mesh; generate selection scalars |
| vtkSelectVisiblePoints | Extract points that are visible (based on z-buffer calculation) |
| vtkSequencePass | Execute render passes sequentially |
| vtkServerSocket | Encapsulate a socket that accepts connections |
| vtkSESAMEReader | Read SESAME files |
| vtkShader | |
| vtkShader2 | GLSL Shader |
| vtkShader2Collection | List of Shader2 objects |
| vtkShaderCodeLibrary | Library for Hardware Shaders |
| vtkShaderDeviceAdapter | Adapter to pass generic vertex attributes to the rendering pipeline. .SECTION This class is an adapter used to pass generic vertex attributes to the rendering pipeline. Since this changes based on the shading language used, this class merely defines the API and subclasses provide implementations for Cg and GSince this changes based on the shading language used, this class merely defines the API and subclasses provide implementations for Cg and GLSL |
| vtkShaderDeviceAdapter2 | Adapter to pass generic vertex attributes to the rendering pipeline. .SECTION This class is an adapter used to pass generic vertex attributes to the rendering pipeline. Since this changes based on the shading language used, this class merely defines the API and subclasses provide implementations for Cg and GL |
| vtkShaderProgram | |
| vtkShaderProgram2 | GLSL Program |
| vtkShadowMapBakerPass | Implement a builder of shadow map pass |
| vtkShadowMapBakerPassLightCameras | |
| vtkShadowMapBakerPassTextures | |
| vtkShadowMapPass | Implement a shadow mapping render pass |
| vtkShepardMethod | Sample unstructured points onto structured points using the method of Shepard |
| vtkShortArray | Dynamic, self-adjusting array of short |
| vtkShrinkFilter | Shrink cells composing an arbitrary data set |
| vtkShrinkPolyData | Shrink cells composing PolyData |
| vtkSignedCharArray | Dynamic, self-adjusting array of signed char |
| vtkSILBuilder | Helper class to build a SIL i.e. a directed graph used by reader producing composite datasets to describes the relationships among the blocks |
| vtkSimple2DLayoutStrategy | Simple 2D graph layout |
| vtkSimple3DCirclesStrategy | Places vertices on circles in 3D |
| vtkSimpleBondPerceiver | Create a simple guess of a molecule's topology |
| vtkSimpleCellTessellator | Helper class to perform cell tessellation |
| vtkSimpleConditionVariable | |
| vtkSimpleCriticalSection | |
| vtkSimpleElevationFilter | Generate scalars along a specified direction |
| vtkSimpleImageFilterExample | Simple example of an image-image filter |
| vtkSimpleImageToImageFilter | Generic image filter with one input |
| vtkSimpleMutexLock | |
| vtkSimplePointsReader | Read a list of points from a file |
| vtkSimplePointsWriter | Write a file of xyz coordinates |
| vtkSimpleScalarTree | Organize data according to scalar values (used to accelerate contouring operations) |
| vtkSLACParticleReader | |
| vtkSLACReader | |
| vtkSLCReader | Read an SLC volume file |
| vtkSliceAndDiceLayoutStrategy | Horizontal and vertical slicing tree map layout |
| vtkSliceCubes | Generate isosurface(s) from volume four slices at a time |
| vtkSliderRepresentation | Abstract class defines the representation for a vtkSliderWidget |
| vtkSliderRepresentation2D | Provide the representation for a vtkSliderWidget with a 3D skin |
| vtkSliderRepresentation3D | Provide the representation for a vtkSliderWidget with a 3D skin |
| vtkSliderWidget | Set a value by manipulating a slider |
| vtkSmartPointer< T > | Hold a reference to a vtkObjectBase instance |
| vtkSmartPointerBase | Non-templated superclass for vtkSmartPointer |
| vtkSmartVector< T > | A vector of smart pointers |
| vtkSmartVolumeMapper | Adaptive volume mapper |
| vtkSmoothErrorMetric | Objects that compute geometry-based error during cell tessellation according to some max angle |
| vtkSmoothPolyDataFilter | Adjust point positions using Laplacian smoothing |
| vtkSobelGradientMagnitudePass | Implement a post-processing edge detection with a Sobel gradient magnitude render pass |
| vtkSocket | BSD socket encapsulation |
| vtkSocketCollection | Collection for sockets |
| vtkSocketCommunicator | Process communication using Sockets |
| vtkSocketController | Process communication using Sockets |
| vtkSortDataArray | Provides several methods for sorting vtk arrays |
| vtkSortFileNames | Group and sort a set of filenames |
| vtkSpanTreeLayoutStrategy | |
| vtkSparseArray< T > | Sparse, independent coordinate storage for N-way arrays |
| vtkSparseArrayToTable | Converts a sparse array to a vtkTable |
| vtkSpatialRepresentationFilter | Generate polygonal model of spatial search object (i.e., a vtkLocator) |
| vtkSphere | Implicit function for a sphere |
| vtkSphereHandleRepresentation | A spherical rendition of point in 3D space |
| vtkSpherePuzzle | Create a polygonal sphere centered at the origin |
| vtkSpherePuzzleArrows | Visualize permutation of the sphere puzzle |
| vtkSphereRepresentation | Class defining the representation for the vtkSphereWidget2 |
| vtkSphereSource | Create a polygonal sphere centered at the origin |
| vtkSphereWidget | 3D widget for manipulating a sphere |
| vtkSphereWidget2 | 3D widget for manipulating a point on a sphere |
| vtkSphericalDirectionEncoder | A direction encoder based on spherical coordinates |
| vtkSphericalTransform | Spherical to rectangular coords and back |
| vtkSpiderPlotActor | Create a spider plot from input field |
| vtkSpline | Spline abstract class for interpolating splines |
| vtkSplineFilter | Generate uniformly subdivided polylines from a set of input polyline using a vtkSpline |
| vtkSplineGraphEdges | Subsample graph edges to make smooth curves |
| vtkSplineRepresentation | VtkWidgetRepresentation for a spline |
| vtkSplineWidget | 3D widget for manipulating a spline |
| vtkSplineWidget2 | Widget for vtkSplineRepresentation |
| vtkSplitColumnComponents | Split multicomponent table columns |
| vtkSplitField | Split a field into single component fields |
| vtkSQLDatabase | Maintain a connection to an sql database |
| vtkSQLDatabaseGraphSource | Generates a vtkGraph based on an SQL query |
| vtkSQLDatabaseSchema | Represent an SQL database schema |
| vtkSQLDatabaseTableSource | Generates a vtkTable based on an SQL query |
| vtkSQLGraphReader | Read a vtkGraph from a database |
| vtkSQLiteDatabase | Maintain a connection to an SQLite database |
| vtkSQLiteQuery | VtkSQLQuery implementation for SQLite databases |
| vtkSQLiteToTableReader | Read an SQLite table as a vtkTable |
| vtkSQLQuery | Executes an sql query and retrieves results |
| vtkSquarifyLayoutStrategy | Uses the squarify tree map layout algorithm |
| vtkStackedTreeLayoutStrategy | Lays out tree in stacked boxes or rings |
| vtkStandardPolyDataPainter | A standard implementation of vtkPolyDataPainter |
| vtkStatisticsAlgorithm | Base class for statistics algorithms |
| vtkStatisticsAlgorithmPrivate | |
| vtkStdString | Wrapper around std::string to keep symbols short |
| vtkSTLReader | Read ASCII or binary stereo lithography files |
| vtkSTLWriter | Write stereo lithography files |
| vtkStrahlerMetric | Compute Strahler metric for a tree |
| vtkStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
| vtkStreamer | Abstract object implements integration of massless particle through vector field |
| vtkStreamerBase | Superclass for filters that stream input pipeline |
| vtkStreamGraph | Combines two graphs |
| vtkStreamingDemandDrivenPipeline | Executive supporting partial updates |
| vtkStreamingStatistics | A class for using the statistics filters in a streaming mode |
| vtkStreamingTessellator | An algorithm that refines an initial simplicial tessellation using edge subdivision |
| vtkStreamLine | Generate streamline in arbitrary dataset |
| vtkStreamPoints | Generate points along streamer separated by constant time increment |
| vtkStreamTracer | Streamline generator |
| vtkStringArray | VtkAbstractArray subclass for strings |
| vtkStringToCategory | Creates a category array from a string array |
| vtkStringToImage | Uses Qt to render the supplied text to an image |
| vtkStringToNumeric | Converts string arrays to numeric arrays |
| vtkStripper | Create triangle strips and/or poly-lines |
| vtkStructuredAMRGridConnectivity | |
| vtkStructuredAMRNeighbor | |
| vtkStructuredData | Singleton class for topologically regular data |
| vtkStructuredExtent | Helper class to aid working with structured extents |
| vtkStructuredGrid | Topologically regular array of data |
| vtkStructuredGridAlgorithm | Superclass for algorithms that produce only structured grid as output |
| vtkStructuredGridClip | Reduces the image extent of the input |
| vtkStructuredGridConnectivity | |
| vtkStructuredGridGeometryFilter | Extract geometry for structured grid |
| vtkStructuredGridGhostDataGenerator | |
| vtkStructuredGridLIC2D | |
| vtkStructuredGridOutlineFilter | Create wireframe outline for structured grid |
| vtkStructuredGridPartitioner | |
| vtkStructuredGridReader | Read vtk structured grid data file |
| vtkStructuredGridWriter | Write vtk structured grid data file |
| vtkStructuredNeighbor | |
| vtkStructuredPoints | A subclass of ImageData |
| vtkStructuredPointsCollection | Maintain a list of structured points data objects |
| vtkStructuredPointsGeometryFilter | Obsolete class |
| vtkStructuredPointsReader | Read vtk structured points data file |
| vtkStructuredPointsWriter | Write vtk structured points data file |
| vtkStructuredVisibilityConstraint | Helper object to manage the visibility of points and cells |
| vtkSubCommunicator | Provides communication on a process group |
| vtkSubdivideTetra | Subdivide one tetrahedron into twelve for every tetra |
| vtkSubGroup | Scalable collective communication for a subset of members of a parallel VTK application |
| vtkSubPixelPositionEdgels | Adjust edgel locations based on gradients |
| vtkHyperTreeGrid::vtkSuperCursorEntry | |
| vtkSuperquadric | Implicit function for a Superquadric |
| vtkSuperquadricSource | Create a polygonal superquadric centered at the origin |
| vtkSurfaceLICDefaultPainter | VtkDefaultPainter replacement that inserts the vtkSurfaceLICPainter at the correct position in the painter chain |
| vtkSurfaceLICPainter | Painter that performs LIC on the surface of arbitrary geometry |
| vtkSurfaceReconstructionFilter | Reconstructs a surface from unorganized points |
| vtkSynchronizedRenderers | Synchronizes renderers across processes |
| vtkSynchronizedRenderWindows | Synchronizes render windows across processess |
| vtkSynchronizedTemplates2D | Generate isoline(s) from a structured points set |
| vtkSynchronizedTemplates3D | Generate isosurface from structured points |
| vtkSynchronizedTemplatesCutter3D | Generate cut surface from structured points |
| vtkSystemIncludes | Transition VTK to ANSI C++, centralize inclusion of system files |
| vtkTable | A table, which contains similar-typed columns of data |
| vtkTableAlgorithm | Superclass for algorithms that produce only vtkTables as output |
| vtkTableBasedClipDataSet | Clip any dataset with a user-specified implicit function or an input scalar point data array |
| vtkTableExtentTranslator | Extent translation through lookup table |
| vtkTableFFT | FFT for table columns |
| vtkTableReader | Read vtkTable data file |
| vtkTableToArray | Converts a vtkTable to a matrix |
| vtkTableToDatabaseWriter | |
| vtkTableToGraph | Convert a vtkTable into a vtkGraph |
| vtkTableToMySQLWriter | Store a vtkTable in a MySQL database |
| vtkTableToPolyData | Filter used to convert a vtkTable to a vtkPolyData consisting of vertices |
| vtkTableToPostgreSQLWriter | Store a vtkTable in a PostgreSQL database |
| vtkTableToSparseArray | Converts a vtkTable into a sparse array |
| vtkTableToSQLiteWriter | Store a vtkTable in an SQLite database |
| vtkTableToStructuredGrid | Converts vtkTable to a vtkStructuredGrid |
| vtkTableToTreeFilter | Filter that converts a vtkTable to a vtkTree |
| vtkTableWriter | Write vtkTable to a file |
| vtkTclCommand | |
| vtkTclCommandArgStruct | |
| vtkTclCommandStruct | |
| vtkTclInterpStruct | |
| vtkTDxDevice | API to access a 3DConnexion input device |
| vtkTDxInteractorStyle | Provide 3DConnexion device event-driven interface to the rendering window |
| vtkTDxInteractorStyleCamera | Interactive manipulation of the camera with a 3DConnexion device |
| vtkTDxInteractorStyleGeo | Interactive manipulation of the camera with a 3DConnexion device, similar to google earth |
| vtkTDxInteractorStyleSettings | 3DConnexion device settings |
| vtkTDxMacDevice | Implementation of vtkTDxDevice on Mac |
| vtkTDxMotionEventInfo | Store motion information from a 3DConnexion input device |
| vtkTDxQtUnixDevices | Manage a list vtkTDXUnixDevice(s) |
| vtkTDxUnixDevice | Implementation of vtkTDxDevice on Unix |
| vtkTDxWinDevice | Implementation of vtkTDxDevice on Windows |
| vtkTecplotReader | A concrete class to read an ASCII Tecplot file |
| vtkTemplateAliasMacro | Dispatch a scalar processing template |
| vtkTemporalDataSetCache | Cache time steps |
| vtkTemporalFractal | A source to test AMR data object |
| vtkTemporalInterpolatedVelocityField | A helper class for interpolating between times during particle tracing |
| vtkTemporalInterpolator | Interpolate datasets between time steps to produce a new dataset |
| vtkTemporalPathLineFilter | Generate a Polydata Pointset from any Dataset |
| vtkTemporalShiftScale | Modify the time range/steps of temporal data |
| vtkTemporalSnapToTimeStep | Modify the time range/steps of temporal data |
| vtkTemporalStatistics | Compute statistics of point or cell data as it changes over time |
| vtkTemporalStreamTracer | A Parallel Particle tracer for unsteady vector fields |
| vtkTensor | Supporting class to enable assignment and referencing of tensors |
| vtkTensorGlyph | Scale and orient glyph(s) according to tensor eigenvalues and eigenvectors |
| vtkTensorProbeRepresentation | Abstract class that serves as a representation for vtkTensorProbeWidget |
| vtkTensorProbeWidget | Widget to probe tensors on a polyline |
| vtkTerrainContourLineInterpolator | Contour interpolator for DEM data |
| vtkTerrainDataPointPlacer | Place points on terrain data |
| vtkTessellatedBoxSource | Create a polygonal representation of a box with a given level of subdivision |
| vtkTessellatorFilter | Approximate nonlinear FEM elements with simplices |
| vtkTesting | Unified VTK regression testing framework |
| vtkTestingInteractor | A RenderWindowInteractor for testing |
| vtkTestingObjectFactory | Object overrides used during testing |
| vtkTestNewVar | |
| vtkTestUtilities | Utility functions used for regression testing |
| vtkTetra | 3D cell that represents a tetrahedron |
| vtkTextActor | An actor that displays text. Scaled or unscaled |
| vtkTextActor3D | An actor that displays text |
| vtkTextCodec | Virtual class to act as an interface for all text codecs |
| vtkTextCodecFactory | Maintain a list of text codecs and return instances |
| vtkTextMapper | 2D text annotation |
| vtkTextProperty | Represent text properties |
| vtkTextRenderer | Interface for generating images and path data from string data, using multiple backends |
| vtkTextRendererCleanup | |
| vtkTextRendererStringToImage | Uses vtkTextRenderer to render the supplied text to an image |
| vtkTextRepresentation | Represent text for vtkTextWidget |
| vtkTextSource | Create polygonal text |
| vtkTexture | Handles properties associated with a texture map |
| vtkTexturedActor2D | Actor that draws 2D data with texture support |
| vtkTexturedButtonRepresentation | Defines a representation for a vtkButtonWidget |
| vtkTexturedButtonRepresentation2D | Defines a representation for a vtkButtonWidget |
| vtkTexturedSphereSource | Create a sphere centered at the origin |
| vtkTextureImageCache< Key > | |
| 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 |
| vtkTextureObject | Abstracts an OpenGL texture object |
| vtkTextureUnitManager | Allocate/free texture units |
| vtkTextWidget | Widget for placing text on overlay plane |
| vtkThinPlateSplineTransform | Nonlinear warp transformation |
| vtkThreadedImageAlgorithm | Generic filter that has one input. |
| vtkThreadedStreamingPipeline | Executive supporting multi-threads |
| vtkThreadMessager | A class for performing inter-thread messaging |
| vtkThreshold | Extracts cells where scalar value in cell satisfies threshold criterion |
| vtkThresholdGraph | Returns a subgraph of a vtkGraph |
| vtkThresholdPoints | Extracts points whose scalar value satisfies threshold criterion |
| vtkThresholdTable | Thresholds table rows |
| vtkThresholdTextureCoords | Compute 1D, 2D, or 3D texture coordinates based on scalar threshold |
| vtkTIFFReader | Read TIFF files |
| vtkTIFFWriter | Write out image data as a TIFF file |
| vtkTimePointUtility | Performs common time operations |
| vtkTimerLog | Timer support and logging |
| vtkTimerLogEntry | |
| vtkTimeSource | Creates a simple time varying data set |
| vtkTimeSourceExample | |
| vtkTimeStamp | Record modification and/or execution time |
| vtkTkImageViewerWidget | Tk Widget for viewing vtk images |
| vtkTkRenderWidget | Tk Widget for vtk renderering |
| vtkTooltipItem | Takes care of drawing 2D axes |
| vtkTransferAttributes | Transfer data from a graph representation to a tree representation using direct mapping or pedigree ids |
| vtkTransform | Describes linear transformations via a 4x4 matrix |
| vtkTransform2D | Describes linear transformations via a 3x3 matrix |
| vtkTransformCollection | Maintain a list of transforms |
| vtkTransformConcatenation | |
| vtkTransformConcatenationStack | |
| vtkTransformCoordinateSystems | Transform points into different coordinate systems |
| vtkTransformFilter | Transform points and associated normals and vectors |
| vtkTransformInterpolator | Interpolate a series of transformation matrices |
| vtkTransformPair | |
| vtkTransformPolyDataFilter | Transform points and associated normals and vectors for polygonal dataset |
| vtkTransformTextureCoords | Transform (scale, rotate, translate) texture coordinates |
| vtkTransformToGrid | Create a grid for a vtkGridTransform |
| vtkTranslucentPass | Render the translucent polygonal geometry with property key filtering |
| vtkTransmitImageDataPiece | For parallel processing, restrict IO to the first process in the cluste.r |
| vtkTransmitPolyDataPiece | Return specified piece, including specified number of ghost levels |
| vtkTransmitRectilinearGridPiece | For parallel processing, restrict IO to the first process in the cluster |
| vtkTransmitStructuredGridPiece | For parallel processing, restrict IO to the first process in the cluster |
| vtkTransmitUnstructuredGridPiece | Return specified piece, including specified number of ghost levels |
| vtkTransposeMatrix | Computes the transpose of an input matrix |
| vtkTree | A rooted tree data structure |
| vtkTreeAlgorithm | Superclass for algorithms that produce only Tree as output |
| 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 |
| vtkTreeBFSIterator | Breadth first search iterator through a vtkTree |
| vtkTreeCompositer | Implements tree based compositing |
| vtkTreeDFSIterator | Depth first iterator through a vtkGraph |
| vtkTreeDifferenceFilter | Compare two trees |
| vtkTreeFieldAggregator | Aggregate field values from the leaves up the tree |
| vtkTreeHeatmapItem | A 2D graphics item for rendering a tree and an associated heatmap |
| vtkTreeIterator | Abstract class for iterator over a vtkTree |
| vtkTreeLayoutStrategy | Hierarchical layout |
| vtkTreeLevelsFilter | Adds level and leaf fields to a vtkTree |
| vtkTreeMapLayout | Layout a vtkTree into a tree map |
| vtkTreeMapLayoutStrategy | Abstract superclass for all tree map layout strategies |
| vtkTreeMapToPolyData | Converts a tree to a polygonal data representing a tree map |
| vtkTreeMapView | Displays a tree as a tree map |
| vtkTreeOrbitLayoutStrategy | Hierarchical orbital layout |
| vtkTreeReader | Read vtkTree data file |
| vtkTreeRingToPolyData | Converts a tree to a polygonal data representing radial space filling tree |
| vtkTreeRingView | Displays a tree in concentric rings |
| vtkTreeWriter | Write vtkTree data to a file |
| vtkTriangle | Cell that represents a triangle |
| vtkTriangleFilter | Convert input polygons and strips to triangles |
| vtkTriangleStrip | Cell that represents a triangle strip |
| vtkTriangularTCoords | 2D texture coordinates based for triangles |
| vtkTriangularTexture | Generate 2D triangular texture map |
| vtkTriQuadraticHexahedron | Cell represents a parabolic, 27-node isoparametric hexahedron |
| vtkTrivialProducer | Producer for stand-alone data objects |
| vtkTryDowncastHelper1< TargetT, FunctorT > | |
| vtkTryDowncastHelper2< TargetT, FunctorT > | |
| vtkTryDowncastHelper3< TargetT, FunctorT > | |
| vtkTStripsPainter | Painter for triangle strips |
| vtkTubeFilter | Filter that generates tubes around lines |
| vtkTulipReader | Reads tulip graph files |
| vtkTuple< T, Size > | Templated base type for containers of constant size |
| vtkTupleInterpolator | Interpolate a tuple of arbitray size |
| vtkTypedArray< T > | Provides a type-specific interface to N-way arrays |
| vtkTypeTemplate< ThisT, BaseT > | Provides the equivalent of vtkTypeMacro for use with template classes |
| vtkTypeTraits | Template defining traits of native types used by VTK |
| vtkUGFacetReader | Read EDS Unigraphics facet files |
| vtkUncertaintyTubeFilter | Generate uncertainty tubes along a polyline |
| vtkUndirectedGraph | An undirected graph |
| vtkUndirectedGraphAlgorithm | Superclass for algorithms that produce undirected graph as output |
| vtkUnicodeString | String class that stores Unicode text |
| vtkUnicodeStringArray | Subclass of vtkAbstractArray that holds vtkUnicodeStrings |
| vtkUniformGrid | Image data with blanking |
| vtkUniformGridAMR | |
| vtkUniformGridAMRAlgorithm | |
| vtkUniformGridAMRDataIterator | Subclass of vtkCompositeDataIterator with API to get current level and dataset index |
| vtkUniformGridGhostDataGenerator | |
| vtkUniformGridPartitioner | |
| vtkUniformVariables | GLSL uniform variables |
| vtkUnsigned__Int64Array | Dynamic, self-adjusting array of unsigned __int64 |
| vtkUnsignedCharArray | Dynamic, self-adjusting array of unsigned char |
| vtkUnsignedIntArray | Dynamic, self-adjusting array of unsigned int |
| vtkUnsignedLongArray | Dynamic, self-adjusting array of unsigned long |
| vtkUnsignedLongLongArray | Dynamic, self-adjusting array of unsigned long long |
| vtkUnsignedShortArray | Dynamic, self-adjusting array of unsigned short |
| vtkUnstructuredGrid | Dataset represents arbitrary combinations of all possible cell types |
| vtkUnstructuredGridAlgorithm | Superclass for algorithms that produce only unstructured grid as output |
| vtkUnstructuredGridBunykRayCastFunction | Superclass for ray casting functions |
| vtkUnstructuredGridGeometryFilter | Extract geometry from an unstructured grid |
| vtkUnstructuredGridHomogeneousRayIntegrator | Performs peicewise constant ray integration |
| vtkUnstructuredGridLinearRayIntegrator | Performs piecewise linear ray integration |
| vtkUnstructuredGridPartialPreIntegration | Performs piecewise linear ray integration |
| vtkUnstructuredGridPreIntegration | Performs ray integration with pre-integration tables |
| vtkUnstructuredGridReader | Read vtk unstructured grid data file |
| vtkUnstructuredGridToReebGraphFilter | Generate a Reeb graph from a scalar field defined on a vtkUnstructuredGrid |
| vtkUnstructuredGridVolumeMapper | Abstract class for a unstructured grid volume mapper |
| vtkUnstructuredGridVolumeRayCastFunction | Superclass for ray casting functions |
| vtkUnstructuredGridVolumeRayCastIterator | |
| vtkUnstructuredGridVolumeRayCastMapper | A software mapper for unstructured volumes |
| vtkUnstructuredGridVolumeRayIntegrator | Superclass for volume ray integration functions |
| vtkUnstructuredGridVolumeZSweepMapper | Unstructured grid volume mapper based the ZSweep Algorithm |
| vtkUnstructuredGridWriter | Write vtk unstructured grid data file |
| vtkUTF16TextCodec | Class to read/write ascii text |
| vtkUTF8TextCodec | Class to read/write UTF-8 text |
| vtkVariant | A atomic type representing the union of many types |
| vtkVariantArray | An array holding vtkVariants |
| vtkVariantBoostSerialization | Serialization support for vtkVariant and vtkVariantArray using the Boost.Serialization library |
| vtkVariantCast | |
| vtkVariantCreate | |
| vtkVariantEqual | |
| vtkVariantExtract | |
| vtkVariantLessThan | |
| vtkVariantStrictEquality | |
| vtkVariantStrictWeakOrder | |
| vtkVector< T, Size > | Templated base type for storage of vectors |
| vtkVector2< T > | |
| vtkVector2d | |
| vtkVector2f | |
| vtkVector2i | |
| vtkVector3< T > | |
| vtkVector3d | |
| vtkVector3f | |
| vtkVector3i | |
| vtkVectorDot | Generate scalars from dot product of vectors and normals (e.g., show displacement plot) |
| vtkVectorNorm | Generate scalars from Euclidean norm of vectors |
| vtkVectorText | Create polygonal text |
| vtkVersion | Versioning class for vtk |
| vtkVertex | Cell that represents a 3D point |
| vtkVertexAdjacencyList | |
| vtkVertexDegree | Adds an attribute array with the degree of each vertex |
| boost::vtkVertexGlobalMap | |
| vtkVertexGlyphFilter | Make a vtkPolyData with a vertex on each point |
| vtkVertexListIterator | Iterates all vertices in a graph |
| boost::vtkVertexLocalMap | |
| boost::vtkVertexOwnerMap | |
| vtkVideoSource | Superclass of video input devices for VTK |
| vtkView | The superclass for all views |
| vtkViewDependentErrorMetric | Objects that compute a screen-based error during cell tessellation |
| vtkViewport | Abstract specification for Viewports |
| vtkViewTheme | Sets theme colors for a graphical view |
| vtkViewUpdater | Updates views automatically |
| vtkVisibilitySort | Abstract class that can sort cell data along a viewpoint |
| vtkVoidArray | Dynamic, self-adjusting array of void* pointers |
| vtkVolume | Volume (data & properties) in a rendered scene |
| vtkVolume16Reader | Read 16 bit image files |
| vtkVolumeCollection | List of volumes |
| 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) |
| vtkVolumeMapper | Abstract class for a volume mapper |
| vtkVolumeOutlineSource | Outline of volume cropping region |
| vtkVolumePicker | Ray-cast picker enhanced for volumes |
| vtkVolumeProperty | Common properties for rendering a volume |
| vtkVolumeRayCastCompositeFunction | Ray function for compositing |
| vtkVolumeRayCastDynamicInfo | |
| vtkVolumeRayCastFunction | Superclass for ray casting functions |
| vtkVolumeRayCastIsosurfaceFunction | An isosurface ray caster for volumes |
| vtkVolumeRayCastMapper | A slow but accurate mapper for rendering volumes |
| vtkVolumeRayCastMIPFunction | A maximum intensity projection ray caster for volumes |
| vtkVolumeRayCastSpaceLeapingImageFilter | Builds the space leaping data structure |
| vtkVolumeRayCastStaticInfo | |
| vtkVolumeReader | Read image files |
| vtkVolumeTextureMapper | Abstract class for a volume mapper |
| vtkVolumeTextureMapper2D | Abstract class for a volume mapper |
| vtkVolumeTextureMapper3D | Volume render with 3D texture mapping |
| vtkVolumetricPass | Render the volumetric geometry with property key filtering |
| vtkVoxel | Cell that represents a 3D orthogonal parallelepiped |
| vtkVoxelContoursToSurfaceFilter | Create surface from contours |
| vtkVoxelModeller | Convert an arbitrary dataset to a voxel representation |
| vtkVPICReader | Class for reading VPIC data files |
| vtkVRMLExporter | Export a scene into VRML 2.0 format |
| vtkVRMLImporter | Imports VRML 2.0 files |
| vtkWarpLens | Deform geometry by applying lens distortion |
| vtkWarpScalar | Deform geometry with scalar data |
| vtkWarpTo | Deform geometry by warping towards a point |
| vtkWarpTransform | Superclass for nonlinear geometric transformations |
| vtkWarpVector | Deform geometry with vector data |
| vtkWeakPointer< T > | Weak reference to a vtkObject |
| vtkWeakPointerBase | Non-templated superclass for vtkWeakPointer |
| vtkWedge | 3D cell that represents a linear wedge |
| vtkWeightedTransformFilter | Transform based on per-point or per-cell weighting functions |
| vtkWidgetCallbackMapper | Map widget events into callbacks |
| vtkWidgetEvent | Define widget events |
| vtkWidgetEventTranslator | Map VTK events into widget events |
| vtkWidgetRepresentation | Abstract class defines interface between the widget and widget representation classes |
| vtkWidgetSet | Synchronize a collection on vtkWidgets drawn on different renderwindows using the Callback - Dispatch Action mechanism |
| vtkWin32Header | Manage Windows system differences |
| vtkWin32OpenGLRenderWindow | OpenGL rendering window |
| vtkWin32OutputWindow | Win32 Specific output window class |
| vtkWin32ProcessOutputWindow | Win32-specific output window class |
| vtkWin32RenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| vtkWin32VideoSource | Video-for-Windows video digitizer |
| vtkWindBladeReader | Class for reading WindBlade data files |
| vtkWindow | Window superclass for vtkRenderWindow |
| vtkWindowedSincPolyDataFilter | Adjust point positions using a windowed sinc function interpolation kernel |
| vtkWindowLevelLookupTable | Map scalar values into colors or colors to scalars; generate color table |
| vtkWindowToImageFilter | Use a vtkWindow as input to image pipeline |
| vtkWorldPointPicker | Find world x,y,z corresponding to display x,y,z |
| vtkWriter | Abstract class to write data to file(s) |
| vtkX3DExporter | Create an x3d file |
| vtkX3DExporterFIWriter | |
| vtkX3DExporterFIWriterHelper | |
| vtkX3DExporterJavaHelper | Create an x3d file |
| vtkX3DExporterWriter | X3D Exporter Writer |
| vtkX3DExporterXMLWriter | X3D Exporter XML Writer |
| vtkXdmfArraySelection | |
| vtkXdmfDataArray | |
| vtkXdmfDocument | |
| vtkXdmfDomain | |
| vtkXdmfHeavyData | |
| vtkXdmfReader | Reads eXtensible Data Model and Format files |
| vtkXdmfReaderInternal | |
| vtkXdmfWriter | Write eXtensible Data Model and Format files |
| vtkXGMLReader | Reads XGML graph files. This reader is developed for a simple graph file format based loosely on the "GML" notation. This implementation is based heavily on the vtkTulipReader class that forms part of the Titan toolkit |
| vtkXGPUInfoList | Get GPUs VRAM information using X server extensions |
| vtkXMLCompositeDataReader | Reader for multi-group datasets |
| vtkXMLCompositeDataWriter | Writer for multi-group datasets |
| vtkXMLDataElement | Represents an XML element and those nested inside |
| vtkXMLDataHeader | |
| vtkXMLDataHeaderImpl< T > | |
| vtkXMLDataParser | Used by vtkXMLReader to parse VTK XML files |
| vtkXMLDataReader | Superclass for VTK XML file readers |
| vtkXMLDataSetWriter | Write any type of VTK XML file |
| vtkXMLFileOutputWindow | XML File Specific output window class |
| vtkXMLFileReadTester | Utility class for vtkXMLReader and subclasses |
| vtkXMLGenericDataObjectReader | Read any type of vtk data object |
| vtkXMLHierarchicalBoxDataFileConverter | Converts older *.vth, *.vthb files to newer format |
| vtkXMLHierarchicalBoxDataReader | Reader for hierarchical datasets (for backwards compatibility) |
| vtkXMLHierarchicalBoxDataWriter | Writer for vtkHierarchicalBoxDataSet for backwards compatibility |
| vtkXMLHierarchicalDataReader | Reader for hierarchical datasets |
| vtkXMLHyperOctreeReader | Read VTK XML HyperOctree files |
| vtkXMLHyperOctreeWriter | Write VTK XML HyperOctree files |
| vtkXMLImageDataReader | Read VTK XML ImageData files |
| vtkXMLImageDataWriter | Write VTK XML ImageData files |
| vtkXMLMaterial | Encapsulates a VTK Material description |
| vtkXMLMaterialParser | Parses VTK Material file |
| vtkXMLMaterialReader | Provide access to elements in Material files |
| vtkXMLMultiBlockDataReader | Reader for multi-block datasets |
| vtkXMLMultiBlockDataWriter | Writer for vtkMultiBlockDataSet |
| vtkXMLMultiGroupDataReader | Reader for multi-block datasets |
| vtkXMLParser | Parse XML to handle element tags and attributes |
| vtkXMLPDataReader | Superclass for PVTK XML file readers |
| vtkXMLPDataSetWriter | Write any type of PVTK XML file |
| vtkXMLPDataWriter | Write data in a parallel XML format |
| vtkXMLPHierarchicalBoxDataWriter | Parallel writer for vtkHierarchicalBoxDataSet for backwards compatibility |
| vtkXMLPImageDataReader | Read PVTK XML ImageData files |
| vtkXMLPImageDataWriter | Write PVTK XML ImageData files |
| vtkXMLPMultiBlockDataWriter | Parallel writer for vtkHierarchicalBoxDataSet |
| vtkXMLPolyDataReader | Read VTK XML PolyData files |
| vtkXMLPolyDataWriter | Write VTK XML PolyData files |
| vtkXMLPPolyDataReader | Read PVTK XML PolyData files |
| vtkXMLPPolyDataWriter | Write PVTK XML PolyData files |
| vtkXMLPRectilinearGridReader | Read PVTK XML RectilinearGrid files |
| vtkXMLPRectilinearGridWriter | Write PVTK XML RectilinearGrid files |
| vtkXMLPStructuredDataReader | Superclass for parallel structured data XML readers |
| vtkXMLPStructuredDataWriter | Superclass for PVTK XML structured data writers |
| vtkXMLPStructuredGridReader | Read PVTK XML StructuredGrid files |
| vtkXMLPStructuredGridWriter | Write PVTK XML StructuredGrid files |
| vtkXMLPUniformGridAMRWriter | Parallel writer for vtkUniformGridAMR and subclasses |
| vtkXMLPUnstructuredDataReader | Superclass for parallel unstructured data XML readers |
| vtkXMLPUnstructuredDataWriter | Superclass for PVTK XML unstructured data writers |
| vtkXMLPUnstructuredGridReader | Read PVTK XML UnstructuredGrid files |
| vtkXMLPUnstructuredGridWriter | Write PVTK XML UnstructuredGrid files |
| vtkXMLReader | Superclass for VTK's XML format readers |
| vtkXMLRectilinearGridReader | Read VTK XML RectilinearGrid files |
| vtkXMLRectilinearGridWriter | Write VTK XML RectilinearGrid files |
| vtkXMLShader | Encapsulates a Shader XML description |
| vtkXMLStructuredDataReader | Superclass for structured data XML readers |
| vtkXMLStructuredDataWriter | Superclass for VTK XML structured data writers |
| vtkXMLStructuredGridReader | Read VTK XML StructuredGrid files |
| vtkXMLStructuredGridWriter | Write VTK XML StructuredGrid files |
| vtkXMLTreeReader | Reads an XML file into a vtkTree |
| vtkXMLUniformGridAMRReader | Reader for amr datasets (vtkOverlappingAMR or vtkNonOverlappingAMR) |
| vtkXMLUniformGridAMRWriter | Writer for vtkUniformGridAMR |
| vtkXMLUnstructuredDataReader | Superclass for unstructured data XML readers |
| vtkXMLUnstructuredDataWriter | Superclass for VTK XML unstructured data writers |
| vtkXMLUnstructuredGridReader | Read VTK XML UnstructuredGrid files |
| vtkXMLUnstructuredGridWriter | Write VTK XML UnstructuredGrid files |
| vtkXMLUtilities | XML utilities |
| vtkXMLWriter | Superclass for VTK's XML file writers |
| vtkXOpenGLRenderWindow | OpenGL rendering window |
| vtkXRenderWindowInteractor | X event driven interface for a RenderWindow |
| vtkXRenderWindowTclInteractor | TCL event driven interface for a RenderWindow |
| vtkXYPlotActor | Generate an x-y plot from input dataset(s) or field data |
| vtkXYPlotRepresentation | Represent XY plot for vtkXYPlotWidget |
| vtkXYPlotWidget | 2D widget for manipulating a XY plot |
| vtkXYZMolReader | Read Molecular Data files |
| vtkYoungsMaterialInterface | Reconstructs material interfaces |
| vtkZLibDataCompressor | Data compression using zlib |
| X3DEncoderFunctions | |
