itkMultiScaleHessianBasedMeasureImageFilter.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkMultiScaleHessianBasedMeasureImageFilter.h,v $
  Language:  C++
  Date:      $Date: 2009-02-25 22:25:50 $
  Version:   $Revision: 1.4 $

  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;

  itkStaticConstMacro(ImageDimension, unsigned int, ::itk::GetImageDimension<InputImageType>::ImageDimension);

  typedef HessianRecursiveGaussianImageFilter< InputImageType, HessianImageType> HessianFilterType;

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

  itkNewMacro(Self);

  itkSetMacro(SigmaMinimum, double);
  itkGetMacro(SigmaMinimum, double);

  itkSetMacro(SigmaMaximum, double);
  itkGetMacro(SigmaMaximum, double);

  itkSetMacro(NumberOfSigmaSteps, int);
  itkGetMacro(NumberOfSigmaSteps, int);

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


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

  itkSetMacro(SigmaStepMethod, SigmaStepMethodType);
  itkGetMacro(SigmaStepMethod, SigmaStepMethodType);
  void SetSigmaStepMethodToEquispaced()
    { 
    this->SetSigmaStepMethod(Self::EquispacedSigmaSteps);
    }

  void SetSigmaStepMethodToLogarithmic()
    {
    this->SetSigmaStepMethod(Self::LogarithmicSigmaSteps);
    }

  const HessianImageType* GetHessianOutput() const
    {
    return static_cast<const HessianImageType*>(this->ProcessObject::GetOutput(2));
    }

  const OutputImageType* GetScalesOutput() const
    {
    return static_cast<const OutputImageType*>(this->ProcessObject::GetOutput(1));
    }

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

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


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

  double                      m_SigmaMinimum;
  double                      m_SigmaMaximum;

  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