diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/DicomView.cpp b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/DicomView.cpp
index c07ece2100..4da36f5c4e 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/DicomView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/DicomView.cpp
@@ -1,109 +1,110 @@
 /*===================================================================
 
 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 "DicomView.h"
 
 #include "org_mitk_example_gui_customviewer_views_Activator.h"
 
 #include "mitkIDataStorageService.h"
 #include "mitkDicomSeriesReader.h"
+#include "mitkImage.h"
 
 #include <berryIWorkbench.h>
 #include <berryIWorkbenchWindow.h>
 #include <berryIWorkbenchPage.h>
 
 #include "QDockWidget"
 
 const std::string DicomView::VIEW_ID = "org.mitk.customviewer.views.dicomview";
 
 DicomView::DicomView()
   : m_Parent(0)
 {
 }
 
 DicomView::~DicomView()
 {
 }
 
 // //! [DicomViewCreatePartControl]
 void DicomView::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets
   m_Parent = parent;
   m_Controls.setupUi(parent);
 
   //remove unused widgets
   QPushButton* downloadButton = parent->findChild<QPushButton*>("downloadButton");
   downloadButton->setVisible(false);
   QDockWidget* searchWidget = parent->findChild<QDockWidget*>("ExternalSearchDockWidget");
   searchWidget->setVisible(false);
 
   connect(m_Controls.importButton, SIGNAL(clicked()), m_Controls.widget, SLOT(OnFolderCDImport()));
   connect(m_Controls.widget, SIGNAL(SignalDicomToDataManager(const QStringList&)), this, SLOT(AddDataNodeFromDICOM(const QStringList&)));
 
   m_Parent->setEnabled(true);
 }
 // //! [DicomViewCreatePartControl]
 
 // //! [DicomViewCreateAddDataNodeInformation]
 void DicomView::AddDataNodeFromDICOM(const QStringList& Properties)
 {
   QString seriesUID = Properties.at(3);
   QString path = Properties.at(5);
 // //! [DicomViewCreateAddDataNodeInformation]
 // //! [DicomViewCreateAddDataNodeLoadSeries]
   mitk::DicomSeriesReader::StringContainer seriesToLoad;
   std::size_t found;
 
   mitk::DicomSeriesReader::FileNamesGrouping dicomSeriesMap = mitk::DicomSeriesReader::GetSeries(path.toStdString(),false);
   mitk::DicomSeriesReader::FileNamesGrouping::const_iterator qualifiedSeriesInstanceUIDIterator;
 
   for(qualifiedSeriesInstanceUIDIterator = dicomSeriesMap.begin();
       qualifiedSeriesInstanceUIDIterator != dicomSeriesMap.end();
       ++qualifiedSeriesInstanceUIDIterator)
   {
       found = qualifiedSeriesInstanceUIDIterator->second.GetSeriesInstanceUID().find(seriesUID.toStdString());
       if(found != std::string::npos)
       {
           seriesToLoad = qualifiedSeriesInstanceUIDIterator->second.GetFilenames();
       }
   }
 
   mitk::DataNode::Pointer node = mitk::DicomSeriesReader::LoadDicomSeries(seriesToLoad);
 // //! [DicomViewCreateAddDataNodeLoadSeries]
   if (node.IsNull())
   {
       MITK_ERROR << "Could not load series: " << seriesUID.toStdString();
   }
   else
   {
 // //! [DicomViewCreateAddDataNode]
       this->GetDataStorage()->Add(node);
 // //! [DicomViewCreateAddDataNode]
       mitk::RenderingManager::GetInstance()->SetDataStorage(this->GetDataStorage());
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
 // //! [DicomViewCreateAddDataNodeActivatePersp]
       berry::IWorkbenchWindow::Pointer window = this->GetSite()->GetWorkbenchWindow();
       std::string perspectiveId = "org.mitk.example.viewerperspective";
       window->GetWorkbench()->ShowPerspective(perspectiveId, berry::IWorkbenchWindow::Pointer(window));
 // //! [DicomViewCreateAddDataNodeActivatePersp]
   }
 }
 
 void DicomView::SetFocus ()
 {
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
index e9117b6532..ca55121a45 100644
--- a/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
+++ b/Examples/Plugins/org.mitk.example.gui.customviewer.views/src/internal/SimpleRenderWindowView.cpp
@@ -1,212 +1,213 @@
 /*===================================================================
 
 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 "SimpleRenderWindowView.h"
 
 #include <QmitkRenderWindow.h>
 
 #include <mitkInteractionConst.h>
 #include <mitkPositionEvent.h>
 #include <mitkStateEvent.h>
 #include <ctkServiceTracker.h>
 #include <berryIBerryPreferences.h>
 #include <mitkIRenderingManager.h>
 #include "org_mitk_example_gui_customviewer_views_Activator.h"
 
 #include <QVBoxLayout>
+#include <mitkPlaneGeometry.h>
 
 /**
  * \brief Helper class adapted from QmitkAbstractRenderEditor by defining the correct plugin context.
  *
  *  This helper class adapted from QmitkAbstractRenderEditor provides the rendering manager interface.
  */
 // //! [SimpleRenderWindowViewHelper]
 class AbstractRenderWindowViewPrivate
 {
 public:
 
   AbstractRenderWindowViewPrivate()
     : m_RenderingManagerInterface(mitk::MakeRenderingManagerInterface(mitk::RenderingManager::GetInstance()))
     , m_PrefServiceTracker(org_mitk_example_gui_customviewer_views_Activator::GetPluginContext())
 // //! [SimpleRenderWindowViewHelper]
   {
     m_PrefServiceTracker.open();
   }
 
   ~AbstractRenderWindowViewPrivate()
   {
     delete m_RenderingManagerInterface;
   }
 
   mitk::IRenderingManager* m_RenderingManagerInterface;
   ctkServiceTracker<berry::IPreferencesService*> m_PrefServiceTracker;
   berry::IBerryPreferences::Pointer m_Prefs;
 };
 
 const std::string SimpleRenderWindowView::VIEW_ID = "org.mitk.customviewer.views.simplerenderwindowview";
 
 
 SimpleRenderWindowView::SimpleRenderWindowView()
   : m_RenderWindow(0), d(new AbstractRenderWindowViewPrivate)
 {
 }
 
 SimpleRenderWindowView::~SimpleRenderWindowView()
 {
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetActiveQmitkRenderWindow() const
 {
   return m_RenderWindow;
 }
 
 QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow*> wnds;
   wnds.insert("transversal", m_RenderWindow);
   return wnds;
 }
 
 QHash<QString, QmitkRenderWindow *> SimpleRenderWindowView::GetQmitkRenderWindows() const
 {
   QHash<QString, QmitkRenderWindow*> wnds;
   wnds.insert("transversal", m_RenderWindow);
   return wnds;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetRenderWindow(const QString &id) const
 {
   if (id == "transversal")
   {
     return m_RenderWindow;
   }
   return 0;
 }
 
 QmitkRenderWindow *SimpleRenderWindowView::GetQmitkRenderWindow(const QString &id) const
 {
   if (id == "transversal")
   {
     return m_RenderWindow;
   }
   return 0;
 }
 
 mitk::Point3D SimpleRenderWindowView::GetSelectedPosition(const QString & /*id*/) const
 {
   const mitk::PlaneGeometry* pg =
       m_RenderWindow->GetSliceNavigationController()->GetCurrentPlaneGeometry();
   if (pg)
   {
     return pg->GetCenter();
   }
   else
   {
     return mitk::Point3D();
   }
 }
 
 void SimpleRenderWindowView::SetSelectedPosition(const mitk::Point3D &pos, const QString &/*id*/)
 {
   // create a PositionEvent with the given position and
   // tell the slice navigation controller to move there
 
   mitk::Point2D p2d;
   mitk::PositionEvent event( m_RenderWindow->GetRenderer(), 0, 0, 0,
                              mitk::Key_unknown, p2d, pos );
   mitk::StateEvent stateEvent(mitk::EIDLEFTMOUSEBTN, &event);
   mitk::StateEvent stateEvent2(mitk::EIDLEFTMOUSERELEASE, &event);
 
   m_RenderWindow->GetSliceNavigationController()->HandleEvent( &stateEvent );
 
   // just in case SNCs will develop something that depends on the mouse
   // button being released again
   m_RenderWindow->GetSliceNavigationController()->HandleEvent( &stateEvent2 );
 
   // update displays
   //mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void SimpleRenderWindowView::EnableDecorations(bool enable, const QStringList &decorations)
 {
   if (decorations.isEmpty() || decorations.contains(DECORATION_MENU))
   {
     m_RenderWindow->ActivateMenuWidget(enable);
   }
 }
 
 bool SimpleRenderWindowView::IsDecorationEnabled(const QString &decoration) const
 {
   if (decoration == DECORATION_MENU)
   {
     return m_RenderWindow->GetActivateMenuWidgetFlag();
   }
   return false;
 }
 
 QStringList SimpleRenderWindowView::GetDecorations() const
 {
   QStringList decorations;
   decorations << DECORATION_MENU;
   return decorations;
 }
 
 void SimpleRenderWindowView::SetFocus()
 {
   m_RenderWindow->setFocus();
 }
 
 // //! [SimpleRenderWindowViewCreatePartControl]
 void SimpleRenderWindowView::CreateQtPartControl(QWidget* parent)
 {
   QVBoxLayout* layout = new QVBoxLayout(parent);
   layout->setContentsMargins(0,0,0,0);
 
   m_RenderWindow = new QmitkRenderWindow(parent);
   layout->addWidget(m_RenderWindow);
 
   mitk::DataStorage::Pointer ds = this->GetDataStorage();
   m_RenderWindow->GetRenderer()->SetDataStorage(ds);
 
   this->RequestUpdate();
 }
 // //! [SimpleRenderWindowViewCreatePartControl]
 
 mitk::IRenderingManager* SimpleRenderWindowView::GetRenderingManager() const
 {
   // we use the global rendering manager here. This should maybe replaced
   // by a local one, managing only the render windows specific for the view
   return d->m_RenderingManagerInterface;
 }
 
 void SimpleRenderWindowView::RequestUpdate(mitk::RenderingManager::RequestType requestType)
 {
   if (GetRenderingManager())
     GetRenderingManager()->RequestUpdateAll(requestType);
 }
 
 void SimpleRenderWindowView::ForceImmediateUpdate(mitk::RenderingManager::RequestType requestType)
 {
   if (GetRenderingManager())
     GetRenderingManager()->ForceImmediateUpdateAll(requestType);
 }
 
 mitk::SliceNavigationController* SimpleRenderWindowView::GetTimeNavigationController() const
 {
   if (GetRenderingManager())
     return GetRenderingManager()->GetTimeNavigationController();
   return 0;
 }
diff --git a/Examples/Plugins/org.mitk.example.gui.regiongrowing/src/internal/QmitkRegionGrowingView.h b/Examples/Plugins/org.mitk.example.gui.regiongrowing/src/internal/QmitkRegionGrowingView.h
index 2f5c998088..3f8ebb81aa 100644
--- a/Examples/Plugins/org.mitk.example.gui.regiongrowing/src/internal/QmitkRegionGrowingView.h
+++ b/Examples/Plugins/org.mitk.example.gui.regiongrowing/src/internal/QmitkRegionGrowingView.h
@@ -1,97 +1,98 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 
 #ifndef QmitkRegionGrowingView_h
 #define QmitkRegionGrowingView_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_QmitkRegionGrowingViewControls.h"
 
 //! [includes]
 #include "mitkPointSet.h"
 #include "mitkIRenderWindowPartListener.h"
+#include <itkImage.h>
 
 class QmitkPointListWidget;
 //! [includes]
 
 /**
   \brief QmitkRegionGrowingView
 
   \warning  This class is not yet documented. Use "git blame" and ask the author to provide basic documentation.
 
   \sa QmitkAbstractView
   \ingroup ${plugin_target}_internal
 */
 class QmitkRegionGrowingView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkRegionGrowingView();
 
   protected slots:
 
     /// \brief Called when the user clicks the GUI button
     void DoImageProcessing();
 
   protected:
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     virtual void SetFocus();
 
     /// \brief called by QmitkFunctionality when DataManager's selection has changed
     virtual void OnSelectionChanged( berry::IWorkbenchPart::Pointer source,
                                      const QList<mitk::DataNode::Pointer>& nodes );
 
     //! [render-window-part-listener]
     void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart);
     void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart);
     //! [render-window-part-listener]
 
     Ui::QmitkRegionGrowingViewControls m_Controls;
 
   private:
 
     //! [itkimageprocessing]
     /**
       \brief ITK image processing function
       This function is templated like an ITK image. The MITK-Macro AccessByItk determines the actual pixel type and dimensionality of
       a given MITK image and calls this function for further processing (in our case region growing)
     */
     template < typename TPixel, unsigned int VImageDimension >
     void ItkImageProcessing( itk::Image< TPixel, VImageDimension >* itkImage, mitk::Geometry3D* imageGeometry );
     //! [itkimageprocessing]
 
     //! [members]
     /// \brief This is the actual seed point data object
     mitk::PointSet::Pointer m_PointSet;
 
     QmitkPointListWidget* m_PointListWidget;
     //! [members]
 
 };
 
 #endif // QmitkRegionGrowingView_h
