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;
 }