| CvtkKdTree::_cellList | |
| C_vtkTclVoidFuncArg | |
| CvtkGLTFDocumentLoader::Accessor | This struct describes an accessor glTF object |
| CvtkOpenVRRenderWindowInteractor::ActionData | |
| CActionFunction< TWidget > | |
| CvtkSingleVTPExporter::actorData | |
| ►Cadjacency_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| Crtw::affine3f | |
| CvtkDataArrayPrivate::AllValues | |
| CvtkGLTFDocumentLoader::Animation | This struct describes a glTF animation object |
| CvtkAnimationCue::AnimationCueInfo | |
| CvtkTypeList::Append< TList, T > | Appends type T to TypeList TList and stores the result in Result |
| CvtkVRCollaborationClient::Argument | |
| Cinternal::ArrayHandleWrapperBase< T > | |
| CvtkExodusIIReaderPrivate::ArrayInfoType | A struct to hold information about time-varying arrays |
| CArrayList | |
| CvtkCellArray::Storage::ArraySwitch | |
| CvtkLagrangianBasicIntegrationModel::ArrayVal | |
| ►CvtkStatisticsAlgorithm::AssessFunctor | A base class for a functor that assesses data |
| CvtkKMeansAssessFunctor | |
| CvtkMultiCorrelativeAssessFunctor | |
| ►CRTW::Backend | |
| CRTW::OSPRayBackend | |
| CRTW::VisRTXBackend | |
| CvtkBlockSortHelper::BackToFront< T > | Operator() for back-to-front sorting |
| ►CBaseArrayPair | |
| CArrayPair< T > | |
| CRealArrayPair< TInput, TOutput > | |
| CCGNSRead::BaseInformation | |
| ►CvtkFieldData::BasicIterator | |
| CvtkFieldData::Iterator | |
| CBHLeaf | |
| CBHNode | |
| CBHTree | |
| ►Cbidirectional_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| CvtkAMRDataInternals::Block | |
| CvtkDIYGhostUtilities::Block< BlockStructureT, InformationT > | Block structure to be used for diy communication |
| CvtkExodusIIWriter::Block | |
| CvtkTemporalStreamTracer::bounds_t | |
| Crtw::box3f | |
| Crtw::box3i | |
| CvtkOpenGLState::BufferBindingState | |
| CvtkGLTFDocumentLoader::BufferView | This struct describes a glTF bufferView object |
| CvtkIOSSUtilities::Cache | Cache |
| CvtkTextureImageCache< Key >::CacheData | |
| CvtkGLTFDocumentLoader::Camera | This struct describes a glTF camera object |
| CvtkTypeList::CanConvert< From, To > | Sets member Result to true if a conversion exists to convert type From to type To |
| CvtkCellArray_detail::GetCellAtIdImpl::CanShareConnPtr< CellStateT > | |
| CvtkOpenGLContextDevice2D::CellArrayHelper | |
| CCGNSRead::CGNSVariable | |
| CCGNSRead::CGNSVector | |
| CvtkGLTFDocumentLoader::Animation::Channel | |
| Cimpl::ClientData | |
| CvtkShaderProgram::cmp_str | |
| Cvtk::detail::CollectionRange< CollectionType > | |
| Cdetail::CollectValidCellSurfacePointsFunctor< VArrayType, WArrayType > | |
| CvtkDendrogramItem::CompareWeightedVertices | |
| CvtkMergeFields::Component | |
| CvtkSplitField::Component | |
| Cvtk::detail::ComponentIterator< ArrayType, TupleSize > | |
| Cvtk::detail::ComponentReference< ArrayType, TupleSize > | |
| Cvtk::detail::CompositeDataSetRange | |
| CvtkSMPTools::Config | Structure used to specify configuration for LocalScope() method |
| CvtkUnicodeString::const_iterator | |
| Cvtk::detail::ConstComponentIterator< ArrayType, TupleSize > | |
| Cvtk::detail::ConstComponentReference< ArrayType, TupleSize > | |
| Cvtk::detail::ConstTupleIterator< ArrayType, TupleSize > | |
| Cvtk::detail::ConstTupleIterator< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| Cvtk::detail::ConstTupleReference< ArrayType, TupleSize > | |
| Cvtk::detail::ConstTupleReference< vtkAOSDataArrayTemplate, TupleSize > | |
| Cvtk::detail::ConstTupleReference< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| Cvtk::detail::ConstValueIterator< ArrayType, TupleSize > | |
| Cvtk::detail::ConstValueReference< ArrayType, TupleSize > | |
| CvtkFieldData::CopyFieldFlag | |
| CvtkMaskFields::CopyFieldFlag | |
| CCstring_less | |
| ►CCWnd | |
| CvtkMFCWindow | Class to display a VTK window in an MFC window |
| Cvtx::types::DataArray | |
| Ctovtkm::DataArrayToArrayHandle< DataArrayType, NumComponents > | |
| Ctovtkm::DataArrayToArrayHandle< vtkAOSDataArrayTemplate< T >, NumComponents > | |
| Ctovtkm::DataArrayToArrayHandle< vtkSOADataArrayTemplate< T >, 1 > | |
| Ctovtkm::DataArrayToArrayHandle< vtkSOADataArrayTemplate< T >, NumComponents > | |
| CvtkAVSucdReader::DataInfo | |
| Cvtk::detail::DataObjectTreeRange | |
| ►CvtkDIYGhostUtilities::DataSetBlockStructure | Base block structure for data sets |
| ►CvtkDIYGhostUtilities::GridBlockStructure | Structure to inherit from for data sets having a structured grid topology |
| CvtkDIYGhostUtilities::ImageDataBlockStructure | Block structure storing information being communicated by neighboring blocks for vtkImageData |
| CvtkDIYGhostUtilities::RectilinearGridBlockStructure | Block structure storing information being communicated by neighboring blocks for vtkRectilinearGrid |
| CvtkDIYGhostUtilities::StructuredGridBlockStructure | Block structure storing information being communicated by neighboring blocks for vtkStructuredGrid |
| ►CvtkDIYGhostUtilities::UnstructuredDataBlockStructure | |
| CvtkDIYGhostUtilities::PolyDataBlockStructure | |
| CvtkDIYGhostUtilities::UnstructuredGridBlockStructure | |
| ►CDataSetsTypeBase | |
| CvtkCompositeInterpolatedVelocityFieldDataSetsType | |
| CvtkDIYGhostUtilities::DataSetTypeToBlockTypeConverter< DataSetT > | This helper structure owns a typedef to the block type of DataSetT used with diy to generate ghosts |
| 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 |
| 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 | |
| CEdgeTuple< TId, TED > | Definition of an edge tuple |
| 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 | |
| CvtkRenderTimerLog::Event | Container for a single timed event |
| CvtkGLTFDocumentLoader::Extensions | This struct contains extension metadata |
| CvtkGLTFDocumentLoader::Node::Extensions | |
| CvtkOpenGLPolyDataMapper::ExtraAttributeValue | |
| CvtkFreeTypeTools::FaceMetrics | |
| CvtkVRMLYaccData::FakeAlloca | |
| CCGNSRead::FamilyInformation | |
| CVrmlNodeType::FieldRec | |
| CvtkArrayDispatch::FilterArraysByValueType< ArrayList, ValueList > | Filter the ArrayList to contain only arrays with ArrayType::ValueType that exist in ValueList |
| CvtkDataArrayPrivate::FiniteValues | |
| CvtkX3DExporterFIWriterHelper::float_to_unsigned_int_to_bytes | |
| CvtkRenderTimerLog::Frame | Container for a frame's events |
| CvtkVRRenderWindow::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 > | |
| Cvtk::detail::GenericTupleSize< DynamicTupleSize > | |
| Cvtk::detail::GetAPITypeImpl< ArrayType > | |
| Cvtk::detail::GetAPITypeImpl< vtkDataArray > | |
| CvtkCellArray_detail::GetCellAtIdImpl | |
| CvtkCellArray_detail::GetCellSizeImpl | |
| Cvtk::detail::GetCollectionItemType< CollectionType > | |
| Cglobal | |
| CvtkOpenGLState::GLState | |
| CvtkGLTFReader::GLTFTexture | Materials are not directly applied to this reader's output |
| CvtkFreeTypeTools::GlyphOutline | |
| ►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 > | |
| CvtkDIYGhostUtilities::StructuredGridBlockStructure::Grid2D | Grid interfacing with block's grid |
| ►CvtkDIYGhostUtilities::GridInformation | Structure storing information needed by a block on it's own grid structure |
| CvtkDIYGhostUtilities::RectilinearGridInformation | |
| CvtkDIYGhostUtilities::StructuredGridInformation | |
| Ch | VtkFrustumSelector is a vtkSelector that selects elements based on whether they are inside or intersect a frustum of interest |
| Ch | Colapses components with magnitude function |
| Ch | Computes the portion of a dataset which is inside a selection |
| CH5RageAdaptor | |
| Cdetail::has_NaN< T, bool > | |
| Cdetail::has_NaN< T, false > | |
| Cdetail::has_NaN< T, true > | |
| CvtkInformationInternals::HashFun | |
| Cvtk::detail::smp::OpenMP::HashTableArray | |
| Cvtk::detail::smp::STDThread::HashTableArray | |
| CvtkXMLHyperTreeGridWriter::HyperTreeGridMetaDataForVersion2 | |
| ►Cidentifier | |
| CMotionFX::CFG::ParameterName | |
| Cvtk::detail::IdStorage< TupleSize > | |
| CvtkGLTFDocumentLoader::Image | This struct describes a glTF image object |
| ►CParentFunctor::Impl | |
| CvtkDispatcherPrivate::FunctorHandler< ParentFunctor, Fun > | |
| CvtkDoubleDispatcherPrivate::FunctorHandler< ParentFunctor, Fun > | |
| CvtkHDFReader::Implementation | Implementation for the vtkHDFReader |
| CvtkLabelHierarchy::Implementation | |
| Ctovtkm::ImplicitFunctionConverter | |
| 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 |
| CvtkCellArray_detail::InsertNextCellImpl | |
| CvtkOpenGLInstanceCulling::InstanceLOD | |
| ►Cstd::integral_constant | |
| Cvtk::detail::AreStaticTupleSizes< S1, S2 > | |
| Cvtk::detail::GenericTupleSize< TupleSize > | |
| Cvtk::detail::IsEitherTupleSizeDynamic< S1, S2 > | |
| ►Cstd::integral_constant< bool,(Size > 0)> | |
| Cvtk::detail::IsStaticTupleSize< Size > | |
| ►Cstd::integral_constant< bool,(Size > 0||Size==DynamicTupleSize)> | |
| Cvtk::detail::IsValidTupleSize< Size > | |
| CvtkmClip::internals | |
| CvtkQtLabelRenderStrategy::Internals | |
| CvtkMultiBlockPLOT3DReaderInternals::InternalSettings | |
| CvtkUnstructuredGridBunykRayCastFunction::Intersection | |
| CvtkGenericStreamTracer::IntervalInformation | |
| CvtkStreamTracer::IntervalInformation | |
| ►Cstd::is_base_of | |
| Cvtk::detail::IsCollection< T > | |
| Cvtk::detail::IsVtkDataArray< T > | |
| CCGNSRead::detail::is_double< T > | |
| CCGNSRead::detail::is_double< double > | |
| CCGNSRead::detail::is_float< T > | |
| CCGNSRead::detail::is_float< float > | |
| Cvtk::detail::IsAOSDataArrayImpl< ArrayType > | |
| Cvtk::detail::IsComplete< T > | |
| CvtkPriorityQueue::Item | |
| Cvtk::detail::IterableTraits< Iterable > | |
| ►Cstd::iterator | |
| Cvtk::detail::CollectionIterator< CollectionType > | |
| Cvtk::detail::CompositeDataSetIterator | |
| Cvtk::detail::DataObjectTreeIterator | |
| Cvtk::detail::smp::vtkSMPThreadLocalAPI< T >::iterator | |
| 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 | |
| ►Cvtk::detail::smp::vtkSMPThreadLocalImplAbstract< T >::ItImpl | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< BackendType::OpenMP, T >::ItImpl | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< BackendType::STDThread, T >::ItImpl | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< BackendType::Sequential, T >::ItImpl | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< BackendType::TBB, T >::ItImpl | |
| CvtkGLTFDocumentLoader::Extensions::KHRLightsPunctual | |
| CvtkGLTFDocumentLoader::Node::Extensions::KHRLightsPunctual | |
| CvtkMatrixUtilities::Layout | This struct determines a prior transform to input matrices, chaging the way they are indexed |
| CvtkGLTFDocumentLoader::Extensions::KHRLightsPunctual::Light | |
| CvtkParallelRenderManager::LightInfo | |
| Crtw::linear3f | |
| 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 |
| CvtkLogger::LogScopeRAII | |
| CLSDynaFamily | |
| CLSDynaFamily::LSDynaFamilyAdaptLevel | |
| CLSDynaFamily::LSDynaFamilySectionMark | |
| CLSDynaMetaData | |
| ►Cstd::map | |
| CCGNSRead::vtkCGNSArraySelection | |
| CvtkADIOS2ArraySelection | Helper to identify requested arrays with |
| CvtkXdmf3ArrayKeeper | LRU cache of XDMF Arrays |
| CvtkXdmf3ArraySelection | Helper to identify requested arrays with |
| CvtkXdmfArraySelection | |
| CvtkMatrixUtilities::detail::Mapper< RowsT, ColsT, LayoutT > | |
| CvtkMatrixUtilities::Mapper< RowsT, ColsT, LayoutT > | This class is a helper class to compute at compile time the index of a matrix stored as a 1D array from its 2D coordinates |
| CvtkMatrixUtilities::detail::Mapper< RowsT, ColsT, Layout::Identity > | |
| CvtkMatrixUtilities::detail::Mapper< RowsT, ColsT, Layout::Transpose > | |
| CvtkGLTFDocumentLoader::Material | This struct describes a glTF material object |
| ►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 |
| CvtkGLTFDocumentLoader::Mesh | This struct describes a glTF mesh object |
| CvtkLogger::Message | The message structure that is passed to custom callbacks registered using vtkLogger::AddCallback |
| 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 |
| CvtkGLTFDocumentLoader::Model | This struct contains all data from a gltf asset |
| CvtkGLTFDocumentLoader::MorphTarget | This struct describes a glTF Morph Target object |
| 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 | |
| ►Cvtk::detail::MTimeWatcher | |
| Cvtk::CompositeDataSetNodeReference< IteratorType, OwnerType > | A reference proxy into a vtkCompositeDataSet, obtained by dereferencing an iterator from the vtk::Range(vtkCompositeDataSet*) overloads |
| ►Cstd::multiset | |
| CvtkLabelHierarchy::Implementation::LabelSet | |
| CVrmlNodeType::NameTypeRec | |
| CNativeToVTKType< T > | Type traits for adios2 types(Native types) to vtk types |
| CNativeToVTKType< char > | |
| CNativeToVTKType< double > | |
| CNativeToVTKType< float > | |
| CNativeToVTKType< int16_t > | |
| CNativeToVTKType< int32_t > | |
| CNativeToVTKType< int64_t > | |
| CNativeToVTKType< int8_t > | |
| CNativeToVTKType< uint16_t > | |
| CNativeToVTKType< uint32_t > | |
| CNativeToVTKType< uint64_t > | |
| CNativeToVTKType< uint8_t > | |
| 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 |
| CCIEDE2000::Node | Node of the color path |
| CvtkGLTFDocumentLoader::Node | This struct describes a glTF node object |
| Cvtk::detail::NoOpMTimeWatcher | |
| CvtkSmartPointerBase::NoReference | |
| CvtkWeakPointerBase::NoReference | |
| CvtkMultiThreshold::NormKey | A class with comparison operator used to index input array norms used in threshold rules |
| ►C<NSDraggingDestination> | |
| CvtkCocoaGLView | Cocoa OpenGL rendering context |
| ►CNSView | |
| CvtkCocoaGLView | Cocoa OpenGL rendering context |
| CvtkTypeList::NullType | Used to terminate a TypeList |
| ►CRTW::Object | |
| CRTW::Camera | |
| CRTW::Data | |
| CRTW::FrameBuffer | |
| CRTW::GeometricModel | |
| CRTW::Geometry | |
| CRTW::Group | |
| CRTW::Instance | |
| CRTW::Light | |
| CRTW::Material | |
| CRTW::Renderer | |
| CRTW::Texture | |
| CRTW::World | |
| ►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 | |
| CvtkOpenGLRenderTimerLog::OGLEvent | |
| CvtkOpenGLRenderTimerLog::OGLFrame | |
| Comf::OMFFile | |
| Comf::OMFProject | |
| CvtkCommunicator::Operation | A custom operation to use in a reduce command |
| CvtkRearrangeFields::Operation | |
| CvtkDIYGhostUtilities::StructuredGridInformation::OuterPointLayersType | This structure represents the set of points and their corresponding extent of an external face of the structured grid |
| CvtkTextCodec::OutputIterator | Base class that any output iterators need to derive from to use the first signature of to_unicode |
| CvtkObjectFactory::OverrideInformation | |
| ►Cstd::pair | |
| CvtkTextureImageCache< Key >::CacheElement | CacheElement associates a unique key to some cache |
| CvtkParticleTracerBaseNamespace::ParticleInformation_t | |
| CvtkTemporalStreamTracerNamespace::ParticleInformation_t | |
| CParticlePathFilterInternal | |
| CvtkGLTFDocumentLoader::Material::PbrMetallicRoughness | |
| CPIO_DATA | |
| CPIO_FIELD | |
| CPIOAdaptor | |
| CvtkHardwareSelector::PixelInformation | Struct used to return information about a pixel location |
| ►Cplus | |
| CMotionFX::CFG::Value | |
| CvtkGenericEdgeTable::PointEntry | |
| CvtkQuadricClustering::PointQuadric | |
| ►Cvtkm::filter::PolicyBase | |
| CvtkmOutputFilterPolicy | |
| CvtkmOutputFilterPolicy | |
| CvtkVRCollaborationClient::Pose | |
| CvtkParticleTracerBaseNamespace::Position_t | |
| CvtkTemporalStreamTracerNamespace::Position_t | |
| CvtkGLTFDocumentLoader::Primitive | This struct describes a glTF primitive object |
| CvtkOpenGLPolyDataMapper::primitiveInfo | |
| CvtkLabelHierarchy::Implementation::PriorityComparator | |
| CvtkOpenGLContextDevice2D::Private | |
| ►Comf::ProjectElement | |
| Comf::LineSetElement | |
| Comf::PointSetElement | |
| Comf::SurfaceElement | |
| Comf::VolumeElement | |
| ►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_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_traits< typename > | |
| Cboost::property_traits< vtkAbstractArray * > | |
| Cboost::property_traits< vtkDataArray * > | |
| Cboost::property_traits< vtkGraphEdgeMap > | |
| Cboost::property_traits< vtkGraphIndexMap > | |
| ►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 | |
| ►CQObject | |
| CQQuickVTKInteractiveWidget | QObject that manages a VTK interactive widget to ensure that it behaves as per the QtQuick threaded render loop |
| ►CQVTKInteractorAdapter | |
| CQQuickVTKInteractorAdapter | Intermediate class that handles relaying Qt events to VTK |
| CQVTKInteractorInternal | |
| CQVTKRenderWindowAdapter | Helper to manage Qt context and other OpenGL components |
| 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 |
| 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) |
| ►CQOpenGLFunctions | |
| CQQuickVTKRenderItem | QQuickItem subclass to render a VTK scene in a QtQuick/QML application |
| CQQuickVTKRenderWindow | QQuickItem subclass that manages the vtkRenderWindow and, in turn, the OpenGL context of the QML application |
| ►CQOpenGLWidget | |
| CQVTKOpenGLNativeWidget | QOpenGLWidget subclass to house a vtkGenericOpenGLRenderWindow in a Qt application |
| ►CQOpenGLWindow | |
| CQVTKOpenGLWindow | Display a vtkGenericOpenGLRenderWindow in a Qt QOpenGLWindow |
| ►CQQmlExtensionPlugin | |
| CQQmlVTKPlugin | Plugin class to expose a VTK C++ module to QML applications |
| ►CQQuickItem | |
| CQQuickVTKRenderItem | QQuickItem subclass to render a VTK scene in a QtQuick/QML application |
| CQQuickVTKRenderWindow | QQuickItem subclass that manages the vtkRenderWindow and, in turn, the OpenGL context of the QML application |
| ►CQSortFilterProxyModel | |
| CQFilterTreeProxyModel | |
| ►CQStandardItemModel | |
| CReferenceCountModel | |
| CvtkQtDebugLeaksModel | Model class that observes the vtkDebugLeaks singleton |
| CQTestApp | |
| CQVTKOpenGLWidget | Wrapper for QVTKOpenGLStereoWidget for legacy support purpose |
| CQVTKRenderWidget | Generic QWidget for displaying a vtkRenderWindow in a Qt Application |
| ►CQWidget | |
| CQVTKOpenGLStereoWidget | QWidget for displaying a vtkRenderWindow in a Qt Application |
| CvtkQtDebugLeaksView | View class to display contents of vtkQtDebugLeaksModel |
| CRealDescriptor | |
| CvtkPParticleTracerBase::RemoteParticleInfo | |
| 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 |
| CvtkShader::ReplacementSpec | |
| CvtkShader::ReplacementValue | |
| CvtkMPICommunicator::Request | |
| CvtkCellArray_detail::ResetImpl | |
| CvtkThreadedTaskQueueInternals::ResultQueue< R > | |
| CvtkGLTFDocumentLoader::Animation::Sampler | |
| CvtkGLTFDocumentLoader::Sampler | This struct describes a glTF sampler object |
| CvtkMatrixUtilities::detail::ScalarTypeExtractor< ContainerTypeT, ContainerT > | |
| CvtkMatrixUtilities::ScalarTypeExtractor< ContainerT > | This class extract the underlying value type of containers |
| CvtkMatrixUtilities::detail::ScalarTypeExtractor< 1, ContainerT > | |
| CvtkGLTFDocumentLoader::Scene | This struct describes a glTF scene object |
| CvtkRenderTimerLog::ScopedEventLogger | RAII struct for logging events |
| CvtkOpenGLState::ScopedglEnableDisable | |
| CvtkOpenGLState::ScopedValue< T > | |
| ►CvtkOpenGLState::ScopedValue< std::array< float, 4 > > | |
| CvtkOpenGLState::ScopedglClearColor | |
| ►CvtkOpenGLState::ScopedValue< std::array< int, 4 > > | |
| CvtkOpenGLState::ScopedglScissor | |
| CvtkOpenGLState::ScopedglViewport | |
| ►CvtkOpenGLState::ScopedValue< std::array< unsigned char, 4 > > | |
| CvtkOpenGLState::ScopedglColorMask | |
| ►CvtkOpenGLState::ScopedValue< std::array< unsigned int, 4 > > | |
| CvtkOpenGLState::ScopedglBlendFuncSeparate | |
| ►CvtkOpenGLState::ScopedValue< unsigned char > | |
| CvtkOpenGLState::ScopedglDepthMask | |
| ►CvtkOpenGLState::ScopedValue< unsigned int > | |
| CvtkOpenGLState::ScopedglActiveTexture | |
| CvtkOpenGLState::ScopedglDepthFunc | |
| CvtkTypeList::Select< Exp, T, F > | Sets Result to T if Exp is true, or F if Exp is false |
| Cvtk::detail::SelectTupleRange< ArrayTypePtr, TupleSize > | |
| Cvtk::detail::SelectValueRange< ArrayTypePtr, TupleSize > | |
| ►Cseq | |
| CMotionFX::CFG::Comment | |
| CMotionFX::CFG::Motion | |
| CMotionFX::CFG::Motions | |
| CMotionFX::CFG::OtherNested | |
| CMotionFX::CFG::OtherNonNested | |
| CMotionFX::CFG::Statement | |
| CMotionFX::CFG::StatementOther | |
| CMotionFX::Common::Exponent | |
| CMotionFX::Common::Number | |
| CMotionFX::LegacyPositionFile::Row | |
| CMotionFX::OrientationsPositionFile::Row | |
| CMotionFX::UniversalTransformRow::Row | |
| CSerialization< T > | |
| CSerialization< std::array< ElementType, N > > | |
| CSerialization< std::map< T1, T2 > > | |
| CSerialization< std::pair< T1, T2 > > | |
| CSerialization< std::set< ElementType > > | |
| CSerialization< std::vector< ElementType > > | |
| Cdiy::Serialization< vtkDataArray * > | |
| Cdiy::Serialization< vtkDataSet * > | |
| Cdiy::Serialization< vtkFieldData * > | |
| ►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 |
| CvtkGLTFDocumentLoader::Skin | This struct describes a glTF asset |
| Cvtk::detail::smp::OpenMP::Slot | |
| Cvtk::detail::smp::STDThread::Slot | |
| ►Csor | |
| CMotionFX::CFG::Lines | |
| CMotionFX::CFG::WS_Required | |
| CMotionFX::Common::Delimiter | |
| CMotionFX::Common::Sign | |
| CvtkGLTFDocumentLoader::Accessor::Sparse | This struct describes an accessor.sparse glTF object |
| ►Cstar | |
| CMotionFX::CFG::Grammar | |
| CMotionFX::CFG::WS | |
| CMotionFX::LegacyPositionFile::Grammar | |
| CMotionFX::OrientationsPositionFile::Grammar | |
| CMotionFX::UniversalTransformRow::Grammar | |
| ►Cdiy::StaticAssigner | |
| CvtkDIYExplicitAssigner | Assigner for use with DIY |
| CvtkCellArray::Storage | |
| CStreaklineFilterInternal | |
| ►Cstd::string | |
| CvtkStdString | Wrapper around std::string to keep symbols short |
| Cvtk::detail::StripPointers< T > | |
| Cvtk::detail::StripPointers< T * > | |
| Cvtk::detail::StripPointers< vtkNew< ArrayType > > | |
| Cvtk::detail::StripPointers< vtkSmartPointer< ArrayType > > | |
| Cvtk::detail::StripPointers< vtkWeakPointer< ArrayType > > | |
| CvtkLagrangianBasicIntegrationModel::SurfaceArrayDescription | |
| CtagBlock | |
| CvtkNumberToString::TagDouble | |
| CtagFlashReaderDoubleScalar | |
| CtagFlashReaderIntegerScalar | |
| CtagFlashReaderSimulationInformation | |
| CtagFlashReaderSimulationParameters | |
| CvtkNumberToString::TagFloat | |
| CvtkPolyData_detail::TaggedCellId | |
| CtagVelodyneSimParameters | |
| CvtkThreadedTaskQueueInternals::TaskQueue< R > | |
| CTextPropertyKey< StringType > | |
| CvtkGLTFDocumentLoader::Texture | This struct describes a glTF texture object |
| CvtkGLTFDocumentLoader::TextureInfo | This struct describes a glTF textureInfo object, mostly used in material descriptions They contain two indexes, one to a texture object, and the second being used to construct a string with the format TEXCOORD_<index>, which references a key in mesh.primitives.attributes |
| CvtkMultiThreader::ThreadInfo | This is the structure that is passed to the thread that is created from the SingleMethodExecute, MultipleMethodExecute or the SpawnThread method |
| Cvtk::detail::smp::OpenMP::ThreadSpecific | |
| Cvtk::detail::smp::STDThread::ThreadSpecific | |
| Cvtk::detail::smp::OpenMP::ThreadSpecificStorageIterator | |
| Cvtk::detail::smp::STDThread::ThreadSpecificStorageIterator | |
| CvtkDIYGhostUtilities::PolyDataBlockStructure::TopologyBufferType | |
| CvtkDIYGhostUtilities::UnstructuredGridBlockStructure::TopologyBufferType | Topology information for cells to be exchanged |
| CvtkOpenVRRenderWindowInteractor::TrackerActions | |
| CvtkUnstructuredGridBunykRayCastFunction::Triangle | |
| CvtkDecimatePro::TriArray | |
| Cvtk::detail::TupleIterator< ArrayType, TupleSize > | |
| Cvtk::detail::TupleIterator< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| Cvtk::detail::TupleRange< ArrayTypeT, TupleSize > | |
| Cvtk::detail::TupleRange< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| Cvtk::detail::TupleReference< ArrayType, TupleSize > | |
| Cvtk::detail::TupleReference< vtkAOSDataArrayTemplate, TupleSize > | |
| Cvtk::detail::TupleReference< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| CvtkHDFReader::Implementation::TypeDescription | Used to store HDF native types in a map |
| CvtkDispatcherCommon::TypeInfo | |
| CvtkTypeList::TypeList< T, U > | Generic implementation of TypeList |
| CvtkTypeList::Unique< TList > | Remove all duplicate types from TypeList TList, storing the new list in Result |
| ►CvtkDIYGhostUtilities::UnstructuredDataInformation | |
| CvtkDIYGhostUtilities::PolyDataInformation | |
| CvtkDIYGhostUtilities::UnstructuredGridInformation | |
| CvtkCellArray_detail::UpdateCellCountImpl | |
| Cvtk::detail::ValueIterator< ArrayType, TupleSize > | |
| Cvtk::detail::ValueRange< ArrayTypeT, TupleSize > | |
| Cvtk::detail::ValueRange< vtkAOSDataArrayTemplate< ValueTypeT >, TupleSize > | |
| Cvtk::detail::ValueReference< ArrayType, TupleSize > | |
| CCGNSRead::Variable | |
| CvtkExodusIIWriter::VariableInfo | |
| CvtkTransformFeedback::VaryingMetaData | |
| Crtw::vec2f | |
| Crtw::vec2i | |
| Crtw::vec3f | |
| Crtw::vec3i | |
| Crtw::vec3ui | |
| Crtw::vec4f | |
| ►Cstd::vector | |
| CvtkSmartVector< vtkTextActor > | |
| CIVFCacheList | |
| CvtkContextScenePrivate | Private implementation for scene/items |
| CvtkDataObjectTreeIndex | |
| CvtkSmartVector< T > | A vector of smart pointers |
| ►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 |
| CvtkCellArray::VisitState< ArrayT > | |
| CvtkCellArray::VisitState< ArrayType32 > | |
| CvtkCellArray::VisitState< ArrayType64 > | |
| CvtkVolumeTexture::VolumeBlock | |
| CVrmlNodeType | |
| Cvtk2DHistogramItem | 2D histogram item |
| Cvtk3DLinearGridInternal | Fast access and processing of 3D linear grids |
| CVTK_ASSUME | Provide compiler hints for non-obvious conditions |
| CvtkABI | Manage macros for exporting symbols in the binary interface |
| CvtkAMRBox | Encloses a rectangular region of voxel like cells |
| CvtkAMREnzoReaderInternal | Consists of the low-level Enzo Reader used by the vtkAMREnzoReader |
| CvtkAMReXGridHeader | |
| CvtkAMReXGridLevelHeader | |
| CvtkAMReXGridReaderInternal | Consists of the low-level AMReX Reader used by the vtkAMReXGridReader |
| CvtkAMRFlashReaderInternal | Consists of the low-level Flash Reader used by the vtkAMRFlashReader |
| CvtkAMRVelodyneReaderInternal | Consists of the low-level Velodyne Reader used by the vtkAMRVelodyneReader |
| 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 processing |
| Ctovtkm::vtkArrayPortal< Type, VTKDataArrayType_ > | |
| 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 |
| CvtkBilinearQuadIntersection | Class to perform non planar quad intersection |
| CvtkBlockDistribution | A helper class that manages a block distribution of N elements of data |
| CvtkBond | Convenience proxy for vtkMolecule |
| CvtkBoundingBox | Fast, simple class for representing and operating on 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 |
| CCGNSRead::vtkCGNSCache< CacheDataType > | |
| CvtkCGNSCache | |
| CCGNSRead::vtkCGNSMetaData | |
| CvtkCGNSReaderInternal | |
| 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 |
| CvtkCocoaMacOSXSDKCompatibility | Compatibility header |
| CvtkCollectionElement | |
| CvtkColor | Templated type for storage of colors |
| CvtkCommonInformationKeyManager | Manages key types in vtkCommon |
| CvtkCompositeMapperHelperData | |
| 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 > | |
| CvtkDataObjectTreeInternals | |
| CvtkDataObjectTreeItem | |
| CvtkDataSetAttributesFieldList | Helps manage arrays from multiple vtkDataSetAttributes |
| CvtkDebugLeaksManager | Manages the vtkDebugLeaks singleton |
| CvtkDebugLeaksObserver | |
| CvtkNetCDFCFReader::vtkDependentDimensionInfo | |
| CvtkDijkstraGraphInternals | Helper class due to PIMPL excess |
| CvtkNetCDFCFReader::vtkDimensionInfo | |
| CvtkDispatcher< BaseLhs, ReturnType, CastingPolicy > | Dispatch to functor based on a pointer type |
| CvtkDIYUtilitiesCleanup | |
| CvtkDoubleDispatcher< BaseLhs, BaseRhs, ReturnType, CastingPolicy > | Dispatch to functor based on two pointer types |
| ►CvtkEdgeBase | |
| CvtkEdgeType | |
| CvtkInEdgeType | |
| CvtkOutEdgeType | |
| 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 | |
| CvtkFFMPEGVideoSourceAudioCallbackData | |
| CvtkFFMPEGVideoSourceVideoCallbackData | |
| CvtkFilteringInformationKeyManager | Manages key types in vtkFiltering |
| CvtkFixedSizeHandleRepresentation | A marker that has the same size in pixels |
| CvtkFlashReaderInternal | |
| CvtkFloatingPointExceptions | Deal with floating-point exceptions |
| CvtkFourByteUnion | OpenGL vertex buffer object |
| CvtkFreeTypeToolsCleanup | |
| CvtkGarbageCollectorManager | Manages the vtkGarbageCollector singleton |
| CvtkGenericDataArrayLookupHelper< ArrayTypeT > | Internal class used by vtkGenericDataArray to support LookupValue |
| CvtkGenericDataArrayLookupHelper< vtkGenericDataArray > | |
| ►CvtkGenericOpenGLResourceFreeCallback | |
| CvtkOpenGLResourceFreeCallback< T > | |
| CvtkGeometryFilterHelper | |
| CvtkGLTFDocumentLoaderInternals | Internal class for vtkGLTFDocumentLoader |
| CvtkGLTFWriterUtils | |
| CvtkGPUInfoListArray | Internal class vtkGPUInfoList |
| Cboost::vtkGraphEdgeMap | |
| Cboost::vtkGraphEdgePropertyMapHelper< PMap > | |
| Cboost::vtkGraphIndexMap | |
| Cboost::vtkGraphPropertyMapMultiplier< PMap > | |
| Cboost::vtkGraphVertexPropertyMapHelper< PMap > | |
| CvtkHDFReaderImplementation | Implementation class for vtkHDFReader |
| CvtkHDFReaderVersion | Version number for legacy readers/writers |
| CvtkHyperTreeData | |
| CvtkHyperTreeGridEntry | Entries are cache data for cursors |
| CvtkHyperTreeGridGeometryEntry | JB |
| CvtkHyperTreeGridGeometryLevelEntry | Cursor cache data with coordinates and level info |
| CvtkHyperTreeGrid::vtkHyperTreeGridIterator | An iterator object to iteratively access trees in the grid |
| CvtkHyperTreeGridLevelEntry | LevelEntry is a cache data for cursors requiring level info |
| CvtkHyperTreeGridScales | A specifalized type of vtkHyperTreeGrid for the case when root cells have uniform sizes in each direction * |
| CvtkImage2DIslandPixel_t | |
| CvtkImageBSplineInternals | BSpline code from P |
| CvtkImageComplex_t | |
| 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 |
| ►CvtkInterpolationInfo | |
| CvtkInterpolationWeights | |
| CvtkInterpolationMath | |
| CvtkInterpolatorInternals | Internals for vtkImageInterpolator |
| CvtkIntersectionCounter | Fast simple class for dealing with ray intersections |
| CvtkIOStream | Include C++ iostreams as used by VTK |
| CvtkIOStreamFwd | Forward-declare C++ iostreams as used by VTK |
| CvtkLagrangianParticle | Basis class for Lagrangian particles |
| CvtkLagrangianThreadedData | Struct to hold a user data |
| CvtkLargeInteger | Class for arbitrarily large ints |
| CvtkLASRasterReader | Reads LIDAR data saved using the LAS file format |
| 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_t | |
| CvtkMapMaskTextureId | |
| CvtkMathPrivate | Internal toolkit used in some vtkMath methods |
| CvtkMathTextUtilitiesCleanup | |
| CvtkMathUtilities | Templated utility math functions intended for internal use in tests etc |
| CvtkObjectBase::vtkMemkindRAII | A class to help modify and restore the global UsingMemkind state, like SetUsingMemkind(newValue), but safer |
| 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< vtkActor2D > | |
| CvtkNew< vtkAppendPolyData > | |
| CvtkNew< vtkArrowSource > | |
| CvtkNew< vtkAxis > | |
| CvtkNew< vtkBezierCurve > | |
| CvtkNew< vtkBezierInterpolation > | |
| CvtkNew< vtkBezierQuadrilateral > | |
| CvtkNew< vtkBezierTriangle > | |
| CvtkNew< vtkBiQuadraticQuad > | |
| CvtkNew< vtkBiQuadraticTriangle > | |
| CvtkNew< vtkBlueObeliskData > | |
| CvtkNew< vtkBox > | |
| CvtkNew< vtkBrush > | |
| CvtkNew< vtkCallbackCommand > | |
| CvtkNew< vtkCamera > | |
| CvtkNew< vtkCameraInterpolator > | |
| CvtkNew< vtkCategoryLegend > | |
| CvtkNew< vtkCellArray > | |
| CvtkNew< vtkCellData > | |
| CvtkNew< vtkCellPicker > | |
| CvtkNew< vtkColorLegend > | |
| CvtkNew< vtkCompositeDataProbeFilter > | |
| CvtkNew< vtkConeSource > | |
| CvtkNew< vtkContext2D > | |
| CvtkNew< vtkContext3D > | |
| CvtkNew< vtkContextClip > | |
| CvtkNew< vtkContextTransform > | |
| CvtkNew< vtkContourValues > | |
| CvtkNew< vtkControlPointsAddPointItem > | |
| CvtkNew< vtkCoordinate > | |
| CvtkNew< vtkDataArraySelection > | |
| CvtkNew< vtkDataSetCollection > | |
| CvtkNew< vtkDiskSource > | |
| CvtkNew< vtkDoubleArray > | |
| CvtkNew< vtkEllipticalButtonSource > | |
| CvtkNew< vtkEmptyCell > | |
| CvtkNew< vtkExtentTranslator > | |
| CvtkNew< vtkFileSeriesHelper > | |
| CvtkNew< vtkFlagpoleLabel > | |
| CvtkNew< vtkFloatArray > | |
| CvtkNew< vtkGenericCell > | |
| CvtkNew< vtkGlyph3DMapper > | |
| CvtkNew< vtkGraphLayout > | |
| CvtkNew< vtkHexahedron > | |
| CvtkNew< vtkIdList > | |
| CvtkNew< vtkIdTypeArray > | |
| CvtkNew< vtkImageData > | |
| CvtkNew< vtkImageResize > | |
| CvtkNew< vtkIncrementalForceLayout > | |
| CvtkNew< vtkInformation > | |
| CvtkNew< vtkIntArray > | |
| CvtkNew< vtkLagrangeCurve > | |
| CvtkNew< vtkLagrangeInterpolation > | |
| CvtkNew< vtkLagrangeQuadrilateral > | |
| CvtkNew< vtkLagrangeTriangle > | |
| CvtkNew< vtkLineSource > | |
| CvtkNew< vtkLookupTable > | |
| CvtkNew< vtkMatrix4x4 > | |
| CvtkNew< vtkMinimalStandardRandomSequence > | |
| CvtkNew< vtkMultiBlockDataSet > | |
| CvtkNew< vtkOpenGLActor > | |
| CvtkNew< vtkOpenGLBufferObject > | |
| CvtkNew< vtkOpenGLCellToVTKCellMap > | |
| CvtkNew< vtkOpenGLFXAAFilter > | |
| CvtkNew< vtkOpenGLInstanceCulling > | |
| CvtkNew< vtkOpenGLPolyDataMapper > | |
| CvtkNew< vtkOpenGLSphereMapper > | |
| CvtkNew< vtkOpenGLStickMapper > | |
| CvtkNew< vtkParametricFunctionSource > | |
| CvtkNew< vtkPen > | |
| CvtkNew< vtkPeriodicTable > | |
| CvtkNew< vtkPlaneCollection > | |
| CvtkNew< vtkPlotBar > | |
| CvtkNew< vtkPlotGrid > | |
| CvtkNew< vtkPlotLine > | |
| CvtkNew< vtkPointData > | |
| CvtkNew< vtkPoints > | |
| CvtkNew< vtkPoints2D > | |
| CvtkNew< vtkPolyData > | |
| CvtkNew< vtkPolyDataMapper > | |
| CvtkNew< vtkPolyDataMapper2D > | |
| CvtkNew< vtkPolyLineSource > | |
| CvtkNew< vtkProperty > | |
| CvtkNew< vtkProperty2D > | |
| CvtkNew< vtkPropPicker > | |
| CvtkNew< vtkPruneTreeFilter > | |
| CvtkNew< vtkPyramid > | |
| CvtkNew< vtkQuadraticEdge > | |
| CvtkNew< vtkRenderer > | |
| CvtkNew< vtkRenderTimerLog > | |
| CvtkNew< vtkRuledSurfaceFilter > | |
| CvtkNew< vtkSphereSource > | |
| CvtkNew< vtkStereoCompositor > | |
| CvtkNew< vtkStreamSurface > | |
| CvtkNew< vtkStreamTracer > | |
| CvtkNew< vtkStringArray > | |
| CvtkNew< vtkSurfaceLICInterface > | |
| CvtkNew< vtkTable > | |
| CvtkNew< vtkTetra > | |
| CvtkNew< vtkTextActor3D > | |
| CvtkNew< vtkTextProperty > | |
| CvtkNew< vtkTextRenderer > | |
| CvtkNew< vtkTexture > | |
| CvtkNew< vtkTextureObject > | |
| CvtkNew< vtkTimerLog > | |
| CvtkNew< vtkTooltipItem > | |
| CvtkNew< vtkTransform > | |
| CvtkNew< vtkTransform2D > | |
| CvtkNew< vtkTransformFilter > | |
| CvtkNew< vtkTransformPolyDataFilter > | |
| CvtkNew< vtkTrivialProducer > | |
| CvtkNew< vtkTubeFilter > | |
| CvtkNew< vtkUniforms > | |
| CvtkNew< vtkUnsignedCharArray > | |
| CvtkNew< vtkUnsignedShortArray > | |
| CvtkNew< vtkUnstructuredGrid > | |
| CvtkNew< vtkVariantArray > | |
| CvtkNew< vtkVRHardwarePicker > | |
| CvtkNew< vtkVRMenuRepresentation > | |
| CvtkNew< vtkVRMenuWidget > | |
| CvtkNew< vtkVRRay > | |
| CvtkNew< vtkWindowToImageFilter > | |
| CvtkNumberToString | Convert floating and fixed point numbers to strings |
| 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 |
| CvtkTclCommand | |
| ►CvtkEventData | |
| ►CvtkEventDataForDevice | |
| CvtkEventDataDevice3D | |
| ►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 |
| CvtkLogger | Logging framework for use in VTK and in applications based on VTK |
| ►CvtkObject | Abstract base class for most VTK objects |
| CvtkBuffer< ValueType > | |
| CExternalVTKWidget | |
| 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 |
| ►CvtkAbstractArray | Abstract superclass for all arrays |
| ►CvtkDataArray | Abstract superclass for arrays of numeric data |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< ValueTypeT >, ValueTypeT > | |
| CvtkAOSDataArrayTemplate< ValueTypeT > | Array-Of-Structs implementation of vtkGenericDataArray |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< char >, char > | |
| ►CvtkAOSDataArrayTemplate< char > | |
| CvtkCharArray | Dynamic, self-adjusting array of char |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< double >, double > | |
| ►CvtkAOSDataArrayTemplate< double > | |
| CvtkDoubleArray | Dynamic, self-adjusting array of double |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< float >, float > | |
| ►CvtkAOSDataArrayTemplate< float > | |
| CvtkFloatArray | Dynamic, self-adjusting array of float |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< vtkIdType >, vtkIdType > | |
| ►CvtkAOSDataArrayTemplate< vtkIdType > | |
| CvtkIdTypeArray | Dynamic, self-adjusting array of vtkIdType |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< int >, int > | |
| ►CvtkAOSDataArrayTemplate< int > | |
| CvtkIntArray | Dynamic, self-adjusting array of int |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< long >, long > | |
| ►CvtkAOSDataArrayTemplate< long > | |
| CvtkLongArray | Dynamic, self-adjusting array of long |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< long long >, long long > | |
| ►CvtkAOSDataArrayTemplate< long long > | |
| CvtkLongLongArray | Dynamic, self-adjusting array of long long |
| ►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< vtkScaledSOADataArrayTemplate< ValueTypeT >, ValueTypeT > | |
| CvtkScaledSOADataArrayTemplate< ValueTypeT > | Struct-Of-Arrays implementation of vtkGenericDataArray with a scaling factor |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< short >, short > | |
| ►CvtkAOSDataArrayTemplate< short > | |
| CvtkShortArray | Dynamic, self-adjusting array of short |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< signed char >, signed char > | |
| ►CvtkAOSDataArrayTemplate< signed char > | |
| CvtkSignedCharArray | Dynamic, self-adjusting array of signed char |
| ►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 |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< unsigned char >, unsigned char > | |
| ►CvtkAOSDataArrayTemplate< unsigned char > | |
| CvtkUnsignedCharArray | Dynamic, self-adjusting array of unsigned char |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< unsigned int >, unsigned int > | |
| ►CvtkAOSDataArrayTemplate< unsigned int > | |
| CvtkUnsignedIntArray | Dynamic, self-adjusting array of unsigned int |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< unsigned long >, unsigned long > | |
| ►CvtkAOSDataArrayTemplate< unsigned long > | |
| CvtkUnsignedLongArray | Dynamic, self-adjusting array of unsigned long |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< unsigned long long >, unsigned long long > | |
| ►CvtkAOSDataArrayTemplate< unsigned long long > | |
| CvtkUnsignedLongLongArray | Dynamic, self-adjusting array of unsigned long long |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< unsigned short >, unsigned short > | |
| ►CvtkAOSDataArrayTemplate< unsigned short > | |
| CvtkUnsignedShortArray | Dynamic, self-adjusting array of unsigned short |
| ►CvtkGenericDataArray< vtkmDataArray< T >, T > | |
| CvtkmDataArray< T > | |
| ►CvtkGenericDataArray< vtkAOSDataArrayTemplate< Scalar >, Scalar > | |
| CvtkAOSDataArrayTemplate< Scalar > | |
| CvtkBitArray | Dynamic, self-adjusting array of bits |
| CvtkGenericDataArray< DerivedT, ValueTypeT > | Base interface for all typed vtkDataArray subclasses |
| 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 |
| ►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 |
| CvtkOTScatterPlotMatrix | Container for a matrix of charts |
| ►CvtkContextArea | Clipped, transformed area with axes for context items |
| CvtkInteractiveArea | Implements zooming and panning in a vtkContextArea |
| 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 |
| CvtkEqualizerContextItem | Draws a interactive polyline |
| 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 |
| ►CvtkPlotRangeHandlesItem | Item to show and control a range on vtkAxis |
| CvtkPlotBarRangeHandlesItem | Show and control the range of a vtkAxis used with a vtkPlotBar |
| CvtkRangeHandlesItem | Item to show and control the range of a vtkColorTransferFunction |
| 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 internal 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 |
| ►CvtkPolyDataItem | Filter that translate a vtkPolyData 2D mesh into vtkContextItems |
| CvtkLabeledContourPolyDataItem | Filter that translate a vtkPolyData 2D mesh into vtkContextItems |
| CvtkPythonItem | A vtkContextItem that can be implemented in Python |
| 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 |
| ►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 |
| CvtkGenericImageInterpolator | Interpolate data values from images using vtkGenericDataArray API |
| 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 |
| CvtkVRHardwarePicker | Pick an actor/prop given a controller position and orientation |
| 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 |
| 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 |
| 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 |
| CvtkAbstractHyperTreeGridMapper | Abstract class for a HyperTreeGrid mapper |
| CvtkOpenGLFluidMapper | Render fluid from position data (and color, if available) |
| ►CvtkUnstructuredGridVolumeMapper | Abstract class for an unstructured grid volume mapper |
| CvtkMultiBlockUnstructuredGridVolumeMapper | Mapper to render volumes defined as vtkMultiBlockDataSet |
| ►CvtkProjectedTetrahedraMapper | Unstructured grid volume renderer |
| 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 implementation of volume rendering through ray-casting |
| CvtkMultiBlockVolumeMapper | Mapper to render volumes defined as vtkMultiBlockDataSet |
| ►CvtkOSPRayVolumeInterface | Removes link dependence on optional ospray module |
| CvtkOSPRayVolumeMapper | Standalone OSPRayVolumeMapper |
| CvtkSmartVolumeMapper | Adaptive volume mapper |
| ►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 |
| ►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 |
| 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 OpenGL2 API |
| ►CvtkMoleculeMapper | Mapper that draws vtkMolecule objects |
| CvtkOpenGLMoleculeMapper | An accelerated class for rendering molecules |
| ►CvtkPolyDataMapper | Map vtkPolyData to graphics primitives |
| ►CvtkOpenGLPolyDataMapper | PolyDataMapper using OpenGL to render |
| CvtkCompositeMapperHelper2 | Helper class for vtkCompositePolyDataMapper2 that is a subclass of vtkOpenGLPolyDataMapper |
| ►CvtkCompositePolyDataMapper2 | Mapper for composite dataset consisting of polygonal data |
| CvtkCompositeSurfaceLICMapper | Mapper for composite dataset |
| 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 |
| ►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 |
| CvtkLabelPlacementMapper | Places and renders non-overlapping labels |
| ►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 |
| ►CvtkPolyDataMapper2D | Draw vtkPolyData onto the image plane |
| 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, identified 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 |
| CvtkmNDHistogram | Generate a n dimensional histogram field from input fields |
| ►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 |
| CvtkExtractBlockUsingDataAssembly | Extract blocks from certain composite datasets |
| 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 |
| Cvtk3DLinearGridCrinkleExtractor | Fast extraction of cells intersected by a plane |
| Cvtk3DLinearGridPlaneCutter | Fast plane cutting of vtkUnstructuredGrid containing 3D linear cells |
| CvtkADIOS2CoreImageReader | Read ADIOS2 bp files |
| CvtkAdaptiveResampleToImage | Samples a dataset with adaptive refinements |
| CvtkAreaContourSpectrumFilter | Compute an approximation of the area contour signature (evolution of the area of the input surface along an arc of the Reeb graph) |
| CvtkContour3DLinearGrid | Fast generation of isosurface from 3D linear cells |
| CvtkDataObjectGenerator | Produces simple (composite or atomic) data sets for testing |
| CvtkDataSetToDataObjectFilter | Map dataset into data object (i.e., a field) |
| ►CvtkDistributedDataFilter | Serial stand-in for parallel filter that distributes data among processors |
| CvtkPDistributedDataFilter | Distribute data among processors |
| CvtkExtractSelection | Extract a subset from a vtkDataSet |
| ►CvtkExtractSelectionBase | Abstract base class for all extract selection filters |
| CvtkExtractSelectedBlock | Extract-Selection filter to extract blocks |
| 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 |
| CvtkProbeSelectedLocations | Similar to vtkExtractSelectedLocations except that it interpolates the point attributes at the probe locations |
| CvtkExtractSubsetWithSeed | Extract a line or plane in the ijk space starting with a seed |
| CvtkExtractTemporalFieldData | Extract temporal arrays from input field data |
| CvtkGenerateIndexArray | Generates a new vtkIdTypeArray containing zero-base indices |
| CvtkGroupDataSetsFilter | Groups inputs into a chosen composite dataset |
| CvtkGroupTimeStepsFilter | Converts a temporal dataset into non-temporal dataset |
| CvtkImageDataToUniformGrid | Convert vtkImageData to vtkUniformGrid |
| ►CvtkLagrangianParticleTracker | Filter to inject and track particles in a flow |
| CvtkPLagrangianParticleTracker | Parallel Lagrangian particle tracker |
| ►CvtkNetCDFReader | A superclass for reading netCDF files |
| CvtkNetCDFCFReader | Reads netCDF files that follow the CF convention |
| CvtkOMFReader | Read Open Mining Format files |
| CvtkPassArrays | Passes a subset of arrays to the output |
| CvtkPlaneCutter | Cut any dataset with a plane and generate a polygonal cut surface |
| CvtkProbeLineFilter | Probe dataset along a line in parallel |
| CvtkProgrammableDataObjectSource | Generate source data object via a user-specified function |
| CvtkProgrammableSource | Generate source dataset via a user-specified function |
| CvtkRedistributeDataSetFilter | Redistributes input dataset into requested number of partitions |
| 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) |
| CvtkXdmf3Reader | Reads eXtensible Data Model and Format files |
| ►CvtkXdmf3Writer | Write eXtensible Data Model and Format files |
| CvtkPXdmf3Writer | Mpi parallel writer for XDMF/HDF5 files |
| CvtkXdmfReader | Reads eXtensible Data Model and Format files |
| CvtkXdmfWriter | Write eXtensible Data Model and Format files |
| ►CvtkDataSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| 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 |
| CvtkCellValidator | Validates cells in a dataset |
| 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 |
| CvtkDeflectNormals | Deflect normals using a 3 component vector field |
| ►CvtkDicer | Abstract superclass to divide dataset into pieces |
| CvtkOBBDicer | Divide dataset into spatially aggregated pieces |
| ►CvtkElevationFilter | Generate scalars along a specified direction |
| CvtkmPointElevation | Generate a scalar field along a specified direction |
| CvtkExtractCellsByType | Extract cells of a specified type |
| 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 |
| CvtkmGradient | A general filter for gradient estimation |
| CvtkHDFReader | VTKHDF format reader |
| CvtkIdFilter | Generate scalars or field data from point and cell ids |
| CvtkImageProbeFilter | Sample image values at specified point positions |
| CvtkImplicitTextureCoords | Generate 1D, 2D, or 3D texture coordinates based on implicit function(s) |
| CvtkInterpolateDataSetAttributes | Interpolate scalars, vectors, etc |
| CvtkMarkBoundaryFilter | Mark points and cells that lie on the boundary of a dataset |
| 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 |
| CvtkPDataSetReader | Manages reading pieces of a data set |
| CvtkPassThroughFilter | Filter which shallow copies it's input to it's output |
| 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 |
| 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 |
| CvtkSPHInterpolator | Interpolate over point cloud using SPH kernels |
| CvtkSampleImplicitFunctionFilter | Sample an implicit function over a dataset, generating scalar values and optional gradient vectors |
| CvtkSegYReader | Reads SegY data files |
| CvtkSelectEnclosedPoints | Mark points as to whether they are inside a closed surface |
| CvtkSimpleElevationFilter | Generate scalars along a specified direction |
| 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 |
| CvtkPTextureMapToSphere | 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 |
| CvtkmAverageToCells | |
| CvtkmAverageToPoints | Accelerated point to cell interpolation filter |
| CvtkmProbe | Sample data at specified point locations |
| ►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 |
| ►CvtkExplicitStructuredGridAlgorithm | Superclass for algorithms that produce only explicit structured grid as output |
| CvtkExplicitStructuredGridCrop | Filter which extracts a piece of explicit structured grid changing its extents |
| CvtkImageDataToExplicitStructuredGrid | Filter which converts a 3D image data into an explicit structured grid |
| CvtkUnstructuredGridToExplicitStructuredGrid | Filter which converts an unstructured grid data into an explicit structured grid |
| CvtkFidesReader | Read ADIOS2 streams using Fides data model |
| ►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 |
| CvtkPerturbCoincidentVertices | Perturbs vertices that are coincident |
| CvtkRandomGraphSource | Graph with random edges |
| CvtkRemoveIsolatedVertices | Remove vertices of a vtkGraph with degree zero |
| CvtkSQLDatabaseGraphSource | Generates a vtkGraph based on an SQL query |
| CvtkSQLGraphReader | Read a vtkGraph from a database |
| CvtkSplineGraphEdges | Subsample graph edges to make smooth curves |
| 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 |
| ►CvtkHyperTreeGridAlgorithm | Superclass for algorithms that produce a hyper tree grid as output |
| CvtkHyperTreeGridAxisClip | Axis aligned hyper tree grid clip |
| CvtkHyperTreeGridAxisCut | Axis aligned hyper tree grid cut |
| CvtkHyperTreeGridAxisReflection | Reflect a hyper tree grid |
| CvtkHyperTreeGridContour | Extract cells from a hyper tree grid where selected scalar value is within given range |
| CvtkHyperTreeGridDepthLimiter | Hyper tree grid level extraction |
| CvtkHyperTreeGridEvaluateCoarse | The value of the parent cell is determined from an operation defined on the values of the child cells |
| CvtkHyperTreeGridGeometry | Hyper tree grid outer surface |
| CvtkHyperTreeGridGhostCellsGenerator | Generated ghost cells (HyperTree's distributed) |
| CvtkHyperTreeGridOutlineFilter | Create wireframe outline for arbitrary data set |
| CvtkHyperTreeGridPlaneCutter | Cut an hyper tree grid volume with a plane and generate a polygonal cut surface |
| ►CvtkHyperTreeGridSource | Create a synthetic grid of hypertrees |
| CvtkUniformHyperTreeGridSource | Create a synthetic grid of uniform hypertrees |
| CvtkHyperTreeGridThreshold | Extract cells from a hyper tree grid where selected scalar value is within given range |
| CvtkHyperTreeGridToDualGrid | Convert hyper tree grid to the dual unstructured grid |
| CvtkHyperTreeGridToUnstructuredGrid | Convert hyper tree grid to unstructured grid |
| CvtkImageDataToHyperTreeGrid | |
| CvtkRandomHyperTreeGridSource | Builds a randomized but reproducible vtkHyperTreeGrid |
| ►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 |
| CvtkContinuousScatterplot | Given a 3D domain space represented by an unstructured grid composed of tetrahedral cells with bivariate fields, this filter tessellates each cell in the domain to polyhedral fragments by intersecting the projection of the cell into 2-D range space against two sets of cutting planes, one set is defined along the first field, the second set is defined along the second field |
| CvtkDEMReader | Read a digital elevation model (DEM) file |
| ►CvtkExtractVOI | Select piece (e.g., volume of interest) and/or subsample structured points dataset |
| CvtkPExtractVOI | |
| CvtkmExtractVOI | Select piece (e.g., volume of interest) and/or subsample structured points dataset |
| 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 |
| CvtkMP4Writer | Writes Windows MP4 files on Windows platforms |
| CvtkOggTheoraWriter | Uses the ogg and theora libraries to write video files |
| CvtkH5RageReader | Class for reading Rage HDF data files |
| 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 |
| ►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 |
| CvtkHDRReader | Read Radiance HDR 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 |
| CvtkMINCImageReader | A reader for MINC files |
| ►CvtkMedicalImageReader2 | VtkImageReader2 with medical meta data |
| CvtkGESignaReader | Read GE Signa ximg files |
| CvtkMetaImageReader | Read binary UNC meta image data |
| 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 |
| CvtkTGAReader | Read PNG files |
| ►CvtkTIFFReader | Read TIFF files |
| CvtkOMETIFFReader | Reader for OME 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 |
| CvtkMINCImageWriter | A writer for MINC files |
| CvtkMetaImageWriter | Write a binary UNC meta image data |
| 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 |
| CvtkPResampleFilter | Probe dataset in parallel using a vtkImageData |
| CvtkPointDensityFilter | Produce density field from input point cloud |
| CvtkPointLoad | Compute stress tensors given point load on semi-infinite domain |
| CvtkPointOccupancyFilter | Produce occupancy bit mask from input point cloud |
| CvtkQImageToImageSource | Create image data from a QImage |
| CvtkRTAnalyticSource | Create an image for regression testing |
| CvtkRasterReprojectionFilter | Transform a VTK image data to a different projection |
| CvtkSEPReader | Stanford Exploration Project files reader |
| 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 |
| CvtkSphericalHarmonics | Compute spherical harmonics of an equirectangular projection image |
| CvtkSurfaceReconstructionFilter | Reconstructs a surface from unorganized points |
| ►CvtkTexture | Handles properties associated with a texture map |
| ►CvtkOpenGLTexture | OpenGL texture map |
| CvtkEquirectangularToCubeMapTexture | Compute a cubemap texture based on a standard equirectangular projection |
| CvtkPBRIrradianceTexture | Precompute irradiance texture used in physically based rendering |
| CvtkPBRLUTTexture | Precompute BRDF look-up table texture used in physically based rendering |
| CvtkPBRPrefilterTexture | Precompute prefilter texture used in physically based rendering |
| ►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 |
| CvtkImageBSplineCoefficients | Convert image to b-spline knots |
| CvtkImageBlend | Blend images together using alpha or opacity |
| 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 |
| CvtkImageHSIToRGB | Converts HSI components to RGB |
| CvtkImageHSVToRGB | Converts HSV components to RGB |
| ►CvtkImageHistogram | Compute the histogram for an image |
| CvtkImageHistogramStatistics | Compute statistics for an image |
| 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 | |
| ►CvtkImageMapToColors | Map the input image through a lookup table |
| CvtkImageMapToRGBA | Map the input image through a lookup table |
| CvtkImageMapToWindowLevelColors | Map an image through a lookup table and/or a window/level |
| 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 |
| CvtkImageRGBToHSI | Converts RGB components to HSI |
| CvtkImageRGBToHSV | Converts RGB components to HSV |
| CvtkImageRGBToYIQ | Converts RGB components to YIQ |
| 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 |
| 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 |
| CvtkUnsignedDistance | Compute unsigned (i.e., non-negative) distances from an input point cloud |
| CvtkVPICReader | Class for reading VPIC data files |
| ►CvtkVideoSource | Superclass of video input devices for VTK |
| CvtkFFMPEGVideoSource | Reader for ffmpeg supported formats |
| 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 |
| CvtkWordCloud | Generate a word cloud visualization of a text document |
| CvtkmImageConnectivity | Label regions inside an image by connectivity |
| ►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 |
| CvtkMoleculeAppend | Appends one or more molecules into a single molecule |
| CvtkPointSetToMoleculeFilter | |
| ►CvtkSimpleBondPerceiver | Create a simple guess of a molecule's topology |
| CvtkPSimpleBondPerceiver | 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 |
| CvtkADIOS2VTXReader | |
| ►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 |
| CvtkAMReXParticlesReader | Reader for AMReX plotfiles particle data |
| CvtkBlockIdScalars | Generates scalars from blocks |
| CvtkCGNSFileSeriesReader | Adds support for reading temporal or partitioned CGNS files |
| CvtkCGNSReader | VtkCGNSReader creates a multi-block dataset and reads unstructured grids, and structured meshes from binary files stored in CGNS file format, with data stored at the nodes or at the cells |
| 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 |
| CvtkCityGMLReader | Read CityGML data file |
| ►CvtkConvertToMultiBlockDataSet | Converts any data type into a vtkMultiBlockDataSet |
| CvtkPConvertToMultiBlockDataSet | Parallel version of vtkConvertToMultiBlockDataSet |
| ►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) |
| CvtkExtractCTHPart | Generates surface of a CTH volume fraction |
| ►CvtkExtractDataArraysOverTime | Extracts array from input dataset over time |
| CvtkPExtractDataArraysOverTime | Parallel version of vtkExtractDataArraysOverTime |
| ►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 | Extract levels between min and max |
| ►CvtkExtractSelectedArraysOverTime | Extracts a selection over time |
| CvtkPExtractSelectedArraysOverTime | Extracts a selection over time |
| CvtkFLUENTReader | Reads a dataset in Fluent file format |
| CvtkGDALVectorReader | Read vector file formats using GDAL |
| CvtkGLTFReader | Read a GLTF file |
| ►CvtkGenericEnSightReader | Class to read any type of EnSight files |
| CvtkEnSightMasterServerReader | Reader for compound 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 |
| CvtkMergeTimeFilter | Create a multiblock containing one block per input, with unified timestep list |
| CvtkMotionFXCFGReader | Reader for MotionFX motion definitions cfg files |
| CvtkMultiBlockDataGroupFilter | Collects multiple inputs into one multi-group dataset |
| CvtkMultiBlockFromTimeSeriesFilter | Converts a temporal dataset into multiblock |
| CvtkMultiBlockMergeFilter | Merges multiblock inputs into a single multiblock output |
| CvtkMultiThreshold | Threshold cells within multiple intervals |
| CvtkOTDensityMap | A VTK Filter to compute density map on any pair of numeric data arrays with the same number of tuples, using OpenTURNS |
| ►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 |
| CvtkPIOReader | Class for reading PIO (Parallel Input Output) data files |
| ►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) |
| CvtkSplitByCellScalarFilter | Splits input dataset according an integer cell scalar array |
| CvtkStructuredGridPartitioner | A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides functionality for partitioning a VTK structured grid dataset |
| CvtkTRUCHASReader | Read GE TRUCHAS format HDF5 files |
| CvtkTecplotReader | A concrete class to read an ASCII Tecplot file |
| 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 |
| CvtkTemporalArrayOperatorFilter | Perform simple mathematical operation on a data array at different time |
| ►CvtkTemporalInterpolator | Interpolate datasets between time steps to produce a new dataset |
| CvtkAdaptiveTemporalInterpolator | Interpolate datasets between time steps to produce a new dataset |
| ►CvtkPartitionedDataSetAlgorithm | Superclass for algorithms that produce vtkPartitionedDataSetAlgorithm |
| CvtkPartitionBalancer | Balances input partitioned data sets so each rank has the same number of data sets |
| CvtkPartitionedDataSetSource | Source that produces a vtkPartitionedDataSet |
| ►CvtkPartitionedDataSetCollectionAlgorithm | Superclass for algorithms that produce vtkPartitionedDataSetCollectionAlgorithm |
| CvtkCONVERGECFDReader | Reader for CONVERGE CFD post files |
| CvtkConvertToPartitionedDataSetCollection | Convert any dataset to vtkPartitionedDataSetCollection |
| CvtkPartitionedDataSetCollectionSource | Source that produces a vtkPartitionedDataSetCollection |
| ►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 |
| ►CvtkAggregateDataSetFilter | Aggregates data sets to a reduced number of processes |
| CvtkDIYAggregateDataSetFilter | Aggregates data sets to a reduced number of processes |
| CvtkAnimateModes | Animate mode shapes |
| CvtkAppendLocationAttributes | Add point locations to point data and/or cell centers cell data, respectively |
| CvtkApplyColors | Apply colors to a data set |
| CvtkApplyIcons | Apply icons to a data set |
| CvtkArrayCalculator | Perform mathematical operations on data in field data arrays |
| 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 |
| ►CvtkCellSizeFilter | Computes cell sizes |
| CvtkPCellSizeFilter | Computes cell sizes in parallel |
| 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 | |
| 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 | |
| CvtkDateToNumeric | Converts string dates to numeric values |
| CvtkExpandMarkedElements | Expands marked elements to including adjacent elements |
| CvtkExtractBlock | Extracts blocks from a vtkDataObjectTree subclass |
| CvtkExtractTimeSteps | Extract specific time-steps from dataset |
| CvtkForceTime | |
| CvtkGenerateGlobalIds | Generates global point and cell ids |
| CvtkGhostCellsGenerator | Computes ghost cells on vtkCompositeDataSet inputs |
| 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 |
| ►CvtkMergeArrays | Multiple inputs with one output |
| CvtkPMergeArrays | Multiple inputs with one output, parallel version |
| CvtkMergeVectorComponents | Merge components of many single-component arrays into one vector |
| CvtkOverlappingCellsDetector | Exposes how many cells each cell of the input collide |
| CvtkPassSelectedArrays | Pass through chosen arrays |
| CvtkPassThrough | Pass input input data through to the output |
| CvtkProgrammableFilter | User-programmable filter |
| CvtkRandomAttributeGenerator | Generate and create random data attributes |
| CvtkRemoveGhosts | Remove ghost points, cells and arrays |
| CvtkRemoveHiddenData | Removes the rows/edges/vertices of input data flagged by ann |
| ►CvtkResampleWithDataSet | Sample point and cell data of a dataset on points from another dataset |
| CvtkPResampleWithDataSet | Points from another dataset |
| CvtkSynchronizeTimeFilter | Set "close" time step values from the second input to the first |
| CvtkTemporalSnapToTimeStep | Modify the time range/steps of temporal data |
| 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 | |
| ►CvtkPointSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| CvtkAppendDataSets | Appends one or more datasets together into a single output vtkPointSet |
| CvtkCenterOfMass | Find the center of mass of a set of points |
| ►CvtkConnectivityFilter | Extract data based on geometric connectivity |
| CvtkPConnectivityFilter | Parallel version of vtkConnectivityFilter |
| CvtkDeformPointSet | Use a control polyhedron to deform an input vtkPointSet |
| CvtkDistanceToCamera | Calculates distance from points to the camera |
| CvtkDistributedPointCloudFilter | Distributes points among MPI processors |
| CvtkExtractDataOverTime | Extract point data from a time sequence for a specified point id |
| CvtkHausdorffDistancePointSetFilter | Compute Hausdorff distance between two point sets |
| CvtkPointSmoothingFilter | Adjust point positions to form a pleasing, packed arrangement |
| CvtkPoissonDiskSampler | Generate point normals using local tangent planes |
| ►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 |
| CvtkmWarpScalar | Deform geometry with scalar data |
| CvtkWarpTo | Deform geometry by warping towards a point |
| ►CvtkWarpVector | Deform geometry with vector data |
| CvtkmWarpVector | Deform geometry with vector data |
| CvtkWeightedTransformFilter | Transform based on per-point or per-cell weighting functions |
| CvtkmCoordinateSystemTransform | Transform a coordinate system between Cartesian&Cylindrical and Cartesian&Spherical |
| CvtkmPointTransform | Transform points via vtkm PointTransform filter |
| ►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 |
| CvtkAppendArcLength | Appends Arc length for input poly lines |
| CvtkAppendPoints | Appends points of one or more vtkPolyData data sets |
| CvtkAppendPolyData | Appends one or more polygonal datasets together |
| 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 |
| CvtkBYUReader | Read MOVIE.BYU polygon files |
| CvtkBandedPolyDataContourFilter | Generate filled contours for vtkPolyData |
| CvtkBinnedDecimation | Reduce the number of triangles in a vtkPolyData mesh |
| 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 |
| CvtkCapsuleSource | Generate a capsule centered at the origin |
| ►CvtkCellCenters | Generate points at center of cells |
| CvtkHyperTreeGridCellCenters | Generate points at center of hyper tree grid leaf cell centers |
| 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 |
| CvtkCollisionDetectionFilter | Performs collision determination between two polyhedral surfaces |
| ►CvtkCompositeDataGeometryFilter | Extract geometry from multi-group data |
| CvtkHierarchicalDataSetGeometryFilter | Extract geometry from hierarchical data |
| CvtkConeSource | Generate polygonal cone |
| CvtkConnectedPointsFilter | Extract / segment points based on geometric connectivity |
| ►CvtkContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkmContour | Generate isosurface(s) from volume |
| ►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 |
| CvtkContourLoopExtraction | Extract closed loops (polygons) from lines and polylines |
| CvtkContourTriangulator | Fill all 2D contours to create polygons |
| CvtkConvertToPointCloud | Convert any dataset to a point cloud |
| CvtkConvexHull2D | Produce filled convex hulls around a set of points |
| CvtkCookieCutter | Cut vtkPolyData defined on the 2D plane with one or more polygons |
| 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 surface (as vtkPolyData) of any dataset |
| 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 |
| CvtkDensifyPointCloudFilter | Add points to a point cloud to make it denser |
| 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 |
| CvtkDiscreteFlyingEdges2D | Generate isoline(s) from 2D image data |
| CvtkDiscreteFlyingEdges3D | Generate isosurface from 3D image data (volume) |
| CvtkDiscreteFlyingEdgesClipper2D | Generate filled regions from segmented 2D image data |
| CvtkDiskSource | Create a disk with hole in center |
| CvtkDistancePolyDataFilter | Computes the signed distance from one vtkPolyData to another |
| 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 |
| CvtkEvenlySpacedStreamlines2D | Evenly spaced streamline generator for 2D |
| CvtkExplicitStructuredGridSurfaceFilter | Filter which creates a surface (polydata) from an explicit structured grid |
| 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 interior, boundary, non-manifold, and/or sharp edges from polygonal data |
| CvtkFiberSurface | Given a fiber surface control polygon (FSCP) and an unstructured grid composed of tetrahedral cells with two scalar arrays, this filter computes the corresponding fiber surfaces |
| CvtkFillHolesFilter | Identify and fill holes in meshes |
| CvtkFitToHeightMapFilter | Adjust polydata to fit image height map |
| CvtkFlyingEdges2D | Generate isoline(s) from a structured points (image) dataset |
| 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 |
| CvtkGeoJSONReader | Convert Geo JSON format to vtkPolyData |
| ►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 |
| ►CvtkGeometryFilter | Extract boundary geometry from dataset (or convert data to polygonal type) |
| CvtkAdaptiveDataSetSurfaceFilter | Adaptively extract dataset surface |
| ►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 |
| CvtkH5PartReader | Read H5Part particle files |
| ►CvtkHandleSource | Interface that can be inherited to define handler sources for any kind of interaction |
| CvtkCameraHandleSource | Handle source used to represent one camera |
| CvtkPointHandleSource | Handle source used to represent points |
| CvtkHedgeHog | Create oriented lines from vector data |
| CvtkHierarchicalBinningFilter | Uniform binning of points into a hierarchical structure |
| CvtkHull | Produce an n-sided convex hull |
| CvtkHyperStreamline | Generate hyperstreamline in arbitrary dataset |
| 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 |
| CvtkImageDataOutlineFilter | Create wireframe outline for a possibly oriented vtkImageData |
| CvtkImageMarchingCubes | Generate isosurface(s) from volume/images |
| CvtkImageToPoints | Extract all image voxels as points |
| CvtkImageToPolyDataFilter | Generate linear primitives (vtkPolyData) from an image |
| CvtkImprintFilter | Imprint the contact surface of one object onto another surface |
| CvtkIntersectionPolyDataFilter | VtkIntersectionPolyDataFilter computes the intersection between two vtkPolyData objects |
| CvtkLASReader | |
| CvtkLabelPlacer | Place a prioritized hierarchy of labels in screen space |
| CvtkLineSource | Create a line defined by two end points |
| CvtkLinearCellExtrusionFilter | Extrude polygonal data to create 3D cells from 2D cells |
| ►CvtkLinearExtrusionFilter | Sweep polygonal data creating a "skirt" from free edges and lines, and lines from vertices |
| CvtkPLinearExtrusionFilter | Subclass that handles piece invariance |
| CvtkLinkEdgels | Links edgels together to form digital curves |
| CvtkLoopBooleanPolyDataFilter | Filter to perform boolean operations |
| CvtkMCubesReader | Read binary marching cubes file |
| CvtkMNIObjectReader | A reader for MNI surface mesh files |
| CvtkMNITagPointReader | A reader for MNI tag files |
| 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 |
| ►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 |
| CvtkMoleculeToLinesFilter | Convert a molecule into a simple polydata with lines |
| CvtkMultiObjectMassProperties | Compute volume and area of objects in a polygonal mesh |
| CvtkOBJPolyDataProcessor | |
| CvtkOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
| CvtkOutlineFilter | Create wireframe outline for an arbitrary data set or composite dataset |
| ►CvtkOutlineSource | Create wireframe outline around bounding box |
| CvtkOutlineCornerSource | Create wireframe outline corners around bounding box |
| CvtkPCACurvatureEstimation | Generate curvature estimates using principal component analysis |
| CvtkPCANormalEstimation | Generate point normals using local tangent planes |
| CvtkPDALReader | Reads LIDAR data using the PDAL library |
| CvtkPOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
| CvtkPOutlineFilter | Create wireframe outline for arbitrary data set |
| CvtkPTSReader | Read ASCII PTS Files |
| CvtkParallelVectors | Compute polylines corresponding to locations where two vector fields are parallel |
| 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 |
| ►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 |
| CvtkParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkParticleTracer | A Parallel Particle tracer for unsteady vector fields |
| CvtkStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkPlaneSource | Create an array of quadrilaterals located in a plane |
| CvtkPlatonicSolidSource | Produce polygonal Platonic solids |
| ►CvtkPointCloudFilter | Abstract class for filtering a point cloud |
| CvtkExtractEnclosedPoints | Extract points inside of a closed polygonal surface |
| CvtkExtractHierarchicalBins | Manipulate the output of vtkHierarchicalBinningFilter |
| CvtkExtractPoints | Extract points within an implicit function |
| CvtkFitImplicitFunction | Extract points on the surface of an implicit function |
| CvtkMaskPointsFilter | Extract points within an image/volume mask |
| CvtkRadiusOutlierRemoval | Remove isolated points |
| CvtkStatisticalOutlierRemoval | Remove sparse outlier points |
| CvtkPointSource | Create a random cloud of points |
| CvtkPolyDataConnectivityFilter | Extract polygonal data based on geometric connectivity |
| CvtkPolyDataEdgeConnectivityFilter | Segment polygonal mesh based on shared edge connectivity |
| ►CvtkPolyDataNormals | Compute normals for polygonal mesh |
| CvtkPPolyDataNormals | Compute normals for polygonal mesh |
| CvtkmPolyDataNormals | Compute normals for polygonal mesh |
| CvtkPolyDataPlaneClipper | Clip a vtkPolyData with a plane and optionally cap it |
| CvtkPolyDataPointSampler | Generate points from vtkPolyData |
| CvtkPolyDataSilhouette | Sort polydata along camera view direction |
| CvtkPolyDataTangents | Compute tangents for triangulated polydata |
| ►CvtkPolyPointSource | Create points from a list of input points |
| CvtkPolyLineSource | Create a poly line from a list of input points |
| CvtkProgrammableGlyphFilter | Control the generation and placement of glyphs at input points |
| CvtkProjectedTerrainPath | Project a polyline onto a terrain |
| CvtkProteinRibbonFilter | Generates protein ribbons |
| 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 |
| CvtkRemoveDuplicatePolys | Remove duplicate/degenerate polygons |
| CvtkRemovePolyData | Removes vtkPolyData cells from an input vtkPolyData |
| 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 |
| CvtkSLACParticleReader | A reader for a data format used by Omega3p, Tau3p, and several other tools used at the Standford Linear Accelerator Center (SLAC) |
| CvtkScalarsToTextureFilter | Generate texture coordinates and a texture image based on a scalar field |
| 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 |
| 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 |
| CvtkSphereTreeFilter | Represent a sphere tree as vtkPolyData |
| CvtkSplineFilter | Generate uniformly subdivided polylines from a set of input polyline using a vtkSpline |
| CvtkStaticCleanPolyData | Merge duplicate points, and/or remove unused points and/or remove degenerate cells |
| ►CvtkStreamTracer | Streamline generator |
| CvtkPStreamTracer | Parallel streamline generators |
| CvtkStreamSurface | Advect a stream surface in a vector field |
| ►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 |
| ►CvtkSubdivisionFilter | Base class for subvision filters |
| ►CvtkApproximatingSubdivisionFilter | Generate a subdivision surface using an Approximating Scheme |
| CvtkLoopSubdivisionFilter | Generate a subdivision surface using the Loop Scheme |
| ►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 |
| 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 eigenvalues and eigenvectors of symmetrical part of tensor |
| 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 |
| ►CvtkTriangleMeshPointNormals | Compute point normals for triangle mesh |
| CvtkmTriangleMeshPointNormals | Compute point normals for triangle mesh |
| CvtkTriangularTCoords | 2D texture coordinates based for triangles |
| CvtkTrimmedExtrusionFilter | Extrude polygonal data trimmed by a second input surface |
| CvtkTubeBender | Rounds corners on lines for better tubes |
| CvtkTubeFilter | Filter that generates tubes around lines |
| CvtkUncertaintyTubeFilter | Generate uncertainty tubes along a polyline |
| CvtkVectorFieldTopology | Extract the topological skeleton as output datasets |
| CvtkVectorText | Create polygonal text |
| CvtkVertexGlyphFilter | Make a vtkPolyData with a vertex on each point |
| CvtkVolumeOutlineSource | Outline of volume cropping region |
| CvtkVoronoi2D | Create 2D Voronoi convex tiling of input points |
| CvtkVortexCore | Compute vortex core lines using the parallel vectors method |
| CvtkVoxelContoursToSurfaceFilter | Create surface from contours |
| CvtkVoxelGrid | Subsample points using uniform binning |
| CvtkWindowedSincPolyDataFilter | Adjust point positions using a windowed sinc function interpolation kernel |
| CvtkmLevelOfDetail | Reduce the number of triangles in a mesh |
| CvtkPythonAlgorithm | Algorithm that can be implemented in Python |
| ►CvtkReaderAlgorithm | Superclass for readers that implement a simplified API |
| CvtkIOSSReader | Reader for IOSS (Sierra IO System) |
| ►CvtkParallelReader | Superclass for algorithms that are parallel aware |
| ►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 |
| ►CvtkSimpleReader | Superclass for algorithms that are not time or parallel aware |
| ►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 |
| ►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 |
| CvtkVeraOutReader | |
| CvtkRenderLargeImage | Use tiling to generate a large rendering |
| CvtkRendererSource | Take a renderer's image and/or depth map into the pipeline |
| ►CvtkResampleToImage | Sample dataset on a uniform grid |
| CvtkPResampleToImage | Sample dataset on a uniform grid in parallel |
| CvtkResizingWindowToImageFilter | Use a vtkWindow as input to image pipeline |
| ►CvtkSelectionAlgorithm | Superclass for algorithms that produce only Selection as output |
| CvtkAppendSelection | Appends one or more selections together |
| CvtkBoostKruskalMinimumSpanningTree | Constructs 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 |
| 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 |
| CvtkDataObjectToTable | Extract field data as a table |
| ►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 |
| ►CvtkDelimitedTextReader | Reads in delimited ascii or unicode text files and outputs a vtkTable data structure |
| CvtkTemporalDelimitedTextReader | Reads a delimited ascii or unicode text files and and output a temporal vtkTable |
| CvtkDotProductSimilarity | Compute dot-product similarity metrics |
| CvtkEqualizerFilter | Implements an algorithm for digital signal processing |
| ►CvtkExtractExodusGlobalTemporalVariables | Extract global temporal arrays or suitable field data arrays |
| CvtkPExtractExodusGlobalTemporalVariables | Parallel version of vtkExtractExodusGlobalTemporalVariables |
| 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 |
| ►CvtkOTFilter | A generic VTK Filter to process vtkTable using openturns algorithm |
| CvtkOTKernelSmoothing | A VTK Filter to compute Kernel Smoothing using PDF computation from openturns |
| CvtkRISReader | Reader for RIS files |
| CvtkReduceTable | Combine some of the rows of a table |
| CvtkRowQueryToTable | Executes an sql query and retrieves results into a table |
| CvtkSQLDatabaseTableSource | Generates a vtkTable based on an SQL query |
| CvtkSparseArrayToTable | Converts a sparse array to a vtkTable |
| CvtkSplitColumnComponents | Split multicomponent table columns |
| ►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 |
| CvtkPContingencyStatistics | A class for parallel bivariate contingency statistics |
| ►CvtkCorrelativeStatistics | A class for bivariate linear correlation |
| CvtkPCorrelativeStatistics | A class for parallel bivariate correlative statistics |
| ►CvtkDescriptiveStatistics | A class for univariate descriptive statistics |
| 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 |
| 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 |
| CvtkmHistogram | Generate a histogram out of a scalar data |
| CvtkTemporalDataSetCache | Cache time steps |
| CvtkTemporalFractal | A source to test AMR data object |
| CvtkTemporalShiftScale | 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 | Constructs a BFS tree from a graph |
| CvtkBoostPrimMinimumSpanningTree | Constructs 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 | |
| CvtkAMRVelodyneReader | A concrete instance of vtkAMRBaseReader that implements functionality for reading Velodyne AMR datasets |
| CvtkAMReXGridReader | Reader for AMReX plotfiles grid data |
| 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 |
| CvtkAVSucdReader | Reads a dataset in AVS "UCD" format |
| CvtkAppendFilter | Appends one or more datasets together into a single unstructured grid |
| CvtkBoxClipDataSet | Clip an unstructured grid |
| CvtkCellTypeSource | Create cells of a given type |
| ►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 |
| CvtkClipVolume | Clip volume data with user-specified implicit function or input scalar data |
| CvtkDataSetTriangleFilter | Triangulate any type of dataset |
| CvtkDelaunay3D | Create 3D Delaunay triangulation of input points |
| CvtkExplicitStructuredGridToUnstructuredGrid | Filter which converts an explicit structured grid into an unstructured grid |
| CvtkExtractCells | Subset a vtkDataSet to create a vtkUnstructuredGrid |
| CvtkExtractGeometry | Extract cells that lie either entirely inside or outside of a specified implicit function |
| CvtkExtractGhostCells | Extracts ghost cells from the input and untag them (they become visible) |
| 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 |
| CvtkIntegrateAttributes | Integrates lines, surfaces and volume |
| 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 |
| CvtkRectilinearGridToTetrahedra | Create a Tetrahedral mesh from a RectilinearGrid |
| CvtkRemoveUnusedPoints | Remove points not used by any cell |
| 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 |
| CvtkmThreshold | Extracts cells where scalar value in cell satisfies threshold criterion |
| CvtkTimeSourceExample | |
| CvtkTransmitUnstructuredGridPiece | |
| ►CvtkUnstructuredGridGhostCellsGenerator | Builds ghost cells for a distributed unstructured grid dataset |
| CvtkPUnstructuredGridGhostCellsGenerator | Builds ghost cells for a distributed unstructured grid dataset |
| CvtkUnstructuredGridQuadricDecimation | Reduce the number of tetrahedra in a mesh |
| CvtkVolumeOfRevolutionFilter | Sweep data about a line to create a volume |
| CvtkmCleanGrid | Removes redundant or unused cells and/or points |
| CvtkmClip | Clip a dataset using the accelerated vtk-m Clip filter |
| ►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 |
| CvtkDIMACSGraphWriter | Write vtkGraph data to a DIMACS formatted file |
| ►CvtkDataSetWriter | Write any type of vtk dataset to file |
| CvtkPDataSetWriter | Manages writing pieces of a data set |
| CvtkSimplePointsWriter | Write a file of xyz coordinates |
| 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 |
| CvtkGLTFWriter | Export a scene into GLTF 2.0 format |
| CvtkGeoJSONWriter | Convert vtkPolyData to Geo JSON format |
| CvtkHoudiniPolyDataWriter | Write vtk polygonal data to Houdini file |
| CvtkIVWriter | Export polydata into OpenInventor 2.0 format |
| CvtkJSONDataSetWriter | Write vtkDataSet using a vtkArchiver with a JSON meta file along with all the binary arrays written as standalone binary files |
| 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 |
| CvtkOBJWriter | Write wavefront obj file |
| CvtkOpenVDBWriter | OpenVDB writer for vtkImageData or vtkPointSet Writes a vtkImageData or vtkPointSet as a VDB file |
| 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 |
| CvtkXMLPartitionedDataSetCollectionReader | Reader for partitioned dataset collections |
| CvtkXMLPartitionedDataSetReader | Reader for partitioned 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 |
| ►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 |
| CvtkXMLHyperTreeGridReader | Read VTK XML HyperTreeGrid files |
| ►CvtkXMLPDataObjectReader | Superclass for PVTK XML file readers |
| ►CvtkXMLPDataReader | Superclass for PVTK XML file readers that read vtkDataSets |
| ►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 |
| CvtkXMLPHyperTreeGridReader | Read PVTK XML HyperTreeGrid files |
| CvtkXMLPTableReader | Read PVTK XML Table files |
| CvtkXMLTableReader | Read VTK XML Table files |
| ►CvtkXMLWriterBase | Abstract base class for VTK-XML writers |
| ►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 |
| ►CvtkXMLDataObjectWriter | Write any type of VTK XML file |
| CvtkXMLDataSetWriter | Write any type of VTK XML file |
| CvtkXMLDataWriterHelper | Helper for vtkXMLWriter2 and subclasses |
| CvtkXMLHyperTreeGridWriter | Write VTK XML HyperTreeGrid files |
| ►CvtkXMLPDataObjectWriter | Write data in a parallel XML format |
| ►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 |
| CvtkXMLPHyperTreeGridWriter | Write PVTK XML HyperTreeGrid files |
| CvtkXMLPTableWriter | 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 |
| CvtkXMLTableWriter | Write VTK XML Table files |
| ►CvtkXMLUnstructuredDataWriter | Superclass for VTK XML unstructured data writers |
| CvtkXMLPolyDataWriter | Write VTK XML PolyData files |
| CvtkXMLUnstructuredGridWriter | Write VTK XML UnstructuredGrid files |
| ►CvtkXMLWriter2 | Base class for new-style XML Writers |
| CvtkXMLPartitionedDataSetCollectionWriter | Writer for vtkPartitionedDataSetCollection |
| ►CvtkXMLPartitionedDataSetWriter | XML writer for vtkPartitionedDataSet |
| CvtkXMLPPartitionedDataSetWriter | Deprecated |
| CvtkmExternalFaces | Generate External Faces of a DataSet |
| CvtkAlgorithmOutput | Proxy object to connect input/output ports |
| CvtkAmoebaMinimizer | Nonlinear optimization with a simplex |
| ►CvtkAnimationCue | Seqin an animation |
| CvtkAnimationScene | Animation scene manager |
| ►CvtkArchiver | Writes an archive |
| CvtkBufferedArchiver | Writes an archive to a buffer for vtk-js datasets |
| CvtkPartitionedArchiver | Writes an archive to several buffers |
| CvtkPythonArchiver | A version of vtkArchiver that can be implemented in Python |
| ►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 | Extended axis tick positioning |
| CvtkBSPIntersections | Perform calculations (mostly intersection calculations) on regions of a 3D binary spatial partitioning |
| 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 |
| CvtkBuffer< ScalarTypeT > | Internal storage class used by vtkSOADataArrayTemplate, vtkAOSDataArrayTemplate, and others |
| CvtkByteSwap | Perform machine dependent byte swapping |
| CvtkCPExodusIIElementBlockImpl | |
| ►CvtkCamera | Virtual camera for 3D rendering |
| ►CvtkOpenGLCamera | OpenGL camera |
| CvtkExternalOpenGLCamera | OpenGL camera |
| ►CvtkVRCamera | VR camera |
| CvtkOpenVRCamera | OpenVR 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 |
| ►CvtkHigherOrderCurve | |
| CvtkBezierCurve | |
| CvtkLagrangeCurve | |
| ►CvtkHigherOrderHexahedron | A 3D cell that represents an arbitrary order HigherOrder hex |
| CvtkBezierHexahedron | A 3D cell that represents an arbitrary order Bezier hex |
| CvtkLagrangeHexahedron | A 3D cell that represents an arbitrary order Lagrange hex |
| ►CvtkHigherOrderQuadrilateral | |
| CvtkBezierQuadrilateral | |
| CvtkLagrangeQuadrilateral | |
| ►CvtkHigherOrderTetra | A 3D cell that represents an arbitrary order HigherOrder tetrahedron |
| CvtkBezierTetra | A 3D cell that represents an arbitrary order Bezier tetrahedron |
| CvtkLagrangeTetra | A 3D cell that represents an arbitrary order Lagrange tetrahedron |
| ►CvtkHigherOrderTriangle | A 2D cell that represents an arbitrary order HigherOrder triangle |
| CvtkBezierTriangle | A 2D cell that represents an arbitrary order Bezier triangle |
| CvtkLagrangeTriangle | A 2D cell that represents an arbitrary order Lagrange triangle |
| ►CvtkHigherOrderWedge | A 3D cell that represents an arbitrary order HigherOrder wedge |
| CvtkBezierWedge | A 3D cell that represents an arbitrary order Bezier wedge |
| CvtkLagrangeWedge | A 3D cell that represents an arbitrary order Lagrange wedge |
| 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 |
| CvtkTriQuadraticPyramid | Cell represents a parabolic, 13-node isoparametric pyramid |
| CvtkPixel | Cell that represents an orthogonal quadrilateral |
| CvtkPolyLine | Cell represents a set of 1D lines |
| CvtkPolyVertex | Cell represents a set of 0D vertices |
| CvtkPolygon | Cell that represents an n-sided polygon |
| 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 |
| CvtkCellArrayIterator | Encapsulate traversal logic for vtkCellArray |
| ►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 ordered lists of objects |
| CvtkAssemblyPath | List of nodes that form an assembly path |
| CvtkAssemblyPaths | List of lists of props representing an assembly hierarchy |
| CvtkCullerCollection | Ordered list of Cullers |
| CvtkDataArrayCollection | Maintain an ordered list of dataarray objects |
| CvtkDataObjectCollection | Maintain an unordered list of data objects |
| CvtkDataSetCollection | Maintain an unordered list of dataset objects |
| CvtkIdListCollection | Maintain an ordered list of IdList objects |
| CvtkImageReader2Collection | Maintain a list of image readers |
| CvtkImplicitFunctionCollection | Maintain a list of implicit functions |
| CvtkLightCollection | Ordered list of lights |
| CvtkMapperCollection | Ordered 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 | Ordered list of Props |
| CvtkActor2DCollection | List of 2D actors |
| CvtkActorCollection | Ordered list of actors |
| CvtkImageSliceCollection | Sorted list of image slice objects |
| CvtkProp3DCollection | Ordered list of 3D props |
| CvtkVolumeCollection | Ordered list of volumes |
| CvtkRenderPassCollection | Ordered list of RenderPasses |
| CvtkRenderWindowCollection | Ordered list of RenderWindows |
| CvtkRendererCollection | Ordered list of renderers |
| CvtkSocketCollection | Collection for sockets |
| CvtkStructuredPointsCollection | Maintain a list of structured points data objects |
| CvtkTextPropertyCollection | Ordered list of vtkTextProperty objects |
| CvtkTransformCollection | Maintain a list of transforms |
| ►CvtkCollectionIterator | Iterator through a vtkCollection |
| CvtkDataArrayCollectionIterator | Iterator through a vtkDataArrayCollection |
| 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 |
| CvtkCompositeDataDisplayAttributesLegacy | 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+ |
| CvtkPDFContextDevice2D | VtkContextDevice2D implementation for use with vtkPDFExporter |
| CvtkSVGContextDevice2D | VtkContextDevice2D implementation for use with vtkSVGExporter |
| ►CvtkContextDevice3D | Abstract class for 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 |
| CvtkCriticalSection | Critical section locking class |
| ►CvtkCuller | Superclass for prop cullers |
| CvtkFrustumCoverageCuller | Cull props based on frustum coverage |
| CvtkDIYDataExchanger | Exchange data-object among ranks |
| CvtkDIYGhostUtilities | Utilities to produce ghost cells between a collection of data sets of same type |
| CvtkDIYKdTreeUtilities | Collection of utility functions for DIY-based KdTree algorithm |
| CvtkDIYUtilities | Collection of helper functions for working with DIY |
| CvtkDSPFilterDefinition | Used by the Exodus readers |
| CvtkDSPFilterGroup | Used by the Exodus readers |
| CvtkDataArraySelection | Store on/off settings for data arrays for a vtkSource |
| CvtkDataAssembly | Hierarchical representation to use with vtkPartitionedDataSetCollection |
| CvtkDataAssemblyUtilities | Collections of utilities for vtkDataAssembly |
| CvtkDataAssemblyVisitor | Visitor API for vtkDataAssembly |
| ►CvtkDataCompressor | Abstract interface for data compression classes |
| CvtkLZ4DataCompressor | Data compression using LZ4 |
| CvtkLZMADataCompressor | Data compression using LZMA Utils |
| CvtkZLibDataCompressor | Data compression using zlib |
| ►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 |
| ►CvtkPartitionedDataSet | Composite dataset to encapsulates a dataset consisting of partitions |
| CvtkMultiPieceDataSet | Composite dataset to encapsulates pieces of dataset |
| CvtkPartitionedDataSetCollection | Composite dataset that groups datasets as a collection |
| ►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 |
| ►CvtkImageData | Topologically and geometrically regular array of data |
| CvtkStructuredPoints | A subclass of ImageData |
| CvtkUniformGrid | Image data with blanking |
| ►CvtkPointSet | Concrete class for storing a set of points |
| CvtkExplicitStructuredGrid | Structured grid with explicit topology and geometry |
| 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 |
| CvtkmDataSet | |
| 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 |
| ►CvtkHyperTreeGrid | A dataset containing a grid of vtkHyperTree instances arranged as a rectilinear grid |
| CvtkUniformHyperTreeGrid | A specifalized type of vtkHyperTreeGrid for the case when root cells have uniform sizes in each direction |
| CvtkImageStencilData | Efficient description of an image stencil |
| CvtkPiecewiseFunction | Defines a 1D piecewise function |
| CvtkSelection | Data object that represents a "selection" in VTK |
| 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 |
| 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 |
| 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 |
| CvtkExecutableRunner | Launch a process on the current machine and get its output |
| 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 |
| CvtkReaderExecutive | Executive that works with vtkReaderAlgorithm and subclasses |
| 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 |
| CvtkGLTFExporter | Export a scene into GLTF 2.0 format |
| CvtkIVExporter | Export a scene into OpenInventor 2.0 format |
| CvtkJSONRenderWindowExporter | Exports a render window for vtk-js |
| CvtkJSONSceneExporter | Export the content of a vtkRenderWindow into a directory with a JSON meta file describing the scene along with the http datasets |
| CvtkOBJExporter | Export a scene into Wavefront format |
| CvtkOOGLExporter | Export a scene into Geomview OOGL format |
| CvtkPDFExporter | Exports vtkContext2D scenes to PDF |
| CvtkPOVExporter | Export scene into povray format |
| CvtkRIBExporter | Export a scene into RenderMan RIB format |
| CvtkSVGExporter | Exports vtkContext2D scenes to SVG |
| CvtkSingleVTPExporter | Export a scene into a single vtp file and png texture |
| CvtkVRMLExporter | Export a scene into VRML 2.0 format |
| CvtkX3DExporter | Create an x3d file |
| CvtkExprTkFunctionParser | Parse and evaluate a mathematical expression |
| 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 |
| CvtkFFT | Perform Discrete Fourier Transforms |
| CvtkFXAAOptions | Configuration for FXAA implementations |
| ►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 |
| CvtkFileSeriesHelper | Helper class to process file series |
| ►CvtkFindCellStrategy | Helper class to manage the vtkPointSet::FindCell() METHOD |
| CvtkCellLocatorStrategy | Implement a specific vtkPointSet::FindCell() strategy based on using a cell locator |
| ►CvtkClosestPointStrategy | Implement a specific vtkPointSet::FindCell() strategy based on closest point |
| CvtkClosestNPointsStrategy | Implement a specific vtkPointSet::FindCell() strategy based on the N closest points |
| 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 |
| ►CvtkFrameBufferObjectBase | Abstract interface to OpenGL FBOs |
| CvtkOpenGLFramebufferObject | Internal class which encapsulates OpenGL FramebufferObject |
| ►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 |
| ►CvtkLagrangianBasicIntegrationModel | VtkFunctionSet abstract implementation to be used in the vtkLagrangianParticleTracker integrator |
| CvtkLagrangianMatidaIntegrationModel | VtkLagrangianBasicIntegrationModel implementation |
| CvtkTemporalInterpolatedVelocityField | A helper class for interpolating between times during particle tracing |
| CvtkGDAL | Shared data for GDAL classes |
| CvtkGDALRasterConverter | Convert between VTK image representation and GDAL datasets |
| CvtkGDALRasterReprojection | |
| CvtkGLTFDocumentLoader | Deserialize a GLTF model file |
| CvtkGPUInfo | Stores GPU VRAM information |
| ►CvtkGPUInfoList | Stores the list of GPUs VRAM information |
| CvtkDummyGPUInfoList | Do thing during Probe() |
| CvtkGarbageCollector | Detect and break reference loops |
| 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 |
| CvtkGeoMath | Useful geographic calculations |
| CvtkGeoProjection | Represent a projection from a sphere to a plane |
| CvtkGlobFileNames | Find files that match a wildcard pattern |
| CvtkGraphEdge | Representation of a single graph edge |
| 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 |
| CvtkGraphicsFactory | |
| ►CvtkHardwareSelector | |
| ►CvtkOpenGLHardwareSelector | Implements the device specific code of vtkOpenGLHardwareSelector |
| CvtkPHardwareSelector | VtkHardwareSelector useful for parallel rendering |
| CvtkHeap | Replacement for malloc/free and new/delete |
| CvtkHierarchicalGraphPipeline | Helper class for rendering graphs superimposed on a tree |
| ►CvtkHigherOrderInterpolation | |
| CvtkBezierInterpolation | |
| CvtkLagrangeInterpolation | |
| CvtkHyperTree | A data object structured as a tree |
| CvtkHyperTreeCursor | Objects for depth-first traversal HyperTrees |
| CvtkHyperTreeGridNonOrientedCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedGeometryCursor | Objects for traversal a HyperTreeGrid |
| ►CvtkHyperTreeGridNonOrientedSuperCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedMooreSuperCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedVonNeumannSuperCursor | Objects for traversal a HyperTreeGrid |
| ►CvtkHyperTreeGridNonOrientedSuperCursorLight | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedMooreSuperCursorLight | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridOrientedCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridOrientedGeometryCursor | Objects for traversal a HyperTreeGrid |
| CvtkIOSSFilesScanner | Helper to scan files |
| 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 |
| CvtkImageTransform | Helper class to transform output of non-axis-aligned images |
| 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 |
| CvtkImplicitProjectOnPlaneDistance | This class recieve a plannar polygon as input |
| 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 |
| CvtkSpheres | Implicit function for a set of spheres |
| CvtkSuperquadric | Implicit function for a Superquadric |
| ►CvtkImporter | Importer abstract class |
| Cvtk3DSImporter | Imports 3D Studio files |
| CvtkGLTFImporter | Import a GLTF file |
| CvtkOBJImporter | Import from .obj wavefront files |
| CvtkVRMLImporter | Imports VRML 2.0 files |
| CvtkInEdgeIterator | Iterates through all incoming edges to a vertex |
| CvtkIncrementalForceLayout | Incremental force-directed layout |
| CvtkIncrementalOctreeNode | Octree node constituting incremental octree (in support of both point location and point insertion) |
| 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 |
| ►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 |
| CvtkCameraOrientationWidget | A widget to manipulate vtkCameraOrientationWidget |
| CvtkCameraPathWidget | Widget for vtkCameraPathRepresentation |
| 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 cylinder |
| CvtkImplicitPlaneWidget2 | 3D widget for manipulating an infinite plane |
| CvtkLightWidget | 3D widget for showing a LightRepresentation |
| CvtkLineWidget2 | 3D widget for manipulating a finite, straight line |
| CvtkMagnifierWidget | Create a moving, magnifying renderer that can inspect the contents of an encapsulating renderer |
| CvtkParallelopipedWidget | Widget to manipulate 3D parallelopipeds |
| CvtkPointCloudWidget | Select and manipulate a point from a point cloud |
| CvtkPolyLineWidget | Widget for vtkPolyLineRepresentation |
| CvtkQWidgetWidget | 3D VTK widget for a QWidget |
| 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 |
| CvtkTensorWidget | 3D widget for manipulating a tensor glyph |
| CvtkVRMenuWidget | 3D widget to display a menu in VR |
| CvtkVRPanelWidget | 3D widget to display a panel/billboard |
| 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 |
| CvtkOpenVRInteractorStyle | Extended from vtkInteractorStyle3D to override command methods |
| 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 |
| ►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 |
| ►CvtkKMeansDistanceFunctor | Measure distance from k-means cluster centers |
| CvtkKMeansDistanceFunctorCalculator | Measure distance from k-means cluster centers using a user-specified expression |
| CvtkKdNode | This class represents a single spatial region in an 3D axis aligned binary spatial partitioning |
| CvtkLSDynaPart | |
| CvtkLSDynaPartCollection | |
| ►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 |
| CvtkRIBLight | RIP Light |
| 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) |
| ►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 |
| CvtkStaticCellLocator | Perform fast cell location operations |
| ►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 |
| CvtkStaticPointLocator2D | Quickly locate points in 2-space |
| ►CvtkKdTree | Kd-tree spatial decomposition of a set of points |
| CvtkPKdTree | Build a k-d tree decomposition of a list of points |
| CvtkMINCImageAttributes | A container for a MINC image header |
| CvtkMPI4PyCommunicator | Class for bridging MPI4Py with vtkMPICommunicator |
| CvtkMPIEventLog | Class for logging and timing |
| CvtkMarkerUtilities | Utilities for generating marker images |
| CvtkMath | Performs common math operations |
| ►CvtkMathTextUtilities | Abstract interface to equation rendering |
| CvtkMatplotlibMathTextUtilities | Access to MatPlotLib MathText rendering |
| 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 |
| CvtkModelMetadata | This class encapsulates the metadata that appear in mesh-based file formats but do not appear in vtkUnstructuredGrid |
| ►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 |
| CvtkNIFTIImageHeader | Store NIfTI header information |
| CvtkNamedColors | A class holding colors and their names |
| CvtkOSPRayMaterialLibrary | Collection of materials for vtk apps to draw from |
| CvtkObjectFactory | Abstract base class for vtkObjectFactories |
| 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 | |
| CvtkOpenGLCellToVTKCellMap | OpenGL rendering utility functions |
| CvtkOpenGLFXAAFilter | Perform FXAA antialiasing on the current framebuffer |
| ►CvtkOpenGLGL2PSHelper | Access GL2PS functionality |
| CvtkOpenGLGL2PSHelperImpl | VtkOpenGLGL2PSHelper override implementation |
| CvtkOpenGLImageAlgorithmHelper | Help image algorithms use the GPU |
| CvtkOpenGLInstanceCulling | Frustum culling and LOD management |
| CvtkOpenGLRenderUtilities | OpenGL rendering utility functions |
| CvtkOpenGLShaderCache | Manage Shader Programs within a context |
| CvtkOpenGLState | OpenGL state storage |
| CvtkOpenGLVertexArrayObject | The VertexArrayObject class uses, or emulates, vertex array objects |
| CvtkOpenGLVertexBufferObjectCache | Manage vertex buffer objects shared within a context |
| CvtkOpenGLVertexBufferObjectGroup | Manage vertex buffer objects shared within a mapper |
| ►CvtkOpenGLVolumeLookupTable | Base class for OpenGL texture management of scalar color, opacity and gradient opacity lookup tables |
| CvtkOpenGLVolumeGradientOpacityTable | |
| CvtkOpenGLVolumeMaskGradientOpacityTransferFunction2D | 2D Transfer function container for label map mask gradient opacity |
| CvtkOpenGLVolumeMaskTransferFunction2D | 2D Transfer function container |
| CvtkOpenGLVolumeOpacityTable | |
| CvtkOpenGLVolumeRGBTable | |
| CvtkOpenGLVolumeTransferFunction2D | 2D Transfer function container |
| CvtkOpenGLVolumeLookupTables< T > | Internal class that manages multiple lookup tables |
| ►CvtkOpenVROverlay | OpenVR overlay |
| CvtkOpenVRDefaultOverlay | OpenVR overlay |
| 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 |
| 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 |
| CvtkPSystemTools | System tools for file system introspection |
| ►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 distributed 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 |
| 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 |
| 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 |
| CvtkPolyData_detail::CellMap | |
| 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 |
| 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 |
| ►CvtkAvatar | Renders head and hands for a user in VR |
| CvtkOpenGLAvatar | OpenGL Avatar |
| CvtkAxisActor | Create an axis with tick marks and labels |
| CvtkCubeAxesActor | Create a plot of a bounding box edges - used for navigation |
| CvtkFlagpoleLabel | Renders a flagpole (line) with a label at the top that faces the camera |
| ►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 |
| CvtkVRFollower | VR Follower |
| CvtkLODActor | Actor that supports multiple levels of detail |
| CvtkOpenGLActor | OpenGL actor |
| CvtkPolarAxesActor | Create an actor of a polar axes - |
| CvtkQuadricLODActor | Specific level-of-detail strategy using the quadric clustering decimation algorithm |
| ►CvtkSkybox | Renders a skybox environment |
| ►CvtkOpenGLSkybox | OpenGL Skybox |
| CvtkOpenGLMovieSphere | OpenGL MovieSphere, an optimized VR sphere for movies |
| 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 |
| CvtkLODProp3D | Level of detail 3D prop |
| CvtkLightActor | Cone and a frustum to represent a spotlight |
| ►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 |
| CvtkMultiVolume | Represents a world axis-aligned bounding-box containing a set of volumes in a rendered scene |
| CvtkPropAssembly | Create hierarchies of props |
| ►CvtkVRControlsHelper | Tooltip helper explaining controls Helper class to draw one tooltip per button around the controller |
| CvtkOpenVRControlsHelper | Tooltip helper explaining controls Helper class to draw one tooltip per button around the controller |
| ►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 |
| CvtkCameraOrientationRepresentation | 3D axes representation for interactive widgets |
| 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 |
| ►CvtkAbstractSplineRepresentation | Abstract representation for a spline |
| CvtkCameraPathRepresentation | Representation for a camera path |
| CvtkSplineRepresentation | Representation for a spline |
| CvtkPolyLineRepresentation | VtkWidgetRepresentation for a poly line |
| ►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 |
| CvtkMeasurementCubeHandleRepresentation3D | Represent a unit cube for measuring/comparing to data |
| 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 |
| CvtkImplicitImageRepresentation | Representation for a vtkImplicitPlaneWidget2 which reslices a volume |
| CvtkLightRepresentation | Represent a vtkLight |
| CvtkLineRepresentation | Class defining the representation for a vtkLineWidget2 |
| CvtkMagnifierRepresentation | Represent a vtkBorderWidget |
| CvtkParallelopipedRepresentation | Default representation for vtkParallelopipedWidget |
| CvtkPointCloudRepresentation | Represent the vtkPointCloudWidget |
| CvtkQWidgetRepresentation | Class defining the representation for a vtkQWidgetWidget |
| 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 |
| CvtkTensorRepresentation | Class defining a representation for the vtkTensorWidget |
| CvtkVRMenuRepresentation | Widget representation for vtkVRMenuWidget Implementation of the popup panel representation for the vtkVRMenuWidget |
| CvtkVRPanelRepresentation | Widget representation for vtkVRPanelWidget Implementation of the popup panel representation for the vtkVRPanelWidget |
| ►CvtkProperty | Represent surface properties of a geometric object |
| CvtkOpenGLProperty | OpenGL property |
| CvtkRIBProperty | RIP Property |
| CvtkProperty2D | Represent surface properties of a 2D image |
| 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 |
| CvtkRandomPool | Convenience class to quickly generate a pool of random numbers |
| ►CvtkRandomSequence | Generate a 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 |
| CvtkReebGraphSimplificationMetric | Abstract class for custom Reeb graph simplification metric design |
| CvtkReferenceCount | Obsolete / empty subclass of object |
| ►CvtkRenderPass | Perform part of the rendering of a vtkRenderer |
| CvtkCameraPass | Implement the camera render pass |
| CvtkClearRGBPass | Paint in the color buffer |
| 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 |
| CvtkOverlayPass | Render the overlay geometry with property key filtering |
| CvtkTranslucentPass | Render the translucent polygonal geometry with property key filtering |
| CvtkVolumetricPass | Render the volumetric geometry with property key filtering |
| CvtkLightsPass | Implement the lights render pass |
| CvtkOSPRayPass | Render pass that uses OSPRay instead of GL |
| ►CvtkOpenGLRenderPass | Abstract render pass with shader modifications |
| ►CvtkDepthPeelingPass | Implement Depth Peeling for use within a framebuffer 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 |
| CvtkFramebufferPass | Render into a FO |
| CvtkPointFillPass | Implement a post-processing fillpass |
| CvtkSimpleMotionBlurPass | Avergae frames to simulate motion blur |
| CvtkGaussianBlurPass | Implement a post-processing Gaussian blur render pass |
| CvtkOpenGLFXAAPass | Render pass calling the FXAA filter |
| CvtkOutlineGlowPass | Renders a glowing outline using a image processing pass |
| CvtkPanoramicProjectionPass | Render pass that render the scene in a cubemap and project these six renderings to a single quad |
| CvtkSSAOPass | Implement a screen-space ambient occlusion pass |
| CvtkSobelGradientMagnitudePass | Implement a post-processing edge detection with a Sobel gradient magnitude render pass |
| CvtkToneMappingPass | Implement a post-processing Tone Mapping |
| CvtkOrderIndependentTranslucentPass | Implement OIT rendering using average color |
| CvtkShadowMapBakerPass | Implement a builder of shadow map pass |
| CvtkShadowMapPass | Implement a shadow mapping render pass |
| CvtkValuePass | Renders geometry using the values of a field array as fragment colors |
| CvtkRenderStepsPass | Execute render passes sequentially |
| CvtkSSAAPass | Implement Screen Space Anti Aliasing pass |
| CvtkSequencePass | Execute render passes sequentially |
| ►CvtkRenderTimerLog | Asynchronously measures GPU execution times for a series of events |
| CvtkOpenGLRenderTimerLog | OpenGL2 override for vtkRenderTimerLog |
| 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 |
| CvtkGenericRenderWindowInteractor | Platform-independent programmable render window interactor |
| CvtkIOSRenderWindowInteractor | Implements IOS specific functions required by vtkRenderWindowInteractor |
| ►CvtkRenderWindowInteractor3D | Adds support for 3D events to vtkRenderWindowInteractor |
| CvtkOpenVRRenderWindowInteractor | Implements OpenVR specific functions required by vtkRenderWindowInteractor |
| CvtkSDL2RenderWindowInteractor | Implements SDL2 specific functions required by vtkRenderWindowInteractor |
| CvtkWin32RenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| CvtkXRenderWindowInteractor | X event driven interface for a RenderWindow |
| CvtkRenderbuffer | Storage for FBO's |
| CvtkRendererDelegate | Render the props of a vtkRenderer |
| CvtkResliceCursor | Geometry for a reslice cursor |
| CvtkResliceImageViewerMeasurements | Manage measurements on a resliced image |
| CvtkResourceFileLocator | Utility to locate resource files |
| ►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 |
| CvtkQtSQLQuery | Query class associated with vtkQtSQLDatabase |
| CvtkSQLiteQuery | VtkSQLQuery implementation for SQLite databases |
| CvtkSILBuilder | Helper class to build a SIL i.e |
| ►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 |
| CvtkQtSQLDatabase | Maintains a connection to an sql database |
| CvtkSQLiteDatabase | Maintain a connection to an SQLite database |
| CvtkSQLDatabaseSchema | Represent an SQL database schema |
| ►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 |
| ►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 |
| CvtkScenePicker | Picks an entire viewport at one shot |
| CvtkSelectionNode | Node in a vtkSelection the defines the selection criteria |
| ►CvtkSelector | |
| CvtkBlockSelector | Selector for blocks |
| CvtkFrustumSelector | |
| CvtkLocationSelector | Selects cells containing or points near chosen point locations |
| CvtkValueSelector | Selects elements matching chosen values |
| CvtkShader | Vertex or Fragment shader, combined into a ShaderProgram |
| CvtkShaderProgram | The ShaderProgram uses one or more Shader objects |
| ►CvtkShaderProperty | Represent GPU shader properties |
| CvtkOpenGLShaderProperty | Represent GPU shader properties |
| 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 |
| CvtkSphereTree | Class to build and traverse sphere trees |
| ►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 |
| CvtkStereoCompositor | Helper class to generate composited stereo images |
| 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 | 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 |
| ►CvtkSurfaceLICInterface | Public API for surface lic parameters arbitrary geometry |
| CvtkPSurfaceLICInterface | Parallel parts of the vtkSurfaceLICInterface |
| CvtkSynchronizedRenderWindows | Synchronizes render windows across processes |
| ►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 |
| ►CvtkTDxInteractorStyle | Provide 3DConnexion device event-driven interface to the rendering window |
| CvtkTDxInteractorStyleCamera | Interactive manipulation of the camera with a 3DConnexion device |
| CvtkTDxInteractorStyleSettings | 3DConnexion device settings |
| CvtkTestNewVar | Tests instantiations of the vtkNew class template |
| ►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 |
| CvtkQWidgetTexture | Allows a QWidget to be used as a texture in VTK with OpenGL |
| CvtkTextureUnitManager | Allocate/free texture units |
| CvtkThreadMessager | A class for performing inter-thread messaging |
| CvtkThreadedImageWriter | Class used to compress/write images using threads to prevent locking while encoding data |
| 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 arbitrary size |
| ►CvtkUniforms | Helper class to set custom uniform variables in GPU shaders |
| CvtkOpenGLUniforms | Helper class to set custom uniform variables in GLSL shaders |
| ►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 piecewise constant ray integration |
| CvtkUnstructuredGridLinearRayIntegrator | Performs piecewise linear ray integration |
| CvtkUnstructuredGridPartialPreIntegration | Performs piecewise linear ray integration |
| CvtkUnstructuredGridPreIntegration | Performs ray integration with pre-integration tables |
| CvtkVRCollaborationClient | |
| ►CvtkVRModel | VR device model |
| CvtkOpenVRModel | OpenVR device model |
| CvtkVRRay | VR device model |
| 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 |
| ►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 |
| CvtkOSPRayMoleculeMapperNode | Links vtkMoleculeMapper to OSPRay |
| ►CvtkOSPRayPolyDataMapperNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkOSPRayCompositePolyDataMapper2Node | Links vtkActor and vtkMapper to OSPRay |
| ►CvtkVolumeMapperNode | VtkViewNode specialized for vtkVolumeMappers |
| CvtkOSPRayUnstructuredVolumeMapperNode | Unstructured grid volume renderer |
| ►CvtkOSPRayVolumeMapperNode | Links vtkVolumeMapper to OSPRay |
| CvtkOSPRayAMRVolumeMapperNode | 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 |
| CvtkVtkJSViewNodeFactory | Constructs view nodes for traversing a scene for vtk-js |
| CvtkViewTheme | Sets theme colors for a graphical view |
| CvtkViewUpdater | Updates views automatically |
| ►CvtkViewport | Abstract specification for Viewports |
| ►CvtkRenderer | Abstract specification for renderers |
| ►CvtkOpenGLRenderer | OpenGL renderer |
| CvtkExternalOpenGLRenderer | OpenGL renderer |
| ►CvtkVRRenderer | VR renderer |
| CvtkOpenVRRenderer | OpenVR renderer |
| ►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 |
| CvtkVolumeTexture | Creates and manages the volume texture rendered by vtkOpenGLGPUVolumeRayCastMapper |
| CvtkVtkJSSceneGraphSerializer | Converts elements of a VTK scene graph into vtk-js elements |
| CvtkWeakReference | Utility class to hold a weak reference to a vtkObject |
| 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 |
| ►CvtkHardwareWindow | Create a window for renderers to draw into |
| CvtkWin32HardwareWindow | Window in a windows GUI |
| ►CvtkRenderWindow | Create a window for renderers to draw into |
| ►CvtkOpenGLRenderWindow | 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 |
| CvtkIOSRenderWindow | IOS OpenGL rendering window |
| CvtkOSOpenGLRenderWindow | OffScreen Mesa rendering window |
| CvtkSDL2OpenGLRenderWindow | |
| ►CvtkVRRenderWindow | VR rendering window |
| CvtkOpenVRRenderWindow | OpenVR rendering window |
| CvtkWin32OpenGLRenderWindow | |
| CvtkXOpenGLRenderWindow | OpenGL rendering window |
| ►CvtkX3DExporterWriter | X3D Exporter Writer |
| CvtkX3DExporterFIWriter | |
| CvtkX3DExporterXMLWriter | X3D Exporter XML Writer |
| CvtkXMLCompositeDataSetWriterHelper | Helper class used by vtkXMLWriter2 subclasses that write composite datasets |
| 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 |
| CvtkXdmfDataArray | |
| CvtkObjectFactoryRegistryCleanup | |
| CvtkOBJImportedMaterial | |
| CvtkODBCInternals | Simple class to hide ODBC structures |
| CvtkOpenGL2ContextDevice2DCellArrayHelper | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| CvtkOpenGL2ContextDevice2DPrivate | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| CvtkOpenGLHelper | |
| CvtkOpenGLImageAlgorithmCallback | |
| CvtkOpenGLQuadHelper | Class to make rendering a full screen quad easier |
| CvtkOpenGLRenderTimer | Asynchronously measures GPU execution time for a single event |
| CvtkOpenVRCameraPose | |
| CvtkOpenVROverlaySpot | |
| CvtkOSPRayCache< T > | Temporal cache ospray structures to speed flipbooks |
| CvtkOSPRayCache< vtkOSPRayCacheItemObject > | |
| CvtkOSPRayCacheItemObject | |
| CvtkOSPRayMaterialHelpers | Convert vtk appearance controls to ospray materials |
| ►CvtkOStreamWrapper | Wrapper for C++ ostream |
| CvtkOStrStreamWrapper | Wrapper for ostrstream |
| CvtkOTUtilities | |
| CvtkOutputWindowCleanup | |
| ►CvtkPainterCommunicator | A communicator that can safely be used inside a painter |
| CvtkPPainterCommunicator | |
| CvtkPolyDataMapperNode::vtkPDConnectivity_t | |
| 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 |
| Ctovtkm::vtkPointsPortal< Type > | |
| CvtkPolyDataInternals | Store mapping from vtkPolyData cell ids to internal cell array ids |
| CvtkPolygonalSurfacePointPlacerNode | |
| CvtkPolygonBuilder | The polygon output is the boundary of the union of the triangles |
| Ctovtkm::vtkPortalTraits< T > | |
| Ctovtkm::vtkPortalTraits< const vtkm::Vec< T, N > > | |
| Ctovtkm::vtkPortalTraits< const vtkm::Vec< vtkm::Vec< T, N >, M > > | |
| Ctovtkm::vtkPortalTraits< vtkm::Vec< T, N > > | |
| Ctovtkm::vtkPortalTraits< vtkm::Vec< vtkm::Vec< T, N >, M > > | |
| CvtkPostgreSQLDatabasePrivate | Internal details of a connection to a PostgreSQL database |
| CvtkPOutlineFilterInternals | Create wireframe outline (or corners) for arbitrary data set |
| CvtkQtLabelMapEntry | |
| CvtkQtLabelMapValue | |
| CvtkSynchronizedRenderers::vtkRawImage | VtkRawImage can be used to make it easier to deal with images for compositing/communicating over client-server etc |
| CvtkRayCastRayInfo_t | |
| CvtkRayCastStructures | Structure definitions for ray casting |
| CvtkRenderState | Context in which a vtkRenderPass will render |
| CvtkScalarBarActorInternal | Internal state for the scalar bar actor shared with subclasses |
| CvtkScalarBarBox | A structure to represent pixel coordinates for text or swatch bounds |
| CvtkSDL2OpenGL2RenderWindow | OpenGL rendering window |
| CvtkSegYBinaryHeaderBytesPositions | |
| CvtkSegYIOUtils | |
| CvtkSegYReaderInternal | |
| CvtkSegYTrace | |
| CvtkSegYTraceHeaderBytesPositions | |
| CvtkSegYTraceReader | |
| CvtkSimpleConditionVariable | |
| CvtkSimpleCriticalSection | Critical section locking class |
| CvtkSimpleMutexLock | |
| ►CvtkSmartPointerBase | Non-templated superclass for vtkSmartPointer |
| CvtkSmartPointer< vtkDataArray > | |
| CvtkSmartPointer< vtkGenericOpenGLRenderWindow > | |
| CvtkSmartPointer< vtkRenderWindow > | |
| CvtkSmartPointer< vtkMotionFXCFGReader > | |
| CvtkSmartPointer< vtkCompositePolyDataMapper2 > | |
| CvtkSmartPointer< CollectionType > | |
| CvtkSmartPointer< InternalIterator > | |
| CvtkSmartPointer< vtkCompositeDataSet > | |
| CvtkSmartPointer< vtkDataObjectTree > | |
| CvtkSmartPointer< vtkMultiProcessController > | |
| CvtkSmartPointer< vtkUniformGrid > | |
| CvtkSmartPointer< vtkIntArray > | |
| CvtkSmartPointer< vtkDoubleArray > | |
| CvtkSmartPointer< vtkUnsignedIntArray > | |
| CvtkSmartPointer< vtkAssignCoordinates > | |
| CvtkSmartPointer< vtkFastSplatter > | |
| CvtkSmartPointer< vtkImageData > | |
| CvtkSmartPointer< vtkFloatArray > | |
| CvtkSmartPointer< vtkStringArray > | |
| CvtkSmartPointer< vtkRenderer > | |
| CvtkSmartPointer< StorageType > | |
| CvtkSmartPointer< vtkPoints > | |
| CvtkSmartPointer< vtkCamera > | |
| CvtkSmartPointer< ArrayType > | |
| CvtkSmartPointer< vtkCellArray > | |
| CvtkSmartPointer< vtkBrush > | |
| CvtkSmartPointer< vtkTooltipItem > | |
| CvtkSmartPointer< vtkPlotHistogram2D > | |
| CvtkSmartPointer< vtkChartLegend > | |
| CvtkSmartPointer< vtkAnnotationLink > | |
| CvtkSmartPointer< vtkAxis > | |
| CvtkSmartPointer< vtkCallbackCommand > | |
| CvtkSmartPointer< vtkCenteredSliderRepresentation > | |
| CvtkSmartPointer< vtkCompositeDataDisplayAttributes > | |
| CvtkSmartPointer< vtkContextDevice3D > | |
| CvtkSmartPointer< vtkTransform > | |
| CvtkSmartPointer< vtkContextScene > | |
| CvtkSmartPointer< vtkTransform2D > | |
| CvtkSmartPointer< vtkContext2D > | |
| CvtkSmartPointer< vtkCellData > | |
| CvtkSmartPointer< vtkCoordinate > | |
| CvtkSmartPointer< vtkTransformPolyDataFilter > | |
| CvtkSmartPointer< vtkPolyLine > | |
| CvtkSmartPointer< vtkPolygon > | |
| CvtkSmartPointer< vtkUnsignedCharArray > | |
| CvtkSmartPointer< vtkFieldData > | |
| CvtkSmartPointer< vtkIdTypeArray > | |
| CvtkSmartPointer< vtkIdList > | |
| CvtkSmartPointer< vtkAlgorithm > | |
| CvtkSmartPointer< vtkDataObject > | |
| CvtkSmartPointer< vtkInformation > | |
| CvtkSmartPointer< vtkDataSet > | |
| CvtkSmartPointer< vtkPixelBufferObject > | |
| CvtkSmartPointer< vtkPriorityQueue > | |
| CvtkSmartPointer< vtkTree > | |
| CvtkSmartPointer< vtkPiecewiseFunction > | |
| CvtkSmartPointer< vtkConvertSelectionDomain > | |
| CvtkSmartPointer< vtkExtractSelection > | |
| CvtkSmartPointer< vtkExtractDataArraysOverTime > | |
| CvtkSmartPointer< vtkGraphToPolyData > | |
| CvtkSmartPointer< vtkPath > | |
| CvtkSmartPointer< vtkPlanes > | |
| CvtkSmartPointer< vtkMatrix4x4 > | |
| CvtkSmartPointer< vtkPolyData > | |
| CvtkSmartPointer< vtkGLTFDocumentLoader > | |
| CvtkSmartPointer< vtkMultiBlockDataSet > | |
| CvtkSmartPointer< vtkDataArraySelection > | |
| CvtkSmartPointer< vtkAppendPolyData > | |
| CvtkSmartPointer< vtkConvexHull2D > | |
| CvtkSmartPointer< vtkGlyph3D > | |
| CvtkSmartPointer< vtkVertexGlyphFilter > | |
| CvtkSmartPointer< vtkIconGlyphFilter > | |
| CvtkSmartPointer< vtkMapArrayValues > | |
| CvtkSmartPointer< vtkTransformCoordinateSystems > | |
| CvtkSmartPointer< vtkPolyDataMapper > | |
| CvtkSmartPointer< vtkPolyDataMapper2D > | |
| CvtkSmartPointer< vtkActor > | |
| CvtkSmartPointer< vtkTexturedActor2D > | |
| CvtkSmartPointer< vtkGraphToPoints > | |
| CvtkSmartPointer< vtkGlyphSource2D > | |
| CvtkSmartPointer< vtkSphereSource > | |
| CvtkSmartPointer< vtkDistanceToCamera > | |
| CvtkSmartPointer< vtkTable > | |
| CvtkSmartPointer< vtkLine > | |
| CvtkSmartPointer< vtkPointData > | |
| CvtkSmartPointer< vtkHexahedron > | |
| CvtkSmartPointer< vtkQuad > | |
| CvtkSmartPointer< vtkWedge > | |
| CvtkSmartPointer< vtkHyperTreeGridNonOrientedGeometryCursor > | |
| CvtkSmartPointer< vtkAbstractCellLocator > | |
| CvtkSmartPointer< vtkPlane > | |
| CvtkSmartPointer< vtkGenericCell > | |
| CvtkSmartPointer< vtkTextPropertyCollection > | |
| CvtkSmartPointer< vtkIncrementalPointLocator > | |
| CvtkSmartPointer< ImplementationType > | |
| CvtkSmartPointer< vtkMathInternal > | |
| CvtkSmartPointer< vtkMatrix3x3 > | |
| CvtkSmartPointer< vtkMolecule > | |
| CvtkSmartPointer< vtkOBJPolyDataProcessor > | |
| CvtkSmartPointer< vtkScalarsToColors > | |
| CvtkSmartPointer< vtkOpenGLFramebufferObject > | |
| CvtkSmartPointer< vtkOpenGLVertexBufferObjectGroup > | |
| CvtkSmartPointer< vtkOpenGLRenderWindow > | |
| CvtkSmartPointer< vtkOpenGLShaderProperty > | |
| CvtkSmartPointer< AbstractPStreamTracerUtils > | |
| CvtkSmartPointer< vtkCollection > | |
| CvtkSmartPointer< vtkPairwiseExtractHistogram2D > | |
| CvtkSmartPointer< vtkLookupTable > | |
| CvtkSmartPointer< vtkComputeHistogram2DOutliers > | |
| CvtkSmartPointer< vtkActor2D > | |
| CvtkSmartPointer< vtkTextMapper > | |
| CvtkSmartPointer< vtkSelection > | |
| CvtkSmartPointer< vtkBivariateLinearTableThreshold > | |
| CvtkSmartPointer< vtkAxisActor2D > | |
| CvtkSmartPointer< vtkOutlineSource > | |
| CvtkSmartPointer< vtkTemporalInterpolatedVelocityField > | |
| CvtkSmartPointer< vtkSignedCharArray > | |
| CvtkSmartPointer< vtkBitArray > | |
| CvtkSmartPointer< vtkPen > | |
| CvtkSmartPointer< vtkContextMapper2D > | |
| CvtkSmartPointer< vtkColorSeries > | |
| CvtkSmartPointer< vtkPlotBar > | |
| CvtkSmartPointer< vtkPointSet > | |
| CvtkSmartPointer< vtkVertex > | |
| CvtkSmartPointer< vtkPolyVertex > | |
| CvtkSmartPointer< vtkTriangle > | |
| CvtkSmartPointer< vtkTriangleStrip > | |
| CvtkSmartPointer< vtkEmptyCell > | |
| CvtkSmartPointer< vtkPolyData_detail::CellMap > | |
| CvtkSmartPointer< vtkCellLinks > | |
| CvtkSmartPointer< vtkEdgeTable > | |
| CvtkSmartPointer< vtkDataObjectToTable > | |
| CvtkSmartPointer< vtkApplyColors > | |
| CvtkSmartPointer< vtkQImageToImageSource > | |
| CvtkSmartPointer< vtkAddMembershipArray > | |
| CvtkSmartPointer< vtkExtractSelectedGraph > | |
| CvtkSmartPointer< vtkExtractSelectedRows > | |
| CvtkSmartPointer< vtkBalloonRepresentation > | |
| CvtkSmartPointer< vtkLabelPlacementMapper > | |
| CvtkSmartPointer< vtkHoverWidget > | |
| CvtkSmartPointer< vtkHardwareSelector > | |
| CvtkSmartPointer< vtkVertexDegree > | |
| CvtkSmartPointer< vtkEdgeCenters > | |
| CvtkSmartPointer< vtkPointSetToLabelHierarchy > | |
| CvtkSmartPointer< vtkGraphLayout > | |
| CvtkSmartPointer< vtkPerturbCoincidentVertices > | |
| CvtkSmartPointer< vtkEdgeLayout > | |
| CvtkSmartPointer< vtkGraphToGlyphs > | |
| CvtkSmartPointer< vtkScalarBarWidget > | |
| CvtkSmartPointer< vtkRemoveHiddenData > | |
| CvtkSmartPointer< vtkApplyIcons > | |
| CvtkSmartPointer< vtkWorldPointPicker > | |
| CvtkSmartPointer< vtkTreeLevelsFilter > | |
| CvtkSmartPointer< vtkTreeFieldAggregator > | |
| CvtkSmartPointer< vtkAreaLayout > | |
| CvtkSmartPointer< vtkTextProperty > | |
| CvtkSmartPointer< vtkSpline > | |
| CvtkSmartPointer< vtkTextureObject > | |
| CvtkSmartPointer< vtkSurfaceLICComposite > | |
| CvtkSmartPointer< vtkLineIntegralConvolution2D > | |
| CvtkSmartPointer< vtkDendrogramItem > | |
| CvtkSmartPointer< TemporalFractalOutputUtil > | |
| CvtkSmartPointer< vtkCachingInterpolatedVelocityField > | |
| CvtkSmartPointer< vtkTemporalPathLineFilterInternals > | |
| CvtkSmartPointer< vtkTexture > | |
| CvtkSmartPointer< vtkHeatmapItem > | |
| CvtkSmartPointer< vtkBoxLayoutStrategy > | |
| CvtkSmartPointer< vtkSliceAndDiceLayoutStrategy > | |
| CvtkSmartPointer< vtkSquarifyLayoutStrategy > | |
| CvtkSmartPointer< AMRIndexIterator > | |
| CvtkSmartPointer< vtkUniformGridAMR > | |
| CvtkSmartPointer< vtkAbstractCellLinks > | |
| CvtkSmartPointer< vtkCellTypes > | |
| CvtkSmartPointer< vtkCellArrayIterator > | |
| CvtkSmartPointer< vtkAbstractArray > | |
| CvtkSmartPointer< vtkVolumeTexture > | |
| CvtkSmartPointer< vtkOpenGLVolumeLookupTables< vtkOpenGLVolumeGradientOpacityTable > > | |
| CvtkSmartPointer< vtkOpenGLVolumeLookupTables< vtkOpenGLVolumeOpacityTable > > | |
| CvtkSmartPointer< vtkOpenGLVolumeLookupTables< vtkOpenGLVolumeRGBTable > > | |
| CvtkSmartPointer< vtkOpenGLVolumeLookupTables< vtkOpenGLVolumeTransferFunction2D > > | |
| CvtkSmartPointer< vtkImplicitFunction > | |
| CvtkSmartPointer< vtkTypeInt64Array > | |
| CvtkSmartPointer< vtkTypeUInt32Array > | |
| CvtkSmartPointer< vtkOverlappingAMR > | |
| CvtkSmartPointer< T > | Hold a reference to a vtkObjectBase instance |
| 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 |
| CvtkSMPThreadLocal< T > | Thread local storage for VTK objects |
| CvtkSMPThreadLocal< T * > | |
| CvtkSMPThreadLocal< vtkProgressObserver * > | |
| Cvtk::detail::smp::vtkSMPThreadLocalAPI< T > | |
| Cvtk::detail::smp::vtkSMPThreadLocalAPI< T * > | |
| Cvtk::detail::smp::vtkSMPThreadLocalAPI< vtkProgressObserver * > | |
| ►Cvtk::detail::smp::vtkSMPThreadLocalImplAbstract< T > | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< Backend, T > | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< BackendType::OpenMP, T > | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< BackendType::STDThread, T > | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< BackendType::Sequential, T > | |
| Cvtk::detail::smp::vtkSMPThreadLocalImpl< BackendType::TBB, T > | |
| CvtkSMPThreadLocalObject< T > | Thread local storage for VTK objects |
| CvtkSMPThreadLocalObject< vtkProgressObserver > | |
| Cvtk::detail::smp::vtkSMPThreadPool | |
| CvtkSMPTools | A set of parallel (multi-threaded) utility functions |
| Cvtk::detail::smp::vtkSMPToolsAPI | |
| Cvtk::detail::smp::vtkSMPToolsImpl< Backend > | |
| CvtkSQLiteDatabaseInternals | |
| CvtkStateStorage | Class to make storing and comparing state quick and easy |
| CvtkStaticCellLinksTemplate< TIds > | Object represents upward pointers from points to list of cells using each point (template implementation) |
| CvtkStaticCellLinksTemplate< vtkIdType > | |
| CvtkStaticEdgeLocatorTemplate< IDType, EdgeData > | Templated on types of ids defining an edge, and any data associated with the edge |
| 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 |
| CvtkSurfaceLICHelper | A small collection of noise routines for LIC |
| CvtkSystemIncludes | Transition VTK to ANSI C++, centralize inclusion of system files |
| CvtkTclCommandArgStruct | |
| CvtkTclCommandStruct | |
| CvtkTclInterpStruct | |
| 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 |
| CvtkThreadedTaskQueue< R, Args > | Simple threaded task queue |
| CvtkThreadedTaskQueue< void, Args... > | |
| CvtkTIFFReader::vtkTIFFReaderInternal | |
| CvtkTIFFReaderInternal | |
| CvtkFileSeriesHelper::vtkTimeInformation | |
| CvtkTimerLogCleanup | |
| CvtkTimerLogEntry | |
| CvtkTimerLogScope | Helper class to log time within scope |
| 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 rendering |
| 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, 4 > | |
| CvtkRect< T > | Templated base type for storage of 2D rectangles |
| CvtkVector4< T > | |
| ►CvtkVector< T, 2 > | |
| CvtkVector2< T > | |
| ►CvtkVector< T, 3 > | |
| CvtkVector3< T > | |
| CvtkVector< T, Size > | Templated base type for storage of vectors |
| ►CvtkTuple< double, 3 > | |
| ►CvtkColor3< double > | |
| CvtkColor3d | |
| ►CvtkTuple< double, 4 > | |
| ►CvtkColor4< double > | |
| CvtkColor4d | |
| ►CvtkQuaternion< double > | |
| CvtkQuaterniond | |
| ►CvtkTuple< double, Size > | |
| ►CvtkVector< double, 4 > | |
| ►CvtkRect< double > | |
| CvtkRectd | |
| ►CvtkVector4< double > | |
| CvtkVector4d | |
| ►CvtkVector< double, 2 > | |
| ►CvtkVector2< double > | |
| CvtkVector2d | |
| ►CvtkVector< double, 3 > | |
| ►CvtkVector3< double > | |
| CvtkVector3d | |
| ►CvtkTuple< float, 3 > | |
| ►CvtkColor3< float > | |
| CvtkColor3f | |
| ►CvtkTuple< float, 4 > | |
| ►CvtkColor4< float > | |
| CvtkColor4f | |
| ►CvtkQuaternion< float > | |
| CvtkQuaternionf | |
| ►CvtkTuple< float, Size > | |
| ►CvtkVector< float, 4 > | |
| ►CvtkRect< float > | |
| CvtkRectf | |
| ►CvtkVector< float, 2 > | |
| ►CvtkVector2< float > | |
| CvtkVector2f | |
| ►CvtkVector< float, 3 > | |
| ►CvtkVector3< float > | |
| CvtkVector3f | |
| CvtkTuple< int, 2 > | |
| CvtkTuple< int, 3 > | |
| CvtkTuple< int, 4 > | |
| CvtkTuple< int, 6 > | |
| ►CvtkTuple< int, Size > | |
| ►CvtkVector< int, 4 > | |
| ►CvtkRect< int > | |
| CvtkRecti | |
| ►CvtkVector4< int > | |
| CvtkVector4i | |
| ►CvtkVector< int, 2 > | |
| ►CvtkVector2< int > | |
| CvtkVector2i | Some derived classes for the different vectors commonly used |
| ►CvtkVector< int, 3 > | |
| ►CvtkVector3< int > | |
| CvtkVector3i | |
| ►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 |
| CvtkUnicodeString | String class that stores Unicode text |
| CvtkUpdateCellsV8toV9 | Update cells from v8 node layout to v9 node layout |
| CCGNSRead::VTKVariable | |
| 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 | |
| CvtkVolumeInputHelper | Convenience container for internal structures specific to a volume input |
| CvtkVolumeMask | |
| CvtkVolumeStateRAII | |
| CvtkVRMLImporter_Yacc | |
| CvtkVRMLUseStruct | |
| CvtkVRMLYaccData | |
| ►CvtkWeakPointerBase | Non-templated superclass for vtkWeakPointer |
| CvtkWeakPointer< vtkAbstractWidget > | |
| CvtkWeakPointer< IteratorType > | |
| CvtkWeakPointer< vtkAxisActor > | |
| CvtkWeakPointer< vtkRenderer > | |
| CvtkWeakPointer< vtkContextScene > | |
| CvtkWeakPointer< vtkRenderWindowInteractor > | |
| CvtkWeakPointer< vtkContext2D > | |
| CvtkWeakPointer< vtkRenderWindow > | |
| CvtkWeakPointer< vtkOpenGLRenderWindow > | |
| CvtkWeakPointer< vtkLagrangianParticleTracker > | |
| CvtkWeakPointer< vtkMapper > | |
| CvtkWeakPointer< vtkCamera > | |
| CvtkWeakPointer< vtkProp3D > | |
| CvtkWeakPointer< vtkOpenVRRenderWindow > | |
| CvtkWeakPointer< vtkPiecewiseFunction > | |
| CvtkWeakPointer< vtkViewport > | |
| CvtkWeakPointer< vtkViewNode > | |
| CvtkWeakPointer< vtkObject > | |
| CvtkWeakPointer< T > | Weak reference to a vtkObject |
| 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 |
| ►Cvtx::VTXSchema | Abstract common class to supported ADIOS2 schemas |
| ►Cvtx::schema::VTXvtkBase | |
| Cvtx::schema::VTXvtkVTI | |
| Cvtx::schema::VTXvtkVTU | |
| Cvtx::VTXSchemaManager | |
| CvtkDendrogramItem::WeightedVertex | |
| CvtkMatrixUtilities::detail::Wrapper< RowsT, ColsT, MatrixT, LayoutT, MatrixLayoutIs2DT > | |
| CvtkMatrixUtilities::Wrapper< RowsT, ColsT, MatrixT, LayoutT > | Matrix wrapping class |
| CvtkMatrixUtilities::detail::Wrapper< RowsT, ColsT, MatrixT, Layout::Diag, false > | |
| CvtkMatrixUtilities::detail::Wrapper< RowsT, ColsT, MatrixT, Layout::Identity, true > | |
| CvtkMatrixUtilities::detail::Wrapper< RowsT, ColsT, MatrixT, Layout::Transpose, true > | |
| CvtkMatrixUtilities::detail::Wrapper< RowsT, ColsT, MatrixT, LayoutT, false > | |
| CX3DEncoderFunctions | |
| CvtkXdmfReader::XdmfDataSetTopoGeoPath | |
| CvtkVRMLYaccData::yy_buffer_state | |
| CvtkVRMLYaccData::yyltype | |
| CvtkVRMLYaccData::YYSTYPE | |
| CCGNSRead::ZoneBCInformation | |
| CCGNSRead::ZoneInformation | |
1.9.4