diff --git a/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilterBase.h b/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilterBase.h
index 5b3658ccef..4b465fc21e 100644
--- a/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilterBase.h
+++ b/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilterBase.h
@@ -1,76 +1,65 @@
 /*===================================================================
 
 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 MITKPHOTOACOUSTICSPECTRALUNMIXINGFILTERBASE_H
 #define MITKPHOTOACOUSTICSPECTRALUNMIXINGFILTERBASE_H
 
 #include "mitkImageToImageFilter.h"
 #include <MitkPhotoacousticsLibExports.h>
 
 //Includes for smart pointer usage
 #include "mitkCommon.h"
 #include "itkLightObject.h"
 
 // Includes for AddEnmemberMatrix
 #include "mitkPAPropertyCalculator.h"
 #include <eigen3/Eigen/Dense>
 
 namespace mitk {
   namespace pa {
     class MITKPHOTOACOUSTICSLIB_EXPORT SpectralUnmixingFilterBase : public mitk::ImageToImageFilter
     {
     public:
-
       mitkClassMacro(SpectralUnmixingFilterBase, mitk::ImageToImageFilter);
 
-      // Contains all (so far) possible chromophores
-
-
-      // Void to creat m_vector of all chosen chromophores with push back method
       void AddChromophore(mitk::pa::PropertyCalculator::ChromophoreType);
-      
-      // Void to creat m_vector of all wavelengths with push back method
       void AddWavelength(int wavelength);
 
-
-
     protected:
       SpectralUnmixingFilterBase();
       virtual ~SpectralUnmixingFilterBase();
 
       std::vector<mitk::pa::PropertyCalculator::ChromophoreType> m_Chromophore;
       std::vector<int> m_Wavelength; 
 
       virtual Eigen::VectorXf SpectralUnmixingAlgorithm(Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix,
         Eigen::VectorXf inputVector) = 0;
 
     private:
-      // Void checking precondtions possibly throwing exeptions
       virtual void CheckPreConditions(unsigned int size, unsigned int NumberOfInputImages, const float* inputDataArray);
 
       virtual void GenerateData() override;
       virtual void InitializeOutputs();
 
       virtual Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> CalculateEndmemberMatrix(
         std::vector<mitk::pa::PropertyCalculator::ChromophoreType> m_Chromophore, std::vector<int> m_Wavelength);
       PropertyCalculator::Pointer m_PropertyCalculatorEigen;
 
       virtual float propertyElement(mitk::pa::PropertyCalculator::ChromophoreType, int wavelength);
-            
     };
   }
 }
 #endif // MITKPHOTOACOUSTICSPECTRALUNMIXINGFILTERBASE_
diff --git a/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp b/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
index 4a2bf6c2b7..4b892e7a7e 100644
--- a/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
+++ b/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
@@ -1,83 +1,84 @@
 /*===================================================================
 
 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 "mitkPALinearSpectralUnmixingFilter.h"
 
 // Testing algorithms
 #include <eigen3\Eigen\src\SVD\JacobiSVD.h>
 
 // ImageAccessor
 #include <mitkImageReadAccessor.h>
 #include <mitkImageWriteAccessor.h>
 
 mitk::pa::LinearSpectralUnmixingFilter::LinearSpectralUnmixingFilter()
 {
 }
 
 mitk::pa::LinearSpectralUnmixingFilter::~LinearSpectralUnmixingFilter()
 {
 }
 
 void mitk::pa::LinearSpectralUnmixingFilter::SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType SetAlgorithmIndex)
 {
   algorithmIndex = SetAlgorithmIndex;
 }
 
 Eigen::VectorXf mitk::pa::LinearSpectralUnmixingFilter::SpectralUnmixingAlgorithm(
   Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix, Eigen::VectorXf inputVector)
 {
   Eigen::VectorXf resultVector;
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::colPivHouseholderQr == algorithmIndex)
     resultVector = EndmemberMatrix.colPivHouseholderQr().solve(inputVector);
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::llt == algorithmIndex)
     resultVector = EndmemberMatrix.llt().solve(inputVector);
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::householderQr == algorithmIndex)
     resultVector = EndmemberMatrix.householderQr().solve(inputVector);
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::ldlt == algorithmIndex)
   {
     mitkThrow() << "algorithm not working";
     resultVector = EndmemberMatrix.ldlt().solve(inputVector);
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::jacobiSvd == algorithmIndex)
     resultVector = EndmemberMatrix.jacobiSvd(Eigen::ComputeFullU | Eigen::ComputeFullV).solve(inputVector);
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::fullPivLu == algorithmIndex)
     resultVector = EndmemberMatrix.fullPivLu().solve(inputVector);
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::householderQr == algorithmIndex)
     resultVector = EndmemberMatrix.householderQr().solve(inputVector);
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::fullPivHouseholderQr == algorithmIndex)
     resultVector = EndmemberMatrix.fullPivHouseholderQr().solve(inputVector);
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::test == algorithmIndex)
   {
     mitkThrow() << "404 NO ALGORITHM IMPLEMENTED";
   }
 
   /*double relativeError = (EndmemberMatrix*resultVector - inputVector).norm() / inputVector.norm(); // norm() is L2 norm
   MITK_INFO << "relativ error: " << relativeError;
   float accuracyLevel = .1;
   bool resultIsApprox = inputVector.isApprox(EndmemberMatrix*resultVector, accuracyLevel);
   MITK_INFO << "IS APPROX RESULT: " << resultIsApprox;*/
   //MITK_INFO << "Result vector: " << resultVector;
