diff --git a/Modules/US/USHardwareTelemed/mitkUSTelemedProbesControls.cpp b/Modules/US/USHardwareTelemed/mitkUSTelemedProbesControls.cpp
index 473cc7489d..b61fd5ceae 100644
--- a/Modules/US/USHardwareTelemed/mitkUSTelemedProbesControls.cpp
+++ b/Modules/US/USHardwareTelemed/mitkUSTelemedProbesControls.cpp
@@ -1,247 +1,247 @@
 /*===================================================================
 
 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 "mitkUSTelemedProbesControls.h"
 #include "mitkUSTelemedDevice.h"
 #include <mitkException.h>
 
 mitk::USTelemedProbesControls::USTelemedProbesControls(itk::SmartPointer<USTelemedDevice> device)
   : mitk::USControlInterfaceProbes(device.GetPointer()),
     m_IsActive(false), m_TelemedDevice(device),
     m_ProbesCollection(0), m_Probe(0)
 {
 }
 
 mitk::USTelemedProbesControls::~USTelemedProbesControls()
 {
   SAFE_RELEASE(m_ProbesCollection);
 }
 
 void mitk::USTelemedProbesControls::SetIsActive(bool isActive)
 {
   if ( ! m_TelemedDevice )
   {
     MITK_WARN("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Cannot activate probe controls while device is not set.";
     return;
   }
 
   if ( isActive && m_ProbesCollection == 0 )
   {
     this->CreateProbesCollection();
     this->CreateProbesSet();
   }
   else
   {
   }
 
   m_IsActive = isActive;
 }
 
 bool mitk::USTelemedProbesControls::GetIsActive()
 {
   return m_IsActive;
 }
 
 std::vector<mitk::USProbe::Pointer> mitk::USTelemedProbesControls::GetProbeSet()
 {
   // create a new vector of base class (USProbe) objects, because
   // interface wants a vector of this type
   std::vector<mitk::USProbe::Pointer> usProbes(m_ProbesSet.size(), 0);
   for (unsigned int n = 0; n < m_ProbesSet.size(); ++n)
   {
     usProbes.at(n) = m_ProbesSet.at(n).GetPointer();
   }
   return usProbes;
 }
 
 void mitk::USTelemedProbesControls::OnSelectProbe(unsigned int index)
 {
   if (index >= m_ProbesSet.size())
   {
     MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Cannot select probe with index " << index << ". Maximum possible index is " << m_ProbesSet.size()-1 << ".";
     mitkThrow() << "Cannot select probe with index " << index <<
       ". Maximum possible index is " << m_ProbesSet.size()-1 << ".";
   }
 
   m_TelemedDevice->SetActiveDataView(m_ProbesSet.at(index)->GetUsgDataView());
 
   m_SelectedProbeIndex = index;
 }
 
 void mitk::USTelemedProbesControls::OnSelectProbe(mitk::USProbe::Pointer probe)
 {
 }
 
 mitk::USProbe::Pointer mitk::USTelemedProbesControls::GetSelectedProbe()
 {
   if (m_SelectedProbeIndex >= m_ProbesSet.size())
   {
     MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Cannot get active probe as the current index is" << m_SelectedProbeIndex <<
       ". Maximum possible index is " << m_ProbesSet.size()-1 << ".";
     mitkThrow() << "Cannot get active probe as the current index is" << m_SelectedProbeIndex <<
       ". Maximum possible index is " << m_ProbesSet.size()-1 << ".";
   }
 
   return m_ProbesSet.at(m_SelectedProbeIndex).GetPointer();
 }
 
 unsigned int mitk::USTelemedProbesControls::GetProbesCount() const
 {
   return m_ProbesSet.size();
 }
 
 /*void mitk::USTelemedProbesControls::SetTelemedDevice(itk::SmartPointer<USTelemedDevice> telemedDevice)
 {
   m_TelemedDevice = telemedDevice;
 }*/
 
 void mitk::USTelemedProbesControls::ProbeRemoved(unsigned int index)
 {
   MITK_INFO << "Probe removed...";
 
   if ( m_ProbesSet.size() > index )
   {
     m_ProbesSet.erase(m_ProbesSet.begin() + index);
   }
 }
 
 void mitk::USTelemedProbesControls::ProbeAdded(unsigned int index)
 {
   MITK_INFO << "Probe arrived...";
 
   this->CreateProbesCollection();
   this->CreateProbesSet();
 
   // Activate the added probe, if the added probe is the first probe
   if (m_ProbesSet.size() == 1)
   {
     m_TelemedDevice->SetActiveDataView(m_ProbesSet.at(0)->GetUsgDataView());
   }
 }
 
 bool mitk::USTelemedProbesControls::CreateProbesCollection()
 {
   IUnknown* tmp_obj = nullptr;
   HRESULT hr;
 
   // get the main API interface from the Telemed device
   Usgfw2Lib::IUsgfw2* usgMainInterface = m_TelemedDevice->GetUsgMainInterface();
   if ( ! usgMainInterface )
   {
     MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Main interface of Telemed device must not be null.";
     mitkThrow() << "Main interface of Telemed device must not be null.";
   }
 
   // get probes collection from Telemed API
   hr = usgMainInterface->get_ProbesCollection(&tmp_obj);
   if (FAILED(hr) || ! tmp_obj)
   {
     MITK_WARN("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Error on getting probes collection (" << hr << ").";
     return false;
   }
 
   // second step for getting probes collection from Telemed API
   SAFE_RELEASE(m_ProbesCollection);
   hr = tmp_obj->QueryInterface(Usgfw2Lib::IID_IUsgCollection,(void**)&m_ProbesCollection);
   SAFE_RELEASE(tmp_obj);
   if (FAILED(hr) || ! m_ProbesCollection)
   {
     MITK_WARN("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Error on querying interface for probes collection (" << hr << ").";
     return false;
   }
 
   return true;
 }
 
 void mitk::USTelemedProbesControls::CreateProbesSet()
 {
   if ( ! m_ProbesCollection)
   {
     MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Cannot get probe set without ProbesCollection being initialized before.";
     mitkThrow() << "Cannot get probe set without ProbesCollection being initialized before.";
   }
 
   // get number of available probes
   LONG probes_count = 0;
   HRESULT hr = m_ProbesCollection->get_Count(&probes_count);
   if (FAILED(hr)) { mitkThrow() << "Could not get probes count (" << hr << ")."; }
 
   if ( ! m_TelemedDevice )
   {
     MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Telemed device must not be null when creating probes set.";
     mitkThrow() << "Telemed device must not be null when creating probes set.";
   }
 
   // get the main API interface from the Telemed device
   Usgfw2Lib::IUsgfw2* usgMainInterface = m_TelemedDevice->GetUsgMainInterface();
   if ( ! usgMainInterface )
   {
     MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
       << "Usg main interface must not be null when creating probes set.";
     mitkThrow() << "Usg main interface must not be null when creating probes set.";
   }
 
   // initialize probes set with new vector
   m_ProbesSet = std::vector<mitk::USTelemedProbe::Pointer>(probes_count, 0);
 
-  for (unsigned int n = 0; n < probes_count; ++n)
+  for (LONG n = 0; n < probes_count; ++n)
   {
     // get the probe item from the API collection
     IUnknown* tmp_obj = nullptr;
     hr = m_ProbesCollection->Item(n,&tmp_obj);
     if (FAILED(hr))
     {
       MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
         << "Could not get probe with index " << n << ".";
       mitkThrow() << "Could not get probe with index " << n << ".";
     }
 
     // convert this item to a probe
     Usgfw2Lib::IProbe* probe;
     hr = tmp_obj->QueryInterface(Usgfw2Lib::IID_IProbe,(void**)&probe);
     if (FAILED(hr))
     {
       MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
         << "Error on querying interface for probe with index "<< n << ".";
       mitkThrow() << "Error on querying interface for probe with index "<< n << ".";
     }
 
     // create main ultrasound scanning object for selected probe
     Usgfw2Lib::IUsgDataView* usgDataView;
     Usgfw2Lib::IUsgDataViewPtr usgDataViewTmp;
     usgDataViewTmp = usgMainInterface->CreateDataView(probe);
     usgDataViewTmp->QueryInterface(Usgfw2Lib::IID_IUsgDataView, (void**)&usgDataView);
     if (! usgDataView)
     {
       MITK_ERROR("USTelemedProbesControls")("USControlInterfaceProbes")
         << "Could not create data view for selected probe.";
       mitkThrow() << "Could not create data view for selected probe.";
     }
 
     // probe object can be created now from API data
     m_ProbesSet.at(n) = mitk::USTelemedProbe::New(probe, usgDataView);
 
     SAFE_RELEASE(tmp_obj);
   }
 }
diff --git a/Modules/US/USHardwareTelemed/mitkUSTelemedScanConverterPlugin.cpp b/Modules/US/USHardwareTelemed/mitkUSTelemedScanConverterPlugin.cpp
index 87137ff769..1c9b0048c1 100644
--- a/Modules/US/USHardwareTelemed/mitkUSTelemedScanConverterPlugin.cpp
+++ b/Modules/US/USHardwareTelemed/mitkUSTelemedScanConverterPlugin.cpp
@@ -1,153 +1,153 @@
 /*===================================================================
 
 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 "mitkUSTelemedScanConverterPlugin.h"
 #include "mitkImageWriteAccessor.h"
 
 USTelemedScanConverterPlugin::USTelemedScanConverterPlugin( )
   : m_Plugin(nullptr), m_OutputImage(nullptr), m_OutputImageMutex(nullptr)
 {
 }
 
 USTelemedScanConverterPlugin::~USTelemedScanConverterPlugin( )
 {
   ReleasePlugin();
 }
 
 // -- internal Telemed API function
 HRESULT __stdcall USTelemedScanConverterPlugin::QueryInterface(const IID& iid, void** ppv)
 {
   reinterpret_cast<IUnknown*>(*ppv)->AddRef() ;
   return S_OK ;
 }
 
 // -- internal Telemed API function
 ULONG __stdcall USTelemedScanConverterPlugin::AddRef()
 {
   return InterlockedIncrement(&m_cRef) ;
 }
 
 // -- internal Telemed API function
 ULONG __stdcall USTelemedScanConverterPlugin::Release()
 {
   if (InterlockedDecrement(&m_cRef) == 0)
   {
     delete this ;
     return 0 ;
   }
   return m_cRef ;
 }
 
 STDMETHODIMP USTelemedScanConverterPlugin::InterimOutBufferCB (
   PBYTE pBufferInterim,
   int nInterimBufferLen,
   PBYTE pBufferOut,
   int nOutBufferLen,
   int nOutX1,
   int nOutY1,
   int nOutX2,
   int nOutY2
   )
 {
   if ( m_OutputImage.IsNull() ) { return S_FALSE; };
 
   if ( m_OutputImageMutex.IsNotNull() ) { m_OutputImageMutex->Lock(); }
 
   // initialize mitk::Image with given image size on the first time
   if ( ! m_OutputImage->IsInitialized() )
   {
-    unsigned int dim[]={(nOutX2 - nOutX1), (nOutY2 - nOutY1)}; // image dimensions
+    unsigned int dim[]={static_cast<unsigned int>(abs(nOutX2 - nOutX1)), static_cast<unsigned int>(abs(nOutY2 - nOutY1))}; // image dimensions
 
     m_OutputImage->Initialize(mitk::MakeScalarPixelType<BYTE>(), 2, dim);
   }
 
   // lock the image for writing an copy the given buffer into the image then
   m_OutputImage->SetSlice(pBufferOut);
 
   if ( m_OutputImageMutex.IsNotNull() ) { m_OutputImageMutex->Unlock(); }
 
   return S_OK;
 }
 
 void USTelemedScanConverterPlugin::ReleasePlugin()
 {
   if (m_Plugin != nullptr)
   {
     // remove this callback from Telemed API plugin
     m_Plugin->SetCallback(nullptr,USPC_BUFFER_INTERIM_OUTPUT);
   }
 }
 
 void USTelemedScanConverterPlugin::SetOutputImage(mitk::Image::Pointer outputImage, itk::FastMutexLock::Pointer outputImageMutex)
 {
   m_OutputImage = outputImage;
   m_OutputImageMutex = outputImageMutex;
 }
 
 STDMETHODIMP USTelemedScanConverterPlugin::SetScanConverterPlugin(IDispatch* plugin)
 {
   // make sure that there is no scan converter plugin registered already
   this->ReleasePlugin();
 
   HRESULT hr;
 
   // it is ok to call this method with a nullptr plugin to remove
   // a previous callback
   if (plugin == nullptr)
   {
     MITK_INFO("IUsgfwScanConverterPluginCB")("ScanConverterPlugin")
       << "nullptr plugin set to the scan converter. The callback for the previous plugin is removed now.";
     return S_OK;
   }
 
   // get Telemed API plugin from the COM library
   Usgfw2Lib::IUsgScanConverterPlugin* tmp_plugin;
   hr = plugin->QueryInterface(__uuidof(Usgfw2Lib::IUsgScanConverterPlugin), (void**)&tmp_plugin);
 
   if (FAILED(hr))
   {
     MITK_WARN("IUsgfwScanConverterPluginCB")("ScanConverterPlugin")
       << "Could not query com interface for IUsgScanConverterPlugin (" << hr << ").";
     return hr;
   }
 
   // get the converter for scan lines from the COM library and
   // save it as a member attribute
   hr = tmp_plugin->get_ScanConverter((IUnknown**)&m_Plugin);
 
   if (FAILED(hr))
   {
     MITK_WARN("IUsgfwScanConverterPluginCB")("ScanConverterPlugin")
       << "Could not get ScanConverter from plugin (" << hr << ").";
     return hr;
   }
 
   SAFE_RELEASE(tmp_plugin);
 
   // now the callback can be set -> interface functions of this
   // object will be called from now on when new image data is
   // available
   hr = m_Plugin->SetCallback(this,USPC_BUFFER_INTERIM_OUTPUT);
 
   if (FAILED(hr))
   {
     MITK_WARN("IUsgfwScanConverterPluginCB")("ScanConverterPlugin")
       << "Could not set callback for plugin (" << hr << ").";
     return hr;
   }
 
   return S_OK;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkUSNavigationTargetOcclusionFilter.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkUSNavigationTargetOcclusionFilter.cpp
index ddb5e240e1..c37a975df9 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkUSNavigationTargetOcclusionFilter.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/Filter/mitkUSNavigationTargetOcclusionFilter.cpp
@@ -1,193 +1,193 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // MITK
 #include "mitkUSNavigationTargetOcclusionFilter.h"
 #include "mitkDataNode.h"
 #include "mitkSurface.h"
 
 // VTK
 #include "vtkSmartPointer.h"
 #include "vtkPointData.h"
 #include "vtkPolyData.h"
 #include "vtkOBBTree.h"
 #include "vtkFloatArray.h"
 #include "vtkTransform.h"
 #include "vtkTransformPolyDataFilter.h"
 
 
 mitk::USNavigationTargetOcclusionFilter::USNavigationTargetOcclusionFilter()
   : m_StartPositionInput(0)
 {
 }
 
 mitk::USNavigationTargetOcclusionFilter::~USNavigationTargetOcclusionFilter()
 {
 }
 
 void mitk::USNavigationTargetOcclusionFilter::SetTargetStructure(itk::SmartPointer<DataNode> targetStructure)
 {
   m_TargetStructure = targetStructure;
 }
 
 void mitk::USNavigationTargetOcclusionFilter::SetObstacleStructures(DataStorage::SetOfObjects::ConstPointer obstacleStructures)
 {
   m_ObstacleStructures = obstacleStructures;
 }
 
 void mitk::USNavigationTargetOcclusionFilter::SelectStartPositionInput(unsigned int n)
 {
   m_StartPositionInput = n;
 }
 
 void mitk::USNavigationTargetOcclusionFilter::GenerateData()
 {
   mitk::NavigationDataPassThroughFilter::GenerateData();
 
   // get vtk surface an the points
   vtkPolyData* targetSurfaceVtk = this->GetVtkPolyDataOfTarget();
   if ( ! targetSurfaceVtk ) { return; } // cannot do anything without a target surface
 
   vtkIdType numberOfPoints = targetSurfaceVtk->GetNumberOfPoints();
 
   // create array for scalar values
   vtkSmartPointer<vtkFloatArray> colors =
       vtkSmartPointer<vtkFloatArray>::New();
   colors->SetNumberOfComponents(1);
   colors->SetName("USNavigation::Occlusion");
 
   const mitk::NavigationData* nd = this->GetInput(m_StartPositionInput);
 
   // set every value to -1 if there is no (valid) navigation data
   if ( nd == 0 || ! nd->IsDataValid() )
   {
     float intersection = -1;
     for ( vtkIdType n = 0; n < numberOfPoints; n++ )
     {
       colors->InsertNextTuple1(intersection);
     }
 
     if ( numberOfPoints > 0 )
     {
       targetSurfaceVtk->GetPointData()->AddArray(colors);
       targetSurfaceVtk->GetPointData()->Update();
     }
 
     return;
   }
 
   // initialize values with 0 (no intersection) if there is valid navigation
   // data and there are some obstacle structures defined
   else if ( m_ObstacleStructures.IsNull() )
   {
     float intersection = 0;
     for ( vtkIdType n = 0; n < numberOfPoints; n++ )
     {
       colors->InsertNextTuple1(intersection);
     }
 
     if ( numberOfPoints > 0 )
     {
       targetSurfaceVtk->GetPointData()->AddArray(colors);
       targetSurfaceVtk->GetPointData()->Update();
     }
 
     return;
   }
 
   // get the current position from the navigation data
   mitk::Point3D position = nd->GetPosition();
   double point1[3];
   point1[0] = position[0]; point1[1] = position[1]; point1[2] = position[2];
 
   // transform vtk polydata according to mitk geometry
   vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter =
     vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   transformFilter->SetInputData(0, targetSurfaceVtk);
   transformFilter->SetTransform(m_TargetStructure->GetData()->GetGeometry()->GetVtkTransform());
   transformFilter->Update();
   vtkPolyData* targetSurfaceVtkTransformed = transformFilter->GetOutput();
 
   std::vector<bool> occlusion(numberOfPoints, false);
 
   // calculate occlusion for every obstacle structure
   for (mitk::DataStorage::SetOfObjects::ConstIterator it = m_ObstacleStructures->Begin();
     it != m_ObstacleStructures->End(); ++it)
   {
     vtkPolyData* polyData = dynamic_cast<mitk::Surface*>(it->Value()->GetData())->GetVtkPolyData();
 
     // transform the obstacle strucutre according to the mitk geometry
     vtkSmartPointer<vtkTransformPolyDataFilter> transformFilter =
       vtkSmartPointer<vtkTransformPolyDataFilter>::New();
     transformFilter->SetInputData(0, polyData);
     transformFilter->SetTransform(it->Value()->GetData()->GetGeometry()->GetVtkTransform());
     transformFilter->Update();
     polyData = transformFilter->GetOutput();
 
     // build an obb tree locator
     vtkSmartPointer<vtkOBBTree> cellLocator = vtkSmartPointer<vtkOBBTree>::New();
     cellLocator->SetDataSet(polyData);
     cellLocator->BuildLocator();
 
     // test for intersection with every point on the surface
-    for ( unsigned int n = 0; n < numberOfPoints; n++ )
+    for ( vtkIdType n = 0; n < numberOfPoints; n++ )
     {
       vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
       if ( cellLocator->IntersectWithLine(point1, targetSurfaceVtkTransformed->GetPoint(n), points, nullptr) != 0 )
       {
         occlusion.at(n) = true;
       }
     }
   }
 
   if ( numberOfPoints > 0 )
   {
     // set the occlusion values as scalar array to the vtkPolyData
     float one = 1.0f; float zero = 0.0f;
     for ( std::vector<bool>::iterator it = occlusion.begin(); it != occlusion.end(); ++it )
     {
       colors->InsertNextTuple1(*it ? one : zero);
     }
 
     targetSurfaceVtk->GetPointData()->AddArray(colors);
     targetSurfaceVtk->GetPointData()->Update();
   }
 }
 
 vtkSmartPointer<vtkPolyData> mitk::USNavigationTargetOcclusionFilter::GetVtkPolyDataOfTarget()
 {
   if ( m_TargetStructure.IsNull() )
   {
     MITK_WARN("USNavigationTargetOcclusionFilter") << "Target structure must not be null.";
     return nullptr;
   }
 
   mitk::Surface::Pointer targetSurface = dynamic_cast<mitk::Surface*>(m_TargetStructure->GetData());
   if ( targetSurface.IsNull() )
   {
     MITK_WARN("USNavigationTargetOcclusionFilter") << "A mitk::Surface has to be set to the data node.";
     return nullptr;
   }
 
   vtkSmartPointer<vtkPolyData> targetSurfaceVtk = targetSurface->GetVtkPolyData();
   if( targetSurfaceVtk == 0 )
   {
     MITK_WARN("USNavigationTargetOcclusionFilter") << "VtkPolyData of the mitk::Surface of the data node must not be null.";
     return nullptr;
   }
 
   return targetSurfaceVtk;
 }
diff --git a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
index 0266b86fee..00ab7836c7 100644
--- a/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
+++ b/Plugins/org.mitk.gui.qt.igt.app.echotrack/src/internal/NavigationStepWidgets/QmitkUSNavigationStepCombinedModality.cpp
@@ -1,427 +1,428 @@
 /*===================================================================
 
 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 "QmitkUSNavigationStepCombinedModality.h"
 #include "ui_QmitkUSNavigationStepCombinedModality.h"
 
 #include "mitkUSCombinedModality.h"
 
 #include "../Widgets/QmitkUSCombinedModalityEditWidget.h"
 
 #include <QFileDialog>
 #include <QTextStream>
 #include <QSettings>
 
 #include "mitkBaseRenderer.h"
 
 QmitkUSNavigationStepCombinedModality::QmitkUSNavigationStepCombinedModality(QWidget *parent) :
   QmitkUSAbstractNavigationStep(parent),
   m_LastCalibrationFilename(""),
   m_CalibrationLoadedNecessary(true),
   m_ListenerDeviceChanged(this, &QmitkUSNavigationStepCombinedModality::OnDevicePropertyChanged),
   ui(new Ui::QmitkUSNavigationStepCombinedModality)
 {
   ui->setupUi(this);
 
   // combined modality create widget should only be visible after button press
   ui->combinedModalityCreateWidget->setVisible(false);
   ui->combinedModalityEditWidget->setVisible(false);
 
   connect(ui->combinedModalityListWidget, SIGNAL(ServiceSelectionChanged(us::ServiceReferenceU)), this, SLOT(OnDeviceSelectionChanged()));
   connect(ui->combinedModalityListWidget, SIGNAL(ServiceModified(us::ServiceReferenceU)), this, SLOT(OnDeviceSelectionChanged()));
   connect(ui->combinedModalityCreateWidget, SIGNAL(SignalAborted()), this, SLOT(OnCombinedModalityCreationExit()));
   connect(ui->combinedModalityCreateWidget, SIGNAL(SignalCreated()), this, SLOT(OnCombinedModalityCreationExit()));
 
   connect(ui->combinedModalityEditWidget, SIGNAL(SignalAborted()), this, SLOT(OnCombinedModalityEditExit()));
   connect(ui->combinedModalityEditWidget, SIGNAL(SignalSaved()), this, SLOT(OnCombinedModalityEditExit()));
 
   std::string filterOnlyCombinedModalities = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.USCombinedModality)(" + mitk::USCombinedModality::GetPropertyKeys().US_PROPKEY_CLASS + "=" + mitk::USCombinedModality::DeviceClassIdentifier + "))";
   //std::string filter = "(&(" + us::ServiceConstants::OBJECTCLASS() + "=" + "org.mitk.services.UltrasoundDevice))";
   ui->combinedModalityListWidget->Initialize<mitk::USCombinedModality>(mitk::USCombinedModality::US_PROPKEY_DEVICENAME);
   ui->combinedModalityListWidget->SetAutomaticallySelectFirstEntry(true);
 
   //try to load UI settings
   QSettings settings;
   settings.beginGroup(QString::fromStdString("QmitkUSNavigationStepCombinedModality"));
   m_LastCalibrationFilename = settings.value("LastCalibrationFilename", QVariant("")).toString().toStdString();
   MITK_DEBUG << "PERSISTENCE load: " << m_LastCalibrationFilename;
   settings.endGroup();
 }
 
 QmitkUSNavigationStepCombinedModality::~QmitkUSNavigationStepCombinedModality()
 {
   ui->combinedModalityListWidget->blockSignals(true);
   //save UI settings
   QSettings settings;
   settings.beginGroup(QString::fromStdString("QmitkUSNavigationStepCombinedModality"));
   settings.setValue("LastCalibrationFilename", QVariant(m_LastCalibrationFilename.c_str()));
   settings.endGroup();
   MITK_DEBUG << "PERSISTENCE save: " << m_LastCalibrationFilename;
   //delete UI
   delete ui;
 }
 
 void QmitkUSNavigationStepCombinedModality::OnDeviceSelectionChanged()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
   bool combinedModalitySelected = combinedModality.IsNotNull();
 
   ui->calibrationGroupBox->setEnabled(combinedModalitySelected);
   ui->combinedModalityDeleteButton->setEnabled(combinedModalitySelected);
   ui->combinedModalitEditButton->setEnabled(combinedModalitySelected);
 
   if (!combinedModalitySelected || m_CombinedModality != combinedModality)
   {
     emit SignalNoLongerReadyForNextStep();
 
     if (m_CombinedModality.IsNotNull() && m_CombinedModality->GetUltrasoundDevice().IsNotNull())
     {
       m_CombinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
     }
 
     if (combinedModalitySelected && combinedModality->GetUltrasoundDevice().IsNotNull())
     {
       combinedModality->GetUltrasoundDevice()->RemovePropertyChangedListener(m_ListenerDeviceChanged);
     }
   }
   m_CombinedModality = combinedModality;
 
   if (combinedModalitySelected)
   {
     bool calibrated = this->UpdateCalibrationState();
 
     if (!m_CalibrationLoadedNecessary) { emit SignalReadyForNextStep(); }
     else
     {
       if (calibrated) { emit SignalReadyForNextStep(); }
       else { emit SignalNoLongerReadyForNextStep(); }
     }
 
     // enable disconnect button only if combined modality is connected or active
     ui->combinedModalityDistconnectButton->setEnabled(combinedModality->GetDeviceState() >= mitk::USCombinedModality::State_Connected);
     ui->combinedModalityActivateButton->setEnabled(combinedModality->GetDeviceState() < mitk::USCombinedModality::State_Activated);
 
     this->UpdateTrackingToolNames();
   }
   else
   {
     ui->combinedModalityDistconnectButton->setEnabled(false);
     ui->combinedModalityActivateButton->setEnabled(false);
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::OnLoadCalibration()
 {
   QString filename = QFileDialog::getOpenFileName(QApplication::activeWindow(),
     "Load Calibration",
     m_LastCalibrationFilename.c_str(),
     "Calibration files *.cal");
   m_LastCalibrationFilename = filename.toStdString();
 
   mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNull())
   {
     ui->calibrationLoadStateLabel->setText("Selected device is no USCombinedModality.");
     emit SignalNoLongerReadyForNextStep();
     return;
   }
 
   if (filename.isEmpty())
   {
     bool calibrated = this->UpdateCalibrationState();
     if (!calibrated) { emit SignalNoLongerReadyForNextStep(); }
 
     return;
   }
 
   QFile file(filename);
   if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
   {
     MITK_WARN << "Cannot open file '" << filename.toStdString() << "' for reading.";
     ui->calibrationLoadStateLabel->setText("Cannot open file '" + filename + "' for reading.");
     emit SignalNoLongerReadyForNextStep();
     return;
   }
 
   QTextStream inStream(&file);
   m_LoadedCalibration = inStream.readAll().toStdString();
   if (m_LoadedCalibration.empty())
   {
     MITK_WARN << "Failed to load file. Unsupported format?";
     ui->calibrationLoadStateLabel->setText("Failed to load file. Unsupported format?");
     emit SignalNoLongerReadyForNextStep();
     return;
   }
 
   try
   {
     combinedModality->DeserializeCalibration(m_LoadedCalibration);
   }
   catch (const mitk::Exception& /*exception*/)
   {
     MITK_WARN << "Failed to deserialize calibration. Unsuppoerted format?";
     ui->calibrationLoadStateLabel->setText("Failed to deserialize calibration. Unsuppoerted format?");
     emit SignalNoLongerReadyForNextStep();
     return;
   }
 
   ui->calibrationLoadStateLabel->setText("Loaded calibration : " + filename);
 
   m_CombinedModality = combinedModality;
 
   emit SignalReadyForNextStep();
 }
 
 void QmitkUSNavigationStepCombinedModality::OnCombinedModalityCreateNewButtonClicked()
 {
   this->SetCombinedModalityCreateWidgetEnabled(true);
 }
 
 void QmitkUSNavigationStepCombinedModality::OnCombinedModalityCreationExit()
 {
   this->SetCombinedModalityCreateWidgetEnabled(false);
-  try
+  mitk::DataNode::Pointer usNode = mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()//GetDataStorage
+    ->GetNamedNode("US Viewing Stream - Image 0");
+  if (usNode.IsNotNull())
   {
     mitk::RenderingManager::GetInstance()->InitializeViews(//Reinit
-      mitk::BaseRenderer::GetInstance(mitk::BaseRenderer::GetRenderWindowByName("stdmulti.widget4"))->GetDataStorage()//GetDataStorage
-      ->GetNamedNode("US Support Viewing Stream")->GetData()->GetTimeGeometry());//GetNode
+      usNode->GetData()->GetTimeGeometry());//GetNode
   }
