Merge pull request #449 from Kotlin/geo

Geo

Author: AndreiKingsley

build.gradle.kts

@@ -37,6 +37,7 @@ val published = listOf(
     "kandy-api",
     "kandy-echarts",
     "kandy-lets-plot",
+    "kandy-geo",
     "kandy-util"
 )
 

gradle/libs.versions.toml

@@ -7,18 +7,21 @@ nexus = "1.3.0"
 jupyterApi = "0.12.0-250"
 
 # libraries version
-dataframe = "0.14.1"
+dataframe = "0.15.0"
 serialization = "1.6.3"
 datetime = "0.6.0"
 html = "0.11.0"
 statistics = "0.4.0-dev-8"
 letsPlot = "4.7.3"
 letsPlotImage = "4.3.3"
 mockk = "1.13.10"
+geotools = "32.0"
+jai-core = "1.1.3"
 
 [libraries]
 # Kotlinx libraries
 kotlinx-dataframe = { group = "org.jetbrains.kotlinx", name = "dataframe", version.ref = "dataframe" }
+kotlinx-dataframe-geo = { group = "org.jetbrains.kotlinx", name = "dataframe-geo", version.ref = "dataframe" }
 kotlinx-serialization-json = { group = "org.jetbrains.kotlinx", name = "kotlinx-serialization-json", version.ref = "serialization" }
 kotlinx-datetime = { group = "org.jetbrains.kotlinx", name = "kotlinx-datetime", version.ref = "datetime" }
 kotlinx-html = { group = "org.jetbrains.kotlinx", name = "kotlinx-html-jvm", version.ref = "html" }
