diff --git a/Modules/PhotoacousticsLib/include/mitkPAPropertyCalculator.h b/Modules/PhotoacousticsLib/include/mitkPAPropertyCalculator.h
index 0b88ce6b44..9fd1417ca7 100644
--- a/Modules/PhotoacousticsLib/include/mitkPAPropertyCalculator.h
+++ b/Modules/PhotoacousticsLib/include/mitkPAPropertyCalculator.h
@@ -1,78 +1,79 @@
 /*===================================================================
 
 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 MITKPHOTOACOUSTICPROPERTYCALCULATOR_H
 #define MITKPHOTOACOUSTICPROPERTYCALCULATOR_H
 
 #include "MitkPhotoacousticsLibExports.h"
 
 //Includes for smart pointer usage
 #include "mitkCommon.h"
 #include "itkLightObject.h"
 
 namespace mitk {
   namespace pa {
     class MITKPHOTOACOUSTICSLIB_EXPORT PropertyCalculator : public itk::LightObject
     {
     public:
 
       mitkClassMacroItkParent(PropertyCalculator, itk::LightObject)
         itkFactorylessNewMacro(Self)
 
       struct Properties
       {
         double mua;
         double mus;
         double g;
       };
 
       enum TissueType
       {
         AIR = 1,
         BLOOD = 2,
         EPIDERMIS = 3,
         FAT = 4,
         STANDARD_TISSUE = 5
       };
 
-      enum MapType
+      enum ChromophoreType
       {
         OXYGENATED = 1,
         DEOXYGENATED = 2,
         WATER = 3,
         FATTY = 4,
-        MELANIN = 5
+        MELANIN = 5,
+        ONEENDMEMBER = 6
       };
 
       double GetAbsorptionForWavelength(
-        MapType mapType, int wavelength);
+        ChromophoreType ChromophoreType, int wavelength);
 
       Properties CalculatePropertyForSpecificWavelength(
         TissueType tissueType, int wavelength, double oxygenSaturatonInFraction = 0);
 
     protected:
       PropertyCalculator();
       ~PropertyCalculator() override;
 
       bool m_Valid = false;
 
       std::map<int, std::map<int, double>> m_SpectralLibMap;
           
     };
   }
 }
 
 #endif // MITKPHOTOACOUSTICPROPERTYCALCULATOR_H
diff --git a/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilterBase.h b/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilterBase.h
index 27e193a1d7..5c84cb9776 100644
--- a/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilterBase.h
+++ b/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilterBase.h
@@ -1,80 +1,76 @@
 /*===================================================================
 
 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
-      enum ChromophoreType
-      {
-        OXYGENATED_HEMOGLOBIN,
-        DEOXYGENATED_HEMOGLOBIN
-      };
+
 
       // Void to creat m_vector of all chosen chromophores with push back method
-      void AddChromophore(ChromophoreType);
+      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<ChromophoreType> m_Chromophore;
+      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();
 
       // Void to creat Eigen::Matrix of all absorbtions
       // @ specific wavelength (columns) of chromophores (rows)
       Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> AddEndmemberMatrix();
 
       PropertyCalculator::Pointer m_PropertyCalculator;
             
     };
   }
 }
 #endif // MITKPHOTOACOUSTICSPECTRALUNMIXINGFILTERBASE_
diff --git a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
index 597d7e939c..64342d05f4 100644
--- a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
+++ b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
@@ -1,216 +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>
 
 // For testing reasons
 #include <random>
 
 mitk::pa::SpectralUnmixingFilterBase::SpectralUnmixingFilterBase()
 {
   this->SetNumberOfIndexedOutputs(2);
 
   for (unsigned int i = 0; i<GetNumberOfIndexedOutputs(); i++)
   {
     this->SetNthOutput(i, mitk::Image::New());
   }
 
   m_PropertyCalculator = 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(ChromophoreType chromophore)
+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 = AddEndmemberMatrix();
   
   // 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");
 
   //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";
     }
   }
   MITK_INFO << "GENERATING DATA...[DONE]";
   //myfile.close();
 }
 
 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())
     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;
 
   //  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::AddEndmemberMatrix()
 {
   unsigned int numberOfChromophores = m_Chromophore.size(); //columns
   unsigned int numberOfWavelengths = m_Wavelength.size(); //rows
 
   Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix(numberOfWavelengths, numberOfChromophores);
 
   //loop over i rows (Wavelengths)
   for(unsigned int i = 0; i < numberOfWavelengths; ++i)
   {
     //loop over j columns (Chromophores)
     for (unsigned int j = 0; j < numberOfChromophores; ++j)
     {
       //writes @ Matrix element (i,j) the absorbtion wavelength of the propertycalculator.cpp
       //'i+1' because MapType is defined different then ChromophoreType
       EndmemberMatrix(i,j)= m_PropertyCalculator->GetAbsorptionForWavelength(
-      static_cast<mitk::pa::PropertyCalculator::MapType>(m_Chromophore[j]+1), m_Wavelength[i]);
+      static_cast<mitk::pa::PropertyCalculator::ChromophoreType>(m_Chromophore[j]+1), m_Wavelength[i]);
             
-      /* Tests to see what gets written in the Matrix:
-      auto testtype = m_PropertyCalculator->GetAbsorptionForWavelength(
-      static_cast<mitk::pa::PropertyCalculator::MapType>(m_Chromophore[j]+1), m_Wavelength[i]);
-      MITK_INFO << "TEST_TYPE Matrix: " << typeid(EndmemberMatrix(i,j)).name();
-      MITK_INFO << "map type: " << static_cast<mitk::pa::PropertyCalculator::MapType>(m_Chromophore[j]+1);
+      //* Tests to see what gets written in the Matrix:
+      //auto testtype = m_PropertyCalculator->GetAbsorptionForWavelength(
+      //static_cast<mitk::pa::PropertyCalculator::MapType>(m_Chromophore[j]+1), m_Wavelength[i]);
+      //MITK_INFO << "TEST_TYPE Matrix: " << typeid(EndmemberMatrix(i,j)).name();
+      MITK_INFO << "ChromophoreType: " << static_cast<mitk::pa::PropertyCalculator::ChromophoreType>(m_Chromophore[j]+1);
       MITK_INFO << "wavelength: " << m_Wavelength[i];
-      MITK_INFO << "Matrixelement: (" << i << ", " << j << ") Absorbtion: " << EndmemberMatrix(i, j);/**/
+      //MITK_INFO << "Matrixelement: (" << i << ", " << j << ") Absorbtion: " << EndmemberMatrix(i, j);/**/
       
       if (EndmemberMatrix(i, j) == 0)
       {
         m_Wavelength.clear();
         mitkThrow() << "WAVELENGTH "<< m_Wavelength[i] << "nm NOT SUPPORTED!";
       }
     }
   }
   MITK_INFO << "GENERATING ENMEMBERMATRIX [DONE]!";
   return EndmemberMatrix;
 }