diff --git a/Examples/Tutorial/Step4/Step4.cpp b/Examples/Tutorial/Step4/Step4.cpp
index 3b6a5cffbd..8460245239 100644
--- a/Examples/Tutorial/Step4/Step4.cpp
+++ b/Examples/Tutorial/Step4/Step4.cpp
@@ -1,186 +1,187 @@
 /*===================================================================
 
 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 "QmitkSliceWidget.h"
 
 #include "mitkDataNodeFactory.h"
 #include "mitkProperties.h"
 #include "mitkRenderingManager.h"
 #include "mitkStandaloneDataStorage.h"
 #include "mitkNodePredicateDataType.h"
 
 #include <itksys/SystemTools.hxx>
 #include <QApplication>
 #include <QHBoxLayout>
+#include <mitkImage.h>
 
 //##Documentation
 //## @brief Use several views to explore data
 //##
 //## As in Step2 and Step3, load one or more data sets (many image,
 //## surface and other formats), but create 3 views on the data.
 //## The QmitkRenderWindow is used for displaying a 3D view as in Step3,
 //## but without volume-rendering.
 //## Furthermore, we create two 2D views for slicing through the data.
 //## We use the class QmitkSliceWidget, 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.
 //## The two slices are also shown at their correct position in 3D as
 //## well as intersection-line, each in the other 2D view.
 int main(int argc, char* argv[])
 {
   QApplication qtapplication( argc, argv );
 
   if(argc<2)
   {
     fprintf( stderr, "Usage:   %s [filename1] [filename2] ...\n\n", itksys::SystemTools::GetFilenameName(argv[0]).c_str() );
     return 1;
   }
 
   // Register Qmitk-dependent global instances
   QmitkRegisterClasses();
 
   //*************************************************************************
   // Part I: Basic initialization
   //*************************************************************************
 
   // Create a DataStorage
   mitk::StandaloneDataStorage::Pointer ds = mitk::StandaloneDataStorage::New();
 
 
   //*************************************************************************
   // Part II: Create some data by reading files
   //*************************************************************************
   int i;
   for(i=1; i<argc; ++i)
   {
     // For testing
     if(strcmp(argv[i], "-testing")==0) continue;
 
     // Create a DataNodeFactory to read a data format supported
     // by the DataNodeFactory (many image formats, surface formats, etc.)
     mitk::DataNodeFactory::Pointer nodeReader=mitk::DataNodeFactory::New();
     const char * filename = argv[i];
     try
     {
       nodeReader->SetFileName(filename);
       nodeReader->Update();
       //*********************************************************************
       //Part III: Put the data into the datastorage
       //*********************************************************************
 
       // Since the DataNodeFactory directly creates a node,
       // use the datastorage to add the read node
       mitk::DataNode::Pointer node = nodeReader->GetOutput();
       ds->Add(node);
     }
     catch(...)
     {
       fprintf( stderr, "Could not open file %s \n\n", filename );
       exit(2);
     }
   }
 
   //*************************************************************************
   // Part IV: Create windows and pass the tree to it
   //*************************************************************************
 
   // Create toplevel widget with horizontal layout
   QWidget toplevelWidget;
   QHBoxLayout layout;
   layout.setSpacing(2);
   layout.setMargin(0);
   toplevelWidget.setLayout(&layout);
 
   //*************************************************************************
   // Part IVa: 3D view
   //*************************************************************************
 
   // Create a renderwindow
   QmitkRenderWindow renderWindow(&toplevelWidget);
   layout.addWidget(&renderWindow);
 
   // Tell the renderwindow which (part of) the datastorage to render
   renderWindow.GetRenderer()->SetDataStorage(ds);
 
   // Use it as a 3D view
   renderWindow.GetRenderer()->SetMapperID(mitk::BaseRenderer::Standard3D);
 
   // *******************************************************
   // ****************** START OF NEW PART ******************
   // *******************************************************
 
   //*************************************************************************
   // Part IVb: 2D view for slicing axially
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view2(&toplevelWidget);
   layout.addWidget(&view2);
   view2.SetLevelWindowEnabled(true);
   // Tell the QmitkSliceWidget which (part of) the tree to render.
   // By default, it slices the data axially
   view2.SetDataStorage(ds);
 
   // Get the image from the data storage. A predicate (mitk::NodePredicateBase)
   // is used to get only nodes of the type mitk::Image.
   mitk::DataStorage::SetOfObjects::ConstPointer rs =
       ds->GetSubset(mitk::TNodePredicateDataType<mitk::Image>::New());
 
   view2.SetData(rs->Begin(),mitk::SliceNavigationController::Axial);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the datastorage!
   ds->Add(view2.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   //*************************************************************************
   // Part IVc: 2D view for slicing sagitally
   //*************************************************************************
 
   // Create QmitkSliceWidget, which is based on the class
   // QmitkRenderWindow, but additionally provides sliders
   QmitkSliceWidget view3(&toplevelWidget);
   layout.addWidget(&view3);
   view3.SetDataStorage(ds);
   // Tell the QmitkSliceWidget which (part of) the datastorage to render
   // and to slice sagitally
   view3.SetData(rs->Begin(), mitk::SliceNavigationController::Sagittal);
   // We want to see the position of the slice in 2D and the
   // slice itself in 3D: add it to the datastorage!
   ds->Add(view3.GetRenderer()->GetCurrentWorldGeometry2DNode());
 
   // *******************************************************
   // ******************* END OF NEW PART *******************
   // *******************************************************
 
   //*************************************************************************
   // Part V: Qt-specific initialization
   //*************************************************************************
   toplevelWidget.show();
 
   // for testing
   #include "QtTesting.h"
   if(strcmp(argv[argc-1], "-testing")!=0)
     return qtapplication.exec();
   else
     return QtTesting();
 }
 
 /**
 \example Step4.cpp
 */
diff --git a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleGui.cpp b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleGui.cpp
index 367d83497f..1207043f54 100644
--- a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleGui.cpp
+++ b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkCmdLineModuleGui.cpp
@@ -1,274 +1,275 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) University College London (UCL).
 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 "QmitkCmdLineModuleGui.h"
 #include "QmitkUiLoader.h"
 #include <QVariant>
 #include <QIODevice>
 #include <QFile>
 #include <QScopedPointer>
 #include <QWidget>
 #include <QTextBrowser>
 #include <QVBoxLayout>
 #include <QmitkCustomVariants.h>
 #include <ctkCmdLineModuleXslTransform.h>
 #include <ctkCmdLineModuleParameter.h>
 #include <ctkCmdLineModuleDescription.h>
 #include <ctkCollapsibleGroupBox.h>
 #include "mitkDataStorage.h"
