| ►CAbstractGroupMarker | |
| Cberry::GroupMarker | |
| Cberry::Separator | |
| ►Cberry::AbstractExceptionHandler | |
| Cberry::MessageExceptionHandler< R > | |
| Cberry::CommandTracing | |
| Cberry::Constants | |
| Cberry::ContributionItemFactory | |
| Cberry::ContributorFactory | |
| Cberry::DebugBreakpointManager | |
| Cberry::DebugUtil | |
| Cberry::DelegateList< D > | |
| Cberry::Display | |
| Cberry::ExpressionConverter | |
| Cberry::ExpressionInfo | |
| Cberry::ExpressionTagNames | |
| Cberry::ExtensionType | Manages named types |
| Cberry::ExtensionTypeId< T > | |
| Cberry::ExtensionTypeId2< T > | |
| Cberry::Geometry | |
| Cberry::GuiTk::IControlListener::Events | |
| Cberry::GuiTk::ISelectionListener::Events | |
| Cberry::GuiWidgetsTweaklet | |
| ►Cberry::HandleObjectManager | |
| Cberry::CommandManager | |
| Cberry::HandlerUtil | |
| ►Cberry::IAdaptable | |
| ►Cberry::IEditorInput | |
| ►Cberry::IPathEditorInput | |
| Cberry::FileEditorInput | |
| Cmitk::DataStorageEditorInput | An editor input based on a mitk::DataStorage |
| Cberry::IViewDescriptor | |
| Cberry::PlatformObject | |
| Cberry::Saveable | |
| Cberry::IAdapterFactory | |
| Cberry::IApplication | |
| Cberry::IApplicationContext | |
| Cberry::ICommandCategoryListener | |
| Cberry::ICommandCategoryListener::Events | |
| Cberry::ICommandListener | |
| Cberry::ICommandListener::Events | |
| Cberry::ICommandManagerListener | |
| Cberry::ICommandManagerListener::Events | |
| Cberry::IDebugObjectListener | |
| Cberry::IDebugObjectListener::Events | |
| ►Cberry::IDropTargetListener | |
| CQmitkDefaultDropTargetListener | |
| Cberry::IDropTargetListener::Events | |
| Cberry::IEditorRegistry | |
| Cberry::IElementFactory | |
| ►Cberry::IExecutableExtension | |
| Cberry::ExtensionFactory | |
| ►Cberry::IntroPart | |
| Cberry::QtIntroPart | |
| Cberry::RadioState | |
| Cberry::RegistryToggleState | |
| ►Cberry::WorkbenchPart | |
| ►Cberry::EditorPart | |
| ►Cberry::QtEditorPart | |
| ►CQmitkAbstractRenderEditor | A convenient base class for MITK render window BlueBerry Editors |
| ►CQmitkAbstractMultiWidgetEditor | |
| CQmitkMxNMultiWidgetEditor | |
| CQmitkStdMultiWidgetEditor | |
| ►Cberry::ViewPart | |
| ►Cberry::QtViewPart | |
| ►CQmitkAbstractView | A convenient base class for MITK related BlueBerry Views |
| CQmitkDataManagerView | A view that shows all data nodes of the data storage in a qt tree view |
| CQmitkViewNavigatorView | |
| ►Cberry::IExecutableExtensionFactory | |
| Cberry::ExtensionFactory | |
| ►Cberry::IExecutionListener | |
| Cberry::IExecutionListenerWithChecks | |
| ►Cberry::IExecutionListener::Events | |
| Cberry::IExecutionListenerWithChecks::Events | |
| Cberry::IExtensionChangeHandler | |
| Cberry::IExtensionPointFilter | |
| Cberry::IExtensionPointFilter::Concept | |
| Cberry::IExtensionRegistry | |
| ►Cberry::IExtensionTracker | |
| Cberry::ExtensionTracker | |
| ►Cberry::IHandlerListener | |
| Cberry::Command | |
| Cberry::IHandlerListener::Events | |
| Cberry::IIntroManager | |
| Cberry::IJobChangeListener | |
| Cberry::IJobChangeListener::Events | |
| Cberry::ILog | |
| Cberry::INamedHandleStateIds | |
| Cberry::Indent | |
| Cberry::internal::ExtensionTypeIdHelper< T, Defined > | |
| Cberry::internal::ExtensionTypeIdHelper< T, false > | |
| ►Cberry::IPageService | |
| Cberry::IWorkbenchWindow | |
| Cberry::IParameterTypeListener | |
| Cberry::IParameterTypeListener::Events | |
| Cberry::IParameterValueConverter | |
| Cberry::IParameterValues | |
| ►Cberry::IPartListener | |
| CQmitkAbstractMultiWidgetEditor | |
| CQmitkViewNavigatorView | |
| Cberry::IPartListener::Events | |
| ►Cberry::IPartService | |
| Cberry::IWorkbenchPage | |
| ►Cberry::IPersistable | |
| Cberry::IPersistableEditor | |
| Cberry::IPersistableElement | |
| Cberry::IPerspectiveListener | |
| Cberry::IPerspectiveListener::Events | |
| Cberry::IPerspectiveRegistry | |
| Cberry::IPresentationFactory | |
| Cberry::IPresentationSerializer | |
| Cberry::IProductProvider | |
| ►Cberry::IPropertyChangeListener | |
| Cberry::PropertyChangeAdapter< R > | |
| Cberry::PropertyChangeIntAdapter< R > | |
| Cberry::IPropertyChangeListener::Events | |
| ►Cberry::IQtStyleManager | |
| Cberry::QtStyleManager | |
| Cberry::IQtStyleManager::Style | |
| Cberry::IRegistryEventListener | |
| Cberry::IRegistryEventListener::Events | |
| Cberry::ISaveablesLifecycleListener::Events | |
| Cberry::ISelectionChangedListener | |
| Cberry::ISelectionChangedListener::Events | |
| ►Cberry::ISelectionListener | |
| ►Cberry::INullSelectionListener | |
| Cberry::NullSelectionChangedAdapter< R > | |
| Cberry::SelectionChangedAdapter< R > | |
| Cberry::ISelectionListener::Events | |
| ►Cberry::ISelectionService | |
| Cberry::IWorkbenchPage | |
| Cberry::ISelectionService::SelectionEvents | |
| Cberry::IServiceFactory | |
| Cberry::IServiceScopes | |
| Cberry::IShellListener | |
| Cberry::IShellListener::Events | |
| ►Cberry::ISizeProvider | |
| Cberry::IPresentablePart | |
| Cberry::StackPresentation | |
| Cberry::ISourceProviderListener | |
| Cberry::ISourceProviderListener::Events | |
| Cberry::ISources | |
| ►Cberry::IStateListener | |
| Cberry::AbstractHandlerWithState | |
| Cberry::IStateListener::Events | |
| Cberry::IVariableResolver | |
| Cberry::IViewRegistry | |
| Cberry::IWindowListener | |
| Cberry::IWindowListener::Events | |
| ►Cberry::IWorkbenchCommandConstants | |
| Cmitk::WorkbenchCommandConstants | |
| Cberry::IWorkbenchListener | |
| Cberry::IWorkbenchListener::Events | |
| Cberry::IWorkbenchPartConstants | |
| Cberry::ListenerList< T, C > | |
| Cberry::ListenerListEquals | |
| Cberry::MenuUtil | |
| Cberry::Message< A > | Event/message/notification class |
| Cberry::Message1< T, A > | |
| Cberry::Message2< T, U, A > | |
| Cberry::Message3< T, U, V, A > | |
| Cberry::Message4< T, U, V, W, A > | |
| Cberry::MessageAbstractDelegate< A > | |
| Cberry::MessageAbstractDelegate1< T, A > | |
| Cberry::MessageAbstractDelegate2< T, U, A > | |
| Cberry::MessageAbstractDelegate3< T, U, V, A > | |
| Cberry::MessageAbstractDelegate4< T, U, V, W, A > | |
| Cberry::NonDerivable | |
| ►Cberry::Object | Light weight base class for most BlueBerry classes |
| ►Cberry::AbstractBitSetEvent | |
| ►Cberry::AbstractHandleObjectEvent | |
| ►Cberry::AbstractNamedHandleEvent | |
| Cberry::CommandCategoryEvent | |
| Cberry::CommandEvent | |
| Cberry::ParameterTypeEvent | |
| Cberry::HandlerEvent | |
| Cberry::AbstractContributionFactory | |
| ►Cberry::ActionBarAdvisor | |
| CQmitkExtActionBarAdvisor | |
| CQmitkExtWorkbenchActionBuilder | |
| Cberry::CommandContributionItemParameter | |
| Cberry::CommandManagerEvent | |
| Cberry::ElementHandler | |
| Cberry::EvaluationResult | |
| Cberry::ExecutionEvent | |
| ►Cberry::Expression | |
| Cberry::FALSE_EVALExpression | |
| Cberry::TRUE_EVALExpression | |
| ►Cberry::GuiTk::Event | |
| Cberry::GuiTk::ControlEvent | |
| Cberry::GuiTk::SelectionEvent | |
| ►Cberry::GuiTk::IControlListener | |
| Cberry::GuiTk::ControlActivatedAdapter< R > | |
| Cberry::GuiTk::ControlDestroyedAdapter< R > | |
| Cberry::GuiTk::ControlMovedAdapter< R > | |
| Cberry::GuiTk::ControlResizedAdapter< R > | |
| Cberry::GuiTk::ISelectionListener | |
| ►Cberry::HandleObject | |
| ►Cberry::NamedHandleObject | |
| Cberry::CommandCategory | |
| ►Cberry::NamedHandleObjectWithState | |
| Cberry::Command | |
| Cberry::ParameterType | |
| Cberry::IActionBarConfigurer | |
| Cberry::IActionBars | |
| Cberry::IAdapterManager | |
| Cberry::IConfigurationElement | |
| ►Cberry::IContributionItem | |
| ►Cberry::ContributionItem | |
| Cberry::CommandContributionItem | |
| Cberry::QActionContributionItem | |
| ►Cberry::IMenuManager | |
| Cberry::MenuManager | |
| Cberry::SubContributionItem | |
| ►Cberry::IContributionManager | |
| ►Cberry::ContributionManager | |
| Cberry::MenuManager | |
| Cberry::IMenuManager | |
| Cberry::IContributionManagerOverrides | |
| Cberry::IContributionRoot | |
| Cberry::IContributor | |
| Cberry::ICountable | |
| ►Cberry::IDisposable | |
| Cberry::ICommandImageService | |
| Cberry::ICommandService | |
| ►Cberry::IServiceWithSources | |
| Cberry::IContextService | |
| Cberry::IEvaluationService | |
| Cberry::IHandlerService | |
| Cberry::IMenuService | |
| Cberry::IEditorInput | |
| Cberry::IEditorMatchingStrategy | |
| Cberry::IElementReference | |
| Cberry::IElementUpdater | |
| ►Cberry::IEvaluationContext | |
| Cberry::EvaluationContext | |
| Cberry::IExtension | |
| Cberry::IExtensionPoint | |
| Cberry::IFileEditorMapping | |
| ►Cberry::IHandler | |
| ►Cberry::AbstractHandler | |
| Cberry::AbstractHandlerWithState | |
| ►Cberry::IIntroPart | |
| Cberry::IntroPart | |
| Cberry::IIterable | |
| Cberry::IJobChangeEvent | |
| Cberry::IJobManager | |
| Cberry::ILock | |
| ►Cberry::IMemento | |
| Cberry::XMLMemento | |
| Cberry::INestable | |
| Cberry::IntroContentDetector | |
| ►Cberry::IObjectWithState | |
| Cberry::AbstractHandlerWithState | |
| Cberry::NamedHandleObjectWithState | |
| Cberry::IPageLayout | |
| Cberry::IParameter | |
| Cberry::IPerspectiveDescriptor | |
| Cberry::IPerspectiveFactory | |
| ►Cberry::IPlaceholderFolderLayout | |
| Cberry::IFolderLayout | |
| Cberry::IPluginContribution | |
| ►Cberry::IPreferencePage | |
| ►Cberry::IQtPreferencePage | |
| CQmitkDataManagerHotkeysPrefPage | |
| CQmitkDataManagerPreferencePage | |
| CQmitkSegmentAnythingPreferencePage | |
| CQmitkSegmentationPreferencePage | |
| Cberry::IPresentablePart | |
| Cberry::IProduct | |
| ►Cberry::IProgressMonitor | |
| Cberry::IProgressMonitorWithBlocking | |
| Cberry::NullProgressMonitor | |
| ►Cberry::IPropertyTester | |
| Cberry::PropertyTester | |
| ►Cberry::ISafeRunnable | |
| Cberry::SafeRunnable | |
| Cberry::SafeRunnableDelegate< R > | |
| Cberry::ISafeRunnableRunner | |
| ►Cberry::ISaveablePart | |
| ►Cberry::IEditorPart | |
| Cberry::EditorPart | |
| Cberry::IReusableEditor | |
| Cberry::ISaveablesLifecycleListener | |
| Cberry::ISaveablesSource | |
| ►Cberry::ISchedulingRule | |
| Cberry::MultiRule | |
| Cmitk::DataStorageAccessRule | The DataStorageAccessRule inherits from the ISchedulingRule class. DataStorageAccessRule are used to restrict the adding and removing of DataStorage nodes in multi-threaded scenarios. Only DataStorageNodes within different branches can be modified concurrently. The idea and its restrictions is explained in the sections and diagrams below |
| ►Cberry::ISelection | |
| ►Cberry::IStructuredSelection | |
| Cberry::QtItemSelection | |
| Cmitk::DataNodeSelection | |
| Cmitk::MAPAlgorithmInfoSelection | Used by plugins to communicate selections of deployed algorithms |
| Cberry::SingleNodeSelection | Represents a selection object that encapsulates the selection of a single node |
| ►Cberry::ISelectionProvider | |
| Cberry::IPostSelectionProvider | |
| ►Cberry::QtSelectionProvider | |
| CQmitkDataNodeSelectionProvider | A BlueBerry selection provider for mitk::DataNode selections |
| ►Cberry::IServiceLocator | |
| Cberry::IWorkbench | |
| ►Cberry::IWorkbenchSite | |
| Cberry::IIntroSite | |
| ►Cberry::IWorkbenchPartSite | |
| Cberry::IEditorSite | |
| Cberry::IViewSite | |
| Cberry::IWorkbenchWindow | |
| ►Cberry::IShellProvider | |
| Cberry::SameShellProvider | |
| Cberry::Window | |
| Cberry::IShowInSource | |
| Cberry::IShowInTarget | |
| ►Cberry::ISourceProvider | |
| Cberry::AbstractSourceProvider | |
| Cberry::ISourceProviderService | |
| Cberry::IStackPresentationSite | |
| ►Cberry::IStatus | |
| ►Cberry::IJobStatus | |
| Cberry::JobStatus | |
| ►Cberry::Status | |
| Cberry::JobStatus | |
| Cberry::MultiStatus | |
| Cberry::IStickyViewDescriptor | |
| Cberry::ITypedParameter | |
| Cberry::IViewCategory | |
| Cberry::IViewLayout | |
| Cberry::IWorkbenchConfigurer | |
| Cberry::IWorkbenchPage | |
| ►Cberry::IWorkbenchPart | |
| Cberry::IEditorPart | |
| ►Cberry::IViewPart | |
| Cberry::ViewPart | |
| Cberry::WorkbenchPart | |
| ►Cberry::IWorkbenchPartDescriptor | |
| Cberry::IEditorDescriptor | |
| Cberry::IViewDescriptor | |
| ►Cberry::IWorkbenchPartReference | |
| Cberry::IEditorReference | |
| Cberry::IViewReference | |
| Cberry::IWorkbenchWindowConfigurer | |
| Cberry::LockListener | |
| Cberry::ObjectGeneric< T > | |
| Cberry::ObjectList< T > | |
| Cberry::ObjectString | |
| Cberry::ObjectStringMap | |
| Cberry::ObjectTypeInfo | |
| Cberry::ParameterizedCommand | |
| Cberry::PlatformObject | |
| Cberry::ProgressProvider | |
| Cberry::PropertyChangeEvent | |
| Cberry::QModelIndexObject | |
| Cberry::Saveable | |
| Cberry::SaveablesLifecycleEvent | |
| Cberry::SelectionChangedEvent | |
| Cberry::Shell | |
| Cberry::ShellEvent | |
| Cberry::ShowInContext | |
| Cberry::StackDropResult | |
| Cberry::StackPresentation | |
| Cberry::State | |
| Cberry::UIElement | |
| Cberry::Window::IExceptionHandler | |
| CIChangeText | |
| Cmitk::DataNodeObject | |
| Cmitk::IDataStorageReference | |
| Cmitk::MAPAlgorithmInfoObject | Berry wrapper for a MatchPoint algorithm deployment info |
| ►Cberry::ObjectGeneric< bool > | |
| Cberry::ObjectBool | |
| ►Cberry::ObjectGeneric< double > | |
| Cberry::ObjectDouble | |
| ►Cberry::ObjectGeneric< float > | |
| Cberry::ObjectFloat | |
| ►Cberry::ObjectGeneric< int > | |
| Cberry::ObjectInt | |
| Cberry::Parameterization | |
| Cberry::Platform | |
| Cberry::PlatformUI | |
| Cberry::QActionProperties | |
| Cberry::QScopedPointerObjectDeleter | |
| Cberry::QtPreferences | |
| Cberry::QualifiedName | |
| Cberry::Reflection::EmptyType | |
| Cberry::Reflection::GetSuperclassTypeList< T, bool > | |
| Cberry::Reflection::GetSuperclassTypeList< T, true > | |
| Cberry::Reflection::HasTypeSuperclass< T > | |
| Cberry::Reflection::MapReduce< TL, Map, Reduce > | |
| Cberry::Reflection::MapReduce< TypeList<>, Map, Reduce > | |
| Cberry::Reflection::MapToTypeInfo< T > | |
| Cberry::Reflection::ReduceToList< T > | |
| ►Cberry::Reflection::TypeInfo | |
| Cberry::ObjectTypeInfo | |
| Cberry::Reflection::TypeList< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > | |
| Cberry::Reflection::TypeList< EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType > | |
| Cberry::RegistryConstants | |
| Cberry::SafeRunner | |
| Cberry::SmartPointer | Implements transparent reference counting |
| Cberry::Status::SourceLocation | |
| Cberry::WeakPointer | Implements a WeakPointer class to deal with circular reference problems |
| Cberry::WorkbenchActionConstants | |
| ►Cberry::WorkbenchAdvisor | |
| Cberry::QtWorkbenchAdvisor | |
| Cberry::WorkbenchPageTweaklet | |
| Cberry::WorkbenchPreferenceConstants | |
| Cberry::WorkbenchTweaklet | |
| ►Cberry::WorkbenchWindowAdvisor | |
| CQmitkExtWorkbenchWindowAdvisor | |
| ►CBinaryFunctorImageFilter | |
| Citk::MaskImageFilter2< TInputImage, TMaskImage, TOutputImage > | |
| ►CConditionalConstIterator | |
| Citk::AdaptiveThresholdIterator< TImage, TFunction > | Iterates over an image using a variable image function, which threshold can be varied during the iteration process |
| CConfigFileReader | |
| ►CConnectedThresholdImageFilter | |
| Citk::ConnectedAdaptiveThresholdImageFilter< TInputImage, TOutputImage > | ImageFilter used for processing an image with an adaptive iterator (such as itkAdaptiveThresholdIterator) |
| Cmitk::CoreServicePointer< mitk::IPropertyAliases > | |
| Cmitk::CoreServicePointer< mitk::IPropertyFilters > | |
| ►CTestCase | |
| Cmitk::TestCaller< ParameterizedFixture > | A test caller for parameterized tests |
| ►CTestFixture | |
| ►Cmitk::TestFixture | Test fixture for parameterized tests |
| Cmitk::mitkModelTestFixture | |
| ►CctkException | |
| Cberry::CoreException | |
| ►CctkPluginActivator | |
| ►Cberry::Plugin | |
| ►Cberry::AbstractUICTKPlugin | |
| Cberry::WorkbenchPlugin | |
| ►CctkPythonConsole | |
| CQmitkCtkPythonShell | |
| ►CctkRuntimeException | |
| Cberry::InvalidRegistryObjectException | |
| ►CctkXnatTreeModel | |
| CQmitkXnatTreeModel | |
| Cberry::DelegateList< berry::MessageAbstractDelegate > | |
| Cberry::DelegateList< berry::MessageAbstractDelegate1 > | |
| Cberry::DelegateList< berry::MessageAbstractDelegate2 > | |
| Cberry::DelegateList< berry::MessageAbstractDelegate3 > | |
| Cberry::DelegateList< berry::MessageAbstractDelegate4 > | |
| CDocumentationExample | This is a class for showing how to document your code using doxygen |
| CEventHandler | |
| Cus::ExplicitlySharedDataPointer< Impl > | |
| Cus::ExplicitlySharedDataPointer< SharedLibraryPrivate > | |
| CFolderNode | Struct to store each (Folder) Node of the hierarchy tree structure |
| ►Cmitk::GenericLookupTable< bool > | |
| Cmitk::BoolLookupTable | Specializations of GenericLookupTable |
| ►Cmitk::GenericLookupTable< DICOMCachedValueInfo > | |
| Cmitk::DICOMCachedValueLookupTable | |
| ►Cmitk::GenericLookupTable< float > | |
| Cmitk::FloatLookupTable | |
| ►Cmitk::GenericLookupTable< int > | |
| Cmitk::IntLookupTable | |
| ►Cmitk::GenericLookupTable< std::string > | |
| Cmitk::StringLookupTable | |
| ►CIEvaluationResultCache | |
| Cberry::IEvaluationReference | |
| Cberry::IHandlerActivation | |
| ►Cmitk::ImagePixelAccessor< TPixel, 3 > | |
| Cmitk::ImagePixelReadAccessor< TPixel, VDimension > | Gives locked and index-based read access for a particular image part. The class provides several set- and get-methods, which allow an easy pixel access. It needs to know about pixel type and dimension of its image at compile time |
| Cmitk::ImagePixelWriteAccessor< TPixel, VDimension > | Gives locked and index-based write access for a particular image part. The class provides several set- and get-methods, which allow an easy pixel access. It needs to know about pixel type and dimension of its image at compile time |
| ►CImageToImageFilter | |
| Citk::LocalIntensityFilter< TInputImage > | |
| Citk::LocalStatisticFilter< TInputImageType, TOuputImageType > | |
| Citk::MaskedNaryStatisticsImageFilter< TInputImage, TMaskImage > | Computes a masked statistic on N images and produces vectors of those statistic results |
| Citk::MaskedStatisticsImageFilter< TInputImage, TMaskImage > | Compute min. max, variance and mean of an (masked) Image |
| Citk::MultiHistogramFilter< TInputImageType, TOuputImageType > | |
| Citk::SmoothedClassProbabilites< TImage > | |
| Citk::StitchImageFilter< TInputImage, TOutputImage, TInterpolatorPrecisionType, TTransformPrecisionType > | ITK filter that resamples/stitches multiple images into a given reference geometry |
| CImporterUtil | |
| ►CImportImageContainer | |
| Citk::ImportMitkImageContainer< TElementIdentifier, TElement > | |
| CInteractionEventList | Generates a list of InteractionEvents based on an XML file- |
| ►CInternalJob | |
| Cberry::Job | |
| CIsoDoseLevelVector | Simple vector that stores dose iso levels |
| ►CAnyEvent | |
| Cmitk::CallbackEventOneParameter< T > | Used by CallbackFromGUIThread to pass parameters |
| ►Cmitk::DisplayActionEvent | |
| Cmitk::DisplayMoveEvent | |
| Cmitk::DisplayScrollEvent | |
| Cmitk::DisplaySetCrosshairEvent | |
| Cmitk::DisplaySetLevelWindowEvent | |
| Cmitk::DisplayZoomEvent | |
| ►Cmitk::ExternalProcessOutputEvent | |
| Cmitk::ExternalProcessStdErrEvent | |
| Cmitk::ExternalProcessStdOutEvent | |
| ►Cmitk::NonBlockingAlgorithmEvent | |
| Cmitk::ProcessingError | |
| Cmitk::ResultAvailable | |
| ►Cmitk::SliceNavigationController::TimeGeometryEvent | |
| Cmitk::SliceNavigationController::GeometrySendEvent | |
| Cmitk::SliceNavigationController::GeometrySliceEvent | |
| Cmitk::SliceNavigationController::GeometryUpdateEvent | |
| Cmitk::TimeNavigationController::TimeEvent | |
| ►CCommand | |
| Cmitk::DicomSeriesReader::CallbackCommand | Progress callback for DicomSeriesReader |
| Cmitk::StdFunctionCommand | |
| Cmitk::ToolCommand | A command to get tool process feedback |
| ►CDataObject | |
| ►Cmitk::BaseData | Base of all data objects |
| Cmitk::AbstractClassifier | |
| ►Cmitk::AbstractGlobalImageFeature | |
| Cmitk::GIFCooccurenceMatrix | |
| Cmitk::GIFCooccurenceMatrix2 | Calculates features based on the co-occurrence matrix |
| Cmitk::GIFCurvatureStatistic | Calculates features based on the co-occurrence matrix |
| Cmitk::GIFFirstOrderHistogramStatistics | Calculates first order features based on a histogram |
| Cmitk::GIFFirstOrderNumericStatistics | |
| Cmitk::GIFFirstOrderStatistics | |
| Cmitk::GIFGreyLevelDistanceZone | |
| Cmitk::GIFGreyLevelRunLength | Calculates the Run Length based features |
| Cmitk::GIFGreyLevelSizeZone | |
| Cmitk::GIFImageDescriptionFeatures | Calculates simple features that describe the given image / mask |
| Cmitk::GIFIntensityVolumeHistogramFeatures | Calculates the Intensity Volume Histogram features |
| Cmitk::GIFLocalIntensity | Calculates the local intensity features |
| Cmitk::GIFNeighbourhoodGreyLevelDifference | |
| Cmitk::GIFNeighbourhoodGreyToneDifferenceFeatures | Calculates the Neighbourhood Grey Tone Difference Features |
| Cmitk::GIFNeighbouringGreyLevelDependenceFeature | Calculates the Neighbouring Grey Level Dependence Features |
| Cmitk::GIFVolumetricDensityStatistics | Calculates Volumetric Density Features |
| Cmitk::GIFVolumetricStatistics | Calculates simpel shape-related features |
| Cmitk::BaseDataTestImplementation | Implementation of BaseData (for testing) |
| Cmitk::Contour | Stores vertices for drawing a contour |
| Cmitk::ContourModel | ContourModel is a structure of linked vertices defining a contour in 3D space. The vertices are stored in a mitk::ContourElement for each timestep. The contour line segments are implicitly defined by the given linked vertices. By default two control points are linked by a straight line. It is possible to add vertices at the front and end of the contour and to iterate in both directions |
| Cmitk::ContourModelSet | |
| Cmitk::ContourSet | |
| Cmitk::CrosshairData | |
| Cmitk::ExampleDataStructure | Example Data Structure |
| ►Cmitk::GeometryData | Data class only having a BaseGeometry but not containing any specific data |
| Cmitk::PlaneGeometryData | Data class containing PlaneGeometry objects |
| Cmitk::ImageStatisticsContainer | Container class for storing a StatisticsObject for each time step |
| Cmitk::IntensityQuantifier | |
| Cmitk::MAPRegistrationWrapper | MAPRegistrationWrapper Wrapper class to allow the handling of MatchPoint registration objects as mitk data (e.g. in the data explorer) |
| ►Cmitk::PlanarFigure | Base-class for geometric planar (2D) figures, such as lines, circles, rectangles, polygons, etc |
| Cmitk::PlanarAngle | Implementation of PlanarFigure to display an angle through three control points |
| Cmitk::PlanarArrow | Implementation of PlanarFigure representing an arrow through two control points |
| Cmitk::PlanarBezierCurve | |
| Cmitk::PlanarCircle | Implementation of PlanarFigure representing a circle either through two control points or by one control point (fixed radius mode) The mode is defined by the chosen constructor |
| Cmitk::PlanarCross | Implementation of PlanarFigure modeling a cross with two orthogonal lines on a plane |
| Cmitk::PlanarDoubleEllipse | Planar representing a double ellipse. The double ellipse is either represented by 4 control points (center, outer major axis, outer minor axis and inner major axis) or be one control point (center, fixed size mode). The mode is selected via the constructor |
| Cmitk::PlanarEllipse | Implementation of PlanarFigure representing a circle through two control points |
| Cmitk::PlanarFourPointAngle | Implementation of PlanarFigure representing a four point angle, which is defined by two non-intersecting lines in 2D. Each of those lines is defined by two control points |
| Cmitk::PlanarLine | Implementation of PlanarFigure representing a line through two control points |
| ►Cmitk::PlanarPolygon | Implementation of PlanarFigure representing a polygon with two or more control points |
| Cmitk::PlanarSubdivisionPolygon | Implementation of PlanarFigure representing a polygon with two or more control points |
| Cmitk::PlanarRectangle | Implementation of PlanarFigure representing a polygon with two or more control points |
| Cmitk::PointSet | Data structure which stores a set of points |
| Cmitk::RegEvaluationObject | RegEvaluationObject Class that contains all data to realize an evaluation of registrations via images |
| Cmitk::ROI | A collection of region of interests (ROIs) |
| Cmitk::SegmentationTaskList | A list of segmentation tasks |
| ►Cmitk::SlicedData | Super class of data objects consisting of slices |
| ►Cmitk::Image | Image class for storing images |
| Cmitk::LabelSetImage | LabelSetImage class for handling labels and layers in a segmentation session |
| ►Cmitk::Surface | Class for storing surfaces (vtkPolyData) |
| ►Cmitk::BoundingObject | Superclass of all bounding objects (cylinder, cuboid,...) |
| Cmitk::BoundingObjectGroup | Group object, that contains several mitk::BoundingObjects |
| Cmitk::Cone | Data class containing an cylinder |
| Cmitk::Cuboid | Data class containing an cuboid |
| Cmitk::Cylinder | Data class containing an cylinder |
| Cmitk::Ellipsoid | Data class containing an ellipsoid |
| Cmitk::ExtrudedContour | Data class containing a bounding-object created by extruding a Contour along a vector |
| Cmitk::Plane | Plane surface representation |
| Cmitk::Gizmo | |
| Cmitk::UnstructuredGrid | Class for storing unstructured grids (vtkUnstructuredGrid) |
| Cmitk::VtkWidgetRendering | Mechanism for rendering a vtkWidget in the foreground of a RenderWindow |
| Cmitk::DataNode | Class for nodes of the DataTree |
| ►Cmitk::LookupTable | Mitk wrapper for a vtkLookupTable |
| Cmitk::LabeledImageLookupTable | |
| ►CEndEvent | |
| Cmitk::OperationEndEvent | |
| ►CExceptionObject | |
| ►Cmitk::Exception | An object of this class represents an exception of MITK. Please don't instantiate exceptions manually, but use the exception macros (file mitkExceptionMacro.h) instead. Simple use in your code is: |
| Cmitk::FormulaParserException | Exception class for all exceptions that are generated in the FormulaParser module |
| Cmitk::InvalidPathNodeException | |
| Cmitk::MemoryIsLockedException | |
| Cmitk::modelFit::ModelFitException | Class-specific exception for modelfits |
| Cmitk::NoPropertyRelationException | |
| Cmitk::TestNotRunException | Specialized mitk::Exception for skipped tests |
| Citk::FFTImageFilterInitFactoryRegisterManager | |
| Citk::Functor::MaskInput2< TInput, TMask, TOutput > | |
| Citk::Functor::NeighborhoodCooccurenceMatrix< TNeighborhoodType, TPixelOutputType > | Functor for texture feature calculation based on the Cooccurrence matrix |
| Citk::Functor::NeighborhoodFirstOrderStatistics< TNeighborhoodType, TPixelOutputType > | |
| Citk::ImageIOFactoryRegisterManager | |
| ►CImageSink | |
| Cmitk::LabelStatisticsImageFilter< TInputImage > | |
| Cmitk::StatisticsImageFilter< TInputImage > | |
| ►CImageSource | |
| Citk::MultiGaussianImageSource< TOutputImage > | Generate an 3-dimensional multigaussian image |
| Cmitk::ImageToItk< TOutputImage > | |
| ►CImageToImageFilter | |
| Citk::IntelligentBinaryClosingFilter< TInputImage, TOutputImage > | |
| Citk::LabelSampler< TImage > | |
| Citk::LineHistogramBasedMassImageFilter< TInputImageType, TOutputImageType, TMaskImageType > | |
| Citk::LocalVariationImageFilter< TInputImage, TOutputImage > | Calculates the local variation in each pixel |
| Citk::MinMaxImageFilterWithIndex< TInputImage > | |
| Citk::MinMaxLabelImageFilterWithIndex< TInputImage, TLabelImage > | |
| Citk::MultiOutputNaryFunctorImageFilter< TInputImage, TOutputImage, TFunction, TMaskImage > | Perform a generic pixel-wise operation on N images and produces m output images |
| Citk::NeighborhoodFunctorImageFilter< TInputImageType, TFeatureImageType, FunctorType > | |
| Citk::ShortestPathImageFilter< TInputImageType, TOutputImageType > | |
| Citk::TotalVariationDenoisingImageFilter< TInputImage, TOutputImage > | Applies a total variation denoising filter to an image |
| Citk::TotalVariationSingleIterationImageFilter< TInputImage, TOutputImage > | Applies a total variation denoising filter to an image |
| ►CLightObject | |
| Cmitk::ContourElement | Represents a contour in 3D space. A ContourElement is consisting of linked vertices implicitely defining the contour. They are stored in a double ended queue making it possible to add vertices at front and end of the contour and to iterate in both directions. To mark a vertex as a special one it can be set as a control point |
| ►Cmitk::DICOMDatasetSorter | The sorting/splitting building-block of DICOMITKSeriesGDCMReader |
| Cmitk::DICOMTagBasedSorter | Sort DICOM datasets based on configurable tags |
| Cmitk::EquiDistantBlocksSorter | Split inputs into blocks of equidistant slices (for use in DICOMITKSeriesGDCMReader) |
| Cmitk::NormalDirectionConsistencySorter | Makes sure that the order of files is along the image plane normals |
| Cmitk::DICOMFileReaderSelector | Simple best-reader selection |
| ►Cmitk::DICOMImageFrameInfo | Describes a frame within a DICOM file |
| ►Cmitk::DICOMDatasetAccessingImageFrameInfo | Defines an abstract base class for DICOM image frame infos with data access |
| Cmitk::DICOMGDCMImageFrameInfo | The dataset access implementation for DICOMITKSeriesGDCMReader, based on GDCM |
| Cmitk::DICOMGenericImageFrameInfo | A generic storage class for image frame info with data access |
| Cmitk::DICOMReaderConfigurator | Too-simple factory to create DICOMFileReaders |
| ►Cmitk::DICOMSortCriterion | A tag based sorting criterion for use in DICOMTagBasedSorter |
| Cmitk::DICOMSortByTag | Compare two datasets by the value of a single tag (for use in DICOMTagBasedSorter) |
| Cmitk::SortByImagePositionPatient | Sort by distance of image origin along image normal (for use in DICOMTagBasedSorter) |
| Cmitk::Dispatcher | Manages event distribution |
| Cmitk::ImageDataItem | Internal class for managing references on sub-images |
| ►Cmitk::InteractionEvent | |
| Cmitk::InteractionKeyEvent | Handles key events Takes a std::string for pressed key or special key description, mitk::ModifierKeys for modifiers |
| ►Cmitk::InteractionPositionEvent | Super class for all position events |
| Cmitk::MouseDoubleClickEvent | |
| Cmitk::MouseMoveEvent | |
| Cmitk::MousePressEvent | |
| Cmitk::MouseReleaseEvent | |
| Cmitk::MouseWheelEvent | |
| Cmitk::InternalEvent | Class to create events from within the application to signal about internal events |
| Cmitk::modelFit::ModelFitInfo | Data class that stores all information about a modelfit that is relevant to the visualization and stored as properties in the result nodes |
| Cmitk::modelFit::Parameter | |
| ►Cmitk::MovieGenerator | |
| Cmitk::MovieGeneratorWin32 | |
| Cmitk::PersistenceService | |
| ►Cmitk::PropertyExtension | Base class for all property extensions |
| Cmitk::FloatPropertyExtension | Property extension for mitk::FloatProperty |
| Cmitk::IntPropertyExtension | Property extension for mitk::IntProperty |
| Cmitk::PropertyPersistenceInfo | Property persistence info. This class is used to specify the way the persistance of a property of BaseData derived instances is handled. The info specifies the key for property, as well as the mime type the info is defined for and should be used. Additionally the functions for deserialization and serialization of the property can be defined. As default |
| Cmitk::PythonService | |
| Cmitk::StateMachineAction | Represents an action, that is executed after a certain event (in statemachine-mechanism) TODO: implement: Is used to connect the Action-Id in an XML Statemachine description with a functor in the |
| Cmitk::StateMachineState | |
| Cmitk::StateMachineTransition | Connects two states, and holds references to corresponding actions and conditions |
| Cmitk::ToolManagerProvider | Micro Service Singleton to get an instance of mitk::ToolManager |
| ►CMatrix | |
| Cmitk::Matrix< T, NRows, NColumns > | |
| Citk::MeshIOFactoryRegisterManager | |
| Citk::MinMaxLabelImageFilterWithIndex< TInputImage, TLabelImage >::LabelExtrema | Just a container for global min/max values and their indices as well as all min and max values (+indices) of the mask labels |
| ►CModifiedEvent | |
| ►Cmitk::AnyGroupEvent | |
| Cmitk::GroupAddedEvent | |
| Cmitk::GroupModifiedEvent | |
| Cmitk::GroupRemovedEvent | |
| ►Cmitk::AnyLabelEvent | |
| Cmitk::LabelAddedEvent | |
| Cmitk::LabelModifiedEvent | |
| Cmitk::LabelRemovedEvent | |
| Cmitk::LabelsChangedEvent | |
| ►CMultipleValuedCostFunction | |
| ►Cmitk::MVModelFitCostFunction | |
| Cmitk::MVConstrainedCostFunctionDecorator | This class is used to add constraints to any multi valued model fit cost function |
| Cmitk::SquaredDifferencesFitCostFunction | |
| Citk::MutexLockHolder< T > | |
| ►CObject | |
| ►Citk::ShortestPathCostFunction< TInputImageType > | |
| Citk::ShortestPathCostFunctionLiveWire< TInputImageType > | Cost function for LiveWire purposes. Specific features are considered to calculate cummulative costs of a link between two pixels. These are: |
| Citk::ShortestPathCostFunctionTbss< TInputImageType > | |
| Citk::Statistics::MITKScalarImageToHistogramGenerator< TImageType, TMeasurementType > | |
| Cmitk::Action | Action, that is executed after a certain event (in statemachine-mechanism) |
| Cmitk::AnisotropicIterativeClosestPointRegistration | Implementation of the anisotropic iterative closest point (A-ICP) algorithm |
| ►Cmitk::Annotation | Base class for all Annotation This class is to be implemented in order to create Annotation which are managed by a AbstractAnnotationRenderer. This class contains an internal Propertylist for configuring the appearance of the implemented Overlay |
| ►Cmitk::VtkAnnotation | Base for all Annotation which are using the VTK framework to render the elements |
| Cmitk::ColorBarAnnotation | Displays configurable scales on the renderwindow. The scale is determined by the image spacing |
| Cmitk::LogoAnnotation | Displays a logo on the renderwindow |
| Cmitk::ScaleLegendAnnotation | Displays configurable scales on the renderwindow. The scale is determined by the image spacing |
| ►Cmitk::VtkAnnotation2D | Basis for all VTK based Annotation which create a vtkActor2D element that will be drawn on the renderer |
| Cmitk::TextAnnotation2D | Displays text on the renderwindow |
| ►Cmitk::VtkAnnotation3D | Basis for all VTK based Annotation which create any 3D element as a vtkProp that will be drawn on the renderer |
| Cmitk::LabelAnnotation3D | Can display a high amount of 3D labels to a PointSet |
| Cmitk::TextAnnotation3D | Displays at 3D position, always facing the camera |
| Cmitk::AterialInputFunctionGenerator | Compute the Aterial Input Function from a given dynamic image and a mask defining the tumour supplying artery |
| ►Cmitk::BaseController | Baseclass for renderer slice-/camera-/time-control |
| Cmitk::CameraController | Controls the camera used by the associated BaseRenderer |
| Cmitk::CameraRotationController | |
| Cmitk::SliceNavigationController | Controls the selection of the slice the associated BaseRenderer will display |
| Cmitk::TimeNavigationController | Controls the time-related properties of the time stepper, according to the given input world time geometry |
| Cmitk::BaseDataIO | BaseDataIO creates instances of BaseData objects using an object factory |
| ►Cmitk::BaseDataSerializer | Base class for objects that serialize BaseData types |
| Cmitk::ContourModelSerializer | |
| Cmitk::ContourModelSetSerializer | |
| Cmitk::ExampleDataStructureSerializer | Serializes mitk::ExampleDataStructure for mitk::SceneIO |
| Cmitk::GeometryDataSerializer | Serializes mitk::GeometryData for mitk::SceneIO |
| Cmitk::ImageSerializer | Serializes mitk::Image for mitk::SceneIO |
| Cmitk::LabelSetImageSerializer | Serializes mitk::LabelSetImage for mitk::SceneIO |
| Cmitk::MAPRegistrationWrapperSerializer | Serializes mitk::MAPRegistrationWrapper for mitk::SceneIO |
| Cmitk::PlanarFigureSerializer | Serializes mitk::Surface for mitk::SceneIO |
| Cmitk::PointSetSerializer | Serializes mitk::Surface for mitk::SceneIO |
| Cmitk::ROISerializer | |
| Cmitk::SegmentationTaskListSerializer | |
| Cmitk::SurfaceSerializer | Serializes mitk::Surface for mitk::SceneIO |
| ►Cmitk::BaseGeometry | BaseGeometry Describes the geometry of a data object |
| Cmitk::Geometry3D | Standard implementation of BaseGeometry |
| ►Cmitk::PlaneGeometry | Describes a two-dimensional, rectangular plane |
| ►Cmitk::AbstractTransformGeometry | Describes a geometry defined by an vtkAbstractTransform and a plane |
| ►Cmitk::LandmarkProjectorBasedCurvedGeometry | Superclass of AbstractTransformGeometry sub-classes defined by a set of landmarks |
| Cmitk::ThinPlateSplineCurvedGeometry | Thin-plate-spline-based landmark-based curved geometry |
| Cmitk::SlicedGeometry3D | Describes the geometry of a data object consisting of slices |
| ►Cmitk::BaseProperty | Abstract base class for properties |
| ►Cmitk::GenericProperty< bool > | |
| Cmitk::BoolProperty | |
| ►Cmitk::GenericProperty< BoolLookupTable > | |
| Cmitk::BoolLookupTableProperty | |
| ►Cmitk::GenericProperty< double > | |
| Cmitk::DoubleProperty | |
| ►Cmitk::GenericProperty< float > | |
| Cmitk::FloatProperty | |
| ►Cmitk::GenericProperty< FloatLookupTable > | |
| Cmitk::FloatLookupTableProperty | |
| ►Cmitk::GenericProperty< int > | |
| Cmitk::IntProperty | |
| ►Cmitk::GenericProperty< IntLookupTable > | |
| Cmitk::IntLookupTableProperty | |
| ►Cmitk::GenericProperty< Point2D > | |
| Cmitk::Point2dProperty | |
| ►Cmitk::GenericProperty< Point3D > | |
| Cmitk::Point3dProperty | |
| ►Cmitk::GenericProperty< Point3I > | |
| Cmitk::Point3iProperty | |
| ►Cmitk::GenericProperty< Point4D > | |
| Cmitk::Point4dProperty | |
| ►Cmitk::GenericProperty< StringLookupTable > | |
| Cmitk::StringLookupTableProperty | |
| ►Cmitk::GenericProperty< unsigned int > | |
| Cmitk::UIntProperty | |
| ►Cmitk::GenericProperty< unsigned short > | |
| Cmitk::UShortProperty | |
| ►Cmitk::GenericProperty< Vector3D > | |
| Cmitk::Vector3DProperty | |
| Cmitk::AnnotationProperty | Property for annotations |
| Cmitk::ClippingProperty | Property for clipping datasets; currently only clipping planes are possible |
| Cmitk::ColorProperty | RGB color property |
| ►Cmitk::EnumerationProperty | |
| Cmitk::GridRepresentationProperty | |
| Cmitk::GridVolumeMapperProperty | |
| Cmitk::ModalityProperty | Enumerates all known modalities |
| Cmitk::PlanarFigureControlPointStyleProperty | Defines the rendering style of control points for PlanarFigure objects |
| Cmitk::PlaneOrientationProperty | |
| Cmitk::PointSetShapeProperty | |
| Cmitk::RegEvalStyleProperty | |
| Cmitk::RegEvalWipeStyleProperty | |
| Cmitk::RegVisColorStyleProperty | |
| Cmitk::RegVisDirectionProperty | |
| Cmitk::RegVisStyleProperty | |
| Cmitk::RenderingModeProperty | |
| Cmitk::ResliceMethodProperty | |
| Cmitk::VtkInterpolationProperty | |
| Cmitk::VtkRepresentationProperty | |
| Cmitk::VtkResliceInterpolationProperty | |
| Cmitk::VtkScalarModeProperty | |
| Cmitk::GenericProperty< T > | |
| Cmitk::GroupTagProperty | Property class that has no value |
| Cmitk::IsoDoseLevelSetProperty | Property class for dose iso level sets |
| Cmitk::IsoDoseLevelVectorProperty | Property class for dose iso level vector |
| Cmitk::LevelWindowProperty | Property for the mitk::LevelWindow |
| Cmitk::LookupTableProperty | Property to associate mitk::LookupTable to an mitk::DataNode |
| Cmitk::SmartPointerProperty | Property containing a smart-pointer |
| Cmitk::StringProperty | Property for strings |
| Cmitk::TemporoSpatialStringProperty | Property for time and space resolved string values |
| Cmitk::TransferFunctionProperty | Property class for the mitk::TransferFunction |
| Cmitk::VectorProperty< DATATYPE > | Providing a std::vector as property |
| Cmitk::WeakPointerProperty | Property containing a smart-pointer |
| ►Cmitk::BasePropertySerializer | Base class for objects that serialize BaseProperty types |
| Cmitk::EnumerationPropertySerializer | |
| Cmitk::LookupTablePropertySerializer | Base class for objects that serialize BaseData types |
| Cmitk::ScalarListLookupTablePropertySerializer | Serializer for the ScalarListLookupTableProperty so it can be written and read from file |
| Cmitk::TransferFunctionPropertySerializer | |
| Cmitk::VectorPropertySerializer< DATATYPE > | Serializes a VectorProperty |
| ►Cmitk::BaseRenderer | |
| Cmitk::VtkPropRenderer | VtkPropRenderer |
| Cmitk::ConcentrationCurveGenerator | Converts a given 4D mitk::Image with MR signal values into a 4D mitk::Image with corresponding contrast agent concentration values |
| ►Cmitk::ConstraintCheckerBase | This class is the base class for constraint checker |
| Cmitk::SimpleBarrierConstraintChecker | This class implements constraints as simple barrier functions |
| Cmitk::ContourModelUtils | Helpful methods for working with contours and images |
| Cmitk::ContourUtils | Helpful methods for working with contours and images |
| ►Cmitk::CoreObjectFactoryBase | |
| Cmitk::BoundingShapeObjectFactory | |
| Cmitk::ContourObjectFactory | |
| Cmitk::CoreObjectFactory | |
| Cmitk::GizmoObjectFactory | |
| Cmitk::MAPRegistrationWrapperObjectFactory | |
| Cmitk::MultilabelObjectFactory | |
| Cmitk::PlanarFigureObjectFactory | |
| Cmitk::RegEvaluationObjectFactory | |
| Cmitk::ROIObjectFactory | |
| Cmitk::SegmentationObjectFactory | |
| Cmitk::CovarianceMatrixCalculator | Class that computes the covariance matrices for every point in a Surface used in the A-ICP algorithm |
| Cmitk::CrosshairManager | The CrosshairManager takes care of the correct settings for the crosshair |
| ►Cmitk::CurveDescriptionParameterBase | |
| Cmitk::AreaUnderFirstMomentDescriptionParameter | |
| Cmitk::AreaUnderTheCurveDescriptionParameter | |
| Cmitk::MaximumCurveDescriptionParameter | |
| Cmitk::MeanResidenceTimeDescriptionParameter | |
| Cmitk::TimeToPeakCurveDescriptionParameter | |
| ►Cmitk::DataStorage | Data management class that handles 'was created by' relations |
| Cmitk::StandaloneDataStorage | Data management class that handles 'was created by' relations |
| Cmitk::DataStorageSelection | |
| ►Cmitk::DescriptionParameterImageGeneratorBase | |
| Cmitk::PixelBasedDescriptionParameterImageGenerator | |
| ►Cmitk::DICOMFileReader | Interface for DICOM readers that produce mitk::Images |
| ►Cmitk::DICOMITKSeriesGDCMReader | Flexible reader based on itk::ImageSeriesReader and GDCM, for single-slice modalities like CT, MR, PET, CR, etc |
| ►Cmitk::ThreeDnTDICOMSeriesReader | Extends DICOMITKSeriesGDCMReader by sorting/grouping into 3D+t image blocks |
| Cmitk::ClassicDICOMSeriesReader | Sorting and grouping like mitk::DicomSeriesReader until 2013 |
| ►Cmitk::DICOMTagCache | .. |
| Cmitk::DICOMGDCMTagCache | Tag cache implementation used by the DICOMGDCMTagScanner |
| Cmitk::DICOMGenericTagCache | Generic tag cache implementation |
| ►Cmitk::DICOMTagScanner | Abstracts the tag scanning process for a set of DICOM files |
| Cmitk::DICOMDCMTKTagScanner | Encapsulates the tag scanning process for a set of DICOM files |
| Cmitk::DICOMGDCMTagScanner | Encapsulates the tag scanning process for a set of DICOM files |
| Cmitk::DiffImageApplier | Applies difference images to 3D images |
| Cmitk::GradientBackground | |
| Cmitk::HistogramGenerator | Provides an easy way to calculate an itk::Histogram for a mitk::Image |
| Cmitk::ImageDescriptor | An object to hold all essential information about an Image object |
| Cmitk::ImageGenerationHelper | |
| Cmitk::ImageStatisticsCalculator | |
| ►Cmitk::IndexedValueFunctorBase | |
| ►Cmitk::ModelBasedValueFunctorBase | |
| Cmitk::ModelFitInfoSignalGenerationFunctor | |
| ►Cmitk::InitialParameterizationDelegateBase | |
| ►Cmitk::ValueBasedParameterizationDelegate | |
| Cmitk::ImageBasedParameterizationDelegate | |
| ►Cmitk::InteractionEventHandler | |
| ►Cmitk::EventStateMachine | ** |
| ►Cmitk::DataInteractor | Base class from with interactors that handle DataNodes are to be derived |
| Cmitk::AffineBaseDataInteractor3D | Affine interaction with mitk::BaseGeometry |
| Cmitk::AffineImageCropperInteractor | Affine interaction with objects in 3D windows |
| Cmitk::BoundingShapeInteractor | Basic interaction methods for mitk::GeometryData |
| Cmitk::ClippingPlaneInteractor3D | Specialized interactor for clipping planes |
| ►Cmitk::ContourModelInteractor | |
| Cmitk::ContourModelLiveWireInteractor | |
| Cmitk::ExampleInteractor | |
| Cmitk::GizmoInteractor | |
| Cmitk::PlanarFigureInteractor | Interaction with mitk::PlanarFigure objects via control-points |
| ►Cmitk::PointSetDataInteractor | Implementation of the PointSetInteractor |
| Cmitk::SinglePointDataInteractor | Implementation of the single point interaction |
| Cmitk::SurfaceDeformationDataInteractor3D | SurfaceDeformation interaction with objects in 3D windows |
| Cmitk::DisplayActionEventBroadcast | This class serves as an event state machine while simultaneously observing interaction events. It connects the actions from the event state machine .xml-file with concrete functions of this class |
| ►Cmitk::Tool | Base class of all tools used by mitk::ToolManager |
| ►Cmitk::SegmentationsProcessingTool | Batch processing of all selected segmentations/data |
| Cmitk::AutoCropTool | Crops selected segmentations |
| ►Cmitk::SegTool2D | Abstract base class for segmentation tools |
| ►Cmitk::FeedbackContourTool | Base class for tools that use a contour for feedback |
| ►Cmitk::ContourTool | Simple contour filling tool |
| Cmitk::AddContourTool | Fill the inside of a contour with 1 |
| Cmitk::SubtractContourTool | Fill the inside of a contour with 1 |
| ►Cmitk::EditableContourTool | |
| Cmitk::LassoTool | A 2D segmentation tool to draw polygon structures |
| Cmitk::LiveWireTool2D | A 2D segmentation tool based on a LiveWire approach |
| ►Cmitk::PaintbrushTool | Paintbrush tool for InteractiveSegmentation |
| Cmitk::DrawPaintbrushTool | Paintbrush tool for InteractiveSegmentation |
| Cmitk::ErasePaintbrushTool | Paintbrush tool for InteractiveSegmentation |
| Cmitk::RegionGrowingTool | A slice based region growing tool |
| ►Cmitk::FillRegionBaseTool | Base class for tools that fill a connected region of a 2D slice |
| Cmitk::CloseRegionTool | Closes/Fills the inside of a contour with the foreground pixel value |
| Cmitk::EraseRegionTool | Erase the inside of a contour by filling the inside of a contour with the background pixel value |
| Cmitk::FillRegionTool | Fill the inside of a contour with the foreground pixel value |
| ►Cmitk::SegWithPreviewTool | Base class for any auto segmentation tool that provides a preview of the new segmentation |
| ►Cmitk::BinaryThresholdBaseTool | Base class for binary threshold tools |
| Cmitk::BinaryThresholdTool | Calculates the segmented volumes for binary images |
| Cmitk::BinaryThresholdULTool | Calculates the segmented volumes for binary images |
| Cmitk::GrowCutTool | |
| ►Cmitk::MonaiLabelTool | MonaiLabel segmentation tool base class |
| Cmitk::MonaiLabel2DTool | MonaiLabel segmentation 2D tool |
| Cmitk::MonaiLabel3DTool | MonaiLabel segmentation 3D tool |
| Cmitk::nnUNetTool | NnUNet segmentation tool |
| Cmitk::OtsuTool3D | |
| Cmitk::PickingTool | Extracts a single region from a segmentation image and creates a new image with same geometry of the input image |
| ►Cmitk::SegmentAnythingTool | Segment Anything Model interactive 2D tool class |
| Cmitk::MedSAMTool | Medical Segment Anything Model interactive 2D tool class |
| Cmitk::TotalSegmentatorTool | TotalSegmentator segmentation tool |
| Cmitk::InteractionSchemeSwitcher | |
| ►Cmitk::IOAdapterBase | IOAdapterBase class is an abstract adapter class for IO process objects |
| Cmitk::IOAdapter< T > | IOAdapter class is an adapter class for instantiation of IO process objects. Additional this interface defines the function CanReadFile(). This interface allows the target (object) the access to the adaptee (IO process object) |
| Cmitk::IsoDoseLevel | Stores values needed for the representation/visualization of dose iso levels |
| Cmitk::IsoDoseLevelSet | Stores values needed for the representation/visualization of dose iso levels |
| Cmitk::LabeledImageVolumeCalculator | Class for calculating the volume (or area) for each label in a labeled image |
| ►Cmitk::LandmarkProjector | Base-class of landmark-projectors, which project the target landmarks to create source landmarks |
| Cmitk::PlaneLandmarkProjector | Thin-plate-spline-based landmark-based curved geometry |
| Cmitk::LevelWindowManager | Provides access to the LevelWindowProperty object and LevelWindow of the "current" image |
| ►Cmitk::Mapper | Base class of all mappers, Vtk as well as OpenGL mappers |
| Cmitk::ContourMapper2D | OpenGL-based mapper to display a mitk::Contour object in a 2D render window |
| ►Cmitk::ContourModelGLMapper2DBase | Base class for OpenGL based 2D mappers. Provides functionality to draw a contour |
| Cmitk::ContourModelGLMapper2D | OpenGL-based mapper to display a mitk::Contour object in a 2D render window |
| Cmitk::ContourModelSetGLMapper2D | OpenGL-based mapper to display a mitk::ContourModelSet object containing several contours in a 2D render window |
| Cmitk::ContourSetMapper2D | OpenGL-based mapper to display a mitk::Contour object in a 2D render window |
| ►Cmitk::GLMapper | Base class of all OpenGL-based mappers |
| Cmitk::UnstructuredGridMapper2D | OpenGL-based mapper to display a 2d cut through a poly data OpenGL-based mapper to display a 2D cut through a poly data. The result is normally a line. This class can be added to any data object, which is rendered in 3D via a vtkPolyData |
| Cmitk::VectorImageMapper2D | |
| Cmitk::PlanarFigureMapper2D | OpenGL-based mapper to render display sub-class instances of mitk::PlanarFigure |
| ►Cmitk::VtkMapper | Base class of all Vtk Mappers in order to display primitives by exploiting Vtk functionality |
| Cmitk::BoundingShapeVtkMapper2D | |
| Cmitk::BoundingShapeVtkMapper3D | |
| Cmitk::ContourModelMapper2D | |
| Cmitk::ContourModelMapper3D | |
| Cmitk::ContourModelSetMapper3D | |
| Cmitk::ContourSetVtkMapper3D | Vtk-based mapper for mitk::Contour |
| Cmitk::ContourVtkMapper3D | Vtk-based mapper for mitk::Contour |
| Cmitk::CrosshairVtkMapper2D | Vtk-based 2D mapper for rendering a crosshair using vtk mapper |
| Cmitk::DoseImageVtkMapper2D | Mapper to resample and display 2D slices of a 3D image |
| Cmitk::EnhancedPointSetVtkMapper3D | Alternative Vtk-based 3D mapper for mitk::PointSet |
| Cmitk::GizmoMapper2D | |
| Cmitk::ImageVtkMapper2D | Mapper to resample and display 2D slices of a 3D image |
| Cmitk::LabelSetImageVtkMapper2D | Mapper to resample and display 2D slices of a 3D labelset image |
| ►Cmitk::MITKRegistrationWrapperMapperBase | |
| Cmitk::MITKRegistrationWrapperMapper2D | |
| Cmitk::MITKRegistrationWrapperMapper3D | |
| Cmitk::MultiLabelSegmentationVtkMapper3D | Mapper to resample and display 2D slices of a 3D labelset image |
| Cmitk::PlanarFigureVtkMapper3D | |
| Cmitk::PlaneGeometryDataMapper2D | Vtk-based 2D mapper for rendering a crosshair with the plane geometry |
| Cmitk::PlaneGeometryDataVtkMapper3D | Vtk-based mapper to display a PlaneGeometry in a 3D window |
| Cmitk::PointSetVtkMapper2D | Vtk-based 2D mapper for PointSet |
| ►Cmitk::PointSetVtkMapper3D | Vtk-based mapper for PointSet |
| Cmitk::SplineVtkMapper3D | Vtk-based mapper for Splines |
| Cmitk::RegEvaluationMapper2D | Mapper to resample and display 2D slices of registration evaluation visualization |
| Cmitk::ROIMapper2D | |
| Cmitk::ROIMapper3D | |
| Cmitk::SurfaceVtkMapper2D | Vtk-based mapper for cutting 2D slices out of Surfaces |
| Cmitk::SurfaceVtkMapper3D | Vtk-based mapper for Surfaces |
| Cmitk::UnstructuredGridVtkMapper3D | Vtk-based mapper for UnstructuredGrid |
| Cmitk::VolumeMapperVtkSmart3D | Vtk-based mapper for VolumeData |
| Cmitk::VtkGLMapperWrapper | Vtk-based 2D mapper for PointSet |
| Cmitk::MaskedDynamicImageStatisticsGenerator | |
| ►Cmitk::MaskGenerator | Base Class for all Mask Generators. Mask generators are classes that provide functionality for the creation of binary (or unsigned short) masks that can be applied to an image. See derived classes for more information |
| Cmitk::HotspotMaskGenerator | Used when a hotspot has to be found in an image. A hotspot is the region of the image where the mean intensity is maximal (=brightest spot). It is usually used in PET scans. The identification of the hotspot is done as follows: First a cubic (or circular, if image is 2d) mask of predefined size is generated. This mask is then convolved with the input image (in fourier domain). The maximum value of the convolved image then corresponds to the hotspot. If a maskGenerator is set, only the pixels of the convolved image where the corresponding mask is == label are searched for the maximum value |
| Cmitk::IgnorePixelMaskGenerator | Used to generate a mask that is zero for specific pixel values in the input image. This class requires an input image |
| Cmitk::ImageMaskGenerator | |
| Cmitk::MultiLabelMaskGenerator | Class that allows to generate masks (for statistic computation) out of multi label segmentations |
| Cmitk::PlanarFigureMaskGenerator | Derived from MaskGenerator. This class is used to convert a mitk::PlanarFigure into a binary image mask |
| Cmitk::MaskUtilities< TPixel, VImageDimension > | Utility class for mask operations. It checks whether an image and a mask are compatible (spacing, orientation, etc...) and it can also crop an image to the LargestPossibleRegion of the Mask |
| Cmitk::Material | |
| ►Cmitk::ModelBase | Base class for (dynamic) models. A model can be used to calculate its signal given the discrete time grid of the signal and the parameters of the model.
A model has 3 types of parameters:
|
| ►Cmitk::AIFBasedModelBase | Base Class for all physiological perfusion models using an Aterial Input Function All AIF based models come with an array of AIF values and the corresponding TimeGrid ( AIF(t)) This class provides functions for setting the AIF Values and optionally a specific AIF TimeGrid. It also provides a method for interpolation of the AIF source array to a specified Timegrid that differs from AIFTimeGrid. The AIF must be set with an itk::Array. If no AIFTimeGrid is specified with the Setter, it is assumed that the AIFTimeGrid is the same as the ModelTimegrid (e.g. AIF is derived from data set to be fitted). In this case, AIFvalues must have the same length as ModelTimeGrid, otherwise an exception is generated |
| Cmitk::ExtendedOneTissueCompartmentModel | |
| Cmitk::ExtendedToftsModel | Implementation of the Model function of the Tofts pharmacokinetic model, using an Aterial Input Function The Model calculates the Concentration-Time-Curve as a convolution of the plasma curve Cp (the AIF) and a tissue specific residue function (in this case an exponential: R(t) = ktrans * exp(-ktrans/ve * (t)) ). C(t) = vp * Cp(t) + conv(Cp(t),R(t)) The parameters ktrans, ve and ve are subject to the fitting routine |
| Cmitk::OneTissueCompartmentModel | |
| Cmitk::StandardToftsModel | Implementation of the Model function of the Tofts pharmacokinetic model, using an Aterial Input Function The Model calculates the Concentration-Time-Curve as a convolution of the plasma curve Cp (the AIF) and a tissue specific residue function (in this case an exponential: R(t) = ktrans * exp(-ktrans/ve * (t)) ). C(t) = vp * Cp(t) + conv(Cp(t),R(t)) The parameters ktrans, ve and ve are subject to the fitting routine |
| Cmitk::TwoCompartmentExchangeModel | Implementation of the analystical model function of the Physiological Pharmacokinetic Brix model, using an Aterial Input Function The Model calculates the Concentration-Time-Curve as a convolution of the Aterial Input funciton CA(t) and a tissue specific residue function R(t). The Residue funktion consists of two parts: The Residue funktion Qp(t) of the Blood Plasma p and the residue funktion Qi(t) of the interstitial volume I. Ctotal(t) = vp * Cp(t) + fi * Ci(t) = [vp * Qp(t) + fi * Qi(t)] conv CA(t) = Qtotal(t) conv CA(t) where vp=Vp/VT and fi=Vi/VT are the portion of Plasma/interstitial volume Vp/VI of the total volume VT respectively. The Residuefunctions are described by Qp(t) = F/Vp * PS/Vp * 1/(l2 - l1) [ µ2 exp(l1*t) - µ1 exp(l2*t)] sig(t) Qi(t) = F/Vp * PS/Vi * 1/(l1 - l2) [ exp(l1*t) - exp(l2*t)] sig(t) = F/Vp * PS/Vp * vp/fi * 1/(l1 - l2) [ exp(l1*t) - exp(l2*t)] sig(t) with l1/2 = -1/2 (PS/Vp * vp/fi + PS/Vp + F/Vp) +/- sqrt((PS/Vp * vp/fi + PS/Vp + F/Vp)² - 4* F/Vp * PS/Vp * vp/fi) µ1/2 = F/Vp * Vp/PS + 1 + Vp/PS* l1/2 |
| Cmitk::TwoTissueCompartmentFDGModel | |
| Cmitk::TwoTissueCompartmentModel | |
| Cmitk::DescriptivePharmacokineticBrixModel | |
| Cmitk::ExpDecayOffsetModel | Implementation of a general exponential decay model with offset, following the function: y(x) = y-intercept * exp(-rate*x) + baseline |
| Cmitk::ExponentialDecayModel | Simple model of exponential decay in the form of: y(x) = y-intercept * exp(-x/lambda) with lambda being the decay constant |
| Cmitk::ExponentialSaturationModel | This generic model has the form: if x<onset: y(x) = baseline , else: y(x) = baseline + (y_final-baseline) * (1 - exp(-rate*(x-onset))) |
| Cmitk::GenericParamModel | |
| Cmitk::LinearModel | |
| Cmitk::TestModel | |
| Cmitk::ThreeStepLinearModel | |
| Cmitk::TwoStepLinearModel | |
| ►Cmitk::ModelFactoryBase | |
| ►Cmitk::ConcreteModelFactoryBase< DescriptivePharmacokineticBrixModel > | |
| Cmitk::DescriptivePharmacokineticBrixModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< ExpDecayOffsetModel > | |
| Cmitk::ExpDecayOffsetModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< ExponentialDecayModel > | |
| Cmitk::ExponentialDecayModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< ExponentialSaturationModel > | |
| Cmitk::ExponentialSaturationModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< ExtendedOneTissueCompartmentModelParameterizer ::ModelType > | |
| ►Cmitk::ConcreteAIFBasedModelFactory< ExtendedOneTissueCompartmentModelParameterizer > | |
| Cmitk::ExtendedOneTissueCompartmentModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< ExtendedToftsModelParameterizer ::ModelType > | |
| ►Cmitk::ConcreteAIFBasedModelFactory< ExtendedToftsModelParameterizer > | |
| Cmitk::ExtendedToftsModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< GenericParamModel > | |
| Cmitk::GenericParamModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< LinearModel > | |
| Cmitk::LinearModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< OneTissueCompartmentModelParameterizer ::ModelType > | |
| ►Cmitk::ConcreteAIFBasedModelFactory< OneTissueCompartmentModelParameterizer > | |
| Cmitk::OneTissueCompartmentModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< StandardToftsModelParameterizer ::ModelType > | |
| ►Cmitk::ConcreteAIFBasedModelFactory< StandardToftsModelParameterizer > | |
| Cmitk::StandardToftsModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< TestModel > | |
| Cmitk::TestModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< ThreeStepLinearModel > | |
| Cmitk::ThreeStepLinearModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< TModelParameterizer::ModelType > | |
| ►Cmitk::ConcreteAIFBasedModelFactory< TModelParameterizer > | |
| Cmitk::TwoCompartmentExchangeModelFactoryBase< TModelParameterizer > | |
| Cmitk::TwoTissueCompartmentModelFactoryBase< TModelParameterizer > | |
| ►Cmitk::ConcreteModelFactoryBase< TwoCompartmentExchangeModelParameterizer ::ModelType > | |
| ►Cmitk::ConcreteAIFBasedModelFactory< TwoCompartmentExchangeModelParameterizer > | |
| ►Cmitk::TwoCompartmentExchangeModelFactoryBase< TwoCompartmentExchangeModelParameterizer > | |
| Cmitk::TwoCompartmentExchangeModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< TwoStepLinearModel > | |
| Cmitk::TwoStepLinearModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< TwoTissueCompartmentFDGModelParameterizer ::ModelType > | |
| ►Cmitk::ConcreteAIFBasedModelFactory< TwoTissueCompartmentFDGModelParameterizer > | |
| Cmitk::TwoTissueCompartmentFDGModelFactory | |
| ►Cmitk::ConcreteModelFactoryBase< TwoTissueCompartmentModelParameterizer ::ModelType > | |
| ►Cmitk::ConcreteAIFBasedModelFactory< TwoTissueCompartmentModelParameterizer > | |
| ►Cmitk::TwoTissueCompartmentModelFactoryBase< TwoTissueCompartmentModelParameterizer > | |
| Cmitk::TwoTissueCompartmentModelFactory | |
| Cmitk::ConcreteModelFactoryBase< TModel > | |
| ►Cmitk::ModelFitFunctorBase | |
| Cmitk::DummyModelFitFunctor | |
| Cmitk::LevenbergMarquardtModelFitFunctor | |
| ►Cmitk::ModelParameterizerBase | |
| ►Cmitk::ConcreteModelParameterizerBase< GenericParamModel > | |
| Cmitk::GenericParamModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::DescriptivePharmacokineticBrixModel > | |
| Cmitk::DescriptivePharmacokineticBrixModelParameterizer | |
| Cmitk::DescriptivePharmacokineticBrixModelValueBasedParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::ExpDecayOffsetModel > | |
| Cmitk::ExpDecayOffsetModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::ExponentialDecayModel > | |
| Cmitk::ExponentialDecayModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::ExponentialSaturationModel > | |
| Cmitk::ExponentialSaturationModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::ExtendedOneTissueCompartmentModel > | |
| ►Cmitk::AIFBasedModelParameterizerBase< mitk::ExtendedOneTissueCompartmentModel > | |
| Cmitk::ExtendedOneTissueCompartmentModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::ExtendedToftsModel > | |
| ►Cmitk::AIFBasedModelParameterizerBase< mitk::ExtendedToftsModel > | |
| Cmitk::ExtendedToftsModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::OneTissueCompartmentModel > | |
| ►Cmitk::AIFBasedModelParameterizerBase< mitk::OneTissueCompartmentModel > | |
| Cmitk::OneTissueCompartmentModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::StandardToftsModel > | |
| ►Cmitk::AIFBasedModelParameterizerBase< mitk::StandardToftsModel > | |
| Cmitk::StandardToftsModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::ThreeStepLinearModel > | |
| Cmitk::ThreeStepLinearModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::TwoCompartmentExchangeModel > | |
| ►Cmitk::AIFBasedModelParameterizerBase< mitk::TwoCompartmentExchangeModel > | |
| Cmitk::TwoCompartmentExchangeModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::TwoStepLinearModel > | |
| Cmitk::TwoStepLinearModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::TwoTissueCompartmentFDGModel > | |
| ►Cmitk::AIFBasedModelParameterizerBase< mitk::TwoTissueCompartmentFDGModel > | |
| Cmitk::TwoTissueCompartmentFDGModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< mitk::TwoTissueCompartmentModel > | |
| ►Cmitk::AIFBasedModelParameterizerBase< mitk::TwoTissueCompartmentModel > | |
| Cmitk::TwoTissueCompartmentModelParameterizer | |
| ►Cmitk::ConcreteModelParameterizerBase< TAIFBasedModel > | |
| Cmitk::AIFBasedModelParameterizerBase< TAIFBasedModel > | |
| Cmitk::ConcreteModelParameterizerBase< TModel > | |
| Cmitk::ModelSignalImageGenerator | |
| ►Cmitk::NodePredicateBase | Interface for evaluation conditions used in the DataStorage class GetSubset() method |
| ►Cmitk::NodePredicateCompositeBase | Base class for all predicates that can have child predicates (e.g. AND/OR) |
| Cmitk::NodePredicateAnd | Composite predicate that forms a logical AND relation from its child predicates |
| Cmitk::NodePredicateNot | Composite predicate that negates its child predicate Changed: NodePredicateNot now derives from NodePredicateCompositeBase though it really holds only one subpredicate at any time. But logically any Predicate that has one or more subpredicate is a CompositePredicate |
| Cmitk::NodePredicateOr | Composite predicate that forms a logical OR relation from its child predicates |
| Cmitk::NodePredicateData | Predicate that evaluates if the given DataNodes data object pointer equals a given pointer |
| Cmitk::NodePredicateDataProperty | Predicate that evaluates if the data of a given DataNode has a specific property. If the second parameter is nullptr, it will only be checked whether there is a property with the specified name for the data instance of the node |
| Cmitk::NodePredicateDataType | Predicate that evaluates if the given DataNodes data object is of a specific data type |
| Cmitk::NodePredicateDataUID | Predicate that compares the data UID of the given DataNode to a specific UID |
| Cmitk::NodePredicateDimension | Predicate that evaluates if the given DataNodes data object has the specified dimension, for datasets where dimension is applicable |
| Cmitk::NodePredicateFunction | Predicate that transfers the check to a specific Callable |
| Cmitk::NodePredicateGeometry | Predicate that evaluates if the given DataNode's data object has the same geometry (in terms of spacing, origin, orientation) like the reference geometry |
| Cmitk::NodePredicateProperty | Predicate that evaluates if the given DataNode has a specific property. If the second parameter is nullptr, it will only be checked whether there is a property with the specified name. If a renderer is specified in the third parameter the renderer-specific property will be checked. If this parameter is nullptr or not specified, then the non-renderer-specific property will be checked |
| Cmitk::NodePredicateSubGeometry | Predicate that evaluates if the given DataNode's data object has a geometry that is a sub geometry of the reference geometry. Sub geometry means that both geometries have the same voxel grid (same spacing, same axes, origin is on voxel grid), but the bounding box of the checked geometry is contained or equal to the bounding box of the reference geometry.
One can either check the whole time geometry of the data node by defining a reference time geometry or check against one given2 reference base geometry. If the predicate should check against a base geometry, you can specify the timepoint of the data's time geometry that should be checked. If no timepoint is defined the predicate will evaluate the data geometry in the first timestep. Evaluates to "false" for unsupported or undefined data objects/geometries |
| Cmitk::TNodePredicateDataType< T > | Tests for type compatibility (dynamic_cast) |
| ►Cmitk::NonBlockingAlgorithm | |
| ►Cmitk::SegmentationSink | |
| Cmitk::CalculateSegmentationVolume | |
| Cmitk::LabelSetImageToSurfaceThreadedFilter | |
| Cmitk::ShowSegmentationAsSmoothedSurface | |
| Cmitk::ShowSegmentationAsSurface | |
| ►Cmitk::ParameterFitImageGeneratorBase | |
| Cmitk::PixelBasedParameterFitImageGenerator | |
| Cmitk::ROIBasedParameterFitImageGenerator | |
| Cmitk::PlotDataCurve | |
| Cmitk::PointLocator | |
| Cmitk::PointSetDifferenceStatisticsCalculator | Class for calculating the difference between two corresponding point sets. The user can access the single distances between corresponding points as well as a complete statistic (mean, sd, rms, median, max, min) The point sets must be of equal size! |
| Cmitk::PointSetStatisticsCalculator | Class for calculating statistics (like standard derivation, RMS, mean, etc.) for a PointSet |
| ►Cmitk::ProcessExecutor | You may register an observer for an ExternalProcessOutputEvent, ExternalProcessStdOutEvent or ExternalProcessStdErrEvent in order to get notified of any output |
| Cmitk::SegmentAnythingProcessExecutor | You may register an observer for an ExternalProcessOutputEvent, ExternalProcessStdOutEvent or ExternalProcessStdErrEvent in order to get notified of any output |
| Cmitk::ProgressBar | Sending a message to the applications ProgressBar |
| ►Cmitk::PropertyList | Key-value list holding instances of BaseProperty |
| Cmitk::Label | A data structure describing a label |
| ►Cmitk::PropertyListDeserializer | Deserializes a mitk::PropertyList |
| Cmitk::PropertyListDeserializerV1 | Deserializes a mitk::PropertyList |
| Cmitk::PropertyListSerializer | Serializes a mitk::PropertyList |
| Cmitk::PropertyListsXmlFileReaderAndWriter | |
| ►Cmitk::PropertyRelationRuleBase | |
| ►Cmitk::GenericIDRelationRule | |
| Cmitk::StatisticsToImageRelationRule | |
| Cmitk::StatisticsToMaskRelationRule | |
| ►Cmitk::SourceImageRelationRule | |
| Cmitk::ModelFitResultRelationRule | |
| Cmitk::ReferenceCountWatcher | Keeps track of the reference count of an object even if it is destroyed |
| ►Cmitk::RenderingManager | Manager for coordinating the rendering process |
| Cmitk::TestingRenderingManager | |
| CQmitkRenderingManager | Qt specific implementation of mitk::RenderingManager |
| Cmitk::RenderWindow | MitkRenderWindow integrates the MITK rendering mechanism into VTK and is NOT QT dependent |
| Cmitk::RenderWindowFrame | |
| Cmitk::SceneIO | |
| ►Cmitk::SceneReader | |
| Cmitk::SceneReaderV1 | |
| Cmitk::SegmentAnythingPythonService | Segment Anything Model Python process handler class |
| ►Cmitk::SegmentationInterpolationAlgorithm | Interface class for interpolation algorithms |
| Cmitk::ShapeBasedInterpolationAlgorithm | Shape-based binary image interpolation |
| Cmitk::SegmentationInterpolationController | Generates interpolations of 2D slices |
| ►Cmitk::SimpleFunctorBase | |
| Cmitk::CurveParameterFunctor | |
| Cmitk::ModelDataGenerationFunctor | |
| Cmitk::StandardFileLocations | Provides a method to look for configuration and option files etc |
| Cmitk::StatusBar | Sending a message to the applications StatusBar |
| ►Cmitk::Stepper | Helper class to step through a list |
| Cmitk::MultiStepper | Helper class to step through a list |
| Cmitk::SurfaceInterpolationController | |
| Cmitk::TimeFramesRegistrationHelper | |
| ►Cmitk::TimeGeometry | |
| Cmitk::ArbitraryTimeGeometry | |
| Cmitk::ProportionalTimeGeometry | |
| Cmitk::ToolManager | Manages and coordinates instances of mitk::Tool |
| Cmitk::TransferFunction | A wrapper class for VTK scalar opacity, gradient opacity, and color transfer functions |
| Cmitk::TransferFunctionInitializer | Wrapper class for VTK scalar opacity, gradient opacity, and color transfer functions |
| ►Cmitk::UndoModel | Superclass for all UndoModels |
| ►Cmitk::LimitedLinearUndo | A linear undo model with one undo and one redo stack |
| Cmitk::VerboseLimitedLinearUndo | A limited linear undo model providing GUI elements with stack status information |
| Cmitk::VideoSource | |
| Cmitk::VolumeCalculator | Calculates the volume of a mitk::Image. The given volume is in milliliters or as a voxel count. Voxels are counted if their gray value is above a threshold (see SetThreshold), the default threshold is 0 |
| Cmitk::WeightedPointTransform | This class implements an extension of the weighted point based registration algorithm from A. Danilchenko, R. Balachandran and J. M. Fitzpatrick |
| ►CQmitkToolGUI | Base class for GUIs belonging to mitk::Tool classes |
| ►CQmitkEditableContourToolGUIBase | GUI for mitk::EditableContourTool based classes |
| CQmitkLassoToolGUI | GUI for mitk::NewAddTool |
| CQmitkLiveWireTool2DGUI | GUI for mitk::LiveWireTool |
| ►CQmitkPaintbrushToolGUI | GUI for mitk::PaintbrushTool |
| CQmitkDrawPaintbrushToolGUI | GUI for mitk::PaintbrushTool |
| CQmitkErasePaintbrushToolGUI | GUI for mitk::PaintbrushTool |
| ►CQmitkSegWithPreviewToolGUIBase | GUI base clase for tools derived from mitk::SegWithPreviewTool |
| ►CQmitkBinaryThresholdToolGUIBase | Base GUI for mitk::BinaryThresholdTool |
| CQmitkBinaryThresholdToolGUI | GUI for mitk::BinaryThresholdTool |
| CQmitkBinaryThresholdULToolGUI | GUI for mitk::BinaryThresholdTool |
| CQmitkMedSAMToolGUI | GUI for mitk::MedSAMTool |
| ►CQmitkMultiLabelSegWithPreviewToolGUIBase | GUI for tools based on mitk::AutoMLSegmentationWithPreviewTool |
| CQmitkGrowCutToolGUI | GUI for mitk::GrowCutTool |
| ►CQmitkMonaiLabelToolGUI | |
| CQmitkMonaiLabel2DToolGUI | |
| CQmitkMonaiLabel3DToolGUI | |
| CQmitknnUNetToolGUI | |
| CQmitkOtsuTool3DGUI | GUI for mitk::OtsuTool3D |
| CQmitkTotalSegmentatorToolGUI | GUI for mitk::TotalSegmentatorTool |
| CQmitkPickingToolGUI | GUI for mitk::PickingTool |
| CQmitkSegmentAnythingToolGUI | GUI for mitk::SegmentAnythingTool |
| ►CObjectFactoryBase | |
| Cmitk::ImageWriterFactory | |
| Cmitk::ItkImageFileIOFactory | Create instances of ItkImageFileReader objects using an object factory |
| Cmitk::LookupTablePropertySerializerFactory | |
| Cmitk::PointSetIOFactory | Create instances of PointSetReader objects using an object factory |
| Cmitk::PointSetWriterFactory | |
| Cmitk::STLFileIOFactory | Create instances of STLFileReader objects using an object factory |
| Cmitk::SurfaceVtkWriterFactory | |
| Cmitk::VtiFileIOFactory | Create instances of VtiFileReader objects using an object factory |
| Cmitk::VtkImageIOFactory | Create instances of VtkImageReader objects using an object factory |
| Cmitk::VtkSurfaceIOFactory | Create instances of VtkSurfaceReader objects using an object factory |
| ►COutputWindow | |
| Cmitk::ItkLoggingAdapter | Adapter that overwrites the standard itk logging output window and sends the logging messages to the MITK |
| ►CPoint | |
| Cmitk::Point< TCoordRep, NPointDimension > | |
| Cmitk::Point< int, 2 > | |
| Cmitk::Point< ScalarType, 2 > | |
| Cmitk::Point< ScalarType, 3 > | |
| ►CProcessObject | |
| Citk::Statistics::EnhancedHistogramToNeighbourhoodGreyLevelDifferenceFeaturesFilter< THistogram > | This class computes texture feature coefficients from a grey level Zone-length matrix |
| Citk::Statistics::EnhancedHistogramToRunLengthFeaturesFilter< THistogram > | This class computes texture feature coefficients from a grey level run-length matrix |
| Citk::Statistics::EnhancedHistogramToSizeZoneFeaturesFilter< THistogram > | This class computes texture feature coefficients from a grey level Zone-length matrix |
| Citk::Statistics::EnhancedHistogramToTextureFeaturesFilter< THistogram > | This class computes texture feature coefficients from a grey level co-occurrence matrix |
| Citk::Statistics::EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceFeaturesFilter< TImageType, THistogramFrequencyContainer > | This class computes run length descriptions from an image |
| Citk::Statistics::EnhancedScalarImageToNeighbourhoodGreyLevelDifferenceMatrixFilter< TImageType, THistogramFrequencyContainer > | This class computes a run length matrix (histogram) from a given image and a mask image if provided. Run length matrces are used for image texture description |
| Citk::Statistics::EnhancedScalarImageToRunLengthFeaturesFilter< TImageType, THistogramFrequencyContainer > | This class computes run length descriptions from an image |
| Citk::Statistics::EnhancedScalarImageToRunLengthMatrixFilter< TImageType, THistogramFrequencyContainer > | This class computes a run length matrix (histogram) from a given image and a mask image if provided. Run length matrces are used for image texture description |
| Citk::Statistics::EnhancedScalarImageToSizeZoneFeaturesFilter< TImageType, THistogramFrequencyContainer > | This class computes run length descriptions from an image |
| Citk::Statistics::EnhancedScalarImageToSizeZoneMatrixFilter< TImageType, THistogramFrequencyContainer > | This class computes a run length matrix (histogram) from a given image and a mask image if provided. Run length matrces are used for image texture description |
| Citk::Statistics::EnhancedScalarImageToTextureFeaturesFilter< TImageType, THistogramFrequencyContainer > | This class computes texture descriptions from an image |
| ►Cmitk::BaseDataSource | Superclass of all classes generating some kind of mitk::BaseData |
| Cmitk::ContourModelSetSource | Superclass of all classes generating ContourModels |
| ►Cmitk::ContourModelSource | Superclass of all classes generating ContourModels |
| Cmitk::ContourModelSubDivisionFilter | This filter interpolates a subdivision curve between control points of the contour. For inserting subpoints Dyn-Levin-Gregory (DLG) interpolation scheme is used. Interpolating a cruve subdivision is done by: F2i = Ci F2i+1 = -1/16Ci-1 + 9/16Ci + 9/16Ci+1 - 1/16Ci+2 |
| Cmitk::ImageLiveWireContourModelFilter | Calculates a LiveWire contour between two points in an image |
| Cmitk::ImageToContourModelFilter | Base class for all filters with mitk::Image as input and mitk::ContourModel |
| ►Cmitk::GeometryDataSource | Superclass of all classes generating GeometryData (instances of class GeometryData) as output |
| Cmitk::PlaneFit | |
| ►Cmitk::ImageSource | Superclass of all classes generating Images (instances of class Image) as output |
| Cmitk::ContourModelSetToImageFilter | Fills a given mitk::ContourModelSet into a given mitk::Image |
| Cmitk::CreateDistanceImageFromSurfaceFilter | This filter interpolates the 3D surface for a segmented area. The basis for the interpolation are the edge-points of contours that are drawn into an image |
| ►Cmitk::ImageToImageFilter | Superclass of all classes having one or more Images as input and generating Images as output |
| Cmitk::BilateralFilter | |
| Cmitk::BinaryImageToLabelSetImageFilter | Converts an binary image to a LabelSetImage. The amount of labels equals the connected components |
| ►Cmitk::BoundingObjectCutter | Cuts an Boundingobject out of an mitk Image |
| Cmitk::BoundingObjectCutAndCast< TPixel > | Cuts an Boundingobject out of an mitk Image |
| Cmitk::BoundingObjectToSegmentationFilter | |
| Cmitk::BoundingShapeCropper | Crops or masks an Boundingbox defined by GeometryData out of an mitk Image |
| Cmitk::CESTImageNormalizationFilter | Normalization filter for CEST images |
| Cmitk::CompareImageDataFilter | Filter for comparing two mitk::Image objects by pixel values |
| Cmitk::Convert2Dto3DImageFilter | Image Filter to convert 2D MITK images to 3D MITK images |
| Cmitk::CorrectorAlgorithm | |
| Cmitk::ExtractDirectedPlaneImageFilter | Extracts a 2D slice of arbitrary geometry from a 3D or 4D image |
| Cmitk::ExtractDirectedPlaneImageFilterNew | A filter that can extract a 2D slice from a 3D or 4D image especially if the image`s axes are rotated |
| Cmitk::ExtractImageFilter | Extracts a 2D slice from a 3D image |
| Cmitk::ExtractSliceFilter | ExtractSliceFilter extracts a 2D arbitrary oriented slice from a 3D volume |
| Cmitk::ExtractSliceFilter2 | Extract an arbitrarily oriented 2-d image from a 3-d image |
| Cmitk::GeometryClipImageFilter | Filter for clipping an image with a PlaneGeometry |
| Cmitk::GrowCutSegmentationFilter | A filter that performs a growcut image segmentation |
| Cmitk::HeightFieldSurfaceClipImageFilter | Filter for clipping an image with an height-field represented by an mitk::Surface |
| Cmitk::LabelSetImageSurfaceStampFilter | |
| Cmitk::MaskAndCutRoiImageFilter | Cuts a region of interest (ROI) out of an image |
| Cmitk::MaskImageFilter | |
| Cmitk::MRNormLinearStatisticBasedFilter | |
| Cmitk::MRNormTwoRegionsBasedFilter | |
| Cmitk::MultiComponentImageDataComparisonFilter | Filter for comparing two multi channel mitk::Image objects by channel wise by pixel values |
| Cmitk::OtsuSegmentationFilter | A filter that performs a multiple threshold otsu image segmentation |
| Cmitk::PadImageFilter | PadImageFilter class pads the first input image to the size of the second input image. Two Images have to be set. The first image is the image to pad. The second image defines the pad size. It is also possible to use an included binary filter |
| Cmitk::RandomImageSampler | |
| Cmitk::RGBToRGBACastImageFilter | |
| ►Cmitk::SubImageSelector | Base class of all classes providing access to parts of an image |
| Cmitk::AutoCropImageFilter | Shrink the image borders to a minimum considering a background color |
| Cmitk::CropTimestepsImageFilter | Crops timesteps at 2D+t and 3D+t images |
| Cmitk::ImageChannelSelector | Provides access to a channel of the input image |
| Cmitk::ImageSliceSelector | Provides access to a slice of the input image |
| Cmitk::ImageTimeSelector | Provides access to a volume at a specific time of the input image |
| Cmitk::SurfaceStampImageFilter | Converts surface data to pixel data. Requires a surface and an image, which header information defines the output image |
| Cmitk::TemporalJoinImagesFilter | |
| Cmitk::ItkImageFileReader | Reader to read file formats supported by itk |
| Cmitk::ITKImageImport< TInputImage > | Pipelined import of itk::Image |
| Cmitk::LabelSetImageSource | Superclass of all classes generating labelset images (instances of class LabelSetImage) as output |
| Cmitk::RawImageFileReader | Reader to read raw image files |
| Cmitk::SurfaceToImageFilter | Converts surface data to pixel data. Requires a surface and an image, which header information defines the output image |
| Cmitk::VtiFileReader | Reader to read image files in vtk file format |
| Cmitk::VtkImageReader | Reader to read image files in vtk file format |
| ►Cmitk::PlanarFigureSource | Base class for all filters which have an object of type mitk::PlanarFigure as output |
| Cmitk::ImageToPlanarFigureFilter | Superclass of all classes having one or more Images as input and generating PlanarFigures as output |
| Cmitk::PlanarFigureToPlanarFigureFilter | Base class for all filters which have an object of type mitk::PlanarFigure as input and output |
| ►Cmitk::PointSetSource | Superclass of all classes generating point sets (instances of class mitk::PointSet) as output |
| Cmitk::ContourModelToPointSetFilter | Converts a contour set to a point set |
| Cmitk::ContourSetToPointSetFilter | Converts a contour set to a point set |
| Cmitk::PointSetReader | Reads xml representations of mitk::PointSets from a file |
| Cmitk::PointSetToPointSetFilter | Superclass of all classes/algorithms having one or more PointSets as input and output |
| Cmitk::SurfaceToPointSetFilter | This filter converts the input surface into a point set. The output point set contains every point exactly one time (no duplicated points like in the stl-format) |
| ►Cmitk::SurfaceSource | Superclass of all classes generating surfaces (instances of class Surface) as output |
| Cmitk::ContourModelToSurfaceFilter | |
| ►Cmitk::ImageToSurfaceFilter | Converts pixel data to surface data by using a threshold The mitkImageToSurfaceFilter is used to create a new surface out of an mitk image. The filter uses a threshold to define the surface. It is based on the vtkMarchingCube algorithm. By default a vtkPolyData surface based on an input threshold for the input image will be created. Optional it is possible to reduce the number of triangles/polygones [SetDecimate(mitk::ImageToSurfaceFilter::DecimatePro) and SetTargetReduction (float _arg)] or smooth the surface-data [SetSmooth(true), SetSmoothIteration(int smoothIteration) and SetSmoothRelaxation(float smoothRelaxation)] |
| Cmitk::ImageToContourFilter | A filter that can extract contours out of a 2D binary image |
| Cmitk::LabeledImageToSurfaceFilter | |
| Cmitk::ManualSegmentationToSurfaceFilter | Supplies a 3D surface from pre-processed segmentation |
| Cmitk::LabelSetImageToSurfaceFilter | |
| Cmitk::PlaneGeometryDataToSurfaceFilter | Superclass of all classes having a PlaneGeometryData as input and generating Images as output |
| Cmitk::STLFileReader | Reader to read files in stl-format |
| ►Cmitk::SurfaceToSurfaceFilter | Superclass of all classes getting surfaces (instances of class Surface) as input and generating surfaces as output |
| Cmitk::ComputeContourSetNormalsFilter | Filter to compute the normales for contours based on vtkPolygons |
| Cmitk::ReduceContourSetFilter | A filter that reduces the number of points of contours represented by a mitk::Surface |
| Cmitk::RemeshFilter | Encapsulates mitk::Remesh function as filter |
| Cmitk::VtkSurfaceReader | Reader to read surface files in vtk-format |
| ►Cmitk::UnstructuredGridSource | Superclass of all classes generating unstructured grids (instances of class UnstructuredGrid) as output |
| ►Cmitk::ImageToUnstructuredGridFilter | Converts an Image into an UnstructuredGrid represented by Points. The filter uses a Threshold to extract every pixel, with value higher than the threshold, as point. If no threshold is set, every pixel is extracted as a point |
| Cmitk::ImageToPointCloudFilter | The filter extracts the edge pixels of an image as points and stores them in an UnstructuredGrid. Every pixel which grey value is between the mean +- standard deviation * (2 or 3), will be extracted as point. The DetectionMethod can be set to choose if the doubled or tripled standard deviation is used |
| ►Cmitk::UnstructuredGridToUnstructuredGridFilter | |
| Cmitk::UnstructuredGridClusteringFilter | This filter uses the DBSCAN algorithm for clustering an mitk::UnstructuredGrid. "MinPts" defines the number of neighbours which are required to be a kernel point if a point is in range of a kernel point but hasn't enough neighbours this point is added to the cluster but is a density reachable point and the cluster ends at this point. "eps" is the range in which the neighbours are searched. If "Meshing" is set the clusteres UnstructuredGrid is meshed and visible in 2D renderwindows |
| Cmitk::DataNodeSource | Superclass of all classes generating data tree nodes (instances of class mitk::DataNode) as output |
| Cmitk::ExtrudePlanarFigureFilter | |
| ►Cmitk::FileWriter | Interface class of writers that write data to files |
| ►Cmitk::FileWriterWithInformation | Interface for FileWriters with extra information. Should be merged into FileWriter |
| Cmitk::ImageWriter | Writer for mitk::Image |
| Cmitk::SurfaceVtkWriter< VTKWRITER > | VTK-based writer for mitk::Surface |
| Cmitk::PointSetWriter | XML-based writer for mitk::PointSets |
| Cmitk::LookupTableSource | Base class for all objects which have an object of type mitkLookupTable as output |
| Citk::ShortestPathImageFilter< TInputImageType, TOutputImageType >::CompareNodeStar | |
| Citk::ShortestPathNode | |
| ►CSingleValuedCostFunction | |
| ►Cmitk::SVModelFitCostFunction | |
| Cmitk::ChiSquareFitCostFunction | |
| Cmitk::NormalizedSumOfSquaredDifferencesFitCostFunction | |
| Cmitk::ReducedChiSquareFitCostFunction | |
| Cmitk::SumOfSquaredDifferencesFitCostFunction | |
| Citk::SmartPointer< T > | |
| Citk::SquaredEuclideanMetric< TPixelType > | |
| ►CTransform | |
| Citk::VtkAbstractTransform< TScalarType > | Adapter from vtkAbstractTransform to itk::Transform<TScalarType, 3, 3> |
| Citk::VtkAbstractTransform< ScalarType > | |
| Citk::TransformIOFactoryRegisterManager | |
| Citk::VariableLengthVector< TValueType > | |
| ►CVector | |
| Cmitk::Vector< TCoordRep, NVectorDimension > | |
| Cmitk::Vector< ScalarType, 2 > | |
| Cmitk::Vector< ScalarType, 3 > | |
| CitkIntelligentBinaryClosingFilter | |
| ►CITKAffineMattesMIMultiResRegistrationAlgorithm | |
| Cmitk::MultiModalAffineDefaultRegistrationAlgorithm< TImageType > | |
| ►CITKEuler3DMattesMIMultiResRegistrationAlgorithm | |
| Cmitk::MultiModalRigidDefaultRegistrationAlgorithm< TImageType > | |
| ►CITKTransMattesMIMultiResRegistrationAlgorithm | |
| Cmitk::MultiModalTranslationDefaultRegistrationAlgorithm< TImageType > | |
| Cmap::algorithm::mitkFastSymmetricForcesDemonsMultiResDefaultRegistrationAlgorithmUIDPolicy | |
| Cmap::algorithm::mitkLevelSetMotionMultiResDefaultRegistrationAlgorithmUIDPolicy | |
| Cmap::algorithm::mitkMultiModalAffineDefaultRegistrationAlgorithmUIDPolicy | |
| Cmap::algorithm::mitkMultiModalRigidDefaultRegistrationAlgorithmUIDPolicy | |
| Cmap::algorithm::mitkMultiModalRigidHeadNeckRegistrationAlgorithmUIDPolicy | |
| Cmap::algorithm::mitkMultiModalRigidSlabbedHeadRegistrationAlgorithmUIDPolicy | |
| Cmap::algorithm::mitkMultiModalTransDefaultRegistrationAlgorithmUIDPolicy | |
| Cmap::algorithm::mitkRigidClosedFormPointsDefaultRegistrationAlgorithmUIDPolicy | |
| Cmap::algorithm::mitkRigidICPDefaultRegistrationAlgorithmUIDPolicy | |
| CMaskImageFilter | Mask an image with a mask |
| CMatchPointBrowserConstants | Structure to define a namespace for constants used privately within this view |
| Cberry::Message1< const IJobChangeEvent::ConstPointer & > | |
| Cberry::Message1< const IWorkbenchPartReference::Pointer & > | |
| Cberry::Message1< const IWorkbenchWindow::Pointer & > | |
| Cberry::Message1< const Object * > | |
| Cberry::Message1< const PropertyChangeEvent::Pointer & > | |
| Cberry::Message1< const QList< berry::SmartPointer< berry::IExtension > > & > | |
| Cberry::Message1< const QList< berry::SmartPointer< berry::IExtensionPoint > > & > | |
| Cberry::Message1< const SaveablesLifecycleEvent::Pointer & > | |
| Cberry::Message1< const SelectionChangedEvent::Pointer & > | |
| Cberry::Message1< const ShellEvent::Pointer & > | |
| Cberry::Message1< const SmartPointer< const CommandCategoryEvent > & > | |
| Cberry::Message1< const SmartPointer< const CommandEvent > & > | |
| Cberry::Message1< const SmartPointer< const CommandManagerEvent > & > | |
| Cberry::Message1< const SmartPointer< const ParameterTypeEvent > & > | |
| Cberry::Message1< const SmartPointer< HandlerEvent > & > | |
| Cberry::Message1< ControlEvent::Pointer > | |
| Cberry::Message1< IWorkbench * > | |
| Cberry::Message1< QDragEnterEvent * > | |
| Cberry::Message1< QDragLeaveEvent * > | |
| Cberry::Message1< QDragMoveEvent * > | |
| Cberry::Message1< QDropEvent * > | |
| Cberry::Message1< SelectionEvent::Pointer > | |
| Cberry::Message2< const berry::SmartPointer< berry::IWorkbenchPage > &, const IPerspectiveDescriptor::Pointer & > | |
| Cberry::Message2< const IWorkbenchPart::Pointer &, const ISelection::ConstPointer & > | |
| Cberry::Message2< const QString &, const berry::SmartPointer & > | |
| Cberry::Message2< const QString &, const berry::SmartPointer< const berry::ExecutionEvent > & > | |
| Cberry::Message2< const QString &, const ExecutionException * > | |
| Cberry::Message2< const QString &, const NotDefinedException * > | |
| Cberry::Message2< const QString &, const NotEnabledException * > | |
| Cberry::Message2< const QString &, const NotHandledException * > | |
| Cberry::Message2< const SmartPointer< State > &, const SmartPointer< Object > & > | |
| Cberry::Message2< int, const QHash< QString, berry::SmartPointer > & > | |
| Cberry::Message2< IWorkbench *, bool, bool > | |
| Cberry::Message2< IWorkbenchPart::Pointer, ISelection::ConstPointer > | |
| Cberry::Message2< unsigned int, const Object * > | |
| Cberry::Message3< const berry::SmartPointer< berry::IWorkbenchPage > &, const IPerspectiveDescriptor::Pointer &, const IPerspectiveDescriptor::Pointer & > | |
| Cberry::Message3< const berry::SmartPointer< berry::IWorkbenchPage > &, const IPerspectiveDescriptor::Pointer &, const QString & > | |
| Cberry::Message3< int, const QString &, berry::SmartPointer > | |
| Cberry::Message3< unsigned int, bool, const Object * > | |
| Cberry::Message4< const berry::SmartPointer< berry::IWorkbenchPage > &, const IPerspectiveDescriptor::Pointer &, const berry::SmartPointer< berry::IWorkbenchPartReference > &, const QString & > | |
| Cmitk::MessageAbstractDelegate1< bool, void > | |
| Cmitk::MessageAbstractDelegate1< const bool, void > | |
| Cmitk::MessageAbstractDelegate1< const DataNode *, void > | |
| Cmitk::MessageAbstractDelegate1< const mitk::DataNode *, void > | |
| Cmitk::MessageAbstractDelegate1< const mitk::IPreferences *, void > | |
| Cmitk::MessageAbstractDelegate1< const mitk::IPreferences::ChangeEvent &, void > | |
| Cmitk::MessageAbstractDelegate1< const mitk::Point &, void > | |
| Cmitk::MessageAbstractDelegate1< const std::string &, void > | |
| Cmitk::MessageAbstractDelegate1< DataVectorType *, void > | |
| Cmitk::MessageAbstractDelegate1< float, void > | |
| Cmitk::MessageAbstractDelegate1< int, void > | |
| Cmitk::MessageAbstractDelegate1< std::string, void > | |
| ►Cberry::MessageAbstractDelegate1< T, void > | |
| Cberry::MessageDelegate1< R, T, A > | |
| ►Cmitk::MessageAbstractDelegate1< T, void > | |
| Cmitk::MessageDelegate1< R, T, A > | |
| Cmitk::MessageAbstractDelegate2< const mitk::DataNode *, const mitk::BaseProperty *, void > | |
| Cmitk::MessageAbstractDelegate2< ScalarType, ScalarType, void > | |
| ►Cberry::MessageAbstractDelegate2< T, U, void > | |
| Cberry::MessageDelegate2< R, T, U, A > | |
| Cmitk::MessageAbstractDelegate2< T, U, void > | |
| Cmitk::MessageAbstractDelegate3< double, double, bool, void > | |
| ►Cberry::MessageAbstractDelegate3< T, U, V, void > | |
| Cberry::MessageDelegate3< R, T, U, V, A > | |
| ►Cmitk::MessageAbstractDelegate3< T, U, V, void > | |
| Cmitk::MessageDelegate3< R, T, U, V, A > | |
| Cmitk::MessageAbstractDelegate4< T, U, V, W > | |
| ►Cberry::MessageAbstractDelegate4< T, U, V, W, void > | |
| Cberry::MessageDelegate4< R, T, U, V, W, A > | |
| ►Cmitk::MessageAbstractDelegate4< T, U, V, W, void > | |
| Cmitk::MessageDelegate4< R, T, U, V, W, A > | |
| ►Cberry::MessageAbstractDelegate< void > | |
| Cberry::MessageDelegate< R, A > | |
| ►Cmitk::MessageAbstractDelegate< void > | |
| Cmitk::MessageDelegate< R, A > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< bool, void > > | |
| Cmitk::Message1< bool > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< const bool, void > > | |
| Cmitk::Message1< const bool > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< const DataNode *, void > > | |
| Cmitk::Message1< const DataNode * > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< const mitk::DataNode *, void > > | |
| Cmitk::Message1< const mitk::DataNode * > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< const mitk::IPreferences *, void > > | |
| Cmitk::Message1< const mitk::IPreferences * > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< const mitk::IPreferences::ChangeEvent &, void > > | |
| Cmitk::Message1< const mitk::IPreferences::ChangeEvent & > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< const mitk::Point &, void > > | |
| Cmitk::Message1< const mitk::Point & > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< const std::string &, void > > | |
| Cmitk::Message1< const std::string & > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< DataVectorType *, void > > | |
| Cmitk::Message1< DataVectorType * > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< float, void > > | |
| Cmitk::Message1< float > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< int, void > > | |
| Cmitk::Message1< int > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< std::string, void > > | |
| Cmitk::Message1< std::string > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate1< T, void > > | |
| Cmitk::Message1< T, A > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate2< const mitk::DataNode *, const mitk::BaseProperty *, void > > | |
| Cmitk::Message2< const mitk::DataNode *, const mitk::BaseProperty * > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate2< ScalarType, ScalarType, void > > | |
| Cmitk::Message2< ScalarType, ScalarType > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate2< T, U, void > > | |
| Cmitk::Message2< T, U, A > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate3< double, double, bool, void > > | |
| Cmitk::Message3< double, double, bool > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate3< T, U, V, void > > | |
| Cmitk::Message3< T, U, V, A > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate4< T, U, V, W > > | |
| Cmitk::Message4< T, U, V, W, A > | |
| ►Cmitk::MessageBase< MessageAbstractDelegate< void > > | |
| Cmitk::Message< A > | Event/message/notification class |
| Cmitk::AbstractFileWriter::LocalFile | A local file representation for streams |
| Cmitk::AccessItkImageFunctor< X, VDimension, T1, T2, T3 > | |
| Cmitk::AnatomicalStructureColorPresets::Category | |
| Cmitk::AnatomicalStructureColorPresets::Type | |
| Cmitk::AnatomicalStructureColorPresets::Type::Modifier | |
| Cmitk::AnisotropicRegistrationCommon | A Class that provides common static functions used by all classes and tests in the anisotropic iterative closest point algorithm (AnisotropicIterativeClosestPointRegistration) |
| ►Cmitk::Annotation::BaseLocalStorage | Base class for mapper specific rendering resources |
| Cmitk::ColorBarAnnotation::LocalStorage | |
| Cmitk::LabelAnnotation3D::LocalStorage | Internal class holding the vtkActor, etc. for each of the render windows |
| Cmitk::LogoAnnotation::LocalStorage | |
| Cmitk::ScaleLegendAnnotation::LocalStorage | |
| Cmitk::TextAnnotation2D::LocalStorage | |
| Cmitk::TextAnnotation3D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the render windows |
| Cmitk::Annotation::Bounds | Container for position and size on the display |
| Cmitk::AnnotationUtils | Static functions for accsessing registered AnnotationRenderers and Annotations |
| Cmitk::ApplicationCursor | Allows to override the application's cursor |
| ►Cmitk::ApplicationCursorImplementation | Toolkit specific implementation of mitk::ApplicationCursor |
| CQmitkApplicationCursor | Qt specific implementation of ApplicationCursorImplementation |
| Cmitk::ArithmeticOperation | Executes a arithmetic operations on one or two images |
| Cmitk::AssertImageTypeIsValid< ItkImageType > | A helper template for compile-time checking of supported ITK image types |
| ►Cmitk::BaseLocalStorageHandler | Interface for accessing (templated) LocalStorageHandler instances |
| Cmitk::LocalStorageHandler< BaseLocalStorage > | |
| Cmitk::LocalStorageHandler< LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::ColorBarAnnotation::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::ContourModelMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::ContourModelMapper3D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::ContourModelSetMapper3D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::CrosshairVtkMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::DoseImageVtkMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::ImageVtkMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::LabelAnnotation3D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::LabelSetImageVtkMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::LogoAnnotation::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::MITKRegistrationWrapperMapperBase::RegWrapperLocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::MultiLabelSegmentationVtkMapper3D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::PlaneGeometryDataMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::PointSetVtkMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::RegEvaluationMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::ScaleLegendAnnotation::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::SurfaceVtkMapper2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::SurfaceVtkMapper3D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::TextAnnotation2D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::TextAnnotation3D::LocalStorage > | |
| Cmitk::LocalStorageHandler< mitk::VtkGLMapperWrapper::LocalStorage > | |
| Cmitk::LocalStorageHandler< L > | Templated class for management of LocalStorage implementations in Mappers |
| Cmitk::BindDispatcherInteractor | This Class is used to connect a DataStorage with the Dispatcher |
| Cmitk::CallbackFromGUIThread | Allows threads to call some method from within the GUI thread |
| ►Cmitk::CallbackFromGUIThreadImplementation | Toolkit specific implementation of mitk::CallbackFromGUIThread |
| CQmitkCallbackFromGUIThread | Qt specific implementation of mitk::CallbackFromGUIThreadImplementation |
| Cmitk::Caster | |
| Cmitk::ChannelDescriptor | An object which holds all essential information about a single channel of an Image |
| Cmitk::ChartExampleTestHelper | |
| Cmitk::cl::CLResultXMLWriter | |
| Cmitk::cl::FeatureResultWriter | |
| Cmitk::cl::GlobalImageFeaturesParameter | |
| Cmitk::ClippedSurfaceBoundsCalculator | |
| Cmitk::CLUtil | |
| ►Cmitk::ColorSequence | Interface for creating a sequence of nice/matching/appropriate/... colors |
| Cmitk::ColorSequenceCycleH | Creates a list of around 36 different colors, where one is easily distinguished from the preceding one |
| Cmitk::ColorSequenceRainbow | |
| Cmitk::CompareFilterResults | A simple struct to hold the result of the comparison filter |
| Cmitk::ComponentsTrait< V, T > | Object for compile-time resolving of the number of components for given type |
| Cmitk::ComponentsTrait< false, T > | Partial specialization for the ComponentsTraits in case of compound types |
| Cmitk::CompressedImageContainer | |
| Cmitk::ConfigurationHolder | |
| ►Cmitk::ConstraintCheckerInterface | |
| Cmitk::ConstraintCheckerBase | This class is the base class for constraint checker |
| Cmitk::ContourElement::ContourModelVertex | Represents a single vertex of a contour |
| Cmitk::ConvertT2ConcentrationFunctor< TInputPixel1, TInputPixel2, TOutputpixel > | |
| Cmitk::ConvertToConcentrationAbsoluteFunctor< TInputPixel1, TInputPixel2, TOutputpixel > | |
| Cmitk::ConvertToConcentrationRelativeFunctor< TInputPixel1, TInputPixel2, TOutputpixel > | |
| Cmitk::ConvertToConcentrationTurboFlashFunctor< TInputPixel1, TInputPixel2, TOutputpixel > | |
| Cmitk::ConvertToConcentrationViaT1CalcFunctor< TInputPixel1, TInputPixel2, TInputPixel3, TOutputpixel > | |
| Cmitk::CoreServicePointer< S > | A RAII helper class for core service objects |
| Cmitk::CoreServices | Access MITK core services |
| Cmitk::CorrectorAlgorithm::TSegData | Calculated difference image |
| ►Cmitk::CustomMimeType | Custom mime-type which may be registered as a service object. It should only be used for mime-type registration, see also mitk::MimeType |
| Cmitk::DICOMRTMimeTypes::RTDoseMimeType | |
| Cmitk::DICOMRTMimeTypes::RTPlanMimeType | |
| Cmitk::DICOMRTMimeTypes::RTStructMimeType | |
| Cmitk::ExampleIOMimeTypes::ExampleDataStructureMimeType | |
| ►Cmitk::IOMimeTypes::BaseDicomMimeType | |
| Cmitk::IOMimeTypes::DicomMimeType | |
| Cmitk::MitkCESTIOMimeTypes::MitkCESTDicomMimeType | |
| Cmitk::MitkCESTIOMimeTypes::MitkCESTDicomWithMetaFileMimeType | |
| Cmitk::MitkCESTIOMimeTypes::MitkCESTDicomWOMetaFileMimeType | |
| Cmitk::MitkDICOMPMIOMimeTypes::MitkDICOMPMMimeType | |
| Cmitk::MitkDICOMSEGIOMimeTypes::MitkDICOMSEGMimeType | |
| Cmitk::MitkMultilabelIOMimeTypes::LegacyLabelSetMimeType | |
| Cmitk::MitkMultilabelIOMimeTypes::MitkSegmentationTaskListMimeType | |
| Cmitk::MitkROIIOMimeTypes::MitkROIMimeType | |
| Cmitk::CustomTagParser | |
| Cmitk::DataStorageInspectorGenerator | |
| Cmitk::DICOMCachedValueInfo | |
| ►Cmitk::DICOMDatasetAccess | Interface to datasets that is presented to sorting classes such as DICOMDatasetSorter |
| Cmitk::DICOMDatasetAccessingImageFrameInfo | Defines an abstract base class for DICOM image frame infos with data access |
| Cmitk::DICOMDatasetFinding | |
| Cmitk::DICOMIOMetaInformationPropertyConstants | The IOMetaInformationPropertyConsants struct |
| Cmitk::DICOMPMPropertyHelper | |
| Cmitk::DICOMQIPropertyHelper | |
| Cmitk::DICOMRTMimeTypes | |
| Cmitk::DICOMSegmentationConstants | |
| Cmitk::DICOMSegmentationPropertyHelper | |
| Cmitk::DicomSeriesReader | |
| Cmitk::DicomSeriesReader::GantryTiltInformation | Gantry tilt analysis result |
| Cmitk::DicomSeriesReader::ImageBlockDescriptor | Return type of GetSeries, describes a logical group of files |
| Cmitk::DicomSeriesReader::SliceGroupingAnalysisResult | Return type of DicomSeriesReader::AnalyzeFileForITKImageSeriesReaderSpacingAssumption |
| Cmitk::DICOMTag | Representation of a DICOM tag |
| Cmitk::DICOMTagBasedSorter::ParameterizedDatasetSort | Helper struct to feed into std::sort, configured via DICOMSortCriterion |
| ►Cmitk::DICOMTagBasedSorter::TagValueProcessor | Processes tag values before they are compared. These classes could do some kind of normalization such as rounding, lower case formatting, etc |
| Cmitk::DICOMTagBasedSorter::CutDecimalPlaces | Cuts a number after configured number of decimal places. An instance of this class can be used to avoid errors when comparing minimally different image orientations |
| Cmitk::DICOMTagPath | Class is used to identify (nested) attributes in a DICOM dataset. In contrast to the class DICOMTag, which only specifies one specific tag, the tag path can identify nested attributes (like items in a DICOM sequence). In addition you may also specify wildcards for the selection index or complete elements of the path |
| Cmitk::DICOMTagPath::NodeInfo | |
| Cmitk::DICOMTagsOfInterestAddHelper | |
| Cmitk::DICOMweb | |
| ►Cmitk::DisplayActionEventHandler | This class simplifies the process of adding an itkEventObject-itkCommand pair as an observer of a DisplayActionEventBroadcast instance. The 'SetObservableBroadcast'-function can be used to define the broadcast instance that should be observed. The 'ConnectDisplayActionEvent'-function can be used to add a an observer to the broadcast. Such an observer consists of a DisplayActionEvent (an itkEventObject) and a StdFunctionCommand (an itkCommand). The StdFunctionCommand is created inside the function by the given two std::functions |
| Cmitk::DisplayActionEventHandlerDesynchronized | |
| Cmitk::DisplayActionEventHandlerStd | |
| Cmitk::DisplayActionEventHandlerSynchronized | |
| Cmitk::EmptyType | |
| Cmitk::EquiDistantBlocksSorter::SliceGroupingAnalysisResult | Return type of AnalyzeFileForITKImageSeriesReaderSpacingAssumption() |
| Cmitk::EventConfig | Configuration Object for Statemachines |
| Cmitk::EventFactory | Generates InteractionEvent-Objects/XML |
| Cmitk::EventInformerService | |
| Cmitk::ExampleIOMimeTypes | |
| Cmitk::Exception::ReThrowData | |
| Cmitk::FeatureID | |
| ►Cmitk::FileReader | Interface class of readers that read from files |
| Cmitk::FileSeriesReader | |
| Cmitk::ItkImageFileReader | Reader to read file formats supported by itk |
| Cmitk::PointSetReader | Reads xml representations of mitk::PointSets from a file |
| Cmitk::RawImageFileReader | Reader to read raw image files |
| Cmitk::VtiFileReader | Reader to read image files in vtk file format |
| Cmitk::VtkImageReader | Reader to read image files in vtk file format |
| Cmitk::FileReaderRegistry | |
| Cmitk::FileReaderSelector | |
| Cmitk::FileReaderSelector::Item | |
| Cmitk::FileReaderWriterBase | |
| Cmitk::FileWriterRegistry | |
| Cmitk::FileWriterSelector | |
| Cmitk::FileWriterSelector::Item | |
| Cmitk::FormulaParser | This class offers the functionality to evaluate simple mathematical formula strings (e.g. "3.5 + 4 * x * sin(x) - 1 / 2") |
| Cmitk::GantryTiltInformation | Gantry tilt analysis result |
| Cmitk::GaussianNoiseFunctor< TInputPixel, TOutputPixel > | |
| Cmitk::GenericLookupTable< T > | Template class for generating lookup-tables |
| Cmitk::Geometry3DToXML | |
| Cmitk::GeometryTransformHolder | |
| Cmitk::GetComponentType< T > | Compile time resolving of the type of a component |
| Cmitk::GetPixelType< TypeList, Index, Step, Stop, OutOfRange > | |
| Cmitk::GetPixelType< TypeList, Index, Step, Stop, true > | |
| Cmitk::GetPixelType< TypeList, Index, Step, true, OutOfRange > | |
| Cmitk::GetSuperclassType< T, bool > | |
| Cmitk::GetSuperclassType< T, true > | |
| Cmitk::GreyLevelDistanceZoneFeatures | |
| Cmitk::Handle | Helper Class for realizing the handles of bounding object encapsulated by a geometry data |
| Cmitk::HasMethodGetStaticNameOfClass< T > | |
| Cmitk::HasTypeSuperclass< T > | |
| Cmitk::HistogramStatisticsCalculator | Computes basic histogram statistics such as Uniformity, UPP (Uniformity of positive entries), Entropy and Median (approximation) |
| Cmitk::HotspotMaskGenerator::ImageExtrema | |
| Cmitk::IContextMenuAction | |
| ►Cmitk::IDataStorageInspectorProvider | The common interface for all DataStorage inspector providers |
| CQmitkDataStorageInspectorProviderBase< TInspector > | Base class for DataStorage inspector provider |
| Cmitk::IDataStorageService | |
| ►Cmitk::Identifiable | Base class of identifiable objects |
| Cmitk::BaseData | Base of all data objects |
| ►Cmitk::IDICOMTagsOfInterest | Interface of DICOM tags of interest service |
| Cmitk::DICOMTagsOfInterestService | DICOM tags of interest service |
| ►Cmitk::IFileIO | Common interface for all MITK file reader and writer |
| ►Cmitk::IFileReader | The common interface for all MITK file readers |
| ►Cmitk::AbstractFileReader | Base class for creating mitk::BaseData objects from files or streams |
| ►Cmitk::AbstractFileIOReader | |
| ►Cmitk::AbstractFileIO | Abstract class for implementing a reader and writer |
| Cmitk::DICOMPMIO | |
| Cmitk::DICOMSegmentationIO | |
| Cmitk::ImageVtkLegacyIO | |
| Cmitk::ImageVtkXmlIO | |
| Cmitk::ItkImageIO | |
| Cmitk::MAPRegistrationWrapperIO | |
| Cmitk::MultiLabelSegmentationIO | |
| Cmitk::PlanarFigureIO | |
| Cmitk::ROIIO | |
| Cmitk::SegmentationTaskListIO | |
| ►Cmitk::SurfaceVtkIO | |
| Cmitk::SurfaceStlIO | |
| Cmitk::SurfaceVtkLegacyIO | |
| Cmitk::SurfaceVtkXmlIO | |
| ►Cmitk::BaseDICOMReaderService | |
| Cmitk::AutoSelectingDICOMReaderService | |
| Cmitk::CESTDICOMManualReaderService | |
| Cmitk::CESTDICOMReaderService | |
| Cmitk::ClassicDICOMSeriesReaderService | |
| Cmitk::ManualSelectingDICOMReaderService | |
| Cmitk::SimpleVolumeDICOMSeriesReaderService | |
| Cmitk::ContourModelReader | |
| Cmitk::ContourModelSetReader | |
| Cmitk::ExampleDataStructureReaderService | The reader service for the MITK example data type |
| Cmitk::GeometryDataReaderService | |
| Cmitk::LegacyFileReaderService | |
| Cmitk::LegacyLabelSetImageIO | |
| Cmitk::PointSetReaderService | |
| Cmitk::RawImageFileReaderService | |
| Cmitk::RTDoseReaderService | RTDoseReaderService reads DICOM files of modality RTDOSE |
| Cmitk::RTPlanReaderService | RTPlanReaderService reads DICOM files of modality RTPLAN |
| Cmitk::RTStructureSetReaderService | |
| ►Cmitk::IFileWriter | The common interface of all MITK file writers |
| ►Cmitk::AbstractFileWriter | Base class for writing mitk::BaseData objects to files or streams |
| ►Cmitk::AbstractFileIOWriter | |
| Cmitk::AbstractFileIO | Abstract class for implementing a reader and writer |
| Cmitk::ContourModelSetWriter | XML-based writer for mitk::ContourModelSet |
| Cmitk::ContourModelWriter | XML-based writer for mitk::ContourModels |
| Cmitk::ExampleDataStructureWriterService | |
| Cmitk::GeometryDataWriterService | |
| Cmitk::LegacyFileWriterService | |
| Cmitk::PointSetWriterService | |
| ►Cmitk::ILifecycleAwarePart | Interface for a MITK Workbench part which wants to be notified about lifecycle changes |
| Cmitk::IZombieViewPart | Interface for MITK Workbench Views with special Zombie state handling |
| ►Cmitk::ImageAccessorBase | |
| Cmitk::ImageReadAccessor | ImageReadAccessor class to get locked read access for a particular image part |
| Cmitk::ImageVtkReadAccessor | ImageVtkReadAccessor class provides any image read access which is required by Vtk methods |
| ►Cmitk::ImageVtkWriteAccessor | ImageVtkWriteAccessor class provides any image write access which is required by Vtk methods |
| Cmitk::ImageVtkAccessor | ImageVtkAccessor class provides any image read access which is required by Vtk methods |
| Cmitk::ImageWriteAccessor | ImageWriteAccessor class to get locked write-access for a particular image part |
| Cmitk::ImageAccessorWaitLock | This struct allows to make ImageAccessors wait for this particular ImageAccessor object |
| Cmitk::ImageCaster | This class is just a proxy for global functions which are needed by the python wrapping process since global functions cannot be wrapped. Static method can be wrapped though |
| Cmitk::ImageGenerator | Generator for synthetic MITK images This is a helper class to generate synthetic MITK images (random or gradient) |
| Cmitk::ImageMappingInterpolator | |
| Cmitk::ImagePixelAccessor< TPixel, VDimension > | Provides templated image access for all inheriting classes |
| Cmitk::ImageSource::ThreadStruct | Internal structure used for passing image data into the threading library |
| Cmitk::ImageStatisticsConstants | |
| Cmitk::ImageStatisticsContainer::ImageStatisticsObject | Container class for storing the computed image statistics |
| Cmitk::ImageStatisticsContainerManager | Returns the StatisticsContainer that was computed on given input (image/mask/planar figure) and is added as DataNode in a DataStorage |
| Cmitk::ImageStatisticsHolder | Class holding the statistics information about a single mitk::Image |
| Cmitk::ImageTypeTrait< TPixelType, VDimension > | |
| Cmitk::ImageTypeTrait< itk::VariableLengthVector< TPixelType >, VDimension > | |
| Cmitk::ImageTypeTrait< itk::VectorImage< TPixelType, VDimension >, 0 > | |
| Cmitk::ImageTypeTrait< T, 0 > | |
| ►Cmitk::IMimeTypeProvider | The IMimeTypeProvider service interface allows to query all registered mime types |
| Cmitk::MimeTypeProvider | |
| ►Cmitk::IModelFitProvider | The common interface for all model providers for model fitting |
| Cmitk::ModelFitProviderBase< TModelFactory > | Base class for model fit provider |
| Cmitk::IndexedValueFunctorPolicy | |
| Cmitk::InteractionEventConst | Constants to describe Mouse Events and special Key Events |
| ►Cmitk::InteractionEventObserver | Base class to implement InteractionEventObservers |
| Cmitk::DisplayActionEventBroadcast | This class serves as an event state machine while simultaneously observing interaction events. It connects the actions from the event state machine .xml-file with concrete functions of this class |
| Cmitk::EventRecorder | Observer that enables recoding of all user interaction with the render windows and storing it in an XML file |
| Cmitk::Tool | Base class of all tools used by mitk::ToolManager |
| Cmitk::InteractionTestHelper | Creates everything needed to load and playback interaction events |
| Cmitk::IOConstants | The IOConstants struct |
| Cmitk::IOMetaInformationPropertyConstants | The IOMetaInformationPropertyConstants struct |
| Cmitk::IOMimeTypes | The IOMimeTypes class |
| ►Cmitk::IOUtil | A utility class to load and save data from/to the local file system |
| CQmitkIOUtil | QmitkIOUtil Provides static helper methods to open and save files with Qt dialogs |
| Cmitk::IOUtil::LoadInfo | |
| ►Cmitk::IOUtil::ReaderOptionsFunctorBase | |
| Cmitk::PreferenceListReaderOptionsFunctor | Option callback functor with a preference list/ black list option selection strategy |
| Cmitk::IOUtil::SaveInfo | |
| Cmitk::IOUtil::WriterOptionsFunctorBase | |
| Cmitk::IPersistable | |
| ►Cmitk::IPersistenceService | |
| Cmitk::PersistenceService | |
| ►Cmitk::IPreferences | Interface to application preferences |
| Cmitk::Preferences | Implementation of the IPreferences interface |
| Cmitk::IPreferences::ChangeEvent | Event object sent on IPreferences::OnPropertyChanged events |
| ►Cmitk::IPreferencesService | A service for persistent application preferences |
| Cmitk::PreferencesService | Implementation of the IPreferencesService interface |
| ►Cmitk::IPreferencesStorage | The backend for persistent preferences |
| Cmitk::XMLPreferencesStorage | See IPreferencesStorage |
| ►Cmitk::IPropertyAliases | Interface of property aliases service |
| Cmitk::PropertyAliases | |
| ►Cmitk::IPropertyDescriptions | Interface of property descriptions service |
| Cmitk::PropertyDescriptions | |
| ►Cmitk::IPropertyDeserialization | Interface of property deserialization service |
| Cmitk::PropertyDeserialization | |
| ►Cmitk::IPropertyExtensions | Interface of property extensions service |
| Cmitk::PropertyExtensions | |
| ►Cmitk::IPropertyFilters | Interface of property filters service |
| Cmitk::PropertyFilters | |
| ►Cmitk::IPropertyPersistence | Interface of property persistence service |
| Cmitk::PropertyPersistence | |
| ►Cmitk::IPropertyProvider | |
| Cmitk::DICOMImageBlockDescriptor | Output descriptor for DICOMFileReader |
| ►Cmitk::IPropertyOwner | |
| Cmitk::BaseData | Base of all data objects |
| Cmitk::DataNode | Class for nodes of the DataTree |
| Cmitk::PropertyList | Key-value list holding instances of BaseProperty |
| Cmitk::ROI::Element | Encapsulates a single (possibly time-resolved) ROI |
| ►Cmitk::IPropertyRelations | Interface of property relations service |
| Cmitk::PropertyRelations | |
| ►Cmitk::IPythonService | |
| Cmitk::PythonService | |
| Cmitk::IRenderingManager | An interface for accessing a mitk::RenderingManager instance |
| ►Cmitk::IRenderWindowPart | Interface for a MITK Workbench Part providing a render window |
| ►Cmitk::ILinkedRenderWindowPart | Extends the IRenderWindowPart interface with methods for controlling linked render windows |
| CQmitkStdMultiWidgetEditor | |
| CQmitkAbstractRenderEditor | A convenient base class for MITK render window BlueBerry Editors |
| Cmitk::IRenderWindowPartListener | Interface for berry::IViewPart implementations to be notified about mitk::IRenderWindowPart lifecycle changes |
| ►Cmitk::IRESTManager | This is a microservice interface for managing REST requests |
| Cmitk::RESTManager | This is a microservice for managing REST-requests, used for non-qt applications |
| Cmitk::IRESTObserver | |
| Cmitk::IsoDoseLevelSet::ConstIterator | |
| Cmitk::isPrimitiveType< T > | This is an implementation of a type trait to provide a compile-time check for PixelType used in the instantiation of an itk::Image |
| Cmitk::isPrimitiveType< char > | Partial specialization (char) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< double > | Partial specialization (double) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< float > | Partial specialization (float) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< int > | Partial specialization (int) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< long int > | Partial specialization (long int) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< long unsigned int > | Partial specialization (long unsigned int) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< short > | Partial specialization (short) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< signed char > | Partial specialization (signed char) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< unsigned char > | Partial specialization (unsigned char) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< unsigned int > | Partial specialization (unsigned int) for the isPrimitiveType object |
| Cmitk::isPrimitiveType< unsigned short > | Partial specialization (unsigned short) for the isPrimitiveType object |
| Cmitk::ITKDICOMSeriesReaderHelper | |
| Cmitk::ITKEventObserverGuard | Convenience class that helps to manage the lifetime of itk event observers |
| Cmitk::LabelHighlightGuard | |
| Cmitk::LabelStatisticsImageFilter< TInputImage >::LabelStatistics | |
| Cmitk::LevelWindow | Class to store level/window values |
| Cmitk::Line< TCoordRep, NPointDimension > | Describes a line |
| Cmitk::LocaleSwitch | Convenience class to temporarily change the current locale |
| ►Cmitk::LogBackendBase | Interface for log backends that can be registered in the MITK log mechanism |
| ►Cmitk::LogBackendText | Abstract superclass for text-based log backends |
| Cmitk::LogBackend | Log backend implementation for MITK |
| Cmitk::LogBackendCout | Default backend of the MITK log mechanism |
| Cmitk::LogMessage | A single log message (log event) of the MITK log mechanism |
| Cmitk::LookupTablePropertySerializerRegistrationMethod | |
| Cmitk::MAPAlgorithmHelper | MAPAlgorithmHelper |
| Cmitk::MAPAlgorithmHelper::CheckError | |
| Cmitk::MapCompositePixelType< T > | Object for compile-time translation of a composite pixel type into an itk::ImageIOBase::IOPixelType information |
| Cmitk::MapCompositePixelType< itk::CovariantVector< C, N > > | |
| Cmitk::MapCompositePixelType< itk::DiffusionTensor3D< C > > | |
| Cmitk::MapCompositePixelType< itk::FixedArray< C, N > > | |
| Cmitk::MapCompositePixelType< itk::Matrix< C, N > > | |
| Cmitk::MapCompositePixelType< itk::RGBAPixel< C > > | |
| Cmitk::MapCompositePixelType< itk::RGBPixel< C > > | |
| Cmitk::MapCompositePixelType< itk::VariableLengthVector< C > > | |
| Cmitk::MapCompositePixelType< itk::Vector< C, N > > | |
| ►Cmitk::Mapper::BaseLocalStorage | Base class for mapper specific rendering resources |
| Cmitk::ContourModelMapper2D::LocalStorage | |
| Cmitk::ContourModelMapper3D::LocalStorage | |
| Cmitk::ContourModelSetMapper3D::LocalStorage | |
| Cmitk::CrosshairVtkMapper2D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 2D render windows |
| Cmitk::DoseImageVtkMapper2D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::ImageVtkMapper2D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::LabelSetImageVtkMapper2D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::MITKRegistrationWrapperMapperBase::RegWrapperLocalStorage | |
| Cmitk::MultiLabelSegmentationVtkMapper3D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::PlaneGeometryDataMapper2D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::PointSetVtkMapper2D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::RegEvaluationMapper2D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::ROIMapperLocalStorage | Common base class for both 2-d and 3-d ROI mapper local storages |
| Cmitk::SurfaceVtkMapper2D::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::SurfaceVtkMapper3D::LocalStorage | |
| Cmitk::VtkGLMapperWrapper::LocalStorage | Internal class holding the mapper, actor, etc. for each of the 3 2D render windows |
| Cmitk::VtkMapper::LocalStorage | |
| Cmitk::MapPixelComponentType< T > | |
| Cmitk::MapPixelType< T, Primitive > | Object for compile-time translation of a pixel type into an itk::ImageIOBase::IOPixelType information |
| Cmitk::MapPixelType< T, true > | Partial specialization for setting the IOPixelType for primitive types to SCALAR |
| Cmitk::MaskCleaningOperation | Executes operations to clean-up Masks |
| Cmitk::MaskedAlgorithmHelper | MaskedAlgorithmHelper Helper class as an easy bridge to set mitk images as masks for registration algorithms. It is assumed that the Image indicates the mask by pixel values != 0 |
| Cmitk::MessageAbstractDelegate< A > | |
| Cmitk::MessageAbstractDelegate1< T, A > | |
| ►Cmitk::MessageAbstractDelegate2< T, U, A > | |
| Cmitk::MessageDelegate2< R, T, U, A > | |
| Cmitk::MessageAbstractDelegate3< T, U, V, A > | |
| Cmitk::MessageAbstractDelegate4< T, U, V, W, A > | |
| Cmitk::MessageBase< AbstractDelegate > | |
| Cmitk::MimeType | Registered mime-type. It is an immutable wrapper for mitk::CustomMimeType that makes memory handling easier by providing a stack-object for the user |
| Cmitk::MitkCESTIOMimeTypes | Provides the custom mime types for MitkCEST |
| Cmitk::MitkDICOMPMIOMimeTypes | Provides the custom mime types for dicom qi objects loaded with DCMQI |
| Cmitk::MitkDICOMSEGIOMimeTypes | Provides the custom mime types for dicom qi objects loaded with DCMQI |
| Cmitk::MITKRegistrationHelper | MITKRegistrationHelper |
| Cmitk::modelFit::StaticParameterMap | |
| Cmitk::ModelFitConstants | |
| ►Cmitk::ModelFitCostFunctionInterface | |
| Cmitk::MVModelFitCostFunction | |
| Cmitk::SVModelFitCostFunction | |
| Cmitk::ModelFitFunctorPolicy | |
| Cmitk::ModelFitPlotData | |
| Cmitk::ModelGenerator | |
| Cmitk::ModelParams | NnUNet parameter request object holding all model parameters for input. Also holds output temporary directory path |
| ►Cmitk::ModelTraitsInterface | |
| Cmitk::ModelBase | Base class for (dynamic) models. A model can be used to calculate its signal given the discrete time grid of the signal and the parameters of the model.
A model has 3 types of parameters:
|
| Cmitk::ModelFactoryBase | |
| Cmitk::ModelParameterizerBase | |
| Cmitk::ModifiedLock | ModifiedLock manages the calls of Modified() functions |
| Cmitk::MonaiAppMetadata | Struct to store MonaiLabel server metadata including all model infos |
| Cmitk::MonaiLabelRequest | Request class to pack model and other necessary server information from GUI |
| Cmitk::MonaiModelInfo | Struct to hold featured models individual info |
| Cmitk::MorphologicalOperations | Encapsulates several morphological operations that can be performed on segmentations |
| Cmitk::MultiLabelIOHelper | The MultiLabelIOHelper is a static helper class that supports serialization of mitk::LabelSetImage |
| Cmitk::NodeSelectionConstants | |
| Cmitk::NonStaticArithmeticOperation | |
| Cmitk::NullLogStream | Simulates a std::cout stream but does nothing |
| ►Cmitk::Operation | Base class of all Operation-classes |
| Cmitk::ApplyDiffImageOperation | Operation, that holds information about some image difference |
| Cmitk::ApplyTransformMatrixOperation | |
| ►Cmitk::CellOperation | Operation, that holds everything necessary for an operation on a cell |
| Cmitk::LineOperation | Operation, that holds everything necessary for an operation on a line. Stores everything for de-/ selecting, inserting , moving and removing a line |
| Cmitk::DiffSliceOperation | An Operation for applying an edited slice to the volume |
| Cmitk::DisplayCoordinateOperation | Operation with information necessary for operations of DisplayVectorInteractor |
| ►Cmitk::PointOperation | Operation that handles all actions on one Point. Stores everything for Adding, Moving and Deleting a Point |
| Cmitk::PlaneOperation | Operation for setting a plane (defined by its origin and normal) |
| Cmitk::RestorePlanePositionOperation | |
| Cmitk::RotationOperation | Operation, that holds everything necessary for an rotation operation on mitk::BaseData |
| Cmitk::ScaleOperation | The ScaleOperation is an operation to scale any mitk::BaseGeometry |
| Cmitk::SurfaceOperation | |
| ►Cmitk::OperationActor | Abstract class, that can be used by Undo to undo an operation |
| Cmitk::BaseController | Baseclass for renderer slice-/camera-/time-control |
| Cmitk::BaseData | Base of all data objects |
| Cmitk::BaseGeometry | BaseGeometry Describes the geometry of a data object |
| Cmitk::DiffImageApplier | Applies difference images to 3D images |
| Cmitk::DiffSliceOperationApplier | Executes a DiffSliceOperation |
| Cmitk::TimeGeometry | |
| Cmitk::ParamapPresetsParser::Type | |
| Cmitk::PixelType | Class for defining the data type of pixels |
| Cmitk::PixelTypeLength< TypeList > | |
| Cmitk::PixelTypeList< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > | |
| Cmitk::PixelTypeList< EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType, EmptyType > | |
| Cmitk::PixelTypeSwitch< TypeList, Index, Stop > | |
| Cmitk::PixelTypeSwitch< TypeList, Index, true > | |
| Cmitk::PixelTypeTrait< flag, T > | Compile-time trait for resolving the ValueType from an ItkImageType |
| Cmitk::PixelTypeTrait< false, T > | Partial specialization for the PixelTypeTrait |
| Cmitk::PlaneGeometryDataVtkMapper3D::ActorInfo | |
| Cmitk::PlanePositionManagerService | |
| Cmitk::PlaneProposer | The PlaneProposer creates a new plane based on an input point cloud |
| Cmitk::PlaneProposer::PlaneInfo | Encapsulates the geometrical information needed to descripe a PlaneInfo |
| Cmitk::PointSet::CellDataType | |
| Cmitk::PointSet::PointDataType | Struct for data of a point |
| ►Cmitk::ProgressBarImplementation | GUI independent Interface for all Gui dependent implementations of a ProgressBar |
| CQmitkProgressBar | QT-Toolkit/GUI dependent class that provides the QT's ProgressBar |
| Cmitk::PropertyFilter | Consists of blacklist and whitelist entries |
| Cmitk::PropertyKeyPath | Class that can be used to specify nested or wild carded property keys. E.g. for the use in context of the property persistence service or the property relation service.
Following assumptions are made /preconditions are defined: |
| Cmitk::PropertyKeyPath::NodeInfo | |
| Cmitk::PropertyListReplacedObserver | |
| ►Cmitk::PropertyObserver | |
| ►Cmitk::PropertyEditor | |
| CQmitkNumberPropertyEditor | |
| CQmitkStringPropertyEditor | |
| CQmitkStringPropertyOnDemandEdit | |
| ►Cmitk::PropertyView | |
| CQmitkBasePropertyView | |
| ►CQmitkColorPropertyView | |
| CQmitkColorPropertyEditor | |
| CQmitkNumberPropertyView | |
| CQmitkStringPropertyView | |
| Cmitk::ProportionalTimeGeometryToXML | |
| Cmitk::ProvisioningInfo | |
| Cmitk::PseudoLogStream | Simulates a std::cout stream |
| ►Cmitk::PythonCommandObserver | |
| CQmitkPythonVariableStackTableModel | |
| Cmitk::PythonVariable | |
| Cmitk::ReduceContourSetFilter::LineSegment | |
| Cmitk::RendererAccess | |
| Cmitk::RenderingManager::RenderWindowCallbacks | |
| ►Cmitk::RenderingManagerFactory | Factory interface for facilitating the usage of a platform-specific mitk::RenderingManager instance |
| Cmitk::TestingRenderingManagerFactory | |
| CQmitkRenderingManagerFactory | Qt specific implementation of mitk::RenderingManagerFactory |
| Cmitk::RenderingTestHelper | |
| Cmitk::RenderingTestHelper::ArgcHelperClass | Convenience class to convert a vector of strings to the standard c++ argv and argc arguments. This is necessary for the vtkTesting::Test, since is requires the reference image (and other optional parameters) via command line |
| ►Cmitk::RenderWindowBase | Base class of MITK RenderWindows |
| Cmitk::RenderWindow | MitkRenderWindow integrates the MITK rendering mechanism into VTK and is NOT QT dependent |
| CQmitkRenderWindow | MITK implementation of the QVTKWidget |
| Cmitk::RenderWindowLayerController | |
| Cmitk::RenderWindowViewDirectionController | |
| Cmitk::RESTClient | |
| Cmitk::RESTServer | |
| Cmitk::RESTUtil | |
| Cmitk::RTConstants | |
| Cmitk::RTCTKEventConstants | |
| Cmitk::RTUIConstants | |
| Cmitk::ScalarListLookupTable | Data class for modelfit properties that store a map of lists (e.g. static parameters) |
| Cmitk::SegmentationInterpolationController::SetChangedSliceOptions | Protected class of mitk::SegmentationInterpolationController. Don't use (you shouldn't be able to do so)! |
| Cmitk::SegmentationTaskList::Task | |
| Cmitk::SegTool2D::SliceInformation | |
| Cmitk::SIGNALCONSTANTS | |
| Cmitk::SimpleBarrierConstraintChecker::Constraint | |
| Cmitk::SimpleFunctorPolicy | |
| ►Cmitk::SimpleHistogram | Abstract superclass for histograms with double values. Classes which are deriving from this class can be cached in the same way |
| Cmitk::SimpleImageHistogram | |
| Cmitk::SimpleUnstructuredGridHistogram | |
| Cmitk::SimpleHistogramCache | |
| Cmitk::SimpleHistogramCache::Element | |
| Cmitk::StateMachineCondition | Represents a condition, that has to be fulfilled in order to execute a state machine transition after a certain event |
| Cmitk::StaticNameOfClass< T, bool > | |
| Cmitk::StaticNameOfClass< T, true > | |
| ►Cmitk::StatusBarImplementation | GUI independent Interface for all Gui dependent implementations of a StatusBar |
| CQmitkStatusBar | QT-Toolkit/GUI dependent class that provides to send a Message to the QT's StatusBar |
| Cmitk::SurfaceInterpolationController::ContourPositionInformation | |
| Cmitk::TActionFunctor | Base class of ActionFunctors, to provide an easy to connect actions with functions |
| Cmitk::TestDICOMLoading | |
| Cmitk::TestManager | |
| Cmitk::TransformationOperation | Executes a transformation operations on one or two images |
| Cmitk::UIDGenerator | Generated unique IDs |
| Cmitk::UIDManipulator | Change the unique ID of an mitk::Identifiable |
| Cmitk::UndoController | |
| ►Cmitk::UndoStackItem | Represents an entry of the undo or redo stack |
| Cmitk::OperationEvent | Represents a pair of operations: undo and the according redo |
| Cmitk::VectorPropertyDataType< D > | Helper for VectorProperty to determine a good ITK ClassName |
| Cmitk::VectorPropertyDataType< double > | |
| Cmitk::VectorPropertyDataType< int > | |
| Cmitk::VideoRecorder | Record the contents of a render window as video using FFmpeg as external command-line application |
| Cmitk::VtkEventAdapter | |
| Cmitk::VtkLayerController | |
| Cmitk::WeakPointer< T > | |
| Cmitk::WorkbenchUtil | Utility class for loading data, opening editors and other tasks in a MITK Workbench |
| CmitkCommandLineParser | |
| CModuleContext | |
| ►CModuleResourceBuffer | |
| Cus::ModuleResourceStream | |
| CnnUNetCache | |
| ►CPathSource | |
| ►Citk::ImageToPathFilter< TInputImage, PolyLineParametricPath< 2 > > | |
| Citk::ContourExtractor2DImageFilter< TInputImage > | Computes a list of PolyLineParametricPath objects from the contours in a 2D image |
| Citk::ImageToPathFilter< TInputImage, TOutputPath > | Base class for filters that take an image as input and produce an path as output |
| ►CPersistentState | |
| Cberry::RadioState | |
| ►Cberry::ToggleState | |
| Cberry::RegistryToggleState | |
| ►CActiveRunnableBase | |
| Cberry::AsyncRunnable< ArgType, OwnerType > | |
| ►CApplication | |
| Cmitk::BaseApplication | |
| ►CQAbstractItemModel | |
| Cberry::ViewTreeModel | |
| ►CQmitkAbstractDataStorageModel | |
| ►CQmitkDataStorageDefaultListModel | The 'QmitkDataStorageDefaultListModel' is a basic list model, derived from the 'QmitkAbstractDataStorageModel'. It provides functions to accept a data storage and a node predicate in order to customize the model data nodes. Furthermore it overrides the functions of 'QAbstractItemModel' to create a simple qt list model. This model can be used in conjunction with a 'QmitkDataStorageSelectionConnector' |
| CQmitkDataStorageHistoryModel | Internal DataStorage model to represent the history of node selections |
| CQmitkDataStorageLayerStackModel | The 'QmitkDataStorageLayerStackModel' is a customized table model, derived from the 'QmitkAbstractDataStorageModel'. It provides functions to accept a data storage and a node predicate in order to customize the model data nodes. Furthermore it overrides the functions of 'QAbstractItemModel' to create a customized qt table model. This model can be used in conjunction with a 'QmitkDataStorageSelectionConnector' |
| CQmitkDataStorageSimpleTreeModel | The 'QmitkDataStorageSimpleTreeModel' is a basic tree model, derived from the 'QmitkAbstractDataStorageModel'. It provides functions to accept a data storage and a node predicate in order to customize the model data nodes. Furthermore it overrides the functions of 'QAbstractItemModel' to create a simple qt list model.* This model can be used in conjunction with a 'QmitkDataStorageSelectionConnector'. This model is a "light" version of the classic QmitkDataStorgageTreeModel. The differences between both are the following: |
| CQmitkImageStatisticsTreeModel | |
| CQmitkRenderWindowDataStorageListModel | |
| CQmitkRenderWindowDataStorageTreeModel | |
| CQmitkDataStorageTreeModel | |
| CQmitkMultiLabelTreeModel | |
| CQmitkPropertyItemModel | |
| CQmitkRenderWindowDataNodeTableModel | |
| ►CQAbstractListModel | |
| Cberry::PerspectiveListModel | |
| CQmitkDataStorageListModel | |
| CQmitkPointListModel | |
| ►CQAbstractTableModel | |
| Cmitk::QMAPAlgorithmModel | |
| CQmitkAlgorithmListModel | |
| CQmitkDataStorageTableModel | Own includes |
| CQmitkFitParameterModel | |
| CQmitkFitPlotDataModel | |
| CQmitkInitialValuesModel | |
| CQmitkIsoDoseLevelSetModel | |
| CQmitkLevelWindowPresetDefinitionDialog::PresetTableModel | |
| CQmitkMAPAlgorithmModel | |
| CQmitkModuleTableModel | |
| CQmitkPropertiesTableModel | A table model for showing and editing mitk::Properties |
| CQmitkPythonVariableStackTableModel | |
| CQmitkSimpleBarrierModel | |
| ►CQAction | |
| CQmitkCloseProjectAction | |
| CQmitkDataNodeColorMapAction | |
| CQmitkDataNodeGlobalReinitAction | |
| CQmitkDataNodeHideAllAction | |
| CQmitkDataNodeOpenInAction | |
| CQmitkDataNodeReinitAction | |
| CQmitkDataNodeRemoveAction | |
| CQmitkDataNodeResetGeometryAction | |
| CQmitkDataNodeShowDetailsAction | |
| CQmitkDataNodeShowSelectedNodesAction | |
| CQmitkDataNodeSurfaceRepresentationAction | |
| CQmitkDataNodeTextureInterpolationAction | |
| CQmitkDataNodeToggleVisibilityAction | |
| CQmitkExtFileSaveProjectAction | |
| CQmitkFileExitAction | |
| CQmitkFileOpenAction | |
| CQmitkFileSaveAction | |
| CQmitkOpenDicomEditorAction | |
| CQmitkOpenMxNMultiWidgetEditorAction | |
| CQmitkOpenStdMultiWidgetEditorAction | |
| CQmitkOpenXnatEditorAction | |
| CQmitkRedoAction | |
| CQmitkUndoAction | |
| ►CQApplication | |
| CQmitkSafeApplication | |
| ►CQCheckBox | |
| CQmitkAnyBoolWidget | |
| CQmitkBoolPropertyWidget | |
| ►CQComboBox | |
| CQmitkAnyVectorWidget | |
| ►CQmitkDataStorageComboBox | Displays all or a subset (defined by a predicate) of nodes of the Data Storage |
| CQmitkDataStorageComboBoxWithSelectNone | Displays all or a subset (defined by a predicate) of nodes of the Data Storage, and additionally, index 0 is always "please select", indicating no selection, and will hence always return a nullptr mitk::DataNode* if asked for the node at index 0 |
| CQmitkEnumerationPropertyWidget | |
| CQmitkUGCombinedRepresentationPropertyWidget | |
| ►CQDialog | |
| CBlueBerryExampleLauncherDialog | |
| CQmitkAboutDialog | |
| CQmitkConfirmSegmentationDialog | |
| CQmitkCopyToClipBoardDialog | Displays read-only QTextEdit |
| CQmitkEditPointDialog | A dialog for editing points directly (coordinates) via TextEdits |
| CQmitkFileReaderOptionsDialog | |
| CQmitkFileWriterOptionsDialog | |
| CQmitkFindSegmentationTaskDialog | |
| CQmitkLevelWindowPresetDefinitionDialog | |
| CQmitkLevelWindowRangeChangeDialog | |
| CQmitkModulesDialog | |
| CQmitkNewSegmentationDialog | Dialog for naming labels |
| CQmitkNodeDetailsDialog | |
| CQmitkNodeSelectionDialog | A customized QDialog that displays different data storage inspectors and allows to set and get a current selection by selecting data nodes in the data storage inspectors |
| CQmitkPlotDialog | |
| CQmitkPreferencesDialog | |
| CQmitkSelectXnatUploadDestinationDialog | |
| CQmitkStartupDialog | |
| CQmitkXnatCreateObjectDialog | |
| CQmitkXnatUploadFromDataStorageDialog | |
| ►CQDoubleSpinBox | |
| CQmitkAnyDoubleWidget | |
| CQmitkAnyFloatWidget | |
| ►CQEvent | |
| CQmitkRenderingRequestEvent | |
| ►CQFrame | |
| CQmitkDnDDataNodeWidget | A drag 'n' drop widget (QFrame) that checks the mime data of the incoming event. If the drag event is coming from another widget and the mime data is of type 'application/x-qmitk-datanode-ptrs' the node(s) will be dropped and a signal is emitted. A class including this DnD-widget can than handle the vector of dropped nodes appropriately |
| CQmitkPopupColorChooser | |
| CQmitkRenderWindowWidget | The 'QmitkRenderWindowWidget' is a QFrame that holds a render window and some associates properties, e.g. decorations. Decorations are corner annotation (text and color), frame color or background color and can be set using this class. The 'QmitkRenderWindowWidget' is used inside a 'QmitkAbstractMultiWidget', where a map contains several render window widgets to create the multi widget display. This class uses a CrosshairManager, which allows to use plane geometries as crosshair |
| CQmitkStringPropertyOnDemandEdit | |
| ►CQHash | |
| Cberry::ObjectStringMap | |
| ►CQLabel | |
| CQClickableLabel | A QLabel with multiple hotspots, that can be clicked |
| CQClickableLabel2 | |
| CQmitkBasePropertyView | |
| CQmitkColorPropertyView | |
| CQmitkCrossWidget | |
| CQmitkInvalidAnyWidget | |
| CQmitkNumberPropertyView | |
| CQmitkStringPropertyView | |
| ►CQLineEdit | |
| CQmitkAnyStringWidget | |
| CQmitkHotkeyLineEdit | |
| CQmitkStringPropertyEditor | |
| ►CQList | |
| Cberry::ObjectList< T > | |
| ►CQListView | |
| CQmitkComboBoxListView | |
| CQmitkPointListView | GUI widget for handling mitk::PointSet |
| ►CQMenu | |
| CQmitkDataNodeContextMenu | |
| ►CQMessageBox | |
| CQmitkStaticDynamicSegmentationDialog | Dialog for static / dynamic segmentation node creation |
| ►CQmitkAbstractDataNodeAction | |
| CQmitkDataNodeColorAction | |
| CQmitkDataNodeColorMapAction | |
| CQmitkDataNodeComponentAction | |
| CQmitkDataNodeGlobalReinitAction | |
| CQmitkDataNodeHideAllAction | |
| CQmitkDataNodeOpacityAction | |
| CQmitkDataNodeOpenInAction | |
| CQmitkDataNodeReinitAction | |
| CQmitkDataNodeRemoveAction | |
| CQmitkDataNodeResetGeometryAction | |
| CQmitkDataNodeShowDetailsAction | |
| CQmitkDataNodeShowSelectedNodesAction | |
| CQmitkDataNodeSurfaceRepresentationAction | |
| CQmitkDataNodeTextureInterpolationAction | |
| CQmitkDataNodeToggleVisibilityAction | |
| ►CQmitkAnyAdapter | |
| CQmitkAnyBoolWidget | |
| CQmitkAnyDoubleWidget | |
| CQmitkAnyFloatWidget | |
| CQmitkAnyIntWidget | |
| CQmitkAnyShortWidget | |
| CQmitkAnyStringWidget | |
| CQmitkAnyUIntWidget | |
| CQmitkAnyUShortWidget | |
| CQmitkAnyVectorWidget | |
| CQmitkInvalidAnyWidget | |
| CQmitkApplicationConstants | |
| CQmitkDataStorageTableModel::DataNodeCompareFunction | A struct that you can use in std::sort algorithm for sorting the node list elements |
| CQmitkDataStorageTreeModelInternalItem | |
| CQmitkGPULoader | Class to load and save GPU information for further validation |
| CQmitkGPUSpec | Struct to store GPU info |
| CQmitkHttpStatusCodeHandler | |
| CQmitkImageStatisticsTreeItem | |
| CQmitkIOUtil::SaveFilter | |
| CQmitkLevelWindowPresetDefinitionDialog::PresetTableModel::Entry | |
| ►CQmitkMappingJobSettings | |
| CQmitkFramesRegistrationJob | |
| CQmitkMappingJob | |
| CQmitkMimeTypes | Prov |
| CQmitkMultiWidgetDecorationManager | |
| CQmitknnUNetFolderParser | Class to store and retrieve folder hierarchy information of RESULTS_FOLDER. Only Root node is explicitly stored in m_RootNode. No. of sub levels in the hierarchry is defined in the LEVEL constant |
| CQmitknnUNetTaskParamsUITemplate | |
| CQmitkPropertiesTableModel::PropertyDataSetCompareFunction | A struct that you can use in std::sort algorithm for sorting the property list elements |
| CQmitkPropertiesTableModel::PropertyListElementFilterFunction | |
| CQmitkPropertyItem | |
| CQmitkPropertyListPopUp | Displays the properties from a mitk::PropertyList |
| CQmitkPropertyViewFactory | |
| CQmitkServiceListWidget::ServiceListLink | Internal structure used to link ServiceReferences to their QListWidgetItems |
| ►CQmitkSetupVirtualEnvUtil | Abstract Class to Setup a python virtual environment and pip install required packages. Derive this class for creating installer for the respective tool |
| CQmitkSAMInstaller | |
| CQmitkTotalSegmentatorToolInstaller | Installer class for TotalSegmentator Tool. Class specifies the virtual environment name, install version, packages required to pip install and implements SetupVirtualEnv method |
| CQmitkSliceNavigationListener::ObserverInfo | |
| CQmitkStatisticsModelToStringConverter | Converts the content of the statistics model to a string |
| CQmitkStyleManager | |
| CQmitkVideoBackground::VideoBackgroundVectorInfo | |
| ►CQObject | |
| Cberry::AbstractHandler | |
| Cberry::CommandContributionItem | |
| Cberry::ExtensionFactory | |
| Cberry::IntroPart | |
| Cberry::MenuManager | |
| Cberry::Plugin | |
| Cberry::PropertyTester | |
| Cberry::QtSelectionProvider | |
| Cberry::QtStyleManager | |
| Cberry::WorkbenchPart | |
| CDescriptionParameterBackgroundJob | |
| Cmitk::XnatSessionTracker | |
| CnnUNetDownloadWorker | Class to execute some functions from the Segmentation Plugin in a separate thread |
| CParameterFitBackgroundJob | |
| CQmitkCallbackFromGUIThread | Qt specific implementation of mitk::CallbackFromGUIThreadImplementation |
| CQmitkChartData | This class holds the relevant properties for the chart generation with C3 such as labels and diagram type. It is derived from QObject, because we need Q_PROPERTIES to send Data via QWebChannel to JavaScript |
| CQmitkChartxyData | |
| ►CQmitkDataGenerationJobBase | QmitkDataGenerationJobBase Base class for generation jobs used by QmitkDataGenerationBase and derived classes |
| CQmitkImageStatisticsCalculationRunnable | |
| ►CQmitkDataGeneratorBase | QmitkDataGeneratorBase BaseClass that implements the organization of (statistic) data generation for pairs of images and ROIs. The key idea is that this class ensures that for vector of given image ROI pairs (defined by derived classes) a result instance (e.g ImageStatisticsContainer) will be calculated, if needed (e.g. because it is missing or not up to date anymore), and stored in the data storage passed to a generator instance. While derived classes i.a. specify how to generate the image ROI pairs, how to detect latest results, what the next generation step is and how to remove obsolete data from the storage, the base class takes care of the observation of the data storage and orchestrates the whole checking and generation workflow. In all the generation/orchestration process the data storage, passed to the generator, 1) serves as place where the final results are stored and searched and 2) it resembles the state of the generation process with these final results and WIP place holder nodes that indicate planed or currently processed generation steps |
| ►CQmitkImageAndRoiDataGeneratorBase | |
| CQmitkImageStatisticsDataGenerator | |
| CQmitkDataManagerHotkeysPrefPage | |
| CQmitkDataManagerPreferencePage | |
| CQmitkExtWorkbenchWindowAdvisor | |
| CQmitkFramesRegistrationJob | |
| CQmitkMappingJob | |
| CQmitkModelViewSelectionConnector | The 'QmitkModelViewSelectionConnector' is used to handle the selections of a model-view-pair and to synchornize them with external node selections (e.g. communicated by the application) |
| CQmitkMultiWidgetLayoutManager | The layout manager provides different layout-functions that can modify the layout of an QmitkAbstractMultiWidget |
| ►CQmitkNodeDescriptor | Decorator class for mitk::DataNode |
| CQmitkColoredNodeDescriptor | Synchronizes the magic color #00ff00 of the given SVG icon to the mitk::DataNode color |
| CQmitkNodeDescriptorManager | QmitkNodeDescriptorManager manages a set of QmitkNodeDescriptors |
| ►CQmitkOverlay | Abstract base class for all overlay-objects in MITK |
| CQmitkCustomWidgetOverlay | Object representing a custom widget that is handled and positioned as an overlay |
| CQmitkScalarBarOverlay | Object representing a text that is drawn as an overlay |
| CQmitkTextOverlay | Object representing a text that is drawn as an overlay |
| CQmitkOverlayController | Controller that manages the positioning and stacking of QmitkOverlays |
| CQmitkPropertyListPopup | |
| CQmitkRegistrationJob | |
| CQmitkRenderingManager | Qt specific implementation of mitk::RenderingManager |
| CQmitkSegmentAnythingPreferencePage | |
| CQmitkSegmentationPreferencePage | |
| CQmitkSelectionServiceConnector | |
| CQmitkSliceNavigationListener | Helper class to allow QmitkAbstractView and derived classes to react on changes of the slice/time navigation. Purpose of the class to be used in view and to give the respective view class (by composition) the possibility to react on changes of the currently selected timepoint or position in the world geometry.
It also offers convenient signals that are only triggered when the selected timepoint or the selected position of the active render window have really changed.
In order to setup this class properly the following things must be regarded: |
| CQmitkStepperAdapter | Helper class to connect Qt-based navigators to instances of Stepper |
| CQmitkSynchronizedWidgetConnector | |
| CQmitkVideoBackground | |
| ►CQProgressBar | |
| CQmitkProgressBar | QT-Toolkit/GUI dependent class that provides the QT's ProgressBar |
| ►CQPushButton | |
| CQmitkNodeSelectionButton | Button class that can be used to display information about a given node. If the given node is a nullptr the node info text will be shown. The node info can be formatted text (e.g. HTML code; like the tooltip text) |
| ►CQRunnable | |
| CDescriptionParameterBackgroundJob | |
| CParameterFitBackgroundJob | |
| CQmitkDataGenerationJobBase | QmitkDataGenerationJobBase Base class for generation jobs used by QmitkDataGenerationBase and derived classes |
| CQmitkFramesRegistrationJob | |
| CQmitkMappingJob | |
| CQmitkRegistrationJob | |
| CQSharedPointer< T > | |
| CQSharedPointer< berry::IParameterValueConverter > | |
| ►CQSlider | |
| CQmitkNumberPropertySlider | |
| ►CQSortFilterProxyModel | |
| CQmitkDataStorageFilterProxyModel | |
| CQmitkViewProxyModel | |
| ►CQSpinBox | |
| CQmitkAnyIntWidget | |
| CQmitkAnyShortWidget | |
| CQmitkAnyUIntWidget | |
| CQmitkAnyUShortWidget | |
| CQmitkNumberPropertyEditor | |
| ►CQStandardItem | |
| CQmitkCategoryItem | |
| CQmitkViewItem | |
| ►CQStandardItemModel | |
| CQmitkViewModel | |
| ►CQString | |
| Cberry::ObjectString | |
| ►CQStyledItemDelegate | |
| CQmitkDoseColorDelegate | An item delegate for rendering and editing dose color in a QTableView |
| CQmitkDoseValueDelegate | An item delegate for rendering and editing dose values. The delegate assumes that the model uses the role Qt::UserRole+1 to indicate if the returned dose value is an absolute (data(Qt::UserRole+1) == true) or an relative dose (data(Qt::UserRole+1) == false) |
| CQmitkDoseVisualStyleDelegate | Toolkit includes |
| CQmitkInitialValuesDelegate | Toolkit includes |
| CQmitkInitialValuesTypeDelegate | An item delegate for rendering and editing the type of a initial value. It assumes that the type is encoded as int. 0: simple scalar, 1: image |
| CQmitkLabelColorItemDelegate | An item delegate for rendering and editing label color in a QmitkMultiLabelTreeView |
| CQmitkLabelToggleItemDelegate | An item delegate for rendering and editing properties that can be toggled (e.g. visibility) |
| CQmitkMapPropertyDelegate | |
| CQmitkPropertyDelegate | Own includes |
| CQmitkPropertyItemDelegate | |
| CQmitkSimpleBarrierParametersDelegate | Toolkit includes |
| CQmitkSimpleBarrierTypeDelegate | An item delegate for rendering and editing the type of a simple barrier constraint. It assumes that the type is encoded as int. 0: lower border, 1: upper border |
| ►CQSyntaxHighlighter | |
| CQmitkPythonScriptEditorHighlighter | A script highlighter for Python Scripts |
| ►CQTableView | |
| CQmitkPythonVariableStackTableView | |
| ►CQToolBar | |
| CQmitkInteractionSchemeToolBar | |
| CQmitkMultiWidgetConfigurationToolBar | |
| ►CQTreeView | |
| CQmitkMultiLabelTreeView | |
| ►CQtSingleApplication | |
| CQmitkSingleApplication | |
| ►CQVTKOpenGLNativeWidget | |
| CQmitkRenderWindow | MITK implementation of the QVTKWidget |
| ►CQWidget | |
| ►CQmitkAbstractDataStorageInspector | This abstract class is a convenient base class for easy implementation of widgets that offer a specific view onto a given DataStorage instance to inspect its contents. One may also get the selection in this inspector of the data storage |
| ►CQmitkDataStorageListInspector | |
| CQmitkDataStorageFavoriteNodesInspector | |
| CQmitkDataStorageSelectionHistoryInspector | |
| CQmitkDataStorageTreeInspector | |
| CQmitkRenderWindowContextDataStorageInspector | |
| CQmitkRenderWindowDataStorageInspector | |
| ►CQmitkAbstractMultiWidget | The 'QmitkAbstractMultiWidget' is a 'QWidget' that can be subclassed to display multiple render windows at once. Render windows can dynamically be added and removed to change the layout of the multi widget. A subclass of this multi widget can be used inside a 'QmitkAbstractMultiWidgetEditor' |
| CQmitkMxNMultiWidget | The 'QmitkMxNMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once. Render windows can dynamically be added and removed to change the layout of the multi widget. This is done by using the 'SetLayout'-function to define a layout. This will automatically add or remove the appropriate number of render window widgets |
| CQmitkStdMultiWidget | The 'QmitkStdMultiWidget' is a 'QmitkAbstractMultiWidget' that is used to display multiple render windows at once. Render windows are predefined in a 2x2 design with 3 different 2D view planes and a 3D render window |
| ►CQmitkAbstractNodeSelectionWidget | Abstract base class for the selection of data from a data storage |
| CQmitkMultiNodeSelectionWidget | Widget that allows to perform and represents a multiple node selection |
| CQmitkSingleNodeSelectionWidget | Widget that represents a node selection of (max) one node. It acts like a button. Clicking on it allows to change the selection |
| CQmitkSynchronizedNodeSelectionWidget | |
| CQmitkAlgorithmProfileViewer | Widget that views the information and profile of an algorithm stored in an DLLInfo object |
| CQmitkAlgorithmSettingsConfig | Widget that views the information and profile of an algorithm stored in an DLLInfo object |
| CQmitkAutomatedLayoutWidget | |
| CQmitkBooleanOperationsWidget | |
| CQmitkBoundingObjectWidget | |
| CQmitkChartWidget | QmitkChartWidget is a widget to display various charts based on the javascript chart library plotly |
| CQmitkColorWidget | |
| CQmitkConvertToMultiLabelSegmentationWidget | QmitkConvertToMultiLabelSegmentationWidget |
| CQmitkDicomExternalDataWidget | QmitkDicomExternalDataWidget is a QWidget providing functionality for dicom import |
| CQmitkDicomLocalStorageWidget | QmitkDicomLocalStorageWidget is a QWidget providing functionality for dicom storage and import |
| CQmitkDnDFrameWidget | Enables loading data into a MITK application via Drag'n Drop |
| CQmitkExtractFromMultiLabelSegmentationWidget | QmitkExtractFromMultiLabelSegmentationWidget |
| CQmitkFileChooser | Convenience Widget showing a line edit with the path of a file or directory and a button which invokes a file choose dialog |
| CQmitkFileReaderWriterOptionsWidget | |
| CQmitkFitParameterWidget | |
| CQmitkFitPlotDataWidget | |
| CQmitkFreeIsoDoseLevelWidget | Widget that allows to show and edit the content of an mitk::IsoDoseLevel instance |
| CQmitkHistogramVisualizationWidget | Widget for displaying Histograms |
| CQmitkImageMaskingWidget | QmitkImageMaskingWidget |
| CQmitkImageStatisticsWidget | |
| CQmitkInitialValuesManagerWidget | Widget that allows to edit the initial values of an model |
| CQmitkInspectionPositionWidget | Widget that allows manage the positions that should be used to inspect fits |
| CQmitkIntensityProfileVisualizationWidget | Widget for displaying intensity profiles |
| CQmitkLevelWindowWidget | |
| CQmitkLevelWindowWidgetContextMenu | Provides a contextmenu for Level/Window functionality |
| CQmitkLineEditLevelWindowWidget | Provides a widget with two lineedit fields, one to change the window value of the current image and one to change the level value of the current image |
| CQmitkMapperSettingsWidget | Widget that views the information and profile of an algorithm stored in an DLLInfo object |
| CQmitkMaskStampWidget | GUI for mask stamp functionality |
| CQmitkMemoryUsageIndicatorView | |
| CQmitkMorphologicalOperationsWidget | GUI class for morphological segmentation tools |
| CQmitkMultiLabelInspector | |
| CQmitkMultiLabelManager | |
| CQmitkMultiWidgetLayoutSelectionWidget | |
| CQmitkNodeSelectionListItemWidget | |
| CQmitkOverlayContainerWidget | Widget that overrides the paintEvent method to correctly display the Qt based overlays when using the system-environment variable QT_DEVICE_PIXEL_RATIO |
| ►CQmitkOverlayWidget | |
| CQmitkButtonOverlayWidget | |
| CQmitkSimpleTextOverlayWidget | |
| CQmitkPlotWidget | |
| CQmitkPointListWidget | Widget for regular operations on point sets |
| CQmitkPrimitiveMovieNavigatorWidget | |
| CQmitkPropertiesTableEditor | Combines a QTableView along with a QmitkPropertiesTableModel to a reusable Property Editor component |
| CQmitkPythonSnippets | Widget that holds snippets and serializes the snippets to a certain places |
| CQmitkPythonTextEditor | This is a python text editor with syntax highlighting |
| CQmitkRegEvalSettingsWidget | Widget that views the information and profile of an algorithm stored in an DLLInfo object |
| CQmitkRegistrationManipulationWidget | QmitkMatchPointRegistrationManipulator |
| CQmitkRenderWindowMenu | The QmitkRenderWindowMenu is a popup Widget which shows up when the mouse cursor enter a QmitkRenderWindow. The Menu Widget is located in the right top corner of each RenderWindow. It includes different settings. For example the layout design can be changed with the setting button. Switching between full-screen mode and layout design can be done with the full-screen button. The popup Widget can be deactivated with ActivateMenuWidget(false) in QmitkRenderWindow |
| CQmitkRenderWindowUtilityWidget | |
| CQmitkScalarBar | |
| CQmitkSegmentationTaskListWidget | |
| CQmitkServiceListWidget | This widget provides abstraction for the handling of MicroServices |
| CQmitkSimpleBarrierManagerWidget | Widget that allows to edit the constraints of SimpleBarrierConstraintChecker |
| CQmitkSimpleLabelSetListWidget | Widget that offers a simple list that displays all labels (color and name) in the active layer of a LabelSetImage |
| CQmitkSliceNavigationWidget | |
| CQmitkSlicesInterpolator | GUI for slices interpolation |
| CQmitkSliceWidget | |
| CQmitkSliderLevelWindowWidget | Provides a widget with a slider to change the level and window value of the current image |
| CQmitkStandardViews | |
| CQmitkSurfaceStampWidget | GUI for surface-based interpolation |
| CQmitkToolGUI | Base class for GUIs belonging to mitk::Tool classes |
| CQmitkToolGUIArea | Dummy class for putting into a GUI (mainly using Qt Designer) |
| CQmitkToolSelectionBox | Display the tool selection state of a mitk::ToolManager |
| ►CQmitkTransferFunctionCanvas | |
| CQmitkColorTransferFunctionCanvas | |
| CQmitkPiecewiseFunctionCanvas | |
| CQmitkTransferFunctionGeneratorWidget | |
| CQmitkTransferFunctionWidget | |
| CQmitkXnatExperimentWidget | |
| CQmitkXnatProjectWidget | |
| CQmitkXnatSubjectWidget | |
| ►CStep6 | |
| CStep7 | |
| CStep8 | |
| ►CQWidgetAction | |
| CQmitkDataNodeColorAction | |
| CQmitkDataNodeComponentAction | |
| CQmitkDataNodeOpacityAction | |
| ►CQwtPlotItem | |
| CQmitkHistogram | Used to create a histogram that can be shown in a Qwt Plot. See QmitkHistogramWidget for an example of its usage |
| CServiceEventListenerHook | |
| CServiceObjects< S > | |
| Cus::ServiceReference< mitk::IPythonService > | |
| Cus::ServiceTrackerCustomizer< Annotation, TrackedTypeTraits< Annotation, Annotation * > ::TrackedType > | |
| Cus::ServiceTrackerCustomizer< ctkXnatSession, TrackedTypeTraits< ctkXnatSession, ctkXnatSession * > ::TrackedType > | |
| ►Cus::ServiceTrackerCustomizer< CustomMimeType, MimeType > | |
| Cmitk::MimeTypeProvider | |
| ►Cus::ServiceTrackerCustomizer< mitk::CustomMimeType, mitk::MimeTypeTrackerTypeTraits ::TrackedType > | |
| Cus::ServiceTracker< mitk::CustomMimeType, mitk::MimeTypeTrackerTypeTraits > | |
| Cus::ServiceTrackerCustomizer< mitk::InteractionEventObserver, TrackedTypeTraits< mitk::InteractionEventObserver, mitk::InteractionEventObserver * > ::TrackedType > | |
| ►Cus::ServiceTrackerCustomizer< S, TrackedTypeTraits< S, S * > ::TrackedType > | |
| Cus::ServiceTracker< S, TTT > | |
| Cus::SharedDataPointer< const Impl > | |
| Cus::SharedDataPointer< EventConfigPrivate > | |
| Cus::SharedDataPointer< Impl > | |
| Cus::SharedDataPointer< LDAPFilterData > | |
| Cus::SharedDataPointer< ModuleEventData > | |
| Cus::SharedDataPointer< ServiceEventData > | |
| Cberry::SmartPointer< berry::Command > | |
| Cberry::SmartPointer< berry::CommandCategory > | |
| Cberry::SmartPointer< berry::IActionBarConfigurer > | |
| Cberry::SmartPointer< berry::IContributionManagerOverrides > | |
| Cberry::SmartPointer< berry::IElementReference > | |
| Cberry::SmartPointer< berry::IHandler > | |
| Cberry::SmartPointer< berry::ISelectionProvider > | |
| Cberry::SmartPointer< berry::IServiceLocator > | |
| Cberry::SmartPointer< berry::IStatus > | |
| Cberry::SmartPointer< berry::IWorkbenchWindowConfigurer > | |
| Cberry::SmartPointer< berry::MenuManager > | |
| Cberry::SmartPointer< berry::ParameterizedCommand > | |
| Cberry::SmartPointer< berry::ParameterType > | |
| Cberry::SmartPointer< berry::Shell > | |
| Cberry::SmartPointer< const berry::EvaluationResult > | |
| Cberry::SmartPointer< const berry::IParameter > | |
| Cberry::SmartPointer< const berry::ISelection > | |
| Cberry::SmartPointer< const Self > | |
| Citk::SmartPointer< const Self > | |
| Citk::SmartPointer< DataStorage > | |
| Citk::SmartPointer< FunctionType > | |
| Citk::SmartPointer< HistogramType > | |
| Citk::SmartPointer< ImageDataItem > | |
| Citk::SmartPointer< ImageType > | |
| Citk::SmartPointer< InteractionEvent > | |
| Citk::SmartPointer< Mapper > | |
| Citk::SmartPointer< mitk::EditableContourTool > | |
| Citk::SmartPointer< mitk::Mapper > | |
| Citk::SmartPointer< mitk::PersistenceService > | |
| Citk::SmartPointer< mitk::PointSet > | |
| Citk::SmartPointer< mitk::SliceNavigationController > | |
| Citk::SmartPointer< mitk::Surface > | |
| Citk::SmartPointer< mitk::TimeNavigationController > | |
| Citk::SmartPointer< mitk::UnstructuredGrid > | |
| Citk::SmartPointer< mitk::WeightedPointTransform > | |
| Cberry::SmartPointer< Self > | |
| Citk::SmartPointer< Self > | |
| Citk::SmartPointer< StateMachineState > | |
| ►Cstd::exception | STL class |
| Cmitk::TestFailedException | Indicate a failed test |
| ►Cstd::bad_cast | STL class |
| Cus::BadAnyCastException | |
| ►Cstd::runtime_error | STL class |
| Cmitk::AccessByItkException | Exception class thrown in AccessByItk macros |
| Cus::ServiceException | |
| ►Cstd::ios_base | STL class |
| ►Cstd::basic_ios< Char > | STL class |
| ►Cstd::basic_istream< Char > | STL class |
| ►Cstd::istream | STL class |
| Cmitk::AbstractFileReader::InputStream | An input stream wrapper |
| Cus::ModuleResourceStream | |
| ►Cstd::basic_ostream< Char > | STL class |
| ►Cstd::ostream | STL class |
| Cmitk::AbstractFileWriter::OutputStream | An output stream wrapper |
| ►CToolEvent | |
| Cmitk::ParameterToolEvent< T > | Tool event with 1 parameter |
| Cmitk::TwoParameterToolEvent< T, U > | Tool event with 1 parameter |
| ►Cus::TrackedTypeTraitsBase< MimeType, MimeTypeTrackerTypeTraits > | |
| Cmitk::MimeTypeTrackerTypeTraits | |
| ►Cus::TrackedTypeTraitsBase< T *, TrackedTypeTraits< S, T * > > | |
| Cus::TrackedTypeTraits< S, T * > | |
| ►CTTransformType | |
| Cmitk::ItkMatrixHack< TTransformType > | Internal hack to set m_MatrixMTime of itk::MatrixOffsetTransformBase correctly after changing the matrix. For internal use only |
| ►CQmitkAlgorithmProfileViewer | |
| CQmitkAlgorithmProfileViewer | Widget that views the information and profile of an algorithm stored in an DLLInfo object |
| ►CQmitkAlgorithmSettingsConfig | |
| CQmitkAlgorithmSettingsConfig | Widget that views the information and profile of an algorithm stored in an DLLInfo object |
| ►CQmitkFreeIsoDoseLevelWidget | |
| CQmitkFreeIsoDoseLevelWidget | Widget that allows to show and edit the content of an mitk::IsoDoseLevel instance |
| ►CQmitkLevelWindowPresetDefinition | |
| CQmitkLevelWindowPresetDefinitionDialog | |
| ►CQmitkLevelWindowRangeChange | |
| CQmitkLevelWindowRangeChangeDialog | |
| ►CQmitkMapperSettingsWidget | |
| CQmitkMapperSettingsWidget | Widget that views the information and profile of an algorithm stored in an DLLInfo object |
| ►CQmitkRegEvalSettingsWidget | |
| CQmitkRegEvalSettingsWidget | Widget that views the information and profile of an algorithm stored in an DLLInfo object |
| ►CQmitkRegistrationManipulationWidget | |
| CQmitkRegistrationManipulationWidget | QmitkMatchPointRegistrationManipulator |
| ►CQmitkSliceNavigationWidget | |
| CQmitkSliceNavigationWidget | |
| ►CQmitkSliceWidgetUi | |
| CQmitkSliceWidget | |
| ►CQmitkTransferFunctionGeneratorWidget | |
| CQmitkTransferFunctionGeneratorWidget | |
| ►CQmitkTransferFunctionWidget | |
| CQmitkTransferFunctionWidget | |
| Cus::Any | |
| Cus::ExplicitlySharedDataPointer< T > | |
| Cus::InterfaceType< Interface > | |
| Cus::LDAPFilter | |
| Cus::LDAPProp | |
| Cus::MakeInterfaceMap< I1, I2, I3 > | |
| Cus::Module | |
| ►Cus::ModuleActivator | |
| Cmitk::CESTIOActivator | |
| Cmitk::DICOMImageIOActivator | |
| Cmitk::PersistenceActivator | |
| Cmitk::ROIIOModuleActivator | |
| CMitkCoreActivator | |
| CMitkQtWidgetsActivator | |
| CMitkRESTServiceActivator | |
| Cus::ModuleEvent | |
| Cus::ModuleEventHook | |
| Cus::ModuleFindHook | |
| Cus::ModuleInfo | |
| Cus::ModuleRegistry | |
| Cus::ModuleResource | |
| Cus::ModuleSettings | |
| Cus::ModuleVersion | |
| Cus::ServiceEvent | |
| ►Cus::ServiceFactory | |
| Cus::PrototypeServiceFactory | |
| Cus::ServiceFindHook | |
| ►Cus::ServiceObjectsBase | |
| Cus::ServiceObjects< mitk::IFileReader > | |
| Cus::ServiceObjects< mitk::IFileWriter > | |
| Cus::ServiceObjects< S > | |
| Cus::ServiceObjects< void > | |
| Cus::ServiceReference< S > | |
| Cus::ServiceReferenceBase | |
| ►Cus::ServiceRegistrationBase | |
| Cus::ServiceRegistration< mitk::CustomMimeType > | |
| Cus::ServiceRegistration< mitk::IFileReader > | |
| Cus::ServiceRegistration< mitk::IFileWriter > | |
| Cus::ServiceRegistration< mitk::IMimeTypeProvider > | |
| Cus::ServiceRegistration< mitk::InteractionEventObserver > | |
| Cus::ServiceRegistration< mitk::IPersistenceService > | |
| Cus::ServiceRegistration< Self > | |
| Cus::ServiceRegistration< I1, I2, I3 > | |
| ►Cus::ServiceTrackerCustomizer< S, T > | |
| ►Cus::ServiceTracker< Annotation > | |
| ►Cmitk::AbstractAnnotationRenderer | Baseclass of Annotation layouters An AbstractAnnotationRenderer can be implemented to control a set of Annotation by means of position and size |
| Cmitk::LayoutAnnotationRenderer | The LayoutAnnotationRenderer is used for the layouted placement of mitk::Annotation Objects |
| Cmitk::ManualPlacementAnnotationRenderer | The ManualPlacementAnnotationRenderer is used for the simple placement of mitk::Annotation Objects |
| ►Cus::ServiceTracker< ctkXnatSession > | |
| Cmitk::XnatSessionTracker | |
| Cus::ServiceTracker< mitk::InteractionEventObserver > | |
| Cus::ServiceTrackerPrivate< S, T > | |
| Cus::SharedData | |
| Cus::SharedDataPointer< T > | |
| Cus::SharedLibrary | |
| Cus::ShrinkableMap< Key, T > | |
| Cus::ShrinkableVector< E > | |
| Cus::TrackedService< S, T > | |
| Cus::TrackedTypeTraitsBase< T, TTT > | |
| CVectorTraits< T > | |
| CVectorTraits< double[3]> | |
| CVectorTraits< double[4]> | |
| CVectorTraits< float[3]> | |
| CVectorTraits< float[4]> | |
| CVectorTraits< itk::Index< 3 > > | |
| CVectorTraits< itk::Index< 5 > > | |
| CVectorTraits< itk::IndexValueType[3]> | |
| CVectorTraits< itk::Point< double, 3 > > | |
| CVectorTraits< itk::Point< double, 4 > > | |
| CVectorTraits< itk::Point< float, 3 > > | |
| CVectorTraits< itk::Point< float, 4 > > | |
| CVectorTraits< itk::SizeValueType[3]> | |
| CVectorTraits< itk::Vector< double, 3 > > | |
| CVectorTraits< itk::Vector< float, 3 > > | |
| CVectorTraits< itk::Vector< int, 3 > > | |
| CVectorTraits< mitk::Point< double, 3 > > | |
| CVectorTraits< mitk::Point< double, 4 > > | |
| CVectorTraits< mitk::Point< float, 3 > > | |
| CVectorTraits< mitk::Point< float, 4 > > | |
| CVectorTraits< mitk::Point< int, 3 > > | |
| CVectorTraits< mitk::Vector< double, 3 > > | |
| CVectorTraits< mitk::VnlVector > | |
| CVectorTraits< unsigned int * > | |
| CVectorTraits< unsigned int[3]> | |
| CVectorTraits< vnl_vector_fixed< mitk::ScalarType, 3 > > | |
| ►CvtkActor2D | |
| CvtkMitkRectangleProp | Renders a rectangle into a renderwindow as a frame |
| ►CvtkGlyph2D | |
| CvtkMaskedGlyph2D | |
| ►CvtkGlyph3D | |
| CvtkMaskedGlyph3D | |
| ►CvtkImageReslice | |
| CmitkVtkImageOverwrite | A vtk Filter based on vtkImageReslice with the additional feature to write a slice into the given input volume. All optimizations for e.g. the plane directions or interpolation are stripped away, the algorithm only interpolates nearest neighbor and uses the non optimized execute function of vtkImageReslice. Note that any interpolation doesn't make sense for round trip use extract->edit->overwrite, because it is nearly impossible to invert the interpolation. There are two use cases for the Filter which are specified by the overwritemode property: |
| ►CvtkInteractorObserver | |
| Cmitk::vtkEventProvider | Integrates into the VTK event mechanism to generate MITK specific events. This class is NON-QT dependent pandon to the current MITK event handling code in QmitkRenderWindow |
| ►CvtkInteractorStyleUser | |
| Cmitk::VtkInteractorStyle | Implements the handling of events that are missing for MITK interaction |
| ►CvtkLogoRepresentation | |
| CmitkVtkLogoRepresentation | |
| ►CvtkMapper | |
| CvtkUnstructuredGridMapper | |
| ►CvtkObjectFactory | |
| CvtkNeverTranslucentTextureFactory | Factory for vtkNeverTranslucentTexture (see this class!) |
| ►CvtkOpenGLTexture | |
| CvtkNeverTranslucentTexture | VTK Fix to speed up our image rendering |
| ►CvtkOutputWindow | |
| Cmitk::VtkLoggingAdapter | Adapter that overwrites the standard vtk logging output window and sends the logging messages to the MITK logging instead |
| ►CvtkPolyDataAlgorithm | |
| CvtkPointSetSlicer | |
| ►CvtkProp | |
| CvtkGLMapperProp | VtkProp, wrapping a GLMapper |
| CvtkMitkRenderProp | VtkMitkRenderProp |
| CvtkSmartPointer< T > | |
| CvtkSmartPointer< mitkVtkLogoRepresentation > | |
| CvtkSmartPointer< vtkActor > | |
| CvtkSmartPointer< vtkActor2D > | |
| CvtkSmartPointer< vtkAppendPolyData > | |
| CvtkSmartPointer< vtkArrowSource > | |
| CvtkSmartPointer< vtkAssembly > | |
| CvtkSmartPointer< vtkAssemblyPaths > | |
| CvtkSmartPointer< vtkCellArray > | |
| CvtkSmartPointer< vtkCellPicker > | |
| CvtkSmartPointer< vtkColorTransferFunction > | |
| CvtkSmartPointer< vtkContext2D > | |
| CvtkSmartPointer< vtkCornerAnnotation > | |
| CvtkSmartPointer< vtkCubeSource > | |
| CvtkSmartPointer< vtkCutter > | |
| CvtkSmartPointer< vtkDepthSortPolyData > | |
| CvtkSmartPointer< vtkDoubleArray > | |
| CvtkSmartPointer< vtkFloatArray > | |
| CvtkSmartPointer< vtkFollower > | |
| CvtkSmartPointer< vtkGenericOpenGLRenderWindow > | |
| CvtkSmartPointer< vtkGLMapperProp > | |
| CvtkSmartPointer< vtkGlyph3D > | |
| CvtkSmartPointer< vtkGlyphSource2D > | |
| CvtkSmartPointer< vtkImageChangeInformation > | |
| CvtkSmartPointer< vtkImageData > | |
| CvtkSmartPointer< vtkImageExtractComponents > | |
| CvtkSmartPointer< vtkImageImport > | |
| CvtkSmartPointer< vtkImageMapToColors > | |
| CvtkSmartPointer< vtkImageReader2Factory > | |
| CvtkSmartPointer< vtkImageReslice > | |
| CvtkSmartPointer< vtkIntArray > | |
| CvtkSmartPointer< vtkLabelPlacementMapper > | |
| CvtkSmartPointer< vtkLandmarkTransform > | |
| CvtkSmartPointer< vtkLegendScaleActor > | |
| CvtkSmartPointer< vtkLookupTable > | |
| CvtkSmartPointer< vtkMatrix4x4 > | |
| CvtkSmartPointer< vtkMitkLevelWindowFilter > | |
| CvtkSmartPointer< vtkMitkThickSlicesFilter > | |
| CvtkSmartPointer< vtkNeverTranslucentTexture > | |
| CvtkSmartPointer< vtkOpenGLContextDevice2D > | |
| CvtkSmartPointer< vtkPen > | |
| CvtkSmartPointer< vtkPiecewiseFunction > | |
| CvtkSmartPointer< vtkPlane > | |
| CvtkSmartPointer< vtkPlaneCollection > | |
| CvtkSmartPointer< vtkPlaneSource > | |
| CvtkSmartPointer< vtkPoints > | |
| CvtkSmartPointer< vtkPointSetToLabelHierarchy > | |
| CvtkSmartPointer< vtkPolyData > | |
| CvtkSmartPointer< vtkPolyDataMapper > | |
| CvtkSmartPointer< vtkPolyDataMapper2D > | |
| CvtkSmartPointer< vtkPolyDataNormals > | |
| CvtkSmartPointer< vtkPropAssembly > | |
| CvtkSmartPointer< vtkRenderer > | |
| CvtkSmartPointer< vtkRenderWindow > | |
| CvtkSmartPointer< vtkReverseSense > | |
| CvtkSmartPointer< vtkScalarBarActor > | |
| CvtkSmartPointer< vtkSmartVolumeMapper > | |
| CvtkSmartPointer< vtkStringArray > | |
| CvtkSmartPointer< vtkTextActor > | |
| CvtkSmartPointer< vtkTextProperty > | |
| CvtkSmartPointer< vtkTexture > | |
| CvtkSmartPointer< vtkTransformPolyDataFilter > | |
| CvtkSmartPointer< vtkTubeFilter > | |
| CvtkSmartPointer< vtkVectorText > | |
| CvtkSmartPointer< vtkVolume > | |
| CvtkSmartPointer< vtkVolumeProperty > | |
| CvtkSmartPointer< VtkWriterType > | |
| ►CvtkThreadedImageAlgorithm | |
| CvtkMitkLevelWindowFilter | Applies the grayvalue or color/opacity level window to scalar or RGB(A) images |
| CvtkMitkThickSlicesFilter | |
| ►CvtkXMLParser | |
| Cmitk::AnatomicalStructureColorPresets | |
| Cmitk::LevelWindowPreset | |
| Cmitk::ParamapPresetsParser | |
| Cmitk::StateMachineContainer | |
| Cmitk::vtkPointSetXMLParser | Implementation of the vtkXMLParser interface for reading mitk::PointSets |
| Cmitk::XML2EventParser | |
| Cmitk::WeakPointer< const mitk::DataNode > | |
| Cmitk::WeakPointer< const mitk::Label > | |
| Cmitk::WeakPointer< DataInteractor > | |
| Cmitk::WeakPointer< mitk::BaseData > | |
| Cmitk::WeakPointer< mitk::BaseRenderer > | |
| Cmitk::WeakPointer< mitk::DataInteractor > | |
| Cmitk::WeakPointer< mitk::DataNode > | |
| Cmitk::WeakPointer< mitk::DataStorage > | |
| Cmitk::WeakPointer< mitk::DICOMTagCache > | |
| Cmitk::WeakPointer< mitk::DisplayActionEventBroadcast > | |
| Cmitk::WeakPointer< mitk::LabelSetImage > | |
| Cmitk::WeakPointer< mitk::PropertyList > | |
| Cmitk::WeakPointer< mitk::TimeNavigationController > | |
1.8.17