diff --git a/Modules/Segmentation/Algorithms/mitkShapeBasedInterpolationAlgorithm.cpp b/Modules/Segmentation/Algorithms/mitkShapeBasedInterpolationAlgorithm.cpp
index 3bc01722ad..0f044a368d 100644
--- a/Modules/Segmentation/Algorithms/mitkShapeBasedInterpolationAlgorithm.cpp
+++ b/Modules/Segmentation/Algorithms/mitkShapeBasedInterpolationAlgorithm.cpp
@@ -1,135 +1,147 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkShapeBasedInterpolationAlgorithm.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageCast.h"
 #include <mitkITKImageImport.h>
 
 #include <itkFastChamferDistanceImageFilter.h>
 #include <itkInvertIntensityImageFilter.h>
 #include <itkIsoContourDistanceImageFilter.h>
 #include <itkSubtractImageFilter.h>
 
 mitk::Image::Pointer mitk::ShapeBasedInterpolationAlgorithm::Interpolate(
   Image::ConstPointer lowerSlice,
   unsigned int lowerSliceIndex,
   Image::ConstPointer upperSlice,
   unsigned int upperSliceIndex,
   unsigned int requestedIndex,
   unsigned int /*sliceDimension*/, // commented variables are not used
   Image::Pointer resultImage,
   unsigned int /*timeStep*/,
   Image::ConstPointer /*referenceImage*/)
 {
-  mitk::Image::Pointer lowerDistanceImage = mitk::Image::New();
-  AccessFixedDimensionByItk_1(lowerSlice, ComputeDistanceMap, 2, lowerDistanceImage);
-
-  mitk::Image::Pointer upperDistanceImage = mitk::Image::New();
-  AccessFixedDimensionByItk_1(upperSlice, ComputeDistanceMap, 2, upperDistanceImage);
+  auto lowerDistanceImage = this->ComputeDistanceMap(lowerSliceIndex, lowerSlice);
+  auto upperDistanceImage = this->ComputeDistanceMap(upperSliceIndex, upperSlice);
 
   // calculate where the current slice is in comparison to the lower and upper neighboring slices
   float ratio = (float)(requestedIndex - lowerSliceIndex) / (float)(upperSliceIndex - lowerSliceIndex);
-  AccessFixedDimensionByItk_3(
-    resultImage, InterpolateIntermediateSlice, 2, upperDistanceImage, lowerDistanceImage, ratio);
+  AccessFixedDimensionByItk_3(resultImage, InterpolateIntermediateSlice, 2, upperDistanceImage, lowerDistanceImage, ratio);
 
   return resultImage;
 }
 
+mitk::Image::Pointer mitk::ShapeBasedInterpolationAlgorithm::ComputeDistanceMap(unsigned int sliceIndex, Image::ConstPointer slice)
+{
+  if (0 != m_DistanceImageCache.count(sliceIndex))
+    return m_DistanceImageCache[sliceIndex];
+
+  if (2 < m_DistanceImageCache.size())
+    m_DistanceImageCache.clear();
+
+  auto distanceImage = mitk::Image::New();
+  AccessFixedDimensionByItk_1(slice, ComputeDistanceMap, 2, distanceImage);
+
+  m_DistanceImageCache[sliceIndex] = distanceImage;
+
+  return distanceImage;
+}
+
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::ShapeBasedInterpolationAlgorithm::ComputeDistanceMap(const itk::Image<TPixel, VImageDimension> *binaryImage,
                                                                 mitk::Image::Pointer &result)
 {
   typedef itk::Image<TPixel, VImageDimension> DistanceFilterInputImageType;
 
   typedef itk::FastChamferDistanceImageFilter<DistanceFilterImageType, DistanceFilterImageType> DistanceFilterType;
   typedef itk::IsoContourDistanceImageFilter<DistanceFilterInputImageType, DistanceFilterImageType> IsoContourType;
   typedef itk::InvertIntensityImageFilter<DistanceFilterInputImageType> InvertIntensityImageFilterType;
   typedef itk::SubtractImageFilter<DistanceFilterImageType, DistanceFilterImageType> SubtractImageFilterType;
 
   typename DistanceFilterType::Pointer distanceFilter = DistanceFilterType::New();
   typename DistanceFilterType::Pointer distanceFilterInverted = DistanceFilterType::New();
   typename IsoContourType::Pointer isoContourFilter = IsoContourType::New();
   typename IsoContourType::Pointer isoContourFilterInverted = IsoContourType::New();
   typename InvertIntensityImageFilterType::Pointer invertFilter = InvertIntensityImageFilterType::New();
   typename SubtractImageFilterType::Pointer subtractImageFilter = SubtractImageFilterType::New();
 
   // arbitrary maximum distance
   int maximumDistance = 100;
 
   // this assumes the image contains only 1 and 0
   invertFilter->SetInput(binaryImage);
   invertFilter->SetMaximum(1);
 
   // do the processing on the image and the inverted image to get inside and outside distance
   isoContourFilter->SetInput(binaryImage);
   isoContourFilter->SetFarValue(maximumDistance + 1);
   isoContourFilter->SetLevelSetValue(0);
 
   isoContourFilterInverted->SetInput(invertFilter->GetOutput());
   isoContourFilterInverted->SetFarValue(maximumDistance + 1);
   isoContourFilterInverted->SetLevelSetValue(0);
 
   distanceFilter->SetInput(isoContourFilter->GetOutput());
   distanceFilter->SetMaximumDistance(maximumDistance);
 
   distanceFilterInverted->SetInput(isoContourFilterInverted->GetOutput());
   distanceFilterInverted->SetMaximumDistance(maximumDistance);
 
   // inside distance should be negative, outside distance positive
   subtractImageFilter->SetInput2(distanceFilter->GetOutput());
   subtractImageFilter->SetInput1(distanceFilterInverted->GetOutput());
   subtractImageFilter->Update();
 
   result = mitk::GrabItkImageMemory(subtractImageFilter->GetOutput());
 }
 
 template <typename TPixel, unsigned int VImageDimension>
 void mitk::ShapeBasedInterpolationAlgorithm::InterpolateIntermediateSlice(itk::Image<TPixel, VImageDimension> *result,
                                                                           const mitk::Image::Pointer &lower,
                                                                           const mitk::Image::Pointer &upper,
                                                                           float ratio)
 {
   typename DistanceFilterImageType::Pointer lowerITK = DistanceFilterImageType::New();
   typename DistanceFilterImageType::Pointer upperITK = DistanceFilterImageType::New();
 
   CastToItkImage(lower, lowerITK);
   CastToItkImage(upper, upperITK);
 
   itk::ImageRegionConstIteratorWithIndex<DistanceFilterImageType> lowerIter(lowerITK,
                                                                             lowerITK->GetLargestPossibleRegion());
 
   lowerIter.GoToBegin();
 
   if (!lowerITK->GetLargestPossibleRegion().IsInside(upperITK->GetLargestPossibleRegion()) ||
       !lowerITK->GetLargestPossibleRegion().IsInside(result->GetLargestPossibleRegion()))
   {
     // TODO Exception etc.
     MITK_ERROR << "The regions of the slices for the 2D interpolation are not equally sized!";
     return;
   }
 
   float weight[2] = {1.0f - ratio, ratio};
 
   while (!lowerIter.IsAtEnd())
   {
     typename DistanceFilterImageType::PixelType lowerPixelVal = lowerIter.Get();
     typename DistanceFilterImageType::PixelType upperPixelVal = upperITK->GetPixel(lowerIter.GetIndex());
 
     typename DistanceFilterImageType::PixelType intermediatePixelVal =
       (weight[0] * upperPixelVal + weight[1] * lowerPixelVal > 0 ? 0 : 1);
 
     result->SetPixel(lowerIter.GetIndex(), static_cast<TPixel>(intermediatePixelVal));
 
     ++lowerIter;
   }
 }
