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 "itkTransform.h"
#include "itkObjectToObjectMetricBase.h"
#include "itkImage.h"
#include "itkDisplacementFieldTransform.h"
#include "itkPointSet.h"

namespace itk
{

template<unsigned int TFixedDimension, unsigned int TMovingDimension, class TVirtualImage = Image<typename ObjectToObjectMetricBase::ParametersValueType, TFixedDimension> >
class ITK_EXPORT ObjectToObjectMetric:
  public ObjectToObjectMetricBase
{
public:
  typedef ObjectToObjectMetric         Self;
  typedef ObjectToObjectMetricBase     Superclass;
  typedef SmartPointer< Self >         Pointer;
  typedef SmartPointer< const Self >   ConstPointer;

  itkTypeMacro(ObjectToObjectMetric, ObjectToObjectMetricBase);

  typedef typename Superclass::ParametersValueType            CoordinateRepresentationType;

  typedef typename Superclass::InternalComputationValueType   InternalComputationValueType;

  typedef typename Superclass::MeasureType            MeasureType;

  typedef typename Superclass::DerivativeType         DerivativeType;
  typedef typename Superclass::DerivativeValueType    DerivativeValueType;

  typedef typename Superclass::ParametersType         ParametersType;
  typedef typename Superclass::ParametersValueType    ParametersValueType;
  typedef typename Superclass::NumberOfParametersType NumberOfParametersType;

  typedef SizeValueType                       DimensionType;

  itkStaticConstMacro(FixedDimension, DimensionType, TFixedDimension);
  itkStaticConstMacro(MovingDimension, DimensionType, TMovingDimension);
  itkStaticConstMacro(VirtualDimension, DimensionType, TVirtualImage::ImageDimension);

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

  typedef PointSet<VirtualPixelType, itkGetStaticConstMacro(VirtualDimension)>  VirtualPointSetType;
  typedef typename VirtualPointSetType::Pointer                                 VirtualPointSetPointer;

  typedef Transform<ParametersValueType, TVirtualImage::ImageDimension, TMovingDimension> MovingTransformType;
  typedef Transform<ParametersValueType, TVirtualImage::ImageDimension, TFixedDimension>  FixedTransformType;

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

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

  typedef typename FixedTransformType::JacobianType     JacobianType;
  typedef typename FixedTransformType::JacobianType     FixedTransformJacobianType;
  typedef typename MovingTransformType::JacobianType    MovingTransformJacobianType;

  typedef DisplacementFieldTransform<CoordinateRepresentationType, itkGetStaticConstMacro( MovingDimension ) >  MovingDisplacementFieldTransformType;

  virtual void Initialize(void) throw ( ExceptionObject );

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

  itkSetObjectMacro(FixedTransform, FixedTransformType);

  itkGetConstObjectMacro(FixedTransform, FixedTransformType);

  itkSetObjectMacro(MovingTransform, MovingTransformType);

  itkGetConstObjectMacro(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( VirtualImageType * virtualImage);
  void SetVirtualDomainFromImage( const VirtualImageType * virtualImage);

  virtual bool SupportsArbitraryVirtualDomainSamples( void ) const = 0;

  virtual const TimeStamp& GetVirtualDomainTimeStamp( void ) const;

  VirtualSpacingType GetVirtualSpacing( void ) const;

  VirtualOriginType  GetVirtualOrigin( void ) const;

  VirtualDirectionType GetVirtualDirection( void ) const;

  const VirtualRegionType   &  GetVirtualRegion( void ) const;

  itkGetConstObjectMacro( 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;

protected:
  ObjectToObjectMetric();
  virtual ~ObjectToObjectMetric();

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

  virtual void VerifyDisplacementFieldSizeAndPhysicalSpace();

  bool TransformPhysicalPointToVirtualIndex( const VirtualPointType &, VirtualIndexType & ) const;
  void TransformVirtualIndexToPhysicalPoint( const VirtualIndexType &, VirtualPointType & ) 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;

private:
  ObjectToObjectMetric(const Self &); //purposely not implemented
  void operator=(const Self &);     //purposely not implemented

};
} // end namespace itk

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

#endif