旋转变换 | 欧拉角的约定与四元数的优势

注：本文为 "旋转变换" 相关合辑。

图片清晰度受引文原图所限。

略作重排，如有内容异常，请看原文。

旋转变换（一）旋转矩阵

csxiaoshui 原创于 2017-03-27 17:15:37 发布

1. 简介

在计算机图形学中，仿射变换是一类应用广泛的特殊变换，其基本形式包括平移、旋转、缩放与剪切。本文及后续系列文章将重点探讨旋转变换，涵盖二维旋转变换、三维旋转变换及其多种数学表达形式（旋转矩阵、四元数、欧拉角等）。

2. 绕原点的二维旋转

二维旋转的关键是围绕某一固定点进行角度偏转，三维旋转则围绕某一固定轴进行。其中，绕坐标原点的二维旋转是最基础的场景，如图所示：

如图所示，点 v v v 绕原点旋转 θ \theta θ 角后得到点 v ′ v' v′。设点 v v v 的坐标为 ( x , y ) (x, y) (x,y)，原点到点 v v v 的距离为 r r r，原点与点 v v v 构成的向量与 x x x 轴的夹角为 ϕ \phi ϕ，则点 v v v 的坐标可表示为：
x = r cos ⁡ ϕ , y = r sin ⁡ ϕ x = r\cos\phi, \quad y = r\sin\phi x=rcosϕ,y=rsinϕ

点 v ′ v' v′ 的坐标 ( x ′ , y ′ ) (x', y') (x′,y′) 满足：
x ′ = r cos ⁡ ( θ + ϕ ) , y ′ = r sin ⁡ ( θ + ϕ ) x' = r\cos(\theta + \phi), \quad y' = r\sin(\theta + \phi) x′=rcos(θ+ϕ),y′=rsin(θ+ϕ)

根据三角函数和角公式展开：
x ′ = r cos ⁡ θ cos ⁡ ϕ − r sin ⁡ θ sin ⁡ ϕ y ′ = r sin ⁡ θ cos ⁡ ϕ + r cos ⁡ θ sin ⁡ ϕ x' = r\cos\theta\cos\phi - r\sin\theta\sin\phi \\ y' = r\sin\theta\cos\phi + r\cos\theta\sin\phi x′=rcosθcosϕ−rsinθsinϕy′=rsinθcosϕ+rcosθsinϕ

将 x = r cos ⁡ ϕ x = r\cos\phi x=rcosϕ 与 y = r sin ⁡ ϕ y = r\sin\phi y=rsinϕ 代入上式，化简得：
x ′ = x cos ⁡ θ − y sin ⁡ θ y ′ = x sin ⁡ θ + y cos ⁡ θ x' = x\cos\theta - y\sin\theta \\ y' = x\sin\theta + y\cos\theta x′=xcosθ−ysinθy′=xsinθ+ycosθ

写成矩阵形式为：

