itkSphericalPolarFourierEstimationImageFilter.h

Go to the documentation of this file.

#ifndef __itkSphericalPolarFourierEstimationImageFilter_h
#define __itkSphericalPolarFourierEstimationImageFilter_h

#include "itkDiffusionModelEstimationInSphericalCoordinateImageFilter.h"

#include "itkL2RegularizedLeastSquaresSolver.h"
#include "itkL1RegularizedLeastSquaresFISTASolver.h"
#include "itkSpamsWeightedLassoSolver.h"

namespace itk
{

template < class TInputImage, class TOutputImage >
class ITK_EXPORT SphericalPolarFourierEstimationImageFilter :
  public DiffusionModelEstimationInSphericalCoordinateImageFilter<TInputImage, TOutputImage>
{
public:
  typedef SphericalPolarFourierEstimationImageFilter         Self;
  typedef DiffusionModelEstimationInSphericalCoordinateImageFilter<TInputImage,TOutputImage>  Superclass;
  typedef SmartPointer<Self>                            Pointer;
  typedef SmartPointer<const Self>                      ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro( SphericalPolarFourierEstimationImageFilter, DiffusionModelEstimationInSphericalCoordinateImageFilter );
  
  itkTypedefMaskedImageToImageMacro(Superclass);

  typedef typename Superclass::MatrixType         MatrixType;
  typedef typename Superclass::VectorType         VectorType;
  typedef typename Superclass::MatrixPointer      MatrixPointer;
  typedef typename Superclass::VectorPointer      VectorPointer;
  typedef typename Superclass::STDVectorType      STDVectorType;
  typedef typename Superclass::STDVectorPointer   STDVectorPointer;

  typedef enum 
    {
    LS=0, 
    L1_2,
    L1_DL
    } EstimationType;
  
  typedef enum 
    {
    FISTA_LS=0, 
    SPAMS
    } L1SolverType;

  typedef L2RegularizedLeastSquaresSolver<double> L2SolverType;
  typedef L1RegularizedLeastSquaresFISTASolver<double> L1FISTASolverType;
  typedef SpamsWeightedLassoSolver<double> L1SpamsSolverType;

  itkSetMacro(EstimationType, EstimationType);
  itkGetMacro(EstimationType, EstimationType);
  
  itkSetMacro(L1SolverType, L1SolverType);
  itkGetMacro(L1SolverType, L1SolverType);
  
  // itkSetMacro(NeedToConvertToQValue,bool);
  // itkGetMacro(NeedToConvertToQValue,bool);
  
  itkSetMacro(BasisCombinationMatrix, MatrixPointer);
  itkGetMacro(BasisCombinationMatrix, MatrixPointer);
  itkSetMacro(BasisEnergyDL, VectorPointer);
  itkGetMacro(BasisEnergyDL, VectorPointer);
  itkSetMacro(BasisEnergyPowerDL, double);
  itkGetMacro(BasisEnergyPowerDL, double);
  
  // itkSetMacro(RegularizationWeight, VectorPointer);
  itkGetMacro(RegularizationWeight, VectorPointer);
  
  itkSetMacro(IsOriginalBasis,bool);
  itkGetMacro(IsOriginalBasis,bool);
  itkBooleanMacro(IsOriginalBasis);
  
  itkSetMacro(LambdaSpherical, double);
  itkGetMacro(LambdaSpherical, double);
  itkSetMacro(LambdaRadial, double);
  itkGetMacro(LambdaRadial, double);
  itkSetMacro(LambdaL1, double);
  itkGetMacro(LambdaL1, double);


  virtual void SetBasisScale(const double scale);
  itkGetMacro(BasisScale, double);
  
  itkSetObjectMacro(MDImage, ScalarImageType);
  itkGetObjectMacro(MDImage, ScalarImageType);
  itkGetConstObjectMacro(MDImage, ScalarImageType);
  
  itkSetObjectMacro(ScaleImage, ScalarImageType);
  itkGetObjectMacro(ScaleImage, ScalarImageType);
  itkGetConstObjectMacro(ScaleImage, ScalarImageType);

  itkSetGetBooleanMacro(IsAnalyticalB0);
  
  itkSetMacro(B0Weight,double);
  itkGetMacro(B0Weight,double);
  
  itkSetMacro(L1FISTASolver, typename L1FISTASolverType::Pointer);
  itkSetMacro(L1SpamsSolver, typename L1SpamsSolverType::Pointer);

  virtual std::vector<int> DimToRank(const int dimm) const 
    {return std::vector<int>();}
  virtual int RankToDim(const bool is_radial=false, const int radialRank=-1, const int shRank=-1) const  
    {return -1;}

  virtual std::vector<int> GetIndexNLM(const int index) const
    {return std::vector<int>();}; 
  virtual int GetIndexJ(const int n, const int l, const int m) const
    {return -1;};

  virtual double ComputeScale(const bool setScale=true);

  bool IsAdaptiveScale() const 
    {
    return !IsImageEmpty(this->m_MDImage);
    }
  
protected:
  SphericalPolarFourierEstimationImageFilter();
  virtual ~SphericalPolarFourierEstimationImageFilter()
    {};
  
  void VerifyInputParameters() const ITK_OVERRIDE;
  
  void InitializeThreadedLibraries() ITK_OVERRIDE;
  
  void GenerateOutputInformation() ITK_OVERRIDE;

  void BeforeThreadedGenerateData () ITK_OVERRIDE;

  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
  typename LightObject::Pointer InternalClone() const ITK_OVERRIDE;
  

  double m_BasisScale;
  
  double m_LambdaSpherical;
  double m_LambdaRadial;
  double m_LambdaL1;
  double m_LambdaL2;
  
  MatrixPointer  m_BasisCombinationMatrix;
  VectorPointer  m_BasisEnergyDL;
  double m_BasisEnergyPowerDL;

  bool m_IsAnalyticalB0;
  double m_B0Weight;
  MatrixPointer m_BasisMatrixForB0;

  typename ScalarImageType::Pointer m_MDImage; 
  typename ScalarImageType::Pointer m_ScaleImage; 

  EstimationType m_EstimationType;

  typename L2SolverType::Pointer   m_L2Solver;
  typename L1FISTASolverType::Pointer   m_L1FISTASolver;
  typename L1SpamsSolverType::Pointer   m_L1SpamsSolver;
  
  L1SolverType   m_L1SolverType;
  
  bool m_IsOriginalBasis;

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

};

}

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkSphericalPolarFourierEstimationImageFilter+-.h"
#endif

#if !defined(ITK_MANUAL_INSTANTIATION) && !defined(__itkSphericalPolarFourierEstimationImageFilter_hxx)
#include "itkSphericalPolarFourierEstimationImageFilter.hxx"
#endif

#endif