はじめに

3Dの「姿勢」（＝物体がどっちを向いているか）を表す方法は、実は1つではありません。代表的なものだけで、回転行列・オイラー角・軸-角度・クォータニオンの4つがあります。

この記事を読むと、こうなります

4つの表現がそれぞれ何者で、なぜ複数あるのかが分かる
有名な罠 「ジンバルロック」 が、なぜ起きるのかを図と実行結果で理解できる
NumPyで全部を手実装して、相互変換まで動かせる

数式は最小限に、手を動かして納得することを優先します。この記事のコードは numpy と scipy（答え合わせ用）だけで動きます。

背景：なぜ「回転の表現」でつまずくのか

平行移動（位置をずらすこと）は「x, y, z を足すだけ」で直感的です。ところが回転は、いざ扱うと急に難しく感じます。理由は3つあります。

表現が複数あり、変換が必要：ライブラリAはオイラー角、ライブラリBはクォータニオンを要求する、といったことが日常茶飯事
回転は「順番」で結果が変わる：足し算と違い、回転は交換法則が成り立たない（先にX軸で回すか、先にY軸で回すかで最終姿勢が変わる）
ジンバルロックという有名な罠：オイラー角では、ある角度で「自由度が1つ消える」現象が起きる

この記事は、この混乱を1本で解きほぐします。

想定読者：三角関数と行列の掛け算がなんとなく分かり、Pythonが読める方。クォータニオンは初めてでも大丈夫です。ロボット・3D・ゲーム・IMU（慣性計測センサ：加速度やジャイロで姿勢を測る部品）を触る人に特に役立ちます。

全体像：4つの表現マップ

まず地図を持ちましょう。下図（図1）のように、4つの表現は 「同じ回転」を別の言葉で言い換えているだけで、相互に変換できます。

図1：4つの姿勢表現の関係。どれも「同じ回転」を表し、回転行列を経由して相互変換できる。

座標系は右手系（親指=X, 人差し指=Y, 中指=Z）を使います。回転の向きは「軸の正方向を見て反時計回りが正」です（図2）。

図2：本記事で使う右手座標系（x × y = z）。

それぞれを一言でまとめると、下表のようになります。

下表の 「格納する数」 は、その表現をコンピュータに保存するのに使う数（成分）の個数のことです。ここで1つ大事な区別があります。回転そのものの 自由度（じゆうど＝本当に自由に決められる向きの数）は、どの表現でも常に3で共通です。にもかかわらず、格納に使う数は表現ごとに違います（回転行列は9個と最も冗長で、余った6個ぶんは「正規直交」という制約でつじつまを合わせています）。

表現	格納する数	一言でいうと
回転行列	9	点を実際に回す計算の主役
オイラー角	3	人間が読み書きしやすい（罠あり）
軸-角度	4	「どの軸に何度」で幾何的に明快
クォータニオン	4	合成・補間に強く、ロックしない

表1：4つの表現の早わかり。「格納する数」は保存に使う成分の個数（自由度はどれも3で共通）。

では1つずつ見ていきます。

① 回転行列

一番の基本は回転行列（3×3の行列で回転を表す）です。ある点の座標ベクトルに左からこの行列を掛けると、回転後の座標が得られます。

まずは回転を絵で見てみましょう（図3）。点 (1, 0, 0) をZ軸まわりに90°回すと、ちょうど (0, 1, 0) に移ります。

図3：右手座標系で点(1,0,0)をZ軸まわりに90°回すと(0,1,0)になる。

たとえばZ軸まわりに角度θ回す行列は次の形です（図4）。

R_z(\theta) =
\begin{pmatrix}
\cos\theta & -\sin\theta & 0 \\
\sin\theta & \cos\theta & 0 \\
0 & 0 & 1 \\
\end{pmatrix}

図4：Z軸まわりθ回転の回転行列。左上2×2が平面回転、Z成分は変わらない。

