[Utils] Clean up coordinates classes and tests

Assets/Scripts/Utils/Coordinates2.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+// Utility functions for 2D coordinates.
+// In Cartesian coordinates, the x-axis points right, and the y-axis points up. The coordinates are
+// given by (x, y).
+// In polar coordinates, the angle is measured in degrees from the x-axis counterclockwise to the
+// y-axis. The coordinates are given by (r, theta).
+public static class Coordinates2 {
+  public static Vector2 ConvertCartesianToPolar(in Vector2 cartesian) {
+    float r = cartesian.magnitude;
+    float theta = Mathf.Atan2(cartesian.y, cartesian.x) * Mathf.Rad2Deg;
+    return new Vector2(r, theta);
+  }
+  public static Vector2 ConvertCartesianToPolar(float x, float y) {
+    return ConvertCartesianToPolar(new Vector2(x, y));
+  }
+
+  public static Vector2 ConvertPolarToCartesian(in Vector2 polar) {
+    float x = polar.x * Mathf.Cos(polar.y * Mathf.Deg2Rad);
+    float y = polar.x * Mathf.Sin(polar.y * Mathf.Deg2Rad);
+    return new Vector2(x, y);
+  }
+  public static Vector2 ConvertPolarToCartesian(float r, float theta) {
+    return ConvertPolarToCartesian(new Vector2(r, theta));
+  }
+}

Assets/Scripts/Utils/Coordinates.cs → Assets/Scripts/Utils/Coordinates3.cs

@@ -1,30 +1,5 @@
 using UnityEngine;
 
-// Utility functions for 2D coordinates.
-// In Cartesian coordinates, the x-axis points right, and the y-axis points up. The coordinates are
-// given by (x, y).
-// In polar coordinates, the angle is measured in degrees from the x-axis counterclockwise to the
-// y-axis. The coordinates are given by (r, theta).
-public static class Coordinates2 {
-  public static Vector2 ConvertCartesianToPolar(in Vector2 cartesian) {
-    float r = cartesian.magnitude;
-    float theta = Mathf.Atan2(cartesian.y, cartesian.x) * Mathf.Rad2Deg;
-    return new Vector2(r, theta);
-  }
-  public static Vector2 ConvertCartesianToPolar(float x, float y) {
-    return ConvertCartesianToPolar(new Vector2(x, y));
-  }
-
-  public static Vector2 ConvertPolarToCartesian(in Vector2 polar) {
-    float x = polar.x * Mathf.Cos(polar.y * Mathf.Deg2Rad);
-    float y = polar.x * Mathf.Sin(polar.y * Mathf.Deg2Rad);
-    return new Vector2(x, y);
-  }
-  public static Vector2 ConvertPolarToCartesian(float r, float theta) {
-    return ConvertPolarToCartesian(new Vector2(r, theta));
-  }
-}
-
 // Utility functions for 3D coordinates.
 // In Cartesian coordinates, the x-axis points right, the y-axis points up, and the z-axis points
 // forward. The coordinates are given by (x, y, z).
