diff --git a/Modules/US/USModel/mitkUSDeviceReaderWriterConstants.h b/Modules/US/USModel/mitkUSDeviceReaderWriterConstants.h
index 5535469911..1f19b0af85 100644
--- a/Modules/US/USModel/mitkUSDeviceReaderWriterConstants.h
+++ b/Modules/US/USModel/mitkUSDeviceReaderWriterConstants.h
@@ -1,53 +1,56 @@
 /*===================================================================
 
 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 mitkUSDeviceReaderWriterConstants_H_HEADER_INCLUDED_
 #define mitkUSDeviceReaderWriterConstants_H_HEADER_INCLUDED_
 
 const static char* TAG_ULTRASOUNDDEVICE = "ULTRASOUNDDEVICE";
 const static char* TAG_GENERALSETTINGS = "GENERALSETTINGS";
 const static char* TAG_PROBES = "PROBES";
 const static char* TAG_PROBE = "PROBE";
 const static char* TAG_DEPTHS = "DEPTHS";
 const static char* TAG_DEPTH = "DEPTH";
 const static char* TAG_SPACING = "SPACING";
 const static char* TAG_CROPPING = "CROPPING";
 
 const static char* ATTR_FILEVERS = "filevers";
 const static char* ATTR_TYPE = "type";
+const static char* ATTR_HOST = "host";
+const static char* ATTR_PORT = "port";
+const static char* ATTR_SERVER = "server";
 const static char* ATTR_NAME = "name";
 const static char* ATTR_MANUFACTURER = "manufacturer";
 const static char* ATTR_MODEL = "model";
 const static char* ATTR_COMMENT = "comment";
 const static char* ATTR_IMAGESTREAMS = "imagestreams";
 const static char* ATTR_GREYSCALE = "greyscale";
 const static char* ATTR_RESOLUTIONOVERRIDE = "resolutionOverride";
 const static char* ATTR_RESOLUTIONWIDTH = "resolutionWidth";
 const static char* ATTR_RESOLUTIONHEIGHT = "resolutionHeight";
 const static char* ATTR_SOURCEID = "sourceID";
 const static char* ATTR_FILEPATH = "filepath";
 const static char* ATTR_OPENCVPORT = "opencvPort";
 const static char* ATTR_DEPTH = "depth";
 const static char* ATTR_X = "x";
 const static char* ATTR_Y = "y";
 const static char* ATTR_TOP = "top";
 const static char* ATTR_BOTTOM = "bottom";
 const static char* ATTR_LEFT = "left";
 const static char* ATTR_RIGHT = "right";
 
 
 #endif // mitkUSDeviceReaderWriterConstants_H_HEADER_INCLUDED_
diff --git a/Modules/US/USModel/mitkUSDeviceReaderXML.cpp b/Modules/US/USModel/mitkUSDeviceReaderXML.cpp
index 7e7aed1530..2ff8a4c5c9 100644
--- a/Modules/US/USModel/mitkUSDeviceReaderXML.cpp
+++ b/Modules/US/USModel/mitkUSDeviceReaderXML.cpp
@@ -1,205 +1,208 @@
 /*===================================================================
 
 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 "mitkUSDeviceReaderWriterConstants.h"
 #include "mitkUSDeviceReaderXML.h"
 #include <mitkIGTMimeTypes.h>
 #include <mitkLocaleSwitch.h>
 
 #include <mitkUSVideoDevice.h>
 
 // Third Party
 #include <itksys/SystemTools.hxx>
 #include <fstream>
 #include <tinyxml.h>
 
 mitk::USDeviceReaderXML::USDeviceReaderXML() : AbstractFileReader(
   mitk::IGTMimeTypes::USDEVICEINFORMATIONXML_MIMETYPE(),
   "MITK USDevice Reader (XML)"), m_Filename("")
 {
   RegisterService();
 }
 
 mitk::USDeviceReaderXML::~USDeviceReaderXML()
 {
 }
 
-mitk::USDeviceReaderXML::USVideoDeviceConfigData &mitk::USDeviceReaderXML::GetUSVideoDeviceConfigData()
+mitk::USDeviceReaderXML::USDeviceConfigData &mitk::USDeviceReaderXML::GetUSDeviceConfigData()
 {
   return m_DeviceConfig;
 }
 
 mitk::USDeviceReaderXML::USDeviceReaderXML(const mitk::USDeviceReaderXML& other) : AbstractFileReader(other)
 {
 }
 
 mitk::USDeviceReaderXML* mitk::USDeviceReaderXML::Clone() const
 {
   return new USDeviceReaderXML(*this);
 }
 
 
 
 
 std::vector<itk::SmartPointer<mitk::BaseData>> mitk::USDeviceReaderXML::Read()
 {
   MITK_WARN << "This method is not implemented. \
   Please use the method ReadUltrasoundDeviceConfiguration() instead.";
   std::vector<mitk::BaseData::Pointer> result;
   return result;
 }
 
 bool mitk::USDeviceReaderXML::ReadUltrasoundDeviceConfiguration()
 {
   MITK_INFO << "Try to start reading xml device configuration...";
   if (m_Filename == "")
   {
     MITK_WARN << "Cannot read file - empty filename!";
     return false;
   }
 
   TiXmlDocument document(m_Filename);
   if (!document.LoadFile())
   {
     MITK_ERROR << "Error when opening and reading file :" << m_Filename;
     return false;
   }
 
   TiXmlHandle documentHandle(&document);
   TiXmlElement* ultrasoundDeviceTag = documentHandle.FirstChildElement(TAG_ULTRASOUNDDEVICE).ToElement();
   if (ultrasoundDeviceTag == nullptr)
   {
     MITK_ERROR << "Error parsing the file :" << m_Filename << std::endl << "Wrong xml format structure.";
     return false;
   }
 
   //Extract attribute information of the ULTRASOUNDDEVICE-Tag:
   this->ExtractAttributeInformationOfUltrasoundDeviceTag(ultrasoundDeviceTag);
 
   TiXmlElement* generalSettingsTag = documentHandle.FirstChildElement(TAG_ULTRASOUNDDEVICE).FirstChildElement(TAG_GENERALSETTINGS).ToElement();
   if (generalSettingsTag == nullptr)
   {
     MITK_ERROR << "Error parsing the GENERALSETTINGS-Tag in the file :" << m_Filename;
     return false;
   }
 
   //Extract attribute information of the GENERALSETTINGS-Tag:
   this->ExtractAttributeInformationOfGeneralSettingsTag(generalSettingsTag);
 
   TiXmlElement* probesTag = documentHandle.FirstChildElement(TAG_ULTRASOUNDDEVICE).FirstChildElement(TAG_PROBES).ToElement();
   if (probesTag == nullptr)
   {
     MITK_ERROR << "Error: PROBES-Tag was not found in the file :" << m_Filename << "Therefore, creating default probe.";
     //Create default ultrasound probe:
     mitk::USProbe::Pointer ultrasoundProbeDefault = mitk::USProbe::New();
     ultrasoundProbeDefault->SetName("default");
     ultrasoundProbeDefault->SetDepth(0);
     m_DeviceConfig.probes.push_back(ultrasoundProbeDefault);
     return true;
   }
 
   //Extract all saved and configured probes of the USDevice:
   for (TiXmlElement* probeTag = probesTag->FirstChildElement(TAG_PROBE);
     probeTag != nullptr; probeTag = probeTag->NextSiblingElement())
   {
     this->ExtractProbe(probeTag);
   }
   return true;
 }
 
 void mitk::USDeviceReaderXML::SetFilename(std::string filename)
 {
   m_Filename = filename;
 }
 
 void mitk::USDeviceReaderXML::ExtractAttributeInformationOfUltrasoundDeviceTag(TiXmlElement *ultrasoundTag)
 {
   ultrasoundTag->QueryDoubleAttribute(ATTR_FILEVERS, &m_DeviceConfig.fileversion);
   ultrasoundTag->QueryStringAttribute(ATTR_TYPE, &m_DeviceConfig.deviceType);
   ultrasoundTag->QueryStringAttribute(ATTR_NAME, &m_DeviceConfig.deviceName);
   ultrasoundTag->QueryStringAttribute(ATTR_MANUFACTURER, &m_DeviceConfig.manufacturer);
   ultrasoundTag->QueryStringAttribute(ATTR_MODEL, &m_DeviceConfig.model);
   ultrasoundTag->QueryStringAttribute(ATTR_COMMENT, &m_DeviceConfig.comment);
   ultrasoundTag->QueryIntAttribute(ATTR_IMAGESTREAMS, &m_DeviceConfig.numberOfImageStreams);
+  ultrasoundTag->QueryStringAttribute(ATTR_HOST, &m_DeviceConfig.host);
+  ultrasoundTag->QueryIntAttribute(ATTR_PORT, &m_DeviceConfig.port);
+  ultrasoundTag->QueryBoolAttribute(ATTR_SERVER, &m_DeviceConfig.server);
 }
 
 void mitk::USDeviceReaderXML::ExtractAttributeInformationOfGeneralSettingsTag(TiXmlElement *generalSettingsTag)
 {
   generalSettingsTag->QueryBoolAttribute(ATTR_GREYSCALE, &m_DeviceConfig.useGreyscale);
   generalSettingsTag->QueryBoolAttribute(ATTR_RESOLUTIONOVERRIDE, &m_DeviceConfig.useResolutionOverride);
   generalSettingsTag->QueryIntAttribute(ATTR_RESOLUTIONHEIGHT, &m_DeviceConfig.resolutionHeight);
   generalSettingsTag->QueryIntAttribute(ATTR_RESOLUTIONWIDTH, &m_DeviceConfig.resolutionWidth);
   generalSettingsTag->QueryIntAttribute(ATTR_SOURCEID, &m_DeviceConfig.sourceID);
   generalSettingsTag->QueryStringAttribute(ATTR_FILEPATH, &m_DeviceConfig.filepathVideoSource);
   generalSettingsTag->QueryIntAttribute(ATTR_OPENCVPORT, &m_DeviceConfig.opencvPort);
 }
 
 void mitk::USDeviceReaderXML::ExtractProbe(TiXmlElement *probeTag)
 {
   mitk::USProbe::Pointer ultrasoundProbe = mitk::USProbe::New();
   std::string probeName;
   probeTag->QueryStringAttribute(ATTR_NAME, &probeName);
   ultrasoundProbe->SetName(probeName);
 
   TiXmlElement* depthsTag = probeTag->FirstChildElement(TAG_DEPTHS);
   if (depthsTag != nullptr)
   {
     for (TiXmlElement* depthTag = depthsTag->FirstChildElement(TAG_DEPTH);
       depthTag != nullptr; depthTag = depthTag->NextSiblingElement())
     {
       int depth = 0;
       mitk::Vector3D spacing;
       spacing[0] = 1;
       spacing[1] = 1;
       spacing[2] = 1;
 
       depthTag->QueryIntAttribute(ATTR_DEPTH, &depth);
 
       TiXmlElement* spacingTag = depthTag->FirstChildElement(TAG_SPACING);
       if (spacingTag != nullptr)
       {
         spacingTag->QueryDoubleAttribute(ATTR_X, &spacing[0]);
         spacingTag->QueryDoubleAttribute(ATTR_Y, &spacing[1]);
       }
 
       ultrasoundProbe->SetDepthAndSpacing(depth, spacing);
     }
   }
   else
   {
     MITK_ERROR << "Error: DEPTHS-Tag was not found in the file :" << m_Filename
       << "Therefore, creating default depth [0] and spacing [1,1,1] for the probe.";
     ultrasoundProbe->SetDepth(0);
   }
 
   unsigned int croppingTop = 0;
   unsigned int croppingBottom = 0;
   unsigned int croppingLeft = 0;
   unsigned int croppingRight = 0;
 
   TiXmlElement* croppingTag = probeTag->FirstChildElement(TAG_CROPPING);
   if (croppingTag != nullptr)
   {
     croppingTag->QueryUnsignedAttribute(ATTR_TOP, &croppingTop);
     croppingTag->QueryUnsignedAttribute(ATTR_BOTTOM, &croppingBottom);
     croppingTag->QueryUnsignedAttribute(ATTR_LEFT, &croppingLeft);
     croppingTag->QueryUnsignedAttribute(ATTR_RIGHT, &croppingRight);
   }
 
   ultrasoundProbe->SetProbeCropping(croppingTop, croppingBottom, croppingLeft, croppingRight);
   m_DeviceConfig.probes.push_back(ultrasoundProbe);
 }
diff --git a/Modules/US/USModel/mitkUSDeviceReaderXML.h b/Modules/US/USModel/mitkUSDeviceReaderXML.h
index 2b6c0a4fde..291d8dbb16 100644
--- a/Modules/US/USModel/mitkUSDeviceReaderXML.h
+++ b/Modules/US/USModel/mitkUSDeviceReaderXML.h
@@ -1,101 +1,105 @@
 /*===================================================================
 
 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 mitkUSDeviceReaderXML_H_HEADER_INCLUDED_
 #define mitkUSDeviceReaderXML_H_HEADER_INCLUDED_
 
 #include <MitkUSExports.h>
 
 #include <mitkAbstractFileReader.h>
 #include <mitkUSProbe.h>
 
 class TiXmlElement;
 class TiXmlNode;
 
 namespace mitk {
 
   class MITKUS_EXPORT USDeviceReaderXML : public AbstractFileReader
   {
   public:
     USDeviceReaderXML();
     ~USDeviceReaderXML() override;
 
     using AbstractFileReader::Read;
     std::vector<itk::SmartPointer<BaseData>> Read() override;
     bool ReadUltrasoundDeviceConfiguration();
 
     void SetFilename(std::string filename);
 
-    typedef struct USVideoDeviceConfigData_
+    typedef struct USDeviceConfigData_
     {
       double fileversion;
       std::string deviceType;
       std::string deviceName;
       std::string manufacturer;
       std::string model;
       std::string comment;
+      std::string host;
+      int port;
+      bool server;
       int numberOfImageStreams;
 
       bool useGreyscale;
       bool useResolutionOverride;
       int resolutionWidth;
       int resolutionHeight;
       int sourceID;
       std::string filepathVideoSource;
       int opencvPort;
 
       std::vector <mitk::USProbe::Pointer> probes;
 
-      USVideoDeviceConfigData_()
+      USDeviceConfigData_()
         : fileversion(0), deviceType("Unknown"), deviceName("Unknown"),
-          manufacturer("Unknown"), comment(""), numberOfImageStreams(1),
+          manufacturer("Unknown"), comment(""), host("localhost"),
+          port(18944), server(false), numberOfImageStreams(1),
           useGreyscale(true), useResolutionOverride(true),
           resolutionWidth(640), resolutionHeight(480), sourceID(0),
           filepathVideoSource(""), opencvPort(0)
         { };
 
-    }USVideoDeviceConfigData;
+    }USDeviceConfigData;
 
-    USVideoDeviceConfigData &GetUSVideoDeviceConfigData();
+    USDeviceConfigData &GetUSDeviceConfigData();
 
   protected:
     USDeviceReaderXML(const USDeviceReaderXML& other);
     mitk::USDeviceReaderXML* Clone() const override;
 
     /**
     * \brief Extracts all stored attribute information of the ULTRASOUNDDEVICE-Tag.
     */
     void ExtractAttributeInformationOfUltrasoundDeviceTag(TiXmlElement *element);
 
     /**
     * \brief Extracts all stored attribute information of the GENERALSETTINGS-Tag.
     */
     void ExtractAttributeInformationOfGeneralSettingsTag(TiXmlElement *element);
 
     /**
     * \brief Extracts all stored information of a single ultrasound probe.
     */
     void ExtractProbe(TiXmlElement *element);
 
   private:
     std::string m_Filename;
