diff --git a/Modules/OpenCVVideoSupport/mitkMovieGeneratorOpenCV.h b/Modules/OpenCVVideoSupport/mitkMovieGeneratorOpenCV.h
index 9d551937bb..af38cb8cea 100755
--- a/Modules/OpenCVVideoSupport/mitkMovieGeneratorOpenCV.h
+++ b/Modules/OpenCVVideoSupport/mitkMovieGeneratorOpenCV.h
@@ -1,92 +1,89 @@
 /*===================================================================
 
 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 MovieGeneratorOpenCV_H_HEADER_INCLUDED
 #define MovieGeneratorOpenCV_H_HEADER_INCLUDED
 
 #include "mitkMovieGenerator.h"
 #include <MitkOpenCVVideoSupportExports.h>
 #include <memory.h>
 #include <string.h>
 
 // OpenCV includes
 #include "cv.h"
 #include "highgui.h"
 
 
 namespace mitk {
 
 
 class MITKOPENCVVIDEOSUPPORT_EXPORT MovieGeneratorOpenCV : public MovieGenerator
 {
 
 public:
 
   mitkClassMacro(MovieGeneratorOpenCV, MovieGenerator);
   itkFactorylessNewMacro(Self)
   itkCloneMacro(Self)
 
   virtual void SetFileName( const char *fileName ) override;
 
   void SetFourCCCodec(char* codec)
   {
     m_FourCCCodec = codec;
   }
 
   virtual void SetFrameRate(unsigned int rate);
 
   ///
   /// if true the movie will be cutted by a 10 pixel margin
   /// in order to remove the standard mitk coloured borders
   /// default: true
   ///
   void SetRemoveColouredFrame(bool);
 protected:
 
   MovieGeneratorOpenCV();
 
   //! called directly before the first frame is added
   virtual bool InitGenerator() override;
 
   //! used to add a frame
   virtual bool AddFrame( void *data ) override;
 
   //! called after the last frame is added
   virtual bool TerminateGenerator() override;
 
   //! name of output file
   std::string m_sFile;
 
   //! frame rate
   int m_dwRate;
 
 
 private:
 
   CvVideoWriter*    m_aviWriter;
   IplImage *        m_currentFrame;
 
   char *            m_FourCCCodec;
 
-  //! frame counter
-  long m_lFrame;
-
   bool m_RemoveColouredFrame;
 };
 
 } // namespace mitk
 
 #endif /* MovieGeneratorOpenCV_H_HEADER_INCLUDED */
diff --git a/Modules/ToFProcessing/CMakeLists.txt b/Modules/ToFProcessing/CMakeLists.txt
index e9a4862975..51c57e409b 100644
--- a/Modules/ToFProcessing/CMakeLists.txt
+++ b/Modules/ToFProcessing/CMakeLists.txt
@@ -1,12 +1,13 @@
 MITK_CREATE_MODULE(
     SUBPROJECTS MITK-ToF
     DEPENDS MitkCameraCalibration
     PACKAGE_DEPENDS OpenCV
+    WARNINGS_NO_ERRORS
   )
-  
+
 if(BUILD_TESTING)
 
   add_subdirectory(Testing)
 
 endif(BUILD_TESTING)
 
