HN 日本語サマリー

← 一覧へ戻る
プログラミング

行列とクォータニオンに関するFAQ

Matrix and Quaternion FAQ (j3d.org)

17 pointsby signa113 コメント

要約

このFAQは、行列とクォータニオンに関する基本的な概念から、算術、決定因子と逆行列、変換(回転、移動、拡大縮小)、そしてクォータニオンの応用まで、幅広い情報を提供するドキュメントです。主に3Dグラフィックスやアニメーションにおけるこれらの数学的ツールの利用に焦点を当てており、OpenGLなどのグラフィックスライブラリにおける行列の表現方法に関する重要な注意点も含まれています。ドキュメントは2003年11月30日にバージョン1.21として更新され、長年にわたり多くの貢献者によって修正と改善が重ねられてきました。

全文翻訳

行列とクォータニオン FAQ

バージョン 1.21 2003年11月30日

フィードバックは matrix_faq@j3d.org までメールでお送りください。
件名は MATRIX-FAQ で始めてください(そうでないとスパムフィルターでブロックされる可能性があります)。
追加の提案や関連する質問も歓迎します。
上記のアドレスにEメールをお送りください。
このFAQの最新版は以下のウェブページで見つけることができます。

http://www.j3d.org/matrix_faq/matrfaq_latest.html
このFAQは自由に配布またはコピーしていただいて構いません。

貢献者

導入 I1: Steve ?????
Q55からQ59への修正:
Andreas Junghanns
Q50への修正:
Morten Ofstad
Q39への注記:
Tom Nuydens
Q29およびQ37への修正:
Eric Reiss
Q56の明確化:
Duncan Murdoch
Q37の明確化:
Ron Avitzur
Q1への修正:
Mona Wong
Q36およびQ37への修正:
Eric Reiss
Q34およびQ38の改善:
Jon Watte
Q58およびQ59への警告と代替案:
Paul Pedriana
Q53の修正(および最適化 [Lee]):
Eleanor GroundwaterおよびLee Morgan
Q39の改善:
jhunpingco
Q11への修正とQ12の最適化:
Gordon
Q54からQ60への修正:
Eleanor Groundwater
Q23およびQ24への修正と改善:
Ben Houston
Q39への追加:
Jon Watte
Q61への修正:
Adam D. Moss
Q63の追加:
Mike Cline
Q11への追加:
Jacob Marner
Q38への修正とI2の開始:
Armin Müller
Q60の追加:
Pablo Figueroa
Q14、Q16、Q21、Q34への修正と追加:
Tronster Hartley
Q12およびQ54への修正:
Frank DJ
Q34への修正:
Robert Funnell

履歴

Andreasは、しばらくの間これを維持していたと思われる "hexapod@(no-spam)netcom.com" を見つけようとしましたが、netcom.com のサイトはもはや存在せず、メールはバウンスします。私(と同僚)がこのドキュメントの以前のバージョンで提供されたいくつかのアルゴリズムの間違いを理解するのにかなりの時間を費やしたので、それを修正してウェブに戻すことにしました。これらのドキュメントの場所として以前に提供されていたサイトはもはや存在しません。
ftp://ftp.netcom.com/pub/he/hexapod/index.html
http://www.glue.umd.edu/~rsrodger
バージョン、日付、およびローカルコピーへのリンク(比較できるように):
matrfaq_1.02.html: バージョン 1.2 1997年9月2日
matrfaq_1.04.html: バージョン 1.4 1998年12月26日
matrfaq_1.06.html: バージョン 1.6 2000年9月30日
matrfaq_1.07.html: バージョン 1.7 2000年12月20日
matrfaq_1.08.html: バージョン 1.8 2000年12月21日
matrfaq_1.09.html: バージョン 1.9 2001年1月16日
matrfaq_1.10.html: バージョン 1.10 2001年1月30日
matrfaq_1.11.html: バージョン 1.11 2001年2月9日
matrfaq_1.12.html: バージョン 1.12 2001年3月26日
matrfaq_1.13.html: バージョン 1.13 2001年7月20日
matrfaq_1.14.html: バージョン 1.14 2001年8月17日
matrfaq_1.15.html: バージョン 1.15 2001年8月20日
matrfaq_1.16.html: バージョン 1.16 2001年10月2日
matrfaq_1.17.html: バージョン 1.17 2001年11月30日
matrfaq_1.18.html: バージョン 1.18 2002年1月27日
matrfaq_1.19.html: バージョン 1.19 2002年3月20日
matrfaq_1.20.html: バージョン 1.20 2002年1月31日
matrfaq_1.21.html: バージョン 1.21 2003年11月30日

数学的な質問はご遠慮ください。私はこのFAQを維持しているだけで、その分野に関する知識はほとんどありません。しかし、このFAQで答えられていない質問があり、後で答えを見つけ、それがこのFAQ(またはその読者)に関連すると信じる場合は、関連するすべての情報(できれば消化済みの形式)を私に送って、ここに含めてください。ありがとうございます!
貢献者リストに「匿名」として表示されることを希望する場合は、お知らせください。そうでない場合は、メールヘッダーから収集できる名前で記載します。

導入

I1. OpenGLとこのドキュメントに関する重要な注意
I2. 正規化された入力に関する重要な注意

質問

基本

Q1. 行列とは何ですか?
Q2. 行列の次数とは何ですか?
Q3. C/C++プログラミング言語で行列をどのように表現しますか?
Q4. 行列を使用する利点は何ですか?
Q5. 行列は座標システムとどのように関係しますか?

算術

Q6. 単位行列とは何ですか?
Q7. 行列の主対角線とは何ですか?
Q8. 行列の転置とは何ですか?
Q9. 2つの行列をどのように加算しますか?
Q10. 2つの行列をどのように減算しますか?
Q11. 2つの行列をどのように乗算しますか?
Q12. 行列を二乗またはべき乗するにはどうすればよいですか?
Q13. 1つ以上のベクトルを行列でどのように乗算しますか?

行列式と逆行列

Q14. 行列の行列式とは何ですか?
Q15. 行列の行列式をどのように計算しますか?
Q16. 等方的および異方的な行列とは何ですか?
Q17. 行列の逆行列とは何ですか?
Q18. 任意の行列の逆行列をどのように計算しますか?
Q19. 単位行列の逆行列をどのように計算しますか?
Q20. 回転行列の逆行列をどのように計算しますか?
Q21. クラメルの公式を用いて行列の逆行列をどのように計算しますか?
Q22. 2x2行列の逆行列をどのように計算しますか?
Q23. 3x3行列の逆行列をどのように計算しますか?
Q24. 4x4行列の逆行列をどのように計算しますか?
Q25. 線形方程式を用いて行列の逆行列をどのように計算しますか?

変換

Q26. 回転行列とは何ですか?
Q27. 回転行列は座標システムとどのように関係しますか?
Q28. X軸の回転行列をどのように生成しますか?
Q29. Y軸の回転行列をどのように生成しますか?
Q30. Z軸の回転行列をどのように生成しますか?
Q31. オイラー角とは何ですか?
Q32. ヨウ、ロール、ピッチとは何ですか?
Q33. 回転行列をどのように結合しますか?
Q34. ジンバルロックとは何ですか?
Q35. 回転行列を結合する正しい方法は?
Q36. オイラー角から回転行列をどのように生成しますか?
Q37. 回転行列からオイラー角をどのように変換しますか?
Q38. 指定された軸と角度の回転行列をどのように生成しますか?
Q39. あるベクトルを別のベクトルにマッピングする回転行列をどのように生成しますか?
Q40. 行列を用いて2つの座標システム間でどのように変換しますか?
Q41. 平行移動行列とは何ですか?
Q42. スケーリング行列とは何ですか?
Q43. せん断行列とは何ですか?
Q44. 2つの行列間で線形補間を実行するにはどうすればよいですか?
Q45. 4つの行列間で立方体補間を実行するにはどうすればよいですか?
Q46. 行列をどのようにレンダリングできますか?

クォータニオン

Q47. クォータニオンとは何ですか?
Q48. クォータニオンは3Dアニメーションとどのように関係しますか?
Q49. クォータニオンの共役をどのように計算しますか?
Q50. クォータニオンの逆行列をどのように計算しますか?
Q51. クォータニオンの大きさをどのように計算しますか?
Q52. クォータニオンを正規化するにはどうすればよいですか?
Q53. 2つのクォータニオンをどのように乗算しますか?
Q54. クォータニオンから回転行列をどのように変換しますか?
Q55. 回転行列からクォータニオンをどのように変換しますか?
Q56. 回転軸と角度からクォータニオンをどのように変換しますか?
Q57. クォータニオンから回転軸と角度をどのように変換しますか?
Q58. 球面回転角からクォータニオンをどのように変換しますか?
Q59. クォータニオンから球面回転角をどのように変換しますか?
Q60. オイラー回転角からクォータニオンをどのように変換しますか?
Q61. クォータニオンを用いて行列間で線形補間を実行するにはどうすればよいですか?
Q62. クォータニオンを用いて行列間で立方体補間を実行するにはどうすればよいですか?
Q63. クォータニオンを用いてベクトルを回転させるにはどうすればよいですか?

導入

I1. OpenGLとこのドキュメントに関する重要な注意

このドキュメントでは(ほとんどの数学の教科書と同様に)、すべての行列は標準的な数学的様式で描画されています。残念ながら、IrisGL、OpenGL、SGIのPerformerなどのグラフィックスライブラリは、行と列を入れ替えて表現しています。
したがって、このドキュメントでは、例えば4x4の平行移動行列は次のように表示されます。

      | 1  0  0  X |
      |            |
      | 0  1  0  Y |
  M = |            |
      | 0  0  1  Z |
      |            |
      | 0  0  0  1 |

Performer(例)では、これは次のように設定されます。

M[0][1] = M[0][2] = M[0][3] =
M[1][0] = M[1][2] = M[1][3] =
M[2][0] = M[2][1] = M[2][3] = 0 ;
M[0][0] = M[1][1] = M[2][2] = m[3][3] = 1 ;
M[3][0] = X ;
M[3][1] = Y ;
M[3][2] = Z ;

つまり、行列は次のように格納されます。

      | M[0][0]  M[1][0]  M[2][0]  M[3][0] |
      |                                    |
      | M[0][1]  M[1][1]  M[2][1]  M[3][1] |
  M = |                                    |
      | M[0][2]  M[1][2]  M[2][2]  M[3][2] |
      |                                    |
      | M[0][3]  M[1][3]  M[2][3]  M[3][3] |

