itkComputeDisplacementDistribution.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 __itkComputeDisplacementDistribution_h
#define __itkComputeDisplacementDistribution_h
 
#include "itkScaledSingleValuedNonLinearOptimizer.h"
 
#include "itkImageGridSampler.h"
#include "itkImageRandomSamplerBase.h"
#include "itkImageRandomCoordinateSampler.h"
#include "itkImageFullSampler.h"
#include "itkPlatformMultiThreader.h"
 
namespace itk
{
template< class TFixedImage, class TTransform >
class ComputeDisplacementDistribution :
  public ScaledSingleValuedNonLinearOptimizer
{
public:
 
  typedef ComputeDisplacementDistribution      Self;
  typedef ScaledSingleValuedNonLinearOptimizer Superclass;
  typedef SmartPointer< Self >                 Pointer;
  typedef SmartPointer< const Self >           ConstPointer;
 
  itkNewMacro( Self );
 
  itkTypeMacro( ComputeDisplacementDistribution,
    ScaledSingleValuedNonLinearOptimizer );
 
  typedef TFixedImage                         FixedImageType;
  typedef typename FixedImageType::PixelType  FixedImagePixelType;
  typedef TTransform                          TransformType;
  typedef typename TransformType::Pointer     TransformPointer;
  typedef typename FixedImageType::RegionType FixedImageRegionType;
  typedef Superclass::ParametersType          ParametersType;
  typedef Superclass::DerivativeType          DerivativeType;
  typedef Superclass::ScalesType              ScalesType;
 
  itkStaticConstMacro( FixedImageDimension, unsigned int,
    TFixedImage::ImageDimension );
  typedef SpatialObject< itkGetStaticConstMacro( FixedImageDimension ) > FixedImageMaskType;
  typedef typename FixedImageMaskType::Pointer                           FixedImageMaskPointer;
  typedef typename FixedImageMaskType::ConstPointer                      FixedImageMaskConstPointer;
  typedef typename TransformType::NonZeroJacobianIndicesType             NonZeroJacobianIndicesType;
 
  itkSetConstObjectMacro( FixedImage, FixedImageType );
 
  itkSetObjectMacro( Transform, TransformType );
 
  itkSetObjectMacro( FixedImageMask, FixedImageMaskType );
  itkSetConstObjectMacro( FixedImageMask, FixedImageMaskType );
  itkGetConstObjectMacro( FixedImageMask, FixedImageMaskType );
 
  itkSetMacro( NumberOfJacobianMeasurements, SizeValueType );
 
  void SetFixedImageRegion( const FixedImageRegionType & region )
  {
    if( region != this->m_FixedImageRegion )
    {
      this->m_FixedImageRegion = region;
    }
  }
 
 
  itkGetConstReferenceMacro( FixedImageRegion, FixedImageRegionType );
 
  virtual void Compute( const ParametersType & mu,
    double & jacg, double & maxJJ, std::string method );
 
  virtual void ComputeSingleThreaded( const ParametersType & mu,
    double & jacg, double & maxJJ, std::string method );
 
  virtual void ComputeUsingSearchDirection( const ParametersType & mu,
    double & jacg, double & maxJJ, std::string methods );
 
  void SetNumberOfWorkUnits( ThreadIdType numberOfThreads )
  {
    this->m_Threader->SetNumberOfWorkUnits( numberOfThreads );
  }
 
 
  virtual void BeforeThreadedCompute( const ParametersType & mu );
 
  virtual void AfterThreadedCompute( double & jacg, double & maxJJ );
 
protected:
 
  ComputeDisplacementDistribution();
  ~ComputeDisplacementDistribution() override;
 
  typedef itk::PlatformMultiThreader             ThreaderType;
  typedef ThreaderType::WorkUnitInfo ThreadInfoType;
 
  typename FixedImageType::ConstPointer   m_FixedImage;
  FixedImageRegionType                    m_FixedImageRegion;
  FixedImageMaskConstPointer              m_FixedImageMask;
  TransformPointer                        m_Transform;
  ScaledSingleValuedCostFunction::Pointer m_CostFunction;
  SizeValueType                           m_NumberOfJacobianMeasurements;
  DerivativeType                          m_ExactGradient;
  SizeValueType                           m_NumberOfParameters;
  ThreaderType::Pointer                   m_Threader;
 
  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 ImageFullSampler< FixedImageType >     ImageFullSamplerType;
  typedef typename ImageFullSamplerType::Pointer ImageFullSamplerPointer;
 
  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::ComputeJacobianTerms
  // in the future it would be better to refactoring this part of the code
  virtual void SampleFixedImageForJacobianTerms(
    ImageSampleContainerPointer & sampleContainer );
 
  void LaunchComputeThreaderCallback( void ) const;
 
  static ITK_THREAD_RETURN_FUNCTION_CALL_CONVENTION ComputeThreaderCallback( void * arg );
 
  virtual inline void ThreadedCompute( ThreadIdType threadID );
 
  virtual void InitializeThreadingParameters( void );
 
  struct MultiThreaderParameterType
  {
    Self * st_Self;
  };
  mutable MultiThreaderParameterType m_ThreaderParameters;
 
  struct ComputePerThreadStruct
  {
    double        st_MaxJJ;
    double        st_Displacement;
    double        st_DisplacementSquared;
    SizeValueType st_NumberOfPixelsCounted;
  };
  itkPadStruct( ITK_CACHE_LINE_ALIGNMENT, ComputePerThreadStruct,
    PaddedComputePerThreadStruct );
  itkAlignedTypedef( ITK_CACHE_LINE_ALIGNMENT, PaddedComputePerThreadStruct,
    AlignedComputePerThreadStruct );
  mutable AlignedComputePerThreadStruct * m_ComputePerThreadVariables;
  mutable ThreadIdType                    m_ComputePerThreadVariablesSize;
 
  SizeValueType               m_NumberOfPixelsCounted;
  bool                        m_UseMultiThread;
  ImageSampleContainerPointer m_SampleContainer;
 
private:
 
  ComputeDisplacementDistribution( const Self & ); // purposely not implemented
  void operator=( const Self & );                  // purposely not implemented
 
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#include "itkComputeDisplacementDistribution.hxx"
#endif
 
#endif // end #ifndef __itkComputeDisplacementDistribution_h