more test coverage

MarginallyClever · Jan 16, 2024 · 3eadff8 · 3eadff8
1 parent 918c0b0
commit 3eadff8
Show file tree

Hide file tree

Showing 4 changed files with 199 additions and 7 deletions.
diff --git a/src/main/java/com/marginallyclever/ro3/node/nodes/Camera.java b/src/main/java/com/marginallyclever/ro3/node/nodes/Camera.java
@@ -138,7 +138,6 @@ private void translate(Vector3d direction,double delta) {
 
     /**
      * Rotate relative to camera's current orientation
-     * TODO test
      * @param delta degrees to rotate.  Positive is left.
      */
     public void pan(double delta) {
@@ -147,7 +146,6 @@ public void pan(double delta) {
 
     /**
      * Rotate relative to camera's current orientation
-     * TODO test
      * @param delta degrees to rotate.  Positive is up.
      */
     public void tilt(double delta) {
@@ -156,7 +154,6 @@ public void tilt(double delta) {
 
     /**
      * Rotate relative to camera's current orientation
-     * TODO test
      * @param delta degrees to rotate.  Positive is counter-clockwise.
      */
     public void roll(double delta) {

diff --git a/src/main/java/com/marginallyclever/ro3/node/nodes/DHParameter.java b/src/main/java/com/marginallyclever/ro3/node/nodes/DHParameter.java
@@ -44,7 +44,7 @@ private void toPose() {
         if (pose != null) pose.setLocal(getDHMatrix());
     }
 
-    private Matrix4d getDHMatrix() {
+    Matrix4d getDHMatrix() {
         Matrix4d m = new Matrix4d();
         double rt = Math.toRadians(theta);
         double ra = Math.toRadians(alpha);
@@ -64,7 +64,7 @@ public void fromPose() {
         if (pose != null) setDHMatrix(pose.getLocal());
     }
 
-    private void setDHMatrix(Matrix4d m) {
+    void setDHMatrix(Matrix4d m) {
         // Extract the elements of the matrix
         double m00 = m.m00;
         double m01 = m.m01;
@@ -80,7 +80,9 @@ private void setDHMatrix(Matrix4d m) {
         double m23 = m.m23;
 
         // Check if the pose is DH compatible
-        if (m00 * m10 + m01 * m11 + m02 * m12 != 0 || m20 != 0 || m21 * m21 + m22 * m22 != 1) {
+        if (Math.abs(m00 * m10 + m01 * m11 + m02 * m12)>1e-6 ||
+                Math.abs(m20)>1e-6 ||
+                Math.abs((m21 * m21 + m22 * m22)-1)>1e-6) {
             throw new IllegalArgumentException("The pose is not DH compatible.  pose="+ m);
         }
 

diff --git a/src/test/java/com/marginallyclever/ro3/node/nodes/CameraTest.java b/src/test/java/com/marginallyclever/ro3/node/nodes/CameraTest.java
@@ -1,7 +1,11 @@
 package com.marginallyclever.ro3.node.nodes;
 
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import com.marginallyclever.convenience.helpers.BigMatrixHelper;
+import com.marginallyclever.convenience.helpers.MatrixHelper;
 import com.marginallyclever.ro3.Registry;
 import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.condition.DisabledIfEnvironmentVariable;
 
@@ -10,9 +14,13 @@
 import javax.vecmath.Vector3d;
 
 public class CameraTest {
+    @BeforeAll
+    public static void setup() {
+        Registry.start();
+    }
+
     @Test
     public void testPanTiltInverses() {
-        Registry.start();
         Camera camera = Registry.getActiveCamera();
 
         for (int pan = -180; pan <= 180; pan += 10) {
@@ -26,4 +34,169 @@ public void testPanTiltInverses() {
             }
         }
     }
+
+    @Test
+    public void getSetOrbitRadius() {
+        Camera camera = Registry.getActiveCamera();
+        assert camera != null;
+        camera.setOrbitRadius(1.0);
+        Assertions.assertEquals(1.0, camera.getOrbitRadius(), 0.01);
+        camera.setOrbitRadius(2.0);
+        Assertions.assertEquals(2.0, camera.getOrbitRadius(), 0.01);
+    }
+
+    @Test
+    public void getSetFOVY() {
+        Camera camera = Registry.getActiveCamera();
+        assert camera != null;
+        camera.setFovY(1.0);
+        Assertions.assertEquals(1.0, camera.getFovY(), 0.01);
+        camera.setFovY(2.0);
+        Assertions.assertEquals(2.0, camera.getFovY(), 0.01);
+    }
+
+    @Test
+    public void getSetNearZ() {
+        Camera camera = Registry.getActiveCamera();
+        assert camera != null;
+        camera.setNearZ(1.0);
+        Assertions.assertEquals(1.0, camera.getNearZ(), 0.01);
+        camera.setNearZ(2.0);
+        Assertions.assertEquals(2.0, camera.getNearZ(), 0.01);
+    }
+
+    @Test
+    public void getSetFarZ() {
+        Camera camera = Registry.getActiveCamera();
+        assert camera != null;
+        camera.setFarZ(1.0);
+        Assertions.assertEquals(1.0, camera.getFarZ(), 0.01);
+        camera.setFarZ(2.0);
+        Assertions.assertEquals(2.0, camera.getFarZ(), 0.01);
+    }
+
+    @Test
+    public void pedestal() {
+        Camera camera = new Camera();
+        var p0 = camera.getPosition();
+        camera.pedestal(1.0);
+        var p1 = camera.getPosition();
+        Assertions.assertEquals(p0.x, p1.x, 0.01);
+        Assertions.assertEquals(p0.y + 1.0, p1.y, 0.01);
+        Assertions.assertEquals(p0.z, p1.z, 0.01);
+    }
+
+    @Test
+    public void truck() {
+        Camera camera = new Camera();
+        var p0 = camera.getPosition();
+        camera.truck(1.0);
+        var p1 = camera.getPosition();
+        Assertions.assertEquals(p0.x + 1.0, p1.x, 0.01);
+        Assertions.assertEquals(p0.y, p1.y, 0.01);
+        Assertions.assertEquals(p0.z, p1.z, 0.01);
+    }
+
+    @Test
+    public void dolly() {
+        Camera camera = new Camera();
+        var p0 = camera.getPosition();
+        camera.dolly(1.0);
+        var p1 = camera.getPosition();
+        Assertions.assertEquals(p0.x, p1.x, 0.01);
+        Assertions.assertEquals(p0.y, p1.y, 0.01);
+        Assertions.assertEquals(p0.z + 1.0, p1.z, 0.01);
+    }
+
+    @Test
+    public void tilt() {
+        Camera camera = new Camera();
+        var p0 = camera.getPanTiltFromMatrix(camera.getLocal());
+        camera.tilt(1.0);
+        var p1 = camera.getPanTiltFromMatrix(camera.getLocal());
+        Assertions.assertEquals(p0[0], p1[0], 0.01);
+        Assertions.assertEquals(p0[1] + 1.0, p1[1], 0.01);
+    }
+
+    @Test
+    public void pan() {
+        Camera camera = new Camera();
+        var p0 = camera.getPanTiltFromMatrix(camera.getLocal());
+        camera.tilt(-90.0);
+        camera.pan(90.0);
+        var p1 = camera.getPanTiltFromMatrix(camera.getLocal());
+        Assertions.assertEquals(p0[0], p1[0], 0.01);
+        Assertions.assertEquals(p0[1] - 90, p1[1], 0.01);
+    }
+
+    @Test
+    public void panTilt() {
+        Camera camera = new Camera();
+        camera.panTilt(90.0, 90.0);
+        var p1 = camera.getPanTiltFromMatrix(camera.getLocal());
+        Assertions.assertEquals(90.0, p1[0], 0.01);
+        Assertions.assertEquals(90.0, p1[1], 0.01);
+    }
+
+    @Test
+    public void roll() {
+        Camera camera = new Camera();
+        var p0 = MatrixHelper.getXAxis(camera.getLocal());
+        camera.roll(90.0);
+        var p1 = MatrixHelper.getXAxis(camera.getLocal());
+        Assertions.assertEquals(p0.x-1, p1.x, 0.01);
+        Assertions.assertEquals(p0.y+1, p1.y, 0.01);
+        Assertions.assertEquals(p0.z, p1.z, 0.01);
+    }
+
+    @Test
+    public void orbit() {
+        Camera camera = new Camera();
+        var p0 = camera.getPanTiltFromMatrix(camera.getLocal());
+        camera.getLocal().rotX(Math.toRadians(90));
+        camera.orbit(90.0,-90);
+        var p1 = camera.getPanTiltFromMatrix(camera.getLocal());
+        Assertions.assertEquals(p0[0] + 90.0, p1[0], 0.01);
+        Assertions.assertEquals(p0[1], p1[1], 0.01);
+    }
+
+    @Test
+    public void getViewMatrix() {
+        Camera camera = new Camera();
+        Matrix4d m = camera.getViewMatrix();
+        Assertions.assertArrayEquals(BigMatrixHelper.matrix4dToArray(m),
+                BigMatrixHelper.matrix4dToArray(MatrixHelper.createIdentityMatrix4()), 0.01);
+    }
+
+    @Test
+    public void getProjectionMatrix() {
+        Camera camera = new Camera();
+        Matrix4d m = camera.getChosenProjectionMatrix(800,600);
+        Matrix4d p = new Matrix4d(
+                1.299038105676658, 0.0, 0.0, 0.0,
+                0.0, 1.7320508075688772, 0.0, 0.0,
+                0.0, 0.0, -1.0002000200020002, -1.0,
+                0.0, 0.0, -2.0020002000200020002, 0.0
+        );
+        Assertions.assertArrayEquals(
+                BigMatrixHelper.matrix4dToArray(m),
+                BigMatrixHelper.matrix4dToArray(p), 0.01);
+    }
+
+    @Test
+    public void getOrthographicMatrix() {
+        Camera camera = new Camera();
+        camera.setDrawOrthographic(true);
+        Assertions.assertTrue(camera.getDrawOrthographic());
+        Matrix4d m = camera.getChosenProjectionMatrix(800,600);
+        Matrix4d p = new Matrix4d(
+                0.0025,0.0,0.0,0.0,
+                0.0,0.0033333333333333335,0.0,0.0,
+                0.0,0.0,-0.0020002000200020002,0.0,
+                0.0,0.0,-1.0020002000200020002,1.0
+        );
+        Assertions.assertArrayEquals(
+                BigMatrixHelper.matrix4dToArray(m),
+                BigMatrixHelper.matrix4dToArray(p), 0.01);
+    }
 }
diff --git a/src/test/java/com/marginallyclever/ro3/node/nodes/DHParameterTest.java b/src/test/java/com/marginallyclever/ro3/node/nodes/DHParameterTest.java
@@ -1,5 +1,9 @@
 package com.marginallyclever.ro3.node.nodes;
+import com.marginallyclever.convenience.helpers.MatrixHelper;
 import org.junit.jupiter.api.Test;
+
+import javax.vecmath.Matrix4d;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 class DHParameterTest {
@@ -30,4 +34,20 @@ void testGetTheta() {
         dhParameter.setTheta(40.0);
         assertEquals(40.0, dhParameter.getTheta());
     }
+
+    @Test
+    public void setDHMatrix() {
+    	var a = new DHParameter();
+        a.setD(1.0);
+        a.setR(2.0);
+        a.setAlpha(3.0);
+        a.setTheta(4.0);
+        a.getDHMatrix();
+        var b = new DHParameter();
+    	b.setDHMatrix(a.getDHMatrix());
+    	assertEquals(1.0, b.getD(),1e-6);
+    	assertEquals(2.0, b.getR(),1e-6);
+    	assertEquals(3.0, b.getAlpha(),1e-6);
+    	assertEquals(4.0, b.getTheta(),1e-6);
+    }
 }