itkCompositeTransform.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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
 *
 *         https://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 VDimension = 3>
class ITK_TEMPLATE_EXPORT CompositeTransform : public MultiTransform<TParametersValueType, VDimension, VDimension>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(CompositeTransform);

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

  itkOverrideGetNameOfClassMacro(CompositeTransform);

  itkNewMacro(Self);

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

  using typename Superclass::InverseTransformBasePointer;

  using typename Superclass::ScalarType;

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

  using typename Superclass::DerivativeType;

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

  using typename Superclass::TransformCategoryEnum;

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

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

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

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

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

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

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

  using typename Superclass::TransformQueueType;

  using typename Superclass::NumberOfParametersType;

  using TransformsToOptimizeFlagsType = std::deque<bool>;

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

 
  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 recently. */
  virtual void
  SetOnlyMostRecentTransformToOptimizeOn()
  {
    this->SetAllTransformsToOptimize(false);
    this->SetNthTransformToOptimizeOn(this->GetNumberOfTransforms() - 1);
  }
 
  /* Get whether the Nth transform is set to be optimized */
  /* 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;

  TransformCategoryEnum
  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 & inputParameters) 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 & inputParameters) 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 & outJacobian) const override;

  void
  ComputeJacobianWithRespectToParametersCachedTemporaries(const InputPointType & p,
                                                          JacobianType &         outJacobian,
                                                          JacobianType &         cacheJacobian) const override;
 
protected:
  CompositeTransform() = default;
  ~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();
  }

  const TransformQueueType &
  GetTransformsToOptimizeQueue() const;
 
  mutable TransformQueueType    m_TransformsToOptimizeQueue{};
  TransformsToOptimizeFlagsType m_TransformsToOptimizeFlags{};
 
private:
  mutable ModifiedTimeType m_PreviousTransformsToOptimizeUpdateTime{};
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkCompositeTransform.hxx"
#endif
 
#endif // itkCompositeTransform_h