us.ihmc.euclid.tuple4D.interfaces.QuaternionBasics类的使用及代码示例

x33g5p2x  于2022-01-28 转载在 其他  
字(13.1k)|赞(0)|评价(0)|浏览(103)

本文整理了Java中us.ihmc.euclid.tuple4D.interfaces.QuaternionBasics类的一些代码示例，展示了QuaternionBasics类的具体用法。这些代码示例主要来源于Github/Stackoverflow/Maven等平台，是从一些精选项目中提取出来的代码，具有较强的参考意义，能在一定程度帮忙到你。QuaternionBasics类的具体详情如下：
包路径：us.ihmc.euclid.tuple4D.interfaces.QuaternionBasics
类名称：QuaternionBasics

QuaternionBasics介绍

暂无

代码示例

代码示例来源：origin: us.ihmc/ihmc-robotics-toolkit

@Override
public void getOrientation(QuaternionBasics orientationToPack)
{
 orientationToPack.set(orientation);
}

代码示例来源：origin: us.ihmc/euclid-test

@Test
public void testMultiplyConjugate()
{
 Random random = new Random(65445L);
 for (int i = 0; i < ITERATIONS; i++)
 {
   T qOther1 = createRandomTuple(random);
   T qOther2 = createRandomTuple(random);
   T qActual = createRandomTuple(random);
   T qExpected = createEmptyTuple();
   { // Test multiplyConjugateThis(QuaternionReadOnly other)
    qExpected.set(qOther1);
    qExpected.conjugate();
    qExpected.multiply(qOther2);
    qActual.set(qOther1);
    qActual.multiplyConjugateThis(qOther2);
    EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon());
   }
   { // Test multiplyConjugateOther(QuaternionReadOnly other)
    qExpected.set(qOther1);
    T qOther2Conjugated = createEmptyTuple();
    qOther2Conjugated.setAndConjugate(qOther2);
    qExpected.multiply(qOther2Conjugated);
    qActual.set(qOther1);
    qActual.multiplyConjugateOther(qOther2);
    EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon());
   }
 }
}

代码示例来源：origin: us.ihmc/euclid-frame

/**
* Performs a linear interpolation in SO(3) from {@code q0} to {@code qf} given the percentage
* {@code alpha}.
* <p>
* The interpolation method used here is often called a <i>Spherical Linear Interpolation</i> or
* SLERP.
* </p>
*
* @param q0 the first frame quaternion used in the interpolation. Not modified.
* @param qf the second quaternion used in the interpolation. Not modified.
* @param alpha the percentage to use for the interpolation. A value of 0 will result in setting
*           this frame quaternion to {@code q0}, while a value of 1 is equivalent to setting this
*           frame quaternion to {@code qf}.
* @throws ReferenceFrameMismatchException if {@code q0} is not expressed in the same reference
*            frame as {@code this}.
*/
default void interpolate(FrameQuaternionReadOnly q0, QuaternionReadOnly qf, double alpha)
{
 checkReferenceFrameMatch(q0);
 QuaternionBasics.super.interpolate(q0, qf, alpha);
}

代码示例来源：origin: us.ihmc/ihmc-robotics-toolkit

/**
* This computes the product: resultToPack = (q0^-1 q1)
*/
public void computeQuaternionDifference(QuaternionReadOnly q0, QuaternionReadOnly q1, QuaternionBasics resultToPack)
{
 resultToPack.setAndConjugate(q0);
 resultToPack.multiply(q1);
}

代码示例来源：origin: us.ihmc/euclid-test

@Test
public void testConjugate()
{
 Random random = new Random(65445L);
 T quaternion;
 T quaternionCopy = createEmptyTuple();
 for (int i = 0; i < ITERATIONS; i++)
 {
   quaternion = createRandomTuple(random);
   quaternionCopy.set(quaternion);
   { // Test conjugate()
    quaternion.conjugate();
    assertEquals(quaternion.getX(), -quaternionCopy.getX(), getEpsilon());
    assertEquals(quaternion.getY(), -quaternionCopy.getY(), getEpsilon());
    assertEquals(quaternion.getZ(), -quaternionCopy.getZ(), getEpsilon());
    assertEquals(quaternion.getS(), quaternionCopy.getS(), getEpsilon());
   }
   { // Test conjugate (QuaternionBasics other)
    T quaternion2 = createEmptyTuple();
    quaternion2.setAndConjugate(quaternionCopy);
    assertTrue(quaternion2.getX() == -quaternionCopy.getX());
    assertTrue(quaternion2.getY() == -quaternionCopy.getY());
    assertTrue(quaternion2.getZ() == -quaternionCopy.getZ());
    assertTrue(quaternion2.getS() == quaternionCopy.getS());
   }
 }
}