diff --git a/Modules/PhotoacousticsLib/src/Utils/mitkPAPropertyCalculator.cpp b/Modules/PhotoacousticsLib/src/Utils/mitkPAPropertyCalculator.cpp
index c6d9461fdc..1eeeb14258 100644
--- a/Modules/PhotoacousticsLib/src/Utils/mitkPAPropertyCalculator.cpp
+++ b/Modules/PhotoacousticsLib/src/Utils/mitkPAPropertyCalculator.cpp
@@ -1,161 +1,161 @@
 /*===================================================================
 
 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 "mitkPAPropertyCalculator.h"
 // us
 #include <usModule.h>
 #include <usModuleResource.h>
 #include <usGetModuleContext.h>
 #include <usModuleContext.h>
 #include <usModuleResourceStream.h>
 
 mitk::pa::PropertyCalculator::Properties mitk::pa::PropertyCalculator::
 CalculatePropertyForSpecificWavelength(
   TissueType tissueType, int wavelength, double bloodOxygenInFraction)
 {
   Properties returnValue;
 
   if (!m_Valid)
   {
     mitkThrow() << "PhotoacousticPropertyGenerator was not loaded properly.";
     return returnValue;
   }
 
   double bloodOxygenation = bloodOxygenInFraction;
   double bloodVolumeFraction;
   double waterVolumeFraction;
   double fatVolumeFraction;
   double melanosomesVolumeFraction;
   double musp500;
   double fray;
   double bmie;
   double g;
 
   switch (tissueType)
   {
   case AIR:
     returnValue.mua = 1e-4;
     returnValue.mus = 1.0;
     returnValue.g = 1.0;
     return returnValue;
   case BLOOD:
     bloodVolumeFraction = 1.0;
     waterVolumeFraction = 0.95;
     fatVolumeFraction = 0.02;
     melanosomesVolumeFraction = 0;
     musp500 = 10;
     fray = 0;
     bmie = 1;
     g = 0.9;
     break;
   case EPIDERMIS:
     bloodVolumeFraction = 0;
     bloodOxygenation = 0;
     waterVolumeFraction = 0.75;
     fatVolumeFraction = 0.01;
     melanosomesVolumeFraction = 0.02;
     musp500 = 40;
     fray = 0;
     bmie = 1;
     g = 0.9;
     break;
   case FAT:
     bloodVolumeFraction = 0.01;
     bloodOxygenation = 0.75;
     waterVolumeFraction = 0.5;
     fatVolumeFraction = 0.6;
     melanosomesVolumeFraction = 0;
     musp500 = 17.47;
     fray = 0.2;
     bmie = 0.5;
     g = 0.9;
     break;
   case STANDARD_TISSUE:
   default:
     bloodVolumeFraction = 0.02;
     bloodOxygenation = 0.75;
     waterVolumeFraction = 0.8;
     fatVolumeFraction = 0.05;
     melanosomesVolumeFraction = 0;
     musp500 = 25;
     fray = 0.25;
     bmie = 1;
     g = 0.9;
     break;
   }
 
   // We want the reduced scattering coefficient directly.
   double musp = musp500 * (fray * pow(wavelength / 500.0, -4.0) + ((1 - fray) * pow(wavelength / 500.0, -bmie)));
   returnValue.mus = musp;
   returnValue.mus = 15;//musp;
 
-  double mua = bloodVolumeFraction*bloodOxygenation*m_SpectralLibMap[MapType::OXYGENATED][wavelength] +
-    bloodVolumeFraction*(1 - bloodOxygenation)*m_SpectralLibMap[MapType::DEOXYGENATED][wavelength] +
-    waterVolumeFraction*m_SpectralLibMap[MapType::WATER][wavelength] +
-    fatVolumeFraction*m_SpectralLibMap[MapType::FATTY][wavelength] +
-    melanosomesVolumeFraction*m_SpectralLibMap[MapType::MELANIN][wavelength];
+  double mua = bloodVolumeFraction*bloodOxygenation*m_SpectralLibMap[ChromophoreType::OXYGENATED][wavelength] +
+    bloodVolumeFraction*(1 - bloodOxygenation)*m_SpectralLibMap[ChromophoreType::DEOXYGENATED][wavelength] +
+    waterVolumeFraction*m_SpectralLibMap[ChromophoreType::WATER][wavelength] +
+    fatVolumeFraction*m_SpectralLibMap[ChromophoreType::FATTY][wavelength] +
+    melanosomesVolumeFraction*m_SpectralLibMap[ChromophoreType::MELANIN][wavelength];
 
   returnValue.mua = mua;
 
   returnValue.g = g;
 
   return returnValue;
 }
 
 mitk::pa::PropertyCalculator::PropertyCalculator()
 {
   us::ModuleResource resource = us::GetModuleContext()->GetModule()->GetResource("spectralLIB.dat");
 
   if (resource.IsValid())
   {
     us::ModuleResourceStream resourceStream(resource);
     std::string line;
     int wavelength = 300;
     int counter = 0;
     while (std::getline(resourceStream, line, '\t'))
     {
       int currentLineIdx = counter % 6;
       if (currentLineIdx == 0)
         wavelength = std::stoi(line);
       else
       {
         std::istringstream lineStream(line);
         double tempDouble;
         lineStream >> tempDouble;
         m_SpectralLibMap[currentLineIdx][wavelength] = tempDouble;
       }
       ++counter;
     }
   }
   else
   {
     m_Valid = false;
   }
 
   m_Valid = true;
 }
 
 mitk::pa::PropertyCalculator::~PropertyCalculator()
 {
   m_SpectralLibMap.clear();
   m_Valid = false;
 }
 
 double mitk::pa::PropertyCalculator::GetAbsorptionForWavelength(
-  MapType mapType, int wavelength)
+  ChromophoreType ChromophoreType, int wavelength)
 {
-  return m_SpectralLibMap[mapType][wavelength];
+  return m_SpectralLibMap[ChromophoreType][wavelength];
 }
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 3730b8b7da..4e97397460 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,326 +1,353 @@
 /*===================================================================
 
 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);
   connect(m_Controls.ButtonAddWavelength, &QPushButton::clicked, this, &SpectralUnmixing::Wavelength);
   connect(m_Controls.ButtonClearWavelength, &QPushButton::clicked, this, &SpectralUnmixing::ClearWavelength);
 }
 
 // Adds Wavelength @ Plugin with button
 void SpectralUnmixing::Wavelength()
 {
   if (m_Wavelengths.empty())
   {
       size = 0;
   }
 
   unsigned int wavelength = m_Controls.spinBoxAddWavelength->value();
   m_Wavelengths.push_back(wavelength);
   size += 1; // size implemented like this because '.size' is const
   MITK_INFO << "ALL WAVELENGTHS: ";
 
   for (int i = 0; i < size; ++i)
   {
     MITK_INFO << m_Wavelengths[i] << "nm";
   }
 }
 
 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();
 
+      /*/+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+      std::vector<double> listOfWavelengths;
+      double tmpWavelength = 0;
+      int currentRow = 0;
+      bool success = false;
+
+      do
+      {
+        if (currentRow != 0) listOfWavelengths.push_back(tmpWavelength);
+        if (m_Controls.inputtable->item(0, currentRow))
+        {
+          QString test = m_Controls.inputtable->item(0, currentRow)->text();
+          tmpWavelength = test.toDouble(&success);
+          currentRow++;
+        }
+        else
+          tmpWavelength = 0;
+
+        if (success == 0)
+          tmpWavelength = 0;
+      } while (tmpWavelength<1200 && tmpWavelength>300);
+
+      MITK_INFO << "listOfWavelengths" << listOfWavelengths;
+
+      //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/
+
       // Set 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 == "Lars")
       {
         m_SpectralUnmixingFilter = mitk::pa::SpectralUnmixingFilterVigra::New();
         dynamic_cast<mitk::pa::SpectralUnmixingFilterVigra*>(m_SpectralUnmixingFilter.GetPointer())
           ->SetAlgorithm(mitk::pa::SpectralUnmixingFilterVigra::VigraAlgortihmType::LARS);
       }
 
       else if (Algorithm == "Goldfarb")
       {
         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 into filter
       for (unsigned int imageIndex = 0; imageIndex < m_Wavelengths.size(); imageIndex++)
       {
         unsigned int wavelength = m_Wavelengths[imageIndex];
         m_SpectralUnmixingFilter->AddWavelength(wavelength);
       }
 
       // Checking which chromophores wanted for SU if none throw exeption!
       unsigned int numberofChromophores = 0;
       DeOxbool = m_Controls.checkBoxDeOx->isChecked();
       Oxbool = m_Controls.checkBoxOx->isChecked();
       if (DeOxbool || Oxbool)
       {
         MITK_INFO << "CHOSEN CHROMOPHORES:";
       }
       if (Oxbool)
       {
         numberofChromophores += 1;
         MITK_INFO << "- Oxyhemoglobin";
         // Set chromophore Oxyhemoglobon:
         m_SpectralUnmixingFilter->AddChromophore(
-        mitk::pa::SpectralUnmixingFilterBase::ChromophoreType::OXYGENATED_HEMOGLOBIN);
+        mitk::pa::PropertyCalculator::ChromophoreType::OXYGENATED);
       }
       if (DeOxbool)
       {
         numberofChromophores += 1;
          MITK_INFO << "- Deoxygenated hemoglobin";
         // Set chromophore Deoxygenated hemoglobin:
          m_SpectralUnmixingFilter->AddChromophore(
-        mitk::pa::SpectralUnmixingFilterBase::ChromophoreType::DEOXYGENATED_HEMOGLOBIN);
+        mitk::pa::PropertyCalculator::ChromophoreType::DEOXYGENATED);
       }
       if (numberofChromophores == 0)
       {
         mitkThrow() << "PRESS 'IGNORE' AND CHOOSE A CHROMOPHORE!";
       }
               
       MITK_INFO << "Updating Filter...";
       
       m_SpectralUnmixingFilter->Update();
 
       // Write Output images to Data Storage
       if (Oxbool)
       {
         mitk::Image::Pointer HbO2 = m_SpectralUnmixingFilter->GetOutput(0);
         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::DataNode::Pointer dataNodeHb = mitk::DataNode::New();
         dataNodeHb->SetData(Hb);
         dataNodeHb->SetName("Hb " + Algorithm);
         this->GetDataStorage()->Add(dataNodeHb);
       }
 
       //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();
         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]";
     }
   }
 }