Rotation2DTest.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.commons.geometry.euclidean.twod.rotation;
import java.util.function.BiFunction;
import java.util.function.DoubleFunction;
import org.apache.commons.geometry.core.GeometryTestUtils;
import org.apache.commons.geometry.euclidean.EuclideanTestUtils;
import org.apache.commons.geometry.euclidean.EuclideanTransform;
import org.apache.commons.geometry.euclidean.twod.AffineTransformMatrix2D;
import org.apache.commons.geometry.euclidean.twod.Line;
import org.apache.commons.geometry.euclidean.twod.Lines;
import org.apache.commons.geometry.euclidean.twod.Vector2D;
import org.apache.commons.numbers.angle.Angle;
import org.apache.commons.numbers.core.Precision;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
class Rotation2DTest {
private static final double TEST_EPS = 1e-10;
private static final Precision.DoubleEquivalence TEST_PRECISION =
Precision.doubleEquivalenceOfEpsilon(TEST_EPS);
private static final double THREE_PI_OVER_TWO = 3 * Math.PI / 2;
@Test
void testIdentity() {
// act
final Rotation2D r = Rotation2D.identity();
// assert
Assertions.assertEquals(0.0, r.getAngle(), 0.0);
Assertions.assertTrue(r.preservesOrientation());
}
@Test
void testProperties() {
// act
final Rotation2D r = Rotation2D.of(100.0);
// assert
Assertions.assertEquals(100.0, r.getAngle(), 0.0);
Assertions.assertTrue(r.preservesOrientation());
}
@Test
void testApply() {
// act/assert
checkApply(1.0, Vector2D.ZERO, Vector2D.ZERO);
checkApply(0.0, Vector2D.Unit.PLUS_X, Vector2D.Unit.PLUS_X);
checkApply(Angle.PI_OVER_TWO, Vector2D.Unit.PLUS_X, Vector2D.Unit.PLUS_Y);
checkApply(Math.PI, Vector2D.Unit.PLUS_X, Vector2D.Unit.MINUS_X);
checkApply(THREE_PI_OVER_TWO, Vector2D.Unit.PLUS_X, Vector2D.Unit.MINUS_Y);
checkApply(Angle.TWO_PI, Vector2D.Unit.PLUS_X, Vector2D.Unit.PLUS_X);
checkRotate(Rotation2D::of, Rotation2D::apply);
}
@Test
void testApplyVector() {
// act/assert
checkApplyVector(1.0, Vector2D.ZERO, Vector2D.ZERO);
checkApplyVector(0.0, Vector2D.Unit.PLUS_X, Vector2D.Unit.PLUS_X);
checkApplyVector(Angle.PI_OVER_TWO, Vector2D.Unit.PLUS_X, Vector2D.Unit.PLUS_Y);
checkApplyVector(Math.PI, Vector2D.Unit.PLUS_X, Vector2D.Unit.MINUS_X);
checkApplyVector(THREE_PI_OVER_TWO, Vector2D.Unit.PLUS_X, Vector2D.Unit.MINUS_Y);
checkApplyVector(Angle.TWO_PI, Vector2D.Unit.PLUS_X, Vector2D.Unit.PLUS_X);
checkRotate(Rotation2D::of, Rotation2D::applyVector);
}
@Test
void testInverse_properties() {
// arrange
final Rotation2D orig = Rotation2D.of(100.0);
// act
final Rotation2D r = orig.inverse();
// assert
Assertions.assertEquals(-100.0, r.getAngle(), 0.0);
Assertions.assertTrue(r.preservesOrientation());
}
@Test
void testInverse_apply() {
// arrange
final Rotation2D orig = Rotation2D.of(100.0);
final Rotation2D inv = orig.inverse();
final Vector2D v1 = Vector2D.of(1, 2);
final Vector2D v2 = Vector2D.of(-3, 4);
final Vector2D v3 = Vector2D.of(-5, -6);
final Vector2D v4 = Vector2D.of(7, -8);
// act/assert
EuclideanTestUtils.assertCoordinatesEqual(v1, orig.apply(inv.apply(v1)), TEST_EPS);
EuclideanTestUtils.assertCoordinatesEqual(v2, inv.apply(orig.apply(v2)), TEST_EPS);
EuclideanTestUtils.assertCoordinatesEqual(v3, orig.apply(inv.apply(v3)), TEST_EPS);
EuclideanTestUtils.assertCoordinatesEqual(v4, inv.apply(orig.apply(v4)), TEST_EPS);
}
@Test
void testToMatrix() {
// arrange
final double angle = 0.1 * Math.PI;
// act
final AffineTransformMatrix2D m = Rotation2D.of(angle).toMatrix();
// assert
final double sin = Math.sin(angle);
final double cos = Math.cos(angle);
final double[] expected = {
cos, -sin, 0,
sin, cos, 0
};
Assertions.assertArrayEquals(expected, m.toArray(), 0.0);
}
@Test
void testToMatrix_apply() {
// act/assert
checkRotate(angle -> Rotation2D.of(angle).toMatrix(), AffineTransformMatrix2D::apply);
}
@Test
void testCreateRotationVector() {
// arrange
final double min = -8;
final double max = 8;
final double step = 1;
EuclideanTestUtils.permuteSkipZero(min, max, step, (ux, uy) -> {
EuclideanTestUtils.permuteSkipZero(min, max, step, (vx, vy) -> {
final Vector2D u = Vector2D.of(ux, uy);
final Vector2D v = Vector2D.of(vx, vy);
// act
final Rotation2D r = Rotation2D.createVectorRotation(u, v);
// assert
EuclideanTestUtils.assertCoordinatesEqual(v.normalize(), r.apply(u).normalize(), TEST_EPS); // u -> v
Assertions.assertEquals(0.0, v.dot(r.apply(u.orthogonal())), TEST_EPS); // preserves orthogonality
});
});
}
@Test
void testCreateRotationVector_invalidVectors() {
// arrange
final Vector2D vec = Vector2D.of(1, 1);
final Vector2D zero = Vector2D.ZERO;
final Vector2D nan = Vector2D.NaN;
final Vector2D posInf = Vector2D.POSITIVE_INFINITY;
final Vector2D negInf = Vector2D.POSITIVE_INFINITY;
// act/assert
Assertions.assertThrows(IllegalArgumentException.class, () -> Rotation2D.createVectorRotation(zero, vec));
Assertions.assertThrows(IllegalArgumentException.class, () -> Rotation2D.createVectorRotation(vec, zero));
Assertions.assertThrows(IllegalArgumentException.class, () -> Rotation2D.createVectorRotation(nan, vec));
Assertions.assertThrows(IllegalArgumentException.class, () -> Rotation2D.createVectorRotation(vec, nan));
Assertions.assertThrows(IllegalArgumentException.class, () -> Rotation2D.createVectorRotation(posInf, vec));
Assertions.assertThrows(IllegalArgumentException.class, () -> Rotation2D.createVectorRotation(vec, negInf));
Assertions.assertThrows(IllegalArgumentException.class, () -> Rotation2D.createVectorRotation(zero, nan));
Assertions.assertThrows(IllegalArgumentException.class, () -> Rotation2D.createVectorRotation(negInf, posInf));
}
@Test
void testHashCode() {
// arrange
final Rotation2D a = Rotation2D.of(1.0);
final Rotation2D b = Rotation2D.of(0.0);
final Rotation2D c = Rotation2D.of(-1.0);
final Rotation2D d = Rotation2D.of(1.0);
final int hash = a.hashCode();
// act/assert
Assertions.assertEquals(hash, a.hashCode());
Assertions.assertNotEquals(hash, b.hashCode());
Assertions.assertNotEquals(hash, c.hashCode());
Assertions.assertEquals(hash, d.hashCode());
}
@Test
void testEquals() {
// arrange
final Rotation2D a = Rotation2D.of(1.0);
final Rotation2D b = Rotation2D.of(0.0);
final Rotation2D c = Rotation2D.of(-1.0);
final Rotation2D d = Rotation2D.of(1.0);
// act/assert
GeometryTestUtils.assertSimpleEqualsCases(a);
Assertions.assertNotEquals(a, b);
Assertions.assertNotEquals(a, c);
Assertions.assertEquals(a, d);
Assertions.assertEquals(d, a);
}
@Test
void testToString() {
// arrange
final Rotation2D r = Rotation2D.of(1.0);
// act
final String str = r.toString();
// assert
Assertions.assertEquals("Rotation2D[angle=1.0]", str);
}
private static void checkApply(final double angle, final Vector2D pt, final Vector2D expectedPt) {
final Rotation2D r = Rotation2D.of(angle);
EuclideanTestUtils.assertCoordinatesEqual(expectedPt, r.apply(pt), TEST_EPS);
}
private static void checkApplyVector(final double angle, final Vector2D pt, final Vector2D expectedPt) {
final Rotation2D r = Rotation2D.of(angle);
EuclideanTestUtils.assertCoordinatesEqual(expectedPt, r.applyVector(pt), TEST_EPS);
}
/** Check a rotation transform for consistency against a variety of points and rotation angles.
* @param factory function used to create a rotation transform from an input angle
* @param transformFn function that accepts the transform and a point and returns
* the transformed point
*/
private static <T extends EuclideanTransform<Vector2D>> void checkRotate(
final DoubleFunction<T> factory, final BiFunction<T, Vector2D, Vector2D> transformFn) {
// check zero
final T transform = factory.apply(0);
EuclideanTestUtils.assertCoordinatesEqual(Vector2D.ZERO, transformFn.apply(transform, Vector2D.ZERO), TEST_EPS);
// check a variety of non-zero points
EuclideanTestUtils.permuteSkipZero(-2, -2, 1, (x, y) -> {
checkRotatePoint(Vector2D.of(x, y), factory, transformFn);
});
}
/** Check a rotation transform for consistency when transforming a single point against a
* variety of rotation angles.
* @param pt point to transform
* @param factory function used to create a rotation transform from an input angle
* @param transformFn function that accepts the transform and a point and returns
* the transformed point
*/
private static <T extends EuclideanTransform<Vector2D>> void checkRotatePoint(
final Vector2D pt, final DoubleFunction<T> factory, final BiFunction<T, ? super Vector2D, ? extends Vector2D> transformFn) {
// arrange
final double limit = 4 * Math.PI;
final double inc = 0.25;
final Line line = Lines.fromPointAndDirection(Vector2D.ZERO, pt, TEST_PRECISION);
T transform;
Vector2D resultPt;
Line resultLine;
for (double angle = -limit; angle < limit; angle += inc) {
transform = factory.apply(angle);
// act
resultPt = transformFn.apply(transform, pt);
// assert
// check that the norm is unchanged
Assertions.assertEquals(pt.norm(), resultPt.norm(), TEST_EPS);
resultLine = Lines.fromPointAndDirection(Vector2D.ZERO, resultPt, TEST_PRECISION);
final double lineAngle = line.angle(resultLine);
// check that the angle is what we expect
Assertions.assertEquals(Angle.Rad.WITHIN_MINUS_PI_AND_PI.applyAsDouble(angle), lineAngle, TEST_EPS);
}
}
}