diff --git a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
index 295bd0a65f..50fce7ce87 100644
--- a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
@@ -1,398 +1,398 @@
 /*===================================================================
 
 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 <mitkToFCompositeFilter.h>
 #include <mitkInstantiateAccessFunctions.h>
 #include "mitkImageReadAccessor.h"
 
 #include <itkImage.h>
 
 mitk::ToFCompositeFilter::ToFCompositeFilter() : m_SegmentationMask(nullptr), m_ImageWidth(0), m_ImageHeight(0), m_ImageSize(0),
 m_IplDistanceImage(nullptr), m_IplOutputImage(nullptr), m_ItkInputImage(nullptr), m_ApplyTemporalMedianFilter(false), m_ApplyAverageFilter(false),
   m_ApplyMedianFilter(false), m_ApplyThresholdFilter(false), m_ApplyMaskSegmentation(false), m_ApplyBilateralFilter(false), m_DataBuffer(nullptr),
 m_DataBufferCurrentIndex(0), m_DataBufferMaxSize(0), m_TemporalMedianFilterNumOfFrames(10), m_ThresholdFilterMin(1),
 m_ThresholdFilterMax(7000), m_BilateralFilterDomainSigma(2), m_BilateralFilterRangeSigma(60), m_BilateralFilterKernelRadius(0)
 {
 }
 
 mitk::ToFCompositeFilter::~ToFCompositeFilter()
 {
   cvReleaseImage(&(this->m_IplDistanceImage));
   cvReleaseImage(&(this->m_IplOutputImage));
   if (m_DataBuffer!=nullptr)
   {
     delete [] m_DataBuffer;
   }
 }
 
 void mitk::ToFCompositeFilter::SetInput(  mitk::Image* distanceImage )
 {
   this->SetInput(0, distanceImage);
 }
 
 void mitk::ToFCompositeFilter::SetInput( unsigned int idx,  mitk::Image* distanceImage )
 {
   if ((distanceImage == nullptr) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to nullptr, reduce the number of inputs by one
   {
-    this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
+    this->SetNumberOfIndexedInputs(this->GetNumberOfInputs() - 1);
   }
   else
   {
     if (idx==0) //create IPL image holding distance data
     {
       if (!distanceImage->IsEmpty())
       {
         this->m_ImageWidth = distanceImage->GetDimension(0);
         this->m_ImageHeight = distanceImage->GetDimension(1);
         this->m_ImageSize = this->m_ImageWidth * this->m_ImageHeight * sizeof(float);
 
         if (this->m_IplDistanceImage != nullptr)
         {
           cvReleaseImage(&(this->m_IplDistanceImage));
         }
         ImageReadAccessor distImgAcc(distanceImage, distanceImage->GetSliceData(0,0,0));
         float* distanceFloatData = (float*) distImgAcc.GetData();
         this->m_IplDistanceImage = cvCreateImage(cvSize(this->m_ImageWidth, this->m_ImageHeight), IPL_DEPTH_32F, 1);
         memcpy(this->m_IplDistanceImage->imageData, (void*)distanceFloatData, this->m_ImageSize);
 
         if (this->m_IplOutputImage != nullptr)
         {
           cvReleaseImage(&(this->m_IplOutputImage));
         }
         this->m_IplOutputImage = cvCreateImage(cvSize(this->m_ImageWidth, this->m_ImageHeight), IPL_DEPTH_32F, 1);
 
         CreateItkImage(this->m_ItkInputImage);
       }
     }
     this->ProcessObject::SetNthInput(idx, distanceImage);   // Process object is not const-correct so the const_cast is required here
   }
 
   this->CreateOutputsForAllInputs();
 }
 
  mitk::Image* mitk::ToFCompositeFilter::GetInput()
 {
   return this->GetInput(0);
 }
 
  mitk::Image* mitk::ToFCompositeFilter::GetInput( unsigned int idx )
 {
   if (this->GetNumberOfInputs() < 1)
     return nullptr; //TODO: geeignete exception werfen
   return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
 }
 
 void mitk::ToFCompositeFilter::GenerateData()
 {
   // copy input 1...n to output 1...n
   for (unsigned int idx=0; idx<this->GetNumberOfOutputs(); idx++)
   {
     mitk::Image::Pointer outputImage = this->GetOutput(idx);
     mitk::Image::Pointer inputImage = this->GetInput(idx);
     if (outputImage.IsNotNull()&&inputImage.IsNotNull())
     {
       ImageReadAccessor inputAcc(inputImage, inputImage->GetSliceData());
       outputImage->CopyInformation(inputImage);
       outputImage->Initialize(inputImage->GetPixelType(),inputImage->GetDimension(),inputImage->GetDimensions());
       outputImage->SetSlice(inputAcc.GetData());
     }
   }
   //mitk::Image::Pointer outputDistanceImage = this->GetOutput();
   ImageReadAccessor outputAcc(this->GetOutput(), this->GetOutput()->GetSliceData(0, 0, 0) );
   float* outputDistanceFloatData = (float*) outputAcc.GetData();
 
   //mitk::Image::Pointer inputDistanceImage = this->GetInput();
   ImageReadAccessor inputAcc(this->GetInput(), this->GetInput()->GetSliceData(0, 0, 0) );
 
   // copy initial distance image to ipl image
   float* distanceFloatData = (float*)inputAcc.GetData();
   memcpy(this->m_IplDistanceImage->imageData, (void*)distanceFloatData, this->m_ImageSize);
   if (m_ApplyThresholdFilter||m_ApplyMaskSegmentation)
   {
     ProcessSegmentation(this->m_IplDistanceImage);
   }
   if (this->m_ApplyTemporalMedianFilter||this->m_ApplyAverageFilter)
   {
     ProcessStreamedQuickSelectMedianImageFilter(this->m_IplDistanceImage);
   }
   if (this->m_ApplyMedianFilter)
   {
     ProcessCVMedianFilter(this->m_IplDistanceImage, this->m_IplOutputImage);
     memcpy( this->m_IplDistanceImage->imageData, this->m_IplOutputImage->imageData, this->m_ImageSize );
   }
   if (this->m_ApplyBilateralFilter)
   {
       float* itkFloatData = this->m_ItkInputImage->GetBufferPointer();
       memcpy(itkFloatData, this->m_IplDistanceImage->imageData, this->m_ImageSize );
       ItkImageType2D::Pointer itkOutputImage = ProcessItkBilateralFilter(this->m_ItkInputImage);
       memcpy( this->m_IplDistanceImage->imageData, itkOutputImage->GetBufferPointer(), this->m_ImageSize );
 
     //ProcessCVBilateralFilter(this->m_IplDistanceImage, this->m_OutputIplImage, domainSigma, rangeSigma, kernelRadius);
     //memcpy( distanceFloatData, this->m_OutputIplImage->imageData, distanceImageSize );
   }
   memcpy( outputDistanceFloatData, this->m_IplDistanceImage->imageData, this->m_ImageSize );
 }
 
 void mitk::ToFCompositeFilter::CreateOutputsForAllInputs()
 {
-  this->SetNumberOfOutputs(this->GetNumberOfInputs());  // create outputs for all inputs
+  this->SetNumberOfIndexedOutputs(this->GetNumberOfInputs());  // create outputs for all inputs
   for (unsigned int idx = 0; idx < this->GetNumberOfIndexedInputs(); ++idx)
     if (this->GetOutput(idx) == nullptr)
     {
       DataObjectPointer newOutput = this->MakeOutput(idx);
       this->SetNthOutput(idx, newOutput);
     }
     this->Modified();
 }
 
 void mitk::ToFCompositeFilter::GenerateOutputInformation()
 {
   mitk::Image::ConstPointer input = this->GetInput();
   mitk::Image::Pointer output = this->GetOutput();
 
   if (output->IsInitialized())
     return;
 
   itkDebugMacro(<<"GenerateOutputInformation()");
 
   output->Initialize(input->GetPixelType(), *input->GetTimeGeometry());
   output->SetPropertyList(input->GetPropertyList()->Clone());
 }
 
 void mitk::ToFCompositeFilter::ProcessSegmentation(IplImage* inputIplImage)
 {
   char* segmentationMask;
   if (m_SegmentationMask.IsNotNull())
   {
     ImageReadAccessor segMaskAcc(m_SegmentationMask, m_SegmentationMask->GetSliceData(0,0,0));
     segmentationMask = (char*)segMaskAcc.GetData();
   }
   else
   {
     segmentationMask = nullptr;
   }
   float *f = (float*)inputIplImage->imageData;
   for(int i=0; i<this->m_ImageWidth*this->m_ImageHeight; i++)
   {
     if (this->m_ApplyThresholdFilter)
     {
       if (f[i]<=m_ThresholdFilterMin)
       {
         f[i] = 0.0;
       }
       else if (f[i]>=m_ThresholdFilterMax)
       {
         f[i] = 0.0;
       }
     }
     if (this->m_ApplyMaskSegmentation)
     {
       if (segmentationMask)
       {
         if (segmentationMask[i]==0)
         {
           f[i] = 0.0;
         }
       }
     }
   }
 }
 
 ItkImageType2D::Pointer mitk::ToFCompositeFilter::ProcessItkBilateralFilter(ItkImageType2D::Pointer inputItkImage)
 {
   ItkImageType2D::Pointer outputItkImage;
   BilateralFilterType::Pointer bilateralFilter = BilateralFilterType::New();
   bilateralFilter->SetInput(inputItkImage);
   bilateralFilter->SetDomainSigma(m_BilateralFilterDomainSigma);
   bilateralFilter->SetRangeSigma(m_BilateralFilterRangeSigma);
   //bilateralFilter->SetRadius(m_BilateralFilterKernelRadius);
   outputItkImage = bilateralFilter->GetOutput();
   outputItkImage->Update();
   return outputItkImage;
 }
 
 void mitk::ToFCompositeFilter::ProcessCVBilateralFilter(IplImage* inputIplImage, IplImage* outputIplImage)
 {
   int diameter = m_BilateralFilterKernelRadius;
   double sigmaColor = m_BilateralFilterRangeSigma;
   double sigmaSpace = m_BilateralFilterDomainSigma;
   cvSmooth(inputIplImage, outputIplImage, CV_BILATERAL, diameter, 0, sigmaColor, sigmaSpace);
 }
 
 void mitk::ToFCompositeFilter::ProcessCVMedianFilter(IplImage* inputIplImage, IplImage* outputIplImage, int radius)
 {
   cvSmooth(inputIplImage, outputIplImage, CV_MEDIAN, radius, 0, 0, 0);
 }
 
 void mitk::ToFCompositeFilter::ProcessStreamedQuickSelectMedianImageFilter(IplImage* inputIplImage)
 {
   float* data = (float*)inputIplImage->imageData;
 
   int imageSize = inputIplImage->width * inputIplImage->height;
   float* tmpArray;
 
   if (this->m_TemporalMedianFilterNumOfFrames == 0)
   {
     return;
   }
 
   if (m_TemporalMedianFilterNumOfFrames != this->m_DataBufferMaxSize) // reset
   {
     //delete current buffer
     for( int i=0; i<this->m_DataBufferMaxSize; i++ ) {
       delete[] this->m_DataBuffer[i];
     }
     if (this->m_DataBuffer != nullptr)
     {
       delete[] this->m_DataBuffer;
     }
 
     this->m_DataBufferMaxSize = m_TemporalMedianFilterNumOfFrames;
 
     // create new buffer with current size
     this->m_DataBuffer = new float*[this->m_DataBufferMaxSize];
     for(int i=0; i<this->m_DataBufferMaxSize; i++)
     {
       this->m_DataBuffer[i] = nullptr;
     }
     this->m_DataBufferCurrentIndex = 0;
   }
 
   int currentBufferSize = this->m_DataBufferMaxSize;
   tmpArray = new float[this->m_DataBufferMaxSize];
 
   // copy data to buffer
   if (this->m_DataBuffer[this->m_DataBufferCurrentIndex] == nullptr)
   {
     this->m_DataBuffer[this->m_DataBufferCurrentIndex] = new float[imageSize];
     currentBufferSize = this->m_DataBufferCurrentIndex + 1;
   }
 
   for(int j=0; j<imageSize; j++)
   {
     this->m_DataBuffer[this->m_DataBufferCurrentIndex][j] = data[j];
   }
 
   float tmpValue = 0.0f;
   for(int i=0; i<imageSize; i++)
   {
     if (m_ApplyAverageFilter)
     {
       tmpValue = 0.0f;
       for(int j=0; j<currentBufferSize; j++)
       {
           tmpValue+=this->m_DataBuffer[j][i];
       }
       data[i] = tmpValue/currentBufferSize;
     }
     else if (m_ApplyTemporalMedianFilter)
     {
       for(int j=0; j<currentBufferSize; j++)
       {
         tmpArray[j] = this->m_DataBuffer[j][i];
       }
       data[i] = quick_select(tmpArray, currentBufferSize);
     }
   }
 
   this->m_DataBufferCurrentIndex = (this->m_DataBufferCurrentIndex + 1) % this->m_DataBufferMaxSize;
 
   delete[] tmpArray;
 }
 
 #define ELEM_SWAP(a,b) { register float t=(a);(a)=(b);(b)=t; }
 float mitk::ToFCompositeFilter::quick_select(float arr[], int n)
 {
   int low = 0;
   int high = n-1;
   int median = (low + high)/2;
   int middle = 0;
   int ll = 0;
   int hh = 0;
   for (;;) {
     if (high <= low) /* One element only */
       return arr[median] ;
     if (high == low + 1) { /* Two elements only */
       if (arr[low] > arr[high])
         ELEM_SWAP(arr[low], arr[high]) ;
       return arr[median] ;
     }
     /* Find median of low, middle and high items; swap into position low */
     middle = (low + high) / 2;
     if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]) ;
     if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]) ;
     if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]) ;
     /* Swap low item (now in position middle) into position (low+1) */
     ELEM_SWAP(arr[middle], arr[low+1]) ;
     /* Nibble from each end towards middle, swapping items when stuck */
     ll = low + 1;
     hh = high;
     for (;;) {
       do ll++; while (arr[low] > arr[ll]) ;
       do hh--; while (arr[hh] > arr[low]) ;
       if (hh < ll)
         break;
       ELEM_SWAP(arr[ll], arr[hh]) ;
     }
     /* Swap middle item (in position low) back into correct position */
     ELEM_SWAP(arr[low], arr[hh]) ;
     /* Re-set active partition */
     if (hh <= median)
       low = ll;
     if (hh >= median)
       high = hh - 1;
   }
 }
 #undef ELEM_SWAP
 
 void mitk::ToFCompositeFilter::SetTemporalMedianFilterParameter(int tmporalMedianFilterNumOfFrames)
 {
   this->m_TemporalMedianFilterNumOfFrames = tmporalMedianFilterNumOfFrames;
 }
 
 void mitk::ToFCompositeFilter::SetThresholdFilterParameter(int min, int max)
 {
   if (min > max)
   {
     min = max;
   }
   this->m_ThresholdFilterMin = min;
   this->m_ThresholdFilterMax = max;
 }
 
 void mitk::ToFCompositeFilter::SetBilateralFilterParameter(double domainSigma, double rangeSigma, int kernelRadius = 0)
 {
   this->m_BilateralFilterDomainSigma = domainSigma;
   this->m_BilateralFilterRangeSigma = rangeSigma;
   this->m_BilateralFilterKernelRadius = kernelRadius;
 }
 
 void mitk::ToFCompositeFilter::CreateItkImage(ItkImageType2D::Pointer &itkInputImage)
 {
   itkInputImage = ItkImageType2D::New();
   ItkImageType2D::IndexType startIndex;
   startIndex[0] =   0;  // first index on X
   startIndex[1] =   0;  // first index on Y
   ItkImageType2D::SizeType  size;
   size[0]  = this->m_ImageWidth;  // size along X
   size[1]  = this->m_ImageHeight;  // size along Y
   ItkImageType2D::RegionType region;
   region.SetSize( size );
   region.SetIndex( startIndex );
   itkInputImage->SetRegions( region );
   itkInputImage->Allocate();
 
 }
