itkANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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 itkANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader_h
#define itkANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader_h
 
#include "itkImageToImageMetricv4GetValueAndDerivativeThreader.h"
#include "itkThreadedImageRegionPartitioner.h"
#include "itkThreadedIndexedContainerPartitioner.h"
#include "itkConstNeighborhoodIterator.h"
 
#include <deque>
 
namespace itk
{
 
template <typename T>
struct IdentityHelper
{
  using MyType = T;
};
 
template <typename TDomainPartitioner, typename TImageToImageMetric, typename TNeighborhoodCorrelationMetric>
class ITK_TEMPLATE_EXPORT ANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader
  : public ImageToImageMetricv4GetValueAndDerivativeThreader<TDomainPartitioner, TImageToImageMetric>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader);
 
  using Self = ANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader;
  using Superclass = ImageToImageMetricv4GetValueAndDerivativeThreader<TDomainPartitioner, TImageToImageMetric>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkTypeMacro(ANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader,
               ImageToImageMetricv4GetValueAndDerivativeThreader);
 
  itkNewMacro(Self);
 
  using DomainType = typename Superclass::DomainType;
  using AssociateType = typename Superclass::AssociateType;
 
  using VirtualImageType = typename Superclass::VirtualImageType;
  using VirtualPointType = typename Superclass::VirtualPointType;
  using VirtualIndexType = typename Superclass::VirtualIndexType;
  using FixedImagePointType = typename Superclass::FixedImagePointType;
  using FixedImagePixelType = typename Superclass::FixedImagePixelType;
  using FixedImageGradientType = typename Superclass::FixedImageGradientType;
  using MovingImagePointType = typename Superclass::MovingImagePointType;
  using MovingImagePixelType = typename Superclass::MovingImagePixelType;
  using MovingImageGradientType = typename Superclass::MovingImageGradientType;
  using MeasureType = typename Superclass::MeasureType;
  using DerivativeType = typename Superclass::DerivativeType;
  using DerivativeValueType = typename Superclass::DerivativeValueType;
 
  using NeighborhoodCorrelationMetricType = TNeighborhoodCorrelationMetric;
 
  using ImageRegionType = typename NeighborhoodCorrelationMetricType::ImageRegionType;
  using InternalComputationValueType = typename NeighborhoodCorrelationMetricType::InternalComputationValueType;
  using ImageDimensionType = typename NeighborhoodCorrelationMetricType::ImageDimensionType;
  using JacobianType = typename NeighborhoodCorrelationMetricType::JacobianType;
  using NumberOfParametersType = typename NeighborhoodCorrelationMetricType::NumberOfParametersType;
  using FixedImageType = typename NeighborhoodCorrelationMetricType::FixedImageType;
  using MovingImageType = typename NeighborhoodCorrelationMetricType::MovingImageType;
  using RadiusType = typename NeighborhoodCorrelationMetricType::RadiusType;
 
  // interested values here updated during scanning
  using QueueRealType = InternalComputationValueType;
  using SumQueueType = std::deque<QueueRealType>;
  using ScanIteratorType = ConstNeighborhoodIterator<VirtualImageType>;
 
  // one ScanMemType for each thread
  using ScanMemType = struct
  {
    // queues used in the scanning
    // sum of the fixed value squared
    SumQueueType QsumFixed2;
    // sum of the moving value squared
    SumQueueType QsumMoving2;
    SumQueueType QsumFixed;
    SumQueueType QsumMoving;
    SumQueueType QsumFixedMoving;
    SumQueueType Qcount;
 
    QueueRealType fixedA;
    QueueRealType movingA;
    QueueRealType sFixedMoving;
    QueueRealType sFixedFixed;
    QueueRealType sMovingMoving;
 
    FixedImageGradientType  fixedImageGradient;
    MovingImageGradientType movingImageGradient;
 
    FixedImagePointType  mappedFixedPoint;
    MovingImagePointType mappedMovingPoint;
    VirtualPointType     virtualPoint;
  };
 
  // For dense scan over one image region
  using ScanParametersType = struct
  {
    // const values during scanning
    ImageRegionType scanRegion;
    SizeValueType   numberOfFillZero; // for each queue
    SizeValueType   windowLength;     // number of voxels in the scanning window
    IndexValueType  scanRegionBeginIndexDim0;
 
    typename FixedImageType::ConstPointer   fixedImage;
    typename MovingImageType::ConstPointer  movingImage;
    typename VirtualImageType::ConstPointer virtualImage;
    RadiusType                              radius;
  };
 