diff --git a/Modules/ToFProcessing/Testing/mitkToFDistanceImageToSurfaceFilterTest.cpp b/Modules/ToFProcessing/Testing/mitkToFDistanceImageToSurfaceFilterTest.cpp
index 04086ec2e8..2ebd87abe3 100644
--- a/Modules/ToFProcessing/Testing/mitkToFDistanceImageToSurfaceFilterTest.cpp
+++ b/Modules/ToFProcessing/Testing/mitkToFDistanceImageToSurfaceFilterTest.cpp
@@ -1,390 +1,390 @@
 /*===================================================================
 
 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 <mitkTestingMacros.h>
 #include <mitkToFDistanceImageToSurfaceFilter.h>
 
 #include <mitkImage.h>
 #include <mitkImagePixelReadAccessor.h>
 #include <mitkImageGenerator.h>
 #include <mitkSurface.h>
 #include <mitkToFProcessingCommon.h>
 #include <mitkNumericTypes.h>
 #include <mitkToFTestingCommon.h>
 #include <mitkIOUtil.h>
 
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkSmartPointer.h>
 
 /**
  *  @brief Test for the class "ToFDistanceImageToSurfaceFilter".
  */
 
 typedef mitk::ToFProcessingCommon::ToFPoint2D ToFPoint2D;
 typedef mitk::ToFProcessingCommon::ToFPoint3D ToFPoint3D;
 typedef mitk::ToFProcessingCommon::ToFScalarType ToFScalarType;
 
 int mitkToFDistanceImageToSurfaceFilterTest(int /* argc */, char* /*argv*/[])
 {
   MITK_TEST_BEGIN("ToFDistanceImageToSurfaceFilter");
   mitk::ToFDistanceImageToSurfaceFilter::Pointer filter = mitk::ToFDistanceImageToSurfaceFilter::New();
   // create test image
   unsigned int dimX =204;
   unsigned int dimY =204;
   mitk::Image::Pointer image = mitk::ImageGenerator::GenerateRandomImage<float>(dimX,dimY);
   //initialize intrinsic parameters with some arbitrary values
   ToFScalarType focalLengthX = 295.78960;
   ToFScalarType focalLengthY = 296.348535;
   ToFPoint2D focalLengthXY;
   focalLengthXY[0]=focalLengthX;
   focalLengthXY[1]=focalLengthY;
   ToFScalarType k1=-0.36,k2=-0.14,p1=0.001,p2=-0.00;
   ToFPoint2D principalPoint;
   principalPoint[0] = 103.576546;
   principalPoint[1] = 100.1532;
   mitk::CameraIntrinsics::Pointer cameraIntrinsics = mitk::CameraIntrinsics::New();
   cameraIntrinsics->SetFocalLength(focalLengthX,focalLengthY);
   cameraIntrinsics->SetPrincipalPoint(principalPoint[0],principalPoint[1]);
   cameraIntrinsics->SetDistorsionCoeffs(k1,k2,p1,p2);
   // test SetCameraIntrinsics()
   filter->SetCameraIntrinsics(cameraIntrinsics);
   MITK_TEST_CONDITION_REQUIRED((focalLengthX==filter->GetCameraIntrinsics()->GetFocalLengthX()),"Testing SetCameraIntrinsics with focalLength");
   ToFPoint2D pp;
   pp[0] = filter->GetCameraIntrinsics()->GetPrincipalPointX();
   pp[1] = filter->GetCameraIntrinsics()->GetPrincipalPointY();
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(principalPoint,pp),"Testing SetCameraIntrinsics with principalPoint()");
   // test SetInterPixelDistance()
   ToFPoint2D interPixelDistance;
   interPixelDistance[0] = 0.04564;
   interPixelDistance[1] = 0.0451564;
   filter->SetInterPixelDistance(interPixelDistance);
   ToFPoint2D ipD = filter->GetInterPixelDistance();
   MITK_TEST_CONDITION_REQUIRED(mitk::Equal(ipD,interPixelDistance),"Testing Set/GetInterPixelDistance()");
 
   // test SetReconstructionMode()
   filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
   MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
 
   // test Set/GetInput()
   filter->SetInput(image);
   MITK_TEST_CONDITION_REQUIRED((image==filter->GetInput()),"Testing Set/GetInput()");
 
   // test filter without subset (without interpixeldistance)
   MITK_INFO<<"Test filter with subset without interpixeldistance ";
   filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance);
     MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithOutInterPixelDistance,"Testing Set/GetReconstructionMode()");
 
   vtkSmartPointer<vtkPoints> expectedResult = vtkSmartPointer<vtkPoints>::New();
   expectedResult->SetDataTypeToDouble();
   unsigned int counter = 0;
   double* point = new double[3];
 //  MITK_INFO<<"Test";
 //  MITK_INFO<<"focal: "<<focalLength;
 //  MITK_INFO<<"inter: "<<interPixelDistance;
 //  MITK_INFO<<"prinicipal: "<<principalPoint;
   for (unsigned int j=0; j<dimX; j++)
   {
     for (unsigned int i=0; i<dimY; i++)
     {
-      itk::Index<2> index = { static_cast<itk::IndexValueType>(i), static_cast< itk::IndexValueType >( j) };
+      itk::Index<2> index = { { static_cast<itk::IndexValueType>(i), static_cast< itk::IndexValueType >( j) } };
       float distance = 0.0;
 
       try
       {
         mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
         distance = readAccess.GetPixelByIndex(index);
       }
       catch(mitk::Exception& e)
       {
           MITK_ERROR << "Image read exception!" << e.what();
       }
 
 
       ToFPoint3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinates(i,j,distance,focalLengthX,focalLengthY,principalPoint[0],principalPoint[1]);
 //      if ((i==0)&&(j==0))
 //      {
 //        MITK_INFO<<"Distance test: "<<distance;
 //        MITK_INFO<<"coordinate test: "<<coordinate;
 //      }
       point[0] = coordinate[0];
       point[1] = coordinate[1];
       point[2] = coordinate[2];
       unsigned int pointID = index[0] + index[1]*dimY;
       //MITK_INFO<<"id: "<<pointID;
       //MITK_INFO<<"counter: "<<counter;
       if (distance!=0)
       {
         expectedResult->InsertPoint(pointID,point);
       }
       counter++;
     }
   }
   filter->Update();
   mitk::Surface::Pointer resultSurface = filter->GetOutput();
   vtkSmartPointer<vtkPoints> result = vtkSmartPointer<vtkPoints>::New();
   result->SetDataTypeToDouble();
   result = resultSurface->GetVtkPolyData()->GetPoints();
 
   MITK_TEST_CONDITION_REQUIRED((expectedResult->GetNumberOfPoints()==result->GetNumberOfPoints()),"Test if number of points in surface is equal");
   bool pointSetsEqual = true;
   for (int i=0; i<expectedResult->GetNumberOfPoints(); i++)
   {
     double* expected = expectedResult->GetPoint(i);
     double* res = result->GetPoint(i);
 
     ToFPoint3D expectedPoint;
     expectedPoint[0] = expected[0];
     expectedPoint[1] = expected[1];
     expectedPoint[2] = expected[2];
     ToFPoint3D resultPoint;
     resultPoint[0] = res[0];
     resultPoint[1] = res[1];
     resultPoint[2] = res[2];
 
     if (!mitk::Equal(expectedPoint,resultPoint))
     {
 //      MITK_INFO << i;
       pointSetsEqual = false;
     }
   }
   MITK_TEST_CONDITION_REQUIRED(pointSetsEqual,"Testing filter without subset");
 
   // test filter without subset (with interpixeldistance)
   MITK_INFO<<"Test filter with subset with interpixeldistance ";
   filter->SetReconstructionMode(mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance);
   MITK_TEST_CONDITION_REQUIRED(filter->GetReconstructionMode() == mitk::ToFDistanceImageToSurfaceFilter::WithInterPixelDistance,"Testing Set/GetReconstructionMode()");
   // calculate focal length considering inter pixel distance
   ToFScalarType focalLength = (focalLengthX*interPixelDistance[0]+focalLengthY*interPixelDistance[1])/2.0;
   expectedResult = vtkSmartPointer<vtkPoints>::New();
   expectedResult->SetDataTypeToDouble();
   counter = 0;
   point = new double[3];
 //  MITK_INFO<<"Test";
 //  MITK_INFO<<"focal: "<<focalLength;
 //  MITK_INFO<<"inter: "<<interPixelDistance;
 //  MITK_INFO<<"prinicipal: "<<principalPoint;
   for (unsigned int j=0; j<dimX; j++)
   {
     for (unsigned int i=0; i<dimY; i++)
     {
         itk::Index<2> index = {{ static_cast<itk::IndexValueType >(i), static_cast< itk::IndexValueType >( j )}};
         float distance = 0.0;
         try
         {
           mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
           distance = readAccess.GetPixelByIndex(index);
         }
         catch(mitk::Exception& e)
         {
             MITK_ERROR << "Image read exception!" << e.what();
         }
       ToFPoint3D coordinate = mitk::ToFProcessingCommon::IndexToCartesianCoordinatesWithInterpixdist(i,j,distance,focalLength,interPixelDistance,principalPoint);
 //      if ((i==0)&&(j==0))
 //      {
 //        MITK_INFO<<"Distance test: "<<distance;
 //        MITK_INFO<<"coordinate test: "<<coordinate;
 //      }
       point[0] = coordinate[0];
       point[1] = coordinate[1];
       point[2] = coordinate[2];
       unsigned int pointID = index[0] + index[1]*dimY;
       //MITK_INFO<<"id: "<<pointID;
       //MITK_INFO<<"counter: "<<counter;
       if (distance!=0)
       {
         expectedResult->InsertPoint(pointID,point);
       }
       counter++;
     }
   }
   filter->Modified();
   filter->Update();
   resultSurface = filter->GetOutput();
   result = vtkSmartPointer<vtkPoints>::New();
   result->SetDataTypeToDouble();
   result = resultSurface->GetVtkPolyData()->GetPoints();
   MITK_TEST_CONDITION_REQUIRED((expectedResult->GetNumberOfPoints()==result->GetNumberOfPoints()),"Test if number of points in surface is equal");
   pointSetsEqual = true;
   for (int i=0; i<expectedResult->GetNumberOfPoints(); i++)
   {
     double* expected = expectedResult->GetPoint(i);
     double* res = result->GetPoint(i);
 
     ToFPoint3D expectedPoint;
     expectedPoint[0] = expected[0];
     expectedPoint[1] = expected[1];
     expectedPoint[2] = expected[2];
     ToFPoint3D resultPoint;
     resultPoint[0] = res[0];
     resultPoint[1] = res[1];
     resultPoint[2] = res[2];
 
     if (!mitk::Equal(expectedPoint,resultPoint))
     {
 //      MITK_INFO << i;
       MITK_INFO<<"expected: "<<expectedPoint;
       MITK_INFO<<"result: "<<resultPoint;
       pointSetsEqual = false;
     }
   }
   MITK_TEST_CONDITION_REQUIRED(pointSetsEqual,"Testing filter without subset");
 
 
   //Backwardtransformation test without interpixeldistance
   bool backwardTransformationsPointsEqual = true;
   for (int i=0; i<expectedResult->GetNumberOfPoints(); i++)
   {
     double* expected = expectedResult->GetPoint(i);
     double* res = result->GetPoint(i);
 
     ToFPoint3D expectedPoint;
     expectedPoint[0] = expected[0];
     expectedPoint[1] = expected[1];
     expectedPoint[2] = expected[2];
     ToFPoint3D resultPoint;
     resultPoint[0] = res[0];
     resultPoint[1] = res[1];
     resultPoint[2] = res[2];
 
     ToFPoint3D expectedPointBackward =
         mitk::ToFProcessingCommon::CartesianToIndexCoordinates(expectedPoint,focalLengthXY,principalPoint);
 
     ToFPoint3D resultPointBackward =
         mitk::ToFProcessingCommon::CartesianToIndexCoordinates(resultPoint,focalLengthXY,principalPoint);
 
     if (!mitk::Equal(expectedPointBackward,resultPointBackward))
     {
 //      MITK_INFO << i;
 //      MITK_INFO<<"expected: "<<expectedPoint;
 //      MITK_INFO<<"result: "<<resultPoint;
       backwardTransformationsPointsEqual = false;
     }
   }
   MITK_TEST_CONDITION_REQUIRED(backwardTransformationsPointsEqual,"Testing backward transformation without interpixeldistance");
 
   //Backwardtransformation test with interpixeldistance
   backwardTransformationsPointsEqual = true;
   for ( int i=0; i<expectedResult->GetNumberOfPoints(); i++)
   {
     double* expected = expectedResult->GetPoint(i);
     double* res = result->GetPoint(i);
 
     ToFPoint3D expectedPoint;
     expectedPoint[0] = expected[0];
     expectedPoint[1] = expected[1];
     expectedPoint[2] = expected[2];
     ToFPoint3D resultPoint;
     resultPoint[0] = res[0];
     resultPoint[1] = res[1];
     resultPoint[2] = res[2];
 
     ToFPoint3D expectedPointBackward =
         mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(expectedPoint,focalLength,interPixelDistance,principalPoint);
 
     ToFPoint3D resultPointBackward =
         mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(resultPoint,focalLength,interPixelDistance,principalPoint);
 
     if (!mitk::Equal(expectedPointBackward,resultPointBackward))
     {
 //      MITK_INFO << i;
 //      MITK_INFO<<"expected: "<<expectedPoint;
 //      MITK_INFO<<"result: "<<resultPoint;
       backwardTransformationsPointsEqual = false;
     }
   }
   MITK_TEST_CONDITION_REQUIRED(backwardTransformationsPointsEqual,"Testing backward transformation with interpixeldistance");
 
 
   //Backwardtransformation test compare to original input without interpixeldistance
   bool compareToInput = true;
   for ( int i=0; i<result->GetNumberOfPoints(); i++)
   {
     double* res = result->GetPoint(i);
 
     ToFPoint3D resultPoint;
     resultPoint[0] = res[0];
     resultPoint[1] = res[1];
     resultPoint[2] = res[2];
 
     ToFPoint3D resultPointBackward =
         mitk::ToFProcessingCommon::CartesianToIndexCoordinates(resultPoint,focalLengthXY,principalPoint);
 
     itk::Index<2> index = {{ (int) (resultPointBackward[0]+0.5), (int) (resultPointBackward[1]+0.5) }};
     float distanceBackward = 0.0;
 
     try
     {
       mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
       distanceBackward = readAccess.GetPixelByIndex(index);
     }
     catch(mitk::Exception& e)
     {
         MITK_ERROR << "Image read exception!" << e.what();
     }
 
     if (!mitk::Equal(distanceBackward,(float) resultPointBackward[2]))
     {
       MITK_INFO<<"expected: " << resultPointBackward[2];
       MITK_INFO<<"result: "<< distanceBackward;
       compareToInput = false;
     }
   }
   MITK_TEST_CONDITION_REQUIRED(compareToInput,"Testing backward transformation compared to original image without interpixeldistance");
 
 
   //Backwardtransformation test compare to original input with interpixeldistance
   compareToInput = true;
   for ( int i=0; i<result->GetNumberOfPoints(); i++)
   {
     double* res = result->GetPoint(i);
 
     ToFPoint3D resultPoint;
     resultPoint[0] = res[0];
     resultPoint[1] = res[1];
     resultPoint[2] = res[2];
 
     ToFPoint3D resultPointBackward =
         mitk::ToFProcessingCommon::CartesianToIndexCoordinatesWithInterpixdist(resultPoint,focalLength,interPixelDistance,principalPoint);
 
     itk::Index<2> pixelIndex = {{ (int) (resultPointBackward[0]+0.5), (int) (resultPointBackward[1]+0.5) }};
     float distanceBackward = 0.0;
     try
     {
       mitk::ImagePixelReadAccessor<float,2> readAccess(image, image->GetSliceData());
       distanceBackward = readAccess.GetPixelByIndex(pixelIndex);
     }
     catch(mitk::Exception& e)
     {
         MITK_ERROR << "Image read exception!" << e.what();
     }
 
     if (!mitk::Equal(distanceBackward, (float) resultPointBackward[2]))
     {
       compareToInput = false;
     }
   }
   MITK_TEST_CONDITION_REQUIRED(compareToInput,"Testing backward transformation compared to original image with interpixeldistance");
 
   //clean up
