mitkPASpectralUnmixingFilterBase.h

Go to the documentation of this file.

/*============================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.

Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.

============================================================================*/

#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);

      void AddChromophore(mitk::pa::PropertyCalculator::ChromophoreType chromophore);

      void AddWavelength(int wavelength);

      /*
      * \brief Verbose gives more information to the console. Default value is false.
      * @param verbose is the boolian to activate the MITK_INFO logged to the console
      */
      virtual void Verbose(bool verbose);

      virtual void AddOutputs(unsigned int outputs);

      /*
      * \brief RelativeError returns a image which compare the L2 norm of the input vector with the unmixing result
      * @param relativeError is the boolian to activate this tool
      */
      virtual void RelativeError(bool relativeError);

      virtual void AddRelativeErrorSettings(int value);

      ofstream myfile; // just for testing purposes; has to be removeed

    protected:
      SpectralUnmixingFilterBase();
      ~SpectralUnmixingFilterBase() override;

      virtual Eigen::VectorXf SpectralUnmixingAlgorithm(Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> endmemberMatrix,
        Eigen::VectorXf inputVector) = 0;

      bool m_Verbose = false;
      bool m_RelativeError = false;

      std::vector<mitk::pa::PropertyCalculator::ChromophoreType> m_Chromophore;
      std::vector<int> m_Wavelength;
      std::vector<int> m_RelativeErrorSettings;

    private:
      /*
      * \brief Initialized output images with the same XY-plane size like the input image and total size in z-direction equals number of sequences.
      * The pixel type is set to float.
      * @param totalNumberOfSequences = (unsigned int) (numberOfInputImages / numberOfWavelength) >= 1
      */
      virtual void InitializeOutputs(unsigned int totalNumberOfSequences);

      /*
      * \brief Checks if there are a suitable amount of wavelengths and if the input image consists of floats.
      * @param input pointer on the MITK input image
      * @throws if there are more wavelength then images
      * @throws if there are more chromophores then wavelengths
      * @throws if the pixel type is not float 32
      * @throws if no chromophores or wavelengths selected as input
      * @throws if the number of indexed outputs does'nt fit to the expected number
      */
      virtual void CheckPreConditions(mitk::Image::Pointer input);

      /*
      * \brief Inherit from the "ImageToImageFilter" Superclass. Herain it calls InitializeOutputs, CalculateEndmemberMatrix and
      * CheckPreConditions methods and enables pixelwise access to do spectral unmixing with the "SpectralUnmixingAlgorithm"
      * method. In the end the method writes the results into the new MITK output images.
      */
      void GenerateData() override;

      /*
      * \brief Creats a Matrix with number of chromophores colums and number of wavelengths rows so matrix element (i,j) contains
      * the absorbtion of chromophore j @ wavelength i. The absorbtion values are taken from the "PropertyElement" method.
      * @param m_Chromophore is a vector of "PropertyCalculator::ChromophoreType" containing all selected chromophores for the unmixing
      * @param m_Wavelength is a vector of integers containing all wavelengths of one sequence
      */
      virtual Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> CalculateEndmemberMatrix(
        std::vector<mitk::pa::PropertyCalculator::ChromophoreType> m_Chromophore, std::vector<int> m_Wavelength);

      /*
      * \brief "PropertyElement" is the tool to access the absorbtion values out of the database using mitk::pa::PropertyCalculator::GetAbsorptionForWavelengt
      * and checks if the requested wavelength is part of the database (not zero values). The "ONEENDMEMBER" is a pseudo absorber with static absorbtion 1
      * at every wavelength and is therefor not part of the database. If this one is the selected chromophore the return value is 1 for every wavelength.
      * @param wavelength has to be integer between 300 and 1000 nm
      * @param chromophore has to be a mitk::pa::PropertyCalculator::ChromophoreType
      * @throws if mitk::pa::PropertyCalculator::GetAbsorptionForWavelengt returns 0, because this means that the delivered wavelength is not in the database.
      */
      virtual float PropertyElement(mitk::pa::PropertyCalculator::ChromophoreType, int wavelength);

      /*
      * \brief calculates the relative error between the input image and the unmixing result in the L2 norm
      * @param endmemberMatrix is a Eigen matrix containing the endmember information
      * @param inputVector is a Eigen vector containing the multispectral information of one pixel
      * @param resultVector is a Eigen vector containing the spectral unmmixing result
      */
      float CalculateRelativeError(Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> endmemberMatrix,
        Eigen::VectorXf inputVector, Eigen::VectorXf resultVector);

      PropertyCalculator::Pointer m_PropertyCalculatorEigen;
    };
  }
}
#endif // MITKPHOTOACOUSTICSPECTRALUNMIXINGFILTERBASE_