-    USVideoDeviceConfigData m_DeviceConfig;
+    USDeviceConfigData m_DeviceConfig;
   };
 
 } // namespace mitk
 
 #endif // mitkUSDeviceReaderXML_H_HEADER_INCLUDED_
diff --git a/Modules/US/USModel/mitkUSDeviceWriterXML.cpp b/Modules/US/USModel/mitkUSDeviceWriterXML.cpp
index 3a05ddb3d8..5a9dc04bfe 100644
--- a/Modules/US/USModel/mitkUSDeviceWriterXML.cpp
+++ b/Modules/US/USModel/mitkUSDeviceWriterXML.cpp
@@ -1,157 +1,157 @@
 /*===================================================================
 
 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 "mitkUSDeviceReaderWriterConstants.h"
 #include "mitkUSDeviceWriterXML.h"
 #include <mitkIGTMimeTypes.h>
 #include <mitkLocaleSwitch.h>
 #include <mitkUSDevice.h>
 
 // Third Party
 #include <tinyxml.h>
 #include <itksys/SystemTools.hxx>
 #include <fstream>
 #include <iostream>
 
 mitk::USDeviceWriterXML::USDeviceWriterXML() : AbstractFileWriter(USDevice::GetStaticNameOfClass(),
   mitk::IGTMimeTypes::USDEVICEINFORMATIONXML_MIMETYPE(),
   "MITK USDevice Writer (XML)"), m_Filename("")
 {
   RegisterService();
 }
 
 mitk::USDeviceWriterXML::USDeviceWriterXML(const mitk::USDeviceWriterXML& other) : AbstractFileWriter(other)
 {
 }
 
 mitk::USDeviceWriterXML::~USDeviceWriterXML()
 {
 }
 
 mitk::USDeviceWriterXML* mitk::USDeviceWriterXML::Clone() const
 {
   return new USDeviceWriterXML(*this);
 }
 
 void mitk::USDeviceWriterXML::Write()
 {
   if (m_Filename == "")
   {
     MITK_WARN << "Cannot write to file - empty filename!";
     return;
   }
 }
 
 void mitk::USDeviceWriterXML::SetFilename(std::string filename)
 {
   m_Filename = filename;
 }
 
-bool mitk::USDeviceWriterXML::WriteUltrasoundVideoDeviceConfiguration(mitk::USDeviceReaderXML::USVideoDeviceConfigData & config)
+bool mitk::USDeviceWriterXML::WriteUltrasoundVideoDeviceConfiguration(mitk::USDeviceReaderXML::USDeviceConfigData & config)
 {
   TiXmlDocument document;
   TiXmlDeclaration* xmlDeclaration = new TiXmlDeclaration("1.0", "", "");
   document.LinkEndChild(xmlDeclaration);
 
 
   //Create the xml information of the ULTRASOUNDDEVICE-Tag:
   TiXmlElement *ultrasoundDeviceTag = new TiXmlElement(TAG_ULTRASOUNDDEVICE);
   this->CreateXmlInformationOfUltrasoundDeviceTag(document, ultrasoundDeviceTag, config);
 
 
   //Create the xml information of the GENERALSETTINGS-Tag:
   TiXmlElement *generalSettingsTag = new TiXmlElement(TAG_GENERALSETTINGS);
   this->CreateXmlInformationOfGeneralSettingsTag(ultrasoundDeviceTag, generalSettingsTag, config);
 
   //Create the xml information of the PROBES-Tag:
   this->CreateXmlInformationOfProbesTag(ultrasoundDeviceTag, config);
 
   return document.SaveFile(m_Filename);
 }
 
 void mitk::USDeviceWriterXML::CreateXmlInformationOfUltrasoundDeviceTag(
   TiXmlDocument &document, TiXmlElement * ultrasoundDeviceTag,
-  mitk::USDeviceReaderXML::USVideoDeviceConfigData &config)
+  mitk::USDeviceReaderXML::USDeviceConfigData &config)
 {
   ultrasoundDeviceTag->SetAttribute(ATTR_FILEVERS, config.fileversion);
   ultrasoundDeviceTag->SetAttribute(ATTR_TYPE, config.deviceType);
   ultrasoundDeviceTag->SetAttribute(ATTR_NAME, config.deviceName);
   ultrasoundDeviceTag->SetAttribute(ATTR_MANUFACTURER, config.manufacturer);
   ultrasoundDeviceTag->SetAttribute(ATTR_MODEL, config.model);
   ultrasoundDeviceTag->SetAttribute(ATTR_COMMENT, config.comment);
   ultrasoundDeviceTag->SetAttribute(ATTR_IMAGESTREAMS, config.numberOfImageStreams);
 
   document.LinkEndChild(ultrasoundDeviceTag);
 }
 
-void mitk::USDeviceWriterXML::CreateXmlInformationOfGeneralSettingsTag(TiXmlElement *parentTag, TiXmlElement *generalSettingsTag, mitk::USDeviceReaderXML::USVideoDeviceConfigData & config)
+void mitk::USDeviceWriterXML::CreateXmlInformationOfGeneralSettingsTag(TiXmlElement *parentTag, TiXmlElement *generalSettingsTag, mitk::USDeviceReaderXML::USDeviceConfigData & config)
 {
   std::string value = config.useGreyscale ? "true" : "false";
   generalSettingsTag->SetAttribute(ATTR_GREYSCALE, value);
   value = config.useResolutionOverride ? "true" : "false";
   generalSettingsTag->SetAttribute(ATTR_RESOLUTIONOVERRIDE, value);
   generalSettingsTag->SetAttribute(ATTR_RESOLUTIONWIDTH, config.resolutionWidth);
   generalSettingsTag->SetAttribute(ATTR_RESOLUTIONHEIGHT, config.resolutionHeight);
 
   generalSettingsTag->SetAttribute(ATTR_SOURCEID, config.sourceID);
   generalSettingsTag->SetAttribute(ATTR_FILEPATH, config.filepathVideoSource);
   generalSettingsTag->SetAttribute(ATTR_OPENCVPORT, config.opencvPort);
 
   parentTag->LinkEndChild(generalSettingsTag);
 }
 
-void mitk::USDeviceWriterXML::CreateXmlInformationOfProbesTag(TiXmlElement * parentTag, mitk::USDeviceReaderXML::USVideoDeviceConfigData & config)
+void mitk::USDeviceWriterXML::CreateXmlInformationOfProbesTag(TiXmlElement * parentTag, mitk::USDeviceReaderXML::USDeviceConfigData & config)
 {
   if (config.probes.size() != 0)
   {
     TiXmlElement *probesTag = new TiXmlElement(TAG_PROBES);
     parentTag->LinkEndChild(probesTag);
 
     for (size_t index = 0; index < config.probes.size(); ++index)
     {
       TiXmlElement *probeTag = new TiXmlElement(TAG_PROBE);
       probesTag->LinkEndChild(probeTag);
 
       mitk::USProbe::Pointer probe = config.probes.at(index);
       probeTag->SetAttribute(ATTR_NAME, probe->GetName());
       std::map<int, mitk::Vector3D> depthsAndSpacing = probe->GetDepthsAndSpacing();
       if (depthsAndSpacing.size() != 0)
       {
         TiXmlElement *depthsTag = new TiXmlElement(TAG_DEPTHS);
         probeTag->LinkEndChild(depthsTag);
         for (std::map<int, mitk::Vector3D>::iterator it = depthsAndSpacing.begin(); it != depthsAndSpacing.end(); it++)
         {
           TiXmlElement *depthTag = new TiXmlElement(TAG_DEPTH);
           depthTag->SetAttribute(ATTR_DEPTH, it->first);
           depthsTag->LinkEndChild(depthTag);
 
           TiXmlElement *spacingTag = new TiXmlElement(TAG_SPACING);
           spacingTag->SetDoubleAttribute(ATTR_X, it->second[0], 6);
           spacingTag->SetDoubleAttribute(ATTR_Y, it->second[1], 6);
           depthTag->LinkEndChild(spacingTag);
         }
 
         TiXmlElement *croppingTag = new TiXmlElement(TAG_CROPPING);
         probeTag->LinkEndChild(croppingTag);
         croppingTag->SetAttribute(ATTR_TOP, probe->GetProbeCropping().top);
         croppingTag->SetAttribute(ATTR_BOTTOM, probe->GetProbeCropping().bottom);
         croppingTag->SetAttribute(ATTR_LEFT, probe->GetProbeCropping().left);
         croppingTag->SetAttribute(ATTR_RIGHT, probe->GetProbeCropping().right);
       }
     }
   }
 }
diff --git a/Modules/US/USModel/mitkUSDeviceWriterXML.h b/Modules/US/USModel/mitkUSDeviceWriterXML.h
index 027733c578..193ed839bb 100644
--- a/Modules/US/USModel/mitkUSDeviceWriterXML.h
+++ b/Modules/US/USModel/mitkUSDeviceWriterXML.h
@@ -1,92 +1,92 @@
 /*===================================================================
 
 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 mitkUSDeviceWriterXML_H_Header_INCLUDED_
 #define mitkUSDeviceWriterXML_H_Header_INCLUDED_
 
 #include <MitkUSExports.h>
 
 #include <mitkAbstractFileWriter.h>
 #include <mitkUSDeviceReaderXML.h>
 
 class TiXmlDocument;
 class TiXmlElement;
 
 namespace mitk {
   class MITKUS_EXPORT USDeviceWriterXML : public AbstractFileWriter
   {
   public:
 
     USDeviceWriterXML();
     ~USDeviceWriterXML() override;
 
     using AbstractFileWriter::Write;
     void Write() override;
 
     /**
     * \brief Sets the filename of the ultrasound device configuration file which should be created.
     */
     void SetFilename(std::string filename);
 
     /**
     * \brief Writes the configuration settings of an ultrasound device to a xml-file.
     * \param config The struct containing all information of the ultrasound device.
     */