+  //++++++++++++++++++Maybe add this as additional ouptu image++++++++++++++++++++++
   return resultVector;
 }
diff --git a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
index 7d2afc8bf9..5f3632af67 100644
--- a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
+++ b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
@@ -1,233 +1,218 @@
 /*===================================================================
 
 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 "mitkPASpectralUnmixingFilterBase.h"
 
 // Includes for AddEnmemberMatrix
 #include "mitkPAPropertyCalculator.h"
 #include <eigen3/Eigen/Dense>
 
 // ImageAccessor
 #include <mitkImageReadAccessor.h>
 #include <mitkImageWriteAccessor.h>
 
 #include <chrono>
 
 mitk::pa::SpectralUnmixingFilterBase::SpectralUnmixingFilterBase()
 {
   this->SetNumberOfIndexedOutputs(4);// find solution
 
   for (unsigned int i = 0; i<GetNumberOfIndexedOutputs(); i++)
   {
     this->SetNthOutput(i, mitk::Image::New());
   }
 
   m_PropertyCalculatorEigen = mitk::pa::PropertyCalculator::New();
 }
 
 mitk::pa::SpectralUnmixingFilterBase::~SpectralUnmixingFilterBase()
 {
 
 }
 
 void mitk::pa::SpectralUnmixingFilterBase::AddWavelength(int wavelength)
 {
   m_Wavelength.push_back(wavelength);
 }
 
 void mitk::pa::SpectralUnmixingFilterBase::AddChromophore(mitk::pa::PropertyCalculator::ChromophoreType chromophore)
 {
   m_Chromophore.push_back(chromophore);
 }
 
 void mitk::pa::SpectralUnmixingFilterBase::GenerateData()
 {
   MITK_INFO << "GENERATING DATA..";
 
   // Get input image
   mitk::Image::Pointer input = GetInput(0);
 
   unsigned int xDim = input->GetDimensions()[0];
   unsigned int yDim = input->GetDimensions()[1];
   unsigned int zDim = input->GetDimensions()[2];
   unsigned int size = xDim * yDim * zDim;
 
   MITK_INFO << "x dimension: " << xDim;
   MITK_INFO << "y dimension: " << yDim;
   MITK_INFO << "z dimension: " << zDim;
 
   InitializeOutputs();
   
   auto EndmemberMatrix = CalculateEndmemberMatrix(m_Chromophore, m_Wavelength); //Eigen Endmember Matrix
   
   // Copy input image into array
   mitk::ImageReadAccessor readAccess(input);
-
   const float* inputDataArray = ((const float*)readAccess.GetData());
 
   CheckPreConditions(size, zDim, inputDataArray);
 
-  /* READ OUT INPUTARRAY
-  MITK_INFO << "Info Array:";
-  int numberOfPixels= 6;
-  for (int i=0; i< numberOfPixels; ++i)
-    MITK_INFO << inputDataArray[i];/**/
-
   // test to see pixel values @ txt file
