itkDiffusionQballReconstructionImageFilter.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 __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;

  itkFactorylessNewMacro(Self)
  itkCloneMacro(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( const 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, ThreadIdType);

  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_