+#include <mitkImage.h>
 
 //-----------------------------------------------------------------------------
 struct QmitkCmdLineModuleGuiPrivate
 {
   QmitkCmdLineModuleGuiPrivate(const mitk::DataStorage* dataStorage)
     : m_DataStorage(dataStorage), m_Loader(NULL), m_Transform(NULL), m_TopLevelWidget(NULL)
   {
   }
   const mitk::DataStorage* m_DataStorage;
   mutable QScopedPointer<QUiLoader> m_Loader;
   mutable QScopedPointer<ctkCmdLineModuleXslTransform> m_Transform;
   mutable QScopedPointer<QWidget> m_TopLevelWidget;
 };
 
 
 //-----------------------------------------------------------------------------
 QmitkCmdLineModuleGui::QmitkCmdLineModuleGui(const mitk::DataStorage* dataStorage, const ctkCmdLineModuleReference& moduleRef)
   : ctkCmdLineModuleFrontendQtGui(moduleRef)
 , d(new QmitkCmdLineModuleGuiPrivate(dataStorage))
 {
   qRegisterMetaType<mitk::DataNode::Pointer>();
 }
 
 
 //-----------------------------------------------------------------------------
 QmitkCmdLineModuleGui::~QmitkCmdLineModuleGui()
 {
 }
 
 
 //-----------------------------------------------------------------------------
 QUiLoader* QmitkCmdLineModuleGui::uiLoader() const
 {
   // Here we are creating a QUiLoader locally, so when this method
   // is called, it overrides the one in the base class, so the base
   // class one is never constructed, and this one is constructed as
   // a replacement.
   if (d->m_Loader == NULL)
   {
     d->m_Loader.reset(new QmitkUiLoader(d->m_DataStorage));
   }
   return d->m_Loader.data();
 }
 
 
 //-----------------------------------------------------------------------------
 ctkCmdLineModuleXslTransform* QmitkCmdLineModuleGui::xslTransform() const
 {
   // This is a virtual getter, overriding the one in the base class.
   // However, we want to use the transform in the base class, and just append to it.
   // So we call the base class one, modify it by adding some stuff, and then return
   // the pointer to the one in the base class.
   ctkCmdLineModuleXslTransform *transform = ctkCmdLineModuleFrontendQtGui::xslTransform();
   if (transform != NULL)
   {
     transform->bindVariable("imageInputWidget", QVariant(QString("QmitkDataStorageComboBoxWithSelectNone")));
     transform->bindVariable("imageInputValueProperty", "currentValue");
     transform->bindVariable("imageInputSetProperty", ""); // Don't need this, as we are connected to DataStorage.
   }
   return transform;
 }
 
 
 //-----------------------------------------------------------------------------
 QVariant QmitkCmdLineModuleGui::value(const QString &parameter, int role) const
 {
   if (role == UserRole)
   {
     ctkCmdLineModuleParameter param = this->moduleReference().description().parameter(parameter);
     if (param.channel() == "input" && param.tag() == "image")
     {
       return this->customValue(parameter, "SelectedNode");
     }
     return QVariant();
   }
   return ctkCmdLineModuleFrontendQtGui::value(parameter, role);
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleGui::setValue(const QString& parameter, const QVariant& value, int role)
 {
   if (role == UserRole)
   {
     ctkCmdLineModuleParameter param = this->moduleReference().description().parameter(parameter);
     if (param.channel() == "input" && param.tag() == "image")
     {
       this->setCustomValue(parameter, value, "SelectedNode");
     }
     else
     {
       ctkCmdLineModuleFrontendQtGui::setValue(parameter, value, role);
     }
   }
   else
   {
     ctkCmdLineModuleFrontendQtGui::setValue(parameter, value, role);
   }
 }
 
 //-----------------------------------------------------------------------------
 QWidget* QmitkCmdLineModuleGui::getGui()
 {
   if (!d->m_TopLevelWidget)
   {
     // Construct additional widgets to contain full GUI.
     QWidget *aboutBoxContainerWidget = new QWidget();
 
     ctkCollapsibleGroupBox *aboutBox = new ctkCollapsibleGroupBox(aboutBoxContainerWidget);
     aboutBox->setTitle("About");
 
     QTextBrowser *aboutBrowser = new QTextBrowser(aboutBox);
     aboutBrowser->setReadOnly(true);
     aboutBrowser->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     aboutBrowser->setOpenExternalLinks(true);
     aboutBrowser->setOpenLinks(true);
 
     QVBoxLayout *aboutLayout = new QVBoxLayout(aboutBox);
     aboutLayout->addWidget(aboutBrowser);
 
     QVBoxLayout *aboutBoxContainerWidgetLayout = new QVBoxLayout(aboutBoxContainerWidget);
     aboutBoxContainerWidgetLayout->addWidget(aboutBox);
 
     QWidget *helpBoxContainerWidget = new QWidget();
 
     ctkCollapsibleGroupBox *helpBox = new ctkCollapsibleGroupBox();
     helpBox->setTitle("Help");
 
     QTextBrowser *helpBrowser = new QTextBrowser(helpBox);
     helpBrowser->setReadOnly(true);
     helpBrowser->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred);
     helpBrowser->setOpenExternalLinks(true);
     helpBrowser->setOpenLinks(true);
 
     QVBoxLayout *helpLayout = new QVBoxLayout(helpBox);
     helpLayout->addWidget(helpBrowser);
 
     QVBoxLayout *helpBoxContainerWidgetLayout = new QVBoxLayout(helpBoxContainerWidget);
     helpBoxContainerWidgetLayout->addWidget(helpBox);
 
     QObject* guiHandle = this->guiHandle();
     QWidget* generatedGuiWidgets = qobject_cast<QWidget*>(guiHandle);
 
     QWidget *topLevelWidget = new QWidget();
 
     QGridLayout *topLevelLayout = new QGridLayout(topLevelWidget);
     topLevelLayout->setContentsMargins(0,0,0,0);
     topLevelLayout->setSpacing(0);
     topLevelLayout->addWidget(aboutBoxContainerWidget, 0, 0);
     topLevelLayout->addWidget(helpBoxContainerWidget, 1, 0);
     topLevelLayout->addWidget(generatedGuiWidgets, 2, 0);
 
     ctkCmdLineModuleDescription description = this->moduleReference().description();
 
     QString helpString = "";
 
     if (!description.title().isEmpty())
     {
       QString titleHtml = "<h1>" + description.title() + "</h1>";
       helpString += titleHtml;
     }
 
     if (!description.description().isEmpty())
     {
       QString descriptionHtml = "<p>" + description.description() + "</p>";
       helpString += descriptionHtml;
     }
 
     if (!description.documentationURL().isEmpty())
     {
       QString docUrlHtml = "<p>For more information please see <a href=\"" + description.documentationURL()
           + "\">" + description.documentationURL() + "</a></p>";
       helpString += docUrlHtml;
     }
 
     QString aboutString = "";
 
     if (!description.title().isEmpty())
     {
       QString titleHtml = "<h1>" + description.title() + "</h1>";
       aboutString += titleHtml;
     }
 
     if (!description.contributor().isEmpty())
     {
       QString contributorHtml = "<h2>Contributed By</h2><p>" + description.contributor() + "</p>";
       aboutString += contributorHtml;
     }
 
     if (!description.license().isEmpty())
     {
       QString licenseHtml = "<h2>License</h2><p>" + description.license() + "</p>";
       aboutString += licenseHtml;
     }
 
     if (!description.acknowledgements().isEmpty())
     {
       QString acknowledgementsHtml = "<h2>Acknowledgements</h2><p>" + description.acknowledgements() + "</p>";
       aboutString += acknowledgementsHtml;
     }
 
     helpBrowser->clear();
     helpBrowser->setHtml(helpString);
     helpBox->setCollapsed(true);
 
     aboutBrowser->clear();
     aboutBrowser->setHtml(aboutString);
     aboutBox->setCollapsed(true);
 
     d->m_TopLevelWidget.reset(topLevelWidget);
   }
 
   return d->m_TopLevelWidget.data();
 }
 
 
 //-----------------------------------------------------------------------------
 void QmitkCmdLineModuleGui::copyParameters(QmitkCmdLineModuleGui& another)
 {
 
   // This copies "display" parameter types.
   // See ctkCmdLineModuleFrontend::DisplayRole
   this->setValues(another.values());
 
   // For custom types, we must manually copy the values.
   // In our case, we copy image types manually, to pass across the mitk::DataNode pointer.
   QList<ctkCmdLineModuleParameter> parameters = another.parameters("image", ctkCmdLineModuleFrontend::Input);
   foreach (ctkCmdLineModuleParameter parameter, parameters)
   {
     QString parameterName = parameter.name();
 
     QVariant tmp = another.value(parameterName, ctkCmdLineModuleFrontend::UserRole);
     mitk::DataNode::Pointer node = tmp.value<mitk::DataNode::Pointer>();
 
     if (node.IsNotNull())
     {
       mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
       if (image != NULL)
       {
         this->setValue(parameterName, tmp, ctkCmdLineModuleFrontend::UserRole);
       }
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkUiLoader.cpp b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkUiLoader.cpp
index 39442bdd17..29c165cee3 100644
--- a/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkUiLoader.cpp
+++ b/Plugins/org.mitk.gui.qt.cmdlinemodules/src/internal/QmitkUiLoader.cpp
@@ -1,65 +1,66 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) University College London (UCL).
 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 "QmitkUiLoader.h"
 #include "QmitkDataStorageComboBoxWithSelectNone.h"
 #include "mitkNodePredicateDataType.h"
 #include "mitkNodePredicateOr.h"
+#include "mitkImage.h"
 
 //-----------------------------------------------------------------------------
 QmitkUiLoader::QmitkUiLoader(const mitk::DataStorage* dataStorage, QObject *parent)
   : ctkCmdLineModuleQtUiLoader(parent)
 , m_DataStorage(dataStorage)
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 QmitkUiLoader::~QmitkUiLoader()
 {
 
 }
 
 
 //-----------------------------------------------------------------------------
 QStringList QmitkUiLoader::availableWidgets () const
 {
   QStringList availableWidgets = ctkCmdLineModuleQtUiLoader::availableWidgets();
   availableWidgets << "QmitkDataStorageComboBoxWithSelectNone";
   return availableWidgets;
 }
 
 
 //-----------------------------------------------------------------------------
 QWidget* QmitkUiLoader::createWidget(const QString& className, QWidget* parent, const QString& name)
 {
   QWidget* widget = NULL;
   if (className == "QmitkDataStorageComboBoxWithSelectNone")
   {
     QmitkDataStorageComboBoxWithSelectNone* comboBox = new QmitkDataStorageComboBoxWithSelectNone(parent);
     comboBox->setObjectName(name);
     comboBox->SetAutoSelectNewItems(false);
     comboBox->SetPredicate(mitk::TNodePredicateDataType< mitk::Image >::New());
     comboBox->SetDataStorage(const_cast<mitk::DataStorage*>(m_DataStorage));
     comboBox->setCurrentIndex(0);
     widget = comboBox;
   }
   else
   {
     widget = ctkCmdLineModuleQtUiLoader::createWidget(className, parent, name);
   }
   return widget;
 }
diff --git a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
index 754f7c8d16..57ec40acb6 100644
--- a/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
+++ b/Plugins/org.mitk.gui.qt.dicom/src/internal/DicomEventHandler.cpp
@@ -1,98 +1,98 @@
 /*===================================================================
 
 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 "mitkPluginActivator.h"
 #include "DicomEventHandler.h"
 #include <service/event/ctkEventConstants.h>
 #include <ctkDictionary.h>
 #include <mitkLogMacros.h>
 #include <mitkDicomSeriesReader.h>
 #include <mitkDataNode.h>
 #include <mitkIDataStorageService.h>
 #include <service/event/ctkEventAdmin.h>
 #include <ctkServiceReference.h>
 #include <mitkRenderingManager.h>
 #include <QVector>
-
+#include "mitkImage.h"
 
 DicomEventHandler::DicomEventHandler()
 {
 }
 
 DicomEventHandler::~DicomEventHandler()
 {
 }
 
 void DicomEventHandler::OnSignalAddSeriesToDataManager(const ctkEvent& ctkEvent)
 {
     QStringList listOfFilesForSeries;
     mitk::DicomSeriesReader::StringContainer seriesToLoad;
 
     listOfFilesForSeries = ctkEvent.getProperty("FilesForSeries").toStringList();
 
     if (!listOfFilesForSeries.isEmpty()){
 
         QStringListIterator it(listOfFilesForSeries);
 
         while (it.hasNext())
         {
             seriesToLoad.push_back(it.next().toStdString());
         }
 
 
         mitk::DataNode::Pointer node = mitk::DicomSeriesReader::LoadDicomSeries(seriesToLoad);
         if (node.IsNull())
         {
             MITK_ERROR << "Error loading series: " << ctkEvent.getProperty("SeriesName").toString().toStdString()
                 << " id: " <<ctkEvent.getProperty("SeriesUID").toString().toStdString();
         }
         else
         {
             //Get Reference for default data storage.
             ctkServiceReference serviceReference =mitk::PluginActivator::getContext()->getServiceReference<mitk::IDataStorageService>();
             mitk::IDataStorageService* storageService = mitk::PluginActivator::getContext()->getService<mitk::IDataStorageService>(serviceReference);
             mitk::DataStorage* dataStorage = storageService->GetDefaultDataStorage().GetPointer()->GetDataStorage();
 
             dataStorage->Add(node);
 
             // Initialize the RenderWindow
             mitk::TimeGeometry::Pointer geometry = dataStorage->ComputeBoundingGeometry3D(dataStorage->GetAll());
             mitk::RenderingManager::GetInstance()->InitializeViews(geometry);
         }
     }
     else
     {
         MITK_INFO << "There are no files for the current series";
     }
 }
 
 void DicomEventHandler::OnSignalRemoveSeriesFromStorage(const ctkEvent& ctkEvent)
 {
 }
 
 void DicomEventHandler::SubscribeSlots()
 {
     ctkServiceReference ref = mitk::PluginActivator::getContext()->getServiceReference<ctkEventAdmin>();
     if (ref)
     {
         ctkEventAdmin* eventAdmin = mitk::PluginActivator::getContext()->getService<ctkEventAdmin>(ref);
         ctkDictionary properties;
         properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/ADD";
         eventAdmin->subscribeSlot(this, SLOT(OnSignalAddSeriesToDataManager(ctkEvent)), properties);
         properties[ctkEventConstants::EVENT_TOPIC] = "org/mitk/gui/qt/dicom/DELETED";
         eventAdmin->subscribeSlot(this, SLOT(OnSignalRemoveSeriesFromStorage(ctkEvent)), properties);
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.h
index 3787ea9b1a..52395255f1 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkDwiSoftwarePhantomView.h
@@ -1,89 +1,90 @@
 /*===================================================================
 
 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 <QmitkFunctionality.h>
 #include "ui_QmitkDwiSoftwarePhantomViewControls.h"
+#include <itkImage.h>
 
 /*!
 \brief View for diffusion software phantom generation using binary ROIs.
 
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 
 class QmitkDwiSoftwarePhantomView : public QmitkFunctionality
 {
 
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkDwiSoftwarePhantomView();
   virtual ~QmitkDwiSoftwarePhantomView();
 
   virtual void CreateQtPartControl(QWidget *parent);
 
   virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
   virtual void StdMultiWidgetNotAvailable();
 
   typedef itk::Image<unsigned char, 3>  ItkUcharImgType;
   typedef itk::Image<float, 3>          ItkFloatImgType;
   typedef itk::Vector<double,3>         GradientType;
   typedef std::vector<GradientType>     GradientListType;
 
 
   protected slots:
 
   void GeneratePhantom();                   ///< Start image generation
   void OnSimulateBaselineToggle(int state); ///< change from SNR to noise variance and vice versa
 
 protected:
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
   /** Generate gradient directions distributed on half sphere (suboptimal distribution but arbitrary number of gradients) **/
   GradientListType GenerateHalfShell(int NPoints);
 
   /** Generate gradient directions (n-fold icosaedron tesselation) **/
   template<int ndirs> std::vector<itk::Vector<double,3> > MakeGradientList();
 
   /** Update button activity etc. depending on current datamanager selection **/
   void UpdateGui();
 
   Ui::QmitkDwiSoftwarePhantomViewControls* m_Controls;
   QmitkStdMultiWidget* m_MultiWidget;
 
   std::vector< mitk::DataNode::Pointer >    m_SignalRegionNodes;    ///< contains binary signal region nodes
   std::vector< ItkUcharImgType::Pointer >   m_SignalRegions;        ///< contains binary signal region images
 
   /** List of gui elements generated dynamically depending on the number of selected signal regions **/
   std::vector< QLabel* >            m_Labels;
   std::vector< QDoubleSpinBox* >    m_SpinFa;
   std::vector< QDoubleSpinBox* >    m_SpinAdc;
   std::vector< QDoubleSpinBox* >    m_SpinX;
   std::vector< QDoubleSpinBox* >    m_SpinY;
   std::vector< QDoubleSpinBox* >    m_SpinZ;
   std::vector< QDoubleSpinBox* >    m_SpinWeight;
 
  };
 
 
 
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp
index 82b690a657..0632133f09 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkFieldmapGeneratorView.cpp
@@ -1,298 +1,299 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK
 #include "QmitkFieldmapGeneratorView.h"
 #include <QmitkStdMultiWidget.h>
 #include <QmitkDataStorageComboBox.h>
 #include <mitkNodePredicateDataType.h>
 #include <itkFieldmapGeneratorFilter.h>
+#include <mitkImage.h>
 
 const std::string QmitkFieldmapGeneratorView::VIEW_ID = "org.mitk.views.fieldmapgenerator";
 
 QmitkFieldmapGeneratorView::QmitkFieldmapGeneratorView()
     : QmitkFunctionality()
     , m_Controls( 0 )
     , m_MultiWidget( NULL )
 {
 
 }
 
 QmitkFieldmapGeneratorView::~QmitkFieldmapGeneratorView()
 {
 
 }
 
 void QmitkFieldmapGeneratorView::CreateQtPartControl( QWidget *parent )
 {
     // build up qt view, unless already done
     if ( !m_Controls )
     {
         // create GUI widgets from the Qt Designer's .ui file
         m_Controls = new Ui::QmitkFieldmapGeneratorViewControls;
         m_Controls->setupUi( parent );
 
         m_Controls->m_SelectedImageBox->SetDataStorage(this->GetDataStorage());
         mitk::TNodePredicateDataType<mitk::Image>::Pointer isMitkImage = mitk::TNodePredicateDataType<mitk::Image>::New();
         m_Controls->m_SelectedImageBox->SetPredicate(isMitkImage);
 
         connect((QObject*) m_Controls->m_GenerateFieldmap, SIGNAL(clicked()), (QObject*) this, SLOT(GenerateFieldmap()));
         connect((QObject*) m_Controls->m_PlaceFieldSource, SIGNAL(clicked()), (QObject*) this, SLOT(PlaceFieldSource()));
         connect((QObject*) m_Controls->m_SourceVarianceBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnVarianceChanged(double)));
         connect((QObject*) m_Controls->m_SourceHeightBox, SIGNAL(valueChanged(double)), (QObject*) this, SLOT(OnHeightChanged(double)));
 
     }
 }
 
 void QmitkFieldmapGeneratorView::OnVarianceChanged(double value)
 {
     if (m_SelectedSource.IsNotNull())
     {
         m_SelectedSource->SetProperty("pointsize", mitk::FloatProperty::New(value));
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkFieldmapGeneratorView::OnHeightChanged(double value)
 {
     if (m_SelectedSource.IsNotNull())
     {
         m_SelectedSource->SetProperty("color", mitk::ColorProperty::New(0, 0, value/100.0));
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkFieldmapGeneratorView::PlaceFieldSource()
 {
     if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull() || !m_MultiWidget)
     {
         m_Controls->m_WorldPosLabel->setText("-");
         m_Controls->m_IndexLabel->setText("-");
         return;
     }
 
     mitk::Point3D index;
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
     mitk::Geometry3D* geom = img->GetGeometry();
 
     if ( geom->IsInside(m_WorldPoint) )
     {
         img->GetGeometry()->WorldToIndex(m_WorldPoint, index);
         mitk::PointSet::Pointer pointSet = mitk::PointSet::New();
         pointSet->InsertPoint(0, m_WorldPoint);
 
 
         mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_Controls->m_SelectedImageBox->GetSelectedNode());
 
         mitk::DataNode::Pointer node = mitk::DataNode::New();
         node->SetData(pointSet);
         QString name = QString("FieldSource_%1").arg(children->size());
         node->SetName(name.toStdString());
         node->SetVisibility(true);
 
         float minSpacing;
         if(geom->GetSpacing()[0]<geom->GetSpacing()[1] && geom->GetSpacing()[0]<geom->GetSpacing()[2])
             minSpacing = geom->GetSpacing()[0];
         else if (geom->GetSpacing()[1] < geom->GetSpacing()[2])
             minSpacing = geom->GetSpacing()[1];
         else
             minSpacing = geom->GetSpacing()[2];
 
         node->SetProperty("pointsize", mitk::FloatProperty::New(minSpacing*5));
         node->SetProperty("color", mitk::ColorProperty::New(0, 0, 1));
 
         GetDataStorage()->Add(node, m_Controls->m_SelectedImageBox->GetSelectedNode());
         mitk::RenderingManager::GetInstance()->RequestUpdateAll();
     }
 }
 
 void QmitkFieldmapGeneratorView::GenerateFieldmap()
 {
     if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull())
         return;
 
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
     mitk::Geometry3D* geom = img->GetGeometry();
 
     typedef itk::Image< double, 3 > FieldMapType;
     itk::Vector<double>                 spacing;              ///< output image spacing
     mitk::Point3D                       origin;               ///< output image origin
     itk::FieldmapGeneratorFilter< FieldMapType >::MatrixType                directionMatrix;      ///< output image rotation
     itk::FieldmapGeneratorFilter< FieldMapType >::OutputImageRegionType     imageRegion;          ///< output image size
 
     spacing = geom->GetSpacing();
     origin = geom->GetOrigin();
     imageRegion.SetSize(0, img->GetDimension(0));
     imageRegion.SetSize(1, img->GetDimension(1));
     imageRegion.SetSize(2, img->GetDimension(2));
     for (int r=0; r<3; r++)
         for (int c=0; c<3; c++)
             directionMatrix[r][c]=geom->GetMatrixColumn(c)[r]/spacing[c];
 
     std::vector< double >               variances;
     std::vector< double >               heights;
     std::vector< mitk::Point3D >        worldPositions;
 
     mitk::DataStorage::SetOfObjects::ConstPointer children = GetDataStorage()->GetDerivations(m_Controls->m_SelectedImageBox->GetSelectedNode());
     for( mitk::DataStorage::SetOfObjects::const_iterator it = children->begin(); it != children->end(); ++it )
         if(dynamic_cast<mitk::PointSet*>((*it)->GetData()))
         {
             float var = 0; (*it)->GetPropertyValue("pointsize", var); variances.push_back(var);
             float color[3]; (*it)->GetColor(color); heights.push_back(color[2]*100);
             mitk::PointSet* ps = dynamic_cast<mitk::PointSet*>((*it)->GetData());
             mitk::Point3D point;
             ps->GetPointIfExists(0, &point);
             worldPositions.push_back(point);
         }
 
     vnl_vector_fixed< double, 3 > gradient, offset;
     gradient[0] = m_Controls->m_xGradientBox->value();
     gradient[1] = m_Controls->m_yGradientBox->value();
     gradient[2] = m_Controls->m_zGradientBox->value();
     offset[0] = m_Controls->m_xOffsetBox->value();
     offset[1] = m_Controls->m_yOffsetBox->value();
     offset[2] = m_Controls->m_zOffsetBox->value();
 
     itk::FieldmapGeneratorFilter< FieldMapType >::Pointer filter = itk::FieldmapGeneratorFilter< FieldMapType >::New();
     filter->SetHeights(heights);
     filter->SetVariances(variances);
     filter->SetWorldPositions(worldPositions);
     filter->SetSpacing(spacing);
     filter->SetOrigin(origin);
     filter->SetDirectionMatrix(directionMatrix);
     filter->SetImageRegion(imageRegion);
     filter->SetGradient(gradient);
     filter->SetOffset(offset);
     filter->Update();
 
     mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
     mitk::Image::Pointer image = mitk::Image::New();
     image->InitializeByItk(filter->GetOutput(0));
     image->SetVolume(filter->GetOutput(0)->GetBufferPointer());
     resultNode->SetData( image );
     resultNode->SetName(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetName()+"_Fieldmap");
     GetDataStorage()->Add(resultNode);
 }
 
 void QmitkFieldmapGeneratorView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
     m_MultiWidget = &stdMultiWidget;
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
         command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
         m_SliceObserverTag1 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
         command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
         m_SliceObserverTag2 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
         itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
         command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
         m_SliceObserverTag3 = slicer->AddObserver( mitk::SliceNavigationController::GeometrySliceEvent(NULL, 0), command );
     }
 }
 
 void QmitkFieldmapGeneratorView::StdMultiWidgetNotAvailable()
 {
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget1->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag1 );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget2->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag2 );
     }
 
     {
         mitk::SliceNavigationController* slicer = m_MultiWidget->mitkWidget3->GetSliceNavigationController();
         slicer->RemoveObserver( m_SliceObserverTag3 );
     }
 
     m_MultiWidget = NULL;
 }
 
 void QmitkFieldmapGeneratorView::OnSelectionChanged( std::vector<mitk::DataNode*> nodes )
 {
     if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNotNull())
         m_Controls->m_SelectedImageBox->GetSelectedNode()->RemoveObserver( m_PropertyObserverTag );
 
     m_Controls->m_InputData->setTitle("Please Select Reference Image");
     m_SelectedSource = NULL;
 
     // iterate selection
     for( std::vector<mitk::DataNode*>::iterator it = nodes.begin(); it != nodes.end(); ++it )
     {
         mitk::DataNode::Pointer node = *it;
 
         if ( node.IsNotNull() && (dynamic_cast<mitk::PointSet*>(node->GetData())) )
         {
             m_Controls->m_SourceNameLabel->setText(node->GetName().c_str());
             m_SelectedSource = node;
             float variance = 0; node->GetPropertyValue("pointsize", variance);
             m_Controls->m_SourceVarianceBox->setValue(variance);
 
             float color[3]; node->GetColor(color);
             m_Controls->m_SourceHeightBox->setValue(color[2]*100);
         }
     }
 
     if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNotNull())
     {
         itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::Pointer command = itk::ReceptorMemberCommand<QmitkFieldmapGeneratorView>::New();
         command->SetCallbackFunction( this, &QmitkFieldmapGeneratorView::OnSliceChanged );
         m_PropertyObserverTag = m_Controls->m_SelectedImageBox->GetSelectedNode()->AddObserver( itk::ModifiedEvent(), command );
 
         m_Controls->m_InputData->setTitle("Reference Image");
     }
 }
 
 void QmitkFieldmapGeneratorView::OnSliceChanged(const itk::EventObject& /*e*/)
 {
     if (m_Controls->m_SelectedImageBox->GetSelectedNode().IsNull() || !m_MultiWidget)
     {
         m_Controls->m_WorldPosLabel->setText("-");
         m_Controls->m_IndexLabel->setText("-");
         return;
     }
 
     m_WorldPoint = m_MultiWidget->GetCrossPosition();
     QString posSting = QString::number(m_WorldPoint[0]); posSting += ", "; posSting += QString::number(m_WorldPoint[1]); posSting += ", "; posSting += QString::number(m_WorldPoint[2]);
     m_Controls->m_WorldPosLabel->setText(posSting.toStdString().c_str());
 
     mitk::Point3D index;
     mitk::Image::Pointer img = dynamic_cast<mitk::Image*>(m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData());
 
     if ( m_Controls->m_SelectedImageBox->GetSelectedNode()->GetData()->GetGeometry()->IsInside(m_WorldPoint) )
     {
         img->GetGeometry()->WorldToIndex(m_WorldPoint, index);
         posSting = QString::number(index[0]); posSting += ", "; posSting += QString::number(index[1]); posSting += ", "; posSting += QString::number(index[2]);
          m_Controls->m_IndexLabel->setText(posSting.toStdString().c_str());
     }
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
index c6df504317..77066e4499 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.cpp
@@ -1,493 +1,494 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Qmitk
 #include "QmitkTbssSkeletonizationView.h"
 
 
 #include <itkSkeletonizationFilter.h>
 #include <itkProjectionFilter.h>
 #include <itkDistanceMapFilter.h>
 #include <itkBinaryThresholdImageFilter.h>
 
 #include <itkImageFileReader.h>
 
 // mitk
 #include <mitkImagePixelReadAccessor.h>
+#include <mitkImage.h>
 
 // Qt
 #include <QInputDialog>
 #include <QMessageBox>
 
 //vtk
 #include <vtkLinearTransform.h>
 #include <vtkMatrix4x4.h>
 
 // Boost
 #include <boost/lexical_cast.hpp>
 
 
 
 const std::string QmitkTbssSkeletonizationView::VIEW_ID = "org.mitk.views.tbssskeletonization";
 
 using namespace berry;
 
 
 QmitkTbssSkeletonizationView::QmitkTbssSkeletonizationView()
   : QmitkFunctionality()
   , m_Controls( 0 )
   , m_MultiWidget( NULL )
 {
 
 }
 
 QmitkTbssSkeletonizationView::~QmitkTbssSkeletonizationView()
 {
 }
 
 void QmitkTbssSkeletonizationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
 
 
   //datamanager selection changed
   if (!this->IsActivated())
     return;
 
   bool found3dImage = false;
   bool found4dImage = false;
 
   this->m_Controls->m_TubularName->setText(QString("Tubular Structure Mask: "));
   this->m_Controls->m_TubularName->setEnabled(false);
   this->m_Controls->m_MeanLabel->setText(QString("Mean: "));
   this->m_Controls->m_MeanLabel->setEnabled(false);
   this->m_Controls->m_PatientDataLabel->setText(QString("Patient Data: "));
   this->m_Controls->m_PatientDataLabel->setEnabled(false);
 
 
   // iterate selection
   for ( int i=0; i<nodes.size(); i++ )
   {
 
 
     // only look at interesting types from valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
     std::string name = "";
     nodes[i]->GetStringProperty("name", name);
 
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
 
         if(img->GetDimension() == 3)
         {
           bool isBinary(false);
           nodes[i]->GetBoolProperty("binary", isBinary);
 
 
           if(isBinary)
           {
             QString label("Tubular Structure Mask: ");
             label.append(QString(name.c_str()));
             this->m_Controls->m_TubularName->setText(label);
             this->m_Controls->m_TubularName->setEnabled(true);
           }
           else
           {
             found3dImage = true;
             QString label("Mean: ");
             label.append(QString(name.c_str()));
             this->m_Controls->m_MeanLabel->setText(label);
             this->m_Controls->m_MeanLabel->setEnabled(true);
           }
         }
         else if(img->GetDimension() == 4)
         {
           found4dImage = true;
           QString label("Patient Data: ");
           label.append(QString(name.c_str()));
           this->m_Controls->m_PatientDataLabel->setText(label);
           this->m_Controls->m_PatientDataLabel->setEnabled(true);
         }
       }
     }
 
   }
 
   this->m_Controls->m_Skeletonize->setEnabled(found3dImage);
   this->m_Controls->m_Project->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputMask->setEnabled(found3dImage && found4dImage);
   this->m_Controls->m_OutputDistanceMap->setEnabled(found3dImage && found4dImage);
 
 }
 
 
 
 void QmitkTbssSkeletonizationView::CreateQtPartControl( QWidget *parent )
 {
   // build up qt view, unless already done
   if ( !m_Controls )
   {
     // create GUI widgets from the Qt Designer's .ui file
     m_Controls = new Ui::QmitkTbssSkeletonizationViewControls;
     m_Controls->setupUi( parent );
     this->CreateConnections();
   }
 
 }
 
 void QmitkTbssSkeletonizationView::Activated()
 {
   QmitkFunctionality::Activated();
 }
 
 void QmitkTbssSkeletonizationView::Deactivated()
 {
   QmitkFunctionality::Deactivated();
 }
 
 void QmitkTbssSkeletonizationView::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->m_Skeletonize), SIGNAL(clicked()), this, SLOT(Skeletonize() ));
     connect( (QObject*)(m_Controls->m_Project), SIGNAL(clicked()), this, SLOT(Project() ));
   }
 }
 
 
 
 void QmitkTbssSkeletonizationView::StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget)
 {
   m_MultiWidget = &stdMultiWidget;
 }
 
 
 void QmitkTbssSkeletonizationView::StdMultiWidgetNotAvailable()
 {
   m_MultiWidget = NULL;
 }
 
 
 void QmitkTbssSkeletonizationView::Skeletonize()
 {
 
 
 
 
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   std::string name = "";
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     // process only on valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
 
         bool isBinary(false);
         nodes[i]->GetBoolProperty("binary", isBinary);
 
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3 && !isBinary)
         {
           meanImage = img;
           name = nodes[i]->GetName();
         }
       }
     }
   }
 
 
   // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   name += "_skeleton";
   AddToDataStorage(mitkOutput, name);
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::Project()
 {
 
   typedef itk::SkeletonizationFilter<FloatImageType, FloatImageType> SkeletonisationFilterType;
   typedef itk::ProjectionFilter ProjectionFilterType;
   typedef itk::DistanceMapFilter<FloatImageType, FloatImageType> DistanceMapFilterType;
 
   SkeletonisationFilterType::Pointer skeletonizer = SkeletonisationFilterType::New();
 
 
 
   std::vector<mitk::DataNode*> nodes = this->GetDataManagerSelection();
 
 
   mitk::Image::Pointer meanImage = mitk::Image::New();
   mitk::Image::Pointer subjects = mitk::Image::New();
   mitk::Image::Pointer tubular = mitk::Image::New();
 
   for ( int i=0; i<nodes.size(); i++ )
   {
     // process only on valid nodes
     mitk::BaseData* nodeData = nodes[i]->GetData();
 
     if(nodeData)
     {
       if(QString("Image").compare(nodeData->GetNameOfClass())==0)
       {
         mitk::Image* img = static_cast<mitk::Image*>(nodeData);
         if(img->GetDimension() == 3)
         {
 
           bool isBinary(false);
           nodes[i]->GetBoolProperty("binary", isBinary);
 
 
           if(isBinary)
           {
             tubular = img;
           }
           else
           {
             meanImage = img;
           }
         }
 
         else if(img->GetDimension() == 4)
         {
           subjects = img;
         }
       }
     }
 
   }
 
   Float4DImageType::Pointer allFA = ConvertToItk(subjects);
 
     // Calculate skeleton
   FloatImageType::Pointer itkImg = FloatImageType::New();
   mitk::CastToItkImage(meanImage, itkImg);
   skeletonizer->SetInput(itkImg);
   skeletonizer->Update();
 
 
   FloatImageType::Pointer output = skeletonizer->GetOutput();
   mitk::Image::Pointer mitkOutput = mitk::Image::New();
   mitk::CastToMitkImage(output, mitkOutput);
   AddToDataStorage(mitkOutput, "mean_FA_skeletonised");
 
 
 
   // Retrieve direction image needed later by the projection filter
   DirectionImageType::Pointer directionImg = skeletonizer->GetVectorImage();
 
 
   // Calculate distance image
   DistanceMapFilterType::Pointer distanceMapFilter = DistanceMapFilterType::New();
   distanceMapFilter->SetInput(output);
   distanceMapFilter->Update();
   FloatImageType::Pointer distanceMap = distanceMapFilter->GetOutput();
 
   if(m_Controls->m_OutputDistanceMap->isChecked())
   {
     mitk::Image::Pointer mitkDistance = mitk::Image::New();
     mitk::CastToMitkImage(distanceMap, mitkDistance);
     AddToDataStorage(mitkDistance, "distance map");
   }
 
   // Do projection
 
   // Ask a threshold to create a skeleton mask
   double threshold = -1.0;
   while(threshold == -1.0)
   {
     threshold = QInputDialog::getDouble(m_Controls->m_Skeletonize, tr("Specify the FA threshold"),
                                         tr("Threshold:"), QLineEdit::Normal,
                                         0.2);
 
     if(threshold < 0.0 || threshold > 1.0)
     {
       QMessageBox msgBox;
       msgBox.setText("Please choose a value between 0 and 1");
       msgBox.exec();
       threshold = -1.0;
     }
   }
 
   typedef itk::BinaryThresholdImageFilter<FloatImageType, CharImageType> ThresholdFilterType;
   ThresholdFilterType::Pointer thresholder = ThresholdFilterType::New();
   thresholder->SetInput(output);
   thresholder->SetLowerThreshold(threshold);
   thresholder->SetUpperThreshold(std::numeric_limits<float>::max());
   thresholder->SetOutsideValue(0);
   thresholder->SetInsideValue(1);
   thresholder->Update();
 
 
   CharImageType::Pointer thresholdedImg = thresholder->GetOutput();
 
 
   if(m_Controls->m_OutputMask->isChecked())
   {
     mitk::Image::Pointer mitkThresholded = mitk::Image::New();
     mitk::CastToMitkImage(thresholdedImg, mitkThresholded);
     std::string maskName = "skeleton_mask_at_" + boost::lexical_cast<std::string>(threshold);
     AddToDataStorage(mitkThresholded, maskName);
   }
 
 
 
 
   CharImageType::Pointer itkTubular = CharImageType::New();
   mitk::CastToItkImage(tubular, itkTubular);
 
 
   ProjectionFilterType::Pointer projectionFilter = ProjectionFilterType::New();
   projectionFilter->SetDistanceMap(distanceMap);
   projectionFilter->SetDirections(directionImg);
   projectionFilter->SetAllFA(allFA);
   projectionFilter->SetTube(itkTubular);
   projectionFilter->SetSkeleton(thresholdedImg);
   projectionFilter->Project();
 
   Float4DImageType::Pointer projected = projectionFilter->GetProjections();
 
   mitk::Image::Pointer mitkProjections = mitk::Image::New();
   mitk::CastToMitkImage(projected, mitkProjections);
 
   AddToDataStorage(mitkProjections, "all_FA_projected");
 
 
 
 }
 
 void QmitkTbssSkeletonizationView::AddToDataStorage(mitk::Image* img, std::string name)
 {
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty( "name", mitk::StringProperty::New(name) );
   result->SetData( img );
 
   // add new image to data storage and set as active to ease further processing
   GetDefaultDataStorage()->Add( result );
 }
 
 
