diff --git a/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingSO2.h b/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingSO2.h
index 9180e8968a..85bac2c75e 100644
--- a/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingSO2.h
+++ b/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingSO2.h
@@ -1,100 +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 MITKPHOTOACOUSTICSPECTRALUNMIXINGSO2_H
 #define MITKPHOTOACOUSTICSPECTRALUNMIXINGSO2_H
 
 #include "mitkImageToImageFilter.h"
 #include <MitkPhotoacousticsLibExports.h>
 
 //Includes for smart pointer usage
 #include "mitkCommon.h"
 #include "itkLightObject.h"
 
 
 namespace mitk {
   namespace pa {
     /**
     * \brief derives out of two identical sized MITK images the oxygen saturation and return one MITK image as result. Furthermore
     * it is possible to set settings that the result shows just SO2 values above a threshold, or above a input value for Hb, HbO2 to
     * get just a oxygen saturation image of interessting structures.
     *
     * Input:
     * The input has to be two 3D MITK images. The order of the inputs matter! The first input has to be the Hb image the second input
     * has to be the HbO2 image. The settings are integer values. The SO2 threshold therefore is percentage value.
     *
     * Output:
     * The output will be one MITK image. Where one can see the oxygen saturation of all pixels above the set threholds. If a pixel is
     * below a threhold or NAN then the value will be set to zero.
     */
     class MITKPHOTOACOUSTICSLIB_EXPORT SpectralUnmixingSO2 : public mitk::ImageToImageFilter
     {
     public:
       mitkClassMacro(SpectralUnmixingSO2, mitk::ImageToImageFilter);
       itkFactorylessNewMacro(Self);
 
       /**
       * \brief AddSO2Settings takes integers and writes them at the end of the m_SO2Settings vector.
-      * @param value has to be a integer
+      * @param value of the Setting
       */
-      virtual void AddSO2Settings(float value);
+      virtual void AddSO2Settings(int value);
 
-      /*
+      /**
       * \brief Verbose gives more information to the console. Default value is false.
       * @param m_Verbose is the boolian to activate the MITK_INFO logged to the console
       */
       virtual void Verbose(bool verbose);
 
     protected:
       /**
       * \brief Constructor sets number of input images to two and number of output images to one, respectively.
       */
       SpectralUnmixingSO2();
       virtual ~SpectralUnmixingSO2();
 
       std::vector<int> m_SO2Settings;
       bool m_Verbose = false;
 
     private:
-      /*
+      /**
       * \brief Inherit from the "ImageToImageFilter" Superclass. Herain it calls InitializeOutputs and the CheckPreConditions
       * methods and enables pixelwise access to the inputs to calculate the oxygen saturation via the "calculate SO2" method.
       */
       virtual void GenerateData() override;
 
-      /*
+      /**
       * \brief Initialized output images with the same size like the input image. The pixel type is set to float.
       */
       virtual void InitializeOutputs();
 
-      /*
+      /**
       * \brief Checks if the dimensions of the input images are equal.
       * @throws if tey are not
       */
       virtual void CheckPreConditions(mitk::Image::Pointer inputHbO2, mitk::Image::Pointer inputHb);
 
-      /*
-      * \brief calculates HbO2 / (Hb + HbO2) and afterwards checks if the result and inputs are above threshold values of the
-      * settings. If they are not the method returns zero otherwise it returns the calculated result.
+      /**
+      * \brief calculates HbO2 / (Hb + HbO2) and afterwards checks if the result is significant (SO2ValueNotSiginificant method).
+      * If not the method returns zero otherwise it returns the calculated result.
       * @param pixelHb is the pixel value of the Hb input.
       * @param pixelHb is the pixel value of the Hb input.
       * @warn if the HbO2 value is NAN (in patricular if Hb == -HbO2), but result will be set to zero
       */
-      float calculateSO2(float pixelHb, float pixelHbO2);
+      float CalculateSO2(float pixelHb, float pixelHbO2);
+
+      /**
+      * \brief return true if SO2 result is not significant by checking if the input values are above the threshold of the settings
+      */
+      bool SO2ValueNotSiginificant(float Hb, float HbO2, float result);
     };
   }
 }
 #endif // MITKPHOTOACOUSTICSPECTRALUNMIXINGSO2_
