| NImFusion | Namespace of the ImFusion SDK |
| NCompression | Data compression tools |
| 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 |
| Nzip | Compression using the ZIP file format |
| CError | Represents a zip/unzip error |
| CEntryInfo | Info for an archive entry: |
| CZipArchive | Class representing a zip archive. A ZipArchive instance can create a zip archive, add/extract files/memory buffers to/from it |
| NContainer | Collection of utility functions operating on STL containers |
| CLRUCache | Templated container class implementing a Least Recently Used Cache |
| 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 |
| 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() |
| 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 |
| 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 |
| CLogCapture | Structure storing a single log event |
| CFilter | Structure storing a filter |
| 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 |
| 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 |
| 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 |
| NFilesystem | Classes and functions to manipulate files and directories, and the paths that identify them |
| CFile | Entity representing a file in the filesystem |
| CDirectory | Entity representing a Directory in the filesystem |
| CSpaceInfo | Simple structure representing the total and remaining disk space |
| CPath | Entity representing a path in the filesystem |
| CTemporaryFile | Temporary file which deletes itself upon going out of scope |
| CTemporaryDirectory | Temporary directory which deletes itself upon going out of scope |
| CUrl | Entity representing a URL (Uniform Resource Locator) |
| CSubquery | A Subquery represents part of a query delimited by '&' or ';' |
| CRelativeTag | |
| 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 |
| CCircle | Class representing a circle (actually a disk, so including the inner part) in 3D space |
| CEllipse2D | Class representing an ellipse in 2D space |
| CLineBase | Common interface of Line and LineSegment |
| CLine | Class representing a full line, i.e |
| 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 |
| CAlignedRectangle2D | Class representing an axis aligned rectangle in 2D space |
| CRectangle | Arbitrary rectangle in 3D space |
| CTriangle | Class representing a triangle in 3D space |
| CSpherePivotResult | |
| 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 |
| NUtils | Generic utility classes and helper functions |
| Ndetail | |
| Nswap_adl_tests | |
| Ctag | |
| Cis_std_swap_noexcept | |
| Cis_std_swap_noexcept< T[N]> | |
| Cis_adl_swap_noexcept | |
| Cconjunction | |
| Cconjunction< B > | |
| Cconjunction< B, Bs... > | |
| Cinvoke_result_impl | |
| Cinvoke_result_impl< F, decltype(detail::invoke(std::declval< F >(), std::declval< Us >()...), void()), Us... > | |
| Cis_swappable | |
| Cis_swappable< T[N], T[N]> | |
| Cis_nothrow_swappable | |
| Cis_expected_impl | |
| Cis_expected_impl< Expected< T, E > > | |
| Cno_init_t | |
| Cexpected_storage_base | |
| Cexpected_storage_base< T, E, true, true > | |
| Cexpected_storage_base< T, E, true, false > | |
| Cexpected_storage_base< T, E, false, true > | |
| Cexpected_storage_base< void, E, false, true > | |
| Cdummy | |
| Cexpected_storage_base< void, E, false, false > | |
| Cexpected_operations_base | |
| Cexpected_operations_base< void, E > | |
| Cexpected_copy_base | |
| Cexpected_copy_base< T, E, false > | |
| Cexpected_move_base | |
| Cexpected_move_base< T, E, false > | |
| Cexpected_copy_assign_base | |
| Cexpected_copy_assign_base< T, E, false > | |
| Cexpected_move_assign_base | |
| Cexpected_move_assign_base< T, E, false > | |
| Cexpected_delete_ctor_base | |
| Cexpected_delete_ctor_base< T, E, true, false > | |
| Cexpected_delete_ctor_base< T, E, false, true > | |
| Cexpected_delete_ctor_base< T, E, false, false > | |
| Cexpected_delete_assign_base | |
| Cexpected_delete_assign_base< T, E, true, false > | |
| Cexpected_delete_assign_base< T, E, false, true > | |
| Cexpected_delete_assign_base< T, E, false, false > | |
| Cdefault_constructor_tag | |
| Cexpected_default_ctor_base | |
| Cexpected_default_ctor_base< T, E, false > | |
| 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 | |
| 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 |
| CUnexpected | |
| Cbad_expected_access | |
| CNotCopyable | Inherit from this class if your class should be neither copy-constructible nor assignable |
| 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 |
| 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 |
| CEigenVectorWrapper | Simple case: non-optional input argument |
| COutputEigenVectorWrapper | Non-optional output argument |
| COptionalEigenVectorWrapper | Optional input argument |
| COptionalOutputEigenVectorWrapper | Optional output argument |
| CLinearIterator | Typed convenience iterator for quick integration into custom containers, especially if traversal requires on-the-fly evaluations |
| CFileGuard | Utility RAII class that deletes the given file when destructed |
| CAutoDisconnectSignals | |
| NGL | Low-level OpenGL Wrappers |
| NDebug | The GL::Debug namespace contains functions and class to help with debugging OpenGL calls |
| COpenGlException | Specialization of std::runtime_error that also stores the original OpenGL error code |
| CGroup | Allows to group a set of OpenGL calls together |
| CAbstractInclude | Base class for abstract GLSL includes |
| CFingerprint | AbstractIncludes provide a fingerprint to simplify duplicate detection |
| CBlending | Helper class to configure the OpenGL blending stage |
| CBuffer | Wrapper class for OpenGL Buffer Objects |
| COpenGLNotFoundException | Specialization of std::runtime_error indicating that OpenGL was not able to initialize correctly |
| CContext | Base class for low-level OpenGL context handling within the ImFusion SDK |
| CCreateInfo | |
| 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) |
| CInstanceManagerBase | Base class for context-aware caching of OpenGL object instances |
| CInstanceManager | Concrete CRTP 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 |
| CMultiAbstractInclude | Concrete type for an instance of a Multi-AbstractInclude |
| CMultiIncludable | Multi-AbstractIncludes allow for using multiple instances of the same AbstractInclude type in one shader |
| CMultiAbstractIncludeBase | Non-templated base class of MultiIncludable to implement polymorphic interface |
| 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 |
| CProgram | OpenGL GLSL program with a fragment and optional vertex and geometry shader |
| CShaderInfo | Encapsulates information about each shader stage |
| CAbstractIncludeStruct | Struct for representing an abstract include object |
| CBufferBinding | Struct to keep track of GlBuffers bound shaders as SSBOs |
| CTextureBinding | |
| CImageBinding | |
| 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 |
| 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 |
| CPlatformInfo | Structure storing information on the GPU/driver/OpenGL context configuration |
| CMemoryInfo | Structure storing information about the available video memory as reported by OpenGL |
| CViewport | Structure describing an OpenGL viewport |
| CVertexBuffer | Specialization of Buffer to store vertex array data |
| CVertexArrayObject | Wrapper around an OpenGL Vertex Array Object (VAO) to define the vertex attribute specification for rendering |
| 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() |
| CAtomicCounterBuffer | Specialization of Buffer for OpenGL Atomic Counter Objects |
| CShaderStorageBuffer | Specialization of Buffer for OpenGL Shader Storage Buffer Object |
| COrderIndependentTransparency | Helper class to consolidate functionality for implementing order-independent transparency of rendered geometry |
| CContextGLX | OpenGL context using GLX as backend |
| NAnimations | Animating objects within the ImFusion SDK |
| CAnimationBackendQt | Concrete implementation of AnimationBackendBase using the Qt event loop for dispatching the animation updates |
| CUniqueId | Helper struct to uniquely describe a type of annotation |
| CScopedEnabler | A scope guard to set the globally available enabled property for animations |
| 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 |
| CBlendingAnimation | Animates the blendFactor of an ImageView2D |
| 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 | |
| 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 |
| 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 |
| CLayoutInfo | Record of information passed to LayoutFunction::createLayout() |
| CLayoutAlgorithm | Interface to derive from to define custom display layout algorithms |
| CDisplayLayoutConfig | The DisplayLayoutConfig serves as static "snapshot" of the view configuration of a DisplayLayout |
| CLayoutCell | One cell in the grid |
| CDisplayLayout | Tiling-based layouting class for arranging Views inside a Display in a non-overlapping fashion |
| 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) |
| CKeyEvent | Key events are triggered when a keyboard key was pressed or released on the GUI |
| CMouseEvent | Mouse events are triggered whenever the status of the mouse has changed wrt |
| CTouchEvent | Touch events occur when pressing, releasing, or moving one ore multiple touch points on a touch device |
| CPoint | Record of touch point metadata |
| 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 |
| CInputEventMapperBase | Helper class to maintain a map of mouse/keyboard combinations to an enumeration of actions |
| CMouseMapping | |
| CKeyboardMapping | |
| CInputEventMapper | Specialization of InputEventMapperBase with a templated action enumeration type to increase type safety |
| 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 |
| 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 |
| CRegularMode | |
| CCreateMode | |
| CMovePointMode | |
| CMoveAnnotationMode | |
| 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 |
| CTouchActionConfig | Record to define which touch events should be processed and how |
| CActionSpeed | Record to define the speed at which a mouse/touch movement will modify the underlying view |
| CSpinboxMatrixWidget | QWidget that allows editing the elements of a matrix (vector) via QDoubleSpinBoxes. Used by EigenMatrixParamControls |
| CSpinboxMatrixDialog | QDialog that simply wraps the SpinBoxMatrixWidget inside a dialog window. Used by EigenMatrixParamControls |
| CView | Base interface for a rendering view (e.g |
| CEventHandler | Interface to be used as base class for event handlers of Views |
| CBorderConfig | Record for specifying if and how to render a border frame surrounding the view |
| 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 |
| CTypedViewObject | Specialization of a ViewObject where the concrete types of the underlying GlObject and EventHandler are defined by the template parameters |
| 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 |
| NDiffusionNet | |
| CDiffusionNetOperators | Populates inputs required for running DiffusionNet architecture (https://arxiv.org/abs/2012.00888) for learning on 3D shapes |
| NPoissonReconstruction | Different wrapper functions for Poisson Surface Reconstruction by M |
| CPoissonParams | Parameters for Poisson reconstruction |
| 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 | |
| NNetwork | Namespace for network communication bundled in the subfolder 'Stream/Network' |
| NOAuth2 | |
| CDeviceFlowConfig | Configuration for the OAuth2 Device Code Flow |
| CDeviceResponse | Response of the authEndpoint that starts the flow |
| CAuthorizationCodeFlowConfig | |
| CPasswordFlowConfig | |
| CAccessToken | Represents an access token for a HTTP server |
| CAuthorizationProvider | Interface for providing the Authorization header for WebRequests |
| CStaticAuthorizationProvider | A most basic AuthorizationProvider that only tracks a static list of authorization headers |
| CHttpError | |
| CLoginDialog | Basic dialog for authentication with username and password TODO: Merge with Labels LoginDialog |
| CClientConnectionBase | Base class providing an interface for client communication |
| CConnectionBase | Abstract non-templated base class for all connection types |
| CTypedConnectionBase | Templated base class providing an interface for client-server communication (e.g., WebSocket, TCP) or peer-to-peer communication (e.g., UDP) |
| 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 | |
| CTCPSocketClient | TCP socket client implementation providing bidirectional communication |
| CTCPSocketServer | TCP socket server implementation providing bidirectional communication |
| CServerConnectionBase | Abstract base class providing a server interface |
| CIPAddress | A class for handling and validating IPv4 addresses |
| CWebsocketClient | WebSocket client implementation providing bidirectional communication |
| CWebsocketServer | Websocket server implementation providing bidirectional communication |
| CUDPSocket | UDP socket implementation for network communication |
| CLockToken | |
| CServerStatus | Contains the status of the server (used by checkServer) i.e |
| CRemoteEvent | |
| CRemoteEventListener | |
| CNetworkManagerGuard | |
| 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 |
| CFP32 | |
| CFP16 | |
| CBisectionSearch | Templated bisection search algorithm, finds the interval in a sorted array in which any given value falls |
| NFramework | Namespace containing general framework initialization methods |
| CInitConfig | Record to configure the initialization of the ImFusion SDK |
| CPluginInfo | |
| NLabelStatistics | |
| CLabelInfo | |
| NImageMath | Arithmetic operations on images and arrays |
| NImgOps | |
| CBinaryImgOpGl | |
| Cbinary_type_trait | Type trait |
| Cbinary_type_trait< true, Op, LhsT, RhsT > | |
| Cadd | Add |
| Cminus | Minus |
| Cmult | Mult |
| Cdivide | Divide |
| CdivideIfNotZero | Divide if rhs is greater Zero |
| Cpow | Pow |
| Cequal | |
| CnotEqual | |
| CgreaterEqual | |
| Cgreater | |
| ClessEqual | |
| Cless | |
| CbinaryAnd | |
| CbinaryOr | |
| Cmin | |
| Cmax | |
| Catan | |
| CbinaryLambdaWrapper | |
| Clength | This is used for the Euclidean length over channels in the ChannelReduction ImageMath node |
| CUnaryImgOpGl | |
| Cunary_type_trait | Type trait |
| Cunary_type_trait< true, Op, OperandT > | |
| CunaryIdentity | Identity |
| CunaryMinus | Unary minus |
| CImpl | |
| CImpl< OperandT, true > | |
| CImpl< OperandT, false > | |
| Cabs | |
| CImpl | |
| CImpl< OperandT, true > | |
| CImpl< OperandT, false > | |
| Csign | |
| Cexp | Unary exp |
| Clog | Unary log |
| Cpow2 | Unary pow2 |
| Csqrt | Unary sqrt |
| Csin | Sin |
| Ccos | Cos |
| CunaryLambdaWrapper | |
| Ninternal | |
| CPermutationLookup | Lookup structure for forward and backward block dimension squeezing |
| CBlockDetails | Block access members |
| CArrayGl | Implementation of GlExprInterface for Array ( |
| CBinaryOpGl | Implementation of GlExprInterface for BinaryOpTpl ( |
| CCastWrapperGl | Implementation of GlExprInterface for CastWrapperTpl ( |
| CChannelReductionIdentifier | |
| CChannelReductionGl | Implementation of GlExprInterface for ChannelReductionTpl ( |
| CChannelSwizzleViewGl | Implementation of GlExprInterface for ChannelSwizzleViewTpl ( |
| CChannelWiseScalarGl | Implementation of GlExprInterface for ChannelWiseScalar ( |
| CCombineChannelsGl | Implementation of GlExprInterface for CombineChannels ( |
| CCoordinatesGl | Implementation of GlExprInterface for Coordinates ( |
| CDeformationLeafGl | Implementation of GlExprInterface for DeformationLeaf ( |
| CDeviceStrategyWrapperGl | Implementation of GlExprInterface for DeviceStrategyWrapperTpl ( |
| CGlExprInterface | Base class for all expressions which provides an interface to automatically create shaders from an expression |
| CMaskLeafGl | Implementation of GlExprInterface for MaskLeaf ( |
| CNoiseIdentifier | |
| CNoiseGlBase | |
| CNoiseGl | Implementation of GlExprInterface for Noise ( |
| CReductionWrapperGlBase | Dummy base as ReductionWrapperGl needs to be a polymorphic type |
| CReductionWrapperGl | Implementation of GlExprInterface for ReductionWrapper ( |
| CResampleGl | Implementation of GlExprInterface for ResampleTpl ( |
| CScalarGl | Implementation of GlExprInterface for ChannelWiseScalar ( |
| CSelectGl | Implementation of GlExprInterface for SelectTpl ( |
| CStashGl | Implementation of GlExprInterface for StashTpl ( |
| CUnaryOpGl | Implementation of GlExprInterface for UnaryOpTpl ( |
| CVariableGl | |
| CBinaryOp | Specialization of ExprBase for binary operators (non template optimization) |
| CCastWrapper | Cast expression |
| CChannelSwizzleView | Specialization of ExprBase for viewing an expression based on channels swizzling |
| CDeviceStrategyWrapper | Chooses device strategy |
| CUnaryOpBase | Base class for unary operators |
| CUnaryWrapperBase | Base class for wrapping operators such as casting, device strategy, etc |
| CBinaryOpBase | Base class for binary operators |
| CChannelReductionBase | Base class for channel reduction |
| CChannelSwizzleViewBase | Base class for channel swizzle views |
| CCombineChannelsBase | Base class for combine channels |
| CSelectBase | Base class for select operator |
| CStashBase | Base class for stash operator |
| CMaskLeafBase | Base class for mask |
| CDeformationLeafBase | Base class for deformation |
| CResampleBase | Base class for resample |
| CArrayBase | Base class for resample |
| CReductionWrapperBase | Base class for reductions needed for polymorphic layer |
| CPolyWrapper | Specialization of ExprBase wrapping a ExprBaseTpl |
| CReductionWrapper | Polymorphic wrapper to wrap an expression and represent a reduction |
| CUnaryOp | Specialization of ExprBase for unary operators (non template optimization) |
| CBinaryOpTpl | Specialization of ExprBaseTpl for binary operators using template optimization |
| CCastWrapperTpl | Cast expression |
| CChannelReductionTpl | Specialization of ExprBaseTpl for reduction operators over channels |
| CChannelSwizzleViewTpl | Specialization of ExprBaseTpl for viewing an expression based on channels swizzling |
| CCombineChannelsTpl | |
| CCoordinatesImpl | |
| CDeviceStrategyWrapperTpl | Chooses device strategy |
| COperandStashImpl | |
| COperandStashImpl< expr_type, true > | |
| CReductionWrapperTpl | Wrapper to wrap an expression and represent a reduction |
| CResampleTpl | Resample an ImageMath operand to a different coordinate system, optionally including a deformation |
| CSelectTpl | Specialization of ExprBaseTpl for ternary (condition ? |
| CStashEntry | |
| 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 |
| CUnaryOpTpl | Specialization of ExprBaseTpl for unary operators using template optimization |
| ChasEvalString | |
| ChasImgType | |
| Cbool_pack | |
| Ccommon_type | Common_type |
| Ccommon_type< T > | |
| Ccommon_type< void, T > | |
| Ccommon_type< T, void > | |
| Ccommon_type< void, void > | |
| Ccommon_type< T1, T2 > | |
| Ccommon_type< T1, T2, Ts... > | |
| Cbiggest_imf_img_type | |
| Cbiggest_imf_img_type< T, Ts... > | |
| Cfirst_non_void | Get first non-void element in parameter pack |
| Cfirst_non_void< T, Ts... > | |
| CWrapSimpleTypeResult | |
| CTaggingIndex | In order to tag leafs in an expression we need to be able to re-identify leafs which represent the same information |
| CGlExpr | Wrapper for using a ExprBase as GlAbstractInclude |
| CExprBase | Base class for expressions (non-templated) (needs to be empty in order to enable empty base class optimization!) |
| CExprInterface | ImageMath base class to provide an interface for non-CRTP polymorphism |
| 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) |
| CExprBaseTpl | Base class for compile-time optimized expressions (curiously recurring template pattern (CRTP)) |
| 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 |
| COperandMaskBase | |
| COperandMask | Mask/GlMask from an ImageMath expression |
| 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 |
| NAuthHelpers | |
| CEncryptedString | |
| Ndetail | |
| CisRegular | |
| CisMoveOnly | |
| CisEqualityComparable | |
| CAnatomyItemWidget | |
| CBarItemWidget | |
| CGraphImpl | Helper struct representing a graph over a fixed set of nodes |
| CNode | |
| CFeatureKey | Used to uniquely identify a feature by name and kind (node/edge) |
| CRangeInputDialog | |
| 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 |
| CLoadResult | |
| CInputFormat | |
| COutputFormat | |
| NMetaImage | Support for loading and saving MetaImage files |
| CSaveOptions | Most properties of a MetaImage header can be deduced from a SharedImageSet, the ones in SaveOptions can not |
| CMetaImageHeader | |
| NUserDocumentation | |
| CAlgorithmDoc | Record of the common sections for Algorithm User Documentation |
| Ninternal | |
| CViewOptions2dWidget | |
| CViewOptionsCurvedViewWidget | |
| CViewOptions3dWidget | |
| CKeyValueStoreTableModel | |
| CASCTableModel | Implementation details should not be used |
| CKeyItemDelegate | |
| CKeyModel | |
| CKeyTreeView | |
| CKeyComboBox | |
| CVisibilityDelegate | |
| NQtHelpers | Some Qt convenience functions |
| CScheduledMainThreadCommand | |
| NDicom | Low-level and intermediate-level interfaces for working with DICOM data |
| NUtils | Collection of utility functions to handle DICOM data |
| CDcmTagKeyStlComp | |
| CUrlQueries | |
| CConfigurableSequenceItem | |
| CConfigurableSequence | |
| 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 |
| CDatasetHandler | Read access handler for proprietary / non-standard DICOM image formats, or non-image datasets |
| CGeneralEquipmentModuleDataComponent | DataComponent mirroring the DICOM General Equipment Module |
| CSourceInfoComponent | DataComponent to store the mapping of SharedImage to the DICOM URIs (such as file names) used for loading |
| CReferencedInstancesComponent | DataComponent to store DICOM instances that are referenced by the dataset |
| CReferencedInstance | |
| CDatasetCache | Caching of DcmDataset loaded from different locations |
| CElementList | Interface for classes that consist of Elements |
| Cvalue_error | Exception specialization for DICOM element retrieval |
| CElementBase | Abstract base class for DICOM Elements |
| CElement | Dicom Element with a concrete value type |
| CTagProxy | |
| CError | Structure for storing errors occurring during loading/saving DICOM data |
| CErrorRecorder | Error handling interface for the Dicom module |
| 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 |
| CIOD | Base class of a Dicom Information Object Definition (IOD) |
| CMultiFrameImageIOD | Base IOD for classic DICOM files |
| CVolumetricImageIOD | The VolumetricImageIOD is a generic IOD for volumetric data that is stored slice by slice |
| CEnhancedMultiFrameImageIOD | Class representing Enhanced CT Image IOD (PS 3.3 A.38) |
| CFunctionalGroupMacro | This is a simplified implementation of the function group macros |
| CSegmentIdentificationSequenceItem | |
| CFrameContentSequenceItem | |
| CDimensionIndexSequenceItem | |
| CDicomGeSignaExciteIOD | Extra IOD specialization for basic support of loading 4D MRI sequences created by GE Signa Excite devices |
| CIOD_Registry | A registry that assigns a IOD implementation to a SOP class UID |
| CSegmentItem | Element in the (0062,0002) SegmentSequence |
| CSegmentedPropertyCode | |
| CSegmentationStorageIOD | Class representing Segmentation IOD |
| CModuleList | Interface for classes that consist of modules |
| CDatasetModuleList | A stub that allows to use a Module with a DcmItem alone (without deriving some class from ModuleList) |
| CModule | Base class for Dicom Modules |
| CCommonModule | Collection of the essential tags describing a Dicom data set combining |
| CImagePixel | Image Pixel Module (PS 3.3 C.7.6.3) |
| CPixelSpacingCalibration | Basic Pixel Spacing Calibration Macro (PS 3.3 Table 10.7) Pixel Measures Macro (PS 3.3 Table C.7.6.16-2) |
| CImagePlane | Image Plane Module (PS 3.3 C.7.6.2) |
| CDetectorInformationSequence | C.8.4.11 NM Detector Module |
| CModalityLUT | Modality LUT Module (PS 3.3 C.11.1) |
| CLutItem | |
| COverlayAnnotation | The OverlayAnnotation displays any DICOM overlay stored in a OverlayDataComponent |
| COverlayDataComponent | DataComponent providing DICOM overlays |
| CDicomParameterBase | Internal type-erased base class for DicomParameter<T> |
| CDicomParameter | A specialized Parameter<T> class that can additionally serialize from and to DICOM |
| CDicomParameterHelper | Helper functions to load and save all DicomParameters of a Configurable |
| CDicomSegIoAlgorithm | |
| CSequenceItem | Base class for sequence items |
| CSequenceBase | Abstract base class for a sequence of elements |
| CSequence | Concrete sequence of items of type T, which must be derived from SequenceItem |
| CDatasetIodPair | Named pair of a DcmDataset and the corresponding IOD |
| CEncryptedAttributesExtension | |
| CExtension | Interface for adding custom functionality to DicomLoader and DicomWriter An Extension might be called in a thread that is not the main thread |
| CGeneralEquipmentExtension | General Equipment Module (PS 3.3 C.7.5) Only considers tags that are part of the GeneralEquipmentModuleDataComponent |
| CGeneralEquipment | |
| CRealWorldValueMappingExtension | Real World Value Mapping Macro (PS 3.3 C.7.6.16.2.11) |
| CRTStructureDataComponent | DataComponent for PointClouds loaded from a DICOM RTStructureSet |
| CContour | Represents a single item in the original 'Contour Sequence' (3006,0040) |
| CRTStructureRenderingDataComponent | Internal rendering data that represent a RT Structure |
| CPolyline | |
| CRTStructureDataDisplayHandler | DataDisplayHandler for PointClouds that represent DICOM RT Structs |
| CRTStructureDatasetHandler | A DatasetHandler for loading DICOM RTStructureSet |
| CVOILUTExtension | VOI LUT Module (PS 3.3 C.11.2) Loads and saves windowing related values to and from DisplayOptions2d |
| CWebClient | Interface for querying and retrieving objects from a DicomWeb compliant server |
| CDatasetPreviewLabel | A widget that shows a preview image of a DICOM dataset |
| CRTStructureDataController | A DataController for PointClouds that contain a RTStructureDataComponent |
| CBase | |
| CImage | |
| CDimensionsInfo | Describes with which dimensions a series will be loaded |
| CSeries | |
| CPacsSeriesProxy | Proxy item to represent Series that exist on the PACS but have not yet been downloaded completely |
| CStudy | |
| CPatient | |
| CScanner | Scan different locations for DICOM files |
| CScannerQt | A scanner with Qt interop |
| CSettingsWidget | Simple Qt widget to configure the DicomPluginSettings |
| CTagsWidget | Widget to display dicom tags |
| NCreateStreamAlgorithmHelper | |
| CHelper | |
| CHelper< T, true > | |
| CHelper< T, false > | |
| NVideoStreamSettings | |
| CVideoStreamSettingsBase | Base class for all video stream settings |
| CVideoCameraSettingDouble | Base class for parameters using a single double precision floating point value |
| CRegionOfInterest | Settings related to a region of interest |
| CROI | Parameters describing a region of interest |
| CFramerate | Settings related to frame rate |
| CGain | Settings related to gain |
| CExposure | Settings related to exposure |
| NIGTL | |
| CParsedMessage | |
| CConnection | Network connection to another OpenIGTLink-supporting system for receiving and sending data |
| CConnectionIoAlgorithm | Main IO algorithm for using the OpenIGTLink library |
| CCreateDeviceAlgorithm | |
| CCreateDataIoAlgorithm | |
| CCreateDeviceController | |
| CDataDevice | Base class for Igtlink devices that receive/send single data (and not data streams) |
| CDevice | Base class for Igtlink devices |
| CDeviceImpl | |
| CDeviceBlueprint | |
| CTypeFactory | Factory class handling Igtl types |
| CDeviceFactory | Factory class handling Igtl devices |
| CImageData | Class to send/receive a single Image over an OpenIGTLink connection |
| CIgtlImageOutStream | |
| CIgtlImageStream | Image streams which are generated by OpenIGTLink connections |
| CMeshData | Class to send/receive a single Mesh over an OpenIGTLink connection |
| CPointCloudData | Class to send/receive a single PointCloud over an OpenIGTLink connection |
| CIgtlPolyDataOutStream | |
| CIgtlPolyDataStream | Polydata (Mesh or PointCloud) streams which are generated by OpenIGTLink connections |
| CTrackingMessage | Tracking message used for 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 |
| NML | Namespace containing all the classes relevant for the data processing and the execution of machine learning models |
| Ndetail | |
| CDataItemSaveWithCompression | |
| CCreator | Base class for creators to be registered in factory |
| CCreatorImpl | Wrapper around a std::function used for constructing an item Derived from Base |
| NShaderUtils | |
| COperationShaderCache | |
| NGNN | |
| CConversionOptions | Options for conversion between Graph and Mesh classes |
| CAddPositionAsChannelAlgorithm | Algorithm to add a new channel to a given image containing each pixel's position |
| CParamException | Special type for handling exceptions during parameter configuration |
| 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 |
| CBox | Bounding Box for ML tasks Since bounding boxes are axis aligned by definition, a Box is represented by its center and its extent |
| CBoundingBoxSet | Class for managing sets of bounding boxes within a BoundingBoxElement The class is meant to be used in parallel with SharedImageSet |
| 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 |
| CDataElementException | Custom exception thrown by some DataElement |
| CDataElement | Main interface for data elements used for wrapping other ImFusion types and use them in a machine learning specific workflow |
| CDataItemException | Custom exception thrown by DataItem |
| CDataItem | Class for holding a map of heterogeneous DataElements, see DataElement |
| CDataItemDisplayHandler | DataDisplayHandler for DataItems |
| CDataLoaderException | Custom exception thrown by DataLoader |
| CDataLoader | Interface for all data loaders, establishing the mechanism for loading and processing data |
| CDataReader | Base class for data readers |
| CDataLoaderSpecs | |
| CDataset | Class for creating an iterable dataset by chaining data loading and transforming operations executed in a lazy fashion |
| CEngine | Generic interface for machine learning models serialized by specific frameworks (PyTorch, ONNX, etc.) |
| CEngineConfiguration | |
| CGenerateBoxSegmentationTrainingDataAlgorithm | Algorithm to generate learning data for box segmentation network |
| CSingleton | Base class for singletons |
| CRegistry | |
| CFactory | Generic factory class for registering polymorphic types Usage: |
| CGroupToDataItemAlgorithm | Groups a list of Data into a DataItem |
| CRegionOfInterest | Helper struct to represent a region of interest |
| CImageSamplersException | Custom exception |
| CImageROISampler | Interface for samplers used during training of machine learning models |
| CKeypointExtractionAlgorithm | Algorithm for extracting keypoints from blobs representing the probability distribution of the keypoint location |
| 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 |
| CBoundingBoxSetIoAlgorithm | Io Algorithm to load/save BoundingBoxSet |
| CLandmarkPredictionAlgorithm | Algorithm to predict landmarks in an image |
| CClassificationLearningEvaluation | Class for evaluation of a binary classification method |
| CMultiClassificationLearningEvaluation | Class for evaluation of a multi-label classification method |
| CRegressionLearningEvaluation | Class for evaluation of a regression method |
| 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 |
| CMLModelException | Custom exception thrown by MachineLearningModel |
| CMachineLearningModel | Class for managing and executing a machine learning model on generic input data |
| CContext | |
| CMachineLearningModelAlgorithm | Generic algorithm to apply a machine learning model |
| CMarkovChain | |
| CMatrixBasedOperation | Extension of the Operation class for operations based on a geometric transformation using a matrix (e.g |
| CMetric | The Metric interface is a key part of our pipeline for standardized evaluations of a machine learning pipeline, or an algorithm in general |
| CMetricException | Custom exception for metrics |
| 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(); |
| CImagewiseClassificationMetrics | Compute the confusion matrix for a multi-class classification |
| CResults | |
| CDiceMetric | Compute the Dice score between a label map and a ground truth segmentation |
| CSurfaceDistancesMetric | Compute a set of distance-based metrics between a label map and a ground truth segmentation |
| CResults | |
| CPixelwiseClassificationMetrics | Compute dense classification related metrics between a label map and a ground truth segmentation Precisely, computes the sensitivity, specificity, precision and recall |
| CElementTypeHash | Hash function for the ElementType enum class |
| CTargetTag | Simple data component to identify data that must be considered as learning target |
| CStatus | Convenience tool for returning error messages together with statuses |
| 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) |
| CSamplingConfiguration | |
| CModelConfiguration | Configuration class for MachineLearningModel parameters |
| 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) |
| 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 |
| CFileNotFoundError | |
| CIOError | |
| COperationException | Custom exception to be used by Operation |
| COperation | Class to define a pre-post processing operation on data items |
| CSpecs | Specifications required to fully instantiate an operation |
| CInvertibleOperation | Base class for operations that support inversion |
| 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) |
| CProcessingRecordComponent | Data component for keeping track of the data's origin |
| CEntry | Struct for holding the name and Properties of Operations, Samplers and Algorithms |
| 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 |
| 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 |
| CReferenceImageDataComponent | Data component used to store a reference 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 |
| CInverseOperation | Operation that inverts a specific operation by using the InversionComponent |
| CAddCenterBoxOperation | Add an additional channel to the input image with a binary box at its center |
| CAddPixelwisePredictionChannelOperation | Run an existing pixelwise model and add result to the input image as additional channels |
| CAddPositionChannelOperation | Add additional channels with the position of the pixels |
| CAddRandomNoiseOperation | Apply a pixelwise random noise to the image intensities |
| CAdjustShiftScaleOperation | Apply a shift and scale to each channel of the input image |
| CApplyTopDownFlagOperation | Flip the input image if it has a topDown flag set to false |
| CApproximateToHigherResolutionOperation | Replicate the input image from the original reference image (in ReferenceImageDataComponent) |
| 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 image 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 | Bake the Photometric Interpretation into the intensities of the image |
| CBakeTransformationOperation | Apply the rotation contained in the matrix of the input volume |
| CBlobsFromKeypointsOperation | Transforms keypoints into an actual image (blob map with the same size of the image) |
| CCheckDataOperation | Checks if all input data match a set of expected conditions |
| CClipOperation | Clip the intensities to a minimum and maximum value |
| CConvertSlicesToVolumeOperation | Stacks a set of 2D images extracted along a specified axis into an actual 3D volume |
| CConvertToGrayOperation | Convert the input image to a single channel image by averaging all channels |
| CConvertVolumeToSlicesOperation | Unstacks a 3D volume to a set of 2D images extracted along one of the axes |
| CConvolutionalCRFOperation | Adapt segmentation map or raw output of model to image content |
| CCopyOperation | Copies a set of fields of a data item |
| CCropAroundLabelMapOperation | Selects the given label from a multi-label, and crops the image and labels around it |
| CAddDegradedLabelAsChannelOperation | Operation to add a channel with blobs whose sign depends on the label |
| CCropOperation | Crop input images and label maps with a given size and offset |
| CCutOutOperation | Cut out input images and label maps with a given size, offset and fill values |
| CDeformationOperation | Apply a deformation to the image using a specified control point grid and specified displacements |
| 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 |
| CGammaCorrectionOperation | Apply a gamma correction which changes the overall contrast |
| CGenerateRandomKeypointsOperation | Generate uniformly distributed random keypoints in the image |
| CHighPassOperation | Smooths the input image with a Gaussian kernel with half_kernel_size, then subtracts the smoothed image from the input, resulting in a reduction of low-frequency components |
| CImageMathOperation | Computes a specified formula involving images from the input dataitem |
| CImageMattingOperation | Refine edges of label-map based on the intensities of the input image |
| CInvertOperation | Invert the intensities of the image |
| 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 |
| CKeepLargestComponentOperation | Create a label map with the largest components above the specified threshold |
| 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) |
| CLinearIntensityMappingOperation | Apply a linear shift and scale to the image intensities |
| CMRIBiasFieldCorrectionOperation | Operation to perform bias field correction using an implicitly trained neural network (see MRIBiasFieldCorrectionAlgorithm for more details and the parameters description) |
| CMRIBiasFieldGenerationOperation | Apply or generate a multiplicative intensity modulation field |
| CMakeFloatOperation | Convert the input image to float with original values (internal shifts and scales are baked in) |
| CTagDataElementOperation | Operation for changing data element tags |
| 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 |
| CUnmarkAsTargetOperation | Remove the target tag from the elements of the input data item |
| CMergeAsChannelsOperation | Merge multiple images into one along the channel dimension |
| CMorphologicalFilterOperation | Runs a morphological operation on the input |
| CConcatenateNeighboringFramesToChannelsOperation | This function iterates over each frame, augmenting the channel dimension by appending or adding information from neighboring frames from both sides |
| CNormalizeMADOperation | Normalize the input image based on robust statistics |
| CNormalizeNormalOperation | Normalize the input image so that it has a zero-mean and a unit-standard deviation |
| CNormalizePercentileOperation | Normalize the input image based on its intensity distribution, in particular on a lower and upper percentile |
| CNormalizeUniformOperation | Normalize the input image based on their minimum/maximum intensity so that the output image has a [min; max] range |
| COneHotOperation | Encode a single channel label image to a one-hot representation with multiple channels |
| CPadOperation | Pad an image to a specific padding size in each dimension |
| CPadDimsOperation | Pad an image to specific target dimensions |
| CPadDimsToNextMultipleOperation | Pads each dimension of the input image to the next multiple of the specified divisor |
| CPolyCropOperation | Masks the image with a convex polygon as described in Markova et al |
| 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 | Apply AddRandomNoiseOperation to images with randomized intensity parameter |
| CRandomAxisFlipOperation | Flip image content along specified set of axes, with independent sampling for each axis |
| CRandomAxisRotationOperation | Rotate image around image axis with independently drawn axis-specific random rotation angle of +-{90, 180, 270} 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 matching random size and offset |
| CRandomCutOutOperation | Apply a random cutout to the image |
| CRandomDeformationOperation | Apply a deformation to the image using a specified control point grid and random displacements |
| CRandomGammaCorrectionOperation | Apply a random gamma correction to the image intensities |
| 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 linear shift and scale to the image intensities |
| CRandomMRIBiasFieldGenerationOperation | Apply or generate a random multiplicative intensity modulation field |
| CRandomPolyCropOperation | Masks the image with a random convex polygon as described in Markova et al |
| CRandomResolutionReductionOperation | Downsamples the image to a target_spacing and upsamples again to the original spacing to reduce image information |
| CRandomRotationOperation | Rotate input images and label maps with random angles |
| CRandomScalingOperation | Scale input images and label maps with random factors |
| 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 image matrix to the closest xyz-axis aligned rotation, effectively making every rotation angle a multiple of 90 degrees |
| CRemoveOperation | Removes a set of fields from a data item |
| CRemoveMaskOperation | Removes the mask of all input images |
| CRenameOperation | Renames a set of fields of a data item |
| CReplaceLabelsValuesOperation | Replace some label values with other values (only works for integer-typed labels) |
| CResampleDimsOperation | Resample the input to fixed target dimensions |
| CResampleKeepingAspectRatioOperation | Resample input to target dimensions while keeping aspect ratio of original images |
| CResampleOperation | Resample the input to a fixed target resolution |
| CResampleToInputOperation | Resample the input image with respect to the image in ReferenceImageDataComponent |
| CResolutionReductionOperation | Downsamples the image to the target_spacing and upsamples again to the original spacing to reduce image information |
| 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 |
| CScalingOperation | Scale input images and label maps with fixed factors |
| CSelectChannelsOperation | Keeps a subset of the input channels specified by the selected channel indices (0-based indexing) |
| CSetModalityOperation | Sets the input modality |
| CSetLabelModalityOperation | Sets the input modality |
| CSetMatrixToIdentityOperation | Set the matrices of all images to identity (associated landmarks and boxes will be moved accordingly) |
| CSetSpacingOperation | Modify images so that image elements have specified spacing (associated landmarks and boxes will be moved accordingly) |
| CSigmoidOperation | Apply a sigmoid function on the input image |
| CSmoothOperation | Run a convolution with a Gaussian kernel on the input image |
| CSoftmaxOperation | Computes channel-wise softmax on input |
| CSplitIntoPatchesOperation | Operation which splits the input image into overlapping patches for sliding window inference |
| CStandardizeImageAxesOperation | Reorganize the memory buffer of a medical image to ensure anatomical consistency |
| CSwapImageAndLabelsOperation | Swaps image and label map |
| CSyncOperation | Synchronizes shared memory (CPU <-> OpenGL) of images |
| CTanhOperation | Apply a tanh function on the input image |
| CTemplateInpaintingOperation | Inpaints a template into an image with specified spatial and intensity transformation |
| CThresholdOperation | Threshold the input image to a binary map with only 0 or 1 values |
| CUndoPaddingOperation | Apply the inverse of a previously applied padding operation |
| CCenterROISampler | Sampler which samples one ROI from the input image and label map with a target size |
| 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 |
| CLabelROISampler | Sampler which samples ROIs from the input image and label map, such that one particular label appears |
| COrientedROISampler | The OrientedROISampler samples m_numSamples samples of size m_roiSize from each dataset with an efficient GPU sampler |
| 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 |
| CSplitROISampler | Sampler which splits the input image into overlapping ROIs for sliding window inference |
| CBatchDataLoader | Batches the items in the nested loader into batches of the specified size |
| CCacheDataLoader | Caches the dataset loaded until now |
| 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 |
| CInterleaveDataLoader | Routes DataItems from different pipelines into one active pipeline |
| CMapDataLoader | Applies a mapping to each item in the nested loader |
| CPersistentCacheDataLoader | Caches the dataset loaded until now in a persistent manner (on a disk location) |
| CPrefetchDataLoader | Prefetch the next items in a background thread |
| CPreprocessDataLoader | Applies a preprocessing pipeline to each item in the nested loader |
| CRepeatDataLoader | Repeats items coming from a nested loader |
| CRandomizeDataLoader | Maintains a fixed-size buffer that provides randomized items through iterative replacement |
| CSampleDataLoader | Extract samples from each item in the nested loader |
| CShuffleDataLoader | Shuffles the next specified items in the nested loader |
| CSplitDataLoader | Splits the items in the nested loader into DataItems containing a single image (batch size of 1) |
| CBoundingBoxElement | DataElement based on BoundingBoxSet |
| CImageElement | DataElement for 2D and 3D images |
| CKeypointsElement | DataElement based on KeypointSet |
| CSISBasedElement | Interface for DataElement based on SharedImageSet |
| 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 |
| CVectorElement | DataElement for non-image data (such as imagewise labels), represented as 1D images (i.e |
| 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 |
| CFileReader | Loads data by reading the files from a list of data "columns" (see above) |
| CDataListReader | DataReader to directly read data from a given datalist where each column corresponds to a (single) field of the DataItem |
| CLoadedInfo | |
| CInversionComponent | Data component for storing operation inversion information |
| CInversionInfo | A structure to store all information needed for operation inversion |
| 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 |
| CPaddingDoneDataComponent | 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 |
| CPatchesFromImageDataComponent | Data component for keeping track of the original location of a patch in the original image |
| CPixelwiseLearningStream | Stream running a pixelwise learning model on another stream |
| CMeshSegmentationAlgorithm | Mesh segmentation algorithm based on a graph neural networks Converts an input Mesh to a Graph and runs a provided GNN model |
| CLabelsProjectDataReader | Data loader for training pipelines that load data directly from a Labels project |
| NGraphUtils | |
| CPathDistance | |
| 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 | |
| CFreeformSelector | Simple class to make it easy to select by hand a portion of a volume |
| CLabelMapRefinement | Helper class for post-processing a label map |
| CLabelPainter | Class for manually drawing to label maps |
| CSegment | |
| CReferenceShape | Abstract class defining a reference shape which has been fitted to a segmentation map |
| CLinearReferenceShape | Class defining a reference shape for which the conversion between local and world coordinates is a linear map (matrix multiplication + vector) |
| CLine2DReferenceShape | Reference with a line shape |
| CEllipseReferenceShape | Reference with an ellipse section shape |
| CSegmentedStructure | Interface class that offers methods to obtain measuring markers on a segmented object |
| CSegmentedBlob | |
| CSegmentedStructureWithReference | |
| CSegmentedLine2DStructure | |
| CSegmentedEllipseStructure | |
| CStructure | A Structure is a helper class providing a view onto a single label value within a label map |
| 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 |
| CStructureStatistics | Struct collecting statistics about a Structure |
| 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 |
| CLambdaManipulator | Utility class to avoid having to subclass the Manipulator class |
| CLambdaEventHandler | |
| CLabelLock | Convenience class for handling locked/unlocked state of labels |
| CWatershedTool | Wrapper class around the WatershedComputer to simplify common use cases |
| NUS | Namespace of the ImFusionUS and ImFusionLiveUS plugins |
| 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 |
| CConvertToSweep | Algorithm wrapping multiple ways to create an UltrasoundSweep from one or multiple images |
| 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 |
| CFrameGeometry | Represents the (fan) geometry of an ultrasound frame acquired through scanline-based imaging |
| CFan | Helper struct for drawing the fan and fan manipulation |
| CFanEdge | |
| CControlPoint | |
| CScanlineConfiguration3D | Dimensions of a 3D scanline dataset |
| CFrameGeometryConvex3D | Describes the specific convex acquisition parameters of a 3D ultrasound frame |
| CFrameGeometry3D | Describes the geometry of a 3D ultrasound frame |
| CFrameGeometryCircular | Specialization for circular frame geometries |
| CFrameGeometryConvex | Specialization for convex frame geometries |
| 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 |
| CFrameGrabbingConfigComponent | Data component that stores the configuration of FrameGrabbingPresets |
| CFrameGrabbingConfigEditorAlgorithm | |
| CFrameGrabbingConfigEditorController | |
| CFrameGrabbingPresets | Set of templates, geometries and depths |
| CROI | |
| CPreset | |
| CGeometryDetection | Actual implementation for automatically detecting the ultrasound image geometry from screen recordings |
| CBaseGeometryDetectionAlgorithm | |
| 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 |
| COptimizerParam | |
| 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 |
| CImportCalibrationAlgorithm | Imports the calibrations from a file and applies them to a number of UltrasoundSweep instances using a SweepCalibrator |
| CImportCalibrationController | Controller for ImportCalibrationAlgorithm |
| CInteractiveFanAnnotation | An interactive fan annotation that manages an internal FrameGeometry |
| CLabelCompoundingAlgorithm | Compounding of label maps belonging to an ultrasound sweep |
| CMergeSweepsAlgorithm | Merges multiple TrackedSharedImageSet into a single one |
| CMotionTrajectoryModel | Base class for helper classes modeling arbitrary motion trajectories using various parameterization methods |
| CComposedMotionModel | Motion model that composes multiple motion models into a single unified model |
| CSimpleMotionModel | Model representing simple motion defined either by a shift and rotation or a rigid pose between the first and last frames |
| CParametricMotionModel | A motion model that extends rigid motion with possible waypoint parametrization |
| CKeyframeMotionModel | This model allows users to define a set of keyframes—each associated with a specific frame index |
| CEveryFrameModel | Motion model with independent poses for each frame, exposing only one frame at a time for optimization |
| CPiecewiseMotionModel | Motion model enabling piecewise segment-based registration using frame selection |
| CGatingMotionModel | Specialized motion model that incorporates gating metadata for respiratory-aware motion |
| 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 |
| CPointsOnSweepManipulator | Class that handles creation and manipulation of points on ultrasound sweeps |
| CProbeRenderer | Visualizes the probe corresponding to an Ultrasound sweep in a volumetric view |
| CProcessUltrasoundParameters | Specifies the values that ProcessUltrasound will apply in the ultrasound data |
| CProcessedFrame | |
| CProcessUltrasound | Common processing functionality for ultrasound data |
| CProcessUltrasoundClip | |
| CProcessUltrasoundController | Controller for the ProcessUltrasound settings |
| CRawDataComponent | This data component holds SharedImageSets that relate to the one they are attached to, holding their associated raw ultrasound data |
| CRemoveDuplicateFrames | Algorithm for detecting and removing duplicate or nearly identical successive frames from an image set |
| CScanConversion | Ultrasound scan-conversion for curved and phased array data |
| CConversionParameters | |
| CScanConversion3D | Ultrasound scan-conversion for 3D probe data into a volumetric image and vice versa |
| CProbeTrackerPair | Class uniquely identifying a probe-tracker pair via probe-name and tracker-ID |
| 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 |
| CSweepCompoundingController | GUI controller for configuring and running freehand ultrasound sweep compounding |
| 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 |
| 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 |
| CSweepProcessingAlgorithm | High-level algorithm for post-processing 3D freehand ultrasound sweeps |
| CSweepPropertiesAlgorithm | Algorithm to change properties of one or two ultrasound 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 |
| CSyntheticUltrasoundSweepAlgorithm | Algorithm to create an ultrasound sweep without image content from two splines |
| CSyntheticUltrasoundSweepController | Controller for SyntheticUltrasoundSweepAlgorithm |
| CUltrasoundCalibrationInit | Helper class for the geometric computations needed in the UltrasoundCalibrationWizardAlgorithm |
| CUltrasoundMedium | Struct for medium properties used in ultrasound simulation |
| CUltrasoundMetadata | Metadata for a medical ultrasound image |
| 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 |
| CUltrasoundSimulationHybrid | Hybrid ultrasound simulation method |
| 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 |
| CPredictionMap | |
| CDetectionResult | |
| CBoneSegmentationController | Controller for ultrasound bone segmentation algorithm |
| CFrameFromVolumeOperation | Extracts 2D frames from a 3D volume by sampling while rotating around the specified axis |
| CRandomFrameFromVolumeOperation | Randomized version of the FrameFromVolumeOperation |
| CRawDataAlgorithm | Handles pairing of B-mode ultrasound images with raw data and an optional label map |
| CRawDataController | Controller for ultrasound B-mode and raw data handling |
| CClProbeDeformation | Differentiable OpenCL implementation of GlProbeDeformation |
| CProbeDeformationAlgorithm | Setup ultrasound probe-skin deformation on another volume |
| CSliceToVolumeRegistrationAlgorithm | Intensity-based registration of an ultrasound sweep to a volume |
| 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 |
| CSweepPointCorrAlgorithm | Handles point correspondences between an ultrasound sweep and a 3D volume for registration |
| CSweepPointCorrController | GUI controller for sweep to volume point correspondences |
| CUltrasoundCalibration | Freehand ultrasound calibration with overlapping sweeps |
| CUltrasoundCalibrationController | GUI controller for freehand ultrasound calibration |
| CUltrasoundRegistrationAlgorithm | Registration of an ultrasound sweep or volume to a tomographic scan (CT or MRI) |
| CLandmarkWeightingConfig | |
| CSegmentationWeightingConfig | |
| CAdvancedConfig | |
| CUltrasoundRegistrationController | GUI controller for 3D ultrasound registration |
| CUltrasoundSimulation | Ultrasound simulation from CT |
| CUltrasoundDISARegistrationAlgorithm | Algorithm for registering an ultrasound sweep to a volume using DISA |
| CUltrasoundDISARegistrationController | Controller for the UltrasoundDISARegistrationAlgorithm |
| CUltrasoundConeCalibrationAlgorithm | Algorithm that automatically computes ultrasound calibration using two or more ultrasound sweeps covering a cone phantom |
| CTrackedCone | Represents a cone detected in an ultrasound sweep across multiple frames |
| CTip | Represents a detected cone tip |
| CEstimatedCalibration | Represents an estimated calibration result |
| CFiducials | Represents fiducial points used for calibration |
| CMatches | Represents matches between cone tips from different sweeps |
| 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 |
| CFrameGrabbingAlgorithm | |
| CRoiAnnotationsWidget | |
| CRecordingWidget | |
| CPresetsTable | |
| CFrameGrabbingController | |
| CInstrumentButtonListener | Utility class for managing button events from hardware |
| 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 |
| CProbeTrackerAssigner | Assigns the main tracker to a tracking instrument whose name matches a predefined list associated with a probe name |
| CProcessedUltrasoundStream | Processes an ImageStream and attaches FrameGeometry info |
| CScreenTint | Utility class for applying a red tint to an UltrasoundSweep by modifying its transfer function |
| CStreamDisplayDataController | GUI DataController for adjusting ultrasound stream visualizations in the display views |
| CSweepPlaybackAlgorithm | An algorithm to playback an UltrasoundSweep as separate ImageStream and TrackingStream |
| 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 | |
| CCalibrationProgress | Progress implementation as an integrated QProgressBar |
| CWizardPage | Base WizardPage class |
| CIntroPage | Introduction page. The user can select which tracking instruments to calibrate for |
| CTrackRecordPage | Tracking recording page. Allows the user to record tracking sequences for each direction in the wizard |
| CSymmetryPage | Symmetry disambiguation page. Guides the user to indicate which probe orientation they're holding |
| CGuidedExpert | Guided or Expert selection page. Allows the user to end the wizard early with an initial calibration |
| CSweepRecordPage | Sweep recording page in the UltrasoundCalibrationWizard. Allows the user to record calibration sweeps |
| CCalibrationPage | Calibration page in the UltrasoundCalibrationWizard. Displays the calibration progress and controls to explore the calibration sweeps |
| CUltrasoundCalibrationWizard | Wizard dialog as fronted for the UltrasoundCalibrationWizardAlorithm |
| 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 |
| 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 |
| CRelativeGeneratorMixin | Template mixin for relative geometry generators |
| CGlobalTransformationGeneratorBase | Base class for global transformation generators |
| CPerFrameTransformationGeneratorBase | Base class for per-frame transformation generators |
| CRelativeTransformationSetupWrapperBase | Base class for RelativeTransformationSetupWrapper which requires customer move and copy semantics due to signal connections it creates |
| NGridBasedDistortionCorrectionUtils | Utilities for grid-based distortion correction algorithms |
| CBeadDetection | Structure representing a detected calibration bead |
| NSpectral | |
| CCTToDensity | Converts CT values (HU) to densities ( \(g/cm^3\)) using a stepweise linear mapping |
| CCTToMuRhoBasis | Converts CT values (HU) to mass attenuation coefficients or basis material fractions (a,b), respectively |
| 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 |
| 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 |
| CAutoFocusMotionCompensationAlgorithm | Compensating for rigid motion in projection images |
| CBeamHardeningCompensation | BeamHardeningCompensation |
| CCBCTPostProcessing | CBCTPostProcessing performs a cone cropping of a CT volume |
| CCTDataAnnotationFactory | Factory for CT-specific data annotations |
| CCTPlugin | ImFusion plugin for CT module algorithms and components |
| CConeBeamCalibration | Geometric calibration algorithm for X-ray imaging systems |
| CPointInfo | Information about extracted points |
| CPhantom | Struct specifying phantom layout |
| CPointExtractionParams | |
| CEllipseParams | |
| CStatistics | Struct holding statistics of the calibration |
| 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 |
| CConvertToConeBeamData | Algorithm for converting DICOM projection data to ConeBeamData format |
| CCopyConeBeamGeometryAlgorithm | Algorithm for copying cone-beam geometry between datasets |
| CEos2D3DRegistrationAlgorithm | 2D-3D registration algorithm for the EOS imaging system |
| CSingleton | Singleton wrapper template for type T |
| CFactory | Generic factory class for registering polymorphic types |
| CGeometrySelfCalibration | Auto-calibration algorithm for cone-beam geometry parameters |
| CGeometryGeneratorOptimizingAlgorithm | Optimizing algorithm for cone-beam geometry parameter estimation |
| CGl2D3DRegistration | OpenGL-accelerated 2D-3D registration for cone-beam projections |
| CGlFourierFilter1D | OpenGL-based 1D ramp filter for FDK reconstruction |
| CGlProjectiveObject | OpenGL wrapper for projecting 3D objects onto 2D X-ray images |
| CGlProjectiveAnnotation | Light-weight wrapper to project a GlAnnotation onto a 2D fluoro shot |
| CGridBasedDistortionCorrection | Grid-based distortion correction algorithm for X-ray images |
| CMetalArtifactReduction | Metal artifact reduction algorithm for CT reconstruction |
| CPointExtraction | Utility class for extracting calibration points from images |
| CProjectionLoader | Abstract base class for X-ray projection image loaders |
| CProjectionMatrixIoAlgorithm | I/O algorithm for saving and loading projection matrices |
| CProjectionPreProcessingAlgorithm | Algorithm for X-ray projection image pre-processing |
| CProjectionSets | Computation of projection subsets for iterative reconstruction |
| CRadonTransformAlgorithm | Algorithm for computing 2D Radon transform |
| CRingArtifactReduction | Ring artifact reduction algorithm for cone-beam CT |
| CSpectralXRaySimulation | Algorithm for generating synthetic spectral X-ray projections from CT volumes or meshes |
| CSyntheticCTFromMeshAlgorithm | Algorithm for creating synthetic CT volumes from mesh data |
| CXRay2D3DRegistrationAlgorithm | High-level 2D-3D registration algorithm for X-ray projections |
| CXRay2D3DRegistrationHistoryEntry | Data structure for storing 2D-3D registration history |
| CXRay2D3DRegistrationInitialization | Abstract interface for custom 2D-3D registration initialization methods |
| CInitializationResult | |
| CXRay2D3DRegistrationInitializationKeyPoints | 2D-3D registration initialization using keypoint correspondences |
| CXRay2D3DRegistrationInitializationPointDirection | 2D-3D registration initialization using point-direction pairs |
| CMesh2D3DRegistrationAlgorithm | Algorithm for 2D-3D registration using mesh-based synthetic CT generation |
| CBlock | Base class for pipeline processing blocks |
| CBlockMixin | Mixin pattern to use any Algorithm as Block |
| CLRUCacheMixin | Mixin pattern to add an lru cache to any Block |
| CCBCTProjector | Abstract base class for Cone-Beam Computed Tomography (CBCT) projectors |
| CGlCBCTProjector | OpenGL-based cone-beam CT projector implementation |
| CReconstructionAlgorithm | Algorithm for tomographic reconstruction |
| CAlgorithmReconstructionDecoratorInterface | Base class interface for AlgorithmReconstructionDecorator |
| CAlgorithmReconstructionDecorator | Template decorator for algorithms requiring reconstruction capabilities |
| CFullGeometryRepresentationWrapper | |
| CSnapshotGenerator | Geometry generator for capturing current geometric state |
| CMotionModelGenerator | Geometry generator using motion models for complex trajectories |
| CRelativeGlobalTransformationGenerator | Geometry generator for single relative transformation applied to all frames |
| CRelativePerFrameTransformationGenerator | Geometry generator for individual relative transformations per frame |
| CDetectorPropertiesDataComponent | Data component for detector properties and configuration Stores detector-specific parameters and settings for cone-beam systems |
| CGeometryAlgorithm | Algorithm for applying geometry settings to cone-beam data |
| CSourceDataComponent | Data component for cone-beam X-ray source parameters |
| CDetectorDataComponent | DataComponent to store the transformation from world to detector space for a single frame |
| CGeometryGenerator | Base class for X-ray geometry generators |
| CGeometryGeneratorParameterWrapper | Parameter wrapper for geometry generator optimization |
| CParametricGeometryGenerator | Parametric geometry generator for regular CBCT acquisition trajectories |
| CRelativeTransformationConfig | Configuration structure for relative transformation setup |
| CRelativeTransformationSetupWrapper | This class handles signal connections and ensures reconnecting after copying etc |
| CAnisotropicTV | Anisotropic Total Variation functional |
| CCG | Conjugate Gradient (CG) algorithm |
| CConvolutionFilter | Convolution filter implemented as LinearOperator |
| CDiagonalOperator | Base class for diagonal matrix linear operators |
| CDiagonalOperatorTpl | LinearOperator that multiplies each pixel by an ImageMath expression |
| CFDK | FDK (Feldkamp-Davis-Kress) algorithm for cone-beam CT reconstruction |
| CFiniteDifferences | Finite differences operator for image gradients |
| CFunctional | Abstract functional interface for optimization problems |
| CIdentityOperator | Identity linear operator implementation |
| 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 |
| 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< true > | Template instantiation for the case where the input expression is always be evaluated inuto a temporary |
| CLinearOperatorEvalInputExpr< false > | Template instantiation for the case where input ImageMath expressions are evaluated by the class directly |
| CLinearOperatorAdjointWrapper | Wraps a given linear operator, and represents its adjoint as a linear operator |
| CLinearOperatorTreeNode | Composite pattern for linear operator expression trees |
| CLinearResidual | Linear residual for tomographic reconstruction |
| CMLEM | MLEM (Maximum Likelihood Expectation Maximization) algorithm |
| CMatrixLinearOperator | Linear operator wrapping an explicit matrix |
| COptimizationProblem | Optimization problem formulation for tomographic reconstruction |
| CRegTerm | |
| CRegTermOwning | |
| CSART | SART (Simultaneous Algebraic Reconstruction Technique) algorithm |
| CSQS | SQS (Separable Quadratic Surrogate) algorithm |
| CSolver | Abstract base class for optimization solvers |
| CStatisticallyWeightedLeastSquaresProblem | Statistically weighted least-squares optimization problem |
| CWeightedL2Pow2 | Weighted L2 squared norm functional with diagonal weighting matrix |
| CAsdPocs | AsdPocs |
| CCropFanEventHandler | CropFanEventHandler |
| CLoggingHandler | EventHandler to log optimization |
| 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 |
| CInitializer | Initializer |
| CMLVolumeInference | |
| CMemoryManager | Memory manager |
| CNesterovStep | NesterovStep |
| CPositivityHandler | PositivityHandler |
| CConeBeamDataDisplayHandler | Display handler for cone-beam data visualization |
| CConeBeamDisplayOptions | Data component for cone-beam display configuration |
| CConeBeamGeometryController | GUI controller for cone-beam geometry parameter editing |
| CConeBeamGeometryVisualisation | Visualization component for cone-beam geometry |
| CGeometrySelfCalibrationController | GUI controller for geometry self-calibration |
| CConeBeamSimulationController | GUI controller for cone-beam simulation algorithm |
| CGl2D3DRegistrationController | GUI controller for OpenGL-based 2D-3D registration |
| CGridBasedDistortionCorrectionController | GUI controller for grid-based distortion correction |
| CMesh2D3DRegistrationController | GUI controller for mesh-based 2D-3D registration |
| CAutoFocusMotionCompensationAlgorithmController | GUI controller for auto-focus motion compensation algorithm |
| CAlgorithmReconstructionDecoratorController | Base controller for reconstruction algorithm decorators |
| CGeometryAlgorithmController | GUI controller for GeometryAlgorithm |
| CXRay2D3DRegistrationAlgorithmController | Controller for the XRay2D3DRegistrationAlgorithm |
| CXRay2D3DRegistrationInitializationController | GUI controller for 2D-3D registration initialization methods |
| CXRay2D3DRegistrationInitializationKeyPointsController | GUI controller for keypoint-based registration initialization |
| CConeBeamFramePars | Stores and handles individual per-frame transformation parameters |
| CConeBeamGeometry | Legacy cone-beam geometry representation |
| CGlConeBeamForward | Legacy OpenGL cone-beam forward projection |
| CGlGeometryView | Legacy OpenGL geometry visualization |
| CProjectionPreProcessing | Pre-processing of projection images |
| CSequentialMotion | Legacy sequential motion analysis for CBCT data |
| CConeBeamSimulationOperation | ML operation for simulating X-ray projections from CT volumes |
| CRandomConeBeamSimulationOperation | Randomized cone-beam simulation operation for data augmentation |
| CXRayFixtureOperation | ML operation for applying virtual fixture to X-ray images |
| CXRayUndoLogConversionOperation | ML operation for reversing X-ray log domain conversion |
| CXRaySamplingOperation | ML operation for X-ray image sampling and processing |
| CSimulateCBCTOperation | ML operation for CBCT simulation and sampling |
| CRandomSimulateCBCTOperation | Randomized CBCT simulation operation for data augmentation |
| CRandomXRaySamplingOperation | Randomized X-ray sampling operation for data augmentation |
| CRandomXRayFixtureOperation | Randomized X-ray fixture operation for data augmentation |
| CRandomXRayUndoLogConversionOperation | Randomized X-ray log conversion reversal operation |
| CSmoothCTEdgesOperation | ML operation for smoothing CT volume edges |
| 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 |
| CXrayFunctionalGroups | Module implementing PS 3.3 C.7.6.16 |
| CXrayFunctionalGroupMacro | |
| CDicomSingleFrameConeBeamIOD | Dicom IOD for loading ConeBeamData from individual files |
| CDicomMultiFrameConeBeamIOD | Dicom IOD for loading ConeBeamData from an enhanced multi-frame file |
| NVision | |
| NUtils | |
| CSharedImageSetCompatibleCondition | Structure contains common compatible criterion for SharedImageSet |
| NMLHelpers | |
| CVisionMLModelsFactory | |
| CDeviceParameters | Save image in text file one image row per line |
| COpticalFlowAlgorithm | |
| NExport | |
| CExportOptions | |
| CFilteringOptions | |
| CLabelEncodingOptions | |
| CPixelwiseEncodingOptions | |
| CGeometricAnnotationsEncodingOptions | |
| CTagsEncodingOptions | |
| CEncoding | |
| CSplittingOptions | |
| CResamplingOptions | |
| CTransformationOptions | |
| CExportDataResult | |
| CDataSplits | |
| CLandmarkExportOptions | |
| CLabel | |
| NImport | |
| CEntry | |
| CEntriesLoader | |
| CImportResult | |
| NProjectWizard | |
| CRemoteInfo | |
| CInfo | |
| NModelsManager | Contains functionality for downloading ML models from a server and caching them on disk |
| CModelInfo | |
| NUrlHandler | |
| COpenProjectAction | A project should be opened |
| NInternal | |
| CLoadModelWorker | A worker thread that loads ML models |
| NUI | |
| CLambdaFilter | |
| NAnatomyPlugin | Namespace of the anatomy plugin |
| Ndetail | |
| CStyleSheetListModel | |
| CStyleSheetsWidget | |
| CCreator | Base class for creators to be registered in factory |
| CCreatorImpl | Wrapper around a std::function used for constructing an item Derived from Base |
| CSelectorElem | Class for querying objects |
| CSelector | Style selector combining with logical OR multiple SelectorElem objects |
| 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 |
| CStylePseudoClass | Known modifier keys. In analogy to CSS, we refer to modifiers of this type as "pseudo-classes" |
| CInspectStyleSheetsAlgorithm | This algorithm exists so that InspectStyleSheetsController can exist |
| CInspectStyleSheetsController | |
| CAnatomyPluginFactory | |
| CAnatomyControllerFactory | |
| CASCDataAnnotationFactory | |
| CSingleton | Base class for singletons |
| CRegistry | |
| CFactory | Generic factory class for registering polymorphic types Usage: |
| 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 |
| 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 | |
| CSmoothMeshes | Replaces by the iso-surface of the distance-volume each contained mesh |
| CMoveFaceLabelsToHalfEdges | Helper algorithm to move face labels in meshes to half-edge labels |
| NAnatomicalStructureRegistrations | |
| CPointsAndPlanes | Register two AnatomicalStructure instances by matching keypoints |
| 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 |
| CAutomaticRegistration | Try various types of registration and run the "best" one |
| NASCRegistrationMethods | |
| NICPUtils | |
| CPointsWithMetadata | Helper struct to store points together with information about what structure the points are derived from |
| CPairedPointsWithMetadataVector | Lightweight helper structure to manage sets of paired points |
| CAlignStructuresByTranslation | Tries to approximately align two structures by translating the moving structure |
| CICP | Align two AnatomicalStructureCollections using variants of the ICP algorithm |
| CReturnError | Meta ASCRegistrationMethod that just returns an error |
| CPerAnatomy | Template to convert a (per-structure) AnatomicalStructureRegistration into a ASCRegistration that acts on the structure collection |
| CModifyBehavior | Sets attributes that control registration behavior per structure |
| CPerStructureBoolean | Describes the behavior of individual structures for registration |
| 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 |
| NCranial | |
| CACPCDetectionAlgorithm | Detects the AC (anterior commissure) and PC (posterior commissure) landmarks in a 3D brain MRI with one of the following contrasts: T1(C), T2, FLAIR |
| CCTSkullSegmentationAlgorithm | Algorithm for segmenting the skull in CT volumes |
| CFastSurferSegmentationAlgorithm | Algorithm wrapping the FastSurfer-based algorithm for brain parcellation |
| CHypothalamusSegmentationAlgorithm | Algorithm for segmenting hypothalamus sub-regions and surrounding structures in T1 MR volumes |
| CMRISequenceClassificationAlgorithm | Algorithm for classifying the MR sequence of a 3D brain scan |
| CSkullStrippingAlgorithm | Algorithm for segmenting the brain in MR volumes |
| CTumorSegmentationAlgorithm | Algorithm for segmenting tumour in one or several MR images |
| CVesselSegmentationAlgorithm | Algorithm for segmenting vessels in brain MR scans with contrast |
| CWholeBrainSegmentationAlgorithm | Algorithm for segmenting all the brain structures in T1 MR volumes |
| NEndoscopy | |
| CEndoscopicToolSegmentation | |
| CEndoscopicToolSegmentationFactory | |
| CEndoscopicToolSegmentationAlgorithm | Algorithm for segmenting endoscopic tools in image sequences |
| CEndoscopicToolSegmentationCustomModel | Endoscopic tool segmentation using a custom machine learning model |
| CLiteTracker | |
| CPointTrackingAlgorithm | Algorithm for tracking user-selected points in 2D image streams |
| NRobotics | |
| NIO | |
| CPathHandler | |
| NMotionPlanning | |
| NCollocation | |
| CGLCollocationData | Structor to contain the collocation points, integration weights, varycentric weights and derivativeMatrix of the gieven set of points |
| NSE3 | |
| CPolynomialSE3 | Polynomial class for SE3 |
| NOptimization | |
| NSE3Operators | |
| CErrorToPolynomial | |
| CPolynomialParametrization | |
| CPolynomialChart | |
| CChart | |
| CParametrization | |
| CError | |
| CErrorTo | |
| CPolynomialLift | |
| NPolynomialOperators | |
| CFunctionPolToPol | |
| CFunctionVecToPol | |
| CFunctionPolToVec | |
| CDerivative | |
| CIntegral | |
| CContinuityError | |
| CInitialPoint | |
| CFinalPoint | |
| CInitialPointDerivative | |
| CFinalPointDerivative | |
| CLeftJunctionPoint | |
| CVectorToPolynomial | |
| CPolynomialToVector | |
| CAbstractFunctionSparseDifferential | |
| NPolynomialWithIntervalPartition | |
| CFunctionPolToPol | |
| CFunctionVecToPol | |
| CFunctionPolToVec | |
| CDerivative | |
| CIntegral | |
| CContinuityError | |
| CInitialPoint | |
| CFinalPoint | |
| CInitialPointDerivative | |
| CFinalPointDerivative | |
| CLeftJunctionPoint | |
| CVectorToPolynomial | |
| CPolynomialToVector | |
| CExecutionTime | |
| CPolynomialWithPartitionToVectorOfCoefficients | |
| CL2Norm | |
| CSobolevSemiNorm | |
| CBSplineInterpolation | |
| CBSplineInterpolationWithVariableWaypoints | |
| CVectorToIntervalPartitionAndWaypointsVector | |
| CTupleIntervalPartitionWaypointsToIntervalPartition | |
| CAbstractFunctionSparseDifferential | |
| NPolynomialWithIntervalPartitionConstraints | |
| CInterpolationConstraints | |
| NInterval | |
| CVectorToIntervalPartition | |
| CLength | |
| NTraits | |
| CRefWrapperSelector | |
| CRefWrapperSelector< std::reference_wrapper< T > > | |
| CRefWrapperSelector< Eigen::VectorXd > | |
| CRefWrapperSelector< Eigen::Ref< Eigen::VectorXd > > | |
| CRefWrapperSelector< const Eigen::Ref< const Eigen::VectorXd > > | |
| CRefWrapperSelector< const Eigen::Ref< Eigen::VectorXd > > | |
| CRefWrapperSelector< Eigen::Ref< const Eigen::VectorXd > > | |
| CRefWrapperSelector< const Eigen::VectorXd > | |
| CRefWrapperSelector< std::vector< T >, std::enable_if_t<!std::is_arithmetic_v< T > > > | Vector specialization |
| CRefWrapperSelector< const std::vector< T >, std::enable_if_t<!std::is_arithmetic_v< T > > > | |
| CRefWrapperSelector< std::array< T, N >, std::enable_if_t<!std::is_arithmetic_v< T > > > | |
| CRefWrapperSelector< const std::array< T, N >, std::enable_if_t<!std::is_arithmetic_v< T > > > | |
| CRefWrapperSelector< std::tuple< Types... > > | |
| CRefWrapperSelector< const std::tuple< Types... > > | |
| CReferenceSelector | |
| CReferenceSelector< Eigen::VectorXd > | |
| CReferenceSelector< const Eigen::VectorXd > | |
| CReferenceSelector< std::vector< T >, std::enable_if_t<!std::is_arithmetic_v< T > > > | Vector specialization |
| CReferenceSelector< const std::vector< T >, std::enable_if_t<!std::is_arithmetic_v< T > > > | |
| CReferenceSelector< std::array< T, N >, std::enable_if_t<!std::is_arithmetic_v< T > > > | |
| CReferenceSelector< const std::array< T, N >, std::enable_if_t<!std::is_arithmetic_v< T > > > | |
| CReferenceSelector< std::tuple< Types... > > | |
| CReferenceSelector< const std::tuple< Types... > > | |
| Cis_vector | |
| Cis_vector< std::vector< T > > | |
| Cis_tuple | |
| Cis_tuple< std::tuple< Args... > > | |
| CRemoveIndexFromTuple | |
| CRemoveIndexFromTuple< std::tuple< Types... >, I > | |
| 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 | |
| CAbstractFunction | |
| CAbstractFunctionTpl | |
| CAbstractFunctionDenseDifferential | |
| CAbstractFunctionDenseDifferentialTpl | |
| CPartial | |
| CAbstractFunctionSparseDifferential | |
| CAbstractFunctionSparseDifferentialTpl | |
| CAbstractFunctionLifting | |
| CConversionWrapper | |
| CAbstractFunction< Eigen::VectorXd, Eigen::VectorXd > | |
| CAbstractFunction< Eigen::VectorXd, double > | |
| CFunctionRnToRmDenseDifferential | |
| CFunctionRnToRmSparseDifferential | |
| CDenseLiftRnToRm | Wraps a lambda function which tales, input, output and an optional to the differential |
| CDenseLiftRnToR | Wraps a lambda function which tales, input, output and an optional to the differential |
| CFunctionRnToRmStack | A class to compose multiple functions into a single combined function |
| CAbstractFunctionComposition< Eigen::VectorXd, double > | |
| CConstraints | This class IMFUSION_ROBOTICS_API contains a stack and two vectors for upper and lower constratins |
| CLessThanZeroWrapper | Transforms a Constraints l < g < u into another g' < 0, such that g' = [l - g, g - u]' |
| CSimpleConstraints | |
| CConstraintsStack | |
| COptimizer | |
| CError | |
| COptimizerNLopt | |
| CError | |
| 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 | |
| CInterval | Represents an interval in the real line |
| CIntervalPartitionXd | Represents an partition of the interval [t_0, t_N] |
| 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 |
| CMPolynomial | Class representing a piecewise polynomial a curve on the type T given be the action of a Parametrization on a Polynomial |
| CMPolynomial< Eigen::VectorXd > | |
| CMPolynomial< double > | Scalar Polynomial class |
| CSE3Interpolator | |
| CRandomTrackingSequence | |
| CDirectKinematics | |
| CPolynomialDirectKinematics | |
| CRobotLocation | Base class for describing the parameters needed by the individual robot SDK to connect to a device |
| CRobotJointDescription | Structs |
| CLimits | Defines the motion limits for a particular joint |
| CRobotLinkDescription | Defines a description of a robot link including its visual properties and connections |
| CVisual | |
| CSavedGroupState | Represents a named configuration of joint positions for a specific group of robot joints |
| CRobotDescription | Comprehensive description of a robot's kinematic structure and properties Contains the complete definition of a robot's joints, links, and their relationships |
| CRobotArmCartesianState | Comprehensive description of the complete Cartesian state of a robot arm and its attached objects |
| CRobotGUIProperties | |
| CRobotBlueprint | |
| CRobotFactory | Factory class for RobotStateStream |
| 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 |
| CRoboticsAlgorithmFactory | Algorithm Factory for the Robotics plugin |
| CRoboticsAlgorithmControllerFactory | Algorithm Controller Factory for the Robotics plugin |
| CRoboticsPlugin | Plugin for generic Robotics functionality |
| CRobotRunner | Core class for managing robot execution and real-time control in the ImFusion SDK |
| CMotionData | Data structure holding information about the current motion |
| CRobotSolution | |
| CRoboticsPluginSettings | |
| 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 |
| CJointState | Represents a joint's rotational state in terms of position and velocity |
| CCartesianQuantities | Represents Cartesian quantities used to describe 3D spatial information |
| CCartesianState | Represents pose and velocity of a frame in Cartesian coordinates |
| CCartesianFrames | Holds two Cartesian States between different parts of the robotic system (i.e flange to base, and effector to base) |
| CNativeRobotStateBase | |
| CRobotState | Contains the current status of the robot (i.e |
| CRobotStateStreamData | Stream data containing robot state information |
| CRobotStateStream | A Stream class for interfacing with robots in the ImFusion SDK |
| CCreateRobotStreamAlgorithm | |
| CControlInterfaceBase | Base class for robot control interfaces |
| CStatusInterface | Most standard control interface, which exposes functionality common to most robots |
| CDynamicsInterface | Interface to define the method used to compute the robot dynamics |
| CDynamicsInterfaceWithFallback | Mixin class for providing a generic implementation of robot dynamics computation |
| CPlanningFrameInterface | Interface used for kinematic computations in world frame |
| CControllerConfiguration | Configuration to be used to configure a controller |
| CControllerConfigurationInterface | Interface to register and query controllers supported by the robot |
| CMotionResult | Type returned by the startMotion() methods implemented by various control interfaces |
| CJointPTPControlInterface | Interface for executing point-to-point motions with a goal identified by a joint position |
| CJointStreamingControlInterface | Interface for executing motions represented by a motion generator in joint space |
| CCartesianPTPControlInterface | Interface for executing point-to-point motions with a goal identified by a Cartesian position |
| CCartesianStreamingControlInterface | Interface for executing motions represented by a motion generator in Cartesian space |
| CGravityCompensationControlInterface | Interface to start and stop gravity compensation / teaching mode |
| CCollisionDetectionPresetInterface | Interface to register, query and activate collision detection presets |
| CRobotControlInterfacesHolder | Interface to register and access robot control interfaces |
| CRobotTrackingStream | Real-time tracking of robot poses via robot state stream (updates) signals |
| CJointTrajectoryDataComponent | DataComponent to hold the joint position of the robot over time |
| 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 | |
| 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 | |
| CCartesianInterpolationMotionGenerator | Interpolates from the current to a target Cartesian position with a trapezoidal speed profile |
| 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 |
| CCartesianImpedanceController | Implements Cartesian impedance with respect to the commanded motion |
| CParameters | |
| CPlanarCartesianImpedanceController | Implements Cartesian impedance on a plane of the given frame |
| CParameters | |
| CUnalignedConstantForceTorqueController | Applies a constant force along the specified axis |
| CParameters | |
| CNullTorqueController | Instructs the robot to apply zero torque |
| CParameters | |
| CConstantForceTorqueController | Applies a constant force along the specified axis |
| CParameters | |
| CMotionStep | |
| CRateLimits | |
| CControlIterationInfo | |
| CMotionGeneratorParametersInterface | |
| CMotionGeneratorParametersBase | |
| CMotionGeneratorBase | |
| 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 |
| 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 |
| CTorqueControllerParametersInterface | |
| CTorqueControllerParametersBase | |
| CTorqueControllerBase | Base class for generic robot controllers |
| CPureTorqueController | |
| CCartesianSetpointTorqueController | |
| CJointSetpointTorqueController | |
| CRuckigCartesianStreamingMotionGenerator | Takes a Cartesian pose as goal; it does IK first and then uses Ruckig to blend the motion with the current movement |
| CParameters | |
| CRobotTree | Represents the tree information of a robot |
| CRobotGroupState | Defines a named state of the joint values in the RobotChains of a particular RobotGroup |
| CRobotEndEffector | |
| CRobotGroup | Describes a named subset of the RobotTree conformed by multiple RobotChains |
| CRobotJoint | Represents a robot joint associated with a RobotSegment. Defines the name, type and limits of a particular joint |
| CRobotLink | |
| CRobotSegment | A RobotSegment represent each of the named individual parts of a RobotChain, with a RobotJoint |
| CRobotSegmentMap | |
| CRobotChain | Subset of a RobotGroup or RobotTree of consecutive RobotSegments |
| CRobotSolver | Calculates the IK/FK of a RobotTreeImpl or a specific RobotChain |
| CRobotSolverAsync | |
| 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 |
| CRobotTreeImpl | Interface between RobotTree and the implementation/libraries used to hold the tree representation |
| CRobotTreeKDL | |
| CRobotVisualization | |
| 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 |
| CFakeRobotControlStream | Stream that allows to programmatically set the joint position and simulate motion in Cartesian and joint space |
| CHighResTimestampDataComponent | DataComponent storing high-resolution timestamps |
| CGenericSocketInterface | Generic class to connect to a raw socket and send/receive text data |
| 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 |
| CMouseEventsReceiver | |
| 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 |
| CTCPTransformFilter | |
| CTransformFilterBase | |
| CCartesianTransformFilter | |
| CTranslationTransformFilter | |
| CWorldTransformFilter | |
| CErrorFrontEnd | Error class used by our specialization of Utils::Expected |
| CErrorInterface | An interface for error handling and representation |
| CErrorKDL | |
| CErrorTracIK | Implementation of error types from trac_ik library |
| CHandEyeCalibrationAlgorithm | Specialized hand-eye calibration for robot-camera systems |
| CCalibrationSample | |
| CHandEyeCalibrationRobotMotion | |
| CHandEyeCalibrationDataCapture | |
| CHandEyeCalibrationPatternGenerator | |
| CCalibrationParameters | |
| CCalibrationSamples | |
| CHandEyeEvaluationAlgorithm | Evaluates hand-eye calibration accuracy (chain error) for robot-camera systems |
| CRelativeCalibrationAlgorithm | An algorithm for computing the matrix which transforms the relative translation of one stream into the relative translation of another such that the following holds: trackingSequence1Delta.translation() = scale * R * trackingSequence2Delta.translation() + t |
| CFakeFrankaControlStream | |
| CFakeFrankaHandControlStream | |
| CFrankaControlStream | Control interface for a Franka Panda robot |
| CFrankaManagerAlgorithm | |
| CFrankaManagerController | |
| CFakeURControlStream | Extends a FakeRobotArmControlStream to add the analog inputs / outputs |
| CFakeUR5ControlStream | |
| CURRobotLocation | |
| CURControlStream | Control interface for a Universal Robot robot (CB3 or e-series) Supports the ControlInterfaces implemented by URRunner |
| 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 |
| CRobotUSTrackingStream | |
| NROS | |
| CSimpleROSListenerInterface | Convenience interface that wraps ROS subscribers |
| CSimpleROSImageListener | |
| CSimpleROSTrackingListener | |
| CSimpleROSFloatListener | |
| CSimpleROSStringListener | |
| CSimpleROSIntListener | |
| CSimpleROSPublisherInterface | Convenience interface that wraps ROS publisher |
| CSimpleROSImagePublisher | |
| CSimpleROSTrackingPublisher | |
| CSimpleROSFloatPublisher | |
| CSimpleROSStringPublisher | |
| CSimpleROSServiceCallerInterface | Convenience interface that wraps ROS service clients |
| CSimpleROSServiceServerInterface | Convenience interface that wraps ROS service servers |
| CSimpleROSEmptyServiceCaller | ImFusion implementation of std_srvs/Empty service client |
| CSimpleROSEmptyServiceServer | ImFusion implementation of std_srvs/Empty service server |
| CSimpleROSTriggerServiceCaller | ImFusion implementation of std_srvs/Trigger service client |
| CSimpleROSTriggerServiceServer | ImFusion implementation of std_srvs/Trigger service server |
| CSimpleROSSetBoolServiceCaller | ImFusion implementation of std_srvs/SetBool service client |
| CSimpleROSSetBoolServiceServer | ImFusion implementation of std_srvs/SetBool service server |
| CROSMsgDLLPreloader | |
| CSimpleROSListener | |
| CSimpleROSPublisher | |
| CSimpleROSServiceCaller | |
| CSimpleROSServiceServer | |
| CROSParameterPath | Class to abstract between ROS1 and ROS2 parameter paths |
| CImFusionROSManager | Singleton class to manage the ROS node When using ROS2, it will manage the main ROS node used to listen to tf |
| CROSPluginSettings | Provides settings used by different parts of the ROSPlugin |
| CRosWorkspace | |
| CSettingsWidget | Simple Qt widget to configure the ROSPluginSettings |
| CROSTypeName | |
| CFrameTransform | Frames identifying a transformation between two coordinate frames in tf |
| CHash | |
| CROSBagTfSelection | |
| 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 |
| CROSBagImportSpecification | |
| CTrackingImportOptions | |
| CImageImportOptions | |
| CPlaybackOptions | |
| CTopicMetadata | |
| CROSBagWriter | Convenience class to wrap custom writer RAII |
| CROSBagReader | Convenience class to wrap custom reader RAII |
| CImFusionTfManager | Singleton class to manage tf |
| CTfTransform | |
| CROSTfTrackingStream | Tracking streams which are generated by listening to the ROS tf system |
| CROSTopicImageStream | Image streams which are generated by listening to ROS 2D Image topics |
| CROSTopicTrackingOutStream | Tracking streams which can transmit a position in space over ROS Transform/Pose topics |
| CROSTopicImageOutStream | Tracking streams which can transmit images over ROS Image topics |
| CROSTopicTrackingStream | Tracking streams which are generated by listening to ROS Transform/Pose topics |
| CCreateROSStreamAlgorithm | |
| CCreateInputROSStreamAlgorithm | |
| CCreateOutputROSStreamAlgorithm | |
| CROSStreamBlueprint | |
| CROSStreamFactory | |
| CROSBagIoAlgorithm | IO algorithm to load/store SharedImageSets and TrackingStreams from/to ROS Bag files |
| CSeekableTrackingStream | |
| CROSBagSeekableStreamIoAlgorithm | Algorithm for creating Streams reading compatible messages out of a ROSBag on the fly |
| CROSMaster | ROS Master execution handler |
| CROSMasterAlgorithm | |
| CROSParameter | Wrapper for ROS1 and ROS2 parameters |
| CROSParameterManager | Class to handle ROS1 and ROS2 parameters |
| CROSTopicRGBDStream | RGBD streams which are generated by ROS drivers for RGBD cameras |
| CMoveItControlStream | Control interface mirroring a running ROS MoveIt! |
| CPlanResult | |
| CCreateMoveItControlStreamAlgorithm | |
| CMoveitServiceCallerInheritanceHelper | Helper class to avoid writing the methods connect, disconnect and isConnected |
| CApplyCollisionObjectServiceClient | Ask to the Move Group what are the planners that are currently loaded |
| CByteBufferView | Const view onto a sized buffer of raw binary data |
| CByteBufferMutableView | Specialization of a ByteBufferView that additionally provides non-const access to the underlying data |
| CByteBuffer | Specialization of the ByteBufferView class that has ownership of the underlying data |
| CByteBufferStream | Specialization of std::istream to easily extract data from a ByteBufferView |
| CByteSize | Helper class to facilitate handling byte sizes |
| CConfigurable | Base interface for classes that support object serialization from/to Properties objects |
| CParam | |
| CDeprecatedSignal | Deprecation layer for signals |
| CFlags | Utility class to store a type-safe combination of enum-based bit fields |
| 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 |
| CPluginBase | Base interface to interact with a plugin that can be loaded into an application at runtime |
| CPluginAutoRegistrationGuard | Helper class to automatically register a plugin when the OS loads a library |
| CPluginManager | Global singleton for loading ImFusion plugins from shared libraries and initializing them |
| CPluginInfo | Record collecting metadata about registered plugins |
| CProperties | Storage container for serialization of arbitrary types, internally backed by strings |
| CGlobalSettings | Class for storing and retrieving persistent global settings |
| CSignalReceiver | Base class for classes that can contain slots (i.e |
| CSignalConnection | Structure for describing/identifying individual connections between signals and slots |
| CSignalDebouncer | |
| CSignalDebouncer< DerivedSignal > | |
| CSignalImpl | Implementation for a specific signal with the given signature |
| CSignalBlocker | Convenient scope guard class to temporarily block signals/connections so that observers are not notified |
| CSignalBase | Base interface for Signals |
| CSignalMutexProxy | |
| CSignalMutexProxy< false > | |
| CEmptyLockGuard | |
| CSignalMutexProxy< true > | |
| CSubProperty | The SubProperty class represents a nested record of a Configurable entity |
| CSubPropertyList | The SubPropertyList class represents nested records of Configurable entities |
| CTransform | The Transform class provides a transformation from a Frame to another Frame, where each Frame is a coordinate system |
| CTimer | Stopwatch class to measure execution time |
| CLoggingTimer | Scope guard-like stopwatch class to automatically log measured execution time on destruction of the guard object |
| CMultiTimer | This class can be used to help the developer to profile the run time of different parts of the same process |
| CVector | Class representing a vector, defined in a Frame |
| CAssignMeshTextureAlgorithm | Copies a RGB 2D image to use as texture for a mesh |
| CCombineMeshesAlgorithm | Algorithm to combine multiple meshes into a new mesh |
| CExtractMeshTextureAlgorithm | Extracts the texture from a given mesh to an image |
| CCustomVertexProperty | A custom property using vertices as geometry elements |
| CCustomFaceProperty | A custom property using faces/triangles as geometry elements |
| CMesh | Represents a triangle mesh |
| CTopologyErrors | Adds a new face, consisting of the 3 existing(!) vertices specified by their indices |
| CMeshBooleanOperationsAlgorithm | Algorithm for performing boolean operations on meshes |
| CMeshCreatorAlgorithm | Algorithm for creating common mesh primitives |
| CCustomPropertyElementBase | Basic interface for the value of a custom property on a single element |
| CCustomPropertyElement | Wrapper for the value of a custom property on a specific element, with conversions to and from the underlying data type |
| CCustomPropertyDescriptor | |
| CCustomPropertyBase | Basic interface for a custom property, i.e. a collection of values on different elements (vertices/faces) |
| CCustomProperty | Interface for a custom typed property, allowing access to the values at individual elements |
| CMeshDistanceAlgorithm | Algorithm to compute point-wise distances between two aligned meshes, between two aligned point clouds, or between aligned point cloud and mesh |
| CStat | |
| CMeshIterator | |
| CMeshIteratorRel | |
| CMeshLaplacian | Compute co-tangent laplacian of a mesh and its eigen decomposition |
| CMeshMeasurementsAlgorithm | A class that provides functions for measuring the lengths of certain curves on a mesh |
| CMeshMeasurementsController | |
| CMeasurementPlane | |
| CMeshOctreeNode | Class representing a mesh octree node |
| 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) |
| 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 |
| CPoissonSurfaceReconstructionAlgorithm | Algorithm for computing poisson reconstruction from a point cloud with normals |
| CTriMeshTraits | |
| CTriMesh | |
| CMeshGeodesicDistance | Class for computing the geodesic distance on the mesh surface between the 2 points |
| 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 |
| CGlMeshRendererIntersectionLengths | Renders the intersection lengths through a mesh in a 3D view |
| CDisplayOptions | Complete record of rendering options for GlMeshRendererIntersectionLengths |
| 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 |
| CMaterial | |
| CClipping | |
| CMeshGl | Stores vertex and texture data of a Mesh on the GPU so that it can be rendered using OpenGL |
| CAlgorithm | Interface for describing algorithms that can be made available in the ImFusion Suite through AlgorithmFactory |
| CFactoryInfo | Struct describing how an Algorithm was instantiated by the AlgorithmFactory |
| CAction | Struct for representing a named action that has been registered with this algorithm |
| CAlgorithmControllerFactory | Interface for algorithm controller factories |
| CAlgorithmFactory | Interface for algorithm factories |
| CDescriptor | Struct describing an algorithm registered with a factory |
| CAnatomy | Class representing a single anatomy code ID from the SNOMED CT database |
| CAnatomyAlgorithm | Edits the list of anatomies of an image (AnatomyDataComponent) |
| CAnatomyDataComponent | A data component storing information about anatomy contained in medical images or other data |
| CApplyMaskAlgorithm | Algorithm for applying a mask and a cropping to an image |
| CAsciiProgress | Displays a basic progress bar with ASCII characters on the console window |
| CAttachTrackingSequenceAlgorithm | Attach tracking sequence to existing tracked shared image set |
| CAverageImagesAlgorithm | Algorithm to average multiple images |
| CBakeMeshDeformationAlgorithm | Bakes an image's deformation into a mesh or point cloud |
| CBaseAlgorithmFactory | Factory for algorithms in the Base module |
| CTypedImage | Concrete implementation of a MemImage for a given pixel type |
| CBasicImageProcessing | Basic image processing such as downsample, flip, rotate or data type change |
| CBinarySerializable | Interface for class which can be serialized and deserialized |
| CBicubicBSplineApproximationAlgorithm | Algorithm that approximates the content of a SharedImageSet with a bicubic B-spline |
| CCircleHoughTransform | Hough transform for detecting circles |
| CCliqueLookupTable | Compute a clique lookup table to identify point constellations in bigger pointclouds |
| CCombineImagesAlgorithm | Algorithm to combine multiple images into a new shared image set |
| CCombineImagesAsVolumeAlgorithm | Algorithm to combine multiple images into a volume |
| CCombinePointCloudsAlgorithm | Algorithm to combine multiple pointclouds into a new pointcloud |
| CCombineSplitVolumesAlgorithm | Algorithm to combine a number of split volumes along the Z dimension |
| CConnectedComponentsAlgorithm | Algorithm to perform an analysis of the connected components |
| CContrastFilter | Contrast-enhancing filter |
| CCostFunction | Interface for a cost function that can be optimized |
| CCropLabelMapAlgorithm | Class for cropping a label map around the targets with certain label values |
| CVolumeFreeformCroppingAlgorithm | Algorithm to crop a volume using a freeform selection |
| CCompoundData | Interface for datasets that are formed by one or multiple other nested Data instances |
| CCombineIntoTrackedSharedImageSetAlgorithm | Algorithm for creating a TrackedSharedImageSet from a TrackingSequence and SharedImageSet |
| CCurve | Interpolation and fitting of a 1D curve |
| CCustomImage | Base interface for custom Image types that can be converted from/to MemImages and are supported by SharedImage |
| 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 | |
| CDataComponentBase | Data components provide a way to generically attach custom information objects |
| CDataComponent | Main specialization of DataComponentBase for regular types |
| CTemporaryDataComponent | Specialization of DataComponentBase that disables serialization, copying and assignment |
| CDataComponentFactory | Factory singleton for creating DataComponents from string IDs |
| CPersistentDataComponent | Base class for DataComponents that must never be deleted from a DataComponentList |
| CDataComponentList | Class for holding a collection of DataComponents |
| CDataComponentWithParentInterface | Interface to augment a DataComponent with a parent of type Data |
| CDataGroup | Data element that groups multiple Data instances together in a hierarchical fashion |
| CDataHashAlgorithm | Algorithm to compute a hash from image data |
| CDataLink | Interface for linking properties between multiple Data instances |
| CDataList | Container for any number of Data instances such as image or meshes |
| 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 |
| CDisplayOptions2d | Configures the display options for 2D slice rendering of images |
| CWindowLevelPreset | Window-level configuration that can be stored as a preset |
| CDisplayOptions3d | Configures the display options for 3D volume rendering of images |
| CDisplayRecorderAlgorithm | |
| CDistanceTransform | Distance transformation algorithm |
| CDistanceTransformAlgorithm | Computes a distance transformation from a label map |
| CDistanceVolumeAlgorithm | Algorithm to create a distance-volume from a mesh |
| CElementwiseDataComponentData | Class for augmenting Data classes with an ElementwiseDataComponentList |
| CElementwiseDataComponentList | Class for managing multiple DataComponentLists for individual elements |
| CErrorFunction | Interface for an error function returning one or multiple values |
| CExtractImagesFromVolumeAlgorithm | Algorithm to extract 2D images from a volume |
| 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 |
| CFFT | Fast Fourier Transform abstract base class |
| CFactoryBase | Abstract base class for all factories |
| CFactoryRegistry | Registry for object factories |
| CFiducialExtraction | Detect circles in the image patch using gradient-based (RANSAC) method |
| CFlowVisualizationAlgorithm | Creates a multi-channel image for flow visualization |
| CFpsCounter | |
| CFrameBasedPointCloud | Data structure for point clouds with frame-dependent point data |
| 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 | |
| CTensor | Data class for strongly typed dense tensors of fixed rank and data type |
| CConstAccess | Helper class for read-only access to the data content of a Tensor |
| CAccess | Helper class for read/write access to the data content of a Tensor |
| CTensorFrequencyFilteringAlgorithm | |
| CTensorLocalAverageAlgorithm | |
| CGatingMetadata | Metadata allowing to perform gating operations on periodic datasets acquired over time |
| CHistogramDataComponent | DataComponent storing information on the intensity distribution of the image they are attached to |
| CHoughTransformAlgorithm | Hough transform wrapper algorithm |
| CHuffman | Huffman code for data compression |
| CImage | Base class and interface for 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 |
| CImageResamplingAlgorithm | Algorithm for resampling an image to a target dimension or resolution, optionally with respect to another image |
| CStatistics | |
| CImageStatisticsAlgorithm | |
| CChannelStatistics | |
| 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 |
| CImFusionFileGroup | Groups for combining different data (with additional properties) within the ImFusion file format |
| CImFusionFile | Loading and saving of the ImFusion file format |
| 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 |
| CImFusionLibPlugin | Specialized interface for a plugin for the ImFusionLib |
| CImFusionPlugin | Base class for plugins that can be loaded by the ImFusion SDK |
| CIMURawMetadata | Metadata for (multiple) IMU sensor raw data |
| CIMURawSample | |
| CLiveSensorFusion | Abstract base class for 9DOF sensor fusion algorithms |
| CPureGyro | Basic sensor fusion |
| CMadgwick | Madgwick sensor fusion |
| CMahony | Mahony sensor fusion |
| CRealWorldMappingDataComponent | The RealWorldMappingDataComponent stores information about an image's real world values |
| CMapping | |
| CIoAlgorithm | Interface for describing IO algorithms |
| CKalmanFilter | Generic Kalman filter |
| CKalmanPosition | Kalman filter for position data |
| CKalmanQuaternion | Kalman filter for quaternions |
| CLabelDataComponent | DataComponent to store meta data of a label map |
| CLabelConfig | Helper struct encapsulating the metadata of a label value |
| CLabelOverlapEncoder | Helper class to encode overlapping labels into an 8bit label map |
| CLabelsOperationsAlgorithm | Algorithm to combine multiple labels set into a new shared image set |
| CLandmarksToImageAlgorithm | Algorithm to generate learning data on the position of landmarks in images |
| CLaplacianPyramid | Represents a pyramid of image details with decreasing resolution |
| CLazyInstantiatedDataComponent | Extended interface for DataComponents that support lazy instantiation / lazy retrieval |
| CLC2 | Linear correlation of linear combination (LC2) similarity measure |
| CLevenbergMarquardt | Levenberg-Marquardt optimizer |
| CMissingLicenseException | Exception thrown in case a suitable license could not be found or activated |
| CLinearRegression | Class for linear regression |
| CLinearSystemSolver | Interface for linear system solvers |
| CIterativeLinearSystemSolver | Interface for interative linear system solvers |
| CLLTFloatSolver | Solver using Cholesky decomposition of the matrix |
| CLLTEigenSolver | Solver using Cholesky decomposition of the matrix (Eigen implementation) |
| CCGSolver | Conjugate gradient solver (Eigen implementation) |
| CBiCGStabSolver | Bi-conjugate gradient solver with stabilization |
| CBiCGStabEigenSolver | Bi-conjugate gradient solver with stabilization (Eigen implementation) |
| CBiCGStabViennaCPUSolver | Bi-conjugate gradient solver with stabilization (Vienna CPU implementation) |
| CBiCGStabViennaGPUSolver | Bi-conjugate gradient solver with stabilization (Vienna GPU implementation) |
| CLineHoughTransform | |
| CLinkPose | Synchronizes the pose matrix across multiple Data instances |
| CLinkHandler | |
| CLinkItem | |
| CLinkSelection | Synchronizes the selection of multiple Selectables |
| CLinkWindowing | Synchronizes DisplayOptions2d and DisplayOptions3d of multiple images |
| CLogisticRegression | Class for logistic regression |
| CMask | Base interface for implementing polymorphic image masks on the CPU |
| CMemImage | Abstract base class for an image residing in main memory |
| 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 |
| CMeshDisplayOptions | DataComponent to store the configuration how meshes should be rendered by default (through MeshDisplayHandler) |
| CMeshToLabelMapAlgorithm | Algorithm to perform a voxelization (conversion) of a mesh to a label map |
| CMeshToPointCloudAlgorithm | Algorithm to convert a mesh to a point cloud |
| CMinimumBoundingBox | Algorithm for computing the minimum axis-aligned bounding box from image data |
| CMorpho | Morphological operations (erosion/dilation) in 2D and 3D |
| CErodeByBlock2D | |
| CDilateByBlock2D | |
| CErodeByBlock3D | |
| CDilateByBlock3D | |
| CMorphologicalOperationsAlgorithm | Algorithm for performing morphological operations on images |
| 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 | |
| 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 |
| COctreeDataComponent | DataComponent to store Octrees directly with their SharedImageSet |
| COctree | Fast Octree space subdivision |
| COpticalFlowAlgorithm | Algorithm to compute the optical flow along a sequence of images |
| COptimizationStudy | Holds optimization study results and offers methods for analyzing results |
| CRecord | Structure for a single optimization study record |
| COptimizer | Non-linear optimization |
| COptimizerDiRect | Global optimizer based on Dividing Rectangles algorithm |
| COptimizerBFGS | Implementation of the Broyden–Fletcher–Goldfarb–Shanno (BFGS) optimizer |
| CState | |
| 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) |
| COptimizerReload | Optimizer that reloads all information from a previously logged file |
| COptimizerNL | Non-linear optimization using the NLOpt library |
| COptimizerSeries | Series of multiple sucessive optimizations bundled in one execution |
| COptimizerXNES | XNES optimizer |
| COptimizerWrapper | Wrapper around Optimizer and CostFunction classes to work on simple lambda functions |
| COptimizingAlgorithm | Algorithm class supporting an optimizer |
| COwningDataList | Wrapper class to store a list of owned Data instances |
| CParameterWrapperBase | Base class for classes that wish to expose zero or more optimization parameters |
| 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 |
| CScalarParameterWrapper | Wrap a single scalar into a ParameterWrapperBase instance |
| CVectorParameterWrapper | Wrap a vector into a ParameterWrapperBase instance |
| CMatrixParameterWrapper | Wrap a matrix into a ParameterWrapperBase instance |
| CCombinedParameterWrapper | Implementation of the ParameterOptimization interface to a combination of other ParameterOptimization interface values |
| CAffineRescaledParameterOptimization | Decorator that subtracts shift, then multiplies by scale to every value before it is passed to the optimizer |
| CParseFolderAndRunWorkspaceAlgorithm | Algorithm to parse through folder structures and run a workspace on individual files |
| CPCA | |
| CPointCloud | Data structure for point clouds |
| CPointCloudData | Struct holding the underlying "heavy" data of a PointCloud object |
| CPointCloudAnalysis | Geometric analysis of a point cloud |
| CPointCorr | Container for point correspondences |
| CPointCorrespondences | Class that handles point correspondences |
| CPointCorrespondencesAlgorithm | Algorithm for managing and registering point correspondences between two Data instances |
| CPointDistanceReg | Registers a point set to a distance volume |
| CPointsOnData | Interface class for points linked to Data |
| CPointsStorageComponent | Data component for storing and managing point sets |
| CPointsOnImage | Class that hold a list of points on a volume or image |
| CPointNode | Class representing a tree point node |
| CPointTree | Data structure for trees with nodes containing a 3D point |
| CProgress | Generic interface to report operation/computation progress |
| CTask | Represents the progress/status report of an individual task hosted by a Progress |
| CPropertiesInspector | Small algorithm allowing the user to inspect a Data's properties and DataComponents |
| CRANSACPairOfVectorsDataset | |
| CRANSAC | This class implements a more generalized form of "Random Sample Consensus" algorithm |
| CResult | |
| CBestNSelector | |
| CReduceToSelection | Algorithm reducing a SharedImageSet or TrackingSequence to its selected frames/samples |
| CRegression | Abstract base class for regression |
| CRemoveUnlabelledImagesAlgorithm | Algorithm reducing an image data set and its label maps to its labelled frames |
| 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 |
| CRmseAlgorithm | Computation of Root Mean Square Error of two SharedImageSets |
| CSelectable | Interface for Data that supports having a Selection |
| CSelection | Utility class for describing a selection of elements out of a set |
| 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 |
| CRemoveModalityAlgorithm | Remove the modality flag of an image data set |
| CSetSpacingAlgorithm | Sets the spacing of an image data set |
| CRemoveSpacingAlgorithm | Remove 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 |
| CSkeletonization | Skeletonization in 2D and 3D see [Lee TC, Kashyap RL, Chu CN |
| CSlice | Represents a planar bounded slice in 3D space |
| CCorners | |
| CSpline | Uniform Catmull-Rom spline |
| CSplitChannelsAlgorithm | Splits a single multi channel image into a set of single channel images |
| CSplitImageSetAlgorithm | Algorithm to split an image set into multiple single images |
| CSplitImagesAlgorithm | Algorithm to split images into a set of subimages |
| CSquareHoughTransform | Hough transform for detecting squares |
| CSubProgress | Wrapper class to report partial progress on an existing Task |
| 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 |
| CSurfaceRegistration | Surface registration using a distance volume |
| CSyntheticDataAlgorithm | Creates synthetic data for various test scenarios |
| CTable | A 2D table with named columns, containing strings and numbers |
| CTensorBase | Abstract base class for Tensors |
| Cbool_pack | |
| CTensorFactory | Factory for creating standard type tensors up to a certain maximum rank |
| CRankFactory< TensorFactory::maxRank > | |
| CTimestampDataComponent | Data component to record both arrival and device timestamps, intended for element-wise usage |
| CTrackedImageSetImFusionFilePlugin | Plugin for loading tracked image sets via ImFusion files |
| CTrackedSharedImageSetPropertiesAlgorithm | Algorithm to change properties of one or multiple tracked SharedImageSets, or a single TrackingSequence |
| CTrackerID | Class identifying a tracker via a unique ID |
| CTrackingInstrument | Class for information of a tracking instrument |
| CTrackingInstrumentRawData | Device-dependent additional data |
| CTrackingInstrumentFiducialsData | Data component to store raw fiducial locations from optical tracking sequences |
| CTrackingSequence | Sequence of rigid tracking data with optional timestamps, quality values and flags |
| CTrackingTuple | Tuple returned by iterator, similar to std::pair used when iterating over maps |
| CTrackingSequenceIterator | Iterator class for iteration over tracking sequence data, for instance in for-each loops |
| CTrackingSequenceDisplayHandler | DataDisplayHandler for TrackingSequence Data Creates and owns an InteractiveObject comprised of GlTrackingSequence and MeshManipulator |
| CTrackingSequenceProcessing | Basic tracking sequence filtering algorithm |
| CTransformationStashDataComponent | DataComponent that stores transformations |
| CNode | Class representing a tree node |
| CTree | Data structure for trees |
| CTypedNode | Class representing a typed tree node |
| CTypedTree | Data structure for typed trees |
| CTreeFactory | Tree factory base class |
| CDefaultTreeFactory | Factory for default Tree and Node types |
| CUnrestoredDataComponents | DataComponent containing the configurations of other components that could not be restored during loading |
| CVideoFileRecorder | |
| CBackgroundVideoFileRecorder | |
| 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 |
| 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 |
| CDataLogger | Support for logging data |
| CResponse | |
| CRequest | Wrapper around libcurl for simple GET and POST requests WARNING: this is experimental and only available for the LicenseManager for the moment |
| CNearestNeighborSearch | Nearest neighbor search for points |
| COutputWrapper | Helper class for optional distance output, implicitly created from output type T. Do not use directly |
| CApplyWindowLevelAlgorithm | Clamps (in-place) the image values to the range [level-window/2; level+window/2] |
| CAttachDenseDeformationAlgorithm | Attaches a displacement field as a GlDenseDeformation |
| 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 |
| CBakeTransformationAlgorithm | Algorithm for baking in an image transformation while adjusting the size to encompass the full transformation |
| CBilateralFilterAlgorithm | Algorithm for edge-preserving image smoothening using the Bilateral filter |
| CCamera | Abstraction layer to model both intrinsic (projection) and extrinsic (view) parameters of a camera showing a 3D scene |
| CCroppingMask | Simple axis-aligned cropping mask with optional roundness |
| CCurvedViewPrimitive | Interface for curved view primitives |
| CDeformationEditor | The DeformationEditor algorithm modifiers the deformation property of a SharedImageSet |
| CDeformationFactory | Factory singleton for creating Deformations from string IDs |
| CDeformationEvent | Base class for customized deformation events |
| CDeformation | Base class for different kinds of non-linear image transformations |
| CEntryExitPointRenderer | Class for high-performance rendering of entry-exit points to be used for direct volume rendering |
| 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 |
| CGaussianFilter | Applies a symmetric Gaussian filter to an image |
| CGl3DObject | Abstract base class for 3D objects for which a center and an extent (i.e. a bounding box) can be specified |
| 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 |
| CGlAxis | Cut Line annotation |
| 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 |
| 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 |
| CGlCurvedViewCircle | Circle annotation for curved views |
| CGlCurvedViewEllipse | Ellipse annotation for curved views |
| CGlCurvedView | Curved slice view |
| COrthoSliceInfo | |
| CGlCurvedViewPolyLine | Polyline annotation for curved views |
| CGlCurvedViewSpline | Spline annotation for curved views |
| CGlCurve | Spline annotation |
| CGlCutLine | Cut Line annotation |
| CGlObjectFactory | Factory singleton for creating GlObject from string IDs |
| CGlDenseDeformation | Dense deformations based on a displacement map |
| CGlDepthDarkening | Implementation of the Depth Darkening technique for a simple screen-space ambient occlusion effect |
| CGlEdgeFilter3D | 3x3x3 Sobel edge filter for 3D images |
| CGlEdgeFilter | 3x3 Sobel edge filter for 2D images |
| CGlEllipse | Ellipse annotation |
| CGlExtractSlice | Extract slice from 3D volume |
| CFreeFormDeformation | The FreeFormDeformation provides deformations using a free-form deformation (FFD) based on B-splines |
| CGlFilterChain | Chain of two GlFilters |
| CGlFilter | Base class for filters |
| 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 |
| CGlFreeFormDeformation | Free Form Deformation |
| CGlFreeform | Freeform annotation. Draw whatever you want |
| CGlGradient | Computes the gradient of an image in pixel coordinates |
| 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 |
| 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 |
| CGlImageHighlighter | GlObject that highlights an image by drawing a colored layer on top of it |
| CGlImageParameters | Set texture parameters for the lifetime of the object and then restore old parameters |
| CGlImageRenderer | GlObject to render an image into a GlSliceView |
| CGlInfiniteLine | Line annotation |
| CGlIntensityNormalizedSmoothedGradient | Gradient relative to image intensity smoothed with a constant kernel |
| CGlJointHistogram | Provides an interface to calculate the joint histogram of an image either on the CPU or on the GPU |
| CGlLiftChartOverlay | Overlay displaying a LIFT chart |
| CGlLine | Line segment annotation |
| CGlLoop | Loop annotation |
| CGlLocalExtremalFilter | Local extremal Filter |
| CGlMask | Base interface for implementing polymorphic image masks using OpenGL |
| CGlMedianFilter | Median Filter |
| CGlMesh | Renders Mesh instances in 2D and 3D |
| CGlNoiseFilter | Filter which adds noise |
| CGlObject | Abstract base class for an renderable OpenGL object that can be hosted in a GlView |
| 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 |
| CGlCurvedViewOrthoSlice | Displays an ortho slice for a panorama curve |
| CGlOverlay | Abstract base class for OpenGL overlays |
| CGlOvershootControlFilter | Overshoot control for sharpening algorithms, as used in ADSOC |
| CGlPainter | |
| CGlParallelogram | Parallelogram annotation |
| CGlPlane | Plane Annotation |
| CGlPlotView | View for plotting data |
| CPlotInfo | Data for a single plot handle |
| CGlPointBasedAnnotation | Base class for implementing point-based annotations |
| CGlImplicitlyPlanarPointBasedAnnotation | Interface extension for point-based annotations that span an area despite consisting of only 2 points |
| CGlPointCloud | Efficient point cloud renderer |
| CGlPoint | Point annotation |
| CGlPointTree | Point tree annotation |
| CGlPolarToCartesian | Converts data from polar coordinate to Cartesian space, with constant degree between polar lines |
| CGlPolyLine | Line annotation |
| CGlPoseGraph | Pose graph annotation |
| CConstraint | |
| 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 |
| CGlMinReduction | Specialization of GlReduction performing a ReductionOperator::MIN reduction |
| CGlMaxReduction | Specialization of GlReduction performing a ReductionOperator::MAX reduction |
| CGlAverageReduction | Specialization of GlReduction performing a ReductionOperator::AVERAGE reduction |
| CGlSumReduction | Specialization of GlReduction performing a ReductionOperator::SUM reduction |
| CGlProductReduction | Specialization of GlReduction performing a ReductionOperator::PRODUCT reduction |
| 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 |
| CRenderInfo | Structure storing information on how to render a data set |
| CRenderbuffer | |
| 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 |
| CGlTexelFetch | Read single intensity values from an OpenGL texture |
| CGlText | |
| CGlTextOverlay | Renderer for displaying text as view overlay |
| 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 |
| CGlTrackingSequenceLegacy | |
| CGlTransformerObject | |
| CGlAxisTransformerObject | |
| CGlTranslationTransformer | |
| CGlInPlaneTransformer | |
| 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 |
| 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 |
| 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 |
| CGlVolumeView | OpenGL view for 3D rendering and correct compositing of direct volume rendering and classic geometry-based GlObjects |
| CRenderBufferWrapper | Helper class to allow the injection of custom render buffers surrounding the entire render pipeline |
| 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 |
| CGlXClaheFilter | XClahe filter |
| CImagePyramid | Represents a pyramid of images with decreasing resolution |
| CIntensityMask | Masks pixels with a specific value or values outside a specific range |
| CInteractiveCroppingBox | |
| CCropOffsets | Helper struct for storing the offsets of the lower and upper corner points of the box |
| CCropBox | Helper struct for storing the size and center of the box in pixel coordinates |
| CIntraOralFilter | Intra-oral filter |
| CInvertDeformationAlgorithm | Algorithm to compute the inverse of a deformation |
| CLinkPoseDeformable | Links the pose of two or more data instances if there is deformation present |
| CMaskEditor | |
| CMatchWindowingAlgorithm | Algorithm for matching window/level between two images |
| COptimizeParametricDeformationAlgorithm | |
| 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 |
| 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 |
| CRadon2D | |
| 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 |
| CRollingGuidanceFilterAlgorithm | Algorithm for Rolling Guidance Filtering |
| CSharedImage | Image shared on multiple devices |
| CRepresentation | |
| CSharedImageSet | Set of images independent of their storage location |
| CSkippingMask | Basic mask where only every N-th pixel is considered inside |
| CPointCorrespondencesVisualGuide | This class calculates visual guides to assist in identifying corresponding points between different modalities |
| CSplineSlicingAlgorithm | Creates slices orthogonal to a spline and exports them to an image set |
| CSynchronizeMemGlAlgorithm | Manually synchronize CPU and OpenGL copies of an image |
| CTrackedSharedImageSet | Set of images with arbitrarily sampled tracking data |
| CTransferFunction | Modern 1D transfer function for classification during rendering |
| 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 |
| 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) |
| CBackgroundExporter | Writing data files into disk in a background thread |
| CBackgroundFrameExporter | Writes frame data to the disk in a background thread |
| CBinaryMaskToTextAlgorithm | Algorithm for loading and exporting a binary mask from a text file |
| CCsvIoAlgorithm | IO algorithm for moving tensors to and from CSV files |
| CDefaultIoAlgorithmFactory | Factory for built-in IO algorithms |
| CFrameBasedPointCloudIoAlgorithm | Algorithm for reading and writing frame-dependent point clouds |
| CImageIoAlgorithm | Algorithm for reading and writing all supported 2D image formats |
| CImageSetIoAlgorithm | Algorithm for reading all 2D images in a directory into an image set |
| CImFusionFileIoAlgorithm | IoAlgorithm to for the ImFusionFile format |
| CInterfileIoAlgorithm | IoAlgorithm for loading and saving images stored in Interfile format |
| CMeshIoAlgorithm | Algorithm for reading and writing meshes |
| CMetaImageIoAlgorithm | Algorithm for reading and writing MetaImage files |
| CMincIO | Class for reading and writing MINC images |
| CNiftiIO | Class for reading and writing Nifti images |
| CNiftiIoAlgorithm | Algorithm for reading and writing NIFTI data |
| CNrrdIoAlgorithm | Algorithm for reading NRRD images |
| CNrrdHeader | |
| CPgmIO | |
| CPointCloudIoAlgorithm | Algorithm for reading and writing point clouds |
| CRawImageIoAlgorithm | Algorithm for reading and writing raw image data |
| CTensorIoAlgorithm | IO algorithm for moving tensors to and from binary files |
| CTrackingSequenceIO | IO class to (de)serialize TrackingSequence objects |
| CTreeIoAlgorithm | Algorithm for reading and writing trees |
| CVideoIoAlgorithm | Algorithm for reading video files as image set, and writing them |
| CUnpackVideoIoAlgorithm | Derived class for different factory name when reading |
| CVideoFileIoAlgorithm | Derived class for different factory name when writing |
| CZipIoAlgorithm | Loads data from a ZIP archive |
| CHDF5IoAlgorithm | Algorithm for reading HDF5 files |
| CJpegIO | Class for reading and writing JPEG images |
| CTiffIO | Class for reading and writing TIFF images |
| CPngIO | |
| 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 |
| CAnatomyController | Controller for AnatomyAlgorithm |
| 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 |
| CBaseAlgorithmControllerFactory | Factory for built-in algorithms |
| CBasicImageProcessingController | Controller for basic image processing tasks |
| CBoxAnnotationManipulator | Manipulator for box annotations |
| CCameraNavigation | Helper class to manipulate a 3D Camera using classic metaphors such as zoom, pan, etc |
| CCleanDecorator | |
| CCleanMeshWidget | Mesh clean widget |
| CColorDecorator | |
| CColorMeshWidget | |
| CColorSettings | |
| CConsoleController | Specialization of ApplicationController for a console application which loads data and runs algorithms |
| 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 |
| CCropDecorator | |
| CCropMeshWidget | |
| CDefaultControllerDecorator | Wrapper class to decorate Controller instances and place them in the GUI of MainWindowBase using Qt Widgets |
| CDisplayRecorderController | |
| CGated4DImageSetDisplayDataController | GUI controller for synchronizing multiple 4D datasets through gating metadata |
| CVolumeBasedMeshCurvatureController | |
| CCSVParser | Converts a CSV file into a Table, with customizable delimiters and optional headers |
| CCSVParseDialog | |
| CTrackingSequenceTableParameters | |
| CTrackingSequenceTableDialog | |
| CCurvedView | Interactive 2D view of one or multiple images |
| 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 |
| CDataController | Specialization of the Controller interface to be used with Data instances |
| CDataControllerBar | The DataControllerBar displays DataController in toolbar-mode |
| CDataDisplayHandlerFactory | Factory class to maintain the list of registered DataDisplayHandlers , |
| CDataDisplayHandler | Interface to generically show/hide Data in a GUI::View and/or query visibility |
| CDataDisplayModel | This class extends a DataItemModel with data visibility information from a DisplayWidgetMulti |
| CDataFilterModel | Proxy model to filter a DataItemModel |
| CDataGroupingModel | QAbstractProxyModel implementation that groups data in a source-model according to a specified GroupingOption |
| 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 |
| CDataMatrixTransformer | |
| 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 |
| CDefaultDataWidgetItemDelegate | Default implementation of the DataWidgetDelegate that is used for instance in the ImFusion Suite |
| CDataWidgetMenu | Context menu of the DataWidget |
| 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) |
| CDefaultDataAnnotationFactory | Factory for default data annotations |
| CDefaultIoAlgorithmControllerFactory | Factory for built-in IO algorithm controllers |
| CDeformationEditorController | Controller for the DeformationEditor algorithm |
| CDeformationWidget | Widget representing the properties of a certain deformation model |
| CDisplayOptions2dWidget | Widget to display and manipulate the per-data rendering options of a 2D view |
| CDisplayOptions3dWidget | Widget to display and manipulate the per-data rendering options of a 3D view |
| 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 |
| CInteractiveViewAdapter | Helper class providing the API of InteractiveView while wrapping around either a InteractiveView or a GUI::View |
| CImageView2DAdapter | Helper class providing the API of ImageView2D while wrapping around either a ImageView2D or a GUI::SliceView |
| CImageView3DAdapter | Helper class providing the API of ImageView3D while wrapping around either a ImageView3D or a GUI::VolumeView |
| CViewGroupAdapter | Helper class providing the API of ViewGroup while wrapping around either a ViewGroup or a GUI::RadiologyViewGroup |
| CDisplayWidgetMultiAdapter | Helper class providing the API of DisplayWidgetMulti while wrapping around either a DisplayWidgetMulti or a GUI::RadiologyDisplay |
| CExpandableGroupBoxButton | |
| CExpandableGroupBox | This class is a container widget that can expand and collapse another widget |
| CExpandableWidget | This class is a container widget that can expand and collapse another widget |
| CFilterController | GUI controller for 2D filtering with preview |
| CFreeformAnnotationManipulator | Manipulator for freeform annotations |
| CGlAlgorithmControllerFactory | Factory for built-in algorithms |
| CGlContextQt | OpenGL context using Qt as backend |
| 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 |
| CHistogramInteraction | Implements mouse interaction logic for the InteractiveHistogramOverlay |
| CImageResamplingController | Controller for image resampling |
| CImageStatisticsController | |
| CImageView2D | High-level wrapper class for 2D/MPR rendering of one or multiple images |
| CImageView3D | Qt widget for 3d rendering of one or multiple images |
| CImFusionFileIoController | Dialog for adjusting image compression settings |
| CInteraction3D | Standard 3D view interaction |
| CInteraction | Base interface class for view and overlay interactions |
| CInteractionOrthoView2D | Ortho 2D view interaction |
| CInteractionPlotView | Interaction class for plot view |
| CTouchActions | Specifies actions with one-finger and two-fingers gestures |
| CInteractionView2D | |
| CInteractionView3D | Standard 2D/3D view interaction |
| CInteractiveAnnotation | |
| CInteractiveButtonOverlay | Interactive overlay for a click-able button |
| CInteractive | Strongly typed templated version of an InteractiveObject |
| 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 |
| CInteractiveView | Abstract base class for a view that can be hosted by a DisplayWidget |
| CInteractiveViewOptionsOverlay | Button overlay for InteractiveView that allows for setting up the view or display options of the view |
| CIoController | Controller for image IO |
| CKeyboardShortcutManager | Singleton class to manage global keyboard shortcuts |
| CAction | Small structure encapsulating a shortcut action |
| CLabelDataComponentWidget | Widget to display and manipulate the per-data rendering options of a 3D view |
| CLightweightController | Interface to set a display instance on a Controller or DataController class |
| CLiftChartOverlayAlgorithm | |
| CLiftChartOverlayController | Controller with a dummy algorithm |
| CLabelResizeHandler | |
| CLinkPoseDeformableController | Default algorithm controller for LinkPoseDeformable algorithm, with a slight modification to have GlMesh access |
| CLoadRawDialog | Dialog for loading raw files, conveniently figuring out dimensions and settings |
| CLoadUnknownDialog | Dialog for opening files without specified type |
| CLogWidgetOptions | |
| CLogViewerWidget | Logging sink that manifests itself as a Qt widget showing formatted log messages and allowing for basic filtering |
| CLoopManipulator | |
| CMainWindowBase | Extends ApplicationController with additional interfaces for graphical user interfaces |
| CManipulatorListener | Interface for manipulator events |
| CManipulator | Abstract base class for manipulator objects |
| CMaskEditorController | |
| CMatrixParameterDialog | Dialog to host a MatrixParameterWidget |
| CMatrixParameterWidget | Widget containing a transformation matrix widget and a transformation stash |
| CMeshDataController | GUI controller for adjusting visualization of meshes |
| CMeshDistanceController | Controller for the MeshDistanceAlgorithm |
| CHistogram | |
| CHistogramDisplayWidget | Qt Widget for displaying and manipulating a histogram from MeshDistanceController |
| 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 |
| CMeshManipulator | Mesh manipulator with 3d controls |
| COptimizationDialog | |
| COverlayInteraction | Base class for all overlay interactions |
| CParseFolderAndRunWorkspaceAlgorithmController | Controller for the algorithm parsing folders and running a workspace on them |
| CPlotView | View for plotting data |
| CPointBasedAnnotationManipulator2 | Manipulator for point-based annotations |
| CPointBasedAnnotationManipulatorEventData | Struct passed as event data to manipulator event |
| CPointBasedAnnotationManipulator | Manipulator for point-based annotations |
| CMouseEvent | Mouse event structure |
| CInteractionModeWrapper | |
| CPointCloudAnalysisController | Controller for point cloud analysis |
| 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 |
| CPointCorrespondenceController | Controller for defining point correspondences |
| CPointCorrespondencesController | Controller for defining point correspondences |
| CPointCorrespondencesWidget | Widget that displays point correspondences in a table with buttons that allows to add and remove correspondences |
| CPointsOnDataManipulator | Interface class that handles creation and manipulation of points on Data |
| CReceiver | |
| CPointsOnImageManipulator | Class that handles creation and manipulation of points on a volume or image |
| CPopupMenuButton | Extension of a QToolButton to which you can add a drop-down menu |
| CProgressDialog | QDialog-based progress reporter that shows one QProgressBar for each progress task |
| CPerTaskUI | |
| CPropertiesListWidget | The PropertiesListWidget shows as sub-properties as a list |
| CPropertiesWidget | Widget for Properties |
| CParamControl | Base class for parameter controls |
| CLabeledParamControl | Composite control that wraps an existing ParamControl and adds a label to the left of it |
| COptionalParamControl | Composite control that wraps an existing ParamControl and adds a checkbox to the left of it |
| CStringParamControl | Represent a ParamType::String with a QLineEdit |
| CTextParamControl | Represent a ParamType::String with a QTextEdit |
| CIntegerParamControl | Represent a ParamType::Integer with a QSpinBox |
| CIntegerAdjusterParamControl | Represent a ParamType::Integer with a IntAdjusterWidget |
| CDoubleParamControl | Represent a ParamType::Double with a QDoubleSpinBox |
| CDoubleAdjusterParamControl | Represent a ParamType::Double with a DoubleAdjusterWidget |
| CBoolParamControl | Represent a ParamType::Bool with a QCheckBox |
| CEnumParamControl | Represent a ParamType::Enum and ParamType::EnumString with a QComboBox |
| CPathParamControl | Represent a ParamType::Path with a QLineEdit and a QToolButton that opens a file dialog |
| CColorPickerParamControl | Represent a ParamType::Vector with a QPushButton that displays the vector as a color and opens a QColorDialog on click |
| CMatrixParamControl | |
| CEigenMatrixParamControl | ParamControl for Eigen Types (Properties::ParamType::Matrix and Properties::ParamType::Vector) |
| CQDebugAppender | |
| CQtAuthorizationProvider | AuthorizationProvider that shows a Qt LoginDialog |
| CQtKeyCanceller | |
| CRecentFileWidget | Qt Widget to display recent files |
| CRecentFilesMenu | QtMenu that displays recent files and favourites |
| CRemoveEdgesWidget | Remove edges widget |
| CSharedImageSetDisplayHandler | Shows regular SharedImageSet instances (no derivatives) in ImageView2D and ImageView3D |
| CSectionWidget | The SectionWidget provides a way to group widgets in vertical sections |
| CSelectFileTypeDialog | Dialog for opening files without specified type |
| 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 |
| CSetModalityController | Controller for setting the modality flag of an image data instance |
| CSettingsDialog | Presents a GUI dialog to configure the global settings |
| CCustomSettingsWidget | Base class for custom settings widgets |
| CSliceManipulator | Interaction for slices |
| CSliceIndexOverlay | Renders the current slice number and total slices of the first data in the assigned view eg |
| CSmartSplineManipulator | Manipulator for smart spline annotations |
| CSmoothMeshWidget | Smooth mesh widget |
| CSplineSlicingController | Minimal controller for spline slicing algorithm. Required to get spline |
| CTableQModel | |
| CThumbnailManager | Generates and manages thumbnails for data instances |
| CTrackedSharedImageSetDisplayDataController | GUI controller for adjusting TrackedSharedImageSet visualization |
| CTrackedSharedImageSetProperties | Dialog for adjusting properties of a tracked shared image set |
| CTrackingParameters | |
| CTrackedSharedImageSetPropertiesLegacy | Dialog for adjusting properties of a tracked shared image set |
| CTrackingSequenceDisplayOptionsWidget | |
| CTransferFunctionDisplayWidget | Qt Widget for displaying an overview of a transfer function and providing basic interaction |
| CTransferFunctionWidget | Widget for setting up a transfer function |
| CTransformationModifierDialog | Shows the MatrixParameterDialog to edit a transformation matrix |
| CTransformationMatrixWidget | Widget to transform a matrix, with global/local and toWorld/fromWorld modifiers |
| CViewGroup | Non-owning container of multiple views that share and sync properties with each other |
| CViewInteraction | Base class for all view interactions |
| CActionSpeed | |
| CViewLayoutWidget | Controls to show/hide views and change the layout |
| CWindowToSelection | Utility class to handle the event loop of the window-to-selection feature |
| 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 |
| CPlottingAlgorithm | |
| CPlottingAlgorithmController | |
| CAdjusterWidgetBase | Base class for widgets providing two ways of adjusting numeric values |
| CIntAdjusterWidget | Widget combining a slider with a spin box for configuring integer values |
| CDoubleAdjusterWidget | Widget combining a slider with a spin box for configuring integer values |
| CButtonDropdownWidget | Push button and a dropdown menu together as a single widget |
| CColorButton | Specialization of a QPushButton to show and select a color |
| CColorPickerWidget | Widget combining a HsvColorPicker2d, an HsvHueSlider, and optionally an OpacitySlider to let the user pick a color |
| CHsvColorPicker2d | QWidget allowing for selecting 2 components of the HSV color space |
| CCompositeSlider | QSlider which adds the possibility of painting a background for the slider |
| CHsvHueSlider | Specialized version of a CompositeSlider that renders the HSV hue color map as background |
| COpacitySlider | Specialized version of a CompositeSlider that renders a checkerboard blended with the given color as background |
| CItemControl | ItemControl abstract interaface |
| CListModelView | Represents a QListView, and the container ItemViewWidget. The model can be accessed in ItemViewWidget::model or QListView::model |
| CTableModelView | Represents a QTableView, and the container ItemViewWidget. The model can be accessed in ItemViewWidget::model or QTableView::model |
| CItemViewWidget | Widget containing an abstract item view, reprensenting a model, as well as configurable options to edit the model |
| CLabeledSlider | This class wraps a QSlider and two QLabels |
| CRecentItemsTableWidget | This widget is a table showing a list of items recently used |
| CVec3Widget | Widget to represent a vec3 type |
| CClCommandQueue | OpenCL command queue class |
| CClContext | OpenCL context class |
| CClDevice | OpenCL device class |
| 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 |
| CClKernel | OpenCL kernel class |
| 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 |
| CClMarkovChain | OpenCL-based Viterbi algorithm |
| CCubicSplineInterpolationAlgorithm | |
| CImageMattingAlgorithm | Algorithm for image matting using guided filter |
| CMeasuring | Measure primitives from 2D and 3D volume |
| CPythonPlugin | Enables Python bindings for the ImFusionLib |
| CPythonSettings | Settings for the Python plugin |
| CActiveEnvironmentControl | A QComboBox with additional add and remove button to change the entries |
| CPythonInterpreterInterface | Interface for the embedded PythonInterpreter that prevents linking to an explicit Python version |
| CGILScopeGuard | |
| CPythonInterpreter | Starts an embedded Python interpreter and provides factories for registering algorithms from Python |
| CDicomIoAlgorithm | IoAlgorithm for reading and writing DICOM files |
| CDicomIOAlgorithmFolder | |
| CDicomIOAlgorithmFile | |
| CDicomIOAlgorithmBrowser | |
| CDicomLoader | Loads images from DICOM files |
| CRawBuffer | |
| CDicomPacsConfiguration | Structure encapsulating all information needed to connect to a PACS instance |
| CDicomPacsCommunication | Class facilitating the communication with DICOM PACS servers |
| CAsyncRequestInfo | Structure wrapping the return value of an asynchronous PACS request |
| CDicomAlgorithmFactory | |
| CDicomDataAnnotationFactory | |
| CDicomPlugin | |
| CDicomPluginSettings | Provides settings used by different parts of the DicomPlugin |
| CPacsServer | |
| CDicomWriter | Can store a SharedImageSet in a DICOM dataset |
| CLabelMapToRTStructure | Converts a LabelMap to RTStructures |
| CNuclearMedicineImageIOD | PS 3.3 A.5 Nuclear Medicine Image IOD Does not support saving yet |
| CPhilipsQLabIOD | Loads ultrasound volume stored by Philips QLab software |
| CRTStructureAnnotation | Annotation that renders a PointCloud with a RTStructureDataComponent |
| CRTStructureToLabelMap | Algorithm to convert a PointCloud with a Dicom::RTStructureDataComponent datacomponent to a labelmap |
| CDicomBrowser | The DicomBrowser is a dialog to browse and preview DICOM files |
| CDateFilterWidget | |
| CDicomBrowserFilterModel | A QSortFilterProxyModel specifically for a DicomBrowserModel |
| CDicomBrowserModel | Hierarchical model of DICOM patients |
| CDicomIoController | |
| CDicomGuiAlgorithmFactory | |
| CDicomAlgorithmControllerFactory | |
| CDicomGuiPlugin | |
| CRTStructureToLabelMapController | Controller that allows to select a reference volume for the RTStructureToLabelMap algorithm |
| CTimestampedPayload | Helper struct uses as container for the BackgroundThreadQueue data elements |
| CBackgroundThreadConsumer | Interface for BackgroundThreadQueue holders to implement |
| CBackgroundThreadQueue | Queue for thread-safe asynchronous management of some payload data as needed in most streaming classes |
| CBasicProcessingStream | Apply basic filters to the content of an incoming ImageStream |
| CCompoundStreamData | Container for StreamData from the individual Streams of a StreamGroup |
| CCreateStreamAlgorithm | Algorithm template to create streams |
| CCreateStreamIoAlgorithm | IO algorithm template to create streams |
| 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 |
| CDevice | |
| CSweepDevice | |
| COscillatingDevice | |
| CConstantDevice | |
| CImageOutStream | Image stream which is sent by an OutputConnection through network or other ports |
| 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 | |
| CStreamSharedImageSet | Wrapper around a streamed SharedImageSet |
| CImageStreamData | Image data streamed from a streaming device |
| CImageStreamRecorder | Records images from an ImageStream |
| CImageTemplateMatchingAlgorithm | Manages a list of image templates for a given ImageStream |
| CInstrumentCalibrationDataComponent | DataComponent storing calibration information for TrackingInstruments |
| CCalibration | Calibration data for a single instrument |
| CLiveStreamProcessingAlgorithm | Abstract base class for algorithms performing live stream processing without necessarily recording the data |
| COfflineStream | Stream class which supports step-by-step playback and direct access of data samples |
| 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 |
| 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 |
| CPlaybackImageStream | Image-based stream created from the playback of an image set |
| CPlaybackStreamBase | Base class for various playback streams |
| CPlaybackTrackingStream | Creates simulated live tracking by playing back the data of a TrackingSequence class |
| 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 |
| CPolyDataStreamMeshDisplayOptions | Display options for a PolyDataStream mesh |
| CPolyDataStreamPointCloudDisplayOptions | |
| CPolyDataStreamDisplayOptions | Display options for a PolyDataStream |
| CPolyDataStreamDisplayOptionsWidget | |
| CPolyDataStreamVisualizationAlgorithm | Algorithm for visualizing an incoming polydata stream |
| CSeekable | |
| 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 | |
| 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 |
| CStreamAlgorithmExecutorPayload | Work item for the StreamAlgorithmExecutor |
| CStreamAlgorithmExecutor | Generic algorithm that allows the execution of arbitrary algorithms on each image coming in through an image stream |
| CAlgorithmExecutorStream | Image stream helper class used as output of the StreamAlgorithmExecutor class |
| CStreamAlgorithmExecutorController | |
| 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 |
| CStreamForwarder | Transfers stream data from an input stream to an output stream |
| CStreamFps | Frames per second computation for a stream |
| CSubstreamBase | Non-templated base class for substreams in a StreamGroup |
| CStreamGroupBase | Non-templated base class for stream groups |
| CStreamGroup | Templated stream group class for bundling multiple streams using the CRTP pattern |
| CSubstream | Template class for creating dummy substreams fully controlled by the proxy stream |
| CTrackingSubstream | Dummy tracking substream for use in StreamGroups |
| CTrackingInstrumentComboBox | QComboBox widget for selecting TrackingInstruments from a TrackingStream |
| CStreamIoAlgorithm | Type-erased base of CreateStreamIoAlgorithm |
| CStreamAlgorithmFactory | Factory for algorithms in the stream plugin |
| CStreamAlgorithmControllerFactory | Factory for controllers for stream algorithms that are registered in the StreamAlgorithmFactory |
| CStreamDataAnnotationFactory | Factory for data annotation in the stream plugin |
| 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 |
| CSubstreamWrapper | Generic wrapper to integrate an existing Stream into a StreamGroup as a substream |
| CThreadSafeInstrumentsBase | Non-templated and fully abstract base class for ThreadSafeInstruments |
| CClonable | Interface for virtual copy construction |
| CUnusedSpecial | Placeholder struct for the extra container |
| CThreadSafeInstruments | Specialized class of ThreadSafeInstrumentsBase with the option to manage additional metadata, which is held in a struct/class Special next to the TrackingInstrument |
| CTrackingInstrumentTable | Table widget for displaying and managing TrackingInstruments from a TrackingStream |
| CTrackingOutStream | Stream of tracking data which is sent by an OutputConnection through network or other ports |
| 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 | Properties dialog for configuring calibration and registration of a TrackingStream |
| CTrackingStreamPropertiesAlgorithm | Utility algorithm to launch the TrackingStreamProperties dialog for a TrackingStream to allow interactive editing of calibration matrices, registration, and main instrument selection |
| CTrackingStreamRecorder | Records data from a TrackingStream |
| CTrackingStreamVisualizationAlgorithm | Algorithm for real-time visualization of tracking data from a TrackingStream (deprecated) |
| 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 |
| CVideoStreamFrameFormat | |
| CVideoCameraDeviceInfo | |
| CVideoCameraStreamPropertiesInspector | Specialization of PropertiesInspector for use with live camera streams |
| CVideoCameraStreamPropertiesInspectorController | Controller of the VideoCameraStreamPropertiesInspector algorithm |
| CVideoStreamIoAlgorithm | IO Algorithm for streaming videos |
| CVideoStreamIoAlgorithmHelper | |
| CSeekableStream | |
| CStreamVitalsDataController | Aggregates stream data-wise VitalsDataComponent signals and adds a vitals overlay to the 2D and 3D views |
| CVideoFileStream | Stream images from a video file |
| 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 |
| CVideoCameraStreamOpenPnp | Stream for videos This is supposed to be created by the corresponding IO algorithm |
| CLiveStreamingAlgorithm | Takes images from ImageStream (8bit images) encodes them and sends them via a web socket |
| CRemoteVideoStream | Creates image stream which receives the Image data via network connection |
| CStreamToVideoRecorder | |
| CVideoDecoder | VideoDecoder is responsible of processing the received ByteBuffer which contains the image data |
| CFrameStats | |
| CVideoEncoder | |
| 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 |
| 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 |
| CGlToolTargetOverlay | Overlay for displaying the distance and orientation of a tool with respect to a target position |
| CLiveTrackingPointRegistrationAlgorithm | Performs point-based registration between a volume and a tracked tool |
| CCorrespondence | Legacy structure representing a correspondence between volume and tracker coordinates |
| CNavigationAlgorithmFactory | Factory for algorithms in the navigation plugin |
| CNavigationAlgorithmControllerFactory | Factory for controllers for navigation algorithms that are registered in the NavigationAlgorithmFactory |
| CNavigationPlugin | Plugin for real-time navigation and visualization of tracking tools |
| CPointsOnTrackingStream | Manages a collection of points associated with a TrackingStream |
| CPointsOnTrackingStreamManipulator | Handles creation and manipulation of points from a TrackingStream |
| CSmoothedTrackingStream | Stream to smooth any TrackingStream |
| 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 |
| 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 |
| 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 |
| CMLPlugin | Plugin for algorithms from ML module |
| CCreatePixelwiseLearningStreamAlgorithm | Create a pixelwise learning stream from an existing stream |
| CAbstractImageRegistration | Interface for all image-based registrations |
| CAnalyzeMotion | Analyzes successive 2D images for various motion parameters |
| CClDeformation | |
| 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 |
| CDisplacementVisualizer | Algorithm/GlObject hybrid to display an image's displacement as a vector field in an ImageView2D |
| CPoseHistory | Class for keeping track of the poses of an image and provide undo/redo functionality |
| CDescriptorsRegistrationAlgorithm | Class for performing image registration using local feature descriptors |
| CGlobalRegistrationConfig | |
| CDescriptorsRegistrationController | |
| CFFDImageRegistration | Registers two images with a non-linear deformation based on FFDs |
| CFeatureMapsRegistrationAlgorithm | Algorithm for registering feature maps volumes |
| COptimizationParameter | Encapsulates the name and range (min, max) of a parameter |
| CFitBoundingBoxAlgorithm | Algorithm to fit an oriented bounding box |
| CGatedLinear4DImageRegistration | Registers two volume clips using a rigid/affine transformation, including a gating phase offset between the two |
| CGlDeformationGrid | The GlDeformationGrid visualizes the deformation of an image through the deformation of a grid rendered on top of the image |
| CGlPolyRigidDeformation | Poly-rigid deformation class |
| CRigidSegmentParameters | |
| CImageBasedGatingAlgorithm | Compute cardiac or respiratory gating parameters by detecting periodic structural change in the images |
| 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 | |
| CImageRegistration | High-level interface for image registration |
| CImageRegistrationController | |
| CImageSetAutoCorrelation | Compute an auto-correlation (band) matrix of an image set |
| CImageSequenceRegistration | Registers a SharedImageSet of multiple images |
| CImageTransformer | Generic way of transforming from the pixel coordinates of one image to the pixel coordinates of another image including any world transformations |
| CLabelOverlapAlgorithm | |
| CLC2Preprocessing | |
| CLinearGridRegistration | Registers a set of images arranged in a 2D grid |
| CLinearImageRegistration | Registers two images using a rigid/affine transformation |
| CMirrorRegistrationAlgorithm | Locally Estimate Mirror symmetry of a volume, and use it to estimate the mirror plane |
| CParametricDeformableRegistration | Registers two images with a non-linear deformation based on TPSs |
| CParametricImageRegistration | Base class for parametric image registration algorithms |
| CParametricImageRegistrationController | |
| CPolyRigidDeformationAlgorithm | Set up a poly-rigid deformation on a volume and multiple labels |
| CPolyRigidImageRegistration | Registers two images with a non-linear poly-rigid deformation |
| 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 |
| CResult | Represents a complete registration result, composed by multiple DataResult objects |
| CDataSource | |
| CRegistrationResultsBrowser | Shows a dialog allowing to browse RegistrationResults stored in a folder |
| CBrowserResult | |
| CRegistrationResultsAlgorithm | Store registration results for data combinations |
| CApplyRegistration | Class that allows to apply registration results on algorithm input data |
| CRegistrationResultsIoAlgorithm | Algorithm for loading ImFusion Registration Results (irr) files |
| 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 |
| CRegPlugin | Plugin for algorithms from Registration plugin |
| CSimilarityMeasureImpl | Base class of a similarity measure between two images |
| CSimilarityMeasureDotProduct | |
| CSimilarityMeasureFactory | Generic interface to any kind of SimilarityMeasure |
| CSimilarityMeasureImplHistBased | |
| CSimilarityMeasureLC2 | |
| CSimilarityMeasureLC2_CPU | |
| CSimilarityMeasureLC2_GPU | |
| CSimilarityMeasureLNCC | |
| CSimilarityMeasureLNCC_CPU | |
| CSimilarityMeasureLNCC_GL | |
| CSimilarityMeasureSSIM | |
| CSimilarityMeasureSSIM_CPU | |
| CSimilarityMeasureSSIM_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 |
| CSimilarityMeasurePatchBased_GL | Helper class for patch based similarity measures |
| CSimilarityMeasureImplPixelWise | |
| CSimilarityMeasurePixelWise_CPU | |
| CSimilarityMeasurePixelWise_GL | |
| CSimilarityMeasureSAD_CPU | |
| CSimilarityMeasureSAD_GL | |
| CSimilarityMeasureSSD_CPU | |
| CSimilarityMeasureSSD_GL | |
| CSimilarityMeasureNCC_CPU | |
| CSimilarityMeasureNCC_GL | |
| CSimilarityMeasureNGF_GL | |
| CSimilarityMeasureTester | |
| CSimilarityMeasureWrapper | Wrapper for safe and configurable use of various similarity measures |
| CTPSImageRegistration | Registers two images with a non-linear deformation based on TPSs |
| CVolumeBasedMeshRegistrationAlgorithm | Calculates a deformable registration between two meshes by calculating a deformable registration between distance volumes |
| CVolumeBasedMeshRegistrationController | |
| 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 |
| CGraphPlugin | Plugin for algorithms from Graph module |
| CGraphPluginFactory | Factory for algorithms of the Graph plugin |
| CGraphPluginControllerFactory | Factory for controllers of the Graph plugin |
| CGraphDataAnnotationFactory | |
| CGraph | Class for representing a (potentially directed) graph |
| CNodeInfo | Information stored at each node of the graph |
| CEdgeInfo | Information stored at each edge of the graph |
| CFeatureDescriptor | |
| CGlGraph | Annotation for visualizing a graph consisting of nodes and edges |
| CDisplayOptions | |
| CGeneralOptions | |
| CFeatureCircleOptions | |
| CFeatureColorMapOptions | |
| CGraphDataController | Controller for managing interactive feature-based color mapping for graphs |
| CFeatureLegend | Provides a colormap legend overlay for a graph |
| CFeatureColorMapper | Component that maps numerical feature values to RGBA colors |
| CGraphToPointCloudAlgorithm | Algorithm to convert graphs into point clouds by treating vertices as point cloud points |
| CGraphSmoothingAlgorithm | |
| CGraphReindexingAlgorithm | Algorithm to renumber nodes in a connected graph starting from a specified root using DFS traversal |
| CCombineGraphsAlgorithm | Algorithm to combine multiple graphs into a new graph |
| CComputeCommonGraphFeaturesAlgorithm | Algorithm for computing different edge features such as length, diameter, cross-section, and node degree in a graph |
| CCenterlineGraphExtractionAlgorithm | |
| CMinimumSpanningTreeAlgorithm | Algorithm to compute the Minimum Spanning Tree (MST) of an undirected cyclic graph, i.e |
| CNodeToEdgeFeatureAlgorithm | Applies a specified binary operation (e.g., difference, sum, average) to features of connected nodes and stores the computed values as edge features |
| CPartitionGraphsAlgorithm | Algorithm to partition a graph into its connected components |
| CPruneTerminalPathsAlgorithm | Algorithm to prune a graph, i.e. remove terminal paths or edged with lengths below a given threshold |
| CDrawGraphAlgorithm | Algorithm to create or edit a graph |
| CDrawGraphController | |
| CGraphManipulator | A manipulator for graphs. It expects Graph::Interaction(s) to be added |
| CInteraction | |
| CEvaluateGraphAtImageAlgorithm | |
| CGraphMLIoAlgorithm | Algorithm for loading/saving a graph to a .graphml file |
| CTransferGraphFeatureToMeshAlgorithm | Class to compute a vertex-wise color given a feature in the closest edge/node from the input centerline graph |
| CTransferGraphFeatureToMeshController | |
| CGraphToLabelMapAlgorithm | |
| CBrainVesselSegmentationAlgorithm | |
| CDoseComputationAlgorithm | Computes the dose distribution from PET/SPECT images |
| CFiducialExtractionAlgorithm | Extract spherical fiducials from data set in 2D and 3D |
| CFiducial | |
| CGlIsolineRenderer | GlObject to render a label map into a GlSliceView using isolines |
| CGlLabelRenderer | GlObject to render a label map into a GlSliceView |
| CGraphBasedSegmentation | Image segmentation in 2D or 3D using graph-based segmentation |
| CGraphLaplacianAlgorithm | Image segmentation in 2D or 3D using graph-based segmentation to solve a Laplacian problem |
| CHistogramIntensityClusteringAlgorithm | HistogramIntensityClusteringAlgorithm |
| CIntensityClusteringAlgorithm | Algorithm for intensity-based clustering using k-means |
| CGaussianCluster | Struct to represent clusters |
| CInteractiveSegmentationAlgorithm | Interactive segmentation algorithm |
| CInteractiveSegmentationController | Controller for interactive segmentation |
| CInteractiveSegmentationWatershedAlgorithm | |
| CMorphologicalInterpolationAlgorithm | Algorithm to interpolate between two label maps |
| 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 |
| CLabelMapToContoursAlgorithm | Algorithm to generate a closed contour encompassing a label map |
| CLabelMapPropagationAlgorithm | Algorithm to propagate a label map along a sequence of images |
| CLabelStatisticsAlgorithm | The LabelStatisticsAlgorithm computes image statistics depending on several label maps |
| 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 |
| CLabelingAlgorithm | Labeling algorithm |
| CLabelingController | Controller for labeling algorithm |
| CLabelingManipulator | Manipulator for circle-based annotations |
| CLabelsToNarrowBandAlgorithm | Algorithm that creates a narrow band around an object represented by a label map |
| CLineToIsosurfaceIntersectionAlgorithm | Finds the intersection between a ray and the first isosurface |
| CIntersectionCylindricalCoordinates | |
| CLineToIsosurfaceIntersectionController | Controller for the LineToIsosurfaceIntersectionAlgorithm |
| CLiverDetectionAlgorithm | Automatically segments the liver with a neural network on MR and CT datasets |
| CMakeCompatibleLabelMapAlgorithm | Algorithm to create a label map compatible with an image |
| CMarkAsLabelMapAlgorithm | Algorithm to mark any image as a Label Map |
| CMaskFluoroImageAlgorithm | Detect circle in fluoro shots |
| CSegPlugin | Plugin for algorithms from Seg module |
| CFitShapeAlgorithm | |
| CSegmentationReductionsAlgorithm | Computes basic image reductions of segmentation images, for instance vessel segmentations, including center of gravity and area |
| CSkinSegmentationAlgorithm | Segment the skin surface from a CT or MRI volume |
| CSplineLabelPainterAlgorithm | Algorithm for executing the label painter on an image guided by a spline |
| CSplineLabelPainterAlgorithmController | Controller for SplineLabelPainterAlgorithm |
| CWatershedComputer | |
| CWatershedSegmentationAlgorithm | Watershed segmentation algorithm |
| CImageMathPlugin | |
| CSharedImageArithmeticAlgorithm | ImageMath algorithm class |
| CVision | Legacy computer vision algorithms for CT |
| CAbstractFactory | |
| 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 |
| 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 |
| CCalibrationOptimizer | Interface for calibration optimizers |
| CHandEyeCalibrationAlgorithm | Performs hand-eye calibration between two tracking sequences |
| 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") |
| 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 |
| 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 |
| 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 |
| 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 |
| CSideBySideToStereoAlgorithm | This Algorithm converts a side-by-side images set to a Stereo Image Set |
| CStereoCalibrationDataComponent | A data component storing the registration matrix between the left and right camera of a stereo camera pair |
| 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 |
| CStereoSharedImageSet | This class is the main high-level container for stereo image data set |
| CStereoSharedImageSetController | Shows regular StereoSharedImageSet instances (no derivatives) in ImageView2D |
| CThresholdingFiducialExtractionController | Controller to extract fiducials from 2D IR images by thresholding and weighted average |
| CVisionDataAnnotationFactory | |
| CVisionPlugin | Plugin for Vision algorithms |
| CBlobDetector | |
| CParams | |
| CBlob | |
| CCameraCalibrationAlgorithm | Camera calibration algorithm Description: |
| CCameraCalibrationSettings | The class stores all parameters/settings for camera calibration |
| CCameraCalibrationSettingsWidget | This widget allows specifying parameters for camera calibration |
| 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 |
| CKeypoint | Structure representing a detected keypoint and its descriptor |
| CFeatureDetector | Base class for feature detection on 2D images |
| CFeatureMatch | Structure representing a match between two keypoints |
| CFeatureDetectorWithAdaptiveThreshold | Feature detection with adaptive thresholding to fill image grid with features |
| CKeyPointIterator | Iterator for traversing keypoints, optionally sorted by response |
| CFeatureSampler | Base class for feature sampling |
| CFeatureMatcher | Base class for feature matching on 2D images |
| CORBFeatureDetector | Implementation of the ORB feature detection and description algorithm |
| CORBKeyPointIterator | Iterator for ORB keypoints, supports multi-level traversal |
| CSIFTFeatureDetector | Implementation of the SIFT feature detection and description algorithm |
| CShiTomasiFeatureDetector | Implementation of the Shi-Tomasi corner detection algorithm |
| CIdentitySampler | Identity sampler, returns input keypoints unchanged |
| CNMSSampler | Non-Maximum Suppression sampler |
| CBruteForceMatcher | Brute-force matcher for feature descriptors |
| CGridBasedMatcher | Grid-based matcher for feature descriptors |
| CFeatureMatchPruner | Base class for pruning feature matches |
| CIdentityMatchPruner | Identity match pruner, returns input matches unchanged |
| CHomographyMatchPruner | Pruner using homography inlier threshold |
| CFundamentalMatrixMatchPruner | Pruner using fundamental matrix inlier threshold |
| CAutomaticMatchPruner | Automatic pruner selecting between homography and fundamental matrix based on decomposition score |
| CMatchScorePruner | Pruner based on match score and/or maximum number of matches |
| CGMSPruner | Pruner applying motion smoothness as a criterion (GMS) |
| CFeatureDetectionAlgorithm | Feature detection algorithm |
| CFeatureDetectorFactory | |
| CFeatureSamplerFactory | |
| CFeatureMatcherFactory | |
| CFeatureMatchPrunerFactory | |
| 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 |
| 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 |
| CMarkerConfiguration | Describes the configuration of a marker calibration target |
| CDetectorParameters | Detector parameters for Aruco markers, boards and Charuco boards |
| CCircleBoardDetectorParameters | Detector parameters for Circle Board markers |
| CArucoMarkerInfo | Information about a single Aruco marker |
| CArucoBoardInfo | Information about a board of Aruco markers |
| CCharucoBoardInfo | Information about a Charuco board |
| CChessboardInfo | Information about a chessboard |
| CCircleBoardInfo | Information about a circle board |
| CAprilTagInfo | Information about a single AprilTag |
| CAprilTagBoardInfo | Information about a board of AprilTags |
| 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") |
| COpticalFlow | Base class for optical flow algorithms producing flow maps (2-channel floating point images) |
| COpticalFlowFactory | |
| CStereoReconstruction | Base class for stereo reconstruction algorithms producing disparity maps |
| CStereoReconstructionFactory | |
| CStereoBlockMatchingReconstruction | Implementation of block matching stereo reconstruction It depends on block matching from OpenCV |
| CStereoSemiGlobalBlockMatchingReconstruction | Implementation of Semi Global block matching stereo reconstruction It depends on Semi Global block matching from OpenCV |
| CStereoReconstructionAlgorithm | This algorithm performs 3D reconstruction from a pair of stereo images |
| 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 |
| CGlobalICP | Global ICP point cloud alignment |
| CICP | ICP-based point cloud alignment |
| CPointCloudFilteringAlgorithm | Implements a flexible and extensible algorithm for filtering and processing point clouds |
| CPointCloudOverlapAlgorithm | Computes the geometric overlap between multiple dense, calibrated point clouds |
| CPoseGraphOptimizationAlgorithm | Pose graph optimization using motion-averaging or graph-based least squares solver |
| CMeshAlignmentAlgorithm | Algorithm for aligning meshes and point clouds |
| CMonocularDepthEstimation | Base class for monocular depth estimation algorithms producing depth maps and (optionally) also point clouds |
| CMonocularDepthEstimationFactory | |
| CMonocularDepthEstimationAlgorithm | Algorithm for estimating relative depth from a single RGB image |
| CMonocularDepthEstimationDepthAnything | |
| CMonocularDepthEstimationCustomModel | Performs depth estimation on a monocular image using a traced machine learning model provided by the user |
| COpticalFlowRAFT | |
| COpticalFlowSEARAFT | |
| COpticalFlowCustomModel | Performs optical flow estimation using a traced machine learning model provided by the user |
| 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 |
| CStereoCGIReconstruction | |
| CStereoReconstructionRAFT | |
| CStereoReconstructionCustomModel | Performs stereo reconstruction using a traced machine learning model provided by the user |
| 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 |
| CCameraCalibrationSetterAlgorithm | The algorithm loads an existing calibration onto a given image set or image stream |
| 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 |
| CGroupedStereoImageStream | GroupedStereoImageStream simultaneously owns and controls its stereo sub-streams |
| 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 |
| CSideBySideToStereoStreamAlgorithm | This class convert a stream with side-by-side image into a stereo image stream |
| CStereoCalibrationSetterAlgorithm | The algorithm loads an existing calibration onto a given stereo image set or stereo image stream |
| CStereoImageStream | Base class for streams based on stereo images |
| CStereoImageStreamDataController | Data Controller for StereoImageStream |
| CStereoImageStreamData | Stereo Image data streamed from a stereo camera |
| CInterlacedToStereoStreamAlgorithm | This class convert a stream with interlaced image into a stereo image stream Input image should have even number of lines |
| 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 |
| CLiveTrackingAlgorithm | Live tracking algorithm for image based pose detectors Use the Configurable interface for setting up the detector |
| CStereoStreamReconstructionAlgorithm | Performs real-time 3D scene reconstruction from stereo camera input |
| CStereoStreamToVideoRecorder | Records stereo image streams to two video files The algorithm internally uses VideoFileRecorder to save videos |
| CStereoStreamToVideoAlgorithm | Algorithm to record stereo image streams to video files The algorithm internally uses VideoFileRecorder to save videos |
| CMeshGroupCollisionDetection | Test for collision between two groups of meshes |
| CMeshCollisionDetectionAlgorithm | Algorithm that checks for collision between groups of meshes |
| CMeshCollisionDetectionController | |
| CImageMetadata | |
| CViewerMetadata | |
| CRegionOfInterest | |
| CDataDescriptor | |
| CTypeSpecificData | |
| CGeometricAnnotationData | |
| CPixelwiseData | |
| CRelatedData | |
| CDataSet | |
| CTypeSpecificData | |
| CGeometricAnnotationData | |
| CPixelwiseData | |
| CDatasetLicenseSystem | |
| CDatasetLicense | |
| CExperiments | |
| CExperiment | |
| CResult | |
| CImFusionLabels | |
| CUpdateChecker | |
| CImFusionLabelsPlugin | Base class for ImFusion SDK plugins that also provide functionality to ImFusion Labels |
| CLabelBgDataComponent | |
| CLabelsSettings | |
| CLabelsAuthorizationProvider | Provides authorization for the remote project as well as DICOMweb and other web resources |
| CKeycloakConfig | |
| CGeometricAnnotation | |
| CProject | |
| CSettings | |
| CSettingsUpdate | |
| CTypeSpecificData | |
| CPixelwiseLabelType | |
| CGeometricAnnotationType | |
| CPermissions | Permissions a user has regarding a project |
| CImportResult | |
| CProjectImportResult | |
| CProjectHelpers | |
| CProjectDB | |
| CProjectSortFilter | |
| CTagValue | |
| CTagType | |
| CEnumValue | |
| CTagSystem | |
| CRemovedTagInfo | |
| CTagValues | |
| CThumbnailLoader | |
| CSingleton | |
| CNiftiIODataComponent | |
| CGeometricAnnotationsAction | |
| CBrushAction | |
| CThresholdingAction | |
| CDrawContourAction | An action that allow to draw contours |
| CDefaultAction | |
| CStatsComputationResult | |
| CDefineROIAction | |
| CFrameInfoDataComponent | |
| CImportAction | Action for importing labelmaps or annotations from a file |
| CInteractiveSegAction | |
| CInteractiveDeformationAction | |
| CLabelMapPropagationAction | |
| CRelatedDataAction | |
| CDataSetPropagationAlgorithm | |
| CConnectedComponentsAction | |
| CMappingResult | |
| CEmptyAction | |
| CRefineAction | |
| CRunAlgorithmAction | |
| CReplaceValuesAction | |
| CSliceInterpolationAction | |
| CTemplateDeformationAction | |
| CUndoAction | |
| CEraseAction | |
| CMeasurementAction | |
| CAnnotationPanel | |
| CAction | |
| CAnnotationActionSharedState | |
| CUndo | |
| CBrushSettings | |
| CLabelMapSettings | |
| CLandmarkSettings | |
| CLineSettings | |
| CAnnotationAction | |
| CGalleryWidget | |
| CAnnotationView | |
| CGroupingGalleryWidget | |
| CDatabaseView | |
| CDataControllerHandler | |
| CExperimentsView | |
| CExportView | |
| CMainView | |
| CAnnotationOnlyView | |
| CSettingsDialogResult | |
| CInteraction2D | |
| CFloatingActionButton | A button floating in the left button of its parent widget |
| CCheckableImage | |
| CFlowLayout | |
| CIconInfo | |
| CPaintResultRects | Contains information about where the painter drew different elements |
| CImportGalleryPainter | |
| CDefaultGalleryPainter | |
| CLabelOverlay | |
| CImageRegistrationWidget | |
| CLabelSelector | |
| CTagsEditor | |
| CFrameSelector | |
| CBrushSettingsWidget | |
| CNotchedScrollBar | |
| CTagSelector | |
| CAutoStretchImage | |
| CTagFilterState | |
| CTagFilterDropDown | |
| CDatasetLicenseFilterState | |
| CDatasetLicenseFilter | |
| CDatasetLicenseEditor | |
| CListManipulator | |
| CTableRow | |
| CFramedWidgetWithButtons | |
| CTotalSegmentatorAction | Provides an action that can run TotalSegmentator and map the resulting labels to the project |
| 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 |
| CASCDataDisplayHandlerBase | Display handler that configures the visual representation of an AnatomicalStructureCollection element |
| CASCDataDisplayHandler | Template class that creates an ASCDataDisplayHandlerBase for a specific ASCVisualiser/AnatomicalStructureCollection pair |
| CASCDeformation | Class for representing "deformations" over an AnatomicalStructureCollection |
| CASCorrespondence | Helper struct to track correspondences between anatomical structures in two AnatomicalStructureCollections |
| CASCDisplayOptions | DataComponent to store AnatomicalStructureCollection-specific rendering options for 3D views |
| CDefaultSystemStyleSheets | These style sheets are created automatically in the constructor |
| CASCVisualiser | |
| CAnatomicalStructureDeformation | Deformation of a single AnatomicalStructure object |
| CDeformationKeys | Structure for managing collections of keys for objects that can be deformed individually |
| CAnatomicalStructurePointwiseDeformation | Class for representing nonlinear transformations on a set of points e.g |
| CAnatomicalStructureFactory | |
| CAnatomicalStructureRegistration | Interface for registering AnatomicalStructure objects to each other |
| CGlMeshOutline | |
| CAnatomicalStructureVisualiserBase | |
| CAnatomicalStructureVisualiser | Helper class for visualizing data contained in the AnatomicalStructure class |
| CAnatomiesInfo | Singleton class that holds a map of anatomies together with information related to that anatomy (such as display color, etc) |
| CAnatomyEntry | |
| 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 |
| CASCAlgorithm | |
| CKeyValueStore | Template class for storing key/value pairs |
| CEntry | |
| CASCAlgorithmController | |
| CAdditionalFeatures | |
| CASCProjectionAlgorithm | |
| CASCProjectionController | |
| CProjectedAnatomicalStructure | |
| CProjectiveObjectManager | |
| CASCRegistrationInterface | Abstract base class interface for algorithms that register two AnatomicalStructureCollection objects |
| CASCRegistration | Registration between two AnatomicalStructureCollections |
| 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 | |
| CASCIoAlgorithm | Algorithm to import/export AnatomicalStructureCollections to .imf or .zip files |
| CASImageBasedRefine | |
| CCombineASCSetAlgorithm | Algorithm to combine AnatomicalStructureCollections into an ASCSet |
| CMergeASCAlgorithm | This algorithm combines the AnatomicalStructures within multiple AnatomicalStructureCollection objects into one AnatomicalStructureCollection |
| CDefaultASCSegmentationController | Helper template for creating controllers for segmentation algorithms using AnatomicalStructureCollection |
| 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 |
| CDependentKeypoint | Represents a keypoint as linear combination of points in meshes or point clouds or other keypoints |
| CGenericAnatomicalStructure | Generic bare-bones implementation of the AnatomicalStructure interface |
| CGenericASC | Generic implementation of the AnatomicalStructureCollection interface |
| CGenericASCImFusionFilePlugin | |
| CImpliedLocalCoordinates | Helper class for storing an "image" representation of an object, and converting to/from image and world representations |
| CKeyNode | Node element used in KeyTree below |
| CKeyTree | Data structure that hierarchically organizes anatomy keys (strings) |
| CKeyValueStoreVisualizerBase | |
| CKeyValueStoreVisualiserParent | |
| CKeyValueStoreVisualiser | Helper class for managing GlObjects for every item in a KeyValueStore across a set of views |
| CSplitASCSetAlgorithm | Algorithm to split an ASCSet into AnatomicalStructureCollections |
| 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 |
| Clike_pointer | |
| Clike_pointer< std::unique_ptr< T > > | |
| Clike_pointer< std::shared_ptr< T > > | |
| Clike_pointer< T * > | |
| Cmap_arrow_proxy | |
| CBinaryOpExpr | |
| CScalingExpr | |
| CVertexExpr | |
| CMatMulExpr | |
| CMeshExpr | |
| CPointCloudExpr | |
| CEigenExpr | |
| CVectorExpr | |
| CAnatomicalStructureInvalidException | Exception thrown when an anatomical structure is invalid Thrown by python bindings |
| CAnatomicalStructureWrapper | Wrapper for anatomical structures that becomes invalid when the wrapped structure is deleted |
| CGenerateLinearShapeModel | Mean shape and linear shape model generation algorithm for anatomical structures using closed mesh representations |
| CEvaluateLinearShapeModel | |
| CEvaluateLinearShapeModelController | |
| CCranialPluginFactory | Factory for algorithms of the Abdomen plugin |
| CCranialPluginControllerFactory | Factory for controllers of the Abdomen plugin |
| CSpinePlugin | Plugin class responsible for initializing all spine related components |
| CSpineCache | |
| 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 |
| CSpinePluginFactory | Factory for the spine workflow algorithms |
| CSpineControllerFactory | Factory for the spine workflow controllers |
| CSpineDataAnnotationFactory | Factory for the spine workflow controllers |
| COrientedVertebra | A representation of a vertebra, containing orientation, classification keypoints, segmentations, meshes and all other related information |
| CSacrum | |
| CIlium | |
| CIntervertebralDisc | |
| CModelEvalLog | |
| CCropAroundVertebraeOperation | |
| CSpinePolyRigidRegistration | |
| CSimilarityResult | Computes the optimal similarity, stores the result in p_offset |
| CVertebraDissectionLegacyAlgorithm | Algorithm to dissect a vertebra segmentation into individual parts |
| CLandmark | Structure to hold landmark information of a level |
| CMostNarrowPedicleCrossSection | Most narrow part of the pedicle |
| CEndplatesPerLevel | Structure to hold endplates of a level |
| CArticularProcessesPerLevel | Structure to hold articular processes of a level |
| CVertebraDissectionLegacyController | Controller for the VertebraDissectionLegacyAlgorithm |
| CVectorDataComponent | |
| CSpineFromMultiLabelAlgorithm | |
| CSpineData | Container for set of vertebrae and other spine-related metadata The SpineData class is the main Data type of the ImFusion SpinePlugin |
| CSpineDataImFusionFilePlugin | |
| CSpineDataVisualiser | Specialization of the AnatomicalStructureCollection class for SpineData |
| CVisualSpineDataAnatomicalStructure | We override the AnatomicalStructureVisualiser class here to define special behavior for the OrientedVertebra case |
| 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 |
| CEvaluationResult | Return type of metric computation |
| CVertebraEvaluationInstance | Instance of vertebra for segmentation evaluation |
| CSpineSegmentationMetricInterface | Segmentation metrics { |
| CSpineDiceMetric | |
| CSpineSurfaceDistanceMetric | |
| CSpineBinaryMetricInterface | } |
| CSpinePrecisionMetric | |
| CSpineRecallMetric | |
| CSpineF1Metric | |
| CSegmentationInputData | } |
| CLocalizationInputData | Data for one localization evaluation instance -> one input scan + groundtruth keypoints |
| CClassificationInputData | |
| CSpineEvaluationIterator | Base class iterator for individual scans and their label/meta data Lets its subclasses handle the loading |
| CSpineAlgorithmAdapterInterface | |
| CCTSpineAlgorithmAdapter | |
| CSpineEvaluation | |
| CLogBook | |
| CSpineLocalizationEvaluation | |
| CSpineSegmentationEvaluation | |
| CSpineClassificationEvaluation | |
| CLoadSpineTemplateAlgorithm | |
| CSpinePolyRigidDeformation | Set up a poly-rigid deformation on a volume and one or two AnatomicalStructureCollection objects |
| 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 |
| CSpineMeshCurvatureAlgorithm | |
| CSpineMeshCurvatureController | |
| CSpineAlgorithmWidget | |
| CKeypointManipulator | |
| CSpine2DModelNames | Model identifiers and parameter names supported by the SpineLocalizatin2D algorithm, |
| CParamNames | |
| CAtracsysTrackingStreamBase | TrackingStream base class for all Atracsys tracking systems |
| CAtracsysSingleCameraUpdate | Helper struct for camera plus fiducials update for one particular side |
| CAtracsysUpdate | Helper struct for full tracker update (both cameras) |
| CAtracsysRenderer | |
| CAtracsysMarkersWidget | |
| CNDITrackingController | Stream algorithm controller to configure NDITrackingStreams |
| CNDITrackingStream | Base class for NDI tracking streams (Polaris/Aurora and Ascension), which share the same controller |
| CNDITrackingInstrumentInfo | NDI instrument info |
| CPolarisAuroraTrackingStream | TrackingStream wrapping the NDI Polaris/Aurora Tracking API |
| CColorMapOptimization | Provides color map optimization for textured mesh generation from RGB data |
| 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 |
| 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 |
| CMVSTexturing | Provides multi-view stereo (MVS) texturing for 3D meshes using RGB-D image sets |
| CMultiSensorCalibration | Provides functionality for external calibration of multiple RGB-D sensors using markers |
| CPointCloudPlaneFittingAlgorithm | Provides plane fitting and distance computation for point clouds |
| CPointCloudToDepthMapAlgorithm | Provides conversion of a dense point cloud to a depth map |
| 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 |
| 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 |
| CRGBDReconstructionCallback | Callback interface for RGBDReconstructionAlgorithm events |
| CRGBDReconstructionAlgorithm | Algorithm for surface reconstruction from RGB-D data streams |
| CKeyframe | Keyframe structure containing depth, color, and camera data |
| 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 |
| CRGBDFrame | Class for representing RGBD image |
| 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 |
| 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 |
| CSensorController | UI controller for configuring an RGB-D sensor stream |
| CSimulatorFrame | Container for a rendered simulator frame of the SimulatorRenderer |
| CSimulatorRenderer | Renderer for simulating RGB-D sensor output from 3D models |
| CSurfaceReconstruction | Abstract interface for surface reconstruction from RGB-D data |
| CSurfaceReconstructionDataListener | |
| CSurfaceReconstructionData | Data model for surface reconstruction |
| CSurfaceReconstructionGPU | GPU-accelerated volumetric surface reconstruction from RGB-D data |
| CTexturingAlgorithm | Algorithm for texturing 3D meshes using RGB-D image data |
| CSurfaceToVolumeRegistrationAlgorithm | Algorithm for surface scan to volume registration |
| CKinectAzureStream | Provides a high-level interface for streaming RGB-D data from Microsoft Kinect Azure sensors |
| 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 |
| CKinectAzureStreamPlaybackAlgorithm | Provides playback functionality for MKV recordings from Microsoft Kinect Azure RGB-D sensors |
| CFrameDecoder | Decoder for video frames in Kinect Azure MKV recordings |
| CCapture | Structure holding decoded frame data for a single capture |
| COpenNI2RGBDStream | Provides a stream interface for RGB-D sensors using the OpenNI2 framework |
| CRealSenseStream | Provides a stream interface for Intel RealSense RGB-D sensors |
| CRange | Structure representing a value range |
| CPropertyInfo | Structure representing information about a property configuring the sensor |
| COrbbecRGBDStream | Provides a stream interface for Orbbec RGB-D sensors (starting from Astra+) |
| CSensorConfig | Sensor configuration for multi-device synchronization |
| Nsensor_msgs | |
| CImage_ | |
| Nstd | STL namespace |
| Chash< ImFusion::Dicom::TagProxy > | |
| Chash< ImFusion::ImageMath::internal::TaggingIndex > | |
| CErrorComposition | Class to represent a stack of errors |
| CErrorException | Error that wraps any C++ exception |
| CErrorInheritanceHelper | Auxiliary type intended to implement a user defined specialization of ErrorInterface |
| 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 | |
| CSimpleErrorMessage | |
