itkDWIWriter.h

Go to the documentation of this file.

#ifndef __itkDWIWriter_h
#define __itkDWIWriter_h



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

#include "itkSamplingSchemeQSpace.h"

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

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

  itkNewMacro(Self);

  itkTypeMacro(DWIWriter, ImageSource);
  
  typedef Image<TPixelType, VImageDimension>       B0ImageType;
  typedef VectorImage<TPixelType, VImageDimension> DWIImageType;
  typedef B0ImageType                              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(SamplingSchemeQSpace, SamplingSchemeQSpaceType);
  itkGetObjectMacro(SamplingSchemeQSpace, SamplingSchemeQSpaceType);
  
  itkSetObjectMacro(MaskImage, MaskImageType);
  itkGetConstObjectMacro(MaskImage, MaskImageType);
  
  itkSetObjectMacro(B0Image, B0ImageType);
  itkGetObjectMacro(B0Image, B0ImageType);

  itkSetMacro(ConfigurationFile, std::string);
  itkGetMacro(ConfigurationFile, std::string);
  itkSetMacro(DWIFile, std::string);
  itkGetMacro(DWIFile, std::string);
  itkSetMacro(OrientationFile, std::string);
  itkGetMacro(OrientationFile, std::string);
  itkSetMacro(BFile, std::string);
  itkGetMacro(BFile, std::string);
  
  itkSetMacro(UseRelativePath, bool);
  itkGetMacro(UseRelativePath, bool);
  itkBooleanMacro(UseRelativePath);
  
  itkSetMacro(OutputEachShell, bool);
  itkGetMacro(OutputEachShell, bool);
  itkBooleanMacro(OutputEachShell);
  
  using Superclass::SetInput;
  void SetInput(const DWIImageType *input);
  const DWIImageType * GetInput();
  
  void WriteToConfigurationFile(const std::string& file);
  
  
protected:
  DWIWriter();
  virtual ~DWIWriter(){}
 
  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
 
  virtual void GenerateData() ITK_OVERRIDE;
 
private:
  DWIWriter(const Self &); //purposely not implemented
  void operator=(const Self &);  //purposely not implemented
  
  SamplingSchemeQSpacePointer m_SamplingSchemeQSpace;
  
  bool m_UseRelativePath;
  bool m_OutputEachShell;

  std::string m_ConfigurationFile;
  std::string m_DWIFile;
  std::string m_BFile;
  std::string m_OrientationFile;

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

}

#if !defined(ITK_MANUAL_INSTANTIATION) && !defined(__itkDWIWriter_hxx)
#include "itkDWIWriter.hxx"
#endif

#endif