itkVersor.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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
 *
 *         http://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 __itkVersor_h
#define __itkVersor_h

#include "itkMatrix.h"
#include "vnl/vnl_quaternion.h"
#include "vnl/vnl_vector_fixed.h"

namespace itk
{
template< typename T >
class Versor
{
public:
  typedef Versor Self;

  typedef T ValueType;

  typedef typename NumericTraits< ValueType >::RealType RealType;

  typedef  Vector< T, 3 > VectorType;

  typedef  Point< T, 3 > PointType;

  typedef  CovariantVector< T, 3 > CovariantVectorType;

  typedef  vnl_vector_fixed< T, 3 > VnlVectorType;

  typedef  vnl_quaternion< T > VnlQuaternionType;

  typedef  Matrix< T, 3, 3 > MatrixType;

  vnl_quaternion< T > GetVnlQuaternion(void) const;

  void Set(const VnlQuaternionType &);

  void Set(T x, T y, T z, T w);

  Versor();

  Versor(const Self & v);

  const Self & operator=(const Self & v);

  const Self & operator*=(const Self & v);

  const Self & operator/=(const Self & v);

  ValueType GetTensor(void) const;

  void Normalize(void);

  Self GetConjugate(void) const;

  Self GetReciprocal(void) const;

  Self operator *(const Self & vec) const;

  Self operator/(const Self & vec) const;

  bool operator==(const Self & vec) const;

  bool operator!=(const Self & vec) const;

  ValueType GetScalar(void) const;

  ValueType GetX(void) const { return m_X; }

  ValueType GetY(void) const { return m_Y; }

  ValueType GetZ(void) const { return m_Z; }

  ValueType GetW(void) const { return m_W; }

  ValueType GetAngle(void) const;

  VectorType GetAxis(void) const;

  VectorType GetRight(void) const;

  void Set(const VectorType & axis, ValueType angle);

  void Set(const MatrixType & m);

  void Set(const VectorType & axis);

  void SetRotationAroundX(ValueType angle);

  void SetRotationAroundY(ValueType angle);

  void SetRotationAroundZ(ValueType angle);

  void SetIdentity();

  VectorType Transform(const VectorType & v) const;

  CovariantVectorType Transform(const CovariantVectorType & v) const;

  PointType Transform(const PointType & v) const;

  VnlVectorType Transform(const VnlVectorType & v) const;

  MatrixType GetMatrix(void) const;

  Self SquareRoot(void) const;

  Self Exponential(ValueType exponent) const;

private:
  static inline ValueType Epsilon(double *)
    {
      return 1e-10;
    }
  static inline ValueType Epsilon(float *)
    {
      return 1e-7;
    }
  static inline ValueType Epsilon()
    {
      return Epsilon((ValueType *)ITK_NULLPTR);
    }

  ValueType m_X;

  ValueType m_Y;

  ValueType m_Z;

  ValueType m_W;
};

template< typename T >
std::ostream & operator<<(std::ostream & os,
                                     const Versor< T > & v)
{
  os << "[ ";
  os << v.GetX() << ", " << v.GetY() << ", ";
  os << v.GetZ() << ", " << v.GetW() << " ]";
  return os;
}

template< typename T >
std::istream & operator>>(std::istream & is,
                                     Versor< T > & v);
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkVersor.hxx"
#endif

#endif