| ►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 | |
| 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 | |
| CQQuickVTKItem | QQuickItem that manages a VTK rendering in the QML scenegraph |
| 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 |
| CvtkBoundedWidgetRepresentation | Extends the vtkWidgetRepresentation to help positioning widget in space and how it should be displayed regarding to input bounds |
| 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 |
| 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 | |
| CvtkCompositePolyDataMapper | Class that renders hierarchical polygonal data |
| ►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 |
| 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 |
| CvtkExplodeDataSet | Explode input dataset according to a cell scalar isovalue criteria |
| 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 |
| CvtkNetCDFAccessor | |
| 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 |
| CvtkOpenGLSurfaceProbeVolumeMapper | PolyDataMapper colored with probed volume data |
| 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 |
| ►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 |
| 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 |
| 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 for algorithms that produce output of the same type as input |
| CvtkPointSetCellIterator | Implementation of vtkCellIterator using vtkPointSet API |
| CvtkPointSetStreamer | Stream points as buckets |
| CvtkPointSetToLabelHierarchy | Build a label hierarchy for a graph or point set |
| CvtkPointSetToMoleculeFilter | |
| CvtkPointSetToOctreeImageFilter | Convert a point set to an octree image |
| CvtkPointSmoothingFilter | Adjust point positions to form a pleasing, packed arrangement |
| CvtkPointSource | Create a random cloud of points |
| CvtkPointsProjectedHull | Convex hull of the orthogonal projection of the vtkPoints in the 3 coordinate directions |
| CvtkPointWidget | Position a point in 3D space |
| CvtkPoissonDiskSampler | Generate point normals using local tangent planes |
| CvtkPolarAxesActor | Create an actor of a polar axes - |
| CvtkPolarAxesActor2D | Display polar axes in Viewport 2D space |
| CvtkPolyData | Concrete dataset represents vertices, lines, polygons, and triangle strips |
| CvtkPolyDataAlgorithm | Superclass for algorithms that produce only polydata as output |
| CvtkPolyDataCollection | Maintain a list of polygonal data objects |
| CvtkPolyDataConnectivityFilter | Extract polygonal data based on geometric connectivity |
| CvtkPolyDataContourLineInterpolator | Contour interpolator for polygonal data |
| CvtkPolyDataEdgeConnectivityFilter | Segment polygonal mesh based on shared edge connectivity |
| CvtkPolyDataInternals | Store mapping from vtkPolyData cell ids to internal cell array ids |
| CvtkPolyDataItem | Filter that translate a vtkPolyData 2D mesh into vtkContextItems |
| CvtkPolyDataMapper | Map vtkPolyData to graphics primitives |
| CvtkPolyDataMapper2D | Draw vtkPolyData onto the image plane |
| ►CvtkPolyDataMapperNode | VtkViewNode specialized for vtkPolyDataMappers |
| CvtkPDConnectivity_t | |
| CvtkPolyDataNormals | Compute normals for polygonal mesh |
| CvtkPolyDataPlaneClipper | Clip a vtkPolyData with a plane and optionally cap it |
| CvtkPolyDataPlaneCutter | Threaded (high-performance) cutting of a vtkPolyData with a plane |
| CvtkPolyDataPointPlacer | Base class to place points given constraints on polygonal data |
| CvtkPolyDataPointSampler | Generate points from vtkPolyData |
| CvtkPolyDataReader | Read vtk polygonal data file |
| CvtkPolyDataSilhouette | Sort polydata along camera view direction |
| CvtkPolyDataSourceWidget | Abstract PolyDataSource-based 3D widget |
| CvtkPolyDataStreamer | Streamer appends input pieces to the output |
| CvtkPolyDataTangents | Compute tangents for triangulated polydata |
| CvtkPolyDataToImageStencil | Use polydata to mask an image |
| CvtkPolyDataToReebGraphFilter | Generate a Reeb graph from a scalar field defined on a vtkPolyData |
| CvtkPolyDataToUnstructuredGrid | Filter which converts a polydata to unstructured grid |
| CvtkPolyDataWriter | Write vtk polygonal data |
| CvtkPolygon | Cell that represents an n-sided polygon |
| CvtkPolygonalHandleRepresentation3D | Represent a user defined handle geometry in 3D space |
| CvtkPolygonalSurfaceContourLineInterpolator | Contour interpolator for to place points on polygonal surfaces |
| CvtkPolygonalSurfacePointPlacer | Place points on the surface of polygonal data |
| CvtkPolygonalSurfacePointPlacerNode | |
| CvtkPolygonBuilder | The polygon output is the boundary of the union of the triangles |
| CvtkPolyhedron | A 3D cell defined by a set of polygonal faces |
| CvtkPolyhedronUtilities | VtkPolyhedron utilities |
| CvtkPolyLine | Cell represents a set of 1D lines |
| CvtkPolyLineRepresentation | VtkWidgetRepresentation for a poly line |
| CvtkPolyLineSource | Create a poly line from a list of input points |
| CvtkPolyLineWidget | Widget for vtkPolyLineRepresentation |
| CvtkPolynomialSolversUnivariate | Polynomial solvers |
| CvtkPolyPlane | Implicit function that is generated by extrusion of a polyline along the Z axis |
| CvtkPolyPointSource | Create points from a list of input points |
| CvtkPolyVertex | Cell represents a set of 0D vertices |
| CvtkPOpenFOAMReader | Reads a decomposed dataset in OpenFOAM format |
| CvtkPOrderStatistics | A class for parallel univariate order statistics |
| CvtkPostgreSQLDatabase | Maintain a connection to a PostgreSQL database |
| CvtkPostgreSQLDatabasePrivate | Internal details of a connection to a PostgreSQL database |
| CvtkPostgreSQLQuery | VtkSQLQuery implementation for PostgreSQL databases |
| CvtkPostgreSQLToTableReader | Read a PostgreSQL table as a vtkTable |
| CvtkPostScriptWriter | Writes an image as a PostScript file |
| CvtkPOutlineCornerFilter | Create wireframe outline corners for arbitrary data set |
| CvtkPOutlineFilter | Create wireframe outline for arbitrary data set |
| CvtkPOutlineFilterInternals | Create wireframe outline (or corners) for arbitrary data set |
| CvtkPOVExporter | Export scene into povray format |
| CvtkPPainterCommunicator | |
| CvtkPPairwiseExtractHistogram2D | Compute a 2D histogram between all adjacent columns of an input vtkTable in parallel |
| CvtkPParticlePathFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkPParticleTracer | A Parallel Particle tracer for unsteady vector fields |
| CvtkPParticleTracerBase | |
| CvtkPPCAStatistics | A class for parallel principal component analysis |
| CvtkPPixelTransfer | Class to handle inter-process communication of pixel data from non-contiguous regions of a shared index space |
| CvtkPPolyDataNormals | Compute normals for polygonal mesh |
| CvtkPProbeFilter | Probe dataset in distributed parallel computation |
| CvtkPProjectSphereFilter | A filter to 'unroll' a sphere |
| CvtkPReflectionFilter | Parallel version of vtkReflectionFilter |
| CvtkPResampleFilter | Probe dataset in parallel using a vtkImageData |
| CvtkPResampleToImage | Sample dataset on a uniform grid in parallel |
| CvtkPResampleWithDataSet | Points from another dataset |
| ►CvtkPriorityQueue | List of ids arranged in priority order |
| CItem | |
| CvtkProbabilisticVoronoiKernel | Interpolate from the weighted closest point |
| CvtkProbeFilter | Sample data values at specified point locations |
| CvtkProbeLineFilter | Probe dataset along a line in parallel |
| CvtkProbePolyhedron | Probe/interpolate data values in the interior, exterior or of the surface of a closed, manifold polyhedron |
| CvtkProbeSelectedLocations | Similar to vtkExtractSelection except that it interpolates the point attributes at the probe locations |
| CvtkProcess | Process that can be launched by a vtkMultiProcessController |
| CvtkProcessGroup | A subgroup of processes from a communicator |
| CvtkProcrustesAlignmentFilter | Aligns a set of pointsets together |
| CvtkProgrammableAttributeDataFilter | Manipulate attribute (cell and point) data via a user-specified function |
| CvtkProgrammableDataObjectSource | Generate source data object via a user-specified function |
| CvtkProgrammableElectronicData | Provides access to and storage of user-generated vtkImageData that describes electrons |
| CvtkProgrammableFilter | User-programmable filter |
| CvtkProgrammableGlyphFilter | Control the generation and placement of glyphs at input points |
| CvtkProgrammableSource | Generate source dataset via a user-specified function |
| CvtkProgressBarRepresentation | Represent a vtkProgressBarWidget |
| CvtkProgressBarWidget | 2D widget for placing and manipulating a progress bar |
| CvtkProgressObserver | Basic class to optionally replace vtkAlgorithm progress functionality |
| CvtkProjectedTerrainPath | Project a polyline onto a terrain |
| CvtkProjectedTetrahedraMapper | Unstructured grid volume renderer |
| CvtkProjectedTexture | Assign texture coordinates for a projected texture |
| CvtkProjectPointsToPlane | Project all input points to a plane |
| CvtkProjectSphereFilter | A filter to 'unroll' a sphere |
| CvtkProp | Abstract superclass for all actors, volumes and annotations |
| CvtkProp3D | 3D object for placement in a rendered scene |
| CvtkProp3DAxisFollower | Subclass of vtkProp3DFollower that ensures that data is always parallel to the axis defined by a vtkAxisActor |
| CvtkProp3DButtonRepresentation | Defines a representation for a vtkButtonWidget |
| CvtkProp3DCollection | Ordered list of 3D props |
| CvtkProp3DFollower | VtkProp3D that always faces the camera |
| CvtkPropAssembly | Create hierarchies of props |
| CvtkPropCollection | Ordered list of Props |
| CvtkProperty | Represent surface properties of a geometric object |
| CvtkProperty2D | Represent surface properties of a 2D image |
| CvtkPropItem | Embed a vtkProp in a vtkContextScene |
| CvtkPropPicker | Pick an actor/prop using graphics hardware |
| CvtkProStarReader | Reads geometry in proSTAR (STARCD) file format |
| CvtkProteinRibbonFilter | Generates protein ribbons |
| CvtkPruneTreeFilter | Prune a subtree out of a vtkTree |
| CvtkPSimpleBondPerceiver | Create a simple guess of a molecule's topology |
| CvtkPSLACReader | Extends the vtkSLACReader to read in partitioned pieces |
| CvtkPSphereSource | Sphere source that supports pieces |
| CvtkPStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkPStreamTracer | Parallel streamline generators |
| CvtkPStructuredGridConnectivity | VtkPStructuredGridConnectivity inherits from vtkStructuredGridConnectivity and implements functionality to compute the neighboring topology within a single, partitioned and distributed structured grid dataset |
| CvtkPSurfaceLICComposite | This class decomposes the image space and shuffles image space data onto the new decomposition with the necessary guard cells to prevent artifacts at the decomposition boundaries |
| CvtkPSurfaceLICInterface | Parallel parts of the vtkSurfaceLICInterface |
| CvtkPSystemTools | System tools for file system introspection |
| CvtkPTextureMapToSphere | Generate texture coordinates by mapping points to sphere |
| CvtkPTSReader | Read ASCII PTS Files |
| CvtkPVWebGLExporter | |
| CvtkPWindBladeReader | Class for reading WindBlade data files |
| CvtkPXdmf3Writer | Mpi parallel writer for XDMF/HDF5 files |
| CvtkPYoungsMaterialInterface | Parallel reconstruction of material interfaces |
| CvtkPyramid | 3D cell that represents a linear pyramid |
| CvtkPythonAlgorithm | Algorithm that can be implemented in Python |
| CvtkPythonArchiver | A version of vtkArchiver that can be implemented in Python |
| CvtkPythonItem | A vtkContextItem that can be implemented in Python |
| CvtkQImageToImageSource | Create image data from a QImage |
| CvtkQtAbstractModelAdapter | Superclass for Qt model adapters |
| CvtkQtAnnotationLayersModelAdapter | Adapts annotations to a Qt item model |
| CvtkQtAnnotationView | A VTK view that displays the annotations on its annotation link |
| CvtkQtConnection | |
| CvtkQtDebugLeaksModel | Model class that observes the vtkDebugLeaks singleton |
| CvtkQtDebugLeaksView | View class to display contents of vtkQtDebugLeaksModel |
| CvtkQtInitialization | Initializes a Qt application |
| CvtkQtLabelMapEntry | |
| CvtkQtLabelMapValue | |
| ►CvtkQtLabelRenderStrategy | Renders labels with Qt |
| CInternals | |
| CvtkQtListView | A VTK view based on a Qt List view |
| CvtkQtRecordView | Superclass for QAbstractItemView-based views |
| CvtkQtSQLDatabase | Maintains a connection to an sql database |
| CvtkQtSQLQuery | Query class associated with vtkQtSQLDatabase |
| CvtkQtStringToImage | Uses Qt to render the supplied text to an image |
| CvtkQtTableModelAdapter | Adapts a table to a Qt item model |
| CvtkQtTableRepresentation | Set up a vtkTable in a Qt model |
| CvtkQtTableView | A VTK view based on a Qt Table view |
| CvtkQtTimePointUtility | Performs common time operations |
| CvtkQtTreeModelAdapter | Adapts a tree to a Qt item model |
| CvtkQtTreeRingLabelMapper | Draw text labels on a tree map |
| CvtkQtTreeView | A VTK view based on a Qt tree view |
| CvtkQtView | Superclass for Qt widget-based views |
| CvtkQuad | Cell that represents a 2D quadrilateral |
| CvtkQuadraticEdge | Cell represents a parabolic, isoparametric edge |
| CvtkQuadraticHexahedron | Cell represents a parabolic, 20-node isoparametric hexahedron |
| CvtkQuadraticLinearQuad | Cell represents a quadratic-linear, 6-node isoparametric quad |
| CvtkQuadraticLinearWedge | Cell represents a, 12-node isoparametric wedge |
| CvtkQuadraticPolygon | Cell that represents a parabolic n-sided polygon |
| CvtkQuadraticPyramid | Cell represents a parabolic, 13-node isoparametric pyramid |
| CvtkQuadraticQuad | Cell represents a parabolic, 8-node isoparametric quad |
| CvtkQuadraticTetra | Cell represents a parabolic, 10-node isoparametric tetrahedron |
| CvtkQuadraticTriangle | Cell represents a parabolic, isoparametric triangle |
| CvtkQuadraticWedge | Cell represents a parabolic, 15-node isoparametric wedge |
| CvtkQuadraturePointInterpolator | Interpolates each scalar/vector field in a vtkDataSet on its input to a specific set of quadrature points |
| CvtkQuadraturePointsGenerator | Create a vtkPolyData on its output containing the vertices for the quadrature points for one of the vtkDataArrays present on its input vtkUnstructuredGrid |
| CvtkQuadratureSchemeDefinition | An Elemental data type that holds a definition of a numerical quadrature scheme |
| CvtkQuadratureSchemeDictionaryGenerator | Given an unstructured grid on its input this filter generates for each data array in point data dictionary (ie an instance of vtkInformationQuadratureSchemeDefinitionVectorKey) |
| CvtkQuadric | Evaluate implicit quadric function |
| ►CvtkQuadricClustering | Reduce the number of triangles in a mesh |
| CPointQuadric | |
| ►CvtkQuadricDecimation | Reduce the number of triangles in a mesh |
| CErrorQuadric | |
| CvtkQuadricLODActor | Specific level-of-detail strategy using the quadric clustering decimation algorithm |
| CvtkQuadRotationalExtrusionFilter | Sweep polygonal data creating "skirt" from free edges and lines, and lines from vertices |
| CvtkQuantizePolyDataPoints | Quantizes x,y,z coordinates of points |
| CvtkQuaternion | Templated base type for storage of quaternions |
| CvtkQuaterniond | |
| CvtkQuaternionf | |
| CvtkQuaternionInterpolator | Interpolate a quaternion |
| CvtkQWidgetRepresentation | Class defining the representation for a vtkQWidgetWidget |
| CvtkQWidgetTexture | Allows a QWidget to be used as a texture in VTK with OpenGL |
| CvtkQWidgetWidget | 3D VTK widget for a QWidget |
| CvtkRadialGridActor2D | VtkRadialGridActor2D displays in overlay a list of vtkAxisActor2D sharing a same origin and rotating around it |
| CvtkRadiusOutlierRemoval | Remove isolated points |
| CvtkRandomAttributeGenerator | Generate and create random data attributes |
| CvtkRandomGraphSource | Graph with random edges |
| CvtkRandomHyperTreeGridSource | Builds a randomized but reproducible vtkHyperTreeGrid |
| CvtkRandomLayoutStrategy | Randomly places vertices in 2 or 3 dimensions |
| CvtkRandomPool | Convenience class to quickly generate a pool of random numbers |
| CvtkRandomSequence | Generate a sequence of random numbers |
| CvtkRangeHandlesItem | Item to show and control the range of a vtkColorTransferFunction |
| CvtkRasterReprojectionFilter | Transform a VTK image data to a different projection |
| CvtkRayCastImageDisplayHelper | Helper class that draws the image to the screen |
| CvtkRayCastRayInfo_t | |
| CvtkRayCastStructures | Structure definitions for ray casting |
| CvtkReaderAlgorithm | Superclass for readers that implement a simplified API |
| ►CvtkRearrangeFields | Move/copy fields between field data, point data and cell data |
| COperation | |
| CvtkRecoverGeometryWireframe | Get corrected wireframe from tessellated facets |
| CvtkRect | Templated base type for storage of 2D rectangles |
| CvtkRectangularButtonSource | Create a rectangular button |
| CvtkRectd | |
| CvtkRectf | |
| CvtkRecti | |
| CvtkRectilinearGrid | Dataset that is topologically regular with variable spacing in the three coordinate directions |
| CvtkRectilinearGridAlgorithm | Superclass for algorithms that produce only rectilinear grid as output |
| CvtkRectilinearGridClip | Reduces the image extent of the input |
| CvtkRectilinearGridGeometryFilter | Extract geometry for a rectilinear grid |
| CvtkRectilinearGridOutlineFilter | Create wireframe outline for a rectilinear grid |
| CvtkRectilinearGridPartitioner | A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides functionality for partitioning a VTK rectilinear dataset |
| CvtkRectilinearGridReader | Read vtk rectilinear grid data file |
| CvtkRectilinearGridToPointSet | Converts a vtkRectilinearGrid to a vtkPointSet |
| CvtkRectilinearGridToTetrahedra | Create a Tetrahedral mesh from a RectilinearGrid |
| CvtkRectilinearGridWriter | Write vtk rectilinear grid data file |
| CvtkRectilinearSynchronizedTemplates | Generate isosurface from rectilinear grid |
| CvtkRectilinearWipeRepresentation | Represent a vtkRectilinearWipeWidget |
| CvtkRectilinearWipeWidget | Interactively control an instance of vtkImageRectilinearWipe filter |
| CvtkRecursiveDividingCubes | Create points laying on isosurface (using recursive approach) |
| CvtkRecursiveSphereDirectionEncoder | A direction encoder based on the recursive subdivision of an octahedron |
| CvtkRedistributeDataSetFilter | Redistributes input dataset into requested number of partitions |
| CvtkReduceTable | Combine some of the rows of a table |
| CvtkReebGraph | Reeb graph computation for PL scalar fields |
| CvtkReebGraphSimplificationFilter | Simplify an input Reeb graph |
| CvtkReebGraphSimplificationMetric | Abstract class for custom Reeb graph simplification metric design |
| CvtkReebGraphSurfaceSkeletonFilter | Compute a skeletal embedding of the Reeb graph of a scalar field defined on a triangulated surface (vtkPolyData) |
| CvtkReebGraphToJoinSplitTreeFilter | Converts a given Reeb graph either to a join tree or a split tree (respectively the connectivity of the sub- and sur- level sets) |
| CvtkReebGraphVolumeSkeletonFilter | Compute a skeletal embedding of the Reeb graph of a scalar field defined on a tetrahedral mesh (vtkUnstructuredGrid) |
| CvtkReferenceCount | Obsolete / empty subclass of object |
| CvtkReflectionFilter | Reflects a data set across a plane |
| CvtkRegularPolygonSource | Create a regular, n-sided polygon and/or polyline |
| CvtkRemoteInteractionAdapter | Map vtk-js interaction events to native VTK events |
| CvtkRemoveDuplicatePolys | Remove duplicate/degenerate polygons |
| CvtkRemoveGhosts | Remove ghost points, cells and arrays |
| CvtkRemoveHiddenData | Removes the rows/edges/vertices of input data flagged by ann |
| CvtkRemoveIsolatedVertices | Remove vertices of a vtkGraph with degree zero |
| CvtkRemovePolyData | Removes vtkPolyData cells from an input vtkPolyData |
| CvtkRemoveUnusedPoints | Remove points not used by any cell |
| CvtkRenderbuffer | Storage for FBO's |
| CvtkRenderedAreaPicker | Uses graphics hardware to picks props behind a selection rectangle on a viewport |
| CvtkRenderedGraphRepresentation | |
| CvtkRenderedHierarchyRepresentation | |
| CvtkRenderedRepresentation | |
| CvtkRenderedSurfaceRepresentation | Displays a geometric dataset as a surface |
| CvtkRenderedTreeAreaRepresentation | |
| CvtkRenderer | Abstract specification for renderers |
| CvtkRendererCollection | Ordered list of renderers |
| CvtkRendererDelegate | Render the props of a vtkRenderer |
| CvtkRendererNode | VtkViewNode specialized for vtkRenderers |
| CvtkRendererSource | Take a renderer's image and/or depth map into the pipeline |
| CvtkRenderingCellGrid | A registrar for cell types contained in this module |
| CvtkRenderLargeImage | Use tiling to generate a large rendering |
| CvtkRenderPass | Perform part of the rendering of a vtkRenderer |
| CvtkRenderPassCollection | Ordered list of RenderPasses |
| CvtkRenderState | Context in which a vtkRenderPass will render |
| CvtkRenderStepsPass | Execute render passes sequentially |
| ►CvtkRenderTimerLog | Asynchronously measures GPU execution times for a series of events |
| CEvent | Container for a single timed event |
| CFrame | Container for a frame's events |
| CScopedEventLogger | RAII struct for logging events |
| CvtkRenderView | A view containing a renderer |
| CvtkRenderViewBase | A base view containing a renderer |
| CvtkRenderWidget | |
| CvtkRenderWindow | Create a window for renderers to draw into |
| CvtkRenderWindowCollection | Ordered list of RenderWindows |
| CvtkRenderWindowInteractor | Platform-independent render window interaction including picking and frame rate control |
| CvtkRenderWindowInteractor3D | Adds support for 3D events to vtkRenderWindowInteractor |
| CvtkResampleToImage | Sample dataset on a uniform grid |
| CvtkResampleWithDataSet | Sample point and cell data of a dataset on points from another dataset |
| CvtkReservoirSampler | |
| CvtkReservoirSampler< IntegerType > | Generate a monotonic sequence of integers that randomly kk-sample a range without substitution |
| CvtkReservoirSamplerBase | |
| CvtkResizingWindowToImageFilter | Use a vtkWindow as input to image pipeline |
| CvtkResliceCursor | Geometry for a reslice cursor |
| CvtkResliceCursorActor | Represent a reslice cursor |
| CvtkResliceCursorLineRepresentation | Represent the vtkResliceCursorWidget |
| CvtkResliceCursorPicker | Ray-cast cell picker for the reslice cursor |
| CvtkResliceCursorPolyDataAlgorithm | Generates a 2D reslice cursor polydata |
| CvtkResliceCursorRepresentation | Represent the vtkResliceCursorWidget |
| CvtkResliceCursorThickLineRepresentation | Thick slab of the reslice cursor widget |
| CvtkResliceCursorWidget | Represent a reslice cursor |
| CvtkResliceImageViewer | Display an image along with a reslice cursor |
| CvtkResliceImageViewerMeasurements | Manage measurements on a resliced image |
| CvtkResourceFileLocator | Utility to locate resource files |
| ►CvtkResourceParser | Helper class to perform formatted input from vtkResourceStream |
| CReadToResult | Structure returned by Read*To functions |
| CvtkResourceStream | Abstract class used for custom streams |
| CvtkReverseSense | Reverse the ordering of polygonal cells and/or vertex normals |
| CvtkRibbonFilter | Create oriented ribbons from lines defined in polygonal dataset |
| CvtkRIBExporter | Export a scene into RenderMan RIB format |
| CvtkRIBLight | RIP Light |
| CvtkRIBProperty | RIP Property |
| CvtkRISReader | Reader for RIS files |
| CvtkROIStencilSource | Create simple mask shapes |
| CvtkRotationalExtrusionFilter | Sweep polygonal data creating "skirt" from free edges and lines, and lines from vertices |
| CvtkRotationFilter | Duplicates a data set by rotation about an axis |
| CvtkRowQuery | Abstract interface for queries that return row-oriented results |
| CvtkRowQueryToTable | Executes an sql query and retrieves results into a table |
| CvtkRTAnalyticSource | Create an image for regression testing |
| CvtkRTXMLPolyDataReader | Read RealTime VTK XML PolyData files |
| CvtkRuledSurfaceFilter | Generates a surface from a set of lines |
| CvtkRungeKutta2 | Integrate an initial value problem using 2nd order Runge-Kutta method |
| CvtkRungeKutta4 | Integrate an initial value problem using 4th order Runge-Kutta method |
| CvtkRungeKutta45 | Integrate an initial value problem using 5th order Runge-Kutta method with adaptive stepsize control |
| CvtkSampleFunction | Sample an implicit function over a structured point set |
| CvtkSampleImplicitFunctionFilter | Sample an implicit function over a dataset, generating scalar values and optional gradient vectors |
| CvtkScalarBarActor | Create a scalar bar with labels |
| CvtkScalarBarActorInternal | Internal state for the scalar bar actor shared with subclasses |
| CvtkScalarBarBox | A structure to represent pixel coordinates for text or swatch bounds |
| CvtkScalarBarRepresentation | Represent scalar bar for vtkScalarBarWidget |
| CvtkScalarBarWidget | 2D widget for manipulating a scalar bar |
| CvtkScalarsToColors | Superclass for mapping scalar values to colors |
| CvtkScalarsToColorsItem | Abstract class for ScalarsToColors items |
| CvtkScalarsToTextureFilter | Generate texture coordinates and a texture image based on a scalar field |
| CvtkScalarTree | Organize data according to scalar values (used to accelerate contouring operations) |
| CvtkScaledSOADataArrayTemplate | Struct-Of-Arrays implementation of vtkGenericDataArray with a scaling factor |
| CvtkScaledTextActor | Create text that will scale as needed |
| CvtkScatterPlotMatrix | Container for a matrix of charts |
| CvtkScenePicker | Picks an entire viewport at one shot |
| CvtkSCurveSpline | Computes an interpolating spline using a a SCurve basis |
| CvtkSDL2OpenGL2RenderWindow | OpenGL rendering window |
| CvtkSDL2OpenGLRenderWindow | |
| CvtkSDL2WebGPURenderWindow | OpenGL rendering window |
| CvtkSectorSource | Create a sector of a disk |
| CvtkSeedRepresentation | Represent the vtkSeedWidget |
| CvtkSeedWidget | Place multiple seed points |
| CvtkSegYBinaryHeaderBytesPositions | |
| CvtkSegYIOUtils | |
| CvtkSegYReader | Reads SegY data files |
| CvtkSegYReaderInternal | |
| CvtkSegYTrace | |
| CvtkSegYTraceHeaderBytesPositions | |
| CvtkSegYTraceReader | |
| CvtkSelectEnclosedPoints | Mark points as to whether they are inside a closed surface |
| CvtkSelection | Data object that represents a "selection" in VTK |
| CvtkSelectionAlgorithm | Superclass for algorithms that produce only Selection as output |
| CvtkSelectionNode | Node in a vtkSelection the defines the selection criteria |
| CvtkSelectionSource | Generate selection from given set of ids |
| CvtkSelector | |
| CvtkSelectPolyData | Select portion of polygonal mesh; generate selection scalars |
| CvtkSelectVisiblePoints | Extract points that are visible (based on z-buffer calculation) |
| CvtkSEPReader | Stanford Exploration Project files reader |
| CvtkSequencePass | Execute render passes sequentially |
| CvtkSerializer | Serialize VTK objects to JSON |
| CvtkServerSocket | Encapsulate a socket that accepts connections |
| ►CvtkShader | Vertex or Fragment shader, combined into a ShaderProgram |
| CReplacementSpec | |
| CReplacementValue | |
| ►CvtkShaderProgram | The ShaderProgram uses one or more Shader objects |
| Ccmp_str | |
| CvtkShaderProperty | Represent GPU shader properties |
| CvtkShadowMapBakerPass | Implement a builder of shadow map pass |
| CvtkShadowMapPass | Implement a shadow mapping render pass |
| CvtkShepardKernel | Shepard method interpolation kernel |
| CvtkShepardMethod | Interpolate points and associated scalars onto volume using the method of Shepard |
| CvtkShortArray | Dynamic, self-adjusting array of short |
| CvtkShrinkFilter | Shrink cells composing an arbitrary data set |
| CvtkShrinkPolyData | Shrink cells composing PolyData |
| CvtkSignedCharArray | Dynamic, self-adjusting array of signed char |
| CvtkSignedDistance | Compute signed distances from an input point cloud |
| CvtkSILBuilder | Helper class to build a SIL i.e |
| CvtkSimple2DLayoutStrategy | Simple 2D graph layout |
| CvtkSimple3DCirclesStrategy | Places vertices on circles in 3D |
| CvtkSimpleBondPerceiver | Create a simple guess of a molecule's topology |
| CvtkSimpleCellTessellator | Helper class to perform cell tessellation |
| CvtkSimpleElevationFilter | Generate scalars along a specified direction |
| CvtkSimpleImageToImageFilter | Generic image filter with one input |
| CvtkSimpleMotionBlurPass | Avergae frames to simulate motion blur |
| CvtkSimplePointsReader | Read a list of points from a file |
| CvtkSimplePointsWriter | Write a file of xyz coordinates |
| CvtkSimpleReader | Superclass for algorithms that are not time or parallel aware |
| CvtkSimpleScalarTree | Organize data according to scalar values (used to accelerate contouring operations) |
| ►CvtkSingleVTPExporter | Export a scene into a single vtp file and png texture |
| CactorData | |
| CvtkSkybox | Renders a skybox environment |
| CvtkSLACParticleReader | A reader for a data format used by Omega3p, Tau3p, and several other tools used at the Standford Linear Accelerator Center (SLAC) |
| ►CvtkSLACReader | A reader for a data format used by Omega3p, Tau3p, and several other tools used at the Standford Linear Accelerator Center (SLAC) |
| CEdgeEndpoints | Simple class used internally to define an edge based on the endpoints |
| CMidpointCoordinateMap | Manages a map from edges to midpoint coordinates |
| CMidpointCoordinates | Simple class used internally for holding midpoint information |
| CMidpointIdMap | Manages a map from edges to the point id of the midpoint |
| CvtkSLCReader | Read an SLC volume file |
| CvtkSliceAndDiceLayoutStrategy | Horizontal and vertical slicing tree map layout |
| CvtkSliceCubes | Generate isosurface(s) from volume four slices at a time |
| CvtkSliderRepresentation | Abstract class defines the representation for a vtkSliderWidget |
| CvtkSliderRepresentation2D | Provide the representation for a vtkSliderWidget with a 3D skin |
| CvtkSliderRepresentation3D | Provide the representation for a vtkSliderWidget with a 3D skin |
| CvtkSliderWidget | Set a value by manipulating a slider |
| CvtkSmartPointer | Hold a reference to a vtkObjectBase instance |
| ►CvtkSmartPointerBase | Non-templated superclass for vtkSmartPointer |
| CNoReference | |
| CvtkSmartVector | A vector of smart pointers |
| CvtkSmartVolumeMapper | Adaptive volume mapper |
| CvtkSmoothErrorMetric | Objects that compute geometry-based error during cell tessellation according to some max angle |
| CvtkSmoothPolyDataFilter | Adjust point positions using Laplacian smoothing |
| CvtkSMPContourGrid | Subclass of vtkContourGrid that works in parallel vtkSMPContourGrid performs the same functionality as vtkContourGrid but does it using multiple threads |
| CvtkSMPMergePoints | Class designed to help with merging of points in parallel |
| ►CvtkSMPMergePolyDataHelper | Utility class for merging poly data in parallel This class is designed as a utility class to help merging of poly data generated by filters that generate multiple polydata outputs and the associated locators |
| CInputData | This is the data structure needed by the MergePolyData function |
| CvtkSMPProgressObserver | Progress observer that is thread safe |
| CvtkSMPThreadLocal | Thread local storage for VTK objects |
| ►CvtkSMPThreadLocalObject | Thread local storage for VTK objects |
| Citerator | Subset of the standard iterator API |
| ►CvtkSMPTools | A set of parallel (multi-threaded) utility functions |
| CConfig | Structure used to specify configuration for LocalScope() method |
| CvtkSOADataArrayTemplate | Struct-Of-Arrays implementation of vtkGenericDataArray |
| CvtkSobelGradientMagnitudePass | Implement a post-processing edge detection with a Sobel gradient magnitude render pass |
| CvtkSocket | BSD socket encapsulation |
| CvtkSocketCollection | Collection for sockets |
| CvtkSocketCommunicator | Process communication using Sockets |
| CvtkSocketController | Process communication using Sockets |
| CvtkSortDataArray | Several methods for sorting VTK arrays |
| CvtkSortFieldData | Method for sorting field data |
| CvtkSortFileNames | Group and sort a set of filenames |
| CvtkSpanSpace | Organize data according to scalar span space |
| CvtkSpanTreeLayoutStrategy | VtkSpanTreeLayout is a strategy for drawing directed graphs that works by first extracting a spanning tree (more accurately, a spanning forest), and using this both to position graph vertices and to plan the placement of non-tree edges |
| CvtkSparseArray | Sparse, independent coordinate storage for N-way arrays |
| CvtkSparseArrayToTable | Converts a sparse array to a vtkTable |
| CvtkSpatialRepresentationFilter | Generate polygonal model of spatial search object (i.e., a vtkLocator) |
| CvtkSpatioTemporalHarmonicsAttribute | Computes spatio-temporal harmonics on each point |
| CvtkSpatioTemporalHarmonicsSource | Creates a vtkImageData with harmonics data |
| CvtkSPHCubicKernel | Cubic SPH interpolation kernel |
| CvtkSphere | Implicit function for a sphere |
| CvtkSphereHandleRepresentation | A spherical rendition of point in 3D space |
| CvtkSpherePuzzle | Create a polygonal sphere centered at the origin |
| CvtkSpherePuzzleArrows | Visualize permutation of the sphere puzzle |
| CvtkSphereRepresentation | Class defining the representation for the vtkSphereWidget2 |
| CvtkSpheres | Implicit function for a set of spheres |
| CvtkSphereSource | Create a polygonal sphere centered at the origin |
| CvtkSphereTree | Class to build and traverse sphere trees |
| CvtkSphereTreeFilter | Represent a sphere tree as vtkPolyData |
| CvtkSphereWidget | 3D widget for manipulating a sphere |
| CvtkSphereWidget2 | 3D widget for manipulating a point on a sphere |
| CvtkSphericalDirectionEncoder | A direction encoder based on spherical coordinates |
| CvtkSphericalHarmonics | Compute spherical harmonics of an equirectangular projection image |
| CvtkSphericalPointIterator | Traverse a collection of points in spherical ordering |
| CvtkSphericalTransform | Spherical to rectangular coords and back |
| CvtkSPHInterpolator | Interpolate over point cloud using SPH kernels |
| CvtkSPHKernel | Family of SPH interpolation kernels |
| CvtkSPHQuarticKernel | Quartic SPH interpolation kernel |
| CvtkSPHQuinticKernel | Quintic SPH interpolation kernel |
| CvtkSpiderPlotActor | Create a spider plot from input field |
| CvtkSpline | Spline abstract class for interpolating splines |
| CvtkSplineFilter | Generate uniformly subdivided polylines from a set of input polyline using a vtkSpline |
| CvtkSplineGraphEdges | Subsample graph edges to make smooth curves |
| CvtkSplineRepresentation | Representation for a spline |
| CvtkSplineWidget | 3D widget for manipulating a spline |
| CvtkSplineWidget2 | Widget for vtkSplineRepresentation |
| CvtkSplitByCellScalarFilter | Splits input dataset according an integer cell scalar array |
| CvtkSplitColumnComponents | Split multicomponent table columns |
| ►CvtkSplitField | Split a field into single component fields |
| CComponent | |
| CvtkSplitSharpEdgesPolyData | Split sharp edges in a polygonal mesh |
| CvtkSQLDatabase | Maintain a connection to an sql database |
| CvtkSQLDatabaseGraphSource | Generates a vtkGraph based on an SQL query |
| CvtkSQLDatabaseSchema | Represent an SQL database schema |
| CvtkSQLDatabaseTableSource | Generates a vtkTable based on an SQL query |
| CvtkSQLGraphReader | Read a vtkGraph from a database |
| CvtkSQLiteDatabase | Maintain a connection to an SQLite database |
| CvtkSQLiteDatabaseInternals | |
| CvtkSQLiteQuery | VtkSQLQuery implementation for SQLite databases |
| CvtkSQLiteToTableReader | Read an SQLite table as a vtkTable |
| CvtkSQLQuery | Executes an sql query and retrieves results |
| CvtkSquarifyLayoutStrategy | Uses the squarify tree map layout algorithm |
| CvtkSSAAPass | Implement Screen Space Anti Aliasing pass |
| CvtkSSAOPass | Implement a screen-space ambient occlusion pass |
| CvtkStackedTreeLayoutStrategy | Lays out tree in stacked boxes or rings |
| CvtkStateStorage | Class to make storing and comparing state quick and easy |
| CvtkStaticCellLinks | Object represents upward pointers from points to list of cells using each point |
| CvtkStaticCellLinksTemplate | Object represents upward pointers from points to list of cells using each point (template implementation) |
| CvtkStaticCellLocator | Perform fast cell location operations |
| CvtkStaticCleanPolyData | Merge duplicate points, and/or remove unused points and/or remove degenerate cells |
| CvtkStaticCleanUnstructuredGrid | Merge duplicate points, removed unused points, in an vtkUnstructuredGrid |
| CvtkStaticCompositeSource | Simple source that create a composite (PartitionedDataSetCollection) of 2 polydata |
| CvtkStaticDataSource | Simple source that create a polydata (triangle) with point data arrays: |
| CvtkStaticEdgeLocatorTemplate | Templated on types of ids defining an edge, and any data associated with the edge |
| CvtkStaticFaceHashLinksTemplate | Templated on types of ids defining an edge |
| CvtkStaticPointLocator | Quickly locate points in 3-space |
| CvtkStaticPointLocator2D | Quickly locate points in 2-space |
| CvtkStatisticalOutlierRemoval | Remove sparse outlier points |
| ►CvtkStatisticsAlgorithm | Base class for statistics algorithms |
| CAssessFunctor | A base class for a functor that assesses data |
| CvtkStatisticsAlgorithmPrivate | |
| CvtkStdString | Wrapper around std::string to keep symbols short |
| CvtkStereoCompositor | Helper class to generate composited stereo images |
| CvtkStitchImageDataWithGhosts | Stitches vtkImageData that are one voxel away |
| CvtkSTLReader | Read ASCII or binary stereo lithography files |
| CvtkSTLWriter | Write stereo lithography files |
| CvtkStrahlerMetric | Compute Strahler metric for a tree |
| CvtkStreaklineFilter | A Parallel Particle tracer for unsteady vector fields |
| CvtkStreamerBase | Superclass for filters that stream input pipeline |
| CvtkStreamGraph | Combines two graphs |
| CvtkStreamingDemandDrivenPipeline | Executive supporting partial updates |
| CvtkStreamingStatistics | A class for using the statistics filters in a streaming mode |
| CvtkStreamingTessellator | An algorithm that refines an initial simplicial tessellation using edge subdivision |
| CvtkStreamSurface | Advect a stream surface in a vector field |
| CvtkStreamTracer | Streamline generator |
| CvtkStringArray | VtkAbstractArray subclass for strings |
| CvtkStringOutputWindow | File Specific output window class |
| CvtkStringToCategory | Creates a category array from a string array |
| CvtkStringToImage | Base class for classes that render supplied text to an image |
| CvtkStringToken | Represent a string by its integer hash |
| CvtkStringToNumeric | Converts string arrays to numeric arrays |
| CvtkStripper | Create triangle strips and/or poly-lines |
| CvtkStructuredAMRGridConnectivity | Grid connectivity |
| CvtkStructuredAMRNeighbor | An internal, light-weight object used to store neighbor information for AMR grids |
| ►CvtkStructuredCellArray | Implicit object to represent cell connectivity |
| CvtkStructuredTCellBackend | |
| CvtkStructuredData | Singleton class for topologically regular data |
| ►CvtkStructuredDataPlaneCutter | Fast plane cutting of vtkImageData/vtkRectilinearGrid/vtkStructuredGrid |
| CvtkInputInfo | |
| CvtkStructuredExtent | Helper class to aid working with structured extents |
| CvtkStructuredGrid | Topologically regular array of data |
| CvtkStructuredGridAlgorithm | Superclass for algorithms that produce only structured grid as output |
| CvtkStructuredGridAppend | Collects data from multiple inputs into one structured grid |
| CvtkStructuredGridClip | Reduces the image extent of the input |
| CvtkStructuredGridConnectivity | VtkStructuredGridConnectivity is a concrete instance of vtkObject that implements functionality for computing the neighboring topology within a single partitioned structured grid dataset |
| CvtkStructuredGridGeometryFilter | Extract geometry for structured grid |
| CvtkStructuredGridLIC2D | GPU implementation of a Line Integral Convolution, a technique for imaging vector fields |
| CvtkStructuredGridOutlineFilter | Create wireframe outline for structured grid |
| CvtkStructuredGridPartitioner | A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides functionality for partitioning a VTK structured grid dataset |
| CvtkStructuredGridReader | Read vtk structured grid data file |
| CvtkStructuredGridWriter | Write vtk structured grid data file |
| CvtkStructuredImplicitConnectivity | Distributed structured dataset that is implicitly connected among partitions without abutting |
| CvtkStructuredNeighbor | An internal, light-weight class used to store neighbor information |
| CvtkStructuredPointArray | An structured point array used by structured datasets subclasses |
| CvtkStructuredPointBackend | A backend for the vtkImplicitArray to query structured points efficiently |
| CvtkStructuredPoints | A subclass of ImageData |
| CvtkStructuredPointsCollection | Maintain a list of structured points data objects |
| CvtkStructuredPointsGeometryFilter | Obsolete class |
| CvtkStructuredPointsReader | Read vtk structured points data file |
| CvtkStructuredPointsWriter | Write vtk structured points data file |
| CvtkStructuredTPointBackend | |
| CvtkSubCommunicator | Provides communication on a process group |
| CvtkSubdivideTetra | Subdivide one tetrahedron into twelve for every tetra |
| CvtkSubdivisionFilter | Base class for subvision filters |
| CvtkSubGroup | Scalable collective communication for a subset of members of a parallel VTK application |
| CvtkSubPixelPositionEdgels | Adjust edgel locations based on gradients |
| CvtkSuperquadric | Implicit function for a Superquadric |
| CvtkSuperquadricSource | Create a polygonal superquadric centered at the origin |
| CvtkSurfaceLICComposite | This class decomposes the image space and shuffles image space data onto the new decomposition with the necessary guard cells to prevent artifacts at the decomposition boundaries |
| CvtkSurfaceLICHelper | A small collection of noise routines for LIC |
| CvtkSurfaceLICInterface | Public API for surface lic parameters arbitrary geometry |
| CvtkSurfaceLICMapper | Mapper that performs LIC on the surface of arbitrary geometry |
| CvtkSurfaceNets2D | Generate smoothed constours from segmented 2D image data (i.e., "label maps") |
| CvtkSurfaceNets3D | Generate smoothed isocontours from segmented 3D image data (i.e., "label maps") |
| CvtkSurfaceReconstructionFilter | Reconstructs a surface from unorganized points |
| CvtkSVGContextDevice2D | VtkContextDevice2D implementation for use with vtkSVGExporter |
| CvtkSVGExporter | Exports vtkContext2D scenes to SVG |
| CvtkSynchronizableActors | Abstract base class for synchronizing a collection of actors |
| CvtkSynchronizableAvatars | Serialize/deserialize collection of vtkOpenGLAvatars among renderers |
| ►CvtkSynchronizedRenderers | Synchronizes renderers across processes |
| CRendererInfo | |
| CvtkRawImage | VtkRawImage can be used to make it easier to deal with images for compositing/communicating over client-server etc |
| ►CvtkSynchronizedRenderWindows | Synchronizes render windows across processes |
| CRenderWindowInfo | |
| CvtkSynchronizedTemplates2D | Generate isoline(s) from a structured points set |
| CvtkSynchronizedTemplates3D | Generate isosurface from structured points |
| CvtkSynchronizedTemplatesCutter3D | Generate cut surface from structured points |
| CvtkSynchronizeTimeFilter | Set "close" time step values from the second input to the first |
| CvtkSystemIncludes | Transition VTK to ANSI C++, centralize inclusion of system files |
| CvtkTable | A table, which contains similar-typed columns of data |
| CvtkTableAlgorithm | Superclass for algorithms that produce only vtkTables as output |
| CvtkTableBasedClipCases< false > | |
| CvtkTableBasedClipCases< true > | |
| CvtkTableBasedClipCasesBase | |
| CvtkTableBasedClipDataSet | Clip any dataset with a user-specified implicit function or an input scalar point data array |
| CvtkTableFFT | FFT for table columns |
| CvtkTableReader | Read vtkTable data file |
| CvtkTableToArray | Converts a vtkTable to a matrix |
| CvtkTableToDatabaseWriter | In a SQL database |
| CvtkTableToGraph | Convert a vtkTable into a vtkGraph |
| CvtkTableToMySQLWriter | Store a vtkTable in a MySQL database |
| CvtkTableToPolyData | Filter used to convert a vtkTable to a vtkPolyData consisting of vertices |
| CvtkTableToPostgreSQLWriter | Store a vtkTable in a PostgreSQL database |
| CvtkTableToSparseArray | Converts a vtkTable into a sparse array |
| CvtkTableToSQLiteWriter | Store a vtkTable in an SQLite database |
| CvtkTableToStructuredGrid | Converts vtkTable to a vtkStructuredGrid |
| CvtkTableToTreeFilter | Filter that converts a vtkTable to a vtkTree |
| CvtkTableWriter | Write vtkTable to a file |
| CvtkTanglegramItem | Display two related trees |
| CvtkTclCommand | |
| CvtkTclCommandArgStruct | |
| CvtkTclCommandStruct | |
| CvtkTclInterpStruct | |
| CvtkTDxInteractorStyle | Provide 3DConnexion device event-driven interface to the rendering window |
| CvtkTDxInteractorStyleCamera | Interactive manipulation of the camera with a 3DConnexion device |
| CvtkTDxInteractorStyleSettings | 3DConnexion device settings |
| CvtkTDxMotionEventInfo | Store motion information from a 3DConnexion input device |
| CvtkTDxQtUnixDevices | Manage a list vtkTDXUnixDevice(s) |
| CvtkTecplotReader | A concrete class to read an ASCII Tecplot file |
| CvtkTecplotTableReader | Reads in Tecplot tabular data and outputs a vtkTable data structure |
| CvtkTemplateAliasMacro | Dispatch a scalar processing template |
| CvtkTemporalAlgorithm | Base class for temporal algorithms |
| CvtkTemporalArrayOperatorFilter | Perform simple mathematical operation on a data array at different time |
| CvtkTemporalDataSetCache | Cache time steps |
| CvtkTemporalDelimitedTextReader | Reads a delimited ascii or unicode text files and and output a temporal vtkTable |
| CvtkTemporalFractal | A source to test AMR data object |
| CvtkTemporalInterpolatedVelocityField | A helper class for interpolating between times during particle tracing |
| CvtkTemporalInterpolator | Interpolate datasets between time steps to produce a new dataset |
| CvtkTemporalPathLineFilter | Generate a Polydata Pointset from any Dataset |
| CvtkTemporalShiftScale | Modify the time range/steps of temporal data |
| CvtkTemporalSmoothing | Smooth point or cell data over a sliding time window |
| CvtkTemporalSnapToTimeStep | Modify the time range/steps of temporal data |
| CvtkTemporalStatistics | Compute statistics of point or cell data as it changes over time |
| CvtkTensorGlyph | Scale and orient glyph(s) according to eigenvalues and eigenvectors of symmetrical part of tensor |
| CvtkTensorPrincipalInvariants | Compute principal values and directions from symmetric tensor |
| CvtkTensorProbeRepresentation | Abstract class that serves as a representation for vtkTensorProbeWidget |
| CvtkTensorProbeWidget | Widget to probe tensors on a polyline |
| CvtkTensorRepresentation | Class defining a representation for the vtkTensorWidget |
| CvtkTensorWidget | 3D widget for manipulating a tensor glyph |
| CvtkTerrainContourLineInterpolator | Contour interpolator for DEM data |
| CvtkTerrainDataPointPlacer | Place points on terrain data |
| CvtkTessellatedBoxSource | Create a polygonal representation of a box with a given level of subdivision |
| CvtkTessellatorFilter | Approximate nonlinear FEM elements with simplices |
| CvtkTestDataArray | An implementation of vtkGenericDataArray for testing fallback algorithms |
| CvtkTestNewVar | Tests instantiations of the vtkNew class template |
| CvtkTetra | 3D cell that represents a tetrahedron |
| CvtkTextActor | An actor that displays text |
| CvtkTextActor3D | An actor that displays text |
| ►CvtkTextCodec | Virtual class to act as an interface for all text codecs |
| COutputIterator | Base class that any output iterators need to derive from to use the first signature of to_unicode |
| CvtkTextCodecFactory | Maintain a list of text codecs and return instances |
| CvtkTextMapper | 2D text annotation |
| CvtkTextProperty | Represent text properties |
| CvtkTextPropertyCollection | Ordered list of vtkTextProperty objects |
| ►CvtkTextRenderer | Interface for generating images and path data from string data, using multiple backends |
| CMetrics | |
| CvtkTextRendererCleanup | |
| CvtkTextRendererStringToImage | Uses vtkTextRenderer to render the supplied text to an image |
| CvtkTextRepresentation | Represent text for vtkTextWidget |
| CvtkTextSource | Create polygonal text |
| CvtkTexture | Handles properties associated with a texture map |
| CvtkTexturedActor2D | Actor that draws 2D data with texture support |
| CvtkTexturedButtonRepresentation | Defines a representation for a vtkButtonWidget |
| CvtkTexturedButtonRepresentation2D | Defines a representation for a vtkButtonWidget |
| CvtkTexturedSphereSource | Create a sphere centered at the origin |
| ►CvtkTextureImageCache | |
| CCacheData | |
| CCacheElement | CacheElement associates a unique key to some cache |
| CvtkTextureIO | A small collection of I/O routines that write vtkTextureObject to disk for debugging |
| CvtkTextureMapToCylinder | Generate texture coordinates by mapping points to cylinder |
| CvtkTextureMapToPlane | Generate texture coordinates by mapping points to plane |
| CvtkTextureMapToSphere | Generate texture coordinates by mapping points to sphere |
| CvtkTextureObject | Abstracts an OpenGL texture object |
| CvtkTextureUnitManager | Allocate/free texture units |
| CvtkTextWidget | Widget for placing text on overlay plane |
| CvtkTGAReader | Read PNG files |
| CvtkThinPlateSplineTransform | Nonlinear warp transformation |
| ►CvtkThreadedCallbackQueue | Simple threaded callback queue |
| CvtkSharedFuture | A vtkSharedFuture is an object returned by the methods Push and PushDependent |
| CvtkSharedFutureBase | vtkSharedFutureBase is the base block to store, run, get the returned value of the tasks that are pushed in the queue |
| CvtkThreadedCompositeDataPipeline | Executive that works in parallel |
| CvtkThreadedImageAlgorithm | Generic filter that has one input |
| CvtkThreadedImageWriter | Class used to compress/write images using threads to prevent locking while encoding data |
| CvtkThreadedTaskQueue | Simple threaded task queue |
| CvtkThreadedTaskQueue< void, Args... > | |
| ►CvtkThreshold | Extracts cells where scalar value in cell satisfies threshold criterion |
| CEvaluateCellsFunctor | |
| CvtkThresholdGraph | Returns a subgraph of a vtkGraph |
| CvtkThresholdPoints | Extracts points whose scalar value satisfies threshold criterion |
| CvtkThresholdTable | Thresholds table rows |
| CvtkThresholdTextureCoords | Compute 1D, 2D, or 3D texture coordinates based on scalar threshold |
| ►CvtkTIFFReader | Read TIFF files |
| CvtkTIFFReaderInternal | |
| CvtkTIFFReaderInternal | |
| CvtkTIFFWriter | Write out image data as a TIFF file |
| CvtkTimePointUtility | Performs common time operations |
| CvtkTimeRange | VtkExecutionRange using time to dispatch in a vtkForEach sub-pipeline |
| CvtkTimerLog | Timer support and logging |
| CvtkTimerLogCleanup | |
| CvtkTimerLogEntry | |
| CvtkTimerLogScope | Helper class to log time within scope |
| CvtkTimeSource | Creates a simple time varying data set |
| CvtkTimeSourceExample | |
| CvtkTimeStamp | Record modification and/or execution time |
| CvtkTkImageViewerWidget | Tk Widget for viewing vtk images |
| CvtkTkRenderWidget | Tk Widget for vtk rendering |
| CvtkToAffineArrayStrategy | Strategy to transform an explicit array into a vtkAffineArray |
| CvtkToConstantArrayStrategy | Strategy to be used in conjunction with vtkToImplicitArrayFilter to identify and compress constant arrays |
| CvtkToImplicitArrayFilter | A VTK filter for compressing explicit memory arrays into implicit arrays |
| CvtkToImplicitRamerDouglasPeuckerStrategy | A strategy for creating constant or affine by parts implicit arrays from explicit memory arrays based on the Ramer-Douglas-Peucker algorithm(*) |
| ►CvtkToImplicitStrategy | Pure interface for strategies to transform explicit arrays into implicit arrays |
| COptional | A helper structure for communicating a result with an optional double value |
| CvtkToImplicitTypeErasureStrategy | A strategy for compressing arrays by type when applicable (int -> unsigned char for example) and wrapping them behind a vtkImplicitArray to furnish the same interface |
| CvtkToneMappingPass | Implement a post-processing Tone Mapping |
| CvtkTooltipItem | Takes care of drawing 2D axes |
| CvtkTransferAttributes | Transfer data from a graph representation to a tree representation using direct mapping or pedigree ids |
| CvtkTransform | Describes linear transformations via a 4x4 matrix |
| CvtkTransform2D | Describes linear transformations via a 3x3 matrix |
| CvtkTransformCollection | Maintain a list of transforms |
| CvtkTransformConcatenation | |
| CvtkTransformConcatenationStack | |
| CvtkTransformCoordinateSystems | Transform points into different coordinate systems |
| ►CvtkTransformFeedback | Manages a TransformFeedback buffer |
| CVaryingMetaData | |
| CvtkTransformFilter | Transform points and associated normals and vectors |
| CvtkTransformInterpolator | Interpolate a series of transformation matrices |
| CvtkTransformPair | |
| CvtkTransformPolyDataFilter | Transform points and associated normals and vectors for polygonal dataset |
| CvtkTransformTextureCoords | Transform (scale, rotate, translate) texture coordinates |
| CvtkTransformToGrid | Create a grid for a vtkGridTransform |
| CvtkTranslucentPass | Render the translucent polygonal geometry with property key filtering |
| CvtkTransmitImageDataPiece | |
| CvtkTransmitPolyDataPiece | |
| CvtkTransmitRectilinearGridPiece | Redistributes data produced by serial readers |
| CvtkTransmitStructuredDataPiece | |
| CvtkTransmitStructuredGridPiece | |
| CvtkTransmitUnstructuredGridPiece | |
| CvtkTransposeMatrix | Computes the transpose of an input matrix |
| CvtkTransposeTable | Transpose an input table |
| CvtkTree | A rooted tree data structure |
| CvtkTreeAlgorithm | Superclass for algorithms that produce only Tree as output |
| CvtkTreeAreaView | Accepts a graph and a hierarchy - currently a tree - and provides a hierarchy-aware display |
| CvtkTreeBFSIterator | Breadth first search iterator through a vtkTree |
| CvtkTreeCompositer | Implements tree based compositing |
| CvtkTreeDFSIterator | Depth first iterator through a vtkGraph |
| CvtkTreeDifferenceFilter | Compare two trees |
| CvtkTreeFieldAggregator | Aggregate field values from the leaves up the tree |
| CvtkTreeHeatmapItem | A 2D graphics item for rendering a tree and an associated heatmap |
| CvtkTreeIterator | Abstract class for iterator over a vtkTree |
| CvtkTreeLayoutStrategy | Hierarchical layout |
| CvtkTreeLevelsFilter | Adds level and leaf fields to a vtkTree |
| CvtkTreeMapLayout | Layout a vtkTree into a tree map |
| CvtkTreeMapLayoutStrategy | Abstract superclass for all tree map layout strategies |
| CvtkTreeMapToPolyData | Converts a tree to a polygonal data representing a tree map |
| CvtkTreeMapView | Displays a tree as a tree map |
| CvtkTreeOrbitLayoutStrategy | Hierarchical orbital layout |
| CvtkTreeReader | Read vtkTree data file |
| CvtkTreeRingToPolyData | Converts a tree to a polygonal data representing radial space filling tree |
| CvtkTreeRingView | Displays a tree in concentric rings |
| CvtkTreeWriter | Write vtkTree data to a file |
| CvtkTriangle | Cell that represents a triangle |
| CvtkTriangleFilter | Convert input polygons and strips to triangles |
| CvtkTriangleMeshPointNormals | Compute point normals for triangle mesh |
| CvtkTriangleStrip | Cell that represents a triangle strip |
| CvtkTriangularTCoords | 2D texture coordinates based for triangles |
| CvtkTriangularTexture | Generate 2D triangular texture map |
| CvtkTrimmedExtrusionFilter | Extrude polygonal data trimmed by a second input surface |
| CvtkTriQuadraticHexahedron | Cell represents a parabolic, 27-node isoparametric hexahedron |
| CvtkTriQuadraticPyramid | Cell represents a parabolic, 19-node isoparametric pyramid |
| CvtkTrivialConsumer | Consumer to consume data off of a pipeline |
| CvtkTrivialProducer | Producer for stand-alone data objects |
| CvtkTRUCHASReader | Read GE TRUCHAS format HDF5 files |
| CvtkTryDowncastHelper1 | |
| CvtkTryDowncastHelper2 | |
| CvtkTryDowncastHelper3 | |
| CvtkTubeBender | Rounds corners on lines for better tubes |
| CvtkTubeFilter | Filter that generates tubes around lines |
| CvtkTulipReader | Reads tulip graph files |
| CvtkTuple | Templated base type for containers of constant size |
| CvtkTupleInterpolator | Interpolate a tuple of arbitrary size |
| CvtkTypedArray | Provides a type-specific interface to N-way arrays |
| CvtkTypedDataArray | Extend vtkDataArray with abstract type-specific API |
| CvtkTypedDataArrayIterator | STL-style random access iterator for vtkTypedDataArrays |
| CvtkTypeList | TypeList implementation and utilities |
| CvtkTypeTraits | Template defining traits of native types used by VTK |
| CvtkUncertaintyTubeFilter | Generate uncertainty tubes along a polyline |
| CvtkUndirectedGraph | An undirected graph |
| CvtkUndirectedGraphAlgorithm | Superclass for algorithms that produce undirected graph as output |
| CvtkUniformGrid | Image data with blanking |
| CvtkUniformGridAMR | Concrete implementation of vtkCompositeDataSet |
| CvtkUniformGridAMRAlgorithm | VtkUniformGridAMR as output |
| CvtkUniformGridAMRDataIterator | Subclass of vtkCompositeDataIterator with API to get current level and dataset index |
| CvtkUniformGridPartitioner | A concrete implementation of vtkMultiBlockDataSetAlgorithm that provides functionality for partitioning a uniform grid |
| CvtkUniformHyperTreeGrid | A specifalized type of vtkHyperTreeGrid for the case when root cells have uniform sizes in each direction |
| CvtkUniformHyperTreeGridSource | Create a synthetic grid of uniform hypertrees |
| CvtkUniforms | Helper class to set custom uniform variables in GPU shaders |
| CvtkUnsignedCharArray | Dynamic, self-adjusting array of unsigned char |
| CvtkUnsignedDistance | Compute unsigned (i.e., non-negative) distances from an input point cloud |
| CvtkUnsignedIntArray | Dynamic, self-adjusting array of unsigned int |
| CvtkUnsignedLongArray | Dynamic, self-adjusting array of unsigned long |
| CvtkUnsignedLongLongArray | Dynamic, self-adjusting array of unsigned long long |
| CvtkUnsignedShortArray | Dynamic, self-adjusting array of unsigned short |
| CvtkUnstructuredGrid | Dataset represents arbitrary combinations of all possible cell types |
| CvtkUnstructuredGridAlgorithm | Superclass for algorithms that produce only unstructured grid as output |
| CvtkUnstructuredGridBase | Dataset represents arbitrary combinations of all possible cell types |
| CvtkUnstructuredGridBaseAlgorithm | Superclass for algorithms that produce only vtkUnstructureGridBase subclasses as output |
| ►CvtkUnstructuredGridBunykRayCastFunction | Superclass for ray casting functions |
| CIntersection | |
| CTriangle | |
| CvtkUnstructuredGridCellIterator | Implementation of vtkCellIterator specialized for vtkUnstructuredGrid |
| ►CvtkUnstructuredGridFieldAnnotations | Fetch/add field annotations from/to an unstructured grid's field data |
| CBlockAttributesKey | A key for indexing annotations |
| CBlockAttributesValue | Configuration hints for a partitioned dataset collection entry |
| CFieldGlom | Gloms of multiple field names that represent vectors or tensors |
| CvtkUnstructuredGridGeometryFilter | Extract geometry from an unstructured grid |
| CvtkUnstructuredGridHomogeneousRayIntegrator | Performs piecewise constant ray integration |
| CvtkUnstructuredGridLinearRayIntegrator | Performs piecewise linear ray integration |
| CvtkUnstructuredGridPartialPreIntegration | Performs piecewise linear ray integration |
| CvtkUnstructuredGridPreIntegration | Performs ray integration with pre-integration tables |
| CvtkUnstructuredGridQuadricDecimation | Reduce the number of tetrahedra in a mesh |
| CvtkUnstructuredGridReader | Read vtk unstructured grid data file |
| ►CvtkUnstructuredGridToCellGrid | Create a cell-grid that approximates a collection of vtkUnstructuredGrids |
| ►CTranscribeQuery | An internal query object for transcribing cells from input to output |
| CClaim | A claim on input vtkCell types registered by an output vtkCellMetadata subclass |
| CvtkUnstructuredGridToExplicitStructuredGrid | Filter which converts an unstructured grid data into an explicit structured grid |
| CvtkUnstructuredGridToReebGraphFilter | Generate a Reeb graph from a scalar field defined on a vtkUnstructuredGrid |
| CvtkUnstructuredGridVolumeMapper | Abstract class for an unstructured grid volume mapper |
| CvtkUnstructuredGridVolumeRayCastFunction | Superclass for ray casting functions |
| CvtkUnstructuredGridVolumeRayCastIterator | VtkUnstructuredGridVolumeRayCastIterator is a superclass for iterating over the intersections of a viewing ray with a group of unstructured cells |
| CvtkUnstructuredGridVolumeRayCastMapper | A software mapper for unstructured volumes |
| CvtkUnstructuredGridVolumeRayIntegrator | Superclass for volume ray integration functions |
| CvtkUnstructuredGridVolumeZSweepMapper | Unstructured grid volume mapper based the ZSweep Algorithm |
| CvtkUnstructuredGridWriter | Write vtk unstructured grid data file |
| CvtkUpdateCellsV8toV9 | Update cells from v8 node layout to v9 node layout |
| CvtkURI | URI representation |
| ►CvtkURIComponent | Represent an URI component |
| CUndefinedTag | |
| CvtkURILoader | Helper class for readers and importer that need to load more than one resource |
| CvtkUTF16TextCodec | Class to read/write ascii text |
| CvtkUTF8TextCodec | Class to read/write UTF-8 text |
| CvtkValuePass | Renders geometry using the values of a field array as fragment colors |
| CvtkValueSelector | Selects elements matching chosen values |
| CvtkVariant | A type representing the union of many types |
| CvtkVariantArray | An array holding vtkVariants |
| CvtkVariantBoostSerialization | Serialization support for vtkVariant and vtkVariantArray using the Boost.Serialization library |
| CvtkVariantCast | Converts a vtkVariant to some other type |
| CvtkVariantCreate | Performs an explicit conversion from an arbitrary type to a vtkVariant |
| CvtkVariantEqual | |
| CvtkVariantExtract | Performs an explicit conversion from a vtkVariant to the type that it contains |
| CvtkVariantLessThan | |
| CvtkVariantStrictEquality | |
| CvtkVariantStrictWeakOrder | |
| CvtkVASPAnimationReader | Reader for VASP animation files |
| CvtkVASPTessellationReader | Read NPT_Z_TESSELLATE.out files |
| CvtkVector | Templated base type for storage of vectors |
| CvtkVector2 | |
| CvtkVector2d | |
| CvtkVector2f | |
| CvtkVector2i | Some derived classes for the different vectors commonly used |
| CvtkVector3 | |
| CvtkVector3d | |
| CvtkVector3f | |
| CvtkVector3i | |
| CvtkVector4 | |
| CvtkVector4d | |
| CvtkVector4i | |
| CvtkVectorDot | Generate scalars from dot product of vectors and normals (e.g., show displacement plot) |
| CvtkVectorFieldTopology | Extract the topological skeleton as output datasets |
| CvtkVectorNorm | Generate scalars from Euclidean norm of vectors |
| CvtkVectorText | Create polygonal text |
| CvtkVeraOutReader | |
| CvtkVersion | Versioning class for vtk |
| CvtkVertex | Cell that represents a 3D point |
| CvtkVertexAdjacencyList | |
| CvtkVertexDegree | Adds an attribute array with the degree of each vertex |
| CvtkVertexGlyphFilter | Make a vtkPolyData with a vertex on each point |
| CvtkVertexListIterator | Iterates all vertices in a graph |
| CvtkVideoSource | Superclass of video input devices for VTK |
| ►CvtkView | The superclass for all views |
| CViewProgressEventCallData | A ptr to an instance of ViewProgressEventCallData is provided in the call data when vtkCommand::ViewProgressEvent is fired |
| CvtkViewDependentErrorMetric | Objects that compute a screen-based error during cell tessellation |
| CvtkViewNode | Node within a VTK scene graph |
| CvtkViewNodeFactory | Factory that chooses vtkViewNodes to create |
| CvtkViewport | Abstract specification for Viewports |
| CvtkViewTheme | Sets theme colors for a graphical view |
| CvtkViewUpdater | Updates views automatically |
| CvtkVisibilitySort | Abstract class that can sort cell data along a viewpoint |
| CvtkVoidArray | Dynamic, self-adjusting array of void* pointers |
| CvtkVolume | Volume (data & properties) in a rendered scene |
| CvtkVolume16Reader | Read 16 bit image files |
| CvtkVolumeCollection | Ordered list of volumes |
| CvtkVolumeContourSpectrumFilter | Compute an approximation of the volume contour signature (evolution of the volume of the input tet-mesh along an arc of the Reeb graph) |
| CvtkVolumeInputHelper | Convenience container for internal structures specific to a volume input |
| CvtkVolumeMapper | Abstract class for a volume mapper |
| CvtkVolumeMapperNode | VtkViewNode specialized for vtkVolumeMappers |
| CvtkVolumeMask | |
| CvtkVolumeNode | VtkViewNode specialized for vtkActors |
| CvtkVolumeOfRevolutionFilter | Sweep data about a line to create a volume |
| CvtkVolumeOutlineSource | Outline of volume cropping region |
| CvtkVolumePicker | Ray-cast picker enhanced for volumes |
| CvtkVolumeProperty | Common properties for rendering a volume |
| CvtkVolumeRayCastSpaceLeapingImageFilter | Builds the space leaping data structure |
| CvtkVolumeReader | Read image files |
| CvtkVolumeStateRAII | |
| ►CvtkVolumeTexture | Creates and manages the volume texture rendered by vtkOpenGLGPUVolumeRayCastMapper |
| CVolumeBlock | |
| CvtkVolumetricPass | Render the volumetric geometry with property key filtering |
| CvtkVoronoi2D | Create 2D Voronoi convex tiling of input points |
| CvtkVoronoiKernel | Voronoi interpolation kernel |
| CvtkVortexCore | Compute vortex core lines using the parallel vectors method |
| CvtkVoxel | Cell that represents a 3D orthogonal parallelepiped |
| CvtkVoxelContoursToSurfaceFilter | Create surface from contours |
| CvtkVoxelGrid | Subsample points using uniform binning |
| CvtkVoxelModeller | Convert an arbitrary dataset to a voxel representation |
| CvtkVPICReader | Class for reading VPIC data files |
| ►CvtkVRCamera | VR camera |
| CPose | |
| ►CvtkVRCollaborationClient | |
| CArgument | |
| CPose | |
| CvtkVRControlsHelper | Tooltip helper explaining controls Helper class to draw one tooltip per button around the controller |
| CvtkVRFollower | VR Follower |
| CvtkVRHardwarePicker | Pick an actor/prop given a controller position and orientation |
| CvtkVRHMDCamera | A superclass for HMD style cameras |
| CvtkVRInteractorStyle | Extended from vtkInteractorStyle3D to override command methods |
| CvtkVRMenuRepresentation | Widget representation for vtkVRMenuWidget Implementation of the popup panel representation for the vtkVRMenuWidget |
| CvtkVRMenuWidget | 3D widget to display a menu in VR |
| CvtkVRMLExporter | Export a scene into VRML 2.0 format |
| CvtkVRMLImporter | Imports VRML 2.0 files |
| CvtkVRMLImporter_Yacc | |
| CvtkVRMLUseStruct | |
| ►CvtkVRMLYaccData | |
| CFakeAlloca | |
| Cyy_buffer_state | |
| Cyyltype | |
| CYYSTYPE | |
| CvtkVRModel | VR device model |
| CvtkVRPanelRepresentation | Widget representation for vtkVRPanelWidget Implementation of the popup panel representation for the vtkVRPanelWidget |
| CvtkVRPanelWidget | 3D widget to display a panel/billboard |
| CvtkVRRay | VR device model |
| CvtkVRRenderer | Renderer class for VR/AR context |
| ►CvtkVRRenderWindow | VR rendering window |
| CDeviceData | |
| CFramebufferDesc | |
| CvtkVRRenderWindowInteractor | Implements VR specific functions required by vtkRenderWindowInteractor |
| CvtkVtkJSSceneGraphSerializer | Converts elements of a VTK scene graph into vtk-js elements |
| CvtkVtkJSViewNodeFactory | Constructs view nodes for traversing a scene for vtk-js |
| CvtkWarpLens | Deform geometry by applying lens distortion |
| CvtkWarpScalar | Deform geometry with scalar data |
| CvtkWarpTo | Deform geometry by warping towards a point |
| CvtkWarpTransform | Superclass for nonlinear geometric transformations |
| CvtkWarpVector | Deform geometry with vector data |
| CvtkWasmSceneManager | VtkWasmSceneManager provides additional functionality that relates to a vtkRenderWindow and user interaction |
| CvtkWeakPointer | Weak reference to a vtkObject |
| ►CvtkWeakPointerBase | Non-templated superclass for vtkWeakPointer |
| CNoReference | |
| CvtkWeakReference | Utility class to hold a weak reference to a vtkObject |
| CvtkWebApplication | Defines ParaViewWeb application interface |
| CvtkWebAssemblyOpenGL2RenderWindow | OpenGL rendering window |
| CvtkWebAssemblyOpenGLRenderWindow | |
| CvtkWebAssemblyRenderWindowInteractor | Handles user interaction in web browsers |
| CvtkWebAssemblyWebGPURenderWindow | OpenGL rendering window |
| CvtkWebGLDataSet | VtkWebGLDataSet represent vertices, lines, polygons, and triangles |
| CvtkWebGLExporter | VtkWebGLExporter export the data of the scene to be used in the WebGL |
| CvtkWebGLObject | VtkWebGLObject represent and manipulate an WebGL object and its data |
| CvtkWebGLPolyData | PolyData representation for WebGL |
| CvtkWebGLWidget | Widget representation for WebGL |
| ►CvtkWebGPUActor | |
| ►CActorBlock | |
| CRenderOptions | |
| CShadeOptions | |
| CTransformInfo | |
| CMapperBooleanCache | |
| CvtkWebGPUBatchedPolyDataMapper | A WebGPU mapper for batched rendering of vtkPolyData |
| ►CvtkWebGPUBindGroupInternals | |
| CBindingInitializationHelper | |
| ►CvtkWebGPUBindGroupLayoutInternals | |
| CLayoutEntryInitializationHelper | |
| CvtkWebGPUBufferInternals | |
| CvtkWebGPUCallbacksInternals | Utilitary class for various WebGPU callbacks methods |
| ►CvtkWebGPUCamera | |
| CSceneTransforms | |
| CvtkWebGPUCellToPrimitiveConverter | Converts VTK cell connectivity arrays into webgpu primitives using compute shaders |
| CvtkWebGPUClearDrawPass | |
| CvtkWebGPUCommandEncoderDebugGroup | Convenient class that inserts annotations around draw commands within a render pass/bundle |
| CvtkWebGPUCompositePolyDataMapperDelegator | An OpenGL delegator for batched rendering of multiple polydata with similar structure |
| CvtkWebGPUComputeBuffer | Represents the set of parameters that will be used to create a compute shader buffer on the device when it will be added to a compute pass using vtkWebGPUComputePass::AddBuffer() |
| CvtkWebGPUComputeBufferInternals | Internal utility class for manipulating vtkWebGPUComputeBuffers |
| CvtkWebGPUComputeFrustumCuller | This culler culls props to the camera view frustum using WebGPU compute shaders |
| CvtkWebGPUComputeOcclusionCuller | This culler does both frustum culling and occlusion culling |
| CvtkWebGPUComputePass | A compute pass is an abstraction for offloading computation from the CPU onto the GPU using WebGPU compute shaders |
| CvtkWebGPUComputePassBufferStorageInternals | This class manages the creation/deletion/recreation/resizing/updating of compute buffers used by a compute pass |
| CvtkWebGPUComputePassInternals | Internals of the vtkWebGPUComputePass |
| CvtkWebGPUComputePassTextureStorageInternals | This class manages the creation/deletion/recreation/ of compute textures used by a compute pass |
| CvtkWebGPUComputePipeline | A compute pipeline is the orchestrator of a collection of compute passes |
| CvtkWebGPUComputePointCloudMapper | The point cloud renderer uses WebGPU compute shaders to render the point cells of a polydata onto the framebuffer of a given WebGPURenderer |
| CvtkWebGPUComputeRenderBuffer | Render buffers are returned by calls to vtkWebGPUPolyDataMapper::AcquirePointAttributeComputeRenderBuffer() (or CellAttribute equivalent) and represent a buffer that is used by the rendering pipeline and that can also be added to a compute pipeline |
| CvtkWebGPUComputeRenderTexture | Render textures are returned by calls to vtkWebGPUPolyDataMapper::AcquireXXXXRenderTexture() and represent a buffer that is used by the rendering pipeline and that can also be added to a compute pipeline |
| CvtkWebGPUComputeTexture | Represents the set of parameters that will be used to create a compute shader texture on the device when it will be added to a pipeline using vtkWebGPUComputePipeline::AddTexture() |
| CvtkWebGPUComputeTextureView | |
| CvtkWebGPUConfiguration | Create a webgpu device for use in rendering and compute pipelines |
| CvtkWebGPUConfigurationInternals | |
| CvtkWebGPUHardwareSelector | Implements the device specific code of vtkWebGPUHardwareSelector |
| CvtkWebGPUHelpers | |
| ►CvtkWebGPULight | OpenGL light |
| CLightInfo | |
| CvtkWebGPUPipelineLayoutInternals | |
| ►CvtkWebGPUPointCloudMapperInternals | Internal implementation details of vtkWebGPUPointCloudMapper |
| CCopyDepthBufferRenderPipeline | Structure that contains the wgpu objects necessary for the use of the render pipeline that copies the depth buffer of a point cloud mapper to the depth buffer of a render window (using a simple fragment shader that reads the depth from the point depth buffer and writes it to the depth buffer of the render window) |
| ►CvtkWebGPUPolyDataMapper | |
| CActorState | |
| CAttributeDescriptor | |
| CMeshAttributeBuffers | |
| CMeshAttributeDescriptor | |
| COverrideColorDescriptor | |
| CTopologyBindGroupInfo | |
| CvtkWebGPUProperty | WebGPU property |
| ►CvtkWebGPURenderer | |
| CRenderPipelineBatch | |
| CvtkWebGPURenderPass | |
| CvtkWebGPURenderPassCreateInfoInternals | |
| CvtkWebGPURenderPassDescriptorInternals | |
| CvtkWebGPURenderPipelineCache | Class to create and retrieve render pipelines based on a given key |
| CvtkWebGPURenderPipelineDescriptorInternals | |
| ►CvtkWebGPURenderWindow | WebGPU rendering window |
| CMappingContext | |
| CvtkWGPUColorAttachment | |
| CvtkWGPUDeptStencil | |
| CvtkWGPUFullScreenQuad | |
| CvtkWGPUUserStagingPixelData | |
| CvtkWebGPUShaderDatabase | Class to add and retrieve source code for shader files for a specified key |
| CvtkWebGPUShaderModuleInternals | |
| CvtkWebGPUTexture | Abstraction class for WebGPU textures |
| CvtkWebGPUTextureInternals | |
| CvtkWebGPUTextureView | Abstraction class for WebGPU texture views |
| CvtkWebInteractionEvent | |
| CvtkWebUtilities | Collection of utility functions for ParaView Web |
| CvtkWedge | 3D cell that represents a linear wedge |
| CvtkWeightedTransformFilter | Transform based on per-point or per-cell weighting functions |
| CvtkWendlandQuinticKernel | Quintic SPH interpolation kernel |
| CvtkWidgetCallbackMapper | Map widget events into callbacks |
| CvtkWidgetEvent | Define widget events |
| CvtkWidgetEventTranslator | Map VTK events into widget events |
| CvtkWidgetRepresentation | Abstract class defines interface between the widget and widget representation classes |
| CvtkWidgetSet | Synchronize a collection on vtkWidgets drawn on different renderwindows using the Callback - Dispatch Action mechanism |
| CvtkWin32HardwareWindow | Window in a windows GUI |
| CvtkWin32Header | Manage Windows system differences |
| CvtkWin32OpenGL2RenderWindow | OpenGL rendering window |
| CvtkWin32OpenGLDXRenderWindow | VTK render window providing OpenGL-DirectX interop |
| CvtkWin32OpenGLRenderWindow | |
| CvtkWin32OutputWindow | Win32 Specific output window class |
| CvtkWin32ProcessOutputWindow | Win32-specific output window class |
| CvtkWin32RenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| CvtkWin32VideoSource | Video-for-Windows video digitizer |
| CvtkWindBladeReader | Class for reading WindBlade data files |
| CvtkWindow | Window superclass for vtkRenderWindow |
| CvtkWindowedSincPolyDataFilter | Adjust point positions using a windowed sinc function interpolation kernel |
| CvtkWindowLevelLookupTable | Map scalar values into colors or colors to scalars; generate color table |
| CvtkWindowNode | VtkViewNode specialized for vtkRenderWindows |
| CvtkWindowToImageFilter | Use a vtkWindow as input to image pipeline |
| CvtkWordCloud | Generate a word cloud visualization of a text document |
| CvtkWorldPointPicker | Find world x,y,z corresponding to display x,y,z |
| CvtkWrappingHints | Hint macros for wrappers |
| CvtkWriter | Abstract class to write data to file(s) |
| CvtkX3DExporter | Create an x3d file |
| CvtkX3DExporterFIWriter | |
| ►CvtkX3DExporterFIWriterHelper | |
| Cfloat_to_unsigned_int_to_bytes | |
| CvtkX3DExporterWriter | X3D Exporter Writer |
| CvtkX3DExporterXMLWriter | X3D Exporter XML Writer |
| CvtkXArrayAccessor | |
| CvtkXdmf3ArrayKeeper | LRU cache of XDMF Arrays |
| CvtkXdmf3ArraySelection | Helper to identify requested arrays with |
| CvtkXdmf3DataSet | Dataset level translation between xdmf3 and vtk |
| CvtkXdmf3HeavyDataHandler | Internal helper for vtkXdmf3Reader |
| CvtkXdmf3LightDataHandler | Internal helper for vtkXdmf3Reader |
| CvtkXdmf3Reader | Reads eXtensible Data Model and Format files |
| CvtkXdmf3SILBuilder | Helper to allow block selection |
| CvtkXdmf3Writer | Write eXtensible Data Model and Format files |
| CvtkXdmfArraySelection | |
| CvtkXdmfDataArray | |
| CvtkXdmfDocument | |
| CvtkXdmfDomain | |
| CvtkXdmfHeavyData | |
| ►CvtkXdmfReader | Reads eXtensible Data Model and Format files |
| CXdmfDataSetTopoGeoPath | |
| CvtkXdmfReaderInternal | |
| CvtkXdmfWriter | Write eXtensible Data Model and Format files |
| CvtkXGMLReader | Reads XGML graph files |
| CvtkXMLCompositeDataReader | Reader for multi-group datasets |
| CvtkXMLCompositeDataSetWriterHelper | Helper class used by vtkXMLWriter2 subclasses that write composite datasets |
| CvtkXMLCompositeDataWriter | Writer for multi-group datasets |
| CvtkXMLDataElement | Represents an XML element and those nested inside |
| CvtkXMLDataHeader | |
| CvtkXMLDataHeaderImpl | |
| CvtkXMLDataObjectWriter | Write any type of VTK XML file |
| CvtkXMLDataParser | Used by vtkXMLReader to parse VTK XML files |
| CvtkXMLDataReader | Superclass for VTK XML file readers |
| CvtkXMLDataSetWriter | Write any type of VTK XML file |
| CvtkXMLDataWriterHelper | Helper for vtkXMLWriter2 and subclasses |
| CvtkXMLFileOutputWindow | XML File Specific output window class |
| CvtkXMLFileReadTester | Utility class for vtkXMLReader and subclasses |
| CvtkXMLGenericDataObjectReader | Read any type of vtk data object |
| CvtkXMLHierarchicalBoxDataFileConverter | Converts older *.vth, *.vthb files to newer format |
| CvtkXMLHierarchicalBoxDataReader | Reader for hierarchical datasets (for backwards compatibility) |
| CvtkXMLHierarchicalBoxDataWriter | Writer for vtkHierarchicalBoxDataSet for backwards compatibility |
| CvtkXMLHierarchicalDataReader | Reader for hierarchical datasets |
| CvtkXMLHyperTreeGridReader | Read VTK XML HyperTreeGrid files |
| ►CvtkXMLHyperTreeGridWriter | Write VTK XML HyperTreeGrid files |
| CHyperTreeGridMetaDataForVersion2 | |
| CvtkXMLImageDataReader | Read VTK XML ImageData files |
| CvtkXMLImageDataWriter | Write VTK XML ImageData files |
| CvtkXMLMultiBlockDataReader | Reader for multi-block datasets |
| CvtkXMLMultiBlockDataWriter | Writer for vtkMultiBlockDataSet |
| CvtkXMLMultiGroupDataReader | Reader for multi-block datasets |
| CvtkXMLParser | Parse XML to handle element tags and attributes |
| CvtkXMLPartitionedDataSetCollectionReader | Reader for partitioned dataset collections |
| CvtkXMLPartitionedDataSetCollectionWriter | Writer for vtkPartitionedDataSetCollection |
| CvtkXMLPartitionedDataSetReader | Reader for partitioned datasets |
| CvtkXMLPartitionedDataSetWriter | XML writer for vtkPartitionedDataSet |
| CvtkXMLPDataObjectReader | Superclass for PVTK XML file readers |
| CvtkXMLPDataObjectWriter | Write data in a parallel XML format |
| CvtkXMLPDataReader | Superclass for PVTK XML file readers that read vtkDataSets |
| CvtkXMLPDataSetWriter | Write any type of PVTK XML file |
| CvtkXMLPDataWriter | Write data in a parallel XML format |
| CvtkXMLPHierarchicalBoxDataWriter | Parallel writer for vtkHierarchicalBoxDataSet for backwards compatibility |
| CvtkXMLPHyperTreeGridReader | Read PVTK XML HyperTreeGrid files |
| CvtkXMLPHyperTreeGridWriter | Write PVTK XML HyperTreeGrid files |
| CvtkXMLPImageDataReader | Read PVTK XML ImageData files |
| CvtkXMLPImageDataWriter | Write PVTK XML ImageData files |
| CvtkXMLPMultiBlockDataWriter | Parallel writer for vtkHierarchicalBoxDataSet |
| CvtkXMLPolyDataReader | Read VTK XML PolyData files |
| CvtkXMLPolyDataWriter | Write VTK XML PolyData files |
| CvtkXMLPPolyDataReader | Read PVTK XML PolyData files |
| CvtkXMLPPolyDataWriter | Write PVTK XML PolyData files |
| CvtkXMLPRectilinearGridReader | Read PVTK XML RectilinearGrid files |
| CvtkXMLPRectilinearGridWriter | Write PVTK XML RectilinearGrid files |
| CvtkXMLPStructuredDataReader | Superclass for parallel structured data XML readers |
| CvtkXMLPStructuredDataWriter | Superclass for PVTK XML structured data writers |
| CvtkXMLPStructuredGridReader | Read PVTK XML StructuredGrid files |
| CvtkXMLPStructuredGridWriter | Write PVTK XML StructuredGrid files |
| CvtkXMLPTableReader | Read PVTK XML Table files |
| CvtkXMLPTableWriter | Write PVTK XML UnstructuredGrid files |
| CvtkXMLPUniformGridAMRWriter | Parallel writer for vtkUniformGridAMR and subclasses |
| CvtkXMLPUnstructuredDataReader | Superclass for parallel unstructured data XML readers |
| CvtkXMLPUnstructuredDataWriter | Superclass for PVTK XML unstructured data writers |
| CvtkXMLPUnstructuredGridReader | Read PVTK XML UnstructuredGrid files |
| CvtkXMLPUnstructuredGridWriter | Write PVTK XML UnstructuredGrid files |
| CvtkXMLReader | Superclass for VTK's XML format readers |
| CvtkXMLReaderVersion | Version number for legacy readers/writers |
| CvtkXMLRectilinearGridReader | Read VTK XML RectilinearGrid files |
| CvtkXMLRectilinearGridWriter | Write VTK XML RectilinearGrid files |
| CvtkXMLStructuredDataReader | Superclass for structured data XML readers |
| CvtkXMLStructuredDataWriter | Superclass for VTK XML structured data writers |
| CvtkXMLStructuredGridReader | Read VTK XML StructuredGrid files |
| CvtkXMLStructuredGridWriter | Write VTK XML StructuredGrid files |
| CvtkXMLTableReader | Read VTK XML Table files |
| CvtkXMLTableWriter | Write VTK XML Table files |
| CvtkXMLTreeReader | Reads an XML file into a vtkTree |
| CvtkXMLUniformGridAMRReader | Reader for amr datasets (vtkOverlappingAMR or vtkNonOverlappingAMR) |
| CvtkXMLUniformGridAMRWriter | Writer for vtkUniformGridAMR |
| CvtkXMLUnstructuredDataReader | Superclass for unstructured data XML readers |
| CvtkXMLUnstructuredDataWriter | Superclass for VTK XML unstructured data writers |
| CvtkXMLUnstructuredGridReader | Read VTK XML UnstructuredGrid files |
| CvtkXMLUnstructuredGridWriter | Write VTK XML UnstructuredGrid files |
| CvtkXMLUtilities | XML utilities |
| CvtkXMLWriter | Superclass for VTK's XML file writers |
| CvtkXMLWriter2 | Base class for new-style XML Writers |
| CvtkXMLWriterBase | Abstract base class for VTK-XML writers |
| CvtkXOpenGLRenderWindow | OpenGL rendering window |
| CvtkXRenderWindowInteractor | X event driven interface for a RenderWindow |
| CvtkXWebGPURenderWindow | WebGPU rendering window for the X Window system |
| CvtkXYPlotActor | Generate an x-y plot from input dataset(s) or field data |
| CvtkXYPlotRepresentation | Represent XY plot for vtkXYPlotWidget |
| CvtkXYPlotWidget | 2D widget for manipulating a XY plot |
| CvtkXYZMolReader | Read Molecular Data files |
| CvtkXYZMolReader2 | Read Molecular Data files |
| CvtkYieldCriteria | Compute principal stress and yield criteria from symmetric tensor |
| CvtkYoungsMaterialInterface | Reconstructs material interfaces |
| CvtkZLibDataCompressor | Data compression using zlib |
| CvtkZSpaceCamera | Extends vtkOpenGLCamera to use custom view and projection matrix given by zSpace SDK |
| CvtkZSpaceCoreCompatibilitySDKManager | ZSpace Core Compatibility SDK manager class |
| CvtkZSpaceCoreSDKManager | ZSpace Core SDK manager class |
| CvtkZSpaceGenericRenderWindow | Generic render window for stereo rendering on ZSpace Inspire |
| CvtkZSpaceHardwarePicker | Pick an actor/prop given the stylus position and orientation |
| CvtkZSpaceInteractorStyle | VtkZSpaceInteractorStyle extends vtkInteractorStyle3D to override command methods |
| CvtkZSpaceRayActor | An actor for displaying a ray |
| CvtkZSpaceRenderer | VR renderer |
| CvtkZSpaceRenderWindowInteractor | Handle zSpace specific interactions |
| CvtkZSpaceSDKManager | Abstract zSpace SDK manager class |
| CvtkZSpaceWin32RenderWindow | OpenGL render window for stereo rendering on ZSpace Inspire |
| CX3DEncoderFunctions | |
| CZCCompatDisplayIntersectionInfo | |
| CZCCompatFrustumBounds | |
| CZCCompatTrackerPose | |
| CZSMatrix4 | Union representing 4x4 matrix (right-handed OpenGL column-major format). / This structure is used by both the Stereo Frustum and Coordinate Space APIs |
| CzSpaceCoreCompatEntryPoints | Structure holding the loaded zSpace Core Compatibility API entry point function pointers |
| CZSVector3 | Union representing a vector of 3 floats |
1.9.7