| ►Nboost | Forward declaration required for Boost serialization |
| Cedge_bundle_type< vtkDirectedGraph * > | |
| Cedge_bundle_type< vtkDirectedGraph *const > | |
| Cedge_bundle_type< vtkGraph * > | |
| Cedge_bundle_type< vtkMutableDirectedGraph * > | |
| Cedge_bundle_type< vtkMutableDirectedGraph *const > | |
| Cedge_bundle_type< vtkMutableUndirectedGraph * > | |
| Cedge_bundle_type< vtkMutableUndirectedGraph *const > | |
| Cedge_bundle_type< vtkUndirectedGraph * > | |
| Cedge_bundle_type< vtkUndirectedGraph *const > | |
| Cedge_property< vtkGraph * > | |
| Cedge_property_type< vtkDirectedGraph * > | |
| Cedge_property_type< vtkDirectedGraph *const > | |
| Cedge_property_type< vtkGraph * > | |
| Cedge_property_type< vtkMutableDirectedGraph * > | |
| Cedge_property_type< vtkMutableDirectedGraph *const > | |
| Cedge_property_type< vtkMutableUndirectedGraph * > | |
| Cedge_property_type< vtkMutableUndirectedGraph *const > | |
| Cedge_property_type< vtkUndirectedGraph * > | |
| Cedge_property_type< vtkUndirectedGraph *const > | |
| Cgraph_traits< const vtkDirectedGraph * > | |
| Cgraph_traits< const vtkMutableDirectedGraph * > | |
| Cgraph_traits< const vtkMutableUndirectedGraph * > | |
| Cgraph_traits< const vtkTree * > | |
| Cgraph_traits< const vtkUndirectedGraph * > | |
| Cgraph_traits< vtkDirectedGraph * > | |
| Cgraph_traits< vtkDirectedGraph *const > | |
| Cgraph_traits< vtkGraph * > | |
| Cgraph_traits< vtkMutableDirectedGraph * > | |
| Cgraph_traits< vtkMutableDirectedGraph *const > | |
| Cgraph_traits< vtkMutableUndirectedGraph * > | |
| Cgraph_traits< vtkMutableUndirectedGraph *const > | |
| Cgraph_traits< vtkTree * > | |
| Cgraph_traits< vtkTree *const > | |
| Cgraph_traits< vtkUndirectedGraph * > | |
| Cgraph_traits< vtkUndirectedGraph *const > | |
| Cproperty_map< vtkDirectedGraph *, edge_index_t > | |
| Cproperty_map< vtkDirectedGraph *, vertex_index_t > | |
| Cproperty_map< vtkDirectedGraph *const, edge_index_t > | |
| Cproperty_map< vtkDirectedGraph *const, vertex_index_t > | |
| Cproperty_map< vtkGraph *, edge_index_t > | |
| Cproperty_map< vtkGraph *, vertex_index_t > | |
| Cproperty_map< vtkUndirectedGraph *, edge_index_t > | |
| Cproperty_map< vtkUndirectedGraph *, vertex_index_t > | |
| Cproperty_map< vtkUndirectedGraph *const, edge_index_t > | |
| Cproperty_map< vtkUndirectedGraph *const, vertex_index_t > | |
| Cproperty_traits | |
| Cproperty_traits< vtkAbstractArray * > | |
| Cproperty_traits< vtkDataArray * > | |
| Cproperty_traits< vtkGraphEdgeMap > | |
| Cproperty_traits< vtkGraphIndexMap > | |
| Cvertex_bundle_type< vtkDirectedGraph * > | |
| Cvertex_bundle_type< vtkDirectedGraph *const > | |
| Cvertex_bundle_type< vtkGraph * > | |
| Cvertex_bundle_type< vtkMutableDirectedGraph * > | |
| Cvertex_bundle_type< vtkMutableDirectedGraph *const > | |
| Cvertex_bundle_type< vtkMutableUndirectedGraph * > | |
| Cvertex_bundle_type< vtkMutableUndirectedGraph *const > | |
| Cvertex_bundle_type< vtkUndirectedGraph * > | |
| Cvertex_bundle_type< vtkUndirectedGraph *const > | |
| Cvertex_property< vtkGraph * > | |
| Cvertex_property_type< vtkDirectedGraph * > | |
| Cvertex_property_type< vtkDirectedGraph *const > | |
| Cvertex_property_type< vtkGraph * > | |
| Cvertex_property_type< vtkMutableDirectedGraph * > | |
| Cvertex_property_type< vtkMutableDirectedGraph *const > | |
| Cvertex_property_type< vtkMutableUndirectedGraph * > | |
| Cvertex_property_type< vtkMutableUndirectedGraph *const > | |
| Cvertex_property_type< vtkUndirectedGraph * > | |
| Cvertex_property_type< vtkUndirectedGraph *const > | |
| Cvtk_edge_iterator | |
| Cvtk_in_edge_pointer_iterator | |
| Cvtk_out_edge_pointer_iterator | |
| Cvtk_vertex_iterator | |
| CvtkGraph_traversal_category | |
| CvtkGraphEdgeMap | |
| CvtkGraphEdgePropertyMapHelper | |
| CvtkGraphIndexMap | |
| CvtkGraphPropertyMapMultiplier | |
| CvtkGraphVertexPropertyMapHelper | |
| ►NCGNSRead | This file defines functions used by vtkCGNSReader and vtkCGNSReaderInternal |
| ►Ndetail | |
| Cis_double | |
| Cis_double< double > | |
| Cis_float | |
| Cis_float< float > | |
| CBaseInformation | |
| CCGNSVariable | |
| CCGNSVector | |
| CFamilyInformation | |
| CVariable | |
| CvtkCGNSArraySelection | |
| CvtkCGNSCache | |
| CvtkCGNSMetaData | |
| CVTKVariable | |
| CZoneBCInformation | |
| CZoneInformation | |
| ►NCIEDE2000 | Private header used by vtkColorTransferFunction to support LAB/CIEDE2000 interpolation |
| CNode | Node of the color path |
| ►Ndetail | |
| CCellTree | |
| CCellTreeBuilder | |
| CCollectValidCellSurfacePointsFunctor | |
| ►Ndiy | |
| CSerialization< vtkDataArray * > | |
| CSerialization< vtkDataSet * > | |
| CSerialization< vtkFieldData * > | |
| ►Nensight_gold | |
| CEnSightDataSet | Handles reading a full EnSight Gold dataset |
| CEnSightFile | EnSightFile performs processing on a single file, whether it's a case file, geometry, etc |
| CFileSetInfo | |
| CGridOptions | |
| CPartInfo | |
| CTimeSetInfo | |
| CVariableOptions | |
| ►Nfromvtkm | |
| CArrayHandleHelperBase | |
| CArrayHandleHelperSwapper | |
| ►Nimpl | |
| CClientData | |
| ►NMotionFX | |
| ►NCFG | |
| CComment | |
| CGrammar | |
| CLines | |
| CMotion | |
| CMotions | |
| COtherNested | |
| COtherNonNested | |
| CParameterName | |
| CStatement | |
| CStatementOther | |
| CValue | |
| CWS | |
| CWS_Required | |
| ►NCommon | |
| CDelimiter | |
| CExponent | |
| CNumber | |
| CSign | |
| ►NLegacyPositionFile | |
| CGrammar | |
| CRow | |
| ►NOrientationsPositionFile | |
| CGrammar | |
| CRow | |
| ►NUniversalTransformRow | |
| CGrammar | |
| CRow | |
| ►Nomf | |
| CLineSetElement | |
| COMFFile | |
| COMFProject | |
| CPointSetElement | |
| CProjectElement | |
| CSurfaceElement | |
| CVolumeElement | |
| ►NRTW | |
| CBackend | |
| CCamera | |
| CData | |
| CFrameBuffer | |
| CGeometricModel | |
| CGeometry | |
| CGroup | |
| CInstance | |
| CLight | |
| CMaterial | |
| CObject | |
| COSPRayBackend | |
| CRenderer | |
| CTexture | |
| CVisRTXBackend | |
| CWorld | |
| ►Nrtw | |
| Caffine3f | |
| Cbox3f | |
| Cbox3i | |
| Clinear3f | |
| Cvec2f | |
| Cvec2i | |
| Cvec3f | |
| Cvec3i | |
| Cvec3ui | |
| Cvec4f | |
| ►Nstd | |
| Chash< vtkSmartPointer< T > > | |
| Chash< vtkStringToken > | VtkStringTokens provide a specialization of std::hash so they can be used in unordered containers |
| ►Ntovtkm | |
| CDataArrayToArrayHandle | |
| CDataArrayToArrayHandle< vtkAOSDataArrayTemplate< T >, NumComponents > | |
| CDataArrayToArrayHandle< vtkSOADataArrayTemplate< T >, 1 > | |
| CDataArrayToArrayHandle< vtkSOADataArrayTemplate< T >, NumComponents > | |
| CImplicitFunctionConverter | |
| CvtkArrayPortal | |
| CvtkPointsPortal | |
| CvtkPortalTraits | |
| CvtkPortalTraits< const vtkm::Vec< T, N > > | |
| CvtkPortalTraits< const vtkm::Vec< vtkm::Vec< T, N >, M > > | |
| CvtkPortalTraits< vtkm::Vec< T, N > > | |
| CvtkPortalTraits< vtkm::Vec< vtkm::Vec< T, N >, M > > | |
| ►Nvtk | Specialization of tuple ranges and iterators for vtkAOSDataArrayTemplate |
| ►Ndetail | |
| ►Nsmp | |
| ►NOpenMP | |
| CHashTableArray | |
| CSlot | |
| CThreadSpecific | |
| CThreadSpecificStorageIterator | |
| ►NSTDThread | |
| CHashTableArray | |
| CSlot | |
| CThreadSpecific | |
| CThreadSpecificStorageIterator | |
| ►CvtkSMPThreadLocalAPI | |
| Citerator | |
| CvtkSMPThreadLocalImpl | |
| ►CvtkSMPThreadLocalImpl< BackendType::OpenMP, T > | |
| CItImpl | |
| ►CvtkSMPThreadLocalImpl< BackendType::Sequential, T > | |
| CItImpl | |
| ►CvtkSMPThreadLocalImpl< BackendType::STDThread, T > | |
| CItImpl | |
| ►CvtkSMPThreadLocalImpl< BackendType::TBB, T > | |
| CItImpl | |
| ►CvtkSMPThreadLocalImplAbstract | |
| CItImpl | |
| ►CvtkSMPThreadPool | Internal thread pool implementation used in SMP functions |
| CProxy | Proxy class used to submit work to the thread pool |
| CvtkSMPToolsAPI | |
| CvtkSMPToolsAPIInitialize | |
| CvtkSMPToolsImpl | |
| CAddNames | |
| CAreStaticTupleSizes | |
| Ccan_close_trait | An intermediate trait for exposing a unified trait interface |
| Ccan_close_trait< T, void_t< typename is_closure_trait< T >::rtype > > | |
| Ccan_get_memory_size_trait | Used to check whether the template type has a method named getMemorySize |
| Ccan_get_memory_size_trait< const T > | |
| Ccan_get_memory_size_trait< T * > | |
| Ccan_get_memory_size_trait< T, void_t< decltype(&std::remove_reference< T >::type::getMemorySize)> > | |
| Ccan_map_component_trait | An intermediate trait for exposing a unified trait interface |
| Ccan_map_component_trait< T, void_t< typename has_map_component_trait< T >::rtype > > | |
| Ccan_map_trait | An intermediate trait for exposing a unified trait interface |
| Ccan_map_trait< T, void_t< typename has_map_trait< T >::rtype > > | |
| Ccan_map_tuple_trait | An intermediate trait for exposing a unified trait interface |
| Ccan_map_tuple_trait< T, void_t< typename has_map_tuple_trait< T >::rtype > > | |
| CCollectionIterator | |
| CCollectionRange | |
| CComponentIterator | |
| CComponentReference | |
| CCompositeDataSetIterator | |
| CCompositeDataSetRange | |
| CConstComponentIterator | |
| CConstComponentReference | |
| CConstTupleIterator | |
| CConstTupleIterator< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| CConstTupleReference | |
| CConstTupleReference< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| CConstValueIterator | |
| CConstValueReference | |
| CDataObjectTreeIterator | |
| CDataObjectTreeRange | |
| CGenericTupleSize | |
| CGenericTupleSize< DynamicTupleSize > | |
| CGetAPITypeImpl | |
| CGetAPITypeImpl< vtkDataArray, ForceValueTypeForVtkDataArray > | |
| CGetCollectionItemType | |
| Chas_map_component_trait | Used to check whether the template type has a method named mapComponent |
| Chas_map_component_trait< const T > | |
| Chas_map_component_trait< R(ArgTupIdx, ArgCompIdx)> | |
| Chas_map_component_trait< R(T::*)(ArgTupIdx, ArgCompIdx) const > | |
| Chas_map_component_trait< T * > | |
| Chas_map_component_trait< T, void_t< decltype(&std::remove_reference< T >::type::mapComponent)> > | |
| Chas_map_trait | Used to check whether the template type has a method named map |
| Chas_map_trait< const T > | |
| Chas_map_trait< R(Arg)> | |
| Chas_map_trait< R(T::*)(Arg) const > | |
| Chas_map_trait< T * > | |
| Chas_map_trait< T, void_t< decltype(&std::remove_reference< T >::type::map)> > | |
| Chas_map_tuple_trait | Used to check whether the template type has a method named mapTuple |
| Chas_map_tuple_trait< const T > | |
| Chas_map_tuple_trait< T * > | |
| Chas_map_tuple_trait< T, void_t< decltype(&std::remove_reference< T >::type::mapTuple)> > | |
| Chas_map_tuple_trait< void(ArgIdx, ArgTup *)> | |
| Chas_map_tuple_trait< void(T::*)(ArgIdx, ArgTup *) const > | |
| CIdStorage | |
| Cimplicit_array_traits | A composite trait for handling all the different capabilities a "backend" to an implicit array can have |
| Cis_closure_trait | A trait determining whether an object acts like a mono-variable integer closure |
| Cis_closure_trait< Closure & > | |
| Cis_closure_trait< Closure * > | |
| Cis_closure_trait< Closure, void_t< decltype(&Closure::operator())> > | |
| Cis_closure_trait< const Closure > | |
| Cis_closure_trait< R(*)(Arg)> | |
| Cis_closure_trait< R(Arg)> | |
| Cis_closure_trait< R(Closure::*)(Arg) const > | |
| CIsAOSDataArrayImpl | |
| CIsCollection | |
| CIsComplete | |
| CIsEitherTupleSizeDynamic | |
| CIsStaticTupleSize | |
| CIsValidTupleSize | |
| CIsVtkDataArray | |
| CIterableTraits | |
| Cmake_void | |
| CMTimeWatcher | |
| CName | |
| CNoOpMTimeWatcher | |
| CSelectTupleRange | |
| CSelectValueRange | |
| CStripPointers | |
| CStripPointers< T * > | |
| CStripPointers< vtkNew< ArrayType > > | |
| CStripPointers< vtkSmartPointer< ArrayType > > | |
| CStripPointers< vtkWeakPointer< ArrayType > > | |
| CTupleIterator | |
| CTupleIterator< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| CTupleRange | |
| CTupleRange< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| CTupleReference | |
| CTupleReference< vtkAOSDataArrayTemplate< ValueType >, TupleSize > | |
| CValueIterator | |
| CValueRange | |
| CValueRange< vtkAOSDataArrayTemplate< ValueTypeT >, TupleSize, ForceValueTypeForVtkDataArray > | |
| CValueReference | |
| CCompositeDataSetNodeReference | A reference proxy into a vtkCompositeDataSet, obtained by dereferencing an iterator from the vtk::Range(vtkCompositeDataSet*) overloads |
| CHasSuperclass | Determine whether the provided class (VTKObjectType ) has a parent class |
| CParentClasses | Invoke a functor on the named type and each of its parent types |
| CParentClasses< VTKObjectType, false > | |
| CParentClasses< VTKObjectType, true > | |
| ►NvtkArrayDispatch | |
| CDispatch2ByArray | Dispatch two arrays with the restriction that the type of the first array is in the ArrayList1 TypeList, and the second is in ArrayList2 |
| CDispatch2ByArrayWithSameValueType | 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 |
| CDispatch2BySameValueType | |
| CDispatch2BySameValueTypeUsingArrays | 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 |
| CDispatch2ByValueType | |
| CDispatch2ByValueTypeUsingArrays | Dispatch two arrays, restricting the valid code paths to use ValueType-filtered versions of the application-wide vtkArrayDispatch::Arrays TypeList |
| CDispatch2SameValueTypeUsingArrays | Dispatch two arrays, restricting the valid code paths to use only arrays that have the same ValueType |
| CDispatch3ByArray | 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 |
| CDispatch3ByArrayWithSameValueType | 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 |
| CDispatch3BySameValueType | |
| CDispatch3BySameValueTypeUsingArrays | 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 |
| CDispatch3ByValueType | |
| CDispatch3ByValueTypeUsingArrays | Dispatch three arrays, restricting the valid code paths to use ValueType-filtered versions of the application-wide vtkArrayDispatch::Arrays TypeList |
| CDispatch3SameValueTypeUsingArrays | Dispatch three arrays, restricting the valid code paths to use only arrays that have the same ValueType |
| CDispatchByArray | Dispatch a single array against all array types mentioned in the ArrayList template parameter |
| CDispatchByValueType | |
| CDispatchByValueTypeUsingArrays | 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 |
| CFilterArraysByValueType | Filter the ArrayList to contain only arrays with ArrayType::ValueType that exist in ValueList |
| ►NvtkBlockSortHelper | Collection of comparison functions for std::sort |
| CBackToFront | Operator() for back-to-front sorting |
| ►NvtkCellArray_detail | |
| ►CGetCellAtIdImpl | |
| CCanShareConnPtr | |
| CGetCellSizeImpl | |
| CInsertNextCellImpl | |
| CResetImpl | |
| CUpdateCellCountImpl | |
| ►NvtkDataArrayPrivate | |
| CAllValues | |
| CFiniteValues | |
| ►NvtkGenericDataArrayLookupHelper_detail | |
| Chas_NaN | |
| Chas_NaN< T, false > | |
| Chas_NaN< T, true > | |
| ►NvtkHDFUtilities | Common utility variables and functions for reader and writer of vtkHDF |
| CTemporalGeometryOffsets | |
| CTransientGeometryOffsets | |
| ►NvtkIOSSUtilities | Internal utilities for vtkIOSSReader |
| CCache | Cache |
| CCaptureNonErrorMessages | A helper to instantiate on stack to temporarily redirect non-critical messages emanating from IOSS |
| ►NvtkMatrixUtilities | |
| ►Ndetail | |
| CArrayOrPointerDepth | |
| CArrayOrPointerDepth< MatrixT &, Depth > | |
| CArrayOrPointerDepth< MatrixT *, Depth > | |
| CArrayOrPointerDepth< MatrixT[], Depth > | |
| CArrayOrPointerDepth< MatrixT[N], Depth > | |
| CExtractRawComponentType | |
| CExtractRawComponentType< MatrixT, typename std::enable_if< MatrixIs2DArray< MatrixT >()>::type > | |
| CExtractRawComponentType< MatrixT, typename std::enable_if<!MatrixIs2DArray< MatrixT >()>::type > | |
| CMapper | |
| CMapper< RowsT, ColsT, Layout::Identity > | |
| CMapper< RowsT, ColsT, Layout::Transpose > | |
| CScalarTypeExtractor | |
| CScalarTypeExtractor< 1, ContainerT > | |
| CWrapper | |
| CWrapper< RowsT, ColsT, MatrixT, Layout::Diag, false > | |
| CWrapper< RowsT, ColsT, MatrixT, Layout::Identity, true > | |
| CWrapper< RowsT, ColsT, MatrixT, Layout::Transpose, true > | |
| CWrapper< RowsT, ColsT, MatrixT, LayoutT, false > | |
| CLayout | This struct determines a prior transform to input matrices, changing the way they are indexed |
| CMapper | 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 |
| CScalarTypeExtractor | This class extract the underlying value type of containers |
| CWrapper | Matrix wrapping class |
| ►NvtkParticleTracerBaseNamespace | |
| CParticleInformation_t | |
| CPosition_t | |
| ►NvtkPolyData_detail | |
| CCellMap | |
| CTaggedCellId | |
| ►NvtkThreadedTaskQueueInternals | |
| CResultQueue | |
| CTaskQueue | |
| ►NvtkTypeList | |
| CAppend | Appends type T to TypeList TList and stores the result in Result |
| CCanConvert | Sets member Result to true if a conversion exists to convert type From to type To |
| CDerivedToFront | Sort the TypeList from most-derived to least-derived type, storing the sorted TypeList in Result |
| CErase | Erase the first element of type T from TypeList TList, storing the new list in Result |
| CEraseAll | Erase all type T from TypeList TList, storing the new list in Result |
| CIndexOf | Sets the enum value Result to the index of type T in the TypeList TList |
| CMostDerived | Given a type T and a TypeList TList, store the most derived type of T in TList as Result |
| CNullType | Used to terminate a TypeList |
| CReplace | Replace the first instance of Bad with Good in the TypeList TList, storing the new list in Result |
| CReplaceAll | Replace all instances of Bad with Good in the TypeList TList, storing the new list in Result |
| CSelect | Sets Result to T if Exp is true, or F if Exp is false |
| CTypeList | Generic implementation of TypeList |
| CUnique | Remove all duplicate types from TypeList TList, storing the new list in Result |
| ►Nvtx | |
| ►Nschema | |
| CVTXvtkBase | |
| CVTXvtkVTI | |
| CVTXvtkVTU | |
| ►Ntypes | |
| CDataArray | |
| CVTXSchema | Abstract common class to supported ADIOS2 schemas |
| CVTXSchemaManager | |
| ►Nxr | |
| CConnectionExtensionDispatchTable | |
| CExtensionDispatchTable | |
| CGraphicsExtensionDispatchTable | |
| C_vtkTclVoidFuncArg | |
| CActionFunction | |
| CArrayList | |
| CArrayPair | |
| CArrayPair< vtkStdString > | |
| CBaseArrayPair | |
| CBHLeaf | |
| CBHNode | |
| CBHTree | |
| CCesium3DTilesHeader | |
| CCstring_less | |
| CDatabasePartitionInfo | |
| CEdgeTuple | Definition of an edge tuple |
| CExternalVTKWidget | |
| Cglobal | |
| CGLTFSampler | This struct describes a glTF sampler object |
| Ch | Class to read EnSight Gold files |
| Ch | Distribute cell-centered finite element fields from the input dataset onto vtk cell points |
| Ch | Colapses components with magnitude function |
| Ch | Computes the portion of a dataset which is inside a selection |
| CH5RageAdaptor | |
| CLabelSet | |
| CLabelVector | |
| ►CLSDynaFamily | |
| CLSDynaFamilyAdaptLevel | |
| CLSDynaFamilySectionMark | |
| CLSDynaMetaData | |
| CNativeToVTKType | Type traits for adios2 types(Native types) to vtk types |
| CNativeToVTKType< char > | |
| CNativeToVTKType< double > | |
| CNativeToVTKType< float > | |
| CNativeToVTKType< int16_t > | |
| CNativeToVTKType< int32_t > | |
| CNativeToVTKType< int64_t > | |
| CNativeToVTKType< int8_t > | |
| CNativeToVTKType< uint16_t > | |
| CNativeToVTKType< uint32_t > | |
| CNativeToVTKType< uint64_t > | |
| CNativeToVTKType< uint8_t > | |
| Cnifti_1_header | Data structure defining the fields in the nifti1 header. This binary header should be found at the beginning of a valid NIFTI-1 header file |
| Cnifti_2_header | Data structure defining the fields in the nifti2 header. This binary header should be found at the beginning of a valid NIFTI-2 header file |
| COffsetsManager | Helper class due to PIMPL excess |
| COffsetsManagerArray | |
| COffsetsManagerGroup | |
| 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 | |
| CQFilterTreeProxyModel | |
| CQQmlVTKPlugin | Plugin class to expose a VTK C++ module to QML applications |
| CQQuickVTKInteractiveWidget | QObject that manages a VTK interactive widget to ensure that it behaves as per the QtQuick threaded render loop |
| CQQuickVTKInteractorAdapter | Intermediate class that handles relaying Qt events to VTK |
| CQQuickVTKItem | QQuickItem that manages a VTK rendering in the QML scenegraph |
| CQQuickVTKRenderItem | QQuickItem subclass to render a VTK scene in a QtQuick/QML application |
| CQQuickVTKRenderWindow | QQuickItem subclass that manages the vtkRenderWindow and, in turn, the OpenGL context of the QML application |
| CQTestApp | |
| CQVTKApplication | |
| CQVTKInteractor |
|
| CQVTKInteractorAdapter | |
| CQVTKInteractorInternal | |
| CQVTKOpenGLNativeWidget | QOpenGLWidget subclass to house a vtkGenericOpenGLRenderWindow in a Qt application |
| CQVTKOpenGLStereoWidget | QWidget for displaying a vtkRenderWindow in a Qt Application |
| CQVTKOpenGLWindow | Display a vtkGenericOpenGLRenderWindow in a Qt QOpenGLWindow |
| CQVTKRenderWidget | Generic QWidget for displaying a vtkRenderWindow in a Qt Application |
| CQVTKRenderWindowAdapter | Helper to manage Qt context and other OpenGL components |
| CQVTKTableModelAdapter | An adapter to create a vtkTable from an QAbstractItemModel |
| CQVTKTableModelAdapterTestClass | Class required by TestQVTKTableModelAdapter to run Qt tests involving event loop |
| CRealArrayPair | |
| CRealDescriptor | |
| CReferenceCountModel | |
| CSerialization | |
| CSerialization< std::array< ElementType, N > > | |
| CSerialization< std::map< T1, T2 > > | |
| CSerialization< std::pair< T1, T2 > > | |
| CSerialization< std::set< ElementType > > | |
| CSerialization< std::vector< ElementType > > | |
| CSingleLabelValue | |
| CtagFlashReaderBlock | |
| CtagFlashReaderDoubleScalar | |
| CtagFlashReaderIntegerScalar | |
| CtagFlashReaderSimulationInformation | |
| CtagFlashReaderSimulationParameters | |
| CTestCompositePipeline | Implement TestPipelineInterface |
| CTestMeshPipeline | Implement TestPipelineInterface |
| CTestPipelineInterface | Interface to provide a pipeline utility: |
| CTestVectorFieldSource | |
| CTextPropertyKey | |
| CTreeInformation | Additional information and routines for 3D Tiles octree nodes |
| ►CVrmlNodeType | |
| CFieldRec | |
| CNameTypeRec | |
| Cvtk2DHistogramItem | 2D histogram item |
| Cvtk3DCursorRepresentation | Representation of the vtk3DCursorWidget |
| Cvtk3DCursorWidget | Widget reprensenting a 3D cursor |
| Cvtk3DLinearGridCrinkleExtractor | Fast extraction of cells intersected by a plane |
| Cvtk3DLinearGridInternal | Fast access and processing of 3D linear grids |
| Cvtk3DLinearGridPlaneCutter | Fast plane cutting of vtkUnstructuredGrid containing 3D linear cells |
| Cvtk3DSImporter | Imports 3D Studio files |
| Cvtk3DWidget | Abstract superclass for 3D widgets |
| CVTK_ASSUME | Provide compiler hints for non-obvious conditions |
| CvtkABI | Manage macros for exporting symbols in the binary interface |
| CvtkAbstractArray | Abstract superclass for all arrays |
| CvtkAbstractCellArray | Abstract object to represent cell connectivity |
| CvtkAbstractCellLinks | Abstract base class for classes that build topological links from points to cells |
| CvtkAbstractCellLocator | Abstract base class for locators which find cells |
| CvtkAbstractContextBufferId | 2D array of ids, used for picking |
| CvtkAbstractContextItem | Base class for items that are part of a vtkContextScene |
| CvtkAbstractElectronicData | Provides access to and storage of chemical electronic data |
| CvtkAbstractGridConnectivity | A superclass that defines the interface to be implemented by all concrete grid connectivity classes |
| CvtkAbstractHyperTreeGridMapper | Abstract class for a HyperTreeGrid mapper |
| CvtkAbstractImageInterpolator | Interpolate data values from images |
| CvtkAbstractInteractionDevice | |
| ►CvtkAbstractInterpolatedVelocityField | An abstract class for obtaining the interpolated velocity values at a point |
| CvtkDataSetInformation | |
| CvtkAbstractMapper | Abstract class specifies interface to map data |
| CvtkAbstractMapper3D | Abstract class specifies interface to map 3D data |
| CvtkAbstractParticleWriter | Abstract class to write particle data to file |
| CvtkAbstractPicker | Define API for picking subclasses |
| CvtkAbstractPointLocator | Abstract class to quickly locate points in 3-space |
| CvtkAbstractPolyDataReader | Superclass for algorithms that read models from a file |
| CvtkAbstractPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D while maintaining a fixed orientation w.r.t the camera |
| CvtkAbstractPropPicker | Abstract API for pickers that can pick an instance of vtkProp |
| CvtkAbstractRenderDevice | |
| CvtkAbstractSplineRepresentation | Abstract representation for a spline |
| CvtkAbstractTransform | Superclass for all geometric transformations |
| CvtkAbstractVolumeMapper | Abstract class for a volume mapper |
| CvtkAbstractWidget | Define the API for widget / widget representation |
| CvtkActor | Object (geometry & properties) in a rendered scene |
| CvtkActor2D | Actor that draws 2D data |
| CvtkActor2DCollection | List of 2D actors |
| CvtkActorCollection | Ordered list of actors |
| CvtkActorNode | VtkViewNode specialized for vtkActors |
| CvtkAdaptiveDataSetSurfaceFilter | Adaptively extract dataset surface |
| CvtkAdaptiveResampleToImage | Samples a dataset with adaptive refinements |
| CvtkAdaptiveSubdivisionFilter | Subdivide triangles based on edge and/or area metrics |
| CvtkAdaptiveTemporalInterpolator | Interpolate datasets between time steps to produce a new dataset |
| CvtkAddMembershipArray | Add an array to the output indicating membership within an input selection |
| CvtkADIOS2CoreImageReader | Read ADIOS2 bp files |
| CvtkADIOS2VTXReader | |
| 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 |
| CvtkAdjacentVertexIterator | Iterates through adjacent vertices in a graph |
| CvtkAffineImplicitBackend | A utility structure serving as a backend for affine (as a function of the index) implicit arrays |
| CvtkAffineRepresentation | Abstract class for representing affine transformation widgets |
| CvtkAffineRepresentation2D | Represent 2D affine transformations |
| CvtkAffineWidget | Perform affine transformations |
| CvtkAggregateDataSetFilter | Aggregates data sets to a reduced number of processes |
| CvtkAggregateToPartitionedDataSetCollection | Aggregate results in the vtkEndFor |
| CvtkAlembicExporter | Export a scene into Alembic format |
| CvtkAlgorithm | Superclass for all sources, filters, and sinks in VTK |
| CvtkAlgorithmOutput | Proxy object to connect input/output ports |
| CvtkAlignImageDataSetFilter | Align collection of image datasets to use a global origin |
| CvtkAmoebaMinimizer | Nonlinear optimization with a simplex |
| CvtkAMRBaseParticlesReader | An abstract base class that implements all the common functionality for all particle readers |
| CvtkAMRBaseReader | An abstract class that encapsulates common functionality for all AMR readers |
| CvtkAMRBox | Encloses a rectangular region of voxel like cells |
| 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 |
| ►CvtkAMRDataInternals | Container of vtkUniformGrid for an AMR data set |
| CBlock | |
| CvtkAMRDataSetCache | A concrete implementation of vtkObject that provides functionality for caching AMR blocks |
| CvtkAMREnzoParticlesReader | A concrete instance of the vtkAMRBaseParticlesReader which provides functionality for loading ENZO AMR particle datasets from ENZO |
| CvtkAMREnzoReader | A concrete instance of vtkAMRBaseReader that implements functionality for reading Enzo AMR datasets |
| CvtkAMREnzoReaderInternal | Consists of the low-level Enzo Reader used by the vtkAMREnzoReader |
| CvtkAMReXGridHeader | |
| CvtkAMReXGridLevelHeader | |
| CvtkAMReXGridReader | Reader for AMReX plotfiles grid data |
| CvtkAMReXGridReaderInternal | Consists of the low-level AMReX Reader used by the vtkAMReXGridReader |
| CvtkAMReXParticlesReader | Reader for AMReX plotfiles particle data |
| CvtkAMRFlashParticlesReader | A concrete instance of vtkAMRBaseParticlesReader that implements functionality for reading flash particle datasets |
| CvtkAMRFlashReader | |
| CvtkAMRFlashReaderInternal | Consists of the low-level Flash Reader used by the vtkAMRFlashReader |
| CvtkAMRGaussianPulseSource | A source that generates sample AMR data with gaussian pulse field |
| CvtkAMRInformation | Meta data that describes the structure of an AMR data set |
| CvtkAMRInterpolatedVelocityField | A concrete class for obtaining the interpolated velocity values at a point in AMR data |
| 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 |
| CvtkAMRSliceFilter | A concrete instance of vtkOverlappingAMRAlgorithm which implements functionality for extracting slices from AMR data |
| CvtkAMRToMultiBlockFilter | A filter that accepts as input an AMR dataset and produces a corresponding vtkMultiBlockDataset as output |
| CvtkAMRUtilities | A concrete instance of vtkObject that employs a singleton design pattern and implements functionality for AMR specific operations |
| CvtkAMRVelodyneReader | A concrete instance of vtkAMRBaseReader that implements functionality for reading Velodyne AMR datasets |
| ►CvtkAMRVelodyneReaderInternal | Consists of the low-level Velodyne Reader used by the vtkAMRVelodyneReader |
| CtagVelodyneBlock | |
| CvtkAMRVolumeMapper | AMR class for a volume mapper |
| CvtkAnariActorNode | Links vtkActor and vtkMapper to ANARI |
| CvtkAnariCameraNode | Links vtkCamera to ANARI |
| ►CvtkAnariCompositePolyDataMapperNode | Links vtkActor and vtkMapper to ANARI |
| CRenderBlockState | |
| CvtkAnariDevice | Base class to objects which create + manage a ANARI library + device |
| CvtkAnariFollowerNode | Links vtkFollower to ANARI |
| CvtkAnariLightNode | Links vtkLights to ANARI |
| CvtkAnariPass | Render pass that uses ANARI (ANAlytic Rendering Interface) instead of OpenGL |
| CvtkAnariPolyDataMapperNode | Links vtkActor and vtkMapper to ANARI |
| CvtkAnariProfiling | Allows instrumenting of the VTK ANARI source code |
| CvtkAnariRenderer | Base class to objects which create + manage an ANARI library, device, and renderer |
| CvtkAnariSceneGraph | Links vtkRenderers to ANARI |
| CvtkAnariTestInteractor | |
| CvtkAnariViewNodeFactory | Matches vtk rendering classes to specific ANARI ViewNode classes |
| CvtkAnariVolumeInterface | Removes link dependence on optional ANARI module |
| CvtkAnariVolumeMapper | Standalone ANARI VolumeMapper |
| CvtkAnariVolumeMapperNode | Links vtkVolumeMapper to ANARI |
| CvtkAnariVolumeNode | Links vtkVolume and vtkMapper to ANARI |
| CvtkAndroidOutputWindow | Win32 Specific output window class |
| CvtkAndroidRenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| CvtkAngleRepresentation | Represent the vtkAngleWidget |
| CvtkAngleRepresentation2D | Represent the vtkAngleWidget |
| CvtkAngleRepresentation3D | Represent the vtkAngleWidget |
| CvtkAngleWidget | Measure the angle between two rays (defined by three points) |
| CvtkAngularPeriodicDataArray | Map native an Array into an angulat periodic array |
| CvtkAngularPeriodicFilter | A filter to produce mapped angular periodic multiblock dataset from a single block, by rotation |
| CvtkAnimateModes | Animate mode shapes |
| ►CvtkAnimationCue | Seqin an animation |
| CAnimationCueInfo | |
| CvtkAnimationScene | Animation scene manager |
| CvtkAnnotatedCubeActor | 3D cube with face labels |
| CvtkAnnotation | Stores a collection of annotation artifacts |
| CvtkAnnotationLayers | Stores a ordered collection of annotation sets |
| CvtkAnnotationLayersAlgorithm | Superclass for algorithms that produce only vtkAnnotationLayers as output |
| CvtkAnnotationLink | An algorithm for linking annotations among objects |
| CvtkAnnulus | Implicit function for a annulus |
| CvtkAOSDataArrayTemplate | Array-Of-Structs implementation of vtkGenericDataArray |
| CvtkAppendArcLength | Appends Arc length for input poly lines |
| CvtkAppendCompositeDataLeaves | Appends one or more composite datasets with the same structure together into a single output composite dataset |
| CvtkAppendDataSets | Appends one or more datasets together into a single output vtkPointSet |
| CvtkAppendFilter | Appends one or more datasets together into a single unstructured grid |
| CvtkAppendLocationAttributes | Add point locations to point data and/or cell centers cell data, respectively |
| CvtkAppendPartitionedDataSetCollection | Append partitioned dataset collections |
| CvtkAppendPoints | Appends points of one or more vtkPolyData data sets |
| CvtkAppendPolyData | Appends one or more polygonal datasets together |
| CvtkAppendSelection | Appends one or more selections together |
| CvtkApplyColors | Apply colors to a data set |
| CvtkApplyIcons | Apply icons to a data set |
| CvtkApproximatingSubdivisionFilter | Generate a subdivision surface using an Approximating Scheme |
| CvtkArcGridActorPrivate | Renders a concentric list of arcs on overlay |
| CvtkArchiver | Writes an archive |
| CvtkArcParallelEdgeStrategy | Routes parallel edges as arcs |
| CvtkArcPlotter | Plot data along an arbitrary polyline |
| CvtkArcSource | Create a circular arc |
| CvtkAreaContourSpectrumFilter | Compute an approximation of the area contour signature (evolution of the area of the input surface along an arc of the Reeb graph) |
| CvtkAreaLayout | Layout a vtkTree into a tree map |
| CvtkAreaLayoutStrategy | Abstract superclass for all area layout strategies |
| CvtkAreaPicker | Picks props behind a selection rectangle on a viewport |
| CvtkArray | Abstract interface for N-dimensional arrays |
| CvtkArrayCalculator | Perform mathematical operations on data in field data arrays |
| CvtkArrayCoordinates | Stores coordinate into an N-way array |
| CvtkArrayData | Pipeline data object that contains multiple vtkArray objects |
| CvtkArrayDataAlgorithm | Superclass for algorithms that produce vtkArrayDatas as output |
| CvtkArrayDataReader | Reads vtkArrayData written by vtkArrayDataWriter |
| CvtkArrayDataWriter | Serialize vtkArrayData to a file or stream |
| CvtkArrayDispatch | VtkDataArray code generator/dispatcher |
| CvtkArrayDownCast_impl | 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 |
| CvtkArrayIterator | Abstract superclass to iterate over elements in an vtkAbstractArray |
| CvtkArrayIteratorIncludes | Centralize array iterator type includes required when using the vtkArrayIteratorTemplateMacro |
| CvtkArrayIteratorTemplate | Implementation template for a array iterator |
| CvtkArrayListTemplate | Thread-safe and efficient data attribute processing |
| CvtkArrayNorm | Computes L-norms along one dimension of an array |
| CvtkArrayPrint | Print arrays in different formats |
| CvtkArrayRange | Stores a half-open range of array coordinates |
| CvtkArrayReader | Reads sparse and dense vtkArray data written by vtkArrayWriter |
| CvtkArrayRename | Rename data arrays |
| CvtkArrayRenderer | Render instanced elements textured with arrays from input data |
| CvtkArraySort | Controls sorting of sparse array coordinates |
| CvtkArrayToTable | Converts one- and two-dimensional vtkArrayData objects to vtkTable |
| CvtkArrayWeights | Stores a collection of weighting factors |
| CvtkArrayWriter | Serialize sparse and dense arrays to a file or stream |
| CvtkArrowSource | Appends a cylinder to a cone to form an arrow |
| CvtkASCIITextCodec | Class to read/write ascii text |
| CvtkAssembly | Create hierarchies of vtkProp3Ds (transformable props) |
| CvtkAssemblyNode | Represent a node in an assembly |
| CvtkAssemblyPath | List of nodes that form an assembly path |
| CvtkAssemblyPaths | List of lists of props representing an assembly hierarchy |
| 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 |
| CvtkAssignCoordinatesLayoutStrategy | Uses array values to set vertex locations |
| CvtkAtom | Convenience proxy for vtkMolecule |
| CvtkAtomicMutex | Mutual exclusion locking class using atomic operations |
| CvtkAttributeClustering2DLayoutStrategy | Simple fast 2D graph layout |
| CvtkAttributeDataToFieldDataFilter | Map attribute data to field data |
| CvtkAttributeDataToTableFilter | This filter produces a vtkTable from the chosen attribute in the input data object |
| CvtkAttributesErrorMetric | Objects that compute attribute-based error during cell tessellation |
| CvtkAttributeSmoothingFilter | Smooth mesh point attribute data using distance weighted Laplacian kernel |
| CvtkAutoCorrelativeStatistics | A class for univariate auto-correlative statistics |
| CvtkAvatar | Renders head and hands for a user in VR |
| CvtkAVIWriter | Writes Windows AVI files |
| ►CvtkAVSucdReader | Reads a dataset in AVS "UCD" format |
| CDataInfo | |
| CvtkAxes | Create an x-y-z axes |
| CvtkAxesActor | 3D axes representation |
| CvtkAxesTransformRepresentation | Represent the vtkAxesTransformWidget |
| CvtkAxesTransformWidget | 3D widget for performing 3D transformations around an axes |
| CvtkAxis | Takes care of drawing 2D axes |
| CvtkAxisActor | Create an axis with tick marks and labels |
| CvtkAxisActor2D | Create an axis with tick marks and labels |
| CvtkAxisActor2DMock | Mock vtkAxisActor2D to access inner member for comparison |
| CvtkAxisAlignedReflectionFilter | Reflects the input over an axis-aligned plane |
| CvtkAxisExtended | Extended axis tick positioning |
| CvtkAxisFollower | Subclass of vtkFollower that ensures that data is always parallel to the axis defined by a vtkAxisActor |
| CvtkAxisGridActorPrivate | Renders a 2D grid given pairs of point positions |
| CvtkBackgroundColorMonitor | Tracks state of background color(s) |
| CvtkBalloonRepresentation | Represent the vtkBalloonWidget |
| CvtkBalloonWidget | Popup text balloons above instance of vtkProp when hovering occurs |
| CvtkBandedPolyDataContourFilter | Generate filled contours for vtkPolyData |
| CvtkBarChartActor | Create a bar chart from an array |
| CvtkBase64InputStream | Reads base64-encoded input from a stream |
| CvtkBase64OutputStream | Writes base64-encoded output to a stream |
| CvtkBase64Utilities | Base64 encode and decode utilities |
| CvtkBatch | VtkBatch is a simple structure that holds a begin and end id |
| CvtkBatchedSurfaceLICMapper | Implements batched rendering of multiple vtkPolyData using LIC interface and OpenGL |
| CvtkBatches | |
| CvtkBezierContourLineInterpolator | Interpolates supplied nodes with bezier line segments |
| CvtkBezierCurve | |
| CvtkBezierHexahedron | A 3D cell that represents an arbitrary order Bezier hex |
| CvtkBezierInterpolation | |
| CvtkBezierQuadrilateral | |
| CvtkBezierTetra | A 3D cell that represents an arbitrary order Bezier tetrahedron |
| CvtkBezierTriangle | A 2D cell that represents an arbitrary order Bezier triangle |
| CvtkBezierWedge | A 3D cell that represents an arbitrary order Bezier wedge |
| CvtkBiDimensionalRepresentation | Represent the vtkBiDimensionalWidget |
| CvtkBiDimensionalRepresentation2D | Represent the vtkBiDimensionalWidget |
| CvtkBiDimensionalWidget | Measure the bi-dimensional lengths of an object |
| CvtkBilinearQuadIntersection | Class to perform non planar quad intersection |
| CvtkBillboardTextActor3D | Renders pixel-aligned text, facing the camera, anchored at a 3D point |
| CvtkBinCellDataFilter | Bin source cell data into input cells |
| CvtkBinnedDecimation | Reduce the number of triangles in a vtkPolyData mesh |
| CvtkBiomTableReader | Read vtkTable from a .biom input file |
| 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 |
| CvtkBitArray | Dynamic, self-adjusting array of bits |
| CvtkBitArrayIterator | Iterator for vtkBitArray |
| CvtkBivariateLinearTableThreshold | Performs line-based thresholding for vtkTable data |
| CvtkBlankStructuredGrid | Translate point attribute data into a blanking field |
| CvtkBlankStructuredGridWithImage | Blank a structured grid with an image |
| CvtkBlockDistribution | A helper class that manages a block distribution of N elements of data |
| CvtkBlockIdScalars | Generates scalars from blocks |
| CvtkBlockItem | VtkContextItem that draws a block (optional label) |
| CvtkBlockSelector | Selector for blocks |
| CvtkBlueObeliskData | Contains chemical data from the Blue Obelisk Data Repository |
| CvtkBlueObeliskDataParser | Fill a vtkBlueObeliskData container with data from the BODR XML dataset |
| CvtkBMPReader | Read Windows BMP files |
| CvtkBMPWriter | Writes Windows BMP files |
| CvtkBond | Convenience proxy for vtkMolecule |
| CvtkBooleanOperationPolyDataFilter | Computes the boundary of the union, intersection, or difference volume computed from the volumes defined by two input surfaces |
| CvtkBooleanTexture | Generate 2D texture map based on combinations of inside, outside, and on region boundary |
| CvtkBoostBetweennessClustering | Implements graph clustering based on edge betweenness centrality |
| CvtkBoostBiconnectedComponents | Find the biconnected components of a graph |
| CvtkBoostBrandesCentrality | Compute Brandes betweenness centrality on a vtkGraph |
| CvtkBoostBreadthFirstSearch | Boost breadth_first_search on a vtkGraph |
| CvtkBoostBreadthFirstSearchTree | Constructs a BFS tree from a graph |
| CvtkBoostConnectedComponents | Find the connected components of a graph |
| CvtkBoostDividedEdgeBundling | Layout graph edges in directed edge bundles |
| CvtkBoostExtractLargestComponent | Extract the largest connected component of a graph |
| CvtkBoostKruskalMinimumSpanningTree | Constructs a minimum spanning tree from a graph and the weighting array |
| CvtkBoostLogWeighting | Given an arbitrary-dimension array of doubles, replaces each value x with one of: |
| CvtkBoostPrimMinimumSpanningTree | Constructs a minimum spanning tree from a graph, start node, and the weighting array |
| CvtkBoostRandomSparseArraySource | Generates a sparse N-way array containing random values |
| CvtkBoostSplitTableField | "Splits" one-or-more table fields by duplicating rows containing delimited data |
| CvtkBorderRepresentation | Represent a vtkBorderWidget |
| CvtkBorderWidget | Place a border around a 2D rectangular region |
| CvtkBoundaryMeshQuality | Computes metrics on the boundary faces of a mesh |
| CvtkBoundedPlanePointPlacer | Placer that constrains a handle to a finite plane |
| CvtkBoundedPointSource | Create a random cloud of points within a specified bounding box |
| CvtkBoundingBox | Fast, simple class for representing and operating on 3D bounds |
| CvtkBox | Implicit function for a bounding box |
| CvtkBoxClipDataSet | Clip an unstructured grid |
| CvtkBoxLayoutStrategy | Tree map layout that puts vertices in square-ish boxes |
| CvtkBoxMuellerRandomSequence | Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform |
| CvtkBoxRepresentation | Class defining the representation for the vtkBoxWidget2 |
| CvtkBoxWidget | Orthogonal hexahedron 3D widget |
| CvtkBoxWidget2 | 3D widget for manipulating a box |
| CvtkBreakPoint | Utility function to debug with gdb and MPI |
| CvtkBrokenLineWidget | 3D widget for manipulating a broken line |
| CvtkBrownianPoints | Assign random vector to points |
| CvtkBrush | Brush that fills shapes drawn by vtkContext2D |
| CvtkBSPCuts | This class represents an axis-aligned Binary Spatial Partitioning of a 3D space |
| CvtkBSPIntersections | Perform calculations (mostly intersection calculations) on regions of a 3D binary spatial partitioning |
| CvtkBSplineTransform | Cubic b-spline deformation transformation |
| CvtkBTSReader | Class to read bts files used by Engys software |
| CvtkBuffer | Internal storage class used by vtkSOADataArrayTemplate, vtkAOSDataArrayTemplate, and others |
| CvtkBufferedArchiver | Writes an archive to a buffer for vtk-js datasets |
| CvtkButterflySubdivisionFilter | Generate a subdivision surface using the Butterfly Scheme |
| CvtkButtonRepresentation | Abstract class defines the representation for a vtkButtonWidget |
| CvtkButtonSource | Abstract class for creating various button types |
| CvtkButtonWidget | Activate an n-state button |
| CvtkByteSwap | Perform machine dependent byte swapping |
| CvtkBYUReader | Read MOVIE.BYU polygon files |
| CvtkBYUWriter | Write MOVIE.BYU files |
| CvtkCachedStreamingDemandDrivenPipeline | VtkCachedStreamingDemandDrivenPipeline |
| CvtkCallbackCommand | Supports function callbacks |
| CvtkCamera | Virtual camera for 3D rendering |
| CvtkCamera3DRepresentation | Class defining the representation for the vtkCamera3DWidget |
| CvtkCamera3DWidget | 3D Widget for manipulating a vtkCamera |
| CvtkCameraActor | Frustum to represent a camera |
| CvtkCameraHandleSource | Handle source used to represent one camera |
| CvtkCameraInterpolator | Interpolate a series of cameras to update a new camera |
| CvtkCameraNode | VtkViewNode specialized for vtkCameras |
| CvtkCameraOrientationRepresentation | A 3D representation for vtkCameraOrientationWidget |
| CvtkCameraOrientationWidget | A widget to manipulate vtkCameraOrientationWidget |
| CvtkCameraPass | Implement the camera render pass |
| CvtkCameraPathRepresentation | Representation for a camera path |
| CvtkCameraPathWidget | Widget for vtkCameraPathRepresentation |
| CvtkCameraRepresentation | Represent the vtkCameraWidget |
| CvtkCameraWidget | 2D widget for saving a series of camera views |
| CvtkCapsuleSource | Generate a capsule centered at the origin |
| CvtkCaptionActor2D | Draw text label associated with a point |
| CvtkCaptionRepresentation | VtkCaptionWidget in the scene |
| CvtkCaptionWidget | Widget for placing a caption (text plus leader) |
| CvtkCardinalSpline | Computes an interpolating spline using a a Cardinal basis |
| CvtkCastToConcrete | Works around type-checking limitations |
| CvtkCategoryLegend | Legend item to display categorical data |
| CvtkCell | Abstract class to specify cell behavior |
| CvtkCell3D | Abstract class to specify 3D cell interface |
| ►CvtkCellArray | Object to represent cell connectivity |
| ►CStorage | |
| CArraySwitch | |
| CVisitState | |
| CvtkCellArrayIterator | Encapsulate traversal logic for vtkCellArray |
| ►CvtkCellAttribute | A function defined over the physical domain of a vtkCellGrid |
| CCellTypeInfo | |
| CvtkCellAttributeCalculator | Perform a per-cell calculation on a vtkCellAttribute |
| CvtkCellAttributeInformation | Provide information about a cell attribute's basis functions on one cell type |
| CvtkCellCenterDepthSort | A simple implementation of vtkCellDepthSort |
| CvtkCellCenters | Generate points at center of cells |
| CvtkCellCentersPointPlacer | Snaps points at the center of a cell |
| CvtkCellData | Represent and manipulate cell attribute data |
| CvtkCellDataToPointData | Map cell data to point data |
| CvtkCellDerivatives | Compute derivatives of scalars and vectors |
| CvtkCellDistanceSelector | Grows a selection, selecting neighbor cells, up to a user defined topological distance |
| ►CvtkCellGraphicsPrimitiveMap | Maps cell connectivity and offsets from VTK data model into primitives that graphics libraries expect (points, lines and triangles) |
| CCellTypeMapperOffsets | |
| CPrimitiveDescriptor | |
| CvtkCellGrid | Visualization data composed of cells of arbitrary type |
| CvtkCellGridAlgorithm | Superclass for algorithms that produce only polydata as output |
| CvtkCellGridBoundsQuery | Compute the geometric bounds of a cell-grid |
| ►CvtkCellGridCellCenters | Output a vertex cell at the center of each input cell |
| CQuery | A query corresponding to this algorithm |
| ►CvtkCellGridCellSource | Create a cell-grid with one or more cells of the requested type |
| CQuery | A cell-grid query used by this filter |
| CvtkCellGridComputeSides | Generate sides of input data (cells and/or sides) based on a strategy |
| CvtkCellGridCopyQuery | Copy the cell metadata and attribute(s) of one cell-grid into another |
| CvtkCellGridElevation | Adds a cell attribute representing elevation |
| CvtkCellGridElevationQuery | A cell-grid query for creating an "elevation" field |
| ►CvtkCellGridEvaluator | Evaluate a field (vtkCellAttribute) at some points inside cells |
| CAllocationsByCellType | Hold per-type input point assignment and an offset for output arrays |
| CvtkCellGridIOQuery | Serialize/deserialize vtkCellMetadata records |
| CvtkCellGridMapper | Map a vtkCellGrid to graphics primitives |
| CvtkCellGridPointProbe | Probe a vtkCellGrid with points |
| CvtkCellGridQuery | Perform an operation on cells in a vtkCellMetadata instance |
| ►CvtkCellGridRangeQuery | Compute the range of a component of some vtkCellAttribute |
| CComponentRange | Store the finite/entire range for a single component of a cell-attribute |
| CvtkCellGridReader | Read a cell-grid file |
| ►CvtkCellGridRenderRequest | State used by vtkCellGridMapper during rendering |
| CBaseState | |
| CvtkCellGridResponder | Respond to a query on one particular type of cell |
| CvtkCellGridResponderBase | 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 |
| CCalculatorForTagSet | A record of a registered calculator along with the tags it requires and values of those tags it will accept |
| ►CvtkCellGridSidesCache | Hold a map from hash-ids (representing sides of cells of multiple types) to details on the cells that claim the corresponding side |
| CEntry | Each hash entry corresponds to one or more sides of one or more cells |
| CSide | Records held by a hash-entry that represent the side of one cell |
| ►CvtkCellGridSidesQuery | A cell-grid query for enumerating sides of cells |
| CSideSetArray | A structure created by the GetSideSetArrays() method for responders to use |
| ►CvtkCellGridToUnstructuredGrid | Create an unstructured grid that approximates a cell-grid |
| ►CQuery | A query corresponding to this algorithm |
| COutputAllocation | A placeholder for space to be occupied in a vtkCellArray |
| ►CvtkCellGridTransform | Transform points and associated normals and vectors |
| CQuery | A cell-grid query for applying a transform to a cell-grid |
| ►CvtkCellGridWarp | Create a deformed copy of the input |
| CQuery | Cell-grid query used to apply deformations to an input shape attribute |
| CvtkCellGridWriter | Write a cell-grid file |
| CvtkCellIterator | Efficient cell iterator for vtkDataSet topologies |
| ►CvtkCellLinks | Object represents upward pointers from points to list of cells using each point |
| CLink | |
| ►CvtkCellLocator | Octree-based spatial search object to quickly locate cells |
| CvtkNeighborCells | |
| CvtkCellLocatorStrategy | Implement a specific vtkPointSet::FindCell() strategy based on using a cell locator |
| CvtkCellMetadata | Metadata for a particular type of cell (finite element) |
| CvtkCellPicker | Ray-cast cell picker for all kinds of Prop3Ds |
| CvtkCellQuality | Calculate functions of quality of the elements of a mesh |
| CvtkCellSizeFilter | Computes cell sizes |
| CvtkCellTreeLocator | This class implements the data structures, construction algorithms for fast cell location |
| CvtkCellType | Define types of cells |
| CvtkCellTypes | Object provides direct access to cells in vtkCellArray and type information |
| CvtkCellTypeSource | Create cells of a given type |
| CvtkCellValidator | Validates cells in a dataset |
| CvtkCenteredSliderRepresentation | Provide the representation for a vtkCenteredSliderWidget |
| CvtkCenteredSliderWidget | Set a value by manipulating a slider |
| CvtkCenterOfMass | Find the center of mass of a set of points |
| CvtkCesium3DTilesReader | Reads a Cesium 3D Tiles tileset |
| CvtkCesium3DTilesWriter | Writes a dataset into 3D Tiles format |
| CvtkCesiumB3DMReader | Read a CesiumB3DM file |
| CvtkCesiumPointCloudWriter | Export a vtkPointSet into a Cesium Point Cloud (PNTS) tile format |
| CvtkCGMWriter | Write polygonal data as a CGM file |
| CvtkCGNSCache | |
| 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 |
| CvtkCGNSReaderInternal | |
| CvtkChacoGraphReader | Reads chaco graph files |
| CvtkChacoReader | Read a Chaco file and create a vtkUnstructuredGrid |
| CvtkCharArray | Dynamic, self-adjusting array of char |
| ►CvtkChart | Factory class for drawing 2D charts |
| CMouseActions | Hold mouse action mappings |
| CMouseClickActions | |
| CvtkChart2DHistogram | Chart for 2D histograms |
| CvtkChartBox | Factory class for drawing box plot charts |
| CvtkChartBoxData | Small struct used by InvokeEvent to send some information about the point that was clicked on |
| CvtkChartHistogram2D | |
| CvtkChartLegend | Draw the chart legend |
| CvtkChartMatrix | Container for a matrix of charts |
| CvtkChartParallelCoordinates | Factory class for drawing 2D charts |
| CvtkChartPie | Factory class for drawing pie charts |
| CvtkChartPlotData | Small struct used by InvokeEvent to send some information about the point that was clicked on |
| CvtkChartXY | Factory class for drawing XY charts |
| CvtkChartXYZ | Factory class for drawing 3D XYZ charts |
| CvtkCheckerboardRepresentation | Represent the vtkCheckerboardWidget |
| CvtkCheckerboardSplatter | Splat points into a volume with an elliptical, Gaussian distribution |
| CvtkCheckerboardWidget | Interactively set the number of divisions in 2D image checkerboard |
| CvtkCirclePackFrontChainLayoutStrategy | Layout a vtkTree into packed circles using the front chain algorithm |
| CvtkCirclePackLayout | Layout a vtkTree as a circle packing |
| CvtkCirclePackLayoutStrategy | Abstract superclass for all circle packing layout strategies |
| CvtkCirclePackToPolyData | Converts a tree to a polygonal data representing a circle packing of the hierarchy |
| CvtkCircularLayoutStrategy | Places vertices around a circle |
| CvtkCityGMLReader | Read CityGML data file |
| CvtkCleanArrays | Filter used to remove partial arrays across processes |
| CvtkCleanPolyData | Merge duplicate points, and/or remove unused points and/or remove degenerate cells |
| CvtkCleanUnstructuredGrid | Merge duplicate points |
| CvtkCleanUnstructuredGridCells | Remove duplicate/degenerate cells |
| 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 |
| CvtkClientServerSynchronizedRenderers | VtkClientServerSynchronizedRenderers is a vtkSynchronizedRenderers subclass designed to be used in 2 processes, client-server mode |
| CvtkClientSocket | Encapsulates a client socket |
| CvtkClipClosedSurface | Clip a closed surface with a plane collection |
| CvtkClipConvexPolyData | Clip any dataset with user-specified implicit function or input scalar data |
| CvtkClipDataSet | 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 |
| CvtkClipVolume | Clip volume data with user-specified implicit function or input scalar data |
| CvtkClosedSurfacePointPlacer | PointPlacer to constrain validity within a set of convex planes |
| CvtkClosestNPointsStrategy | Implement a specific vtkPointSet::FindCell() strategy based on the N closest points |
| CvtkClosestPointStrategy | Implement a specific vtkPointSet::FindCell() strategy based on closest point |
| CvtkClustering2DLayoutStrategy | Simple fast 2D graph layout |
| CvtkCMLMoleculeReader | Read a CML file and output a vtkMolecule object |
| CvtkCocoaGLView | Cocoa OpenGL rendering context |
| CvtkCocoaMacOSXSDKCompatibility | Compatibility header |
| CvtkCocoaRenderWindow | Cocoa OpenGL rendering window |
| CvtkCocoaRenderWindowInteractor | Implements Cocoa specific functions required by vtkRenderWindowInteractor |
| CvtkCocoaTkUtilities | Internal Tk Routines for Cocoa |
| CvtkCoincidentPoints | Octree of labels |
| CvtkCollapseGraph | "Collapses" vertices onto their neighbors |
| CvtkCollapseVerticesByArray | Collapse the graph given a vertex array |
| CvtkCollectGraph | Collect distributed graph |
| CvtkCollection | Create and manipulate ordered lists of objects |
| CvtkCollectionElement | |
| CvtkCollectionIterator | Iterator through a vtkCollection |
| CvtkCollectPolyData | Collect distributed polydata |
| CvtkCollectTable | Collect distributed table |
| CvtkCollisionDetectionFilter | Performs collision determination between two polyhedral surfaces |
| CvtkColor | Templated type for storage of colors |
| CvtkColor3 | |
| CvtkColor3d | |
| CvtkColor3f | |
| CvtkColor3ub | Some derived classes for the different colors commonly used |
| CvtkColor4 | |
| CvtkColor4d | |
| CvtkColor4f | |
| CvtkColor4ub | |
| CvtkColorLegend | Legend item to display vtkScalarsToColors |
| CvtkColorSeries | Stores a list of colors |
| CvtkColorTransferControlPointsItem | Control points for vtkColorTransferFunction |
| CvtkColorTransferFunction | Defines a transfer function for mapping a property to an RGB color value |
| CvtkColorTransferFunctionItem | |
| CvtkCommand | Superclass for callback/observer methods |
| CvtkCommonInformationKeyManager | Manages key types in vtkCommon |
| ►CvtkCommunicator | Used to send/receive messages in a multiprocess environment |
| COperation | A custom operation to use in a reduce command |
| 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 |
| CvtkCompassRepresentation | Provide a compass and distance, tilt sliders |
| CvtkCompassWidget | Widget to set distance, tilt and heading |
| CvtkCompositeCellGridMapper | Class that renders hierarchical cell-grid data |
| ►CvtkCompositeCellGridReader | Read a cell-grid file |
| CFileGroup | |
| CvtkCompositeControlPointsItem | Control points for vtkCompositeFunction |
| CvtkCompositeCutter | Cut composite data sets with user-specified implicit function |
| CvtkCompositeDataDisplayAttributes | Rendering attributes for a multi-block dataset |
| CvtkCompositeDataDisplayAttributesLegacy | Rendering attributes for a multi-block dataset |
| CvtkCompositeDataGeometryFilter | Extract geometry from multi-group data |
| CvtkCompositeDataIterator | Superclass for composite data iterators |
| CvtkCompositeDataPipeline | Executive supporting composite datasets |
| CvtkCompositeDataProbeFilter | Subclass of vtkProbeFilter which supports composite datasets in the input |
| CvtkCompositeDataReader | Read vtkCompositeDataSet data file |
| CvtkCompositeDataSet | Abstract superclass for composite (multi-block or AMR) datasets |
| CvtkCompositeDataSetAlgorithm | Superclass for algorithms that produce only vtkCompositeDataSet as output |
| CvtkCompositeDataWriter | Legacy VTK file writer for vtkCompositeDataSet subclasses |
| CvtkCompositedSynchronizedRenderers | VtkCompositedSynchronizedRenderers is vtkSynchronizedRenderers that uses vtkCompositer to composite the images on the root node |
| CvtkCompositeImplicitBackend | A utility structure serving as a backend for composite arrays: an array composed of multiple arrays concatenated together |
| ►CvtkCompositeInterpolatedVelocityField | An abstract class for obtaining the interpolated velocity values at a point |
| CDataSetBoundsInformation | |
| CvtkCompositeMapperHelper2 | Helper class for vtkCompositePolyDataMapper2 that is a subclass of vtkOpenGLPolyDataMapper |
| CvtkCompositeMapperHelperData | |
| CvtkCompositePolyDataMapper | Class that renders hierarchical polygonal data |
| ►CvtkCompositePolyDataMapper2 | Mapper for composite dataset consisting of polygonal data |
| CRenderBlockState | |
| ►CvtkCompositePolyDataMapperDelegator | Delegates rendering of multiple polydata that share similar signatures |
| CBatchElement | |
| CvtkCompositer | Super class for composite algorithms |
| CvtkCompositeRenderManager | An object to control sort-last parallel rendering |
| CvtkCompositeRGBAPass | Blend RGBA buffers of processes |
| CvtkCompositeSurfaceLICMapper | Mapper for composite dataset |
| CvtkCompositeSurfaceLICMapperDelegator | Delegates rendering to vtkBatchedSurfaceLICMapper |
| CvtkCompositeTransferFunctionItem | |
| CvtkCompositeZPass | Merge depth buffers of processes |
| CvtkCompressCompositer | Implements compressed tree based compositing |
| CvtkComputeHistogram2DOutliers | Compute the outliers in a set of 2D histograms and extract the corresponding row data |
| 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 |
| CvtkConduitArrayUtilities | Helper to convert Conduit arrays to VTK arrays |
| CvtkConduitSource | Data source for Conduit Mesh Blueprint |
| CvtkConduitToDataObject | Convert conduit node to VTK data objects |
| CvtkCone | Implicit function for a cone |
| CvtkConeLayoutStrategy | Produce a cone-tree layout for a forest |
| CvtkConeSource | Generate polygonal cone |
| CvtkConnectedPointsFilter | Extract / segment points based on geometric connectivity |
| CvtkConnectivityFilter | Extract data based on geometric connectivity |
| CvtkConstantImplicitBackend | A utility structure serving as a backend for constant implicit arrays |
| CvtkConstrained2DLayoutStrategy | Simple fast 2D graph layout that looks for a 'constraint' array (vtkDoubleArray) |
| CvtkConstrainedPointHandleRepresentation | Point representation constrained to a 2D plane |
| CvtkConstrainedSmoothingFilter | Adjust point positions using constrained smoothing |
| CvtkConsumerDataFilter | Simple filter that will be our cache consummer |
| CvtkContext2D | Class for drawing 2D primitives to a graphical context |
| CvtkContext3D | Class for drawing 3D primitives to a graphical context |
| CvtkContextActor | VtkProp derived object |
| CvtkContextArea | Clipped, transformed area with axes for context items |
| CvtkContextClip | All children of this item are clipped by the specified area |
| CvtkContextDevice2D | Abstract class for drawing 2D primitives |
| CvtkContextDevice3D | Abstract class for drawing 3D primitives |
| CvtkContextInteractorStyle | An interactor for chart views |
| CvtkContextItem | Base class for items that are part of a vtkContextScene |
| CvtkContextKeyEvent | Data structure to represent key events |
| CvtkContextMapper2D | Abstract class for 2D context mappers |
| CvtkContextMouseEvent | Data structure to represent mouse events |
| CvtkContextPolygon | |
| CvtkContextScene | Provides a 2D scene for vtkContextItem objects |
| CvtkContextScenePrivate | Private implementation for scene/items |
| CvtkContextTransform | All children of this item are transformed by the vtkTransform2D of this item |
| CvtkContextView | View of the vtkContextScene |
| CvtkContingencyStatistics | A class for bivariate correlation contigency tables, conditional probabilities, and information entropy |
| 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 |
| CvtkContinuousValueWidget | Set a value by manipulating something |
| CvtkContinuousValueWidgetRepresentation | Provide the representation for a continuous value |
| CvtkContour3DLinearGrid | Fast generation of isosurface from 3D linear cells |
| CvtkContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkContourGrid | Generate isosurfaces/isolines from scalar values (specialized for unstructured grids) |
| CvtkContourHelper | A utility class used by various contour filters |
| CvtkContourLineInterpolator | Defines API for interpolating/modifying nodes from a vtkContourRepresentation |
| CvtkContourLoopExtraction | Extract closed loops (polygons) from lines and polylines |
| CvtkContourRepresentation | Represent the vtkContourWidget |
| CvtkContourRepresentationInternals | |
| CvtkContourRepresentationNode | |
| CvtkContourRepresentationPoint | |
| CvtkContourTriangulator | Fill all 2D contours to create polygons |
| CvtkContourValues | Helper object to manage setting and generating contour values |
| CvtkContourWidget | Create a contour with a set of points |
| CvtkControlPointsItem | Abstract class for control points items |
| CvtkCONVERGECFDCGNSReader | Reader for CONVERGECFD CGNS post files |
| CvtkCONVERGECFDReader | Reader for CONVERGE CFD post files |
| CvtkConvertSelection | Convert a selection from one type to another |
| CvtkConvertSelectionDomain | Convert a selection from one domain to another |
| CvtkConvertToMultiBlockDataSet | Converts any data type into a vtkMultiBlockDataSet |
| CvtkConvertToPartitionedDataSetCollection | Convert any dataset to vtkPartitionedDataSetCollection |
| CvtkConvertToPointCloud | Convert any dataset to a point cloud |
| CvtkConvertToPolyhedra | Convert 3D linear cells to vtkPolyhedra |
| CvtkConvexHull2D | Produce filled convex hulls around a set of points |
| CvtkConvexPointSet | 3D cell defined by a set of convex points |
| CvtkCookieCutter | Cut vtkPolyData defined on the 2D plane with one or more polygons |
| CvtkCoordinate | Perform coordinate transformation, and represent position, in a variety of vtk coordinate systems |
| CvtkCoordinateFrame | Implicit function for a right-handed coordinate system |
| CvtkCoordinateFrameRepresentation | Class defining the representation for a vtkCoordinateFrameWidget |
| CvtkCoordinateFrameWidget | 3D widget for manipulating a display sized coordinate frame widget |
| CvtkCornerAnnotation | Text annotation in four corners |
| CvtkCorrelativeStatistics | A class for bivariate linear correlation |
| CvtkCosmicTreeLayoutStrategy | Tree layout strategy reminiscent of astronomical systems |
| 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 |
| CvtkCPExodusIIElementBlock | Uses an Exodus II element block as a vtkMappedUnstructuredGrid's implementation |
| CvtkCPExodusIIElementBlockCellIterator | VtkCellIterator subclass specialized for vtkCPExodusIIElementBlock |
| CvtkCPExodusIIElementBlockImpl | |
| CvtkCPExodusIIInSituReader | Read an Exodus II file into data structures that map the raw arrays returned by the Exodus II library into a multi-block data set containing vtkUnstructuredGridBase subclasses |
| CvtkCPExodusIINodalCoordinatesTemplate | Map native Exodus II coordinate arrays into the vtkDataArray interface |
| CvtkCPExodusIIResultsArrayTemplate | Map native Exodus II results arrays into the vtkDataArray interface |
| CvtkCriticalTime | Compute time step at which a threshold value has been reached |
| CvtkCubeAxesActor | Create a plot of a bounding box edges - used for navigation |
| CvtkCubeAxesActor2D | Create a 2D plot of a bounding box edges - used for navigation |
| CvtkCubeSource | Create a polygonal representation of a cube |
| CvtkCubicLine | Cell represents a cubic , isoparametric 1D line |
| CvtkCuller | Superclass for prop cullers |
| CvtkCullerCollection | Ordered list of Cullers |
| CvtkCursor2D | Generate a 2D cursor representation |
| CvtkCursor3D | Generate a 3D cursor representation |
| CvtkCurvatures | Compute curvatures (Gauss and mean) of a Polydata object |
| CvtkCurveRepresentation | Base class for a widget that represents a curve that connects control points |
| CvtkCutMaterial | Automatically computes the cut plane for a material array pair |
| CvtkCutter | Cut vtkDataSet with user-specified implicit function |
| CvtkCylinder | Implicit function for a cylinder |
| CvtkCylinderSource | Generate a polygonal cylinder centered at the origin |
| CvtkCylindricalTransform | Cylindrical to rectangular coords and back |
| CvtkDataArray | Abstract superclass for arrays of numeric data |
| CvtkDataArrayAccessor | Efficient templated access to vtkDataArray |
| CvtkDataArrayAccessor< vtkDataArray > | |
| CvtkDataArrayCollection | Maintain an ordered list of dataarray objects |
| CvtkDataArrayCollectionIterator | Iterator through a vtkDataArrayCollection |
| 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 |
| CvtkDatabaseToTableReader | Read an SQL table as a vtkTable |
| CvtkDataCompressor | Abstract interface for data compression classes |
| CvtkDataEncoder | Class used to compress/encode images using threads |
| CvtkDataObject | General representation of visualization data |
| CvtkDataObjectAlgorithm | Superclass for algorithms that produce only data object as output |
| CvtkDataObjectCollection | Maintain an unordered list of data objects |
| CvtkDataObjectGenerator | Produces simple (composite or atomic) data sets for testing |
| CvtkDataObjectImplicitBackendInterface | A utility structure that can be used as a base for implicit array backend that relies on a vtkDataObject |
| ►CvtkDataObjectMeshCache | VtkDataObjectMeshCache is a class to store and reuse the mesh of a vtkDataSet, while forwarding data arrays from another dataset |
| CStatus | Structure to handle the current cache status |
| CvtkDataObjectReader | Read vtk field data file |
| CvtkDataObjectToConduit | Convert VTK Data Object to Conduit Node |
| CvtkDataObjectToDataSetFilter | Map field data to concrete dataset |
| CvtkDataObjectToTable | Extract field data as a table |
| CvtkDataObjectTree | Implementation for most abstract methods in the superclass vtkCompositeDataSet |
| CvtkDataObjectTreeIndex | |
| CvtkDataObjectTreeInternals | |
| CvtkDataObjectTreeItem | |
| CvtkDataObjectTreeIterator | Superclass for composite data iterators |
| CvtkDataObjectTypes | |
| CvtkDataObjectWriter | Write vtk field data |
| CvtkDataReader | Helper superclass for objects that read vtk data files |
| CvtkDataRepresentation | The superclass for all representations |
| CvtkDataSet | Abstract class to specify dataset behavior |
| CvtkDataSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| CvtkDataSetAttributes | Represent and manipulate attribute data in a dataset |
| CvtkDataSetAttributesFieldList | Helps manage arrays from multiple vtkDataSetAttributes |
| CvtkDataSetCellIterator | Implementation of vtkCellIterator using vtkDataSet API |
| CvtkDataSetCollection | Maintain an unordered list of dataset objects |
| CvtkDataSetEdgeSubdivisionCriterion | Subclass of vtkEdgeSubdivisionCriterion for vtkDataSet objects |
| CvtkDataSetGradient | Computes scalar field gradient |
| CvtkDataSetGradientPrecompute | Computes a geometry based vector field that the DataSetGradient filter uses to accelerate gradient computation |
| CvtkDataSetMapper | Map vtkDataSet and derived classes to graphics primitives |
| CvtkDataSetReader | Class to read any type of vtk dataset |
| CvtkDataSetRegionSurfaceFilter | Extract surface of materials |
| CvtkDataSetSurfaceFilter | Extracts outer surface (as vtkPolyData) of any dataset |
| CvtkDataSetToDataObjectFilter | Map dataset into data object (i.e., a field) |
| CvtkDataSetTriangleFilter | Triangulate any type of dataset |
| CvtkDataSetWriter | Write any type of vtk dataset to file |
| CvtkDataTransferHelper | Helper class that aids in transferring data between CPU memory and GPU memory |
| CvtkDataWriter | Helper class for objects that write VTK data files |
| CvtkDateToNumeric | Converts string dates to numeric values |
| CvtkDebugLeaks | Identify memory leaks at program termination vtkDebugLeaks is used to report memory leaks at the exit of the program |
| CvtkDebugLeaksManager | Manages the vtkDebugLeaks singleton |
| CvtkDebugLeaksObserver | |
| 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 |
| CvtkDecimatePolylineFilter | Reduce the number of lines in a polyline |
| CvtkDecimatePolylineStrategy | Abstract class to define a decimation strategy for the vtkDecimatePolylineFilter |
| ►CvtkDecimatePro | Reduce the number of triangles in a mesh |
| CLocalTri | |
| CLocalVertex | |
| CTriArray | |
| CVertexArray | |
| CvtkDefaultPass | Implement the basic render passes |
| CvtkDeflectNormals | Deflect normals using a 3 component vector field |
| CvtkDeformPointSet | Use a control polyhedron to deform an input vtkPointSet |
| CvtkDelaunay2D | Create 2D Delaunay triangulation of input points |
| CvtkDelaunay3D | Create 3D Delaunay triangulation of input points |
| CvtkDelimitedTextCodecIteratorPrivate | Implements vtkTextCodec::OutputIterator to fill a vtkTable from text input |
| CvtkDelimitedTextReader | Reads in delimited ascii or unicode text files and outputs a vtkTable data structure |
| CvtkDelimitedTextWriter | Delimited text writer for vtkTable Writes a vtkTable as a delimited text file (such as CSV) |
| CvtkDemandDrivenPipeline | Executive supporting on-demand execution |
| CvtkDEMReader | Read a digital elevation model (DEM) file |
| ►CvtkDendrogramItem | A 2D graphics item for rendering a tree as a dendrogram |
| CCompareWeightedVertices | |
| CWeightedVertex | |
| ►CvtkDenseArray | Contiguous storage for N-way arrays |
| CHeapMemoryBlock | MemoryBlock implementation that manages internally-allocated memory using new[] and delete[] |
| CMemoryBlock | Strategy object that contains a block of memory to be used by vtkDenseArray for value storage |
| CStaticMemoryBlock | MemoryBlock implementation that manages a static (will not be freed) memory block |
| CvtkDensifyPointCloudFilter | Add points to a point cloud to make it denser |
| CvtkDensifyPolyData | Densify the input by adding points at the centroid |
| CvtkDepthImageProcessingPass | Convenient class for post-processing passes |
| CvtkDepthImageToPointCloud | Convert a depth image into a point cloud |
| CvtkDepthOfFieldPass | Implement a post-processing DOF blur pass |
| CvtkDepthPeelingPass | Implement Depth Peeling for use within a framebuffer pass |
| CvtkDepthSortPolyData | Sort poly data along camera view direction |
| CvtkDeRhamCell | Base class for cells that form 2-d or 3-d DeRham complexes |
| CvtkDescriptiveStatistics | A class for univariate descriptive statistics |
| CvtkDeserializer | Deserialize VTK objects from JSON |
| ►CvtkDGArrayOutputAccessor | Store values interpolated from DG cells into a vtkDoubleArray instance |
| CTuple | Expose a tuple in a vtkDoubleArray as an object with a size() method to satisfy requirements of the output iterator API |
| CvtkDGArraysInputAccessor | Evaluate DG cells whose indices and parameters are provided by vtkDataArray instances |
| CvtkDGAttributeInformation | Provide information about a cell attribute's basis functions on one cell type |
| CvtkDGBoundsResponder | Respond to a query on one particular type of cell |
| ►CvtkDGCell | Base class for a discontinuous Galerkin cells of all shapes |
| CSource | Records describing the source arrays for cells or cell-sides |
| CvtkDGCellCenterResponder | Respond to a query on one particular type of cell |
| CvtkDGCellSourceResponder | Respond to a query on one particular type of cell |
| CvtkDGCopyResponder | Copy data from one vtkCellGrid to another |
| CvtkDGEdge | Metadata for a discontinuous Galerkin triangle |
| CvtkDGElevationResponder | Respond to a query on one particular type of cell |
| CvtkDGEvaluator | Classify world points, evaluate cell parameters, and interpolate attributes |
| CvtkDGHex | Metadata for a discontinuous Galerkin hexahedron |
| CvtkDGInterpolateCalculator | Calculate field values at a point in a cell's parametric space |
| CvtkDGIOResponder | Read/write metadata specific to discontinuous Galerkin cells |
| ►CvtkDGOperation | Invoke an operator on DG cells/sides |
| CWorker | A vtkSMPTools worker class for evaluating an operation across a range of cells |
| ►CvtkDGOperationBase | A base class for operator evaluators |
| CRangeKey | A range of cell IDs handled by a vtkDGCell::Source instance |
| CvtkDGOperationEvaluator | Evaluate a vtkDGOperationEntry on a provided cell ID at provided parametric coordinates |
| CvtkDGOperationState | Encapsulate the state required to evaluate DG cell-attributes |
| CvtkDGOperationStateEntry | Encapsulate the state required to evaluate DG cell-attributes |
| 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 |
| CvtkDGOperatorEntry | A record for a basis in a function space that is specific to one cell shape |
| CvtkDGPyr | Metadata for a discontinuous Galerkin pyramid |
| CvtkDGQuad | Metadata for a discontinuous Galerkin quadrilateral |
| CvtkDGRangeResponder | Compute the range of a cell-attribute over any vtkDGCell |
| ►CvtkDGRenderResponder | Rendering simple DG cells (i.e., those with a fixed reference shape) |
| CCacheEntry | Entries for a cache of render-helpers |
| CvtkDGSidesResponder | Compute the sides on the outside surface of a collection of DG cells |
| CvtkDGTet | Metadata for a discontinuous Galerkin tetrahedron |
| CvtkDGTranscribeCellGridCells | Respond to a query on one particular type of cell |
| CvtkDGTranscribeUnstructuredCells | Transcribe unstructured-grid cells as vtkDGCell subclasses |
| CvtkDGTransformResponder | Apply a transform to an attribute of a vtkDGCell |
| CvtkDGTri | Metadata for a discontinuous Galerkin triangle |
| CvtkDGVert | Metadata for a discontinuous Galerkin vertex |
| CvtkDGWarp | Respond to a "warp" query on one particular type of cell |
| CvtkDGWdg | Metadata for a discontinuous Galerkin wedge |
| CvtkDiagonalMatrixSource | Generates a sparse or dense square matrix with user-specified values for the diagonal, superdiagonal, and subdiagonal |
| CvtkDicer | Abstract superclass to divide dataset into pieces |
| CvtkDICOMImageReader | Reads some DICOM images |
| CvtkDijkstraGraphGeodesicPath | Dijkstra algorithm to compute the graph geodesic |
| CvtkDijkstraGraphInternals | Helper class due to PIMPL excess |
| CvtkDijkstraImageContourLineInterpolator | Contour interpolator for placing points on an image |
| CvtkDijkstraImageGeodesicPath | Dijkstra algorithm to compute the graph geodesic |
| CvtkDIMACSGraphReader | Reads vtkGraph data from a DIMACS formatted file |
| CvtkDIMACSGraphWriter | Write vtkGraph data to a DIMACS formatted file |
| CvtkDirectedAcyclicGraph | A rooted tree data structure |
| CvtkDirectedGraph | A directed graph |
| CvtkDirectedGraphAlgorithm | Superclass for algorithms that produce only directed graph as output |
| CvtkDirectionEncoder | Encode a direction into a one or two byte value |
| CvtkDirectory | OS independent class for access and manipulation of system directories |
| 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 |
| CvtkDiscreteMarchingCubes | Generate object boundaries from labelled volumes |
| CvtkDiscretizableColorTransferFunction | Combination of vtkColorTransferFunction and vtkLookupTable |
| CvtkDiskSource | Create a disk with hole in center |
| CvtkDisplaySizedImplicitPlaneRepresentation | Class defining the representation for a vtkDisplaySizedImplicitPlaneWidget |
| CvtkDisplaySizedImplicitPlaneWidget | 3D widget for manipulating a display sized plane |
| CvtkDistancePolyDataFilter | Computes the signed distance from one vtkPolyData to another |
| CvtkDistanceRepresentation | Represent the vtkDistanceWidget |
| CvtkDistanceRepresentation2D | Represent the vtkDistanceWidget |
| CvtkDistanceRepresentation3D | Represent the vtkDistanceWidget |
| CvtkDistanceToCamera | Calculates distance from points to the camera |
| CvtkDistanceWidget | Measure the distance between two points |
| CvtkDistributedDataFilter | Serial stand-in for parallel filter that distributes data among processors |
| CvtkDistributedGraphHelper | Helper for the vtkGraph class that allows the graph to be distributed across multiple memory spaces |
| CvtkDistributedPointCloudFilter | Distributes points among MPI processors |
| CvtkDIYAggregateDataSetFilter | Aggregates data sets to a reduced number of processes |
| CvtkDIYDataExchanger | Exchange data-object among ranks |
| CvtkDIYExplicitAssigner | Assigner for use with DIY |
| ►CvtkDIYGhostUtilities | Utilities to produce ghost cells between a collection of data sets of same type |
| CBlock | Block structure to be used for diy communication |
| CDataSetBlockStructure | Base block structure for data sets |
| CDataSetInformation | |
| CDataSetTypeToBlockTypeConverter | This helper structure owns a typedef to the block type of DataSetT used with diy to generate ghosts |
| CGridBlockStructure | Structure to inherit from for data sets having a structured grid topology |
| CGridInformation | Structure storing information needed by a block on it's own grid structure |
| CImageDataBlockStructure | Block structure storing information being communicated by neighboring blocks for vtkImageData |
| CImageDataInformation | |
| ►CPolyDataBlockStructure | |
| CTopologyBufferType | |
| CPolyDataInformation | |
| CRectilinearGridBlockStructure | Block structure storing information being communicated by neighboring blocks for vtkRectilinearGrid |
| CRectilinearGridInformation | |
| ►CStructuredGridBlockStructure | Block structure storing information being communicated by neighboring blocks for vtkStructuredGrid |
| CGrid2D | Grid interfacing with block's grid |
| ►CStructuredGridInformation | |
| COuterPointLayersType | This structure represents the set of points and their corresponding extent of an external face of the structured grid |
| CUnstructuredDataBlockStructure | |
| CUnstructuredDataInformation | |
| ►CUnstructuredGridBlockStructure | |
| CTopologyBufferType | Topology information for cells to be exchanged |
| CUnstructuredGridInformation | |
| CvtkDIYKdTreeUtilities | Collection of utility functions for DIY-based KdTree algorithm |
| CvtkDIYUtilities | Collection of helper functions for working with DIY |
| CvtkDIYUtilitiesCleanup | |
| CvtkDotProductSimilarity | Compute dot-product similarity metrics |
| CvtkDoubleArray | Dynamic, self-adjusting array of double |
| CvtkDrawTexturedElements | A base class for mappers or render responders that need to draw primitives via vertex-pulling |
| CvtkDSPFilterDefinition | Used by the Exodus readers |
| CvtkDSPFilterGroup | Used by the Exodus readers |
| CvtkDualDepthPeelingPass | Implements the dual depth peeling algorithm |
| CvtkDummyCommunicator | Dummy controller for single process applications |
| CvtkDummyController | Dummy controller for single process applications |
| CvtkDummyGPUInfoList | Do thing during Probe() |
| CvtkDuplicatePolyData | For distributed tiled displays |
| CvtkDynamic2DLabelMapper | Draw text labels at 2D dataset points |
| CvtkDynamicLoader | Class interface to system dynamic libraries |
| CvtkEarthSource | Create the continents of the Earth as a sphere |
| CvtkEdgeBase | |
| CvtkEdgeCenters | Generate points at center of edges |
| CvtkEdgeLayout | Layout graph edges |
| CvtkEdgeLayoutStrategy | Abstract superclass for all edge layout strategies |
| CvtkEdgeListIterator | Iterates through all edges in a graph |
| CvtkEdgePoints | Generate points on isosurface |
| CvtkEdgeSubdivisionCriterion | How to decide whether a linear approximation to nonlinear geometry or field should be subdivided |
| CvtkEdgeTable | Keep track of edges (edge is pair of integer id's) |
| CvtkEdgeType | |
| CvtkEDLShading | Implement an EDL offscreen shading |
| CvtkEGLRenderWindow | OpenGL rendering window |
| CvtkElevationFilter | Generate scalars along a specified direction |
| CvtkEllipseArcSource | Create an elliptical arc |
| CvtkEllipsoidalGaussianKernel | Ellipsoidal Gaussian interpolation kernel |
| CvtkEllipsoidTensorProbeRepresentation | A concrete implementation of vtkTensorProbeRepresentation that renders tensors as ellipoids |
| CvtkEllipticalButtonSource | Create a ellipsoidal-shaped button |
| CvtkEmptyCell | Empty cell used as a place-holder during processing |
| CvtkEmptyRepresentation | |
| CvtkEncodedGradientEstimator | Superclass for gradient estimation |
| CvtkEncodedGradientShader | Compute shading tables for encoded normals |
| CvtkEndFor | VtkEndFor define the end of the sub-pipeline to loop |
| CvtkEnsembleSource | Source that manages dataset ensembles |
| CvtkEnSight6BinaryReader | Class to read binary EnSight6 files |
| CvtkEnSight6Reader | Class to read EnSight6 files |
| CvtkEnSightGoldBinaryReader | Class to read binary EnSight Gold files |
| CvtkEnSightGoldCombinedReader | |
| CvtkEnSightGoldReader | Class to read EnSight Gold files |
| CvtkEnSightMasterServerReader | Reader for compound EnSight files |
| ►CvtkEnSightReader | Superclass for EnSight file readers |
| CPartTransforms | |
| CvtkEnSightSOSGoldReader | Reader for EnSight SOS gold files |
| CvtkEnSightWriter | Write vtk unstructured grid data as an EnSight file |
| CvtkEnzoReaderBlock | |
| CvtkEnzoReaderInternal | |
| CvtkEqualizerContextItem | Draws a interactive polyline |
| CvtkEqualizerFilter | Implements an algorithm for digital signal processing |
| CvtkEquirectangularToCubeMapTexture | Compute a cubemap texture based on a standard equirectangular projection |
| CvtkERFReader | Read ERF-HDF5 files |
| CvtkErrorCode | Superclass for error codes |
| CvtkEuclideanClusterExtraction | Perform segmentation based on geometric proximity and optional scalar threshold |
| CvtkEvenlySpacedStreamlines2D | Evenly spaced streamline generator for 2D |
| CvtkEvent | Complete specification of a VTK event including all modifiers |
| CvtkEventData | |
| CvtkEventDataDevice3D | |
| CvtkEventDataForDevice | |
| CvtkEventForwarderCommand | Simple event forwarder command |
| CvtkEventQtSlotConnect | Manage connections between VTK events and Qt slots |
| CvtkExecutableRunner | Launch a process on the current machine and get its output |
| CvtkExecutionAggregator | Aggregate the results of the sub-pipeline in vtkEndFor |
| CvtkExecutionRange | Define a range for the vtkForEach |
| CvtkExecutionTimer | Time filter execution |
| CvtkExecutive | Superclass for all pipeline executives in VTK |
| CvtkExodusIICache | |
| CvtkExodusIICacheEntry | |
| CvtkExodusIICacheKey | |
| CvtkExodusIIReader | Read exodus 2 files .ex2 |
| CvtkExodusIIReaderIntPointCheck | This looks for integration-point variables whose names contain an element shape and digits specifying an integration point |
| CvtkExodusIIReaderParser | Internal parser used by vtkExodusIIReader |
| ►CvtkExodusIIReaderPrivate | This class holds metadata for an Exodus file |
| CArrayInfoType | A struct to hold information about time-varying arrays |
| CAssemblyInfoType | |
| CBlockInfoType | A struct to hold information about Exodus blocks |
| CBlockSetInfoType | A struct to hold information about Exodus blocks or sets (they have some members in common) |
| CMapInfoType | A struct to hold information about Exodus maps |
| CMaterialInfoType | |
| CObjectInfoType | A struct to hold information about Exodus objects (blocks, sets, maps) |
| CPartInfoType | A struct to hold information about Exodus blocks |
| CSetInfoType | A struct to hold information about Exodus sets |
| 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 |
| CvtkExodusIIReaderVariableCheck | Abstract base class for glomming arrays of variable names |
| CvtkExodusIIReaderVectorCheck | This looks for n-D vectors whose names are identical except for a single final character |
| ►CvtkExodusIIWriter | Write Exodus II files |
| CBlock | |
| CVariableInfo | |
| CvtkExpandMarkedElements | Expands marked elements to including adjacent elements |
| CvtkExpandSelectedGraph | Expands a selection set of a vtkGraph |
| CvtkExplicitStructuredGrid | Structured grid with explicit topology and geometry |
| 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 |
| CvtkExplicitStructuredGridSurfaceFilter | Filter which creates a surface (polydata) from an explicit structured grid |
| CvtkExplicitStructuredGridToUnstructuredGrid | Filter which converts an explicit structured grid into an unstructured grid |
| CvtkExporter | Abstract class to write a scene to a 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 |
| CvtkExternalLight | Virtual light object for tweaking existing lights in an external 3D rendering context |
| CvtkExternalOpenGLCamera | OpenGL camera |
| CvtkExternalOpenGLRenderer | OpenGL renderer |
| CvtkExternalOpenGLRenderWindow | OpenGL render window that allows using an external window to render vtk objects |
| CvtkExtractArray | Given a vtkArrayData object containing one-or-more vtkArray instances, produces a vtkArrayData containing just one vtkArray, identified by index |
| CvtkExtractBlock | Extracts blocks from a vtkDataObjectTree subclass |
| CvtkExtractBlockUsingDataAssembly | Extract blocks from certain composite datasets |
| CvtkExtractCells | Subset a vtkDataSet to create a vtkUnstructuredGrid |
| CvtkExtractCellsAlongPolyLine | Extracts input cells that are intersected by a list of input lines or poly lines |
| CvtkExtractCellsByType | Extract cells of a specified type |
| CvtkExtractCTHPart | Generates surface of a CTH volume fraction |
| CvtkExtractDataArraysOverTime | Extracts array from input dataset over time |
| CvtkExtractDataOverTime | Extract point data from a time sequence for a specified point id |
| CvtkExtractDataSets | Extracts a number of datasets |
| CvtkExtractEdges | Extract cell edges from any type of dataset |
| CvtkExtractEnclosedPoints | Extract points inside of a closed polygonal surface |
| CvtkExtractExodusGlobalTemporalVariables | Extract global temporal arrays or suitable field data arrays |
| 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 |
| 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) |
| CvtkExtractGrid | Select piece (e.g., volume of interest) and/or subsample structured grid dataset |
| CvtkExtractHierarchicalBins | Manipulate the output of vtkHierarchicalBinningFilter |
| CvtkExtractHistogram | Extract histogram data (binned values) from any dataset |
| CvtkExtractHistogram2D | Compute a 2D histogram between two columns of an input vtkTable |
| CvtkExtractLevel | Extract levels between min and max from a hierarchical box dataset |
| CvtkExtractParticlesOverTime | Extract particles that goes through a given volumic data set |
| CvtkExtractPiece | VtkExtractPiece returns the appropriate piece of each sub-dataset in the vtkCompositeDataSet |
| CvtkExtractPointCloudPiece | Return a piece of a point cloud |
| CvtkExtractPoints | Extract points within an implicit function |
| 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 |
| CvtkExtractRectilinearGrid | Extract a sub grid (VOI) from the structured rectilinear dataset |
| CvtkExtractSelectedArraysOverTime | Extracts a selection over time |
| CvtkExtractSelectedFrustum | Returns the portion of the input dataset that lies within a selection frustum |
| CvtkExtractSelectedGraph | Return a subgraph of a vtkGraph |
| CvtkExtractSelectedRows | Return selected rows of a table |
| CvtkExtractSelectedTree | Return a subtree from a vtkTree |
| CvtkExtractSelection | Extract a subset from a vtkDataSet |
| CvtkExtractSelectionBase | Abstract base class for all extract selection filters |
| CvtkExtractStructuredGridHelper | Helper for extracting/sub-sampling structured datasets |
| CvtkExtractSubsetWithSeed | Extract a line or plane in the ijk space starting with a seed |
| CvtkExtractSurface | Generate zero-crossing isosurface from truncated signed distance volume |
| CvtkExtractTensorComponents | Extract parts of tensor and create a scalar, vector, normal, or texture coordinates |
| CvtkExtractTimeSteps | Extract specific time-steps from dataset |
| 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 |
| CvtkExtractVectorComponents | Extract components of vector as separate scalars |
| CvtkExtractVOI | Select piece (e.g., volume of interest) and/or subsample structured points dataset |
| CvtkFacetReader | Reads a dataset in Facet format |
| CvtkFacetWriter | Reads a dataset in Facet format |
| CvtkFast2DLayoutStrategy | Simple fast 2D graph layout |
| CvtkFastGeomQuadStruct | |
| CvtkFastSplatter | A splatter optimized for splatting single kernels |
| CvtkFDSReader | A reader for the Fire Dynamics Simulator (FDS) output data |
| CvtkFeatureEdges | Extract interior, boundary, non-manifold, and/or sharp edges from polygonal data |
| CvtkFFMPEGVideoSource | Reader for ffmpeg supported formats |
| CvtkFFMPEGVideoSourceAudioCallbackData | |
| CvtkFFMPEGVideoSourceVideoCallbackData | |
| CvtkFFMPEGWriter | Uses the FFMPEG library to write video files |
| ►CvtkFFT | Perform Discrete Fourier Transforms |
| CisFftType | |
| CisFftType< vtkFFT::ComplexNumber > | |
| CisFftType< vtkFFT::ScalarNumber > | |
| 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 |
| CvtkFidesReader | Read ADIOS2 streams using Fides data model |
| ►CvtkFieldData | Represent and manipulate fields of data |
| CBasicIterator | |
| CCopyFieldFlag | |
| CIterator | |
| 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 |
| CvtkFieldDataToAttributeDataFilter | Map field data to dataset attribute data |
| CvtkFieldDataToDataSetAttribute | Map field data to other attribute data |
| CvtkFileOutputWindow | File Specific output window class |
| CvtkFileResourceStream | VtkResourceStream implementation for file input |
| ►CvtkFileSeriesHelper | Helper class to process file series |
| CvtkTimeInformation | |
| CvtkFillHolesFilter | Identify and fill holes in meshes |
| CvtkFilteringInformationKeyManager | Manages key types in vtkFiltering |
| CvtkFiltersCellGrid | A registrar for cell types contained in this module |
| CvtkFindCellStrategy | Helper class to manage the vtkPointSet::FindCell() method |
| CvtkFiniteDifferenceGradientEstimator | Use finite differences to estimate gradient |
| CvtkFiniteElementFieldDistributor | |
| CvtkFinitePlaneRepresentation | Represent the vtkFinitePlaneWidget |
| CvtkFinitePlaneWidget | 3D widget for manipulating a finite plane |
| CvtkFitImplicitFunction | Extract points on the surface of an implicit function |
| CvtkFitToHeightMapFilter | Adjust polydata to fit image height map |
| CvtkFixedPointRayCastImage | Helper class for a ray cast image |
| 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 |
| CvtkFixedPointVolumeRayCastHelper | An abstract helper that generates images for the volume ray cast mapper |
| CvtkFixedPointVolumeRayCastMapper | A fixed point mapper for volumes |
| CvtkFixedPointVolumeRayCastMIPHelper | A helper that generates MIP images for the volume ray cast mapper |
| CvtkFixedSizeHandleRepresentation | A marker that has the same size in pixels |
| CvtkFixedSizeHandleRepresentation3D | |
| CvtkFixedWidthTextReader | Reader for pulling in text files with fixed-width fields |
| CvtkFlagpoleLabel | Renders a flagpole (line) with a label at the top that faces the camera |
| CvtkFlashReaderInternal | |
| CvtkFloatArray | Dynamic, self-adjusting array of float |
| CvtkFloatingPointExceptions | Deal with floating-point exceptions |
| ►CvtkFLUENTCFFReader | Reads a dataset in Fluent CFF file format |
| CCell | |
| CFace | |
| CScalarDataChunk | |
| CVectorDataChunk | |
| CvtkFLUENTReader | Reads a dataset in Fluent file format |
| 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 |
| CvtkFocalPlaneContourRepresentation | Represent a contour drawn on the focal plane |
| CvtkFocalPlanePointPlacer | |
| CvtkFollower | Subclass of actor that always faces the camera |
| CvtkFontConfigFreeTypeTools | Subclass of vtkFreeTypeTools that uses system installed fonts |
| CvtkForceDirectedLayoutStrategy | Force directed graph layout algorithm |
| CvtkForceStaticMesh | Takes in input as a cache the first time it is executed then use it as a static mesh |
| CvtkForceTime | |
| CvtkForEach | Algorithm allowing to implement a for loop using the VTK pipeline and a sister filter vtkEndFor |
| CvtkFourByteUnion | OpenGL vertex buffer object |
| CvtkFrameBufferObjectBase | Abstract interface to OpenGL FBOs |
| CvtkFramebufferPass | Render into a FO |
| CvtkFreeTypeLabelRenderStrategy | Renders labels with freetype |
| CvtkFreeTypeStringToImage | Render the supplied text to an image |
| ►CvtkFreeTypeTools | FreeType library support |
| CFaceMetrics | |
| CGlyphOutline | |
| CvtkFreeTypeToolsCleanup | |
| CvtkFrustum | Implicit function for a frustum |
| CvtkFrustumCoverageCuller | Cull props based on frustum coverage |
| CvtkFrustumSelector | VtkFrustumSelector is a vtkSelector that selects elements based on whether they are inside or intersect a frustum of interest |
| CvtkFrustumSource | Create a polygonal representation of a frustum |
| CvtkFunctionParser | Parse and evaluate a mathematical expression |
| CvtkFunctionSet | Abstract interface for sets of functions |
| CvtkFXAAOptions | Configuration for FXAA implementations |
| CvtkGAMBITReader | Reads a dataset in Fluent GAMBIT neutral file format |
| CvtkGarbageCollector | Detect and break reference loops |
| CvtkGarbageCollectorManager | Manages the vtkGarbageCollector singleton |
| CvtkGaussianBlurPass | Implement a post-processing Gaussian blur render pass |
| CvtkGaussianCubeReader | Read ASCII Gaussian Cube Data files |
| CvtkGaussianCubeReader2 | Read a Gaussian Cube file and output a vtkMolecule object and a vtkImageData |
| CvtkGaussianKernel | Spherical Gaussian interpolation kernel |
| CvtkGaussianRandomSequence | Gaussian sequence of pseudo random numbers |
| CvtkGaussianSplatter | Splat points into a volume with an elliptical, Gaussian distribution |
| CvtkGDAL | Shared data for GDAL classes |
| CvtkGDALRasterConverter | Convert between VTK image representation and GDAL datasets |
| CvtkGDALRasterReader | Read raster file formats using GDAL |
| CvtkGDALRasterReprojection | |
| CvtkGDALVectorReader | Read vector file formats using GDAL |
| CvtkGeneralizedKernel | Flexible, general interpolation kernels |
| CvtkGeneralTransform | Allows operations on any transforms |
| CvtkGenerateGlobalIds | Generates global point and cell ids |
| CvtkGenerateIds | Generate scalars or field data from point and cell ids |
| CvtkGenerateIndexArray | Generates a new vtkIdTypeArray containing zero-base indices |
| CvtkGenerateProcessIds | Sets ProcessIds attribute for PointData and/or CellData |
| CvtkGenerateRegionIds | Generate cell array containing the region id |
| CvtkGenerateTimeSteps | Generate timesteps on any input |
| CvtkGenericAdaptorCell | Defines cell interface |
| CvtkGenericAttribute | Abstract class defined API for attribute data |
| CvtkGenericAttributeCollection | Collection of attributes |
| CvtkGenericCell | Thread-safe access to cells |
| CvtkGenericCellIterator | Iterator used to traverse cells |
| CvtkGenericCellTessellator | Helper class to perform cell tessellation |
| CvtkGenericClip | Clip any dataset with an implicit function or scalar data |
| CvtkGenericContourFilter | Generate isocontours from input dataset |
| CvtkGenericCutter | Cut a vtkGenericDataSet with an implicit function or scalar data |
| CvtkGenericDataArray | Base interface for all typed vtkDataArray subclasses |
| CvtkGenericDataArrayLookupHelper | Internal class used by vtkGenericDataArray to support LookupValue |
| CvtkGenericDataObjectReader | Class to read any type of vtk data object |
| CvtkGenericDataObjectWriter | Writes any type of vtk data object to file |
| CvtkGenericDataSet | Defines dataset interface |
| CvtkGenericDataSetTessellator | Tessellates generic, higher-order datasets into linear cells |
| ►CvtkGenericEdgeTable | Keep track of edges (defined by pair of integer id's) |
| CEdgeEntry | |
| CPointEntry | |
| CvtkGenericEnSightReader | Class to read any type of EnSight files |
| CvtkGenericGeometryFilter | Extract geometry from data (or convert data to polygonal type) |
| CvtkGenericGlyph3DFilter | Copy oriented and scaled glyph geometry to every input point |
| CvtkGenericImageInterpolator | Interpolate data values from images using vtkGenericDataArray API |
| CvtkGenericInterpolatedVelocityField | Interface for obtaining interpolated velocity values |
| CvtkGenericMovieWriter | Abstract movie writer class |
| CvtkGenericOpenGLRenderWindow | Platform independent render window |
| CvtkGenericOpenGLResourceFreeCallback | |
| CvtkGenericOutlineFilter | Create wireframe outline for arbitrary generic data set |
| CvtkGenericPointIterator | Iterator used to traverse points |
| CvtkGenericProbeFilter | Sample data values at specified point locations |
| CvtkGenericRenderWindowInteractor | Platform-independent programmable render window interactor |
| ►CvtkGenericStreamTracer | Streamline generator |
| CIntervalInformation | |
| CvtkGenericSubdivisionErrorMetric | Objects that compute error during cell tessellation |
| CvtkGenericVertexAttributeMapping | Stores mapping for data arrays to generic vertex attributes |
| CvtkGeodesicPath | Abstract base for classes that generate a geodesic path |
| CvtkGeoEdgeStrategy | Layout graph edges on a globe as arcs |
| CvtkGeoJSONFeature | Represents GeoJSON feature geometry & properties |
| CvtkGeoJSONReader | Convert Geo JSON format to vtkPolyData |
| CvtkGeoJSONWriter | Convert vtkPolyData to Geo JSON format |
| CvtkGeoMath | Useful geographic calculations |
| CvtkGeometricErrorMetric | Objects that compute geometry-based error during cell tessellation |
| CvtkGeometryFilter | Extract boundary geometry from dataset (or convert data to polygonal type) |
| CvtkGeometryFilterHelper | |
| CvtkGeoProjection | Represent a projection from a sphere to a plane |
| CvtkGeoTransform | A transformation between two geographic coordinate systems |
| CvtkGESignaReader | Read GE Signa ximg files |
| CvtkGhostCellsGenerator | Computes ghost cells on vtkCompositeDataSet inputs |
| CvtkGL2PSExporter | Export a scene as a PostScript file using GL2PS |
| CvtkGlobFileNames | Find files that match a wildcard pattern |
| CvtkGLSLModCamera | Implement model-view-projection transforms in the OpenGL renderer |
| CvtkGLSLModCoincidentTopology | Handle coincident topology |
| CvtkGLSLModifierBase | Abstract class that helps you develop modifier for VTK GLSL shaders |
| CvtkGLSLModifierFactory | This class empowers developers to write and use GLSL mods eaisly in VTK |
| ►CvtkGLSLModLight | Implement light kit support in the OpenGL renderer for vtkCellGrid |
| CLightStatsBasic | |
| CvtkGLSLModPixelDebugger | Allow live pixel debugging by overwriting gl_FragData[0] output |
| ►CvtkGLTFDocumentLoader | Deserialize a GLTF model file |
| ►CAccessor | This struct describes an accessor glTF object |
| CSparse | This struct describes an accessor.sparse glTF object |
| ►CAnimation | This struct describes a glTF animation object |
| CChannel | |
| CSampler | |
| CBufferView | This struct describes a glTF bufferView object |
| CCamera | This struct describes a glTF camera object |
| ►CExtensions | This struct contains extension metadata |
| ►CKHRLightsPunctual | |
| CLight | |
| CImage | This struct describes a glTF image object |
| ►CMaterial | This struct describes a glTF material object |
| CPbrMetallicRoughness | |
| CMesh | This struct describes a glTF mesh object |
| CModel | This struct contains all data from a gltf asset |
| CMorphTarget | This struct describes a glTF Morph Target object |
| ►CNode | This struct describes a glTF node object |
| ►CExtensions | |
| CKHRLightsPunctual | |
| ►CPrimitive | This struct describes a glTF primitive object |
| ►CExtensions | |
| CKHRDracoMeshCompression | |
| CSampler | This struct describes a glTF sampler object |
| CScene | This struct describes a glTF scene object |
| CSkin | This struct describes a glTF asset |
| CTexture | This struct describes a glTF texture object |
| CTextureInfo | 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 |
| CvtkGLTFDocumentLoaderInternals | Internal class for vtkGLTFDocumentLoader |
| CvtkGLTFExporter | Export a scene into GLTF 2.0 format |
| CvtkGLTFImporter | Import a GLTF file |
| ►CvtkGLTFReader | Read a GLTF file |
| CGLTFTexture | Materials are not directly applied to this reader's output |
| CvtkGLTFTexture | |
| CvtkGLTFWriter | Export a scene into GLTF 2.0 format |
| CvtkGLTFWriterUtils | |
| CvtkGlyph2D | Copy oriented and scaled glyph geometry to every input point (2D specialization) |
| CvtkGlyph3D | Copy oriented and scaled glyph geometry to every input point |
| CvtkGlyph3DMapper | VtkGlyph3D on the GPU |
| CvtkGlyphSource2D | Create 2D glyphs represented by vtkPolyData |
| CvtkGoldenBallSource | Create a faceted approximation to a ball (i.e., a solid sphere) |
| CvtkGPUInfo | Stores GPU VRAM information |
| CvtkGPUInfoList | Stores the list of GPUs VRAM information |
| CvtkGPUInfoListArray | Internal class vtkGPUInfoList |
| CvtkGPUVolumeRayCastMapper | Ray casting performed on the GPU |
| CvtkGradientFilter | A general filter for gradient estimation |
| CvtkGraph | Base class for graph data types |
| CvtkGraphAlgorithm | Superclass for algorithms that produce only graph as output |
| CvtkGraphAnnotationLayersFilter | Produce filled convex hulls around subsets of vertices in a vtkGraph |
| CvtkGraphEdge | Representation of a single graph edge |
| CvtkGraphGeodesicPath | Abstract base for classes that generate a geodesic path on a graph (mesh) |
| CvtkGraphHierarchicalBundleEdges | Layout graph arcs in bundles |
| CvtkGraphicsFactory | |
| CvtkGraphInternals | Internal representation of vtkGraph |
| CvtkGraphItem | A 2D graphics item for rendering a graph |
| CvtkGraphLayout | Layout a graph in 2 or 3 dimensions |
| CvtkGraphLayoutFilter | Nice layout of undirected graphs in 3D |
| CvtkGraphLayoutStrategy | Abstract superclass for all graph layout strategies |
| CvtkGraphLayoutView | Lays out and displays a graph |
| CvtkGraphMapper | Map vtkGraph and derived classes to graphics primitives |
| CvtkGraphReader | Read vtkGraph data file |
| CvtkGraphToGlyphs | Create glyphs for graph vertices |
| CvtkGraphToPoints | Convert a vtkGraph a set of points |
| CvtkGraphToPolyData | Convert a vtkGraph to vtkPolyData |
| CvtkGraphWeightEuclideanDistanceFilter | Weights the edges of a graph based on the Euclidean distance between the points |
| CvtkGraphWeightFilter | Base class for filters that weight graph edges |
| CvtkGraphWriter | Write vtkGraph data to a file |
| CvtkGreedyTerrainDecimation | Reduce height field (represented as image) to reduced TIN |
| CvtkGridSynchronizedTemplates3D | Generate isosurface from structured grids |
| CvtkGridTransform | Nonlinear warp transformation |
| CvtkGroupDataSetsFilter | Groups inputs into a chosen composite dataset |
| CvtkGroupLeafVertices | Filter that expands a tree, categorizing leaf vertices |
| CvtkGroupTimeStepsFilter | Converts a temporal dataset into non-temporal dataset |
| CvtkH5PartReader | Read H5Part particle files |
| CvtkH5RageReader | Class for reading Rage HDF data files |
| CvtkHandleRepresentation | Abstract class for representing widget handles |
| CvtkHandleSource | Interface that can be inherited to define handler sources for any kind of interaction |
| CvtkHandleWidget | General widget for moving handles |
| CvtkHardwarePicker | Pick a point or snap to point of an actor/prop using graphics hardware |
| ►CvtkHardwareSelector | |
| CPixelInformation | Struct used to return information about a pixel location |
| CvtkHardwareWindow | Create a window for renderers to draw into |
| CvtkHashCombiner | Combine 4- and 8-byte integers into a single hash value |
| CvtkHausdorffDistancePointSetFilter | Compute Hausdorff distance between two point sets |
| CvtkHDF5Helper | Helper class used to read hdf5 file format |
| ►CvtkHDFReader | Reads data saved using the VTK HDF format which supports all vtkDataSet types (image data, poly data, unstructured grid, overlapping AMR, partitioned dataset collection and multiblock are currently implemented) and serial as well as parallel processing |
| CImplementation | Implementation for the vtkHDFReader |
| CvtkHDFReaderImplementation | Implementation class for vtkHDFReader |
| CvtkHDFVersion | Version number for legacy readers/writers |
| ►CvtkHDFWriter | Writes input dataset to a VTKHDF file |
| ►CImplementation | |
| CPolyDataTopos | Stores a group name and the corresponding cell array |
| CvtkHDFWriterImplementation | Implementation class for vtkHDFWriter |
| CvtkHDRReader | Read Radiance HDR files |
| CvtkHeap | Replacement for malloc/free and new/delete |
| CvtkHeatmapItem | A 2D graphics item for rendering a heatmap |
| CvtkHedgeHog | Create oriented lines from vector data |
| CvtkHexagonalPrism | 3D cell that represents a prism with hexagonal base |
| CvtkHexahedron | Cell that represents a linear 3D hexahedron |
| CvtkHiddenLineRemovalPass | RenderPass for HLR |
| CvtkHierarchicalBinningFilter | Uniform binning of points into a hierarchical structure |
| CvtkHierarchicalBoxDataSet | Backwards compatibility class |
| CvtkHierarchicalBoxDataSetAlgorithm | Superclass for algorithms that produce vtkHierarchicalBoxDataSet as output |
| CvtkHierarchicalDataExtractDataSets | Extract a number of datasets |
| CvtkHierarchicalDataExtractLevel | Extract levels between min and max |
| CvtkHierarchicalDataLevelFilter | Generate scalars from levels |
| CvtkHierarchicalDataSetGeometryFilter | Extract geometry from hierarchical data |
| CvtkHierarchicalGraphPipeline | Helper class for rendering graphs superimposed on a tree |
| CvtkHierarchicalGraphView | Accepts a graph and a hierarchy - currently a tree - and provides a hierarchy-aware display |
| CvtkHierarchicalPolyDataMapper | Class that renders hierarchical polygonal data |
| CvtkHigherOrderCurve | |
| CvtkHigherOrderHexahedron | A 3D cell that represents an arbitrary order HigherOrder hex |
| CvtkHigherOrderInterpolation | |
| CvtkHigherOrderQuadrilateral | |
| CvtkHigherOrderTetra | A 3D cell that represents an arbitrary order HigherOrder tetrahedron |
| CvtkHigherOrderTriangle | A 2D cell that represents an arbitrary order HigherOrder triangle |
| CvtkHigherOrderWedge | A 3D cell that represents an arbitrary order HigherOrder wedge |
| CvtkHighestDensityRegionsStatistics | Compute a random vector of density f from input observations points |
| CvtkHomogeneousTransform | Superclass for homogeneous transformations |
| CvtkHoudiniPolyDataWriter | Write vtk polygonal data to Houdini file |
| CvtkHoverWidget | Invoke a vtkTimerEvent when hovering |
| CvtkHull | Produce an n-sided convex hull |
| CvtkHyperStreamline | Generate hyperstreamline in arbitrary dataset |
| CvtkHyperTree | A data object structured as a tree |
| CvtkHyperTreeData | |
| ►CvtkHyperTreeGrid | A dataset containing a grid of vtkHyperTree instances arranged as a rectilinear grid |
| CvtkHyperTreeGridIterator | An iterator object to iteratively access trees in the grid |
| CvtkHyperTreeGridAlgorithm | Superclass for algorithms that produce a hyper tree grid as output |
| CvtkHyperTreeGridAxisClip | Axis aligned hyper tree grid clip |
| CvtkHyperTreeGridAxisCut | Axis aligned hyper tree grid cut |
| CvtkHyperTreeGridAxisReflection | Reflect a hyper tree grid |
| CvtkHyperTreeGridCellCenters | Generate points at center of hyper tree grid leaf cell centers |
| CvtkHyperTreeGridContour | Extract cells from a hyper tree grid where selected scalar value is within given range |
| CvtkHyperTreeGridDepthLimiter | Hyper tree grid level extraction |
| CvtkHyperTreeGridEntry | Entries are cache data for cursors |
| 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 |
| CvtkHyperTreeGridGenerateGlobalIds | Generate global IDs of input HyperTee Grid(s) |
| CvtkHyperTreeGridGenerateProcessIds | Sets ProcessIds attribute for CellData |
| CvtkHyperTreeGridGeometricLocator | Class that implements accelerated searches through HyperTree Grids (HTGs) using geometric information |
| CvtkHyperTreeGridGeometry | Generate vtkHyperTreeGrid external surface |
| CvtkHyperTreeGridGeometry1DImpl | VtkHyperTreeGridGeometry internal classes for 1D vtkHyperTreeGrid |
| CvtkHyperTreeGridGeometry2DImpl | VtkHyperTreeGridGeometry internal classes for 2D vtkHyperTreeGrid |
| CvtkHyperTreeGridGeometry3DImpl | VtkHyperTreeGridGeometry internal classes for 3D vtkHyperTreeGrid |
| CvtkHyperTreeGridGeometryEntry | GeometryEntry is a cache data for cursors requiring coordinates |
| CvtkHyperTreeGridGeometryImpl | Interface for all vtkHyperTreeGridGeometry internal classes |
| CvtkHyperTreeGridGeometryLevelEntry | Cursor cache data with coordinates and level info |
| CvtkHyperTreeGridGeometrySmallDimensionsImpl | Common interface for 1D and 2D vtkHyperTreeGridGeometry internal classes |
| CvtkHyperTreeGridGeometryUnlimitedEntry | GeometryUnlimitedEntry is a cache data for cursors requiring coordinates |
| CvtkHyperTreeGridGeometryUnlimitedLevelEntry | Cursor cache data with coordinates and level info |
| CvtkHyperTreeGridGhostCellsGenerator | Generated ghost cells (HyperTree's distributed) |
| ►CvtkHyperTreeGridGhostCellsGeneratorInternals | Internal class for vtkHyperTreeGridGhostCellsGenerator |
| CCellDataArray | |
| CvtkHyperTreeGridGradient | Compute the gradient of a scalar field on a Hyper Tree Grid |
| CvtkHyperTreeGridLevelEntry | LevelEntry is a cache data for cursors requiring level info |
| CvtkHyperTreeGridLocator | Abstract base class for objects that implement accelerated searches through HyperTree Grids (HTGs) |
| CvtkHyperTreeGridMapper | Map vtkHyperTreeGrid to graphics primitives |
| CvtkHyperTreeGridNonOrientedCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedGeometryCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedMooreSuperCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedMooreSuperCursorLight | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedSuperCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedSuperCursorLight | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedUnlimitedGeometryCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedUnlimitedMooreSuperCursor | Specific Moore super cursor that can subdivied neighborhood |
| CvtkHyperTreeGridNonOrientedUnlimitedSuperCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedVonNeumannSuperCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridNonOrientedVonNeumannSuperCursorLight | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridOrientedCursor | Objects for traversal a HyperTreeGrid |
| CvtkHyperTreeGridOrientedGeometryCursor | Objects for traversal a HyperTreeGrid |
| 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 |
| CvtkHyperTreeGridProbeFilter | Probe a vtkHyperTreeGrid |
| CvtkHyperTreeGridRemoveGhostCells | Remove ghost cells and ghost array from the input HTG |
| CvtkHyperTreeGridScales | A specifalized type of vtkHyperTreeGrid for the case when root cells have uniform sizes in each direction * |
| CvtkHyperTreeGridSource | Create a synthetic grid of 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 |
| CvtkHyperTreeGridVisibleLeavesSize | Generate a cell field equal to 1 if the cell is a valid leaf and 0 otherwise, as well as a size field |
| CvtkIcicleView | Displays a tree in a stacked "icicle" view |
| CvtkIconGlyphFilter | Filter that generates a polydata consisting of quads with texture coordinates referring to a set of icons within a sheet of icons |
| CvtkIdentityTransform | Transform that doesn't do anything |
| CvtkIdFilter | Generate scalars or field data from point and cell ids |
| CvtkIdList | List of point or cell ids |
| CvtkIdListCollection | Maintain an ordered list of IdList objects |
| CvtkIdTypeArray | Dynamic, self-adjusting array of vtkIdType |
| CvtkImage2DIslandPixel_t | |
| CvtkImageAccumulate | Generalized histograms up to 3 dimensions |
| CvtkImageActor | Draw an image in a rendered 3D scene |
| CvtkImageActorPointPlacer | Converts 2D display positions to world positions such that they lie on an ImageActor |
| CvtkImageAlgorithm | Generic algorithm superclass for image algs |
| CvtkImageAnisotropicDiffusion2D | Edge preserving smoothing |
| CvtkImageAnisotropicDiffusion3D | Edge preserving smoothing |
| CvtkImageAppend | Collects data from multiple inputs into one image |
| CvtkImageAppendComponents | Collects components from two inputs into one output |
| CvtkImageBlend | Blend images together using alpha or opacity |
| CvtkImageBSplineCoefficients | Convert image to b-spline knots |
| CvtkImageBSplineInternals | BSpline code from P |
| CvtkImageBSplineInterpolator | Perform b-spline interpolation on images |
| CvtkImageButterworthHighPass | Frequency domain high pass |
| CvtkImageButterworthLowPass | Frequency domain Low pass |
| CvtkImageCacheFilter | Caches multiple vtkImageData objects |
| CvtkImageCanvasSource2D | Paints on a canvas |
| CvtkImageCast | Image Data type Casting Filter |
| CvtkImageChangeInformation | Modify spacing, origin and extent |
| CvtkImageCheckerboard | Show two images at once using a checkboard pattern |
| CvtkImageCityBlockDistance | 1,2 or 3D distance map |
| CvtkImageClip | Reduces the image extent of the input |
| CvtkImageComplex_t | |
| CvtkImageConnectivityFilter | Label an image by connectivity |
| CvtkImageConnector | Create a binary image of a sphere |
| CvtkImageConnectorSeed | |
| CvtkImageConstantPad | Makes image larger by padding with constant |
| CvtkImageContinuousDilate3D | Dilate implemented as a maximum |
| CvtkImageContinuousErode3D | Erosion implemented as a minimum |
| CvtkImageConvolve | Convolution of an image with a kernel |
| CvtkImageCorrelation | Correlation imageof the two inputs |
| CvtkImageCroppingRegionsWidget | Widget for cropping an image |
| CvtkImageCursor3D | Paints a cursor on top of an image or volume |
| CvtkImageData | Topologically and geometrically regular array of data |
| CvtkImageDataGeometryFilter | Extract geometry for structured points |
| CvtkImageDataLIC2D | GPU implementation of a Line Integral Convolution, a technique for imaging vector fields |
| CvtkImageDataOutlineFilter | Create wireframe outline for a possibly oriented vtkImageData |
| CvtkImageDataStreamer | Initiates streaming on image data |
| CvtkImageDataToExplicitStructuredGrid | Filter which converts a 3D image data into an explicit structured grid |
| CvtkImageDataToHyperTreeGrid | |
| CvtkImageDataToPointSet | Converts a vtkImageData to a vtkPointSet |
| CvtkImageDataToUniformGrid | Convert vtkImageData to vtkUniformGrid |
| CvtkImageDecomposeFilter | Filters that execute axes in series |
| CvtkImageDifference | Compares images for regression tests |
| CvtkImageDilateErode3D | Dilates one value and erodes another |
| CvtkImageDivergence | Divergence of a vector field |
| CvtkImageDotProduct | Dot product of two vector images |
| CvtkImageEllipsoidSource | Create a binary image of an ellipsoid |
| CvtkImageEuclideanDistance | Computes 3D Euclidean DT |
| CvtkImageEuclideanToPolar | Converts 2D Euclidean coordinates to polar |
| CvtkImageExport | Export VTK images to third-party systems |
| CvtkImageExtractComponents | Outputs a single component |
| CvtkImageFFT | Fast Fourier Transform |
| CvtkImageFlip | This flips an axis of an image |
| CvtkImageFourierCenter | Shifts constant frequency to center for display |
| CvtkImageFourierFilter | Superclass that implements complex numbers |
| CvtkImageGaussianSmooth | Performs a gaussian convolution |
| CvtkImageGaussianSource | Create an image with Gaussian pixel values |
| CvtkImageGradient | Computes the gradient vector |
| CvtkImageGradientMagnitude | Computes magnitude of the gradient |
| CvtkImageGridSource | Create an image of a grid |
| CvtkImageHistogram | Compute the histogram for an image |
| CvtkImageHistogramStatistics | Compute statistics for an image |
| CvtkImageHSIToRGB | Converts HSI components to RGB |
| CvtkImageHSVToRGB | Converts HSV components to RGB |
| CvtkImageHybridMedian2D | Median filter that preserves lines and corners |
| CvtkImageIdealHighPass | Simple frequency domain band pass |
| CvtkImageIdealLowPass | Simple frequency domain band pass |
| CvtkImageImport | Import data from a C array |
| CvtkImageImportExecutive | VtkImageImportExecutive |
| CvtkImageInPlaceFilter | Filter that operates in place |
| CvtkImageInterpolator | Interpolate data values from images |
| CvtkImageIslandRemoval2D | Removes small clusters in masks |
| CvtkImageItem | VtkContextItem that draws a supplied image in the scene |
| CvtkImageIterateFilter | Multiple executes per update |
| CvtkImageIterator | Simple image iterator |
| 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 | |
| CvtkImageMandelbrotSource | Mandelbrot image |
| CvtkImageMapper | 2D image display |
| CvtkImageMapper3D | Abstract class for mapping images to the screen |
| 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 |
| CvtkImageMarchingCubes | Generate isosurface(s) from volume/images |
| 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 |
| CvtkImageMedian3D | Median Filter |
| CvtkImageMirrorPad | Extra pixels are filled by mirror images |
| CvtkImageNoiseSource | Create an image filled with noise |
| CvtkImageNonMaximumSuppression | Performs non-maximum suppression |
| CvtkImageNormalize | Normalizes that scalar components for each point |
| CvtkImageOpenClose3D | Will perform opening or closing |
| CvtkImageOrthoPlanes | Connect three vtkImagePlaneWidgets together |
| CvtkImagePadFilter | Super class for filters that fill in extra pixels |
| CvtkImagePermute | Permutes axes of input |
| CvtkImagePlaneWidget | 3D widget for reslicing image data |
| CvtkImagePointDataIterator | Iterate over point data in an image |
| CvtkImagePointIterator | Iterate over all data points in an image |
| CvtkImageProbeFilter | Sample image values at specified point positions |
| CvtkImageProcessingPass | Convenient class for post-processing passes |
| CvtkImageProgressIterator | Simple image iterator with progress |
| CvtkImageProperty | Image display properties |
| CvtkImageQuantizeRGBToIndex | Generalized histograms up to 4 dimensions |
| CvtkImageRange3D | Max - min of a circular neighborhood |
| CvtkImageReader | Superclass of transformable binary file readers |
| CvtkImageReader2 | Superclass of binary file readers |
| CvtkImageReader2Collection | Maintain a list of image readers |
| CvtkImageReader2Factory | Superclass of binary file readers |
| CvtkImageRectilinearWipe | Make a rectilinear combination of two images |
| CvtkImageRenderManager | An object to control sort-first parallel rendering |
| CvtkImageResample | Resamples an image to be larger or smaller |
| CvtkImageResize | High-quality image resizing filter |
| CvtkImageReslice | Reslices a volume along a new set of axes |
| CvtkImageResliceMapper | Map a slice of a vtkImageData to the screen |
| CvtkImageResliceToColors | Reslice and produce color scalars |
| CvtkImageRFFT | Reverse Fast Fourier Transform |
| CvtkImageRGBToHSI | Converts RGB components to HSI |
| CvtkImageRGBToHSV | Converts RGB components to HSV |
| CvtkImageRGBToXYZ | Converts XYZ components to LAB |
| CvtkImageRGBToYIQ | Converts RGB components to YIQ |
| CvtkImageSeedConnectivity | SeedConnectivity with user defined seeds |
| CvtkImageSeparableConvolution | 3 1D convolutions on an image |
| CvtkImageShiftScale | Shift and scale an input image |
| CvtkImageShrink3D | Subsamples an image |
| CvtkImageSincInterpolator | Perform sinc interpolation on images |
| CvtkImageSinusoidSource | Create an image with sinusoidal pixel values |
| CvtkImageSkeleton2D | Skeleton of 2D images |
| CvtkImageSlab | Combine image slices to form a slab image |
| CvtkImageSlabReslice | Thick slab reformat through data |
| CvtkImageSlice | Image in a 3D scene |
| CvtkImageSliceCollection | Sorted list of image slice objects |
| CvtkImageSliceMapper | Map a slice of a vtkImageData to the screen |
| CvtkImageSobel2D | Computes a vector field using sobel functions |
| CvtkImageSobel3D | Computes a vector field using sobel functions |
| CvtkImageSpatialAlgorithm | Filters that operate on pixel neighborhoods |
| CvtkImageSSIM | This filter implements an algorithm based on SSIM for image comparison |
| CvtkImageStack | Manages a stack of composited images |
| CvtkImageStencil | Combine images via a cookie-cutter operation |
| CvtkImageStencilAlgorithm | Producer of vtkImageStencilData |
| CvtkImageStencilData | Efficient description of an image stencil |
| CvtkImageStencilIterator | Image region iterator |
| CvtkImageStencilRaster | This is a helper class for stencil creation |
| CvtkImageStencilSource | Generate an image stencil |
| CvtkImageStencilToImage | Convert an image stencil into an image |
| CvtkImageThreshold | Flexible threshold |
| CvtkImageThresholdConnectivity | Flood fill an image region |
| CvtkImageToAMR | Filter to convert any vtkImageData to a vtkOverlappingAMR |
| CvtkImageToImageStencil | Clip an image with a mask image |
| CvtkImageToPoints | Extract all image voxels as points |
| CvtkImageToPolyDataFilter | Generate linear primitives (vtkPolyData) from an image |
| CvtkImageToStructuredGrid | Structured grid instance |
| CvtkImageToStructuredPoints | Attaches image pipeline to VTK |
| CvtkImageTracerWidget | 3D widget for tracing on planar props |
| CvtkImageTransform | Helper class to transform output of non-axis-aligned images |
| CvtkImageTranslateExtent | Changes extent, nothing else |
| CvtkImageVariance3D | Variance in a neighborhood |
| CvtkImageViewer | Display a 2d image |
| CvtkImageViewer2 | Display a 2D image |
| CvtkImageWeightedSum | Adds any number of images, weighting each according to the weight set using this->SetWeights(i,w) |
| CvtkImageWrapPad | Makes an image larger by wrapping existing data |
| CvtkImageWriter | Writes images to files |
| CvtkImageXYZToLAB | Converts XYZ components to LAB |
| CvtkImageYIQToRGB | |
| CvtkImplicitAnnulusRepresentation | Defining the representation for a vtkImplicitAnnulusWidget |
| CvtkImplicitAnnulusWidget | 3D widget for manipulating an infinite annulus |
| CvtkImplicitArray | A read only array class that wraps an implicit function from integers to any value type supported by VTK |
| CvtkImplicitBoolean | Implicit function consisting of boolean combinations of implicit functions |
| CvtkImplicitConeRepresentation | Defining the representation for a vtkImplicitConeWidget |
| CvtkImplicitConeWidget | 3D widget for manipulating an infinite cone |
| CvtkImplicitCylinderRepresentation | Defining the representation for a vtkImplicitCylinderWidget |
| CvtkImplicitCylinderWidget | 3D widget for manipulating an infinite cylinder |
| CvtkImplicitDataSet | Treat a dataset as if it were an implicit function |
| CvtkImplicitFrustumRepresentation | The representation for a vtkImplicitFrustumWidget |
| CvtkImplicitFrustumWidget | 3D widget for manipulating an infinite frustum |
| CvtkImplicitFunction | Abstract interface for implicit functions |
| CvtkImplicitFunctionCollection | Maintain a list of implicit functions |
| CvtkImplicitFunctionToImageStencil | Clip an image with a function |
| CvtkImplicitHalo | Implicit function for an halo |
| CvtkImplicitImageRepresentation | Representation for a vtkImplicitPlaneWidget2 which reslices a volume |
| CvtkImplicitModeller | Compute distance from input geometry on structured point dataset |
| CvtkImplicitPlaneRepresentation | Class defining the representation for a vtkImplicitPlaneWidget2 |
| CvtkImplicitPlaneWidget | 3D widget for manipulating an infinite plane |
| CvtkImplicitPlaneWidget2 | 3D widget for manipulating an infinite plane |
| 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 |
| CvtkImplicitTextureCoords | Generate 1D, 2D, or 3D texture coordinates based on implicit function(s) |
| CvtkImplicitVolume | Treat a volume as if it were an implicit function |
| CvtkImplicitWindowFunction | Implicit function maps another implicit function to lie within a specified range |
| CvtkImporter | Importer abstract class |
| CvtkImprintFilter | Imprint the contact surface of one object onto another surface |
| CvtkIncrementalForceLayout | Incremental force-directed layout |
| CvtkIncrementalOctreeNode | Octree node constituting incremental octree (in support of both point location and point insertion) |
| CvtkIncrementalOctreePointLocator | Incremental octree in support of both point location and point insertion |
| CvtkIncrementalPointLocator | Abstract class in support of both point location and point insertion |
| CvtkIndent | Simple class to control print indentation |
| CvtkIndexedImplicitBackend | 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 |
| CvtkInEdgeIterator | Iterates through all incoming edges to a vertex |
| CvtkInEdgeType | |
| CvtkInformation | Store vtkAlgorithm input/output information |
| 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 |
| CvtkInformationIntegerPointerKey | Key for pointer to integer |
| 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 |
| CvtkInformationIntegerVectorKey | Key for integer vector values |
| ►CvtkInformationInternals | Internal structure for vtkInformation |
| CHashFun | |
| CvtkInformationIterator | Iterates over keys of an information object |
| CvtkInformationKey | Superclass for vtkInformation keys |
| CvtkInformationKeyLookup | Find vtkInformationKeys from name and location strings |
| 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 |
| CvtkInformationVector | Store zero or more vtkInformation instances |
| CvtkInitialValueProblemSolver | Integrate a set of ordinary differential equations (initial value problem) in time |
| CvtkInputStream | Wraps a binary input stream with a VTK interface |
| CvtkIntArray | Dynamic, self-adjusting array of int |
| CvtkIntegrateAttributes | Integrates lines, surfaces and volume |
| CvtkInteractiveArea | Implements zooming and panning in a vtkContextArea |
| CvtkInteractorEventRecorder | Record and play VTK events passing through a vtkRenderWindowInteractor |
| CvtkInteractorObserver | Abstract superclass for classes observing events invoked by vtkRenderWindowInteractor |
| CvtkInteractorStyle | Provide event-driven interface to the rendering window (defines trackball mode) |
| CvtkInteractorStyle3D | Extends interaction to support 3D input |
| CvtkInteractorStyleAreaSelectHover | An interactor style for an area tree view |
| CvtkInteractorStyleDrawPolygon | Draw polygon during mouse move |
| CvtkInteractorStyleFlight | Flight motion routines |
| CvtkInteractorStyleImage | Interactive manipulation of the camera specialized for images |
| CvtkInteractorStyleJoystickActor | Manipulate objects in the scene independently of one another |
| CvtkInteractorStyleJoystickCamera | Interactive manipulation of the camera |
| CvtkInteractorStyleMultiTouchCamera | Multitouch manipulation of the camera |
| CvtkInteractorStyleRubberBand2D | A rubber band interactor for a 2D view |
| CvtkInteractorStyleRubberBand3D | A rubber band interactor for a 3D view |
| CvtkInteractorStyleRubberBandPick | Like TrackBallCamera, but this can pick props underneath a rubber band selection rectangle |
| CvtkInteractorStyleRubberBandZoom | Zoom in by amount indicated by rubber band box |
| CvtkInteractorStyleSwitch | Class to swap between interactory styles |
| CvtkInteractorStyleSwitchBase | Dummy interface class |
| CvtkInteractorStyleTerrain | Manipulate camera in scene with natural view up (e.g., terrain) |
| CvtkInteractorStyleTrackball | Trackball motion control |
| CvtkInteractorStyleTrackballActor | Manipulate objects in the scene independent of each other |
| CvtkInteractorStyleTrackballCamera | Interactive manipulation of the camera |
| CvtkInteractorStyleTreeMapHover | An interactor style for a tree map view |
| CvtkInteractorStyleUnicam | Unicam navigation style |
| CvtkInteractorStyleUser | Customizable interaction routines |
| CvtkInterpolateCalculator | Calculate field values at a point in a cell's parametric space |
| CvtkInterpolateDataSetAttributes | Interpolate scalars, vectors, etc |
| CvtkInterpolatingSubdivisionFilter | Generate a subdivision surface using an Interpolating Scheme |
| CvtkInterpolationInfo | |
| CvtkInterpolationKernel | Base class for interpolation kernels |
| CvtkInterpolationMath | |
| CvtkInterpolationWeights | |
| CvtkInterpolatorInternals | Internals for vtkImageInterpolator |
| CvtkIntersectionCounter | Fast simple class for dealing with ray intersections |
| CvtkIntersectionPolyDataFilter | VtkIntersectionPolyDataFilter computes the intersection between two vtkPolyData objects |
| CvtkIntervalInformation | |
| CvtkIOCellGrid | A registrar for cell types contained in this module |
| CvtkIOSRenderWindow | IOS OpenGL rendering window |
| CvtkIOSRenderWindowInteractor | Implements IOS specific functions required by vtkRenderWindowInteractor |
| CvtkIOSSCellGridReader | Reader for IOSS (Sierra IO System) that produces cell-grid data |
| CvtkIOSSCellGridReaderInternal | Internal methods for the cell-grid version of the IOSS reader |
| CvtkIOSSFilesScanner | Helper to scan files |
| CvtkIOSSModel | Internal class used by vtkIOSSWriter |
| CvtkIOSSReader | Reader for IOSS (Sierra IO System) |
| CvtkIOSSReaderInternal | Internal methods and state for the IOSS reader |
| CvtkIOSSWriter | Writer for IOSS (Sierra IO System) |
| CvtkIOStream | Include C++ iostreams as used by VTK |
| CvtkIOStreamFwd | Forward-declare C++ iostreams as used by VTK |
| CvtkISIReader | Reader for ISI files |
| CvtkIterativeClosestPointTransform | Implementation of the ICP algorithm |
| CvtkIVExporter | Export a scene into OpenInventor 2.0 format |
| CvtkIVWriter | Export polydata into OpenInventor 2.0 format |
| CvtkJavaScriptDataWriter | A Javascript data writer for vtkTable Writes a vtkTable into a Javascript data format |
| ►CvtkJoinTables | SQL-style Join operation on two tables |
| CMaps | |
| CvtkJPEGReader | Read JPEG files |
| CvtkJPEGWriter | Writes JPEG files |
| CvtkJSONDataSetWriter | Write vtkDataSet using a vtkArchiver with a JSON meta file along with all the binary arrays written as standalone binary files |
| CvtkJSONImageWriter | Writes vtkImageData to a JSON file |
| 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 |
| CvtkKCoreDecomposition | Compute the k-core decomposition of the input graph |
| CvtkKCoreLayout | Produces a layout for a graph labeled with K-Core information |
| CvtkKdNode | This class represents a single spatial region in an 3D axis aligned binary spatial partitioning |
| ►CvtkKdTree | Kd-tree spatial decomposition of a set of points |
| CcellList_ | |
| CvtkKdTreePointLocator | Class to quickly locate points in 3-space |
| CvtkKdTreeSelector | Selects point ids using a kd-tree |
| CvtkKMeansAssessFunctor | |
| CvtkKMeansDistanceFunctor | Measure distance from k-means cluster centers |
| CvtkKMeansDistanceFunctorCalculator | Measure distance from k-means cluster centers using a user-specified expression |
| CvtkKMeansStatistics | A class for KMeans clustering |
| CvtkKochanekSpline | Computes an interpolating spline using a Kochanek basis |
| CvtkLabeledContourMapper | Draw labeled isolines |
| CvtkLabeledContourPolyDataItem | Filter that translate a vtkPolyData 2D mesh into vtkContextItems |
| CvtkLabeledDataMapper | Draw text labels at dataset points |
| CvtkLabeledTreeMapDataMapper | Draw text labels on a tree map |
| ►CvtkLabelHierarchy | Octree of labels |
| ►CImplementation | |
| CLabelSet | |
| CPriorityComparator | |
| CvtkLabelHierarchyAlgorithm | Superclass for algorithms that produce only label hierarchies as output |
| CvtkLabelHierarchyCompositeIterator | Iterator over sub-iterators |
| CvtkLabelHierarchyIterator | Iterator over vtkLabelHierarchy |
| CvtkLabelMapLookup | Provide an efficient numeric label lookup |
| CvtkLabelPlacementMapper | Places and renders non-overlapping labels |
| CvtkLabelPlacer | Place a prioritized hierarchy of labels in screen space |
| CvtkLabelRenderStrategy | Superclass for label rendering implementations |
| CvtkLabelSizeCalculator | This filter takes an input dataset, an array to process (which must be a string array), and a text property |
| CvtkLagrangeCurve | |
| CvtkLagrangeHexahedron | A 3D cell that represents an arbitrary order Lagrange hex |
| CvtkLagrangeInterpolation | |
| CvtkLagrangeQuadrilateral | |
| CvtkLagrangeTetra | A 3D cell that represents an arbitrary order Lagrange tetrahedron |
| CvtkLagrangeTriangle | A 2D cell that represents an arbitrary order Lagrange triangle |
| CvtkLagrangeWedge | A 3D cell that represents an arbitrary order Lagrange wedge |
| ►CvtkLagrangianBasicIntegrationModel | VtkFunctionSet abstract implementation to be used in the vtkLagrangianParticleTracker integrator |
| CArrayVal | |
| CSurfaceArrayDescription | |
| CvtkLagrangianMatidaIntegrationModel | VtkLagrangianBasicIntegrationModel implementation |
| CvtkLagrangianParticle | Basis class for Lagrangian particles |
| CvtkLagrangianParticleTracker | Filter to inject and track particles in a flow |
| CvtkLagrangianThreadedData | Struct to hold a user data |
| CvtkLandmarkTransform | Linear transform specified by two corresponding point sets |
| CvtkLargeInteger | Class for arbitrarily large ints |
| CvtkLASRasterReader | Reads LIDAR data saved using the LAS file format |
| CvtkLASReader | |
| CvtkLassoStencilSource | Create a stencil from a contour |
| CvtkLeaderActor2D | Create a leader with optional label and arrows |
| CvtkLegacyCellGridReader | Read vtk unstructured grid data file |
| CvtkLegacyCellGridWriter | Write VTK cell-grid data to a file |
| CvtkLegacyReaderVersion | Version number for legacy readers/writers |
| CvtkLegendBoxActor | Draw symbols with text |
| CvtkLegendScaleActor | Annotate the render window with scale and distance information |
| CvtkLengthDistribution | Sample the distribution of representative "cell lengths" of a mesh |
| CvtkLevelIdScalars | Empty class for backwards compatibility |
| CvtkLICNoiseHelper | A small collection of noise routines for LIC |
| CvtkLICRandomNoise2D | 2D Noise Generator |
| CvtkLICRandomNumberGeneratorInterface | An interface to a random number generator |
| CvtkLight | Virtual light for 3D rendering |
| CvtkLightActor | Cone and a frustum to represent a spotlight |
| CvtkLightCollection | Ordered list of lights |
| CvtkLightingMapPass | TO DO |
| CvtkLightKit | Simple but quality lighting kit |
| CvtkLightNode | VtkViewNode specialized for vtkLights |
| CvtkLightRepresentation | Represent a vtkLight |
| CvtkLightsPass | Implement the lights render pass |
| CvtkLightWidget | 3D widget for showing a LightRepresentation |
| CvtkLine | Cell represents a 1D line |
| CvtkLinearCellExtrusionFilter | Extrude polygonal data to create 3D cells from 2D cells |
| CvtkLinearContourLineInterpolator | Interpolates supplied nodes with line segments |
| CvtkLinearExtrusionFilter | Sweep polygonal data creating a "skirt" from free edges and lines, and lines from vertices |
| CvtkLinearKernel | Linear interpolation kernel |
| CvtkLinearSelector | Select cells intersecting a line (possibly broken) |
| CvtkLinearSubdivisionFilter | Generate a subdivision surface using the Linear Scheme |
| CvtkLinearToQuadraticCellsFilter | Degree elevate the cells of a linear unstructured grid |
| CvtkLinearTransform | Abstract superclass for linear transformations |
| CvtkLinearTransformCellLocator | Cell locator adaptor to perform cell Location on datasets that are a linear transformation of the original dataset |
| CvtkLineIntegralConvolution2D | GPU-based implementation of Line Integral Convolution (LIC) |
| CvtkLineRepresentation | Class defining the representation for a vtkLineWidget2 |
| CvtkLineSource | Create a line defined by two end points |
| CvtkLineWidget | 3D widget for manipulating a line |
| CvtkLineWidget2 | 3D widget for manipulating a finite, straight line |
| CvtkLinkEdgels | Links edgels together to form digital curves |
| CvtkLocationSelector | Selects cells containing or points near chosen point locations |
| CvtkLocator | Abstract base class for objects that accelerate spatial searches |
| CvtkLODActor | Actor that supports multiple levels of detail |
| CvtkLODProp3D | Level of detail 3D prop |
| CvtkLODProp3DEntry_t | |
| ►CvtkLogger | Logging framework for use in VTK and in applications based on VTK |
| CLogScopeRAII | |
| CMessage | The message structure that is passed to custom callbacks registered using vtkLogger::AddCallback |
| CvtkLogLookupTable | Map scalars into colors using log (base 10) scale |
| CvtkLogoRepresentation | Represent the vtkLogoWidget |
| CvtkLogoWidget | 2D widget for placing and manipulating a logo |
| CvtkLongArray | Dynamic, self-adjusting array of long |
| CvtkLongLongArray | Dynamic, self-adjusting array of long long |
| CvtkLookupTable | Map scalar values into colors via a lookup table |
| CvtkLookupTableItem | |
| CvtkLookupTableWithEnabling | A lookup table that allows for an optional array to be provided that specifies which scalars to "enable" and which to "disable" |
| CvtkLoopBooleanPolyDataFilter | Filter to perform boolean operations |
| CvtkLoopSubdivisionFilter | Generate a subdivision surface using the Loop Scheme |
| CvtkLSDynaPart | |
| CvtkLSDynaPartCollection | |
| CvtkLSDynaReader | Read LS-Dyna databases (d3plot) |
| CvtkLSDynaSummaryParser | This is a helper class used by vtkLSDynaReader to read XML files |
| CvtkLZ4DataCompressor | Data compression using LZ4 |
| CvtkLZMADataCompressor | Data compression using LZMA Utils |
| CvtkMagnifierRepresentation | Represent a vtkBorderWidget |
| CvtkMagnifierWidget | Create a moving, magnifying renderer that can inspect the contents of an encapsulating renderer |
| CvtkMapArrayValues | Map values in an input array to different values in an output array of (possibly) different type |
| CvtkMapMaskTextureId | |
| CvtkMappedDataArray | Map non-contiguous data structures into the vtkDataArray API |
| CvtkMappedUnstructuredGrid | Allows datasets with arbitrary storage layouts to be used with VTK |
| CvtkMappedUnstructuredGridCellIterator | Default cell iterator for vtkMappedUnstructuredGrid |
| CvtkMapper | Abstract class specifies interface to map data to graphics primitives |
| CvtkMapper2D | Abstract class specifies interface for objects which render 2D actors |
| CvtkMapperCollection | Ordered list of mappers |
| CvtkMapperNode | VtkViewNode specialized for vtkMappers |
| CvtkMarchingContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkMarchingCubes | Generate isosurface(s) from volume |
| CvtkMarchingCubesPolygonCases | |
| CvtkMarchingSquares | Generate isoline(s) from structured points set |
| CvtkMarkBoundaryFilter | Mark points and cells that lie on the boundary of a dataset |
| CvtkMarkerUtilities | Utilities for generating marker images |
| ►CvtkMarshalContext | Shared context used by vtkSerializer and vtkDeserializer |
| CScopedParentTracker | Convenient to push a parent as the 'active' identifier and add children to that parent when (de)serializing sub-states or sub-objects |
| ►CvtkMaskFields | Allow control of which fields get passed to the output |
| CCopyFieldFlag | |
| CvtkMaskPoints | Selectively filter points |
| CvtkMaskPointsFilter | Extract points within an image/volume mask |
| CvtkMaskPolyData | Sample subset of input polygonal data cells |
| CvtkMassProperties | Estimate volume, area, shape index of triangle mesh |
| CvtkMath | Performs common math operations |
| CvtkMathPrivate | Internal toolkit used in some vtkMath methods |
| CvtkMathTextFreeTypeTextRenderer | Default implementation of vtkTextRenderer |
| CvtkMathTextUtilities | Abstract interface to equation rendering |
| CvtkMathTextUtilitiesCleanup | |
| CvtkMathUtilities | Templated utility math functions intended for internal use in tests etc |
| CvtkMatplotlibMathTextUtilities | Access to MatPlotLib MathText rendering |
| CvtkMatricizeArray | Convert an array of arbitrary dimensions to a matrix |
| CvtkMatrix3x3 | Represent and manipulate 3x3 transformation matrices |
| CvtkMatrix4x4 | Represent and manipulate 4x4 transformation matrices |
| CvtkMatrixMathFilter | Calculate functions of quality of the elements of a mesh |
| CvtkMatrixToHomogeneousTransform | Convert a matrix to a transform |
| CvtkMatrixToLinearTransform | Convert a matrix to a transform |
| CvtkmAverageToCells | |
| CvtkmAverageToPoints | Accelerated point to cell interpolation filter |
| CvtkmCleanGrid | Removes redundant or unused cells and/or points |
| ►CvtkmClip | Clip a dataset using the accelerated vtk-m Clip filter |
| Cinternals | |
| CvtkmContour | Generate isosurface(s) from volume |
| CvtkmCoordinateSystemTransform | Transform a coordinate system between Cartesian&Cylindrical and Cartesian&Spherical |
| CvtkMCubesReader | Read binary marching cubes file |
| CvtkMCubesWriter | Write binary marching cubes file |
| CvtkmDataArray | Wraps a VTK-m ArrayHandle inside a sub-class of vtkGenericDataArray |
| CvtkmDataSet | |
| CvtkMeanValueCoordinatesInterpolator | Compute interpolation computes for closed triangular mesh |
| CvtkMeasurementCubeHandleRepresentation3D | Represent a unit cube for measuring/comparing to data |
| CvtkMedicalImageProperties | Some medical image properties |
| CvtkMedicalImageReader2 | VtkImageReader2 with medical meta data |
| CvtkMemoryLimitImageDataStreamer | Initiates streaming on image data |
| CvtkMemoryResourceStream | vtkResourceStream implementation for memory input |
| CvtkMergeArrays | Multiple inputs with one output |
| CvtkMergeBlocks | Merges blocks in a composite dataset to a dataset |
| CvtkMergeCells | Merges any number of vtkDataSets back into a single vtkUnstructuredGrid |
| CvtkMergeColumns | Merge two columns into a single column |
| CvtkMergeDataObjectFilter | Merge dataset and data object field to create dataset with attribute data |
| ►CvtkMergeFields | Merge multiple fields into one |
| CComponent | |
| CvtkMergeFilter | Extract separate components of data from different datasets |
| CvtkMergeGraphs | Combines two graphs |
| CvtkMergePoints | Merge exactly coincident points |
| CvtkMergeTables | Combine two tables |
| CvtkMergeTimeFilter | Create a multiblock containing one block per input, with unified timestep list |
| CvtkMergeVectorComponents | Merge components of many single-component arrays into one vector |
| CvtkMersenneTwister | Generator for Mersenne Twister pseudorandom numbers |
| CvtkMeshQuality | Calculate functions of quality of the elements of a mesh |
| CvtkMetaImageReader | Read binary UNC meta image data |
| CvtkMetaImageWriter | Write a binary UNC meta image data |
| CvtkmExternalFaces | Generate External Faces of a DataSet |
| CvtkmExtractVOI | Select piece (e.g., volume of interest) and/or subsample structured points dataset |
| CvtkMFCWindow | Class to display a VTK window in an MFC window |
| CvtkmFilterOverrides | A class with static methods to turn vtkm filter overrides on/off at runtime |
| CvtkMFIXReader | Reads a dataset in MFIX file format |
| CvtkmGradient | A general filter for gradient estimation |
| CvtkmHistogram | Generate a histogram out of a scalar data |
| CvtkmImageConnectivity | Label regions inside an image by connectivity |
| CvtkMINCImageAttributes | A container for a MINC image header |
| CvtkMINCImageReader | A reader for MINC files |
| CvtkMINCImageWriter | A writer for MINC files |
| CvtkMinimalStandardRandomSequence | Park and Miller Sequence of pseudo random numbers |
| CvtkmInitializer | |
| CvtkmLevelOfDetail | Reduce the number of triangles in a mesh |
| CvtkmNDHistogram | Generate a n dimensional histogram field from input fields |
| CvtkMNIObjectReader | A reader for MNI surface mesh files |
| CvtkMNIObjectWriter | A writer for MNI surface mesh files |
| CvtkMNITagPointReader | A reader for MNI tag files |
| CvtkMNITagPointWriter | A writer for MNI tag point files |
| CvtkMNITransformReader | A reader for MNI transformation files |
| CvtkMNITransformWriter | A writer for MNI transformation files |
| CvtkModelMetadata | This class encapsulates the metadata that appear in mesh-based file formats but do not appear in vtkUnstructuredGrid |
| CvtkModifiedBSPTree | Generate axis aligned BBox tree for ray-casting and other Locator based searches |
| CvtkMolecule | Class describing a molecule |
| CvtkMoleculeAlgorithm | Superclass for algorithms that operate on vtkMolecules |
| CvtkMoleculeAppend | Appends one or more molecules into a single molecule |
| CvtkMoleculeMapper | Mapper that draws vtkMolecule objects |
| CvtkMoleculeReaderBase | Read molecular data files |
| CvtkMoleculeToAtomBallFilter | Generate polydata with spheres representing atoms |
| CvtkMoleculeToBondStickFilter | Generate polydata with cylinders representing bonds |
| CvtkMoleculeToLinesFilter | Convert a molecule into a simple polydata with lines |
| CvtkMoleculeToPolyDataFilter | Abstract filter class |
| CvtkMotionFXCFGReader | Reader for MotionFX motion definitions cfg files |
| CvtkMP4Writer | Writes Windows MP4 files on Windows platforms |
| CvtkMPASReader | Read an MPAS netCDF file |
| CvtkMPI4PyCommunicator | Class for bridging MPI4Py with vtkMPICommunicator |
| ►CvtkMPICommunicator | Class for creating user defined MPI communicators |
| CRequest | |
| CvtkMPIController | Process communication using MPI |
| CvtkMPIEventLog | Class for logging and timing |
| 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 |
| CvtkMPIMultiBlockPLOT3DReader | VtkMultiBlockPLOT3DReader subclass that uses MPI-IO to efficiently read binary files for 3D domains in parallel using MPI-IO |
| CvtkMPIPixelTT | |
| CvtkMPIPixelView | MPI datatypes that describe a vtkPixelExtent |
| CvtkmPointElevation | Generate a scalar field along a specified direction |
| CvtkmPointTransform | Transform points via vtkm PointTransform filter |
| CvtkmPolyDataNormals | Compute normals for polygonal mesh |
| CvtkmProbe | Sample data at specified point locations |
| CvtkMRCReader | Read MRC image files |
| CvtkmSlice | Generate |
| CvtkmThreshold | Extracts cells where scalar value in cell satisfies threshold criterion |
| CvtkmTriangleMeshPointNormals | Compute point normals for triangle mesh |
| CvtkMultiBlockDataGroupFilter | Collects multiple inputs into one multi-group dataset |
| CvtkMultiBlockDataSet | Composite dataset that organizes datasets into blocks |
| CvtkMultiBlockDataSetAlgorithm | Superclass for algorithms that produce only vtkMultiBlockDataSet as output |
| CvtkMultiBlockMergeFilter | Merges multiblock inputs into a single multiblock output |
| CvtkMultiBlockPLOT3DReader | Read PLOT3D data files |
| ►CvtkMultiBlockPLOT3DReaderInternals | |
| CDims | |
| CInternalSettings | |
| CvtkMultiBlockPLOT3DReaderRecord | |
| CvtkMultiBlockUnstructuredGridVolumeMapper | Mapper to render volumes defined as vtkMultiBlockDataSet |
| CvtkMultiBlockVolumeMapper | Mapper to render volumes defined as vtkMultiBlockDataSet |
| CvtkMultiCorrelativeAssessFunctor | |
| CvtkMultiCorrelativeStatistics | A class for multivariate linear correlation |
| CvtkMultiNewickTreeReader | Read multiple vtkTrees from Newick formatted file |
| CvtkMultiObjectMassProperties | Compute volume and area of objects in a polygonal mesh |
| CvtkMultiPieceDataSet | Composite dataset to encapsulates pieces of dataset |
| CvtkMultiProcessController | Multiprocessing communication superclass |
| CvtkMultiProcessControllerHelper | Collection of assorted helper routines dealing with communication |
| CvtkMultiProcessStream | Stream used to pass data across processes using vtkMultiProcessController |
| ►CvtkMultiThreader | A class for performing multithreaded execution |
| CThreadInfo | This is the structure that is passed to the thread that is created from the SingleMethodExecute, MultipleMethodExecute or the SpawnThread method |
| ►CvtkMultiThreshold | Threshold cells within multiple intervals |
| CBooleanSet | A subset of a mesh represented as a boolean set operation |
| CInterval | A subset of a mesh represented by a range of acceptable attribute values |
| CNormKey | A class with comparison operator used to index input array norms used in threshold rules |
| CSet | A base class for representing threshold sets |
| CvtkMultiTimeStepAlgorithm | Superclass for algorithms that would like to make multiple time requests |
| CvtkMultiVolume | Represents a world axis-aligned bounding-box containing a set of volumes in a rendered scene |
| CvtkMutableDirectedGraph | An editable directed graph |
| CvtkMutableGraphHelper | Helper class for building a directed or directed graph |
| CvtkMutableUndirectedGraph | An editable undirected graph |
| CvtkmWarpScalar | Deform geometry with scalar data |
| CvtkmWarpVector | Deform geometry with vector data |
| CvtkMySQLDatabase | Maintain a connection to a MySQL database |
| CvtkMySQLDatabasePrivate | |
| CvtkMySQLQuery | VtkSQLQuery implementation for MySQL databases |
| CvtkMySQLToTableReader | Read a MySQL table as a vtkTable |
| CvtkNamedColors | A class holding colors and their names |
| CvtkNativePartitioningStrategy | A partitioning strategy based on load balancing geometric bounding boxes as cuts of a data set |
| CvtkNek5000Reader | Reads Nek5000 format data files |
| CvtkNetCDFCAMReader | Read unstructured NetCDF CAM files |
| ►CvtkNetCDFCFReader | Reads netCDF files that follow the CF convention |
| CvtkDependentDimensionInfo | |
| CvtkDimensionInfo | |
| CvtkNetCDFCFWriter | Writes netCDF files that follow the CF convention |
| CvtkNetCDFPOPReader | Read NetCDF files .Author Joshua Wu 09.15.2009 |
| CvtkNetCDFReader | A superclass for reading netCDF files |
| CvtkNetCDFUGRIDeader | Read unstructured NetCDF UGRID files |
| CvtkNetCDFUGRIDReader | |
| CvtkNetworkHierarchy | Filter that takes a graph and makes a tree out of the network ip addresses in that graph |
| CvtkNew | Allocate and hold a VTK object |
| CvtkNewickTreeReader | Read vtkTree from Newick formatted file |
| CvtkNewickTreeWriter | Write vtkTree data to Newick format |
| CvtkNIFTIImageHeader | Store NIfTI header information |
| CvtkNIFTIImageReader | Read NIfTI-1 and NIfTI-2 medical image files |
| CvtkNIFTIImageWriter | Write NIfTI-1 and NIfTI-2 medical image files |
| CvtkNonLinearCell | Abstract superclass for non-linear cells |
| CvtkNonMergingPointLocator | Direct / check-free point insertion |
| CvtkNonOverlappingAMR | A concrete instance of vtkUniformGridAMR to store uniform grids at different levels of resolution that do not overlap with each other |
| CvtkNonOverlappingAMRAlgorithm | Produce vtkNonOverlappingAMR as output |
| CvtkNonOverlappingAMRLevelIdScalars | Generate scalars from levels |
| 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) |
| CvtkNrrdReader | Read nrrd files file system |
| ►CvtkNumberToString | Convert floating and fixed point numbers to strings |
| CTagDouble | |
| CTagFloat | |
| CvtkOBBDicer | Divide dataset into spatially aggregated pieces |
| CvtkOBBNode | |
| CvtkOBBTree | Generate oriented bounding box (OBB) tree |
| CvtkObject | Abstract base class for most VTK objects |
| ►CvtkObjectBase | Abstract base class for most VTK objects |
| CvtkMemkindRAII | A class to help modify and restore the global UsingMemkind state, like SetUsingMemkind(newValue), but safer |
| ►CvtkObjectFactory | Abstract base class for vtkObjectFactories |
| COverrideInformation | |
| CvtkObjectFactoryCollection | Maintain a list of object factories |
| CvtkObjectFactoryRegistryCleanup | |
| 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 |
| CvtkOBJExporter | Export a scene into Wavefront format |
| CvtkOBJImportedMaterial | |
| CvtkOBJImporter | Import from .obj wavefront files |
| CvtkOBJPolyDataProcessor | |
| CvtkOBJReader | Read Wavefront .obj files |
| CvtkOBJWriter | Write wavefront obj file |
| CvtkObserverMediator | Manage contention for cursors and other resources |
| CvtkOCCTReader | VTK Reader for STEP and IGES files using OpenCASCADE |
| CvtkOctreeImageToPointSetFilter | Convert an octree image to point set |
| CvtkOctreePointLocator | Octree spatial decomposition of a set of points |
| CvtkOctreePointLocatorNode | Octree node that has 8 children each of equal size |
| CvtkODBCDatabase | Maintain an ODBC connection to a SQL database |
| CvtkODBCInternals | Simple class to hide ODBC structures |
| CvtkODBCQuery | VtkSQLQuery implementation for ODBC connections to databases |
| CvtkOFFReader | Read Geomview .off files |
| CvtkOggTheoraWriter | Uses the ogg and theora libraries to write video files |
| CvtkOldStyleCallbackCommand | Supports legacy function callbacks for VTK |
| CvtkOMETIFFReader | Reader for OME TIFF files |
| CvtkOMFReader | Read Open Mining Format files |
| CvtkOOGLExporter | Export a scene into Geomview OOGL format |
| CvtkOpaquePass | Render the opaque geometry with property key filtering |
| CvtkOpenFOAMReader | Reads a dataset in OpenFOAM format |
| CvtkOpenGL2ContextDevice2DCellArrayHelper | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| CvtkOpenGL2ContextDevice2DPrivate | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| CvtkOpenGLActor | OpenGL actor |
| CvtkOpenGLArrayTextureBufferAdapter | Interfaces vtkDataArray to an OpenGL texture buffer |
| CvtkOpenGLAvatar | OpenGL Avatar |
| CvtkOpenGLBatchedPolyDataMapper | An OpenGL mapper for batched rendering of vtkPolyData |
| CvtkOpenGLBillboardTextActor3D | Handles GL2PS capture of billboard text |
| CvtkOpenGLBufferObject | OpenGL buffer object |
| CvtkOpenGLCamera | OpenGL camera |
| CvtkOpenGLCellGridMapper | CellGrid mapper using OpenGL to render exotic finite element fields and cells |
| CvtkOpenGLCellToVTKCellMap | OpenGL rendering utility functions |
| ►CvtkOpenGLCompositePolyDataMapperDelegator | An OpenGL delegator for batched rendering of multiple polydata with similar structure |
| CGLBatchElement | |
| CvtkOpenGLContextActor | VtkProp derived object |
| CvtkOpenGLContextBufferId | 2D array of ids stored in VRAM |
| ►CvtkOpenGLContextDevice2D | Class for drawing 2D primitives using OpenGL 1.1+ |
| CCellArrayHelper | |
| CPrivate | |
| CvtkOpenGLContextDevice3D | OpenGL class drawing 3D primitives |
| CvtkOpenGLContextDeviceBufferObjectBuilder | Internal buffer object builder that maintains a cache of VBO groups |
| CvtkOpenGLES30PolyDataMapper2D | 2D PolyData support for OpenGL ES 3.0 |
| CvtkOpenGLFluidMapper | Render fluid from position data (and color, if available) |
| CvtkOpenGLFramebufferObject | Internal class which encapsulates OpenGL FramebufferObject |
| CvtkOpenGLFXAAFilter | Perform FXAA antialiasing on the current framebuffer |
| CvtkOpenGLFXAAPass | Render pass calling the FXAA filter |
| CvtkOpenGLGL2PSExporter | OpenGL2 implementation of GL2PS exporter |
| CvtkOpenGLGL2PSHelper | Access GL2PS functionality |
| CvtkOpenGLGL2PSHelperImpl | VtkOpenGLGL2PSHelper override implementation |
| CvtkOpenGLGlyph3DHelper | PolyDataMapper using OpenGL to render |
| CvtkOpenGLGlyph3DMapper | VtkOpenGLGlyph3D on the GPU |
| CvtkOpenGLGPUVolumeRayCastMapper | OpenGL implementation of volume rendering through ray-casting |
| CvtkOpenGLHardwareSelector | Implements the device specific code of vtkOpenGLHardwareSelector |
| CvtkOpenGLHelper | |
| CvtkOpenGLHyperTreeGridMapper | Map vtkHyperTreeGrid to graphics primitives |
| CvtkOpenGLImageAlgorithmCallback | |
| CvtkOpenGLImageAlgorithmHelper | Help image algorithms use the GPU |
| CvtkOpenGLImageGradient | Compute Gradient using the GPU |
| CvtkOpenGLImageMapper | 2D image display support for OpenGL |
| CvtkOpenGLImageSliceMapper | OpenGL mapper for image slice display |
| CvtkOpenGLIndexBufferObject | OpenGL vertex buffer object |
| ►CvtkOpenGLInstanceCulling | Frustum culling and LOD management |
| CInstanceLOD | |
| CvtkOpenGLLabeledContourMapper | VtkOpenGLLabeledContourMapper is an override for vtkLabeledContourMapper that implements stenciling using the OpenGL2 API |
| CvtkOpenGLLight | OpenGL light |
| ►CvtkOpenGLLowMemoryBatchedPolyDataMapper | An OpenGL mapper for batched rendering of vtkPolyData |
| CGLBatchElement | |
| 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 |
| ►CvtkOpenGLLowMemoryPolyDataMapper | PolyDataMapper using OpenGL to render surface meshes |
| CCellGroupInformation | |
| CExtraAttributeValue | |
| CPrimitiveInformation | |
| 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 |
| CvtkOpenGLMoleculeMapper | An accelerated class for rendering molecules |
| CvtkOpenGLMovieSphere | OpenGL MovieSphere, an optimized VR sphere for movies |
| CvtkOpenGLPointGaussianMapper | Draw PointGaussians using imposters |
| CvtkOpenGLPointGaussianMapperHelper | |
| ►CvtkOpenGLPolyDataMapper | PolyDataMapper using OpenGL to render |
| CExtraAttributeValue | |
| CprimitiveInfo | |
| CvtkOpenGLPolyDataMapper2D | 2D PolyData support for OpenGL |
| CvtkOpenGLProjectedTetrahedraMapper | OpenGL implementation of PT |
| CvtkOpenGLProperty | OpenGL property |
| CvtkOpenGLPropItem | Sync Context2D state with vtk camera |
| CvtkOpenGLQuadHelper | Class to make rendering a full screen quad easier |
| CvtkOpenGLRayCastImageDisplayHelper | OpenGL subclass that draws the image to the screen |
| CvtkOpenGLRenderer | OpenGL renderer |
| CvtkOpenGLRenderPass | Abstract render pass with shader modifications |
| CvtkOpenGLRenderTimer | Asynchronously measures GPU execution time for a single event |
| ►CvtkOpenGLRenderTimerLog | OpenGL2 override for vtkRenderTimerLog |
| COGLEvent | |
| COGLFrame | |
| CvtkOpenGLRenderUtilities | OpenGL rendering utility functions |
| CvtkOpenGLRenderWindow | OpenGL rendering window |
| CvtkOpenGLResourceFreeCallback | |
| CvtkOpenGLShaderCache | Manage Shader Programs within a context |
| CvtkOpenGLShaderDeclaration | |
| CvtkOpenGLShaderProperty | Represent GPU shader properties |
| CvtkOpenGLSkybox | OpenGL Skybox |
| CvtkOpenGLSphereMapper | Draw spheres using imposters |
| ►CvtkOpenGLState | OpenGL state storage |
| CBufferBindingState | |
| CGLState | |
| CScopedglActiveTexture | |
| CScopedglBlendFuncSeparate | |
| CScopedglClearColor | |
| CScopedglColorMask | |
| CScopedglDepthFunc | |
| CScopedglDepthMask | |
| CScopedglEnableDisable | |
| CScopedglScissor | |
| CScopedglViewport | |
| CScopedValue | |
| CvtkOpenGLStickMapper | Use imposters to draw cylinders |
| CvtkOpenGLTextActor | VtkTextActor override |
| CvtkOpenGLTextActor3D | OpenGL2 override for vtkTextActor3D |
| CvtkOpenGLTextMapper | VtkTextMapper override for OpenGL2 |
| CvtkOpenGLTexture | OpenGL texture map |
| CvtkOpenGLUniforms | Helper class to set custom uniform variables in GLSL shaders |
| CvtkOpenGLVertexArrayObject | The VertexArrayObject class uses, or emulates, vertex array objects |
| CvtkOpenGLVertexBufferObject | |
| CvtkOpenGLVertexBufferObjectCache | Manage vertex buffer objects shared within a context |
| CvtkOpenGLVertexBufferObjectGroup | Manage vertex buffer objects shared within a mapper |
| CvtkOpenGLVolumeGradientOpacityTable | |
| CvtkOpenGLVolumeLookupTable | Base class for OpenGL texture management of scalar color, opacity and gradient opacity lookup tables |
| CvtkOpenGLVolumeLookupTables | Internal class that manages multiple lookup tables |
| CvtkOpenGLVolumeMaskGradientOpacityTransferFunction2D | 2D Transfer function container for label map mask gradient opacity |
| CvtkOpenGLVolumeMaskTransferFunction2D | 2D Transfer function container |
| CvtkOpenGLVolumeOpacityTable | |
| CvtkOpenGLVolumeRGBTable | |
| CvtkOpenGLVolumeTransferFunction2D | 2D Transfer function container |
| CvtkOpenQubeElectronicData | Provides access to and storage of electronic data calculated by OpenQube |
| CvtkOpenQubeMoleculeSource | Read a OpenQube readable file and output a vtkMolecule object |
| CvtkOpenSlideReader | Read digital whole slide images supported by openslide library |
| CvtkOpenVDBReader | OpenVDB reader Reader for OpenVDB files |
| CvtkOpenVDBWriter | OpenVDB writer for vtkImageData or vtkPointSet Writes a vtkImageData or vtkPointSet as a VDB file |
| CvtkOpenVRCamera | OpenVR camera |
| CvtkOpenVRCameraPose | |
| CvtkOpenVRControlsHelper | Tooltip helper explaining controls Helper class to draw one tooltip per button around the controller |
| CvtkOpenVRDefaultOverlay | OpenVR overlay |
| CvtkOpenVRInteractorStyle | Implements OpenVR specific functions required by vtkVRInteractorStyle |
| CvtkOpenVRModel | OpenVR device model |
| CvtkOpenVROverlay | OpenVR overlay |
| CvtkOpenVROverlaySpot | |
| CvtkOpenVRRenderer | OpenVR renderer |
| CvtkOpenVRRenderWindow | OpenVR rendering window |
| ►CvtkOpenVRRenderWindowInteractor | Implements OpenVR specific functions required by vtkVRRenderWindowInteractor |
| CActionData | |
| CTrackerActions | |
| CvtkOpenXRCamera | OpenXR camera |
| CvtkOpenXRControlsHelper | Tooltip helper explaining controls Helper class to draw one tooltip per button around the controller |
| CvtkOpenXRInteractorStyle | Extended from vtkInteractorStyle3D to override command methods |
| ►CvtkOpenXRManager | Singleton class that holds a collection of utility functions and member variables to communicate with the OpenXR runtime |
| CAction_t | |
| CInstanceVersion | Structure representing OpenXR instance version |
| CRenderResources_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 |
| CSwapchain_t | Swapchain structure storing information common to all rendering backend |
| CvtkOpenXRManagerConnection | OpenXR manager connection no-op implementation |
| ►CvtkOpenXRManagerD3DGraphics | OpenXR manager D3D graphics implementation |
| CSwapchainImagesD3D | D3D structure to store swapchain images |
| CvtkOpenXRManagerGraphics | OpenXR manager graphics implementation |
| ►CvtkOpenXRManagerOpenGLGraphics | OpenXR manager OpenGL graphics implementation |
| CSwapchainImagesOpenGL | OpenGL structure to store swapchain images |
| CvtkOpenXRManagerRemoteConnection | OpenXR remoting connection strategy |
| CvtkOpenXRModel | OpenXR device model |
| CvtkOpenXRRemotingRenderWindow | OpenXR remoting rendering window |
| CvtkOpenXRRenderer | OpenXR renderer |
| CvtkOpenXRRenderWindow | OpenXR rendering window |
| ►CvtkOpenXRRenderWindowInteractor | Implements OpenXR specific functions required by vtkRenderWindowInteractor |
| CActionData | |
| CvtkOpenXRUtilities | Header file that contains utility functions for OpenXR |
| CvtkOrderedTriangulator | Helper class to generate triangulations |
| CvtkOrderIndependentTranslucentPass | Implement OIT rendering using average color |
| CvtkOrderStatistics | A class for univariate order statistics |
| CvtkOrientationMarkerWidget | 2D widget for manipulating a marker prop |
| CvtkOrientationRepresentation | Class defining the representation for the vtkOrientationWidget |
| CvtkOrientationWidget | 3D Widget for manipulating a vtkCamera |
| CvtkOrientedGlyphContourRepresentation | Default representation for the contour widget |
| CvtkOrientedGlyphFocalPlaneContourRepresentation | Contours constrained to a focal plane |
| CvtkOrientedPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D while maintaining a fixed orientation w.r.t the camera |
| CvtkOrientPolyData | Auto detect correct normal orientation and/or enforce consistent polygon ordering |
| CvtkOSOpenGLRenderWindow | OffScreen Mesa rendering window |
| CvtkOSPRayActorNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkOSPRayAMRVolumeMapperNode | Links vtkVolumeMapper to OSPRay |
| CvtkOSPRayCache | Temporal cache ospray structures to speed flipbooks |
| CvtkOSPRayCacheItemObject | |
| CvtkOSPRayCameraNode | Links vtkCamera to OSPRay |
| ►CvtkOSPRayCompositePolyDataMapper2Node | Links vtkActor and vtkMapper to OSPRay |
| CRenderBlockState | |
| ►CvtkOSPRayCompositePolyDataMapperNode | Links vtkActor and vtkMapper to OSPRay |
| CRenderBlockState | |
| CvtkOSPRayLightNode | Links vtkLights to OSPRay |
| CvtkOSPRayMaterialHelpers | Convert vtk appearance controls to ospray materials |
| CvtkOSPRayMaterialLibrary | Collection of materials for vtk apps to draw from |
| CvtkOSPRayMoleculeMapperNode | Links vtkMoleculeMapper to OSPRay |
| CvtkOSPRayPass | Render pass that uses OSPRay instead of GL |
| CvtkOSPRayPointGaussianMapperNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkOSPRayPolyDataMapperNode | Links vtkActor and vtkMapper to OSPRay |
| CvtkOSPRayRendererNode | Links vtkRenderers to OSPRay |
| CvtkOSPRayTestInteractor | |
| CvtkOSPRayUnstructuredVolumeMapperNode | Unstructured grid volume renderer |
| CvtkOSPRayViewNodeFactory | Matches vtk rendering classes to specific ospray ViewNode classes |
| CvtkOSPRayVolumeInterface | Removes link dependence on optional ospray module |
| CvtkOSPRayVolumeMapper | Standalone OSPRayVolumeMapper |
| CvtkOSPRayVolumeMapperNode | Links vtkVolumeMapper to OSPRay |
| CvtkOSPRayVolumeNode | Links vtkVolume and vtkMapper to OSPRay |
| CvtkOSPRayWindowNode | Links vtkRendererWindows to OSPRay |
| ►CvtkOStreamWrapper | Wrapper for C++ ostream |
| CEndlType | Type for a fake endl |
| CvtkOStrStreamWrapper | Wrapper for ostrstream |
| CvtkOTDensityMap | A VTK Filter to compute density map on any pair of numeric data arrays with the same number of tuples, using OpenTURNS |
| CvtkOTFilter | A generic VTK Filter to process vtkTable using openturns algorithm |
| CvtkOTKernelSmoothing | A VTK Filter to compute Kernel Smoothing using PDF computation from openturns |
| CvtkOTScatterPlotMatrix | Container for a matrix of charts |
| CvtkOTUtilities | |
| CvtkOutEdgeIterator | Iterates through all outgoing edges from a vertex |
| CvtkOutEdgeType | |
| CvtkOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
| CvtkOutlineCornerSource | Create wireframe outline corners around bounding box |
| CvtkOutlineFilter | Create wireframe outline for an arbitrary data set or composite dataset |
| CvtkOutlineGlowPass | Renders a glowing outline using a image processing pass |
| CvtkOutlineSource | Create wireframe outline around bounding box |
| CvtkOutputStream | Wraps a binary output stream with a VTK interface |
| CvtkOutputWindow | Base class for writing debug output to a console |
| CvtkOutputWindowCleanup | |
| CvtkOverlappingAMR | Hierarchical dataset of vtkUniformGrids |
| CvtkOverlappingAMRAlgorithm | A base class for all algorithms that take as input vtkOverlappingAMR and produce vtkOverlappingAMR |
| CvtkOverlappingAMRLevelIdScalars | Generate scalars from levels |
| CvtkOverlappingCellsDetector | Exposes how many cells each cell of the input collide |
| CvtkOverlayPass | Render the overlay geometry with property key filtering |
| CvtkOverrideInformation | Factory object override information |
| CvtkOverrideInformationCollection | Maintain a list of override information objects |
| CvtkPackLabels | Renumber segmentation labels into contiguous runs of (potentially) smaller type |
| CvtkPainterCommunicator | A communicator that can safely be used inside a painter |
| CvtkPairwiseExtractHistogram2D | Compute a 2D histogram between all adjacent columns of an input vtkTable |
| CvtkPanoramicProjectionPass | Render pass that render the scene in a cubemap and project these six renderings to a single quad |
| CvtkParallelAMRUtilities | A concrete instance of vtkObject that employs a singleton design pattern and implements functionality for AMR specific operations |
| CvtkParallelCoordinatesActor | Create parallel coordinate display from input field |
| CvtkParallelCoordinatesHistogramRepresentation | Data representation that takes generic multivariate data and produces a parallel coordinates plot |
| CvtkParallelCoordinatesInteractorStyle | Interactive manipulation of the camera specialized for parallel coordinates |
| CvtkParallelCoordinatesRepresentation | Data representation that takes generic multivariate data and produces a parallel coordinates plot |
| CvtkParallelCoordinatesView | View to be used with vtkParallelCoordinatesRepresentation |
| CvtkParallelopipedRepresentation | Default representation for vtkParallelopipedWidget |
| CvtkParallelopipedWidget | Widget to manipulate 3D parallelopipeds |
| CvtkParallelReader | Superclass for algorithms that are parallel aware |
| ►CvtkParallelRenderManager | An object to control parallel rendering |
| CLightInfo | |
| CRendererInfo | |
| CRenderWindowInfo | |
| ►CvtkParallelTimer | Provides distributed log functionality |
| CLogBodyType | Type used to direct an output stream into the log's body |
| CLogHeaderType | Type used to direct an output stream into the log's header |
| CvtkParallelVectors | Compute polylines corresponding to locations where two vector fields are parallel |
| 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 |
| CvtkParametricFunction | Abstract interface for parametric functions |
| CvtkParametricFunctionSource | Tessellate parametric functions |
| 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 |
| CvtkParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkParticleReader | Read ASCII or binary particle data and (optionally) one scalar value associated with each particle |
| CvtkParticleTracer | A Parallel Particle tracer for unsteady vector fields |
| ►CvtkParticleTracerBase | A particle tracer for vector fields |
| Cbounds_t | |
| CvtkPartitionBalancer | Balances input partitioned data sets so each rank has the same number of data sets |
| CvtkPartitionedArchiver | Writes an archive to several buffers |
| CvtkPartitionedDataSet | Composite dataset to encapsulates a dataset consisting of partitions |
| CvtkPartitionedDataSetAlgorithm | Superclass for algorithms that produce vtkPartitionedDataSetAlgorithm |
| CvtkPartitionedDataSetCollection | Composite dataset that groups datasets as a collection |
| CvtkPartitionedDataSetCollectionAlgorithm | Superclass for algorithms that produce vtkPartitionedDataSetCollectionAlgorithm |
| CvtkPartitionedDataSetCollectionSource | Source that produces a vtkPartitionedDataSetCollection |
| CvtkPartitionedDataSetSource | Source that produces a vtkPartitionedDataSet |
| ►CvtkPartitioningStrategy | A strategy interface for partitioning meshes |
| CPartitionInformation | Encapsulation structure for describing the result of a partitioning calculation |
| CvtkPassArrays | Passes a subset of arrays to the output |
| CvtkPassInputTypeAlgorithm | Superclass for algorithms that produce output of the same type as input |
| CvtkPassSelectedArrays | Pass through chosen arrays |
| CvtkPassThrough | Pass input input data through to the output |
| CvtkPassThroughEdgeStrategy | Passes edge routing information through |
| CvtkPassThroughLayoutStrategy | Layout strategy that does absolutely nothing |
| CvtkPath | Concrete dataset representing a path defined by Bezier curves |
| CvtkPAutoCorrelativeStatistics | A class for parallel auto-correlative statistics |
| CvtkPBivariateLinearTableThreshold | Performs line-based thresholding for vtkTable data in parallel |
| 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 |
| CvtkPCAAnalysisFilter | Performs principal component analysis of a set of aligned pointsets |
| CvtkPCACurvatureEstimation | Generate curvature estimates using principal component analysis |
| CvtkPCANormalEstimation | Generate point normals using local tangent planes |
| CvtkPCAStatistics | A class for multivariate principal component analysis |
| CvtkPCellDataToPointData | Compute point arrays from cell arrays |
| CvtkPCellSizeFilter | Computes cell sizes in parallel |
| CvtkPChacoReader | Read Chaco files |
| CvtkPComputeHistogram2DOutliers | Extract outlier rows from a vtkTable based on input 2D histograms, in parallel |
| CvtkPComputeQuantiles | A class for parallel univariate order statistics |
| CvtkPComputeQuartiles | A class for parallel univariate order statistics |
| CvtkPConnectivityFilter | Parallel version of vtkConnectivityFilter |
| CvtkPContingencyStatistics | A class for parallel bivariate contingency statistics |
| CvtkPConvertToMultiBlockDataSet | Parallel version of vtkConvertToMultiBlockDataSet |
| CvtkPCorrelativeStatistics | A class for parallel bivariate correlative statistics |
| CvtkPDALReader | Reads LIDAR data using the PDAL library |
| CvtkPDataSetReader | Manages reading pieces of a data set |
| CvtkPDataSetWriter | Manages writing pieces of a data set |
| CvtkPDBReader | Read Molecular Data files |
| CvtkPDescriptiveStatistics | A class for parallel univariate descriptive statistics |
| CvtkPDFContextDevice2D | VtkContextDevice2D implementation for use with vtkPDFExporter |
| CvtkPDFExporter | Exports vtkContext2D scenes to PDF |
| 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 |
| CvtkPDistributedDataFilter | Distribute data among processors |
| CvtkPen | Pen that draws the outlines of shapes drawn by vtkContext2D |
| CvtkPentagonalPrism | 3D cell that represents a convex prism with pentagonal base |
| CvtkPeriodicDataArray | Map native an Array into an angulat periodic array |
| CvtkPeriodicFilter | A filter to produce mapped periodic multiblock dataset from a single block |
| CvtkPeriodicTable | Access to information about the elements |
| CvtkPerlinNoise | Implicit function that implements Perlin noise |
| CvtkPerspectiveTransform | Describes a 4x4 matrix transformation |
| CvtkPerturbCoincidentVertices | Perturbs vertices that are coincident |
| CvtkPExodusIIReader | Read Exodus II files (.exii) |
| CvtkPExodusIIWriter | Write Exodus II files |
| CvtkPExtractDataArraysOverTime | Parallel version of vtkExtractDataArraysOverTime |
| CvtkPExtractExodusGlobalTemporalVariables | Parallel version of vtkExtractExodusGlobalTemporalVariables |
| CvtkPExtractGrid | Extract VOI and/or sub-sample a distributed structured dataset |
| CvtkPExtractHistogram2D | Compute a 2D histogram between two columns of an input vtkTable in parallel |
| CvtkPExtractRectilinearGrid | Extract VOI and/or sub-sample a distributed rectilinear grid dataset |
| CvtkPExtractSelectedArraysOverTime | Extracts a selection over time |
| CvtkPExtractVOI | |
| CvtkPHardwareSelector | VtkHardwareSelector useful for parallel rendering |
| CvtkPhyloXMLTreeReader | Read vtkTree from PhyloXML formatted file |
| CvtkPhyloXMLTreeWriter | Write vtkTree data to PhyloXML format |
| CvtkPHyperTreeGridProbeFilter | Probe a vtkHyperTreeGrid in parallel |
| CvtkPicker | Superclass for 3D geometric pickers (uses ray cast) |
| CvtkPickingManager | Class defines API to manage the picking process |
| CvtkPieceRequestFilter | Sets the piece request for upstream filters |
| CvtkPieceScalars | Sets all cell scalars from the update piece |
| CvtkPiecewiseControlPointsItem | Control points for vtkPiecewiseFunction |
| CvtkPiecewiseFunction | Defines a 1D piecewise function |
| CvtkPiecewiseFunctionAlgorithm | Superclass for algorithms that produce only piecewise function as output |
| CvtkPiecewiseFunctionItem | VtkPiecewiseFunctionItem internal uses vtkPlot::Color, white by default |
| CvtkPiecewiseFunctionShiftScale | |
| CvtkPiecewisePointHandleItem | VtkContextItem that draws handles around a point of a piecewise function |
| CvtkPieChartActor | Create a pie chart from an array |
| CvtkPImageWriter | Writes images to files |
| CvtkPIOReader | Class for reading PIO (Parallel Input Output) data files |
| CvtkPipelineGraphSource | Graph constructed from a VTK pipeline |
| CvtkPipelineSize | Compute the memory required by a pipeline |
| CvtkPixel | Cell that represents an orthogonal quadrilateral |
| CvtkPixelBufferObject | Abstracts an OpenGL pixel buffer object |
| 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 |
| CvtkPKdTree | Build a k-d tree decomposition of a list of points |
| CvtkPKMeansStatisitcs | A class for parallel k means clustering |
| CvtkPKMeansStatistics | |
| CvtkPLagrangianParticleTracker | Parallel Lagrangian particle tracker |
| CvtkPlane | Perform various plane computations |
| CvtkPlaneCollection | Maintain a list of planes |
| ►CvtkPlaneCutter | Cut any dataset with a plane and generate a polygonal cut surface |
| CvtkInputInfo | |
| 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 |
| CvtkPlaneSource | Create an array of quadrilaterals located in a plane |
| CvtkPlaneWidget | 3D widget for manipulating a finite plane |
| CvtkPlatonicSolidSource | Produce polygonal Platonic solids |
| CvtkPlaybackRepresentation | Represent the vtkPlaybackWidget |
| CvtkPlaybackWidget | 2D widget for controlling a playback stream |
| CvtkPLinearExtrusionFilter | Subclass that handles piece invariance |
| CvtkPLineIntegralConvolution2D | Parallel part of GPU-based implementation of Line Integral Convolution (LIC) |
| CvtkPlot | Abstract class for 2D plots |
| CvtkPlot3D | Abstract class for 3D plots |
| CvtkPlot3DMetaReader | Reads meta-files points to PLOT3D files |
| CvtkPlotArea | Draws an area plot |
| CvtkPlotBag | Class for drawing an a bagplot |
| CvtkPlotBar | Class for drawing an XY plot given two columns from a vtkTable |
| CvtkPlotBarRangeHandlesItem | Show and control the range of a vtkAxis used with a vtkPlotBar |
| CvtkPlotBox | Class for drawing box plots |
| CvtkPlotFunctionalBag | Class for drawing an XY line plot or bag given two columns from a vtkTable |
| CvtkPlotGrid | Takes care of drawing the plot grid |
| CvtkPlotHistogram2D | |
| CvtkPlotLine | Class for drawing an XY line plot given two columns from a vtkTable |
| CvtkPlotLine3D | Class for drawing an XYZ line plot given three columns from a vtkTable |
| 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 |
| CvtkPlotPoints3D | 3D scatter plot |
| CvtkPlotRangeHandlesItem | Item to show and control a range on vtkAxis |
| CvtkPlotStacked | Class for drawing an stacked polygon plot given an X, Ybase, Yextent in a vtkTable |
| CvtkPlotSurface | 3D surface plot |
| CvtkPLSDynaReader | Read LS-Dyna databases (d3plot) in parallel |
| CvtkPLYReader | Read Stanford University PLY polygonal file format |
| CvtkPLYWriter | Write Stanford PLY file format |
| CvtkPMaskPoints | Parallel Mask Points |
| CvtkPMergeArrays | Multiple inputs with one output, parallel version |
| CvtkPMultiCorrelativeStatistics | A class for parallel bivariate correlative statistics |
| CvtkPNetCDFPOPReader | Read NetCDF files in parallel with MPI .Author Ross Miller 03.14.2011 |
| CvtkPNGReader | Read PNG files |
| CvtkPNGWriter | Writes PNG files |
| CvtkPNMReader | Read pnm (i.e., portable anymap) files |
| CvtkPNMWriter | Writes PNM (portable any map) files |
| CvtkPNrrdReader | Read nrrd files efficiently from parallel file systems (and reasonably well elsewhere) |
| CvtkPointCloudFilter | Abstract class for filtering a point cloud |
| CvtkPointCloudRepresentation | Represent the vtkPointCloudWidget |
| CvtkPointCloudWidget | Select and manipulate a point from a point cloud |
| CvtkPointConnectivityFilter | Output a scalar field indicating point connectivity |
| CvtkPointData | Represent and manipulate point attribute data |
| CvtkPointDataToCellData | Map point data to cell data |
| CvtkPointDensityFilter | Produce density field from input point cloud |
| CvtkPointFillPass | Implement a post-processing fillpass |
| CvtkPointGaussianMapper | Draw PointGaussians using imposters |
| CvtkPointHandleRepresentation2D | Represent the position of a point in display coordinates |
| CvtkPointHandleRepresentation3D | Represent the position of a point in 3D space |
| CvtkPointHandleSource | Handle source used to represent points |
| CvtkPointInterpolator | Interpolate over point cloud using various kernels |
| CvtkPointInterpolator2D | Interpolate point cloud attribute data onto x-y plane using various kernels |
| CvtkPointLoad | Compute stress tensors given point load on semi-infinite domain |
| CvtkPointLocator | Quickly locate points in 3-space |
| CvtkPointOccupancyFilter | Produce occupancy bit mask from input point cloud |
| CvtkPointPicker | Select a point by shooting a ray into a graphics window |
| CvtkPointPlacer | Abstract interface to translate 2D display positions to world coordinates |
| CvtkPoints | Represent and manipulate 3D points |
| CvtkPoints2D | Represent and manipulate 2D points |
| CvtkPointSet | Concrete class for storing a set of points |
| CvtkPointSetAlgorithm | Superclass fo |