# Quaternion(四元数)和旋转

 本文介绍了四元数以及如何在OpenGL中使用四元数表示旋转。

#### Quaternion 的定义

    q=w+xi+yj+zk


    i*i=-1

j*j=-1

k*k=-1



    q=[w,v]


#### 四元组的优点1

• 四元数不会有欧拉角存在的 gimbal lock 问题
• 四元数由4个数组成，旋转矩阵需要9个数
• 两个四元数之间更容易插值
• 四元数、矩阵在多次运算后会积攒误差，需要分别对其做规范化(normalize)和正交化(orthogonalize)，对四元数规范化更容易
• 与旋转矩阵类似，两个四元组相乘可表示两次旋转

#### Quaternion 的基本运算1

##### Normalizing a quaternion
// normalising a quaternion works similar to a vector. This method will not do anything
// if the quaternion is close enough to being unit-length. define TOLERANCE as something
// small like 0.00001f to get accurate results
void Quaternion::normalise()
{
// Don't normalize if we don't have to
float mag2 = w * w + x * x + y * y + z * z;
if (  mag2!=0.f && (fabs(mag2 - 1.0f) > TOLERANCE)) {
float mag = sqrt(mag2);
w /= mag;
x /= mag;
y /= mag;
z /= mag;
}
}


##### The complex conjugate of a quaternion
// We need to get the inverse of a quaternion to properly apply a quaternion-rotation to a vector
// The conjugate of a quaternion is the same as the inverse, as long as the quaternion is unit-length
Quaternion Quaternion::getConjugate()
{
return Quaternion(-x, -y, -z, w);
}


##### Multiplying quaternions
// Multiplying q1 with q2 applies the rotation q2 to q1
Quaternion Quaternion::operator* (const Quaternion &rq) const
{
// the constructor takes its arguments as (x, y, z, w)
return Quaternion(w * rq.x + x * rq.w + y * rq.z - z * rq.y,
w * rq.y + y * rq.w + z * rq.x - x * rq.z,
w * rq.z + z * rq.w + x * rq.y - y * rq.x,
w * rq.w - x * rq.x - y * rq.y - z * rq.z);
}


##### Rotating vectors
// Multiplying a quaternion q with a vector v applies the q-rotation to v
Vector3 Quaternion::operator* (const Vector3 &vec) const
{
Vector3 vn(vec);
vn.normalise();

Quaternion vecQuat, resQuat;
vecQuat.x = vn.x;
vecQuat.y = vn.y;
vecQuat.z = vn.z;
vecQuat.w = 0.0f;

resQuat = vecQuat * getConjugate();
resQuat = *this * resQuat;

return (Vector3(resQuat.x, resQuat.y, resQuat.z));
}



#### How to convert to/from quaternions1

##### Quaternion from axis-angle
// Convert from Axis Angle
void Quaternion::FromAxis(const Vector3 &v, float angle)
{
float sinAngle;
angle *= 0.5f;
Vector3 vn(v);
vn.normalise();

sinAngle = sin(angle);

x = (vn.x * sinAngle);
y = (vn.y * sinAngle);
z = (vn.z * sinAngle);
w = cos(angle);
}


##### Quaternion from Euler angles
// Convert from Euler Angles
void Quaternion::FromEuler(float pitch, float yaw, float roll)
{
// Basically we create 3 Quaternions, one for pitch, one for yaw, one for roll
// and multiply those together.
// the calculation below does the same, just shorter

float p = pitch * PIOVER180 / 2.0;
float y = yaw * PIOVER180 / 2.0;
float r = roll * PIOVER180 / 2.0;

float sinp = sin(p);
float siny = sin(y);
float sinr = sin(r);
float cosp = cos(p);
float cosy = cos(y);
float cosr = cos(r);

this->x = sinr * cosp * cosy - cosr * sinp * siny;
this->y = cosr * sinp * cosy + sinr * cosp * siny;
this->z = cosr * cosp * siny - sinr * sinp * cosy;
this->w = cosr * cosp * cosy + sinr * sinp * siny;

normalise();
}


##### Quaternion to Matrix
// Convert to Matrix
Matrix4 Quaternion::getMatrix() const
{
float x2 = x * x;
float y2 = y * y;
float z2 = z * z;
float xy = x * y;
float xz = x * z;
float yz = y * z;
float wx = w * x;
float wy = w * y;
float wz = w * z;

// This calculation would be a lot more complicated for non-unit length quaternions
// Note: The constructor of Matrix4 expects the Matrix in column-major format like expected by
//   OpenGL
return Matrix4( 1.0f - 2.0f * (y2 + z2), 2.0f * (xy - wz), 2.0f * (xz + wy), 0.0f,
2.0f * (xy + wz), 1.0f - 2.0f * (x2 + z2), 2.0f * (yz - wx), 0.0f,
2.0f * (xz - wy), 2.0f * (yz + wx), 1.0f - 2.0f * (x2 + y2), 0.0f,
0.0f, 0.0f, 0.0f, 1.0f)
}


##### Quaternion to axis-angle
// Convert to Axis/Angles
void Quaternion::getAxisAngle(Vector3 *axis, float *angle)
{
float scale = sqrt(x * x + y * y + z * z);
axis->x = x / scale;
axis->y = y / scale;
axis->z = z / scale;
*angle = acos(w) * 2.0f;
}



