程序包 org.hipparchus.geometry.euclidean.threed

类 FieldRotation<T extends CalculusFieldElement<T>>

java.lang.Object
org.hipparchus.geometry.euclidean.threed.FieldRotation<T>
类型参数:
T - 字段元素的类型
所有已实现的接口:
Serializable
public class FieldRotation<T extends CalculusFieldElement<T>> extends Object implements Serializable
该类是使用CalculusFieldElement重新实现的Rotation。此类的实例保证是不可变的。
另请参阅:

  • 构造器详细资料

    • FieldRotation

      public FieldRotation(T q0, T q1, T q2, T q3, boolean needsNormalization)
      从四元数坐标构建旋转。

      可以从归一化四元数构建旋转，即满足q02 + q12 + q22 + q32 = 1的四元数。如果四元数未归一化，则构造函数可以在使用之前对其进行归一化预处理。

      请注意，某些约定将四元数的标量部分作为第4个分量，将矢量部分作为前三个分量。这不是我们的约定。我们将标量部分作为第一个分量。

      参数:
      q0 - 四元数的标量部分
      q1 - 四元数的矢量部分的第一个坐标
      q2 - 四元数的矢量部分的第二个坐标
      q3 - 四元数的矢量部分的第三个坐标
      needsNormalization - 如果为true，则认为坐标未归一化，在使用之前执行归一化预处理

    • FieldRotation

      public FieldRotation(FieldVector3D<T> axis, T angle, RotationConvention convention) throws MathIllegalArgumentException
      从轴和角度构建旋转。

      我们使用的约定是，角度是根据旋转对轴周围的向量的影响而定向的。这意味着如果(i, j, k)是一个直角坐标系，如果我们首先将+k作为轴，π/2作为角度提供给此构造函数，然后apply实例到+i，我们将得到+j。

      表示我们约定的另一种方式是说，围绕单位向量(x, y, z)旋转θ的旋转与从四元数分量{ cos(-θ/2), x * sin(-θ/2), y * sin(-θ/2), z * sin(-θ/2) }构建的旋转相同。请注意角度上的负号！

      一方面，这个约定与矢量视角一致（在固定坐标系中移动矢量），另一方面，它与具有框架视角的约定不同（从不同框架查看的固定矢量），例如在航天器姿态社区或图形社区中使用的约定。

      参数:
      axis - 绕其旋转的轴
      angle - 旋转角度。
      convention - 角度语义使用的约定
      抛出:
      MathIllegalArgumentException - 如果轴的范数为零

    • FieldRotation

      public FieldRotation(Field<T> field, Rotation r)
      从Rotation构建一个FieldRotation。
      参数:
      field - 组件的字段
      r - 要转换的旋转

    • FieldRotation

      public FieldRotation(T[][] m, double threshold) throws MathIllegalArgumentException
      从3X3矩阵构建旋转。

      旋转矩阵是正交矩阵，即单位矩阵（其矩阵为m.mT = I）具有实系数。单位矩阵的行列式模为1，在正交3X3矩阵中，只有行列式为正（+1）的矩阵是旋转矩阵。

      当旋转由具有截断值的矩阵定义时（通常当从技术说明中提取时，仅有四到五个有效数字可用），矩阵不再是正交的。此构造函数通过使用给定矩阵的副本并对副本应用校正来处理此情况，以使其完全正交。如果所需的Frobenius范数的校正超过给定阈值，则认为矩阵离真正的旋转矩阵太远，并抛出异常。

      参数:
      m - 旋转矩阵
      threshold - 迭代正交性校正的收敛阈值（当校正的Frobenius范数的两个步骤之间的差小于此阈值时达到收敛）
      抛出:
      MathIllegalArgumentException - 如果矩阵不是3X3矩阵，或者无法使用给定阈值将其转换为正交矩阵，或者结果正交矩阵的行列式为负

    • FieldRotation

      public FieldRotation(FieldVector3D<T> u1, FieldVector3D<T> u2, FieldVector3D<T> v1, FieldVector3D<T> v2) throws MathRuntimeException
      构建将一对向量转换为另一对向量的旋转。

      除了可能的比例因子外，如果将该实例应用于一对向量(u1, u2)，它将产生一对向量(v1, v2)。

      如果u1和u2之间的角度差与v1和v2之间的角度差不同，则将使用校正后的v'2而不是v2，校正后的向量将位于(±v1, +v2)半平面。

      参数:
      u1 - 原始向量对的第一个向量
      u2 - 原始向量对的第二个向量
      v1 - 旋转后u1的期望图像
      v2 - 旋转后u2的期望图像
      抛出:
      MathRuntimeException - 如果其中一个向量的范数为零，或者一对向量是退化的（即一对向量共线）

    • FieldRotation

      public FieldRotation(FieldVector3D<T> u, FieldVector3D<T> v) throws MathRuntimeException
      构建将一个向量转换为另一个向量的旋转之一。

      除了可能的比例因子外，如果将该实例应用于向量u，它将产生向量v。有无限多个这样的旋转，此构造函数选择与最小关联角度（即轴与(u, v)平面正交的旋转）的旋转。如果u和v共线，则选择任意旋转轴。

      参数:
      u - 原始向量
      v - 旋转后u的期望图像
      抛出:
      MathRuntimeException - 如果其中一个向量的范数为零

    • FieldRotation

      public FieldRotation(RotationOrder order, RotationConvention convention, T alpha1, T alpha2, T alpha3)
      从三个Cardan或Euler基本旋转构建旋转。

      Cardan旋转是绕规范轴X、Y和Z的三次连续旋转，每个轴只使用一次。有6种这样的旋转集合（XYZ、XZY、YXZ、YZX、ZXY和ZYX）。Euler旋转是绕规范轴X、Y和Z的三次连续旋转，第一次和最后一次旋转是围绕同一轴进行的。有6种这样的旋转集合（XYX、XZX、YXY、YZY、ZXZ和ZYZ），最流行的是ZXZ。

      请注意，许多人通常将欧拉角术语错误地用于实际上是Cardan角的情况（这种混淆在航空航天业特别普遍，其中横滚、俯仰和偏航角经常错误地标记为欧拉角）。

      参数:
      order - 要组合的旋转顺序，从左到右（即我们将使用r1.compose(r2.compose(r3, convention), convention)）
      convention - 角度语义使用的约定
      alpha1 - 第一个基本旋转的角度
      alpha2 - 第二个基本旋转的角度
      alpha3 - 第三个基本旋转的角度

  • 方法详细资料

    • getIdentity

      public static <T extends CalculusFieldElement<T>> FieldRotation<T> getIdentity(Field<T> field)
      获取单位旋转。
      类型参数:
      T - 字段元素的类型
      参数:
      field - 组件的字段
      返回:
      一个新的旋转

    • revert

      public FieldRotation<T> revert()
      反转旋转。构建一个反转另一个旋转效果的旋转。这意味着如果r(u) = v，则r.revert(v) = u。实例不会改变。
      返回:
      一个新的旋转，其效果与实例的效果相反

    • getQ0

      public T getQ0()
      获取四元数的标量坐标。
      返回:
      四元数的标量坐标

    • getQ1

      public T getQ1()
      获取四元数的矢量部分的第一个坐标。
      返回:
      四元数的矢量部分的第一个坐标

    • getQ2

      public T getQ2()
      获取四元数的矢量部分的第二个坐标。
      返回:
      四元数的矢量部分的第二个坐标

    • getQ3

      public T getQ3()
      获取四元数的矢量部分的第三个坐标。
      返回:
      四元数的矢量部分的第三个坐标

    • getAxis

      public FieldVector3D<T> getAxis(RotationConvention convention)
      获取旋转的归一化轴。

      请注意，由于getAngle()始终返回0到π之间的角度，更改约定会更改轴的方向，而不是角度的符号。

      参数:
      convention - 角度语义使用的约定
      返回:
      旋转的归一化轴
      另请参阅:

    • getAngle

      public T getAngle()
      获取旋转的角度。
      返回:
      旋转的角度（介于0和π之间）
      另请参阅:

    • getAngles

      public T[] getAngles(RotationOrder order, RotationConvention convention) throws MathIllegalStateException
      获取与实例对应的Cardan或Euler角。

      方程式表明，每个旋转可以由Cardan或Euler角集的两个不同值来定义。例如，如果使用Cardan角，则由角度a1、a2和a3定义的旋转与由角度π + a1、π - a2和π + a3定义的旋转相同。此方法实现以下任意选择：

      • 对于Cardan角，所选集合是第二个角度介于-π/2和π/2之间（即其余弦为正），
      • 对于Euler角，所选集合是第二个角度介于0和π之间（即其正弦为正）。

      Cardan和Euler角有一个非常令人失望的缺点：它们都有奇点。这意味着如果实例太接近给定旋转顺序对应的奇点，将无法检索角度。对于Cardan角，这经常被称为万向节锁定。无法防止这种情况发生，这是Cardan和Euler表示法的固有问题（但不是旋转本身的问题，旋转本身是完全定义良好的）。对于Cardan角，当第二个角度接近-π/2或+π/2时会出现奇点，对于Euler角，当第二个角度接近0或π时会出现奇点，这意味着对于Euler角，单位旋转始终是奇点！

      参数:
      order - 要使用的旋转顺序
      convention - 角度语义使用的约定
      返回:
      三个角度的数组，按照指定的顺序
      抛出:
      MathIllegalStateException - 如果旋转对指定的角度集是奇点

    • getMatrix

      public T[][] getMatrix()
      获取与实例对应的3X3矩阵
      返回:
      与实例对应的矩阵

    • toRotation

      public Rotation toRotation()
      转换为没有导数的常量向量。
      返回:
      一个常量向量

    • applyTo

      public FieldVector3D<T> applyTo(FieldVector3D<T> u)
      将旋转应用于一个向量。
      参数:
      u - 要应用旋转的向量
      返回:
      一个新的向量，是旋转后u的图像

    • applyTo

      public FieldVector3D<T> applyTo(Vector3D u)
      将旋转应用于一个向量。
      参数:
      u - 要应用旋转的向量
      返回:
      一个新的向量，是旋转后u的图像

    • applyTo

      public void applyTo(T[] in, T[] out)
      将旋转应用于存储在数组中的向量。
      参数:
      in - 一个包含三个项目的数组，存储要旋转的向量
      out - 一个包含三个项目的数组，用于放置结果（可以与in相同的数组）

    • applyTo

      public void applyTo(double[] in, T[] out)
      将旋转应用于存储在数组中的向量。
      参数:
      in - 一个包含三个项目的数组，存储要旋转的向量
      out - 一个包含三个项目的数组，用于放置结果

    • applyTo

      public static <T extends CalculusFieldElement<T>> FieldVector3D<T> applyTo(Rotation r, FieldVector3D<T> u)
      将旋转应用于一个向量。
      类型参数:
      T - 字段元素的类型
      参数:
      r - 要应用的旋转
      u - 要应用旋转的向量
      返回:
      一个新的向量，是旋转后u的图像

    • applyInverseTo

      public FieldVector3D<T> applyInverseTo(FieldVector3D<T> u)
      将旋转的逆应用于一个向量。
      参数:
      u - 要应用旋转的逆的向量
      返回:
      一个新的向量，使得u是旋转的图像

    • applyInverseTo

      public FieldVector3D<T> applyInverseTo(Vector3D u)
      将旋转的逆应用于一个向量。
      参数:
      u - 要应用旋转的逆的向量
      返回:
      一个新的向量，使得u是旋转的图像

    • applyInverseTo

      public void applyInverseTo(T[] in, T[] out)
      将旋转的逆应用于存储在数组中的向量。
      参数:
      in - 一个包含三个项目的数组，存储要旋转的向量
      out - 一个包含三个项目的数组，用于放置结果（可以与in相同的数组）

    • applyInverseTo

      public void applyInverseTo(double[] in, T[] out)
      将旋转的逆应用于存储在数组中的向量。
      参数:
      in - 一个包含三个项目的数组，存储要旋转的向量
      out - 一个包含三个项目的数组，用于放置结果

    • applyInverseTo

      public static <T extends CalculusFieldElement<T>> FieldVector3D<T> applyInverseTo(Rotation r, FieldVector3D<T> u)
      将旋转的逆应用于一个向量。
      类型参数:
      T - 字段元素的类型
      参数:
      r - 要应用的旋转
      u - 要应用旋转的逆的向量
      返回:
      一个新的向量，使得u是旋转的图像

    • applyTo

      public FieldRotation<T> applyTo(FieldRotation<T> r)
      将实例应用于另一个旋转。

      调用此方法等效于调用

      参数:
      r - 要应用旋转的旋转
      返回:
      一个新的旋转，是r与实例的组合

    • compose

      public FieldRotation<T> compose(FieldRotation<T> r, RotationConvention convention)
      组合实例与另一个旋转。

      如果旋转组合的语义对应于矢量运算符约定，将实例应用于旋转是按照以下规则进行组合的：假设u是任意矢量，v是通过r1映射的图像（即r1.applyTo(u) = v）。让w是通过旋转r2映射的v的图像（即r2.applyTo(v) = w）。那么w = comp.applyTo(u)，其中comp = r2.compose(r1, RotationConvention.VECTOR_OPERATOR)。

      如果旋转组合的语义对应于框架变换约定，应用顺序将被颠倒。因此，保持所有r1，r2，u，v，w和comp的确切含义与上述相同，comp也可以计算为comp = r1.compose(r2, RotationConvention.FRAME_TRANSFORM)。

      参数:
      r - 要应用旋转的旋转
      convention - 用于角度语义的约定
      返回:
      一个新的旋转，是r与实例的组合

    • applyTo

      public FieldRotation<T> applyTo(Rotation r)
      将实例应用于另一个旋转。

      调用此方法等同于调用compose(r, RotationConvention.VECTOR_OPERATOR)。

      参数:
      r - 要应用旋转的旋转
      返回:
      一个新的旋转，是r与实例的组合

    • compose

      public FieldRotation<T> compose(Rotation r, RotationConvention convention)
      组合实例与另一个旋转。

      如果旋转组合的语义对应于矢量运算符约定，将实例应用于旋转是按照以下规则进行组合的：假设u是任意矢量，v是通过r1映射的图像（即r1.applyTo(u) = v）。让w是通过旋转r2映射的v的图像（即r2.applyTo(v) = w）。那么w = comp.applyTo(u)，其中comp = r2.compose(r1, RotationConvention.VECTOR_OPERATOR)。

      如果旋转组合的语义对应于框架变换约定，应用顺序将被颠倒。因此，保持所有r1，r2，u，v，w和comp的确切含义与上述相同，comp也可以计算为comp = r1.compose(r2, RotationConvention.FRAME_TRANSFORM)。

      参数:
      r - 要应用旋转的旋转
      convention - 用于角度语义的约定
      返回:
      一个新的旋转，是r与实例的组合

    • applyTo

      public static <T extends CalculusFieldElement<T>> FieldRotation<T> applyTo(Rotation r1, FieldRotation<T> rInner)
      将一个旋转应用于另一个旋转。将一个旋转应用于另一个旋转是按照以下规则进行组合的：假设u是任意矢量，v是通过rInner映射的图像（即rInner.applyTo(u) = v），让w是通过rOuter映射的v的图像（即rOuter.applyTo(v) = w），那么w = comp.applyTo(u)，其中comp = applyTo(rOuter, rInner)。
      类型参数:
      T - 字段元素的类型
      参数:
      r1 - 要应用的旋转
      rInner - 要应用旋转的旋转
      返回:
      一个新的旋转，是r与实例的组合

    • applyInverseTo

      public FieldRotation<T> applyInverseTo(FieldRotation<T> r)
      将实例的逆应用于另一个旋转。

      调用此方法等同于调用composeInverse(r, RotationConvention.VECTOR_OPERATOR)。

      参数:
      r - 要应用旋转的旋转
      返回:
      一个新的旋转，是r与实例的逆的组合

    • composeInverse

      public FieldRotation<T> composeInverse(FieldRotation<T> r, RotationConvention convention)
      将实例的逆与另一个旋转组合。

      如果旋转组合的语义对应于矢量运算符约定，将实例的逆应用于旋转是按照以下规则进行组合的：假设u是任意矢量，v是通过r1映射的图像（即r1.applyTo(u) = v）。让w是通过r2的逆映射的v的图像（即r2.applyInverseTo(v) = w）。那么w = comp.applyTo(u)，其中comp = r2.composeInverse(r1)。

      如果旋转组合的语义对应于框架变换约定，应用顺序将被颠倒，这意味着最内部的旋转将被颠倒。因此，保持所有r1，r2，u，v，w和comp的确切含义与上述相同，comp也可以计算为comp = r1.revert().composeInverse(r2.revert(), RotationConvention.FRAME_TRANSFORM)。

      参数:
      r - 要应用旋转的旋转
      convention - 用于角度语义的约定
      返回:
      一个新的旋转，是r与实例的逆的组合

    • applyInverseTo

      public FieldRotation<T> applyInverseTo(Rotation r)
      将实例的逆应用于另一个旋转。

      调用此方法等同于调用composeInverse(r, RotationConvention.VECTOR_OPERATOR)。

      参数:
      r - 要应用旋转的旋转
      返回:
      一个新的旋转，是r与实例的逆的组合

    • composeInverse

      public FieldRotation<T> composeInverse(Rotation r, RotationConvention convention)
      将实例的逆与另一个旋转组合。

      如果旋转组合的语义对应于矢量运算符约定，将实例的逆应用于旋转是按照以下规则进行组合的：假设u是任意矢量，v是通过r1映射的图像（即r1.applyTo(u) = v）。让w是通过r2的逆映射的v的图像（即r2.applyInverseTo(v) = w）。那么w = comp.applyTo(u)，其中comp = r2.composeInverse(r1)。

      如果旋转组合的语义对应于框架变换约定，应用顺序将被颠倒，这意味着最内部的旋转将被颠倒。因此，保持所有r1，r2，u，v，w和comp的确切含义与上述相同，comp也可以计算为comp = r1.revert().composeInverse(r2.revert(), RotationConvention.FRAME_TRANSFORM)。

      参数:
      r - 要应用旋转的旋转
      convention - 用于角度语义的约定
      返回:
      一个新的旋转，是r与实例的逆的组合

    • applyInverseTo

      public static <T extends CalculusFieldElement<T>> FieldRotation<T> applyInverseTo(Rotation rOuter, FieldRotation<T> rInner)
      将一个旋转的逆应用于另一个旋转。将一个旋转的逆应用于另一个旋转是按照以下规则进行组合的：假设u是任意矢量，v是通过rInner映射的图像（即rInner.applyTo(u) = v），让w是通过rOuter的逆映射的v的图像（即rOuter.applyInverseTo(v) = w），那么w = comp.applyTo(u)，其中comp = applyInverseTo(rOuter, rInner)。
      类型参数:
      T - 字段元素的类型
      参数:
      rOuter - 要应用旋转的旋转
      rInner - 要应用旋转的旋转
      返回:
      一个新的旋转，是r与实例的逆的组合

    • distance

      public static <T extends CalculusFieldElement<T>> T distance(FieldRotation<T> r1, FieldRotation<T> r2)
      计算两个旋转之间的距离。

      这里的距离是一种检查两个旋转是否几乎相似（即它们以相同方式转换矢量）或非常不同的方法。在数学上，它被定义为前置到其中一个旋转的旋转r的角度，使得\(r_1(r) = r_2\)

      这个距离是介于0和π之间的角度。它的值是r1(v)和r2(v)之间的所有可能矢量v的角度的最小可能上限。对于某些v，这个上限是达到的。如果两个旋转完全相同，则距离等于0。

      比较两个旋转应该始终使用这个值，而不是例如比较四元数的分量。这更加稳定，并且具有几何意义。此外，比较四元数分量是容易出错的，因为例如四元数(0.36, 0.48, -0.48, -0.64)和(-0.36, -0.48, 0.48, 0.64)表示完全相同的旋转，尽管它们的分量不同（它们是完全相反的）。

      类型参数:
      T - 字段元素的类型
      参数:
      r1 - 第一个旋转
      r2 - 第二个旋转
      返回:
      r1和r2之间的距离