ImFusion SDK 4.3
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234567]
 CAbstractFactory< T >
 ►CAbstractFactory< EndoscopicToolSegmentation >
 ►CAbstractFactory< FeatureDetector >
 ►CAbstractFactory< FeatureMatcher >
 ►CAbstractFactory< FeatureMatchPruner >
 ►CAbstractFactory< FeatureSampler >
 ►CAbstractFactory< MonocularDepthEstimation >
 ►CAbstractFactory< OpticalFlow >
 ►CAbstractFactory< StereoReconstruction >
 ►CAbstractFunctionBaseAbstract base class to define a differentiable function between general c++ types
 CProgram::AbstractIncludeStructStruct for representing an abstract include object
 CAccessTokenRepresents an access token for a HTTP server
 CAlgorithm::ActionStruct for representing a named action that has been registered with this algorithm
 CMenu::ActionRepresents an item inside a Menu where a callback function is called when user clicks on it
 CKeyboardShortcutManager::ActionSmall structure encapsulating a shortcut action
 CSliceViewDefaultEventHandler::ActionSpeedRecord to define the speed at which a mouse/touch movement will modify the underlying view
 CVolumeViewDefaultEventHandler::ActionSpeedRecord to define the speed/change rate at which a mouse/touch movement will modify the underlying view
 CViewInteraction::ActionSpeed
 CAlgorithmDocRecord of the common sections for Algorithm User Documentation
 ►CAlgorithmReconstructionDecoratorInterfaceBase class interface for AlgorithmReconstructionDecorator
 ►CAlignedBoxClass representing an axis aligned rectangular cuboid in 3D space
 CAlignedRectangle2DClass representing an axis aligned rectangle in 2D space
 CURRobotState::AnalogIoState
 CAnatomicalStructureDeformationDeformation of a single AnatomicalStructure object
 CAnatomicalStructureFactory
 CAnatomicalStructurePointwiseDeformationClass for representing nonlinear transformations on a set of points e.g
 CAnatomiesInfoSingleton class that holds a map of anatomies together with information related to that anatomy (such as display color, etc)
 CAnatomyClass representing a single anatomy code ID from the SNOMED CT database
 CAnatomiesInfo::AnatomyEntry
 ►CAnnotationOutputInterfaceInterface for passing annotations from an algorithm to the DefaultAlgorithmController
 CAnyClass to store arbitrary objects and provide type-safe access to them
 CAnyConstRefClass helper to pass a writable reference to arbitrary objects into
 CAnyRef
 CMarkerConfiguration::AprilTagBoardInfoInformation about a board of AprilTags
 CMarkerConfiguration::AprilTagInfoInformation about a single AprilTag
 CVertebraDissectionLegacyAlgorithm::ArticularProcessesPerLevelStructure to hold articular processes of a level
 CMarkerConfiguration::ArucoBoardInfoInformation about a board of Aruco markers
 CMarkerConfiguration::ArucoMarkerInfoInformation about a single Aruco marker
 CASCDeformationClass for representing "deformations" over an AnatomicalStructureCollection
 CDicomPacsCommunication::AsyncRequestInfoStructure wrapping the return value of an asynchronous PACS request
 CRobotInstance::AttachedObjectDefines the relationship between an attached object and the robot's end effector (EE), along with a file path to the object's mesh
 CAttributeAttributes allow for attaching custom data to individual parameters or an entire Properties instance
 CAuthorizationCodeFlowConfig
 ►CAuthorizationProviderInterface for providing the Authorization header for WebRequests
 ►CB
 CBackgroundThreadConsumer< T >Interface for BackgroundThreadQueue holders to implement
 CBackgroundThreadConsumer< ImFusion::SharedImageSet >
 CBackgroundThreadConsumer< ImFusion::StreamAlgorithmExecutorPayload >
 ►CBackgroundThreadConsumer< SharedImageSet >
 ►CBackgroundThreadConsumer< StreamAlgorithmExecutorPayload >
 CBackgroundThreadQueue< T >Queue for thread-safe asynchronous management of some payload data as needed in most streaming classes
 CBackgroundThreadQueue< ImFusion::SharedImageSet >
 CBackgroundThreadQueue< ImFusion::StreamAlgorithmExecutorPayload >
 CBackgroundVideoFileRecorder
 CBakeDeformationCPUBakes in a deformation applied to an image using the CPU
 ►CBase
 ►CBaseStream
 CBeadDetectionStructure representing a detected calibration bead
 CBestNSelector< T >
 CBicubicBSplineApproximationImplements the approximation of a 2D scalar field with bicubic bsplines
 Cbiggest_imf_img_type< Ts >
 Cbiggest_imf_img_type< T, Ts... >
 Cbinary_type_trait< cond, Op, LhsT, RhsT >Type trait
 Cbinary_type_trait< true, Op, LhsT, RhsT >
 ►CBinaryImgOpGl
 ►CBinarySerializableInterface for class which can be serialized and deserialized
 CBisectionSearch< T, U >Templated bisection search algorithm, finds the interval in a sorted array in which any given value falls
 CBlobDetector::Blob
 CBlobDetector
 ►CBlockBase class for pipeline processing blocks
 CBlockDetailsBlock access members
 Cbool_pack<... >
 CTensorBase::bool_pack<... >
 CView::BorderConfigRecord for specifying if and how to render a border frame surrounding the view
 CDepthMapToPointCloudAlgorithm::BoundingBoxStructure representing a bounding box for cropping
 CBoxBounding Box for ML tasks Since bounding boxes are axis aligned by definition, a Box is represented by its center and its extent
 CRegistrationResultsBrowser::BrowserResult
 CProgram::BufferBindingStruct to keep track of GlBuffers bound shaders as SSBOs
 ►CByteBufferViewConst view onto a sized buffer of raw binary data
 CByteSizeHelper class to facilitate handling byte sizes
 CInstrumentCalibrationDataComponent::Calibration
 CTrackingToolCalibrationWizardAlgorithm::CalibrationDataInternal struct to hold the current state of the calibration
 CCalibrationOptimizerInterface for calibration optimizers
 CCalibrationSettingsSettings for calibrateCamera()
 CCameraNavigationHelper class to manipulate a 3D Camera using classic metaphors such as zoom, pan, etc
 CKinectAzureStreamPlaybackAlgorithm::CaptureStructure holding decoded frame data for a single capture
 CCartesianFramesHolds two Cartesian States between different parts of the robotic system (i.e flange to base, and effector to base)
 CCartesianQuantitiesRepresents Cartesian quantities used to describe 3D spatial information
 CCartesianStateRepresents pose and velocity of a frame in Cartesian coordinates
 CChannelReductionIdentifier
 CImageStatisticsAlgorithm::ChannelStatistics
 CMarkerConfiguration::CharucoBoardInfoInformation about a Charuco board
 CMarkerConfiguration::ChessboardInfoInformation about a chessboard
 CCircleClass representing a circle (actually a disk, so including the inner part) in 3D space
 CMarkerConfiguration::CircleBoardDetectorParametersDetector parameters for Circle Board markers
 CMarkerConfiguration::CircleBoardInfoInformation about a circle board
 CPolynomial::citeratorConstant Iterator for traversing the values of a piecewise polynomial at Gauss-Lobatto points across all intervals
 CClassificationInputData
 CClassificationLearningEvaluationClass for evaluation of a binary classification method
 CClCommandQueueOpenCL command queue class
 CClContextOpenCL context class
 ►CClDeformation
 CClDeviceOpenCL device class
 CClEnvironmentEncapsulates OpenCL environment
 CClEventOpenCL event class
 CClFastMarchingOpenCL Fast Marching implementation
 CClKernelOpenCL kernel class
 CClMarkovChainOpenCL-based Viterbi algorithm
 ►CClonableInterface for virtual copy construction
 CClPlatformOpenCL platform class
 CClProgramOpenCL program class
 CClReductionOpenCL-based reduction based on the NVIDIA OpenCL reduction SDK sample
 CClSortOpenCL-based sorting
 CColorMeshWidget::ColorSettings
 Ccommon_type< Ts >Common_type
 Ccommon_type< T >
 Ccommon_type< T, void >
 Ccommon_type< T1, T2 >
 Ccommon_type< T1, T2, Ts... >
 Ccommon_type< void, T >
 Ccommon_type< void, void >
 ►CCompoundDataInterface for datasets that are formed by one or multiple other nested Data instances
 CCompoundStreamDataContainer for StreamData from the individual Stream#s of a StreamGroup
 CConeBeamFrameParsStores and handles individual per-frame transformation parameters
 ►CConfigurableBase interface for classes that support object serialization from/to Properties objects
 CConnectedComponent
 CConnectedComponentData
 CConnectedComponentInfo
 ►CConnectionBaseAbstract non-templated base class for all connection types
 CConnectionBlueprint< Payload >Defines the necessary information for registering a new connection type
 CConnectionFactory< Payload >The ConnectionFactory manages available connection protocols and creates new connections based on the provided configuration
 CGlPoseGraph::Constraint
 CPoseGraphOptimization::ConstraintConstraints between nodes, i.e. relative poses between them
 CContextWhen (de)compressing many times it is recommended to allocate the context only once and reuse it for each successive operations
 CMachineLearningModel::Context
 CRTStructureDataComponent::ContourRepresents a single item in the original 'Contour Sequence' (3006,0040)
 ►CControlInterfaceBaseBase class for robot control interfaces
 CControlIterationInfo
 CControllerConfigurationConfiguration to be used to configure a controller
 CFrameGeometry::Fan::ControlPoint
 CConversionOptionsOptions for conversion between Graph and Mesh classes
 CConversionParameters
 ►CCoordinatesImpl
 CSlice::Corners
 CPointCorrAlgorithm::CorrItemStructure encapsulating a single point correspondence item defined by a pair of points
 ►CCostFunctionInterface for a cost function that can be optimized
 CContext::CreateInfo
 CPointBasedAnnotationEventHandler::CreateMode
 CCreator< Base, Params >Base class for creators to be registered in factory
 CCreator< Base, Params >Base class for factory "create" functionality
 CCreator< Base, Params >Base class for creators to be registered in factory
 ►CCreator< Base, Params... >
 ►CCreator< Base, Params... >
 ►CCreator< Base, Params... >
 CInteractiveCroppingBox::CropBoxHelper struct for storing the size and center of the box in pixel coordinates
 CInteractiveCroppingBox::CropOffsetsHelper struct for storing the offsets of the lower and upper corner points of the box
 CCudaComputeCapabilityHelper struct to store the CUDA compute capability
 CCudaDeviceManagerSingleton class that helps getting a compatible CUDA device
 CCudaDeviceManager::CudaDevicePropAbstracted and stripped down version of cudaDeviceProp
 CCurveInterpolation and fitting of a 1D curve
 ►CCustomPropertyBaseBasic interface for a custom property, i.e. a collection of values on different elements (vertices/faces)
 CCustomPropertyDescriptor< T >
 ►CCustomPropertyDescriptor< char >
 ►CCustomPropertyElementBaseBasic interface for the value of a custom property on a single element
 ►CDataVirtual base class for representing data from which all concrete data class such as images need to derive
 CDataAnnotationFactory::DataAttribute
 ►CDataComponentWithParentInterfaceInterface to augment a DataComponent with a parent of type Data
 CDataDisplayHandlerFactoryFactory class to maintain the list of registered DataDisplayHandlers ,
 ►CDataLinkInterface for linking properties between multiple Data instances
 CDataListContainer for any number of Data instances such as image or meshes
 CDataLoaderSpecs
 CDataLoggerSupport for logging data
 CRegistrationResults::DataResultRepresents the registration result for a single data object
 CDatasetClass for creating an iterable dataset by chaining data loading and transforming operations executed in a lazy fashion
 CDatasetIodPairNamed pair of a DcmDataset and the corresponding IOD
 CRegistrationResults::DataSource
 CDcmTagKeyStlComp
 Cdefault_constructor_tag
 CASCDisplayOptions::DefaultSystemStyleSheetsThese style sheets are created automatically in the constructor
 ►CDefaultTraits
 CApplyASCDeformation::DeformationDataData structure extracted from ASCDeformation This is used as input to the shader
 CDeformationEventBase class for customized deformation events
 CAnatomicalStructureDeformation::DeformationKeysStructure for managing collections of keys for objects that can be deformed individually
 CDepthColorWarpingDepthColorWarping provides functionality for warping between depth and color images using camera calibration and extrinsic parameters
 CAlgorithmFactory::DescriptorStruct describing an algorithm registered with a factory
 CBoneSegmentationBaseAlgorithm::DetectionResult
 CMarkerConfiguration::DetectorParametersDetector parameters for Aruco markers, boards and Charuco boards
 ►CDeviceBase class for Igtlink devices
 CDeviceBlueprint
 CDeviceFactoryFactory class handling Igtl devices
 CDeviceFlowConfigConfiguration for the OAuth2 Device Code Flow
 CDeviceImpl
 CDeviceParametersSave image in text file one image row per line
 CDeviceResponseResponse of the authEndpoint that starts the flow
 CDicomPacsConfigurationStructure encapsulating all information needed to connect to a PACS instance
 ►CDicomParameterBaseInternal type-erased base class for DicomParameter<T>
 CDiffusionNetOperatorsPopulates inputs required for running DiffusionNet architecture (https://arxiv.org/abs/2012.00888) for learning on 3D shapes
 CMorpho< T >::DilateByBlock2D
 CMorpho< T >::DilateByBlock3D
 CDimensionsInfoDescribes with which dimensions a series will be loaded
 ►CDirectoryEntity representing a Directory in the filesystem
 ►CDisplayBaseCommon base class interface of GUI::Display and DisplayWidget enabling other parts of the framework to access the most basic functionality in a general fashion
 CDisplayLayoutConfigThe DisplayLayoutConfig serves as static "snapshot" of the view configuration of a DisplayLayout
 CDisplayWidgetMultiAdapterHelper class providing the API of DisplayWidgetMulti while wrapping around either a DisplayWidgetMulti or a GUI::RadiologyDisplay
 CDistanceTransformDistance transformation algorithm
 CDominantPlaneOptimizerSettingsStructure representing the settings for the optimizor used to compute dominant plane of the mesh
 Cexpected_storage_base< void, E, false, true >::dummy
 CDynamicLibProvides access to functions of a shared library
 CGraph::EdgeInfoInformation stored at each edge of the graph
 CEigenHasher< T >STL-compatible hasher for dense Eigen types (matrices, vectors, arrays)
 ►CEigenVectorWrapperOptionalBase
 ►CElementListInterface for classes that consist of Elements
 CElementTypeHashHash function for the ElementType enum class
 ►CElementwiseDataComponentDataClass for augmenting Data classes with an ElementwiseDataComponentList
 CEllipse2DClass representing an ellipse in 2D space
 CConeBeamCalibration::PointExtractionParams::EllipseParams
 CSignalMutexProxy< false >::EmptyLockGuard
 CEncryptedString< N >
 CVertebraDissectionLegacyAlgorithm::EndplatesPerLevelStructure to hold endplates of a level
 CProcessingRecordComponent::EntryStruct for holding the name and Properties of Operations, Samplers and Algorithms
 CURRobotState::AnalogIoState::Entry
 CEntryInfoInfo for an archive entry:
 CMorpho< T >::ErodeByBlock2D
 CMorpho< T >::ErodeByBlock3D
 CErrorRepresents a zip/unzip error
 CErrorStructure for storing errors occurring during loading/saving DICOM data
 ►CErrorFunctionInterface for an error function returning one or multiple values
 ►CErrorInterfaceAn interface for error handling and representation
 ►CErrorRecorderError handling interface for the Dicom module
 CUltrasoundConeCalibrationAlgorithm::EstimatedCalibrationRepresents an estimated calibration result
 CEvaluationResultReturn type of metric computation
 CEventHandler::Event
 ►CView::EventHandlerInterface to be used as base class for event handlers of Views
 ►CViewObject::EventHandlerInterface to be used as base class for event handlers of ViewObjects
 CEventResultSimple record intended to be used as return value of the a handleInputEvent() function to indicate how to proceed
 ►Cexception [external]STL class
 CExpandableWidgetThis class is a container widget that can expand and collapse another widget
 ►Cexpected_default_ctor_base< T, E, Enable >
 Cexpected_default_ctor_base< T, E, false >
 ►Cexpected_delete_assign_base< T, E, EnableCopy, EnableMove >
 Cexpected_delete_assign_base< T, E, false, false >
 Cexpected_delete_assign_base< T, E, false, true >
 Cexpected_delete_assign_base< T, E, true, false >
 ►Cexpected_delete_ctor_base< T, E, EnableCopy, EnableMove >
 Cexpected_delete_ctor_base< T, E, false, false >
 Cexpected_delete_ctor_base< T, E, false, true >
 Cexpected_delete_ctor_base< T, E, true, false >
 ►Cexpected_storage_base< T, E, bool, bool >
 Cexpected_storage_base< T, E, false, true >
 Cexpected_storage_base< T, E, true, false >
 Cexpected_storage_base< T, E, true, true >
 ►Cexpected_storage_base< void, E >
 Cexpected_storage_base< void, E, false, false >
 Cexpected_storage_base< void, E, false, true >
 CExportFolder
 ►CExprBaseBase class for expressions (non-templated) (needs to be empty in order to enable empty base class optimization!)
 ►CExprBaseTpl< ImplType >Base class for compile-time optimized expressions (curiously recurring template pattern (CRTP))
 ►CExprBaseTpl< Array< T, ImgType, false > >
 ►CExprBaseTpl< BinaryOpTpl< Op, LhsT, RhsT > >
 ►CExprBaseTpl< CastWrapperTpl< OperandT, CastT > >
 ►CExprBaseTpl< ChannelReductionTpl< Op, OperandT > >
 ►CExprBaseTpl< ChannelSwizzleViewTpl< OperandT > >
 ►CExprBaseTpl< ChannelWiseScalar< T, Dim > >
 ►CExprBaseTpl< CombineChannelsTpl< Ts... > >
 ►CExprBaseTpl< Coordinates< imf_img_typeT > >
 ►CExprBaseTpl< DeformationLeaf >
 ►CExprBaseTpl< DeviceStrategyWrapperTpl< OperandT > >
 ►CExprBaseTpl< MaskLeaf< OperandT > >
 CExprBaseTpl< Noise< imf_img_typeT, Scalar< float >, Scalar< float > > >
 ►CExprBaseTpl< ResampleTpl< OperandT, includeDeformation > >
 ►CExprBaseTpl< Scalar< float > >
 ►CExprBaseTpl< Scalar< T > >
 ►CExprBaseTpl< SelectTpl< ConditionT, LhsT, RhsT > >
 ►CExprBaseTpl< StashTpl< ExprT, ImFusion::ImageMath::StashVariable< double > > >
 ►CExprBaseTpl< StashTpl< ExprT, VariableT > >
 ►CExprBaseTpl< StashVariable< T > >
 ►CExprBaseTpl< StringLeaf >
 ►CExprBaseTpl< UnaryOpTpl< Op, OperandT > >
 ►CExprBaseTpl< Variable >
 ►CExprInterfaceImageMath base class to provide an interface for non-CRTP polymorphism
 CFactory< Base, Params >Generic factory class for registering polymorphic types Usage:
 CASCRegistrationMethod::FactoryGlobal and local factories for ASCRegistrationMethod objects
 CFactory< Base, Params >Generic factory class for registering polymorphic types
 CFactory< Base, Params >Generic factory class for registering polymorphic types Usage:
 CAlgorithm::FactoryInfoStruct describing how an Algorithm was instantiated by the AlgorithmFactory
 ►Cfalse_type [external]
 CFrameGeometry::FanHelper struct for drawing the fan and fan manipulation
 CFrameGeometry::Fan::FanEdge
 CGraph::FeatureDescriptor
 CFeatureKeyUsed to uniquely identify a feature by name and kind (node/edge)
 CFeatureMatchStructure representing a match between two keypoints
 CFiducialExtractionAlgorithm::Fiducial
 CUltrasoundConeCalibrationAlgorithm::FiducialsRepresents fiducial points used for calibration
 ►CFileEntity representing a file in the filesystem
 CFileReaderColumnThis struct represents a "column" of filenames in a filelist, like those contained in datalist_training.txt/data_list_validation.txt produced by ImFusionLabels
 CSink::FilterStructure storing a filter
 CAbstractInclude::FingerprintAbstractIncludes provide a fingerprint to simplify duplicate detection
 Cfirst_non_void< Ts >Get first non-void element in parameter pack
 Cfirst_non_void< T, Ts... >
 CFlags< Enum >Utility class to store a type-safe combination of enum-based bit fields
 CFlags< AlgorithmAttributes >
 CFlags< Button >
 CFlags< Contents >
 CFlags< Coordinates >
 CFlags< Decoration >
 CFlags< DisplayOptions2dWidget::Sections >
 CFlags< DisplayOptions3dWidget::Sections >
 CFlags< Face >
 CFlags< FormattingOptions >
 CFlags< InputEvent::KeyboardModifier >
 CFlags< InstrumentTableConfiguration >
 CFlags< InteractionMode >
 CFlags< KeyboardModifier >
 CFlags< Link >
 CFlags< Log::ConsoleSink::Options >
 CFlags< Log::FileSink::Options >
 CFlags< PostLoadAction >
 CFlags< RenderMode2d >
 CFlags< RenderMode3d >
 CFlags< SaveFlags >
 CFlags< SelectionMode >
 CFlags< ShaderTextReplacement >
 CFlags< TaskMode >
 CFlags< ValueDomains >
 CTextRenderer::FontStruct to describe font settings such as font family, size, or decorations
 CGlSweepReconstruction::FourCorners
 CFP16
 CFP32
 CKinectAzureStreamPlaybackAlgorithm::FrameDecoderDecoder for video frames in Kinect Azure MKV recordings
 CFrameDescriptorDescriptor for a single DICOM frame that is used during the loading process as intermediate representation before eventually converting the image data to a SharedImageSet
 CKinectAzureStreamRecordingAlgorithm::FrameEncoderEncoder for video frames in Kinect Azure recordings
 CSweepTrajectoryAnalysisAlgorithm::FrameInfoStructure to store geometry information and meta data for an US frame
 CVideoDecoder::FrameStats
 CFreeformSelectorSimple class to make it easy to select by hand a portion of a volume
 CFrequencyFilter1DApply arbitrary frequency filters to 1D input
 CFrequencyFilter2DApply arbitrary frequency filters to 2D input
 CFullGeometryRepresentationStruct for the collection off all components needed to represent the full geometry of a frame
 CFunction< FunctionRnToRm::dense_matrix_t >Specialization of the Function template for dense matrix Jacobians
 CFunction< FunctionRnToRm::sparse_matrix_sparse_matrix_t >Specialization of the Function template for sparse matrix Jacobians
 CFunctionRnToRmAbstract base class to define constraints and cost functions for optimization
 CIntensityClusteringAlgorithm::GaussianClusterStruct to represent clusters
 CGaussianFilterApplies a symmetric Gaussian filter to an image
 CGeneralEquipmentExtension::GeneralEquipment
 CGeneratorConvenience class for generating random numbers from various distributions
 CGenericHasher< T, PointerToMember >STL-compatible hasher for custom classes where you list the members to be hashed as template parameters
 CGenericSocketInterfaceGeneric class to connect to a raw socket and send/receive text data
 CgladGLversionStruct
 CGlAnnotationFactory
 CGLCollocationDataStructor to contain the collocation points, integration weights, varycentric weights and derivativeMatrix of the gieven set of points
 CGlConeBeamForwardLegacy OpenGL cone-beam forward projection
 ►CGlExprInterfaceBase class for all expressions which provides an interface to automatically create shaders from an expression
 CGlMeshRendererContoursRenders the silhouette/contours of a mesh in a 3D view
 CGlMeshRendererIntersectionRenders the intersection between a Mesh and a Geometry::Plane using lines
 CGlMeshRendererNormalsRenders the normals of a Mesh using line primitives
 CGlMeshRendererSurfaceHighly configurable renderer to display the surface of a Mesh
 CGlobalICPGlobal ICP point cloud alignment
 CGlobalSettingsClass for storing and retrieving persistent global settings
 CGlPainter
 CGraphImpl< EdgeInfo, NodeInfo, NodeIndex >Helper struct representing a graph over a fixed set of nodes
 CGraphImpl< EdgeInfo, NodeInfo, NodeIndex >Helper struct representing a graph over a fixed set of nodes
 CGraphImpl< std::optional< ImFusion::Graph::EdgeInfo >, ImFusion::Graph::NodeInfo, NodeIndex >
 CGroupAllows to group a set of OpenGL calls together
 ChasEvalString< T, Args >
 CFrameTransform::Hash
 ChasImgType< T >
 CHelper< T, takesArguments >
 CHelper< T, false >
 CHelper< T, true >
 CMeshDistanceController::Histogram
 CHomographyAndFundamentalMatrixDecompositionThis class, given point correspondences from two images, estimates the homography and the fundamental matrix, then, depending on the score, decomposes one of them into rotation and translation
 CHttpError
 CHuffmanHuffman code for data compression
 CDefaultDataWidgetItemDelegate::ElementInfo::Icon
 CICPICP-based point cloud alignment
 CImage_< ContainerAllocator >
 CProgram::ImageBinding
 CImageDescriptorStruct describing the essential properties of an image
 CImageDescriptorWorldConvenience struct extending an ImageDescriptor to also include a matrix describing the image orientation in world coordinates
 CImageDownsamplerManager for image downsampling/upsampling
 CImageResamplerHelper class to run resampling algorithms within operations The class holds two permanent algorithm instances (one for images, one for labels) for the sake of efficiency Images with more 4 channels are properly handled so that GPU execution is still possible
 CImageTemplateClass representing a template for extracting image content based on named reference regions
 CImageTransformerGeneric way of transforming from the pixel coordinates of one image to the pixel coordinates of another image including any world transformations
 CImageUndistortionThis class enables the undistortion of images, i.e
 CImFusionFileGroupGroups for combining different data (with additional properties) within the ImFusion file format
 ►CImFusionFilePluginAllow loading and saving of custom classes and data within the ImFusion file format
 CImFusionImage::ImFusionImageHeaderFor image types, the corresponding data block contains the following header
 ►CImFusionPluginBase class for plugins that can be loaded by the ImFusion SDK
 CImFusionROSManagerSingleton class to manage the ROS node When using ROS2, it will manage the main ROS node used to listen to tf
 CImFusionTfManagerSingleton class to manage tf
 Cabs::Impl< OperandT, IsSigned >
 CunaryMinus::Impl< OperandT, IsSigned >
 Cabs::Impl< OperandT, false >
 CunaryMinus::Impl< OperandT, false >
 Cabs::Impl< OperandT, true >
 CunaryMinus::Impl< OperandT, true >
 CImpliedLocalCoordinates< T >Helper class for storing an "image" representation of an object, and converting to/from image and world representations
 CImpliedLocalCoordinates< ImFusion::AnatomicalStructure >
 CImpliedLocalCoordinates< ImFusion::Ilium >
 CImpliedLocalCoordinates< ImFusion::IntervertebralDisc >
 CImpliedLocalCoordinates< ImFusion::OrientedVertebra >
 CImpliedLocalCoordinates< ImFusion::Sacrum >
 CIMURawMetadata::IMURawSample
 CExportFolder::IndexedPath
 CInitConfigRecord to configure the initialization of the ImFusion SDK
 CXRay2D3DRegistrationInitialization::InitializationResult
 ►CInputEventBase class for user input events in a graphical user interface (GUI)
 ►Cintegral_constant< bool, !std::is_copy_constructible< T >::value &&!std::is_copy_assignable< T >::value &&std::is_move_constructible< T >::value &&std::is_move_assignable< T >::value > [external]
 ►Cintegral_constant< bool, decltype(detail::swap_adl_tests::can_swap< T, T >(0))::value &&(!decltype(detail::swap_adl_tests::uses_std< T, T >(0))::value||(std::is_move_assignable< T >::value &&std::is_move_constructible< T >::value))> [external]
 ►Cintegral_constant< bool, decltype(detail::swap_adl_tests::can_swap< T[N], T[N]>(0))::value &&(!decltype(detail::swap_adl_tests::uses_std< T[N], T[N]>(0))::value||is_swappable< T, T >::value)> [external]
 ►Cintegral_constant< bool, is_swappable< T, T >::value &&((decltype(detail::swap_adl_tests::uses_std< T, T >(0))::value &&detail::swap_adl_tests::is_std_swap_noexcept< T >::value)||(!decltype(detail::swap_adl_tests::uses_std< T, T >(0))::value &&detail::swap_adl_tests::is_adl_swap_noexcept< T, T >::value))> [external]
 ►Cintegral_constant< bool, noexcept(can_swap< T, U >(0))> [external]
 ►Cintegral_constant< bool, std::is_default_constructible< T >::value &&std::is_copy_constructible< T >::value &&std::is_move_constructible< T >::value &&std::is_copy_assignable< T >::value &&std::is_move_assignable< T >::value > [external]
 ►Cintegral_constant< bool, std::is_nothrow_move_constructible< T >::value &&std::is_nothrow_move_assignable< T >::value > [external]
 CPointBasedAnnotationManipulator::InteractionModeWrapper
 ►CInteractiveViewAdapterHelper class providing the API of InteractiveView while wrapping around either a InteractiveView or a GUI::View
 CInternalFormatDescribes an internal texture format that you can request from OpenGL
 CLineToIsosurfaceIntersectionAlgorithm::IntersectionCylindricalCoordinates
 CIntervalRepresents an interval in the real line
 CIntervalPartitionXdRepresents an partition of the interval [t_0, t_N]
 CInversionComponent::InversionInfoA structure to store all information needed for operation inversion
 Cinvoke_result_impl< F, class, Us >
 Cinvoke_result_impl< F, decltype(detail::invoke(std::declval< F >(), std::declval< Us >()...), void()), Us... >
 ►Cios_base [external]STL class
 CIPAddressA class for handling and validating IPv4 addresses
 CisEqualityComparable< T >
 CItemControlItemControl abstract interaface
 CDeformableIcp::IterationInfoUsed to report information about an iteration
 CPolynomial::iteratorIterator for traversing the values of a piecewise polynomial at Gauss-Lobatto points across all intervals
 CJointQuantitiesRepresents joint-related values (position, velocity, acceleration, torque, etc.) and their corresponding states (measured, desired, or commanded) and provides access to each of these values through member variables
 CJointStateRepresents a joint's rotational state in terms of position and velocity
 CJpegIOClass for reading and writing JPEG images
 CKalmanFilter< StateSize, MeasurementSize >Generic Kalman filter
 CKalmanFilter< 6, 3 >
 CKalmanFilter< 7, 4 >
 CKalmanPositionKalman filter for position data
 CKalmanQuaternionKalman filter for quaternions
 ►CKeyBaseBase class
 CInputEventMapperBase::KeyboardMapping
 CRGBDReconstructionAlgorithm::KeyframeKeyframe structure containing depth, color, and camera data
 CTransferFunctionTissue::KeyPointDescribes a single key point of a tissue
 CKeypointStructure representing a detected keypoint and its descriptor
 ►CFeatureDetectorWithAdaptiveThreshold::KeyPointIteratorIterator for traversing keypoints, optionally sorted by response
 CKeyRegistry
 CKeyValueStoreVisualiserParent< DataType >
 ►CKeyValueStoreVisualiserParent< AnatomicalStructure >
 ►CKeyValueStoreVisualiserParent< AnatomicalStructureCollection >
 CKeyValueStoreVisualiserParent< ImFusion::AnatomicalStructure >
 CKeyValueStoreVisualizerBase< DataType >
 ►CKeyValueStoreVisualizerBase< AnatomicalStructure >
 ►CKeyValueStoreVisualizerBase< ImFusion::AnatomicalStructure >
 CLabelDataComponent::LabelConfigHelper struct encapsulating the metadata of a label value
 CLabelInfo
 CLabelLockConvenience class for handling locked/unlocked state of labels
 CStructuresView::LabelMapInfoBookkeeping information to easily map between label maps and their structures
 CLabelMapRefinementHelper class for post-processing a label map
 CLabelPainterClass for manually drawing to label maps
 CVertebraDissectionLegacyAlgorithm::LandmarkStructure to hold landmark information of a level
 CLaserLockerProvides management and acquisition of laser locks for RGB-D sensors
 CLaserManagerManages synchronization and coordination of laser states among multiple RGB-D sensors
 CConnectionLatencyMeasuringAlgorithm::Latency
 CDisplayAutoLayouter::LayoutAlgorithmInterface to derive from to define custom display layout algorithms
 CDisplayLayoutConfig::LayoutCellOne cell in the grid
 CDisplayAutoLayouter::LayoutInfoRecord of information passed to LayoutFunction::createLayout()
 CLC2Linear correlation of linear combination (LC2) similarity measure
 CSettings::LegacyInterfaceSettings
 CLevenbergMarquardtLevenberg-Marquardt optimizer
 ►CLightweightControllerInterface to set a display instance on a Controller or DataController class
 Clike_pointer< T >
 Clike_pointer< std::shared_ptr< T > >
 Clike_pointer< std::unique_ptr< T > >
 Clike_pointer< T * >
 CRobotJointDescription::LimitsDefines the motion limits for a particular joint
 CLinearIterator< T >Typed convenience iterator for quick integration into custom containers, especially if traversal requires on-the-fly evaluations
 ►CLinearIterator< TrackingTuple >
 CLinearResidualLinear residual for tomographic reconstruction
 ►CLinearSystemSolverInterface for linear system solvers
 ►CLineBaseCommon interface of Line and LineSegment
 CLineHoughTransform
 CLinkPose::LinkHandler
 CLinkPose::LinkItem
 CListModelViewRepresents a QListView, and the container ItemViewWidget. The model can be accessed in ItemViewWidget::model or QListView::model
 CLiteTracker
 ►CLiveSensorFusionAbstract base class for 9DOF sensor fusion algorithms
 CDataListReader::LoadedInfo
 CLocalizationInputDataData for one localization evaluation instance -> one input scan + groundtruth keypoints
 CSpineEvaluation< Data >::LogBook
 CSink::LogCaptureStructure storing a single log event
 CLoggingTimerScope guard-like stopwatch class to automatically log measured execution time on destruction of the guard object
 CLRUCache< Key, Value, Hash, KeyEqual >Templated container class implementing a Least Recently Used Cache
 CLRUCache< BufferConfig, ImFusion::GL::OffscreenRenderHelper::RenderBuffer, BufferConfigHasher >
 CLRUCache< ImFusion::Filesystem::Url, CacheItem, UrlHash >
 CLRUCache< ImFusion::SharedImageSet *, std::unique_ptr< CacheElem > >
 CMachineLearningModelClass for managing and executing a machine learning model on generic input data
 ►CManipulatorListenerInterface for manipulator events
 Cmap_arrow_proxy< T >
 CRealWorldMappingDataComponent::Mapping
 CMarkerDetectionGeneric marker detection class for a wide range of marker types, such as Aruco, Charuco, Chessboard, Circle Board, AprilTag and STag
 CMarkovChain
 CUltrasoundConeCalibrationAlgorithm::MatchesRepresents matches between cone tips from different sweeps
 CMeshMeasurementsController::MeasurementPlane
 CMemoryInfoStructure storing information about the available video memory as reported by OpenGL
 CMemoryInfoStructure storing information about the available main memory as reported Platform::memoryInfo()
 CMenuRepresents a hierarchical menu of actions used to describe menu bars, context menus, or popup menus
 CMeshGeodesicDistanceClass for computing the geodesic distance on the mesh surface between the 2 points
 CMeshGroupCollisionDetectionTest for collision between two groups of meshes
 CMeshIterator< Impl >
 CMeshIteratorRel< Impl >
 CMeshLaplacianCompute co-tangent laplacian of a mesh and its eigen decomposition
 CMetaImageHeader
 CMincIOClass for reading and writing MINC images
 CMinimumBoundingBoxAlgorithm for computing the minimum axis-aligned bounding box from image data
 CModelFactory::MLEngineCurrently supported ML Engines (cf. ML::Engine)
 CModelEvalLog
 CModelFactoryFactory for managing different versions of ML model sets globally
 CSpineBaseAlgorithm::ModelIdentifierCollection of known model identifiers for the SpineBaseAlgorithm
 CModelFactory::ModelInfoHolds the meta information about a single model
 CModelFactory::ModelSetList of models
 CSpineBaseAlgorithm::ModelSetMetadataIdentifierCollection of known model set metadata identifiers for the SpineBaseAlgorithm
 ►CModuleListInterface for classes that consist of modules
 CMorpho< T >Morphological operations (erosion/dilation) in 2D and 3D
 CVertebraDissectionLegacyAlgorithm::MostNarrowPedicleCrossSectionMost narrow part of the pedicle
 CRobotRunner::MotionDataData structure holding information about the current motion
 ►CMotionGeneratorBase
 ►CMotionGeneratorParametersInterface
 CMotionResultType returned by the startMotion() methods implemented by various control interfaces
 CMotionStep< PositionType >
 CPointBasedAnnotationManipulator::MouseEventMouse event structure
 CInputEventMapperBase::MouseMapping
 CPointBasedAnnotationEventHandler::MoveAnnotationMode
 CPointBasedAnnotationEventHandler::MovePointMode
 CMPolynomial< T >Class representing a piecewise polynomial a curve on the type T given be the action of a Parametrization on a Polynomial
 ►CMPolynomial< Eigen::Isometry3d >
 CMultiClassificationLearningEvaluationClass for evaluation of a multi-label classification method
 CMultiIncludable< BaseIncludeType, IncludeArgumentsTypes >Multi-AbstractIncludes allow for using multiple instances of the same AbstractInclude type in one shader
 ►CMultiIncludable< Deformation, const SharedImage * >
 ►CMultiIncludable< GlExpr >
 ►CMultiIncludable< GlGeometricTransform >
 ►CMultiIncludable< GlMask >
 CMultinomial
 CMultiSensorCalibrationProvides functionality for external calibration of multiple RGB-D sensors using markers
 CMultiTimerThis class can be used to help the developer to profile the run time of different parts of the same process
 CNativeRobotStateBase
 CNDITrackingInstrumentInfoNDI instrument info
 CNearestNeighborSearchNearest neighbor search for points
 CNiftiIOClass for reading and writing Nifti images
 Cno_init_t
 CGraphImpl< EdgeInfo, NodeInfo, NodeIndex >::Node
 CGraphImpl< EdgeInfo, NodeInfo, NodeIndex >::Node
 CGraph::NodeInfoInformation stored at each node of the graph
 CNoiseIdentifier
 CRobotModel::NotableFramesName of frames that identify the base, flange and end effector links within the URDF link tree
 ►CNotCopyableInherit from this class if your class should be neither copy-constructible nor assignable
 CNrrdIoAlgorithm::NrrdHeader
 CObjectPickingHelper class to consolidate functionality for implementing object picking of rendered geometry
 COctreeFast Octree space subdivision
 CGlVolumeRendererBasic::OpacityPeelingParametersRecord of parameters for configuring Opacity Peeling in the GlVolumeRendererBasic
 ►COperandMaskBase
 COperandStashImpl< expr_type, has_variable >
 COperandStashImpl< expr_type, true >
 ►COperandStashImpl< OperandT::var_type, OperandT::has_variable >
 ►COperationClass to define a pre-post processing operation on data items
 COperationsSequenceClass to execute a sequence of Operation, depending on the workflow phase (training, validation, etc.)
 CFeatureMapsRegistrationAlgorithm::OptimizationParameterEncapsulates the name and range (min, max) of a parameter
 COptimizationStudyHolds optimization study results and offers methods for analyzing results
 ►COptimizer
 COptimizerFactoryFactory for creating an Optimizer
 CLineRenderer::OptionsHelper struct to encapsulate all supported rendering options
 COrderedMap< KeyType, ValueType >Class for an insertion ordered map in order to mimic a python dictionary in C++ This is a convenience class which provides a similar interface to std::map and std::unordered_map It should be only used if there are not many elements to store or performance is not critical Due to its simple implementation it performs lookup only in O(N)
 COrderIndependentTransparencyHelper class to consolidate functionality for implementing order-independent transparency of rendered geometry
 CGlCurvedView::OrthoSliceInfo
 ►COutputConnectionInterface for connections to other devices for sending streams, volumes, and other information through network, USB port or other connection types
 CNearestNeighborSearch::OutputWrapper< T >Helper class for optional distance output, implicitly created from output type T. Do not use directly
 COwningDataListWrapper class to store a list of owned Data instances
 CStreamRecorderAlgorithm::OwningDataListAsyncHelper class for managing recorded data together with a future to ensure that background saving tasks are complete before the data is deleted
 CDicomPluginSettings::PacsServer
 CPaddingDoneInfoStruct for geometrical information about how the patches were extracted from the original images
 CPaddingDoneInfo::PadSizeStruct for storing the actual padding size applied to a single image
 CPairedPointsWithMetadataVectorLightweight helper structure to manage sets of paired points
 CConfigurable::Param
 CParamRecord of all properties that represent a single param inside a Properties instance
 ►CParameterBaseShared base interface of Parameter and SubProperty so that Configurable can maintain a collection of those
 ►CParameterWrapperBaseBase class for classes that wish to expose zero or more optimization parameters
 CGlFilterSet::ParamInfoSimple container to store information about filter parameters and names
 CSpine2DModelNames::ParamNames
 CBlobDetector::Params
 CParsedMessage
 CPasswordFlowConfig
 CPatchInfoStruct for storing the descriptor of the image a patch was extracted from and the region of interest in the original image
 CPathEntity representing a path in the filesystem
 CPathHandler
 CPCA< Scalar, Dim >
 CPcg64EngineWrapper class for a 64-bit PCG engine
 CKinectAzureStreamRecordingAlgorithm::PerFrameMetaDataStructure for per-frame metadata
 CPermutationLookupLookup structure for forward and backward block dimension squeezing
 ►CPersistentDataComponentBase class for DataComponents that must never be deleted from a DataComponentList
 CProgressDialog::PerTaskUI
 CPgmIO
 CConeBeamCalibration::PhantomStruct specifying phantom layout
 CObjectPicking::PickingInfoStructure encoding picking information for a single pixel
 CGlVolumeView::PickingTokenGlVolumeView uses tokens to handle access to object picking. The token enables picking and keeps it active until the last associated token gets destroyed
 CViewState::PixelIncrementWorldHelper struct to store the result of unprojectPixelIncrementOrtho() and unprojectPixelIncrementPerspective()
 CPlaneClass representing an oriented plane in 3D space defined by a base point and a normal direction
 CMoveItControlStream::PlanResult
 CPlatformInfoStructure storing information on the GPU/driver/OpenGL context configuration
 CPlaybackTimerRecurring timer class that allows for playback over a range at given timestamps/intervals
 CSelectionWidget::PlaybackWrapperThis class provides an interface for creating wrappers that allow playback functionality to a type
 CGlPlotView::PlotInfoData for a single plot handle
 CPluginInfo
 CPngIO
 CTouchEvent::PointRecord of touch point metadata
 CPointBasedAnnotationManipulatorEventDataStruct passed as event data to manipulator event
 CPointCloud::PointCloudDataStruct holding the underlying "heavy" data of a PointCloud object
 CPointCorrespondencesVisualGuideThis class calculates visual guides to assist in identifying corresponding points between different modalities
 CPointExtractionUtility class for extracting calibration points from images
 CConeBeamCalibration::PointExtractionParams
 CConeBeamCalibration::PointInfoInformation about extracted points
 CPointsWithMetadataHelper struct to store points together with information about what structure the points are derived from
 CPoissonParamsParameters for Poisson reconstruction
 CPolygon2DClass representing a planar polygon
 CRTStructureRenderingDataComponent::Polyline
 ►CPolynomialClass representing a piecewise polynomial constructed using Lagrange polynomials at Gauss-Lobatto points
 ►CPoseGraphOptimizationPose graph optimization The first pose is the reference pose and will stay fixed, all other poses are free to change
 CPoseHistoryClass for keeping track of the poses of an image and provide undo/redo functionality
 CBoneSegmentationBaseAlgorithm::PredictionMap
 CFrameGrabbingPresets::Preset
 CProcessedFrame
 CProcessUltrasoundParametersSpecifies the values that ProcessUltrasound will apply in the ultrasound data
 ►CProgramDecoratorInterface to apply custom arguments to a shader program
 CProjectionLoaderAbstract base class for X-ray projection image loaders
 CProjectionSetsComputation of projection subsets for iterative reconstruction
 CPropertiesStorage container for serialization of arbitrary types, internally backed by strings
 CRealSenseStream::PropertyInfoStructure representing information about a property configuring the sensor
 ►CPythonInterpreterInterfaceInterface for the embedded PythonInterpreter that prevents linking to an explicit Python version
 ►CQAbstractItemModel
 ►CQAbstractListModel
 ►CQAbstractProxyModel
 ►CQAbstractTableModel
 ►CQComboBox
 ►CQDialog
 ►CQFrame
 ►CQLabel
 ►CQMainWindow
 ►CQMenu
 ►CQObject
 ►CQOpenGLWidget
 ►CQPushButton
 ►CQScrollBar
 ►CQSlider
 ►CQSortFilterProxyModel
 ►CQStyledItemDelegate
 ►CQTableView
 ►CQTableWidget
 ►CQToolButton
 ►CQTreeView
 ►CQWidget
 ►CQWidgetAction
 ►CQWindow
 CRadon2D
 CRealSenseStream::RangeStructure representing a value range
 CTensorFactory::RankFactory< N >Internal helper factory for fixed type and increasing rank
 CTensorFactory::RankFactory< TensorFactory::maxRank >
 CRANSAC< Dataset, Hypothesis >This class implements a more generalized form of "Random Sample Consensus" algorithm
 CRANSACPairOfVectorsDataset< T, S >
 CRateLimits
 CDicomLoader::RawBuffer
 COptimizationStudy::RecordStructure for a single optimization study record
 CRectangleArbitrary rectangle in 3D space
 CStereoRectification::RectificationInformationStores parameters used in stereo rectification, a process that aligns images from a stereo camera pair to simplify disparity computation
 ►CReductionWrapperBaseBase class for reductions needed for polymorphic layer
 ►CReductionWrapperGlBaseDummy base as ReductionWrapperGl needs to be a polymorphic type
 CReferencedInstancesComponent::ReferencedInstance
 CReferenceSelector< T, Enable >
 CReferenceSelector< const Eigen::VectorXd >
 CReferenceSelector< const std::array< T, N >, std::enable_if_t<!std::is_arithmetic_v< T > > >
 CReferenceSelector< const std::tuple< Types... > >
 CReferenceSelector< const std::vector< T >, std::enable_if_t<!std::is_arithmetic_v< T > > >
 CReferenceSelector< Eigen::VectorXd >
 CReferenceSelector< std::array< T, N >, std::enable_if_t<!std::is_arithmetic_v< T > > >
 CReferenceSelector< std::tuple< Types... > >
 CReferenceSelector< std::vector< T >, std::enable_if_t<!std::is_arithmetic_v< T > > >Vector specialization
 ►CReferenceShapeAbstract class defining a reference shape which has been fitted to a segmentation map
 CRefWrapperSelector< T, Enable >
 CRefWrapperSelector< const Eigen::Ref< const Eigen::VectorXd > >
 CRefWrapperSelector< const Eigen::Ref< Eigen::VectorXd > >
 CRefWrapperSelector< const Eigen::VectorXd >
 CRefWrapperSelector< const std::array< T, N >, std::enable_if_t<!std::is_arithmetic_v< T > > >
 CRefWrapperSelector< const std::tuple< Types... > >
 CRefWrapperSelector< const std::vector< T >, std::enable_if_t<!std::is_arithmetic_v< T > > >
 CRefWrapperSelector< Eigen::Ref< const Eigen::VectorXd > >
 CRefWrapperSelector< Eigen::Ref< Eigen::VectorXd > >
 CRefWrapperSelector< Eigen::VectorXd >
 CRefWrapperSelector< std::array< T, N >, std::enable_if_t<!std::is_arithmetic_v< T > > >
 CRefWrapperSelector< std::reference_wrapper< T > >
 CRefWrapperSelector< std::tuple< Types... > >
 CRefWrapperSelector< std::vector< T >, std::enable_if_t<!std::is_arithmetic_v< T > > >Vector specialization
 CImageTemplate::Region
 CRegionOfInterestHelper struct to represent a region of interest
 CRegistrationResultsClass responsible for managing and storing the results of data registration
 CRegistry< Item >
 CRegistry< Item >
 CRegressionLearningEvaluationClass for evaluation of a regression method
 COptimizationProblem::RegTerm
 COptimizationProblem::RegTermOwning
 CPointBasedAnnotationEventHandler::RegularMode
 CUrl::RelativeTag
 CRemoveIndexFromTuple< Tup, I >
 CRemoveIndexFromTuple< std::tuple< Types... >, I >
 CGlSlice::Renderbuffer
 CGlVolumeView::RenderBufferWrapperHelper class to allow the injection of custom render buffers surrounding the entire render pipeline
 CRendererFactoryStatic factory class to manage registered slice and volume renderers to be used in views
 CGlSlice::RenderInfoStructure storing information on how to render a data set
 CGlVolumeRenderer::RenderTexturesHelper struct to encapsulate all input/output textures needed/used during direct volume rendering
 ►CRepositoryBase interface for a ImFusion resource repository
 CSharedImage::Representation
 CResponse
 CRANSAC< Dataset, Hypothesis >::Result
 CRegistrationResults::ResultRepresents a complete registration result, composed by multiple DataResult objects
 CImagewiseClassificationMetrics::Results
 CSurfaceDistancesMetric::Results
 CRGBDCalibrationAlgorithm::RGBDCalibrationStruct holding all calibration results for an RGBD sensor
 CRGBDMultiSequenceCollection of multiple synchronized or unsynchronized RGB-D sequences
 CRGBDReconstructionCallbackCallback interface for RGBDReconstructionAlgorithm events
 CRGBDSequenceInterface for a single sequence of RGB-D images
 CRGBDStreamFactoryFactory for enumerating available RGB-D streams
 CGlPolyRigidDeformation::RigidSegmentParameters
 CRobotArmCartesianStateComprehensive description of the complete Cartesian state of a robot arm and its attached objects
 CRobotBlueprint
 CRobotChainSubset of a RobotGroup or RobotTree of consecutive RobotSegments
 ►CRobotControlInterfacesHolderInterface to register and access robot control interfaces
 CRobotDescriptionComprehensive description of a robot's kinematic structure and properties Contains the complete definition of a robot's joints, links, and their relationships
 CRobotEndEffector
 CRobotFactoryFactory class for RobotStateStream
 CRobotGroupDescribes a named subset of the RobotTree conformed by multiple RobotChains
 CRobotGroupStateDefines a named state of the joint values in the RobotChains of a particular RobotGroup
 ►CRobotItemMap
 CRobotJointRepresents a robot joint associated with a RobotSegment. Defines the name, type and limits of a particular joint
 CRobotJointDescriptionStructs
 CRobotLink
 CRobotLinkDescriptionDefines a description of a robot link including its visual properties and connections
 CRobotModelHolds the description of a robot arm as a tree of links, kept together by joints (fixed or mobile)
 CRobotSegmentA RobotSegment represent each of the named individual parts of a RobotChain, with a RobotJoint
 CRobotSolverCalculates the IK/FK of a RobotTreeImpl or a specific RobotChain
 CRobotSolverAsync
 ►CRobotStateContains the current status of the robot (i.e
 CRobotTreeRepresents the tree information of a robot
 ►CRobotTreeImplInterface between RobotTree and the implementation/libraries used to hold the tree representation
 CFrameGrabbingPresets::ROI
 CRegionOfInterest::ROIParameters describing a region of interest
 CROSBagReaderConvenience class to wrap custom reader RAII
 CROSBagWriterConvenience class to wrap custom writer RAII
 CROSMasterROS Master execution handler
 CROSMsgDLLPreloader
 CROSParameterWrapper for ROS1 and ROS2 parameters
 CROSParameterManagerClass to handle ROS1 and ROS2 parameters
 CROSParameterPathClass to abstract between ROS1 and ROS2 parameter paths
 CROSStreamBlueprint
 CROSStreamFactory
 CROSTypeName
 CROSPluginSettings::RosWorkspace
 CVitalsDataComponent::SampleA single temporal sample
 CSavedGroupStateRepresents a named configuration of joint positions for a specific group of robot joints
 CSaveOptionsMost properties of a MetaImage header can be deduced from a SharedImageSet, the ones in SaveOptions can not
 CScaledIso3Class for representing uniformly scaled elements of E(3), where E(3) is the Euclidean group, i.e linear transformations that are isometries on R^3 Strictly speaking, such transformations are defined by a scaling (around the origin), translation, and a rotation around the origin
 ►CScannerScan different locations for DICOM files
 CScheduledMainThreadCommand
 CScopeGuard< ReleaseFunc >Templated proxy class to implement generic scope guards
 CSeekable< T >
 CSeekable< TrackingInstrument >
 CLabelPainter::Segment
 CSegmentationInputData}
 ►CSegmentedStructureInterface class that offers methods to obtain measuring markers on a segmented object
 ►CSelectableInterface for Data that supports having a Selection
 CSelectorStyle selector combining with logical OR multiple SelectorElem objects
 CSelectorElemClass for querying objects
 COrbbecRGBDStream::SensorConfigSensor configuration for multi-device synchronization
 CMenu::SeparatorRepresents a separator to be shown as divider between unrelated groups of actions
 ►CSequentialImageProcessorInterface for algorithms that are able to repeatedly process individual images
 CSequentialMotionLegacy sequential motion analysis for CBCT data
 CSettings::Setting< T >Provides a type-safe way to access a setting value
 CSettings::Setting< bool >
 CSettings::Setting< int >
 CSettings::Setting< std::string >
 CSettings::Setting< vec4 >
 CProgram::ShaderInfoEncapsulates information about each shader stage
 CGlVolumeRendererGlobalIllum::ShadingParametersStructure encapsulating a Phong shading configuration
 CSharedImageImage shared on multiple devices
 CSharedImageRingBuffer::SharedImageBuffer
 CSharedImageRingBufferHolds a vector of shared_ptr<SharedImage>, which can be used alternatively to avoid reallocation It provides methods to get the next buffer which is not held by some other listener as well, and can be hence written into
 CSharedImageSetCompatibleConditionStructure contains common compatible criterion for SharedImageSet
 ►CSignalBaseBase interface for Signals
 CSignalImpl< false, ArgTypes... >< Action >
 CSignalImpl< false, ArgTypes... >< bool >
 CSignalImpl< false, ArgTypes... >< const BufferConfig & >
 CSignalImpl< false, ArgTypes... >< const float & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::Algorithm * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::Data * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::DataList &, const ImFusion::DataList & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::DeformationEvent & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::Filesystem::Url & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::GlImage *, const std::string & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::GlPointBasedAnnotation * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::GUI::View *, bool >
 CSignalImpl< false, ArgTypes... >< const ImFusion::IGTL::ParsedMessage & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::InteractiveObject * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::MemImage *, const std::string & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::Mesh *, const std::string & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::PointBasedAnnotationManipulator * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::PointCloud *, const std::string & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::SharedImage * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::SharedImage *, const std::string & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::SharedImageSet * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::SharedImageSet *& >
 CSignalImpl< false, ArgTypes... >< const ImFusion::SharedImageSet *, const std::string & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::TrackedSharedImageSet * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::Tree *, const std::string & >
 CSignalImpl< false, ArgTypes... >< const ImFusion::US::FrameGeometryMetadata * >
 CSignalImpl< false, ArgTypes... >< const ImFusion::US::UltrasoundSweep * >
 CSignalImpl< false, ArgTypes... >< const Key & >
 CSignalImpl< false, ArgTypes... >< const std::string & >
 CSignalImpl< false, ArgTypes... >< const std::string &, const ImFusion::InstrumentCalibrationDataComponent::Calibration & >
 CSignalImpl< false, ArgTypes... >< const std::string &, ImFusion::KeyValueStore::Entry & >
 CSignalImpl< false, ArgTypes... >< const std::string &, std::conditional_t & >
 CSignalImpl< false, ArgTypes... >< const std::string &, std::conditional_t &, ImFusion::KeyValueStore::Entry & >
 CSignalImpl< false, ArgTypes... >< const std::vector< double > &, const std::string & >
 CSignalImpl< false, ArgTypes... >< const std::vector< int > & >
 CSignalImpl< false, ArgTypes... >< const std::vector< int > &, const std::optional< vec3 > & >
 CSignalImpl< false, ArgTypes... >< const std::vector< std::pair< int, vec2i > > &, const std::optional< vec3 > & >
 CSignalImpl< false, ArgTypes... >< const std::vector< vec2 > & >
 CSignalImpl< false, ArgTypes... >< Data::Kind >
 CSignalImpl< false, ArgTypes... >< double >
 CSignalImpl< false, ArgTypes... >< ImFusion::AnatomicalStructure * >
 CSignalImpl< false, ArgTypes... >< ImFusion::Data * >
 CSignalImpl< false, ArgTypes... >< ImFusion::DataLink * >
 CSignalImpl< false, ArgTypes... >< ImFusion::DataList >
 CSignalImpl< false, ArgTypes... >< ImFusion::DisplayOptions2d * >
 CSignalImpl< false, ArgTypes... >< ImFusion::DisplayOptions3d * >
 CSignalImpl< false, ArgTypes... >< ImFusion::Flags< ResetOptions > >
 CSignalImpl< false, ArgTypes... >< ImFusion::GlSlice * >
 CSignalImpl< false, ArgTypes... >< ImFusion::GlVolumeView * >
 CSignalImpl< false, ArgTypes... >< ImFusion::GUI::View * >
 CSignalImpl< false, ArgTypes... >< ImFusion::Ilium * >
 CSignalImpl< false, ArgTypes... >< ImFusion::KinectAzureStreamPlaybackAlgorithm::Capture * >
 CSignalImpl< false, ArgTypes... >< ImFusion::LabelDataComponent * >
 CSignalImpl< false, ArgTypes... >< ImFusion::OrientedVertebra * >
 CSignalImpl< false, ArgTypes... >< ImFusion::RGBDStream * >
 CSignalImpl< false, ArgTypes... >< ImFusion::Sacrum * >
 CSignalImpl< false, ArgTypes... >< ImFusion::Seg::Structure * >
 CSignalImpl< false, ArgTypes... >< ImFusion::SpinePolyRigidRegistration::SimilarityResult >
 CSignalImpl< false, ArgTypes... >< ImFusion::StreamRecorder * >
 CSignalImpl< false, ArgTypes... >< ImFusion::TrackingStreamRecorder * >
 CSignalImpl< false, ArgTypes... >< ImFusion::US::SweepCalibrator * >
 CSignalImpl< false, ArgTypes... >< ImFusion::US::UltrasoundSweep * >
 CSignalImpl< false, ArgTypes... >< int >
 CSignalImpl< false, ArgTypes... >< int, int >
 CSignalImpl< false, ArgTypes... >< isom3 >
 CSignalImpl< false, ArgTypes... >< MarkerConfiguration::MarkerType >
 CSignalImpl< false, ArgTypes... >< Mode >
 CSignalImpl< false, ArgTypes... >< QModelIndex >
 CSignalImpl< false, ArgTypes... >< QString >
 CSignalImpl< false, ArgTypes... >< Qt::MouseButton >
 CSignalImpl< false, ArgTypes... >< Robotics::JointPosition >
 CSignalImpl< false, ArgTypes... >< std::chrono::system_clock::time_point, const ImFusion::MemImage & >
 CSignalImpl< false, ArgTypes... >< std::chrono::system_clock::time_point, const isom3 & >
 CSignalImpl< false, ArgTypes... >< std::optional< isom3 > >
 CSignalImpl< false, ArgTypes... >< std::shared_ptr< const ImFusion::Robotics::RobotState > >
 CSignalImpl< false, ArgTypes... >< std::shared_ptr< ImFusion::SharedImage > >
 CSignalImpl< false, ArgTypes... >< std::shared_ptr< ImFusion::TrackingSequence > >
 CSignalImpl< false, ArgTypes... >< std::size_t >
 CSignalImpl< false, ArgTypes... >< std::string >
 CSignalImpl< false, ArgTypes... >< std::vector< ImFusion::ImageDescriptor > >
 CSignalImpl< false, ArgTypes... >< StopReason >
 CSignalImpl< false, ArgTypes... >< StopReason, int >
 CSignalImpl< false, ArgTypes... >< vec2 >
 CSignalImpl< false, ArgTypes... >< vec2i >
 ►CSignalMutexProxy< UseMutex >
 CSignalMutexProxy< false >
 CSignalMutexProxy< true >
 ►CSignalReceiverBase class for classes that can contain slots (i.e
 ►CSimilarityMeasurePatchBased_GLHelper class for patch based similarity measures
 CSpinePolyRigidRegistration::SimilarityResultComputes the optimal similarity, stores the result in p_offset
 ►CSimpleROSListenerInterfaceConvenience interface that wraps ROS subscribers
 ►CSimpleROSPublisherInterfaceConvenience interface that wraps ROS publisher
 ►CSimpleROSServiceCallerInterfaceConvenience interface that wraps ROS service clients
 ►CSimpleROSServiceServerInterfaceConvenience interface that wraps ROS service servers
 CSimplificationSettings
 CSimulatorFrameContainer for a rendered simulator frame of the SimulatorRenderer
 CSimulatorRendererRenderer for simulating RGB-D sensor output from 3D models
 CSingleton< T >Base class for singletons
 CSingleton< T >Singleton wrapper template for type T
 CSingleton< T >Base class for singletons
 ►CSinkInterface for a logger sink that can receive individual log events
 CSkeletonization< T >Skeletonization in 2D and 3D see [Lee TC, Kashyap RL, Chu CN
 CSliceRepresents a planar bounded slice in 3D space
 CRendererFactory::SliceRendererDescriptor of a registered slice renderer
 CSpaceInfoSimple structure representing the total and remaining disk space
 CSpan< ElementType, Extent >Describes a non-owning view into contiguous sequence of elements
 CSparseSharedImageSetRepresentation of a SharedImageSet with N images with the same descriptor of which only M (<N) are used at the same time
 COperation::SpecsSpecifications required to fully instantiate an operation
 CSpherePivotResult
 CSpine2DModelNamesModel identifiers and parameter names supported by the SpineLocalizatin2D algorithm,
 ►CSpineAlgorithmAdapterInterface
 ►CSpineBinaryMetricInterface}
 CSpineCache
 CSpineEvaluation< Data >
 ►CSpineEvaluation< ClassificationInputData >
 ►CSpineEvaluation< LocalizationInputData >
 ►CSpineEvaluation< SegmentationInputData >
 CSpineEvaluationIterator< Data >Base class iterator for individual scans and their label/meta data Lets its subclasses handle the loading
 ►CSpineSegmentationMetricInterfaceSegmentation metrics {
 CSplineUniform Catmull-Rom spline
 CMarkerConfiguration::STagInfoInformation about a single STag
 CStashEntry< expr_type >
 CStashEntry< double >
 CMeshDistanceAlgorithm::Stat
 COptimizerBFGS::State
 CStream::StateChange
 CStateGuardGuard to easily save and restore critical (modern) OpenGL state
 CConeBeamCalibration::StatisticsStruct holding statistics of the calibration
 CStatistics
 CStatusConvenience tool for returning error messages together with statuses
 CStereoImageThis class stores a pair of images, taken by a stereo camera at the same time point
 CStereoRectificationPerforms stereo rectification und unrectification on images
 CStereoStreamToVideoRecorderRecords stereo image streams to two video files The algorithm internally uses VideoFileRecorder to save videos
 CStreamAlgorithmExecutorPayloadWork item for the StreamAlgorithmExecutor
 CImageStreamCache::StreamCacheElement
 ►CStreamDataBase class for all data streamed from a streaming device
 CStreamingMotionGenerator< PositionType >Motion generators which do not represent a finite motion from A to B, but can follow a moving target The end of the motion can be automatically emitted when reaching the target or upon request
 ►CStreamingMotionGenerator< isom3 >
 ►CStreamRecorderAbstract base class for stream recorders
 CStreamSharedImageSetWrapper around a streamed SharedImageSet
 CStreamToVideoRecorder
 ►CStreamType
 CStringAccepterHelper class to enable the convenience Properties constructor taking an initializer list
 CStructureStatisticsStruct collecting statistics about a Structure
 CStylePseudoClassKnown modifier keys. In analogy to CSS, we refer to modifiers of this type as "pseudo-classes"
 CUrl::SubqueryA Subquery represents part of a query delimited by '&' or ';'
 ►CSubstreamBaseNon-templated base class for substreams
 CSuperpixelClass representing a superpixel
 ►CSurfaceReconstructionAbstract interface for surface reconstruction from RGB-D data
 CSurfaceReconstructionDataListener
 CBoneSegmentationAlgorithm::SweepDetectionResultsData structure to store the detections results for a given sweep
 ►CSweepOptimizationClass that factors out the parametrization of an UltrasoundSweep as needed for registration, motion estimation and calibration
 CSweepRecorderController::SweepsTrackings
 ►CT
 CTableA 2D table with named columns, containing strings and numbers
 CTableModelViewRepresents a QTableView, and the container ItemViewWidget. The model can be accessed in ItemViewWidget::model or QTableView::model
 Ctag
 CTaggingIndexIn order to tag leafs in an expression we need to be able to re-identify leafs which represent the same information
 CTagProxy
 CTC< class >
 CTemplateWrapper< T, RemainingDimensions, NumberOfDimensions >
 CTemplateWrapper< T, 0, NumberOfDimensions >
 CTensorImplementation of a Tensor class; used in TensorDataElement to directly present data to a neural network
 CTensorFactoryFactory for creating standard type tensors up to a certain maximum rank
 CProgram::TextureBinding
 CImFusionTfManager::TfTransform
 ►CThreadSafeInstrumentsBaseNon-templated and fully abstract base class for ThreadSafeInstruments
 CTiffIOClass for reading and writing TIFF images
 CTimePointClass representing a point in time, keeping track of UTC offsets and time zone name, if available
 CTimestampedPayload< T >Helper struct uses as container for the BackgroundThreadQueue data elements
 CUltrasoundConeCalibrationAlgorithm::TipRepresents a detected cone tip
 CTopicMetadata
 CMesh::TopologyErrorsAdds a new face, consisting of the 3 existing(!) vertices specified by their indices
 ►CTorqueControllerBaseBase class for generic robot controllers
 CSliceViewDefaultEventHandler::TouchActionConfigRecord to define which touch events should be processed and how
 CTouchActionsSpecifies actions with one-finger and two-fingers gestures
 CUltrasoundConeCalibrationAlgorithm::TrackedConeRepresents a cone detected in an ultrasound sweep across multiple frames
 CTrackerIDClass identifying a tracker via a unique ID
 CTrackingEvaluation
 CTrackingInstrumentClass for information of a tracking instrument
 CTrackedSharedImageSetProperties::TrackingParameters
 CTrackingSequenceTableParameters
 CTrackingSequence::TrackingTupleTuple returned by iterator, similar to std::pair used when iterating over maps
 CTransferFunctionFactoryCollection of factory functions for transfer function presets
 CTransform< To, From, EigenType >The Transform class provides a transformation from a Frame to another Frame, where each Frame is a coordinate system
 CTransform< GlobalCS::Data, TrackingCS::Tracker >
 CTransform< GlobalCS::World, GlobalCS::Data >
 CTransform< RobotJointPtr >
 CTransform< TrackingCS::Tracker, TrackingCS::Calibrated >
 CTransformFilterBase< T >
 ►CTransformFilterBase< isom3 >
 ►CTransformMessage
 ►CTreeFactoryTree factory base class
 CTriangleClass representing a triangle in 3D space
 ►CTriMesh_ArrayKernelT
 ►Ctrue_type [external]
 ►CTs...
 ►Cconditional::type
 CTypeFactoryFactory class handling Igtl types
 CTypeWrapper< WrappedT >
 CUltrasoundCalibrationInitHelper class for the geometric computations needed in the UltrasoundCalibrationWizardAlgorithm
 CUltrasoundMediumStruct for medium properties used in ultrasound simulation
 Cunary_type_trait< cond, Op, OperandT >Type trait
 Cunary_type_trait< true, Op, OperandT >
 ►CUnaryImgOpGl
 CUndoLevel
 CUndoRecorderSimple class to keep track of data changes in a SharedImageSet
 CUndoSerializerSerializes undo levels into (binary) files and restores the whole stack of undos from these files writeUndoFile() can be repeatedly called asynchronously, restoreUndoStack() should be called once
 CUnexpected< E >
 CUniqueIdHelper struct to uniquely describe a type of annotation
 CUnusedSpecialPlaceholder struct for the extra container
 CUrlEntity representing a URL (Uniform Resource Locator)
 CUrlQueries
 ►Cvariant< Types... > [external]
 CVector< From, EigenType >Class representing a vector, defined in a Frame
 ►Cvector< Eigen::Matrix< InsideScalar, InsideDimension, 1 > > [external]
 CVersionUtility class to work with version information following the SemVer format
 CImFusionPlugin::VersionInfo
 CVertebraEvaluationInstanceInstance of vertebra for segmentation evaluation
 CFixedFunctionPipeline::VertexData< PosT, TexCoordT, ColorT >Utility struct to build a VertexBuffer to be used with FixedFunctionPipeline in a type-safe fashion
 CVertexExpr< T >
 ►CVertexExpr< BinaryOpExpr< T, Q, add > >
 ►CVertexExpr< EigenExpr< false > >
 ►CVertexExpr< MatMulExpr< T > >
 ►CVertexExpr< MeshExpr< true > >
 ►CVertexExpr< PointCloudExpr< true > >
 ►CVertexExpr< ScalingExpr< T > >
 ►CVertexExpr< VectorExpr< T > >
 CVideoCameraStream::VideoCameraDeviceInfo
 CVideoCameraIoFactoryFactory for VideoCameraStreams used by the framework, in particular the VideoStreamIoAlgorithm and associated controller
 CVideoDecoderVideoDecoder is responsible of processing the received ByteBuffer which contains the image data
 CVideoEncoder
 CVideoFileRecorder
 CVideoCameraStream::VideoStreamFrameFormat
 ►CVideoStreamSettingsBaseBase class for all video stream settings
 CViewGroupAdapterHelper class providing the API of ViewGroup while wrapping around either a ViewGroup or a GUI::RadiologyViewGroup
 CViewportStructure describing an OpenGL viewport
 CViewStateEncapsulates the OpenGL view state defined by the viewport, a projection matrix and a model-view matrix
 CGlView::ViewStateGuardTemporarily changes the GL::ViewState of a GlView and resetting to the original value on destruction
 CVisionLegacy computer vision algorithms for CT
 CRobotLinkDescription::Visual
 CRendererFactory::VolumeRendererDescriptor of a registered volume renderer
 CWebClientInterface for querying and retrieving objects from a DicomWeb compliant server
 CDisplayOptions2d::WindowLevelPresetWindow-level configuration that can be stored as a preset
 CStream::WorkContinuation
 CWorkspaceConversionFunctionStructure to describe a conversion of workspace files between different versions
 CWorkspaceConversionRegistrySingleton to manage registered workspace conversion functions and apply them to workspace file
 CWrapSimpleTypeResult< T >
 CZipArchiveClass representing a zip archive. A ZipArchive instance can create a zip archive, add/extract files/memory buffers to/from it
 CVolumeViewDefaultEventHandler::MouseDownState::ZRotation
Search Tab / S to search, Esc to close