-    bool WriteUltrasoundVideoDeviceConfiguration(mitk::USDeviceReaderXML::USVideoDeviceConfigData &config);
+    bool WriteUltrasoundVideoDeviceConfiguration(mitk::USDeviceReaderXML::USDeviceConfigData &config);
 
   protected:
     USDeviceWriterXML(const USDeviceWriterXML& other);
     mitk::USDeviceWriterXML* Clone() const override;
 
     /**
     * \brief Creates the xml ULTRASOUNDDEVICE-Tag entry of the ultrasound video device configuration file.
     * \param document A reference to the xml document.
     * \param ultrasoundDeviceTag The ULTRASOUNDDEVICETAG which should be created.
     * \param config The struct containing all information of the ultrasound device.
     */
     void CreateXmlInformationOfUltrasoundDeviceTag( TiXmlDocument &document,
                                                     TiXmlElement *ultrasoundDeviceTag,
-                                                    mitk::USDeviceReaderXML::USVideoDeviceConfigData &config);
+                                                    mitk::USDeviceReaderXML::USDeviceConfigData &config);
 
     /**
     * \brief Creates the xml GENERALSETTINGS-Tag entry of the ultrasound video device configuration file.
     * \param parentTag The xml parent tag of the GENERALSETTINGS-Tag. This is the ULTRASOUNDDEVICE-Tag.
     * \param generalSettingsTag The GENERALSETTINGS-Tag which should be created.
     * \param config The struct containing all information of the ultrasound device.
     */
     void CreateXmlInformationOfGeneralSettingsTag( TiXmlElement *parentTag,
                                                    TiXmlElement *generalSettingsTag,
-                                                   mitk::USDeviceReaderXML::USVideoDeviceConfigData &config);
+                                                   mitk::USDeviceReaderXML::USDeviceConfigData &config);
 
     /**
     * \brief Creates the xml PROBES-Tag entry of the ultrasound video device configuration file. All information
     * of all configured probes is extracted and then stored in the xml file.
     * \param parentTag The xml parent tag of the GENERALSETTINGS-Tag. This is the ULTRASOUNDDEVICE-Tag.
     * \param config The struct containing all information of the ultrasound device.
     */
     void CreateXmlInformationOfProbesTag( TiXmlElement *parentTag,
-                                          mitk::USDeviceReaderXML::USVideoDeviceConfigData &config);
+                                          mitk::USDeviceReaderXML::USDeviceConfigData &config);
   private:
     /**
     * \brief The filename of the ultrasound device configuration file which should be created.
     */
     std::string m_Filename;
 
 
   };
 }
 
 #endif // mitkUSDeviceWriterXML_H_Header_INCLUDED_
