itkImageToImageMetricWithFeatures.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 itkImageToImageMetricWithFeatures_h
#define itkImageToImageMetricWithFeatures_h
 
#include "itkAdvancedImageToImageMetric.h"
#include "itkInterpolateImageFunction.h"
 
namespace itk
{
 
template <class TFixedImage,
          class TMovingImage,
          class TFixedFeatureImage = TFixedImage,
          class TMovingFeatureImage = TMovingImage>
class ITK_TEMPLATE_EXPORT ImageToImageMetricWithFeatures : public AdvancedImageToImageMetric<TFixedImage, TMovingImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ImageToImageMetricWithFeatures);
 
  using Self = ImageToImageMetricWithFeatures;
  using Superclass = AdvancedImageToImageMetric<TFixedImage, TMovingImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;
 
  itkTypeMacro(ImageToImageMetricWithFeatures, AdvancedImageToImageMetric);
 
  using typename Superclass::CoordinateRepresentationType;
  using typename Superclass::MovingImageType;
  using typename Superclass::MovingImagePixelType;
  using typename Superclass::MovingImageConstPointer;
  using typename Superclass::FixedImageType;
  using typename Superclass::FixedImageConstPointer;
  using typename Superclass::FixedImageRegionType;
  using typename Superclass::TransformType;
  using typename Superclass::TransformPointer;
  using typename Superclass::InputPointType;
  using typename Superclass::OutputPointType;
  using typename Superclass::TransformParametersType;
  using typename Superclass::TransformJacobianType;
  using typename Superclass::InterpolatorType;
  using typename Superclass::InterpolatorPointer;
  using typename Superclass::RealType;
  using typename Superclass::GradientPixelType;
  using typename Superclass::GradientImageType;
  using typename Superclass::GradientImagePointer;
  using typename Superclass::GradientImageFilterType;
  using typename Superclass::GradientImageFilterPointer;
  using typename Superclass::FixedImageMaskType;
  using typename Superclass::FixedImageMaskPointer;
  using typename Superclass::MovingImageMaskType;
  using typename Superclass::MovingImageMaskPointer;
  using typename Superclass::MeasureType;
  using typename Superclass::DerivativeType;
  using typename Superclass::ParametersType;
  using typename Superclass::FixedImagePixelType;
  using typename Superclass::MovingImageRegionType;
  using typename Superclass::ImageSamplerType;
  using typename Superclass::ImageSamplerPointer;
  using typename Superclass::ImageSampleContainerType;
  using typename Superclass::ImageSampleContainerPointer;
  using typename Superclass::InternalMaskPixelType;
  using typename Superclass::InternalMovingImageMaskType;
  using typename Superclass::MovingImageMaskInterpolatorType;
  using typename Superclass::FixedImageLimiterType;
  using typename Superclass::MovingImageLimiterType;
  using typename Superclass::FixedImageLimiterOutputType;
  using typename Superclass::MovingImageLimiterOutputType;
 
  itkStaticConstMacro(FixedImageDimension, unsigned int, FixedImageType::ImageDimension);
 
  itkStaticConstMacro(MovingImageDimension, unsigned int, MovingImageType::ImageDimension);
 
  using FixedFeatureImageType = TFixedFeatureImage;
  using FixedFeatureImagePointer = typename FixedFeatureImageType::Pointer;
  using MovingFeatureImageType = TMovingFeatureImage;
  using MovingFeatureImagePointer = typename MovingFeatureImageType::Pointer;
  using FixedFeatureImageVectorType = std::vector<FixedFeatureImagePointer>;
  using MovingFeatureImageVectorType = std::vector<MovingFeatureImagePointer>;
 
  using FixedFeatureInterpolatorType = InterpolateImageFunction<FixedFeatureImageType, double>;
  using MovingFeatureInterpolatorType = InterpolateImageFunction<MovingFeatureImageType, double>;
  using FixedFeatureInterpolatorPointer = typename FixedFeatureInterpolatorType::Pointer;
  using MovingFeatureInterpolatorPointer = typename MovingFeatureInterpolatorType::Pointer;
  using FixedFeatureInterpolatorVectorType = std::vector<FixedFeatureInterpolatorPointer>;
  using MovingFeatureInterpolatorVectorType = std::vector<MovingFeatureInterpolatorPointer>;
 
  void
  SetNumberOfFixedFeatureImages(unsigned int arg);
 
  itkGetConstMacro(NumberOfFixedFeatureImages, unsigned int);
 
  void
  SetFixedFeatureImage(unsigned int i, FixedFeatureImageType * im);
 
  void
  SetFixedFeatureImage(FixedFeatureImageType * im)
  {
    this->SetFixedFeatureImage(0, im);
  }
 
 
  const FixedFeatureImageType *
  GetFixedFeatureImage(unsigned int i) const;
 
  const FixedFeatureImageType *
  GetFixedFeatureImage() const
  {
    return this->GetFixedFeatureImage(0);
  }
 
 
  void
  SetFixedFeatureInterpolator(unsigned int i, FixedFeatureInterpolatorType * interpolator);
 
  void
  SetFixedFeatureInterpolator(FixedFeatureInterpolatorType * interpolator)
  {
    this->SetFixedFeatureInterpolator(0, interpolator);
  }
 
 
  const FixedFeatureInterpolatorType *
  GetFixedFeatureInterpolator(unsigned int i) const;
 
  const FixedFeatureInterpolatorType *
  GetFixedFeatureInterpolator() const
  {
    return this->GetFixedFeatureInterpolator(0);
  }
 
 
  void
  SetNumberOfMovingFeatureImages(unsigned int arg);
 
  itkGetConstMacro(NumberOfMovingFeatureImages, unsigned int);
 
  void
  SetMovingFeatureImage(unsigned int i, MovingFeatureImageType * im);
 
  void
  SetMovingFeatureImage(MovingFeatureImageType * im)
  {
    this->SetMovingFeatureImage(0, im);
  }
 
 
  const MovingFeatureImageType *
  GetMovingFeatureImage(unsigned int i) const;
 
  const MovingFeatureImageType *
  GetMovingFeatureImage() const
  {
    return this->GetMovingFeatureImage(0);
  }
 
 
  void
  SetMovingFeatureInterpolator(unsigned int i, MovingFeatureInterpolatorType * interpolator);
 
  void
  SetMovingFeatureInterpolator(MovingFeatureInterpolatorType * interpolator)
  {
    this->SetMovingFeatureInterpolator(0, interpolator);
  }
 
 
  const MovingFeatureInterpolatorType *
  GetMovingFeatureInterpolator(unsigned int i) const;
 
  const MovingFeatureInterpolatorType *
  GetMovingFeatureInterpolator() const
  {
    return this->GetMovingFeatureInterpolator(0);
  }
 
 
  virtual void
  Initialize();
 
