public YoGraphic(String name) { this.name = name; objectTransform = new AffineTransform(); }
public AffineTransform generateTransform(AffineTransform init) { AffineTransform rotated = new AffineTransform(init); rotated.multiply(incrementalRotation); return rotated; } }
@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 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); } }
@Test public void testToString() throws Exception { Random random = new Random(12345L); AffineTransform affA; AffineTransform affB; for (int i = 0; i < ITERATIONS; ++i) { affA = EuclidCoreRandomTools.nextAffineTransform(random); affB = EuclidCoreRandomTools.nextAffineTransform(random); assertNotEquals(affA.toString(), affB.toString()); } for (int i = 0; i < ITERATIONS; ++i) { affA = EuclidCoreRandomTools.nextAffineTransform(random); affB = new AffineTransform(affA); assertEquals(affA.toString(), affB.toString()); } }
@Test public void testResetScale() throws Exception { Random random = new Random(42353L); AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform transform = new AffineTransform(original); RotationMatrix rotation = new RotationMatrix(); original.getRotation(rotation); transform.resetScale(); for (int row = 0; row < 3; row++) { for (int column = 0; column < 3; column++) assertTrue(transform.getElement(row, column) == rotation.getElement(row, column)); assertTrue(transform.getElement(row, 3) == original.getElement(row, 3)); } }
@Test public void testResetTranslation() throws Exception { Random random = new Random(42353L); AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform transform = new AffineTransform(original); transform.setTranslationToZero(); for (int row = 0; row < 4; row++) { for (int column = 0; column < 4; column++) { if (column < 3) assertTrue(transform.getElement(row, column) == original.getElement(row, column)); else if (row == column) assertTrue(transform.getElement(row, column) == 1.0); else assertTrue(transform.getElement(row, column) == 0.0); } } }
@Test public void testHashCode() throws Exception { Random random = new Random(12345L); RotationScaleMatrix rsm; Vector3D translation; AffineTransform affine = EuclidCoreRandomTools.nextAffineTransform(random); int newHashCode, previousHashCode; newHashCode = affine.hashCode(); assertEquals(newHashCode, affine.hashCode()); previousHashCode = affine.hashCode(); for (int i = 0; i < ITERATIONS; ++i) { rsm = EuclidCoreRandomTools.nextRotationScaleMatrix(random, 2.0); translation = EuclidCoreRandomTools.nextVector3D(random); affine = new AffineTransform(rsm, translation); newHashCode = affine.hashCode(); assertNotEquals(previousHashCode, newHashCode); previousHashCode = newHashCode; } }
@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); }
@Test public void testTransformWithAffineTransform() throws Exception { Random random = new Random(23423L); RigidBodyTransform transform = EuclidCoreRandomTools.nextRigidBodyTransform(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); }
public void run() { AffineTransform transform = new AffineTransform(); transform.setRotationEuler(nextVector3d(parametersHolder.getRotationTrajectory())); transform.setTranslation(nextVector3d(parametersHolder.getTranslationTrajectory())); transform.setScale(parametersHolder.getScaleTrajectory().getNextValue()); node.setTransform(transform); } public static Vector3D nextVector3d(ImmutableTriple<SimpleBounceTrajectory, SimpleBounceTrajectory, SimpleBounceTrajectory> trajectoryVector)
@Test public void testPreMultiplyInvertThisWithAffineTransform() throws Exception { Random random = new Random(465416L); // Test against multiply(RigidBodyTransform) for (int i = 0; i < ITERATIONS; i++) { RigidBodyTransform original = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform expected = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform actual = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform multipliedWithRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); AffineTransform multipliedWith = new AffineTransform(multipliedWithRigidBody); multipliedWith.setScale(EuclidCoreRandomTools.nextVector3D(random, 0.0, 10.0)); expected.set(original); expected.invert(); expected.preMultiply(multipliedWithRigidBody); actual.set(original); actual.preMultiplyInvertThis(multipliedWith); EuclidCoreTestTools.assertRigidBodyTransformEquals(expected, actual, EPS); actual.preMultiplyInvertThis(new AffineTransform(actual)); assertFalse(actual.hasRotation()); assertFalse(actual.hasTranslation()); expected.setToZero(); EuclidCoreTestTools.assertRigidBodyTransformEquals(expected, actual, EPS); } }
@Test public void testResetRotation() throws Exception { Random random = new Random(42353L); AffineTransform original = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform transform = new AffineTransform(original); transform.setRotationToZero(); for (int row = 0; row < 4; row++) { for (int column = 0; column < 4; column++) { if (column == 3) assertTrue(transform.getElement(row, column) == original.getElement(row, column)); else if (row == column) assertTrue(transform.getElement(row, column) == transform.getRotationScaleMatrix().getScale().getElement(column)); else assertTrue(transform.getElement(row, column) == 0.0); } } }
AffineTransform actual = new AffineTransform(expected); assertAssertionMethodsBehaveProperly(false, methodName, argumentsClass, expected, actual, EPSILON);
@Test public void testContainsNaN() throws Exception { AffineTransform transform = new AffineTransform(); assertFalse(transform.containsNaN()); transform.setRotationToNaN(); assertTrue(transform.containsNaN()); transform.setIdentity(); assertFalse(transform.containsNaN()); transform.setTranslationToNaN(); assertTrue(transform.containsNaN()); }
@Test public void testPreMultiplyWithRigidBodyTransform() throws Exception { Random random = new Random(465416L); // Test against EJML for (int i = 0; i < ITERATIONS; i++) { RigidBodyTransform t1 = EuclidCoreRandomTools.nextRigidBodyTransform(random); AffineTransform t2 = EuclidCoreRandomTools.nextAffineTransform(random); AffineTransform t3 = new AffineTransform(t2); t3.preMultiply(t1); DenseMatrix64F m1 = new DenseMatrix64F(4, 4); DenseMatrix64F m2 = new DenseMatrix64F(4, 4); DenseMatrix64F m3 = new DenseMatrix64F(4, 4); t1.get(m1); t2.get(m2); CommonOps.mult(m1, m2, m3); for (int row = 0; row < 4; row++) for (int column = 0; column < 4; column++) assertEquals(m3.get(row, column), t3.getElement(row, column), EPS); } }
@Test public void testPreMultiplyInvertOtherWithAffineTransform() throws Exception { Random random = new Random(465416L); // Test against multiply(RigidBodyTransform) for (int i = 0; i < ITERATIONS; i++) { RigidBodyTransform original = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform expected = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform actual = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform multipliedWithRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform inverseOfMultipliedWithRigidBody = new RigidBodyTransform(multipliedWithRigidBody); inverseOfMultipliedWithRigidBody.invert(); AffineTransform multipliedWith = new AffineTransform(multipliedWithRigidBody); multipliedWith.setScale(EuclidCoreRandomTools.nextVector3D(random, 0.0, 10.0)); expected.set(original); expected.preMultiply(inverseOfMultipliedWithRigidBody); actual.set(original); actual.preMultiplyInvertOther(multipliedWith); EuclidCoreTestTools.assertRigidBodyTransformEquals(expected, actual, EPS); } }
@Test public void testMultiplyInvertThisWithAffineTransform() throws Exception { Random random = new Random(465416L); // Test against multiply(RigidBodyTransform) for (int i = 0; i < ITERATIONS; i++) { RigidBodyTransform original = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform expected = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform actual = EuclidCoreRandomTools.nextRigidBodyTransform(random); RigidBodyTransform multipliedWithRigidBody = EuclidCoreRandomTools.nextRigidBodyTransform(random); AffineTransform multipliedWith = new AffineTransform(multipliedWithRigidBody); multipliedWith.setScale(EuclidCoreRandomTools.nextVector3D(random, 0.0, 10.0)); expected.set(original); expected.invert(); expected.multiply(multipliedWithRigidBody); actual.set(original); assertTrue(actual.hasRotation()); assertTrue(actual.hasTranslation()); actual.multiplyInvertThis(multipliedWith); assertTrue(actual.hasRotation()); assertTrue(actual.hasTranslation()); EuclidCoreTestTools.assertRigidBodyTransformEquals(expected, actual, EPS); actual.multiplyInvertThis(new AffineTransform(actual)); assertFalse(actual.hasRotation()); assertFalse(actual.hasTranslation()); expected.setToZero(); EuclidCoreTestTools.assertRigidBodyTransformEquals(expected, actual, EPS); } }
RigidBodyTransform inverseOfMultipliedWithRigidBody = new RigidBodyTransform(multipliedWithRigidBody); inverseOfMultipliedWithRigidBody.invert(); AffineTransform multipliedWith = new AffineTransform(multipliedWithRigidBody); multipliedWith.setScale(EuclidCoreRandomTools.nextVector3D(random, 0.0, 10.0)); EuclidCoreTestTools.assertRigidBodyTransformEquals(expected, actual, EPS); actual.multiplyInvertOther(new AffineTransform(actual)); assertFalse(actual.hasRotation()); assertFalse(actual.hasTranslation());
@Test public void testNormalizeRotationPart() throws Exception { Random random = new Random(2342L); RotationScaleMatrix rotationScaleMatrix = EuclidCoreRandomTools.nextRotationScaleMatrix(random, 10.0); Tuple3DReadOnly translation = EuclidCoreRandomTools.nextVector3D(random); AffineTransform affineTransform = new AffineTransform(rotationScaleMatrix, translation); double m00 = rotationScaleMatrix.getRotationMatrix().getM00() + 1.0e-5; double m01 = rotationScaleMatrix.getRotationMatrix().getM01() + 1.0e-5; double m02 = rotationScaleMatrix.getRotationMatrix().getM02() + 1.0e-5; double m10 = rotationScaleMatrix.getRotationMatrix().getM10() + 1.0e-5; double m11 = rotationScaleMatrix.getRotationMatrix().getM11() + 1.0e-5; double m12 = rotationScaleMatrix.getRotationMatrix().getM12() + 1.0e-5; double m20 = rotationScaleMatrix.getRotationMatrix().getM20() + 1.0e-5; double m21 = rotationScaleMatrix.getRotationMatrix().getM21() + 1.0e-5; double m22 = rotationScaleMatrix.getRotationMatrix().getM22() + 1.0e-5; rotationScaleMatrix.getRotationMatrix().setUnsafe(m00, m01, m02, m10, m11, m12, m20, m21, m22); ((RotationMatrix) affineTransform.getRotationMatrix()).setUnsafe(m00, m01, m02, m10, m11, m12, m20, m21, m22); rotationScaleMatrix.normalizeRotationMatrix(); affineTransform.normalizeRotationPart(); EuclidCoreTestTools.assertMatrix3DEquals(rotationScaleMatrix, affineTransform.getRotationScaleMatrix(), EPS); EuclidCoreTestTools.assertTuple3DEquals(translation, affineTransform.getTranslationVector(), EPS); }