diff --git a/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp b/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
index 3d82579432..5ac1d3fe9e 100644
--- a/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
+++ b/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
@@ -1,105 +1,108 @@
 /*===================================================================
 
 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"
 
 // Includes for AddEnmemberMatrix
 #include "mitkPAPropertyCalculator.h"
 #include <eigen3/Eigen/Dense>
 
 // 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(int SetAlgorithmIndex)
 {
   algorithmIndex = static_cast<mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType>(SetAlgorithmIndex);
 }
 
 Eigen::VectorXf mitk::pa::LinearSpectralUnmixingFilter::SpectralUnmixingAlgorithm(
   Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix, Eigen::VectorXf inputVector)
 {
 
   //test other solvers https://eigen.tuxfamily.org/dox/group__TutorialLinearAlgebra.html
 
   bool relativErrorBool = false;
   bool tresholdBool = false;
   int treshold = 0;
   int defaultValue = -1;
 
   Eigen::Vector2f resultVector;
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::colPivHouseholderQr == algorithmIndex)
   {
-    mitkThrow() << "not working";
-    resultVector = EndmemberMatrix.colPivHouseholderQr().solve(inputVector); //not working
+    resultVector = EndmemberMatrix.colPivHouseholderQr().solve(inputVector); //works :)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::llt == algorithmIndex)
   {
-    resultVector = EndmemberMatrix.llt().solve(inputVector);
+    resultVector = EndmemberMatrix.llt().solve(inputVector); //works with negativ values (no correct unmixing)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::householderQr == algorithmIndex)
   {
-    resultVector = EndmemberMatrix.householderQr().solve(inputVector);
+    resultVector = EndmemberMatrix.householderQr().solve(inputVector); //works :)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::ldlt == algorithmIndex)
   {
-    resultVector = EndmemberMatrix.ldlt().solve(inputVector); //until now 'best' algorithm
+    mitkThrow() << "not working";
+
+    resultVector = EndmemberMatrix.ldlt().solve(inputVector); //not working because matrix not quadratic(?)
   }
 
   //testing new algorithms:
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::test == algorithmIndex)
   {
     mitkThrow() << "nothing implemented";
   }
 
   if (relativErrorBool)
   {
     double relativeError = (EndmemberMatrix*inputVector - resultVector).norm() / resultVector.norm(); // norm() is L2 norm
     MITK_INFO << "rel err: " << relativeError;
   }
 
   //Set threshold and replace with default value if under threshold
   if (tresholdBool)
   {
     for (int i = 0; i < 2; ++i)
     {
       if (resultVector[i] < treshold)
       {
         resultVector[i] = defaultValue;
         MITK_INFO << "UNMIXING RESULT N/A";
       }
     }
   }
 
+  bool resultIsApprox = inputVector.isApprox(EndmemberMatrix*resultVector);
+  MITK_INFO << "IS APPROX RESULT: " << resultIsApprox;
   return resultVector;
 }
diff --git a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
index 3b2bcd3112..42148d6b43 100644
--- a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
+++ b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilterBase.cpp
@@ -1,216 +1,216 @@
 /*===================================================================
 
 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)
 {
   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);
 
       // 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 Hb: " << resultVector[0] << "\n HbO2: " << 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 rows and #wavelengths columns
-//so Matrix Element (i,j) contains the Absorbtion of chromophore i @ wavelength j
+//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(); //rows
-  unsigned int numberOfWavelengths = m_Wavelength.size(); //columns
+  unsigned int numberOfChromophores = m_Chromophore.size(); //columns
+  unsigned int numberOfWavelengths = m_Wavelength.size(); //rows
 
-  Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix(numberOfChromophores, numberOfWavelengths);
+  Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix(numberOfWavelengths, numberOfChromophores);
 
-  //loop over i rows (Chromophores)
-  for(unsigned int i = 0; i < numberOfChromophores; ++i)
+  //loop over i rows (Wavelengths)
+  for(unsigned int i = 0; i < numberOfWavelengths; ++i)
   {
-    //loop over j columns (Wavelengths)
-    for (unsigned int j = 0; j < numberOfWavelengths; ++j)
+    //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[i]+1), m_Wavelength[j]);
+      static_cast<mitk::pa::PropertyCalculator::MapType>(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[i]+1), m_Wavelength[j]);
+      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[i]+1);
-      MITK_INFO << "wavelength: " << m_Wavelength[j];
+      MITK_INFO << "map type: " << static_cast<mitk::pa::PropertyCalculator::MapType>(m_Chromophore[j]+1);
+      MITK_INFO << "wavelength: " << m_Wavelength[i];
       MITK_INFO << "Matrixelement: (" << i << ", " << j << ") Absorbtion: " << EndmemberMatrix(i, j);/**/
       
       if (EndmemberMatrix(i, j) == 0)
       {
         m_Wavelength.clear();
-        mitkThrow() << "WAVELENGTH "<< m_Wavelength[j] << "nm NOT SUPPORTED!";
+        mitkThrow() << "WAVELENGTH "<< m_Wavelength[i] << "nm NOT SUPPORTED!";
       }
     }
   }
   MITK_INFO << "GENERATING ENMEMBERMATRIX [DONE]!";
   return EndmemberMatrix;
 }