-  ofstream myfile;
-  myfile.open("PASpectralUnmixingPixelValues.txt");
+  //ofstream myfile;
+  //myfile.open("PASpectralUnmixingPixelValues.txt");
 
   std::chrono::steady_clock::time_point _start(std::chrono::steady_clock::now());
 
   //loop over every pixel @ x,y plane
   for (unsigned int x = 0; x < xDim; x++)
   {
     for (unsigned int y = 0; y < yDim; y++)
     {
       Eigen::VectorXf inputVector(zDim);
       for (unsigned int z = 0; z < zDim; z++)
       {
         // Get pixel value of pixel x,y @ wavelength z
         unsigned int pixelNumber = (xDim*yDim*z) + x * yDim + y;
         auto pixel = inputDataArray[pixelNumber];
 
-        //MITK_INFO << "Pixel_values: " << pixel;
-
-        // dummy values for pixel for testing purposes
-        //float pixel = rand();
-
         //write all wavelength absorbtion values for one(!) pixel to a vector
         inputVector[z] = pixel;
       }
       Eigen::VectorXf resultVector = SpectralUnmixingAlgorithm(EndmemberMatrix, inputVector);
-      //Eigen::VectorXf resultVector = SpectralUnmixingAlgorithm(m_Chromophore, inputVector);
-
 
       // write output
       for (int outputIdx = 0; outputIdx < GetNumberOfIndexedOutputs(); ++outputIdx)
       {
         auto output = GetOutput(outputIdx);
         mitk::ImageWriteAccessor writeOutput(output);
         float* writeBuffer = (float *)writeOutput.GetData();
         writeBuffer[x*yDim + y] = resultVector[outputIdx]; 
       }
-      myfile << "Input Pixel(x,y): " << x << "," << y << "\n" << inputVector << "\n";
-      myfile << "Result: "  << "\n HbO2: " << resultVector[0] << "\n Hb: " << resultVector[1] << "\n Mel: "
-        << resultVector[2] << "Result vector size" << resultVector.size() << "\n";
+      //myfile << "Input Pixel(x,y): " << x << "," << y << "\n" << inputVector << "\n";
+      //myfile << "Result: "  << "\n HbO2: " << resultVector[0] << "\n Hb: " << resultVector[1] << "\n Mel: "
+      //  << resultVector[2] << "Result vector size" << resultVector.size() << "\n";
     }
   }
   std::chrono::steady_clock::time_point _end(std::chrono::steady_clock::now());
   MITK_INFO << "GENERATING DATA...[DONE]";