OpenGLは行列を格納するために1次元配列を使用しますが、幸いなことに、パッキング順序によりメモリ内のバイトレイアウトは同じになります。したがって、pfMatrixのアドレスを取得してfloat*にキャストすると、glLoadMatrixfなどのルーチンに直接渡すことができます。
このドキュメント全体に散在するコードスニペットでは、1次元配列が行列を格納するために使用されています。配列要素の順序は、OpenGLと比較して転置されています。

このドキュメント OpenGL
| 0 1 2 3 |
| |
| 4 5 6 7 |
M = |
| 8 9 10 11 |
| |
| 12 13 14 15 |

    | 0  4  8  12 |
    |             |
    | 1  5  9  13 |
M = |
    | 2  6  10 14 |
    |             |
    | 3  7  11 15 |

I2. 正規化された入力に関する重要な注意

ほとんどのアルゴリズムは、単位長さのベクトルや、主対角線が正規化された行列などの正規化された入力を想定していることに注意してください。アルゴリズム(およびここで提供されるコードスニペット)が任意の入力で正しく機能する可能性があり、実際によくそうなりますが、このプロパティに依存することは一般的に悪い習慣と見なされます(この提案に従わない場合、デバッグに時間がかかります)。

回答

基本

Q1. 行列とは何ですか?

行列とは、数値データの2次元配列であり、各行または列は1つ以上の数値値で構成されます。
行列に対して実行できる算術演算には、加算、減算、乗算、除算があります。
行列のサイズは、行数と列数で定義されます。
M行N列の行列はMxN行列と定義されます。
行列の個々の要素は、2つのインデックス値を使用して参照されます。数学的な表記法では、通常 'i' と 'j' という変数に割り当てられます。順序は行が先、列が後です。
たとえば、4x4の次数を持つ行列Mが存在する場合、行列の要素は次の行:列のペアでインデックス付けされます。

    | 00 01 02 03 |
M = | 10 11 12 13 |
    | 20 21 22 23 |
    | 30 31 32 33 |

行列の右上隅の要素は i=0 および j=3 です。
これは次のように参照されます。

M    = M
 i,j    0,3

コンピュータアニメーションでは、最も一般的に使用される行列は、2、3、または4行と列を持つものです。これらはそれぞれ2x2、3x3、4x4行列と呼ばれます。
2x2行列は、回転、せん断、その他の画像処理に使用されます。汎用NxN行列は、畳み込みなどの画像処理機能に使用できます。
3x3行列は、低予算の3Dアニメーションに使用されます。回転や乗算などの操作は、行列演算を使用して実行できますが、遠近法による奥行き投影は、標準的な最適化された純粋な除算操作を使用して実行されます。
4x4行列は、ハイエンドの3Dアニメーションに使用されます。乗算や遠近法による奥行き投影などの操作は、行列演算を使用して実行できます。

Q2. 行列の「次数」とは何ですか?

行列の「次数」は、行列のサイズの別の名前です。
M行N列の行列は、次数MxNであると言われます。

Q3. C/C++プログラミング言語で行列をどのように表現しますか?

C/C++プログラミング言語で行列を定義する最も簡単な方法は、「typedef」キーワードを使用することです。3x3行列と4x4行列の両方をこのように定義できます。

typedef float MATRIX3[9];
typedef float MATRIX4[16];

各種類の行列の次元は3x3および4x4であるため、それぞれ9および16のデータ要素が必要です。

一見すると、単一の線形配列のデータ値の使用は直感的でないように思えるかもしれません。2次元配列の使用の方が便利に思えるかもしれません。

typedef float MATRIX3[3][3];
typedef float MATRIX4[4][4];

しかし、各行列要素に対して2つの参照システムを使用すると、非常に混乱することがよくあります。数学では、順序は行が先(i)、列が後(j)です。

 Mij

C/C++では、これは次のようになります。

 matrix[j][i]

 2次元配列を使用すると、CPUのパフォーマンスにもペナルティが発生します。Cコンパイラは、配列インデックス操作を解決するために乗算演算を利用することがよくあります。

したがって、線形配列を使用し続ける方が効率的です。しかし、1つの問題がまだ解決されていません。2次元行列は線形配列にどのようにマッピングされますか?(行優先/列優先または列優先/行優先)の2つの方法しかありません。
2つのパフォーマンスの違いは微妙です。すべてのfor-nextループがアンロールされている場合、行列-行列乗算などの操作のパフォーマンスにはほとんど差がありません。
C/C++プログラミング言語を使用すると、各行列の線形順序は次のようになります。

mat[0] = M mat[3] = M
00 03
mat[12] = M mat[15] = M
30 33

|  0  1  2  3 |
    |             |
    |  4  5  6  7 |
M = |
    |  8  9 10 11 |
    |             |
    | 12 13 14 15 |

| 0 1 2 |
    |       |
    | 3 4 5 |
M = |
    | 6 7 8 |

Q4. 行列を使用する利点は何ですか?

コンピュータアニメーションで行列を使用することについて最初に尋ねられる質問の1つは、そもそもなぜそれらを使用する必要があるのかということです。
直感的には、for-nextループと行列乗算のオーバーヘッドがアプリケーションを遅くするように思えるでしょう。
これらの異論を解決する議論を指摘できます。これらには、ループカウンターを処理するためのCPUレジスタの使用や、メモリアクセスを最適化するためのデータキャッシュが含まれます。
利点も指摘できます。3Dアルゴリズムを定義するための数学的アプローチに従うことで、3Dアニメーションシステムの設計を予測および計画することが可能になります。このような数学的アプローチにより、キャラクターアニメーション、スプライン曲線、逆運動学の実装が可能になります。
しかし、頻繁に発生する異論の1つは、各座標ペアをその軸の回転係数で乗算する方が、完全なベクトル-行列乗算を実行するよりも速いということです。
つまり、X軸での回転はYとZを変換します。
Y軸での回転はXとZを変換します。
Z軸での回転はXとYを変換します。
これに対する議論は次のとおりです。
頂点 V = (x,y,z)、回転角度 (A,B,C)、平行移動 (D,E,F) が与えられた場合。アルゴリズム
は次のように定義されます。
---------------------------
sx = sin(A) // セットアップ - 一度だけ実行
cx = cos(A)
sy = sin(B)
cy = cos(B)
sz = sin(C)
cz = cos(C)
x1 = x * cz + y * sz // 各頂点の回転
y1 = y * cz - x * sz
z1 = z
x2 = x1 * cy + z1 * sy
y2 = z1
z2 = z1 * cy - x1 * sy
x3 = x2
y3 = y2 * cx + z1 * sx
z3 = z2 * cx - x1 * sx
xr = x3 + D // 各頂点の平行移動
yr = y3 + E
zr = z3 + F
---------------------------
全体として、このアルゴリズムは次の処理時間の量を使用します。
セットアップ 頂点ごと
------------------------- ------------------------
6つの三角関数
6つの代入操作。 12の代入
12の乗算
9の加算
------------------------- ------------------------
同じ操作が行列乗算を使用して実行されていると仮定します。
4x4行列の場合、処理時間は次のように使用されます。
セットアップ 変更 頂点ごと 変更
-------------------------- ------ ------------------------ ------
6 三角関数 0 0
18 代入操作 -12 3 代入 -9
12 乗算 +12 9 乗算 -3
6 減算 +6 6 加算 -3
-------------------------- ------ ------------------------ ------
2つの表を比較すると、回転行列のセットアップには少なくとも12回の乗算計算と追加の18回の代入呼び出しが必要であることがわかります。
しかし、これは贅沢に見えるかもしれませんが、節約は各頂点を処理することから来ます。行列乗算を使用すると、わずか4つの頂点を処理することによる節約は、追加のセットアップコストを上回ります。

Q5. 行列は座標システムとどのように関係しますか?

3x3または4x4の回転、平行移動、またはせん断行列のいずれかについて、各行列と結果の座標システムの間には単純な関係があります。
行列の最初の3つの列は、それぞれX、Y、Z軸の方向ベクトルを定義します。
4x4行列が次のように定義されている場合:

    | A B C D |
M = | E F G H |
    | I J K L |
    | M N O P |

次に、各軸の方向ベクトルは次のようになります。

 X軸 = [ A E I ]
 Y軸 = [ B F J ]
 Z軸 = [ C G K ]
 

算術

Q6. 単位行列とは何ですか?

単位行列は、行数と列数が同じである行列です。また、i=jとなるすべての要素は1に設定されます。他のすべてはゼロに設定されます。たとえば、4x4の単位行列は次のようになります。

    | 1 0 0 0 |
M = | 0 1 0 0 |
    | 0 0 1 0 |
    | 0 0 0 1 |

Q7. 行列の主対角線とは何ですか?

行列の主対角線は、行番号が列番号と等しい要素のセットです。

M   ここで i=j
 ij

単位行列の場合、主対角線上の要素のみが1に設定され、他のすべての要素は0に設定されます。

Q8. 行列の転置とは何ですか?

行列の転置は、行列のすべての要素が主対角線に対して反対にスワップされたときに生成される行列です。
これは次のような数学的操作として表すことができます。

M'   = M
  ij    ji

ただし、これは行列が行数と列数が等しい場合にのみ実行できます。
行列Mが次のように定義されている場合:

    |  0.707 -0.866 |
M = |               |
    |  0.866  0.707 |

次に、転置は次と等しくなります。

    |  0.707  0.866 |
T = |               |
    | -0.866  0.707 |

行列が回転行列の場合、転置は必ず行列の逆行列になります。

Q9. 2つの行列をどのように加算しますか?

2つの行列を加算する際の経験則は次のとおりです。
「行と列を行と列に加算する」
これは数学的に次のように表すことができます。

R   = M   + L
 ij    ij    ij

ただし、両方の行列はサイズが同じでなければなりません。
たとえば、2x2行列Mを2x2行列Lに加算すると、結果は次のようになります。

R = M + L
    | A B C |   | J K L |
    |       |   |       |
  = | D E F | + | M N O |
    |       |   |       |
    | G H I |   | P Q R |

| A+J B+K C+L |
    |             |
  = | D+M E+N F+O |
    |             |
    | G+P H+Q I+R |