protected:
  ANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader()
    : m_ANTSAssociate(nullptr)
  {}
 
  bool
  ProcessVirtualPoint(const VirtualIndexType & virtualIndex,
                      const VirtualPointType & virtualPoint,
                      const ThreadIdType       threadId) override
  {
    return ProcessVirtualPoint_impl(IdentityHelper<TDomainPartitioner>(), virtualIndex, virtualPoint, threadId);
  }
 
  /* specific overloading for sparse CC metric */
  bool
  ProcessVirtualPoint_impl(IdentityHelper<ThreadedIndexedContainerPartitioner> itkNotUsed(self),
                           const VirtualIndexType &                            virtualIndex,
                           const VirtualPointType &                            virtualPoint,
                           const ThreadIdType                                  threadId);
 
  /* for other default case */
  template <typename T>
  bool
  ProcessVirtualPoint_impl(IdentityHelper<T>        itkNotUsed(self),
                           const VirtualIndexType & virtualIndex,
                           const VirtualPointType & virtualPoint,
                           const ThreadIdType       threadId)
  {
    return Superclass::ProcessVirtualPoint(virtualIndex, virtualPoint, threadId);
  }
 
 
  bool
  ProcessPoint(const VirtualIndexType &        itkNotUsed(virtualIndex),
               const VirtualPointType &        itkNotUsed(virtualPoint),
               const FixedImagePointType &     itkNotUsed(mappedFixedPoint),
               const FixedImagePixelType &     itkNotUsed(mappedFixedPixelValue),
               const FixedImageGradientType &  itkNotUsed(mappedFixedImageGradient),
               const MovingImagePointType &    itkNotUsed(mappedMovingPoint),
               const MovingImagePixelType &    itkNotUsed(mappedMovingPixelValue),
               const MovingImageGradientType & itkNotUsed(mappedMovingImageGradient),
               MeasureType &                   itkNotUsed(metricValueReturn),
               DerivativeType &                itkNotUsed(localDerivativeReturn),
               const ThreadIdType              itkNotUsed(threadId)) const override
  {
    itkExceptionMacro("ProcessPoint should never be reached in ANTS CC metric threader class.");
  }
 
  void
  ThreadedExecution(const DomainType & domain, const ThreadIdType threadId) override
  {
    ThreadedExecution_impl(IdentityHelper<TDomainPartitioner>(), domain, threadId);
  }
 
  /* specific overloading for dense threader only based CC metric */
  void
  ThreadedExecution_impl(
    IdentityHelper<ThreadedImageRegionPartitioner<TImageToImageMetric::VirtualImageDimension>> itkNotUsed(self),
    const DomainType &                                                                         virtualImageSubRegion,
    const ThreadIdType                                                                         threadId);
 
  /* for other default case */
  template <typename T>
  void
  ThreadedExecution_impl(IdentityHelper<T> itkNotUsed(self), const DomainType & domain, const ThreadIdType threadId);
 
  void
  InitializeScanning(const ImageRegionType & scanRegion,
                     ScanIteratorType &      scanIt,
                     ScanMemType &           scanMem,
                     ScanParametersType &    scanParameters) const;
 
  void
  UpdateQueues(const ScanIteratorType &   scanIt,
               ScanMemType &              scanMem,
               const ScanParametersType & scanParameters,
               const ThreadIdType         threadId) const;
 
  void
  UpdateQueuesAtBeginningOfLine(const ScanIteratorType &   scanIt,
                                ScanMemType &              scanMem,
                                const ScanParametersType & scanParameters,
                                const ThreadIdType         threadId) const;
 
  void
  UpdateQueuesToNextScanWindow(const ScanIteratorType &   scanIt,
                               ScanMemType &              scanMem,
                               const ScanParametersType & scanParameters,
                               const ThreadIdType         threadId) const;
 
  bool
  ComputeInformationFromQueues(const ScanIteratorType &   scanIt,
                               ScanMemType &              scanMem,
                               const ScanParametersType & scanParameters,
                               const ThreadIdType         threadId) const;
 
  void
  ComputeMovingTransformDerivative(const ScanIteratorType &   scanIt,
                                   ScanMemType &              scanMem,
                                   const ScanParametersType & scanParameters,
                                   DerivativeType &           deriv,
                                   MeasureType &              localCC,
                                   const ThreadIdType         threadId) const;
 
private:
  TNeighborhoodCorrelationMetric * m_ANTSAssociate;
};
 
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkANTSNeighborhoodCorrelationImageToImageMetricv4GetValueAndDerivativeThreader.hxx"
#endif
 
#endif