代码示例来源：origin: us.ihmc/euclid-test

@Test
public void testPreMultiplyConjugate()
{
 Random random = new Random(65445L);
 for (int i = 0; i < ITERATIONS; i++)
 {
   T qOther1 = createRandomTuple(random);
   T qOther2 = createRandomTuple(random);
   T qActual = createRandomTuple(random);
   T qExpected = createEmptyTuple();
   { // Test preMultiplyConjugateThis(QuaternionBasics other)
    qExpected.set(qOther1);
    qExpected.conjugate();
    qExpected.preMultiply(qOther2);
    qActual.set(qOther1);
    qActual.preMultiplyConjugateThis(qOther2);
    EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon());
   }
   { // Test preMultiplyConjugateOther(QuaternionBasics other)
    qExpected.set(qOther1);
    T qOther2Conjugated = createEmptyTuple();
    qOther2Conjugated.setAndConjugate(qOther2);
    qExpected.preMultiply(qOther2Conjugated);
    qActual.set(qOther1);
    qActual.preMultiplyConjugateOther(qOther2);
    EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon());
   }
 }
}

代码示例来源：origin: us.ihmc/euclid-test

double yaw = EuclidCoreRandomTools.nextDouble(random, Math.PI);
yawRotation.setToYawQuaternion(yaw);
QuaternionTools.multiply(original, yawRotation, expected);
actual.set(original);
actual.appendYawRotation(yaw);
double pitch = EuclidCoreRandomTools.nextDouble(random, Math.PI);
pitchRotation.setToPitchQuaternion(pitch);
QuaternionTools.multiply(original, pitchRotation, expected);
actual.set(original);
actual.appendPitchRotation(pitch);
double roll = EuclidCoreRandomTools.nextDouble(random, Math.PI);
rollRotation.setToRollQuaternion(roll);
QuaternionTools.multiply(original, rollRotation, expected);
actual.set(original);
actual.appendRollRotation(roll);

代码示例来源：origin: us.ihmc/euclid-test

double yaw = EuclidCoreRandomTools.nextDouble(random, Math.PI);
yawRotation.setToYawQuaternion(yaw);
QuaternionTools.multiply(yawRotation, original, expected);
actual.set(original);
actual.prependYawRotation(yaw);
double pitch = EuclidCoreRandomTools.nextDouble(random, Math.PI);
pitchRotation.setToPitchQuaternion(pitch);
QuaternionTools.multiply(pitchRotation, original, expected);
actual.set(original);
actual.prependPitchRotation(pitch);
double roll = EuclidCoreRandomTools.nextDouble(random, Math.PI);
rollRotation.setToRollQuaternion(roll);
QuaternionTools.multiply(rollRotation, original, expected);
actual.set(original);
actual.prependRollRotation(roll);

代码示例来源：origin: us.ihmc/euclid-test

qActual.interpolate(q0, qf, alpha);
qExpected.setToZero();
EuclidCoreTestTools.assertQuaternionEquals(qExpected, qActual, epsilon);
EuclidCoreTestTools.assertQuaternionIsSetToZero(q0);
EuclidCoreTestTools.assertQuaternionIsSetToZero(qf);
qActual.set(q0);
qActual.interpolate(qf, alpha);
qExpected.setToZero();
EuclidCoreTestTools.assertQuaternionEquals(qExpected, qActual, epsilon);
EuclidCoreTestTools.assertQuaternionIsSetToZero(q0);
qf.set(q0);
double alpha = EuclidCoreRandomTools.nextDouble(random, 10.0);
qActual.interpolate(q0, qf, alpha);
qExpected.set(q0);
EuclidCoreTestTools.assertQuaternionEquals(qExpected, qActual, epsilon);
qActual.set(q0);
qActual.interpolate(qf, alpha);
qExpected.set(q0);
EuclidCoreTestTools.assertQuaternionEquals(qExpected, qActual, epsilon);
qActual.interpolate(q0, qf, alpha);
EuclidCoreTestTools.assertQuaternionEquals(qExpected, qActual, epsilon);
qActual.set(q0);
qActual.interpolate(qf, alpha);
EuclidCoreTestTools.assertQuaternionEquals(qExpected, qActual, epsilon);

代码示例来源：origin: us.ihmc/euclid-test

