| ►CA | |
| CC | |
| ►CD | |
| CE | |
| ►CAbstractFileReader | |
| Cmitk::NavigationDataReaderCSV | |
| Cmitk::NavigationDataReaderXML | |
| Cmitk::USDeviceReaderXML | |
| ►CAbstractFileWriter | |
| Cmitk::NavigationDataSetWriterCSV | |
| Cmitk::NavigationDataSetWriterXML | |
| Cmitk::USDeviceWriterXML | |
| CAfterdoc_Test | |
| ►Cmitk::Algorithm | |
| Cmitk::CvMatCompare | |
| Cmitk::CvMatFromVnlMatrix< T > | |
| Cmitk::CvMatFromVnlVector< T > | |
| Cmitk::EndoDebugFromXmlFile | |
| Cmitk::EndoDebugToXmlFile | |
| Cmitk::StringFromCvMat | |
| Cmitk::VnlMatrixFromCvMat< T > | |
| Cmitk::VnlVectorCaster< T, R > | |
| Cmitk::VnlVectorFixedCaster< T, R, n > | |
| Cmitk::VnlVectorFromCvMat< T > | |
| CAutolink_Test | |
| ►CB | |
| CD | |
| ►CBaseData | |
| Cmitk::NavigationDataSet | Data structure which stores streams of mitk::NavigationData for multiple tools |
| ►CBaseProperty | |
| Cmitk::CameraIntrinsicsProperty | |
| CC1 | Class C1 in group 1 |
| CC2 | Class C2 in group 1 |
| CC3 | Class C3 in group 2 |
| CC4 | Class C4 in group 2 |
| CC5 | Class C5 in the third group |
| CCoordStruct | |
| ►CctkPluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::org_mbi_gui_qt_usnavigation_Activator | |
| Cmitk::org_mitk_gui_qt_openigtlink_Activator | |
| Cmitk::org_mitk_gui_qt_ultrasound_Activator | |
| ►CDataInteractor | |
| Cmitk::USPointMarkInteractor | Simple interactor for getting just one position on mouse click |
| Cmitk::USZonesInteractor | DataInteractor for creating a sphere at a specific coordinate. The origin is set by mitk::USZonesInteractor::AddCenter() and then the radius can be updated by mitk::USZonesInteractor::ChangeRadius(). An updated sphere is rendered every time the radius changes |
| ►Citk::DataObject | |
| Cmitk::IGTLMessage | A wrapper for the OpenIGTLink message type |
| Cmitk::IGTLMessageCommon | Helper class for copying OpenIGTLink messages |
| Cmitk::NavigationData | Navigation Data |
| Cmitk::NavigationTool | An object of this class represents a navigation tool in the view of the software. A few informations like an identifier, a toolname, a surface and a itk spatial object are stored in such an object. The classes NavigationToolReader and are availiable to write/read tools to/from the harddisc. If you need a collection of navigation tools the class NavigationToolStorage could be used |
| Cmitk::USNavigationStepTimer::DurationForIndex | |
| Cmitk::EndoDebug | |
| Cmitk::EndoDebugData | |
| Cmitk::EndoDebugFromXmlFileData | |
| Cmitk::EndoDebugToXmlFileData | |
| CEnum_Test | |
| ►CExample_Test | |
| CTag | |
| ►Cmitk::Exception | |
| ►Cmitk::IGTException | An object of this class represents an exception of the MITK-IGT module |
| Cmitk::IGTHardwareException | An object of this class represents an exception of the MITK-IGT module which are releated to the hardware (e.g. connection problems, etc.) |
| Cmitk::IGTIOException | An object of this class represents an exception of the MITK-IGT module which are releated to the input/output problems (e.g. reading writing files, etc.) |
| CFn_Test | Fn_Test class |
| Cmitk::HummelProtocolEvaluation::HummelProtocolDistanceError | |
| Cmitk::HummelProtocolEvaluation | Static methods for evaluations according to the assessment protocol for EM trackers published by Hummel et al. 2005 [1] |
| Cmitk::IGTMimeTypes | |
| ►Cmitk::Image | |
| Cmitk::USImage | This specialization of mitk::Image only appends necessary Metadata to an MITK image. Otherwise it can safely be treated like it's mother class. To generate an USImage from a standard mitkImage, call the appropriate constructor USImage(image::Pointer) |
| ►Cmitk::ImageSource | |
| ►Cmitk::AbstractUltrasoundTrackerDevice | Abstract class for an easy handling of a combination of an USDevice and a NavigationDataSource. This class can be used as an ImageSource subclass. Additionally tracking data be retrieved from the NavigationDataSource returned by GetTrackingDevice() |
| Cmitk::TrackedUltrasound | Combination of USDevice and NavigationDataSource. This class can be used as an ImageSource subclass. Additionally tracking data be retrieved from the NavigationDataSource returned by GetTrackingDevice() |
| Cmitk::USCombinedModality | Combination of USDevice and NavigationDataSource. This class can be used as an ImageSource subclass. Additionally tracking data be retrieved from the NavigationDataSource returned by GetTrackingDevice() |
| Cmitk::OpenCVToMitkImageFilter | Filter for creating MITK RGB Images from an OpenCV image |
| ►Cmitk::ToFImageSource | Image source providing ToF images. Interface for filters provided in ToFProcessing module |
| Cmitk::ToFImageGrabber | Image source providing ToF images. Interface for filters provided in ToFProcessing module |
| ►Cmitk::USDevice | A device holds information about it's model, make and the connected probes. It is the common super class for all devices and acts as an image source for mitkUSImages. It is the base class for all US Devices, and every new device should extend it |
| Cmitk::USIGTLDevice | A mitk::USIGTLDevice is a USDevice to receive images over an OpenIGTLink connection. It registers an OIGTL device as a Microservice to receive image messages and transforms them to mitk::Images. It can act both as a server (listening for incoming connections) and as a client (connecting to an existing OIGTL server) |
| Cmitk::USTelemedDevice | Implementation of mitk::USDevice for Telemed API devices. Connects to a Telemed API device through its COM library interface |
| Cmitk::USVideoDevice | A mitk::USVideoDevice is the common class for video only devices. They capture video input either from a file or from a device and transform the output into an mitk::USImage with attached metadata. This simple implementation does only capture and display 2d images without registration for example |
| ►CImageToImageFilter | |
| Cmitk::ToFCompositeFilter | Applies a common filter-pipeline to the first input of this filter |
| Cmitk::ToFImageDownsamplingFilter | Reduces the resolution of a ToF distance image. Although it is meant to be used for ToF distance images, it should work for any 2D or 3D images. The dimensions (in pixels) of the desired image are taken as input parameters, and an image with these specified dimensions is created |
| Cmitk::ToFImageRecorderFilter | Filter that allows recording of processed ToF images Internally the ToFImageWriter is used for writing |
| ►Cmitk::ImageToImageFilter | |
| Cmitk::USImageLoggingFilter | |
| CInclude_Test | |
| Citk::Index< T > | |
| ►Cberry::IPerspectiveFactory | |
| CQmitkUSNavigationPerspective | Perspective for the ultrasound navigation process. This perspective displays the IGT tracking toolbox and the ultrasound support view on the left and the us navigation view on the right. The data manager is not shown by default |
| ►Cmitk::IToFDeviceFactory | This is the base of class for all ToFDeviceFactories |
| ►Cmitk::AbstractToFDeviceFactory | Virtual interface and base class for all Time-of-Flight device factories. The basic interface is in the base class: IToFDeviceFactory. This AbstractToFDeviceFactory implements some generic function which are useful for every device and not specific |
| Cmitk::KinectDeviceFactory | KinectDeviceFactory is an implementation of the factory pattern to generate Microsoft Kinect devices. KinectDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new KinectDevices via a global instance of this factory |
| Cmitk::KinectV2DeviceFactory | KinectDeviceFactory is an implementation of the factory pattern to generate Microsoft Kinect V2 devices. KinectDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new KinectDevices via a global instance of this factory |
| Cmitk::ToFCameraMESASR4000DeviceFactory | ToFCameraMESASR4000DeviceFactory is an implementation of the factory pattern to generate MESASR4000Devices. ToFCameraMESASR4000DeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new MESA SR4000 Devices via a global instance of this factory |
| Cmitk::ToFCameraMITKPlayerDeviceFactory | ToFPlayerDeviceFactory is an implementation of the factory pattern to generate ToFPlayer devices. ToFPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new ToFPlayerDevices via a global instance of this factory |
| Cmitk::ToFCameraPMDCamBoardDeviceFactory | ToFPMDCamBoardDeviceFactory is an implementation of the factory pattern to generate CamBoard devices. ToFPMDCamBoardDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new CamBoard Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDCamCubeDeviceFactory | ToFPMDCamBoardDeviceFactory is an implementation of the factory pattern to generate Cam Cube Devices. ToFPMDCamCubeDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new Cam Cube Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDO3DeviceFactory | ToFCameraPMDO3DeviceFactory is an implementation of the factory pattern to generate Do3 Devices. ToFPMDCamCubeDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new Cam Cube Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDPlayerDeviceFactory | ToFPMDPlayerDeviceFactory is an implementation of the factory pattern to generate PMD Player Devices. ToFPMDPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new PMD Player Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDRawDataCamBoardDeviceFactory | ToFPMDRawPlayerDeviceFactory is an implementation of the factory pattern to generate Raw Player Devices. ToFPMDRawPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new Raw Player Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDRawDataCamCubeDeviceFactory | ToFPMDRawPlayerDeviceFactory is an implementation of the factory pattern to generate Raw Player Devices. ToFPMDRawPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new Raw Player Devices via a global instance of this factory |
| ►CUsgfw2Lib::IUsgDeviceChangeSink | |
| Cmitk::USTelemedDevice | Implementation of mitk::USDevice for Telemed API devices. Connects to a Telemed API device through its COM library interface |
| ►CIUsgfwScanConverterPluginCB | |
| CUSTelemedScanConverterPlugin | Telemed API plugin for getting images from scan lines. Implements a COM interface whereat only the function InterimOutBufferCB is used for copying given image buffer into a mitk::Image |
| ►Cmitk::IZombieViewPart | |
| CQmitkToFUtilView | QmitkToFUtilView |
| CJavadoc_Test | |
| Cmitk::KinectController::KinectControllerPrivate | |
| Cmitk::KinectV2Controller::KinectV2ControllerPrivate | |
| ►Citk::LightObject | |
| Cmitk::KinectDeviceFactory | KinectDeviceFactory is an implementation of the factory pattern to generate Microsoft Kinect devices. KinectDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new KinectDevices via a global instance of this factory |
| Cmitk::KinectV2DeviceFactory | KinectDeviceFactory is an implementation of the factory pattern to generate Microsoft Kinect V2 devices. KinectDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new KinectDevices via a global instance of this factory |
| Cmitk::ToFCameraMESASR4000DeviceFactory | ToFCameraMESASR4000DeviceFactory is an implementation of the factory pattern to generate MESASR4000Devices. ToFCameraMESASR4000DeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new MESA SR4000 Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDCamBoardDeviceFactory | ToFPMDCamBoardDeviceFactory is an implementation of the factory pattern to generate CamBoard devices. ToFPMDCamBoardDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new CamBoard Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDCamCubeDeviceFactory | ToFPMDCamBoardDeviceFactory is an implementation of the factory pattern to generate Cam Cube Devices. ToFPMDCamCubeDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new Cam Cube Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDO3DeviceFactory | ToFCameraPMDO3DeviceFactory is an implementation of the factory pattern to generate Do3 Devices. ToFPMDCamCubeDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new Cam Cube Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDPlayerDeviceFactory | ToFPMDPlayerDeviceFactory is an implementation of the factory pattern to generate PMD Player Devices. ToFPMDPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new PMD Player Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDRawDataCamBoardDeviceFactory | ToFPMDRawPlayerDeviceFactory is an implementation of the factory pattern to generate Raw Player Devices. ToFPMDRawPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new Raw Player Devices via a global instance of this factory |
| Cmitk::ToFCameraPMDRawDataCamCubeDeviceFactory | ToFPMDRawPlayerDeviceFactory is an implementation of the factory pattern to generate Raw Player Devices. ToFPMDRawPlayerDeviceFactory inherits from AbstractToFDeviceFactory which is a MicroService interface. This offers users the oppertunity to generate new Raw Player Devices via a global instance of this factory |
| ►CLogBackendText | |
| Cmitk::USNavigationLoggingBackend | Backend for the MITK log mechanism. This backend writes all messages to the given file |
| CMemgrp_Test | |
| CMessageReceiverClass | |
| CmitkClaronTrackingDeviceHardwareTestClass | |
| CmitkCombinedModalityTestClass | |
| CmitkNavigationDataLandmarkTransformFilterTestClass | |
| CmitkNavigationDataPlayerTestClass | |
| CmitkNavigationDataSourceTestClass | |
| CmitkNavigationToolStorageTestClass | |
| CmitkNavigationToolTestClass | |
| CmitkNodeDisplacementFilterTestClass | |
| CmitkTrackingVolumeGeneratorTestClass | |
| CmitkUSDeviceTestClass | |
| CmitkUSImageVideoSourceTestClass | |
| CmitkUSPipelineTestClass | |
| CmitkUSProbeTestClass | |
| ►Cus::ModuleActivator | |
| Cmitk::IGTActivator | The load function of this class is executed every time, the module is loaded. Attention: no static variables of any class in IGT Module are initialized at this moment! |
| Cmitk::IGTLModuleActivator | Registers services for IGTL module |
| Cmitk::IGTUIActivator | The load function of this class is executed every time, the module is loaded. Attention: don't do any qt initialization during autoload. keep it as simple as possible! And be careful with static variables, they might not be initialized yet.. |
| Cmitk::IOExtActivator | |
| Cmitk::KinectActivator | This is the module activator for the "mitkKinectModule" module. It registers services like the IToFDeviceFactory |
| Cmitk::KinectV2Activator | |
| Cmitk::MESASR4000ModuleActivator | This is the module activator for the "MESASR4000Module" module. It registers services like the IToFDeviceFactory |
| Cmitk::PMDModuleActivator | This is the module activator for the "PMDModule" module. It registers services like the IToFDeviceFactory |
| Cmitk::ToFHardwareActivator | |
| Cmitk::USActivator | Module activator for the US module. Loads mitk::USVideoDevice objects from hard disk on module load and write them to hard disk on module unload |
| Cmitk::USTelemedActivator | |
| Cmitk::USUIActivator | Module activator for the USUI module. Registers custom widget for mitk::USVideoDevice as microservice |
| ►CMovieGenerator | |
| Cmitk::MovieGeneratorOpenCV | |
| Cmux_using_with | Mux entity brief description Detailed description of this mux design element |
| ►Citk::Object | |
| ►Cmitk::AbstractOpenCVImageFilter | Interface for image filters on OpenCV images |
| Cmitk::BasicCombinationOpenCVImageFilter | |
| Cmitk::ConvertGrayscaleOpenCVImageFilter | |
| Cmitk::CropOpenCVImageFilter | |
| Cmitk::GrabCutOpenCVImageFilter | Makes the OpenCV GrabCut filter available as OpenCVImageFilter |
| Cmitk::CameraIntrinsics | Class representing camera intrinsics and related functions |
| Cmitk::ClaronInterface | An object of this class represents the interface to the MicronTracker. The methods of this class are calling the c-functions which are provided by the MTC-library. If the MicronTracker is not in use, which means the CMake-variable "MITK_USE_MICRON_TRACKER" is set to OFF, this class is replaced by a stub class called "ClaronInterfaceStub" |
| ►Cmitk::IGTLDevice | Interface for all OpenIGTLink Devices |
| Cmitk::IGTLClient | Superclass for OpenIGTLink clients |
| Cmitk::IGTLServer | Superclass for OpenIGTLink server |
| Cmitk::IGTLMeasurements | Is a helper class to make measurments for latency and fps |
| Cmitk::IGTLMessageCloneHandler | Base class for clone handlers for igtl::MessageBase derived message types |
| Cmitk::IGTLMessageFactory | Factory class of supported OpenIGTLink message types |
| Cmitk::IGTLMessageQueue | Thread safe message queue to store OpenIGTLink messages |
| Cmitk::IGTTimeStamp | Time stamp in milliseconds |
| Cmitk::ImageToOpenCVImageFilter | A pseudo-filter for creating OpenCV images from MITK images with the option of copying data or referencing it |
| Cmitk::KinectController | Interface to the Kinect camera |
| Cmitk::KinectV2Controller | Interface to the Kinect 2 camera. Currently, the Microsoft SDK is used |
| ►Cmitk::NDIProtocol | The NDI Protocol class provides building and parsing of command strings and answers to and from a NDI tracking device |
| CNDIProtocolTestClass | |
| Cmitk::NavigationDataReaderInterface | |
| Cmitk::NavigationToolReader | This class offers methods to read objects of the class NavigationTool from the harddisc. The tools have to be saved in a special format by the class NavigationToolWriter to be loadable |
| Cmitk::NavigationToolStorage | An object of this class represents a collection of navigation tools. You may add/delete navigation tools or store/load the whole collection to/from the harddisc by using the class NavigationToolStorageSerializer and NavigationToolStorageDeserializer |
| Cmitk::NavigationToolStorageDeserializer | This class offers methods to load an object of the class NavigationToolStorage from the harddisc |
| Cmitk::NavigationToolStorageSerializer | This class offers methods to save an object of the class NavigationToolStorage to the harddisc |
| Cmitk::NavigationToolWriter | This class offers methods to write objects of the class navigation tool permanently to the harddisk. The objects are saved in a special fileformat which can be read by the class NavigationToolReader to restore the object |
| ►Cmitk::OpenCVImageSource | |
| ►Cmitk::OpenCVVideoSource | |
| Cmitk::VideoInputSource | |
| Cmitk::ToFOpenCVImageGrabber | TofImageGrabber class providing OpenCV images |
| Cmitk::PivotCalibration | Class for performing a pivot calibration out of a set of navigation datas |
| Cmitk::PolhemusInterface | An object of this class represents the interface to Polhemus trackers. All variables with the name "tool" start with index 1, which is the station number of Polhemus. Make sure to call functions in this class with parameter "1" if you want to loop over all tools. If you need to access an array (e.g. m_Hemisphere), you need to use "_tool -1" and adapt your index for loops.. |
| Cmitk::QuaternionAveraging | This class offers methods to average quaternions |
| ►Cmitk::RealTimeClock | RealTimeClock is a superclass to WindowsRealTimeClock, LinuxRealTimeClock, etc |
| Cmitk::LinuxRealTimeClock | RealTimeClock for linux-systems |
| Cmitk::WindowsRealTimeClock | Realtimeclock implementation for windows-systems |
| Cmitk::SerialCommunication | Serial communication interface |
| ►Cmitk::ToFCameraDevice | Virtual interface and base class for all Time-of-Flight devices |
| Cmitk::KinectDevice | Interface for all representations of Kinect devices. KinectDevice internally holds an instance of KinectController and starts a thread that continuously grabs images from the controller. A buffer structure buffers the last acquired images to provide the image data loss-less |
| Cmitk::KinectV2Device | Interface for all representations of Microsoft Kinect V2 devices. Kinect2Device internally holds an instance of Kinect2Controller and starts a thread that continuously grabs images from the controller. A buffer structure buffers the last acquired images to provide the image data loss-less |
| ►Cmitk::ToFCameraMESADevice | Interface for all representations of MESA ToF devices. ToFCameraMESADevice internally holds an instance of ToFCameraMESAController and starts a thread that continuously grabs images from the controller. A buffer structure buffers the last acquired images to provide the image data loss-less |
| Cmitk::ToFCameraMESASR4000Device | Device class representing a MESA CamBoard camera |
| ►Cmitk::ToFCameraMITKPlayerDevice | Device class representing a player for MITK-ToF images |
| Cmitk::ToFCameraMITKPlayerDeviceImpl | |
| ►Cmitk::ToFCameraPMDDevice | Interface for all representations of PMD ToF devices. ToFCameraPMDDevice internally holds an instance of ToFCameraPMDController and starts a thread that continuously grabs images from the controller. A buffer structure buffers the last acquired images to provide the image data loss-less |
| Cmitk::ToFCameraPMDCamBoardDevice | Device class representing a PMD CamBoard camera |
| Cmitk::ToFCameraPMDCamCubeDevice | Device class representing a PMD CamCube camera |
| Cmitk::ToFCameraPMDO3Device | Device class representing a PMD O3 camera |
| Cmitk::ToFCameraPMDPlayerDevice | Device class representing a player for PMD data |
| ►Cmitk::ToFCameraPMDRawDataDevice | Interface for all representations of PMD ToF devices. ToFCameraPMDDevice internally holds an instance of ToFCameraPMDController and starts a thread that continuously grabs images from the controller. A buffer structure buffers the last acquired images to provide the image data loss-less |
| ►Cmitk::ToFCameraPMDRawDataCamBoardDevice | Device class representing a PMD CamBoard camera |
| CRawDataDeviceHelperImpl | |
| Cmitk::ToFCameraPMDRawDataCamCubeDevice | Device class representing a PMD CamCube camera |
| ►Cmitk::ToFCameraMESAController | Virtual interface and base class for all MESA Time-of-Flight devices. Wraps MESA API provided in library Provides methods for accessing current distance, amplitude, intensity and raw data. Allows to set parameters like modulation frequency and integration time |
| Cmitk::ToFCameraMESASR4000Controller | Interface to the Time-of-Flight (ToF) camera MESA Swissranger 4000 |
| Cmitk::ToFCameraMITKPlayerController | Controller for playing ToF images saved in NRRD format |
| ►Cmitk::ToFCameraPMDController | Virtual interface and base class for all PMD Time-of-Flight devices. Wraps PMD API provided in PMDSDK2 Provides methods for accessing current distance, amplitude, intensity and raw data. Allows to set parameters like modulation frequency and integration time |
| Cmitk::ToFCameraPMDCamBoardController | Interface to the Time-of-Flight (ToF) camera PMD CamBoard |
| Cmitk::ToFCameraPMDCamCubeController | Interface to the Time-of-Flight (ToF) camera PMD CamCube |
| Cmitk::ToFCameraPMDControllerTest | The ToFCameraPMDControllerTest class Special class to test the abstract class ToFCameraPMDController |
| Cmitk::ToFCameraPMDO3Controller | Interface to the Time-of-Flight (ToF) camera PMD O3 Connection is established over Ethernet connection. IP address must be specified |
| Cmitk::ToFCameraPMDPlayerController | Interface to read ToF data from a PMD file |
| Cmitk::ToFDeviceFactoryManager | ToFDeviceListener |
| Cmitk::ToFImageRecorder | Recorder class for ToF images |
| ►Cmitk::ToFImageWriter | Writer class for ToF images |
| Cmitk::ToFImageCsvWriter | CSV writer class for ToF image data |
| Cmitk::ToFNrrdImageWriter | Writer class for ToF nrrd images |
| ►Cmitk::TrackingDevice | Interface for all Tracking Devices |
| CTrackingDeviceTestClass | |
| Cmitk::ClaronTrackingDevice | An object of this class represents the MicronTracker device. You can add tools to this device, then open the connection and start tracking. The tracking device will then continuously update the tool coordinates |
| Cmitk::MicroBirdTrackingDevice | Superclass for specific MIRCOBIRD tracking Devices |
| Cmitk::NDITrackingDevice | Superclass for specific NDI tracking Devices that use serial communication |
| Cmitk::OpenIGTLinkTrackingDevice | An object of this class represents the MicronTracker device. You can add tools to this device, then open the connection and start tracking. The tracking device will then continuously update the tool coordinates |
| Cmitk::OptitrackTrackingDevice | An object of this class represents the Optitrack device. You can add tools to this device, then open the connection and start tracking. The tracking device will then continuously update the tool coordinates. Remember that it will be necessary to to have a license for using the Optitrack System. See https://www.naturalpoint.com/ for details |
| Cmitk::PolhemusTrackingDevice | An object of this class represents Polhemus tracking device. You can add tools to this device, then open the connection and start tracking. The tracking device will then continuously update the tool coordinates. The tools which are used by Polhemus need to be connected to the correct port. The port of the tool is stored as m_ToolPort in PolhemusTool AND as identifier in the NavigationTool (ToolStorage) |
| Cmitk::VirtualTrackingDevice | Class representing a tracking device which generates random positions / orientations. No hardware is needed for tracking device |
| Cmitk::TrackingDeviceSourceConfigurator | This class offers a factory method for objects of the class TrackingDeviceSource. It initializes this TrackingDeviceSource with the given navigation tools and the given tracking device. The factory method also checks if all tools are valid and of the same type like the TrackingDevice. You can do this check before trying to create the TrackingDeviceSource by calling the method IsCreateTrackingDeviceSourcePossible(), if it returns false you might want to get the error message by calling the method GetErrorMessage() |
| ►Cmitk::TrackingTool | Interface for all Tracking Tools |
| ►Cmitk::ClaronTool | An object of this class represents a MicronTracker 2 tool. A tool has to be added to a tracking device which will then continuously update the tool coordinates |
| CClaronToolTestClass | |
| Cmitk::MicroBirdTool | Implementation of a MicroBird tool |
| ►Cmitk::NDIPassiveTool | Implementation of a passive NDI optical tool |
| CNDIPassiveToolTestClass | |
| Cmitk::OpenIGTLinkTrackingTool | An object of this class represents a OpenIGTLink tracking tool. A tool has to be added to a tracking device which will then continuously update the tool coordinates |
| Cmitk::OptitrackTrackingTool | An object of this class represents the a Tool tracked by Optitrack System. You can define the tool by the a definition file like in the example in ****. Remember that it will be necessary to to have a license for using the Optitrack System. See https://www.naturalpoint.com/ for details |
| Cmitk::PolhemusTool | An object of this class represents a tool of a Polhemus tracking device. A tool has to be added to a tracking device which will then continuously update the tool coordinates |
| Cmitk::VirtualTrackingTool | Implements TrackingTool interface |
| Cmitk::Transform | Class representing a transfrom in 3D |
| ►Cmitk::USAbstractControlInterface | Superclass for all ultrasound device control interfaces. Defines an interface for activating and deactivating a control interface |
| ►Cmitk::USControlInterfaceBMode | Interface defining methods for scanning mode b of ultrasound devices. It consists of methods for scanning depth, scanning gaing and scanning rejection |
| Cmitk::USTelemedBModeControls | Implementation of mitk::USControlInterfaceBMode for Telemed ultrasound devices. See documentation of mitk::USControlInterfaceBMode for a description of the interface methods |
| ►Cmitk::USControlInterfaceDoppler | Interface defining methods for scanning mode doppler of ultrasound devices. There are no methods defined, yet! At the moment, this is just an empty interface |
| Cmitk::USTelemedDopplerControls | Implementation of mitk::USControlInterfaceDoppler for Telemed ultrasound devices. See documentation of mitk::USControlInterfaceBMode for a description of the interface methods |
| ►Cmitk::USControlInterfaceProbes | Interface defining methods for probe selection of ultrasound devices. It consists of methods for getting all available probes and selecting one of them |
| Cmitk::USTelemedProbesControls | Implementation of mitk::USControlInterfaceProbes for Telemed ultrasound devices. See documentation of mitk::USControlInterfaceProbes for a description of the interface methods |
| Cmitk::USVideoDeviceCustomControls | Custom controls for mitk::USVideoDevice. Controls image cropping of the corresponding mitk::USImageVideoSource |
| Cmitk::USDevicePersistence | |
| Cmitk::USImageMetadata | This class encapsulates all necessary metadata to describe a US Image |
| ►Cmitk::USImageSource | This is an abstract superclass for delivering USImages. Each subclass must implement the method mitk::USImageSource::GetNextRawImage(). The public method mitk::USImageSource::GetNextImage() can the be used to get the next image from the image source. This image will be filtered by the filter set with mitk::USImageSource::SetImageFilter() |
| Cmitk::IGTLMessageToUSImageFilter | |
| Cmitk::USImageVideoSource | This class can be pointed to a video file or a videodevice and delivers USImages |
| Cmitk::USTelemedImageSource | Implementation of mitk::USImageSource for Telemed API devices. The method mitk::USImageSource::GetNextRawImage() is implemented for getting images from the Telemed API |
| Cmitk::USNavigationCombinedModalityPersistence | Persistence for the mitk::CombinedModality micro services. The micro services are saved into QSettings on destruction of this objects and they are loaded again when their NavigationDataSource and USDevice will become registered as a micro service |
| Cmitk::USNavigationExperimentLogging | Logs data node properties to an XML file |
| Cmitk::USNavigationStepTimer | Timer for measureing the durations of navigation steps. The different steps are identified by indices. To measure the duraion of a step it can be activated by calling SetActiveIndex(). The duration is measured until another step is activated by calling SetActiveIndex() with an other index or Stop() is called |
| Cmitk::USNavigationTargetIntersectionFilter | Calculates the intersection between a mitk::Surface and a line. Surface and line have to be set by SetTargetSurface() and SetLine. CalculateIntersection() can be called then to calculate the intersection. The results can be got afterwards by GetIsIntersecting(), GetIntersectionPoint(), GetIntersectionNearestSurfacePointId() and GetDistanceToIntersection() |
| Cmitk::USNavigationTargetUpdateFilter | Calculates a score for target placement for every vertex of a given surface. The scores are calculated for placing the targets equally on the surface. It is assumed that the surface approximates a sphere. For every vertex of the surface a score between 0 and 1 is calculated. The scores are stored in the vtkSurface as a vtkFloatArray. The name of this array can be set by calling SetScalarArrayIdentifier() |
| ►Cmitk::USProbe | Right now, the US Probe is only a fancy name for a string. Later, it could handle probe specific parameters like the current frequency etc. It is able to compare itself to other probes for device managment though |
| Cmitk::USTelemedProbe | Specialized mitk::USProbe for handling Telemed API probe objects. It encapsulates a probe object from the Telemed API |
| Cmitk::USTargetPlacementQualityCalculator | Calculates qualitiy metrics for given target positions. The calculated metrics are: |
| Cmitk::UndistortCameraImage | |
| CmitkTestOpenCVToMITKImageFilterThread | Objects of this class can start an internal thread by calling the Start() method. The thread is then updateing the tested object until the method Stop() is called. The class can be used to test if a filter is thread-save by using multiple objects and let them update simuntanously |
| ►CObject | |
| ►CVehicle | |
| CCar | |
| CTruck | |
| Citk::NonUniformBSpline< TDimension > | BSpline with nonuniform knot spacing |
| Cmitk::Observable | |
| Cmitk::OptitrackErrorMessages | |
| COverload_Test | A short description |
| CPar_Test | |
| ►CPointSetSource | |
| Cmitk::NavigationDataToPointSetFilter | This filter creates mitk::PointSet objects from mitk::NavigaitionData objects |
| Cmitk::ToFDistanceImageToPointSetFilter | Converts a Time-of-Flight (ToF) distance image to a PointSet using the pinhole camera model for coordinate computation. The intrinsic parameters of the camera (FocalLength, PrincipalPoint, InterPixelDistance) are set via SetIntrinsicParameters(). The measured distance for each pixel corresponds to the distance between the object point and the corresponding image point on the image plane. If a subset of indizes of the image is defined via SetSubset(), the output PointSet will only contain the cartesian coordinates of the corresponding 3D points |
| ►Citk::ProcessObject | |
| ►Cmitk::IGTLMessageSource | OpenIGTLink message source |
| ►Cmitk::IGTLDeviceSource | Connects a mitk::IGTLDevice to a MITK-OpenIGTLink-Message-Filter-Pipeline |
| Cmitk::IGTL2DImageDeviceSource | Connects a mitk::IGTLDevice to a MITK-OpenIGTLink-Message-Filter-Pipeline |
| Cmitk::IGTL3DImageDeviceSource | Connects a mitk::IGTLDevice to a MITK-OpenIGTLink-Message-Filter-Pipeline |
| Cmitk::IGTLMessageProvider | Provides information/objects from a MITK-Pipeline to other OpenIGTLink devices |
| Cmitk::IGTLTrackingDataDeviceSource | Connects a mitk::IGTLDevice to a MITK-OpenIGTLink-Message-Filter-Pipeline |
| Cmitk::ImageToIGTLMessageFilter | This filter creates IGTL messages from mitk::Image objects |
| Cmitk::NavigationDataToIGTLMessageFilter | This filter creates IGTL messages from mitk::NavigaitionData objects |
| Cmitk::NavigationDataRecorderDeprecated | This class records NavigationData objects |
| ►Cmitk::NavigationDataSource | Navigation Data source |
| CMyNavigationDataSourceTest | Test class that only adds a public New() method to NavigationDataSource, so that it can be tested |
| CMyNavigationDataSourceTest | Test class that only adds a public New() method to NavigationDataSource, so that it can be tested |
| Cmitk::IGTLMessageToNavigationDataFilter | IGTLinkMessageToNavigationDataFilter is a filter that receives OpenIGTLink messages as input and produce NavigationDatas as output |
| ►Cmitk::NavigationDataPlayerBase | Base class for using mitk::NavigationData as a filter source. Subclasses can play objects of mitk::NavigationDataSet |
| Cmitk::NavigationDataCSVSequentialPlayer | This class is a NavigationDataPlayer which can play CSV formatted files in sequential order, which means it doesn't care about timestamps and just outputs the navigationdatas in their sequential order |
| Cmitk::NavigationDataPlayer | This class is used to play recorded (see mitkNavigationDataRecorder class) NavigationDataSets |
| Cmitk::NavigationDataSequentialPlayer | This class is a slightly changed reimplementation of the NavigationDataPlayer which does not care about timestamps and just outputs the navigationdatas in their sequential order |
| ►Cmitk::NavigationDataToNavigationDataFilter | NavigationDataToNavigationDataFilter is the base class of all filters that receive NavigationDatas as input and produce NavigationDatas as output |
| CNavigationDataToNavigationDataFilterTestClass | Test class to be able to instantiate the normally abstract (private constructor) mitk::NavigationDataToNavigationDataFilter |
| Cmitk::CameraVisualization | CameraVisualization controls the camera according to the spatial information of the navigation data |
| Cmitk::NavigationDataDelayFilter | NavigationDataDelayFilter |
| Cmitk::NavigationDataDisplacementFilter | NavigationDataDisplacementFilter adds an offset to navigation data objects |
| ►Cmitk::NavigationDataEvaluationFilter | NavigationDataEvaluationFilter calculates statistical data (mean value, mean error, etc.) on the input navigation data. Input navigation data are set 1:1 on output navigation data |
| CNavigationDataEvaluationFilterTestClass | |
| Cmitk::NavigationDataHandEyeCalibrationFilter | IGT filter applying a Hand-Eye transformation to a given BaseData according to the current NavigationDataTransformation. The resulting BaseData is then given in tracking coordinates |
| ►Cmitk::NavigationDataLandmarkTransformFilter | NavigationDataLandmarkTransformFilter applies a itk-landmark-transformation defined by source and target pointsets |
| Cmitk::NavigationDataReferenceTransformFilter | NavigationDataReferenceTransformFilter applies a itk-landmark-transformation defined by source and target NavigationDatas |
| Cmitk::NavigationDataObjectVisualizationFilter | Class that reads NavigationData from input and transfers the information to the geometry of the associated BaseData |
| ►Cmitk::NavigationDataPassThroughFilter | Basis for filters that want to leave the navigation data untouched |
| Cmitk::FloatingImageToUltrasoundRegistrationFilter | This filter transforms a given floating image into the ultrasound coordinate system |
| Cmitk::NeedleProjectionFilter | This filter projects a needle's path onto a plane |
| Cmitk::NodeDisplacementFilter | This filter moves DataNodes relatively to tracking Data from a 6-DoF Sensor |
| Cmitk::USNavigationTargetOcclusionFilter | NavigationData filter calcuting occluded positions on a target surface. The occlusion caused by obstacle structures is calculated between the current NavigationData position and a given target surface |
| Cmitk::NavigationDataRecorder | This class records NavigationData objects into NavigationDataSets |
| Cmitk::NavigationDataSliceVisualization | Control the position and orientation of rendered slices with NavigationData |
| Cmitk::NavigationDataSmoothingFilter | This filter smoothes the navigation data by calculating the mean value of the last few input values and using this as output |
| Cmitk::NavigationDataToMessageFilter | NavigationDataToMessageFilter emits multiple mitk::Message messages when the input NavigationData values change |
| Cmitk::NavigationDataTransformFilter | NavigationDataTransformFilter applies an user-defined rigid transformation on navigation data objects. Input navigation data are mapped 1:1 on output navigation data. To run the filter SetRigid3DTransform(TransformType::Pointer transform) has to be called first |
| Cmitk::NavigationDataVisualizationFilter | NavigationDataVisualizationFilter represents the superclass of all IGT Filters that visualize NavigationData |
| Cmitk::TrackingDeviceSource | Connects a mitk::TrackingDevice to a MITK-IGT NavigationData-Filterpipeline |
| Cmitk::ThreadedToFRawDataReconstruction | |
| Cmitk::USDevice::PropertyKeys | These constants are used in conjunction with Microservices. The constants aren't defined as static member attributes to avoid the "static initialization order fiasco", which would occur when objects of this class are used in module activators (for restoring stored device, for example) |
| ►Cmitk::PropertyListReplacedObserver | |
| CQmitkOpenCVVideoControls | Offers widgets to play/pause/stop a video on a certain render window with the use of an !initialized! QmitkVideoBackground. The QmitkVideoBackground should contain an OpenCVVideoSource is then owned by this widget (and deleted) |
| Cdocstring.PyClass | |
| Cpyexample.PyClass | Documentation for a class |
| ►CQAbstractTableModel | |
| CQmitkUSNavigationCalibrationsDataModel | |
| CQmitkUSZonesDataModel | Implementation of the QAbstractTableModel for ultrasound risk zones. This class manages the data model for the QmitkUSZoneManagementWidget. It provides consistency between the table in QmitkUSZoneManagementWidget and the DataStorage |
| ►CQComboBox | |
| CQmitkComboBoxStepThrough | Extension of QComboBox which offers stepping through the values |
| ►CQDialog | |
| CQmitkInteractiveTransformationWidget | An object of this class offers an UI to create a widget to access the advanced tool creation options |
| ►CQmitkAbstractView | |
| COpenIGTLinkExample | OpenIGTLinkExample |
| COpenIGTLinkPlugin | OpenIGTLinkPlugin |
| COpenIGTLinkProviderExample | OpenIGTLinkProviderExample |
| CQmitkIGTFiducialRegistration | QmitkIGTFiducialRegistration |
| CQmitkIGTNavigationToolCalibration | IGTNavigationToolCalibration |
| CQmitkIGTTrackingDataEvaluationView | QmitkIGTTrackingDataEvaluationView |
| CQmitkIGTTrackingLabView | QmitkIGTTrackingLabView |
| CQmitkIGTTrackingSemiAutomaticMeasurementView | QmitkIGTTrackingSemiAutomaticMeasurementView |
| CQmitkIGTTutorialView | QmitkIGTTutorial shows a small typically navigation MITK view |
| CQmitkMITKIGTNavigationToolManagerView | QmitkMITKIGTNavigationToolManagerView |
| CQmitkMITKIGTTrackingToolboxView | QmitkMITKIGTTrackingToolboxView |
| CQmitkNavigationDataPlayerView | QmitkNavigationDataPlayerView |
| CQmitkOpenIGTLinkManager | OpenIGTLinkManager |
| CQmitkToFDeviceGeneration | QmitkToFDeviceGeneration |
| CQmitkToFScreenshotMaker | QmitkToFScreenshotMaker Select a ToF image source in the GUI to make a screenshot of the provided data. If a camera is active, the Make Screenshot button will become enabled. Select the data including format you want to save at the given path. To activate a camera, you can for example use the ToF Util view. Note you can only select data which is provided by the device. Screenshots will be saved at the respective path with a counter indicating the order |
| CQmitkToFTutorialView | QmitkToFTutorialView is a tutorial showing the basic implementation techniques of MITK-ToF Step 1 shows how to acquire images from a tof camera Step 2 shows how to apply a processing filter to generate a surface from a range image |
| CQmitkToFUtilView | QmitkToFUtilView |
| CQmitkUSNavigationMarkerPlacement | View for navigated marker placement using the combined modality. This view utilizes the QmitkUSNavigationProcessWidget to do the navigation process. It can be switched between widgets for marker placement and widgets for punctuation |
| CQmitkUltrasoundCalibration | QmitkUltrasoundCalibration |
| CQmitkUltrasoundSupport | UltrasoundSupport This plugin provides functionality to manage Ultrasound devices, create video devices and to view device images |
| CUSNavigation | USNavigation |
| CQmitkIGTCommonHelper | Simple and fast access to a pre-configured TrackingDeviceSource |
| CQmitkOpenCVVideoControlsPrivate | |
| ►CQObject | |
| CQmitkIGTLStreamingConnector | This class is used to stream messages from a IGTL message source into the sending queue of a message provider |
| CQmitkMITKIGTTrackingToolboxViewWorker | |
| CQmitkTrackingDeviceConfigurationWidgetConnectionWorker | |
| CQmitkTrackingDeviceConfigurationWidgetScanPortsWorker | |
| CQmitkUSNavigationPerspective | Perspective for the ultrasound navigation process. This perspective displays the IGT tracking toolbox and the ultrasound support view on the left and the us navigation view on the right. The data manager is not shown by default |
| Cmitk::PluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::PluginActivator | |
| Cmitk::org_mbi_gui_qt_usnavigation_Activator | |
| Cmitk::org_mitk_gui_qt_openigtlink_Activator | |
| Cmitk::org_mitk_gui_qt_ultrasound_Activator | |
| ►CQProgressBar | |
| CQmitkZoneProgressBar | QProgressBar for displaying distances to zones. Colors are changed according to the distance to the zone and and the progress will be filled more the smaller the distance to the zone becomes |
| ►CQPushButton | |
| CQmitkUSNavigationFreezeButton | QPushButton for freezing and unfreezing a combined modality. The button already has an icon and a text. On every successful freeze or unfreeze the signal SignalFrezzed() is emitted. One should listen to this signal rather than to the clicked() signal of the QPushButton as the combined modality may not be freezed after clicked() was emitted |
| ►CQStyledItemDelegate | |
| CQmitkNDIToolDelegate | An item delegate for rendering and editing mitk::Properties in a QTableView |
| CQmitkUSNavigationCalibrationRemoveDelegate | QStyledItemDelegate that provides a QColorDialog as editor |
| CQmitkUSNavigationCalibrationUpdateDepthDelegate | QStyledItemDelegate that changes the current depth of the ultasound image on double click |
| CQmitkUSZoneManagementColorDialogDelegate | QStyledItemDelegate that provides a QColorDialog as editor |
| CQTstyle_Test | A test class |
| ►CQWidget | |
| ►CQmitkAbstractTrackingDeviceWidget | Abstract class to configure a tracking device. Inherited widgets should be registered in the Microservice (TrackingDeviceCollectionWidget), If done so, they will be included in the QmitkTrackingDeviceConfigurationWidget of the Tracking Toolbox |
| CQmitkMicronTrackerWidget | Implementation of a configuration widget for Micron Tracking Devices |
| ►CQmitkNDIAbstractDeviceWidget | Abstract class of a configuration widget for NDI Devices. For implementations see NDIAuroraWidget or NDIPolarisWidget |
| CQmitkNDIAuroraWidget | Implementation of a configuration widget for NDI Aurora Devices |
| CQmitkNDIPolarisWidget | Implementation of a configuration widget for NDI Polaris Devices |
| CQmitkNPOptitrackWidget | Implementation of a configuration widget for NP Optitrack Tracking Devices |
| CQmitkOpenIGTLinkWidget | Implementation of a configuration widget to use an Open IGT Link connection to track any device |
| CQmitkPolhemusTrackerWidget | Implementation of a configuration widget for Polhemus Tracking Devices |
| CQmitkVirtualTrackerWidget | Implementation of a configuration widget for a Vitrual Tracking Device |
| CQmitkFiducialRegistrationWidget | IGT Fiducial Registration Widget |
| CQmitkIGTConnectionWidget | Simple and fast access to a pre-configured TrackingDeviceSource |
| CQmitkIGTLDeviceCommandWidget | An object of this class offers an UI to send OpenIGTLink commands |
| CQmitkIGTLDeviceSetupConnectionWidget | An object of this class offers an UI to setup the connection of an OpenIGTLink device |
| CQmitkIGTLDeviceSourceManagementWidget | An object of this class offers an UI to manage OpenIGTLink Device Sources and OpenIGTLink Devices |
| CQmitkIGTLDeviceSourceSelectionWidget | This widget allows the user to select a OpenIGTLink device source |
| CQmitkIGTLMessageSourceSelectionWidget | This widget allows the user to select a OpenIGTLink message source |
| CQmitkIGTLStreamingManagementWidget | An object of this class offers an UI to manage the streaming of message sources |
| CQmitkIGTLoggerWidget | GUI to access the IGT recorder. User can specify the file name where the output shall be stored and how long the recording shall be performed |
| CQmitkIGTPlayerWidget | GUI to access the IGT Player. User must specify the file name where the input xml-file is located. The NavigationDatas from the xml-file can be played in normal mode or in PointSet mode |
| CQmitkKinectParameterWidget | Widget for configuring the Kinect device |
| CQmitkNDIConfigurationWidget | |
| CQmitkNavigationDataPlayerControlWidget | |
| CQmitkNavigationDataSequentialPlayerControlWidget | |
| CQmitkNavigationDataSourceSelectionWidget | This widget allows the user to select a NavigationDataSource. Tools of this Source are also shown and the user can select one of these tools |
| CQmitkNavigationToolCreationWidget | An object of this class offers an UI to create or modify NavigationTools |
| CQmitkNavigationToolManagementWidget | An object of this class offers an UI to manage NavigationTools and NavigationToolStorages. This means a user may create, save and load single NavigationTools and/or NavigationToolStorages with this widget |
| CQmitkNavigationToolStorageSelectionWidget | This widget allows the user to select a navigation tool storage |
| CQmitkOpenCVVideoControls | Offers widgets to play/pause/stop a video on a certain render window with the use of an !initialized! QmitkVideoBackground. The QmitkVideoBackground should contain an OpenCVVideoSource is then owned by this widget (and deleted) |
| CQmitkStructureSensorParameterWidget | Widget for configuring the Structure Sensor device (Occipital, Inc.) |
| CQmitkToFCompositeFilterWidget | Widget for controlling the ToFCompositeFilter (located in module ToFProcessing) |
| CQmitkToFConnectionWidget | Widget allowing to connect to different ToF / range cameras (located in module ToFProcessing) |
| CQmitkToFMESAParameterWidget | Widget allowing to connect to different ToF / range cameras (located in module ToFProcessing) |
| CQmitkToFPMDParameterWidget | Widget allowing to connect to different ToF / range cameras (located in module ToFProcessing) |
| CQmitkToFPointSetWidget | Widget allowing interaction with point sets for measurement and PointSet definition |
| CQmitkToFRecorderWidget | Widget allowing to play / record ToF data |
| CQmitkToFSurfaceGenerationWidget | |
| CQmitkToFVisualisationSettingsWidget | |
| CQmitkToolDistanceWidget | QmitkToolDistanceWidget |
| CQmitkToolSelectionWidget | QmitkToolSelectionWidget |
| CQmitkToolTrackingStatusWidget | QmitkToolTrackingStatusWidget |
| CQmitkTrackingDeviceConfigurationWidget | An object of this class offers an UI to configurate a tracking device. If the user finished the configuration process and a fully configurated tracking device is availiabe the object emits a signal "TrackingDeviceConfigurationFinished()". You can then get the tracking device by calling the method GetTrackingDevice() |
| CQmitkTrackingDeviceWidget | |
| CQmitkTrackingSourcesCheckBoxPanelWidget | QmitkTrackingSourcesCheckBoxPanelWidget |
| ►CQmitkUSAbstractCustomWidget | Abstract superclass for all custom control widgets of mitk::USDevice classes |
| CQmitkUSControlsCustomVideoDeviceWidget | Widget for custom controls of mitk::USVideoDevice. This class handles the itk::USVideoDeviceCustomControls of video device objects |
| ►CQmitkUSAbstractNavigationStep | Abstract base class for navigation step widgets |
| CQmitkUSNavigationStepCombinedModality | Navigation step for creating and selecting a combined modality. Already created combined modalities can be selected from a service list widget and calibrations can be loaded for them. New combined modalities can be created from two service list widgets of NavigationDataSources and USDevices |
| CQmitkUSNavigationStepCtUsRegistration | Navigation step for marking risk structures. The user can add risk structures by interacting with the render windows. The risk structures are organized in an embedded table view |
| CQmitkUSNavigationStepMarkerIntervention | Navigation step for the actual marker placement |
| CQmitkUSNavigationStepPlacementPlanning | Navigation step for planning the positions for implanting markers |
| CQmitkUSNavigationStepPunctuationIntervention | Navigations step for the actual punctuation intervention. The needle path is projected onto the image plane and the distances to all risk structures are displayed in the widget |
| CQmitkUSNavigationStepTumourSelection | Navigation step for marking the tumor position and extent. The user can mark the position by interacting with the render windows. The tumor size can be changed afterwards and the tumor can be removed |
| CQmitkUSNavigationStepZoneMarking | Navigation step for marking risk structures. The user can add risk structures by interacting with the render windows. The risk structures are organized in an embedded table view |
| CQmitkUSCombinedModalityCreationWidget | Widget that enables the user to create a mitk::USCombinedModality of a mitk::NavigationDataSource and a mitk::USDevice. A mitk::NavigationDataSource and a mitk::USDevice can be picked from two lists, showing the corresponding micro service objects. The combined modality is registered as a micro service as well during the creation process |
| CQmitkUSCombinedModalityEditWidget | |
| CQmitkUSControlsBModeWidget | Widget for b mode controls of ultrasound devices. This class handles the mitk::USControlInterfaceBMode of mitk::USDevice objects |
| CQmitkUSControlsDopplerWidget | Widget for b mode controls of ultrasound devices. This class handles the mitk::USControlInterfaceDoppler of mitk::USDevice objects |
| CQmitkUSControlsProbesWidget | Widget for probes controls of ultrasound devices. This class handles the mitk::USControlInterfaceProbes of mitk::USDevice objects |
| CQmitkUSDeviceManagerWidget | This Widget is used to manage available Ultrasound Devices |
| ►CQmitkUSNavigationAbstractSettingsWidget | Abstract class of settings widgets used by the QmitkUSNavigationProcessWidget. This class handles the emitting of Saved(), Canceled() and SettingsChanged() signals and provides slots for save and cancel buttons |
| CQmitkUSNavigationCombinedSettingsWidget | Settings widget for the USNavigationMarkerPlacement. This widgets allows for configuring the experiment mode and for changing the application between marker placement and punctuation |
| CQmitkUSNavigationZoneDistancesWidget | Widget for showing distances to given zones using instances of QmitkZoneProgressBar. The zones can be added by AddZone() and removed by ClearZones(). To update the progress bars, UpdateDistancesToNeedlePosition() has to be called with a navigation data |
| CQmitkUSNewVideoDeviceWidget | This Widget enables the USer to create and connect Video Devices |
| CQmitkUSZoneManagementWidget | Shows a table of the zone nodes and allows to change properties and add and delete zone nodes |
| CQmitkUpdateTimerWidget | QmitkUpdateTimerWidget |
| Citk::SmartPointer< T > | |
| Citk::SmartPointer< DataNode > | |
| Citk::SmartPointer< itk::RealTimeClock > | |
| Citk::SmartPointer< mitk::AbstractUltrasoundTrackerDevice > | |
| Citk::SmartPointer< mitk::DataNode > | |
| Citk::SmartPointer< mitk::DataStorage > | |
| Citk::SmartPointer< mitk::FloatingImageToUltrasoundRegistrationFilter > | |
| Citk::SmartPointer< mitk::LookupTableProperty > | |
| Citk::SmartPointer< mitk::NavigationDataDelayFilter > | |
| Citk::SmartPointer< mitk::NavigationDataDisplacementFilter > | |
| Citk::SmartPointer< mitk::NavigationDataSmoothingFilter > | |
| Citk::SmartPointer< mitk::NavigationDataSource > | |
| Citk::SmartPointer< mitk::NeedleProjectionFilter > | |
| Citk::SmartPointer< mitk::NodeDisplacementFilter > | |
| Citk::SmartPointer< mitk::Surface > | |
| Citk::SmartPointer< mitk::TextAnnotation2D > | |
| Citk::SmartPointer< mitk::TextAnnotation3D > | |
| Citk::SmartPointer< mitk::USControlInterfaceBMode > | |
| Citk::SmartPointer< mitk::USNavigationStepTimer > | |
| Citk::SmartPointer< mitk::USNavigationTargetIntersectionFilter > | |
| Citk::SmartPointer< mitk::USNavigationTargetOcclusionFilter > | |
| Citk::SmartPointer< mitk::USNavigationTargetUpdateFilter > | |
| Citk::SmartPointer< mitk::USPointMarkInteractor > | |
| Citk::SmartPointer< mitk::USTargetPlacementQualityCalculator > | |
| Citk::SmartPointer< mitk::USTelemedDevice > | |
| Citk::SmartPointer< mitk::USVideoDeviceCustomControls > | |
| Citk::SmartPointer< mitk::USZonesInteractor > | |
| Citk::SmartPointer< PointSet > | |
| Citk::SmartPointer< Surface > | |
| CSomeNiceClass | Pretty nice class |
| CSourceDataStruct | |
| CString | |
| ►Cigtl::StringMessage | |
| Cmitk::IGTLDummyMessage | This class is a dummy message to show how to implement a new message type |
| ►Cmitk::SurfaceSource | |
| Cmitk::TrackingVolumeGenerator | An instance of this class represents a generator wich generates the tracking volume of a given tracking device as a mitk:Surface |
| ►CSurfaceSource | |
| Cmitk::ToFDistanceImageToSurfaceFilter | Converts a Time-of-Flight (ToF) distance image to a 3D surface using the pinhole camera model for coordinate computation. The intrinsic parameters of the camera (FocalLength, PrincipalPoint, InterPixelDistance) are set via SetCameraIntrinsics(). The measured distance for each pixel corresponds to the distance between the object point and the corresponding image point on the image plane |
| CTest< T, i > | This is a test class |
| ►CTest< void *, 200 > | |
| CTest< T * > | |
| ►Cmitk::TestFixture | |
| CmitkAbstractToFDeviceFactoryTestSuite | |
| CmitkNavigationDataObjectVisualizationFilterTestSuite | |
| CmitkNavigationDataRecorderTestSuite | |
| CmitkNavigationDataSequentialPlayerTestSuite | |
| CmitkNavigationDataSetReaderWriterCSVTestSuite | |
| CmitkNavigationDataSetReaderWriterXMLTestSuite | |
| CmitkNavigationToolStorageDeserializerTestSuite | |
| CmitkNavigationToolStorageSerializerAndDeserializerIntegrationTestSuite | |
| CmitkNavigationToolStorageSerializerTestSuite | |
| CmitkOpenCVToMitkImageFilterTestSuite | |
| CmitkOpenIGTLinkClientServerTestSuite | |
| CmitkOpenIGTLinkIGTLImageMessageFilterTestSuite | |
| CmitkOpenIGTLinkImageFactoryTestSuite | |
| CmitkOpenIGTLinkTrackingDeviceTestSuite | |
| CmitkPolhemusToolTestSuite | |
| CmitkPolhemusTrackingDeviceHardwareTestSuite | |
| CmitkToFCameraMITKPlayerDeviceFactoryTestSuite | |
| CmitkToFCameraMITKPlayerDeviceTestSuite | |
| CmitkToFImageGrabberTestSuite | Test-suite for mitkToFImageGrabber |
| CmitkToFImageRecorderTestSuite | |
| CmitkToFNrrdImageWriterTestSuite | |
| CmitkTrackingToolTestSuite | |
| CmitkUSImageLoggingFilterTestSuite | |
| CmitkVirtualTrackingDeviceTestSuite | |
| Cmitk::ThreadDataStruct | |
| Cmitk::ToFDebugHelper | |
| Cmitk::ToFProcessingCommon | Helper class providing functions which are useful for multiple usage |
| Cmitk::ToFTestingCommon | |
| Cmitk::PolhemusInterface::trackingData | |
| Cmitk::TrackingDeviceData | |
| Cmitk::TrackingDeviceTypeCollection | This class is a collection for information of all Tracking Device Types (derived from abstract TrackingDeviceTypeInformation) The Collection is avaiable via Microservice. If you want to add your own tracking device (e.g. to the Tracking Toolbox), you should register information about your tracking device in this collection using the RegisterTrackingDeviceType function |
| ►Cmitk::TrackingDeviceTypeInformation | Abstract class containing |
| Cmitk::MicronTrackerTypeInformation | Type information for Micron Tracking Devices |
| Cmitk::NDIAuroraTypeInformation | Type information for NDI Aurora |
| Cmitk::NDIPolarisTypeInformation | Type information for NDI Polaris |
| Cmitk::NPOptitrackTrackingTypeInformation | Type information for NP Optitrack |
| Cmitk::OpenIGTLinkTypeInformation | Type information for tracking devices using OpenIGTLink |
| Cmitk::PolhemusTrackerTypeInformation | Type information for Polhemus Tracking Devices |
| Cmitk::UnspecifiedTrackingTypeInformation | Type information for unspecified or invalid tracking devices. This is often used as default or for testing |
| Cmitk::VirtualTrackerTypeInformation | Type information for a virtual tracker |
| Cmitk::TrackingDeviceWidgetCollection | This class is a collection for all TrackingDeviceWidgets (derived from AbstractTrackingDeviceWidget) The Collection is avaiable via Microservice. If you want to add your own tracking device to the Tracking Toolbox, you should register your widget configuring your device to this collection using the RegisterTrackingDeviceWidget function |
| Cmitk::USDeviceReaderXML::USDeviceConfigData_ | |
| Cmitk::USDeviceReaderWriterConstants | |
| Cmitk::USDevice::USImageCropArea | |
| Cmitk::USImageVideoSource::USImageCropping | Defines a region of interest by distances to the four image borders |
| Cmitk::USImageVideoSource::USImageRoi | Defines a region of interest by top left and bottom right corner |
| ►Cmitk::USImageToUSImageFilter | |
| CTestUSFilter | |
| Cmitk::USProbe::USProbeCropping_ | Struct to define a probe specific ultrasound image cropping |
| ►CVideoSource | |
| Cmitk::OpenCVVideoSource | |
| CvtkSmartPointer< T > | |
| CvtkSmartPointer< vtkCamera > | |
| CvtkSmartPointer< vtkIdList > | |
| CvtkSmartPointer< vtkOBBTree > | |
| CvtkSmartPointer< vtkPoints > | |
| CvtkSmartPointer< vtkPolyData > | |
| CvtkSmartPointer< vtkSphereSource > | |
| ►Cmitk::XMLSerializable | Interface for all classes able to write themselves to XML files |
| Cmitk::CameraIntrinsics | Class representing camera intrinsics and related functions |
| Cmitk::Transform | Class representing a transfrom in 3D |
1.12.0