itkOdfMaximaExtractionFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkDiffusionTensor3DReconstructionImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2006-03-27 17:01:06 $
  Version:   $Revision: 1.12 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkOdfMaximaExtractionFilter_h_
#define __itkOdfMaximaExtractionFilter_h_

#include <mitkFiberBundle.h>

#include <itkImageToImageFilter.h>
#include <itkVectorContainer.h>
#include <itkOrientationDistributionFunction.h>
#include <itkAnalyticalDiffusionQballReconstructionImageFilter.h>

namespace itk{
template< class TOdfPixelType >
class OdfMaximaExtractionFilter : public ProcessObject
{

public:

  enum NormalizationMethods {
    NO_NORM,            
    SINGLE_VEC_NORM,    
    MAX_VEC_NORM        
  };

  typedef OdfMaximaExtractionFilter Self;
  typedef SmartPointer<Self>                      Pointer;
  typedef SmartPointer<const Self>                ConstPointer;
  typedef ProcessObject Superclass;

  itkFactorylessNewMacro(Self)
  itkCloneMacro(Self)

  itkTypeMacro(OdfMaximaExtractionFilter, ImageToImageFilter)

  typedef itk::AnalyticalDiffusionQballReconstructionImageFilter<short,short,float,4,QBALL_ODFSIZE> QballReconstructionFilterType;
  typedef QballReconstructionFilterType::CoefficientImageType                                       CoefficientImageType;
  typedef CoefficientImageType::PixelType                                                           CoefficientPixelType;
  typedef itk::VectorImage< short, 3 >                                                              DiffusionImageType;
  typedef vnl_vector_fixed< double, 3 >                                                             Vector3D;
  typedef VectorContainer< unsigned int, Vector3D >                                                 DirectionContainerType;
  typedef VectorContainer< unsigned int, DirectionContainerType::Pointer >                          ContainerType;
  typedef itk::Image<unsigned char, 3>                                                              ItkUcharImgType;
  typedef itk::Image< itk::Vector< float, 3 >, 3>                                                   ItkDirectionImage;
  typedef itk::VectorContainer< unsigned int, ItkDirectionImage::Pointer >                          ItkDirectionImageContainer;

  // output
  itkGetMacro( OutputFiberBundle, mitk::FiberBundle::Pointer)                  
  itkGetMacro( NumDirectionsImage, ItkUcharImgType::Pointer)                    
  itkGetMacro( DirectionImageContainer, ItkDirectionImageContainer::Pointer)    

  // input
  itkSetMacro( MaskImage, ItkUcharImgType::Pointer)                 
  itkSetMacro( NormalizationMethod, NormalizationMethods)           
  itkSetMacro( DiffusionGradients, DirectionContainerType::Pointer) 
  itkSetMacro( DiffusionImage, DiffusionImageType::Pointer)         
  itkSetMacro( Bvalue, float)                                       
  itkSetMacro( ShCoeffImage, CoefficientImageType::Pointer)         
  itkSetMacro( MaxNumPeaks, unsigned int)                           
  itkSetMacro( PeakThreshold, double)                               

  void GenerateData() override;

protected:
  OdfMaximaExtractionFilter();
  ~OdfMaximaExtractionFilter(){}

  bool ReconstructQballImage();

  std::vector<double> SolveCubic(const double& a, const double& b, const double& c, const double& d);

  double ODF_dtheta2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);

  double ODF_dphi2(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);

  double ODF_dtheta(const double& sn, const double& cs, const double& A, const double& B, const double& C, const double& D, const double& E, const double& F, const double& G, const double& H);

  void FindCandidatePeaks(const CoefficientPixelType& SHcoeff);

  std::vector< Vector3D > ClusterPeaks(const CoefficientPixelType& shCoeff);

  void Cart2Sph(const std::vector< Vector3D >& dir,  vnl_matrix<double>& sphCoords);
  vnl_matrix<double> CalcShBasis(vnl_matrix<double>& sphCoords, const int& shOrder);

  // diffusion weighted image (mandatory input)
  DirectionContainerType::Pointer           m_DiffusionGradients;   
  DiffusionImageType::Pointer               m_DiffusionImage;       
  float                                     m_Bvalue;               

  // binary mask image (optional input)
  ItkUcharImgType::Pointer                  m_MaskImage;            

  // input parameters
  NormalizationMethods                      m_NormalizationMethod;  
  double                                    m_PeakThreshold;        
  unsigned int                              m_MaxNumPeaks;          

  // intermediate results
  CoefficientImageType::Pointer                 m_ShCoeffImage;     
  std::vector< vnl_vector_fixed< double, 2 > >  m_CandidatePeaks;   

  // output data
  mitk::FiberBundle::Pointer               m_OutputFiberBundle;        
  ItkUcharImgType::Pointer                  m_NumDirectionsImage;       
  ItkDirectionImageContainer::Pointer       m_DirectionImageContainer;  

private:

};

}

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkOdfMaximaExtractionFilter.cpp"
#endif

#endif //__itkOdfMaximaExtractionFilter_h_