@Override public AffineTransform createRandomTransform2D(Random random) { AffineTransform transfom2D = new AffineTransform(); transfom2D.setRotationYaw(2.0 * Math.PI * random.nextDouble() - Math.PI); transfom2D.setTranslation(EuclidCoreRandomTools.nextVector3D(random)); transfom2D.setScale(random.nextDouble(), random.nextDouble(), 1.0); return transfom2D; } }
public void rotate(double angle, Axis axis) { switch (axis) { case X: transform.appendRollRotation(angle); break; case Y: transform.appendPitchRotation(angle); break; case Z: transform.appendYawRotation(angle); break; default: throw new RuntimeException("Unhandled value of Axis: " + axis); } }
@Test public void testTransformWithAffineTransform() throws Exception { Random random = new Random(23423L); AffineTransform transform = EuclidCoreRandomTools.nextAffineTransform(random); RigidBodyTransform originalRigidBodyTransform = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform expectedRigidBodyTransform = new RigidBodyTransform(); Vector3D scale = EuclidCoreRandomTools.nextVector3D(random, 0.0, 10.0); AffineTransform original = new AffineTransform(originalRigidBodyTransform); original.setScale(scale); AffineTransform expected = new AffineTransform(); AffineTransform actual = new AffineTransform(); transform.transform(originalRigidBodyTransform, expectedRigidBodyTransform); expected.set(expectedRigidBodyTransform); expected.setScale(scale); transform.transform(original, actual); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); actual.set(original); transform.transform(actual); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); RigidBodyTransform inverse = new RigidBodyTransform(); transform.getRigidBodyTransform(inverse); inverse.invert(); inverse.transform(original, expected); transform.inverseTransform(original, actual); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); actual.set(original); transform.inverseTransform(actual); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); }
public void translateTo(Vector3D translation) { transform.setIdentity(); transform.setTranslation(translation); }
public AffineTransform generateTransform(AffineTransform init) { AffineTransform rotated = new AffineTransform(init); rotated.multiply(incrementalRotation); return rotated; } }
AffineTransform actual = new AffineTransform(); actual.setIdentity(); double m00 = expected.getM00(); double m01 = expected.getM01(); double m02 = expected.getM02(); double m03 = expected.getM03(); double m10 = expected.getM10(); double m11 = expected.getM11(); double m12 = expected.getM12(); double m13 = expected.getM13(); double m20 = expected.getM20(); double m21 = expected.getM21(); double m22 = expected.getM22(); double m23 = expected.getM23(); actual.set(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); actual.setIdentity(); actual.set(expected); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); actual.setIdentity(); actual.set(rigidBodyTransform); assertTrue(rigidBodyTransform.getElement(row, column) == actual.getElement(row, column)); actual.setIdentity(); DenseMatrix64F denseMatrix = new DenseMatrix64F(4, 4);
@Override protected void computeRotationTranslation(AffineTransform transform3D) { transform3D.setIdentity(); if (isUsingYawPitchRoll()) { yoFrameYawPitchRoll.getEulerAngles(rotationEulerVector); transform3D.setRotationEuler(rotationEulerVector); } else { transform3D.setRotation(yoFrameQuaternion); } transform3D.setTranslation(yoFramePoint); transform3D.setScale(scale); }
@Test public void testMultiply() throws Exception { Random random = new Random(2342L); // Test against RigidBodyTransform.multiply() for (int i = 0; i < ITERATIONS; i++) { AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform expected = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform actual = EuclidCoreRandomTools.nextAffineTransform(random); RigidBodyTransform expectedRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); AffineTransform multipliedWith = EuclidCoreRandomTools.nextAffineTransform(random); original.getRigidBodyTransform(expectedRigidBody); expectedRigidBody.multiply(multipliedWith); expected.set(expectedRigidBody); expected.setScale(original.getScale()); actual.set(original); actual.multiply(multipliedWith); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); } }
AffineTransform expected = new AffineTransform(); AffineTransform actual = new AffineTransform(); RotationScaleMatrix expectedRotation = new RotationScaleMatrix(original.getRotationScaleMatrix()); double yaw = EuclidCoreRandomTools.nextDouble(random, Math.PI); expectedRotation.appendYawRotation(yaw); expected.set(expectedRotation, original.getTranslationVector()); actual.set(original); actual.appendYawRotation(yaw); RotationScaleMatrix expectedRotation = new RotationScaleMatrix(original.getRotationScaleMatrix()); double pitch = EuclidCoreRandomTools.nextDouble(random, Math.PI); expectedRotation.appendPitchRotation(pitch); expected.set(expectedRotation, original.getTranslationVector()); actual.set(original); actual.appendPitchRotation(pitch); RotationScaleMatrix expectedRotation = new RotationScaleMatrix(original.getRotationScaleMatrix()); double roll = EuclidCoreRandomTools.nextDouble(random, Math.PI); expectedRotation.appendRollRotation(roll); expected.set(expectedRotation, original.getTranslationVector()); actual.set(original); actual.appendRollRotation(roll);
@Test public void testMultiplyInvertOther() throws Exception { Random random = new Random(2342L); // Test against RigidBodyTransform.multiply() for (int i = 0; i < ITERATIONS; i++) { AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform expected = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform actual = EuclidCoreRandomTools.nextAffineTransform(random); RigidBodyTransform expectedRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); AffineTransform multipliedWith = EuclidCoreRandomTools.nextAffineTransform(random); original.getRigidBodyTransform(expectedRigidBody); expectedRigidBody.multiplyInvertOther(multipliedWith); expected.set(expectedRigidBody); expected.setScale(original.getScale()); actual.set(original); actual.multiplyInvertOther(multipliedWith); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); } }
@Test public void testPreMultiplyInvertOther() throws Exception { Random random = new Random(2342L); // Test against RigidBodyTransform.multiply() for (int i = 0; i < ITERATIONS; i++) { AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform expected = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform actual = EuclidCoreRandomTools.nextAffineTransform(random); RigidBodyTransform expectedRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); AffineTransform multipliedWith = EuclidCoreRandomTools.nextAffineTransform(random); original.getRigidBodyTransform(expectedRigidBody); expectedRigidBody.preMultiplyInvertOther(multipliedWith); expected.set(expectedRigidBody); expected.setScale(original.getScale()); actual.set(original); actual.preMultiplyInvertOther(multipliedWith); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); } }
@Test public void testPreMultiplyInvertThisWithRigidBodyTransform() throws Exception { Random random = new Random(2342L); // Test against RigidBodyTransform.multiply() for (int i = 0; i < ITERATIONS; i++) { AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform expected = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform actual = EuclidCoreRandomTools.nextAffineTransform(random); RigidBodyTransform expectedRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform multipliedWith = EuclidCoreRandomTools.nextRigidBodyTransform(random); original.getRigidBodyTransform(expectedRigidBody); expectedRigidBody.preMultiplyInvertThis(multipliedWith); expected.set(expectedRigidBody); expected.setScale(original.getScale()); actual.set(original); actual.preMultiplyInvertThis(multipliedWith); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); } }
@Test public void testMultiplyInvertThis() throws Exception { Random random = new Random(2342L); // Test against RigidBodyTransform.multiply() for (int i = 0; i < ITERATIONS; i++) { AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform expected = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform actual = EuclidCoreRandomTools.nextAffineTransform(random); RigidBodyTransform expectedRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); AffineTransform multipliedWith = EuclidCoreRandomTools.nextAffineTransform(random); original.getRigidBodyTransform(expectedRigidBody); expectedRigidBody.multiplyInvertThis(multipliedWith); expected.set(expectedRigidBody); expected.setScale(original.getScale()); actual.set(original); actual.multiplyInvertThis(multipliedWith); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); } }
AffineTransform t2 = new AffineTransform(); double epsilon = 1.0e-3; double[] rot = new double[9]; Vector3D translation = new Vector3D(); assertFalse(t1.epsilonEquals(t2, epsilon)); t2.set(t1); assertTrue(t1.epsilonEquals(t2, epsilon)); t2.set(t1); assertTrue(t1.epsilonEquals(t2, epsilon)); t1.getRotation(rot); rot[3 * row + column] += 0.999 * epsilon; ((RotationMatrix) t2.getRotationMatrix()).setUnsafe(rot[0], rot[1], rot[2], rot[3], rot[4], rot[5], rot[6], rot[7], rot[8]); assertTrue(t1.epsilonEquals(t2, epsilon)); t2.set(t1); assertTrue(t1.epsilonEquals(t2, epsilon)); t1.getRotation(rot); rot[3 * row + column] += 1.001 * epsilon; ((RotationMatrix) t2.getRotationMatrix()).setUnsafe(rot[0], rot[1], rot[2], rot[3], rot[4], rot[5], rot[6], rot[7], rot[8]); assertFalse(t1.epsilonEquals(t2, epsilon)); t2.set(t1); assertTrue(t1.epsilonEquals(t2, epsilon)); t1.getRotation(rot); rot[3 * row + column] -= 0.999 * epsilon; ((RotationMatrix) t2.getRotationMatrix()).setUnsafe(rot[0], rot[1], rot[2], rot[3], rot[4], rot[5], rot[6], rot[7], rot[8]); assertTrue(t1.epsilonEquals(t2, epsilon));
public void run() { rotation += 0.01; translation += 0.01; if (scalingDown) { scale = scale * 0.99; if (scale < 0.1) scalingDown = false; } else { scale = scale * 1.01; if (scale > 2.0) scalingDown = true; } AffineTransform transform = new AffineTransform(); transform.setRotationEuler(Math.PI/2.0, 0.0, rotation); transform.setTranslation(new Vector3D(translation, 0.0, 0.0)); transform.setScale(scale); node.setTransform(transform); } }
transformToCanvasSpace = new AffineTransform(); transformToCanvasSpace.setScale(50.0, 50.0, 1.0);
AffineTransform expected = new AffineTransform(); AffineTransform actual = new AffineTransform(); AffineTransform yawTransform = new AffineTransform(); yawTransform.setRotationYaw(yaw); expected.set(original); expected.preMultiply(yawTransform); actual.set(original); actual.prependYawRotation(yaw); AffineTransform pitchTransform = new AffineTransform(); pitchTransform.setRotationPitch(pitch); expected.set(original); expected.preMultiply(pitchTransform); actual.set(original); actual.prependPitchRotation(pitch); AffineTransform rollTransform = new AffineTransform(); rollTransform.setRotationRoll(roll); expected.set(original); expected.preMultiply(rollTransform); actual.set(original); actual.prependRollRotation(roll);
@Test public void testPreMultiply() throws Exception { Random random = new Random(2342L); // Test against RigidBodyTransform.multiply() for (int i = 0; i < ITERATIONS; i++) { AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform expected = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform actual = EuclidCoreRandomTools.nextAffineTransform(random); RigidBodyTransform expectedRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); AffineTransform multipliedWith = EuclidCoreRandomTools.nextAffineTransform(random); original.getRigidBodyTransform(expectedRigidBody); expectedRigidBody.preMultiply(multipliedWith); expected.set(expectedRigidBody); expected.setScale(original.getScale()); actual.set(original); actual.preMultiply(multipliedWith); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); } }
RotationScaleMatrixReadOnly actualRotationScale = transform.getRotationScaleMatrix(); Vector3DReadOnly actualTranslation = transform.getTranslationVector(); RotationScaleMatrix expectedRotationScale = new RotationScaleMatrix(); Vector3D expectedTranslation = new Vector3D(); transform.getTranslation(expectedTranslation); transform.getRotationScale(expectedRotationScale); expectedRotationScale.setRotation(axisAngle); transform.setRotation(axisAngle); EuclidCoreTestTools.assertMatrix3DEquals(expectedRotationScale, actualRotationScale, EPS); EuclidCoreTestTools.assertTuple3DEquals(expectedTranslation, actualTranslation, EPS); transform.getRotationScale(expectedRotationScale); expectedRotationScale.setRotation(rotationVector); transform.setRotation(rotationVector); EuclidCoreTestTools.assertMatrix3DEquals(expectedRotationScale, actualRotationScale, EPS); EuclidCoreTestTools.assertTuple3DEquals(expectedTranslation, actualTranslation, EPS); DenseMatrix64F denseMatrix = new DenseMatrix64F(3, 3); rotationMatrix.get(denseMatrix); transform.getRotationScale(expectedRotationScale); expectedRotationScale.setRotation(rotationMatrix); transform.setRotation(denseMatrix); EuclidCoreTestTools.assertMatrix3DEquals(expectedRotationScale, actualRotationScale, EPS); EuclidCoreTestTools.assertTuple3DEquals(expectedTranslation, actualTranslation, EPS); transform.getRotationScale(expectedRotationScale); expectedRotationScale.setRotation(quaternion); transform.setRotation(quaternion);
@Test public void testTransformWithAffineTransform() throws Exception { Random random = new Random(23423L); QuaternionBasedTransform transform = EuclidCoreRandomTools.nextQuaternionBasedTransform(random); RigidBodyTransform originalRigidBodyTransform = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform expectedRigidBodyTransform = new RigidBodyTransform(); Vector3D scale = EuclidCoreRandomTools.nextVector3D(random, 0.0, 10.0); AffineTransform original = new AffineTransform(originalRigidBodyTransform); original.setScale(scale); AffineTransform expected = new AffineTransform(); AffineTransform actual = new AffineTransform(); transform.transform(originalRigidBodyTransform, expectedRigidBodyTransform); expected.set(expectedRigidBodyTransform); expected.setScale(scale); transform.transform(original, actual); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); actual.set(original); transform.transform(actual); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); RigidBodyTransform inverse = new RigidBodyTransform(transform); inverse.invert(); inverse.transform(original, expected); transform.inverseTransform(original, actual); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); actual.set(original); transform.inverseTransform(actual); EuclidCoreTestTools.assertAffineTransformEquals(expected, actual, EPS); }