web-dev-qa-db-ja.com

3Dベクトルの回転？

Pythonリストと角度として2つのベクトルがあります。例：

v = [3,5,0]
axis = [4,4,1]
theta = 1.2 #radian

軸の周りにvベクトルを回転させるときに、結果のベクトルを取得する最良/最も簡単な方法は何ですか？

回転は、軸ベクトルが指している観測者にとっては反時計回りに見えるはずです。これは 右手規則 と呼ばれます

pythonvectorrotation
61
Mads Skjern

http://vpython.org/contents/docs/visual/VisualIntro.html をご覧ください。

メソッドA.rotate(theta,B)を持つvectorクラスを提供します。 Aでメソッドを呼び出したくない場合は、ヘルパー関数rotate(A,theta,B)も提供します。

http://vpython.org/contents/docs/visual/vector.html

12
agf

Euler-Rodrigues式 の使用：

import numpy as np
import math

def rotation_matrix(axis, theta):
    """
    Return the rotation matrix associated with counterclockwise rotation about
    the given axis by theta radians.
    """
    axis = np.asarray(axis)
    axis = axis / math.sqrt(np.dot(axis, axis))
    a = math.cos(theta / 2.0)
    b, c, d = -axis * math.sin(theta / 2.0)
    aa, bb, cc, dd = a * a, b * b, c * c, d * d
    bc, ad, ac, ab, bd, cd = b * c, a * d, a * c, a * b, b * d, c * d
    return np.array([[aa + bb - cc - dd, 2 * (bc + ad), 2 * (bd - ac)],
                     [2 * (bc - ad), aa + cc - bb - dd, 2 * (cd + ab)],
                     [2 * (bd + ac), 2 * (cd - ab), aa + dd - bb - cc]])

v = [3, 5, 0]
axis = [4, 4, 1]
theta = 1.2 

print(np.dot(rotation_matrix(axis, theta), v)) 
# [ 2.74911638  4.77180932  1.91629719]
100
unutbu

Numpy/scipy関数を備えたワンライナー。

以下を使用します。

aをaxisに沿った単位ベクトル、つまりa = axis/norm（axis）
andA = I×aは、a、すなわちaとの単位行列の外積

M = exp（θA）は回転行列です。

_from numpy import cross, eye, dot
from scipy.linalg import expm, norm

def M(axis, theta):
    return expm(cross(eye(3), axis/norm(axis)*theta))

v, axis, theta = [3,5,0], [4,4,1], 1.2
M0 = M(axis, theta)

print(dot(M0,v))
# [ 2.74911638  4.77180932  1.91629719]
_

expm（ここにコード） 指数関数のテイラー級数を計算します：
\sum_{k=0}^{20} \frac{1}{k!} (θ A)^kなので、時間はかかりますが、読みやすく安全です。回転数が少なく、ベクトルが多い場合に便利です。

44
B. M.

速度が必要な場合、unutbuのコードをscipyのweave.inlineでラップし、既存の行列をパラメーターとして渡すと、実行時間が20倍短縮されることに言及したかっただけです。

コード（rotation_matrix_test.py内）：

import numpy as np
import timeit

from math import cos, sin, sqrt
import numpy.random as nr

from scipy import weave

def rotation_matrix_weave(axis, theta, mat = None):
    if mat == None:
        mat = np.eye(3,3)

    support = "#include <math.h>"
    code = """
        double x = sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
        double a = cos(theta / 2.0);
        double b = -(axis[0] / x) * sin(theta / 2.0);
        double c = -(axis[1] / x) * sin(theta / 2.0);
        double d = -(axis[2] / x) * sin(theta / 2.0);

        mat[0] = a*a + b*b - c*c - d*d;
        mat[1] = 2 * (b*c - a*d);
        mat[2] = 2 * (b*d + a*c);

        mat[3*1 + 0] = 2*(b*c+a*d);
        mat[3*1 + 1] = a*a+c*c-b*b-d*d;
        mat[3*1 + 2] = 2*(c*d-a*b);

        mat[3*2 + 0] = 2*(b*d-a*c);
        mat[3*2 + 1] = 2*(c*d+a*b);
        mat[3*2 + 2] = a*a+d*d-b*b-c*c;
    """

    weave.inline(code, ['axis', 'theta', 'mat'], support_code = support, libraries = ['m'])

    return mat

def rotation_matrix_numpy(axis, theta):
    mat = np.eye(3,3)
    axis = axis/sqrt(np.dot(axis, axis))
    a = cos(theta/2.)
    b, c, d = -axis*sin(theta/2.)

    return np.array([[a*a+b*b-c*c-d*d, 2*(b*c-a*d), 2*(b*d+a*c)],
                  [2*(b*c+a*d), a*a+c*c-b*b-d*d, 2*(c*d-a*b)],
                  [2*(b*d-a*c), 2*(c*d+a*b), a*a+d*d-b*b-c*c]])

タイミング：

