scipy.spatial.transform.RigidTransform.

pow#

RigidTransform.__pow__(self, float n)#

Композиция этого преобразования с самим собой n раз.

Жёсткое преобразование p при возведении в нецелые степени можно рассматривать как нахождение доли преобразования. Например, степень 0.5 находит «половинное» преобразование от тождественного к p.

Это реализовано путем применения винтовой линейной интерполяции (ScLERP) между p и тождественное преобразование, где угол компонента вращения масштабируется на n, и перемещение пропорционально корректируется вдоль винтовой оси.

q = p ** n также может быть выражено как q = RigidTransform.from_exp_coords(p.as_exp_coords() * n).

Если n отрицательно, то преобразование инвертируется перед применением степени. Другими словами, p ** -abs(n) == p.inv() ** abs(n).

Параметры:

nfloat: Количество раз для композиции преобразования с самим собой.

Возвращает:

RigidTransform экземпляр: Если входной Rotation p содержит N несколько вращений, тогда выходные данные будут содержать N вращения, где i вращение th равно p[i] ** n.

Примечания

Есть три примечательных случая: если n == 1 то возвращается копия исходного преобразования, если n == 0 тогда возвращается тождественное преобразование, и если n == -1 тогда возвращается обратное преобразование.

Обратите внимание, что дробные степени n которые фактически извлекают корень вращения, делают это с использованием кратчайшего пути наименьшего представления этого угла (главный корень). Это означает, что степени n и 1/n не обязательно являются обратными друг другу. Например, степень 0.5 поворота на +240 градусов будет вычислена как степень 0.5 поворота на -120 градусов, с результатом поворота на -60, а не на +120 градусов.

Примеры

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

Степень 2 возвращает преобразование, применённое к самому себе:

>>> 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.]])

Отрицательная степень возвращает обратное преобразование, возведенное в абсолютное значение n:

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

Степень 0 возвращает тождественное преобразование:

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

Степень 1 возвращает копию исходного преобразования:

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

Дробная степень возвращает преобразование с масштабированным вращением и сдвигом вдоль винтовой оси. Здесь мы берём квадратный корень из преобразования, который при возведении в квадрат восстанавливает исходное преобразование:

>>> 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#