-Float4DImageType::Pointer QmitkTbssSkeletonizationView::ConvertToItk(mitk::Image::Pointer image)
+Float4DImageType::Pointer QmitkTbssSkeletonizationView::ConvertToItk(itk::SmartPointer<mitk::Image> image)
 {
 
   Float4DImageType::Pointer output = Float4DImageType::New();
 
   mitk::Geometry3D* geo = image->GetGeometry();
   mitk::Vector3D mitkSpacing = geo->GetSpacing();
   mitk::Point3D mitkOrigin = geo->GetOrigin();
 
   Float4DImageType::SpacingType spacing;
   spacing[0] = mitkSpacing[0];
   spacing[1] = mitkSpacing[1];
   spacing[2] = mitkSpacing[2];
   spacing[3] = 1.0; // todo: check if spacing has length 4
 
   Float4DImageType::PointType origin;
   origin[0] = mitkOrigin[0];
   origin[1] = mitkOrigin[1];
   origin[2] = mitkOrigin[2];
   origin[3] = 0;
 
   Float4DImageType::SizeType size;
   size[0] = image->GetDimension(0);
   size[1] = image->GetDimension(1);
   size[2] = image->GetDimension(2);
   size[3] = image->GetDimension(3);
 
   Float4DImageType::DirectionType dir;
   vtkLinearTransform* lin = geo->GetVtkTransform();
   vtkMatrix4x4 *m = lin->GetMatrix();
 
   dir.Fill(0.0);
   for(int x=0; x<3; x++)
   {
     for(int y=0; y<3; y++)
     {
       dir[x][y] = m->GetElement(x,y);
     }
   }
   dir[3][3] = 1;
 
 
 
   output->SetSpacing(spacing);
   output->SetOrigin(origin);
   output->SetRegions(size);
   output->SetDirection(dir);
   output->Allocate();
 
 
   if(image->GetDimension() == 4)
   {
     int timesteps = image->GetDimension(3);
 
     try{
       // REPLACE THIS METHODE()ConvertToItk) WITH mitk::CastToItk
 
       // iterate through the subjects and copy data to output
       for(int t=0; t<timesteps; t++)
       {
         for(int x=0; x<image->GetDimension(0); x++)
         {
           for(int y=0; y<image->GetDimension(1); y++)
           {
             for(int z=0; z<image->GetDimension(2); z++)
             {
               itk::Index<3> ix = {x, y, z};
               itk::Index<4> ix4 = {x, y, z, t};
 
               output->SetPixel(ix4, image->GetPixelValueByIndex(ix, t));
 
             }
           }
         }
       }
     }
     catch(std::exception & e)
     {
       MITK_INFO << e.what();
     }
 
   }
 
 
   return output;
 }
