diff --git a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsStatisticView.cpp b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsStatisticView.cpp
index 6271d5a532..3f7296a1ff 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsStatisticView.cpp
+++ b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsStatisticView.cpp
@@ -1,330 +1,330 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkRadiomicsStatisticView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 #include <QApplication>
 #include <QClipboard>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include <QmitkDataStorageComboBox.h>
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general)
 #include "mitkLabelSetImage.h"
 #include <mitkAbstractGlobalImageFeature.h>
 #include <mitkGIFCooccurenceMatrix.h>
 #include <mitkGIFCooccurenceMatrix2.h>
 #include <mitkGIFGreyLevelRunLength.h>
 #include <mitkGIFFirstOrderStatistics.h>
 #include <mitkGIFFirstOrderHistogramStatistics.h>
 #include <mitkGIFFirstOrderNumericStatistics.h>
 #include <mitkGIFVolumetricStatistics.h>
 #include <mitkGIFVolumetricDensityStatistics.h>
 #include <mitkGIFGreyLevelSizeZone.h>
 #include <mitkGIFGreyLevelDistanceZone.h>
 #include <mitkGIFImageDescriptionFeatures.h>
 #include <mitkGIFLocalIntensity.h>
 #include <mitkGIFCurvatureStatistic.h>
 #include <mitkGIFIntensityVolumeHistogramFeatures.h>
 #include <mitkGIFNeighbourhoodGreyToneDifferenceFeatures.h>
 #include <mitkGIFNeighbouringGreyLevelDependenceFeatures.h>
 
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateDimension.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkProperties.h>
 #include <mitkLevelWindowProperty.h>
 #include <mitkImageStatisticsHolder.h>
 
 // Includes for image casting between ITK and MITK
 #include <mitkImageCast.h>
 #include <mitkITKImageImport.h>
 
 // Specific GUI Includes
 #include "QmitkGIFConfigurationPanel.h"
 
 QmitkRadiomicsStatistic::QmitkRadiomicsStatistic()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
 }
 
 QmitkRadiomicsStatistic::~QmitkRadiomicsStatistic()
 {
   //berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   //if(s)
   //  s->RemoveSelectionListener(m_SelectionListener);
 }
 
 void QmitkRadiomicsStatistic::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == nullptr)
   {
     mitk::GIFImageDescriptionFeatures::Pointer ipCalculator = mitk::GIFImageDescriptionFeatures::New(); // Commented 2, Tested
     mitk::GIFFirstOrderStatistics::Pointer firstOrderCalculator = mitk::GIFFirstOrderStatistics::New(); //Commented 2
     mitk::GIFFirstOrderHistogramStatistics::Pointer firstOrderHistoCalculator = mitk::GIFFirstOrderHistogramStatistics::New(); // Commented 2, Tested
     mitk::GIFFirstOrderNumericStatistics::Pointer firstOrderNumericCalculator = mitk::GIFFirstOrderNumericStatistics::New(); // Commented 2, Tested
     mitk::GIFVolumetricStatistics::Pointer volCalculator = mitk::GIFVolumetricStatistics::New();   // Commented 2, Tested
     mitk::GIFVolumetricDensityStatistics::Pointer voldenCalculator = mitk::GIFVolumetricDensityStatistics::New(); // Commented 2, Tested
     mitk::GIFCooccurenceMatrix::Pointer coocCalculator = mitk::GIFCooccurenceMatrix::New(); // Commented 2, Will not be tested
     mitk::GIFCooccurenceMatrix2::Pointer cooc2Calculator = mitk::GIFCooccurenceMatrix2::New(); //Commented 2
     mitk::GIFNeighbouringGreyLevelDependenceFeature::Pointer ngldCalculator = mitk::GIFNeighbouringGreyLevelDependenceFeature::New(); //Commented 2, Tested
     mitk::GIFGreyLevelRunLength::Pointer rlCalculator = mitk::GIFGreyLevelRunLength::New(); // Commented 2
     mitk::GIFGreyLevelSizeZone::Pointer glszCalculator = mitk::GIFGreyLevelSizeZone::New(); // Commented 2, Tested
     mitk::GIFGreyLevelDistanceZone::Pointer gldzCalculator = mitk::GIFGreyLevelDistanceZone::New(); //Commented 2, Tested
     mitk::GIFLocalIntensity::Pointer lociCalculator = mitk::GIFLocalIntensity::New(); //Commented 2, Tested
     mitk::GIFIntensityVolumeHistogramFeatures::Pointer ivohCalculator = mitk::GIFIntensityVolumeHistogramFeatures::New(); // Commented 2
     mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::Pointer ngtdCalculator = mitk::GIFNeighbourhoodGreyToneDifferenceFeatures::New(); //Commented 2, Tested
     mitk::GIFCurvatureStatistic::Pointer curvCalculator = mitk::GIFCurvatureStatistic::New(); //Commented 2, Tested
 
     std::vector<mitk::AbstractGlobalImageFeature::Pointer> features;
     features.push_back(volCalculator.GetPointer());
     features.push_back(voldenCalculator.GetPointer());
     features.push_back(curvCalculator.GetPointer());
     features.push_back(firstOrderCalculator.GetPointer());
     features.push_back(firstOrderNumericCalculator.GetPointer());
     features.push_back(firstOrderHistoCalculator.GetPointer());
     features.push_back(ivohCalculator.GetPointer());
     features.push_back(lociCalculator.GetPointer());
     features.push_back(cooc2Calculator.GetPointer());
     features.push_back(ngldCalculator.GetPointer());
     features.push_back(rlCalculator.GetPointer());
     features.push_back(glszCalculator.GetPointer());
     features.push_back(gldzCalculator.GetPointer());
     features.push_back(ipCalculator.GetPointer());
     features.push_back(ngtdCalculator.GetPointer());
 
     m_Controls = new Ui::QmitkRadiomicsStatisticViewControls;
     m_Controls->setupUi(parent);
 
     for (auto cFeature : features)
     {
       mitkUI::GIFConfigurationPanel* gifPanel = new mitkUI::GIFConfigurationPanel(parent, cFeature);
       m_Controls->m_FeaturesGroup->layout()->addWidget(gifPanel);
     }
 
     QLabel * label1 = new QLabel("Image: ");
     QLabel * label2 = new QLabel("Mask: ");
     QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
     QmitkDataStorageComboBox * cb_maskimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
     m_Controls->m_InputImageGroup->layout()->addWidget(label1);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_inputimage);
     m_Controls->m_InputImageGroup->layout()->addWidget(label2);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_maskimage);
 
     this->CreateConnections();
 
     //setup predictaes for combobox
 
     mitk::NodePredicateDimension::Pointer dimensionPredicate = mitk::NodePredicateDimension::New(3);
     mitk::NodePredicateDataType::Pointer imagePredicate = mitk::NodePredicateDataType::New("Image");
 
 
   }
 }
 
 void QmitkRadiomicsStatistic::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->buttonExecute), SIGNAL(clicked() ), this, SLOT(executeButtonPressed() ) );
     connect((QObject*)(m_Controls->buttonExecuteAndAppend), SIGNAL(clicked()), this, SLOT(executeAndAppendButtonPressed()));
     connect((QObject*)(m_Controls->buttonTableToClipboard), SIGNAL(clicked()), this, SLOT(copyToClipboardButtonPressed()));
   }
 }
 
 std::map < std::string, us::Any> QmitkRadiomicsStatistic::GenerateParameters()
 {
   std::map < std::string, us::Any> parameter;
 
   if (m_Controls->m_SetMinimumIntensity->isChecked())
   {
     parameter["minimum-intensity"] = us::Any(float(m_Controls->m_ParamMinimumIntensity->value()));
   }
   if (m_Controls->m_SetMaximumIntensity->isChecked())
   {
     parameter["maximum-intensity"] = us::Any(float(m_Controls->m_ParamMaximumIntensity->value()));
   }
   if (m_Controls->m_SetNumberOfBins->isChecked())
   {
     parameter["bins"] = us::Any(m_Controls->m_ParamBins->value());
   }
   if (m_Controls->m_SetBinSize->isChecked())
   {
     parameter["binsize"] = us::Any(float(m_Controls->m_ParamBinSize->value()));
   }
   if (m_Controls->m_SetIgnoreBinSize->isChecked())
   {
     parameter["ignore-mask-for-histogram"] = us::Any(m_Controls->m_ParamIgnoreMask->isChecked());
   }
   if (m_Controls->m_SetEncodeParameterInName->isChecked())
   {
     parameter["encode-parameter-in-name"] = us::Any(m_Controls->m_ParamEncodeName->isChecked());
   }
   if (m_Controls->m_SetDirectionParameter->isChecked())
   {
     parameter["direction"] = us::Any(m_Controls->m_ParamDirection->value());
   }
   if (m_Controls->m_SetSliceWiseParameter->isChecked())
   {
     parameter["slice-wise"] = us::Any(m_Controls->m_ParamSliceWise->value());
   }
 
   return parameter;
 }
 
 void QmitkRadiomicsStatistic::executeButtonPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   QmitkDataStorageComboBox * cb_maskimage = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(3)->widget());
   mitk::BaseData* baseDataRawImage = NULL;
   mitk::BaseData* baseDataMaskImage = NULL;
 
   mitk::Image::Pointer raw_image;
   mitk::Image::Pointer mask_image;
   QString imageName;
   QString maskName;
 
   if ((cb_image->GetSelectedNode().IsNotNull() ) && (cb_maskimage->GetSelectedNode().IsNotNull()))
   {
     imageName = cb_image->GetSelectedNode()->GetName().c_str();
     maskName = cb_maskimage->GetSelectedNode()->GetName().c_str();
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     baseDataMaskImage = (cb_maskimage->GetSelectedNode()->GetData());
   }
   if ((baseDataRawImage != NULL) && (baseDataMaskImage != NULL))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
     mask_image = dynamic_cast<mitk::Image *>(baseDataMaskImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull() || mask_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   mitk::AbstractGlobalImageFeature::FeatureListType stats;
   for (int i = 0; i < m_Controls->m_FeaturesGroup->layout()->count(); ++i)
   {
     auto parameter = this->GenerateParameters();
 
     mitkUI::GIFConfigurationPanel* gifPanel = dynamic_cast<mitkUI::GIFConfigurationPanel*>(m_Controls->m_FeaturesGroup->layout()->itemAt(i)->widget());
     if (gifPanel == NULL)
       continue;
     gifPanel->CalculateFeaturesUsingParameters(raw_image, mask_image, parameter, stats);
   }
 
   m_Controls->m_ResultTable->setRowCount(stats.size());
 
   for (std::size_t i = 0; i < stats.size(); ++i)
   {
     m_Controls->m_ResultTable->setItem(i, 0, new QTableWidgetItem(imageName));
     m_Controls->m_ResultTable->setItem(i, 1, new QTableWidgetItem(maskName));
     m_Controls->m_ResultTable->setItem(i, 2, new QTableWidgetItem(stats[i].first.c_str()));
     m_Controls->m_ResultTable->setItem(i, 3, new QTableWidgetItem(QString::number(stats[i].second)));
   }
   }
 
 void QmitkRadiomicsStatistic::executeAndAppendButtonPressed()
 {
   std::vector<QTableWidgetItem *> elementImage;
   std::vector<QTableWidgetItem *> elementMask;
   std::vector<QTableWidgetItem *> elementText;
   std::vector<QTableWidgetItem *> elementValue;
 
-  for (std::size_t i = 0; i < m_Controls->m_ResultTable->rowCount(); ++i)
+  for (int i = 0; i < m_Controls->m_ResultTable->rowCount(); ++i)
   {
     auto itemImage = m_Controls->m_ResultTable->item(i, 0)->clone();
     auto itemMask = m_Controls->m_ResultTable->item(i, 1)->clone();
     auto itemText = m_Controls->m_ResultTable->item(i, 2)->clone();
     auto itemValue = m_Controls->m_ResultTable->item(i, 3)->clone();
     elementImage.push_back(itemImage);
     elementMask.push_back(itemMask);
     elementText.push_back(itemText);
     elementValue.push_back(itemValue);
   }
 
   executeButtonPressed();
 
   std::size_t oldSize = m_Controls->m_ResultTable->rowCount();
   m_Controls->m_ResultTable->setRowCount(oldSize + elementText.size());
 
   for (std::size_t i = 0; i < elementText.size(); ++i)
   {
     m_Controls->m_ResultTable->setItem(i + oldSize, 0, elementImage[i]);
     m_Controls->m_ResultTable->setItem(i + oldSize, 1, elementMask[i]);
     m_Controls->m_ResultTable->setItem(i+oldSize, 2, elementText[i]);
     m_Controls->m_ResultTable->setItem(i+oldSize, 3, elementValue[i]);
   }
 }
 
 void QmitkRadiomicsStatistic::copyToClipboardButtonPressed()
 {
   QString selectedText;
-  for (std::size_t i = 0; i < m_Controls->m_ResultTable->rowCount(); ++i)
+  for (int i = 0; i < m_Controls->m_ResultTable->rowCount(); ++i)
   {
     auto itemImage = m_Controls->m_ResultTable->item(i, 0);
     auto itemMask = m_Controls->m_ResultTable->item(i, 1);
     auto itemText = m_Controls->m_ResultTable->item(i, 2);
     auto itemValue = m_Controls->m_ResultTable->item(i, 3);
     selectedText.append(itemImage->text());
     selectedText.append(";");
     selectedText.append(itemMask->text());
     selectedText.append(";");
     selectedText.append(itemText->text());
     selectedText.append(";");
     selectedText.append(itemValue->text());
     selectedText.append("\n");
   }
   QApplication::clipboard()->setText(selectedText);
 }
 
 void QmitkRadiomicsStatistic::SetFocus()
 {
 }
 
 //datamanager selection changed
 void QmitkRadiomicsStatistic::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   //any nodes there?
   if (!nodes.empty())
   {
 
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsTransformationView.cpp b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsTransformationView.cpp
index 1564a26e04..88ad07f15f 100644
--- a/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsTransformationView.cpp
+++ b/Plugins/org.mitk.gui.qt.radiomics/src/internal/QmitkRadiomicsTransformationView.cpp
@@ -1,380 +1,379 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "QmitkRadiomicsTransformationView.h"
 
 // QT includes (GUI)
 #include <qlabel.h>
 #include <qspinbox.h>
 #include <qpushbutton.h>
 #include <qcheckbox.h>
 #include <qgroupbox.h>
 #include <qradiobutton.h>
 #include <qmessagebox.h>
 
 // Berry includes (selection service)
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // MITK includes (GUI)
 #include <QmitkDataStorageComboBox.h>
 #include "QmitkDataNodeSelectionProvider.h"
 #include "mitkDataNodeObject.h"
 
 // MITK includes (general
 #include <mitkNodePredicateDataType.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkProperties.h>
 #include <mitkTransformationOperation.h>
 #include <mitkLabelSetImage.h>
 
 // Specific GUI Includes
 #include "QmitkGIFConfigurationPanel.h"
 
 QmitkRadiomicsTransformation::QmitkRadiomicsTransformation()
 : QmitkAbstractView(),
   m_Controls(nullptr)
 {
 }
 
 QmitkRadiomicsTransformation::~QmitkRadiomicsTransformation()
 {
   //berry::ISelectionService* s = GetSite()->GetWorkbenchWindow()->GetSelectionService();
   //if(s)
   //  s->RemoveSelectionListener(m_SelectionListener);
 }
 
 void QmitkRadiomicsTransformation::CreateQtPartControl(QWidget *parent)
 {
   if (m_Controls == nullptr)
   {
     m_Controls = new Ui::QmitkRadiomicsTransformationViewControls;
     m_Controls->setupUi(parent);
 
     QLabel * label1 = new QLabel("Image: ");
-    QLabel * label2 = new QLabel("Mask: ");
     QmitkDataStorageComboBox * cb_inputimage = new QmitkDataStorageComboBox(this->GetDataStorage(), mitk::TNodePredicateDataType<mitk::Image>::New());
     m_Controls->m_InputImageGroup->layout()->addWidget(label1);
     m_Controls->m_InputImageGroup->layout()->addWidget(cb_inputimage);
 
     this->CreateConnections();
   }
 }
 
 void QmitkRadiomicsTransformation::CreateConnections()
 {
   if ( m_Controls )
   {
     connect( (QObject*)(m_Controls->buttonExecuteMultiresolution), SIGNAL(clicked() ), this, SLOT(executeButtonMultiResolutionPressed() ) );
     connect((QObject*)(m_Controls->m_WaveletExecuteButton), SIGNAL(clicked()), this, SLOT(executeButtonWaveletPressed()));
     connect((QObject*)(m_Controls->m_ExecuteLOG), SIGNAL(clicked()), this, SLOT(executeButtonLoGPressed()));
     connect((QObject*)(m_Controls->buttonResampleImage), SIGNAL(clicked()), this, SLOT(executeButtonResamplingPressed()));
 
   }
 }
 
 void QmitkRadiomicsTransformation::executeButtonMultiResolutionPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   mitk::BaseData* baseDataRawImage = NULL;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull() ) )
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
   if ((baseDataRawImage != NULL))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   unsigned int numberOfLevels = m_Controls->m_NumberOfLevels->value();
   bool resultAsDouble = m_Controls->m_resultAsDouble->isChecked();
 
   auto results = mitk::TransformationOperation::MultiResolution(raw_image, numberOfLevels, resultAsDouble);
   unsigned int level = 1;
   for (auto image : results)
   {
     mitk::DataNode::Pointer result = mitk::DataNode::New();
     result->SetProperty("name", mitk::StringProperty::New(nodeName+"::MultiRes::Level-"+us::Any(numberOfLevels-level).ToString()));
     result->SetData(image);
     GetDataStorage()->Add(result, cb_image->GetSelectedNode());
     ++level;
   }
 }
 
 void QmitkRadiomicsTransformation::executeButtonWaveletPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   mitk::BaseData* baseDataRawImage = NULL;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
   if ((baseDataRawImage != NULL))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   unsigned int numberOfLevels = m_Controls->m_WaveletNumberOfLevels->value();
   unsigned int numberOfBands = m_Controls->m_WaveletNumberOfBands->value();
   mitk::BorderCondition condition = mitk::BorderCondition::Constant;
   mitk::WaveletType waveletType = mitk::WaveletType::Held;
 
   std::string waveletStr = m_Controls->m_WaveletWavelet->currentText().toStdString();
   if (waveletStr == "Shannon")
   {
     waveletType = mitk::WaveletType::Shannon;
   }
   if (waveletStr == "Simoncelli")
   {
     waveletType = mitk::WaveletType::Simoncelli;
   }
   if (waveletStr == "Vow")
   {
     waveletType = mitk::WaveletType::Vow;
   }
   if (waveletStr == "Held")
   {
     waveletType = mitk::WaveletType::Held;
   }
 
   std::string conditionStr = m_Controls->m_WaveletBorderCondition->currentText().toStdString();
   if (conditionStr == "Constant")
   {
     condition = mitk::BorderCondition::Constant;
   }
   if (conditionStr == "Periodic")
   {
     condition = mitk::BorderCondition::Periodic;
   }
   if (conditionStr == "Zero Flux Neumann")
   {
     condition = mitk::BorderCondition::ZeroFluxNeumann;
   }
 
   auto results = mitk::TransformationOperation::WaveletForward(raw_image, numberOfLevels, numberOfBands, condition, waveletType);
   unsigned int level = 0;
   for (auto image : results)
   {
     mitk::DataNode::Pointer result = mitk::DataNode::New();
     result->SetProperty("name", mitk::StringProperty::New(nodeName + "::Wavelet::"+waveletStr+"-"+conditionStr+"::Level-" + us::Any(level).ToString()));
     result->SetData(image);
     GetDataStorage()->Add(result, cb_image->GetSelectedNode());
     ++level;
   }
 
 }
 
 
 void QmitkRadiomicsTransformation::executeButtonLoGPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   mitk::BaseData* baseDataRawImage = NULL;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
   if ((baseDataRawImage != NULL))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   double sigma = m_Controls->m_LoGSigma->value();
   bool resultAsDouble = m_Controls->m_LogResultAsDouble->isChecked();
 
   auto results = mitk::TransformationOperation::LaplacianOfGaussian(raw_image, sigma, resultAsDouble);
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty("name", mitk::StringProperty::New(nodeName + "::LoG::Sigma-" + us::Any(sigma).ToString()));
   result->SetData(results);
   GetDataStorage()->Add(result, cb_image->GetSelectedNode());
 }
 
 void QmitkRadiomicsTransformation::executeButtonResamplingPressed()
 {
   QmitkDataStorageComboBox * cb_image = dynamic_cast<QmitkDataStorageComboBox *>(m_Controls->m_InputImageGroup->layout()->itemAt(1)->widget());
   mitk::BaseData* baseDataRawImage = NULL;
 
   mitk::Image::Pointer raw_image;
   std::string nodeName;
   if ((cb_image->GetSelectedNode().IsNotNull()))
   {
     baseDataRawImage = (cb_image->GetSelectedNode()->GetData());
     nodeName = cb_image->GetSelectedNode()->GetName();
   }
   if ((baseDataRawImage != NULL))
   {
     raw_image = dynamic_cast<mitk::Image *>(baseDataRawImage);
   }
   else {
     QMessageBox msgBox;
     msgBox.setText("Please specify the images that shlould be used.");
     msgBox.exec();
     return;
   }
   if (raw_image.IsNull())
   {
     QMessageBox msgBox;
     msgBox.setText("Error during processing the specified images.");
     msgBox.exec();
     return;
   }
 
   mitk::ImageMappingInterpolator::Type interpolatorType;
   switch (m_Controls->comboInterpolationMode->currentIndex())
   {
   case 0:
     interpolatorType = mitk::ImageMappingInterpolator::Linear;
     break;
 
   case 1:
     interpolatorType = mitk::ImageMappingInterpolator::BSpline_3;
     break;
 
   case 2:
     interpolatorType = mitk::ImageMappingInterpolator::NearestNeighbor;
     break;
 
   case 3:
     interpolatorType = mitk::ImageMappingInterpolator::WSinc_Hamming;
     break;
 
   case 4:
     interpolatorType = mitk::ImageMappingInterpolator::WSinc_Welch;
     break;
 
   default:
     interpolatorType = mitk::ImageMappingInterpolator::Linear;
   }
 
   mitk::GridInterpolationPositionType gridPosition;
   switch (m_Controls->comboAxisAlignment->currentIndex())
   {
   case 0:
     gridPosition = mitk::GridInterpolationPositionType::OriginAligned;
     break;
 
   case 1:
     gridPosition = mitk::GridInterpolationPositionType::CenterAligned;
     break;
 
   case 2:
     gridPosition = mitk::GridInterpolationPositionType::SameSize;
     break;
 
   default:
     gridPosition = mitk::GridInterpolationPositionType::OriginAligned;
   }
 
   bool resultAsDouble = m_Controls->checkResamplingOutputAsDouble->isChecked();
   bool roundResult = m_Controls->checkResamplingRoundOutput->isChecked();
 
   mitk::Vector3D spacing;
   spacing.Fill(-1);
   if (m_Controls->checkResampleX->isChecked()) {
     spacing[0] = m_Controls->doubleSpinDimensionX->value();
   }
   if (m_Controls->checkResampleY->isChecked()) {
     spacing[1] = m_Controls->doubleSpinDimensionY->value();
   }
   if (m_Controls->checkResampleZ->isChecked()) {
     spacing[2] = m_Controls->doubleSpinDimensionZ->value();
   }
 
 
   mitk::Image::Pointer results;
   if (m_Controls->checkResampleAsMask->isChecked()) {
     results = mitk::TransformationOperation::ResampleMask(raw_image, spacing, interpolatorType, gridPosition);
     mitk::LabelSetImage::Pointer oldLabelImage = dynamic_cast<mitk::LabelSetImage *> (raw_image.GetPointer());
     if (oldLabelImage.IsNotNull())
     {
       mitk::LabelSetImage::Pointer labelResult = mitk::LabelSetImage::New();
       labelResult->InitializeByLabeledImage(results);
       labelResult->AddLabelSetToLayer(labelResult->GetActiveLayer(), oldLabelImage->GetLabelSet());
       results = dynamic_cast<mitk::Image*>(labelResult.GetPointer());
     }
   }
   else {
     results = mitk::TransformationOperation::ResampleImage(raw_image, spacing, interpolatorType, gridPosition, resultAsDouble, roundResult);
   }
   mitk::DataNode::Pointer result = mitk::DataNode::New();
   result->SetProperty("name", mitk::StringProperty::New(nodeName + "::Resampled" ));
   result->SetData(results);
   GetDataStorage()->Add(result, cb_image->GetSelectedNode());
 }
 
 void QmitkRadiomicsTransformation::SetFocus()
 {
 }
 
 //datamanager selection changed
 void QmitkRadiomicsTransformation::OnSelectionChanged(berry::IWorkbenchPart::Pointer, const QList<mitk::DataNode::Pointer>& nodes)
 {
   //any nodes there?
   if (!nodes.empty())
   {
 
   }
 }