itkDWIGeneratorBase.h

Go to the documentation of this file.

#ifndef __itkDWIGeneratorBase_h
#define __itkDWIGeneratorBase_h

#include "itkPeakContainerHelper.h"
#include "itkImage.h"
#include "itkImageSource.h"

#include <tr1/memory>
#include "itkSamplingSchemeQSpace.h"
#include "itkCylinderModelGenerator.h"

namespace itk
{
  
template <class TOutputImage, class TScalarImage=Image<double,3> >
class ITK_EXPORT DWIGeneratorBase : public ImageSource<TOutputImage>
{
public:
  typedef DWIGeneratorBase            Self;
  typedef ImageSource<TOutputImage>   Superclass;
  typedef SmartPointer<Self>          Pointer;
  
  // [>* Method for creation through the object factory. <]
  // itkNewMacro(Self);

  itkTypeMacro(DWIGeneratorBase, ImageSource);

  typedef TOutputImage  OutputImageType;
  typedef typename OutputImageType::Pointer               OutputImagePointer;
  typedef typename OutputImageType::SizeType              OutputImageSizeType;
  typedef typename OutputImageType::SpacingType           OutputImageSpacingType;
  typedef typename OutputImageType::IndexType             OutputImageIndexType;
  typedef typename OutputImageType::PointType             OutputImagePointType;
  typedef typename OutputImageType::DirectionType         OutputImageDirectionType;
  typedef typename OutputImageType::RegionType            OutputImageRegionType;
  typedef typename OutputImageType::PixelType             OutputImagePixelType;
  typedef typename OutputImageType::InternalPixelType     OutputImageInternalPixelType;

  itkStaticConstMacro(OutputImageDimension, unsigned int, OutputImageType::ImageDimension);

//  typedef Image<float, OutputImageDimension>     ScalarImageType;
  typedef TScalarImage                               ScalarImageType;
  typedef typename ScalarImageType::Pointer          ScalarImagePointer;
    
  typedef double                                           PrecisionType;
  typedef utl::NDArray<PrecisionType,2>                    MatrixType;
  typedef utl::NDArray<PrecisionType,1>                    VectorType;
  typedef utl_shared_ptr<MatrixType >                      MatrixPointer;
  typedef std::vector<PrecisionType>                       STDVectorType;
  typedef utl_shared_ptr<STDVectorType>                    STDVectorPointer;
  
  typedef typename std::vector<double>                       DiffusionParameterValuesType;
  typedef typename std::vector<DiffusionParameterValuesType> DiffusionParameterContainerType;
  
  typedef CylinderModelGenerator<double>                     CylinderModelType;
  typedef typename CylinderModelType::Pointer                CylinderModelPointer;
  
  typedef SamplingSchemeQSpace<double>                       SamplingSchemeQSpaceType;
  typedef typename SamplingSchemeQSpaceType::Pointer         SamplingSchemeQSpacePointer;
  
  typedef SamplingScheme3D<double>                           SamplingSchemeRSpaceType;
  typedef typename SamplingSchemeRSpaceType::Pointer         SamplingSchemeRSpacePointer;
  
  typedef enum 
    {
    SYMMETRICAL_TENSOR_IN_CARTESIAN_COORDS=0,
    SYMMETRICAL_TENSOR_IN_SPHERICAL_COORDS,
    TENSOR_IN_EULER_ANGLES,
    CYLINDER_SPHERICAL_MODEL
    } ModelType;
  
  itkSetEnumMacro( ModelType, ModelType );
  itkGetEnumMacro( ModelType, ModelType );
  
  itkSetObjectMacro(SamplingSchemeQSpace, SamplingSchemeQSpaceType);
  itkGetObjectMacro(SamplingSchemeQSpace, SamplingSchemeQSpaceType);

  itkSetObjectMacro(SamplingSchemeRSpace, SamplingSchemeRSpaceType);
  itkGetObjectMacro(SamplingSchemeRSpace, SamplingSchemeRSpaceType);
  
  itkSetObjectMacro(CylinderModel, CylinderModelType);
  itkGetObjectMacro(CylinderModel, CylinderModelType);