回転行列には 「正規直交」（各列が長さ1で互いに直交している）という性質があり、これが「形を変えず向きだけ変える」ことを保証しています。

NumPyでZ軸回転行列を作り、点 (1, 0, 0) を90°回すと (0, 1, 0) になることを確かめます。

import numpy as np


def rot_z(theta: float) -> np.ndarray:
    """Z軸まわりに角度theta[rad]回す回転行列を返す。"""
    c, s = np.cos(theta), np.sin(theta)
    return np.array([
        [c, -s, 0.0],
        [s,  c, 0.0],
        [0.0, 0.0, 1.0],
    ])


# 点(1,0,0)をZ軸まわり90°回すと(0,1,0)になる
# 行列とベクトルの積は np.dot() で計算する
print(np.dot(rot_z(np.radians(90.0)), np.array([1.0, 0.0, 0.0])))
# -> [0. 1. 0.]

同じ要領で、X軸・Y軸まわりの回転行列も作れます（次の節で使います）。

def rot_x(theta: float) -> np.ndarray:
    """X軸まわりに角度theta[rad]回す回転行列を返す。"""
    c, s = np.cos(theta), np.sin(theta)
    return np.array([
        [1.0, 0.0, 0.0],
        [0.0,  c,  -s],
        [0.0,  s,   c],
    ])


def rot_y(theta: float) -> np.ndarray:
    """Y軸まわりに角度theta[rad]回す回転行列を返す。"""
    c, s = np.cos(theta), np.sin(theta)
    return np.array([
        [ c, 0.0,  s],
        [0.0, 1.0, 0.0],
        [-s, 0.0,  c],
    ])

長所：点を回す計算がそのまま掛け算。合成も行列の積。
短所：9個の数で冗長。人間には読み取りにくい。

② オイラー角

オイラー角（3つの角度で姿勢を表す方法）は、飛行機の姿勢でおなじみの roll（ロール＝機体軸まわりの傾き）／pitch（ピッチ＝上下の傾き）／yaw（ヨー＝左右の首振り） です。人間にとって一番直感的です（図5）。

図5：飛行機で見る roll / pitch / yaw。人間には分かりやすい。

オイラー角は、各軸まわりの回転行列を順番に掛けて1つの回転行列に合成します。ここで大事なのが 「順番」 です。X→Y→Zで掛けるのと Z→Y→X では結果が変わります。だからライブラリごとに「回転順序（例：ZYX）」が決まっているのです。

ここでは、yaw → pitch → roll の順（ZYX順、ロボットで定番）で合成します。

def euler_zyx_to_matrix(roll: float, pitch: float, yaw: float) -> np.ndarray:
    """roll(X)→pitch(Y)→yaw(Z)の順で合成した回転行列を返す。"""
    # R = Rz(yaw)・Ry(pitch)・Rx(roll) を、np.dot() を2回重ねて計算する
    return np.dot(np.dot(rot_z(yaw), rot_y(pitch)), rot_x(roll))

SciPy（科学計算ライブラリ）の実装と一致するかで答え合わせをしておきます。

from scipy.spatial.transform import Rotation

roll, pitch, yaw = np.radians([30.0, 20.0, 45.0])
R_mine = euler_zyx_to_matrix(roll, pitch, yaw)
R_scipy = Rotation.from_euler("ZYX", [yaw, pitch, roll]).as_matrix()
print(np.max(np.abs(R_mine - R_scipy)))
# -> 2.220446049250313e-16 （ほぼ0＝一致）

長所：3つの数で直感的。人間の入力・表示に向く
短所：順序依存でややこしい。そして次に見るジンバルロックという致命的な罠がある

ジンバルロック：自由度が1つ消える瞬間

オイラー角最大の弱点がジンバルロック（gimbal lock：3つの回転軸のうち2つが重なって、回せる方向が1つ減ってしまう現象）です。

pitch（真ん中の回転）を±90°にすると、1つ目の軸と3つ目の軸が同じ向きに揃ってしまい、本来3方向あったはずの自由度が2方向に減ります。「別々に回したはずが、同じ回転になってしまう」状態です。