diff --git a/Modules/Segmentation/Algorithms/mitkShapeBasedInterpolationAlgorithm.h b/Modules/Segmentation/Algorithms/mitkShapeBasedInterpolationAlgorithm.h
index 934271b89b..92f44810b9 100644
--- a/Modules/Segmentation/Algorithms/mitkShapeBasedInterpolationAlgorithm.h
+++ b/Modules/Segmentation/Algorithms/mitkShapeBasedInterpolationAlgorithm.h
@@ -1,65 +1,71 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkShapeBasedInterpolationAlgorithm_h_Included
 #define mitkShapeBasedInterpolationAlgorithm_h_Included
 
 #include "mitkSegmentationInterpolationAlgorithm.h"
 #include <MitkSegmentationExports.h>
 
+#include <map>
+
 namespace mitk
 {
   /**
    * \brief Shape-based binary image interpolation.
    *
    * This class uses legacy code from ipSegmentation to implement
    * the shape-based interpolation algorithm described in
    *
    * G.T. Herman, J. Zheng, C.A. Bucholtz: "Shape-based interpolation"
    * IEEE Computer Graphics & Applications, pp. 69-79,May 1992
    *
    *  Last contributor:
    *  $Author:$
    */
   class MITKSEGMENTATION_EXPORT ShapeBasedInterpolationAlgorithm : public SegmentationInterpolationAlgorithm
   {
   public:
     mitkClassMacro(ShapeBasedInterpolationAlgorithm, SegmentationInterpolationAlgorithm);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
       Image::Pointer Interpolate(Image::ConstPointer lowerSlice,
                                  unsigned int lowerSliceIndex,
                                  Image::ConstPointer upperSlice,
                                  unsigned int upperSliceIndex,
                                  unsigned int requestedIndex,
                                  unsigned int sliceDimension,
                                  Image::Pointer resultImage,
                                  unsigned int timeStep,
                                  Image::ConstPointer referenceImage) override;
 
   private:
     typedef itk::Image<mitk::ScalarType, 2> DistanceFilterImageType;
 
     template <typename TPixel, unsigned int VImageDimension>
     void ComputeDistanceMap(const itk::Image<TPixel, VImageDimension> *, mitk::Image::Pointer &result);
 
+    Image::Pointer ComputeDistanceMap(unsigned int sliceIndex, Image::ConstPointer slice);
+
     template <typename TPixel, unsigned int VImageDimension>
     void InterpolateIntermediateSlice(itk::Image<TPixel, VImageDimension> *result,
                                       const mitk::Image::Pointer &lowerDistanceImage,
                                       const mitk::Image::Pointer &upperDistanceImage,
                                       float ratio);
+
+    std::map<unsigned int, Image::Pointer> m_DistanceImageCache;
   };
 
 } // namespace
 
 #endif