scipy.spatial.transform.RigidTransform.

apply#

RigidTransform.apply(self, vector, inverse=False)#

Wendet die Transformation auf einen Vektor an.

Wenn der ursprüngliche Bezugsrahmen durch diese Transformation in den Endbezugsrahmen überführt wird, dann kann ihre Anwendung auf einen Vektor auf zwei Arten betrachtet werden:

  • Als Projektion von Vektorkomponenten, die im Endbezugsrahmen ausgedrückt sind, auf den ursprünglichen Bezugsrahmen.

  • Als physikalische Transformation eines Vektors, der an den ursprünglichen Bezugsrahmen gebunden ist, während dieser transformiert wird. In diesem Fall werden die Vektorkomponenten vor und nach der Transformation im ursprünglichen Bezugsrahmen ausgedrückt.

In Bezug auf Rotationsmatrizen und Translationsvektoren ist diese Anwendung identisch mit self.translation + self.rotation.as_matrix() @ vector.

Parameter:
vectorarray_like, Form (N, 3) oder (3,)

Ein einzelner Vektor oder ein Stapel von Vektoren.

inversebool, optional

Wenn True, wird die Umkehrung der Transformation auf den Vektor angewendet.

Rückgabe:
transformed_vectornumpy.ndarray, Form (N, 3) oder (3,)

Der/die transformierte(n) Vektor(en). Die Form hängt von folgenden Fällen ab:

  • Wenn das Objekt eine einzelne Transformation enthält (im Gegensatz zu einem Stapel mit einer einzelnen Transformation) und ein einzelner Vektor mit der Form (3,) angegeben wird, dann hat transformed_vector die Form (3,).

  • In allen anderen Fällen hat transformed_vector die Form (N, 3), wobei N entweder die Anzahl der Transformationen oder der Vektoren ist.

Beispiele

>>> from scipy.spatial.transform import RigidTransform as Tf
>>> from scipy.spatial.transform import Rotation as R
>>> import numpy as np

Wendet eine einzelne Transformation auf einen Vektor an. Hier ist die Transformation nur eine Translation, daher ist das Ergebnis der Vektor, der zum Translationsvektor addiert wird.

>>> t = np.array([1, 2, 3])
>>> tf = Tf.from_translation(t)
>>> t + np.array([1, 0, 0])
array([2, 2, 3])
>>> tf.apply([1, 0, 0])
array([2., 2., 3.])

Wendet eine einzelne Transformation auf einen Stapel von Vektoren an.

>>> tf.apply([[1, 0, 0], [0, 1, 0]])
array([[2., 2., 3.],
       [1., 3., 3.]])

Wendet die Umkehrung einer Transformation auf einen Vektor an, so dass das Ergebnis der negative des Translationsvektors ist, der zum Vektor addiert wird.

>>> -t + np.array([1, 0, 0])
array([0, -2, -3])
>>> tf.apply([1, 0, 0], inverse=True)
array([0., -2., -3.])

Für Transformationen, die nicht nur reine Translationen sind, ist die Anwendung auf einen Vektor dasselbe wie die Anwendung der Rotationskomponente auf den Vektor und anschließendes Hinzufügen der Translation.

>>> r = R.from_euler('z', 60, degrees=True)
>>> tf = Tf.from_components(t, r)
>>> t + r.apply([1, 0, 0])
array([1.5,       2.8660254, 3.       ])
>>> tf.apply([1, 0, 0])
array([1.5,       2.8660254, 3.       ])

Beim Anwenden der Umkehrung einer Transformation ist das Ergebnis der negative des Translationsvektors, der zum Vektor addiert wird, und dann rotiert durch die inverse Rotation.

>>> r.inv().apply(-t + np.array([1, 0, 0]))
array([-1.73205081, -1.        , -3.        ])
>>> tf.apply([1, 0, 0], inverse=True)
array([-1.73205081, -1.        , -3.        ])
Auf dieser Seite