@Test
public void testPreMultiply()
{
 Random random = new Random(65445L);
 for (int i = 0; i < ITERATIONS; i++)
 {
   T qOther1 = createRandomTuple(random);
   T qOther2 = createRandomTuple(random);
   T qActual = createRandomTuple(random);
   T qExpected = createEmptyTuple();
   { // Test preMultiply(QuaternionBasics other)
    qActual.set(qOther1);
    qExpected.set(qOther1);
    qActual.preMultiply(qOther2);
    QuaternionTools.multiply(qOther2, qExpected, qExpected);
    EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon());
   }
 }
}

代码示例来源：origin: us.ihmc/ihmc-robotics-toolkit

errorToPack.set(rotationMatrixCurrent);
     errorToPack.multiply(orientation);
     errorToPack.preMultiplyConjugateOther(orientation);
     errorToPack.normalizeAndLimitToPi();
     return true;
errorToPack.set(axisAngleOffset);

代码示例来源：origin: us.ihmc/ihmc-jmonkey-engine-toolkit

public static void packJMEQuaterionInVecMathQuat4d(Quaternion original, QuaternionBasics target)
{
 target.set(original.getX(), original.getY(), original.getZ(), original.getW());
 // do not remove the normalization. 
 // The conversion from float to double generates very tiny differences which make the 
 // quaternion SLIGHTLY not normal.
 target.normalize();
}

代码示例来源：origin: us.ihmc/euclid-test

@Override
public void testSetDoubles()
{
 Random random = new Random(621541L);
 T quaternion = createEmptyTuple();
 for (int i = 0; i < ITERATIONS; i++)
 { // Test set(double x, double y, double z, double s);
   double x = random.nextDouble();
   double y = random.nextDouble();
   double z = random.nextDouble();
   double s = random.nextDouble();
   quaternion.set(x, y, z, s);
   // The method should normalize, so assertNotEquals is used.
   assertNotEquals(quaternion.getX(), x, getEpsilon());
   assertNotEquals(quaternion.getY(), y, getEpsilon());
   assertNotEquals(quaternion.getZ(), z, getEpsilon());
   assertNotEquals(quaternion.getS(), s, getEpsilon());
   assertEquals(1.0, quaternion.norm(), getEpsilon());
   T original = createRandomTuple(random);
   x = original.getX();
   y = original.getY();
   z = original.getZ();
   s = original.getS();
   quaternion.set(x, y, z, s);
   EuclidCoreTestTools.assertQuaternionEquals(original, quaternion, getEpsilon());
 }
}

代码示例来源：origin: us.ihmc/euclid-test

T actual = createEmptyTuple();
expected.set(original);
expected.prepend(transform.getRotationMatrix());
actual.set(original);
actual.applyTransform(transform);
EuclidCoreTestTools.assertTuple4DEquals(expected, actual, getEpsilon());
T actual = createEmptyTuple();
expected.set(original);
expected.preMultiply(transform.getQuaternion());
actual.set(original);
actual.applyTransform(transform);
EuclidCoreTestTools.assertTuple4DEquals(expected, actual, getEpsilon());
T actual = createEmptyTuple();
expected.set(original);
expected.prepend(transform.getRotationMatrix());
actual.set(original);
actual.applyTransform(transform);
EuclidCoreTestTools.assertTuple4DEquals(expected, actual, getEpsilon());

代码示例来源：origin: us.ihmc/euclid-test

@Test
public void testMultiply()
{
 Random random = new Random(65445L);
 for (int i = 0; i < ITERATIONS; i++)
 {
   T qOther1 = createRandomTuple(random);
   T qOther2 = createRandomTuple(random);
   T qActual = createRandomTuple(random);
   T qExpected = createEmptyTuple();
   { // Test multiply(QuaternionBasics other)
    qActual.set(qOther1);
    qExpected.set(qOther1);
    qActual.multiply(qOther2);
    QuaternionTools.multiply(qExpected, qOther2, qExpected);
    EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon());
   }
   { // Test multiply(QuaternionBasics q1, QuaternionBasics q2)
    qActual.multiply(qOther1, qOther2);
    QuaternionTools.multiply(qOther1, qOther2, qExpected);
    EuclidCoreTestTools.assertQuaternionEquals(qActual, qExpected, getEpsilon());
   }
 }
}

代码示例来源：origin: us.ihmc/euclid-test

