itkComputeJacobianTerms.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 __itkComputeJacobianTerms_h
#define __itkComputeJacobianTerms_h
 
#include "itkImageGridSampler.h"
#include "itkImageRandomSamplerBase.h"
#include "itkImageRandomCoordinateSampler.h"
#include "itkScaledSingleValuedNonLinearOptimizer.h"
 
namespace itk
{
template< class TFixedImage, class TTransform >
class ComputeJacobianTerms :
  public Object
{
public:
 
  typedef ComputeJacobianTerms       Self;
  typedef Object                     Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( ComputeJacobianTerms, Object );
 
  typedef TFixedImage                         FixedImageType;
  typedef TTransform                          TransformType;
  typedef typename TransformType::Pointer     TransformPointer;
  typedef typename FixedImageType::RegionType FixedImageRegionType;
 
  itkStaticConstMacro( FixedImageDimension, unsigned int,
    TFixedImage::ImageDimension );
  typedef SpatialObject< itkGetStaticConstMacro( FixedImageDimension ) > FixedImageMaskType;
  typedef typename FixedImageMaskType::Pointer                           FixedImageMaskPointer;
  typedef typename FixedImageMaskType::ConstPointer                      FixedImageMaskConstPointer;
 
  typedef ScaledSingleValuedNonLinearOptimizer ScaledSingleValuedNonLinearOptimizerType;
  typedef typename ScaledSingleValuedNonLinearOptimizerType
    ::ScaledCostFunctionPointer ScaledCostFunctionPointer;
  typedef typename ScaledSingleValuedNonLinearOptimizerType::ScalesType ScalesType;
  typedef typename TransformType::NonZeroJacobianIndicesType            NonZeroJacobianIndicesType;
 
  itkSetConstObjectMacro( FixedImage, FixedImageType );
 
  itkSetObjectMacro( Transform, TransformType );
 
  itkSetObjectMacro( FixedImageMask, FixedImageMaskType );
  itkSetConstObjectMacro( FixedImageMask, FixedImageMaskType );
  itkGetConstObjectMacro( FixedImageMask, FixedImageMaskType );
 
  itkSetMacro( Scales, ScalesType );
  itkSetMacro( UseScales, bool );
  itkSetMacro( MaxBandCovSize, unsigned int );
  itkSetMacro( NumberOfBandStructureSamples, unsigned int );
  itkSetMacro( NumberOfJacobianMeasurements, SizeValueType );
 
  void SetFixedImageRegion( const FixedImageRegionType & region )
  {
    if( region != this->m_FixedImageRegion )
    {
      this->m_FixedImageRegion = region;
    }
  }
 
 
  itkGetConstReferenceMacro( FixedImageRegion, FixedImageRegionType );
 
  virtual void Compute( double & TrC, double & TrCC,
    double & maxJJ, double & maxJCJ );
 
protected:
 
  ComputeJacobianTerms();
  ~ComputeJacobianTerms() override {}
 
  typename FixedImageType::ConstPointer m_FixedImage;
  FixedImageRegionType       m_FixedImageRegion;
  FixedImageMaskConstPointer m_FixedImageMask;
  TransformPointer           m_Transform;
  ScalesType                 m_Scales;
  bool                       m_UseScales;
 
  unsigned int  m_MaxBandCovSize;
  unsigned int  m_NumberOfBandStructureSamples;
  SizeValueType m_NumberOfJacobianMeasurements;
 
  typedef typename  FixedImageType::IndexType   FixedImageIndexType;
  typedef typename  FixedImageType::PointType   FixedImagePointType;
  typedef typename  TransformType::JacobianType JacobianType;
  typedef typename  JacobianType::ValueType     JacobianValueType;
 
  typedef ImageSamplerBase< FixedImageType >           ImageSamplerBaseType;
  typedef typename ImageSamplerBaseType::Pointer       ImageSamplerBasePointer;
  typedef ImageRandomSamplerBase< FixedImageType >     ImageRandomSamplerBaseType;
  typedef typename ImageRandomSamplerBaseType::Pointer ImageRandomSamplerBasePointer;
 
  typedef ImageGridSampler< FixedImageType >     ImageGridSamplerType;
  typedef typename ImageGridSamplerType::Pointer ImageGridSamplerPointer;
  typedef typename ImageGridSamplerType
    ::ImageSampleContainerType ImageSampleContainerType;
  typedef typename ImageSampleContainerType::Pointer ImageSampleContainerPointer;
 
  typedef JacobianType                                   TransformJacobianType;
  typedef typename TransformType::ScalarType             CoordinateRepresentationType;
  typedef typename TransformType::NumberOfParametersType NumberOfParametersType;
 
  // \todo: note that this is an exact copy of itk::ComputeDisplacementDistribution
  // in the future it would be better to refactoring this part of the code.
  virtual void SampleFixedImageForJacobianTerms(
    ImageSampleContainerPointer & sampleContainer );
 
private:
 
  ComputeJacobianTerms( const Self & ); // purposely not implemented
  void operator=( const Self & );       // purposely not implemented
 
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkComputeJacobianTerms.hxx"
#endif
 
#endif // end #ifndef __itkComputeJacobianTerms_h