Q10. 2つの行列をどのように減算しますか?

2つの行列を減算する際の経験則は次のとおりです。
「行と列を行と列から減算する」
これは数学的に次のように表すことができます。

R   = M   - L
 ij    ij    ij

ただし、両方の行列はサイズが同じでなければなりません。
たとえば、2x2行列Lを2x2行列Mから減算すると、結果は次のようになります。

R = M - L
    | A B C |   | J K L |
    |       |   |       |
  = | D E F | - | M N O |
    |       |   |       |
    | G H I |   | P Q R |

| A-J B-K C-L |
    |             |
  = | D-M E-N F-O |
    |             |
    | G-P H-Q I-R |

Q11. 2つの行列をどのように乗算しますか?

2つの行列を乗算する際の経験則は次のとおりです。
「行を列に掛け、結果を合計する」
これは数学的に次のように表すことができます。
n
--
R = \ M x L
ij / ik kj
--
k=1

乗算される2つの行列の次数が次のようになっている場合:

M = AxB および L = CxD

次に、BとCの2つの値は同じでなければなりません。
また、結果の行列の次数はAxDになります。
したがって、Nx4行列を4x4行列で乗算することは可能ですが、その逆は不可能です。
たとえば、4x4行列Mが次のように定義されている場合:

    | A B C D |
M = | E F G H |
    | I J K L |
    | M N O P |

そして4x2行列Lが次のように定義されている場合:

L = | Q R |
    | S T |
    | U V |
    | W X |

次に、結果の行列のサイズは4x2になります。結果の行列は次のように定義されます。

R = M x L

    | A B C D |   | Q R |
  = | E F G H | x | S T |
    | I J K L |   | U V |
    | M N O P |   | W X |

    | AQ+BS+CU+DW  AR+BT+CV+DX |
  = | EQ+FS+GU+HW  ER+FT+GV+HX |
    | IQ+JS+KU+LW  IR+JT+KV+LX |
    | MQ+NS+OU+PW  MR+NT+OV+PX |

リスト内の各ベクトルについて、合計12回の乗算、16回の加算、および1回の除算(遠近法用)の操作が行われます。
行列が回転行列または平行移動行列でないことがわかっている場合は、除算操作をスキップできます。

Q12. 行列を二乗またはべき乗するにはどうすればよいですか?

行列は二乗または整数べき乗にすることができます。ただし、いくつかの制限があります。すべてのべき乗について、行列は正方形でなければなりません。つまり、直交しており、幅と高さが同じでなければなりません。
たとえば、

 -1
M   は行列の逆行列です。

 0
M   は単位行列を生成します。

 1
 M   は行列を変更しません。

 2
M   は行列を二乗し、

 3
M   は行列の立方体を生成します。

行列を1より大きいべき乗にすることは、行列を特定の回数だけ自分自身で乗算することを含みます。
たとえば、

 2
M  = M . M

 3
M  = M . M . M

など。

単位行列を任意のべき乗にしても、常に単位行列が生成されます。

 n
I  = I

次のコードスニペットを使用して、少し速くすることができます。mとiの両方が変更されていることに注意してください。
m -> べき乗にする行列
i -> べき乗する指数
a -> 結果を含む行列
I -> 単位行列
/ -> 整数除算(つまり、最も近い整数に切り捨てます)
% -> 整数剰余演算
* -> 行列乗算

a=I
while(i>0){
   if(i%2) a=a*m
   i=i/2
   m=m*m
}

Q13. 1つ以上のベクトルを行列でどのように乗算しますか?

このタスクを実行する最良の方法は、ベクトルのリストを単一の行列として扱い、各ベクトルを列ベクトルとして表すことです。
N個のベクトルを4x4行列で乗算する場合、それらを単一の4xN行列として扱うことができます。
行列が次のように定義されている場合:

    | A B C D |
M = | E F G H |
    | I J K L |
    | M N O P |

そしてベクトルのリストが次のように定義されている場合:

    | x1 x2 x3 x4 x5|
V = | y1 y2 y3 y4 y5|
    | z1 z2 z3 z4 z5|
    | 1  1  1  1   1|

定数項の追加行がベクトルリストに追加され、すべて1.0に設定されていることに注意してください。実際には、この行は存在しません。行列MとベクトルリストVの次数を一致させるためだけに単に使用されます。
次に、乗算は次のように実行されます。

        M . V = V'

| A B C D | | x1 x2 x3 x4 x5 | | A.x1+B.y1+C.z1+D A.x2+B.y2+C.z2+D ... |
| E F G H | . | y1 y2 y3 y4 y5 | = | E.x1+F.y1+G.z1+H E.x2+F.y2+G.z2+H ... |
| I J K L | | z1 z2 y3 y4 z5 | | I.x1+J.y1+K.z1+L I.x2+J.y2+K.z2+L ... |
| M N O P | | 1 1 1 1 1 | | M.x1+N.y1+O.z1+P M.x2+N.y2+O.z2+P ... |

リスト内の各ベクトルについて、合計12回の乗算、16回の加算、および1回の除算(遠近法用)の操作が行われます。
行列が回転または平行移動行列でないことがわかっている場合は、除算操作をスキップできます。

DETERMINANTS AND INVERSES

Q14. 行列の行列式とは何ですか?

行列の行列式は、行列に逆行列が存在するかどうかを示すために使用される浮動小数点値です。ゼロの場合、逆行列は存在しません。非ゼロの場合、逆行列が存在します。
例として、単一の要素からなる行列を考えます。

M = [ 1 ].

このサイズの行列の場合、行列式は単一の要素の値にすぎません。
また、逆行列は単一の要素の逆数にすぎません。

-1
M = [ 1 / M[0][0] ]

この単一の値が非ゼロの場合、逆行列が存在します。単位行列の場合、これは1 / 1または1.0になります。
ただし、この単一要素の値がゼロの場合、行列式もゼロになります。

ゼロの逆数を計算しようとすると、無限大の値が生成されます。これは行列に関しては許可されないため、行列の逆行列は存在しません。
単位行列の場合、行列式は常に1に等しくなります。
行列式が1.0の任意の行列は等方的であると言われます。
したがって、すべての回転行列は等方的であると言われます。なぜなら、行列式は常に1.0に等しいからです。
これは次のように証明できます。

    | A B |   | cos X  -sin X |
M = |     | = |               |
    | C D |   | sin X   cos X |

D = AD - BC

D = (cos X . cos X) -  (-sin X . sin X)

        2          2
D = (cos X ) + (sin X)

        2       2
しかし、cos X + sin X = 1

したがって、
D = 1

Q15. 行列の行列式をどのように計算しますか?

行列の行列式は、クラメルの公式を使用して計算されます。ここで、値は行列をより小さな行列に分割することによって計算できます。
2x2行列Mの場合、行列式Dは次のように計算されます。

    | A B |
M = |     |
    | C D |

D = AD - BC

3x3および4x4行列の場合、これはより複雑ですが、クラメルの公式などの方法で解決できます。

Q16. 等方的および異方的な行列とは何ですか?

等方的行列とは、すべての3つの行または列の二乗の合計が1になる行列です。
そうでない行列は異方的であると言われます。
3x3または4x4行列を使用してオブジェクトを回転およびスケーリングする場合、場合によっては、他の軸よりも1つの軸を拡大または縮小する必要があります。
たとえば、地震調査では、X軸とY軸を同じままにして、Z軸を50倍以上に拡大すると便利です。
別の例は、キャラクターアニメーションでの「つぶし」と「伸ばし」の実装です。キャラクターが重い物体(例:金床)に当たると、キャラクターが横に引き伸ばされ、垂直につぶされたように見せたい効果があります。
適切な行列は次のようになります。

    |  2   0   0    0  |
M = |  0   2   0    0  |
    |  0   0   0.5  0  |
    |  0   0   0    1  |

ただし、問題が発生しています。この行列は頂点データの変換に問題を引き起こしませんが、法線データには問題を引き起こします。
変換ステージは行列乗算を使用して実装されるため、頂点データと外向き法線データの両方がこの行列で乗算されます。
これは頂点データの問題ではありません(望ましい効果です)が、外向き法線データに大きな問題を引き起こします。
生の乗算後、各外向き法線は正規化されなくなり、結果としてシェーディングやバックフェイスカリングなどの他の計算に影響します。

Q17. 行列の逆行列とは何ですか?

                                                             -1

行列Mが与えられた場合、その行列の逆行列(M と表記)は、次の式を満たす行列です。

     -1
M . M   = I

ここでIは単位行列です。
したがって、行列とその逆行列を乗算すると単位行列が生成されます。ただし、行列の逆行列を計算できる前に、いくつかの要件を満たす必要があります。
これらには、行列の幅と高さが同じであること、および行列の行列式がゼロでないことが含まれます。
行列の逆行列を計算することは、スプライン曲線を使用して逆運動学を実装するためによく行われるタスクです。

Q18. 任意の行列の逆行列をどのように計算しますか?

行列のサイズによっては、逆行列の計算は単純な場合もあれば、非常に複雑な場合もあります。
たとえば、1x1行列の逆行列は、単一の要素の逆数にすぎません。

つまり、M = | x |

次に、逆行列は次のように定義されます。

 -1   | 1 |
M   = | - |
      | x |

2x2行列以上の解は、クラメルの公式を使用するか、連立方程式として解くことによって達成できます。
ただし、単位行列や回転行列などの特定のケースでは、逆行列はすでにわかっているか、行列の転置を取ることから決定できます。

Q19. 単位行列の逆行列をどのように計算しますか?

気にする必要はありません。単位行列の逆行列は単位行列です。つまり、

     -1
I . I   = I

任意の単位行列の行列式は常に+1です。

Q20. 回転行列の逆行列をどのように計算しますか?

回転行列は常に+1の行列式を生成するため、逆行列の計算は転置の計算と同等です。
あるいは、回転角度がわかっている場合は、回転角度を否定して新しい回転行列を計算するために使用できます。

Q21. クラメルの公式を用いて行列の逆行列をどのように計算しますか?

3x3行列Mが与えられた場合:

    | A B C |
    |       |
M = | D E F |
    |       |
    | G H I |

次に、行列式は次のように計算されます。

         n
        ---
        \                           i
det M = /   M    * submat    M  * -1
        ---  0,i         0,i
        i=1

ここで

submat   M は、Mのすべての行と列で構成される行列を定義します。
      ij

i行とj列を除外します。submat は再帰的に呼び出すことができます。
ij
| A B C |
M = | D E F | は submat = | E F | となります。
| G H I | 11 | H I |

行列式が非ゼロの場合、行列の逆行列が存在します。
この場合、各行列要素の値は次のように定義されます。

 -1      1                            i+j
M    = -----  *  det submat     M * -1
 j,i   det M               i,j

Q22. 2x2行列の逆行列をどのように計算しますか?

2x2行列の場合、計算は少し難しくなります。行列が次のように定義されている場合:

    | A B |
M = |     |
    | C D |

次に、行列式は次のように定義されます。

det = AD - BC

そして、逆行列は次のように定義されます。

 -1     1   |  D  -B  |
M   =  ---  |         |
       det  | -C   A  |

これはクラメルの公式を使用して証明できます。行列Mが与えられた場合:

    | A B |
M = |     |
    | C D |

次に、行列式は次のようになります。

                       0                            1
det =  M    * submat M    * -1 +  M    * submat M    * -1
        0,0           0,0          0,1           0,1

<=>    M    * M    * 1         +  M    * M    * -1
        0,0    1,1                 0,1    1,0

<=>    A  * D                  +  B    * C    * -1

<=>    AD                      +  BC . -1

<=>    AD - BC

そして、逆行列は次から導出されます。

 -1                      0+0      -1
M    = det submat    * -1    <=> M    = M    *  1 <=> D
 0,0             0,0              0,0    1,1

 -1                      1+0      -1
M    = det submat    * -1    <=> M    = M    * -1 <=> C * -1
 0,1             1,0              0,1    1,0

 -1                      0+1      -1
M    = det submat    * -1    <=> M    = M    * -1 <=> B * -1
 1,0             0,1              1,0    0,1

 -1                      1+1      -1
M    = det submat    * -1    <=> M    = M    *  1 <=> A
 1,1             1,1              1,1    0,0

 次に、逆行列は次と等しくなります。

 -1    1  |  D  -C |
M   = --- |        |
      det | -B   A |

行列式がゼロでないことを前提とします。

Q23. 3x3行列の逆行列をどのように計算しますか?

3x3行列以上の場合、逆行列はクラメルの公式を適用するか、連立方程式として解くことによって計算できます。
クラメルの公式を行列Mに適用する場合:

    | A B C |
M = | D E F |
    | G H I |

次に、行列式は次のように計算されます。
det M = A * (EI - HF) - B * (DI - GF) + C * (DH - GE)

行列式が非ゼロであることを前提とすると、逆行列は次のように計算されます。

 -1     1     |   EI-FH  -(BI-HC)   BF-EC  |
M   = ----- . | -(DI-FG)   AI-GC  -(AF-DC) |
      det M   |   DH-GE  -(AH-GB)   AE-BD  |

これは、一対の「C」関数を使用して実装できます。

VFLOAT m3_det( MATRIX3 mat )
  {
  VFLOAT det;
  det = mat[0] * ( mat[4]*mat[8] - mat[7]*mat[5] )
      - mat[1] * ( mat[3]*mat[8] - mat[6]*mat[5] )
      + mat[2] * ( mat[3]*mat[7] - mat[6]*mat[4] );
  return( det );
  }

int m3_inverse( MATRIX3 mr, MATRIX3 ma )
{
VFLOAT det = m3_det( ma );
if ( fabs( det ) < 0.0005 )
{

   m3_identity( mr );
   return(0);
   }

 mr[0] =    ma[4]*ma[8] - ma[5]*ma[7]   / det;
 mr[1] = -( ma[1]*ma[8] - ma[7]*ma[2] ) / det;
 mr[2] =    ma[1]*ma[5] - ma[4]*ma[2]   / det;
 mr[3] = -( ma[3]*ma[8] - ma[5]*ma[6] ) / det;
 mr[4] =    ma[0]*ma[8] - ma[6]*ma[2]   / det;
 mr[5] = -( ma[0]*ma[5] - ma[3]*ma[2] ) / det;
 mr[6] =    ma[3]*ma[7] - ma[6]*ma[4]   / det;
 mr[7] = -( ma[0]*ma[7] - ma[6]*ma[1] ) / det;
 mr[8] =    ma[0]*ma[4] - ma[1]*ma[3]   / det;
 return(1);
 }

Q24. 4x4行列の逆行列をどのように計算しますか?

3x3行列と同様に、クラメルの公式を適用するか、行列を連立方程式として解くことができます。
効率的な方法は、3x3行列の行列式と逆行列を計算するために定義された既存の「C」関数を利用することです。
4x4行列でクラメルの公式を実装するには、個々のサブ行列を決定する必要があります。これは次のルーチンによって達成されます。

void	 m4_submat( MATRIX4 mr, MATRIX3 mb, int i, int j ) {
  int di, dj, si, sj;
  // 3x3サブ行列をループする
  for( di = 0; di < 3; di ++ ) {
    for( dj = 0; dj < 3; dj ++ ) {
      // 3x3要素(宛先)を4x4要素(ソース)にマッピングする
      si = di + ( ( di >= i ) ? 1 : 0 );
      sj = dj + ( ( dj >= j ) ? 1 : 0 );
      // 要素をコピーする
      mb[di * 3 + dj] = mr[si * 4 + sj];
    }
  }
}

4x4行列の行列式は次のように計算できます。

VFLOAT m4_det( MATRIX4 mr )
  {
  VFLOAT  det, result = 0, i = 1;
  MATRIX3 msub3;
  int     n;
  for ( n = 0; n < 4; n++, i *= -1 )
    {

    m4_submat( mr, msub3, 0, n );
    det     = m3_det( msub3 );
    result += mr[n] * det * i;
    }
  return( result );
  }

そして、逆行列は次のように計算できます。

int m4_inverse( MATRIX4 mr, MATRIX4 ma )
  {

  VFLOAT  mdet = m4_det( ma );
  MATRIX3 mtemp;
  int     i, j, sign;
  if ( fabs( mdet ) < 0.0005 )
m4_identity( mr );
    return( 0 );
  for ( i = 0; i < 4; i++ )
    for ( j = 0; j < 4; j++ )
      {
      sign = 1 - ( (i +j) % 2 ) * 2;
      m4_submat( ma, mtemp, i, j );
      mr[i+j*4] = ( m3_det( mtemp ) * sign ) / mdet;
      }
  return( 1 );
  }

任意の4x4行列の逆行列を計算できる関数を持つことは、信じられないほど便利なツールです。アプリケーションには、スプラインのベース行列、逆回転、行列方程式の並べ替えを計算する機能が含まれます。

Q25. 線形方程式を用いて行列の逆行列をどのように計算しますか?

行列Mが存在する場合、次のように:

     | A B C |
M  = | D E F |
     | G H I |

次に、逆行列が存在します。

     | P Q R |
M' = | S T U |
     | V W X |

そして、次の式が有効です。

                 -1
    M     .     M     = I

| A B C |   | P Q R |   | 1 0 0 |
| D E F | . | S T U | = | 0 1 0 |
| G H I |   | V W X |   | 0 0 1 |

逆行列は、連立方程式のセットとして解くことによって計算できます。

| AP + BS + CV |   | 1 |   列 0 (X)
| DP + ES + FV | = | 0 |
| GP + HS + IV |   | 0 |

| AQ + BT + CW |   | 0 |   列 1 (Y)
| DQ + ET + FW | = | 1 |
| GQ + HT + IW |   | 0 |

| AR + BU + CX |   | 0 |   列 2 (Z)
| DR + EU + FX | = | 0 |
| GR + HU + IX |   | 1 |

TRANSFORMS

Q26. 回転行列とは何ですか?

回転行列は、座標システム内の点のセットを回転するために使用されます。個々の点の座標は新しい座標に割り当てられますが、それらの相対距離は変わりません。
すべての回転は、三角関数「サイン」と「コサイン」を使用して定義されます。
2次元座標システムの場合、回転行列は次のようになります。

| cos(A)  -sin(A) |
|                 |
| sin(A)   cos(A) |

回転角度Aがゼロに設定されると、これは単位行列を生成します。

    |  1  0 |
I = |       |
    |  0  1 |

回転が+90度に設定されると、行列は次のようになります。

    |  0 -1 |
M = |       |
    |  1  0 |

回転が-90度に設定されると、行列は次のようになります。

    |  0  1 |
M = |       |
    | -1  0 |

回転角度を否定することは、行列の転置を生成することと同等です。
回転行列をその転置で乗算すると、結果は単位行列になります。

Q27. 回転行列は座標システムとどのように関係しますか?

回転行列は、次のように座標システムと関係します。
数学的な慣習では、正の回転角度は、原点から回転軸の正の端に向かって見るときに時計回りの回転を生成すると要求されます。
この規則を適用すると、3つのデカルト回転行列を導出できます。右手座標系を考えます。各回転軸について、原点から選択された軸の正の端に向かって見ます。これにより、次の3つのビューが生成されます。
+----------------------------------------+
| |
| X軸 Y軸 Z軸 |
| |
| |
| ^ Y ^ Z Y ^ |
| | | | |
| | | | |
| | | | |
| | | | |
| O----> Z O----> X X <----O |
| |
+----------------------------------------+
正の回転角度は時計回りの回転を生成するため、各回転の座標マッピングのセットを生成できます。
簡潔にするために、+90度の回転を検討します。
X軸から始めます。

( 0, 1, 0 ) -> ( 0, 0, 1 )
( 0, 0, 1 ) -> ( 0,-1, 0 )
( 0,-1, 0 ) -> ( 0, 0,-1 )
( 0, 0,-1 ) -> ( 0, 1, 0 )

これらは次のように単純化できます。

X' =  X
Y' = -Z
Z' =  Y

これらを行列に配置できます。

     | 1  0       0     |
Rx = | 0  cos A  -sin A |
     | 0  sin A   cos A |

Y軸についても同様に行います。

( 0, 0, 1) -> ( 1,0, 0)
( 1, 0, 0) -> ( 0,0,-1)
( 0, 0,-1) -> (-1,0, 0)
(-1, 0, 0) -> ( 0,0, 1)

これらは次のように単純化できます。

X' = Z
Y' = Y
Z' = -X

これらを次に行列に配置できます。

     |  cos A   0   sin A  |
Ry = |  0       1   0      |
     | -sin A   0   cos A  |

そして最後にZ軸について。

( 0, 1, 0 ) -> ( -1,  0, 0 )
(-1, 0, 0 ) -> (  0, -1, 0 )
( 0,-1, 0 ) -> (  1,  0, 0 )
( 1, 0, 0 ) -> (  0,  1, 0 )

これらは次のように単純化できます。

X' = -Y
Y' =  X
Z' =  Z

これらを次に行列に配置します。

     |  cos A   -sin A    0  |
Rz = |  sin A    cos A    0  |
     |  0        0        1  |

これらはOpenGLによって使用される3つの基本的な回転行列です。

Q28. X軸の回転行列をどのように生成しますか?

4x4行列を使用します。

     |  1  0       0       0 |
 M = |  0  cos(A) -sin(A)  0 |
     |  0  sin(A)  cos(A)  0 |
     |  0  0       0       1 |

Q29. Y軸の回転行列をどのように生成しますか?

4x4行列を使用します。

     |  cos(A)  0   sin(A)  0 |
 M = |  0       1   0       0 |
     | -sin(A)  0   cos(A)  0 |
     |  0       0   0       1 |

Q30. Z軸の回転行列をどのように生成しますか?

4x4行列を使用します。

     |  cos(A)  -sin(A)   0   0 |
 M = |  sin(A)   cos(A)   0   0 |
     |  0        0        1   0 |
     |  0        0        0   1 |

Q31. オイラー角とは何ですか?

オイラー角とは、X、Y、Zの各回転軸での回転を指定する回転角度のセットに付けられた名前です。
これらはベクトル形式で指定されます(例:|x y z|)そしてVECTORデータ構造として格納できます。
たとえば、セット

| 0 0 0 |

は常に単位行列を生成します。
他の角度は次のように表されます。

| 90 0 0 | はX軸の+90度回転です。
| 0 90 0 | はY軸の+90度回転です。
| 0 0 90 | はZ軸の+90度回転です。

オイラー角は、単一のベクトルデータ構造を使用して表すことができます。

Q32. ヨウ、ロール、ピッチとは何ですか?

ヨウ、ロール、ピッチは、航空機のローカル座標系に対するユークリッド座標系(オイラー角)を使用した回転の航空用語です。
飛行機を真上から、そして真後ろから見ていると想像してください。
Z軸は飛行機の尾部と機首に沿って配置されます。
X軸は左翼端から右翼端まで走ります。
Y軸は地面からまっすぐ上に伸びています。
ピッチはX軸の回転、ヨウはY軸の回転、ロールはZ軸の回転になります。

Q33. 回転行列をどのように結合しますか?

回転行列は行列乗算を使用して結合されます。
結果として、乗算の順序は非常に重要です。

Q34. ジンバルロックとは何ですか?

ジンバルロックとは、オイラー角の使用時に発生する問題に付けられた名前です。最終的な回転行列は乗算の順序に依存するため、ある軸での回転が別の回転軸にマッピングされる場合があります。
さらに悪いことに、オブジェクトを指定された軸で回転させることが不可能になる場合があります。これはジンバルロックと呼ばれます。
たとえば、オブジェクトがZ、Y、Xの順序で回転しており、Y軸の回転が90度であると仮定します。
この場合、Z軸の回転が最初に実行され、したがって正しく行われます。Y軸も正しく回転します。しかし、Y軸での回転後、X軸はZ軸に回転します。
したがって、X軸での任意の回転は、実際にはオブジェクトをZ軸で回転させます。さらに悪いことに、オブジェクトをX軸で回転させることが不可能になります。
この問題の便利な解決策は、クォータニオンを利用することです。

Q35. 回転行列を結合する正しい方法は?

実際には、回転行列を結合する「正しい方法」はありません。
しかし、行列を結合した結果を予測できるようにするには、ある程度の組織化が必要です。これは、完全な3D行列ライブラリを構築する場合にも必要です。
オブジェクトを回転させる最も簡単な方法は、次の順序で乗算することです。

M = X.Y.Z

ここで、Mは最終的な回転行列、X、Y、Zは個々の回転行列です。これは、まずX軸(ピッチ)、次にY軸(ヨウ)、そして最後にZ軸(ロール)での回転を定義します。
ただし、カメラの視点からのビューを評価する際には、回転の順序と符号が逆になります。
たとえば、あなたが立っていて、左を向くと、あなたの視野にあるすべてが右に向かって移動するように見えます。
しかし、あなたに面している他の人は、あなたが彼らの右に向かって回ったと言うでしょう。
したがって、カメラからのビューは次の順序を使用してモデル化されます。

M = -Z.-Y.-X

これは、カメラが別のオブジェクトとしてレンダリングされていた場合に生成される回転行列の逆行列(または転置)です。

Q36. オイラー角から回転行列をどのように生成しますか?

一見すると、オイラー角から回転行列を生成する最も明白な方法は、各行列を個別に生成し、3つすべてを乗算することです。

m3_rotx( mat_x,     vec -> angle_x );
m3_roty( mat_y,     vec -> angle_y );
m3_rotz( mat_z,     vec -> angle_z );
m3_mult( mat_tmp,   mat_z, mat_y   );
m3_mult( mat_final, mat_tmp, mat_x );

この一連の呼び出しは、次のような別のルーチンに配置できます。

m3_fromeuler( MATRIX *mat_final, VECTOR3 *euler )

しかし、この一連の呼び出しを実行することは、処理時間の点で非常に無駄です。各4x4回転行列は、値がゼロ(0)の要素が10個、値が1(1)の要素が2個、その他の4つの任意の値を持つことが保証されているため、各行列演算の75%以上が無駄になります。これには、各行列のセットアップと初期化は含まれていません。
全体として、すべての行列演算の75%以上は、ゼロまたは1につながる算術式の処理に費やされます。
より効率的な方法を見つける必要があります。幸いなことに、最終的な結果の行列を決定する別の方法があります。
3つの行列すべてを代数形式で結合すると、次の式が定義されます。

M = X.Y.Z

ここで、Mは最終行列、
XはX軸の回転行列、
YはY軸の回転行列、
ZはZ軸の回転行列です。

代数形式の回転行列に展開すると、次のようになります。

     |  1  0  0 |
X  = |  0  A -B |
     |  0  B  A |

     |  C  0  D |
Y  = |  0  1  0 |
     | -D  0  C |

     |  E -F  0 |
Z  = |  F  E  0 |
     |  0  0  1 |

ここで、A、BはX軸回転軸のコサインとサイン、
C、DはY軸回転軸のコサインとサイン、
E、FはZ軸回転軸のコサインとサインです。

次に、次の式:

M  = X.Y.Z

を2つの行列乗算に分割できます。

M' = X.Y
M  = M'.Z

まずM'を評価します。

M' = X.Y

     | 1  0  0 |   | C  0  D |
M' = | 0  A -B | . | 0  1  0 |
     | 0  B  A |   |-D  0  C |

     | 1.C + 0.0 +  0.-D   1.0 + 0.1 +  0.0   1.D + 0.0 +  0.C |
M' = | 0.C + A.0 + -B.-D   0.0 + A.1 + -B.0   0.D + A.0 + -B.C |
     | 0.C + B.0 +  A.-D   0.0 + B.1 +  A.0   0.D + B.0 +  A.C |

M'を単純化すると、次のようになります。

     |  C     0   D   |
M' = |  B.D   A  -B.C |
     | -A.D   B   A.C |

Mを評価します。

M  = M'.Z

     |  C   0   D  |   | E -F  0 |
M  = |  BD  A  -BC | . | F  E  0 |
     | -AD  B   AC |   | 0  0  1 |

     |   C.E + 0.F +   D.0    C.-F + 0.E +  D.0     C.0 + 0.0 +   D.1 |
M  = |  BD.E + A.F + -BC.0   BD.-F + A.E + -BC.0   BD.0 + A.0 + -BC.1 |
     | -AD.E + B.F +  AC.0  -AD.-F + B.E +  AC.0  -AD.0 + 0.0 +  AC.1 |

Mを単純化すると、3x3行列が得られます。

     |  CE      -CF       D  |
M  = |  BDE+AF  -BDF+AE  -BC |
     | -ADE+BF   ADF+BE   AC |

4x4行列としては次のようになります。

     |  CE      -CF       D   0 |
M  = |  BDE+AF  -BDF+AE  -BC  0 |
     | -ADE+BF   ADF+BE   AC  0 |
     |  0        0        0   1 |

A、B、C、D、E、Fの個々の値が最初に評価されます。また、BDとADの値も、複数回出現するため評価されます。
したがって、最終的なアルゴリズムは次のようになります。

A       = cos(angle_x);
B       = sin(angle_x);
C       = cos(angle_y);
D       = sin(angle_y);
E       = cos(angle_z);
F       = sin(angle_z);
AD      =   A * D;
BD      =   B * D;
mat[0]  =   C * E;
mat[1]  =  -C * F;
mat[2]  =   D;

mat[4]  =  BD * E + A * F;
mat[5]  = -BD * F + A * E;
mat[6]  =  -B * C;
mat[8]  = -AD * E + B * F;
mat[9]  =  AD * F + B * E;
mat[10] =   A * C;
mat[3]  =  mat[7] = mat[11] = mat[12] = mat[13] = mat[14] = 0;
mat[15] =  1;

基本的な行列計算を使用すると、操作数は128回の乗算、96回の加算、および80回の代入操作に達します。
最適化されたアルゴリズムを使用すると、12回の乗算、6回の減算、および18回の代入操作のみが必要です。
したがって、最適化されたアルゴリズムを使用することで、1000%のパフォーマンス達成が可能になることは明らかです。

Q37. 回転行列からオイラー角をどのように変換しますか?

この操作は、上記の質問の逆です。回転行列が次のようになっていると仮定します。

     |  CE      -CF       D   0 |
M  = |  BDE+AF  -BDF+AE  -BC  0 |
     | -ADE+BF   ADF+BE   AC  0 |
     |  0        0        0   1 |

ここで、A、BはX軸回転軸のコサインとサイン、
C、DはY軸回転軸のコサインとサイン、
E、FはZ軸回転軸のコサインとサインです。

4x4行列のCデータ構造を使用すると、インデックス値は次のようになります。

     |  0  1  2  3 |
M =  |  4  5  6  7 |
     |  8  9 10 11 |
     | 12 13 14 15 |

これらの2つの表を見ると、配列要素[2]の値がDまたはsin(Y)であることがわかります。次に、Y軸の回転角度は、逆サイン関数呼び出しから計算できます。この値をコサイン関数に渡すと、Cの値が得られます。

Cがゼロでない場合、X軸とZ軸の回転角度は、それぞれ3番目の列と最初の行の項から導出できます。これらは次のようになります。

X軸:  M[6]  = -BC
         M[10] =  AC

Z軸:  M[0]  =  CE
         M[1]  = -CF

実際の回転角度は、各ペアの値を取り、Cで割って結果を逆タンジェント関数に渡すことで導出できます。
Cがゼロの場合、これらの計算は不可能です。この場合、Y軸の回転角度は-90または+90のいずれかになります。したがって、Dは1または-1の値になります。
この場合、ジンバルロックが発生します。X軸とZ軸の両方の回転は同じ軸にあるように見えます。これは、回転軸の評価を通じて見ることができます。

     |  0.E       -0.F        1    0 |
M  = |  B.1.E+AF  -B.1.F+AE  -B.0  0 |
     | -A.1.E+BF   A.1.F+BE   A.0  0 |
     |  0          0          0    1 |

各項を乗算すると、次のようになります。

     |  0          0          1    0 |
M  = |  BE+AF     -BF+AE      0    0 |
     | -AE+BF      AF+BE      0    0 |
     |  0          0          0    1 |

これらの2つの値を並べ替えると、次のようになります。

     |   0          0          1    0 |
M  = |   BE+AF      AE-BF      0    0 |
     | -(AE-BF)     BE+AF      0    0 |
     |   0          0          0    1 |

次に、行列が実際には次の形式であることがわかります。

     |  0   0   1   0 |
M  = |  V   W   0   0 |
     | -W   V   0   0 |
     |  0   0   0   1 |

ここで、Vの値はBE+AFであり、
Wの値はAE-BFです。

これらの2つの値は、単一の回転軸のサインとコサインと見なすことができます。
最終的なアルゴリズムは次のようになります。

angle_y = D =  asin( mat[2]);        /* Y軸角度を計算 */
C           =  cos( angle_y );
angle_y    *=  RADIANS;            /* 角度をラジアンに変換 */
if ( fabs( C ) > 0.005 )             /* ジンバルロックか? */
  {
  trx      =  mat[10] / C;           /* いいえ、X軸角度を取得 */
  try      = -mat[6]  / C;
  angle_x  = atan2( try, trx ) * RADIANS;
  trx      =  mat[0] / C;            /* Z軸角度を取得 */
  try      = -mat[1] / C;
  angle_z  = atan2( try, trx ) * RADIANS;
  }
else                                 /* ジンバルロックが発生した場合 */
  {
  angle_x  = 0;                      /* X軸角度をゼロに設定 */
  trx      =  mat[5];                 /* そしてZ軸角度を計算 */
  try      =  mat[4];
  angle_z  = atan2( try, trx ) * RADIANS;
  }

/* 正の角度のみを[0,360]で返す */
if (angle_x < 0) angle_x += 360;
if (angle_y < 0) angle_y += 360;
if (angle_z < 0) angle_z += 360;
-----------------------------------

Q38. 指定された軸と角度の回転行列をどのように生成しますか?

このタイプの回転行列を生成する最も簡単な方法は、クォータニオン数学を使用することです。
詳細については、[Q53: クォータニオンから回転行列をどのように変換しますか?] を参照してください。
次のコードスニペットは、その大部分を行います(phiは回転角度、(u,v,w)は回転(軸)ベクトル)。

rcos = cos(phi);
rsin = sin(phi);
matrix[0][0] =      rcos + u*u*(1-rcos);
matrix[1][0] =  w * rsin + v*u*(1-rcos);
matrix[2][0] = -v * rsin + w*u*(1-rcos);
matrix[0][1] = -w * rsin + u*v*(1-rcos);
matrix[1][1] =      rcos + v*v*(1-rcos);
matrix[2][1] =  u * rsin + w*v*(1-rcos);
matrix[0][2] =  v * rsin + u*w*(1-rcos);
matrix[1][2] = -u * rsin + v*w*(1-rcos);
matrix[2][2] =      rcos + w*w*(1-rcos);

4x4行列を使用している場合は、残りの行列を0([3][3]に1)に設定することを忘れないでください!

Q39. あるベクトルを別のベクトルにマッピングする回転行列をどのように生成しますか?

アニメーションソフトウェアを開発する際、一般的な要件は、ある方向ベクトルを別の方向にマッピングする回転行列を見つけることです。
この問題は、2つの方向ベクトルがそれらの始点で接続されていると考えることで視覚化できます。次に、回転空間全体が単位球を形成します。
理論的には、1つのベクトルを別のベクトルにマッピングする無限の回転軸と角度が存在します。これらの軸はすべて、両方のベクトルから等距離にあるすべての点の平面上にあります。
しかし、実用的な関心のある解は1つだけです。これは、2つのベクトル間の最短角度距離をカバーするパスです。
このパスの回転軸は、2つのベクトルの外積を取ることによって計算されます。

Vaxis = Vs x Vf

回転角度は、2つのベクトルの内積を取ることで計算されます。

            -1
Vangle = cos   ( Vs . Vf )

この問題の解の実用的な応用例の1つは、2つの都市間の最短飛行経路を見つけることです。この場合、各都市は球面座標から生成された方向ベクトルとして表されます。地球は球形であるため、目的の飛行経路は2つの都市間の最短角度回転です。

注:VsとVfが共線の場合、外積は(0,0,0)を返します。そのケースをテストし、VsまたはVfのいずれかの90度回転を回転軸として使用する必要があります(例:(y、z、x))。x == y == zの場合、2番目のベクトルからx、y、またはzのいずれかを使用すると役立つ場合があります。
--> より良い方法はありますか?

回転角度とベクトルがあれば、対応する行列を生成するのは簡単です。[Q38: 指定された軸と角度の回転行列をどのように生成しますか?] を参照してください。

ジンバルロックの幽霊に惑わされないでください。オイラー角は依然として3D空間の任意の回転の完全な表現です。単に、特定の望ましい回転を達成するために必要な実際のオイラー角が非常に直感的でないだけです。

Q40. 行列を用いて座標システムを別の座標システムに変換するにはどうすればよいですか?

前の問題と同様に、要件は1つの座標システムを別の座標システムにマッピングすることです。ただし、単一の座標軸を別の軸にマッピングしようとするだけでなく、3つの軸すべてを一致させる必要があります。
したがって、両方の座標システムは3x3または4x4行列として表されます。

問題は、一方の行列をもう一方の行列にマッピングする回転行列を見つけることです。これは数学的に次のように表現できます。

Mfinal = Mrot . Morig

ここで、Mfinalは最終的な座標システム行列、
Morigは元の座標システム、
Mrotは目的の回転行列です。

目標は、行列Mrotを見つけることです。これは、方程式を次のように並べ替えることで達成できます。

              -1
Mfinal . Morig   = Mrot

                       -1
Mrot   = Mfinal . Morig

したがって、目的の回転行列は、元の座標システムの逆行列を計算し、それを最終的な回転行列で乗算することによって得られます。

チェックとして、元の回転行列または最終的な回転行列のいずれかが単位行列であるケースを検討します。各ケースで、回転行列は最終行列および最終行列の逆行列とそれぞれ一致する必要があります。

計算されたら、回転行列をクォータニオンに変換できます。

Q41. 平行移動行列とは何ですか?

平行移動行列は、オブジェクトを回転させることなく3D空間内に配置するために使用されます。行列乗算を使用した平行移動操作は、4x4行列のみを使用して実行できます。

平行移動がベクトル[X Y Z]によって定義されている場合、平行移動を実行するための4x4行列は次のようになります。

    | 1  0  0  X |
    |            |
    | 0  1  0  Y |
M = |            |
    | 0  0  1  Z |
    |            |
    | 0  0  0  1 |

ベクトルが[0 0 0]の場合、頂点リストは以前と同じになります。

Q42. スケーリング行列とは何ですか?

スケーリング行列は、3Dモデルのサイズを拡大または縮小するために使用されます。
スケーリングベクトルが[X Y Z]の場合、これを実行するための行列は次のようになります。

    | X  0  0  0 |
    |            |
    | 0  Y  0  0 |
M = |            |
    | 0  0  Z  0 |
    |            |
    | 0  0  0  1 |

スケーリングベクトルが[1 1 1]の場合、これは単位行列を生成し、頂点ジオメトリは変更されません。

Q43. せん断行列とは何ですか?

せん断行列は、3Dモデルが横に傾いているように見せるために使用されます。
たとえば、「イタリック」テキストは、各文字が右に傾いている必要があります。
3次元では、6つの可能なせん断方向が存在します。

o XをYでせん断
o XをZでせん断
o YをXでせん断
o YをZでせん断
o ZをXでせん断
o ZをYでせん断

6つのせん断方向すべてを単一の行列に組み合わせることができます。

    | 1    Syx  Szx  0 |
    |                  |
    | Sxy  1    Szy  0 |
M = |                  |
    | Sxz  Syz  1    0 |
    |                  |
    | 0    0    0    1 |
    |                  |

ここでSijはIをJでせん断します。
したがって、SxyはXをYでせん断します。

理論的には、3次元の回転は、6つのせん断方向の組み合わせと見なすことができます。

Q44. 2つの行列間で線形補間を実行するにはどうすればよいですか?

2つの回転行列が与えられた場合、問題は、tが0.0から1.0まで変化するパラメータ変数によって指定される中間位置を決定する方法を見つけることです。
これは、2つの行列をオイラー角または球面回転角(クォータニオン経由)と平行移動ベクトルに変換することによって達成できます。

いずれの場合も、各行列は2つの3Dベクトルのペアに変換されます。次に、これらの2つのベクトル間の補間は、標準の線形補間方程式を使用して実行できます。

  Vr = Va + t .(Vb - Va )

ここで、Vrは結果のベクトル、
Vaは開始位置ベクトル、
Vbは最終位置ベクトルです。

この方程式は、平行移動ベクトルと回転ベクトルに適用できます。
決定後、結果の平行移動と回転は、目的の中間行列に変換されます。

Q45. 4つの行列間で立方体補間を実行するにはどうすればよいですか?

4つの回転または平行移動行列が与えられた場合、問題は、パラメータ変数tによって指定される中間位置を決定する方法を見つけることです。

これは、立方体補間を利用することによって達成できます。線形補間と同様に、4つの行列は対応する平行移動ベクトルと回転ベクトル(再び、オイラー角または球面回転角のいずれか)に変換されます。

次に、各4つのベクトルのセットは、単一のジオメトリベクトルGに変換されます。スプライン数学を使用すると、このジオメトリベクトルは補間行列Mに変換されます。

ジオメトリベクトルが次のように定義されている場合:

     | x1 x2 x3 x4 |
 G = | y1 y2 y3 y4 |
     | z1 z2 z3 z4 |

次に、ベース行列で乗算します。

     |  -4.5    9.0  -5.5  1.0  |
Mb = |  13.5  -22.5   9.0  0.0  |
     | -13.5   18.0  -4.5  0.0  |
     |   4.5   -4.5   1.0  0.0  |

は、3x4補間行列Miを生成します。

Mi = G .Mb

これは、標準の行列ベクトル乗算によって実装できます。次に、パラメータ変数tを使用して補間を実行できます。

    R  = Mi . t

                       |t^3|
| xr |   | A B C D |   |t^2|
| yr | = | E F G H | . |t  |
| zr |   | I J K L |   |1  |

結果ベクトルは、回転または平行移動行列に変換できます。

生成される回転パスが時々ループ状になることがあることに注意してください。これは正常です。アルゴリズムは、4つのベクトルすべて間の回転量が最も少ないパスを見つけようとしているためです。

2つの方法のうち、球面回転角は通常、回転に対して最もクリーンな補間パスを提供することがわかります。

Q46. 行列をどのようにレンダリングできますか?

3Dアニメーション用のグラフィックスウィンドウを使用する場合、アニメーションと同時に回転行列を表示できると便利です。
しかし、回転行列を数値の配列として表示しても、あまり意味のあるコンテキストは提供されません。
数値データをレンダリングする代替手段は、棒グラフなどのグラフィカル表示方法を利用することです。

ステレオのグラフィックイコライザーのように、回転行列は棒グラフ形式で表示できます。回転行列の各要素は、-1から+1の範囲で個別の棒グラフとしてレンダリングされます。
3x3行列は次のようになります。

+--+ +--+ +--+
|##| |  | |  |
+--+ +--+ +--+
|  | |  | |  |
+--+ +--+ +--+

+--+ +--+ +--+
|  | |##| |  |
+--+ +--+ +--+
|  | |  | |  |
+--+ +--+ +--+

+--+ +--+ +--+
|  | |  | |##|
+--+ +--+ +--+
|  | |  | |  |
+--+ +--+ +--+

この場合、各主対角線要素が+1で、他のすべてがゼロであるため、回転行列は単位行列です。
視覚的な明確さを高めるために、負のパラメータは正のパラメータとは異なる色でシェーディングできます。

QUATERNIONS

Q47. クォータニオンとは何ですか?

クォータニオンは、3次元の回転の概念を4次元の回転に拡張します。これにより、「ジンバルロック」の問題が回避され、スムーズで連続的な回転の実装が可能になります。
実際には、球面座標にさらに回転角度を追加すると見なすことができます。つまり、経度、緯度、および回転角度です。クォータニオンは、4つの浮動小数点値|x y z w|を使用して定義されます。
これらは、回転軸の3つの座標と回転角度の組み合わせから計算されます。

Q48. クォータニオンは3Dアニメーションとどのように関係しますか?

前述のように、オイラー角には「ジンバルロック」にかかりやすいという欠点があります。これは、回転の順序によって、オブジェクトを回転させようとしても期待どおりに表示されない場合があるという問題です。

クォータニオンはこの問題の解決策です。クォータニオンは、オブジェクトを連続的な回転のシリーズで回転させる代わりに、プログラマが任意の回転軸と角度でオブジェクトを回転させることができます。

回転は依然として行列数学を使用して実行されます。ただし、行列を乗算する代わりに、軸の回転を表すクォータニオンが乗算されます。最終的な結果のクォータニオンは、目的の回転行列に変換されます。
回転軸は単位方向ベクトルとして指定されるため、ベクトル数学または球面座標(つまり(経度/緯度))から計算することもできます。
クォータニオンは、補間できるという別の利点を提供します。
これにより、スムーズで予測可能な回転効果が可能になります。

Q49. クォータニオンの共役をどのように計算しますか?

これは、クォータニオンのベクトル部分の極性を反転させる(または否定する)ことによって達成できます。

Qr =  ( Qr.scalar, -Qr.vector )

quaternion_conjugate( QUAT *qr, QUAT *qa )
{
qr -> qw = qa -> qw;
qr -> qx = -qa -> qx;
qr -> qy = -qa -> qy;
qr -> qz = -qa -> qz;
}

Q50. クォータニオンの逆行列をどのように計算しますか?

クォータニオンが正規化されている(または単位クォータニオン)場合、これはクォータニオンの共役を計算することと同等です。
それ以外の場合、逆行列の大きさは1/|q|です。
Q49を参照:クォータニオンの共役をどのように計算しますか?

Q51. クォータニオンの大きさをどのように計算しますか?

クォータニオンの大きさは、クォータニオンをその共役で乗算することによって計算されます。
------------
/ --
|Qr| = \ Qr.Qr
これは、次のコードシーケンスとして実装できます。

QFLOAT quaternion_magnitude( QUAT qa )
{
return( sqrt(qa->qw
qa->qw+
qa->qxqa->qx+ qa->qyqa->qy+qa->qz*qa->qz) )
}

Q52. クォータニオンを正規化するにはどうすればよいですか?

クォータニオンは、ベクトルと同様の方法で正規化できます。まずクォータニオンの大きさを計算します。次に、クォータニオンのスカラー部分とベクトル部分の両方をこの値で割ります。
単位クォータニオンの大きさは常に1.0になります。

Q53. 2つのクォータニオンをどのように乗算しますか?

2つのクォータニオンQ1とQ2が与えられた場合、目的は結合された回転Qrを計算することです。

Qr = Q1.Q2

これは次の式で達成されます。

Qr = Q1.Q2 = ( w1.w2 - v1.v2, w1.v2 + w2.v1 + v1 x v2 )

ここで、v1 = Q1の(x,y,z)
w1 = Q1の(w)
v2 = Q2の(x,y,z)
w2 = Q2の(w)

そして、.とxは標準のベクトル内積と外積です。
これは次のコードセグメントを使用して実装できます。

quaternion_multiply( QUAT *qr, QUAT *qa, QUAT *qb )
{
qr.scalar = qa->scalar * qb->scalar - v3_dot( &qa->vector, &qb->vector );
v3_cross( &va, &qa->vector, &qb->vector );
v3_scalef( &vb, &qa->vector, &qb->scalar );
v3_scalef( &vc, &qb->vector, &qa->scalar );
v3_add( &va, &va, &vb );
v3_add( &qr->vector, &va, &vc );
quaternion_normalise( qr );
}


次の最適化も可能です。
w = w1w2 - x1x2 - y1y2 - z1z2
x = w1x2 + x1w2 + y1z2 - z1y2
y = w1y2 + y1w2 + z1x2 - x1z2
z = w1z2 + z1w2 + x1y2 - y1x2

Q54. クォータニオンから回転行列をどのように変換しますか?

クォータニオンが次の形式で作成されたと仮定します。

Q = |X Y Z W|

次に、クォータニオンは次の式を使用して4x4回転行列に変換できます(警告:OpenGLの順序に従う場合/従わない場合、この行列を転置する必要があるかもしれません)。

     �        2     2                                      �
     � 1 - (2Y  + 2Z )   2XY + 2ZW         2XZ - 2YW       �
     �                                                     �
     �                          2     2                    �
 M = � 2XY - 2ZW         1 - (2X  + 2Z )   2YZ + 2XW       �
     �                                                     �
     �                                            2     2  �
     � 2XZ + 2YW         2YZ - 2XW         1 - (2X  + 2Y ) �
     �                                                     �

4x4行列が必要な場合、下部の行と右端の列を追加できます。
行列は次の式を使用して生成できます。

xx      = X * X;
xy      = X * Y;
xz      = X * Z;
xw      = X * W;
yy      = Y * Y;
yz      = Y * Z;
yw      = Y * W;
zz      = Z * Z;
zw      = Z * W;
mat[0]  = 1 - 2 * ( yy + zz );
mat[1]  =     2 * ( xy - zw );
mat[2]  =     2 * ( xz + yw );
mat[4]  =     2 * ( xy + zw );
mat[5]  = 1 - 2 * ( xx + zz );
mat[6]  =     2 * ( yz - xw );
mat[8]  =     2 * ( xz - yw );
mat[9]  =     2 * ( yz + xw );
mat[10] = 1 - 2 * ( xx + yy );
mat[3]  = mat[7] = mat[11] = mat[12] = mat[13] = mat[14] = 0;
mat[15] = 1;

結果の行列は次の位置を使用します。

  � mat[0]  mat[4] mat[ 8] mat[12] �

M = � mat[1] mat[5] mat[ 9] mat[13] �
� mat[2] mat[6] mat[10] mat[14] �
� mat[3] mat[7] mat[11] mat[15] �

Q55. 回転行列からクォータニオンをどのように変換しますか?

回転は、次のアルゴリズムを使用してクォータニオンに変換できます。
プロセスは次のステージで実行されます。

行列のトレースTを次の式から計算します。

            2     2     2
  T = 4 - 4x  - 4y  - 4z

             2    2    2
    = 4( 1 -x  - y  - z )

    = 1 + mat[0] + mat[5] + mat[10]


トレースがゼロより大きい場合、
「インスタント」計算を実行します。
丸め誤差に関する重要な注意:

大きな歪みを避けるために、( T > 0.00000001 ) をテストしてください!

  S = sqrt(T) * 2;
  X = ( mat[9] - mat[6] ) / S;
  Y = ( mat[2] - mat[8] ) / S;
  Z = ( mat[4] - mat[1] ) / S;
  W = 0.25 * S;

トレースがゼロに等しい場合、最大の値を持ち、どの主対角線要素かを特定します。
これに応じて、次のように計算します。

if ( mat[0] > mat[5] && mat[0] > mat[10] )  { // 列 0:
    S  = sqrt( 1.0 + mat[0] - mat[5] - mat[10] ) * 2;
    X = 0.25 * S;
    Y = (mat[4] + mat[1] ) / S;
    Z = (mat[2] + mat[8] ) / S;
    W = (mat[9] - mat[6] ) / S;
} else if ( mat[5] > mat[10] ) { // 列 1:
    S  = sqrt( 1.0 + mat[5] - mat[0] - mat[10] ) * 2;
    X = (mat[4] + mat[1] ) / S;
    Y = 0.25 * S;
    Z = (mat[9] + mat[6] ) / S;
    W = (mat[2] - mat[8] ) / S;
} else { // 列 2:
    S  = sqrt( 1.0 + mat[10] - mat[0] - mat[5] ) * 2;
    X = (mat[2] + mat[8] ) / S;
    Y = (mat[9] + mat[6] ) / S;
    Z = 0.25 * S;
    W = (mat[4] - mat[1] ) / S;
}

 クォータニオンは次のように定義されます。
   Q = | X Y Z W |

Q56. 回転軸と角度からクォータニオンをどのように変換しますか?

回転軸と角度が与えられた場合、次のアルゴリズムを使用してクォータニオンを生成できます。

vector_normalize(axis);
sin_a = sin( angle / 2 );
cos_a = cos( angle / 2 );
X    = axis -> x * sin_a;
Y    = axis -> y * sin_a;
Z    = axis -> z * sin_a;
W    = cos_a;

値がゼロに非常に近い場合があるため、クォータニオンを正規化する必要があります。

Q57. クォータニオンから回転軸と角度をどのように変換しますか?

クォータニオンは、次のアルゴリズムを使用して回転軸と角度に変換できます。

quaternion_normalise( |X,Y,Z,W| );
cos_a = W;
angle = acos( cos_a ) * 2;
sin_a = sqrt( 1.0 - cos_a * cos_a );
if ( fabs( sin_a ) < 0.0005 ) sin_a = 1;
axis -> x = X / sin_a;
axis -> y = Y / sin_a;
axis -> z = Z / sin_a;

Q58. 球面回転角からクォータニオンをどのように変換しますか?

回転軸自体は、球面座標(緯度と経度)と回転角度を使用して定義できます。
この場合、クォータニオンは次のように計算できます。

sin_a    = sin( angle / 2 )
cos_a    = cos( angle / 2 )
sin_lat  = sin( latitude )
cos_lat  = cos( latitude )
sin_long = sin( longitude )
cos_long = cos( longitude )
X       = sin_a * cos_lat * sin_long
Y       = sin_a * sin_lat
Z       = sin_a * sin_lat * cos_long
W       = cos_a

警告:このコードには問題がある可能性があります。
代替案は、[Q60: オイラー回転角からクォータニオンをどのように変換しますか?] で提供されているコードスニペットです。

Q59. クォータニオンから球面回転角をどのように変換しますか?

クォータニオンは、変換プロセスを拡張することによって球面座標に変換できます。

cos_a  = W;
sin_a  = sqrt( 1.0 - cos_a * cos_a );
angle  = acos( cos_a ) * 2;
if ( fabs( sin_angle ) < 0.0005 ) sin_a = 1;
tx = X / sin_a;
ty = Y / sin_a;
tz = Z / sin_a;
latitude = -asin( ty );
if ( tx * tx + tz * tz < 0.0005 )
  longitude   = 0;
else
   longitude  = atan2( tx, tz );
if ( longitude < 0 )
  longitude += 360.0;

警告:このコードにはまだ問題がある可能性があります。
それが何であるか、そしてそれをどのように修正するかを教えてください。

Q60. オイラー回転角からクォータニオンをどのように変換しますか?

オイラー回転角からクォータニオンへの変換は、クォータニオン乗算を使用して達成できます。各回転角度は、軸がユークリッド軸のいずれかに対応する軸角度ペアに変換されます。軸角度ペアはクォータニオンに変換され、乗算されます。最終的なクォータニオンが目的の結果です。

次のコードセグメントがこれを実証しています。

quaternion_from_euler( QUATERNION *q, VFLOAT ax, VFLOAT ay, VFLOAT az )
{
VECTOR3 vx = { 1, 0, 0 }, vy = { 0, 1, 0 }, vz = { 0, 0, 1 };
QUATERNION qx, qy, qz, qt;
quaternion_from_axisangle( qx, &vx, rx );
quaternion_from_axisangle( qy, &vy, ry );
quaternion_from_axisangle( qz, &vz, rz );
quaternion_multiply( &qt, &qx, &qy );
quaternion_multiply( &q, &qt, &qz );
}

次のものは、ほぼ次のソースからのものです。
http://vered.rose.utoronto.ca/people/david_dir/GEMS/GEMS.html

//ピッチ->X軸、ヨウ->Y軸、ロール->Z軸
Quaternion::Quaternion(float fPitch, float fYaw, float fRoll)
{
const float fSinPitch(sin(fPitch0.5F));
const float fCosPitch(cos(fPitch
0.5F));
const float fSinYaw(sin(fYaw0.5F));
const float fCosYaw(cos(fYaw
0.5F));
const float fSinRoll(sin(fRoll0.5F));
const float fCosRoll(cos(fRoll
0.5F));
const float fCosPitchCosYaw(fCosPitchfCosYaw);
const float fSinPitchSinYaw(fSinPitch
fSinYaw);
X = fSinRoll * fCosPitchCosYaw - fCosRoll * fSinPitchSinYaw;
Y = fCosRoll * fSinPitch * fCosYaw + fSinRoll * fCosPitch * fSinYaw;
Z = fCosRoll * fCosPitch * fSinYaw - fSinRoll * fSinPitch * fCosYaw;
W = fCosRoll * fCosPitchCosYaw + fSinRoll * fSinPitchSinYaw;
}

次のものも機能するかもしれません。
QUATERNION qx = { cos(pitch/2f), sin(pitch/2f), 0, 0 }
QUATERNION qy = { cos(yaw/2f), 0, sin(yaw/2f), 0 }
QUATERNION qz = { cos(roll/2f), 0, 0, sin(roll/2f) }
quaternion_multiply( &qt, &qx, &qy );
quaternion_multiply( &q, &qt, &qz );

Javaでは次のようになります。

public static void setQ( Quat4f q, float pitch, float yaw, float roll )
{
Quat4f qx = new Quat4f((float) Math.cos(pitch/2f),
(float) Math.sin(pitch/2f), 0, 0);
Quat4f qy = new Quat4f((float) Math.cos(yaw/2f), 0,
(float) Math.sin(yaw/2f),0);
Quat4f qz = new Quat4f((float) Math.cos(roll/2f), 0, 0,
(float) Math.sin(roll/2f) );
Quat4f qt = new Quat4f();
qt.set( qx );
qt.mul( qy );
qt.mul( qz );
q.set( qt );
}

Q61. クォータニオンを用いて行列間で線形補間を実行するにはどうすればよいですか?

多くのアプリケーションでは、オブジェクトの2つの回転位置間で補間を実行する必要があります。これらの位置は、キーフレームアニメーションまたは逆運動学を使用して指定されている場合があります。
いずれの方法を使用しても、少なくとも2つの回転行列を知っている必要があり、目的はそれらの間で補間することです。2つの行列は、開始行列と終了行列(MSとMF)と呼ばれます。
線形補間を使用して、補間された回転行列は、Tを0.0から1.0まで変化するパラメータを使用したブレンディング方程式を使用して生成されます。

T=0の場合、補間された行列は開始行列と等しくなります。
T=1の場合、補間された行列は終了行列と等しくなります。
次に、補間された回転行列(MI)は次のように指定されます。

MI = F( MS, MF, T )

ここでFはブレンディング関数です。
2つの行列間の補間を行う最初のステップは、MSをMFに変換する回転行列を決定することです。
これは次の式を使用して達成されます。

      -1
T = Ms  . Mf

ここでMsは開始行列、
Mfは終了行列、
そしてTは中間行列です。

次のステップは、この行列を回転軸と角度に変換することです。これは、行列をクォータニオンに変換し、最終的に必要な回転軸と角度に変換することによって達成されます。
補間された回転行列を生成するために、回転角度をスケーリングし、この角度と回転軸を回転行列に戻すだけで十分です。

4x4行列ライブラリを使用すると、次のようになります。

m4_transpose(    mt, ms );                /* 逆行列 */
m4_mult(         ms, mt, mb );            /* 回転行列 */
m4_to_axisangle( ms, axis, angle );       /* 回転軸/角度 */
for ( t = 0; t < 1.0; t += 0.05 )
  {
  m4_from_axisangle( mi, axis, angle * t ); /* 最終補間 */
  ... whatever ...
  }

ここでtは0.0から1.0までの補間係数です。

Q62. クォータニオンを用いて行列間で立方体補間を実行するにはどうすればよいですか?

一部のアプリケーションでは、アニメーション目的で線形補間を使用することが便利または可能でない場合があります。この場合、立方体補間は別の代替手段です。
立方体補間を使用するには、少なくとも4つの回転行列を知っている必要があります。

これらのそれぞれは、クォータニオンと球面回転角(つまり経度、緯度、回転角度)を介して球面回転のセットに変換されます。

次に、これらはCardinalスプライン曲線のベース行列で乗算されます。この補間行列を使用して、中間球面回転角を決定できます。
補間された座標(緯度、経度、回転角度)がわかったら、クォータニオンへの変換を通じて補間された回転行列を生成できます。

4x4行列ライブラリを使用すると、アルゴリズムは次のようになります。

for ( n = 0; n < 4; n++ )
  m4_to_spherical( mat[n], &v_sph[n] );   /* 球面座標 */
m4_multspline( m_cardinal, v_sph, v_interp ); /* 補間ベクトル */
...
v3_cubic( v_pos, v_interp, t );           /* 補間 */
m4_from_spherical( m_rot, v_pos );        /* 行列に戻す */

Q63. クォータニオンを用いてベクトルを回転させるにはどうすればよいですか?

クォータニオンを直接使用してベクトルを回転させる非常にエレガントな方法は次のとおりです(qrは回転クォータニオン)。

                   -1
   v' = qr * v * qr

これは簡単に実現でき、回転行列を使用した変換よりもおそらく高速です。