qExpected.setUnsafe(-qx, -qy, -qz, qs);
T qActual = createEmptyTuple();
qActual.setUnsafe(qx, qy, qz, qs);
qActual.inverse();
qActual.setUnsafe(scale * qx, scale * qy, scale * qz, scale * qs);
qActual.inverse();
qs = cosHalfTheta;
qExpected.setUnsafe(-qx, -qy, -qz, qs);
qActual.setUnsafe(qx, qy, qz, qs);
qActual.inverse();
EuclidCoreTestTools.assertQuaternionEquals(qExpected, qActual, getEpsilon());
qExpected.set(qOriginal);
qExpected.inverse();
qActual.setAndInvert(qOriginal);
EuclidCoreTestTools.assertQuaternionEquals(qExpected, qActual, getEpsilon());

代码示例来源：origin: us.ihmc/ihmc-robotics-toolkit

public static void computeQuaternionFromYawAndZNormal(double yaw, Vector3DReadOnly zNormal, QuaternionBasics quaternionToPack)
{
 double Cx = 1.0;
 double Cy = Math.tan(yaw);
 if (Math.abs(zNormal.getZ()) < 1e-9)
 {
   quaternionToPack.setToNaN();
   return;
 }
 double Cz = -1.0 * (zNormal.getX() + Cy * zNormal.getY()) / zNormal.getZ();
 double CT = Math.sqrt(Cx * Cx + Cy * Cy + Cz * Cz);
 if (CT < 1e-9)
   throw new RuntimeException("Error calculating Quaternion");
 Vector3D xAxis = new Vector3D(Cx / CT, Cy / CT, Cz / CT);
 if (xAxis.getX() * Math.cos(yaw) + xAxis.getY() * Math.sin(yaw) < 0.0)
 {
   xAxis.negate();
 }
 Vector3D yAxis = new Vector3D();
 Vector3DReadOnly zAxis = zNormal;
 yAxis.cross(zAxis, xAxis);
 RotationMatrix rotationMatrix = rotationMatrixForQuaternionFromYawAndZNormal.get();
 rotationMatrix.setColumns(xAxis, yAxis, zAxis);
 quaternionToPack.set(rotationMatrix);
}

代码示例来源：origin: us.ihmc/ihmc-robotics-toolkit

public void inverseMultiply(QuaternionReadOnly q1, QuaternionReadOnly q2, QuaternionBasics resultToPack)
{
 qInv.setAndConjugate(q1);
 resultToPack.multiply(qInv, q2);
}

代码示例来源：origin: us.ihmc/euclid-test

T actual = createEmptyTuple();
expected.set(original);
actual.set(original);
actual.applyTransform(transform);
actual.applyInverseTransform(transform);
EuclidCoreTestTools.assertTuple4DEquals(expected, actual, getEpsilon());
T actual = createEmptyTuple();
expected.set(original);
actual.set(original);
actual.applyTransform(transform);
actual.applyInverseTransform(transform);
EuclidCoreTestTools.assertTuple4DEquals(expected, actual, getEpsilon());
T actual = createEmptyTuple();
expected.set(original);
actual.set(original);
actual.applyTransform(transform);
actual.applyInverseTransform(transform);
EuclidCoreTestTools.assertTuple4DEquals(expected, actual, getEpsilon());

代码示例来源：origin: us.ihmc/euclid-test

double xOriginal = signX * original.getX();
double yOriginal = signY * original.getY();
double zOriginal = signZ * original.getZ();
double sOriginal = signS * original.getS();
tuple1 = createTuple(xOriginal, yOriginal, zOriginal, sOriginal);
tuple2.setToNaN();
tuple2.setAndNegate(tuple1);
assertEquals(tuple2.getX(), -xOriginal, getEpsilon());
assertEquals(tuple2.getY(), -yOriginal, getEpsilon());
assertEquals(tuple2.getZ(), -zOriginal, getEpsilon());
assertEquals(tuple2.getS(), -sOriginal, getEpsilon());
assertEquals(tuple1.getX(), xOriginal, getEpsilon());
assertEquals(tuple1.getY(), yOriginal, getEpsilon());
assertEquals(tuple1.getZ(), zOriginal, getEpsilon());
assertEquals(tuple1.getS(), sOriginal, getEpsilon());
tuple1.negate();
assertEquals(tuple1.getX(), -xOriginal, getEpsilon());
assertEquals(tuple1.getY(), -yOriginal, getEpsilon());
assertEquals(tuple1.getZ(), -zOriginal, getEpsilon());
assertEquals(tuple1.getS(), -sOriginal, getEpsilon());

内容来源于网络，如有侵权，请联系作者删除！

QuaternionBasics

相关文章

    查看更多
    微信公众号

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com