build.gradle.kts

@@ -5,16 +5,15 @@ plugins {
     id("space.kscience.gradle.project")
 }
 
-val kmathVersion: String by extra("0.3.1")
+val kmathVersion: String by extra("0.4.0-RC2")
 
 allprojects {
     group = "center.sciprog"
-    version = "0.3.0-dev-1"
+    version = "0.3.0-dev-2"
 
     repositories {
         mavenLocal()
         maven("https://repo.kotlin.link")
-        maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
     }
 }
 

demo/maps-js/build.gradle.kts

@@ -1,26 +0,0 @@
-plugins {
-    kotlin("multiplatform")
-    id("org.jetbrains.compose")
-}
-
-val ktorVersion: String by rootProject.extra
-
-kotlin {
-    js {
-        browser()
-        binaries.executable()
-    }
-    sourceSets {
-        val jsMain by getting {
-            dependencies {
-                implementation(projects.mapsKtCompose)
-                implementation(compose.runtime)
-                implementation(compose.html.core)
-            }
-        }
-    }
-}
-
-compose {
-    web {}
-}

demo/maps-js/src/jsMain/kotlin/Main.kt

@@ -1,172 +0,0 @@
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.PointerMatcher
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalFontFamilyResolver
-import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.text.font.createFontFamilyResolver
-import androidx.compose.ui.unit.Density
-import androidx.compose.ui.unit.DpSize
-import androidx.compose.ui.unit.LayoutDirection
-import androidx.compose.ui.unit.dp
-import center.sciprog.attributes.Attributes
-import center.sciprog.maps.compose.*
-import center.sciprog.maps.coordinates.GeodeticMapCoordinates
-import center.sciprog.maps.coordinates.Gmc
-import center.sciprog.maps.coordinates.kilometers
-import center.sciprog.maps.features.*
-import io.ktor.client.HttpClient
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.filterNotNull
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import org.jetbrains.compose.web.renderComposable
-import space.kscience.kmath.geometry.Angle
-import space.kscience.kmath.geometry.degrees
-import space.kscience.kmath.geometry.radians
-import kotlin.math.PI
-import kotlin.random.Random
-
-public fun GeodeticMapCoordinates.toShortString(): String =
-    "${(latitude.degrees).toString().take(6)}:${(longitude.degrees).toString().take(6)}"
-
-
-@OptIn(ExperimentalFoundationApi::class)
-@Composable
-fun App() {
-
-    val scope = rememberCoroutineScope()
-
-    val mapTileProvider = remember {
-        OpenStreetMapTileProvider(
-            client = HttpClient(),
-        )
-    }
-
-    val centerCoordinates = MutableStateFlow<Gmc?>(null)
-
-    val pointOne = 55.568548 to 37.568604
-    val pointTwo = 55.929444 to 37.518434
-//        val pointThree = 60.929444 to 37.518434
-
-    MapView(
-        mapTileProvider = mapTileProvider,
-        config = ViewConfig(
-            onViewChange = { centerCoordinates.value = focus },
-            onClick = { _, viewPoint ->
-                println(viewPoint)
-            }
-        )
-    ) {
-
-//        icon(pointOne, Icons.Filled.Home)
-
-        val marker1 = rectangle(55.744 to 38.614, size = DpSize(10.dp, 10.dp))
-            .color(Color.Magenta)
-        val marker2 = rectangle(55.8 to 38.5, size = DpSize(10.dp, 10.dp))
-            .color(Color.Magenta)
-        val marker3 = rectangle(56.0 to 38.5, size = DpSize(10.dp, 10.dp))
-            .color(Color.Magenta)
-
-        draggableLine(marker1, marker2, id = "line 1").color(Color.Red).onClick {
-            println("line 1 clicked")
-        }
-        draggableLine(marker2, marker3, id = "line 2").color(Color.DarkGray).onClick {
-            println("line 2 clicked")
-        }
-        draggableLine(marker3, marker1, id = "line 3").color(Color.Blue).onClick {
-            println("line 3 clicked")
-        }
-
-
-        multiLine(
-            points = listOf(
-                55.742465 to 37.615812,
-                55.742713 to 37.616370,
-                55.742815 to 37.616659,
-                55.742320 to 37.617132,
-                55.742086 to 37.616566,
-                55.741715 to 37.616716
-            ),
-        )
-
-        //remember feature ref
-        val circleId = circle(
-            centerCoordinates = pointTwo,
-        )
-        scope.launch {
-            while (isActive) {
-                delay(200)
-                circleId.color(Color(Random.nextFloat(), Random.nextFloat(), Random.nextFloat()))
-            }
-        }
-
-        arc(pointOne, 10.0.kilometers, (PI / 4).radians, -Angle.pi / 2)
-
-
-        line(pointOne, pointTwo, id = "line")
-        text(pointOne, "Home", font = { size = 32f })
-
-
-        pixelMap(
-            space.Rectangle(
-                Gmc(latitude = 55.58461879539754.degrees, longitude = 37.8746197303493.degrees),
-                Gmc(latitude = 55.442792937592415.degrees, longitude = 38.132240805463844.degrees)
-            ),
-            0.005.degrees,
-            0.005.degrees
-        ) { gmc ->
-            Color(
-                red = ((gmc.latitude + Angle.piDiv2).degrees * 10 % 1f).toFloat(),
-                green = ((gmc.longitude + Angle.pi).degrees * 10 % 1f).toFloat(),
-                blue = 0f,
-                alpha = 0.3f
-            )
-        }
-
-        centerCoordinates.filterNotNull().onEach {
-            group(id = "center") {
-                circle(center = it, id = "circle", size = 1.dp).color(Color.Blue)
-                text(position = it, it.toShortString(), id = "text").color(Color.Blue)
-            }
-        }.launchIn(scope)
-
-        //Add click listeners for all polygons
-        forEachWithType<Gmc, PolygonFeature<Gmc>> { ref ->
-            ref.onClick(PointerMatcher.Primary) {
-                println("Click on ${ref.id}")
-                //draw in top-level scope
-                with(this@MapView) {
-                    multiLine(
-                        ref.resolve().points,
-                        attributes = Attributes(ZAttribute, 10f),
-                        id = "selected",
-                    ).modifyAttribute(StrokeAttribute, 4f).color(Color.Magenta)
-                }
-            }
-        }
-    }
-
-}
-
-
-fun main() {
-    renderComposable(rootElementId = "root") {
-        CompositionLocalProvider(
-            LocalDensity provides Density(1.0f),
-            LocalLayoutDirection provides LayoutDirection.Ltr,
-//            LocalViewConfiguration provides DefaultViewConfiguration(Density(1.0f)),
-//            LocalInputModeManager provides InputModeManagerObject,
-            LocalFontFamilyResolver provides createFontFamilyResolver()
-        ) {
-            App()
-        }
-    }
-}

demo/maps-js/src/jsMain/resources/index.html

@@ -1,13 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <title>Maps-kt demo</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-
-</head>
-<body>
-<div id="root"/>
-</body>
-<script src="maps-js.js"></script>
-</html>

demo/maps-wasm/build.gradle.kts

@@ -0,0 +1,30 @@
+import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl
+
+plugins {
+    kotlin("multiplatform")
+    id("org.jetbrains.compose")
+}
+
+//val ktorVersion: String by rootProject.extra
+
+kotlin {
+    @OptIn(ExperimentalWasmDsl::class)
+    wasmJs {
+        browser()
+        binaries.executable()
+    }
+    sourceSets {
+        val wasmJsMain by getting {
+            dependencies {
+                implementation(projects.mapsKtScheme)
+                @OptIn(org.jetbrains.compose.ExperimentalComposeLibrary::class) api(compose.components.resources)
+            }
+        }
+    }
+}
+
+compose {
+    experimental.web{
+        application{}
+    }
+}

demo/maps-wasm/src/wasmJsMain/kotlin/Main.kt

@@ -0,0 +1,79 @@
+@file:OptIn(ExperimentalComposeUiApi::class, ExperimentalResourceApi::class)
+
+import androidx.compose.runtime.*
+import androidx.compose.ui.ExperimentalComposeUiApi
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.window.CanvasBasedWindow
+import center.sciprog.maps.features.FeatureGroup
+import center.sciprog.maps.features.ViewConfig
+import center.sciprog.maps.features.ViewPoint
+import center.sciprog.maps.features.color
+import center.sciprog.maps.scheme.*
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import org.jetbrains.compose.resources.DrawableResource
+import org.jetbrains.compose.resources.ExperimentalResourceApi
+import org.jetbrains.compose.resources.painterResource
+import space.kscience.kmath.geometry.Angle
+
+
+@Composable
+fun App() {
+
+    val scope = rememberCoroutineScope()
+
+
+    val features: FeatureGroup<XY> = FeatureGroup.remember(XYCoordinateSpace) {
+        background(1600f, 1200f) { painterResource(DrawableResource("middle-earth.jpg")) }
+        circle(410.52737 to 868.7676).color(Color.Blue)
+        text(410.52737 to 868.7676, "Shire").color(Color.Blue)
+        circle(1132.0881 to 394.99127).color(Color.Red)
+        text(1132.0881 to 394.99127, "Ordruin").color(Color.Red)
+        arc(center = 1132.0881 to 394.99127, radius = 20f, startAngle = Angle.zero, Angle.piTimes2)
+
+        //circle(410.52737 to 868.7676, id = "hobbit")
+
+        scope.launch {
+            var t = 0.0
+            while (isActive) {
+                val x = 410.52737 + t * (1132.0881 - 410.52737)
+                val y = 868.7676 + t * (394.99127 - 868.7676)
+                circle(x to y, id = "hobbit").color(Color.Green)
+                delay(100)
+                t += 0.005
+                if (t >= 1.0) t = 0.0
+            }
+        }
+    }
+
+    val initialViewPoint: ViewPoint<XY> = remember {
+        features.getBoundingBox(1f)?.computeViewPoint() ?: XYViewPoint(XY(0f, 0f))
+    }
+
+    var viewPoint: ViewPoint<XY> by remember { mutableStateOf(initialViewPoint) }
+
+    val mapState: XYCanvasState = XYCanvasState.remember(
+        ViewConfig(
+            onClick = { _, click ->
+                println("${click.focus.x}, ${click.focus.y}")
+            },
+            onViewChange = { viewPoint = this }
+        ),
+        initialViewPoint = initialViewPoint,
+    )
+
+    SchemeView(
+        mapState,
+        features,
+    )
+
+}
+
+
+fun main() {
+//    renderComposable(rootElementId = "root") {
+    CanvasBasedWindow("Maps demo", canvasElementId = "ComposeTarget") {
+        App()
+    }
+}

demo/maps-wasm/src/wasmJsMain/resources/index.html

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Compose App</title>
+    <script type="application/javascript" src="skiko.js"></script>
+    <script type="application/javascript" src="maps-wasm.js"></script>
+</head>
+<body>
+<canvas id="ComposeTarget"></canvas>
+</body>
+</html>

demo/maps/src/jvmMain/kotlin/Main.kt

@@ -13,7 +13,6 @@ import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.application
-import center.sciprog.attributes.Attributes
 import center.sciprog.maps.compose.*
 import center.sciprog.maps.coordinates.GeodeticMapCoordinates
 import center.sciprog.maps.coordinates.Gmc
@@ -29,6 +28,7 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
+import space.kscience.attributes.Attributes
 import space.kscience.kmath.geometry.Angle
 import space.kscience.kmath.geometry.degrees
 import space.kscience.kmath.geometry.radians
@@ -37,7 +37,7 @@ import kotlin.math.PI
 import kotlin.random.Random
 
 public fun GeodeticMapCoordinates.toShortString(): String =
-    "${(latitude.degrees).toString().take(6)}:${(longitude.degrees).toString().take(6)}"
+    "${(latitude.toDegrees().value).toString().take(6)}:${(longitude.toDegrees().value).toString().take(6)}"
 
 
 @OptIn(ExperimentalFoundationApi::class)
