itkPerspectiveProjectionTransform.h

Go to the documentation of this file.

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

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

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

#ifndef itkPerspectiveProjectionTransform_h
#define itkPerspectiveProjectionTransform_h

#include <itkExceptionObject.h>
#include <iostream>
#include <itkMatrix.h>
#include <itkTransform.h>

namespace itk
{

template <class TScalarType=double>    // Data type for scalars (float or double)
class ITK_EXPORT PerspectiveProjectionTransform : 
        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, 3);

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

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

  itkNewMacro( Self );

  typedef typename Superclass::ScalarType  ScalarType;

  typedef typename Superclass::ParametersType  ParametersType;

  typedef typename Superclass::JacobianType  JacobianType;

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

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

  void SetParameters( const ParametersType & parameters );
  const ParametersType & GetParameters() const;
  
  virtual void SetFixedParameters( const ParametersType & ) {}

  virtual const ParametersType& GetFixedParameters(void) const
  { return this->m_FixedParameters; }

  void SetFocalDistance( TScalarType focalDistance )
    { this->m_Parameters[0] = focalDistance;  this->Modified(); }

  double GetFocalDistance( void ) const
    { return this->m_Parameters[0]; }

  void SetOriginIn2D( TScalarType u0, TScalarType v0 )
    {
      this->m_Parameters[1] = u0;
      this->m_Parameters[2] = v0;
      this->Modified();
    }
  
  void SetK1IsNegative( void ) { this->m_k1 = 1.; this->Modified(); }
  void SetK2IsNegative( void ) { this->m_k2 = 1.; this->Modified(); }

  void GetOriginIn2D( TScalarType &u0, TScalarType &v0 )
    {
      u0 = this->m_Parameters[1];
      v0 = this->m_Parameters[2];
    }

  MatrixType GetMatrix() const;

  OutputPointType  TransformPoint(const InputPointType  &point ) const;

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

  virtual void ComputeJacobianWithRespectToParameters(const InputPointType & point,
                                                      JacobianType & jacobian ) const;

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

  // Coefficient (1 or -1) indicating that the the 'x' dimension of the 2D projection is inverted
  double m_k1;
  // Coefficient (1 or -1) indicating that the the 'y' dimension of the 2D projection is inverted
  double m_k2;


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

}; //class PerspectiveProjectionTransform:



}  // namespace itk

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

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

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

#endif /* __itkPerspectiveProjectionTransform_h */