scipy.spatial.transform.RigidTransform.

inv#

RigidTransform.inv(self)#

Kehrt diese Transformation um.

Die Zusammensetzung einer Transformation mit ihrer Umkehrung ergibt eine Identitätstransformation.

Eine starre Transformation ist eine Zusammensetzung einer Rotation und einer Translation, wobei die Rotation zuerst angewendet wird, gefolgt von der Translation. Die umgekehrte Transformation entspricht also der umgekehrten Translation, gefolgt von der umgekehrten Rotation.

Rückgabe:

RigidTransform Instanz: Die Umkehrung dieser Transformation.

Beispiele

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

Eine Transformation, die mit ihrer Umkehrung zusammengesetzt wird, ergibt eine Identitätstransformation.

>>> rng = np.random.default_rng(seed=123)
>>> t = rng.random(3)
>>> r = R.random(rng=rng)
>>> tf = Tf.from_components(t, r)
>>> tf.as_matrix()
array([[-0.45431291,  0.67276178, -0.58394466,  0.68235186],
       [-0.23272031,  0.54310598,  0.80676958,  0.05382102],
       [ 0.85990758,  0.50242162, -0.09017473,  0.22035987],
       [ 0.        ,  0.        ,  0.        ,  1.        ]])

>>> (tf.inv() * tf).as_matrix()
array([[[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]]])

Die inverse starre Transformation ist dieselbe wie die inverse Translation, gefolgt von der inversen Rotation.

>>> t, r = tf.as_components()
>>> r_inv = r.inv()  # inverse rotation
>>> t_inv = -t  # inverse translation
>>> tf_r_inv = Tf.from_rotation(r_inv)
>>> tf_t_inv = Tf.from_translation(t_inv)
>>> np.allclose((tf_r_inv * tf_t_inv).as_matrix(),
...             tf.inv().as_matrix(),
...             atol=1e-12)
True
>>> (tf_r_inv * tf_t_inv * tf).as_matrix()
array([[[1., 0., 0., 0.],
        [0., 1., 0., 0.],
        [0., 0., 1., 0.],
        [0., 0., 0., 1.]]])