diff --git a/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilter.h b/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilter.h
index ee5a5671df..5e4b58575d 100644
--- a/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilter.h
+++ b/Modules/PhotoacousticsLib/include/mitkPASpectralUnmixingFilter.h
@@ -1,94 +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.
 
 ===================================================================*/
 
 #ifndef MITKPHOTOACOUSTICSPECTRALUNMIXINGFILTER_H
 #define MITKPHOTOACOUSTICSPECTRALUNMIXINGFILTER_H
 
 #include "mitkImageToImageFilter.h"
 
 //Includes for smart pointer usage
 #include "mitkCommon.h"
 #include "itkLightObject.h"
 
 #include <MitkPhotoacousticsLibExports.h>
 
 #include "mitkPAPropertyCalculator.h"
 #include <eigen3/Eigen/Dense>
 
 // Test with ImagePixelAccessor
 #include <mitkImagePixelAccessor.h>
 #include <mitkImagePixelWriteAccessor.h>
 
 namespace mitk {
   namespace pa {
     class MITKPHOTOACOUSTICSLIB_EXPORT SpectralUnmixingFilter : public mitk::ImageToImageFilter
     {
     public:
 
       mitkClassMacro(SpectralUnmixingFilter, mitk::ImageToImageFilter)
         itkFactorylessNewMacro(Self)
 
       //Contains all (so far) possible chromophores
       enum ChromophoreType
       {
         OXYGENATED = 1,
         DEOXYGENATED = 2
       };
 
       //Void to creat m_vector of all chosen chromophores with push back method
       void SetChromophores(ChromophoreType);
       std::vector<int> m_Chromophore;
       
       //Void to creat m_vector of all wavelengths with push back method
       void AddWavelength(int wavelength);
       std::vector<int> m_Wavelength; 
       
-      void SetDimensions(int dimension);
-      std::vector<int> m_Dimensions;
-
+    
 
       //Void to creat Eigen::Matrix of all absorbtions
       //@ specific wavelength (columns) of chromophores (rows)
       Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> AddEndmemberMatrix();
      
 
     protected:
       SpectralUnmixingFilter();
       virtual ~SpectralUnmixingFilter();
 
     private:
       virtual void GenerateData();
       PropertyCalculator::Pointer m_PropertyCalculator;
       unsigned int numberofchromophores;
       unsigned int numberofwavelengths;
       unsigned int numberOfInputs;
       unsigned int numberOfOutputs;
       long length;
 
       Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>  EndmemberMatrix;
 
       //'New':
       virtual void CheckPreConditions(unsigned int NumberOfInputImages);
 
       virtual void InitializeOutputs();
       //Eigen::VectorXd OutputVector = (Eigen::VectorXd, Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>);
       Eigen::VectorXd SpectralUnmixingAlgorithms(Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix,
         Eigen::VectorXd inputVector);
 
+
     };
   }
 }
 #endif // MITKPHOTOACOUSTICSPECTRALUNMIXINGFILTER_H
