diff --git a/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp b/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
index 689f239e1d..a2adf7ba99 100644
--- a/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
+++ b/Modules/PhotoacousticsLib/src/SUFilter/mitkPALinearSpectralUnmixingFilter.cpp
@@ -1,106 +1,106 @@
 /*===================================================================
 
 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
 
   Eigen::Vector2f resultVector;
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::colPivHouseholderQr == algorithmIndex)
   {
     resultVector = EndmemberMatrix.colPivHouseholderQr().solve(inputVector); //works :)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::llt == algorithmIndex)
   {
     resultVector = EndmemberMatrix.llt().solve(inputVector); //works with negativ values (no correct unmixing)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::householderQr == algorithmIndex)
   {
     resultVector = EndmemberMatrix.householderQr().solve(inputVector); //works :)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::ldlt == algorithmIndex)
   {
     mitkThrow() << "not working";
     resultVector = EndmemberMatrix.ldlt().solve(inputVector); //not working because matrix not quadratic(?)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::jacobiSvd == algorithmIndex)
   {
-    resultVector = EndmemberMatrix.jacobiSvd(Eigen::ComputeFullU | Eigen::ComputeFullV).solve(inputVector); //not working
+    resultVector = EndmemberMatrix.jacobiSvd(Eigen::ComputeFullU | Eigen::ComputeFullV).solve(inputVector);
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::fullPivLu == algorithmIndex)
   {
     resultVector = EndmemberMatrix.fullPivLu().solve(inputVector); //works :)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::householderQr == algorithmIndex)
   {
     resultVector = EndmemberMatrix.householderQr().solve(inputVector); //works :)
   }
 
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::fullPivHouseholderQr == algorithmIndex)
   {
     resultVector = EndmemberMatrix.fullPivHouseholderQr().solve(inputVector);//works :)
   }
 
   //testing new algorithms:
   if (mitk::pa::LinearSpectralUnmixingFilter::AlgortihmType::test == algorithmIndex)
   {
     mitkThrow() << "nothing 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;
   return resultVector;
 }
diff --git a/Modules/PhotoacousticsLib/test/mitkSpectralUnmixingTest.cpp b/Modules/PhotoacousticsLib/test/mitkSpectralUnmixingTest.cpp
index 17c20cdd80..d87bf16208 100644
--- a/Modules/PhotoacousticsLib/test/mitkSpectralUnmixingTest.cpp
+++ b/Modules/PhotoacousticsLib/test/mitkSpectralUnmixingTest.cpp
@@ -1,49 +1,93 @@
 ///*===================================================================
 
 //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 <mitkTestFixture.h>
 #include <mitkTestingMacros.h>
 
 #include <mitkPASpectralUnmixingFilterBase.h>
 
 class mitkSpectralUnmixingTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkSpectralUnmixingTestSuite);
   MITK_TEST(testSUAlgorithm);
   CPPUNIT_TEST_SUITE_END();
 
 private:
   mitk::pa::SpectralUnmixingFilterBase::Pointer m_SpectralUnmixingFilter;
 
 public:
 
   void setUp() override
   {
   }
 
   void testSUAlgorithm()
   {
     // INSERT TEST HERE?
     MITK_INFO << "TEST TEST";
+
+
+
   }
 
 
+
+
   void tearDown() override
   {
     m_SpectralUnmixingFilter = nullptr;
   }
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkSpectralUnmixing)
+
+
+//++++++++++++++++++++++ erstmal (TM) verworfen:+++++++++++++++++++++++++++++++++++
+/* relativ aufwenig ggf Bild laden
+void creatInputImage()
+{
+unsigned int xDim = 1;
+unsigned int yDim = 1;
+unsigned int zDim = 3;
+
+mitk::Image *inputImage;
+
+mitk::PixelType pixelType = mitk::MakeScalarPixelType<float>();
+const int NUMBER_OF_SPATIAL_DIMENSIONS = 3;
+auto* dimensions = new unsigned int[NUMBER_OF_SPATIAL_DIMENSIONS];
+dimensions[0] = xDim;
+dimensions[1] = yDim;
+dimensions[2] = zDim;
+
+inputImage->Initialize(pixelType, NUMBER_OF_SPATIAL_DIMENSIONS, dimensions);
+
+float value;
+mitk::ImageWriteAccessor writeOutput(inputImage);
+
+
+for (int x = 0; x < xDim; ++x)
+{
+for (int y = 0; y < yDim; ++y)
+{
+for (int z = 0; z < zDim; ++z)
+{
+float* writeBuffer = (float *)writeOutput.GetData();
+writeBuffer[x*yDim + y] = value;
+}
+}
+}
+
+
+}/**/