@Override public Orientation3DBasics createEmptyOrientation3DBasics() { return createEmptyTuple(); }
@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 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 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 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()); } }
@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 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 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()); } }
T expected = createEmptyTuple(); T actual = createEmptyTuple(); T yawRotation = createEmptyTuple(); double yaw = EuclidCoreRandomTools.nextDouble(random, Math.PI); T pitchRotation = createEmptyTuple(); double pitch = EuclidCoreRandomTools.nextDouble(random, Math.PI); T rollRotation = createEmptyTuple(); double roll = EuclidCoreRandomTools.nextDouble(random, Math.PI);
@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 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 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 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()); } } }
@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()); } }
@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()); } } }
@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 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 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()); } } }