#### Quaternion 插值2

##### 线性插值

    q(t)=(1-t)q1 + t q2


    q(t)=(1-t)q1+t q2 / || (1-t)q1+t q2 ||


##### 球形线性插值

q(t)=q1 * sinθ(1-t)/sinθ + q2 * sinθt/sineθ



#### 用 Quaternion 实现 Camera 旋转

• 沿直线移动
• 围绕某轴自转
• 围绕某轴公转

    class Camera {

private:
Quaternion m_orientation;

public:
void rotate (const Quaternion& q);
void rotate(const Vector3& axis, const Radian& angle);

void roll (const GLfloat angle);
void yaw (const GLfloat angle);
void pitch (const GLfloat angle);

};

void Camera::rotate(const Quaternion& q)
{
// Note the order of the mult, i.e. q comes after
m_Orientation = q * m_Orientation;

}

void Camera::rotate(const Vector3& axis, const Radian& angle)
{
Quaternion q;
q.FromAngleAxis(angle,axis);
rotate(q);
}

void Camera::roll (const GLfloat angle) //in radian
{

Vector3 zAxis = m_Orientation * Vector3::UNIT_Z;
rotate(zAxis, angleInRadian);

}

void Camera::yaw (const GLfloat angle)  //in degree
{

Vector3 yAxis;

{
// Rotate around local Y axis
yAxis = m_Orientation * Vector3::UNIT_Y;
}

rotate(yAxis, angleInRadian);

}

void Camera::pitch (const GLfloat angle)  //in radian
{

Vector3 xAxis = m_Orientation * Vector3::UNIT_X;
rotate(xAxis, angleInRadian);

}

void Camera::gluLookAt() {
GLfloat m[4][4];

identf(&m[0][0]);
m_Orientation.createMatrix (&m[0][0]);

glMultMatrixf(&m[0][0]);
glTranslatef(-m_eyex, -m_eyey, -m_eyez);
}



#### 用 Quaternion 实现 trackball

class TrackBall
{
public:
TrackBall();

void push(const QPointF& p);
void move(const QPointF& p);
void release(const QPointF& p);

QQuaternion rotation() const;

private:
QQuaternion m_rotation;
QVector3D m_axis;
float m_angularVelocity;

QPointF m_lastPos;

};

void TrackBall::move(const QPointF& p)
{

if (!m_pressed)
return;

QVector3D lastPos3D = QVector3D(m_lastPos.x(), m_lastPos.y(), 0.0f);
float sqrZ = 1 - QVector3D::dotProduct(lastPos3D, lastPos3D);
if (sqrZ > 0)
lastPos3D.setZ(sqrt(sqrZ));
else
lastPos3D.normalize();

QVector3D currentPos3D = QVector3D(p.x(), p.y(), 0.0f);
sqrZ = 1 - QVector3D::dotProduct(currentPos3D, currentPos3D);
if (sqrZ > 0)
currentPos3D.setZ(sqrt(sqrZ));
else
currentPos3D.normalize();

m_axis = QVector3D::crossProduct(lastPos3D, currentPos3D);
float angle = 180 / PI * asin(sqrt(QVector3D::dotProduct(m_axis, m_axis)));

m_axis.normalize();
m_rotation = QQuaternion::fromAxisAndAngle(m_axis, angle) * m_rotation;

m_lastPos = p;

}



#### Yaw, pitch, roll 的含义3

Yaw – Vertical axis：

 yaw

Pitch – Lateral axis

 pitch

Roll – Longitudinal axis

 roll

The Position of All three axes

 Yaw Pitch Roll

• 本文已收录于以下专栏：

## Unity3D中的Quaternion（四元数）

Unity中四元数的基本概念和几个常用函数的用法
• liulong1567
• 2015年06月09日 00:18
• 6024

## 【Unity技巧】四元数（Quaternion）和旋转

• candycat1992
• 2014年11月23日 11:30
• 200025

## Unity3D 四元数旋转使用 Quaternion

//增量a是180度的百分比            //debug             if (Input.GetKeyDown(KeyCode.D))             {  ...
• young39
• 2017年05月02日 07:19
• 164

## three.js 源码注释（六）Math/Quaternion.js

• omni360
• 2014年10月10日 15:52
• 2704

## Eigen库使用教程之旋转矩阵，旋转向量和四元数的初始化和相互转换的实现

• u011092188
• 2017年08月20日 18:22
• 3601

## quaternion in eigen

eigen中的四元数
• zerolover
• 2016年04月17日 15:52
• 2624

## 四元数—Quaternion

• nizihabi
• 2015年07月31日 12:03
• 1894

## 四元数（Quaternion）和旋转

• xixihaha36524
• 2016年01月12日 17:57
• 208

## Unity Quaternion(四元数) 使用认识

Unity Quaternion(四元数) 使用认识项目中经常使用 Quaternion 的一些方法，比如关于 Quaternion * Quaternion , Quaternion * Vec...
• LIQIANGEASTSUN
• 2015年12月17日 12:36
• 1513

## 用C++实现一个Quaternion类

• qp120291570
• 2015年12月24日 00:04
• 4211

举报原因： 您举报文章：Quaternion(四元数)和旋转 色情 政治 抄袭 广告 招聘 骂人 其他 (最多只允许输入30个字)