diff --git a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilter.cpp b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilter.cpp
index 82a7bc34e6..4ff387505b 100644
--- a/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilter.cpp
+++ b/Modules/PhotoacousticsLib/src/SUFilter/mitkPASpectralUnmixingFilter.cpp
@@ -1,252 +1,244 @@
 /*===================================================================
 
 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 "mitkPASpectralUnmixingFilter.h"
 
-#include <mitkImageReadAccessor.h>
-#include <mitkImageWriteAccessor.h>
-
 // Includes for AddEnmemberMatrix
 #include "mitkPAPropertyCalculator.h"
 #include <eigen3/Eigen/Dense>
 
-// Test with ImagePixelAccessor
-#include <mitkImagePixelReadAccessor.h>
-#include <mitkImagePixelWriteAccessor.h>
-
+// ImageAccessor
 #include <mitkImageReadAccessor.h>
 #include <mitkImageWriteAccessor.h>
 
+// for testing reasons:
 #include <random>
 
 mitk::pa::SpectralUnmixingFilter::SpectralUnmixingFilter()
 {
   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::SpectralUnmixingFilter::~SpectralUnmixingFilter()
 {
 
 }
 
 void mitk::pa::SpectralUnmixingFilter::AddWavelength(int wavelength)
 {
   m_Wavelength.push_back(wavelength);
 }
 
 void mitk::pa::SpectralUnmixingFilter::SetChromophores(ChromophoreType chromophore)
 {
   m_Chromophore.push_back(chromophore);
 }
 
 void mitk::pa::SpectralUnmixingFilter::GenerateData()
 {
   MITK_INFO << "GENERATING DATA..";
+  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 xDim = m_Dimensions[0];
-  unsigned int yDim = m_Dimensions[1];
-  unsigned int zDim = m_Dimensions[2];
+  MITK_INFO << "xdim: " << xDim;
+  MITK_INFO << "ydim: " << yDim;
 
-  MITK_INFO << "NumberOfInputImages: " << zDim;
+  MITK_INFO << "zdim: " << zDim;
 
   CheckPreConditions(zDim);
 
   InitializeOutputs();
   
-  itk::Index<3> idx;
 
   EndmemberMatrix = AddEndmemberMatrix();
 
+  //* IMAGE READ ACCESOR see old SU.cpp
+  
+  mitk::ImageReadAccessor readAccess(input);
+  const float* inputDataArray = ((const float*)readAccess.GetData());
+
   for (unsigned int x = 0; x < xDim; x++)
   {
-    idx[0] = x;
     for (unsigned int y = 0; y < yDim; y++)
     {
-      idx[1] = y;
-      Eigen::VectorXd inputVector(numberOfInputs);
+      Eigen::VectorXd inputVector(zDim);
       for (unsigned int z = 0; z < zDim; z++)
       {
-        idx[3] = z;
-
-        //* IMAGE READ ACCESOR see old SU.cpp
-        mitk::Image::Pointer input = GetInput(z);
-        mitk::ImageReadAccessor readAccess(input, input->GetVolumeData());
+        
         unsigned int pixelNumber = (xDim*yDim*z)+x*yDim+y;
-        auto pixel = ((const float*)readAccess.GetData())[pixelNumber];/**/
+        //MITK_INFO << pixelNumber;
+        auto pixel = inputDataArray[pixelNumber];/**/
         // --> works with 3x3x3 but not with 1000x1000x3 picture 
         
-        /* IMAGE PIXEL READ ACCESOR:
-        // Bsp.: mitkTbssImporter.cpp line 114
-        mitk::Image::Pointer data = GetInput(????);
-        mitk::ImagePixelReadAccessor<double, 3> readAccesor(data, data->GetVolumeData());
-        auto pixel = readAccesor.GetPixelByIndex(idx); /**/
-
         //float pixel = rand(); // dummy value for pixel
         
         inputVector[z] = pixel;
       }
       
       Eigen::VectorXd resultVector = SpectralUnmixingAlgorithms(EndmemberMatrix, inputVector);
 
       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]; 
       }
     }
   }
   MITK_INFO << "GENERATING DATA...[DONE]";
 }
 
-// creats vector with x, y, z dimensions as entries
-void mitk::pa::SpectralUnmixingFilter::SetDimensions(int Dimension)
-{
-  m_Dimensions.push_back(Dimension);
-}
+
+
 
 // checks if number of Inputs == added wavelengths 
 void mitk::pa::SpectralUnmixingFilter::CheckPreConditions(unsigned int NumberOfInputImages)
 {
   if (m_Wavelength.size() != NumberOfInputImages)
     mitkThrow() << "CHECK INPUTS! WAVELENGTHERROR";
   MITK_INFO << "CHECK PRECONDITIONS ...[DONE]";
 }
 
 // Initialize Outputs
 void mitk::pa::SpectralUnmixingFilter::InitializeOutputs()
 {
-  numberOfInputs = m_Dimensions[2];
+  numberOfInputs = GetNumberOfIndexedInputs();
   numberOfOutputs = GetNumberOfIndexedOutputs();
 
   //* see MitkPAVolume.cpp
   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];
