diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/Architecture.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/Architecture.dox
index d499f3a0dc..912a2a1cef 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/Architecture.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/Architecture.dox
@@ -1,47 +1,47 @@
/**
\page Architecture The Architecture of MITK
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 heavily reusable code base to enable rapid development of new features. Following
-this design philosophy MITK includes many different specialized modules e.g. the Segmentation Module.
+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. Furthermore it will give an introduction into the coding
-and design concepts behind this toolkit.
+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.
\section OverviewPage_DesignOverview Design Overview
-MITK is designed to be used as a pure software library or as a complete application framework. Thus, a user
-of MITK can decide if he simply wants to add a new plug-in to the existing application framework or if he needs to implement his
-own application and wants to use MITK as a software library. Depending on the type of use MITK uses different software libraries, which is
+MITK is designed to be used either as a pure software library or as a complete application framework. Thus, a user
+of MITK can decide if he or she simply wants to add a new plug-in to the existing application framework or to implement an
+own application by using MITK as a software library. Depending on the type of use MITK uses different software libraries, which is
shown in the next figure for overview.
\imageMacro{MitkOverview.png,"Overview of MITK",16}
-Like shown above, MITK uses the following libraries.
+As shown above, MITK uses the following libraries.
-These are the main libraries MITK is based on. For further functionality you can optionally include others, a list can be found \ref thirdpartylibs "here" .
+These are the main libraries MITK is based on. For more functionality you can optionally include other libraries as well. A list of used libraries can be found \ref thirdpartylibs "here" .
Based on these libraries, MITK includes the following features:
- High level interactions with data.
- Specialized medical imaging algorithms (e.g. segmentation)
- Support of 3D + t data.
- Complete application framework, expandable by plug-ins
- Standard tools for medical imaging as default plug-ins (e.g. measurement, segmentation)
-
- Many specialized module for different topics on medical imaging (e.g. diffusion imaging, image guided therapy, live image/ultrasound data processing)
+
- Many specialized modules for different topics on medical imaging (e.g. diffusion imaging, image guided therapy, live image/ultrasound data processing)
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildInstructions.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildInstructions.dox
index 167bd4f7e0..ba5c06a458 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildInstructions.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/BuildInstructions.dox
@@ -1,272 +1,211 @@
/**
\page BuildInstructionsPage Build Instructions
\tableofcontents
\section BuildInstructions_Introduction Introduction
-The MITK build system (which is based on CMake) supports a "superbuild" process,
+The CMake-based build system of MITK supports a "superbuild" process,
meaning that it will download, configure, and build all required third-party
libraries (except Qt) automatically. These instructions will show you how to use
the MITK superbuild.
\note This page explains explicitly how to build MITK itself. If you want to
create your own project based on MITK, the process described below is completely
automated. Please see \ref HowToNewProject.
-For more advanced users, the last sections explain how to inject custom build
+For more advanced users, the last sections explains how to inject custom build
libraries into the superbuild process.
\section BuildInstructions_Prerequisites Prerequisites
You need:
-# Git from http://git-scm.com (there are also numerous third-party graphical
clients available). We recomment using Git, but see below for a way how to
get the current source code without using it.
-# CMake (version \minimumCMakeVersion or higher)
- -# Qt 4.x if you plan to develop Qt-based
- applications (version \minimumQt4Version or above is required, Qt 5.x is only
- supported experimentally for a very limited number of modules)
- -# If you are using Mac OS X you need an Xcode installation as this
+ -# Qt 5.x if you plan to develop Qt-based
+ applications (Qt 4 is still supported but may be dropped in near future)
+ -# If you are using Mac OS X you need an XCode installation as it
provides the neccessary compilers and SDKs
\section BuildInstructions_Qt A note about Qt
-Nokia provides several binary packages for Qt. You must make sure that the package
-you download matches your toolchain. On Linux, getting Qt by installing the
-packages provided by your Linux package manager is the preferred way.
-
-On Windows, the Nokia provided binaries are compiled for 32bit architectures.
-You cannot build your own project for a 64bit machine and
-use the 32bit Qt libraries. You have two options for a 64bit Qt-based application:
-
- -# Download an inofficial 64bit installer, for example
- here. Note
- that we cannot offer support for problems with MITK due to the usage of
- this kind of installers.
- -# Compile Qt yourself. This is shortly described below.
-
-To compile Qt on Windows using Visual Studio, follow the steps below:
-
- -# Download the Qt sources and unpack them, e.g. to
- C:/qt-everywhere-opensource-src-4.7.4
- -# Open a Visual Studio command prompt. Make sure to use the appropriate
- command prompt for either a 32 bit or 64 bit build.
- Note that Visual Studio Express does not come with 64bit compilers out
- of the box (the Professional version does).
- -# Configure Qt by executing the configure.exe command in your Qt source
- directory. The following configure options will build a Qt compatible
- with MITK:
- \verbatim
-configure.exe -prefix C:\Qt\4.7.4_vc9_x64 -debug-and-release -qt-sql-sqlite -no-multimedia -no-audio-backend -no-phonon -no-phonon-backend -no-declarative -mp -nomake examples -nomake demos -nomake docs
-\endverbatim
- -# Build and install the Qt libraries
- \verbatim
-nmake
-nmake install
-\endverbatim
-
-After "nmake install" completed successfully, you may delete your Qt source
-directory.
+As we do not provide Qt in the MITK superbuild you need to install Qt manually.
+Installing Qt dramatically improved since Qt 5, as The Qt Company provides
+sophisticated online installers for all
+supported platforms.
+
+\note Make sure that you select a Qt version which provides the right OpenGL-enabled
+packages for your architecture and compiler.
\section BuildInstructions_Get_Source Get a source tree
-Since MITK is under active development we recommend to use git to check out
+Since MITK is under active development we recommend to use Git to check out
the latest stable release from the homepage. If you decide to use the most
current nightly release, make sure to get a stable tree: Check the
MITK dashboard
before checking out. If the build tree is not clean, you can specify an
older revision for the checkout or get a stable tar ball from
www.mitk.org.
-If you don't want to use Git, you may also download the current source code
-(or any other older version) as a tar.gz package by clicking on the
-snapshot
-link. You can then skip the clone step below.
+If you don't want to use Git, you may also download a snapshot of the current source code
+(or any other older version) as a tar.gz package.
-To clone MITK's current git repository do:
+To clone MITK's current Git repository do:
\code
git clone http://git.mitk.org/MITK.git
\endcode
\section BuildInstructions_Build_With_CMake Build MITK with CMake
Create a new directory for the superbuild binary tree, change to it and call CMake:
-In the shell (assuming you current directory is the same as the one where you
+In the shell (assuming your current directory is the same as the one where you
issued the git clone command):
\code
mkdir MITK-superbuild
cd MITK-superbuild
ccmake ../MITK
\endcode
-If you use Windows, then you just start the CMake GUI and enter the
-location of the source and of the binary tree, choose a suitable generator
+If you use Windows or prefer to use the CMake GUI, start the CMake GUI and enter the
+location of the source tree and binary tree, choose a suitable generator
and configure the project.
-If you use Mac OS X you will have to tweak the CMake configuration:
- - First of all you have to check the selected compilers, i.e.:
- - CMAKE_CXX_COMPILER
- - CMAKE_C_COMPILER
- - both should be either apple's clang or apple's gcc compiler
- - Next you have to assure hat CMAKE_OSX_SYSROOT points to
- the correct SDK location:
- - This is either /Developer/SDKs/Developer/SDKs/MacOSX10.7.sdk or if you
- have installed Xcode 4.3+ it is located in
- /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.7.sdk/
-
CMake will present you a couple of options, these are the most important ones:
+ - CMAKE_PREFIX_PATH The path to your Qt installation, e.g., C:\Qt\5.4\msvc2013_64_opengl or /home/user/Qt/5.4/gcc_64
- MITK_USE_ACVD Build MITK code which depends on ACVD (this
will download and build ACVD)
- MITK_USE_BLUEBERRY Build the BlueBerry application framework
- MITK_USE_Boost Build MITK code which depends on Boost (this
will download Boost 1.56)
- MITK_USE_Boost_LIBRARIES If you need binary Boost libraries,
specify them here.
- MITK_USE_OpenCV Build MITK code which depends on OpenCV (this
will download and build OpenCV 2.4)
- MITK_USE_Python Enables Python wrapping in MITK. This will also
configure ITK, VTK, and OpenCV (if enabled) to build Python wrappers.
- MITK_USE_QT Build MITK code which depends on Qt
- MITK_USE_SOFA Build MITK code which depends on SOFA (this will
download and build SOFA)
- - QT_QMAKE_EXECUTABLE The path to the qmake executable of your Qt
- installation
-
-You may also choose to build with either Qt4 or Qt5. When building with Qt5,
-the BlueBerry application framework and hence the MITK Workbench application
-will not be available. Further, many Qt-depdendent MITK modules have not been
-migrated to Qt5 yet. In case of Qt4 you may point CMake to a certain Qt4
-installation directory by setting the QT_QMAKE_EXECUTABLE variable.
-When building against Qt5, the following variables are important:
-
- - DESIRED_QT_VERSION Set this to "5" for building with Qt5.
- - CMAKE_PREFIX_PATH If Qt5 is not found automatically, set
- this variable to the base directory of your Qt5 installation.
If you are satisfied with the configuration of your MITK superbuild, generate
the project files with CMake by pressing "Generate".
Linux and Mac OS X users usually just enter "make" (optionally
supplying the number threads to be used for a parallel build):
\code
make -j4
\endcode
-\note On Mac OS X: If you follow these steps CMake will produce Makefiles
-and therefore you cannot use Xcode but you have to use e.g. the QtCreator for
-programming. At the moment developing MITK with Xcode is not supported and using
-Xcode the superbuild doesn't complete without errors.
-
Windows users using Visual Studio can open the generated
MITK-superbuild.sln solution file in the MITK-superbuild
directory and start the build by building the BUILD_ALL project.
\section BuildInstructions_Customize Customize your MITK superbuild
-The MITK superbuild configured MITK with all needed external libraries. The
+The MITK superbuild configures MITK as well as all external libraries. The
build directories of these libraries, and of MITK itself are located inside
the MITK-superbuild directory. For example, the directory layout may
look like:
\code
MITK-superbuild
- |- ITK-build
- |- VTK-build
+ |- ep "external projects"
+ |-bin
+ |-lib
+ |-include
+ |-src
|- MITK-build
\endcode
-To change the configuration of the MITK build, choose the MITK-build directory
-as the binary directory in the CMake GUI. After generating the project files,
-build the MITK project by either issuing "make" in the MITK-build directory
-(Linux), or by opening MITK-build/MITK.sln and building the project with
-Visual Studio.
+To change the configuration of the MITK build itself, choose the MITK-build directory
+as the binary directory in the CMake GUI (not the MITK-superbuild directory).
+After generating the project files, build the MITK project by either issuing "make"
+in the MITK-build directory (Linux, Mac OS X), or by opening MITK-build/MITK.sln (Windows).
You may also change the configuration of any project configured via the
superbuild process. Make sure to also build the changed project and also the
projects which depend on it.
\section BuildInstructions_Running Running Applications
On Linux, just execute the application you want to run. MITK executables are
located in MITK-superbuild/MITK-build/bin
On Windows, the PATH environment variable must contain the directories
-containging third-party libraries. The MITK build system generated Windows Batch
-files in the MITK-build directory which set up a correct environment
-and opens the appropriate Visual Studio solution file. Use (and maybe
-modify/enhance) these Batch files to be able to start and debug MITK applications
-from inside Visual Studio.
+containing the third-party libraries. The MITK build system generated Windows batch
+files in the MITK-build directory set up a correct environment
+and opens the appropriate Visual Studio solution file. Use these batch files to be able
+to start and debug MITK applications from inside Visual Studio.
\section BuildInstructions_Documentation Documentation
If you have the Doxygen documentation tool
installed, you get a new project (Visual Studio) or "make" target named "doc".
You can build this to generate the HTML documentation of MITK in the
Documentation/Doxygen directory of your MITK-build binary tree or in the
MITK_DOXYGEN_OUTPUT_DIR CMake variable (if specified).
\section BuildInstructions_Extending Extend MITK on your own (using the application framework BlueBerry)
Please see \ref NewPluginPage
\section BuildInstructions_As_Toolkit Use MITK in your own project (as a toolkit)
To use MITK in your external project, add the CMake command
find_package(MITK REQUIRED)
to your CMakeLists.txt and make use of
the CMake macros mitk_create_module()
and
mitk_create_executable()
provided by MITK.
Here is an example CMakeLists.txt (from the Examples/QtAppExample/ directory)
-which allows you to create a Qt based application using MITK to display an image.
+which allows you to create a Qt-based application using MITK to display an image.
\include QtAppExample/CMakeLists.txt
-\section BuildInstructions_Advanced_Customization Superbuild Customization
+\section BuildInstructions_Advanced_Customization Superbuild customization
You can inject pre-build third-party libraries into the MITK superbuild by
setting certain CMake variables before the first configure step. MITK will
then use these third-party libraries instead of downloading and building them
-itself. Note you must take care to configure those libraries with all options
+by itself. Note that you must take care of configuring those libraries with all options
MITK requires.
The variables listed below are provided for injecting third-party libraries.
Their occurrence in the CMake GUI or in ccmake may depend on specific
MITK_USE_* options set to ON. You may also use the variable names below without
the EXTERNAL_ prefix, for example when providing their values on a
command line call to CMake.
- EXTERNAL_BOOST_ROOT Set this variable to your custom Boost
installation
- EXTERNAL_CTK_DIR Set this variable to your CTK binary tree
(the directory containing the CTKConfig.cmake file)
- EXTERNAL_CableSwig_DIR Set this variable to your CableSwig
binary tree for Python wrapping (the directory containing the
CableSwigConfig.cmake file)
- EXTERNAL_DCMTK_DIR Set this variable to your DCMTK binary
tree (the directory containing the DCMTKConfig.cmake file)
- EXTERNAL_GDCM_DIR Set this variable to your GDCM binary
tree (the directory containing the GDCMConfig.cmake file)
- EXTERNAL_ITK_DIR Set this variable to your ITK binary tree
(the directory containing the ITKConfig.cmake file)
- EXTERNAL_OpenCV_DIR Set this variable to your OpenCV binary
tree (the directory containing the OpenCVConfig.cmake file)
- - EXTERNAL_SOFA_DIR Set this variable to your SOFA binary tree
- (the directory containing the SOFAConfig.cmake file)
- EXTERNAL_VTK_DIR Set this variable to your VTK binary tree
(the directory containing the VTKConfig.cmake file)
To set CMake options before the first configure step is invoked, supply them
on the command line, i.e.
\code
ccmake -DITK_DIR:PATH=/opt/ITK-release ../MITK
\endcode
See the following link for more information about how to configure third-party
libraries:
-\subpage BuildToolkits "How to build ITK, VTK and QT"
+\subpage BuildToolkits "How to build ITK, VTK and Qt"
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
index 108183b08b..af6b67cd2d 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/HowToNewProject.dox
@@ -1,258 +1,258 @@
/**
\page HowToNewProject Creating a new MITK project
\tableofcontents
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
\ref HowToNewProjectAdvancedInformation.
If you have set up your MITK project already and want to start developing you could
take a look at \ref TutorialPage.
\section HowToNewProjectGettingStarted Getting Started
To bootstrap your project MITK offers two convenient options:
- Use the MITK Plugin Generator, a command line tool used to generate a customized
MITK project and/or MITK plug-ins (available for download
here).
- Use the MITK project template
as an example project.
Both options will provide you with a project which contains a "superbuild" mechanism
to automatically download, configure, and build MITK as a dependency of your own project.
The MITK Plugin Generator generates code using the supplied command line arguments,
whereas the MITK project template needs immediate modifications to customize it to
your naming schemes. However, the project template will potentially contain more
code demonstrating features of MITK.
\note Using the MITK Plugin Generator is recommended for beginners.
\section HowToNewProjectPrerequisites Prerequisites
What ever option you choose, a MITK-based project needs essentially the same
prerequisites as MITK itself. Please see \ref BuildInstructions_Prerequisites for
details.
\note If you use one of the two options above you will \b not \b need to build MITK
yourself. This will be done automatically.
\section HowToNewProjectCreatingSourceDir Preparing your source directory
In order to start developing with MITK, you first have to set up the source directory
for your project.
\subsection HowToNewProjectSourceUsingGenerator Using the MITK Plugin Generator
The usage of the Plugin Generator for creating a new project is described in
\ref NewPluginWithProject, please have a look there.
\subsection HowToNewProjectSourceUsingTemplate Using the MITK Project Template
Download the project as a tarball or zipball and extract it to your desired source
directory.
\note This is a \b template \b. You must modify it such that it fits the needs of
your particular project. Especially you should do a global search and replace for
the string "awesome" to rename the template application and plug-in. You may want
to rename some files too.
\section HowToNewProjectGeneratingCMake Generating your binary with CMake
After you have set up your source directory you can proceed to generate your binary
directory using %CMake. Depending on your operating system and preferences you might
want to use "cmake-gui" or "ccmake" (shell). This document assumes you are using
cmake-gui.
- Start "cmake-gui" and enter your source (e.g. "D:\AwesomeProject") and binary
directory (e.g. "D:\AwesomeProject-superbuild").
- Upon first pressing "Configure" you will be prompted to select your generator.
This determines what project files will be generated by %CMake. Set this to the
development tool you are intending to use (e.g. "Visual Studio 2010 64Bit" or
"linux makefiles".
- Press "Configure" until no new variables appear and then "Generate". Now all
project files have been generated into your binary directory.
- Double-check that the right Qt version is used.
Now you are ready to compile your code. Depending on your choice of tool this will
be done differently, we cover two possibilities here.
\subsection HowToNewProjectCompilingLinuxMakefiles Compiling using linux makefiles
- In the shell, switch to your binary directory.
- type "make" and hit enter
\subsection HowToNewProjectCompilingVisualStudio Compiling using visual studio
We assume your application is called "AwesomeApp" and your project "AwesomeProject"
and your binary directory is "D:\AwesomeProject-superbuild\". Replace names and
paths accordingly.
- Close %CMake and open "D:\AwesomeProject-superbuild\AwesomeProject-superbuild.sln".
Your Visual Studio should appear and by pressing F7 you start the compilation.
This will clone the MITK source code, build it, and then start building your own
project.
- After the superbuild compilation has finished, close the solution file and start
the batch file "D:\AwesomeProject-superbuild\AwesomeProject-build\StartVS_debug.bat"
(or _release.bat if you built in Release mode) which opens the
"D:\AwesomeProject-superbuild\AweseomeProject-build\AwesomeProject.sln" solution.
- Set the "AwesomeApp" project as start-up project (right click > "Set as StartUp
Project") and press "F5" to start your MITK AwesomeApp.
\note Just opening AwesomeProject.sln from your explorer by double-cliking won`t
allow you to start or debug your application because the required environment
variables would be missing. Use the supplied batch files or set your PATH variable
accordingly.
\section HowToNewProjectAddingMITKFunctionality I want to use some MITK plugin but
it is not available
Due to the sheer number of MITK plugins not every plugin is activated by default.
To activate a specific plugin (again replace paths as needed):
- Start "cmake-gui" and set the binary directory to
"D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\", the source will
adjust automatically and you will see new settings appear.
- Navigate to the plugin you want to use (e.g. "MITK_BUILD_org.mitk.gui.qt.segmentation")
and tick the checkbox behind it
- Press "Configure" until no new variables appear and then "Generate".
- Build MITK using your development tool (as in
\ref HowToNewProjectCompilingLinuxMakefiles or \ref HowToNewProjectCompilingVisualStudio
only in the "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\" directory )
- Start "cmake-gui" and set the binary directory to
"D:\AwesomeProject-superbuild\AwesomeProject-build\", the source will adjust
automatically and you will see new settings appear.
- Press "Configure" until no new variables appear and then "Generate".
- Build your project
- Start your application
\note If you want to use an application provided by MITK (e.g. MITK Workbench) you
-have to tick the appropriate checkbox as well (in this case MITK_BUILD_APP_mitkWorkbench)
+have to tick the appropriate checkbox as well (in this case MITK_BUILD_APP_Workbench)
and build MITK. Do note, that this application will be located in the bin directory
of the "D:\AwesomeProject-superbuild\MITK-superbuild\MITK-build\" folder.
\section HowToNewProjectAdvancedInformation Information for advanced users
\subsection HowToNewProjectCustomizingMITK Customizing MITK
The %CMake scripts from the Plugin Generator of the project template provide some
handy options which allow you to customize the MITK build used in your project.
You can either inject an already build MITK to be used by your project or configure
some MITK options directly in your project's superbuild configuration if MITK is
going to be build inside your project.
\subsubsection HowToNewProjectCustomizingMITKInjectMITK Inject a MITK build
By setting the \b EXTERNAL_MITK_DIR \b variable in your project's superbuild
%CMake configuration to a MITK build directory (containing the MITKConfig.cmake)
you can skip the MITK build process.
If MITK is the only external project in your project, you might want to disable
the superbuild of your project completely (set _USE_SUPERBUILD
to OFF or edit your CMakeLists.txt file to set it to OFF by default) and set
the \b MITK_DIR \b %CMake variable to your MITK build directory.
\subsubsection HowToNewProjectCustomizingMITKConfigure Configure the MITK superbuild
If MITK is being build inside your project's superbuild process, you can enable
the use of certain third-party libraries inside of MITK. The following variables
control the MITK configuration:
- \b MITK_USE_BLUEBERRY Enable the use of the BlueBerry application framework
- \b MITK_USE_Boost Download and use Boost in MITK
- \b MITK_USE_CTK Download, compile, and use CTK in MITK
- \b MITK_USE_DCMTK Download, compile, and use DCMTK in MITK
- \b MITK_USE_OpenCV Download, compile, and use OpenCV in MITK
- \b MITK_USE_Python Download and compile 1CableSwig and enable Python
wrapping in ITK, VTK, OpenCV, and MITK
- \b MITK_USE_QT Use the Qt framework in MITK
You can also inject already build third-party libraries from inside your project's
superbuild in the MITK superbuild by using any of the following %CMake variables:
- \b MITK_CTK_DIR Reuse a CTK build directory in MITK.
- \b MITK_CableSwig_DIR Reuse a 1CableSwig build directory in MITK.
- \b MITK_DCMTK_DIR Reuse a DCMKT build directory in MITK.
- \b MITK_GDCM_DIR Reuse a GDCM build directory in MITK.
- \b MITK_ITK_DIR Reuse a ITK build directory in MITK.
- \b MITK_OpenCV_DIR Reuse a OpenCV build directory in MITK.
- \b MITK_VTK_DIR Reuse a VTK build directory in MITK.
If the corresponding \b MITK_USE_ \b option is set to on, the MITK
superbuild will use the provided build directory instead of building the
project itself.
You can also control the source code location for MITK in your project's
superbuild configuration by using the following %CMake variables:
- \b MITK_SOURCE_DIR The path to the MITK source directory. If the value
for this variable is non-empty, the variables below are ignored.
- \b MITK_GIT_REPOSITORY The Git repository containing the MITK source code.
- \b MITK_GIT_TAG The hash id, tag or branch name used for a checkout
from MITK_GIT_REPOSITORY.
\subsubsection HowToNewProjectProjectStructure Project Structure
If you are using the superbuild feature of the generated project (the default),
you might want to familiarise yourself with the layout of your build tree.
The top-level build directory which you specified in %CMake when configuring
your project will contain all the required dependencies.
Suppose we call our project MyProject and the build directory is
"C:\MyProject-superbuild". Then the layout looks something like this:
MyProjectLayout.png The top-level directory contains the source code and the
build directories from the dependencies of your project. In the current case,
the only dependency of MyProject is MITK, which in turn has downloaded and built
its own dependencies (CTK, DCMTK, ITK, etc.). The "real" build tree for your
project is located in MyProject-superbuild/MyProject-build, so point the
%CMake-GUI to this build directory if you want to change the set of enabled
plug-ins for example.
Further, you should open the MyProject.sln solution file (for Visual Studio)
or execute "make" in the MyProject-superbuild/MyProject-build/ directory.
Only for the very first time or if you want to update and newly build the
project's dependencies should you use the project files in the
MyProject-superbuild directory directly.
The same applies for the MyProject-superbuild/MITK-superbuild directory. This
directory contains the MITK superbuild, nested inside your project's superbuild.
If you want to change %CMake options for MITK, use the
MyProject-superbuild/MITK-superbuild/MITK-build build directory.
\imageMacro{HowToNewProject-MyProjectLayout.png,"Layout of MyProject",4.02}
\subsubsection HowToNewProjectPackaging Packaging
The project template and the generated projects by the Plugin Generator come
with full packaging support. You can create deployable packages of your project
for all supported operating systems my building the PACKAGE target. On Linux,
this will create a tarball, on MacOS a .dmg file, and on Windows a zipball and
an NSIS installer (if NSIS is installed and found).
You can read more about deployment \ref DeploymentPage "here".
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/SupportedPlatforms.md b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/SupportedPlatforms.md
index a892f50440..b71cb00b15 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/SupportedPlatforms.md
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/SupportedPlatforms.md
@@ -1,51 +1,51 @@
Supported Platforms {#SupportedPlatformsPage}
===================
-MITK is a cross-platform framework and is available for the following platforms:
+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).
+we divide platform support into two test categories: Tier 1 and Tier 2.
-Although MITK may be built on a range of platform-compiler combinations, only a subset of these are actively
-support by the MITK development team.
+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.
| Platform | Compilers
-| ----------------------------------- | -----------------------------
-| Ubuntu Linux 12.04 (64-bit) | gcc as provided by Ubuntu
-| Microsoft Windows 7 (64-bit) | MSVC 2010 Professional SP1 (x64)
-| Apple OS X 10.9 "Mavericks" | LLVM-Clang 6.0 as provided by Apple (XCode)
+| ----------------------------------- | --------------------------------------------------
+| Ubuntu Linux 14.04 (x64) | GNU 4.8
+| Ubuntu Linux 12.04 (x64) | GNU 4.7 as provided by ppa:ubuntu-toolchain-r/test
+| Microsoft Windows 7 (x64) | MSVC 2012 Express Update 4
+| Apple OS X 10.10 "Yosemite" | Clang 6.0
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.
| Platform | Compilers
-| ---------------------------------- | -----------------------------
-| Fedora 20 (64-bit) | gcc as provided by Fedora
-| Fedora 20 (64-bit) | Clang as provided by Fedora
-| Microsoft Windows 7 (32-bit) | MSVC 2012 Express (x64)
-| Apple OS X 10.7 "Lion" | LLVM-Clang as provided by Apple (XCode)
-
+| ---------------------------------- | --------------------------------------------------
+| Ubuntu Linux 12.04 (x86) | GNU 4.7 as provided by ppa:ubuntu-toolchain-r/test
+| Microsoft Windows 7 (x64) | MSVC 2012 Express Update 4 (x86)
+| Microsoft Windows 8 (x64) | MSVC 2013 Community Update 4
+| Apple OS X 10.9 "Mavericks" | Clang 5.0
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.
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
index ee2ebe66ba..28be67420a 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/SettingUpMITK/ThirdPartyLibs.dox
@@ -1,109 +1,113 @@
/**
\page thirdpartylibs Third-party libraries
The following third-party libraries can be used with MITK by default and can, in part, be automatically downloaded during superbuild.
\par ACVD
http://www.creatis.insa-lyon.fr/site/en/acvd
\par ANN
http://www.cs.umd.edu/~mount/ANN/
\par Boost
http://www.boost.org/
\par CppUnit
http://sourceforge.net/projects/cppunit/
\par CTK
http://www.commontk.org/
\par DCMTK
http://dicom.offis.de/dcmtk.php.en
\par GDCM
http://gdcm.sourceforge.net/
-\par GLEW (The OpenGL Extension Wrangler Library)
+\par GLEW
http://glew.sourceforge.net/
\par GLUT
https://www.opengl.org/resources/libraries/glut/
\par ITK
http://www.itk.org/
-\par KWStlye
-
-http://public.kitware.com/KWStyle/
-
-\par LibQxt (the Qt eXTension library)
-
-http://www.libqxt.org/
-
\par NumPy
http://www.numpy.org/
\par OpenCV
http://opencv.willowgarage.com/wiki/Welcome
+\par OpenIGTLink
+
+http://openigtlink.org/
+
\par PCRE
http://www.pcre.org/
-\par POCO (Portable Components)
+\par POCO
http://pocoproject.org
\par Python
https://www.python.org/
\par Qt
-http://qt.nokia.com/
+http://www.qt.io/
-\par Qwt (Qt Widgets for Technical Applications)
+\par Qwt
http://qwt.sourceforge.net/
+\par Redland
+
+http://librdf.org/
+
\par SimpleITK
http://www.simpleitk.org/
\par SOFA
http://www.sofa-framework.org/
\par SWIG
http://swig.org/
\par tinyxml
http://sourceforge.net/projects/tinyxml/
+\par VIGRA
+
+http://ukoethe.github.io/vigra/
+
\par VTK
http://www.vtk.org/
\par zlib
https://github.com/commontk/zlib
For copyright information on any of the above toolkits see the corresponding home page or the corresponding source folder.
*/
diff --git a/Documentation/Doxygen/3-DeveloperManual/Starting/Starting.dox b/Documentation/Doxygen/3-DeveloperManual/Starting/Starting.dox
index 8832e14bdd..fb427a42ac 100644
--- a/Documentation/Doxygen/3-DeveloperManual/Starting/Starting.dox
+++ b/Documentation/Doxygen/3-DeveloperManual/Starting/Starting.dox
@@ -1,45 +1,40 @@
/**
\page StartingDevelopment Starting your MITK Development
-This Introduction will acquaint you with the most important work flows to get you started with your MITK Development.
-First, \ref Architecture will explain the difference between the application and the toolkit.
-\ref SettingUpMITK will get you started with a working MITK Development environment. \ref GettingToKnowMITK will walk you trough the folder structure and the module and plugin system. This chapter also contains an extensive tutorial on how to work with MITK.
+This introduction will acquaint you with the most important workflows to get you started with your MITK development.
+First, \ref Architecture will explain the differences between the application and the toolkit.
+\ref SettingUpMITK will get you started with a working environment for MITK development. \ref GettingToKnowMITK 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 \ref FirstSteps section will then show you how to extend MITK for your own project.
-
-
-
- \subpage Architecture
- \subpage SettingUpMITK
- \ref SupportedPlatformsPage
- \ref BuildInstructionsPage
- \ref thirdpartylibs
- \ref HowToNewProject
- \subpage GettingToKnowMITK
- \ref DirectoryStructurePage
- \ref TutorialPage
- \ref CMAKE_FAQ
- \ref StyleGuideAndNotesPage
- \ref DocumentationGuide
- \ref CodingPage
- \ref KnownProblemsPage
- \subpage FirstSteps
- \ref NewPluginPage
- \ref NewViewPage
- \ref NewModulePage
- \ref CMAKE_FAQ
- \ref StatemachineEditor
- \subpage AboutTestingPage
-
-
*/
diff --git a/Examples/QtAppExample/CMakeLists.txt b/Examples/QtAppExample/CMakeLists.txt
index 8e0e371a57..f5336896ab 100644
--- a/Examples/QtAppExample/CMakeLists.txt
+++ b/Examples/QtAppExample/CMakeLists.txt
@@ -1,13 +1,13 @@
-cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+cmake_minimum_required(VERSION 3.2 FATAL_ERROR)
project(QtAppExample)
find_package(MITK REQUIRED)
# Check that MITK has been build with Qt support
if(NOT MITK_USE_QT)
message(SEND_ERROR "MITK needs to be built with MITK_USE_QT set to ON")
endif()
# Create the executable - it needs the MitkQtWidgetsExt module
mitk_create_executable(${PROJECT_NAME} DEPENDS MitkQtWidgets)
diff --git a/README.md b/README.md
index f2b3c3f068..52811c3495 100644
--- a/README.md
+++ b/README.md
@@ -1,94 +1,94 @@
![MITK Logo][logo]
The [Medical Imaging Interaction Toolkit][mitk] (MITK) is a free open-source software
system for development of interactive medical image processing software. MITK
combines the [Insight Toolkit][itk] (ITK) and the [Visualization Toolkit][vtk] (VTK) with an application framework.
The links below provide high-level and reference documentation targeting different
usage scenarios:
- Get a [high-level overview][mitk-overview] about MITK with pointers to further
documentation
- End-users looking for help with MITK applications should read the
[MITK User Manual][mitk-usermanual]
- Developers contributing to or using MITK, please see the [MITK Developer Manual][mitk-devmanual]
as well as the [MITK API Reference][mitk-apiref]
See the [MITK homepage][mitk] for details.
Supported Platforms
-----------------------------
MITK is a cross-platform C++ toolkit and officially supports:
- Windows
- MacOS X
- Linux
For details, please read the [Supported Platforms][platforms] page.
License
-----------
Copyright (c) [German Cancer Research Center][dkfz].
MITK is available as free open-source software under a [BSD-style license][license].
Download
---------
-The MITK source code and binaries for the *mitkWorkbench* application are released regularly according to the [MITK release cycle][release-cycle]. See the [Download][download] page for a list of releases.
+The MITK source code and binaries for the *MitkWorkbench* application are released regularly according to the [MITK release cycle][release-cycle]. See the [Download][download] page for a list of releases.
The official MITK source code is available in the [MITK Git repository][gitweb]. The Git clone command is
git clone http://git.mitk.org/MITK.git
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][contribute] page if you plan to contribute to MITK.
Build Instructions
------------------------
MITK uses [CMake][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 http://git.mitk.org/MITK.git
mkdir MITK-build
cd MITK-build
cmake ../MITK
make -j4
Read the comprehensive [Build Instructions][build] page for details.
Useful Links
------------------
- [Homepage][mitk]
- [Download][download]
- [Mailing List][mailinglist]
- [Bug Tracker][bugs]
[logo]: https://github.com/MITK/MITK/raw/master/mitk.png
[mitk]: http://mitk.org
[itk]: http://www.itk.org
[vtk]: http://www.vtk.org
[mitk-overview]: http://docs.mitk.org/2014.10/Overview.html
[mitk-usermanual]: http://docs.mitk.org/2014.10/UserManualPortal.html
[mitk-devmanual]: http://docs.mitk.org/2014.10/DeveloperManualPortal.html
[mitk-apiref]: http://docs.mitk.org/2014.10/usergroup0.html
[platforms]: http://docs.mitk.org/2014.10/SupportedPlatformsPage.html
[dkfz]: http://www.dkfz.de
[license]: http://mitk.org/git/?p=MITK.git;a=blob_plain;f=LICENSE.txt
[release-cycle]: http://mitk.org/MitkReleaseCycle
[download]: http://mitk.org/Download
[gitweb]: http://mitk.org/git/?p=MITK.git
[contribute]: http://mitk.org/How_to_contribute
[cmake]: http://www.cmake.org
[build]: http://docs.mitk.org/2014.10/BuildInstructionsPage.html
[mailinglist]: http://mitk.org/Mailinglist
[bugs]: http://bugs.mitk.org/