diff --git a/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp b/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
index 4ae868996a..54aa6fa3ba 100644
--- a/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
+++ b/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.cpp
@@ -1,244 +1,245 @@
 /*===================================================================
 
 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"
 
 mitk::SurfaceInterpolationController::SurfaceInterpolationController()
 : m_CurrentContourListID (0)
 {
   m_ReduceFilter = ReduceContourSetFilter::New();
   m_NormalsFilter = ComputeContourSetNormalsFilter::New();
   m_InterpolateSurfaceFilter = CreateDistanceImageFromSurfaceFilter::New();
 
   m_ReduceFilter->SetUseProgressBar(true);
   m_NormalsFilter->SetUseProgressBar(true);
   m_InterpolateSurfaceFilter->SetUseProgressBar(true);
 
   m_Contours = Surface::New();
 
   m_PolyData = vtkSmartPointer<vtkPolyData>::New();
   m_PolyData->SetPoints(vtkPoints::New());
 
   m_InterpolationResult = 0;
 }
 
 mitk::SurfaceInterpolationController::~SurfaceInterpolationController()
 {
   for (unsigned int i = 0; i < m_ListOfContourLists.size(); ++i)
   {
       for (unsigned int j = 0; j < m_ListOfContourLists.at(i).size(); ++j)
       {
           delete(m_ListOfContourLists.at(i).at(j).position);
       }
   }
 }
 
 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 ,RestorePlanePositionOperation* op)
 {
   AffineTransform3D::Pointer transform = AffineTransform3D::New();
   transform = op->GetTransform();
 
   mitk::Vector3D direction = op->GetDirectionVector();
   int pos (-1);
 
   for (unsigned int i = 0; i < m_ListOfContourLists.at(m_CurrentContourListID).size(); i++)
   {
       itk::Matrix<float> diffM = transform->GetMatrix()-m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetTransform()->GetMatrix();
       bool isSameMatrix(true);
       for (unsigned int j = 0; j < 3; j++)
       {
         if (fabs(diffM[j][0]) > 0.0001 && fabs(diffM[j][1]) > 0.0001 && fabs(diffM[j][2]) > 0.0001)
         {
           isSameMatrix = false;
           break;
         }
       }
       itk::Vector<float> diffV = m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetTransform()->GetOffset()-transform->GetOffset();
       if ( isSameMatrix && m_ListOfContourLists.at(m_CurrentContourListID).at(i).position->GetPos() == op->GetPos() && (fabs(diffV[0]) < 0.0001 && fabs(diffV[1]) < 0.0001 && fabs(diffV[2]) < 0.0001) )
       {
         pos = i;
         break;
       }
     
   }
 
   if (pos == -1)
   {
     //MITK_INFO<<"New Contour";
     mitk::RestorePlanePositionOperation* newOp = new mitk::RestorePlanePositionOperation (OpRESTOREPLANEPOSITION, op->GetWidth(), 
       op->GetHeight(), op->GetSpacing(), op->GetPos(), direction, transform);
     ContourPositionPair newData;
     newData.contour = newContour;
     newData.position = newOp;
 
     m_ReduceFilter->SetInput(m_ListOfContourLists.at(m_CurrentContourListID).size(), newContour);
     m_ListOfContourLists.at(m_CurrentContourListID).push_back(newData);
   }
   else
   {
     //MITK_INFO<<"Modified Contour";
     m_ListOfContourLists.at(m_CurrentContourListID).at(pos).contour = newContour;
     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();
 }
 
 void mitk::SurfaceInterpolationController::Interpolate()
 {
   if (m_CurrentNumberOfReducedContours< 2)
     return;
 
   //Setting up progress bar
   mitk::ProgressBar::GetInstance()->AddStepsToDo(8);
 
   m_InterpolateSurfaceFilter->Update();
 
   Image::Pointer distanceImage = m_InterpolateSurfaceFilter->GetOutput();
 
   vtkSmartPointer<vtkMarchingCubes> mcFilter = vtkMarchingCubes::New();
   mcFilter->SetInput(distanceImage->GetVtkImageData());
   mcFilter->SetValue(0,0);
   mcFilter->Update();
 
   m_InterpolationResult = 0;
   m_InterpolationResult = mitk::Surface::New();
   m_InterpolationResult->SetVtkPolyData(mcFilter->GetOutput());
   m_InterpolationResult->GetGeometry()->SetOrigin(distanceImage->GetGeometry()->GetOrigin());
 
   vtkSmartPointer<vtkAppendPolyData> polyDataAppender = vtkSmartPointer<vtkAppendPolyData>::New();
   for (unsigned int i = 0; i < m_ReduceFilter->GetNumberOfOutputs(); i++)
   {
     polyDataAppender->AddInput(m_ReduceFilter->GetOutput(i)->GetVtkPolyData());
   }
   polyDataAppender->Update();
   m_Contours->SetVtkPolyData(polyDataAppender->GetOutput());
 
   //Last progress step
   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 &ds)
 {
   m_DataStorage = &ds;
 }
 
 unsigned int mitk::SurfaceInterpolationController::CreateNewContourList()
 {
   unsigned int newID =  m_ListOfContourLists.size();
   ContourPositionPairList newList;
   m_ListOfContourLists.push_back(newList);
   this->SetCurrentListID(newID);
   m_InterpolationResult = 0;
   return m_CurrentContourListID;
 }
 
 void mitk::SurfaceInterpolationController::SetCurrentListID ( unsigned int ID )
 {
   if (ID == m_CurrentContourListID )
     return;
 
   m_CurrentContourListID = ID;
 
   m_ReduceFilter->Reset();
   m_NormalsFilter->Reset();
   m_InterpolateSurfaceFilter->Reset();
   
   for (unsigned int i = 0; i < m_ListOfContourLists.at(m_CurrentContourListID).size(); i++)
   {
     m_ReduceFilter->SetInput(i, m_ListOfContourLists.at(m_CurrentContourListID).at(i).contour);
 //    m_NormalsFilter->SetInput(i,m_ReduceFilter->GetOutput(i));
 //    m_InterpolateSurfaceFilter->SetInput(i,m_NormalsFilter->GetOutput(i));
   }
 
   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));
   }
 }
 
 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::SetWorkingImage(Image* workingImage)
 {
   m_NormalsFilter->SetSegmentationBinaryImage(workingImage);
 }
 
 mitk::Image* mitk::SurfaceInterpolationController::GetImage()
 {
   return m_InterpolateSurfaceFilter->GetOutput();
 }
 
-float mitk::SurfaceInterpolationController::EstimatePortionOfNeededMemory()
+double mitk::SurfaceInterpolationController::EstimatePortionOfNeededMemory()
 {
-  float sizeOfPoints = pow(m_ReduceFilter->GetNumberOfPointsAfterReduction()*3,2)*sizeof(double);
-  float totalMem = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
-  float percentage = sizeOfPoints/totalMem;
+  double numberOfPointsAfterReduction = m_ReduceFilter->GetNumberOfPointsAfterReduction()*3;
+  double sizeOfPoints = pow(numberOfPointsAfterReduction,2)*sizeof(double);
+  double totalMem = mitk::MemoryUtilities::GetTotalSizeOfPhysicalRam();
+  double percentage = sizeOfPoints/totalMem;
   return percentage;
 }
diff --git a/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.h b/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.h
index 325f8245f6..f46b8f2657 100644
--- a/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.h
+++ b/Modules/Segmentation/Controllers/mitkSurfaceInterpolationController.h
@@ -1,166 +1,166 @@
 /*===================================================================
 
 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 "SegmentationExports.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 Segmentation_EXPORT SurfaceInterpolationController : public itk::Object
  {
 
   public:
 
     mitkClassMacro(SurfaceInterpolationController, itk::Object);
     itkNewMacro(Self);
 
     static SurfaceInterpolationController* GetInstance();
 
     /**
      * Adds a new extracted contour to the list 
      */
     void AddNewContour(Surface::Pointer newContour, RestorePlanePositionOperation *op);
 
     /**
      * 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 SetWorkingImage(Image* workingImage);
 
     Surface* GetContoursAsSurface();
 
     void SetDataStorage(DataStorage &ds);
 
     /**
      * Creates a new contourlist.
      * \returns the new ContourList ID
      */
     unsigned int CreateNewContourList();
 
     /**
      * Sets the ID for the ContourList which will be used for interpolation.
      * This is neccessary since MITK allows to load / create multiple segmentations and each segmentation must have its own contour list.
      */
     void SetCurrentListID (unsigned int ID);
 
     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
      */