@@ -37,11 +12,12 @@ public static class Coordinates3 {
   public static Vector3 ConvertCartesianToSpherical(in Vector3 cartesian) {
     float r = cartesian.magnitude;
     float azimuth = Mathf.Atan2(cartesian.x, cartesian.z) * Mathf.Rad2Deg;
-    float elevation = Mathf.Atan(cartesian.y / Mathf.Sqrt(cartesian.x * cartesian.x +
+    float elevation = Mathf.Atan2(cartesian.y, Mathf.Sqrt(cartesian.x * cartesian.x +
                                                           cartesian.z * cartesian.z)) *
                       Mathf.Rad2Deg;
     return new Vector3(r, azimuth, elevation);
   }
+
   public static Vector3 ConvertCartesianToSpherical(float x, float y, float z) {
     return ConvertCartesianToSpherical(new Vector3(x, y, z));
   }
@@ -54,6 +30,7 @@ public static Vector3 ConvertSphericalToCartesian(in Vector3 spherical) {
               Mathf.Cos(spherical.y * Mathf.Deg2Rad);
     return new Vector3(x, y, z);
   }
+
   public static Vector3 ConvertSphericalToCartesian(float r, float azimuth, float elevation) {
     return ConvertSphericalToCartesian(new Vector3(r, azimuth, elevation));
   }
@@ -64,6 +41,7 @@ public static Vector3 ConvertCartesianToCylindrical(in Vector3 cartesian) {
     float height = cartesian.y;
     return new Vector3(r, azimuth, height);
   }
+
   public static Vector3 ConvertCartesianToCylindrical(float x, float y, float z) {
     return ConvertCartesianToCylindrical(new Vector3(x, y, z));
   }
@@ -74,6 +52,7 @@ public static Vector3 ConvertCylindricalToCartesian(in Vector3 cylindrical) {
     float z = cylindrical.x * Mathf.Cos(cylindrical.y * Mathf.Deg2Rad);
     return new Vector3(x, y, z);
   }
+
   public static Vector3 ConvertCylindricalToCartesian(float r, float azimuth, float height) {
     return ConvertCylindricalToCartesian(new Vector3(r, azimuth, height));
   }

Assets/Tests/EditMode/Coordinates2Tests.cs

@@ -0,0 +1,90 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools.Utils;
+
+public class Coordinates2Tests {
+  private const float _epsilon = 1e-4f;
+
+  [Test]
+  public void ConvertCartesianToPolar_Origin_ReturnsZeroDistance() {
+    var cartesian = Vector2.zero;
+    Vector2 polar = Coordinates2.ConvertCartesianToPolar(cartesian);
+    Assert.AreEqual(0, polar.x, _epsilon);
+    Assert.IsFalse(float.IsNaN(polar.y));
+  }
+
+  [Test]
+  public void ConvertCartesianToPolar_OnXAxis_ReturnsZeroTheta() {
+    var cartesian = new Vector2(5, 0);
+    var expectedPolar = new Vector2(5.0f, 0.0f);
+    Vector2 actualPolar = Coordinates2.ConvertCartesianToPolar(cartesian);
+    Assert.That(actualPolar, Is.EqualTo(expectedPolar).Using(Vector2EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void ConvertCartesianToPolar_OnYAxis_ReturnsNinetyTheta() {
+    var cartesian = new Vector2(0, 5);
+    var expectedPolar = new Vector2(5.0f, 90.0f);
+    Vector2 actualPolar = Coordinates2.ConvertCartesianToPolar(cartesian);
+    Assert.That(actualPolar, Is.EqualTo(expectedPolar).Using(Vector2EqualityComparer.Instance));
+  }
+
+  [Test]
+  [TestCase(0f)]
+  [TestCase(45f)]
+  [TestCase(90f)]
+  [TestCase(180f)]
+  [TestCase(360f)]
+  public void ConvertPolarToCartesian_ZeroDistance_ReturnsOrigin(float theta) {
+    var polar = new Vector2(0, theta);
+    var expectedCartesian = Vector2.zero;
+    Vector2 actualCartesian = Coordinates2.ConvertPolarToCartesian(polar);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector2EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void ConvertPolarToCartesian_ZeroTheta_ReturnsOnXAxis() {
+    var polar = new Vector2(10, 0);
+    var expectedCartesian = new Vector2(10.0f, 0.0f);
+    Vector2 actualCartesian = Coordinates2.ConvertPolarToCartesian(polar);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector2EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void ConvertPolarToCartesian_NinetyTheta_ReturnsOnYAxis() {
+    Vector2 polar = new Vector2(10, 90);
+    Vector2 expectedCartesian = new Vector2(0.0f, 10.0f);
+    Vector2 actualCartesian = Coordinates2.ConvertPolarToCartesian(polar);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector2EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void ConvertPolarToCartesian_ThirtyTheta() {
+    var polar = new Vector2(20, 30);
+    var expectedCartesian = new Vector2(10 * Mathf.Sqrt(3), 10);
+    Vector2 actualCartesian = Coordinates2.ConvertPolarToCartesian(polar);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector2EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void ConvertPolarToCartesian_FortyFiveTheta() {
+    var polar = new Vector2(10 * Mathf.Sqrt(2), 45);
+    var expectedCartesian = new Vector2(10.0f, 10.0f);
+    Vector2 actualCartesian = Coordinates2.ConvertPolarToCartesian(polar);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector2EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void RoundTrip_CartesianToPolarToCartesian_ReturnsOriginal() {
+    var originalCartesian = new Vector2(3.5f, 7.2f);
+    Vector2 polar = Coordinates2.ConvertCartesianToPolar(originalCartesian);
+    Vector2 resultCartesian = Coordinates2.ConvertPolarToCartesian(polar);
+    Assert.That(resultCartesian,
+                Is.EqualTo(originalCartesian).Using(Vector2EqualityComparer.Instance));
+  }
+}

Assets/Tests/EditMode/Coordinates3Tests.cs

@@ -0,0 +1,120 @@
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools.Utils;
+
+public class Coordinates3Tests {
+  private const float _epsilon = 1e-4f;
+
+  [Test]
+  public void ConvertCartesianToSpherical_Origin_ReturnsZeroDistance() {
+    var cartesian = Vector3.zero;
+    Vector3 spherical = Coordinates3.ConvertCartesianToSpherical(cartesian);
+    Assert.AreEqual(0, spherical.x, _epsilon);
+    Assert.IsFalse(float.IsNaN(spherical.y));
+    Assert.IsFalse(float.IsNaN(spherical.z));
+  }
+
+  [Test]
+  public void ConvertCartesianToSpherical_ReturnsCorrectly() {
+    var cartesian = new Vector3(2, -1, 3);
+    var expectedSpherical = new Vector3(Mathf.Sqrt(14), 33.690068f, -15.501360f);
+    Vector3 actualSpherical = Coordinates3.ConvertCartesianToSpherical(cartesian);
+    Assert.That(actualSpherical,
+                Is.EqualTo(expectedSpherical).Using(Vector3EqualityComparer.Instance));
+  }
+
+  [Test]
+  [TestCase(0f, 0f)]
+  [TestCase(45f, 0f)]
+  [TestCase(90f, 0f)]
+  [TestCase(180f, 0f)]
+  [TestCase(360f, 0f)]
+  [TestCase(45f, 45f)]
+  [TestCase(45f, 90f)]
+  [TestCase(45f, 180f)]
+  [TestCase(45f, 360f)]
+  public void ConvertSphericalToCartesian_ZeroDistance_ReturnsOrigin(float theta, float phi) {
+    var spherical = new Vector3(0, theta, phi);
+    var expectedCartesian = Vector3.zero;
+    Vector3 actualCartesian = Coordinates3.ConvertSphericalToCartesian(spherical);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector3EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void ConvertSphericalToCartesian_ReturnsCorrectly() {
+    var spherical = new Vector3(10, 60, 30);
+    var expectedCartesian = new Vector3(7.5f, 5.0f, 4.3301270189221945f);
+    Vector3 actualCartesian = Coordinates3.ConvertSphericalToCartesian(spherical);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector3EqualityComparer.Instance));
+  }
+
+  [TestCase(1.5f, 2.5f, 3.5f)]
+  [TestCase(-1, 2, 3)]
+  [TestCase(-12, 0, 0)]
+  [TestCase(0, 5, 0)]
+  [TestCase(0, 0, -10)]
+  public void RoundTrip_CartesianToSphericalToCartesian_ReturnsOriginal(float x, float y, float z) {
+    var originalCartesian = new Vector3(x, y, z);
+    Vector3 spherical = Coordinates3.ConvertCartesianToSpherical(originalCartesian);
+    Vector3 resultCartesian = Coordinates3.ConvertSphericalToCartesian(spherical);
+    Assert.That(resultCartesian,
+                Is.EqualTo(originalCartesian).Using(Vector3EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void ConvertCartesianToCylindrical_Origin_ReturnsZeroDistanceZeroHeight() {
+    var cartesian = Vector3.zero;
+    Vector3 cylindrical = Coordinates3.ConvertCartesianToCylindrical(cartesian);
+    Assert.AreEqual(0, cylindrical.x, _epsilon);
+    Assert.IsFalse(float.IsNaN(cylindrical.y));
+    Assert.AreEqual(0, cylindrical.z, _epsilon);
+  }
+
+  [Test]
+  public void ConvertCartesianToCylindrical_ReturnsCorrectly() {
+    var cartesian = new Vector3(2, -1, 3);
+    var expectedCylindrical = new Vector3(Mathf.Sqrt(13), 33.6900675f, -1);
+    Vector3 actualCylindrical = Coordinates3.ConvertCartesianToCylindrical(cartesian);
+    Assert.That(actualCylindrical,
+                Is.EqualTo(expectedCylindrical).Using(Vector3EqualityComparer.Instance));
+  }
+
+  [Test]
+  [TestCase(0f)]
+  [TestCase(45f)]
+  [TestCase(90f)]
+  [TestCase(180f)]
+  [TestCase(360f)]
+  public void ConvertCylindricalToCartesian_ZeroDistance_ZeroHeight_ReturnsOrigin(float theta) {
+    var cylindrical = new Vector3(0, theta, 0);
+    var expectedCartesian = Vector3.zero;
+    Vector3 actualCartesian = Coordinates3.ConvertCylindricalToCartesian(cylindrical);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector3EqualityComparer.Instance));
+  }
+
+  [Test]
+  public void ConvertCylindricalToCartesian_ReturnsCorrectly() {
+    var cylindrical = new Vector3(10, 60, 2);
+    var expectedCartesian = new Vector3(8.660254f, 2.0f, 5.0f);
+    Vector3 actualCartesian = Coordinates3.ConvertCylindricalToCartesian(cylindrical);
+    Assert.That(actualCartesian,
+                Is.EqualTo(expectedCartesian).Using(Vector3EqualityComparer.Instance));
+  }
+
+  [TestCase(1.5f, 2.5f, 3.5f)]
+  [TestCase(-1, 2, 3)]
+  [TestCase(-12, 0, 0)]
+  [TestCase(0, 5, 0)]
+  [TestCase(0, 0, -10)]
+  public void RoundTrip_CartesianToCylindricalToCartesian_ReturnsOriginal(float x, float y,
+                                                                          float z) {
+    var originalCartesian = new Vector3(x, y, z);
+    Vector3 cylindrical = Coordinates3.ConvertCartesianToCylindrical(originalCartesian);
+    Vector3 resultCartesian = Coordinates3.ConvertCylindricalToCartesian(cylindrical);
+    Assert.That(resultCartesian,
+                Is.EqualTo(originalCartesian).Using(Vector3EqualityComparer.Instance));
+  }
+}