@@ -151,8 +151,8 @@ fun App() {
                 0.005.degrees
             ) { gmc ->
                 Color(
-                    red = ((gmc.latitude + Angle.piDiv2).degrees * 10 % 1f).toFloat(),
+                    red = ((gmc.latitude + Angle.piDiv2).toDegrees().value * 10 % 1f).toFloat(),
-                    green = ((gmc.longitude + Angle.pi).degrees * 10 % 1f).toFloat(),
+                    green = ((gmc.longitude + Angle.pi).toDegrees().value * 10 % 1f).toFloat(),
                     blue = 0f,
                     alpha = 0.3f
                 )

demo/trajectory-playground/src/jvmMain/kotlin/Main.kt

@@ -12,13 +12,13 @@ import center.sciprog.maps.features.*
 import center.sciprog.maps.scheme.SchemeView
 import center.sciprog.maps.scheme.XY
 import space.kscience.kmath.geometry.Angle
-import space.kscience.kmath.geometry.Circle2D
+import space.kscience.kmath.geometry.Vector2D
-import space.kscience.kmath.geometry.DoubleVector2D
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
-import space.kscience.kmath.geometry.Euclidean2DSpace
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
 import space.kscience.trajectory.*
 import kotlin.random.Random
 
-private fun DoubleVector2D.toXY() = XY(x.toFloat(), y.toFloat())
+private fun Vector2D<out Number>.toXY() = XY(x.toFloat(), y.toFloat())
 
 private val random = Random(123)
 
@@ -32,7 +32,7 @@ fun FeatureGroup<XY>.trajectory(
             bCoordinates = trajectory.end.toXY(),
         ).color(colorPicker(trajectory))
 
-        is CircleTrajectory2D -> with(Euclidean2DSpace) {
+        is CircleTrajectory2D -> with(Float64Space2D) {
             val topLeft = trajectory.circle.center + vector(-trajectory.circle.radius, trajectory.circle.radius)
             val bottomRight = trajectory.circle.center + vector(trajectory.circle.radius, -trajectory.circle.radius)
 
@@ -59,20 +59,20 @@ fun FeatureGroup<XY>.obstacle(obstacle: Obstacle, colorPicker: (Trajectory2D) ->
     polygon(obstacle.arcs.map { it.center.toXY() }).color(Color.Gray)
 }
 
-fun FeatureGroup<XY>.pose(pose2D: Pose2D) = with(Euclidean2DSpace) {
+fun FeatureGroup<XY>.pose(pose2D: Pose2D) = with(Float64Space2D) {
     line(pose2D.toXY(), (pose2D + Pose2D.bearingToVector(pose2D.bearing)).toXY())
 }
 
 @Composable
 @Preview
-fun closePoints() {
+fun closePoints()  = with(Float64Space2D){
     SchemeView {
 
         val obstacle = Obstacle(
-            Circle2D(Euclidean2DSpace.vector(0.0, 0.0), 1.0),
+            Circle2D(vector(0.0, 0.0), 1.0),
-            Circle2D(Euclidean2DSpace.vector(0.0, 1.0), 1.0),
+            Circle2D(vector(0.0, 1.0), 1.0),
-            Circle2D(Euclidean2DSpace.vector(1.0, 1.0), 1.0),
+            Circle2D(vector(1.0, 1.0), 1.0),
-            Circle2D(Euclidean2DSpace.vector(1.0, 0.0), 1.0)
+            Circle2D(vector(1.0, 0.0), 1.0)
         )
         val enter = Pose2D(-0.8, -0.8, Angle.pi)
         val exit = Pose2D(-0.8, -0.8, Angle.piDiv2)
@@ -101,7 +101,7 @@ fun closePoints() {
 @Preview
 fun singleObstacle() {
     SchemeView {
-        val obstacle = Obstacle(Circle2D(Euclidean2DSpace.vector(7.0, 1.0), 5.0))
+        val obstacle = Obstacle(Circle2D(Float64Space2D.vector(7.0, 1.0), 5.0))
         val enter = Pose2D(-5, -1, Angle.pi / 4)
         val exit = Pose2D(20, 4, Angle.pi * 3 / 4)
 
@@ -123,19 +123,19 @@ fun singleObstacle() {
 
 @Composable
 @Preview
-fun doubleObstacle() {
+fun doubleObstacle() = with(Float64Space2D){
     SchemeView {
         val obstacles = arrayOf(
             Obstacle(
-                Circle2D(Euclidean2DSpace.vector(1.0, 6.5), 0.5),
+                Circle2D(vector(1.0, 6.5), 0.5),
-                Circle2D(Euclidean2DSpace.vector(2.0, 1.0), 0.5),
+                Circle2D(vector(2.0, 1.0), 0.5),
-                Circle2D(Euclidean2DSpace.vector(6.0, 0.0), 0.5),
+                Circle2D(vector(6.0, 0.0), 0.5),
-                Circle2D(Euclidean2DSpace.vector(5.0, 5.0), 0.5)
+                Circle2D(vector(5.0, 5.0), 0.5)
             ), Obstacle(
-                Circle2D(Euclidean2DSpace.vector(10.0, 1.0), 0.5),
+                Circle2D(vector(10.0, 1.0), 0.5),
-                Circle2D(Euclidean2DSpace.vector(16.0, 0.0), 0.5),
+                Circle2D(vector(16.0, 0.0), 0.5),
-                Circle2D(Euclidean2DSpace.vector(14.0, 6.0), 0.5),
+                Circle2D(vector(14.0, 6.0), 0.5),
-                Circle2D(Euclidean2DSpace.vector(9.0, 4.0), 0.5)
+                Circle2D(vector(9.0, 4.0), 0.5)
             )
         )
 

gradle.properties

@@ -1,6 +1,7 @@
 kotlin.code.style=official
 
-compose.version=1.5.10
+compose.version=1.6.0-rc02
+org.jetbrains.compose.experimental.wasm.enabled=true
 org.jetbrains.compose.experimental.jscanvas.enabled=true
 
 agp.version=8.1.0
@@ -9,4 +10,4 @@ android.enableJetifier=true
 
 org.gradle.jvmargs=-Xmx4096m
 
-toolsVersion=0.15.0-kotlin-1.9.20
+toolsVersion=0.15.2-kotlin-1.9.22

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.4-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.6-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

maps-kt-compose/build.gradle.kts

@@ -7,7 +7,8 @@ plugins {
 
 kscience {
     jvm()
-    js()
+    wasm()
+
     useCoroutines()
 }
 
@@ -27,12 +28,12 @@ kotlin {
                 api("io.ktor:ktor-client-cio")
             }
         }
-
+//
-        getByName("jsMain"){
+//        getByName("jsMain"){
-            dependencies {
+//            dependencies {
-                api("io.ktor:ktor-client-js")
+//                api("io.ktor:ktor-client-js")
-            }
+//            }
-        }
+//        }
 
         getByName("jvmTest") {
             dependencies {

maps-kt-compose/src/commonMain/kotlin/center/sciprog/maps/compose/MapCanvasState.kt

@@ -61,8 +61,8 @@ public class MapCanvasState private constructor(
     override fun computeViewPoint(rectangle: Rectangle<Gmc>): ViewPoint<Gmc> {
         val zoom = log2(
             min(
-                canvasSize.width.value / rectangle.longitudeDelta.radians,
+                canvasSize.width.value / rectangle.longitudeDelta.toRadians().value,
-                canvasSize.height.value / rectangle.latitudeDelta.radians
+                canvasSize.height.value / rectangle.latitudeDelta.toRadians().value
             ) * 2 * PI / mapTileProvider.tileSize
         ).coerceIn(0.0..22.0)
         return space.ViewPoint(rectangle.center, zoom.toFloat())

maps-kt-compose/src/commonMain/kotlin/center/sciprog/maps/compose/mapFeatures.kt

@@ -8,6 +8,7 @@ import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.dp
 import center.sciprog.maps.coordinates.*
 import center.sciprog.maps.features.*
+import org.jetbrains.skia.Font
 import space.kscience.kmath.geometry.Angle
 import kotlin.math.ceil
 
@@ -139,7 +140,7 @@ public fun FeatureGroup<Gmc>.icon(
 public fun FeatureGroup<Gmc>.text(
     position: Pair<Double, Double>,
     text: String,
-    font: FeatureFont.() -> Unit = { size = 16f },
+    font: Font.() -> Unit = { size = 16f },
     id: String? = null,
 ): FeatureRef<Gmc, TextFeature<Gmc>> = feature(
     id,

maps-kt-core/build.gradle.kts

@@ -9,6 +9,8 @@ kscience{
     jvm()
     js()
     native()
+    wasm()
+
     useSerialization()
 
     dependencies{

maps-kt-core/src/commonMain/kotlin/center/sciprog/maps/coordinates/GeodeticMapCoordinates.kt

@@ -22,7 +22,6 @@ public class GeodeticMapCoordinates(
             "Longitude $longitude is not in (-PI..PI) range"
         }
     }
-
     override val x: Angle get() = longitude
 
     override val y: Angle get() = latitude
@@ -43,7 +42,7 @@ public class GeodeticMapCoordinates(
     }
 
     override fun toString(): String {
-        return "GMC(latitude=${latitude.degrees} deg, longitude=${longitude.degrees} deg)"
+        return "GMC(latitude=${latitude.toDegrees().value} deg, longitude=${longitude.toDegrees().value} deg)"
     }
 
 

maps-kt-core/src/commonMain/kotlin/center/sciprog/maps/coordinates/GmcCurve.kt

@@ -79,7 +79,7 @@ public fun GeoEllipsoid.parallelCurve(latitude: Angle, fromLongitude: Angle, toL
     return GmcCurve(
         forward = GmcPose(Gmc.normalized(latitude, fromLongitude), if (right) Angle.piDiv2 else -Angle.piDiv2),
         backward = GmcPose(Gmc.normalized(latitude, toLongitude), if (right) -Angle.piDiv2 else Angle.piDiv2),
-        distance = reducedRadius(latitude) * abs((fromLongitude - toLongitude).radians)
+        distance = reducedRadius(latitude) * abs((fromLongitude - toLongitude).toRadians().value)
     )
 }
 

maps-kt-core/src/commonMain/kotlin/center/sciprog/maps/coordinates/MercatorProjection.kt

@@ -57,12 +57,12 @@ public open class MercatorProjection(
         return if (ellipsoid === GeoEllipsoid.sphere) {
             GeodeticMapCoordinates.ofRadians(
                 atan(sinh(pc.y / ellipsoid.equatorRadius)),
-                baseLongitude.radians + (pc.x / ellipsoid.equatorRadius),
+                baseLongitude.toRadians().value + (pc.x / ellipsoid.equatorRadius),
             )
         } else {
             GeodeticMapCoordinates.ofRadians(
                 cphi2(exp(-(pc.y / ellipsoid.equatorRadius))),
-                baseLongitude.radians + (pc.x / ellipsoid.equatorRadius)
+                baseLongitude.toRadians().value + (pc.x / ellipsoid.equatorRadius)
             )
         }
     }
@@ -76,13 +76,13 @@ public open class MercatorProjection(
 
         return if (ellipsoid === GeoEllipsoid.sphere) {
             ProjectionCoordinates(
-                x = ellipsoid.equatorRadius * (gmc.longitude - baseLongitude).radians,
+                x = ellipsoid.equatorRadius * (gmc.longitude - baseLongitude).toRadians().value,
                 y = ellipsoid.equatorRadius * ln(tan(Angle.pi / 4 + gmc.latitude / 2))
             )
         } else {
             val sinPhi = sin(gmc.latitude)
             ProjectionCoordinates(
-                x = ellipsoid.equatorRadius * (gmc.longitude - baseLongitude).radians,
+                x = ellipsoid.equatorRadius * (gmc.longitude - baseLongitude).toRadians().value,
                 y = ellipsoid.equatorRadius * ln(
                     tan(Angle.pi / 4 + gmc.latitude / 2) * ((1 - e * sinPhi) / (1 + e * sinPhi)).pow(e / 2)
                 )

maps-kt-core/src/commonMain/kotlin/center/sciprog/maps/coordinates/WebMercatorProjection.kt

@@ -6,7 +6,6 @@
 package center.sciprog.maps.coordinates
 
 import space.kscience.kmath.geometry.abs
-import space.kscience.kmath.geometry.radians
 import kotlin.math.*
 
 public data class WebMercatorCoordinates(val zoom: Int, val x: Float, val y: Float)
@@ -36,8 +35,8 @@ public object WebMercatorProjection {
         val scaleFactor = scaleFactor(zoom.toFloat())
         return WebMercatorCoordinates(
             zoom = zoom,
-            x = scaleFactor * (gmc.longitude.radians + PI).toFloat(),
+            x = scaleFactor * (gmc.longitude.toRadians().value + PI).toFloat(),
-            y = scaleFactor * (PI - ln(tan(PI / 4 + gmc.latitude.radians / 2))).toFloat()
+            y = scaleFactor * (PI - ln(tan(PI / 4 + gmc.latitude.toRadians().value / 2))).toFloat()
         )
     }
 

maps-kt-core/src/commonTest/kotlin/center/sciprog/maps/coordinates/DistanceTest.kt

@@ -21,7 +21,7 @@ internal class DistanceTest {
         val distance = curve.distance
 
         assertEquals(632.035426877, distance.kilometers, 0.0001)
-        assertEquals(-0.6947937116552751, curve.forward.bearing.radians, 0.0001)
+        assertEquals(-0.6947937116552751, curve.forward.bearing.toRadians().value, 0.0001)
     }
 
     @Test
@@ -30,7 +30,7 @@ internal class DistanceTest {
             GmcPose(moscow, (-0.6947937116552751).radians), Distance(632.035426877)
         )
 
-        assertEquals(spb.latitude.radians, curve.backward.latitude.radians, 0.0001)
+        assertEquals(spb.latitude.toRadians().value, curve.backward.latitude.toRadians().value, 0.0001)
-        assertEquals(spb.longitude.radians, curve.backward.longitude.radians, 0.0001)
+        assertEquals(spb.longitude.toRadians().value, curve.backward.longitude.toRadians().value, 0.0001)
     }
 }

maps-kt-core/src/commonTest/kotlin/center/sciprog/maps/coordinates/MercatorTest.kt

@@ -1,6 +1,5 @@
 package center.sciprog.maps.coordinates
 
-import space.kscience.kmath.geometry.degrees
 import kotlin.test.Test
 import kotlin.test.assertEquals
 
@@ -13,8 +12,8 @@ class MercatorTest {
         assertEquals(4186.0120709, mercator.x.kilometers, 1e-4)
         assertEquals(7510.9013658, mercator.y.kilometers, 1e-4)
         val backwards = MapProjection.epsg3857.toGeodetic(mercator)
-        assertEquals(moscow.latitude.degrees, backwards.latitude.degrees, 1e-6)
+        assertEquals(moscow.latitude.toDegrees().value, backwards.latitude.toDegrees().value, 1e-6)
-        assertEquals(moscow.longitude.degrees, backwards.longitude.degrees, 1e-6)
+        assertEquals(moscow.longitude.toDegrees().value, backwards.longitude.toDegrees().value, 1e-6)
     }
 
     @Test
@@ -23,7 +22,7 @@ class MercatorTest {
         val projection = MercatorProjection(ellipsoid = GeoEllipsoid.WGS84)
         val mercator = projection.toProjection(moscow)
         val backwards = projection.toGeodetic(mercator)
-        assertEquals(moscow.latitude.degrees, backwards.latitude.degrees, 1e-6)
+        assertEquals(moscow.latitude.toDegrees().value, backwards.latitude.toDegrees().value, 1e-6)
-        assertEquals(moscow.longitude.degrees, backwards.longitude.degrees, 1e-6)
+        assertEquals(moscow.longitude.toDegrees().value, backwards.longitude.toDegrees().value, 1e-6)
     }
 }

maps-kt-features/build.gradle.kts

@@ -8,7 +8,17 @@ val kmathVersion: String by rootProject.extra
 
 kscience {
     jvm()
-    js()
+//    js()
+    wasm{
+        browser {
+            testTask {
+                enabled = false
+            }
+        }
+    }
+
+    useCoroutines()
+
     useSerialization {
         json()
     }
@@ -23,8 +33,11 @@ kotlin {
         commonMain {
             dependencies {
                 api(projects.trajectoryKt)
+                api(compose.runtime)
                 api(compose.foundation)
-                api("io.github.oshai:kotlin-logging:5.1.0")
+                api(compose.material)
+                api(compose.ui)
+                api("io.github.oshai:kotlin-logging:6.0.3")
             }
         }
     }

maps-kt-features/src/commonMain/kotlin/center.sciprog.attributes/Attribute.kt

@@ -1,22 +0,0 @@
-package center.sciprog.attributes
-
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.builtins.serializer
-
-public interface Attribute<T>
-
-public abstract class SerializableAttribute<T>(
-    public val serialId: String,
-    public val serializer: KSerializer<T>,
-) : Attribute<T> {
-    override fun toString(): String = serialId
-}
-
-public interface AttributeWithDefault<T> : Attribute<T> {
-    public val default: T
-}
-
-public interface SetAttribute<V> : Attribute<Set<V>>
-
-public object NameAttribute : SerializableAttribute<String>("name", String.serializer())
-

maps-kt-features/src/commonMain/kotlin/center.sciprog.attributes/Attributes.kt

@@ -1,68 +0,0 @@
-package center.sciprog.attributes
-
-import center.sciprog.maps.features.Feature
-import center.sciprog.maps.features.ZAttribute
-import kotlin.jvm.JvmInline
-
-@JvmInline
-public value class Attributes internal constructor(public val content: Map<out Attribute<*>, Any>) {
-
-    public val keys: Set<Attribute<*>> get() = content.keys
-
-    @Suppress("UNCHECKED_CAST")
-    public operator fun <T> get(attribute: Attribute<T>): T? = content[attribute] as? T
-
-    override fun toString(): String = "Attributes(value=${content.entries})"
-
-    public companion object {
-        public val EMPTY: Attributes = Attributes(emptyMap())
-    }
-}
-
-public fun Attributes.isEmpty(): Boolean = content.isEmpty()
-
-public fun <T> Attributes.getOrDefault(attribute: AttributeWithDefault<T>): T = get(attribute) ?: attribute.default
-
-public fun <T, A : Attribute<T>> Attributes.withAttribute(
-    attribute: A,
-    attrValue: T?,
-): Attributes = Attributes(
-    if (attrValue == null) {
-        content - attribute
-    } else {
-        content + (attribute to attrValue)
-    }
-)
-
-/**
- * Add an element to a [SetAttribute]
- */
-public fun <T, A : SetAttribute<T>> Attributes.withAttributeElement(
-    attribute: A,
-    attrValue: T,
-): Attributes {
-    val currentSet: Set<T> = get(attribute) ?: emptySet()
-    return Attributes(
-        content + (attribute to (currentSet + attrValue))
-    )
-}
-
-/**
- * Remove an element from [SetAttribute]
- */
-public fun <T, A : SetAttribute<T>> Attributes.withoutAttributeElement(
-    attribute: A,
-    attrValue: T,
-): Attributes {
-    val currentSet: Set<T> = get(attribute) ?: emptySet()
-    return Attributes(
-        content + (attribute to (currentSet - attrValue))
-    )
-}
-
-public fun <T : Any, A : Attribute<T>> Attributes(
-    attribute: A,
-    attrValue: T,
-): Attributes = Attributes(mapOf(attribute to attrValue))
-
-public operator fun Attributes.plus(other: Attributes): Attributes = Attributes(content + other.content)

maps-kt-features/src/commonMain/kotlin/center.sciprog.attributes/AttributesBuilder.kt

@@ -1,47 +0,0 @@
-package center.sciprog.attributes
-
-/**
- * A safe builder for [Attributes]
- */
-public class AttributesBuilder internal constructor(private val map: MutableMap<Attribute<*>, Any> = mutableMapOf()) {
-
-    @Suppress("UNCHECKED_CAST")
-    public operator fun <T> get(attribute: Attribute<T>): T? = map[attribute] as? T
-
-    public operator fun <V> Attribute<V>.invoke(value: V?) {
-        if (value == null) {
-            map.remove(this)
-        } else {
-            map[this] = value
-        }
-    }
-
-    public fun from(attributes: Attributes) {
-        map.putAll(attributes.content)
-    }
-
-    public fun <V> SetAttribute<V>.add(
-        attrValue: V,
-    ) {
-        val currentSet: Set<V> = get(this) ?: emptySet()
-        map[this] = currentSet + attrValue
-    }
-
-    /**
-     * Remove an element from [SetAttribute]
-     */
-    public fun <V> SetAttribute<V>.remove(
-        attrValue: V,
-    ) {
-        val currentSet: Set<V> = get(this) ?: emptySet()
-        map[this] = currentSet - attrValue
-    }
-
-    public fun build(): Attributes = Attributes(map)
-}
-
-public fun AttributesBuilder(
-    attributes: Attributes,
-): AttributesBuilder = AttributesBuilder(attributes.content.toMutableMap())
-
-public fun Attributes(builder: AttributesBuilder.() -> Unit): Attributes = AttributesBuilder().apply(builder).build()

maps-kt-features/src/commonMain/kotlin/center/sciprog/maps/features/Feature.kt

@@ -17,8 +17,9 @@ import androidx.compose.ui.graphics.vector.rememberVectorPainter
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.dp
-import center.sciprog.attributes.Attributes
+import org.jetbrains.skia.Font
-import center.sciprog.attributes.NameAttribute
+import space.kscience.NameAttribute
+import space.kscience.attributes.Attributes
 import space.kscience.kmath.geometry.Angle
 import space.kscience.kmath.nd.Structure2D
 
@@ -331,7 +332,7 @@ public data class TextFeature<T : Any>(
     public val position: T,
     public val text: String,
     override val attributes: Attributes = Attributes.EMPTY,
-    public val fontConfig: FeatureFont.() -> Unit,
+    public val fontConfig: Font.() -> Unit,
 ) : DraggableFeature<T> {
     override fun getBoundingBox(zoom: Float): Rectangle<T> = space.Rectangle(position, position)
 

maps-kt-features/src/commonMain/kotlin/center/sciprog/maps/features/FeatureDrawScope.kt

@@ -15,8 +15,8 @@ import androidx.compose.ui.text.TextMeasurer
 import androidx.compose.ui.text.drawText
 import androidx.compose.ui.text.rememberTextMeasurer
 import androidx.compose.ui.unit.DpRect
-import center.sciprog.attributes.Attributes
 import io.github.oshai.kotlinlogging.KotlinLogging
+import space.kscience.attributes.Attributes
 
 /**
  * An extension of [DrawScope] to include map-specific features

maps-kt-features/src/commonMain/kotlin/center/sciprog/maps/features/FeatureFont.kt

@@ -1,5 +0,0 @@
-package center.sciprog.maps.features
-
-public expect class FeatureFont {
-    public var size: Float
-}

maps-kt-features/src/commonMain/kotlin/center/sciprog/maps/features/FeatureGroup.kt

@@ -9,8 +9,9 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.dp
-import center.sciprog.attributes.Attribute
+import org.jetbrains.skia.Font
-import center.sciprog.attributes.Attributes
+import space.kscience.attributes.Attribute
+import space.kscience.attributes.Attributes
 import space.kscience.kmath.geometry.Angle
 import space.kscience.kmath.nd.*
 import space.kscience.kmath.structures.Buffer
@@ -285,7 +286,7 @@ public fun <T : Any> FeatureGroup<T>.scalableImage(
 public fun <T : Any> FeatureGroup<T>.text(
     position: T,
     text: String,
-    font: FeatureFont.() -> Unit = { size = 16f },
+    font: Font.() -> Unit = { size = 16f },
     attributes: Attributes = Attributes.EMPTY,
     id: String? = null,
 ): FeatureRef<T, TextFeature<T>> = feature(
@@ -293,14 +294,14 @@ public fun <T : Any> FeatureGroup<T>.text(
     TextFeature(space, position, text, fontConfig = font, attributes = attributes)
 )
 
-public fun <T> StructureND(shape: ShapeND, initializer: (IntArray) -> T): StructureND<T> {
+//public fun <T> StructureND(shape: ShapeND, initializer: (IntArray) -> T): StructureND<T> {
-    val strides = Strides(shape)
+//    val strides = Strides(shape)
-    return BufferND(strides, Buffer.boxing(strides.linearSize) { initializer(strides.index(it)) })
+//    return BufferND(strides, Buffer(strides.linearSize) { initializer(strides.index(it)) })
-}
+//}
 
-public fun <T> Structure2D(rows: Int, columns: Int, initializer: (IntArray) -> T): Structure2D<T> {
+public inline fun <reified T> Structure2D(rows: Int, columns: Int, initializer: (IntArray) -> T): Structure2D<T> {
     val strides = Strides(ShapeND(rows, columns))
-    return BufferND(strides, Buffer.boxing(strides.linearSize) { initializer(strides.index(it)) }).as2D()
+    return BufferND(strides, Buffer(strides.linearSize) { initializer(strides.index(it)) }).as2D()
 }
 
 public fun <T : Any> FeatureGroup<T>.pixelMap(

maps-kt-features/src/commonMain/kotlin/center/sciprog/maps/features/compositeFeatures.kt

@@ -1,6 +1,6 @@
 package center.sciprog.maps.features
 
-import center.sciprog.attributes.Attributes
+import space.kscience.attributes.Attributes
 import kotlin.jvm.JvmName
 
 
@@ -18,7 +18,7 @@ public fun <T : Any> FeatureGroup<T>.draggableLine(
                 space,
                 aId.resolve().center,
                 bId.resolve().center,
-                Attributes {
+                Attributes<FeatureGroup<T>> {
                     ZAttribute(-10f)
                     lineId?.attributes?.let { from(it) }
                 }
@@ -51,7 +51,7 @@ public fun <T : Any> FeatureGroup<T>.draggableMultiLine(
             MultiLineFeature(
                 space,
                 points.map { it.resolve().center },
-                Attributes {
+                Attributes<FeatureGroup<T>>{
                     ZAttribute(-10f)
                     polygonId?.attributes?.let { from(it) }
                 }

maps-kt-features/src/commonMain/kotlin/center/sciprog/maps/features/drawFeature.kt

@@ -8,9 +8,8 @@ import androidx.compose.ui.graphics.Path
 import androidx.compose.ui.graphics.PointMode
 import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.graphics.drawscope.translate
-import center.sciprog.attributes.plus
+import space.kscience.attributes.plus
 import space.kscience.kmath.PerformancePitfall
-import space.kscience.kmath.geometry.degrees
 
 
 //internal fun Color.toPaint(): Paint = Paint().apply {
@@ -57,8 +56,8 @@ public fun <T : Any> FeatureDrawScope<T>.drawFeature(
 
             drawArc(
                 color = color,
-                startAngle = (feature.startAngle.degrees).toFloat(),
+                startAngle = (feature.startAngle.toDegrees().value).toFloat(),
-                sweepAngle = (feature.arcLength.degrees).toFloat(),
+                sweepAngle = (feature.arcLength.toDegrees().value).toFloat(),
                 useCenter = false,
                 topLeft = dpRect.topLeft,
                 size = size,
@@ -91,7 +90,11 @@ public fun <T : Any> FeatureDrawScope<T>.drawFeature(
 
         is FeatureGroup -> {
             feature.featureMap.values.forEach {
-                drawFeature(it.withAttributes { feature.attributes + this })
+                drawFeature(
+                    it.withAttributes {
+                        feature.attributes + this
+                    }
+                )
             }
         }
 

maps-kt-features/src/commonMain/kotlin/center/sciprog/maps/features/mapFeatureAttributes.kt

@@ -6,10 +6,7 @@ import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.PathEffect
 import androidx.compose.ui.input.pointer.PointerEvent
 import androidx.compose.ui.input.pointer.PointerKeyboardModifiers
-import center.sciprog.attributes.Attribute
+import space.kscience.attributes.*
-import center.sciprog.attributes.AttributesBuilder
-import center.sciprog.attributes.SetAttribute
-import center.sciprog.attributes.withAttribute
 
 public object ZAttribute : Attribute<Float>
 
@@ -50,21 +47,19 @@ public fun <T : Any, F : Feature<T>> FeatureRef<T, F>.zoomRange(range: FloatRang
 public object AlphaAttribute : Attribute<Float>
 
 public fun <T : Any, F : Feature<T>> FeatureRef<T, F>.modifyAttributes(
-    modification: AttributesBuilder.() -> Unit
+    modification: AttributesBuilder<F>.() -> Unit,
 ): FeatureRef<T, F> {
     @Suppress("UNCHECKED_CAST")
     parent.feature(
         id,
-        resolve().withAttributes {
+        resolve().withAttributes { modify(modification) } as F
-            AttributesBuilder(this).apply(modification).build()
-        } as F
     )
     return this
 }
 
 public fun <T : Any, F : Feature<T>, V> FeatureRef<T, F>.modifyAttribute(
     key: Attribute<V>,
-    value: V?,
+    value: V,
 ): FeatureRef<T, F> {
     @Suppress("UNCHECKED_CAST")
     parent.feature(id, resolve().withAttributes { withAttribute(key, value) } as F)

maps-kt-features/src/commonTest/kotlin/center/sciprog/attributes/AttributesSerializationTest.kt

@@ -1,13 +1,22 @@
 package center.sciprog.attributes
 
-import kotlinx.serialization.*
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.ExperimentalSerializationApi
+import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.modules.SerializersModule
 import kotlinx.serialization.modules.contextual
 import kotlinx.serialization.protobuf.ProtoBuf
+import kotlinx.serialization.serializer
+import space.kscience.AttributesSerializer
+import space.kscience.NameAttribute
+import space.kscience.SerializableAttribute
+import space.kscience.attributes.Attributes
+import space.kscience.equals
 import kotlin.test.Ignore
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.test.assertTrue
 
 internal class AttributesSerializationTest {
 
@@ -28,32 +37,36 @@ internal class AttributesSerializationTest {
         override fun toString(): String = "test"
     }
 
+    val serializer = AttributesSerializer(setOf(NameAttribute, TestAttribute, ContainerAttribute))
+
     @Test
     fun restoreFromJson() {
+
         val json = Json {
             serializersModule = SerializersModule {
-                contextual(AttributesSerializer(setOf(NameAttribute, TestAttribute, ContainerAttribute)))
+                contextual(serializer)
             }
         }
 
-        val attributes = Attributes {
+        val attributes = Attributes<Any> {
             NameAttribute("myTest")
             TestAttribute(mapOf("a" to "aa", "b" to "bb"))
             ContainerAttribute(
                 Container(
-                    Attributes {
+                    Attributes<Any> {
                         TestAttribute(mapOf("a" to "aa", "b" to "bb"))
                     }
                 )
             )
         }
 
-        val serialized: String = json.encodeToString(attributes)
+
+        val serialized: String = json.encodeToString(serializer, attributes)
         println(serialized)
 
-        val restored: Attributes = json.decodeFromString(serialized)
+        val restored: Attributes = json.decodeFromString(serializer, serialized)
 
-        assertEquals(attributes, restored)
+        assertTrue { Attributes.equals(attributes, restored) }
     }
 
     @OptIn(ExperimentalSerializationApi::class)
@@ -62,25 +75,25 @@ internal class AttributesSerializationTest {
     fun restoreFromProtoBuf() {
         val protoBuf = ProtoBuf {
             serializersModule = SerializersModule {
-                contextual(AttributesSerializer(setOf(NameAttribute, TestAttribute, ContainerAttribute)))
+                contextual(serializer)
             }
         }
 
-        val attributes = Attributes {
+        val attributes = Attributes<Any> {
             NameAttribute("myTest")
             TestAttribute(mapOf("a" to "aa", "b" to "bb"))
             ContainerAttribute(
                 Container(
-                    Attributes {
+                    Attributes<Any> {
                         TestAttribute(mapOf("a" to "aa", "b" to "bb"))
                     }
                 )
             )
         }
 
-        val serialized = protoBuf.encodeToByteArray(attributes)
+        val serialized = protoBuf.encodeToByteArray(serializer, attributes)
 
-        val restored: Attributes = protoBuf.decodeFromByteArray(serialized)
+        val restored: Attributes = protoBuf.decodeFromByteArray(serializer, serialized)
 
         assertEquals(attributes, restored)
     }

maps-kt-features/src/jsMain/kotlin/center/sciprog/maps/features/FeatureFont.kt

@@ -1,5 +0,0 @@
-package center.sciprog.maps.features
-
-public actual class FeatureFont {
-    public actual var size: Float = 16f
-}

maps-kt-features/src/jvmMain/kotlin/center/sciprog/maps/features/FeatureFont.kt

@@ -1,5 +0,0 @@
-package center.sciprog.maps.features
-
-import org.jetbrains.skia.Font
-
-public actual typealias FeatureFont = Font

maps-kt-geojson/build.gradle.kts

@@ -6,7 +6,9 @@ plugins {
 
 kscience{
     jvm()
-    js()
+//    js()
+    wasm()
+
     useSerialization {
         json()
     }

maps-kt-geojson/src/commonMain/kotlin/center/sciprog/maps/geojson/GeoJsonGeometry.kt

@@ -4,7 +4,6 @@ import center.sciprog.maps.coordinates.Gmc
 import center.sciprog.maps.coordinates.meters
 import center.sciprog.maps.geojson.GeoJsonGeometry.Companion.COORDINATES_KEY
 import kotlinx.serialization.json.*
-import space.kscience.kmath.geometry.degrees
 import kotlin.jvm.JvmInline
 
 public sealed interface GeoJsonGeometry : GeoJson {
@@ -35,8 +34,8 @@ internal fun JsonElement.toGmc() = jsonArray.run {
 }
 
 internal fun Gmc.toJsonArray(): JsonArray = buildJsonArray {
-    add(longitude.degrees)
+    add(longitude.toDegrees().value)
-    add(latitude.degrees)
+    add(latitude.toDegrees().value)
     elevation?.let {
         add(it.meters)
     }

maps-kt-geojson/src/commonMain/kotlin/center/sciprog/maps/geojson/GeoJsonPropertiesAttribute.kt

@@ -1,7 +1,7 @@
 package center.sciprog.maps.geojson
 
-import center.sciprog.attributes.SerializableAttribute
 import kotlinx.serialization.json.JsonObject
 import kotlinx.serialization.serializer
+import space.kscience.SerializableAttribute
 
 public object GeoJsonPropertiesAttribute : SerializableAttribute<JsonObject>("properties", serializer())

maps-kt-geojson/src/commonMain/kotlin/center/sciprog/maps/geojson/geoJsonToMap.kt

@@ -1,12 +1,12 @@
 package center.sciprog.maps.geojson
 
 import androidx.compose.ui.graphics.Color
-import center.sciprog.attributes.NameAttribute
 import center.sciprog.maps.coordinates.Gmc
 import center.sciprog.maps.features.*
 import kotlinx.serialization.json.contentOrNull
 import kotlinx.serialization.json.intOrNull
 import kotlinx.serialization.json.jsonPrimitive
+import space.kscience.NameAttribute
 
 
 /**

maps-kt-scheme/build.gradle.kts

@@ -6,7 +6,8 @@ plugins {
 
 kscience{
     jvm()
-    js()
+//    js()
+    wasm()
 }
 
 kotlin {
@@ -14,8 +15,6 @@ kotlin {
         commonMain {
             dependencies {
                 api(projects.mapsKtFeatures)
-                api("io.github.microutils:kotlin-logging:2.1.23")
-                api(compose.foundation)
             }
         }
         getByName("jvmMain"){

maps-kt-scheme/src/commonMain/kotlin/center/sciprog/maps/scheme/SchemeView.kt

@@ -3,14 +3,10 @@ package center.sciprog.maps.scheme
 import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.PathEffect
-import androidx.compose.ui.graphics.drawscope.Stroke
-import androidx.compose.ui.graphics.drawscope.clipRect
 import androidx.compose.ui.unit.DpSize
 import center.sciprog.maps.compose.canvasControls
 import center.sciprog.maps.features.*
-import mu.KotlinLogging
+import io.github.oshai.kotlinlogging.KotlinLogging
 import kotlin.math.min
 
 

maps-kt-scheme/src/commonMain/kotlin/center/sciprog/maps/scheme/schemeFeatures.kt

@@ -8,8 +8,8 @@ import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.unit.Dp
 import androidx.compose.ui.unit.DpSize
 import androidx.compose.ui.unit.dp
-import center.sciprog.attributes.Attributes
 import center.sciprog.maps.features.*
+import space.kscience.attributes.Attributes
 import space.kscience.kmath.geometry.Angle
 import kotlin.math.ceil
 

maps-kt-scheme/src/jvmMain/kotlin/center/sciprog/maps/svg/SvgCanvas.kt

@@ -301,7 +301,7 @@ internal class SvgCanvas(val graphics: SVGGraphics2D) : Canvas {
 }
 
 internal class SvgDrawContext(val graphics: SVGGraphics2D, override var size: Size) : DrawContext {
-    override val canvas: Canvas = SvgCanvas(graphics)
+    override var canvas: Canvas = SvgCanvas(graphics)
 
     override val transform: DrawTransform = asDrawTransform()
 }

maps-kt-scheme/src/jvmMain/kotlin/center/sciprog/maps/svg/SvgDrawScope.kt

@@ -4,15 +4,18 @@ import androidx.compose.ui.geometry.CornerRadius
 import androidx.compose.ui.geometry.Offset
 import androidx.compose.ui.geometry.Size
 import androidx.compose.ui.graphics.*
-import androidx.compose.ui.graphics.drawscope.*
+import androidx.compose.ui.graphics.drawscope.DrawContext
+import androidx.compose.ui.graphics.drawscope.DrawStyle
+import androidx.compose.ui.graphics.drawscope.Fill
+import androidx.compose.ui.graphics.drawscope.Stroke
 import androidx.compose.ui.graphics.painter.Painter
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.IntSize
 import androidx.compose.ui.unit.LayoutDirection
-import center.sciprog.attributes.Attributes
 import center.sciprog.maps.features.*
 import center.sciprog.maps.scheme.XY
 import org.jfree.svg.SVGGraphics2D
+import space.kscience.attributes.Attributes
 import java.awt.BasicStroke
 import java.awt.geom.*
 import java.awt.image.AffineTransformOp

settings.gradle.kts

@@ -61,6 +61,6 @@ include(
     ":demo:scheme",
     ":demo:polygon-editor",
     ":demo:trajectory-playground",
-    ":demo:maps-js"
+    ":demo:maps-wasm"
 )
 

trajectory-kt/build.gradle.kts

@@ -11,9 +11,12 @@ kscience{
     jvm()
     js()
     native()
+    wasm()
 
     useContextReceivers()
-    useSerialization()
+    useSerialization{
+        json()
+    }
     dependencies {
         api("space.kscience:kmath-geometry:$kmathVersion")
     }

trajectory-kt/src/commonMain/kotlin/space/kscience/AttributesSerializer.kt

@@ -1,12 +1,15 @@
 @file:Suppress("UNCHECKED_CAST")
 
-package center.sciprog.attributes
+package space.kscience
 
 import kotlinx.serialization.KSerializer
+import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 import kotlinx.serialization.json.*
+import space.kscience.attributes.Attribute
+import space.kscience.attributes.Attributes
 
 public class AttributesSerializer(
     private val serializableAttributes: Set<SerializableAttribute<*>>,
@@ -29,12 +32,16 @@ public class AttributesSerializer(
 
             attr to value
         }
-        return Attributes(attributeMap)
+        return object : Attributes {
+            override val content: Map<out Attribute<*>, Any?> = attributeMap
+            override fun toString(): String = "Attributes(value=${content.entries})"
+            override fun equals(other: Any?): Boolean = other is Attributes && Attributes.equals(this, other)
+        }
     }
 
     override fun serialize(encoder: Encoder, value: Attributes) {
         val json = buildJsonObject {
-            value.content.forEach { (key: Attribute<*>, value: Any) ->
+            value.content.forEach { (key: Attribute<*>, value: Any?) ->
                 if (key !in serializableAttributes) error("An attribute key '$key' is not in the list of allowed attributes for this serializer")
                 val serializableKey = key as SerializableAttribute
 
@@ -46,10 +53,22 @@ public class AttributesSerializer(
 
                 put(
                     serializableKey.serialId,
-                    json.encodeToJsonElement(serializableKey.serializer as KSerializer<Any>, value)
+                    json.encodeToJsonElement(serializableKey.serializer as KSerializer<Any?>, value)
                 )
             }
         }
         jsonSerializer.serialize(encoder, json)
     }
 }
+
+public abstract class SerializableAttribute<T>(
+    public val serialId: String,
+    public val serializer: KSerializer<T>,
+) : Attribute<T> {
+    override fun toString(): String = serialId
+}
+
+public object NameAttribute : SerializableAttribute<String>("name", String.serializer())
+
+public fun Attributes.Companion.equals(a1: Attributes, a2: Attributes): Boolean =
+    a1.keys == a2.keys && a1.keys.all { a1[it] == a2[it] }

trajectory-kt/src/commonMain/kotlin/space/kscience/geometryExtensions.kt

@@ -1,21 +1,25 @@
-package space.kscience.kmath.geometry
+package space.kscience
 
+import space.kscience.kmath.geometry.*
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.structures.Float64
 import space.kscience.trajectory.*
 import kotlin.math.abs
 import kotlin.math.pow
 import kotlin.math.sign
 import kotlin.math.sqrt
 
-public fun Euclidean2DSpace.circle(x: Number, y: Number, radius: Number): Circle2D =
+public fun Float64Space2D.circle(x: Number, y: Number, radius: Number): Circle2D<Float64> =
     Circle2D(vector(x, y), radius = radius.toDouble())
 
-public fun Euclidean2DSpace.segment(begin: DoubleVector2D, end: DoubleVector2D): LineSegment2D =
+public fun Float64Space2D.segment(begin: Vector2D<Float64>, end: Vector2D<Float64>): LineSegment2D =
     LineSegment(begin, end)
 
-public fun Euclidean2DSpace.segment(x1: Number, y1: Number, x2: Number, y2: Number): LineSegment2D =
+public fun Float64Space2D.segment(x1: Number, y1: Number, x2: Number, y2: Number): LineSegment2D =
     LineSegment(vector(x1, y1), vector(x2, y2))
 
-public fun Euclidean2DSpace.intersectsOrInside(circle1: Circle2D, circle2: Circle2D): Boolean {
+public fun Float64Space2D.intersectsOrInside(circle1: Circle2D<Float64>, circle2: Circle2D<Float64>): Boolean {
     val distance = norm(circle2.center - circle1.center)
     return distance <= circle1.radius + circle2.radius
 }
@@ -23,7 +27,7 @@ public fun Euclidean2DSpace.intersectsOrInside(circle1: Circle2D, circle2: Circl
 /**
  * https://mathworld.wolfram.com/Circle-LineIntersection.html
  */
-public fun Euclidean2DSpace.intersects(segment: LineSegment2D, circle: Circle2D): Boolean {
+public fun Float64Space2D.intersects(segment: LineSegment2D, circle: Circle2D<Float64>): Boolean {
     val direction = segment.end - segment.begin
     val radiusVector = segment.begin - circle.center
 
@@ -43,14 +47,14 @@ public fun Euclidean2DSpace.intersects(segment: LineSegment2D, circle: Circle2D)
 }
 
 
-public fun Euclidean2DSpace.intersects(circle: Circle2D, segment: LineSegment2D): Boolean =
+public fun Float64Space2D.intersects(circle: Circle2D<Float64>, segment: LineSegment2D): Boolean =
     intersects(segment, circle)
 
-public fun Euclidean2DSpace.intersects(segment1: LineSegment2D, segment2: LineSegment2D): Boolean {
+public fun Float64Space2D.intersects(segment1: LineSegment2D, segment2: LineSegment2D): Boolean {
-    infix fun DoubleVector2D.cross(v2: DoubleVector2D): Double = x * v2.y - y * v2.x
+    infix fun Vector2D<Float64>.cross(v2: Vector2D<Float64>): Double = x * v2.y - y * v2.x
-    infix fun DoubleVector2D.crossSign(v2: DoubleVector2D) = cross(v2).sign
+    infix fun Vector2D<Float64>.crossSign(v2: Vector2D<Float64>) = cross(v2).sign
 
-    return with(Euclidean2DSpace) {
+    return with(Float64Space2D) {
         (segment2.begin - segment1.begin) crossSign (segment2.end - segment1.begin) !=
                 (segment2.begin - segment1.end) crossSign (segment2.end - segment1.end) &&
                 (segment1.begin - segment2.begin) crossSign (segment1.end - segment2.begin) !=
@@ -58,7 +62,7 @@ public fun Euclidean2DSpace.intersects(segment1: LineSegment2D, segment2: LineSe
     }
 }
 
-public fun Euclidean2DSpace.intersectsTrajectory(segment: LineSegment2D, trajectory: Trajectory2D): Boolean =
+public fun Float64Space2D.intersectsTrajectory(segment: LineSegment2D, trajectory: Trajectory2D): Boolean =
     when (trajectory) {
         is CircleTrajectory2D -> intersects(segment, trajectory.circle)
         is StraightTrajectory2D -> intersects(segment, trajectory)
@@ -72,7 +76,7 @@ public fun Euclidean2DSpace.intersectsTrajectory(segment: LineSegment2D, traject
  *
  * @param bearing is counted the same way as in [Pose2D], from positive y clockwise
  */
-public fun Circle2D.tangent(bearing: Angle, direction: Trajectory2D.Direction): Pose2D = with(Euclidean2DSpace) {
+public fun Circle2D<Float64>.tangent(bearing: Angle, direction: Trajectory2D.Direction): Pose2D = with(Float64Space2D) {
     val coordinates: Vector2D<Double> = vector(center.x + radius * sin(bearing), center.y + radius * cos(bearing))
     val tangentAngle = when (direction) {
         Trajectory2D.R -> bearing + Angle.piDiv2
@@ -82,7 +86,7 @@ public fun Circle2D.tangent(bearing: Angle, direction: Trajectory2D.Direction):
 }
 
 
-public fun CircleTrajectory2D.containsPoint(point: DoubleVector2D): Boolean = with(Euclidean2DSpace) {
+public fun CircleTrajectory2D.containsPoint(point: Vector2D<Float64>): Boolean = with(Float64Space2D) {
     val radiusVector = point - center
     if (abs(norm(radiusVector) - circle.radius) > 1e-4 * circle.radius) error("Wrong radius")
     val radiusVectorBearing = radiusVector.bearing

trajectory-kt/src/commonMain/kotlin/space/kscience/kmath/geometry/polygonExtensions.kt

@@ -1,21 +0,0 @@
-package space.kscience.kmath.geometry
-
-import space.kscience.kmath.misc.zipWithNextCircular
-import space.kscience.trajectory.Trajectory2D
-
-public fun Euclidean2DSpace.polygon(points: List<DoubleVector2D>): Polygon<Double> = object : Polygon<Double> {
-    override val points: List<Vector2D<Double>> get() = points
-}
-
-public fun Euclidean2DSpace.intersects(polygon: Polygon<Double>, segment: LineSegment2D): Boolean =
-    polygon.points.zipWithNextCircular { l, r -> segment(l, r) }.any { intersects(it, segment) }
-
-public fun Euclidean2DSpace.intersects(polygon: Polygon<Double>, circle: Circle2D): Boolean =
-    polygon.points.zipWithNextCircular { l, r -> segment(l, r) }.any { intersects(it, circle) }
-
-public fun Euclidean2DSpace.intersectsTrajectory(polygon: Polygon<Double>, trajectory: Trajectory2D): Boolean =
-    polygon.points.zipWithNextCircular { l, r ->
-        segment(l, r)
-    }.any { edge ->
-        intersectsTrajectory(edge, trajectory)
-    }

trajectory-kt/src/commonMain/kotlin/space/kscience/polygonExtensions.kt

@@ -0,0 +1,28 @@
+package space.kscience
+
+import space.kscience.kmath.geometry.LineSegment2D
+import space.kscience.kmath.geometry.Polygon
+import space.kscience.kmath.geometry.Vector2D
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.misc.zipWithNextCircular
+import space.kscience.kmath.structures.Float64
+import space.kscience.trajectory.Trajectory2D
+
+public fun Float64Space2D.polygon(points: List<Vector2D<Double>>): Polygon<Vector2D<Float64>> =
+    object : Polygon<Vector2D<Float64>> {
+        override val points: List<Vector2D<Double>> get() = points
+    }
+
+public fun Float64Space2D.intersects(polygon: Polygon<Vector2D<Float64>>, segment: LineSegment2D): Boolean =
+    polygon.points.zipWithNextCircular { l, r -> segment(l, r) }.any { intersects(it, segment) }
+
+public fun Float64Space2D.intersects(polygon: Polygon<Vector2D<Float64>>, circle: Circle2D<Float64>): Boolean =
+    polygon.points.zipWithNextCircular { l, r -> segment(l, r) }.any { intersects(it, circle) }
+
+public fun Float64Space2D.intersectsTrajectory(polygon: Polygon<Vector2D<Float64>>, trajectory: Trajectory2D): Boolean =
+    polygon.points.zipWithNextCircular { l, r ->
+        segment(l, r)
+    }.any { edge ->
+        intersectsTrajectory(edge, trajectory)
+    }

trajectory-kt/src/commonMain/kotlin/space/kscience/trajectory/DubinsPath.kt

@@ -5,23 +5,33 @@
 
 package space.kscience.trajectory
 
-import space.kscience.kmath.geometry.*
+import space.kscience.kmath.geometry.cos
-import space.kscience.kmath.geometry.Euclidean2DSpace.distanceTo
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D.distanceTo
+import space.kscience.kmath.geometry.normalized
+import space.kscience.kmath.geometry.radians
+import space.kscience.kmath.geometry.sin
+import space.kscience.kmath.structures.Float64
 import space.kscience.trajectory.Trajectory2D.*
 import kotlin.math.acos
 
-internal fun Pose2D.getLeftCircle(radius: Double): Circle2D = getTangentCircles(radius).first
+internal fun Pose2D.getLeftCircle(radius: Double): Circle2D<Float64> = getTangentCircles(radius).first
 
-internal fun Pose2D.getRightCircle(radius: Double): Circle2D = getTangentCircles(radius).second
+internal fun Pose2D.getRightCircle(radius: Double): Circle2D<Float64> = getTangentCircles(radius).second
 
-internal fun Pose2D.getTangentCircles(radius: Double): Pair<Circle2D, Circle2D> = with(Euclidean2DSpace) {
+internal fun Pose2D.getTangentCircles(radius: Double): Pair<Circle2D<Float64>, Circle2D<Float64>> =
+    with(Float64Space2D) {
         val dX = radius * cos(bearing)
         val dY = radius * sin(bearing)
         return Circle2D(vector(x - dX, y + dY), radius) to Circle2D(vector(x + dX, y - dY), radius)
     }
 
-private fun outerTangent(from: Circle2D, to: Circle2D, direction: Direction): StraightTrajectory2D =
+private fun Float64Space2D.outerTangent(
-    with(Euclidean2DSpace) {
+    from: Circle2D<Float64>,
+    to: Circle2D<Float64>,
+    direction: Direction,
+): StraightTrajectory2D {
     val centers = StraightTrajectory2D(from.center, to.center)
     val p1 = when (direction) {
         L -> vector(
@@ -41,12 +51,11 @@ private fun outerTangent(from: Circle2D, to: Circle2D, direction: Direction): St
 }
 
 
-private fun innerTangent(
+private fun Float64Space2D.innerTangent(
-    from: Circle2D,
+    from: Circle2D<Float64>,
-    to: Circle2D,
+    to: Circle2D<Float64>,
     direction: Direction,
-): StraightTrajectory2D? =
+): StraightTrajectory2D? {
-    with(Euclidean2DSpace) {
     val centers = StraightTrajectory2D(from.center, to.center)
     if (centers.length < from.radius * 2) return null
     val angle = when (direction) {
@@ -118,7 +127,7 @@ public object DubinsPath {
         all(start, end, turningRadius).minBy { it.length }
 
     public fun rlr(start: Pose2D, end: Pose2D, turningRadius: Double): CompositeTrajectory2D? =
-        with(Euclidean2DSpace) {
+        with(Float64Space2D) {
             val c1 = start.getRightCircle(turningRadius)
             val c2 = end.getRightCircle(turningRadius)
             val centers = StraightTrajectory2D(c1.center, c2.center)
@@ -162,7 +171,7 @@ public object DubinsPath {
         }
 
     public fun lrl(start: Pose2D, end: Pose2D, turningRadius: Double): CompositeTrajectory2D? =
-        with(Euclidean2DSpace) {
+        with(Float64Space2D) {
             val c1 = start.getLeftCircle(turningRadius)
             val c2 = end.getLeftCircle(turningRadius)
             val centers = StraightTrajectory2D(c1.center, c2.center)
@@ -208,7 +217,7 @@ public object DubinsPath {
     public fun rsr(start: Pose2D, end: Pose2D, turningRadius: Double): CompositeTrajectory2D {
         val c1 = start.getRightCircle(turningRadius)
         val c2 = end.getRightCircle(turningRadius)
-        val s = outerTangent(c1, c2, L)
+        val s = Float64Space2D.outerTangent(c1, c2, L)
         val a1 = CircleTrajectory2D(c1.center, start, s.begin, R)
         val a3 = CircleTrajectory2D(c2.center, s.end, end, R)
         return CompositeTrajectory2D(a1, s, a3)
@@ -217,7 +226,7 @@ public object DubinsPath {
     public fun lsl(start: Pose2D, end: Pose2D, turningRadius: Double): CompositeTrajectory2D {
         val c1 = start.getLeftCircle(turningRadius)
         val c2 = end.getLeftCircle(turningRadius)
-        val s = outerTangent(c1, c2, R)
+        val s = Float64Space2D.outerTangent(c1, c2, R)
         val a1 = CircleTrajectory2D(c1.center, start, s.begin, L)
         val a3 = CircleTrajectory2D(c2.center, s.end, end, L)
         return CompositeTrajectory2D(a1, s, a3)
@@ -226,7 +235,7 @@ public object DubinsPath {
     public fun rsl(start: Pose2D, end: Pose2D, turningRadius: Double): CompositeTrajectory2D? {
         val c1 = start.getRightCircle(turningRadius)
         val c2 = end.getLeftCircle(turningRadius)
-        val s = innerTangent(c1, c2, R)
+        val s = Float64Space2D.innerTangent(c1, c2, R)
         if (s == null || c1.center.distanceTo(c2.center) < turningRadius * 2) return null
 
         val a1 = CircleTrajectory2D(c1.center, start, s.begin, R)
@@ -237,7 +246,7 @@ public object DubinsPath {
     public fun lsr(start: Pose2D, end: Pose2D, turningRadius: Double): CompositeTrajectory2D? {
         val c1 = start.getLeftCircle(turningRadius)
         val c2 = end.getRightCircle(turningRadius)
-        val s = innerTangent(c1, c2, L)
+        val s = Float64Space2D.innerTangent(c1, c2, L)
         if (s == null || c1.center.distanceTo(c2.center) < turningRadius * 2) return null
 
         val a1 = CircleTrajectory2D(c1.center, start, s.begin, L)

trajectory-kt/src/commonMain/kotlin/space/kscience/trajectory/Obstacle.kt

@@ -5,8 +5,15 @@
 
 package space.kscience.trajectory
 
-import space.kscience.kmath.geometry.*
+import space.kscience.intersectsTrajectory
+import space.kscience.kmath.geometry.Angle
+import space.kscience.kmath.geometry.Polygon
+import space.kscience.kmath.geometry.Vector2D
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
 import space.kscience.kmath.misc.zipWithNextCircular
+import space.kscience.kmath.structures.Float64
+import space.kscience.polygon
 
 
 public interface Obstacle {
@@ -30,7 +37,7 @@ public interface Obstacle {
     }
 }
 
-private class CircleObstacle(val circle: Circle2D) : Obstacle {
+private class CircleObstacle(val circle: Circle2D<Float64>) : Obstacle {
     override val center: Vector2D<Double> get() = circle.center
 
     override val arcs: List<CircleTrajectory2D>
@@ -41,7 +48,7 @@ private class CircleObstacle(val circle: Circle2D) : Obstacle {
 
 
     override fun intersectsTrajectory(trajectory: Trajectory2D): Boolean =
-        Euclidean2DSpace.intersectsTrajectory(circumvention, trajectory)
+        Float64Space2D.intersectsTrajectory(circumvention, trajectory)
 
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -67,18 +74,18 @@ private class CoreObstacle(override val circumvention: CompositeTrajectory2D) :
     }
 
     override val center: Vector2D<Double> by lazy {
-        Euclidean2DSpace.vector(
+        Float64Space2D.vector(
             arcs.sumOf { it.center.x } / arcs.size,
             arcs.sumOf { it.center.y } / arcs.size
         )
     }
 
-    val core: Polygon<Double> by lazy {
+    val core: Polygon<Vector2D<Float64>> by lazy {
-        Euclidean2DSpace.polygon(arcs.map { it.circle.center })
+        Float64Space2D.polygon(arcs.map { it.circle.center })
     }
 
     override fun intersectsTrajectory(trajectory: Trajectory2D): Boolean =
-        Euclidean2DSpace.intersectsTrajectory(core, trajectory)
+        Float64Space2D.intersectsTrajectory(core, trajectory)
 
 
     override fun equals(other: Any?): Boolean {
@@ -99,7 +106,7 @@ private class CoreObstacle(override val circumvention: CompositeTrajectory2D) :
     }
 }
 
-public fun Obstacle(circles: List<Circle2D>): Obstacle = with(Euclidean2DSpace) {
+public fun Obstacle(circles: List<Circle2D<Float64>>): Obstacle = with(Float64Space2D) {
     require(circles.isNotEmpty()) { "Can't create circumvention for an empty obstacle" }
     //Create a single circle obstacle
     if(circles.size == 1) return CircleObstacle(circles.first())
@@ -123,7 +130,7 @@ public fun Obstacle(circles: List<Circle2D>): Obstacle = with(Euclidean2DSpace)
         (it.center - center).bearing
     }
 
-    val tangents = convex.zipWithNextCircular { a: Circle2D, b: Circle2D ->
+    val tangents = convex.zipWithNextCircular { a: Circle2D<Float64>, b: Circle2D<Float64> ->
         tangentsBetweenCircles(a, b)[DubinsPath.Type.RSR]
             ?: error("Can't find right handed circumvention")
     }
@@ -144,7 +151,7 @@ public fun Obstacle(circles: List<Circle2D>): Obstacle = with(Euclidean2DSpace)
 }
 
 
-public fun Obstacle(vararg circles: Circle2D): Obstacle = Obstacle(listOf(*circles))
+public fun Obstacle(vararg circles: Circle2D<Float64>): Obstacle = Obstacle(listOf(*circles))
 
 public fun Obstacle(points: List<Vector2D<Double>>, radius: Double): Obstacle =
     Obstacle(points.map { Circle2D(it, radius) })

trajectory-kt/src/commonMain/kotlin/space/kscience/trajectory/Obstacles.kt

@@ -1,13 +1,21 @@
 package space.kscience.trajectory
 
-import space.kscience.kmath.geometry.*
+import space.kscience.containsPoint
+import space.kscience.intersects
+import space.kscience.intersectsOrInside
+import space.kscience.kmath.geometry.Angle
+import space.kscience.kmath.geometry.Polygon
+import space.kscience.kmath.geometry.Vector2D
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.structures.Float64
 import kotlin.collections.component1
 import kotlin.collections.component2
 
 /**
  * The same as [intersectsTrajectory], but bypasses same circles or same straights
  */
-private fun Euclidean2DSpace.intersectsOtherTrajectory(a: Trajectory2D, b: Trajectory2D): Boolean = when (a) {
+private fun Float64Space2D.intersectsOtherTrajectory(a: Trajectory2D, b: Trajectory2D): Boolean = when (a) {
     is CircleTrajectory2D -> when (b) {
         is CircleTrajectory2D -> a != b && intersectsOrInside(a.circle, b.circle)
         is StraightTrajectory2D -> intersects(a.circle, b)
@@ -32,7 +40,7 @@ public class Obstacles(public val obstacles: List<Obstacle>) {
         val direction: Trajectory2D.Direction,
     ) {
         val obstacle: Obstacle get() = obstacles[obstacleIndex]
-        val circle: Circle2D get() = obstacle.arcs[nodeIndex].circle
+        val circle: Circle2D<Float64> get() = obstacle.arcs[nodeIndex].circle
     }
 
     private inner class ObstacleTangent(
@@ -44,7 +52,7 @@ public class Obstacles(public val obstacles: List<Obstacle>) {
          * If false, this tangent intersects another obstacle
          */
         val isValid by lazy {
-            with(Euclidean2DSpace) {
+            with(Float64Space2D) {
                 obstacles.indices.none {
                     it != from?.obstacleIndex && it != to?.obstacleIndex && obstacles[it].intersectsTrajectory(
                         tangentTrajectory
@@ -64,7 +72,7 @@ public class Obstacles(public val obstacles: List<Obstacle>) {
     private fun tangentsBetween(
         firstIndex: Int,
         secondIndex: Int,
-    ): Map<DubinsPath.Type, ObstacleTangent> = with(Euclidean2DSpace) {
+    ): Map<DubinsPath.Type, ObstacleTangent> = with(Float64Space2D) {
         val first = obstacles[firstIndex]
         val second = obstacles[secondIndex]
         buildMap {
@@ -99,7 +107,7 @@ public class Obstacles(public val obstacles: List<Obstacle>) {
     private fun tangentsFromArc(
         arc: CircleTrajectory2D,
         obstacleIndex: Int,
-    ): Map<DubinsPath.Type, ObstacleTangent> = with(Euclidean2DSpace) {
+    ): Map<DubinsPath.Type, ObstacleTangent> = with(Float64Space2D) {
         val obstacle = obstacles[obstacleIndex]
         buildMap {
             for (circleIndex in obstacle.arcs.indices) {
@@ -127,7 +135,7 @@ public class Obstacles(public val obstacles: List<Obstacle>) {
         obstacleIndex: Int,
         obstacleDirection: Trajectory2D.Direction,
         arc: CircleTrajectory2D,
-    ): ObstacleTangent? = with(Euclidean2DSpace) {
+    ): ObstacleTangent? = with(Float64Space2D) {
         val obstacle = obstacles[obstacleIndex]
         for (circleIndex in obstacle.arcs.indices) {
             val obstacleArc = obstacle.arcs[circleIndex]
@@ -207,7 +215,7 @@ public class Obstacles(public val obstacles: List<Obstacle>) {
 
     private fun avoiding(
         dubinsPath: CompositeTrajectory2D,
-    ): Collection<Trajectory2D> = with(Euclidean2DSpace) {
+    ): Collection<Trajectory2D> = with(Float64Space2D) {
         //fast return if no obstacles intersect the direct path
         if (obstacles.none { it.intersectsTrajectory(dubinsPath) }) return listOf(dubinsPath)
 
@@ -337,7 +345,7 @@ public class Obstacles(public val obstacles: List<Obstacle>) {
             start: Pose2D,
             finish: Pose2D,
             radius: Double,
-            vararg polygons: Polygon<Double>,
+            vararg polygons: Polygon<Vector2D<Float64>>,
         ): List<Trajectory2D> {
             val obstacles: List<Obstacle> = polygons.map { polygon ->
                 Obstacle(polygon.points, radius)
@@ -350,7 +358,7 @@ public class Obstacles(public val obstacles: List<Obstacle>) {
             start: Pose2D,
             finish: Pose2D,
             radius: Double,
-            polygons: Collection<Polygon<Double>>,
+            polygons: Collection<Polygon<Vector2D<Float64>>>,
         ): List<Trajectory2D> {
             val obstacles: List<Obstacle> = polygons.map { polygon ->
                 Obstacle(polygon.points, radius)

trajectory-kt/src/commonMain/kotlin/space/kscience/trajectory/Pose2D.kt

@@ -2,7 +2,7 @@
  * Copyright 2018-2022 KMath contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
-@file:UseSerializers(Euclidean2DSpace.VectorSerializer::class)
+@file:UseSerializers(Float64Space2D.VectorSerializer::class)
 
 package space.kscience.trajectory
 
@@ -14,14 +14,16 @@ import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
 import space.kscience.kmath.geometry.*
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.structures.Float64
 import kotlin.math.atan2
 
 /**
  * Combination of [Vector] and its view angle (clockwise from positive y-axis direction)
  */
 @Serializable(Pose2DSerializer::class)
-public interface Pose2D : DoubleVector2D {
+public interface Pose2D : Vector2D<Float64> {
-    public val coordinates: DoubleVector2D
+    public val coordinates: Vector2D<Float64>
     public val bearing: Angle
 
     /**
@@ -31,9 +33,9 @@ public interface Pose2D : DoubleVector2D {
 
     public companion object {
         public fun bearingToVector(bearing: Angle): Vector2D<Double> =
-            Euclidean2DSpace.vector(cos(bearing), sin(bearing))
+            Float64Space2D.vector(cos(bearing), sin(bearing))
 
-        public fun vectorToBearing(vector2D: DoubleVector2D): Angle {
+        public fun vectorToBearing(vector2D: Vector2D<Float64>): Angle {
             require(vector2D.x != 0.0 || vector2D.y != 0.0) { "Can't get bearing of zero vector" }
             return atan2(vector2D.y, vector2D.x).radians
         }
@@ -43,25 +45,24 @@ public interface Pose2D : DoubleVector2D {
 
 @Serializable
 public class PhaseVector2D(
-    override val coordinates: DoubleVector2D,
+    override val coordinates: Vector2D<Float64>,
-    public val velocity: DoubleVector2D,
+    public val velocity: Vector2D<Float64>,
-) : Pose2D, DoubleVector2D by coordinates {
+) : Pose2D, Vector2D<Float64> by coordinates {
     override val bearing: Angle get() = atan2(velocity.x, velocity.y).radians
 
-    override fun reversed(): Pose2D = with(Euclidean2DSpace) { PhaseVector2D(coordinates, -velocity) }
+    override fun reversed(): Pose2D = with(Float64Space2D) { PhaseVector2D(coordinates, -velocity) }
 }
 
 @Serializable
 @SerialName("DubinsPose2D")
 private class Pose2DImpl(
-    override val coordinates: DoubleVector2D,
+    override val coordinates: Vector2D<Float64>,
     override val bearing: Angle,
-) : Pose2D, DoubleVector2D by coordinates {
+) : Pose2D, Vector2D<Float64> by coordinates {
 
     override fun reversed(): Pose2D = Pose2DImpl(coordinates, bearing.plus(Angle.pi).normalized())
 
 
-
     override fun toString(): String = "Pose2D(x=$x, y=$y, bearing=$bearing)"
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
@@ -96,11 +97,11 @@ public object Pose2DSerializer : KSerializer<Pose2D> {
     }
 }
 
-public fun Pose2D(coordinate: DoubleVector2D, bearing: Angle): Pose2D =
+public fun Pose2D(coordinate: Vector2D<Float64>, bearing: Angle): Pose2D =
     Pose2DImpl(coordinate, bearing)
 
-public fun Pose2D(point: DoubleVector2D, direction: DoubleVector2D): Pose2D =
+public fun Pose2D(point: Vector2D<Float64>, direction: Vector2D<Float64>): Pose2D =
     Pose2D(point, Pose2D.vectorToBearing(direction))
 
 public fun Pose2D(x: Number, y: Number, bearing: Angle): Pose2D =
-    Pose2DImpl(Euclidean2DSpace.vector(x, y), bearing)
+    Pose2DImpl(Float64Space2D.vector(x, y), bearing)

trajectory-kt/src/commonMain/kotlin/space/kscience/trajectory/Trajectory2D.kt

@@ -2,16 +2,21 @@
  * Copyright 2018-2022 KMath contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
-@file:UseSerializers(Euclidean2DSpace.VectorSerializer::class)
+@file:UseSerializers(Float64Space2D.VectorSerializer::class)
 
 package space.kscience.trajectory
 
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.UseSerializers
+import space.kscience.intersects
+import space.kscience.intersectsOrInside
 import space.kscience.kmath.geometry.*
-import space.kscience.kmath.geometry.Euclidean2DSpace.distanceTo
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
-import space.kscience.kmath.geometry.Euclidean2DSpace.minus
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D.distanceTo
+import space.kscience.kmath.structures.Float64
+import space.kscience.tangent
 import kotlin.math.atan2
 
 @Serializable
@@ -44,7 +49,7 @@ public sealed interface Trajectory2D {
 }
 
 
-public val DoubleVector2D.bearing: Angle get() = (atan2(x, y).radians).normalized()
+public val Vector2D<Float64>.bearing: Angle get() = (atan2(x, y).radians).normalized()
 
 /**
  * Straight path segment. The order of start and end defines the direction
@@ -52,13 +57,13 @@ public val DoubleVector2D.bearing: Angle get() = (atan2(x, y).radians).normalize
 @Serializable
 @SerialName("straight")
 public data class StraightTrajectory2D(
-    override val begin: DoubleVector2D,
+    override val begin: Vector2D<Float64>,
-    override val end: DoubleVector2D,
+    override val end: Vector2D<Float64>,
 ) : Trajectory2D, LineSegment2D {
 
     override val length: Double get() = begin.distanceTo(end)
 
-    public val bearing: Angle get() = (end - begin).bearing
+    public val bearing: Angle get() = with(Float64Space2D) { (end - begin).bearing }
 
     override val beginPose: Pose2D get() = Pose2D(begin, bearing)
     override val endPose: Pose2D get() = Pose2D(end, bearing)
@@ -75,7 +80,7 @@ public fun StraightTrajectory2D(segment: LineSegment2D): StraightTrajectory2D =
 @Serializable
 @SerialName("arc")
 public data class CircleTrajectory2D(
-    public val circle: Circle2D,
+    public val circle: Circle2D<Float64>,
     public val arcStart: Angle,
     public val arcAngle: Angle,
 ) : Trajectory2D {
@@ -86,7 +91,7 @@ public data class CircleTrajectory2D(
     override val endPose: Pose2D get() = circle.tangent(arcEnd, direction)
 
     override val length: Double by lazy {
-        circle.radius * kotlin.math.abs(arcAngle.radians)
+        circle.radius * kotlin.math.abs(arcAngle.toRadians().value)
     }
 
     val center: Vector2D<Double> get() = circle.center
@@ -98,11 +103,11 @@ public data class CircleTrajectory2D(
 }
 
 public fun CircleTrajectory2D(
-    center: DoubleVector2D,
+    center: Vector2D<Float64>,
-    start: DoubleVector2D,
+    start: Vector2D<Float64>,
-    end: DoubleVector2D,
+    end: Vector2D<Float64>,
     direction: Trajectory2D.Direction,
-): CircleTrajectory2D = with(Euclidean2DSpace) {
+): CircleTrajectory2D = with(Float64Space2D) {
     val startVector = start - center
     val endVector = end - center
     val startRadius = norm(startVector)
@@ -131,11 +136,11 @@ public fun CircleTrajectory2D(
 }
 
 public fun CircleTrajectory2D(
-    circle: Circle2D,
+    circle: Circle2D<Float64>,
-    start: DoubleVector2D,
+    start: Vector2D<Float64>,
-    end: DoubleVector2D,
+    end: Vector2D<Float64>,
     direction: Trajectory2D.Direction,
-): CircleTrajectory2D = with(Euclidean2DSpace) {
+): CircleTrajectory2D = with(Float64Space2D) {
     val startVector = start - circle.center
     val endVector = end - circle.center
     val startBearing = startVector.bearing
@@ -161,10 +166,10 @@ public fun CircleTrajectory2D(
 
 @Deprecated("Use angle notation instead")
 public fun CircleTrajectory2D(
-    circle: Circle2D,
+    circle: Circle2D<Float64>,
     beginPose: Pose2D,
     endPose: Pose2D,
-): CircleTrajectory2D = with(Euclidean2DSpace) {
+): CircleTrajectory2D = with(Float64Space2D) {
     val vectorToBegin = beginPose - circle.center
     val vectorToEnd = endPose - circle.center
     //TODO check pose bearing
@@ -185,7 +190,7 @@ public class CompositeTrajectory2D(public val segments: List<Trajectory2D>) : Tr
 public fun CompositeTrajectory2D(vararg segments: Trajectory2D): CompositeTrajectory2D =
     CompositeTrajectory2D(segments.toList())
 
-public fun Euclidean2DSpace.intersectsTrajectory(a: Trajectory2D, b: Trajectory2D): Boolean = when (a) {
+public fun Float64Space2D.intersectsTrajectory(a: Trajectory2D, b: Trajectory2D): Boolean = when (a) {
     is CircleTrajectory2D -> when (b) {
         is CircleTrajectory2D -> intersectsOrInside(a.circle, b.circle)
         is StraightTrajectory2D -> intersects(a.circle, b)

trajectory-kt/src/commonMain/kotlin/space/kscience/trajectory/circumvention.kt

@@ -1,6 +1,10 @@
 package space.kscience.trajectory
 
+import space.kscience.containsPoint
 import space.kscience.kmath.geometry.*
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.structures.Float64
 import space.kscience.trajectory.DubinsPath.Type
 import kotlin.math.*
 
@@ -10,9 +14,9 @@ import kotlin.math.*
  * This method returns a map of segments using [DubinsPath] connection type notation.
  */
 internal fun tangentsBetweenCircles(
-    first: Circle2D,
+    first: Circle2D<Float64>,
-    second: Circle2D,
+    second: Circle2D<Float64>,
-): Map<Type, StraightTrajectory2D> = with(Euclidean2DSpace) {
+): Map<Type, StraightTrajectory2D> = with(Float64Space2D) {
     // Distance between centers
     val distanceBetweenCenters: Double = first.center.distanceTo(second.center)
 

trajectory-kt/src/commonTest/kotlin/space/kscience/kmath/geometry/ArcTests.kt

@@ -5,6 +5,11 @@
 
 package space.kscience.kmath.geometry
 
+import space.kscience.circle
+import space.kscience.containsPoint
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.geometry.euclidean2d.circumference
 import space.kscience.trajectory.CircleTrajectory2D
 import space.kscience.trajectory.Trajectory2D
 import kotlin.math.PI
@@ -16,7 +21,7 @@ import kotlin.test.assertTrue
 class ArcTests {
 
     @Test
-    fun arc() = with(Euclidean2DSpace) {
+    fun arc() = with(Float64Space2D) {
         val circle = Circle2D(vector(0.0, 0.0), 2.0)
         val arc = CircleTrajectory2D(
             circle.center,
@@ -25,12 +30,12 @@ class ArcTests {
             Trajectory2D.R
         )
         assertEquals(circle.circumference / 4, arc.length, 1.0)
-        assertEquals(0.0, arc.beginPose.bearing.degrees)
+        assertEquals(0.0, arc.beginPose.bearing.toDegrees().value)
-        assertEquals(90.0, arc.endPose.bearing.degrees)
+        assertEquals(90.0, arc.endPose.bearing.toDegrees().value)
     }
 
     @Test
-    fun quarter() = with(Euclidean2DSpace) {
+    fun quarter() = with(Float64Space2D) {
         val circle = circle(1, 0, 1)
         val arc = CircleTrajectory2D(
             circle,
@@ -38,11 +43,11 @@ class ArcTests {
             (PI/2).radians
         )
         assertEquals(Trajectory2D.R, arc.direction)
-        assertEquals(PI, arc.arcEnd.radians, 1e-4)
+        assertEquals(PI, arc.arcEnd.toRadians().value, 1e-4)
     }
 
     @Test
-    fun arcContains() = with(Euclidean2DSpace) {
+    fun arcContains() = with(Float64Space2D) {
         val circle = circle(0, 0, 1.0)
 
         val arc1 = CircleTrajectory2D(circle, Angle.pi / 4, Angle.piDiv2)

trajectory-kt/src/commonTest/kotlin/space/kscience/kmath/geometry/CircleTests.kt

@@ -5,6 +5,14 @@
 
 package space.kscience.kmath.geometry
 
+import space.kscience.circle
+import space.kscience.intersects
+import space.kscience.intersectsOrInside
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
+import space.kscience.kmath.geometry.euclidean2d.circumference
+import space.kscience.kmath.structures.Float64
+import space.kscience.segment
 import kotlin.math.pow
 import kotlin.math.sqrt
 import kotlin.test.Test
@@ -16,7 +24,7 @@ class CircleTests {
 
     @Test
     fun circle() {
-        val center = Euclidean2DSpace.vector(0.0, 0.0)
+        val center = Float64Space2D.vector(0.0, 0.0)
         val radius = 2.0
         val expectedCircumference = 12.56637
         val circle = Circle2D(center, radius)
@@ -24,7 +32,7 @@ class CircleTests {
     }
 
     @Test
-    fun circleIntersection() = with(Euclidean2DSpace) {
+    fun circleIntersection() = with(Float64Space2D) {
         assertTrue {
             intersectsOrInside(
                 circle(0.0, 0.0, 1.0),
@@ -46,7 +54,7 @@ class CircleTests {
     }
 
     @Test
-    fun circleLineIntersection() = with(Euclidean2DSpace) {
+    fun circleLineIntersection() = with(Float64Space2D) {
         assertTrue {
             intersects(circle(0, 0, 1.0), segment(1, 1, -1, 1))
         }
@@ -84,7 +92,7 @@ class CircleTests {
         }
     }
 
-    private fun Euclidean2DSpace.oldIntersect(circle: Circle2D, segment: LineSegment2D): Boolean{
+    private fun Float64Space2D.oldIntersect(circle: Circle2D<Float64>, segment: LineSegment2D): Boolean{
         val begin = segment.begin
         val end = segment.end
         val lengthSquared = (begin.x - end.x).pow(2) + (begin.y - end.y).pow(2)
@@ -111,7 +119,7 @@ class CircleTests {
     }
 
     @Test
-    fun oldCircleLineIntersection() = with(Euclidean2DSpace){
+    fun oldCircleLineIntersection() = with(Float64Space2D){
         assertTrue {
             oldIntersect(circle(0, 0, 1.1), segment(1, 1, -1, 1))
         }

trajectory-kt/src/commonTest/kotlin/space/kscience/kmath/geometry/LineTests.kt

@@ -5,6 +5,7 @@
 
 package space.kscience.kmath.geometry
 
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
 import space.kscience.trajectory.StraightTrajectory2D
 import kotlin.math.pow
 import kotlin.math.sqrt
@@ -14,22 +15,22 @@ import kotlin.test.assertEquals
 class LineTests {
 
     @Test
-    fun lineTest() = with(Euclidean2DSpace){
+    fun lineTest() = with(Float64Space2D){
         val straight = StraightTrajectory2D(vector(0.0, 0.0), vector(100.0, 100.0))
         assertEquals(sqrt(100.0.pow(2) + 100.0.pow(2)), straight.length)
-        assertEquals(45.0, straight.bearing.degrees)
+        assertEquals(45.0, straight.bearing.toDegrees().value)
     }
 
     @Test
-    fun lineAngleTest() = with(Euclidean2DSpace){
+    fun lineAngleTest() = with(Float64Space2D){
         //val zero = Vector2D(0.0, 0.0)
         val north = StraightTrajectory2D(zero, vector(0.0, 2.0))
-        assertEquals(0.0, north.bearing.degrees)
+        assertEquals(0.0, north.bearing.toDegrees().value)
         val east = StraightTrajectory2D(zero, vector(2.0, 0.0))
-        assertEquals(90.0, east.bearing.degrees)
+        assertEquals(90.0, east.bearing.toDegrees().value)
         val south = StraightTrajectory2D(zero, vector(0.0, -2.0))
-        assertEquals(180.0, south.bearing.degrees)
+        assertEquals(180.0, south.bearing.toDegrees().value)
         val west = StraightTrajectory2D(zero, vector(-2.0, 0.0))
-        assertEquals(270.0, west.bearing.degrees)
+        assertEquals(270.0, west.bearing.toDegrees().value)
     }
 }

trajectory-kt/src/commonTest/kotlin/space/kscience/trajectory/DubinsTests.kt

@@ -5,7 +5,7 @@
 
 package space.kscience.trajectory
 
-import space.kscience.kmath.geometry.Euclidean2DSpace
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
@@ -14,7 +14,7 @@ import kotlin.test.assertNotNull
 class DubinsTests {
 
     @Test
-    fun dubinsTest() = with(Euclidean2DSpace) {
+    fun dubinsTest() = with(Float64Space2D) {
         val straight = StraightTrajectory2D(vector(0.0, 0.0), vector(100.0, 100.0))
         val lineP1 = straight.shift(1, 10.0).inverse()
 

trajectory-kt/src/commonTest/kotlin/space/kscience/trajectory/ObstacleTest.kt

@@ -6,10 +6,10 @@
 package space.kscience.trajectory
 
 import space.kscience.kmath.geometry.Angle
-import space.kscience.kmath.geometry.Circle2D
 import space.kscience.kmath.geometry.Degrees
-import space.kscience.kmath.geometry.Euclidean2DSpace.vector
 import space.kscience.kmath.geometry.degrees
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
 import kotlin.math.PI
 import kotlin.test.Test
 import kotlin.test.assertEquals
@@ -18,7 +18,7 @@ import kotlin.test.assertTrue
 class ObstacleTest {
 
     @Test
-    fun equalObstacles() {
+    fun equalObstacles() = with(Float64Space2D) {
         val circle1 = Circle2D(vector(1.0, 6.5), 0.5)
         val circle2 = Circle2D(vector(1.0, 6.5), 0.5)
         assertEquals(circle1, circle2)
@@ -28,7 +28,7 @@ class ObstacleTest {
     }
 
     @Test
-    fun singePoint() {
+    fun singePoint() = with(Float64Space2D) {
         val outputTangents: List<Trajectory2D> = Obstacles.avoidObstacles(
             Pose2D(-5, -1, Angle.pi / 4),
             Pose2D(20, 4, Angle.pi * 3 / 4),
@@ -41,7 +41,7 @@ class ObstacleTest {
     }
 
     @Test
-    fun twoObstacles() {
+    fun twoObstacles() = with(Float64Space2D) {
         val paths = Obstacles.avoidObstacles(
             Pose2D(-5, -1, Angle.pi / 4),
             Pose2D(20, 4, Angle.pi * 3 / 4),
@@ -64,7 +64,7 @@ class ObstacleTest {
     }
 
     @Test
-    fun circumvention() {
+    fun circumvention() = with(Float64Space2D) {
         val obstacle = Obstacle(
             Circle2D(vector(0.0, 0.0), 1.0),
             Circle2D(vector(0.0, 1.0), 1.0),
@@ -80,7 +80,7 @@ class ObstacleTest {
     }
 
     @Test
-    fun closePoints() {
+    fun closePoints() = with(Float64Space2D) {
         val obstacle = Obstacle(
             Circle2D(vector(0.0, 0.0), 1.0),
             Circle2D(vector(0.0, 1.0), 1.0),
@@ -100,7 +100,7 @@ class ObstacleTest {
     }
 
     @Test
-    fun largeCoordinates() {
+    fun largeCoordinates() = with(Float64Space2D) {
         val startPoints = listOf(
             Pose2D(x = 484149.535516561, y = 2995086.2534208703, bearing = Degrees(3.401475378237137))
         )

trajectory-kt/src/commonTest/kotlin/space/kscience/trajectory/TangentTest.kt

@@ -5,18 +5,17 @@
 
 package space.kscience.trajectory
 
-import space.kscience.kmath.geometry.Circle2D
-import space.kscience.kmath.geometry.Euclidean2DSpace
-import space.kscience.kmath.geometry.Euclidean2DSpace.vector
 import space.kscience.kmath.geometry.LineSegment
 import space.kscience.kmath.geometry.equalsLine
+import space.kscience.kmath.geometry.euclidean2d.Circle2D
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
 
 class TangentTest {
     @Test
-    fun tangents() {
+    fun tangents() = with(Float64Space2D) {
         val c1 = Circle2D(vector(0.0, 0.0), 1.0)
         val c2 = Circle2D(vector(4.0, 0.0), 1.0)
         val routes = listOf(
@@ -50,12 +49,12 @@ class TangentTest {
 
         assertEquals(routes, tangentMapKeys)
         for (i in segments.indices) {
-            assertTrue(segments[i].equalsLine(Euclidean2DSpace, tangentMapValues[i]))
+            assertTrue(segments[i].equalsLine(Float64Space2D, tangentMapValues[i]))
         }
     }
 
     @Test
-    fun concentric(){
+    fun concentric() = with(Float64Space2D) {
         val c1 = Circle2D(vector(0.0, 0.0), 10.0)
         val c2 = Circle2D(vector(0.0, 0.0), 1.0)
         assertEquals(emptyMap(), tangentsBetweenCircles(c1, c2))

trajectory-kt/src/commonTest/kotlin/space/kscience/trajectory/testutils.kt

@@ -5,20 +5,19 @@
 
 package space.kscience.trajectory
 
-import space.kscience.kmath.geometry.Euclidean2DSpace
+import space.kscience.kmath.geometry.euclidean2d.Float64Space2D
-import space.kscience.kmath.geometry.radians
 import space.kscience.kmath.geometry.sin
 
 
 fun assertEquals(expected: Pose2D, actual: Pose2D, precision: Double = 1e-6) {
     kotlin.test.assertEquals(expected.x, actual.x, precision)
     kotlin.test.assertEquals(expected.y, actual.y, precision)
-    kotlin.test.assertEquals(expected.bearing.radians, actual.bearing.radians, precision)
+    kotlin.test.assertEquals(expected.bearing.toRadians().value, actual.bearing.toRadians().value, precision)
 }
 
 fun StraightTrajectory2D.inverse() = StraightTrajectory2D(end, begin)
 
-fun StraightTrajectory2D.shift(shift: Int, width: Double): StraightTrajectory2D = with(Euclidean2DSpace) {
+fun StraightTrajectory2D.shift(shift: Int, width: Double): StraightTrajectory2D = with(Float64Space2D) {
     val dX = width * sin(inverse().bearing)
     val dY = width * sin(bearing)