itkCompositeTransform.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 itkCompositeTransform_h
#define itkCompositeTransform_h

#include "itkMultiTransform.h"

#include <deque>

namespace itk
{

template<typename TParametersValueType=double, unsigned int NDimensions = 3>
class ITK_TEMPLATE_EXPORT CompositeTransform :
  public MultiTransform<TParametersValueType, NDimensions, NDimensions>
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(CompositeTransform);

  using Self = CompositeTransform;
  using Superclass = MultiTransform<TParametersValueType, NDimensions, NDimensions>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkTypeMacro( CompositeTransform, Transform );

  itkNewMacro( Self );

  using TransformType = typename Superclass::TransformType;
  using TransformTypePointer = typename Superclass::TransformTypePointer;

  using InverseTransformBasePointer = typename Superclass::InverseTransformBasePointer;

  using ScalarType = typename Superclass::ScalarType;

  using FixedParametersType = typename Superclass::FixedParametersType;
  using FixedParametersValueType = typename Superclass::FixedParametersValueType;
  using ParametersType = typename Superclass::ParametersType;
  using ParametersValueType = typename Superclass::ParametersValueType;

  using DerivativeType = typename Superclass::DerivativeType;

  using JacobianType = typename Superclass::JacobianType;
  using JacobianPositionType = typename Superclass::JacobianPositionType;
  using InverseJacobianPositionType = typename Superclass::InverseJacobianPositionType;

  using TransformCategoryType = typename Superclass::TransformCategoryType;

  using InputPointType = typename Superclass::InputPointType;
  using OutputPointType = typename Superclass::OutputPointType;

  using InputVectorType = typename Superclass::InputVectorType;
  using OutputVectorType = typename Superclass::OutputVectorType;

  using InputCovariantVectorType = typename Superclass::InputCovariantVectorType;
  using OutputCovariantVectorType = typename Superclass::OutputCovariantVectorType;

  using InputVnlVectorType = typename Superclass::InputVnlVectorType;
  using OutputVnlVectorType = typename Superclass::OutputVnlVectorType;

  using InputVectorPixelType = typename Superclass::InputVectorPixelType;
  using OutputVectorPixelType = typename Superclass::OutputVectorPixelType;

  using InputDiffusionTensor3DType = typename Superclass::InputDiffusionTensor3DType;
  using OutputDiffusionTensor3DType = typename Superclass::OutputDiffusionTensor3DType;

  using InputSymmetricSecondRankTensorType = typename Superclass::InputSymmetricSecondRankTensorType;
  using OutputSymmetricSecondRankTensorType = typename Superclass::OutputSymmetricSecondRankTensorType;

  using TransformQueueType = typename Superclass::TransformQueueType;

  using NumberOfParametersType = typename Superclass::NumberOfParametersType;

  using TransformsToOptimizeFlagsType = std::deque<bool>;

  static constexpr unsigned int InputDimension = NDimensions;
  static constexpr unsigned int OutputDimension = NDimensions;

  virtual void SetNthTransformToOptimize( SizeValueType i, bool state )
  {
    this->m_TransformsToOptimizeFlags.at(i) = state;
    this->Modified();
  }

  virtual void SetNthTransformToOptimizeOn( SizeValueType i )
  {
    this->SetNthTransformToOptimize( i, true );
  }

  virtual void SetNthTransformToOptimizeOff( SizeValueType i )
  {
    this->SetNthTransformToOptimize( i, false );
  }

  virtual void SetAllTransformsToOptimize( bool state )
  {
    this->m_TransformsToOptimizeFlags.assign(
      this->m_TransformsToOptimizeFlags.size(), state );
    this->Modified();
  }

  virtual void SetAllTransformsToOptimizeOn()
  {
    this->SetAllTransformsToOptimize( true );
  }

  virtual void SetAllTransformsToOptimizeOff()
  {
    this->SetAllTransformsToOptimize( false );
  }

  /* With AddTransform() as the only way to add a transform, we
   * can have this method to easily allow user to optimize only
   * the transform added most recenlty. */
  virtual void SetOnlyMostRecentTransformToOptimizeOn()
  {
    this->SetAllTransformsToOptimize( false );
    this->SetNthTransformToOptimizeOn( this->GetNumberOfTransforms() - 1 );
  }

  /* Get whether the Nth transform is set to be optimzied */
  /* NOTE: ambiguous function name here - are we getting if the Nth transform
      is set to be optimized, or the Nth of the transforms that are set to be
      optimized? */
  virtual bool GetNthTransformToOptimize( SizeValueType i ) const
  {
    return this->m_TransformsToOptimizeFlags.at(i);
  }

  virtual const TransformsToOptimizeFlagsType & GetTransformsToOptimizeFlags() const
  {
    return this->m_TransformsToOptimizeFlags;
  }

  void ClearTransformQueue() override
  {
    Superclass::ClearTransformQueue();
    this->m_TransformsToOptimizeFlags.clear();
  }

  bool GetInverse( Self *inverse ) const;

  InverseTransformBasePointer GetInverseTransform() const override;

  OutputPointType TransformPoint( const InputPointType & inputPoint ) const override;

  using Superclass::TransformVector;
  OutputVectorType TransformVector(const InputVectorType &) const override;

  OutputVnlVectorType TransformVector(const InputVnlVectorType & inputVector) const override;

