Python SciPy Rotation.align_vectors用法及代码示例

本文简要介绍 python 语言中 scipy.spatial.transform.Rotation.align_vectors 的用法。

用法:

classmethod  Rotation.align_vectors(cls, a, b, weights=None, return_sensitivity=False)#

估计旋转以最佳地对齐两组向量。

找到 A 帧和 B 帧之间最能对齐一组向量的旋转a和b在这些帧中观察到。最小化以下损失函数以求解旋转矩阵\(C\)：

\[L(C) = \frac{1}{2} \sum_{i = 1}^{n} w_i \lVert \mathbf{a}_i - C \mathbf{b}_i \rVert^2 ,\]

其中\(w_i\)是权重对应于每个向量。

旋转是用 Kabsch 算法 [1] 估计的，并解决了所谓的 “pointing problem” 或“Wahba 问题”。

有两种特殊情况。第一种情况是，如果为 a 和 b 给出单个向量，则返回将 b 与 a 对齐的最短距离旋转。

第二种情况是其中一个权重为无穷大时。在这种情况下，初级无限权重向量之间的最短距离旋转的计算如上。然后，计算围绕对齐的主向量的旋转，以便根据上述损失函数最佳地对齐次向量。结果就是这两个旋转的组合。此过程的结果与 Kabsch 算法相同，相应的权重在极限下接近无穷大。对于单个辅助向量，这称为align-constrain 算法 [2]。

对于这两种特殊情况(单个向量或无限权重)，灵敏度矩阵没有物理意义，如果需要，将会引发错误。对于无限权重，主向量充当完美对齐的约束，因此它们对 rssd 的贡献将被迫为 0。

参数 ：：

a： 数组，形状 (3,) 或 (N, 3)

在初始帧 A 中观察到的向量分量。a 的每一行表示一个向量。

b： 数组，形状 (3,) 或 (N, 3)

在另一帧 B 中观察到的向量分量。b 的每一行表示一个向量。

weights： 数组 形状 (N,)，可选

说明矢量观测值相对重要性的权重。如果无(默认)，则权重中的所有值都假定为 1。一个且只有一个权重可以是无穷大，并且权重必须为正。

return_sensitivity： 布尔型，可选

是否返回灵敏度矩阵。详细信息请参见注释。默认值为 False。

返回 ：：

rotation： Rotation 实例

将 b 转换为 a 的旋转的最佳估计。

rssd： 浮点数

代表“距离和平方根”。对齐后给定向量集之间的平方距离的加权和的平方根。它等于sqrt(2 * minimum_loss)，其中minimum_loss是针对找到的最佳旋转评估的损失函数。请注意，结果还将按向量的大小进行加权，因此完美对齐的向量对将具有非零值RSSD如果它们的长度不同。因此，根据使用情况，可能需要在调用此方法之前将输入向量标准化为单位长度。

sensitivity_matrix： ndarray，形状 (3, 3)

估计旋转估计的灵敏度矩阵，如注释中所述。仅当 return_sensitivity 为 True 时返回。如果对齐一对向量或权重无穷大则无效，在这种情况下会引发错误。

注意：

该方法还可以计算估计旋转对矢量测量的小扰动的敏感性。具体来说，我们将旋转估计误差视为帧 A 的一个小旋转向量。灵敏度矩阵与该旋转向量的协方差成正比，假设以下向量a测量误差明显小于其长度。为了得到真正的协方差矩阵，返回的灵敏度矩阵必须乘以调和平均值[3]每个观察值的方差。注意权重应该与观察方差成反比以获得一致的结果。例如，如果所有向量均以 0.01 的相同精度进行测量(权重必须全部相等)，那么您应该将灵敏度矩阵乘以 0.01**2 以获得协方差。

有关协方差估计的更严格讨论，请参阅[4]。有关指向问题和最小正确指向的更多讨论，请参阅[5]。

参考：

[1]

https://en.wikipedia.org/wiki/Kabsch_algorithm

[2]

罗伯特·马格纳，“通过轨迹和动量设定点优化扩展目标跟踪能力。”小卫星会议，2018。

[3]

https://en.wikipedia.org/wiki/Harmonic_mean

[4]

F. Landis Markley，“使用矢量观测的姿态确定：快速最优矩阵算法”，《宇航科学杂志》，卷。 41，第2期，1993年，第261-280页。

[5]

Bar-Itzhack、Itzhack Y.、Daniel Hershkowitz 和 Leiba Rodman，“指向真实欧几里得空间”，《制导、控制和动力学杂志》，卷。 20，第 5 期，1997 年，第 916-922 页。

例子：

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

最好使用 Kabsch 算法对齐两组向量，其中 b 组的最后两个向量测量值存在噪声：

>>> a = [[0, 1, 0], [0, 1, 1], [0, 1, 1]]
>>> b = [[1, 0, 0], [1, 1.1, 0], [1, 0.9, 0]]
>>> rot, rssd, sens = R.align_vectors(a, b, return_sensitivity=True)
>>> rot.as_matrix()
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.]])

当我们将旋转应用于 b 时，我们得到接近 a 的向量：

>>> rot.apply(b)
array([[0. , 1. , 0. ],
       [0. , 1. , 1.1],
       [0. , 1. , 0.9]])

第一个向量的误差为 0，后两个向量的误差为 0.1。这RSSD是加权平方误差之和的平方根，默认权重都是1，所以在这种情况下RSSD计算为sqrt(1 * 0**2 + 1 * 0.1**2 + 1 * (-0.1)**2) = 0.141421356237308

>>> a - rot.apply(b)
array([[ 0., 0.,  0. ],
       [ 0., 0., -0.1],
       [ 0., 0.,  0.1]])
>>> np.sqrt(np.sum(np.ones(3) @ (a - rot.apply(b))**2))
0.141421356237308
>>> rssd
0.141421356237308

本例的灵敏度矩阵如下：

>>> sens
array([[0.2, 0. , 0.],
       [0. , 1.5, 1.],
       [0. , 1. , 1.]])

特殊情况 1：求单个向量之间的最小旋转：

>>> a = [1, 0, 0]
>>> b = [0, 1, 0]
>>> rot, _ = R.align_vectors(a, b)
>>> rot.as_matrix()
array([[0., 1., 0.],
       [-1., 0., 0.],
       [0., 0., 1.]])
>>> rot.apply(b)
array([1., 0., 0.])

特殊情况 2：一个无限重量。在这里，我们找到了可以精确对齐的主向量和辅助向量之间的旋转：

>>> a = [[0, 1, 0], [0, 1, 1]]
>>> b = [[1, 0, 0], [1, 1, 0]]
>>> rot, _ = R.align_vectors(a, b, weights=[np.inf, 1])
>>> rot.as_matrix()
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.]])
>>> rot.apply(b)
array([[0., 1., 0.],
       [0., 1., 1.]])

这里的辅助向量必须是best-fit：

>>> b = [[1, 0, 0], [1, 2, 0]]
>>> rot, _ = R.align_vectors(a, b, weights=[np.inf, 1])
>>> rot.as_matrix()
array([[0., 0., 1.],
       [1., 0., 0.],
       [0., 1., 0.]])
>>> rot.apply(b)
array([[0., 1., 0.],
       [0., 1., 2.]])