これを数値で確かめてみましょう。roll・pitch・yaw を1つずつ微小に動かしたときの姿勢変化を3本のベクトルに並べ、その3×3行列の行列式（＝3軸が独立に姿勢を変えられる「体積」）を測ります。値が 1 なら3軸フルに独立、0 ならジンバルロックです。

def dof_volume(pitch: float) -> float:
    """pitchでの「3つの軸が独立に姿勢を変えられる度合い」を返す（1〜0）。"""
    eps = 1e-5
    base = euler_zyx_to_matrix(0.0, pitch, 0.0)
    cols = []
    for idx in range(3):  # 0=roll, 1=pitch, 2=yaw
        angles = [0.0, pitch, 0.0]
        angles[idx] += eps
        R_pert = euler_zyx_to_matrix(angles[0], angles[1], angles[2])
        # 微小回転 dR = R_pert・base^T を回転ベクトル化して列に並べる
        rotvec = Rotation.from_matrix(np.dot(R_pert, base.T)).as_rotvec()
        cols.append(rotvec / eps)
    return abs(np.linalg.det(np.column_stack(cols)))


for p in [0, 30, 60, 80, 89]:
    print(f"pitch={p:2d}° -> 独立性 {dof_volume(np.radians(p)):.3f}")
# pitch= 0° -> 独立性 1.000
# pitch=30° -> 独立性 0.866
# pitch=60° -> 独立性 0.500
# pitch=80° -> 独立性 0.174
# pitch=89° -> 独立性 0.017  ← ほぼロック

pitch を 0°→90° と動かすと、独立性が cos(pitch) のカーブでなめらかに 0 へ潰れていくのが分かります（下図）。

図6：pitchが90°に近づくほど3軸の独立性が0へ潰れていく（ジンバルロック）。

この「1自由度の消失」があるため、姿勢を内部で保持する用途にオイラー角は不向きとされます。これを避けるのが、次の軸-角度とクォータニオンです。

③ 軸-角度（回転ベクトル）

軸-角度表現（axis-angle：回転を「回転軸の向き」と「その軸まわりの角度」で表す）は、とても幾何的で分かりやすい方法です。「単位ベクトル n の軸まわりに、角度 θ 回す」——それだけです（図7）。

図7：軸-角度表現。「どの軸に・何度」の2要素だけ。

軸ベクトルに角度を掛け込んで1本の回転ベクトル（長さ＝回転角、向き＝回転軸）にまとめる書き方もよく使います。軸-角度から回転行列への変換はロドリゲスの回転公式（axis-angleを回転行列に直す有名な公式）で計算できます。

単位軸 $n=(n_x, n_y, n_z)$ から、その軸との外積（$n \times v$）を行列で表した外積行列 $K$ を作ります。

K =
\begin{pmatrix}
0 & -n_z & n_y \\
n_z & 0 & -n_x \\
-n_y & n_x & 0
\end{pmatrix}

この $K$ を使うと、軸 $n$ まわりに角度 $\theta$ 回す回転行列は次のように書けます（$I$ は3×3の単位行列）。これがロドリゲスの回転公式です。

R = I + \sin\theta K + (1 - \cos\theta) K^2

下のコードは、この式をそのまま np.eye(3) + np.sin(theta) * K + (1 - np.cos(theta)) * np.dot(K, K) として実装しています。

def axis_angle_to_matrix(axis: np.ndarray, theta: float) -> np.ndarray:
    """単位ベクトルaxisまわりに角度theta回す回転行列を返す（ロドリゲスの公式）。"""
    n = axis / np.linalg.norm(axis)  # 念のため正規化
    x, y, z = n
    K = np.array([          # 外積行列（np.dot(K, v) が n × v になる）
        [0.0, -z,   y],
        [z,   0.0, -x],
        [-y,   x,  0.0],
    ])
    return np.eye(3) + np.sin(theta) * K + (1.0 - np.cos(theta)) * np.dot(K, K)


