| CvtkKdTree::_cellList | |
| C_ClassInfo | ClassInfo is for classes, structs, unions, and namespaces |
| C_FileInfo | FileInfo is for header files |
| C_FunctionInfo | FunctionInfo is for functions and methods |
| C_HierarchyEntry | This file contains utility functions for loading and parsing a VTK hierarchy file |
| C_HierarchyInfo | All the entries from a hierarchy file |
| C_ItemInfo | ItemInfo just contains an index |
| C_MacroInfo | Struct to describe a preprocessor symbol |
| C_MergeInfo | This file contains utility functions for merging together the methods for a class with those inherited from all superclasses |
| C_OptionInfo | VtkParseMain.h provides argument parsing for the wrapper executables |
| C_PreprocessInfo | Contains all symbols defined thus far (including those defined in any included header files) |
| C_StringCache | StringCache provides a simple way of allocating strings centrally |
| C_StringTokenizer | A struct for going through a string one token at a time |
| C_TemplateInfo | TemplateInfo holds template definitions |
| C_UsingInfo | UsingInfo is for using directives |
| C_ValueInfo | ValueInfo is for typedefs, constants, variables, function parameters, and return values |
| C_vtkTclVoidFuncArg | |
| CActionFunction< TWidget > | |
| ►Cadjacency_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| CvtkAnimationCue::AnimationCueInfo | |
| CvtkExodusIIReaderPrivate::ArrayInfoType | A struct to hold information about time-varying arrays |
| ►CvtkStatisticsAlgorithm::AssessFunctor | |
| CvtkKMeansAssessFunctor | |
| CvtkMultiCorrelativeAssessFunctor | |
| Cdetail::AtomicOps< size > | |
| Cdetail::AtomicOps< 4 > | |
| Cdetail::AtomicOps< 8 > | |
| ►CvtkFieldData::BasicIterator | |
| CvtkFieldData::Iterator | |
| ►Cbidirectional_graph_tag | |
| Cboost::vtkGraph_traversal_category | |
| ►Cbinary_function | |
| CvtkPiston::minmax_binary_op< T > | |
| CvtkAMRDataInternals::Block | |
| CvtkExodusIIWriter::Block | |
| CvtkTemporalStreamTracer::bounds | |
| CBSPNode | |
| CvtkTextureImageCache< Key >::CacheData | |
| CvtkDax::detail::CellTypeInDataSet | |
| 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< std::numeric_limits< vtkIdType >::is_specialized &&std::numeric_limits< vtkIdType >::is_integer &&(sizeof(vtkIdType)==4||sizeof(vtkIdType)==8)> | |
| Cvtk::atomic::detail::CompileTimeCheck< std::numeric_limits< vtkTypeInt32 >::is_specialized &&std::numeric_limits< vtkTypeInt32 >::is_integer &&(sizeof(vtkTypeInt32)==4||sizeof(vtkTypeInt32)==8)> | |
| Cvtk::atomic::detail::CompileTimeCheck< true > | |
| CvtkMergeFields::Component | |
| CvtkSplitField::Component | |
| CvtkUnicodeString::const_iterator | |
| CvtkMaskFields::CopyFieldFlag | |
| CvtkFieldData::CopyFieldFlag | |
| ►CCWnd | |
| CvtkMFCWindow | Class to display a VTK window in an MFC window |
| CvtkAVSucdReader::DataInfo | |
| ►CDataSetsTypeBase | |
| CvtkCompositeInterpolatedVelocityFieldDataSetsType | |
| CvtkMultiBlockPLOT3DReaderInternals::Dims | |
| 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 | |
| CvtkGenericEdgeTable::EdgeEntry | |
| CvtkOStreamWrapper::EndlType | |
| CvtkFreeTypeUtilities::Entry | |
| CvtkQuadricDecimation::ErrorQuadric | |
| CvtkVRMLYaccData::FakeAlloca | |
| CvtkDataSetAttributes::FieldList | |
| CVrmlNodeType::FieldRec | |
| CvtkX3DExporterFIWriterHelper::float_to_unsigned_int_to_bytes | |
| 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 > | |
| ►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 > | |
| Cboost::hash< vtkEdgeType > | |
| CvtkInformationInternals::HashFun | |
| ►CImpl | |
| CvtkDispatcherPrivate::FunctorHandler< ParentFunctor, Fun > | |
| CvtkDoubleDispatcherPrivate::FunctorHandler< ParentFunctor, Fun > | |
| CvtkLabelHierarchy::Implementation | |
| CvtkSMPMergePolyDataHelper::InputData | |
| ►Cvtk::atomic::detail::IntegralType< T > | |
| CvtkAtomic< T > | Provides support for atomic integers |
| ►Cvtk::atomic::detail::IntegralType< vtkIdType > | |
| CvtkAtomic< vtkIdType > | |
| ►Cvtk::atomic::detail::IntegralType< vtkTypeInt32 > | |
| CvtkAtomic< vtkTypeInt32 > | |
| CvtkMultiBlockPLOT3DReaderInternals::InternalSettings | |
| CvtkUnstructuredGridBunykRayCastFunction::Intersection | |
| CvtkStreamTracer::IntervalInformation | |
| CvtkGenericStreamTracer::IntervalInformation | |
| CvtkPriorityQueue::Item | |
| CvtkSMPThreadLocal< T >::iterator | |
| CvtkSMPThreadLocalObject< T >::iterator | |
| ►Citerator_facade | |
| Cboost::vtk_edge_iterator | |
| Cboost::vtk_in_edge_pointer_iterator | |
| Cboost::vtk_out_edge_pointer_iterator | |
| Cboost::vtk_vertex_iterator | |
| CIVFDataSetInfo | |
| CvtkParallelRenderManager::LightInfo | |
| CvtkCellLinks::Link | |
| CvtkDecimatePro::LocalTri | |
| CvtkDecimatePro::LocalVertex | |
| CvtkParallelTimer::LogBodyType | |
| CvtkParallelTimer::LogHeaderType | |
| ►Cmap | |
| CvtkXdmf3ArrayKeeper | LRU cache of XDMF Arrays |
| CvtkXdmf3ArraySelection | Helper to identify requested arrays with |
| CvtkXdmfArraySelection | |
| ►CvtkDenseArray< T >::MemoryBlock | |
| CvtkDenseArray< T >::HeapMemoryBlock | |
| CvtkDenseArray< T >::StaticMemoryBlock | |
| CvtkTextRenderer::Metrics | |
| CvtkSLACReader::MidpointCoordinateMap | |
| CvtkSLACReader::MidpointCoordinates | |
| CvtkSLACReader::MidpointIdMap | |
| CvtkPiston::minmax_pair< T > | |
| CvtkChart::MouseActions | |
| 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 |
| CvtkWeakPointerBase::NoReference | |
| CvtkSmartPointerBase::NoReference | |
| CvtkMultiThreshold::NormKey | A class with comparison operator used to index input array norms used in threshold rules |
| ►CNSView | |
| CvtkCocoaGLView | Cocoa OpenGL rendering context |
| CvtkCocoaGLView | Cocoa OpenGL rendering context |
| ►CvtkExodusIIReaderPrivate::ObjectInfoType | A struct to hold information about Exodus objects (blocks, sets, maps) |
| CvtkExodusIIReaderPrivate::AssemblyInfoType | |
| ►CvtkExodusIIReaderPrivate::BlockSetInfoType | A struct to hold information about Exodus blocks or sets (they have some members in common) |
| CvtkExodusIIReaderPrivate::BlockInfoType | A struct to hold information about Exodus blocks |
| CvtkExodusIIReaderPrivate::SetInfoType | A struct to hold information about Exodus sets |
| CvtkExodusIIReaderPrivate::MapInfoType | A struct to hold information about Exodus maps |
| CvtkExodusIIReaderPrivate::MaterialInfoType | |
| CvtkExodusIIReaderPrivate::PartInfoType | A struct to hold information about Exodus blocks |
| COffsetsManager | Helper class due to PIMPL excess |
| COffsetsManagerArray | |
| COffsetsManagerGroup | |
| CvtkCommunicator::Operation | |
| CvtkRearrangeFields::Operation | |
| CvtkTextCodec::OutputIterator | |
| CvtkObjectFactory::OverrideInformation | |
| ►Cpair | |
| CvtkTextureImageCache< Key >::CacheElement | |
| CvtkTextureImageCache< Key >::CacheElement | |
| CvtkParticleTracerBaseNamespace::ParticleInformation | |
| CvtkTemporalStreamTracerNamespace::ParticleInformation | |
| CParticlePathFilterInternal | |
| CvtkHardwareSelector::PixelInformation | |
| CvtkGenericEdgeTable::PointEntry | |
| CvtkQuadricClustering::PointQuadric | |
| CvtkParticleTracerBaseNamespace::Position | |
| CvtkTemporalStreamTracerNamespace::Position | |
| CvtkLabelHierarchy::Implementation::PriorityComparator | |
| CvtkOpenGLContextDevice2D::Private | |
| ►Cboost::graph::parallel::process_group_type< vtkGraph * > | |
| ►Cboost::graph::parallel::process_group_type< vtkDirectedGraph * > | |
| Cboost::graph::parallel::process_group_type< vtkDirectedGraph *const > | |
| ►Cboost::graph::parallel::process_group_type< vtkUndirectedGraph * > | |
| Cboost::graph::parallel::process_group_type< vtkUndirectedGraph *const > | |
| Cboost::property_map< vtkGraph *, edge_global_t > | |
| ►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_global_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_map< vtkGraph *, vertex_local_t > | |
| Cboost::property_map< vtkGraph *, vertex_owner_t > | |
| Cboost::property_traits< typename > | |
| Cboost::property_traits< vtkAbstractArray * > | |
| Cboost::property_traits< vtkDataArray * > | |
| Cboost::property_traits< vtkEdgeGlobalMap > | |
| Cboost::property_traits< vtkGraphEdgeMap > | |
| Cboost::property_traits< vtkGraphIndexMap > | |
| Cboost::property_traits< vtkVertexGlobalMap > | |
| Cboost::property_traits< vtkVertexLocalMap > | |
| Cboost::property_traits< vtkVertexOwnerMap > | |
| ►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 |
| ►CQObject | |
| 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) |
| ►CQStandardItemModel | |
| CReferenceCountModel | |
| CvtkQtDebugLeaksModel | Model class that observes the vtkDebugLeaks singleton |
| ►CQWidget | |
| CvtkQtDebugLeaksView | View class to display contents of vtkQtDebugLeaksModel |
| CvtkPParticleTracerBase::RemoteParticleInfo | |
| CvtkCompositeSurfaceLICMapper::RenderBlockState | |
| CvtkCompositePainter::RenderBlockState | |
| CvtkGenericCompositePolyDataMapper2::RenderBlockState | |
| CvtkSynchronizedRenderers::RendererInfo | |
| CvtkParallelRenderManager::RendererInfo | |
| CvtkCompositePolyDataMapper2::RenderValue | |
| CvtkParallelRenderManager::RenderWindowInfo | |
| CvtkSynchronizedRenderWindows::RenderWindowInfo | |
| CvtkMPICommunicator::Request | |
| ►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 |
| CStreaklineFilterInternal | |
| CvtkStreamer::StreamArray | |
| CvtkStreamer::StreamPoint | |
| ►Cstring | |
| CvtkStdString | Wrapper around std::string to keep symbols short |
| CtagBlock | |
| CtagFlashReaderDoubleScalar | |
| CtagFlashReaderIntegerScalar | |
| CtagFlashReaderSimulationInformation | |
| CtagFlashReaderSimulationParameters | |
| CTest | |
| CTextPropertyKey< StringType > | |
| CvtkMultiThreader::ThreadInfo | |
| CvtkUnstructuredGridBunykRayCastFunction::Triangle | |
| CvtkDecimatePro::TriArray | |
| CvtkDispatcherCommon::TypeInfo | |
| ►Cunary_function | |
| Cvtkpiston::float4tofloat3 | |
| CvtkPiston::minmax_unary_op< T > | |
| Cvtkpiston::tuple2float3 | |
| CvtkDax::detail::ValidContourInput | |
| CvtkDax::detail::ValidThresholdInput | |
| CvtkExodusIIWriter::VariableInfo | |
| ►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 | |
| CVrmlNodeType | |
| Cvtk2DHistogramItem | 2D histogram item |
| Cvtkpiston::vtk_polydata | |
| 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 | |
| CvtkAMRFlashReaderInternal | |
| CvtkArrayCoordinates | Stores coordinate into an N-way array |
| CvtkArrayExtents | Stores the number of dimensions and valid coordinate ranges along each dimension for vtkArray |
| CvtkArrayExtentsList | Stores a collection of vtkArrayExtents objects |
| CvtkArrayInterpolate | |
| CvtkArrayIteratorIncludes | Centralize array iterator type includes required when using the vtkArrayIteratorTemplateMacro |
| 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 |
| CvtkAtomic< T * > | |
| CvtkAtomic< void * > | |
| 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 |
| CvtkBridgeExport | Manage Windows system differences |
| CvtkDispatcherCommon::vtkCaster< To, From > | |
| CvtkCellTreeLocator::vtkCellTree | |
| CvtkCellTreeLocator::vtkCellTreeNode | |
| CvtkCellType | Define types of cells |
| CvtkChart2DHistogram | Chart for 2D histograms |
| CvtkChartBoxData | |
| CvtkChartPlotData | |
| CvtkChartSelectionHelper | Helper functions for making selections in charts |
| CvtkCocoaMacOSXSDKCompatibility | Compatibility header |
| CvtkCollectionElement | |
| CvtkColor | Templated type for storage of colors |
| CvtkCommonInformationKeyManager | Manages key types in vtkCommon |
| CvtkComputeQuartiles | Extract quartiles and extremum values of all columns of a table or all fields of a dataset |
| 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 |
| 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 |
| CvtkDataArrayTemplateHelper | |
| CvtkDataArrayTemplateHelpers | Non-templated implementations for vtkDataArrayTemplate |
| CvtkDataArrayTemplateLookup< T > | |
| CvtkDataArrayTemplateLookup< Scalar > | |
| CvtkDataObjectTreeInternals | |
| CvtkDataObjectTreeItem | |
| CvtkDebugLeaksManager | Manages the vtkDebugLeaks singleton |
| CvtkDebugLeaksObserver | |
| CvtkNetCDFCFReader::vtkDependentDimensionInfo | |
| CvtkDescriptiveStatisticsGnu | A class for univariate descriptive statistics using R to calculate p-values |
| CvtkDijkstraGraphInternals | Helper class due to PIMPL excess |
| CvtkNetCDFCFReader::vtkDimensionInfo | |
| CvtkDispatcher< BaseLhs, ReturnType, CastingPolicy > | Dispatch to functor based on a pointer type |
| CvtkDistributedEdgePropertyMapType< DataArray > | |
| CvtkDistributedVertexPropertyMapType< DataArray > | |
| CvtkDoubleDispatcher< BaseLhs, BaseRhs, ReturnType, CastingPolicy > | Dispatch to functor based on two pointer types |
| ►CvtkEdgeBase | |
| CvtkEdgeType | |
| CvtkInEdgeType | |
| CvtkOutEdgeType | |
| Cboost::vtkEdgeGlobalMap | |
| 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 | |
| CvtkFilteringInformationKeyManager | Manages key types in vtkFiltering |
| CvtkFixedSizeHandleRepresentation | A marker that has the same size in pixels |
| CvtkFlashReaderInternal | |
| CvtkFloatingPointExceptions | Deal with floating-point exceptions |
| CvtkFreeTypeToolsCleanup | |
| CvtkFreeTypeUtilitiesCleanup | |
| CvtkGarbageCollectorManager | Manages the vtkGarbageCollector singleton |
| CvtkgluPickMatrix | Implement selected glu functionality |
| CvtkGPUInfoListArray | Internal class vtkGPUInfoList |
| Cboost::vtkGraphEdgeMap | |
| Cboost::vtkGraphEdgePropertyMapHelper< PMap > | |
| Cboost::vtkGraphIndexMap | |
| Cboost::vtkGraphPropertyMapMultiplier< PMap > | |
| CvtkHyperOctreeLightWeightCursor | |
| CvtkHyperTreeGrid::vtkHyperTreeGridSuperCursor | |
| CvtkHyperTreeGrid::vtkHyperTreeIterator | |
| CvtkHyperTreeGrid::vtkHyperTreeSimpleCursor | |
| CvtkImage2DIslandPixel | |
| CvtkImageBSplineInternals | BSpline code from P. Thevenaz |
| CvtkImageComplex | |
| CvtkImageConnectorSeed | |
| ►CvtkImageIterator< DType > | Simple image iterator |
| CvtkImageProgressIterator< DType > | Simple image iterator with progress |
| CvtkImageStencilIterator< DType > | Image region iterator |
| CvtkImageStencilRaster | |
| CvtkIndent | Simple class to control print indentation |
| CvtkInformationInternals | Internal structure for vtkInformation |
| CvtkInstantiatorInitialize | |
| ►CvtkInterpolationInfo | |
| CvtkInterpolationWeights | |
| CvtkInterpolationMath | |
| CvtkInterpolatorInternals | Internals for vtkImageInterpolator |
| CvtkIOStream | Include C++ iostreams as used by VTK |
| CvtkIOStreamFwd | Forward-declare C++ iostreams as used by VTK |
| CvtkJavaVoidFuncArg | |
| CvtkLargeInteger | Class for arbitrarily large ints |
| CvtkLegacyReaderVersion | Version number for legacy readers/writers |
| CvtkLODProp3DEntry | |
| CvtkMapMaskTextureId | |
| CvtkMarchingCubesTriangleCases | |
| CvtkMarchingSquaresLineCases | |
| CvtkMathTextUtilitiesCleanup | |
| CvtkMathUtilities | Templated utility math functions intended for internal use in tests etc |
| CvtkMPIPixelTT< T > | |
| CvtkMPIPixelView | |
| CvtkMultiBlockPLOT3DReaderInternals | |
| CvtkMultiProcessStream | Stream used to pass data across processes using vtkMultiProcessController |
| CvtkMySQLDatabasePrivate | |
| CvtkNew< T > | Allocate and hold a VTK object |
| CvtkNew< vtkAbstractInteractionDevice > | |
| CvtkNew< vtkAbstractRenderDevice > | |
| CvtkNew< vtkBlueObeliskData > | |
| CvtkNew< vtkBrush > | |
| CvtkNew< vtkCallbackCommand > | |
| CvtkNew< vtkCategoryLegend > | |
| CvtkNew< vtkColorLegend > | |
| CvtkNew< vtkContext2D > | |
| CvtkNew< vtkContext3D > | |
| CvtkNew< vtkDataSetCollection > | |
| CvtkNew< vtkFloatArray > | |
| CvtkNew< vtkGenericCell > | |
| CvtkNew< vtkGlyph3DMapper > | |
| CvtkNew< vtkGraphLayout > | |
| CvtkNew< vtkIdList > | |
| CvtkNew< vtkImageData > | |
| CvtkNew< vtkIncrementalForceLayout > | |
| CvtkNew< vtkLookupTable > | |
| CvtkNew< vtkMultiBlockDataSet > | |
| CvtkNew< vtkOpenGLSphereMapper > | |
| CvtkNew< vtkOpenGLStickMapper > | |
| CvtkNew< vtkPen > | |
| CvtkNew< vtkPeriodicTable > | |
| CvtkNew< vtkPlaneCollection > | |
| CvtkNew< vtkPlotLine > | |
| CvtkNew< vtkPointData > | |
| CvtkNew< vtkPoints > | |
| CvtkNew< vtkPoints2D > | |
| CvtkNew< vtkPolyData > | |
| CvtkNew< vtkPolyDataMapper > | |
| CvtkNew< vtkPolyDataMapper2D > | |
| CvtkNew< vtkPruneTreeFilter > | |
| CvtkNew< vtkStringArray > | |
| CvtkNew< vtkTextProperty > | |
| CvtkNew< vtkTexture > | |
| CvtkNew< vtkTooltipItem > | |
| CvtkNew< vtkTransform > | |
| CvtkNew< vtkTrivialProducer > | |
| CvtkNew< vtkUnsignedCharArray > | |
| CvtkNew< vtkUnsignedShortArray > | |
| CvtkNew< vtkVariantArray > | |
| CvtkOBBNode | |
| ►CvtkObjectBase | Abstract base class for most VTK objects |
| ►CvtkCommand | Superclass for callback/observer methods |
| CvtkCallbackCommand | Supports function callbacks |
| CvtkEventForwarderCommand | Simple event forwarder command |
| CvtkJavaCommand | |
| CvtkOldStyleCallbackCommand | Supports legacy function callbacks for VTK |
| CvtkPythonCommand | |
| CvtkTclCommand | |
| CvtkTest::ErrorObserver | |
| ►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. Hence it can be used to provide meta-data of type vtkDataObject or any subclass |
| 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. A good example of this is UPDATE_NUMBER_OF_PIECES where downstream can request that upstream provides data partitioned into a certain number of pieces. There are several components that make this work. First, the key will copy itself upstream during REQUEST_UPDATE_EXTENT. Second, after a successfull execution, it will stor its value into a data object's information using a specific key defined by its data member DataKey. Third, before execution, it will check if the requested value matched the value in the data object's information. If not, it will ask the pipeline to execute |
| 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 |
| ►CvtkAbstractArray | Abstract superclass for all arrays |
| ►CvtkDataArray | Abstract superclass for arrays of numeric data |
| Cvtk__Int64Array | Dynamic, self-adjusting array of __int64 |
| CvtkBitArray | Dynamic, self-adjusting array of bits |
| ►CvtkCharArray | Dynamic, self-adjusting array of char |
| CvtkTypeInt8Array | Dynamic, self-adjusting array of vtkTypeInt8 |
| ►CvtkDoubleArray | Dynamic, self-adjusting array of double |
| CvtkTypeFloat64Array | Dynamic, self-adjusting array of vtkTypeFloat64 |
| ►CvtkFloatArray | Dynamic, self-adjusting array of float |
| CvtkTypeFloat32Array | Dynamic, self-adjusting array of vtkTypeFloat32 |
| CvtkIdTypeArray | Dynamic, self-adjusting array of vtkIdType |
| ►CvtkIntArray | Dynamic, self-adjusting array of int |
| CvtkTypeInt32Array | Dynamic, self-adjusting array of vtkTypeInt32 |
| CvtkLongArray | Dynamic, self-adjusting array of long |
| ►CvtkLongLongArray | Dynamic, self-adjusting array of long long |
| CvtkTypeInt64Array | Dynamic, self-adjusting array of vtkTypeInt64 |
| ►CvtkShortArray | Dynamic, self-adjusting array of short |
| CvtkTypeInt16Array | Dynamic, self-adjusting array of vtkTypeInt16 |
| CvtkSignedCharArray | Dynamic, self-adjusting array of signed char |
| ►CvtkTypeTemplate< vtkTypedDataArray< Scalar >, vtkDataArray > | |
| ►CvtkTypedDataArray< Scalar > | Extend vtkDataArray with abstract type-specific API |
| ►CvtkTypeTemplate< vtkDataArrayTemplate< Scalar >, vtkTypedDataArray< Scalar > > | |
| CvtkDataArrayTemplate< Scalar > | |
| ►CvtkTypeTemplate< vtkMappedDataArray< Scalar >, vtkTypedDataArray< Scalar > > | |
| ►CvtkMappedDataArray< Scalar > | Map non-contiguous data structures into the vtkDataArray API |
| ►CvtkTypeTemplate< vtkCPExodusIINodalCoordinatesTemplate< Scalar >, vtkMappedDataArray< Scalar > > | |
| CvtkCPExodusIINodalCoordinatesTemplate< Scalar > | Map native Exodus II coordinate arrays into the vtkDataArray interface |
| ►CvtkTypeTemplate< vtkCPExodusIIResultsArrayTemplate< Scalar >, vtkMappedDataArray< Scalar > > | |
| CvtkCPExodusIIResultsArrayTemplate< Scalar > | Map native Exodus II results arrays into the vtkDataArray interface |
| ►CvtkTypeTemplate< vtkPeriodicDataArray< Scalar >, vtkMappedDataArray< Scalar > > | |
| ►CvtkPeriodicDataArray< Scalar > | Map native an Array into an angulat periodic array |
| CvtkAngularPeriodicDataArray< Scalar > | Map native an Array into an angulat periodic array |
| ►CvtkTypeTemplate< vtkTypedDataArray< T >, vtkDataArray > | |
| ►CvtkTypedDataArray< T > | |
| ►CvtkTypeTemplate< vtkDataArrayTemplate< T >, vtkTypedDataArray< T > > | |
| CvtkDataArrayTemplate< T > | Implementation template for vtkDataArray |
| CvtkUnsigned__Int64Array | Dynamic, self-adjusting array of unsigned __int64 |
| ►CvtkUnsignedCharArray | Dynamic, self-adjusting array of unsigned char |
| CvtkTypeUInt8Array | Dynamic, self-adjusting array of vtkTypeUInt8 |
| ►CvtkUnsignedIntArray | Dynamic, self-adjusting array of unsigned int |
| CvtkTypeUInt32Array | Dynamic, self-adjusting array of vtkTypeUInt32 |
| CvtkUnsignedLongArray | Dynamic, self-adjusting array of unsigned long |
| ►CvtkUnsignedLongLongArray | Dynamic, self-adjusting array of unsigned long long |
| CvtkTypeUInt64Array | Dynamic, self-adjusting array of vtkTypeUInt64 |
| ►CvtkUnsignedShortArray | Dynamic, self-adjusting array of unsigned short |
| CvtkTypeUInt16Array | Dynamic, self-adjusting array of vtkTypeUInt16 |
| CvtkStringArray | VtkAbstractArray subclass for strings |
| CvtkUnicodeStringArray | Subclass of vtkAbstractArray that holds vtkUnicodeStrings |
| CvtkVariantArray | An array holding vtkVariants |
| ►CvtkAbstractContextBufferId | 2D array of ids, used for picking |
| CvtkOpenGLContextBufferId | 2D array of ids stored in VRAM |
| 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 |
| 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 internall 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 |
| 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 |
| ►CvtkAbstractGridConnectivity | |
| CvtkStructuredAMRGridConnectivity | |
| ►CvtkStructuredGridConnectivity | |
| CvtkPStructuredGridConnectivity | |
| ►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 | |
| CvtkXInteractionDevice | |
| ►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 |
| CvtkWorldPointPicker | Find world x,y,z corresponding to display x,y,z |
| ►CvtkAbstractRenderDevice | |
| CvtkXOpenGLRenderDevice | |
| ►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 a unstructured grid volume mapper |
| ►CvtkHAVSVolumeMapper | Hardware-Assisted Visibility Sorting unstructured grid mapper |
| CvtkOpenGLHAVSVolumeMapper | Hardware-Assisted Visibility Sorting unstructured grid mapper, OpenGL implementation |
| ►CvtkProjectedAAHexahedraMapper | Volume mapper for axis-aligned hexahedra |
| CvtkOpenGLProjectedAAHexahedraMapper | OpenGL implementation of a volume mapper for axis-aligned hexahedra |
| ►CvtkProjectedTetrahedraMapper | Unstructured grid volume renderer |
| CvtkOpenGLProjectedTetrahedraMapper | OpenGL implementation of PT |
| 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 subclass that draws the image to the screen |
| CvtkOpenGLGPUVolumeRayCastMapper | OpenGL subclass that draws the image to the screen |
| CvtkSmartVolumeMapper | Adaptive volume mapper |
| CvtkSmartVolumeMapper | Adaptive volume mapper |
| CvtkVolumeRayCastMapper | A slow but accurate mapper for rendering volumes |
| ►CvtkVolumeTextureMapper | Abstract class for a volume mapper |
| ►CvtkVolumeTextureMapper2D | Abstract class for a volume mapper |
| CvtkOpenGLVolumeTextureMapper2D | Abstract class for a volume mapper |
| ►CvtkVolumeTextureMapper3D | Volume render with 3D texture mapping |
| CvtkOpenGLVolumeTextureMapper3D | Concrete implementation of 3D volume texture mapping |
| ►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 |
| 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 |
| CvtkOpenGLGlyph3DMapper | VtkOpenGLGlyph3D on the GPU |
| CvtkGraphMapper | Map vtkGraph and derived classes to graphics primitives |
| ►CvtkLabeledContourMapper | Draw labeled isolines |
| CvtkOpenGLLabeledContourMapper | |
| CvtkOpenGLLabeledContourMapper | |
| ►CvtkMoleculeMapper | Mapper that draws vtkMolecule objects |
| CvtkOpenGLMoleculeMapper | An accelerated class for rendering molecules |
| CvtkPistonMapper | Draws vtkPistonDataObjects to the screen |
| ►CvtkPolyDataMapper | Map vtkPolyData to graphics primitives |
| ►CvtkOpenGLPolyDataMapper | PolyDataMapper for the OpenGL library |
| ►CvtkGenericCompositePolyDataMapper2 | Mapper for composite dataset consisting of polygonal data |
| CvtkCompositePolyDataMapper2 | Mapper for composite dataset consisting of polygonal data |
| 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 |
| CvtkCompositeSurfaceLICMapper | Mapper for composite dataset |
| CvtkPSurfaceLICMapper | Parallel parts of the vtkSurfaceLICMapper |
| CvtkOpenGLPolyDataMapper | PolyDataMapper for the OpenGL library |
| ►CvtkPainterPolyDataMapper | PolyDataMapper using painters |
| CvtkCompositePolyDataMapper2 | Mapper for composite dataset consisting of polygonal data |
| ►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 |
| 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 |
| CvtkOpenGLPolyDataMapper2D | 2D PolyData support for OpenGL |
| CvtkTextMapper | 2D text annotation |
| ►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, indentified by index |
| CvtkMatricizeArray | Convert an array of arbitrary dimensions to a matrix |
| CvtkNormalizeMatrixVectors | Given a sparse input matrix, produces a sparse output matrix with each vector normalized to unit length with respect to a p-norm (default p=2) |
| CvtkTableToArray | Converts a vtkTable to a matrix |
| CvtkTableToSparseArray | Converts a vtkTable into a sparse array |
| CvtkTransposeMatrix | Computes the transpose of an input matrix |
| ►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 | |
| 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 |
| ►CvtkExtractSelectionBase | Abstract base class for all extract selection filters |
| CvtkExtractSelectedBlock | |
| 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 |
| CvtkExtractSelection | Extract a subset from a vtkDataSet |
| CvtkProbeSelectedLocations | Similar to vtkExtractSelectedLocations except that it interpolates the point attributes at the probe locations |
| CvtkGenerateIndexArray | |
| CvtkImageDataToUniformGrid | Convert vtkImageData to vtkUniformGrid |
| CvtkMatlabEngineFilter | |
| ►CvtkNetCDFReader | |
| CvtkNetCDFCFReader | |
| CvtkPassArrays | Passes a subset of arrays to the output |
| CvtkProgrammableDataObjectSource | Generate source data object via a user-specified function |
| CvtkRCalculatorFilter | |
| 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) |
| CvtkXdmf3Writer | Write eXtensible Data Model and Format files |
| CvtkXdmfWriter | Write eXtensible Data Model and Format files |
| ►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 |
| CvtkXdmf3Reader | Reads eXtensible Data Model and Format files |
| CvtkXdmfReader | Reads eXtensible Data Model and Format files |
| ►CvtkDataSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| CvtkArrayCalculator | Perform mathematical operations on data in field data arrays |
| CvtkAttributeDataToFieldDataFilter | Map attribute data to field data |
| 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 |
| CvtkDataObjectToDataSetFilter | Map field data to concrete dataset |
| CvtkDataSetGradient | Computes scalar field gradient |
| CvtkDataSetGradientPrecompute | |
| ►CvtkDicer | Abstract superclass to divide dataset into pieces |
| CvtkOBBDicer | Divide dataset into spatially aggregated pieces |
| CvtkElevationFilter | Generate scalars 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 |
| CvtkHyperOctreeDepth | Assign tree depth attribute to each cell |
| CvtkHyperOctreeLimiter | Limit the tree's depth, averaging data from lower level branches into the new leaves at the cut points |
| 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. and other dataset attributes |
| CvtkMaskFields | Allow control of which fields get passed to the output |
| CvtkMatrixMathFilter | Calculate functions of quality of the elements of a mesh |
| CvtkMergeDataObjectFilter | Merge dataset and data object field to create dataset with attribute data |
| CvtkMergeFields | Merge multiple fields into one |
| CvtkMergeFilter | Extract separate components of data from different datasets |
| CvtkMeshQuality | Calculate functions of quality of the elements |
| 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 |
| CvtkPointDataToCellData | Map point data to cell data |
| ►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 |
| CvtkProgrammableSource | Generate source dataset via a user-specified function |
| CvtkProjectedTexture | Assign texture coordinates for a projected texture |
| CvtkQuadraturePointInterpolator | |
| CvtkQuadratureSchemeDictionaryGenerator | |
| CvtkRearrangeFields | Move/copy fields between field data, point data and cell data |
| CvtkSelectEnclosedPoints | Mark points as to whether they are inside a closed surface |
| CvtkSimpleElevationFilter | Generate scalars along a specified direction |
| CvtkSplitField | Split a field into single component fields |
| CvtkTextureMapToCylinder | Generate texture coordinates by mapping points to cylinder |
| CvtkTextureMapToPlane | Generate texture coordinates by mapping points to plane |
| CvtkTextureMapToSphere | Generate texture coordinates by mapping points to sphere |
| 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). Note: if you want to use simplification filters, do so on the input Reeb graph first |
| 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 |
| CvtkPBGLBreadthFirstSearch | Breadth-first search on a distributed vtkGraph |
| CvtkPBGLCollapseGraph | Collapse multiple vertices into a single vertex |
| CvtkPBGLCollapseParallelEdges | Collapse multiple vertices into a single vertex |
| CvtkPBGLCollectGraph | Collects all of the pieces of a distributed vtkGraph into a single, non-distributed vtkGraph |
| CvtkPBGLConnectedComponents | Compute connected components for a distributed vtkGraph. For directed graphs, this computes the connected components; for undirected graphs, this computes the strongly-connected components |
| CvtkPBGLGraphSQLReader | Read a vtkGraph from a database |
| CvtkPBGLMinimumSpanningTree | Minimum spanning tree of a distributed vtkGraph |
| CvtkPBGLRandomGraphSource | Generates a distributed graph with random edges |
| CvtkPBGLRMATGraphSource | Distributed graph with random edges built accorting to the recursive matrix (R-MAT) model |
| CvtkPBGLShortestPaths | Compute the shortest paths from the origin vertex to all other vertices in a distributed vtkGraph |
| CvtkPBGLVertexColoring | Compute a vertex coloring for a distributed, undirected vtkGraph, where each vertex has a color distinct from the colors of its adjacent vertices |
| 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 |
| ►CvtkHyperOctreeAlgorithm | Superclass for algorithms that produce only octree as output |
| CvtkHyperOctreeFractalSource | Create an octree from a fractal. hyperoctree |
| CvtkHyperOctreeSampleFunction | Sample an implicit function over an hyperoctree |
| ►CvtkHyperTreeGridAlgorithm | Superclass for algorithms that produce a hyper tree grid as output |
| CvtkHyperTreeGridSource | Create a synthetic grid of hypertrees |
| ►CvtkImageAlgorithm | Generic algorithm superclass for image algs |
| 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 |
| CvtkDEMReader | Read a digital elevation model (DEM) file |
| ►CvtkExtractVOI | 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 |
| CvtkMPEG2Writer | Writes MPEG2 Movie files |
| CvtkOggTheoraWriter | Uses the ogg and theora libraries to write video files |
| CvtkHyperOctreeToUniformGridFilter | Flat the octree into a uniform grid |
| 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 |
| CvtkImageDataLIC2D | |
| CvtkImageDataLIC2D | |
| ►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 | |
| ►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 |
| 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 |
| CvtkPointLoad | Compute stress tensors given point load on semi-infinite domain |
| CvtkPResampleFilter | Probe dataset in parallel using a vtkImageData |
| CvtkQImageToImageSource | Create image data from a QImage |
| CvtkRTAnalyticSource | Create an image for regression testing |
| CvtkSampleFunction | Sample an implicit function over a structured point set |
| CvtkShepardMethod | Sample unstructured points onto structured points using the method of Shepard |
| ►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 |
| 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 |
| 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 the input image through a lookup table and window / level it |
| 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. Right becomes left .. |
| 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 |
| 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) |
| CvtkVolumeRayCastSpaceLeapingImageFilter | Builds the space leaping data structure |
| CvtkTriangularTexture | Generate 2D triangular texture map |
| ►CvtkVideoSource | Superclass of video input devices for VTK |
| 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 |
| 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 |
| CvtkSimpleBondPerceiver | Create a simple guess of a molecule's topology |
| ►CvtkMultiBlockDataSetAlgorithm | Superclass for algorithms that produce only vtkMultiBlockDataSet as output |
| ►CvtkAMRBaseParticlesReader | |
| CvtkAMREnzoParticlesReader | |
| CvtkAMRFlashParticlesReader | |
| CvtkAMRCutPlane | |
| CvtkAMRResampleFilter | |
| CvtkAMRToMultiBlockFilter | |
| CvtkBlockIdScalars | Generates scalars from blocks |
| 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 | |
| ►CvtkPDataSetGhostGenerator | |
| CvtkPStructuredGridGhostDataGenerator | |
| CvtkPUniformGridGhostDataGenerator | |
| CvtkStructuredGridGhostDataGenerator | |
| CvtkUniformGridGhostDataGenerator | |
| ►CvtkExodusIIReader | Read exodus 2 files .ex2 |
| CvtkPExodusIIReader | Read Exodus II files (.exii) |
| ►CvtkExtractArraysOverTime | Extracts a selection over time |
| CvtkPExtractArraysOverTime | Extract point or cell data over time (parallel) |
| CvtkExtractBlock | Extracts blocks from a multiblock dataset |
| CvtkExtractCTHPart | Generates surface of a CTH volume fraction |
| ►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 | Extact levels between min and max |
| 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 compund 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 |
| CvtkMultiBlockDataGroupFilter | Collects multiple inputs into one multi-group dataset |
| CvtkMultiBlockMergeFilter | Merges multiblock inputs into a single multiblock output |
| ►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 |
| CvtkMultiThreshold | Threshold cells within multiple intervals |
| ►CvtkOpenFOAMReader | Reads a dataset in OpenFOAM format |
| CvtkPOpenFOAMReader | Reads a decomposed dataset in OpenFOAM format |
| CvtkPCAAnalysisFilter | Performs principal component analysis of a set of aligned pointsets |
| ►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 | |
| ►CvtkSLACReader | |
| CvtkPSLACReader | |
| CvtkSpatialRepresentationFilter | Generate polygonal model of spatial search object (i.e., a vtkLocator) |
| CvtkStructuredGridPartitioner | |
| CvtkTecplotReader | A concrete class to read an ASCII Tecplot file |
| ►CvtkThreadedSynchronizedTemplates3D | Generate isosurface from structured points |
| CvtkThreadedSynchronizedTemplatesCutter3D | Generate cut surface from structured points |
| CvtkUniformGridPartitioner | |
| ►CvtkYoungsMaterialInterface | Reconstructs material interfaces |
| CvtkPYoungsMaterialInterface | Parallel reconstruction of material interfaces |
| ►CvtkMultiTimeStepAlgorithm | Superclass for algorithms that would like to make multiple time requests |
| 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 |
| CvtkApplyColors | Apply colors to a data set |
| CvtkApplyIcons | Apply icons to a data set |
| 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 |
| CvtkConvertSelectionDomain | Convert a selection from one domain to another |
| ►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. This plot optionally can draw a histogram-based plot summary |
| ►CvtkRenderedGraphRepresentation | |
| CvtkRenderedHierarchyRepresentation | |
| CvtkRenderedSurfaceRepresentation | Displays a geometric dataset as a surface |
| CvtkRenderedTreeAreaRepresentation | |
| CvtkGeoAssignCoordinates | Given latitude and longitude arrays, take the values in those arrays and convert them to x,y,z world coordinates |
| CvtkLabelSizeCalculator | |
| 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 |
| CvtkRemoveHiddenData | Removes the rows/edges/vertices of input data flagged by ann |
| 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 | |
| ►CvtkPistonAlgorithm | Superclass for algorithms that produce only PistonDataObjects |
| CvtkDataSetToPiston | Converts a DataSet to a PistonDataObject |
| CvtkPistonContour | A filter that contours on the GPU |
| CvtkPistonSlice | A filter that slices on the GPU |
| CvtkPistonSort | NVidia thrust filter example |
| CvtkPistonThreshold | A filter that contours on the GPU |
| CvtkPistonToDataSet | Converts a PistonDataObject to a DataSet |
| ►CvtkPointSetAlgorithm | Superclass for algorithms that produce output of the same type as input |
| CvtkCenterOfMass | Find the center of mass of a set of points |
| CvtkDeformPointSet | Use a control polyhedron to deform an input vtkPointSet |
| CvtkExtractDataOverTime | Extract point data from a time sequence for a specified point id |
| ►CvtkProjectSphereFilter | A filter to 'unroll' a sphere. The unroll longitude is -180 |
| CvtkPProjectSphereFilter | A filter to 'unroll' a sphere. The unroll longitude is -180 |
| 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 |
| CvtkWarpTo | Deform geometry by warping towards a point |
| ►CvtkWarpVector | 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 |
| CvtkAppendPoints | Appends points of one or more vtkPolyData data sets |
| CvtkAppendPolyData | Appends one or more polygonal datasets together |
| ►CvtkApproximatingSubdivisionFilter | Generate a subdivision surface using an Approximating Scheme |
| CvtkLoopSubdivisionFilter | Generate a subdivision surface using the Loop Scheme |
| CvtkArcPlotter | Plot data along an arbitrary polyline |
| CvtkArcSource | Create an arc between two end points |
| 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 | |
| ►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 |
| ►CvtkContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkDaxContour | |
| ►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. This will probably be merged with vtkContourGrid in the future |
| CvtkSMPContourGridManyPieces | Subclass of vtkContourGrid that works in parallel vtkSMPContourGridManyPieces performs the same functionaliy as vtkContourGrid but does it using multiple threads. This filter generates a multi-block of vtkPolyData. It will generate a relatively large number of pieces - the number is dependent on the input size and number of threads available. See vtkSMPContourGrid is you are interested in a filter that merges the piece. This will probably be merged with vtkContourGrid in the future |
| CvtkContourTriangulator | Fill all 2D contours to create polygons |
| CvtkConvexHull2D | Produce filled convex hulls around a set of points |
| 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 |
| 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 |
| CvtkDensifyPolyData | Densify the input by adding points at the centroid |
| CvtkDepthSortPolyData | Sort poly data along camera view direction |
| CvtkDiskSource | Create a disk with hole in center |
| CvtkDistancePolyDataFilter | |
| CvtkDistanceToCamera | Calculates distance from points to the camera |
| 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 |
| CvtkExtractEdges | Extract cell edges from any type of data |
| 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 |
| 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 |
| CvtkFillHolesFilter | Identify and fill holes in meshes |
| 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 |
| 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 |
| CvtkHull | Produce an n-sided convex hull |
| CvtkHyperOctreeContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkHyperOctreeCutter | Cut vtkHyperOctree with user-specified implicit function |
| CvtkHyperOctreeDualGridContourFilter | Generate isosurfaces/isolines from scalar values |
| CvtkHyperOctreeSurfaceFilter | Extracts outer (polygonal) surface |
| CvtkHyperStreamline | Generate hyperstreamline in arbitrary dataset |
| CvtkHyperTreeGridAxisCut | Axis aligned hyper tree grid cut |
| CvtkHyperTreeGridGeometry | Hyper tree grid outer surface |
| 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 |
| CvtkImageToPolyDataFilter | Generate linear primitives (vtkPolyData) from an image |
| ►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 |
| CvtkIntersectionPolyDataFilter | |
| CvtkLabelPlacer | Place a prioritized hierarchy of labels in screen space |
| ►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 |
| 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 |
| 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 |
| 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 |
| CvtkPlaneSource | Create an array of quadrilaterals located in a plane |
| CvtkPlatonicSolidSource | Produce polygonal Platonic solids |
| CvtkPointSource | Create a random cloud of points |
| CvtkPolyDataConnectivityFilter | Extract polygonal data based on geometric connectivity |
| ►CvtkPolyDataNormals | 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 |
| CvtkQuadraturePointsGenerator | |
| 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 |
| 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 |
| 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 | |
| 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 |
| CvtkSplineFilter | Generate uniformly subdivided polylines from a set of input polyline using a vtkSpline |
| ►CvtkStreamer | Abstract object implements integration of massless particle through vector field |
| ►CvtkStreamLine | Generate streamline in arbitrary dataset |
| CvtkDashedStreamLine | Generate constant-time dashed streamline in arbitrary dataset |
| CvtkStreamPoints | Generate points along streamer separated by constant time increment |
| ►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 |
| 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 tensor eigenvalues and eigenvectors |
| 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 |
| CvtkTriangularTCoords | 2D texture coordinates based for triangles |
| CvtkTubeFilter | Filter that generates tubes around lines |
| CvtkUGFacetReader | Read EDS Unigraphics facet files |
| 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 |
| CvtkVoxelContoursToSurfaceFilter | Create surface from contours |
| CvtkWindowedSincPolyDataFilter | Adjust point positions using a windowed sinc function interpolation kernel |
| CvtkPythonAlgorithm | Algorithm that can be implemented in Python |
| ►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 |
| CvtkRendererSource | Take a renderer into the pipeline |
| CvtkRenderLargeImage | Use tiling to generate a large rendering |
| ►CvtkSelectionAlgorithm | Superclass for algorithms that produce only Selection as output |
| CvtkAppendSelection | Appends one or more selections together |
| CvtkBoostKruskalMinimumSpanningTree | Contructs a minimum spanning tree from a graph and the weighting array |
| CvtkCellDistanceSelector | Select neighbor cells up to a 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. It will only generate the selection values that match UPDATE_PIECE_NUMBER (i.e. piece == UPDATE_PIECE_NUMBER) |
| ►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 | |
| 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 | |
| CvtkStructuredGridLIC2D | |
| 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 | |
| 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 |
| ►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 | |
| CvtkExtractSelectedRows | Return selected rows of a table |
| CvtkExtractTemporalFieldData | Extract temporal arrays from input field data |
| 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 |
| 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 |
| CvtkRRandomTableSource | Generates vtkTables with columns of random numbers using Gnu R |
| 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 |
| CvtkContingencyStatisticsGnuR | A class for bivariate correlation contigency tables, conditional probabilities, and information entropy. The p-value are calculated using R |
| CvtkPContingencyStatistics | A class for parallel bivariate contingency statistics |
| ►CvtkCorrelativeStatistics | A class for bivariate linear correlation |
| CvtkCorrelativeStatisticsGnuR | A class for bivariate linear correlation using R to calculate the p-values |
| CvtkPCorrelativeStatistics | A class for parallel bivariate correlative statistics |
| ►CvtkDescriptiveStatistics | A class for univariate descriptive statistics |
| CvtkDescriptiveStatisticsGnuR | |
| 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. f is computed using a smooth kernel method |
| ►CvtkKMeansStatistics | A class for KMeans clustering |
| CvtkPKMeansStatistics | |
| ►CvtkMultiCorrelativeStatistics | A class for multivariate linear correlation |
| ►CvtkPCAStatistics | A class for multivariate principal component analysis |
| CvtkPCAStatisticsGnuR | A class for multivariate principal component analysis using R to calculate p-values |
| 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 |
| 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 |
| CvtkTemporalSnapToTimeStep | 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 | Contructs a BFS tree from a graph |
| CvtkBoostPrimMinimumSpanningTree | Contructs 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 |
| 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. This reader is developed for a simple graph file format based loosely on the "GML" notation. This implementation is based heavily on the vtkTulipReader class that forms part of the Titan toolkit |
| ►CvtkUniformGridAMRAlgorithm | |
| ►CvtkNonOverlappingAMRAlgorithm | |
| CvtkNonOverlappingAMRLevelIdScalars | Generate scalars from levels |
| ►CvtkOverlappingAMRAlgorithm | |
| ►CvtkAMRBaseReader | |
| CvtkAMREnzoReader | |
| CvtkAMRFlashReader | |
| CvtkAMRGaussianPulseSource | |
| CvtkAMRSliceFilter | |
| CvtkImageToAMR | Filter to convert any vtkImageData to a vtkOverlappingAMR |
| ►CvtkOverlappingAMRLevelIdScalars | Generate scalars from levels |
| ►CvtkLevelIdScalars | |
| 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 |
| ►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 |
| CvtkClipHyperOctree | Clip an hyperoctree with user-specified implicit function or input scalar data |
| CvtkClipVolume | Clip volume data with user-specified implicit function or input scalar data |
| CvtkConnectivityFilter | Extract data based on geometric connectivity |
| 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 |
| CvtkHyperTreeGridToUnstructuredGrid | Convert hyper tree grid to unstructured grid |
| CvtkMFIXReader | Reads a dataset in MFIX file format |
| CvtkMPASReader | Read an MPAS netCDF file |
| CvtkNetCDFCAMReader | Read unstructured NetCDF CAM files |
| CvtkProStarReader | Reads geometry in proSTAR (STARCD) file format |
| CvtkPUnstructuredGridGhostDataGenerator | |
| 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 |
| CvtkDaxThreshold | |
| CvtkTimeSourceExample | |
| CvtkTransmitUnstructuredGridPiece | |
| ►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 |
| 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 |
| CvtkPLYWriter | Write Stanford PLY file format |
| CvtkSTLWriter | Write stereo lithography files |
| ►CvtkTableToDatabaseWriter | |
| 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 |
| ►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 |
| CvtkXMLHyperOctreeReader | Read VTK XML HyperOctree 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 |
| ►CvtkXMLPDataReader | Superclass for PVTK XML file readers |
| ►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 |
| ►CvtkXMLWriter | Superclass for VTK's XML file writers |
| CvtkPhyloXMLTreeWriter | Write vtkTree data to PhyloXML format |
| ►CvtkXMLCompositeDataWriter | Writer for multi-group datasets |
| ►CvtkXMLMultiBlockDataWriter | Writer for vtkMultiBlockDataSet |
| CvtkXMLPMultiBlockDataWriter | Parallel writer for vtkHierarchicalBoxDataSet |
| ►CvtkXMLUniformGridAMRWriter | Writer for vtkUniformGridAMR |
| CvtkXMLHierarchicalBoxDataWriter | Writer for vtkHierarchicalBoxDataSet for backwards compatibility |
| ►CvtkXMLPUniformGridAMRWriter | Parallel writer for vtkUniformGridAMR and subclasses |
| CvtkXMLPHierarchicalBoxDataWriter | Parallel writer for vtkHierarchicalBoxDataSet for backwards compatibility |
| CvtkXMLDataSetWriter | Write any type of VTK XML file |
| CvtkXMLHyperOctreeWriter | Write VTK XML HyperOctree files |
| ►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 |
| ►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 |
| ►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 | |
| CvtkAMRInformation | Meta data that describes the structure of an AMR data set |
| ►CvtkAMRUtilities | |
| CvtkParallelAMRUtilities | |
| ►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 |
| ►CvtkTypeTemplate< vtkTypedArray< T >, vtkArray > | |
| ►CvtkTypedArray< T > | Provides a type-specific interface to N-way arrays |
| ►CvtkTypeTemplate< vtkDenseArray< T >, vtkTypedArray< T > > | |
| CvtkDenseArray< T > | Contiguous storage for N-way arrays |
| ►CvtkTypeTemplate< vtkSparseArray< T >, vtkTypedArray< T > > | |
| CvtkSparseArray< T > | Sparse, independent coordinate storage for N-way arrays |
| ►CvtkArrayIterator | Abstract superclass to iterate over elements in an vtkAbstractArray |
| CvtkBitArrayIterator | Iterator for vtkBitArray. This iterator iterates over a vtkBitArray. It uses the double interface to get/set bit values |
| ►CvtkTypeTemplate< vtkArrayIteratorTemplate< T >, vtkArrayIterator > | |
| CvtkArrayIteratorTemplate< T > | Implementation template for a array iterator |
| CvtkAssemblyNode | Represent a node in an assembly |
| CvtkAxisExtended | Octree-based spatial search object to quickly locate cells |
| CvtkBackgroundColorMonitor | |
| 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 |
| CvtkByteSwap | Perform machine dependent byte swapping |
| ►CvtkCamera | Virtual camera for 3D rendering |
| ►CvtkOpenGLCamera | OpenGL camera |
| CvtkExternalOpenGLCamera | OpenGL camera |
| CvtkOpenGLCamera | OpenGL 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 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 |
| 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 |
| CvtkPointSetCellIterator | Implementation of vtkCellIterator using vtkPointSet API |
| ►CvtkTypeTemplate< vtkMappedUnstructuredGridCellIterator< Implementation >, vtkCellIterator > | |
| CvtkMappedUnstructuredGridCellIterator< Implementation > | Default cell iterator for vtkMappedUnstructuredGrid |
| CvtkUnstructuredGridCellIterator | Implementation of vtkCellIterator specialized for vtkUnstructuredGrid |
| CvtkCellLinks | Object represents upward pointers from points to list of cells using each point |
| 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 unsorted lists of objects |
| CvtkAssemblyPath | List of nodes that form an assembly path |
| CvtkAssemblyPaths | List of lists of props representing an assembly hierarchy |
| CvtkCullerCollection | List of Cullers |
| CvtkDataArrayCollection | Maintain an unordered list of dataarray objects |
| CvtkDataObjectCollection | Maintain an unordered list of data objects |
| CvtkDataSetCollection | Maintain an unordered list of dataset objects |
| CvtkIdListCollection | Maintain an unordered list of dataarray objects |
| CvtkImageReader2Collection | Maintain a list of image readers |
| CvtkImplicitFunctionCollection | Maintain a list of implicit functions |
| CvtkLightCollection | List of lights |
| CvtkMapperCollection | 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 | List of Props |
| CvtkActor2DCollection | List of 2D actors |
| CvtkActorCollection | List of actors |
| CvtkImageSliceCollection | Sorted list of image slice objects |
| CvtkProp3DCollection | List of 3D props |
| CvtkVolumeCollection | List of volumes |
| CvtkRendererCollection | List of renderers |
| CvtkRenderPassCollection | List of RenderPasses |
| CvtkRenderPassCollection | List of RenderPasses |
| CvtkRenderWindowCollection | List of RenderWindows |
| CvtkShader2Collection | List of Shader2 objects |
| CvtkSocketCollection | Collection for sockets |
| CvtkStructuredPointsCollection | Maintain a list of structured points data objects |
| CvtkTextPropertyCollection | List of vtkTextProperty objects |
| CvtkTransformCollection | Maintain a list of transforms |
| ►CvtkCollectionIterator | Iterator through a vtkCollection |
| CvtkDataArrayCollectionIterator | Iterator through a vtkDataArrayCollection |
| CvtkColorMaterialHelper | Helper to assist in simulating the ColorMaterial behaviour of the default OpenGL pipeline |
| 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 |
| ►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 | |
| ►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+ |
| CvtkGL2PSContextDevice2D | Class for drawing 2D primitives using GL2PS |
| CvtkOpenGL2ContextDevice2D | Class for drawing 2D primitives using OpenGL 2 |
| CvtkOpenGLContextDevice2D | Class for drawing 2D primitives using OpenGL 1.1+ |
| ►CvtkContextDevice3D | Abstract class for drawing 3D primitives |
| CvtkOpenGLContextDevice3D | OpenGL class 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 |
| 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 |
| CvtkMultiPieceDataSet | Composite dataset to encapsulates pieces of dataset |
| ►CvtkUniformGridAMR | |
| CvtkNonOverlappingAMR | |
| ►CvtkOverlappingAMR | Hierarchical dataset of vtkUniformGrids |
| CvtkHierarchicalBoxDataSet | Backwards compatibility class |
| ►CvtkDataSet | Abstract class to specify dataset behavior |
| CvtkHyperOctree | A dataset structured as a tree where each node has exactly 2^n children |
| 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. May be mapped onto a non-standard memory layout |
| ►CvtkTypeTemplate< vtkMappedUnstructuredGrid< Implementation, CellIterator >, vtkUnstructuredGridBase > | |
| 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 |
| CvtkBridgeDataSet | Implementation of vtkGenericDataSet |
| ►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 |
| CvtkPistonDataObject | A GPU resident data set |
| CvtkSelection | A node in a selection tree. Used to store selection results |
| 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 |
| CvtkDataTransferHelper | Helper class that aids in transferring data between CPU memory and GPU memory |
| CvtkDebugLeaks | Identify memory leaks at program termination |
| ►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 |
| CvtkPBGLDistributedGraphHelper | End namespace boost::graph::distributed |
| 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 | |
| ►CvtkCompositeDataPipeline | Executive supporting composite datasets |
| CvtkThreadedCompositeDataPipeline | Executive that works in parallel |
| CvtkImageImportExecutive | |
| 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 |
| CvtkIVExporter | Export a scene into OpenInventor 2.0 format |
| CvtkOBJExporter | Export a scene into Wavefront format |
| CvtkOOGLExporter | Export a scene into Geomview OOGL format |
| CvtkPOVExporter | Export scene into povray format |
| CvtkPVWebGLExporter | |
| CvtkRIBExporter | Export a scene into RenderMan RIB format |
| CvtkVRMLExporter | Export a scene into VRML 2.0 format |
| CvtkX3DExporter | Create an x3d file |
| CvtkExtentRCBPartitioner | |
| 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 | |
| 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 |
| CvtkFrameBufferObject | Internal class which encapsulates OpenGL frame buffer object. Not to be used directly |
| CvtkFrameBufferObject | Internal class which encapsulates OpenGL frame buffer object. Not to be used directly |
| CvtkFrameBufferObject2 | Interface to OpenGL framebuffer object |
| CvtkFrameBufferObject2 | Interface to OpenGL framebuffer object |
| ►CvtkFreeTypeTools | FreeType library support |
| CvtkFontConfigFreeTypeTools | Subclass of vtkFreeTypeTools that uses system installed fonts |
| CvtkFreeTypeUtilities | FreeType library support |
| 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 |
| CvtkTemporalInterpolatedVelocityField | A helper class for interpolating between times during particle tracing |
| CvtkGarbageCollector | Detect and break reference loops |
| CvtkGDAL | Shared data for GDAL classes |
| ►CvtkGenericAdaptorCell | Defines cell interface |
| CvtkBridgeCell | Implementation of vtkGenericAdaptorCell |
| ►CvtkGenericAttribute | Abstract class defined API for attribute data |
| CvtkBridgeAttribute | Implementation of vtkGenericAttribute |
| CvtkGenericAttributeCollection | Collection of attributes |
| ►CvtkGenericCellIterator | Iterator used to traverse cells |
| CvtkBridgeCellIterator | Implementation of vtkGenericCellIterator. It is just an example that show how to implement the Generic API. It is also used for testing and evaluating the Generic framework |
| ►CvtkBridgeCellIteratorStrategy | Interface used by vtkBridgeCellIterator vtkBridgeCellIterator has different behaviors depending on the way it is initialized. vtkBridgeCellIteratorStrategy is the interface for one of those behaviors. Concrete classes are vtkBridgeCellIteratorOnDataSet, vtkBridgeCellIteratorOnDataSetBoundaries, vtkBridgeCellIteratorOnCellBoundaries, vtkBridgeCellIteratorOnCellNeighbors, |
| CvtkBridgeCellIteratorOnCellBoundaries | Iterate over boundary cells of a cell |
| CvtkBridgeCellIteratorOnCellList | Iterate over a list of cells defined on a dataset. See InitWithCells() |
| CvtkBridgeCellIteratorOnDataSet | Iterate over cells of a dataset |
| CvtkBridgeCellIteratorOne | Iterate over one cell only of a dataset |
| ►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 |
| CvtkBridgePointIterator | Implementation of vtkGenericPointIterator |
| CvtkBridgePointIteratorOnCell | Implementation of vtkGenericPointIterator |
| CvtkBridgePointIteratorOnDataSet | Implementation of vtkGenericPointIterator |
| CvtkBridgePointIteratorOne | Iterate over one point of a dataset |
| ►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 |
| CvtkGL2PSUtilities | Helper functions for using GL2PS within VTK |
| CvtkGlobFileNames | Find files that match a wildcard pattern |
| CvtkGPUInfo | Stores GPU VRAM information |
| ►CvtkGPUInfoList | Stores the list of GPUs VRAM information |
| CvtkCoreGraphicsGPUInfoList | Get GPUs VRAM information using CoreGraphics |
| CvtkDirectXGPUInfoList | Get GPUs VRAM information using DirectX |
| CvtkDummyGPUInfoList | Do thing during Probe() |
| CvtkDummyGPUInfoList | Do thing during Probe() |
| CvtkXGPUInfoList | Get GPUs VRAM information using X server extensions |
| 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). Any entry in the constraint array will indicate the level of impedance a node has to the force calculations during the layout optimization. The array is assumed to be normalized between zero and one, with one being totally constrained, so no force will be applied to the node (i.e. no movement), and zero being full range of movement (no constraints) |
| 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 | |
| CvtkTreeLayoutStrategy | Hierarchical layout |
| CvtkTreeOrbitLayoutStrategy | Hierarchical orbital layout |
| ►CvtkHardwareSelector | Manager for OpenGL-based selection |
| ►CvtkOpenGLHardwareSelector | Implements the device specific code of vtkOpenGLHardwareSelector |
| CvtkPHardwareSelector | VtkHardwareSelector useful for parallel rendering |
| CvtkOpenGLHardwareSelector | Implements the device specific code of vtkOpenGLHardwareSelector |
| CvtkHeap | Replacement for malloc/free and new/delete |
| CvtkHierarchicalGraphPipeline | Helper class for rendering graphs superimposed on a tree |
| CvtkHyperOctreeCursor | Objects that can traverse hyperoctree nodes |
| ►CvtkHyperOctreePointsGrabber | An object used by filters to store points computed on face or edge of an hyperoctant. It is an abstract class. vtkClipHyperOctree and vtkHyperOctreeCutter use vtkHyperOctreeClipCutPointsGrabber vtkHyperOctreeContourFilter use an internal one: vtkHyperOctreeContourFilterPointsGrabber |
| CvtkHyperOctreeClipCutPointsGrabber | A concrete implementation of vtkHyperOctreePointsGrabber used by vtkClipHyperOctree and vtkHyperOctreeCutter |
| CvtkHyperTree | An object structured as a tree where each node has exactly either 2^n or 3^n children |
| CvtkHyperTreeCursor | Objects that can traverse hypertree nodes |
| 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 | |
| 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 |
| 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 |
| 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 |
| CvtkInstantiator | Create an instance of any VTK class from its name |
| ►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 |
| 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 |
| CvtkHandleWidget | General widget for moving handles |
| ►CvtkHoverWidget | Invoke a vtkTimerEvent when hovering |
| CvtkBalloonWidget | Popup text balloons above instance of vtkProp when hovering occurs |
| CvtkImplicitPlaneWidget2 | 3D widget for manipulating an infinite plane |
| CvtkLineWidget2 | 3D widget for manipulating a finite, straight line |
| 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 It observes the user events (mouse events) and propagates them to the scene. If the scene doesn't eat the event, it is propagated to the interactor style superclass |
| 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 | Interactive 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 |
| 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 |
| CvtkKdNode | This class represents a single spatial region in an 3D axis aligned binary spatial partitioning. It is assumed the region bounds some set of points. Regions are represented as nodes in a binary tree |
| ►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 |
| ►CvtkLight | Virtual light for 3D rendering |
| CvtkExternalLight | Virtual light object for tweaking existing lights in an external 3D rendering context |
| CvtkOpenGLLight | OpenGL light |
| CvtkOpenGLLight | OpenGL light |
| CvtkRIBLight | RIP Light |
| CvtkLightingHelper | Helper to assist in simulating lighting similar to default OpenGL pipeline |
| 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) |
| CvtkLineIntegralConvolution2D | 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. Joy in VisWeek, 2011 |
| CvtkModifiedBSPTree | Generate axis aligned BBox tree for raycasting and other Locator based searches |
| CvtkOBBTree | Generate oriented bounding box (OBB) tree |
| ►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 |
| ►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 |
| CvtkMatlabEngineInterface | |
| CvtkMatlabMexAdapter | This is a utility class to convert VTK array data to and from the Matlab mxArray format. It is used with the Matlab Mex and Matlab Engine interfaces |
| 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 |
| CvtkInteractionStyleObjectFactory | |
| CvtkRenderingContextOpenGLObjectFactory | |
| CvtkRenderingFreeTypeObjectFactory | |
| CvtkRenderingOpenGLObjectFactory | |
| CvtkRenderingVolumeOpenGLObjectFactory | |
| CvtkObjectIdMap | Class used to assign Id to any VTK object and be able to retreive 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 | |
| CvtkOpenGLHardwareSupport | OpenGL rendering window |
| CvtkOpenGLLightMonitor | |
| CvtkOpenGLModelViewProjectionMonitor | |
| CvtkOpenGLRenderUtilities | OpenGL rendering utility functions |
| CvtkOpenGLShaderCache | Manage Shader Programs within a context |
| CvtkOpenGLVertexArrayObject | The VertexArrayObject class uses, or emulates, vertex array objects |
| CvtkOrderedTriangulator | Helper class to generate triangulations |
| CvtkOutEdgeIterator | Iterates through all outgoing edges from a vertex |
| ►CvtkOutputStream | Wraps a binary output stream with a VTK interface |
| CvtkBase64OutputStream | Writes base64-encoded output to a stream |
| ►CvtkOutputWindow | Base class for writing debug output to a console |
| CvtkAndroidOutputWindow | Win32 Specific output window class |
| ►CvtkFileOutputWindow | File Specific output window class |
| CvtkXMLFileOutputWindow | XML File Specific output window class |
| CvtkWin32OutputWindow | Win32 Specific output window class |
| CvtkWin32ProcessOutputWindow | Win32-specific output window class |
| CvtkOverrideInformation | Factory object override information |
| ►CvtkPainter | Abstract class for drawing poly data |
| ►CvtkClipPlanesPainter | Abstract class defining interface for painter that manages clipping |
| CvtkOpenGLClipPlanesPainter | Painter that manages clipping |
| ►CvtkCompositePainter | Painter that can be inserted before any vtkDataSet painting chain to handle composite datasets |
| CvtkOpenGLCompositePainter | Composite painter for OpenGL |
| ►CvtkDefaultPainter | Sets up a default chain of painters |
| CvtkSurfaceLICDefaultPainter | VtkDefaultPainter replacement that inserts the vtkSurfaceLICPainter at the correct position in the painter chain |
| ►CvtkDisplayListPainter | Abstract superclass for painter that builds/uses display lists |
| CvtkOpenGLDisplayListPainter | Display list painter using OpenGL |
| ►CvtkPolyDataPainter | Abstract class for drawing poly data |
| CvtkChooserPainter | Painter that selects painters to render primitives |
| ►CvtkCoincidentTopologyResolutionPainter | Painter that resolves conicident topology |
| CvtkOpenGLCoincidentTopologyResolutionPainter | |
| ►CvtkLightingPainter | Abstract class defining interface for painter that can handle lightin |
| CvtkOpenGLLightingPainter | Painter that manages lighting |
| ►CvtkPrimitivePainter | Superclass for class that handle single privmitives |
| CvtkLinesPainter | Painter that paints lines |
| CvtkPointsPainter | This painter paints verts |
| CvtkPolygonsPainter | This painter paints polygons |
| CvtkTStripsPainter | Painter for triangle strips |
| ►CvtkRepresentationPainter | Painter that handles representation |
| CvtkOpenGLRepresentationPainter | Painter handling representation using OpenGL |
| ►CvtkStandardPolyDataPainter | A standard implementation of vtkPolyDataPainter |
| CvtkHardwareSelectionPolyDataPainter | Painter used to render polydata for selection passes |
| CvtkValuePainter | Painter that renders arrays encoded into pixel colors |
| ►CvtkScalarsToColorsPainter | Painter that converts scalars to colors. It enable/disables coloring state depending on the ScalarMode |
| CvtkOpenGLScalarsToColorsPainter | Implementation of vtkScalarsToColorsPainter for OpenGL |
| ►CvtkSurfaceLICPainter | Painter that performs LIC on the surface of arbitrary geometry |
| CvtkPSurfaceLICPainter | Parallel parts of the vtkSurfaceLICPainter |
| ►CvtkPainterDeviceAdapter | An adapter between a vtkPainter and a rendering device |
| CvtkOpenGLPainterDeviceAdapter | An adapter between a vtkPainter and a rendering device |
| ►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 | |
| ►CvtkParametricFunction | Abstract interface for parametric functions |
| CvtkParametricBoy | Generate Boy's 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 |
| CvtkParametricKlein | Generates a "classical" representation of a Klein bottle |
| CvtkParametricMobius | Generate a Mobius strip |
| CvtkParametricRandomHills | Generate a surface covered with randomly placed hills |
| CvtkParametricRoman | Generate Steiner's Roman Surface |
| CvtkParametricSpline | Parametric function for 1D interpolating splines |
| CvtkParametricSuperEllipsoid | Generate a superellipsoid |
| CvtkParametricSuperToroid | Generate a supertoroid |
| CvtkParametricTorus | Generate a torus |
| CvtkPen | Pen that draws the outlines of shapes drawn by vtkContext2D |
| CvtkPeriodicTable | Access to information about the elements |
| CvtkPickingManager | |
| CvtkPipelineSize | Compute the memory required by a pipeline |
| CvtkPistonScalarsColors | Color Mapping for piston results |
| CvtkPixelBufferObject | Abstracts an OpenGL pixel buffer object |
| 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 | |
| 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. Scaled or unscaled |
| 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 |
| CvtkOpenGLContextActor | VtkProp derived object |
| CvtkLegendScaleActor | Annotate the render window with scale and distance information |
| ►CvtkProp3D | 3D object for placement in a rendered scene |
| ►CvtkActor | Object (geometry & properties) in a rendered scene |
| CvtkAxisActor | Create an axis with tick marks and labels |
| CvtkCubeAxesActor | Create a plot of a bounding box edges - |
| ►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 |
| CvtkLODActor | Actor that supports multiple levels of detail |
| CvtkOpenGLActor | OpenGL actor |
| CvtkOpenGLActor | OpenGL actor |
| CvtkPolarAxesActor | Create an actor of a polar axes - |
| CvtkQuadricLODActor | Specific level-of-detail strategy using the quadric clustering decimation algorithm |
| CvtkAnnotatedCubeActor | 3D cube with face labels |
| CvtkAssembly | Create hierarchies of vtkProp3Ds (transformable props) |
| CvtkAxesActor | 3D axes representation |
| 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 |
| CvtkVolume | Volume (data & properties) 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 |
| 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 |
| ►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 |
| 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 |
| CvtkImplicitPlaneRepresentation | Class defining the representation for a vtkImplicitPlaneWidget2 |
| CvtkLineRepresentation | Class defining the representation for a vtkLineWidget2 |
| 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 |
| CvtkOpenGLProperty | OpenGL property |
| CvtkRIBProperty | RIP Property |
| CvtkProperty2D | Represent surface properties of a 2D image |
| CvtkPUnstructuredGridConnectivity | |
| CvtkQtInitialization | Initializes a Qt application |
| CvtkQtTimePointUtility | Performs common time operations |
| CvtkQuadratureSchemeDefinition | |
| CvtkQuaternionInterpolator | Interpolate a quaternion |
| CvtkRAdapter | This is a utility class to convert VTK array data and VTK tables to and from Gnu R S expression (SEXP) data structures. It is used with the R .Call interface and the embedded R interpreter |
| ►CvtkRandomSequence | Sequence of random numbers |
| ►CvtkGaussianRandomSequence | Gaussian sequence of pseudo random numbers |
| CvtkBoxMuellerRandomSequence | Gaussian sequence of pseudo random numbers implemented with the Box-Mueller transform |
| 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 |
| 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 |
| 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 |
| CvtkCameraPass | Implement the camera render pass |
| CvtkClearRGBPass | Paint in the color buffer |
| CvtkClearRGBPass | Paint in the color buffer |
| CvtkClearZPass | Clear the depth buffer with a given value |
| CvtkClearZPass | Clear the depth buffer with a given value |
| CvtkClientServerCompositePass | |
| CvtkCompositeRGBAPass | Blend RGBA buffers of processes |
| CvtkCompositeZPass | Merge depth buffers of processes |
| ►CvtkDefaultPass | Implement the basic render passes |
| ►CvtkOpaquePass | Render the opaque geometry with property key filtering |
| CvtkValuePass | Render opaque objects with the vtkValuePainter |
| CvtkOpaquePass | Render the opaque geometry with property key filtering |
| CvtkOverlayPass | Render the overlay geometry with property key filtering |
| CvtkOverlayPass | Render the overlay geometry with property key filtering |
| CvtkTranslucentPass | Render the translucent polygonal geometry with property key filtering |
| CvtkTranslucentPass | Render the translucent polygonal geometry with property key filtering |
| CvtkVolumetricPass | Render the volumetric geometry with property key filtering |
| CvtkVolumetricPass | Render the volumetric geometry with property key filtering |
| CvtkDefaultPass | Implement the basic render passes |
| CvtkDepthPeelingPass | Implement an Order Independent Transparency render pass |
| CvtkDepthPeelingPass | Implement an Order Independent Transparency render pass |
| ►CvtkImageProcessingPass | Convenient class for post-processing passes. render pass |
| CvtkGaussianBlurPass | Implement a post-processing Gaussian blur render pass |
| CvtkGaussianBlurPass | Implement a post-processing Gaussian blur render pass |
| CvtkSobelGradientMagnitudePass | Implement a post-processing edge detection with a Sobel gradient magnitude render pass |
| CvtkSobelGradientMagnitudePass | Implement a post-processing edge detection with a Sobel gradient magnitude render pass |
| CvtkImageProcessingPass | Convenient class for post-processing passes. render pass |
| CvtkLightsPass | Implement the lights render pass |
| CvtkLightsPass | Implement the lights render pass |
| CvtkRenderStepsPass | Execute render passes sequentially |
| CvtkSequencePass | Execute render passes sequentially |
| CvtkSequencePass | Execute render passes sequentially |
| CvtkShadowMapBakerPass | Implement a builder of shadow map pass |
| CvtkShadowMapPass | Implement a shadow mapping render pass |
| CvtkValuePasses | Top level pass to render scene for ValuePainter |
| CvtkRenderPass | Perform part of the rendering of a vtkRenderer |
| CvtkRenderWidget | |
| ►CvtkRenderWindowInteractor | Platform-independent render window interaction including picking and frame rate control |
| CvtkAndroidRenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| CvtkCarbonRenderWindowInteractor | Implements Carbon specific functions required by vtkRenderWindowInteractor |
| CvtkCocoaRenderWindowInteractor | Implements Cocoa 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 |
| CvtkTestingInteractor | A RenderWindowInteractor for testing |
| CvtkWin32RenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| CvtkWin32RenderWindowInteractor | Implements Win32 specific functions required by vtkRenderWindowInteractor |
| ►CvtkXRenderWindowInteractor | X event driven interface for a RenderWindow |
| CvtkXRenderWindowTclInteractor | TCL event driven interface for a RenderWindow |
| CvtkXRenderWindowTclInteractor | TCL event driven interface for a RenderWindow |
| CvtkXRenderWindowInteractor | X event driven interface for a RenderWindow |
| CvtkResliceCursor | Geometry for a reslice cursor |
| CvtkResliceImageViewerMeasurements | Manage measurements on a resliced image |
| CvtkRInterface | |
| ►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) |
| CvtkScenePicker | Picks an entire viewport at one shot |
| CvtkSelectionNode | A node in a selection tree. Used to store selection results |
| CvtkShader | Vertex or Fragment shader, combined into a ShaderProgram |
| CvtkShader2 | GLSL Shader |
| ►CvtkShaderDeviceAdapter2 | Adapter to pass generic vertex attributes to the rendering pipeline. .SECTION This class is an adapter used to pass generic vertex attributes to the rendering pipeline. Since this changes based on the shading language used, this class merely defines the API and subclasses provide implementations for Cg and GL |
| CvtkGLSLShaderDeviceAdapter2 | Adapter to pass generic vertex attributes to the rendering pipeline to be used in a vtkShaderProgram2 |
| CvtkShaderProgram | The ShaderProgram uses one or more Shader objects |
| CvtkShaderProgram2 | GLSL Program |
| CvtkSILBuilder | Helper class to build a SIL i.e. a directed graph used by reader producing composite datasets to describes the relationships among the blocks |
| 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 | Provides several methods for sorting vtk arrays |
| CvtkSortFileNames | Group and sort a set of filenames |
| ►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 | Uses Qt to render the supplied text to an image |
| CvtkFreeTypeStringToImage | Uses Qt to 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 | |
| CvtkSubGroup | Scalable collective communication for a subset of members of a parallel VTK application |
| ►CvtkSurfaceLICComposite | |
| CvtkPSurfaceLICComposite | |
| CvtkSurfaceLICComposite | |
| ►CvtkSynchronizedRenderers | Synchronizes renderers across processes |
| CvtkClientServerSynchronizedRenderers | |
| CvtkCompositedSynchronizedRenderers | |
| CvtkSynchronizedRenderWindows | Synchronizes render windows across processess |
| ►CvtkTDxDevice | API to access a 3DConnexion input device |
| CvtkTDxMacDevice | Implementation of vtkTDxDevice on Mac |
| CvtkTDxUnixDevice | Implementation of vtkTDxDevice on Unix |
| CvtkTDxWinDevice | Implementation of vtkTDxDevice on Windows |
| ►CvtkTDxInteractorStyle | Provide 3DConnexion device event-driven interface to the rendering window |
| CvtkTDxInteractorStyleCamera | Interactive manipulation of the camera with a 3DConnexion device |
| CvtkTDxInteractorStyleGeo | Interactive manipulation of the camera with a 3DConnexion device, similar to google earth |
| CvtkTDxInteractorStyleSettings | 3DConnexion device settings |
| CvtkTensor | Supporting class to enable assignment and referencing of tensors |
| ►CvtkTesting | Unified VTK regression testing framework |
| CvtkRegressionTester | |
| 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 |
| CvtkTextureObject | Abstracts an OpenGL texture object |
| CvtkTextureUnitManager | Allocate/free texture units |
| CvtkTextureUnitManager | Allocate/free texture units |
| 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 |
| 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 arbitray size |
| CvtkUniformVariables | GLSL uniform variables |
| ►CvtkUnstructuredGridVolumeRayCastFunction | Superclass for ray casting functions |
| CvtkUnstructuredGridBunykRayCastFunction | Superclass for ray casting functions |
| CvtkUnstructuredGridVolumeRayCastIterator | |
| ►CvtkUnstructuredGridVolumeRayIntegrator | Superclass for volume ray integration functions |
| CvtkUnstructuredGridHomogeneousRayIntegrator | Performs peicewise 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. Currently, this means displaying the hierarchy using a tree layout, then rendering the graph vertices as leaves of the tree with curved graph edges between leaves |
| CvtkParallelCoordinatesView | View to be used with vtkParallelCoordinatesRepresentation |
| ►CvtkTreeAreaView | Accepts a graph and a hierarchy - currently a tree - and provides a hierarchy-aware display. Currently, this means displaying the hierarchy using a tree ring layout, then rendering the graph vertices as leaves of the tree with curved graph edges between leaves |
| CvtkIcicleView | Displays a tree in a stacked "icicle" view |
| CvtkTreeMapView | Displays a tree as a tree map |
| CvtkTreeRingView | Displays a tree in concentric rings |
| ►CvtkViewport | Abstract specification for Viewports |
| ►CvtkRenderer | Abstract specification for renderers |
| ►CvtkOpenGLRenderer | OpenGL renderer |
| CvtkExternalOpenGLRenderer | OpenGL renderer |
| CvtkOpenGLRenderer | OpenGL 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 |
| ►CvtkVolumeRayCastFunction | Superclass for ray casting functions |
| CvtkVolumeRayCastCompositeFunction | Ray function for compositing |
| CvtkVolumeRayCastIsosurfaceFunction | An isosurface ray caster for volumes |
| CvtkVolumeRayCastMIPFunction | A maximum intensity projection ray caster for volumes |
| CvtkWebApplication | Defines ParaViewWeb application interface |
| CvtkWebGLDataSet | |
| CvtkWebGLExporter | |
| ►CvtkWebGLObject | |
| CvtkWebGLPolyData | |
| CvtkWebGLWidget | |
| 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 |
| CvtkCarbonRenderWindow | Carbon OpenGL rendering window |
| CvtkCocoaRenderWindow | Cocoa 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 |
| CvtkGenericOpenGLRenderWindow | Platform independent render window |
| CvtkIOSRenderWindow | IOS OpenGL rendering window |
| CvtkOSOpenGLRenderWindow | OffScreen Mesa rendering window |
| CvtkOSOpenGLRenderWindow | OffScreen Mesa rendering window |
| CvtkWin32OpenGLRenderWindow | OpenGL rendering window |
| CvtkWin32OpenGLRenderWindow | OpenGL rendering window |
| CvtkXOpenGLRenderWindow | OpenGL rendering window |
| CvtkXOpenGLRenderWindow | OpenGL rendering window |
| CvtkOpenGLRenderWindow | 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 | |
| CvtkXMLDataParser | Used by vtkXMLReader to parse VTK XML files |
| CvtkXMLFileReadTester | Utility class for vtkXMLReader and subclasses |
| CvtkXMLUtilities | XML utilities |
| CvtkOBJImportedMaterial | |
| CvtkODBCInternals | Simple class to hide ODBC structures |
| CvtkOpenGL2ContextDevice2DPrivate | Private class with storage and utility functions for the vtkOpenGLContextDevice2D |
| CvtkOpenGLBufferObjectState | |
| CvtkOpenGLClipPlaneState | |
| CvtkOpenGLComponentTransform | |
| CvtkOpenGLExtensionManager | Interface class for querying and using OpenGL extensions |
| CvtkOpenGLFixePipelineState | |
| CvtkOpenGLGL2PSHelper | Helper functionality for GL2PS exporting |
| CvtkOpenGLHelper | |
| CvtkOpenGLIndexPixelMapState | |
| CvtkOpenGLLightState | |
| CvtkOpenGLMaterialState | |
| CvtkOpenGLPixelControl | |
| CvtkOpenGLProgramState | |
| CvtkOpenGLRGBAPixelMapState | |
| CvtkOpenGLShaderState | |
| CvtkOpenGLState | Raw OpenGL State |
| CvtkOpenGLTexGenState | |
| CvtkOpenGLTextureCoordinateProcessingUnit | |
| CvtkOpenGLTextureImageState | |
| CvtkOpenGLTextureImageUnit | |
| CvtkOpenGLTextureImageUnitFixedPipelineState | |
| CvtkOpenGLVolumeGradientOpacityTable | |
| CvtkOpenGLVolumeGradientOpacityTables | |
| CvtkOpenGLVolumeOpacityTable | |
| CvtkOpenGLVolumeOpacityTables | |
| CvtkOpenGLVolumeRGBTable | |
| CvtkOpenGLVolumeRGBTables | |
| ►CvtkOStreamWrapper | Wrapper for C++ ostream. Internal VTK use only |
| CvtkOStrStreamWrapper | Wrapper for ostrstream. Internal VTK use only |
| CvtkOutputWindowCleanup | |
| ►CvtkPainterCommunicator | |
| CvtkPPainterCommunicator | |
| CvtkPBGLGraphAdapter | Adapter to the Parallel Boost Graph Library (http://www.osl.iu.edu/research/pbgl) |
| CvtkPistonDataWrangling | Miscellaneous conversion code |
| CvtkPistonMinMax | Computes scalar range on GPU for mapper |
| CvtkPistonReference | Lower level handle on GPU resident data |
| CvtkPixelExtent | |
| CvtkPixelExtentIO | |
| ►CvtkPixelTransfer | |
| CvtkPPixelTransfer | |
| CvtkPKMeansStatisitcs | A class for parallel k means clustering |
| CvtkPolygonalSurfacePointPlacerNode | |
| CvtkPolygonBuilder | |
| CvtkPostgreSQLDatabasePrivate | Internal details of a connection to a PostgreSQL database |
| CvtkPOutlineFilterInternals | Create wireframe outline (or corners) for arbitrary data set |
| CvtkPythonArgs | |
| CvtkPythonOverload | Created in June 2010 by David Gobbi, originally in vtkPythonUtil |
| CvtkPythonUtil | |
| 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 |
| CvtkShadowMapBakerPassLightCameras | |
| CvtkShadowMapBakerPassTextures | |
| 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< StorageType > | |
| CvtkSmartPointer< TemporalFractalOutputUtil > | |
| CvtkSmartPointer< vtkAbstractCellLocator > | |
| 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< vtkComputeHistogram2DOutliers > | |
| CvtkSmartPointer< vtkContext2D > | |
| CvtkSmartPointer< vtkContextDevice3D > | |
| CvtkSmartPointer< vtkContextMapper2D > | |
| CvtkSmartPointer< vtkContextScene > | |
| CvtkSmartPointer< vtkConvertSelectionDomain > | |
| CvtkSmartPointer< vtkConvexHull2D > | |
| CvtkSmartPointer< vtkCoordinate > | |
| CvtkSmartPointer< vtkDataArraySelection > | |
| CvtkSmartPointer< vtkDataObject > | |
| CvtkSmartPointer< vtkDataObjectToTable > | |
| CvtkSmartPointer< vtkDataSet > | |
| CvtkSmartPointer< vtkDendrogramItem > | |
| CvtkSmartPointer< vtkDistanceToCamera > | |
| CvtkSmartPointer< vtkDoubleArray > | |
| CvtkSmartPointer< vtkEdgeCenters > | |
| CvtkSmartPointer< vtkEdgeLayout > | |
| CvtkSmartPointer< vtkExtractSelectedGraph > | |
| CvtkSmartPointer< vtkExtractSelectedRows > | |
| CvtkSmartPointer< vtkFastSplatter > | |
| CvtkSmartPointer< vtkFloatArray > | |
| CvtkSmartPointer< vtkGenericCell > | |
| CvtkSmartPointer< vtkGeoCamera > | |
| CvtkSmartPointer< vtkGeoTreeNode > | |
| CvtkSmartPointer< vtkGlyph3D > | |
| CvtkSmartPointer< vtkGlyphSource2D > | |
| CvtkSmartPointer< vtkGraphLayout > | |
| CvtkSmartPointer< vtkGraphToGlyphs > | |
| CvtkSmartPointer< vtkGraphToPoints > | |
| CvtkSmartPointer< vtkGraphToPolyData > | |
| CvtkSmartPointer< vtkHardwareSelector > | |
| CvtkSmartPointer< vtkHeatmapItem > | |
| CvtkSmartPointer< vtkHoverWidget > | |
| CvtkSmartPointer< vtkIconGlyphFilter > | |
| CvtkSmartPointer< vtkIdTypeArray > | |
| CvtkSmartPointer< vtkImageData > | |
| CvtkSmartPointer< vtkInformation > | |
| CvtkSmartPointer< vtkIntArray > | |
| CvtkSmartPointer< vtkLabelPlacementMapper > | |
| CvtkSmartPointer< vtkLookupTable > | |
| CvtkSmartPointer< vtkMapArrayValues > | |
| CvtkSmartPointer< vtkMultiBlockDataSet > | |
| CvtkSmartPointer< vtkOBJPolyDataProcessor > | |
| CvtkSmartPointer< vtkOutlineSource > | |
| CvtkSmartPointer< vtkOverlappingAMR > | |
| CvtkSmartPointer< vtkPairwiseExtractHistogram2D > | |
| CvtkSmartPointer< vtkPen > | |
| CvtkSmartPointer< vtkPerturbCoincidentVertices > | |
| CvtkSmartPointer< vtkPiecewiseFunction > | |
| CvtkSmartPointer< vtkPixelBufferObject > | |
| 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< vtkRemoveHiddenData > | |
| CvtkSmartPointer< vtkRenderer > | |
| CvtkSmartPointer< vtkRenderWindow > | |
| CvtkSmartPointer< vtkScalarBarWidget > | |
| CvtkSmartPointer< vtkScalarsToColors > | |
| CvtkSmartPointer< vtkSelection > | |
| CvtkSmartPointer< vtkSliceAndDiceLayoutStrategy > | |
| CvtkSmartPointer< vtkSphereSource > | |
| CvtkSmartPointer< vtkSpline > | |
| CvtkSmartPointer< vtkSquarifyLayoutStrategy > | |
| CvtkSmartPointer< vtkStringArray > | |
| 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< vtkVertexDegree > | |
| CvtkSmartPointer< vtkVertexGlyphFilter > | |
| CvtkSmartPointer< vtkWorldPointPicker > | |
| CvtkSmartPyObject | |
| 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. It requires that the filter uses vtkSMPMergePoints which creates a number of necessary data structures |
| CvtkSMPThreadLocal< T > | A simple thread local implementation for sequential operations |
| CvtkSMPThreadLocal< T * > | |
| CvtkSMPThreadLocal< unsigned char > | |
| CvtkSMPThreadLocal< vtkProgressObserver * > | |
| CvtkSMPThreadLocalObject< T > | Thread local storage for VTK objects |
| CvtkSMPThreadLocalObject< vtkProgressObserver > | |
| CvtkSMPTools | A set of parallel (multi-threaded) utility functions |
| Cvtk::detail::smp::vtkSMPTools_FunctorInternal< Functor, Init > | |
| Cvtk::detail::smp::vtkSMPTools_FunctorInternal< Functor, false > | |
| Cvtk::detail::smp::vtkSMPTools_FunctorInternal< Functor, true > | |
| Cvtk::detail::smp::vtkSMPTools_Has_Initialize< T > | |
| Cvtk::detail::smp::vtkSMPTools_Has_Initialize_const< T > | |
| Cvtk::detail::smp::vtkSMPTools_Lookup_For< Functor > | |
| Cvtk::detail::smp::vtkSMPTools_Lookup_For< Functor const > | |
| CvtkStatisticsAlgorithmPrivate | |
| ►CvtkStructuredNeighbor | |
| CvtkStructuredAMRNeighbor | |
| CvtkHyperTreeGrid::vtkSuperCursorEntry | |
| 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 |
| CvtkTestingObjectFactory | Object overrides used during testing |
| CvtkTestUtilities | Utility functions used for regression testing |
| CvtkTextRendererCleanup | |
| CvtkTextureImageCache< Key > | |
| CvtkTextureImageCache< TextPropertyKey > | |
| CvtkTextureIO | |
| CvtkTimerLogEntry | |
| 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 renderering |
| 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 |
| ►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 | |
| ►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, 4 > | |
| ►CvtkTuple< int, Size > | |
| ►CvtkVector< int, 2 > | |
| ►CvtkVector2< int > | |
| CvtkVector2i | |
| ►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 | |
| ►CvtkTuple< unsigned char, 4 > | |
| ►CvtkColor4< unsigned char > | |
| CvtkColor4ub | |
| CvtkTypedDataArrayIterator< Scalar > | STL-style random access iterator for vtkTypedDataArrays |
| CvtkTypeTraits< T > | Template defining traits of native types used by VTK |
| Cvtkucfloat | OpenGL vertex buffer object |
| 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 | |
| CvtkVariantCreate | |
| CvtkVariantEqual | |
| CvtkVariantExtract | |
| CvtkVariantLessThan | |
| CvtkVariantStrictEquality | |
| CvtkVariantStrictWeakOrder | |
| CvtkVertexAdjacencyList | |
| Cboost::vtkVertexGlobalMap | |
| Cboost::vtkVertexLocalMap | |
| Cboost::vtkVertexOwnerMap | |
| CvtkVolumeMask | |
| CvtkVolumeRayCastDynamicInfo | |
| CvtkVolumeRayCastStaticInfo | |
| 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< vtkOpenGLRenderWindow > | |
| CvtkWeakPointer< vtkPiecewiseFunction > | |
| CvtkWeakPointer< vtkRenderer > | |
| CvtkWeakPointer< vtkRenderWindow > | |
| CvtkWeakPointer< vtkRenderWindowInteractor > | |
| CvtkWeakPointer< vtkViewport > | |
| CvtkWeakPointer< vtkWindow > | |
| CvtkWin32Header | Manage Windows system differences |
| CvtkWin32OpenGL2RenderWindow | OpenGL rendering window |
| 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 | |
| CX3DEncoderFunctions | |
| CvtkXdmfReader::XdmfDataSetTopoGeoPath | |
| CvtkVRMLYaccData::yy_buffer_state | |
| CvtkVRMLYaccData::yyltype | |
| CvtkVRMLYaccData::YYSTYPE | |
| ►CBaseT | |
| CvtkTypeTemplate< ThisT, BaseT > | Provides the equivalent of vtkTypeMacro for use with template classes |