>>> import timeit
>>> 
>>> setup = """
... import numpy as np
... import numpy.random as nr
... 
... from rotation_matrix_test import rotation_matrix_weave
... from rotation_matrix_test import rotation_matrix_numpy
... 
... mat1 = np.eye(3,3)
... theta = nr.random()
... axis = nr.random(3)
... """
>>> 
>>> timeit.repeat("rotation_matrix_weave(axis, theta, mat1)", setup=setup, number=100000)
[0.36641597747802734, 0.34883809089660645, 0.3459300994873047]
>>> timeit.repeat("rotation_matrix_numpy(axis, theta)", setup=setup, number=100000)
[7.180983066558838, 7.172032117843628, 7.180462837219238]
20
juniper-

これは非常に高速な四元数を使用したエレガントな方法です。適切にベクトル化されたnumpy配列を使用して、1秒あたり1,000万回転を計算できます。 numpyの四元数拡張に依存します here 。

クォータニオン理論：クォータニオンは、通常_q = w + xi + yj + zk_として記述される1つの実次元と3つの虚次元を持つ数値です。ここで、「i」、「j」、「k」は虚次元です。単位複素数「c」がc=exp(i * theta)ですべての2d回転を表すことができるように、単位四元数「q」はq=exp(p)ですべての3d回転を表すことができます。軸と角度によって設定された仮想四元数。

まず、軸と角度をクォータニオンに変換します。クォータニオンの仮想次元は回転軸によって与えられ、大きさは回転角度の半分（ラジアン）によって与えられます。 4つの要素ベクトル_(w, x, y, z)_は、次のように構築されます。

_import numpy as np
import quaternion as quat

v = [3,5,0]
axis = [4,4,1]
theta = 1.2 #radian

vector = np.array([0.] + v)
rot_axis = np.array([0.] + axis)
axis_angle = (theta*0.5) * rot_axis/np.linalg.norm(rot_axis)
_

最初に、4つの要素のnumpy配列が、回転するベクトルvectorと回転軸_rot_axis_の両方に対して実数成分w = 0で構築されます。軸の角度表現は、正規化してから目的の角度thetaの半分を掛けることで作成されます。角度の半分が必要な理由については、 こちら をご覧ください。

次に、ライブラリを使用してクォータニオンvおよびqlogを作成し、指数関数を使用して単位回転クォータニオンqを取得します。

_vec = quat.quaternion(*v)
qlog = quat.quaternion(*axis_angle)
q = np.exp(qlog)
_

最後に、ベクトルの回転は次の操作によって計算されます。

_v_prime = q * vec * np.conjugate(q)

print(v_prime) # quaternion(0.0, 2.7491163, 4.7718093, 1.9162971)
_

ここで、実際の要素を破棄するだけで、回転したベクトルが得られます！

_v_prime_vec = v_prime.imag # [2.74911638 4.77180932 1.91629719] as a numpy array
_

四元数の積はq = q1 * q2 * q3 * q4 * ... * qnとして計算できるので、ベクトルを回転させるだけなので、この方法は多くの連続回転でベクトルを回転させる必要がある場合に特に効率的であることに注意してくださいv '= q * v * conj（q）を使用して、最後に' q 'で。

このメソッドは、単純にexp関数とlog関数（はいlog(q)は軸角度表現を返すだけで、軸角度<---> 3D回転演算子間のシームレスな変換を提供します！）。四元数の乗算などの仕組みの詳細については、 here を参照してください

14
henneray

Python {2,3}用の3D数学のかなり完全なライブラリを作成しました。 Cythonはまだ使用していませんが、numpyの効率に大きく依存しています。ここでpipで見つけることができます：

python[3] -m pip install math3d

または、私のgitwebをご覧ください http://git.automatics.dyndns.dk/?p=pymath3d.git そして今githubでも： https://github.com/ mortlind/pymath3d 。

インストールすると、pythonで、ベクトルを回転できる、または変換オブジェクトの一部となる方向オブジェクトを作成できます。たとえば、次のコードスニペットは、軸を中心に1 radの回転を表す方向を構成します[1,2,3]、それをベクトル[4,5,6]に適用し、結果を出力します：

import math3d as m3d
r = m3d.Orientation.new_axis_angle([1,2,3], 1)
v = m3d.Vector(4,5,6)
print(r * v)

出力は次のようになります

<Vector: (2.53727, 6.15234, 5.71935)>

これは、上記のB. M.によって投稿されたscipyを使用するonelinerよりも、時間の範囲内で約4倍の効率です。ただし、math3dパッケージのインストールが必要です。

6
Morten Lind

免責事項：私はこのパッケージの著者です

回転のための特別なクラスは便利ですが、場合によっては回転マトリックスが必要になることがあります（たとえば、scipyのaffine_transform関数のような他のライブラリを操作するため）。誰もが独自の小さなマトリックス生成関数を実装するのを避けるために、便利な回転マトリックス生成関数を提供する以上のことをしない小さな純粋なpythonパッケージがあります。パッケージはgithub（ mgen ）そしてpip経由でインストールできます：

