itkImageToImageMetricWithFeatures.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright UMC Utrecht and contributors
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkImageToImageMetricWithFeatures_h
#define __itkImageToImageMetricWithFeatures_h
 
#include "itkAdvancedImageToImageMetric.h"
#include "itkInterpolateImageFunction.h"
 
namespace itk
{
 
template< class TFixedImage, class TMovingImage,
class TFixedFeatureImage = TFixedImage, class TMovingFeatureImage = TMovingImage >
class ImageToImageMetricWithFeatures :
  public AdvancedImageToImageMetric< TFixedImage, TMovingImage >
{
public:
 
  typedef ImageToImageMetricWithFeatures                          Self;
  typedef AdvancedImageToImageMetric< TFixedImage, TMovingImage > Superclass;
  typedef SmartPointer< Self >                                    Pointer;
  typedef SmartPointer< const Self >                              ConstPointer;
 
  itkTypeMacro( ImageToImageMetricWithFeatures, AdvancedImageToImageMetric );
 
  typedef typename Superclass::CoordinateRepresentationType    CoordinateRepresentationType;
  typedef typename Superclass::MovingImageType                 MovingImageType;
  typedef typename Superclass::MovingImagePixelType            MovingImagePixelType;
  typedef typename Superclass::MovingImageConstPointer         MovingImageConstPointer;
  typedef typename Superclass::FixedImageType                  FixedImageType;
  typedef typename Superclass::FixedImageConstPointer          FixedImageConstPointer;
  typedef typename Superclass::FixedImageRegionType            FixedImageRegionType;
  typedef typename Superclass::TransformType                   TransformType;
  typedef typename Superclass::TransformPointer                TransformPointer;
  typedef typename Superclass::InputPointType                  InputPointType;
  typedef typename Superclass::OutputPointType                 OutputPointType;
  typedef typename Superclass::TransformParametersType         TransformParametersType;
  typedef typename Superclass::TransformJacobianType           TransformJacobianType;
  typedef typename Superclass::InterpolatorType                InterpolatorType;
  typedef typename Superclass::InterpolatorPointer             InterpolatorPointer;
  typedef typename Superclass::RealType                        RealType;
  typedef typename Superclass::GradientPixelType               GradientPixelType;
  typedef typename Superclass::GradientImageType               GradientImageType;
  typedef typename Superclass::GradientImagePointer            GradientImagePointer;
  typedef typename Superclass::GradientImageFilterType         GradientImageFilterType;
  typedef typename Superclass::GradientImageFilterPointer      GradientImageFilterPointer;
  typedef typename Superclass::FixedImageMaskType              FixedImageMaskType;
  typedef typename Superclass::FixedImageMaskPointer           FixedImageMaskPointer;
  typedef typename Superclass::MovingImageMaskType             MovingImageMaskType;
  typedef typename Superclass::MovingImageMaskPointer          MovingImageMaskPointer;
  typedef typename Superclass::MeasureType                     MeasureType;
  typedef typename Superclass::DerivativeType                  DerivativeType;
  typedef typename Superclass::ParametersType                  ParametersType;
  typedef typename Superclass::FixedImagePixelType             FixedImagePixelType;
  typedef typename Superclass::MovingImageRegionType           MovingImageRegionType;
  typedef typename Superclass::ImageSamplerType                ImageSamplerType;
  typedef typename Superclass::ImageSamplerPointer             ImageSamplerPointer;
  typedef typename Superclass::ImageSampleContainerType        ImageSampleContainerType;
  typedef typename Superclass::ImageSampleContainerPointer     ImageSampleContainerPointer;
  typedef typename Superclass::InternalMaskPixelType           InternalMaskPixelType;
  typedef typename Superclass::InternalMovingImageMaskType     InternalMovingImageMaskType;
  typedef typename Superclass::MovingImageMaskInterpolatorType MovingImageMaskInterpolatorType;
  typedef typename Superclass::FixedImageLimiterType           FixedImageLimiterType;
  typedef typename Superclass::MovingImageLimiterType          MovingImageLimiterType;
  typedef typename Superclass::FixedImageLimiterOutputType     FixedImageLimiterOutputType;
  typedef typename Superclass::MovingImageLimiterOutputType    MovingImageLimiterOutputType;
 
  itkStaticConstMacro( FixedImageDimension, unsigned int,
    FixedImageType::ImageDimension );
 
  itkStaticConstMacro( MovingImageDimension, unsigned int,
    MovingImageType::ImageDimension );
 
  typedef TFixedFeatureImage                       FixedFeatureImageType;
  typedef typename FixedFeatureImageType::Pointer  FixedFeatureImagePointer;
  typedef TMovingFeatureImage                      MovingFeatureImageType;
  typedef typename MovingFeatureImageType::Pointer MovingFeatureImagePointer;
  typedef std::vector< FixedFeatureImagePointer >  FixedFeatureImageVectorType;
  typedef std::vector< MovingFeatureImagePointer > MovingFeatureImageVectorType;
 
  typedef InterpolateImageFunction< FixedFeatureImageType, double >  FixedFeatureInterpolatorType;
  typedef InterpolateImageFunction< MovingFeatureImageType, double > MovingFeatureInterpolatorType;
  typedef typename FixedFeatureInterpolatorType::Pointer             FixedFeatureInterpolatorPointer;
  typedef typename MovingFeatureInterpolatorType::Pointer            MovingFeatureInterpolatorPointer;
  typedef std::vector< FixedFeatureInterpolatorPointer >             FixedFeatureInterpolatorVectorType;
  typedef std::vector< MovingFeatureInterpolatorPointer >            MovingFeatureInterpolatorVectorType;
 
  void SetNumberOfFixedFeatureImages( unsigned int arg );
 
  itkGetConstMacro( NumberOfFixedFeatureImages, unsigned int );
 
  void SetFixedFeatureImage( unsigned int i, FixedFeatureImageType * im );
 
  void SetFixedFeatureImage( FixedFeatureImageType * im )
  {
    this->SetFixedFeatureImage( 0, im );
  }
 
 
  const FixedFeatureImageType * GetFixedFeatureImage( unsigned int i ) const;
 
  const FixedFeatureImageType * GetFixedFeatureImage( void ) const
  {
    return this->GetFixedFeatureImage( 0 );
  }
 
 
  void SetFixedFeatureInterpolator( unsigned int i, FixedFeatureInterpolatorType * interpolator );
 
  void SetFixedFeatureInterpolator( FixedFeatureInterpolatorType * interpolator )
  {
    this->SetFixedFeatureInterpolator( 0, interpolator );
  }
 
 
  const FixedFeatureInterpolatorType * GetFixedFeatureInterpolator( unsigned int i ) const;
 
  const FixedFeatureInterpolatorType * GetFixedFeatureInterpolator( void ) const
  {
    return this->GetFixedFeatureInterpolator( 0 );
  }
 
 
  void SetNumberOfMovingFeatureImages( unsigned int arg );
 
  itkGetConstMacro( NumberOfMovingFeatureImages, unsigned int );
 
  void SetMovingFeatureImage( unsigned int i, MovingFeatureImageType * im );
 
  void SetMovingFeatureImage( MovingFeatureImageType * im )
  {
    this->SetMovingFeatureImage( 0, im );
  }
 
 
  const MovingFeatureImageType * GetMovingFeatureImage( unsigned int i ) const;
 
  const MovingFeatureImageType * GetMovingFeatureImage( void ) const
  {
    return this->GetMovingFeatureImage( 0 );
  }
 
 
  void SetMovingFeatureInterpolator( unsigned int i, MovingFeatureInterpolatorType * interpolator );
 
  void SetMovingFeatureInterpolator( MovingFeatureInterpolatorType * interpolator )
  {
    this->SetMovingFeatureInterpolator( 0, interpolator );
  }
 
 
  const MovingFeatureInterpolatorType * GetMovingFeatureInterpolator( unsigned int i ) const;
 
  const MovingFeatureInterpolatorType * GetMovingFeatureInterpolator( void ) const
  {
    return this->GetMovingFeatureInterpolator( 0 );
  }
 
 
  virtual void Initialize( void );
 
protected:
 
  ImageToImageMetricWithFeatures();
  virtual ~ImageToImageMetricWithFeatures() {}
  void PrintSelf( std::ostream & os, Indent indent ) const;
 
  typedef typename Superclass::BSplineInterpolatorType        BSplineInterpolatorType;
  typedef typename BSplineInterpolatorType::Pointer           BSplineInterpolatorPointer;
  typedef std::vector< BSplineInterpolatorPointer >           BSplineFeatureInterpolatorVectorType;
  typedef typename Superclass::FixedImagePointType            FixedImagePointType;
  typedef typename Superclass::MovingImagePointType           MovingImagePointType;
  typedef typename Superclass::MovingImageDerivativeType      MovingImageDerivativeType;
  typedef typename Superclass::MovingImageContinuousIndexType MovingImageContinuousIndexType;
 
  unsigned int                        m_NumberOfFixedFeatureImages;
  unsigned int                        m_NumberOfMovingFeatureImages;
  FixedFeatureImageVectorType         m_FixedFeatureImages;
  MovingFeatureImageVectorType        m_MovingFeatureImages;
  FixedFeatureInterpolatorVectorType  m_FixedFeatureInterpolators;
  MovingFeatureInterpolatorVectorType m_MovingFeatureInterpolators;
 
  std::vector< bool >                  m_FeatureInterpolatorsIsBSpline;
  bool                                 m_FeatureInterpolatorsAreBSpline;
  BSplineFeatureInterpolatorVectorType m_MovingFeatureBSplineInterpolators;
 
  virtual void CheckForBSplineFeatureInterpolators( void );
 
private:
 
  ImageToImageMetricWithFeatures( const Self & ); // purposely not implemented
  void operator=( const Self & );                 // purposely not implemented
 
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkImageToImageMetricWithFeatures.hxx"
#endif
 
#endif // end #ifndef __itkImageToImageMetricWithFeatures_h