# SciPyの回転ベクトル実装と一致（誤差 0.0）
axis, theta = np.array([1.0, 1.0, 0.0]), np.radians(60.0)
R_aa = axis_angle_to_matrix(axis, theta)
R_ref = Rotation.from_rotvec(theta * axis / np.linalg.norm(axis)).as_matrix()
print(np.max(np.abs(R_aa - R_ref)))  # -> 0.0

長所：幾何的に明快。ジンバルロックしない
短所：回転の合成（2つの回転を続ける）が素直にできない。そこで登場するのがクォータニオン

④ クォータニオン

いよいよ主役クォータニオン（quaternion：4つの数 (w, x, y, z) で回転を表す方法）です。「軸-角度を、合成しやすい形に詰め直したもの」と考えると腹落ちします。

軸 n=(nx, ny, nz)・角度θの回転は、次のように4つの数になります（図8）。角度が「θ/2」になっているのがポイントです。

w = cos(θ/2)
x = nx * sin(θ/2)
y = ny * sin(θ/2)
z = nz * sin(θ/2)

図8：軸-角度からクォータニオンへの変換。角度が半分になる。

def axis_angle_to_quat(axis: np.ndarray, theta: float) -> np.ndarray:
    """軸-角度からクォータニオン(w, x, y, z)を作る。"""
    n = axis / np.linalg.norm(axis)
    w = np.cos(theta / 2.0)
    xyz = n * np.sin(theta / 2.0)
    return np.array([w, xyz[0], xyz[1], xyz[2]])

すごいのは合成です。2つの回転を続けて行うとき、クォータニオン同士を掛け算（ハミルトン積）するだけで合成後の回転が出ます（図9）。

ハミルトン積（Hamilton product：クォータニオン専用の掛け算）は、普通の数の掛け算と違って順番を入れ替えると結果が変わります（回転が順序依存なのと同じ）。$q_1 \otimes q_2$ は「先に $q_2$ の回転を行い、そのあと $q_1$ の回転を行う」合成回転を表します。2つのクォータニオン $q_1=(w_1, x_1, y_1, z_1)$、$q_2=(w_2, x_2, y_2, z_2)$ に対して、成分ごとに次のように計算します。

q_1 \otimes q_2 =
\begin{pmatrix}
w_1 w_2 - x_1 x_2 - y_1 y_2 - z_1 z_2 \\
w_1 x_2 + x_1 w_2 + y_1 z_2 - z_1 y_2 \\
w_1 y_2 - x_1 z_2 + y_1 w_2 + z_1 x_2 \\
w_1 z_2 + x_1 y_2 - y_1 x_2 + z_1 w_2
\end{pmatrix}

図9：ハミルトン積。クォータニオンの合成は、この掛け算1回で済む。

この式は、下の quat_multiply の4行の戻り値とそのまま対応しています。

クォータニオン $q=(w, x, y, z)$（長さ1に正規化済み）は、次の式で回転行列に変換できます。「クォータニオンの4つの数」と「回転行列の9成分」は、こうして相互に行き来できます。

R =
\begin{pmatrix}
1 - 2(y^2 + z^2) & 2(xy - wz) & 2(xz + wy) \\
2(xy + wz) & 1 - 2(x^2 + z^2) & 2(yz - wx) \\
2(xz - wy) & 2(yz + wx) & 1 - 2(x^2 + y^2)
\end{pmatrix}

なお、この記事のコードでは行列へ変換せず、次に示す「$q \otimes v \otimes q^{*}$」で点を直接回します（結果はこの行列を掛けるのと一致します）。ハミルトン積と、クォータニオンで点を回す関数を手実装します。

def quat_multiply(q1: np.ndarray, q2: np.ndarray) -> np.ndarray:
    """ハミルトン積 q1 ⊗ q2（q2の後にq1を行う合成）を返す。"""
    w1, x1, y1, z1 = q1
    w2, x2, y2, z2 = q2
    return np.array([
        w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
        w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
        w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2,
        w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2,
    ])


