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