scipy.spatial.transform.RigidTransform.

pow#

RigidTransform.__pow__(self, float n)#

Diese Transformation n-mal mit sich selbst komponieren.

Eine starre Transformation p, wenn sie auf nicht-ganzzahlige Potenzen erhoben wird, kann als Finden eines Bruchteils der Transformation betrachtet werden. Zum Beispiel findet eine Potenz von 0,5 eine „Halbzeit“-Transformation von der Identität zu p.

Dies wird durch Anwenden einer schraubenlinienförmigen linearen Interpolation (ScLERP) zwischen p und der Identitätstransformation implementiert, wobei der Winkel der Rotationskomponente mit n skaliert und die Translation proportional entlang der Schraubenachse angepasst wird.

q = p ** n kann auch ausgedrückt werden als q = RigidTransform.from_exp_coords(p.as_exp_coords() * n).

Wenn n negativ ist, dann wird die Transformation vor dem Anwenden der Potenz invertiert. Anders ausgedrückt, p ** -abs(n) == p.inv() ** abs(n).

Parameter:

nfloat: Die Anzahl der Male, die die Transformation mit sich selbst komponiert wird.

Rückgabe:

RigidTransform Instanz: Wenn die Eingaberotation p N mehrere Rotationen enthält, dann enthält die Ausgabe N Rotationen, wobei die i-te Rotation gleich p[i] ** n ist.

Hinweise

Es gibt drei bemerkenswerte Fälle: wenn n == 1, dann wird eine Kopie der ursprünglichen Transformation zurückgegeben, wenn n == 0, dann wird die Identitätstransformation zurückgegeben, und wenn n == -1, dann wird die inverse Transformation zurückgegeben.

Beachten Sie, dass gebrochene Potenzen n, die effektiv eine Wurzel einer Rotation ziehen, dies unter Verwendung des kürzesten Pfades der kleinsten Darstellung dieses Winkels (der Hauptwurzel) tun. Dies bedeutet, dass die Potenzen von n und 1/n nicht notwendigerweise ihre Inversen sind. Zum Beispiel wird die Potenz 0,5 einer +240-Grad-Rotation als Potenz 0,5 einer -120-Grad-Rotation berechnet, wobei das Ergebnis eine Rotation von -60 statt +120 Grad ist.

Beispiele

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

Eine Potenz von 2 gibt die Transformation zurück, die mit sich selbst komponiert wurde

>>> tf = Tf.from_translation([1, 2, 3])
>>> (tf ** 2).translation
array([2., 4., 6.])
>>> (tf ** 2).as_matrix()
array([[1., 0., 0., 2.],
       [0., 1., 0., 4.],
       [0., 0., 1., 6.],
       [0., 0., 0., 1.]])

Eine negative Potenz gibt die Inverse der Transformation zurück, die zur absoluten Größe von n erhoben wurde

>>> (tf ** -2).translation
array([-2., -4., -6.])
>>> np.allclose((tf ** -2).as_matrix(), (tf.inv() ** 2).as_matrix(),
...             atol=1e-12)
True

Eine Potenz von 0 gibt die Identitätstransformation zurück

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

Eine Potenz von 1 gibt eine Kopie der ursprünglichen Transformation zurück

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

Eine gebrochene Potenz gibt eine Transformation mit einer skalierten Rotation zurück, die entlang der Schraubenachse verschoben wurde. Hier ziehen wir die Quadratwurzel der Transformation, die beim Quadrieren die ursprüngliche Transformation wiederherstellt

>>> tf_half = (tf ** 0.5)
>>> tf_half.translation
array([0.5, 1., 1.5])
>>> (tf_half ** 2).as_matrix()
array([[1., 0., 0., 1.],
       [0., 1., 0., 2.],
       [0., 0., 1., 3.],
       [0., 0., 0., 1.]])

__pow__#

pow#