protected:
  ImageToImageMetricWithFeatures();
  virtual ~ImageToImageMetricWithFeatures() {}
  void
  PrintSelf(std::ostream & os, Indent indent) const;
 
  using typename Superclass::BSplineInterpolatorType;
  using BSplineInterpolatorPointer = typename BSplineInterpolatorType::Pointer;
  using BSplineFeatureInterpolatorVectorType = std::vector<BSplineInterpolatorPointer>;
  using typename Superclass::FixedImagePointType;
  using typename Superclass::MovingImagePointType;
  using typename Superclass::MovingImageDerivativeType;
  using typename Superclass::MovingImageContinuousIndexType;
 
  unsigned int                        m_NumberOfFixedFeatureImages;
  unsigned int                        m_NumberOfMovingFeatureImages;
  FixedFeatureImageVectorType         m_FixedFeatureImages;
  MovingFeatureImageVectorType        m_MovingFeatureImages;
  FixedFeatureInterpolatorVectorType  m_FixedFeatureInterpolators;
  MovingFeatureInterpolatorVectorType m_MovingFeatureInterpolators;
 
  std::vector<bool>                    m_FeatureInterpolatorsIsBSpline;
  BSplineFeatureInterpolatorVectorType m_MovingFeatureBSplineInterpolators;
 
  virtual void
  CheckForBSplineFeatureInterpolators();
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkImageToImageMetricWithFeatures.hxx"
#endif
 
#endif // end #ifndef itkImageToImageMetricWithFeatures_h