diff --git a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
index 683c7bdd1b..7321584b91 100644
--- a/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
+++ b/Plugins/org.mitk.gui.qt.diffusionimaging/src/internal/QmitkTbssSkeletonizationView.h
@@ -1,95 +1,99 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef QmitkTbssSkeletonizationView_h
 #define QmitkTbssSkeletonizationView_h
 
 
 #include <QmitkFunctionality.h>
 #include "ui_QmitkTbssSkeletonizationViewControls.h"
+#include "itkImage.h"
 
+namespace mitk {
+  class Image;
+}
 
 typedef itk::Image<float, 3> FloatImageType;
 typedef itk::Image<char, 3> CharImageType;
 typedef itk::Image<float, 4> Float4DImageType;
 
 typedef itk::CovariantVector<int,3> VectorType;
 typedef itk::Image<VectorType, 3> DirectionImageType;
 
 
 /*!
   * \brief Implementation of the core functionality of TBSS.
   * This plugin provides the core functionality of TBSS (see Smith et al., 2009. http://dx.doi.org/10.1016/j.neuroimage.2006.02.024)
   * It can skeletonize a mean FA image and calculate the projection of all individual subjects to this skeleton.
 */
 
 class QmitkTbssSkeletonizationView : public QmitkFunctionality
 {
 
   Q_OBJECT
 
   public:
 
     static const std::string VIEW_ID;
 
     QmitkTbssSkeletonizationView();
     virtual ~QmitkTbssSkeletonizationView();
 
     virtual void CreateQtPartControl(QWidget *parent);
 
     //Creation of the connections of main and control widget
     virtual void CreateConnections();
 
     virtual void StdMultiWidgetAvailable (QmitkStdMultiWidget &stdMultiWidget);
     virtual void StdMultiWidgetNotAvailable();
 
     /// \brief Called when the functionality is activated
     virtual void Activated();
 
     virtual void Deactivated();
 
 
   protected slots:
 
 
     /* \brief Perform skeletonization only */
     void Skeletonize();
 
     // Perform skeletonization and Projection of subject data to the skeleton
     void Project();
 
 
 
   protected:
 
     //brief called by QmitkFunctionality when DataManager's selection has changed
     virtual void OnSelectionChanged( std::vector<mitk::DataNode*> nodes );
 
     Ui::QmitkTbssSkeletonizationViewControls* m_Controls;
 
     QmitkStdMultiWidget* m_MultiWidget;
 
     void AddToDataStorage(mitk::Image* img, std::string name);
 
-    Float4DImageType::Pointer ConvertToItk(mitk::Image::Pointer image);
+    Float4DImageType::Pointer ConvertToItk(itk::SmartPointer<mitk::Image> image);
 
 
 };
 
 
 
 #endif // _QMITKTbssSkeletonizationVIEW_H_INCLUDED
 
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
index bef27189bd..4f1ac3fdec 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkMeasurementView.cpp
@@ -1,890 +1,891 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #define MEASUREMENT_DEBUG MITK_DEBUG("QmitkMeasurementView") << __LINE__ << ": "
 
 #include "QmitkMeasurementView.h"
 
 #include <QtGui>
 
 #include <mitkIPropertyFilters.h>
 #include <mitkPropertyFilter.h>
 #include <mitkVtkLayerController.h>
 #include <mitkWeakPointer.h>
 #include <mitkPlanarCircle.h>
 #include <mitkPlanarPolygon.h>
 #include <mitkPlanarAngle.h>
 #include <mitkPlanarRectangle.h>
 #include <mitkPlanarLine.h>
 #include <mitkPlanarCross.h>
 #include <mitkPlanarFourPointAngle.h>
 #include <mitkPlanarDoubleEllipse.h>
 #include <mitkPlanarFigureInteractor.h>
 #include <mitkPlaneGeometry.h>
 #include <mitkGlobalInteraction.h>
 #include <mitkILinkedRenderWindowPart.h>
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateProperty.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateNot.h>
 #include <QmitkRenderWindow.h>
