Quat.h

Go to the documentation of this file.

// Mantid Repository : https://github.com/mantidproject/mantid
//
// Copyright © 2007 ISIS Rutherford Appleton Laboratory UKRI,
//   NScD Oak Ridge National Laboratory, European Spallation Source,
//   Institut Laue - Langevin & CSNS, Institute of High Energy Physics, CAS
// SPDX - License - Identifier: GPL - 3.0 +
#pragma once
 
#include "MantidKernel/DllConfig.h"
#include "MantidKernel/V3D_fwd.h"
#include <string>
#include <vector>
 
namespace Mantid {
namespace Kernel {
template <class T> class Matrix;
 
class MANTID_KERNEL_DLL Quat {
 
public:
  Quat();
  // direct quat definition
  Quat(const double _w, const double _a, const double _b, const double _c);
  // * Construct a Quat between two vectors;
  // * The angle between them is defined differently from usual if vectors are
  // not unit or the same length vectors, so quat would be not consistent
  Quat(const V3D &src, const V3D &des);
  Quat(const V3D &rX, const V3D &rY, const V3D &rZ);
  Quat(const double _deg, const V3D &_axis);
  // set a quaternion from a rotational matrix;
  Quat(const Matrix<double> &RotMat);
  void operator()(const Quat &);
  void operator()(const double ww, const double aa, const double bb, const double cc);
  void operator()(const double angle, const V3D &);
  void operator()(const V3D &rX, const V3D &rY, const V3D &rZ);
 
  void set(const double ww, const double aa, const double bb, const double cc);
  void setAngleAxis(const double _deg, const V3D &_axis);
  void getAngleAxis(double &_deg, double &_ax0, double &_ax1, double &ax2) const;
  std::vector<double> getEulerAngles(const std::string &convention) const;
  void setRotation(const double deg);
  double len() const;
  double len2() const;
  void init();
  void normalize();
  void conjugate();
  void inverse();
  bool isNull(const double tolerance = 0.001) const;
  void GLMatrix(double *mat) const;
  // vector representing M33 matrix
  // if the mod(quat) is indeed == 1 and throws otherwise.
  std::vector<double> getRotation(bool check_normalisation = false, bool throw_on_errors = false) const;
  void setQuat(const double mat[16]);
  // rotational;
  void setQuat(const Matrix<double> &rMat);
  void rotate(V3D &) const;
 
  //(xmax,ymax,zmax)
  // which means implicitly that the cube edges are parallel to the axes,
  // find the smallest bounding box with the edges also parallel to the axes
  // after rotation of the object.
  void rotateBB(double &xmin, double &ymin, double &zmin, double &xmax, double &ymax, double &zmax) const;
  Quat operator+(const Quat &) const;
  Quat &operator+=(const Quat &);
  Quat operator-(const Quat &) const;
  Quat &operator-=(const Quat &);
  Quat operator*(const Quat &) const;
  Quat &operator*=(const Quat &);
  bool operator==(const Quat &) const;
  bool operator!=(const Quat &) const;
  double operator[](int) const;
  double &operator[](int);
 
  inline double real() const { return w; }
  inline double imagI() const { return a; }
  inline double imagJ() const { return b; }
  inline double imagK() const { return c; }
 
  void printSelf(std::ostream &) const;
  void readPrinted(std::istream &);
  std::string toString() const;
  void fromString(const std::string &str);
 
private:
  double w;
  double a;
  double b;
  double c;
};
 
MANTID_KERNEL_DLL std::ostream &operator<<(std::ostream &, const Quat &);
MANTID_KERNEL_DLL std::istream &operator>>(std::istream &, Quat &q);
 
} // namespace Kernel
 
} // namespace Mantid