diff --git a/Modules/CameraCalibration/mitkCameraIntrinsics.h b/Modules/CameraCalibration/mitkCameraIntrinsics.h
index 24466803e6..45b96bfaa1 100644
--- a/Modules/CameraCalibration/mitkCameraIntrinsics.h
+++ b/Modules/CameraCalibration/mitkCameraIntrinsics.h
@@ -1,144 +1,145 @@
 /*===================================================================
 
 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 mitkCameraIntrinsics_h
 #define mitkCameraIntrinsics_h
 
 #include <mitkCommon.h>
 #include <mitkNumericTypes.h>
 #include <itkDataObject.h>
 #include <itkFastMutexLock.h>
-#include <cv.h>
 #include <vnl/vnl_matrix_fixed.h>
 #include "mitkXMLSerializable.h"
 #include <MitkCameraCalibrationExports.h>
 
+#include "opencv2/core.hpp"
+
 int mitkCameraIntrinsicsTest(int, char* []);
 
 namespace mitk
 {
   ///
   /// \brief class representing camera intrinsics and related functions
   ///
   class MITKCAMERACALIBRATION_EXPORT CameraIntrinsics: virtual public itk::Object,
     virtual public mitk::XMLSerializable
   {
   public:
     ///
     /// for testing purposes
     ///
     friend int mitkCameraIntrinsicsTest(int argc, char* argv[]);
     ///
     /// smartpointer typedefs
     ///
     mitkClassMacroItkParent(CameraIntrinsics, itk::Object);
     ///
     /// the static new function
     ///
     itkFactorylessNewMacro(Self);
 
     ///
     /// make a clone of this intrinsics
     ///
     itkCloneMacro(Self)
 
     ///
     /// copy information from other to this
     ///
     void Copy(const CameraIntrinsics* other);
 
     ///
     /// checks two intrinsics for equality
     ///
     bool Equals( const CameraIntrinsics* other ) const;
 
     ///
     /// \return the intrinsic parameter matrix as a 3x3 vnl matrix
     ///
     vnl_matrix_fixed<mitk::ScalarType, 3, 3> GetVnlCameraMatrix() const;
 
     ///
     /// \return the intrinsic parameter matrix as a 3x4 vnl matrix
     /// (the last column only containing zeros)
     ///
     vnl_matrix_fixed<mitk::ScalarType, 3, 4> GetVnlCameraMatrix3x4() const;
 
     ///
     /// \return true if the intrinsics are set (some plausibility checks
     /// may be done here)
     ///
     bool IsValid() const;
     void SetValid(bool valid);
     cv::Mat GetCameraMatrix() const;
     cv::Mat GetDistorsionCoeffs();
     cv::Mat GetDistorsionCoeffs() const;
     void ToXML(TiXmlElement* elem) const override;
     std::string ToString() const;
     std::string GetString();
     double GetFocalLengthX() const;
     double GetFocalLengthY() const;
     double GetPrincipalPointX() const;
     double GetPrincipalPointY() const;
     mitk::Point4D GetDistorsionCoeffsAsPoint4D() const;
     mitk::Point3D GetFocalPoint() const;
     mitk::Point3D GetPrincipalPoint() const;
     vnl_vector_fixed<mitk::ScalarType, 2> GetFocalPointAsVnlVector() const;
     vnl_vector_fixed<mitk::ScalarType, 2> GetPrincipalPointAsVnlVector() const;
 
     ///
     /// set a new camera matrix utilizing a vnl matrix
     ///
     void SetCameraMatrix( const vnl_matrix_fixed<mitk::ScalarType, 3, 3>&
                         _CameraMatrix );
 
     void SetIntrinsics( const cv::Mat& _CameraMatrix
                         , const cv::Mat& _DistorsionCoeffs);
 
     void SetFocalLength( double x, double y );
     void SetPrincipalPoint( double x, double y );
     void SetDistorsionCoeffs( double k1, double k2, double p1, double p2 );
 
     void SetIntrinsics( const mitk::Point3D& focalPoint,
                         const mitk::Point3D& principalPoint,
                         const mitk::Point4D& distortionCoefficients);
 
     void FromXML(TiXmlElement* elem) override;
     void FromGMLCalibrationXML(TiXmlElement* elem);
     std::string ToOctaveString(const std::string& varName="CameraIntrinsics");
 
     ~CameraIntrinsics() override;
 
   protected:
     CameraIntrinsics();
     CameraIntrinsics(const CameraIntrinsics& other);
 
     cv::Mat m_CameraMatrix;
     cv::Mat m_DistorsionCoeffs;
     bool m_Valid;
     itk::FastMutexLock::Pointer m_Mutex;
 
   private:
 
     itk::LightObject::Pointer InternalClone() const override;
   };
 
 } // namespace mitk
 
 MITKCAMERACALIBRATION_EXPORT std::ostream& operator<<
     (std::ostream& os, mitk::CameraIntrinsics::Pointer p);
 
 #endif // mitkCameraIntrinsics_h
diff --git a/Modules/OpenCVVideoSupport/mitkUndistortCameraImage.h b/Modules/OpenCVVideoSupport/mitkUndistortCameraImage.h
index e9561d8d62..bb709aad58 100644
--- a/Modules/OpenCVVideoSupport/mitkUndistortCameraImage.h
+++ b/Modules/OpenCVVideoSupport/mitkUndistortCameraImage.h
@@ -1,128 +1,130 @@
 /*===================================================================
 
 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 __mitkUndistortCameraImage_h
 #define __mitkUndistortCameraImage_h
 
 #include "mitkCommon.h"
 #include <MitkOpenCVVideoSupportExports.h>
 #include "itkObject.h"
 
 #include "mitkPoint.h"
-#include "cv.h"
+
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
 
 /*!
 \brief UndistortCameraImage
 
 This class is used to undistort camera images. Before any undistortion the class has to be initialized using the functions:
 SetFocalLength(),SetPrinzipalPoint() and SetCameraDistortion().
 After this you can either use UndistortPixel() to undistort a single pixel's coordinates or UndistortImage() to undistort an
 OpenCV image.
 
 A faster version of UndistortImage() is UndistortImageFast(), however, it has to be initialized once with SetUndistortImageFastInfo()
 instead of the Set... methods before use.
 
 \sa QmitkFunctionality
 \ingroup Functionalities
 */
 
 namespace mitk
 {
 
 class MITKOPENCVVIDEOSUPPORT_EXPORT UndistortCameraImage : public itk::Object
 {
   public:
 
     mitkClassMacroItkParent(UndistortCameraImage,itk::Object);
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     /// Initialization ///
     /*
     * Set the camera's intrinsic focal length
     */
     void SetFocalLength(float fc_x, float fc_y)
     {
       m_fcX = fc_x; m_fcY = fc_y;
     }
     /*
     * Set the camera's intrinsic principal point
     */
     void SetPrincipalPoint(float cc_x, float cc_y)
     {
       m_ccX = cc_x; m_ccY = cc_y;
     }
     /*
     * Set the camera's intrinsic distortion parameters
     */
     void SetCameraDistortion(float kc1, float kc2, float kc3, float kc4)
     {
       m_distortionMatrixData[0] = kc1; m_distortionMatrixData[1] = kc2;
       m_distortionMatrixData[2] = kc3; m_distortionMatrixData[3] = kc4;
     }
     /*
     * Pre-Calculates matrices for the later use of UndistortImageFast()
     */
     void InitRemapUndistortion(int sizeX, int sizeY);
 
     /// USAGE ///
     /*
     * Undistort a single pixel, returns undistorted pixel
     */
     mitk::Point2D UndistortPixel(const mitk::Point2D& src);
     /*
     * Complete undistortion of an OpenCV image, including all calculations
     */
     void UndistortImage(IplImage* src, IplImage* dst);
 
 
     /*
     * Complete undistortion of an OpenCV image, using pre-calculated matrices from SetUndistortImageFastInfo()
     * The use of only a source parameter will cause the source to be overwritten.
     * NOTE: Using the Fast undistortion methods does not require a initialization via the Set... methods.
     */
     void UndistortImageFast( IplImage * src, IplImage* dst = nullptr );
     void SetUndistortImageFastInfo(float in_dF1, float in_dF2,
                                    float in_dPrincipalX, float in_dPrincipalY,
                                    float in_Dist[4], float ImageSizeX, float ImageSizeY);
 
     UndistortCameraImage();
     ~UndistortCameraImage() override;
 
   protected:
 
     // principal point and focal length parameters
     float m_ccX, m_ccY, m_fcX, m_fcY;
     // undistortion parameters
     float m_distortionMatrixData[4];
     // intrinsic camera parameters
     float m_intrinsicMatrixData[9];
     // precalculated matrices for fast image undistortion with UndistortImageFast()
     CvMat * m_mapX, * m_mapY;
     // intrinsic and undistortion camera matrices
     CvMat m_intrinsicMatrix, m_distortionMatrix;
     // temp image
     IplImage * m_tempImage;
 
 
 
     CvMat *m_DistortionCoeffs;
     CvMat *m_CameraMatrix;
 };
 
 }
 
 #endif
