| ►NImFusion | Namespace of the ImFusion SDK |
| ►NAnatomicalStructureProcessing | |
| CConvertToMultiLabelMap | Converts AnatomicalStructureCollection to a label map using the given reference image to define the image grid |
| CGenericASCFromMultiLabelMap | Converts a label map to an GenericAnatomicalStructureCollection using the given label map by converting individual label values to meshes |
| CMaskAnatomicalStructure | |
| CMoveFaceLabelsToHalfEdges | Helper algorithm to move face labels in meshes to half-edge labels |
| CSmoothMeshes | Replaces by the iso-surface of the distance-volume each contained mesh |
| ►NAnatomicalStructureRegistrations | |
| CAutomaticRegistration | Try various types of registration and run the "best" one |
| CDeformableMesh | Register two AnatomicalStructure instances by computing a deformable mesh registration over meshes contained in the Anatomical structure |
| CImageRegistration | Register two AnatomicalStructure instances by performing an image registration on the images contained in the Anatomical structure |
| CPointsAndPlanes | Register two AnatomicalStructure instances by matching keypoints |
| ►NAnatomyPlugin | Namespace of the anatomy plugin |
| ►Ndetail | |
| CCreator | Base class for creators to be registered in factory |
| CCreatorImpl | Wrapper around a std::function used for constructing an item Derived from Base |
| CStyleSheetListModel | |
| CStyleSheetsWidget | |
| CAnatomyControllerFactory | |
| CAnatomyPluginFactory | |
| CASCDataAnnotationFactory | |
| CFactory | Generic factory class for registering polymorphic types Usage: |
| CInspectStyleSheetsAlgorithm | This algorithm exists so that InspectStyleSheetsController can exist |
| CInspectStyleSheetsController | |
| ►CModelFactory | Factory for managing different versions of ML model sets globally |
| CMLEngine | Currently supported ML Engines (cf. ML::Engine) |
| CModelInfo | Holds the meta information about a single model |
| CModelSet | List of models |
| CRegistry | |
| CSelector | Style selector combining with logical OR multiple SelectorElem objects |
| CSelectorElem | Class for querying objects |
| CSingleton | Base class for singletons |
| CStylePseudoClass | Known modifier keys. In analogy to CSS, we refer to modifiers of this type as "pseudo-classes" |
| ►CStyleSheet | Class for managing a logically grouped set of style rules |
| CStyleRule | Single "style" entry consisting of a selector (that matches a subset of objects) and a set of property-value pairs (a Properties instance declaration) This is the fundamental build block of styling in the anatomy plugin |
| ►NAnimations | Animating objects within the ImFusion SDK |
| CAnimation | Helper class to define an animation, that is an interpolated transition between two states |
| CAnimationBackendBase | Base interface for managing and dispatching animations |
| CAnimationBackendDummy | Dummy implementation of the AnimationBackendBase interface that will not execute any animation but only call its update() function exactly once with t=1.0 |
| CAnimationBackendQt | Concrete implementation of AnimationBackendBase using the Qt event loop for dispatching the animation updates |
| CBlendingAnimation | Animates the blendFactor of an ImageView2D |
| CScopedEnabler | A scope guard to set the globally available enabled property for animations |
| CUniqueId | Helper struct to uniquely describe a type of annotation |
| ►NASCRegistrationMethods | |
| ►NICPUtils | |
| CPairedPointsWithMetadataVector | Lightweight helper structure to manage sets of paired points |
| CPointsWithMetadata | Helper struct to store points together with information about what structure the points are derived from |
| CAlignStructuresByTranslation | Tries to approximately align two structures by translating the moving structure |
| CICP | Align two AnatomicalStructureCollections using variants of the ICP algorithm |
| ►CModifyBehavior | Sets attributes that control registration behavior per structure |
| CPerStructureBoolean | Describes the behavior of individual structures for registration |
| CPerAnatomy | Template to convert a (per-structure) AnatomicalStructureRegistration into a ASCRegistration that acts on the structure collection |
| CPerAnatomyImageBasedRefine | The challenge with the raw PerAnatomy<ImageBasedRefine> is that if there are any registration sequence items before it, these will deform the moving structures but not the moving image, and so the moving structures and moving image go out of sync |
| CReturnError | Meta ASCRegistrationMethod that just returns an error |
| ►NAuthHelpers | |
| CEncryptedString | |
| ►NCompression | Data compression tools |
| ►Nzip | Compression using the ZIP file format |
| CEntryInfo | Info for an archive entry: |
| CError | Represents a zip/unzip error |
| CZipArchive | Class representing a zip archive. A ZipArchive instance can create a zip archive, add/extract files/memory buffers to/from it |
| ►Nzstd | Compression using Zstandard, a high speed compression algorithm still providing good compression ratios |
| CContext | When (de)compressing many times it is recommended to allocate the context only once and reuse it for each successive operations |
| ►NContainer | Collection of utility functions operating on STL containers |
| CLRUCache | Templated container class implementing a Least Recently Used Cache |
| ►NCreateStreamAlgorithmHelper | |
| CHelper | |
| CHelper< T, false > | |
| CHelper< T, true > | |
| ►NCT | X-ray and computed tomography |
| ►NConeBeamCalibrationUtils | Utilities for cone-beam calibration computations |
| CCalibrationSettings | Settings for calibrateCamera() |
| ►Ndetail | Internal implementation details for CT utilities |
| CCreator | Base class for factory "create" functionality |
| CCreatorImpl | Wrapper around a pair of std::functions used for constructing an item Derived from Base |
| CGlobalTransformationGeneratorBase | Base class for global transformation generators |
| CPerFrameTransformationGeneratorBase | Base class for per-frame transformation generators |
| CRelativeGeneratorMixin | Template mixin for relative geometry generators |
| CRelativeTransformationSetupWrapperBase | Base class for RelativeTransformationSetupWrapper which requires customer move and copy semantics due to signal connections it creates |
| CSparseSharedImageSet | Representation of a SharedImageSet with N images with the same descriptor of which only M (<N) are used at the same time |
| CTrivialConfigurable | Helper class for storing arbitrary Properties in a Configurable instance |
| ►NGeometryUtils | Utility functions for geometry processing and manipulation |
| CFullGeometryRepresentation | Struct for the collection off all components needed to represent the full geometry of a frame |
| ►NGridBasedDistortionCorrectionUtils | Utilities for grid-based distortion correction algorithms |
| CBeadDetection | Structure representing a detected calibration bead |
| ►Ninternal | |
| CHistoryEntryTableModel | Implementation details for history view, should not be used |
| CKeyPointWidgetInternal | The following class is used internally, the private implementation details are exposed here only to satisfy AutoMoc; this class should not be used |
| CAlgorithmReconstructionDecorator | Template decorator for algorithms requiring reconstruction capabilities |
| CAlgorithmReconstructionDecoratorController | Base controller for reconstruction algorithm decorators |
| CAlgorithmReconstructionDecoratorInterface | Base class interface for AlgorithmReconstructionDecorator |
| CAnisotropicTV | Anisotropic Total Variation functional |
| CAsdPocs | AsdPocs |
| CAutoFocusMotionCompensationAlgorithm | Compensating for rigid motion in projection images |
| CAutoFocusMotionCompensationAlgorithmController | GUI controller for auto-focus motion compensation algorithm |
| CBeamHardeningCompensation | BeamHardeningCompensation |
| CBlock | Base class for pipeline processing blocks |
| CBlockMixin | Mixin pattern to use any Algorithm as Block |
| CCBCTPostProcessing | CBCTPostProcessing performs a cone cropping of a CT volume |
| CCBCTProjector | Abstract base class for Cone-Beam Computed Tomography (CBCT) projectors |
| CCG | Conjugate Gradient (CG) algorithm |
| ►CConeBeamCalibration | Geometric calibration algorithm for X-ray imaging systems |
| CPhantom | Struct specifying phantom layout |
| ►CPointExtractionParams | |
| CEllipseParams | |
| CPointInfo | Information about extracted points |
| CStatistics | Struct holding statistics of the calibration |
| CConeBeamDataDisplayHandler | Display handler for cone-beam data visualization |
| CConeBeamDisplayOptions | Data component for cone-beam display configuration |
| CConeBeamFramePars | Stores and handles individual per-frame transformation parameters |
| CConeBeamGeometry | Legacy cone-beam geometry representation |
| CConeBeamGeometryController | GUI controller for cone-beam geometry parameter editing |
| CConeBeamGeometryVisualisation | Visualization component for cone-beam geometry |
| CConeBeamMetadata | Data component for cone-beam projection metadata |
| CConeBeamReconLoader | I/O algorithm for loading cone-beam reconstruction data |
| CConeBeamReconLoaderExtra | Loading and pre-processing of data from various CBCT devices |
| CConeBeamSimulation | Algorithm for simulating cone-beam X-ray projections from CT volumes |
| CConeBeamSimulationController | GUI controller for cone-beam simulation algorithm |
| CConeBeamSimulationOperation | ML operation for simulating X-ray projections from CT volumes |
| CConvertToConeBeamData | Algorithm for converting DICOM projection data to ConeBeamData format |
| CConvolutionFilter | Convolution filter implemented as LinearOperator |
| CCopyConeBeamGeometryAlgorithm | Algorithm for copying cone-beam geometry between datasets |
| CCropFanEventHandler | CropFanEventHandler |
| CCTDataAnnotationFactory | Factory for CT-specific data annotations |
| CCTPlugin | ImFusion plugin for CT module algorithms and components |
| CDetectorDataComponent | DataComponent to store the transformation from world to detector space for a single frame |
| CDetectorPropertiesDataComponent | Data component for detector properties and configuration Stores detector-specific parameters and settings for cone-beam systems |
| CDiagonalOperator | Base class for diagonal matrix linear operators |
| CDiagonalOperatorTpl | LinearOperator that multiplies each pixel by an ImageMath expression |
| CDicomMultiFrameConeBeamIOD | Dicom IOD for loading ConeBeamData from an enhanced multi-frame file |
| CDicomSingleFrameConeBeamIOD | Dicom IOD for loading ConeBeamData from individual files |
| CEos2D3DRegistrationAlgorithm | 2D-3D registration algorithm for the EOS imaging system |
| ►CEventHandler | Event handler |
| CEvent | |
| CEventHandlerWithTarget | Event handler for handlers which support to set a target event while the computation is independent of the Event::Phase |
| CFactory | Generic factory class for registering polymorphic types |
| CFDK | FDK (Feldkamp-Davis-Kress) algorithm for cone-beam CT reconstruction |
| CFiniteDifferences | Finite differences operator for image gradients |
| CFullGeometryRepresentationWrapper | |
| CFunctional | Abstract functional interface for optimization problems |
| CGeometryAlgorithm | Algorithm for applying geometry settings to cone-beam data |
| CGeometryGenerator | Base class for X-ray geometry generators |
| CGeometryGeneratorOptimizingAlgorithm | Optimizing algorithm for cone-beam geometry parameter estimation |
| CGeometryGeneratorParameterWrapper | Parameter wrapper for geometry generator optimization |
| CGeometrySelfCalibration | Auto-calibration algorithm for cone-beam geometry parameters |
| CGeometrySelfCalibrationController | GUI controller for geometry self-calibration |
| CGl2D3DRegistration | OpenGL-accelerated 2D-3D registration for cone-beam projections |
| CGl2D3DRegistrationController | GUI controller for OpenGL-based 2D-3D registration |
| CGlCBCTProjector | OpenGL-based cone-beam CT projector implementation |
| CGlConeBeamForward | Legacy OpenGL cone-beam forward projection |
| CGlFourierFilter1D | OpenGL-based 1D ramp filter for FDK reconstruction |
| CGlGeometryView | Legacy OpenGL geometry visualization |
| CGlProjectiveAnnotation | Light-weight wrapper to project a GlAnnotation onto a 2D fluoro shot |
| CGlProjectiveObject | OpenGL wrapper for projecting 3D objects onto 2D X-ray images |
| CGridBasedDistortionCorrection | Grid-based distortion correction algorithm for X-ray images |
| CGridBasedDistortionCorrectionController | GUI controller for grid-based distortion correction |
| CIdentityOperator | Identity linear operator implementation |
| CInitializer | Initializer |
| CIsotropicTV | Isotropic Total Variation functional |
| CIterativeOSSolver | Abstract iterative solver with ordered subsets support |
| CIterativeSolver | Abstract base class for iterative solvers |
| CL2Pow2 | L2 squared norm functional for data fidelity |
| CLaplaceOperator | Discrete Laplace operator for image regularization |
| CLeastSquaresIsotropicTV | Least-squares optimization problem with isotropic total variation regularization |
| CLinearOperator | Abstract linear operator interface with adjoint |
| CLinearOperatorAdjointWrapper | Wraps a given linear operator, and represents its adjoint as a linear operator |
| CLinearOperatorEvalInputExpr | Specialization of LinearOperator which lets the user choose whether the ImageMath input expressions must be evaluated into a temporary before apply() or applyAdjoint() |
| CLinearOperatorEvalInputExpr< false > | Template instantiation for the case where input ImageMath expressions are evaluated by the class directly |
| CLinearOperatorEvalInputExpr< true > | Template instantiation for the case where the input expression is always be evaluated inuto a temporary |
| CLinearOperatorTreeNode | Composite pattern for linear operator expression trees |
| CLinearResidual | Linear residual for tomographic reconstruction |
| CLoggingHandler | EventHandler to log optimization |
| CLRUCacheMixin | Mixin pattern to add an lru cache to any Block |
| CMatrixLinearOperator | Linear operator wrapping an explicit matrix |
| CMemoryManager | Memory manager |
| CMesh2D3DRegistrationAlgorithm | Algorithm for 2D-3D registration using mesh-based synthetic CT generation |
| CMesh2D3DRegistrationController | GUI controller for mesh-based 2D-3D registration |
| CMetalArtifactReduction | Metal artifact reduction algorithm for CT reconstruction |
| CMLEM | MLEM (Maximum Likelihood Expectation Maximization) algorithm |
| CMLVolumeInference | |
| CMotionModelGenerator | Geometry generator using motion models for complex trajectories |
| CNesterovStep | NesterovStep |
| ►COptimizationProblem | Optimization problem formulation for tomographic reconstruction |
| CRegTerm | |
| CRegTermOwning | |
| CParametricGeometryGenerator | Parametric geometry generator for regular CBCT acquisition trajectories |
| CPointExtraction | Utility class for extracting calibration points from images |
| CPositivityHandler | PositivityHandler |
| CProjectionLoader | Abstract base class for X-ray projection image loaders |
| CProjectionMatrixIoAlgorithm | I/O algorithm for saving and loading projection matrices |
| CProjectionPreProcessing | Pre-processing of projection images |
| CProjectionPreProcessingAlgorithm | Algorithm for X-ray projection image pre-processing |
| CProjectionSets | Computation of projection subsets for iterative reconstruction |
| CRadonTransformAlgorithm | Algorithm for computing 2D Radon transform |
| CRandomConeBeamSimulationOperation | Randomized cone-beam simulation operation for data augmentation |
| CRandomSimulateCBCTOperation | Randomized CBCT simulation operation for data augmentation |
| CRandomXRayFixtureOperation | Randomized X-ray fixture operation for data augmentation |
| CRandomXRaySamplingOperation | Randomized X-ray sampling operation for data augmentation |
| CRandomXRayUndoLogConversionOperation | Randomized X-ray log conversion reversal operation |
| CReconstructionAlgorithm | Algorithm for tomographic reconstruction |
| CRelativeGlobalTransformationGenerator | Geometry generator for single relative transformation applied to all frames |
| CRelativePerFrameTransformationGenerator | Geometry generator for individual relative transformations per frame |
| CRelativeTransformationConfig | Configuration structure for relative transformation setup |
| CRelativeTransformationSetupWrapper | This class handles signal connections and ensures reconnecting after copying etc |
| CRingArtifactReduction | Ring artifact reduction algorithm for cone-beam CT |
| CSART | SART (Simultaneous Algebraic Reconstruction Technique) algorithm |
| CSequentialMotion | Legacy sequential motion analysis for CBCT data |
| CSimulateCBCTOperation | ML operation for CBCT simulation and sampling |
| CSingleton | Singleton wrapper template for type T |
| CSmoothCTEdgesOperation | ML operation for smoothing CT volume edges |
| CSnapshotGenerator | Geometry generator for capturing current geometric state |
| CSolver | Abstract base class for optimization solvers |
| CSourceDataComponent | Data component for cone-beam X-ray source parameters |
| CSQS | SQS (Separable Quadratic Surrogate) algorithm |
| CStatisticallyWeightedLeastSquaresProblem | Statistically weighted least-squares optimization problem |
| CSyntheticCTFromMeshAlgorithm | Algorithm for creating synthetic CT volumes from mesh data |
| CWeightedL2Pow2 | Weighted L2 squared norm functional with diagonal weighting matrix |
| CXRay2D3DRegistrationAlgorithm | High-level 2D-3D registration algorithm for X-ray projections |
| CXRay2D3DRegistrationAlgorithmController | Controller for the XRay2D3DRegistrationAlgorithm |
| CXRay2D3DRegistrationHistoryEntry | Data structure for storing 2D-3D registration history |
| ►CXRay2D3DRegistrationInitialization | Abstract interface for custom 2D-3D registration initialization methods |
| CInitializationResult | |
| CXRay2D3DRegistrationInitializationController | GUI controller for 2D-3D registration initialization methods |
| CXRay2D3DRegistrationInitializationKeyPoints | 2D-3D registration initialization using keypoint correspondences |
| CXRay2D3DRegistrationInitializationKeyPointsController | GUI controller for keypoint-based registration initialization |
| CXRay2D3DRegistrationInitializationPointDirection | 2D-3D registration initialization using point-direction pairs |
| CXRayFixtureOperation | ML operation for applying virtual fixture to X-ray images |
| ►CXrayFunctionalGroups | Module implementing PS 3.3 C.7.6.16 |
| CXrayFunctionalGroupMacro | |
| ►CXrayPositioning | DICOM IOD for cone-beam CT data |
| CZiehmImageSpotPositionSequence | This is a implementation private Ziehm tag Sequence see: https://www.ziehm.com/fileadmin/user_upload/row/Footer/DICOM_EN_28415_01_01_2018.pdf |
| CXRaySamplingOperation | ML operation for X-ray image sampling and processing |
| CXRayUndoLogConversionOperation | ML operation for reversing X-ray log domain conversion |
| ►NDateTime | Utility methods and classes related to date and time representation, including time zones |
| CTimePoint | Class representing a point in time, keeping track of UTC offsets and time zone name, if available |
| ►Ndetail | |
| CAnatomyItemWidget | |
| CBarItemWidget | |
| CFeatureKey | Used to uniquely identify a feature by name and kind (node/edge) |
| ►CGraphImpl | Helper struct representing a graph over a fixed set of nodes |
| CNode | |
| CisEqualityComparable | |
| CisMoveOnly | |
| CisRegular | |
| CRangeInputDialog | |
| ►NDicom | Low-level and intermediate-level interfaces for working with DICOM data |
| ►NUtils | Collection of utility functions to handle DICOM data |
| CDcmTagKeyStlComp | |
| CUrlQueries | |
| CBase | |
| ►CClinicalTrialSubjectDataComponent | Represents the Clinical Trial Subject Module https://dicom.nema.org/medical/dicom/current/output/chtml/part03/sect_C.7.html#table_C.7-2b |
| COtherProtocolID | |
| CClinicalTrialSubjectExtension | Extension that loads and saves the ClinicalTrialSubjectDataComponent |
| CCommonModule | Collection of the essential tags describing a Dicom data set combining |
| CConfigurableSequence | |
| CConfigurableSequenceItem | |
| CDatasetCache | Caching of DcmDataset loaded from different locations |
| CDatasetHandler | Read access handler for proprietary / non-standard DICOM image formats, or non-image datasets |
| CDatasetIodPair | Named pair of a DcmDataset and the corresponding IOD |
| CDatasetModuleList | A stub that allows to use a Module with a DcmItem alone (without deriving some class from ModuleList) |
| CDatasetPreviewLabel | A widget that shows a preview image of a DICOM dataset |
| CDicomGeSignaExciteIOD | Extra IOD specialization for basic support of loading 4D MRI sequences created by GE Signa Excite devices |
| CDicomParameter | A specialized Parameter<T> class that can additionally serialize from and to DICOM |
| CDicomParameterBase | Internal type-erased base class for DicomParameter<T> |
| CDicomParameterHelper | Helper functions to load and save all DicomParameters of a Configurable |
| CDicomSegIoAlgorithm | |
| CDimensionsInfo | Describes with which dimensions a series will be loaded |
| CElement | Dicom Element with a concrete value type |
| CElementBase | Abstract base class for DICOM Elements |
| CElementList | Interface for classes that consist of Elements |
| CEncryptedAttributesExtension | |
| ►CEnhancedMultiFrameImageIOD | Class representing Enhanced CT Image IOD (PS 3.3 A.38) |
| CDimensionIndexSequenceItem | |
| ►CFunctionalGroupMacro | This is a simplified implementation of the function group macros |
| CFrameContentSequenceItem | |
| CSegmentIdentificationSequenceItem | |
| CError | Structure for storing errors occurring during loading/saving DICOM data |
| CErrorRecorder | Error handling interface for the Dicom module |
| CExtension | Interface for adding custom functionality to DicomLoader and DicomWriter An Extension might be called in a thread that is not the main thread |
| CFrameDescriptor | Descriptor for a single DICOM frame that is used during the loading process as intermediate representation before eventually converting the image data to a SharedImageSet |
| ►CGeneralEquipmentExtension | General Equipment Module (PS 3.3 C.7.5) Only considers tags that are part of the GeneralEquipmentModuleDataComponent |
| CGeneralEquipment | |
| CGeneralEquipmentModuleDataComponent | DataComponent mirroring the DICOM General Equipment Module |
| CImage | |
| CImagePixel | Image Pixel Module (PS 3.3 C.7.6.3) |
| ►CImagePlane | Image Plane Module (PS 3.3 C.7.6.2) |
| CDetectorInformationSequence | C.8.4.11 NM Detector Module |
| CIOD | Base class of a Dicom Information Object Definition (IOD) |
| CIOD_Registry | A registry that assigns a IOD implementation to a SOP class UID |
| ►CModalityLUT | Modality LUT Module (PS 3.3 C.11.1) |
| CLutItem | |
| CModule | Base class for Dicom Modules |
| CModuleList | Interface for classes that consist of modules |
| CMultiFrameImageIOD | Base IOD for classic DICOM files |
| COverlayAnnotation | The OverlayAnnotation displays any DICOM overlay stored in a OverlayDataComponent |
| COverlayDataComponent | DataComponent providing DICOM overlays |
| CPacsSeriesProxy | Proxy item to represent Series that exist on the PACS but have not yet been downloaded completely |
| CPatient | |
| CPixelSpacingCalibration | Basic Pixel Spacing Calibration Macro (PS 3.3 Table 10.7) Pixel Measures Macro (PS 3.3 Table C.7.6.16-2) |
| CRealWorldValueMappingExtension | Real World Value Mapping Macro (PS 3.3 C.7.6.16.2.11) |
| ►CReferencedInstancesComponent | DataComponent to store DICOM instances that are referenced by the dataset |
| CReferencedInstance | |
| ►CRTStructureDataComponent | DataComponent for PointClouds loaded from a DICOM RTStructureSet |
| CContour | Represents a single item in the original 'Contour Sequence' (3006,0040) |
| CRTStructureDataController | A DataController for PointClouds that contain a RTStructureDataComponent |
| CRTStructureDataDisplayHandler | DataDisplayHandler for PointClouds that represent DICOM RT Structs |
| CRTStructureDatasetHandler | A DatasetHandler for loading DICOM RTStructureSet |
| ►CRTStructureRenderingDataComponent | Internal rendering data that represent a RT Structure |
| CPolyline | |
| CScanner | Scan different locations for DICOM files |
| CScannerQt | A scanner with Qt interop |
| CSegmentationStorageIOD | Class representing Segmentation IOD |
| ►CSegmentItem | Element in the (0062,0002) SegmentSequence |
| CSegmentedPropertyCode | |
| CSequence | Concrete sequence of items of type T, which must be derived from SequenceItem |
| CSequenceBase | Abstract base class for a sequence of elements |
| CSequenceItem | Base class for sequence items |
| CSeries | |
| CSettingsWidget | Simple Qt widget to configure the DicomPluginSettings |
| CSourceInfoComponent | DataComponent to store the mapping of SharedImage to the DICOM URIs (such as file names) used for loading |
| CStudy | |
| CTagProxy | |
| CTagsWidget | Widget to display dicom tags |
| Cvalue_error | Exception specialization for DICOM element retrieval |
| CVOILUTExtension | VOI LUT Module (PS 3.3 C.11.2) Loads and saves windowing related values to and from DisplayOptions2d |
| CVolumetricImageIOD | The VolumetricImageIOD is a generic IOD for volumetric data that is stored slice by slice |
| CWebClient | Interface for querying and retrieving objects from a DicomWeb compliant server |
| ►NDiffusionNet | |
| CDiffusionNetOperators | Populates inputs required for running DiffusionNet architecture (https://arxiv.org/abs/2012.00888) for learning on 3D shapes |
| ►NEndoscopy | |
| CEndoscopicToolSegmentation | |
| CEndoscopicToolSegmentationAlgorithm | Algorithm for segmenting endoscopic tools in image sequences |
| CEndoscopicToolSegmentationCustomModel | Endoscopic tool segmentation using a custom machine learning model |
| CEndoscopicToolSegmentationFactory | |
| CLiteTracker | |
| ►NFilesystem | Classes and functions to manipulate files and directories, and the paths that identify them |
| CDirectory | Entity representing a Directory in the filesystem |
| CFile | Entity representing a file in the filesystem |
| CPath | Entity representing a path in the filesystem |
| CSpaceInfo | Simple structure representing the total and remaining disk space |
| CTemporaryDirectory | Temporary directory which deletes itself upon going out of scope |
| CTemporaryFile | Temporary file which deletes itself upon going out of scope |
| ►CUrl | Entity representing a URL (Uniform Resource Locator) |
| CRelativeTag | |
| CSubquery | A Subquery represents part of a query delimited by '&' or ';' |
| ►NFramework | Namespace containing general framework initialization methods |
| CInitConfig | Record to configure the initialization of the ImFusion SDK |
| CPluginInfo | |
| ►NGeometry | Classes to represent geometric primitives like lines or polygons, as well as functions dealing exclusively with such objects |
| CAlignedBox | Class representing an axis aligned rectangular cuboid in 3D space |
| CAlignedRectangle2D | Class representing an axis aligned rectangle in 2D space |
| CCircle | Class representing a circle (actually a disk, so including the inner part) in 3D space |
| CEllipse2D | Class representing an ellipse in 2D space |
| CLine | Class representing a full line, i.e |
| CLineBase | Common interface of Line and LineSegment |
| CLineSegment | Class representing a line segment, i.e |
| CPlane | Class representing an oriented plane in 3D space defined by a base point and a normal direction |
| CPolygon2D | Class representing a planar polygon |
| CRectangle | Arbitrary rectangle in 3D space |
| CSpherePivotResult | |
| CTriangle | Class representing a triangle in 3D space |
| ►NGL | Low-level OpenGL Wrappers |
| ►NDebug | The GL::Debug namespace contains functions and class to help with debugging OpenGL calls |
| CGroup | Allows to group a set of OpenGL calls together |
| COpenGlException | Specialization of std::runtime_error that also stores the original OpenGL error code |
| ►CAbstractInclude | Base class for abstract GLSL includes |
| CFingerprint | AbstractIncludes provide a fingerprint to simplify duplicate detection |
| CAtomicCounterBuffer | Specialization of Buffer for OpenGL Atomic Counter Objects |
| CBlending | Helper class to configure the OpenGL blending stage |
| CBuffer | Wrapper class for OpenGL Buffer Objects |
| ►CContext | Base class for low-level OpenGL context handling within the ImFusion SDK |
| CCreateInfo | |
| CContextGLX | OpenGL context using GLX as backend |
| CContextManager | Singleton class to manage access to OpenGL contexts |
| CContextWindows | OpenGL context using WGL as backend |
| ►CFixedFunctionPipeline | Convenience class for a shader implementing a basic fixed function rendering pipeline |
| CVertexData | Utility struct to build a VertexBuffer to be used with FixedFunctionPipeline in a type-safe fashion |
| CFramebuffer | Wrapper class for OpenGL Framebuffer Objects (FBO) |
| CFullscreenSquare | Helper class to easily render a full-screen quad |
| ►CImageProgram | Convenience class to execute a GLSL fragment shader on an image or volume |
| CCuboid | Utility class to specify the (sub-) region of the textures to execute the shader on |
| CIndexBuffer | Specialization of Buffer to store vertex index data (GL_ELEMENT_ARRAY_BUFFER) |
| CInstanceManager | Concrete CRTP class for context-aware caching of OpenGL object instances |
| CInstanceManagerBase | Base class for context-aware caching of OpenGL object instances |
| CInternalFormat | Describes an internal texture format that you can request from OpenGL |
| ►CLineRenderer | Convenience class for a shader implementing thick and stippled line rendering |
| COptions | Helper struct to encapsulate all supported rendering options |
| CMemoryInfo | Structure storing information about the available video memory as reported by OpenGL |
| CMultiAbstractInclude | Concrete type for an instance of a Multi-AbstractInclude |
| CMultiAbstractIncludeBase | Non-templated base class of MultiIncludable to implement polymorphic interface |
| CMultiIncludable | Multi-AbstractIncludes allow for using multiple instances of the same AbstractInclude type in one shader |
| ►CObjectPicking | Helper class to consolidate functionality for implementing object picking of rendered geometry |
| CPickingInfo | Structure encoding picking information for a single pixel |
| ►COffscreenRenderHelper | Helper class to perform deferred off-screen rendering |
| CRenderBuffer | Helper structure to encapsulate OpenGL objects representing the temporary rendering buffer |
| COpenGLNotFoundException | Specialization of std::runtime_error indicating that OpenGL was not able to initialize correctly |
| COrderIndependentTransparency | Helper class to consolidate functionality for implementing order-independent transparency of rendered geometry |
| CPlatformInfo | Structure storing information on the GPU/driver/OpenGL context configuration |
| ►CProgram | OpenGL GLSL program with a fragment and optional vertex and geometry shader |
| CAbstractIncludeStruct | Struct for representing an abstract include object |
| CBufferBinding | Struct to keep track of GlBuffers bound shaders as SSBOs |
| CImageBinding | |
| CShaderInfo | Encapsulates information about each shader stage |
| CTextureBinding | |
| CProgramCache | Helper class to manage instances of the same base shader with different abstract includes and/or defines |
| CProgramDecorator | Interface to apply custom arguments to a shader program |
| CSampler | Sets texture sampling parameters for a specific texture unit |
| CShaderStorageBuffer | Specialization of Buffer for OpenGL Shader Storage Buffer Object |
| CStateGuard | Guard to easily save and restore critical (modern) OpenGL state |
| CSyncObject | Helper class to synchronize between multiple OpenGL contexts or a context and the application |
| ►CTextRenderer | Utility class to perform text rendering with OpenGL |
| CFont | Struct to describe font settings such as font family, size, or decorations |
| CTexture | Wrapper of an OpenGL Texture to store image data on the GPU |
| CVertexArrayObject | Wrapper around an OpenGL Vertex Array Object (VAO) to define the vertex attribute specification for rendering |
| CVertexBuffer | Specialization of Buffer to store vertex array data |
| CViewport | Structure describing an OpenGL viewport |
| ►CViewState | Encapsulates the OpenGL view state defined by the viewport, a projection matrix and a model-view matrix |
| CPixelIncrementWorld | Helper struct to store the result of unprojectPixelIncrementOrtho() and unprojectPixelIncrementPerspective() |
| ►NGraphUtils | |
| ►CGraphImpl | Helper struct representing a graph over a fixed set of nodes |
| CNode | |
| ►NGUI | Generic Abstraction Layer for Visualization and User Input Events |
| CBoxAnnotationEventHandler | Event handler for creating and editing Box annotations |
| CButtonOverlay | ViewOverlay representing a clickable button |
| CColorBarOverlay | |
| CContextMenuEvent | A ContextMenuEvent signals that a context-sensitive popup menu was requested by the user, for instance by a click with the right mouse button |
| CDisplay | Basic version of a display surface hosting a set of Views, rendering them, and distributing input events to them |
| ►CDisplayAutoLayouter | This class facilitates the layouting of Views inside a Display by encapsulating logic to generate layouts for dynamic view configurations based on a customizable set of layouting algorithms |
| CLayoutAlgorithm | Interface to derive from to define custom display layout algorithms |
| CLayoutInfo | Record of information passed to LayoutFunction::createLayout() |
| CDisplayBase | Common base class interface of GUI::Display and DisplayWidget enabling other parts of the framework to access the most basic functionality in a general fashion |
| CDisplayLayout | Tiling-based layouting class for arranging Views inside a Display in a non-overlapping fashion |
| ►CDisplayLayoutConfig | The DisplayLayoutConfig serves as static "snapshot" of the view configuration of a DisplayLayout |
| CLayoutCell | One cell in the grid |
| CEventResult | Simple record intended to be used as return value of the a handleInputEvent() function to indicate how to proceed |
| CHistogramOverlay | ViewOverlay to show an intensity histogram of the first shown image in a SliceView |
| CInfoOverlay | Interface for a ViewOverlay to show textual information depending on the mouse cursor position (for instance: pixel information of an image, face/vertex info of a mesh) |
| CInputEvent | Base class for user input events in a graphical user interface (GUI) |
| CInputEventMapper | Specialization of InputEventMapperBase with a templated action enumeration type to increase type safety |
| ►CInputEventMapperBase | Helper class to maintain a map of mouse/keyboard combinations to an enumeration of actions |
| CKeyboardMapping | |
| CMouseMapping | |
| CKeyEvent | Key events are triggered when a keyboard key was pressed or released on the GUI |
| CLiftChartOverlay | Wrapper of a GlLiftChartOverlay implementing the ViewOverlay interface so that it can be hosted inside a GUI::View |
| ►CMenu | Represents a hierarchical menu of actions used to describe menu bars, context menus, or popup menus |
| CAction | Represents an item inside a Menu where a callback function is called when user clicks on it |
| CSeparator | Represents a separator to be shown as divider between unrelated groups of actions |
| CMouseEvent | Mouse events are triggered whenever the status of the mouse has changed wrt |
| COffscreenIndicatorsOverlay | The OffscreenIndicatorOverlay provides indicators to data that is outside of the current view area |
| COrientationMeshOverlay | Wraps a GlOrientationMeshOverlay and does not provide any interactions |
| CPixelInfoOverlay | InfoOverlay to show information about the pixel currently underneath the mouse cursor |
| ►CPointBasedAnnotationEventHandler | Event handler for creating and editing point-based annotations |
| CCreateMode | |
| CMoveAnnotationMode | |
| CMovePointMode | |
| CRegularMode | |
| CQtDisplayWidget | Specialization of a QOpenGLWidget that allows for rendering the contents of a Display into a QtWidget-based application |
| CQtDisplayWindow | Specialization of a QWindow that allows for rendering the contents of a Display directly into the window framebuffer |
| CQtDisplayWrapperBase | Abstract base interface for wrappers of a Display that embed them in a Qt-based GUI application |
| CQualityBarOverlay | Wraps a GlQualityBarOverlay object in an InteractiveOverlay |
| CRadiologyDisplay | Specialization of a Display that provides an off-the-shelf setup typically present in radiology workstations |
| CRadiologyViewGroup | Convenience class to setup a set of views typically available in radiology workstations |
| CRadiologyViewOverlays | Helper class to create and manage ViewOverlays commonly shown in radiology workstations |
| CScaleOverlay | Wraps a GlScaleOverlay into a ViewOverlay so that it can be added to a GUI::View |
| CSliceIndicator | Interactive renderer to show and manipulate the position/extent of SliceView instances in context of other Views |
| CSliceView | 2D renderer for SharedImageSets that can be hosted inside a Display |
| ►CSliceViewDefaultEventHandler | Implementation of an input event handler providing standard mouse, touch, and keyboard interaction with a SliceView |
| CActionSpeed | Record to define the speed at which a mouse/touch movement will modify the underlying view |
| CTouchActionConfig | Record to define which touch events should be processed and how |
| CSpinboxMatrixDialog | QDialog that simply wraps the SpinBoxMatrixWidget inside a dialog window. Used by EigenMatrixParamControls |
| CSpinboxMatrixWidget | QWidget that allows editing the elements of a matrix (vector) via QDoubleSpinBoxes. Used by EigenMatrixParamControls |
| ►CTouchEvent | Touch events occur when pressing, releasing, or moving one ore multiple touch points on a touch device |
| CPoint | Record of touch point metadata |
| CTypedViewObject | Specialization of a ViewObject where the concrete types of the underlying GlObject and EventHandler are defined by the template parameters |
| ►CView | Base interface for a rendering view (e.g |
| CBorderConfig | Record for specifying if and how to render a border frame surrounding the view |
| CEventHandler | Interface to be used as base class for event handlers of Views |
| ►CViewObject | Wraps a GlObject pairing it with an optional EventHandler in order to attach it to a View |
| CEventHandler | Interface to be used as base class for event handlers of ViewObjects |
| CViewOverlay | Wraps a GlOverlay in order to display it at specific positions inside a View and handle input events |
| CVolumeView | Volumetric 3D renderer for SharedImageSets that can be hosted inside a Display |
| ►CVolumeViewDefaultEventHandler | Implementation of an input event handler providing standard mouse, touch, and keyboard interaction with a VolumeView |
| CActionSpeed | Record to define the speed/change rate at which a mouse/touch movement will modify the underlying view |
| ►NHashing | Tools and functions to compute non-cryptographics hashes, for instance to use them in std::unordered_map |
| CEigenHasher | STL-compatible hasher for dense Eigen types (matrices, vectors, arrays) |
| CGenericHasher | STL-compatible hasher for custom classes where you list the members to be hashed as template parameters |
| ►NIGTL | |
| CConnection | Network connection to another OpenIGTLink-supporting system for receiving and sending data |
| CConnectionIoAlgorithm | Main IO algorithm for using the OpenIGTLink library |
| CCreateDataIoAlgorithm | |
| CCreateDeviceAlgorithm | |
| CCreateDeviceController | |
| CDataDevice | Base class for Igtlink devices that receive/send single data (and not data streams) |
| CDevice | Base class for Igtlink devices |
| CDeviceBlueprint | |
| CDeviceFactory | Factory class handling Igtl devices |
| CDeviceImpl | |
| CIgtlImageOutStream | |
| CIgtlImageStream | Image streams which are generated by OpenIGTLink connections |
| CIgtlPolyDataOutStream | |
| CIgtlPolyDataStream | Polydata (Mesh or PointCloud) streams which are generated by OpenIGTLink connections |
| CIgtlTrackingOutStream | Stream of tracking data which is sent by an OutputConnection through network or other ports |
| CIgtlTrackingStream | Tracking streams which are generated by OpenIGTLink connections |
| CImageData | Class to send/receive a single Image over an OpenIGTLink connection |
| CMeshData | Class to send/receive a single Mesh over an OpenIGTLink connection |
| CParsedMessage | |
| CPointCloudData | Class to send/receive a single PointCloud over an OpenIGTLink connection |
| CTrackingMessage | Tracking message used for OpenIGTLink connections |
| CTypeFactory | Factory class handling Igtl types |
| ►NImageMath | Arithmetic operations on images and arrays |
| ►NImgOps | |
| ►Cabs | |
| CImpl | |
| CImpl< OperandT, false > | |
| CImpl< OperandT, true > | |
| Cadd | Add |
| Catan | |
| Cbinary_type_trait | Type trait |
| Cbinary_type_trait< true, Op, LhsT, RhsT > | |
| CbinaryAnd | |
| CBinaryImgOpGl | |
| CbinaryLambdaWrapper | |
| CbinaryOr | |
| Ccos | Cos |
| Cdivide | Divide |
| CdivideIfNotZero | Divide if rhs is greater Zero |
| Cequal | |
| Cexp | Unary exp |
| Cgreater | |
| CgreaterEqual | |
| Clength | This is used for the Euclidean length over channels in the ChannelReduction ImageMath node |
| Cless | |
| ClessEqual | |
| Clog | Unary log |
| Cmax | |
| Cmin | |
| Cminus | Minus |
| Cmult | Mult |
| CnotEqual | |
| Cpow | Pow |
| Cpow2 | Unary pow2 |
| Csign | |
| Csin | Sin |
| Csqrt | Unary sqrt |
| Cunary_type_trait | Type trait |
| Cunary_type_trait< true, Op, OperandT > | |
| CunaryIdentity | Identity |
| CUnaryImgOpGl | |
| CunaryLambdaWrapper | |
| ►CunaryMinus | Unary minus |
| CImpl | |
| CImpl< OperandT, false > | |
| CImpl< OperandT, true > | |
| ►Ninternal | |
| CArrayBase | Base class for resample |
| CArrayGl | Implementation of GlExprInterface for Array ( |
| Cbiggest_imf_img_type | |
| Cbiggest_imf_img_type< T, Ts... > | |
| CBinaryOp | Specialization of ExprBase for binary operators (non template optimization) |
| CBinaryOpBase | Base class for binary operators |
| CBinaryOpGl | Implementation of GlExprInterface for BinaryOpTpl ( |
| CBinaryOpTpl | Specialization of ExprBaseTpl for binary operators using template optimization |
| CBlockDetails | Block access members |
| Cbool_pack | |
| CCastWrapper | Cast expression |
| CCastWrapperGl | Implementation of GlExprInterface for CastWrapperTpl ( |
| CCastWrapperTpl | Cast expression |
| CChannelReductionBase | Base class for channel reduction |
| CChannelReductionGl | Implementation of GlExprInterface for ChannelReductionTpl ( |
| CChannelReductionIdentifier | |
| CChannelReductionTpl | Specialization of ExprBaseTpl for reduction operators over channels |
| CChannelSwizzleView | Specialization of ExprBase for viewing an expression based on channels swizzling |
| CChannelSwizzleViewBase | Base class for channel swizzle views |
| CChannelSwizzleViewGl | Implementation of GlExprInterface for ChannelSwizzleViewTpl ( |
| CChannelSwizzleViewTpl | Specialization of ExprBaseTpl for viewing an expression based on channels swizzling |
| CChannelWiseScalarGl | Implementation of GlExprInterface for ChannelWiseScalar ( |
| CCombineChannelsBase | Base class for combine channels |
| CCombineChannelsGl | Implementation of GlExprInterface for CombineChannels ( |
| CCombineChannelsTpl | |
| Ccommon_type | 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 > | |
| CCoordinatesGl | Implementation of GlExprInterface for Coordinates ( |
| CCoordinatesImpl | |
| CDeformationLeafBase | Base class for deformation |
| CDeformationLeafGl | Implementation of GlExprInterface for DeformationLeaf ( |
| CDeviceStrategyWrapper | Chooses device strategy |
| CDeviceStrategyWrapperGl | Implementation of GlExprInterface for DeviceStrategyWrapperTpl ( |
| CDeviceStrategyWrapperTpl | Chooses device strategy |
| Cfirst_non_void | Get first non-void element in parameter pack |
| Cfirst_non_void< T, Ts... > | |
| CGlExprInterface | Base class for all expressions which provides an interface to automatically create shaders from an expression |
| ChasEvalString | |
| ChasImgType | |
| CMaskLeafBase | Base class for mask |
| CMaskLeafGl | Implementation of GlExprInterface for MaskLeaf ( |
| CNoiseGl | Implementation of GlExprInterface for Noise ( |
| CNoiseGlBase | |
| CNoiseIdentifier | |
| COperandStashImpl | |
| COperandStashImpl< expr_type, true > | |
| CPermutationLookup | Lookup structure for forward and backward block dimension squeezing |
| CPolyWrapper | Specialization of ExprBase wrapping a ExprBaseTpl |
| CReductionWrapper | Polymorphic wrapper to wrap an expression and represent a reduction |
| CReductionWrapperBase | Base class for reductions needed for polymorphic layer |
| CReductionWrapperGl | Implementation of GlExprInterface for ReductionWrapper ( |
| CReductionWrapperGlBase | Dummy base as ReductionWrapperGl needs to be a polymorphic type |
| CReductionWrapperTpl | Wrapper to wrap an expression and represent a reduction |
| CResampleBase | Base class for resample |
| CResampleGl | Implementation of GlExprInterface for ResampleTpl ( |
| CResampleTpl | Resample an ImageMath operand to a different coordinate system, optionally including a deformation |
| CScalarGl | Implementation of GlExprInterface for ChannelWiseScalar ( |
| CSelectBase | Base class for select operator |
| CSelectGl | Implementation of GlExprInterface for SelectTpl ( |
| CSelectTpl | Specialization of ExprBaseTpl for ternary (condition ? |
| CStashBase | Base class for stash operator |
| CStashEntry | |
| CStashGl | Implementation of GlExprInterface for StashTpl ( |
| CStashTpl | ImageMath class that can be used to substitute a multi-channel expression into another expression Typically, the expression being substituted is "expensive" relative to the "cheap" expression being substituted into |
| CTaggingIndex | In order to tag leafs in an expression we need to be able to re-identify leafs which represent the same information |
| CUnaryOp | Specialization of ExprBase for unary operators (non template optimization) |
| CUnaryOpBase | Base class for unary operators |
| CUnaryOpGl | Implementation of GlExprInterface for UnaryOpTpl ( |
| CUnaryOpTpl | Specialization of ExprBaseTpl for unary operators using template optimization |
| CUnaryWrapperBase | Base class for wrapping operators such as casting, device strategy, etc |
| CVariableGl | |
| CWrapSimpleTypeResult | |
| CArray | Specialization of ExprBase for a image leaf, i.e |
| CChannelWiseScalar | Specialization of ExprBaseTpl for a channel wise scalar value |
| CCoordinates | ImageMath leaf for using world coordinates in ImageMath expressions |
| CDeformationLeaf | Leaf node for ImageMath expressions that represents a deformation (cf Deformation) |
| CExprBase | Base class for expressions (non-templated) (needs to be empty in order to enable empty base class optimization!) |
| CExprBaseTpl | Base class for compile-time optimized expressions (curiously recurring template pattern (CRTP)) |
| CExprInterface | ImageMath base class to provide an interface for non-CRTP polymorphism |
| CGlExpr | Wrapper for using a ExprBase as GlAbstractInclude |
| CMaskLeaf | Use a Mask/GlMask as an ImageMath leaf that can be used in ImageMath expressions |
| CNoise | ImageMath leaf for generating noise in ImageMath expressions |
| COperandDeformation | Use an ImageMath expression as a Deformation |
| COperandMask | Mask/GlMask from an ImageMath expression |
| COperandMaskBase | |
| CScalar | Specialization of ExprBaseTpl for a single scalar value |
| CStashVariable | Helper Variable class for use with stashes |
| CStringLeaf | Specialization of ExprBaseTpl for a simple leaf representing a string |
| CVariable | Specialization of ExprBaseTpl for a variable, e.g |
| ►Ninternal | |
| CASCTableModel | Implementation details should not be used |
| CKeyComboBox | |
| CKeyItemDelegate | |
| CKeyModel | |
| CKeyTreeView | |
| CKeyValueStoreTableModel | |
| CViewOptions2dWidget | |
| CViewOptions3dWidget | |
| CViewOptionsCurvedViewWidget | |
| CVisibilityDelegate | |
| ►NIO | |
| ►CExportFolder | |
| CIndexedPath | |
| CFileLoader | This class provides a very high level of abstraction for loading data from files independent of their type |
| CFolderLoader | This class provides a very high level of abstraction for loading data from a directory |
| ►NLabelStatistics | |
| CLabelInfo | |
| ►NLog | Logging framework |
| CConsoleSink | Default implementation for a Logger that prints to the attached console/terminal |
| CFileSink | Default implementation for a Logger that writes to the filesystem |
| ►CSink | Interface for a logger sink that can receive individual log events |
| CFilter | Structure storing a filter |
| CLogCapture | Structure storing a single log event |
| ►NMath | |
| ►NInterpolation | Helper functions for N-linear interpolation of N-cells(pixel, voxel, etc. ) |
| ►NImpl | |
| CTemplateWrapper | |
| CTemplateWrapper< T, 0, NumberOfDimensions > | |
| CBicubicBSplineApproximation | Implements the approximation of a 2D scalar field with bicubic bsplines |
| CBisectionSearch | Templated bisection search algorithm, finds the interval in a sorted array in which any given value falls |
| CFP16 | |
| CFP32 | |
| ►NMeshProcessing | Collection of algorithms for post-processing meshes |
| ►NCleaning | Mesh processing algorithms related to cleaning of the mesh |
| CImFusionOriginProperty | Vertex and / or face property indicating the origin of a vertex or face in the mesh, added to the mesh by cropMesh |
| ►NConnectedComponents | Mesh processing algorithms based on connected component analysis |
| CConnectedComponent | |
| CConnectedComponentInfo | |
| ►NGeometry | Mesh processing algorithms related to geometrical operations |
| CDominantPlaneOptimizerSettings | Structure representing the settings for the optimizor used to compute dominant plane of the mesh |
| ►NRemeshing | Mesh processing algorithms related to mesh remeshing (smoothing, decimation, subdivision) |
| CSimplificationSettings | |
| CConnectedComponentData | |
| ►NMetaImage | Support for loading and saving MetaImage files |
| CMetaImageHeader | |
| CSaveOptions | Most properties of a MetaImage header can be deduced from a SharedImageSet, the ones in SaveOptions can not |
| ►NML | Namespace containing all the classes relevant for the data processing and the execution of machine learning models |
| ►Ndetail | |
| CCreator | Base class for creators to be registered in factory |
| CCreatorImpl | Wrapper around a std::function used for constructing an item Derived from Base |
| CDataItemSaveWithCompression | |
| ►NGNN | |
| CConversionOptions | Options for conversion between Graph and Mesh classes |
| ►NShaderUtils | |
| COperationShaderCache | |
| CAddCenterBoxOperation | Add Centerbox in a second channel |
| CAddDegradedLabelAsChannelOperation | Operation to add a channel with blobs whose sign depends on the label |
| CAddPixelwisePredictionChannelOperation | Run an existing pixelwise model and add result to the input image as additional channels |
| CAddPositionAsChannelAlgorithm | Algorithm to add a new channel to a given image containing each pixel's position |
| CAddPositionChannelOperation | Add Position Channel |
| CAddRandomNoiseOperation | Apply a pixelwise random noise to the image pixels type (string): Distribution of the noise ('uniform', 'gaussian', 'gamma') random_range (double): The generated noise level: For 'uniform': noise is drawn in [-intensity, intensity] For 'gaussian': noise is drawn from a Gaussian with zero mean and standard deviation equal to intensity For 'gamma': noise is drawn from a Gamma distribution with k = theta = intensity (note that this noise has a mean of 1.0 so it is biased) For 'shot': noise is drawn from a Gaussian with zero mean and standard deviation equal to intensity * sqrt(pixelValue) probability (double): Value in [0.0; 1.0] indicating the probability of this operation to be performed |
| CAdjustShiftScaleOperation | Apply a shift and scale to the input image intensities: Output = (Input + shift) / scale |
| CAdvancedParameter | The AdvancedParameter class extends the Parameter class by providing some additional functionalities used in ML::Operation and ML::ImageROISampler classes, like specifying whether a parameter is required for the object to work, and automatically logging an error message in case the user doesn't provide it |
| CApplyTopDownFlagOperation | Flip the image, if the image is not top-down |
| CApproximateToHigherResolutionOperation | Replicate the input from the original reference image |
| CArgMaxOperation | Create a label map with the indices corresponding of the input channel with the highest value |
| CAxisFlipOperation | Flip image content along specified set of axes |
| CAxisRotationOperation | Rotate around image axis with axis-specific rotation angles that are signed multiples of 90 degrees |
| CBakeDeformationOperation | Deform an image with its attached Deformation and store the result into the returned output image |
| CBakePhotometricInterpretationOperation | The PhotometricInterpretation is a DICOM flag that encodes the relation between intensity values and their display value If the PhotometricInterpretation is set to Monochrome1, we invert the values over the range of values (min becomes max, max becomes min) |
| CBakeTransformationOperation | Apply the rotation contained in the matrix of the input volume |
| CBatchDataLoader | Batches the items in the nested loader into batches of the specified size |
| CBlobsFromKeypointsOperation | Transforms keypoints into an actual image (blob map with the same size of the image) |
| CBoundingBoxElement | DataElement based on BoundingBoxSet |
| CBoundingBoxSet | Class for managing sets of bounding boxes within a BoundingBoxElement The class is meant to be used in parallel with SharedImageSet |
| CBoundingBoxSetIoAlgorithm | Io Algorithm to load/save BoundingBoxSet |
| CBox | Bounding Box for ML tasks Since bounding boxes are axis aligned by definition, a Box is represented by its center and its extent |
| CCacheDataLoader | Caches the dataset loaded until now |
| CCenterROISampler | Sampler which samples one ROI from the input image and label map with a target size |
| CCheckDataOperation | Runs some tests on the input data and then forwards it as is |
| CClassificationLearningEvaluation | Class for evaluation of a binary classification method |
| CClipOperation | Clip values in a range |
| CConcatenateNeighboringFramesToChannelsOperation | Iterates over frame and adds to channel dimension the neighboring frames of both sides of the frame |
| CConvertSlicesToVolumeOperation | Creates a volume out of a set of slices with the same size |
| CConvertToGrayOperation | Convert input image to grayscale by averaging the color channels |
| CConvertVolumeToSlicesOperation | Extract slices from a volume TODO: for now this works only if input SIS contains a single 3D image, see issue ML-577 |
| CConvolutionalCRFOperation | Adapt segmentation map or raw output of model to image content |
| CCopyOperation | Copy a set of fields of a DataItem source (List[str]): list of the elements to be copied target (List[str]): list of the names of the new elements (must match the size of source) |
| CCropAroundLabelMapOperation | Selects the given label from a multi-label, and crops the image and labels around it |
| CCropOperation | Crop input images and label maps with a given size and offset crop_size (vec3i): List of integers representing the target dimensions of the image to be cropped |
| CCudaComputeCapability | Helper struct to store the CUDA compute capability |
| ►CCudaDeviceManager | Singleton class that helps getting a compatible CUDA device |
| CCudaDeviceProp | Abstracted and stripped down version of cudaDeviceProp |
| CCutOutOperation | Cut out regions in input images and label maps with a given size, offset and fill value size (vector<vec3>): List of 3-dim vectors representing the extent of the cut out fill_value (vector<float>): List of intensity values for filling out cutout region size_units (ParamUnit): Units of cut out size parameter |
| CDataElement | Main interface for data elements used for wrapping other ImFusion types and use them in a machine learning specific workflow |
| CDataElementException | Custom exception thrown by some DataElement |
| CDataItem | Class for holding a map of heterogeneous DataElements, see DataElement |
| CDataItemDisplayHandler | DataDisplayHandler for DataItems |
| CDataItemException | Custom exception thrown by DataItem |
| ►CDataListReader | DataReader to directly read data from a given datalist where each column corresponds to a (single) field of the DataItem |
| CLoadedInfo | |
| CDataLoader | Interface for all data loaders, establishing the mechanism for loading and processing data |
| CDataLoaderException | Custom exception thrown by DataLoader |
| CDataLoaderSpecs | |
| CDataReader | Base class for data readers |
| CDataset | Class for creating an iterable dataset by chaining data loading and transforming operations executed in a lazy fashion |
| CDefaultROISampler | Sampler which simply returns the image and the label map, after padding of a specified dimension divisor: each spatial dimension of the output arrays will be divisible by dimensionDivisor |
| CDeformationOperation | Apply a deformation to the image using a specified control point grid and specified displacements nSubdivisions (vec3i): list specifying the number of subdivisions for each dimension (the number of control points is subdivisions+1) |
| CDiceMetric | Compute the Dice score between a label map and a ground truth segmentation |
| CElementTypeHash | Hash function for the ElementType enum class |
| CEngine | Generic interface for machine learning models serialized by specific frameworks (PyTorch, ONNX, etc.) |
| CEngineConfiguration | |
| CEnsureExplicitMaskOperation | Converts the existing mask of all input images into explicit masks |
| CEnsureOneToOneMatrixMappingOperation | Ensures that it is possible to get/set the matrix of each frame of the input image set independently |
| CExtractRandomSubsetOperation | Extracts a random subset from a SharedImageSet |
| CExtractSubsetOperation | Extracts a subset from a SharedImageSet |
| CFactory | Generic factory class for registering polymorphic types Usage: |
| CFileNotFoundError | |
| CFileReader | Loads data by reading the files from a list of data "columns" (see above) |
| CFileReaderColumn | This struct represents a "column" of filenames in a filelist, like those contained in datalist_training.txt/data_list_validation.txt produced by ImFusionLabels |
| CFilterDataLoader | Filters the items according to user defined criterion |
| CFilterEmptyElementContentDataLoader | Filters the items out if any of the selected fields is holding a DataElement with empty content |
| CForegroundGuidedLabelUpsamplingOperation | Operation that generates a label map by upsampling or resampling a multi-class one-hot encoded image (such as a softmax model prediction) to the space of a binary image (such as a sigmoid model prediction) |
| CGammaCorrectionOperation | Apply a gamma correction which changes the overall contrast (see https://en.wikipedia.org/wiki/Gamma_correction) gamma (double): Power applied to the normalized intensities |
| CGenerateBoxSegmentationTrainingDataAlgorithm | Algorithm to generate learning data for box segmentation network |
| CGenerateRandomKeypointsOperation | Generate uniformly distributed random keypoints in the image |
| CGroupToDataItemAlgorithm | Groups a list of Data into a DataItem |
| CHighPassOperation | Smooth input image with a Gaussian kernel with halfKernelSize Then subtract the smoothed image from the input, resulting in a reduction of low-frequency components (like large gradients) |
| CImageElement | DataElement for 2D and 3D images |
| CImageMathOperation | Computes a specified formula involving images from the input dataitem |
| CImageMattingOperation | Reshape label map based on intensities of input image |
| CImageResampler | Helper 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 |
| CImageROISampler | Interface for samplers used during training of machine learning models |
| CImageSamplersException | Custom exception |
| ►CImagewiseClassificationMetrics | Compute the confusion matrix for a multi-class classification |
| CResults | |
| CInterleaveDataLoader | Routes DataItems from different pipelines into one active pipeline |
| CInverseOperation | Operation that inverts a specific operation by using the InversionComponent |
| ►CInversionComponent | Data component for storing operation inversion information |
| CInversionInfo | A structure to store all information needed for operation inversion |
| CInvertibleOperation | Base class for operations that support inversion |
| CInvertOperation | Invert the intensities of the image |
| CIOError | |
| CKeepLargestComponentOperation | Create a label map with the largest components above the specified threshold |
| CKeypointExtractionAlgorithm | Algorithm for extracting keypoints from blobs representing the probability distribution of the keypoint location |
| CKeypointsElement | DataElement based on KeypointSet |
| CKeypointSet | Class for managing sets of keypoints within a KeypointsElement The class is meant to be used in parallel with SharedImageSet |
| CKeypointSetIoAlgorithm | Io Algorithm to load/save KeypointSet |
| CKeypointsFromBlobsOperation | Extracts keypoints from a blob image Requires an image called label keypoints_field_name (str): Field name of the output keypoints keypoint_extraction_mode (int): Extraction mode: 0: Max, 1: Mean, 2: Local Max |
| CLabelROISampler | Sampler which samples ROIs from the input image and label map, such that one particular label appears |
| CLandmarkPredictionAlgorithm | Algorithm to predict landmarks in an image |
| CLinearIntensityMappingOperation | Apply a linear shift and scale to the image intensities |
| CLocalConvolutionalNetworkAlgorithm | Algorithm to perform a Local (possibly augmented) prediction using a fully convolutional network around a central point |
| CLocalizeSegmentAlgorithm | Localize & Segment Algorithm Runs an initial low resolution pixelwise segmentation to find a bounding box |
| ►CMachineLearningModel | Class for managing and executing a machine learning model on generic input data |
| CContext | |
| CMachineLearningModelAlgorithm | Generic algorithm to apply a machine learning model |
| CMakeFloatOperation | Turn image into a float image (if not float already) |
| CMapDataLoader | Applies a mapping to each item in the nested loader |
| CMarkAsTargetOperation | Mark elements from the input data item as "target" which might affect the behavior of subsequent operations that rely on Operation::ProcessingPolicy or use other custom target-specific logic |
| CMarkovChain | |
| CMatrixBasedOperation | Extension of the Operation class for operations based on a geometric transformation using a matrix (e.g |
| CMergeAsChannelsOperation | Merge multiple images into one along the channel dimension |
| CMeshSegmentationAlgorithm | Mesh segmentation algorithm based on a graph neural networks Converts an input Mesh to a Graph and runs a provided GNN model |
| CMetric | The Metric interface is a key part of our pipeline for standardized evaluations of a machine learning pipeline, or an algorithm in general |
| CMetricAlgorithm | Algorithm to compute metrics from a generic list of data The selected metric need to be set via the configure method: DataList algoInput = {labelMap1.get(), labelMap2.get()}; MetricAlgorithm metricAlgo(algoInput); Properties algoProps; algoProps.setParam("metricName", "DiceMetric"); metricAlgo.configure(&algoProps); metricAlgo.compute(); std::vector<Metric::Record> results = metricAlgo.metricOutput(); |
| CMetricException | Custom exception for metrics |
| CMLModelException | Custom exception thrown by MachineLearningModel |
| CModalitySynthesisAlgorithm | Class for running an algorithm that that given an image in one modality generates the corresponding image in another modality. (e.g. MR to CT) |
| CModelConfiguration | Configuration class for MachineLearningModel parameters |
| CMorphologicalFilterOperation | Runs a morphological operation on the input mode (string): Name of the operation in ['dilation', 'erosion', 'opening', 'closing'] op_size (int): Size of the structuring element |
| CMRIBiasFieldCorrectionAlgorithm | Algorithm to perform bias field correction using an implicitly trained neural network This algorithm addresses the problem of intensity inhomogeneities "bias fields" in magnetic resonance imaging (MRI) |
| CMRIBiasFieldCorrectionOperation | Operation to perform bias field correction using an implicitly trained neural network (see MRIBiasFieldCorrectionAlgorithm for more details and the parameters description) |
| CMRIBiasFieldGenerationOperation | Generate and optionally apply a smooth multiplicative intensity modulation ("bias") field |
| CMultiClassificationLearningEvaluation | Class for evaluation of a multi-label classification method |
| CNetworkTrainingFileGenerator | Generator of a Caffe neural network architecture text file from a set of the training data and some user-defined parameters This class is called from the GenerateCaffeTrainingDataAlgorithm to automatically produce a sample network suitable for training |
| CNormalizeMADOperation | MAD (median absolute deviation) Normalize Operation |
| CNormalizeNormalOperation | Channel-wise normalize values to mean 0, std 1, ignoring a certain background value if needed |
| CNormalizePercentileOperation | Normalize the input image based on its intensity distribution, in particular on a lower and upper percentile |
| CNormalizeUniformOperation | Normalize values in range [a, b] |
| COneHotOperation | Transform a label map into a multi-channel image based on a one-hot encoding Up to 4 channels are supported with OpenGL, more channels will fall back to CPU |
| ►COperation | Class to define a pre-post processing operation on data items |
| CSpecs | Specifications required to fully instantiate an operation |
| COperationException | Custom exception to be used by Operation |
| COperationsSequence | Class to execute a sequence of Operation, depending on the workflow phase (training, validation, etc.) |
| COperationsSequenceAlgorithm | Algorithm for running operations sequence on data |
| COrderedMap | 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) |
| COrientedROISampler | The OrientedROISampler samples m_numSamples samples of size m_roiSize from each dataset with an efficient GPU sampler |
| CPadDimsOperation | Pad an image to specific target dimensions |
| CPadDimsToNextMultipleOperation | Pads each dimension of the input image to the next multiple of the specified divisor |
| CPaddingDoneDataComponent | Data component for keeping track of the original location of a patch in the original image |
| ►CPaddingDoneInfo | Struct for geometrical information about how the patches were extracted from the original images |
| CPadSize | Struct for storing the actual padding size applied to a single image |
| CPadOperation | Pad an image to a specific padding size in each dimension |
| CParamException | Special type for handling exceptions during parameter configuration |
| CPatchesFromImageDataComponent | Data component for keeping track of the original location of a patch in the original image |
| CPatchInfo | Struct for storing the descriptor of the image a patch was extracted from and the region of interest in the original image |
| CPersistentCacheDataLoader | Caches the dataset loaded until now in a persistent manner (on a disk location) |
| CPixelwiseClassificationMetrics | Compute dense classification related metrics between a label map and a ground truth segmentation Precisely, computes the sensitivity, specificity, precision and recall |
| CPixelwiseLearningStream | Stream running a pixelwise learning model on another stream |
| CPolyCropOperation | Masks the image with a convex polygon as described in Markova et al |
| CPrefetchDataLoader | Prefetch the next items in a background thread |
| CPreprocessDataLoader | Applies a preprocessing pipeline to each item in the nested loader |
| ►CProcessingRecordComponent | Data component for keeping track of the data's origin |
| CEntry | Struct for holding the name and Properties of Operations, Samplers and Algorithms |
| CRandomAddDegradedLabelAsChannelOperation | Operation to add a channel with randomly distributed blobs, whose sign is positive if a blob is in the label and else negative |
| CRandomAddRandomNoiseOperation | Operation that randomly varies the intensity strength of the AddRandomNoiseOperation |
| CRandomAxisFlipOperation | Flip image content along specified set of axes, with independent sampling for each axis |
| CRandomAxisRotationOperation | Rotate around image axis with axis-specific rotation angles that are signed multiples of 90 degrees |
| CRandomChoiceOperation | Meta-operation that picks one operation from its configuration randomly and executes it This is particularly useful for image samplers, where we might want to alternate between different ways of sampling the input images The operationWeights argument allows to parameterize the operation selection probability distribution, if not specified, uniform sampling is used |
| CRandomCropAroundLabelMapOperation | Random version of CropAroundLabelMapOperation that selects a single random label value and crops around it |
| CRandomCropOperation | Crop input images and label maps with a random factor crop_ranges (vec3): List of floats from [0;1] specifying the maximum percentage of the dimension to crop, for each axis |
| CRandomCutOutOperation | Cut out regions in input images and label maps with a random factor cutout_number_range (vec2i): List of integers specifying the minimum and maximum number of cutout regions cutout_value_range (vec2f): List of floats specifying the minimum and maximum fill value for cutout regions cutout_size_lower (vec3): List of floats specifying the lower bound of the cutout region size for each dimension cutout_size_upper (vec3): List of floats specifying the upper bound of the cutout region size for each dimension cutout_size_units (ParamUnit): Units of the cutout size bounds, Default: ParamUnit::MM |
| CRandomDeformationOperation | Same as DeformationOperation but samples displacements randomly from a specified range nSubdivisions (vec3i): list specifying the number of subdivisions for each dimension (the number of control points is subdivisions+1) maxAbsDisplacement (float): absolute value of the maximum possible displacement (mm) paddingMode (PaddingMode): defines which type of padding is used |
| CRandomGammaCorrectionOperation | Apply a random gamma correction which changes the overall contrast (see https://en.wikipedia.org/wiki/Gamma_correction) |
| CRandomImageFromLabelOperation | Creates a random image from a label map, each label is sampled from a Gaussian distribution |
| CRandomInvertOperation | Operation that randomly inverts an image with a default probability of 50% (can be changed) |
| CRandomKeypointJitterOperation | Adds an individually and randomly sampled offset to each keypoint of each KeypointElement |
| CRandomLinearIntensityMappingOperation | Apply a random affine intensity mapping to an image |
| CRandomMRIBiasFieldGenerationOperation | Apply a random multiplicative bias field The field amplitude, length scale and distance scaling are drawn from uniform distributions |
| CRandomOperation | Abstract class for random operations that build upon another one In order to create a randomized version of a BaseOperation, you need to derive from RandomOperation<BaseOperation> and just implement the method randomizeOperation |
| CRandomPolyCropOperation | Masks the image with a random convex polygon as described in Markova et al |
| CRandomResolutionReductionOperation | Reduces the resolution of an image to a spacing randomly sampled in each dimension between the image spacing and the specified max_spacing max_spacing (vec3): maximum spacing for resolution reduction |
| CRandomROISampler | Sampler which randomly samples ROIs from the input image and label map with a target The images will be padded if the target size is larger than the input image |
| CRandomRotationOperation | Rotate input images and label maps with random angles |
| CRandomScalingOperation | Scale input images and label maps with random factors scales_range (vec3): List of floats specifying the upper bound of the range from which the scaling ofset will be sampled |
| CRandomSmoothOperation | Apply a random smoothing on the image (Gaussian kernel) |
| CRandomTemplateInpaintingOperation | Inpaints a template into an image with randomly selected spatial and intensity transformation in a given range |
| CRecombinePatchesOperation | Operation to recombine image patches back into a full image |
| CRectifyRotationOperation | Sets the rotation matrix of each element to the nearest xyz-axis aligned rotation to avoid oblique angles when baking in the rotation |
| CReferenceImageDataComponent | Data component used to store a reference image |
| CRegionOfInterest | Helper struct to represent a region of interest |
| CRegistry | |
| CRegressionLearningEvaluation | Class for evaluation of a regression method |
| CRemoveMaskOperation | Removes the mask of all input images |
| CRemoveOperation | Remove a set of fields from a DataItem Use 'apply_to' from base to specify which fields to remove |
| CRenameOperation | Rename a set of fields of a DataItem source (List[str]): list of the elements to be replaced target (List[str]): list of names of the new elements (must match the size of source) throw_error_on_missing_source (bool): if source field is missing, then throw an error (otherwise do nothing) throw_error_on_existing_target (bool): if target field already exists, then throw an error (otherwise overwrite it) |
| CRepeatDataLoader | Repeats items coming from a nested loader |
| CReplaceLabelsValuesOperation | Replace label values (assumes that it is unsigned byte) |
| CResampleDimsOperation | Resample input to target dimensions |
| CResampleKeepingAspectRatioOperation | Resample input to target dimensions while keeping aspect ratio of original images |
| CResampleOperation | Resample input to target spacing |
| CResampleToInputOperation | Resample to a target image |
| CResolutionReductionOperation | Reduces the resolution of an image to a specified spacing by keeping image dimensions target_spacing (vec3): target spacing for intermediate downsampling before upsampling again |
| CRotationOperation | Rotate input images and label maps with fixed angles |
| CRunModelOperation | Run a machine learning model on the input item and merge the prediction to the input item |
| CSampleDataLoader | Extract samples from each item in the nested loader |
| CSamplingConfiguration | |
| CScalingOperation | Scale input images and label maps with fixed factors scales (vec3): Scaling factor applied to each dimension apply_now (bool): Bake transformation right way (otherwise, just changes the matrix) |
| CSelectChannelsOperation | Select a sub-set of the input channels |
| CSetLabelModalityOperation | Sets the data modality of labels to Data::Modality::LABEL if data type is PixelType::UByte, otherwise casts a warning and skips execution |
| CSetMatrixToIdentityOperation | Set the matrices of all images to identity (associated landmarks and boxes will be moved accordingly) |
| CSetModalityOperation | Sets the data modality |
| CSetSpacingOperation | Sets spacing of image elements (data buffer is not changed) |
| CShuffleDataLoader | Shuffles the next specified items in the nested loader |
| CSigmoidOperation | Apply a sigmoid function on values |
| CSingleton | Base class for singletons |
| CSISBasedElement | Interface for DataElement based on SharedImageSet |
| CSmoothOperation | Run a convolution with a Gaussian kernel on the input image |
| CSoftmaxOperation | Computes channel-wise softmax of input image |
| CSplitDataLoader | Splits the items in the nested loader into DataItems containing a single image (batch size of 1) |
| CSplitIntoPatchesOperation | Operation which splits the input image into overlapping patches for sliding window inference |
| CSplitROISampler | Sampler which splits the input image into overlapping ROIs for sliding window inference |
| CStandardizeImageAxesOperation | Reorganize the memory buffer of a medical image to ensure anatomical consistency |
| CStatus | Convenience tool for returning error messages together with statuses |
| ►CSurfaceDistancesMetric | Compute a set of distance-based metrics between a label map and a ground truth segmentation |
| CResults | |
| CSwapImageAndLabelsOperation | Swap image and labels |
| CSyncOperation | Sync shared memory of images |
| CTagDataElementOperation | Operation for changing data element tags |
| CTanhOperation | Apply a tanh function on values |
| CTargetTag | Simple data component to identify data that must be considered as learning target |
| CTemplateInpaintingOperation | Inpaints a template into an image with specified spatial and intensity transformation |
| CTensor | Implementation of a Tensor class; used in TensorDataElement to directly present data to a neural network |
| CTensorSet | Class for managing sets of tensors, one for each frame in the set |
| CTensorSetElement | DataElements for Raw Tensors (Experimental) Unlike ImageElements, these elements will go into the ML engine in the shape that they are created (i.e |
| CThresholdOperation | Threshold values of the input image |
| CUndoPaddingOperation | Apply the inverse of a previously applied padding operation |
| CUnmarkAsTargetOperation | Remove the target tag from the elements of the input data item |
| CVectorElement | DataElement for non-image data (such as imagewise labels), represented as 1D images (i.e |
| ►NNetwork | Namespace for network communication bundled in the subfolder 'Stream/Network' |
| ►NOAuth2 | |
| CAuthorizationCodeFlowConfig | |
| CDeviceFlowConfig | Configuration for the OAuth2 Device Code Flow |
| CDeviceResponse | Response of the authEndpoint that starts the flow |
| CPasswordFlowConfig | |
| CAccessToken | Represents an access token for a HTTP server |
| CAuthorizationProvider | Interface for providing the Authorization header for WebRequests |
| CClientConnectionBase | Base class providing an interface for client communication |
| CConnectionBase | Abstract non-templated base class for all connection types |
| CConnectionBlueprint | Defines the necessary information for registering a new connection type |
| CConnectionFactory | The ConnectionFactory manages available connection protocols and creates new connections based on the provided configuration |
| ►CConnectionLatencyMeasuringAlgorithm | Measure the delay (latency) experienced in transmitting data with the corresponding protocol, where the transmission data is represented as std::string, and the each message is defined as[TIMESTAMP]:time_in_ms,[ID]:message_id |
| CLatency | |
| CHttpError | |
| CIPAddress | A class for handling and validating IPv4 addresses |
| CLoginDialog | Basic dialog for authentication with username and password TODO: Merge with Labels LoginDialog |
| CServerConnectionBase | Abstract base class providing a server interface |
| CStaticAuthorizationProvider | A most basic AuthorizationProvider that only tracks a static list of authorization headers |
| CTCPSocketClient | TCP socket client implementation providing bidirectional communication |
| CTCPSocketServer | TCP socket server implementation providing bidirectional communication |
| CTypedConnectionBase | Templated base class providing an interface for client-server communication (e.g., WebSocket, TCP) or peer-to-peer communication (e.g., UDP) |
| CUDPSocket | UDP socket implementation for network communication |
| CWebsocketClient | WebSocket client implementation providing bidirectional communication |
| CWebsocketServer | Websocket server implementation providing bidirectional communication |
| ►NPlatform | Selection of platform-specific functions |
| CDynamicLib | Provides access to functions of a shared library |
| CMemoryInfo | Structure storing information about the available main memory as reported Platform::memoryInfo() |
| ►NPoissonReconstruction | Different wrapper functions for Poisson Surface Reconstruction by M |
| CPoissonParams | Parameters for Poisson reconstruction |
| ►NPropertiesDetail | |
| CAttribute | Attributes allow for attaching custom data to individual parameters or an entire Properties instance |
| CParam | Record of all properties that represent a single param inside a Properties instance |
| CStringAccepter | Helper class to enable the convenience Properties constructor taking an initializer list |
| ►NQtHelpers | Some Qt convenience functions |
| CScheduledMainThreadCommand | |
| ►NRandom | Random number generation with convenience functions |
| CGenerator | Convenience class for generating random numbers from various distributions |
| CPcg64Engine | Wrapper class for a 64-bit PCG engine |
| ►NResource | ImFusion Resource System to store binary data in the executable/library and retrieve it at runtime |
| CFilesystemRepository | Repository for loading resources from the local filesystem |
| CRepository | Base interface for a ImFusion resource repository |
| ►NRobotics | |
| ►NIO | |
| CPathHandler | |
| ►NMotionPlanning | |
| ►NCollocation | |
| CGLCollocationData | Structor to contain the collocation points, integration weights, varycentric weights and derivativeMatrix of the gieven set of points |
| ►NOptimization | |
| ►NInterval | |
| CLength | |
| CVectorToIntervalPartition | |
| ►NPolynomialOperators | |
| CAbstractFunctionSparseDifferential | |
| CContinuityError | |
| CDerivative | |
| CFinalPoint | |
| CFinalPointDerivative | |
| CFunctionPolToPol | |
| CFunctionPolToVec | |
| CFunctionVecToPol | |
| CInitialPoint | |
| CInitialPointDerivative | |
| CIntegral | |
| CLeftJunctionPoint | |
| CPolynomialToVector | |
| CVectorToPolynomial | |
| ►NPolynomialWithIntervalPartition | |
| CAbstractFunctionSparseDifferential | |
| CBSplineInterpolation | |
| CBSplineInterpolationWithVariableWaypoints | |
| CContinuityError | |
| CDerivative | |
| CExecutionTime | |
| CFinalPoint | |
| CFinalPointDerivative | |
| CFunctionPolToPol | |
| CFunctionPolToVec | |
| CFunctionVecToPol | |
| CInitialPoint | |
| CInitialPointDerivative | |
| CIntegral | |
| CL2Norm | |
| CLeftJunctionPoint | |
| CPolynomialToVector | |
| CPolynomialWithPartitionToVectorOfCoefficients | |
| CSobolevSemiNorm | |
| CTupleIntervalPartitionWaypointsToIntervalPartition | |
| CVectorToIntervalPartitionAndWaypointsVector | |
| CVectorToPolynomial | |
| ►NPolynomialWithIntervalPartitionConstraints | |
| CInterpolationConstraints | |
| ►NSE3Operators | |
| CChart | |
| CError | |
| CErrorTo | |
| CErrorToPolynomial | |
| CParametrization | |
| CPolynomialChart | |
| CPolynomialLift | |
| CPolynomialParametrization | |
| ►NTraits | |
| Cis_tuple | |
| Cis_tuple< std::tuple< Args... > > | |
| Cis_vector | |
| Cis_vector< std::vector< T > > | |
| CReferenceSelector | |
| 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 |
| CRefWrapperSelector | |
| 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 |
| CRemoveIndexFromTuple | |
| CRemoveIndexFromTuple< std::tuple< Types... >, I > | |
| CAbstractFunction | |
| CAbstractFunction< Eigen::VectorXd, double > | |
| CAbstractFunction< Eigen::VectorXd, Eigen::VectorXd > | |
| CAbstractFunctionBase | Abstract base class to define a differentiable function between general c++ types |
| CAbstractFunctionBaseComposition | A class to compose multiple functions with agnostic domain and codomain |
| CAbstractFunctionComposition | |
| CAbstractFunctionComposition< Eigen::VectorXd, double > | |
| CAbstractFunctionDenseDifferential | |
| CAbstractFunctionDenseDifferentialTpl | |
| CAbstractFunctionLifting | |
| CAbstractFunctionSparseDifferential | |
| CAbstractFunctionSparseDifferentialTpl | |
| CAbstractFunctionTpl | |
| CAny | Class to store arbitrary objects and provide type-safe access to them |
| CAnyConstRef | Class helper to pass a writable reference to arbitrary objects into |
| CAnyRef | |
| CConstraints | This class IMFUSION_ROBOTICS_API contains a stack and two vectors for upper and lower constratins |
| CConstraintsStack | |
| CConversionWrapper | |
| CDenseLiftRnToR | Wraps a lambda function which tales, input, output and an optional to the differential |
| CDenseLiftRnToRm | Wraps a lambda function which tales, input, output and an optional to the differential |
| CFunctionRnToRmDenseDifferential | |
| CFunctionRnToRmSparseDifferential | |
| CFunctionRnToRmStack | A class to compose multiple functions into a single combined function |
| CLessThanZeroWrapper | Transforms a Constraints l < g < u into another g' < 0, such that g' = [l - g, g - u]' |
| ►COptimizer | |
| CError | |
| ►COptimizerNLopt | |
| CError | |
| CPartial | |
| CSimpleConstraints | |
| ►NSE3 | |
| CPolynomialSE3 | Polynomial class for SE3 |
| CDirectKinematics | |
| CInterval | Represents an interval in the real line |
| CIntervalPartitionXd | Represents an partition of the interval [t_0, t_N] |
| CMPolynomial | Class representing a piecewise polynomial a curve on the type T given be the action of a Parametrization on a Polynomial |
| CMPolynomial< double > | Scalar Polynomial class |
| CMPolynomial< Eigen::VectorXd > | |
| ►CPolynomial | Class representing a piecewise polynomial constructed using Lagrange polynomials at Gauss-Lobatto points |
| Cciterator | Constant Iterator for traversing the values of a piecewise polynomial at Gauss-Lobatto points across all intervals |
| Citerator | Iterator for traversing the values of a piecewise polynomial at Gauss-Lobatto points across all intervals |
| CPolynomialDirectKinematics | |
| CRandomTrackingSequence | |
| CSE3Interpolator | |
| CCartesianFrames | Holds two Cartesian States between different parts of the robotic system (i.e flange to base, and effector to base) |
| ►CCartesianImpedanceController | Implements Cartesian impedance with respect to the commanded motion |
| CParameters | |
| CCartesianInterpolationJointMotionGenerator | Interpolates from the current to a target Cartesian position with a trapezoidal speed profile The joint position is computed with inverse kinematics at each step |
| ►CCartesianInterpolationMotionGenerator | Interpolates from the current to a target Cartesian position with a trapezoidal speed profile |
| CParameters | |
| CCartesianPTPControlInterface | Interface for executing point-to-point motions with a goal identified by a Cartesian position |
| CCartesianQuantities | Represents Cartesian quantities used to describe 3D spatial information |
| CCartesianSetpointTorqueController | |
| CCartesianState | Represents pose and velocity of a frame in Cartesian coordinates |
| CCartesianStreamingControlInterface | Interface for executing motions represented by a motion generator in Cartesian space |
| CCartesianTransformFilter | |
| CCollisionDetectionPresetInterface | Interface to register, query and activate collision detection presets |
| ►CConstantForceTorqueController | Applies a constant force along the specified axis |
| CParameters | |
| CControlInterfaceBase | Base class for robot control interfaces |
| CControlIterationInfo | |
| CControllerConfiguration | Configuration to be used to configure a controller |
| CControllerConfigurationInterface | Interface to register and query controllers supported by the robot |
| CCreateRobotStreamAlgorithm | |
| CDynamicsInterface | Interface to define the method used to compute the robot dynamics |
| CDynamicsInterfaceWithFallback | Mixin class for providing a generic implementation of robot dynamics computation |
| CErrorComposition | Class to represent a stack of errors |
| CErrorException | Error that wraps any C++ exception |
| CErrorFrontEnd | Error class used by our specialization of Utils::Expected |
| CErrorInheritanceHelper | Auxiliary type intended to implement a user defined specialization of ErrorInterface |
| CErrorInterface | An interface for error handling and representation |
| CErrorKDL | |
| CErrorTracIK | Implementation of error types from trac_ik library |
| CFakeFrankaControlStream | |
| CFakeFrankaHandControlStream | |
| CFakeRobotControlStream | Stream that allows to programmatically set the joint position and simulate motion in Cartesian and joint space |
| CFakeUR5ControlStream | |
| CFakeURControlStream | Extends a FakeRobotArmControlStream to add the analog inputs / outputs |
| ►CFlangeMotionGenerator | Moves the last joint of the robot with a trapezoidal speed profile The same could be achieved with a JointMotionGenerator, but with more code |
| CParameters | |
| CFrankaControlStream | Control interface for a Franka Panda robot |
| CFrankaManagerAlgorithm | |
| CFrankaManagerController | |
| CGenericSocketInterface | Generic class to connect to a raw socket and send/receive text data |
| CGravityCompensationControlInterface | Interface to start and stop gravity compensation / teaching mode |
| CHandEyeCalibrationAlgorithm | Specialized hand-eye calibration for robot-camera systems |
| CHandEyeEvaluationAlgorithm | Evaluates hand-eye calibration accuracy (chain error) for robot-camera systems |
| CHighResTimestampDataComponent | DataComponent storing high-resolution timestamps |
| ►CHoldJointPositionMotionGenerator | Holds the current position for a given time (or until the motion is stopped) |
| CParameters | |
| ►CJointPositionMotionGenerator | Interpolates from the current to a target joint position with a trapezoidal speed profile |
| CParameters | |
| CJointPTPControlInterface | Interface for executing point-to-point motions with a goal identified by a joint position |
| CJointQuantities | Represents 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 |
| CJointSetpointTorqueController | |
| CJointState | Represents a joint's rotational state in terms of position and velocity |
| CJointStreamingControlInterface | Interface for executing motions represented by a motion generator in joint space |
| CJointTrajectoryDataComponent | DataComponent to hold the joint position of the robot over time |
| CKeyboardEventsReceiver | The class captures and forwards all the events coming from the keyboard (keys pressed, keys released, ..). and can be used to design tracking streams that are controller by the keyboards keys |
| CKeyboardTrackingStream | The class captures and forwards all the events coming from the keyboard (keys pressed, keys released, ..). and can be used to design tracking streams that are controller by the keyboards keys |
| CMotionGenerator | Online generator for trajectory waypoints Given input parameters (typically including the goal pose) and the initial state of the robot, it will compute intermediate PositionType objects at arbitrary points in time |
| CMotionGeneratorBase | |
| CMotionGeneratorParametersBase | |
| CMotionGeneratorParametersInterface | |
| CMotionResult | Type returned by the startMotion() methods implemented by various control interfaces |
| CMotionStep | |
| CMouseEventsReceiver | |
| CNativeRobotStateBase | |
| ►CNullTorqueController | Instructs the robot to apply zero torque |
| CParameters | |
| ►CPlanarCartesianImpedanceController | Implements Cartesian impedance on a plane of the given frame |
| CParameters | |
| CPlanningFrameInterface | Interface used for kinematic computations in world frame |
| CPureTorqueController | |
| CRateLimits | |
| CRobotArmCartesianState | Comprehensive description of the complete Cartesian state of a robot arm and its attached objects |
| CRobotBlueprint | |
| CRobotChain | Subset of a RobotGroup or RobotTree of consecutive RobotSegments |
| CRobotControlInterfacesHolder | Interface to register and access robot control interfaces |
| CRobotDescription | Comprehensive description of a robot's kinematic structure and properties Contains the complete definition of a robot's joints, links, and their relationships |
| CRobotEndEffector | |
| CRobotFactory | Factory class for RobotStateStream |
| CRobotGroup | Describes a named subset of the RobotTree conformed by multiple RobotChains |
| CRobotGroupState | Defines a named state of the joint values in the RobotChains of a particular RobotGroup |
| CRobotGUIProperties | |
| CRoboticsAlgorithmControllerFactory | Algorithm Controller Factory for the Robotics plugin |
| CRoboticsAlgorithmFactory | Algorithm Factory for the Robotics plugin |
| CRoboticsPlugin | Plugin for generic Robotics functionality |
| CRoboticsPluginSettings | |
| ►CRobotInstance | A class that manages a robot's kinematic model and coordinate transformations in the ImFusion SDK |
| CAttachedObject | Defines the relationship between an attached object and the robot's end effector (EE), along with a file path to the object's mesh |
| CRobotJoint | Represents a robot joint associated with a RobotSegment. Defines the name, type and limits of a particular joint |
| ►CRobotJointDescription | Structs |
| CLimits | Defines the motion limits for a particular joint |
| CRobotLink | |
| ►CRobotLinkDescription | Defines a description of a robot link including its visual properties and connections |
| CVisual | |
| CRobotLocation | Base class for describing the parameters needed by the individual robot SDK to connect to a device |
| ►CRobotModel | Holds the description of a robot arm as a tree of links, kept together by joints (fixed or mobile) |
| CNotableFrames | Name of frames that identify the base, flange and end effector links within the URDF link tree |
| ►CRobotRunner | Core class for managing robot execution and real-time control in the ImFusion SDK |
| CMotionData | Data structure holding information about the current motion |
| CRobotSegment | A RobotSegment represent each of the named individual parts of a RobotChain, with a RobotJoint |
| CRobotSegmentMap | |
| CRobotSolution | |
| CRobotSolver | Calculates the IK/FK of a RobotTreeImpl or a specific RobotChain |
| CRobotSolverAsync | |
| CRobotState | Contains the current status of the robot (i.e |
| CRobotStateStream | A Stream class for interfacing with robots in the ImFusion SDK |
| CRobotStateStreamData | Stream data containing robot state information |
| CRobotTrackingStream | Real-time tracking of robot poses via robot state stream (updates) signals |
| CRobotTransformsSubcontroller | Subcontroller to conveniently manage the robot goal specification It contains UI to move the goal state visualization to a manually typed Cartesian or joint goal position |
| CRobotTree | Represents the tree information of a robot |
| CRobotTreeImpl | Interface between RobotTree and the implementation/libraries used to hold the tree representation |
| CRobotTreeKDL | |
| CRobotUSTrackingStream | |
| CRobotVisualization | |
| ►CRuckigCartesianStreamingMotionGenerator | Takes a Cartesian pose as goal; it does IK first and then uses Ruckig to blend the motion with the current movement |
| CParameters | |
| CSavedGroupState | Represents a named configuration of joint positions for a specific group of robot joints |
| CSimpleErrorMessage | |
| CStatusInterface | Most standard control interface, which exposes functionality common to most robots |
| CStreamingMotionGenerator | 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 |
| CTCPTransformFilter | |
| CTorqueControllerBase | Base class for generic robot controllers |
| CTorqueControllerParametersBase | |
| CTorqueControllerParametersInterface | |
| CTransformFilterBase | |
| CTranslationTransformFilter | |
| ►CUnalignedConstantForceTorqueController | Applies a constant force along the specified axis |
| CParameters | |
| CURControlStream | Control interface for a Universal Robot robot (CB3 or e-series) Supports the ControlInterfaces implemented by URRunner |
| CURRobotLocation | |
| ►CURRobotState | Extends RobotState adding fields for the Universal Robot analog IO |
| ►CAnalogIoState | |
| CEntry | |
| CURRunner | Low-level interface to the Universal Robot RTDE interface |
| CURStateStream | Connects to a UR robot arm in read-only mode and publishes its state as a RobotStateStream |
| CWorldTransformFilter | |
| ►NROS | |
| CApplyCollisionObjectServiceClient | Ask to the Move Group what are the planners that are currently loaded |
| CCreateInputROSStreamAlgorithm | |
| CCreateMoveItControlStreamAlgorithm | |
| CCreateOutputROSStreamAlgorithm | |
| CCreateROSStreamAlgorithm | |
| ►CFrameTransform | Frames identifying a transformation between two coordinate frames in tf |
| CHash | |
| CImFusionROSManager | Singleton class to manage the ROS node When using ROS2, it will manage the main ROS node used to listen to tf |
| ►CImFusionTfManager | Singleton class to manage tf |
| CTfTransform | |
| ►CMoveItControlStream | Control interface mirroring a running ROS MoveIt! |
| CPlanResult | |
| CMoveitServiceCallerInheritanceHelper | Helper class to avoid writing the methods connect, disconnect and isConnected |
| ►CROSBagImportSpecification | |
| CImageImportOptions | |
| CPlaybackOptions | |
| CTrackingImportOptions | |
| CROSBagIoAlgorithm | IO algorithm to load/store SharedImageSets and TrackingStreams from/to ROS Bag files |
| CROSBagReader | Convenience class to wrap custom reader RAII |
| CROSBagSeekableStreamIoAlgorithm | Algorithm for creating Streams reading compatible messages out of a ROSBag on the fly |
| CROSBagSelection | Struct to specify the range of messages to be read from a topic If both frames and times are set, only the messages satisfying both constraints will be read |
| CROSBagTfSelection | |
| CROSBagWriter | Convenience class to wrap custom writer RAII |
| CROSMaster | ROS Master execution handler |
| CROSMasterAlgorithm | Algorithm to run a ROS1 master |
| CROSMsgDLLPreloader | |
| CROSParameter | Wrapper for ROS1 and ROS2 parameters |
| CROSParameterManager | Class to handle ROS1 and ROS2 parameters |
| CROSParameterPath | Class to abstract between ROS1 and ROS2 parameter paths |
| ►CROSPluginSettings | Provides settings used by different parts of the ROSPlugin |
| CRosWorkspace | |
| CROSStreamBlueprint | |
| CROSStreamFactory | |
| CROSTfTrackingStream | Tracking streams which are generated by listening to the ROS tf system |
| CROSTopicImageOutStream | Tracking streams which can transmit images over ROS Image topics |
| CROSTopicImageStream | Image streams which are generated by listening to ROS 2D Image topics |
| CROSTopicRGBDStream | RGBD streams which are generated by ROS drivers for RGBD cameras |
| CROSTopicTrackingOutStream | Tracking streams which can transmit a position in space over ROS Transform/Pose topics |
| CROSTopicTrackingStream | Tracking streams which are generated by listening to ROS Transform/Pose topics |
| CROSTypeName | |
| CSeekableTrackingStream | |
| CSettingsWidget | Simple Qt widget to configure the ROSPluginSettings |
| CSimpleROSEmptyServiceCaller | ImFusion implementation of std_srvs/Empty service client |
| CSimpleROSEmptyServiceServer | ImFusion implementation of std_srvs/Empty service server |
| CSimpleROSFloatListener | |
| CSimpleROSFloatPublisher | |
| CSimpleROSImageListener | |
| CSimpleROSImagePublisher | |
| CSimpleROSIntListener | |
| CSimpleROSListener | |
| CSimpleROSListenerInterface | Convenience interface that wraps ROS subscribers |
| CSimpleROSPublisher | |
| CSimpleROSPublisherInterface | Convenience interface that wraps ROS publisher |
| CSimpleROSServiceCaller | |
| CSimpleROSServiceCallerInterface | Convenience interface that wraps ROS service clients |
| CSimpleROSServiceServer | |
| CSimpleROSServiceServerInterface | Convenience interface that wraps ROS service servers |
| CSimpleROSSetBoolServiceCaller | ImFusion implementation of std_srvs/SetBool service client |
| CSimpleROSSetBoolServiceServer | ImFusion implementation of std_srvs/SetBool service server |
| CSimpleROSStringListener | |
| CSimpleROSStringPublisher | |
| CSimpleROSTrackingListener | |
| CSimpleROSTrackingPublisher | |
| CSimpleROSTriggerServiceCaller | ImFusion implementation of std_srvs/Trigger service client |
| CSimpleROSTriggerServiceServer | ImFusion implementation of std_srvs/Trigger service server |
| CTopicMetadata | |
| ►NSeg | Namespace of the Segmentation Plugin plugin |
| ►Ninternal | |
| CUndoLevel | |
| CUndoSerializer | Serializes 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 |
| CBrush | Convenience class to facilitate drawing in the views using the LabelPainter |
| CContour | Data Structure containing a vector of 3D points as well as metadata such as: |
| CContoursStorageComponent | |
| CEllipseReferenceShape | Reference with an ellipse section shape |
| CFreeformSelector | Simple class to make it easy to select by hand a portion of a volume |
| CLabelLock | Convenience class for handling locked/unlocked state of labels |
| CLabelMapRefinement | Helper class for post-processing a label map |
| ►CLabelPainter | Class for manually drawing to label maps |
| CSegment | |
| CLambdaEventHandler | |
| CLambdaManipulator | Utility class to avoid having to subclass the Manipulator class |
| CLine2DReferenceShape | Reference with a line shape |
| CLinearReferenceShape | Class defining a reference shape for which the conversion between local and world coordinates is a linear map (matrix multiplication + vector) |
| CReferenceShape | Abstract class defining a reference shape which has been fitted to a segmentation map |
| CSegmentedBlob | |
| CSegmentedEllipseStructure | |
| CSegmentedLine2DStructure | |
| CSegmentedStructure | Interface class that offers methods to obtain measuring markers on a segmented object |
| CSegmentedStructureWithReference | |
| CStructure | A Structure is a helper class providing a view onto a single label value within a label map |
| CStructureStatistics | Struct collecting statistics about a Structure |
| ►CStructuresView | The StructuresView provides a flattened view onto a given set of label maps |
| CLabelMapInfo | Bookkeeping information to easily map between label maps and their structures |
| CStructuresViewAlgorithm | ImFusion::Algorithm that wraps around a StructuresView and adds a couple of convenience functions |
| CStructuresViewAlgorithmController | GUI for the StructuresViewAlgorithm |
| CStructuresViewRenderer | Helper class to automatically visualize the content of a StructuresView in a DisplayWidget |
| CStructuresViewWidget | GUI to show the contents of a StructuresView as a table widget |
| CThresholdTool | Simple class to set values of a labelMap by doing thresholding on its corresponding image |
| CUndoRecorder | Simple class to keep track of data changes in a SharedImageSet |
| CWatershedTool | Wrapper class around the WatershedComputer to simplify common use cases |
| ►NThreading | Utility classes for multi-threading |
| CPlaybackTimer | Recurring timer class that allows for playback over a range at given timestamps/intervals |
| ►CStoppableThread | Extension of a std::thread to allow for signalling the thread to abort its execution |
| CStopException | Special exception type that is thrown by throwIfStopRequested() if abortion was requested |
| CThreadPool | Lightweight implementation of a thread pool for distributing work onto a fixed number of threads |
| ►NUS | Namespace of the ImFusionUS and ImFusionLiveUS plugins |
| CBaseGeometryDetectionAlgorithm | |
| ►CBoneSegmentationAlgorithm | Algorithm which segments bone in an ultrasound sweep |
| CSweepDetectionResults | Data structure to store the detections results for a given sweep |
| ►CBoneSegmentationBaseAlgorithm | Performs bone segmentation on ultrasound images using a machine learning model |
| CDetectionResult | |
| CPredictionMap | |
| CBoneSegmentationController | Controller for ultrasound bone segmentation algorithm |
| CCalibrationMatrixWidget | Specialization of TransformationMatrixWidget that allows the user to read and modify the calibration matrix of image sets that use a FrameGeometry to identify where in the image the tip of the ultrasound probe is, and allowing to express the calibration matrix independent of the imaging depth |
| CCalibrationPage | Calibration page in the UltrasoundCalibrationWizard. Displays the calibration progress and controls to explore the calibration sweeps |
| CCalibrationProgress | Progress implementation as an integrated QProgressBar |
| CClProbeDeformation | Differentiable OpenCL implementation of GlProbeDeformation |
| CComposedMotionModel | Motion model that composes multiple motion models into a single unified model |
| CConversionParameters | |
| CConvertToSweep | Algorithm wrapping multiple ways to create an UltrasoundSweep from one or multiple images |
| ►CDicomGeVividE9IOD | Extra IOD specialization for basic support of loading multiple ultrasound volumes created by GE Vivid E9 devices |
| CVividVolumeGroupItem | Dicom sequence item representing a sequence of images from a GE Healthcare Vivid E9 |
| CEveryFrameModel | Motion model with independent poses for each frame, exposing only one frame at a time for optimization |
| CExportCalibrationAlgorithm | Exports the calibration of an UltrasoundSweep to a calibration file |
| CExportCalibrationController | Controller for ExportCalibrationAlgorithm |
| CExtractDoppler | Extract color doppler information from an ultrasound sweep |
| CFanAnnotationManipulator | Manipulator for fan geometries |
| CFanMask | Mask for images, that shows only those pixels which are inside the configured FrameGeometry |
| CFrameFromVolumeOperation | Extracts 2D frames from a 3D volume by sampling while rotating around the specified axis |
| ►CFrameGeometry | Represents the (fan) geometry of an ultrasound frame acquired through scanline-based imaging |
| ►CFan | Helper struct for drawing the fan and fan manipulation |
| CControlPoint | |
| CFanEdge | |
| CFrameGeometry3D | Describes the geometry of a 3D ultrasound frame |
| CFrameGeometryCircular | Specialization for circular frame geometries |
| CFrameGeometryConvex | Specialization for convex frame geometries |
| CFrameGeometryConvex3D | Describes the specific convex acquisition parameters of a 3D ultrasound frame |
| CFrameGeometryConvexSteered | Specialization for convex frame geometries including steering |
| CFrameGeometryLinear | Specialization for linear frame geometries |
| CFrameGeometryMetadata | Metadata for the frame geometry of an ultrasound sweep |
| CFrameGeometryPropertiesAlgorithm | Algorithm to change properties of a FrameGeometry of a Shared Image Set |
| CFrameGeometryPropertiesController | Dialog for adjusting the frame geometry properties of a Shared Image Set |
| CFrameGeometrySector | Specialization for sector frame geometries |
| CFrameGrabbingAlgorithm | |
| CFrameGrabbingConfigComponent | Data component that stores the configuration of FrameGrabbingPresets |
| CFrameGrabbingConfigEditorAlgorithm | |
| CFrameGrabbingConfigEditorController | |
| CFrameGrabbingController | |
| ►CFrameGrabbingPresets | Set of templates, geometries and depths |
| CPreset | |
| CROI | |
| CGatingMotionModel | Specialized motion model that incorporates gating metadata for respiratory-aware motion |
| CGenerateDataForTrackingEstimation | Generate training/testing data from an US sweep for tracking estimation |
| CGeometryDetection | Actual implementation for automatically detecting the ultrasound image geometry from screen recordings |
| CGeometryDetectionAlgorithm | Algorithm to detect the actual image region of interest (ROI) in an ultrasound video |
| CGeometryDetectionController | GUI controller for real-time ultrasound video content detection |
| CGlFanGeometry | Ultrasound fan illustration on 2D slice view |
| CGlFanWireframe | Ultrasound fan wireframe enclosing a 3D sweep Fan wireframes can be created from an existing UltrasoundSweep, and can be added to image views: |
| CGlGeometricTransform | Base interface for implementing polymorphic geometric transforms from and to image coordinates using OpenGL |
| CGlProbeDeformation | Deformation model simulating radial compression from an ultrasound probe |
| CGlScanConversionConvexGeometricTransform | A geometric transform shader include that converts image coordinates to pre-scanconverted coordinates of convex frame geometries and vice versa |
| CGlScanConversionLinearGeometricTransform | A geometric transform shader include that converts image coordinates to pre-scanconverted coordinates of linear frame geometries and vice versa |
| CGlScanConversionSectorGeometricTransform | A geometric transform shader include that converts image coordinates to pre-scanconverted coordinates of sector frame geometries and vice versa |
| CGlSliceRendererSweep | Enables GlSlice to render freehand Ultrasound Sweeps |
| CGlSweep3D | GlObject to render an UltrasoundSweep in 3D Views |
| CGlSweepCompounding | Algorithm to reconstruct a voxel-based 3D volume from an UltrasoundSweep |
| ►CGlSweepReconstruction | Reconstruction of pixel data of one or multiple UltrasoundSweep image sets into an arbitrary 2D frame in 3D space |
| CFourCorners | |
| CGlSweepStretchDeformation | Deformation model to undo probe pressure deformation on an ultrasound sweep |
| CGlUltrasoundRuler | OpenGL object that renders a ruler-like scale overlay on Ultrasound images |
| CGuidedExpert | Guided or Expert selection page. Allows the user to end the wizard early with an initial calibration |
| CImportCalibrationAlgorithm | Imports the calibrations from a file and applies them to a number of UltrasoundSweep instances using a SweepCalibrator |
| CImportCalibrationController | Controller for ImportCalibrationAlgorithm |
| CInstrumentButtonListener | Utility class for managing button events from hardware |
| CInteractiveFanAnnotation | An interactive fan annotation that manages an internal FrameGeometry |
| CIntroPage | Introduction page. The user can select which tracking instruments to calibrate for |
| CKeyframeMotionModel | This model allows users to define a set of keyframes—each associated with a specific frame index |
| CLabelCompoundingAlgorithm | Compounding of label maps belonging to an ultrasound sweep |
| CLiveGeometryDetectionAlgorithm | Algorithm to detect the actual image region of interest (ROI) in an ultrasound stream |
| CLiveSweepRecordingVisualizationAlgorithm | Handles live ultrasound sweep visualization using an ImageStream and a TrackingStream |
| CLiveSweepRecordingVisualizationController | Controller for visualizing live ring buffer sweeps |
| CLiveUSAlgorithmControllerFactory | Factory for built-in algorithms |
| CLiveUSAlgorithmFactory | Factory for built-in Live US algorithms |
| CLiveUSPlugin | Plugin for algorithms from Live US module |
| CMergeSweepsAlgorithm | Merges multiple TrackedSharedImageSet into a single one |
| CMotionTrajectoryModel | Base class for helper classes modeling arbitrary motion trajectories using various parameterization methods |
| CNeedleSweepCalibrationAlgorithm | This algorithm allows to perform ultrasound calibration using a tracked needle or pointer |
| CNeedleSweepCalibrationController | Controller for defining needle points in ultrasound sweeps for calibration |
| CParametricMotionModel | A motion model that extends rigid motion with possible waypoint parametrization |
| CPiecewiseMotionModel | Motion model enabling piecewise segment-based registration using frame selection |
| CPointsOnSweepManipulator | Class that handles creation and manipulation of points on ultrasound sweeps |
| CPresetsTable | |
| CProbeDeformationAlgorithm | Setup ultrasound probe-skin deformation on another volume |
| CProbeRenderer | Visualizes the probe corresponding to an Ultrasound sweep in a volumetric view |
| CProbeTrackerAssigner | Assigns the main tracker to a tracking instrument whose name matches a predefined list associated with a probe name |
| CProbeTrackerPair | Class uniquely identifying a probe-tracker pair via probe-name and tracker-ID |
| CProcessedFrame | |
| CProcessedUltrasoundStream | Processes an ImageStream and attaches FrameGeometry info |
| CProcessUltrasound | Common processing functionality for ultrasound data |
| CProcessUltrasoundClip | |
| CProcessUltrasoundController | Controller for the ProcessUltrasound settings |
| CProcessUltrasoundParameters | Specifies the values that ProcessUltrasound will apply in the ultrasound data |
| CRandomFrameFromVolumeOperation | Randomized version of the FrameFromVolumeOperation |
| CRawDataAlgorithm | Handles pairing of B-mode ultrasound images with raw data and an optional label map |
| CRawDataComponent | This data component holds SharedImageSets that relate to the one they are attached to, holding their associated raw ultrasound data |
| CRawDataController | Controller for ultrasound B-mode and raw data handling |
| CRecordingWidget | |
| CRemoveDuplicateFrames | Algorithm for detecting and removing duplicate or nearly identical successive frames from an image set |
| CRoiAnnotationsWidget | |
| CScanConversion | Ultrasound scan-conversion for curved and phased array data |
| CScanConversion3D | Ultrasound scan-conversion for 3D probe data into a volumetric image and vice versa |
| CScanlineConfiguration3D | Dimensions of a 3D scanline dataset |
| CScreenTint | Utility class for applying a red tint to an UltrasoundSweep by modifying its transfer function |
| CSimpleMotionModel | Model representing simple motion defined either by a shift and rotation or a rigid pose between the first and last frames |
| CSliceToVolumeRegistrationAlgorithm | Intensity-based registration of an ultrasound sweep to a volume |
| CStreamDisplayDataController | GUI DataController for adjusting ultrasound stream visualizations in the display views |
| CSweepCalibrationData | This class maintains a database of calibration matrices between the image FrameGeometry offset and the (possibly multiple) TrackingInstrument frames |
| CSweepCalibrationDataIO | Loads and saves SweepCalibrationData instances from XML files |
| CSweepCalibrator | Calibrates UltrasoundSweep instances given a SweepCalibrationData |
| CSweepCroppingAlgorithm | Algorithm for cropping, binning (downsampling), and vertical flipping of ultrasound image data, with full correction of associated tracking and geometry metadata |
| CSweepDisplayDataController | GUI DataController for adjusting ultrasound sweep visualization in the display views |
| CSweepDisplayHandler | A DataDisplayHandler for UltrasoundSweep |
| CSweepDisplayOptions | DataComponent to store UltrasoundSweep-specific rendering options |
| CSweepGlobalInitAlgorithm | Algorithm for initializing the 3D pose of an ultrasound sweep relative to a reference volume |
| CSweepGlobalInitController | Provides a user interface for initializing the global pose of an ultrasound sweep relative to a reference volume |
| CSweepMotion | Analyse and edit motion of a freehand ultrasound sweep |
| CSweepOptimization | Class that factors out the parametrization of an UltrasoundSweep as needed for registration, motion estimation and calibration |
| CSweepPlaybackAlgorithm | An algorithm to playback an UltrasoundSweep as separate ImageStream and TrackingStream |
| CSweepPointCorrAlgorithm | Handles point correspondences between an ultrasound sweep and a 3D volume for registration |
| CSweepPointCorrController | GUI controller for sweep to volume point correspondences |
| CSweepProcessingAlgorithm | High-level algorithm for post-processing 3D freehand ultrasound sweeps |
| CSweepPropertiesAlgorithm | Algorithm to change properties of one or two ultrasound sweeps |
| CSweepRecorderAlgorithm | Algorithm for recording an ImageStream with modality ULTRASOUND and zero, one, or multiple TrackingStreams into an UltrasoundSweep |
| ►CSweepRecorderController | Controller for recording and visualizing multiple ultrasound sweeps |
| CSweepsTrackings | |
| CSweepRecordPage | Sweep recording page in the UltrasoundCalibrationWizard. Allows the user to record calibration sweeps |
| CSweepToMeshAlgorithm | Algorithm to generate a 3D surface mesh from a 2D ultrasound sweep |
| CSweepTrackingProperties | Dialog for adjusting FrameGeometry related properties of a tracked shared image set |
| ►CSweepTrajectoryAnalysisAlgorithm | Algorithm for removing unwanted parts from UltrasoundSweeps |
| CFrameInfo | Structure to store geometry information and meta data for an US frame |
| CSymmetryPage | Symmetry disambiguation page. Guides the user to indicate which probe orientation they're holding |
| CSyntheticUltrasoundSweepAlgorithm | Algorithm to create an ultrasound sweep without image content from two splines |
| CSyntheticUltrasoundSweepController | Controller for SyntheticUltrasoundSweepAlgorithm |
| CTrackingEstimationAlgorithmInterface | Interface for tracking estimation algorithms |
| CTrackingEstimationController | Controller for US tracking estimation algorithms |
| CTrackingEvaluation | |
| CTrackRecordPage | Tracking recording page. Allows the user to record tracking sequences for each direction in the wizard |
| CUltrasoundCalibration | Freehand ultrasound calibration with overlapping sweeps |
| CUltrasoundCalibrationController | GUI controller for freehand ultrasound calibration |
| CUltrasoundCalibrationInit | Helper class for the geometric computations needed in the UltrasoundCalibrationWizardAlgorithm |
| CUltrasoundCalibrationWizard | Wizard dialog as fronted for the UltrasoundCalibrationWizardAlorithm |
| ►CUltrasoundConeCalibrationAlgorithm | Algorithm that automatically computes ultrasound calibration using two or more ultrasound sweeps covering a cone phantom |
| CEstimatedCalibration | Represents an estimated calibration result |
| CFiducials | Represents fiducial points used for calibration |
| CMatches | Represents matches between cone tips from different sweeps |
| CTip | Represents a detected cone tip |
| CTrackedCone | Represents a cone detected in an ultrasound sweep across multiple frames |
| CUltrasoundDISARegistrationAlgorithm | Algorithm for registering an ultrasound sweep to a volume using DISA |
| CUltrasoundDISARegistrationController | Controller for the UltrasoundDISARegistrationAlgorithm |
| CUltrasoundMedium | Struct for medium properties used in ultrasound simulation |
| CUltrasoundMetadata | Metadata for a medical ultrasound image |
| ►CUltrasoundRegistrationAlgorithm | Registration of an ultrasound sweep or volume to a tomographic scan (CT or MRI) |
| CAdvancedConfig | |
| CLandmarkWeightingConfig | |
| CSegmentationWeightingConfig | |
| CUltrasoundRegistrationController | GUI controller for 3D ultrasound registration |
| CUltrasoundSimulation | Ultrasound simulation from CT |
| CUltrasoundSimulationHybrid | Hybrid ultrasound simulation method |
| CUltrasoundSweep | Set of 2D ultrasound images constituting a 3D (freehand) ultrasound sweep, so a clip of 2D ultrasound images with arbitrarily sampled tracking data and additional ultrasound-specific metadata |
| CUltrasoundSweepRingBuffer | Class for ring buffer version of freehand ultrasound sweep |
| CUSAlgorithmControllerFactory | Factory for controllers around ultrasound imaging |
| CUSAlgorithmFactory | Factory for algorithms around ultrasound imaging |
| CUSPlugin | Plugin for algorithms from US module |
| CUSPluginSettings | |
| CVolumeReslicingAlgorithm | Reslices a volume at the frame positions of an ultrasound sweep |
| CWizardPage | Base WizardPage class |
| ►NUserDocumentation | |
| CAlgorithmDoc | Record of the common sections for Algorithm User Documentation |
| ►NUtils | Collection of utility methods not associated with any class |
| ►Ndetail | |
| ►Nswap_adl_tests | |
| Cis_adl_swap_noexcept | |
| Cis_std_swap_noexcept | |
| Cis_std_swap_noexcept< T[N]> | |
| Ctag | |
| Cconjunction | |
| Cconjunction< B > | |
| Cconjunction< B, Bs... > | |
| Cdefault_constructor_tag | |
| Cexpected_copy_assign_base | |
| Cexpected_copy_assign_base< T, E, false > | |
| Cexpected_copy_base | |
| Cexpected_copy_base< T, E, false > | |
| Cexpected_default_ctor_base | |
| Cexpected_default_ctor_base< T, E, false > | |
| Cexpected_delete_assign_base | |
| 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 | |
| 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_move_assign_base | |
| Cexpected_move_assign_base< T, E, false > | |
| Cexpected_move_base | |
| Cexpected_move_base< T, E, false > | |
| Cexpected_operations_base | |
| Cexpected_operations_base< void, E > | |
| Cexpected_storage_base | |
| ►Cexpected_storage_base< T, E, false, true > | |
| C | |
| ►Cexpected_storage_base< T, E, true, false > | |
| C | |
| ►Cexpected_storage_base< T, E, true, true > | |
| C | |
| ►Cexpected_storage_base< void, E, false, false > | |
| C | |
| ►Cexpected_storage_base< void, E, false, true > | |
| C | |
| Cdummy | |
| Cinvoke_result_impl | |
| Cinvoke_result_impl< F, decltype(detail::invoke(std::declval< F >(), std::declval< Us >()...), void()), Us... > | |
| Cis_expected_impl | |
| Cis_expected_impl< Expected< T, E > > | |
| Cis_nothrow_swappable | |
| Cis_swappable | |
| Cis_swappable< T[N], T[N]> | |
| Cno_init_t | |
| CTC | |
| CTypeWrapper | |
| ►NEigenVectorWrapperImpl | Wrapper classes for using std::vector<Eigen::Matrix<T,N,1>> with arbitrary T and N as input of a non-template function |
| CEigenVectorWrapperBase | |
| CEigenVectorWrapperOptionalBase | |
| CEigenVectorWrapperOutputBase | |
| Cbad_expected_access | |
| CEigenVectorWrapper | Simple case: non-optional input argument |
| CExpected | An Expected<T, E> object is an object that contains the storage for another object and manages the lifetime of this contained object T |
| CLinearIterator | Typed convenience iterator for quick integration into custom containers, especially if traversal requires on-the-fly evaluations |
| CNotCopyable | Inherit from this class if your class should be neither copy-constructible nor assignable |
| COptionalEigenVectorWrapper | Optional input argument |
| COptionalOutputEigenVectorWrapper | Optional output argument |
| COutputEigenVectorWrapper | Non-optional output argument |
| COverloaded | Syntactic sugar for easier implementation of visitors of a std::variant or our Utils::Variant |
| CScopeGuard | Templated proxy class to implement generic scope guards |
| CSpan | Describes a non-owning view into contiguous sequence of elements |
| CUnexpected | |
| CVariant | Specialization of std::variant offering additional convenience member functions for functionality that the standard library only provides in the form of free functions |
| CVersion | Utility class to work with version information following the SemVer format |
| ►NVideoStreamSettings | |
| CExposure | Settings related to exposure |
| CFramerate | Settings related to frame rate |
| CGain | Settings related to gain |
| ►CRegionOfInterest | Settings related to a region of interest |
| CROI | Parameters describing a region of interest |
| CVideoCameraSettingDouble | Base class for parameters using a single double precision floating point value |
| CVideoStreamSettingsBase | Base class for all video stream settings |
| ►NVision | |
| ►NMLHelpers | |
| CVisionMLModelsFactory | |
| ►NUtils | |
| CSharedImageSetCompatibleCondition | Structure contains common compatible criterion for SharedImageSet |
| CDeviceParameters | Save image in text file one image row per line |
| COpticalFlowAlgorithm | |
| CAbstractFactory | |
| CAbstractImageRegistration | Interface for all image-based registrations |
| CActiveEnvironmentControl | A QComboBox with additional add and remove button to change the entries |
| CAdjusterWidgetBase | Base class for widgets providing two ways of adjusting numeric values |
| CAffineRescaledParameterOptimization | Decorator that subtracts shift, then multiplies by scale to every value before it is passed to the optimizer |
| ►CAlgorithm | Interface for describing algorithms that can be made available in the ImFusion Suite through AlgorithmFactory |
| CAction | Struct for representing a named action that has been registered with this algorithm |
| CFactoryInfo | Struct describing how an Algorithm was instantiated by the AlgorithmFactory |
| CAlgorithmBrowserDialog | Qt dialog showing a list of compatible Algorithms and enables the user to navigate and execute them |
| CAlgorithmController | Specialization of the Controller interface to be used with Algorithm instances |
| CAlgorithmControllerFactory | Interface for algorithm controller factories |
| CAlgorithmExecutorStream | Image stream helper class used as output of the StreamAlgorithmExecutor class |
| ►CAlgorithmFactory | Interface for algorithm factories |
| CDescriptor | Struct describing an algorithm registered with a factory |
| CAnalyzeMotion | Analyzes successive 2D images for various motion parameters |
| CAnatomicalStructure | Interface for storing information (points, meshes, images, ...) about anatomical structures |
| CAnatomicalStructureCollection | Interface for managing collections of anatomical structures For a concrete implementation of this class, see GenericASC |
| ►CAnatomicalStructureDeformation | Deformation of a single AnatomicalStructure object |
| CDeformationKeys | Structure for managing collections of keys for objects that can be deformed individually |
| CAnatomicalStructureFactory | |
| CAnatomicalStructureInvalidException | Exception thrown when an anatomical structure is invalid Thrown by python bindings |
| CAnatomicalStructurePointwiseDeformation | Class for representing nonlinear transformations on a set of points e.g |
| CAnatomicalStructureRegistration | Interface for registering AnatomicalStructure objects to each other |
| CAnatomicalStructuresCollider | Helper class for visualizing overlaps of AnatomicalStructures in a Spine |
| CAnatomicalStructureVisualiser | Helper class for visualizing data contained in the AnatomicalStructure class |
| CAnatomicalStructureVisualiserBase | |
| CAnatomicalStructureWrapper | Wrapper for anatomical structures that becomes invalid when the wrapped structure is deleted |
| ►CAnatomiesInfo | Singleton class that holds a map of anatomies together with information related to that anatomy (such as display color, etc) |
| CAnatomyEntry | |
| CAnatomy | Class representing a single anatomy code ID from the SNOMED CT database |
| CAnatomyAlgorithm | Edits the list of anatomies of an image (AnatomyDataComponent) |
| CAnatomyController | Controller for AnatomyAlgorithm |
| CAnatomyDataComponent | A data component storing information about anatomy contained in medical images or other data |
| CAnnotationModel | Container class for annotations Each annotation is always related to exactly one dataset |
| CAnnotationOutputInterface | Interface for passing annotations from an algorithm to the DefaultAlgorithmController |
| CAnnotationPoseLink | Links the pose and deformation of a point-based annotation to a dataset |
| CAnnotationWidget | Qt User interface for editing annotations managed by AnnotationModel |
| CApplicationController | The basic ApplicationController provides essential interfaces of the SDK but no graphical user interface |
| ►CApplyASCDeformation | Algorithm for converting an ASCDeformation into a (dense) deformation field |
| CDeformationData | Data structure extracted from ASCDeformation This is used as input to the shader |
| CApplyMaskAlgorithm | Algorithm for applying a mask and a cropping to an image |
| CApplyRegistration | Class that allows to apply registration results on algorithm input data |
| CApplyWindowLevelAlgorithm | Clamps (in-place) the image values to the range [level-window/2; level+window/2] |
| CASCAlgorithm | |
| ►CASCAlgorithmController | |
| CAdditionalFeatures | |
| CASCDataDisplayHandler | Template class that creates an ASCDataDisplayHandlerBase for a specific ASCVisualiser/AnatomicalStructureCollection pair |
| CASCDataDisplayHandlerBase | Display handler that configures the visual representation of an AnatomicalStructureCollection element |
| CASCDeformation | Class for representing "deformations" over an AnatomicalStructureCollection |
| ►CASCDisplayOptions | DataComponent to store AnatomicalStructureCollection-specific rendering options for 3D views |
| CDefaultSystemStyleSheets | These style sheets are created automatically in the constructor |
| CAsciiProgress | Displays a basic progress bar with ASCII characters on the console window |
| CASCIoAlgorithm | Algorithm to import/export AnatomicalStructureCollections to .imf or .zip files |
| CASCProjectionAlgorithm | |
| CASCProjectionController | |
| CASCRegistration | Registration between two AnatomicalStructureCollections |
| CASCRegistrationInterface | Abstract base class interface for algorithms that register two AnatomicalStructureCollection objects |
| ►CASCRegistrationMethod | Abstract base class for registration of AnatomicalStructureCollection objects to each other |
| CFactory | Global and local factories for ASCRegistrationMethod objects |
| CASCSet | Class storing a vector of AnatomicalStructureCollection objects |
| CASCSetDisplayOptions | |
| CASCVisualiser | |
| CASImageBasedRefine | |
| CAssignMeshTextureAlgorithm | Copies a RGB 2D image to use as texture for a mesh |
| CAttachDenseDeformationAlgorithm | Attaches a displacement field as a GlDenseDeformation |
| CAttachTrackingSequenceAlgorithm | Attach tracking sequence to existing tracked shared image set |
| CAutomaticMatchPruner | Automatic pruner selecting between homography and fundamental matrix based on decomposition score |
| CAverageImagesAlgorithm | Algorithm to average multiple images |
| CBackgroundExporter | Writing data files into disk in a background thread |
| CBackgroundFrameExporter | Writes frame data to the disk in a background thread |
| CBackgroundThreadConsumer | Interface for BackgroundThreadQueue holders to implement |
| CBackgroundThreadQueue | Queue for thread-safe asynchronous management of some payload data as needed in most streaming classes |
| CBackgroundVideoFileRecorder | |
| CBakeDeformationAlgorithm | Algorithm for baking in an image deformation while adjusting the size to encompass the full deformation |
| CBakeDeformationCPU | Bakes in a deformation applied to an image using the CPU |
| CBakeMeshDeformationAlgorithm | Bakes an image's deformation into a mesh or point cloud |
| CBakeTransformationAlgorithm | Algorithm for baking in an image transformation while adjusting the size to encompass the full transformation |
| CBaseAlgorithmControllerFactory | Factory for built-in algorithms |
| CBaseAlgorithmFactory | Factory for algorithms in the Base module |
| CBasicImageProcessing | Basic image processing such as downsample, flip, rotate or data type change |
| CBasicImageProcessingController | Controller for basic image processing tasks |
| CBasicProcessingStream | Apply basic filters to the content of an incoming ImageStream |
| CBestNSelector | |
| CBiCGStabEigenSolver | Bi-conjugate gradient solver with stabilization (Eigen implementation) |
| CBiCGStabSolver | Bi-conjugate gradient solver with stabilization |
| CBiCGStabViennaCPUSolver | Bi-conjugate gradient solver with stabilization (Vienna CPU implementation) |
| CBiCGStabViennaGPUSolver | Bi-conjugate gradient solver with stabilization (Vienna GPU implementation) |
| CBicubicBSplineApproximationAlgorithm | Algorithm that approximates the content of a SharedImageSet with a bicubic B-spline |
| CBilateralFilterAlgorithm | Algorithm for edge-preserving image smoothening using the Bilateral filter |
| CBinaryMaskToTextAlgorithm | Algorithm for loading and exporting a binary mask from a text file |
| CBinaryOpExpr | |
| CBinarySerializable | Interface for class which can be serialized and deserialized |
| ►CBlobDetector | |
| CBlob | |
| CParams | |
| CBoolParamControl | Represent a ParamType::Bool with a QCheckBox |
| CBoxAnnotationManipulator | Manipulator for box annotations |
| CBrainVesselSegmentationAlgorithm | |
| CBruteForceMatcher | Brute-force matcher for feature descriptors |
| CBullseyeVisualizationAlgorithm | Algorithm for the visualization of a bull's eye and simplified target distance sketch in the 3D view |
| CBullseyeVisualizationController | Controller for the visualization of tools such as needles in MPRs and 3D view and a bull's eye overlay in 3D view |
| CButtonDropdownWidget | Push button and a dropdown menu together as a single widget |
| CByteBuffer | Specialization of the ByteBufferView class that has ownership of the underlying data |
| CByteBufferMutableView | Specialization of a ByteBufferView that additionally provides non-const access to the underlying data |
| CByteBufferStream | Specialization of std::istream to easily extract data from a ByteBufferView |
| CByteBufferView | Const view onto a sized buffer of raw binary data |
| CByteSize | Helper class to facilitate handling byte sizes |
| CCalibrationOptimizer | Interface for calibration optimizers |
| CCamera | Abstraction layer to model both intrinsic (projection) and extrinsic (view) parameters of a camera showing a 3D scene |
| CCameraCalibrationAlgorithm | Camera calibration algorithm Description: |
| CCameraCalibrationDataComponent | A data component storing mainly the intrinsic calibration of a pinhole camera Information such as image size, extrinsic poses and distortions are also stored Debug values like MRE and standard deviations estimated for intrinsic parameters, which are used for evaluating the calibration results during the calibration process are also saved here |
| CCameraCalibrationSetterAlgorithm | The algorithm loads an existing calibration onto a given image set or image stream |
| CCameraCalibrationSettings | The class stores all parameters/settings for camera calibration |
| CCameraCalibrationSettingsWidget | This widget allows specifying parameters for camera calibration |
| CCameraNavigation | Helper class to manipulate a 3D Camera using classic metaphors such as zoom, pan, etc |
| CCameraRegistrationAlgorithm | Camera registration algorithm Description: This algorithm performs camera registration for a stereo camera system using known fiducial markers (e.g., chessboard or a ChArUco board) to estimate the relative pose between the left and right cameras |
| CCenterlineGraphExtractionAlgorithm | |
| CCGSolver | Conjugate gradient solver (Eigen implementation) |
| CCircleHoughTransform | Hough transform for detecting circles |
| CClassificationInputData | |
| CClCommandQueue | OpenCL command queue class |
| CClContext | OpenCL context class |
| CClDeformation | |
| CClDevice | OpenCL device class |
| CCleanDecorator | |
| CCleanMeshWidget | Mesh clean widget |
| CClEnvironment | Encapsulates OpenCL environment |
| CClEvent | OpenCL event class |
| CClFastMarching | OpenCL Fast Marching implementation |
| CClFftAlgorithm | Algorithm interface of the Fast Fourier Transform using the ClFFT library |
| CClFourierTransform | OpenCL-based Fast Fourier Transform using the ClFFT library |
| CClImage | OpenCL image class |
| CCliqueLookupTable | Compute a clique lookup table to identify point constellations in bigger pointclouds |
| CClKernel | OpenCL kernel class |
| CClMarkovChain | OpenCL-based Viterbi algorithm |
| CClonable | Interface for virtual copy construction |
| CClPlatform | OpenCL platform class |
| CClPointCloud | OpenCL point cloud |
| CClPointDistanceReg | Registers a point set to a distance volume |
| CClProgram | OpenCL program class |
| CClReduction | OpenCL-based reduction based on the NVIDIA OpenCL reduction SDK sample |
| CClSort | OpenCL-based sorting |
| CColorButton | Specialization of a QPushButton to show and select a color |
| CColorDecorator | |
| CColorMapOptimization | Provides color map optimization for textured mesh generation from RGB data |
| ►CColorMeshWidget | |
| CColorSettings | |
| CColorPickerParamControl | Represent a ParamType::Vector with a QPushButton that displays the vector as a color and opens a QColorDialog on click |
| CColorPickerWidget | Widget combining a HsvColorPicker2d, an HsvHueSlider, and optionally an OpacitySlider to let the user pick a color |
| CCombineASCSetAlgorithm | Algorithm to combine AnatomicalStructureCollections into an ASCSet |
| CCombinedParameterWrapper | Implementation of the ParameterOptimization interface to a combination of other ParameterOptimization interface values |
| ►CCombinedTrackingStream | A TrackingStream that combines the poses of two TrackingInstruments into a single relative tracking or a composition of the two |
| CCombinationInstruction | Defines how to combine instruments from multiple tracking streams |
| CCombinedTrackingStreamController | Controller to add combination instructions to the CombinedTrackingStream |
| CCombineGraphsAlgorithm | Algorithm to combine multiple graphs into a new graph |
| CCombineImagesAlgorithm | Algorithm to combine multiple images into a new shared image set |
| CCombineImagesAsVolumeAlgorithm | Algorithm to combine multiple images into a volume |
| CCombineIntoTrackedSharedImageSetAlgorithm | Algorithm for creating a TrackedSharedImageSet from a TrackingSequence and SharedImageSet |
| CCombineMeshesAlgorithm | Algorithm to combine multiple meshes into a new mesh |
| CCombinePointCloudsAlgorithm | Algorithm to combine multiple pointclouds into a new pointcloud |
| CCombineSplitVolumesAlgorithm | Algorithm to combine a number of split volumes along the Z dimension |
| CCompositeSlider | QSlider which adds the possibility of painting a background for the slider |
| CCompoundData | Interface for datasets that are formed by one or multiple other nested Data instances |
| CCompoundStreamData | Container for StreamData from the individual Stream#s of a StreamGroup |
| CComputeCommonGraphFeaturesAlgorithm | Algorithm to compute different edge features |
| ►CConfigurable | Base interface for classes that support object serialization from/to Properties objects |
| CParam | |
| CConnectedComponentsAlgorithm | Algorithm to perform an analysis of the connected components |
| CConsoleController | Specialization of ApplicationController for a console application which loads data and runs algorithms |
| CContrastFilter | Contrast-enhancing filter |
| CController | Base interface for a GUI element within MainWindowBase |
| CControllerDecorator | Base interface for wrapper classes to decorate Controller instances and place them inside a MainWindowBase |
| CCostFunction | Interface for a cost function that can be optimized |
| CCreateGroupedStereoImageStreamAlgorithm | The algorithm creates a GroupedStereoImageStream from two image streams and takes over their control Before using any stereo-related algorithms (e.g., depth estimation, disparity calculation, or 3D reconstruction), it is recommended to first run this algorithm to convert the two image streams into a stereo image stream |
| CCreatePixelwiseLearningStreamAlgorithm | Create a pixelwise learning stream from an existing stream |
| CCreateStereoSharedImageSetAlgorithm | The algorithm creates a stereo shared image set from two shared image sets The algorithm take over the ownership of the input two image sets It is recommended to first run this algorithm to convert the two image sets into a stereo image set before using any stereo-related algorithm |
| CCreateStreamAlgorithm | Algorithm template to create streams |
| CCreateStreamIoAlgorithm | IO algorithm template to create streams |
| CCropAroundVertebraeOperation | |
| CCropDecorator | |
| CCropLabelMapAlgorithm | Class for cropping a label map around the targets with certain label values |
| CCropMeshWidget | |
| CCroppingMask | Simple axis-aligned cropping mask with optional roundness |
| CCsvIoAlgorithm | IO algorithm for moving tensors to and from CSV files |
| CCSVParseDialog | |
| CCSVParser | Converts a CSV file into a Table, with customizable delimiters and optional headers |
| CCTSpineAlgorithmAdapter | |
| CCubicSplineInterpolationAlgorithm | |
| CCurve | Interpolation and fitting of a 1D curve |
| CCurvedView | Interactive 2D view of one or multiple images |
| CCurvedViewPrimitive | Interface for curved view primitives |
| CCurvedViewSettingsController | Simple dialog to modify parameters of the curved view |
| CCurvedViewSplineManipulator | Manipulator setting the direction of spline based curved views |
| CCurveEditorManipulator | |
| CCurveEditorView | Curve editor view |
| CCustomFaceProperty | A custom property using faces/triangles as geometry elements |
| CCustomImage | Base interface for custom Image types that can be converted from/to MemImages and are supported by SharedImage |
| CCustomProperty | Interface for a custom typed property, allowing access to the values at individual elements |
| CCustomPropertyBase | Basic interface for a custom property, i.e. a collection of values on different elements (vertices/faces) |
| CCustomPropertyDescriptor | |
| CCustomPropertyElement | Wrapper for the value of a custom property on a specific element, with conversions to and from the underlying data type |
| CCustomPropertyElementBase | Basic interface for the value of a custom property on a single element |
| CCustomVertexProperty | A custom property using vertices as geometry elements |
| CData | Virtual base class for representing data from which all concrete data class such as images need to derive |
| ►CDataAnnotationFactory | Interface for data annotation factories |
| CDataAttribute | |
| CDataComponent | Main specialization of DataComponentBase for regular types |
| CDataComponentBase | Data components provide a way to generically attach custom information objects |
| CDataComponentFactory | Factory singleton for creating DataComponents from string IDs |
| CDataComponentList | Class for holding a collection of DataComponents |
| CDataComponentWithParentInterface | Interface to augment a DataComponent with a parent of type Data |
| CDataController | Specialization of the Controller interface to be used with Data instances |
| CDataControllerBar | The DataControllerBar displays DataController in toolbar-mode |
| CDataDisplayHandler | Interface to generically show/hide Data in a GUI::View and/or query visibility |
| CDataDisplayHandlerFactory | Factory class to maintain the list of registered DataDisplayHandlers , |
| CDataDisplayModel | This class extends a DataItemModel with data visibility information from a DisplayWidgetMulti |
| CDataFilterModel | Proxy model to filter a DataItemModel |
| CDataGroup | Data element that groups multiple Data instances together in a hierarchical fashion |
| CDataGroupingModel | QAbstractProxyModel implementation that groups data in a source-model according to a specified GroupingOption |
| CDataHashAlgorithm | Algorithm to compute a hash from image data |
| ►CDataItemModel | Wrapper class to transform the DataModel into a QAbstractItemModel so that it can be used in Qt views |
| CItem | Internal record to implement bookkeeping of the hierarchy in the underlying DataModel |
| CDataLink | Interface for linking properties between multiple Data instances |
| CDataList | Container for any number of Data instances such as image or meshes |
| CDataLogger | Support for logging data |
| CDataMatrixTransformer | |
| CDataModel | Container for datasets holding ownership and managing a hierarchical list of persistent data |
| CDataModelAutoLinking | Utility class to automatically create DataLink instances between datasets in a DataModel |
| ►CDatasetLicenseComponent | Data component for keeping track of the data's license (when it comes from a public dataset) |
| CDatasetInfo | Structure holding the information for one element |
| ►CDataSourceComponent | Data component for keeping track of the data's origin |
| CDataSourceInfo | Simple struct for storing the original filename of a data, how it has been loaded and the history of its sources |
| CDataWidget | Graphical user interface for the DataModel/DataItemModel |
| CDataWidgetItemDelegate | Base interface for a Qt item delegate that defines how the entries in a DataWidget are supposed to be shown |
| CDataWidgetMenu | Context menu of the DataWidget |
| CDateFilterWidget | |
| CDebouncer | Class that can be used to limit the frequency of calls to a function |
| CDecimateMeshWidget | Mesh decimation widget |
| CDefaultAlgorithmController | Default algorithm controller, with automatically generated GUI This GUI includes: A PropertiesWidget displaying the configurable properties of the Algorithm A push-button for each Algorithm::Action registered with the algorithm (see Algorithm::registerAction) |
| CDefaultASCRegistrationController | Controller for AnatomicalStructureCollection (ASC) registration algorithms that handles basic UI elements such as adding the ASCs to the DataModel, unlinking their pose with the moving Data if they were linked and re-linking on closure |
| CDefaultASCSegmentationController | Helper template for creating controllers for segmentation algorithms using AnatomicalStructureCollection |
| CDefaultControllerDecorator | Wrapper class to decorate Controller instances and place them in the GUI of MainWindowBase using Qt Widgets |
| CDefaultDataAnnotationFactory | Factory for default data annotations |
| CDefaultDataWidgetItemDelegate | Default implementation of the DataWidgetDelegate that is used for instance in the ImFusion Suite |
| CDefaultIoAlgorithmControllerFactory | Factory for built-in IO algorithm controllers |
| CDefaultIoAlgorithmFactory | Factory for built-in IO algorithms |
| CDefaultTreeFactory | Factory for default Tree and Node types |
| ►CDeformableIcp | Implements a regularized-least-squares-based iterative closest point (ICP) procedure for deformable registration of two sets of points |
| CIterationInfo | Used to report information about an iteration |
| CRansacProperties | |
| CDeformableIcpAlgorithm | Regularized-least-squares-based iterative closest point (ICP) algorithm for deformable registration of two meshes, a mesh to a point cloud, or two point clouds representing a curve |
| CDeformation | Base class for different kinds of non-linear image transformations |
| CDeformationEditor | The DeformationEditor algorithm modifiers the deformation property of a SharedImageSet |
| CDeformationEditorController | Controller for the DeformationEditor algorithm |
| CDeformationEvent | Base class for customized deformation events |
| CDeformationFactory | Factory singleton for creating Deformations from string IDs |
| CDeformationWidget | Widget representing the properties of a certain deformation model |
| CDemonsImageRegistration | Registers two images with the Demons algorithm The algorithm modifies the GlDenseDeformation object attached to the moving image A number of variants of the standard demons algorithm (diffeomorphic vs additive, various gradient modes) are supported (cf |
| CDependentKeypoint | Represents a keypoint as linear combination of points in meshes or point clouds or other keypoints |
| CDeprecatedSignal | Deprecation layer for signals |
| CDepthColorWarping | DepthColorWarping provides functionality for warping between depth and color images using camera calibration and extrinsic parameters |
| CDepthMapToMeshAlgorithm | DepthMapToMeshAlgorithm converts depth maps (optionally with color and mask images) into triangle meshes |
| ►CDepthMapToPointCloudAlgorithm | DepthMapToPointCloudAlgorithm converts depth maps (optionally with color images) into point clouds |
| CBoundingBox | Structure representing a bounding box for cropping |
| ►CDescriptorsRegistrationAlgorithm | Class for performing image registration using local feature descriptors |
| CGlobalRegistrationConfig | |
| CDescriptorsRegistrationController | |
| CDicomAlgorithmControllerFactory | |
| CDicomAlgorithmFactory | |
| CDicomBrowser | The DicomBrowser is a dialog to browse and preview DICOM files |
| CDicomBrowserFilterModel | A QSortFilterProxyModel specifically for a DicomBrowserModel |
| CDicomBrowserModel | Hierarchical model of DICOM patients |
| CDicomDataAnnotationFactory | |
| CDicomGuiAlgorithmFactory | |
| CDicomGuiPlugin | |
| CDicomIoAlgorithm | IoAlgorithm for reading and writing DICOM files |
| CDicomIOAlgorithmBrowser | |
| CDicomIOAlgorithmFile | |
| CDicomIOAlgorithmFolder | |
| CDicomIoController | |
| ►CDicomLoader | Loads images from DICOM files |
| CRawBuffer | |
| ►CDicomPacsCommunication | Class facilitating the communication with DICOM PACS servers |
| CAsyncRequestInfo | Structure wrapping the return value of an asynchronous PACS request |
| CDicomPacsConfiguration | Structure encapsulating all information needed to connect to a PACS instance |
| CDicomPlugin | |
| ►CDicomPluginSettings | Provides settings used by different parts of the DicomPlugin |
| CPacsServer | |
| CDicomWriter | Can store a SharedImageSet in a DICOM dataset |
| CDISAFeaturesAlgorithm | Algorithm for extracting DISA features from a 3D volume By default the algorithm uses the same model used for the MICCAI 2023 publication, which can be executed by Torch and Onnx engines |
| CDisplacementVisualizer | Algorithm/GlObject hybrid to display an image's displacement as a vector field in an ImageView2D |
| ►CDisplayOptions2d | Configures the display options for 2D slice rendering of images |
| CWindowLevelPreset | Window-level configuration that can be stored as a preset |
| CDisplayOptions2dWidget | Widget to display and manipulate the per-data rendering options of a 2D view |
| CDisplayOptions3d | Configures the display options for 3D volume rendering of images |
| CDisplayOptions3dWidget | Widget to display and manipulate the per-data rendering options of a 3D view |
| CDisplayRecorderAlgorithm | |
| CDisplayRecorderController | |
| CDisplayWidget | Render surface that hosts InteractiveViews and will call their render method on repaints |
| CDisplayWidgetMulti | Specialized version of DisplayWidget that manages specific views and provides an automatic layout |
| CDisplayWidgetMultiAdapter | Helper class providing the API of DisplayWidgetMulti while wrapping around either a DisplayWidgetMulti or a GUI::RadiologyDisplay |
| CDistanceTransform | Distance transformation algorithm |
| CDistanceTransformAlgorithm | Computes a distance transformation from a label map |
| CDistanceVolumeAlgorithm | Algorithm to create a distance-volume from a mesh |
| CDoseComputationAlgorithm | Computes the dose distribution from PET/SPECT images |
| CDoubleAdjusterParamControl | Represent a ParamType::Double with a DoubleAdjusterWidget |
| CDoubleAdjusterWidget | Widget combining a slider with a spin box for configuring integer values |
| CDoubleParamControl | Represent a ParamType::Double with a QDoubleSpinBox |
| CDrawGraphAlgorithm | Algorithm to create or edit a graph |
| CDrawGraphController | |
| CEigenExpr | |
| CEigenMatrixParamControl | ParamControl for Eigen Types (Properties::ParamType::Matrix and Properties::ParamType::Vector) |
| CElementwiseDataComponentData | Class for augmenting Data classes with an ElementwiseDataComponentList |
| CElementwiseDataComponentList | Class for managing multiple DataComponentLists for individual elements |
| CEntryExitPointRenderer | Class for high-performance rendering of entry-exit points to be used for direct volume rendering |
| CEnumParamControl | Represent a ParamType::Enum and ParamType::EnumString with a QComboBox |
| CErrorFunction | Interface for an error function returning one or multiple values |
| CEvaluateGraphAtImageAlgorithm | |
| CEvaluateLinearShapeModel | |
| CEvaluateLinearShapeModelController | |
| CEvaluationResult | Return type of metric computation |
| CExpandableGroupBox | This class is a container widget that can expand and collapse another widget |
| CExpandableGroupBoxButton | |
| CExpandableWidget | This class is a container widget that can expand and collapse another widget |
| CExplicitIntensityMask | An ExplicitIntensityMask is a combination of an ExplicitMask and an IntensityMask |
| CExplicitMask | An ExplicitMask holds an individual mask value for every pixel |
| CExtractDeformationAlgorithm | Extracts the displacement field of a deformation as a 3 channel float image |
| CExtractImagesFromVolumeAlgorithm | Algorithm to extract 2D images from a volume |
| CExtractMeshTextureAlgorithm | Extracts the texture from a given mesh to an image |
| CExtractSelection | Algorithm to extract the current selection into a new object instance (SharedImageSet or TrackingSequence) |
| CExtractTrackingSequence | Duplicate and extract TrackingSequence data of a tracked image set |
| CFactoryBase | Abstract base class for all factories |
| CFactoryRegistry | Registry for object factories |
| CFakeImageStream | Small tool class to create an image stream |
| CFakePolyDataStream | Fake stream emitting a moving PointCloud or Mesh |
| ►CFakeTrackingStream | Small tool class to create a tracking stream out of nowhere |
| CConstantDevice | |
| CDevice | |
| COscillatingDevice | |
| CSweepDevice | |
| CFeatureDetectionAlgorithm | Feature detection algorithm |
| CFeatureDetector | Base class for feature detection on 2D images |
| CFeatureDetectorFactory | |
| ►CFeatureDetectorWithAdaptiveThreshold | Feature detection with adaptive thresholding to fill image grid with features |
| CKeyPointIterator | Iterator for traversing keypoints, optionally sorted by response |
| ►CFeatureMapsRegistrationAlgorithm | Algorithm for registering feature maps volumes |
| COptimizationParameter | Encapsulates the name and range (min, max) of a parameter |
| CFeatureMatch | Structure representing a match between two keypoints |
| CFeatureMatcher | Base class for feature matching on 2D images |
| CFeatureMatcherFactory | |
| CFeatureMatchPruner | Base class for pruning feature matches |
| CFeatureMatchPrunerFactory | |
| CFeatureSampler | Base class for feature sampling |
| CFeatureSamplerFactory | |
| CFFDImageRegistration | Registers two images with a non-linear deformation based on FFDs |
| CFFT | Fast Fourier Transform abstract base class |
| CFiducialExtraction | Detect circles in the image patch using gradient-based (RANSAC) method |
| ►CFiducialExtractionAlgorithm | Extract spherical fiducials from data set in 2D and 3D |
| CFiducial | |
| CFilterController | GUI controller for 2D filtering with preview |
| CFitBoundingBoxAlgorithm | Algorithm to fit an oriented bounding box |
| CFitShapeAlgorithm | |
| CFlags | Utility class to store a type-safe combination of enum-based bit fields |
| CFlowVisualizationAlgorithm | Creates a multi-channel image for flow visualization |
| CFpsCounter | |
| CFrameBasedPointCloud | Data structure for point clouds with frame-dependent point data |
| CFrameBasedPointCloudIoAlgorithm | Algorithm for reading and writing frame-dependent point clouds |
| CFreeformAnnotationManipulator | Manipulator for freeform annotations |
| CFreeFormDeformation | The FreeFormDeformation provides deformations using a free-form deformation (FFD) based on B-splines |
| CFreeFormMeshAlgorithm | Algorithm to convert Point Based annotation to mesh |
| CFrequencyFilter1D | Apply arbitrary frequency filters to 1D input |
| CFrequencyFilter2D | Apply arbitrary frequency filters to 2D input |
| CFrequencyFilterAlgorithm | |
| CFundamentalMatrixMatchPruner | Pruner using fundamental matrix inlier threshold |
| CGated4DImageSetDisplayDataController | GUI controller for synchronizing multiple 4D datasets through gating metadata |
| CGatedLinear4DImageRegistration | Registers two volume clips using a rigid/affine transformation, including a gating phase offset between the two |
| CGatingMetadata | Metadata allowing to perform gating operations on periodic datasets acquired over time |
| CGaussianFilter | Applies a symmetric Gaussian filter to an image |
| CGenerateLinearShapeModel | Mean shape and linear shape model generation algorithm for anatomical structures using closed mesh representations |
| CGenericAnatomicalStructure | Generic bare-bones implementation of the AnatomicalStructure interface |
| CGenericASC | Generic implementation of the AnatomicalStructureCollection interface |
| CGenericASCImFusionFilePlugin | |
| CGl3DObject | Abstract base class for 3D objects for which a center and an extent (i.e. a bounding box) can be specified |
| CGlAlgorithmControllerFactory | Factory for built-in algorithms |
| CGlAlgorithmFactory | Factory for GL algorithms |
| CGlAngle | Angle annotation |
| CGlAnisotropicDiffusionFilter | Anisotropic diffusion filter using the explicit scheme |
| CGlAnnotation | Base class for implementing annotations |
| CGlAnnotationFactory | |
| CGlArrow | Line segment annotation |
| CGlAverageReduction | Specialization of GlReduction performing a ReductionOperator::AVERAGE reduction |
| CGlAxis | Cut Line annotation |
| CGlAxisTransformerObject | |
| CGlBall | Ball annotation, based on GlCircle annotation (basically three circles in 3 orientations) |
| CGlBilateralFilter | Bilateral Filter from Szeliski's Computer vision |
| CGlBoundingBox | Draws a bounding box |
| CGlBox | Bounding box annotation |
| CGlCircle | Circle annotation |
| CGlColormap | Wrapper around GlImage to create 1D look-up tables that provides presets for common used colormaps |
| CGlContextQt | OpenGL context using Qt as backend |
| CGlConvolutionFilter | Convolution filter |
| CGlCoordinateSystem | GlObject to render an illustration of a coordinate system into the scene |
| CGlCrosshair | Renders a crosshair as two symmetrical and orthogonal lines, with a gap in the center with a given length |
| CGlCurve | Spline annotation |
| ►CGlCurvedView | Curved slice view |
| COrthoSliceInfo | |
| CGlCurvedViewCircle | Circle annotation for curved views |
| CGlCurvedViewEllipse | Ellipse annotation for curved views |
| CGlCurvedViewOrthoSlice | Displays an ortho slice for a panorama curve |
| CGlCurvedViewPolyLine | Polyline annotation for curved views |
| CGlCurvedViewSpline | Spline annotation for curved views |
| CGlCutLine | Cut Line annotation |
| CGlDeformationGrid | The GlDeformationGrid visualizes the deformation of an image through the deformation of a grid rendered on top of the image |
| CGlDenseDeformation | Dense deformations based on a displacement map |
| CGlDepthDarkening | Implementation of the Depth Darkening technique for a simple screen-space ambient occlusion effect |
| CGlEdgeFilter | 3x3 Sobel edge filter for 2D images |
| CGlEdgeFilter3D | 3x3x3 Sobel edge filter for 3D images |
| CGlEllipse | Ellipse annotation |
| CGlExtractSlice | Extract slice from 3D volume |
| CGlFilter | Base class for filters |
| CGlFilterChain | Chain of two GlFilters |
| ►CGlFilterSet | Processing multiple images with a standard filter |
| CParamInfo | Simple container to store information about filter parameters and names |
| CGlFlattenTrackingDeformation | Deformation model based on flattening a tracking sequence |
| CGlFpsOverlay | Overlay showing a basic FPS counter inside an InteractiveView |
| CGlFreeform | Freeform annotation. Draw whatever you want |
| CGlFreeFormDeformation | Free Form Deformation |
| CGlGradient | Computes the gradient of an image in pixel coordinates |
| ►CGlGraph | Annotation for visualizing a graph consisting of nodes and edges |
| ►CDisplayOptions | |
| CFeatureCircleOptions | |
| CFeatureColorMapOptions | |
| CGeneralOptions | |
| CGlGrid | |
| CGlGuidedFilter | Guided Filter from the paper by He et al |
| CGlHistogram | Provides an interface to calculate the histogram of an image either on the CPU or on the GPU |
| CGlIcon | Renders an icon as a billboard in world space The icon will be rendered always looking towards the camera, without depth test The position is set with setWorldPosition or GlObject::setMatrix |
| CGlImage | OpenGL texture image |
| CGlImageHighlighter | GlObject that highlights an image by drawing a colored layer on top of it |
| CGlImageIntensifierAngleOverlay | Text overlay representing the current view's matrix in the form of image intensifier angles, for instance "RAO -3.3, CAU -51.5" |
| CGlImageMetric | Computation of standard metrics on a 2D or 3D image |
| CGlImageParameters | Set texture parameters for the lifetime of the object and then restore old parameters |
| CGlImageRenderer | GlObject to render an image into a GlSliceView |
| CGlImplicitlyPlanarPointBasedAnnotation | Interface extension for point-based annotations that span an area despite consisting of only 2 points |
| CGlInfiniteLine | Line annotation |
| CGlInPlaneTransformer | |
| CGlIntensityNormalizedSmoothedGradient | Gradient relative to image intensity smoothed with a constant kernel |
| CGlIsolineRenderer | GlObject to render a label map into a GlSliceView using isolines |
| CGlJointHistogram | Provides an interface to calculate the joint histogram of an image either on the CPU or on the GPU |
| CGlLabelRenderer | GlObject to render a label map into a GlSliceView |
| CGlLiftChartOverlay | Overlay displaying a LIFT chart |
| CGlLine | Line segment annotation |
| CGlLocalExtremalFilter | Local extremal Filter |
| CGlLoop | Loop annotation |
| CGlMask | Base interface for implementing polymorphic image masks using OpenGL |
| CGlMaxReduction | Specialization of GlReduction performing a ReductionOperator::MAX reduction |
| CGlMedianFilter | Median Filter |
| CGlMesh | Renders Mesh instances in 2D and 3D |
| CGlMeshOutline | |
| ►CGlMeshRendererContours | Renders the silhouette/contours of a mesh in a 3D view |
| CDisplayOptions | Complete record of rendering options for MeshRendererOutline |
| ►CGlMeshRendererIntersection | Renders the intersection between a Mesh and a Geometry::Plane using lines |
| CDisplayOptions | Complete record of rendering options for GlMeshRendererIntersection |
| ►CGlMeshRendererNormals | Renders the normals of a Mesh using line primitives |
| CDisplayOptions | Complete record of rendering options for GlMeshRendererNormals |
| ►CGlMeshRendererSurface | Highly configurable renderer to display the surface of a Mesh |
| ►CDisplayOptions | Complete record of rendering options for GlMeshRendererSurface |
| CClipping | |
| CMaterial | |
| CGlMinReduction | Specialization of GlReduction performing a ReductionOperator::MIN reduction |
| CGlNoiseFilter | Filter which adds noise |
| CGlobalICP | Global ICP point cloud alignment |
| CGlobalSettings | Class for storing and retrieving persistent global settings |
| CGlObject | Abstract base class for an renderable OpenGL object that can be hosted in a GlView |
| CGlObjectFactory | Factory singleton for creating GlObject from string IDs |
| CGlOffscreenIndicatorsOverlay | The GlOffscreenIndicatorOverlay provides indicators to data that is outside of the current view area |
| CGlOrientationMeshOverlay | Draws an overlay that shows the current camera orientation of a view on a proxy mesh |
| CGlOutlineRenderer | Light-weight wrapper to render a colored outline around any rendered GlObject |
| CGlOverlay | Abstract base class for OpenGL overlays |
| CGlOvershootControlFilter | Overshoot control for sharpening algorithms, as used in ADSOC |
| CGlPainter | |
| CGlParallelogram | Parallelogram annotation |
| CGlPlane | Plane Annotation |
| CGlPlotLegend | Display legend of a plot view as an overlay Color and marker styles replicate the plot style, however, in the text form instead of graphic renders |
| ►CGlPlotView | View for plotting data |
| CPlotInfo | Data for a single plot handle |
| CGlPoint | Point annotation |
| CGlPointBasedAnnotation | Base class for implementing point-based annotations |
| CGlPointCloud | Efficient point cloud renderer |
| CGlPointTree | Point tree annotation |
| CGlPolarToCartesian | Converts data from polar coordinate to Cartesian space, with constant degree between polar lines |
| CGlPolyLine | Line annotation |
| ►CGlPolyRigidDeformation | Poly-rigid deformation class |
| CRigidSegmentParameters | |
| ►CGlPoseGraph | Pose graph annotation |
| CConstraint | |
| CGlProductReduction | Specialization of GlReduction performing a ReductionOperator::PRODUCT reduction |
| CGlProgramIncludeManager | Helper class to manage instances of the same base shader with different abstract includes and/or defines |
| CGlRectangle | Rectangle annotation |
| CGlRectangleBillboard | Renders a fixed size rectangle billboard in the world, always facing towards the camera |
| CGlReduction | High-performance implementation of a reduction of 2D and 3D images using OpenGL |
| CGlRotationTransformer | |
| CGlScalarBarOverlay | Overlay for displaying one or multiple named scalar values represented as colored bars |
| CGlScreenSpaceAmbientOcclusion | Post-processing filter implementing Screen Space Ambient Occlusion (SSAO) |
| CGlSeparableConvolutionFilter | Separable Convolution filter |
| CGlSharpenFilter | Unsharp Mask filter |
| ►CGlSlice | Represents an MPR slice for rendering Data into 2D views |
| CRenderbuffer | |
| CRenderInfo | Structure storing information on how to render a data set |
| CGlSliceIndicator | Renderer to show the position/orientation of GlSlice instances in context of other Views |
| CGlSliceRenderer | Interface for a class that can render data into a GlSlice/GlSliceView |
| CGlSliceRendererImage | Enables GlSlice to render normal images/volumes (SharedImageSet) |
| CGlSliceView | OpenGL view for 2D slice rendering of one or multiple images and GlObjects |
| CGlSmartSpline | Intelligent spline annotation |
| CGlSmoothingFilter | Gaussian smoothing filter |
| CGlSpline | Spline annotation |
| CGlSumReduction | Specialization of GlReduction performing a ReductionOperator::SUM reduction |
| CGlTexelFetch | Read single intensity values from an OpenGL texture |
| CGlText | |
| CGlTextOverlay | Renderer for displaying text as view overlay |
| CGlToolTargetOverlay | Overlay for displaying the distance and orientation of a tool with respect to a target position |
| CGlTPSDeformation | Deformations using a thin-plate splines (TPS) |
| ►CGlTrackingSequence | Render-class for a TrackingSequence |
| CDisplayOptions | Record of settings to configure the appearance of a GlTrackingSequence |
| CGlTransformerObject | |
| CGlTranslationTransformer | |
| CGlTree | Point tree annotation |
| CGlVesselnessFilter | Computes a multi-scale vesselness measure based on Frangi's filter |
| ►CGlView | Base class for implementing OpenGL views |
| CViewStateGuard | Temporarily changes the GL::ViewState of a GlView and resetting to the original value on destruction |
| CGlVitalsOverlay | Overlay illustrating the ECG and other vitals data signals together with the current focus frame |
| CGlVolumeCompounding | Compounding of multiple volumes (SharedImageSets) with different modalities for the computation of the resulting voxel values (Mode): Mean, Median, Maximum, and Distance |
| ►CGlVolumeRenderer | Interface for a class that can render volumetric data into a GlVolumeView |
| CRenderTextures | Helper struct to encapsulate all input/output textures needed/used during direct volume rendering |
| ►CGlVolumeRendererBasic | Basic implementation of a direct volume renderer that supports different compositing modes |
| COpacityPeelingParameters | Record of parameters for configuring Opacity Peeling in the GlVolumeRendererBasic |
| ►CGlVolumeRendererGlobalIllum | GlVolumeRenderer that supports global illumination in terms of shadows and local ambient occlusion |
| CShadingParameters | Structure encapsulating a Phong shading configuration |
| ►CGlVolumeView | OpenGL view for 3D rendering and correct compositing of direct volume rendering and classic geometry-based GlObjects |
| CPickingToken | GlVolumeView uses tokens to handle access to object picking. The token enables picking and keeps it active until the last associated token gets destroyed |
| CRenderBufferWrapper | Helper class to allow the injection of custom render buffers surrounding the entire render pipeline |
| CGlXClaheFilter | XClahe filter |
| CGMSPruner | Pruner applying motion smoothness as a criterion (GMS) |
| ►CGraph | Class for representing a (potentially directed) graph |
| CEdgeInfo | Information stored at each edge of the graph |
| CFeatureDescriptor | |
| CNodeInfo | Information stored at each node of the graph |
| CGraphBasedSegmentation | Image segmentation in 2D or 3D using graph-based segmentation |
| CGraphDataAnnotationFactory | |
| ►CGraphDataController | Controller for managing interactive feature-based color mapping for graphs |
| CFeatureColorMapper | Component that maps numerical feature values to RGBA colors |
| CFeatureLegend | Provides a colormap legend overlay for a graph |
| CGraphLaplacianAlgorithm | Image segmentation in 2D or 3D using graph-based segmentation to solve a Laplacian problem |
| ►CGraphManipulator | A manipulator for graphs. It expects Graph::Interaction(s) to be added |
| CInteraction | |
| CGraphMLIoAlgorithm | Algorithm for loading/saving a graph to a .graphml file |
| CGraphPlugin | Plugin for algorithms from Graph module |
| CGraphPluginControllerFactory | Factory for controllers of the Graph plugin |
| CGraphPluginFactory | Factory for algorithms of the Graph plugin |
| CGraphReindexingAlgorithm | Algorithm to renumber nodes in a connected graph starting from a specified root using DFS traversal |
| CGraphSmoothingAlgorithm | |
| CGraphToPointCloudAlgorithm | Algorithm to convert graphs into point clouds by treating vertices as point cloud points |
| CGridBasedMatcher | Grid-based matcher for feature descriptors |
| CGroupedStereoImageStream | GroupedStereoImageStream simultaneously owns and controls its stereo sub-streams |
| CHandEyeCalibrationAlgorithm | Performs hand-eye calibration between two tracking sequences |
| CHDF5IoAlgorithm | Algorithm for reading HDF5 files |
| CHistogramDataComponent | DataComponent storing information on the intensity distribution of the image they are attached to |
| CHistogramDisplayWidget | Qt Widget for displaying and manipulating a histogram from MeshDistanceController |
| CHistogramIntensityClusteringAlgorithm | HistogramIntensityClusteringAlgorithm |
| CHistogramInteraction | Implements mouse interaction logic for the InteractiveHistogramOverlay |
| CHomographyAndFundamentalMatrixDecomposition | This 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 |
| CHomographyMatchPruner | Pruner using homography inlier threshold |
| CHoughTransformAlgorithm | Hough transform wrapper algorithm |
| CHsvColorPicker2d | QWidget allowing for selecting 2 components of the HSV color space |
| CHsvHueSlider | Specialized version of a CompositeSlider that renders the HSV hue color map as background |
| CHuffman | Huffman code for data compression |
| CICP | ICP-based point cloud alignment |
| CIdentityMatchPruner | Identity match pruner, returns input matches unchanged |
| CIdentitySampler | Identity sampler, returns input keypoints unchanged |
| CIlium | |
| CImage | Base class and interface for images |
| CImageBasedGatingAlgorithm | Compute cardiac or respiratory gating parameters by detecting periodic structural change in the images |
| CImageComparison | Comparison of different images |
| CImageCompression | Saving and loading of compressed image data |
| CImageCompressionCodec | Saving and loading of compressed image data through video codecs |
| CImageDescriptor | Struct describing the essential properties of an image |
| CImageDescriptorWorld | Convenience struct extending an ImageDescriptor to also include a matrix describing the image orientation in world coordinates |
| CImageDownsampler | Manager for image downsampling/upsampling |
| CImageGatingAlgorithm | Algorithm to bin image sets according to a gating signal |
| CImageInfoDataComponent | DataComponent storing general information on the image origin |
| CImageInpaintingAlgorithm | Algorithm that inpaints a masked area of an image |
| CImageIoAlgorithm | Algorithm for reading and writing all supported 2D image formats |
| CImageMathPlugin | |
| CImageMattingAlgorithm | Algorithm for image matting using guided filter |
| CImageOutStream | Image stream which is sent by an OutputConnection through network or other ports |
| CImagePyramid | Represents a pyramid of images with decreasing resolution |
| CImageRegistration | High-level interface for image registration |
| CImageRegistrationController | |
| CImageResamplingAlgorithm | Algorithm for resampling an image to a target dimension or resolution, optionally with respect to another image |
| CImageResamplingController | Controller for image resampling |
| CImageSequenceRegistration | Registers a SharedImageSet of multiple images |
| CImageSetAutoCorrelation | Compute an auto-correlation (band) matrix of an image set |
| CImageSetIoAlgorithm | Algorithm for reading all 2D images in a directory into an image set |
| CImageSharpnessEstimationAlgorithm | Algorithm for esimating sharpness of the image (based on paper "The Blur Effect: Perception and Estimation with a New No-Reference Perceptual Blur Metric") |
| ►CImageStatisticsAlgorithm | |
| CChannelStatistics | |
| CImageStatisticsController | |
| CImageStream | Specialization of Stream for streams producing 2D or 3D images |
| ►CImageStreamCache | A singleton class for caching the output of an ImageStream in a SharedImageSet |
| CStreamCacheElement | |
| CImageStreamData | Image data streamed from a streaming device |
| CImageStreamRecorder | Records images from an ImageStream |
| ►CImageTemplate | Class representing a template for extracting image content based on named reference regions |
| CRegion | |
| CImageTemplateDataComponent | Data component for storing a ImageTemplate in a SharedImageSet |
| CImageTemplateMatchingAlgorithm | Manages a list of image templates for a given ImageStream |
| CImageTransformer | Generic way of transforming from the pixel coordinates of one image to the pixel coordinates of another image including any world transformations |
| CImageUndistortion | This class enables the undistortion of images, i.e |
| CImageUndistortionAlgorithm | Algorithm for undistoring images, intrinsics and distortion parameters are retrieved from CameraCalibrationDataComponent, if not then user defined ones are used |
| CImageView2D | High-level wrapper class for 2D/MPR rendering of one or multiple images |
| CImageView2DAdapter | Helper class providing the API of ImageView2D while wrapping around either a ImageView2D or a GUI::SliceView |
| CImageView3D | Qt widget for 3d rendering of one or multiple images |
| CImageView3DAdapter | Helper class providing the API of ImageView3D while wrapping around either a ImageView3D or a GUI::VolumeView |
| CImFusionFile | Loading and saving of the ImFusion file format |
| CImFusionFileGroup | Groups for combining different data (with additional properties) within the ImFusion file format |
| CImFusionFileIoAlgorithm | IoAlgorithm to for the ImFusionFile format |
| CImFusionFileIoController | Dialog for adjusting image compression settings |
| CImFusionFilePlugin | Allow loading and saving of custom classes and data within the ImFusion file format |
| ►CImFusionImage | Loading and saving of the ImFusion image format |
| CImFusionImageHeader | For image types, the corresponding data block contains the following header |
| ►CImFusionPlugin | Base class for plugins that can be loaded by the ImFusion SDK |
| CVersionInfo | |
| CImpliedLocalCoordinates | Helper class for storing an "image" representation of an object, and converting to/from image and world representations |
| ►CIMURawMetadata | Metadata for (multiple) IMU sensor raw data |
| CIMURawSample | |
| ►CInstrumentCalibrationDataComponent | Data component representing the calibration matrix for a set of instruments |
| CCalibration | |
| CIntAdjusterWidget | Widget combining a slider with a spin box for configuring integer values |
| CIntegerAdjusterParamControl | Represent a ParamType::Integer with a IntAdjusterWidget |
| CIntegerParamControl | Represent a ParamType::Integer with a QSpinBox |
| ►CIntensityClusteringAlgorithm | Algorithm for intensity-based clustering using k-means |
| CGaussianCluster | Struct to represent clusters |
| CIntensityMask | Masks pixels with a specific value or values outside a specific range |
| CInteraction | Base interface class for view and overlay interactions |
| CInteraction3D | Standard 3D view interaction |
| CInteractionOrthoView2D | Ortho 2D view interaction |
| CInteractionPlotView | Interaction class for plot view |
| CInteractionView2D | |
| CInteractionView3D | Standard 2D/3D view interaction |
| CInteractive | Strongly typed templated version of an InteractiveObject |
| CInteractiveAnnotation | |
| CInteractiveButtonOverlay | Interactive overlay for a click-able button |
| ►CInteractiveCroppingBox | |
| CCropBox | Helper struct for storing the size and center of the box in pixel coordinates |
| CCropOffsets | Helper struct for storing the offsets of the lower and upper corner points of the box |
| CInteractiveHistogramOverlay | Wraps a GlHistogramOverlay object (that contains a GlHistogram) in an InteractiveOverlay |
| CInteractiveObject | Wraps a GlObject pairing it with an optional Manipulator in order to attach it to an InteractiveView |
| CInteractiveOrientationMeshOverlay | Wraps a GlOrientationMeshOverlay and does not provide any interactions |
| CInteractiveOverlay | Wraps a GlOverlay in order to display it at specific positions in an InteractiveView |
| CInteractiveScaleOverlay | Wraps a GlScaleOverlay |
| CInteractiveSegmentationAlgorithm | Interactive segmentation algorithm |
| CInteractiveSegmentationController | Controller for interactive segmentation |
| CInteractiveSegmentationWatershedAlgorithm | |
| CInteractiveView | Abstract base class for a view that can be hosted by a DisplayWidget |
| CInteractiveViewAdapter | Helper class providing the API of InteractiveView while wrapping around either a InteractiveView or a GUI::View |
| CInteractiveViewOptionsOverlay | Button overlay for InteractiveView that allows for setting up the view or display options of the view |
| CInterfileIoAlgorithm | IoAlgorithm for loading and saving images stored in Interfile format |
| CInterlacedToStereoAlgorithm | This algorithm converts a interlaced image into two shared image sets or a stereo image set Input image should have even number of lines |
| CInterlacedToStereoStreamAlgorithm | This class convert a stream with interlaced image into a stereo image stream Input image should have even number of lines |
| CIntervertebralDisc | |
| CIntraOralFilter | Intra-oral filter |
| CIntroPage | |
| CInvertDeformationAlgorithm | Algorithm to compute the inverse of a deformation |
| CIoAlgorithm | Interface for describing IO algorithms |
| CIoController | Controller for image IO |
| CItemControl | ItemControl abstract interaface |
| CItemViewWidget | Widget containing an abstract item view, reprensenting a model, as well as configurable options to edit the model |
| CIterativeLinearSystemSolver | Interface for interative linear system solvers |
| CJpegIO | Class for reading and writing JPEG images |
| CKalmanFilter | Generic Kalman filter |
| CKalmanPosition | Kalman filter for position data |
| CKalmanQuaternion | Kalman filter for quaternions |
| ►CKeyboardShortcutManager | Singleton class to manage global keyboard shortcuts |
| CAction | Small structure encapsulating a shortcut action |
| CKeyNode | Node element used in KeyTree below |
| CKeypoint | Structure representing a detected keypoint and its descriptor |
| CKeypointManipulator | |
| CKeyTree | Data structure that hierarchically organizes anatomy keys (strings) |
| ►CKeyValueStore | Template class for storing key/value pairs |
| CEntry | |
| CKeyValueStoreVisualiser | Helper class for managing GlObjects for every item in a KeyValueStore across a set of views |
| CKeyValueStoreVisualiserParent | |
| CKeyValueStoreVisualizerBase | |
| CKinectAzureStream | Provides a high-level interface for streaming RGB-D data from Microsoft Kinect Azure sensors |
| ►CKinectAzureStreamPlaybackAlgorithm | Provides playback functionality for MKV recordings from Microsoft Kinect Azure RGB-D sensors |
| CCapture | Structure holding decoded frame data for a single capture |
| CFrameDecoder | Decoder for video frames in Kinect Azure MKV recordings |
| ►CKinectAzureStreamRecordingAlgorithm | Provides recording functionality for streams from Kinect Azure RGB-D sensors |
| CFrameEncoder | Encoder for video frames in Kinect Azure recordings |
| CPerFrameMetaData | Structure for per-frame metadata |
| ►CLabelDataComponent | DataComponent to store meta data of a label map |
| CLabelConfig | Helper struct encapsulating the metadata of a label value |
| CLabelDataComponentWidget | Widget to display and manipulate the per-data rendering options of a 3D view |
| CLabeledParamControl | Composite control that wraps an existing ParamControl and adds a label to the left of it |
| CLabeledSlider | This class wraps a QSlider and two QLabels |
| CLabelingAlgorithm | Labeling algorithm |
| CLabelingController | Controller for labeling algorithm |
| CLabelingManipulator | Manipulator for circle-based annotations |
| CLabelMapInterpolationAlgorithm | Algorithm to run a 3D interpolatation of a label map with sparsely labelled slices EITHER Input is a 3D label map with a couple of non-zero z-slices, output is the interpolated volume OR Input is a set of 2D label maps some of them being not empty, output is the interpolated 2D sequence |
| CLabelMapPropagationAlgorithm | Algorithm to propagate a label map along a sequence of images |
| CLabelMapToContoursAlgorithm | Algorithm to generate a closed contour encompassing a label map |
| CLabelMapToRTStructure | Converts a LabelMap to RTStructures |
| CLabelOverlapAlgorithm | |
| CLabelOverlapEncoder | Helper class to encode overlapping labels into an 8bit label map |
| CLabelResizeHandler | |
| CLabelsOperationsAlgorithm | Algorithm to combine multiple labels set into a new shared image set |
| CLabelStatisticsAlgorithm | The LabelStatisticsAlgorithm computes image statistics depending on several label maps |
| CLabelsToNarrowBandAlgorithm | Algorithm that creates a narrow band around an object represented by a label map |
| CLabelToFrameBasedPointCloudAlgorithm | Given a label map and a tracked shared image set, create a frame based point cloud |
| CLabelToMeshAlgorithm | Algorithm to convert label maps to meshes |
| CLandmarksToImageAlgorithm | Algorithm to generate learning data on the position of landmarks in images |
| CLaplacianPyramid | Represents a pyramid of image details with decreasing resolution |
| CLaserLocker | Provides management and acquisition of laser locks for RGB-D sensors |
| CLaserManager | Manages synchronization and coordination of laser states among multiple RGB-D sensors |
| CLazyInstantiatedDataComponent | Extended interface for DataComponents that support lazy instantiation / lazy retrieval |
| CLC2 | Linear correlation of linear combination (LC2) similarity measure |
| CLC2Preprocessing | |
| CLeastSquaresPoseGraphSolution | Pose graph optimization with Least Squares solution based on g2o's implementation The first pose is the reference pose and will stay fixed, all other poses are free to change |
| CLevenbergMarquardt | Levenberg-Marquardt optimizer |
| CLiftChartOverlayAlgorithm | |
| CLiftChartOverlayController | Controller with a dummy algorithm |
| CLightweightController | Interface to set a display instance on a Controller or DataController class |
| Clike_pointer | |
| Clike_pointer< std::shared_ptr< T > > | |
| Clike_pointer< std::unique_ptr< T > > | |
| Clike_pointer< T * > | |
| CLinearGridRegistration | Registers a set of images arranged in a 2D grid |
| CLinearImageRegistration | Registers two images using a rigid/affine transformation |
| CLinearRegression | Class for linear regression |
| CLinearSystemSolver | Interface for linear system solvers |
| CLineHoughTransform | |
| ►CLineToIsosurfaceIntersectionAlgorithm | Finds the intersection between a ray and the first isosurface |
| CIntersectionCylindricalCoordinates | |
| CLineToIsosurfaceIntersectionController | Controller for the LineToIsosurfaceIntersectionAlgorithm |
| ►CLinkPose | Synchronizes the pose matrix across multiple Data instances |
| CLinkHandler | |
| CLinkItem | |
| CLinkPoseDeformable | Links the pose of two or more data instances if there is deformation present |
| CLinkPoseDeformableController | Default algorithm controller for LinkPoseDeformable algorithm, with a slight modification to have GlMesh access |
| CLinkSelection | Synchronizes the selection of multiple Selectables |
| CLinkWindowing | Synchronizes DisplayOptions2d and DisplayOptions3d of multiple images |
| CListModelView | Represents a QListView, and the container ItemViewWidget. The model can be accessed in ItemViewWidget::model or QListView::model |
| CLiveHandEyeCalibrationAlgorithm | Takes two tracking streams, and allows to sample frames and to compute the calibration from them The expected input is a stream containing the transforms from base to hand (i.e |
| CLiveHandEyeCalibrationController | Controller for sampling and computation of the calibration |
| CLiveHandEyeEvaluationAlgorithm | Takes two tracking streams and the respective calibration, and computes the chain error |
| CLiveHandEyeEvaluationController | Controller for determining the type of calibration to be checked, and inspect the result |
| CLiveImageBasedGating | Compute cardiac or respiratory gating parameters by detecting periodic structural change in the images To use, feed a consecutive block of frames into initialize and get their phase values |
| CLiveImageBasedGatingTestAlgorithm | |
| CLiverDetectionAlgorithm | Automatically segments the liver with a neural network on MR and CT datasets |
| CLiveSensorFusion | Abstract base class for 9DOF sensor fusion algorithms |
| CLiveStereoCalibrationAlgorithm | Takes two image streams, and allows to sample frames and to compute the calibration from them Both streams have to see the same calibration board The output is the intrinsic calibration for each camera, transformation between the cameras and the deformation fields for stereo rectification Another variant of the algorithm takes image samples as an input |
| CLiveStereoCalibrationController | Controller for sampling and computation of the calibration |
| CLiveStreamingAlgorithm | Takes images from ImageStream (8bit images) encodes them and sends them via a web socket |
| CLiveStreamProcessingAlgorithm | Abstract base class for algorithms performing live stream processing without necessarily recording the data |
| CLiveTrackingAlgorithm | Live tracking algorithm for image based pose detectors Use the Configurable interface for setting up the detector |
| ►CLiveTrackingPointRegistrationAlgorithm | Performs point-based registration between a volume and a tracked tool |
| CCorrespondence | Legacy structure representing a correspondence between volume and tracker coordinates |
| CLLTEigenSolver | Solver using Cholesky decomposition of the matrix (Eigen implementation) |
| CLLTFloatSolver | Solver using Cholesky decomposition of the matrix |
| CLoadRawDialog | Dialog for loading raw files, conveniently figuring out dimensions and settings |
| CLoadSpineTemplateAlgorithm | |
| CLoadUnknownDialog | Dialog for opening files without specified type |
| CLocalizationInputData | Data for one localization evaluation instance -> one input scan + groundtruth keypoints |
| CLoggingTimer | Scope guard-like stopwatch class to automatically log measured execution time on destruction of the guard object |
| CLogisticRegression | Class for logistic regression |
| CLogViewerWidget | Logging sink that manifests itself as a Qt widget showing formatted log messages and allowing for basic filtering |
| CLogWidgetOptions | |
| CLoopManipulator | |
| CMadgwick | Madgwick sensor fusion |
| CMahony | Mahony sensor fusion |
| CMainWindowBase | Extends ApplicationController with additional interfaces for graphical user interfaces |
| CMakeCompatibleLabelMapAlgorithm | Algorithm to create a label map compatible with an image |
| CManipulator | Abstract base class for manipulator objects |
| CManipulatorListener | Interface for manipulator events |
| Cmap_arrow_proxy | |
| CMarkAsLabelMapAlgorithm | Algorithm to mark any image as a Label Map |
| ►CMarkerConfiguration | Describes the configuration of a marker calibration target |
| CAprilTagBoardInfo | Information about a board of AprilTags |
| CAprilTagInfo | Information about a single AprilTag |
| CArucoBoardInfo | Information about a board of Aruco markers |
| CArucoMarkerInfo | Information about a single Aruco marker |
| CCharucoBoardInfo | Information about a Charuco board |
| CChessboardInfo | Information about a chessboard |
| CCircleBoardDetectorParameters | Detector parameters for Circle Board markers |
| CCircleBoardInfo | Information about a circle board |
| CDetectorParameters | Detector parameters for Aruco markers, boards and Charuco boards |
| CSTagInfo | Information about a single STag |
| CMarkerConfigurationWidget | |
| CMarkerDetection | Generic marker detection class for a wide range of marker types, such as Aruco, Charuco, Chessboard, Circle Board, AprilTag and STag |
| CMarkerDetectionAlgorithm | Marker detection algorithm |
| CMarkerGenerationAlgorithm | Algorithm for creating calibration markers |
| CMarkerHandEyeCalibrationAlgorithm | Performs hand eye calibration of a sensor that provides tracking information (called "tracker") to a camera that captured images of a marker board (called "camera") |
| CMask | Base interface for implementing polymorphic image masks on the CPU |
| CMaskEditor | |
| CMaskEditorController | |
| CMaskFluoroImageAlgorithm | Detect circle in fluoro shots |
| CMatchScorePruner | Pruner based on match score and/or maximum number of matches |
| CMatchWindowingAlgorithm | Algorithm for matching window/level between two images |
| CMatMulExpr | |
| CMatrixParamControl | |
| CMatrixParameterDialog | Dialog to host a MatrixParameterWidget |
| CMatrixParameterWidget | Widget containing a transformation matrix widget and a transformation stash |
| CMatrixParameterWrapper | Wrap a matrix into a ParameterWrapperBase instance |
| CMeasuring | Measure primitives from 2D and 3D volume |
| CMemImage | Abstract base class for an image residing in main memory |
| CMergeASCAlgorithm | This algorithm combines the AnatomicalStructures within multiple AnatomicalStructureCollection objects into one AnatomicalStructureCollection |
| CMergeChannelsAlgorithm | Merge an image set to another one as additional channel |
| CMergeFrameBasedPointCloudsAlgorithm | Algorithm for merging frame-based point clouds |
| CMergeTrackingSequencesAlgorithm | Merges multiple tracking sequences into a new one |
| ►CMesh | Represents a triangle mesh |
| CTopologyErrors | Adds a new face, consisting of the 3 existing(!) vertices specified by their indices |
| CMeshAlignmentAlgorithm | Algorithm for aligning meshes and point clouds |
| CMeshBooleanOperationsAlgorithm | Algorithm for performing boolean operations on meshes |
| CMeshCollisionDetectionAlgorithm | Algorithm that checks for collision between groups of meshes |
| CMeshCollisionDetectionController | |
| CMeshCreatorAlgorithm | Algorithm for creating common mesh primitives |
| CMeshDataController | GUI controller for adjusting visualization of meshes |
| CMeshDisplayOptions | DataComponent to store the configuration how meshes should be rendered by default (through MeshDisplayHandler) |
| ►CMeshDistanceAlgorithm | Algorithm to compute point-wise distances between two aligned meshes, between two aligned point clouds, or between aligned point cloud and mesh |
| CStat | |
| ►CMeshDistanceController | Controller for the MeshDistanceAlgorithm |
| CHistogram | |
| CMeshExpr | |
| CMeshGeodesicDistance | Class for computing the geodesic distance on the mesh surface between the 2 points |
| CMeshGl | Stores vertex and texture data of a Mesh on the GPU so that it can be rendered using OpenGL |
| CMeshGroupCollisionDetection | Test for collision between two groups of meshes |
| CMeshIoAlgorithm | Algorithm for reading and writing meshes |
| CMeshIterator | |
| CMeshIteratorRel | |
| CMeshLaplacian | Compute co-tangent laplacian of a mesh and its eigen decomposition |
| CMeshManipulator | Mesh manipulator with 3d controls |
| CMeshMeasurementsAlgorithm | A class that provides functions for measuring the lengths of certain curves on a mesh |
| ►CMeshMeasurementsController | |
| CMeasurementPlane | |
| CMeshOctree | Class representing a mesh octree. Faces of the mesh are split between the nodes of the tree, each node represents a partition of the parent volume (minimum 1/8th) |
| CMeshOctreeNode | Class representing a mesh octree node |
| CMeshPickingManipulator | Mesh picking manipulator The MeshPickingManipulator can return the list of selected vertices/faces/edges It offers several manipulation modes like double-click, hover, alt + mouse key press For proper use the MeshPickingManipulator object must be added to a view as mesh manipulator and the outer object should subscribe to its signals e.g |
| CMeshPointCloudCroppingAlgorithm | Algorithm for cropping point clouds or/and meshes |
| CMeshPointCloudCroppingController | Controller for mesh (point cloud) cropping algorithm |
| CMeshProcessingAlgorithm | Wraps different mesh processing functionality into a single algorithm |
| CMeshToLabelMapAlgorithm | Algorithm to perform a voxelization (conversion) of a mesh to a label map |
| CMeshToPointCloudAlgorithm | Algorithm to convert a mesh to a point cloud |
| CMetaImageIoAlgorithm | Algorithm for reading and writing MetaImage files |
| CMincIO | Class for reading and writing MINC images |
| CMinimumBoundingBox | Algorithm for computing the minimum axis-aligned bounding box from image data |
| CMinimumSpanningTreeAlgorithm | Algorithm to compute the Minimum Spanning Tree (MST) of an undirected cyclic graph, i.e |
| CMirrorRegistrationAlgorithm | Locally Estimate Mirror symmetry of a volume, and use it to estimate the mirror plane |
| CMissingLicenseException | Exception thrown in case a suitable license could not be found or activated |
| CMLPlugin | Plugin for algorithms from ML module |
| CModelEvalLog | |
| CMonocularDepthEstimation | Base class for monocular depth estimation algorithms producing depth maps and (optionally) also point clouds |
| CMonocularDepthEstimationAlgorithm | Algorithm for estimating relative depth from a single RGB image |
| CMonocularDepthEstimationCustomModel | Performs depth estimation on a monocular image using a traced machine learning model provided by the user |
| CMonocularDepthEstimationDepthAnything | |
| CMonocularDepthEstimationFactory | |
| ►CMorpho | Morphological operations (erosion/dilation) in 2D and 3D |
| CDilateByBlock2D | |
| CDilateByBlock3D | |
| CErodeByBlock2D | |
| CErodeByBlock3D | |
| CMorphologicalInterpolationAlgorithm | Algorithm to interpolate between two label maps |
| CMorphologicalOperationsAlgorithm | Algorithm for performing morphological operations on images |
| CMotionAveragingPoseGraphSolution | Pose graph optimization with motion averaging, this is to be utilized in MAICP The first pose is the reference pose and will stay fixed, all other poses are free to change |
| CMotionModel | Motion model of smooth (modeled by splines) homogenous transformations over time |
| CMultiLogisticRegression | Class for multiple logistic regressions (to be used for multi-label classification) |
| CMultinomial | |
| CMultiSensorCalibration | Provides functionality for external calibration of multiple RGB-D sensors using markers |
| CMultiTimer | This class can be used to help the developer to profile the run time of different parts of the same process |
| CMVSTexturing | Provides multi-view stereo (MVS) texturing for 3D meshes using RGB-D image sets |
| CNavigationAlgorithmControllerFactory | Factory for controllers for navigation algorithms that are registered in the NavigationAlgorithmFactory |
| CNavigationAlgorithmFactory | Factory for algorithms in the navigation plugin |
| CNavigationPlugin | Plugin for real-time navigation and visualization of tracking tools |
| CNDITrackingController | Stream algorithm controller to configure NDITrackingStreams |
| CNDITrackingInstrumentInfo | NDI instrument info |
| CNDITrackingStream | Base class for NDI tracking streams (Polaris/Aurora and Ascension), which share the same controller |
| ►CNearestNeighborSearch | Nearest neighbor search for points |
| COutputWrapper | Helper class for optional distance output, implicitly created from output type T. Do not use directly |
| CNestedProgress | Wrapper class to provide the Progress interface, ensure certain invariants for created tasks and/or optionally forward the progress information to an existing Progress |
| CNiftiIO | Class for reading and writing Nifti images |
| CNiftiIoAlgorithm | Algorithm for reading and writing NIFTI data |
| CNMSSampler | Non-Maximum Suppression sampler |
| CNode | Class representing a tree node |
| CNodeToEdgeFeatureAlgorithm | Applies a specified binary operation (e.g., difference, sum, average) to features of connected nodes and stores the computed values as edge features |
| ►CNrrdIoAlgorithm | Algorithm for reading NRRD images |
| CNrrdHeader | |
| CNuclearMedicineImageIOD | PS 3.3 A.5 Nuclear Medicine Image IOD Does not support saving yet |
| COctree | Fast Octree space subdivision |
| COctreeDataComponent | DataComponent to store Octrees directly with their SharedImageSet |
| COfflineStream | Stream class which supports step-by-step playback and direct access of data samples |
| COpacitySlider | Specialized version of a CompositeSlider that renders a checkerboard blended with the given color as background |
| COpenNI2RGBDStream | Provides a stream interface for RGB-D sensors using the OpenNI2 framework |
| COpticalFlow | Base class for optical flow algorithms producing flow maps (2-channel floating point images) |
| COpticalFlowAlgorithm | Algorithm to compute the optical flow along a sequence of images |
| COpticalFlowCustomModel | Performs optical flow estimation using a traced machine learning model provided by the user |
| COpticalFlowFactory | |
| COpticalFlowRAFT | |
| COpticalFlowSEARAFT | |
| COptimizationDialog | |
| ►COptimizationStudy | Holds optimization study results and offers methods for analyzing results |
| CRecord | Structure for a single optimization study record |
| COptimizeParametricDeformationAlgorithm | |
| COptimizer | Non-linear optimization |
| ►COptimizerBFGS | Implementation of the Broyden–Fletcher–Goldfarb–Shanno (BFGS) optimizer |
| CState | |
| COptimizerDiRect | Global optimizer based on Dividing Rectangles algorithm |
| COptimizerFactory | Factory for creating an Optimizer |
| COptimizerNelderMead | Local optimizer based on Neldea-Mead algorithm (also known as downhill simplex method) (see for instance https://en.wikipedia.org/wiki/Nelder%E2%80%93Mead_method) |
| COptimizerNL | Non-linear optimization using the NLOpt library |
| COptimizerReload | Optimizer that reloads all information from a previously logged file |
| COptimizerSeries | Series of multiple sucessive optimizations bundled in one execution |
| COptimizerWrapper | Wrapper around Optimizer and CostFunction classes to work on simple lambda functions |
| COptimizerXNES | XNES optimizer |
| COptimizingAlgorithm | Algorithm class supporting an optimizer |
| COptionalParamControl | Composite control that wraps an existing ParamControl and adds a checkbox to the left of it |
| ►COrbbecRGBDStream | Provides a stream interface for Orbbec RGB-D sensors (starting from Astra+) |
| CSensorConfig | Sensor configuration for multi-device synchronization |
| ►CORBFeatureDetector | Implementation of the ORB feature detection and description algorithm |
| CORBKeyPointIterator | Iterator for ORB keypoints, supports multi-level traversal |
| COrientedVertebra | A representation of a vertebra, containing orientation, classification keypoints, segmentations, meshes and all other related information |
| COutputConnection | Interface for connections to other devices for sending streams, volumes, and other information through network, USB port or other connection types |
| COutStream | Base class for streams which are sent by an OutputConnection through network or other ports |
| COverlayInteraction | Base class for all overlay interactions |
| COwningDataList | Wrapper class to store a list of owned Data instances |
| CParamControl | Base class for parameter controls |
| CParameter | The Parameter class represents a single parameter of a Configurable entity |
| CParameterBase | Shared base interface of Parameter and SubProperty so that Configurable can maintain a collection of those |
| CParameterOptimization | Class for combining a ParameterWrapperBase instance with a cost function over C++ objects to produce a CostFunction that can be optimized over with an Optimizer instance |
| CParameterWrapperBase | Base class for classes that wish to expose zero or more optimization parameters |
| CParametricDeformableRegistration | Registers two images with a non-linear deformation based on TPSs |
| CParametricDeformation | Base interface for a parametric deformation in 2D or 3D |
| CParametricDeformationOptimizer | Runs a non-linear optimization on a ParametricDeformation in order to match its deformation to a given reference displacement field |
| CParametricImageRegistration | Base class for parametric image registration algorithms |
| CParametricImageRegistrationController | |
| CParseFolderAndRunWorkspaceAlgorithm | Algorithm to parse through folder structures and run a workspace on individual files |
| CParseFolderAndRunWorkspaceAlgorithmController | Controller for the algorithm parsing folders and running a workspace on them |
| CPartitionGraphsAlgorithm | Algorithm to partition a graph into its connected components |
| CPathParamControl | Represent a ParamType::Path with a QLineEdit and a QToolButton that opens a file dialog |
| CPCA | |
| CPersistentDataComponent | Base class for DataComponents that must never be deleted from a DataComponentList |
| CPgmIO | |
| CPhilipsQLabIOD | Loads ultrasound volume stored by Philips QLab software |
| CPlaybackAlgorithm | Creates PlaybackImageStream and/or PlaybackTrackingStream from one SharedImageSet, one TrackedSharedImageSet, or one or multiple TrackingSequences |
| CPlaybackController | Controller for replaying (potentially tracked) shared image sets |
| CPlaybackStereoImageStream | StereoImage-based stream created from the playback of a stereo image set |
| CPlaybackStereoImageStreamAlgorithm | Creates PlaybackStereoImageStream from one StereoSharedImageSet For more details please refer to PlaybackStereoImageStream |
| CPlaybackStereoImageStreamController | Controller for replaying stereo shared image sets |
| CPlaybackStream | Image-based stream created from the playback of an image set |
| CPlaybackTrackingStream | Creates simulated live tracking by playing back the data of a TrackingSequence class |
| CPlottingAlgorithm | |
| CPlottingAlgorithmController | |
| CPlotView | View for plotting data |
| CPngIO | |
| ►CPointBasedAnnotationManipulator | Manipulator for point-based annotations |
| CInteractionModeWrapper | |
| CMouseEvent | Mouse event structure |
| CPointBasedAnnotationManipulator2 | Manipulator for point-based annotations |
| CPointBasedAnnotationManipulatorEventData | Struct passed as event data to manipulator event |
| ►CPointCloud | Data structure for point clouds |
| CPointCloudData | Struct holding the underlying "heavy" data of a PointCloud object |
| CPointCloudAnalysis | Geometric analysis of a point cloud |
| CPointCloudAnalysisController | Controller for point cloud analysis |
| CPointCloudExpr | |
| CPointCloudFilteringAlgorithm | Implements a flexible and extensible algorithm for filtering and processing point clouds |
| CPointCloudIoAlgorithm | Algorithm for reading and writing point clouds |
| CPointCloudMeasuringAlgorithm | Algorithm for measuring distances between points in a point cloud |
| CPointCloudOverlapAlgorithm | Computes the geometric overlap between multiple dense, calibrated point clouds |
| CPointCloudPickingManipulator | Point cloud picking manipulator The PointCloudPickingManipulator can return the list of selected vertices The supported manipulation is alt + mouse key press with optional dragging |
| CPointCloudPlaneFittingAlgorithm | Provides plane fitting and distance computation for point clouds |
| CPointCloudToDepthMapAlgorithm | Provides conversion of a dense point cloud to a depth map |
| CPointCorr | Container for point correspondences |
| ►CPointCorrAlgorithm | Algorithm for defining point correspondences on a pair of images |
| CCorrItem | Structure encapsulating a single point correspondence item defined by a pair of points |
| CPointCorrespondenceController | Controller for defining point correspondences |
| CPointCorrespondences | Class that handles point correspondences |
| CPointCorrespondencesAlgorithm | Algorithm for managing and registering point correspondences between two Data instances |
| CPointCorrespondencesController | Controller for defining point correspondences |
| CPointCorrespondencesVisualGuide | This class calculates visual guides to assist in identifying corresponding points between different modalities |
| CPointCorrespondencesWidget | Widget that displays point correspondences in a table with buttons that allows to add and remove correspondences |
| CPointDistanceReg | Registers a point set to a distance volume |
| CPointNode | Class representing a tree point node |
| CPointsOnData | Interface class for points linked to Data |
| ►CPointsOnDataManipulator | Interface class that handles creation and manipulation of points on Data |
| CReceiver | |
| CPointsOnImage | Class that hold a list of points on a volume or image |
| CPointsOnImageManipulator | Class that handles creation and manipulation of points on a volume or image |
| CPointsOnTrackingStream | Manages a collection of points associated with a TrackingStream |
| CPointsOnTrackingStreamManipulator | Handles creation and manipulation of points from a TrackingStream |
| CPointsStorageComponent | Data component for storing and managing point sets |
| CPointTree | Data structure for trees with nodes containing a 3D point |
| CPoissonSurfaceReconstructionAlgorithm | Algorithm for computing poisson reconstruction from a point cloud with normals |
| CPolarisAuroraTrackingStream | TrackingStream wrapping the NDI Polaris/Aurora Tracking API |
| CPolyDataOutStream | Mesh or point cloud stream which is sent by an OutputConnection through network or other ports |
| CPolyDataStream | Specialization of Stream for streams producing polygonal data, such as meshes or point clouds |
| CPolyDataStreamData | Polygonal data (point clouds or meshes) streamed from a streaming device |
| CPolyDataStreamDisplayOptions | Display options for a PolyDataStream |
| CPolyDataStreamDisplayOptionsWidget | |
| CPolyDataStreamMeshDisplayOptions | Display options for a PolyDataStream mesh |
| CPolyDataStreamPointCloudDisplayOptions | |
| CPolyDataStreamVisualizationAlgorithm | Algorithm for visualizing an incoming polydata stream |
| CPolyRigidDeformationAlgorithm | Set up a poly-rigid deformation on a volume and multiple labels |
| CPolyRigidImageRegistration | Registers two images with a non-linear poly-rigid deformation |
| CPopupMenuButton | Extension of a QToolButton to which you can add a drop-down menu |
| ►CPoseGraphOptimization | Pose graph optimization The first pose is the reference pose and will stay fixed, all other poses are free to change |
| CConstraint | Constraints between nodes, i.e. relative poses between them |
| CPoseGraphOptimizationAlgorithm | Pose graph optimization using motion-averaging or graph-based least squares solver |
| CPoseHistory | Class for keeping track of the poses of an image and provide undo/redo functionality |
| ►CProgress | Generic interface to report operation/computation progress |
| CTask | Represents the progress/status report of an individual task hosted by a Progress |
| ►CProgressDialog | QDialog-based progress reporter that shows one QProgressBar for each progress task |
| CPerTaskUI | |
| ►CProjectedAnatomicalStructure | |
| CProjectiveObjectManager | |
| CProperties | Storage container for serialization of arbitrary types, internally backed by strings |
| CPropertiesInspector | Small algorithm allowing the user to inspect a Data's properties and DataComponents |
| CPropertiesListWidget | The PropertiesListWidget shows as sub-properties as a list |
| CPropertiesWidget | Widget for Properties |
| CPruneTerminalPathsAlgorithm | Algorithm to prune a graph, i.e. remove terminal paths or edged with lengths below a given threshold |
| CPureGyro | Basic sensor fusion |
| CPythonInterpreter | Starts an embedded Python interpreter and provides factories for registering algorithms from Python |
| ►CPythonInterpreterInterface | Interface for the embedded PythonInterpreter that prevents linking to an explicit Python version |
| CGILScopeGuard | |
| CPythonPlugin | Enables Python bindings for the ImFusionLib |
| CPythonSettings | Settings for the Python plugin |
| CQDebugAppender | |
| CQtAuthorizationProvider | AuthorizationProvider that shows a Qt LoginDialog |
| CQtKeyCanceller | |
| CRadon2D | |
| ►CRANSAC | This class implements a more generalized form of "Random Sample Consensus" algorithm |
| CResult | |
| CRANSACPairOfVectorsDataset | |
| CRawImageIoAlgorithm | Algorithm for reading and writing raw image data |
| ►CRealSenseStream | Provides a stream interface for Intel RealSense RGB-D sensors |
| CPropertyInfo | Structure representing information about a property configuring the sensor |
| CRange | Structure representing a value range |
| ►CRealWorldMappingDataComponent | The RealWorldMappingDataComponent stores information about an image's real world values |
| CMapping | |
| CRecentFilesMenu | QtMenu that displays recent files and favourites |
| CRecentFileWidget | Qt Widget to display recent files |
| CRecentItemsTableWidget | This widget is a table showing a list of items recently used |
| CReduceToSelection | Algorithm reducing a SharedImageSet or TrackingSequence to its selected frames/samples |
| CRegistrationFromPredictionMapAlgorithm | Algorithm to register two images based on prediction maps |
| CRegistrationInitAlgorithm | Initialize the registration of two volumes by moving the second one |
| ►CRegistrationResults | Class responsible for managing and storing the results of data registration |
| CDataResult | Represents the registration result for a single data object |
| CDataSource | |
| CResult | Represents a complete registration result, composed by multiple DataResult objects |
| CRegistrationResultsAlgorithm | Store registration results for data combinations |
| ►CRegistrationResultsBrowser | Shows a dialog allowing to browse RegistrationResults stored in a folder |
| CBrowserResult | |
| ►CRegistrationResultsController | GUI controller managing registration results |
| CListItemDelegate | Custom Item Delegate that paints an item in the results list If data(Qt::UserRole + 1).toBool() is true it adds a "GT" symbol next to the result |
| CRegistrationResultsIoAlgorithm | Algorithm for loading ImFusion Registration Results (irr) files |
| CRegPlugin | Plugin for algorithms from Reg module |
| CRegression | Abstract base class for regression |
| CRelocalization | Interface for relocalization algorithms using RGB-D data, typically used in RGBDReconstructionAlgorithm |
| CRelocalizationStack | RelocalizationStack coordinates multiple relocalization strategies to robustly estimate camera poses from RGBD images |
| CRemoteVideoStream | Creates image stream which receives the Image data via network connection |
| CRemoveEdgesWidget | Remove edges widget |
| CRemoveModalityAlgorithm | Remove the modality flag of an image data set |
| CRemoveSpacingAlgorithm | Remove the spacing of an image data set |
| CRemoveUnlabelledImagesAlgorithm | Algorithm reducing an image data set and its label maps to its labelled frames |
| ►CRendererFactory | Static factory class to manage registered slice and volume renderers to be used in views |
| CSliceRenderer | Descriptor of a registered slice renderer |
| CVolumeRenderer | Descriptor of a registered volume renderer |
| CReorderLabelValuesAlgorithm | Stacks fragmented values of a single channel UByte/UShort-typed labelmap inplace into consecutive integer values [0, ..., n] |
| CReplaceValuesAlgorithm | Replace in-place a set of image values with others values |
| CRequest | Wrapper around libcurl for simple GET and POST requests WARNING: this is experimental and only available for the LicenseManager for the moment |
| CResponse | |
| ►CRGBDCalibrationAlgorithm | RGBDCalibrationAlgorithm estimates intrinsic and extrinsic calibration parameters for RGB-D camera systems |
| CRGBDCalibration | Struct holding all calibration results for an RGBD sensor |
| CRGBDDataComponent | RGBDDataComponent stores all calibration and configuration parameters for an RGBD sensor |
| CRGBDFrame | Class for representing RGBD image |
| CRGBDIoAlgorithm | Algorithm for opening and managing RGB-D data streams |
| CRGBDMultiSequence | Collection of multiple synchronized or unsynchronized RGB-D sequences |
| CRGBDPlayback | Playback of stored RGB-D sequences |
| CRGBDPlaybackExtractionAlgorithm | Algorithm to extract depth images, color images, point clouds, and sequences from RGBDPlayback |
| ►CRGBDReconstructionAlgorithm | Algorithm for surface reconstruction from RGB-D data streams |
| CKeyframe | Keyframe structure containing depth, color, and camera data |
| CRGBDReconstructionCallback | Callback interface for RGBDReconstructionAlgorithm events |
| CRGBDRelocalization | Algorithm for relocalization using RGB-D data |
| CRGBDSequence | Interface for a single sequence of RGB-D images |
| CRGBDSequenceIoAlgorithm | Algorithm for reading and writing RGB-D sequences |
| ►CRGBDStream | Base class for RGB-D streams |
| CFrameInfo | Structure describing frame format and resolution |
| CRGBDStreamController | Controller for RGBD Streams |
| CRGBDStreamFactory | Factory for enumerating available RGB-D streams |
| CRGBDTumSequenceIoAlgorithm | Algorithm for reading and writing RGB-D sequences in the Tum folder/file format |
| CRIDEFeatureDetector | Implementation of "RIDE: Self-Supervised Learning of Rotation-Equivariant Keypoint Detection and Invariant Description for Endoscopy" published at ICRA 2024: https://ieeexplore.ieee.org/abstract/document/10611381 |
| CRmseAlgorithm | Computation of Root Mean Square Error of two SharedImageSets |
| CRollingGuidanceFilterAlgorithm | Algorithm for Rolling Guidance Filtering |
| CRTStructureAnnotation | Annotation that renders a PointCloud with a RTStructureDataComponent |
| CRTStructureToLabelMap | Algorithm to convert a PointCloud with a Dicom::RTStructureDataComponent datacomponent to a labelmap |
| CRTStructureToLabelMapController | Controller that allows to select a reference volume for the RTStructureToLabelMap algorithm |
| CSacrum | |
| CScalarParameterWrapper | Wrap a single scalar into a ParameterWrapperBase instance |
| CScaledIso3 | Class 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 |
| CScalingExpr | |
| CSectionWidget | The SectionWidget provides a way to group widgets in vertical sections |
| CSeekable | |
| CSeekableStream | |
| CSegmentationInputData | } |
| CSegmentationReductionsAlgorithm | Computes basic image reductions of segmentation images, for instance vessel segmentations, including center of gravity and area |
| CSegPlugin | Plugin for algorithms from Seg module |
| CSelectable | Interface for Data that supports having a Selection |
| CSelectFileTypeDialog | Dialog for opening files without specified type |
| CSelection | Utility class for describing a selection of elements out of a set |
| CSelectionScrollBar | Custom scrollbar to visualize data selection |
| ►CSelectionWidget | Widget and scrollbar for handling selection and playback of data |
| CPlaybackWrapper | This class provides an interface for creating wrappers that allow playback functionality to a type |
| CSensorController | UI controller for configuring an RGB-D sensor stream |
| CSequentialImageProcessor | Interface for algorithms that are able to repeatedly process individual images |
| CSetGatingMetadataAlgorithm | Algorithm to compute gating information to an image set |
| CSetModalityAlgorithm | Sets the modality flag of an image data set |
| CSetModalityController | Controller for setting the modality flag of an image data instance |
| CSetSpacingAlgorithm | Sets the spacing of an image data set |
| CSetTimestampsAlgorithm | Sets the timestamps of an image data set based on a first timestamp and frame rate |
| ►CSettings | This class provides a way for getting and setting base settings for ImFusionLib |
| CLegacyInterfaceSettings | |
| CSetting | Provides a type-safe way to access a setting value |
| ►CSettingsDialog | Presents a GUI dialog to configure the global settings |
| CCustomSettingsWidget | Base class for custom settings widgets |
| ►CSharedImage | Image shared on multiple devices |
| CRepresentation | |
| CSharedImageArithmeticAlgorithm | ImageMath algorithm class |
| ►CSharedImageRingBuffer | Holds 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 |
| CSharedImageBuffer | |
| CSharedImageSet | Set of images independent of their storage location |
| CSharedImageSetDisplayHandler | Shows regular SharedImageSet instances (no derivatives) in ImageView2D and ImageView3D |
| CShiTomasiFeatureDetector | Implementation of the Shi-Tomasi corner detection algorithm |
| CSideBySideToStereoAlgorithm | This Algorithm converts a side-by-side images set to a Stereo Image Set |
| CSideBySideToStereoStreamAlgorithm | This class convert a stream with side-by-side image into a stereo image stream |
| CSIFTFeatureDetector | Implementation of the SIFT feature detection and description algorithm |
| CSignalBase | Base interface for Signals |
| CSignalBlocker | Convenient scope guard class to temporarily block signals/connections so that observers are not notified |
| CSignalConnection | Structure for describing/identifying individual connections between signals and slots |
| CSignalImpl | Implementation for a specific signal with the given signature |
| CSignalMutexProxy | |
| ►CSignalMutexProxy< false > | |
| CEmptyLockGuard | |
| CSignalMutexProxy< true > | |
| CSignalReceiver | Base class for classes that can contain slots (i.e |
| CSimilarityMeasureDotProduct | |
| CSimilarityMeasureFactory | Generic interface to any kind of SimilarityMeasure |
| CSimilarityMeasureImpl | Base class of a similarity measure between two images |
| CSimilarityMeasureImplHistBased | |
| CSimilarityMeasureImplPixelWise | |
| CSimilarityMeasureLC2 | |
| CSimilarityMeasureLC2_CPU | |
| CSimilarityMeasureLC2_GPU | |
| CSimilarityMeasureLNCC | |
| CSimilarityMeasureLNCC_CPU | |
| CSimilarityMeasureLNCC_GL | |
| CSimilarityMeasureMI | Computes the Mutual Information of two images |
| CSimilarityMeasureMI_CPU | CPU implementation of Mutual Information |
| CSimilarityMeasureMI_GL | GPU implementation of Mutual Information using modern OpenGL |
| CSimilarityMeasureML | Machine Learning based similarity measure |
| CSimilarityMeasureNCC_CPU | |
| CSimilarityMeasureNCC_GL | |
| CSimilarityMeasureNGF_GL | |
| CSimilarityMeasurePatchBased_GL | Helper class for patch based similarity measures |
| CSimilarityMeasurePixelWise_CPU | |
| CSimilarityMeasurePixelWise_GL | |
| CSimilarityMeasureSAD_CPU | |
| CSimilarityMeasureSAD_GL | |
| CSimilarityMeasureSSD_CPU | |
| CSimilarityMeasureSSD_GL | |
| CSimilarityMeasureSSIM | |
| CSimilarityMeasureSSIM_CPU | |
| CSimilarityMeasureSSIM_GL | |
| CSimilarityMeasureTester | |
| CSimilarityMeasureWrapper | Wrapper for safe and configurable use of various similarity measures |
| CSimulatorFrame | Container for a rendered simulator frame of the SimulatorRenderer |
| CSimulatorRenderer | Renderer for simulating RGB-D sensor output from 3D models |
| CSkeletonization | Skeletonization in 2D and 3D see [Lee TC, Kashyap RL, Chu CN |
| CSkinSegmentationAlgorithm | Segment the skin surface from a CT or MRI volume |
| CSkippingMask | Basic mask where only every N-th pixel is considered inside |
| ►CSlice | Represents a planar bounded slice in 3D space |
| CCorners | |
| CSliceIndexOverlay | Renders the current slice number and total slices of the first data in the assigned view eg |
| CSliceManipulator | Interaction for slices |
| CSmartSplineManipulator | Manipulator for smart spline annotations |
| CSmoothedTrackingStream | Stream to smooth any TrackingStream |
| CSmoothMeshWidget | Smooth mesh widget |
| ►CSpine2DModelNames | Model identifiers and parameter names supported by the SpineLocalizatin2D algorithm, |
| CParamNames | |
| CSpineAlgorithmAdapterInterface | |
| CSpineAlgorithmWidget | |
| ►CSpineBaseAlgorithm | Spine localisation / classification and segmentation algorithm |
| CModelIdentifier | Collection of known model identifiers for the SpineBaseAlgorithm |
| CModelSetMetadataIdentifier | Collection of known model set metadata identifiers for the SpineBaseAlgorithm |
| CSpineBaseAlgorithmImpl | |
| CSpineBaseController | Controller for Spine Algorithms |
| CSpineBinaryMetricInterface | } |
| CSpineCache | |
| CSpineClassificationEvaluation | |
| CSpineControllerFactory | Factory for the spine workflow controllers |
| CSpineData | Container for set of vertebrae and other spine-related metadata The SpineData class is the main Data type of the ImFusion SpinePlugin |
| CSpineDataAnnotationFactory | Factory for the spine workflow controllers |
| CSpineDataImFusionFilePlugin | |
| ►CSpineDataVisualiser | Specialization of the AnatomicalStructureCollection class for SpineData |
| CVisualSpineDataAnatomicalStructure | We override the AnatomicalStructureVisualiser class here to define special behavior for the OrientedVertebra case |
| CSpineDiceMetric | |
| ►CSpineEvaluation | |
| CLogBook | |
| CSpineEvaluationIterator | Base class iterator for individual scans and their label/meta data Lets its subclasses handle the loading |
| CSpineF1Metric | |
| CSpineFromMultiLabelAlgorithm | |
| ►CSpineLocalization2DAlgorithm | Localization algorithm that detects vertebrae and other structures in X-Ray images |
| CModelSet | Configuration for a set of models to be used for localization in 2D |
| CSpineLocalizationEvaluation | |
| CSpineMeshCurvatureAlgorithm | |
| CSpineMeshCurvatureController | |
| CSpinePlugin | Plugin class responsible for initializing all spine related components |
| CSpinePluginFactory | Factory for the spine workflow algorithms |
| CSpinePolyRigidDeformation | Set up a poly-rigid deformation on a volume and one or two AnatomicalStructureCollection objects |
| ►CSpinePolyRigidRegistration | |
| CSimilarityResult | Computes the optimal similarity, stores the result in p_offset |
| CSpinePrecisionMetric | |
| CSpineRecallMetric | |
| CSpineSegmentationEvaluation | |
| CSpineSegmentationMetricInterface | Segmentation metrics { |
| CSpineSurfaceDistanceMetric | |
| CSpline | Uniform Catmull-Rom spline |
| CSplineLabelPainterAlgorithm | Algorithm for executing the label painter on an image guided by a spline |
| CSplineLabelPainterAlgorithmController | Controller for SplineLabelPainterAlgorithm |
| CSplineSlicingAlgorithm | Creates slices orthogonal to a spline and exports them to an image set |
| CSplineSlicingController | Minimal controller for spline slicing algorithm. Required to get spline |
| CSplitASCSetAlgorithm | Algorithm to split an ASCSet into AnatomicalStructureCollections |
| CSplitChannelsAlgorithm | Splits a single multi channel image into a set of single channel images |
| CSplitImagesAlgorithm | Algorithm to split images into a set of subimages |
| CSplitImageSetAlgorithm | Algorithm to split an image set into multiple single images |
| CSquareHoughTransform | Hough transform for detecting squares |
| CStatistics | |
| CStereoBlockMatchingReconstruction | Implementation of block matching stereo reconstruction It depends on block matching from OpenCV |
| CStereoCalibrationDataComponent | A data component storing the registration matrix between the left and right camera of a stereo camera pair |
| CStereoCalibrationSetterAlgorithm | The algorithm loads an existing calibration onto a given stereo image set or stereo image stream |
| CStereoCGIReconstruction | |
| CStereoImage | This class stores a pair of images, taken by a stereo camera at the same time point |
| CStereoImageExtractSelection | Algorithm to extract the current StereoSharedImageSet selection into a new object instance |
| CStereoImageImFusionFilePlugin | Loading and saving of the ImFusion stereo image format |
| CStereoImageReduceToSelection | Algorithm for reducing a StereoSharedImageSet to its selected samples |
| CStereoImageStream | Base class for streams based on stereo images |
| CStereoImageStreamData | Stereo Image data streamed from a stereo camera |
| CStereoImageStreamDataController | Data Controller for StereoImageStream |
| CStereoReconstruction | Base class for stereo reconstruction algorithms producing disparity maps |
| CStereoReconstructionAlgorithm | This algorithm performs 3D reconstruction from a pair of stereo images |
| CStereoReconstructionCustomModel | Performs stereo reconstruction using a traced machine learning model provided by the user |
| CStereoReconstructionFactory | |
| CStereoReconstructionRAFT | |
| ►CStereoRectification | Performs stereo rectification und unrectification on images |
| CRectificationInformation | Stores parameters used in stereo rectification, a process that aligns images from a stereo camera pair to simplify disparity computation |
| CStereoRectificationAlgorithm | Stereo Rectification Algorithm |
| CStereoSemiGlobalBlockMatchingReconstruction | Implementation of Semi Global block matching stereo reconstruction It depends on Semi Global block matching from OpenCV |
| CStereoSharedImageSet | This class is the main high-level container for stereo image data set |
| CStereoSharedImageSetController | Shows regular StereoSharedImageSet instances (no derivatives) in ImageView2D |
| CStereoStreamReconstructionAlgorithm | Performs real-time 3D scene reconstruction from stereo camera input |
| CStereoStreamToVideoAlgorithm | Algorithm to record stereo image streams to video files The algorithm internally uses VideoFileRecorder to save videos |
| CStereoStreamToVideoRecorder | Records stereo image streams to two video files The algorithm internally uses VideoFileRecorder to save videos |
| ►CStream | Base class representing a stream of changing data in the DataModel |
| CStateChange | |
| CWorkContinuation | |
| CStreamAlgorithm | Type-erased base of CreateStreamAlgorithm |
| CStreamAlgorithmBase | Interface for algorithms that work on streams |
| CStreamAlgorithmControllerFactory | Factory for controllers for stream algorithms that are registered in the StreamAlgorithmFactory |
| CStreamAlgorithmExecutor | Generic algorithm that allows the execution of arbitrary algorithms on each image coming in through an image stream |
| CStreamAlgorithmExecutorController | |
| CStreamAlgorithmExecutorPayload | Work item for the StreamAlgorithmExecutor |
| CStreamAlgorithmFactory | Factory for algorithms in the stream plugin |
| CStreamController | Implementation of the DataController interface for manipulating streams |
| CStreamControllerBase | Base AlgorithmController for creating controllers of streaming algorithms, but it can also be used directly to show a auto generated UI for a Stream |
| CStreamData | Base class for all data streamed from a streaming device |
| CStreamDataAnnotationFactory | Factory for data annotation in the stream plugin |
| CStreamForwarder | Transfers stream data from an input stream to an output stream |
| CStreamFps | Frames per second computation for a stream |
| CStreamGroup | Templated stream group class to extend a proxy stream to a StreamGroup with the CRTP pattern |
| CStreamGroupBase | Non-templated base class for stream groups to create a CompoundData of a proxy stream and an arbitrary number of substreams |
| CStreamIoAlgorithm | Type-erased base of CreateStreamIoAlgorithm |
| CStreamPlugin | Plugin for real-time streaming of image, tracking, or custom data and network communication |
| CStreamRecorder | Abstract base class for stream recorders |
| ►CStreamRecorderAlgorithm | Records multiple ImageStream and TrackingStream instances and optionally merges their results into one or more TrackedSharedImageSet objects |
| COwningDataListAsync | Helper class for managing recorded data together with a future to ensure that background saving tasks are complete before the data is deleted |
| CStreamRecorderController | Controller for recording and synchronizing any combination of ImageStreams and TrackingStreams |
| CStreamSettings | Settings for the Stream plugin |
| CStreamSharedImageSet | Wrapper around a streamed SharedImageSet |
| CStreamToVideoRecorder | |
| CStringParamControl | Represent a ParamType::String with a QLineEdit |
| CSubProgress | Wrapper class to report partial progress on an existing Task |
| CSubProperty | The SubProperty class represents a nested record of a Configurable entity |
| CSubPropertyList | The SubPropertyList class represents nested records of Configurable entities |
| CSubstream | Template class for dummy substreams |
| CSubstreamBase | Non-templated base class for substreams |
| CSubstreamWrapper | Generic wrapper class for a Stream to become a substream |
| CSummedAreaTable | Class for efficient box average using a summed area table |
| CSuperpixel | Class representing a superpixel |
| CSuperpixelsAlgorithm | Algorithm for computing superpixels (SLIC method) |
| CSuperpixelsFilter | Algorithm for image filtering guided by superpixels |
| CSurfaceReconstruction | Abstract interface for surface reconstruction from RGB-D data |
| CSurfaceReconstructionData | Data model for surface reconstruction |
| CSurfaceReconstructionDataListener | |
| CSurfaceReconstructionGPU | GPU-accelerated volumetric surface reconstruction from RGB-D data |
| CSurfaceRegistration | Surface registration using a distance volume |
| CSurfaceToVolumeRegistrationAlgorithm | Algorithm for surface scan to volume registration |
| CSymmetryPage | |
| CSynchronizeMemGlAlgorithm | Manually synchronize CPU and OpenGL copies of an image |
| CSyntheticDataAlgorithm | Creates synthetic data for various test scenarios |
| CTable | A 2D table with named columns, containing strings and numbers |
| CTableModelView | Represents a QTableView, and the container ItemViewWidget. The model can be accessed in ItemViewWidget::model or QTableView::model |
| CTableQModel | |
| CTemporaryDataComponent | Specialization of DataComponentBase that disables serialization, copying and assignment |
| ►CTensor | Data class for strongly typed dense tensors of fixed rank and data type |
| CAccess | Helper class for read/write access to the data content of a Tensor |
| CConstAccess | Helper class for read-only access to the data content of a Tensor |
| ►CTensorBase | Abstract base class for Tensors |
| Cbool_pack | |
| ►CTensorFactory | Factory for creating standard type tensors up to a certain maximum rank |
| CRankFactory | Internal helper factory for fixed type and increasing rank |
| CRankFactory< TensorFactory::maxRank > | |
| CTensorFrequencyFilteringAlgorithm | |
| CTensorIoAlgorithm | IO algorithm for moving tensors to and from binary files |
| CTensorLocalAverageAlgorithm | |
| CTextParamControl | Represent a ParamType::String with a QTextEdit |
| CTexturingAlgorithm | Algorithm for texturing 3D meshes using RGB-D image data |
| CThreadSafeInstruments | Specialized class of ThreadSafeInstrumentsBase with the option to manage additional metadata, which is held in a struct/class Special next to the TrackingInstrument |
| CThreadSafeInstrumentsBase | Non-templated and fully abstract base class for ThreadSafeInstruments |
| CThresholdingFiducialExtractionController | Controller to extract fiducials from 2D IR images by thresholding and weighted average |
| CThumbnailManager | Generates and manages thumbnails for data instances |
| CTiffIO | Class for reading and writing TIFF images |
| CTimer | Stopwatch class to measure execution time |
| CTimestampDataComponent | Data component to record both arrival and device timestamps, intended for element-wise usage |
| CTimestampedPayload | Helper struct uses as container for the BackgroundThreadQueue data elements |
| CToolCalibrationAlgorithm | Algorithm for pointer tool calibrations |
| CToolCalibrationController | Controller for ToolCalibrationAlgorithm |
| CToolVisualizationAlgorithm | Algorithm for the visualization of tools such as needles in MPRs and 3D view |
| CToolVisualizationController | Controller for the visualization of tools such as needles in MPRs and 3D view |
| CTouchActions | Specifies actions with one-finger and two-fingers gestures |
| CTPSImageRegistration | Registers two images with a non-linear deformation based on TPSs |
| CTrackedImageSetImFusionFilePlugin | Plugin for loading tracked image sets via ImFusion files |
| CTrackedSharedImageSet | Set of images with arbitrarily sampled tracking data |
| CTrackedSharedImageSetDisplayDataController | GUI controller for adjusting TrackedSharedImageSet visualization |
| ►CTrackedSharedImageSetProperties | Dialog for adjusting properties of a tracked shared image set |
| CTrackingParameters | |
| CTrackedSharedImageSetPropertiesAlgorithm | Algorithm to change properties of one or multiple tracked SharedImageSets, or a single TrackingSequence |
| CTrackedSharedImageSetPropertiesLegacy | Dialog for adjusting properties of a tracked shared image set |
| CTrackerID | Class identifying a tracker via a unique ID |
| CTrackingInstrument | Class for information of a tracking instrument |
| CTrackingInstrumentComboBox | Helper class to set a list of TrackingInstruments to a QComboBox for instrument selection |
| CTrackingInstrumentFiducialsData | Data component to store raw fiducial locations from optical tracking sequences |
| CTrackingInstrumentRawData | Device-dependent additional data |
| CTrackingInstrumentTable | Widget to display and modify the TrackingInstruments of a TrackingStream |
| CTrackingOutStream | Stream of tracking data which is sent by an OutputConnection through network or other ports |
| ►CTrackingSequence | Sequence of rigid tracking data with optional timestamps, quality values and flags |
| CTrackingSequenceIterator | Iterator class for iteration over tracking sequence data, for instance in for-each loops |
| CTrackingTuple | Tuple returned by iterator, similar to std::pair used when iterating over maps |
| CTrackingSequenceDisplayHandler | DataDisplayHandler for TrackingSequence Data Creates and owns an InteractiveObject comprised of GlTrackingSequence and MeshManipulator |
| CTrackingSequenceDisplayOptionsWidget | |
| CTrackingSequenceIO | IO class to (de)serialize TrackingSequence objects |
| CTrackingSequenceProcessing | Basic tracking sequence filtering algorithm |
| CTrackingSequenceTableDialog | |
| CTrackingSequenceTableParameters | |
| CTrackingStream | Specialization of Stream for streams producing tracking data for spatial localization |
| CTrackingStreamData | Tracking data streamed from a streaming device for spatial localization of tools, images, etc |
| CTrackingStreamDisplayOptions | Display options for a TrackingStream |
| CTrackingStreamProperties | Dialog for adjusting properties of a tracked shared image set |
| CTrackingStreamPropertiesAlgorithm | Algorithm to change properties of one TrackingStream |
| CTrackingStreamRecorder | Records data from a TrackingStream |
| CTrackingStreamVisualizationAlgorithm | Algorithm for visualizing an incoming tracking stream |
| CTrackingSubstream | Substream of StreamGroup for a TrackingStream |
| CTrackingToolCalibrationWizard | Workflow controller to perform a pointer calibration of a TrackingInstrument |
| ►CTrackingToolCalibrationWizardAlgorithm | Algorithm for stepwise pointer calibration of a TrackingInstrument |
| CCalibrationData | Internal struct to hold the current state of the calibration |
| CTrackRecordPage | |
| CTransferFunction | Modern 1D transfer function for classification during rendering |
| CTransferFunctionDisplayWidget | Qt Widget for displaying an overview of a transfer function and providing basic interaction |
| CTransferFunctionFactory | Collection of factory functions for transfer function presets |
| ►CTransferFunctionTissue | Describes a single tissue of a transfer function |
| CKeyPoint | Describes a single key point of a tissue |
| CTransferFunctionWidget | Widget for setting up a transfer function |
| CTransferGraphFeatureToMeshAlgorithm | Class to compute a vertex-wise color given a feature in the closest edge/node from the input centerline graph |
| CTransferGraphFeatureToMeshController | |
| CTransform | The Transform class provides a transformation from a Frame to another Frame, where each Frame is a coordinate system |
| CTransformationMatrixWidget | Widget to transform a matrix, with global/local and toWorld/fromWorld modifiers |
| CTransformationModifierDialog | Shows the MatrixParameterDialog to edit a transformation matrix |
| CTransformationStashDataComponent | DataComponent that stores transformations |
| CTree | Data structure for trees |
| CTreeFactory | Tree factory base class |
| CTreeIoAlgorithm | Algorithm for reading and writing trees |
| CTriMesh | |
| CTriMeshTraits | |
| CTypedImage | Concrete implementation of a MemImage for a given pixel type |
| CTypedNode | Class representing a typed tree node |
| CTypedTree | Data structure for typed trees |
| CUnpackVideoIoAlgorithm | Derived class for different factory name when reading |
| CUnrestoredDataComponents | DataComponent containing the configurations of other components that could not be restored during loading |
| CUnusedSpecial | Placeholder struct for the extra container |
| CVec3Widget | Widget to represent a vec3 type |
| CVector | Class representing a vector, defined in a Frame |
| CVectorDataComponent | |
| CVectorExpr | |
| CVectorFieldFlow | Class for computing solutions to (autonomous) ordinary differential equations (ODEs) Currently only supports the classical 4th-order explicit Runge-Kutta method with fixed stepsize |
| CVectorFieldFlowAlgorithm | Algorithm for computing solutions to (autonomous) ordinary differential equations (ODEs) |
| CVectorParameterWrapper | Wrap a vector into a ParameterWrapperBase instance |
| CVertebraDissectionAlgorithm | Algorithm for extracting structures of interest from an instance of SpineData The structures are extracted by performing a deformable mesh registration of a template structure onto the given input SpineData |
| ►CVertebraDissectionLegacyAlgorithm | Algorithm to dissect a vertebra segmentation into individual parts |
| CArticularProcessesPerLevel | Structure to hold articular processes of a level |
| CEndplatesPerLevel | Structure to hold endplates of a level |
| CLandmark | Structure to hold landmark information of a level |
| CMostNarrowPedicleCrossSection | Most narrow part of the pedicle |
| CVertebraDissectionLegacyController | Controller for the VertebraDissectionLegacyAlgorithm |
| CVertebraEvaluationInstance | Instance of vertebra for segmentation evaluation |
| CVertexExpr | |
| CVideoCameraIoFactory | Factory for VideoCameraStreams used by the framework, in particular the VideoStreamIoAlgorithm and associated controller |
| ►CVideoCameraStream | Interface for video streams from cameras Derived classes must override setFormat and setDeviceByIndex (and call the base class versions from there), as well as enumerateDevices |
| CVideoCameraDeviceInfo | |
| CVideoStreamFrameFormat | |
| CVideoCameraStreamOpenPnp | Stream for videos This is supposed to be created by the corresponding IO algorithm |
| CVideoCameraStreamPropertiesInspector | Specialization of PropertiesInspector for use with live camera streams |
| CVideoCameraStreamPropertiesInspectorController | Controller of the VideoCameraStreamPropertiesInspector algorithm |
| ►CVideoDecoder | VideoDecoder is responsible of processing the received ByteBuffer which contains the image data |
| CFrameStats | |
| CVideoEncoder | |
| CVideoFileIoAlgorithm | Derived class for different factory name when writing |
| CVideoFileRecorder | |
| CVideoFileStream | Stream images from a video file |
| CVideoIoAlgorithm | Algorithm for reading video files as image set, and writing them |
| CVideoStreamBackendOpenCV | Backend for OpenCV based video streams Virtual base class that handles most of the functionality of an OpenCV based stream |
| CVideoStreamExtractionAlgorithm | Extracts part of a video stream |
| CVideoStreamIoAlgorithm | IO Algorithm for streaming videos |
| CVideoStreamIoAlgorithmHelper | |
| CViewGroup | Non-owning container of multiple views that share and sync properties with each other |
| CViewGroupAdapter | Helper class providing the API of ViewGroup while wrapping around either a ViewGroup or a GUI::RadiologyViewGroup |
| ►CViewInteraction | Base class for all view interactions |
| CActionSpeed | |
| CViewLayoutWidget | Controls to show/hide views and change the layout |
| CVision | Legacy computer vision algorithms for CT |
| CVisionDataAnnotationFactory | |
| CVisionPlugin | Plugin for Vision algorithms |
| ►CVitalsDataComponent | DataComponent for a collection of time dependent vital signs like ECG, heart rate or pulse oximeter measurements |
| CSample | A single temporal sample |
| CTimeSeries | A scalar time series |
| CVitalsDataController | GUI controller to show the GlVitalsOverlay |
| CVolumeBasedMeshCurvatureAlgorithm | Algorithm to compute curvature measures (mean curvature, Gaussian curvature, curvedness and shape index) of a mesh based on its implicit surface representation as signed distance volume |
| CVolumeBasedMeshCurvatureController | |
| CVolumeBasedMeshRegistrationAlgorithm | Calculates a deformable registration between two meshes by calculating a deformable registration between distance volumes |
| CVolumeBasedMeshRegistrationController | |
| CVolumeFreeformCroppingAlgorithm | Algorithm to crop a volume using a freeform selection |
| CWatershedComputer | |
| CWatershedSegmentationAlgorithm | Watershed segmentation algorithm |
| CWizardPage | |
| CWorkspace | Workspaces allow for restoring a session or automate the execution of a series of data loading and algorithms in a similar fashion as scripting |
| CWorkspaceConversionFunction | Structure to describe a conversion of workspace files between different versions |
| CWorkspaceConversionRegistry | Singleton to manage registered workspace conversion functions and apply them to workspace file |
| CWorkspacePlaceholdersDialog | Dialog allowing the user to specify missing values for workspace placeholders |
| CZipFileHandler | Automatically extracts a ZIP archive to a temporary folder for loading |
| CZipIoAlgorithm | Loads data from a ZIP archive |
| ►Nsensor_msgs | |
| CImage_ | |
| 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 |
| CFunctionRnToRm | Abstract base class to define constraints and cost functions for optimization |
| CgladGLversionStruct | |
| CKey | |
| CKeyBase | Base class |
| CKeyRegistry | |
