diff --git a/Modules/Segmentation/Controllers/mitkToolManager.cpp b/Modules/Segmentation/Controllers/mitkToolManager.cpp
index 2ff9e68aac..bb79dc4ec8 100644
--- a/Modules/Segmentation/Controllers/mitkToolManager.cpp
+++ b/Modules/Segmentation/Controllers/mitkToolManager.cpp
@@ -1,542 +1,548 @@
 /*===================================================================
 
 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 "mitkToolManager.h"
 #include "mitkGlobalInteraction.h"
 #include "mitkCoreObjectFactory.h"
 
 #include <itkObjectFactoryBase.h>
 #include <itkCommand.h>
 
 #include <list>
 
 #include "mitkInteractionEventObserver.h"
 #include "mitkDisplayInteractor.h"
 #include "mitkSegTool2D.h"
 // MicroServices
 #include "mitkGetModuleContext.h"
 #include "mitkModule.h"
 #include "mitkModuleRegistry.h"
 
 
 mitk::ToolManager::ToolManager(DataStorage* storage)
 :m_ActiveTool(NULL),
  m_ActiveToolID(-1),
  m_RegisteredClients(0),
  m_DataStorage(storage)
 {
   CoreObjectFactory::GetInstance(); // to make sure a CoreObjectFactory was instantiated (and in turn, possible tools are registered) - bug 1029
 
-  if(mitk::GlobalInteraction::GetInstance()->IsInitialized())
-  {
-    // get a list of all known mitk::Tools
-    std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");
-
-    // remember these tools
-    for ( std::list<itk::LightObject::Pointer>::iterator iter = thingsThatClaimToBeATool.begin();
-      iter != thingsThatClaimToBeATool.end();
-      ++iter )
-    {
-      if ( Tool* tool = dynamic_cast<Tool*>( iter->GetPointer() ) )
-      {
-        tool->SetToolManager(this); // important to call right after instantiation
-        tool->ErrorMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnToolErrorMessage );
-        tool->GeneralMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnGeneralToolMessage );
-        m_Tools.push_back( tool );
-      }
-    }
-  }
   //ActivateTool(0); // first one is default
 }
 
 mitk::ToolManager::~ToolManager()
 {
   for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter)
     (*dataIter)->RemoveObserver(m_WorkingDataObserverTags[(*dataIter)]);
 
   if(this->GetDataStorage() != NULL)
     this->GetDataStorage()->RemoveNodeEvent.RemoveListener( mitk::MessageDelegate1<ToolManager, const mitk::DataNode*>
         ( this, &ToolManager::OnNodeRemoved ));
 
   if (m_ActiveTool)
   {
     m_ActiveTool->Deactivated();
     GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
 
     m_ActiveTool = NULL;
     m_ActiveToolID = -1; // no tool active
 
     ActiveToolChanged.Send();
 
   }
   for ( NodeTagMapType::iterator observerTagMapIter = m_ReferenceDataObserverTags.begin(); observerTagMapIter != m_ReferenceDataObserverTags.end(); ++observerTagMapIter )
   {
     observerTagMapIter->first->RemoveObserver( observerTagMapIter->second );
   }
 }
 
+
+void mitk::ToolManager::InitializeTools()
+{
+  if(mitk::GlobalInteraction::GetInstance()->IsInitialized())
+  {
+    // get a list of all known mitk::Tools
+    std::list<itk::LightObject::Pointer> thingsThatClaimToBeATool = itk::ObjectFactoryBase::CreateAllInstance("mitkTool");
+
+    // remember these tools
+    for ( std::list<itk::LightObject::Pointer>::iterator iter = thingsThatClaimToBeATool.begin();
+      iter != thingsThatClaimToBeATool.end();
+      ++iter )
+    {
+      if ( Tool* tool = dynamic_cast<Tool*>( iter->GetPointer() ) )
+      {
+        tool->SetToolManager(this); // important to call right after instantiation
+        tool->ErrorMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnToolErrorMessage );
+        tool->GeneralMessage += MessageDelegate1<mitk::ToolManager, std::string>( this, &ToolManager::OnGeneralToolMessage );
+        m_Tools.push_back( tool );
+      }
+    }
+  }
+}
+
+
 void mitk::ToolManager::OnToolErrorMessage(std::string s)
 {
   this->ToolErrorMessage(s);
 }
 
 void mitk::ToolManager::OnGeneralToolMessage(std::string s)
 {
   this->GeneralToolMessage(s);
 }
 
 
 const mitk::ToolManager::ToolVectorTypeConst mitk::ToolManager::GetTools()
 {
   ToolVectorTypeConst resultList;
 
   for ( ToolVectorType::iterator iter = m_Tools.begin();
     iter != m_Tools.end();
     ++iter )
   {
     resultList.push_back( iter->GetPointer() );
   }
 
   return resultList;
 }
 
 mitk::Tool* mitk::ToolManager::GetToolById(int id)
 {
   try
   {
     return m_Tools.at(id);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 bool mitk::ToolManager::ActivateTool(int id)
 {
 
   if(this->GetDataStorage())
     {
       this->GetDataStorage()->RemoveNodeEvent.AddListener( mitk::MessageDelegate1<ToolManager, const mitk::DataNode*>
         ( this, &ToolManager::OnNodeRemoved ) );
     }
 
   //MITK_INFO << "ToolManager::ActivateTool("<<id<<")"<<std::endl;
   //if( GetToolById(id) == NULL ) return false; // NO, invalid IDs are actually used here. Parameter -1 or anything that does not exists will deactivate all tools!
 
   //If a tool is deactivated set the event notification policy of the global interaction to multiple again
   if (id == -1)
   {
     GlobalInteraction::GetInstance()->SetEventNotificationPolicy(GlobalInteraction::INFORM_MULTIPLE);
   }
 
   if ( GetToolById( id ) == m_ActiveTool ) return true; // no change needed
 
   static int nextTool = -1;
   nextTool = id;
   //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): nextTool = "<<nextTool<<std::endl;
 
   static bool inActivateTool = false;
   if (inActivateTool)
   {
     //MITK_INFO << "ToolManager::ActivateTool("<<id<<"): already inside ActivateTool somehow, returning now "<<std::endl;
     return true;
   }
   inActivateTool = true;
 
   while ( nextTool != m_ActiveToolID )
   {
     //MITK_INFO <<"ToolManager::ActivateTool: nextTool = " << nextTool << " (active tool = " << m_ActiveToolID<<")"<<std::endl;
     if (m_ActiveTool)
     {
       m_ActiveTool->Deactivated();
       GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
     }
 
     m_ActiveTool = GetToolById( nextTool );
     m_ActiveToolID = m_ActiveTool ? nextTool : -1; // current ID if tool is valid, otherwise -1
 
     ActiveToolChanged.Send();
 
     if (m_ActiveTool)
     {
       if (m_RegisteredClients > 0)
       {
         m_ActiveTool->Activated();
         GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
         //If a tool is activated set event notification policy to one
         if (dynamic_cast<mitk::SegTool2D*>(m_ActiveTool))
           GlobalInteraction::GetInstance()->SetEventNotificationPolicy(GlobalInteraction::INFORM_ONE);
       }
     }
   }
 
   inActivateTool = false;
   return (m_ActiveTool != NULL);
 }
 
 void mitk::ToolManager::SetReferenceData(DataVectorType data)
 {
   if (data != m_ReferenceData)
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_ReferenceDataObserverTags.find( *dataIter );
       if ( searchIter != m_ReferenceDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_ReferenceData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_ReferenceDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
     {
 
 
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheReferenceDataDeletedConst );
       m_ReferenceDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
 
     ReferenceDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheReferenceDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheReferenceDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_ReferenceData.begin(); dataIter != m_ReferenceData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_ReferenceDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetReferenceData( v );
 }
 
 void mitk::ToolManager::SetReferenceData(DataNode* data)
 {
   //MITK_INFO << "ToolManager::SetReferenceData(" << (void*)data << ")" << std::endl;
   DataVectorType v;
   if (data)
   {
     v.push_back(data);
   }
   SetReferenceData(v);
 }
 
 void mitk::ToolManager::SetWorkingData(DataVectorType data)
 {
   if ( data != m_WorkingData )
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_WorkingDataObserverTags.find( *dataIter );
       if ( searchIter != m_WorkingDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_WorkingData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_WorkingDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
     {
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheWorkingDataDeletedConst );
       m_WorkingDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
 
     WorkingDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheWorkingDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheWorkingDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from reference data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_WorkingData.begin(); dataIter != m_WorkingData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_WorkingDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetWorkingData( v );
 }
 
 
 void mitk::ToolManager::SetWorkingData(DataNode* data)
 {
   DataVectorType v;
 
   if (data) // don't allow for NULL nodes
   {
     v.push_back(data);
   }
 
   SetWorkingData(v);
 }
 
 void mitk::ToolManager::SetRoiData(DataVectorType data)
 {
   if (data != m_RoiData)
   {
     // remove observers from old nodes
     for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
     {
       NodeTagMapType::iterator searchIter = m_RoiDataObserverTags.find( *dataIter );
       if ( searchIter != m_RoiDataObserverTags.end() )
       {
         //MITK_INFO << "Stopping observation of " << (void*)(*dataIter) << std::endl;
         (*dataIter)->RemoveObserver( searchIter->second );
       }
     }
 
     m_RoiData = data;
     // TODO tell active tool?
 
     // attach new observers
     m_RoiDataObserverTags.clear();
     for ( DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
     {
       //MITK_INFO << "Observing " << (void*)(*dataIter) << std::endl;
       itk::MemberCommand<ToolManager>::Pointer command = itk::MemberCommand<ToolManager>::New();
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeleted );
       command->SetCallbackFunction( this, &ToolManager::OnOneOfTheRoiDataDeletedConst );
       m_RoiDataObserverTags.insert( std::pair<DataNode*, unsigned long>( (*dataIter), (*dataIter)->AddObserver( itk::DeleteEvent(), command ) ) );
     }
     RoiDataChanged.Send();
   }
 }
 
 void mitk::ToolManager::SetRoiData(DataNode* data)
 {
   DataVectorType v;
 
   if(data)
   {
     v.push_back(data);
   }
   this->SetRoiData(v);
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeletedConst(const itk::Object* caller, const itk::EventObject& e)
 {
   OnOneOfTheRoiDataDeleted( const_cast<itk::Object*>(caller), e );
 }
 
 void mitk::ToolManager::OnOneOfTheRoiDataDeleted(itk::Object* caller, const itk::EventObject& itkNotUsed(e))
 {
   //MITK_INFO << "Deleted: " << (void*)caller << " Removing from roi data list." << std::endl;
   DataVectorType v;
 
   for (DataVectorType::iterator dataIter = m_RoiData.begin(); dataIter != m_RoiData.end(); ++dataIter )
   {
     //MITK_INFO << " In list: " << (void*)(*dataIter);
     if ( (void*)(*dataIter) != (void*)caller )
     {
       v.push_back( *dataIter );
       //MITK_INFO << " kept" << std::endl;
     }
     else
     {
       //MITK_INFO << " removed" << std::endl;
       m_RoiDataObserverTags.erase( *dataIter ); // no tag to remove anymore
     }
   }
   this->SetRoiData( v );
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetReferenceData()
 {
   return m_ReferenceData;
 }
 
 mitk::DataNode* mitk::ToolManager::GetReferenceData(int idx)
 {
   try
   {
     return m_ReferenceData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetWorkingData()
 {
   return m_WorkingData;
 }
 
 mitk::ToolManager::DataVectorType mitk::ToolManager::GetRoiData()
 {
   return m_RoiData;
 }
 
 mitk::DataNode* mitk::ToolManager::GetRoiData(int idx)
 {
   try
   {
     return m_RoiData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 mitk::DataStorage* mitk::ToolManager::GetDataStorage()
 {
   if ( m_DataStorage.IsNotNull() )
   {
     return m_DataStorage;
   }
   else
   {
     return NULL;
   }
 }
 
 void mitk::ToolManager::SetDataStorage(DataStorage& storage)
 {
   m_DataStorage = &storage;
 }
 
 
 
 mitk::DataNode* mitk::ToolManager::GetWorkingData(int idx)
 {
   try
   {
     return m_WorkingData.at(idx);
   }
   catch(std::exception&)
   {
     return NULL;
   }
 }
 
 int mitk::ToolManager::GetActiveToolID()
 {
   return m_ActiveToolID;
 }
 
 mitk::Tool* mitk::ToolManager::GetActiveTool()
 {
   return m_ActiveTool;
 }
 
 void mitk::ToolManager::RegisterClient()
 {
   if ( m_RegisteredClients < 1 )
   {
     if ( m_ActiveTool )
     {
       m_ActiveTool->Activated();
       GlobalInteraction::GetInstance()->AddListener( m_ActiveTool );
     }
   }
   ++m_RegisteredClients;
 }
 
 void mitk::ToolManager::UnregisterClient()
 {
   if ( m_RegisteredClients < 1) return;
 
   --m_RegisteredClients;
   if ( m_RegisteredClients < 1 )
   {
     if ( m_ActiveTool )
     {
       m_ActiveTool->Deactivated();
       GlobalInteraction::GetInstance()->RemoveListener( m_ActiveTool );
     }
   }
 }
 
 int mitk::ToolManager::GetToolID( const Tool* tool )
 {
   int id(0);
   for ( ToolVectorType::iterator iter = m_Tools.begin();
     iter != m_Tools.end();
     ++iter, ++id )
   {
     if ( tool == iter->GetPointer() )
     {
       return id;
     }
   }
   return -1;
 }
 
 
 void mitk::ToolManager::OnNodeRemoved(const mitk::DataNode* node)
 {
   //check if the data of the node is typeof Image
   /*if(dynamic_cast<mitk::Image*>(node->GetData()))
   {*/
     //check all storage vectors
     OnOneOfTheReferenceDataDeleted(const_cast<mitk::DataNode*>(node), itk::DeleteEvent());
     OnOneOfTheRoiDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
     OnOneOfTheWorkingDataDeleted(const_cast<mitk::DataNode*>(node),itk::DeleteEvent());
   //}
 }
 