diff --git a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingSO2.cpp b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingSO2.cpp
index 47cfcb208d..6ce14c6efd 100644
--- a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingSO2.cpp
+++ b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingSO2.cpp
@@ -1,153 +1,155 @@
 /*===================================================================
 
 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 "mitkPASpectralUnmixingSO2.h"
 
 // ImageAccessor
 #include <mitkImageReadAccessor.h>
 #include <mitkImageWriteAccessor.h>
 
 
 mitk::pa::SpectralUnmixingSO2::SpectralUnmixingSO2()
 {
   this->SetNumberOfIndexedInputs(2);
   this->SetNumberOfIndexedOutputs(1);
   this->SetNthOutput(0, mitk::Image::New());
 }
 
 mitk::pa::SpectralUnmixingSO2::~SpectralUnmixingSO2()
 {
 
 }
 
 void mitk::pa::SpectralUnmixingSO2::Verbose(bool verbose)
 {
   m_Verbose = verbose;
 }
 
 void mitk::pa::SpectralUnmixingSO2::GenerateData()
 {
   MITK_INFO(m_Verbose) << "GENERATING DATA..";
 
   // Get input image
   mitk::Image::Pointer inputHbO2 = GetInput(0);
   mitk::Image::Pointer inputHb = GetInput(1);
 
   CheckPreConditions(inputHbO2, inputHb);
 
   unsigned int xDim = inputHbO2->GetDimensions()[0];
   unsigned int yDim = inputHbO2->GetDimensions()[1];
   unsigned int zDim = inputHbO2->GetDimensions()[2];
 
   InitializeOutputs();
 
   mitk::ImageReadAccessor readAccessHbO2(inputHbO2);
   mitk::ImageReadAccessor readAccessHb(inputHb);
 
   const float* inputDataArrayHbO2 = ((const float*)readAccessHbO2.GetData());
   const float* inputDataArrayHb = ((const float*)readAccessHb.GetData());
 
   auto output = GetOutput(0);
   mitk::ImageWriteAccessor writeOutput(output);
   float* writeBuffer = (float *)writeOutput.GetData();
 
   for (unsigned int x = 0; x < xDim; x++)
   {
     for (unsigned int y = 0; y < yDim; y++)
     {
       for (unsigned int z = 0;z < zDim; z++)
       {
         unsigned int pixelNumber = (xDim*yDim * z) + x * yDim + y;
         float pixelHb = inputDataArrayHb[pixelNumber];
         float pixelHbO2 = inputDataArrayHbO2[pixelNumber];
-        float resultSO2 = calculateSO2(pixelHb, pixelHbO2);
+        float resultSO2 = CalculateSO2(pixelHb, pixelHbO2);
         writeBuffer[(xDim*yDim * z) + x * yDim + y] = resultSO2;
       }
     }
   }
   MITK_INFO(m_Verbose) << "GENERATING DATA...[DONE]";
 }
 
 void mitk::pa::SpectralUnmixingSO2::CheckPreConditions(mitk::Image::Pointer inputHbO2, mitk::Image::Pointer inputHb)
 {
   unsigned int xDimHb = inputHb->GetDimensions()[0];
   unsigned int yDimHb = inputHb->GetDimensions()[1];
   unsigned int zDimHb = inputHb->GetDimensions()[2];
 
   unsigned int xDimHbO2 = inputHbO2->GetDimensions()[0];
   unsigned int yDimHbO2 = inputHbO2->GetDimensions()[1];
   unsigned int zDimHbO2 = inputHbO2->GetDimensions()[2];
 
   if (xDimHb != xDimHbO2 || yDimHb != yDimHbO2 || zDimHb != zDimHbO2)
     mitkThrow() << "DIMENTIONALITY ERROR!";
 
   MITK_INFO(m_Verbose) << "CHECK PRECONDITIONS ...[DONE]";
 }
 
 void mitk::pa::SpectralUnmixingSO2::InitializeOutputs()
 {
   unsigned int numberOfInputs = GetNumberOfIndexedInputs();
   unsigned int numberOfOutputs = GetNumberOfIndexedOutputs();
 
   mitk::PixelType pixelType = mitk::MakeScalarPixelType<float>();
   const int NUMBER_OF_SPATIAL_DIMENSIONS = 3;
   auto* dimensions = new unsigned int[NUMBER_OF_SPATIAL_DIMENSIONS];
   for(unsigned int dimIdx=0; dimIdx<NUMBER_OF_SPATIAL_DIMENSIONS; dimIdx++)
   {
     dimensions[dimIdx] = GetInput()->GetDimensions()[dimIdx];
   }
 
   for (unsigned int outputIdx = 0; outputIdx < numberOfOutputs; outputIdx++)
   {
     GetOutput(outputIdx)->Initialize(pixelType, NUMBER_OF_SPATIAL_DIMENSIONS, dimensions);
   }
 }
 
-float mitk::pa::SpectralUnmixingSO2::calculateSO2(float Hb, float HbO2)
+float mitk::pa::SpectralUnmixingSO2::CalculateSO2(float Hb, float HbO2)
 {
-  float MinHb = m_SO2Settings[0];
-  float MinHbO2 = m_SO2Settings[1];
-  float MinSum = m_SO2Settings[2];
-  float MinSO2 = m_SO2Settings[3];
   float result = HbO2 / (Hb + HbO2);
-  float zero = 0.0;
 
   if (result != result)
   {
     MITK_WARN(m_Verbose) << "SO2 VALUE NAN! WILL BE SET TO ZERO!";
-    return zero;
+    return 0;
   }
   else
   {
-    if (MinHb != 0 && MinHb > Hb)
-      return zero;
-    else if (MinHbO2 != 0 && MinHbO2 > HbO2)
-      return zero;
-    else if (MinSum != 0 && MinSum > Hb + HbO2)
-      return zero;
-    else if (MinSO2 != 0 && 100 * result > MinSO2)
-      return result;
-    else if (MinSO2 != 0 && result < MinSO2)
-      return zero;
-    else
-      return result;
+    if (SO2ValueNotSiginificant(Hb, HbO2, result))
+      return 0;
+    else return result;
   }
 }
 
-void mitk::pa::SpectralUnmixingSO2::AddSO2Settings(float value)
+void mitk::pa::SpectralUnmixingSO2::AddSO2Settings(int value)
 {
   m_SO2Settings.push_back(value);
 }
+
+bool mitk::pa::SpectralUnmixingSO2::SO2ValueNotSiginificant(float Hb, float HbO2, float result)
+{
+  std::vector<int> significant;
+  significant.push_back(HbO2);
+  significant.push_back(Hb);
+  significant.push_back(HbO2 + Hb);
+  significant.push_back(100*(result));
+
+  for (unsigned int i = 0; i < m_SO2Settings.size(); ++i)
+  {
+    if (m_SO2Settings[i] >= significant[i])
+      return true;
+  }
+  return false;
+}
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/src/internal/SpectralUnmixing.cpp b/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/src/internal/SpectralUnmixing.cpp
index 395f8fbafb..88c3e7fbf4 100644
--- a/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/src/internal/SpectralUnmixing.cpp
+++ b/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/src/internal/SpectralUnmixing.cpp
@@ -1,469 +1,469 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 // Blueberry
 #include <berryISelectionService.h>
 #include <berryIWorkbenchWindow.h>
 
 // Qmitk
 #include "SpectralUnmixing.h"
 
 // Qt
 #include <QMessageBox>
 
 // mitk image
 #include <mitkImage.h>
 
 // Include to perform Spectral Unmixing
 #include "mitkPASpectralUnmixingFilterBase.h"
 #include "mitkPALinearSpectralUnmixingFilter.h"
 #include "mitkPASpectralUnmixingSO2.h"
 #include "mitkPASpectralUnmixingFilterVigra.h"
 #include "mitkPASpectralUnmixingFilterLagrange.h"
 #include "mitkPASpectralUnmixingFilterSimplex.h"
 
 #include <numeric>
 #include <QtConcurrentRun>
 
 const std::string SpectralUnmixing::VIEW_ID = "org.mitk.views.spectralunmixing";
 
 void SpectralUnmixing::SetFocus()
 {
   m_Controls.buttonPerformImageProcessing->setFocus();
 }
 
 void SpectralUnmixing::CreateQtPartControl(QWidget *parent)
 {
   // create GUI widgets from the Qt Designer's .ui file
   m_Controls.setupUi(parent);
   connect(m_Controls.buttonPerformImageProcessing, &QPushButton::clicked, this, &SpectralUnmixing::DoImageProcessing);
   m_Controls.tableWeight->hide();
   m_Controls.tableSO2->hide();
   m_Controls.tableError->hide();
   connect((QObject*)(m_Controls.QComboBoxAlgorithm), SIGNAL(currentIndexChanged(int)), this, SLOT(EnableGUIWeight()));
   connect((QObject*)(m_Controls.checkBoxsO2), SIGNAL(clicked()), this, SLOT(EnableGUISO2()));
   connect((QObject*)(m_Controls.checkBoxError), SIGNAL(clicked()), this, SLOT(EnableGUIError()));
   this->connect(this, SIGNAL(finishSignal()), this, SLOT(storeOutputs()));
   this->connect(this, SIGNAL(crashSignal()), this, SLOT(crashInfo()));
 }
 
 void SpectralUnmixing::SwitchGUIControls(bool change)
 {
   m_Controls.inputtable->setEnabled(change);
   m_Controls.checkBoxOx->setEnabled(change);
   m_Controls.checkBoxDeOx->setEnabled(change);
   m_Controls.checkBoxMelanin->setEnabled(change);
   m_Controls.checkBoxAdd->setEnabled(change);
   m_Controls.QComboBoxAlgorithm->setEnabled(change);
   m_Controls.tableWeight->setEnabled(change);
   m_Controls.checkBoxsO2->setEnabled(change);
   m_Controls.tableSO2->setEnabled(change);
   m_Controls.checkBoxVerbose->setEnabled(change);
   m_Controls.checkBoxChrono->setEnabled(change);
   m_Controls.buttonPerformImageProcessing->setEnabled(change);
   m_Controls.checkBoxError->setEnabled(change);
 }
 
 void SpectralUnmixing::EnableGUIWeight()
 {
   auto qs = m_Controls.QComboBoxAlgorithm->currentText();
   std::string Algorithm = qs.toUtf8().constData();
   if (Algorithm == "weighted")
     m_Controls.tableWeight->show();
   else
     m_Controls.tableWeight->hide();
 }
 
 void SpectralUnmixing::EnableGUISO2()
 {
   if (m_Controls.checkBoxsO2->isChecked())
     m_Controls.tableSO2->show();
   else
     m_Controls.tableSO2->hide();
 }
 
 void SpectralUnmixing::EnableGUIError()
 {
   if (m_Controls.checkBoxError->isChecked())
     m_Controls.tableError->show();
   else
     m_Controls.tableError->hide();
 }
 
 void SpectralUnmixing::SetVerboseMode(mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter, bool PluginVerbose)
 {
   m_SpectralUnmixingFilter->Verbose(PluginVerbose);
 }
 
 void SpectralUnmixing::SetWavlength(mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter)
 {
   int col = 0;
   int Wavelength = 1;
   while (m_Controls.inputtable->item(0, col) && Wavelength > 0)
   {
     QString Text = m_Controls.inputtable->item(0, col)->text();
     Wavelength = Text.toInt();
     if (Wavelength > 0)
     {
       m_SpectralUnmixingFilter->AddWavelength(Wavelength);
       MITK_INFO(PluginVerbose) << "Wavelength: " << Wavelength << "nm \n";
     }
     ++col;
   }
 }
 
 void SpectralUnmixing::SetChromophore(mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter, std::vector<bool> boolVec,
   std::vector<std::string> chromophoreNameVec)
 {
   unsigned int numberofChromophores = 0;
 
   std::vector<mitk::pa::PropertyCalculator::ChromophoreType> m_ChromoType = { mitk::pa::PropertyCalculator::ChromophoreType::OXYGENATED,
     mitk::pa::PropertyCalculator::ChromophoreType::DEOXYGENATED, mitk::pa::PropertyCalculator::ChromophoreType::MELANIN,
     mitk::pa::PropertyCalculator::ChromophoreType::ONEENDMEMBER};
 
   for (unsigned int chromo = 0; chromo < m_ChromoType.size(); ++chromo)
   {
     if (boolVec[chromo] == true)
     {
       MITK_INFO(PluginVerbose) << "Chromophore: " << chromophoreNameVec[chromo];
       m_SpectralUnmixingFilter->AddChromophore(m_ChromoType[chromo]);
       numberofChromophores += 1;
     }
   }
 
   if (numberofChromophores == 0)
     mitkThrow() << "PRESS 'IGNORE' AND CHOOSE A CHROMOPHORE!";
 }
 
 void SpectralUnmixing::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*source*/,
                                                 const QList<mitk::DataNode::Pointer> &nodes)
 {
   // iterate all selected objects, adjust warning visibility
   foreach (mitk::DataNode::Pointer node, nodes)
   {
     if (node.IsNotNull() && dynamic_cast<mitk::Image *>(node->GetData()))
     {
       m_Controls.labelWarning->setVisible(false);
       m_Controls.buttonPerformImageProcessing->setEnabled(true);
       return;
     }
   }
 
   m_Controls.labelWarning->setVisible(true);
   m_Controls.buttonPerformImageProcessing->setEnabled(false);
 }
 
 mitk::pa::SpectralUnmixingFilterBase::Pointer SpectralUnmixing::GetFilterInstance(std::string algorithm)
 {
   mitk::pa::SpectralUnmixingFilterBase::Pointer spectralUnmixingFilter;
 
   if (algorithm == "householderQr")
   {
     spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
     dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::HOUSEHOLDERQR);
   }
 
   else if (algorithm == "ldlt")
   {
     spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
     dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::LDLT);
   }
 
   else if (algorithm == "llt")
   {
     spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
     dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::LLT);
   }
 
   else if (algorithm == "colPivHouseholderQr")
   {
     spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
     dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::COLPIVHOUSEHOLDERQR);
   }
 
   else if (algorithm == "jacobiSvd")
   {
     spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
     dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::JACOBISVD);
   }
 
   else if (algorithm == "fullPivLu")
   {
     spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
     dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::FULLPIVLU);
   }
 
   else if (algorithm == "fullPivHouseholderQr")
   {
     spectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
     dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::FULLPIVHOUSEHOLDERQR);
   }
 
   else if (algorithm == "NNLARS")
   {
     spectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
     dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::LARS);
   }
 
   else if (algorithm == "NNGoldfarb")
   {
     spectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
     dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::GOLDFARB);
   }
 
   else if (algorithm == "weighted")
   {
     spectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
     dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::WEIGHTED);
     //Tranfer GUI information(Weights) to filter
     unsigned int colunm = 0;
     int Weight = 1;
     while (m_Controls.tableWeight->item(0, colunm) && Weight > 0)
     {
       QString Text = m_Controls.tableWeight->item(0, colunm)->text();
       Weight = Text.toInt();
       if (Weight > 0)
       {
         dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(spectralUnmixingFilter.GetPointer())
           ->AddWeight(Weight);
         MITK_INFO(PluginVerbose) << "Weight: " << Weight;
       }
       ++colunm;
     }
   }
 
   else if (algorithm == "LS")
   {
     spectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
     dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(spectralUnmixingFilter.GetPointer())
       ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::LS);
   }
 
   else if (algorithm == "SimplexMax")
   {
     spectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterSimplex::New();
   }
 
   else
     mitkThrow() << "404 ALGORITHM NOT FOUND!";
 
     return spectralUnmixingFilter;
 }
 
 
 void SpectralUnmixing::SetSO2Settings(mitk::pa::SpectralUnmixingSO2::Pointer m_sO2)
 {
   for (unsigned int i = 0; i < 4; ++i)
   {
-    if (m_Controls.inputtable->item(0, i))
+    if (m_Controls.tableSO2->item(0, i))
     {
       QString Text = m_Controls.tableSO2->item(0, i)->text();
-      float value = Text.toFloat();
+      int value = Text.toInt();
       MITK_INFO(PluginVerbose) << "SO2 setting value: " << value;
       m_sO2->AddSO2Settings(value);
     }
     else
       m_sO2->AddSO2Settings(0);
   }
 }
 
 void SpectralUnmixing::SetRelativeErrorSettings(mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter)
 {
   for (unsigned int i = 0; i < 2; ++i)
   {
     if (m_Controls.tableError->item(0, i))
     {
       QString Text = m_Controls.tableError->item(0, i)->text();
       int value = Text.toInt();
       MITK_INFO(PluginVerbose) << "Relative error setting value: " << value;
       m_SpectralUnmixingFilter->AddRelativeErrorSettings(value);
     }
     else
       m_SpectralUnmixingFilter->AddRelativeErrorSettings(0);
   }
 }
 
 void SpectralUnmixing::CalculateSO2(mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter, std::vector<bool> boolVec)
 {
   MITK_INFO(PluginVerbose) << "CALCULATE OXYGEN SATURATION ...";
 
   if (!boolVec[0])
     mitkThrow() << "SELECT CHROMOPHORE DEOXYHEMOGLOBIN!";
   if (!boolVec[1])
     mitkThrow() << "SELECT CHROMOPHORE OXYHEMOGLOBIN!";
   auto m_sO2 = mitk::pa::SpectralUnmixingSO2::New();
   m_sO2->Verbose(PluginVerbose);
   SetSO2Settings(m_sO2);
 
   // Initialize pipeline from SU filter class to SO2 class
   auto output1 = m_SpectralUnmixingFilter->GetOutput(0);
   auto output2 = m_SpectralUnmixingFilter->GetOutput(1);
   m_sO2->SetInput(0, output1);
   m_sO2->SetInput(1, output2);
 
   m_sO2->Update();
 
   mitk::Image::Pointer sO2 = m_sO2->GetOutput(0);
   sO2->SetSpacing(output1->GetGeometry()->GetSpacing());
   WriteOutputToDataStorage(sO2, "sO2");
   MITK_INFO(PluginVerbose) << "[DONE]";
 }
 
 void SpectralUnmixing::WriteOutputToDataStorage(mitk::Image::Pointer m_Image, std::string name)
 {
   mitk::DataNode::Pointer dataNodeOutput = mitk::DataNode::New();
   dataNodeOutput->SetData(m_Image);
   dataNodeOutput->SetName(name);
   this->GetDataStorage()->Add(dataNodeOutput);
 }
 
 void SpectralUnmixing::Settings(mitk::Image::Pointer image)
 {
   boolVec = { m_Controls.checkBoxOx->isChecked(),  m_Controls.checkBoxDeOx->isChecked(),
     m_Controls.checkBoxMelanin->isChecked(), m_Controls.checkBoxAdd->isChecked() };
   outputNameVec = { "HbO2",  "Hb", "Melanin", "Static Endmember" };
   sO2Bool = (m_Controls.checkBoxsO2->isChecked());
 
   //Read GUI information(algorithm)
   auto qs = m_Controls.QComboBoxAlgorithm->currentText();
   Algorithm = qs.toUtf8().constData();
 
   m_SpectralUnmixingFilter = GetFilterInstance(Algorithm);
   SetVerboseMode(m_SpectralUnmixingFilter, PluginVerbose);
   m_SpectralUnmixingFilter->RelativeError(m_Controls.checkBoxError->isChecked());
   m_SpectralUnmixingFilter->SetInput(image);
   SetWavlength(m_SpectralUnmixingFilter);
   SetChromophore(m_SpectralUnmixingFilter, boolVec, outputNameVec);
 
   boolVec.push_back(m_Controls.checkBoxError->isChecked());
   outputNameVec.push_back("Relative Error");
   if (m_Controls.checkBoxError->isChecked())
     SetRelativeErrorSettings(m_SpectralUnmixingFilter);
 
   m_SpectralUnmixingFilter->AddOutputs(std::accumulate(boolVec.begin(), boolVec.end(), 0));
   MITK_INFO(PluginVerbose) << "Number of indexed outputs: " << std::accumulate(boolVec.begin(), boolVec.end(), 0);
 }
 
 void SpectralUnmixing::storeOutputs()
 {
   int outputCounter = 0;
   mitk::Image::Pointer m_Output;
   for (unsigned int chromophore = 0; chromophore < outputNameVec.size(); ++chromophore)
   {
     if (boolVec[chromophore] != false)
     {
       m_Output = m_SpectralUnmixingFilter->GetOutput(outputCounter++);
       m_Output->SetSpacing(image->GetGeometry()->GetSpacing());
       WriteOutputToDataStorage(m_Output, outputNameVec[chromophore] + Algorithm);
     }
   }
 
   if (sO2Bool)
     CalculateSO2(m_SpectralUnmixingFilter, boolVec);
 
   mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
   MITK_INFO(PluginVerbose) << "Adding images to DataStorage...[DONE]";
 
   std::chrono::steady_clock::time_point _end(std::chrono::steady_clock::now());
   MITK_INFO(m_Controls.checkBoxChrono->isChecked()) << "Time for image Processing: "
     << std::chrono::duration_cast<std::chrono::duration<double>>(_end - _start).count();
   SwitchGUIControls(true);
 }
 
 void SpectralUnmixing::WorkingThreadUpdateFilter(mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter)
 {
   SwitchGUIControls(false);
   try
   {
     m_SpectralUnmixingFilter->Update();
     emit finishSignal();
   }
   catch (const mitk::Exception& e)
   {
     SwitchGUIControls(true);
     errorMessage = e.GetDescription();
     emit crashSignal();
   }
 }
 
 void SpectralUnmixing::crashInfo()
 {
   const char *error = errorMessage.c_str();
   QMessageBox::information(nullptr, "Template", error);
 }
 
 void SpectralUnmixing::DoImageProcessing()
 {
   QList<mitk::DataNode::Pointer> nodes = this->GetDataManagerSelection();
   if (nodes.empty())
     return;
 
   mitk::DataNode *node = nodes.front();
 
   if (!node)
   {
     // Nothing selected. Inform the user and return
     QMessageBox::information(nullptr, "Template", "Please load and select an image before starting image processing.");
     return;
   }
 
   // here we have a valid mitk::DataNode
 
   // a node itself is not very useful, we need its data item (the image)
   mitk::BaseData *data = node->GetData();
   if (data)
   {
     // test if this data item is an image or not (could also be a surface or something totally different)
     image = dynamic_cast<mitk::Image *>(data);
     if (image)
     {
       std::stringstream message;
       std::string name;
       message << "PERFORMING SPECTRAL UNMIXING ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
       }
       message << ".";
 
       _start = std::chrono::steady_clock::now();
       PluginVerbose = m_Controls.checkBoxVerbose->isChecked();
       MITK_INFO(PluginVerbose) << message.str();
 
       try
       {
         Settings(image);
         MITK_INFO(PluginVerbose) << "Updating Filter...";
         QtConcurrent::run(this, &SpectralUnmixing::WorkingThreadUpdateFilter, m_SpectralUnmixingFilter);
       }
       catch (const mitk::Exception& e)
       {
         QMessageBox::information(nullptr, "Template", e.GetDescription());
       }
     }
   }
 }