-    float EstimatePortionOfNeededMemory();
+    double EstimatePortionOfNeededMemory();
 
  protected:
 
    SurfaceInterpolationController();
 
    ~SurfaceInterpolationController();
 
  private:
 
    struct ContourPositionPair {
      Surface::Pointer contour;
      RestorePlanePositionOperation* position;
    };
 
     typedef std::vector<ContourPositionPair> ContourPositionPairList;
 
     ContourPositionPairList::iterator m_Iterator;
 
     ReduceContourSetFilter::Pointer m_ReduceFilter;
     ComputeContourSetNormalsFilter::Pointer m_NormalsFilter;
     CreateDistanceImageFromSurfaceFilter::Pointer m_InterpolateSurfaceFilter;
 
     double m_MinSpacing;
     double m_MaxSpacing;
 
     const Image* m_WorkingImage;
 
     Surface::Pointer m_Contours;
 
     vtkSmartPointer<vtkPolyData> m_PolyData;
 
     unsigned int m_DistImageVolume;
 
     mitk::WeakPointer<mitk::DataStorage> m_DataStorage;
 
     std::vector<ContourPositionPairList> m_ListOfContourLists;
 
     unsigned int m_CurrentContourListID;
 
     mitk::Surface::Pointer m_InterpolationResult;
 
     unsigned int m_CurrentNumberOfReducedContours;
  };
 }
 #endif