QmitkUSNewVideoDeviceWidget.cpp

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
//#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() {}
 
 
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)));
  }
}
 
 
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();
}
 
 
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;
}
 
 
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::USDeviceConfigData config;
  this->CollectUltrasoundDeviceConfigInformation(config);
 
  if (!deviceWriter.WriteUltrasoundDeviceConfiguration(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::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::CollectUltrasoundDeviceConfigInformation(mitk::USDeviceReaderXML::USDeviceConfigData &config)
{
  config.fileversion = 1.0;
  if (m_Controls->m_RadioDeviceSource->isChecked() || m_Controls->m_RadioFileSource->isChecked())
  {
    //Fill info about video source:
    config.deviceType = "video";
    config.sourceID = m_Controls->m_DeviceSelector->value();
    config.filepathVideoSource = m_Controls->m_FilePathSelector->text().toStdString();
  }
  else
  {
    config.deviceType = "oigtl";
    if (m_Controls->m_RadioOIGTLServerSource->isChecked())
    {
      config.server = true;
      config.host = m_Controls->m_OIGTLServerHost->text().toStdString();
      config.port = m_Controls->m_OIGTLServerPort->value();
    }
    else
    {
      config.server = false;
      config.host = m_Controls->m_OIGTLClientHost->text().toStdString();
      config.port = m_Controls->m_OIGTLClientPort->value();
    }
  }
 
  //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 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);
}