itkFeaturesFromSPFImageFilter.h

Go to the documentation of this file.

#ifndef __itkFeaturesFromSPFImageFilter_h
#define __itkFeaturesFromSPFImageFilter_h

#include "itkObject.h"
#include "itkMaskedImageToImageFilter.h"
#include "itkSphericalPolarFourierEstimationImageFilter.h"

namespace itk
{  

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

  itkNewMacro(Self);

  itkTypeMacro( FeaturesFromSPFImageFilter, MaskedImageToImageFilter );
  
  itkTypedefMaskedImageToImageMacro(Superclass);

  typedef utl::NDArray<double,2>                           MatrixType;
  typedef utl_shared_ptr<MatrixType>                       MatrixPointer;
  typedef utl::NDArray<double,1>                           VectorType;
  typedef utl_shared_ptr<VectorType>                       VectorPointer;
  typedef std::vector<double>                              STDVectorType;
  typedef utl_shared_ptr<STDVectorType >                   STDVectorPointer;
    
  typedef SphericalPolarFourierEstimationImageFilter<TInputImage, TOutputImage> SPFIFilterBaseType;
  
  typedef enum 
    {
    SPF=0, 
    DSPF
    } BasisType;
  
  itkSetMacro(SHRank, int);
  itkGetMacro(SHRank, int);
  itkSetMacro(RadialRank, int);
  itkGetMacro(RadialRank, int);
  
  itkSetMacro(Tau, double);
  itkGetMacro(Tau, double);
  itkSetMacro(MD0, double);
  itkGetMacro(MD0, double);

  itkSetMacro(BasisType, BasisType);
  itkGetMacro(BasisType, BasisType);
  
  itkSetMacro(Orientations, MatrixPointer);
  itkGetMacro(Orientations, MatrixPointer);

  double ComputeScale(const bool setScale=true);
  
  virtual void SetBasisScale(const double scale);
  itkGetMacro(BasisScale, double);
  
  void SetScaleImage(const ScalarImagePointer& scaleImage);
  // itkSetObjectMacro(ScaleImage, ScalarImageType);
  itkGetObjectMacro(ScaleImage, ScalarImageType);
  itkGetConstObjectMacro(ScaleImage, ScalarImageType);
  
  itkSetMacro(IsInQSpace,bool);
  itkGetMacro(IsInQSpace,bool);
  itkBooleanMacro(IsInQSpace);

  itkSetMacro(IsFourier,bool);
  itkGetMacro(IsFourier,bool);
  itkBooleanMacro(IsFourier);
  
  
  itkGetMacro(SPFToFeatureTransform, MatrixPointer);
  
  virtual void ComputeSPFToFeatureTransform() {}
  

protected:
  FeaturesFromSPFImageFilter();
  virtual ~FeaturesFromSPFImageFilter() {};

  typename LightObject::Pointer InternalClone() const ITK_OVERRIDE;
  
  virtual void VerifyInputParameters() const ITK_OVERRIDE;

  void BeforeThreadedGenerateData () ITK_OVERRIDE;
  // void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,ThreadIdType threadId );
  
  void SetSPFIEstimator();

  void PrintSelf(std::ostream& os, Indent indent) const ITK_OVERRIDE;
  
  double m_BasisScale;
  double m_MD0;
  double m_Tau;
  int m_SHRank;
  int m_RadialRank;
  typename ScalarImageType::Pointer m_ScaleImage;

  bool m_IsInQSpace;
  
  bool m_IsFourier;
  
  MatrixPointer m_SPFToFeatureTransform;
  BasisType m_BasisType;
  
  MatrixPointer m_Orientations;
    
  typename SPFIFilterBaseType::Pointer m_SPFIEstimator;

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

};

}

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

#if !defined(ITK_MANUAL_INSTANTIATION) && !defined(__itkFeaturesFromSPFImageFilter_hxx)
#include "itkFeaturesFromSPFImageFilter.hxx"
#endif




#endif