itkMultiScaleHessianBasedMeasureImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMultiScaleHessianBasedMeasureImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2010-02-04 12:16:43 $
  Version:   $Revision: 1.10 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkMultiScaleHessianBasedMeasureImageFilter_h
#define __itkMultiScaleHessianBasedMeasureImageFilter_h

#include "itkImageToImageFilter.h"
#include "itkImage.h"
#include "itkHessianRecursiveGaussianImageFilter.h"

namespace itk
{
template <typename TInputImage,
          typename THessianImage, 
          typename TOutputImage=TInputImage >
class ITK_EXPORT MultiScaleHessianBasedMeasureImageFilter 
: public
ImageToImageFilter< TInputImage,TOutputImage > 
{
public:
  typedef MultiScaleHessianBasedMeasureImageFilter          Self;
  typedef ImageToImageFilter<TInputImage,TOutputImage>      Superclass;

  typedef SmartPointer<Self>                                      Pointer;
  typedef SmartPointer<const Self>                                ConstPointer;

  typedef TInputImage                                    InputImageType;
  typedef TOutputImage                                   OutputImageType;
  typedef THessianImage                                  HessianImageType;

  typedef ImageToImageFilter< HessianImageType, OutputImageType  >  HessianToMeasureFilterType;

  typedef typename TInputImage::PixelType                InputPixelType;
  typedef typename TOutputImage::PixelType               OutputPixelType;
  typedef typename TOutputImage::RegionType              OutputRegionType;
 
  itkStaticConstMacro(ImageDimension, unsigned int, ::itk::GetImageDimension<InputImageType>::ImageDimension);

  typedef float                                          ScalesPixelType;
  typedef Image<ScalesPixelType, itkGetStaticConstMacro(ImageDimension)>  ScalesImageType;

  typedef HessianRecursiveGaussianImageFilter< InputImageType, HessianImageType> HessianFilterType;

  typedef Image< double, itkGetStaticConstMacro(ImageDimension) > UpdateBufferType;
  typedef typename UpdateBufferType::ValueType                    BufferValueType;

  typedef typename Superclass::DataObjectPointer          DataObjectPointer;
  
  itkNewMacro(Self);

  itkTypeMacro(MultiScaleHessianBasedMeasureImageFilter, 
                 ImageToImageFilter);

  itkSetMacro(SigmaMinimum, double);
  itkGetConstMacro(SigmaMinimum, double);

  itkSetMacro(SigmaMaximum, double);
  itkGetConstMacro(SigmaMaximum, double);

  itkSetMacro(NumberOfSigmaSteps, unsigned int);
  itkGetConstMacro(NumberOfSigmaSteps, unsigned int);

  itkSetObjectMacro( HessianToMeasureFilter, HessianToMeasureFilterType); 
  itkGetObjectMacro( HessianToMeasureFilter, HessianToMeasureFilterType); 

  itkSetMacro(NonNegativeHessianBasedMeasure,bool);
  itkGetConstMacro(NonNegativeHessianBasedMeasure,bool);
  itkBooleanMacro(NonNegativeHessianBasedMeasure);

  typedef enum { EquispacedSigmaSteps = 0,
                 LogarithmicSigmaSteps = 1 } SigmaStepMethodType;

  itkSetMacro(SigmaStepMethod, SigmaStepMethodType);
  itkGetConstMacro(SigmaStepMethod, SigmaStepMethodType);

  void SetSigmaStepMethodToEquispaced();

  void SetSigmaStepMethodToLogarithmic();

  const HessianImageType* GetHessianOutput() const;

  const ScalesImageType* GetScalesOutput() const;

  void EnlargeOutputRequestedRegion (DataObject *);

  itkSetMacro(GenerateScalesOutput,bool);
  itkGetConstMacro(GenerateScalesOutput,bool);
  itkBooleanMacro(GenerateScalesOutput);

  itkSetMacro(GenerateHessianOutput,bool);
  itkGetConstMacro(GenerateHessianOutput,bool);
  itkBooleanMacro(GenerateHessianOutput);

  virtual DataObjectPointer MakeOutput(unsigned int idx);

protected:
  MultiScaleHessianBasedMeasureImageFilter();
  ~MultiScaleHessianBasedMeasureImageFilter() {};
  void PrintSelf(std::ostream& os, Indent indent) const;
  
  void GenerateData( void );

private:
  void UpdateMaximumResponse(double sigma);
  double ComputeSigmaValue(int scaleLevel);
  
  void AllocateUpdateBuffer();

  //purposely not implemented
  MultiScaleHessianBasedMeasureImageFilter(const Self&); 
  void operator=(const Self&); //purposely not implemented

  bool                        m_NonNegativeHessianBasedMeasure;

  double                      m_SigmaMinimum;
  double                      m_SigmaMaximum;

  unsigned int                m_NumberOfSigmaSteps;
  SigmaStepMethodType         m_SigmaStepMethod;

  typename HessianToMeasureFilterType::Pointer  m_HessianToMeasureFilter;
  typename HessianFilterType::Pointer           m_HessianFilter;
  typename UpdateBufferType::Pointer            m_UpdateBuffer;

  bool m_GenerateScalesOutput;
  bool m_GenerateHessianOutput;
};

} // end namespace itk

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