  itkSetMacro(PeakType, PeakType);
  itkGetMacro(PeakType, PeakType);
  
  itkSetMacro( B0Scale, double );
  itkGetMacro( B0Scale, double );
  
  itkSetMacro( OutputSize, OutputImageSizeType );
  itkGetMacro( OutputSize, OutputImageSizeType );
    
  unsigned int
  GetNumberOfQSpaceSamples() const
  {
    return m_SamplingSchemeQSpace->GetNumberOfSamples();
  }
  unsigned int
  GetNumberOfRSpaceSamples() const
  {
    return m_SamplingSchemeRSpace->GetNumberOfSamples();
  }
  
  itkSetMacro(NoiseSigma, double);
  itkGetMacro(NoiseSigma, double);
  itkSetMacro(SNR, double);
  itkGetMacro(SNR, double);
  itkSetMacro(ODFOrder, unsigned int);
  itkGetMacro(ODFOrder, unsigned int);
  
  itkSetMacro(MaxNumberOfPeaks, int);
  itkGetMacro(MaxNumberOfPeaks, int);
  
  itkSetGetBooleanMacro(IsOutputDWI);
  itkSetGetBooleanMacro(IsOutputEAP);
  itkSetGetBooleanMacro(IsOutputODF);
  itkSetGetBooleanMacro(IsOutputRTO);
  itkSetGetBooleanMacro(IsOutputMSD);
  
  ScalarImageType* GetB0Image()
  {
    return  dynamic_cast< ScalarImageType* >(this->ProcessObject::GetOutput(1) );
  }
  
  OutputImageType* GetDWIImage()
  {
    return  dynamic_cast< OutputImageType* >(this->ProcessObject::GetOutput(0) );
  }
  
  OutputImageType* GetODFImage()
  {
    return  dynamic_cast< OutputImageType* >(this->ProcessObject::GetOutput(2) );
  }
  
  OutputImageType* GetEAPImage()
  {
    return  dynamic_cast< OutputImageType* >(this->ProcessObject::GetOutput(3) );
  }
  
  OutputImageType* GetPeakImage()
  {
    return  dynamic_cast< OutputImageType* >(this->ProcessObject::GetOutput(4) );
  }
  
  ScalarImageType* GetRTOImage()
  {
    return  dynamic_cast< ScalarImageType* >(this->ProcessObject::GetOutput(5) );
  }
  ScalarImageType* GetMSDImage()
  {
    return  dynamic_cast< ScalarImageType* >(this->ProcessObject::GetOutput(6) );
  }

protected:
  DWIGeneratorBase();
  ~DWIGeneratorBase();

  typename LightObject::Pointer InternalClone() const ITK_OVERRIDE;
  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
  
  void GenerateData() ITK_OVERRIDE =0;
  
  virtual void Initialization();
  virtual void AllocateOutputs() ITK_OVERRIDE;
  
  SamplingSchemeQSpacePointer m_SamplingSchemeQSpace;

  SamplingSchemeRSpacePointer m_SamplingSchemeRSpace;

  bool m_IsOutputDWI;
  bool m_IsOutputODF;
  bool m_IsOutputEAP;
  bool m_IsOutputRTO;
  bool m_IsOutputMSD;
  
  double m_NoiseSigma;
  double m_SNR;

  unsigned int m_ODFOrder;
  
  ModelType m_ModelType;
  double m_B0Scale;
  
  int m_MaxNumberOfPeaks;
  PeakType m_PeakType;

  CylinderModelPointer m_CylinderModel;  
  
  OutputImageSizeType m_OutputSize;
  OutputImageSpacingType m_OutputSpacing;
  OutputImagePointType m_OutputOrigin;
  OutputImageDirectionType m_OutputDirection;

private:
  DWIGeneratorBase(const Self&); //purposely not implemented
  void operator=(const Self&); //purposely not implemented
  
  
};


} //namespace ITK


#if !defined(ITK_MANUAL_INSTANTIATION) && !defined(__itkDWIGeneratorBase_hxx)
#include "itkDWIGeneratorBase.hxx"
#endif

#endif