diff --git a/Modules/Segmentation/Controllers/mitkToolManager.h b/Modules/Segmentation/Controllers/mitkToolManager.h
index 925371baf1..1ffb10e8a9 100644
--- a/Modules/Segmentation/Controllers/mitkToolManager.h
+++ b/Modules/Segmentation/Controllers/mitkToolManager.h
@@ -1,295 +1,298 @@
 /*===================================================================
 
 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 mitkToolManager_h_Included
 #define mitkToolManager_h_Included
 
 #include "mitkTool.h"
 #include "SegmentationExports.h"
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "mitkWeakPointer.h"
 #include "mitkServiceReference.h"
 
 #pragma GCC visibility push(default)
 #include <itkEventObject.h>
 #pragma GCC visibility pop
 
 #include <vector>
 #include <map>
 
 namespace mitk
 {
 
 class Image;
 class PlaneGeometry;
 
 /**
   \brief Manages and coordinates instances of mitk::Tool.
 
   \sa QmitkToolSelectionBox
   \sa QmitkToolReferenceDataSelectionBox
   \sa QmitkToolWorkingDataSelectionBox
   \sa Tool
   \sa QmitkSegmentationView
 
   \ingroup Interaction
   \ingroup ToolManagerEtAl
 
   There is a separate page describing the general design of QmitkSegmentationView: \ref QmitkSegmentationTechnicalPage
 
   This class creates and manages several instances of mitk::Tool.
 
   \li ToolManager creates instances of mitk::Tool by asking the itk::ObjectFactory to list all known implementations of mitk::Tool.
       As a result, one has to implement both a subclass of mitk::Tool and a matching subclass of itk::ObjectFactoryBase that is registered
       to the top-level itk::ObjectFactory. For an example, see mitkContourToolFactory.h. (this limitiation of one-class-one-factory is due
       to the implementation of itk::ObjectFactory).
       In MITK, the right place to register the factories to itk::ObjectFactory is the mitk::QMCoreObjectFactory or mitk::SBCoreObjectFactory.
 
    \li One (and only one - or none at all) of the registered tools can be activated using ActivateTool. This tool is registered to mitk::GlobalInteraction
       as a listener and will receive all mouse clicks and keyboard strokes that get into the MITK event mechanism. Tools are automatically
       unregistered from GlobalInteraction when no clients are registered to ToolManager (see RegisterClient()).
 
    \li ToolManager knows a set of "reference" DataNodes and a set of "working" DataNodes. The first application are segmentation tools, where the
       reference is the original image and the working data the (kind of) binary segmentation. However, ToolManager is implemented more generally, so that
       there could be other tools that work, e.g., with surfaces.
 
   \li Any "user/client" of ToolManager, i.e. every functionality that wants to use a tool, should call RegisterClient when the tools should be active.
       ToolManager keeps track of how many clients want it to be used, and when this count reaches zero, it unregistes the active Tool from GlobalInteraction.
       In "normal" settings, the functionality does not need to care about that if it uses a QmitkToolSelectionBox, which does exactly that when it is
       enabled/disabled.
 
   \li There is a set of events that are sent by ToolManager. At the moment these are TODO update documentation:
       - mitk::ToolReferenceDataChangedEvent whenever somebody calls SetReferenceData. Most of the time this actually means that the data has changed, but
         there might be cases where the same data is passed to SetReferenceData a second time, so don't rely on the assumption that something actually changed.
       - mitk::ToolSelectedEvent is sent when a (truly) different tool was activated. In reaction to this event you can ask for the active Tool using
         GetActiveTool or GetActiveToolID (where NULL or -1 indicate that NO tool is active at the moment).
 
   Design descisions:
 
   \li Not a singleton, because there could be two functionalities using tools, each one with different reference/working data.
 
   $Author$
 */
 class Segmentation_EXPORT ToolManager : public itk::Object
 {
   public:
 
     typedef std::vector<Tool::Pointer>         ToolVectorType;
     typedef std::vector<Tool::ConstPointer>    ToolVectorTypeConst;
     typedef std::vector<DataNode*> DataVectorType; // has to be observed for delete events!
     typedef std::map<DataNode*, unsigned long> NodeTagMapType;
 
     Message<> NodePropertiesChanged;
     Message<> NewNodesGenerated;
     Message1<DataVectorType*> NewNodeObjectsGenerated;
 
     Message<> ActiveToolChanged;
     Message<> ReferenceDataChanged;
     Message<> WorkingDataChanged;
     Message<> RoiDataChanged;
 
     Message1<std::string> ToolErrorMessage;
     Message1<std::string> GeneralToolMessage;
 
     mitkClassMacro(ToolManager, itk::Object);
     mitkNewMacro1Param(ToolManager, DataStorage*);
 
     /**
       \brief Gives you a list of all tools.
       This is const on purpose.
      */
     const ToolVectorTypeConst GetTools();
 
     int GetToolID( const Tool* tool );
 
     /*
       \param id The tool of interest.
       Counting starts with 0.
     */
     Tool* GetToolById(int id);
 
     /**
       \param id The tool to activate. Provide -1 for disabling any tools.
       Counting starts with 0.
       Registeres a listner for NodeRemoved event at DataStorage (see mitk::ToolManager::OnNodeRemoved).
     */
     bool ActivateTool(int id);
 
     template <class T>
     int GetToolIdByToolType()
     {
       int id = 0;
       for ( ToolVectorType::iterator iter = m_Tools.begin();
             iter != m_Tools.end();
             ++iter, ++id )
       {
         if ( dynamic_cast<T*>(iter->GetPointer()) )
         {
           return id;
         }
       }
       return -1;
     }
 
     /**
       \return -1 for "No tool is active"
     */
     int GetActiveToolID();
 
     /**
       \return NULL for "No tool is active"
     */
     Tool* GetActiveTool();
 
     /*
       \brief Set a list of data/images as reference objects.
     */
     void SetReferenceData(DataVectorType);
 
     /*
       \brief Set single data item/image as reference object.
     */
     void SetReferenceData(DataNode*);
 
     /*
       \brief Set a list of data/images as working objects.
     */
     void SetWorkingData(DataVectorType);
 
     /*
       \brief Set single data item/image as working object.
     */
     void SetWorkingData(DataNode*);
 
     /*
       \brief Set a list of data/images as roi objects.
     */
     void SetRoiData(DataVectorType);
 
     /*
       \brief Set a single data item/image as roi object.
     */
     void SetRoiData(DataNode*);
 
     /*
       \brief Get the list of reference data.
     */
     DataVectorType GetReferenceData();
 
     /*
       \brief Get the current reference data.
       \warning If there is a list of items, this method will only return the first list item.
     */
     DataNode* GetReferenceData(int);
 
     /*
       \brief Get the list of working data.
     */
     DataVectorType GetWorkingData();
 
     /*
       \brief Get the current working data.
       \warning If there is a list of items, this method will only return the first list item.
     */
     DataNode* GetWorkingData(int);
 
     /*
      \brief Get the current roi data
      */
     DataVectorType GetRoiData();
 
     /*
      \brief Get the roi data at position idx
      */
     DataNode* GetRoiData(int idx);
 
     DataStorage* GetDataStorage();
     void SetDataStorage(DataStorage& storage);
 
     /*
       \brief Tell that someone is using tools.
       GUI elements should call this when they become active. This method increases an internal "client count". Tools
       are only registered to GlobalInteraction when this count is greater than 0. This is useful to automatically deactivate
       tools when you hide their GUI elements.
      */
     void RegisterClient();
 
     /*
       \brief Tell that someone is NOT using tools.
       GUI elements should call this when they become active. This method increases an internal "client count". Tools
       are only registered to GlobalInteraction when this count is greater than 0. This is useful to automatically deactivate
       tools when you hide their GUI elements.
      */
     void UnregisterClient();
 
+    /** \brief Initialize all classes derived from mitk::Tool by itkObjectFactoy */
+    void InitializeTools();
+
     void OnOneOfTheReferenceDataDeletedConst(const itk::Object* caller, const itk::EventObject& e);
     void OnOneOfTheReferenceDataDeleted           (itk::Object* caller, const itk::EventObject& e);
 
     void OnOneOfTheWorkingDataDeletedConst(const itk::Object* caller, const itk::EventObject& e);
     void OnOneOfTheWorkingDataDeleted           (itk::Object* caller, const itk::EventObject& e);
 
     void OnOneOfTheRoiDataDeletedConst(const itk::Object* caller, const itk::EventObject& e);
     void OnOneOfTheRoiDataDeleted           (itk::Object* caller, const itk::EventObject& e);
 
     /*
      \brief Connected to tool's messages
 
      This method just resends error messages coming from any of the tools. This way clients (GUIs) only have to observe one message.
      */
     void OnToolErrorMessage(std::string s);
     void OnGeneralToolMessage(std::string s);
 
   protected:
 
     /**
       You may specify a list of tool "groups" that should be available for this ToolManager. Every Tool can report its group
       as a string. This constructor will try to find the tool's group inside the supplied string. If there is a match,
       the tool is accepted. Effectively, you can provide a human readable list like "default, lymphnodevolumetry, oldERISstuff".
     */
     ToolManager(DataStorage* storage); // purposely hidden
     virtual ~ToolManager();
 
     ToolVectorType m_Tools;
 
     Tool* m_ActiveTool;
     int m_ActiveToolID;
 
     DataVectorType m_ReferenceData;
     NodeTagMapType  m_ReferenceDataObserverTags;
 
     DataVectorType m_WorkingData;
     NodeTagMapType  m_WorkingDataObserverTags;
 
     DataVectorType m_RoiData;
     NodeTagMapType m_RoiDataObserverTags;
 
     int m_RegisteredClients;
 
     WeakPointer<DataStorage> m_DataStorage;
 
     /// \brief Callback for NodeRemove events
     void OnNodeRemoved(const mitk::DataNode* node);
 
   private:
 
     //std::map<ServiceReference, EventConfig> m_DisplayInteractorConfigs;
 };
 
 } // namespace
 
 #endif
 
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index 677f6e93a3..d7004d600c 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,1147 +1,1148 @@
 /*===================================================================
 
 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 "mitkProperties.h"
 #include "mitkSegTool2D.h"
 
 #include "QmitkStdMultiWidget.h"
 #include "QmitkNewSegmentationDialog.h"
 
 #include <QMessageBox>
 
 #include <berryIWorkbenchPage.h>
 
 #include "QmitkSegmentationView.h"
 #include "QmitkSegmentationOrganNamesHandling.cpp"
 
 #include <mitkSurfaceToImageFilter.h>
 
 #include "mitkVtkResliceInterpolationProperty.h"
 
 #include "mitkGetModuleContext.h"
 #include "mitkModule.h"
 #include "mitkModuleRegistry.h"
 #include "mitkModuleResource.h"
 #include "mitkStatusBar.h"
 #include "mitkApplicationCursor.h"
 
 #include "mitkSegmentationObjectFactory.h"
 
 //micro service to get the ToolManager instance
 #include "mitkToolManagerProvider.h"
 
 const std::string QmitkSegmentationView::VIEW_ID =
     "org.mitk.views.segmentation";
 
 // public methods
 
 QmitkSegmentationView::QmitkSegmentationView()
 :m_Parent(NULL)
 ,m_Controls(NULL)
 ,m_MultiWidget(NULL)
 ,m_DataSelectionChanged(false)
 ,m_MouseCursorSet(false)
 {
   RegisterSegmentationObjectFactory();
   mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
   mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
   mitk::NodePredicateDataType::Pointer isQbi = mitk::NodePredicateDataType::New("QBallImage");
   mitk::NodePredicateOr::Pointer isDiffusionImage = mitk::NodePredicateOr::New(isDwi, isDti);
   isDiffusionImage = mitk::NodePredicateOr::New(isDiffusionImage, isQbi);
   m_IsOfTypeImagePredicate = mitk::NodePredicateOr::New(isDiffusionImage, mitk::TNodePredicateDataType<mitk::Image>::New());
 
   m_IsBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   m_IsNotBinaryPredicate = mitk::NodePredicateNot::New( m_IsBinaryPredicate );
 
   m_IsNotABinaryImagePredicate = mitk::NodePredicateAnd::New( m_IsOfTypeImagePredicate, m_IsNotBinaryPredicate );
   m_IsABinaryImagePredicate = mitk::NodePredicateAnd::New( m_IsOfTypeImagePredicate, m_IsBinaryPredicate);
 }
 
 QmitkSegmentationView::~QmitkSegmentationView()
 {
   delete m_Controls;
 }
 
 void QmitkSegmentationView::NewNodesGenerated()
 {
   MITK_WARN<<"Use of deprecated function: NewNodesGenerated!! This function is empty and will be removed in the next time!";
 }
 
 void QmitkSegmentationView::NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType* nodes)
 {
   if (!nodes) return;
 
   mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   if (!toolManager) return;
   for (mitk::ToolManager::DataVectorType::iterator iter = nodes->begin(); iter != nodes->end(); ++iter)
   {
     this->FireNodeSelected( *iter );
     // only last iteration meaningful, multiple generated objects are not taken into account here
   }
 }
 
 void QmitkSegmentationView::Visible()
 {
   if (m_DataSelectionChanged)
   {
     this->OnSelectionChanged(this->GetDataManagerSelection());
   }
 }
 
 void QmitkSegmentationView::Activated()
 {
   // should be moved to ::BecomesVisible() or similar
   if( m_Controls )
   {
     //m_Controls->m_ManualToolSelectionBox2D->SetAutoShowNamesWidth(m_Controls->m_ManualToolSelectionBox2D->minimumSizeHint().width()+1);
     m_Controls->m_ManualToolSelectionBox2D->SetAutoShowNamesWidth(250);
     m_Controls->m_ManualToolSelectionBox2D->setEnabled( true );
     //m_Controls->m_ManualToolSelectionBox3D->SetAutoShowNamesWidth(m_Controls->m_ManualToolSelectionBox3D->minimumSizeHint().width()+1);
     m_Controls->m_ManualToolSelectionBox3D->SetAutoShowNamesWidth(260);
     m_Controls->m_ManualToolSelectionBox3D->setEnabled( true );
 //    m_Controls->m_OrganToolSelectionBox->setEnabled( true );
 //    m_Controls->m_LesionToolSelectionBox->setEnabled( true );
 
 //    m_Controls->m_SlicesInterpolator->Enable3DInterpolation( m_Controls->widgetStack->currentWidget() == m_Controls->pageManual );
 
 
     mitk::DataStorage::SetOfObjects::ConstPointer segmentations = this->GetDefaultDataStorage()->GetSubset( m_IsABinaryImagePredicate );
 
     mitk::DataStorage::SetOfObjects::ConstPointer image = this->GetDefaultDataStorage()->GetSubset( m_IsNotABinaryImagePredicate );
     if (!image->empty()) {
       OnSelectionChanged(*image->begin());
     }
 
     for ( mitk::DataStorage::SetOfObjects::const_iterator iter = segmentations->begin();
         iter != segmentations->end();
         ++iter)
     {
       mitk::DataNode* node = *iter;
       itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
       command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
       m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( node, node->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
 
       itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
       command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
       m_BinaryPropertyObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( node, node->GetProperty("binary")->AddObserver( itk::ModifiedEvent(), command2 ) ) );
     }
   }
   this->SetToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), m_Controls->segImageSelector->GetSelectedNode());
 }
 
 void QmitkSegmentationView::Deactivated()
 {
   if( m_Controls )
   {
     m_Controls->m_ManualToolSelectionBox2D->setEnabled( false );
     m_Controls->m_ManualToolSelectionBox3D->setEnabled( false );
     //deactivate all tools
     mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 //    m_Controls->m_OrganToolSelectionBox->setEnabled( false );
 //    m_Controls->m_LesionToolSelectionBox->setEnabled( false );
     m_Controls->m_SlicesInterpolator->EnableInterpolation( false );
 
     //Removing all observers
     for ( NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter )
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver( (*dataIter).second );
     }
     m_WorkingDataObserverTags.clear();
 
     for ( NodeTagMapType::iterator dataIter = m_BinaryPropertyObserverTags.begin(); dataIter != m_BinaryPropertyObserverTags.end(); ++dataIter )
     {
       (*dataIter).first->GetProperty("binary")->RemoveObserver( (*dataIter).second );
     }
     m_BinaryPropertyObserverTags.clear();
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTK plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
     service->RemoveAllPlanePositions();
   }
 }
 
 void QmitkSegmentationView::StdMultiWidgetAvailable( QmitkStdMultiWidget& stdMultiWidget )
 {
   SetMultiWidget(&stdMultiWidget);
 }
 
 void QmitkSegmentationView::StdMultiWidgetNotAvailable()
 {
   SetMultiWidget(NULL);
 }
 
 void QmitkSegmentationView::StdMultiWidgetClosed( QmitkStdMultiWidget& /*stdMultiWidget*/ )
 {
   SetMultiWidget(NULL);
 }
 
 void QmitkSegmentationView::SetMultiWidget(QmitkStdMultiWidget* multiWidget)
 {
   // save the current multiwidget as the working widget
   m_MultiWidget = multiWidget;
 
   if (m_Parent)
   {
     m_Parent->setEnabled(m_MultiWidget);
   }
 
   // tell the interpolation about toolmanager and multiwidget (and data storage)
   if (m_Controls && m_MultiWidget)
   {
     mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
     m_Controls->m_SlicesInterpolator->SetDataStorage( this->GetDefaultDataStorage());
     QList<mitk::SliceNavigationController*> controllers;
     controllers.push_back(m_MultiWidget->GetRenderWindow1()->GetSliceNavigationController());
     controllers.push_back(m_MultiWidget->GetRenderWindow2()->GetSliceNavigationController());
     controllers.push_back(m_MultiWidget->GetRenderWindow3()->GetSliceNavigationController());
     m_Controls->m_SlicesInterpolator->Initialize( toolManager, controllers );
   }
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   m_AutoSelectionEnabled = prefs->GetBool("auto selection", false);
 }
 
 void QmitkSegmentationView::CreateNewSegmentation()
 {
 
   mitk::DataNode::Pointer node = mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0);
   if (node.IsNotNull())
   {
     mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
     if (image.IsNotNull())
     {
       if (image->GetDimension()>1)
       {
         // ask about the name and organ type of the new segmentation
         QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog( m_Parent ); // needs a QWidget as parent, "this" is not QWidget
 
         QString storedList = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
         QStringList organColors;
         if (storedList.isEmpty())
         {
           organColors = GetDefaultOrganColorString();
         }
         else
         {
           /*
           a couple of examples of how organ names are stored:
 
           a simple item is built up like 'name#AABBCC' where #AABBCC is the hexadecimal notation of a color as known from HTML
 
           items are stored separated by ';'
           this makes it necessary to escape occurrences of ';' in name.
           otherwise the string "hugo;ypsilon#AABBCC;eugen#AABBCC" could not be parsed as two organs
           but we would get "hugo" and "ypsilon#AABBCC" and "eugen#AABBCC"
 
           so the organ name "hugo;ypsilon" is stored as "hugo\;ypsilon"
           and must be unescaped after loading
 
           the following lines could be one split with Perl's negative lookbehind
           */
 
           // recover string list from BlueBerry view's preferences
           QString storedString = QString::fromStdString( this->GetPreferences()->GetByteArray("Organ-Color-List","") );
           MITK_DEBUG << "storedString: " << storedString.toStdString();
           // match a string consisting of any number of repetitions of either "anything but ;" or "\;". This matches everything until the next unescaped ';'
           QRegExp onePart("(?:[^;]|\\\\;)*");
           MITK_DEBUG << "matching " << onePart.pattern().toStdString();
           int count = 0;
           int pos = 0;
           while( (pos = onePart.indexIn( storedString, pos )) != -1 )
           {
             ++count;
             int length = onePart.matchedLength();
             if (length == 0) break;
             QString matchedString = storedString.mid(pos, length);
             MITK_DEBUG << "   Captured length " << length << ": " << matchedString.toStdString();
             pos += length + 1; // skip separating ';'
 
             // unescape possible occurrences of '\;' in the string
             matchedString.replace("\\;", ";");
 
             // add matched string part to output list
             organColors << matchedString;
           }
             MITK_DEBUG << "Captured " << count << " organ name/colors";
           }
 
     dialog->SetSuggestionList( organColors );
 
     int dialogReturnValue = dialog->exec();
 
     if ( dialogReturnValue == QDialog::Rejected ) return; // user clicked cancel or pressed Esc or something similar
 
     // ask the user about an organ type and name, add this information to the image's (!) propertylist
     // create a new image of the same dimensions and smallest possible pixel type
     mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
     mitk::Tool* firstTool = toolManager->GetToolById(0);
     if (firstTool)
     {
       try
       {
         std::string newNodeName = dialog->GetSegmentationName().toStdString();
         if(newNodeName.empty())
           newNodeName = "no_name";
 
       mitk::DataNode::Pointer emptySegmentation =
         firstTool->CreateEmptySegmentationNode( image, newNodeName, dialog->GetColor() );
 
       // initialize showVolume to false to prevent recalculating the volume while working on the segmentation
       emptySegmentation->SetProperty( "showVolume", mitk::BoolProperty::New( false ) );
 
       if (!emptySegmentation) return; // could be aborted by user
 
       UpdateOrganList( organColors, dialog->GetSegmentationName(), dialog->GetColor() );
 
       /*
       escape ';' here (replace by '\;'), see longer comment above
       */
             std::string stringForStorage = organColors.replaceInStrings(";","\\;").join(";").toStdString();
             MITK_DEBUG << "Will store: " << stringForStorage;
             this->GetPreferences()->PutByteArray("Organ-Color-List", stringForStorage );
             this->GetPreferences()->Flush();
 
             if(mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0))
             {
               mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0)->SetSelected(false);
             }
             emptySegmentation->SetSelected(true);
             this->GetDefaultDataStorage()->Add( emptySegmentation, node ); // add as a child, because the segmentation "derives" from the original
 
             itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
             command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
             m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( emptySegmentation, emptySegmentation->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
 
             itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
             command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
             m_BinaryPropertyObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( emptySegmentation, emptySegmentation->GetProperty("binary")->AddObserver( itk::ModifiedEvent(), command2 ) ) );
 
             this->ApplyDisplayOptions( emptySegmentation );
             this->FireNodeSelected( emptySegmentation );
             this->OnSelectionChanged( emptySegmentation );
 
             m_Controls->segImageSelector->SetSelectedNode(emptySegmentation);
           }
           catch (std::bad_alloc)
           {
             QMessageBox::warning(NULL,"Create new segmentation","Could not allocate memory for new segmentation");
           }
         }
       }
       else
       {
         QMessageBox::information(NULL,"Segmentation","Segmentation is currently not supported for 2D images");
       }
     }
   }
   else
   {
     MITK_ERROR << "'Create new segmentation' button should never be clickable unless a patient image is selected...";
   }
 }
 
 void QmitkSegmentationView::OnWorkingNodeVisibilityChanged()
 {
   mitk::DataNode* selectedNode = m_Controls->segImageSelector->GetSelectedNode();
   bool selectedNodeIsVisible = selectedNode->IsVisible(mitk::BaseRenderer::GetInstance(
                                                          mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1")));
 
   if (m_Controls->tab2DTools->isVisible() && !selectedNodeIsVisible)
   {
     m_Controls->m_ManualToolSelectionBox2D->setEnabled(false);
     this->UpdateWarningLabel("The selected segmentation is currently not visible!");
     m_Controls->m_SlicesInterpolator->Show3DInterpolationResult(false);
     mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
   }
   else
   {
       m_Controls->m_ManualToolSelectionBox2D->setEnabled(true);
     this->UpdateWarningLabel("");
     //Trigger 3d interpolation is selected segmentation is visible again
     mitk::SurfaceInterpolationController::GetInstance()->Modified();
   }
 }
 
 void QmitkSegmentationView::OnBinaryPropertyChanged()
 {
   mitk::DataStorage::SetOfObjects::ConstPointer patImages = m_Controls->patImageSelector->GetNodes();
 
   bool isBinary(false);
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = patImages->Begin(); it != patImages->End(); ++it)
   {
     const mitk::DataNode* node = it->Value();
     node->GetBoolProperty("binary", isBinary);
 
     if(isBinary)
     {
       m_Controls->patImageSelector->RemoveNode(node);
       m_Controls->segImageSelector->AddNode(node);
       this->SetToolManagerSelection(NULL,NULL);
       return;
     }
   }
 
   mitk::DataStorage::SetOfObjects::ConstPointer segImages = m_Controls->segImageSelector->GetNodes();
 
   isBinary = true;
 
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = segImages->Begin(); it != segImages->End(); ++it)
   {
     const mitk::DataNode* node = it->Value();
     node->GetBoolProperty("binary", isBinary);
 
     if(!isBinary)
     {
       m_Controls->segImageSelector->RemoveNode(node);
       m_Controls->patImageSelector->AddNode(node);
       if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0) == node)
         mitk::ToolManagerProvider::GetInstance()->GetToolManager()->SetWorkingData(NULL);
       return;
     }
   }
 }
 
 void QmitkSegmentationView::NodeAdded(const mitk::DataNode *node)
 {
   bool isBinary (false);
   bool isHelperObject (false);
   node->GetBoolProperty("binary", isBinary);
   node->GetBoolProperty("helper object", isHelperObject);
   if (m_AutoSelectionEnabled)
   {
     if (!isBinary && dynamic_cast<mitk::Image*>(node->GetData()))
     {
       FireNodeSelected(const_cast<mitk::DataNode*>(node));
     }
   }
   if (isBinary && !isHelperObject)
   {
     itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
     command->SetCallbackFunction(this, &QmitkSegmentationView::OnWorkingNodeVisibilityChanged);
     m_WorkingDataObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( const_cast<mitk::DataNode*>(node), node->GetProperty("visible")->AddObserver( itk::ModifiedEvent(), command ) ) );
 
     itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command2 = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
     command2->SetCallbackFunction(this, &QmitkSegmentationView::OnBinaryPropertyChanged);
     m_BinaryPropertyObserverTags.insert( std::pair<mitk::DataNode*, unsigned long>( const_cast<mitk::DataNode*>(node), node->GetProperty("binary")->AddObserver( itk::ModifiedEvent(), command2 ) ) );
 
     this->ApplyDisplayOptions(  const_cast<mitk::DataNode*>(node) );
   }
 }
 
 void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
 {
   bool isSeg(false);
   bool isHelperObject(false);
   node->GetBoolProperty("helper object", isHelperObject);
   node->GetBoolProperty("binary", isSeg);
 
   mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
   if(isSeg && !isHelperObject && image)
   {
     //First of all remove all possible contour markers of the segmentation
     mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(node, mitk::NodePredicateProperty::New("isContourMarker"
                                                                             , mitk::BoolProperty::New(true)));
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTK plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
 
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
     {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
 
       service->RemovePlanePosition(id);
 
       this->GetDataStorage()->Remove(it->Value());
     }
 
     if ((mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0) == node) && m_Controls->patImageSelector->GetSelectedNode().IsNotNull())
     {
       this->SetToolManagerSelection(mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0), NULL);
       this->UpdateWarningLabel("Select or create a segmentation!");
     }
 
     mitk::SurfaceInterpolationController::GetInstance()->RemoveSegmentationFromContourList(image);
   }
   mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
   //Since the binary property could be changed during runtime by the user
   if (image && !isHelperObject)
   {
       node->GetProperty("visible")->RemoveObserver( m_WorkingDataObserverTags[tempNode] );
       m_WorkingDataObserverTags.erase(tempNode);
       node->GetProperty("binary")->RemoveObserver( m_BinaryPropertyObserverTags[tempNode] );
       m_BinaryPropertyObserverTags.erase(tempNode);
   }
 
   if((mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0) == node))
   {
     //as we don't know which node was actually removed e.g. our reference node, disable 'New Segmentation' button.
     //consider the case that there is no more image in the datastorage
     this->SetToolManagerSelection(NULL, NULL);
   }
 }
 
 //void QmitkSegmentationView::CreateSegmentationFromSurface()
 //{
 //  mitk::DataNode::Pointer surfaceNode =
 //      m_Controls->MaskSurfaces->GetSelectedNode();
 //  mitk::Surface::Pointer surface(0);
 //  if(surfaceNode.IsNotNull())
 //    surface = dynamic_cast<mitk::Surface*> ( surfaceNode->GetData() );
 //  if(surface.IsNull())
 //  {
 //    this->HandleException( "No surface selected.", m_Parent, true);
 //    return;
 //  }
 
 //  mitk::DataNode::Pointer imageNode
 //      = mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0);
 //  mitk::Image::Pointer image(0);
 //  if (imageNode.IsNotNull())
 //    image = dynamic_cast<mitk::Image*>( imageNode->GetData() );
 //  if(image.IsNull())
 //  {
 //    this->HandleException( "No image selected.", m_Parent, true);
 //    return;
 //  }
 
 //  mitk::SurfaceToImageFilter::Pointer s2iFilter
 //      = mitk::SurfaceToImageFilter::New();
 
 //  s2iFilter->MakeOutputBinaryOn();
 //  s2iFilter->SetInput(surface);
 //  s2iFilter->SetImage(image);
 //  s2iFilter->Update();
 
 //  mitk::DataNode::Pointer resultNode = mitk::DataNode::New();
 //  std::string nameOfResultImage = imageNode->GetName();
 //  nameOfResultImage.append(surfaceNode->GetName());
 //  resultNode->SetProperty("name", mitk::StringProperty::New(nameOfResultImage) );
 //  resultNode->SetProperty("binary", mitk::BoolProperty::New(true) );
 //  resultNode->SetData( s2iFilter->GetOutput() );
 
 //  this->GetDataStorage()->Add(resultNode, imageNode);
 
 //}
 
 //void QmitkSegmentationView::ToolboxStackPageChanged(int id)
 //{
 //  // interpolation only with manual tools visible
 //  m_Controls->m_SlicesInterpolator->EnableInterpolation( id == 0 );
 
 //  if( id == 0 )
 //  {
 //    mitk::DataNode::Pointer workingData =   mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0);
 //    if( workingData.IsNotNull() )
 //    {
 //      m_Controls->segImageSelector->setCurrentIndex( m_Controls->segImageSelector->Find(workingData) );
 //    }
 //  }
 
 //  // this is just a workaround, should be removed when all tools support 3D+t
 //  if (id==2) // lesions
 //  {
 //    mitk::DataNode::Pointer node = mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0);
 //    if (node.IsNotNull())
 //    {
 //      mitk::Image::Pointer image = dynamic_cast<mitk::Image*>( node->GetData() );
 //      if (image.IsNotNull())
 //      {
 //        if (image->GetDimension()>3)
 //        {
 //          m_Controls->widgetStack->setCurrentIndex(0);
 //          QMessageBox::information(NULL,"Segmentation","Lesion segmentation is currently not supported for 4D images");
 //        }
 //      }
 //    }
 //  }
 //}
 
 // protected
 
 void QmitkSegmentationView::OnPatientComboBoxSelectionChanged( const mitk::DataNode* node )
 {
   //mitk::DataNode* selectedNode = const_cast<mitk::DataNode*>(node);
   if( node != NULL )
   {
     this->UpdateWarningLabel("");
     mitk::DataNode* segNode = m_Controls->segImageSelector->GetSelectedNode();
     if (segNode)
     {
       mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDefaultDataStorage()->GetSources( segNode, m_IsNotABinaryImagePredicate );
       bool isSourceNode(false);
 
       for (mitk::DataStorage::SetOfObjects::ConstIterator it = possibleParents->Begin(); it != possibleParents->End(); it++)
       {
         if (it.Value() == node)
           isSourceNode = true;
       }
 
       if ( !isSourceNode && (!this->CheckForSameGeometry(segNode, node) || possibleParents->Size() > 0 ))
       {
         this->SetToolManagerSelection(node, NULL);
         this->UpdateWarningLabel("The selected patient image does not\nmatch with the selected segmentation!");
       }
       else if ((!isSourceNode && this->CheckForSameGeometry(segNode, node)) || isSourceNode )
       {
         this->SetToolManagerSelection(node, segNode);
         //Doing this we can assure that the segmenation is always visible if the segmentation and the patient image are
         //loaded separately
         int layer(10);
         node->GetIntProperty("layer", layer);
         layer++;
         segNode->SetProperty("layer", mitk::IntProperty::New(layer));
         this->UpdateWarningLabel("");
       }
     }
     else
     {
       this->SetToolManagerSelection(node, NULL);
       this->UpdateWarningLabel("Select or create a segmentation");
     }
   }
   else
   {
     this->UpdateWarningLabel("Please load an image!");
   }
 }
 
 void QmitkSegmentationView::OnSegmentationComboBoxSelectionChanged(const mitk::DataNode *node)
 {
   if ( node == 0)
     return;
 
   mitk::DataNode* refNode = m_Controls->patImageSelector->GetSelectedNode();
 
   if (m_AutoSelectionEnabled)
   {
     this->OnSelectionChanged(const_cast<mitk::DataNode*>(node));
   }
   else
   {
     mitk::DataStorage::SetOfObjects::ConstPointer possibleParents = this->GetDefaultDataStorage()->GetSources( node, m_IsNotABinaryImagePredicate );
 
     if ( possibleParents->Size() == 1 )
     {
       mitk::DataNode* parentNode = possibleParents->ElementAt(0);
 
       if (parentNode != refNode)
       {
         this->UpdateWarningLabel("The selected segmentation does not\nmatch with the selected patient image!");
         this->SetToolManagerSelection(NULL, node);
       }
       else
       {
         this->UpdateWarningLabel("");
         this->SetToolManagerSelection(refNode, node);
       }
 
     }
     else if (refNode && this->CheckForSameGeometry(node, refNode))
     {
       this->UpdateWarningLabel("");
       this->SetToolManagerSelection(refNode, node);
     }
     else if (!refNode || !this->CheckForSameGeometry(node, refNode))
     {
       this->UpdateWarningLabel("Please select or load the according patient image!");
     }
   }
   if (!node->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))))
     this->UpdateWarningLabel("The selected segmentation is currently not visible!");
 }
 
 void QmitkSegmentationView::OnShowMarkerNodes (bool state)
 {
   mitk::SegTool2D::Pointer manualSegmentationTool;
 
   unsigned int numberOfExistingTools = mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetTools().size();
 
   for(unsigned int i = 0; i < numberOfExistingTools; i++)
   {
     manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetToolById(i));
 
     if (manualSegmentationTool)
     {
       if(state == true)
       {
         manualSegmentationTool->SetShowMarkerNodes( true );
       }
       else
       {
         manualSegmentationTool->SetShowMarkerNodes( false );
       }
     }
   }
 }
 
 
 void QmitkSegmentationView::OnSelectionChanged(mitk::DataNode* node)
 {
   std::vector<mitk::DataNode*> nodes;
   nodes.push_back( node );
   this->OnSelectionChanged( nodes );
 }
 
 //void QmitkSegmentationView::OnSurfaceSelectionChanged()
 //{
 //  // if Image and Surface are selected, enable button
 //  if ( (m_Controls->patImageSelector->GetSelectedNode().IsNull()) ||
 //  (m_Controls->MaskSurfaces->GetSelectedNode().IsNull()))
 //    m_Controls->CreateSegmentationFromSurface->setEnabled(false);
 //  else
 //    m_Controls->CreateSegmentationFromSurface->setEnabled(true);
 //}
 
 void QmitkSegmentationView::OnSelectionChanged(std::vector<mitk::DataNode*> nodes)
 {
   if (nodes.size() != 0)
   {
     std::string markerName = "Position";
     unsigned int numberOfNodes = nodes.size();
     std::string nodeName = nodes.at( 0 )->GetName();
     if ( ( numberOfNodes == 1 ) && ( nodeName.find( markerName ) == 0) )
     {
       this->OnContourMarkerSelected( nodes.at( 0 ) );
       return;
     }
 
   }
   if (m_AutoSelectionEnabled && this->IsActivated())
   {
     if (nodes.size() == 0 && m_Controls->patImageSelector->GetSelectedNode().IsNull())
     {
       SetToolManagerSelection(NULL,NULL);
     }
     else if (nodes.size() == 1)
     {
       mitk::DataNode::Pointer selectedNode = nodes.at(0);
       if(selectedNode.IsNull())
       {
         return;
       }
 
       mitk::Image::Pointer selectedImage = dynamic_cast<mitk::Image*>(selectedNode->GetData());
       if (selectedImage.IsNull())
       {
         SetToolManagerSelection(NULL,NULL);
         return;
       }
       else
       {
         bool isASegmentation(false);
         selectedNode->GetBoolProperty("binary", isASegmentation);
 
         if (isASegmentation)
         {
 
           //If a segmentation is selected find a possible reference image:
           mitk::DataStorage::SetOfObjects::ConstPointer sources = this->GetDataStorage()->GetSources(selectedNode, m_IsNotABinaryImagePredicate);
           mitk::DataNode::Pointer refNode;
           if (sources->Size() != 0)
           {
             refNode = sources->ElementAt(0);
 
             refNode->SetVisibility(true);
             selectedNode->SetVisibility(true);
             SetToolManagerSelection(refNode,selectedNode);
 
             mitk::DataStorage::SetOfObjects::ConstPointer otherSegmentations = this->GetDataStorage()->GetSubset(m_IsABinaryImagePredicate);
             for(mitk::DataStorage::SetOfObjects::const_iterator iter = otherSegmentations->begin(); iter != otherSegmentations->end(); ++iter)
             {
               mitk::DataNode* node = *iter;
               if (dynamic_cast<mitk::Image*>(node->GetData()) != selectedImage.GetPointer())
                 node->SetVisibility(false);
             }
 
             mitk::DataStorage::SetOfObjects::ConstPointer otherPatientImages = this->GetDataStorage()->GetSubset(m_IsNotABinaryImagePredicate);
             for(mitk::DataStorage::SetOfObjects::const_iterator iter = otherPatientImages->begin(); iter != otherPatientImages->end(); ++iter)
             {
               mitk::DataNode* node = *iter;
               if (dynamic_cast<mitk::Image*>(node->GetData()) != dynamic_cast<mitk::Image*>(refNode->GetData()))
                 node->SetVisibility(false);
             }
           }
           else
           {
             mitk::DataStorage::SetOfObjects::ConstPointer possiblePatientImages = this->GetDataStorage()->GetSubset(m_IsNotABinaryImagePredicate);
 
             for (mitk::DataStorage::SetOfObjects::ConstIterator it = possiblePatientImages->Begin(); it != possiblePatientImages->End(); it++)
             {
               refNode = it->Value();
 
               if (this->CheckForSameGeometry(selectedNode, it->Value()))
               {
                 refNode->SetVisibility(true);
                 selectedNode->SetVisibility(true);
 
                 mitk::DataStorage::SetOfObjects::ConstPointer otherSegmentations = this->GetDataStorage()->GetSubset(m_IsABinaryImagePredicate);
                 for(mitk::DataStorage::SetOfObjects::const_iterator iter = otherSegmentations->begin(); iter != otherSegmentations->end(); ++iter)
                 {
                   mitk::DataNode* node = *iter;
                   if (dynamic_cast<mitk::Image*>(node->GetData()) != selectedImage.GetPointer())
                     node->SetVisibility(false);
                 }
 
                 mitk::DataStorage::SetOfObjects::ConstPointer otherPatientImages = this->GetDataStorage()->GetSubset(m_IsNotABinaryImagePredicate);
                 for(mitk::DataStorage::SetOfObjects::const_iterator iter = otherPatientImages->begin(); iter != otherPatientImages->end(); ++iter)
                 {
                   mitk::DataNode* node = *iter;
                   if (dynamic_cast<mitk::Image*>(node->GetData()) != dynamic_cast<mitk::Image*>(refNode->GetData()))
                     node->SetVisibility(false);
                 }
                 this->SetToolManagerSelection(refNode, selectedNode);
 
                 //Doing this we can assure that the segmenation is always visible if the segmentation and the patient image are at the
                 //same level in the datamanager
                 int layer(10);
                 refNode->GetIntProperty("layer", layer);
                 layer++;
                 selectedNode->SetProperty("layer", mitk::IntProperty::New(layer));
                 return;
               }
             }
             this->SetToolManagerSelection(NULL, selectedNode);
 
           }
         }
         else
         {
           if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0) != selectedNode)
           {
             SetToolManagerSelection(selectedNode, NULL);
             //May be a bug in the selection services. A node which is deselected will be passed as selected node to the OnSelectionChanged function
             if (!selectedNode->IsVisible(mitk::BaseRenderer::GetInstance( mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget1"))))
                 selectedNode->SetVisibility(true);
             this->UpdateWarningLabel("The selected patient image does not\nmatchwith the selected segmentation!");
           }
         }
       }
     }
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 
   }
 }
 
 void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode *node)
 {
   QmitkRenderWindow* selectedRenderWindow = 0;
   QmitkRenderWindow* RenderWindow1 =
       this->GetActiveStdMultiWidget()->GetRenderWindow1();
   QmitkRenderWindow* RenderWindow2 =
       this->GetActiveStdMultiWidget()->GetRenderWindow2();
   QmitkRenderWindow* RenderWindow3 =
       this->GetActiveStdMultiWidget()->GetRenderWindow3();
   QmitkRenderWindow* RenderWindow4 =
       this->GetActiveStdMultiWidget()->GetRenderWindow4();
   bool PlanarFigureInitializedWindow = false;
 
   // find initialized renderwindow
   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;
   }
 
   // make node visible
   if (selectedRenderWindow)
   {
     std::string nodeName = node->GetName();
     unsigned int t = nodeName.find_last_of(" ");
     unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
 
     // gets the context of the "Mitk" (Core) module (always has id 1)
     // TODO Workaround until CTL plugincontext is available
     mitk::ModuleContext* context = mitk::ModuleRegistry::GetModule(1)->GetModuleContext();
     // Workaround end
     mitk::ServiceReference serviceRef = context->GetServiceReference<mitk::PlanePositionManagerService>();
 
     mitk::PlanePositionManagerService* service = dynamic_cast<mitk::PlanePositionManagerService*>(context->GetService(serviceRef));
     selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
     selectedRenderWindow->GetRenderer()->GetDisplayGeometry()->Fit();
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
 }
 
 void QmitkSegmentationView::OnTabWidgetChanged(int id)
 {
   //always disable tools on tab changed
   mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
   //2D Tab ID = 0
   //3D Tab ID = 1
   if (id == 0)
   {
     //Hide 3D selection box, show 2D selection box
     m_Controls->m_ManualToolSelectionBox3D->hide();
     m_Controls->m_ManualToolSelectionBox2D->show();
     //Deactivate possible active tool
 
     //TODO Remove possible visible interpolations -> Maybe changes in SlicesInterpolator
   }
   else
   {
     //Hide 3D selection box, show 2D selection box
     m_Controls->m_ManualToolSelectionBox2D->hide();
     m_Controls->m_ManualToolSelectionBox3D->show();
     //Deactivate possible active tool
   }
 }
 
 
 void QmitkSegmentationView::SetToolManagerSelection(const mitk::DataNode* referenceData, const mitk::DataNode* workingData)
 {
   // called as a result of new BlueBerry selections
   //   tells the ToolManager for manual segmentation about new selections
   //   updates GUI information about what the user should select
   mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   toolManager->SetReferenceData(const_cast<mitk::DataNode*>(referenceData));
   toolManager->SetWorkingData(  const_cast<mitk::DataNode*>(workingData));
 
 
   // check original image
   m_Controls->btnNewSegmentation->setEnabled(referenceData != NULL);
   if (referenceData)
   {
     this->UpdateWarningLabel("");
     disconnect( m_Controls->patImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
           this, SLOT( OnPatientComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
     m_Controls->patImageSelector->setCurrentIndex( m_Controls->patImageSelector->Find(referenceData) );
 
     connect( m_Controls->patImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
          this, SLOT( OnPatientComboBoxSelectionChanged( const mitk::DataNode* ) ) );
   }
 
   // check segmentation
   if (referenceData)
   {
     if (workingData)
     {
       this->FireNodeSelected(const_cast<mitk::DataNode*>(workingData));
 //      mitk::RenderingManager::GetInstance()->InitializeViews(workingData->GetData()->GetTimeSlicedGeometry(),
 //                                                             mitk::RenderingManager::REQUEST_UPDATE_ALL, true );
 
 //      if( m_Controls->widgetStack->currentIndex() == 0 )
 //      {
         disconnect( m_Controls->segImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
               this, SLOT( OnSegmentationComboBoxSelectionChanged( const mitk::DataNode* ) ) );
 
         m_Controls->segImageSelector->setCurrentIndex(m_Controls->segImageSelector->Find(workingData));
 
         connect( m_Controls->segImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
              this, SLOT( OnSegmentationComboBoxSelectionChanged(const mitk::DataNode*)) );
 //      }
     }
   }
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
 {
   if (!node) return;
 
   bool isBinary(false);
   node->GetPropertyValue("binary", isBinary);
 
   if (isBinary)
   {
     node->SetProperty( "outline binary", mitk::BoolProperty::New( this->GetPreferences()->GetBool("draw outline", true)) );
     node->SetProperty( "outline width", mitk::FloatProperty::New( 2.0 ) );
     node->SetProperty( "opacity", mitk::FloatProperty::New( this->GetPreferences()->GetBool("draw outline", true) ? 1.0 : 0.3 ) );
     node->SetProperty( "volumerendering", mitk::BoolProperty::New( this->GetPreferences()->GetBool("volume rendering", false) ) );
   }
 }
 
 bool QmitkSegmentationView::CheckForSameGeometry(const mitk::DataNode *node1, const mitk::DataNode *node2) const
 {
   bool isSameGeometry(true);
 
   mitk::Image* image1 = dynamic_cast<mitk::Image*>(node1->GetData());
   mitk::Image* image2 = dynamic_cast<mitk::Image*>(node2->GetData());
   if (image1 && image2)
   {
     mitk::Geometry3D* geo1 = image1->GetGeometry();
     mitk::Geometry3D* geo2 = image2->GetGeometry();
 
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetOrigin(), geo2->GetOrigin());
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(0), geo2->GetExtent(0));
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(1), geo2->GetExtent(1));
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(2), geo2->GetExtent(2));
     isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetSpacing(), geo2->GetSpacing());
     isSameGeometry = isSameGeometry && mitk::MatrixEqualElementWise(geo1->GetIndexToWorldTransform()->GetMatrix(), geo2->GetIndexToWorldTransform()->GetMatrix());
 
     return isSameGeometry;
   }
   else
   {
     return false;
   }
 }
 
 void QmitkSegmentationView::UpdateWarningLabel(QString text)
 {
   if (text.size() == 0)
     m_Controls->lblSegmentationWarnings->hide();
   else
     m_Controls->lblSegmentationWarnings->show();
   m_Controls->lblSegmentationWarnings->setText(text);
 }
 
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
   // setup the basic GUI of this view
   m_Parent = parent;
 
   m_Controls = new Ui::QmitkSegmentationControls;
   m_Controls->setupUi(parent);
 
   m_Controls->patImageSelector->SetDataStorage(this->GetDefaultDataStorage());
   m_Controls->patImageSelector->SetPredicate(m_IsNotABinaryImagePredicate);
 
   this->UpdateWarningLabel("Please load an image");
 
   if( m_Controls->patImageSelector->GetSelectedNode().IsNotNull() )
     this->UpdateWarningLabel("Select or create a new segmentation");
 
   m_Controls->segImageSelector->SetDataStorage(this->GetDefaultDataStorage());
   m_Controls->segImageSelector->SetPredicate(m_IsABinaryImagePredicate);
   if( m_Controls->segImageSelector->GetSelectedNode().IsNotNull() )
     this->UpdateWarningLabel("");
 
   mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
