itkParzenWindowHistogramImageToImageMetric.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 __itkParzenWindowHistogramImageToImageMetric_H__
#define __itkParzenWindowHistogramImageToImageMetric_H__
 
#include "itkAdvancedImageToImageMetric.h"
#include "itkKernelFunctionBase2.h"
 
 
namespace itk
{
template< class TFixedImage, class TMovingImage >
class ParzenWindowHistogramImageToImageMetric :
  public AdvancedImageToImageMetric< TFixedImage, TMovingImage >
{
public:
 
  typedef ParzenWindowHistogramImageToImageMetric                 Self;
  typedef AdvancedImageToImageMetric< TFixedImage, TMovingImage > Superclass;
  typedef SmartPointer< Self >                                    Pointer;
  typedef SmartPointer< const Self >                              ConstPointer;
 
  itkTypeMacro( ParzenWindowHistogramImageToImageMetric, 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::DerivativeValueType             DerivativeValueType;
  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::FixedImageLimiterType           FixedImageLimiterType;
  typedef typename Superclass::MovingImageLimiterType          MovingImageLimiterType;
  typedef typename Superclass::FixedImageLimiterOutputType     FixedImageLimiterOutputType;
  typedef typename Superclass::MovingImageLimiterOutputType    MovingImageLimiterOutputType;
  typedef typename Superclass::MovingImageDerivativeScalesType MovingImageDerivativeScalesType;
  typedef typename Superclass::ThreaderType                    ThreaderType;
  typedef typename Superclass::ThreadInfoType                  ThreadInfoType;
 
  itkStaticConstMacro( FixedImageDimension, unsigned int,
    FixedImageType::ImageDimension );
 
  itkStaticConstMacro( MovingImageDimension, unsigned int,
    MovingImageType::ImageDimension );
 
  void Initialize( void ) override;
 
  void GetDerivative(
    const ParametersType & parameters,
    DerivativeType & Derivative ) const override;
 
  void GetValueAndDerivative( const ParametersType & parameters,
    MeasureType & value, DerivativeType & derivative ) const override;
 
  itkSetClampMacro( NumberOfFixedHistogramBins, unsigned long,
    4, NumericTraits< unsigned long >::max() );
  itkGetMacro( NumberOfFixedHistogramBins, unsigned long );
 
  itkSetClampMacro( NumberOfMovingHistogramBins, unsigned long,
    4, NumericTraits< unsigned long >::max() );
  itkGetMacro( NumberOfMovingHistogramBins, unsigned long );
 
  itkSetClampMacro( FixedKernelBSplineOrder, unsigned int, 0, 3 );
  itkGetConstMacro( FixedKernelBSplineOrder, unsigned int );
 
  itkSetClampMacro( MovingKernelBSplineOrder, unsigned int, 0, 3 );
  itkGetConstMacro( MovingKernelBSplineOrder, unsigned int );
 
  itkSetMacro( UseExplicitPDFDerivatives, bool );
  itkGetConstReferenceMacro( UseExplicitPDFDerivatives, bool );
  itkBooleanMacro( UseExplicitPDFDerivatives );
 
  itkSetMacro( UseDerivative, bool );
  itkGetConstMacro( UseDerivative, bool );
 
  itkSetMacro( UseFiniteDifferenceDerivative, bool );
  itkGetConstMacro( UseFiniteDifferenceDerivative, bool );
 
  itkSetMacro( FiniteDifferencePerturbation, double );
  itkGetConstMacro( FiniteDifferencePerturbation, double );
 
protected:
 
  ParzenWindowHistogramImageToImageMetric();
 
  ~ParzenWindowHistogramImageToImageMetric() override;
 
  void PrintSelf( std::ostream & os, Indent indent ) const override;
 
  typedef typename Superclass::FixedImageIndexType                 FixedImageIndexType;
  typedef typename Superclass::FixedImageIndexValueType            FixedImageIndexValueType;
  typedef typename FixedImageType::OffsetValueType                 OffsetValueType;
  typedef typename Superclass::MovingImageIndexType                MovingImageIndexType;
  typedef typename Superclass::FixedImagePointType                 FixedImagePointType;
  typedef typename Superclass::MovingImagePointType                MovingImagePointType;
  typedef typename Superclass::MovingImageContinuousIndexType      MovingImageContinuousIndexType;
  typedef typename Superclass::BSplineInterpolatorType             BSplineInterpolatorType;
  typedef typename Superclass::MovingImageDerivativeType           MovingImageDerivativeType;
  typedef typename Superclass::CentralDifferenceGradientFilterType CentralDifferenceGradientFilterType;
  typedef typename Superclass::NonZeroJacobianIndicesType          NonZeroJacobianIndicesType;
 
  typedef double                                       PDFValueType;
  typedef float                                        PDFDerivativeValueType;
  typedef Array< PDFValueType >                        MarginalPDFType;
  typedef Image< PDFValueType, 2 >                     JointPDFType;
  typedef typename JointPDFType::Pointer               JointPDFPointer;
  typedef Image< PDFDerivativeValueType, 3 >           JointPDFDerivativesType;
  typedef typename JointPDFDerivativesType::Pointer    JointPDFDerivativesPointer;
  typedef Image< PDFValueType, 2 >                     IncrementalMarginalPDFType;
  typedef typename IncrementalMarginalPDFType::Pointer IncrementalMarginalPDFPointer;
  typedef JointPDFType::IndexType                      JointPDFIndexType;
  typedef JointPDFType::RegionType                     JointPDFRegionType;
  typedef JointPDFType::SizeType                       JointPDFSizeType;
  typedef JointPDFDerivativesType::IndexType           JointPDFDerivativesIndexType;
  typedef JointPDFDerivativesType::RegionType          JointPDFDerivativesRegionType;
  typedef JointPDFDerivativesType::SizeType            JointPDFDerivativesSizeType;
  typedef IncrementalMarginalPDFType::IndexType        IncrementalMarginalPDFIndexType;
  typedef IncrementalMarginalPDFType::RegionType       IncrementalMarginalPDFRegionType;
  typedef IncrementalMarginalPDFType::SizeType         IncrementalMarginalPDFSizeType;
  typedef Array< PDFValueType >                        ParzenValueContainerType;
 
  typedef KernelFunctionBase2< PDFValueType >  KernelFunctionType;
  typedef typename KernelFunctionType::Pointer KernelFunctionPointer;
 
  mutable double         m_Alpha;
  mutable DerivativeType m_PerturbedAlphaRight;
  mutable DerivativeType m_PerturbedAlphaLeft;
 
  mutable MarginalPDFType       m_FixedImageMarginalPDF;
  mutable MarginalPDFType       m_MovingImageMarginalPDF;
  JointPDFPointer               m_JointPDF;
  JointPDFDerivativesPointer    m_JointPDFDerivatives;
  JointPDFDerivativesPointer    m_IncrementalJointPDFRight;
  JointPDFDerivativesPointer    m_IncrementalJointPDFLeft;
  IncrementalMarginalPDFPointer m_FixedIncrementalMarginalPDFRight;
  IncrementalMarginalPDFPointer m_MovingIncrementalMarginalPDFRight;
  IncrementalMarginalPDFPointer m_FixedIncrementalMarginalPDFLeft;
  IncrementalMarginalPDFPointer m_MovingIncrementalMarginalPDFLeft;
  mutable JointPDFRegionType    m_JointPDFWindow;                // no need for mutable anymore?
  double                        m_MovingImageNormalizedMin;
  double                        m_FixedImageNormalizedMin;
  double                        m_FixedImageBinSize;
  double                        m_MovingImageBinSize;
  double                        m_FixedParzenTermToIndexOffset;
  double                        m_MovingParzenTermToIndexOffset;
 
  KernelFunctionPointer m_FixedKernel;
  KernelFunctionPointer m_MovingKernel;
  KernelFunctionPointer m_DerivativeMovingKernel;
 
  mutable std::vector< JointPDFPointer > m_ThreaderJointPDFs;
 
  struct ParzenWindowHistogramMultiThreaderParameterType // can't we use the one from AdvancedImageToImageMetric ?
  {
    Self * m_Metric;
  };
  ParzenWindowHistogramMultiThreaderParameterType m_ParzenWindowHistogramThreaderParameters;
 
  struct ParzenWindowHistogramGetValueAndDerivativePerThreadStruct
  {
    SizeValueType   st_NumberOfPixelsCounted;
    JointPDFPointer st_JointPDF;
  };
  itkPadStruct( ITK_CACHE_LINE_ALIGNMENT, ParzenWindowHistogramGetValueAndDerivativePerThreadStruct,
    PaddedParzenWindowHistogramGetValueAndDerivativePerThreadStruct );
  itkAlignedTypedef( ITK_CACHE_LINE_ALIGNMENT, PaddedParzenWindowHistogramGetValueAndDerivativePerThreadStruct,
    AlignedParzenWindowHistogramGetValueAndDerivativePerThreadStruct );
  mutable AlignedParzenWindowHistogramGetValueAndDerivativePerThreadStruct * m_ParzenWindowHistogramGetValueAndDerivativePerThreadVariables;
  mutable ThreadIdType                                                       m_ParzenWindowHistogramGetValueAndDerivativePerThreadVariablesSize;
 
  void InitializeThreadingParameters( void ) const override;
 
  inline void ThreadedComputePDFs( ThreadIdType threadId );
 
  inline void AfterThreadedComputePDFs( void ) const;
 
  static ITK_THREAD_RETURN_FUNCTION_CALL_CONVENTION ComputePDFsThreaderCallback( void * arg );
 
  void LaunchComputePDFsThreaderCallback( void ) const;
 
  void EvaluateParzenValues(
    double parzenWindowTerm, OffsetValueType parzenWindowIndex,
    const KernelFunctionType * kernel,
    ParzenValueContainerType & parzenValues ) const;
 
  virtual void UpdateJointPDFAndDerivatives(
    const RealType & fixedImageValue,
    const RealType & movingImageValue,
    const DerivativeType * imageJacobian,
    const NonZeroJacobianIndicesType * nzji,
    JointPDFType * jointPDF ) const;
 
  virtual void UpdateJointPDFAndIncrementalPDFs(
    RealType fixedImageValue, RealType movingImageValue, RealType movingMaskValue,
    const DerivativeType & movingImageValuesRight,
    const DerivativeType & movingImageValuesLeft,
    const DerivativeType & movingMaskValuesRight,
    const DerivativeType & movingMaskValuesLeft,
    const NonZeroJacobianIndicesType & nzji ) const;
 
  void UpdateJointPDFDerivatives(
    const JointPDFIndexType & pdfIndex, double factor,
    const DerivativeType & imageJacobian,
    const NonZeroJacobianIndicesType & nzji ) const;
 
  virtual void NormalizeJointPDF(
    JointPDFType * pdf, const double & factor ) const;
 
  virtual void NormalizeJointPDFDerivatives(
    JointPDFDerivativesType * pdf, const double & factor ) const;
 
  virtual void ComputeMarginalPDF(
    const JointPDFType * jointPDF,
    MarginalPDFType & marginalPDF,
    const unsigned int & direction ) const;
 
  virtual void ComputeIncrementalMarginalPDFs(
    const JointPDFDerivativesType * incrementalPDF,
    IncrementalMarginalPDFType * fixedIncrementalMarginalPDF,
    IncrementalMarginalPDFType * movingIncrementalMarginalPDF ) const;
 
  virtual void ComputePDFsAndPDFDerivatives( const ParametersType & parameters ) const;
 
  virtual void ComputePDFsAndIncrementalPDFs( const ParametersType & parameters ) const;
 
  virtual void ComputePDFsSingleThreaded( const ParametersType & parameters ) const;
 
  virtual void ComputePDFs( const ParametersType & parameters ) const;
 
  virtual void InitializeHistograms( void );
 
  virtual void InitializeKernels( void );
 
  virtual void GetValueAndAnalyticDerivative(
    const ParametersType & itkNotUsed( parameters ),
    MeasureType & itkNotUsed( value ),
    DerivativeType & itkNotUsed( derivative ) ) const {}
 
  virtual void GetValueAndFiniteDifferenceDerivative(
    const ParametersType & itkNotUsed( parameters ),
    MeasureType & itkNotUsed( value ),
    DerivativeType & itkNotUsed( derivative ) ) const {}
 
private:
 
  ParzenWindowHistogramImageToImageMetric( const Self & ); // purposely not implemented
  void operator=( const Self & );                          // purposely not implemented
 
  unsigned long m_NumberOfFixedHistogramBins;
  unsigned long m_NumberOfMovingHistogramBins;
  unsigned int  m_FixedKernelBSplineOrder;
  unsigned int  m_MovingKernelBSplineOrder;
  bool          m_UseDerivative;
  bool          m_UseExplicitPDFDerivatives;
  bool          m_UseFiniteDifferenceDerivative;
  double        m_FiniteDifferencePerturbation;
 
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkParzenWindowHistogramImageToImageMetric.hxx"
#endif
 
#endif // end #ifndef __itkParzenWindowHistogramImageToImageMetric_H__