itkDWIReader.h

Go to the documentation of this file.

#ifndef __itkDWIReader_h
#define __itkDWIReader_h

#include "itkImage.h"
#include "itkVectorImage.h"
#include "itkImageSource.h"
#include "utlITK.h"
#include <tr1/memory>

#include "itkSamplingSchemeQSpace.h"

namespace itk
{
template <class TPixelType, unsigned int VImageDimension = 3 >
class ITK_EXPORT DWIReader : public ImageSource< VectorImage<TPixelType, VImageDimension> >
{

public:
  typedef DWIReader             Self;
  typedef ImageSource< VectorImage<TPixelType, VImageDimension> > Superclass;
  typedef SmartPointer< Self >        Pointer;

  itkNewMacro(Self);

  itkTypeMacro(DWIReader, ImageSource);
  
  typedef Image<TPixelType, VImageDimension>       B0ImageType;
  typedef VectorImage<TPixelType, VImageDimension> DWIImageType;
  typedef Image<double, VImageDimension>           MaskImageType;
  
  typedef utl::NDArray<double,2>                     MatrixType;
  typedef utl_shared_ptr<MatrixType>                 MatrixPointer;
  typedef std::vector<double>                        STDVectorType;
  typedef utl_shared_ptr<STDVectorType >             STDVectorPointer;
  
  typedef typename DWIImageType::SizeType          SizeType;
  typedef typename DWIImageType::IndexType         IndexType;
  typedef typename DWIImageType::RegionType        RegionType;
  typedef typename DWIImageType::PixelType         PixelType;
  typedef typename DWIImageType::DirectionType     DirectionType;
  typedef typename DWIImageType::SpacingType       SpacingType;
  
  typedef typename B0ImageType::SizeType           B0SizeType;
  typedef typename B0ImageType::IndexType          B0IndexType;
  typedef typename B0ImageType::RegionType         B0RegionType;
  typedef typename B0ImageType::PixelType          B0PixelType;
  typedef typename B0ImageType::DirectionType      B0DirectionType;
  typedef typename B0ImageType::SpacingType        B0SpacingType;
  
  typedef SamplingSchemeQSpace<double>                         SamplingSchemeQSpaceType;
  typedef typename SamplingSchemeQSpaceType::Pointer           SamplingSchemeQSpacePointer;

  itkSetObjectMacro(MaskImage, MaskImageType);
  itkGetConstObjectMacro(MaskImage, MaskImageType);
  
  itkSetObjectMacro(B0Image, B0ImageType);
  itkGetObjectMacro(B0Image, B0ImageType);
  
  itkSetObjectMacro(SamplingSchemeQSpace, SamplingSchemeQSpaceType);
  itkGetObjectMacro(SamplingSchemeQSpace, SamplingSchemeQSpaceType);

  typename DWIImageType::Pointer GetDWIImage()
    {
    this->GetOutput();
    }
  
  itkSetMacro(ConfigurationFile, std::string);
  itkGetMacro(ConfigurationFile, std::string);
  
  itkSetMacro(NormalizeDWI, bool);
  itkGetMacro(NormalizeDWI, bool);
  itkBooleanMacro(NormalizeDWI);
  
  // [>* If set on, the first dimension of output DWI Image will be B0Image  <]
  // itkSetMacro(DWIWithB0, bool);
  // itkGetMacro(DWIWithB0, bool);
  // itkBooleanMacro(DWIWithB0);
  
  itkSetMacro(IsInput4DImage, bool);
  itkGetMacro(IsInput4DImage, bool);
  itkBooleanMacro(IsInput4DImage);
  
  itkSetMacro(CorrectDWIValues, bool);
  itkGetMacro(CorrectDWIValues, bool);
  itkBooleanMacro(CorrectDWIValues);
  
  itkSetMacro(ShowWarnings, bool);
  itkGetMacro(ShowWarnings, bool);
  itkBooleanMacro(ShowWarnings);
  
  void ReadFromConfigurationFile(const std::string& file);
  
  // void ReadBGradDWI(const std::string& bFile, const std::string& gradFile, const std::string& imageFile, const std::string& indexFile="");
  
  static bool DetermineIsInput4DImage(const std::string& dataStr);
  
  void NormalizeDWI();

  void CorrectDWI();
  
protected:
  DWIReader();
  virtual ~DWIReader(){}
 
  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
 
  virtual void GenerateData() ITK_OVERRIDE;
 
private:
  DWIReader(const Self &); //purposely not implemented
  void operator=(const Self &);  //purposely not implemented

  SamplingSchemeQSpacePointer m_SamplingSchemeQSpace;

  bool m_NormalizeDWI;
  // bool m_DWIWithB0;
  bool m_IsInput4DImage;
  bool m_CorrectDWIValues;

  std::string m_ConfigurationFile;
  
  bool m_ShowWarnings;

  typename MaskImageType::Pointer m_MaskImage;
  typename B0ImageType::Pointer m_B0Image;
};

}

#if !defined(ITK_MANUAL_INSTANTIATION) && !defined(__itkDWIReader_hxx)
#include "itkDWIReader.hxx"
#endif

#endif