-  toolManager->SetDataStorage( *(this->GetDefaultDataStorage()) );
   assert ( toolManager );
 
+  toolManager->SetDataStorage( *(this->GetDefaultDataStorage()) );
+  toolManager->InitializeTools();
 
   // all part of open source MITK
   m_Controls->m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
   m_Controls->m_ManualToolSelectionBox2D->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer2D );
   m_Controls->m_ManualToolSelectionBox2D->SetDisplayedToolGroups("Add Subtract Correction Paint Wipe 'Region Growing' Fill Erase 'Live Wire' 'FastMarching2D'");
   m_Controls->m_ManualToolSelectionBox2D->SetLayoutColumns(3);
   m_Controls->m_ManualToolSelectionBox2D->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
   connect( m_Controls->m_ManualToolSelectionBox2D, SIGNAL(ToolSelected(int)), this, SLOT(OnManualTool2DSelected(int)) );
 
   //setup 3D Tools
   m_Controls->m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
   m_Controls->m_ManualToolSelectionBox3D->SetToolGUIArea( m_Controls->m_ManualToolGUIContainer3D );
   //specify tools to be added to 3D Tool area
   m_Controls->m_ManualToolSelectionBox3D->SetDisplayedToolGroups("Threshold 'Two Thresholds' Otsu FastMarching3D RegionGrowing Watershed");
   m_Controls->m_ManualToolSelectionBox3D->SetLayoutColumns(3);
   m_Controls->m_ManualToolSelectionBox3D->SetEnabledMode( QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible );
 
   //Hide 3D selection box, show 2D selection box
   m_Controls->m_ManualToolSelectionBox3D->hide();
   m_Controls->m_ManualToolSelectionBox2D->show();
 
   toolManager->NewNodesGenerated +=
       mitk::MessageDelegate<QmitkSegmentationView>( this, &QmitkSegmentationView::NewNodesGenerated );      // update the list of segmentations
   toolManager->NewNodeObjectsGenerated +=
       mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>( this, &QmitkSegmentationView::NewNodeObjectsGenerated );      // update the list of segmentations
 
   // create signal/slot connections
   connect( m_Controls->patImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
        this, SLOT( OnPatientComboBoxSelectionChanged( const mitk::DataNode* ) ) );
   connect( m_Controls->segImageSelector, SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
        this, SLOT( OnSegmentationComboBoxSelectionChanged( const mitk::DataNode* ) ) );
   connect( m_Controls->btnNewSegmentation, SIGNAL(clicked()), this, SLOT(CreateNewSegmentation()) );
 //  connect( m_Controls->CreateSegmentationFromSurface, SIGNAL(clicked()), this, SLOT(CreateSegmentationFromSurface()) );
 //  connect( m_Controls->widgetStack, SIGNAL(currentChanged(int)), this, SLOT(ToolboxStackPageChanged(int)) );
 
   connect( m_Controls->tabWidgetSegmentationTools, SIGNAL(currentChanged(int)), this, SLOT(OnTabWidgetChanged(int)));
 
 //  connect(m_Controls->MaskSurfaces,  SIGNAL( OnSelectionChanged( const mitk::DataNode* ) ),
 //      this, SLOT( OnSurfaceSelectionChanged( ) ) );
 
   connect(m_Controls->m_SlicesInterpolator, SIGNAL(SignalShowMarkerNodes(bool)), this, SLOT(OnShowMarkerNodes(bool)));
   connect(m_Controls->m_SlicesInterpolator, SIGNAL(Signal3DInterpolationEnabled(bool)), this, SLOT(On3DInterpolationEnabled(bool)));
 
 //  m_Controls->MaskSurfaces->SetDataStorage(this->GetDefaultDataStorage());
 //  m_Controls->MaskSurfaces->SetPredicate(mitk::NodePredicateDataType::New("Surface"));
 }
 
 void QmitkSegmentationView::OnManualTool2DSelected(int id)
 {
     if (id >= 0)
     {
         std::string text = "Active Tool: \"";
         mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
         text += toolManager->GetToolById(id)->GetName();
         text += "\"";
         mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
 
         mitk::ModuleResource resource = toolManager->GetToolById(id)->GetCursorIconResource();
         this->SetMouseCursor(resource, 0, 0);
     }
     else
     {
         this->ResetMouseCursor();
         mitk::StatusBar::GetInstance()->DisplayText("");
     }
 }
 
 void QmitkSegmentationView::ResetMouseCursor()
 {
   if ( m_MouseCursorSet )
   {
     mitk::ApplicationCursor::GetInstance()->PopCursor();
     m_MouseCursorSet = false;
   }
 }
 
 void QmitkSegmentationView::SetMouseCursor( const mitk::ModuleResource resource, int hotspotX, int hotspotY )
 {
   // Remove previously set mouse cursor
   if ( m_MouseCursorSet )
   {
     mitk::ApplicationCursor::GetInstance()->PopCursor();
   }
 
   mitk::ApplicationCursor::GetInstance()->PushCursor( resource, hotspotX, hotspotY );
   m_MouseCursorSet = true;
 }
 
 // ATTENTION some methods for handling the known list of (organ names, colors) are defined in QmitkSegmentationOrganNamesHandling.cpp