Welcome to MITK’s documentation!¶
-
namespace
mitk
¶
-
namespace
std
¶ STL namespace.
-
file
AboutTestingPage.dox
-
file
Annotation.dox
-
file
Applications.dox
-
file
Architecture.dox
-
file
BasicDataTypes.dox
-
file
BlueBerryExamples.dox
-
file
BlueBerryExtensionPointReference.dox
-
file
BlueBerryExtensionPointsIntro.dox
-
file
BlueBerryIntro.dox
-
file
BlueBerrySelectionServiceIntro.dox
-
file
BuildInstructions.dox
-
file
CMakeFAQ.dox
-
file
Coding.dox
-
file
Concepts.dox
-
file
DataInteraction.dox
-
file
DataInteractionTechnical.dox
-
file
DataManagement.dox
-
file
Deployment.dox
-
file
DeveloperManualPortal.dox
-
file
DevelopmentApplication.dox
-
file
DICOMTesting.dox
-
file
DirectoryStructure.dox
-
file
DocumentationExample.dox
-
file
DocumentationGuide.dox
-
file
Exceptions.dox
-
file
ExtensionPointReference.dox
-
file
FirstSteps.dox
-
file
GeometryMigration.dox
-
file
GeometryOverview.dox
-
file
GettingToKnowMITK.dox
-
file
Groups.dox
-
file
HowToNewProject.dox
-
file
Interaction.dox
-
file
InteractionHowTo.dox
-
file
InteractionMigration.dox
-
file
InteractionTestingHowTo.dox
-
file
KnownProblems.dox
-
file
Logging.dox
-
file
MiniAppCommandLineToolHowTo.dox
-
file
MiniApps.dox
-
file
MitkImage.dox
-
file
MITKModuleManualsList.dox
-
file
MITKPerspectiveManualsList.dox
-
file
MITKPluginManualsList.dox
-
file
Modularization.dox
-
file
ModuleMicroServices.dox
-
file
NewDataType.dox
-
file
NewEvents.dox
-
file
NewModule.dox
-
file
NewPlugin.dox
-
file
NewView.dox
-
file
OverlayMigration.dox
-
file
Overview.dox
-
file
Pages.dox
-
file
Persistence.dox
-
file
Pipelining.dox
-
file
Properties.dox
-
file
QVTKRendering.dox
-
file
ReaderWriterPage.md
-
file
README.md
-
file
RenderingTests.dox
-
file
SettingUpMITK.dox
-
file
Starting.dox
-
file
Step00.dox
-
file
Step01.dox
-
file
Step02.dox
-
file
Step03.dox
-
file
Step04.dox
-
file
Step05.dox
-
file
Step06.dox
-
file
Step07.dox
-
file
Step08.dox
-
file
Step09.dox
-
file
Step10.dox
-
file
StyleGuideAndNotes.dox
-
file
SupportedPlatforms.md
-
file
TestsGeneral.dox
Functions
-
section GeneralTestsDeprecatedOldTestingStyle Deprecated macros All tests with MITK_TEST_BEGIN()
-
and MITK_TEST_END()
Variables
-
use the deprecated old MITK testing style If possible
-
-
file
ThirdPartyLibs.dox
-
file
Troubleshooting.dox
-
file
Tutorial.dox
-
file
UserManualPortal.dox
-
group
ToolManagerEtAl
A couple of classes related to the Segmentation plugin. See also QmitkSegmentationTechnicalPage.
-
group
MITKModules
This group includes all MITK Modules.
-
group
BlueBerryPlugins
This group includes all BlueBerry Plugins.
-
group
MITKPlugins
This group includes all MITK Plugins.
-
group
MITKExamplePlugins
This group includes all MITK example plugins demonstrating specific framework features.
-
group
MITKTestingAPI
In this group, the API documentation of methods useful for testing is collected. The more general concepts of testing in MITK are described on the General: Tests in MITK page.
-
group
MITKDeprecatedAPI
-
group
MicroServices
-
group
MicroServicesUtils
-
page
Overview
The Medical Imaging Interaction Toolkit (MITK) is a versatile and flexible open-source project. It can be used as a C++ toolkit or application framework for software development. The following sections describe the most common usage scenarios.
I want to use MITK as an application
You will use the MITK Workbench as an end user and will find user manuals in User Manual and MITK Plugin Manuals.
I want to develop my own software framework, and use some of MITK’s data structures and algorithms
You will use MITK as a toolkit and probably benefit most from the Build Instructions and MITK API Documentation.
I want to use the MITK and BlueBerry software framework to develop my own software
Here you have again two options.
I want use the MITK Workbench and extend its capabilities
You are using MITK as software framework and writing your own modules and plugins for MITK. You want to read the Build Instructions and further on Development. Also you might want to take a look at our CMake FAQ.
I want to create my own application based on MITK
This is probably the most common way to use MITK. You are using MITK as software framework and building your own project and application using MITK. You want to read Creating a new MITK project and the general information in Development. Also you might want to take a look at our CMake FAQ.
-
page
ApplicationsPage
-
page
MiniAppExplainPage
-
page
PerspectiveListPage
-
page
PluginListPage
-
page
UserManualPortal
To get an introduction to the usage of any MITK based application please read MITKUserManualPage. It will give you an overview of most of the common questions, such as how to load or save data or navigate within it. This is a good starting point for first questions.
Depending on what kind of work you intend do perform with MITK, certain applications are better suited to your needs than others. MITK offers a number of these Applications, each of which features a set of Plugins, which can solve certain tasks. To Learn more about MITK applications, please visit the Using MITK and Applications.
For more specific information on how a plugin operates you can find the plugin documentation in MITK Plugin Manuals. The Plugin documentation usually explains the functionality in depth and should solve most problems you might encounter with the plugin. Depending on the application you are using you might have only some or all of the listed plugins available.
Lastly, if your question is not answered here, please use our Mailinglist to let us know about your problem. Alternatively, you can contact us directly.
List of topics
- MITKUserManualPage
- Using MITK and Applications
- MITK Plugin Manuals
- MITK Perspective Manuals
- MITK MiniApps
-
page
BlueBerryExamples
The following examples give an introduction to Blueberry.
The source code of the examples can be found in mitk/Examples/Plugins/
Run the examples by executing startBlueBerryExampleLauncher_release.bat (or startBlueBerryExampleLauncher_debug.bat depending on the configured build type).
All examples can be found among the shown list.
- BlueBerryExampleMinimalApplication
- BlueBerryExampleMultiplePerspectives
- Selection Service
- Extension Points
- BlueBerryExampleCustomViewer
-
page
BlueBerryExampleExtensionPoint
A minimal applictaion that definines an extension point and collects extensions.
- Introduction
- Extension Point Definition
- Extension Contribution
-
page
IntroductionExtensionPoints
The BlueBerry application framework provides the concept of extension points and extensions. The main goal is to allow the extension of functionality of a plugin (based on the contract defined by the extension point) by several other plugins. Both the extension point and the extension are defined in the according plugin.xml.
-
page
BlueBerryIntro
BlueBerry is an application framework used in MITK for creating modular and extensible end-user applications.
More high-level documentation can be found below:
Please see the BlueBerry Examples for code examples demonstrating different features of the application framework.
The BlueBerry developer reference is available here:
-
page
BlueBerryWorkbench
BlueBerry makes use of the Eclipse UI guidlines which state some concepts on how to build up a GUI. The different objects of the platform UI shall be described here:
-
page
BlueBerrySelectionServiceIntro
- Introduction
- BlueBerryExampleSelectionServiceQt
- BlueBerryExampleSelectionServiceMitk
-
page
IntroductionSelectionService
The selection service provided by the BlueBerry workbench allows efficient linking of different parts within the workbench window: View parts that provide additional information for particular objects and update their content automatically whenever such objects are selected somewhere in the workbench window. For example the “Properties” view in MITK applications behaves in this way: Wherever an element is selected in the workbench this view lists the properties of that element.
Other aspects of the workbench like the enablement of global actions may also depend on the current selection.
Each workbench window has its own selection service instance. The service keeps track of the selection in the currently active part and propagates selection changes to all registered listeners. Such selection events occur when the selection in the current part is changed or when a different part is activated. Both can be triggered by user interaction or programmatically.
-
page
BlueBerryExtPointsIndex
The following extension points can be used to extend the capabilities of the platform infrastructure:
Platform Core Expressions
- org.blueberry.core.expressions.definitions
- org.blueberry.core.expressions.commonExpression
- org.blueberry.core.expressions.propertyTesters
Platform Runtime
Workbench
- org.blueberry.ui.editors
- org.blueberry.ui.elementFactories
- org.blueberry.ui.keywords
- org.blueberry.ui.menus
- org.blueberry.ui.perspectiveExtensions
- org.blueberry.ui.perspectives
- org.blueberry.ui.preferencePages
- org.blueberry.ui.presentationFactories
- org.blueberry.ui.services
- org.blueberry.ui.tweaklets
- org.blueberry.ui.views
Other
-
page
xp_org_blueberry_core_expressions_definitions
-
page
xp_org_blueberry_core_expressions_commonExpression
-
page
xp_org_blueberry_core_expressions_propertyTesters
-
page
xp_org_blueberry_osgi_applications
-
page
xp_org_blueberry_core_runtime_products
-
page
xp_org_blueberry_ui_elementFactories
-
page
xp_org_blueberry_ui_menus
-
page
xp_org_blueberry_ui_perspectiveExtensions
-
page
xp_org_blueberry_ui_editors
-
page
xp_org_blueberry_ui_perspectives
-
page
xp_org_blueberry_ui_presentationFactories
-
page
xp_org_blueberry_ui_services
-
page
xp_org_blueberry_ui_keywords
-
page
xp_org_blueberry_ui_preferencePages
-
page
xp_org_blueberry_ui_tweaklets
-
page
xp_org_blueberry_ui_views
-
page
xp_org_blueberry_tests
-
page
DeploymentPage
-
page
DevelopmentApplication
MITK offers a powerful application featuring a plugin system and many predefined plugins. You can configure this application to offer a set of functionality to the user and easily create an installer.
Working with the application, you will have to learn about extension points and the Blueberry framework itself. If you are new to the matter, please also consult The Architecture of MITK and First steps in Development.
The BlueBerry framework extension-point reference is available here:
The MITK application extension-point reference is available here:
-
page
mitkExtPointsIndex
The following extension points can be used to extend the capabilities of MITK Plugins:
Input Devices
-
page
xp_org_mitk_core_ext_inputdevices
-
page
AnnotationPage
-
page
BasicDataTypesPage
This page describes how to use very foundational data-tyes in MITK like mitk::Vector, mitk::Point and mitk::Matrix and how they can interact.
-
page
Concepts
The following items describe some issues about MITK on a more abstract level.
- OverviewPage
- Coding Concepts
- General Information
- Coding Style
- Macros in MITK
- MicroServices_Overview
- Data Concepts
- Rendering Concept
- Interaction
- Logging Concept
- Error Handling and Exception Concept
- Modularization Concept
- Overview
- How to create your own application
If you want to start using MITK, you also want to see the chapter Development.
-
page
DataInteractionPage
-
page
DataInteractionTechnicalPage
This page describes some technicalities of the implementation and the workflow, for a detailed list of tutorials see Topics related to interaction - further information: .
-
page
DataManagementPage
As MITK is used to process large and diverse data the management thereof becomes an important issue. In order to abstract the management of data from the actual format of the data it is encapsulated.
-
page
DICOMTesting
-
page
ExceptionPage
-
page
GeometryOverviewPage
-
page
InteractionPage
- Note
- The following page refers to the deprecated interaction frame work. Please refer to Interaction Concepts for information about the current one.
-
page
LoggingPage
-
page
MitkImagePage
-
page
ModularizationPage
MITK has been designed to be modular and flexible, to facilitate reuse of existing code and functionality if possible. As such there are several levels of modularization which can be chosen when working with MITK, depending on the use case.
-
page
ImplementNewEventsPage
-
page
PersistenceConceptPage
In general, persistence referes to the capability of an application to permanently store data, settings, states, etc. so that they outlive a restart. Normal data objects, such as images, surfaces, etc., which are visible in the data storage of MITK can be saved easily by the save/load functions, see Data Management Concept for more details. This page focus on the persistence of settings, configurations, object states and parameters of the application. Depending on the component, e.g. plugin, module, etc., where you want to store your settings, MITK offers various ways to do so:
- For code inside UI independent modules with low dependencies to other libraries the mitk::PersistenceService inside the MITK persistence module can be used to store parameters by using the mitk::PropertyList class: MITK Persistence Service
- UI dependent code where the Qt library is available can use QSettings: Qt Settings
- If the UI setting of Plugins should be stored permanently, the persistence features of blueberry can be used: Persistence Features of Blueberry
- Extended features, which include persistence, are provided by the configuration service. Configuration Service
-
page
PipelineingConceptPage
-
page
PropertiesPage
-
page
QVTKRendering
The MITK rendering pipeline is derived from the VTK rendering pipeline.
-
page
ReaderWriterPage
This page is work in progress and will introduce you to the IO-System of MITK.
Introductory slides
Several Talks have been given on the IO-System. The following list should provide you with a good starting point.
- Introduction to MimeTypes: http://www.mitk.org/images/e/e8/MimeTypes.pdf (by Caspar J. Goch)
- Introduction to the IO-System: http://www.mitk.org/images/0/0b/Newio.pdf (by Keno März)
- IO-Streams and the new IO System: http://www.mitk.org/images/9/95/Streams.pdf (by Keno März)
Quick start: Reading and writing files using IOUtil
mitk::IOUtil class provides convenience methods for loading data into a data storage or just returning BaseData objects without user interaction. The mitk::IOUtil::Save() and mitk::IOUtil::Load() methods cover the typical use cases and automatically select the best matching mitk::IFileReader and mitk::IFileWriter instance. In most cases, this is the easiest way to read or write a file.
// load files directly into datastorage mitk::IOUtil::Load("/path/to/my/file.nrrd",*ds); // load basedata into local vector std::vector< mitk::Basedata::Pointer > basedatas; basedatas = mitk::IOUtil::Load("/path/to/my/file.nrrd"); // write basedata to file (here: surface as PLY mitk::IOUtil::Save(mySurface, "/Save/surface/here.ply"); // write basedata to file (here: surface as STL mitk::IOUtil::Save(mySurface, "/Save/surface/here.stl");
When reading a file using IOUtil, the IO-Framework first determines the mime-type of the given file. Afterwards, the best reader is selected internally, instantiated, and executed. The resulting BaseData Objects are returned to the developer as the method result.
Quick start: Creating your own reader or writer
If you implement a new BaseData, usually matching readers and writers are required. The following guide will help you to quickly set up these up and get them working in MITK.
Create new classes for reader and writers. Optimally, place them in an extra IO-Module that is configured as autoload. This way, they are available to the application from the start. If you are working with common data, the appropriate module is MitkIOExt. You can either extend mitk::AbstractFileIO, which will allow you to implement a class with reader and writer abilities, or you can extend mitk::AbstractFileReader or mitk::AbstractFileWriter specifically.
Implement the given Methods. A good example on how to write a simple reader and writer is the mitkPointSetReaderService.cpp and mitkPointSetWriterService.cpp class, from which you can take implementation cues. The following is a simplified version of the header file:
namespace mitk { class PointSetReaderService: public AbstractFileReader // 2) Extend the Abstract File Reader { public: PointSetReaderService(); // 3) Provide Constructor and Destructor virtual ~PointSetReaderService(); // 4) Overwrite the Read Method as seen here using AbstractFileReader::Read; virtual std::vector< itk::SmartPointer<BaseData> > Read(); private: // 5) Provide a clone method PointSetReaderService(const PointSetReaderService& other); virtual PointSetReaderService* Clone() const; }; }
Example
Follow these steps to implement a new Reader:
A) Create a new cpp and h file in an appropriate submodule. Usually, a reader or writer should be located in the same module as the BaseData derivate it reads/writes.
B) Extend AbstractFileReader . This is highly recommended because it enables integration of your Reader into the Registery. It will then automatically be used by the application to load this type of files.
C) Provide a constructor . It should contain a minimal amount of information and might look like this:
mitk::PointSetReaderService::PointSetReaderService() : AbstractFileReader(CustomMimeType(IOMimeTypes::POINTSET_MIMETYPE_NAME()), "MITK Point Set Reader") { RegisterService(); }
Note the call to the superclass constructor containing the MIME-type. You can either reuse an existent MIME type here or create your own MIME-type locally . Finally, register the service to make it available to MITK.
D) Provide a Clone Method: Readers are clones when the registry requires a new reader. Provide a clone method to accommodate for this. Use the mitkPointSetReaderService.cpp as a reference if necessary.
E) Instantiate it in the module activator. Open the module activator and make sure that the new Reader/Writer is instantiated and held somewhere in the code. Also, unregister the reader/writer in the unload function if necessary.
Reader/Writer Options
Options are a powerful concept to modify Reader/Writer behaviour and to automate user interaction with minimal development overhead. In principal, options are represented by a simple map and a few getter and setter functions:
typedef std::map<std::string, us::Any> Options; virtual Options GetOptions(); virtual void SetOptions(const Options& options); virtual us::Any GetOption(const std::string& name); virtual void SetOptions(const Options& options);
In its constructor, a reader or writer can set its options as a number map entries consisting of an human-readable option name and a default value. When a user tries to read/write a file via the interface, an options menu is generate from the map.
The user can then modify these options, which are automatically set in the reader/writer. You can use raw-images to see this behaviour in action.
Mime Types
The MimeType class provides meta-data about a specific data format. Every mitk::IFileReader and mitk::IFileWriter instance must be associated with exactly one mime-type via a service property.
Mime-type are used for categorizing data formats and creating filter strings in file open and save dialogs. Hence they effectively control the accessible set of data formats from a graphical user interface. Minimally, mime-types should provide a name and a list of handled extensions in lower case. Additionally, it is highly encouraged to set a category and a comment which will provide user-readable strings for user interaction.
It is important to understand the difference between mitk::MimeType and mitk::CustomMimeType. The former is an immutable stack object and can be pulled from mitk::MimeTypeProvider. it should be used for all interaction with MimeTypes. mitk::CustomMimeType is the heap-object pendant which is wrapped by mitk::MimeType and should exclusively be used for registration purposes, i.e. when you register a new MimeType.
Additional Capabilities
You can extend your reader writer with useful capabilities. All of these are optional
- Priority: Reader use a ranking with Get- and SetRanking in order to signify how well they are suited to read a file. If several readers are able to read a file, the one with the highest Ranking level will be chosen.
- ProgressCallbacks : Readers are executed in a thread automatically. If the reader implements callbacks, the progress bar will be more accurate during loading of files. Note: Progress callbacks are work in progress.
Ranking strategies
Todo.
Convenience classes
Developers usually do not interact with the service registry directly to retrieve and select a matching mitk::IFileReader or mitk::IFileWriter instance.
QmitkIOUtil
The QmitkIOUtil class is a wrapper around mitk::IOUtil, providing file open and save dialogues for selecting a file name from a within a graphical user interface.
FileReaderRegistry and FileWriterRegistry
Access to mitk::IFileReader and mitk::IFileWriter objects and their service references.
Integrating external I/O mechanisms
The MITK I/O system integrates with several external I/O systems.
ITK Reader and Writer
The I/O classes from ITK are automatically added to the service registry of MITK. They can be transparently used via the mitk::IFileReader and mitk::IFileWriter interfaces or the mitk::IOUtil methods.
VTK Reader and Writer
VTK does not provide a mechanism to enumerate all available I/O classes. Hence MITK provides manual integration of a specific set of VTK readers and writers.
Error handling and recovery
Todo.
-
page
RenderingTests
Available sections:
- What is an automatic rendering test?
- How to create a rendering test
-
page
GeneralTests
-
page
DeveloperManualPortal
Development with MITK can happen under several conditions. Depending on whether you are using the Toolkit or the entire application, different sections may apply to you. In case you are unsure about what you need, please refer to The Architecture of MITK text. An extensive Introduction to MITK is available under Starting your MITK Development.
Once you have made yourself familiar with MITK, you should have a look at the Development Concepts, as MITK implements a lot of high-level functionality. Knowing about these concepts will prevent you from reimplementing functionality.
Once you start consuming more specific functionality, the Module Manual will be helpful to understand how a specific plugin works and what functionality it provides.
Finally, generated API-Documentation can be found here.
-
page
InteractionHowTo
-
page
InteractionTestingHowTo
-
page
AboutTestingPage
Testing is a very important part of ensuring code quality. We use CDash for testing whether MITK builds on a variety of platforms and configurations. You can find our dashboard here.
Additionally we support tests of software function as well. More detailed information on testing in MITK can be found below.
-
page
Architecture
MITK is an open source software toolkit for medical image processing, subsequent data analysis and integration of medical hardware. It is designed with the aim of providing a modular and reusable code base to enable rapid development of new features. Following this design philosophy, MITK includes many specialized modules.
This document is aimed at giving an overview of the general structure of MITK. It will give you an introduction to the coding and design concepts behind the toolkit.
-
page
FirstSteps
This section will show you how to extend MITK for your own project.
-
page
MiniAppCommandLineToolHowToPage
This page will give you an overview of creating your own command line tool that can be integrated into a MiniApp. If you don’t know about MiniApps, you can read about their purpose and use at MITK MiniApps page.
-
page
NewDataTypePage
-
page
NewModulePage
-
page
NewPluginPage
The MITK Plugin Generator is a command line tool to simplify the process of creating your own MITK project (optional) and plugins. It can either be downloaded here or used from an existing MITK build.
The Plugin Generator takes the following command line arguments:
./MitkPluginGenerator -h A CTK plugin generator for MITK (version 1.2.0) -h, --help Show this help text -o, --out-dir Output directory (default: /tmp) -l, --license Path to a file containing license information (default: :/MITKLicense.txt) -v, --vendor The vendor of the generated code (default: DKFZ, Medical and Biological Informatics) -q, --quiet Do not print additional information -y, --confirm-all Answer all questions with 'yes' -u, --check-update Check for updates and exit -n, --no-networking Disable all network requests Plugin View options -vc, --view-class The View's' class name -vn, --view-name * The View's human readable name Plugin options -ps, --plugin-symbolic-name * The plugin's symbolic name -pn, --plugin-name The plugin's human readable name Project options --project-copyright Path to a file containing copyright information (default: :/LICENSE.txt) --project-name The project name --project-app-name The application name [* - options are required]
If a project name is provided via the
project-name
argument, the new plugin will be generated as part of a new project.
-
page
NewViewPage
A plugin can bundle several views. If you want to extend an existing plugin, for example created as in How to create a new MITK Plugin, by an additional view, you only need to adapt a few files. This guide will give you a quick overview of what to do. We assume you are adding the view “Useful Functions View” and use default file names and locations (relative to your plugin folder root).
-
page
CMAKE_FAQ
-
page
CodingPage
-
page
DirectoryStructurePage
To avoid clutter and ease the administration of the source code the MITK source code is structured into several subdirectories according to their function. This document aims at helping you finding what you want within this structure.
-
page
DocumentationExample
This page will try to give an example of some of the most commonly used commands and techniques for documenting your code using doxygen. The corresponding source file can be found below.
For the generated documentation page see DocumentationExample .
-
page
DocumentationGuide
-
page
GettingToKnowMITK
This section will show you around MITK and acquaint you with the basic concepts.
-
page
KnownProblemsPage
- “Installing” MITK via cmake (or using “make install”) is not yet supported.
- Sometimes remote X sessions will display black rendering windows. It is not known whether this is a problem within MITK or within the X implementation.
- MITK CHILI plugin has limitations when working with DICOMDIR data sources (bug #1756)
-
page
StyleGuideAndNotesPage
The following document is a description of the accepted coding style for the Medical Imaging Interaction Toolkit (MITK). Developers who wish to contribute code to MITK should read and adhere to the standards described here.
-
page
TroubleshootingPage
NOTE: In case of errors such as:
!1.132! WARNING: QmitkSliceWidget data is not an image! !1.150! WARNING: QmitkSliceWidget data is not an image!
make sure your working directory is set correctly. This is especially an issue when directly running the application from the IDE. It should be set to:
$MITK_ROOT_DIRECTORY/build/MITK-build/bin
-
page
Step00Page
To build the tutorials follow the Build Instructions and make sure that MITK_BUILD_EXAMPLES is checked/set to ON.
The tutorial source files can be found in the Examples\Tutorial\ subdirectory of the source tree. The tutorial executables are in the bin\Release\ or bin\Debug\ subdirectory (Windows) respectively the bin\ subdirectory (Linux/Mac) of the binary tree after compilation (called MitkStepX, corresponding to the tutorial step).
-
page
Step01Page
- Path to files used in this step: http://mitk.org/download/tutorial-data/Pic3D.nrrd
Open your IDE. All steps can be found among the listed projects. The first program shows how to display an image in a 2D view. The picture above is a screenshot of the program. The program has to be executed using the image file Pic3D.nrrd.
If you are using Visual Studio use the StartVS_release.bat in your bin\ subdirectory to start it with all required paths set. To set the image file path in Visual Studio, right click on “MitkStep1”-project and go to ‘Properties -> Configuration Properties -> Debugging’. Now insert the image file path to Pic3D.nrrd in the “Command Arguments” text field. Then right click on the “MitkStep1”-project again and select “Set as StartUp Project”. Start to run the code. Use this also in the following steps.
The code is divided into parts I through V. First of all a DataTree has to be created. Then data has to be read from a file which afterwards has to be put into the tree. Part IV creates a window and passes the tree to it. The last part deals with some Qt-specific initialization.
/*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkRegisterClasses.h" #include "QmitkRenderWindow.h" #include <mitkStandaloneDataStorage.h> #include <QApplication> #include <itksys/SystemTools.hxx> #include <mitkIOUtil.h> //##Documentation //## @brief Load image (nrrd format) and display it in a 2D view int main(int argc, char *argv[]) { QApplication qtapplication(argc, argv); if (argc < 2) { fprintf(stderr, "Usage: %s [filename] \n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str()); return 1; } // Register Qmitk-dependent global instances QmitkRegisterClasses(); //************************************************************************* // Part I: Basic initialization //************************************************************************* // Create a DataStorage // The DataStorage manages all data objects. It is used by the // rendering mechanism to render all data objects // We use the standard implementation mitk::StandaloneDataStorage. mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New(); //************************************************************************* // Part II: Create some data by reading a file //************************************************************************* // Load datanode (eg. many image formats, surface formats, etc.) mitk::IOUtil::Load(argv[1], *ds); //************************************************************************* // Part IV: Create window and pass the datastorage to it //************************************************************************* // Create a RenderWindow QmitkRenderWindow renderWindow; // Tell the RenderWindow which (part of) the datastorage to render renderWindow.GetRenderer()->SetDataStorage(ds); // Initialize the RenderWindow mitk::TimeGeometry::Pointer geo = ds->ComputeBoundingGeometry3D(ds->GetAll()); mitk::RenderingManager::GetInstance()->InitializeViews(geo); // mitk::RenderingManager::GetInstance()->InitializeViews(); // Select a slice mitk::SliceNavigationController::Pointer sliceNaviController = renderWindow.GetSliceNavigationController(); if (sliceNaviController) sliceNaviController->GetSlice()->SetPos(0); //************************************************************************* // Part V: Qt-specific initialization //************************************************************************* renderWindow.show(); renderWindow.resize(256, 256); // for testing #include "QtTesting.h" if (strcmp(argv[argc - 1], "-testing") != 0) return qtapplication.exec(); else return QtTesting(); // cleanup: Remove References to DataStorage. This will delete the object ds = nullptr; }
-
page
Step02Page
- Step2.cpp Contains the code for this example.
- Path to files used in this step: http://mitk.org/download/tutorial-data/Pic3D.nrrd (image) http://mitk.org/download/tutorial-data/lungs.vtk (surface)
This program shows how to load multiple data sets. The picture above shows the result of the program when reading both the image file and the surface file. In order to obtain the result the program has to be executed using the image file Pic3D.nrrd and the surface file lungs.vtk.
The code for this example equals the code of Step 1 except for part II and part III which are changed as follows:
// Part II: Create some data by reading files
-
page
Step03Page
- Step3.cpp Contains the code that both creates a 3D view and turns volume rendering on.
- Path to files used in this step: http://mitk.org/download/tutorial-data/Pic3D.nrrd (image) http://mitk.org/download/tutorial-data/lungs.vtk (surface)
- Step 3a works for default condition for surface mesh. To run this tutorial with Step 3a, pass the argument as “lungs.vtk” (without quotes).
- Step 3b works for surface mesh with volume rendering. To run this tutorial with Step 3b, pass the arguments as “Pic3D.nrrd lungs.vtk” (without quotes).
-
page
Step04Page
- Step4.cpp Contains the code of step 4a + b.
- Path to files used in this step: http://mitk.org/download/tutorial-data/Pic3D.nrrd (image) http://mitk.org/download/tutorial-data/lungs.vtk (surface)
This now creates three views on the data. The QmitkRenderWindow is used for displaying a 3D view as in Step 3, but without volume-rendering. Furthermore two 2D views for slicing through the data are created. The class QmitkSliceWidget is used, which is based on the class QmitkRenderWindow, but additionally provides sliders to slice through the data. We create two instances of QmitkSliceWidget, one for axial and one for sagittal slicing. Step 4b enhances the program in that the two slices are also shown at their correct position in 3D as well as intersection-line, each in the other 2D view.
As in the previous steps, to obtain the result the program has to be executed using the image file Pic3D.nrrd and the surface file lungs.vtk.
-
page
Step05Page
- Step5.cpp Contains the code for this step.
- Path to files used in this step: http://mitk.org/download/tutorial-data/Pic3D.nrrd (image) http://mitk.org/download/tutorial-data/lungs.vtk (surface)
A node containing a PointSet as data is added to the data tree and a PointSetDataInteractor is associated with the node, which handles the interaction. The interaction pattern is defined in a state-machine, stored in an external XML file. Thus, we need to load a state-machine.
A state machine describes interaction pattern with different states (states beeing something like “a point is selected”) and transitions to these states (e.g. “select a point”). These transitions are associated with actions. In this way it is possible to model complex interaction schemes. By what these transitions and actions are triggered is described in a configuration file. It maps user events to identifiers that are used in the state machine patterns. In this way the user interaction can be changed by simply loading a different configuration file for a state machine, and the user may add points now with a right click instead of left click + SHIFT, as in our case.
Therefore after loading the state machine pattern the PointSetDataInteractor is also given a event configuration file.
More information about interaction in MITK can be found here.
In order to add a point the shift key has to be pressed while left clicking in a render window. You can also move points or remove them (left click while pressing ALT).
A PointSet and a node for it have to be created to be able to interactively adding points:
mitk::PointSet::Pointer pointSet = mitk::PointSet::New(); mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New(); // Store the point set in the DataNode pointSetNode->SetData(pointSet); // Add the node to the tree ds->Add(pointSetNode); // Create PointSetDataInteractor mitk::PointSetDataInteractor::Pointer interactor = mitk::PointSetDataInteractor::New(); // Set the StateMachine pattern that describes the flow of the interactions interactor->LoadStateMachine("PointSet.xml"); // Set the configuration file, which describes the user interactions that trigger actions // in this file SHIFT + LeftClick triggers add Point, but by modifying this file, // it could as well be changes to any other user interaction. interactor->SetEventConfig("PointSetConfig.xml"); // Assign the pointSetNode to the interactor, // alternatively one could also add the DataInteractor to the pointSetNode using the SetDataInteractor() method. interactor->SetDataNode(pointSetNode);
-
page
Step06Page
The source is now split among several files:
- Step6.cpp
- Step6.h
- Step6RegionGrowing.txx
- Step6RegionGrowing1.cpp
- Step6RegionGrowing2.cpp
- Step6main.cpp
- Path to files used in this step: http://mitk.org/download/tutorial-data/Pic3D.nrrd (image)
Add points in the image by pressing SHIFT+left mouse key, then adjust the thresholds and press ‘Start region growing’.
The class Step6 inherits from QWidget and provides methods for setting up the widgets. Step6RegionGrowing.cpp contains a method for performing the region-growing. Step6main.cpp contains main. Like in ITK and VTK class member names start with m_ followed by the proper member name starting with a capital letter (e.g. m_Tree). Function names start with capital letters. To learn more about style conventions in MITK read The MITK Style Guide.
The widgets are initialized as in the previous steps but with an additional QVBox for a button to start the segmentation:
// Create controlsParent widget with horizontal layout QWidget *controlsParent = new QWidget(this); this->layout()->addWidget(controlsParent); QHBoxLayout *hlayout = new QHBoxLayout(controlsParent); hlayout->setSpacing(2); QLabel *labelThresholdMin = new QLabel("Lower Threshold:", controlsParent); hlayout->addWidget(labelThresholdMin); m_LineEditThresholdMin = new QLineEdit("-1000", controlsParent); hlayout->addWidget(m_LineEditThresholdMin); QLabel *labelThresholdMax = new QLabel("Upper Threshold:", controlsParent); hlayout->addWidget(labelThresholdMax); m_LineEditThresholdMax = new QLineEdit("-400", controlsParent); hlayout->addWidget(m_LineEditThresholdMax);
This creates a button to start the segmentation and its clicked() signal is connected to the method StartRegionGrowing():
-
page
Step07Page
- Step7.cpp
- Step7.h
- Step7main.cpp
- Path to files used in this step: http://mitk.org/download/tutorial-data/Pic3D.nrrd (image)
Step7 inherits from Step6. It enhances the method StartRegionGrowing() by processing the result image.
-
page
Step08Page
- Step8.cpp
- Step8.h
- Step8main.cpp
- Path to files used in this step: http://mitk.org/download/tutorial-data/Pic3D.nrrd (image)
Step8 inherits from Step6. The method SetupWidgets() is changed: A QmitkStdMultiWidget is used instead of one QmitkRenderWindow and two instances of QmitkSliceWidget.
// Part Ia: create and initialize QmitkStdMultiWidget
-
page
Step09Page
MITK uses a very modular concept to maximize reusability and portability. A MITK application based on the BlueBerry application framework (for example the MITK Workbench) consists of several bundles (or plug-ins). A bundle can contain resources and program logic. It can also contribute so-called Views to the main application, which provide a specific user interface for controlling the bundles functions.
The creation of a MITK plug-in is considerably facilitated by using the MITK PluginGenerator as described in How to create a new MITK Plugin if you want to add a new view to an existing plugin see Adding a new view to a MITK Plugin.
The mentioned tool was used to create a plug-in called org.mitk.example.gui.regiongrowing. Let’s first take a look at which files the PluginGenerator has created:
documentation\doxygen\ modules.dox......................... Doxygen file for documenting your plug-in resources\ icon.png............................ The icon of your plug-in. GIMP or other programs (including your text editor) can be used to change this src\internal\ QmitkRegionGrowingView.cpp.......... The most important file, implementing behaviour QmitkRegionGrowingView.h............ Header file of the functionality QmitkRegionGrowingViewControls.ui... XML file of the Qt Designer, describes buttons, combo boxes, etc. of your controls CMakeLists.txt \...................... Build system related files for CMake files.cmake / manifest_headers.cmake................ Information about your plug-in plugin.xml ........................... BlueBerry integration
If you are not familiar with Qt development, please look into this Qt company page describing .ui files (no, forget about the please, DO it!)
The C++ files implement a subclass of QmitkAbstractView. In this special case of QmitkRegionGrowing, we added the option to set some seed points and run a region grower. If you are interested in the concrete changes necessary to turn a freshly generated QmitkRegionGrowing into an integrated one:
The plug-in will be build as part of MITK Workbench. Do use it start MITK Workbench an select the region growing view in the view menu.
To add a mitk::PointSet for the seed points: QmitkRegionGrowingView.h
Add includes and forward declarations:
Add the point set and a pointer to a QmitkPointListWidget as a private member:#include "mitkIRenderWindowPartListener.h" #include "mitkPointSet.h" #include <itkImage.h> class QmitkPointListWidget;
QmitkRegionGrowingView.cppmitk::PointSet::Pointer m_PointSet; QmitkPointListWidget *m_PointListWidget;
CreateQtPartControl():
To use the ITK region grower:// create a QmitkPointListWidget and add it to the widget created from .ui file m_PointListWidget = new QmitkPointListWidget(); m_Controls.verticalLayout->addWidget(m_PointListWidget, 1); // retrieve a possibly existing IRenderWindowPart if (mitk::IRenderWindowPart *renderWindowPart = GetRenderWindowPart()) { // let the point set widget know about the render window part (crosshair updates) RenderWindowPartActivated(renderWindowPart); } // create a new DataNode containing a PointSet with some interaction m_PointSet = mitk::PointSet::New(); mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New(); pointSetNode->SetData(m_PointSet); pointSetNode->SetName("seed points for region growing"); pointSetNode->SetProperty("helper object", mitk::BoolProperty::New(true)); pointSetNode->SetProperty("layer", mitk::IntProperty::New(1024)); // add the pointset to the data storage (for rendering and access by other modules) GetDataStorage()->Add(pointSetNode); // tell the GUI widget about the point set m_PointListWidget->SetPointSetNode(pointSetNode);
QmitkRegionGrowingView.h
Add the private method:
QmitkRegionGrowingView.cpptemplate <typename TPixel, unsigned int VImageDimension> void ItkImageProcessing(itk::Image<TPixel, VImageDimension> *itkImage, mitk::BaseGeometry *imageGeometry);
Add includes:
DoImageProcessing():// Qmitk #include "QmitkPointListWidget.h" #include "QmitkRenderWindow.h" // MITK #include "mitkColorProperty.h" #include "mitkITKImageImport.h" #include "mitkImageAccessByItk.h" #include "mitkImageCast.h" #include "mitkProperties.h" // ITK #include <itkConnectedThresholdImageFilter.h>
And add the new method:// So we have an image. Let's see if the user has set some seed points already if (m_PointSet->GetSize() == 0) { // no points there. Not good for region growing QMessageBox::information(nullptr, "Region growing functionality", "Please set some seed points inside the image first.\n" "(hold Shift key and click left mouse button inside the image.)"); return; } // actually perform region growing. Here we have both an image and some seed points AccessByItk_1( image, ItkImageProcessing, image->GetGeometry()) // some magic to call the correctly templated function
Have fun using MITK!template <typename TPixel, unsigned int VImageDimension> void QmitkRegionGrowingView::ItkImageProcessing(itk::Image<TPixel, VImageDimension> *itkImage, mitk::BaseGeometry *imageGeometry) { typedef itk::Image<TPixel, VImageDimension> InputImageType; typedef typename InputImageType::IndexType IndexType; // instantiate an ITK region growing filter, set its parameters typedef itk::ConnectedThresholdImageFilter<InputImageType, InputImageType> RegionGrowingFilterType; typename RegionGrowingFilterType::Pointer regionGrower = RegionGrowingFilterType::New(); regionGrower->SetInput(itkImage); // don't forget this // determine a thresholding interval IndexType seedIndex; TPixel min(std::numeric_limits<TPixel>::max()); TPixel max(std::numeric_limits<TPixel>::min()); mitk::PointSet::PointsContainer *points = m_PointSet->GetPointSet()->GetPoints(); for (mitk::PointSet::PointsConstIterator pointsIterator = points->Begin(); pointsIterator != points->End(); ++pointsIterator) { // first test if this point is inside the image at all if (!imageGeometry->IsInside(pointsIterator.Value())) { continue; } // convert world coordinates to image indices imageGeometry->WorldToIndex(pointsIterator.Value(), seedIndex); // get the pixel value at this point TPixel currentPixelValue = itkImage->GetPixel(seedIndex); // adjust minimum and maximum values if (currentPixelValue > max) max = currentPixelValue; if (currentPixelValue < min) min = currentPixelValue; regionGrower->AddSeed(seedIndex); } MITK_INFO << "Values between " << min << " and " << max; min -= 30; max += 30; // set thresholds and execute filter regionGrower->SetLower(min); regionGrower->SetUpper(max); regionGrower->Update(); mitk::Image::Pointer resultImage; mitk::CastToMitkImage(regionGrower->GetOutput(), resultImage); mitk::DataNode::Pointer newNode = mitk::DataNode::New(); newNode->SetData(resultImage); // set some properties newNode->SetProperty("binary", mitk::BoolProperty::New(true)); newNode->SetProperty("name", mitk::StringProperty::New("dumb segmentation")); newNode->SetProperty("color", mitk::ColorProperty::New(1.0, 0.0, 0.0)); newNode->SetProperty("volumerendering", mitk::BoolProperty::New(true)); newNode->SetProperty("layer", mitk::IntProperty::New(1)); newNode->SetProperty("opacity", mitk::FloatProperty::New(0.5)); // add result to data tree this->GetDataStorage()->Add(newNode); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); }
If you meet any difficulties during your first steps, don’t hesitate to ask on the MITK mailing list mitk-users@lists.sourceforge.net! People there are kind and will try to help you.
-
page
Step10Page
-
page
TutorialPage
If you have set up and compiled MITK already and want to know more about developing with MITK you might want to read the Tutorial chapters. If you want help setting up MITK and creating your own project using MITK you should take a look at Creating a new MITK project.
-
page
BuildInstructionsPage
-
page
HowToNewProject
This page is intended to give a comprehensive guide to setting up your own MITK based project. It will use the application framework provided by MITK and is probably the preferred way for most users.
The first part of this document is a tutorial aimed at newcomers to MITK and possibly CMake and tries to give as much help as possible on setting up your own project. If you are looking for more technical information about customizing MITK, the structure of the superbuild or packaging you might want to read the Information for advanced users.
If you have set up your MITK project already and want to start developing you could take a look at The MITK Tutorial.
-
page
SettingUpMITK
This section will get you started with your MITK Development environment.
-
page
SupportedPlatformsPage
MITK is a cross-platform framework that is available for the following platforms:
- Windows
- Linux/X11
- Mac OS X
Supported Platforms Details
The MITK team provides support for the most frequently used platforms and continuously runs testing procedures to ensure compatibility. Due to the large amount of possible combinations of operating systems and compiler versions, we divide platform support into two test categories: Tier 1 and Tier 2.
Although MITK may be built on a broader range of platform-compiler combinations, only a subset of these are actively supported by the MITK development team.
Tier 1 Platforms
All Tier 1 platforms are continuously tested by our unit test suite and other internal testing procedures. Errors or bugs discovered in these platforms are prioritized and corrected as soon as possible.
Tier 2 Platforms
Tier 2 platforms may or may not be tested on a regular basis. Some Tier 2 platforms are used by individual members of the MITK development team on a daily basis and some only receive occasional testing. While we strive to support these platforms, MITK users should note that errors may be present in released versions as well as in the current master branch.
All platforms not listed above are not officially supported by the MITK team. However, we will happily accept contributions to improve support for other platforms.
-
page
thirdpartylibs
The following third-party libraries can be used with MITK by default and can, in part, be automatically downloaded during superbuild.
http://www.creatis.insa-lyon.fr/site/en/acvd
- ACVD
http://www.cs.umd.edu/~mount/ANN/
- ANN
- Boost
http://sourceforge.net/projects/cppunit/
- CppUnit
- CTK
http://dicom.offis.de/dcmtk.php.en
- DCMTK
http://eigen.tuxfamily.org/index.php?title=Main_Page
- Eigen
- GDCM
https://www.opengl.org/resources/libraries/glut/
- GLUT
https://support.hdfgroup.org/HDF5/
- HDF5
- ITK
https://www.dkfz.de/en/sidt/projects/matchpoint/info.html
- MatchPoint
- NumPy
https://www.khronos.org/opencl/
- OpenCL
http://opencv.willowgarage.com/wiki/Welcome
- OpenCV
- OpenIGTLink
- PCRE
- POCO
- Python
- Qt
- Qwt
- Rasqal
- Raptor2
- Redland
- SimpleITK
- SWIG
http://sourceforge.net/projects/tinyxml/
- tinyxml
http://ukoethe.github.io/vigra/
- VIGRA
- VTK
https://github.com/commontk/zlib
- zlib
For copyright information on any of the above toolkits see the corresponding home page or the corresponding source folder.
-
page
StartingDevelopment
This introduction will acquaint you with the most important workflows to get you started with your MITK development. First, The Architecture of MITK will explain the differences between the application and the toolkit. Setting Up Mitk will get you started with a working environment for MITK development. Getting to know MITK will walk you trough the folder structure, the module system, and plugin system. This chapter also contains an extensive tutorial on how to work with MITK. The First steps in Development section will then show you how to extend MITK for your own project.
-
page
GeometryMigration
-
page
InteractionMigration
-
page
MITKModuleManualsListPage
-
page
OverlayMigration
-
page
deprecatedSince2012_09
-
page
deprecatedSince2013_03
-
page
deprecatedSince2013_06
-
page
deprecatedSince2013_09
-
page
deprecatedSince2014_03
-
page
deprecatedSince2014_10
-
page
deprecatedSince2015_05
-
page
deprecatedSince2016_03
-
page
deprecatedSince2016_11
-
page
deprecated
-
page
index
-
The Medical Imaging Interaction Toolkit (MITK) is a free open-source software system for development of interactive medical image processing software. MITK combines the Insight Toolkit (ITK) and the Visualization Toolkit (VTK) with an application framework.
The links below provide high-level and reference documentation targeting different usage scenarios:
- Get a high-level overview about MITK with pointers to further documentation
- End-users looking for help with MITK applications should read the MITK User Manual
- Developers contributing to or using MITK, please see the MITK Developer Manual as well as the MITK API Reference
See the MITK homepage for details.
Supported Platforms
MITK is a cross-platform C++ toolkit and officially supports:
- Windows
- macOS
- Linux
For details, please read the Supported Platforms page.
License
Copyright (c) German Cancer Research Center.
MITK is available as free open-source software under a BSD-style license.
Download
The MITK source code and binaries for the MitkWorkbench application are released regularly according to the MITK release cycle. See the Download page for a list of releases.
The official MITK source code is available in the MITK Git repository. The Git clone command is
git clone https://phabricator.mitk.org/source/mitk.git MITK
Active development takes place in the MITK master branch and its usage is advised for advanced users only.
How to Contribute
Contributions of all kind are happily accepted. However, to make the contribution process as smooth as possible, please read the How to contribute to MITK page if you plan to contribute to MITK.
Build Instructions
MITK uses CMake to configure a build tree. The following is a crash course about cloning, configuring, and building MITK on a Linux/Unix system:
git clone https://phabricator.mitk.org/source/mitk.git MITK mkdir MITK-build cd MITK-build cmake ../MITK make -j4
Read the comprehensive Build Instructions page for details.
Useful Links