+  }
   Image::Pointer m_InternalMitkImage;/**/
 
   for (unsigned int outputIdx = 0; outputIdx < numberOfOutputs; outputIdx++)
   {
-    GetOutput(outputIdx)->Initialize(GetInput(0));
+    //GetOutput(outputIdx)->Initialize(GetInput(0));
     
-    /* see MitkPAVolume.cpp :: DOESN'T WORK (TM)
+    //* see MitkPAVolume.cpp :: DOESN'T WORK (TM)
     //m_InternalMitkImage = mitk::Image::New();
     GetOutput(outputIdx)->Initialize(pixelType, NUMBER_OF_SPATIAL_DIMENSIONS, dimensions);/**/
   }
 }
 
 //Matrix with #chromophores rows and #wavelengths columns
 //so Matrix Element (j,i) contains the Absorbtion of chromophore j @ wavelength i
 Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> mitk::pa::SpectralUnmixingFilter::AddEndmemberMatrix()
 {
   numberofchromophores = m_Chromophore.size();
   numberofwavelengths = m_Wavelength.size();
 
   Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix(numberofchromophores, numberofwavelengths);
 
   //loop over j rows (Chromophores)
   for(unsigned int j =0; j < numberofchromophores; ++j)
   {
     //loop over i columns (Wavelength)
     for (unsigned int i = 0; i < numberofwavelengths; ++i)
     {
       //writes @ Matrix element (i,j) the absorbtion wavelength of the propertycalculator.cpp
       EndmemberMatrix(j,i)= m_PropertyCalculator->GetAbsorptionForWavelength(
       static_cast<mitk::pa::PropertyCalculator::MapType>(m_Chromophore[j]), m_Wavelength[i]);
       /* Test to see what gets written in the Matrix:
       MITK_INFO << "map type: " << static_cast<mitk::pa::PropertyCalculator::MapType>(m_Chromophore[j]);
       MITK_INFO << "wavelength: " << m_Wavelength[i];
       MITK_INFO << "Matrixelement: (" << j << ", " << i << ") Absorbtion: " << EndmemberMatrix(j, i);/**/
       
       if (EndmemberMatrix(j, i) == 0)
       {
         m_Wavelength.clear();
         mitkThrow() << "WAVELENGTH "<< m_Wavelength[i] << "nm NOT SUPPORTED!";
       }
     }
   }
   MITK_INFO << "GENERATING ENMEMBERMATRIX SUCCESSFUL!";
   return EndmemberMatrix;
 }
 
 // Perform SU algorithm
 Eigen::VectorXd mitk::pa::SpectralUnmixingFilter::SpectralUnmixingAlgorithms(
   Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> EndmemberMatrix, Eigen::VectorXd inputVector)
 {
   //test "solver" (input = output)
-  //Eigen::VectorXd resultVector = inputVector;
-  //return resultVector;
+  Eigen::VectorXd resultVector = inputVector;
+  return resultVector;
     
   //llt solver
-  Eigen::VectorXd resultVector = EndmemberMatrix.llt().solve(inputVector);
-  return resultVector;
+  //Eigen::VectorXd resultVector = EndmemberMatrix.llt().solve(inputVector);
+  //return resultVector;
 
   //householderqr solver
   //Eigen::VectorXd resultVector =EndmemberMatrix.householderQr().solve(inputVector);
   //return resultVector;
 
   //test other solvers https://eigen.tuxfamily.org/dox/group__TutorialLinearAlgebra.html
   // define treshold for relativ error and set value to eg. -1 ;)
   /*double relative_error = (EndmemberMatrix*inputVector - resultVector).norm() / resultVector.norm(); // norm() is L2 norm
   MITK_INFO << relative_error;/**/
 }
 
 /* +++++++++++++++++++++++++++++++++++++++++ OLD CODE: +++++++++++++++++++++++++++++++++++++++++++++++++++
 was @ generate data
 
 length = GetOutput(0)->GetDimension(0)*GetOutput(0)->GetDimension(1)*GetOutput(0)->GetDimension(2);
 
 for (int i = 0; i < length; i++)
 {
 Eigen::VectorXd b(numberOfInputs);
 for (unsigned int j = 0; j < numberOfInputs; j++)
 {
 mitk::Image::Pointer input = GetInput(j);
 mitk::ImageReadAccessor readAccess(input, input->GetVolumeData());
 b(j) = ((const float*)readAccess.GetData())[i];
 }
 
 Eigen::Vector3d x = EndmemberMatrix.householderQr().solve(b);
 
 
 if (i == 0)
 {
 MITK_INFO << "for i=0 b(#Inputs)";
 MITK_INFO << b;
 MITK_INFO << "EndmemberMatrix";
 MITK_INFO << EndmemberMatrix;
 MITK_INFO << "x";
 MITK_INFO << x;
 }
 
 
 for (unsigned int outputIdx = 0; outputIdx < numberOfOutputs; outputIdx++)
 {
 mitk::Image::Pointer output = GetOutput(outputIdx);
 mitk::ImageWriteAccessor writeOutput(output, output->GetVolumeData());
 double* outputArray = (double *)writeOutput.GetData();
 outputArray[i] = x[outputIdx];
 }
 }
 /**/
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 ffa0e37da8..9b33b242fa 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,249 +1,212 @@
 /*===================================================================
 
 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>
 
 //test mitk image
 #include <mitkIOUtil.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkImageReadAccessor.h>
 
 // Include to perform Spectral Unmixing
 #include "mitkPASpectralUnmixingFilter.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);
 }
 
 // Add Wavelength is working, BUT in the Plugin! Not with same implementation at the filter
 // probably because the m_wavelengths vector is created new every time and not 'saved'.
 void SpectralUnmixing::Wavelength()
 {
   if (m_Wavelengths.empty())
   {
       size = 0;
   }
 
   wavelength = m_Controls.spinBoxAddWavelength->value();
   m_Wavelengths.push_back(wavelength);
   MITK_INFO << "ADD WAVELENGTH: " << wavelength << "nm";
   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 (SOON)";
+      message << "PERFORMING SPECTRAL UNMIXING ";
       if (node->GetName(name))
       {
         // a property called "name" was found for this DataNode
         message << "'" << name << "'";
       }
       message << ".";
       MITK_INFO << message.str();
 
       //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
 
       auto m_SpectralUnmixingFilter = mitk::pa::SpectralUnmixingFilter::New();
 
-      for (unsigned int i = 0; i < 3; i++)
-      {
-        m_SpectralUnmixingFilter->SetDimensions(image->GetDimension(i));
-      }
+      m_SpectralUnmixingFilter->SetInput(image);
 
 
       // Checking which chromophores wanted for SU if none throw exeption!
       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->SetChromophores(
-          mitk::pa::SpectralUnmixingFilter::ChromophoreType(1));
+          mitk::pa::SpectralUnmixingFilter::ChromophoreType::OXYGENATED);
       }
       if (DeOxbool)
       {
         numberofChromophores += 1;
         MITK_INFO << "- Deoxygenated hemoglobin";
         // Set chromophore Deoxygenated hemoglobin:
         m_SpectralUnmixingFilter->SetChromophores(
-          mitk::pa::SpectralUnmixingFilter::ChromophoreType(2));
+          mitk::pa::SpectralUnmixingFilter::ChromophoreType::DEOXYGENATED);
       }
       if (numberofChromophores == 0)
       {
         mitkThrow() << "PRESS 'IGNORE' AND CHOOSE A CHROMOPHORE!";       
       }
 
       // Checking if number of wavelengths >= number of chromophores
       if (numberofChromophores > size)
       {
         mitkThrow() << "PRESS 'IGNORE' AND ADD MORE WAVELENGTHS!";
       }
 
       //code recreaction from "old" SU.cpp
         
       MITK_INFO << "GENERATING DATA...";
       unsigned int numberOfInputs = size;
       unsigned int numberOfOutputs = numberofChromophores;
 
-      MITK_INFO << "Inputs: " << numberOfInputs << " Outputs: " << numberOfOutputs;
-            
-      mitk::DataStorage::Pointer storage = this->GetDataStorage();
-
-      mitk::DataNode::Pointer node = nodes.front();
-    
-      mitk::Image* inputImage = dynamic_cast<mitk::Image*>(data);
-
-      const unsigned int dimensions[]{
-      inputImage->GetDimension(0),
-      inputImage->GetDimension(1),
-      1 }; // just the first sequence for starters TODO GENERALIZE
-      unsigned int dimension = 3;
-      mitk::PixelType TPixel = mitk::MakeScalarPixelType<double>();
+      MITK_INFO << "Inputs: " << numberOfInputs << " Outputs: " << numberOfOutputs;  
             
       // additional wavelength implementation into fiter vector; needs "above" one 
       for (unsigned int imageIndex = 0; imageIndex < numberOfInputs; imageIndex++)
       {
-        mitk::Image::Pointer fooImage = mitk::Image::New();
-        fooImage->Initialize(TPixel, dimension, dimensions);
         wavelength = m_Wavelengths[imageIndex];
         MITK_INFO << wavelength;
         m_SpectralUnmixingFilter->AddWavelength(wavelength);
-        mitk::ImageReadAccessor inputAcc(inputImage, inputImage->GetSliceData(imageIndex));
-        fooImage->SetSlice(inputAcc.GetData(), 0);
-        m_SpectralUnmixingFilter->SetInput(imageIndex, fooImage);
+      
       }
               
       MITK_INFO << "Updating Filter...";
       
       m_SpectralUnmixingFilter->Update();
      
       mitk::Image::Pointer HbO2 = m_SpectralUnmixingFilter->GetOutput(0);
-
-      //*
-      HbO2->GetGeometry()->SetIndexToWorldTransform(inputImage->GetGeometry()->GetIndexToWorldTransform());
-           
-      mitk::ImageWriteAccessor writeOutputHbO2(HbO2, HbO2->GetVolumeData());
-      double* outputArrayHbO2 = (double *)writeOutputHbO2.GetData();/**/
-
       mitk::DataNode::Pointer dataNodeHbO2 = mitk::DataNode::New();
       dataNodeHbO2->SetData(HbO2);
       dataNodeHbO2->SetName("HbO2");
       this->GetDataStorage()->Add(dataNodeHbO2);  
        
       mitk::Image::Pointer Hb = m_SpectralUnmixingFilter->GetOutput(1);
-            
-      //*
-      Hb->GetGeometry()->SetIndexToWorldTransform(inputImage->GetGeometry()->GetIndexToWorldTransform());
-            
-      mitk::ImageWriteAccessor writeOutputHb(Hb, Hb->GetVolumeData());
-      double* outputArrayHb = (double *)writeOutputHb.GetData();/**/
-
       mitk::DataNode::Pointer dataNodeHb = mitk::DataNode::New();
       dataNodeHb->SetData(Hb);
       dataNodeHb->SetName("Hb");
       this->GetDataStorage()->Add(dataNodeHb);
       
       mitk::RenderingManager::GetInstance()->InitializeViewsByBoundingObjects(this->GetDataStorage());
 
       MITK_INFO << "Adding images to DataStorage...[DONE]";
     }
   }
 }