GeQuaternion.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
 
 
#ifndef OD_GEQUATERNION_H
#define OD_GEQUATERNION_H 
#include "Ge/GeExport.h"
#include "Ge/GeMatrix3d.h"
 
 
#include "TD_PackPush.h"
 
class GE_TOOLKIT_EXPORT OdGeQuaternion
{
public:
  
  OdGeQuaternion()
    : w(1.), x(0.), y(0.), z(0.)
  {}
  
  OdGeQuaternion(double ww, double xx, double yy, double zz)
    : w(ww), x(xx), y(yy), z(zz)
  {}
 
  OdGeQuaternion& set(double ww, double xx, double yy, double zz)
  {
    w = ww;
    x = xx;
    y = yy;
    z = zz;
    return *this;
  }
 
  OdGeQuaternion& set(const OdGeMatrix3d& matrix);
 
  OdGeMatrix3d getMatrix() const
  {
    OdGeMatrix3d matrix;
 
    matrix(0, 0) = w * w + x * x - y * y - z * z;
    matrix(0, 1) = 2. * (x * y - w * z);
    matrix(0, 2) = 2. * (w * y + x * z);
 
    matrix(1, 0) = 2. * (w * z + x * y);
    matrix(1, 1) = w * w - x * x + y * y - z * z;
    matrix(1, 2) = 2. * (y * z - w * x);
 
    matrix(2, 0) = 2. * (x * z - w * y);
    matrix(2, 1) = 2. * (w * x + y * z);
    matrix(2, 2) = w * w - x * x - y * y + z * z;
 
    return matrix;
  }
 
  OdGePoint3d rotate(OdGePoint3d& sourcePoint) const
  {
    OdGeMatrix3d matrix = getMatrix();
 
    return sourcePoint.transformBy(matrix);
  }
 
  OdGeVector3d rotate(OdGeVector3d& vector) const
  {
    OdGeMatrix3d matrix = getMatrix();
 
    return vector.transformBy(matrix);
  }
 
  // DGN special (they use Shuster multiplication convention)
 
  OdGePoint3d rotateOpposite(OdGePoint3d& sourcePoint) const
  {
    OdGeMatrix3d matrix = getMatrix().transpose();
 
    return sourcePoint.transformBy(matrix);
  }
 
  OdGeVector3d rotateOpposite(OdGeVector3d& vector) const
  {
    OdGeMatrix3d matrix = getMatrix().transpose();
 
    return vector.transformBy(matrix);
  }
 
 
  bool isEqualTo(
    const OdGeQuaternion& quat,
    const OdGeTol& tol = OdGeContext::gTol) const
  {
    return fabs(x - quat.x) <= tol.equalVector() &&
           fabs(y - quat.y) <= tol.equalVector() &&
           fabs(z - quat.z) <= tol.equalVector() &&
           fabs(w - quat.w) <= tol.equalVector();
  }
 
  bool operator ==(const OdGeQuaternion& quat) const
  {
    return isEqualTo(quat);
  }
  
  bool operator !=(const OdGeQuaternion& quat) const
  {
    return !isEqualTo(quat);
  }
 
  OdGeQuaternion operator *(
    double scale) const
  {
    return OdGeQuaternion(w * scale, x * scale, y * scale, z * scale);
  }
 
  OdGeQuaternion& operator *=(
    double scale)
  {
    w *= scale;
    x *= scale;
    y *= scale;
    z *= scale;
    return *this;
  }
 
  OdGeQuaternion operator /(
    double scale) const
  {
    return OdGeQuaternion(w / scale, x / scale, y / scale, z / scale);
  }
 
  OdGeQuaternion& operator /=(
    double scale)
  {
    w /= scale;
    x /= scale;
    y /= scale;
    z /= scale;
    return *this;
  }
 
  OdGeQuaternion operator +(
    const OdGeQuaternion& quat) const
  {
    return OdGeQuaternion(w + quat.w, x + quat.x, y + quat.y, z + quat.z);
  }
 
  OdGeQuaternion& operator +=(
    const OdGeQuaternion& quat)
  {
    w += quat.w;
    x += quat.x,
    y += quat.y;
    z += quat.z;
    return *this;
  }
 
  OdGeQuaternion operator -(
    const OdGeQuaternion& quat) const
  {
    return OdGeQuaternion(w - quat.w, x - quat.x, y - quat.y, z - quat.z);
  }
 
  OdGeQuaternion& operator -=(
    const OdGeQuaternion& quat)
  {
    w -= quat.w;
    x -= quat.x,
    y -= quat.y;
    z -= quat.z;
    return *this;
  }
 
 
  OdGeQuaternion operator -() const { return OdGeQuaternion(-w, -x, -y, -z); }
 
  double normSqrd() const { return w*w + x*x + y*y + z*z; }
 
  double norm() const;
 
  OdGeQuaternion& normalize(const OdGeTol& tol = OdGeContext::gTol);
 
  double dotProduct(const OdGeQuaternion& quat) const
  {
    return w * quat.w + x * quat.x + y * quat.y + z * quat.z;
  }
 
  OdGeQuaternion slerp(OdGeQuaternion& q, double t, bool bUseShortestPath);
 
  double w;
  double x;
  double y;
  double z;
 
  GE_STATIC_EXPORT static const OdGeQuaternion kIdentity;
 
};
 
#include "TD_PackPop.h"
 
 
#endif // OD_GEQUATERNION_H