itkRigid3DPerspectiveTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkRigid3DPerspectiveTransform.h,v $
  Language:  C++
  Date:      $Date: 2009-11-28 15:53:15 $
  Version:   $Revision: 1.32 $

  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 __itkRigid3DPerspectiveTransform_h
#define __itkRigid3DPerspectiveTransform_h

#include "itkExceptionObject.h"
#include "vnl/vnl_quaternion.h"
#include <iostream>
#include "itkMatrix.h"
#include "itkTransform.h"
#include "itkVersor.h"

namespace itk
{

template <
    class TScalarType=double>    // Data type for scalars (float or double)
class ITK_EXPORT Rigid3DPerspectiveTransform : 
        public Transform<  TScalarType, 3, 2 > 
{
public:
  itkStaticConstMacro(InputSpaceDimension, unsigned int, 3);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, 2);

  itkStaticConstMacro(SpaceDimension, unsigned int, 3);
  itkStaticConstMacro(ParametersDimension, unsigned int, 6);

  typedef Rigid3DPerspectiveTransform Self;
  typedef Transform<  TScalarType, 
                      itkGetStaticConstMacro(InputSpaceDimension),
                      itkGetStaticConstMacro(OutputSpaceDimension)> Superclass;

  typedef SmartPointer<Self>        Pointer;
  typedef SmartPointer<const Self>  ConstPointer;
  
  itkTypeMacro( Rigid3DPerspectiveTransform, Transform );

  itkNewMacro( Self );

  typedef typename Superclass::ScalarType  ScalarType;

  typedef typename Superclass::ParametersType  ParametersType;
  typedef typename ParametersType::ValueType   ParameterValueType;

  typedef typename Superclass::JacobianType  JacobianType;

  typedef Matrix<TScalarType, itkGetStaticConstMacro(InputSpaceDimension), itkGetStaticConstMacro(InputSpaceDimension)> MatrixType;

  typedef Vector<TScalarType, itkGetStaticConstMacro(InputSpaceDimension)> OffsetType;
  typedef typename OffsetType::ValueType                                   OffsetValueType;

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

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

  typedef vnl_quaternion<TScalarType>           VnlQuaternionType;

  typedef Versor<TScalarType>              VersorType;
  typedef typename VersorType::VectorType  AxisType;
  typedef typename VersorType::ValueType   AngleType;
  typedef typename AxisType::ValueType     AxisValueType;

  const OffsetType & GetOffset() const
    { return m_Offset; }

  const VersorType & GetRotation() const
    { return m_Versor; }

  void SetParameters( const ParametersType & parameters );
  const ParametersType & GetParameters() const;

  void SetOffset(const OffsetType &offset)
    { m_Offset = offset; return; }

  void SetRotation(const VersorType &rotation);

  void SetRotation(const Vector<TScalarType,3> &axis, double angle);

  void SetFocalDistance( TScalarType focalDistance )
    { m_FocalDistance = focalDistance; }

  double GetFocalDistance( void ) const
    { return m_FocalDistance; }

  OutputPointType  TransformPoint(const InputPointType  &point ) const;

  const MatrixType & GetRotationMatrix() const {return m_RotationMatrix;}

  void ComputeMatrix(void);

  virtual const JacobianType & GetJacobian(const InputPointType  &point ) const;

  itkGetConstReferenceMacro(FixedOffset,OffsetType);
  itkSetMacro(FixedOffset,OffsetType);

  itkSetMacro(CenterOfRotation,InputPointType);
  itkGetConstReferenceMacro(CenterOfRotation,InputPointType);


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

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

  OffsetType          m_Offset;   

  VersorType          m_Versor; 

  TScalarType         m_FocalDistance;  

  MatrixType          m_RotationMatrix;   

  OffsetType m_FixedOffset;

  InputPointType m_CenterOfRotation;

}; //class Rigid3DPerspectiveTransform:

}  // namespace itk

// Define instantiation macro for this template.
#define ITK_TEMPLATE_Rigid3DPerspectiveTransform(_, EXPORT, x, y) namespace itk { \
  _(1(class EXPORT Rigid3DPerspectiveTransform< ITK_TEMPLATE_1 x >)) \
  namespace Templates { typedef Rigid3DPerspectiveTransform< ITK_TEMPLATE_1 x > \
                                                  Rigid3DPerspectiveTransform##y; } \
  }

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

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

#endif /* __itkRigid3DPerspectiveTransform_h */