itkBSplineBaseTransform.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 __itkBSplineBaseTransform_h
#define __itkBSplineBaseTransform_h

#include <iostream>
#include "itkTransform.h"
#include "itkImage.h"
#include "itkBSplineInterpolationWeightFunction.h"

namespace itk
{
template <class TScalarType = double, unsigned int NDimensions = 3,
          unsigned int VSplineOrder = 3>
class ITK_EXPORT BSplineBaseTransform :
  public Transform<TScalarType, NDimensions, NDimensions>
{
public:
  typedef BSplineBaseTransform                             Self;
  typedef Transform<TScalarType, NDimensions, NDimensions> Superclass;
  typedef SmartPointer<Self>                               Pointer;
  typedef SmartPointer<const Self>                         ConstPointer;

  itkTypeMacro( BSplineBaseTransform, Transform );

  itkStaticConstMacro( SpaceDimension, unsigned int, NDimensions );

  itkStaticConstMacro( SplineOrder, unsigned int, VSplineOrder );

  itkCloneMacro(Self);

  typedef typename Superclass::ScalarType ScalarType;

  typedef typename Superclass::ParametersType ParametersType;

  typedef typename Superclass::JacobianType JacobianType;

  typedef typename Superclass::NumberOfParametersType NumberOfParametersType;

  typedef Vector<TScalarType, itkGetStaticConstMacro( SpaceDimension )> InputVectorType;
  typedef Vector<TScalarType, itkGetStaticConstMacro( SpaceDimension )> OutputVectorType;

  typedef CovariantVector<TScalarType, itkGetStaticConstMacro( SpaceDimension )> InputCovariantVectorType;
  typedef CovariantVector<TScalarType, itkGetStaticConstMacro( SpaceDimension )> OutputCovariantVectorType;

  typedef vnl_vector_fixed<TScalarType, SpaceDimension> InputVnlVectorType;
  typedef vnl_vector_fixed<TScalarType, SpaceDimension> OutputVnlVectorType;

  typedef Point <TScalarType, itkGetStaticConstMacro( SpaceDimension )> InputPointType;
  typedef Point <TScalarType, itkGetStaticConstMacro( SpaceDimension )> OutputPointType;

  void SetParameters( const ParametersType & parameters );

  virtual void SetFixedParameters( const ParametersType & parameters ) = 0;

  void SetParametersByValue( const ParametersType & parameters );

  void SetIdentity();

  virtual const ParametersType & GetParameters() const;

  virtual const ParametersType & GetFixedParameters() const;

  typedef typename ParametersType::ValueType           ParametersValueType;
  typedef Image<ParametersValueType, itkGetStaticConstMacro( SpaceDimension )> ImageType;
  typedef typename ImageType::Pointer                  ImagePointer;
  typedef FixedArray<ImagePointer, NDimensions>        CoefficientImageArray;

  virtual void SetCoefficientImages( const CoefficientImageArray & images ) = 0;

  const CoefficientImageArray GetCoefficientImages() const
  {
    return this->m_CoefficientImages;
  }

  typedef typename Superclass::DerivativeType DerivativeType;

  virtual void UpdateTransformParameters( DerivativeType & update, TScalarType factor = 1.0 );

  typedef ImageRegion<itkGetStaticConstMacro( SpaceDimension )> RegionType;

  typedef typename RegionType::IndexType    IndexType;
  typedef typename RegionType::SizeType     SizeType;
  typedef typename ImageType::SpacingType   SpacingType;
  typedef typename ImageType::DirectionType DirectionType;
  typedef typename ImageType::PointType     OriginType;

  OutputPointType  TransformPoint( const InputPointType & point ) const;

  typedef BSplineInterpolationWeightFunction<ScalarType,
    itkGetStaticConstMacro( SpaceDimension ),
     itkGetStaticConstMacro( SplineOrder )> WeightsFunctionType;

  typedef typename WeightsFunctionType::WeightsType         WeightsType;
  typedef typename WeightsFunctionType::ContinuousIndexType ContinuousIndexType;

  typedef Array<unsigned long> ParameterIndexArrayType;

  virtual void TransformPoint( const InputPointType & inputPoint, OutputPointType & outputPoint,
    WeightsType & weights, ParameterIndexArrayType & indices, bool & inside ) const = 0;

  unsigned long GetNumberOfWeights() const
  {
    return m_WeightsFunction->GetNumberOfWeights();
  }

  using Superclass::TransformVector;
  virtual OutputVectorType TransformVector( const InputVectorType & ) const
  {
    itkExceptionMacro( << "Method not applicable for deformable transform." );
    return OutputVectorType();
  }

  virtual OutputVnlVectorType TransformVector( const InputVnlVectorType & ) const
  {
    itkExceptionMacro( << "Method not applicable for deformable transform. " );
    return OutputVnlVectorType();
  }

  using Superclass::TransformCovariantVector;
  virtual OutputCovariantVectorType TransformCovariantVector(
    const InputCovariantVectorType & ) const
  {
    itkExceptionMacro( << "Method not applicable for deformable transfrom. " );
    return OutputCovariantVectorType();
  }

  void ComputeJacobianFromBSplineWeightsWithRespectToPosition(
    const InputPointType &, WeightsType &, ParameterIndexArrayType & ) const;

  virtual void ComputeJacobianWithRespectToParameters( const InputPointType &, JacobianType & ) const = 0;

  virtual void ComputeJacobianWithRespectToPosition( const InputPointType &, JacobianType & ) const
  {
    itkExceptionMacro( << "ComputeJacobianWithRespectToPosition not yet implemented "
                       "for " << this->GetNameOfClass() );
  }

  virtual NumberOfParametersType GetNumberOfParameters() const = 0;

  virtual NumberOfParametersType GetNumberOfParametersPerDimension() const = 0;

  virtual bool IsLinear() const
  {
    return false;
  }

  unsigned int GetNumberOfAffectedWeights() const;

  typedef typename ImageType::SpacingType   PhysicalDimensionsType;
  typedef typename ImageType::PixelType     PixelType;

  typedef SizeType MeshSizeType;


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

  BSplineBaseTransform();
  virtual ~BSplineBaseTransform();

  itkSetObjectMacro( WeightsFunction, WeightsFunctionType );

  itkGetObjectMacro( WeightsFunction, WeightsFunctionType );

  void WrapAsImages();

protected:
  void SetFixedParametersFromTransformDomainInformation() const;

  virtual void SetFixedParametersGridSizeFromTransformDomainInformation() const = 0;

  virtual void SetFixedParametersGridOriginFromTransformDomainInformation() const = 0;

  virtual void SetFixedParametersGridSpacingFromTransformDomainInformation() const = 0;

  virtual void SetFixedParametersGridDirectionFromTransformDomainInformation() const = 0;

  virtual void SetCoefficientImageInformationFromFixedParameters() =0;

  virtual bool InsideValidRegion( ContinuousIndexType & ) const = 0;

  // NOTE:  There is a natural duality between the
  //       two representations of of the coefficients
  //       whereby the m_InternalParametersBuffer is
  //       needed to fit into the optimization framework
  //       and the m_CoefficientImages is needed for
  //       the Jacobian computations.  This implementation
  //       is an attempt to remove as much redundancy as possible
  //       and share as much information between the two
  //       instances as possible.
  //
  CoefficientImageArray m_CoefficientImages;

  const ParametersType *m_InputParametersPointer;

  ParametersType m_InternalParametersBuffer;


  typename WeightsFunctionType::Pointer m_WeightsFunction;

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

  CoefficientImageArray ArrayOfImagePointerGeneratorHelper() const;
}; // class BSplineBaseTransform
}  // namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_BSplineBaseTransform(_, EXPORT, TypeX, TypeY)     \
  namespace itk                                                              \
  {                                                                          \
  _( 3 ( class EXPORT BSplineBaseTransform<ITK_TEMPLATE_3 TypeX> ) ) \
  namespace Templates                                                        \
  {                                                                          \
  typedef BSplineBaseTransform<ITK_TEMPLATE_3 TypeX>                 \
  BSplineBaseTransform##TypeY;                                       \
  }                                                                          \
  }

#if ITK_TEMPLATE_EXPLICIT
// template < class TScalarType, unsigned int NDimensions, unsigned int
// VSplineOrder >
//   const unsigned int itk::BSplineBaseTransform<TScalarType,
// NDimensions, VSplineOrder >::SpaceDimension;
// template < class TScalarType, unsigned int NDimensions, unsigned int
// VSplineOrder >
//   const unsigned int itk::BSplineBaseTransform<TScalarType,
// NDimensions, VSplineOrder >::SplineOrder;
#include "Templates/itkBSplineBaseTransform+-.h"
#endif

#if ITK_TEMPLATE_TXX
#include "itkBSplineBaseTransform.hxx"
#endif

#endif /* __itkBSplineBaseTransform_h */