1
概述
编辑
四元数(Quaternions)是由爱尔兰数学家
哈密顿(William Rowan Hamilton,1805-1865)在1843年发明的数学概念。四元数的
乘法不符合
交换律(commutative law),故
威廉·卢云·哈密顿
它似乎破坏了科学知识中一个最基本的原则。
明确地说,四元数是复数的不可交换延伸。如把四元数的集合考虑成多维实数空间的话,四元数就代表着一个
四维空间,相对于复数为
二维空间。
四元数是
除环(除法环)的一个例子。除了没有
乘法的交换律外,
除法环与域是相类的。特别地,乘法的
结合律仍旧存在、非零元素仍有唯一的
逆元素。
四元数形成一个在实数上的四维
结合代数(事实上是除法代数),并包括复数,但不与复数组成结合代数。四元数(以及实数和复数)都只是有限维的实数结合除法代数。
四元数的不可交换性往往导致一些令人意外的结果,例如四元数的 n-阶多项式能有多于 n 个不同的根。
2基本性质编辑
四元数就是形如 ai+bj+ck+d 的数,a、b、c、d是实数。
i^2=j^2=k^2=-1
ij=k、ji=-k、jk=i、kj=-i、ki=j、ik=-j
(a^2+b^2+c^2+d^2)的
平方根,称为四元数的模。
3例子编辑
假设:
x = 3 + i
y = 5i + j - 2k
那么:
x + y = 3 + 6i + j - 2k
xy =( {3 + i} )( {5i + j - 2k} ) = 15i + 3j - 6k + 5i^2 + ij - 2ik
= 15i + 3j - 6k - 5 + k + 2j = - 5 + 15i + 5j - 5k
4群旋转编辑
像在四元数和
空间转动条目中详细解释的那样,非零四元数的乘法群在R3的取实部为零的
拷贝上以共轭作用可以实现转动。单位四元数(绝对值为1的四元数)的共轭作用,若实部为cos(t),是一个角度为2t的转动,转轴为虚部的方向。四元数的优点是:
非奇异表达(和例如
欧拉角之类的表示相比)
比
矩阵更紧凑(更快速)
单位四元数的对可以表示四维空间中的一个转动。
所有单位四元数的集合组成一个三维球S3和在乘法下的一个群(一个
李群)。S3是行列式为1的实正交3×3正交矩阵的群SO(3,R)的双面覆盖,因为每两个单位四元数通过上述关系对应于一个转动。群S3和SU(2)同构,SU(2)是行列式为1的复酉2×2矩阵的群。令A为形为a + bi + cj + dk的四元数的集合,其中a,b,c和d或者都是整数或者都是分子为奇数分母为2的有理数。集合A是一个环,并且是一个格。该环中存在24个四元数,而它们是
施莱夫利符号为{3,4,3}的正二十四胞体的顶点。
5矩阵表示编辑
有两种方法能以矩阵表示四元数,并以矩阵之加法、乘法应用于四元数之加法、乘法。
第一种是以二阶复数矩阵表示。若 h = a + bi + cj + dk 则它的复数形式为:
这种表示法有如下优点:
所有复数 (c = d = 0) 就相应于一个实矩阵。
四元数的
绝对值的平方就等于矩阵的
行列式。
四元数的共轭值就等于矩阵的
共轭转置。
对于单位四元数 (|h| = 1)而言,这种表示方式给了四维球体和SU(2)之间的一个同型,而后者对于量子力学中的
自旋的研究十分重要。(请另见
泡利矩阵)
第二种则是以四阶实数矩阵表示:
其中四元数的共轭等于矩阵的转置。
6历史编辑
四元数是由
哈密顿在1843年爱尔兰发现的。当时他正研究扩展复数到更高的维次(复数可视为平面上的点)。他不能做到
三维空间的例子,但四维则造出四元数。根据哈密顿记述,他于10月16日跟他的妻子在
都柏林的皇家运河(Royal Canal)上散步时突然想到 <math>i^2 = j^2 = k^2 = ijk = -1 \,</math>Image:Quaternion Plague on Broom Bridge.jpg的方程解。之后哈密顿立刻将此方程刻在附近布鲁穆桥(Brougham Bridge,现称为金雀花桥 Broom Bridge)。这条方程放弃了交换律,是当时一个极端的想法(那时还未发展出向量和矩阵)。
不只如此,哈密顿还创造了向量的内外积。他亦把四元数描绘成一个有序的四重实数:一个纯量(a)和向量(bi + cj + dk)的组合。若两个纯量部为零的四元数相乘,所得的纯量部便是原来的两个向量部的纯量积的负值,而向量部则为
向量积的值,但它们的重要性仍有待发掘。
哈密顿之后继续推广四元数,并出了几本书。最后一本《四元数的原理》(Elements of Quaternions)于他死后不久出版,长达八百多页。
7用途争辩编辑
即使到目前为止四元数的用途仍在争辩之中。一些哈密顿的支持者非常反对
奥利弗·亥维赛(Oliver Heaviside)的向量
代数学和
约西亚·威拉德·吉布斯(Josiah Willard Gibbs)的
向量微积分的发展,以维持四元数的超然地位。对于三维空间这可以讨论,但对于更高维四元数就失效了(但可用延伸如
八元数和柯利弗德代数学)。而事实上,在二十世纪中叶的科学和工程界中,
向量几乎已完全取代四元数的位置。
詹姆斯·克拉克·麦克斯韦(James Clerk Maxwell)曾经在他的《电磁场动力理论》(A Dynamical Theory of Electromagnetic Field)直接以20条有20个变量的微分方程组来解释电力、磁力和电磁场之间的关系。某些早期的
麦克斯韦方程组使用了四元数来表述,但与后来亥维赛使用四条以向量为基础的麦克斯韦方程组表述相比较,使用四元数的表述并没有流行起来。
8运算编辑
综述
四元数运算在
电动力学与
广义相对论中有广泛的应用。四元数可以用来取代
张量表示。有时候采用带有复数元素之四元数会比较容易,导得结果不为除法代数之形式。然而亦可结合共轭运算以达到相同的运算结果。
此处仅讨论具有实数元素之四元数,并将以两种形式来描述四元数。其中一种是向量与
纯量的结合,另一形式两个创建量(constructor)与双向量(bivector;i、j与k)的结合。
定义两个四元数:
其中
表示矢量
;而
表示矢量
。
四元数加法:p + q
跟复数、向量和矩阵一样,两个四元数之和需要将不同的元素加起来。
加法遵循实数和复数的所有交换律和结合律。
四元数乘法:pq
两个四元数之间的非可换乘积通常被
格拉斯曼(Hermann Grassmann)称为积,这个积上面已经简单介绍过,它的完整型态是︰
由于四元数乘法的非可换性,pq并不等于qp。格拉斯曼积常用在描述许多其他代数函数。qp乘积的向量部分是:
四元数点积: p · q
点积也叫做欧几里德内积,四元数的点积等同于一个四维向量的点积。点积的值是p中每个元素的数值与q中相应元素的数值的乘积的和。这是四元数之间的可换积,并返回一个
标量。
点积可以用格拉斯曼积的形式表示:
这个积对于从四元数分离出一个元素有用。例如,i项可以从p中这样提出来:
四元数外积:Outer(p,q)
欧几里德外积并不常用; 然而因为外积和内积的格拉斯曼积形式的相似性,它们总是一同被提及:
四元数偶积:Even(p,q)
四元数偶积也不常用,但是它也会被提到,因为它和奇积的相似性。它是纯对称的积;因此,它是完全可交换的。
叉积:p × q
四元数叉积也称为奇积。它和向量叉积等价,并且只返回一个向量值:
四元数转置:p−1
四元数的转置通过
被定义。它定义在上面的定义一节,位于属性之下(注意变量记法的差异)。其建构方式相同于复倒数(complex inverse)之构造:
一个四元数的自身点积是个纯量。四元数除以一个纯量等效于乘上此纯量的倒数,而使四元数的每个元素皆除以此一除数。
四元数除法:p−1q
四元数的不可换性导致了
和
的不同。这意味着除非p是一个标量,否则不能使用q/p这一符号。
四元数纯量部:Scalar(p)
四元数的标量部分可以用前面所述的点积来分离出来:
四元数向量部:Vector(p)
四元数的向量部分可以用外积提取出来,就象用点积分离标量那样:
四元数模:|p|
四元数的绝对值是四元数到原点的距离。
四元数符号数:sgn(p)
一复数之符号数乃得出单位圆上,一个方向与原复数相同之复数。四元数的符号数亦产生单位四元数:
四元数辐角:arg(p)
幅角函数可找出一4-向量四元数偏离单位纯量(即:1)之角度。此函数输出一个纯量角度。
Quaternion(四元数)
Quaternion 的定义
四元数一般定义如下:
q=w+xi+yj+zk
其中 w,x,y,z是实数。同时,有:
i*i=-1
j*j=-1
k*k=-1
四元数也可以表示为:
q=[w,v]
其中v=(x,y,z)是矢量,w是标量,虽然v是矢量,但不能简单的理解为3D空间的矢量,它是4维空间中的的矢量,也是非常不容易想像的。
通俗的讲,一个四元数(Quaternion)描述了一个旋转轴和一个旋转角度。这个旋转轴和这个角度可以通过 Quaternion::ToAngleAxis转换得到。当然也可以随意指定一个角度一个旋转轴来构造一个Quaternion。这个角度是相对于单位四元数而言的,也可以说是相对于物体的初始方向而言的。
当用一个四元数乘以一个向量时,实际上就是让该向量围绕着这个四元数所描述的旋转轴,转动这个四元数所描述的角度而得到的向量。
四元组的优点
有多种方式可表示旋转,如 axis/angle、欧拉角(Euler angles)、矩阵(matrix)、四元组等。 相对于其它方法,四元组有其本身的优点:
四元数不会有欧拉角存在的 gimbal lock 问题
四元数由4个数组成,旋转矩阵需要9个数
两个四元数之间更容易插值
四元数、矩阵在多次运算后会积攒误差,需要分别对其做规范化(normalize)和正交化(orthogonalize),对四元数规范化更容易
与旋转矩阵类似,两个四元组相乘可表示两次旋转
Quaternion 的基本运算
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 插值
线性插值
最简单的插值算法就是线性插值,公式如:
q(t)=(1-t)q1 + t q2
但这个结果是需要规格化的,否则q(t)的单位长度会发生变化,所以
q(t)=(1-t)q1+t q2 / || (1-t)q1+t q2 ||
球形线性插值
尽管线性插值很有效,但不能以恒定的速率描述q1到q2之间的曲线,这也是其弊端,我们需要找到一种插值方法使得q1->q(t)之间的夹角θ是线性的,即θ(t)=(1-t)θ1+t*θ2,这样我们得到了球形线性插值函数q(t),如下:
q(t)=q1 * sinθ(1-t)/sinθ + q2 * sinθt/sineθ
如果使用D3D,可以直接使用 D3DXQuaternionSlerp 函数就可以完成这个插值过程。
用 Quaternion 实现 Camera 旋转
总体来讲,Camera 的操作可分为如下几类:
沿直线移动
围绕某轴自转
围绕某轴公转
下面是一个使用了 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
用鼠标拖动物体在三维空间里旋转,一般设计一个 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;
}
---------------------------------------------------------------------------------------------------------
每一个单位四元数都可以对应到一个旋转矩阵
单位四元数q=(s,V)的共轭为q*=(s,-V)
单位四元数的模为||q||=1;
四元数q=(s,V)的逆q^(-1)=q*/(||q||)=q*
一个向量r,沿着向量n旋转a角度之后的向量是哪个(假设为v),这个用四元数可以轻松搞定
构造两个四元数q=(cos(a/2),sin(a/2)*n),p=(0,r)
p`=q * p * q^(-1) 这个可以保证求出来的p`也是(0,r`)形式的,求出的r`就是r旋转后的向量
另外其实对p做q * p * q^(-1)操作就是相当于对p乘了一个旋转矩阵,这里先假设 q=(cos(a/2),sin(a/2)*n)=(s,(x, y, z))
两个四元数相乘也表示一个旋转
Q1 * Q2 表示先以Q2旋转,再以Q1旋转
则这个矩阵为
同理一个旋转矩阵也可以转换为一个四元数,即给你一个旋转矩阵可以求出(s,x,y,z)这个四元数,
方法是: