Springhead
An open source physics engine for virtual reality, haptics and motion generation.
ベクトル・行列・座標変換

モジュール

 Affine行列クラス
 
 ポータブル テンプレート 行列クラスライブラリ
 

ファイル

ファイル  Affine.h
 2/3次元アフィン行列
 
ファイル  TinyMat.h
 2x2, 3x3行列の定義
 
ファイル  TinyVec.h
 2,3,4次元のベクトルの定義
 
ファイル  TMatrix.h
 テンプレートによるN×M行列型の定義.
 
ファイル  TMatrixUtility.h
 行列初期化ユーティリティー.
 
ファイル  TQuaternion.h
 クォータニオンクラスの定義
 
ファイル  TVector.h
 C++ の template 機能を生かしたベクトルライブラリ. メモリと管理情報(ベクトルのサイズなど)の持ち方で3種ある。
 

構成

class  TMatrix2< T >
 2x2行列クラス. [詳細]
 
class  TMatrix3< T >
 3x3行列クラス. [詳細]
 
class  TVecDesc< EXP, T >
 
class  TVec2< T >
 2次元ベクトルクラス [詳細]
 
class  TVec3< T >
 3次元ベクトルクラス. [詳細]
 
class  TVec4< T >
 4次元ベクトルクラス. [詳細]
 
class  TVec6< T >
 6次元ベクトルクラス. [詳細]
 
class  TQuaternion< ET >
 Quaternion/4元数.3x3行列の代わりに回転を表すために使える. 4変数で済む.補間や微分・積分がやりやすい.
TVec3との掛け算は,回転変換でオーバーロードされている. [詳細]
 
class  TPose< ET >
 姿勢.位置と向きを表すクラス. TQuaternionTVec3 で向きと位置を表す. TAffineの代わりに使える. [詳細]
 
class  VectorDesc< EXP, RET, E, Z >
 
class  TVectorDesc< STR, EXP, RET, E, Z >
 
class  VectorImp< D >
 ベクトルの演算などの実装 [詳細]
 
class  TVectorBase< N, D >
 次元をテンプレートで持つベクトルの基本型 [詳細]
 
class  TVectorSlice< SZ, STR, OD >
 
class  TSubVector< SZ, OD >
 
class  EVectorSlice< D >
 
class  ConstEVectorSlice< D >
 
class  TSubVectorDim< SOFF, SDIM >
 部分ベクトル型作成のためのユーティリティークラス. [詳細]
 
class  TVector< N, T >
 ベクトル型. [詳細]
 
class  VVector< T >
 ベクトル型. [詳細]
 
class  ConstEVector< T >
 ベクトル型. [詳細]
 
class  EVector< T >
 

マクロ定義

#define TYPENAME   typename
 
#define DEF_VECTOR_BASIC_MEMBER(THIS)
 ベクトル型派生クラスに必要なメンバの定義. [詳細]
 
#define DEF_TVECTOR_BASIC_MEMBER(THIS)
 

型定義

typedef TMatrix2< float > Matrix2f
 float版2×2行列.
 
typedef TMatrix2< double > Matrix2d
 double版2×2行列.
 
typedef TMatrix3< float > Matrix3f
 float版3×3行列.
 
typedef TMatrix3< double > Matrix3d
 double版3×3行列.
 
typedef TVec2< int > Vec2i
 int版2次元ベクトル
 
typedef TVec2< float > Vec2f
 float版2次元ベクトル
 
typedef TVec2< double > Vec2d
 double版2次元ベクトル
 
typedef TVec3< int > Vec3i
 int版3次元ベクトル
 
typedef TVec3< float > Vec3f
 float版3次元ベクトル
 
typedef TVec3< double > Vec3d
 double版3次元ベクトル
 
typedef TVec4< int > Vec4i
 int版4次元ベクトル
 
typedef TVec4< float > Vec4f
 float版4次元ベクトル
 
typedef TVec4< double > Vec4d
 double版4次元ベクトル
 
typedef TVec6< int > Vec6i
 int版6次元ベクトル
 
typedef TVec6< float > Vec6f
 float版6次元ベクトル
 
typedef TVec6< double > Vec6d
 double版6次元ベクトル
 
typedef TQuaternion< float > Quaternionf
 float版TQuaternion.
 
typedef TQuaternion< double > Quaterniond
 double版TQuaternion.
 
typedef TPose< float > Posef
 float版TPose.
 
typedef TPose< double > Posed
 double版TPose.
 

関数

template<class T >
bool IsUnitary (TMatrix3< T > r)
 
void getAxisMap2D (int &x, int &y, int axis)
 
template<class MD , class AD >
void init_rot (TMatrixBase< 2, 2, MD > &m, const TVectorBase< 2, AD > &a, char axis)
 x/y軸を指定して2×2行列を回転行列に初期化
 
template<class D >
void init_rot (TMatrixBase< 2, 2, D > &m, TYPENAME D::element_type th)
 2×2行列を回転行列に初期化
 
void getAxisMap3D (int &x, int &y, int &z, int axis)
 
template<class MD , class AD , class BD >
void init_rot (TMatrixBase< 3, 3, MD > &m, const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b, char axis)
 axis軸, axis++軸を指定して3×3行列を回転行列に初期化
 
template<class MD >
void init_rot (TMatrixBase< 3, 3, MD > &m, TYPENAME MD::element_type th, char axis)
 3×3行列をx/y/z軸まわり回転行列に初期化
 
template<class MD , class AD >
void init_rot (TMatrixBase< 3, 3, MD > &m, TYPENAME MD::element_type th, const TVectorBase< 3, AD > &axis)
 3×3行列を任意軸まわり回転行列に初期化 [詳細]
 
template<class MD , class QD >
void init_rot (TMatrixBase< 3, 3, MD > &m, const TVectorBase< 4, QD > &q)
 3×3行列をクォータニオンから任意軸まわり回転行列に初期化
 
template<class D >
void init_unitize (TMatrixBase< 2, 2, D > &m)
 2×2行列を単位行列に初期化
 
template<class D >
void init_unitize (TMatrixBase< 3, 3, D > &m)
 3×3行列を単位行列に初期化
 
template<class D >
void init_unitize (TMatrixBase< 4, 4, D > &m)
 4×4行列を単位行列に初期化
 
template<class M >
void init_unitize (MatrixImp< M > &m)
 N×N行列を単位行列に初期化
 
template<class MD , class D >
void init_cross (TMatrixBase< 3, 3, MD > &m, const TVectorBase< 3, D > &v)
 3×3行列をベクトルの外積計算になるように初期化(m*b == v^b).
 
template<class D , class BP , class BT >
void init_look_at (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, BP > &pos, const TVectorBase< 3, BT > &diry)
 4×4行列をある点を注視する視点行列に初期化する.
 
template<class D , class BZ , class BY >
void init_look_at_gl (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, BZ > &pos, const TVectorBase< 3, BY > &diry)
 4×4行列をある点を注視する視点行列に初期化する.
 
template<class D , class SD , class ZD >
void init_projection_gl (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, SD > &screen_, const TVectorBase< 2, ZD > &size_, TYPENAME D::element_type front=1.0f, TYPENAME D::element_type back=10000.0f)
 
template<class D , class SD , class ZD >
void init_projection_d3d (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, SD > &screen_, const TVectorBase< 2, ZD > &size_, TYPENAME D::element_type front=1.0f, TYPENAME D::element_type back=10000.0f)
 
template<class D , class SD , class ZD >
void init_ortho_gl (TMatrixBase< 4, 4, D > &a, const TVectorBase< 3, SD > &screen_, const TVectorBase< 2, ZD > &size_, TYPENAME D::element_type front=1.0f, TYPENAME D::element_type back=10000.0f)
 
template<class QD , class T , class AD >
void init_quaternion (TVectorBase< 4, QD > &q, T angle, const TVectorBase< 3, AD > &axis)
 4行ベクトルを回転をあらわすクォータニオンとして初期化
 
template<class QD , class AD >
void init_quaternion (TVectorBase< 4, QD > &q, const TVectorBase< 3, AD > &rot)
 4行ベクトルを回転をあらわすクォータニオンとして初期化
 
template<class QD , class T >
void init_quaternion (TVectorBase< 4, QD > &q, T angle, char axis)
 4行ベクトルを回転をあらわすクォータニオンとして初期化
 
template<class QD , class MD >
void init_quaternion (TVectorBase< 4, QD > &qt, const TMatrixBase< 3, 3, MD > &m)
 4行ベクトルを回転をあらわすクォータニオンとして初期化
 
template<class A , class B >
TQuaternion< A > operator* (const TQuaternion< A > &q1, const TQuaternion< B > &q2)
 TQuaternion 同士の掛け算.回転変換としては,合成になる.
 
template<class ET , class BD >
TYPENAME BD::ret_type operator* (const TQuaternion< ET > &q, const PTM::TVectorBase< 3, BD > &v)
 TQuaternionでベクトルを回転. Quaternion * vector * Quaternion^{*} と同じ.
 
template<class ET , class BD >
TYPENAME BD::ret_type operator* (const TQuaternion< ET > &q, const PTM::TMatrixBase< 3, 3, BD > &m)
 TQuaternionで行列を回転. TQuaternion * (ex,ey,ez) * TQuaternion.conjugated() と同じ.
 
template<class T1 , class T2 >
T1 dot (const TQuaternion< T1 > &q1, const TQuaternion< T2 > &q2)
 TQuaternion の内積.
 
template<class ET , class BD >
TQuaternion< ET > mult (const TQuaternion< ET > &q, const PTM::TVectorBase< 3, BD > &v)
 回転操作をせず,普通にQuaternionとベクトルの積を求める
 
template<class BD , class ET >
TQuaternion< ET > mult (const PTM::TVectorBase< 3, BD > &v, const TQuaternion< ET > &q)
 回転操作をせず,普通にベクトルとQuaternionの積を求める
 
template<class T1 , class T2 >
TQuaternion< T1 > interpolate (T1 t, const TQuaternion< T1 > &q1, const TQuaternion< T2 > &q2)
 
template<class EP , class EV >
TVec3< EV > operator* (const TPose< EP > &p, const TVec3< EV > &v)
 
template<class EA , class EB >
TPose< EA > operator* (const TPose< EA > &a, const TPose< EB > &b)
 
template<class EA , class EB >
TPose< EA > interpolate (EA t, const TPose< EA > &p0, const TPose< EB > &p1)
 Poseの補間
 
template<class AD , class BD >
TYPENAME AD::ret_type operator+ (const VectorImp< AD > &a, const VectorImp< BD > &b)
 ベクトルの和(return a + b). [詳細]
 
template<class AD , class BD >
TYPENAME AD::ret_type operator- (const VectorImp< AD > &a, const VectorImp< BD > &b)
 ベクトルの差(return a - b). [詳細]
 
template<class BD >
TYPENAME BD::ret_type operator* (const TYPENAME BD::element_type &a, const VectorImp< BD > &b)
 スカラーとベクトルの積(return a * b). [詳細]
 
template<class BD >
TYPENAME BD::ret_type operator* (const VectorImp< BD > &a, const TYPENAME BD::element_type &b)
 スカラーとベクトルの積(return a * b). [詳細]
 
template<class AD , class BD >
AD::element_type operator* (const VectorImp< AD > &a, const VectorImp< BD > &b)
 ベクトルの内積(return a * b). [詳細]
 
template<class AD , class BD >
bool operator== (const VectorImp< AD > &a, const VectorImp< BD > &b)
 比較(return a == b). [詳細]
 
template<class AD , class BD >
bool operator!= (const VectorImp< AD > &a, const VectorImp< BD > &b)
 比較(return a != b). [詳細]
 
template<class BD >
std::ostream & operator<< (std::ostream &os, const VectorImp< BD > &v)
 ストリームに書式付で出力する.
 
template<class BD >
std::istream & operator>> (std::istream &is, VectorImp< BD > &v)
 ストリームから書式付で入力する.
 
template<class AD , class BD >
AD::element_type cross (const TVectorBase< 2, AD > &a, const TVectorBase< 2, BD > &b)
 2次元ベクトルの外積(return a x b). [詳細]
 
template<class AD , class BD >
AD::element_type operator% (const TVectorBase< 2, AD > &a, const TVectorBase< 2, BD > &b)
 
template<class AD , class BD >
AD::element_type operator^ (const TVectorBase< 2, AD > &a, const TVectorBase< 2, BD > &b)
 
template<class AD , class BD >
TYPENAME AD::ret_type cross (const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)
 3次元ベクトルの外積(return a x b). [詳細]
 
template<class AD , class BD >
TYPENAME AD::ret_type operator% (const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)
 
template<class AD , class BD >
TYPENAME AD::ret_type operator^ (const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)
 
template<class AD , class BD >
TYPENAME AD::ret_type interpolate (TYPENAME AD::element_type &t, const VectorImp< AD > &a, const VectorImp< BD > &b)
 補間 [詳細]
 

演算.

template<class D >
void clear (VectorImp< D > &a, const TYPENAME D::element_type v=D::zero(0))
 ベクトルの要素を全てvにする. [詳細]
 
template<class AD , class BD >
void assign (VectorImp< AD > &a, const VectorImp< BD > &b)
 代入(a = b). [詳細]
 
template<class AD , class BD >
void assign (TVectorBase< 2, AD > &a, const TVectorBase< 2, BD > &b)
 代入(a = b) 2要素専用
 
template<class AD , class BD >
void assign (TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)
 代入(a = b) 3要素専用
 
template<class AD , class BD >
void assign (TVectorBase< 4, AD > &a, const TVectorBase< 4, BD > &b)
 代入(a = b) 4要素専用
 
template<class AD >
void assign (VectorImp< AD > &a, const TYPENAME AD::element_type *b)
 代入(a = b). [詳細]
 
template<class AD , class BD >
void add (VectorImp< AD > &a, const VectorImp< BD > &b)
 加算(a += b). [詳細]
 
template<class AD , class BD >
void sub (VectorImp< AD > &a, const VectorImp< BD > &b)
 減算(a -= b). [詳細]
 
template<class AD >
void multi (VectorImp< AD > &a, const TYPENAME AD::element_type &b)
 定数倍(*this *= b). [詳細]
 
template<class AD , class BD >
void multi_each (VectorImp< AD > &a, const VectorImp< BD > &b)
 定数倍(*this *= b). [詳細]
 
template<class AD >
void div (VectorImp< AD > &a, const TYPENAME AD::element_type &b)
 定数分の1(*this /= b). [詳細]
 
template<class AD , class BD >
TYPENAME AD::element_type dot (const VectorImp< AD > &a, const VectorImp< BD > &b)
 内積(return *this * b). [詳細]
 
template<class AD , class BD >
TYPENAME AD::element_type dot (const TVectorBase< 3, AD > &a, const TVectorBase< 3, BD > &b)
 
template<class AD , class BD >
bool equal (const VectorImp< AD > &a, const VectorImp< BD > &b)
 比較(return *this == b). [詳細]
 
template<class AD , class BD >
void element_min_impl (VectorImp< AD > &a, const VectorImp< BD > &b)
 要素ごとの最小値(min(*this, b)). [詳細]
 
template<class AD , class BD >
TYPENAME AD::ret_type element_min (const VectorImp< AD > &a, const VectorImp< BD > &b)
 
template<class AD , class BD >
void element_max_impl (VectorImp< AD > &a, const VectorImp< BD > &b)
 要素ごとの最大値(max(*this, b)). [詳細]
 
template<class AD , class BD >
TYPENAME AD::ret_type element_max (const VectorImp< AD > &a, const VectorImp< BD > &b)
 
template<class AD , class BD , class ED >
void clip (const VectorImp< AD > &a, const VectorImp< BD > &b, const VectorImp< ED > &e)
 クリッピングする(bとeを頂点とする矩形内に収まるようにする).
 

説明

マクロ定義

#define DEF_TVECTOR_BASIC_MEMBER (   THIS)
値:
/* ベクトル b による初期化 */ \
template <class D> \
THIS(const PTM::VectorImp<D>& b){ \
this->init_buffer(); this->assign(b);} \
/* 要素数が等しい配列 p による初期化 */ \
THIS(const element_type* p){ \
this->assign(p); \
} \
/* デフォルトコンストラクタ */ \
THIS(){ this->init_buffer(); this->set_default(); } \
ベクトルの演算などの実装
Definition: TVector.h:71
void assign(VectorImp< AD > &a, const VectorImp< BD > &b)
代入(a = b).
Definition: TVector.h:82
#define DEF_VECTOR_BASIC_MEMBER(THIS)
ベクトル型派生クラスに必要なメンバの定義.
Definition: TVector.h:469
#define DEF_VECTOR_BASIC_MEMBER (   THIS)
値:
typedef THIS this_type; /* このクラスの型を定義しておく. */ \
typedef TYPENAME desc::element_type element_type; \
typedef TYPENAME desc::ret_type ret_type; \
/* コピーコンストラクタ */ \
THIS& operator =(const THIS& b){ \
this->exp().assign(b); return *this; \
} \
/* ベクトル b を代入 */ \
template <class D> \
THIS& operator =(const PTM::VectorImp<D>& b){ \
this->exp().assign(b); return *this; \
} \
/* ベクトル b を加算 */ \
template <class D> \
THIS& operator +=(const PTM::VectorImp<D>& b){ \
this->exp().add(b); return *this; \
} \
/* ベクトル b を減算 */ \
template <class D> \
THIS& operator -=(const PTM::VectorImp<D>& b){ \
this->exp().sub(b); return *this; \
} \
/* 要素数が等しい配列 p の代入 */ \
THIS& operator =(const element_type* p){ \
this->exp().assign(p); \
return *this; \
} \
ベクトルの演算などの実装
Definition: TVector.h:71

