Skip to content

Commit

Permalink
Refactor tests, generate tests for each angle dynamically, separate 3…
Browse files Browse the repository at this point in the history 
… test types
  • Loading branch information
@Eirenliel
Eirenliel committed Jul 25, 2021
1 parent 9ecfc57 commit b22a236
Show file tree
Hide file tree
Showing 2 changed files with 133 additions and 315 deletions.
260 changes: 133 additions & 127 deletions ...n/unit/ReferenceAdjustmentsFullTests.java → ...eiren/unit/ReferenceAdjustmentsTests.java
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,131 +10,68 @@
import io.eiren.vr.trackers.ReferenceAdjustedTracker;

import static org.junit.jupiter.api.Assertions.*;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;

import java.util.HashSet;
import java.util.Set;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;

/**
* Tests {@link ReferenceAdjustedTracker#resetFull(Quaternion)}
*/
public class ReferenceAdjustmentsFullTests {

private Set<String> testedTrackerNames = new HashSet<>();

@Test
public void check0to0() {
yawTest(0, 0);
}

@Test
public void check45to0() {
yawTest(0, 45);
}

@Test
public void check90to0() {
yawTest(0, 90);
}
public class ReferenceAdjustmentsTests {

@Test
public void check180to0() {
yawTest(0, 180);
}

@Test
public void check270to0() {
yawTest(0, 270);
}
private static final int[] yaws = {0, 45, 90, 180, 270};
private static final int[] pitches = {0, 15, 35, -15, -35};
private static final int[] rolls = {0, 15, 35, -15, -35};

@Test
public void check0to45() {
yawTest(45, 0);
}

@Test
public void check45to45() {
yawTest(45, 45);
}

@Test
public void check90to45() {
yawTest(45, 90);
}

@Test
public void check180to45() {
yawTest(45, 180);
}

@Test
public void check270to45() {
yawTest(45, 270);
public static List<AnglesSet> getAnglesSet() {
List<AnglesSet> angles = new ArrayList<>();
for(int yaw : yaws) {
for(int pitch : pitches) {
for(int roll : rolls) {
angles.add(new AnglesSet(pitch, yaw, roll));
}
}
}
return angles;
}

@Test
public void check0to90() {
yawTest(90, 0);
}

@Test
public void check45to90() {
yawTest(90, 45);
}

@Test
public void check90to90() {
yawTest(90, 90);
}

@Test
public void check180to90() {
yawTest(90, 180);
}

@Test
public void check270to90() {
yawTest(90, 270);
@TestFactory
Stream<DynamicTest> getTestsYaw() {
return getAnglesSet().stream().map((p) ->
dynamicTest("Adjustment Yaw Test of Tracker(" + p.pitch + "," + p.yaw + "," + p.roll + ")",
() -> {
getAnglesSet().forEach((ref) ->
checkReferenceAdjustmentYaw(q(p.pitch, p.yaw, p.roll), ref.pitch, ref.yaw, ref.roll));
}));
}

@Test
public void check0to180() {
yawTest(180, 0);
}

@Test
public void check45to180() {
yawTest(180, 45);
}

@Test
public void check90to180() {
yawTest(180, 90);
}

@Test
public void check180to180() {
yawTest(180, 180);
}

@Test
public void check270to180() {
yawTest(180, 270);
@TestFactory
Stream<DynamicTest> getTestsFull() {
return getAnglesSet().stream().map((p) ->
dynamicTest("Adjustment Full Test of Tracker(" + p.pitch + "," + p.yaw + "," + p.roll + ")",
() -> {
getAnglesSet().forEach((ref) ->
checkReferenceAdjustmentFull(q(p.pitch, p.yaw, p.roll), ref.pitch, ref.yaw, ref.roll));
}));
}

private void yawTest(int refYaw, int trackerYaw) {
checkReferenceAdjustmentFull(q(0, refYaw, 0), q(0, trackerYaw, 0), refYaw, "Tracker(0," + trackerYaw + ",0/" + refYaw + ")");
checkReferenceAdjustmentFull(q(0, refYaw, 15), q(0, trackerYaw, 0), refYaw, "Tracker(0," + trackerYaw + ",0/" + refYaw + ")");
checkReferenceAdjustmentFull(q(15, refYaw, 0), q(0, trackerYaw, 0), refYaw, "Tracker(0," + trackerYaw + ",0/" + refYaw + ")");
checkReferenceAdjustmentFull(q(15, refYaw, 15), q(0, trackerYaw, 0), refYaw, "Tracker(0," + trackerYaw + ",0/" + refYaw + ")");
checkReferenceAdjustmentFull(q(0, refYaw, 0), q(15, trackerYaw, 0), refYaw, "Tracker(15," + trackerYaw + ",0/" + refYaw + ")");
checkReferenceAdjustmentFull(q(0, refYaw, 15), q(0, trackerYaw, 15), refYaw, "Tracker(0," + trackerYaw + ",0/" + refYaw + ")");
checkReferenceAdjustmentFull(q(15, refYaw, 0), q(15, trackerYaw, 15), refYaw, "Tracker(15," + trackerYaw + ",0/" + refYaw + ")");
checkReferenceAdjustmentFull(q(15, refYaw, 15), q(0, trackerYaw, 15), refYaw, "Tracker(0," + trackerYaw + ",0/" + refYaw + ")");
@TestFactory
Stream<DynamicTest> getTestsForRotation() {
return getAnglesSet().stream().map((p) ->
dynamicTest("Adjustment Rotation Test of Tracker(" + p.pitch + "," + p.yaw + "," + p.roll + ")",
() -> {
getAnglesSet().forEach((ref) ->
testAdjustedTrackerRotation(q(p.pitch, p.yaw, p.roll), ref.pitch, ref.yaw, ref.roll));
}));
}

public void checkReferenceAdjustmentFull(Quaternion referenceQuat, Quaternion trackerQuat, int refYaw, String name) {
public void checkReferenceAdjustmentFull(Quaternion trackerQuat, int refPitch, int refYaw, int refRoll) {
Quaternion referenceQuat = q(refPitch, refYaw, refRoll);
ComputedTracker tracker = new ComputedTracker("test");
tracker.rotation.set(trackerQuat);
ReferenceAdjustedTracker<ComputedTracker> adj = new ReferenceAdjustedTracker<>(tracker);
Expand All @@ -150,30 +87,56 @@ public void checkReferenceAdjustmentFull(Quaternion referenceQuat, Quaternion tr

assertEquals(new QuatEqualFullWithEpsilon(read), new QuatEqualFullWithEpsilon(targetTrackerRotation),
"Adjusted quat is not equal to reference quat (" + toDegs(targetTrackerRotation) + " vs " + toDegs(read) + ")");
testAdjustedTracker(tracker, adj, name, refYaw);
}

public void checkReferenceAdjustmentYaw(Quaternion trackerQuat, int refPitch, int refYaw, int refRoll) {
Quaternion referenceQuat = q(refPitch, refYaw, refRoll);
ComputedTracker tracker = new ComputedTracker("test");
tracker.rotation.set(trackerQuat);
ReferenceAdjustedTracker<ComputedTracker> adj = new ReferenceAdjustedTracker<>(tracker);
adj.resetYaw(referenceQuat);
Quaternion read = new Quaternion();
assertTrue(adj.getRotation(read), "Adjusted tracker didn't return rotation");
assertEquals(new QuatEqualYawWithEpsilon(referenceQuat), new QuatEqualYawWithEpsilon(read),
"Adjusted quat is not equal to reference quat (" + toDegs(referenceQuat) + " vs " + toDegs(read) + ")");
}

public static String toDegs(Quaternion q) {
float[] degs = new float[3];
q.toAngles(degs);
return StringUtils.prettyNumber(degs[0] * FastMath.RAD_TO_DEG, 0) + "," + StringUtils.prettyNumber(degs[1] * FastMath.RAD_TO_DEG, 0) + "," + StringUtils.prettyNumber(degs[2] * FastMath.RAD_TO_DEG, 0);
}

private static final boolean PRINT_TEST_RESULTS = false;

private static int errors = 0;
private static int successes = 0;

private void testAdjustedTracker(ComputedTracker tracker, ReferenceAdjustedTracker<ComputedTracker> adj, String name, int refYaw) {
if(!testedTrackerNames.add(name))
return;
private void testAdjustedTrackerRotation(Quaternion trackerQuat, int refPitch, int refYaw, int refRoll) {
Quaternion referenceQuat = q(refPitch, refYaw, refRoll);
ComputedTracker tracker = new ComputedTracker("test");
tracker.rotation.set(trackerQuat);
ReferenceAdjustedTracker<ComputedTracker> adj = new ReferenceAdjustedTracker<>(tracker);
adj.resetFull(referenceQuat);
Quaternion read = new Quaternion();
assertTrue(adj.getRotation(read), "Adjusted tracker didn't return rotation");

// Use only yaw HMD rotation
Quaternion targetTrackerRotation = new Quaternion(referenceQuat);
float[] angles = new float[3];
targetTrackerRotation.toAngles(angles);
targetTrackerRotation.fromAngles(0, angles[1], 0);

final Quaternion trackerBase = new Quaternion();
trackerBase.set(tracker.rotation);

Quaternion rotation = new Quaternion();
Quaternion rotationCompare = new Quaternion();
Quaternion read = new Quaternion();
Quaternion diff = new Quaternion();
float[] angles = new float[3];
float[] anglesAdj = new float[3];
float[] anglesDiff = new float[3];

TransformNode trackerNode = new TransformNode(name, true);
TransformNode trackerNode = new TransformNode("Tracker", true);
TransformNode rotationNode = new TransformNode("Rot", true);
rotationNode.attachChild(trackerNode);

Expand All @@ -197,13 +160,13 @@ private void testAdjustedTracker(ComputedTracker tracker, ReferenceAdjustedTrack

if(!PRINT_TEST_RESULTS) {
assertTrue(FloatMath.equalsToZero(anglesDiff[0]) && FloatMath.equalsToZero(anglesDiff[1]) && FloatMath.equalsToZero(anglesDiff[2]),
name(name, yaw, pitch, roll, angles, anglesAdj, anglesDiff));
name(yaw, pitch, roll, angles, anglesAdj, anglesDiff));
} else {
if(FloatMath.equalsToZero(anglesDiff[0]) && FloatMath.equalsToZero(anglesDiff[1]) && FloatMath.equalsToZero(anglesDiff[2]))
successes++;
else
errors++;
System.out.println(name(name, yaw, pitch, roll, angles, anglesAdj, anglesDiff));
System.out.println(name(yaw, pitch, roll, angles, anglesAdj, anglesDiff));
}
}
}
Expand All @@ -212,8 +175,8 @@ private void testAdjustedTracker(ComputedTracker tracker, ReferenceAdjustedTrack
System.out.println("Errors: " + errors + ", successes: " + successes);
}

private static String name(String name, int yaw, int pitch, int roll, float[] angles, float[] anglesAdj, float[] anglesDiff) {
return name + ". Rot: " + yaw + "/" + pitch + ". "
private static String name(int yaw, int pitch, int roll, float[] angles, float[] anglesAdj, float[] anglesDiff) {
return "Rot: " + yaw + "/" + pitch + ". "
+ "Angles: " + StringUtils.prettyNumber(angles[0] * FastMath.RAD_TO_DEG, 1) + "/" + StringUtils.prettyNumber(anglesAdj[0] * FastMath.RAD_TO_DEG, 1) + ", "
+ StringUtils.prettyNumber(angles[1] * FastMath.RAD_TO_DEG, 1) + "/" + StringUtils.prettyNumber(anglesAdj[1] * FastMath.RAD_TO_DEG, 1) + ", "
+ StringUtils.prettyNumber(angles[2] * FastMath.RAD_TO_DEG, 1) + "/" + StringUtils.prettyNumber(anglesAdj[2] * FastMath.RAD_TO_DEG, 1) + ". Diff: "
Expand All @@ -222,16 +185,47 @@ private static String name(String name, int yaw, int pitch, int roll, float[] an
+ StringUtils.prettyNumber(anglesDiff[2] * FastMath.RAD_TO_DEG, 1);
}

public static String toDegs(Quaternion q) {
float[] degs = new float[3];
q.toAngles(degs);
return StringUtils.prettyNumber(degs[0] * FastMath.RAD_TO_DEG, 0) + "," + StringUtils.prettyNumber(degs[1] * FastMath.RAD_TO_DEG, 0) + "," + StringUtils.prettyNumber(degs[2] * FastMath.RAD_TO_DEG, 0);
}

public static Quaternion q(float pitch, float yaw, float roll) {
return new Quaternion().fromAngles(pitch * FastMath.DEG_TO_RAD, yaw * FastMath.DEG_TO_RAD, roll * FastMath.DEG_TO_RAD);
}

private static class QuatEqualYawWithEpsilon {

private final Quaternion q;

public QuatEqualYawWithEpsilon(Quaternion q) {
this.q = q;
}

@Override
public String toString() {
return String.valueOf(q);
}

@Override
public int hashCode() {
return q.hashCode();
}

@Override
public boolean equals(Object obj) {
if(obj instanceof Quaternion)
obj = new QuatEqualYawWithEpsilon((Quaternion) obj);
if(!(obj instanceof QuatEqualYawWithEpsilon))
return false;
Quaternion q2 = ((QuatEqualYawWithEpsilon) obj).q;
float[] degs1 = new float[3];
q.toAngles(degs1);
float[] degs2 = new float[3];
q2.toAngles(degs2);
if(degs1[1] < -FloatMath.ANGLE_EPSILON_RAD)
degs1[1] += FastMath.TWO_PI;
if(degs2[1] < -FloatMath.ANGLE_EPSILON_RAD)
degs2[1] += FastMath.TWO_PI;
return FloatMath.equalsWithEpsilon(degs1[1], degs2[1]);
}
}

public static class QuatEqualFullWithEpsilon {

private final Quaternion q;
Expand Down Expand Up @@ -270,4 +264,16 @@ public boolean equals(Object obj) {
&& FloatMath.equalsWithEpsilon(degs1[2], degs2[2]);
}
}
}

public static class AnglesSet {
public final int pitch;
public final int yaw;
public final int roll;

public AnglesSet(int pitch, int yaw, int roll) {
this.pitch = pitch;
this.yaw = yaw;
this.roll = roll;
}
}
}
Loading

0 comments on commit b22a236

Please sign in to comment.