Move to Kotlin primary constructors and export geometry classes to JS

Author: richiksc

build.gradle

@@ -51,6 +51,11 @@ kotlin {
                 implementation kotlin('test-annotations-common')
             }
         }
+        all {
+            languageSettings {
+                useExperimentalAnnotation('kotlin.js.ExperimentalJsExport')
+            }
+        }
     }
 }
 test {

npm-publish.sh

@@ -1,8 +1,8 @@
-./gradlew compileKotlinJs
-./gradlew compileProductionExecutableKotlinJs
-./gradlew jsPublicPackageJson
+./gradlew compileKotlinJs || exit
+./gradlew compileProductionExecutableKotlinJs || exit
+./gradlew jsPublicPackageJson || exit
 
 outputDir=build/compileSync/main/productionExecutable/kotlin
 cp build/tmp/jsPublicPackageJson/package.json $outputDir/
-cd outputDir || exit
+cd $outputDir || exit
 npm publish

src/commonMain/kotlin/com/team254/lib/geometry/Pose2d.kt

@@ -3,6 +3,7 @@ package com.team254.lib.geometry
 import com.team254.lib.splinesutil.Util
 import kotlin.js.ExperimentalJsExport
 import kotlin.js.JsExport
+import kotlin.js.JsName
 import kotlin.jvm.JvmStatic
 
 /**
@@ -13,33 +14,27 @@ import kotlin.jvm.JvmStatic
  */
 @ExperimentalJsExport
 @JsExport
-class Pose2d : IPose2d<Pose2d> {
-    private val translation_: Translation2d
-    private val rotation_: Rotation2d
-
-    constructor() {
-        translation_ = Translation2d()
-        rotation_ = Rotation2d()
-    }
-
-    constructor(x: Double, y: Double, rotation: Rotation2d) {
-        translation_ = Translation2d(x, y)
-        rotation_ = rotation
-    }
+class Pose2d(
+    private val translation_ : Translation2d = Translation2d(),
+    private val rotation_ : Rotation2d = Rotation2d()
+) : IPose2d<Pose2d> {
+
+    @JsName("fromXYRotation")
+    constructor(x: Double, y: Double, rotation: Rotation2d) : this(
+        Translation2d(x, y),
+        rotation
+    )
 
+    @JsName("fromTriple")
     constructor(x: Double, y: Double, rotation: Double): this(
         x, y, Rotation2d.fromDegrees(rotation)
     )
 
-    constructor(translation: Translation2d, rotation: Rotation2d) {
-        translation_ = translation
-        rotation_ = rotation
-    }
-
-    constructor(other: Pose2d) {
-        translation_ = Translation2d(other.translation_)
-        rotation_ = Rotation2d(other.rotation_)
-    }
+    @JsName("copyOf")
+    constructor(other: Pose2d) : this(
+        Translation2d(other.translation_),
+        Rotation2d(other.rotation_)
+    )
 
     override val translation: Translation2d
         get() = translation_
@@ -141,6 +136,12 @@ class Pose2d : IPose2d<Pose2d> {
         return Pose2d(Translation2d(translation.x(), -translation.y()), rotation.inverse())
     }
 
+    override fun hashCode(): Int {
+        var result = translation_.hashCode()
+        result = 31 * result + rotation_.hashCode()
+        return result
+    }
+
     companion object {
         private val kIdentity = Pose2d()
 

src/commonMain/kotlin/com/team254/lib/geometry/Rotation2d.kt

@@ -7,7 +7,7 @@ import com.team254.lib.splinesutil.toDegrees
 import com.team254.lib.splinesutil.toRadians
 import kotlin.js.ExperimentalJsExport
 import kotlin.js.JsExport
-import kotlin.jvm.JvmOverloads
+import kotlin.js.JsName
 import kotlin.jvm.JvmStatic
 
 /**
@@ -18,12 +18,15 @@ import kotlin.jvm.JvmStatic
  */
 @ExperimentalJsExport
 @JsExport
-class Rotation2d : IRotation2d<Rotation2d> {
+class Rotation2d(
+    x: Double = 1.0,
+    y: Double = 0.0,
+    normalize: Boolean = false
+) : IRotation2d<Rotation2d> {
     private val cos_angle_: Double
     private val sin_angle_: Double
 
-    @JvmOverloads
-    constructor(x: Double = 1.0, y: Double = 0.0, normalize: Boolean = false) {
+    init {
         if (normalize) {
             // From trig, we know that sin^2 + cos^2 == 1, but as we do math on this object we might accumulate rounding errors.
             // Normalizing forces us to re-scale the sin and cos to reset rounding errors.
@@ -41,11 +44,13 @@ class Rotation2d : IRotation2d<Rotation2d> {
         }
     }
 
-    constructor(other: Rotation2d) {
-        cos_angle_ = other.cos_angle_
-        sin_angle_ = other.sin_angle_
-    }
+    @JsName("copyOf")
+    constructor(other: Rotation2d) : this(
+        other.cos_angle_,
+        other.sin_angle_
+    )
 
+    @JsName("fromTranslation")
     constructor(direction: Translation2d, normalize: Boolean) : this(
         direction.x(),
         direction.y(),

src/commonMain/kotlin/com/team254/lib/geometry/Translation2d.kt

@@ -4,56 +4,50 @@ import com.team254.lib.splinesutil.Util
 import com.team254.lib.splinesutil.format
 import kotlin.js.ExperimentalJsExport
 import kotlin.js.JsExport
+import kotlin.js.JsName
 import kotlin.jvm.JvmStatic
 
 /**
  * A translation in a 2d coordinate frame. Translations are simply shifts in an (x, y) plane.
  */
 @ExperimentalJsExport
 @JsExport
-class Translation2d : ITranslation2d<Translation2d> {
-    private val x_: Double
-    private val y_: Double
+class Translation2d(
+    private val x: Double,
+    private val y: Double
+) : ITranslation2d<Translation2d> {
 
-    constructor() {
-        x_ = 0.0
-        y_ = 0.0
-    }
+    @JsName("identity")
+    constructor() : this(0.0, 0.0)
 
-    constructor(x: Double, y: Double) {
-        x_ = x
-        y_ = y
-    }
+    @JsName("copyOf")
+    constructor(other: Translation2d) : this(other.x, other.y)
 
-    constructor(other: Translation2d) {
-        x_ = other.x_
-        y_ = other.y_
-    }
-
-    constructor(start: Translation2d, end: Translation2d) {
-        x_ = end.x_ - start.x_
-        y_ = end.y_ - start.y_
-    }
+    @JsName("delta")
+    constructor(start: Translation2d, end: Translation2d) : this(
+        x = end.x - start.x,
+        y = end.y - start.y
+    )
 
     /**
      * The "norm" of a transform is the Euclidean distance in x and y.
      *
      * @return sqrt(x ^ 2 + y ^ 2)
      */
     fun norm(): Double {
-        return kotlin.math.hypot(x_, y_)
+        return kotlin.math.hypot(x, y)
     }
 
     fun norm2(): Double {
-        return x_ * x_ + y_ * y_
+        return x * x + y * y
     }
 
     fun x(): Double {
-        return x_
+        return x
     }
 
     fun y(): Double {
-        return y_
+        return y
     }
 
     /**
@@ -63,7 +57,7 @@ class Translation2d : ITranslation2d<Translation2d> {
      * @return The combined effect of translating by this object and the other.
      */
     fun translateBy(other: Translation2d): Translation2d {
-        return Translation2d(x_ + other.x_, y_ + other.y_)
+        return Translation2d(x + other.x, y + other.y)
     }
 
     /**
@@ -73,11 +67,11 @@ class Translation2d : ITranslation2d<Translation2d> {
      * @return This translation rotated by rotation.
      */
     fun rotateBy(rotation: Rotation2d): Translation2d {
-        return Translation2d(x_ * rotation.cos() - y_ * rotation.sin(), x_ * rotation.sin() + y_ * rotation.cos())
+        return Translation2d(x * rotation.cos() - y * rotation.sin(), x * rotation.sin() + y * rotation.cos())
     }
 
     fun direction(): Rotation2d {
-        return Rotation2d(x_, y_, true)
+        return Rotation2d(x, y, true)
     }
 
     /**
@@ -86,7 +80,7 @@ class Translation2d : ITranslation2d<Translation2d> {
      * @return Translation by -x and -y.
      */
     fun inverse(): Translation2d {
-        return Translation2d(-x_, -y_)
+        return Translation2d(-x, -y)
     }
 
     override fun interpolate(other: Translation2d, x: Double): Translation2d {
@@ -99,23 +93,23 @@ class Translation2d : ITranslation2d<Translation2d> {
     }
 
     fun extrapolate(other: Translation2d, x: Double): Translation2d {
-        return Translation2d(x * (other.x_ - x_) + x_, x * (other.y_ - y_) + y_)
+        return Translation2d(x * (other.x - x) + x, x * (other.y - y) + y)
     }
 
     fun scale(s: Double): Translation2d {
-        return Translation2d(x_ * s, y_ * s)
+        return Translation2d(x * s, y * s)
     }
 
     fun epsilonEquals(other: Translation2d, epsilon: Double): Boolean {
         return Util.epsilonEquals(x(), other.x(), epsilon) && Util.epsilonEquals(y(), other.y(), epsilon)
     }
 
     override fun toString(): String {
-        return "(" + x_.format(3) + "," + y_.format(3) + ")"
+        return "(" + x.format(3) + "," + y.format(3) + ")"
     }
 
     override fun toCSV(): String {
-        return x_.format(3) + "," + y_.format(3)
+        return x.format(3) + "," + y.format(3)
     }
 
     override fun distance(other: Translation2d): Double {
@@ -127,8 +121,8 @@ class Translation2d : ITranslation2d<Translation2d> {
     }
 
     override fun hashCode(): Int {
-        var result = x_.hashCode()
-        result = 31 * result + y_.hashCode()
+        var result = x.hashCode()
+        result = 31 * result + y.hashCode()
         return result
     }
 
@@ -156,7 +150,7 @@ class Translation2d : ITranslation2d<Translation2d> {
 
         @JvmStatic
         fun dot(a: Translation2d, b: Translation2d): Double {
-            return a.x_ * b.x_ + a.y_ * b.y_
+            return a.x * b.x + a.y * b.y
         }
 
         @JvmStatic
@@ -176,7 +170,7 @@ class Translation2d : ITranslation2d<Translation2d> {
 
         @JvmStatic
         fun cross(a: Translation2d, b: Translation2d): Double {
-            return a.x_ * b.y_ - a.y_ * b.x_
+            return a.x * b.y - a.y * b.x
         }
     }
 }

src/commonMain/kotlin/com/team254/lib/splinesutil/Util.kt

@@ -1,5 +1,8 @@
 package com.team254.lib.splinesutil
 
+import kotlin.js.ExperimentalJsExport
+import kotlin.js.JsExport
+import kotlin.js.JsName
 import kotlin.jvm.JvmOverloads
 import kotlin.math.PI
 
@@ -55,10 +58,14 @@ object Util {
     }
 }
 
+@ExperimentalJsExport
+@JsName("toDegrees")
 fun toDegrees(radians: Double): Double {
     return radians * (180.0 / PI)
 }
 
+@ExperimentalJsExport
+@JsName("toRadians")
 fun toRadians(degrees: Double): Double {
     return degrees * (PI / 180.0)
 }

src/jsMain/kotlin/main.kt

@@ -9,10 +9,7 @@ external fun decodeURIComponent(encodedURI: String): String
 @ExperimentalJsExport
 @JsExport
 @JsName("calcSplines")
-fun calcSplines(pointData: Array<DoubleArray>): String {
-    val points = pointData.map { point ->
-        Pose2d(point[0], point[1], point[2])
-    }
+fun calcSplines(points: Array<Pose2d>): String {
     val mQuinticHermiteSplines: ArrayList<QuinticHermiteSpline> =
         ArrayList()
     val mSplines: ArrayList<Spline> = ArrayList()