itkDiffusionQballReconstructionImageFilter.h

Go to the documentation of this file.

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

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date: 2009-07-14 19:11:20 +0200 (Tue, 14 Jul 2009) $
Version:   $Revision: 18127 $

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html 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 __itkDiffusionQballReconstructionImageFilter_h_
#define __itkDiffusionQballReconstructionImageFilter_h_

#include "itkImageToImageFilter.h"
//#include "vnl/vnl_matrix.h"
#include "vnl/vnl_vector_fixed.h"
#include "vnl/vnl_matrix.h"
#include "vnl/algo/vnl_svd.h"
#include "itkVectorContainer.h"
#include "itkVectorImage.h"

namespace itk{
template< class TReferenceImagePixelType, 
          class TGradientImagePixelType,
          class TOdfPixelType,
          int NrOdfDirections,
          int NrBasisFunctionCenters = NrOdfDirections>
class DiffusionQballReconstructionImageFilter :
  public ImageToImageFilter< Image< TReferenceImagePixelType, 3 >, 
                             Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > >
{

public:

  enum Normalization {
    QBR_STANDARD,
    QBR_B_ZERO_B_VALUE,
    QBR_B_ZERO,
    QBR_NONE
  };

  typedef DiffusionQballReconstructionImageFilter Self;
  typedef SmartPointer<Self>                      Pointer;
  typedef SmartPointer<const Self>                ConstPointer;
  typedef ImageToImageFilter< Image< TReferenceImagePixelType, 3>, 
          Image< Vector< TOdfPixelType, NrOdfDirections >, 3 > >
                          Superclass;
  
  itkNewMacro(Self);  

  itkTypeMacro(DiffusionQballReconstructionImageFilter, 
                                                   ImageToImageFilter);
 
  typedef TReferenceImagePixelType                 ReferencePixelType;

  typedef TGradientImagePixelType                  GradientPixelType;

  typedef Vector< TOdfPixelType, NrOdfDirections >
                                                   OdfPixelType;

  typedef typename Superclass::InputImageType      ReferenceImageType;
  
  typedef Image< OdfPixelType, 3 >                 OdfImageType;

  typedef OdfImageType                             OutputImageType;

  typedef TOdfPixelType                            BZeroPixelType;

  typedef Image< BZeroPixelType, 3 >      BZeroImageType;

  typedef typename Superclass::OutputImageRegionType
                                                   OutputImageRegionType;

  typedef Image< GradientPixelType, 3 >            GradientImageType;

  typedef VectorImage< GradientPixelType, 3 >      GradientImagesType;

  typedef vnl_matrix< TOdfPixelType >*
                                                   OdfReconstructionMatrixType;

  typedef vnl_vector_fixed< double, 3 >            GradientDirectionType;

  typedef VectorContainer< unsigned int, 
          GradientDirectionType >                  GradientDirectionContainerType;
  
  itkStaticConstMacro(NOdfDirections,int,NrOdfDirections);
  itkStaticConstMacro(NBasisFunctionCenters,int,NrBasisFunctionCenters);

  void AddGradientImage( const GradientDirectionType &, const GradientImageType *image);

  void SetGradientImage( GradientDirectionContainerType *, 
                                             const GradientImagesType *image);
  
  void SetReferenceImage( ReferenceImageType *referenceImage )
    {
    if( m_GradientImageTypeEnumeration == GradientIsInASingleImage)
      {
      itkExceptionMacro( << "Cannot call both methods:" 
      << "AddGradientImage and SetGradientImage. Please call only one of them.");
      }
  
    this->ProcessObject::SetNthInput( 0, referenceImage );

    m_GradientImageTypeEnumeration = GradientIsInManyImages;
    }
    
  virtual ReferenceImageType * GetReferenceImage() 
  { return ( static_cast< ReferenceImageType *>(this->ProcessObject::GetInput(0)) ); }

  virtual GradientDirectionType GetGradientDirection( unsigned int idx) const
    {
    if( idx >= m_NumberOfGradientDirections )
      {
      itkExceptionMacro( << "Gradient direction " << idx << "does not exist" );
      }
    return m_GradientDirectionContainer->ElementAt( idx+1 );
    }

  OdfPixelType Normalize(OdfPixelType odf, typename NumericTraits<ReferencePixelType>::AccumulateType b0 );
  
  vnl_vector<TOdfPixelType> PreNormalize( vnl_vector<TOdfPixelType> vec );
  
  itkSetMacro( Threshold, ReferencePixelType );
  itkGetMacro( Threshold, ReferencePixelType );

  itkSetMacro( NormalizationMethod, Normalization);
  itkGetMacro( NormalizationMethod, Normalization );

  itkGetMacro( BZeroImage, typename BZeroImageType::Pointer);

  itkSetMacro( BValue, TOdfPixelType);
#ifdef GetBValue
#undef GetBValue
#endif
  itkGetConstReferenceMacro( BValue, TOdfPixelType);

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(ReferenceEqualityComparableCheck,
    (Concept::EqualityComparable<ReferencePixelType>));
  itkConceptMacro(TensorEqualityComparableCheck,
    (Concept::EqualityComparable<OdfPixelType>));
  itkConceptMacro(GradientConvertibleToDoubleCheck,
    (Concept::Convertible<GradientPixelType, double>));
  itkConceptMacro(DoubleConvertibleToTensorCheck,
    (Concept::Convertible<double, OdfPixelType>));
  itkConceptMacro(GradientReferenceAdditiveOperatorsCheck,
    (Concept::AdditiveOperators<GradientPixelType, GradientPixelType,
                                ReferencePixelType>));
  itkConceptMacro(ReferenceOStreamWritableCheck,
    (Concept::OStreamWritable<ReferencePixelType>));
  itkConceptMacro(TensorOStreamWritableCheck,
    (Concept::OStreamWritable<OdfPixelType>));
#endif

protected:
  DiffusionQballReconstructionImageFilter();
  ~DiffusionQballReconstructionImageFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;

  void ComputeReconstructionMatrix();
  
  void BeforeThreadedGenerateData();
  void ThreadedGenerateData( const 
      OutputImageRegionType &outputRegionForThread, int);
  
  typedef enum
    {
    GradientIsInASingleImage = 1,
    GradientIsInManyImages,
    Else
    } GradientImageTypeEnumeration;
    
private:
  
  /* Tensor basis coeffs */
  OdfReconstructionMatrixType                       m_ReconstructionMatrix;

  GradientDirectionContainerType::Pointer           m_GradientDirectionContainer;

  unsigned int                                      m_NumberOfGradientDirections;

  unsigned int                                      m_NumberOfEquatorSamplingPoints;

  unsigned int                                      m_NumberOfBaselineImages;

  ReferencePixelType                                m_Threshold;

  TOdfPixelType                                     m_BValue;

  GradientImageTypeEnumeration                      m_GradientImageTypeEnumeration;

  typename BZeroImageType::Pointer                  m_BZeroImage;

  bool                                              m_DirectionsDuplicated;

  Normalization                                     m_NormalizationMethod;
};

}

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

#endif //__itkDiffusionQballReconstructionImageFilter_h_