itkBasicImageFeaturesImageFilter.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/

#ifndef itkBasicImageFeaturesImageFilter_h
#define itkBasicImageFeaturesImageFilter_h

#include <itkImageToImageFilter.h>
#include "itkLewisGriffinRecursiveGaussianImageFilter.h"
#include <itkMaskImageFilter.h>

#include <vnl/vnl_double_2.h>

namespace itk {
  
template<class TInputImage, class TOutputImage>
class ITK_EXPORT BasicImageFeaturesImageFilter:
    public ImageToImageFilter< TInputImage, TOutputImage >
{
public:
  typedef BasicImageFeaturesImageFilter                  Self;
  typedef ImageToImageFilter< TInputImage,TOutputImage > Superclass;
  typedef SmartPointer< Self >                           Pointer;
  typedef SmartPointer< const Self >                     ConstPointer;
  
  itkTypeMacro( BasicImageFeaturesImageFilter, ImageToImageFilter );

  itkNewMacro(Self);

  itkStaticConstMacro(ImageDimension, unsigned int,
                      TInputImage::ImageDimension);

  typedef TInputImage                           InputImageType;
  typedef typename InputImageType::Pointer      InputImagePointer;
  typedef typename InputImageType::ConstPointer InputImageConstPointer;
  typedef typename InputImageType::RegionType   InputImageRegionType;
  typedef typename InputImageType::PixelType    InputImagePixelType;
  typedef typename InputImageType::SpacingType  InputImageSpacingType;
  typedef typename InputImageType::PointType    InputImagePointType;

  typedef typename NumericTraits<InputImagePixelType>::RealType    RealType;

  typedef TOutputImage                          OutputImageType;
  typedef typename OutputImageType::Pointer     OutputImagePointer;
  typedef typename OutputImageType::RegionType  OutputImageRegionType;
  typedef typename OutputImageType::PixelType   OutputImagePixelType;
  typedef typename OutputImageType::IndexType   OutputImageIndexType;
  typedef typename OutputImageType::PointType   OutputImagePointType;

  typedef OutputImagePointType OriginType;

  typedef unsigned char                                      MaskPixelType;
  typedef typename itk::Image<MaskPixelType, ImageDimension> MaskImageType;
  typedef typename MaskImageType::Pointer                    MaskImagePointer;

  typedef typename itk::MaskImageFilter< OutputImageType, MaskImageType, OutputImageType > MaskFilterType;
  typedef typename MaskFilterType::Pointer                   MaskFilterPointer;


  typedef float InternalRealType;

  typedef Image< InternalRealType, TInputImage::ImageDimension > RealImageType;

  typedef typename RealImageType::Pointer RealImagePointer;

  typedef LewisGriffinRecursiveGaussianImageFilter < InputImageType, 
                                                     RealImageType > DerivativeFilterTypeX;
  typedef LewisGriffinRecursiveGaussianImageFilter < RealImageType,  
                                                     RealImageType > DerivativeFilterTypeY;

  typedef typename DerivativeFilterTypeX::OrderEnumType  DerivativeFilterOrderEnumTypeX;
  typedef typename DerivativeFilterTypeY::OrderEnumType  DerivativeFilterOrderEnumTypeY;
                
  typedef typename DerivativeFilterTypeX::Pointer  DerivativeFilterPointerX;
  typedef typename DerivativeFilterTypeY::Pointer  DerivativeFilterPointerY;

  void SetDebug(bool b) { itk::Object::SetDebug(b); }
  void DebugOn() { this->SetDebug(true); }
  void DebugOff() { this->SetDebug(false); }

  void SetVerbose(bool b) { itk::Object::SetGlobalWarningDisplay(b); }
  void VerboseOn() { this->SetVerbose(true); }
  void VerboseOff() { this->SetVerbose(false); }

  void SetSigma( RealType sigma );

  virtual void GenerateInputRequestedRegion()
  throw( InvalidRequestedRegionError );

  void SetNormalizeAcrossScale( bool normalizeInScaleSpace );
  itkGetConstMacro( NormalizeAcrossScale, bool );

  void CalculateOrientatedBIFs(void) {m_FlagCalculateOrientatedBIFs = true;}

  void SecondOrderOnly(void) {m_FlagSecondOrderOnly = true;}

  itkSetMacro( Epsilon, InternalRealType );
  itkGetMacro( Epsilon, InternalRealType );

  itkSetMacro( NumberOfOrientations, unsigned int );
  itkGetMacro( NumberOfOrientations, unsigned int );

  void SetOrigin( OriginType o ) {
    m_Origin = o;
    m_FlagOriginSet = true;
    this->Modified();
  }
  itkGetMacro( Origin, OriginType );

  void SetFlipHorizontally( void ) { flipHorizontally = -1.; this->Modified();}
  void SetFlipVertically( void ) { flipVertically = -1.; this->Modified();}

  void SetLocalOrientation( RealImagePointer OrientationInX, RealImagePointer OrientationInY ) {
    m_OrientationInX = OrientationInX;
    m_OrientationInY = OrientationInY;

    m_FlagLocalOrientationSet = true;
    m_FlagCalculateOrientatedBIFs = true;
    m_FlagOriginSet = false;
    this->Modified();
  }

  itkSetObjectMacro( OrientationInY, RealImageType );

  itkSetObjectMacro( Mask, MaskImageType );

  itkGetObjectMacro( S00, RealImageType );  
  itkGetObjectMacro( S10, RealImageType );  
  itkGetObjectMacro( S01, RealImageType );  
  itkGetObjectMacro( S11, RealImageType );  
  itkGetObjectMacro( S20, RealImageType );  
  itkGetObjectMacro( S02, RealImageType );  

  
  itkGetObjectMacro( ResponseFlat, RealImageType );      
  itkGetObjectMacro( ResponseSlope, RealImageType );     
  itkGetObjectMacro( ResponseDarkBlob, RealImageType );  
  itkGetObjectMacro( ResponseLightBlob, RealImageType ); 
  itkGetObjectMacro( ResponseDarkLine, RealImageType );  
  itkGetObjectMacro( ResponseLightLine, RealImageType ); 
  itkGetObjectMacro( ResponseSaddle, RealImageType );    

  itkGetObjectMacro( Orientation, RealImageType );    

  void WriteDerivativeToFile( int n, std::string filename );
  void WriteFilterResponseToFile( int n, std::string filename );

#ifdef ITK_USE_CONCEPT_CHECKING

  itkConceptMacro(DimensionShouldBe2,
      (Concept::SameDimension<itkGetStaticConstMacro(InputImageDimension),2>));
  itkConceptMacro(InputHasNumericTraitsCheck,
                  (Concept::HasNumericTraits<InputImagePixelType>));
  itkConceptMacro(OutputHasPixelTraitsCheck,
                  (Concept::HasPixelTraits<OutputImagePixelType>));
#endif

  void SetSingleThreadedExecution(void) {m_FlagMultiThreadedExecution = false;}

protected:
  BasicImageFeaturesImageFilter();
  virtual ~BasicImageFeaturesImageFilter();
  void PrintSelf(std::ostream& os, Indent indent) const;

  struct BasicImageFeaturesThreadStruct
  {
    BasicImageFeaturesImageFilter *Filter;
  };
  
  RealImagePointer GetDerivative( DerivativeFilterOrderEnumTypeX xOrder,
          DerivativeFilterOrderEnumTypeY yOrder );

  virtual void BeforeThreadedGenerateData(void);
  
  virtual void AfterThreadedGenerateData(void);
  
  void GenerateData();
  
  void ThreadedGenerateData(const OutputImageRegionType& outputRegionForThread,
                            ThreadIdType threadId );

  // Override since the filter produces the entire dataset
  void EnlargeOutputRequestedRegion(DataObject *output);

  bool m_FlagMultiThreadedExecution;

  bool m_FlagCalculateOrientatedBIFs;

  bool m_FlagLocalOrientationSet;

  unsigned int m_NumberOfOrientations;

  bool m_NormalizeAcrossScale; 
  
  bool m_FlagSecondOrderOnly;

  InternalRealType m_Epsilon; 

  InternalRealType m_Sigma; 

  bool m_FlagOriginSet;
  OriginType m_Origin;

  RealType flipHorizontally;
  RealType flipVertically;

  
  RealImagePointer m_OrientationInX; 
  RealImagePointer m_OrientationInY; 

  MaskImagePointer m_Mask;
  MaskFilterPointer m_MaskFilter;

  RealImagePointer m_S00; 
  RealImagePointer m_S10; 
  RealImagePointer m_S01; 
  RealImagePointer m_S11; 
  RealImagePointer m_S20; 
  RealImagePointer m_S02; 

  RealImagePointer m_ResponseFlat;  
  RealImagePointer m_ResponseSlope; 
  RealImagePointer m_ResponseDarkBlob;  
  RealImagePointer m_ResponseLightBlob; 
  RealImagePointer m_ResponseDarkLine;  
  RealImagePointer m_ResponseLightLine; 
  RealImagePointer m_ResponseSaddle;  

  RealImagePointer m_Orientation; 

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

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkBasicImageFeaturesImageFilter.txx"
#endif

#endif