itkGradientDifferenceImageToImageMetric.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkGradientDifferenceImageToImageMetric.h,v $
  Language:  C++
  Date:      $Date: 2003/12/31 12:40:37 $
  Version:   $Revision: 1.4 $

  Copyright (c) 2002 Insight 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 __itkGradientDifferenceImageToImageMetric_h
#define __itkGradientDifferenceImageToImageMetric_h

#include "itkImageToImageMetric.h"

#include "itkPoint.h"
#include "itkCastImageFilter.h"
#include "itkResampleImageFilter.h"
#include "itkSobelOperator.h"
#include "itkNeighborhoodOperatorImageFilter.h"


namespace itk
{
template < class TFixedImage, class TMovingImage > 
class ITK_EXPORT GradientDifferenceImageToImageMetric : 
public ImageToImageMetric< TFixedImage, TMovingImage>
{
public:

  typedef GradientDifferenceImageToImageMetric    Self;
  typedef ImageToImageMetric<TFixedImage, TMovingImage >  Superclass;

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

  itkNewMacro(Self);
 
  itkTypeMacro(GradientDifferenceImageToImageMetric, ImageToImageMetric);

 
  typedef typename Superclass::RealType                 RealType;
  typedef typename Superclass::TransformType            TransformType;
  typedef typename Superclass::TransformPointer         TransformPointer;
  typedef typename Superclass::TransformParametersType  TransformParametersType;
  typedef typename Superclass::TransformJacobianType    TransformJacobianType;

  typedef typename Superclass::MeasureType              MeasureType;
  typedef typename Superclass::DerivativeType           DerivativeType;
  typedef typename Superclass::FixedImageType           FixedImageType;
  typedef typename Superclass::MovingImageType          MovingImageType;
  typedef typename Superclass::FixedImageConstPointer   FixedImageConstPointer;
  typedef typename Superclass::MovingImageConstPointer  MovingImageConstPointer;

  typedef typename TFixedImage::PixelType               FixedImagePixelType;
  typedef typename TMovingImage::PixelType              MovedImagePixelType;

  itkStaticConstMacro(FixedImageDimension, unsigned int, TFixedImage::ImageDimension);
  typedef itk::Image< FixedImagePixelType, 
                      itkGetStaticConstMacro( FixedImageDimension ) >      
                    TransformedMovingImageType;

  typedef itk::ResampleImageFilter< MovingImageType, TransformedMovingImageType >  
                                                        TransformMovingImageFilterType;

  typedef itk::Image< RealType, 
                      itkGetStaticConstMacro( FixedImageDimension ) >
                    FixedGradientImageType;

  typedef itk::CastImageFilter< FixedImageType, FixedGradientImageType > 
                                                      CastFixedImageFilterType;

  typedef typename FixedGradientImageType::PixelType FixedGradientPixelType;


  itkStaticConstMacro( MovedImageDimension, unsigned int,
                       MovingImageType::ImageDimension );

  typedef itk::Image< RealType,
                      itkGetStaticConstMacro( MovedImageDimension ) >
                    MovedGradientImageType;

  typedef itk::CastImageFilter< TransformedMovingImageType, MovedGradientImageType > 
                                                     CastMovedImageFilterType;

  typedef typename MovedGradientImageType::PixelType MovedGradientPixelType;


#if 0  

  itkGetConstObjectMacro( FixedGradientImage, FixedGradientImageType::Pointer );
  itkGetConstObjectMacro( MovedGradientImage, MovedGradientImageType::Pointer );
#endif

  void GetDerivative( const TransformParametersType & parameters,
                            DerivativeType  & derivative ) const;

  MeasureType GetValue( const TransformParametersType & parameters ) const;

  void GetValueAndDerivative( const TransformParametersType & parameters,
                              MeasureType& Value, DerivativeType& derivative ) const;

  virtual void Initialize(void) throw ( ExceptionObject );

  void WriteGradientImagesToFiles(void) const;

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

  void ComputeMovedGradientRange( void ) const;

  void ComputeVariance( void ) const;

  MeasureType ComputeMeasure( const TransformParametersType &parameters,
                              const double *subtractionFactor ) const;

  typedef NeighborhoodOperatorImageFilter<
    FixedGradientImageType, FixedGradientImageType > FixedSobelFilter;

  typedef NeighborhoodOperatorImageFilter<
    MovedGradientImageType, MovedGradientImageType > MovedSobelFilter;

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

  mutable MovedGradientPixelType m_Variance[FixedImageDimension];

  mutable MovedGradientPixelType m_MinMovedGradient[MovedImageDimension];
  mutable MovedGradientPixelType m_MaxMovedGradient[MovedImageDimension];
  mutable FixedGradientPixelType m_MinFixedGradient[FixedImageDimension];
  mutable FixedGradientPixelType m_MaxFixedGradient[FixedImageDimension];

  typename TransformMovingImageFilterType::Pointer m_TransformMovingImageFilter;
 
  typename TransformedMovingImageType::Pointer m_MovedImage;

  typename FixedGradientImageType::Pointer
     m_FixedGradientImage[itkGetStaticConstMacro( FixedImageDimension )];

  typename MovedGradientImageType::Pointer
     m_MovedGradientImage[itkGetStaticConstMacro( MovedImageDimension )];


  CastFixedImageFilterType m_CastFixedImageFilter;

  SobelOperator< FixedGradientPixelType, 
                 itkGetStaticConstMacro(FixedImageDimension) >
               m_FixedSobelOperators[FixedImageDimension];
  FixedSobelFilter m_FixedSobelFilters[FixedImageDimension];


  CastMovedImageFilterType m_CastMovedImageFilter;

  SobelOperator< MovedGradientPixelType, 
                 itkGetStaticConstMacro(MovedImageDimension) >
               m_MovedSobelOperators[MovedImageDimension];
  MovedSobelFilter m_MovedSobelFilters[MovedImageDimension];

};

} // end namespace itk

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

#endif

---