-  catch (...)
+  else
   {
-    MITK_DEBUG << "No reinit possible";
+    mitkThrow()<< "No reinit possible";
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::OnCombinedModalityEditExit()
 {
   this->SetCombinedModalityEditWidgetEnabled(false);
   ui->combinedModalityEditWidget->SetCombinedModality(0);
 }
 
 void QmitkUSNavigationStepCombinedModality::OnDeleteButtonClicked()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     combinedModality->RemoveAllObservers();
     combinedModality->UnregisterOnService();
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::OnCombinedModalityEditButtonClicked()
 {
   ui->combinedModalityEditWidget->SetCombinedModality(m_CombinedModality);
   this->SetCombinedModalityEditWidgetEnabled(true);
 }
 
 void QmitkUSNavigationStepCombinedModality::OnActivateButtonClicked()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     if (!combinedModality->GetIsConnected()) { combinedModality->Connect(); }
     if (!combinedModality->GetIsActive()) { combinedModality->Activate(); }
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::OnDisconnectButtonClicked()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     if (combinedModality->GetIsActive()) { combinedModality->Deactivate(); }
     if (combinedModality->GetIsConnected()) { combinedModality->Disconnect(); }
   }
 }
 
 bool QmitkUSNavigationStepCombinedModality::OnStartStep()
 {
   return true;
 }
 
 bool QmitkUSNavigationStepCombinedModality::OnRestartStep()
 {
   return true;
 }
 
 bool QmitkUSNavigationStepCombinedModality::OnFinishStep()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetSelectedCombinedModality();
   if (combinedModality.IsNotNull())
   {
     QApplication::setOverrideCursor(Qt::WaitCursor);
     // make sure that the combined modality is in connected state before using it
     if (combinedModality->GetDeviceState() < mitk::USDevice::State_Connected) { combinedModality->Connect(); }
     if (combinedModality->GetDeviceState() < mitk::USDevice::State_Activated) { combinedModality->Activate(); }
     QApplication::restoreOverrideCursor();
   }
 
   emit SignalCombinedModalityChanged(combinedModality);
 
   this->CreateCombinedModalityResultAndSignalIt();
 
   return true;
 }
 
 bool QmitkUSNavigationStepCombinedModality::OnActivateStep()
 {
   // make sure that device selection status is up-to-date
   this->OnDeviceSelectionChanged();
 
   return true;
 }
 
 void QmitkUSNavigationStepCombinedModality::OnUpdate()
 {
 }
 
 QString QmitkUSNavigationStepCombinedModality::GetTitle()
 {
   return "Selection of Combined Modality";
 }
 
 bool QmitkUSNavigationStepCombinedModality::GetIsRestartable()
 {
   return false;
 }
 
 void QmitkUSNavigationStepCombinedModality::SetCombinedModalityCreateWidgetEnabled(bool enabled)
 {
   ui->combinedModalityLabel->setVisible(!enabled);
   ui->combinedModalityListWidget->setVisible(!enabled);
   ui->combinedModalityCreateButton->setVisible(!enabled);
   ui->combinedModalityDeleteButton->setVisible(!enabled);
   ui->combinedModalitEditButton->setVisible(!enabled);
   ui->combinedModalityActivateButton->setVisible(!enabled);
   ui->combinedModalityDistconnectButton->setVisible(!enabled);
   ui->helpLabel->setVisible(!enabled);
   ui->calibrationGroupBox->setVisible(!enabled);
   ui->combinedModalityCreateWidget->setVisible(enabled);
 }
 
 void QmitkUSNavigationStepCombinedModality::SetCombinedModalityEditWidgetEnabled(bool enabled)
 {
   ui->combinedModalityLabel->setVisible(!enabled);
   ui->combinedModalityListWidget->setVisible(!enabled);
   ui->combinedModalityCreateButton->setVisible(!enabled);
   ui->combinedModalityDeleteButton->setVisible(!enabled);
   ui->combinedModalitEditButton->setVisible(!enabled);
   ui->combinedModalityActivateButton->setVisible(!enabled);
   ui->combinedModalityDistconnectButton->setVisible(!enabled);
   ui->helpLabel->setVisible(!enabled);
   ui->calibrationGroupBox->setVisible(!enabled);
   ui->combinedModalityEditWidget->setVisible(enabled);
 }
 
 void QmitkUSNavigationStepCombinedModality::CreateCombinedModalityResultAndSignalIt()
 {
   mitk::USCombinedModality::Pointer combinedModality = this->GetCombinedModality();
   mitk::USDevice::Pointer usDevice = combinedModality->GetUltrasoundDevice();
 
   // save identifiers and calibration to a result object
   mitk::DataNode::Pointer combinedModalityResult = mitk::DataNode::New();
   combinedModalityResult->SetName("CombinedModalityResult");
   combinedModalityResult->SetStringProperty("USNavigation::CombinedModality",
     std::string(combinedModality->GetManufacturer() + ": " + combinedModality->GetName()
     + " (" + combinedModality->GetComment() + ")").c_str());
   combinedModalityResult->SetStringProperty("USNavigation::UltrasoundDevice",
     std::string(usDevice->GetManufacturer() + ": " + usDevice->GetName()
     + " (" + usDevice->GetComment() + ")").c_str());
   combinedModalityResult->SetStringProperty("USNavigation::TrackingDevice",
     combinedModality->GetNavigationDataSource()->GetName().c_str());
   combinedModalityResult->SetStringProperty("USNavigation::Calibration",
     combinedModality->SerializeCalibration().c_str());
 
   emit SignalIntermediateResult(combinedModalityResult);
 }
 
 bool QmitkUSNavigationStepCombinedModality::UpdateCalibrationState()
 {
   if (m_CombinedModality.IsNull()) { return false; }
 
   bool calibrated = m_CombinedModality->GetContainsAtLeastOneCalibration();
 
   if (calibrated) { ui->calibrationLoadStateLabel->setText("Selected device contains at least one calibration."); }
   else { ui->calibrationLoadStateLabel->setText("Selected device is not calibrated."); }
 
   return calibrated;
 }
 
 mitk::USCombinedModality::Pointer QmitkUSNavigationStepCombinedModality::GetSelectedCombinedModality()
 {
   // nothing more to do if no device is selected at the moment
   if (!ui->combinedModalityListWidget->GetIsServiceSelected()) { return 0; }
 
   mitk::USCombinedModality::Pointer combinedModality = ui->combinedModalityListWidget->GetSelectedService<mitk::USCombinedModality>();
 
   if (combinedModality.IsNull())
   {
     MITK_WARN << "Selected device is no USCombinedModality.";
   }
 
   return combinedModality;
 }
 
 void QmitkUSNavigationStepCombinedModality::SetCalibrationLoadedNecessary(bool necessary)
 {
   m_CalibrationLoadedNecessary = necessary;
 }
 
 void QmitkUSNavigationStepCombinedModality::OnDevicePropertyChanged(const std::string& key, const std::string&)
 {
   // property changes only matter if the navigation step is currently active
   // (being sensitive to them in other states may even be dangerous)
   if (this->GetNavigationStepState() < QmitkUSAbstractNavigationStep::State_Active) { return; }
 
   // calibration state could have changed if the depth was changed
   if (key == mitk::USDevice::GetPropertyKeys().US_PROPKEY_BMODE_DEPTH)
   {
     bool calibrated = this->UpdateCalibrationState();
     if (calibrated) { emit SignalReadyForNextStep(); }
     else { emit SignalNoLongerReadyForNextStep(); }
   }
 }
 
 void QmitkUSNavigationStepCombinedModality::UpdateTrackingToolNames()
 {
   //check if everything is initialized
   if (m_CombinedModality.IsNull()) { return; }
   mitk::NavigationDataSource::Pointer navigationDataSource = m_CombinedModality->GetNavigationDataSource();
   if (navigationDataSource.IsNull()) { return; }
   if (GetDataStorage(false).IsNull()) { return; }
 
   // get the settings node
   mitk::DataNode::Pointer settingsNode = this->GetNamedDerivedNode(DATANAME_SETTINGS, DATANAME_BASENODE);
   std::string needleNames;
 
   itk::ProcessObject::DataObjectPointerArray outputs = navigationDataSource->GetOutputs();
   for (itk::ProcessObject::DataObjectPointerArray::iterator it = outputs.begin(); it != outputs.end(); ++it)
   {
     needleNames += std::string((static_cast<mitk::NavigationData*>(it->GetPointer()))->GetName()) + ";";
   }
 
   // change the settings node only if the settings changed
   std::string oldProperty;
   if (!settingsNode->GetStringProperty("settings.needle-names", oldProperty)
     || oldProperty != needleNames
     || !settingsNode->GetStringProperty("settings.reference-names", oldProperty)
     || oldProperty != needleNames)
   {
     settingsNode->SetStringProperty("settings.needle-names", needleNames.c_str());
     settingsNode->SetStringProperty("settings.reference-names", needleNames.c_str());
 
     emit SignalSettingsNodeChanged(settingsNode);
   }
 }