diff --git a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
index 8f909cc828..dabad1e173 100644
--- a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
+++ b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.cpp
@@ -1,807 +1,853 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 //#define _USE_MATH_DEFINES
 #include <QmitkUSNewVideoDeviceWidget.h>
 
 // QT headers
 #include <QFileDialog>
 #include <QMessageBox>
 
 // mitk headers
 
 // itk headers
 
 #include <mitkUSDeviceReaderXML.h>
 #include <mitkUSDeviceWriterXML.h>
 
 const std::string QmitkUSNewVideoDeviceWidget::VIEW_ID =
 "org.mitk.views.QmitkUSNewVideoDeviceWidget";
 
 QmitkUSNewVideoDeviceWidget::QmitkUSNewVideoDeviceWidget(QWidget* parent,
   Qt::WindowFlags f)
   : QWidget(parent, f)
 {
   m_Controls = nullptr;
   CreateQtPartControl(this);
 }
 
 QmitkUSNewVideoDeviceWidget::~QmitkUSNewVideoDeviceWidget() {}
 
 //////////////////// INITIALIZATION /////////////////////
 
 void QmitkUSNewVideoDeviceWidget::CreateQtPartControl(QWidget* parent)
 {
   if (!m_Controls)
   {
     // create GUI widgets
     m_Controls = new Ui::QmitkUSNewVideoDeviceWidgetControls;
     m_Controls->setupUi(parent);
     this->CreateConnections();
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::CreateConnections()
 {
   if (m_Controls)
   {
     // connect(m_Controls->m_BtnDone, SIGNAL(clicked()), this,
     //  SLOT(OnClickedDone()));
     connect(m_Controls->m_BtnCancel, SIGNAL(clicked()), this,
       SLOT(OnClickedCancel()));
     connect(m_Controls->m_RadioDeviceSource, SIGNAL(clicked()), this,
       SLOT(OnDeviceTypeSelection()));
     connect(m_Controls->m_RadioFileSource, SIGNAL(clicked()), this,
       SLOT(OnDeviceTypeSelection()));
     connect(m_Controls->m_RadioOIGTLClientSource, SIGNAL(clicked()), this,
       SLOT(OnDeviceTypeSelection()));
     connect(m_Controls->m_RadioOIGTLServerSource, SIGNAL(clicked()), this,
       SLOT(OnDeviceTypeSelection()));
     connect(m_Controls->m_OpenFileButton, SIGNAL(clicked()), this,
       SLOT(OnOpenFileButtonClicked()));
 
     connect(m_Controls->m_BtnSave, SIGNAL(clicked()), this,
             SLOT(OnSaveButtonClicked()));
     connect(m_Controls->m_BtnLoadConfiguration, SIGNAL(clicked()), this,
       SLOT(OnLoadConfigurationButtonClicked()));
 
     //Connect buttons and functions for editing of probes
     connect(m_Controls->m_AddNewProbePushButton, SIGNAL(clicked()), this, SLOT(OnAddNewProbeClicked()));
     connect(m_Controls->m_BtnRemoveProbe, SIGNAL(clicked()), this, SLOT(OnClickedRemoveProbe()));
     connect(m_Controls->m_BtnRemoveDepth, SIGNAL(clicked()), this, SLOT(OnClickedRemoveDepth()));
     connect(m_Controls->m_BtnAddDepths, SIGNAL(clicked()), this, SLOT(OnClickedAddDepths()));
     connect(m_Controls->m_Probes, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnProbeChanged(const QString &)));
     connect(m_Controls->m_Depths, SIGNAL(currentTextChanged(const QString &)), this, SLOT(OnDepthChanged(const QString &)));
 
     connect(m_Controls->m_XSpacingSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnXSpacingSpinBoxChanged(double)));
     connect(m_Controls->m_YSpacingSpinBox, SIGNAL(valueChanged(double)), this, SLOT(OnYSpacingSpinBoxChanged(double)));
     connect(m_Controls->m_CroppingTopSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnCroppingTopSpinBoxChanged(int)));
     connect(m_Controls->m_CroppingRightSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnCroppingRightSpinBoxChanged(int)));
     connect(m_Controls->m_CroppingBottomSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnCroppingBottomSpinBoxChanged(int)));
     connect(m_Controls->m_CroppingLeftSpinBox, SIGNAL(valueChanged(int)), this, SLOT(OnCroppingLeftSpinBoxChanged(int)));
   }
 }
 
 ///////////// Methods & Slots Handling Direct Interaction /////////////////
 
 void QmitkUSNewVideoDeviceWidget::OnClickedDone()
 {
   m_Active = false;
 
   // Create Device
   mitk::USDevice::Pointer newDevice;
   if (m_Controls->m_RadioDeviceSource->isChecked())
   {
     newDevice = mitk::USVideoDevice::New(
       m_Controls->m_DeviceSelector->value(),
       m_Controls->m_Manufacturer->text().toStdString(),
       m_Controls->m_Model->text().toStdString());
     newDevice->SetComment(m_Controls->m_Comment->text().toStdString());
   }
   else if (m_Controls->m_RadioFileSource->isChecked())
   {
     newDevice = mitk::USVideoDevice::New(
       m_Controls->m_FilePathSelector->text().toStdString(),
       m_Controls->m_Manufacturer->text().toStdString(),
       m_Controls->m_Model->text().toStdString());
     newDevice->SetComment(m_Controls->m_Comment->text().toStdString());
   }
   else if (m_Controls->m_RadioOIGTLClientSource->isChecked())
   {
     std::string host = m_Controls->m_OIGTLClientHost->text().toStdString();
     int port = m_Controls->m_OIGTLClientPort->value();
 
     // Create a new USIGTLDevice. The last parameter tells the device that it should be a client.
     newDevice = mitk::USIGTLDevice::New(m_Controls->m_Manufacturer->text().toStdString(),
                 m_Controls->m_Model->text().toStdString(), host, port, false);
     //New behavior at this position: do not return immediately as it was done in earlier MITK-versions
     // The IGTL Device can have different probe configurations,  as well.
   }
   else
   {
     std::string host = m_Controls->m_OIGTLServerHost->text().toStdString();
     int port = m_Controls->m_OIGTLServerPort->value();
 
     // Create a new USIGTLDevice. The last parameter tells the device that it should be a server.
     newDevice = mitk::USIGTLDevice::New(m_Controls->m_Manufacturer->text().toStdString(),
                 m_Controls->m_Model->text().toStdString(), host, port, true);
     //New behavior at this position: do not return immediately as it was done in earlier MITK-versions
     // The IGTL Device can have different probe configurations,  as well.
   }
 
   //At first: only ckeck, whether it is a USImageVideoSource or not (--> if it a IGTL Client)
   // Later: perhaps it would be helpful, if the IGTLMessageToUSImageFilter have a region of interest, as well.
   mitk::USImageVideoSource::Pointer imageSource =
     dynamic_cast<mitk::USImageVideoSource*>(
       newDevice->GetUSImageSource().GetPointer());
   if (imageSource.IsNotNull())
   {
 
     // Set Video Options
     imageSource->SetColorOutput(!m_Controls->m_CheckGreyscale->isChecked());
 
     // If Resolution override is activated, apply it
     if (m_Controls->m_CheckResolutionOverride->isChecked())
     {
       int width = m_Controls->m_ResolutionWidth->value();
       int height = m_Controls->m_ResolutionHeight->value();
       imageSource->OverrideResolution(width, height);
       imageSource->SetResolutionOverride(true);
     }
   }
 
   if (m_Controls->m_Probes->count() != 0 ) //there are informations about the probes of the device, so create the probes
   {
     this->AddProbesToDevice(newDevice);
   }
   else //no information about the probes of the device, so set default value
   {
     mitk::USProbe::Pointer probe = mitk::USProbe::New("default");
     probe->SetDepth(0);
     newDevice->DeleteAllProbes();
     newDevice->AddNewProbe(probe);
   }
   newDevice->Initialize();
   CleanUpAfterCreatingNewDevice();
 
   emit Finished();
 }
 
 void QmitkUSNewVideoDeviceWidget::OnClickedFinishedEditing()
 {
   m_Active = false;
   m_TargetDevice->SetManufacturer(m_Controls->m_Manufacturer->text().toStdString());
   m_TargetDevice->SetName(m_Controls->m_Model->text().toStdString());
   m_TargetDevice->SetComment(m_Controls->m_Comment->text().toStdString());
 
   if (m_Controls->m_Probes->count() != 0) //there are informations about the probes of the device, so create the probes
   {
     this->AddProbesToDevice(m_TargetDevice);
   }
   else //no information about the probes of the device, so set default value
   {
     mitk::USProbe::Pointer probe = mitk::USProbe::New("default");
     probe->SetDepth(0);
     m_TargetDevice->DeleteAllProbes();
     m_TargetDevice->AddNewProbe(probe);
   }
 
   //At first: only ckeck, whether it is a USImageVideoSource or not (--> if it a IGTL Client)
   // Later: perhaps it would be helpful, if the IGTLMessageToUSImageFilter have a region of interest, as well.
   mitk::USImageVideoSource::Pointer imageSource =
     dynamic_cast<mitk::USImageVideoSource*>(
     m_TargetDevice->GetUSImageSource().GetPointer());
   if (imageSource.IsNotNull())
   {
     // Set Video Options
     imageSource->SetColorOutput(!m_Controls->m_CheckGreyscale->isChecked());
 
     // If Resolution override is activated, apply it
     if (m_Controls->m_CheckResolutionOverride->isChecked())
     {
       int width = m_Controls->m_ResolutionWidth->value();
       int height = m_Controls->m_ResolutionHeight->value();
       imageSource->OverrideResolution(width, height);
       imageSource->SetResolutionOverride(true);
     }
   }
   CleanUpAfterEditingOfDevice();
   MITK_INFO << "Finished Editing";
   emit Finished();
 }
 
 void QmitkUSNewVideoDeviceWidget::OnClickedCancel()
 {
   m_TargetDevice = nullptr;
   m_Active = false;
   CleanUpAfterCreatingNewDevice();
   CleanUpAfterEditingOfDevice();
   emit Finished();
 }
 
 void QmitkUSNewVideoDeviceWidget::OnDeviceTypeSelection()
 {
   m_Controls->m_FilePathSelector->setEnabled(
     m_Controls->m_RadioFileSource->isChecked());
   m_Controls->m_DeviceSelector->setEnabled(
     m_Controls->m_RadioDeviceSource->isChecked());
   m_Controls->m_OIGTLClientHost->setEnabled(
     m_Controls->m_RadioOIGTLClientSource->isChecked());
   m_Controls->m_OIGTLClientPort->setEnabled(
     m_Controls->m_RadioOIGTLClientSource->isChecked());
   m_Controls->m_OIGTLServerHost->setEnabled(
     m_Controls->m_RadioOIGTLServerSource->isChecked());
   m_Controls->m_OIGTLServerPort->setEnabled(
     m_Controls->m_RadioOIGTLServerSource->isChecked());
 }
 
 void QmitkUSNewVideoDeviceWidget::OnOpenFileButtonClicked()
 {
   QString fileName = QFileDialog::getOpenFileName(nullptr, "Open Video File");
   if (fileName.isNull())
   {
     return;
   }  // user pressed cancel
 
   m_Controls->m_FilePathSelector->setText(fileName);
 
   m_Controls->m_RadioFileSource->setChecked(true);
   this->OnDeviceTypeSelection();
 }
 
 ///////////////// Methods & Slots Handling Logic //////////////////////////
 
 void QmitkUSNewVideoDeviceWidget::EditDevice(mitk::USDevice::Pointer device)
 {
   // If no VideoDevice is given, throw an exception
   if (device->GetDeviceClass().compare("org.mitk.modules.us.USVideoDevice") != 0 &&
       device->GetDeviceClass().compare("IGTL Client") != 0)
   {
     // TODO Alert if bad path
     mitkThrow() << "NewVideoDeviceWidget recieved an incompatible device type "
       "to edit. Type was: " << device->GetDeviceClass();
   }
 
   m_TargetDevice = device;
   m_Active = true;
   m_ConfigProbes.clear();
   m_ConfigProbes = m_TargetDevice->GetAllProbes();
   ChangeUIEditingUSVideoDevice();
 }
 
 void QmitkUSNewVideoDeviceWidget::CreateNewDevice()
 {
 
   //Prevent multiple calls of OnClickedDone()
   disconnect(m_Controls->m_BtnDone, SIGNAL(clicked()), this, SLOT(OnClickedDone()));
   //Toggle functionality of Btn_Done
   connect(m_Controls->m_BtnDone, SIGNAL(clicked()), this, SLOT(OnClickedDone()));
   m_Controls->m_BtnDone->setText("Add Video Device");
 
   //Fill Metadata with default information
   m_Controls->m_Manufacturer->setText("Unknown Manufacturer");
   m_Controls->m_Model->setText("Unknown Model");
   m_Controls->m_Comment->setText("None");
 
   m_TargetDevice = nullptr;
   m_ConfigProbes.clear();
   m_ConfigProbes.clear();
   m_Active = true;
 }
 
 /////////////////////// HOUSEHOLDING CODE ///////////////////////////////
 
 QListWidgetItem* QmitkUSNewVideoDeviceWidget::ConstructItemFromDevice(
   mitk::USDevice::Pointer device)
 {
   QListWidgetItem* result = new QListWidgetItem;
   std::string text =
     device->GetManufacturer() + "|" + device->GetName();
   result->setText(text.c_str());
   return result;
 }
 
 void QmitkUSNewVideoDeviceWidget::ChangeUIEditingUSVideoDevice()
 {
   for (std::vector<mitk::USProbe::Pointer>::iterator it = m_ConfigProbes.begin(); it != m_ConfigProbes.end(); it++)
   {
     std::string probeName = (*it)->GetName();
     m_Controls->m_Probes->addItem(QString::fromUtf8(probeName.data(), probeName.size()));
   }
   OnProbeChanged(m_Controls->m_Probes->currentText());
 
   //Toggle functionality of Btn_Done
   m_Controls->m_BtnDone->setText("Apply Changes");
   connect(m_Controls->m_BtnDone, SIGNAL(clicked()), this, SLOT(OnClickedFinishedEditing()));
 
   //Fill Metadata with Information provided by the Device selected to edit
   m_Controls->m_Manufacturer->setText(m_TargetDevice->GetManufacturer().c_str());
   m_Controls->m_Model->setText(m_TargetDevice->GetName().c_str());
   m_Controls->m_Comment->setText(m_TargetDevice->GetComment().c_str());
 }
 
 void QmitkUSNewVideoDeviceWidget::OnClickedAddDepths()
 {
   if (!m_Controls->m_Probes->currentText().isEmpty())
   {
     QString depths = m_Controls->m_AddDepths->text();
     if( depths.isEmpty() )
       return;
 
     std::string probename = m_Controls->m_Probes->currentText().toStdString();
     mitk::USProbe::Pointer currentProbe = this->CheckIfProbeExistsAlready(probename);
 
     QStringList singleDepths = depths.split(',');
     for (int i = 0; i < singleDepths.size(); i++)
     {
       currentProbe->SetDepth(singleDepths.at(i).toInt());
     }
     m_Controls->m_AddDepths->clear();
     m_Controls->m_Depths->setEnabled(true);
     m_Controls->m_BtnRemoveDepth->setEnabled(true);
     OnProbeChanged(m_Controls->m_Probes->currentText());
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::OnClickedRemoveDepth()
 {
   if (!m_Controls->m_Probes->currentText().isEmpty() && !m_Controls->m_Depths->currentText().isEmpty())
   {
     std::string probename = m_Controls->m_Probes->currentText().toStdString();
     int indexOfDepthToRemove = m_Controls->m_Depths->currentIndex();
     mitk::USProbe::Pointer currentProbe = this->CheckIfProbeExistsAlready(probename);
     currentProbe->RemoveDepth(m_Controls->m_Depths->currentText().toInt());
     m_Controls->m_Depths->removeItem(indexOfDepthToRemove);
 
     if (m_Controls->m_Depths->count() == 0)
     {
       m_Controls->m_Depths->setEnabled(false);
       m_Controls->m_BtnRemoveDepth->setEnabled(false);
 
       this->EnableDisableSpacingAndCropping(false);
     }
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::OnClickedRemoveProbe()
 {
   if (!m_Controls->m_Probes->currentText().isEmpty())
   {
     std::string probename = m_Controls->m_Probes->currentText().toStdString();
     int indexOfProbeToRemove = m_Controls->m_Probes->currentIndex();
     m_ConfigProbes.erase(m_ConfigProbes.begin() + indexOfProbeToRemove);
     m_Controls->m_Probes->removeItem(indexOfProbeToRemove);
     if( m_Controls->m_Probes->count() == 0 )
     {
       m_Controls->m_Probes->setEnabled(false);
       m_Controls->m_BtnRemoveProbe->setEnabled(false);
       m_Controls->m_BtnAddDepths->setEnabled(false);
       m_Controls->m_AddDepths->setEnabled(false);
       m_Controls->m_Depths->setEnabled(false);
       m_Controls->m_BtnRemoveDepth->setEnabled(false);
 
       this->EnableDisableSpacingAndCropping(false);
     }
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::OnProbeChanged(const QString & probename)
 {
   if (!probename.isEmpty())
   {
     std::string name = probename.toStdString();
     mitk::USProbe::Pointer probe = this->CheckIfProbeExistsAlready(name);
     if( probe.IsNotNull() )
     {
       std::map<int, mitk::Vector3D> depths = probe->GetDepthsAndSpacing();
       m_Controls->m_Depths->clear();
       for (std::map<int, mitk::Vector3D>::iterator it = depths.begin(); it != depths.end(); it++)
       {
         m_Controls->m_Depths->addItem(QString::number(it->first));
       }
 
       this->OnDepthChanged(m_Controls->m_Depths->currentText().toInt(), probe);
     }
   }
   else
   {
     m_Controls->m_Depths->clear();
     m_Controls->m_Depths->setEnabled(false);
     m_Controls->m_BtnRemoveDepth->setEnabled(false);
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::OnDepthChanged(int depth, mitk::USProbe::Pointer probe)
 {
   if (m_Controls->m_Depths->count() == 0)
   {
     m_Controls->m_Depths->setEnabled(false);
     m_Controls->m_BtnRemoveDepth->setEnabled(false);
 
     this->EnableDisableSpacingAndCropping(false);
     return;
   }
 
   if (probe.IsNotNull())
   {
     mitk::Vector3D spacing = probe->GetSpacingForGivenDepth(depth);
     m_Controls->m_XSpacingSpinBox->setValue(spacing[0]);
     m_Controls->m_YSpacingSpinBox->setValue(spacing[1]);
 
     mitk::USProbe::USProbeCropping cropping = probe->GetProbeCropping();
     m_Controls->m_CroppingTopSpinBox->setValue(cropping.top);
     m_Controls->m_CroppingRightSpinBox->setValue(cropping.right);
     m_Controls->m_CroppingBottomSpinBox->setValue(cropping.bottom);
     m_Controls->m_CroppingLeftSpinBox->setValue(cropping.left);
 
     this->EnableDisableSpacingAndCropping(true);
 
     m_Controls->m_Depths->setEnabled(true);
     m_Controls->m_BtnRemoveDepth->setEnabled(true);
     m_Controls->m_AddDepths->setEnabled(true);
     m_Controls->m_BtnAddDepths->setEnabled(true);
     m_Controls->m_Probes->setEnabled(true);
     m_Controls->m_BtnRemoveProbe->setEnabled(true);
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::OnDepthChanged(const QString &depth)
 {
   MITK_INFO << "OnDepthChanged(int, mitk::USProbe)";
   if( depth.isEmpty() )
   {
     this->EnableDisableSpacingAndCropping(false);
     return;
   }
   QString probeName = m_Controls->m_Probes->currentText();
 
   this->OnDepthChanged(depth.toInt(), this->CheckIfProbeExistsAlready(probeName.toStdString()) );
 }
 
 void QmitkUSNewVideoDeviceWidget::OnSaveButtonClicked()
 {
   QString fileName = QFileDialog::getSaveFileName(nullptr, "Save Configuration ...", "", "XML files (*.xml)");
   if( fileName.isNull() )
   {
     return;
   }  // user pressed cancel
 
   mitk::USDeviceWriterXML deviceWriter;
   deviceWriter.SetFilename(fileName.toStdString());
 
-  mitk::USDeviceReaderXML::USVideoDeviceConfigData config;
+  mitk::USDeviceReaderXML::USDeviceConfigData config;
   this->CollectUltrasoundVideoDeviceConfigInformation(config);
 
   if (!deviceWriter.WriteUltrasoundVideoDeviceConfiguration(config))
   {
     QMessageBox msgBox;
     msgBox.setText("Error when writing the configuration to the selected file. Could not write device information.");
     msgBox.exec();
     return;
   }
 
 }
 
 void QmitkUSNewVideoDeviceWidget::OnLoadConfigurationButtonClicked()
 {
   QString fileName = QFileDialog::getOpenFileName(this, "Open ultrasound device configuration ...");
   if (fileName.isNull())
   {
     return;
   }  // user pressed cancel
 
   mitk::USDeviceReaderXML deviceReader;
   deviceReader.SetFilename(fileName.toStdString());
   if (!deviceReader.ReadUltrasoundDeviceConfiguration())
   {
     QMessageBox msgBox;
     msgBox.setText("Error when parsing the selected file. Could not load stored device information.");
     msgBox.exec();
     return;
   }
-  mitk::USDeviceReaderXML::USVideoDeviceConfigData config = deviceReader.GetUSVideoDeviceConfigData();
+  mitk::USDeviceReaderXML::USDeviceConfigData config = deviceReader.GetUSDeviceConfigData();
 
   if( config.fileversion == 1.0 )
   {
     if (config.deviceType.compare("video") == 0)
     {
       //Fill info in metadata groupbox:
       m_Controls->m_DeviceName->setText(QString::fromStdString(config.deviceName));
       m_Controls->m_Manufacturer->setText(QString::fromStdString(config.manufacturer));
       m_Controls->m_Model->setText(QString::fromStdString(config.model));
       m_Controls->m_Comment->setText(QString::fromStdString(config.comment));
 
       //Fill info about video source:
       m_Controls->m_DeviceSelector->setValue(config.sourceID);
       m_Controls->m_FilePathSelector->setText(QString::fromStdString(config.filepathVideoSource));
 
       //Fill video options:
       m_Controls->m_CheckGreyscale->setChecked(config.useGreyscale);
 
       //Fill override options:
       m_Controls->m_CheckResolutionOverride->setChecked(config.useResolutionOverride);
       m_Controls->m_ResolutionWidth->setValue(config.resolutionWidth);
       m_Controls->m_ResolutionHeight->setValue(config.resolutionHeight);
 
       //Fill information about probes:
       m_ConfigProbes.clear();
       m_ConfigProbes = config.probes;
 
       m_Controls->m_Probes->clear();
       m_Controls->m_ProbeNameLineEdit->clear();
       m_Controls->m_AddDepths->clear();
       m_Controls->m_Depths->clear();
 
       for( size_t index = 0; index < m_ConfigProbes.size(); ++index)
       {
         m_Controls->m_Probes->addItem(QString::fromStdString(config.probes.at(index)->GetName()));
       }
       this->OnProbeChanged(m_Controls->m_Probes->currentText());
 
     }
+    else if (config.deviceType.compare("oigtl") == 0)
+    {
+      //Fill info in metadata groupbox:
+      m_Controls->m_DeviceName->setText(QString::fromStdString(config.deviceName));
+      m_Controls->m_Manufacturer->setText(QString::fromStdString(config.manufacturer));
+      m_Controls->m_Model->setText(QString::fromStdString(config.model));
+      m_Controls->m_Comment->setText(QString::fromStdString(config.comment));
+
+      //Fill info about OpenIGTLink video source:
+      if (config.server)
+      {
+        m_Controls->m_RadioOIGTLServerSource->setChecked(true);
+        m_Controls->m_OIGTLServerHost->setText(QString::fromStdString(config.host));
+        m_Controls->m_OIGTLServerPort->setValue(config.port);
+      }
+      else
+      {
+        m_Controls->m_RadioOIGTLClientSource->setChecked(true);
+        m_Controls->m_OIGTLClientHost->setText(QString::fromStdString(config.host));
+        m_Controls->m_OIGTLClientPort->setValue(config.port);
+      }
+      this->OnDeviceTypeSelection();
+
+      //Fill video options:
+      m_Controls->m_CheckGreyscale->setChecked(config.useGreyscale);
+
+      //Fill override options:
+      m_Controls->m_CheckResolutionOverride->setChecked(config.useResolutionOverride);
+      m_Controls->m_ResolutionWidth->setValue(config.resolutionWidth);
+      m_Controls->m_ResolutionHeight->setValue(config.resolutionHeight);
+
+      //Fill information about probes:
+      m_ConfigProbes.clear();
+      m_ConfigProbes = config.probes;
+
+      m_Controls->m_Probes->clear();
+      m_Controls->m_ProbeNameLineEdit->clear();
+      m_Controls->m_AddDepths->clear();
+      m_Controls->m_Depths->clear();
+
+      for (size_t index = 0; index < m_ConfigProbes.size(); ++index)
+      {
+        m_Controls->m_Probes->addItem(QString::fromStdString(config.probes.at(index)->GetName()));
+      }
+      this->OnProbeChanged(m_Controls->m_Probes->currentText());
+    }
     else
     {
       MITK_WARN << "Unknown device type detected. The device type must be of type |video|";
     }
   }
   else
   {
     MITK_WARN << "Unknown fileversion. Only fileversion 1.0 is known to the system.";
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::OnAddNewProbeClicked()
 {
   QString probeName = m_Controls->m_ProbeNameLineEdit->text();
   probeName = probeName.trimmed();
   if (probeName.isEmpty())
   {
     m_Controls->m_ProbeNameLineEdit->clear();
     return;
   }
 
   if( this->CheckIfProbeExistsAlready(probeName.toStdString() ) != nullptr )
   {
     QMessageBox msgBox;
     msgBox.setText("Probe name already exists. Please choose another name for the probe.");
     msgBox.exec();
     m_Controls->m_ProbeNameLineEdit->clear();
   }
   else
   {
     mitk::USProbe::Pointer newProbe = mitk::USProbe::New(probeName.toStdString());
     m_ConfigProbes.push_back(newProbe);
     m_Controls->m_Probes->addItem(QString::fromStdString(probeName.toStdString()));
 
     m_Controls->m_Probes->setEnabled(true);
     m_Controls->m_BtnRemoveProbe->setEnabled(true);
     m_Controls->m_BtnAddDepths->setEnabled(true);
     m_Controls->m_AddDepths->setEnabled(true);
     m_Controls->m_ProbeNameLineEdit->clear();
   }
 }
 
 void QmitkUSNewVideoDeviceWidget::OnXSpacingSpinBoxChanged(double value)
 {
   MITK_INFO << "Changing x-spacing to: " << value;
   QString probeName = m_Controls->m_Probes->currentText();
   int depth = m_Controls->m_Depths->currentText().toInt();
 
   mitk::USProbe::Pointer probe = this->CheckIfProbeExistsAlready(probeName.toStdString());
   if (probe.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("An error occurred when changing the spacing. \
       The specified probe does not exist. \
       Please restart the configuration process.");
     msgBox.exec();
     return;
   }
 
   mitk::Vector3D spacing = probe->GetSpacingForGivenDepth(depth);
   spacing[0] = value;
   probe->SetSpacingForGivenDepth(depth, spacing);
 }
 
 void QmitkUSNewVideoDeviceWidget::OnYSpacingSpinBoxChanged(double value)
 {
   MITK_INFO << "Changing y-spacing to: " << value;
   QString probeName = m_Controls->m_Probes->currentText();
   int depth = m_Controls->m_Depths->currentText().toInt();
 
   mitk::USProbe::Pointer probe = this->CheckIfProbeExistsAlready(probeName.toStdString());
   if (probe.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("An error occurred when changing the spacing. \
       The specified probe does not exist. \
       Please restart the configuration process.");
     msgBox.exec();
     return;
   }
 
   mitk::Vector3D spacing = probe->GetSpacingForGivenDepth(depth);
   spacing[1] = value;
   probe->SetSpacingForGivenDepth(depth, spacing);
 }
 
 void QmitkUSNewVideoDeviceWidget::OnCroppingTopSpinBoxChanged(int value)
 {
   MITK_INFO << "Changing cropping top to: " << value;
   QString probeName = m_Controls->m_Probes->currentText();
 
   mitk::USProbe::Pointer probe = this->CheckIfProbeExistsAlready(probeName.toStdString());
   if (probe.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("An error occurred when changing the probe cropping. \
       The specified probe does not exist. \
       Please restart the configuration process.");
     msgBox.exec();
     return;
   }
 
   mitk::USProbe::USProbeCropping cropping = probe->GetProbeCropping();
   probe->SetProbeCropping(value, cropping.bottom, cropping.left, cropping.right);
 }
 
 void QmitkUSNewVideoDeviceWidget::OnCroppingRightSpinBoxChanged(int value)
 {
   MITK_INFO << "Changing cropping right to: " << value;
   QString probeName = m_Controls->m_Probes->currentText();
 
   mitk::USProbe::Pointer probe = this->CheckIfProbeExistsAlready(probeName.toStdString());
   if (probe.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("An error occurred when changing the probe cropping. \
       The specified probe does not exist. \
       Please restart the configuration process.");
     msgBox.exec();
     return;
   }
 
   mitk::USProbe::USProbeCropping cropping = probe->GetProbeCropping();
   probe->SetProbeCropping(cropping.top, cropping.bottom, cropping.left, value);
 }
 
 void QmitkUSNewVideoDeviceWidget::OnCroppingBottomSpinBoxChanged(int value)
 {
   MITK_INFO << "Changing cropping bottom to: " << value;
   QString probeName = m_Controls->m_Probes->currentText();
 
   mitk::USProbe::Pointer probe = this->CheckIfProbeExistsAlready(probeName.toStdString());
   if (probe.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("An error occurred when changing the probe cropping. \
       The specified probe does not exist. \
       Please restart the configuration process.");
     msgBox.exec();
     return;
   }
 
   mitk::USProbe::USProbeCropping cropping = probe->GetProbeCropping();
   probe->SetProbeCropping(cropping.top, value, cropping.left, cropping.right);
 }
 
 void QmitkUSNewVideoDeviceWidget::OnCroppingLeftSpinBoxChanged(int value)
 {
   MITK_INFO << "Changing cropping left to: " << value;
   QString probeName = m_Controls->m_Probes->currentText();
 
   mitk::USProbe::Pointer probe = this->CheckIfProbeExistsAlready(probeName.toStdString());
   if (probe.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("An error occurred when changing the probe cropping. \
       The specified probe does not exist. \
       Please restart the configuration process.");
     msgBox.exec();
     return;
   }
 
   mitk::USProbe::USProbeCropping cropping = probe->GetProbeCropping();
   probe->SetProbeCropping(cropping.top, cropping.bottom, value, cropping.right);
 }
 
 void QmitkUSNewVideoDeviceWidget::CleanUpAfterCreatingNewDevice()
 {
   disconnect(m_Controls->m_BtnDone, SIGNAL(clicked()), this, SLOT(OnClickedDone()));
   m_Controls->m_Probes->clear();
   m_Controls->m_Depths->clear();
   m_Controls->m_AddDepths->clear();
   m_Controls->m_ProbeNameLineEdit->clear();
   m_ConfigProbes.clear();
 }
 
 void QmitkUSNewVideoDeviceWidget::CleanUpAfterEditingOfDevice()
 {
   disconnect(m_Controls->m_BtnDone, SIGNAL(clicked()), this, SLOT(OnClickedFinishedEditing()));
   m_Controls->m_Probes->clear();
   m_Controls->m_Depths->clear();
   m_Controls->m_AddDepths->clear();
   m_ConfigProbes.clear();
 }
 
 void QmitkUSNewVideoDeviceWidget::AddProbesToDevice(mitk::USDevice::Pointer device)
 {
   device->DeleteAllProbes();
   for( std::vector<mitk::USProbe::Pointer>::iterator it = m_ConfigProbes.begin();
     it != m_ConfigProbes.end(); it++)
   {
     if ((*it)->IsDepthAndSpacingEmpty())
     {
       (*it)->SetDepth(0);
     }
     device->AddNewProbe((*it));
   }
 }
 
 mitk::USProbe::Pointer QmitkUSNewVideoDeviceWidget::CheckIfProbeExistsAlready(const std::string &probeName)
 {
   for( std::vector<mitk::USProbe::Pointer>::iterator it = m_ConfigProbes.begin();
        it != m_ConfigProbes.end(); it++ )
   {
     if( probeName.compare((*it)->GetName()) == 0)
       return (*it);
   }
   return nullptr; //no matching probe was found so nullptr is returned
 }
 
-void QmitkUSNewVideoDeviceWidget::CollectUltrasoundVideoDeviceConfigInformation(mitk::USDeviceReaderXML::USVideoDeviceConfigData &config)
+void QmitkUSNewVideoDeviceWidget::CollectUltrasoundVideoDeviceConfigInformation(mitk::USDeviceReaderXML::USDeviceConfigData &config)
 {
   config.fileversion = 1.0;
   config.deviceType = "video";
 
   //Fill info in metadata groupbox:
   config.deviceName = m_Controls->m_DeviceName->text().toStdString();
   config.manufacturer = m_Controls->m_Manufacturer->text().toStdString();
   config.model = m_Controls->m_Model->text().toStdString();
   config.comment = m_Controls->m_Comment->text().toStdString();
 
   //Fill info about video source:
   config.sourceID = m_Controls->m_DeviceSelector->value();
   config.filepathVideoSource = m_Controls->m_FilePathSelector->text().toStdString();
 
   //Fill video options:
   config.useGreyscale = m_Controls->m_CheckGreyscale->isChecked();
 
   //Fill override options:
   config.useResolutionOverride = m_Controls->m_CheckResolutionOverride->isChecked();
   config.resolutionWidth = m_Controls->m_ResolutionWidth->value();
   config.resolutionHeight = m_Controls->m_ResolutionHeight->value();
 
   //Fill information about probes:
   config.probes = m_ConfigProbes;
 }
 
 void QmitkUSNewVideoDeviceWidget::EnableDisableSpacingAndCropping(bool enable)
 {
   m_Controls->m_XSpacingSpinBox->setEnabled(enable);
   m_Controls->m_YSpacingSpinBox->setEnabled(enable);
   m_Controls->m_XSpacingLabel->setEnabled(enable);
   m_Controls->m_YSpacingLabel->setEnabled(enable);
 
   m_Controls->m_CroppingTopSpinBox->setEnabled(enable);
   m_Controls->m_CroppingRightSpinBox->setEnabled(enable);
   m_Controls->m_CroppingBottomSpinBox->setEnabled(enable);
   m_Controls->m_CroppingLeftSpinBox->setEnabled(enable);
   m_Controls->m_CroppingTopLabel->setEnabled(enable);
   m_Controls->m_CroppingBottomLabel->setEnabled(enable);
   m_Controls->m_CroppingLeftLabel->setEnabled(enable);
   m_Controls->m_CroppingRightLabel->setEnabled(enable);
 }
diff --git a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.h b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.h
index 00bfdaf60c..e1c18df4f2 100644
--- a/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.h
+++ b/Modules/USUI/Qmitk/QmitkUSNewVideoDeviceWidget.h
@@ -1,169 +1,169 @@
 /*===================================================================
 
 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 _QmitkUSNewVideoDeviceWidget_H_INCLUDED
 #define _QmitkUSNewVideoDeviceWidget_H_INCLUDED
 
 #include "MitkUSUIExports.h"
 #include "ui_QmitkUSNewVideoDeviceWidgetControls.h"
 #include "mitkUSVideoDevice.h"
 #include "mitkUSIGTLDevice.h"
 #include "mitkUSDeviceReaderXML.h"
 
 //QT headers
 #include <QWidget>
 #include <QListWidgetItem>
 
 //mitk header
 
 /**
 * @brief This Widget enables the USer to create and connect Video Devices.
 *
 * @ingroup USUI
 */
 class MITKUSUI_EXPORT QmitkUSNewVideoDeviceWidget :public QWidget
 {
   //this is needed for all Qt objects that should have a MOC object (everything that derives from QObject)
   Q_OBJECT
 
 public:
 
   static const std::string VIEW_ID;
 
   QmitkUSNewVideoDeviceWidget(QWidget* p = nullptr, Qt::WindowFlags f1 = nullptr);
   ~QmitkUSNewVideoDeviceWidget() override;
 
   /* @brief This method is part of the widget an needs not to be called seperately. */
   virtual void CreateQtPartControl(QWidget *parent);
   /* @brief This method is part of the widget an needs not to be called seperately. (Creation of the connections of main and control widget.)*/
   virtual void CreateConnections();
 
 signals:
 
   void Finished();
 
   public slots:
 
   /*
   \brief Activates the widget and displays the given device's Data to edit.
   */
   void EditDevice(mitk::USDevice::Pointer device);
 
   /*
   \brief Activates the widget with fields empty.
   */
   void CreateNewDevice();
 
   protected slots:
 
   /*
   \brief Called, when the the user clicks the "Done" button (Labeled either "Add Device" or "Edit Device", depending on the situation.
   */
   void OnClickedDone();
 
   void OnClickedFinishedEditing();
 
   /*
   \brief Called, when the button "Cancel" was clicked
   */
   void OnClickedCancel();
 
   /*
   \brief Called, when the Use selects one of the Radiobuttons
   */
   void OnDeviceTypeSelection();
 
   void OnOpenFileButtonClicked();
 
   void OnClickedRemoveProbe();
 
   void OnClickedRemoveDepth();
 
   void OnClickedAddDepths();
 
   void OnProbeChanged(const QString & probename);
 
   void OnDepthChanged(int depth, mitk::USProbe::Pointer probe);
 
   void OnDepthChanged(const QString &depth);
 
   void OnSaveButtonClicked();
 
   void OnLoadConfigurationButtonClicked();
 
   void OnAddNewProbeClicked();
 
   void OnXSpacingSpinBoxChanged(double value);
 
   void OnYSpacingSpinBoxChanged(double value);
 
   void OnCroppingTopSpinBoxChanged(int value);
 
   void OnCroppingRightSpinBoxChanged(int value);
 
   void OnCroppingBottomSpinBoxChanged(int value);
 
   void OnCroppingLeftSpinBoxChanged(int value);
 
 protected:
 
   Ui::QmitkUSNewVideoDeviceWidgetControls* m_Controls; ///< member holding the UI elements of this widget
 
   /*
   \brief Constructs a ListItem from the given device for display in the list of active devices
   */
   QListWidgetItem* ConstructItemFromDevice(mitk::USDevice::Pointer device);
 
   void ChangeUIEditingUSVideoDevice();
 
   void CleanUpAfterEditingOfDevice();
 
   void CleanUpAfterCreatingNewDevice();
 
   void AddProbesToDevice(mitk::USDevice::Pointer device);
 
   mitk::USProbe::Pointer CheckIfProbeExistsAlready(const std::string &probe);
 
-  void CollectUltrasoundVideoDeviceConfigInformation(mitk::USDeviceReaderXML::USVideoDeviceConfigData &config);
+  void CollectUltrasoundVideoDeviceConfigInformation(mitk::USDeviceReaderXML::USDeviceConfigData &config);
 
   /**
   * \brief Enables or disables the GUI elements of the spacing and cropping options.
   * \param enable If true: the GUI elements are enabled. If false: elements are disabled.
   */
   void EnableDisableSpacingAndCropping(bool enable);
 
   /*
   \brief Displays whether this widget is active or not. It gets activated by either sending a Signal to
   *  the "CreateNewDevice" Slot or to the "EditDevice" Slot. If the user finishes editing the device, a
   * "EditingComplete" Signal is sent, and the widget is set to inactive again. Clicking Cancel also
   *  deactivates it.
   */
   bool m_Active;
 
   /**
   *   \brief This is the device to edit. It is either the device transmitted in the "EditDevice" signal, or a new one
   *  if the "CreateNewDevice slot was called. As device type: either mitkUSVideoDevice or mitkUSIGTLDevice
   */
   mitk::USDevice::Pointer m_TargetDevice;
 
   /**
   *   \brief The config probes are used to have a possibility to configure ultrasound probes without having an existing
   *   created USVideoDevice yet.
   */
   std::vector<mitk::USProbe::Pointer> m_ConfigProbes;
 };
 
 #endif // _QmitkUSNewVideoDeviceWidget_H_INCLUDED