派生クラスを作るたびに,このマクロを使ってメンバを作る. デフォルトコンストラクタ, 同じサイズのベクトルによる 初期化・代入などが定義される.

引数
THIS新たに宣言する派生クラスの型名.
参照
TVector

関数

void PTM::add ( VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
aベクトル.
b同じサイズのベクトル.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::add().

void PTM::assign ( VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
void PTM::assign ( VectorImp< AD > &  a,
const TYPENAME AD::element_type *  b 
)
引数
aベクトル.
b同じサイズのベクトル.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

void PTM::clear ( VectorImp< D > &  a,
const TYPENAME D::element_type  v = D::zero(0) 
)
AD::element_type PTM::cross ( const TVectorBase< 2, AD > &  a,
const TVectorBase< 2, BD > &  b 
)
引数
a2次元ベクトル型
b2次元ベクトル型
戻り値
要素型

参照元 TQuaternion< float >::RotationArc().

TYPENAME AD::ret_type PTM::cross ( const TVectorBase< 3, AD > &  a,
const TVectorBase< 3, BD > &  b 
)
引数
a3次元ベクトル型
b3次元ベクトル型
戻り値
3次元ベクトル型
void PTM::div ( VectorImp< AD > &  a,
const TYPENAME AD::element_type &  b 
)
TYPENAME AD::element_type PTM::dot ( const VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
inline
引数
b同じサイズのベクトル.
戻り値
内積の値(要素型)

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

void PTM::element_max_impl ( VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
void PTM::element_min_impl ( VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
bool PTM::equal ( const VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
b同じサイズのベクトル.
戻り値
bool値.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::equal().

void PTM::init_rot ( TMatrixBase< 3, 3, MD > &  m,
TYPENAME MD::element_type  th,
const TVectorBase< 3, AD > &  axis 
)
+                                                                      +
|u^2+(1-u^2)cos(th)      uv(1-cos(th))-wsin(th)  wu(1-cos(th))+vsin(th)|

R = |uv(1-cos(th))+wsin(th) v^2+(1-v^2)cos(th) vw(1-cos(th))-usin(th)| |wu(1-cos(th))-vsin(th) vw(1-cos(th))+usin(th) w^2+(1-w^2)cos(th) |

  • +

参照先 VectorImp< D >::item().

TYPENAME AD::ret_type PTM::interpolate ( TYPENAME AD::element_type &  t,
const VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
t補間量0-1
aベクトル
b同じサイズのベクトル

参照先 VectorImp< D >::size().

void PTM::multi ( VectorImp< AD > &  a,
const TYPENAME AD::element_type &  b 
)
void PTM::multi_each ( VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
b要素型.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

bool PTM::operator!= ( const VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
aベクトル型
b要素型aと同じ次元数のベクトル型
戻り値
bool

参照先 VectorImp< D >::equal().

TYPENAME BD::ret_type PTM::operator* ( const TYPENAME BD::element_type &  a,
const VectorImp< BD > &  b 
)
引数
aベクトル型
b要素型
戻り値
ベクトル型
TYPENAME BD::ret_type PTM::operator* ( const VectorImp< BD > &  a,
const TYPENAME BD::element_type &  b 
)

ベクトルとスカラーは可換なため.

引数
a要素型
bベクトル型
戻り値
ベクトル型
AD::element_type PTM::operator* ( const VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
inline
引数
aベクトル型
baと同じ次元数のベクトル型
戻り値
要素型

参照先 VectorImp< D >::dot().

TYPENAME AD::ret_type PTM::operator+ ( const VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
aベクトル型
baと同じ次元数のベクトル型
戻り値
aと同じ次元数のTVector型
TYPENAME AD::ret_type PTM::operator- ( const VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
aベクトル型
baと同じ次元数のベクトル型
戻り値
aと同じ次元数のベクトル型
bool PTM::operator== ( const VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
aベクトル型
b要素型aと同じ次元数のベクトル型
戻り値
bool

参照先 VectorImp< D >::equal().

void PTM::sub ( VectorImp< AD > &  a,
const VectorImp< BD > &  b 
)
引数
aベクトル.
b同じサイズのベクトル.

参照先 VectorImp< D >::item(), と VectorImp< D >::size().

参照元 VectorImp< VectorDesc< ConstEVectorSlice< T >, VVector< T >, T > >::sub().