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 ITK_TEMPLATE_EXPORT Versor
{
public:
  using Self = Versor;

  using ValueType = T;

  using RealType = typename NumericTraits< ValueType >::RealType;

  using VectorType = Vector< T, 3 >;

  using PointType = Point< T, 3 >;

  using CovariantVectorType = CovariantVector< T, 3 >;

  using VnlVectorType = vnl_vector_fixed< T, 3 >;

  using VnlQuaternionType = vnl_quaternion< T >;

  using MatrixType = Matrix< T, 3, 3 >;

  vnl_quaternion< T > GetVnlQuaternion() 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() const;

  void Normalize();

  Self GetConjugate() const;

  Self GetReciprocal() 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() const;

  ValueType GetX() const { return m_X; }

  ValueType GetY() const { return m_Y; }

  ValueType GetZ() const { return m_Z; }

  ValueType GetW() const { return m_W; }

  ValueType GetAngle() const;

  VectorType GetAxis() const;

  VectorType GetRight() 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() const;

  Self SquareRoot() 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 *)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