| CvtkKdTree::_cellList | |
| CActionFunction< TWidget > | |
| ►Cadjacency_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| CvtkAnimationCue::AnimationCueInfo | |
| CvtkTypeList::Append< TList, T > | Appends type T to TypeList TList and stores the result in Result |
| Cdax::cont::internal::ArrayContainerControl< DaxValueType, vtkToDax::vtkArrayContainerTag< VTKArrayType > > | |
| Cdax::cont::internal::ArrayContainerControl< ValueT, vtkToDax::vtkPointsContainerTag > | |
| Cdax::cont::internal::ArrayContainerControl< ValueT, vtkToDax::vtkTopologyContainerTag< CellType > > | |
| CADIOS::ArrayDim | |
| CvtkExodusIIReaderPrivate::ArrayInfoType | A struct to hold information about time-varying arrays |
| CArrayList | |
| ►CvtkStatisticsAlgorithm::AssessFunctor | A base class for a functor that assesses data |
| CvtkKMeansAssessFunctor | |
| CvtkMultiCorrelativeAssessFunctor | |
| CADIOS::Attribute | |
| ►CBaseArrayPair | |
| CArrayPair< T > | |
| CRealArrayPair< TInput, TOutput > | |
| ►CBaseFunctor | |
| ►CFunctor0Args< TReturn > | |
| CMemberFunction0Args< TObject, TReturn > | |
| CMemberFunction1Arg< TObject, TReturn, TArg1 > | |
| CMemberFunction2Args< TObject, TReturn, TArg1, TArg2 > | |
| CMemberFunction3Args< TObject, TReturn, TArg1, TArg2, TArg3 > | |
| ►CBaseT | |
| CvtkTypeTemplate< ThisT, BaseT > | Provides the equivalent of vtkTypeMacro for use with template classes |
| ►CvtkFieldData::BasicIterator | |
| CvtkFieldData::Iterator | |
| ►Cbidirectional_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| ►Cbinary_function | |
| CvtkPiston::minmax_binary_op< T > | |
| CvtkAMRDataInternals::Block | |
| CvtkExodusIIWriter::Block | |
| CvtkTemporalStreamTracer::bounds | |
| CBSPNode | |
| CvtkTextureImageCache< Key >::CacheData | |
| CvtkTypeList::CanConvert< From, To > | Sets member Result to true if a conversion exists to convert type From to type To |
| CvtkToDax::CellTypeAndDataType< DataSetType, CellType > | |
| CvtkToDax::CellTypeAndDataType< VTK_IMAGE_DATA, VTK_VOXEL > | |
| CvtkToDax::CellTypeAndDataType< VTK_STRUCTURED_GRID, VTK_HEXAHEDRON > | |
| CvtkToDax::CellTypeAndDataType< VTK_UNIFORM_GRID, VTK_VOXEL > | |
| CvtkToDax::CellTypeAndDataType< VTK_UNSTRUCTURED_GRID, VTK_HEXAHEDRON > | |
| CvtkToDax::CellTypeAndDataType< VTK_UNSTRUCTURED_GRID, VTK_LINE > | |
| CvtkToDax::CellTypeAndDataType< VTK_UNSTRUCTURED_GRID, VTK_QUAD > | |
| CvtkToDax::CellTypeAndDataType< VTK_UNSTRUCTURED_GRID, VTK_TETRA > | |
| CvtkToDax::CellTypeAndDataType< VTK_UNSTRUCTURED_GRID, VTK_TRIANGLE > | |
| CvtkToDax::CellTypeAndDataType< VTK_UNSTRUCTURED_GRID, VTK_WEDGE > | |
| CvtkDax::detail::CellTypeInDataSet | |
| CdaxToVtk::CellTypeToType< T > | |
| CvtkToDax::CellTypeToType< T > | |
| CdaxToVtk::CellTypeToType< dax::CellTagHexahedron > | |
| CdaxToVtk::CellTypeToType< dax::CellTagLine > | |
| CdaxToVtk::CellTypeToType< dax::CellTagQuadrilateral > | |
| CdaxToVtk::CellTypeToType< dax::CellTagTetrahedron > | |
| CdaxToVtk::CellTypeToType< dax::CellTagTriangle > | |
| CdaxToVtk::CellTypeToType< dax::CellTagVertex > | |
| CdaxToVtk::CellTypeToType< dax::CellTagVoxel > | |
| CdaxToVtk::CellTypeToType< dax::CellTagWedge > | |
| CvtkToDax::CellTypeToType< vtkHexahedron > | |
| CvtkToDax::CellTypeToType< vtkLine > | |
| CvtkToDax::CellTypeToType< vtkQuad > | |
| CvtkToDax::CellTypeToType< vtkTetra > | |
| CvtkToDax::CellTypeToType< vtkTriangle > | |
| CvtkToDax::CellTypeToType< vtkVertex > | |
| CvtkToDax::CellTypeToType< vtkVoxel > | |
| CvtkToDax::CellTypeToType< vtkWedge > | |
| CvtkShaderProgram::cmp_str | |
| CvtkToDax::CompactPointField< DispatcherType > | |
| CvtkDendrogramItem::CompareWeightedVertices | |
| Cvtk::atomic::detail::CompileTimeCheck< bool > | |
| Cvtk::atomic::detail::CompileTimeCheck< std::numeric_limits< T >::is_specialized &&std::numeric_limits< T >::is_integer &&(sizeof(T)==4||sizeof(T)==8)> | |
| Cvtk::atomic::detail::CompileTimeCheck< true > | |
| CvtkSplitField::Component | |
| CvtkMergeFields::Component | |
| CvtkUnicodeString::const_iterator | |
| CvtkToDax::Contour< FieldType_ > | |
| CvtkMaskFields::CopyFieldFlag | |
| CvtkFieldData::CopyFieldFlag | |
| ►CCWnd | |
| CvtkMFCWindow | Class to display a VTK window in an MFC window |
| CvtkAVSucdReader::DataInfo | |
| ►CDataSetsTypeBase | |
| CvtkCompositeInterpolatedVelocityFieldDataSetsType | |
| CvtkToDax::DataSetTypeToType< CellTypeToTypeDef, vtkDataSetType > | |
| CvtkToDax::DataSetTypeToType< CellTypeToTypeDef, vtkImageData > | |
| CvtkToDax::DataSetTypeToType< CellTypeToTypeDef, vtkUniformGrid > | |
| CvtkToDax::DataSetTypeToType< CellTypeToTypeDef, vtkUnstructuredGrid > | |
| CvtkTypeList::DerivedToFront< TList > | Sort the TypeList from most-derived to least-derived type, storing the sorted TypeList in Result |
| CvtkMultiBlockPLOT3DReaderInternals::Dims | |
| CvtkArrayDispatch::Dispatch2ByArray< ArrayList1, ArrayList2 > | Dispatch two arrays with the restriction that the type of the first array is in the ArrayList1 TypeList, and the second is in ArrayList2 |
| CvtkArrayDispatch::Dispatch2ByArrayWithSameValueType< ArrayList1, ArrayList2 > | Dispatch two arrays, restricting the valid code paths to use only array types specified in the ArrayList TypeList, additionally enforcing that all arrays must have the same ValueType |
| CvtkArrayDispatch::Dispatch2BySameValueType< ValueTypeList > | Dispatch two arrays, restricting the valid code paths to use only array types found in application-wide vtkArrayDispatch::Arrays TypeList that have a ValueType contained in the ValueTypeList TypeList |
| CvtkArrayDispatch::Dispatch2ByValueType< ValueTypeList1, ValueTypeList2 > | Dispatch two arrays, restricting the valid code paths to use ValueType-filtered versions of the application-wide vtkArrayDispatch::Arrays TypeList |
| CvtkArrayDispatch::Dispatch3ByArray< ArrayList1, ArrayList2, ArrayList3 > | Dispatch three arrays with the restriction that the type of the first array is in the ArrayList1 TypeList, the second is in ArrayList2, and the third is in ArrayList3 |
| CvtkArrayDispatch::Dispatch3ByArrayWithSameValueType< ArrayList1, ArrayList2, ArrayList3 > | Dispatch three arrays, restricting the valid code paths to use only array types specified in the ArrayList TypeList, additionally enforcing that all arrays must have the same ValueType |
| CvtkArrayDispatch::Dispatch3BySameValueType< ValueTypeList > | Dispatch three arrays, restricting the valid code paths to use only array types found in application-wide vtkArrayDispatch::Arrays TypeList that have a ValueType contained in the ValueTypeList TypeList |
| CvtkArrayDispatch::Dispatch3ByValueType< ValueTypeList1, ValueTypeList2, ValueTypeList3 > | Dispatch three arrays, restricting the valid code paths to use ValueType-filtered versions of the application-wide vtkArrayDispatch::Arrays TypeList |
| CvtkArrayDispatch::DispatchByArray< ArrayList > | Dispatch a single array against all array types mentioned in the ArrayList template parameter |
| CvtkArrayDispatch::DispatchByValueType< ValueTypeList > | Dispatch a single array against all array types in the application-wide vtkArrayDispatch::Arrays list with the added restriction that the array must have a type that appears the ValueTypeList TypeList |
| CvtkToDax::DoContour< B > | |
| CvtkToDax::DoContour< 1 > | |
| CvtkToDax::DoThreshold< B > | |
| CvtkToDax::DoThreshold< 1 > | |
| CvtkDispatcherCommon::DynamicCaster< To, From > | |
| ►Cboost::edge_bundle_type< vtkGraph * > | |
| ►Cboost::edge_bundle_type< vtkDirectedGraph * > | |
| Cboost::edge_bundle_type< vtkMutableDirectedGraph * > | |
| Cboost::edge_bundle_type< vtkMutableDirectedGraph *const > | |
| Cboost::edge_bundle_type< vtkDirectedGraph *const > | |
| ►Cboost::edge_bundle_type< vtkUndirectedGraph * > | |
| Cboost::edge_bundle_type< vtkMutableUndirectedGraph * > | |
| Cboost::edge_bundle_type< vtkMutableUndirectedGraph *const > | |
| Cboost::edge_bundle_type< vtkUndirectedGraph *const > | |
| ►Cedge_list_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| Cboost::edge_property< vtkGraph * > | |
| ►Cboost::edge_property_type< vtkGraph * > | |
| ►Cboost::edge_property_type< vtkDirectedGraph * > | |
| Cboost::edge_property_type< vtkMutableDirectedGraph * > | |
| Cboost::edge_property_type< vtkMutableDirectedGraph *const > | |
| Cboost::edge_property_type< vtkDirectedGraph *const > | |
| ►Cboost::edge_property_type< vtkUndirectedGraph * > | |
| Cboost::edge_property_type< vtkMutableUndirectedGraph * > | |
| Cboost::edge_property_type< vtkMutableUndirectedGraph *const > | |
| Cboost::edge_property_type< vtkUndirectedGraph *const > | |
| CvtkSLACReader::EdgeEndpoints | Simple class used internally to define an edge based on the endpoints |
| CvtkGenericEdgeTable::EdgeEntry | |
| CvtkOStreamWrapper::EndlType | Type for a fake endl |
| CvtkTypeList::Erase< TList, T > | Erase the first element of type T from TypeList TList, storing the new list in Result |
| CvtkTypeList::EraseAll< TList, T > | Erase all type T from TypeList TList, storing the new list in Result |
| CvtkQuadricDecimation::ErrorQuadric | |
| CvtkVRMLYaccData::FakeAlloca | |
| CvtkDataSetAttributes::FieldList | |
| CVrmlNodeType::FieldRec | |
| CvtkToDax::FieldTypeToType< VTKArrayType, NUM_COMP > | |
| CvtkToDax::FieldTypeToType< vtkUnsignedCharArray, 1 > | |
| CvtkToDax::FieldTypeToType< vtkUnsignedCharArray, NUM_COMP > | |
| CvtkArrayDispatch::FilterArraysByValueType< ArrayList, ValueList > | Filter the ArrayList to contain only arrays with ArrayType::ValueType that exist in ValueList |
| CvtkX3DExporterFIWriterHelper::float_to_unsigned_int_to_bytes | |
| CvtkOculusRenderWindow::FramebufferDesc | |
| CvtkOpenVRRenderWindow::FramebufferDesc | |
| CvtkDispatcherPrivate::Functor< R, Parm1 > | |
| CvtkDoubleDispatcherPrivate::Functor< R, Parm1, Parm2 > | |
| CvtkDispatcherPrivate::FunctorDispatcherHelper< BaseLhs, SomeLhs, RT, CastLhs, Fun > | |
| CvtkDoubleDispatcherPrivate::FunctorDoubleDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, RT, CastLhs, CastRhs, Fun > | |
| CvtkDispatcherPrivate::FunctorImpl< R, P1 > | |
| CvtkDoubleDispatcherPrivate::FunctorImpl< R, P1, P2 > | |
| CvtkDispatcherPrivate::FunctorRefDispatcherHelper< BaseLhs, SomeLhs, RT, CastLhs, Fun > | |
| CvtkDoubleDispatcherPrivate::FunctorRefDispatcherHelper< BaseLhs, BaseRhs, SomeLhs, SomeRhs, RT, CastLhs, CastRhs, Fun > | |
| Cglobal | |
| ►Cboost::graph_traits< vtkGraph * > | |
| ►Cboost::graph_traits< vtkDirectedGraph * > | |
| Cboost::graph_traits< const vtkDirectedGraph * > | |
| Cboost::graph_traits< vtkDirectedGraph *const > | |
| ►Cboost::graph_traits< vtkMutableDirectedGraph * > | |
| Cboost::graph_traits< const vtkMutableDirectedGraph * > | |
| Cboost::graph_traits< vtkMutableDirectedGraph *const > | |
| ►Cboost::graph_traits< vtkTree * > | |
| Cboost::graph_traits< const vtkTree * > | |
| Cboost::graph_traits< vtkTree *const > | |
| ►Cboost::graph_traits< vtkUndirectedGraph * > | |
| Cboost::graph_traits< const vtkUndirectedGraph * > | |
| ►Cboost::graph_traits< vtkMutableUndirectedGraph * > | |
| Cboost::graph_traits< const vtkMutableUndirectedGraph * > | |
| Cboost::graph_traits< vtkMutableUndirectedGraph *const > | |
| Cboost::graph_traits< vtkUndirectedGraph *const > | |
| Cboost::hash< vtkEdgeType > | |
| CvtkInformationInternals::HashFun | |
| ►CvtkToDax::internal::IdType< NUM_COMP > | |
| CvtkToDax::FieldTypeToType< vtkIdTypeArray, NUM_COMP > | |
| CvtkToDax::FieldTypeToType< vtkIntArray, NUM_COMP > | |
| CvtkToDax::internal::IdType< 1 > | |
| ►CImpl | |
| CvtkDispatcherPrivate::FunctorHandler< ParentFunctor, Fun > | |
| CvtkDoubleDispatcherPrivate::FunctorHandler< ParentFunctor, Fun > | |
| CvtkLabelHierarchy::Implementation | |
| CvtkTypeList::IndexOf< TList, T > | Sets the enum value Result to the index of type T in the TypeList TList |
| CvtkSMPMergePolyDataHelper::InputData | This is the data structure needed by the MergePolyData function |
| Cvtk::atomic::detail::IntegralType< T > | |
| CvtkMultiBlockPLOT3DReaderInternals::InternalSettings | |
| CvtkUnstructuredGridBunykRayCastFunction::Intersection | |
| CvtkGenericStreamTracer::IntervalInformation | |
| CvtkStreamTracer::IntervalInformation | |
| CvtkPriorityQueue::Item | |
| CvtkSMPThreadLocalObject< T >::iterator | Subset of the standard iterator API |
| ►Citerator_facade | |
| Cboost::vtk_edge_iterator | |
| Cboost::vtk_in_edge_pointer_iterator | |
| Cboost::vtk_out_edge_pointer_iterator | |
| Cboost::vtk_vertex_iterator | |
| CIVFDataSetInfo | |
| CvtkParallelRenderManager::LightInfo | |
| CvtkCellLinks::Link | |
| CvtkDecimatePro::LocalTri | |
| CvtkDecimatePro::LocalVertex | |
| CvtkParallelTimer::LogBodyType | Type used to direct an output stream into the log's body |
| CvtkParallelTimer::LogHeaderType | Type used to direct an output stream into the log's header |
| CLSDynaFamily | |
| CLSDynaFamily::LSDynaFamilyAdaptLevel | |
| CLSDynaFamily::LSDynaFamilySectionMark | |
| CLSDynaMetaData | |
| ►Cmap | |
| CvtkXdmf3ArrayKeeper | LRU cache of XDMF Arrays |
| CvtkXdmf3ArraySelection | Helper to identify requested arrays with |
| CvtkXdmfArraySelection | |
| ►CvtkDenseArray< T >::MemoryBlock | Strategy object that contains a block of memory to be used by vtkDenseArray for value storage |
| CvtkDenseArray< T >::HeapMemoryBlock | MemoryBlock implementation that manages internally-allocated memory using new[] and delete[] |
| CvtkDenseArray< T >::StaticMemoryBlock | MemoryBlock implementation that manages a static (will not be freed) memory block |
| CvtkTextRenderer::Metrics | |
| CvtkSLACReader::MidpointCoordinateMap | Manages a map from edges to midpoint coordinates |
| CvtkSLACReader::MidpointCoordinates | Simple class used internally for holding midpoint information |
| CvtkSLACReader::MidpointIdMap | Manages a map from edges to the point id of the midpoint |
| CvtkPiston::minmax_pair< T > | |
| CvtkTypeList::MostDerived< TList, T > | Given a type T and a TypeList TList, store the most derived type of T in TList as Result |
| CvtkChart::MouseActions | Hold mouse action mappings |
| CvtkChart::MouseClickActions | |
| ►Cmultiset | |
| CvtkLabelHierarchy::Implementation::LabelSet | |
| CVrmlNodeType::NameTypeRec | |
| Cnifti_1_header | Data structure defining the fields in the nifti1 header. This binary header should be found at the beginning of a valid NIFTI-1 header file |
| Cnifti_2_header | Data structure defining the fields in the nifti2 header. This binary header should be found at the beginning of a valid NIFTI-2 header file |
| CvtkSmartPointerBase::NoReference | |
| CvtkWeakPointerBase::NoReference | |
| CvtkMultiThreshold::NormKey | A class with comparison operator used to index input array norms used in threshold rules |
| ►CNSView | |
| CvtkCocoaGLView | Cocoa OpenGL rendering context |
| CvtkCocoaGLView | Cocoa OpenGL rendering context |
| CvtkTypeList::NullType | Used to terminate a TypeList |
| ►CvtkExodusIIReaderPrivate::ObjectInfoType | A struct to hold information about Exodus objects (blocks, sets, maps) |
| CvtkExodusIIReaderPrivate::AssemblyInfoType | |
| ►CvtkExodusIIReaderPrivate::BlockSetInfoType | A struct to hold information about Exodus blocks or sets (they have some members in common) |
| CvtkExodusIIReaderPrivate::BlockInfoType | A struct to hold information about Exodus blocks |
| CvtkExodusIIReaderPrivate::SetInfoType | A struct to hold information about Exodus sets |
| CvtkExodusIIReaderPrivate::MapInfoType | A struct to hold information about Exodus maps |
| CvtkExodusIIReaderPrivate::MaterialInfoType | |
| CvtkExodusIIReaderPrivate::PartInfoType | A struct to hold information about Exodus blocks |
| COffsetsManager | Helper class due to PIMPL excess |
| COffsetsManagerArray | |
| COffsetsManagerGroup | |
| CvtkCommunicator::Operation | A custom operation to use in a reduce command |
| CvtkRearrangeFields::Operation | |
| CvtkTextCodec::OutputIterator | Base class that any output iterators need to derive from to use the first signature of to_unicode |
| CvtkObjectFactory::OverrideInformation | |
| ►Cpair | |
| CvtkTextureImageCache< Key >::CacheElement | CacheElement associates a unique key to some cache |
| CvtkTextureImageCache< Key >::CacheElement | CacheElement associates a unique key to some cache |
| CvtkParticleTracerBaseNamespace::ParticleInformation | |
| CvtkTemporalStreamTracerNamespace::ParticleInformation | |
| CParticlePathFilterInternal | |
| CvtkHardwareSelector::PixelInformation | Struct used to return information about a pixel location |
| CvtkGenericEdgeTable::PointEntry | |
| CvtkQuadricClustering::PointQuadric | |
| CvtkParticleTracerBaseNamespace::Position | |
| CvtkTemporalStreamTracerNamespace::Position | |
| CvtkLabelHierarchy::Implementation::PriorityComparator | |
| CvtkOpenGLContextDevice2D::Private | |
| ►Cboost::graph::parallel::process_group_type< vtkGraph * > | |
| ►Cboost::graph::parallel::process_group_type< vtkDirectedGraph * > | |
| Cboost::graph::parallel::process_group_type< vtkDirectedGraph *const > | |
| ►Cboost::graph::parallel::process_group_type< vtkUndirectedGraph * > | |
| Cboost::graph::parallel::process_group_type< vtkUndirectedGraph *const > | |
| Cboost::property_map< vtkGraph *, edge_global_t > | |
| ►Cboost::property_map< vtkGraph *, edge_index_t > | |
| ►Cboost::property_map< vtkDirectedGraph *, edge_index_t > | |
| Cboost::property_map< vtkDirectedGraph *const, edge_index_t > | |
| ►Cboost::property_map< vtkUndirectedGraph *, edge_index_t > | |
| Cboost::property_map< vtkUndirectedGraph *const, edge_index_t > | |
| Cboost::property_map< vtkGraph *, vertex_global_t > | |
| ►Cboost::property_map< vtkGraph *, vertex_index_t > | |
| ►Cboost::property_map< vtkDirectedGraph *, vertex_index_t > | |
| Cboost::property_map< vtkDirectedGraph *const, vertex_index_t > | |
| ►Cboost::property_map< vtkUndirectedGraph *, vertex_index_t > | |
| Cboost::property_map< vtkUndirectedGraph *const, vertex_index_t > | |
| Cboost::property_map< vtkGraph *, vertex_local_t > | |
| Cboost::property_map< vtkGraph *, vertex_owner_t > | |
| Cboost::property_traits< typename > | |
| Cboost::property_traits< vtkAbstractArray * > | |
| Cboost::property_traits< vtkDataArray * > | |
| Cboost::property_traits< vtkEdgeGlobalMap > | |
| Cboost::property_traits< vtkGraphEdgeMap > | |
| Cboost::property_traits< vtkGraphIndexMap > | |
| Cboost::property_traits< vtkVertexGlobalMap > | |
| Cboost::property_traits< vtkVertexLocalMap > | |
| Cboost::property_traits< vtkVertexOwnerMap > | |
| ►CQAbstractItemModel | |
| ►CvtkQtAbstractModelAdapter | Superclass for Qt model adapters |
| CvtkQtAnnotationLayersModelAdapter | Adapts annotations to a Qt item model |
| CvtkQtTableModelAdapter | Adapts a table to a Qt item model |
| CvtkQtTreeModelAdapter | Adapts a tree to a Qt item model |
| ►CQApplication | |
| CQVTKApplication | |
| ►CQDesignerCustomWidgetCollectionInterface | |
| CQVTKPlugin | |
| ►CQDesignerCustomWidgetInterface | |
| CQVTKWidgetPlugin | |
| ►CQGLWidget | |
| CQVTKWidget2 | QVTKWidget2 displays a VTK window in a Qt window |
| ►CQGraphicsWidget | |
| CQVTKGraphicsItem | |
| ►CQMainWindow | |
| CQTestMainWindow | |
| ►CQObject | |
| CQVTKInteractorAdapter | |
| CQVTKInteractorInternal | |
| CQVTKPlugin | |
| CvtkQtConnection | |
| ►CvtkQtView | Superclass for Qt widget-based views |
| CvtkQtAnnotationView | A VTK view that displays the annotations on its annotation link |
| CvtkQtListView | A VTK view based on a Qt List view |
| CvtkQtRecordView | Superclass for QAbstractItemView-based views |
| CvtkQtRichTextView | Superclass for QAbstractItemView-based views |
| CvtkQtTableView | A VTK view based on a Qt Table view |
| CvtkQtTreeView | A VTK view based on a Qt tree view |
| CvtkTDxQtUnixDevices | Manage a list vtkTDXUnixDevice(s) |
| ►CQPaintEngine | |
| CQVTKPaintEngine | A paint engine class to direct QPainter calls into a VTK window |
| ►CQSortFilterProxyModel | |
| CQFilterTreeProxyModel | |
| ►CQStandardItemModel | |
| CReferenceCountModel | |
| CvtkQtDebugLeaksModel | Model class that observes the vtkDebugLeaks singleton |
| CQTestApp | |
| ►CQWidget | |
| CQVTKWidget | QVTKWidget displays a VTK window in a Qt window |
| CQVTKWidget | QVTKWidget displays a VTK window in a Qt window |
| CvtkQtDebugLeaksView | View class to display contents of vtkQtDebugLeaksModel |
| CADIOS::Reader | |
| CvtkPParticleTracerBase::RemoteParticleInfo | |
| Cdetail::remove_const< T > | |
| Cdetail::remove_const< const T > | |
| CvtkCompositeSurfaceLICMapper::RenderBlockState | |
| CvtkCompositePainter::RenderBlockState | |
| CvtkCompositePolyDataMapper2::RenderBlockState | |
| CvtkOSPRayCompositePolyDataMapper2Node::RenderBlockState | |
| CvtkParallelRenderManager::RendererInfo | |
| CvtkSynchronizedRenderers::RendererInfo | |
| CvtkParallelRenderManager::RenderWindowInfo | |
| CvtkSynchronizedRenderWindows::RenderWindowInfo | |
| CvtkTypeList::Replace< TList, Bad, Good > | Replace the first instance of Bad with Good in the TypeList TList, storing the new list in Result |
| CvtkTypeList::ReplaceAll< TList, Bad, Good > | Replace all instances of Bad with Good in the TypeList TList, storing the new list in Result |
| CvtkOpenGLPolyDataMapper::ReplacementSpec | |
| CvtkOpenGLPolyDataMapper::ReplacementValue | |
| CvtkMPICommunicator::Request | |
| ►Cruntime_error | |
| CADIOS::ReadError | |
| CADIOS::WriteError | |
| ►CvtkToDax::internal::ScalarType< NUM_COMP > | |
| CvtkToDax::FieldTypeToType< vtkDoubleArray, NUM_COMP > | |
| CvtkToDax::FieldTypeToType< vtkFloatArray, NUM_COMP > | |
| CvtkToDax::internal::ScalarType< 1 > | |
| CvtkTypeList::Select< Exp, T, F > | Sets Result to T if Exp is true, or F if Exp is false |
| ►CvtkMultiThreshold::Set | A base class for representing threshold sets |
| CvtkMultiThreshold::BooleanSet | A subset of a mesh represented as a boolean set operation |
| CvtkMultiThreshold::Interval | A subset of a mesh represented by a range of acceptable attribute values |
| CADIOS::VarInfo::StepBlock | |
| CStreaklineFilterInternal | |
| CvtkStreamer::StreamArray | |
| CvtkStreamer::StreamPoint | |
| ►Cstring | |
| CvtkStdString | Wrapper around std::string to keep symbols short |
| CtagBlock | |
| CtagFlashReaderDoubleScalar | |
| CtagFlashReaderIntegerScalar | |
| CtagFlashReaderSimulationInformation | |
| CtagFlashReaderSimulationParameters | |
| CTest | Tests instantiations of the vtkNew class template |
| CTextPropertyKey< StringType > | |
| CvtkMultiThreader::ThreadInfo | |
| CvtkToDax::Threshold< FieldType_ > | |
| CvtkUnstructuredGridBunykRayCastFunction::Triangle | |
| CvtkDecimatePro::TriArray | |
| CvtkDispatcherCommon::TypeInfo | |
| CvtkTypeList::TypeList< T, U > | Generic implementation of TypeList |
| ►Cunary_function | |
| Cvtkpiston::float4tofloat3 | |
| CvtkPiston::minmax_unary_op< T > | |
| Cvtkpiston::tuple2float3 | |
| CvtkTypeList::Unique< TList > | Remove all duplicate types from TypeList TList, storing the new list in Result |
| CvtkDax::detail::ValidContourInput | |
| CvtkDax::detail::ValidThresholdInput | |
| CvtkExodusIIWriter::VariableInfo | |
| ►CADIOS::VarInfo | |
| CADIOS::Scalar | |
| CvtkTransformFeedback::VaryingMetaData | |
| ►Cvector | |
| CIVFCacheList | |
| CvtkContextScenePrivate | Private implementation for scene/items |
| CvtkDataObjectTreeIndex | |
| CvtkSmartVector< T > | A vector of smart pointers |
| CvtkSmartVector< vtkTextActor > | |
| ►Cboost::vertex_bundle_type< vtkGraph * > | |
| ►Cboost::vertex_bundle_type< vtkDirectedGraph * > | |
| Cboost::vertex_bundle_type< vtkMutableDirectedGraph * > | |
| Cboost::vertex_bundle_type< vtkMutableDirectedGraph *const > | |
| Cboost::vertex_bundle_type< vtkDirectedGraph *const > | |
| ►Cboost::vertex_bundle_type< vtkUndirectedGraph * > | |
| Cboost::vertex_bundle_type< vtkMutableUndirectedGraph * > | |
| Cboost::vertex_bundle_type< vtkMutableUndirectedGraph *const > | |
| Cboost::vertex_bundle_type< vtkUndirectedGraph *const > | |
| ►Cvertex_list_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| Cboost::vertex_property< vtkGraph * > | |
| ►Cboost::vertex_property_type< vtkGraph * > | |
| ►Cboost::vertex_property_type< vtkDirectedGraph * > | |
| Cboost::vertex_property_type< vtkMutableDirectedGraph * > | |
| Cboost::vertex_property_type< vtkMutableDirectedGraph *const > | |
| Cboost::vertex_property_type< vtkDirectedGraph *const > | |
| ►Cboost::vertex_property_type< vtkUndirectedGraph * > | |
| Cboost::vertex_property_type< vtkMutableUndirectedGraph * > | |
| Cboost::vertex_property_type< vtkMutableUndirectedGraph *const > | |
| Cboost::vertex_property_type< vtkUndirectedGraph *const > | |
| CvtkDecimatePro::VertexArray | |
| CvtkView::ViewProgressEventCallData | A ptr to an instance of ViewProgressEventCallData is provided in the call data when vtkCommand::ViewProgressEvent is fired |
| CVrmlNodeType | |
| Cvtk2DHistogramItem | 2D histogram item |
| CVTK_ASSUME | Provide compiler hints for non-obvious conditions |
| Cvtkpiston::vtk_polydata | |
| CvtkABI | Manage macros for exporting symbols in the binary interface |
| CvtkADIOSDirTree | A directory tree structure holding ADIOS data |
| CvtkToDax::vtkAlloc< _T, NUM_COMPONENTS > | |
| CvtkToDax::vtkAlloc< vtkCellArray, NUM_COMPONENTS > | |
| CvtkToDax::vtkAlloc< vtkPoints, NUM_COMPONENTS > | |
| CvtkAMRBox | Encloses a rectangular region of voxel like cells |
| CvtkAMREnzoReaderInternal | Consists of the low-level Enzo Reader used by the vtkAMREnzoReader |
| CvtkAMRFlashReaderInternal | Consists of the low-level Flash Reader used by the vtkAMRFlashReader |
| CvtkToDax::vtkArrayContainerTag< VTKArrayType > | |
| CvtkArrayCoordinates | Stores coordinate into an N-way array |
| CvtkArrayDispatch | VtkDataArray code generator/dispatcher |
| CvtkArrayDownCast_impl< ArrayT > | Implementation of vtkArrayDownCast |
| CvtkArrayExtents | Stores the number of dimensions and valid coordinate ranges along each dimension for vtkArray |
| CvtkArrayExtentsList | Stores a collection of vtkArrayExtents objects |
| CvtkArrayInterpolate | Computes the weighted sum of a collection of slices from a source array, and stores the results in a slice of a target array |
| CvtkArrayIteratorIncludes | Centralize array iterator type includes required when using the vtkArrayIteratorTemplateMacro |
| CvtkArrayListTemplate | Thread-safe and efficient data attribute manipulation |
| CvtkToDax::vtkArrayPortal< DaxValueType, VTKComponentType > | |
| CvtkArrayPrint | Print arrays in different formats |
| CvtkArrayRange | Stores a half-open range of array coordinates |
| CvtkArraySort | Controls sorting of sparse array coordinates |
| CvtkArrayWeights | Stores a collection of weighting factors |
| CvtkAtom | Convenience proxy for vtkMolecule |
| CvtkBlockDistribution | A helper class that manages a block distribution of N elements of data |
| CvtkBond | Convenience proxy for vtkMolecule |
| CvtkBoundingBox | Fast Simple Class for dealing with 3D bounds |
| CvtkBreakPoint | Utility function to debug with gdb and MPI |
| CvtkDispatcherCommon::vtkCaster< To, From > | |
| CvtkCellTreeLocator::vtkCellTree | Internal classes made public to allow subclasses to create customized some traversal algorithms |
| CvtkCellTreeLocator::vtkCellTreeNode | This class is the basic building block of the cell tree |
| CvtkCellType | Define types of cells |
| CvtkChart2DHistogram | Chart for 2D histograms |
| CvtkChartBoxData | Small struct used by InvokeEvent to send some information about the point that was clicked on |
| CvtkChartPlotData | Small struct used by InvokeEvent to send some information about the point that was clicked on |
| CvtkChartSelectionHelper | Helper functions for making selections in charts |
| CvtkCocoaMacOSXSDKCompatibility | Compatibility header |
| CvtkCollectionElement | |
| CvtkColor | Templated type for storage of colors |
| CvtkCommonInformationKeyManager | Manages key types in vtkCommon |
| CvtkContextKeyEvent | Data structure to represent key events |
| CvtkContextMouseEvent | Data structure to represent mouse events |
| CvtkContextPolygon | |
| CvtkContourHelper | A utility class used by various contour filters |
| CvtkContourRepresentationInternals | |
| CvtkContourRepresentationNode | |
| CvtkContourRepresentationPoint | |
| CvtkCPExodusIIElementBlock | Uses an Exodus II element block as a vtkMappedUnstructuredGrid's implementation |
| CvtkDataArrayAccessor< ArrayT > | Efficient templated access to vtkDataArray |
| CvtkDataArrayAccessor< vtkDataArray > | |
| CvtkDataArrayDispatcher< DefaultFunctorType, ReturnType > | Dispatch to functor vtkDataArrayType |
| CvtkDataArrayDispatcherPointer< T > | |
| CvtkDataArrayIteratorMacro | A macro for obtaining iterators to vtkDataArray data when the array implementation and type are unknown |
| CvtkDataObjectTreeInternals | |
| CvtkDataObjectTreeItem | |
| CvtkDebugLeaksManager | Manages the vtkDebugLeaks singleton |
| CvtkDebugLeaksObserver | |
| CvtkNetCDFCFReader::vtkDependentDimensionInfo | |
| CvtkDescriptiveStatisticsGnu | A class for univariate descriptive statistics using R to calculate p-values |
| CvtkDijkstraGraphInternals | Helper class due to PIMPL excess |
| CvtkNetCDFCFReader::vtkDimensionInfo | |
| CvtkDispatcher< BaseLhs, ReturnType, CastingPolicy > | Dispatch to functor based on a pointer type |
| CvtkDistributedEdgePropertyMapType< DataArray > | Retrieves the type of the distributed property map indexed by the edges of a distributed graph |
| CvtkDistributedVertexPropertyMapType< DataArray > | Retrieves the type of the distributed property map indexed by the vertices of a distributed graph |
| CvtkDoubleDispatcher< BaseLhs, BaseRhs, ReturnType, CastingPolicy > | Dispatch to functor based on two pointer types |
| ►CvtkEdgeBase | |
| CvtkEdgeType | |
| CvtkInEdgeType | |
| CvtkOutEdgeType | |
| Cboost::vtkEdgeGlobalMap | |
| CvtkEnzoReaderBlock | |
| CvtkEnzoReaderInternal | |
| CvtkErrorCode | Superclass for error codes |
| CvtkExodusIICacheEntry | |
| CvtkExodusIICacheKey | |
| ►CvtkExodusIIReaderVariableCheck | Abstract base class for glomming arrays of variable names |
| CvtkExodusIIReaderIntPointCheck | This looks for integration-point variables whose names contain an element shape and digits specifying an integration point |
| CvtkExodusIIReaderScalarCheck | This always accepts a single array name as a scalar. It is the fallback for all other checkers |
| CvtkExodusIIReaderTensorCheck | This looks for symmetric tensors of a given rank and dimension |
| CvtkExodusIIReaderVectorCheck | This looks for n-D vectors whose names are identical except for a single final character |
| CvtkFastGeomQuadStruct | |
| CvtkFilteringInformationKeyManager | Manages key types in vtkFiltering |
| CvtkFixedSizeHandleRepresentation | A marker that has the same size in pixels |
| CvtkFlashReaderInternal | |
| CvtkFloatingPointExceptions | Deal with floating-point exceptions |
| CvtkFreeTypeToolsCleanup | |
| CvtkGarbageCollectorManager | Manages the vtkGarbageCollector singleton |
| CvtkGenericDataArrayLookupHelper< ArrayTypeT > | Internal class used by vtkGenericDataArray to support LookupValue |
| CvtkGenericDataArrayLookupHelper< vtkGenericDataArray > | |
| ►CvtkGenericOpenGLResourceFreeCallback | |
| CvtkOpenGLResourceFreeCallback< T > | |
| CvtkgluPickMatrix | Implement selected glu functionality |
| CvtkGPUInfoListArray | Internal class vtkGPUInfoList |
| Cboost::vtkGraphEdgeMap | |
| Cboost::vtkGraphEdgePropertyMapHelper< PMap > | |
| Cboost::vtkGraphIndexMap | |
| Cboost::vtkGraphPropertyMapMultiplier< PMap > | |
| CvtkHyperOctreeLightWeightCursor | |
| CvtkHyperTreeGrid::vtkHyperTreeGridSuperCursor | |
| CvtkHyperTreeGrid::vtkHyperTreeIterator | |
| CvtkHyperTreeGrid::vtkHyperTreeSimpleCursor | |
| CvtkImage2DIslandPixel | |
| CvtkImageBSplineInternals | BSpline code from P |
| CvtkImageComplex | |
| CvtkImageConnectorSeed | |
| ►CvtkImageIterator< DType > | Simple image iterator |
| CvtkImageProgressIterator< DType > | Simple image iterator with progress |
| ►CvtkImagePointDataIterator | Iterate over point data in an image |
| CvtkImagePointIterator | Iterate over all data points in an image |
| CvtkImageStencilIterator< DType > | Image region iterator |
| CvtkImageStencilRaster | This is a helper class for stencil creation |
| CvtkIndent | Simple class to control print indentation |
| CvtkInformationInternals | Internal structure for vtkInformation |
| CvtkInstantiatorInitialize | |
| ►CvtkInterpolationInfo | |
| CvtkInterpolationWeights | |
| CvtkInterpolationMath | |
| CvtkInterpolatorInternals | Internals for vtkImageInterpolator |
| CvtkIOStream | Include C++ iostreams as used by VTK |
| CvtkIOStreamFwd | Forward-declare C++ iostreams as used by VTK |
| CvtkLargeInteger | Class for arbitrarily large ints |
| CvtkLegacyReaderVersion | Version number for legacy readers/writers |
| CvtkLICNoiseHelper | A small collection of noise routines for LIC |
| CvtkLICRandomNoise2D | 2D Noise Generator |
| CvtkLICRandomNumberGeneratorInterface | An interface to a random number generator |
| CvtkLODProp3DEntry | |
| CvtkMapMaskTextureId | |
| CvtkMarchingCubesTriangleCases | |
| CvtkMarchingSquaresLineCases | |
| CvtkMathTextUtilitiesCleanup | |
| CvtkMathUtilities | Templated utility math functions intended for internal use in tests etc |
| CvtkMPIPixelTT< T > | |
| CvtkMPIPixelView | MPI datatypes that describe a vtkPixelExtent |
| CvtkMultiBlockPLOT3DReaderInternals | |
| CvtkMultiBlockPLOT3DReaderRecord | |
| CvtkMultiProcessStream | Stream used to pass data across processes using vtkMultiProcessController |
| CvtkMySQLDatabasePrivate | |
| CvtkNew< T > | Allocate and hold a VTK object |
| CvtkNew< vtkAbstractInteractionDevice > | |
| CvtkNew< vtkAbstractRenderDevice > | |
| CvtkNew< vtkActor > | |
| CvtkNew< vtkAxis > | |
| CvtkNew< vtkBlueObeliskData > | |
| CvtkNew< vtkBrush > | |
| CvtkNew< vtkCallbackCommand > | |
| CvtkNew< vtkCamera > | |
| CvtkNew< vtkCategoryLegend > | |
| CvtkNew< vtkColorLegend > | |
| CvtkNew< vtkCompositeDataProbeFilter > | |
| CvtkNew< vtkContext2D > | |
| CvtkNew< vtkContext3D > | |
| CvtkNew< vtkContextClip > | |
| CvtkNew< vtkContextTransform > | |
| CvtkNew< vtkDataSetCollection > | |
| CvtkNew< vtkFloatArray > | |
| CvtkNew< vtkGenericCell > | |
| CvtkNew< vtkGlyph3DMapper > | |
| CvtkNew< vtkGraphLayout > | |
| CvtkNew< vtkIdList > | |
| CvtkNew< vtkImageData > | |
| CvtkNew< vtkIncrementalForceLayout > | |
| CvtkNew< vtkInformation > | |
| CvtkNew< vtkLookupTable > | |
| CvtkNew< vtkMatrix4x4 > | |
| CvtkNew< vtkMultiBlockDataSet > | |
| CvtkNew< vtkOpenGLSphereMapper > | |
| CvtkNew< vtkOpenGLStickMapper > | |
| CvtkNew< vtkPen > | |
| CvtkNew< vtkPeriodicTable > | |
| CvtkNew< vtkPlaneCollection > | |
| CvtkNew< vtkPlotGrid > | |
| CvtkNew< vtkPlotLine > | |
| CvtkNew< vtkPointData > | |
| CvtkNew< vtkPoints > | |
| CvtkNew< vtkPoints2D > | |
| CvtkNew< vtkPolyData > | |
| CvtkNew< vtkPolyDataMapper > | |
| CvtkNew< vtkPolyDataMapper2D > | |
| CvtkNew< vtkPruneTreeFilter > | |
| CvtkNew< vtkStringArray > | |
| CvtkNew< vtkTextProperty > | |
| CvtkNew< vtkTextRenderer > | |
| CvtkNew< vtkTexture > | |
| CvtkNew< vtkTooltipItem > | |
| CvtkNew< vtkTransform > | |
| CvtkNew< vtkTrivialProducer > | |
| CvtkNew< vtkUnsignedCharArray > | |
| CvtkNew< vtkUnsignedShortArray > | |
| CvtkNew< vtkVariantArray > | |
| CvtkOBBNode | |
| ►CvtkObjectBase | Abstract base class for most VTK objects |
| ►CvtkCommand | Superclass for callback/observer methods |
| CvtkCallbackCommand | Supports function callbacks |
| CvtkEventForwarderCommand | Simple event forwarder command |
| CvtkOldStyleCallbackCommand | Supports legacy function callbacks for VTK |
| ►CvtkInformationKey | Superclass for vtkInformation keys |
| ►CvtkInformationDataObjectKey | Key for vtkDataObject values |
| CvtkInformationDataObjectMetaDataKey | Key used to define meta-data of type vtkDataObject vtkInformationDataObjectMetaDataKey is a vtkInformationDataObjectKey that (shallow) copies itself downstream during the REQUEST_INFORMATION pass |
| CvtkInformationDoubleKey | Key for double values in vtkInformation |
| CvtkInformationDoubleVectorKey | Key for double vector values |
| CvtkInformationExecutivePortKey | Key for vtkExecutive/Port value pairs |
| CvtkInformationExecutivePortVectorKey | Key for vtkExecutive/Port value pair vectors |
| CvtkInformationIdTypeKey | Key for vtkIdType values in vtkInformation |
| CvtkInformationInformationKey | Key for vtkInformation values |
| CvtkInformationInformationVectorKey | Key for vtkInformation vectors |
| ►CvtkInformationIntegerKey | Key for integer values in vtkInformation |
| CvtkInformationIntegerRequestKey | Key that can used to request integer values from the pipeline vtkInformationIntegerRequestKey is a vtkInformationIntegerKey that can used to request integer values from upstream |
| CvtkInformationIntegerPointerKey | Key for pointer to integer |
| CvtkInformationIntegerVectorKey | Key for integer vector values |
| CvtkInformationKeyVectorKey | Key for vector-of-keys values |
| CvtkInformationObjectBaseKey | Key for vtkObjectBase values |
| CvtkInformationObjectBaseVectorKey | Key for vtkObjectBase vector values |
| CvtkInformationQuadratureSchemeDefinitionVectorKey | Key for vtkQuadratureSchemeDefinition vector values |
| CvtkInformationRequestKey | Key for pointer to pointer |
| CvtkInformationStringKey | Key for string values in vtkInformation |
| CvtkInformationStringVectorKey | Key for String vector values |
| CvtkInformationUnsignedLongKey | Key for unsigned long values in vtkInformation |
| CvtkInformationVariantKey | Key for variant values in vtkInformation |
| CvtkInformationVariantVectorKey | Key for variant vector values |
| ►CvtkObject | Abstract base class for most VTK objects |
| CExternalVTKWidget | |
| ►CvtkAbstractArray | Abstract superclass for all arrays |
| ►CvtkDataArray | Abstract superclass for arrays of numeric data |
| CvtkBitArray | Dynamic, self-adjusting array of bits |
| CvtkCharArray | Dynamic, self-adjusting array of char |
| CvtkDoubleArray | Dynamic, self-adjusting array of double |
| CvtkFloatArray | Dynamic, self-adjusting array of float |
| CvtkGenericDataArray< DerivedT, ValueTypeT > | Base interface for all typed vtkDataArray subclasses |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< Scalar >, Scalar > | |
| CvtkAOSDataArrayTemplate< Scalar > | |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< ValueType >, ValueType > | |
| ►CvtkAOSDataArrayTemplate< ValueType > | |
| CvtkDataArrayTemplate< ValueType > | VtkDataArrayTemplate is deprecated, use vtkAOSDataArrayTemplate instead |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< ValueTypeT >, ValueTypeT > | |
| CvtkAOSDataArrayTemplate< ValueTypeT > | Array-Of-Structs implementation of vtkGenericDataArray |
| ►CvtkGenericDataArray< vtkPeriodicDataArray< Scalar >, Scalar > | |
| ►CvtkPeriodicDataArray< Scalar > | Map native an Array into an angulat periodic array |
| CvtkAngularPeriodicDataArray< Scalar > | Map native an Array into an angulat periodic array |
| ►CvtkGenericDataArray< vtkSOADataArrayTemplate< ValueTypeT >, ValueTypeT > | |
| CvtkSOADataArrayTemplate< ValueTypeT > | Struct-Of-Arrays implementation of vtkGenericDataArray |
| ►CvtkGenericDataArray< vtkTestDataArray< ArrayT >, ArrayT::ValueType > | |
| CvtkTestDataArray< ArrayT > | An implementation of vtkGenericDataArray for testing fallback algorithms |
| ►CvtkGenericDataArray< vtkTypedDataArray< Scalar >, Scalar > | |
| ►CvtkTypedDataArray< Scalar > | Extend vtkDataArray with abstract type-specific API |
| ►CvtkMappedDataArray< Scalar > | Map non-contiguous data structures into the vtkDataArray API |
| CvtkCPExodusIINodalCoordinatesTemplate< Scalar > | Map native Exodus II coordinate arrays into the vtkDataArray interface |
| CvtkCPExodusIIResultsArrayTemplate< Scalar > | Map native Exodus II results arrays into the vtkDataArray interface |
| CvtkIdTypeArray | Dynamic, self-adjusting array of vtkIdType |
| CvtkIntArray | Dynamic, self-adjusting array of int |
| CvtkLongArray | Dynamic, self-adjusting array of long |
| CvtkLongLongArray | Dynamic, self-adjusting array of long long |
| CvtkShortArray | Dynamic, self-adjusting array of short |
| CvtkSignedCharArray | Dynamic, self-adjusting array of signed char |
| CvtkUnsignedCharArray | Dynamic, self-adjusting array of unsigned char |
| CvtkUnsignedIntArray | Dynamic, self-adjusting array of unsigned int |
| CvtkUnsignedLongArray | Dynamic, self-adjusting array of unsigned long |
| CvtkUnsignedLongLongArray | Dynamic, self-adjusting array of unsigned long long |
| CvtkUnsignedShortArray | Dynamic, self-adjusting array of unsigned short |
| CvtkStringArray | VtkAbstractArray subclass for strings |
| CvtkUnicodeStringArray | Subclass of vtkAbstractArray that holds vtkUnicodeStrings |
| CvtkVariantArray | An array holding vtkVariants |
| ►CvtkAbstractCellLinks | Abstract base class for classes that build topological links from points to cells |
| CvtkCellLinks | Object represents upward pointers from points to list of cells using each point |
| CvtkStaticCellLinks | Object represents upward pointers from points to list of cells using each point |
| ►CvtkAbstractContextBufferId | 2D array of ids, used for picking |
| CvtkOpenGLContextBufferId | 2D array of ids stored in VRAM |
| CvtkOpenGLContextBufferId | 2D array of ids stored in VRAM |
| ►CvtkAbstractContextItem | Base class for items that are part of a vtkContextScene |
| ►CvtkChartMatrix | Container for a matrix of charts |
| CvtkScatterPlotMatrix | Container for a matrix of charts |
| CvtkContextArea | Clipped, transformed area with axes for context items |
| CvtkContextClip | All children of this item are clipped by the specified area |
| ►CvtkContextItem | Base class for items that are part of a vtkContextScene |
| CvtkAxis | Takes care of drawing 2D axes |
| CvtkBlockItem | VtkContextItem that draws a block (optional label) |
| ►CvtkChart | Factory class for drawing 2D charts |
| CvtkChartBox | Factory class for drawing box plot charts |
| CvtkChartParallelCoordinates | Factory class for drawing 2D charts |
| CvtkChartPie | Factory class for drawing pie charts |
| ►CvtkChartXY | Factory class for drawing XY charts |
| CvtkChartHistogram2D | |
| ►CvtkChartLegend | Draw the chart legend |
| CvtkCategoryLegend | Legend item to display categorical data |
| CvtkColorLegend | Legend item to display vtkScalarsToColors |
| CvtkChartXYZ | Factory class for drawing 3D XYZ charts |
| CvtkDendrogramItem | A 2D graphics item for rendering a tree as a dendrogram |
| CvtkGraphItem | A 2D graphics item for rendering a graph |
| CvtkHeatmapItem | A 2D graphics item for rendering a heatmap |
| CvtkImageItem | VtkContextItem that draws a supplied image in the scene |
| CvtkPiecewisePointHandleItem | VtkContextItem that draws handles around a point of a piecewise function |
| ►CvtkPlot | Abstract class for 2D plots |
| ►CvtkControlPointsItem | Abstract class for control points items |
| ►CvtkColorTransferControlPointsItem | Control points for vtkColorTransferFunction |
| CvtkCompositeControlPointsItem | Control points for vtkCompositeFunction |
| CvtkPiecewiseControlPointsItem | Control points for vtkPiecewiseFunction |
| CvtkPlotArea | Draws an area plot |
| CvtkPlotBar | Class for drawing an XY plot given two columns from a vtkTable |
| CvtkPlotBox | Class for drawing box plots |
| CvtkPlotFunctionalBag | Class for drawing an XY line plot or bag given two columns from a vtkTable |
| CvtkPlotHistogram2D | |
| CvtkPlotParallelCoordinates | Class for drawing a parallel coordinate plot given columns from a vtkTable |
| CvtkPlotPie | Class for drawing a Pie diagram |
| ►CvtkPlotPoints | Class for drawing an points given two columns from a vtkTable |
| CvtkPlotBag | Class for drawing an a bagplot |
| CvtkPlotLine | Class for drawing an XY line plot given two columns from a vtkTable |
| CvtkPlotStacked | Class for drawing an stacked polygon plot given an X, Ybase, Yextent in a vtkTable |
| ►CvtkScalarsToColorsItem | Abstract class for ScalarsToColors items |
| ►CvtkColorTransferFunctionItem | |
| CvtkCompositeTransferFunctionItem | |
| CvtkLookupTableItem | |
| CvtkPiecewiseFunctionItem | VtkPiecewiseFunctionItem internall uses vtkPlot::Color, white by default |
| ►CvtkPlot3D | Abstract class for 3D plots |
| ►CvtkPlotPoints3D | 3D scatter plot |
| CvtkPlotLine3D | Class for drawing an XYZ line plot given three columns from a vtkTable |
| CvtkPlotSurface | 3D surface plot |
| CvtkPlotGrid | Takes care of drawing the plot grid |
| CvtkTanglegramItem | Display two related trees |
| CvtkTooltipItem | Takes care of drawing 2D axes |
| CvtkTreeHeatmapItem | A 2D graphics item for rendering a tree and an associated heatmap |
| CvtkContextTransform | All children of this item are transformed by the vtkTransform2D of this item |
| ►CvtkPropItem | Embed a vtkProp in a vtkContextScene |
| CvtkOpenGLPropItem | Sync Context2D state with vtk camera |
| CvtkOpenGLPropItem | Sync Context2D state with vtk camera |
| ►CvtkAbstractGridConnectivity | A superclass that defines the interface to be implemented by all concrete grid connectivity classes |
| CvtkStructuredAMRGridConnectivity | Grid connectivity |
| ►CvtkStructuredGridConnectivity | VtkStructuredGridConnectivity is a concrete instance of vtkObject that implements functionality for computing the neighboring topology within a single partitioned structured grid dataset |
| CvtkPStructuredGridConnectivity | VtkPStructuredGridConnectivity inherits from vtkStructuredGridConnectivity and implements functionality to compute the neighboring topology within a single, partitioned and distributed structured grid dataset |
| ►CvtkAbstractImageInterpolator | Interpolate data values from images |
| CvtkImageBSplineInterpolator | Perform b-spline interpolation on images |
| CvtkImageInterpolator | Interpolate data values from images |
| CvtkImageSincInterpolator | Perform sinc interpolation on images |
| CvtkAbstractInteractionDevice | |
| ►CvtkAbstractPicker | Define API for picking subclasses |
| ►CvtkAbstractPropPicker | Abstract API for pickers that can pick an instance of vtkProp |
| ►CvtkAreaPicker | Picks props behind a selection rectangle on a viewport |
| CvtkRenderedAreaPicker | Uses graphics hardware to picks props behind a selection rectangle on a viewport |
| ►CvtkPicker | Superclass for 3D geometric pickers (uses ray cast) |
| ►CvtkCellPicker | Ray-cast cell picker for all kinds of Prop3Ds |
| CvtkVolumePicker | Ray-cast picker enhanced for volumes |
| CvtkPointPicker | Select a point by shooting a ray into a graphics window |
| CvtkResliceCursorPicker | Ray-cast cell picker for the reslice cursor |
| CvtkPropPicker | Pick an actor/prop using graphics hardware |
| CvtkPropPicker3D | Pick an actor/prop given XYZ coordinates |
| CvtkWorldPointPicker | Find world x,y,z corresponding to display x,y,z |
| CvtkAbstractRenderDevice | |
| ►CvtkAbstractTransform | Superclass for all geometric transformations |
| CvtkGeneralTransform | Allows operations on any transforms |
| CvtkGeoSphereTransform | A transformation between long-lat-alt and rect coords |
| CvtkGeoTransform | A transformation between two geographic coordinate systems |
| ►CvtkHomogeneousTransform | Superclass for homogeneous transformations |
| ►CvtkLinearTransform | Abstract superclass for linear transformations |
| CvtkIdentityTransform | Transform that doesn't do anything |
| CvtkIterativeClosestPointTransform | Implementation of the ICP algorithm |
| CvtkLandmarkTransform | Linear transform specified by two corresponding point sets |
| CvtkMatrixToLinearTransform | Convert a matrix to a transform |
| ►CvtkTransform | Describes linear transformations via a 4x4 matrix |
| CvtkSMPTransform | Transform that uses the SMP framework |
| CvtkMatrixToHomogeneousTransform | Convert a matrix to a transform |
| CvtkPerspectiveTransform | Describes a 4x4 matrix transformation |
| ►CvtkWarpTransform | Superclass for nonlinear geometric transformations |
| CvtkBSplineTransform | Cubic b-spline deformation transformation |
| CvtkCylindricalTransform | Cylindrical to rectangular coords and back |
| CvtkGridTransform | Nonlinear warp transformation |
| CvtkSphericalTransform | Spherical to rectangular coords and back |
| CvtkThinPlateSplineTransform | Nonlinear warp transformation |
| CvtkAdjacentVertexIterator | Iterates through adjacent vertices in a graph |
| ►CvtkAlgorithm | Superclass for all sources, filters, and sinks in VTK |
| ►CvtkAbstractMapper | Abstract class specifies interface to map data |
| ►CvtkAbstractMapper3D | Abstract class specifies interface to map 3D data |
| ►CvtkAbstractVolumeMapper | Abstract class for a volume mapper |
| ►CvtkUnstructuredGridVolumeMapper | Abstract class for a unstructured grid volume mapper |
| ►CvtkHAVSVolumeMapper | Hardware-Assisted Visibility Sorting unstructured grid mapper |
| CvtkOpenGLHAVSVolumeMapper | Hardware-Assisted Visibility Sorting unstructured grid mapper, OpenGL implementation |
| ►CvtkProjectedAAHexahedraMapper | Volume mapper for axis-aligned hexahedra |
| CvtkOpenGLProjectedAAHexahedraMapper | OpenGL implementation of a volume mapper for axis-aligned hexahedra |
| ►CvtkProjectedTetrahedraMapper | Unstructured grid volume renderer |
| CvtkOpenGLProjectedTetrahedraMapper | OpenGL implementation of PT |
| CvtkOpenGLProjectedTetrahedraMapper | OpenGL implementation of PT |
| CvtkUnstructuredGridVolumeRayCastMapper | A software mapper for unstructured volumes |
| CvtkUnstructuredGridVolumeZSweepMapper | Unstructured grid volume mapper based the ZSweep Algorithm |
| ►CvtkVolumeMapper | Abstract class for a volume mapper |
| CvtkAMRVolumeMapper | AMR class for a volume mapper |
| CvtkFixedPointVolumeRayCastMapper | A fixed point mapper for volumes |
| ►CvtkGPUVolumeRayCastMapper | Ray casting performed on the GPU |
| CvtkOpenGLGPUVolumeRayCastMapper | OpenGL subclass that draws the image to the screen |
| CvtkOpenGLGPUVolumeRayCastMapper | OpenGL subclass that draws the image to the screen |
| ►CvtkOSPRayVolumeInterface | Removes link dependence on optional ospray module |
| CvtkOSPRayVolumeMapper | Standalone OSPRayVolumeMapper |
| CvtkSmartVolumeMapper | Adaptive volume mapper |
| CvtkSmartVolumeMapper | Adaptive volume mapper |
| CvtkVolumeRayCastMapper | A slow but accurate mapper for rendering volumes |
| ►CvtkVolumeTextureMapper | Abstract class for a volume mapper |
| ►CvtkVolumeTextureMapper2D | Abstract class for a volume mapper |
| CvtkOpenGLVolumeTextureMapper2D | Abstract class for a volume mapper |
| ►CvtkVolumeTextureMapper3D | Volume render with 3D texture mapping |
| CvtkOpenGLVolumeTextureMapper3D | Concrete implementation of 3D volume texture mapping |
| ►CvtkImageMapper3D | Abstract class for mapping images to the screen |
| CvtkImageResliceMapper | Map a slice of a vtkImageData to the screen |
| ►CvtkImageSliceMapper | Map a slice of a vtkImageData to the screen |
| CvtkOpenGLImageSliceMapper | OpenGL mapper for image slice display |
| CvtkOpenGLImageSliceMapper | OpenGL mapper for image slice display |
| ►CvtkMapper | Abstract class specifies interface to map data to graphics primitives |
| ►CvtkCompositePolyDataMapper | Class that renders hierarchical polygonal data |
| CvtkHierarchicalPolyDataMapper | Class that renders hierarchical polygonal data |
| CvtkDataSetMapper | Map vtkDataSet and derived classes to graphics primitives |
| ►CvtkGlyph3DMapper | VtkGlyph3D on the GPU |
| CvtkOpenGLGlyph3DMapper | VtkOpenGLGlyph3D on the GPU |
| CvtkOpenGLGlyph3DMapper | VtkOpenGLGlyph3D on the GPU |
| CvtkGraphMapper | Map vtkGraph and derived classes to graphics primitives |
| ►CvtkLabeledContourMapper | Draw labeled isolines |
| CvtkOpenGLLabeledContourMapper | VtkOpenGLLabeledContourMapper is an override for vtkLabeledContourMapper that implements stenciling using the OpenGL API |
| CvtkOpenGLLabeledContourMapper | VtkOpenGLLabeledContourMapper is an override for vtkLabeledContourMapper that implements stenciling using the OpenGL API |
| ►CvtkMoleculeMapper | Mapper that draws vtkMolecule objects |
| CvtkOpenGLMoleculeMapper | An accelerated class for rendering molecules |
| CvtkPistonMapper | Draws vtkPistonDataObjects to the screen |
| ►CvtkPolyDataMapper | Map vtkPolyData to graphics primitives |
| ►CvtkOpenGLPolyDataMapper | PolyDataMapper for the OpenGL library |
| CvtkCompositePolyDataMapper2 | Mapper for composite dataset consisting of polygonal data |
| CvtkOpenGLGlyph3DHelper | PolyDataMapper using OpenGL to render |
| CvtkOpenGLSphereMapper | Draw spheres using imposters |
| CvtkOpenGLStickMapper | Use imposters to draw cylinders |
| ►CvtkSurfaceLICMapper | Mapper that performs LIC on the surface of arbitrary geometry |
| CvtkCompositeSurfaceLICMapper | Mapper for composite dataset |
| CvtkOpenGLPolyDataMapper | PolyDataMapper for the OpenGL library |
| ►CvtkPainterPolyDataMapper | PolyDataMapper using painters |
| CvtkCompositePolyDataMapper2 | Mapper for composite dataset consisting of polygonal data |
| ►CvtkPointGaussianMapper | Draw PointGaussians using imposters |
| CvtkOpenGLPointGaussianMapper | Draw PointGaussians using imposters |
| ►CvtkMapper2D | Abstract class specifies interface for objects which render 2D actors |
| ►CvtkImageMapper | 2D image display |
| CvtkOpenGLImageMapper | 2D image display support for OpenGL |
| CvtkOpenGLImageMapper | 2D image display support for OpenGL |
| ►CvtkLabeledDataMapper | Draw text labels at dataset points |
| CvtkDynamic2DLabelMapper | Draw text labels at 2D dataset points |
| CvtkLabeledTreeMapDataMapper | Draw text labels on a tree map |
| CvtkQtTreeRingLabelMapper | Draw text labels on a tree map |
| CvtkLabelPlacementMapper | Places and renders non-overlapping labels |
| ►CvtkPolyDataMapper2D | Draw vtkPolyData onto the image plane |
| CvtkOpenGLPolyDataMapper2D | 2D PolyData support for OpenGL |
| CvtkOpenGLPolyDataMapper2D | 2D PolyData support for OpenGL |
| ►CvtkTextMapper | 2D text annotation |
| CvtkOpenGLTextMapper | VtkTextMapper override for OpenGL2 |
| ►CvtkAnnotationLayersAlgorithm | Superclass for algorithms that produce only vtkAnnotationLayers as output |
| CvtkAnnotationLink | An algorithm for linking annotations among objects |
| ►CvtkArrayDataAlgorithm | Superclass for algorithms that produce vtkArrayDatas as output |
| CvtkArrayDataReader | Reads vtkArrayData written by vtkArrayDataWriter |
| CvtkArrayNorm | Computes L-norms along one dimension of an array |
| CvtkArrayReader | Reads sparse and dense vtkArray data written by vtkArrayWriter |
| CvtkBoostLogWeighting | Given an arbitrary-dimension array of doubles, replaces each value x with one of: |
| CvtkBoostRandomSparseArraySource | Generates a sparse N-way array containing random values |
| CvtkDiagonalMatrixSource | Generates a sparse or dense square matrix with user-specified values for the diagonal, superdiagonal, and subdiagonal |
| CvtkExtractArray | Given a vtkArrayData object containing one-or-more vtkArray instances, produces a vtkArrayData containing just one vtkArray, indentified by index |
| CvtkMatricizeArray | Convert an array of arbitrary dimensions to a matrix |
| CvtkNormalizeMatrixVectors | 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) |
| CvtkTableToArray | Converts a vtkTable to a matrix |
| CvtkTableToSparseArray | Converts a vtkTable into a sparse array |
| CvtkTransposeMatrix | Computes the transpose of an input matrix |
| ►CvtkCompositeDataSetAlgorithm | Superclass for algorithms that produce only vtkCompositeDataSet as output |
| CvtkAppendCompositeDataLeaves | Appends one or more composite datasets with the same structure together into a single output composite dataset |
| CvtkExtractPiece | VtkExtractPiece returns the appropriate piece of each sub-dataset in the vtkCompositeDataSet |
| CvtkContextMapper2D | Abstract class for 2D context mappers |
| ►CvtkDataObjectAlgorithm | Superclass for algorithms that produce only data object as output |
| CvtkADIOSReader | Read ADIOS files |
| CvtkADIOSWriter | Write ADIOS files |
| CvtkAreaContourSpectrumFilter | Compute an approximation of the area contour signature (evolution of the area of the input surface along an arc of the Reeb graph) |
| CvtkDataObjectGenerator | Produces simple (composite or atomic) data sets for testing |
| CvtkDataSetToDataObjectFilter | Map dataset into data object (i.e., a field) |
| CvtkDistributedDataFilter | Distribute data among processors |
| ►CvtkExtractSelectionBase | Abstract base class for all extract selection filters |
| CvtkExtractSelectedBlock | |
| CvtkExtractSelectedFrustum | Returns the portion of the input dataset that lies within a selection frustum |
| CvtkExtractSelectedIds | Extract a list of cells from a dataset |
| CvtkExtractSelectedLocations | Extract cells within a dataset that contain the locations listen in the vtkSelection |
| CvtkExtractSelectedThresholds | Extract a cells or points from a dataset that have values within a set of thresholds |
| CvtkExtractSelection | Extract a subset from a vtkDataSet |
| CvtkProbeSelectedLocations | Similar to vtkExtractSelectedLocations except that it interpolates the point attributes at the probe locations |
| CvtkExtractTemporalFieldData | Extract temporal arrays from input field data |
| CvtkGenerateIndexArray | Generates a new vtkIdTypeArray containing zero-base indices |
| CvtkImageDataToUniformGrid | Convert vtkImageData to vtkUniformGrid |
| CvtkMatlabEngineFilter | This VTK uses the vtkMatlabEngineInterface class to perform calculations on VTK array input using the Matlab Engine |
| ►CvtkNetCDFReader | A superclass for reading netCDF files |
| CvtkNetCDFCFReader | Reads netCDF files that follow the CF convention |
| CvtkPassArrays | Passes a subset of arrays to the output |
| CvtkProgrammableDataObjectSource | Generate source data object via a user-specified function |
| CvtkRCalculatorFilter | This class functions as an array calculator for vtkDataArrays and VTKarray objects, using GNU R as the calculation engine |
| CvtkReebGraphSurfaceSkeletonFilter | Compute a skeletal embedding of the Reeb graph of a scalar field defined on a triangulated surface (vtkPolyData) |
| CvtkReebGraphVolumeSkeletonFilter | Compute a skeletal embedding of the Reeb graph of a scalar field defined on a tetrahedral mesh (vtkUnstructuredGrid) |
| ►CvtkReflectionFilter | Reflects a data set across a plane |
| CvtkPReflectionFilter | Parallel version of vtkReflectionFilter |
| CvtkStringToCategory | Creates a category array from a string array |
| CvtkStringToNumeric | Converts string arrays to numeric arrays |
| CvtkVolumeContourSpectrumFilter | Compute an approximation of the volume contour signature (evolution of the volume of the input tet-mesh along an arc of the Reeb graph) |
| CvtkXdmf3Writer | Write eXtensible Data Model and Format files |
| CvtkXdmfWriter | Write eXtensible Data Model and Format files |
| ►CvtkDataReader | Helper superclass for objects that read vtk data files |
| CvtkCompositeDataReader | Read vtkCompositeDataSet data file |
| CvtkDataObjectReader | Read vtk field data file |
| CvtkDataSetReader | Class to read any type of vtk dataset |
| CvtkGenericDataObjectReader | Class to read any type of vtk data object |
| CvtkGraphReader | Read vtkGraph data file |
| CvtkMultiNewickTreeReader | Read multiple vtkTrees from Newick formatted file |
| CvtkNewickTreeReader | Read vtkTree from Newick formatted file |
| CvtkOpenQubeMoleculeSource | Read a OpenQube readable file and output a vtkMolecule object |
| CvtkPolyDataReader | Read vtk polygonal data file |
| CvtkRectilinearGridReader | Read vtk rectilinear grid data file |
| CvtkStructuredGridReader | Read vtk structured grid data file |
| CvtkStructuredPointsReader | Read vtk structured points data file |
| ►CvtkTableReader | Read vtkTable data file |
| CvtkBiomTableReader | Read vtkTable from a .biom input file |
| CvtkTreeReader | Read vtkTree data file |
| CvtkUnstructuredGridReader | Read vtk unstructured grid data file |
| CvtkXdmf3Reader | Reads eXtensible Data Model and Format files |
| CvtkXdmfReader | Reads eXtensible Data Model and Format files |
| ►CvtkDataSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| CvtkArrayCalculator | Perform mathematical operations on data in field data arrays |
| CvtkAttributeDataToFieldDataFilter | Map attribute data to field data |
| CvtkBinCellDataFilter | Bin source cell data into input cells |
| CvtkBrownianPoints | Assign random vector to points |
| CvtkCastToConcrete | Works around type-checking limitations |
| ►CvtkCellDataToPointData | Map cell data to point data |
| CvtkPCellDataToPointData | Compute point arrays from cell arrays |
| CvtkCellDerivatives | Compute derivatives of scalars and vectors |
| CvtkCellQuality | Calculate functions of quality of the elements of a mesh |
| CvtkDataObjectToDataSetFilter | Map field data to concrete dataset |
| CvtkDataSetGradient | Computes scalar field gradient |
| CvtkDataSetGradientPrecompute | Computes a geometry based vector field that the DataSetGradient filter uses to accelerate gradient computation |
| ►CvtkDicer | Abstract superclass to divide dataset into pieces |
| CvtkOBBDicer | Divide dataset into spatially aggregated pieces |
| CvtkElevationFilter | Generate scalars along a specified direction |
| CvtkExtractTensorComponents | Extract parts of tensor and create a scalar, vector, normal, or texture coordinates |
| CvtkExtractVectorComponents | Extract components of vector as separate scalars |
| CvtkFieldDataToAttributeDataFilter | Map field data to dataset attribute data |
| CvtkGenericProbeFilter | Sample data values at specified point locations |
| CvtkGradientFilter | A general filter for gradient estimation |
| CvtkHyperOctreeDepth | Assign tree depth attribute to each cell |
| CvtkHyperOctreeLimiter | Limit the tree's depth, averaging data from lower level branches into the new leaves at the cut points |
| CvtkIdFilter | Generate scalars or field data from point and cell ids |
| CvtkImplicitTextureCoords | Generate 1D, 2D, or 3D texture coordinates based on implicit function(s) |
| CvtkInterpolateDataSetAttributes | Interpolate scalars, vectors, etc |
| CvtkMaskFields | Allow control of which fields get passed to the output |
| CvtkMatrixMathFilter | Calculate functions of quality of the elements of a mesh |
| CvtkMergeDataObjectFilter | Merge dataset and data object field to create dataset with attribute data |
| CvtkMergeFields | Merge multiple fields into one |
| CvtkMergeFilter | Extract separate components of data from different datasets |
| CvtkMeshQuality | Calculate functions of quality of the elements of a mesh |
| CvtkPassThroughFilter | Filter which shallow copies it's input to it's output |
| CvtkPDataSetReader | Manages reading pieces of a data set |
| CvtkPieceScalars | Sets all cell scalars from the update piece |
| CvtkPointConnectivityFilter | Output a scalar field indicating point connectivity |
| CvtkPointDataToCellData | Map point data to cell data |
| ►CvtkPointInterpolator | Interpolate over point cloud using various kernels |
| CvtkPointInterpolator2D | Interpolate point cloud attribute data onto x-y plane using various kernels |
| ►CvtkProbeFilter | Sample data values at specified point locations |
| ►CvtkCompositeDataProbeFilter | Subclass of vtkProbeFilter which supports composite datasets in the input |
| CvtkPProbeFilter | Probe dataset in parallel |
| CvtkProbePolyhedron | Probe/interpolate data values in the interior, exterior or of the surface of a closed, manifold polyhedron |
| CvtkProcessIdScalars | Sets cell or point scalars to the processor rank |
| CvtkProgrammableAttributeDataFilter | Manipulate attribute (cell and point) data via a user-specified function |
| CvtkProgrammableSource | Generate source dataset via a user-specified function |
| CvtkProjectedTexture | Assign texture coordinates for a projected texture |
| CvtkQuadraturePointInterpolator | Interpolates each scalar/vector field in a vtkUnstrcturedGrid on its input to a specific set of quadrature points |
| CvtkQuadratureSchemeDictionaryGenerator | Given an unstructured grid on its input this filter generates for each data array in point data dictionary (ie an instance of vtkInformationQuadratureSchemeDefinitionVectorKey) |
| CvtkRearrangeFields | Move/copy fields between field data, point data and cell data |
| CvtkSampleImplicitFunctionFilter | Sample an implicit function over a dataset, generating scalar values and optional gradient vectors |
| CvtkSelectEnclosedPoints | Mark points as to whether they are inside a closed surface |
| CvtkSimpleElevationFilter | Generate scalars along a specified direction |
| CvtkSPHInterpolator | Interpolate over point cloud using SPH kernels |
| CvtkSplitField | Split a field into single component fields |
| CvtkTextureMapToCylinder | Generate texture coordinates by mapping points to cylinder |
| CvtkTextureMapToPlane | Generate texture coordinates by mapping points to plane |
| CvtkTextureMapToSphere | Generate texture coordinates by mapping points to sphere |
| CvtkThresholdTextureCoords | Compute 1D, 2D, or 3D texture coordinates based on scalar threshold |
| CvtkTransformTextureCoords | Transform (scale, rotate, translate) texture coordinates |
| ►CvtkTransmitStructuredDataPiece | |
| CvtkTransmitImageDataPiece | |
| CvtkTransmitRectilinearGridPiece | Redistributes data produced by serial readers |
| CvtkTransmitStructuredGridPiece | |
| CvtkVectorDot | Generate scalars from dot product of vectors and normals (e.g., show displacement plot) |
| CvtkVectorNorm | Generate scalars from Euclidean norm of vectors |
| ►CvtkDirectedGraphAlgorithm | Superclass for algorithms that produce only directed graph as output |
| CvtkBoostDividedEdgeBundling | Layout graph edges in directed edge bundles |
| CvtkPipelineGraphSource | Graph constructed from a VTK pipeline |
| CvtkPolyDataToReebGraphFilter | Generate a Reeb graph from a scalar field defined on a vtkPolyData |
| CvtkReebGraphSimplificationFilter | Simplify an input Reeb graph |
| CvtkReebGraphToJoinSplitTreeFilter | Converts a given Reeb graph either to a join tree or a split tree (respectively the connectivity of the sub- and sur- level sets) |
| CvtkUnstructuredGridToReebGraphFilter | Generate a Reeb graph from a scalar field defined on a vtkUnstructuredGrid |
| CvtkEnsembleSource | Source that manages dataset ensembles |
| ►CvtkGraphAlgorithm | Superclass for algorithms that produce only graph as output |
| CvtkBoostBetweennessClustering | Implements graph clustering based on edge betweenness centrality |
| CvtkBoostBrandesCentrality | Compute Brandes betweenness centrality on a vtkGraph |
| CvtkBoostBreadthFirstSearch | Boost breadth_first_search on a vtkGraph |
| CvtkBoostConnectedComponents | Find the connected components of a graph |
| CvtkBoostExtractLargestComponent | Extract the largest connected component of a graph |
| CvtkCollapseGraph | "Collapses" vertices onto their neighbors |
| CvtkCollapseVerticesByArray | Collapse the graph given a vertex array |
| CvtkCollectGraph | Collect distributed graph |
| CvtkDIMACSGraphReader | Reads vtkGraph data from a DIMACS formatted file |
| CvtkEdgeLayout | Layout graph edges |
| CvtkExtractSelectedGraph | Return a subgraph of a vtkGraph |
| CvtkGraphHierarchicalBundleEdges | Layout graph arcs in bundles |
| CvtkGraphLayout | Layout a graph in 2 or 3 dimensions |
| ►CvtkGraphWeightFilter | Base class for filters that weight graph edges |
| CvtkGraphWeightEuclideanDistanceFilter | Weights the edges of a graph based on the Euclidean distance between the points |
| CvtkKCoreDecomposition | Compute the k-core decomposition of the input graph |
| CvtkKCoreLayout | Produces a layout for a graph labeled with K-Core information |
| CvtkMergeGraphs | Combines two graphs |
| CvtkPBGLBreadthFirstSearch | Breadth-first search on a distributed vtkGraph |
| CvtkPBGLCollapseGraph | Collapse multiple vertices into a single vertex |
| CvtkPBGLCollapseParallelEdges | Collapse multiple vertices into a single vertex |
| CvtkPBGLCollectGraph | Collects all of the pieces of a distributed vtkGraph into a single, non-distributed vtkGraph |
| CvtkPBGLConnectedComponents | Compute connected components for a distributed vtkGraph |
| CvtkPBGLGraphSQLReader | Read a vtkGraph from a database |
| CvtkPBGLMinimumSpanningTree | Minimum spanning tree of a distributed vtkGraph |
| CvtkPBGLRandomGraphSource | Generates a distributed graph with random edges |
| CvtkPBGLRMATGraphSource | Distributed graph with random edges built accorting to the recursive matrix (R-MAT) model |
| CvtkPBGLShortestPaths | Compute the shortest paths from the origin vertex to all other vertices in a distributed vtkGraph |
| CvtkPBGLVertexColoring | Compute a vertex coloring for a distributed, undirected vtkGraph, where each vertex has a color distinct from the colors of its adjacent vertices |
| CvtkPerturbCoincidentVertices | Perturbs vertices that are coincident |
| ►CvtkRandomGraphSource | Graph with random edges |
| CvtkGeoRandomGraphSource | A geospatial graph with random edges |
| CvtkRemoveIsolatedVertices | Remove vertices of a vtkGraph with degree zero |
| CvtkSplineGraphEdges | Subsample graph edges to make smooth curves |
| CvtkSQLDatabaseGraphSource | Generates a vtkGraph based on an SQL query |
| CvtkSQLGraphReader | Read a vtkGraph from a database |
| CvtkStreamGraph | Combines two graphs |
| CvtkTableToGraph | Convert a vtkTable into a vtkGraph |
| CvtkThresholdGraph | Returns a subgraph of a vtkGraph |
| CvtkTreeDifferenceFilter | Compare two trees |
| CvtkVertexDegree | Adds an attribute array with the degree of each vertex |
| CvtkHierarchicalBoxDataSetAlgorithm | Superclass for algorithms that produce vtkHierarchicalBoxDataSet as output |
| ►CvtkHyperOctreeAlgorithm | Superclass for algorithms that produce only octree as output |
| CvtkHyperOctreeFractalSource | Create an octree from a fractal |
| CvtkHyperOctreeSampleFunction | Sample an implicit function over an hyperoctree |
| ►CvtkHyperTreeGridAlgorithm | Superclass for algorithms that produce a hyper tree grid as output |
| CvtkHyperTreeGridSource | Create a synthetic grid of hypertrees |
| ►CvtkImageAlgorithm | Generic algorithm superclass for image algs |
| CTestVectorFieldSource | |
| CvtkBooleanTexture | Generate 2D texture map based on combinations of inside, outside, and on region boundary |
| CvtkCheckerboardSplatter | Splat points into a volume with an elliptical, Gaussian distribution |
| CvtkDEMReader | Read a digital elevation model (DEM) file |
| ►CvtkExtractVOI | Select piece (e.g., volume of interest) and/or subsample structured points dataset |
| CvtkPExtractVOI | |
| CvtkFastSplatter | A splatter optimized for splatting single kernels |
| CvtkGaussianSplatter | Splat points into a volume with an elliptical, Gaussian distribution |
| ►CvtkGenericMovieWriter | Abstract movie writer class |
| CvtkAVIWriter | Writes Windows AVI files |
| CvtkFFMPEGWriter | Uses the FFMPEG library to write video files |
| CvtkMPEG2Writer | Writes MPEG2 Movie files |
| CvtkOggTheoraWriter | Uses the ogg and theora libraries to write video files |
| CvtkHyperOctreeToUniformGridFilter | Flat the octree into a uniform grid |
| CvtkImageAccumulate | Generalized histograms up to 3 dimensions |
| CvtkImageCacheFilter | Caches multiple vtkImageData objects |
| CvtkImageCanvasSource2D | Paints on a canvas |
| CvtkImageChangeInformation | Modify spacing, origin and extent |
| CvtkImageClip | Reduces the image extent of the input |
| CvtkImageConnectivityFilter | Label an image by connectivity |
| CvtkImageDataLIC2D | GPU implementation of a Line Integral Convolution, a technique for imaging vector fields |
| CvtkImageDataLIC2D | GPU implementation of a Line Integral Convolution, a technique for imaging vector fields |
| ►CvtkImageDataStreamer | Initiates streaming on image data |
| CvtkMemoryLimitImageDataStreamer | Initiates streaming on image data |
| CvtkImageEllipsoidSource | Create a binary image of an ellipsoid |
| CvtkImageExport | Export VTK images to third-party systems |
| CvtkImageGaussianSource | Create an image with Gaussian pixel values |
| CvtkImageGridSource | Create an image of a grid |
| CvtkImageImport | Import data from a C array |
| ►CvtkImageInPlaceFilter | Filter that operates in place |
| CvtkImageCursor3D | Paints a cursor on top of an image or volume |
| CvtkImageIslandRemoval2D | Removes small clusters in masks |
| CvtkImageMandelbrotSource | Mandelbrot image |
| CvtkImageNoiseSource | Create an image filled with noise |
| CvtkImageOpenClose3D | Will perform opening or closing |
| CvtkImageQuantizeRGBToIndex | Generalized histograms up to 4 dimensions |
| ►CvtkImageReader2 | Superclass of binary file readers |
| CvtkDICOMImageReader | Reads some DICOM images |
| CvtkGDALRasterReader | Read raster file formats using GDAL |
| ►CvtkImageReader | Superclass of transformable binary file readers |
| CvtkBMPReader | Read Windows BMP files |
| CvtkMPIImageReader | VtkMPIImageReader provides the mechanism to read a brick of bytes (or shorts, or ints, or floats, or doubles, ...) from a file or series of files |
| ►CvtkNrrdReader | Read nrrd files file system |
| CvtkPNrrdReader | Read nrrd files efficiently from parallel file systems (and reasonably well elsewhere) |
| CvtkPNMReader | Read pnm (i.e., portable anymap) files |
| CvtkJPEGReader | Read JPEG files |
| ►CvtkMedicalImageReader2 | VtkImageReader2 with medical meta data |
| CvtkGESignaReader | Read GE Signa ximg files |
| CvtkMetaImageReader | Read binary UNC meta image data |
| CvtkMINCImageReader | A reader for MINC files |
| CvtkNIFTIImageReader | Read NIfTI-1 and NIfTI-2 medical image files |
| CvtkOpenSlideReader | Read digital whole slide images supported by openslide library |
| CvtkPNGReader | Read PNG files |
| CvtkSLCReader | Read an SLC volume file |
| CvtkTIFFReader | Read TIFF files |
| CvtkImageSeedConnectivity | SeedConnectivity with user defined seeds |
| CvtkImageSinusoidSource | Create an image with sinusoidal pixel values |
| CvtkImageStencilToImage | Convert an image stencil into an image |
| CvtkImageThresholdConnectivity | Flood fill an image region |
| CvtkImageToStructuredPoints | Attaches image pipeline to VTK |
| CvtkImageTranslateExtent | Changes extent, nothing else |
| ►CvtkImageWriter | Writes images to files |
| CvtkBMPWriter | Writes Windows BMP files |
| CvtkJPEGWriter | Writes JPEG files |
| CvtkMetaImageWriter | Write a binary UNC meta image data |
| CvtkMINCImageWriter | A writer for MINC files |
| CvtkNIFTIImageWriter | Write NIfTI-1 and NIfTI-2 medical image files |
| CvtkPImageWriter | Writes images to files |
| CvtkPNGWriter | Writes PNG files |
| CvtkPNMWriter | Writes PNM (portable any map) files |
| CvtkPostScriptWriter | Writes an image as a PostScript file |
| CvtkTIFFWriter | Write out image data as a TIFF file |
| CvtkImplicitModeller | Compute distance from input geometry on structured point dataset |
| CvtkJSONImageWriter | Writes vtkImageData to a JSON file |
| CvtkMRCReader | Read MRC image files |
| CvtkPointDensityFilter | Produce density field from input point cloud |
| CvtkPointLoad | Compute stress tensors given point load on semi-infinite domain |
| CvtkPResampleFilter | Probe dataset in parallel using a vtkImageData |
| CvtkQImageToImageSource | Create image data from a QImage |
| CvtkRTAnalyticSource | Create an image for regression testing |
| CvtkSampleFunction | Sample an implicit function over a structured point set |
| CvtkShepardMethod | Interpolate points and associated scalars onto volume using the method of Shepard |
| CvtkSignedDistance | Compute signed distances from an input point cloud |
| ►CvtkSimpleImageToImageFilter | Generic image filter with one input |
| CvtkSimpleImageFilterExample | Simple example of an image-image filter |
| CvtkSurfaceReconstructionFilter | Reconstructs a surface from unorganized points |
| ►CvtkTexture | Handles properties associated with a texture map |
| CvtkOpenGLTexture | OpenGL texture map |
| CvtkOpenGLTexture | OpenGL texture map |
| ►CvtkThreadedImageAlgorithm | Generic filter that has one input |
| CvtkImageAppend | Collects data from multiple inputs into one image |
| CvtkImageAppendComponents | Collects components from two inputs into one output |
| CvtkImageBlend | Blend images together using alpha or opacity |
| CvtkImageBSplineCoefficients | Convert image to b-spline knots |
| CvtkImageButterworthHighPass | Frequency domain high pass |
| CvtkImageButterworthLowPass | Frequency domain Low pass |
| CvtkImageCast | Image Data type Casting Filter |
| CvtkImageCheckerboard | Show two images at once using a checkboard pattern |
| CvtkImageConvolve | Convolution of an image with a kernel |
| CvtkImageCorrelation | Correlation imageof the two inputs |
| CvtkImageDifference | Compares images for regression tests |
| CvtkImageDivergence | Divergence of a vector field |
| CvtkImageDotProduct | Dot product of two vector images |
| CvtkImageEuclideanToPolar | Converts 2D Euclidean coordinates to polar |
| CvtkImageExtractComponents | Outputs a single component |
| CvtkImageGaussianSmooth | Performs a gaussian convolution |
| ►CvtkImageGradient | Computes the gradient vector |
| CvtkOpenGLImageGradient | Compute Gradient using the GPU |
| CvtkImageGradientMagnitude | Computes magnitude of the gradient |
| ►CvtkImageHistogram | Compute the histogram for an image |
| CvtkImageHistogramStatistics | Compute statistics for an image |
| CvtkImageHSIToRGB | Converts HSI components to RGB |
| CvtkImageHSVToRGB | Converts HSV components to RGB |
| CvtkImageIdealHighPass | Simple frequency domain band pass |
| CvtkImageIdealLowPass | Simple frequency domain band pass |
| ►CvtkImageIterateFilter | Multiple executes per update |
| ►CvtkImageDecomposeFilter | Filters that execute axes in series |
| CvtkImageCityBlockDistance | 1,2 or 3D distance map |
| CvtkImageEuclideanDistance | Computes 3D Euclidean DT |
| CvtkImageFourierCenter | Shifts constant frequency to center for display |
| ►CvtkImageFourierFilter | Superclass that implements complex numbers |
| CvtkImageFFT | Fast Fourier Transform |
| CvtkImageRFFT | Reverse Fast Fourier Transform |
| CvtkImageSeparableConvolution | 3 1D convolutions on an image |
| CvtkImageSkeleton2D | Skeleton of 2D images |
| CvtkImageLaplacian | Computes divergence of gradient |
| CvtkImageLogarithmicScale | Passes each pixel through log function |
| CvtkImageLogic | And, or, xor, nand, nor, not |
| CvtkImageLuminance | Computes the luminance of the input |
| CvtkImageMagnify | Magnify an image by an integer value |
| CvtkImageMagnitude | Colapses components with magnitude function |
| ►CvtkImageMapToColors | Map the input image through a lookup table |
| CvtkImageMapToRGBA | Map the input image through a lookup table |
| CvtkImageMapToWindowLevelColors | Map the input image through a lookup table and window / level it |
| CvtkImageMask | Combines a mask and an image |
| CvtkImageMaskBits | Applies a bit-mask pattern to each component |
| CvtkImageMathematics | Add, subtract, multiply, divide, invert, sin, cos, exp, log |
| CvtkImageNonMaximumSuppression | Performs non-maximum suppression |
| CvtkImageNormalize | Normalizes that scalar components for each point |
| ►CvtkImagePadFilter | Super class for filters that fill in extra pixels |
| CvtkImageConstantPad | Makes image larger by padding with constant |
| CvtkImageMirrorPad | Extra pixels are filled by mirror images |
| CvtkImageWrapPad | Makes an image larger by wrapping existing data |
| CvtkImageRectilinearWipe | Make a rectilinear combination of two images |
| CvtkImageResize | High-quality image resizing filter |
| ►CvtkImageReslice | Reslices a volume along a new set of axes |
| CvtkImageFlip | This flips an axis of an image |
| CvtkImagePermute | Permutes axes of input |
| CvtkImageResample | Resamples an image to be larger or smaller |
| CvtkImageResliceToColors | Reslice and produce color scalars |
| CvtkImageSlabReslice | Thick slab reformat through data |
| CvtkImageRGBToHSI | Converts RGB components to HSI |
| CvtkImageRGBToHSV | Converts RGB components to HSV |
| CvtkImageRGBToYIQ | Converts RGB components to YIQ |
| CvtkImageShiftScale | Shift and scale an input image |
| CvtkImageShrink3D | Subsamples an image |
| CvtkImageSlab | Combine image slices to form a slab image |
| ►CvtkImageSpatialAlgorithm | Filters that operate on pixel neighborhoods |
| CvtkImageAnisotropicDiffusion2D | Edge preserving smoothing |
| CvtkImageAnisotropicDiffusion3D | Edge preserving smoothing |
| CvtkImageContinuousDilate3D | Dilate implemented as a maximum |
| CvtkImageContinuousErode3D | Erosion implemented as a minimum |
| CvtkImageDilateErode3D | Dilates one value and erodes another |
| CvtkImageHybridMedian2D | Median filter that preserves lines and corners |
| CvtkImageMedian3D | Median Filter |
| CvtkImageRange3D | Max - min of a circular neighborhood |
| CvtkImageSobel2D | Computes a vector field using sobel functions |
| CvtkImageSobel3D | Computes a vector field using sobel functions |
| CvtkImageVariance3D | Variance in a neighborhood |
| CvtkImageStencil | Combine images via a cookie-cutter operation |
| CvtkImageThreshold | Flexible threshold |
| CvtkImageWeightedSum | Adds any number of images, weighting each according to the weight set using this->SetWeights(i,w) |
| CvtkImageYIQToRGB | |
| CvtkVolumeRayCastSpaceLeapingImageFilter | Builds the space leaping data structure |
| CvtkTriangularTexture | Generate 2D triangular texture map |
| ►CvtkVideoSource | Superclass of video input devices for VTK |
| CvtkMILVideoSource | Matrox Imaging Library frame grabbers |
| CvtkWin32VideoSource | Video-for-Windows video digitizer |
| ►CvtkVolumeReader | Read image files |
| CvtkVolume16Reader | Read 16 bit image files |
| CvtkVoxelModeller | Convert an arbitrary dataset to a voxel representation |
| CvtkVPICReader | Class for reading VPIC data files |
| ►CvtkImageStencilAlgorithm | Producer of vtkImageStencilData |
| ►CvtkImageStencilSource | Generate an image stencil |
| CvtkImplicitFunctionToImageStencil | Clip an image with a function |
| CvtkLassoStencilSource | Create a stencil from a contour |
| CvtkPolyDataToImageStencil | Use polydata to mask an image |
| CvtkROIStencilSource | Create simple mask shapes |
| CvtkImageToImageStencil | Clip an image with a mask image |
| ►CvtkLabelHierarchyAlgorithm | Superclass for algorithms that produce only label hierarchies as output |
| CvtkPointSetToLabelHierarchy | Build a label hierarchy for a graph or point set |
| CvtkMNITransformReader | A reader for MNI transformation files |
| CvtkMNITransformWriter | A writer for MNI transformation files |
| ►CvtkMoleculeAlgorithm | Superclass for algorithms that operate on vtkMolecules |
| CvtkCMLMoleculeReader | Read a CML file and output a vtkMolecule object |
| CvtkGaussianCubeReader2 | Read a Gaussian Cube file and output a vtkMolecule object and a vtkImageData |
| CvtkSimpleBondPerceiver | Create a simple guess of a molecule's topology |
| CvtkVASPAnimationReader | Reader for VASP animation files |
| CvtkVASPTessellationReader | Read NPT_Z_TESSELLATE.out files |
| CvtkXYZMolReader2 | Read Molecular Data files |
| ►CvtkMultiBlockDataSetAlgorithm | Superclass for algorithms that produce only vtkMultiBlockDataSet as output |
| ►CvtkAMRBaseParticlesReader | An abstract base class that implements all the common functionality for all particle readers |
| CvtkAMREnzoParticlesReader | A concrete instance of the vtkAMRBaseParticlesReader which provides functionality for loading ENZO AMR particle datasets from ENZO |
| CvtkAMRFlashParticlesReader | A concrete instance of vtkAMRBaseParticlesReader that implements functionality for reading flash particle datasets |
| CvtkAMRCutPlane | A concrete instance of vtkMultiBlockDataSet that provides functionality for cutting an AMR dataset (an instance of vtkOverlappingAMR) with user supplied implicit plane function defined by a normal and center |
| CvtkAMRResampleFilter | This filter is a concrete instance of vtkMultiBlockDataSetAlgorithm and provides functionality for extracting portion of the AMR dataset, specified by a bounding box, in a uniform grid of the desired level of resolution |
| CvtkAMRToMultiBlockFilter | A filter that accepts as input an AMR dataset and produces a corresponding vtkMultiBlockDataset as output |
| CvtkBlockIdScalars | Generates scalars from blocks |
| CvtkCPExodusIIInSituReader | Read an Exodus II file into data structures that map the raw arrays returned by the Exodus II library into a multi-block data set containing vtkUnstructuredGridBase subclasses |
| ►CvtkDataSetGhostGenerator | An abstract class that provides common functionality and implements an interface for all ghost data generators |
| ►CvtkPDataSetGhostGenerator | An abstract class that provides common functionality and implements an interface for all parallel ghost data generators |
| CvtkPStructuredGridGhostDataGenerator | Structured grids |
| CvtkPUniformGridGhostDataGenerator | Uniform grids |
| CvtkStructuredGridGhostDataGenerator | A concrete implementation of vtkDataSetGhostGenerator for generating ghost data on partitioned structured grids on a singled process |
| CvtkUniformGridGhostDataGenerator | A concrete implementation of vtkDataSetGhostGenerator for generating ghost data on partitioned uniform grids on a single process |
| ►CvtkExodusIIReader | Read exodus 2 files .ex2 |
| CvtkPExodusIIReader | Read Exodus II files (.exii) |
| ►CvtkExtractArraysOverTime | Extracts a selection over time |
| CvtkPExtractArraysOverTime | Extract point or cell data over time (parallel) |
| CvtkExtractBlock | Extracts blocks from a multiblock dataset |
| CvtkExtractCTHPart | Generates surface of a CTH volume fraction |
| ►CvtkExtractDataSets | Extracts a number of datasets |
| CvtkHierarchicalDataExtractDataSets | Extract a number of datasets |
| ►CvtkExtractLevel | Extract levels between min and max from a hierarchical box dataset |
| CvtkHierarchicalDataExtractLevel | Extact levels between min and max |
| CvtkFLUENTReader | Reads a dataset in Fluent file format |
| CvtkGDALVectorReader | Read vector file formats using GDAL |
| ►CvtkGenericEnSightReader | Class to read any type of EnSight files |
| CvtkEnSightMasterServerReader | Reader for compund EnSight files |
| ►CvtkEnSightReader | Superclass for EnSight file readers |
| CvtkEnSight6BinaryReader | Class to read binary EnSight6 files |
| CvtkEnSight6Reader | Class to read EnSight6 files |
| CvtkEnSightGoldBinaryReader | Class to read binary EnSight Gold files |
| CvtkEnSightGoldReader | Class to read EnSight Gold files |
| ►CvtkLSDynaReader | Read LS-Dyna databases (d3plot) |
| CvtkPLSDynaReader | Read LS-Dyna databases (d3plot) in parallel |
| CvtkMultiBlockDataGroupFilter | Collects multiple inputs into one multi-group dataset |
| CvtkMultiBlockFromTimeSeriesFilter | Collects multiple inputs into one multi-group dataset |
| CvtkMultiBlockMergeFilter | Merges multiblock inputs into a single multiblock output |
| ►CvtkMultiBlockPLOT3DReader | Read PLOT3D data files |
| CvtkMPIMultiBlockPLOT3DReader | VtkMultiBlockPLOT3DReader subclass that uses MPI-IO to efficiently read binary files for 3D domains in parallel using MPI-IO |
| CvtkMultiThreshold | Threshold cells within multiple intervals |
| ►CvtkOpenFOAMReader | Reads a dataset in OpenFOAM format |
| CvtkPOpenFOAMReader | Reads a decomposed dataset in OpenFOAM format |
| CvtkPCAAnalysisFilter | Performs principal component analysis of a set of aligned pointsets |
| ►CvtkPeriodicFilter | A filter to produce mapped periodic multiblock dataset from a single block |
| CvtkAngularPeriodicFilter | A filter to produce mapped angular periodic multiblock dataset from a single block, by rotation |
| CvtkPlot3DMetaReader | Reads meta-files points to PLOT3D files |
| CvtkProcrustesAlignmentFilter | Aligns a set of pointsets together |
| CvtkQuadRotationalExtrusionFilter | Sweep polygonal data creating "skirt" from free edges and lines, and lines from vertices |
| CvtkRectilinearGridPartitioner | A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides functionality for partitioning a VTK rectilinear dataset |
| ►CvtkSLACReader | A reader for a data format used by Omega3p, Tau3p, and several other tools used at the Standford Linear Accelerator Center (SLAC) |
| CvtkPSLACReader | Extends the vtkSLACReader to read in partitioned pieces |
| CvtkSpatialRepresentationFilter | Generate polygonal model of spatial search object (i.e., a vtkLocator) |
| CvtkStructuredGridPartitioner | A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides functionality for partitioning a VTK structured grid dataset |
| CvtkTecplotReader | A concrete class to read an ASCII Tecplot file |
| ►CvtkThreadedSynchronizedTemplates3D | Generate isosurface from structured points |
| CvtkThreadedSynchronizedTemplatesCutter3D | Generate cut surface from structured points |
| CvtkUniformGridPartitioner | A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides functionality for partitioning a uniform grid |
| ►CvtkYoungsMaterialInterface | Reconstructs material interfaces |
| CvtkPYoungsMaterialInterface | Parallel reconstruction of material interfaces |
| ►CvtkMultiTimeStepAlgorithm | Superclass for algorithms that would like to make multiple time requests |
| CvtkTemporalInterpolator | Interpolate datasets between time steps to produce a new dataset |
| ►CvtkPassInputTypeAlgorithm | Superclass for algorithms that produce output of the same type as input |
| CvtkAddMembershipArray | Add an array to the output indicating membership within an input selection |
| CvtkApplyColors | Apply colors to a data set |
| CvtkApplyIcons | Apply icons to a data set |
| CvtkAssignAttribute | Labels/marks a field as an attribute |
| CvtkAssignCoordinates | Given two(or three) arrays take the values in those arrays and simply assign them to the coordinates of the vertices |
| CvtkConvertSelectionDomain | Convert a selection from one domain to another |
| CvtkCountFaces | Add a cell data array containing the number of faces per cell |
| CvtkCountVertices | Add a cell data array containing the number of vertices per cell |
| ►CvtkDataRepresentation | The superclass for all representations |
| CvtkEmptyRepresentation | |
| CvtkGeoAlignedImageRepresentation | A multi-resolution image tree |
| CvtkQtTableRepresentation | Set up a vtkTable in a Qt model |
| ►CvtkRenderedRepresentation | |
| ►CvtkParallelCoordinatesRepresentation | Data representation that takes generic multivariate data and produces a parallel coordinates plot |
| CvtkParallelCoordinatesHistogramRepresentation | Data representation that takes generic multivariate data and produces a parallel coordinates plot |
| ►CvtkRenderedGraphRepresentation | |
| CvtkRenderedHierarchyRepresentation | |
| CvtkRenderedSurfaceRepresentation | Displays a geometric dataset as a surface |
| CvtkRenderedTreeAreaRepresentation | |
| CvtkExtractTimeSteps | Extract specific time-steps from dataset |
| CvtkForceTime | |
| CvtkGeoAssignCoordinates | Given latitude and longitude arrays, take the values in those arrays and convert them to x,y,z world coordinates |
| CvtkLabelSizeCalculator | This filter takes an input dataset, an array to process (which must be a string array), and a text property |
| CvtkMapArrayValues | Map values in an input array to different values in an output array of (possibly) different type |
| CvtkPassThrough | Shallow copies the input into the output |
| CvtkProgrammableFilter | User-programmable filter |
| CvtkRandomAttributeGenerator | Generate and create random data attributes |
| CvtkRemoveHiddenData | Removes the rows/edges/vertices of input data flagged by ann |
| ►CvtkResampleWithDataSet | |
| CvtkPResampleWithDataSet | Points from another dataset |
| CvtkTemporalStatistics | Compute statistics of point or cell data as it changes over time |
| CvtkTransferAttributes | Transfer data from a graph representation to a tree representation using direct mapping or pedigree ids |
| CvtkPieceRequestFilter | Sets the piece request for upstream filters |
| ►CvtkPiecewiseFunctionAlgorithm | Superclass for algorithms that produce only piecewise function as output |
| CvtkPiecewiseFunctionShiftScale | |
| ►CvtkPistonAlgorithm | Superclass for algorithms that produce only PistonDataObjects |
| CvtkDataSetToPiston | Converts a DataSet to a PistonDataObject |
| CvtkPistonContour | A filter that contours on the GPU |
| CvtkPistonSlice | A filter that slices on the GPU |
| CvtkPistonSort | NVidia thrust filter example |
| CvtkPistonThreshold | A filter that contours on the GPU |
| CvtkPistonToDataSet | Converts a PistonDataObject to a DataSet |
| ►CvtkPointSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| CvtkCenterOfMass | Find the center of mass of a set of points |
| CvtkDeformPointSet | Use a control polyhedron to deform an input vtkPointSet |
| CvtkExtractDataOverTime | Extract point data from a time sequence for a specified point id |
| ►CvtkProjectSphereFilter | A filter to 'unroll' a sphere |
| CvtkPProjectSphereFilter | A filter to 'unroll' a sphere |
| CvtkTransformCoordinateSystems | Transform points into different coordinate systems |
| CvtkTransformFilter | Transform points and associated normals and vectors |
| CvtkWarpLens | Deform geometry by applying lens distortion |
| CvtkWarpScalar | Deform geometry with scalar data |
| CvtkWarpTo | Deform geometry by warping towards a point |
| ►CvtkWarpVector | Deform geometry with vector data |
| CvtkSMPWarpVector | Multithreaded vtkWarpVector |
| CvtkWeightedTransformFilter | Transform based on per-point or per-cell weighting functions |
| ►CvtkPolyDataAlgorithm | Superclass for algorithms that produce only polydata as output |
| ►CvtkAbstractPolyDataReader | Superclass for algorithms that read models from a file |
| CvtkOBJReader | Read Wavefront .obj files |
| CvtkPLYReader | Read Stanford University PLY polygonal file format |
| CvtkSTLReader | Read ASCII or binary stereo lithography files |
| CvtkAdaptiveSubdivisionFilter | Subdivide triangles based on edge and/or area metrics |
| CvtkAppendPoints | Appends points of one or more vtkPolyData data sets |
| CvtkAppendPolyData | Appends one or more polygonal datasets together |
| ►CvtkApproximatingSubdivisionFilter | Generate a subdivision surface using an Approximating Scheme |
| CvtkLoopSubdivisionFilter | Generate a subdivision surface using the Loop Scheme |
| CvtkArcPlotter | Plot data along an arbitrary polyline |
| CvtkArcSource | Create a circular arc |
| CvtkArrowSource | Appends a cylinder to a cone to form an arrow |
| CvtkAxes | Create an x-y-z axes |
| CvtkBandedPolyDataContourFilter | Generate filled contours for vtkPolyData |
| CvtkBooleanOperationPolyDataFilter | Computes the boundary of the union, intersection, or difference volume computed from the volumes defined by two input surfaces |
| CvtkBoundedPointSource | Create a random cloud of points within a specified bounding box |
| ►CvtkButtonSource | Abstract class for creating various button types |
| CvtkEllipticalButtonSource | Create a ellipsoidal-shaped button |
| CvtkRectangularButtonSource | Create a rectangular button |
| CvtkBYUReader | Read MOVIE.BYU polygon files |
| CvtkCellCenters | Generate points at center of cells |
| CvtkCirclePackToPolyData | Converts a tree to a polygonal data representing a circle packing of the hierarchy |
| ►CvtkCleanPolyData | Merge duplicate points, and/or remove unused points and/or remove degenerate cells |
| CvtkQuantizePolyDataPoints | Quantizes x,y,z coordinates of points |
| CvtkClipClosedSurface | Clip a closed surface with a plane collection |
| CvtkClipConvexPolyData | Clip any dataset with user-specified implicit function or input scalar data |
| CvtkClipPolyData | Clip polygonal data with user-specified implicit function or input scalar data |
| CvtkCollectPolyData | Collect distributed polydata |
| ►CvtkCompositeDataGeometryFilter | Extract geometry from multi-group data |
| CvtkHierarchicalDataSetGeometryFilter | Extract geometry from hierarchical data |
| CvtkConeSource | Generate polygonal cone |
| ►CvtkContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkDaxContour | |
| ►CvtkContourGrid | Generate isosurfaces/isolines from scalar values (specialized for unstructured grids) |
| CvtkSMPContourGrid | Subclass of vtkContourGrid that works in parallel vtkSMPContourGrid performs the same functionaliy as vtkContourGrid but does it using multiple threads |
| CvtkSMPContourGridManyPieces | Subclass of vtkContourGrid that works in parallel vtkSMPContourGridManyPieces performs the same functionaliy as vtkContourGrid but does it using multiple threads |
| CvtkContourTriangulator | Fill all 2D contours to create polygons |
| CvtkConvexHull2D | Produce filled convex hulls around a set of points |
| CvtkCubeSource | Create a polygonal representation of a cube |
| CvtkCursor2D | Generate a 2D cursor representation |
| CvtkCursor3D | Generate a 3D cursor representation |
| CvtkCurvatures | Compute curvatures (Gauss and mean) of a Polydata object |
| CvtkCutMaterial | Automatically computes the cut plane for a material array pair |
| ►CvtkCutter | Cut vtkDataSet with user-specified implicit function |
| CvtkCompositeCutter | Cut composite data sets with user-specified implicit function |
| CvtkCylinderSource | Generate a cylinder centered at origin |
| ►CvtkDataSetSurfaceFilter | Extracts outer (polygonal) surface |
| CvtkDataSetRegionSurfaceFilter | Extract surface of materials |
| CvtkDecimatePolylineFilter | Reduce the number of lines in a polyline |
| CvtkDecimatePro | Reduce the number of triangles in a mesh |
| CvtkDelaunay2D | Create 2D Delaunay triangulation of input points |
| CvtkDensifyPolyData | Densify the input by adding points at the centroid |
| CvtkDepthImageToPointCloud | Convert a depth image into a point cloud |
| CvtkDepthSortPolyData | Sort poly data along camera view direction |
| CvtkDiskSource | Create a disk with hole in center |
| CvtkDistancePolyDataFilter | Computes the signed distance from one vtkPolyData to another |
| CvtkDistanceToCamera | Calculates distance from points to the camera |
| CvtkDuplicatePolyData | For distributed tiled displays |
| CvtkEarthSource | Create the continents of the Earth as a sphere |
| CvtkEdgeCenters | Generate points at center of edges |
| CvtkEdgePoints | Generate points on isosurface |
| CvtkEllipseArcSource | Create an elliptical arc |
| CvtkEuclideanClusterExtraction | Perform segmentation based on geometric proximity and optional scalar threshold |
| CvtkExtractEdges | Extract cell edges from any type of data |
| CvtkExtractPointCloudPiece | Return a piece of a point cloud |
| CvtkExtractPolyDataGeometry | Extract vtkPolyData cells that lies either entirely inside or outside of a specified implicit function |
| CvtkExtractPolyDataPiece | Return specified piece, including specified number of ghost levels |
| CvtkExtractSelectedPolyDataIds | Extract a list of cells from a polydata |
| CvtkExtractSurface | Generate zero-crossing isosurface from truncated signed distance volume |
| CvtkFacetReader | Reads a dataset in Facet format |
| CvtkFacetWriter | Reads a dataset in Facet format |
| CvtkFeatureEdges | Extract boundary, non-manifold, and/or sharp edges from polygonal data |
| CvtkFillHolesFilter | Identify and fill holes in meshes |
| CvtkFlyingEdges2D | Generate isoline(s) from a structured points set |
| CvtkFlyingEdges3D | Generate isosurface from 3D image data (volume) |
| CvtkFlyingEdgesPlaneCutter | Cut a volume with a plane and generate a polygonal cut surface |
| CvtkFrustumSource | Create a polygonal representation of a frustum |
| CvtkGenericContourFilter | Generate isocontours from input dataset |
| CvtkGenericCutter | Cut a vtkGenericDataSet with an implicit function or scalar data |
| CvtkGenericGeometryFilter | Extract geometry from data (or convert data to polygonal type) |
| CvtkGenericGlyph3DFilter | Copy oriented and scaled glyph geometry to every input point |
| CvtkGenericOutlineFilter | Create wireframe outline for arbitrary generic data set |
| CvtkGenericStreamTracer | Streamline generator |
| CvtkGeoAdaptiveArcs | |
| CvtkGeoArcs | Layout graph edges on a globe as arcs |
| ►CvtkGeodesicPath | Abstract base for classes that generate a geodesic path |
| ►CvtkGraphGeodesicPath | Abstract base for classes that generate a geodesic path on a graph (mesh) |
| ►CvtkDijkstraGraphGeodesicPath | Dijkstra algorithm to compute the graph geodesic |
| CvtkDijkstraImageGeodesicPath | Dijkstra algorithm to compute the graph geodesic |
| CvtkGeoGraticule | Create a polygonal lat-long grid |
| CvtkGeoJSONReader | Convert Geo JSON format to vtkPolyData |
| CvtkGeometryFilter | Extract geometry from data (or convert data to polygonal type) |
| CvtkGeoSampleArcs | Samples geospatial lines at regular intervals |
| CvtkGlobeSource | Sphere patch with Lat/Long scalar array |
| ►CvtkGlyph3D | Copy oriented and scaled glyph geometry to every input point |
| CvtkGlyph2D | Copy oriented and scaled glyph geometry to every input point (2D specialization) |
| CvtkGlyphSource2D | Create 2D glyphs represented by vtkPolyData |
| CvtkGraphAnnotationLayersFilter | Produce filled convex hulls around subsets of vertices in a vtkGraph |
| CvtkGraphLayoutFilter | Nice layout of undirected graphs in 3D |
| CvtkGraphToGlyphs | Create glyphs for graph vertices |
| CvtkGraphToPoints | Convert a vtkGraph a set of points |
| CvtkGraphToPolyData | Convert a vtkGraph to vtkPolyData |
| CvtkGreedyTerrainDecimation | Reduce height field (represented as image) to reduced TIN |
| CvtkGridSynchronizedTemplates3D | Generate isosurface from structured grids |
| CvtkHedgeHog | Create oriented lines from vector data |
| CvtkHierarchicalBinningFilter | Uniform binning of points into a hierarchical structure |
| CvtkHull | Produce an n-sided convex hull |
| CvtkHyperOctreeContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkHyperOctreeCutter | Cut vtkHyperOctree with user-specified implicit function |
| CvtkHyperOctreeDualGridContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkHyperOctreeSurfaceFilter | Extracts outer (polygonal) surface |
| CvtkHyperStreamline | Generate hyperstreamline in arbitrary dataset |
| CvtkHyperTreeGridAxisCut | Axis aligned hyper tree grid cut |
| CvtkHyperTreeGridGeometry | Hyper tree grid outer surface |
| CvtkIconGlyphFilter | Filter that generates a polydata consisting of quads with texture coordinates referring to a set of icons within a sheet of icons |
| ►CvtkImageDataGeometryFilter | Extract geometry for structured points |
| CvtkStructuredPointsGeometryFilter | Obsolete class |
| CvtkImageMarchingCubes | Generate isosurface(s) from volume/images |
| CvtkImageToPoints | Extract all image voxels as points |
| CvtkImageToPolyDataFilter | Generate linear primitives (vtkPolyData) from an image |
| ►CvtkInterpolatingSubdivisionFilter | Generate a subdivision surface using an Interpolating Scheme |
| CvtkButterflySubdivisionFilter | Generate a subdivision surface using the Butterfly Scheme |
| CvtkLinearSubdivisionFilter | Generate a subdivision surface using the Linear Scheme |
| CvtkIntersectionPolyDataFilter | VtkIntersectionPolyDataFilter computes the intersection between two vtkPolyData objects |
| CvtkLabelPlacer | Place a prioritized hierarchy of labels in screen space |
| ►CvtkLinearExtrusionFilter | Sweep polygonal data creating a "skirt" from free edges and lines, and lines from vertices |
| CvtkPLinearExtrusionFilter | Subclass that handles piece invariance |
| CvtkLineSource | Create a line defined by two end points |
| CvtkLinkEdgels | Links edgels together to form digital curves |
| CvtkMarchingContourFilter | Generate isosurfaces/isolines from scalar values |
| ►CvtkMarchingCubes | Generate isosurface(s) from volume |
| CvtkDiscreteMarchingCubes | Generate object boundaries from labelled volumes |
| CvtkMarchingSquares | Generate isoline(s) from structured points set |
| ►CvtkMaskPoints | Selectively filter points |
| CvtkPMaskPoints | Parallel Mask Points |
| CvtkMaskPolyData | Sample subset of input polygonal data cells |
| CvtkMassProperties | Estimate volume, area, shape index of triangle mesh |
| CvtkMCubesReader | Read binary marching cubes file |
| CvtkMNIObjectReader | A reader for MNI surface mesh files |
| CvtkMNITagPointReader | A reader for MNI tag files |
| ►CvtkMoleculeReaderBase | Read Molecular Data files |
| CvtkGaussianCubeReader | Read ASCII Gaussian Cube Data files |
| CvtkPDBReader | Read Molecular Data files |
| CvtkXYZMolReader | Read Molecular Data files |
| ►CvtkMoleculeToPolyDataFilter | Abstract filter class |
| CvtkMoleculeToAtomBallFilter | Generate polydata with spheres representing atoms |
| CvtkMoleculeToBondStickFilter | Generate polydata with cylinders representing bonds |
| CvtkOBJPolyDataProcessor | |
| CvtkOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
| CvtkOutlineFilter | Create wireframe outline for arbitrary data set |
| ►CvtkOutlineSource | Create wireframe outline around bounding box |
| CvtkOutlineCornerSource | Create wireframe outline corners around bounding box |
| CvtkParametricFunctionSource | Tessellate parametric functions |
| CvtkParticleReader | Read ASCII or binary particle data and (optionally) one scalar value associated with each particle |
| ►CvtkParticleTracerBase | A particle tracer for vector fields |
| CvtkParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkParticleTracer | A Parallel Particle tracer for unsteady vector fields |
| ►CvtkPParticleTracerBase | |
| CvtkPParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkPParticleTracer | A Parallel Particle tracer for unsteady vector fields |
| CvtkPStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkPCACurvatureEstimation | Generate curvature estimates using principal component analysis |
| CvtkPCANormalEstimation | Generate point normals using local tangent planes |
| CvtkPlaneSource | Create an array of quadrilaterals located in a plane |
| CvtkPlatonicSolidSource | Produce polygonal Platonic solids |
| ►CvtkPointCloudFilter | Abstract class for filtering a point cloud |
| CvtkExtractHierarchicalBins | Manipulate the output of vtkHierarchicalBinningFilter |
| CvtkExtractPoints | Extract points within an implicit function |
| CvtkFitImplicitFunction | Extract points on the surface of an implicit function |
| CvtkRadiusOutlierRemoval | Remove isolated points |
| CvtkStatisticalOutlierRemoval | Remove sparse outlier points |
| CvtkPointSource | Create a random cloud of points |
| CvtkPolyDataConnectivityFilter | Extract polygonal data based on geometric connectivity |
| ►CvtkPolyDataNormals | Compute normals for polygonal mesh |
| CvtkPPolyDataNormals | Compute normals for polygonal mesh |
| CvtkPolyDataPointSampler | Generate points from vtkPolyData |
| CvtkPolyDataSilhouette | Sort polydata along camera view direction |
| CvtkPolyLineSource | Create a poly line from a list of input points |
| CvtkPOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
| CvtkPOutlineFilter | Create wireframe outline for arbitrary data set |
| CvtkProgrammableGlyphFilter | Control the generation and placement of glyphs at input points |
| CvtkProjectedTerrainPath | Project a polyline onto a terrain |
| CvtkProteinRibbonFilter | Generates protein ribbons |
| CvtkPTSReader | Read ASCII PTS Files |
| CvtkQuadraturePointsGenerator | Create a vtkPolyData on its output containing the vertices for the quadrature points for one of the vtkDataArrays present on its input vtkUnstructuredGrid |
| CvtkQuadricClustering | Reduce the number of triangles in a mesh |
| CvtkQuadricDecimation | Reduce the number of triangles in a mesh |
| CvtkRectilinearGridGeometryFilter | Extract geometry for a rectilinear grid |
| CvtkRectilinearGridOutlineFilter | Create wireframe outline for a rectilinear grid |
| CvtkRectilinearSynchronizedTemplates | Generate isosurface from rectilinear grid |
| CvtkRecursiveDividingCubes | Create points laying on isosurface (using recursive approach) |
| CvtkRegularPolygonSource | Create a regular, n-sided polygon and/or polyline |
| CvtkResliceCursorPolyDataAlgorithm | Generates a 2D reslice cursor polydata |
| CvtkReverseSense | Reverse the ordering of polygonal cells and/or vertex normals |
| CvtkRibbonFilter | Create oriented ribbons from lines defined in polygonal dataset |
| CvtkRotationalExtrusionFilter | Sweep polygonal data creating "skirt" from free edges and lines, and lines from vertices |
| CvtkRuledSurfaceFilter | Generates a surface from a set of lines |
| CvtkSectorSource | Create a sector of a disk |
| CvtkSelectPolyData | Select portion of polygonal mesh; generate selection scalars |
| CvtkSelectVisiblePoints | Extract points that are visible (based on z-buffer calculation) |
| CvtkShrinkPolyData | Shrink cells composing PolyData |
| CvtkSimplePointsReader | Read a list of points from a file |
| CvtkSLACParticleReader | A reader for a data format used by Omega3p, Tau3p, and several other tools used at the Standford Linear Accelerator Center (SLAC) |
| CvtkSmoothPolyDataFilter | Adjust point positions using Laplacian smoothing |
| CvtkSpherePuzzle | Create a polygonal sphere centered at the origin |
| CvtkSpherePuzzleArrows | Visualize permutation of the sphere puzzle |
| ►CvtkSphereSource | Create a polygonal sphere centered at the origin |
| CvtkPSphereSource | Sphere source that supports pieces |
| CvtkSplineFilter | Generate uniformly subdivided polylines from a set of input polyline using a vtkSpline |
| ►CvtkStreamer | Abstract object implements integration of massless particle through vector field |
| ►CvtkStreamLine | Generate streamline in arbitrary dataset |
| CvtkDashedStreamLine | Generate constant-time dashed streamline in arbitrary dataset |
| CvtkStreamPoints | Generate points along streamer separated by constant time increment |
| ►CvtkStreamTracer | Streamline generator |
| CvtkPStreamTracer | Parallel streamline generators |
| ►CvtkTemporalStreamTracer | A Parallel Particle tracer for unsteady vector fields |
| CvtkPTemporalStreamTracer | |
| CvtkStripper | Create triangle strips and/or poly-lines |
| CvtkStructuredGridGeometryFilter | Extract geometry for structured grid |
| CvtkStructuredGridOutlineFilter | Create wireframe outline for structured grid |
| CvtkSubPixelPositionEdgels | Adjust edgel locations based on gradients |
| CvtkSuperquadricSource | Create a polygonal superquadric centered at the origin |
| CvtkSynchronizedTemplates2D | Generate isoline(s) from a structured points set |
| ►CvtkSynchronizedTemplates3D | Generate isosurface from structured points |
| CvtkSynchronizedTemplatesCutter3D | Generate cut surface from structured points |
| CvtkTableToPolyData | Filter used to convert a vtkTable to a vtkPolyData consisting of vertices |
| CvtkTemporalPathLineFilter | Generate a Polydata Pointset from any Dataset |
| CvtkTensorGlyph | Scale and orient glyph(s) according to tensor eigenvalues and eigenvectors |
| CvtkTessellatedBoxSource | Create a polygonal representation of a box with a given level of subdivision |
| CvtkTextSource | Create polygonal text |
| CvtkTexturedSphereSource | Create a sphere centered at the origin |
| CvtkThresholdPoints | Extracts points whose scalar value satisfies threshold criterion |
| CvtkTransformPolyDataFilter | Transform points and associated normals and vectors for polygonal dataset |
| CvtkTransmitPolyDataPiece | |
| CvtkTreeMapToPolyData | Converts a tree to a polygonal data representing a tree map |
| CvtkTreeRingToPolyData | Converts a tree to a polygonal data representing radial space filling tree |
| CvtkTriangleFilter | Convert input polygons and strips to triangles |
| CvtkTriangularTCoords | 2D texture coordinates based for triangles |
| CvtkTubeFilter | Filter that generates tubes around lines |
| CvtkUGFacetReader | Read EDS Unigraphics facet files |
| CvtkUncertaintyTubeFilter | Generate uncertainty tubes along a polyline |
| CvtkVectorText | Create polygonal text |
| CvtkVertexGlyphFilter | Make a vtkPolyData with a vertex on each point |
| CvtkVolumeOutlineSource | Outline of volume cropping region |
| CvtkVoxelContoursToSurfaceFilter | Create surface from contours |
| CvtkVoxelGrid | Subsample points using uniform binning |
| CvtkWindowedSincPolyDataFilter | Adjust point positions using a windowed sinc function interpolation kernel |
| CvtkPythonAlgorithm | Algorithm that can be implemented in Python |
| ►CvtkRectilinearGridAlgorithm | Superclass for algorithms that produce only rectilinear grid as output |
| ►CvtkExtractRectilinearGrid | Extract a sub grid (VOI) from the structured rectilinear dataset |
| CvtkPExtractRectilinearGrid | Extract VOI and/or sub-sample a distributed rectilinear grid dataset |
| CvtkNetCDFPOPReader | Read NetCDF files .Author Joshua Wu 09.15.2009 |
| CvtkPNetCDFPOPReader | Read NetCDF files in parallel with MPI .Author Ross Miller 03.14.2011 |
| CvtkRectilinearGridClip | Reduces the image extent of the input |
| CvtkRendererSource | Take a renderer's image and/or depth map into the pipeline |
| CvtkRenderLargeImage | Use tiling to generate a large rendering |
| ►CvtkResampleToImage | Sample dataset on a uniform grid |
| CvtkPResampleToImage | Sample dataset on a uniform grid in parallel |
| ►CvtkSelectionAlgorithm | Superclass for algorithms that produce only Selection as output |
| CvtkAppendSelection | Appends one or more selections together |
| CvtkBoostKruskalMinimumSpanningTree | Contructs a minimum spanning tree from a graph and the weighting array |
| CvtkCellDistanceSelector | Grows a selection, selecting neighbor cells, up to a user defined topological distance |
| ►CvtkComputeHistogram2DOutliers | Compute the outliers in a set of 2D histograms and extract the corresponding row data |
| CvtkPComputeHistogram2DOutliers | Extract outlier rows from a vtkTable based on input 2D histograms, in parallel |
| CvtkConvertSelection | Convert a selection from one type to another |
| CvtkExpandSelectedGraph | Expands a selection set of a vtkGraph |
| CvtkKdTreeSelector | Selects point ids using a kd-tree |
| CvtkLinearSelector | Select cells intersecting a line (possibly broken) |
| CvtkSelectionSource | Generate selection from given set of ids vtkSelectionSource generates a vtkSelection from a set of (piece id, cell id) pairs |
| ►CvtkStreamerBase | Superclass for filters that stream input pipeline |
| CvtkPolyDataStreamer | Streamer appends input pieces to the output |
| ►CvtkStructuredGridAlgorithm | Superclass for algorithms that produce only structured grid as output |
| CvtkBlankStructuredGrid | Translate point attribute data into a blanking field |
| CvtkBlankStructuredGridWithImage | Blank a structured grid with an image |
| ►CvtkExtractGrid | Select piece (e.g., volume of interest) and/or subsample structured grid dataset |
| CvtkPExtractGrid | Extract VOI and/or sub-sample a distributed structured dataset |
| CvtkImageDataToPointSet | Converts a vtkImageData to a vtkPointSet |
| CvtkImageToStructuredGrid | Structured grid instance |
| CvtkRectilinearGridToPointSet | Converts a vtkRectilinearGrid to a vtkPointSet |
| CvtkStructuredGridAppend | Collects data from multiple inputs into one structured grid |
| CvtkStructuredGridClip | Reduces the image extent of the input |
| CvtkStructuredGridLIC2D | GPU implementation of a Line Integral Convolution, a technique for imaging vector fields |
| CvtkStructuredGridLIC2D | GPU implementation of a Line Integral Convolution, a technique for imaging vector fields |
| CvtkTableToStructuredGrid | Converts vtkTable to a vtkStructuredGrid |
| ►CvtkWindBladeReader | Class for reading WindBlade data files |
| CvtkPWindBladeReader | Class for reading WindBlade data files |
| ►CvtkTableAlgorithm | Superclass for algorithms that produce only vtkTables as output |
| CvtkAdjacencyMatrixToEdgeTable | Treats a dense 2-way array of doubles as an adacency matrix and converts it into a vtkTable suitable for use as an edge table with vtkTableToGraph |
| CvtkArrayToTable | Converts one- and two-dimensional vtkArrayData objects to vtkTable |
| ►CvtkBivariateLinearTableThreshold | Performs line-based thresholding for vtkTable data |
| CvtkPBivariateLinearTableThreshold | Performs line-based thresholding for vtkTable data in parallel |
| CvtkBoostSplitTableField | "Splits" one-or-more table fields by duplicating rows containing delimited data |
| CvtkCollectTable | Collect distributed table |
| CvtkComputeQuartiles | Extract quartiles and extremum values of all columns of a table or all fields of a dataset |
| ►CvtkDatabaseToTableReader | Read an SQL table as a vtkTable |
| CvtkMySQLToTableReader | Read a MySQL table as a vtkTable |
| CvtkPostgreSQLToTableReader | Read a PostgreSQL table as a vtkTable |
| CvtkSQLiteToTableReader | Read an SQLite table as a vtkTable |
| CvtkDataObjectToTable | Extract field data as a table |
| CvtkDelimitedTextReader | Reads in delimited ascii or unicode text files and outputs a vtkTable data structure |
| CvtkDotProductSimilarity | Compute dot-product similarity metrics |
| CvtkExtractFunctionalBagPlot | From an input table containing series on port 0 and another table describing densities on port 1 (for instance obtained by applying filter vtkHighestDensityRegionsStatistics, this filter generates a table containing all the columns of the input port 0 plus two 2 components columns containing the bag series to be used by vtkFunctionalBagPlot |
| CvtkExtractSelectedRows | Return selected rows of a table |
| CvtkFixedWidthTextReader | Reader for pulling in text files with fixed-width fields |
| CvtkISIReader | Reader for ISI files |
| CvtkMergeColumns | Merge two columns into a single column |
| CvtkMergeTables | Combine two tables |
| CvtkReduceTable | Combine some of the rows of a table |
| CvtkRISReader | Reader for RIS files |
| CvtkRowQueryToTable | Executes an sql query and retrieves results into a table |
| CvtkRRandomTableSource | Generates vtkTables with columns of random numbers using Gnu R |
| CvtkSparseArrayToTable | Converts a sparse array to a vtkTable |
| CvtkSplitColumnComponents | Split multicomponent table columns |
| CvtkSQLDatabaseTableSource | Generates a vtkTable based on an SQL query |
| ►CvtkStatisticsAlgorithm | Base class for statistics algorithms |
| ►CvtkAutoCorrelativeStatistics | A class for univariate auto-correlative statistics |
| CvtkPAutoCorrelativeStatistics | A class for parallel auto-correlative statistics |
| ►CvtkContingencyStatistics | A class for bivariate correlation contigency tables, conditional probabilities, and information entropy |
| CvtkContingencyStatisticsGnuR | A class for bivariate correlation contigency tables, conditional probabilities, and information entropy |
| CvtkPContingencyStatistics | A class for parallel bivariate contingency statistics |
| ►CvtkCorrelativeStatistics | A class for bivariate linear correlation |
| CvtkCorrelativeStatisticsGnuR | A class for bivariate linear correlation using R to calculate the p-values |
| CvtkPCorrelativeStatistics | A class for parallel bivariate correlative statistics |
| ►CvtkDescriptiveStatistics | A class for univariate descriptive statistics |
| CvtkDescriptiveStatisticsGnuR | |
| CvtkPDescriptiveStatistics | A class for parallel univariate descriptive statistics |
| ►CvtkExtractHistogram2D | Compute a 2D histogram between two columns of an input vtkTable |
| CvtkPExtractHistogram2D | Compute a 2D histogram between two columns of an input vtkTable in parallel |
| CvtkHighestDensityRegionsStatistics | Compute a random vector of density f from input observations points |
| ►CvtkKMeansStatistics | A class for KMeans clustering |
| CvtkPKMeansStatistics | |
| ►CvtkMultiCorrelativeStatistics | A class for multivariate linear correlation |
| ►CvtkPCAStatistics | A class for multivariate principal component analysis |
| CvtkPCAStatisticsGnuR | A class for multivariate principal component analysis using R to calculate p-values |
| CvtkPPCAStatistics | A class for parallel principal component analysis |
| CvtkPMultiCorrelativeStatistics | A class for parallel bivariate correlative statistics |
| ►CvtkOrderStatistics | A class for univariate order statistics |
| CvtkPOrderStatistics | A class for parallel univariate order statistics |
| ►CvtkPairwiseExtractHistogram2D | Compute a 2D histogram between all adjacent columns of an input vtkTable |
| CvtkPPairwiseExtractHistogram2D | Compute a 2D histogram between all adjacent columns of an input vtkTable in parallel |
| CvtkStreamingStatistics | A class for using the statistics filters in a streaming mode |
| CvtkTableFFT | FFT for table columns |
| CvtkTecplotTableReader | Reads in Tecplot tabular data and outputs a vtkTable data structure |
| CvtkThresholdTable | Thresholds table rows |
| CvtkTransposeTable | Transpose an input table |
| CvtkTemporalDataSetCache | Cache time steps |
| CvtkTemporalFractal | A source to test AMR data object |
| CvtkTemporalShiftScale | Modify the time range/steps of temporal data |
| CvtkTemporalSnapToTimeStep | Modify the time range/steps of temporal data |
| CvtkTransformToGrid | Create a grid for a vtkGridTransform |
| ►CvtkTreeAlgorithm | Superclass for algorithms that produce only Tree as output |
| CvtkAreaLayout | Layout a vtkTree into a tree map |
| CvtkBoostBreadthFirstSearchTree | Contructs a BFS tree from a graph |
| CvtkBoostPrimMinimumSpanningTree | Contructs a minimum spanning tree from a graph, start node, and the weighting array |
| CvtkCirclePackLayout | Layout a vtkTree as a circle packing |
| CvtkExtractSelectedTree | Return a subtree from a vtkTree |
| CvtkGroupLeafVertices | Filter that expands a tree, categorizing leaf vertices |
| CvtkNetworkHierarchy | Filter that takes a graph and makes a tree out of the network ip addresses in that graph |
| CvtkPruneTreeFilter | Prune a subtree out of a vtkTree |
| CvtkStrahlerMetric | Compute Strahler metric for a tree |
| CvtkTableToTreeFilter | Filter that converts a vtkTable to a vtkTree |
| CvtkTreeFieldAggregator | Aggregate field values from the leaves up the tree |
| CvtkTreeLevelsFilter | Adds level and leaf fields to a vtkTree |
| CvtkTreeMapLayout | Layout a vtkTree into a tree map |
| CvtkXMLTreeReader | Reads an XML file into a vtkTree |
| CvtkTrivialConsumer | Consumer to consume data off of a pipeline |
| CvtkTrivialProducer | Producer for stand-alone data objects |
| ►CvtkUndirectedGraphAlgorithm | Superclass for algorithms that produce undirected graph as output |
| CvtkBoostBiconnectedComponents | Find the biconnected components of a graph |
| CvtkChacoGraphReader | Reads chaco graph files |
| CvtkTulipReader | Reads tulip graph files |
| CvtkXGMLReader | Reads XGML graph files |
| ►CvtkUniformGridAMRAlgorithm | VtkUniformGridAMR as output |
| ►CvtkNonOverlappingAMRAlgorithm | Produce vtkNonOverlappingAMR as output |
| CvtkNonOverlappingAMRLevelIdScalars | Generate scalars from levels |
| ►CvtkOverlappingAMRAlgorithm | A base class for all algorithms that take as input vtkOverlappingAMR and produce vtkOverlappingAMR |
| ►CvtkAMRBaseReader | An abstract class that encapsulates common functionality for all AMR readers |
| CvtkAMREnzoReader | A concrete instance of vtkAMRBaseReader that implements functionality for reading Enzo AMR datasets |
| CvtkAMRFlashReader | |
| CvtkAMRGaussianPulseSource | A source that generates sample AMR data with gaussian pulse field |
| CvtkAMRSliceFilter | A concrete instance of vtkOverlappingAMRAlgorithm which implements functionality for extracting slices from AMR data |
| CvtkImageToAMR | Filter to convert any vtkImageData to a vtkOverlappingAMR |
| ►CvtkOverlappingAMRLevelIdScalars | Generate scalars from levels |
| ►CvtkLevelIdScalars | Empty class for backwards compatibility |
| CvtkHierarchicalDataLevelFilter | Generate scalars from levels |
| ►CvtkUnstructuredGridAlgorithm | Superclass for algorithms that produce only unstructured grid as output |
| CvtkAppendFilter | Appends one or more datasets together into a single unstructured grid |
| CvtkAVSucdReader | Reads a dataset in AVS "UCD" format |
| CvtkBoxClipDataSet | Clip an unstructured grid |
| ►CvtkChacoReader | Read a Chaco file and create a vtkUnstructuredGrid |
| CvtkPChacoReader | Read Chaco files |
| CvtkClipDataSet | Clip any dataset with user-specified implicit function or input scalar data |
| CvtkClipHyperOctree | Clip an hyperoctree with user-specified implicit function or input scalar data |
| CvtkClipVolume | Clip volume data with user-specified implicit function or input scalar data |
| CvtkConnectivityFilter | Extract data based on geometric connectivity |
| CvtkDataSetTriangleFilter | Triangulate any type of dataset |
| CvtkDelaunay3D | Create 3D Delaunay triangulation of input points |
| CvtkExtractCells | Subset a vtkDataSet to create a vtkUnstructuredGrid |
| CvtkExtractGeometry | Extract cells that lie either entirely inside or outside of a specified implicit function |
| CvtkExtractUnstructuredGrid | Extract subset of unstructured grid geometry |
| ►CvtkExtractUnstructuredGridPiece | Return specified piece, including specified number of ghost levels |
| CvtkExtractUserDefinedPiece | Return user specified piece with ghost cells |
| CvtkGAMBITReader | Reads a dataset in Fluent GAMBIT neutral file format |
| CvtkGenericClip | Clip any dataset with an implicit function or scalar data |
| CvtkGenericDataSetTessellator | Tessellates generic, higher-order datasets into linear cells |
| CvtkHyperTreeGridToUnstructuredGrid | Convert hyper tree grid to unstructured grid |
| CvtkLinearToQuadraticCellsFilter | Degree elevate the cells of a linear unstructured grid |
| CvtkMFIXReader | Reads a dataset in MFIX file format |
| CvtkMPASReader | Read an MPAS netCDF file |
| CvtkNetCDFCAMReader | Read unstructured NetCDF CAM files |
| CvtkProStarReader | Reads geometry in proSTAR (STARCD) file format |
| CvtkPUnstructuredGridGhostCellsGenerator | Builds ghost cells for a distributed unstructured grid dataset |
| CvtkPUnstructuredGridGhostDataGenerator | Distributed unstructured grid dataset |
| CvtkRectilinearGridToTetrahedra | Create a Tetrahedral mesh from a RectilinearGrid |
| CvtkRotationFilter | Duplicates a data set by rotation about an axis |
| CvtkShrinkFilter | Shrink cells composing an arbitrary data set |
| CvtkSubdivideTetra | Subdivide one tetrahedron into twelve for every tetra |
| CvtkTableBasedClipDataSet | Clip any dataset with a user-specified implicit function or an input scalar point data array |
| CvtkTessellatorFilter | Approximate nonlinear FEM elements with simplices |
| ►CvtkThreshold | Extracts cells where scalar value in cell satisfies threshold criterion |
| CvtkDaxThreshold | |
| CvtkTimeSourceExample | |
| CvtkTransmitUnstructuredGridPiece | |
| CvtkUnstructuredGridQuadricDecimation | Reduce the number of tetrahedra in a mesh |
| CvtkVolumeOfRevolutionFilter | Sweep data about a line to create a volume |
| ►CvtkUnstructuredGridBaseAlgorithm | Superclass for algorithms that produce only vtkUnstructureGridBase subclasses as output |
| CvtkUnstructuredGridGeometryFilter | Extract geometry from an unstructured grid |
| CvtkWindowToImageFilter | Use a vtkWindow as input to image pipeline |
| ►CvtkWriter | Abstract class to write data to file(s) |
| CvtkAbstractParticleWriter | Abstract class to write particle data to file |
| CvtkArrayDataWriter | Serialize vtkArrayData to a file or stream |
| CvtkArrayWriter | Serialize sparse and dense arrays to a file or stream |
| CvtkBYUWriter | Write MOVIE.BYU files |
| CvtkDataObjectWriter | Write vtk field data |
| ►CvtkDataWriter | Helper class for objects that write vtk data files |
| CvtkCompositeDataWriter | Legacy VTK file writer for vtkCompositeDataSet subclasses |
| ►CvtkDataSetWriter | Write any type of vtk dataset to file |
| CvtkPDataSetWriter | Manages writing pieces of a data set |
| CvtkSimplePointsWriter | Write a file of xyz coordinates |
| CvtkDIMACSGraphWriter | Write vtkGraph data to a DIMACS formatted file |
| CvtkGenericDataObjectWriter | Writes any type of vtk data object to file |
| CvtkGraphWriter | Write vtkGraph data to a file |
| CvtkNewickTreeWriter | Write vtkTree data to Newick format |
| ►CvtkPolyDataWriter | Write vtk polygonal data |
| CvtkCGMWriter | Write polygonal data as a CGM file |
| CvtkRectilinearGridWriter | Write vtk rectilinear grid data file |
| CvtkStructuredGridWriter | Write vtk structured grid data file |
| CvtkStructuredPointsWriter | Write vtk structured points data file |
| CvtkTableWriter | Write vtkTable to a file |
| CvtkTreeWriter | Write vtkTree data to a file |
| CvtkUnstructuredGridWriter | Write vtk unstructured grid data file |
| CvtkDelimitedTextWriter | Delimited text writer for vtkTable Writes a vtkTable as a delimited text file (such as CSV) |
| CvtkEnSightWriter | Write vtk unstructured grid data as an EnSight file |
| ►CvtkExodusIIWriter | Write Exodus II files |
| CvtkPExodusIIWriter | Write Exodus II files |
| CvtkGeoJSONWriter | Convert vtkPolyData to Geo JSON format |
| CvtkHoudiniPolyDataWriter | Write vtk polygonal data to Houdini file |
| CvtkIVWriter | Export polydata into OpenInventor 2.0 format |
| CvtkJavaScriptDataWriter | A Javascript data writer for vtkTable Writes a vtkTable into a Javascript data format |
| CvtkMCubesWriter | Write binary marching cubes file |
| CvtkMNIObjectWriter | A writer for MNI surface mesh files |
| CvtkMNITagPointWriter | A writer for MNI tag point files |
| CvtkPLYWriter | Write Stanford PLY file format |
| CvtkSTLWriter | Write stereo lithography files |
| ►CvtkTableToDatabaseWriter | In a SQL database |
| CvtkTableToMySQLWriter | Store a vtkTable in a MySQL database |
| CvtkTableToPostgreSQLWriter | Store a vtkTable in a PostgreSQL database |
| CvtkTableToSQLiteWriter | Store a vtkTable in an SQLite database |
| ►CvtkXMLReader | Superclass for VTK's XML format readers |
| CvtkPhyloXMLTreeReader | Read vtkTree from PhyloXML formatted file |
| ►CvtkXMLCompositeDataReader | Reader for multi-group datasets |
| ►CvtkXMLMultiBlockDataReader | Reader for multi-block datasets |
| ►CvtkXMLMultiGroupDataReader | Reader for multi-block datasets |
| CvtkXMLHierarchicalDataReader | Reader for hierarchical datasets |
| ►CvtkXMLUniformGridAMRReader | Reader for amr datasets (vtkOverlappingAMR or vtkNonOverlappingAMR) |
| CvtkXMLHierarchicalBoxDataReader | Reader for hierarchical datasets (for backwards compatibility) |
| ►CvtkXMLDataReader | Superclass for VTK XML file readers |
| CvtkXMLGenericDataObjectReader | Read any type of vtk data object |
| CvtkXMLHyperOctreeReader | Read VTK XML HyperOctree files |
| ►CvtkXMLStructuredDataReader | Superclass for structured data XML readers |
| CvtkXMLImageDataReader | Read VTK XML ImageData files |
| CvtkXMLRectilinearGridReader | Read VTK XML RectilinearGrid files |
| CvtkXMLStructuredGridReader | Read VTK XML StructuredGrid files |
| ►CvtkXMLUnstructuredDataReader | Superclass for unstructured data XML readers |
| ►CvtkXMLPolyDataReader | Read VTK XML PolyData files |
| CvtkRTXMLPolyDataReader | Read RealTime VTK XML PolyData files |
| CvtkXMLUnstructuredGridReader | Read VTK XML UnstructuredGrid files |
| ►CvtkXMLPDataReader | Superclass for PVTK XML file readers |
| ►CvtkXMLPStructuredDataReader | Superclass for parallel structured data XML readers |
| CvtkXMLPImageDataReader | Read PVTK XML ImageData files |
| CvtkXMLPRectilinearGridReader | Read PVTK XML RectilinearGrid files |
| CvtkXMLPStructuredGridReader | Read PVTK XML StructuredGrid files |
| ►CvtkXMLPUnstructuredDataReader | Superclass for parallel unstructured data XML readers |
| CvtkXMLPPolyDataReader | Read PVTK XML PolyData files |
| CvtkXMLPUnstructuredGridReader | Read PVTK XML UnstructuredGrid files |
| ►CvtkXMLWriter | Superclass for VTK's XML file writers |
| CvtkPhyloXMLTreeWriter | Write vtkTree data to PhyloXML format |
| ►CvtkXMLCompositeDataWriter | Writer for multi-group datasets |
| ►CvtkXMLMultiBlockDataWriter | Writer for vtkMultiBlockDataSet |
| CvtkXMLPMultiBlockDataWriter | Parallel writer for vtkHierarchicalBoxDataSet |
| ►CvtkXMLUniformGridAMRWriter | Writer for vtkUniformGridAMR |
| CvtkXMLHierarchicalBoxDataWriter | Writer for vtkHierarchicalBoxDataSet for backwards compatibility |
| ►CvtkXMLPUniformGridAMRWriter | Parallel writer for vtkUniformGridAMR and subclasses |
| CvtkXMLPHierarchicalBoxDataWriter | Parallel writer for vtkHierarchicalBoxDataSet for backwards compatibility |
| CvtkXMLDataSetWriter | Write any type of VTK XML file |
| CvtkXMLHyperOctreeWriter | Write VTK XML HyperOctree files |
| ►CvtkXMLPDataWriter | Write data in a parallel XML format |
| CvtkXMLPDataSetWriter | Write any type of PVTK XML file |
| ►CvtkXMLPStructuredDataWriter | Superclass for PVTK XML structured data writers |
| CvtkXMLPImageDataWriter | Write PVTK XML ImageData files |
| CvtkXMLPRectilinearGridWriter | Write PVTK XML RectilinearGrid files |
| CvtkXMLPStructuredGridWriter | Write PVTK XML StructuredGrid files |
| ►CvtkXMLPUnstructuredDataWriter | Superclass for PVTK XML unstructured data writers |
| CvtkXMLPPolyDataWriter | Write PVTK XML PolyData files |
| CvtkXMLPUnstructuredGridWriter | Write PVTK XML UnstructuredGrid files |
| ►CvtkXMLStructuredDataWriter | Superclass for VTK XML structured data writers |
| CvtkXMLImageDataWriter | Write VTK XML ImageData files |
| CvtkXMLRectilinearGridWriter | Write VTK XML RectilinearGrid files |
| CvtkXMLStructuredGridWriter | Write VTK XML StructuredGrid files |
| ►CvtkXMLUnstructuredDataWriter | Superclass for VTK XML unstructured data writers |
| CvtkXMLPolyDataWriter | Write VTK XML PolyData files |
| CvtkXMLUnstructuredGridWriter | Write VTK XML UnstructuredGrid files |
| CvtkAlgorithmOutput | Proxy object to connect input/output ports |
| CvtkAmoebaMinimizer | Nonlinear optimization with a simplex |
| CvtkAMRDataInternals | Container of vtkUniformGrid for an AMR data set |
| CvtkAMRDataSetCache | A concrete implementation of vtkObject that provides functionality for caching AMR blocks |
| CvtkAMRInformation | Meta data that describes the structure of an AMR data set |
| ►CvtkAMRUtilities | A concrete instance of vtkObject that employs a singleton design pattern and implements functionality for AMR specific operations |
| CvtkParallelAMRUtilities | A concrete instance of vtkObject that employs a singleton design pattern and implements functionality for AMR specific operations |
| ►CvtkAnimationCue | Seqin an animation |
| CvtkAnimationScene | Animation scene manager |
| ►CvtkAreaLayoutStrategy | Abstract superclass for all area layout strategies |
| CvtkStackedTreeLayoutStrategy | Lays out tree in stacked boxes or rings |
| ►CvtkTreeMapLayoutStrategy | Abstract superclass for all tree map layout strategies |
| CvtkBoxLayoutStrategy | Tree map layout that puts vertices in square-ish boxes |
| CvtkSliceAndDiceLayoutStrategy | Horizontal and vertical slicing tree map layout |
| CvtkSquarifyLayoutStrategy | Uses the squarify tree map layout algorithm |
| ►CvtkArray | Abstract interface for N-dimensional arrays |
| ►CvtkTypedArray< T > | Provides a type-specific interface to N-way arrays |
| CvtkDenseArray< T > | Contiguous storage for N-way arrays |
| CvtkSparseArray< T > | Sparse, independent coordinate storage for N-way arrays |
| ►CvtkArrayIterator | Abstract superclass to iterate over elements in an vtkAbstractArray |
| CvtkArrayIteratorTemplate< T > | Implementation template for a array iterator |
| CvtkBitArrayIterator | Iterator for vtkBitArray |
| CvtkAssemblyNode | Represent a node in an assembly |
| CvtkAxisExtended | Octree-based spatial search object to quickly locate cells |
| CvtkBackgroundColorMonitor | Tracks state of background color(s) |
| CvtkBase64Utilities | Base64 encode and decode utilities |
| CvtkBlueObeliskData | Contains chemical data from the Blue Obelisk Data Repository |
| CvtkBrush | Brush that fills shapes drawn by vtkContext2D |
| CvtkBSPIntersections | Perform calculations (mostly intersection calculations) on regions of a 3D binary spatial partitioning |
| CvtkBuffer< ScalarTypeT > | Internal storage class used by vtkSOADataArrayTemplate, vtkAOSDataArrayTemplate, and others |
| CvtkBuffer< ValueType > | |
| CvtkByteSwap | Perform machine dependent byte swapping |
| ►CvtkCamera | Virtual camera for 3D rendering |
| ►CvtkOpenGLCamera | OpenGL camera |
| CvtkExternalOpenGLCamera | OpenGL camera |
| CvtkOculusCamera | Oculus camera |
| CvtkOpenVRCamera | OpenVR camera |
| CvtkOpenGLCamera | OpenGL camera |
| CvtkCameraInterpolator | Interpolate a series of cameras to update a new camera |
| ►CvtkCell | Abstract class to specify cell behavior |
| ►CvtkCell3D | Abstract class to specify 3D cell interface |
| CvtkConvexPointSet | 3D cell defined by a set of convex points |
| CvtkHexagonalPrism | 3D cell that represents a prism with hexagonal base |
| CvtkHexahedron | Cell that represents a linear 3D hexahedron |
| CvtkPentagonalPrism | 3D cell that represents a convex prism with pentagonal base |
| CvtkPolyhedron | 3D cell defined by a set of polygonal faces |
| CvtkPyramid | 3D cell that represents a linear pyramid |
| CvtkTetra | 3D cell that represents a tetrahedron |
| CvtkVoxel | Cell that represents a 3D orthogonal parallelepiped |
| CvtkWedge | 3D cell that represents a linear wedge |
| CvtkEmptyCell | Empty cell used as a place-holder during processing |
| CvtkGenericCell | Thread-safe access to cells |
| CvtkLine | Cell represents a 1D line |
| ►CvtkNonLinearCell | Abstract superclass for non-linear cells |
| CvtkBiQuadraticQuad | Cell represents a parabolic, 9-node isoparametric quad |
| CvtkBiQuadraticQuadraticHexahedron | Cell represents a biquadratic, 24-node isoparametric hexahedron |
| CvtkBiQuadraticQuadraticWedge | Cell represents a parabolic, 18-node isoparametric wedge |
| CvtkBiQuadraticTriangle | Cell represents a parabolic, isoparametric triangle |
| CvtkCubicLine | Cell represents a cubic , isoparametric 1D line |
| CvtkQuadraticEdge | Cell represents a parabolic, isoparametric edge |
| CvtkQuadraticHexahedron | Cell represents a parabolic, 20-node isoparametric hexahedron |
| CvtkQuadraticLinearQuad | Cell represents a quadratic-linear, 6-node isoparametric quad |
| CvtkQuadraticLinearWedge | Cell represents a, 12-node isoparametric wedge |
| CvtkQuadraticPolygon | Cell that represents a parabolic n-sided polygon |
| CvtkQuadraticPyramid | Cell represents a parabolic, 13-node isoparametric pyramid |
| CvtkQuadraticQuad | Cell represents a parabolic, 8-node isoparametric quad |
| CvtkQuadraticTetra | Cell represents a parabolic, 10-node isoparametric tetrahedron |
| CvtkQuadraticTriangle | Cell represents a parabolic, isoparametric triangle |
| CvtkQuadraticWedge | Cell represents a parabolic, 15-node isoparametric wedge |
| CvtkTriQuadraticHexahedron | Cell represents a parabolic, 27-node isoparametric hexahedron |
| CvtkPixel | Cell that represents an orthogonal quadrilateral |
| CvtkPolygon | Cell that represents an n-sided polygon |
| CvtkPolyLine | Cell represents a set of 1D lines |
| CvtkPolyVertex | Cell represents a set of 0D vertices |
| CvtkQuad | Cell that represents a 2D quadrilateral |
| CvtkTriangle | Cell that represents a triangle |
| CvtkTriangleStrip | Cell that represents a triangle strip |
| CvtkVertex | Cell that represents a 3D point |
| CvtkCellArray | Object to represent cell connectivity |
| ►CvtkCellIterator | Efficient cell iterator for vtkDataSet topologies |
| CvtkCPExodusIIElementBlockCellIterator | VtkCellIterator subclass specialized for vtkCPExodusIIElementBlock |
| CvtkDataSetCellIterator | Implementation of vtkCellIterator using vtkDataSet API |
| CvtkMappedUnstructuredGridCellIterator< Implementation > | Default cell iterator for vtkMappedUnstructuredGrid |
| CvtkPointSetCellIterator | Implementation of vtkCellIterator using vtkPointSet API |
| CvtkUnstructuredGridCellIterator | Implementation of vtkCellIterator specialized for vtkUnstructuredGrid |
| CvtkCellTypes | Object provides direct access to cells in vtkCellArray and type information |
| ►CvtkCirclePackLayoutStrategy | Abstract superclass for all circle packing layout strategies |
| CvtkCirclePackFrontChainLayoutStrategy | Layout a vtkTree into packed circles using the front chain algorithm |
| CvtkCocoaTkUtilities | Internal Tk Routines for Cocoa |
| CvtkCoincidentPoints | Octree of labels |
| ►CvtkCollection | Create and manipulate unsorted lists of objects |
| CvtkAssemblyPath | List of nodes that form an assembly path |
| CvtkAssemblyPaths | List of lists of props representing an assembly hierarchy |
| CvtkCullerCollection | List of Cullers |
| CvtkDataArrayCollection | Maintain an unordered list of dataarray objects |
| CvtkDataObjectCollection | Maintain an unordered list of data objects |
| CvtkDataSetCollection | Maintain an unordered list of dataset objects |
| CvtkIdListCollection | Maintain an unordered list of dataarray objects |
| CvtkImageReader2Collection | Maintain a list of image readers |
| CvtkImplicitFunctionCollection | Maintain a list of implicit functions |
| CvtkLightCollection | List of lights |
| CvtkMapperCollection | List of mappers |
| CvtkObjectFactoryCollection | Maintain a list of object factories |
| CvtkOverrideInformationCollection | Maintain a list of override information objects |
| CvtkPlaneCollection | Maintain a list of planes |
| CvtkPolyDataCollection | Maintain a list of polygonal data objects |
| ►CvtkPropCollection | List of Props |
| CvtkActor2DCollection | List of 2D actors |
| CvtkActorCollection | List of actors |
| CvtkImageSliceCollection | Sorted list of image slice objects |
| CvtkProp3DCollection | List of 3D props |
| CvtkVolumeCollection | List of volumes |
| CvtkRendererCollection | List of renderers |
| CvtkRenderPassCollection | List of RenderPasses |
| CvtkRenderPassCollection | List of RenderPasses |
| CvtkRenderWindowCollection | List of RenderWindows |
| CvtkShader2Collection | List of Shader2 objects |
| CvtkSocketCollection | Collection for sockets |
| CvtkStructuredPointsCollection | Maintain a list of structured points data objects |
| CvtkTextPropertyCollection | List of vtkTextProperty objects |
| CvtkTransformCollection | Maintain a list of transforms |
| CvtkViewNodeCollection | Collection of view nodes |
| ►CvtkCollectionIterator | Iterator through a vtkCollection |
| CvtkDataArrayCollectionIterator | Iterator through a vtkDataArrayCollection |
| CvtkColorMaterialHelper | Helper to assist in simulating the ColorMaterial behaviour of the default OpenGL pipeline |
| CvtkColorSeries | Stores a list of colors |
| ►CvtkCommunicator | Used to send/receive messages in a multiprocess environment |
| CvtkDummyCommunicator | Dummy controller for single process applications |
| CvtkMPICommunicator | Class for creating user defined MPI communicators |
| CvtkSocketCommunicator | Process communication using Sockets |
| CvtkSubCommunicator | Provides communication on a process group |
| CvtkCompositeDataDisplayAttributes | Rendering attributes for a multi-block dataset |
| ►CvtkCompositeDataIterator | Superclass for composite data iterators |
| CvtkDataObjectTreeIterator | Superclass for composite data iterators |
| ►CvtkUniformGridAMRDataIterator | Subclass of vtkCompositeDataIterator with API to get current level and dataset index |
| CvtkHierarchicalBoxDataIterator | Empty class for backwards compatibility |
| ►CvtkCompositer | Super class for composite algorthms |
| CvtkCompressCompositer | Implements compressed tree based compositing |
| CvtkTreeCompositer | Implements tree based compositing |
| CvtkConditionVariable | Mutual exclusion locking class |
| CvtkContext2D | Class for drawing 2D primitives to a graphical context |
| CvtkContext3D | Class for drawing 3D primitives to a graphical context |
| ►CvtkContextDevice2D | Abstract class for drawing 2D primitives |
| ►CvtkOpenGLContextDevice2D | Class for drawing 2D primitives using OpenGL 1.1+ |
| CvtkGL2PSContextDevice2D | Class for drawing 2D primitives using GL2PS |
| CvtkOpenGL2ContextDevice2D | Class for drawing 2D primitives using OpenGL 2 |
| CvtkOpenGLContextDevice2D | Class for drawing 2D primitives using OpenGL 1.1+ |
| ►CvtkContextDevice3D | Abstract class for drawing 3D primitives |
| CvtkOpenGLContextDevice3D | OpenGL class drawing 3D primitives |
| CvtkOpenGLContextDevice3D | OpenGL class drawing 3D primitives |
| CvtkContextScene | Provides a 2D scene for vtkContextItem objects |
| ►CvtkContourLineInterpolator | Defines API for interpolating/modifying nodes from a vtkContourRepresentation |
| CvtkBezierContourLineInterpolator | Interpolates supplied nodes with bezier line segments |
| CvtkDijkstraImageContourLineInterpolator | Contour interpolator for placing points on an image |
| CvtkLinearContourLineInterpolator | Interpolates supplied nodes with line segments |
| ►CvtkPolyDataContourLineInterpolator | Contour interpolator for polygonal data |
| CvtkPolygonalSurfaceContourLineInterpolator | Contour interpolator for to place points on polygonal surfaces |
| CvtkTerrainContourLineInterpolator | Contour interpolator for DEM data |
| CvtkContourValues | Helper object to manage setting and generating contour values |
| CvtkCoordinate | Perform coordinate transformation, and represent position, in a variety of vtk coordinate systems |
| CvtkCPExodusIIElementBlockImpl | |
| CvtkCriticalSection | Critical section locking class |
| ►CvtkCuller | Superclass for prop cullers |
| CvtkFrustumCoverageCuller | Cull props based on frustum coverage |
| CvtkDataArraySelection | Store on/off settings for data arrays for a vtkSource |
| ►CvtkDataCompressor | Abstract interface for data compression classes |
| CvtkZLibDataCompressor | Data compression using zlib |
| CvtkDataEncoder | Class used to compress/encode images using threads |
| ►CvtkDataObject | General representation of visualization data |
| ►CvtkAbstractElectronicData | Provides access to and storage of chemical electronic data |
| CvtkOpenQubeElectronicData | Provides access to and storage of electronic data calculated by OpenQube |
| CvtkProgrammableElectronicData | Provides access to and storage of user-generated vtkImageData that describes electrons |
| CvtkAnnotation | Stores a collection of annotation artifacts |
| CvtkAnnotationLayers | Stores a ordered collection of annotation sets |
| CvtkArrayData | Pipeline data object that contains multiple vtkArray objects |
| CvtkBSPCuts | This class represents an axis-aligned Binary Spatial Partitioning of a 3D space |
| ►CvtkCompositeDataSet | Abstract superclass for composite (multi-block or AMR) datasets |
| ►CvtkDataObjectTree | Implementation for most abstract methods in the superclass vtkCompositeDataSet |
| CvtkMultiBlockDataSet | Composite dataset that organizes datasets into blocks |
| CvtkMultiPieceDataSet | Composite dataset to encapsulates pieces of dataset |
| ►CvtkUniformGridAMR | |
| CvtkNonOverlappingAMR | A concrete instance of vtkUniformGridAMR to store uniform grids at different levels of resolution that do not overlap with each other |
| ►CvtkOverlappingAMR | Hierarchical dataset of vtkUniformGrids |
| CvtkHierarchicalBoxDataSet | Backwards compatibility class |
| ►CvtkDataSet | Abstract class to specify dataset behavior |
| CvtkHyperOctree | A dataset structured as a tree where each node has exactly 2^n children |
| CvtkHyperTreeGrid | A dataset containing a grid of vtkHyperTree instances arranged as a rectilinear grid |
| ►CvtkImageData | Topologically and geometrically regular array of data |
| CvtkStructuredPoints | A subclass of ImageData |
| CvtkUniformGrid | Image data with blanking |
| ►CvtkPointSet | Abstract class for specifying dataset behavior |
| CvtkLabelHierarchy | Octree of labels |
| CvtkPath | Concrete dataset representing a path defined by Bezier curves |
| CvtkPolyData | Concrete dataset represents vertices, lines, polygons, and triangle strips |
| CvtkStructuredGrid | Topologically regular array of data |
| ►CvtkUnstructuredGridBase | Dataset represents arbitrary combinations of all possible cell types |
| CvtkMappedUnstructuredGrid< Implementation, CellIterator > | Allows datasets with arbitrary storage layouts to be used with VTK |
| CvtkUnstructuredGrid | Dataset represents arbitrary combinations of all possible cell types |
| CvtkRectilinearGrid | Dataset that is topologically regular with variable spacing in the three coordinate directions |
| CvtkGenericDataSet | Defines dataset interface |
| CvtkGeoJSONFeature | Represents GeoJSON feature geometry & properties |
| ►CvtkGraph | Base class for graph data types |
| ►CvtkDirectedGraph | A directed graph |
| ►CvtkDirectedAcyclicGraph | A rooted tree data structure |
| CvtkTree | A rooted tree data structure |
| ►CvtkMutableDirectedGraph | An editable directed graph |
| CvtkReebGraph | Reeb graph computation for PL scalar fields |
| ►CvtkUndirectedGraph | An undirected graph |
| CvtkMolecule | Class describing a molecule |
| CvtkMutableUndirectedGraph | An editable undirected graph |
| CvtkImageStencilData | Efficient description of an image stencil |
| CvtkPiecewiseFunction | Defines a 1D piecewise function |
| CvtkPistonDataObject | A GPU resident data set |
| CvtkSelection | A node in a selection tree |
| CvtkTable | A table, which contains similar-typed columns of data |
| CvtkDataObjectTypes | |
| CvtkDataTransferHelper | Helper class that aids in transferring data between CPU memory and GPU memory |
| CvtkDataTransferHelper | Helper class that aids in transferring data between CPU memory and GPU memory |
| CvtkDebugLeaks | Identify memory leaks at program termination vtkDebugLeaks is used to report memory leaks at the exit of the program |
| ►CvtkDirectionEncoder | Encode a direction into a one or two byte value |
| CvtkRecursiveSphereDirectionEncoder | A direction encoder based on the recursive subdivision of an octahedron |
| CvtkSphericalDirectionEncoder | A direction encoder based on spherical coordinates |
| CvtkDirectory | OS independent class for access and manipulation of system directories |
| ►CvtkDistributedGraphHelper | Helper for the vtkGraph class that allows the graph to be distributed across multiple memory spaces |
| CvtkPBGLDistributedGraphHelper | End namespace boost::graph::distributed |
| CvtkDSPFilterDefinition | Used by the Exodus readers |
| CvtkDSPFilterGroup | Used by the Exodus readers |
| CvtkDynamicLoader | Class interface to system dynamic libraries |
| ►CvtkEdgeLayoutStrategy | Abstract superclass for all edge layout strategies |
| CvtkArcParallelEdgeStrategy | Routes parallel edges as arcs |
| CvtkGeoEdgeStrategy | Layout graph edges on a globe as arcs |
| CvtkPassThroughEdgeStrategy | Passes edge routing information through |
| CvtkEdgeListIterator | Iterates through all edges in a graph |
| ►CvtkEdgeSubdivisionCriterion | How to decide whether a linear approximation to nonlinear geometry or field should be subdivided |
| CvtkDataSetEdgeSubdivisionCriterion | Subclass of vtkEdgeSubdivisionCriterion for vtkDataSet objects |
| CvtkEdgeTable | Keep track of edges (edge is pair of integer id's) |
| ►CvtkEncodedGradientEstimator | Superclass for gradient estimation |
| CvtkFiniteDifferenceGradientEstimator | Use finite differences to estimate gradient |
| CvtkEncodedGradientShader | Compute shading tables for encoded normals |
| CvtkEvent | Complete specification of a VTK event including all modifiers |
| CvtkEventQtSlotConnect | Manage connections between VTK events and Qt slots |
| CvtkExecutionTimer | Time filter execution |
| ►CvtkExecutive | Superclass for all pipeline executives in VTK |
| ►CvtkDemandDrivenPipeline | Executive supporting on-demand execution |
| ►CvtkStreamingDemandDrivenPipeline | Executive supporting partial updates |
| CvtkCachedStreamingDemandDrivenPipeline | VtkCachedStreamingDemandDrivenPipeline |
| ►CvtkCompositeDataPipeline | Executive supporting composite datasets |
| CvtkThreadedCompositeDataPipeline | Executive that works in parallel |
| CvtkImageImportExecutive | VtkImageImportExecutive |
| CvtkExodusIICache | |
| CvtkExodusIIReaderPrivate | This class holds metadata for an Exodus file |
| ►CvtkExporter | Abstract class to write a scene to a file |
| ►CvtkGL2PSExporter | Export a scene as a PostScript file using GL2PS |
| CvtkOpenGLGL2PSExporter | OpenGL2 implementation of GL2PS exporter |
| CvtkOpenGLGL2PSExporter | OpenGL2 implementation of GL2PS exporter |
| CvtkIVExporter | Export a scene into OpenInventor 2.0 format |
| CvtkOBJExporter | Export a scene into Wavefront format |
| CvtkOOGLExporter | Export a scene into Geomview OOGL format |
| CvtkPOVExporter | Export scene into povray format |
| CvtkPVWebGLExporter | |
| CvtkRIBExporter | Export a scene into RenderMan RIB format |
| CvtkVRMLExporter | Export a scene into VRML 2.0 format |
| CvtkX3DExporter | Create an x3d file |
| CvtkExtentRCBPartitioner | This method partitions a global extent to N partitions where N is a user supplied parameter |
| CvtkExtentSplitter | Split an extent across other extents |
| CvtkExtentTranslator | Generates a structured extent from unstructured |
| CvtkExtractStructuredGridHelper | Helper for extracting/sub-sampling structured datasets |
| ►CvtkFieldData | Represent and manipulate fields of data |
| ►CvtkDataSetAttributes | Represent and manipulate attribute data in a dataset |
| CvtkCellData | Represent and manipulate cell attribute data |
| CvtkPointData | Represent and manipulate point attribute data |
| CvtkFieldDataSerializer | A concrete instance of vtkObject which provides functionality for serializing and de-serializing field data, primarily used for the purpose of preparing the data for transfer over MPI or other communication mechanism |
| CvtkFixedPointRayCastImage | Helper class for a ray cast image |
| ►CvtkFixedPointVolumeRayCastHelper | An abstract helper that generates images for the volume ray cast mapper |
| CvtkFixedPointVolumeRayCastCompositeGOHelper | A helper that generates composite images for the volume ray cast mapper |
| CvtkFixedPointVolumeRayCastCompositeGOShadeHelper | A helper that generates composite images for the volume ray cast mapper |
| CvtkFixedPointVolumeRayCastCompositeHelper | A helper that generates composite images for the volume ray cast mapper |
| CvtkFixedPointVolumeRayCastCompositeShadeHelper | A helper that generates composite images for the volume ray cast mapper |
| CvtkFixedPointVolumeRayCastMIPHelper | A helper that generates MIP images for the volume ray cast mapper |
| CvtkFrameBufferObject2 | Interface to OpenGL framebuffer object |
| ►CvtkFrameBufferObjectBase | Abstract interface to OpenGL FBOs |
| CvtkFrameBufferObject | Internal class which encapsulates OpenGL frame buffer object |
| CvtkFrameBufferObject | Internal class which encapsulates OpenGL frame buffer object |
| CvtkFrameBufferObject2 | Interface to OpenGL framebuffer object |
| ►CvtkFreeTypeTools | FreeType library support |
| CvtkFontConfigFreeTypeTools | Subclass of vtkFreeTypeTools that uses system installed fonts |
| CvtkFunctionParser | Parse and evaluate a mathematical expression |
| ►CvtkFunctionSet | Abstract interface for sets of functions |
| ►CvtkAbstractInterpolatedVelocityField | An abstract class for obtaining the interpolated velocity values at a point |
| CvtkAMRInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point in AMR data |
| ►CvtkCompositeInterpolatedVelocityField | An abstract class for obtaining the interpolated velocity values at a point |
| CvtkCellLocatorInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point |
| CvtkInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point |
| CvtkCachingInterpolatedVelocityField | Interface for obtaining interpolated velocity values |
| CvtkGenericInterpolatedVelocityField | Interface for obtaining interpolated velocity values |
| CvtkTemporalInterpolatedVelocityField | A helper class for interpolating between times during particle tracing |
| CvtkFXAAOptions | Configuration for FXAA implementations |
| CvtkGarbageCollector | Detect and break reference loops |
| CvtkGDAL | Shared data for GDAL classes |
| CvtkGenericAdaptorCell | Defines cell interface |
| CvtkGenericAttribute | Abstract class defined API for attribute data |
| CvtkGenericAttributeCollection | Collection of attributes |
| CvtkGenericCellIterator | Iterator used to traverse cells |
| ►CvtkGenericCellTessellator | Helper class to perform cell tessellation |
| CvtkSimpleCellTessellator | Helper class to perform cell tessellation |
| CvtkGenericEdgeTable | Keep track of edges (defined by pair of integer id's) |
| CvtkGenericPointIterator | Iterator used to traverse points |
| ►CvtkGenericSubdivisionErrorMetric | Objects that compute error during cell tessellation |
| CvtkAttributesErrorMetric | Objects that compute attribute-based error during cell tessellation |
| CvtkGeometricErrorMetric | Objects that compute geometry-based error during cell tessellation |
| CvtkSmoothErrorMetric | Objects that compute geometry-based error during cell tessellation according to some max angle |
| CvtkViewDependentErrorMetric | Objects that compute a screen-based error during cell tessellation |
| CvtkGenericVertexAttributeMapping | Stores mapping for data arrays to generic vertex attributes |
| CvtkGeoCamera | Geo interface to a camera |
| CvtkGeoMath | Useful geographic calculations |
| CvtkGeoProjection | Represent a projection from a sphere to a plane |
| ►CvtkGeoSource | A multi-resolution geographic data source |
| CvtkGeoAlignedImageSource | Splits hi-res image into tiles |
| CvtkGeoFileImageSource | A tiled image source on disk |
| CvtkGeoFileTerrainSource | A source for tiled geometry on disk |
| CvtkGeoGlobeSource | Spherical globe source |
| CvtkGeoProjectionSource | A 2D geographic geometry source |
| ►CvtkGeoTerrain | A 3D terrain model for the globe |
| CvtkGeoTerrain2D | A 2D terrain model for the globe |
| ►CvtkGeoTreeNode | Stores data for a patch of the globe |
| CvtkGeoImageNode | A node in a multi-resolution image tree |
| CvtkGeoTerrainNode | |
| CvtkGeoTreeNodeCache | Manages a list of vtkGeoTreeNodes |
| CvtkGL2PSUtilities | Helper functions for using GL2PS within VTK |
| CvtkGlobFileNames | Find files that match a wildcard pattern |
| CvtkGPUInfo | Stores GPU VRAM information |
| ►CvtkGPUInfoList | Stores the list of GPUs VRAM information |
| CvtkCoreGraphicsGPUInfoList | Get GPUs VRAM information using CoreGraphics |
| CvtkDirectXGPUInfoList | Get GPUs VRAM information using DirectX |
| CvtkDummyGPUInfoList | Do thing during Probe() |
| CvtkDummyGPUInfoList | Do thing during Probe() |
| CvtkXGPUInfoList | Get GPUs VRAM information using X server extensions |
| CvtkGraphEdge | Representation of a single graph edge |
| CvtkGraphicsFactory | |
| CvtkGraphInternals | Internal representation of vtkGraph |
| ►CvtkGraphLayoutStrategy | Abstract superclass for all graph layout strategies |
| CvtkAssignCoordinatesLayoutStrategy | Uses array values to set vertex locations |
| CvtkAttributeClustering2DLayoutStrategy | Simple fast 2D graph layout |
| CvtkCircularLayoutStrategy | Places vertices around a circle |
| CvtkClustering2DLayoutStrategy | Simple fast 2D graph layout |
| CvtkCommunity2DLayoutStrategy | 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 |
| CvtkConeLayoutStrategy | Produce a cone-tree layout for a forest |
| CvtkConstrained2DLayoutStrategy | Simple fast 2D graph layout that looks for a 'constraint' array (vtkDoubleArray) |
| CvtkCosmicTreeLayoutStrategy | Tree layout strategy reminiscent of astronomical systems |
| CvtkFast2DLayoutStrategy | Simple fast 2D graph layout |
| CvtkForceDirectedLayoutStrategy | Force directed graph layout algorithm |
| CvtkPassThroughLayoutStrategy | Layout strategy that does absolutely nothing |
| CvtkRandomLayoutStrategy | Randomly places vertices in 2 or 3 dimensions |
| CvtkSimple2DLayoutStrategy | Simple 2D graph layout |
| CvtkSimple3DCirclesStrategy | Places vertices on circles in 3D |
| CvtkSpanTreeLayoutStrategy | VtkSpanTreeLayout is a strategy for drawing directed graphs that works by first extracting a spanning tree (more accurately, a spanning forest), and using this both to position graph vertices and to plan the placement of non-tree edges |
| CvtkTreeLayoutStrategy | Hierarchical layout |
| CvtkTreeOrbitLayoutStrategy | Hierarchical orbital layout |
| ►CvtkHardwareSelector | Manager for OpenGL-based selection |
| ►CvtkOpenGLHardwareSelector | Implements the device specific code of vtkOpenGLHardwareSelector |
| CvtkPHardwareSelector | VtkHardwareSelector useful for parallel rendering |
| CvtkOpenGLHardwareSelector | Implements the device specific code of vtkOpenGLHardwareSelector |
| CvtkHeap | Replacement for malloc/free and new/delete |
| CvtkHierarchicalGraphPipeline | Helper class for rendering graphs superimposed on a tree |
| CvtkHyperOctreeCursor | Objects that can traverse hyperoctree nodes |
| ►CvtkHyperOctreePointsGrabber | An object used by filters to store points computed on face or edge of an hyperoctant |
| CvtkHyperOctreeClipCutPointsGrabber | A concrete implementation of vtkHyperOctreePointsGrabber used by vtkClipHyperOctree and vtkHyperOctreeCutter |
| CvtkHyperTree | An object structured as a tree where each node has exactly either 2^n or 3^n children |
| CvtkHyperTreeCursor | Objects that can traverse hypertree nodes |
| CvtkIdList | List of point or cell ids |
| CvtkImageConnector | Create a binary image of a sphere |
| CvtkImageOrthoPlanes | Connect three vtkImagePlaneWidgets together |
| CvtkImageProperty | Image display properties |
| CvtkImageReader2Factory | Superclass of binary file readers |
| CvtkImageViewer | Display a 2d image |
| ►CvtkImageViewer2 | Display a 2D image |
| CvtkResliceImageViewer | Display an image along with a reslice cursor |
| ►CvtkImplicitFunction | Abstract interface for implicit functions |
| CvtkBox | Implicit function for a bounding box |
| CvtkCone | Implicit function for a cone |
| CvtkCylinder | Implicit function for a cylinder |
| CvtkImplicitBoolean | Implicit function consisting of boolean combinations of implicit functions |
| CvtkImplicitDataSet | Treat a dataset as if it were an implicit function |
| CvtkImplicitHalo | Implicit function for an halo |
| CvtkImplicitPolyDataDistance | Implicit function that computes the distance from a point x to the nearest point p on an input vtkPolyData |
| CvtkImplicitSelectionLoop | Implicit function for a selection loop |
| CvtkImplicitSum | Implicit sum of other implicit functions |
| CvtkImplicitVolume | Treat a volume as if it were an implicit function |
| CvtkImplicitWindowFunction | Implicit function maps another implicit function to lie within a specified range |
| CvtkPerlinNoise | Implicit function that implements Perlin noise |
| CvtkPlane | Perform various plane computations |
| ►CvtkPlanes | Implicit function for convex set of planes |
| CvtkPlanesIntersection | 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 |
| CvtkPolyPlane | Implicit function that is generated by extrusion of a polyline along the Z axis |
| CvtkQuadric | Evaluate implicit quadric function |
| CvtkSphere | Implicit function for a sphere |
| CvtkSuperquadric | Implicit function for a Superquadric |
| ►CvtkImporter | Importer abstract class |
| Cvtk3DSImporter | Imports 3D Studio files |
| CvtkOBJImporter | Import from .obj wavefront files |
| CvtkVRMLImporter | Imports VRML 2.0 files |
| CvtkIncrementalForceLayout | Incremental force-directed layout |
| CvtkIncrementalOctreeNode | Octree node constituting incremental octree (in support of both point location and point insertion) |
| CvtkInEdgeIterator | Iterates through all incoming edges to a vertex |
| CvtkInformation | Store vtkAlgorithm input/output information |
| CvtkInformationIterator | Iterates over keys of an information object |
| CvtkInformationKeyLookup | Find vtkInformationKeys from name and location strings |
| CvtkInformationVector | Store zero or more vtkInformation instances |
| ►CvtkInitialValueProblemSolver | Integrate a set of ordinary differential equations (initial value problem) in time |
| CvtkRungeKutta2 | Integrate an initial value problem using 2nd order Runge-Kutta method |
| CvtkRungeKutta4 | Integrate an initial value problem using 4th order Runge-Kutta method |
| CvtkRungeKutta45 | Integrate an initial value problem using 5th order Runge-Kutta method with adaptive stepsize control |
| ►CvtkInputStream | Wraps a binary input stream with a VTK interface |
| CvtkBase64InputStream | Reads base64-encoded input from a stream |
| CvtkInstantiator | Create an instance of any VTK class from its name |
| ►CvtkInteractorObserver | Abstract superclass for classes observing events invoked by vtkRenderWindowInteractor |
| ►Cvtk3DWidget | Abstract superclass for 3D widgets |
| CvtkBoxWidget | Orthogonal hexahedron 3D widget |
| CvtkBrokenLineWidget | 3D widget for manipulating a broken line |
| CvtkImageCroppingRegionsWidget | Widget for cropping an image |
| CvtkImageTracerWidget | 3D widget for tracing on planar props |
| CvtkLineWidget | 3D widget for manipulating a line |
| CvtkPointWidget | Position a point in 3D space |
| ►CvtkPolyDataSourceWidget | Abstract PolyDataSource-based 3D widget |
| CvtkImagePlaneWidget | 3D widget for reslicing image data |
| CvtkImplicitPlaneWidget | 3D widget for manipulating an infinite plane |
| CvtkPlaneWidget | 3D widget for manipulating a finite plane |
| CvtkSphereWidget | 3D widget for manipulating a sphere |
| CvtkSplineWidget | 3D widget for manipulating a spline |
| ►CvtkAbstractWidget | Define the API for widget / widget representation |
| CvtkAffineWidget | Perform affine transformations |
| CvtkAngleWidget | Measure the angle between two rays (defined by three points) |
| CvtkAxesTransformWidget | 3D widget for performing 3D transformations around an axes |
| CvtkBiDimensionalWidget | Measure the bi-dimensional lengths of an object |
| ►CvtkBorderWidget | Place a border around a 2D rectangular region |
| CvtkCameraWidget | 2D widget for saving a series of camera views |
| CvtkCaptionWidget | Widget for placing a caption (text plus leader) |
| CvtkLogoWidget | 2D widget for placing and manipulating a logo |
| CvtkPlaybackWidget | 2D widget for controlling a playback stream |
| CvtkProgressBarWidget | 2D widget for placing and manipulating a progress bar |
| CvtkScalarBarWidget | 2D widget for manipulating a scalar bar |
| CvtkTextWidget | Widget for placing text on overlay plane |
| CvtkBoxWidget2 | 3D widget for manipulating a box |
| CvtkButtonWidget | Activate an n-state button |
| CvtkCenteredSliderWidget | Set a value by manipulating a slider |
| CvtkCheckerboardWidget | Interactively set the number of divisions in 2D image checkerboard |
| CvtkCompassWidget | Set a value by manipulating something |
| CvtkContinuousValueWidget | Set a value by manipulating something |
| CvtkContourWidget | Create a contour with a set of points |
| CvtkDistanceWidget | Measure the distance between two points |
| CvtkFinitePlaneWidget | 3D widget for manipulating a finite plane |
| CvtkHandleWidget | General widget for moving handles |
| ►CvtkHoverWidget | Invoke a vtkTimerEvent when hovering |
| CvtkBalloonWidget | Popup text balloons above instance of vtkProp when hovering occurs |
| CvtkImplicitCylinderWidget | 3D widget for manipulating an infinite cylnder |
| CvtkImplicitPlaneWidget2 | 3D widget for manipulating an infinite plane |
| CvtkLineWidget2 | 3D widget for manipulating a finite, straight line |
| CvtkParallelopipedWidget | Widget to manipulate 3D parallelopipeds |
| CvtkPolyLineWidget | Widget for vtkPolyLineRepresentation |
| CvtkRectilinearWipeWidget | Interactively control an instance of vtkImageRectilinearWipe filter |
| CvtkResliceCursorWidget | Represent a reslice cursor |
| CvtkSeedWidget | Place multiple seed points |
| CvtkSliderWidget | Set a value by manipulating a slider |
| CvtkSphereWidget2 | 3D widget for manipulating a point on a sphere |
| CvtkSplineWidget2 | Widget for vtkSplineRepresentation |
| CvtkTensorProbeWidget | Widget to probe tensors on a polyline |
| CvtkInteractorEventRecorder | Record and play VTK events passing through a vtkRenderWindowInteractor |
| ►CvtkInteractorStyle | Provide event-driven interface to the rendering window (defines trackball mode) |
| CvtkContextInteractorStyle | An interactor for chart views |
| CvtkInteractorStyle3D | Extends interaction to support 3D input |
| CvtkInteractorStyleDrawPolygon | Draw polygon during mouse move |
| CvtkInteractorStyleFlight | Flight motion routines |
| CvtkInteractorStyleJoystickActor | Manipulate objects in the scene independently of one another |
| CvtkInteractorStyleJoystickCamera | Interactive manipulation of the camera |
| ►CvtkInteractorStyleRubberBand2D | A rubber band interactor for a 2D view |
| CvtkInteractorStyleAreaSelectHover | An interactor style for an area tree view |
| CvtkInteractorStyleRubberBandZoom | Zoom in by amount indicated by rubber band box |
| ►CvtkInteractorStyleSwitchBase | Dummy interface class |
| ►CvtkInteractorStyleSwitch | Class to swap between interactory styles |
| CvtkInteractorStyleTrackball | Trackball motion control |
| CvtkInteractorStyleTerrain | Manipulate camera in scene with natural view up (e.g., terrain) |
| CvtkInteractorStyleTrackballActor | Manipulate objects in the scene independent of each other |
| ►CvtkInteractorStyleTrackballCamera | Interactive manipulation of the camera |
| CvtkGeoInteractorStyle | Interaction for a globe |
| ►CvtkInteractorStyleImage | Interactive manipulation of the camera specialized for images |
| CvtkInteractorStyleTreeMapHover | An interactor style for a tree map view |
| CvtkInteractorStyleMultiTouchCamera | Multitouch manipulation of the camera |
| CvtkInteractorStyleRubberBand3D | A rubber band interactor for a 3D view |
| CvtkInteractorStyleRubberBandPick | Like TrackBallCamera, but this can pick props underneath a rubber band selection rectangle |
| CvtkOSPRayTestInteractor | |
| CvtkParallelCoordinatesInteractorStyle | Interactive manipulation of the camera specialized for parallel coordinates |
| CvtkInteractorStyleUnicam | Unicam navigation style |
| CvtkInteractorStyleUser | Customizable interaction routines |
| CvtkOrientationMarkerWidget | 2D widget for manipulating a marker prop |
| CvtkXYPlotWidget | 2D widget for manipulating a XY plot |
| ►CvtkInterpolationKernel | Base class for interpolation kernels |
| ►CvtkGeneralizedKernel | Flexible, general interpolation kernels |
| CvtkEllipsoidalGaussianKernel | Ellipsoidal Gaussian interpolation kernel |
| CvtkGaussianKernel | Spherical Gaussian interpolation kernel |
| CvtkLinearKernel | Linear interpolation kernel |
| CvtkProbabilisticVoronoiKernel | Interpolate from the weighted closest point |
| CvtkShepardKernel | Shepard method interpolation kernel |
| ►CvtkSPHKernel | Family of SPH interpolation kernels |
| CvtkSPHCubicKernel | Cubic SPH interpolation kernel |
| CvtkSPHQuarticKernel | Quartic SPH interpolation kernel |
| CvtkSPHQuinticKernel | Quintic SPH interpolation kernel |
| CvtkWendlandQuinticKernel | Quintic SPH interpolation kernel |
| CvtkVoronoiKernel | Voronoi interpolation kernel |
| CvtkKdNode | This class represents a single spatial region in an 3D axis aligned binary spatial partitioning |
| ►CvtkKMeansDistanceFunctor | Measure distance from k-means cluster centers |
| CvtkKMeansDistanceFunctorCalculator | Measure distance from k-means cluster centers using a user-specified expression |
| ►CvtkLabelHierarchyIterator | Iterator over vtkLabelHierarchy |
| CvtkLabelHierarchyCompositeIterator | Iterator over sub-iterators |
| ►CvtkLabelRenderStrategy | Superclass for label rendering implementations |
| CvtkFreeTypeLabelRenderStrategy | Renders labels with freetype |
| CvtkQtLabelRenderStrategy | Renders labels with Qt |
| ►CvtkLight | Virtual light for 3D rendering |
| CvtkExternalLight | Virtual light object for tweaking existing lights in an external 3D rendering context |
| CvtkOpenGLLight | OpenGL light |
| CvtkOpenGLLight | OpenGL light |
| CvtkRIBLight | RIP Light |
| CvtkLightingHelper | Helper to assist in simulating lighting similar to default OpenGL pipeline |
| CvtkLightKit | Simple but quality lighting kit |
| ►CvtkLineIntegralConvolution2D | GPU-based implementation of Line Integral Convolution (LIC) |
| CvtkPLineIntegralConvolution2D | Parallel part of GPU-based implementation of Line Integral Convolution (LIC) |
| CvtkLineIntegralConvolution2D | GPU-based implementation of Line Integral Convolution (LIC) |
| ►CvtkLocator | Abstract base class for objects that accelerate spatial searches |
| ►CvtkAbstractCellLocator | Abstract base class for locators which find cells |
| CvtkCellLocator | Octree-based spatial search object to quickly locate cells |
| CvtkCellTreeLocator | 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 |
| CvtkModifiedBSPTree | Generate axis aligned BBox tree for raycasting and other Locator based searches |
| CvtkOBBTree | Generate oriented bounding box (OBB) tree |
| ►CvtkAbstractPointLocator | Abstract class to quickly locate points in 3-space |
| ►CvtkIncrementalPointLocator | Abstract class in support of both point location and point insertion |
| CvtkIncrementalOctreePointLocator | Incremental octree in support of both point location and point insertion |
| ►CvtkPointLocator | Quickly locate points in 3-space |
| ►CvtkMergePoints | Merge exactly coincident points |
| CvtkSMPMergePoints | Class designed to help with merging of points in parallel |
| CvtkNonMergingPointLocator | Direct / check-free point insertion |
| CvtkKdTreePointLocator | Class to quickly locate points in 3-space |
| CvtkOctreePointLocator | Octree spatial decomposition of a set of points |
| CvtkStaticPointLocator | Quickly locate points in 3-space |
| ►CvtkKdTree | Kd-tree spatial decomposition of a set of points |
| CvtkPKdTree | Build a k-d tree decomposition of a list of points |
| CvtkLSDynaPart | |
| CvtkLSDynaPartCollection | |
| CvtkMarkerUtilities | Utilities for generating marker images |
| CvtkMath | Performs common math operations |
| ►CvtkMathTextUtilities | Abstract interface to equation rendering |
| CvtkMatplotlibMathTextUtilities | Access to MatPlotLib MathText rendering |
| CvtkMatlabEngineInterface | This class defines a VTK inteface to the MathWorks Matlab Engine |
| CvtkMatlabMexAdapter | This is a utility class to convert VTK array data to and from the Matlab mxArray format |
| CvtkMatrix3x3 | Represent and manipulate 3x3 transformation matrices |
| CvtkMatrix4x4 | Represent and manipulate 4x4 transformation matrices |
| CvtkMeanValueCoordinatesInterpolator | Compute interpolation computes for closed triangular mesh |
| CvtkMedicalImageProperties | Some medical image properties |
| CvtkMergeCells | Merges any number of vtkDataSets back into a single vtkUnstructuredGrid |
| CvtkMINCImageAttributes | A container for a MINC image header |
| CvtkModelMetadata | This class encapsulates the metadata that appear in mesh-based file formats but do not appear in vtkUnstructuredGrid |
| CvtkMPI4PyCommunicator | Class for bridging MPI4Py with vtkMPICommunicator |
| CvtkMPIEventLog | Class for logging and timing |
| ►CvtkMultiProcessController | Multiprocessing communication superclass |
| CvtkDummyController | Dummy controller for single process applications |
| CvtkMPIController | Process communication using MPI |
| CvtkSocketController | Process communication using Sockets |
| CvtkMultiThreader | A class for performing multithreaded execution |
| CvtkMutableGraphHelper | Helper class for building a directed or directed graph |
| CvtkMutexLock | Mutual exclusion locking class |
| CvtkNamedColors | A class holding colors and their names |
| CvtkNIFTIImageHeader | Store NIfTI header information |
| CvtkObjectFactory | Abstract base class for vtkObjectFactories |
| CvtkObjectIdMap | Class used to assign Id to any VTK object and be able to retreive it base on its id |
| CvtkObserverMediator | Manage contention for cursors and other resources |
| CvtkOctreePointLocatorNode | Octree node that has 8 children each of equal size |
| ►CvtkOpenGLBufferObject | OpenGL buffer object |
| CvtkOpenGLIndexBufferObject | OpenGL vertex buffer object |
| CvtkOpenGLVertexBufferObject | |
| CvtkOpenGLFXAAFilter | Perform FXAA antialiasing on the current framebuffer |
| ►CvtkOpenGLGL2PSHelper | Helper functionality for GL2PS exporting |
| CvtkOpenGLGL2PSHelperImpl | VtkOpenGLGL2PSHelper override implementation |
| CvtkOpenGLHardwareSupport | OpenGL rendering window |
| CvtkOpenGLImageAlgorithmHelper | Help image algorithms use the GPU |
| CvtkOpenGLLightMonitor | Tracks state of OpenGL model-view and projection matrices |
| CvtkOpenGLModelViewProjectionMonitor | Tracks state of OpenGL model-view and projection matrices |
| CvtkOpenGLRenderUtilities | OpenGL rendering utility functions |
| CvtkOpenGLShaderCache | Manage Shader Programs within a context |
| CvtkOpenGLVertexArrayObject | The VertexArrayObject class uses, or emulates, vertex array objects |
| CvtkOpenGLVolumeGradientOpacityTable | |
| CvtkOpenGLVolumeOpacityTable | |
| CvtkOpenGLVolumeRGBTable | |
| CvtkOrderedTriangulator | Helper class to generate triangulations |
| CvtkOutEdgeIterator | Iterates through all outgoing edges from a vertex |
| ►CvtkOutputStream | Wraps a binary output stream with a VTK interface |
| CvtkBase64OutputStream | Writes base64-encoded output to a stream |
| ►CvtkOutputWindow | Base class for writing debug output to a console |
| CvtkAndroidOutputWindow | Win32 Specific output window class |
| ►CvtkFileOutputWindow | File Specific output window class |
| CvtkXMLFileOutputWindow | XML File Specific output window class |
| CvtkStringOutputWindow | File Specific output window class |
| CvtkWin32OutputWindow | Win32 Specific output window class |
| CvtkWin32ProcessOutputWindow | Win32-specific output window class |
| CvtkOverrideInformation | Factory object override information |
| ►CvtkPainter | Abstract class for drawing poly data |
| ►CvtkClipPlanesPainter | Abstract class defining interface for painter that manages clipping |
| CvtkOpenGLClipPlanesPainter | Painter that manages clipping |
| ►CvtkCompositePainter | Painter that can be inserted before any vtkDataSet painting chain to handle composite datasets |
| CvtkOpenGLCompositePainter | Composite painter for OpenGL |
| ►CvtkDefaultPainter | Sets up a default chain of painters |
| CvtkSurfaceLICDefaultPainter | VtkDefaultPainter replacement that inserts the vtkSurfaceLICPainter at the correct position in the painter chain |
| ►CvtkDisplayListPainter | Abstract superclass for painter that builds/uses display lists |
| CvtkOpenGLDisplayListPainter | Display list painter using OpenGL |
| ►CvtkPolyDataPainter | Abstract class for drawing poly data |
| CvtkChooserPainter | Painter that selects painters to render primitives |
| ►CvtkCoincidentTopologyResolutionPainter | Painter that resolves conicident topology |
| CvtkOpenGLCoincidentTopologyResolutionPainter | Implementation for vtkCoincidentTopologyResolutionPainter using OpenGL |
| ►CvtkLightingPainter | Abstract class defining interface for painter that can handle lightin |
| CvtkOpenGLLightingPainter | Painter that manages lighting |
| ►CvtkPrimitivePainter | Superclass for class that handle single privmitives |
| CvtkLinesPainter | Painter that paints lines |
| CvtkPointsPainter | This painter paints verts |
| CvtkPolygonsPainter | This painter paints polygons |
| CvtkTStripsPainter | Painter for triangle strips |
| ►CvtkRepresentationPainter | Painter that handles representation |
| CvtkOpenGLRepresentationPainter | Painter handling representation using OpenGL |
| ►CvtkStandardPolyDataPainter | A standard implementation of vtkPolyDataPainter |
| CvtkHardwareSelectionPolyDataPainter | Painter used to render polydata for selection passes |
| CvtkValuePainter | Painter that renders arrays encoded into pixel colors |
| ►CvtkScalarsToColorsPainter | Painter that converts scalars to colors |
| CvtkOpenGLScalarsToColorsPainter | Implementation of vtkScalarsToColorsPainter for OpenGL |
| ►CvtkSurfaceLICPainter | Painter that performs LIC on the surface of arbitrary geometry |
| CvtkPSurfaceLICPainter | Parallel parts of the vtkSurfaceLICPainter |
| ►CvtkPainterDeviceAdapter | An adapter between a vtkPainter and a rendering device |
| CvtkOpenGLPainterDeviceAdapter | An adapter between a vtkPainter and a rendering device |
| ►CvtkParallelRenderManager | An object to control parallel rendering |
| CvtkCompositeRenderManager | An object to control sort-last parallel rendering |
| CvtkImageRenderManager | An object to control sort-first parallel rendering |
| CvtkParallelTimer | Provides ditributed log functionality |
| ►CvtkParametricFunction | Abstract interface for parametric functions |
| CvtkParametricBohemianDome | Generate a Bohemian dome |
| CvtkParametricBour | Generate Bour's minimal surface |
| CvtkParametricBoy | Generate Boy's surface |
| CvtkParametricCatalanMinimal | Generate Catalan's minimal surface |
| CvtkParametricConicSpiral | Generate conic spiral surfaces that resemble sea-shells |
| CvtkParametricCrossCap | Generate a cross-cap |
| CvtkParametricDini | Generate Dini's surface |
| CvtkParametricEllipsoid | Generate an ellipsoid |
| CvtkParametricEnneper | Generate Enneper's surface |
| CvtkParametricFigure8Klein | Generate a figure-8 Klein bottle |
| CvtkParametricHenneberg | Generate Henneberg's minimal surface |
| CvtkParametricKlein | Generates a "classical" representation of a Klein bottle |
| CvtkParametricKuen | Generate Kuens' surface |
| CvtkParametricMobius | Generate a Mobius strip |
| CvtkParametricPluckerConoid | Generate Plucker's conoid surface |
| CvtkParametricPseudosphere | Generate a pseudosphere |
| CvtkParametricRandomHills | Generate a surface covered with randomly placed hills |
| CvtkParametricRoman | Generate Steiner's Roman Surface |
| CvtkParametricSpline | Parametric function for 1D interpolating splines |
| CvtkParametricSuperEllipsoid | Generate a superellipsoid |
| CvtkParametricSuperToroid | Generate a supertoroid |
| CvtkParametricTorus | Generate a torus |
| CvtkPDirectory | VtkPDirectory provides a portable way of finding the names of the files in a system directory where process 0 finds the information and broadcasts it to other processes |
| CvtkPen | Pen that draws the outlines of shapes drawn by vtkContext2D |
| CvtkPeriodicTable | Access to information about the elements |
| CvtkPickingManager | Class defines API to manage the picking process |
| CvtkPipelineSize | Compute the memory required by a pipeline |
| CvtkPistonScalarsColors | Color Mapping for piston results |
| CvtkPixelBufferObject | Abstracts an OpenGL pixel buffer object |
| CvtkPixelBufferObject | Abstracts an OpenGL pixel buffer object |
| ►CvtkPointPlacer | Abstract interface to translate 2D display positions to world coordinates |
| CvtkBoundedPlanePointPlacer | Placer that constrains a handle to a finite plane |
| CvtkCellCentersPointPlacer | Snaps points at the center of a cell |
| CvtkClosedSurfacePointPlacer | PointPlacer to constrain validity within a set of convex planes |
| CvtkFocalPlanePointPlacer | |
| CvtkImageActorPointPlacer | Converts 2D display positions to world positions such that they lie on an ImageActor |
| ►CvtkPolyDataPointPlacer | Base class to place points given constraints on polygonal data |
| CvtkPolygonalSurfacePointPlacer | Place points on the surface of polygonal data |
| CvtkTerrainDataPointPlacer | Place points on terrain data |
| ►CvtkPoints | Represent and manipulate 3D points |
| CvtkPointsProjectedHull | Convex hull of the orthogonal projection of the vtkPoints in the 3 coordinate directions |
| CvtkPoints2D | Represent and manipulate 2D points |
| CvtkPolynomialSolversUnivariate | Polynomial solvers |
| CvtkPriorityQueue | List of ids arranged in priority order |
| CvtkProcess | Process that can be launched by a vtkMultiProcessController |
| CvtkProcessGroup | A subgroup of processes from a communicator |
| ►CvtkProgressObserver | Basic class to optionally replace vtkAlgorithm progress functionality |
| CvtkSMPProgressObserver | Progress observer that is thread safe |
| ►CvtkProp | Abstract superclass for all actors, volumes and annotations |
| ►CvtkActor2D | Actor that draws 2D data |
| CvtkAxisActor2D | Create an axis with tick marks and labels |
| CvtkBarChartActor | Create a bar chart from an array |
| CvtkCaptionActor2D | Draw text label associated with a point |
| CvtkCornerAnnotation | Text annotation in four corners |
| CvtkCubeAxesActor2D | Create a 2D plot of a bounding box edges - used for navigation |
| CvtkLeaderActor2D | Create a leader with optional label and arrows |
| CvtkLegendBoxActor | Draw symbols with text |
| CvtkParallelCoordinatesActor | Create parallel coordinate display from input field |
| CvtkPieChartActor | Create a pie chart from an array |
| CvtkScalarBarActor | Create a scalar bar with labels |
| CvtkSpiderPlotActor | Create a spider plot from input field |
| ►CvtkTexturedActor2D | Actor that draws 2D data with texture support |
| ►CvtkTextActor | An actor that displays text |
| CvtkOpenGLTextActor | VtkTextActor override |
| CvtkScaledTextActor | Create text that will scale as needed |
| CvtkXYPlotActor | Generate an x-y plot from input dataset(s) or field data |
| ►CvtkContextActor | VtkProp derived object |
| CvtkOpenGLContextActor | VtkProp derived object |
| CvtkOpenGLContextActor | VtkProp derived object |
| CvtkLegendScaleActor | Annotate the render window with scale and distance information |
| ►CvtkProp3D | 3D object for placement in a rendered scene |
| ►CvtkActor | Object (geometry & properties) in a rendered scene |
| CvtkAxisActor | Create an axis with tick marks and labels |
| CvtkCubeAxesActor | Create a plot of a bounding box edges - used for navigation |
| ►CvtkFollower | Subclass of actor that always faces the camera |
| CvtkAxisFollower | Subclass of vtkFollower that ensures that data is always parallel to the axis defined by a vtkAxisActor |
| CvtkLODActor | Actor that supports multiple levels of detail |
| CvtkOpenGLActor | OpenGL actor |
| CvtkOpenGLActor | OpenGL actor |
| CvtkPolarAxesActor | Create an actor of a polar axes - |
| CvtkQuadricLODActor | Specific level-of-detail strategy using the quadric clustering decimation algorithm |
| CvtkAnnotatedCubeActor | 3D cube with face labels |
| CvtkAssembly | Create hierarchies of vtkProp3Ds (transformable props) |
| CvtkAxesActor | 3D axes representation |
| ►CvtkBillboardTextActor3D | Renders pixel-aligned text, facing the camera, anchored at a 3D point |
| CvtkOpenGLBillboardTextActor3D | Handles GL2PS capture of billboard text |
| CvtkCameraActor | Frustum to represent a camera |
| ►CvtkImageSlice | Image in a 3D scene |
| CvtkImageActor | Draw an image in a rendered 3D scene |
| CvtkImageStack | Manages a stack of composited images |
| CvtkLightActor | Cone and a frustum to represent a spotlight |
| CvtkLODProp3D | Level of detail 3D prop |
| ►CvtkProp3DFollower | VtkProp3D that always faces the camera |
| CvtkProp3DAxisFollower | Subclass of vtkProp3DFollower that ensures that data is always parallel to the axis defined by a vtkAxisActor |
| CvtkResliceCursorActor | Represent a reslice cursor |
| ►CvtkTextActor3D | An actor that displays text |
| CvtkOpenGLTextActor3D | OpenGL2 override for vtkTextActor3D |
| CvtkVolume | Volume (data & properties) in a rendered scene |
| CvtkPropAssembly | Create hierarchies of props |
| ►CvtkWidgetRepresentation | Abstract class defines interface between the widget and widget representation classes |
| ►CvtkAffineRepresentation | Abstract class for representing affine transformation widgets |
| CvtkAffineRepresentation2D | Represent 2D affine transformations |
| ►CvtkAngleRepresentation | Represent the vtkAngleWidget |
| CvtkAngleRepresentation2D | Represent the vtkAngleWidget |
| CvtkAngleRepresentation3D | Represent the vtkAngleWidget |
| CvtkAxesTransformRepresentation | Represent the vtkAxesTransformWidget |
| CvtkBalloonRepresentation | Represent the vtkBalloonWidget |
| ►CvtkBiDimensionalRepresentation | Represent the vtkBiDimensionalWidget |
| CvtkBiDimensionalRepresentation2D | Represent the vtkBiDimensionalWidget |
| ►CvtkBorderRepresentation | Represent a vtkBorderWidget |
| CvtkCameraRepresentation | Represent the vtkCameraWidget |
| CvtkCaptionRepresentation | VtkCaptionWidget in the scene |
| CvtkLogoRepresentation | Represent the vtkLogoWidget |
| CvtkPlaybackRepresentation | Represent the vtkPlaybackWidget |
| CvtkProgressBarRepresentation | Represent a vtkProgressBarWidget |
| CvtkScalarBarRepresentation | Represent scalar bar for vtkScalarBarWidget |
| CvtkTextRepresentation | Represent text for vtkTextWidget |
| CvtkXYPlotRepresentation | Represent XY plot for vtkXYPlotWidget |
| CvtkBoxRepresentation | Class defining the representation for the vtkBoxWidget2 |
| ►CvtkButtonRepresentation | Abstract class defines the representation for a vtkButtonWidget |
| CvtkProp3DButtonRepresentation | Defines a representation for a vtkButtonWidget |
| CvtkTexturedButtonRepresentation | Defines a representation for a vtkButtonWidget |
| CvtkTexturedButtonRepresentation2D | Defines a representation for a vtkButtonWidget |
| CvtkCheckerboardRepresentation | Represent the vtkCheckerboardWidget |
| ►CvtkContinuousValueWidgetRepresentation | Provide the representation for a continuous value |
| CvtkCompassRepresentation | Provide a compass |
| ►CvtkContourRepresentation | Represent the vtkContourWidget |
| ►CvtkFocalPlaneContourRepresentation | Represent a contour drawn on the focal plane |
| CvtkOrientedGlyphFocalPlaneContourRepresentation | Contours constrained to a focal plane |
| CvtkOrientedGlyphContourRepresentation | Default representation for the contour widget |
| ►CvtkCurveRepresentation | VtkWidgetRepresentation base class for a widget that represents an curve that connects control points |
| CvtkPolyLineRepresentation | VtkWidgetRepresentation for a poly line |
| CvtkSplineRepresentation | Representation for a spline |
| ►CvtkDistanceRepresentation | Represent the vtkDistanceWidget |
| CvtkDistanceRepresentation2D | Represent the vtkDistanceWidget |
| CvtkDistanceRepresentation3D | Represent the vtkDistanceWidget |
| CvtkFinitePlaneRepresentation | Represent the vtkFinitePlaneWidget |
| ►CvtkHandleRepresentation | Abstract class for representing widget handles |
| ►CvtkAbstractPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D while maintaining a fixed orientation w.r.t the camera |
| CvtkOrientedPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D while maintaining a fixed orientation w.r.t the camera |
| ►CvtkPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D space |
| CvtkFixedSizeHandleRepresentation3D | |
| CvtkConstrainedPointHandleRepresentation | Point representation constrained to a 2D plane |
| CvtkPointHandleRepresentation2D | Represent the position of a point in display coordinates |
| CvtkPointHandleRepresentation3D | Represent the position of a point in 3D space |
| CvtkSphereHandleRepresentation | A spherical rendition of point in 3D space |
| CvtkImplicitCylinderRepresentation | Defining the representation for a vtkImplicitCylinderWidget |
| CvtkImplicitPlaneRepresentation | Class defining the representation for a vtkImplicitPlaneWidget2 |
| CvtkLineRepresentation | Class defining the representation for a vtkLineWidget2 |
| CvtkParallelopipedRepresentation | Default representation for vtkParallelopipedWidget |
| CvtkRectilinearWipeRepresentation | Represent a vtkRectilinearWipeWidget |
| ►CvtkResliceCursorRepresentation | Represent the vtkResliceCursorWidget |
| ►CvtkResliceCursorLineRepresentation | Represent the vtkResliceCursorWidget |
| CvtkResliceCursorThickLineRepresentation | Thick slab of the reslice cursor widget |
| CvtkSeedRepresentation | Represent the vtkSeedWidget |
| ►CvtkSliderRepresentation | Abstract class defines the representation for a vtkSliderWidget |
| CvtkCenteredSliderRepresentation | Provide the representation for a vtkCenteredSliderWidget |
| CvtkSliderRepresentation2D | Provide the representation for a vtkSliderWidget with a 3D skin |
| CvtkSliderRepresentation3D | Provide the representation for a vtkSliderWidget with a 3D skin |
| CvtkSphereRepresentation | Class defining the representation for the vtkSphereWidget2 |
| ►CvtkTensorProbeRepresentation | Abstract class that serves as a representation for vtkTensorProbeWidget |
| CvtkEllipsoidTensorProbeRepresentation | A concrete implementation of vtkTensorProbeRepresentation that renders tensors as ellipoids |
| ►CvtkProperty | Represent surface properties of a geometric object |
| CvtkOpenGLProperty | OpenGL property |
| CvtkOpenGLProperty | OpenGL property |
| CvtkRIBProperty | RIP Property |
| CvtkProperty2D | Represent surface properties of a 2D image |
| CvtkPSystemTools | System tools for file system introspection |
| CvtkPUnstructuredGridConnectivity | VtkPUnstructuredGridConnectivity implements functionality for generating ghost zones for a distributed unstructured grid |
| CvtkQtInitialization | Initializes a Qt application |
| CvtkQtTimePointUtility | Performs common time operations |
| CvtkQuadratureSchemeDefinition | An Elemental data type that holds a definition of a numerical quadrature scheme |
| CvtkQuaternionInterpolator | Interpolate a quaternion |
| CvtkRAdapter | This is a utility class to convert VTK array data and VTK tables to and from Gnu R S expression (SEXP) data structures |
| ►CvtkRandomSequence | Sequence of random numbers |
| ►CvtkGaussianRandomSequence | Gaussian sequence of pseudo random numbers |
| CvtkBoxMuellerRandomSequence | Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform |
| CvtkMersenneTwister | Generator for Mersenne Twister pseudorandom numbers |
| CvtkMinimalStandardRandomSequence | Park and Miller Sequence of pseudo random numbers |
| ►CvtkRayCastImageDisplayHelper | Helper class that draws the image to the screen |
| CvtkOpenGLRayCastImageDisplayHelper | OpenGL subclass that draws the image to the screen |
| CvtkOpenGLRayCastImageDisplayHelper | OpenGL subclass that draws the image to the screen |
| CvtkReebGraphSimplificationMetric | Abstract class for custom Reeb graph simplification metric design |
| CvtkReferenceCount | Obsolete / empty subclass of object |
| CvtkRenderbuffer | Storage for FBO's |
| CvtkRenderbuffer | Storage for FBO's |
| CvtkRendererDelegate | Render the props of a vtkRenderer |
| ►CvtkRenderPass | Perform part of the rendering of a vtkRenderer |
| CvtkCameraPass | Implement the camera render pass |
| CvtkCameraPass | Implement the camera render pass |
| CvtkClearRGBPass | Paint in the color buffer |
| CvtkClearRGBPass | Paint in the color buffer |
| CvtkClearZPass | Clear the depth buffer with a given value |
| CvtkClearZPass | Clear the depth buffer with a given value |
| CvtkClientServerCompositePass | VtkClientServerCompositePass is a render-pass that can handle client-server image delivery |
| CvtkCompositeRGBAPass | Blend RGBA buffers of processes |
| CvtkCompositeZPass | Merge depth buffers of processes |
| ►CvtkDefaultPass | Implement the basic render passes |
| CvtkLightingMapPass | TO DO |
| ►CvtkOpaquePass | Render the opaque geometry with property key filtering |
| CvtkValuePass | Render opaque objects with the vtkValuePainter |
| CvtkOpaquePass | Render the opaque geometry with property key filtering |
| CvtkOverlayPass | Render the overlay geometry with property key filtering |
| CvtkOverlayPass | Render the overlay geometry with property key filtering |
| CvtkTranslucentPass | Render the translucent polygonal geometry with property key filtering |
| CvtkTranslucentPass | Render the translucent polygonal geometry with property key filtering |
| CvtkValuePass | Render opaque objects with the vtkValuePainter |
| CvtkVolumetricPass | Render the volumetric geometry with property key filtering |
| CvtkVolumetricPass | Render the volumetric geometry with property key filtering |
| CvtkDefaultPass | Implement the basic render passes |
| ►CvtkDepthPeelingPass | Implement an Order Independent Transparency render pass |
| CvtkDualDepthPeelingPass | Implements the dual depth peeling algorithm |
| CvtkHiddenLineRemovalPass | RenderPass for HLR |
| ►CvtkImageProcessingPass | Convenient class for post-processing passes |
| ►CvtkDepthImageProcessingPass | Convenient class for post-processing passes |
| CvtkDepthOfFieldPass | Implement a post-processing DOF blur pass |
| CvtkEDLShading | Implement an EDL offscreen shading |
| CvtkPointFillPass | Implement a post-processing fillpass |
| CvtkGaussianBlurPass | Implement a post-processing Gaussian blur render pass |
| CvtkGaussianBlurPass | Implement a post-processing Gaussian blur render pass |
| CvtkSobelGradientMagnitudePass | Implement a post-processing edge detection with a Sobel gradient magnitude render pass |
| CvtkSobelGradientMagnitudePass | Implement a post-processing edge detection with a Sobel gradient magnitude render pass |
| CvtkImageProcessingPass | Convenient class for post-processing passes |
| CvtkLightsPass | Implement the lights render pass |
| CvtkLightsPass | Implement the lights render pass |
| ►CvtkOpenGLRenderPass | Abstract render pass with shader modifications |
| CvtkDepthPeelingPass | Implement an Order Independent Transparency render pass |
| CvtkHiddenLineRemovalPass | RenderPass for HLR |
| CvtkOSPRayPass | Render pass that uses OSPRay instead of GL |
| CvtkRenderStepsPass | Execute render passes sequentially |
| CvtkSequencePass | Execute render passes sequentially |
| CvtkSequencePass | Execute render passes sequentially |
| CvtkShadowMapBakerPass | Implement a builder of shadow map pass |
| CvtkShadowMapBakerPass | Implement a builder of shadow map pass |
| CvtkShadowMapPass | Implement a shadow mapping render pass |
| CvtkShadowMapPass | Implement a shadow mapping render pass |
| CvtkSSAAPass | Implement Screen Space Anti Aliasing pass |
| CvtkValuePasses | Top level pass to render scene for ValuePainter |
| CvtkRenderWidget | |
| ►CvtkRenderWindowInteractor | Platform-independent render window interaction including picking and frame rate control |
| CQVTKInteractor | |
| CvtkAndroidRenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| CvtkCocoaRenderWindowInteractor | Implements Cocoa specific functions required by vtkRenderWindowInteractor |
| CvtkCocoaRenderWindowInteractor | Implements Cocoa specific functions required by vtkRenderWindowInteractor |
| CvtkGenericRenderWindowInteractor | Platform-independent programmable render window interactor |
| CvtkIOSRenderWindowInteractor | Implements IOS specific functions required by vtkRenderWindowInteractor |
| ►CvtkRenderWindowInteractor3D | Adds support for 3D events to vtkRenderWindowInteractor |
| CvtkOculusRenderWindowInteractor | Implements Oculus specific functions required by vtkRenderWindowInteractor |
| CvtkOpenVRRenderWindowInteractor | Implements OpenVR specific functions required by vtkRenderWindowInteractor |
| CvtkWin32RenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| CvtkWin32RenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| ►CvtkXRenderWindowInteractor | X event driven interface for a RenderWindow |
| CvtkXRenderWindowTclInteractor | TCL event driven interface for a RenderWindow |
| CvtkXRenderWindowTclInteractor | TCL event driven interface for a RenderWindow |
| CvtkXRenderWindowInteractor | X event driven interface for a RenderWindow |
| CvtkResliceCursor | Geometry for a reslice cursor |
| CvtkResliceImageViewerMeasurements | Manage measurements on a resliced image |
| CvtkRInterface | This class defines a VTK interface to an embedded GNU R intepreter instance |
| ►CvtkRowQuery | Abstract interface for queries that return row-oriented results |
| ►CvtkSQLQuery | Executes an sql query and retrieves results |
| CvtkMySQLQuery | VtkSQLQuery implementation for MySQL databases |
| CvtkODBCQuery | VtkSQLQuery implementation for ODBC connections to databases |
| CvtkPostgreSQLQuery | VtkSQLQuery implementation for PostgreSQL databases |
| CvtkSQLiteQuery | VtkSQLQuery implementation for SQLite databases |
| ►CvtkScalarsToColors | Superclass for mapping scalar values to colors |
| ►CvtkColorTransferFunction | Defines a transfer function for mapping a property to an RGB color value |
| CvtkDiscretizableColorTransferFunction | Combination of vtkColorTransferFunction and vtkLookupTable |
| ►CvtkLookupTable | Map scalar values into colors via a lookup table |
| CvtkLogLookupTable | Map scalars into colors using log (base 10) scale |
| CvtkLookupTableWithEnabling | A lookup table that allows for an optional array to be provided that specifies which scalars to "enable" and which to "disable" |
| CvtkWindowLevelLookupTable | Map scalar values into colors or colors to scalars; generate color table |
| ►CvtkScalarTree | Organize data according to scalar values (used to accelerate contouring operations) |
| CvtkSimpleScalarTree | Organize data according to scalar values (used to accelerate contouring operations) |
| CvtkSpanSpace | Organize data according to scalar span space |
| CvtkScenePicker | Picks an entire viewport at one shot |
| CvtkSelectionNode | A node in a selection tree |
| CvtkShader | Vertex or Fragment shader, combined into a ShaderProgram |
| CvtkShader2 | GLSL Shader |
| ►CvtkShaderDeviceAdapter2 | Adapter to pass generic vertex attributes to the rendering pipeline |
| CvtkGLSLShaderDeviceAdapter2 | Adapter to pass generic vertex attributes to the rendering pipeline to be used in a vtkShaderProgram2 |
| CvtkShaderProgram | The ShaderProgram uses one or more Shader objects |
| CvtkShaderProgram2 | GLSL Program |
| CvtkSILBuilder | Helper class to build a SIL i.e |
| CvtkSliceCubes | Generate isosurface(s) from volume four slices at a time |
| ►CvtkSocket | BSD socket encapsulation |
| CvtkClientSocket | Encapsulates a client socket |
| CvtkServerSocket | Encapsulate a socket that accepts connections |
| ►CvtkSortDataArray | Several methods for sorting VTK arrays |
| CvtkSortFieldData | Method for sorting field data |
| CvtkSortFileNames | Group and sort a set of filenames |
| ►CvtkSpline | Spline abstract class for interpolating splines |
| CvtkCardinalSpline | Computes an interpolating spline using a a Cardinal basis |
| CvtkKochanekSpline | Computes an interpolating spline using a Kochanek basis |
| CvtkSCurveSpline | Computes an interpolating spline using a a SCurve basis |
| ►CvtkSQLDatabase | Maintain a connection to an sql database |
| CvtkMySQLDatabase | Maintain a connection to a MySQL database |
| CvtkODBCDatabase | Maintain an ODBC connection to a SQL database |
| CvtkPostgreSQLDatabase | Maintain a connection to a PostgreSQL database |
| CvtkSQLiteDatabase | Maintain a connection to an SQLite database |
| CvtkSQLDatabaseSchema | Represent an SQL database schema |
| CvtkStreamingTessellator | An algorithm that refines an initial simplicial tessellation using edge subdivision |
| ►CvtkStringToImage | Base class for classes that render supplied text to an image |
| CvtkFreeTypeStringToImage | Uses Qt to render the supplied text to an image |
| CvtkQtStringToImage | Uses Qt to render the supplied text to an image |
| CvtkTextRendererStringToImage | Uses vtkTextRenderer to render the supplied text to an image |
| CvtkStructuredData | Singleton class for topologically regular data |
| CvtkStructuredExtent | Helper class to aid working with structured extents |
| CvtkStructuredImplicitConnectivity | Distributed structured dataset that is implicitly connected among partitions without abutting |
| CvtkSubGroup | Scalable collective communication for a subset of members of a parallel VTK application |
| ►CvtkSurfaceLICComposite | This class decomposes the image space and shuffles image space data onto the new decomposition with the necessary guard cells to prevent artifacts at the decomposition boundaries |
| CvtkPSurfaceLICComposite | This class decomposes the image space and shuffles image space data onto the new decomposition with the necessary guard cells to prevent artifacts at the decomposition boundaries |
| CvtkSurfaceLICComposite | This class decomposes the image space and shuffles image space data onto the new decomposition with the necessary guard cells to prevent artifacts at the decomposition boundaries |
| ►CvtkSurfaceLICInterface | Public API for surface lic parameters arbitrary geometry |
| CvtkPSurfaceLICInterface | Parallel parts of the vtkSurfaceLICInterface |
| ►CvtkSynchronizedRenderers | Synchronizes renderers across processes |
| CvtkClientServerSynchronizedRenderers | VtkClientServerSynchronizedRenderers is a vtkSynchronizedRenderers subclass designed to be used in 2 processes, client-server mode |
| CvtkCompositedSynchronizedRenderers | VtkCompositedSynchronizedRenderers is vtkSynchronizedRenderers that uses vtkCompositer to composite the images on the root node |
| CvtkSynchronizedRenderWindows | Synchronizes render windows across processess |
| ►CvtkTDxDevice | API to access a 3DConnexion input device |
| CvtkTDxMacDevice | Implementation of vtkTDxDevice on Mac |
| CvtkTDxUnixDevice | Implementation of vtkTDxDevice on Unix |
| CvtkTDxWinDevice | Implementation of vtkTDxDevice on Windows |
| ►CvtkTDxInteractorStyle | Provide 3DConnexion device event-driven interface to the rendering window |
| CvtkTDxInteractorStyleCamera | Interactive manipulation of the camera with a 3DConnexion device |
| CvtkTDxInteractorStyleGeo | Interactive manipulation of the camera with a 3DConnexion device, similar to google earth |
| CvtkTDxInteractorStyleSettings | 3DConnexion device settings |
| CvtkTestNewVar | |
| ►CvtkTextCodec | Virtual class to act as an interface for all text codecs |
| CvtkASCIITextCodec | Class to read/write ascii text |
| CvtkUTF16TextCodec | Class to read/write ascii text |
| CvtkUTF8TextCodec | Class to read/write UTF-8 text |
| CvtkTextCodecFactory | Maintain a list of text codecs and return instances |
| CvtkTextProperty | Represent text properties |
| ►CvtkTextRenderer | Interface for generating images and path data from string data, using multiple backends |
| CvtkMathTextFreeTypeTextRenderer | Default implementation of vtkTextRenderer |
| CvtkTextureObject | Abstracts an OpenGL texture object |
| CvtkTextureObject | Abstracts an OpenGL texture object |
| CvtkTextureUnitManager | Allocate/free texture units |
| CvtkTextureUnitManager | Allocate/free texture units |
| CvtkThreadMessager | A class for performing inter-thread messaging |
| CvtkTimePointUtility | Performs common time operations |
| CvtkTimerLog | Timer support and logging |
| CvtkTransform2D | Describes linear transformations via a 3x3 matrix |
| CvtkTransformFeedback | Manages a TransformFeedback buffer |
| CvtkTransformInterpolator | Interpolate a series of transformation matrices |
| ►CvtkTreeIterator | Abstract class for iterator over a vtkTree |
| CvtkTreeBFSIterator | Breadth first search iterator through a vtkTree |
| CvtkTreeDFSIterator | Depth first iterator through a vtkGraph |
| CvtkTupleInterpolator | Interpolate a tuple of arbitray size |
| CvtkUniformVariables | GLSL uniform variables |
| ►CvtkUnstructuredGridVolumeRayCastFunction | Superclass for ray casting functions |
| CvtkUnstructuredGridBunykRayCastFunction | Superclass for ray casting functions |
| CvtkUnstructuredGridVolumeRayCastIterator | VtkUnstructuredGridVolumeRayCastIterator is a superclass for iterating over the intersections of a viewing ray with a group of unstructured cells |
| ►CvtkUnstructuredGridVolumeRayIntegrator | Superclass for volume ray integration functions |
| CvtkUnstructuredGridHomogeneousRayIntegrator | Performs peicewise constant ray integration |
| CvtkUnstructuredGridLinearRayIntegrator | Performs piecewise linear ray integration |
| CvtkUnstructuredGridPartialPreIntegration | Performs piecewise linear ray integration |
| CvtkUnstructuredGridPreIntegration | Performs ray integration with pre-integration tables |
| CvtkValuePassHelper | Implementation of both rendering modes of vtkValuePass for the vtkOpenGLPolyDataMapper |
| CvtkVersion | Versioning class for vtk |
| CvtkVertexListIterator | Iterates all vertices in a graph |
| ►CvtkView | The superclass for all views |
| CvtkQtView | Superclass for Qt widget-based views |
| ►CvtkRenderViewBase | A base view containing a renderer |
| CvtkContextView | View of the vtkContextScene |
| ►CvtkRenderView | A view containing a renderer |
| CvtkGeoView | A 3D geospatial view |
| CvtkGeoView2D | A 2D geospatial view |
| ►CvtkGraphLayoutView | Lays out and displays a graph |
| CvtkHierarchicalGraphView | Accepts a graph and a hierarchy - currently a tree - and provides a hierarchy-aware display |
| CvtkParallelCoordinatesView | View to be used with vtkParallelCoordinatesRepresentation |
| ►CvtkTreeAreaView | Accepts a graph and a hierarchy - currently a tree - and provides a hierarchy-aware display |
| CvtkIcicleView | Displays a tree in a stacked "icicle" view |
| CvtkTreeMapView | Displays a tree as a tree map |
| CvtkTreeRingView | Displays a tree in concentric rings |
| ►CvtkViewNode | Node within a VTK scene graph |
| ►CvtkActorNode | VtkViewNode specialized for vtkActors |
| CvtkOSPRayActorNode | Links vtkActor and vtkMapper to OSPRay |
| ►CvtkCameraNode | VtkViewNode specialized for vtkCameras |
| CvtkOSPRayCameraNode | Links vtkCamera to OSPRay |
| ►CvtkLightNode | VtkViewNode specialized for vtkLights |
| CvtkOSPRayLightNode | Links vtkLights to OSPRay |
| ►CvtkMapperNode | VtkViewNode specialized for vtkMappers |
| ►CvtkPolyDataMapperNode | VtkViewNode specialized for vtkPolyDataMappers |
| ►CvtkOSPRayPolyDataMapperNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkOSPRayCompositePolyDataMapper2Node | Links vtkActor and vtkMapper to OSPRay |
| ►CvtkVolumeMapperNode | VtkViewNode specialized for vtkVolumeMappers |
| CvtkOSPRayVolumeMapperNode | Links vtkVolumeMapper to OSPRay |
| ►CvtkRendererNode | VtkViewNode specialized for vtkRenderers |
| CvtkOSPRayRendererNode | Links vtkRenderers to OSPRay |
| ►CvtkVolumeNode | VtkViewNode specialized for vtkActors |
| CvtkOSPRayVolumeNode | Links vtkVolume and vtkMapper to OSPRay |
| ►CvtkWindowNode | VtkViewNode specialized for vtkRenderWindows |
| CvtkOSPRayWindowNode | Links vtkRendererWindows to OSPRay |
| ►CvtkViewNodeFactory | Factory that chooses vtkViewNodes to create |
| CvtkOSPRayViewNodeFactory | Matches vtk rendering classes to specific ospray ViewNode classes |
| ►CvtkViewport | Abstract specification for Viewports |
| ►CvtkRenderer | Abstract specification for renderers |
| ►CvtkOpenGLRenderer | OpenGL renderer |
| CvtkExternalOpenGLRenderer | OpenGL renderer |
| CvtkOculusRenderer | Oculus renderer |
| CvtkOpenVRRenderer | OpenVR renderer |
| CvtkOpenGLRenderer | OpenGL renderer |
| CvtkViewTheme | Sets theme colors for a graphical view |
| CvtkViewUpdater | Updates views automatically |
| ►CvtkVisibilitySort | Abstract class that can sort cell data along a viewpoint |
| CvtkCellCenterDepthSort | A simple implementation of vtkCellDepthSort |
| CvtkVoidArray | Dynamic, self-adjusting array of void* pointers |
| CvtkVolumeProperty | Common properties for rendering a volume |
| ►CvtkVolumeRayCastFunction | Superclass for ray casting functions |
| CvtkVolumeRayCastCompositeFunction | Ray function for compositing |
| CvtkVolumeRayCastIsosurfaceFunction | An isosurface ray caster for volumes |
| CvtkVolumeRayCastMIPFunction | A maximum intensity projection ray caster for volumes |
| CvtkWebApplication | Defines ParaViewWeb application interface |
| CvtkWebGLDataSet | VtkWebGLDataSet represent vertices, lines, polygons, and triangles |
| CvtkWebGLExporter | VtkWebGLExporter export the data of the scene to be used in the WebGL |
| ►CvtkWebGLObject | VtkWebGLObject represent and manipulate an WebGL object and its data |
| CvtkWebGLPolyData | PolyData representation for WebGL |
| CvtkWebGLWidget | Widget representation for WebGL |
| CvtkWebInteractionEvent | |
| CvtkWebUtilities | Collection of utility functions for ParaView Web |
| CvtkWidgetCallbackMapper | Map widget events into callbacks |
| CvtkWidgetEvent | Define widget events |
| CvtkWidgetEventTranslator | Map VTK events into widget events |
| CvtkWidgetSet | Synchronize a collection on vtkWidgets drawn on different renderwindows using the Callback - Dispatch Action mechanism |
| ►CvtkWindow | Window superclass for vtkRenderWindow |
| ►CvtkRenderWindow | Create a window for renderers to draw into |
| ►CvtkOpenGLRenderWindow | OpenGL rendering window |
| CvtkCocoaRenderWindow | Cocoa OpenGL rendering window |
| CvtkCocoaRenderWindow | Cocoa OpenGL rendering window |
| CvtkEGLRenderWindow | OpenGL rendering window |
| ►CvtkGenericOpenGLRenderWindow | Platform independent render window |
| CvtkExternalOpenGLRenderWindow | OpenGL render window that allows using an external window to render vtk objects |
| CvtkGenericOpenGLRenderWindow | Platform independent render window |
| CvtkIOSRenderWindow | IOS OpenGL rendering window |
| CvtkOculusRenderWindow | Oculus rendering window |
| CvtkOpenVRRenderWindow | OpenVR rendering window |
| CvtkOSOpenGLRenderWindow | OffScreen Mesa rendering window |
| CvtkOSOpenGLRenderWindow | OffScreen Mesa rendering window |
| CvtkWin32OpenGLRenderWindow | OpenGL rendering window |
| CvtkWin32OpenGLRenderWindow | OpenGL rendering window |
| CvtkXOpenGLRenderWindow | OpenGL rendering window |
| CvtkXOpenGLRenderWindow | OpenGL rendering window |
| CvtkOpenGLRenderWindow | OpenGL rendering window |
| CvtkX3DExporterJavaHelper | Create an x3d file |
| ►CvtkX3DExporterWriter | X3D Exporter Writer |
| CvtkX3DExporterFIWriter | |
| CvtkX3DExporterXMLWriter | X3D Exporter XML Writer |
| CvtkXdmfDataArray | |
| CvtkXMLDataElement | Represents an XML element and those nested inside |
| CvtkXMLHierarchicalBoxDataFileConverter | Converts older *.vth, *.vthb files to newer format |
| ►CvtkXMLParser | Parse XML to handle element tags and attributes |
| CvtkBlueObeliskDataParser | Fill a vtkBlueObeliskData container with data from the BODR XML dataset |
| CvtkExodusIIReaderParser | Internal parser used by vtkExodusIIReader |
| CvtkLSDynaSummaryParser | This is a helper class used by vtkLSDynaReader to read XML files |
| CvtkXMLDataParser | Used by vtkXMLReader to parse VTK XML files |
| CvtkXMLFileReadTester | Utility class for vtkXMLReader and subclasses |
| CvtkXMLUtilities | XML utilities |
| CvtkObjectFactoryRegistryCleanup | |
| CvtkOBJImportedMaterial | |
| CvtkODBCInternals | Simple class to hide ODBC structures |
| CvtkOpenGL2ContextDevice2DPrivate | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| CvtkOpenGLBufferObjectState | |
| CvtkOpenGLClipPlaneState | |
| CvtkOpenGLComponentTransform | |
| CvtkOpenGLExtensionManager | Interface class for querying and using OpenGL extensions |
| CvtkOpenGLFixePipelineState | |
| CvtkOpenGLHelper | |
| CvtkOpenGLImageAlgorithmCallback | |
| CvtkOpenGLIndexPixelMapState | |
| CvtkOpenGLLightState | |
| CvtkOpenGLMaterialState | |
| CvtkOpenGLPixelControl | |
| CvtkOpenGLProgramState | |
| CvtkOpenGLRenderTimer | Asynchronously measures GPU execution time |
| CvtkOpenGLRGBAPixelMapState | |
| CvtkOpenGLShaderState | |
| CvtkOpenGLState | Raw OpenGL State |
| CvtkOpenGLTexGenState | |
| CvtkOpenGLTextureCoordinateProcessingUnit | |
| CvtkOpenGLTextureImageState | |
| CvtkOpenGLTextureImageUnit | |
| CvtkOpenGLTextureImageUnitFixedPipelineState | |
| CvtkOpenGLVolumeGradientOpacityTables | |
| CvtkOpenGLVolumeOpacityTables | |
| CvtkOpenGLVolumeRGBTables | |
| ►CvtkOStreamWrapper | Wrapper for C++ ostream |
| CvtkOStrStreamWrapper | Wrapper for ostrstream |
| CvtkOutputWindowCleanup | |
| ►CvtkPainterCommunicator | A communicator that can safely be used inside a painter |
| CvtkPPainterCommunicator | |
| CvtkPBGLGraphAdapter | Adapter to the Parallel Boost Graph Library (http://www.osl.iu.edu/research/pbgl) |
| CvtkPistonDataWrangling | Miscellaneous conversion code |
| CvtkPistonMinMax | Computes scalar range on GPU for mapper |
| CvtkPistonReference | Lower level handle on GPU resident data |
| CvtkPixelExtent | Representation of a cartesian pixel plane and common operations on it |
| CvtkPixelExtentIO | A small collection of I/O routines that can write vtkPixelExtent's or collections of them to disk for visualization as unstructured grids |
| ►CvtkPixelTransfer | Pixel extents |
| CvtkPPixelTransfer | Class to handle inter-process communication of pixel data from non-contiguous regions of a shared index space |
| CvtkPKMeansStatisitcs | A class for parallel k means clustering |
| CvtkToDax::vtkPointsContainerTag | |
| CvtkToDax::vtkPointsPortal< Type, NUM_COMPONENTS > | |
| CvtkPolygonalSurfacePointPlacerNode | |
| CvtkPolygonBuilder | The polygon output is the boundary of the union of the triangles |
| CvtkPostgreSQLDatabasePrivate | Internal details of a connection to a PostgreSQL database |
| CvtkPOutlineFilterInternals | Create wireframe outline (or corners) for arbitrary data set |
| CvtkQtSQLDatabase | Maintains a connection to an sql database |
| CvtkQtSQLQuery | Query class associated with vtkQtSQLDatabase |
| CvtkSynchronizedRenderers::vtkRawImage | VtkRawImage can be used to make it easier to deal with images for compositing/communicating over client-server etc |
| CvtkRayCastRayInfo | |
| CvtkRayCastStructures | Structure definitions for ray casting |
| CvtkRenderState | Context in which a vtkRenderPass will render |
| CvtkResampleWithDataset | Sample point and cell data of a dataset on points from another dataset |
| CvtkScalarBarActorInternal | Internal state for the scalar bar actor shared with subclasses |
| CvtkScalarBarBox | A structure to represent pixel coordinates for text or swatch bounds |
| CvtkShadowMapBakerPassLightCameras | |
| CvtkShadowMapBakerPassTextures | |
| CvtkSimpleConditionVariable | |
| CvtkSimpleCriticalSection | Critical section locking class |
| CvtkSimpleMutexLock | |
| ►CvtkSmartPointerBase | Non-templated superclass for vtkSmartPointer |
| CvtkSmartPointer< T > | Hold a reference to a vtkObjectBase instance |
| CvtkSmartPointer< AbstractPStreamTracerUtils > | |
| CvtkSmartPointer< AMRIndexIterator > | |
| CvtkSmartPointer< ImplementationType > | |
| CvtkSmartPointer< QVTKInteractor > | |
| CvtkSmartPointer< StorageType > | |
| CvtkSmartPointer< TemporalFractalOutputUtil > | |
| CvtkSmartPointer< vtkAbstractCellLocator > | |
| CvtkSmartPointer< vtkActor > | |
| CvtkSmartPointer< vtkActor2D > | |
| CvtkSmartPointer< vtkAddMembershipArray > | |
| CvtkSmartPointer< vtkAnnotationLink > | |
| CvtkSmartPointer< vtkAppendPolyData > | |
| CvtkSmartPointer< vtkApplyColors > | |
| CvtkSmartPointer< vtkApplyIcons > | |
| CvtkSmartPointer< vtkAreaLayout > | |
| CvtkSmartPointer< vtkAssignCoordinates > | |
| CvtkSmartPointer< vtkAxis > | |
| CvtkSmartPointer< vtkAxisActor2D > | |
| CvtkSmartPointer< vtkBalloonRepresentation > | |
| CvtkSmartPointer< vtkBitArray > | |
| CvtkSmartPointer< vtkBivariateLinearTableThreshold > | |
| CvtkSmartPointer< vtkBoxLayoutStrategy > | |
| CvtkSmartPointer< vtkBrush > | |
| CvtkSmartPointer< vtkCachingInterpolatedVelocityField > | |
| CvtkSmartPointer< vtkCallbackCommand > | |
| CvtkSmartPointer< vtkCamera > | |
| CvtkSmartPointer< vtkCellArray > | |
| CvtkSmartPointer< vtkCellData > | |
| CvtkSmartPointer< vtkCenteredSliderRepresentation > | |
| CvtkSmartPointer< vtkCharArray > | |
| CvtkSmartPointer< vtkChartLegend > | |
| CvtkSmartPointer< vtkCollection > | |
| CvtkSmartPointer< vtkColorSeries > | |
| CvtkSmartPointer< vtkCommand > | |
| CvtkSmartPointer< vtkCompassWidget > | |
| CvtkSmartPointer< vtkCompositeDataDisplayAttributes > | |
| CvtkSmartPointer< vtkComputeHistogram2DOutliers > | |
| CvtkSmartPointer< vtkContext2D > | |
| CvtkSmartPointer< vtkContextDevice3D > | |
| CvtkSmartPointer< vtkContextMapper2D > | |
| CvtkSmartPointer< vtkContextScene > | |
| CvtkSmartPointer< vtkConvertSelectionDomain > | |
| CvtkSmartPointer< vtkConvexHull2D > | |
| CvtkSmartPointer< vtkCoordinate > | |
| CvtkSmartPointer< vtkDataArray > | |
| CvtkSmartPointer< vtkDataArraySelection > | |
| CvtkSmartPointer< vtkDataObject > | |
| CvtkSmartPointer< vtkDataObjectToTable > | |
| CvtkSmartPointer< vtkDataSet > | |
| CvtkSmartPointer< vtkDendrogramItem > | |
| CvtkSmartPointer< vtkDistanceToCamera > | |
| CvtkSmartPointer< vtkDoubleArray > | |
| CvtkSmartPointer< vtkEdgeCenters > | |
| CvtkSmartPointer< vtkEdgeLayout > | |
| CvtkSmartPointer< vtkEventQtSlotConnect > | |
| CvtkSmartPointer< vtkExtractSelectedGraph > | |
| CvtkSmartPointer< vtkExtractSelectedRows > | |
| CvtkSmartPointer< vtkFastSplatter > | |
| CvtkSmartPointer< vtkFloatArray > | |
| CvtkSmartPointer< vtkFrameBufferObject2 > | |
| CvtkSmartPointer< vtkGenericCell > | |
| CvtkSmartPointer< vtkGenericOpenGLRenderWindow > | |
| CvtkSmartPointer< vtkGeoCamera > | |
| CvtkSmartPointer< vtkGeoTreeNode > | |
| CvtkSmartPointer< vtkGlyph3D > | |
| CvtkSmartPointer< vtkGlyphSource2D > | |
| CvtkSmartPointer< vtkGraphLayout > | |
| CvtkSmartPointer< vtkGraphToGlyphs > | |
| CvtkSmartPointer< vtkGraphToPoints > | |
| CvtkSmartPointer< vtkGraphToPolyData > | |
| CvtkSmartPointer< vtkHardwareSelector > | |
| CvtkSmartPointer< vtkHeatmapItem > | |
| CvtkSmartPointer< vtkHoverWidget > | |
| CvtkSmartPointer< vtkIconGlyphFilter > | |
| CvtkSmartPointer< vtkIdTypeArray > | |
| CvtkSmartPointer< vtkImageData > | |
| CvtkSmartPointer< vtkInformation > | |
| CvtkSmartPointer< vtkIntArray > | |
| CvtkSmartPointer< vtkLabelPlacementMapper > | |
| CvtkSmartPointer< vtkLineIntegralConvolution2D > | |
| CvtkSmartPointer< vtkLookupTable > | |
| CvtkSmartPointer< vtkMapArrayValues > | |
| CvtkSmartPointer< vtkMathInternal > | |
| CvtkSmartPointer< vtkMatrix3x3 > | |
| CvtkSmartPointer< vtkMultiBlockDataSet > | |
| CvtkSmartPointer< vtkOBJPolyDataProcessor > | |
| CvtkSmartPointer< vtkOpenGLRenderWindow > | |
| CvtkSmartPointer< vtkOutlineSource > | |
| CvtkSmartPointer< vtkOverlappingAMR > | |
| CvtkSmartPointer< vtkPairwiseExtractHistogram2D > | |
| CvtkSmartPointer< vtkPen > | |
| CvtkSmartPointer< vtkPerturbCoincidentVertices > | |
| CvtkSmartPointer< vtkPiecewiseFunction > | |
| CvtkSmartPointer< vtkPixelBufferObject > | |
| CvtkSmartPointer< vtkPlotHistogram2D > | |
| CvtkSmartPointer< vtkPointData > | |
| CvtkSmartPointer< vtkPoints > | |
| CvtkSmartPointer< vtkPointSet > | |
| CvtkSmartPointer< vtkPointSetToLabelHierarchy > | |
| CvtkSmartPointer< vtkPolyData > | |
| CvtkSmartPointer< vtkPolyDataMapper > | |
| CvtkSmartPointer< vtkPolyDataMapper2D > | |
| CvtkSmartPointer< vtkPolygon > | |
| CvtkSmartPointer< vtkPolyLine > | |
| CvtkSmartPointer< vtkPriorityQueue > | |
| CvtkSmartPointer< vtkQImageToImageSource > | |
| CvtkSmartPointer< vtkRemoveHiddenData > | |
| CvtkSmartPointer< vtkRenderer > | |
| CvtkSmartPointer< vtkRenderWindow > | |
| CvtkSmartPointer< vtkScalarBarWidget > | |
| CvtkSmartPointer< vtkScalarsToColors > | |
| CvtkSmartPointer< vtkSelection > | |
| CvtkSmartPointer< vtkSliceAndDiceLayoutStrategy > | |
| CvtkSmartPointer< vtkSphereSource > | |
| CvtkSmartPointer< vtkSpline > | |
| CvtkSmartPointer< vtkSquarifyLayoutStrategy > | |
| CvtkSmartPointer< vtkStringArray > | |
| CvtkSmartPointer< vtkSurfaceLICComposite > | |
| CvtkSmartPointer< vtkTable > | |
| CvtkSmartPointer< vtkTemporalInterpolatedVelocityField > | |
| CvtkSmartPointer< vtkTemporalPathLineFilterInternals > | |
| CvtkSmartPointer< vtkTextMapper > | |
| CvtkSmartPointer< vtkTextProperty > | |
| CvtkSmartPointer< vtkTextPropertyCollection > | |
| CvtkSmartPointer< vtkTexture > | |
| CvtkSmartPointer< vtkTexturedActor2D > | |
| CvtkSmartPointer< vtkTextureObject > | |
| CvtkSmartPointer< vtkTooltipItem > | |
| CvtkSmartPointer< vtkTransform > | |
| CvtkSmartPointer< vtkTransform2D > | |
| CvtkSmartPointer< vtkTransformCoordinateSystems > | |
| CvtkSmartPointer< vtkTransformPolyDataFilter > | |
| CvtkSmartPointer< vtkTree > | |
| CvtkSmartPointer< vtkTreeFieldAggregator > | |
| CvtkSmartPointer< vtkTreeLevelsFilter > | |
| CvtkSmartPointer< vtkUniformGrid > | |
| CvtkSmartPointer< vtkUniformGridAMR > | |
| CvtkSmartPointer< vtkUnsignedCharArray > | |
| CvtkSmartPointer< vtkUnsignedIntArray > | |
| CvtkSmartPointer< vtkValuePassHelper > | |
| CvtkSmartPointer< vtkVertexDegree > | |
| CvtkSmartPointer< vtkVertexGlyphFilter > | |
| CvtkSmartPointer< vtkWorldPointPicker > | |
| CvtkSMPMergePolyDataHelper | Utility class for merging poly data in parallel This class is designed as a utility class to help merging of poly data generated by filters that generate multiple polydata outputs and the associated locators |
| CvtkSMPThreadLocalObject< T > | Thread local storage for VTK objects |
| CvtkSMPThreadLocalObject< vtkProgressObserver > | |
| CvtkSMPTools | A set of parallel (multi-threaded) utility functions |
| Cvtk::detail::smp::vtkSMPTools_FunctorInternal< Functor, Init > | |
| Cvtk::detail::smp::vtkSMPTools_FunctorInternal< Functor, false > | |
| Cvtk::detail::smp::vtkSMPTools_FunctorInternal< Functor, true > | |
| Cvtk::detail::smp::vtkSMPTools_Has_Initialize< T > | |
| Cvtk::detail::smp::vtkSMPTools_Has_Initialize_const< T > | |
| Cvtk::detail::smp::vtkSMPTools_Lookup_For< Functor > | |
| Cvtk::detail::smp::vtkSMPTools_Lookup_For< Functor const > | |
| CvtkStaticCellLinksTemplate< TIds > | Object represents upward pointers from points to list of cells using each point (template implementation) |
| CvtkStaticCellLinksTemplate< vtkIdType > | |
| CvtkStatisticsAlgorithmPrivate | |
| ►CvtkStructuredNeighbor | An internal, light-weight class used to store neighbor information |
| CvtkStructuredAMRNeighbor | An internal, light-weight object used to store neighbor information for AMR grids |
| CvtkHyperTreeGrid::vtkSuperCursorEntry | |
| CvtkSurfaceLICHelper | A small collection of noise routines for LIC |
| CvtkSystemIncludes | Transition VTK to ANSI C++, centralize inclusion of system files |
| CvtkTDxMotionEventInfo | Store motion information from a 3DConnexion input device |
| CvtkTemplateAliasMacro | Dispatch a scalar processing template |
| CvtkTextRendererCleanup | |
| CvtkTextureImageCache< Key > | |
| CvtkTextureImageCache< TextPropertyKey > | |
| CvtkTextureIO | A small collection of I/O routines that write vtkTextureObject to disk for debugging |
| CvtkTimerLogEntry | |
| CvtkTimeSource | Creates a simple time varying data set |
| CvtkTimeStamp | Record modification and/or execution time |
| CvtkTkImageViewerWidget | Tk Widget for viewing vtk images |
| CvtkTkRenderWidget | Tk Widget for vtk renderering |
| CvtkToDax::vtkTopologyContainerTag< CellType > | |
| CvtkToDax::vtkTopologyPortal< T, PointsPerCell > | |
| CvtkTransformConcatenation | |
| CvtkTransformConcatenationStack | |
| CvtkTransformPair | |
| CvtkTryDowncastHelper1< TargetT, FunctorT > | |
| CvtkTryDowncastHelper2< TargetT, FunctorT > | |
| CvtkTryDowncastHelper3< TargetT, FunctorT > | |
| ►CvtkTuple< T, Size > | Templated base type for containers of constant size |
| CvtkVector< T, Size > | Templated base type for storage of vectors |
| ►CvtkVector< T, 2 > | |
| CvtkVector2< T > | |
| ►CvtkVector< T, 3 > | |
| CvtkVector3< T > | |
| ►CvtkVector< T, 4 > | |
| CvtkRect< T > | Templated base type for storage of 2D rectangles |
| ►CvtkTuple< double, 3 > | |
| ►CvtkColor3< double > | |
| CvtkColor3d | |
| ►CvtkTuple< double, 4 > | |
| ►CvtkColor4< double > | |
| CvtkColor4d | |
| ►CvtkQuaternion< double > | |
| CvtkQuaterniond | |
| ►CvtkTuple< double, Size > | |
| ►CvtkVector< double, 2 > | |
| ►CvtkVector2< double > | |
| CvtkVector2d | |
| ►CvtkVector< double, 3 > | |
| ►CvtkVector3< double > | |
| CvtkVector3d | |
| ►CvtkVector< double, 4 > | |
| ►CvtkRect< double > | |
| CvtkRectd | |
| ►CvtkTuple< float, 3 > | |
| ►CvtkColor3< float > | |
| CvtkColor3f | |
| ►CvtkTuple< float, 4 > | |
| ►CvtkColor4< float > | |
| CvtkColor4f | |
| ►CvtkQuaternion< float > | |
| CvtkQuaternionf | |
| ►CvtkTuple< float, Size > | |
| ►CvtkVector< float, 2 > | |
| ►CvtkVector2< float > | |
| CvtkVector2f | |
| ►CvtkVector< float, 3 > | |
| ►CvtkVector3< float > | |
| CvtkVector3f | |
| ►CvtkVector< float, 4 > | |
| ►CvtkRect< float > | |
| CvtkRectf | |
| CvtkTuple< int, 2 > | |
| CvtkTuple< int, 4 > | |
| ►CvtkTuple< int, Size > | |
| ►CvtkVector< int, 2 > | |
| ►CvtkVector2< int > | |
| CvtkVector2i | Some derived classes for the different vectors commonly used |
| ►CvtkVector< int, 3 > | |
| ►CvtkVector3< int > | |
| CvtkVector3i | |
| ►CvtkVector< int, 4 > | |
| ►CvtkRect< int > | |
| CvtkRecti | |
| ►CvtkTuple< T, 3 > | |
| CvtkColor3< T > | |
| ►CvtkTuple< T, 4 > | |
| CvtkColor4< T > | |
| CvtkQuaternion< T > | Templated base type for storage of quaternions |
| ►CvtkTuple< unsigned char, 3 > | |
| ►CvtkColor3< unsigned char > | |
| CvtkColor3ub | Some derived classes for the different colors commonly used |
| ►CvtkTuple< unsigned char, 4 > | |
| ►CvtkColor4< unsigned char > | |
| CvtkColor4ub | |
| CvtkTuple< vtkAxis *, 4 > | |
| CvtkTypedDataArrayIterator< Scalar > | STL-style random access iterator for vtkTypedDataArrays |
| CvtkTypeList | TypeList implementation and utilities |
| CvtkTypeTraits< T > | Template defining traits of native types used by VTK |
| Cvtkucfloat | OpenGL vertex buffer object |
| CvtkUnicodeString | String class that stores Unicode text |
| CvtkVariant | A atomic type representing the union of many types |
| CvtkVariantBoostSerialization | Serialization support for vtkVariant and vtkVariantArray using the Boost.Serialization library |
| CvtkVariantCast | Converts a vtkVariant to some other type |
| CvtkVariantCreate | Performs an explicit conversion from an arbitrary type to a vtkVariant |
| CvtkVariantEqual | |
| CvtkVariantExtract | Performs an explicit conversion from a vtkVariant to the type that it contains |
| CvtkVariantLessThan | |
| CvtkVariantStrictEquality | |
| CvtkVariantStrictWeakOrder | |
| CvtkVertexAdjacencyList | |
| Cboost::vtkVertexGlobalMap | |
| Cboost::vtkVertexLocalMap | |
| Cboost::vtkVertexOwnerMap | |
| CvtkVolumeMask | |
| CvtkVolumeRayCastDynamicInfo | |
| CvtkVolumeRayCastStaticInfo | |
| CvtkVolumeStateRAII | |
| CvtkVRMLImporter_Yacc | |
| CvtkVRMLUseStruct | |
| CvtkVRMLYaccData | |
| ►CvtkWeakPointerBase | Non-templated superclass for vtkWeakPointer |
| CvtkWeakPointer< T > | Weak reference to a vtkObject |
| CvtkWeakPointer< vtkAxisActor > | |
| CvtkWeakPointer< vtkContext2D > | |
| CvtkWeakPointer< vtkContextScene > | |
| CvtkWeakPointer< vtkOpenGLRenderWindow > | |
| CvtkWeakPointer< vtkPiecewiseFunction > | |
| CvtkWeakPointer< vtkRenderer > | |
| CvtkWeakPointer< vtkRenderWindow > | |
| CvtkWeakPointer< vtkRenderWindowInteractor > | |
| CvtkWeakPointer< vtkViewNode > | |
| CvtkWeakPointer< vtkViewport > | |
| CvtkWeakPointer< vtkWindow > | |
| CvtkWin32Header | Manage Windows system differences |
| CvtkWin32OpenGL2RenderWindow | OpenGL rendering window |
| CvtkWrappingHints | Hint macros for wrappers |
| CvtkX3DExporterFIWriterHelper | |
| CvtkXdmf3DataSet | Dataset level translation between xdmf3 and vtk |
| CvtkXdmf3HeavyDataHandler | Internal helper for vtkXdmf3Reader |
| CvtkXdmf3LightDataHandler | Internal helper for vtkXdmf3Reader |
| CvtkXdmf3SILBuilder | Helper to allow block selection |
| CvtkXdmfDocument | |
| CvtkXdmfDomain | |
| CvtkXdmfHeavyData | |
| CvtkXdmfReaderInternal | |
| ►CvtkXMLDataHeader | |
| CvtkXMLDataHeaderImpl< T > | |
| CvtkXMLReaderVersion | Version number for legacy readers/writers |
| CvtkDendrogramItem::WeightedVertex | |
| CADIOS::Writer | |
| CX3DEncoderFunctions | |
| CvtkXdmfReader::XdmfDataSetTopoGeoPath | |
| CvtkVRMLYaccData::yy_buffer_state | |
| CvtkVRMLYaccData::yyltype | |
| CvtkVRMLYaccData::YYSTYPE | |
