diff --git a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
index fecf54b68f..55364470e1 100644
--- a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
+++ b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.cpp
@@ -1,395 +1,410 @@
 /*===================================================================
 
 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 "mitkSurfaceInterpolationController.h"
 #include "mitkMemoryUtilities.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 
 #include "mitkImageToSurfaceFilter.h"
 
 // TODO Use Equal of BaseGeometry instead after master merge!
 bool PlanesEqual (mitk::PlaneGeometry::Pointer leftHandSide, mitk::PlaneGeometry::Pointer rightHandSide, mitk::ScalarType eps)
 {
   bool result = true;
 
   //Compare spacings
   if( !mitk::Equal( leftHandSide->GetSpacing(), rightHandSide->GetSpacing(), eps ) )
   {
     result = false;
   }
 
   //Compare Origins
   if( !mitk::Equal( leftHandSide->GetOrigin(), rightHandSide->GetOrigin(), eps ) )
   {
     result = false;
   }
 
   //Compare Axis and Extents
   for( unsigned int i=0; i<3; ++i)
   {
     if( !mitk::Equal( leftHandSide->GetAxisVector(i), rightHandSide->GetAxisVector(i), eps))
     {
       result =  false;
     }
 
     if( !mitk::Equal( leftHandSide->GetExtent(i), rightHandSide->GetExtent(i), eps) )
     {
       result = false;
     }
   }
 
   //Compare ImageGeometry Flag
   if( rightHandSide->GetImageGeometry() != leftHandSide->GetImageGeometry() )
   {
     result = false;
   }
 
   //Compare IndexToWorldTransform Matrix
   if( !mitk::MatrixEqualElementWise( leftHandSide->GetIndexToWorldTransform()->GetMatrix(), rightHandSide->GetIndexToWorldTransform()->GetMatrix(), eps) )
   {
     result = false;
   }
   return result;
 }
 
 mitk::SurfaceInterpolationController::SurfaceInterpolationController()
   :m_SelectedSegmentation(0)
 {
   m_ReduceFilter = ReduceContourSetFilter::New();
   m_NormalsFilter = ComputeContourSetNormalsFilter::New();
   m_InterpolateSurfaceFilter = CreateDistanceImageFromSurfaceFilter::New();
 
   m_ReduceFilter->SetUseProgressBar(false);
   m_NormalsFilter->SetUseProgressBar(false);
   m_InterpolateSurfaceFilter->SetUseProgressBar(false);
 
   m_Contours = Surface::New();
 
   m_PolyData = vtkSmartPointer<vtkPolyData>::New();
   m_PolyData->SetPoints(vtkPoints::New());
 
   m_InterpolationResult = 0;
   m_CurrentNumberOfReducedContours = 0;
 }
 
 mitk::SurfaceInterpolationController::~SurfaceInterpolationController()
 {
   //Removing all observers
   std::map<mitk::Image*, unsigned long>::iterator dataIter = m_SegmentationObserverTags.begin();
   for (; dataIter != m_SegmentationObserverTags.end(); ++dataIter )
   {
     (*dataIter).first->RemoveObserver( (*dataIter).second );
   }
   m_SegmentationObserverTags.clear();
 }
 
 mitk::SurfaceInterpolationController* mitk::SurfaceInterpolationController::GetInstance()
 {
   static mitk::SurfaceInterpolationController* m_Instance;
 
   if ( m_Instance == 0)
   {
     m_Instance = new SurfaceInterpolationController();
   }
   return m_Instance;
 }
 
 void mitk::SurfaceInterpolationController::AddNewContour (mitk::Surface::Pointer newContour, PlaneGeometry::Pointer plane)
 {
-  int pos (-1);
+  ContourPositionPair pair;
+  pair.contour = newContour;
+  pair.plane = plane;
+  this->AddToInterpolationPipeline(pair);
+
+  this->Modified();
+}
 
-  for (unsigned int i = 0; i < m_ListOfInterpolationSessions[m_SelectedSegmentation].size(); i++)
+void mitk::SurfaceInterpolationController::AddNewContours(ContourPositionPairList newContours)
+{
+  for (unsigned int i = 0; i < newContours.size(); ++i)
   {
-    mitk::PlaneGeometry::Pointer planeFromList = m_ListOfInterpolationSessions[m_SelectedSegmentation].at(i).plane;
+    this->AddToInterpolationPipeline(newContours.at(i));
+  }
+  this->Modified();
+}
+
+void mitk::SurfaceInterpolationController::AddToInterpolationPipeline(ContourPositionPair pair)
+{
+  int pos (-1);
+  ContourPositionPairList currentContourList = m_ListOfInterpolationSessions[m_SelectedSegmentation];
+  mitk::PlaneGeometry* plane = pair.plane;
+  mitk::Surface* newContour = pair.contour;
+  for (unsigned int i = 0; i < currentContourList.size(); i++)
+  {
+    mitk::PlaneGeometry::Pointer planeFromList = currentContourList.at(i).plane;
     if ( PlanesEqual(plane, planeFromList, mitk::eps) )
     {
       pos = i;
       break;
     }
   }
 
   //Don't save a new empty contour
   if (pos == -1 && newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
   {
-    ContourPositionPair newData;
-    newData.contour = newContour;
-    newData.plane = plane;
-
     m_ReduceFilter->SetInput(m_ListOfInterpolationSessions[m_SelectedSegmentation].size(), newContour);
-    m_ListOfInterpolationSessions[m_SelectedSegmentation].push_back(newData);
+    m_ListOfInterpolationSessions[m_SelectedSegmentation].push_back(pair);
   }
   else if (pos != -1 && newContour->GetVtkPolyData()->GetNumberOfPoints() > 0)
   {
-    m_ListOfInterpolationSessions[m_SelectedSegmentation].at(pos).contour = newContour;
+    m_ListOfInterpolationSessions[m_SelectedSegmentation].at(pos) = pair;
     m_ReduceFilter->SetInput(pos, newContour);
   }
 
   m_ReduceFilter->Update();
   m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
   for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
   {
     m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
     m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
   }
-
-  this->Modified();
 }
 
 const mitk::Surface* mitk::SurfaceInterpolationController::GetContour(mitk::PlaneGeometry::Pointer plane)
 {
   ContourPositionPairList contourList = m_ListOfInterpolationSessions[m_SelectedSegmentation];
   for (unsigned int i = 0; i < contourList.size(); ++i)
   {
     ContourPositionPair pair = contourList.at(i);
     if (PlanesEqual(plane, pair.plane, mitk::eps))
       return pair.contour;
   }
   return 0;
 }
 
 unsigned int mitk::SurfaceInterpolationController::GetNumberOfContours()
 {
   return m_ListOfInterpolationSessions[m_SelectedSegmentation].size();
 }
 
 void mitk::SurfaceInterpolationController::Interpolate()
 {
   if (m_CurrentNumberOfReducedContours< 2)
   {
     //If no interpolation is possible reset the interpolation result
     m_InterpolationResult = 0;
     return;
   }
 
   //Setting up progress bar
    /*
     * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
     */
   //mitk::ProgressBar::GetInstance()->AddStepsToDo(8);
 
   // update the filter and get teh resulting distance-image
   m_InterpolateSurfaceFilter->Update();
   Image::Pointer distanceImage = m_InterpolateSurfaceFilter->GetOutput();
 
   // create a surface from the distance-image
   mitk::ImageToSurfaceFilter::Pointer imageToSurfaceFilter = mitk::ImageToSurfaceFilter::New();
   imageToSurfaceFilter->SetInput( distanceImage );
   imageToSurfaceFilter->SetThreshold( 0 );
   imageToSurfaceFilter->SetSmooth(true);
   imageToSurfaceFilter->SetSmoothIteration(20);
   imageToSurfaceFilter->Update();
   m_InterpolationResult = imageToSurfaceFilter->GetOutput();
 
 
   vtkSmartPointer<vtkAppendPolyData> polyDataAppender = vtkSmartPointer<vtkAppendPolyData>::New();
   for (unsigned int i = 0; i < m_ReduceFilter->GetNumberOfOutputs(); i++)
   {
     polyDataAppender->AddInputData(m_ReduceFilter->GetOutput(i)->GetVtkPolyData());
   }
   polyDataAppender->Update();
   m_Contours->SetVtkPolyData(polyDataAppender->GetOutput());
 
   //Last progress step
   /*
    * Removed due to bug 12441. ProgressBar messes around with Qt event queue which is fatal for segmentation
    */
   //mitk::ProgressBar::GetInstance()->Progress(8);
 
   m_InterpolationResult->DisconnectPipeline();
 }
 
 mitk::Surface::Pointer mitk::SurfaceInterpolationController::GetInterpolationResult()
 {
     return m_InterpolationResult;
 }
 
 mitk::Surface* mitk::SurfaceInterpolationController::GetContoursAsSurface()
 {
   return m_Contours;
 }
 
 void mitk::SurfaceInterpolationController::SetDataStorage(DataStorage::Pointer ds)
 {
   m_DataStorage = ds;
 }
 
 void mitk::SurfaceInterpolationController::SetMinSpacing(double minSpacing)
 {
   m_ReduceFilter->SetMinSpacing(minSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetMaxSpacing(double maxSpacing)
 {
   m_ReduceFilter->SetMaxSpacing(maxSpacing);
   m_NormalsFilter->SetMaxSpacing(maxSpacing);
 }
 
 void mitk::SurfaceInterpolationController::SetDistanceImageVolume(unsigned int distImgVolume)
 {
   m_InterpolateSurfaceFilter->SetDistanceImageVolume(distImgVolume);
 }
 
 void mitk::SurfaceInterpolationController::SetSegmentationImage(Image* /*workingImage*/)
 {
 //  m_NormalsFilter->SetSegmentationBinaryImage(workingImage);
 }
 
 mitk::Image::Pointer mitk::SurfaceInterpolationController::GetCurrentSegmentation()
 {
   return m_SelectedSegmentation;
 }
 
 mitk::Image* mitk::SurfaceInterpolationController::GetImage()
 {
   return m_InterpolateSurfaceFilter->GetOutput();
 }
 
 double mitk::SurfaceInterpolationController::EstimatePortionOfNeededMemory()
 {
   double numberOfPointsAfterReduction = m_ReduceFilter->GetNumberOfPointsAfterReduction()*3;
   double sizeOfPoints = pow(numberOfPointsAfterReduction,2)*sizeof(double);
   double totalMem = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
   double percentage = sizeOfPoints/totalMem;
   return percentage;
 }
 
 unsigned int mitk::SurfaceInterpolationController::GetNumberOfInterpolationSessions()
 {
   return m_ListOfInterpolationSessions.size();
 }
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::SurfaceInterpolationController::GetImageBase(itk::Image<TPixel, VImageDimension>* input, itk::ImageBase<3>::Pointer& result)
 {
   result->Graft(input);
 }
 
 void mitk::SurfaceInterpolationController::SetCurrentSegmentationInterpolationList(mitk::Image::Pointer segmentation)
 {
   this->SetCurrentInterpolationSession(segmentation);
 }
 
 void mitk::SurfaceInterpolationController::SetCurrentInterpolationSession(mitk::Image::Pointer currentSegmentationImage)
 {
   if (currentSegmentationImage.GetPointer() == m_SelectedSegmentation)
     return;
 
   m_ReduceFilter->Reset();
   m_NormalsFilter->Reset();
   m_InterpolateSurfaceFilter->Reset();
 
   if (currentSegmentationImage.IsNull())
   {
     m_SelectedSegmentation = 0;
     return;
   }
   ContourListMap::iterator it = m_ListOfInterpolationSessions.find(currentSegmentationImage.GetPointer());
 
   m_SelectedSegmentation = currentSegmentationImage.GetPointer();
 
   itk::ImageBase<3>::Pointer itkImage = itk::ImageBase<3>::New();
   AccessFixedDimensionByItk_1( m_SelectedSegmentation, GetImageBase, 3, itkImage );
   m_InterpolateSurfaceFilter->SetReferenceImage( itkImage.GetPointer() );
 
   if (it == m_ListOfInterpolationSessions.end())
   {
     ContourPositionPairList newList;
     m_ListOfInterpolationSessions.insert(std::pair<mitk::Image*, ContourPositionPairList>(m_SelectedSegmentation, newList));
     m_InterpolationResult = 0;
     m_CurrentNumberOfReducedContours = 0;
 
     itk::MemberCommand<SurfaceInterpolationController>::Pointer command = itk::MemberCommand<SurfaceInterpolationController>::New();
     command->SetCallbackFunction(this, &SurfaceInterpolationController::OnSegmentationDeleted);
     m_SegmentationObserverTags.insert( std::pair<mitk::Image*, unsigned long>( m_SelectedSegmentation, m_SelectedSegmentation->AddObserver( itk::DeleteEvent(), command ) ) );
 
   }
   else
   {
     for (unsigned int i = 0; i < m_ListOfInterpolationSessions[m_SelectedSegmentation].size(); i++)
     {
       m_ReduceFilter->SetInput(i, m_ListOfInterpolationSessions[m_SelectedSegmentation].at(i).contour);
     }
 
     m_ReduceFilter->Update();
 
     m_CurrentNumberOfReducedContours = m_ReduceFilter->GetNumberOfOutputs();
 
     for (unsigned int i = 0; i < m_CurrentNumberOfReducedContours; i++)
     {
       m_NormalsFilter->SetInput(i, m_ReduceFilter->GetOutput(i));
       m_InterpolateSurfaceFilter->SetInput(i, m_NormalsFilter->GetOutput(i));
     }
   }
   Modified();
 }
 
 void mitk::SurfaceInterpolationController::RemoveSegmentationFromContourList(mitk::Image *segmentation)
 {
   this->RemoveInterpolationSession(segmentation);
 }
 
 void mitk::SurfaceInterpolationController::RemoveInterpolationSession(mitk::Image::Pointer segmentationImage)
 {
   if (segmentationImage)
   {
     if (m_SelectedSegmentation == segmentationImage)
     {
       SetSegmentationImage(NULL);
       m_SelectedSegmentation = 0;
     }
     m_ListOfInterpolationSessions.erase(segmentationImage);
     // Remove observer
     std::map<mitk::Image*, unsigned long>::iterator pos = m_SegmentationObserverTags.find(segmentationImage);
     if (pos != m_SegmentationObserverTags.end())
     {
       segmentationImage->RemoveObserver((*pos).second);
       m_SegmentationObserverTags.erase(pos);
     }
   }
 }
 
 void mitk::SurfaceInterpolationController::RemoveAllInterpolationSessions()
 {
   //Removing all observers
   std::map<mitk::Image*, unsigned long>::iterator dataIter = m_SegmentationObserverTags.begin();
   while (dataIter != m_SegmentationObserverTags.end())
   {
     mitk::Image* image = (*dataIter).first;
     image->RemoveObserver((*dataIter).second);
     ++dataIter;
   }
 
   m_SegmentationObserverTags.clear();
   m_SelectedSegmentation = 0;
   m_ListOfInterpolationSessions.clear();
 }
 
 void mitk::SurfaceInterpolationController::OnSegmentationDeleted(const itk::Object *caller, const itk::EventObject &/*event*/)
 {
   mitk::Image* tempImage = dynamic_cast<mitk::Image*>(const_cast<itk::Object*>(caller));
   if (tempImage)
   {
     if (m_SelectedSegmentation == tempImage)
     {
       SetSegmentationImage(NULL);
       m_SelectedSegmentation = 0;
     }
     m_SegmentationObserverTags.erase(tempImage);
     m_ListOfInterpolationSessions.erase(tempImage);
   }
 }
diff --git a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
index 1fb6e4dd7b..36235eb579 100644
--- a/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
+++ b/Modules/SurfaceInterpolation/mitkSurfaceInterpolationController.h
@@ -1,209 +1,221 @@
 /*===================================================================
 
 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 mitkSurfaceInterpolationController_h_Included
 #define mitkSurfaceInterpolationController_h_Included
 
 #include "mitkCommon.h"
 #include <MitkSurfaceInterpolationExports.h>
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkSurface.h"
 #include "mitkInteractionConst.h"
 #include "mitkColorProperty.h"
 #include "mitkProperties.h"
 
 #include "mitkCreateDistanceImageFromSurfaceFilter.h"
 #include "mitkReduceContourSetFilter.h"
 #include "mitkComputeContourSetNormalsFilter.h"
 
 #include "mitkDataNode.h"
 #include "mitkDataStorage.h"
 #include "mitkWeakPointer.h"
 
 #include "vtkPolygon.h"
 #include "vtkPoints.h"
 #include "vtkCellArray.h"
 #include "vtkPolyData.h"
 #include "vtkSmartPointer.h"
 #include "vtkAppendPolyData.h"
 
 #include "vtkMarchingCubes.h"
 #include "vtkImageData.h"
 #include "mitkVtkRepresentationProperty.h"
 #include "vtkProperty.h"
 
 #include "mitkProgressBar.h"
 
 namespace mitk
 {
 
  class MitkSurfaceInterpolation_EXPORT SurfaceInterpolationController : public itk::Object
  {
 
   public:
 
     mitkClassMacro(SurfaceInterpolationController, itk::Object)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
+    struct ContourPositionPair {
+      Surface::Pointer contour;
+      mitk::PlaneGeometry::Pointer plane;
+    };
+
+    typedef std::vector<ContourPositionPair> ContourPositionPairList;
+    typedef std::map<mitk::Image*, ContourPositionPairList> ContourListMap;
+
     static SurfaceInterpolationController* GetInstance();
 
     /**
-     * Adds a new extracted contour to the list
+     * @brief Adds a new extracted contour to the list
+     * @param newContour the contour to be added
+     * @param plane the image plane in which the contour lies. If plane already exists the related
+     *        contour will be updated
      */
     void AddNewContour (Surface::Pointer newContour, PlaneGeometry::Pointer plane);
 
+    /**
+     * @brief Adds new extracted contours to the list. If one or more contours at a given position
+     *        already exist they will be updated respectively
+     * @param newContours the list of the contours and the respective positions
+     */
+    void AddNewContours (ContourPositionPairList newContours);
+
     /**
     * @brief Returns the contour for a given plane for the current selected segmenation
     * @param plane the plane for which the contour should be returned
     * @return the contour as an mitk::Surface. If no contour is available for the plane NULL is returned
     */
     const mitk::Surface* GetContour (PlaneGeometry::Pointer plane);
 
     /**
     * @brief Returns the number of available contours for the current selected segmentation
     * @return the number of contours
     */
     unsigned int GetNumberOfContours();
 
     /**
      * Interpolates the 3D surface from the given extracted contours
      */
     void Interpolate ();
 
     mitk::Surface::Pointer GetInterpolationResult();
 
     /**
      * Sets the minimum spacing of the current selected segmentation
      * This is needed since the contour points we reduced before they are used to interpolate the surface
      */
     void SetMinSpacing(double minSpacing);
 
     /**
      * Sets the minimum spacing of the current selected segmentation
      * This is needed since the contour points we reduced before they are used to interpolate the surface
      */
     void SetMaxSpacing(double maxSpacing);
 
     /**
      * Sets the volume i.e. the number of pixels that the distance image should have
      * By evaluation we found out that 50.000 pixel delivers a good result
      */
     void SetDistanceImageVolume(unsigned int distImageVolume);
 
     /**
      * Sets the current segmentation which is used by the interpolation
      * This is needed because the calculation of the normals needs to now wheather a normal points inside a segmentation or not
      */
     void SetSegmentationImage(Image* workingImage);
 
     /**
      * @brief Get the current selected segmentation for which the interpolation is performed
      * @return the current segmentation image
      */
     mitk::Image::Pointer GetCurrentSegmentation();
 
     Surface* GetContoursAsSurface();
 
     void SetDataStorage(DataStorage::Pointer ds);
 
     /**
      * Sets the current list of contourpoints which is used for the surface interpolation
      * @param segmentation The current selected segmentation
      * \deprecatedSince{2014_03}
      */
     DEPRECATED (void SetCurrentSegmentationInterpolationList(mitk::Image::Pointer segmentation));
 
     /**
      * Sets the current list of contourpoints which is used for the surface interpolation
      * @param segmentation The current selected segmentation
      */
     void SetCurrentInterpolationSession(mitk::Image::Pointer currentSegmentationImage);
 
     /**
      * Removes the segmentation and all its contours from the list
      * @param segmentation The segmentation to be removed
      * \deprecatedSince{2014_03}
      */
     DEPRECATED (void RemoveSegmentationFromContourList(mitk::Image* segmentation));
 
     /**
      * @brief Remove interpolation session
      * @param segmentationImage the session to be removed
      */
     void RemoveInterpolationSession(mitk::Image::Pointer segmentationImage);
 
     /**
      * @brief Removes all sessions
      */
     void RemoveAllInterpolationSessions();
 
     mitk::Image* GetImage();
 
     /**
      * Estimates the memory which is needed to build up the equationsystem for the interpolation.
      * \returns The percentage of the real memory which will be used by the interpolation
      */
     double EstimatePortionOfNeededMemory();
 
     unsigned int GetNumberOfInterpolationSessions();
 
  protected:
 
    SurfaceInterpolationController();
 
    ~SurfaceInterpolationController();
 
    template<typename TPixel, unsigned int VImageDimension> void GetImageBase(itk::Image<TPixel, VImageDimension>* input, itk::ImageBase<3>::Pointer& result);
 
  private:
 
    void OnSegmentationDeleted(const itk::Object *caller, const itk::EventObject &event);
 
    void ReinitializeInterpolation();
 
-   struct ContourPositionPair {
-     Surface::Pointer contour;
-     mitk::PlaneGeometry::Pointer plane;
-   };
-
-    typedef std::vector<ContourPositionPair> ContourPositionPairList;
-    typedef std::map<mitk::Image*, ContourPositionPairList> ContourListMap;
+   void AddToInterpolationPipeline(ContourPositionPair pair);
 
     ContourPositionPairList::iterator m_Iterator;
 
     ReduceContourSetFilter::Pointer m_ReduceFilter;
     ComputeContourSetNormalsFilter::Pointer m_NormalsFilter;
     CreateDistanceImageFromSurfaceFilter::Pointer m_InterpolateSurfaceFilter;
 
     Surface::Pointer m_Contours;
 
     vtkSmartPointer<vtkPolyData> m_PolyData;
 
     mitk::DataStorage::Pointer m_DataStorage;
 
     ContourListMap m_ListOfInterpolationSessions;
 
     mitk::Surface::Pointer m_InterpolationResult;
 
     unsigned int m_CurrentNumberOfReducedContours;
 
     mitk::Image* m_SelectedSegmentation;
 
     std::map<mitk::Image*, unsigned long> m_SegmentationObserverTags;
  };
 }
 #endif