  OutputVectorPixelType TransformVector(const InputVectorPixelType & inputVector ) const override;

  OutputVectorType TransformVector(const InputVectorType & inputVector,
                                           const InputPointType & inputPoint ) const override;

  OutputVnlVectorType TransformVector(const InputVnlVectorType & inputVector,
                                              const InputPointType & inputPoint ) const override;

  OutputVectorPixelType TransformVector(const InputVectorPixelType & inputVector,
                                                const InputPointType & inputPoint ) const override;

  using Superclass::TransformCovariantVector;
  OutputCovariantVectorType TransformCovariantVector(const InputCovariantVectorType &) const override;

  OutputVectorPixelType TransformCovariantVector(const InputVectorPixelType &) const override;

  OutputCovariantVectorType TransformCovariantVector(const InputCovariantVectorType & inputVector,
                                                             const InputPointType & inputPoint ) const override;

  OutputVectorPixelType TransformCovariantVector(const InputVectorPixelType & inputVector,
                                                         const InputPointType & inputPoint ) const override;

  using Superclass::TransformDiffusionTensor3D;
  OutputDiffusionTensor3DType TransformDiffusionTensor3D(
    const InputDiffusionTensor3DType & inputTensor) const override;

  OutputVectorPixelType TransformDiffusionTensor3D(
    const InputVectorPixelType & inputTensor) const override;

  OutputDiffusionTensor3DType TransformDiffusionTensor3D(
    const InputDiffusionTensor3DType & inputTensor,
    const InputPointType & inputPoint ) const override;

  OutputVectorPixelType TransformDiffusionTensor3D(
    const InputVectorPixelType & inputTensor,
    const InputPointType & inputPoint ) const override;

  using Superclass::TransformSymmetricSecondRankTensor;
  OutputSymmetricSecondRankTensorType TransformSymmetricSecondRankTensor(
    const InputSymmetricSecondRankTensorType & inputTensor) const override;

  OutputVectorPixelType TransformSymmetricSecondRankTensor(
    const InputVectorPixelType & inputTensor) const override;

  OutputSymmetricSecondRankTensorType TransformSymmetricSecondRankTensor(
    const InputSymmetricSecondRankTensorType & inputTensor,
    const InputPointType & inputPoint ) const override;

  OutputVectorPixelType TransformSymmetricSecondRankTensor(
    const InputVectorPixelType & inputTensor,
    const InputPointType & inputPoint ) const override;

  TransformCategoryType GetTransformCategory() const override;

  const ParametersType & GetParameters() const override;

  /* SetParameters only for transforms that are set to be optimized
   * See GetParameters() for parameter ordering. */
  void  SetParameters(const ParametersType & p) override;

  /* GetFixedParameters only for transforms that are set to be optimized
   * See GetParameters() for parameter ordering. */
  const FixedParametersType & GetFixedParameters() const override;

  /* SetFixedParameters only for transforms that are set to be optimized.
   * See GetParameters() for parameter ordering. */
  void  SetFixedParameters(const FixedParametersType & fixedParameters) override;

  /* Get total number of parameters for transforms that are set to be
   * optimized */
  NumberOfParametersType GetNumberOfParameters() const override;

  /* Get total number of local parameters for transforms that are set
   * to be optimized */
  NumberOfParametersType GetNumberOfLocalParameters() const override;

  /* Get total number of fixed parameters for transforms that are set
   * to be optimized */
  NumberOfParametersType GetNumberOfFixedParameters() const override;

  void UpdateTransformParameters( const DerivativeType & update, ScalarType factor = 1.0 ) override;

  virtual void FlattenTransformQueue();

  void ComputeJacobianWithRespectToParameters(const InputPointType  & p, JacobianType & j) const override;

  void ComputeJacobianWithRespectToParametersCachedTemporaries( const InputPointType & p,
                                                                JacobianType & outJacobian,
                                                                JacobianType & cacheJacobian ) const override;

protected:
  CompositeTransform();
  ~CompositeTransform() override = default;
  void PrintSelf( std::ostream& os, Indent indent ) const override;

  typename LightObject::Pointer InternalClone() const override;

  void PushFrontTransform( TransformTypePointer t  ) override
  {
    Superclass::PushFrontTransform( t );
    /* Add element to list of flags, and set true by default */
    this->m_TransformsToOptimizeFlags.push_front( true );
  }

  void PushBackTransform( TransformTypePointer t  ) override
  {
    Superclass::PushBackTransform( t );
    /* Add element to list of flags, and set true by default */
    this->m_TransformsToOptimizeFlags.push_back( true );
  }

  void PopFrontTransform() override
  {
    Superclass::PopFrontTransform();
    this->m_TransformsToOptimizeFlags.pop_front();
  }

  void PopBackTransform() override
  {
    Superclass::PopBackTransform();
    this->m_TransformsToOptimizeFlags.pop_back();
  }

  TransformQueueType & GetTransformsToOptimizeQueue() const;

  mutable TransformQueueType            m_TransformsToOptimizeQueue;
  mutable TransformsToOptimizeFlagsType m_TransformsToOptimizeFlags;

private:
  mutable ModifiedTimeType m_PreviousTransformsToOptimizeUpdateTime;

};

} // end namespace itk

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

#endif // itkCompositeTransform_h