itkTensorReconstructionWithEigenvalueCorrectionFilter.h

Go to the documentation of this file.

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

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 _itk_TensorReconstructionWithEigenvalueCorrectionFilter_h_
#define _itk_TensorReconstructionWithEigenvalueCorrectionFilter_h_

#include "itkImageToImageFilter.h"
#include <itkDiffusionTensor3D.h>
#include <itkVectorImage.h>
#include <vnl/algo/vnl_symmetric_eigensystem.h>

#include <math.h>



namespace itk
{

  template <class TDiffusionPixelType, class TTensorPixelType>
  class TensorReconstructionWithEigenvalueCorrectionFilter
    : public ImageToImageFilter< itk::Image< TDiffusionPixelType, 3 >, itk::Image<itk::DiffusionTensor3D<TTensorPixelType>,3> >
  {

  public:


    typedef itk::VectorImage<short, 3>  ImageType;



    typedef TensorReconstructionWithEigenvalueCorrectionFilter                  Self;
    typedef SmartPointer<Self>                          Pointer;
    typedef SmartPointer<const Self>                    ConstPointer;



    typedef ImageToImageFilter< Image< TDiffusionPixelType, 3>,
      Image< DiffusionTensor3D< TTensorPixelType >, 3 > >
      Superclass;

    itkFactorylessNewMacro(Self)
    itkCloneMacro(Self)

    itkTypeMacro(TensorReconstructionWithEigenvalueCorrectionFilter, ImageToImageFilter)


    typedef typename itk::Image<itk::DiffusionTensor3D<TTensorPixelType>,3> OutputType;
    typedef TDiffusionPixelType                       GradientPixelType;
    typedef DiffusionTensor3D< TTensorPixelType >     TensorPixelType;

    typedef Image< TensorPixelType, 3 >              TensorImageType;

    typedef typename Superclass::OutputImageRegionType
      OutputImageRegionType;


    typedef VectorImage< GradientPixelType, 3 >      GradientImagesType;
    typedef typename GradientImagesType::PixelType         GradientVectorType;



    typedef vnl_vector_fixed< double, 3 >            GradientDirectionType;

    typedef VectorContainer< unsigned int,
      GradientDirectionType >                  GradientDirectionContainerType;



    void SetGradientImage( GradientDirectionContainerType *,
      const GradientImagesType *image);





    itkSetMacro( BValue, TTensorPixelType)

    itkSetMacro( B0Threshold, double)

    itkGetMacro(PseudoInverse, vnl_matrix<double>)

    itkGetMacro(CorrectedDiffusionVolumes, ImageType::Pointer)

    itkGetMacro(H, vnl_matrix<double>)

    itkGetMacro(BVec, vnl_vector<double>)

    itkGetMacro(B0Mask, vnl_vector<short>)


    ImageType::Pointer GetGradientImagePointer()
    {
      return m_GradientImagePointer;
    }

    itk::Image<short, 3>::Pointer GetMask()
    {
      return m_MaskImage;
    }


  protected:

    TensorReconstructionWithEigenvalueCorrectionFilter();
    ~TensorReconstructionWithEigenvalueCorrectionFilter() {}


    void GenerateData();


    typedef enum
    {
      GradientIsInASingleImage = 1,
      GradientIsInManyImages,
      Else
    } GradientImageTypeEnumeration;



  private:

    double CheckNeighbours(int x, int y, int z,int f, itk::Size<3> size, itk::Image<short, 3> ::Pointer mask,typename GradientImagesType::Pointer corrected_diffusion_temp);

    void CalculateAttenuation(vnl_vector<double> org_data, vnl_vector<double> &atten,int nof,int numberb0);


    void CorrectDiffusionImage(int nof,int numberb0,itk::Size<3> size,typename GradientImagesType::Pointer corrected_diffusion,itk::Image<short, 3>::Pointer mask,vnl_vector< double> pixel_max,vnl_vector< double> pixel_min);

    void GenerateTensorImage(int nof,int numberb0,itk::Size<3> size,itk::VectorImage<short, 3>::Pointer corrected_diffusion,itk::Image<short, 3>::Pointer mask,double what_mask, typename itk::Image< itk::DiffusionTensor3D<TTensorPixelType>, 3 >::Pointer tensorImg );

    //void DeepCopyTensorImage(itk::Image< itk::DiffusionTensor3D<double>, 3 >::Pointer tensorImg, itk::Image< itk::DiffusionTensor3D<double>, 3 >::Pointer temp_tensorImg);

    //void DeepCopyDiffusionImage(itk::VectorImage<short, 3>::Pointer corrected_diffusion, itk::VectorImage<short, 3>::Pointer corrected_diffusion_temp,int nof);


    void TurnMask( itk::Size<3> size, itk::Image<short, 3>::Pointer mask, double previous_mask, double set_mask);

    double CheckNegatives ( itk::Size<3> size, itk::Image<short, 3>::Pointer mask, typename itk::Image< itk::DiffusionTensor3D<TTensorPixelType>, 3 >::Pointer tensorImg );


    GradientImageTypeEnumeration                      m_GradientImageTypeEnumeration;

    unsigned int                                      m_NumberOfGradientDirections;

    GradientDirectionContainerType::Pointer           m_GradientDirectionContainer;


    TTensorPixelType                                  m_BValue;

    unsigned int                                      m_NumberOfBaselineImages;

    ImageType::Pointer                                m_CorrectedDiffusionVolumes;

    double                                             m_B0Threshold;


    itk::Image<short, 3>::Pointer m_MaskImage;

    vnl_matrix<double> m_PseudoInverse;

    vnl_matrix<double> m_H;

    vnl_vector<double> m_BVec;

    vnl_vector<short> m_B0Mask;

    typename GradientImagesType::Pointer m_GradientImagePointer;

  };






} // end of namespace


#ifndef ITK_MANUAL_INSTANTIATION
#include "itkTensorReconstructionWithEigenvalueCorrectionFilter.txx"
#endif


#endif