-  delete point;
+  delete[] point;
   //  expectedResult->Delete();
 
   MITK_TEST_END();
 
 }
 
 
diff --git a/Modules/USUI/Qmitk/QmitkUSControlsCustomDiPhASDeviceWidget.cpp b/Modules/USUI/Qmitk/QmitkUSControlsCustomDiPhASDeviceWidget.cpp
index 4a8cd6ef85..e765872d1d 100644
--- a/Modules/USUI/Qmitk/QmitkUSControlsCustomDiPhASDeviceWidget.cpp
+++ b/Modules/USUI/Qmitk/QmitkUSControlsCustomDiPhASDeviceWidget.cpp
@@ -1,421 +1,421 @@
 /*===================================================================
 
 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 "QmitkUSControlsCustomDiPhASDeviceWidget.h"
 #include "ui_QmitkUSControlsCustomDiPhASDeviceWidget.h"
 #include <QMessageBox>
 
 
 #include <mitkException.h>
 
 QmitkUSControlsCustomDiPhASDeviceWidget::QmitkUSControlsCustomDiPhASDeviceWidget(QWidget *parent)
   : QmitkUSAbstractCustomWidget(parent), ui(new Ui::QmitkUSControlsCustomDiPhASDeviceWidget)
 {
 }
 
 QmitkUSControlsCustomDiPhASDeviceWidget::~QmitkUSControlsCustomDiPhASDeviceWidget()
 {
   m_ControlInterface = dynamic_cast<mitk::USDiPhASDeviceCustomControls*>
     (this->GetDevice()->GetControlInterfaceCustom().GetPointer());
 
   if (m_ControlInterface.IsNotNull())
   {
     m_ControlInterface->passGUIOut([](QString /*str*/)->void {} );
   }
   delete ui;
 }
 
 std::string QmitkUSControlsCustomDiPhASDeviceWidget::GetDeviceClass() const
 {
   return "org.mitk.modules.us.USDiPhASDevice";
 }
 
 QmitkUSAbstractCustomWidget* QmitkUSControlsCustomDiPhASDeviceWidget::Clone(QWidget* parent) const
 {
   QmitkUSAbstractCustomWidget* clonedWidget = new QmitkUSControlsCustomDiPhASDeviceWidget(parent);
   clonedWidget->SetDevice(this->GetDevice());
   return clonedWidget;
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnDeviceSet()
 {
   m_ControlInterface = dynamic_cast<mitk::USDiPhASDeviceCustomControls*>
     (this->GetDevice()->GetControlInterfaceCustom().GetPointer());
 
   if ( m_ControlInterface.IsNotNull() )
   {
     m_ControlInterface->passGUIOut([this](QString str)->void{
-      if (this && this->ui) {
+      if (this->ui) {
         this->ui->CurrentState->setText(str);
       } });
   }
   else
   {
     MITK_WARN("QmitkUSAbstractCustomWidget")("QmitkUSControlsCustomDiPhASDeviceWidget")
         << "Did not get a custom device control interface.";
   }
 
   //now pass the default values
 
   m_OldReconstructionLines = 0;
 
   m_ControlInterface->SetSilentUpdate(true); // don't update the scanmode everytime
 
   OnTransmitPhaseLengthChanged();
   OnExcitationFrequencyChanged();
   OnTransmitEventsChanged();
   OnVoltageChanged();
   OnScanDepthChanged(); // HERE
   OnAveragingCountChanged();
   OnTGCMinChanged();
   OnTGCMaxChanged();
   OnDataTypeChanged();
   OnPitchChanged();
   OnReconstructedSamplesChanged();
   OnReconstructedLinesChanged();
   OnSpeedOfSoundChanged();
   OnBandpassEnabledChanged();
   OnLowCutChanged();
   OnHighCutChanged();
   OnUseBModeFilterChanged(); // HERE
   OnVerticalSpacingChanged();
   OnScatteringCoefficientChanged();
   OnCompensateScatteringChanged();
   OnChangedSavingSettings();
   OnCompensateEnergyChanged();
 
   m_ControlInterface->SetSilentUpdate(false); // on the last update pass the scanmode and geometry!
 
   OnModeChanged(); // HERE
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::Initialize()
 {
   ui->setupUi(this);
 
   connect(ui->CompensateEnergy, SIGNAL(stateChanged(int)), this, SLOT(OnCompensateEnergyChanged()));
   connect(ui->UseBModeFilter, SIGNAL(stateChanged(int)), this, SLOT(OnUseBModeFilterChanged()));
   connect(ui->StartStopRecord, SIGNAL(clicked()), this, SLOT(OnRecordChanged()));
   connect(ui->ScatteringCoefficient, SIGNAL(valueChanged(int)), this, SLOT(OnScatteringCoefficientChanged()));
   connect(ui->CompensateScattering, SIGNAL(stateChanged(int)), this, SLOT(OnCompensateScatteringChanged()));
   connect(ui->VerticalSpacing, SIGNAL(valueChanged(double)), this, SLOT(OnVerticalSpacingChanged()));
   connect(ui->SaveBeamformed, SIGNAL(stateChanged(int)), this, SLOT(OnChangedSavingSettings()));
   connect(ui->SaveRaw, SIGNAL(stateChanged(int)), this, SLOT(OnChangedSavingSettings()));
   //transmit
   connect(ui->TransmitPhaseLength, SIGNAL(valueChanged(double)), this, SLOT(OnTransmitPhaseLengthChanged()));
   connect(ui->ExcitationFrequency, SIGNAL(valueChanged(double)), this, SLOT(OnExcitationFrequencyChanged()));
   connect(ui->TransmitEvents, SIGNAL(valueChanged(int)), this, SLOT(OnTransmitEventsChanged()));
   connect(ui->Voltage, SIGNAL(valueChanged(int)), this, SLOT(OnVoltageChanged()));
   connect(ui->Mode, SIGNAL(currentTextChanged(QString)), this, SLOT(OnModeChanged()));
 
   //Receive
   connect(ui->ScanDepth, SIGNAL(valueChanged(double)), this, SLOT(OnScanDepthChanged()));
   connect(ui->AveragingCount, SIGNAL(valueChanged(int)), this, SLOT(OnAveragingCountChanged()));
   connect(ui->TimeGainCompensationMinSlider, SIGNAL(valueChanged(int)), this, SLOT(OnTGCMinChanged()));
   connect(ui->TimeGainCompensationMaxSlider, SIGNAL(valueChanged(int)), this, SLOT(OnTGCMaxChanged()));
   connect(ui->DataType, SIGNAL(currentTextChanged(QString)), this, SLOT(OnDataTypeChanged()));
 
   //Beamforming
   connect(ui->PitchOfTransducer, SIGNAL(valueChanged(double)), this, SLOT(OnPitchChanged()));
   connect(ui->ReconstructedSamplesPerLine, SIGNAL(valueChanged(int)), this, SLOT(OnReconstructedSamplesChanged()));
   connect(ui->ReconstructedLines, SIGNAL(valueChanged(int)), this, SLOT(OnReconstructedLinesChanged()));
   connect(ui->SpeedOfSound, SIGNAL(valueChanged(int)), this, SLOT(OnSpeedOfSoundChanged()));
 
   //Bandpass
   connect(ui->BandpassEnabled, SIGNAL(currentTextChanged(QString)), this, SLOT(OnBandpassEnabledChanged()));
   connect(ui->LowCut, SIGNAL(valueChanged(double)), this, SLOT(OnLowCutChanged()));
   connect(ui->HighCut, SIGNAL(valueChanged(double)), this, SLOT(OnHighCutChanged()));
 }
 
 //slots
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnCompensateEnergyChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   bool CompensateEnergy = ui->CompensateEnergy->isChecked();
   m_ControlInterface->SetCompensateEnergy(CompensateEnergy);
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnUseBModeFilterChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   bool UseBModeFilter = ui->UseBModeFilter->isChecked();
   m_ControlInterface->SetUseBModeFilter(UseBModeFilter);
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnRecordChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   if (ui->StartStopRecord->text() == "Start Recording")
   {
     ui->StartStopRecord->setText("Stop Recording");
 
     ui->UseBModeFilter->setEnabled(false);
     ui->ScatteringCoefficient->setEnabled(false);
     ui->CompensateScattering->setEnabled(false);
     ui->VerticalSpacing->setEnabled(false);
     ui->SaveBeamformed->setEnabled(false);
     ui->SaveRaw->setEnabled(false);
     ui->TransmitPhaseLength->setEnabled(false);
     ui->ExcitationFrequency->setEnabled(false);
     ui->TransmitEvents->setEnabled(false);
     ui->Voltage->setEnabled(false);
     ui->Mode->setEnabled(false);
     ui->ScanDepth->setEnabled(false);
     ui->AveragingCount->setEnabled(false);
     ui->TimeGainCompensationMinSlider->setEnabled(false);
     ui->TimeGainCompensationMaxSlider->setEnabled(false);
     ui->DataType->setEnabled(false);
     ui->PitchOfTransducer->setEnabled(false);
     ui->ReconstructedSamplesPerLine->setEnabled(false);
     ui->ReconstructedLines->setEnabled(false);
     ui->SpeedOfSound->setEnabled(false);
     ui->BandpassEnabled->setEnabled(false);
     ui->LowCut->setEnabled(false);
     ui->HighCut->setEnabled(false);
     ui->CompensateEnergy->setEnabled(false);
 
     m_ControlInterface->SetRecord(true);
   }
   else
   {
     ui->StartStopRecord->setText("Start Recording");
 
     ui->UseBModeFilter->setEnabled(true);
     ui->CompensateScattering->setEnabled(true);
     if(ui->CompensateScattering->isChecked())
       ui->ScatteringCoefficient->setEnabled(true);
     ui->VerticalSpacing->setEnabled(true);
     ui->SaveBeamformed->setEnabled(true);
     ui->SaveRaw->setEnabled(true);
     ui->TransmitPhaseLength->setEnabled(true);
     ui->ExcitationFrequency->setEnabled(true);
     ui->TransmitEvents->setEnabled(true);
     ui->Voltage->setEnabled(true);
     ui->Mode->setEnabled(true);
     ui->ScanDepth->setEnabled(true);
     ui->AveragingCount->setEnabled(true);
     ui->TimeGainCompensationMinSlider->setEnabled(true);
     ui->TimeGainCompensationMaxSlider->setEnabled(true);
     ui->DataType->setEnabled(true);
     ui->PitchOfTransducer->setEnabled(true);
     ui->ReconstructedSamplesPerLine->setEnabled(true);
     ui->ReconstructedLines->setEnabled(true);
     ui->SpeedOfSound->setEnabled(true);
     ui->BandpassEnabled->setEnabled(true);
     ui->LowCut->setEnabled(true);
     ui->HighCut->setEnabled(true);
     ui->CompensateEnergy->setEnabled(true);
 
     m_ControlInterface->SetRecord(false);
   }
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnVerticalSpacingChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetVerticalSpacing(ui->VerticalSpacing->value());
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnScatteringCoefficientChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetScatteringCoefficient(ui->ScatteringCoefficient->value());
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnCompensateScatteringChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   if (ui->CompensateScattering->isChecked())
     ui->ScatteringCoefficient->setEnabled(true);
   else
     ui->ScatteringCoefficient->setEnabled(false);
 
   m_ControlInterface->SetCompensateScattering(ui->CompensateScattering->isChecked());
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnChangedSavingSettings()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   mitk::USDiPhASDeviceCustomControls::SavingSettings settings;
 
   settings.saveBeamformed = ui->SaveBeamformed->isChecked();
   settings.saveRaw = ui->SaveRaw->isChecked();
 
   m_ControlInterface->SetSavingSettings(settings);
 }
 
 //Transmit
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnTransmitPhaseLengthChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetTransmitPhaseLength(ui->TransmitPhaseLength->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnExcitationFrequencyChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetExcitationFrequency(ui->ExcitationFrequency->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnTransmitEventsChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   m_ControlInterface->SetTransmitEvents(ui->TransmitEvents->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnVoltageChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetVoltage(ui->Voltage->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnModeChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   QString Mode = ui->Mode->currentText();
   bool silent = m_ControlInterface->GetSilentUpdate();
   m_ControlInterface->SetSilentUpdate(true);
 
   if (Mode == "Ultrasound only") {
     m_ControlInterface->SetMode(false);
     ui->TransmitEvents->setValue(1);
   }
   else if (Mode == "Interleaved") {
     m_ControlInterface->SetMode(true);
     ui->TransmitEvents->setValue(1);
   }
   if (!silent) { m_ControlInterface->SetSilentUpdate(false); }
   OnTransmitEventsChanged();
 }
 
 //Receive
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnScanDepthChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetScanDepth(ui->ScanDepth->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnAveragingCountChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetAveragingCount(ui->AveragingCount->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnTGCMinChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   int tgcMin = ui->TimeGainCompensationMinSlider->value();
   int tgcMax = ui->TimeGainCompensationMaxSlider->value();
   if (tgcMin > tgcMax) {
     ui->TimeGainCompensationMinSlider->setValue(tgcMax);
     MITK_INFO << "User tried to set tgcMin>tgcMax.";
   }
   QString text("TGC min = " + QString::fromStdString(std::to_string(ui->TimeGainCompensationMinSlider->value())));
   ui->TimeGainCompensationMinLabel->setText(text);
   m_ControlInterface->SetTGCMin(ui->TimeGainCompensationMinSlider->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnTGCMaxChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   int tgcMin = ui->TimeGainCompensationMinSlider->value();
   int tgcMax = ui->TimeGainCompensationMaxSlider->value();
   if (tgcMin > tgcMax) {
     ui->TimeGainCompensationMaxSlider->setValue(tgcMin);
     MITK_INFO << "User tried to set tgcMin>tgcMax.";
   }
   QString text("TGC max = "+QString::fromStdString(std::to_string(ui->TimeGainCompensationMaxSlider->value())));
   ui->TimeGainCompensationMaxLabel->setText(text);
   m_ControlInterface->SetTGCMax(ui->TimeGainCompensationMaxSlider->value());
 }
 
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnDataTypeChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   QString DataType = ui->DataType->currentText();
   if (DataType == "Image Data") {
     m_ControlInterface->SetDataType(mitk::USDiPhASDeviceCustomControls::DataType::Image_uChar);
   }
   else if (DataType == "Beamformed Data") {
     m_ControlInterface->SetDataType(mitk::USDiPhASDeviceCustomControls::DataType::Beamformed_Short);
   }
 }
 
 //Beamforming
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnPitchChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetPitch(ui->PitchOfTransducer->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnReconstructedSamplesChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   m_ControlInterface->SetReconstructedSamples(ui->ReconstructedSamplesPerLine->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnReconstructedLinesChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
   if (m_OldReconstructionLines == 0)
     m_OldReconstructionLines = ui->ReconstructedLines->value();
 
   m_ControlInterface->SetReconstructedLines(ui->ReconstructedLines->value());
 
   ui->PitchOfTransducer->setValue(ui->PitchOfTransducer->value()*((double)m_OldReconstructionLines / (double)ui->ReconstructedLines->value()));
   m_OldReconstructionLines = ui->ReconstructedLines->value();
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnSpeedOfSoundChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   m_ControlInterface->SetSpeedOfSound(ui->SpeedOfSound->value());
 }
 
 //Bandpass
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnBandpassEnabledChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   if (ui->BandpassEnabled->currentText() == "On") {
     m_ControlInterface->SetBandpassEnabled(true);
   }
   else {
     m_ControlInterface->SetBandpassEnabled(false);
   }
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnLowCutChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   unsigned int Low = ui->LowCut->value();
   unsigned int High = ui->HighCut->value();
   if (Low > High) {
     ui->LowCut->setValue(High);
     MITK_INFO << "User tried to set LowCut>HighCut.";
   }
 
   m_ControlInterface->SetLowCut(ui->LowCut->value());
 }
 void QmitkUSControlsCustomDiPhASDeviceWidget::OnHighCutChanged()
 {
   if (m_ControlInterface.IsNull()) { return; }
 
   unsigned int Low = ui->LowCut->value();
   unsigned int High = ui->HighCut->value();
   if (Low > High) {
     ui->HighCut->setValue(Low);
     MITK_INFO << "User tried to set LowCut>HighCut.";
   }
 
   m_ControlInterface->SetHighCut(ui->HighCut->value());
 }