diff --git a/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp b/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
index 98fb84f68e..b31b5e7199 100644
--- a/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFDistanceImageToPointSetFilter.cpp
@@ -1,220 +1,220 @@
 /*===================================================================
 
 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 "mitkToFDistanceImageToPointSetFilter.h"
 
 #include "mitkImageDataItem.h"
 #include "mitkPointSet.h"
 #include <mitkImagePixelReadAccessor.h>
 #include "mitkToFProcessingCommon.h"
 
 mitk::ToFDistanceImageToPointSetFilter::ToFDistanceImageToPointSetFilter()
 : m_Subset(0), m_CameraIntrinsics(), m_InterPixelDistance()
 {
   m_InterPixelDistance.Fill(0.045);
   m_CameraIntrinsics = mitk::CameraIntrinsics::New();
   m_CameraIntrinsics->SetFocalLength(5.9421434211923247e+02,5.9104053696870778e+02);
   m_CameraIntrinsics->SetPrincipalPoint(3.3930780975300314e+02,2.4273913761751615e+02);
   m_CameraIntrinsics->SetDistorsionCoeffs(-0.36874385358645773f,-0.14339503290129013,0.0033210108720361795,-0.004277703352074105);
   m_ReconstructionMode = true;
 }
 
 mitk::ToFDistanceImageToPointSetFilter::~ToFDistanceImageToPointSetFilter()
 {
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetInput(const mitk::Image* distanceImage )
 {
   this->SetInput(0,distanceImage);
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetInput( unsigned int idx,const mitk::Image* distanceImage )
 {
   if ((distanceImage == nullptr) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to nullptr, reduce the number of inputs by one
   {
-    this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
+    this->SetNumberOfIndexedInputs(this->GetNumberOfInputs() - 1);
   }
   else
   {
     this->ProcessObject::SetNthInput(idx, const_cast<mitk::Image*>(distanceImage));   // Process object is not const-correct so the const_cast is required here
     this->CreateOutputsForAllInputs();
   }
 }
 
 mitk::Image* mitk::ToFDistanceImageToPointSetFilter::GetInput()
 {
   return this->GetInput(0);
 }
 
 mitk::Image* mitk::ToFDistanceImageToPointSetFilter::GetInput( unsigned int idx )
 {
   if (this->GetNumberOfInputs() < 1)
     return nullptr;
 
   return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetSubset(std::vector<itk::Index<3> > subset)
 {
   // check if points of PointSet are inside the input image
   mitk::Image::Pointer input = this->GetInput();
 
   unsigned int xDim = UINT_MAX;
   unsigned int yDim = UINT_MAX;
 
   if(input.IsNotNull() && input->IsInitialized())
   {
     xDim = input->GetDimension(0);
     yDim = input->GetDimension(1);
   }
 
   bool pointSetValid = true;
   for (unsigned int i=0; i<subset.size(); i++)
   {
     itk::Index<3> currentIndex = subset.at(i);
     if (currentIndex[0] < 0 || currentIndex[0] > static_cast<itk::IndexValueType>(xDim) ||
         currentIndex[1] < 0 || currentIndex[1] > static_cast<itk::IndexValueType>(yDim))
     {
       pointSetValid = false;
     }
   }
   if (pointSetValid)
   {
     m_Subset = subset;
   }
   else
   {
     MITK_ERROR<<"One or more indizes are located outside the image domain";
   }
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetSubset( mitk::PointSet::Pointer pointSet)
 {
   std::vector<itk::Index<3> > subset;
   for (int i=0; i<pointSet->GetSize(); i++)
   {
     mitk::Point3D currentPoint = pointSet->GetPoint(i);
     itk::Index<3> currentIndex;
     currentIndex[0] = currentPoint[0];
     currentIndex[1] = currentPoint[1];
     currentIndex[2] = currentPoint[2];
     subset.push_back(currentIndex);
   }
   this->SetSubset(subset);
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::GenerateData()
 {
   //calculate world coordinates
   mitk::ToFProcessingCommon::ToFPoint2D focalLengthInPixelUnits;
   mitk::ToFProcessingCommon::ToFScalarType focalLengthInMm;
   if (m_ReconstructionMode)
   {
     focalLengthInPixelUnits[0] = m_CameraIntrinsics->GetFocalLengthX();
     focalLengthInPixelUnits[1] = m_CameraIntrinsics->GetFocalLengthY();
   }
   else
     focalLengthInMm = (m_CameraIntrinsics->GetFocalLengthX()*m_InterPixelDistance[0]+m_CameraIntrinsics->GetFocalLengthY()*m_InterPixelDistance[1])/2.0;
 
   mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
   principalPoint[0] = m_CameraIntrinsics->GetPrincipalPointX();
   principalPoint[1] = m_CameraIntrinsics->GetPrincipalPointY();
 
   mitk::PointSet::Pointer output = this->GetOutput();
   assert(output);
   mitk::Image::Pointer input = this->GetInput();
   assert(input);
 
   //compute subset of points if input PointSet is defined
   if (m_Subset.size()!=0)
   {
     mitk::ImagePixelReadAccessor<float,2> imageAcces(input, input->GetSliceData(0));
     for (unsigned int i=0; i<m_Subset.size(); i++)
     {
       itk::Index<3> currentIndex = m_Subset.at(i);
       itk::Index<2> index2D;
       index2D[0] = currentIndex[0];
       index2D[1] = currentIndex[1];
       mitk::ToFProcessingCommon::ToFScalarType distance = (double)imageAcces.GetPixelByIndex(index2D);
 
       mitk::Point3D currentPoint;
       if (m_ReconstructionMode)
         currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(currentIndex,distance,focalLengthInPixelUnits,principalPoint);
       else
         currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(currentIndex,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
 
       output->InsertPoint(i,currentPoint);
     }
   }
   else //compute PointSet holding cartesian coordinates for every image point
   {
     int xDimension = (int)input->GetDimension(0);
     int yDimension = (int)input->GetDimension(1);
     int pointCount = 0;
     mitk::ImagePixelReadAccessor<float,2> imageAcces(input, input->GetSliceData(0));
     for (int j=0; j<yDimension; j++)
     {
       for (int i=0; i<xDimension; i++)
       {
         itk::Index<2> pixel;
         pixel[0] = i;
         pixel[1] = j;
 
         mitk::ToFProcessingCommon::ToFScalarType distance = (double)imageAcces.GetPixelByIndex(pixel);
 
       mitk::Point3D currentPoint;
       if (m_ReconstructionMode)
         currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthInPixelUnits,principalPoint);
       else
         currentPoint = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
 
         if (distance>mitk::eps)
         {
           output->InsertPoint( pointCount, currentPoint );
           pointCount++;
         }
       }
     }
   }
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::CreateOutputsForAllInputs()
 {
-  this->SetNumberOfOutputs(this->GetNumberOfInputs());  // create outputs for all inputs
+  this->SetNumberOfIndexedOutputs(this->GetNumberOfInputs());  // create outputs for all inputs
   for (unsigned int idx = 0; idx < this->GetNumberOfIndexedOutputs(); ++idx)
     if (this->GetOutput(idx) == nullptr)
     {
       DataObjectPointer newOutput = this->MakeOutput(idx);
       this->SetNthOutput(idx, newOutput);
     }
     this->Modified();
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::GenerateOutputInformation()
 {
   this->GetOutput();
   itkDebugMacro(<<"GenerateOutputInformation()");
 }
 
 void mitk::ToFDistanceImageToPointSetFilter::SetReconstructionMode(bool withoutInterpixdist)
 {
   this->m_ReconstructionMode = withoutInterpixdist;
 }
 
 bool mitk::ToFDistanceImageToPointSetFilter::GetReconstructionMode()
 {
   return (this->m_ReconstructionMode);
 }
diff --git a/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp b/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
index 667d80b57a..f568b2994b 100644
--- a/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFDistanceImageToSurfaceFilter.cpp
@@ -1,351 +1,351 @@
 /*===================================================================
 
 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 <mitkToFDistanceImageToSurfaceFilter.h>
 #include <mitkInstantiateAccessFunctions.h>
 #include <mitkSurface.h>
 #include "mitkImageReadAccessor.h"
 
 #include <itkImage.h>
 
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPointData.h>
 #include <vtkFloatArray.h>
 #include <vtkSmartPointer.h>
 #include <vtkIdList.h>
 
 #include <math.h>
 #include <vtkMath.h>
 
 mitk::ToFDistanceImageToSurfaceFilter::ToFDistanceImageToSurfaceFilter() :
   m_IplScalarImage(nullptr), m_CameraIntrinsics(), m_TextureImageWidth(0), m_TextureImageHeight(0), m_InterPixelDistance(), m_TextureIndex(0),
   m_GenerateTriangularMesh(true), m_TriangulationThreshold(0.0)
 {
   m_InterPixelDistance.Fill(0.045);
   m_CameraIntrinsics = mitk::CameraIntrinsics::New();
   m_CameraIntrinsics->SetFocalLength(273.138946533,273.485900879);
   m_CameraIntrinsics->SetPrincipalPoint(107.867935181,98.3807373047);
   m_CameraIntrinsics->SetDistorsionCoeffs(-0.486690014601f,0.553943634033f,0.00222016777843f,-0.00300851115026f);
   m_ReconstructionMode = WithInterPixelDistance;
 }
 
 mitk::ToFDistanceImageToSurfaceFilter::~ToFDistanceImageToSurfaceFilter()
 {
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::SetInput( Image* distanceImage, mitk::CameraIntrinsics::Pointer cameraIntrinsics )
 {
   this->SetCameraIntrinsics(cameraIntrinsics);
   this->SetInput(0,distanceImage);
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::SetInput( unsigned int idx,  Image* distanceImage, mitk::CameraIntrinsics::Pointer cameraIntrinsics )
 {
   this->SetCameraIntrinsics(cameraIntrinsics);
   this->SetInput(idx,distanceImage);
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::SetInput(  mitk::Image* distanceImage )
 {
   this->SetInput(0,distanceImage);
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::SetInput( unsigned int idx,  mitk::Image* distanceImage )
 {
   if ((distanceImage == nullptr) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to nullptr, reduce the number of inputs by one
-    this->SetNumberOfInputs(this->GetNumberOfInputs() - 1);
+    this->SetNumberOfIndexedInputs(this->GetNumberOfInputs() - 1);
   else
     this->ProcessObject::SetNthInput(idx, distanceImage);   // Process object is not const-correct so the const_cast is required here
 
   this->CreateOutputsForAllInputs();
 }
 
 mitk::Image* mitk::ToFDistanceImageToSurfaceFilter::GetInput()
 {
   return this->GetInput(0);
 }
 
 mitk::Image* mitk::ToFDistanceImageToSurfaceFilter::GetInput( unsigned int idx )
 {
   if (this->GetNumberOfInputs() < 1)
   {
     mitkThrow() << "No input given for ToFDistanceImageToSurfaceFilter";
   }
   return static_cast< mitk::Image*>(this->ProcessObject::GetInput(idx));
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::GenerateData()
 {
   mitk::Surface::Pointer output = this->GetOutput();
   assert(output);
   mitk::Image::Pointer input = this->GetInput();
   assert(input);
   // mesh points
   int xDimension = input->GetDimension(0);
   int yDimension = input->GetDimension(1);
   unsigned int size = xDimension*yDimension; //size of the image-array
   std::vector<bool> isPointValid;
   isPointValid.resize(size);
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   points->SetDataTypeToDouble();
   vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkCellArray> vertices = vtkSmartPointer<vtkCellArray>::New();
   vtkSmartPointer<vtkFloatArray> scalarArray = vtkSmartPointer<vtkFloatArray>::New();
   vtkSmartPointer<vtkFloatArray> textureCoords = vtkSmartPointer<vtkFloatArray>::New();
   textureCoords->SetNumberOfComponents(2);
   textureCoords->Allocate(size);
 
   //Make a vtkIdList to save the ID's of the polyData corresponding to the image
   //pixel ID's. See below for more documentation.
   m_VertexIdList = vtkSmartPointer<vtkIdList>::New();
   //Allocate the object once else it would automatically allocate new memory
   //for every vertex and perform a copy which is expensive.
   m_VertexIdList->Allocate(size);
   m_VertexIdList->SetNumberOfIds(size);
   for(unsigned int i = 0; i < size; ++i)
   {
     m_VertexIdList->SetId(i, 0);
   }
 
   float* scalarFloatData = nullptr;
 
   if (this->m_IplScalarImage) // if scalar image is defined use it for texturing
   {
     scalarFloatData = (float*)this->m_IplScalarImage->imageData;
   }
   else if (this->GetInput(m_TextureIndex)) // otherwise use intensity image (input(2))
   {
     ImageReadAccessor inputAcc(this->GetInput(m_TextureIndex));
     scalarFloatData = (float*)inputAcc.GetData();
   }
 
   ImageReadAccessor inputAcc(input, input->GetSliceData(0,0,0));
   float* inputFloatData = (float*)inputAcc.GetData();
   //calculate world coordinates
   mitk::ToFProcessingCommon::ToFPoint2D focalLengthInPixelUnits;
   mitk::ToFProcessingCommon::ToFScalarType focalLengthInMm;
   if((m_ReconstructionMode == WithOutInterPixelDistance) || (m_ReconstructionMode == Kinect))
   {
     focalLengthInPixelUnits[0] = m_CameraIntrinsics->GetFocalLengthX();
     focalLengthInPixelUnits[1] = m_CameraIntrinsics->GetFocalLengthY();
   }
   else if( m_ReconstructionMode == WithInterPixelDistance)
   {
     //convert focallength from pixel to mm
     focalLengthInMm = (m_CameraIntrinsics->GetFocalLengthX()*m_InterPixelDistance[0]+m_CameraIntrinsics->GetFocalLengthY()*m_InterPixelDistance[1])/2.0;
   }
 
   mitk::ToFProcessingCommon::ToFPoint2D principalPoint;
   principalPoint[0] = m_CameraIntrinsics->GetPrincipalPointX();
   principalPoint[1] = m_CameraIntrinsics->GetPrincipalPointY();
 
   mitk::Point3D origin = input->GetGeometry()->GetOrigin();
   mitk::Vector3D spacing = input->GetGeometry()->GetSpacing();
 
   for (int j=0; j<yDimension; j++)
   {
     for (int i=0; i<xDimension; i++)
     {
       unsigned int pixelID = i+j*xDimension;
 
       mitk::ToFProcessingCommon::ToFScalarType distance = (double)inputFloatData[pixelID];
 
       /** Here we have to incorporate spacing and origin to allow processing of cropped/resampled images
       * Usually origin will be [0, 0, 0] and spacing will be [1, 1, 1], but just in case the image is moved
       * due to cropping or the spacing differes due to up- or downsampling.*/
       unsigned int completeIndexX = i*spacing[0]+origin[0];
       unsigned int completeIndexY = j*spacing[1]+origin[1];
 
       mitk::ToFProcessingCommon::ToFPoint3D cartesianCoordinates;
       switch (m_ReconstructionMode)
       {
       case WithOutInterPixelDistance:
       {
         cartesianCoordinates = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(completeIndexX,completeIndexY,distance,focalLengthInPixelUnits,principalPoint);
         break;
       }
       case WithInterPixelDistance:
       {
         cartesianCoordinates = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(completeIndexX,completeIndexY,distance,focalLengthInMm,m_InterPixelDistance,principalPoint);
         break;
       }
       case Kinect:
       {
         cartesianCoordinates = mitk::ToFProcessingCommon::KinectIndexToCartesianCoordinates(completeIndexX,completeIndexY,distance,focalLengthInPixelUnits,principalPoint);
         break;
       }
       default:
       {
         MITK_ERROR << "Incorrect reconstruction mode!";
       }
       }
       //Epsilon here, because we may have small float values like 0.00000001 which in fact represents 0.
       if (distance<=mitk::eps)
       {
         isPointValid[pixelID] = false;
       }
       else
       {
         isPointValid[pixelID] = true;
         //VTK would insert empty points into the polydata if we use
         //points->InsertPoint(pixelID, cartesianCoordinates.GetDataPointer()).
         //If we use points->InsertNextPoint(...) instead, the ID's do not
         //correspond to the image pixel ID's. Thus, we have to save them
         //in the vertexIdList.
         m_VertexIdList->SetId(pixelID, points->InsertNextPoint(cartesianCoordinates.GetDataPointer()));
 
         if (m_GenerateTriangularMesh)
         {
           if((i >= 1) && (j >= 1))
           {
             //This little piece of art explains the ID's:
             //
             // P(x_1y_1)---P(xy_1)
             // |           |
             // |           |
             // |           |
             // P(x_1y)-----P(xy)
             //
             //We can only start triangulation if we are at vertex (1,1),
             //because we need the other 3 vertices near this one.
             //To go one pixel line back in the image array, we have to
             //subtract 1x xDimension.
             vtkIdType xy = pixelID;
             vtkIdType x_1y = pixelID-1;
             vtkIdType xy_1 = pixelID-xDimension;
             vtkIdType x_1y_1 = xy_1-1;
 
             //Find the corresponding vertex ID's in the saved vertexIdList:
             vtkIdType xyV = m_VertexIdList->GetId(xy);
             vtkIdType x_1yV = m_VertexIdList->GetId(x_1y);
             vtkIdType xy_1V = m_VertexIdList->GetId(xy_1);
             vtkIdType x_1y_1V = m_VertexIdList->GetId(x_1y_1);
 
             if (isPointValid[xy]&&isPointValid[x_1y]&&isPointValid[x_1y_1]&&isPointValid[xy_1]) // check if points of cell are valid
             {
               double pointXY[3], pointX_1Y[3], pointXY_1[3], pointX_1Y_1[3];
 
               points->GetPoint(xyV, pointXY);
               points->GetPoint(x_1yV, pointX_1Y);
               points->GetPoint(xy_1V, pointXY_1);
               points->GetPoint(x_1y_1V, pointX_1Y_1);
 
               if( (mitk::Equal(m_TriangulationThreshold, 0.0)) || ((vtkMath::Distance2BetweenPoints(pointXY, pointX_1Y) <= m_TriangulationThreshold)
                                                                    && (vtkMath::Distance2BetweenPoints(pointXY, pointXY_1) <= m_TriangulationThreshold)
                                                                    && (vtkMath::Distance2BetweenPoints(pointX_1Y, pointX_1Y_1) <= m_TriangulationThreshold)
                                                                    && (vtkMath::Distance2BetweenPoints(pointXY_1, pointX_1Y_1) <= m_TriangulationThreshold)))
               {
                 polys->InsertNextCell(3);
                 polys->InsertCellPoint(x_1yV);
                 polys->InsertCellPoint(xyV);
                 polys->InsertCellPoint(x_1y_1V);
 
                 polys->InsertNextCell(3);
                 polys->InsertCellPoint(x_1y_1V);
                 polys->InsertCellPoint(xyV);
                 polys->InsertCellPoint(xy_1V);
               }
               else
               {
                 //We dont want triangulation, but we want to keep the vertex
                 vertices->InsertNextCell(1);
                 vertices->InsertCellPoint(xyV);
               }
             }
           }
         }
         else
         {
           //We dont want triangulation, we only want vertices
           vertices->InsertNextCell(1);
           vertices->InsertCellPoint(m_VertexIdList->GetId(pixelID));
         }
         //Scalar values are necessary for mapping colors/texture onto the surface
         if (scalarFloatData)
         {
           scalarArray->InsertTuple1(m_VertexIdList->GetId(pixelID), scalarFloatData[pixelID]);
         }
         //These Texture Coordinates will map color pixel and vertices 1:1 (e.g. for Kinect).
         float xNorm = (((float)i)/xDimension);// correct video texture scale for kinect
         float yNorm = ((float)j)/yDimension; //don't flip. we don't need to flip.
         textureCoords->InsertTuple2(m_VertexIdList->GetId(pixelID), xNorm, yNorm);
       }
     }
   }
 
   vtkSmartPointer<vtkPolyData> mesh = vtkSmartPointer<vtkPolyData>::New();
   mesh->SetPoints(points);
   mesh->SetPolys(polys);
   mesh->SetVerts(vertices);
   //Pass the scalars to the polydata (if they were set).
   if (scalarArray->GetNumberOfTuples()>0)
   {
     mesh->GetPointData()->SetScalars(scalarArray);
   }
   //Pass the TextureCoords to the polydata anyway (to save them).
   mesh->GetPointData()->SetTCoords(textureCoords);
   output->SetVtkPolyData(mesh);
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::CreateOutputsForAllInputs()
 {
-  this->SetNumberOfOutputs(this->GetNumberOfInputs());  // create outputs for all inputs
+  this->SetNumberOfIndexedOutputs(this->GetNumberOfInputs());  // create outputs for all inputs
   for (unsigned int idx = 0; idx < this->GetNumberOfOutputs(); ++idx)
     if (this->GetOutput(idx) == nullptr)
     {
       DataObjectPointer newOutput = this->MakeOutput(idx);
       this->SetNthOutput(idx, newOutput);
     }
   this->Modified();
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::GenerateOutputInformation()
 {
   this->GetOutput();
   itkDebugMacro(<<"GenerateOutputInformation()");
 
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::SetScalarImage(IplImage* iplScalarImage)
 {
   this->m_IplScalarImage = iplScalarImage;
   this->Modified();
 }
 
 IplImage* mitk::ToFDistanceImageToSurfaceFilter::GetScalarImage()
 {
   return this->m_IplScalarImage;
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::SetTextureImageWidth(int width)
 {
   this->m_TextureImageWidth = width;
 }
 
 void mitk::ToFDistanceImageToSurfaceFilter::SetTextureImageHeight(int height)
 {
   this->m_TextureImageHeight = height;
 }
 
 
 void mitk::ToFDistanceImageToSurfaceFilter::SetTriangulationThreshold(double triangulationThreshold)
 {
   //vtkMath::Distance2BetweenPoints returns the squared distance between two points and
   //hence we square m_TriangulationThreshold in order to save run-time.
   this->m_TriangulationThreshold = triangulationThreshold*triangulationThreshold;
 }