itkSingleImageCostFunction.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkSingleImageCostFunction.h,v $
  Language:  C++
  Date:      $Date$
  Version:   $Revision$

  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 itkSingleImageCostFunction_h
#define itkSingleImageCostFunction_h

#include "itkNumericTraits.h"
#include "itkExceptionObject.h"
#include "itkContinuousIndex.h"
#include "itkSingleValuedCostFunction.h"
#include "itkInterpolateImageFunction.h"
#include "itkLinearInterpolateImageFunction.h"
#include "itkCentralDifferenceImageFunction.h"
#include "itkPhysicalCentralDifferenceImageFunction.h"

namespace itk
{

template <class TImage>
class ITK_EXPORT SingleImageCostFunction :
    public SingleValuedCostFunction
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(SingleImageCostFunction);

  using Self = SingleImageCostFunction;
  using Superclass = SingleValuedCostFunction;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkNewMacro(Self);

  itkTypeMacro( SingleImageCostFunction, SingleValuedCostFunction );

  using MeasureType = typename Superclass::MeasureType;

  using DerivativeType = typename Superclass::DerivativeType;

  using ParametersType = typename Superclass::ParametersType;

  using ImageType = TImage;
  using ImagePixelType = typename TImage::PixelType;
  using ImageConstPointer = typename ImageType::ConstPointer;

  static constexpr unsigned int ImageDimension = ImageType::ImageDimension;

  using CoordRepType = Superclass::ParametersValueType;

  using IndexType = Index< ImageDimension >;
  using PointType = Point< CoordRepType, ImageDimension >;
  using ContinuousIndexType = ContinuousIndex< CoordRepType, ImageDimension >;

  using InterpolatorType = InterpolateImageFunction< ImageType, CoordRepType >;
  using DefaultInterpolatorType = LinearInterpolateImageFunction< ImageType, CoordRepType >;

  using GradientImageFunctionType = PhysicalCentralDifferenceImageFunction< ImageType, CoordRepType >;

  itkSetObjectMacro( Interpolator, InterpolatorType );
  itkGetConstObjectMacro( Interpolator, InterpolatorType );

  itkSetConstObjectMacro( Image, ImageType );
  itkGetConstObjectMacro( Image, ImageType );

  virtual void Initialize(void) throw ( ExceptionObject );

  unsigned int GetNumberOfParameters(void) const override
  { return ImageDimension; }

  MeasureType GetValue( const ParametersType & parameters ) const override;

  void GetDerivative( const ParametersType & parameters,
                              DerivativeType & derivative ) const override;

  // Set these depending on whether you will be minimizing or maximizing.
  // They control the value returned when the point isn't inside the buffer.
  void SetMinimize()
  {
    m_OutsideValue = itk::NumericTraits< ImagePixelType >::max();
  }
  void SetMaximize()
  {
    m_OutsideValue = itk::NumericTraits< ImagePixelType >::NonpositiveMin();
  }

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

private:
  ImageConstPointer                           m_Image;
  typename InterpolatorType::Pointer          m_Interpolator;
  typename GradientImageFunctionType::Pointer m_GradientImageFunction;
  ImagePixelType                              m_OutsideValue;

};

} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkSingleImageCostFunction.hxx"
#endif

#endif