itkRigid3DPerspectiveTransform.h

Go to the documentation of this file.

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

  Program:   Insight Segmentation & Registration Toolkit
  Module:    $RCSfile: itkRigid3DPerspectiveTransform.h,v $
  Language:  C++
  Date:      $Date: 2003/02/01 01:47:29 $
  Version:   $Revision: 1.24 $

  Copyright (c) 2002 Insight 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, 7);

  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 Superclass::JacobianType  JacobianType;

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

  typedef Vector<TScalarType, itkGetStaticConstMacro(InputSpaceDimension)> OffsetType;

  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;
  
  const OffsetType & GetOffset() const
    { return m_Offset; }

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

  void SetParameters( const ParametersType & parameters );

  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; }

  void SetHeight( TScalarType height )
    { m_Height = height; }

  void SetWidth( TScalarType width )
    { m_Width = width; }

  OutputPointType  TransformPoint(const InputPointType  &point ) const;

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

  void ComputeMatrix(void);

  virtual const JacobianType & GetJacobian(const InputPointType  &point ) const;
  
  itkGetConstMacro(ObjectToPlaneDistance,float);
  itkSetMacro(ObjectToPlaneDistance,float);

  itkGetConstMacro(FixedOffset,OffsetType);
  itkSetMacro(FixedOffset,OffsetType);

  itkSetMacro(CenterOfRotation,InputPointType);
  itkGetMacro(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;  

  TScalarType         m_Height;  

  TScalarType         m_Width;  

  MatrixType          m_RotationMatrix;   

  float m_ObjectToPlaneDistance;
  
  OffsetType m_FixedOffset;

  InputPointType m_CenterOfRotation;


}; //class Rigid3DPerspectiveTransform:



}  // namespace itk


#ifndef ITK_MANUAL_INSTANTIATION
#include "itkRigid3DPerspectiveTransform.txx"
#endif

#endif /* __itkRigid3DPerspectiveTransform_h */

---