def quat_rotate(q: np.ndarray, v: np.ndarray) -> np.ndarray:
    """クォータニオンqで点vを回す（q ⊗ v ⊗ q*）。"""
    q_v = np.array([0.0, v[0], v[1], v[2]])          # 点を純虚クォータニオン化
    q_conj = np.array([q[0], -q[1], -q[2], -q[3]])   # 共役（逆回転）
    return quat_multiply(quat_multiply(q, q_v), q_conj)[1:]

きちんと回転行列と同じ結果になり、合成も行列積と一致します。

# クォータニオンで点を回す結果は回転行列と一致（誤差 ~1e-16）
q = axis_angle_to_quat(axis, theta)
v = np.array([1.0, 0.0, 0.0])
print(np.max(np.abs(quat_rotate(q, v) - np.dot(R_aa, v))))  # -> ~1e-16

# 合成：ハミルトン積 と 回転行列の積 が一致
qa = axis_angle_to_quat(np.array([0.0, 0.0, 1.0]), np.radians(90.0))
qb = axis_angle_to_quat(np.array([1.0, 0.0, 0.0]), np.radians(90.0))
Ra = axis_angle_to_matrix(np.array([0.0, 0.0, 1.0]), np.radians(90.0))
Rb = axis_angle_to_matrix(np.array([1.0, 0.0, 0.0]), np.radians(90.0))
print(quat_rotate(quat_multiply(qa, qb), v))  # -> [0. 1. 0.]
print(np.dot(np.dot(Ra, Rb), v))              # -> [0. 1. 0.]

なぜロックしないのかを直感で言うと、オイラー角のように「3本の軸に分解」せず、回転を4次元の1つの塊として持つから、途中で軸が潰れることがないのです。

長所：合成が掛け算1回、補間が得意、ロックしない、数が4つで省メモリ
短所：4つの数の意味が直感的でない（人間の目視・入力には向かない）

比較：いつ、どれを使う？

ここまでを1枚に畳みます（表2）。凡例は ◎＝最も得意／○＝得意／△＝一応できるが不向き／✕＝苦手・要変換 です。

観点	回転行列	オイラー角	軸-角度	クォータニオン
格納する数（自由度は全て3）	9	3	4	4
人間への直感性	△	◎	○	✕
点を回す計算	◎	✕（要変換）	✕（要変換）	○
回転の合成	○	✕	✕	◎
なめらかな補間	△	✕	○	◎
ジンバルロック	起きない	起きる	起きない	起きない
主な用途	点の変換	入力・表示	幾何・微小回転	内部保持・合成

表2：4つの姿勢表現の使い分け早見表。

実務の勘所を一言でいうと——

人間が入力・表示するところは オイラー角（分かりやすいから）
内部で姿勢を保持・合成・補間するところは クォータニオン（ロックせず高速）
実際に点を回す計算の瞬間は 回転行列（掛けるだけ）

つまり「入り口はオイラー角、心臓部はクォータニオン、実行は回転行列」というリレーで使い分けるのが定番です。

まとめ

姿勢の表現は4つ（回転行列・オイラー角・軸-角度・クォータニオン）あり、同じ回転の言い換えで相互変換できる。
オイラー角は直感的だがジンバルロックする。pitchが90°に近づくと自由度が1つ消えるため、内部保持には不向き。
クォータニオンは合成が掛け算1回・ロックしない・補間に強いので、ロボットやゲームの心臓部で使われる。
使い分けは「入力＝オイラー角／保持＝クォータニオン／実行＝回転行列」。

次回は、ここで作ったクォータニオンを実際にロボットアームの手先姿勢に適用して、姿勢制御・姿勢の補間まで繋げる予定です。

おわりに

姿勢表現は、ロボットアームや経路生成を実装するときの「地味だけど必ず要る土台」です。関連する実装記事は下記から辿れます。