diff --git a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
index c336ba8c3a..94a632b937 100644
--- a/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
+++ b/Modules/ToFProcessing/mitkToFCompositeFilter.cpp
@@ -1,400 +1,402 @@
 /*===================================================================
 
 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>
 
+#include "opencv2/imgproc.hpp"
+
 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(  const InputImageType* distanceImage )
 {
   this->SetInput(0, distanceImage);
 }
 
 void mitk::ToFCompositeFilter::SetInput( unsigned int idx,  const InputImageType* distanceImage )
 {
   if ((distanceImage == nullptr) && (idx == this->GetNumberOfInputs() - 1)) // if the last input is set to nullptr, reduce the number of inputs by one
   {
     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, const_cast<InputImageType*>(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->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/mitkToFCompositeFilter.h b/Modules/ToFProcessing/mitkToFCompositeFilter.h
index e520b96280..cbdc1686cb 100644
--- a/Modules/ToFProcessing/mitkToFCompositeFilter.h
+++ b/Modules/ToFProcessing/mitkToFCompositeFilter.h
@@ -1,201 +1,201 @@
 /*===================================================================
 
 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 __mitkToFCompositeFilter_h
 #define __mitkToFCompositeFilter_h
 
 #include <mitkImage.h>
 #include "mitkImageToImageFilter.h"
 #include <MitkToFProcessingExports.h>
-#include <cv.h>
 #include <itkBilateralImageFilter.h>
+#include "opencv2/core.hpp"
 
 typedef itk::Image<float, 2> ItkImageType2D;
 typedef itk::Image<float, 3> ItkImageType3D;
 typedef itk::BilateralImageFilter<ItkImageType2D,ItkImageType2D> BilateralFilterType;
 
 namespace mitk
 {
   /**
   * @brief Applies a common filter-pipeline to the first input of this filter
   *
   * This class intends to allow quick preprocessing of (ToF) range data. Input 0 of this filter, holding the range image,
   * is processed using the following image processing filters:
   * - threshold filter
   * - mask segmentation
   * - temporal median filter
   * - spatial median filter
   * - bilateral filter
   *
   * @ingroup ToFProcessing
   */
   class MITKTOFPROCESSING_EXPORT ToFCompositeFilter : public ImageToImageFilter
   {
   public:
 
     mitkClassMacro( ToFCompositeFilter , ImageToImageFilter );
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
     itkSetMacro(SegmentationMask,mitk::Image::Pointer);
     itkSetMacro(ApplyTemporalMedianFilter,bool);
     itkGetConstMacro(ApplyTemporalMedianFilter,bool);
     itkSetMacro(ApplyAverageFilter,bool);
     itkGetConstMacro(ApplyAverageFilter,bool);
     itkSetMacro(ApplyMedianFilter,bool);
     itkGetConstMacro(ApplyMedianFilter,bool);
     itkSetMacro(ApplyThresholdFilter,bool);
     itkGetConstMacro(ApplyThresholdFilter,bool);
     itkSetMacro(ApplyMaskSegmentation,bool);
     itkGetConstMacro(ApplyMaskSegmentation,bool);
     itkSetMacro(ApplyBilateralFilter,bool);
     itkGetConstMacro(ApplyBilateralFilter,bool);
 
     using itk::ProcessObject::SetInput;
 
      /*!
     \brief sets the input of this filter
     \param distanceImage input is the distance image of e.g. a ToF camera
     */
     void SetInput( const InputImageType* distanceImage) override;
 
     /*!
     \brief sets the input of this filter at idx
     \param idx number of the current input
     \param distanceImage input is the distance image of e.g. a ToF camera
     */
     void SetInput(unsigned int idx,  const InputImageType* distanceImage) override;
 
     /*!
     \brief returns the input of this filter
     */
     Image* GetInput();
 
     /*!
     \brief returns the input with id idx of this filter
     */
     Image* GetInput(unsigned int idx);
     /*!
     \brief Sets the parameter of the temporal median filter
     \param tmporalMedianFilterNumOfFrames number of frames to be considered for calulating the temporal median
     */
     void SetTemporalMedianFilterParameter(int tmporalMedianFilterNumOfFrames);
     /*!
     \brief Sets the parameters (lower, upper threshold) of the threshold filter
     \param min lower threshold of the threshold filter
     \param max upper threshold of the threshold filter
     */
     void SetThresholdFilterParameter(int min, int max);
     /*!
     \brief Sets the parameters (domain sigma, range sigma, kernel radius) of the bilateral filter
     \param domainSigma Parameter controlling the smoothing effect of the bilateral filter. Default value: 2
     \param rangeSigma Parameter controlling the edge preserving effect of the bilateral filter. Default value: 60
     \param kernelRadius radius of the filter mask of the bilateral filter
     */
     void SetBilateralFilterParameter(double domainSigma, double rangeSigma, int kernelRadius);
 
   protected:
     /*!
     \brief standard constructor
     */
     ToFCompositeFilter();
     /*!
     \brief standard destructor
     */
     ~ToFCompositeFilter() override;
     void GenerateOutputInformation() override;
     /*!
     \brief method generating the output of this filter. Called in the updated process of the pipeline.
     This method generates the output of the ToFSurfaceSource: The generated surface of the 3d points
     */
     void GenerateData() override;
     /**
     * \brief Create an output for each input
     *
     * This Method sets the number of outputs to the number of inputs
     * and creates missing outputs objects.
     * \warning any additional outputs that exist before the method is called are deleted
     */
     void CreateOutputsForAllInputs();
     /*!
     \brief Applies a mask and/or threshold segmentation to the input image.
     All pixels with values outside the mask, below the lower threshold (min) and above the upper threshold (max)
     are assigned the pixel value 0
     */
     void ProcessSegmentation(IplImage* inputIplImage);
     /*!
     \brief Applies the ITK bilateral filter to the input image
     See http://www.itk.org/Doxygen320/html/classitk_1_1BilateralImageFilter.html for more details.
     */
     ItkImageType2D::Pointer ProcessItkBilateralFilter(ItkImageType2D::Pointer inputItkImage);
     /*!
     \brief Applies the OpenCV bilateral filter to the input image.
     See http://opencv.willowgarage.com/documentation/c/image_filtering.html#smooth for more details
     */
     void ProcessCVBilateralFilter(IplImage* inputIplImage, IplImage* outputIplImage);
     /*!
     \brief Applies the OpenCV median filter to the input image.
     See http://opencv.willowgarage.com/documentation/c/image_filtering.html#smooth for more details
     */
     void ProcessCVMedianFilter(IplImage* inputIplImage, IplImage* outputIplImage, int radius = 3);
     /*!
     \brief Performs temporal median filter on an image given the number of frames to be considered
     */
     void ProcessStreamedQuickSelectMedianImageFilter(IplImage* inputIplImage);
     /*!
     \brief Quickselect algorithm
     * This Quickselect routine is based on the algorithm described in
     * "Numerical recipes in C", Second Edition,
     * Cambridge University Press, 1992, Section 8.5, ISBN 0-521-43108-5
     * This code by Nicolas Devillard - 1998. Public domain.
     */
     float quick_select(float arr[], int n);
     /*!
     \brief Initialize and allocate a 2D ITK image of dimension m_ImageWidth*m_ImageHeight
     */
     void CreateItkImage(ItkImageType2D::Pointer &itkInputImage);
 
     mitk::Image::Pointer m_SegmentationMask; ///< mask image used for segmenting the image
 
     int m_ImageWidth; ///< x-dimension of the image
     int m_ImageHeight; ///< y-dimension of the image
     int m_ImageSize; ///< size of the image in bytes
 
     IplImage* m_IplDistanceImage; ///< OpenCV-representation of the distance image
     IplImage* m_IplOutputImage; ///< OpenCV-representation of the output image
 
     ItkImageType2D::Pointer m_ItkInputImage; ///< ITK representation of the distance image
 
     bool m_ApplyTemporalMedianFilter; ///< Flag indicating if the temporal median filter is currently active for processing the distance image
     bool m_ApplyAverageFilter; ///< Flag indicating if the average filter is currently active for processing the distance image
     bool m_ApplyMedianFilter; ///< Flag indicating if the spatial median filter is currently active for processing the distance image
     bool m_ApplyThresholdFilter; ///< Flag indicating if the threshold filter is currently active for processing the distance image
     bool m_ApplyMaskSegmentation; ///< Flag indicating if a mask segmentation is performed
     bool m_ApplyBilateralFilter; ///< Flag indicating if the bilateral filter is currently active for processing the distance image
 
     float** m_DataBuffer; ///< Buffer used for calculating the pixel-wise median over the last n (m_TemporalMedianFilterNumOfFrames) number of frames
     int m_DataBufferCurrentIndex; ///< Current index in the buffer of the temporal median filter
     int m_DataBufferMaxSize; ///< Maximal size for the buffer of the temporal median filter (m_DataBuffer)
 
     int m_TemporalMedianFilterNumOfFrames; ///< Number of frames to be used in the calculation of the temporal median
     int m_ThresholdFilterMin; ///< Lower threshold of the threshold filter. Pixels with values below will be assigned value 0 when applying the threshold filter
     int m_ThresholdFilterMax; ///< Lower threshold of the threshold filter. Pixels with values above will be assigned value 0 when applying the threshold filter
     double m_BilateralFilterDomainSigma; ///< Parameter of the bilateral filter controlling the smoothing effect of the filter. Default value: 2
     double m_BilateralFilterRangeSigma; ///< Parameter of the bilateral filter controlling the edge preserving effect of the filter. Default value: 60
     int m_BilateralFilterKernelRadius; ///< Kernel radius of the bilateral filter mask
 
   };
 } //END mitk namespace
 #endif