x ′ y ′ \] = \[ cos ⁡ θ − sin ⁡ θ sin ⁡ θ cos ⁡ θ \] ⋅ \[ x y \] \\begin{bmatrix} x' \\\\ y' \\end{bmatrix} = \\begin{bmatrix} \\cos\\theta \& -\\sin\\theta \\\\ \\sin\\theta \& \\cos\\theta \\end{bmatrix} \\cdot \\begin{bmatrix} x \\\\ y \\end{bmatrix} \[x′y′\]=\[cosθsinθ−sinθcosθ\]⋅\[xy

上述推导基于三角函数的基本定义，适用于任意旋转角度（如大于 18 0 ∘ 180^\circ 180∘ 或负角度），并非局限于图示中的锐角场景。

3. 绕任意点的二维旋转

绕原点的旋转是二维旋转的基础形式，绕任意点的旋转可通过坐标变换转化为绕原点的旋转，具体步骤如下：

将旋转中心平移至坐标原点；
执行绕原点的旋转操作（参考第 2 节）；
将旋转中心平移回原始位置。

设平移矩阵为 T ( t x , t y ) T(t_x, t_y) T(tx,ty)（表示沿 x x x 轴平移 t x t_x tx、沿 y y y 轴平移 t y t_y ty），则绕任意点的旋转变换可表示为：
v ′ = T ( t x , t y ) ⋅ R ( θ ) ⋅ T ( − t x , − t y ) ⋅ v v' = T(t_x, t_y) \cdot R(\theta) \cdot T(-t_x, -t_y) \cdot v v′=T(tx,ty)⋅R(θ)⋅T(−tx,−ty)⋅v

其中， v v v 为原始点坐标， v ′ v' v′ 为旋转后点坐标， R ( θ ) R(\theta) R(θ) 为绕原点的旋转矩阵。由于采用列向量表示点坐标，矩阵运算遵循左乘规则，先执行平移 T ( − t x , − t y ) T(-t_x, -t_y) T(−tx,−ty) 将旋转中心移至原点。

在计算机图形学中，为统一描述平移、旋转、缩放等变换，需引入齐次坐标。二维变换中，齐次坐标采用 ( x , y , w ) (x, y, w) (x,y,w) 表示（通常取 w = 1 w=1 w=1），通过 3×3 矩阵实现各类变换的统一表达（三维变换则需 4×4 矩阵）。

3.1 二维平移的矩阵表示

如图所示，点 P ( x , y ) P(x, y) P(x,y) 沿 x x x 轴平移 t x t_x tx、沿 y y y 轴平移 t y t_y ty 后得到点 P ′ ( x ′ , y ′ ) P'(x', y') P′(x′,y′)，其坐标关系为：

x ′ = x + t x , y ′ = y + t y x' = x + t_x, \quad y' = y + t_y x′=x+tx,y′=y+ty

采用齐次坐标表示为：

这与二维旋转矩阵完全一致，说明复数乘法可等价描述复平面内绕原点的旋转。

2. 四元数的定义与运算

复数可描述二维旋转，但直接拓展为"三维复数"（ z = a + b i + c j z = a+bi+cj z=a+bi+cj）会导致乘法不闭合（运算结果超出三维空间）。威廉·哈密顿（William Hamilton）于 1843 年提出四元数，通过引入第四个分量解决了这一问题，并将公式刻于爱尔兰布鲁姆桥（Broom Bridge）。

2.1 四元数的表示形式

四元数有两种常用表示法：

拆分形式： q = [ s , v ] q = [s, \boldsymbol{v}] q=[s,v]（ s ∈ R s \in \mathbb{R} s∈R 为实部， v = ( x , y , z ) ∈ R 3 \boldsymbol{v} = (x,y,z) \in \mathbb{R}^3 v=(x,y,z)∈R3 为虚部向量）；
完整形式： q = s + x i + y j + z k q = s + xi + yj + zk q=s+xi+yj+zk（ i , j , k i,j,k i,j,k 为虚部单位，满足 i 2 = j 2 = k 2 = − 1 i^2=j^2=k^2=-1 i2=j2=k2=−1，且 i j = k , j i = − k , j k = i , k j = − i , k i = j , i k = − j ij=k, ji=-k, jk=i, kj=-i, ki=j, ik=-j ij=k,ji=−k,jk=i,kj=−i,ki=j,ik=−j）。

2.2 四元数的基本运算

以下实现基于四元数类 Quat，其成员 _v[4] 存储 ( x , y , z , w ) (x,y,z,w) (x,y,z,w)（ w w w 对应实部 s s s）。

2.2.1 加减法

加法：对应分量相加， q 1 + q 2 = ( s 1 + s 2 , x 1 + x 2 , y 1 + y 2 , z 1 + z 2 ) q_1 + q_2 = (s_1+s_2, x_1+x_2, y_1+y_2, z_1+z_2) q1+q2=(s1+s2,x1+x2,y1+y2,z1+z2)；
cpp 复制代码
```
inline Quat operator + (const Quat& rhs) const
{
    return Quat(
        _v[0] + rhs._v[0],
        _v[1] + rhs._v[1],
        _v[2] + rhs._v[2],
        _v[3] + rhs._v[3]
    );
}
```
减法：对应分量相减， q 1 − q 2 = ( s 1 − s 2 , x 1 − x 2 , y 1 − y 2 , z 1 − z 2 ) q_1 - q_2 = (s_1-s_2, x_1-x_2, y_1-y_2, z_1-z_2) q1−q2=(s1−s2,x1−x2,y1−y2,z1−z2)；
cpp 复制代码
```
inline Quat operator - (const Quat& rhs) const
{
    return Quat(
        _v[0] - rhs._v[0],
        _v[1] - rhs._v[1],
        _v[2] - rhs._v[2],
        _v[3] - rhs._v[3]
    );
}
```

2.2.2 乘法

四元数乘法遵循多项式展开规则，结合虚部运算规则，最终展开式为：
( s 1 + x 1 i + y 1 j + z 1 k ) ( s 2 + x 2 i + y 2 j + z 2 k ) = ( s 1 s 2 − x 1 x 2 − y 1 y 2 − z 1 z 2 ) + ( s 1 x 2 + x 1 s 2 + y 1 z 2 − z 1 y 2 ) i + ( s 1 y 2 − x 1 z 2 + y 1 s 2 + z 1 x 2 ) j + ( s 1 z 2 + x 1 y 2 − y 1 x 2 + z 1 s 2 ) k \begin{align*} &(s_1+x_1i+y_1j+z_1k)(s_2+x_2i+y_2j+z_2k) \\ =& (s_1s_2 - x_1x_2 - y_1y_2 - z_1z_2) \\ &+ (s_1x_2 + x_1s_2 + y_1z_2 - z_1y_2)i \\ &+ (s_1y_2 - x_1z_2 + y_1s_2 + z_1x_2)j \\ &+ (s_1z_2 + x_1y_2 - y_1x_2 + z_1s_2)k \end{align*} =(s1+x1i+y1j+z1k)(s2+x2i+y2j+z2k)(s1s2−x1x2−y1y2−z1z2)+(s1x2+x1s2+y1z2−z1y2)i+(s1y2−x1z2+y1s2+z1x2)j+(s1z2+x1y2−y1x2+z1s2)k

实现代码：

cpp 复制代码

inline const Quat operator*(const Quat& rhs) const
{
    return Quat( 
        rhs._v[3]*_v[0] + rhs._v[0]*_v[3] + rhs._v[1]*_v[2] - rhs._v[2]*_v[1],
        rhs._v[3]*_v[1] - rhs._v[0]*_v[2] + rhs._v[1]*_v[3] + rhs._v[2]*_v[0],
        rhs._v[3]*_v[2] + rhs._v[0]*_v[1] - rhs._v[1]*_v[0] + rhs._v[2]*_v[3],
        rhs._v[3]*_v[3] - rhs._v[0]*_v[0] - rhs._v[1]*_v[1] - rhs._v[2]*_v[2] 
    );
}

2.2.3 除法（逆运算）

四元数乘法不满足交换律，因此除法定义为 q 1 / q 2 = q 1 ⋅ q 2 − 1 q_1 / q_2 = q_1 \cdot q_2^{-1} q1/q2=q1⋅q2−1，其中逆四元数 q − 1 = q ∗ ∣ q ∣ 2 q^{-1} = \frac{q^*}{|q|^2} q−1=∣q∣2q∗（ q ∗ q^* q∗ 为共轭四元数， ∣ q ∣ 2 |q|^2 ∣q∣2 为模的平方）。

实现：

cpp 复制代码

// 共轭四元数（虚部取反）
inline Quat conj () const
{
    return Quat( -_v[0], -_v[1], -_v[2], _v[3] );
}

// 模的平方
value_type length2() const
{
    return _v[0]*_v[0] + _v[1]*_v[1] + _v[2]*_v[2] + _v[3]*_v[3];
}

// 逆四元数
inline const Quat inverse () const
{
    return conj() / length2();
}

// 除法
inline const Quat operator/(const Quat& denom) const
{
    return ( (*this) * denom.inverse() );
}

3. 四元数与三维旋转

四元数是三维旋转的最优描述方式之一，无万向节死锁问题，且插值平滑、计算高效。其思想是：任意三维旋转可表示为绕单位向量 u \boldsymbol{u} u 旋转 θ \theta θ 角，对应的四元数由旋转轴和旋转角构造。

3.1 绕任意轴旋转的四元数构造

设旋转轴为单位向量 u = ( u x , u y , u z ) \boldsymbol{u} = (u_x, u_y, u_z) u=(ux,uy,uz)，旋转角为 θ \theta θ，则对应的四元数为：
q = cos ⁡ θ 2 + ( u x i + u y j + u z k ) sin ⁡ θ 2 q = \cos\frac{\theta}{2} + (u_xi + u_yj + u_zk)\sin\frac{\theta}{2} q=cos2θ+(uxi+uyj+uzk)sin2θ

实现代码：

cpp 复制代码

void makeRotate(value_type angle, value_type x, value_type y, value_type z)
{
    const value_type epsilon = 1e-7;
    value_type length = sqrt(x*x + y*y + z*z);
    if (length < epsilon)
    {
        *this = Quat(); // 零旋转
        return;
    }

    value_type inversenorm = 1.0 / length; // 单位化旋转轴
    value_type coshalfangle = cos(0.5*angle);
    value_type sinhalfangle = sin(0.5*angle);

    _v[0] = x * sinhalfangle * inversenorm;
    _v[1] = y * sinhalfangle * inversenorm;
    _v[2] = z * sinhalfangle * inversenorm;
    _v[3] = coshalfangle;
}

3.2 从向量旋转构造四元数

已知初始向量 u \boldsymbol{u} u 和目标向量 v \boldsymbol{v} v，构造旋转四元数的逻辑：

旋转轴为 u × v \boldsymbol{u} \times \boldsymbol{v} u×v；
旋转角为 u \boldsymbol{u} u 与 v \boldsymbol{v} v 的夹角；
特殊处理向量共线（夹角 0 ∘ 0^\circ 0∘ 或 18 0 ∘ 180^\circ 180∘）的情况。

3.2.1 基础实现（含特殊处理）

cpp 复制代码

void makeRotate(const Vec3<value_type>& from, const Vec3<value_type>& to)
{
    const value_type epsilon = 1e-7;
    value_type length1 = from.length();
    value_type length2 = to.length();
    value_type cosangle = from*to / (length1*length2); // 点乘求夹角余弦

    // 向量同向（夹角0°）
    if (fabs(cosangle - 1) < epsilon)
    {
        makeRotate(0.0, 0.0, 0.0, 1.0); // 零旋转
    }
    // 向量反向（夹角180°）
    else if (fabs(cosangle + 1.0) < epsilon)
    {
        // 构造垂直于from的任意轴
        Vec3<value_type> tmp;
        if ((fabs(from.x())) < fabs(from.y()))
        {
            tmp = (fabs(from.x()) < fabs(from.z())) ? Vec3<value_type>(1,0,0) : Vec3<value_type>(0,0,1);
        }
        else
        {
            tmp = (fabs(from.y()) < fabs(from.z())) ? Vec3<value_type>(0,1,0) : Vec3<value_type>(0,0,1);
        }
        Vec3<value_type> axis = from ^ tmp; // 叉乘得旋转轴
        axis.normalize();
        _v[0] = axis[0]; _v[1] = axis[1]; _v[2] = axis[2]; _v[3] = 0.0; // 旋转角180°
    }
    // 一般情况
    else
    {
        Vec3<value_type> axis = from ^ to;
        value_type angle = acos(cosangle);
        makeRotate(angle, axis.x(), axis.y(), axis.z());
    }
}

3.2.2 优化实现（避免反三角函数）

利用三角恒等式 sin ⁡ θ 2 = 1 − cos ⁡ θ 2 \sin\frac{\theta}{2} = \sqrt{\frac{1-\cos\theta}{2}} sin2θ=21−cosθ 、 cos ⁡ θ 2 = 1 + cos ⁡ θ 2 \cos\frac{\theta}{2} = \sqrt{\frac{1+\cos\theta}{2}} cos2θ=21+cosθ ，简化计算：

cpp 复制代码

// 替换一般情况的代码块
else
{
    value_type normFromAndTo = sqrt(from.length2()*to.length2());
    value_type cos_theta = from * to / normFromAndTo;
    value_type half_cos = sqrt(0.5 * (1+cos_theta));
    Vec3<value_type> axis = (from ^ to) / (normFromAndTo * 2 * half_cos);

    _v[0] = axis[0];
    _v[1] = axis[1];
    _v[2] = axis[2];
    _v[3] = half_cos;
}

3.3 从四元数提取旋转轴与旋转角

已知四元数 q = w + x i + y j + z k q = w + xi + yj + zk q=w+xi+yj+zk，反推旋转参数的公式：
θ = 2 arccos ⁡ ( w ) u = ( x , y , z ) 1 − w 2 ( w ≠ ± 1 ) \begin{align*} \theta &= 2\arccos(w) \\ \boldsymbol{u} &= \frac{(x,y,z)}{\sqrt{1-w^2}} \quad (w \neq \pm1) \end{align*} θu=2arccos(w)=1−w2 (x,y,z)(w=±1)

特殊处理：

w = 1 w=1 w=1（旋转角 0 ∘ 0^\circ 0∘）：分母为 0，直接取 ( x , y , z ) (x,y,z) (x,y,z) 为旋转轴；
w = − 1 w=-1 w=−1（旋转角 18 0 ∘ 180^\circ 180∘）： u = ( x , y , z ) \boldsymbol{u} = (x,y,z) u=(x,y,z)。

实现代码：

cpp 复制代码

void getRotate(value_type& angle, value_type& x, value_type& y, value_type& z) const 
{
    Quat q1 = *this;
    if (_v[3] > 1) q1.normalize(); // 确保单位四元数

    angle = 2 * acos(q1._v[3]);
    value_type s = sqrt(1 - q1._v[3]*q1._v[3]);

    if (s < 1e-6) // 旋转角0°
    {
        x = q1._v[0]; y = q1._v[1]; z = q1._v[2];
    }
    else // 一般情况
    {
        x = q1._v[0] / s; y = q1._v[1] / s; z = q1._v[2] / s;
    }
}

3.4 四元数旋转向量

将向量 v \boldsymbol{v} v 转换为纯虚四元数 p = 0 + v x i + v y j + v z k p = 0 + v_xi + v_yj + v_zk p=0+vxi+vyj+vzk，旋转后的向量为：
v ′ = q ⋅ p ⋅ q ∗ \boldsymbol{v}' = q \cdot p \cdot q^* v′=q⋅p⋅q∗

优化实现（避免直接四元数乘法，降低计算量）：

cpp 复制代码

Vec3<value_type> operator* (const Vec3<value_type>& v)
{
    // nVidia SDK 优化实现
    Vec3<value_type> uv, uuv;
    Vec3<value_type> qvec(_v[0], _v[1], _v[2]);
    uv = qvec ^ v;          // 叉乘
    uuv = qvec ^ uv;        // 二次叉乘
    uv *= (2.0f * _v[3]);   // 实部缩放
    uuv *= 2.0f;            // 缩放
    return v + uv + uuv;    // 最终旋转向量
}

3.5 四元数的球面插值（SLERP）

四元数的球面插值（Spherical Linear Interpolation）可实现平滑的旋转过渡，公式为：
q t = sin ⁡ ( ( 1 − t ) θ ) sin ⁡ θ q a + sin ⁡ ( t θ ) sin ⁡ θ q b q_t = \frac{\sin((1-t)\theta)}{\sin\theta}q_a + \frac{\sin(t\theta)}{\sin\theta}q_b qt=sinθsin((1−t)θ)qa+sinθsin(tθ)qb

其中 θ \theta θ 为 q a q_a qa 与 q b q_b qb 的夹角（ cos ⁡ θ = q a ⋅ q b \cos\theta = q_a \cdot q_b cosθ=qa⋅qb）， t ∈ [ 0 , 1 ] t \in [0,1] t∈[0,1] 为插值因子。

实现代码：

cpp 复制代码

void slerp(value_type t, const Quat& from, const Quat& to )
{
    const double epsilon = 0.00001;
    double omega, cosomega, sinomega, scale_from, scale_to ;

    Quat quatTo(to);
    cosomega = from.asVec4() * to.asVec4(); // 点乘求夹角余弦

    // 确保插值方向最短
    if (cosomega < 0.0)
    {
        cosomega = -cosomega;
        quatTo = -to;
    }

    if( (1.0 - cosomega) > epsilon )
    {
        // 非近距离插值：球面插值
        omega = acos(cosomega);
        sinomega = sin(omega);
        scale_from = sin((1.0-t)*omega)/sinomega;
        scale_to = sin(t*omega)/sinomega;
    }
    else
    {
        // 近距离插值：线性插值
        scale_from = 1.0 - t;
        scale_to = t;
    }

    *this = (from*scale_from) + (quatTo*scale_to);
}

4. 四元数的优势

无万向节死锁：相比欧拉角，四元数通过单一参数描述旋转，避免了旋转轴重合导致的自由度丢失；
插值平滑：球面插值（SLERP）可实现旋转的连续、平滑过渡，无欧拉角插值的"生硬感"；
计算高效：四元数仅需 4 个分量，乘法运算量远低于 4×4 旋转矩阵；
易于归一化：单位四元数（模为 1）可保证旋转的正交性，归一化操作简单。

参考文献

Wiki Rotation (mathematics)
https://en.wikipedia.org/wiki/Rotation_(mathematics)
Euler's rotation theorem
https://en.wikipedia.org/wiki/Euler's_rotation_theorem
Maths - Rotation Matrice
https://www.euclideanspace.com/maths/algebra/matrix/orthogonal/rotation/index.htm
绕任意轴旋转
https://www.cnblogs.com/graphics/archive/2012/08/10/2627458.html
Rotation About an Arbitrary Axis in 3 Dimension
https://inside.mines.edu/fs_home/gmurray/ArbitraryAxisRotation/
Rotation about an Arbitrary Axis (Line)
https://www.engr.uvic.ca/~mech410/lectures/4_2_RotateArbi.pdf
Maths - Euler Angle
http://www.euclideanspace.com/maths/geometry/rotations/euler/
Wiki-Euler angle
https://en.wikipedia.org/wiki/Euler_angles
Euler Angle
http://mathworld.wolfram.com/EulerAngles.html
Wiki-Gimbal lock
https://en.wikipedia.org/wiki/Gimbal_lock
欧拉角、内部旋转、外部旋转
http://blog.csdn.net/hy3316597/article/details/50966633
Understanding Quaternion
https://www.3dgep.com/understanding-quaternions/
如何形象地理解四元数？
https://www.zhihu.com/question/23005815/answer/33971127
Quaternion
http://mathworld.wolfram.com/Quaternion.html
Quaternion
https://en.wikipedia.org/wiki/Quaternion
Maths - Quaternion
https://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/index.htm
Beautiful maths simplification: quaternion from two vector
https://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
Rotating vector3 by a quaternion
https://gamedev.stackexchange.com/questions/28395/rotating-vector3-by-a-quaternion
quaternion vector product - the principle of the element-transformed vector algorithm
https://www.gamedev.net/topic/466725-quaternion-vector-product/

via：

旋转变换（一）旋转矩阵 - 二维与三维旋转变换-CSDN博客
https://blog.csdn.net/csxiaoshui/article/details/65446125
旋转变换（二）欧拉角 - 欧拉角详解-CSDN博客
https://blog.csdn.net/csxiaoshui/article/details/65437633
- 欧拉角(Euler Angle)-CSDN博客
  https://thefist.blog.csdn.net/article/details/126595776
旋转变换（三）四元数 - 四元数与三维旋转-CSDN博客
https://blog.csdn.net/csxiaoshui/article/details/65445633