| CZCCompatFrustumBounds::[struct].__unnamed0__ | |
| CZSMatrix4::[struct].__unnamed0__ | |
| CZSVector3::[struct].__unnamed0__ | |
| Cvtk::detail::vtkOpenXRManager::Action_t::[union].States | |
| C_vtkTclVoidFuncArg | |
| CvtkGLTFDocumentLoader::Accessor | This struct describes an accessor glTF object |
| Cvtk::detail::vtkOpenXRManager::Action_t | |
| CvtkOpenVRRenderWindowInteractor::ActionData | |
| CvtkWebXRRenderWindowInteractor::ActionData | |
| CActionFunction< TWidget > | |
| CvtkWebGPUActorInternals::ActorBlock | |
| CvtkSingleVTPExporter::actorData | |
| Cvtk::detail::AddNames< Container, StopAtType > | |
| Cadjacency_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| Crtw::affine3f | |
| CAlgorithmT | |
| CvtkmAlgorithm< AlgorithmT > | Base class for VTK-m algorithms |
| CvtkCellGridEvaluator::AllocationsByCellType | Hold per-type input point assignment and an offset for output arrays |
| CvtkDataArrayPrivate::AllValues | |
| CvtkGLTFDocumentLoader::Animation | This struct describes a glTF animation object |
| CvtkAnimationCue::AnimationCueInfo | |
| CvtkTypeList::Append< TList, T, Rest > | Appends types/TypeLists to TypeList TList and stores the result in Result |
| CvtkVRCollaborationClient::Argument | |
| Cfromvtkm::ArrayHandleHelperBase< T > | |
| Cfromvtkm::ArrayHandleHelperRead< ArrayHandleType > | |
| Cfromvtkm::ArrayHandleHelperUnknown< T > | |
| Cfromvtkm::ArrayHandleHelperWrite< ArrayHandleType > | |
| CvtkExodusIIReaderPrivate::ArrayInfoType | A struct to hold information about time-varying arrays |
| CArrayList | |
| CvtkMatrixUtilities::detail::ArrayOrPointerDepth< MatrixT, Depth > | |
| CvtkMatrixUtilities::detail::ArrayOrPointerDepth< MatrixT &, Depth > | |
| CvtkMatrixUtilities::detail::ArrayOrPointerDepth< MatrixT *, Depth > | |
| CvtkMatrixUtilities::detail::ArrayOrPointerDepth< MatrixT[], Depth > | |
| CvtkMatrixUtilities::detail::ArrayOrPointerDepth< MatrixT[N], Depth > | |
| CvtkLagrangianBasicIntegrationModel::ArrayVal | |
| CvtkStatisticsAlgorithm::AssessFunctor | A base class for a functor that assesses data |
| CvtkKMeansAssessFunctor | |
| CvtkMultiCorrelativeAssessFunctor | |
| CvtkWebGPUPolyDataMapper::AttributeBuffer | |
| CAvmeshMetadata | |
| CAvmeshPatch | |
| CRTW::Backend | |
| CRTW::OSPRayBackend | |
| CRTW::VisRTXBackend | |
| CvtkBlockSortHelper::BackToFront< T > | Operator() for back-to-front sorting |
| CBaseArrayPair | |
| CArrayPair< vtkStringArray, vtkStringArray, vtkStdString > | |
| CArrayPair< TInputArray, TOutputArray, T > | |
| CArrayPair< vtkStringArray, vtkStringArray, vtkStdString > | |
| CCGNSRead::BaseInformation | |
| CvtkCellGridRenderRequest::BaseState | |
| CvtkFieldData::BasicIterator | |
| CvtkFieldData::Iterator | |
| CvtkCompositePolyDataMapperDelegator::BatchElement | |
| CBHLeaf | |
| CBHNode | |
| CBHTree | |
| Cbidirectional_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| CBinaryFile | |
| Cwgpu::BindGroupLayoutEntry | |
| CvtkWebGPUBindGroupLayoutInternals::LayoutEntryInitializationHelper | |
| CvtkWebGPUBindGroupInternals::BindingInitializationHelper | |
| CvtkAMRDataInternals::Block | |
| CvtkDIYGhostUtilities::Block< BlockStructureT, InformationT > | Block structure to be used for diy communication |
| CvtkExodusIIWriter::Block | |
| CvtkUnstructuredGridFieldAnnotations::BlockAttributesKey | A key for indexing annotations |
| CvtkUnstructuredGridFieldAnnotations::BlockAttributesValue | Configuration hints for a partitioned dataset collection entry |
| CvtkParticleTracerBase::bounds_t | |
| Crtw::box3f | |
| Crtw::box3i | |
| CvtkOpenGLState::BufferBindingState | |
| CvtkGLTFDocumentLoader::BufferView | This struct describes a glTF bufferView object |
| CvtkIOSSUtilities::Cache | Cache |
| CvtkTextureImageCache< Key >::CacheData | |
| CvtkDGRenderResponder::CacheEntry | Entries for a cache of render-helpers |
| CvtkCellGridResponders::CalculatorForTagSet | A record of a registered calculator along with the tags it requires and values of those tags it will accept |
| CvtkGLTFDocumentLoader::Camera | This struct describes a glTF camera object |
| CvtkGLSLModCamera::CameraUniformLocations | |
| Cvtk::detail::can_close_trait< T, typename > | An intermediate trait for exposing a unified trait interface |
| Cvtk::detail::can_close_trait< T, void_t< typename is_closure_trait< T >::rtype > > | |
| Cvtk::detail::can_map_component_trait< T, typename > | An intermediate trait for exposing a unified trait interface |
| Cvtk::detail::can_map_component_trait< T, void_t< typename has_map_component_trait< T >::rtype > > | |
| Cvtk::detail::can_map_trait< T, typename > | An intermediate trait for exposing a unified trait interface |
| Cvtk::detail::can_map_trait< T, void_t< typename has_map_trait< T >::rtype > > | |
| Cvtk::detail::can_map_tuple_trait< T, typename > | An intermediate trait for exposing a unified trait interface |
| Cvtk::detail::can_map_tuple_trait< T, void_t< typename has_map_tuple_trait< T >::rtype > > | |
| CvtkTypeList::CanConvert< From, To > | Sets member Result to true if a conversion exists to convert type From to type To |
| CvtkCellArray_detail::GetCellAtIdImpl::CanShareConnPtr< ConnectivityT > | |
| CvtkIOSSUtilities::CaptureNonErrorMessages | A helper to instantiate on stack to temporarily redirect non-critical messages emanating from IOSS |
| CvtkFLUENTCFFReader::Cell | |
| CvtkOpenGLContextDevice2D::CellArrayHelper | |
| CvtkHyperTreeGridGhostCellsGeneratorInternals::CellDataArray | |
| CvtkOpenGLLowMemoryPolyDataMapper::CellGroupInformation | |
| CvtkKdTree::cellList_ | |
| Cdetail::CellTree< T > | |
| Cdetail::CellTreeBuilder< T > | |
| CvtkCellAttribute::CellTypeInfo | |
| CvtkCellGraphicsPrimitiveMap::CellTypeMapperOffsets | |
| CCesium3DTilesHeader | |
| CCGNSRead::CGNSVariable | |
| CCGNSRead::CGNSVector | |
| CvtkGLTFDocumentLoader::Animation::Channel | |
| CvtkUnstructuredGridToCellGrid::TranscribeQuery::Claim | A claim on input vtkCell types registered by an output vtkCellMetadata subclass |
| CvtkCellGridEvaluator::AllocationsByCellType::ClassifiedPoint | The result of classifying a single probe point: the index of the input point, the cell that contains it, and the reference-element (r, s, t) coordinates computed by Newton-Raphson during classification |
| Cimpl::ClientData | |
| CvtkShaderProgram::cmp_str | |
| Cvtk::detail::CollectionIterator< CollectionType > | |
| Cvtk::detail::CollectionRange< CollectionType > | |
| Cdetail::CollectValidCellSurfacePointsFunctor< VArrayType, WArrayType > | |
| CvtkWebGPUActorInternals::ActorBlock::ColorOptions | |
| CvtkDendrogramItem::CompareWeightedVertices | |
| CvtkMergeFields::Component | |
| CvtkSplitField::Component | |
| Cvtk::detail::ComponentIterator< ArrayType, TupleSize > | |
| CvtkCellGridRangeQuery::ComponentRange | Store the finite/entire range for a single component of a cell-attribute |
| Cvtk::detail::ComponentReference< ArrayType, TupleSize > | |
| Cvtk::detail::CompositeDataSetIterator | |
| Cvtk::detail::CompositeDataSetRange | |
| CvtkSMPTools::Config | Structure used to specify configuration for LocalScope() method |
| Cxr::ConnectionExtensionDispatchTable | |
| 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< ValueType >, TupleSize > | |
| Cvtk::detail::ConstValueIterator< ArrayType, TupleSize, ForceValueTypeForVtkDataArray > | |
| Cvtk::detail::ConstValueReference< ArrayType, TupleSize, ForceValueTypeForVtkDataArray > | |
| CvtkWebGPUPointCloudMapperInternals::CopyDepthBufferRenderPipeline | Structure that contains the wgpu objects necessary for the use of the render pipeline that copies the depth buffer of a point cloud mapper to the depth buffer of a render window (using a simple fragment shader that reads the depth from the point depth buffer and writes it to the depth buffer of the render window) |
| CvtkFieldData::CopyFieldFlag | |
| CvtkMaskFields::CopyFieldFlag | |
| CCstring_less | |
| CCWnd | |
| CvtkMFCWindow | Class to display a VTK window in an MFC window |
| Cvtx::types::DataArray | |
| CDatabasePartitionInfo | |
| CvtkAVSucdReader::DataInfo | |
| Cvtk::detail::DataObjectTreeIterator | |
| 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 | |
| CvtkCompositeInterpolatedVelocityField::DataSetBoundsInformation | |
| CvtkDIYGhostUtilities::DataSetInformation | |
| CvtkDIYGhostUtilities::GridInformation | Structure storing information needed by a block on it's own grid structure |
| CvtkDIYGhostUtilities::ImageDataInformation | |
| CvtkDIYGhostUtilities::RectilinearGridInformation | |
| CvtkDIYGhostUtilities::StructuredGridInformation | |
| CvtkDIYGhostUtilities::DataSetTypeToBlockTypeConverter< DataSetT > | This helper structure owns a typedef to the block type of DataSetT used with diy to generate ghosts |
| CvtkVoronoiHull::DeletionStack | A homebrew stack with a preferred API |
| CvtkTypeList::DerivedToFront< TList > | Sort the TypeList from most-derived to least-derived type, storing the sorted TypeList in Result |
| CvtkVRRenderWindow::DeviceData | |
| 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::Dispatch2ByArrayAndSameValueType< ArrayList, ValueTypeList > | Dispatch two arrays, restricting the valid code paths to use only array types found in ArrayList that have a ValueType contained in the ValueTypeList TypeList |
| CvtkArrayDispatch::Dispatch2ByArrayAndValueType< ArrayList1, ArrayList2, ValueTypeList1, ValueTypeList2 > | Dispatch two arrays, restricting the valid code paths to use ValueType-filtered versions of the ArrayList1 and ArrayList2 TypeLists |
| 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::Dispatch2BySameValueTypeUsingArrays< ArrayList, ValueTypeList > | |
| 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::Dispatch2ByValueTypeUsingArrays< ArrayList, ValueTypeList1, ValueTypeList2 > | |
| CvtkArrayDispatch::Dispatch2SameValueTypeUsingArrays< ArrayList > | |
| 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::Dispatch3ByArrayAndValueType< ArrayList1, ArrayList2, ArrayList3, ValueTypeList1, ValueTypeList2, ValueTypeList3 > | Dispatch three arrays, restricting the valid code paths to use ValueType-filtered versions of ArrayList1 , ArrayList2, and ArrayList3 TypeList |
| CvtkArrayDispatch::Dispatch3ByArraySameValueType< ArrayList, ValueTypeList > | Dispatch three arrays, restricting the valid code paths to use only array types found in ArrayList TypeList that have a ValueType contained in the ValueTypeList TypeList |
| 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::Dispatch3BySameValueTypeUsingArrays< ArrayList, ValueTypeList > | |
| 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::Dispatch3ByValueTypeUsingArrays< ArrayList, ValueTypeList1, ValueTypeList2, ValueTypeList3 > | |
| CvtkArrayDispatch::Dispatch3SameValueTypeUsingArrays< ArrayList > | |
| CvtkArrayDispatch::DispatchByArray< ArrayList > | Dispatch a single array against all array types mentioned in the ArrayList template parameter |
| CvtkArrayDispatch::DispatchByArrayAndValueType< ArrayList, ValueTypeList > | Dispatch a single array against all array types in ArrayList with the added restriction that the array must have a type that appears the ValueTypeList TypeList |
| 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 |
| CvtkArrayDispatch::DispatchByValueTypeUsingArrays< ArrayList, ValueTypeList > | |
| CvtkCellArray::DispatchUtilities | |
| CvtkCellArray_detail::CellPointAtIdImpl | |
| CvtkCellArray_detail::GetCellAtIdImpl | |
| CvtkCellArray_detail::GetCellSizeImpl | |
| CvtkCellArray_detail::InsertCellPointImpl | |
| CvtkCellArray_detail::InsertNextCellImpl | |
| CvtkCellArray_detail::ResetImpl | |
| CvtkCellArray_detail::UpdateCellCountImpl | |
| CvtkWebGPUPolyDataMapper::DrawCallArgs | |
| 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 |
| Censight_gold::EnSightDataSet | Handles reading a full EnSight Gold dataset |
| Censight_gold::EnSightFile | EnSightFile performs processing on a single file, whether it's a case file, geometry, etc |
| CvtkCellGridSidesCache::Entry | Each hash entry corresponds to one or more sides of one or more cells |
| CvtkOpenGLArrayTextureBufferCache::Entry | A cached texture buffer for one (array, role) |
| 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 | |
| CvtkThreshold::EvaluateCellsFunctor< TScalarArray > | |
| CvtkRenderTimerLog::Event | Container for a single timed event |
| Cxr::ExtensionDispatchTable | |
| CvtkGLTFDocumentLoader::Extensions | This struct contains extension metadata |
| CvtkGLTFDocumentLoader::Node::Extensions | |
| CvtkGLTFDocumentLoader::Primitive::Extensions | |
| CvtkOpenGLLowMemoryPolyDataMapper::ExtraAttributeValue | |
| CvtkOpenGLPolyDataMapper::ExtraAttributeValue | |
| CvtkMatrixUtilities::detail::ExtractRawComponentType< MatrixT, class > | |
| CvtkMatrixUtilities::detail::ExtractRawComponentType< MatrixT, typename std::enable_if< MatrixIs2DArray< MatrixT >()>::type > | |
| CvtkMatrixUtilities::detail::ExtractRawComponentType< MatrixT, typename std::enable_if<!MatrixIs2DArray< MatrixT >()>::type > | |
| CvtkFLUENTCFFReader::Face | |
| CvtkFreeTypeTools::FaceMetrics | |
| CvtkVoronoiHull::FaceOperation | Keep track of points and faces currently being operated on |
| CvtkVRMLYaccData::FakeAlloca | |
| Cstd::false_type | |
| Cvtk::detail::can_get_memory_size_trait< T > | |
| Cvtk::detail::can_get_memory_size_trait< T * > | |
| Cvtk::detail::can_get_memory_size_trait< const T > | |
| Cvtk::detail::can_get_memory_size_trait< decltype(&std::remove_reference< T >::type::getMemorySize)> | |
| Cvtk::detail::can_get_memory_size_trait< T, void_t< decltype(&std::remove_reference< T >::type::getMemorySize)> > | |
| Cvtk::detail::can_get_memory_size_trait< T * > | |
| Cvtk::detail::can_get_memory_size_trait< T, void_t< decltype(&std::remove_reference< T >::type::getMemorySize)> > | |
| Cvtk::detail::can_get_memory_size_trait< const T > | |
| Cvtk::detail::has_map_component_trait< T > | |
| Cvtk::detail::has_map_component_trait< T * > | |
| Cvtk::detail::has_map_component_trait< const T > | |
| Cvtk::detail::has_map_component_trait< decltype(&std::remove_reference< T >::type::mapComponent)> | |
| Cvtk::detail::has_map_component_trait< T, void_t< decltype(&std::remove_reference< T >::type::mapComponent)> > | |
| Cvtk::detail::has_map_component_trait< R(ArgTupIdx, ArgCompIdx)> | |
| Cvtk::detail::has_map_component_trait< R(T::*)(ArgTupIdx, ArgCompIdx) const > | |
| Cvtk::detail::has_map_component_trait< R(T::*)(ArgTupIdx, ArgCompIdx) const > | |
| Cvtk::detail::has_map_component_trait< T * > | |
| Cvtk::detail::has_map_component_trait< T, void_t< decltype(&std::remove_reference< T >::type::mapComponent)> > | |
| Cvtk::detail::has_map_component_trait< const T > | |
| Cvtk::detail::has_map_trait< T > | |
| Cvtk::detail::has_map_trait< T * > | |
| Cvtk::detail::has_map_trait< const T > | |
| Cvtk::detail::has_map_trait< decltype(&std::remove_reference< T >::type::map)> | |
| Cvtk::detail::has_map_trait< T, void_t< decltype(&std::remove_reference< T >::type::map)> > | |
| Cvtk::detail::has_map_trait< R(Arg)> | |
| Cvtk::detail::has_map_trait< R(T::*)(Arg) const > | |
| Cvtk::detail::has_map_trait< R(T::*)(Arg) const > | |
| Cvtk::detail::has_map_trait< T * > | |
| Cvtk::detail::has_map_trait< T, void_t< decltype(&std::remove_reference< T >::type::map)> > | |
| Cvtk::detail::has_map_trait< const T > | |
| Cvtk::detail::has_map_tuple_trait< T > | |
| Cvtk::detail::has_map_tuple_trait< T * > | |
| Cvtk::detail::has_map_tuple_trait< const T > | |
| Cvtk::detail::has_map_tuple_trait< decltype(&std::remove_reference< T >::type::mapTuple)> | |
| Cvtk::detail::has_map_tuple_trait< T, void_t< decltype(&std::remove_reference< T >::type::mapTuple)> > | |
| Cvtk::detail::has_map_tuple_trait< T * > | |
| Cvtk::detail::has_map_tuple_trait< T, void_t< decltype(&std::remove_reference< T >::type::mapTuple)> > | |
| Cvtk::detail::has_map_tuple_trait< const T > | |
| Cvtk::detail::has_map_tuple_trait< void(ArgIdx, ArgTup *)> | |
| Cvtk::detail::has_map_tuple_trait< void(T::*)(ArgIdx, ArgTup *) const > | |
| Cvtk::detail::has_map_tuple_trait< void(T::*)(ArgIdx, ArgTup *) const > | |
| Cvtk::detail::is_closure_trait< Closure > | |
| Cvtk::detail::is_closure_trait< Closure & > | |
| Cvtk::detail::is_closure_trait< Closure * > | |
| Cvtk::detail::is_closure_trait< const Closure > | |
| Cvtk::detail::is_closure_trait< decltype(&Closure::operator())> | |
| Cvtk::detail::is_closure_trait< Closure, void_t< decltype(&Closure::operator())> > | |
| Cvtk::detail::is_closure_trait< Closure & > | |
| Cvtk::detail::is_closure_trait< Closure * > | |
| Cvtk::detail::is_closure_trait< Closure, void_t< decltype(&Closure::operator())> > | |
| Cvtk::detail::is_closure_trait< R(*)(Arg)> | |
| Cvtk::detail::is_closure_trait< R(Arg)> | |
| Cvtk::detail::is_closure_trait< R(*)(Arg)> | |
| Cvtk::detail::is_closure_trait< R(Closure::*)(Arg) const > | |
| Cvtk::detail::is_closure_trait< R(Closure::*)(Arg) const > | |
| Cvtk::detail::is_closure_trait< const Closure > | |
| CvtkFFT::isFftType< vtkFFT::ComplexNumber > | |
| CvtkFFT::isFftType< vtkFFT::ScalarNumber > | |
| Cvtk::detail::can_get_memory_size_trait< typename, typename > | Used to check whether the template type has a method named getMemorySize |
| Cvtk::detail::has_map_component_trait< typename, typename > | Used to check whether the template type has a method named mapComponent |
| Cvtk::detail::has_map_trait< typename, typename > | Used to check whether the template type has a method named map |
| Cvtk::detail::has_map_tuple_trait< typename, typename > | Used to check whether the template type has a method named mapTuple |
| Cvtk::detail::is_closure_trait< typename, typename > | A trait determining whether an object acts like a mono-variable integer closure |
| CvtkFFT::isFftType< T > | |
| CCGNSRead::FamilyInformation | |
| CvtkHyperTreeGridGenerateFieldStrategy::Field | |
| CvtkUnstructuredGridFieldAnnotations::FieldGlom | Gloms of multiple field names that represent vectors or tensors |
| CVrmlNodeType::FieldRec | |
| CvtkCompositeCellGridReader::FileGroup | |
| Censight_gold::FileSetInfo | |
| CvtkArrayDispatch::FilterArraysByArrayTypeTag< ArrayList, ArrayTypeTagList > | Filter the ArrayList to contain only arrays with ArrayType::ArrayTypeTag that exist in ArrayTypeTagList |
| CvtkArrayDispatch::FilterArraysByDataTypeTag< ArrayList, DataTypeTagList > | Filter the ArrayList to contain only arrays with ArrayType::DataTypeTag that exist in DataTypeTagList |
| 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 | |
| Cvtk::detail::GetAPITypeImpl< ArrayType, ForceValueTypeForVtkDataArray > | |
| Cvtk::detail::GetAPITypeImpl< vtkDataArray, ForceValueTypeForVtkDataArray > | |
| Cvtk::detail::GetCollectionItemType< CollectionType > | |
| CvtkOpenGLCompositePolyDataMapperDelegator::GLBatchElement | |
| CvtkOpenGLLowMemoryBatchedPolyDataMapper::GLBatchElement | |
| CvtkOpenGLRenderWindow::GLFuncResolverState | |
| Cglobal | |
| CvtkOpenGLState::GLState | |
| CGLTFSampler | This struct describes a glTF sampler object |
| CvtkGLTFDocumentLoader::Sampler | This struct describes a glTF sampler object |
| 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 > | |
| Cxr::GraphicsExtensionDispatchTable | |
| CvtkDIYGhostUtilities::StructuredGridBlockStructure::Grid2D | Grid interfacing with block's grid |
| Censight_gold::GridOptions | |
| Ch | Class to read EnSight Gold files |
| Ch | Distribute cell-centered finite element fields from the input dataset onto vtk cell points |
| Ch | Collapses components with magnitude function |
| Ch | Computes the portion of a dataset which is inside a selection |
| CH5RageAdaptor | |
| CvtkGenericDataArrayLookupHelper_detail::has_NaN< T, bool > | |
| CvtkGenericDataArrayLookupHelper_detail::has_NaN< T, false > | |
| CvtkGenericDataArrayLookupHelper_detail::has_NaN< T, true > | |
| Cstd::hash< vtkSmartPointer< T > > | |
| Cstd::hash< vtkStringToken > | VtkStringTokens provide a specialization of std::hash so they can be used in unordered containers |
| CvtkInformationInternals::HashFun | |
| Cvtk::detail::smp::OpenMP::HashTableArray | |
| Cvtk::detail::smp::STDThread::HashTableArray | |
| Cvtk::HasSuperclass< VTKObjectType > | Determine whether the provided class (VTKObjectType ) has a parent class |
| CvtkXMLHyperTreeGridWriter::HyperTreeGridMetaDataForVersion2 | |
| Cidentifier | |
| CMotionFX::CFG::ParameterName | |
| Cvtk::detail::IdStorage< TupleSize > | |
| CvtkGLTFDocumentLoader::Image | This struct describes a glTF image object |
| CvtkHDFReader::Implementation | Implementation for the vtkHDFReader |
| CvtkHDFWriter::Implementation | |
| CvtkLabelHierarchy::Implementation | |
| Cvtk::detail::implicit_array_traits< T > | A composite trait for handling all the different capabilities a "backend" to an implicit array can have |
| 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 |
| CvtkOpenGLInstanceCulling::InstanceLOD | |
| CvtkOpenXRRenderWindow::InstanceVersion | Structure representing OpenXR instance version |
| Cstd::integral_constant | |
| Cvtk::detail::GenericTupleSize< DynamicTupleSize > | |
| 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 > | |
| CvtkQtLabelRenderStrategy::Internals | |
| CvtkmClip::internals | |
| CvtkMultiBlockPLOT3DReaderInternals::InternalSettings | |
| CvtkUnstructuredGridBunykRayCastFunction::Intersection | |
| 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 > | |
| Cvtk::detail::IsVtkArray< T > | |
| CvtkPriorityQueue::Item | |
| Cvtk::detail::IterableTraits< Iterable > | |
| 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::Primitive::Extensions::KHRDracoMeshCompression | |
| CvtkGLTFDocumentLoader::Extensions::KHRLightsPunctual | |
| CvtkGLTFDocumentLoader::Node::Extensions::KHRLightsPunctual | |
| CvtkMatrixUtilities::Layout | This struct determines a prior transform to input matrices, changing the way they are indexed |
| CvtkGLTFDocumentLoader::Extensions::KHRLightsPunctual::Light | |
| CvtkParallelRenderManager::LightInfo | |
| CvtkWebGPULight::LightInfo | |
| CvtkGLSLModLight::LightStatsBasic | |
| CvtkGLSLModLight::LightUniformLocations | |
| Crtw::linear3f | |
| CvtkCellLinks::Link | |
| CvtkEmptyVoronoi2DCompositor::LocalData | Thread local data may be needed |
| CvtkEmptyVoronoi3DCompositor::LocalData | Thread local data may be needed |
| CLocalTri | |
| CLocalVertex | |
| 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 | |
| Cvtk::detail::make_void< Ts > | |
| Cstd::map | |
| CCGNSRead::vtkCGNSArraySelection | |
| CvtkXdmf3ArrayKeeper | LRU cache of XDMF Arrays |
| CvtkXdmf3ArraySelection | Helper to identify requested arrays with |
| CvtkXdmfArraySelection | |
| CBucketList2D< TIds >::MapDataSet< T > | |
| CBucketList< TIds >::MapDataSet< T > | |
| CBucketList2D< TIds >::MapOffsets< T > | |
| CBucketList< TIds >::MapOffsets< T > | |
| 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 > | |
| CvtkWebGPUActorInternals::MapperBooleanCache | |
| CBucketList2D< TIds >::MapPointsArray< T, TPointsArray > | |
| CBucketList< TIds >::MapPointsArray< T, TPointsArray > | |
| CBucketList2D< TIds >::MapPointsArrayWorker | |
| CBucketList< TIds >::MapPointsArrayWorker | |
| CvtkJoinTables::Maps< T > | |
| 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 |
| CBucketList2D< TIds >::MergeClose< T > | |
| CBucketList< TIds >::MergeClose< T > | |
| CBucketList< TIds >::MergeBinOrder< T > | |
| CBucketList< TIds >::MergePointOrder< T > | |
| CBucketList< TIds >::MergePointsAndData< T > | |
| CBucketList2D< TIds >::MergePrecise< T > | |
| CBucketList< TIds >::MergePrecise< T > | |
| 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< vtkCompositeDataIterator, CompositeDataSetIterator > | |
| Cvtk::CompositeDataSetNodeReference< vtkDataObjectTreeIterator, DataObjectTreeIterator > | |
| 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 | |
| Cvtk::detail::Name< ObjectType > | |
| CVrmlNodeType::NameTypeRec | |
| Cnifti_1_header | Data structure defining the fields in the nifti1 header. This binary header should be found at the beginning of a valid NIFTI-1 header file |
| Cnifti_2_header | Data structure defining the fields in the nifti2 header. This binary header should be found at the beginning of a valid NIFTI-2 header file |
| CCIEDE2000::Node | Node of the color path |
| CvtkGLTFDocumentLoader::Node | This struct describes a glTF node object |
| CvtkSurfaceNets3DNonManifoldCases::NonManifoldCaseMetadata | For non-manifold edge cases: |
| 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 |
| CvtkCocoaHardwareView | This class is a subclass of Cocoa's NSView; it uses Objective-C++ |
| CNSView | |
| CvtkCocoaGLView | Cocoa OpenGL rendering context |
| CvtkCocoaHardwareView | This class is a subclass of Cocoa's NSView; it uses Objective-C++ |
| CvtkTypeList::NullType | Used to terminate a TypeList |
| CvtkLabeledFormatterInterface::NumericComponent | |
| CvtkLabeledFormatterInterface::NumericVector | |
| 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 | |
| CvtkToImplicitStrategy::Optional | A helper structure for communicating a result with an optional double value |
| CvtkDIYGhostUtilities::StructuredGridInformation::OuterPointLayersType | This structure represents the set of points and their corresponding extent of an external face of the structured grid |
| CvtkCellGridToUnstructuredGrid::Query::OutputAllocation | A placeholder for space to be occupied in a vtkCellArray |
| CvtkTextCodec::OutputIterator | Base class that any output iterators need to derive from to use the first signature of to_unicode |
| CvtkDelimitedTextCodecIteratorPrivate | Implements vtkTextCodec::OutputIterator to fill a vtkTable from text input |
| CvtkObjectFactory::OverrideInformation | |
| Cstd::pair | |
| CvtkTextureImageCache< Key >::CacheElement | CacheElement associates a unique key to some cache |
| CvtkAnariPolyDataMapperInheritInterface::ParameterFlags | Specifies parameter flags, which can be used by inheriting classes to specify which parameter it takes responsibility for |
| Cvtk::ParentClasses< VTKObjectType, IsDerived > | Invoke a functor on the named type and each of its parent types |
| Cvtk::ParentClasses< VTKObjectType, false > | |
| Cvtk::ParentClasses< VTKObjectType, true > | |
| CvtkParticleTracerBaseNamespace::ParticleInformation_t | |
| Censight_gold::PartInfo | |
| CvtkPartitioningStrategy::PartitionInformation | Encapsulation structure for describing the result of a partitioning calculation |
| CvtkEnSightReader::PartTransforms | |
| CvtkGLTFDocumentLoader::Material::PbrMetallicRoughness | |
| CPIO_DATA | Class for reading PIO (Parallel Input Output) data files |
| CPIO_DATA_HDF5 | Class for reading PIO (Parallel Input Output) files in HDF5 format |
| CPIO_DATA_PIO | Class for reading PIO (Parallel Input Output) data files |
| CPIO_FIELD | |
| CPIOAdaptor | Class for reading PIO (Parallel Input Output) data files |
| CPIOMaterialVariable | |
| CvtkHardwareSelector::PixelInformation | Struct used to return information about a pixel location |
| CvtkConvexHull::Plane | Half-plane representation: point P is inside the hull iff P·Normal ≤ D for every plane in the set |
| Cplus | |
| CMotionFX::CFG::Value | |
| CvtkGenericEdgeTable::PointEntry | |
| CvtkQuadricClustering::PointQuadric | |
| CvtkAppendPolyData::PolyDataOffsets | PolyDataOffsets agregates cell array information from the input polydata list |
| CvtkHDFWriter::Implementation::PolyDataTopos | Stores a group name and the corresponding cell array |
| CvtkVRCamera::Pose | |
| CvtkOpenVRCameraPose | |
| CvtkVRCollaborationClient::Pose | |
| CvtkParticleTracerBaseNamespace::Position_t | |
| CvtkGLTFDocumentLoader::Primitive | This struct describes a glTF primitive object |
| CvtkCellGraphicsPrimitiveMap::PrimitiveDescriptor | |
| CvtkOpenGLPolyDataMapper::primitiveInfo | |
| CvtkOpenGLLowMemoryPolyDataMapper::PrimitiveInformation | |
| CvtkLabelHierarchy::Implementation::PriorityComparator | |
| CvtkOpenGLContextDevice2D::Private | |
| CvtkVoronoiCore2D< TCompositor, TClassifier >::ProduceWheelsAndSpokes | Produce the global adjacency graph / wheels and spokes data structure |
| CvtkVoronoiCore3D< TCompositor, TClassifier >::ProduceWheelsAndSpokes | Produce the global adjacency graph / wheels and spokes data structure |
| 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 > | |
| Cvtk::detail::smp::vtkSMPThreadPool::Proxy | Proxy class used to submit work to the thread pool |
| 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 |
| CQAbstractTableModel | |
| CQVTKTableModelAdapterTestClass | Class required by TestQVTKTableModelAdapter to run Qt tests involving event loop |
| CQApplication | |
| CQVTKApplication | |
| CQEvent | |
| CQQuickVTKPinchEvent | Custom multitouch pinch event handler for QML PinchHandler |
| CQObject | |
| CQVTKInteractorAdapter | |
| CQQuickVTKInteractorAdapter | Interactor that handles relaying custom QML handler events to VTK |
| CQVTKInteractorInternal | |
| CQVTKRenderWindowAdapter | Helper to manage Qt context and other OpenGL components |
| CQVTKTableModelAdapter | An adapter to create a vtkTable from an QAbstractItemModel |
| 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) |
| CQOpenGLWidget | |
| CQVTKOpenGLNativeWidget | QOpenGLWidget subclass to house a vtkGenericOpenGLRenderWindow in a Qt application |
| CQOpenGLWindow | |
| CQVTKOpenGLWindow | Display a vtkGenericOpenGLRenderWindow in a Qt QOpenGLWindow |
| CQQuickItem | |
| CQQuickVTKItem | QQuickItem that manages a VTK rendering in the QML scenegraph |
| CQSortFilterProxyModel | |
| CQFilterTreeProxyModel | |
| CQStandardItemModel | |
| CReferenceCountModel | |
| CvtkQtDebugLeaksModel | Model class that observes the vtkDebugLeaks singleton |
| CQTestApp | |
| 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 |
| CvtkDGOperationBase::RangeKey | A range of cell IDs handled by a vtkDGCell::Source instance |
| CvtkResourceParser::ReadToResult< It > | Structure returned by Read*To functions |
| CRealDescriptor | |
| CvtkAnariCompositePolyDataMapperNode::RenderBlockState | |
| CvtkOSPRayCompositePolyDataMapperNode::RenderBlockState | |
| CvtkParallelRenderManager::RendererInfo | |
| CvtkSynchronizedRenderers::RendererInfo | |
| CvtkWebGPUActorInternals::ActorBlock::RenderOptions | |
| Cwgpu::RenderPassDescriptor | |
| CvtkWebGPURenderPassDescriptorInternals | |
| Cwgpu::RenderPipelineDescriptor | |
| CvtkWebGPURenderPipelineDescriptorInternals | |
| Cvtk::detail::vtkOpenXRManager::RenderResources_t | This struct stores all needed information to render the images and send it to the user We can't make a vector of struct because OpenXR SDK needs an array of XrXXX for xrEnumerate functions |
| 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 | |
| CvtkThreadedTaskQueueInternals::ResultQueue< R > | |
| Cstd::runtime_error | |
| CAvmeshError | |
| CvtkGLTFDocumentLoader::Animation::Sampler | |
| 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 | |
| CvtkMarshalContext::ScopedParentTracker | Convenient to push a parent as the 'active' identifier and add children to that parent when (de)serializing sub-states or sub-objects |
| 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, ForceValueTypeForVtkDataArray > | |
| 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 |
| CvtkCellGridSidesCache::Side | Records held by a hash-entry that represent the side of one cell |
| CvtkCellGridSidesQuery::SideSetArray | A structure created by the GetSideSetArrays() method for responders to use |
| CvtkTypeList::Size< TList > | Get the Size of the TypeList TList |
| 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 | |
| CvtkDGCell::Source | Records describing the source arrays for cells or cell-sides |
| 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 | |
| CvtkSurfaceNets3DNonManifoldCases::StateInfo | Decoded metadata for a state: number of points to generate and the corresponding non-manifold table index |
| Cdiy::StaticAssigner | |
| CvtkDIYExplicitAssigner | Assigner for use with DIY |
| CvtkDataObjectMeshCache::Status | Structure to handle the current cache status |
| 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 > > | |
| Cvtk::detail::StripPointers< vtkWeakPtr< ArrayType > > | |
| CvtkZSpaceSDKManager::StylusEventData | Event data structure used for sending vtkCommand::UserEvent considered here also as custom stylus events |
| CvtkCellGridSummaryInformationQuery::SummaryInformation | Information to collect on a per-vtkCellAttribute basis |
| CvtkLagrangianBasicIntegrationModel::SurfaceArrayDescription | |
| Cvtk::detail::vtkOpenXRManager::Swapchain_t | Swapchain structure storing information common to all rendering backend |
| CvtkOpenXRManagerD3DGraphics::SwapchainImagesD3D | D3D structure to store swapchain images |
| CvtkOpenXRManagerOpenGLGraphics::SwapchainImagesOpenGL | OpenGL structure to store swapchain images |
| CvtkNumberToString::TagDouble | |
| CtagFlashReaderBlock | |
| CtagFlashReaderDoubleScalar | |
| CtagFlashReaderIntegerScalar | |
| CtagFlashReaderSimulationInformation | |
| CtagFlashReaderSimulationParameters | |
| CvtkNumberToString::TagFloat | |
| CvtkPolyData_detail::TaggedCellId | |
| CvtkAMRVelodyneReaderInternal::tagVelodyneBlock | |
| CvtkThreadedTaskQueueInternals::TaskQueue< R > | |
| CvtkHDFUtilities::TemporalGeometryOffsets | |
| CvtkHDFUtilities::TemporalHyperTreeGridOffsets | |
| CTestPipelineInterface | Interface to provide a pipeline utility: |
| CTestCompositePipeline | Implement TestPipelineInterface |
| CTestMeshPipeline | Implement TestPipelineInterface |
| 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 |
| CvtkDGInterpolateCalculator::ThreadLocalData | |
| Cvtk::detail::smp::OpenMP::ThreadSpecific | |
| Cvtk::detail::smp::STDThread::ThreadSpecific | |
| Cvtk::detail::smp::OpenMP::ThreadSpecificStorageIterator | |
| Cvtk::detail::smp::STDThread::ThreadSpecificStorageIterator | |
| Censight_gold::TimeSetInfo | |
| CvtkVoronoiCore2D< TCompositor, TClassifier >::TopologicalMerge | Functor class used to topologically merge (nearly) coincident points |
| CvtkVoronoiCore3D< TCompositor, TClassifier >::TopologicalMerge | Functor class used to topologically merge (nearly) coincident points |
| CvtkWebGPUPolyDataMapper::TopologyBindGroupInfo | |
| CvtkDIYGhostUtilities::PolyDataBlockStructure::TopologyBufferType | |
| CvtkDIYGhostUtilities::UnstructuredGridBlockStructure::TopologyBufferType | Topology information for cells to be exchanged |
| CvtkOpenVRRenderWindowInteractor::TrackerActions | |
| CvtkWebGPUActorInternals::ActorBlock::TransformInfo | |
| CTreeInformation | Additional information and routines for 3D Tiles octree nodes |
| CvtkUnstructuredGridBunykRayCastFunction::Triangle | |
| CTriArray | |
| Cstd::true_type | |
| CvtkFFT::isFftType< vtkFFT::ComplexNumber > | |
| CvtkFFT::isFftType< vtkFFT::ScalarNumber > | |
| CvtkDGArrayOutputAccessor::Tuple | Expose a tuple in a vtkDoubleArray as an object with a size() method to satisfy requirements of the output iterator API |
| 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< ValueType >, TupleSize > | |
| CvtkTypeList::TypeList< T, U > | Generic implementation of TypeList |
| CvtkURIComponent::UndefinedTag | |
| CvtkOpenGLLowMemoryPolyDataMapper::UniformLocations | |
| CvtkTypeList::Unique< TList > | Remove all duplicate types from TypeList TList, storing the new list in Result |
| CvtkDIYGhostUtilities::UnstructuredDataInformation | |
| CvtkDIYGhostUtilities::PolyDataInformation | |
| CvtkDIYGhostUtilities::UnstructuredGridInformation | |
| CvtkVoronoiAdjacencyGraph::ValidateAdjacencyGraph | Threaded perform validity checking |
| Cvtk::detail::ValueIterator< ArrayType, TupleSize, ForceValueTypeForVtkDataArray > | |
| Cvtk::detail::ValueRange< ArrayTypeT, TupleSize, ForceValueTypeForVtkDataArray > | |
| Cvtk::detail::ValueRange< vtkAOSDataArrayTemplate< ValueTypeT >, TupleSize, ForceValueTypeForVtkDataArray > | |
| Cvtk::detail::ValueReference< ArrayType, TupleSize, ForceValueTypeForVtkDataArray > | |
| CCGNSRead::Variable | |
| CvtkExodusIIWriter::VariableInfo | |
| Censight_gold::VariableOptions | |
| CvtkTransformFeedback::VaryingMetaData | |
| Crtw::vec2f | |
| Crtw::vec2i | |
| Crtw::vec3f | |
| Crtw::vec3i | |
| Crtw::vec3ui | |
| Crtw::vec4f | |
| Cstd::vector | |
| CvtkSmartVector< vtkTextActor > | |
| CvtkContextScenePrivate | Private implementation for scene/items |
| CvtkDataObjectTreeIndex | |
| CvtkDist2TupleArray | Represent an array of vtkDist2Tuples |
| CvtkSmartVector< T > | A vector of smart pointers |
| CvtkVoronoiHull::FaceProcessingArray | Unique list of faces (by id) that require processing |
| CvtkVoronoiHull::PointProcessingArray | Add points to be processed |
| 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 > | |
| CVertexArray | |
| CvtkView::ViewProgressEventCallData | A ptr to an instance of ViewProgressEventCallData is provided in the call data when vtkCommand::ViewProgressEvent is fired |
| CvtkCellArray::VisitState< ArrayT > | |
| CvtkVolumeTexture::VolumeBlock | |
| CvtkSurfaceNets3DNonManifoldCases::VoxelNeighborhood< T > | Holds the local configuration of the 8 voxels surrounding a triad point in the grid |
| CVrmlNodeType | |
| Cvtk2DHistogramItem | 2D histogram item |
| CvtkABI | Manage macros for exporting symbols in the binary interface |
| CvtkAffineImplicitBackend< ValueType > | A utility structure serving as a backend for affine (as a function of the index) implicit arrays |
| 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 |
| CvtkAnariPolyDataMapperInheritInterface | Interface for inheriting classes for overriding mapper functionality |
| CvtkAnariProfiling | Allows instrumenting of the VTK ANARI source code |
| CvtkAnnularBinIterator | A fast, lightweight class for iterating over the bins of a 2D vtkStaticPointLocator2D |
| CvtkAnnularBinIteratorDispatch | |
| 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 |
| CvtkAtomicMutex | Mutual exclusion locking class using atomic operations |
| CvtkBatch< TBatchData > | VtkBatch is a simple structure that holds a begin and end id |
| CvtkBatches< TBatchData > | |
| 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 |
| CvtkBucketList | Private declarations for 3D binned spatial locator |
| CBucketList< T > | |
| CBucketList< TIds > | |
| CvtkBucketList2D | Private declarations for 2D binned spatial locator |
| CBucketList2D< T > | |
| CBucketList2D< TIds > | |
| 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 |
| CvtkCocoaAutoreleasePool | RAII class to create an NSAutoreleasePool |
| CvtkCocoaMacOSXSDKCompatibility | Compatibility header |
| CvtkColor | Templated type for storage of colors |
| CvtkCommonInformationKeyManager | Manages key types in vtkCommon |
| CvtkCompositeImplicitBackend< ValueType > | A utility structure serving as a backend for composite arrays: an array composed of multiple arrays concatenated together |
| CvtkConduitToDataObject | Convert conduit node to VTK data objects |
| CvtkConstantImplicitBackend< ValueType > | A utility structure serving as a backend for constant implicit arrays |
| 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 > | |
| CvtkDataObjectImplicitBackendInterface< ValueType > | A utility structure that can be used as a base for implicit array backend that relies on a vtkDataObject |
| CvtkDataObjectToConduit | Convert VTK Data Object to Conduit Node |
| CvtkDataObjectTreeInternals | |
| CvtkDataObjectTreeItem | |
| CvtkDataSetAttributesFieldList | Helps manage arrays from multiple vtkDataSetAttributes |
| CvtkIntegrateAttributesFieldList | Helper class for vtkIntegrateAttributes |
| CvtkAbstractInterpolatedVelocityField::vtkDataSetInformation | |
| CvtkDebugLeaksManager | Manages the vtkDebugLeaks singleton |
| CvtkDebugLeaksObserver | |
| CvtkDecimatePro | Reduce the number of triangles in a mesh |
| CvtkNetCDFCFReader::vtkDependentDimensionInfo | |
| CvtkDGArrayOutputAccessor | Store values interpolated from DG cells into a vtkDoubleArray instance |
| CvtkDGArraysInputAccessor | Evaluate DG cells whose indices and parameters are provided by vtkDataArray instances |
| CvtkDGOperationBase | A base class for operator evaluators |
| CvtkDGOperation< vtkDGArraysInputAccessor, vtkDGArrayOutputAccessor > | |
| CvtkDGOperation< InputIterator, OutputIterator > | Invoke an operator on DG cells/sides |
| CvtkDGOperationState | Encapsulate the state required to evaluate DG cell-attributes |
| CvtkDGOperationEvaluator< InputIterator, OutputIterator, DOFSharing, SourceType, Modifier, ShapeSharing > | Evaluate a vtkDGOperationEntry on a provided cell ID at provided parametric coordinates |
| CvtkDGOperationStateEntryBase | This is a base class that exists so that vtkDGOperationState can provide a virtual CloneInto method that accepts any of the templated subclasses below |
| CvtkDGOperationStateEntry< InputIterator, OutputIterator > | Encapsulate the state required to evaluate DG cell-attributes |
| CvtkDGOperatorEntry | A record for a basis in a function space that is specific to one cell shape |
| CvtkDijkstraGraphInternals | Helper class due to PIMPL excess |
| CvtkNetCDFCFReader::vtkDimensionInfo | |
| CvtkDist2Tuple | Represent a 2-tuple consisting of a VTK Id, and a distance**2 value |
| CvtkDIYUtilitiesCleanup | |
| CvtkDrawTexturedElements | A base class for mappers or render responders that need to draw primitives via vertex-pulling |
| CvtkArrayRenderer | Render instanced elements textured with arrays from input data |
| CvtkOpenGLLowMemoryPolyDataMapper | PolyDataMapper using OpenGL to render surface meshes |
| CvtkOpenGLLowMemoryBatchedPolyDataMapper | An OpenGL mapper for batched rendering of vtkPolyData |
| CvtkEdgeBase | |
| CvtkEdgeType | |
| CvtkInEdgeType | |
| CvtkOutEdgeType | |
| CvtkEGLConfig | Base class for EGL configuration |
| CvtkEGLAndroidConfig | VtkEGLAndroidConfig |
| CvtkEGLDefaultConfig | VtkEGLDefaultConfig |
| CvtkEGLWaylandConfig | VtkEGLWaylandConfig |
| CvtkEGLRenderWindowInternals | Internal class used to store and control EGL state |
| CvtkEmptyVoronoi2DClassifier | |
| CvtkEmptyVoronoi2DCompositor | These are convenience/demonstration classes for configuring the templated 2D Voronoi classes |
| CvtkEmptyVoronoi3DClassifier | |
| CvtkEmptyVoronoi3DCompositor | These are convenience/demonstration classes for configuring the templated 3D Voronoi classes |
| 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 |
| CvtkFollowerTextPropertyAdaptor | VtkFollowerTextPropertyAdaptor is a helper class to mimic vtkTextProperty behavior for a vtkAxisFollower |
| CvtkFourByteUnion | OpenGL vertex buffer object |
| CvtkFreeTypeToolsCleanup | |
| CvtkGarbageCollectorManager | Manages the vtkGarbageCollector singleton |
| CvtkGenericDataArrayLookupHelper< ArrayTypeT > | Internal class used by vtkGenericDataArray to support LookupValue |
| CvtkGenericOpenGLResourceFreeCallback | |
| CvtkOpenGLResourceFreeCallback< T > | |
| CvtkGeometryFilterHelper | |
| CvtkGLSLModifierFactory | This class empowers developers to write and use GLSL mods easily in VTK |
| CvtkGLTFDocumentLoaderInternals | Internal class for vtkGLTFDocumentLoader |
| CvtkGLTFWriterUtils | |
| CvtkGPUInfoListArray | Internal class vtkGPUInfoList |
| Cboost::vtkGraphEdgeMap | |
| Cboost::vtkGraphEdgePropertyMapHelper< PMap > | |
| Cboost::vtkGraphIndexMap | |
| Cboost::vtkGraphPropertyMapMultiplier< PMap > | |
| Cboost::vtkGraphVertexPropertyMapHelper< PMap > | |
| CvtkHashCombiner | Combine 4- and 8-byte integers into a single hash value |
| CvtkHDF5Helper | Helper class used to read hdf5 file format |
| CvtkHDFReaderImplementation | Implementation class for vtkHDFReader |
| CvtkHDFVersion | Version number for legacy readers/writers |
| CvtkHDFWriterImplementation | Implementation class for vtkHDFWriter |
| CvtkHullEdgeTuple | Represent a polyhedral edge intersected by the current clipping plane |
| CvtkHullFace | Represent a face composing the polyhedron |
| CvtkHullPoint | Represent a point/vertex of the Voronoi polyhedron |
| CvtkHyperTreeData | |
| CvtkHyperTreeGridEntry | Entries are cache data for cursors |
| CvtkHyperTreeGridGeometryEntry | GeometryEntry is a cache data for cursors requiring coordinates |
| CvtkHyperTreeGridGeometryImpl | Interface for all vtkHyperTreeGridGeometry internal classes |
| CvtkHyperTreeGridGeometry3DImpl | VtkHyperTreeGridGeometry internal classes for 3D vtkHyperTreeGrid |
| CvtkHyperTreeGridGeometrySmallDimensionsImpl | Common interface for 1D and 2D vtkHyperTreeGridGeometry internal classes |
| CvtkHyperTreeGridGeometry1DImpl | VtkHyperTreeGridGeometry internal classes for 1D vtkHyperTreeGrid |
| CvtkHyperTreeGridGeometry2DImpl | VtkHyperTreeGridGeometry internal classes for 2D vtkHyperTreeGrid |
| CvtkHyperTreeGridGeometryLevelEntry | Cursor cache data with coordinates and level info |
| CvtkHyperTreeGridGeometryUnlimitedEntry | GeometryUnlimitedEntry is a cache data for cursors requiring coordinates |
| CvtkHyperTreeGridGeometryUnlimitedLevelEntry | Cursor cache data with coordinates and level info |
| CvtkHyperTreeGridGhostCellsGeneratorInternals | Internal class for vtkHyperTreeGridGhostCellsGenerator |
| CvtkHyperTreeGrid::vtkHyperTreeGridIterator | An iterator object to iteratively access trees in the grid |
| CvtkHyperTreeGridLevelEntry | LevelEntry is a cache data for cursors requiring level info |
| CvtkHyperTreeGridScales | Dynamic generation of scales for vtkHyperTree |
| 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 |
| CvtkIndexedImplicitBackend< ValueType > | A backend for the vtkImplicitArray framework allowing one to use a subset of a given data array, by providing a vtkIdList or vtkDataArray of indexes as indirection, as another vtkDataArray without any excess memory consumption |
| CvtkInformationInternals | Internal structure for vtkInformation |
| CvtkPlaneCutter::vtkInputInfo | |
| CvtkStructuredDataPlaneCutter::vtkInputInfo | |
| CvtkInterpolationInfo | |
| CvtkInterpolationWeights | |
| CvtkInterpolationMath | Math code for image interpolators |
| CvtkInterpolatorInternals | Internals for vtkImageInterpolator |
| CvtkIntersectionCounter | Fast simple class for dealing with ray intersections |
| CvtkIntervalInformation | |
| CvtkIOSSModel | Internal class used by vtkIOSSWriter |
| CvtkIOSSReaderInternal | Internal methods and state for the IOSS reader |
| CvtkIOSSCellGridReaderInternal | Internal methods for the cell-grid version of the IOSS reader |
| CvtkIOStream | Include C++ iostreams as used by VTK |
| CvtkIOStreamFwd | Forward-declare C++ iostreams as used by VTK |
| CvtkLabeledFormatterInput | Resolved label input for one dataset/graph, produced by vtkLabeledDataMapper::ResolveLabeledFormatterInput and consumed by vtkLabeledFormatterInterface::Dispatch |
| CvtkLabeledFormatterInterface | Base class for label formatters |
| CvtkLabelMapLookup< T > | Provide an efficient numeric label lookup |
| CLabelSet< T > | |
| CLabelVector< T > | |
| CSingleLabelValue< T > | |
| 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 |
| CvtkLegendBoxEntryInternal | A single entry to use inside vtkLegendBoxActor |
| CvtkLICNoiseHelper | A small collection of noise routines for LIC |
| CvtkLICRandomNoise2D | 2D Noise Generator |
| CvtkLICRandomNumberGeneratorInterface | An interface to a random number generator |
| CvtkLocatorInterface | A variety of classes used for high-performance interface to spatial locator classes |
| CvtkLocatorTuple< TTuple > | |
| CvtkLODProp3DEntry_t | |
| CvtkMapMaskTextureId | |
| CvtkMarchingCellsClipCases< InsideOut > | |
| CvtkMarchingCellsClipCasesBase | |
| CvtkMarchingCellsClipCases< false > | |
| CvtkMarchingCellsClipCases< true > | |
| CvtkMarchingCellsContourCases | Lookup tables for marching cells contouring |
| CvtkMarchingCubesPolygonCases | |
| CvtkMathPrivate | Internal toolkit used in some vtkMath methods |
| CvtkMathTextUtilitiesCleanup | |
| CvtkMathUtilities | Templated utility math functions intended for internal use in tests etc |
| CvtkmDataArrayUtilities | Utility functions for working with Viskores device arrays |
| CvtkObjectBase::vtkMemkindRAII | A class to help modify and restore the global UsingMemkind state, like SetUsingMemkind(newValue), but safer |
| CvtkMeshCacheRunner | An RAII class to easily use vtkDataObjectMeshCache |
| CvtkmFilterOverrides | A class with static methods to turn viskores filter overrides on/off at runtime |
| CvtkmInitializer | |
| CvtkMPIPixelTT< T > | |
| CvtkMPIPixelView | MPI datatypes that describe a vtkPixelExtent |
| CvtkMultiBlockPLOT3DReaderInternals | |
| CvtkMultiBlockPLOT3DReaderRecord | |
| CvtkMultiProcessStream | Stream used to pass data across processes using vtkMultiProcessController |
| CvtkMySQLDatabasePrivate | |
| CvtkCellLocator::vtkNeighborCells | |
| CvtkNew< T > | Allocate and hold a VTK object |
| CvtkNumberToString | Convert floating and fixed point numbers to strings |
| CvtkOBBTree | Generate oriented bounding box (OBB) tree |
| CvtkObjectBase | Abstract base class for most VTK objects |
| CvtkCommand | Superclass for callback/observer methods |
| CvtkCallbackCommand | Supports function callbacks |
| CvtkEventForwarderCommand | Simple event forwarder command |
| CvtkJoystickFlyObserver | |
| 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 |
| CExternalVTKWidget | |
| CvtkAMRDataInternals | Container of vtkUniformGrid for an AMR data set |
| CvtkAMRDataSetCache | A concrete implementation of vtkObject that provides functionality for caching AMR blocks |
| CvtkAMRMetaData | Meta data that describes the structure of a generic AMR data set |
| CvtkOverlappingAMRMetaData | Meta data that describes the structure of an overlapping AMR data set |
| CvtkAMRInformation | Meta data that describes the structure of an AMR data seit |
| 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< vtkmDataArray< T >, T, vtkArrayTypes::VTKM_DATA_ARRAY > | |
| CvtkmDataArray< T > | Wraps a Viskores ArrayHandle inside a sub-class of vtkGenericDataArray |
| CvtkGenericDataArray< vtkAOSDataArrayTemplate< ValueTypeT >, ValueTypeT, vtkArrayTypes::VTK_AOS_DATA_ARRAY > | |
| CvtkAOSDataArrayTemplate< ValueTypeT > | Array-Of-Structs implementation of vtkGenericDataArray |
| CvtkGenericDataArray< DerivedT, ValueTypeT, ArrayType > | |
| CvtkGenericDataArray< vtkImplicitArray< BackendT, ArrayType >, typename vtk::detail::implicit_array_traits< BackendT >::rtype, ArrayType > | |
| CvtkGenericDataArray< vtkScaledSOADataArrayTemplate< ValueTypeT >, ValueTypeT, 7 > | |
| CvtkScaledSOADataArrayTemplate< ValueTypeT > | Struct-Of-Arrays implementation of vtkGenericDataArray with a scaling factor |
| CvtkGenericDataArray< vtkSOADataArrayTemplate< ValueTypeT >, ValueTypeT, vtkArrayTypes::VTK_SOA_DATA_ARRAY > | |
| CvtkSOADataArrayTemplate< ValueTypeT > | Struct-Of-Arrays implementation of vtkGenericDataArray |
| CvtkGenericDataArray< vtkTestDataArray< ArrayT >, ValueType > | |
| CvtkGenericDataArray< MockDataArray< ValueT >, ValueT > | |
| CMockDataArray< ValueT > | This class is used in some unit tests to setup a mock data array which derives vtkGenericDataArray |
| CvtkGenericDataArray< vtkPeriodicDataArray< Scalar >, Scalar, 9 > | |
| CvtkPeriodicDataArray< Scalar > | Map native an Array into an angulat periodic array |
| CvtkAngularPeriodicDataArray< Scalar > | Map native an Array into an angulat periodic array |
| CvtkGenericDataArray< vtkImplicitArray< BackendT, vtkArrayTypes::VTK_IMPLICIT_ARRAY >, vtk::detail::implicit_array_traits< BackendT >::rtype, vtkArrayTypes::VTK_IMPLICIT_ARRAY > | |
| CvtkImplicitArray< BackendT, ArrayType > | A read only array class that wraps an implicit function from integers to any value type supported by VTK |
| CvtkAffineArray< vtkTypeInt32 > | |
| CvtkAffineArray< vtkTypeInt64 > | |
| CvtkGenericDataArray< vtkImplicitArray< BackendT, vtkArrayTypes::VTK_IMPLICIT_ARRAY >, vtk::detail::implicit_array_traits< BackendT >::rtype, ArrayType > | |
| CvtkGenericDataArray< vtkTestDataArray< ArrayT >, ArrayT::ValueType > | |
| CvtkTestDataArray< ArrayT > | An implementation of vtkGenericDataArray for testing fallback algorithms |
| CvtkGenericDataArray< vtkTestDataArray< ArrayT >, ArrayT::ValueType, vtkArrayTypes::VTK_DATA_ARRAY > | |
| CvtkGenericDataArray< vtkTestDataArray< ArrayT >, ArrayT::ValueType, ArrayType > | |
| CvtkGenericDataArray< DerivedT, ValueTypeT, vtkArrayTypes::VTK_DATA_ARRAY > | |
| CvtkGenericDataArray< vtkImplicitArray< vtkIndexedImplicitBackend< double >, ArrayType >, vtk::detail::implicit_array_traits< vtkIndexedImplicitBackend< double > >::rtype, ArrayType > | |
| CvtkImplicitArray< vtkIndexedImplicitBackend< double >, vtkArrayTypes::VTK_INDEXED_ARRAY > | |
| CvtkIndexedArray< double > | |
| CvtkGenericDataArray< vtkAOSDataArrayTemplate< Scalar >, Scalar, vtkArrayTypes::VTK_AOS_DATA_ARRAY > | |
| CvtkAOSDataArrayTemplate< Scalar > | |
| CvtkGenericDataArray< vtkAOSDataArrayTemplate< Scalar >, Scalar, ArrayType > | |
| CvtkBitArray | Dynamic, self-adjusting array of bits |
| CvtkGenericDataArray< DerivedT, ValueTypeT, ArrayType > | Base interface for all typed vtkDataArray subclasses |
| CvtkAOSDataArrayTemplate< char > | |
| CvtkCharArray | Dynamic, self-adjusting array of char |
| CvtkAOSDataArrayTemplate< ValueType > | |
| CvtkAOSDataArrayTemplate< double > | |
| CvtkDoubleArray | Dynamic, self-adjusting array of double |
| CvtkAOSDataArrayTemplate< float > | |
| CvtkFloatArray | Dynamic, self-adjusting array of float |
| CvtkAOSDataArrayTemplate< vtkIdType > | |
| CvtkIdTypeArray | Dynamic, self-adjusting array of vtkIdType |
| CvtkAOSDataArrayTemplate< int > | |
| CvtkIntArray | Dynamic, self-adjusting array of int |
| CvtkAOSDataArrayTemplate< long > | |
| CvtkLongArray | Dynamic, self-adjusting array of long |
| CvtkAOSDataArrayTemplate< long long > | |
| CvtkLongLongArray | Dynamic, self-adjusting array of long long |
| CvtkAOSDataArrayTemplate< short > | |
| CvtkShortArray | Dynamic, self-adjusting array of short |
| CvtkAOSDataArrayTemplate< signed char > | |
| CvtkSignedCharArray | Dynamic, self-adjusting array of signed char |
| CvtkAOSDataArrayTemplate< unsigned char > | |
| CvtkUnsignedCharArray | Dynamic, self-adjusting array of unsigned char |
| CvtkAOSDataArrayTemplate< unsigned int > | |
| CvtkUnsignedIntArray | Dynamic, self-adjusting array of unsigned int |
| CvtkAOSDataArrayTemplate< unsigned long > | |
| CvtkUnsignedLongArray | Dynamic, self-adjusting array of unsigned long |
| CvtkAOSDataArrayTemplate< unsigned long long > | |
| CvtkUnsignedLongLongArray | Dynamic, self-adjusting array of unsigned long long |
| CvtkAOSDataArrayTemplate< unsigned short > | |
| CvtkUnsignedShortArray | Dynamic, self-adjusting array of unsigned short |
| CvtkAOSDataArrayTemplate< vtkTypeInt32 > | |
| CvtkAOSDataArrayTemplate< vtkTypeInt64 > | |
| CvtkAOSDataArrayTemplate< vtkFFT::ScalarNumber > | |
| CvtkImplicitArray< vtkAffineImplicitBackend< ValueTypeT >, vtkArrayTypes::VTK_AFFINE_ARRAY > | |
| CvtkAffineArray< ValueTypeT > | A utility array for wrapping affine functions in implicit arrays |
| CvtkImplicitArray< vtkCompositeImplicitBackend< ValueTypeT >, vtkArrayTypes::VTK_COMPOSITE_ARRAY > | |
| CvtkCompositeArray< ValueTypeT > | A utility array for concatenating arrays into an implicit array |
| CvtkImplicitArray< vtkConstantImplicitBackend< ValueTypeT >, vtkArrayTypes::VTK_CONSTANT_ARRAY > | |
| CvtkConstantArray< ValueTypeT > | A utility array for wrapping constant functions in implicit arrays |
| CvtkImplicitArray< BackendT, ArrayType > | |
| CvtkImplicitArray< vtkIndexedImplicitBackend< ValueTypeT >, vtkArrayTypes::VTK_INDEXED_ARRAY > | |
| CvtkIndexedArray< ValueTypeT > | A utility array for creating a wrapper array around an existing array and reindexing its components |
| CvtkImplicitArray< std::function< ValueTypeT(int)>, 15 > | |
| CvtkStdFunctionArray< ValueTypeT > | A utility array for wrapping std::function in implicit arrays |
| CvtkImplicitArray< vtkStridedImplicitBackend< ValueTypeT >, vtkArrayTypes::VTK_STRIDED_ARRAY > | |
| CvtkStridedArray< ValueTypeT > | A utility array for wrapping a strided buffer in implicit arrays |
| CvtkImplicitArray< vtkStructuredPointBackend< ValueTypeT >, vtkArrayTypes::VTK_STRUCTURED_POINT_ARRAY > | |
| CvtkStructuredPointArray< ValueTypeT > | A structured point array used by vtkCartesianGrid subclasses |
| CvtkStringArray | VtkAbstractArray subclass for strings |
| CvtkVariantArray | An array holding vtkVariants |
| CvtkAbstractBuffer | Abstract base class for vtkBuffer providing buffer protocol support |
| CvtkBuffer< ValueT > | |
| CvtkBuffer< ValueType > | |
| CvtkBuffer< vtkIdType > | |
| CvtkBuffer< vtkStdString > | |
| CvtkBuffer< vtkVariant > | |
| CvtkBuffer< ScalarTypeT > | Internal storage class used by vtkSOADataArrayTemplate, vtkAOSDataArrayTemplate, and others |
| CvtkAbstractCellArray | Abstract object to represent cell connectivity |
| CvtkCellArray | Object to represent cell connectivity |
| CvtkStructuredCellArray | Implicit object to represent cell connectivity |
| 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 |
| CvtkHardwarePicker | Pick a point or snap to point of an actor/prop using graphics hardware |
| 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 |
| CvtkZSpaceHardwarePicker | Pick an actor/prop given the stylus 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 |
| CvtkAnariVolumeInterface | Removes link dependence on optional ANARI module |
| CvtkAnariVolumeMapper | Standalone ANARI VolumeMapper |
| 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 |
| CvtkArrayRenderer | Render instanced elements textured with arrays from input data |
| CvtkCellGridMapper | Map a vtkCellGrid to graphics primitives |
| CvtkOpenGLCellGridMapper | CellGrid mapper using OpenGL to render exotic finite element fields and cells |
| CvtkCompositeCellGridMapper | Class that renders hierarchical cell-grid data |
| CvtkDataSetMapper | Map vtkDataSet and derived classes to graphics primitives |
| CvtkGlyph3DMapper | VtkGlyph3D on the GPU |
| CvtkOpenGLGlyph3DMapper | VtkOpenGLGlyph3D on the GPU |
| CvtkWebGPUGlyph3DMapper | Generate 3D glyphs at points in input dataset using webgpu |
| CvtkGraphMapper | Map vtkGraph and derived classes to graphics primitives |
| CvtkHyperTreeGridMapper | Map vtkHyperTreeGrid to graphics primitives |
| CvtkOpenGLHyperTreeGridMapper | Map vtkHyperTreeGrid 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 |
| CvtkCompositePolyDataMapper | Class that renders hierarchical polygonal data |
| CvtkCompositeSurfaceLICMapper | Mapper for composite dataset |
| CvtkHierarchicalPolyDataMapper | Class that renders hierarchical polygonal data |
| CvtkOpenGLLowMemoryPolyDataMapper | PolyDataMapper using OpenGL to render surface meshes |
| CvtkOpenGLPolyDataMapper | PolyDataMapper using OpenGL to render |
| CvtkFastLabeledDataMapper | Draw text labels at dataset points |
| CvtkOpenGLBatchedLabeledDataMapperInternals | |
| CvtkOpenGLBatchedPolyDataMapper | An OpenGL mapper for batched rendering of vtkPolyData |
| CvtkBatchedSurfaceLICMapper | Implements batched rendering of multiple vtkPolyData using LIC interface and OpenGL |
| CvtkOpenGLGlyph3DHelper | PolyDataMapper using OpenGL to render |
| CvtkOpenGLPointGaussianMapperHelper | |
| CvtkOpenGLSphereMapper | Draw spheres using imposters |
| CvtkOpenGLStickMapper | Use imposters to draw cylinders |
| CvtkOpenGLSurfaceProbeVolumeMapper | PolyDataMapper colored with probed volume data |
| CvtkSurfaceLICMapper | Mapper that performs LIC on the surface of arbitrary geometry |
| CvtkPointGaussianMapper | Draw PointGaussians using imposters |
| CvtkOpenGLPointGaussianMapper | Draw PointGaussians using imposters |
| CvtkWebGPUComputePointCloudMapper | The point cloud renderer uses WebGPU compute shaders to render the point cells of a polydata onto the framebuffer of a given WebGPURenderer |
| CvtkWebGPUPolyDataMapper | |
| CvtkWebGPUBatchedLabeledDataMapperInternals | |
| CvtkWebGPUBatchedPolyDataMapper | A WebGPU mapper for batched rendering of vtkPolyData |
| CvtkMapper2D | Abstract class specifies interface for objects which render 2D actors |
| CvtkImageMapper | 2D image display |
| CvtkOpenGLImageMapper | 2D image display support for OpenGL |
| CvtkWebGPUImageMapper | 2D image display using webgpu |
| CvtkLabelPlacementMapper | Places and renders non-overlapping labels |
| CvtkLabeledDataMapper | Draw text labels at dataset points |
| CvtkBatchedLabeledDataMapper | Draw text labels at dataset points using batch rendering |
| CvtkOpenGLBatchedLabeledDataMapper | OpenGL backend for vtkBatchedLabeledDataMapper |
| CvtkWebGPUBatchedLabeledDataMapper | WebGPU backend for vtkBatchedLabeledDataMapper |
| 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 |
| CvtkOpenGLES30PolyDataMapper2D | 2D PolyData support for OpenGL ES 3.0 |
| CvtkWebGPUPolyDataMapper2D | 2D PolyData support for WebGPU |
| 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 |
| CvtkCellGridAlgorithm | Superclass for algorithms that produce only polydata as output |
| CvtkCellGridCellCenters | Output a vertex cell at the center of each input cell |
| CvtkCellGridCellSource | Create a cell-grid with one or more cells of the requested type |
| CvtkCellGridComputeSides | Generate sides of input data (cells and/or sides) based on a strategy |
| CvtkCellGridElevation | Adds a cell attribute representing elevation |
| CvtkCellGridReader | Read a cell-grid file |
| CvtkCellGridTransform | Transform points and associated normals and vectors |
| CvtkCellGridWarp | Create a deformed copy of the input |
| 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 |
| CvtkAxisAlignedReflectionFilter | Reflects the input over an axis-aligned plane |
| CvtkPAxisAlignedReflectionFilter | Distributed version of vtkAxisAlignedReflectionFilter |
| 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) |
| CvtkAxisAlignedTransformFilter | Applies an axis-aligned affine transformation (translation, scaling, and rotation) |
| CvtkConduitSource | Data source for Conduit Mesh Blueprint |
| 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 |
| CvtkEndFor | VtkEndFor define the end of the sub-pipeline to loop |
| CvtkExtractSelection | Extract a subset from a vtkDataSet |
| CvtkExtractSelectionBase | Abstract base class for all extract selection filters |
| CvtkExtractSelectedFrustum | Returns the portion of the input dataset that lies within a selection frustum |
| CvtkProbeSelectedLocations | Similar to vtkExtractSelection 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 |
| CvtkForEach | Algorithm allowing to implement a for loop using the VTK pipeline and a sister filter vtkEndFor |
| CvtkGenerateIndexArray | Generates a new vtkIdTypeArray containing zero-base indices |
| CvtkGeometryFilterDispatcher | Geometry filter that does outlines for volumes |
| CvtkGroupDataSetsFilter | Groups inputs into a chosen composite dataset |
| CvtkGroupTimeStepsFilter | Converts a temporal dataset into non-temporal dataset |
| CvtkHDFReader | Read VTK HDF files |
| CvtkImageDataToUniformGrid | Convert vtkImageData to vtkUniformGrid |
| CvtkLagrangianParticleTracker | Filter to inject and track particles in a flow |
| CvtkPLagrangianParticleTracker | Parallel Lagrangian particle tracker |
| CvtkMergeBlocks | Merges blocks in a composite dataset to a dataset |
| 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 |
| CvtkRedistributeDataSetToSubCommFilter | Redistributes input dataset to specific mpi ranks |
| 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 |
| CvtkAttributeSmoothingFilter | Smooth mesh point attribute data using distance weighted Laplacian kernel |
| 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 |
| CvtkmAverageToPoints | Accelerated point to cell interpolation filter |
| 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 |
| CvtkExtractParticlesOverTime | Extract particles that goes through a given volumic data set |
| 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 |
| CvtkGenerateProcessIds | Sets ProcessIds attribute for PointData and/or CellData |
| CvtkGenericProbeFilter | Sample data values at specified point locations |
| CvtkGradientFilter | A general filter for gradient estimation |
| CvtkmGradient | A general filter for gradient estimation |
| CvtkHyperTreeGridProbeFilter | Probe a vtkHyperTreeGrid |
| CvtkPHyperTreeGridProbeFilter | Probe a vtkHyperTreeGrid in parallel |
| 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 |
| CvtkPackLabels | Renumber segmentation labels into contiguous runs of (potentially) smaller type |
| CvtkPieceScalars | Sets all cell scalars from the update piece |
| CvtkPointConnectivityFilter | Output a scalar field indicating point connectivity |
| CvtkPointDataToCellData | Map point data to cell data |
| CvtkmAverageToCells | |
| 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 distributed parallel computation |
| CvtkProbePolyhedron | Probe/interpolate data values in the interior, exterior or of the surface of a closed, manifold polyhedron |
| 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 vtkDataSet on its input to a specific set of quadrature points |
| CvtkQuadraturePointsGenerator | Create a vtkPolyData on its output containing the vertices for the quadrature points for one of the vtkDataArrays present on its input vtkUnstructuredGrid |
| 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 |
| CvtkSpatioTemporalHarmonicsAttribute | Computes spatio-temporal harmonics on each point |
| CvtkSplitField | Split a field into single component fields |
| CvtkTensorPrincipalInvariants | Compute principal values and directions from symmetric tensor |
| 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 |
| CvtkThresholdScalars | Label scalars according to one or more threshold intervals |
| 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 |
| CvtkVoronoiFlower3D | Create a 3D Voronoi tessellation of input points |
| CvtkYieldCriteria | Compute principal stress and yield criteria from symmetric tensor |
| CvtkmHistogramSampling | 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 |
| CvtkHyperTreeGridAlgorithm | Superclass for algorithms that produce a hyper tree grid as output |
| CHDFTestUtilities::vtkHTGChangingDescriptorSource | Custom source to generate time-dependent HTG |
| 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 |
| CvtkHyperTreeGridExtractGhostCells | Extract ghost cells from the input HTG and untag them as ghost |
| CvtkHyperTreeGridFeatureEdges | Generates feature edges from an Hyper Tree Grid |
| CvtkHyperTreeGridGenerateFields | Generate cell fields for a HTG |
| CvtkHyperTreeGridGeometry | Generate vtkHyperTreeGrid external surface |
| CvtkHyperTreeGridGhostCellsGenerator | Generate ghost cells for distributed vtkHyperTreeGrids |
| CvtkHyperTreeGridGradient | Compute the gradient of a scalar field on a Hyper Tree Grid |
| CvtkHyperTreeGridOutlineFilter | Create wireframe outline for arbitrary data set |
| CvtkHyperTreeGridPlaneCutter | Cut an hyper tree grid volume with a plane and generate a polygonal cut surface |
| CvtkHyperTreeGridPreConfiguredSource | Helper class for generating a curated set of HyperTree Grids (HTGs) for testing purposes |
| CvtkHyperTreeGridRemoveGhostCells | Remove ghost cells and ghost array from the input HTG |
| 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 |
| CvtkSpatioTemporalHarmonicsSource | Creates a vtkImageData with harmonics data |
| 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 |
| CvtkWebGPUTexture | VtkWebGPUTexture is a concrete implementation of the abstract class vtkTexture for WebGPU |
| 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 |
| CvtkImageBinaryThreshold | VtkImageBinaryThreshold is an image thresholding algorithm that allows users to replace pixel data by comparing them with 2 thresholds |
| 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 |
| CvtkImageRGBToXYZ | Converts XYZ components to LAB |
| 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 |
| CvtkImageSSIM | This filter implements an algorithm based on SSIM for image comparison |
| 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) |
| CvtkImageXYZToLAB | Converts XYZ components to LAB |
| 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 |
| 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, cells or faces |
| 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 vtkUnstructuredGrids |
| CvtkCesiumB3DMReader | Read a CesiumB3DM file |
| CvtkCityGMLReader | Read CityGML data file |
| CvtkConvertToMultiBlockDataSet | Converts any data type into a vtkMultiBlockDataSet |
| 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 |
| CvtkFLUENTCFFReader | Reads a dataset in Fluent CFF file format |
| 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 |
| CvtkLANLX3DReader | Class for reading LANL X3D format 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 |
| CvtkMultiBlockMergeFilter | Merges multiblock inputs into a single multiblock output |
| CvtkMultiThreshold | Threshold cells within multiple intervals |
| CvtkOCCTReader | VTK Reader for STEP and IGES files using OpenCASCADE |
| 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 |
| CvtkAMRContourFilter | A contour filter for vtkOverlappingAMR data |
| CvtkAMRInterfaceFilter | A contour filter for vtkOverlappingAMR data |
| CvtkBTSReader | Class to read bts files used by Engys software |
| CvtkPartitionBalancer | Balances input partitioned data sets so each rank has the same number of data sets |
| CvtkPartitionedDataSetSource | Source that produces a vtkPartitionedDataSet |
| CvtkPointSetToOctreeImageFilter | Convert a point set to an octree image |
| CvtkPartitionedDataSetCollectionAlgorithm | Superclass for algorithms that produce vtkPartitionedDataSetCollectionAlgorithm |
| CvtkAppendPartitionedDataSetCollection | Append partitioned dataset collections |
| CvtkAvmeshReader | Read an AVMESH file |
| CvtkCONVERGECFDCGNSReader | Reader for CONVERGECFD CGNS post files |
| CvtkCONVERGECFDReader | Reader for CONVERGE CFD post files |
| CvtkCesium3DTilesReader | Reads a Cesium 3D Tiles tileset |
| CvtkConvertToPartitionedDataSetCollection | Convert any dataset to vtkPartitionedDataSetCollection |
| CvtkERFReader | Read ERF-HDF5 files |
| CvtkEnSightGoldCombinedReader | |
| CvtkEnSightSOSGoldReader | Reader for EnSight SOS gold files |
| CvtkExplodeDataSet | Explode input dataset according to a cell scalar isovalue criteria |
| CvtkExtractStatisticalModelTables | Extract all tables from statistical models |
| CvtkFDSReader | A reader for the Fire Dynamics Simulator (FDS) output data |
| CvtkFiniteElementFieldDistributor | |
| CvtkGenerateStatistics | Statistical modeling of non-tabular data adapted from VTK geometric datasets |
| CvtkIFCReader | Reads an IFC file using IFcOpenShell library |
| CvtkOpenVDBReader | OpenVDB reader Reader for OpenVDB files |
| CvtkPartitionedDataSetCollectionSource | Source that produces a vtkPartitionedDataSetCollection |
| CvtkStaticCompositeSource | Simple source that create a composite (PartitionedDataSetCollection) of 2 polydata |
| CvtkSurfaceNetsAtlas | Query-driven extraction of regions and patches from any SurfaceNets filter output |
| CvtkUnstructuredGridToCellGrid | Create a cell-grid that approximates a collection of vtkUnstructuredGrids |
| 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 |
| CvtkAlignImageDataSetFilter | Align collection of image datasets to use a global origin |
| 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 |
| CvtkArrayRename | Rename 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 |
| CvtkBlockIdScalars | Generates scalars from blocks |
| CvtkCellSizeFilter | Computes cell sizes |
| CvtkPCellSizeFilter | Computes cell sizes in parallel |
| CvtkCleanArrays | Filter used to remove partial arrays across processes |
| CvtkConsumerDataFilter | Simple filter that will be our cache consumer |
| 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 |
| CvtkCriticalTime | Compute time step at which a threshold value has been reached |
| 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 |
| CvtkFieldDataToDataSetAttribute | Map field data to other attribute data |
| CvtkForceTime | |
| CvtkGenerateGlobalIds | Generates global point and cell ids |
| CvtkGenerateIds | Generate scalars or field data from point and cell ids |
| CvtkGenerateTimeSteps | Generate timesteps on any input |
| CvtkGhostCellsGenerator | Computes ghost cells on vtkCompositeDataSet inputs |
| CvtkStitchImageDataWithGhosts | Stitches vtkImageData that are one voxel away |
| CvtkHilbertCurveSorter | Sort point coordinates using Hilbert-curve |
| CvtkHyperTreeGridGenerateGlobalIds | Generate global IDs of input HyperTee Grid(s) |
| CvtkHyperTreeGridGenerateProcessIds | Sets ProcessIds attribute for CellData |
| CvtkHyperTreeGridRedistribute | Redistribute input HyperTreeGrid into requested number of partitions |
| 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 |
| CvtkONNXInference | Infer an ONNX model |
| CvtkOverlappingCellsDetector | Exposes how many cells each cell of the input collide |
| CvtkPassThrough | Pass input input data through to the output |
| CvtkForceStaticMesh | Takes in input as a cache the first time it is executed then use it as a static mesh |
| 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 |
| CvtkTemporalSmoothing | Smooth point or cell data over a sliding time window |
| CvtkTemporalSnapToTimeStep | Modify the time range/steps of temporal data |
| CvtkTemporalStatistics | Compute statistics of point or cell data as it changes over time |
| CvtkToImplicitArrayFilter | A VTK filter for compressing explicit memory arrays into implicit arrays |
| 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 process vtkPointSet 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 |
| CvtkConstrainedSmoothingFilter | Adjust point positions using constrained smoothing |
| CvtkConvexHull | Convex hull and point-in-hull testing for 1-D, 2-D, and 3-D point sets |
| 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 |
| CvtkHull | Produce an n-sided convex hull |
| CvtkJogglePoints | Randomly perturb (or jitter) point positions |
| CvtkPointSmoothingFilter | Adjust point positions to form a pleasing, packed arrangement |
| CvtkPointsMatchingTransformFilter | Affine transform a vtkPointSet based on 4 pairs of points |
| CvtkPoissonDiskSampler | Generate point normals using local tangent planes |
| CvtkProjectPointsToPlane | Project all input points to a plane |
| 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 viskores 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 |
| CvtkOFFReader | Read Geomview .off 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 |
| CvtkBoundaryMeshQuality | Computes metrics on the boundary faces of a mesh |
| 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 |
| CvtkCellCenters | Generate points at center of cells |
| CvtkHyperTreeGridCellCenters | Generate points at center of hyper tree grid leaf cell centers |
| CvtkCellGridPointProbe | Probe a vtkCellGrid with points |
| 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 |
| 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 functionality 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 |
| CvtkmSlice | Generate |
| CvtkCylinderSource | Generate a polygonal cylinder centered at the origin |
| CvtkDataSetSurfaceFilter | Extracts outer surface (as vtkPolyData) of any dataset |
| CvtkDataSetRegionSurfaceFilter | Extract surface of materials |
| CvtkDecimatePolylineFilter | Reduce the number of lines in a polyline |
| 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 dataset |
| 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 |
| 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 |
| CvtkFeatureEdgesDispatcher | Feature Edges filter that delegates to type specific implementations |
| 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 |
| CvtkFillPointCloud | Add points to empty regions in an input point cloud |
| 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 |
| CvtkGeneralizedSurfaceNets3D | Create a surface net from an unorganized set of segmented (i.e., labeled) points |
| CvtkGenerateRegionIds | Generate cell array containing the region id |
| 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 |
| 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 |
| CvtkLabeledImagePointSampler | Produce sampled points from a segmented image |
| 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 |
| CvtkLissajousPointCloud | Create a set of points distributed within a tube centered on a Lissajous curve |
| 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 | |
| CvtkOctreeImageToPointSetFilter | Convert an octree image to point set |
| CvtkOrientPolyData | Auto detect correct normal orientation and/or enforce consistent polygon ordering |
| 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 |
| 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 |
| CvtkPointSetStreamer | Stream points as buckets |
| 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 |
| CvtkPolyDataPlaneCutter | Threaded (high-performance) cutting of a vtkPolyData with a plane |
| 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 |
| CvtkQuadricClustering | Reduce the number of triangles in a mesh |
| CvtkQuadricDecimation | Reduce the number of triangles in a mesh |
| CvtkRecoverGeometryWireframe | Get corrected wireframe from tessellated facets |
| 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 |
| CvtkSplitSharpEdgesPolyData | Split sharp edges in a polygonal mesh |
| CvtkStaticCleanPolyData | Merge duplicate points, and/or remove unused points and/or remove degenerate cells |
| CvtkStaticDataSource | Simple source that create a polydata (triangle) with point data arrays: |
| CvtkStreamTracer | Streamline generator |
| CvtkPStreamTracer | Parallel streamline generators |
| CvtkStreamSurface | Advect a stream surface in a vector field |
| CvtkStripper | Create triangle strips and/or poly-lines |
| CvtkStructuredDataPlaneCutter | Fast plane cutting of vtkImageData/vtkRectilinearGrid/vtkStructuredGrid |
| 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 |
| CvtkSurfaceNets2D | Generate smoothed constours from segmented 2D image data (i.e., "label maps") |
| CvtkSurfaceNets3D | Generate smoothed isocontours from segmented 3D image data (i.e., "label maps") |
| 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 |
| CvtkPTemporalPathLineFilter | Parallel version of vtkTemporalPathLineFilter |
| CvtkTensorGlyph | Scale and orient glyph(s) according to eigenvalues and eigenvectors of symmetrical part of tensor |
| 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 |
| CvtkVoronoiFlower2D | 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 |
| CvtkCompositeCellGridReader | Read a cell-grid file |
| CvtkIOSSReader | Reader for IOSS (Sierra IO System) |
| CvtkIOSSCellGridReader | Reader for IOSS (Sierra IO System) that produces cell-grid data |
| 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 |
| CvtkLegacyCellGridReader | Read vtk unstructured grid data file |
| CvtkLegacyStatisticalModelReader | Read vtk unstructured grid 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 |
| 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 |
| CHDFTestUtilities::vtkTemporalTableSource | Custom source to generate time-dependent vtkTable |
| 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 |
| CvtkAttributeDataToTableFilter | This filter produces a vtkTable from the chosen attribute in the input data object |
| 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 |
| CvtkComputeQuantiles | Extract Ntiles and extremum values of all columns of a table or all fields of a dataset |
| CvtkComputeQuartiles | Extract quartiles and extremum values of all columns of a table or all fields of a dataset |
| CvtkPComputeQuartiles | A class for parallel univariate order statistics |
| CvtkPComputeQuantiles | A class for parallel univariate order statistics |
| 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 |
| CvtkExtractHistogram | Extract histogram data (binned values) from any dataset |
| CvtkExtractSelectedRows | Return selected rows of a table |
| CvtkFixedWidthTextReader | Reader for pulling in text files with fixed-width fields |
| CvtkISIReader | Reader for ISI files |
| CvtkJoinTables | SQL-style Join operation on two tables |
| CvtkLengthDistribution | Sample the distribution of representative "cell lengths" of a mesh |
| 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 |
| CvtkVisualStatistics | A class to provide normality estimation and binned histogram data to render |
| 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 |
| CvtkSumTables | Matrix-like summation of tables |
| 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 |
| CvtkCellGridToUnstructuredGrid | Create an unstructured grid that approximates a cell-grid |
| CvtkCellTypeSource | Create cells of a given type |
| CvtkChacoReader | Read a Chaco file and create a vtkUnstructuredGrid |
| CvtkPChacoReader | Read Chaco files |
| CvtkCleanUnstructuredGrid | Merge duplicate points |
| CvtkCleanUnstructuredGridCells | Remove duplicate/degenerate cells |
| 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 |
| CvtkConvertToPolyhedra | Convert 3D linear cells to vtkPolyhedra |
| 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 |
| CvtkExtractCellsAlongPolyLine | Extracts input cells that are intersected by a list of input lines or poly lines |
| 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 |
| CvtkGoldenBallSource | Create a faceted approximation to a ball (i.e., a solid sphere) |
| 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 |
| CvtkNek5000Reader | Reads Nek5000 format data files |
| CvtkNetCDFCAMReader | Read unstructured NetCDF CAM files |
| CvtkNetCDFUGRIDReader | Read unstructured NetCDF UGRID files |
| CvtkPolyDataToUnstructuredGrid | Filter which converts a polydata to unstructured grid |
| 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 |
| CvtkStaticCleanUnstructuredGrid | Merge duplicate points, removed unused points, in an vtkUnstructuredGrid |
| 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 |
| CvtkmClip | Clip a dataset using the accelerated viskores Clip filter |
| 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 | |
| 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 |
| 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 |
| CvtkCellGridWriter | Write a cell-grid file |
| CvtkCesium3DTilesWriter | Writes a dataset into 3D Tiles format |
| CvtkCesiumPointCloudWriter | Export a vtkPointSet into a Cesium Point Cloud (PNTS) tile format |
| 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 |
| CvtkLegacyCellGridWriter | Write VTK cell-grid data to a file |
| CvtkLegacyStatisticalModelWriter | Write a statistical model 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 |
| CvtkFidesWriter | Write ADIOS2 streams using Fides data model |
| CvtkGLTFWriter | Export a scene into GLTF 2.0 format |
| CvtkGeoJSONWriter | Convert vtkPolyData to Geo JSON format |
| CvtkHDFWriter | Write a data object to a VTKHDF file |
| CvtkHoudiniPolyDataWriter | Write vtk polygonal data to Houdini file |
| CvtkIOSSWriter | Writer for IOSS (Sierra IO System) |
| 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 |
| CvtkNanoVDBWriter | NanoVDB writer for vtkImageData |
| CvtkNetCDFCFWriter | Writes netCDF files that follow the CF convention |
| 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 |
| CvtkXMLPartitionedDataSetCollectionReader | Reader for partitioned dataset collections |
| CvtkXMLUniformGridAMRReader | Reader for amr datasets (vtkOverlappingAMR or vtkNonOverlappingAMR) |
| CvtkXMLPartitionedDataSetReader | Reader for partitioned datasets |
| 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 |
| CvtkXMLStatisticalModelReader | Read VTK XML StatisticalModel (.vtstat) 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 vtkMultiBlockDataSet |
| CvtkXMLUniformGridAMRWriter | Writer for vtkUniformGridAMR |
| CvtkXMLPUniformGridAMRWriter | Parallel writer for vtkUniformGridAMR and subclasses |
| 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 |
| CvtkXMLStatisticalModelWriter | Write VTK XML Table 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 |
| CvtkmExternalFaces | Generate External Faces of a DataSet |
| CvtkAlgorithmOutput | Proxy object to connect input/output ports |
| CvtkAmoebaMinimizer | Nonlinear optimization with a simplex |
| CvtkAnariDevice | Base class to objects which create + manage a ANARI library + device |
| CvtkAnariRenderer | Base class to objects which create + manage an ANARI library, device, and renderer |
| 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 |
| CvtkByteSwap | Perform machine dependent byte swapping |
| CvtkCPExodusIIElementBlockImpl | |
| CvtkCamera | Virtual camera for 3D rendering |
| CvtkOpenGLCamera | OpenGL camera |
| CvtkExternalOpenGLCamera | OpenGL camera |
| CvtkVRCamera | VR camera |
| CvtkVRHMDCamera | A superclass for HMD style cameras |
| CvtkOpenVRCamera | OpenVR camera |
| CvtkOpenXRCamera | OpenXR camera |
| CvtkWebXRCamera | WebXR camera |
| CvtkZSpaceCamera | Extends vtkOpenGLCamera to use custom view and projection matrix given by zSpace SDK |
| CvtkWebGPUCamera | |
| CvtkCameraInterpolator | Interpolate a series of cameras to update a new camera |
| CvtkCameraManipulator | Abstraction of style away from button |
| CvtkJoystickFly | Fly camera towards or away from the object |
| CvtkJoystickFlyIn | Rotates camera with xy mouse movement |
| CvtkJoystickFlyOut | Rotates camera with xy mouse movement |
| CvtkTableTopRotate | Rotates camera with xy mouse movement |
| CvtkTrackballEnvironmentRotate | Rotates the environment with xy mouse movement |
| CvtkTrackballMoveActor | Moves an actor |
| CvtkTrackballMultiRotate | This camera manipulator combines the vtkTrackballRotate and vtkTrackballRoll manipulators in one |
| CvtkTrackballPan | Pans camera with x y mouse movements |
| CvtkTrackballRoll | Rolls camera around a point |
| CvtkTrackballRotate | Rotates camera with xy mouse movement |
| CvtkTrackballZoom | Zooms camera with vertical mouse movement |
| CvtkTrackballZoomToMouse | Zooms camera with vertical mouse movement to mouse position |
| 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 | A 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, 19-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 |
| CvtkCellArrayIterator | Encapsulate traversal logic for vtkCellArray |
| CvtkCellAttribute | A function defined over the physical domain of a vtkCellGrid |
| CvtkCellAttributeCalculator | Perform a per-cell calculation on a vtkCellAttribute |
| CvtkCellAttributeInformation | Provide information about a cell attribute's basis functions on one cell type |
| CvtkDGAttributeInformation | Provide information about a cell attribute's basis functions on one cell type |
| CvtkInterpolateCalculator | Calculate field values at a point in a cell's parametric space |
| CvtkDGInterpolateCalculator | Calculate field values at a point in a cell's parametric space |
| CvtkCellGraphicsPrimitiveMap | Maps cell connectivity and offsets from VTK data model into primitives that graphics libraries expect (points, lines and triangles) |
| CvtkCellGridQuery | Perform an operation on cells in a vtkCellMetadata instance |
| CvtkCellGridBoundsQuery | Compute the geometric bounds of a cell-grid |
| CvtkCellGridCellCenters::Query | A query corresponding to this algorithm |
| CvtkCellGridCellSource::Query | A cell-grid query used by this filter |
| CvtkCellGridCopyQuery | Copy the cell metadata and attribute(s) of one cell-grid into another |
| CvtkCellGridElevationQuery | A cell-grid query for creating an "elevation" field |
| CvtkCellGridEvaluator | Evaluate a field (vtkCellAttribute) at some points inside cells |
| CvtkCellGridIOQuery | Serialize/deserialize vtkCellMetadata records |
| CvtkCellGridRangeQuery | Compute the range of a component of some vtkCellAttribute |
| CvtkCellGridRenderRequest | State used by vtkCellGridMapper during rendering |
| CvtkCellGridSampleQuery | Output a table of samples at zero or more points inside each cell |
| CvtkCellGridSidesQuery | A cell-grid query for enumerating sides of cells |
| CvtkCellGridSummaryInformationQuery | Compute summary information for a vtkCellGrid in a single pass |
| CvtkCellGridToUnstructuredGrid::Query | A query corresponding to this algorithm |
| CvtkCellGridTransform::Query | A cell-grid query for applying a transform to a cell-grid |
| CvtkCellGridWarp::Query | Cell-grid query used to apply deformations to an input shape attribute |
| CvtkUnstructuredGridToCellGrid::TranscribeQuery | An internal query object for transcribing cells from input to output |
| CvtkCellGridResponderBase | Respond to a query on one particular type of cell |
| CvtkCellGridResponder< vtkCellGridBoundsQuery > | |
| CvtkDGBoundsResponder | Respond to a query on one particular type of cell |
| CvtkCellGridResponder< vtkCellGridCellCenters::Query > | |
| CvtkDGCellCenterResponder | Respond to a query on one particular type of cell |
| CvtkCellGridResponder< vtkCellGridCellSource::Query > | |
| CvtkDGCellSourceResponder | Respond to a query on one particular type of cell |
| CvtkCellGridResponder< vtkCellGridCopyQuery > | |
| CvtkDGCopyResponder | Copy data from one vtkCellGrid to another |
| CvtkCellGridResponder< vtkCellGridElevationQuery > | |
| CvtkDGElevationResponder | Respond to a query on one particular type of cell |
| CvtkCellGridResponder< vtkCellGridEvaluator > | |
| CvtkDGEvaluator | Classify world points, evaluate cell parameters, and interpolate attributes |
| CvtkCellGridResponder< vtkCellGridRangeQuery > | |
| CvtkDGRangeResponder | Compute the range of a cell-attribute over any vtkDGCell |
| CvtkCellGridResponder< vtkCellGridSidesQuery > | |
| CvtkDGSidesResponder | Compute the sides on the outside surface of a collection of DG cells |
| CvtkCellGridResponder< vtkCellGridSummaryInformationQuery > | |
| CvtkDGSummaryInformationResponder | Respond to vtkCellGridSummaryInformationQuery for vtkDGCell types |
| CvtkCellGridResponder< vtkCellGridToUnstructuredGrid::Query > | |
| CvtkDGTranscribeCellGridCells | Respond to a query on one particular type of cell |
| CvtkCellGridResponder< vtkUnstructuredGridToCellGrid::TranscribeQuery > | |
| CvtkDGTranscribeUnstructuredCells | Transcribe unstructured-grid cells as vtkDGCell subclasses |
| CvtkCellGridResponder< vtkCellGridTransform::Query > | |
| CvtkDGTransformResponder | Apply a transform to an attribute of a vtkDGCell |
| CvtkCellGridResponder< vtkCellGridWarp::Query > | |
| CvtkDGWarp | Respond to a "warp" query on one particular type of cell |
| CvtkCellGridResponder< vtkCellGridIOQuery > | |
| CvtkDGIOResponder | Read/write metadata specific to discontinuous Galerkin cells |
| CvtkCellGridResponder< vtkCellGridRenderRequest > | |
| CvtkDGRenderResponder | Rendering simple DG cells (i.e., those with a fixed reference shape) |
| CvtkCellGridResponder< QueryClass > | Respond to a query on one particular type of cell |
| CvtkCellGridResponders | A container that holds objects able to respond to queries specialized for particular vtkCellMetadata types |
| CvtkCellGridSidesCache | Hold a map from hash-ids (representing sides of cells of multiple types) to details on the cells that claim the corresponding side |
| CvtkCellIterator | Efficient cell iterator for vtkDataSet topologies |
| CvtkMappedUnstructuredGridCellIterator< ImplementationType > | |
| 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 |
| CvtkCellMetadata | Metadata for a particular type of cell (finite element) |
| CvtkDGCell | Base class for a discontinuous Galerkin cells of all shapes |
| CvtkDGEdge | Metadata for a discontinuous Galerkin triangle |
| CvtkDGPyr | Metadata for a discontinuous Galerkin pyramid |
| CvtkDGVert | Metadata for a discontinuous Galerkin vertex |
| CvtkDeRhamCell | Base class for cells that form 2-d or 3-d DeRham complexes |
| CvtkDGHex | Metadata for a discontinuous Galerkin hexahedron |
| CvtkDGQuad | Metadata for a discontinuous Galerkin quadrilateral |
| CvtkDGTet | Metadata for a discontinuous Galerkin tetrahedron |
| CvtkDGTri | Metadata for a discontinuous Galerkin triangle |
| CvtkDGWdg | Metadata for a discontinuous Galerkin wedge |
| CvtkCellTypeUtilities | VtkCellTypeUtilities is a collection of methods for cell type lookup |
| 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 |
| CvtkUniformGridAMRIterator | Specialized vtkDataObjectTreeIterator for AMR |
| CvtkUniformGridAMRDataIterator | Deprecated AMR iterator |
| CvtkCompositePolyDataMapperDelegator | Delegates rendering of multiple polydata that share similar signatures |
| CvtkOpenGLCompositePolyDataMapperDelegator | An OpenGL delegator for batched rendering of multiple polydata with similar structure |
| CvtkCompositeSurfaceLICMapperDelegator | Delegates rendering to vtkBatchedSurfaceLICMapper |
| CvtkWebGPUCompositePolyDataMapperDelegator | An OpenGL delegator for batched rendering of multiple polydata with similar structure |
| CvtkCompositer | Super class for composite algorithms |
| CvtkCompressCompositer | Implements compressed tree based compositing |
| CvtkTreeCompositer | Implements tree based compositing |
| CvtkConduitArrayUtilities | Helper to convert Conduit arrays to VTK arrays |
| CvtkConduitArrayUtilitiesDevice | Helper to convert Conduit arrays stored on acceleration devices to Viskores arrays |
| 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 |
| CvtkCuller | Superclass for prop cullers |
| CvtkFrustumCoverageCuller | Cull props based on frustum coverage |
| CvtkWebGPUComputeFrustumCuller | This culler culls props to the camera view frustum using WebGPU compute shaders |
| CvtkWebGPUComputeOcclusionCuller | This culler does both frustum culling and occlusion culling |
| 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, etc |
| 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 |
| CvtkDataEncoder | Class used to compress/encode images using threads |
| CvtkDataObject | General representation of visualization data |
| CvtkAbstractElectronicData | Provides access to and storage of chemical electronic data |
| CvtkOpenQubeElectronicData | Provides access to and storage of electronic data calculated by OpenQube |
| CvtkProgrammableElectronicData | Provides access to and storage of user-generated vtkImageData that describes electrons |
| CvtkAnnotation | Stores a collection of annotation artifacts |
| CvtkAnnotationLayers | Stores a ordered collection of annotation sets |
| CvtkArrayData | Pipeline data object that contains multiple vtkArray objects |
| CvtkBSPCuts | This class represents an axis-aligned Binary Spatial Partitioning of a 3D space |
| CvtkCellGrid | Visualization data composed of cells of arbitrary type |
| 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 |
| CvtkAMRDataObject | Multi-resolution dataset based on vtkCartesianGrid |
| CvtkUniformGridAMR | Legacy, empty shell inheriting vtkAMRDataObject |
| CvtkNonOverlappingAMR | A concrete instance of vtkAMRDataObject to store uniform grids at different levels of resolution that do not overlap with each other |
| CvtkOverlappingAMR | Multi-resolution dataset based on vtkCartesianGrid allowing overlaps |
| CvtkDataSet | Abstract class to specify dataset behavior |
| CvtkCartesianGrid | Abstract API for vtkImageData and vtkRectilinearGrid |
| CvtkImageData | Topologically and geometrically regular array of data |
| CvtkStructuredPoints | A subclass of ImageData |
| CvtkUniformGrid | Deprecated vtkImageData |
| CvtkRectilinearGrid | Dataset that is topologically regular with variable spacing in the three coordinate directions |
| 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 > | |
| CvtkMappedUnstructuredGrid< Implementation, CellIterator > | Allows datasets with arbitrary storage layouts to be used with VTK |
| CvtkUnstructuredGrid | Dataset represents arbitrary combinations of all possible cell types |
| 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 |
| CvtkStatisticalModel | Base class for statistical modeling of other data |
| CvtkTable | A table, which contains similar-typed columns of data |
| CvtkDataObjectMeshCache | VtkDataObjectMeshCache is a class to store and reuse the mesh of a vtkDataSet, while forwarding data arrays from another dataset |
| 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 |
| CvtkDecimatePolylineStrategy | Abstract class to define a decimation strategy for the vtkDecimatePolylineFilter |
| CvtkDecimatePolylineAngleStrategy | Decimation strategy using the angle between 3 consecutive points as a metric |
| CvtkDecimatePolylineCustomFieldStrategy | Decimation strategy using a custom point data array to retrieve the data to be used a a metric |
| CvtkDecimatePolylineDistanceStrategy | Decimation strategy using distance between points as a metric |
| CvtkDeserializer | Deserialize VTK objects from JSON |
| 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 |
| CvtkPExecutableRunner | VtkPExecutableRunner provides a way to launch commands processes and control for multi-process use cases |
| CvtkExecutionAggregator | Aggregate the results of the sub-pipeline in vtkEndFor |
| CvtkAggregateToPartitionedDataSetCollection | Aggregate results in the vtkEndFor |
| CvtkExecutionRange | Define a range for the vtkForEach |
| CvtkTimeRange | VtkExecutionRange using time to dispatch in a vtkForEach sub-pipeline |
| CvtkExecutionTimer | Time filter execution |
| CvtkExecutive | Superclass for all pipeline executives in VTK |
| CvtkDemandDrivenPipeline | Executive supporting on-demand execution |
| CvtkStreamingDemandDrivenPipeline | Executive supporting partial updates |
| CvtkCachedStreamingDemandDrivenPipeline | VtkCachedStreamingDemandDrivenPipeline |
| CvtkCompositeDataPipeline | Executive supporting composite datasets |
| CvtkThreadedCompositeDataPipeline | Executive that works in parallel |
| CvtkImageImportExecutive | VtkImageImportExecutive |
| CvtkExodusIICache | |
| CvtkExodusIIReaderPrivate | This class holds metadata for an Exodus file |
| CvtkExporter | Abstract class to write a scene to a file |
| CvtkAlembicExporter | Export a scene into Alembic format |
| 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 |
| CvtkPVWebGLExporter | |
| 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 |
| CvtkUSDExporter | Export a scene into USD format |
| 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 | Represents and manipulates a collection of data arrays |
| 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 |
| CvtkFiltersCellGrid | A registrar for cell types contained in this module |
| 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 |
| 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 | |
| CvtkGLSLModifierBase | Abstract class that helps you develop modifier for VTK GLSL shaders |
| CvtkGLSLModCamera | Implement model-view-projection transforms in the OpenGL renderer |
| CvtkGLSLModCoincidentTopology | Handle coincident topology |
| CvtkGLSLModLight | Implement light kit support in the OpenGL renderer for vtkCellGrid |
| CvtkGLSLModPixelDebugger | Allow live pixel debugging by overwriting gl_FragData[0] output |
| CvtkGLTFDocumentLoader | Deserialize a GLTF model file |
| CvtkGLTFTexture | |
| 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 |
| 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 | |
| CvtkGridAxesHelper | Helper object used by vtkGridAxesActor2D, vtkGridAxesActor3D, and vtkGridAxesPlane2DActor |
| CvtkHardwareSelector | |
| CvtkOpenGLHardwareSelector | Implements the device specific code of vtkOpenGLHardwareSelector |
| CvtkPHardwareSelector | VtkHardwareSelector useful for parallel rendering |
| CvtkWebGPUHardwareSelector | Implements the device specific code of vtkWebGPUHardwareSelector |
| 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 |
| CvtkHyperTreeGridGenerateFieldStrategy | Abstract class for field definition used by vtkHyperTreeGridGenerateFields |
| CvtkHyperTreeGridCellCenterStrategy | Define the CellCenter field used in vtkHyperTreeGridGenerateFields |
| CvtkHyperTreeGridCellSizeStrategy | Define the CellSize field used in vtkHyperTreeGridGenerateFields |
| CvtkHyperTreeGridTotalVisibleVolumeStrategy | Define the TotalVisibleVolume field data used in vtkHyperTreeGridGenerateFields |
| CvtkHyperTreeGridValidCellStrategy | Define the ValidCell field used in vtkHyperTreeGridGenerateFields |
| CvtkHyperTreeGridLocator | Abstract base class for objects that implement accelerated searches through HyperTree Grids (HTGs) |
| CvtkHyperTreeGridGeometricLocator | Class that implements accelerated searches through HyperTree Grids (HTGs) using geometric information |
| 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 |
| CvtkHyperTreeGridNonOrientedUnlimitedGeometryCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedUnlimitedSuperCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedUnlimitedMooreSuperCursor | Specific Moore super cursor that can subdivied neighborhood |
| CvtkHyperTreeGridOrientedCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridOrientedGeometryCursor | Objects for traversal a HyperTreeGrid |
| CvtkIOCellGrid | A registrar for cell types contained in this module |
| 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 |
| CvtkAnnulus | Implicit function for a annulus |
| CvtkBox | Implicit function for a bounding box |
| CvtkCone | Implicit function for a cone |
| CvtkCoordinateFrame | Implicit function for a right-handed coordinate system |
| CvtkCylinder | Implicit function for a cylinder |
| CvtkFrustum | Implicit function for a frustum |
| 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 receive 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) |
| CvtkIndependentViewerCollection | Store data for independent viewers |
| 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 |
| CvtkIntegrationStrategy | Abstract class to define an integration strategy for vtkIntegrateAttributes |
| CvtkIntegrationGaussianStrategy | Gaussian Quadrature Integration Strategy |
| CvtkIntegrationLinearStrategy | Linear Integration Strategy |
| 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 |
| Cvtk3DCursorWidget | Widget reprensenting a 3D cursor |
| 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 |
| CvtkCamera3DWidget | 3D Widget for manipulating a vtkCamera |
| 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 | Widget to set distance, tilt and heading |
| CvtkContinuousValueWidget | Set a value by manipulating something |
| CvtkContourWidget | Create a contour with a set of points |
| CvtkCoordinateFrameWidget | 3D widget for manipulating a display sized coordinate frame widget |
| CvtkDisplaySizedImplicitPlaneWidget | 3D widget for manipulating a display sized plane |
| 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 |
| CvtkImplicitAnnulusWidget | 3D widget for manipulating an infinite annulus |
| CvtkImplicitConeWidget | 3D widget for manipulating an infinite cone |
| CvtkImplicitCylinderWidget | 3D widget for manipulating an infinite cylinder |
| CvtkImplicitFrustumWidget | 3D widget for manipulating an infinite frustum |
| 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 |
| CvtkMultiLineWidget | 3D widget for manipulating multiple lines |
| CvtkOrientationWidget | 3D Widget for manipulating a vtkCamera |
| 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 |
| CvtkVRInteractorStyle | Extended from vtkInteractorStyle3D to override command methods |
| CvtkOpenVRInteractorStyle | Implements OpenVR specific functions required by vtkVRInteractorStyle |
| CvtkOpenXRInteractorStyle | Extended from vtkInteractorStyle3D to override command methods |
| CvtkWebXRInteractorStyle | Extended from vtkInteractorStyle3D to override command methods |
| CvtkZSpaceInteractorStyle | VtkZSpaceInteractorStyle extends 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 |
| CvtkInteractorStyleManipulator | 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 |
| CvtkAnariTestInteractor | |
| 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 |
| CvtkInvoker | Deserialize VTK objects from JSON |
| 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 |
| CvtkWebGPULight | OpenGL 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 |
| CvtkJumpAndWalkCellLocator | Point locator adaptor to perform cell Location using the jump and walk approach |
| CvtkLinearTransformCellLocator | Cell locator adaptor to perform cell Location on datasets that are a linear transformation of the original dataset |
| CvtkModifiedBSPTree | Generate axis aligned BBox tree for ray-casting and other Locator based searches |
| 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 |
| CvtkMarshalContext | Shared context used by vtkSerializer and vtkDeserializer |
| 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 |
| CvtkMultiProcessControllerHelper | Collection of assorted helper routines dealing with communication |
| CvtkMultiThreader | A class for performing multithreaded execution |
| CvtkMutableGraphHelper | Helper class for building a directed or directed graph |
| CvtkNIFTIImageHeader | Store NIfTI header information |
| CvtkNamedColors | A class holding colors and their names |
| CvtkNetCDFAccessor | |
| CvtkXArrayAccessor | |
| CvtkObjectFactory | Abstract base class for vtkObjectFactories |
| CvtkObjectIdMap | Class used to assign Id to any VTK object and be able to retrieve it base on its id |
| CvtkObjectManager | VtkObjectManager maintains internal instances of vtkSerializer and a vtkDeserializer to serialize and deserialize VTK objects respectively |
| CvtkObserverMediator | Manage contention for cursors and other resources |
| CvtkOctreePointLocatorNode | Octree node that has 8 children each of equal size |
| CvtkOpenGLArrayTextureBufferCache | Manage texture-buffer-backed data arrays shared within a context |
| 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 |
| CvtkOpenGLTextureNormalizationHelper | GPU-based texture normalization for GLES 3.0 without GL_EXT_texture_norm16 |
| CvtkOpenGLTextureCPUNormalization | CPU-based fallback for 16-bit to float texture normalization |
| CvtkOpenGLTextureFramebufferNormalization | Framebuffer-based shader conversion for 16-bit to float texture normalization |
| 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 |
| CvtkOpenXRManagerConnection | OpenXR manager connection no-op implementation |
| CvtkOpenXRManagerRemoteConnection | OpenXR remoting connection strategy |
| CvtkOpenXRManagerGraphics | OpenXR manager graphics implementation |
| CvtkOpenXRManagerD3DGraphics | OpenXR manager D3D graphics implementation |
| CvtkOpenXRManagerOpenGLGraphics | OpenXR manager OpenGL graphics implementation |
| CvtkOpenXRSceneComponent | VtkOpenXRSceneComponent represent a component in the XR scene |
| CvtkOpenXRSceneObserver | vtkOpenXRSceneObserver is a wrapper around OpenXR scene understanding extensions |
| CvtkOpenXRUtilities | Header file that contains utility functions for OpenXR |
| 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 |
| CvtkOverrideAttribute | Attribute for vtkObjectFactory overrides |
| 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 |
| CvtkPartitioningStrategy | A strategy interface for partitioning meshes |
| CvtkNativePartitioningStrategy | A partitioning strategy based on load balancing geometric bounding boxes as cuts of a data set |
| 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 |
| CvtkPolyDataMaterial | If the polydata has a texture, it should contain a TCOORDS point array of type float/double (with two components (u,v)) and a field array of type string: "texture_uri" containing one tuple per texture file with the absolute/relative path to the file |
| 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 |
| CvtkArcGridActorInternal | Renders a concentric list of arcs on overlay |
| CvtkAxisActor2D | Create an axis with tick marks and labels |
| CvtkAxisActor2DMock | Mock vtkAxisActor2D to access inner member for comparison |
| CvtkAxisGridActorInternal | Renders a 2D grid given pairs of point positions |
| 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 |
| CvtkPolarAxesActor2D | Display polar axes in Viewport 2D space |
| CvtkRadialGridActor2D | VtkRadialGridActor2D displays in overlay a list of vtkAxisActor2D sharing a same origin and rotating around it |
| 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 |
| CvtkZSpaceRayActor | An actor for displaying a ray |
| CvtkPolarAxesActor | Create an actor of a polar axes - |
| CvtkSkybox | Renders a skybox environment |
| CvtkOpenGLSkybox | OpenGL Skybox |
| CvtkOpenGLMovieSphere | OpenGL MovieSphere, an optimized VR sphere for movies |
| CvtkWebGPUSkybox | WebGPU Skybox |
| CvtkWebGPUActor | |
| 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 |
| CvtkGridAxesActor2D | Actor for an axes plane in a 3D view |
| CvtkGridAxesActor3D | Actor for a cube-axes like prop in the 3D view |
| CvtkGridAxesPlaneActor2D | Renders a 2D grid for vtkGridAxesActor2D |
| 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 |
| CvtkOpenXRControlsHelper | 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 |
| Cvtk3DCursorRepresentation | Representation of the vtk3DCursorWidget |
| 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 |
| CvtkBoundedWidgetRepresentation | Extends the vtkWidgetRepresentation to help positioning widget in space and how it should be displayed regarding to input bounds |
| CvtkImplicitAnnulusRepresentation | Defining the representation for a vtkImplicitAnnulusWidget |
| CvtkImplicitConeRepresentation | Defining the representation for a vtkImplicitConeWidget |
| CvtkImplicitCylinderRepresentation | Defining the representation for a vtkImplicitCylinderWidget |
| CvtkImplicitFrustumRepresentation | The representation for a vtkImplicitFrustumWidget |
| CvtkImplicitPlaneRepresentation | Class defining the representation for a vtkImplicitPlaneWidget2 |
| CvtkImplicitImageRepresentation | Representation for a vtkImplicitPlaneWidget2 which reslices a volume |
| 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 |
| CvtkCamera3DRepresentation | Class defining the representation for the vtkCamera3DWidget |
| CvtkCameraOrientationRepresentation | A 3D representation for vtkCameraOrientationWidget |
| CvtkCheckerboardRepresentation | Represent the vtkCheckerboardWidget |
| CvtkContinuousValueWidgetRepresentation | Provide the representation for a continuous value |
| CvtkCompassRepresentation | Provide a compass and distance, tilt sliders |
| 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 |
| CvtkCoordinateFrameRepresentation | Class defining the representation for a vtkCoordinateFrameWidget |
| CvtkCurveRepresentation | Base class for a widget that represents a 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 |
| CvtkDisplaySizedImplicitPlaneRepresentation | Class defining the representation for a vtkDisplaySizedImplicitPlaneWidget |
| 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 |
| CvtkLightRepresentation | Represent a vtkLight |
| CvtkLineRepresentation | Class defining the representation for a vtkLineWidget2 |
| CvtkMagnifierRepresentation | Represent a vtkBorderWidget |
| CvtkMultiLineRepresentation | Class defining the representation for a vtkMultiLineWidget |
| CvtkOrientationRepresentation | Class defining the representation for the vtkOrientationWidget |
| 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 |
| CvtkWebGPUProperty | WebGPU 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 |
| CvtkRemoteInteractionAdapter | Map vtk-js interaction events to native VTK events |
| CvtkRenderMaterialLibrary | Renderer-agnostic collection of materials for VTK apps to draw from |
| CvtkANARIMaterialLibrary | Collection of materials for ANARI-based rendering |
| CvtkOSPRayMaterialLibrary | Collection of materials for OSPRay-based rendering |
| CvtkRenderPass | Perform part of the rendering of a vtkRenderer |
| CvtkAnariPass | Render pass that uses ANARI (ANAlytic Rendering Interface) instead of OpenGL |
| 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 |
| CvtkHexagonalBokehBlurPass | Screen space render pass that blur a given image using the hexagonal bokeh method |
| 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 |
| CvtkVRRenderWindowInteractor | Implements VR specific functions required by vtkRenderWindowInteractor |
| CvtkOpenVRRenderWindowInteractor | Implements OpenVR specific functions required by vtkVRRenderWindowInteractor |
| CvtkOpenXRRenderWindowInteractor | Implements OpenXR specific functions required by vtkRenderWindowInteractor |
| CvtkWebXRRenderWindowInteractor | Implements WebXR specific functions required by vtkVRRenderWindowInteractor |
| CvtkZSpaceRenderWindowInteractor | Handle zSpace specific interactions |
| CvtkWaylandRenderWindowInteractor | Wayland event-driven interface for a RenderWindow |
| CvtkWebAssemblyRenderWindowInteractor | Handles user interaction in web browsers |
| 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 |
| CvtkRenderingCellGrid | A registrar for cell types contained in this module |
| CvtkResliceCursor | Geometry for a reslice cursor |
| CvtkResliceImageViewerMeasurements | Manage measurements on a resliced image |
| CvtkResourceFileLocator | Utility to locate resource files |
| CvtkResourceParser | Helper class to perform formatted input from vtkResourceStream |
| CvtkResourceStream | Abstract class used for custom streams |
| CvtkFileResourceStream | VtkResourceStream implementation for file input |
| CvtkMemoryResourceStream | vtkResourceStream implementation for memory input |
| 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 |
| CvtkSelector | |
| CvtkBlockSelector | Selector for blocks |
| CvtkFrustumSelector | VtkFrustumSelector is a vtkSelector that selects elements based on whether they are inside or intersect a frustum of interest |
| CvtkLocationSelector | Selects cells containing or points near chosen point locations |
| CvtkValueSelector | Selects elements matching chosen values |
| CvtkSerializer | Serialize VTK objects to JSON |
| 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 |
| CvtkWebGPUShaderProperty | 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 |
| CvtkSphericalPointIterator | Traverse a collection of points in spherical ordering |
| 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 |
| CvtkSynchronizableActors | Abstract base class for synchronizing a collection of actors |
| CvtkSynchronizableAvatars | Serialize/deserialize collection of vtkOpenGLAvatars among renderers |
| 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 | In case DepthTextureCompare is true, specify the comparison function in use |
| CvtkQWidgetTexture | Allows a QWidget to be used as a texture in VTK with OpenGL |
| CvtkTextureObject | In case DepthTextureCompare is true, specify the comparison function in use |
| CvtkTextureUnitManager | Allocate/free texture units |
| CvtkThreadedCallbackQueue | Simple threaded callback queue |
| 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 |
| CvtkToImplicitStrategy | Pure interface for strategies to transform explicit arrays into implicit arrays |
| CvtkToAffineArrayStrategy | Strategy to transform an explicit array into a vtkAffineArray |
| CvtkToConstantArrayStrategy | Strategy to be used in conjunction with vtkToImplicitArrayFilter to identify and compress constant arrays |
| CvtkToImplicitRamerDouglasPeuckerStrategy | A strategy for creating constant or affine by parts implicit arrays from explicit memory arrays based on the Ramer-Douglas-Peucker algorithm(*) |
| CvtkToImplicitTypeErasureStrategy | A strategy for compressing arrays by type when applicable (int -> unsigned char for example) and wrapping them behind a vtkImplicitArray to furnish the same interface |
| 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 |
| CvtkURI | URI representation |
| CvtkURILoader | Helper class for readers and importer that need to load more than one resource |
| CvtkUniforms | Helper class to set custom uniform variables in GPU shaders |
| CvtkOpenGLUniforms | Helper class to set custom uniform variables in GLSL shaders |
| CvtkUnstructuredGridFieldAnnotations | Fetch/add field annotations from/to an unstructured grid's field data |
| 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 |
| CvtkOpenXRModel | OpenXR device model |
| CvtkWebXRModel | WebXR 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 |
| CvtkAnariActorNode | Links vtkActor and vtkMapper to ANARI |
| CvtkAnariFollowerNode | Links vtkFollower to ANARI |
| CvtkOSPRayActorNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkCameraNode | VtkViewNode specialized for vtkCameras |
| CvtkAnariCameraNode | Links vtkCamera to ANARI |
| CvtkOSPRayCameraNode | Links vtkCamera to OSPRay |
| CvtkLightNode | VtkViewNode specialized for vtkLights |
| CvtkAnariLightNode | Links vtkLights to ANARI |
| CvtkOSPRayLightNode | Links vtkLights to OSPRay |
| CvtkMapperNode | VtkViewNode specialized for vtkMappers |
| CvtkPolyDataMapperNode | VtkViewNode specialized for vtkPolyDataMappers |
| CvtkAnariPolyDataMapperNode | Links vtkActor and vtkMapper to ANARI |
| CvtkAnariCompositePolyDataMapperNode | Links vtkActor and vtkMapper to ANARI |
| CvtkAnariGlyph3DMapperNode | A Glyph mapper node for ANARI (ANAlytic Rendering Interface) |
| CvtkOSPRayMoleculeMapperNode | Links vtkMoleculeMapper to OSPRay |
| CvtkOSPRayPolyDataMapperNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkOSPRayCompositePolyDataMapperNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkOSPRayPointGaussianMapperNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkVolumeMapperNode | VtkViewNode specialized for vtkVolumeMappers |
| CvtkAnariVolumeMapperNode | Links vtkVolumeMapper to ANARI |
| CvtkOSPRayUnstructuredVolumeMapperNode | Unstructured grid volume renderer |
| CvtkOSPRayVolumeMapperNode | Links vtkVolumeMapper to OSPRay |
| CvtkOSPRayAMRVolumeMapperNode | Links vtkVolumeMapper to OSPRay |
| CvtkRendererNode | VtkViewNode specialized for vtkRenderers |
| CvtkAnariSceneGraph | Links vtkRenderers to ANARI |
| CvtkOSPRayRendererNode | Links vtkRenderers to OSPRay |
| CvtkVolumeNode | VtkViewNode specialized for vtkActors |
| CvtkAnariVolumeNode | Links vtkVolume and vtkMapper to ANARI |
| CvtkOSPRayVolumeNode | Links vtkVolume and vtkMapper to OSPRay |
| CvtkWindowNode | VtkViewNode specialized for vtkRenderWindows |
| CvtkOSPRayWindowNode | Links vtkRendererWindows to OSPRay |
| CvtkViewNodeFactory | Factory that chooses vtkViewNodes to create |
| CvtkAnariViewNodeFactory | Matches vtk rendering classes to specific ANARI ViewNode classes |
| 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 | Renderer class for VR/AR context |
| CvtkOpenVRRenderer | OpenVR renderer |
| CvtkOpenXRRenderer | OpenXR renderer |
| CvtkWebXRRenderer | WebXR renderer |
| CvtkZSpaceRenderer | VR renderer |
| CvtkWebGPURenderer | |
| 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 |
| CvtkWebApplication | Defines ParaViewWeb application interface |
| CvtkWebGLDataSet | VtkWebGLDataSet represent vertices, lines, polygons, and triangles |
| CvtkWebGLExporter | VtkWebGLExporter export the data of the scene to be used in the WebGL |
| CvtkWebGLObject | VtkWebGLObject represent and manipulate an WebGL object and its data |
| CvtkWebGLPolyData | PolyData representation for WebGL |
| CvtkWebGLWidget | Widget representation for WebGL |
| CvtkWebGPUCellToPrimitiveConverter | Converts VTK cell connectivity arrays into webgpu primitives using compute shaders |
| CvtkWebGPUComputeBuffer | Represents the set of parameters that will be used to create a compute shader buffer on the device when it will be added to a compute pass using vtkWebGPUComputePass::AddBuffer() |
| CvtkWebGPUComputeRenderBuffer | Render buffers are returned by calls to vtkWebGPUPolyDataMapper::AcquirePointAttributeComputeRenderBuffer() (or CellAttribute equivalent) and represent a buffer that is used by the rendering pipeline and that can also be added to a compute pipeline |
| CvtkWebGPUComputePass | A compute pass is an abstraction for offloading computation from the CPU onto the GPU using WebGPU compute shaders |
| CvtkWebGPUComputePassBufferStorageInternals | This class manages the creation/deletion/recreation/resizing/updating of compute buffers used by a compute pass |
| CvtkWebGPUComputePassInternals | Internals of the vtkWebGPUComputePass |
| CvtkWebGPUComputePassTextureStorageInternals | This class manages the creation/deletion/recreation/ of compute textures used by a compute pass |
| CvtkWebGPUComputePipeline | A compute pipeline is the orchestrator of a collection of compute passes |
| CvtkWebGPUConfiguration | Create a webgpu device for use in rendering and compute pipelines |
| CvtkWebGPUPointCloudMapperInternals | Internal implementation details of vtkWebGPUPointCloudMapper |
| CvtkWebGPURenderPipelineCache | Class to create and retrieve render pipelines based on a given key |
| CvtkWebGPURenderTextureCache | Class to create and retrieve render Textures based on a given key |
| CvtkWebGPUShaderDatabase | Class to add and retrieve source code for shader files for a specified key |
| CvtkWebGPUTextureDeviceResource | Abstraction class for WebGPU textures |
| CvtkWebGPUComputeTexture | Represents the set of parameters that will be used to create a compute shader texture on the device when it will be added to a pipeline using vtkWebGPUComputePipeline::AddTexture() |
| CvtkWebGPUComputeRenderTexture | Render textures are returned by calls to vtkWebGPUPolyDataMapper::AcquireXXXXRenderTexture() and represent a buffer that is used by the rendering pipeline and that can also be added to a compute pipeline |
| CvtkWebGPURenderTextureDeviceResource | |
| CvtkWebGPUTextureView | Abstraction class for WebGPU texture views |
| CvtkWebGPUComputeTextureView | |
| CvtkWebInteractionEvent | |
| CvtkWebUtilities | Collection of utility functions for ParaView Web |
| CvtkWidgetCallbackMapper | Map widget events into callbacks |
| CvtkWidgetEvent | Define widget events |
| CvtkWidgetEventTranslator | Map VTK events into widget events |
| CvtkWidgetSet | Synchronize a collection on vtkWidgets drawn on different renderwindows using the Callback - Dispatch Action mechanism |
| CvtkWindow | Window superclass for vtkRenderWindow |
| CvtkHardwareWindow | Create a window for renderers to draw into |
| CvtkCocoaHardwareWindow | Window in a Cocoa GUI |
| CvtkWaylandHardwareWindow | Window in a Wayland GUI |
| CvtkWebAssemblyHardwareWindow | WebAssembly hardware window that interfaces with HTML5 canvas |
| CvtkWin32HardwareWindow | Window in a windows GUI |
| CvtkXlibHardwareWindow | 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 |
| CvtkZSpaceGenericRenderWindow | Generic render window for stereo rendering on ZSpace Inspire |
| CvtkIOSRenderWindow | IOS OpenGL rendering window |
| CvtkOSOpenGLRenderWindow | OffScreen Mesa rendering window |
| CvtkVRRenderWindow | VR rendering window |
| CvtkOpenVRRenderWindow | OpenVR rendering window |
| CvtkOpenXRRenderWindow | OpenXR rendering window |
| CvtkOpenXRRemotingRenderWindow | OpenXR remoting rendering window |
| CvtkWebXRRenderWindow | WebXR rendering window |
| CvtkWebAssemblyOpenGLRenderWindow | |
| CvtkWin32OpenGLRenderWindow | |
| CvtkWin32OpenGLDXRenderWindow | VTK render window providing OpenGL-DirectX interop |
| CvtkZSpaceWin32RenderWindow | OpenGL render window for stereo rendering on ZSpace Inspire |
| CvtkXOpenGLRenderWindow | OpenGL rendering window |
| CvtkWebGPURenderWindow | WebGPU 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 | |
| CvtkZSpaceSDKManager | Abstract zSpace SDK manager class |
| CvtkZSpaceCoreCompatibilitySDKManager | ZSpace Core Compatibility SDK manager class |
| CvtkZSpaceCoreSDKManager | ZSpace Core SDK manager class |
| CvtkThreadedCallbackQueue::vtkSharedFutureBase | vtkSharedFutureBase is the base block to store, run, get the returned value of the tasks that are pushed in the queue |
| CvtkThreadedCallbackQueue::vtkSharedFuture< ReturnT > | A vtkSharedFuture is an object returned by the methods Push and PushDependent |
| CvtkObjectFactoryRegistryCleanup | |
| CvtkOBJImportedMaterial | |
| CvtkODBCInternals | Simple class to hide ODBC structures |
| CvtkONNXInferenceInternals | VTK internal class for hiding ONNX members |
| CvtkONNXInternalUtils | Some utilities related to ONNX |
| CvtkOpenGL2ContextDevice2DCellArrayHelper | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| CvtkOpenGL2ContextDevice2DPrivate | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| CvtkOpenGLArrayTextureBufferAdapter | Interfaces vtkDataArray to an OpenGL texture buffer |
| CvtkOpenGLContextDeviceBufferObjectBuilder | Internal buffer object builder that maintains a cache of VBO groups |
| CvtkOpenGLHelper | |
| CvtkOpenGLImageAlgorithmCallback | |
| CvtkOpenGLLowMemoryCellTypeAgent | Helps vtkOpenGLLowMemoryPolyDataMapper map and draw cell types from vtkPolyData as OpenGL graphics primitives |
| CvtkOpenGLLowMemoryLinesAgent | Maps VTK_LINE and VTK_POLY_LINE into GL_LINES and draws GL_LINES or GL_POINTS |
| CvtkOpenGLLowMemoryPolygonsAgent | Maps VTK_TRIANGLE and VTK_POLYGON into GL_TRIANGLES and draws GL_TRIANGLES or GL_LINES or GL_POINTS |
| CvtkOpenGLLowMemoryStripsAgent | Maps VTK_TRIANGLE_STRIP into GL_TRIANGLES and draws GL_TRIANGLES or GL_LINES or GL_POINTS |
| CvtkOpenGLLowMemoryVerticesAgent | Maps VTK_VERTEX and VTK_POLY_VERTEX into GL_POINTS and draws GL_POINTS |
| CvtkOpenGLQuadHelper | Class to make rendering a full screen quad easier |
| CvtkOpenGLRenderTimer | Asynchronously measures GPU execution time for a single event |
| CvtkOpenGLShaderDeclaration | |
| CvtkOpenGLTextureComputeShaderNormalization | GPU compute shader implementation for 16-bit to float texture normalization |
| CvtkOpenVROverlaySpot | |
| Cvtk::detail::vtkOpenXRManager | Singleton class that holds a collection of utility functions and member variables to communicate with the OpenXR runtime |
| CvtkOSPRayCache< T > | Temporal cache ospray structures to speed flipbooks |
| CvtkOSPRayCacheItemObject | |
| CvtkOSPRayMaterialHelpers | Convert vtk appearance controls to ospray materials |
| CvtkOStreamWrapper | Wrapper for C++ ostream |
| CvtkOStrStreamWrapper | Wrapper for ostrstream |
| CvtkOTUtilities | |
| CvtkPainterCommunicator | A communicator that can safely be used inside a painter |
| CvtkPPainterCommunicator | |
| CvtkPassSelectedArrays | Pass through chosen arrays |
| CvtkPConvertToMultiBlockDataSet | Parallel version of vtkConvertToMultiBlockDataSet |
| 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 |
| CvtkPolyhedronContour | Isosurface extraction using López polygon tracing algorithm |
| CvtkPolyhedronUtilities | VtkPolyhedron utilities |
| Ctovtkm::vtkPortalTraits< T > | |
| Ctovtkm::vtkPortalTraits< const viskores::Vec< T, N > > | |
| Ctovtkm::vtkPortalTraits< const viskores::Vec< viskores::Vec< T, N >, M > > | |
| Ctovtkm::vtkPortalTraits< viskores::Vec< T, N > > | |
| Ctovtkm::vtkPortalTraits< viskores::Vec< viskores::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 | |
| CvtkQuadricLODActor | Specific level-of-detail strategy using the quadric clustering decimation algorithm |
| 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 |
| CvtkRemoteSession | Provides a remote session interface wrapped around vtk.h for managing VTK objects and states in a WebAssembly environment |
| CvtkRenderState | Context in which a vtkRenderPass will render |
| CvtkReservoirSampler< IntegerType > | Generate a monotonic sequence of integers that randomly kk-sample a range without substitution |
| CvtkReservoirSamplerBase | |
| CvtkReservoirSampler< Integer, Monotonic > | |
| CvtkScalarBarActorInternal | Internal state for the scalar bar actor shared with subclasses |
| CvtkScalarBarBox | A structure to represent pixel coordinates for text or swatch bounds |
| CvtkSegYBinaryHeaderBytesPositions | |
| CvtkSegYIOUtils | |
| CvtkSegYReaderInternal | |
| CvtkSegYTrace | |
| CvtkSegYTraceHeaderBytesPositions | |
| CvtkSegYTraceReader | |
| CvtkSelectionNode | Node in a vtkSelection the defines the selection criteria |
| CvtkSessionDescriptor | |
| CvtkSessionJsonImpl | |
| CvtkShellBinIterator | A fast, lightweight class for iterating over the bins of a 3D vtkStaticPointLocator |
| CvtkShellBinIteratorDispatch | |
| CvtkSmartPointerBase | Non-templated superclass for vtkSmartPointer |
| CvtkSmartPointer< vtkSharedFutureBase > | |
| CvtkSmartPointer< vtkSharedFuture< ReturnT > > | |
| CvtkSmartPointer< vtkInvoker< FT, ArgsT... > > | |
| CvtkSmartPointer< InternalIterator > | |
| CvtkSmartPointer< ParticleTrail > | |
| CvtkSmartPointer< vtkObject > | |
| CvtkSmartPointer< vtkAbstractArray > | |
| CvtkSmartPointer< vtkGenericOpenGLRenderWindow > | |
| CvtkSmartPointer< vtkDataObjectMeshCache > | |
| CvtkSmartPointer< vtkStringArray > | |
| CvtkSmartPointer< vtkRenderWindow > | |
| CvtkSmartPointer< vtkMotionFXCFGReader > | |
| CvtkSmartPointer< vtkCompositePolyDataMapper > | |
| CvtkSmartPointer< vtkActor > | |
| CvtkSmartPointer< CollectionType > | |
| CvtkSmartPointer< vtkCompositeDataSet > | |
| CvtkSmartPointer< vtkDataObjectTree > | |
| CvtkSmartPointer< vtkOpenXRManagerGraphics > | |
| CvtkSmartPointer< vtkOpenXRManagerConnection > | |
| CvtkSmartPointer< vtkMultiProcessController > | |
| CvtkSmartPointer< vtkUniformGrid > | |
| CvtkSmartPointer< vtkAMRMetaData > | |
| CvtkSmartPointer< vtkUnsignedIntArray > | |
| CvtkSmartPointer< vtkResourceStream > | |
| CvtkSmartPointer< vtkMatrix4x4 > | |
| CvtkSmartPointer< vtkAnariDevice > | |
| CvtkSmartPointer< vtkAssignCoordinates > | |
| CvtkSmartPointer< vtkFastSplatter > | |
| CvtkSmartPointer< vtkImageData > | |
| CvtkSmartPointer< vtkFloatArray > | |
| CvtkSmartPointer< vtkIntArray > | |
| CvtkSmartPointer< vtkUnsignedCharArray > | |
| CvtkSmartPointer< vtkPen > | |
| CvtkSmartPointer< vtkDoubleArray > | |
| CvtkSmartPointer< vtkTextProperty > | |
| CvtkSmartPointer< vtkCamera > | |
| CvtkSmartPointer< vtkPlane > | |
| CvtkSmartPointer< vtkContourValues > | |
| CvtkSmartPointer< vtkRenderer > | |
| CvtkSmartPointer< vtkPoints > | |
| CvtkSmartPointer< vtkStructuredCellArray > | |
| CvtkSmartPointer< vtkConstantArray< unsigned char > > | |
| CvtkSmartPointer< vtkConstantArray< int > > | |
| CvtkSmartPointer< vtkOrderedTriangulator > | |
| CvtkSmartPointer< vtkTetra > | |
| CvtkSmartPointer< vtkDataArray > | |
| CvtkSmartPointer< ArrayType > | |
| CvtkSmartPointer< vtkCellArray > | |
| CvtkSmartPointer< vtkScalarsToColors > | |
| CvtkSmartPointer< vtkTypeUInt8Array > | |
| CvtkSmartPointer< vtkTypeInt32Array > | |
| CvtkSmartPointer< vtkCellAttributeCalculator > | |
| CvtkSmartPointer< vtkCellGrid > | |
| CvtkSmartPointer< vtkTable > | |
| CvtkSmartPointer< vtkTypeUInt32Array > | |
| CvtkSmartPointer< vtkIdTypeArray > | |
| CvtkSmartPointer< vtkIdList > | |
| CvtkSmartPointer< vtkBrush > | |
| CvtkSmartPointer< vtkTooltipItem > | |
| CvtkSmartPointer< vtkPlotHistogram2D > | |
| CvtkSmartPointer< vtkChartLegend > | |
| CvtkSmartPointer< vtkAnnotationLink > | |
| CvtkSmartPointer< vtkIncrementalPointLocator > | |
| CvtkSmartPointer< vtkAxis > | |
| CvtkSmartPointer< vtkCallbackCommand > | |
| CvtkSmartPointer< vtkCenteredSliderRepresentation > | |
| CvtkSmartPointer< vtkCompositeDataDisplayAttributes > | |
| CvtkSmartPointer< vtkPolyDataMapper > | |
| CvtkSmartPointer< vtkTexture > | |
| CvtkSmartPointer< vtkContextDevice3D > | |
| CvtkSmartPointer< vtkTransform > | |
| CvtkSmartPointer< vtkContextScene > | |
| CvtkSmartPointer< vtkContext2D > | |
| CvtkSmartPointer< vtkCoordinate > | |
| CvtkSmartPointer< vtkTransformFilter > | |
| CvtkSmartPointer< vtkPolyLine > | |
| CvtkSmartPointer< vtkPolygon > | |
| CvtkSmartPointer< vtkTriangle > | |
| CvtkSmartPointer< vtkDGCell > | |
| CvtkSmartPointer< vtkCellAttribute > | |
| CvtkSmartPointer< vtkFieldData > | |
| CvtkSmartPointer< vtkAlgorithm > | |
| CvtkSmartPointer< vtkAOSDataArrayTemplate< ValueType > > | |
| CvtkSmartPointer< vtkDataObject > | |
| CvtkSmartPointer< vtkInformation > | |
| CvtkSmartPointer< vtkDataSet > | |
| CvtkSmartPointer< vtkPixelBufferObject > | |
| CvtkSmartPointer< vtkDecimatePolylineStrategy > | |
| CvtkSmartPointer< vtkAbstractTransform > | |
| CvtkSmartPointer< vtkPolyData > | |
| CvtkSmartPointer< vtkTree > | |
| CvtkSmartPointer< vtkMarshalContext > | |
| CvtkSmartPointer< vtkPiecewiseFunction > | |
| CvtkSmartPointer< vtkShaderProgram > | |
| CvtkSmartPointer< vtkConvertSelectionDomain > | |
| CvtkSmartPointer< vtkAbstractCellLinks > | |
| CvtkSmartPointer< vtkExtractCellsIdList > | |
| CvtkSmartPointer< vtkExtractSelection > | |
| CvtkSmartPointer< vtkExtractDataArraysOverTime > | |
| CvtkSmartPointer< vtkGraphToPolyData > | |
| CvtkSmartPointer< vtkStaticPointLocator > | |
| CvtkSmartPointer< vtkLabeledImagePointSampler > | |
| CvtkSmartPointer< vtkPath > | |
| CvtkSmartPointer< vtkPlanes > | |
| CvtkSmartPointer< vtkURILoader > | |
| CvtkSmartPointer< vtkGLTFDocumentLoader > | |
| CvtkSmartPointer< vtkMultiBlockDataSet > | |
| CvtkSmartPointer< vtkDataArraySelection > | |
| CvtkSmartPointer< vtkConstrainedSmoothingFilter > | |
| CvtkSmartPointer< vtkOutlineSource > | |
| CvtkSmartPointer< vtkGeometryFilter > | |
| CvtkSmartPointer< vtkGenericGeometryFilter > | |
| CvtkSmartPointer< vtkUnstructuredGridGeometryFilter > | |
| CvtkSmartPointer< vtkRecoverGeometryWireframe > | |
| CvtkSmartPointer< vtkFeatureEdges > | |
| CvtkSmartPointer< vtkPolyDataNormals > | |
| CvtkSmartPointer< vtkAppendPolyData > | |
| CvtkSmartPointer< vtkConvexHull2D > | |
| CvtkSmartPointer< vtkGlyph3D > | |
| CvtkSmartPointer< vtkVertexGlyphFilter > | |
| CvtkSmartPointer< vtkIconGlyphFilter > | |
| CvtkSmartPointer< vtkMapArrayValues > | |
| CvtkSmartPointer< vtkTransformCoordinateSystems > | |
| CvtkSmartPointer< vtkPolyDataMapper2D > | |
| CvtkSmartPointer< vtkTexturedActor2D > | |
| CvtkSmartPointer< vtkGraphToPoints > | |
| CvtkSmartPointer< vtkGlyphSource2D > | |
| CvtkSmartPointer< vtkSphereSource > | |
| CvtkSmartPointer< vtkDistanceToCamera > | |
| CvtkSmartPointer< vtkGridAxesPlaneActor2D > | |
| CvtkSmartPointer< vtkGridAxesHelper > | |
| CvtkSmartPointer< vtkDataAssembly > | |
| CvtkSmartPointer< vtkSelection > | |
| CvtkSmartPointer< vtkOpenGLFramebufferObject > | |
| CvtkSmartPointer< vtkTextureObject > | |
| CvtkSmartPointer< vtkLine > | |
| CvtkSmartPointer< vtkPointData > | |
| CvtkSmartPointer< vtkCellData > | |
| CvtkSmartPointer< vtkHexahedron > | |
| CvtkSmartPointer< vtkQuad > | |
| CvtkSmartPointer< vtkWedge > | |
| CvtkSmartPointer< vtkBitArray > | |
| CvtkSmartPointer< vtkMergePoints > | |
| CvtkSmartPointer< vtkHyperTreeGridGenerateFieldStrategy > | |
| CvtkSmartPointer< vtkHyperTreeGridNonOrientedGeometryCursor > | |
| CvtkSmartPointer< vtkHyperTreeGridNonOrientedUnlimitedGeometryCursor > | |
| CvtkSmartPointer< vtkHyperTreeGridLocator > | |
| CvtkSmartPointer< vtkCharArray > | |
| CvtkSmartPointer< vtkAbstractCellLocator > | |
| CvtkSmartPointer< vtkGenericCell > | |
| CvtkSmartPointer< vtkIntegrationStrategy > | |
| CvtkSmartPointer< vtkAbstractPointLocator > | |
| CvtkSmartPointer< vtkTextPropertyCollection > | |
| CvtkSmartPointer< vtkLagrangianBasicIntegrationModel > | |
| CvtkSmartPointer< vtkInitialValueProblemSolver > | |
| CvtkSmartPointer< ImplementationType > | |
| CvtkSmartPointer< vtkMathInternal > | |
| CvtkSmartPointer< vtkMatrix3x3 > | |
| CvtkSmartPointer< vtkMolecule > | |
| CvtkSmartPointer< vtkOBJPolyDataProcessor > | |
| CvtkSmartPointer< vtkOverrideAttribute > | |
| CvtkSmartPointer< vtkOpenGLBufferObject > | |
| CvtkSmartPointer< vtkOpenGLTexture > | |
| CvtkSmartPointer< vtkOpenGLVertexBufferObjectGroup > | |
| CvtkSmartPointer< vtkOpenGLRenderWindow > | |
| CvtkSmartPointer< vtkFFMPEGVideoSource > | |
| CvtkSmartPointer< vtkPBRLUTTexture > | |
| CvtkSmartPointer< vtkPBRIrradianceTexture > | |
| CvtkSmartPointer< vtkPBRPrefilterTexture > | |
| CvtkSmartPointer< vtkHexagonalBokehBlurPass > | |
| CvtkSmartPointer< vtkOpenGLArrayTextureBufferCache > | |
| CvtkSmartPointer< vtkVolumeTexture > | |
| CvtkSmartPointer< vtkOpenVROverlay > | |
| CvtkSmartPointer< vtkProp > | |
| CvtkSmartPointer< AbstractPStreamTracerUtils > | |
| CvtkSmartPointer< vtkCollection > | |
| CvtkSmartPointer< vtkPairwiseExtractHistogram2D > | |
| CvtkSmartPointer< vtkLookupTable > | |
| CvtkSmartPointer< vtkComputeHistogram2DOutliers > | |
| CvtkSmartPointer< vtkActor2D > | |
| CvtkSmartPointer< vtkTextMapper > | |
| CvtkSmartPointer< vtkBivariateLinearTableThreshold > | |
| CvtkSmartPointer< vtkAxisActor2D > | |
| CvtkSmartPointer< vtkPointSet > | |
| CvtkSmartPointer< vtkTemporalInterpolatedVelocityField > | |
| CvtkSmartPointer< vtkPartitionedDataSet > | |
| CvtkSmartPointer< vtkContextMapper2D > | |
| CvtkSmartPointer< vtkColorSeries > | |
| CvtkSmartPointer< vtkPlotBar > | |
| CvtkSmartPointer< vtkProperty > | |
| CvtkSmartPointer< vtkPolyData_detail::CellMap > | |
| CvtkSmartPointer< vtkEdgeTable > | |
| CvtkSmartPointer< vtkVertex > | |
| CvtkSmartPointer< vtkPriorityQueue > | |
| CvtkSmartPointer< vtkAttributeDataToTableFilter > | |
| CvtkSmartPointer< vtkApplyColors > | |
| CvtkSmartPointer< vtkQImageToImageSource > | |
| CvtkSmartPointer< vtkAddMembershipArray > | |
| CvtkSmartPointer< vtkPartitioningStrategy > | |
| CvtkSmartPointer< vtkExtractSelectedGraph > | |
| CvtkSmartPointer< vtkExtractSelectedRows > | |
| CvtkSmartPointer< vtkBalloonRepresentation > | |
| CvtkSmartPointer< vtkLabelPlacementMapper > | |
| CvtkSmartPointer< vtkHoverWidget > | |
| CvtkSmartPointer< vtkHardwareSelector > | |
| CvtkSmartPointer< vtkHardwareWindow > | |
| CvtkSmartPointer< vtkInteractorObserver > | |
| 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< vtkRenderPass > | |
| CvtkSmartPointer< vtkSpline > | |
| CvtkSmartPointer< vtkBuffer< ValueType > > | |
| CvtkSmartPointer< vtkImplicitArray< vtkStructuredCellBackend, vtkArrayTypes::VTK_IMPLICIT_ARRAY > > | |
| CvtkSmartPointer< ArrayTypeX > | |
| CvtkSmartPointer< ArrayTypeY > | |
| CvtkSmartPointer< ArrayTypeZ > | |
| CvtkSmartPointer< vtkSurfaceLICComposite > | |
| CvtkSmartPointer< vtkLineIntegralConvolution2D > | |
| CvtkSmartPointer< vtkDendrogramItem > | |
| CvtkSmartPointer< TemporalFractalOutputUtil > | |
| CvtkSmartPointer< vtkCompositeInterpolatedVelocityField > | |
| CvtkSmartPointer< vtkTemporalPathLineFilterInternals > | |
| CvtkSmartPointer< vtkHeatmapItem > | |
| CvtkSmartPointer< vtkBoxLayoutStrategy > | |
| CvtkSmartPointer< vtkSliceAndDiceLayoutStrategy > | |
| CvtkSmartPointer< vtkSquarifyLayoutStrategy > | |
| CvtkSmartPointer< vtkCellTypes > | |
| CvtkSmartPointer< vtkCellArrayIterator > | |
| CvtkSmartPointer< vtkVRModel > | |
| CvtkSmartPointer< vtkOpenGLVolumeLookupTables< vtkOpenGLVolumeGradientOpacityTable > > | |
| CvtkSmartPointer< vtkOpenGLVolumeLookupTables< vtkOpenGLVolumeOpacityTable > > | |
| CvtkSmartPointer< vtkOpenGLVolumeLookupTables< vtkOpenGLVolumeRGBTable > > | |
| CvtkSmartPointer< vtkOpenGLVolumeLookupTables< vtkOpenGLVolumeTransferFunction2D > > | |
| CvtkSmartPointer< vtkImplicitFunction > | |
| CvtkSmartPointer< vtkStaticPointLocator2D > | |
| CvtkSmartPointer< vtkSpheres > | |
| CvtkSmartPointer< vtkWebGPUComputePass > | |
| CvtkSmartPointer< vtkWebGPUComputePipeline > | |
| CvtkSmartPointer< vtkWebGPUComputePassInternals > | |
| CvtkSmartPointer< vtkWebGPUConfiguration > | |
| CvtkSmartPointer< vtkWebGPUComputePassTextureStorageInternals > | |
| CvtkSmartPointer< vtkWebGPUComputePassBufferStorageInternals > | |
| CvtkSmartPointer< vtkWebGPUPointCloudMapperInternals > | |
| CvtkSmartPointer< vtkWebGPUComputeBuffer > | |
| CvtkSmartPointer< vtkWebGPUTexture > | |
| CvtkSmartPointer< vtkTypeInt64Array > | |
| 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 |
| Cvtk::detail::smp::vtkSMPThreadLocalAPI< T > | |
| Cvtk::detail::smp::vtkSMPThreadLocalImplAbstract< 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 > | |
| 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 |
| Cvtk::detail::smp::vtkSMPThreadPool | Internal thread pool implementation used in SMP functions |
| CvtkSMPTools | A set of parallel (multi-threaded) utility functions |
| Cvtk::detail::smp::vtkSMPToolsAPI | |
| Cvtk::detail::smp::vtkSMPToolsAPIInitialize | |
| Cvtk::detail::smp::vtkSMPToolsImpl< Backend > | |
| CvtkSQLiteDatabaseInternals | |
| CvtkStandaloneSession | A standalone session for managing VTK objects in a WebAssembly environment |
| 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) |
| CvtkStaticEdgeLocatorTemplate< IDType, EdgeData > | Templated on types of ids defining an edge, and any data associated with the edge |
| CvtkStaticFaceHashLinksTemplate< TInputIdType, TFaceIdType > | Templated on types of ids defining an edge |
| CvtkStatisticsAlgorithmPrivate | |
| CvtkStridedImplicitBackend< ValueType > | A backend for the vtkImplicitArray framework to give a strided view on a buffer |
| CvtkStringToken | Represent a string by its integer hash |
| 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 |
| CvtkStructuredPointBackend< ValueType > | A backend for the vtkImplicitArray to query structured points efficiently |
| CvtkStructuredTPointBackend< ValueType, ArrayTypeX, ArrayTypeY, ArrayTypeZ, DataDescription, UseDirMatrix > | |
| CvtkStructuredCellArray::vtkStructuredTCellBackend< DataDescription, UsePixelVoxelOrientation > | |
| CvtkSurfaceLICHelper | A small collection of noise routines for LIC |
| CvtkSurfaceNets3DNonManifoldCases | Provides utilities to identify vtkSurfaceNets3D's edge-cases that can lead to non-manifold output geometry, and to resolve them by creating duplicate points |
| 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 |
| CvtkTemporalAlgorithm | Base class for temporal algorithms |
| CvtkTessellatedBoxSource | Create a polygonal representation of a box with a given level of subdivision |
| CvtkTextActorInterfaceInternal | VTK Internal interface to manipulate text actors from vtkAxisActor |
| CvtkTextRendererCleanup | |
| CvtkTextureImageCache< Key > | |
| 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 | |
| CvtkTilePoint | |
| 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 |
| CvtkVector2< int > | |
| CvtkVector2i | Some derived classes for the different vectors commonly used |
| CvtkVector2< float > | |
| CvtkVector2f | |
| CvtkVector2< double > | |
| CvtkVector2d | |
| CvtkVector3< int > | |
| CvtkVector3i | |
| CvtkVector3< float > | |
| CvtkVector3f | |
| CvtkVector3< double > | |
| CvtkVector3d | |
| 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 | |
| CvtkTuple< float, 3 > | |
| CvtkColor3< float > | |
| CvtkColor3f | |
| CvtkTuple< float, 4 > | |
| CvtkColor4< float > | |
| CvtkColor4f | |
| CvtkQuaternion< float > | |
| CvtkQuaternionf | |
| CvtkTuple< float, Size > | |
| CvtkVector< float, 4 > | |
| CvtkRect< float > | |
| CvtkRectf | |
| CvtkTuple< int, Size > | |
| CvtkVector< int, 4 > | |
| CvtkRect< int > | |
| CvtkRecti | |
| CvtkVector4< int > | |
| CvtkVector4i | |
| 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 | |
| CvtkTypeList | TypeList implementation and utilities |
| CvtkTypeTraits< T > | Template defining traits of native types used by VTK |
| CvtkUpdateCellsV8toV9 | Update cells from v8 node layout to v9 node layout |
| CvtkURIComponent | Represent an URI component |
| CCGNSRead::VTKVariable | |
| CvtkVariant | A 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 | |
| CvtkViewDependentErrorMetric | Objects that compute a screen-based error during cell tessellation |
| CvtkVolumeInputHelper | Convenience container for internal structures specific to a volume input |
| CvtkVolumeMask | |
| CvtkVolumeStateRAII | |
| CvtkVoronoi2DLocalData< TCompositor, TClassifier > | The following thread local data is used to process and keep track of information on a per-thread basis |
| CvtkVoronoi3DLocalData< TCompositor, TClassifier > | The following thread local data is used to process and keep track of information on a per-thread basis |
| CvtkVoronoiAbortCheck | Convenience class to check and interrupt processing aborts during threaded processing |
| CvtkVoronoiAdjacencyGraph | The adjacency graph, a collection of wheels and spokes, is a topological construct that connects Voronoi hull face neighbors |
| CvtkVoronoiBatchManager | Class to manage batches of points |
| CvtkVoronoiClassifier2D | Implementation note about the compositor |
| CvtkVoronoiClassifier3D | Implementation note about the compositor |
| CvtkVoronoiCore2D< TCompositor, TClassifier > | ========================================================================= The templated, core Voronoi class |
| CvtkVoronoiCore3D< TCompositor, TClassifier > | ========================================================================= The templated, core Voronoi class |
| CvtkVoronoiHull | The polyhedron class proper |
| CvtkVoronoiHullVertex | Define hull/tile vertex types |
| CvtkVoronoiJoggle | |
| CvtkVoronoiRandom01Range | |
| CvtkVoronoiRandomColors | |
| CvtkVoronoiSpoke | Typedefs and classes in support of the adjacency graph |
| CvtkVoronoiTile | The convex polygon tile class proper |
| CvtkVoronoiTileVertex | |
| CvtkVoronoiTopoCoord2D | |
| CvtkVoronoiMergeTuple2D | |
| CvtkVoronoiTopoCoord3D | A topological coordinate of dimension N are the N+1 ids of neighboring N+1 Voronoi generator points whose spokes form half spaces intersecting at a tile (2D) / hull (3D) vertex |
| CvtkVoronoiMergeTuple3D | Merge tuples contain an additional point id, which is the global id of a tile/hull point, with most of these points being duplicates |
| CvtkVoronoiWheel | |
| CvtkVRMLImporter_Yacc | |
| CvtkVRMLUseStruct | |
| CvtkVRMLYaccData | |
| CvtkWeakPointerBase | Non-templated superclass for vtkWeakPointer |
| CvtkWeakPointer< ObjectType > | |
| CvtkWeakPointer< vtkMapper > | |
| CvtkWeakPointer< vtkAxisActor > | |
| CvtkWeakPointer< vtkRenderer > | |
| CvtkWeakPointer< vtkContextScene > | |
| CvtkWeakPointer< vtkRenderWindowInteractor > | |
| CvtkWeakPointer< vtkContext2D > | |
| CvtkWeakPointer< vtkIncrementalPointLocator > | |
| CvtkWeakPointer< vtkCellArray > | |
| CvtkWeakPointer< vtkPointData > | |
| CvtkWeakPointer< vtkCellData > | |
| CvtkWeakPointer< vtkDataObject > | |
| CvtkWeakPointer< vtkAlgorithm > | |
| CvtkWeakPointer< vtkDataSet > | |
| CvtkWeakPointer< vtkCompositeDataSet > | |
| CvtkWeakPointer< vtkRenderWindow > | |
| CvtkWeakPointer< vtkTextProperty > | |
| CvtkWeakPointer< vtkMultiProcessController > | |
| CvtkWeakPointer< vtkHyperTreeGrid > | |
| CvtkWeakPointer< vtkOpenGLRenderWindow > | |
| CvtkWeakPointer< vtkLagrangianParticleTracker > | |
| CvtkWeakPointer< vtkCamera > | |
| CvtkWeakPointer< vtkProp3D > | |
| CvtkWeakPointer< vtkOpenVRRenderWindow > | |
| CvtkWeakPointer< vtkPiecewiseFunction > | |
| CvtkWeakPointer< vtkViewport > | |
| CvtkWeakPointer< vtkViewNode > | |
| CvtkWeakPointer< vtkObject > | |
| CvtkWeakPointer< vtkWebGPURenderWindow > | |
| CvtkWeakPointer< vtkWebGPUComputePass > | |
| CvtkWeakPointer< vtkWebGPUComputePipeline > | |
| CvtkWeakPointer< T > | Weak reference to a vtkObject |
| CvtkWeakPtr< T > | Weak reference to a vtkObjectBase |
| CvtkWebAssemblyOpenGL2RenderWindow | OpenGL rendering window |
| CvtkWebGPUActorInternals | |
| CvtkWebGPUBindGroupInternals | |
| CvtkWebGPUBindGroupLayoutInternals | |
| CvtkWebGPUBufferInternals | |
| CvtkWebGPUCommandEncoderDebugGroup | Convenient class that inserts annotations around draw commands within a render pass/bundle |
| CvtkWebGPUComputeBufferInternals | Internal utility class for manipulating vtkWebGPUComputeBuffers |
| CvtkWebGPUConfigurationInternals | |
| CvtkWebGPUHelpers | |
| CvtkWebGPUPipelineLayoutInternals | |
| CvtkWebGPUPolyDataMapper2DInternals | Internal implementation details of vtkWebGPUPolyDataMapper2D |
| CvtkWebGPURenderPassCreateInfoInternals | |
| CvtkWebGPUShaderModuleInternals | |
| CvtkWebGPUTextureInternals | |
| CvtkWebXRUtilities | Header file that contains utility functions for WebXR |
| 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 | |
| CWebXRGamepad | WebXR Gamepad see https://www.w3.org/TR/2024/WD-webxr-gamepads-module-1-20240409/#xr-standard-heading |
| CWebXRGamepadButton | |
| CvtkWebXRRenderWindowInteractor::WebXRInput | |
| CWebXRInputSource | |
| CWebXRRigidTransform | WebXR rigid transform |
| CWebXRView | WebXR view |
| CvtkDendrogramItem::WeightedVertex | |
| CvtkDGOperation< InputIterator, OutputIterator >::Worker | A vtkSMPTools worker class for evaluating an operation across a range of cells |
| 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 | |
| CZCCompatDisplayIntersectionInfo | |
| CZCCompatFrustumBounds | |
| CZCCompatTrackerPose | |
| CCGNSRead::ZoneBCInformation | |
| CCGNSRead::ZoneInformation | |
| CZSMatrix4 | Union representing 4x4 matrix (right-handed OpenGL column-major format). / This structure is used by both the Stereo Frustum and Coordinate Space APIs |
| CzSpaceCoreCompatEntryPoints | Structure holding the loaded zSpace Core Compatibility API entry point function pointers |
| CZSVector3 | Union representing a vector of 3 floats |
1.18.0