itkThreadSafeTransform.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkThreadSafeTransform.h,v $
  Language:  C++
  Date:      $Date: 2007/07/21 22:51:26 $
  Version:   $Revision: 1.2 $

  Copyright (c) Insight Software Consortium. All rights reserved.
  See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __itkThreadSafeTransform_h
#define __itkThreadSafeTransform_h

#include "itkTransformBase.h"
#include "itkPoint.h"
#include "itkVector.h"
#include "itkCovariantVector.h"
#include "vnl/vnl_vector_fixed.h"
#include "itkArray.h"
#include "itkArray2D.h"

#include "itkObjectFactory.h"


namespace itk
{
  
template <class TScalarType,
          unsigned int NInputDimensions=3, 
          unsigned int NOutputDimensions=3>
class ITK_EXPORT  Transform  : public TransformBase
{
public:
  typedef Transform                     Self;
  typedef TransformBase                 Superclass;
  typedef SmartPointer< Self >          Pointer;
  typedef SmartPointer< const Self >    ConstPointer;

  /* Since this is an abstract class the itkNewMacro() has been removed.
   * Making this an abstract class will prevent in practice the inifinite 
   * recursion that may happen if the default implementation of the GetJacobian,
   * TransformPoint, TransformVector methods are invoked. The forward/backward
   * compatibility wraps in the default implementation would result in an
   * infinite recursion. The recurssion is avoided in derived classes by 
   * providing an overloaded implementation of the non-thread-safe or the 
   * thread-safe version of the methods listed above.
   * */

  itkTypeMacro( Transform, TransformBase );

  itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions);

  unsigned int GetInputSpaceDimension(void) const {return NInputDimensions;}

  unsigned int GetOutputSpaceDimension(void) const {return NOutputDimensions;}

  typedef  TScalarType     ScalarType;

  typedef  typename Superclass::ParametersType         ParametersType;

  typedef  Array2D< double >                           JacobianType;

  typedef Vector<TScalarType, NInputDimensions>  InputVectorType;
  typedef Vector<TScalarType, NOutputDimensions> OutputVectorType;

  typedef CovariantVector<TScalarType, NInputDimensions>  InputCovariantVectorType;
  typedef CovariantVector<TScalarType, NOutputDimensions> OutputCovariantVectorType;

  typedef vnl_vector_fixed<TScalarType, NInputDimensions>  InputVnlVectorType;
  typedef vnl_vector_fixed<TScalarType, NOutputDimensions> OutputVnlVectorType;

  typedef Point<TScalarType, NInputDimensions>   InputPointType;
  typedef Point<TScalarType, NOutputDimensions>  OutputPointType;

  virtual OutputPointType TransformPoint( const InputPointType  & inputPoint, 
                                          unsigned int itkNotUsed( threadId ) ) const
    { return this->TransformPoint( inputPoint ); } // Backward compatibility for non-thread-safe transforms.
  virtual OutputPointType TransformPoint(const InputPointType  & inputPoint ) const
    { return this->TransformPoint( inputPoint, 0 ); } // Forward compatibility for non-thread-safe transforms.

  virtual OutputVectorType    TransformVector( const InputVectorType & inputVector, 
                                               unsigned int itkNotUsed( threadId ) ) const
    { return this->TransformVector( inputVector ); } // Backward compatibility for non-thread-safe transforms.
  virtual OutputVectorType    TransformVector(const InputVectorType & inputVector ) const
    { return this->TransformVector( inputVector, 0 ); } // Forward compatibility for non-thread-safe transforms.

  virtual OutputVnlVectorType TransformVector( const InputVnlVectorType & inputVnlVector,
                                               unsigned int itkNotUsed( threadId ) ) const
    { return  this->TransformVector( inputVnlVector ); } // Backward compatibility for non-thread-safe transforms.
  virtual OutputVnlVectorType TransformVector(const InputVnlVectorType & inputVnlVector ) const
    { return TransformVector( inputVnlVector, 0 ); } // Forward compatibility for non-thread-safe transforms.

  virtual OutputCovariantVectorType TransformCovariantVector(
    const InputCovariantVectorType &inputCovariantVector, 
    unsigned int itkNotUsed( threadId ) ) const
    { return this->TransformCovariantVector( inputCovariantVector ); } // Backward compatibility for non-thread-safe transforms.
  virtual OutputCovariantVectorType TransformCovariantVector(
    const InputCovariantVectorType & inputCovariantVector ) const
    { return TransformCovariantVector( inputCovariantVector, 0 ); }  // Forward compatibility for non-thread-safe transforms.

  virtual void SetParameters( const ParametersType & ) 
    { itkExceptionMacro( << "Subclasses should override this method" ) }

  virtual void SetParametersByValue ( const ParametersType & p ) 
    { this->SetParameters ( p ); };

  virtual const ParametersType& GetParameters(void) const
    { itkExceptionMacro( << "Subclasses should override this method" );
      return m_Parameters; }

  virtual void SetFixedParameters( const ParametersType & ) 
    { itkExceptionMacro( << "Subclasses should override this method" ) };

  virtual const ParametersType& GetFixedParameters(void) const
    { itkExceptionMacro( << "Subclasses should override this method" );
      return m_Parameters; };

  virtual const JacobianType & GetJacobian( const InputPointType  & inputPoint, 
                                            unsigned int itkNotUsed( threadId ) ) const
    { return this->GetJacobian( inputPoint ); } // Backward compatibility for non-thread-safe.
  virtual const JacobianType & GetJacobian(const InputPointType  & inputPoint ) const
    { return this->GetJacobian( inputPoint, 0 ); } // Forward compatibility for non-thread-safe.


  virtual unsigned int GetNumberOfParameters(void) const 
                      { return m_Parameters.Size(); }

  bool GetInverse(Self*) const {return false;}

  virtual std::string GetTransformTypeAsString() const;

  virtual bool IsLinear() const { return false; }

  virtual void SetNumberOfThreads( unsigned int numberOfThreads ) const;
  itkGetConstReferenceMacro( NumberOfThreads, unsigned int );

protected:
  Transform(); 
  Transform(unsigned int Dimension, unsigned int NumberOfParameters);
  virtual ~Transform() {};
  void PrintSelf(std::ostream& os, Indent indent) const;


  mutable ParametersType     m_Parameters;
  mutable ParametersType     m_FixedParameters;
  mutable JacobianType       m_Jacobian;
  mutable JacobianType     * m_ThreaderJacobian;

  virtual JacobianType * GetJacobianVariableForThread( unsigned int threadId=0 ) const;

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

  mutable unsigned int       m_NumberOfThreads;
  
  unsigned int               m_JacobianDimensions;
  unsigned int               m_JacobianNumberOfParameters;

};

} // end namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_Transform(_, EXPORT, x, y) namespace itk { \
  _(3(class EXPORT Transform< ITK_TEMPLATE_3 x >)) \
  namespace Templates { typedef Transform< ITK_TEMPLATE_3 x > Transform##y; } \
  }

#if ITK_TEMPLATE_EXPLICIT
# include "Templates/itkTransform+-.h"
#endif

#if ITK_TEMPLATE_TXX
# include "itkThreadSafeTransform.txx"
#endif

#endif

---