itkObjectToObjectMetric.h

Go to the documentation of this file.

  /*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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 itkObjectToObjectMetric_h
#define itkObjectToObjectMetric_h


#include "itkObjectToObjectMetricBase.h"

#include "itkDisplacementFieldTransform.h"
#include "itkImage.h"
#include "itkObject.h"
#include "itkPointSet.h"
#include "itkTransform.h"

namespace itk
{

template<unsigned int TFixedDimension, unsigned int TMovingDimension, typename TVirtualImage = Image<double, TFixedDimension>,
         typename TParametersValueType=double>
class ITK_TEMPLATE_EXPORT ObjectToObjectMetric:
  public ObjectToObjectMetricBaseTemplate<TParametersValueType>
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(ObjectToObjectMetric);

  using Self = ObjectToObjectMetric;
  using Superclass = ObjectToObjectMetricBaseTemplate<TParametersValueType>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkTypeMacro(ObjectToObjectMetric, ObjectToObjectMetricBaseTemplate);

  using CoordinateRepresentationType = TParametersValueType;

  using InternalComputationValueType = TParametersValueType;

  using MeasureType = typename Superclass::MeasureType;

  using ObjectType = typename Superclass::Object;

  using DerivativeType = typename Superclass::DerivativeType;
  using DerivativeValueType = typename Superclass::DerivativeValueType;

  using ParametersType = typename Superclass::ParametersType;
  using NumberOfParametersType = typename Superclass::NumberOfParametersType;

  using GradientSourceType = typename Superclass::GradientSourceType;

  using DimensionType = SizeValueType;

  static constexpr DimensionType FixedDimension = TFixedDimension;
  static constexpr DimensionType MovingDimension = TMovingDimension;
  static constexpr DimensionType VirtualDimension = TVirtualImage::ImageDimension;

  using VirtualImageType = TVirtualImage;
  using VirtualImagePointer = typename VirtualImageType::Pointer;
  using VirtualImageConstPointer = typename VirtualImageType::ConstPointer;
  using VirtualPixelType = typename VirtualImageType::PixelType;
  using VirtualRegionType = typename VirtualImageType::RegionType;
  using VirtualSizeType = typename VirtualRegionType::SizeType;
  using VirtualSpacingType = typename VirtualImageType::SpacingType;
  using VirtualOriginType = typename VirtualImageType::PointType;
  using VirtualPointType = typename VirtualImageType::PointType;
  using VirtualDirectionType = typename VirtualImageType::DirectionType;
  using VirtualRadiusType = typename VirtualImageType::SizeType;
  using VirtualIndexType = typename VirtualImageType::IndexType;

  using VirtualPointSetType = PointSet<VirtualPixelType, Self::VirtualDimension>;
  using VirtualPointSetPointer = typename VirtualPointSetType::Pointer;

  using MovingTransformType = Transform<TParametersValueType,
                    TVirtualImage::ImageDimension,
                    TMovingDimension>;
  using FixedTransformType = Transform<TParametersValueType,
                    TVirtualImage::ImageDimension,
                    TFixedDimension>;

  using FixedTransformPointer = typename FixedTransformType::Pointer;
  using FixedInputPointType = typename FixedTransformType::InputPointType;
  using FixedOutputPointType = typename FixedTransformType::OutputPointType;
  using FixedTransformParametersType = typename FixedTransformType::ParametersType;

  using MovingTransformPointer = typename MovingTransformType::Pointer;
  using MovingInputPointType = typename MovingTransformType::InputPointType;
  using MovingOutputPointType = typename MovingTransformType::OutputPointType;
  using MovingTransformParametersType = typename MovingTransformType::ParametersType;

  using JacobianType = typename FixedTransformType::JacobianType;
  using FixedTransformJacobianType = typename FixedTransformType::JacobianType;
  using MovingTransformJacobianType = typename MovingTransformType::JacobianType;

  using MovingDisplacementFieldTransformType = DisplacementFieldTransform<CoordinateRepresentationType, Self::MovingDimension  >;

  void Initialize() override;

  NumberOfParametersType GetNumberOfParameters() const override;
  NumberOfParametersType GetNumberOfLocalParameters() const override;
  void SetParameters( ParametersType & params ) override;
  const ParametersType & GetParameters() const override;
  bool HasLocalSupport() const override;
  void UpdateTransformParameters( const DerivativeType & derivative, TParametersValueType factor) override;

  itkSetObjectMacro(FixedTransform, FixedTransformType);

  itkGetModifiableObjectMacro(FixedTransform, FixedTransformType);

  itkSetObjectMacro(MovingTransform, MovingTransformType);

  itkGetModifiableObjectMacro(MovingTransform, MovingTransformType);

  void SetTransform( MovingTransformType* transform );

  const MovingTransformType * GetTransform();

  itkGetConstMacro(NumberOfValidPoints, SizeValueType)


  void SetVirtualDomain( const VirtualSpacingType & spacing, const VirtualOriginType & origin,
                         const VirtualDirectionType & direction, const VirtualRegionType & region );

  void SetVirtualDomainFromImage( const VirtualImageType * virtualImage);

  virtual bool SupportsArbitraryVirtualDomainSamples() const = 0;

  virtual const TimeStamp& GetVirtualDomainTimeStamp() const;

  VirtualSpacingType GetVirtualSpacing() const;

  VirtualOriginType  GetVirtualOrigin() const;

  VirtualDirectionType GetVirtualDirection() const;

  const VirtualRegionType   &  GetVirtualRegion() const;

  itkGetModifiableObjectMacro(VirtualImage, VirtualImageType );

  OffsetValueType ComputeParameterOffsetFromVirtualIndex( const VirtualIndexType & index, const NumberOfParametersType &numberOfLocalParameters ) const;

  OffsetValueType ComputeParameterOffsetFromVirtualPoint( const VirtualPointType & point, const NumberOfParametersType & numberOfLocalParameters ) const;

  bool IsInsideVirtualDomain( const VirtualPointType & point ) const;
  bool IsInsideVirtualDomain( const VirtualIndexType & index ) const;

  using MetricCategoryType = typename Superclass::MetricCategoryType;

  MetricCategoryType GetMetricCategory() const override
    {
    return Superclass::OBJECT_METRIC;
    }

protected:
  ObjectToObjectMetric();
  ~ObjectToObjectMetric() override = default;

  void PrintSelf(std::ostream & os, Indent indent) const override;

  virtual void VerifyDisplacementFieldSizeAndPhysicalSpace();

  bool TransformPhysicalPointToVirtualIndex( const VirtualPointType &, VirtualIndexType & ) const;
  void TransformVirtualIndexToPhysicalPoint( const VirtualIndexType &, VirtualPointType & ) const;

  const MovingDisplacementFieldTransformType * GetMovingDisplacementFieldTransform() const;

  bool VerifyNumberOfValidPoints( MeasureType & value, DerivativeType & derivative ) const;

  FixedTransformPointer   m_FixedTransform;
  MovingTransformPointer  m_MovingTransform;

  VirtualImagePointer     m_VirtualImage;

  bool                    m_UserHasSetVirtualDomain;

  mutable SizeValueType                   m_NumberOfValidPoints{0};
};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkObjectToObjectMetric.hxx"
#endif

#endif