@@ -27,6 +30,15 @@ kotlinx-statistics = { group = "org.jetbrains.kotlinx", name = "kotlin-statistic
 lets-plot = { group = "org.jetbrains.lets-plot", name = "lets-plot-kotlin-jvm", version.ref = "letsPlot" }
 lets-plot-image = { group = "org.jetbrains.lets-plot", name = "lets-plot-image-export", version.ref = "letsPlotImage" }
 lets-plot-awt = { group = "org.jetbrains.lets-plot", name = "platf-awt-jvm", version.ref = "letsPlotImage" }
+lets-plot-geotools = { group = "org.jetbrains.lets-plot", name = "lets-plot-kotlin-geotools", version.ref = "letsPlot" }
+#Geootools
+jai-core = { module = "javax.media:jai-core", version.ref = "jai-core" }
+
+geotools-main = { module = "org.geotools:gt-main", version.ref = "geotools" }
+geotools-shapefile = { module = "org.geotools:gt-shapefile", version.ref = "geotools" }
+geotools-geojson = { module = "org.geotools:gt-geojson", version.ref = "geotools" }
+geotools-referencing = { module = "org.geotools:gt-referencing", version.ref = "geotools" }
+geotools-epsg-hsql = { module = "org.geotools:gt-epsg-hsql", version.ref = "geotools" }
 
 # Testing
 kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" }

kandy-api/src/main/kotlin/org/jetbrains/kotlinx/kandy/dsl/internal/dataframe/concatFixed.kt

@@ -13,7 +13,7 @@ internal fun <T, R> GroupBy<T, R>.concatFixed(): DataFrame<R> {
     return mapToFrames {
         val rowsCount = group.rowsCount()
         val keyColumns = keyNames.filter { it !in group.columnNames() }.map { keyName ->
-            DataColumn.create(keyName, List(rowsCount) { key[keyName] }, Infer.Type)
+            DataColumn.createByType(keyName, List(rowsCount) { key[keyName] }, Infer.Type)
         }
         group.addAll(keyColumns)
     }.concat()

kandy-api/src/test/kotlin/org/jetbrains/kotlinx/kandy/builders/dataframe/dataFramePlotBuilder.kt

@@ -55,8 +55,8 @@ class DataFramePlotBuilderTest {
 
     @Test
     fun `test get columns with selector`() {
-        val nameColumn: DataColumn<String> = DataColumn.create("name", listOf("Alice", "Bob", "Charlie"))
-        val ageColumn: DataColumn<Int> = DataColumn.create("age", listOf(15, 20, 100))
+        val nameColumn: DataColumn<String> = DataColumn.createByType("name", listOf("Alice", "Bob", "Charlie"))
+        val ageColumn: DataColumn<Int> = DataColumn.createByType("age", listOf(15, 20, 100))
 
         val dataFrame = dataFrameOf(nameColumn, ageColumn)
 

kandy-api/src/test/kotlin/org/jetbrains/kotlinx/kandy/builders/dataframe/groupByPlotBuilder.kt

@@ -24,9 +24,9 @@ import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
 class GroupByPlotBuilderTest {
-    private val a = DataColumn.create("a", listOf(1, 4))
-    private val b = DataColumn.create("b", listOf(2, 5))
-    private val c = DataColumn.create("c", listOf(3, 6))
+    private val a = DataColumn.createByType("a", listOf(1, 4))
+    private val b = DataColumn.createByType("b", listOf(2, 5))
+    private val c = DataColumn.createByType("c", listOf(3, 6))
     private val dataFrame = dataFrameOf(a, b, c)
 
     @Test

kandy-geo/build.gradle.kts

@@ -0,0 +1,57 @@
+import org.jetbrains.kotlin.gradle.tasks.BaseKotlinCompile
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    with(libs.plugins) {
+        alias(kotlin.jvm)
+        alias(kotlin.jupyter.api)
+        alias(korro)
+    }
+}
+
+repositories {
+    maven("https://repo.osgeo.org/repository/release")
+    mavenCentral()
+}
+
+// https://stackoverflow.com/questions/26993105/i-get-an-error-downloading-javax-media-jai-core1-1-3-from-maven-central
+// jai core dependency should be excluded from geotools dependencies and added separately
+fun ExternalModuleDependency.excludeJaiCore() = exclude("javax.media", "jai_core")
+
+dependencies {
+    api(project(":kandy-api"))
+    api(project(":kandy-lets-plot"))
+    implementation(libs.lets.plot)
+    implementation(libs.lets.plot.geotools)
+    implementation(libs.kotlinx.dataframe)
+    implementation(libs.kotlinx.dataframe.geo)
+
+    implementation(libs.geotools.main) { excludeJaiCore() }
+    implementation(libs.geotools.shapefile) { excludeJaiCore() }
+    implementation(libs.geotools.geojson) { excludeJaiCore() }
+    implementation(libs.geotools.referencing) { excludeJaiCore() }
+    implementation(libs.geotools.epsg.hsql) { excludeJaiCore() }
+
+    implementation(libs.jai.core)
+
+    testImplementation(kotlin("test"))
+}
+
+// add friend modules to access internal properties
+tasks.withType<KotlinCompile>().configureEach {
+    val friendModules = listOf(project(":kandy-api"), project(":kandy-lets-plot"))
+    val jarTasks = friendModules.map { it.tasks.getByName("jar") as Jar }
+    val jarPaths = jarTasks.map { it.archiveFile.get().asFile.absolutePath }
+    (this as BaseKotlinCompile).friendPaths.from(jarPaths)
+}
+
+tasks.test {
+    useJUnitPlatform()
+}
+kotlin {
+    jvmToolchain(11)
+}
+
+tasks.processJupyterApiResources {
+    libraryProducers = listOf("org.jetbrains.kotlinx.kandy.letsplot.geo.jupyter.IntegrationGeo")
+}

kandy-geo/src/main/kotlin/org/jetbrains/kotlinx/kandy/letsplot/geo/coordinatesMercator.kt

@@ -0,0 +1,39 @@
+@file:Suppress("INVISIBLE_REFERENCE", "INVISIBLE_MEMBER", "CANNOT_OVERRIDE_INVISIBLE_MEMBER")
+
+package org.jetbrains.kotlinx.kandy.letsplot.geo
+
+import org.jetbrains.kotlinx.kandy.ir.Plot
+import org.jetbrains.kotlinx.kandy.letsplot.feature.CoordinatesTransformation
+import org.jetbrains.kotlinx.kandy.letsplot.feature.CustomCoordinatesTransformation
+import org.jetbrains.kotlinx.kandy.letsplot.internal.X
+import org.jetbrains.kotlinx.kandy.letsplot.internal.Y
+import org.jetbrains.kotlinx.kandy.letsplot.translator.axes
+import org.jetbrains.kotlinx.kandy.letsplot.translator.limits
+import org.jetbrains.letsPlot.coord.coordMap
+import org.jetbrains.letsPlot.intern.FeatureList
+
+internal class MercatorCoordinatesTransformation : CustomCoordinatesTransformation {
+    override fun wrap(plot: Plot): FeatureList {
+        val axes = plot.axes()
+        val xLimits = axes[X]?.limits()
+        val yLimits = axes[Y]?.limits()
+
+        return FeatureList(listOf(coordMap(xlim = xLimits, ylim = yLimits, flip = false)))
+    }
+}
+
+internal class MercatorFlippedCoordinates : CustomCoordinatesTransformation {
+    override fun wrap(plot: Plot): FeatureList {
+        val axes = plot.axes()
+        val xLimits = axes[X]?.limits()
+        val yLimits = axes[Y]?.limits()
+
+        return FeatureList(listOf(coordMap(xlim = xLimits, ylim = yLimits, flip = true)))
+    }
+}
+
+public fun CoordinatesTransformation.Companion.mercator(): CoordinatesTransformation =
+    MercatorCoordinatesTransformation()
+
+public fun CoordinatesTransformation.Companion.mercatorFlipped(): CoordinatesTransformation =
+    MercatorFlippedCoordinates()

kandy-geo/src/main/kotlin/org/jetbrains/kotlinx/kandy/letsplot/geo/dsl/GeoData.kt

@@ -0,0 +1,31 @@
+package org.jetbrains.kotlinx.kandy.letsplot.geo.dsl
+
+import org.geotools.geojson.geom.GeometryJSON
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.remove
+import org.jetbrains.kotlinx.dataframe.api.toMap
+import org.jetbrains.kotlinx.dataframe.geo.GeoDataFrame
+import org.jetbrains.kotlinx.dataframe.geo.WithGeometry
+import org.jetbrains.kotlinx.dataframe.geo.geometry
+import org.jetbrains.kotlinx.kandy.letsplot.data.GeoSpatialData
+import org.jetbrains.letsPlot.spatial.SpatialDataset
+
+internal class GeoData(val geoDataFrame: GeoDataFrame<*>) : GeoSpatialData {
+    override val dataFrame: DataFrame<WithGeometry> = geoDataFrame.df
+
+    companion object {
+        // TODO(https://github.com/Kotlin/kandy/issues/454)
+        const val DEFAULT_PRECISION = 10
+    }
+
+    override fun toSpatialDataset(): SpatialDataset {
+        with(geoDataFrame) {
+            val geojson = GeometryJSON(DEFAULT_PRECISION)
+            return SpatialDataset.withGEOJSON(
+                df.remove { geometry }.toMap(),
+                df.geometry.toList().map { geojson.toString(it) },
+                crs = crs?.name?.code
+            )
+        }
+    }
+}

kandy-geo/src/main/kotlin/org/jetbrains/kotlinx/kandy/letsplot/geo/dsl/GeoDataBuilder.kt

@@ -0,0 +1,28 @@
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE", "CANNOT_OVERRIDE_INVISIBLE_MEMBER")
+
+package org.jetbrains.kotlinx.kandy.letsplot.geo.dsl
+
+import org.jetbrains.kotlinx.dataframe.DataFrame
+import org.jetbrains.kotlinx.dataframe.api.add
+import org.jetbrains.kotlinx.dataframe.geo.GeoDataFrame
+import org.jetbrains.kotlinx.dataframe.geo.WithGeometry
+import org.jetbrains.kotlinx.dataframe.geo.geometry
+import org.jetbrains.kotlinx.kandy.dsl.internal.dataframe.DatasetBuilderImpl
+import org.jetbrains.kotlinx.kandy.ir.data.TableData
+
+internal class GeoDataBuilder(
+    geoData: GeoData
+) : DatasetBuilderImpl(null) {
+    constructor(geodf: GeoDataFrame<*>) : this(GeoData(geodf))
+
+    val crs = geoData.geoDataFrame.crs
+    override val baseDataFrame: DataFrame<WithGeometry> = geoData.dataFrame
+
+    @Suppress("UNCHECKED_CAST")
+    override fun build(): TableData {
+        if (!buffer.containsColumn("geometry")) {
+            buffer = buffer.add(baseDataFrame.geometry)
+        }
+        return GeoData(GeoDataFrame(buffer as DataFrame<WithGeometry>, crs))
+    }
+}

kandy-geo/src/main/kotlin/org/jetbrains/kotlinx/kandy/letsplot/geo/dsl/GeoDataFramePlotBuilder.kt

@@ -0,0 +1,28 @@
+@file:Suppress("CANNOT_OVERRIDE_INVISIBLE_MEMBER")
+
+package org.jetbrains.kotlinx.kandy.letsplot.geo.dsl
+
+import org.jetbrains.kotlinx.dataframe.ColumnsContainer
+import org.jetbrains.kotlinx.dataframe.geo.GeoDataFrame
+import org.jetbrains.kotlinx.dataframe.geo.WithGeometry
+import org.jetbrains.kotlinx.kandy.dsl.internal.DatasetBuilder
+import org.jetbrains.kotlinx.kandy.dsl.internal.dataframe.MultiLayerPlotBuilderImpl
+
+/**
+ * Represents a geo plotting context initialized with a [GeoDataFrame] as its primary dataset.
+ * The class allows the seamless integration of the inner dataframe's columns into the plotting process.
+ *
+ * The implemented [ColumnsContainer] enables the user
+ * to leverage the columns of the dataframe directly in the plotting process.
+ *
+ * In this scope, you can create geo layers that will use the `geometry` column of this GeoDataFrame
+ * by default.
+ *
+ * @param T the type of the GeoDataFrame.
+ */
+public class GeoDataFramePlotBuilder<T : WithGeometry> @PublishedApi internal constructor(
+    @PublishedApi
+    internal val geodf: GeoDataFrame<T>,
+) : MultiLayerPlotBuilderImpl(), ColumnsContainer<T> by geodf.df, GeoDataScope {
+    override val datasetBuilders: MutableList<DatasetBuilder> = mutableListOf(GeoDataBuilder(geodf))
+}