+#include <mitkImage.h>
 
 #include "mitkPluginActivator.h"
 #include "usModuleRegistry.h"
 
 template <class T>
 static T* GetService()
 {
   ctkPluginContext* context = mitk::PluginActivator::GetContext();
   ctkServiceReference serviceRef = context->getServiceReference<T>();
 
   return serviceRef
     ? context->getService<T>(serviceRef)
     : NULL;
 }
 
 struct QmitkPlanarFigureData
 {
   QmitkPlanarFigureData()
     : m_Figure(0), m_EndPlacementObserverTag(0), m_SelectObserverTag(0), m_StartInteractionObserverTag(0), m_EndInteractionObserverTag(0)
   {
   }
 
   mitk::PlanarFigure* m_Figure;
   unsigned int m_EndPlacementObserverTag;
   unsigned int m_SelectObserverTag;
   unsigned int m_StartInteractionObserverTag;
   unsigned int m_EndInteractionObserverTag;
 };
 
 struct QmitkMeasurementViewData
 {
   QmitkMeasurementViewData()
     : m_LineCounter(0), m_PathCounter(0), m_AngleCounter(0),
     m_FourPointAngleCounter(0), m_EllipseCounter(0), m_DoubleEllipseCounter(0),
       m_RectangleCounter(0), m_PolygonCounter(0), m_UnintializedPlanarFigure(false)
   {
   }
 
   // internal vars
   unsigned int m_LineCounter;
   unsigned int m_PathCounter;
   unsigned int m_AngleCounter;
   unsigned int m_FourPointAngleCounter;
   unsigned int m_EllipseCounter;
   unsigned int m_DoubleEllipseCounter;
   unsigned int m_RectangleCounter;
   unsigned int m_PolygonCounter;
   QList<mitk::DataNode::Pointer> m_CurrentSelection;
   std::map<mitk::DataNode*, QmitkPlanarFigureData> m_DataNodeToPlanarFigureData;
   mitk::WeakPointer<mitk::DataNode> m_SelectedImageNode;
   bool m_UnintializedPlanarFigure;
 
   // WIDGETS
   QWidget* m_Parent;
   QLabel* m_SelectedImageLabel;
   QAction* m_DrawLine;
   QAction* m_DrawPath;
   QAction* m_DrawAngle;
   QAction* m_DrawFourPointAngle;
   QAction* m_DrawEllipse;
   QAction* m_DrawDoubleEllipse;
   QAction* m_DrawRectangle;
   QAction* m_DrawPolygon;
   QToolBar* m_DrawActionsToolBar;
   QActionGroup* m_DrawActionsGroup;
   QTextBrowser* m_SelectedPlanarFiguresText;
   QPushButton* m_CopyToClipboard;
   QGridLayout* m_Layout;
 };
 
 const std::string QmitkMeasurementView::VIEW_ID = "org.mitk.views.measurement";
 
 QmitkMeasurementView::QmitkMeasurementView()
   : d( new QmitkMeasurementViewData )
 {
 }
 QmitkMeasurementView::~QmitkMeasurementView()
 {
   this->RemoveAllInteractors();
   delete d;
 }
 void QmitkMeasurementView::CreateQtPartControl(QWidget* parent)
 {
   d->m_Parent = parent;
 
   // image label
   QLabel* selectedImageLabel = new QLabel("Reference Image: ");
   d->m_SelectedImageLabel = new QLabel;
   d->m_SelectedImageLabel->setStyleSheet("font-weight: bold;");
 
   d->m_DrawActionsToolBar = new QToolBar;
   d->m_DrawActionsGroup = new QActionGroup(this);
   d->m_DrawActionsGroup->setExclusive(true);
 
   //# add actions
   MEASUREMENT_DEBUG << "Draw Line";
   QAction* currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/line.png"), "Draw Line");
   currentAction->setCheckable(true);
   d->m_DrawLine = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Path";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/path.png"), "Draw Path");
   currentAction->setCheckable(true);
   d->m_DrawPath = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/angle.png"), "Draw Angle");
   currentAction->setCheckable(true);
   d->m_DrawAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Four Point Angle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/four-point-angle.png"), "Draw Four Point Angle");
   currentAction->setCheckable(true);
   d->m_DrawFourPointAngle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Circle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/circle.png"), "Draw Circle");
   currentAction->setCheckable(true);
   d->m_DrawEllipse = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Double Ellipse";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/doubleellipse.png"), "Draw Double Ellipse");
   currentAction->setCheckable(true);
   d->m_DrawDoubleEllipse = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Rectangle";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/rectangle.png"), "Draw Rectangle");
   currentAction->setCheckable(true);
   d->m_DrawRectangle = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   MEASUREMENT_DEBUG << "Draw Polygon";
   currentAction = d->m_DrawActionsToolBar->addAction(QIcon(":/measurement/polygon.png"), "Draw Polygon");
   currentAction->setCheckable(true);
   d->m_DrawPolygon = currentAction;
   d->m_DrawActionsToolBar->addAction(currentAction);
   d->m_DrawActionsGroup->addAction(currentAction);
 
   // planar figure details text
   d->m_SelectedPlanarFiguresText = new QTextBrowser;
 
   // copy to clipboard button
   d->m_CopyToClipboard = new QPushButton("Copy to Clipboard");
 
   d->m_Layout = new QGridLayout;
   d->m_Layout->addWidget(selectedImageLabel, 0, 0, 1, 1);
   d->m_Layout->addWidget(d->m_SelectedImageLabel, 0, 1, 1, 1);
   d->m_Layout->addWidget(d->m_DrawActionsToolBar, 1, 0, 1, 2);
   d->m_Layout->addWidget(d->m_SelectedPlanarFiguresText, 2, 0, 1, 2);
   d->m_Layout->addWidget(d->m_CopyToClipboard, 3, 0, 1, 2);
 
   d->m_Parent->setLayout(d->m_Layout);
 
   // create connections
   this->CreateConnections();
 
   // readd interactors and observers
   this->AddAllInteractors();
 }
 void QmitkMeasurementView::CreateConnections()
 {
   QObject::connect( d->m_DrawLine, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawLineTriggered(bool) ) );
   QObject::connect( d->m_DrawPath, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawPathTriggered(bool) ) );
   QObject::connect( d->m_DrawAngle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawFourPointAngle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawFourPointAngleTriggered(bool) ) );
   QObject::connect( d->m_DrawEllipse, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawEllipseTriggered(bool) ) );
   QObject::connect( d->m_DrawDoubleEllipse, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawDoubleEllipseTriggered(bool) ) );
   QObject::connect( d->m_DrawRectangle, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawRectangleTriggered(bool) ) );
   QObject::connect( d->m_DrawPolygon, SIGNAL( triggered(bool) ), this, SLOT( ActionDrawPolygonTriggered(bool) ) );
   QObject::connect( d->m_CopyToClipboard, SIGNAL( clicked(bool) ), this, SLOT( CopyToClipboard(bool) ) );
 }
 
 void QmitkMeasurementView::NodeAdded( const mitk::DataNode* node )
 {
   // add observer for selection in renderwindow
   mitk::PlanarFigure* figure = dynamic_cast<mitk::PlanarFigure*>(node->GetData());
   bool isPositionMarker (false);
   node->GetBoolProperty("isContourMarker", isPositionMarker);
   if( figure && !isPositionMarker )
   {
     MEASUREMENT_DEBUG << "figure added. will add interactor if needed.";
     mitk::PlanarFigureInteractor::Pointer figureInteractor
         = dynamic_cast<mitk::PlanarFigureInteractor*>(node->GetDataInteractor().GetPointer() );
 
     mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>( node );
     if(figureInteractor.IsNull())
     {
       figureInteractor = mitk::PlanarFigureInteractor::New();
       us::Module* planarFigureModule = us::ModuleRegistry::GetModule( "MitkPlanarFigure" );
       figureInteractor->LoadStateMachine("PlanarFigureInteraction.xml", planarFigureModule );
       figureInteractor->SetEventConfig( "PlanarFigureConfig.xml", planarFigureModule );
       figureInteractor->SetDataNode( nonConstNode );
       //      nonConstNode->SetBoolProperty( "planarfigure.isextendable", true );
     }
     else
     {
       // just to be sure that the interactor is not added twice
       //    mitk::GlobalInteraction::GetInstance()->RemoveInteractor(figureInteractor);
     }
 
     MEASUREMENT_DEBUG << "adding interactor to globalinteraction";
     //  mitk::GlobalInteraction::GetInstance()->AddInteractor(figureInteractor);
 
     MEASUREMENT_DEBUG << "will now add observers for planarfigure";
     QmitkPlanarFigureData data;
     data.m_Figure = figure;
 
     // add observer for event when figure has been placed
     typedef itk::SimpleMemberCommand< QmitkMeasurementView > SimpleCommandType;
     SimpleCommandType::Pointer initializationCommand = SimpleCommandType::New();
     initializationCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureInitialized );
     data.m_EndPlacementObserverTag = figure->AddObserver( mitk::EndPlacementPlanarFigureEvent(), initializationCommand );
 
     // add observer for event when figure is picked (selected)
     typedef itk::MemberCommand< QmitkMeasurementView > MemberCommandType;
     MemberCommandType::Pointer selectCommand = MemberCommandType::New();
     selectCommand->SetCallbackFunction( this, &QmitkMeasurementView::PlanarFigureSelected );
     data.m_SelectObserverTag = figure->AddObserver( mitk::SelectPlanarFigureEvent(), selectCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer startInteractionCommand = SimpleCommandType::New();
     startInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::DisableCrosshairNavigation);
     data.m_StartInteractionObserverTag = figure->AddObserver( mitk::StartInteractionPlanarFigureEvent(), startInteractionCommand );
 
     // add observer for event when interaction with figure starts
     SimpleCommandType::Pointer endInteractionCommand = SimpleCommandType::New();
     endInteractionCommand->SetCallbackFunction( this, &QmitkMeasurementView::EnableCrosshairNavigation);
     data.m_EndInteractionObserverTag = figure->AddObserver( mitk::EndInteractionPlanarFigureEvent(), endInteractionCommand );
 
     // adding to the map of tracked planarfigures
     d->m_DataNodeToPlanarFigureData[nonConstNode] = data;
   }
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::NodeChanged(const mitk::DataNode* node)
 {
   // DETERMINE IF WE HAVE TO RENEW OUR DETAILS TEXT (ANY NODE CHANGED IN OUR SELECTION?)
   bool renewText = false;
   for( int i=0; i < d->m_CurrentSelection.size(); ++i )
   {
     if( node == d->m_CurrentSelection.at(i) )
     {
       renewText = true;
       break;
     }
   }
 
   if(renewText)
   {
     MEASUREMENT_DEBUG << "Selected nodes changed. Refreshing text.";
     this->UpdateMeasurementText();
   }
 
   this->CheckForTopMostVisibleImage();
 }
 
 void QmitkMeasurementView::CheckForTopMostVisibleImage(mitk::DataNode* _NodeToNeglect)
 {
   d->m_SelectedImageNode = this->DetectTopMostVisibleImage().GetPointer();
   if( d->m_SelectedImageNode.GetPointer() == _NodeToNeglect )
     d->m_SelectedImageNode = 0;
 
   if( d->m_SelectedImageNode.IsNotNull() && d->m_UnintializedPlanarFigure == false )
   {
     MEASUREMENT_DEBUG << "Reference image found";
     d->m_SelectedImageLabel->setText( QString::fromStdString( d->m_SelectedImageNode->GetName() ) );
     d->m_DrawActionsToolBar->setEnabled(true);
     MEASUREMENT_DEBUG << "Updating Measurement text";
   }
   else
   {
     MEASUREMENT_DEBUG << "No reference image available. Will disable actions for creating new planarfigures";
     if( d->m_UnintializedPlanarFigure == false )
       d->m_SelectedImageLabel->setText( "No visible image available." );
 
     d->m_DrawActionsToolBar->setEnabled(false);
   }
 }
 
 void QmitkMeasurementView::NodeRemoved(const mitk::DataNode* node)
 {
   MEASUREMENT_DEBUG << "node removed from data storage";
 
   mitk::DataNode* nonConstNode = const_cast<mitk::DataNode*>(node);
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.find(nonConstNode);
 
   bool isFigureFinished = false;
   bool isPlaced = false;
 
   if( it != d->m_DataNodeToPlanarFigureData.end() )
   {
     QmitkPlanarFigureData& data = it->second;
     // remove observers
     data.m_Figure->RemoveObserver( data.m_EndPlacementObserverTag );
     data.m_Figure->RemoveObserver( data.m_SelectObserverTag );
     data.m_Figure->RemoveObserver( data.m_StartInteractionObserverTag );
     data.m_Figure->RemoveObserver( data.m_EndInteractionObserverTag );
 
     MEASUREMENT_DEBUG << "removing from the list of tracked planar figures";
 
     isFigureFinished = data.m_Figure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
     if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
       PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
     }
     d->m_DataNodeToPlanarFigureData.erase( it );
   }
 
   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
   mitk::DataStorage::SetOfObjects::ConstPointer nodes =
       GetDataStorage()->GetDerivations(node,isPlanarFigure);
 
   for (unsigned int x = 0; x < nodes->size(); x++)
   {
     mitk::PlanarFigure* planarFigure  = dynamic_cast<mitk::PlanarFigure*>  (nodes->at(x)->GetData());
     if (planarFigure != NULL) {
 
       isFigureFinished = planarFigure->GetPropertyList()->GetBoolProperty("initiallyplaced",isPlaced);
       if (!isFigureFinished) { // if the property does not yet exist or is false, drop the datanode
         GetDataStorage()->Remove(nodes->at(x));
         if( !d->m_DataNodeToPlanarFigureData.empty() )
         {
           std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it2 =
               d->m_DataNodeToPlanarFigureData.find(nodes->at(x));
           //check if returned it2 valid
           if( it2 != d->m_DataNodeToPlanarFigureData.end() )
           {
             d->m_DataNodeToPlanarFigureData.erase( it2 );// removing planar figure from tracked figure list
             PlanarFigureInitialized(); // normally called when a figure is finished, to reset all buttons
             EnableCrosshairNavigation();
           }
         }
       }
     }
   }
   this->CheckForTopMostVisibleImage(nonConstNode);
 }
 
 
 void QmitkMeasurementView::PlanarFigureSelected( itk::Object* object, const itk::EventObject& )
 {
   MEASUREMENT_DEBUG << "planar figure " << object << " selected";
   std::map<mitk::DataNode*, QmitkPlanarFigureData>::iterator it =
       d->m_DataNodeToPlanarFigureData.begin();
 
   d->m_CurrentSelection.clear();
   while( it != d->m_DataNodeToPlanarFigureData.end())
   {
     mitk::DataNode* node = it->first;
     QmitkPlanarFigureData& data = it->second;
 
     if( data.m_Figure == object )
     {
       MITK_DEBUG << "selected node found. enabling selection";
       node->SetSelected(true);
       d->m_CurrentSelection.push_back( node );
     }
     else
     {
       node->SetSelected(false);
     }
 
     ++it;
   }
   this->UpdateMeasurementText();
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::PlanarFigureInitialized()
 {
   MEASUREMENT_DEBUG << "planar figure initialized";
   d->m_UnintializedPlanarFigure = false;
   d->m_DrawActionsToolBar->setEnabled(true);
 
   d->m_DrawLine->setChecked(false);
   d->m_DrawPath->setChecked(false);
   d->m_DrawAngle->setChecked(false);
   d->m_DrawFourPointAngle->setChecked(false);
   d->m_DrawEllipse->setChecked(false);
   d->m_DrawDoubleEllipse->setChecked(false);
   d->m_DrawRectangle->setChecked(false);
   d->m_DrawPolygon->setChecked(false);
 }
 
 void QmitkMeasurementView::SetFocus()
 {
   d->m_SelectedImageLabel->setFocus();
 }
 
 void QmitkMeasurementView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/,
                                               const QList<mitk::DataNode::Pointer> &nodes)
 {
   MEASUREMENT_DEBUG << "Determine the top most visible image";
   MEASUREMENT_DEBUG << "The PlanarFigure interactor will take the currently visible PlaneGeometry from the slice navigation controller";
 
   this->CheckForTopMostVisibleImage();
 
   MEASUREMENT_DEBUG << "refreshing selection and detailed text";
   d->m_CurrentSelection = nodes;
   this->UpdateMeasurementText();
   // bug 16600: deselecting all planarfigures by clicking on datamanager when no node is selected
   if(d->m_CurrentSelection.size() == 0)
   {
     mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
     mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetDataStorage()->GetSubset( isPlanarFigure );
     // setting all planar figures which are not helper objects not selected
     for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin(); it!=planarFigures->End(); it++)
     {
       mitk::DataNode* node = it.Value();
       bool isHelperObject(false);
       node->GetBoolProperty("helper object", isHelperObject);
       if(!isHelperObject)
       {
         node->SetSelected(false);
       }
     }
   }
 
   for( int i=d->m_CurrentSelection.size()-1; i>= 0; --i)
   {
     mitk::DataNode* node = d->m_CurrentSelection.at(i);
     mitk::PlanarFigure* _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     // the last selected planar figure
 
     if (_PlanarFigure && _PlanarFigure->GetGeometry2D())
     {
 
       QmitkRenderWindow* selectedRenderWindow = 0;
       bool PlanarFigureInitializedWindow = false;
 
       mitk::ILinkedRenderWindowPart* linkedRenderWindow = dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart());
       if(! linkedRenderWindow )
       {
         return;
       }
 
       QmitkRenderWindow* RenderWindow1 = linkedRenderWindow->GetQmitkRenderWindow( "axial") ;
       QmitkRenderWindow* RenderWindow2 = linkedRenderWindow->GetQmitkRenderWindow( "sagittal") ;
       QmitkRenderWindow* RenderWindow3 = linkedRenderWindow->GetQmitkRenderWindow( "coronal") ;
       QmitkRenderWindow* RenderWindow4 = linkedRenderWindow->GetQmitkRenderWindow( "3d") ;
 
       if (node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow1->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow1;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow2->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow2;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,RenderWindow3->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow3;
       }
 
       if (!selectedRenderWindow && node->GetBoolProperty("PlanarFigureInitializedWindow", PlanarFigureInitializedWindow, RenderWindow4->GetRenderer()))
       {
         selectedRenderWindow = RenderWindow4;
       }
 
       const mitk::PlaneGeometry* _PlaneGeometry = dynamic_cast<const mitk::PlaneGeometry*> (_PlanarFigure->GetGeometry2D());
 
       mitk::VnlVector normal = _PlaneGeometry->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry1 = RenderWindow1->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane1 = dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry1.GetPointer() );
       mitk::VnlVector normal1 = _Plane1->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry2 = RenderWindow2->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane2 = dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry2.GetPointer() );
       mitk::VnlVector normal2 = _Plane2->GetNormalVnl();
 
       mitk::Geometry2D::ConstPointer worldGeometry3 = RenderWindow3->GetRenderer()->GetCurrentWorldGeometry2D();
       mitk::PlaneGeometry::ConstPointer _Plane3 = dynamic_cast<const mitk::PlaneGeometry*>( worldGeometry3.GetPointer() );
       mitk::VnlVector normal3 = _Plane3->GetNormalVnl();
 
       normal[0]  = fabs(normal[0]);  normal[1]  = fabs(normal[1]);  normal[2]  = fabs(normal[2]);
       normal1[0] = fabs(normal1[0]); normal1[1] = fabs(normal1[1]); normal1[2] = fabs(normal1[2]);
       normal2[0] = fabs(normal2[0]); normal2[1] = fabs(normal2[1]); normal2[2] = fabs(normal2[2]);
       normal3[0] = fabs(normal3[0]); normal3[1] = fabs(normal3[1]); normal3[2] = fabs(normal3[2]);
 
       double ang1 = angle(normal, normal1);
       double ang2 = angle(normal, normal2);
       double ang3 = angle(normal, normal3);
 
       if(ang1 < ang2 && ang1 < ang3)
       {
         selectedRenderWindow = RenderWindow1;
       }
       else
       {
         if(ang2 < ang3)
         {
           selectedRenderWindow = RenderWindow2;
         }
         else
         {
           selectedRenderWindow = RenderWindow3;
         }
       }
 
       // re-orient view
       if (selectedRenderWindow)
       {
         const mitk::Point3D& centerP = _PlaneGeometry->GetOrigin();
         selectedRenderWindow->GetSliceNavigationController()->ReorientSlices(centerP, _PlaneGeometry->GetNormal());
       }
     }
     break;
   }
 
   this->RequestRenderWindowUpdate();
 }
 
 void QmitkMeasurementView::ActionDrawLineTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarLine::Pointer figure = mitk::PlanarLine::New();
   QString qString = QString("Line%1").arg(++d->m_LineCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarLine initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPathTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::IPropertyFilters* propertyFilters = GetService<mitk::IPropertyFilters>();
 
   if (propertyFilters != NULL)
   {
     mitk::PropertyFilter filter;
     filter.AddEntry("ClosedPlanarPolygon", mitk::PropertyFilter::Blacklist);
 
     propertyFilters->AddFilter(filter, "PlanarPolygon");
   }
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOff();
   QString qString = QString("Path%1").arg(++d->m_PathCounter);
   mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
   mitk::BoolProperty::Pointer closedProperty = mitk::BoolProperty::New( false );
   node->SetProperty("ClosedPlanarPolygon", closedProperty);
   node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
 
   MEASUREMENT_DEBUG << "PlanarPath initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarAngle::Pointer figure = mitk::PlanarAngle::New();
   QString qString = QString("Angle%1").arg(++d->m_AngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawFourPointAngleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarFourPointAngle::Pointer figure =
       mitk::PlanarFourPointAngle::New();
   QString qString = QString("Four Point Angle%1").arg(++d->m_FourPointAngleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarFourPointAngle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarCircle::Pointer figure = mitk::PlanarCircle::New();
   QString qString = QString("Circle%1").arg(++d->m_EllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarCircle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawDoubleEllipseTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarDoubleEllipse::Pointer figure = mitk::PlanarDoubleEllipse::New();
   QString qString = QString("DoubleEllipse%1").arg(++d->m_DoubleEllipseCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarDoubleEllipse initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawRectangleTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarRectangle::Pointer figure = mitk::PlanarRectangle::New();
   QString qString = QString("Rectangle%1").arg(++d->m_RectangleCounter);
   this->AddFigureToDataStorage(figure, qString);
 
   MEASUREMENT_DEBUG << "PlanarRectangle initialized...";
 }
 
 void QmitkMeasurementView::ActionDrawPolygonTriggered(bool checked)
 {
   Q_UNUSED(checked)
 
   mitk::PlanarPolygon::Pointer figure = mitk::PlanarPolygon::New();
   figure->ClosedOn();
   QString qString = QString("Polygon%1").arg(++d->m_PolygonCounter);
   mitk::DataNode::Pointer node = this->AddFigureToDataStorage(figure, qString);
   node->SetProperty("planarfigure.isextendable",mitk::BoolProperty::New(true));
 
   MEASUREMENT_DEBUG << "PlanarPolygon initialized...";
 }
 
 void QmitkMeasurementView::CopyToClipboard( bool checked )
 {
   Q_UNUSED(checked)
 
   MEASUREMENT_DEBUG << "Copying current Text to clipboard...";
   QString clipboardText = d->m_SelectedPlanarFiguresText->toPlainText();
   QApplication::clipboard()->setText(clipboardText, QClipboard::Clipboard);
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::AddFigureToDataStorage(
     mitk::PlanarFigure* figure, const QString& name)
 {
   // add as
   MEASUREMENT_DEBUG << "Adding new figure to datastorage...";
   if( d->m_SelectedImageNode.IsNull() )
   {
     MITK_ERROR << "No reference image available";
     return 0;
   }
 
   mitk::DataNode::Pointer newNode = mitk::DataNode::New();
   newNode->SetName(name.toStdString());
   newNode->SetData(figure);
   // set as selected
   newNode->SetSelected( true );
   this->GetDataStorage()->Add(newNode, d->m_SelectedImageNode);
 
   // set all others in selection as deselected
   for( int i=0; i<d->m_CurrentSelection.size(); ++i)
     d->m_CurrentSelection.at(i)->SetSelected(false);
   d->m_CurrentSelection.clear();
   d->m_CurrentSelection.push_back( newNode );
   this->UpdateMeasurementText();
   this->DisableCrosshairNavigation();
   d->m_DrawActionsToolBar->setEnabled(false);
   d->m_UnintializedPlanarFigure = true;
   return newNode;
 }
 
 void QmitkMeasurementView::UpdateMeasurementText()
 {
   d->m_SelectedPlanarFiguresText->clear();
 
   QString infoText;
   QString plainInfoText;
   int j = 1;
   mitk::PlanarFigure* _PlanarFigure = 0;
   mitk::PlanarAngle* planarAngle = 0;
   mitk::PlanarFourPointAngle* planarFourPointAngle = 0;
   mitk::DataNode::Pointer node = 0;
 
   for (int i=0; i<d->m_CurrentSelection.size(); ++i, ++j)
   {
     plainInfoText.clear();
     node = d->m_CurrentSelection.at(i);
     _PlanarFigure = dynamic_cast<mitk::PlanarFigure*> (node->GetData());
 
     if( !_PlanarFigure )
       continue;
 
     if(j>1)
       infoText.append("<br />");
 
     infoText.append(QString("<b>%1</b><hr />").arg(QString::fromStdString(
                                                      node->GetName())));
     plainInfoText.append(QString("%1").arg(QString::fromStdString(
                                              node->GetName())));
 
     planarAngle = dynamic_cast<mitk::PlanarAngle*> (_PlanarFigure);
     if(!planarAngle)
     {
       planarFourPointAngle = dynamic_cast<mitk::PlanarFourPointAngle*> (_PlanarFigure);
     }
 
     double featureQuantity = 0.0;
     for (unsigned int k = 0; k < _PlanarFigure->GetNumberOfFeatures(); ++k)
     {
       if ( !_PlanarFigure->IsFeatureActive( k ) ) continue;
 
       featureQuantity = _PlanarFigure->GetQuantity(k);
       if ((planarAngle && k == planarAngle->FEATURE_ID_ANGLE)
           || (planarFourPointAngle && k == planarFourPointAngle->FEATURE_ID_ANGLE))
         featureQuantity = featureQuantity * 180 / vnl_math::pi;
 
       infoText.append(
             QString("<i>%1</i>: %2 %3") .arg(QString(
                                                _PlanarFigure->GetFeatureName(k))) .arg(featureQuantity, 0, 'f',
                                                                                        2) .arg(QString(_PlanarFigure->GetFeatureUnit(k))));
 
       plainInfoText.append(
             QString("\n%1: %2 %3") .arg(QString(_PlanarFigure->GetFeatureName(k))) .arg(
               featureQuantity, 0, 'f', 2) .arg(QString(
                                                  _PlanarFigure->GetFeatureUnit(k))));
 
       if(k+1 != _PlanarFigure->GetNumberOfFeatures())
         infoText.append("<br />");
     }
 
     if (j != d->m_CurrentSelection.size())
       infoText.append("<br />");
   }
 
   d->m_SelectedPlanarFiguresText->setHtml(infoText);
 }
 
 void QmitkMeasurementView::AddAllInteractors()
 {
   MEASUREMENT_DEBUG << "Adding interactors and observers to all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetAllPlanarFigures();
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin();
     it!=planarFigures->End(); it++)
   {
     this->NodeAdded( it.Value() );
   }
 }
 
 void QmitkMeasurementView::RemoveAllInteractors()
 {
   MEASUREMENT_DEBUG << "Removing interactors and observers from all planar figures";
 
   mitk::DataStorage::SetOfObjects::ConstPointer planarFigures = this->GetAllPlanarFigures();
 
   for(mitk::DataStorage::SetOfObjects::ConstIterator it=planarFigures->Begin();
     it!=planarFigures->End(); it++)
   {
     this->NodeRemoved( it.Value() );
   }
 }
 
 mitk::DataNode::Pointer QmitkMeasurementView::DetectTopMostVisibleImage()
 {
   // get all images from the data storage which are not a segmentation
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateProperty::Pointer isBinary = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer isNotBinary = mitk::NodePredicateNot::New( isBinary );
   mitk::NodePredicateAnd::Pointer isNormalImage = mitk::NodePredicateAnd::New( isImage, isNotBinary );
 
   mitk::DataStorage::SetOfObjects::ConstPointer Images
       = this->GetDataStorage()->GetSubset( isNormalImage );
 
 
   mitk::DataNode::Pointer currentNode;
   int maxLayer = itk::NumericTraits<int>::min();
 
   // iterate over selection
   for (mitk::DataStorage::SetOfObjects::ConstIterator sofIt = Images->Begin(); sofIt != Images->End(); ++sofIt)
   {
     mitk::DataNode::Pointer node = sofIt->Value();
     if ( node.IsNull() )
       continue;
     if (node->IsVisible(NULL) == false)
       continue;
     // we also do not want to assign planar figures to helper objects ( even if they are of type image )
     if (node->GetProperty("helper object"))
       continue;
 
     int layer = 0;
     node->GetIntProperty("layer", layer);
     if ( layer < maxLayer )
     {
       continue;
     }
     else
     {
       maxLayer = layer;
       currentNode = node;
     }
   }
 
   return currentNode;
 }
 
 void QmitkMeasurementView::EnableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "EnableCrosshairNavigation";
 
   // enable the crosshair navigation
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "enabling linked navigation";
     linkedRenderWindow->EnableLinkedNavigation(true);
     linkedRenderWindow->EnableSlicingPlanes(true);
   }
 }
 
 void QmitkMeasurementView::DisableCrosshairNavigation()
 {
   MEASUREMENT_DEBUG << "DisableCrosshairNavigation";
 
   // disable the crosshair navigation during the drawing
   if (mitk::ILinkedRenderWindowPart* linkedRenderWindow =
       dynamic_cast<mitk::ILinkedRenderWindowPart*>(this->GetRenderWindowPart()))
   {
     MEASUREMENT_DEBUG << "disabling linked navigation";
     linkedRenderWindow->EnableLinkedNavigation(false);
     linkedRenderWindow->EnableSlicingPlanes(false);
   }
 }
 
 mitk::DataStorage::SetOfObjects::ConstPointer QmitkMeasurementView::GetAllPlanarFigures() const
 {
   mitk::TNodePredicateDataType<mitk::PlanarFigure>::Pointer isPlanarFigure = mitk::TNodePredicateDataType<mitk::PlanarFigure>::New();
 
   mitk::NodePredicateProperty::Pointer isNotHelperObject = mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(false));
   mitk::NodePredicateAnd::Pointer isNotHelperButPlanarFigure = mitk::NodePredicateAnd::New( isPlanarFigure, isNotHelperObject );
 
   return this->GetDataStorage()->GetSubset( isPlanarFigure );
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp
index 438fae704b..0a85bb0e1e 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.cpp
@@ -1,301 +1,302 @@
 /*===================================================================
 
 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 "QmitkImageMaskingWidget.h"
+#include "mitkImage.h"
 #include "../../Common/QmitkDataSelectionWidget.h"
 
 #include <mitkException.h>
 #include <mitkExceptionMacro.h>
 #include <mitkImageStatisticsHolder.h>
 #include <mitkMaskImageFilter.h>
 #include <mitkProgressBar.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkSurfaceToImageFilter.h>
 
 #include <qmessagebox.h>
 
 static const char* const HelpText = "Select a regular image and a binary image";
 
 QmitkImageMaskingWidget::QmitkImageMaskingWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
 {
   m_Controls.setupUi(this);
 
   m_Controls.dataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::ImagePredicate);
   m_Controls.dataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::SegmentationPredicate);
   m_Controls.dataSelectionWidget->SetHelpText(HelpText);
 
   this->EnableButtons(false);
 
   connect (m_Controls.rbMaskImage, SIGNAL(toggled(bool)), this, SLOT(OnImageMaskingToggled(bool)));
   connect (m_Controls.rbMaskSurface, SIGNAL(toggled(bool)), this, SLOT(OnSurfaceMaskingToggled(bool)));
   connect (m_Controls.btnMaskImage, SIGNAL(pressed()), this, SLOT(OnMaskImagePressed()));
 
   connect(m_Controls.dataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)),
     this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
 
   if( m_Controls.dataSelectionWidget->GetSelection(0).IsNotNull() &&
     m_Controls.dataSelectionWidget->GetSelection(1).IsNotNull() )
   {
     this->OnSelectionChanged( 0, m_Controls.dataSelectionWidget->GetSelection(0));
   }
 }
 
 QmitkImageMaskingWidget::~QmitkImageMaskingWidget()
 {
 }
 
 void QmitkImageMaskingWidget::OnSelectionChanged(unsigned int index, const mitk::DataNode* selection)
 {
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node0 = dataSelectionWidget->GetSelection(0);
   mitk::DataNode::Pointer node1 = dataSelectionWidget->GetSelection(1);
 
   if (node0.IsNull() || node1.IsNull() )
   {
     if( m_Controls.rbMaskImage->isChecked() )
     {
       dataSelectionWidget->SetHelpText(HelpText);
     }
     else
     {
       dataSelectionWidget->SetHelpText("Select a regular image and a surface");
     }
     this->EnableButtons(false);
   }
   else
   {
     this->SelectionControl(index, selection);
   }
 }
 
 void QmitkImageMaskingWidget::SelectionControl(unsigned int index, const mitk::DataNode* selection)
 {
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(index);
 
   //if Image-Masking is enabled, check if image-dimension of reference and binary image is identical
   if( m_Controls.rbMaskImage->isChecked() )
   {
     if( dataSelectionWidget->GetSelection(0) == dataSelectionWidget->GetSelection(1) )
     {
       dataSelectionWidget->SetHelpText("Select two different images above");
       this->EnableButtons(false);
       return;
     }
 
     else if( node.IsNotNull() && selection )
     {
       mitk::Image::Pointer referenceImage = dynamic_cast<mitk::Image*> ( dataSelectionWidget->GetSelection(0)->GetData() );
       mitk::Image::Pointer maskImage = dynamic_cast<mitk::Image*> ( dataSelectionWidget->GetSelection(1)->GetData() );
 
       if( referenceImage->GetLargestPossibleRegion().GetSize() != maskImage->GetLargestPossibleRegion().GetSize() )
       {
         dataSelectionWidget->SetHelpText("Different image sizes cannot be masked");
         this->EnableButtons(false);
         return;
       }
     }
 
     else
     {
       dataSelectionWidget->SetHelpText(HelpText);
       return;
     }
   }
 
   dataSelectionWidget->SetHelpText("");
   this->EnableButtons();
 }
 
 void QmitkImageMaskingWidget::EnableButtons(bool enable)
 {
   m_Controls.btnMaskImage->setEnabled(enable);
 }
 
 void QmitkImageMaskingWidget::OnImageMaskingToggled(bool status)
 {
   if (status)
   {
     m_Controls.dataSelectionWidget->SetHelpText("Select a regular image and a binary image");
     m_Controls.dataSelectionWidget->SetPredicate(1, QmitkDataSelectionWidget::SegmentationPredicate);
   }
 }
 
 void QmitkImageMaskingWidget::OnSurfaceMaskingToggled(bool status)
 {
   if (status)
   {
     m_Controls.dataSelectionWidget->SetHelpText("Select a regular image and a surface");
     m_Controls.dataSelectionWidget->SetPredicate(1, QmitkDataSelectionWidget::SurfacePredicate);
   }
 }
 
 
 void QmitkImageMaskingWidget::OnMaskImagePressed()
 {
   //Disable Buttons during calculation and initialize Progressbar
   this->EnableButtons(false);
   mitk::ProgressBar::GetInstance()->AddStepsToDo(4);
   mitk::ProgressBar::GetInstance()->Progress();
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
 
   //create result image, get mask node and reference image
   mitk::Image::Pointer resultImage(0);
   mitk::DataNode::Pointer maskingNode = dataSelectionWidget->GetSelection(1);
   mitk::Image::Pointer referenceImage = static_cast<mitk::Image*>(dataSelectionWidget->GetSelection(0)->GetData());
 
   if(referenceImage.IsNull() || maskingNode.IsNull() )
   {
     MITK_ERROR << "Selection does not contain an image";
     QMessageBox::information( this, "Image and Surface Masking", "Selection does not contain an image", QMessageBox::Ok );
     m_Controls.btnMaskImage->setEnabled(true);
     return;
   }
 
   //Do Image-Masking
   if (m_Controls.rbMaskImage->isChecked())
   {
     mitk::ProgressBar::GetInstance()->Progress();
 
     mitk::Image::Pointer maskImage = dynamic_cast<mitk::Image*> ( maskingNode->GetData() );
 
     if(maskImage.IsNull() )
     {
       MITK_ERROR << "Selection does not contain a binary image";
       QMessageBox::information( this, "Image and Surface Masking", "Selection does not contain a binary image", QMessageBox::Ok );
       this->EnableButtons();
       return;
     }
 
     if( referenceImage->GetLargestPossibleRegion().GetSize() == maskImage->GetLargestPossibleRegion().GetSize() )
     {
       resultImage = this->MaskImage( referenceImage, maskImage );
     }
 
   }
 
   //Do Surface-Masking
   else
   {
     mitk::ProgressBar::GetInstance()->Progress();
 
     //1. convert surface to image
     mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*> ( maskingNode->GetData() );
 
     //TODO Get 3D Surface of current time step
 
     if(surface.IsNull())
     {
       MITK_ERROR << "Selection does not contain a surface";
       QMessageBox::information( this, "Image and Surface Masking", "Selection does not contain a surface", QMessageBox::Ok );
       this->EnableButtons();
       return;
     }
 
     mitk::Image::Pointer maskImage = this->ConvertSurfaceToImage( referenceImage, surface );
 
     //2. mask reference image with mask image
     if(maskImage.IsNotNull() &&
        referenceImage->GetLargestPossibleRegion().GetSize() == maskImage->GetLargestPossibleRegion().GetSize() )
     {
       resultImage = this->MaskImage( referenceImage, maskImage );
     }
   }
 
   mitk::ProgressBar::GetInstance()->Progress();
 
   if( resultImage.IsNull() )
   {
     MITK_ERROR << "Masking failed";
     QMessageBox::information( this, "Image and Surface Masking", "Masking failed. For more information please see logging window.", QMessageBox::Ok );
     this->EnableButtons();
     mitk::ProgressBar::GetInstance()->Progress(4);
     return;
   }
 
   //Add result to data storage
   this->AddToDataStorage(
     dataSelectionWidget->GetDataStorage(),
     resultImage,
     dataSelectionWidget->GetSelection(0)->GetName() + "_" + dataSelectionWidget->GetSelection(1)->GetName(),
     dataSelectionWidget->GetSelection(0));
 
   this->EnableButtons();
 
   mitk::ProgressBar::GetInstance()->Progress();
 }
 
 mitk::Image::Pointer QmitkImageMaskingWidget::MaskImage(mitk::Image::Pointer referenceImage, mitk::Image::Pointer maskImage )
 {
   mitk::Image::Pointer resultImage(0);
 
   mitk::MaskImageFilter::Pointer maskFilter = mitk::MaskImageFilter::New();
   maskFilter->SetInput( referenceImage );
   maskFilter->SetMask( maskImage );
   maskFilter->OverrideOutsideValueOn();
   maskFilter->SetOutsideValue( referenceImage->GetStatistics()->GetScalarValueMin() );
   try
   {
     maskFilter->Update();
   }
   catch(itk::ExceptionObject& excpt)
   {
     MITK_ERROR << excpt.GetDescription();
     return 0;
   }
 
   resultImage = maskFilter->GetOutput();
 
   return resultImage;
 }
 
 mitk::Image::Pointer QmitkImageMaskingWidget::ConvertSurfaceToImage( mitk::Image::Pointer image, mitk::Surface::Pointer surface )
 {
   mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
   mitk::ProgressBar::GetInstance()->Progress();
 
   mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
   surfaceToImageFilter->MakeOutputBinaryOn();
   surfaceToImageFilter->SetInput(surface);
   surfaceToImageFilter->SetImage(image);
   try
   {
     surfaceToImageFilter->Update();
   }
   catch(itk::ExceptionObject& excpt)
   {
     MITK_ERROR << excpt.GetDescription();
     return 0;
   }
 
   mitk::ProgressBar::GetInstance()->Progress();
   mitk::Image::Pointer resultImage = mitk::Image::New();
   resultImage = surfaceToImageFilter->GetOutput();
 
   return resultImage;
 }
 
 void QmitkImageMaskingWidget::AddToDataStorage(mitk::DataStorage::Pointer dataStorage, mitk::Image::Pointer segmentation, const std::string& name, mitk::DataNode::Pointer parent )
 {
   mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
 
   dataNode->SetName(name);
   dataNode->SetData(segmentation);
 
   dataStorage->Add(dataNode, parent);
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.h b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.h
index e370cefa40..79fca915ad 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ImageMasking/QmitkImageMaskingWidget.h
@@ -1,80 +1,84 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef QmitkImageMaskingWidget_h
 #define QmitkImageMaskingWidget_h
 
 #include "../QmitkSegmentationUtilityWidget.h"
 #include <ui_QmitkImageMaskingWidgetControls.h>
 
 #include <mitkSurface.h>
 
+namespace mitk {
+  class Image;
+}
+
 /*!
   \brief QmitkImageMaskingWidget
 
   Tool masks an image with a binary image or a surface. The Method requires
   an image and a binary image mask or a surface. The input image and the binary
   image mask must be of the same size. Masking with a surface creates first a
   binary image of the surface and then use this for the masking of the input image.
 */
 class QmitkImageMaskingWidget : public QmitkSegmentationUtilityWidget
 {
   Q_OBJECT
 
 public:
 
   /** @brief Default constructor, including creation of GUI elements and signals/slots connections. */
   explicit QmitkImageMaskingWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent = NULL);
 
   /** @brief Defaul destructor. */
   ~QmitkImageMaskingWidget();
 
 private slots:
 
   /** @brief This slot is called if the selection in the workbench is changed. */
   void OnSelectionChanged(unsigned int index, const mitk::DataNode* selection);
 
   /** @brief This slot is called if user activates the radio button for masking an image with a binary image mask. */
   void OnImageMaskingToggled(bool);
 
   /** @brief This slot is called if user activates the radio button for masking an image with a surface. */
   void OnSurfaceMaskingToggled(bool);
 
   /** @brief This slot is called if user activates the button to mask an image. */
   void OnMaskImagePressed();
 
 private:
 
   /** @brief Check if selections is valid. */
   void SelectionControl( unsigned int index, const mitk::DataNode* selection);
 
   /** @brief Enable buttons if data selction is valid. */
   void EnableButtons(bool enable = true);
 
   /** @brief Mask an image with a given binary mask. Note that the input image and the mask image must be of the same size. */
-  mitk::Image::Pointer MaskImage(mitk::Image::Pointer referenceImage, mitk::Image::Pointer maskImage );
+  itk::SmartPointer<mitk::Image> MaskImage(itk::SmartPointer<mitk::Image> referenceImage, itk::SmartPointer<mitk::Image> maskImage );
 
   /** @brief Convert a surface into an binary image. */
-  mitk::Image::Pointer ConvertSurfaceToImage( mitk::Image::Pointer image, mitk::Surface::Pointer surface );
+  itk::SmartPointer<mitk::Image> ConvertSurfaceToImage( itk::SmartPointer<mitk::Image> image, mitk::Surface::Pointer surface );
 
   /** @brief Adds a new data object to the DataStorage.*/
-  void AddToDataStorage(mitk::DataStorage::Pointer dataStorage, mitk::Image::Pointer segmentation,
+  void AddToDataStorage(mitk::DataStorage::Pointer dataStorage, itk::SmartPointer<mitk::Image> segmentation,
                         const std::string& name, mitk::DataNode::Pointer parent = NULL);
 
   Ui::QmitkImageMaskingWidgetControls m_Controls;
 };
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp
index 02fe54b911..93304e5ef6 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.cpp
@@ -1,156 +1,158 @@
 /*===================================================================
 
 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 "QmitkSurfaceToImageWidget.h"
 
 #include <mitkException.h>
 #include <mitkExceptionMacro.h>
 #include <mitkProgressBar.h>
 #include <mitkProperties.h>
 #include <mitkSurfaceToImageFilter.h>
+#include <mitkSurface.h>
+#include <mitkImage.h>
 
 #include <qmessagebox.h>
 
 static const char* const HelpText = "Select a regular image and a surface";
 
 QmitkSurfaceToImageWidget::QmitkSurfaceToImageWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
 {
   m_Controls.setupUi(this);
 
   m_Controls.dataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::ImagePredicate);
   m_Controls.dataSelectionWidget->AddDataStorageComboBox(QmitkDataSelectionWidget::SurfacePredicate);
   m_Controls.dataSelectionWidget->SetHelpText(HelpText);
 
   this->EnableButtons(false);
 
   connect (m_Controls.btnSurface2Image, SIGNAL(pressed()), this, SLOT(OnSurface2ImagePressed()));
   connect(m_Controls.dataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)),
     this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
 
   if( m_Controls.dataSelectionWidget->GetSelection(0).IsNotNull() &&
     m_Controls.dataSelectionWidget->GetSelection(1).IsNotNull() )
   {
     this->OnSelectionChanged( 0, m_Controls.dataSelectionWidget->GetSelection(0));
   }
 }
 
 QmitkSurfaceToImageWidget::~QmitkSurfaceToImageWidget()
 {
 }
 
 void QmitkSurfaceToImageWidget::EnableButtons(bool enable)
 {
   m_Controls.btnSurface2Image->setEnabled(enable);
 }
 
 void QmitkSurfaceToImageWidget::OnSelectionChanged(unsigned int index, const mitk::DataNode* selection)
 {
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer imageNode = dataSelectionWidget->GetSelection(0);
   mitk::DataNode::Pointer surfaceNode = dataSelectionWidget->GetSelection(1);
 
   if (imageNode.IsNull() || surfaceNode.IsNull() )
   {
     dataSelectionWidget->SetHelpText(HelpText);
     this->EnableButtons(false);
   }
   else
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( dataSelectionWidget->GetSelection(0)->GetData() );
     mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>( dataSelectionWidget->GetSelection(1)->GetData() );
     if( image->GetTimeSteps() != surface->GetTimeSteps() )
     {
       dataSelectionWidget->SetHelpText("Image and surface are of different size");
       this->EnableButtons(false);
     }
     else
     {
       dataSelectionWidget->SetHelpText("");
       this->EnableButtons();
     }
   }
 }
 
 void QmitkSurfaceToImageWidget::OnSurface2ImagePressed()
 {
   this->EnableButtons(false);
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( dataSelectionWidget->GetSelection(0)->GetData() );
   mitk::Surface::Pointer surface = dynamic_cast<mitk::Surface*>( dataSelectionWidget->GetSelection(1)->GetData() );
 
   if( image.IsNull() || surface.IsNull())
   {
     MITK_ERROR << "Selection does not contain an image and/or a surface";
     QMessageBox::information( this, "Surface To Image", "Selection does not contain an image and/or a surface", QMessageBox::Ok );
     this->EnableButtons();
     return;
   }
 
   mitk::Image::Pointer resultImage(0);
   resultImage = this->ConvertSurfaceToImage( image, surface );
 
   if( resultImage.IsNull() )
   {
     MITK_ERROR << "Convert Surface to binary image failed";
     QMessageBox::information( this, "Surface To Image", "Convert Surface to binary image failed", QMessageBox::Ok );
     this->EnableButtons();
     return;
   }
 
   //create name for result node
   std::string nameOfResultImage = dataSelectionWidget->GetSelection(0)->GetName();
   nameOfResultImage.append("_");
   nameOfResultImage.append(dataSelectionWidget->GetSelection(1)->GetName());
 
   //create data node and add to data storage
   mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
   resultNode->SetData( resultImage );
   resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
   resultNode->SetProperty("binary", mitk::BoolProperty::New(true) );
 
   dataSelectionWidget->GetDataStorage()->Add(resultNode, dataSelectionWidget->GetSelection(0));
 
   this->EnableButtons();
 }
 
 mitk::Image::Pointer QmitkSurfaceToImageWidget::ConvertSurfaceToImage( mitk::Image::Pointer image, mitk::Surface::Pointer surface )
 {
   mitk::ProgressBar::GetInstance()->AddStepsToDo(2);
   mitk::ProgressBar::GetInstance()->Progress();
 
   mitk::SurfaceToImageFilter::Pointer surfaceToImageFilter = mitk::SurfaceToImageFilter::New();
   surfaceToImageFilter->MakeOutputBinaryOn();
   surfaceToImageFilter->SetInput(surface);
   surfaceToImageFilter->SetImage(image);
   try
   {
     surfaceToImageFilter->Update();
   }
   catch(itk::ExceptionObject& excpt)
   {
     MITK_ERROR << excpt.GetDescription();
     return 0;
   }
 
   mitk::ProgressBar::GetInstance()->Progress();
 
   mitk::Image::Pointer resultImage = surfaceToImageFilter->GetOutput();
 
   return resultImage;
 }
 
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.h b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.h
index c773313ae6..ca3c7b9df8 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/SurfaceToImage/QmitkSurfaceToImageWidget.h
@@ -1,64 +1,67 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef QmitkSurfaceToImageWidget_h
 #define QmitkSurfaceToImageWidget_h
 
 #include "../QmitkSegmentationUtilityWidget.h"
 #include <ui_QmitkSurfaceToImageWidgetControls.h>
 
-#include <mitkSurface.h>
+namespace mitk {
+  class Surface;
+  class Image;
+}
 
 /*!
   \brief QmitkSurfaceToImageWidget
 
   The Tool converts a surface to a binary image. The Method requires
   a surface and an image, which header information defines the output
   image. The resulting binary image has the same dimension, size, and
   Geometry3D as the input image.
 */
 class QmitkSurfaceToImageWidget : public QmitkSegmentationUtilityWidget
 {
   Q_OBJECT
 
 public:
 
   /** @brief Default constructor, including creation of GUI elements and signals/slots connections. */
   explicit QmitkSurfaceToImageWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent = NULL);
 
   /** @brief Defaul destructor. */
   ~QmitkSurfaceToImageWidget();
 
 private slots:
 
   /** @brief This slot is called if the selection in the workbench is changed. */
   void OnSelectionChanged(unsigned int index, const mitk::DataNode* selection);
 
   /** @brief This slot is called if user activates the button to convert a surface into a binary image. */
   void OnSurface2ImagePressed();
 
 private:
 
   /** @brief Enable buttons if data selction is valid. */
   void EnableButtons(bool enable = true);
 
   /** @brief Convert a surface into an binary image. */
-  mitk::Image::Pointer ConvertSurfaceToImage( mitk::Image::Pointer image, mitk::Surface::Pointer surface );
+  itk::SmartPointer<mitk::Image> ConvertSurfaceToImage( itk::SmartPointer<mitk::Image> image, itk::SmartPointer<mitk::Surface> surface );
 
   Ui::QmitkSurfaceToImageWidgetControls m_Controls;
 };
 
 #endif