pip install mgen

Readmeからコピーした使用例：

import numpy as np
np.set_printoptions(suppress=True)

from mgen import rotation_around_axis
from mgen import rotation_from_angles
from mgen import rotation_around_x

matrix = rotation_from_angles([np.pi/2, 0, 0], 'XYX')
matrix.dot([0, 1, 0])
# array([0., 0., 1.])

matrix = rotation_around_axis([1, 0, 0], np.pi/2)
matrix.dot([0, 1, 0])
# array([0., 0., 1.])

matrix = rotation_around_x(np.pi/2)
matrix.dot([0, 1, 0])
# array([0., 0., 1.])

行列は通常のnumpy配列であるため、このパッケージを使用するときに新しいデータ構造が導入されないことに注意してください。

2
NOhs

四元数理論を使用して解決することもできます。

def angle_axis_quat(theta, axis):
    """
    Given an angle and an axis, it returns a quaternion.
    """
    axis = np.array(axis) / np.linalg.norm(axis)
    return np.append([np.cos(theta/2)],np.sin(theta/2) * axis)

def mult_quat(q1, q2):
    """
    Quaternion multiplication.
    """
    q3 = np.copy(q1)
    q3[0] = q1[0]*q2[0] - q1[1]*q2[1] - q1[2]*q2[2] - q1[3]*q2[3]
    q3[1] = q1[0]*q2[1] + q1[1]*q2[0] + q1[2]*q2[3] - q1[3]*q2[2]
    q3[2] = q1[0]*q2[2] - q1[1]*q2[3] + q1[2]*q2[0] + q1[3]*q2[1]
    q3[3] = q1[0]*q2[3] + q1[1]*q2[2] - q1[2]*q2[1] + q1[3]*q2[0]
    return q3

def rotate_quat(quat, vect):
    """
    Rotate a vector with the rotation defined by a quaternion.
    """
    # Transfrom vect into an quaternion 
    vect = np.append([0],vect)
    # Normalize it
    norm_vect = np.linalg.norm(vect)
    vect = vect/norm_vect
    # Computes the conjugate of quat
    quat_ = np.append(quat[0],-quat[1:])
    # The result is given by: quat * vect * quat_
    res = mult_quat(quat, mult_quat(vect,quat_)) * norm_vect
    return res[1:]

v = [3, 5, 0]
axis = [4, 4, 1]
theta = 1.2 

print(rotate_quat(angle_axis_quat(theta, axis), v))
# [2.74911638 4.77180932 1.91629719]
1
Guillaume Mougeot

Pyquaternionの使用は非常に簡単です。 （まだPythonで）インストールするには、コンソールで実行します：

import pip;
pip.main(['install','pyquaternion'])

インストールしたら：

  from pyquaternion import Quaternion
  v = [3,5,0]
  axis = [4,4,1]
  theta = 1.2 #radian
  rotated_v = Quaternion(axis=axis,angle=theta).rotate(v)
1
Dr.PP

そのモデルが埋め込まれた3つの軸{x、y、z}の1つを中心に3Dモデルを回転する必要があり、これがnumpyでこれを行う方法の検索のトップの結果でした。次の単純な関数を使用しました。

def rotate(X, theta, axis='x'):
  '''Rotate multidimensional array `X` `theta` degrees around axis `axis`'''
  c, s = np.cos(theta), np.sin(theta)
  if axis == 'x': return np.dot(X, np.array([
    [1.,  0,  0],
    [0 ,  c, -s],
    [0 ,  s,  c]
  ]))
  Elif axis == 'y': return np.dot(X, np.array([
    [c,  0,  -s],
    [0,  1,   0],
    [s,  0,   c]
  ]))
  Elif axis == 'z': return np.dot(X, np.array([
    [c, -s,  0 ],
    [s,  c,  0 ],
    [0,  0,  1.],
  ]))
0
duhaime

Scipyの Rotation.from_rotvec() を使用します。引数は、回転ベクトル（単位ベクトル）にラジアン単位の回転角度を掛けたものです。

from scipy.spatial.transform import Rotation
from numpy.linalg import norm


v = [3, 5, 0]
axis = [4, 4, 1]
theta = 1.2

axis = axis / norm(axis)  # normalize the rotation vector first
rot = Rotation.from_rotvec(theta * axis)

new_v = rot.apply(v)  
print(new_v)    # results in [2.74911638 4.77180932 1.91629719]

Rotation を使用する他の方法がいくつかあります。これは、ローテーションに関するデータに基づいています。

  • from_quat クォータニオンから初期化。

  • from_dcm 方向余弦行列から初期化されます。

  • from_euler オイラー角から初期化。

トピック外の注意：1行のコードは、not一部のユーザーが暗示しているように、必ずしも優れたコードではありません。

0
Fermi paradox