scipy.spatial.transform.Rotation.

from_davenport#

classmethod Rotation.from_davenport(cls, axes, order, angles, degrees=False)#

Initialisierung aus Davenport-Winkeln.

Rotations in 3D können durch eine Sequenz von 3 Rotationen um eine Sequenz von Achsen dargestellt werden.

Die drei Rotationen können entweder in einem globalen Bezugssystem (extrinsisch) oder in einem körperzentrierten Bezugssystem (intrinsisch) erfolgen, das am rotierenden Objekt angebracht ist und sich mit diesem bewegt [1].

Sowohl für Euler-Winkel als auch für Davenport-Winkel müssen aufeinanderfolgende Achsen orthogonal sein (axis2 ist orthogonal zu sowohl axis1 als auch axis3). Bei Euler-Winkeln besteht eine zusätzliche Beziehung zwischen axis1 oder axis3, mit zwei Möglichkeiten:

  • axis1 und axis3 sind ebenfalls orthogonal (asymmetrische Sequenz)

  • axis1 == axis3 (symmetrische Sequenz)

Bei Davenport-Winkeln wird diese letzte Beziehung gelockert [2], und nur die Anforderung orthogonaler aufeinanderfolgender Achsen wird beibehalten.

Parameter:
axesarray_like, Form (3,) oder ([1 oder 2 oder 3], 3)

Rotationsachse, wenn eindimensional. Wenn zweidimensional, beschreibt die Sequenz von Achsen für Rotationen, wobei jede Achse axes[i, :] die i-te Achse ist. Wenn mehr als eine Achse angegeben ist, muss die zweite Achse orthogonal zur ersten und dritten Achse sein.

orderstring

Wenn gleich 'e' oder 'extrinsic', wird die Sequenz als extrinsisch behandelt. Wenn gleich 'i' oder 'intrinsic', wird die Sequenz als intrinsisch behandelt.

anglesfloat oder array_like, Form (N,) oder (N, [1 oder 2 oder 3])

Euler-Winkel, angegeben in Radiant (degrees ist False) oder Grad (degrees ist True). Für eine einzelne Achse können angles sein:

  • ein einzelner Wert

  • array_like mit Form (N,), wobei jeder angle[i] einer einzelnen Rotation entspricht

  • array_like mit Form (N, 1), wobei jeder angle[i, 0] einer einzelnen Rotation entspricht

Für 2 und 3 Achsen können angles sein:

  • array_like mit Form (W,), wobei W die Anzahl der Zeilen von axes ist, was einer einzelnen Rotation mit W Achsen entspricht

  • array_like mit Form (N, W), wobei jedes angle[i] einer Sequenz von Davenport-Winkeln entspricht, die eine einzelne Rotation beschreiben

degreesbool, optional

Wenn True, dann werden die gegebenen Winkel als Grad angenommen. Standard ist False.

Rückgabe:
rotationRotation Instanz

Objekt, das die durch die Sequenz von Rotationen um gegebene Achsen mit gegebenen Winkeln dargestellte Rotation enthält.

Referenzen

[2]

Shuster, Malcolm & Markley, Landis. (2003). Generalization of the Euler Angles. Journal of the Astronautical Sciences. 51. 123-132. 10.1007/BF03546304.

Beispiele

>>> from scipy.spatial.transform import Rotation as R

Davenport-Winkel sind eine Verallgemeinerung der Euler-Winkel, wenn wir die kanonischen Basisachsen verwenden

>>> ex = [1, 0, 0]
>>> ey = [0, 1, 0]
>>> ez = [0, 0, 1]

Initialisiert eine einzelne Rotation mit einer gegebenen Achsenfolge

>>> axes = [ez, ey, ex]
>>> r = R.from_davenport(axes, 'extrinsic', [90, 0, 0], degrees=True)
>>> r.as_quat().shape
(4,)

Entspricht in diesem Fall Euler-Winkeln

>>> r.as_euler('zyx', degrees=True)
array([90.,  0., -0.])

Initialisierung mehrerer Rotationen in einem Objekt

>>> r = R.from_davenport(axes, 'extrinsic', [[90, 45, 30], [35, 45, 90]], degrees=True)
>>> r.as_quat().shape
(2, 4)

Auch die Verwendung von nur einer oder zwei Achsen ist möglich

>>> r = R.from_davenport([ez, ex], 'extrinsic', [[90, 45], [35, 45]], degrees=True)
>>> r.as_quat().shape
(2, 4)

Nicht-kanonische Achsen sind möglich und müssen nicht normalisiert werden, solange aufeinanderfolgende Achsen orthogonal sind

>>> e1 = [2, 0, 0]
>>> e2 = [0, 1, 0]
>>> e3 = [1, 0, 1]
>>> axes = [e1, e2, e3]
>>> r = R.from_davenport(axes, 'extrinsic', [90, 45, 30], degrees=True)
>>> r.as_quat()
[ 0.701057,  0.430459, -0.092296,  0.560986]
Auf dieser Seite