@Override public double getEpsilon() { return QuaternionBasicsTest.this.getEpsilon(); } };
@Test public void testIsOrientation2D() throws Exception { Random random = new Random(23905872L); for (int i = 0; i < ITERATIONS; i++) { double qx = random.nextDouble(); double qy = random.nextDouble(); double qz = random.nextDouble(); double qs = random.nextDouble(); T quaternion = createEmptyTuple(); quaternion.set(qx, qy, qz, qs); assertFalse(quaternion.isOrientation2D(getEpsilon())); quaternion.set(0.0, qy, qz, qs); assertFalse(quaternion.isOrientation2D(getEpsilon())); quaternion.set(qx, 0.0, qz, qs); assertFalse(quaternion.isOrientation2D(getEpsilon())); quaternion.set(0.0, 0.0, qz, qs); assertTrue(quaternion.isOrientation2D(getEpsilon())); quaternion.set(2.0 * getEpsilon(), 0.0, qz, qs); assertFalse(quaternion.isOrientation2D(getEpsilon())); quaternion.set(0.0, 2.0 * getEpsilon(), qz, qs); assertFalse(quaternion.isOrientation2D(getEpsilon())); } }
@Test public void testSetToZero() { Random random = new Random(621541L); T quaternion = createRandomTuple(random); quaternion.setToZero(); T zeroQ = createTuple(0.0, 0.0, 0.0, 1.0); EuclidCoreTestTools.assertQuaternionEquals(quaternion, zeroQ, getEpsilon()); }
@Test public void testGetAngle() { Random random = new Random(65445L); double expectedAngle = 2.0 * Math.PI * random.nextDouble(); // Sign issue when theta < 0.0 double c = Math.cos(expectedAngle / 2.0); double s = Math.sin(expectedAngle / 2.0); Vector3D axis = EuclidCoreRandomTools.nextVector3DWithFixedLength(random, 1.0); Quaternion q = new Quaternion(); double qx = s * axis.getX(); double qy = s * axis.getY(); double qz = s * axis.getZ(); double qs = c; q.setUnsafe(qx, qy, qz, qs); assertEquals(expectedAngle, q.getAngle(), getEpsilon()); }
@Test public void testSetYawPitchRoll() { Random random = new Random(574631L); T actualQuaternion = createEmptyTuple(); T expectedQuaternion = createEmptyTuple(); double[] yawPitchRoll; for (int i = 0; i < ITERATIONS; i++) { // Test setYawPitchRoll(double[] yawPitchRoll) yawPitchRoll = EuclidCoreRandomTools.nextYawPitchRollArray(random); QuaternionConversion.convertYawPitchRollToQuaternion(yawPitchRoll, expectedQuaternion); actualQuaternion.setYawPitchRoll(yawPitchRoll); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); actualQuaternion.setToZero(); actualQuaternion.setYawPitchRoll(yawPitchRoll[0], yawPitchRoll[1], yawPitchRoll[2]); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); } }
@Test public void testGetRotationVector() throws Exception { Random random = new Random(23423L); for (int i = 0; i < ITERATIONS; i++) { T quaternion = createRandomTuple(random); Vector3D expectedRotationVector = new Vector3D(); Vector3D actualRotationVector = new Vector3D(); RotationVectorConversion.convertQuaternionToRotationVector(quaternion, expectedRotationVector); quaternion.getRotationVector(actualRotationVector); EuclidCoreTestTools.assertTuple3DEquals(expectedRotationVector, actualRotationVector, getEpsilon()); } }
@Test public void testSetAxisAngle() { Random random = new Random(574631L); T actualQuaternion = createEmptyTuple(); T expectedQuaternion = createEmptyTuple(); AxisAngle axisAngle; for (int i = 0; i < ITERATIONS; i++) { // Test set(AxisAngleReadOnly axisAngle) axisAngle = EuclidCoreRandomTools.nextAxisAngle(random); QuaternionConversion.convertAxisAngleToQuaternion(axisAngle, expectedQuaternion); actualQuaternion.set(axisAngle); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); } }
@Test public void testSetRollQuaternion() { Random random = new Random(574631L); T actualQuaternion = createEmptyTuple(); T expectedQuaternion = createEmptyTuple(); for (int i = 0; i < ITERATIONS; i++) { // Test setToRollQuaternion(double roll) double roll = EuclidCoreRandomTools.nextDouble(random, 2.0 * Math.PI); actualQuaternion.setToRollQuaternion(roll); expectedQuaternion.set(new AxisAngle(1.0, 0.0, 0.0, roll)); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); } }
@Test public void testSetRotationMatrix() { Random random = new Random(574631L); T actualQuaternion = createEmptyTuple(); T expectedQuaternion = createEmptyTuple(); RotationMatrix rotationMatrix; for (int i = 0; i < ITERATIONS; i++) { // Test set(RotationMatrixReadOnly rotationMatrix) rotationMatrix = EuclidCoreRandomTools.nextRotationMatrix(random); QuaternionConversion.convertMatrixToQuaternion(rotationMatrix, expectedQuaternion); actualQuaternion.set(rotationMatrix); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); } }
@Test public void testSetRotationVector() { Random random = new Random(574631L); T actualQuaternion = createEmptyTuple(); T expectedQuaternion = createEmptyTuple(); Vector3D rotationVector; for (int i = 0; i < ITERATIONS; i++) { // Test set(Vector3DReadOnly rotationVector) rotationVector = EuclidCoreRandomTools.nextRotationVector(random); QuaternionConversion.convertRotationVectorToQuaternion(rotationVector, expectedQuaternion); actualQuaternion.setRotationVector(rotationVector); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); } }
@Test public void testSetYawQuaternion() { Random random = new Random(574631L); T actualQuaternion = createEmptyTuple(); T expectedQuaternion = createEmptyTuple(); for (int i = 0; i < ITERATIONS; i++) { // Test setToYawQuaternion(double yaw) double yaw = EuclidCoreRandomTools.nextDouble(random, 2.0 * Math.PI); actualQuaternion.setToYawQuaternion(yaw); expectedQuaternion.set(new AxisAngle(0.0, 0.0, 1.0, yaw)); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); } }
@Test public void testSetPitchQuaternion() { Random random = new Random(574631L); T actualQuaternion = createEmptyTuple(); T expectedQuaternion = createEmptyTuple(); for (int i = 0; i < ITERATIONS; i++) { // Test setToPitchQuaternion(double pitch) double pitch = EuclidCoreRandomTools.nextDouble(random, 2.0 * Math.PI); actualQuaternion.setToPitchQuaternion(pitch); expectedQuaternion.set(new AxisAngle(0.0, 1.0, 0.0, pitch)); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); } }
@Override @Test public void testNormalize() { super.testNormalize(); Quaternion expected = new Quaternion(); Quaternion actual = new Quaternion(); actual.setUnsafe(0.0, 0.0, 0.0, 0.0); actual.normalize(); EuclidCoreTestTools.assertTuple4DEquals(expected, actual, getEpsilon()); Quaternion q = new Quaternion(); q.setUnsafe(1.0, 1.0, 1.0, 1.0); actual.setAndNormalize(q); assertTrue(actual.isUnitary(getEpsilon())); q.setUnsafe(1.0, 1.0, 1.0, 1.0); actual.setAndNormalize((Orientation3DReadOnly) q); assertTrue(actual.isUnitary(getEpsilon())); }
@Test public void testDifference() { Random random = new Random(65445L); T diff = createEmptyTuple(); T expected = createEmptyTuple(); for (int i = 0; i < ITERATIONS; i++) { T q1 = createRandomTuple(random); T q2 = createRandomTuple(random); diff.difference(q1, q2); QuaternionTools.multiplyConjugateLeft(q1, q2, expected); EuclidCoreTestTools.assertQuaternionEquals(diff, expected, getEpsilon()); } }
@Test public void testIsUnitary() { Random random = new Random(65445L); for (int i = 0; i < ITERATIONS; i++) { T q1 = createRandomTuple(random); assertTrue(q1.isUnitary(getEpsilon())); // Quaternion should have norm = 1 T q2 = createRandomTuple(random); q1 = createTuple(q2.getX(), q2.getY(), q2.getZ(), q2.getS()); assertTrue(q1.isUnitary(getEpsilon())); double delta = 6.0 * Math.sqrt(getEpsilon()); q1 = createTuple(delta + q2.getX(), q2.getY(), q2.getZ(), q2.getS()); assertFalse(q1.isUnitary(getEpsilon())); q1 = createTuple(q2.getX(), delta + q2.getY(), q2.getZ(), q2.getS()); assertFalse(q1.isUnitary(getEpsilon())); q1 = createTuple(q2.getX(), q2.getY(), delta + q2.getZ(), q2.getS()); assertFalse(q1.isUnitary(getEpsilon())); q1 = createTuple(q2.getX(), q2.getY(), q2.getZ(), delta + q2.getS()); assertFalse(q1.isUnitary(getEpsilon())); } }
@Test public void testSetEuler() { Random random = new Random(574631L); T actualQuaternion = createEmptyTuple(); T expectedQuaternion = createEmptyTuple(); Vector3D eulerAngles; for (int i = 0; i < ITERATIONS; i++) { // Test setEuler(Vector3DReadOnly eulerAngles) eulerAngles = EuclidCoreRandomTools.nextRotationVector(random); QuaternionConversion.convertYawPitchRollToQuaternion(eulerAngles.getZ(), eulerAngles.getY(), eulerAngles.getX(), expectedQuaternion); actualQuaternion.setEuler(eulerAngles); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); actualQuaternion.setToZero(); actualQuaternion.setEuler(eulerAngles.getX(), eulerAngles.getY(), eulerAngles.getZ()); EuclidCoreTestTools.assertQuaternionEquals(expectedQuaternion, actualQuaternion, getEpsilon()); } }
@Test public void testDistancePrecise() throws Exception { Random random = new Random(1651L); for (int i = 0; i < ITERATIONS; i++) { QuaternionReadOnly q1 = createRandomTuple(random); for (int j = 0; j < ITERATIONS; j++) { double expectedAngle = random.nextDouble(); AxisAngle aa = new AxisAngle(EuclidCoreRandomTools.nextVector3DWithFixedLength(random, 1.0), expectedAngle); T q2 = createEmptyTuple(); q2.set(aa); q2.preMultiply(q1); double actualAngle = q1.distancePrecise(q2); assertEquals(expectedAngle, actualAngle, getEpsilon()); assertEquals(0.0, q1.distance(q1), 1.0e-3); } } }
@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()); } } }
@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()); } } }
@Test public void testPow() throws Exception { Random random = new Random(541651L); for (int i = 0; i < ITERATIONS; i++) { QuaternionBasics original = createRandomTuple(random); double alpha = EuclidCoreRandomTools.nextDouble(random, 2.0); AxisAngle axisAngle = new AxisAngle(original); axisAngle.setAngle(alpha * axisAngle.getAngle()); QuaternionBasics expected = createEmptyTuple(); expected.set(axisAngle); QuaternionBasics actual = createEmptyTuple(); actual.set(original); actual.pow(alpha); EuclidCoreTestTools.assertQuaternionEquals(expected, actual, getEpsilon()); } }