-  myfile.close();
+  //myfile.close();
   MITK_INFO << "Chrono: " << std::chrono::duration_cast<std::chrono::duration<double>>(    _end - _start).count() << "s";
 }
 
 void mitk::pa::SpectralUnmixingFilterBase::CheckPreConditions(unsigned int size, unsigned int NumberOfInputImages, const float* inputDataArray)
 {
   // Checking if number of Inputs == added wavelengths
   if (m_Wavelength.size() != NumberOfInputImages)
     mitkThrow() << "CHECK INPUTS! WAVELENGTHERROR";
 
   // Checking if number of wavelengths >= number of chromophores
-  if (m_Chromophore.size() > m_Wavelength.size())
+  if (m_Chromophore.size() >= m_Wavelength.size())
     mitkThrow() << "PRESS 'IGNORE' AND ADD MORE WAVELENGTHS!";
 
   // Checking if pixel type is float
   int maxPixel = size;
   for (int i = 0; i < maxPixel; ++i)
   {
     if (typeid(inputDataArray[i]).name() != typeid(float).name())
     {
       mitkThrow() << "PIXELTYPE ERROR! FLOAT 32 REQUIRED";
     }
     else continue;
   }
 
   MITK_INFO << "CHECK PRECONDITIONS ...[DONE]";
 }
 
 void mitk::pa::SpectralUnmixingFilterBase::InitializeOutputs()
 {
   unsigned int numberOfInputs = GetNumberOfIndexedInputs();
   unsigned int numberOfOutputs = GetNumberOfIndexedOutputs();
-  //MITK_INFO << "Inputs: " << numberOfInputs << " Outputs: " << numberOfOutputs;
+  MITK_INFO << "Inputs: " << numberOfInputs << " Outputs: " << numberOfOutputs;
 
   //  Set dimensions (2) and pixel type (float) for output
   mitk::PixelType pixelType = mitk::MakeScalarPixelType<float>();
   const int NUMBER_OF_SPATIAL_DIMENSIONS = 2;
   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];
   }
 
   // Initialize numberOfOutput pictures with pixel type and dimensions
   for (unsigned int outputIdx = 0; outputIdx < numberOfOutputs; outputIdx++)
   {
     GetOutput(outputIdx)->Initialize(pixelType, NUMBER_OF_SPATIAL_DIMENSIONS, dimensions);
   }
 }
 
 
 //Matrix with #chromophores colums and #wavelengths rows
 //so Matrix Element (i,j) contains the Absorbtion of chromophore j @ wavelength i
 Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> mitk::pa::SpectralUnmixingFilterBase::CalculateEndmemberMatrix(
   std::vector<mitk::pa::PropertyCalculator::ChromophoreType> m_Chromophore, std::vector<int> m_Wavelength)
 {
   unsigned int numberOfChromophores = m_Chromophore.size(); //columns
   unsigned int numberOfWavelengths = m_Wavelength.size(); //rows
   Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrixEigen(numberOfWavelengths, numberOfChromophores);
 
   for (unsigned int j = 0; j < numberOfChromophores; ++j)
   {
     if (m_Chromophore[j] == mitk::pa::PropertyCalculator::ChromophoreType::OXYGENATED)
     {
       for (unsigned int i = 0; i < numberOfWavelengths; ++i)
         EndmemberMatrixEigen(i, j) = propertyElement(m_Chromophore[j], m_Wavelength[i]);
     }
     else if (m_Chromophore[j] == mitk::pa::PropertyCalculator::ChromophoreType::DEOXYGENATED)
     {
       for (unsigned int i = 0; i < numberOfWavelengths; ++i)
         EndmemberMatrixEigen(i, j) = propertyElement(m_Chromophore[j], m_Wavelength[i]);
     }
     else if (m_Chromophore[j] == mitk::pa::PropertyCalculator::ChromophoreType::MELANIN)
     {
       for (unsigned int i = 0; i < numberOfWavelengths; ++i)
       {
         EndmemberMatrixEigen(i, j) = propertyElement(m_Chromophore[j], m_Wavelength[i]);
         MITK_INFO << "MELANIN " << EndmemberMatrixEigen(i, j);
       }
     }
     else if (m_Chromophore[j] == mitk::pa::PropertyCalculator::ChromophoreType::ONEENDMEMBER)
     {
       for (unsigned int i = 0; i < numberOfWavelengths; ++i)
         EndmemberMatrixEigen(i, j) = 1;
     }
     else
       mitkThrow() << "404 CHROMOPHORE NOT FOUND!";
   }
   MITK_INFO << "GENERATING ENMEMBERMATRIX [DONE]!";
-  MITK_INFO << "endmember matrix: " << EndmemberMatrixEigen;
   return EndmemberMatrixEigen;
 }
 
 float mitk::pa::SpectralUnmixingFilterBase::propertyElement(mitk::pa::PropertyCalculator::ChromophoreType Chromophore, int Wavelength)
 {
   float value = m_PropertyCalculatorEigen->GetAbsorptionForWavelength(Chromophore, Wavelength);
   if (value == 0)
     mitkThrow() << "WAVELENGTH " << Wavelength << "nm NOT SUPPORTED!";
   return value;
 }
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 b5df5bc14f..fd421e5a5a 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,358 +1,360 @@
 /*===================================================================
 
 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"
 
 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);
 }
 
 void SpectralUnmixing::ClearWavelength()
 {
   m_Wavelengths.clear();
 }
 
 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);
 }
 
 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)
     mitk::Image *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 << ".";
       MITK_INFO << message.str();
 
-      // Set Algortihm to filter
+      //Tranfer GUI information(Algortihm) to filter
       auto qs = m_Controls.QComboBoxAlgorithm->currentText();
       std::string Algorithm = qs.toUtf8().constData();
 
       mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter;
 
       if (Algorithm == "householderQr")
       {
         m_SpectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
         dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::householderQr);
       }
 
       else if (Algorithm == "ldlt")
       {
         m_SpectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
         dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::ldlt);
       }
 
       else if (Algorithm == "llt")
       {
         m_SpectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
         dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::llt);
       }
 
       else if (Algorithm == "colPivHouseholderQr")
       {
         m_SpectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
         dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::colPivHouseholderQr);
       }
 
       else if (Algorithm == "jacobiSvd")
       {
         m_SpectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
         dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::jacobiSvd);
       }
 
       else if (Algorithm == "fullPivLu")
       {
         m_SpectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
         dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::fullPivLu);
       }
 
       else if (Algorithm == "fullPivHouseholderQr")
       {
         m_SpectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
         dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::fullPivHouseholderQr);
       }
 
       else if (Algorithm == "test")
       {
         m_SpectralUnmixingFilter = mitk::pa::LinearSpectralUnmixingFilter::New();
         dynamic_cast<mitk::pa::LinearSpectralUnmixingFilter*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::test);
       }
       
       else if (Algorithm == "NNLARS")
       {
         m_SpectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
         dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::LARS);
       }
 
       else if (Algorithm == "NNGoldfarb")
       {
         m_SpectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
         dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::GOLDFARB);
       }
 
       else if (Algorithm == "weighted")
       {
         m_SpectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
         dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::WEIGHTED);
       }
 
       else if (Algorithm == "vigratest")
       {
         m_SpectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
         dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::vigratest);
       }
 
       else if (Algorithm == "SimplexMax")
       {
         m_SpectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterSimplex::New();
         dynamic_cast<mitk::pa::SpectralUnmixingFilterSimplex*>(m_SpectralUnmixingFilter.GetPointer());
       }
 
       else
         mitkThrow() << "404 ALGORITHM NOT FOUND!";
 
       m_SpectralUnmixingFilter->SetInput(image);
 
-      // Wavelength implementation
+      //Tranfer GUI information(Wavelength) to filter
       ClearWavelength();
       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);
         ++col;
       }
 
-      // Checking which chromophores wanted for SU if none throw exeption!
+      //Tranfer GUI information(Chromophores) to filter
       unsigned int numberofChromophores = 0;
       DeOxbool = m_Controls.checkBoxDeOx->isChecked();
       Oxbool = m_Controls.checkBoxOx->isChecked();
       bool Melaninbool = m_Controls.checkBoxMelanin->isChecked();
       bool Onebool = m_Controls.checkBoxAdd->isChecked();
       if (DeOxbool || Oxbool)
       {
         MITK_INFO << "CHOSEN CHROMOPHORES:";
       }
       if (Oxbool)
       {
         numberofChromophores += 1;
         MITK_INFO << "- Oxyhemoglobin";
-        // Set chromophore Oxyhemoglobon:
         m_SpectralUnmixingFilter->AddChromophore(
         mitk::pa::PropertyCalculator::ChromophoreType::OXYGENATED);
       }
       if (DeOxbool)
       {
         numberofChromophores += 1;
          MITK_INFO << "- Deoxygenated hemoglobin";
-        // Set chromophore Deoxygenated hemoglobin:
          m_SpectralUnmixingFilter->AddChromophore(
         mitk::pa::PropertyCalculator::ChromophoreType::DEOXYGENATED);
       }
       if (Melaninbool)
       {
         numberofChromophores += 1;
         MITK_INFO << "- Melanin";
         m_SpectralUnmixingFilter->AddChromophore(
           mitk::pa::PropertyCalculator::ChromophoreType::MELANIN);
       }
       if (Onebool)
       {
         numberofChromophores += 1;
         MITK_INFO << "- Additional Chromophore";
         m_SpectralUnmixingFilter->AddChromophore(
           mitk::pa::PropertyCalculator::ChromophoreType::ONEENDMEMBER);
       }
       if (numberofChromophores == 0)
       {
         mitkThrow() << "PRESS 'IGNORE' AND CHOOSE A CHROMOPHORE!";
       }
 
       MITK_INFO << "Updating Filter...";
       m_SpectralUnmixingFilter->Update();
-
+      int outputCounter = 0;
       // Write Output images to Data Storage
       if (Oxbool)
       {
-        mitk::Image::Pointer HbO2 = m_SpectralUnmixingFilter->GetOutput(0);
+        mitk::Image::Pointer HbO2 = m_SpectralUnmixingFilter->GetOutput(outputCounter);
+        outputCounter += 1;
         mitk::DataNode::Pointer dataNodeHbO2 = mitk::DataNode::New();
         dataNodeHbO2->SetData(HbO2);
         dataNodeHbO2->SetName("HbO2 " + Algorithm);
         this->GetDataStorage()->Add(dataNodeHbO2);
       }
 
       if (DeOxbool)
       {
-        mitk::Image::Pointer Hb = m_SpectralUnmixingFilter->GetOutput(1);
+        mitk::Image::Pointer Hb = m_SpectralUnmixingFilter->GetOutput(outputCounter);
+        outputCounter += 1;
         mitk::DataNode::Pointer dataNodeHb = mitk::DataNode::New();
         dataNodeHb->SetData(Hb);
         dataNodeHb->SetName("Hb " + Algorithm);
         this->GetDataStorage()->Add(dataNodeHb);
       }
 
       if (Melaninbool)
       {
-        mitk::Image::Pointer Melanin = m_SpectralUnmixingFilter->GetOutput(2);
+        mitk::Image::Pointer Melanin = m_SpectralUnmixingFilter->GetOutput(outputCounter);
+        outputCounter += 1;
         mitk::DataNode::Pointer dataNodeMelanin = mitk::DataNode::New();
         dataNodeMelanin->SetData(Melanin);
         dataNodeMelanin->SetName("Melanin " + Algorithm);
         this->GetDataStorage()->Add(dataNodeMelanin);
       }
 
       if (Onebool)
       {
-        mitk::Image::Pointer One = m_SpectralUnmixingFilter->GetOutput(3);
+        mitk::Image::Pointer One = m_SpectralUnmixingFilter->GetOutput(outputCounter);
         mitk::DataNode::Pointer dataNodeOne = mitk::DataNode::New();
         dataNodeOne->SetData(One);
         dataNodeOne->SetName("One " + Algorithm);
         this->GetDataStorage()->Add(dataNodeOne);
       }
 
       //Calculate oxygen saturation
       bool sO2bool = m_Controls.checkBoxsO2->isChecked();
 
       if (sO2bool)
       {
         if (!DeOxbool)
           mitkThrow() << "SELECT CHROMOPHORE DEOXYHEMOGLOBIN!";
         if (!Oxbool)
           mitkThrow() << "SELECT CHROMOPHORE OXYHEMOGLOBIN!";
 
         MITK_INFO << "CALCULATE OXYGEN SATURATION ...";
-        // Initialize pipeline from SU filter class to SO2 class
         auto m_sO2 = mitk::pa::SpectralUnmixingSO2::New();
 
         // Oxygen Saturation Setting
         for (int i = 0; i < 4; ++i)
         {
           if (m_Controls.inputtable->item(0, i))
           {
             QString Text = m_Controls.tableSO2->item(0, i)->text();
             float value = Text.toFloat();
             MITK_INFO << "value: " << value;
             m_sO2->AddSO2Settings(value);
           }
           else
             m_sO2->AddSO2Settings(0);
         }
 
+        // 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();
 
         // Write Output images to Data Storage
         mitk::Image::Pointer sO2 = m_sO2->GetOutput(0);
         mitk::DataNode::Pointer dataNodesO2 = mitk::DataNode::New();
         dataNodesO2->SetData(sO2);
         dataNodesO2->SetName("sO2");
         this->GetDataStorage()->Add(dataNodesO2);
 
         MITK_INFO << "[DONE]";
       }
       mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
       MITK_INFO << "Adding images to DataStorage...[DONE]";
     }
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/src/internal/SpectralUnmixing.h b/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/src/internal/SpectralUnmixing.h
index 73de289ccb..ba9fed9c5c 100644
--- a/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/src/internal/SpectralUnmixing.h
+++ b/Plugins/org.mitk.gui.qt.photoacoustics.spectralunmixing/src/internal/SpectralUnmixing.h
@@ -1,62 +1,57 @@
 /*===================================================================
 
 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 SpectralUnmixing_h
 #define SpectralUnmixing_h
 
 #include <berryISelectionListener.h>
 
 #include <QmitkAbstractView.h>
 
 #include "ui_SpectralUnmixingControls.h"
 
-#include "mitkPAPropertyCalculator.h"
-
 class SpectralUnmixing : public QmitkAbstractView
 {
   // this is needed for all Qt objects that should have a Qt meta-object
   // (everything that derives from QObject and wants to have signal/slots)
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
   
 protected:
   virtual void CreateQtPartControl(QWidget *parent) override;
   virtual void SetFocus() override;
 
   /// \brief called by QmitkFunctionality when DataManager's selection has changed
   virtual void OnSelectionChanged(berry::IWorkbenchPart::Pointer source,
                                   const QList<mitk::DataNode::Pointer> &nodes) override;
 
   /// \brief Called when the user clicks the GUI button
   void DoImageProcessing();
 
   virtual void ClearWavelength();
 
   Ui::SpectralUnmixingControls m_Controls;
-  mitk::pa::PropertyCalculator::Pointer m_PropertyCalculator;
 
-  // Add Wavelengths with button:
-  int size = 0;
   std::vector<int> m_Wavelengths;
 
   // Selection of Chromophores
   bool DeOxbool;
   bool Oxbool;
 };
 
 #endif // SpectralUnmixing_h