diff --git a/build.gradle.kts b/build.gradle.kts index a1a0bc7a..9af6c02d 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,5 +8,6 @@ plugins { alias(libs.plugins.jetbrainsCompose) apply false alias(libs.plugins.kotlinMultiplatform) apply false alias(libs.plugins.composeCompiler) apply false + alias(libs.plugins.kotlinSerialization) apply false alias(libs.plugins.vanniktechPublish) apply false -} +} \ No newline at end of file diff --git a/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.android.kt b/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.android.kt new file mode 100644 index 00000000..9c0ae03d --- /dev/null +++ b/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.android.kt @@ -0,0 +1,14 @@ +package ovh.plrapps.mapcompose.demo.ui.screens + +import androidx.compose.runtime.Composable +import androidx.lifecycle.viewmodel.compose.viewModel +import ovh.plrapps.mapcompose.demo.viewmodels.SwissMapVectorDemoVM + +actual object SwissMapVectorDemo { + @Composable + actual fun Content() { + val viewModel: SwissMapVectorDemoVM = viewModel() + + SwissMapVectorCommonUi(viewModel) + } +} \ No newline at end of file diff --git a/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.android.kt b/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.android.kt new file mode 100644 index 00000000..70cdced5 --- /dev/null +++ b/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.android.kt @@ -0,0 +1,14 @@ +package ovh.plrapps.mapcompose.demo.ui.screens + +import androidx.compose.runtime.Composable +import androidx.lifecycle.viewmodel.compose.viewModel +import ovh.plrapps.mapcompose.demo.viewmodels.VectorDemoVM + +actual object VectorDemo { + @Composable + actual fun Content() { + val screenModel: VectorDemoVM = viewModel() + + VectorCommonUi(screenModel) + } +} \ No newline at end of file diff --git a/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt b/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt index aec69332..552856ca 100644 --- a/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt +++ b/demo/composeApp/src/androidMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt @@ -1,7 +1,12 @@ package ovh.plrapps.mapcompose.demo.viewmodels +import kotlinx.io.Buffer +import kotlinx.io.RawSource import kotlinx.io.asSource +import org.jetbrains.compose.resources.ExperimentalResourceApi import ovh.plrapps.mapcompose.core.TileStreamProvider +import ovh.plrapps.mapcompose.vector.core.VectorTileStreamProvider +import ovh.plrapps.mapcomposemp.demo.Res import java.net.HttpURLConnection import java.net.URL @@ -42,4 +47,44 @@ actual fun makeOsmTileStreamProvider() : TileStreamProvider { null } } +} + +actual class OSMVectorTileStreamProvider actual constructor(actual override val styleUrl: String) : + VectorTileStreamProvider { + + @OptIn(ExperimentalResourceApi::class) + actual override suspend fun loadResources(url: String): RawSource? { + return when (url) { + "files/style_street_v2.json" -> { + val buffer = Buffer() + buffer.write(Res.readBytes(url)) + buffer + } + else -> getResourceAsStream(url) + } + } + + actual override suspend fun getTileStream( + tileUrl: String, + row: Int, + col: Int, + zoomLvl: Int + ): RawSource? { + return getResourceAsStream(tileUrl) + } + + private fun getResourceAsStream(url: String): RawSource? { + return try { + val url = URL(url) + val connection = url.openConnection() as HttpURLConnection + // OSM requires a user-agent + connection.setRequestProperty("User-Agent", "Chrome/120.0.0.0 Safari/537.36") + connection.doInput = true + connection.connect() + connection.inputStream.asSource() + } catch (e: Exception) { + e.printStackTrace() + null + } + } } \ No newline at end of file diff --git a/demo/composeApp/src/commonMain/composeResources/files/style_street_v2.json b/demo/composeApp/src/commonMain/composeResources/files/style_street_v2.json new file mode 100644 index 00000000..51e3556f --- /dev/null +++ b/demo/composeApp/src/commonMain/composeResources/files/style_street_v2.json @@ -0,0 +1,8247 @@ +{ + "version": 8, + "id": "streets-v2", + "name": "Streets", + "sources": { + "maptiler_attribution": { + "attribution": "© MapTiler © OpenStreetMap contributors", + "type": "vector" + }, + "maptiler_planet": { + "url": "https://api.maptiler.com/tiles/v3/tiles.json?key=Tp9K7a8qzMTkBSzO4EZb", + "type": "vector" + } + }, + "layers": [ + { + "id": "Background", + "type": "background", + "layout": { + "visibility": "visible" + }, + "paint": { + "background-color": { + "stops": [ + [ + 6, + "hsl(47,79%,94%)" + ], + [ + 14, + "hsl(42,49%,93%)" + ] + ] + } + } + }, + { + "id": "Meadow", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "globallandcover", + "maxzoom": 8, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(75,51%,85%)", + "fill-opacity": { + "stops": [ + [ + 0, + 1 + ], + [ + 8, + 0.1 + ] + ] + } + }, + "filter": [ + "==", + "class", + "grass" + ] + }, + { + "id": "Scrub", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "globallandcover", + "maxzoom": 8, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(97,51%,80%)", + "fill-opacity": { + "stops": [ + [ + 0, + 1 + ], + [ + 8, + 0.1 + ] + ] + } + }, + "filter": [ + "==", + "class", + "scrub" + ] + }, + { + "id": "Crop", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "globallandcover", + "maxzoom": 8, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(50,67%,86%)", + "fill-opacity": { + "stops": [ + [ + 0, + 1 + ], + [ + 8, + 0.1 + ] + ] + } + }, + "filter": [ + "==", + "class", + "crop" + ] + }, + { + "id": "Glacier", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landcover", + "maxzoom": 24, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(0,0%,100%)", + "fill-opacity": { + "stops": [ + [ + 0, + 1 + ], + [ + 10, + 0.7 + ] + ] + } + }, + "filter": [ + "==", + "class", + "ice" + ] + }, + { + "id": "Forest", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "globallandcover", + "maxzoom": 8, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(119,38%,76%)", + "fill-opacity": { + "stops": [ + [ + 1, + 0.8 + ], + [ + 8, + 0 + ] + ] + } + }, + "filter": [ + "in", + "class", + "forest", + "tree" + ] + }, + { + "id": "Sand", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landcover", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": false, + "fill-color": "hsl(52,93%,89%)", + "fill-opacity": 0.85 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "sand" + ] + }, + { + "id": "Wood", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landcover", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(87,46%,85%)", + "fill-opacity": 1 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "wood" + ] + }, + { + "id": "Residential", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "maxzoom": 24, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": { + "base": 1, + "stops": [ + [ + 4, + "hsl(44,34%,87%)" + ], + [ + 16, + "hsl(54, 45%, 91%)" + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "class", + "residential", + "suburbs", + "neighbourhood" + ] + }, + { + "id": "Industrial", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "maxzoom": 24, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 9, + [ + "match", + [ + "get", + "class" + ], + [ + "industrial" + ], + "hsl(40,67%,90%)", + "quarry", + "hsla(32, 47%, 87%, 0.2)", + "hsl(60, 31%, 87%)" + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "industrial" + ], + "hsl(49,54%,90%)", + "quarry", + "hsla(32, 47%, 87%, 0.5)", + "hsl(60, 31%, 87%)" + ] + ], + "fill-opacity": [ + "step", + [ + "zoom" + ], + 1, + 9, + [ + "match", + [ + "get", + "class" + ], + "quarry", + 0, + 1 + ], + 10, + 1 + ] + }, + "metadata": {}, + "filter": [ + "in", + "class", + "industrial", + "quarry" + ] + }, + { + "id": "Grass", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landcover", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": false, + "fill-color": "hsl(103, 40%, 85%)", + "fill-opacity": 0.5 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "grass" + ] + }, + { + "id": "Airport zone", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "aeroway", + "minzoom": 11, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(0,0%,93%)", + "fill-opacity": 1 + }, + "metadata": {}, + "filter": [ + "==", + "$type", + "Polygon" + ] + }, + { + "id": "Pedestrian", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(43,100%,99%)", + "fill-opacity": 0.7 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Polygon" + ], + [ + "!has", + "brunnel" + ], + [ + "!in", + "class", + "bridge", + "pier" + ], + [ + "in", + "subclass", + "pedestrian", + "platform" + ] + ] + }, + { + "id": "Cemetery", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "minzoom": 9, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(0,0%,88%)", + "fill-opacity": { + "stops": [ + [ + 9, + 0.25 + ], + [ + 16, + 1 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "==", + "class", + "cemetery" + ] + }, + { + "id": "Hospital", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "minzoom": 9, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(12,63%,94%)", + "fill-opacity": { + "stops": [ + [ + 9, + 0.25 + ], + [ + 16, + 1 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "==", + "class", + "hospital" + ] + }, + { + "id": "Stadium", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "minzoom": 9, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(94, 100%, 88%)", + "fill-opacity": { + "stops": [ + [ + 9, + 0.25 + ], + [ + 16, + 1 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "class", + "pitch", + "stadium", + "playground" + ] + }, + { + "id": "School", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "minzoom": 9, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(194,52%,94%)", + "fill-opacity": { + "stops": [ + [ + 9, + 0.25 + ], + [ + 16, + 1 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "class", + "college", + "school", + "university" + ] + }, + { + "id": "River tunnel", + "type": "line", + "source": "maptiler_planet", + "source-layer": "waterway", + "minzoom": 14, + "layout": { + "line-cap": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(210,73%,78%)", + "line-dasharray": [ + 2, + 4 + ], + "line-opacity": 0.5, + "line-width": { + "base": 1.3, + "stops": [ + [ + 12, + 0.5 + ], + [ + 20, + 6 + ] + ] + } + }, + "filter": [ + "==", + "brunnel", + "tunnel" + ] + }, + { + "id": "River", + "type": "line", + "source": "maptiler_planet", + "source-layer": "waterway", + "layout": { + "line-cap": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(210,73%,78%)", + "line-width": { + "stops": [ + [ + 12, + 0.5 + ], + [ + 20, + 6 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "!=", + "brunnel", + "tunnel" + ] + }, + { + "id": "Water intermittent", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "water", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(205,91%,83%)", + "fill-opacity": 0.85 + }, + "metadata": {}, + "filter": [ + "==", + "intermittent", + 1 + ] + }, + { + "id": "Water", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "water", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(204,92%,75%)", + "fill-opacity": [ + "match", + [ + "get", + "intermittent" + ], + 1, + 0.85, + 1 + ] + }, + "metadata": {}, + "filter": [ + "!=", + "intermittent", + 1 + ] + }, + { + "id": "Aeroway", + "type": "line", + "source": "maptiler_planet", + "source-layer": "aeroway", + "minzoom": 11, + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,100%)", + "line-width": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 11, + [ + "match", + [ + "get", + "class" + ], + [ + "runway" + ], + 3, + 0.5 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "runway" + ], + 16, + 6 + ] + ] + }, + "metadata": {} + }, + { + "id": "Heliport", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "aeroway", + "minzoom": 11, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(0,0%,100%)", + "fill-opacity": 1 + }, + "metadata": {}, + "filter": [ + "in", + "class", + "helipad", + "heliport" + ] + }, + { + "id": "Ferry line", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 6, + "layout": { + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": { + "stops": [ + [ + 10, + "hsl(205,61%,63%)" + ], + [ + 16, + "hsl(205,67%,47%)" + ] + ] + }, + "line-dasharray": [ + 2, + 2 + ], + "line-opacity": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 6, + 0.5, + 7, + 0.8, + 8, + 1 + ], + "line-width": { + "stops": [ + [ + 10, + 0.5 + ], + [ + 14, + 1.1 + ] + ] + } + }, + "filter": [ + "==", + "class", + "ferry" + ] + }, + { + "id": "Tunnel outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": [ + "match", + [ + "get", + "class" + ], + "motorway", + "hsl(28,72%,69%)", + [ + "trunk", + "primary" + ], + "hsl(28,72%,69%)", + "hsl(36,5%,80%)" + ], + "line-dasharray": [ + 0.5, + 0.25 + ], + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 6, + 0, + 7, + 0.5, + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + [ + "trunk", + "primary" + ], + 2, + 0 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 2, + 6 + ], + [ + "trunk", + "primary" + ], + 3, + [ + "secondary", + "tertiary" + ], + 2, + [ + "minor", + "service", + "track" + ], + 1, + 0.5 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 8 + ], + [ + "trunk" + ], + 4, + [ + "primary" + ], + 6, + [ + "secondary" + ], + 6, + [ + "tertiary" + ], + 4, + [ + "minor", + "service", + "track" + ], + 3, + 3 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway", + "trunk", + "primary" + ], + 10, + [ + "secondary" + ], + 8, + [ + "tertiary" + ], + 8, + [ + "minor", + "service", + "track" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway", + "trunk", + "primary" + ], + 26, + [ + "secondary" + ], + 26, + [ + "tertiary" + ], + 26, + [ + "minor", + "service", + "track" + ], + 18, + 18 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "brunnel", + "tunnel" + ], + [ + "!in", + "class", + "bridge", + "ferry", + "rail", + "transit", + "pier", + "path", + "aerialway", + "motorway_construction", + "trunk_construction", + "primary_construction", + "secondary_construction", + "tertiary_construction", + "minor_construction", + "service_construction", + "track_construction" + ] + ] + }, + { + "id": "Tunnel", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": [ + "match", + [ + "get", + "class" + ], + "motorway", + "hsl(35,100%,76%)", + [ + "trunk", + "primary" + ], + "hsl(48,100%,88%)", + "hsl(0,0%,96%)" + ], + "line-opacity": 1, + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 5, + 0, + 6, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "brunnel" + ], + [ + "bridge" + ], + 0, + 1 + ], + [ + "trunk", + "primary" + ], + 0, + 0 + ], + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + [ + "trunk", + "primary" + ], + 1.5, + 1 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 1, + 4 + ], + [ + "trunk" + ], + 2.5, + [ + "primary" + ], + 2.5, + [ + "secondary", + "tertiary" + ], + 1.5, + [ + "minor", + "service", + "track" + ], + 1, + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 6 + ], + [ + "trunk" + ], + 3, + [ + "primary" + ], + 5, + [ + "secondary" + ], + 4, + [ + "tertiary" + ], + 3, + [ + "minor", + "service", + "track" + ], + 2, + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway", + "trunk", + "primary" + ], + 8, + [ + "secondary" + ], + 7, + [ + "tertiary" + ], + 6, + [ + "minor", + "service", + "track" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway", + "trunk", + "primary" + ], + 24, + [ + "secondary" + ], + 24, + [ + "tertiary" + ], + 24, + [ + "minor", + "service", + "track" + ], + 16, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "brunnel", + "tunnel" + ], + [ + "!in", + "class", + "ferry", + "rail", + "transit", + "pier", + "bridge", + "path", + "aerialway", + "motorway_construction", + "trunk_construction", + "primary_construction", + "secondary_construction", + "tertiary_construction", + "minor_construction", + "service_construction", + "track_construction" + ] + ] + }, + { + "id": "Railway tunnel", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,73%)", + "line-opacity": 0.5, + "line-width": { + "base": 1.4, + "stops": [ + [ + 14, + 0.4 + ], + [ + 15, + 0.75 + ], + [ + 20, + 2 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "rail" + ] + ] + }, + { + "id": "Railway tunnel hatching", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,73%)", + "line-dasharray": [ + 0.2, + 8 + ], + "line-opacity": 0.5, + "line-width": { + "base": 1.4, + "stops": [ + [ + 14.5, + 0 + ], + [ + 15, + 3 + ], + [ + 20, + 8 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "rail" + ] + ] + }, + { + "id": "Footway tunnel outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "round", + "line-join": "miter", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,100%)", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0 + ], + [ + 16, + 0 + ], + [ + 18, + 4 + ], + [ + 22, + 8 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path", + "pedestrian" + ], + [ + "==", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Footway tunnel", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,63%)", + "line-dasharray": { + "stops": [ + [ + 14, + [ + 1, + 0.5 + ] + ], + [ + 18, + [ + 1, + 0.25 + ] + ] + ] + }, + "line-opacity": 0.4, + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0.5 + ], + [ + 16, + 1 + ], + [ + 18, + 2 + ], + [ + 22, + 5 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path", + "pedestrian" + ], + [ + "==", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Pier", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(42,49%,93%)" + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Polygon" + ], + [ + "==", + "class", + "pier" + ] + ] + }, + { + "id": "Pier road", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(42,49%,93%)", + "line-width": { + "base": 1.2, + "stops": [ + [ + 15, + 1 + ], + [ + 17, + 4 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "class", + "pier" + ] + ] + }, + { + "id": "Bridge outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 13, + "maxzoom": 17, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(43, 50%, 93%)", + "line-opacity": 0.5, + "line-width": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 13, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 5, + 8 + ], + 15, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 15, + 22 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 20, + 24 + ] + ] + }, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "in", + "class", + "motorway", + "primary", + "trunk" + ] + ] + }, + { + "id": "Bridge", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(42,49%,93%)", + "fill-opacity": 0.6 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Polygon" + ], + [ + "==", + "brunnel", + "bridge" + ] + ] + }, + { + "id": "Minor road outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(36,5%,80%)", + "line-opacity": 1, + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 6, + 0, + 7, + 0.5, + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary", + "tertiary" + ], + 2, + [ + "minor", + "service", + "track" + ], + 1, + 0.5 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 6, + [ + "tertiary" + ], + 4, + [ + "minor", + "service", + "track" + ], + 3, + 3 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 8, + [ + "tertiary" + ], + 8, + [ + "minor", + "service", + "track" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 26, + [ + "tertiary" + ], + 26, + [ + "minor", + "service", + "track" + ], + 18, + 18 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "!in", + "class", + "aerialway", + "bridge", + "ferry", + "minor_construction", + "motorway", + "motorway_construction", + "path", + "path_construction", + "pier", + "primary", + "primary_construction", + "rail", + "secondary_construction", + "service_construction", + "tertiary_construction", + "track_construction", + "transit", + "trunk_construction" + ] + ] + }, + { + "id": "Major road outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(28,72%,69%)", + "line-opacity": 1, + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 6, + 0, + 7, + 0.5, + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 2.4, + 0 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 3, + 0.5 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk" + ], + 4, + [ + "primary" + ], + 6, + 3 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 10, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 26, + 18 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "in", + "class", + "primary", + "trunk" + ] + ] + }, + { + "id": "Highway outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(28,72%,69%)", + "line-opacity": 1, + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 6, + 0, + 7, + 0.5, + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + 0 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 2, + 6 + ], + 0.5 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 8 + ], + 3 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + 10, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + 26, + 18 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "motorway" + ] + ] + }, + { + "id": "Road under construction", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "square", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": [ + "match", + [ + "get", + "class" + ], + "motorway_construction", + "hsl(35,100%,76%)", + [ + "trunk_construction", + "primary_construction" + ], + "hsl(48,100%,83%)", + "hsl(0,0%,100%)" + ], + "line-dasharray": [ + 2, + 2 + ], + "line-opacity": [ + "case", + [ + "==", + [ + "get", + "brunnel" + ], + "tunnel" + ], + 0.7, + 1 + ], + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 5, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction" + ], + [ + "match", + [ + "get", + "brunnel" + ], + [ + "bridge" + ], + 0, + 0.5 + ], + [ + "trunk_construction", + "primary_construction" + ], + 0, + 0 + ], + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + [ + "trunk_construction", + "primary_construction" + ], + 1.5, + 1 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 1, + 4 + ], + [ + "trunk_construction" + ], + 2.5, + [ + "primary_construction" + ], + 2.5, + [ + "secondary_construction", + "tertiary_construction" + ], + 1.5, + [ + "minor_construction", + "service_construction", + "track_construction" + ], + 1, + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 6 + ], + [ + "trunk_construction" + ], + 3, + [ + "primary_construction" + ], + 5, + [ + "secondary_construction" + ], + 4, + [ + "tertiary_construction" + ], + 3, + [ + "minor_construction", + "service_construction", + "track_construction" + ], + 2, + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction", + "trunk_construction", + "primary_construction" + ], + 8, + [ + "secondary_construction" + ], + 7, + [ + "tertiary_construction" + ], + 6, + [ + "minor_construction", + "service_construction", + "track_construction" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction", + "trunk_construction", + "primary_construction" + ], + 24, + [ + "secondary_construction" + ], + 24, + [ + "tertiary_construction" + ], + 24, + [ + "minor_construction", + "service_construction", + "track_construction" + ], + 16, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "in", + "class", + "motorway_construction", + "trunk_construction", + "primary_construction", + "secondary_construction", + "tertiary_construction", + "minor_construction", + "service_construction", + "track_construction" + ] + }, + { + "id": "Minor road", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,100%)", + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 5, + 0.5, + 10, + 1, + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary", + "tertiary" + ], + 1.5, + [ + "minor", + "service", + "track" + ], + 1, + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 4, + [ + "tertiary" + ], + 3, + [ + "minor", + "service", + "track" + ], + 2, + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 7, + [ + "tertiary" + ], + 6, + [ + "minor", + "service", + "track" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 24, + [ + "tertiary" + ], + 24, + [ + "minor", + "service", + "track" + ], + 16, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "!in", + "class", + "aerialway", + "bridge", + "ferry", + "minor_construction", + "motorway", + "motorway_construction", + "path", + "path_construction", + "pier", + "primary", + "primary_construction", + "rail", + "secondary_construction", + "service_construction", + "tertiary_construction", + "track_construction", + "transit", + "trunk_construction" + ] + ] + }, + { + "id": "Major road", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(48,100%,83%)", + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 1.5, + 1 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 2.5, + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk" + ], + 3, + [ + "primary" + ], + 5, + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 8, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 24, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "in", + "class", + "primary", + "trunk" + ] + ] + }, + { + "id": "Highway", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(35,100%,76%)", + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 5, + 0.5, + 6, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "brunnel" + ], + [ + "bridge" + ], + 0, + 1 + ], + 0 + ], + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + 1 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 1, + 4 + ], + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 6 + ], + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + 8, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + 24, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "motorway" + ] + ] + }, + { + "id": "Path outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "round", + "line-join": "miter", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,100%)", + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0 + ], + [ + 16, + 0 + ], + [ + 18, + 4 + ], + [ + 22, + 8 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path", + "pedestrian" + ], + [ + "!=", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Path minor", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 79%)", + "line-dasharray": { + "stops": [ + [ + 14, + [ + 1, + 0.5 + ] + ], + [ + 18, + [ + 1, + 0.25 + ] + ] + ] + }, + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0.5 + ], + [ + 16, + 1 + ], + [ + 18, + 2 + ], + [ + 22, + 5 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path_pedestrian" + ], + [ + "!=", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Path", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 79%)", + "line-dasharray": { + "stops": [ + [ + 14, + [ + 1, + 0.5 + ] + ], + [ + 18, + [ + 1, + 0.25 + ] + ] + ] + }, + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0.5 + ], + [ + 16, + 1 + ], + [ + 18, + 2 + ], + [ + 22, + 5 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path", + "pedestrian" + ], + [ + "!=", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Major rail", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": { + "stops": [ + [ + 8, + "hsl(0,0%,72%)" + ], + [ + 16, + "hsl(0,0%,70%)" + ] + ] + }, + "line-opacity": [ + "match", + [ + "get", + "service" + ], + "yard", + 0.5, + 1 + ], + "line-width": { + "base": 1.4, + "stops": [ + [ + 14, + 0.4 + ], + [ + 15, + 0.75 + ], + [ + 20, + 2 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "!in", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "rail" + ] + ] + }, + { + "id": "Major rail hatching", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,72%)", + "line-dasharray": [ + 0.2, + 9 + ], + "line-opacity": [ + "match", + [ + "get", + "service" + ], + "yard", + 0.5, + 1 + ], + "line-width": { + "base": 1.4, + "stops": [ + [ + 14.5, + 0 + ], + [ + 15, + 3 + ], + [ + 20, + 8 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "!in", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "rail" + ] + ] + }, + { + "id": "Minor rail", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,73%)", + "line-width": { + "base": 1.4, + "stops": [ + [ + 14, + 0.4 + ], + [ + 15, + 0.75 + ], + [ + 20, + 2 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "subclass", + "light_rail", + "tram" + ] + }, + { + "id": "Minor rail hatching", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,73%)", + "line-dasharray": [ + 0.2, + 4 + ], + "line-width": { + "base": 1.4, + "stops": [ + [ + 14.5, + 0 + ], + [ + 15, + 2 + ], + [ + 20, + 6 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "subclass", + "tram", + "light_rail" + ] + }, + { + "id": "Building", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "building", + "minzoom": 13, + "maxzoom": 15, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(30,6%,73%)", + "fill-opacity": 0.3, + "fill-outline-color": { + "base": 1, + "stops": [ + [ + 13, + "hsla(35, 6%, 79%, 0.3)" + ], + [ + 14, + "hsl(35, 6%, 79%)" + ] + ] + } + }, + "metadata": {} + }, + { + "id": "Building 3D", + "type": "fill-extrusion", + "source": "maptiler_planet", + "source-layer": "building", + "minzoom": 15, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-extrusion-base": { + "property": "render_min_height", + "type": "identity" + }, + "fill-extrusion-color": "hsl(44,14%,79%)", + "fill-extrusion-height": { + "property": "render_height", + "type": "identity" + }, + "fill-extrusion-opacity": 0.4 + }, + "metadata": {}, + "filter": [ + "!has", + "hide_3d" + ] + }, + { + "id": "Aqueduct outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "waterway", + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,51%)", + "line-width": { + "base": 1.3, + "stops": [ + [ + 14, + 1 + ], + [ + 20, + 6 + ] + ] + } + }, + "filter": [ + "==", + "brunnel", + "bridge" + ] + }, + { + "id": "Aqueduct", + "type": "line", + "source": "maptiler_planet", + "source-layer": "waterway", + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(204,92%,75%)", + "line-width": { + "base": 1.3, + "stops": [ + [ + 12, + 0.5 + ], + [ + 20, + 5 + ] + ] + } + }, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "brunnel", + "bridge" + ] + ] + }, + { + "id": "Cablecar", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 13, + "layout": { + "line-cap": "round", + "visibility": "visible" + }, + "paint": { + "line-blur": 1, + "line-color": "hsl(0,0%,100%)", + "line-width": { + "base": 1, + "stops": [ + [ + 13, + 2 + ], + [ + 19, + 4 + ] + ] + } + }, + "filter": [ + "==", + "class", + "aerialway" + ] + }, + { + "id": "Cablecar dash", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 13, + "layout": { + "line-cap": "round", + "line-join": "bevel", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,64%)", + "line-dasharray": [ + 2, + 2 + ], + "line-width": { + "base": 1, + "stops": [ + [ + 13, + 1 + ], + [ + 19, + 2 + ] + ] + } + }, + "filter": [ + "==", + "class", + "aerialway" + ] + }, + { + "id": "Other border", + "type": "line", + "source": "maptiler_planet", + "source-layer": "boundary", + "minzoom": 3, + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 70%)", + "line-dasharray": [ + 2, + 1 + ], + "line-width": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 3, + 0.75, + 4, + 0.8, + 11, + [ + "case", + [ + "<=", + [ + "get", + "admin_level" + ], + 6 + ], + 1.75, + 1.5 + ], + 18, + [ + "case", + [ + "<=", + [ + "get", + "admin_level" + ], + 6 + ], + 3, + 2 + ] + ] + }, + "filter": [ + "all", + [ + "in", + "admin_level", + 3, + 4, + 5, + 6, + 7, + 8 + ], + [ + "==", + "maritime", + 0 + ] + ] + }, + { + "id": "Disputed border", + "type": "line", + "source": "maptiler_planet", + "source-layer": "boundary", + "minzoom": 0, + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 63%)", + "line-dasharray": [ + 2, + 2 + ], + "line-width": { + "stops": [ + [ + 1, + 0.5 + ], + [ + 5, + 1.5 + ], + [ + 10, + 2 + ], + [ + 24, + 12 + ] + ] + } + }, + "filter": [ + "all", + [ + "==", + "admin_level", + 2 + ], + [ + "==", + "disputed", + 1 + ], + [ + "==", + "maritime", + 0 + ] + ] + }, + { + "id": "Country border", + "type": "line", + "source": "maptiler_planet", + "source-layer": "boundary", + "minzoom": 0, + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 54%)", + "line-width": { + "stops": [ + [ + 1, + 0.5 + ], + [ + 5, + 1.5 + ], + [ + 10, + 2 + ], + [ + 24, + 12 + ] + ] + } + }, + "filter": [ + "all", + [ + "==", + "admin_level", + 2 + ], + [ + "==", + "disputed", + 0 + ], + [ + "==", + "maritime", + 0 + ] + ] + }, + { + "id": "River labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "waterway", + "minzoom": 13, + "layout": { + "symbol-placement": "line", + "symbol-spacing": 400, + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-letter-spacing": 0.2, + "text-max-width": 5, + "text-rotation-alignment": "map", + "text-size": { + "stops": [ + [ + 12, + 8 + ], + [ + 16, + 14 + ], + [ + 22, + 20 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(205,84%,39%)", + "text-halo-blur": 1, + "text-halo-color": "hsl(202, 76%, 82%)", + "text-halo-width": { + "stops": [ + [ + 10, + 1 + ], + [ + 18, + 2 + ] + ] + } + }, + "filter": [ + "==", + "$type", + "LineString" + ] + }, + { + "id": "Ocean labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "water_name", + "minzoom": 0, + "layout": { + "symbol-placement": "point", + "text-field": "{name:en}", + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-max-width": 5, + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 1, + [ + "match", + [ + "get", + "class" + ], + [ + "ocean" + ], + 14, + 10 + ], + 3, + [ + "match", + [ + "get", + "class" + ], + [ + "ocean" + ], + 18, + 14 + ], + 9, + [ + "match", + [ + "get", + "class" + ], + [ + "ocean" + ], + 22, + 18 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "lake" + ], + 14, + [ + "sea" + ], + 20, + 26 + ] + ], + "visibility": "visible" + }, + "paint": { + "text-color": { + "stops": [ + [ + 1, + "hsl(203,54%,54%)" + ], + [ + 4, + "hsl(203,72%,39%)" + ] + ] + }, + "text-halo-blur": 1, + "text-halo-color": { + "stops": [ + [ + 1, + "hsla(196, 72%, 80%, 0.05)" + ], + [ + 3, + "hsla(200, 100%, 88%, 0.75)" + ] + ] + }, + "text-halo-width": 1, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 1, + [ + "match", + [ + "get", + "class" + ], + [ + "ocean" + ], + 1, + 0 + ], + 3, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "has", + "name" + ], + [ + "!=", + "class", + "lake" + ] + ] + }, + { + "id": "Lake labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "water_name", + "minzoom": 0, + "layout": { + "symbol-placement": "line", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-letter-spacing": 0.1, + "text-max-width": 5, + "text-size": { + "stops": [ + [ + 10, + 13 + ], + [ + 14, + 16 + ], + [ + 22, + 20 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(205,84%,39%)", + "text-halo-color": "hsla(0, 100%, 100%, 0.45)", + "text-halo-width": 1.5 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "class", + "lake" + ] + ] + }, + { + "id": "Housenumber", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "housenumber", + "minzoom": 18, + "layout": { + "text-field": "{housenumber}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-size": 10, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(26,10%,44%)", + "text-halo-blur": 1, + "text-halo-color": "hsl(21,64%,96%)", + "text-halo-width": 1 + } + }, + { + "id": "Gondola", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 13, + "layout": { + "symbol-placement": "line", + "text-anchor": "center", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-offset": [ + 0.8, + 0.8 + ], + "text-size": { + "base": 1, + "stops": [ + [ + 13, + 11 + ], + [ + 15, + 12 + ], + [ + 18, + 13 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,40%)", + "text-halo-blur": 1, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "metadata": {}, + "filter": [ + "in", + "subclass", + "gondola", + "cable_car" + ] + }, + { + "id": "Ferry", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 12, + "layout": { + "symbol-placement": "line", + "text-anchor": "center", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-offset": [ + 0.8, + 0.8 + ], + "text-size": { + "base": 1, + "stops": [ + [ + 13, + 11 + ], + [ + 15, + 12 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(205,84%,39%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsla(0, 0%, 100%, 0.15)", + "text-halo-width": 1 + }, + "filter": [ + "==", + "class", + "ferry" + ] + }, + { + "id": "Oneway", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 16, + "layout": { + "icon-image": "oneway", + "icon-padding": 2, + "icon-rotate": [ + "match", + [ + "get", + "oneway" + ], + 1, + 0, + 0 + ], + "icon-rotation-alignment": "map", + "icon-size": { + "stops": [ + [ + 16, + 0.7 + ], + [ + 19, + 1 + ] + ] + }, + "symbol-placement": "line", + "symbol-spacing": 75, + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 65%)", + "icon-opacity": 0.5 + }, + "filter": [ + "all", + [ + "has", + "oneway" + ], + [ + "in", + "class", + "motorway", + "trunk", + "primary", + "secondary", + "tertiary", + "minor", + "service" + ] + ] + }, + { + "id": "Road labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 8, + "layout": { + "icon-allow-overlap": false, + "icon-ignore-placement": false, + "icon-keep-upright": false, + "symbol-placement": "line", + "symbol-spacing": [ + "step", + [ + "zoom" + ], + 250, + 21, + 1000 + ], + "text-allow-overlap": false, + "text-anchor": "center", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-ignore-placement": false, + "text-justify": "center", + "text-max-width": 10, + "text-offset": [ + 0, + 0.15 + ], + "text-optional": false, + "text-size": { + "stops": [ + [ + 13, + 10 + ], + [ + 14, + 11 + ], + [ + 18, + 13 + ], + [ + 22, + 15 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 16%)", + "text-color": "hsl(0, 0%, 16%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "metadata": {}, + "filter": [ + "all", + [ + "!in", + "subclass", + "gondola", + "cable_car" + ], + [ + "!in", + "class", + "ferry", + "service" + ] + ] + }, + { + "id": "Highway junction", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 16, + "layout": { + "icon-image": "exit_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-avoid-edges": true, + "symbol-placement": "point", + "symbol-spacing": 200, + "symbol-z-order": "auto", + "text-field": "{ref}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-offset": [ + 0, + 0.1 + ], + "text-rotation-alignment": "viewport", + "text-size": 9, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,21%)", + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "filter": [ + "all", + [ + ">", + "ref_length", + 0 + ], + [ + "==", + "$type", + "Point" + ], + [ + "==", + "subclass", + "junction" + ] + ] + }, + { + "id": "Highway shield", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 8, + "layout": { + "icon-image": "road_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-avoid-edges": true, + "symbol-placement": "line", + "symbol-spacing": { + "stops": [ + [ + 10, + 200 + ], + [ + 18, + 400 + ] + ] + }, + "text-field": "{ref}", + "text-font": [ + "match", + [ + "get", + "class" + ], + "motorway", + [ + "literal", + [ + "Roboto Bold", + "Noto Sans Bold" + ] + ], + [ + "literal", + [ + "Roboto Regular" + ] + ] + ], + "text-offset": [ + 0, + 0.05 + ], + "text-padding": 2, + "text-rotation-alignment": "viewport", + "text-size": 10, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 100%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "text-color": "hsl(0, 0%, 29%)", + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 1 + }, + "filter": [ + "all", + [ + "<=", + "ref_length", + 6 + ], + [ + "==", + "$type", + "LineString" + ], + [ + "!in", + "network", + "us-interstate", + "us-highway", + "us-state" + ], + [ + "!in", + "class", + "path" + ] + ] + }, + { + "id": "Highway shield (US)", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 7, + "layout": { + "icon-image": "{network}_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1.1, + "symbol-avoid-edges": true, + "symbol-placement": { + "base": 1, + "stops": [ + [ + 7, + "point" + ], + [ + 7, + "line" + ], + [ + 8, + "line" + ] + ] + }, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": [ + "match", + [ + "get", + "class" + ], + "motorway", + [ + "literal", + [ + "Roboto Bold", + "Noto Sans Bold" + ] + ], + [ + "literal", + [ + "Roboto Regular", + "Noto Sans Regular" + ] + ] + ], + "text-offset": [ + 0, + 0.05 + ], + "text-rotation-alignment": "viewport", + "text-size": 9, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 100%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "text-color": "hsl(0, 0%, 29%)", + "text-halo-color": "rgba(255, 255, 255, 1)", + "text-halo-width": 0 + }, + "filter": [ + "all", + [ + "<=", + "ref_length", + 6 + ], + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "network", + "us-highway", + "us-state" + ], + [ + "!in", + "class", + "path" + ] + ] + }, + { + "id": "Highway shield interstate top (US)", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 7, + "layout": { + "icon-image": "{network}_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-placement": { + "base": 1, + "stops": [ + [ + 7, + "point" + ], + [ + 7, + "line" + ], + [ + 8, + "line" + ] + ] + }, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": [ + "match", + [ + "get", + "class" + ], + "motorway", + [ + "literal", + [ + "Roboto Bold", + "Noto Sans Bold" + ] + ], + [ + "literal", + [ + "Roboto Regular", + "Noto Sans Regular" + ] + ] + ], + "text-offset": [ + 0, + 0.1 + ], + "text-rotation-alignment": "viewport", + "text-size": 9, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(21, 100%, 45%)", + "icon-halo-color": "rgba(255, 255, 255, 1)", + "icon-halo-width": 1, + "icon-translate": [ + 0, + -4 + ], + "icon-translate-anchor": "viewport", + "text-color": "hsl(21, 100%, 45%)", + "text-halo-color": "rgba(255, 255, 255, 1)", + "text-halo-width": 0 + }, + "filter": [ + "all", + [ + "<=", + "ref_length", + 6 + ], + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "network", + "us-interstate" + ], + [ + "!in", + "class", + "path" + ] + ] + }, + { + "id": "Highway shield interstate (US)", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 7, + "layout": { + "icon-image": "{network}_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-placement": { + "base": 1, + "stops": [ + [ + 7, + "point" + ], + [ + 7, + "line" + ], + [ + 8, + "line" + ] + ] + }, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": [ + "match", + [ + "get", + "class" + ], + "motorway", + [ + "literal", + [ + "Roboto Bold", + "Noto Sans Bold" + ] + ], + [ + "literal", + [ + "Roboto Regular", + "Noto Sans Regular" + ] + ] + ], + "text-offset": [ + 0, + 0.1 + ], + "text-rotation-alignment": "viewport", + "text-size": 9, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(212, 79%, 42%)", + "icon-halo-color": "rgba(255, 255, 255, 1)", + "icon-halo-width": 1, + "text-color": "hsl(0, 0%, 100%)", + "text-halo-color": "rgba(255, 255, 255, 1)", + "text-halo-width": 0, + "text-translate": [ + 0, + -0.5 + ] + }, + "filter": [ + "all", + [ + "<=", + "ref_length", + 6 + ], + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "network", + "us-interstate" + ], + [ + "!in", + "class", + "path" + ] + ] + }, + { + "id": "Public", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 16, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "bbq", + "cemetery", + "courthouse", + "drinking_water", + "fire_station", + "fountain", + "hairdresser", + "office", + "post", + "prison", + "recycling", + "shower", + "telephone", + "toilets", + "townhall", + "town_hall" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(51, 10%, 40%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "cemetery", + "courthouse", + "townhall", + "town_hall" + ], + 1, + 0 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "cemetery", + "courthouse", + "fire_station", + "townhall", + "town_hall", + "post" + ], + 1, + 0 + ], + 18, + 1 + ], + "text-color": "hsl(51, 10%, 40%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "cemetery", + "courthouse", + "townhall", + "town_hall" + ], + 1, + 0 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "cemetery", + "courthouse", + "fire_station", + "townhall", + "town_hall", + "post" + ], + 1, + 0 + ], + 18, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "atm", + "bank", + "bbq", + "cemetery", + "courthouse", + "drinking_water", + "fire_station", + "fountain", + "hairdresser", + "office", + "post", + "prison", + "recycling", + "shower", + "telephone", + "toilets", + "townhall", + "town_hall" + ] + ] + }, + { + "id": "Sport", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 16, + "layout": { + "icon-image": [ + "coalesce", + [ + "image", + [ + "to-string", + [ + "get", + "subclass" + ] + ] + ], + [ + "image", + [ + "get", + "class" + ] + ], + [ + "image", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(129, 65%, 30%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "playground", + "pitch", + "stadium", + "sports_hall", + "swimming_pool" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(129, 65%, 30%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "playground", + "pitch", + "stadium", + "sports_hall", + "swimming_pool" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "american_football", + "athletics", + "archery", + "baseball", + "basketball", + "climbing", + "equestrian", + "fitness", + "fitness_centre", + "golf", + "motor", + "multi", + "playground", + "pitch", + "running", + "sauna", + "soccer", + "sport", + "stadium", + "sports_centre", + "sports_hall", + "swimming", + "swimming_area", + "swimming_pool", + "tennis", + "volleyball", + "water_park" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Education", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 15, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "college", + "childcare", + "dancing_school", + "driving_school", + "kindergarten", + "school", + "university" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(175, 50%, 40%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 15, + [ + "match", + [ + "get", + "subclass" + ], + [ + "university" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "school", + "university" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(175, 50%, 40%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 15, + [ + "match", + [ + "get", + "subclass" + ], + [ + "university" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "school", + "university" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "college", + "childcare", + "dancing_school", + "driving_school", + "kindergarten", + "school", + "university" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Tourism", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "apartment", + "aquarium", + "attraction", + "campsite", + "camp_site", + "caravan_site", + "castle", + "chalet", + "guest_house", + "hotel", + "hostel", + "information", + "lodging", + "motel", + "reservoir", + "ruins", + "theme_park", + "zoo" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(283, 55%, 35%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "attraction" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "attraction", + "castle", + "hotel", + "zoo" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(283, 55%, 35%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "attraction" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "attraction", + "castle", + "hotel", + "zoo" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "apartment", + "aquarium", + "attraction", + "campsite", + "camp_site", + "caravan_site", + "castle", + "chalet", + "guest_house", + "hotel", + "hostel", + "information", + "lodging", + "motel", + "reservoir", + "ruins", + "theme_park", + "zoo" + ], + [ + "!=", + "subclass", + "board" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Culture", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "coalesce", + [ + "image", + [ + "to-string", + [ + "get", + "subclass" + ] + ] + ], + [ + "image", + [ + "get", + "class" + ] + ], + [ + "image", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(315, 35%, 50%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "museum" + ], + 1, + 0 + ], + 15, + [ + "match", + [ + "get", + "class" + ], + [ + "cinema", + "art_gallery", + "museum", + "theatre" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "cinema", + "art_gallery", + "library", + "museum", + "place_of_worship", + "theatre" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(315, 35%, 50%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "museum" + ], + 1, + 0 + ], + 15, + [ + "match", + [ + "get", + "class" + ], + [ + "cinema", + "art_gallery", + "museum", + "theatre" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "cinema", + "art_gallery", + "library", + "museum", + "place_of_worship", + "theatre" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "art_gallery", + "archeological_site", + "cinema", + "community_centre", + "gallery", + "library", + "monastery", + "monument", + "museum", + "opera", + "place_of_worship", + "planetarium", + "theatre" + ], + [ + "!=", + "subclass", + "artwork" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Shopping", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "coalesce", + [ + "image", + [ + "to-string", + [ + "get", + "subclass" + ] + ] + ], + [ + "image", + [ + "get", + "class" + ] + ], + [ + "image", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(18, 17%, 30%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "mall" + ], + 1, + 0 + ], + 15, + [ + "match", + [ + "get", + "subclass" + ], + [ + "mall", + "supermarket" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "bakery", + "chemist", + "mall", + "supermarket" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(18, 17%, 30%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "mall" + ], + 1, + 0 + ], + 15, + [ + "match", + [ + "get", + "subclass" + ], + [ + "mall", + "supermarket" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "bakery", + "chemist", + "mall", + "supermarket" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "all", + [ + "in", + "class", + "alcohol_shop", + "bakery", + "book", + "books", + "butcher", + "chemist", + "clothing_store", + "convenience", + "gift", + "grocery", + "laundry", + "mall", + "music", + "shop", + "supermarket" + ], + [ + "has", + "name" + ] + ] + ] + }, + { + "id": "Food", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "maxzoom": 22, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "bar", + "beer", + "cafe", + "fast_food", + "ice_cream", + "restaurant" + ], + [ + "get", + "class" + ], + [ + "biergarten", + "pub" + ], + "beer", + "", + [ + "get", + "class" + ], + [ + "food_court" + ], + "restaurant", + "dot" + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(18, 24%, 44%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 20 + ], + 1, + 0 + ], + 15, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 99 + ], + 1, + 0 + ], + 16, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 499 + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(18, 24%, 44%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 20 + ], + 1, + 0 + ], + 15, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 99 + ], + 1, + 0 + ], + 16, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 499 + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "bar", + "beer", + "biergarten", + "cafe", + "fast_food", + "food_court", + "ice_cream", + "pub", + "restaurant" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Transport", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "aerialway", + "bicycle", + "bicycle_parking", + "car", + "car_rental", + "car_repair", + "charging_station", + "cycle_barrier", + "ferry_terminal", + "fuel", + "harbor", + "motorcycle_parking", + "parking", + "parking_garage", + "parking_paid" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "dot", + "" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(215, 81%, 35%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "ferry_terminal", + "fuel", + "terminal" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "terminal", + "toll" + ], + 1, + 0 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "parking", + "parking_garage", + "parking_paid", + "terminal", + "toll" + ], + 1, + 0 + ], + 18, + 1 + ], + "text-color": "hsl(215, 81%, 35%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "ferry_terminal", + "fuel", + "terminal" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "terminal", + "toll" + ], + 1, + 0 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "parking", + "parking_garage", + "parking_paid", + "terminal", + "toll" + ], + 1, + 0 + ], + 18, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "bicycle", + "bicycle_parking", + "bicycle_rental", + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "motorcycle_parking", + "parking", + "parking_garage", + "parking_paid", + "scooter", + "terminal", + "toll" + ] + ] + }, + { + "id": "Park", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-anchor": "center", + "icon-image": "park", + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(82, 83%, 25%)", + "icon-halo-blur": 0, + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 10 + ], + 1, + 0 + ], + 15, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 99 + ], + 1, + 0 + ], + 16, + 1 + ], + "text-color": "hsl(82, 83%, 25%)", + "text-halo-blur": 0, + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 10 + ], + 1, + 0 + ], + 15, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 99 + ], + 1, + 0 + ], + 16, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "class", + "park" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Healthcare", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "clinic", + "dentist", + "doctors", + "doctor", + "first_aid", + "hospital", + "pharmacy", + "veterinary" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(6, 96%, 35%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "hospital" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "clinic", + "hospital" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(6, 96%, 35%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "hospital" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "clinic", + "hospital" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "clinic", + "dentist", + "doctors", + "first_aid", + "hospital", + "pharmacy", + "veterinary" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Place labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 4, + "layout": { + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "center", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-letter-spacing": [ + "match", + [ + "get", + "class" + ], + [ + "suburb", + "neighborhood", + "neighbourhood", + "quarter", + "island" + ], + 0.2, + 0 + ], + "text-max-width": [ + "match", + [ + "get", + "class" + ], + [ + "island" + ], + 6, + 8 + ], + "text-offset": [ + 0, + 0 + ], + "text-padding": 2, + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 3, + 11, + 8, + 13, + 11, + [ + "match", + [ + "get", + "class" + ], + "village", + 12, + [ + "suburb", + "neighbourhood", + "quarter", + "hamlet", + "isolated_dwelling" + ], + 9, + "island", + 8, + 12 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + "village", + 18, + [ + "suburb", + "neighbourhood", + "quarter", + "hamlet", + "isolated_dwelling" + ], + 15, + "island", + 11, + 16 + ] + ], + "text-transform": [ + "match", + [ + "get", + "class" + ], + [ + "suburb", + "neighborhood", + "neighbourhood", + "quarter", + "island" + ], + "uppercase", + "none" + ], + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,25%)", + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1.2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 1, + 8, + [ + "match", + [ + "get", + "class" + ], + [ + "island" + ], + 0, + 1 + ], + 9, + [ + "match", + [ + "get", + "class" + ], + [ + "island" + ], + 1, + 1 + ] + ] + }, + "metadata": {}, + "filter": [ + "!in", + "class", + "continent", + "country", + "state", + "region", + "province", + "city", + "town", + "place" + ] + }, + { + "id": "Station", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 12, + "layout": { + "icon-image": [ + "match", + [ + "get", + "subclass" + ], + [ + "bus_stop", + "subway" + ], + [ + "get", + "subclass" + ], + "bus_station", + "bus_stop", + "station", + "railway", + "tram_stop", + "tramway", + [ + "case", + [ + "has", + "subclass" + ], + "dot", + "" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-line-height": 0.9, + "text-max-width": 9, + "text-offset": [ + 0, + 0.9 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 13, + 11 + ], + [ + 16, + 12 + ], + [ + 22, + 16 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(215, 83%, 53%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 12, + [ + "match", + [ + "get", + "subclass" + ], + [ + "station" + ], + 1, + 0 + ], + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "station", + "subway", + "tram_stop" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "bus_stop", + "station", + "subway", + "tram_stop" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(215, 83%, 53%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 12, + [ + "match", + [ + "get", + "subclass" + ], + [ + "station" + ], + 1, + 0 + ], + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "station", + "subway", + "tram_stop" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "bus_stop", + "station", + "subway", + "tram_stop" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "in", + "class", + "bus", + "railway" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Airport gate", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "aeroway", + "minzoom": 15, + "layout": { + "text-field": "{ref}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-size": { + "stops": [ + [ + 15, + 10 + ], + [ + 22, + 18 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,40%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "filter": [ + "==", + "class", + "gate" + ] + }, + { + "id": "Airport", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "aerodrome_label", + "minzoom": 8, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + "international", + "airport", + "airfield" + ], + "icon-size": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 0.6, + 10, + [ + "match", + [ + "get", + "class" + ], + "international", + 0.8, + 0.6 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + "international", + 1, + 0.8 + ] + ], + "text-anchor": "top", + "text-field": { + "stops": [ + [ + 8, + " " + ], + [ + 9, + "{iata}" + ], + [ + 12, + "{name:en}" + ] + ] + }, + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-line-height": 1.2, + "text-max-width": 9, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 9, + 9, + 10, + [ + "match", + [ + "get", + "class" + ], + "international", + 10, + 7 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + "international", + 13, + 11 + ] + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(215, 83%, 53%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 1, + 10, + 0.5, + 12, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 1, + 12, + 2 + ], + "icon-opacity": 1, + "text-color": "hsl(215, 83%, 53%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 1, + 10, + 0.5, + 12, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 1, + 12, + 2 + ] + }, + "filter": [ + "all", + [ + "has", + "iata" + ], + [ + "!in", + "class", + "public" + ] + ] + }, + { + "id": "State labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 3, + "maxzoom": 9, + "layout": { + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-letter-spacing": 0.1, + "text-max-width": 8, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 3, + 9 + ], + [ + 5, + 10 + ], + [ + 6, + 11 + ] + ] + }, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(48,4%,44%)", + "text-halo-color": "hsla(0,0%,100%,0.75)", + "text-halo-width": 0.8, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 3, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 3 + ], + 1, + 0 + ], + 8, + [ + "case", + [ + "==", + [ + "get", + "rank" + ], + 0 + ], + 0, + 1 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "in", + "class", + "state", + "province" + ], + [ + "<=", + "rank", + 6 + ] + ] + }, + { + "id": "Town labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 4, + "maxzoom": 16, + "layout": { + "icon-allow-overlap": true, + "icon-image": { + "stops": [ + [ + 6, + "circle" + ], + [ + 12, + " " + ] + ] + }, + "icon-optional": false, + "icon-size": [ + "interpolate", + [ + "exponential", + 1 + ], + [ + "zoom" + ], + 6, + 0.3, + 14, + 0.4 + ], + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "bottom", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + -0.15 + ], + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 6, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 12 + ], + 11, + 10 + ], + 9, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 15 + ], + 13, + 12 + ], + 16, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 15 + ], + 22, + 20 + ] + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 20%, 99%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "text-color": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 6, + "hsl(0,0%,20%)", + 12, + "hsl(0,0%,0%)" + ], + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "town" + ] + }, + { + "id": "City labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 4, + "maxzoom": 16, + "layout": { + "icon-allow-overlap": true, + "icon-image": [ + "step", + [ + "zoom" + ], + "circle", + 13, + "" + ], + "icon-optional": false, + "icon-size": 0.4, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "bottom", + "text-field": "{name:en}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + -0.15 + ], + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 4, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 2 + ], + 14, + 12 + ], + 8, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 4 + ], + 18, + 14 + ], + 12, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 4 + ], + 24, + 18 + ], + 16, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 4 + ], + 32, + 26 + ] + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 100%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "icon-opacity": 1, + "text-color": "hsl(0,0%,20%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 0.8 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "class", + "city" + ], + [ + "!=", + "capital", + 2 + ] + ] + }, + { + "id": "Capital city labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 4, + "maxzoom": 16, + "layout": { + "icon-allow-overlap": true, + "icon-image": [ + "step", + [ + "zoom" + ], + "circle", + 13, + "" + ], + "icon-optional": false, + "icon-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 4, + 0.45, + 10, + 0.5, + 11, + 0.6 + ], + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "bottom", + "text-field": "{name:en}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + -0.15 + ], + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 4, + 14, + 8, + 18, + 12, + 24, + 16, + 32 + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 100%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "icon-opacity": 1, + "text-color": "hsl(0,0%,20%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 0.8 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "class", + "city" + ], + [ + "==", + "capital", + 2 + ] + ] + }, + { + "id": "Country labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 1, + "maxzoom": 12, + "layout": { + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-allow-overlap": false, + "text-field": "{name:en}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-letter-spacing": 0.07, + "text-max-width": { + "stops": [ + [ + 1, + 5 + ], + [ + 5, + 8 + ] + ] + }, + "text-padding": 1, + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 0, + 8, + 1, + 10, + 4, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 2 + ], + 15, + 17 + ], + 8, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 2 + ], + 19, + 23 + ] + ], + "text-transform": "none", + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0, 0%, 20%)", + "text-halo-blur": 0.8, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1, + "text-opacity": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 4, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 4 + ], + 0, + 1 + ], + 5.9, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 4 + ], + 0, + 1 + ], + 6, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 4 + ], + 1, + 1 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "class", + "country" + ], + [ + "has", + "iso_a2" + ], + [ + "!=", + "iso_a2", + "VA" + ] + ] + }, + { + "id": "Continent labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "maxzoom": 1, + "layout": { + "text-field": "{name:en}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-justify": "center", + "text-size": { + "stops": [ + [ + 0, + 12 + ], + [ + 2, + 13 + ] + ] + }, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,19%)", + "text-halo-blur": 1, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "continent" + ] + } + ], + "metadata": { + "maptiler:copyright": "You are licensed to use the style or its derivate for serving map tiles exclusively with MapTiler Server or MapTiler Cloud and in accordance with their licenses and terms. If you plan to use the style in a different way, contact us at sales@maptiler.com.", + "spaceColor": "hsl(203, 100%, 85%)" + }, + "glyphs": "https://api.maptiler.com/fonts/{fontstack}/{range}.pbf?key=Tp9K7a8qzMTkBSzO4EZb", + "sprite": "https://api.maptiler.com/maps/streets-v2/sprite", + "bearing": 0, + "pitch": 0, + "center": [ + 0, + 0 + ], + "zoom": 1 +} \ No newline at end of file diff --git a/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/NavGraph.kt b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/NavGraph.kt index b464a151..a2b314db 100644 --- a/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/NavGraph.kt +++ b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/NavGraph.kt @@ -23,6 +23,8 @@ import ovh.plrapps.mapcompose.demo.ui.screens.MarkersLazyLoadingDemo import ovh.plrapps.mapcompose.demo.ui.screens.OsmDemo import ovh.plrapps.mapcompose.demo.ui.screens.PathsDemo import ovh.plrapps.mapcompose.demo.ui.screens.RotationDemo +import ovh.plrapps.mapcompose.demo.ui.screens.SwissMapVectorDemo +import ovh.plrapps.mapcompose.demo.ui.screens.VectorDemo import ovh.plrapps.mapcompose.demo.ui.screens.VisibleAreaPaddingDemo /* Type-safe navigation routes. Each demo screen and the home list has its own route object. */ @@ -42,6 +44,8 @@ import ovh.plrapps.mapcompose.demo.ui.screens.VisibleAreaPaddingDemo @Serializable object VisibleAreaPaddingRoute @Serializable object MarkersClusteringRoute @Serializable object MarkersLazyLoadingRoute +@Serializable object VectorRoute +@Serializable object SwissMapVectorRoute enum class MainDestinations(val title: String, val route: Any) { MAP_ALONE("Simple map", MapAlone), @@ -58,7 +62,9 @@ enum class MainDestinations(val title: String, val route: Any) { HTTP_TILES_DEMO("Remote HTTP tiles", HttpTilesRoute), VISIBLE_AREA_PADDING("Visible area padding", VisibleAreaPaddingRoute), MARKERS_CLUSTERING("Markers clustering", MarkersClusteringRoute), - MARKERS_LAZY_LOADING("Markers lazy loading", MarkersLazyLoadingRoute); + MARKERS_LAZY_LOADING("Markers lazy loading", MarkersLazyLoadingRoute), + VECTOR_TILE("Vector tile ", VectorRoute), + SWISS_VECTOR_TILE("Swiss map vector tile", SwissMapVectorRoute); } /** @@ -82,6 +88,8 @@ fun NavGraphBuilder.demoDestinations() { composable { VisibleAreaPaddingDemo.Content() } composable { MarkersClusteringDemo.Content() } composable { MarkersLazyLoadingDemo.Content() } + composable { VectorDemo.Content() } + composable { SwissMapVectorDemo.Content() } } /** diff --git a/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.kt b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.kt new file mode 100644 index 00000000..e1619de4 --- /dev/null +++ b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.kt @@ -0,0 +1,19 @@ +package ovh.plrapps.mapcompose.demo.ui.screens + +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import ovh.plrapps.mapcompose.demo.viewmodels.SwissMapVectorDemoVM +import ovh.plrapps.mapcompose.ui.MapUI + +expect object SwissMapVectorDemo { + @Composable + fun Content() +} + +@Composable +fun SwissMapVectorCommonUi(screenModel: SwissMapVectorDemoVM) { + MapUI( + Modifier, + state = screenModel.state + ) +} \ No newline at end of file diff --git a/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.kt b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.kt new file mode 100644 index 00000000..a6ba54f3 --- /dev/null +++ b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.kt @@ -0,0 +1,19 @@ +package ovh.plrapps.mapcompose.demo.ui.screens + +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import ovh.plrapps.mapcompose.demo.viewmodels.VectorDemoVM +import ovh.plrapps.mapcompose.ui.MapUI + +expect object VectorDemo { + @Composable + fun Content() +} + +@Composable +fun VectorCommonUi(screenModel: VectorDemoVM) { + MapUI( + Modifier, + state = screenModel.state + ) +} \ No newline at end of file diff --git a/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/SwissMapVectorDemoVM.kt b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/SwissMapVectorDemoVM.kt new file mode 100644 index 00000000..d132495b --- /dev/null +++ b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/SwissMapVectorDemoVM.kt @@ -0,0 +1,52 @@ +package ovh.plrapps.mapcompose.demo.viewmodels + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import kotlinx.coroutines.launch +import ovh.plrapps.mapcompose.api.addVectorLayer +import ovh.plrapps.mapcompose.api.enableRotation +import ovh.plrapps.mapcompose.api.scale +import ovh.plrapps.mapcompose.api.shouldLoopScale +import ovh.plrapps.mapcompose.ui.layout.Forced +import ovh.plrapps.mapcompose.ui.state.MapState +import kotlin.math.pow + +/** + * Shows how MapCompose behaves with remote HTTP tiles. + */ +class SwissMapVectorDemoVM : ViewModel() { + private val vectorTileStreamProvider = OSMVectorTileStreamProvider( + styleUrl = "https://vectortiles.geo.admin.ch/styles/ch.swisstopo.lightbasemap.vt/style.json" // ch.swisstopo.basemap.vt + ) + + private val maxLevel = 15 + private val minLevel = 7 + private val tileSize = 512 + private val mapSize = mapSizeAtLevel(maxLevel, tileSize = tileSize) + + val state = MapState( + levelCount = maxLevel + 1, + fullWidth = mapSize, + fullHeight = mapSize, + workerCount = 16, + tileSize = tileSize + ) { + minimumScaleMode(Forced(1 / 2.0.pow(maxLevel - minLevel))) + scroll(0.5231943373, 0.3542287256) + }.apply { + viewModelScope.launch { + addVectorLayer(vectorTileStreamProvider) + } + enableRotation() + scale = 0.0 + shouldLoopScale = true + } +} + +/** + * wmts level are 0 based. + * At level 0, the map corresponds to just one tile. + */ +private fun mapSizeAtLevel(wmtsLevel: Int, tileSize: Int): Int { + return tileSize * 2.0.pow(wmtsLevel).toInt() +} \ No newline at end of file diff --git a/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/VectorDemoVM.kt b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/VectorDemoVM.kt new file mode 100644 index 00000000..c91785c2 --- /dev/null +++ b/demo/composeApp/src/commonMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/VectorDemoVM.kt @@ -0,0 +1,61 @@ +package ovh.plrapps.mapcompose.demo.viewmodels + +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import kotlinx.coroutines.launch +import kotlinx.io.RawSource +import ovh.plrapps.mapcompose.api.addVectorLayer +import ovh.plrapps.mapcompose.api.enableRotation +import ovh.plrapps.mapcompose.api.scale +import ovh.plrapps.mapcompose.api.shouldLoopScale +import ovh.plrapps.mapcompose.vector.core.VectorTileStreamProvider +import ovh.plrapps.mapcompose.ui.state.MapState +import kotlin.math.pow + +/** + * Shows how MapCompose behaves with remote HTTP tiles. + */ +class VectorDemoVM : ViewModel() { + private val vectorTileStreamProvider = OSMVectorTileStreamProvider( + styleUrl = "files/style_street_v2.json" + ) + + private val maxLevel = 16 + private val mapSize = mapSizeAtLevel(maxLevel, tileSize = 256) + + val state = MapState( + levelCount = maxLevel + 1, + fullWidth = mapSize, + fullHeight = mapSize, + workerCount = 16 + ){ + infiniteScrollX(true) + }.apply { + viewModelScope.launch { + addVectorLayer(vectorTileStreamProvider) + } + enableRotation() + scale = 0.0 + shouldLoopScale = true + } +} + +expect class OSMVectorTileStreamProvider(styleUrl: String) : VectorTileStreamProvider { + override val styleUrl: String + + override suspend fun loadResources(url: String): RawSource? + override suspend fun getTileStream( + tileUrl: String, + row: Int, + col: Int, + zoomLvl: Int + ): RawSource? +} + +/** + * wmts level are 0 based. + * At level 0, the map corresponds to just one tile. + */ +private fun mapSizeAtLevel(wmtsLevel: Int, tileSize: Int): Int { + return tileSize * 2.0.pow(wmtsLevel).toInt() +} \ No newline at end of file diff --git a/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.desktop.kt b/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.desktop.kt new file mode 100644 index 00000000..11417cf9 --- /dev/null +++ b/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.desktop.kt @@ -0,0 +1,17 @@ +package ovh.plrapps.mapcompose.demo.ui.screens + +import androidx.compose.runtime.Composable +import androidx.lifecycle.viewmodel.compose.viewModel +import ovh.plrapps.mapcompose.demo.ui.MapWithZoomControl +import ovh.plrapps.mapcompose.demo.viewmodels.SwissMapVectorDemoVM + +actual object SwissMapVectorDemo { + @Composable + actual fun Content() { + val viewModel = viewModel { SwissMapVectorDemoVM() } + + MapWithZoomControl(state = viewModel.state) { + SwissMapVectorCommonUi(viewModel) + } + } +} \ No newline at end of file diff --git a/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.desktop.kt b/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.desktop.kt new file mode 100644 index 00000000..b7bf774a --- /dev/null +++ b/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.desktop.kt @@ -0,0 +1,17 @@ +package ovh.plrapps.mapcompose.demo.ui.screens + +import androidx.compose.runtime.Composable +import androidx.lifecycle.viewmodel.compose.viewModel +import ovh.plrapps.mapcompose.demo.ui.MapWithZoomControl +import ovh.plrapps.mapcompose.demo.viewmodels.VectorDemoVM + +actual object VectorDemo { + @Composable + actual fun Content() { + val viewModel = viewModel { VectorDemoVM() } + + MapWithZoomControl(state = viewModel.state) { + VectorCommonUi(viewModel) + } + } +} \ No newline at end of file diff --git a/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt b/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt index aec69332..b42f35e6 100644 --- a/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt +++ b/demo/composeApp/src/desktopMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt @@ -1,7 +1,12 @@ package ovh.plrapps.mapcompose.demo.viewmodels +import kotlinx.io.Buffer +import kotlinx.io.RawSource import kotlinx.io.asSource +import org.jetbrains.compose.resources.ExperimentalResourceApi import ovh.plrapps.mapcompose.core.TileStreamProvider +import ovh.plrapps.mapcompose.vector.core.VectorTileStreamProvider +import ovh.plrapps.mapcomposemp.demo.Res import java.net.HttpURLConnection import java.net.URL @@ -42,4 +47,51 @@ actual fun makeOsmTileStreamProvider() : TileStreamProvider { null } } +} + +actual class OSMVectorTileStreamProvider actual constructor(actual override val styleUrl: String) : + VectorTileStreamProvider { + + @OptIn(ExperimentalResourceApi::class) + actual override suspend fun loadResources(url: String): RawSource? { + return when (url) { + "files/style_street_v2.json" -> { + val buffer = Buffer() + buffer.write(Res.readBytes(url)) + buffer + } + else -> getResourceAsStream(url) + } + } + + actual override suspend fun getTileStream( + tileUrl: String, + row: Int, + col: Int, + zoomLvl: Int + ): RawSource? { + return getResourceAsStream(tileUrl) + } + + private fun getResourceAsStream(url: String): RawSource? { + return try { + val connection = URL(url).openConnection() as HttpURLConnection + connection.setRequestProperty("User-Agent", "Chrome/120.0.0.0 Safari/537.36") + // Explicitly request gzip — this disables Java's auto-decompression, so we + // decompress manually below when the server confirms gzip encoding. + connection.setRequestProperty("Accept-Encoding", "gzip") + connection.doInput = true + connection.connect() + + val stream = if (connection.contentEncoding?.equals("gzip", ignoreCase = true) == true) { + java.util.zip.GZIPInputStream(connection.inputStream) + } else { + connection.inputStream + } + stream.asSource() + } catch (e: Exception) { + e.printStackTrace() + null + } + } } \ No newline at end of file diff --git a/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.ios.kt b/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.ios.kt new file mode 100644 index 00000000..8901d691 --- /dev/null +++ b/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/SwissMapVectorDemo.ios.kt @@ -0,0 +1,14 @@ +package ovh.plrapps.mapcompose.demo.ui.screens + +import androidx.compose.runtime.Composable +import androidx.lifecycle.viewmodel.compose.viewModel +import ovh.plrapps.mapcompose.demo.viewmodels.SwissMapVectorDemoVM + +actual object SwissMapVectorDemo { + @Composable + actual fun Content() { + val viewModel = viewModel { SwissMapVectorDemoVM() } + + SwissMapVectorCommonUi(viewModel) + } +} \ No newline at end of file diff --git a/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.ios.kt b/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.ios.kt new file mode 100644 index 00000000..429467dd --- /dev/null +++ b/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/ui/screens/VectorDemo.ios.kt @@ -0,0 +1,14 @@ +package ovh.plrapps.mapcompose.demo.ui.screens + +import androidx.compose.runtime.Composable +import androidx.lifecycle.viewmodel.compose.viewModel +import ovh.plrapps.mapcompose.demo.viewmodels.VectorDemoVM + +actual object VectorDemo { + @Composable + actual fun Content() { + val viewModel = viewModel { VectorDemoVM() } + + VectorCommonUi(viewModel) + } +} \ No newline at end of file diff --git a/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt b/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt index d697c278..f565808f 100644 --- a/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt +++ b/demo/composeApp/src/iosMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/Http.kt @@ -1,8 +1,13 @@ package ovh.plrapps.mapcompose.demo.viewmodels +import kotlinx.io.Buffer +import kotlinx.io.RawSource +import org.jetbrains.compose.resources.ExperimentalResourceApi import ovh.plrapps.mapcompose.core.TileStreamProvider +import ovh.plrapps.mapcompose.vector.core.VectorTileStreamProvider import ovh.plrapps.mapcompose.demo.utils.getKtorClient import ovh.plrapps.mapcompose.demo.utils.readBuffer +import ovh.plrapps.mapcomposemp.demo.Res actual fun makeHttpTileStreamProvider(): TileStreamProvider { // TODO: use a blocking http client. MapCompose already switches context when calling the provided TileStreamProvider, @@ -33,4 +38,40 @@ actual fun makeOsmTileStreamProvider(): TileStreamProvider { null } } +} + +actual class OSMVectorTileStreamProvider actual constructor(actual override val styleUrl: String) : + VectorTileStreamProvider { + val httpClient = getKtorClient() + + @OptIn(ExperimentalResourceApi::class) + actual override suspend fun loadResources(url: String): RawSource? { + return try { + when (url) { + "files/style_street_v2.json" -> { + val buffer = Buffer() + buffer.write(Res.readBytes(url)) + buffer + } + else -> readBuffer(httpClient, url) + } + } catch (e: Exception) { + e.printStackTrace() + null + } + } + + actual override suspend fun getTileStream( + tileUrl: String, + row: Int, + col: Int, + zoomLvl: Int + ): RawSource? { + return try { + readBuffer(httpClient, tileUrl) + } catch (e: Exception) { + e.printStackTrace() + null + } + } } \ No newline at end of file diff --git a/demo/composeApp/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/VectorDemoVM.wasmJs.kt b/demo/composeApp/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/VectorDemoVM.wasmJs.kt new file mode 100644 index 00000000..390b32ad --- /dev/null +++ b/demo/composeApp/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/demo/viewmodels/VectorDemoVM.wasmJs.kt @@ -0,0 +1,44 @@ +package ovh.plrapps.mapcompose.demo.viewmodels + +import kotlinx.io.Buffer +import kotlinx.io.RawSource +import org.jetbrains.compose.resources.ExperimentalResourceApi +import ovh.plrapps.mapcompose.vector.core.VectorTileStreamProvider +import ovh.plrapps.mapcompose.demo.utils.getKtorClient +import ovh.plrapps.mapcompose.demo.utils.readBuffer +import ovh.plrapps.mapcomposemp.demo.Res + +actual class OSMVectorTileStreamProvider actual constructor(actual override val styleUrl: String) : VectorTileStreamProvider { + val httpClient = getKtorClient() + + @OptIn(ExperimentalResourceApi::class) + actual override suspend fun loadResources(url: String): RawSource? { + return try { + when (url) { + "files/style_street_v2.json" -> { + val buffer = Buffer() + buffer.write(Res.readBytes(url)) + buffer + } + else -> readBuffer(httpClient, url) + } + } catch (e: Exception) { + e.printStackTrace() + null + } + } + + actual override suspend fun getTileStream( + tileUrl: String, + row: Int, + col: Int, + zoomLvl: Int + ): RawSource? { + return try { + readBuffer(httpClient, tileUrl) + } catch (e: Exception) { + e.printStackTrace() + null + } + } +} \ No newline at end of file diff --git a/doc/wip/trouble_direct_raster.mp4 b/doc/wip/trouble_direct_raster.mp4 new file mode 100644 index 00000000..207de402 Binary files /dev/null and b/doc/wip/trouble_direct_raster.mp4 differ diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index e085e968..6323c71c 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -11,11 +11,13 @@ jetbrains-compose = "1.11.1" # JetBrains Compose (KMP) compose = "1.11.2" # AndroidX Compose (Android-only) coroutines = "1.11.0" kotlinx-io = "0.9.0" +pbandk = "0.16.0" +kotlinx-datetime = "0.6.2" +kotlinx-serialization = "1.11.0" # ---- Demo ---- jetbrains-compose-material3 = "1.9.0" ktor = "3.4.3" -kotlinx-serialization = "1.11.0" jetbrains-navigation = "2.9.2" jetbrains-lifecycle = "2.11.0-beta01" androidx-activityCompose = "1.13.0" @@ -30,12 +32,16 @@ jetbrains-compose-foundation = { module = "org.jetbrains.compose.foundation:foun jetbrains-compose-ui = { module = "org.jetbrains.compose.ui:ui", version.ref = "jetbrains-compose" } kotlinx-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" } kotlinx-io-core = { module = "org.jetbrains.kotlinx:kotlinx-io-core", version.ref = "kotlinx-io" } +pbandk-runtime = { group = "pro.streem.pbandk", name = "pbandk-runtime", version.ref = "pbandk" } +kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" } # -- Android -- compose-ui-tooling = { module = "androidx.compose.ui:ui-tooling", version.ref = "compose" } compose-ui-tooling-preview = { module = "androidx.compose.ui:ui-tooling-preview", version.ref = "compose" } # -- Test -- kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotlin" } kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "coroutines" } +kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" } +compose-ui-test = { module = "org.jetbrains.compose.ui:ui-test", version.ref = "jetbrains-compose" } # ============================== Demo ============================== # Dependencies the demo app adds on top of what the library already needs. @@ -50,6 +56,7 @@ jetbrains-lifecycle-viewmodel-compose = { module = "org.jetbrains.androidx.lifec kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "kotlinx-serialization" } # -- Android -- androidx-activity-compose = { module = "androidx.activity:activity-compose", version.ref = "androidx-activityCompose" } +androidx-core = { module = "androidx.core:core-ktx", version = "1.19.0" } ktor-client-android = { module = "io.ktor:ktor-client-android", version.ref = "ktor" } # -- iOS -- ktor-client-darwin = { module = "io.ktor:ktor-client-darwin", version.ref = "ktor" } @@ -69,7 +76,7 @@ vanniktechPublish = { id = "com.vanniktech.maven.publish", version = "0.36.0" } # Declared `apply false` in the root build but not applied by any module: androidLibrary = { id = "com.android.library", version.ref = "agp" } kotlinAndroid = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" } +kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } # ---- Demo ---- androidApplication = { id = "com.android.application", version.ref = "agp" } -kotlinSerialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" } diff --git a/library/build.gradle.kts b/library/build.gradle.kts index 898f520e..1d03ac11 100644 --- a/library/build.gradle.kts +++ b/library/build.gradle.kts @@ -10,6 +10,7 @@ plugins { alias(libs.plugins.jetbrainsCompose) alias(libs.plugins.composeCompiler) alias(libs.plugins.vanniktechPublish) + alias(libs.plugins.kotlinSerialization) } kotlin { @@ -71,13 +72,17 @@ kotlin { androidMain.dependencies { implementation(libs.compose.ui.tooling.preview) implementation(libs.compose.ui.tooling) + implementation(libs.androidx.core) } commonMain.dependencies { implementation(libs.jetbrains.compose.runtime) implementation(libs.jetbrains.compose.foundation) implementation(libs.jetbrains.compose.ui) + implementation(libs.components.resources) implementation(libs.kotlinx.coroutines) api(libs.kotlinx.io.core) + implementation(libs.pbandk.runtime) + implementation(libs.kotlinx.serialization.json) } named("skiaMain").configure { dependencies { @@ -92,6 +97,9 @@ kotlin { commonTest.dependencies { implementation(libs.kotlin.test) implementation(libs.kotlinx.coroutines.test) + implementation(libs.kotlinx.datetime) + + implementation(libs.compose.ui.test) } } } diff --git a/library/src/androidMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.android.kt b/library/src/androidMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.android.kt new file mode 100644 index 00000000..aaa4552a --- /dev/null +++ b/library/src/androidMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.android.kt @@ -0,0 +1,16 @@ +package ovh.plrapps.mapcompose.vector.data + +import android.graphics.BitmapFactory +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.asImageBitmap +import androidx.core.graphics.createBitmap + +internal actual fun imageBitmapFromArgb(argb: IntArray, width: Int, height: Int): ImageBitmap { + val bmp = createBitmap(width, height) + bmp.setPixels(argb, 0, width, 0, 0, width, height) + return bmp.asImageBitmap() +} + +internal actual fun byteArrayToImageBitmap(bytes: ByteArray): ImageBitmap { + return BitmapFactory.decodeByteArray(bytes, 0, bytes.size).asImageBitmap() +} \ No newline at end of file diff --git a/library/src/androidMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.android.kt b/library/src/androidMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.android.kt new file mode 100644 index 00000000..3279343b --- /dev/null +++ b/library/src/androidMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.android.kt @@ -0,0 +1,16 @@ +package ovh.plrapps.mapcompose.vector.data.extension + +import android.graphics.Bitmap +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.asAndroidBitmap +import java.io.ByteArrayOutputStream + +actual fun ImageBitmap.toBytes(): ByteArray? { + val bitmap = this.asAndroidBitmap() + val stream = ByteArrayOutputStream() + return if (bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)) { + stream.toByteArray() + } else { + null + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/api/LayerApi.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/api/LayerApi.kt index 3e7ee774..6c60adf5 100644 --- a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/api/LayerApi.kt +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/api/LayerApi.kt @@ -2,9 +2,18 @@ package ovh.plrapps.mapcompose.api -import ovh.plrapps.mapcompose.core.* +import ovh.plrapps.mapcompose.core.AboveAll +import ovh.plrapps.mapcompose.core.AboveLayer +import ovh.plrapps.mapcompose.core.BelowAll +import ovh.plrapps.mapcompose.core.BelowLayer +import ovh.plrapps.mapcompose.core.Layer +import ovh.plrapps.mapcompose.core.LayerPlacement +import ovh.plrapps.mapcompose.core.TileStreamProvider +import ovh.plrapps.mapcompose.vector.core.VectorTileStreamProvider +import ovh.plrapps.mapcompose.core.makeLayerId import ovh.plrapps.mapcompose.ui.state.MapState import ovh.plrapps.mapcompose.utils.swap +import ovh.plrapps.mapcompose.vector.core.VectorLayer /** @@ -55,6 +64,17 @@ fun MapState.addLayer( return id } +suspend fun MapState.addVectorLayer( + vectorTileStreamProvider: VectorTileStreamProvider, + initialOpacity: Float = 1f, + placement: LayerPlacement = AboveAll +): String { + val vectorLayer = VectorLayer(mapState = this, vectorTileStreamProvider) + val tileStreamProvider = vectorLayer.makeTileStreamProvider() + // TODO: honor placement parameter + return addLayer(tileStreamProvider) +} + /** * Replaces a layer. If the layer doesn't exist, no layer is added. * diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/MapUI.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/MapUI.kt index bee44821..41ceb39e 100644 --- a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/MapUI.kt +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/MapUI.kt @@ -7,12 +7,15 @@ import androidx.compose.runtime.remember import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clipToBounds import androidx.compose.ui.platform.LocalDensity +import androidx.compose.ui.platform.LocalFontFamilyResolver +import androidx.compose.ui.text.rememberTextMeasurer import androidx.compose.ui.zIndex import ovh.plrapps.mapcompose.ui.layout.ZoomPanRotate import ovh.plrapps.mapcompose.ui.layout.ZoomPanRotateConfig import ovh.plrapps.mapcompose.ui.markers.MarkerComposer import ovh.plrapps.mapcompose.ui.paths.PathComposer import ovh.plrapps.mapcompose.ui.state.MapState +import ovh.plrapps.mapcompose.vector.ui.symbols.SymbolComposer import ovh.plrapps.mapcompose.ui.view.TileCanvas @Composable @@ -22,6 +25,7 @@ fun MapUI( content: @Composable () -> Unit = {} ) { val zoomPRState = state.zoomPanRotateState + val symbolState = state.symbolState val markerState = state.markerRenderState val pathState = state.pathState @@ -29,6 +33,14 @@ fun MapUI( remember(density) { state.densityState.value = density } + val fontFamilyResolver = LocalFontFamilyResolver.current + remember(fontFamilyResolver) { + state.fontFamilyResolverState.value = fontFamilyResolver + } + val textMeasurer = rememberTextMeasurer() + remember(textMeasurer) { + state.textMeasurerState.value = textMeasurer + } key(state) { ZoomPanRotate( @@ -55,6 +67,12 @@ fun MapUI( isFilteringBitmap = state.isFilteringBitmap, ) + SymbolComposer( + modifier = Modifier, + zoomPRState = zoomPRState, + symbolState = symbolState + ) + MarkerComposer( modifier = Modifier.zIndex(1f), zoomPRState = zoomPRState, diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/state/MapState.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/state/MapState.kt index 7198a88c..e449289a 100644 --- a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/state/MapState.kt +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/state/MapState.kt @@ -6,6 +6,8 @@ import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.setValue import androidx.compose.ui.geometry.Offset import androidx.compose.ui.graphics.Color +import androidx.compose.ui.text.TextMeasurer +import androidx.compose.ui.text.font.FontFamily import androidx.compose.ui.unit.Density import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers @@ -23,6 +25,7 @@ import ovh.plrapps.mapcompose.ui.state.markers.MarkerRenderState import ovh.plrapps.mapcompose.ui.state.markers.MarkerState import ovh.plrapps.mapcompose.utils.AngleDegree import ovh.plrapps.mapcompose.utils.toRad +import ovh.plrapps.mapcompose.vector.ui.state.SymbolState /** * The state of the map. All public APIs are extensions functions or extension properties of this @@ -62,6 +65,7 @@ class MapState( internal val markerRenderState = MarkerRenderState() internal val markerState = MarkerState(scope, markerRenderState) internal val pathState = PathState(fullWidth, fullHeight) + internal val symbolState = SymbolState() internal val visibleTilesResolver = VisibleTilesResolver( levelCount = levelCount, @@ -73,6 +77,7 @@ class MapState( ) { zoomPanRotateState.scale } + internal val tileCanvasState = TileCanvasState( scope, tileSize, @@ -100,6 +105,8 @@ class MapState( applyLateInitialValues(initialValues) } internal val densityState = MutableStateFlow(null) + internal val fontFamilyResolverState = MutableStateFlow(null) + internal val textMeasurerState = MutableStateFlow(null) /** * Cancels all internal tasks. @@ -167,6 +174,14 @@ class MapState( private suspend fun renderVisibleTiles() { val viewport = updateViewport() tileCanvasState.setViewport(viewport) + for (listener in viewportListeners) { + listener.onViewportChanged(viewport) + } + } + + private var viewportListeners = mutableListOf() + internal fun addViewportChangeListener(listener: ViewportListener) { + viewportListeners.add(listener) } private fun updateViewport(): Viewport { @@ -337,4 +352,8 @@ class InitialValues internal constructor() { internal typealias LayoutTapCb = (x: Double, y: Double) -> Unit +internal fun interface ViewportListener { + fun onViewportChanged(viewport: Viewport) +} + expect fun getProcessorCount(): Int \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/state/TileCanvasState.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/state/TileCanvasState.kt index 9f9fe77e..68b316ed 100644 --- a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/state/TileCanvasState.kt +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/ui/state/TileCanvasState.kt @@ -15,6 +15,7 @@ import kotlinx.coroutines.flow.Flow import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.asStateFlow import kotlinx.coroutines.flow.collectLatest +import kotlinx.coroutines.flow.map import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import ovh.plrapps.mapcompose.core.ColorFilterProvider @@ -65,6 +66,10 @@ internal class TileCanvasState( private val visibleTileLocationsChannel = Channel(capacity = Channel.RENDEZVOUS) private val tilesOutput = Channel(capacity = Channel.RENDEZVOUS) private val visibleStateFlow = MutableStateFlow(null) + internal val visibleTiles = visibleStateFlow.asStateFlow().map { + it?.visibleTiles + } + internal var alphaTick = 0.07f set(value) { field = value.coerceIn(0.01f, 1f) diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/README.md b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/README.md new file mode 100644 index 00000000..c26059dd --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/README.md @@ -0,0 +1,104 @@ +## Specifications +- style-spec https://maplibre.org/maplibre-style-spec/ + - [Expressions](https://maplibre.org/maplibre-style-spec/expressions/) + - [Layers](https://maplibre.org/maplibre-style-spec/layers/) +- tilejson-spec https://github.com/mapbox/tilejson-spec/blob/master/2.2.0/README.md +- vector-tile-spec https://github.com/mapbox/vector-tile-spec/tree/master + +## Reference implementations : +- Maplibre-gl-js https://github.com/maplibre/maplibre-gl-js/tree/main/src/render +- Maplibre-native https://github.com/maplibre/maplibre-native/blob/main/src/mbgl/renderer/layers/render_symbol_layer.cpp + +## Status +The overall project structure and, most importantly, the parsers and decoders have been implemented. +For rendering, only the basic painters have been implemented (background, lines, polygons, labels). + +Three main directions +- Expression parser and processing. Needs to be covered with tests, and the existing tests require reorganization. +- Rendering.Implement the remaining painters and fix bugs in the existing ones. +- Tests. Not enough tests, more needed + +TL;DR +### ✅ Decoders + +- ✅ PBF decoder -> + - ✅ Geometry decoder +- ✅ Style decoder +- ✅ interpolation for: + - ✅ Color + - ✅ Number + - ✅ String +- ✅ Expressions (may require further analysis) +- ✅ Filters (MVP) + +### 🚧 Layers + +- 🛠 Background +- 🛠️ Lines +- 🛠️ Polygons +- 🛠️ Symbols +- ❌ Sprites (part of Symbols) +- ❌ Raster +- ❌ Circle +- ❌ FillExtrusion +- ❌ Heatmap +- ❌ Hillshade +- ❌ Sky + +### What is implemented and close to MapLibre + +#### MVT (Vector Tile) Geometry Decoding +ZigZag decoding, correct coordinate handling, support for POINT, LINESTRING, POLYGON. +Tests for the decoder and reversibility. + +#### Symbol Painter +Rendering text on lines and polygons. +Text centering on lines/polygons, angle calculation. +Correct text rotation (so it’s never upside down). +Support for text-halo (outline), color, size, opacity. +Support for text-offset, text-anchor. +Correct work with text templates (substituteTemplate). +Basic collision system implemented: labels do not overlap (within a tile). +Support for allowOverlap, ignorePlacement, priorities. +Visual debugging (borders, color). +Collision reset. +Currently, collision reset is implemented at the tile level, but MapLibre has nuances with global placement (especially when rendering multiple tiles in one frame). +No spatial index (R-tree), but for small tiles this is not critical. No Fonts(WIP). +#### Line, Background & Polygons +WIP +#### Styles +Using expressions (process()) to obtain styles. +LineLabelPlacement +Placing labels along a line, taking symbol-spacing into account. +Tests for even and correct placement. +Tests +Unit test coverage for decoder, collision, and line placement. + +What is partially or simplistically implemented +Not implemented (or not fully implemented) +What is not yet implemented (or only partially implemented): + +Icon placement and icon support +In MapLibre, labels can be not only text but also icons (icon-image, icon-size, etc.). + +Layout Expressions +In MapLibre, layout expressions can be very complex (e.g., depending on zoom, feature-state, data-driven styling). + +Collision Groups +MapLibre allows specifying collision groups (collision-group) so that labels from different groups do not interfere with each other. + +Rotated collision box +In MapLibre, rotated collision boxes are used for text along lines, so collisions are calculated based on the actual position of the text, not just AABB. + +Complex scenarios with multilingual labels, fallback, bidirectional text +MapLibre supports advanced language scenarios. + +Dynamic loading and removal of labels when zoom/viewport changes +In MapLibre, placement can be global for the entire frame, not just per tile. + +Everything related to basic rendering, collisions, and text placement is implemented close to MapLibre. +To be improved: rotated collision box, spatial index, icon support, complex expressions, collision groups. + + + + diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/compose/rememberRasterizer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/compose/rememberRasterizer.kt new file mode 100644 index 00000000..161b3765 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/compose/rememberRasterizer.kt @@ -0,0 +1,38 @@ +package ovh.plrapps.mapcompose.vector.compose + +//import androidx.compose.runtime.Composable +//import androidx.compose.runtime.getValue +//import androidx.compose.runtime.produceState +//import androidx.compose.runtime.remember +//import androidx.compose.ui.platform.LocalDensity +//import androidx.compose.ui.platform.LocalFontFamilyResolver +//import androidx.compose.ui.text.rememberTextMeasurer +//import org.jetbrains.compose.resources.ExperimentalResourceApi +//import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +//import ovh.plrapps.mapcompose.vector.data.getMapLibreConfiguration +//import kotlin.math.roundToInt + +//@OptIn(ExperimentalResourceApi::class) +//@Composable +//fun rememberRasterizer(styleSource: suspend () -> String): MapLibreRasterizer? { +// val density = LocalDensity.current +// val fontFamilyResolver = LocalFontFamilyResolver.current +// val textMeasurer = rememberTextMeasurer() +// val configuration by produceState(null) { +// value = styleSource().let { +// getMapLibreConfiguration(it, pixelRatio = density.density.roundToInt()).getOrThrow() +// } +// } +// +// return remember(configuration) { +// configuration?.let { +// MapLibreRasterizer( +// configuration = it, +// density = density, +// fontFamilyResolver = fontFamilyResolver, +// textMeasurer = textMeasurer, +// tileCache = null +// ) +// } +// } +//} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorLayer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorLayer.kt new file mode 100644 index 00000000..7cdd420b --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorLayer.kt @@ -0,0 +1,179 @@ +package ovh.plrapps.mapcompose.vector.core + +import androidx.compose.ui.unit.IntSize +import androidx.compose.ui.unit.dp +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.SharingStarted +import kotlinx.coroutines.flow.collectLatest +import kotlinx.coroutines.flow.stateIn +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import kotlinx.io.Buffer +import kotlinx.io.buffered +import kotlinx.io.readString +import ovh.plrapps.mapcompose.api.centroidX +import ovh.plrapps.mapcompose.api.centroidY +import ovh.plrapps.mapcompose.api.fullSize +import ovh.plrapps.mapcompose.api.scale +import ovh.plrapps.mapcompose.core.TileMatrix +import ovh.plrapps.mapcompose.core.TileStreamProvider +import ovh.plrapps.mapcompose.vector.core.VectorTileStreamProvider +import ovh.plrapps.mapcompose.core.Viewport +import ovh.plrapps.mapcompose.core.VisibleTiles +import ovh.plrapps.mapcompose.core.VisibleWindow +import ovh.plrapps.mapcompose.ui.state.MapState +import ovh.plrapps.mapcompose.utils.IODispatcher +import ovh.plrapps.mapcompose.utils.throttle +import ovh.plrapps.mapcompose.vector.data.extension.toBytes +import ovh.plrapps.mapcompose.vector.data.extension.toMVTViewport +import ovh.plrapps.mapcompose.vector.data.getMapLibreConfiguration + +internal class VectorLayer( + private val mapState: MapState, + private val vectorTileStreamProvider: VectorTileStreamProvider, +) { + private val scope = mapState.scope + + val visibleTiles = + mapState.tileCanvasState.visibleTiles.stateIn(scope, SharingStarted.Eagerly, null) + val viewportInfoFlow = MutableStateFlow(null) + + init { + listenForViewportUpdates() + } + + suspend fun makeTileStreamProvider(): TileStreamProvider { + val style = withContext(IODispatcher) { + vectorTileStreamProvider.loadResources(vectorTileStreamProvider.styleUrl)?.buffered()?.readString() + } + + val configuration = getMapLibreConfiguration( + style = style ?: "", + loadResource = vectorTileStreamProvider::loadResources + ).getOrThrow() + + val rasterizer = VectorRasterizer( + configuration = configuration, + densityState = mapState.densityState, + fontFamilyResolverState = mapState.fontFamilyResolverState, + textMeasurerState = mapState.textMeasurerState, + getTileStream = vectorTileStreamProvider::getTileStream + ) + + startSymbolsProcessing(rasterizer) + + return TileStreamProvider { row, col, zoomLvl -> + val density = mapState.densityState.value ?: return@TileStreamProvider null + val tilePx = with(density) { 256.dp.toPx() }.toInt() + + val imageBitmap = rasterizer.getTile( + x = col, + y = row, + zoom = zoomLvl.toDouble(), + tileSize = tilePx + ) + + val bytes = imageBitmap.toBytes() + ?: return@TileStreamProvider null + + Buffer().apply { + write(bytes) + } + } + } + + private fun startSymbolsProcessing(rasterizer: VectorRasterizer) { + scope.launch { + viewportInfoFlow + .throttle(250) + .collectLatest { viewportInfo -> + viewportInfo ?: return@collectLatest + + val zoomLvl = viewportInfo.zoom + val tilePx = mapState.tileSize + + val nextSymbols = rasterizer.produceSymbols( + viewport = viewportInfo.toMVTViewport(), + tileSize = tilePx, + z = zoomLvl.toDouble() + ).getOrElse { e -> + println("[ERROR] produceSymbols(): ${e.message}") + return@collectLatest + } + + rasterizer.updateSymbols( + nextSymbols = nextSymbols, + state = mapState, + viewportInfo = viewportInfo + ) + mapState.symbolState.visiblePhases = viewportInfo.visiblePhases + } + } + } + + private fun listenForViewportUpdates() { + var lastViewport: Viewport? = null + fun updateViewportInfo(visibleTiles: VisibleTiles, viewport: Viewport) { + val visibleWindow = visibleTiles.visibleWindow + val (mergedMatrix, leftVisible, rightVisible) = when (visibleWindow) { + is VisibleWindow.InfiniteScrollX -> Triple( + mergeMatrices( + visibleWindow.tileMatrix, + visibleWindow.leftOverflow?.tileMatrix, + visibleWindow.rightOverflow?.tileMatrix + ), + visibleWindow.leftOverflow != null, + visibleWindow.rightOverflow != null + ) + is VisibleWindow.BoundsConstrained -> Triple(visibleWindow.tileMatrix, false, false) + } + viewportInfoFlow.value = ViewportInfo( + matrix = mergedMatrix, + size = IntSize( + width = (viewport.right - viewport.left), + height = (viewport.bottom - viewport.top), + ), + angleRad = viewport.angleRad, + pitch = 0f, + zoom = visibleTiles.level, + centroidX = mapState.centroidX, + centroidY = mapState.centroidY, + scale = mapState.scale, + fullWidth = mapState.fullSize.width, + fullHeight = mapState.fullSize.height, + infiniteScrollX = leftVisible || rightVisible, + visiblePhases = (if (leftVisible) -1 else 0)..(if (rightVisible) 1 else 0), + ) + } + + mapState.addViewportChangeListener { viewport -> + val currentVisibleTiles = visibleTiles.value + if (currentVisibleTiles != null) { + lastViewport = viewport + updateViewportInfo(currentVisibleTiles, viewport) + } + } + + scope.launch { + visibleTiles.collect { visibleTiles -> + visibleTiles ?: return@collect + val viewport = lastViewport ?: return@collect + updateViewportInfo(visibleTiles, viewport) + } + } + } + + private fun mergeMatrices(vararg matrices: TileMatrix?): TileMatrix { + val result = mutableMapOf() + for (matrix in matrices) { + matrix ?: continue + for ((row, cols) in matrix) { + val existing = result[row] + result[row] = if (existing == null) cols else { + minOf(existing.first, cols.first)..maxOf(existing.last, cols.last) + } + } + } + return result + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorRasterizer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorRasterizer.kt new file mode 100644 index 00000000..b5d07a14 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorRasterizer.kt @@ -0,0 +1,718 @@ +package ovh.plrapps.mapcompose.vector.core + +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Rect +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.Canvas +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.drawscope.CanvasDrawScope +import androidx.compose.ui.text.TextMeasurer +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.unit.Density +import androidx.compose.ui.unit.IntSize +import androidx.compose.ui.unit.LayoutDirection +import kotlinx.coroutines.CancellationException +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.async +import kotlinx.coroutines.currentCoroutineContext +import kotlinx.coroutines.ensureActive +import kotlinx.coroutines.supervisorScope +import kotlinx.coroutines.withContext +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlinx.io.RawSource +import kotlinx.io.buffered +import kotlinx.io.readByteArray +import ovh.plrapps.mapcompose.core.TileMatrix +import ovh.plrapps.mapcompose.ui.state.MapState +import ovh.plrapps.mapcompose.utils.AngleRad +import ovh.plrapps.mapcompose.utils.IODispatcher +import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +import ovh.plrapps.mapcompose.vector.renderer.CompoundLabelPlacement +import ovh.plrapps.mapcompose.vector.renderer.Point +import ovh.plrapps.mapcompose.vector.renderer.Symbol +import ovh.plrapps.mapcompose.vector.renderer.SymbolsProducer +import ovh.plrapps.mapcompose.vector.renderer.TextPlacementCandidate +import ovh.plrapps.mapcompose.vector.renderer.TileRenderer +import ovh.plrapps.mapcompose.vector.renderer.collision.CollisionDetector +import ovh.plrapps.mapcompose.vector.renderer.collision.LabelPlacement +import ovh.plrapps.mapcompose.vector.renderer.utils.MVTViewport +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.utils.LruCache +import ovh.plrapps.mapcompose.vector.spec.style.SymbolLayer +import ovh.plrapps.mapcompose.vector.utils.obb.OBB +import ovh.plrapps.mapcompose.vector.utils.obb.ObbPoint +import pbandk.decodeFromByteArray +import kotlin.collections.component1 +import kotlin.collections.component2 +import kotlin.math.cos +import kotlin.math.sin +import kotlin.math.sqrt + +class VectorRasterizer( + val configuration: MapLibreConfiguration, + val densityState: MutableStateFlow, + val fontFamilyResolverState: MutableStateFlow, + val textMeasurerState: MutableStateFlow, + val getTileStream: suspend (url: String, row: Int, col: Int, zoomLvl: Int) -> RawSource?, + val tileSize: Int = 256, +) { + // Decoded protobuf Tile objects are large (up to several MB each in dense areas). + // Keep size modest; raw bytes remain available in byteCache for cheap re-decoding. + private val tileCache = LruCache(maxSize = 30) + private val byteCache = LruCache(maxSize = 100) + // Rendered tile output (PNG bytes). Cache hit avoids full geometry re-render. + private val renderedByteCache = LruCache(maxSize = 50) + private val pathCache = LruCache(maxSize = 200) + // Separate mutexes per cache eliminate cross-cache contention when tiles render concurrently. + private val byteCacheMutex = Mutex() + private val tileCacheMutex = Mutex() + private val pathCacheMutex = Mutex() + private val renderedByteCacheMutex = Mutex() + + // Precomputed set of all source names referenced by style layers (constant after init). + private val allSourceNames: Set by lazy { + configuration.style.layers.mapNotNull { it.source?.takeIf { s -> s.isNotBlank() } }.toSet() + } + + // Minimum viewport-pixel distance between repetitions of the same line label across tiles. + // Mirrors MapLibre's default symbol-spacing (250px). + private val MIN_LINE_LABEL_REPEAT_DIST = 250f + + private val stableAnchorCache = LruCache(maxSize = 1000) + + private fun getTileKey(sourceName: String, z: Int, x: Int, y: Int): String { + return "$sourceName-$z-$x-$y" + } + + fun decodePBFFromByteArray(bytes: ByteArray): Tile? { + return try { + Tile.decodeFromByteArray(bytes) + } catch (e: Exception) { + println("Error decoding PBF: ${e.message}") + null + } + } + + private suspend fun renderTile( + pbfList: Map, + zoom: Double, + tileSize: Int, + actualZoom: Double, + x: Int, + y: Int, + ): ImageBitmap { + val z = zoom.toInt() + val density = densityState.value ?: return emptyBitmap(tileSize) + + // One tileCache lookup per source (not per style layer) — reduces mutex ops from + // O(style_layers) to O(sources). + val tileForSource: Map = allSourceNames.associateWith { sourceName -> + val key = getTileKey(sourceName, z, x, y) + tileCacheMutex.withLock { tileCache.get(key) } + ?: pbfList[sourceName]?.let { bytes -> + decodePBFFromByteArray(bytes)?.also { t -> + tileCacheMutex.withLock { tileCache.put(key, t) } + } + } + } + + val imageBitmap = ImageBitmap(tileSize, tileSize) + val canvas = Canvas(imageBitmap) + val drawScope = CanvasDrawScope() + val localPropCache = HashMap>() + val tileRenderer = TileRenderer( + configuration = configuration, + pathCache = pathCache, + pathCacheMutex = pathCacheMutex, + localPropCache = localPropCache + ) + + drawScope.draw( + density = density, + layoutDirection = LayoutDirection.Ltr, + canvas = canvas, + size = Size(tileSize.toFloat(), tileSize.toFloat()) + ) { + for (styleLayer in configuration.style.layers) { + val sourceName = styleLayer.source.takeIf { !it.isNullOrBlank() } + val tileKey = sourceName?.let { getTileKey(it, z, x, y) } + val tile = sourceName?.let { tileForSource[it] } + + tileRenderer.render( + canvas = this, + tile = tile, + styleLayer = styleLayer, + zoom = zoom, + canvasSize = tileSize, + actualZoom = actualZoom, + tileKey = tileKey + ) + } + } + return imageBitmap + } + + private suspend fun fetchTile(url: String, row: Int, col: Int, zoomLvl: Int, sourceName: String): Result { + val key = getTileKey(sourceName, zoomLvl, col, row) + byteCacheMutex.withLock { + byteCache.get(key)?.let { return Result.success(it) } + } + + try { + // Check if the coroutine is cancelled before the network request + currentCoroutineContext().ensureActive() + +// println("fetch the tile $url") + val result = withContext(IODispatcher) { + val response = getTileStream(url, row, col, zoomLvl) + response?.buffered()?.use { bufferedSource -> + bufferedSource.readByteArray() + } + } ?: return Result.failure(LoadTileException("fetch error")) + byteCacheMutex.withLock { + byteCache.put(key, result) + } + return Result.success(result) + } catch (e: CancellationException) { + // We do not log cancellation as an error - this is normal behavior + throw e + } catch (e: Throwable) { + return Result.failure(e) + } + } + + // return sourceName: String and tile: ByteArray + private suspend fun fetch(z: Int, x: Int, y: Int): Result> = supervisorScope { + try { + // Kick off concurrent fetches per source without failing the whole scope on one error + val deferred = configuration.tileSources.map { (sourceName, ts) -> + sourceName to async { + // Ensure still active before heavy work + coroutineContext.ensureActive() + fetchTile(ts.getTileUrl(z = z, x = x, y = y), row = y, col = x, zoomLvl = z, sourceName = sourceName).getOrThrow() + } + } + + // Await all; collect successes, ignore failures so partial data can still render + val buffer = mutableMapOf() + for ((sourceName, d) in deferred) { + runCatching { d.await() } + .onSuccess { bytes -> buffer[sourceName] = bytes } + .onFailure { /* ignore single source failure */ } + } + + return@supervisorScope Result.success(buffer) + } catch (t: Throwable) { + Result.failure(t) + } + } + + private fun emptyBitmap(size: Int): ImageBitmap { + val density = densityState.value ?: return ImageBitmap(size, size) + + val imageBitmap = ImageBitmap(size, size) + val canvas = Canvas(imageBitmap) + val drawScope = CanvasDrawScope() + drawScope.draw( + density = density, + layoutDirection = LayoutDirection.Ltr, + canvas = canvas, + size = Size(size.toFloat(), size.toFloat()) + ) { + this.drawRect( + color = Color.LightGray, + ) + } + return imageBitmap + } + + suspend fun getTile( + x: Int, + y: Int, + zoom: Double, + tileSize: Int, + ): ImageBitmap { + val z = zoom.toInt() + val pbfList = fetch(z = z, x = x, y = y).getOrElse { e -> + println("ERROR: ${e.message}") + return emptyBitmap(tileSize) + } + + return renderTile( + pbfList = pbfList, + zoom = zoom, + tileSize = tileSize, + actualZoom = zoom, + x = x, + y = y, + ) + } + + private val symbolsProducer = SymbolsProducer( + textMeasurer = textMeasurerState, + configuration = configuration, + pathCache = pathCache, + pathCacheMutex = pathCacheMutex + ) + + suspend fun produceSymbols(viewport: MVTViewport, tileSize: Int, z: Double): Result> = withContext( + Dispatchers.Default + ) { + val density = densityState.value ?: return@withContext Result.failure(LoadTileException("density is null")) + + val symbols = mutableListOf() + if (viewport.tileMatrix.isEmpty()) return@withContext Result.success(symbols) + + val maxTileIndex = (1 shl viewport.zoom.toInt()) - 1 + val visibleRowMin = viewport.tileMatrix.keys.min() + val visibleRowMax = viewport.tileMatrix.keys.max() + + // Expand by 1 tile in each direction so edge symbols are collision-checked + // against off-screen content (MapLibre-style viewport padding). + val expandedTiles = mutableMapOf() + for ((row, cols) in viewport.tileMatrix) { + if (cols.isEmpty()) continue + expandedTiles[row] = (cols.min() - 1).coerceAtLeast(0)..(cols.max() + 1).coerceAtMost(maxTileIndex) + } + for (adjRow in listOf(visibleRowMin - 1, visibleRowMax + 1)) { + if (adjRow < 0 || adjRow > maxTileIndex) continue + val refRow = if (adjRow < visibleRowMin) visibleRowMin else visibleRowMax + val refCols = viewport.tileMatrix[refRow] ?: continue + if (refCols.isEmpty()) continue + expandedTiles[adjRow] = (refCols.min() - 1).coerceAtLeast(0)..(refCols.max() + 1).coerceAtMost(maxTileIndex) + } + + for ((y, colRange) in expandedTiles) { + for (x in colRange) { + // Loading PBF for the tile + val pbfList = fetch(z = z.toInt(), x = x, y = y).getOrElse { e -> + println("ERROR: ${e.message}") + return@withContext Result.failure(e) + } + + // One tileCache lookup per source (not per style layer). + val tileForSource: Map = allSourceNames.associateWith { sourceName -> + val key = getTileKey(sourceName, z.toInt(), x, y) + tileCacheMutex.withLock { tileCache.get(key) } + ?: pbfList[sourceName]?.let { bytes -> + decodePBFFromByteArray(bytes)?.also { t -> + tileCacheMutex.withLock { tileCache.put(key, t) } + } + } + } + + val localPropCache = HashMap>() + + // Use withIndex() to avoid O(n²) indexOf in the loop. + for ((layerIndex, styleLayer) in configuration.style.layers.withIndex()) { + if (styleLayer !is SymbolLayer) continue + val tile = styleLayer.source.takeIf { !it.isNullOrBlank() } + ?.let { tileForSource[it] } ?: continue + + symbolsProducer.produce( + tile = tile, + styleLayer = styleLayer, + layerIndex = layerIndex, + zoom = z, + canvasSize = tileSize, + actualZoom = z, + tileX = x, + tileY = y, + density = density, + localPropCache = localPropCache + ).let { + symbols.addAll(it) + } + } + } + } + + Result.success(symbols) + } + + fun updateSymbols(nextSymbols: List, state: MapState, viewportInfo: ViewportInfo) { + // run collision detection if enabled + val symbols = when (this.configuration.collisionDetectionEnabled) { + true -> clearCollision(nextSymbols, viewportInfo) + else -> nextSymbols + } + + checkIndexErrors(symbols) + println("xxxxx number of symbols ${symbols.size}") + state.symbolState.symbols = symbols + } + + private class Counter { + var value: Int = 0 + } + + private fun checkIndexErrors(nextSymbols: List) { + val counters = mutableMapOf() + + nextSymbols.forEach { symbol -> + counters.getOrPut(symbol.id) { Counter() }.value++ + } + counters.forEach { (id, value) -> + if (value.value > 1) { + println("xxxxx [ERROR]: Id $id not unique (${value.value})") + } + } + } + + /** + * Creates a LabelPlacement with viewport coordinates. + * + * [mapRotationDeg] is added to the OBB rotation only for symbols that rotate with the map + * (i.e. line text whose own angle is non-zero). Point symbols keep angle = 0 regardless of + * map rotation because their rotation-alignment defaults to "viewport". + */ + private fun createViewportLabelPlacement( + center: Offset, + originalPlacement: LabelPlacement, + mapRotationDeg: Float = 0f + ): LabelPlacement { + val bounds = originalPlacement.bounds + val ownAngle = originalPlacement.angle + + // The dimensions remain the same + val rectWidth = bounds.width + val rectHeight = bounds.height + + // New bounds relative to viewport center + val newBounds = Rect( + left = center.x - rectWidth / 2f, + top = center.y - rectHeight / 2f, + right = center.x + rectWidth / 2f, + bottom = center.y + rectHeight / 2f + ) + + // Line text (non-zero angle) rotates with the map; point symbols stay viewport-aligned. + val effectiveAngle = if (ownAngle != 0f) ownAngle + mapRotationDeg else ownAngle + + return originalPlacement.copy( + position = ObbPoint(center.x, center.y), + bounds = newBounds, + obb = OBB( + center = ObbPoint(center.x, center.y), + size = ovh.plrapps.mapcompose.vector.utils.obb.Size(rectWidth, rectHeight), + rotation = effectiveAngle + ) + ) + } + + /** + * Converts normalized Mercator coordinates to viewport (screen) pixel coordinates, + * accounting for the current map scale and rotation. + */ + private fun mercatorToViewport( + mercatorX: Double, + mercatorY: Double, + viewportInfo: ViewportInfo + ): Offset { + val centroidX = viewportInfo.centroidX + val centroidY = viewportInfo.centroidY + val currentScale = viewportInfo.scale + + var deltaX = mercatorX - centroidX + if (viewportInfo.infiniteScrollX) { + if (deltaX > 0.5) deltaX -= 1.0 + else if (deltaX < -0.5) deltaX += 1.0 + } + val deltaY = mercatorY - centroidY + + val viewportCenterX = viewportInfo.size.width.toDouble() / 2.0 + val viewportCenterY = viewportInfo.size.height.toDouble() / 2.0 + + // Scale the map-space delta to screen pixels + val scaledDX = deltaX * viewportInfo.fullWidth.toDouble() * currentScale + val scaledDY = deltaY * viewportInfo.fullHeight.toDouble() * currentScale + + // Compose rotate(θ) is clockwise, matching x'=dx*cos(θ)-dy*sin(θ); use +angleRad. + val angle = viewportInfo.angleRad.toDouble() + val viewportX = viewportCenterX + scaledDX * cos(angle) - scaledDY * sin(angle) + val viewportY = viewportCenterY + scaledDX * sin(angle) + scaledDY * cos(angle) + + return Offset(viewportX.toFloat(), viewportY.toFloat()) + } + + /** + * Sort symbols according to priority + */ + private fun sortForPlacement(symbols: List): List { + return symbols.withIndex() + .sortedWith( + compareByDescending> { + it.value.placement.spritePlacement.layerIndex + }.thenBy { + it.value.placement.spritePlacement.inLayerPriority + }.thenBy { + it.index + } + ) + .map { it.value } + } + + private fun makeStableAnchorKey(symbol: Symbol.SpriteWithText): String { + val text = symbol.textCandidates.firstOrNull()?.labelPlacement?.text ?: "" + val gx = (symbol.global.x * 100_000.0).toLong() + val gy = (symbol.global.y * 100_000.0).toLong() + return "${text}_${gx}_${gy}" + } + + /** + * Detects collisions and determines whether the element can be placed or not. + */ + private fun clearCollision(symbols: List, viewportInfo: ViewportInfo): List { + val collisionDetector = CollisionDetector() + val sortedSymbols = sortForPlacement(symbols) + val acceptedSymbols = mutableListOf() + val mapRotationDeg = viewportInfo.angleRad * (180f / kotlin.math.PI.toFloat()) + // Cross-tile line-label deduplication: track placed viewport positions per text string. + val placedLineTextPositions = mutableMapOf>() + + sortedSymbols.forEach { symbol -> + val viewportPos = mercatorToViewport( + mercatorX = symbol.global.x, + mercatorY = symbol.global.y, + viewportInfo = viewportInfo + ) + + val spritePlacement = symbol.placement.spritePlacement + val textPlacement = symbol.placement.textPlacement + + when (symbol) { + is Symbol.SpriteWithText -> { + val spriteViewportPlacement = createViewportLabelPlacement( + center = viewportPos, + originalPlacement = spritePlacement, + mapRotationDeg = mapRotationDeg + ) + + if (symbol.textCandidates.isNotEmpty()) { + // Candidate path: try each text position in order, pick the first that fits. + // Used for both text-variable-anchor (multiple candidates) and text-anchor + // (single candidate) — textCandidates is always non-empty for SpriteWithText. + if (!collisionDetector.wouldCollide(spriteViewportPlacement)) { + var placed = false + val stableKey = makeStableAnchorKey(symbol) + val lastIndex = stableAnchorCache.get(stableKey) + val orderedCandidates: List> = + if (lastIndex != null && lastIndex < symbol.textCandidates.size) { + listOf(IndexedValue(lastIndex, symbol.textCandidates[lastIndex])) + + symbol.textCandidates.withIndex().filter { it.index != lastIndex } + } else { + symbol.textCandidates.withIndex().toList() + } + for ((index, candidate) in orderedCandidates) { + val textVP = mercatorToViewport(candidate.mercatorX, candidate.mercatorY, viewportInfo) + val textVPPlacement = createViewportLabelPlacement(textVP, candidate.labelPlacement, mapRotationDeg) + if (!collisionDetector.wouldCollide(textVPPlacement)) { + collisionDetector.insert(spriteViewportPlacement) + collisionDetector.insert(textVPPlacement) + stableAnchorCache.put(stableKey, index) + // Text added first: SymbolComposer draws reversed(), so first + // entries are drawn on top — text should render above sprite. + acceptedSymbols.add( + Symbol.Text( + id = "${symbol.id}_t", + global = Point(candidate.mercatorX, candidate.mercatorY), + placement = CompoundLabelPlacement(candidate.labelPlacement, candidate.labelPlacement), + value = symbol.text, + spriteAnchorGlobal = symbol.global, + textOffset = Pair(candidate.dx, candidate.dy), + ) + ) + acceptedSymbols.add( + Symbol.Sprite( + id = "${symbol.id}_s", + global = symbol.global, + placement = CompoundLabelPlacement(spritePlacement, null), + value = symbol.sprite, + ) + ) + placed = true + break + } + } + if (!placed && symbol.textOptional) { + collisionDetector.insert(spriteViewportPlacement) + acceptedSymbols.add( + Symbol.Sprite( + id = symbol.id, + global = symbol.global, + placement = CompoundLabelPlacement(spritePlacement, null), + value = symbol.sprite, + ) + ) + } + } else if (symbol.iconOptional) { + // Sprite collides but icon is optional — try text-only placement. + for (candidate in symbol.textCandidates) { + val textVP = mercatorToViewport(candidate.mercatorX, candidate.mercatorY, viewportInfo) + val textVPPlacement = createViewportLabelPlacement(textVP, candidate.labelPlacement, mapRotationDeg) + if (!collisionDetector.wouldCollide(textVPPlacement)) { + collisionDetector.insert(textVPPlacement) + acceptedSymbols.add( + Symbol.Text( + id = "${symbol.id}_t", + global = Point(candidate.mercatorX, candidate.mercatorY), + placement = CompoundLabelPlacement(candidate.labelPlacement, candidate.labelPlacement), + value = symbol.text, + ) + ) + break + } + } + } + } else { + val textViewportPlacement = textPlacement?.let { textPlace -> + val spriteHeight = symbol.spriteSize.height.toFloat() + val verticalGap = symbol.verticalGap + val textHeight = symbol.textSize.height.toFloat() + + val textOffsetY = spriteHeight / 2f + verticalGap + textHeight / 2f + // SpriteWithText is viewport-aligned: text is always directly below the + // sprite in screen space, regardless of map rotation. + val textViewportPos = Offset(viewportPos.x, viewportPos.y + textOffsetY) + + createViewportLabelPlacement( + center = textViewportPos, + originalPlacement = textPlace, + mapRotationDeg = mapRotationDeg + ) + } + + val spriteCanPlace = !collisionDetector.wouldCollide(spriteViewportPlacement) + val textCanPlace = textViewportPlacement?.let { + !collisionDetector.wouldCollide(it) + } ?: true + + if (spriteCanPlace && textCanPlace) { + // Use insert() (not tryPlaceLabel) because we already validated both parts + // above. tryPlaceLabel would re-check after sprite is inserted and reject + // the text OBB since padded sprite/text boxes always overlap each other. + collisionDetector.insert(spriteViewportPlacement) + textViewportPlacement?.let { collisionDetector.insert(it) } + acceptedSymbols.add(symbol) + } else if (spriteCanPlace && !textCanPlace && symbol.textOptional) { + collisionDetector.insert(spriteViewportPlacement) + acceptedSymbols.add( + Symbol.Sprite( + id = symbol.id, + global = symbol.global, + placement = CompoundLabelPlacement(spritePlacement, spritePlacement), + value = symbol.sprite + ) + ) + } else if (!spriteCanPlace && textCanPlace && symbol.iconOptional && textPlacement != null && textViewportPlacement != null) { + collisionDetector.insert(textViewportPlacement) + acceptedSymbols.add( + Symbol.Text( + id = symbol.id, + global = symbol.global, + placement = CompoundLabelPlacement(textPlacement, textPlacement), + value = symbol.text + ) + ) + } + } + } + + is Symbol.Sprite -> { + val spriteViewportPlacement = createViewportLabelPlacement( + center = viewportPos, + originalPlacement = spritePlacement, + mapRotationDeg = mapRotationDeg + ) + + val textViewportPlacement = textPlacement?.let { textPlace -> + createViewportLabelPlacement( + center = viewportPos, + originalPlacement = textPlace, + mapRotationDeg = mapRotationDeg + ) + } + + val spriteCanPlace = !collisionDetector.wouldCollide(spriteViewportPlacement) + val textCanPlace = textViewportPlacement?.let { + !collisionDetector.wouldCollide(it) + } ?: true + + if (spriteCanPlace && textCanPlace) { + collisionDetector.insert(spriteViewportPlacement) + textViewportPlacement?.let { collisionDetector.insert(it) } + acceptedSymbols.add(symbol) + } + } + + is Symbol.Text -> { + // textPlacement is always non-null for Symbol.Text (set in producePointText/produceLineText) + val resolvedTextPlacement = textPlacement ?: return@forEach + val textViewportPlacement = createViewportLabelPlacement( + center = viewportPos, + originalPlacement = resolvedTextPlacement, + mapRotationDeg = mapRotationDeg + ) + + // Cross-tile deduplication for line labels: suppress if a same-text label was + // already placed within MIN_LINE_LABEL_REPEAT_DIST viewport pixels. Point labels + // (viewportAligned = true) rely on collision detection instead. + if (!symbol.viewportAligned) { + val text = resolvedTextPlacement.text + val prev = placedLineTextPositions[text] + if (prev != null && prev.any { placed -> + val dx = viewportPos.x - placed.x + val dy = viewportPos.y - placed.y + sqrt(dx * dx + dy * dy) < MIN_LINE_LABEL_REPEAT_DIST + }) { + return@forEach + } + } + + if (!collisionDetector.wouldCollide(textViewportPlacement)) { + collisionDetector.insert(textViewportPlacement) + acceptedSymbols.add(symbol) + if (!symbol.viewportAligned) { + placedLineTextPositions + .getOrPut(resolvedTextPlacement.text) { mutableListOf() } + .add(viewportPos) + } + } + } + } + } + + return acceptedSymbols + } +} + +/** + * Provides information about the current state of the viewport in a MapLibre-like map renderer. + * + * @property matrix The current tile transformation matrix, describing how map tiles are projected and positioned in the viewport. + * @property size The pixel size (width and height) of the viewport. + * @property angleRad The rotation angle of the viewport, in radians. + * @property pitch The pitch (tilt) of the viewport, in degrees (0 = looking straight down). + * @property zoom The current zoom level, providing continuous zoom information. + */ +data class ViewportInfo( + val matrix: TileMatrix, + val size: IntSize, + val angleRad: AngleRad, + val pitch: Float, + val zoom: Int, + + // Snapshot values + val centroidX: Double, + val centroidY: Double, + val scale: Double, + val fullWidth: Int, + val fullHeight: Int, + val infiniteScrollX: Boolean = false, + val visiblePhases: IntRange = 0..0, +) + +class LoadTileException(msg: String) : Exception(msg) \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorTileStreamProvider.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorTileStreamProvider.kt new file mode 100644 index 00000000..102f4375 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/core/VectorTileStreamProvider.kt @@ -0,0 +1,41 @@ +package ovh.plrapps.mapcompose.vector.core + +import kotlinx.io.RawSource + +/** + * Defines how vector tiles should be fetched. It must be supplied as part of the configuration of + * MapCompose. + * + * The [styleUrl] property is used to identify the style of the vector tiles. + * + * The [loadResources] method is used to load resources (e.g, stylesheets) required to render the vector + * tiles. + * + * The [getTileStream] method implementation may suspend, but it isn't required (e.g, it isn't + * required to switch context using withContext(Dispatcher.IO) { .. }) as MapCompose does that + * already. The [getTileStream] method is declared using the suspend modifier, as it is sometimes + * useful to provide an implementation which suspends. + * + * The [getTileStream] method is invoked with the following parameters: + * - [tileUrl]: the url of the tile to fetch. + * - [row]: the row index of the tile. + * - [col]: the column index of the tile. + * - [zoomLvl]: the zoom level of the tile. + * [row], [col] and [zoomLvl] are can be used to implement caching strategies, because the [tileUrl] may change + * when multiple servers are used. + * + * MapCompose leverages bitmap pooling to reduce the pressure on the garbage collector. However, + * there's no tile caching by default - this is an implementation detail of the supplied + * [VectorTileStreamProvider]. + * + * If [getTileStream] returns null, the tile won't be rendered. + * The library does not handle exceptions thrown from [getTileStream]. Such errors are treated as + * unrecoverable failures. + */ +interface VectorTileStreamProvider { + val styleUrl: String + + suspend fun loadResources(url: String): RawSource? + + suspend fun getTileStream(tileUrl: String, row: Int, col: Int, zoomLvl: Int): RawSource? +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/JsonConfig.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/JsonConfig.kt new file mode 100644 index 00000000..c67f640f --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/JsonConfig.kt @@ -0,0 +1,17 @@ +package ovh.plrapps.mapcompose.vector.data + +import kotlinx.serialization.json.Json +import kotlinx.serialization.modules.contextual +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ColorSerializer +import ovh.plrapps.mapcompose.vector.spec.style.symbol.TextAnchorSerializer + +val json = Json { + ignoreUnknownKeys = true + isLenient = true + encodeDefaults = true + coerceInputValues = true + serializersModule = kotlinx.serialization.modules.SerializersModule { + contextual(ColorSerializer) + contextual(TextAnchorSerializer) + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/LanguageCode.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/LanguageCode.kt new file mode 100644 index 00000000..e348cd5b --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/LanguageCode.kt @@ -0,0 +1,172 @@ +package ovh.plrapps.mapcompose.vector.data + +enum class LanguageCode(val code: String, val title: String) { + Afar(code = "aa", title = "Afar"), + Abkhazian(code = "ab", title = "Abkhazian"), + Avestan(code = "ae", title = "Avestan"), + Afrikaans(code = "af", title = "Afrikaans"), + Akan(code = "ak", title = "Akan"), + Amharic(code = "am", title = "Amharic"), + Aragonese(code = "an", title = "Aragonese"), + Arabic(code = "ar", title = "Arabic"), + Assamese(code = "as", title = "Assamese"), + Avaric(code = "av", title = "Avaric"), + Aymara(code = "ay", title = "Aymara"), + Azerbaijani(code = "az", title = "Azerbaijani"), + Bashkir(code = "ba", title = "Bashkir"), + Belarusian(code = "be", title = "Belarusian"), + Bulgarian(code = "bg", title = "Bulgarian"), + Bislama(code = "bi", title = "Bislama"), + Bambara(code = "bm", title = "Bambara"), + Bengali(code = "bn", title = "Bengali"), + Tibetan(code = "bo", title = "Tibetan"), + Breton(code = "br", title = "Breton"), + Bosnian(code = "bs", title = "Bosnian"), + Catalan(code = "ca", title = "Catalan"), + Valencian(code = "ca", title = "Valencian"), + Chechen(code = "ce", title = "Chechen"), + Chamorro(code = "ch", title = "Chamorro"), + Corsican(code = "co", title = "Corsican"), + Cree(code = "cr", title = "Cree"), + Czech(code = "cs", title = "Czech"), + Chuvash(code = "cv", title = "Chuvash"), + Welsh(code = "cy", title = "Welsh"), + Danish(code = "da", title = "Danish"), + German(code = "de", title = "German"), + Divehi(code = "dv", title = "Divehi"), + Dzongkha(code = "dz", title = "Dzongkha"), + Ewe(code = "ee", title = "Ewe"), + English(code = "en", title = "English"), + Esperanto(code = "eo", title = "Esperanto"), + Spanish(code = "es", title = "Spanish"), + Estonian(code = "et", title = "Estonian"), + Basque(code = "eu", title = "Basque"), + Persian(code = "fa", title = "Persian"), + Fulah(code = "ff", title = "Fulah"), + Finnish(code = "fi", title = "Finnish"), + Fijian(code = "fj", title = "Fijian"), + Faroese(code = "fo", title = "Faroese"), + French(code = "fr", title = "French"), + WesternFrisian(code = "fy", title = "Western Frisian"), + Irish(code = "ga", title = "Irish"), + ScottishGaelic(code = "gd", title = "Gaelic; Scottish Gaelic"), + Galician(code = "gl", title = "Galician"), + Guarani(code = "gn", title = "Guarani"), + Gujarati(code = "gu", title = "Gujarati"), + Manx(code = "gv", title = "Manx"), + Hausa(code = "ha", title = "Hausa"), + Hebrew(code = "he", title = "Hebrew"), + Hindi(code = "hi", title = "Hindi"), + HiriMotu(code = "ho", title = "Hiri Motu"), + Croatian(code = "hr", title = "Croatian"), + Haitian(code = "ht", title = "Haitian; Haitian Creole"), + Hungarian(code = "hu", title = "Hungarian"), + Armenian(code = "hy", title = "Armenian"), + Herero(code = "hz", title = "Herero"), + Interlingua(code = "ia", title = "Interlingua (International Auxiliary Language Association)"), + Indonesian(code = "id", title = "Indonesian"), + Interlingue(code = "ie", title = "Interlingue; Occidental"), + Igbo(code = "ig", title = "Igbo"), + SichuanYi(code = "ii", title = "Sichuan Yi; Nuosu"), + Inupiaq(code = "ik", title = "Inupiaq"), + Ido(code = "io", title = "Ido"), + Icelandic(code = "is", title = "Icelandic"), + Italian(code = "it", title = "Italian"), + Inuktitut(code = "iu", title = "Inuktitut"), + Japanese(code = "ja", title = "Japanese"), + Javanese(code = "jv", title = "Javanese"), + Georgian(code = "ka", title = "Georgian"), + Kongo(code = "kg", title = "Kongo"), + Kikuyu(code = "ki", title = "Kikuyu; Gikuyu"), + Kuanyama(code = "kj", title = "Kuanyama; Kwanyama"), + Kazakh(code = "kk", title = "Kazakh"), + Kalaallisut(code = "kl", title = "Kalaallisut; Greenlandic"), + CentralKhmer(code = "km", title = "Central Khmer"), + Kannada(code = "kn", title = "Kannada"), + Korean(code = "ko", title = "Korean"), + Kanuri(code = "kr", title = "Kanuri"), + Kashmiri(code = "ks", title = "Kashmiri"), + Kurdish(code = "ku", title = "Kurdish"), + Komi(code = "kv", title = "Komi"), + Cornish(code = "kw", title = "Cornish"), + Kirghiz(code = "ky", title = "Kirghiz; Kyrgyz"), + Latin(code = "la", title = "Latin"), + Luxembourgish(code = "lb", title = "Luxembourgish; Letzeburgesch"), + Ganda(code = "lg", title = "Ganda"), + Limburgan(code = "li", title = "Limburgan; Limburger; Limburgish"), + Lingala(code = "ln", title = "Lingala"), + Lao(code = "lo", title = "Lao"), + Lithuanian(code = "lt", title = "Lithuanian"), + LubaKatanga(code = "lu", title = "Luba-Katanga"), + Latvian(code = "lv", title = "Latvian"), + Malagasy(code = "mg", title = "Malagasy"), + Marshallese(code = "mh", title = "Marshallese"), + Maori(code = "mi", title = "Maori"), + Macedonian(code = "mk", title = "Macedonian"), + Malayalam(code = "ml", title = "Malayalam"), + Mongolian(code = "mn", title = "Mongolian"), + Marathi(code = "mr", title = "Marathi"), + Malay(code = "ms", title = "Malay"), + Maltese(code = "mt", title = "Maltese"), + Burmese(code = "my", title = "Burmese"), + Nauru(code = "na", title = "Nauru"), + Nepali(code = "ne", title = "Nepali"), + Ndonga(code = "ng", title = "Ndonga"), + Dutch(code = "nl", title = "Dutch; Flemish"), + Norwegian(code = "no", title = "Norwegian"), + Ojibwa(code = "oj", title = "Ojibwa"), + Oromo(code = "om", title = "Oromo"), + Oriya(code = "or", title = "Oriya"), + Pali(code = "pi", title = "Pali"), + Polish(code = "pl", title = "Polish"), + Portuguese(code = "pt", title = "Portuguese"), + Quechua(code = "qu", title = "Quechua"), + Romansh(code = "rm", title = "Romansh"), + Rundi(code = "rn", title = "Rundi"), + Romanian(code = "ro", title = "Romanian; Moldavian; Moldovan"), + Russian(code = "ru", title = "Russian"), + Kinyarwanda(code = "rw", title = "Kinyarwanda"), + Sanskrit(code = "sa", title = "Sanskrit"), + Sardinian(code = "sc", title = "Sardinian"), + Sindhi(code = "sd", title = "Sindhi"), + Sango(code = "sg", title = "Sango"), + Slovak(code = "sk", title = "Slovak"), + Slovenian(code = "sl", title = "Slovenian"), + Samoan(code = "sm", title = "Samoan"), + Shona(code = "sn", title = "Shona"), + Somali(code = "so", title = "Somali"), + Albanian(code = "sq", title = "Albanian"), + Serbian(code = "sr", title = "Serbian"), + Swati(code = "ss", title = "Swati"), + Sundanese(code = "su", title = "Sundanese"), + Swedish(code = "sv", title = "Swedish"), + Swahili(code = "sw", title = "Swahili"), + Tamil(code = "ta", title = "Tamil"), + Telugu(code = "te", title = "Telugu"), + Tajik(code = "tg", title = "Tajik"), + Thai(code = "th", title = "Thai"), + Tigrinya(code = "ti", title = "Tigrinya"), + Turkmen(code = "tk", title = "Turkmen"), + Tagalog(code = "tl", title = "Tagalog"), + Tswana(code = "tn", title = "Tswana"), + Turkish(code = "tr", title = "Turkish"), + Tsonga(code = "ts", title = "Tsonga"), + Tatar(code = "tt", title = "Tatar"), + Twi(code = "tw", title = "Twi"), + Tahitian(code = "ty", title = "Tahitian"), + Ukrainian(code = "uk", title = "Ukrainian"), + Urdu(code = "ur", title = "Urdu"), + Uzbek(code = "uz", title = "Uzbek"), + Venda(code = "ve", title = "Venda"), + Vietnamese(code = "vi", title = "Vietnamese"), + Volapük(code = "vo", title = "Volapük"), + Walloon(code = "wa", title = "Walloon"), + Wolof(code = "wo", title = "Wolof"), + Xhosa(code = "xh", title = "Xhosa"), + Yiddish(code = "yi", title = "Yiddish"), + Yoruba(code = "yo", title = "Yoruba"), + Zhuang(code = "za", title = "Zhuang"), + Chuang(code = "za", title = "Chuang"), + Chinese(code = "zh", title = "Chinese"), + Zulu(code = "zu", title = "Zulu"); +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/MapLibreConfiguration.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/MapLibreConfiguration.kt new file mode 100644 index 00000000..a5f7d448 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/MapLibreConfiguration.kt @@ -0,0 +1,11 @@ +package ovh.plrapps.mapcompose.vector.data + +import ovh.plrapps.mapcompose.vector.spec.style.MapLibreStyle + +data class MapLibreConfiguration( + val style: MapLibreStyle, + val tileSources: Map, + val spriteManager: SpriteManager?, + val collisionDetectionEnabled: Boolean = true, + val lang: LanguageCode? = LanguageCode.English +) diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/MapLibreTileSource.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/MapLibreTileSource.kt new file mode 100644 index 00000000..2f6d3b7f --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/MapLibreTileSource.kt @@ -0,0 +1,23 @@ +package ovh.plrapps.mapcompose.vector.data + +import ovh.plrapps.mapcompose.vector.spec.tilejson.TileJson + +class MapLibreTileSource(val tileJson: TileJson) { + + companion object { + const val SEGMENT_ZOOM = "{z}" + const val SEGMENT_X = "{x}" + const val SEGMENT_Y = "{y}" + } + + private val tileTemplates: List = tileJson.tiles + + fun getTileUrl(z: Int, x: Int, y: Int): String { + val template = tileTemplates.random() + + return template + .replace(SEGMENT_ZOOM, z.toString()) + .replace(SEGMENT_X, x.toString()) + .replace(SEGMENT_Y, y.toString()) + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.kt new file mode 100644 index 00000000..0b410602 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.kt @@ -0,0 +1,239 @@ +package ovh.plrapps.mapcompose.vector.data + +import androidx.compose.ui.geometry.Rect +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.CanvasDrawScope +import androidx.compose.ui.unit.Density +import androidx.compose.ui.unit.IntOffset +import androidx.compose.ui.unit.IntSize +import androidx.compose.ui.unit.LayoutDirection +import kotlinx.coroutines.withContext +import kotlinx.io.RawSource +import kotlinx.io.buffered +import kotlinx.io.readByteArray +import kotlinx.io.readString +import org.jetbrains.compose.resources.ExperimentalResourceApi +import ovh.plrapps.mapcompose.utils.IODispatcher +import ovh.plrapps.mapcompose.vector.spec.sprites.Sprite +import ovh.plrapps.mapcompose.vector.utils.LruCache +import kotlin.math.max +import kotlin.math.roundToInt + +internal expect fun imageBitmapFromArgb( + argb: IntArray, + width: Int, + height: Int +): ImageBitmap + +internal expect fun byteArrayToImageBitmap(bytes: ByteArray): ImageBitmap + +class SpriteManager( + private val spriteIndex: Map, + private val spriteImage: ImageBitmap +) { + fun getSpriteInfo(spriteId: String): Sprite? { + val spriteInfo = spriteIndex[spriteId] ?: run { + return null + } + return spriteInfo + } + + /** + * Gets a sprite by its id + * @param spriteId Sprite id from JSON file + * @return Pair of sprite object with metadata and sprite cutout image + */ + private val spriteCache = LruCache(maxSize = 100) + + fun getSprite(spriteId: String, tintColor: Color? = null, sdf: SDF? = null): Pair? { + val spriteInfo = spriteIndex[spriteId] ?: return null + + val cacheKey = "$spriteId-${tintColor?.toArgb() ?: "none"}-${sdf?.hashCode() ?: "none"}" + spriteCache.get(cacheKey)?.let { + return spriteInfo to it + } + + var sprite = cropImageBitmap( + source = spriteImage, + x = spriteInfo.x, + y = spriteInfo.y, + width = spriteInfo.width, + height = spriteInfo.height, + tintColor = if (!spriteInfo.sdf && tintColor != null) tintColor else null + ) + + if (spriteInfo.sdf) { + sprite = renderSdf( + src = resizeImageBitmapWithAspectRatio( + src = sprite, + targetMaxSize = 128 // scale sdf for improve result + ), + sdf = sdf ?: error("sdf not provided") + ) + } + + spriteCache.put(cacheKey, sprite) + return spriteInfo to sprite + } + + fun getAvailableSprites(): List = spriteIndex.keys.toList() + + companion object { + var softness = 0.005f + + fun intArrayToImageByteArray(ints: IntArray): ByteArray { + val bytes = ByteArray(ints.size * 4) + for (i in ints.indices) { + val v = ints[i] + val j = i * 4 + bytes[j] = (v shr 0 and 0xFF).toByte() // B + bytes[j + 1] = (v shr 8 and 0xFF).toByte() // G + bytes[j + 2] = (v shr 16 and 0xFF).toByte() // R + bytes[j + 3] = (v shr 24 and 0xFF).toByte() // A + } + return bytes + } + + fun smoothstep(edge0: Float, edge1: Float, x: Float): Float { + val t = ((x - edge0) / (edge1 - edge0)).coerceIn(0f, 1f) + return t * t * (3 - 2 * t) + } + + fun resizeImageBitmapWithAspectRatio( + src: ImageBitmap, + targetMaxSize: Int, + filterQuality: FilterQuality = FilterQuality.High + ): ImageBitmap { + val srcWidth = src.width + val srcHeight = src.height + + val scale = targetMaxSize.toFloat() / max(srcWidth, srcHeight) + val dstWidth = (srcWidth * scale).roundToInt() + val dstHeight = (srcHeight * scale).roundToInt() + + val resizedBitmap = ImageBitmap(dstWidth, dstHeight) + + CanvasDrawScope().draw( + density = Density(1f), + layoutDirection = LayoutDirection.Ltr, + canvas = Canvas(resizedBitmap), + size = Size(dstWidth.toFloat(), dstHeight.toFloat()) + ) { + drawImage( + image = src, + dstSize = IntSize(dstWidth, dstHeight), + filterQuality = filterQuality + ) + } + return resizedBitmap + } + + fun renderSdf(src: ImageBitmap, sdf: SDF): ImageBitmap { + val width = src.width + val height = src.height + val strokeColor = sdf.haloColor + val strokeWidth = sdf.haloWidth + val fillColor = sdf.fillColor + + val srcPixels = src.toPixelMap() + + val fillEdge = sdf.threshold + val strokeEdge = fillEdge + strokeWidth + val outPixels = IntArray(width * height) + + for (y in 0 until height) { + for (x in 0 until width) { + val idx = y * width + x + val sdfVal = srcPixels[x, y].alpha + + val fillAlpha = smoothstep(fillEdge - softness, fillEdge + softness, sdfVal) + val strokeAlpha = smoothstep(strokeEdge - softness, strokeEdge + softness, sdfVal) + + val strokeOnly = (fillAlpha - strokeAlpha).coerceIn(0f, 1f) + val fillOnly = fillAlpha.coerceIn(0f, 1f) + + val r = fillColor.red * fillOnly + strokeColor.red * strokeOnly + val g = fillColor.green * fillOnly + strokeColor.green * strokeOnly + val b = fillColor.blue * fillOnly + strokeColor.blue * strokeOnly + val a = (fillOnly + strokeOnly).coerceIn(0f, 1f) + + outPixels[idx] = Color(r, g, b, a).toArgb() + } + } + + return imageBitmapFromArgb(outPixels, width, height) + } + + fun cropImageBitmap( + source: ImageBitmap, + x: Int, + y: Int, + width: Int, + height: Int, + tintColor: Color? = null, + ): ImageBitmap { + val result = ImageBitmap(width, height) + val canvas = Canvas(result) + canvas.drawImageRect( + image = source, + srcOffset = IntOffset(x, y), + srcSize = IntSize(width, height), + dstOffset = IntOffset(0, 0), + dstSize = IntSize(width, height), + paint = Paint().apply { + isAntiAlias = false + } + ) + + if (tintColor != null) { + canvas.drawRect( + Rect(0f, 0f, width.toFloat(), height.toFloat()), + Paint().apply { + color = tintColor + blendMode = BlendMode.SrcIn + } + ) + } + return result + } + + /** + * Loads sprites from the specified URL + * @param spriteUrl Sprite URL (without extension) + * @param pixelRatio Pixel density (1 or 2 for @2x) + * @return Result of loading sprites + */ + @OptIn(ExperimentalResourceApi::class) + suspend fun load(spriteUrl: String, pixelRatio: Int = 1, loadResource: suspend (String) -> RawSource?): Result { + val suffix = if (pixelRatio > 1) "@2x" else "" + val jsonUrl = "$spriteUrl$suffix.json" + val imageUrl = "$spriteUrl$suffix.png" + + return try { + val spriteJson = withContext(IODispatcher) { + loadResource(jsonUrl)?.buffered()?.readString() ?: throw Exception("Sprite JSON not found") + } + val spriteIndex = json.decodeFromString>(spriteJson) + + val spriteImageBytes = withContext(IODispatcher) { + loadResource(imageUrl)?.buffered()?.readByteArray() ?: throw Exception("Sprite image not found") + } + val spriteImage = byteArrayToImageBitmap(spriteImageBytes) + + Result.success(SpriteManager(spriteIndex, spriteImage)) + } catch (e: Exception) { + println("Failed to load sprite: ${e.message}") + Result.failure(e) + } + + } + } +} + +data class SDF( + val haloColor: Color = Color.Unspecified, + val haloWidth: Float = 0.02f, + val threshold: Float = 0.729f, + val fillColor: Color +) \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/TileCache.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/TileCache.kt new file mode 100644 index 00000000..d7491416 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/TileCache.kt @@ -0,0 +1,7 @@ +package ovh.plrapps.mapcompose.vector.data + +interface TileCache { + suspend fun get(sourceName: String, key: String): ByteArray? + suspend fun put(sourceName: String, key: String, data: ByteArray) + suspend fun clear() +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.kt new file mode 100644 index 00000000..46cf7a07 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.kt @@ -0,0 +1,5 @@ +package ovh.plrapps.mapcompose.vector.data.extension + +import androidx.compose.ui.graphics.ImageBitmap + +expect fun ImageBitmap.toBytes(): ByteArray? \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ViewportInfo.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ViewportInfo.kt new file mode 100644 index 00000000..e9f26143 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ViewportInfo.kt @@ -0,0 +1,13 @@ +package ovh.plrapps.mapcompose.vector.data.extension + +import ovh.plrapps.mapcompose.vector.core.ViewportInfo +import ovh.plrapps.mapcompose.vector.renderer.utils.MVTViewport + +fun ViewportInfo.toMVTViewport() = MVTViewport( + width = (this.size.width).toFloat(), + height = (this.size.height).toFloat(), + bearing = this.angleRad, + pitch = this.pitch, + zoom = this.zoom.toFloat(), + tileMatrix = this.matrix +) \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/getMapLibreConfiguration.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/getMapLibreConfiguration.kt new file mode 100644 index 00000000..99748a83 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/data/getMapLibreConfiguration.kt @@ -0,0 +1,65 @@ +package ovh.plrapps.mapcompose.vector.data + +import kotlinx.coroutines.withContext +import kotlinx.io.RawSource +import kotlinx.io.buffered +import kotlinx.io.readString +import ovh.plrapps.mapcompose.utils.IODispatcher +import ovh.plrapps.mapcompose.vector.spec.style.MapLibreStyle +import ovh.plrapps.mapcompose.vector.spec.style.sprites +import ovh.plrapps.mapcompose.vector.spec.tilejson.TileJson + +suspend fun getMapLibreConfiguration( + style: String, + pixelRatio: Int = 1, + loadResource: suspend (String) -> RawSource? +): Result { + try { + val style = json.decodeFromString(MapLibreStyle.serializer(), style) + val tileSources = mutableMapOf() + + style.sources?.toList()?.forEach { (name, source) -> + val sourceUrl = source.url + val tiles = source.tiles + if (sourceUrl !== null) { + val tileJson = getTileJson(sourceUrl, loadResource).getOrElse { e -> return Result.failure(e) } + tileSources[name] = MapLibreTileSource(tileJson) + } else if(tiles != null) { + tileSources[name] = MapLibreTileSource( + TileJson( + tilejson = "2.0.0", + tiles = tiles, + maxzoom = source.maxzoom ?: 22, + minzoom = source.minzoom ?: 0, + ) + ) + } + } + + val spriteManager = style.sprites.firstOrNull()?.url?.let { sprite -> + SpriteManager.load(spriteUrl = sprite, pixelRatio = pixelRatio, loadResource = loadResource).getOrElse { e -> return Result.failure(e) } + } + + return Result.success(MapLibreConfiguration( + style = style, + tileSources = tileSources, + spriteManager = spriteManager + )) + + } catch (e: Exception) { + return Result.failure(e) + } +} + +suspend fun getTileJson(tileJsonUrl: String, loadResource: suspend (String) -> RawSource?): Result { + return try { + val rawTileJson = withContext(IODispatcher) { + loadResource(tileJsonUrl)?.buffered()?.readString() ?: throw Exception("TileJson not found") + } + val tileJson = json.decodeFromString(TileJson.serializer(), rawTileJson) + + Result.success(tileJson) + } catch (e: Exception) { + Result.failure(e) + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BackgroundLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BackgroundLayerPainter.kt new file mode 100644 index 00000000..a56308db --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BackgroundLayerPainter.kt @@ -0,0 +1,32 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.drawscope.DrawScope +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.BackgroundLayer +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsFloat +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsColor + +class BackgroundLayerPainter : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: BackgroundLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + val paint = style.paint ?: return + + val backgroundColor = paint.backgroundColor?.processAsColor(featureProperties, zoom) ?: Color.White + val opacity = paint.backgroundOpacity.processAsFloat(featureProperties, zoom) ?: 1f + + canvas.drawRect( + color = backgroundColor.copy(alpha = opacity), + size = canvas.size + ) + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BaseLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BaseLayerPainter.kt new file mode 100644 index 00000000..f23a68d8 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BaseLayerPainter.kt @@ -0,0 +1,42 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.drawscope.DrawScope +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.Layer + +abstract class BaseLayerPainter { + protected val geometryDecoders = GeometryDecoders() + + abstract suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: T, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? = null + ) + + protected fun createPath( + feature: Tile.Feature, + canvasSize: Int, + extent: Int + ): Path? { + return when (feature.type) { + Tile.GeomType.POLYGON -> { + val rings = geometryDecoders.decodePolygon(feature.geometry, canvasSize = canvasSize, extent = extent) + if (rings.isNotEmpty()) { + geometryDecoders.createPolygonPath(rings) + } else null + } + Tile.GeomType.LINESTRING -> geometryDecoders.createLineStringPath( + geometryDecoders.decodeLine(feature.geometry, canvasSize = canvasSize, extent = extent).flatten() + ) + Tile.GeomType.POINT -> null // TODO: Implement point rendering + else -> null + } + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BaseRenderer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BaseRenderer.kt new file mode 100644 index 00000000..4c6d3e21 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/BaseRenderer.kt @@ -0,0 +1,64 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.Layer +import kotlinx.coroutines.sync.withLock + +abstract class BaseRenderer( + private val configuration: MapLibreConfiguration, +) { + + fun shouldRenderFeature( + feature: Tile.Feature, + tileLayer: Tile.Layer, + styleLayer: Layer, + zoom: Double, + featureProperties: Map? = null + ): Boolean { + val filter = styleLayer.filter + if (filter == null) { + return true + } + val properties = featureProperties ?: extractFeatureProperties(feature, tileLayer) + return filter.process( + properties, + zoom = zoom.toInt().toDouble() + ) + } + + private val MAX_ZOOM = 30.0 + + fun isZoomInRange(styleLayer: Layer, zoom: Double): Boolean { + val minZoom = styleLayer.minzoom ?: 0.0 + val maxZoom = styleLayer.maxzoom ?: MAX_ZOOM + return zoom in minZoom.. { + val props = mutableMapOf() + val keys = tileLayer.keys + val values = tileLayer.values + for (i in feature.tags.indices step 2) { + val keyIdx = feature.tags[i] + val valueIdx = feature.tags[i + 1] + if (keyIdx < keys.size && valueIdx < values.size) { + val key = keys[keyIdx] + val value = values[valueIdx] + props[key] = + value.stringValue ?: value.floatValue ?: value.doubleValue ?: value.intValue ?: value.uintValue + ?: value.sintValue ?: value.boolValue + } + } + + props["\$type"] = when (feature.type) { + Tile.GeomType.LINESTRING -> "LineString" + Tile.GeomType.POINT -> "Point" + Tile.GeomType.POLYGON -> "Polygon" + Tile.GeomType.UNKNOWN -> "Unknown" + is Tile.GeomType.UNRECOGNIZED -> "Unrecognized" + null -> "" + } + return props + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/CircleLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/CircleLayerPainter.kt new file mode 100644 index 00000000..40614c11 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/CircleLayerPainter.kt @@ -0,0 +1,50 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Stroke +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.CircleLayer +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsFloat +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsColor + +class CircleLayerPainter : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: CircleLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + if (feature.type != Tile.GeomType.POINT) return + + val paint = style.paint ?: return + val path = createPath(feature, canvasSize, extent) ?: return + + val circleColor = paint.circleColor?.processAsColor(featureProperties, zoom) ?: Color.Black + val circleOpacity = paint.circleOpacity.processAsFloat(featureProperties, zoom) ?: 1f + val circleRadius = paint.circleRadius.processAsFloat(featureProperties, zoom) ?: 5f + val circleStrokeWidth = paint.circleStrokeWidth.processAsFloat(featureProperties, zoom) ?: 0f + val circleStrokeColor = paint.circleStrokeColor?.processAsColor(featureProperties, zoom) ?: Color.Black + + canvas.drawPath( + path = path, + color = circleColor.copy(alpha = circleOpacity) + ) + + if (circleStrokeWidth > 0f) { + canvas.drawPath( + path = path, + color = circleStrokeColor.copy(alpha = circleOpacity), + style = Stroke( + width = circleStrokeWidth, + pathEffect = null + ) + ) + } + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/FillExtrusionPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/FillExtrusionPainter.kt new file mode 100644 index 00000000..8d944dd7 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/FillExtrusionPainter.kt @@ -0,0 +1,25 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.drawscope.DrawScope +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.FillExtrusionLayer + +class FillExtrusionPainter : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: FillExtrusionLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + // TODO: Implement 3D extrusion rendering + // 1. Get height from properties + // 2. Create 3D geometry + // 3. Apply materials and lighting + // 4. Draw with perspective + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/FillLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/FillLayerPainter.kt new file mode 100644 index 00000000..0449c15e --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/FillLayerPainter.kt @@ -0,0 +1,101 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.Path +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Stroke +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.FillLayer +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsFloat +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsColor +import ovh.plrapps.mapcompose.vector.utils.LruCache +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock + +class FillLayerPainter( + private val pathCache: LruCache? = null, + private val mutex: Mutex? = null +) : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: FillLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + if (feature.type != Tile.GeomType.POLYGON) return + + val paint = style.paint ?: return + + val path: Path? = if (featureKey != null && pathCache != null && mutex != null) { + mutex.withLock { + pathCache.get(featureKey) as? Path + } ?: createPath(feature, canvasSize, extent)?.also { + mutex.withLock { + pathCache.put(featureKey, it) + } + } + } else { + createPath(feature, canvasSize, extent) + } + + if (path == null) return + + // FIXME: It's broken previous layers + if (paint.fillPattern != null) { + return + } + val fillColor = paint.fillColor?.processAsColor(featureProperties, actualZoom) ?: Color.Transparent + val fillOpacity = paint.fillOpacity.processAsFloat(featureProperties, actualZoom) ?: 1f + val fillOutlineColor = paint.fillOutlineColor?.processAsColor(featureProperties, actualZoom) ?: Color.Transparent + + canvas.drawPath( + path = path, + color = fillColor.copy(alpha = fillOpacity) + ) + + if (paint.fillOutlineColor != null) { + canvas.drawPath( + path = path, + color = fillOutlineColor, + style = Stroke( + width = canvas.density, + pathEffect = null + ) + ) + } + } + + private fun applyTranslation(path: Path, translate: JsonElement?): Path { + if (translate == null) return path + + val offset = when (translate) { + is JsonPrimitive -> { + val value = translate.content.toFloatOrNull() ?: 0f + Offset(value, value) + } + + is JsonObject -> { + val x = translate["x"]?.toString()?.toFloatOrNull() ?: 0f + val y = translate["y"]?.toString()?.toFloatOrNull() ?: 0f + Offset(x, y) + } + + else -> Offset.Zero + } + + if (offset == Offset.Zero) return path + + val translatedPath = Path() + translatedPath.addPath(path, offset) + return translatedPath + } +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/GeometryDecoders.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/GeometryDecoders.kt new file mode 100644 index 00000000..f43c3278 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/GeometryDecoders.kt @@ -0,0 +1,214 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.Path + +data class Point(val x: Double, val y: Double) + +class GeometryDecoders { + companion object { + internal fun decodeZigZag(n: Int): Int = (n ushr 1) xor (-(n and 1)) + internal fun tileCoordToCanvas( + x: Int, + y: Int, + canvasSize: Int, + extent: Int + ): Pair { + val scale = canvasSize.toFloat() / extent + val result = Pair(x * scale, y * scale) + return result + } + } + + fun decodePolygon( + geometry: List, + extent: Int, + canvasSize: Int + ): List>> { + val rings = mutableListOf>>() + var x = 0 + var y = 0 + var i = 0 + var currentRing: MutableList>? = null + val scale = canvasSize.toFloat() / extent + while (i < geometry.size) { + val cmdInteger = geometry[i++] + val command = cmdInteger and 0x7 + val count = cmdInteger shr 3 + when (command) { + 1 -> { // MoveTo + if (count < 1) continue + currentRing = mutableListOf() + for (j in 0 until count) { + if (i + 1 >= geometry.size) break + x += decodeZigZag(geometry[i++]) + y += decodeZigZag(geometry[i++]) + currentRing.add(Pair(x * scale, y * scale)) + } + } + 2 -> { // LineTo + if (currentRing == null) break + for (j in 0 until count) { + if (i + 1 >= geometry.size) break + x += decodeZigZag(geometry[i++]) + y += decodeZigZag(geometry[i++]) + currentRing.add(Pair(x * scale, y * scale)) + } + } + 7 -> { // ClosePath + if (currentRing != null && currentRing.isNotEmpty()) { + currentRing.add(currentRing[0]) + rings.add(currentRing) + currentRing = null + } + } + else -> break + } + } + return rings + } + + fun decodeLine( + geometry: List, + extent: Int, + canvasSize: Int + ): List>> { + val lines = mutableListOf>>() + var x = 0 + var y = 0 + var i = 0 + var currentLine: MutableList>? = null + val scale = canvasSize.toFloat() / extent + while (i < geometry.size) { + val cmdInteger = geometry[i++] + val command = cmdInteger and 0x7 + val count = cmdInteger shr 3 + when (command) { + 1 -> { // MoveTo + if (count < 1) continue + if (currentLine != null && currentLine.isNotEmpty()) { + lines.add(currentLine) + } + currentLine = mutableListOf() + for (j in 0 until count) { + if (i + 1 >= geometry.size) break + x += decodeZigZag(geometry[i++]) + y += decodeZigZag(geometry[i++]) + currentLine.add(Pair(x * scale, y * scale)) + } + } + 2 -> { // LineTo + if (currentLine == null) break + for (j in 0 until count) { + if (i + 1 >= geometry.size) break + x += decodeZigZag(geometry[i++]) + y += decodeZigZag(geometry[i++]) + currentLine.add(Pair(x * scale, y * scale)) + } + } + 7 -> { // ClosePath + // For lines ClosePath is ignored + } + else -> break + } + } + if (currentLine != null && currentLine.isNotEmpty()) { + lines.add(currentLine) + } + return lines + } + + fun createLineStringPath(points: List>): Path { + val path = Path() + if (points.isEmpty()) return path + + var isFirst = true + for (point in points) { + if (isFirst) { + path.moveTo(point.first, point.second) + isFirst = false + } else { + path.lineTo(point.first, point.second) + } + } + return path + } + + fun createPolygonPath(rings: List>>): Path { + val path = Path() + for (ring in rings) { + if (ring.isEmpty()) continue + + var isFirst = true + for (point in ring) { + if (isFirst) { + path.moveTo(point.first, point.second) + isFirst = false + } else { + path.lineTo(point.first, point.second) + } + } + path.close() + } + return path + } + + fun calculateCentroid(points: List): Point { + var sumX = 0.0 + var sumY = 0.0 + for (point in points) { + sumX += point.x + sumY += point.y + } + return Point(sumX / points.size, sumY / points.size) + } + + fun calculateCentroid(path: Path): Point { + val bounds = path.getBounds() + return Point((bounds.left + bounds.width / 2).toDouble(), (bounds.top + bounds.height / 2f).toDouble()) + } + + fun decodePoint( + geometry: List, + extent: Int = 4096, + canvasSize: Int = 256 + ): List { + val points = mutableListOf() + var x = 0 + var y = 0 + var i = 0 + while (i < geometry.size) { + if (i >= geometry.size) break + val cmdInteger = geometry[i++] + val command = cmdInteger and 0x7 + val count = cmdInteger shr 3 + when (command) { + 1 -> { // MoveTo + for (j in 0 until count) { + if (i + 1 >= geometry.size) break + val dx = geometry[i++] + val dy = geometry[i++] + x += decodeZigZag(dx) + y += decodeZigZag(dy) + val point = tileCoordToCanvas(x = x, y = y, canvasSize = canvasSize, extent = extent) + points.add(Point(point.first.toDouble(), point.second.toDouble())) + } + } + else -> break + } + } + return points + } + + /** + * Returns a list of polygons (each a list of rings). + * For Polygon, a list of one element. + * For MultiPolygon, a list of all polygons. + */ + fun decodePolygons( + geometry: List, + extent: Int, + canvasSize: Int + ): List>>> { + return listOf(decodePolygon(geometry, extent, canvasSize)) + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/HeatmapLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/HeatmapLayerPainter.kt new file mode 100644 index 00000000..d6c74ac1 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/HeatmapLayerPainter.kt @@ -0,0 +1,25 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.drawscope.DrawScope +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.HeatmapLayer + +class HeatmapLayerPainter : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: HeatmapLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + // TODO: Implement heatmap rendering + // 1. Collect all points with weights + // 2. Apply Gaussian blur + // 3. Normalize values + // 4. Apply color scheme + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/HillshadeLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/HillshadeLayerPainter.kt new file mode 100644 index 00000000..2ee1c3e7 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/HillshadeLayerPainter.kt @@ -0,0 +1,25 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.drawscope.DrawScope +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.HillshadeLayer + +class HillshadeLayerPainter : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: HillshadeLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + // TODO: Implement terrain rendering + // 1. Get height data + // 2. Calculate normals for each point + // 3. Apply lighting + // 4. Draw with shadow + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/LineLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/LineLayerPainter.kt new file mode 100644 index 00000000..d507687c --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/LineLayerPainter.kt @@ -0,0 +1,341 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.* +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.Stroke +import androidx.compose.ui.graphics.drawscope.translate +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.LineLayer +import ovh.plrapps.mapcompose.vector.spec.style.line.LineLayout +import ovh.plrapps.mapcompose.vector.spec.style.line.LinePaint +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsDouble +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsDoubleList +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsFloat +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsColor +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsString +import ovh.plrapps.mapcompose.vector.utils.LruCache +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import kotlin.math.sqrt + +class LineLayerPainter( + private val pathCache: LruCache? = null, + private val mutex: Mutex? = null +) : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: LineLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + if (feature.type != Tile.GeomType.LINESTRING && feature.type != Tile.GeomType.POLYGON) return + + val paint = style.paint ?: LinePaint() + val layout = style.layout + + val path: Path? = if (featureKey != null && pathCache != null && mutex != null) { + mutex.withLock { + pathCache.get(featureKey) as? Path + } ?: createPath(feature, canvasSize, extent)?.also { + mutex.withLock { + pathCache.put(featureKey, it) + } + } + } else { + createPath(feature, canvasSize, extent) + } + + if (path == null) return + + val lineColor = + paint.lineColor?.processAsColor(featureProperties = featureProperties, zoom = actualZoom) ?: Color.Black + val lineOpacity = paint.lineOpacity.processAsFloat(featureProperties, actualZoom) ?: 1f + val lineWidth = paint.lineWidth.processAsFloat(featureProperties, actualZoom)?.let { it * canvas.density } ?: 1f + val lineGapWidth = paint.lineGapWidth.processAsFloat(featureProperties, actualZoom) ?: 0f + val lineBlur = paint.lineBlur.processAsFloat(featureProperties, actualZoom) ?: 0f + val lineOffset = paint.lineOffset.processAsFloat(featureProperties, actualZoom) ?: 0f + val lineTranslate = + paint.lineTranslate.processAsDoubleList(featureProperties, actualZoom)?.map { it.toFloat() } ?: listOf(0f, 0f) + val lineTranslateAnchor = paint.lineTranslateAnchor?.processAsString(featureProperties, actualZoom) ?: "map" + val lineCap = getLineCap(layout, actualZoom, featureProperties) + val lineJoin = getLineJoin(layout, actualZoom, featureProperties) + val lineMiterLimit = layout?.lineMiterLimit.processAsFloat(featureProperties, actualZoom) ?: 2f + val lineRoundLimit = layout?.lineRoundLimit.processAsDouble(featureProperties, actualZoom) ?: 1.0 + val dashArray = getLineDashArray(paint, actualZoom, featureProperties) + + // TODO rewrite + val lineWidthPx = lineWidth + val lineGapWidthPx = lineGapWidth + val lineBlurPx = lineBlur + val lineOffsetPx = lineOffset + val dashArrayPx = dashArray?.map { it.toFloat() * canvas.density }?.toFloatArray() + + if (feature.type == Tile.GeomType.POLYGON) { + val polygons = geometryDecoders.decodePolygons(feature.geometry, canvasSize = canvasSize, extent = extent) + // println("[LineLayerPainter] POLYGON/MULTIPOLYGON: polygons.size = ${polygons.size}") + for ((polyIdx, rings) in polygons.withIndex()) { + for ((ringIdx, ring) in rings.withIndex()) { + if (ring.isNotEmpty()) { + // println("[LineLayerPainter] Polygon #$polyIdx, ring #$ringIdx: size = ${ring.size}") + val path = createPathFromPoints(ring, lineOffsetPx) + if (lineGapWidthPx > 0) { + // First, draw a gap (a wide line in the base color) + drawPathWithBlur( + canvas = canvas, + path = path, + color = Color.Black, // TODO + opacity = 1f, + width = lineWidthPx + lineGapWidthPx * 2, + blur = lineBlurPx, + translate = lineTranslate, + translateAnchor = lineTranslateAnchor, + cap = lineCap, + join = lineJoin, + miterLimit = lineMiterLimit, + roundLimit = lineRoundLimit, + dashArray = dashArrayPx + ) + + drawPathWithBlur( + canvas = canvas, + path = path, + color = lineColor, + opacity = lineOpacity, + width = lineWidthPx, + blur = lineBlurPx, + translate = lineTranslate, + translateAnchor = lineTranslateAnchor, + cap = lineCap, + join = lineJoin, + miterLimit = lineMiterLimit, + roundLimit = lineRoundLimit, + dashArray = dashArrayPx + ) + } else { + drawPathWithBlur( + canvas = canvas, + path = path, + color = lineColor, + opacity = lineOpacity, + width = lineWidthPx, + blur = lineBlurPx, + translate = lineTranslate, + translateAnchor = lineTranslateAnchor, + cap = lineCap, + join = lineJoin, + miterLimit = lineMiterLimit, + roundLimit = lineRoundLimit, + dashArray = dashArrayPx + ) + } + } + } + } + } else { + val path = createPath(feature, canvasSize, extent, lineOffsetPx) ?: return + drawPathWithBlur( + canvas = canvas, + path = path, + color = lineColor, + opacity = lineOpacity, + width = lineWidthPx, + blur = lineBlurPx, + translate = lineTranslate, + translateAnchor = lineTranslateAnchor, + cap = lineCap, + join = lineJoin, + miterLimit = lineMiterLimit, + roundLimit = lineRoundLimit, + dashArray = dashArrayPx + ) + } + + if (style.id == "geolines") { + println("DEBUG!") + } + } + + private fun drawPathWithBlur( + canvas: DrawScope, + path: Path, + color: Color, + opacity: Float, + width: Float, + blur: Float, + translate: List, + translateAnchor: String, + cap: StrokeCap, + join: StrokeJoin, + miterLimit: Float, + roundLimit: Double, + dashArray: FloatArray? + ) { + val (dx, dy) = when (translateAnchor) { + "viewport" -> translate + else -> translate // "map" + } + + canvas.translate(dx, dy) { + if (blur > 0) { + val blurSteps = 5 + val blurStep = blur / blurSteps + val opacityStep = opacity / blurSteps + + for (i in 0 until blurSteps) { + val currentBlur = blurStep * (i + 1) + val currentOpacity = opacityStep * (i + 1) + val currentWidth = width + currentBlur * 2 + + canvas.drawPath( + path = path, + color = color.copy(alpha = currentOpacity), + style = Stroke( + width = currentWidth, + cap = cap, + join = if (join == StrokeJoin.Round && width <= roundLimit) StrokeJoin.Round else StrokeJoin.Miter, + miter = miterLimit, + pathEffect = dashArray?.let { createDashPathEffect(it) } + ) + ) + } + } else { + canvas.drawPath( + path = path, + color = color.copy(alpha = opacity), + style = Stroke( + width = width, + cap = cap, + join = if (join == StrokeJoin.Round && width <= roundLimit) StrokeJoin.Round else StrokeJoin.Miter, + miter = miterLimit, + pathEffect = dashArray?.let { createDashPathEffect(it) } + ) + ) + } + } + } + + private fun createPathFromPoints(points: List>, offset: Float): Path { + if (offset == 0f) { + val path = Path() + var isFirst = true + for (point in points) { + if (isFirst) { + path.moveTo(point.first, point.second) + isFirst = false + } else { + path.lineTo(point.first, point.second) + } + } + return path + } + + val path = Path() + var isFirst = true + var prevPoint: Pair? = null + var prevNormal: Pair? = null + + for (i in points.indices) { + val currentPoint = points[i] + val nextPoint = if (i < points.size - 1) points[i + 1] else null + + if (isFirst) { + path.moveTo(currentPoint.first, currentPoint.second) + isFirst = false + } else { + // Calculate the normal for the current segment + val normal = if (nextPoint != null) { + val dx = nextPoint.first - currentPoint.first + val dy = nextPoint.second - currentPoint.second + val length = sqrt(dx * dx + dy * dy) + if (length > 0) { + Pair(-dy / length, dx / length) + } else { + Pair(0f, 0f) + } + } else { + prevNormal ?: Pair(0f, 0f) + } + + val offsetPoint = Pair( + currentPoint.first + normal.first * offset, + currentPoint.second + normal.second * offset + ) + + path.lineTo(offsetPoint.first, offsetPoint.second) + prevNormal = normal + } + prevPoint = currentPoint + } + + return path + } + + private fun createPath(feature: Tile.Feature, canvasSize: Int, extent: Int, offset: Float): Path? { + return when (feature.type) { + Tile.GeomType.LINESTRING -> { + val lines = geometryDecoders.decodeLine(feature.geometry, canvasSize = canvasSize, extent = extent) + if (lines.isNotEmpty()) { + val path = Path() + for (line in lines) { + if (line.isNotEmpty()) { + var isFirst = true + for (point in line) { + if (isFirst) { + path.moveTo(point.first, point.second) + isFirst = false + } else { + path.lineTo(point.first, point.second) + } + } + } + } + path + } else null + } + + else -> super.createPath(feature, canvasSize, extent) + } + } + + private fun createDashPathEffect(dashArray: FloatArray): PathEffect { + return PathEffect.dashPathEffect( + intervals = dashArray, + phase = 0f + ) + } + + private fun getLineCap(layout: LineLayout?, actualZoom: Double, featureProperties: Map?): StrokeCap { + return when (layout?.lineCap?.processAsString(featureProperties = featureProperties, zoom = actualZoom) ?: "butt") { + "butt" -> StrokeCap.Butt + "round" -> StrokeCap.Round + "square" -> StrokeCap.Square + else -> StrokeCap.Butt + } + } + + private fun getLineJoin( + layout: LineLayout?, + actualZoom: Double, + featureProperties: Map? + ): StrokeJoin { + return when (layout?.lineJoin?.processAsString(featureProperties = featureProperties, zoom = actualZoom) ?: "miter") { + "bevel" -> StrokeJoin.Bevel + "round" -> StrokeJoin.Round + "miter" -> StrokeJoin.Miter + else -> StrokeJoin.Miter + } + } + + private fun getLineDashArray( + paint: LinePaint, + actualZoom: Double, + featureProperties: Map? + ): DoubleArray? { + return paint.lineDasharray.processAsDoubleList(featureProperties = featureProperties, zoom = actualZoom)?.toDoubleArray() + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/RasterLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/RasterLayerPainter.kt new file mode 100644 index 00000000..b5bb39f1 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/RasterLayerPainter.kt @@ -0,0 +1,24 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.drawscope.DrawScope +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.RasterLayer + +class RasterLayerPainter : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: RasterLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + // TODO: Implement bitmap layer rendering + // 1. Load bitmap + // 2. Apply transformations + // 3. Draw with transparency + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SkyLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SkyLayerPainter.kt new file mode 100644 index 00000000..83da2b0d --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SkyLayerPainter.kt @@ -0,0 +1,24 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.drawscope.DrawScope +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.SkyLayer + +class SkyLayerPainter : BaseLayerPainter() { + override suspend fun paint( + canvas: DrawScope, + feature: Tile.Feature, + style: SkyLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + featureKey: String? + ) { + // TODO: Implement sky rendering + // 1. Create a sky gradient + // 2. Add atmospheric effects + // 3. Apply lighting + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SymbolLayerPainter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SymbolLayerPainter.kt new file mode 100644 index 00000000..556c12c1 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SymbolLayerPainter.kt @@ -0,0 +1,1222 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Rect +import androidx.compose.ui.geometry.Size +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.Shadow +import androidx.compose.ui.graphics.drawscope.DrawScope +import androidx.compose.ui.graphics.drawscope.rotate +import androidx.compose.ui.text.* +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.Constraints +import androidx.compose.ui.unit.Density +import androidx.compose.ui.unit.IntOffset +import androidx.compose.ui.unit.IntSize +import androidx.compose.ui.unit.sp +import kotlinx.coroutines.flow.MutableStateFlow +import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +import ovh.plrapps.mapcompose.vector.data.SDF +import ovh.plrapps.mapcompose.vector.data.SpriteManager +import ovh.plrapps.mapcompose.vector.renderer.collision.LabelPlacement +import ovh.plrapps.mapcompose.vector.renderer.collision.LineLabelPlacement +import ovh.plrapps.mapcompose.vector.renderer.collision.OverlapMode +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.SymbolLayer +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsDouble +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsDoubleList +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsFloat +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsString +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsBoolean +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsStringList +import ovh.plrapps.mapcompose.vector.spec.style.props.processAsColor +import ovh.plrapps.mapcompose.vector.spec.style.symbol.SymbolLayout +import ovh.plrapps.mapcompose.vector.spec.style.symbol.TextAnchor +import ovh.plrapps.mapcompose.vector.utils.LruCache +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock +import androidx.compose.ui.graphics.toArgb +import ovh.plrapps.mapcompose.vector.utils.obb.OBB +import ovh.plrapps.mapcompose.vector.utils.obb.ObbPoint +import kotlin.collections.zipWithNext +import kotlin.math.PI +import kotlin.math.atan2 +import kotlin.math.max +import kotlin.math.pow +import kotlin.math.sqrt + +data class CompoundLabelPlacement( + val spritePlacement: LabelPlacement, + val textPlacement: LabelPlacement? +) + +data class TextPlacementCandidate( + val labelPlacement: LabelPlacement, + val mercatorX: Double, + val mercatorY: Double, + val dx: Float, + val dy: Float, +) + +sealed class Symbol( + val id: String, + val global: Point, + val placement: CompoundLabelPlacement, + val align: Offset = IN_CENTER, + val viewportAligned: Boolean = true, +) { + class Sprite( + id: String, + global: Point, + placement: CompoundLabelPlacement, + val value: ImageBitmap, + viewportAligned: Boolean = true, + ) : Symbol(id, global, placement, viewportAligned = viewportAligned) + + class Text( + id: String, + global: Point, + placement: CompoundLabelPlacement, + val value: TextLayoutResult, + viewportAligned: Boolean = true, + val spriteAnchorGlobal: Point? = null, + val textOffset: Pair? = null, + ) : Symbol(id, global, placement, viewportAligned = viewportAligned) + + class SpriteWithText( + id: String, + global: Point, + placement: CompoundLabelPlacement, + align: Offset, + val sprite: ImageBitmap, + val text: TextLayoutResult, + val spriteSize: IntSize, + val textSize: IntSize, + val verticalGap: Float, + val iconOptional: Boolean, + val textOptional: Boolean, + viewportAligned: Boolean = true, + val textCandidates: List = emptyList(), + ) : Symbol(id, global, placement, align, viewportAligned) + + fun draw(drawScope: DrawScope) { + val s = getInPixels() + val symbolCenter = Offset(s.width / 2f, s.height / 2f) + with(drawScope) { + when (this@Symbol) { + is Sprite -> { + rotate(placement.spritePlacement.angle, pivot = symbolCenter) { + drawImage( + image = value, + dstSize = IntSize( + placement.spritePlacement.bounds.width.toInt(), + placement.spritePlacement.bounds.height.toInt() + ) + ) + } + } + + is Text -> { + // For text, use the corner from textPlacement (if available) or spritePlacement + val textAngle = + placement.textPlacement?.angle ?: placement.spritePlacement.angle + rotate(textAngle, pivot = symbolCenter) { + val centerX = (s.width - value.size.width) / 2f + val centerY = (s.height - value.size.height) / 2f + val topLeft = Offset(centerX, centerY) + + drawText( + textLayoutResult = value, + topLeft = topLeft + ) + } + } + + is SpriteWithText -> { + rotate(placement.spritePlacement.angle, pivot = symbolCenter) { + // For SpriteWithText offset is already taken into account in the position, you need to correctly place the elements inside the Canvas + // The sprite should be horizontally centered + val spriteLeft = (s.width - spriteSize.width) / 2f + val spriteTop = 0f + + // The text should be centered relative to the sprite + val textLeft = (s.width - textSize.width) / 2f + val textTop = spriteSize.height + verticalGap + + drawImage( + image = sprite, + dstSize = spriteSize, + dstOffset = IntOffset(spriteLeft.toInt(), spriteTop.toInt()) + ) + + // Draw text under the sprite + drawText( + textLayoutResult = text, + topLeft = Offset(textLeft, textTop) + ) + } + } + } + } + } + + fun getInPixels(): Size { + return when (this) { + is SpriteWithText -> { + val totalWidth = max(spriteSize.width, textSize.width) + val totalHeight = (spriteSize.height + verticalGap + textSize.height) + Size(totalWidth.toFloat(), totalHeight) + } + + is Sprite -> { + Size( + placement.spritePlacement.bounds.width, + placement.spritePlacement.bounds.height + ) + } + + is Text -> { + Size( + placement.textPlacement!!.bounds.width, + placement.textPlacement.bounds.height + ) + } + } + } + + companion object { + val IN_CENTER = Offset(-0.5f, -0.5f) + } +} + +data class SymbolPlacement( + val position: ObbPoint, + val angle: Float, + val size: Size = Size.Zero +) + +class SymbolLayerPainter( + private val textMeasurerState: MutableStateFlow, + private val spriteManager: SpriteManager?, + private val configuration: MapLibreConfiguration, + private val pathCache: LruCache, + private val mutex: Mutex +) { + private val DEFAULT_ICON_SCALE = 1f + + private val geometryDecoders = GeometryDecoders() + + private fun resolveViewportAligned(alignmentValue: String?, defaultViewportAligned: Boolean): Boolean = + when (alignmentValue) { + "map" -> false + "viewport" -> true + else -> defaultViewportAligned + } + + private fun resolveIconOverlapMode( + layout: SymbolLayout, + props: Map?, + zoom: Double + ): OverlapMode = + layout.iconOverlap?.processAsString(props, zoom)?.let { v -> + when (v) { + "always" -> OverlapMode.Always + "cooperative" -> OverlapMode.Cooperative + else -> OverlapMode.Never + } + } ?: if (layout.iconAllowOverlap?.processAsBoolean(props, zoom) == true) OverlapMode.Always else OverlapMode.Never + + private fun resolveTextOverlapMode( + layout: SymbolLayout, + props: Map?, + zoom: Double + ): OverlapMode = + layout.textOverlap?.processAsString(props, zoom)?.let { v -> + when (v) { + "always" -> OverlapMode.Always + "cooperative" -> OverlapMode.Cooperative + else -> OverlapMode.Never + } + } ?: if (layout.textAllowOverlap?.processAsBoolean(props, zoom) == true) OverlapMode.Always else OverlapMode.Never + + /** + * Transformation to normalized Mercator coordinates + */ + private fun tileCoordToNormalized( + tileX: Int, + tileY: Int, + pixelX: Double, + pixelY: Double, + zoom: Double, + tileSize: Int + ): Point { + val n = 2.0.pow(zoom) + + val normalizedX = (tileX * tileSize + pixelX) / (tileSize * n) + val normalizedY = (tileY * tileSize + pixelY) / (tileSize * n) + + return Point(normalizedX, normalizedY) + } + + private fun substituteTemplate(template: String, properties: Map?): String { + val lang = configuration.lang?.code + if (properties == null) return template + + // Without curly braces - just substitute the desired name + if (!template.contains("{")) { + if (lang != null) { + val localized = properties["name:$lang"]?.toString() + if (!localized.isNullOrBlank()) return localized + } + return properties["name"]?.toString() ?: template + } + + // In the template - we substitute by key if it is name:lang, otherwise name, otherwise just by key + return regexForSubProcess.replace(template) { matchResult -> + val key = matchResult.groupValues[1] + if (lang != null && key == "name:$lang") { + val localized = properties["name:$lang"]?.toString() + if (!localized.isNullOrBlank()) return@replace localized + return@replace properties["name"]?.toString() ?: "" + } + if (key == "name") { + return@replace properties["name"]?.toString() ?: "" + } + properties[key]?.toString() ?: "" + } + } + + private fun calculatePointPlacement( + feature: Tile.Feature, + extent: Int, + canvasSize: Int + ): SymbolPlacement? { + val points = geometryDecoders.decodePoint(geometry = feature.geometry, extent = extent, canvasSize = canvasSize) + return points.firstOrNull()?.let { + SymbolPlacement( + position = ObbPoint(it.x.toFloat(), it.y.toFloat()), + angle = 0f + ) + } + } + + private val regexForSubProcess = "\\{([^}]+)\\}".toRegex() + + private fun subProcess( + input: String, + featureProperties: Map? + ): String { + return if (input.firstOrNull() == '{') { + val matchResult = regexForSubProcess.find(input) + if (matchResult != null) { + val key = matchResult.groupValues[1] + val propValue = featureProperties?.get(key)?.toString() ?: "" + input.replace("{$key}", propValue) + } else { + input + } + } else { + input + } + } + + private fun produceSprite( + placement: SymbolPlacement, + style: SymbolLayer, + featureProperties: Map?, + actualZoom: Double, + zoom: Double, + id: String, + canvasSize: Int, + tileX: Int, + tileY: Int, + density: Density, + layerIndex: Int + ): Symbol? { + val spriteManager = spriteManager ?: return null + val paint = style.paint ?: return null + val layout = style.layout ?: return null + + val spriteId = + layout.iconImage?.processAsString(featureProperties, actualZoom)?.let { subProcess(it, featureProperties) } + ?: return null + val spriteInfo = spriteManager.getSpriteInfo(spriteId) + ?: return null + + val iconScale: Float = layout.iconSize.processAsFloat(featureProperties, actualZoom) ?: DEFAULT_ICON_SCALE + val iconColor = paint.iconColor?.processAsColor(featureProperties, actualZoom) + val iconHaloColor = paint.iconHaloColor?.processAsColor(featureProperties, actualZoom) + val iconOpacity = paint.iconOpacity.processAsFloat(featureProperties, actualZoom) ?: 1f + if (iconOpacity == 0f) { + return null + } + val scale = iconScale * density.density + + val sdf = if (spriteInfo.sdf) { + iconColor?.let { fillColor -> + SDF(fillColor = fillColor) + }?.let { + if (iconHaloColor != null) { + it.copy(haloColor = iconHaloColor) + } else it + } + } else null + + val spritePair = spriteManager.getSprite(spriteId, iconColor, sdf) + if (spritePair == null) { + return null + } + val (spriteMeta, sprite) = spritePair + + val size = IntSize( + (spriteMeta.width.toFloat() * scale).toInt(), + (spriteMeta.height.toFloat() * scale).toInt() + ) + + val spritePosition = ObbPoint(placement.position.x, placement.position.y) + + // Direct conversion of tile coordinates to normalized MapCompose coordinates + val normalizedPoint = tileCoordToNormalized( + tileX = tileX, + tileY = tileY, + pixelX = spritePosition.x.toDouble(), + pixelY = spritePosition.y.toDouble(), + zoom = zoom, + tileSize = canvasSize + ) + val globalX = normalizedPoint.x + val globalY = normalizedPoint.y + + val iconPadding = (layout.iconPadding.processAsFloat(featureProperties, actualZoom) ?: 2f) * density.density + + // Use double for exact calculations, then convert to float + val leftBound = (spritePosition.x.toDouble() - size.width.toDouble() / 2.0).toFloat() - iconPadding + val topBound = (spritePosition.y.toDouble() - size.height.toDouble() / 2.0).toFloat() - iconPadding + val rightBound = (spritePosition.x.toDouble() + size.width.toDouble() / 2.0).toFloat() + iconPadding + val bottomBound = (spritePosition.y.toDouble() + size.height.toDouble() / 2.0).toFloat() + iconPadding + + val bounds = Rect( + left = leftBound, + top = topBound, + right = rightBound, + bottom = bottomBound + ) + + val iconRotateDeg = layout.iconRotate.processAsFloat(featureProperties, actualZoom) ?: 0f + val spriteAngle = placement.angle + iconRotateDeg + + return LabelPlacement( + text = "sprite_$spriteId", + position = ObbPoint( + spritePosition.x, + spritePosition.y + ), + angle = spriteAngle, + bounds = bounds, + obb = OBB( + ObbPoint(spritePosition.x, spritePosition.y), + ovh.plrapps.mapcompose.vector.utils.obb.Size(size.width + 2 * iconPadding, size.height + 2 * iconPadding), + spriteAngle + ), + layerIndex = layerIndex, + inLayerPriority = layout.symbolSortKey.processAsDouble(featureProperties, actualZoom) ?: 0.0, + overlapMode = resolveIconOverlapMode(layout, featureProperties, actualZoom), + ignorePlacement = layout.iconIgnorePlacement?.processAsBoolean(featureProperties, actualZoom) ?: false + ).let { + val isLinePlacement = layout.symbolPlacement?.processAsString(featureProperties, actualZoom) + ?.let { p -> p == "line" || p == "line-center" } ?: false + val iconViewportAligned = resolveViewportAligned( + layout.iconRotationAlignment?.processAsString(featureProperties, actualZoom), + defaultViewportAligned = !isLinePlacement + ) + Symbol.Sprite( + id = id, + global = Point(globalX, globalY), + placement = CompoundLabelPlacement(it, null), + value = sprite, + viewportAligned = iconViewportAligned, + ) + } + } + + /** + * Sets the angle of the caption to the range where the text always reads from left to right (or bottom to top for vertical lines). + * If the angle is outside [-90, 90] degrees, it is flipped 180°. + * This prevents the text from appearing upside down on the lines. + * @param angle the original angle (in degrees) + * @return the angle to display the text correctly + */ + private fun makeTextUpright(angle: Float): Float { + return if (angle > 90f || angle < -90f) angle + 180f else angle + } + + private fun produceSpriteWithText( + id: String, + placement: SymbolPlacement, + style: SymbolLayer, + featureProperties: Map?, + actualZoom: Double, + zoom: Double, + canvasSize: Int, + tileX: Int, + tileY: Int, + density: Density, + layerIndex: Int + ): Symbol? { + val textMeasurer = textMeasurerState.value ?: return null + + val layout = style.layout ?: return null + val paint = style.paint ?: return null + val spriteManager = spriteManager ?: return null + + val spriteId = + layout.iconImage?.processAsString(featureProperties, actualZoom)?.let { subProcess(it, featureProperties) } + ?: return null + val spriteInfo = spriteManager.getSpriteInfo(spriteId) ?: return null + + val iconScale: Float = layout.iconSize.processAsFloat(featureProperties, actualZoom) ?: DEFAULT_ICON_SCALE + val iconColor = paint.iconColor?.processAsColor(featureProperties, actualZoom) + val iconHaloColor = paint.iconHaloColor?.processAsColor(featureProperties, actualZoom) + val iconOpacity = paint.iconOpacity.processAsFloat(featureProperties, actualZoom) ?: 1f + if (iconOpacity == 0f) return null + + val scale = iconScale * density.density + + val sdf = if (spriteInfo.sdf) { + iconColor?.let { fillColor -> + SDF(fillColor = fillColor) + }?.let { + if (iconHaloColor != null) { + it.copy(haloColor = iconHaloColor) + } else it + } + } else null + + val spritePair = spriteManager.getSprite(spriteId, iconColor, sdf) ?: return null + val (spriteMeta, sprite) = spritePair + + val spriteSize = IntSize( + (spriteMeta.width.toFloat() * scale).toInt(), + (spriteMeta.height.toFloat() * scale).toInt() + ) + + // We receive the text + val templateTextField = layout.textField?.processAsString(featureProperties, actualZoom) ?: return null + val textField = substituteTemplate(templateTextField, featureProperties) + if (textField.isBlank() || textField.length > 256) return null + + val fontSize = (layout.textSize.processAsFloat(featureProperties, actualZoom) ?: 16f) + val textMaxWidth = + layout.textMaxWidth.processAsFloat(featureProperties, actualZoom) ?: Float.POSITIVE_INFINITY + + val textColor = paint.textColor?.processAsColor(featureProperties, actualZoom) ?: Color.Black + val textOpacity = paint.textOpacity.processAsFloat(featureProperties, actualZoom) ?: 1f + if (textOpacity == 0f) return null + + val textHaloColor = paint.textHaloColor?.processAsColor(featureProperties, actualZoom) ?: Color.White + val textHaloWidth = (paint.textHaloWidth.processAsFloat(featureProperties, actualZoom) ?: 0f) + + val iconOptional = layout.iconOptional?.processAsBoolean(featureProperties, actualZoom) ?: false + val textOptional = layout.textOptional?.processAsBoolean(featureProperties, actualZoom) ?: false + + val textStyle = TextStyle( + color = textColor.copy(alpha = textOpacity), + fontSize = fontSize.sp, + textAlign = TextAlign.Center, + shadow = if (textHaloWidth > 0f) { + Shadow( + color = textHaloColor, + offset = Offset.Zero, + blurRadius = textHaloWidth * 2 + ) + } else null + ) + + val textLayoutResult = textMeasurer.measure( + text = AnnotatedString(textField), + density = density, + style = textStyle, + maxLines = 5, + constraints = if (textMaxWidth.isFinite()) { + Constraints(maxWidth = (textMaxWidth * fontSize * density.density).toInt()) + } else { + Constraints() + }, + softWrap = true + ) + + val textSize = textLayoutResult.size + val verticalGap = 2.0f * density.density + + // We calculate the overall dimensions + val totalWidth = max(spriteSize.width, textSize.width) + val totalHeight = spriteSize.height + verticalGap + textSize.height + + // The sprite position remains in the center of placement + val spritePosition = placement.position + + // Normalized coordinates for the sprite's center + val normalizedPoint = tileCoordToNormalized( + tileX = tileX, + tileY = tileY, + pixelX = spritePosition.x.toDouble(), + pixelY = spritePosition.y.toDouble(), + zoom = zoom, + tileSize = canvasSize + ) + + val iconPadding = (layout.iconPadding.processAsFloat(featureProperties, actualZoom) ?: 2f) * density.density + val textPadding = (layout.textPadding.processAsFloat(featureProperties, actualZoom) ?: 2f) * density.density + + val iconRotateDeg = layout.iconRotate.processAsFloat(featureProperties, actualZoom) ?: 0f + val textRotateDeg = layout.textRotate.processAsFloat(featureProperties, actualZoom) ?: 0f + + val spriteLabelPlacement = LabelPlacement( + text = "sprite_$spriteId", + position = spritePosition, + angle = iconRotateDeg, + bounds = Rect( + left = spritePosition.x - spriteSize.width / 2f - iconPadding, + top = spritePosition.y - spriteSize.height / 2f - iconPadding, + right = spritePosition.x + spriteSize.width / 2f + iconPadding, + bottom = spritePosition.y + spriteSize.height / 2f + iconPadding + ), + obb = OBB( + spritePosition, + ovh.plrapps.mapcompose.vector.utils.obb.Size(spriteSize.width + 2 * iconPadding, spriteSize.height + 2 * iconPadding), + iconRotateDeg + ), + layerIndex = layerIndex, + inLayerPriority = layout.symbolSortKey.processAsDouble(featureProperties, actualZoom) ?: 0.0, + overlapMode = resolveIconOverlapMode(layout, featureProperties, actualZoom), + ignorePlacement = layout.iconIgnorePlacement?.processAsBoolean(featureProperties, actualZoom) ?: false + ) + + // Position of text under sprite + val textPosition = ObbPoint( + spritePosition.x, + spritePosition.y + spriteSize.height / 2f + verticalGap + textSize.height / 2f + ) + + // Create a LabelPlacement for the text + val textLabelPlacement = LabelPlacement( + text = textField, + position = textPosition, + angle = textRotateDeg, + bounds = Rect( + left = textPosition.x - textSize.width / 2f - textPadding, + top = textPosition.y - textSize.height / 2f - textPadding, + right = textPosition.x + textSize.width / 2f + textPadding, + bottom = textPosition.y + textSize.height / 2f + textPadding + ), + obb = OBB( + textPosition, + ovh.plrapps.mapcompose.vector.utils.obb.Size(textSize.width + 2 * textPadding, textSize.height + 2 * textPadding), + textRotateDeg + ), + layerIndex = layerIndex, + inLayerPriority = layout.symbolSortKey.processAsDouble(featureProperties, actualZoom) ?: 0.0, + overlapMode = resolveTextOverlapMode(layout, featureProperties, actualZoom), + ignorePlacement = layout.textIgnorePlacement?.processAsBoolean(featureProperties, actualZoom) ?: false + ) + + val variableAnchors = layout.textVariableAnchor?.processAsStringList(featureProperties, actualZoom) + val textAnchorStr = TextAnchor.fromAny(layout.textAnchor?.processAsString(featureProperties, actualZoom))?.value ?: "bottom" + val anchors: List = + if (!variableAnchors.isNullOrEmpty()) variableAnchors else listOf(textAnchorStr) + + val radialPx = (layout.textRadialOffset.processAsFloat(featureProperties, actualZoom) ?: 0f) * + fontSize * density.density + val hOff = spriteSize.width / 2f + verticalGap + radialPx + textSize.width / 2f + val vOff = spriteSize.height / 2f + verticalGap + radialPx + textSize.height / 2f + + + val textCandidates: List = anchors.map { anchor -> + val (dx, dy) = when (anchor) { + "top" -> Pair(0f, -vOff) + "bottom" -> Pair(0f, +vOff) + "left" -> Pair(-hOff, 0f) + "right" -> Pair(+hOff, 0f) + "top-left" -> Pair(-hOff, -vOff) + "top-right" -> Pair(+hOff, -vOff) + "bottom-left" -> Pair(-hOff, +vOff) + "bottom-right" -> Pair(+hOff, +vOff) + "center" -> Pair(0f, 0f) + else -> Pair(0f, +vOff) + } + val cx = spritePosition.x + dx + val cy = spritePosition.y + dy + val norm = tileCoordToNormalized(tileX, tileY, cx.toDouble(), cy.toDouble(), zoom, canvasSize) + TextPlacementCandidate( + labelPlacement = LabelPlacement( + text = textField, + position = ObbPoint(cx, cy), + angle = textRotateDeg, + bounds = Rect( + cx - textSize.width / 2f - textPadding, + cy - textSize.height / 2f - textPadding, + cx + textSize.width / 2f + textPadding, + cy + textSize.height / 2f + textPadding + ), + obb = OBB( + ObbPoint(cx, cy), + ovh.plrapps.mapcompose.vector.utils.obb.Size( + textSize.width + 2 * textPadding, + textSize.height + 2 * textPadding + ), + textRotateDeg + ), + layerIndex = layerIndex, + inLayerPriority = layout.symbolSortKey.processAsDouble(featureProperties, actualZoom) ?: 0.0, + overlapMode = resolveTextOverlapMode(layout, featureProperties, actualZoom), + ignorePlacement = layout.textIgnorePlacement?.processAsBoolean(featureProperties, actualZoom) ?: false + ), + mercatorX = norm.x, + mercatorY = norm.y, + dx = dx, + dy = dy, + ) + } + + val offsetY = -((spriteSize.height.toFloat() / 2f) / totalHeight) + + val centerOffset = Offset( + x = -0.5f, + y = offsetY + ) + + val viewportAligned = resolveViewportAligned( + layout.textRotationAlignment?.processAsString(featureProperties, actualZoom), + defaultViewportAligned = true // produceSpriteWithText is only called for point geometry + ) + + return Symbol.SpriteWithText( + id = id, + global = Point(normalizedPoint.x, normalizedPoint.y), + placement = CompoundLabelPlacement( + spritePlacement = spriteLabelPlacement, + textPlacement = textLabelPlacement + ), + align = centerOffset, + sprite = sprite, + text = textLayoutResult, + spriteSize = spriteSize, + textSize = IntSize(textSize.width, textSize.height), + verticalGap = verticalGap, + iconOptional = iconOptional, + textOptional = textOptional, + viewportAligned = viewportAligned, + textCandidates = textCandidates, + ) + } + + private suspend fun produceText( + placement: SymbolPlacement, + style: SymbolLayer, + featureProperties: Map?, + actualZoom: Double, + zoom: Double, + lineStrings: List>>? = null, + id: String, + canvasSize: Int, + tileX: Int, + tileY: Int, + density: Density, + layerIndex: Int + ): Symbol? { + val textMeasurer = textMeasurerState.value ?: return null + + val layout = style.layout ?: return null + val paint = style.paint ?: return null + + val templateTextField = layout.textField?.processAsString(featureProperties, actualZoom) ?: return null + val textField = substituteTemplate(templateTextField, featureProperties) + if (textField.isBlank() || textField.length > 256) { + return null + } + + val fontSize = (layout.textSize.processAsFloat(featureProperties, actualZoom) ?: 16f) + val textMaxWidth = + layout.textMaxWidth.processAsFloat(featureProperties, actualZoom) ?: Float.POSITIVE_INFINITY + + val textColor = paint.textColor?.processAsColor(featureProperties, actualZoom) ?: Color.Black + val textOpacity = paint.textOpacity.processAsFloat(featureProperties, actualZoom) ?: 1f + if (textOpacity == 0f) { + return null + } + + val textHaloColor = paint.textHaloColor?.processAsColor(featureProperties, actualZoom) ?: Color.White + val textHaloWidth = (paint.textHaloWidth.processAsFloat(featureProperties, actualZoom) ?: 0f) + val offsetArr = layout.textOffset.processAsDoubleList(featureProperties, actualZoom) ?: listOf(0.0, 0.0) + val anchor = TextAnchor.fromAny(layout.textAnchor?.processAsString(featureProperties, actualZoom)) ?: TextAnchor.Center + + val dx = (offsetArr.getOrNull(0) ?: 0.0).toFloat() * fontSize + val dy = (offsetArr.getOrNull(1) ?: 0.0).toFloat() * fontSize + + val textStyle = TextStyle( + color = textColor.copy(alpha = textOpacity), + fontSize = fontSize.sp, + textAlign = TextAlign.Unspecified, + shadow = if (textHaloWidth > 0f) { + Shadow( + color = textHaloColor, + offset = Offset.Zero, + blurRadius = textHaloWidth * 2 + ) + } else null + ) + + val textCacheKey = "TEXT-$textField-${fontSize}-${textColor.toArgb()}-${textHaloWidth}-${textHaloColor.toArgb()}-${density.density}" + val textLayoutResult = mutex.withLock { + pathCache.get(textCacheKey) as? TextLayoutResult + } ?: textMeasurer.measure( + text = AnnotatedString(textField), + density = density, + style = textStyle, + maxLines = 1, + constraints = Constraints(), + softWrap = true + ).also { + mutex.withLock { + pathCache.put(textCacheKey, it) + } + } + + val textWidth = textLayoutResult.size.width.toFloat() + val textHeight = textLayoutResult.size.height.toFloat() + val verticalGap = 1.1f * density.density + + if (lineStrings != null && lineStrings.isNotEmpty()) { + return produceLineText( + id = id, + lineStrings = lineStrings, + layout = layout, + featureProperties = featureProperties, + actualZoom = actualZoom, + textWidth = textWidth, + dx = dx, + dy = dy, + tileX = tileX, + tileY = tileY, + textHeight = textHeight, + textField = textField, + zoom = zoom, + canvasSize = canvasSize, + textLayoutResult = textLayoutResult, + density = density, + layerIndex = layerIndex + ) + } else { + return producePointText( + id = id, + placement = placement, + anchor = anchor, + textWidth = textWidth, + textHeight = textHeight, + dx = dx, + dy = dy, + tileX = tileX, + tileY = tileY, + zoom = zoom, + canvasSize = canvasSize, + layout = layout, + featureProperties = featureProperties, + actualZoom = actualZoom, + textLayoutResult = textLayoutResult, + textField = textField, + density = density, + layerIndex = layerIndex + ) + } + } + + private fun produceLineText( + id: String, + lineStrings: List>>, + layout: SymbolLayout, + featureProperties: Map?, + actualZoom: Double, + textWidth: Float, + dx: Float, + dy: Float, + tileX: Int, + tileY: Int, + textHeight: Float, + textField: String, + zoom: Double, + canvasSize: Int, + textLayoutResult: TextLayoutResult, + density: Density, + layerIndex: Int, + ): Symbol? { + val symbolSpacing = layout.symbolSpacing.processAsFloat(featureProperties, actualZoom) ?: 250f + val maxAngleDeg = layout.textMaxAngle.processAsFloat(featureProperties, actualZoom) ?: 45f + val textRotateDeg = layout.textRotate.processAsFloat(featureProperties, actualZoom) ?: 0f + val textViewportAligned = resolveViewportAligned( + layout.textRotationAlignment?.processAsString(featureProperties, actualZoom), + defaultViewportAligned = false // "auto" + line placement = map-aligned + ) + val textPadding = (layout.textPadding.processAsFloat(featureProperties, actualZoom) ?: 2f) * density.density + var anyPlaced = false + var maxLength = 0f + var maxLine: List>? = null + + lineStrings.forEachIndexed lineStrings@{ indexLine, line -> + if (line.size < 2) return@lineStrings + val lineLength = line.zipWithNext { a, b -> + val dx = a.first - b.first + val dy = a.second - b.second + sqrt(dx * dx + dy * dy) + }.sum() + + if (lineLength > maxLength) { + maxLength = lineLength + maxLine = line + } + + if (lineLength < textWidth) return@lineStrings + val placements = LineLabelPlacement.calculatePlacements(line, textWidth, symbolSpacing, maxAngleDeg) + if (placements.isNotEmpty()) anyPlaced = true + placements.forEachIndexed { index, (pos, angle) -> + val distToStart = + sqrt((pos.first - line.first().first).pow(2) + (pos.second - line.first().second).pow(2)) + val distToEnd = + sqrt((pos.first - line.last().first).pow(2) + (pos.second - line.last().second).pow(2)) + if (distToStart < textWidth / 2 || distToEnd < textWidth / 2) return@forEachIndexed + val x = pos.first + dx + val y = pos.second + dy + val displayAngle = makeTextUpright(angle) + + try { + val normalizedPoint = + tileCoordToNormalized(tileX, tileY, x.toDouble(), y.toDouble(), zoom, canvasSize) + val globalX = normalizedPoint.x + val globalY = normalizedPoint.y + + val leftBound = (x.toDouble() - textWidth.toDouble() / 2.0).toFloat() - textPadding + val topBound = (y.toDouble() - textHeight.toDouble() / 2.0).toFloat() - textPadding + val rightBound = (x.toDouble() + textWidth.toDouble() / 2.0).toFloat() + textPadding + val bottomBound = (y.toDouble() + textHeight.toDouble() / 2.0).toFloat() + textPadding + + // Create a deterministic ID based on a tile, coordinates and indices + val coordHash = "${x.toInt()}_${y.toInt()}_${displayAngle.toInt()}" + val stableId = "L${tileX}_${tileY}_${id}_${indexLine}_${index}_$coordHash" + + val lineTextAngle = displayAngle + textRotateDeg + return LabelPlacement( + text = textField, + position = ObbPoint(x, y), + angle = lineTextAngle, + bounds = Rect( + left = leftBound, + top = topBound, + right = rightBound, + bottom = bottomBound + ), + obb = OBB( + ObbPoint(x, y), + ovh.plrapps.mapcompose.vector.utils.obb.Size(textWidth + 2 * textPadding, textHeight + 2 * textPadding), + lineTextAngle + ), + layerIndex = layerIndex, + inLayerPriority = layout.symbolSortKey.processAsDouble(featureProperties, actualZoom) ?: 0.0, + overlapMode = resolveTextOverlapMode(layout, featureProperties, actualZoom), + ignorePlacement = layout.textIgnorePlacement?.processAsBoolean(featureProperties, actualZoom) + ?: false + ).let { labelPlacement -> + Symbol.Text( + id = stableId, + global = Point(globalX, globalY), + placement = CompoundLabelPlacement( + spritePlacement = labelPlacement, + textPlacement = labelPlacement + ), + value = textLayoutResult, + viewportAligned = textViewportAligned, + ) + } + } catch (_: IllegalArgumentException) { + return@forEachIndexed + } + } + } + + if (!anyPlaced && maxLine != null && maxLine.size >= 2) { + val maxLineRef = maxLine // for smart cast + val maxLineLength = maxLineRef.zipWithNext { a, b -> + val dx = a.first - b.first + val dy = a.second - b.second + sqrt(dx * dx + dy * dy) + }.sum() + + if (maxLineLength >= textWidth) { + val midIdx = maxLineRef.size / 2 + val p1 = maxLineRef[midIdx - 1] + val p2 = maxLineRef[midIdx] + val x = (p1.first + p2.first) / 2 + dx + val y = (p1.second + p2.second) / 2 + dy + val angle = atan2(p2.second - p1.second, p2.first - p1.first) * 180f / PI.toFloat() + val displayAngle = makeTextUpright(angle) + val distToStart = sqrt((x - maxLineRef.first().first).pow(2) + (y - maxLineRef.first().second).pow(2)) + val distToEnd = sqrt((x - maxLineRef.last().first).pow(2) + (y - maxLineRef.last().second).pow(2)) + if (distToStart >= textWidth / 2 && distToEnd >= textWidth / 2) { + try { + val normalizedPoint = + tileCoordToNormalized(tileX, tileY, x.toDouble(), y.toDouble(), zoom, canvasSize) + val globalX = normalizedPoint.x + val globalY = normalizedPoint.y + + val leftBound = (x.toDouble() - textWidth.toDouble() / 2.0).toFloat() - textPadding + val topBound = (y.toDouble() - textHeight.toDouble() / 2.0).toFloat() - textPadding + val rightBound = (x.toDouble() + textWidth.toDouble() / 2.0).toFloat() + textPadding + val bottomBound = (y.toDouble() + textHeight.toDouble() / 2.0).toFloat() + textPadding + val lineTextAngle = displayAngle + textRotateDeg + return LabelPlacement( + text = textField, + position = ObbPoint(x, y), + angle = lineTextAngle, + bounds = Rect( + left = leftBound, + top = topBound, + right = rightBound, + bottom = bottomBound + ), + obb = OBB( + ObbPoint(x, y), + ovh.plrapps.mapcompose.vector.utils.obb.Size(textWidth + 2 * textPadding, textHeight + 2 * textPadding), + lineTextAngle + ), + layerIndex = layerIndex, + inLayerPriority = layout.symbolSortKey.processAsDouble(featureProperties, actualZoom) ?: 0.0, + overlapMode = resolveTextOverlapMode(layout, featureProperties, actualZoom), + ignorePlacement = layout.textIgnorePlacement?.processAsBoolean(featureProperties, actualZoom) + ?: false + ).let { labelPlacement -> + // Create a deterministic ID for the fallback case + val coordHash = "${x.toInt()}_${y.toInt()}_${displayAngle.toInt()}" + val stableId = "LF${tileX}_${tileY}_${id}_$coordHash" + + Symbol.Text( + id = stableId, + global = Point(globalX, globalY), + placement = CompoundLabelPlacement( + spritePlacement = labelPlacement, + textPlacement = labelPlacement + ), + value = textLayoutResult, + viewportAligned = textViewportAligned, + ) + } + } catch (_: IllegalArgumentException) { + return null + } + } + } + return null + } + return null + } + + private fun producePointText( + placement: SymbolPlacement, + anchor: TextAnchor, + textWidth: Float, + textHeight: Float, + dx: Float, + dy: Float, + tileX: Int, + tileY: Int, + zoom: Double, + canvasSize: Int, + layout: SymbolLayout, + featureProperties: Map?, + actualZoom: Double, + textLayoutResult: TextLayoutResult, + textField: String, + density: Density, + id: String, + layerIndex: Int + ): Symbol? { + val x = placement.position.x + dx + val y = placement.position.y + dy + val textPosition = when (anchor) { + TextAnchor.Top -> ObbPoint(x, y - textHeight / 2) + TextAnchor.Bottom -> ObbPoint(x, y + textHeight / 2) + TextAnchor.Left -> ObbPoint(x - textWidth / 2, y) + TextAnchor.Right -> ObbPoint(x + textWidth / 2, y) + TextAnchor.TopLeft -> ObbPoint(x - textWidth / 2, y - textHeight / 2) + TextAnchor.TopRight -> ObbPoint(x + textWidth / 2, y - textHeight / 2) + TextAnchor.BottomLeft -> ObbPoint(x - textWidth / 2, y + textHeight / 2) + TextAnchor.BottomRight -> ObbPoint(x + textWidth / 2, y + textHeight / 2) + TextAnchor.Center -> ObbPoint(x, y) + } + + try { + val normalizedPoint = tileCoordToNormalized( + tileX = tileX, + tileY = tileY, + pixelX = textPosition.x.toDouble(), + pixelY = textPosition.y.toDouble(), + zoom = zoom, + tileSize = canvasSize + ) + val globalX = normalizedPoint.x + val globalY = normalizedPoint.y + + val textPadding = (layout.textPadding.processAsFloat(featureProperties, actualZoom) ?: 2f) * density.density + + val leftBound = (textPosition.x.toDouble() - textWidth.toDouble() / 2.0).toFloat() - textPadding + val topBound = (textPosition.y.toDouble() - textHeight.toDouble() / 2.0).toFloat() - textPadding + val rightBound = (textPosition.x.toDouble() + textWidth.toDouble() / 2.0).toFloat() + textPadding + val bottomBound = (textPosition.y.toDouble() + textHeight.toDouble() / 2.0).toFloat() + textPadding + + val bounds = Rect( + left = leftBound, + top = topBound, + right = rightBound, + bottom = bottomBound + ) + + val textRotateDeg = layout.textRotate.processAsFloat(featureProperties, actualZoom) ?: 0f + val pointTextAngle = placement.angle + textRotateDeg + return LabelPlacement( + text = textField, + position = ObbPoint(textPosition.x, textPosition.y), + angle = pointTextAngle, + bounds = bounds, + obb = OBB( + center = ObbPoint(textPosition.x, textPosition.y), + size = ovh.plrapps.mapcompose.vector.utils.obb.Size(textWidth + 2 * textPadding, textHeight + 2 * textPadding), + rotation = pointTextAngle + ), + layerIndex = layerIndex, + inLayerPriority = layout.symbolSortKey.processAsDouble(featureProperties, actualZoom) ?: 0.0, + overlapMode = resolveTextOverlapMode(layout, featureProperties, actualZoom), + ignorePlacement = layout.textIgnorePlacement?.processAsBoolean(featureProperties, actualZoom) ?: false + ).let { labelPlacement -> + // Add coordinates to ID for uniqueness + val coordHash = "${textPosition.x.toInt()}_${textPosition.y.toInt()}" + val stableId = "P${tileX}_${tileY}_${id}_$coordHash" + + val textViewportAligned = resolveViewportAligned( + layout.textRotationAlignment?.processAsString(featureProperties, actualZoom), + defaultViewportAligned = true + ) + Symbol.Text( + id = stableId, + global = Point(globalX, globalY), + placement = CompoundLabelPlacement( + spritePlacement = labelPlacement, + textPlacement = labelPlacement // Correct placement for text + ), + value = textLayoutResult, + viewportAligned = textViewportAligned, + ) + } + } catch (_: IllegalArgumentException) { + return null + } + } + + suspend fun produceSymbol( + feature: Tile.Feature, + style: SymbolLayer, + canvasSize: Int, + extent: Int, + zoom: Double, + featureProperties: Map?, + actualZoom: Double, + id: String, + tileX: Int = 0, + tileY: Int = 0, + density: Density, + layerIndex: Int = 0, + ): List { + val layout = style.layout ?: return emptyList() + val paint = style.paint ?: return emptyList() + + // Calculate the symbol placement + val placement: SymbolPlacement? + var lineStrings: List>>? = null + if (feature.type == Tile.GeomType.POINT) { + placement = calculatePointPlacement(feature = feature, extent = extent, canvasSize = canvasSize) + } else if (layout.symbolPlacement?.processAsString(featureProperties, actualZoom) == "line" && + feature.type == Tile.GeomType.LINESTRING + ) { + lineStrings = geometryDecoders.decodeLine( + geometry = feature.geometry, + extent = extent, + canvasSize = canvasSize + ) + placement = lineStrings.firstOrNull()?.firstOrNull()?.let { + SymbolPlacement( + position = ObbPoint(it.first, it.second), + angle = 0f + ) + } + } else { + placement = null + } + if (placement == null) return emptyList() + + // Check if there is both a sprite and text + val hasSprite = layout.iconImage != null && spriteManager != null + val hasText = layout.textField != null + + if (hasSprite && hasText && feature.type == Tile.GeomType.POINT && lineStrings == null) { + // Create a SpriteWithText combo symbol for point objects + produceSpriteWithText( + id = "ST${tileX}_${tileY}_${id}", + placement = placement, + style = style, + featureProperties = featureProperties, + actualZoom = actualZoom, + zoom = zoom, + canvasSize = canvasSize, + tileX = tileX, + tileY = tileY, + density = density, + layerIndex = layerIndex + )?.let { return listOf(it) } + } + + // For lines or when there is only one element - create separate symbols + val list = mutableListOf() + + if (hasSprite) { + produceSprite( + id = "S${tileX}_${tileY}_${id}", + placement = placement, + style = style, + featureProperties = featureProperties, + actualZoom = actualZoom, + zoom = zoom, + canvasSize = canvasSize, + tileX = tileX, + tileY = tileY, + density = density, + layerIndex = layerIndex + )?.let { list.add(it) } + } + + if (hasText) { + produceText( + id = "T${tileX}_${tileY}_${id}", + placement = placement, + style = style, + featureProperties = featureProperties, + actualZoom = actualZoom, + zoom = zoom, + lineStrings = lineStrings, + canvasSize = canvasSize, + tileX = tileX, + tileY = tileY, + density = density, + layerIndex = layerIndex + )?.let { list.add(it) } + } + + return list + } +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SymbolsProducer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SymbolsProducer.kt new file mode 100644 index 00000000..5256add2 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/SymbolsProducer.kt @@ -0,0 +1,90 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.text.TextMeasurer +import androidx.compose.ui.unit.Density +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.sync.Mutex +import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.SymbolLayer +import ovh.plrapps.mapcompose.vector.utils.LruCache + +class SymbolsProducer( + configuration: MapLibreConfiguration, + private val textMeasurer: MutableStateFlow, + private val pathCache: LruCache, + private val pathCacheMutex: Mutex +) : BaseRenderer(configuration = configuration) { + + val symbolsPainter = SymbolLayerPainter( + textMeasurerState = textMeasurer, + spriteManager = configuration.spriteManager, + configuration = configuration, + pathCache = pathCache, + mutex = pathCacheMutex + ) + + suspend fun produce( + tile: Tile?, + styleLayer: SymbolLayer, + layerIndex: Int = 0, + zoom: Double, + canvasSize: Int, + actualZoom: Double, + tileX: Int = 0, + tileY: Int = 0, + density: Density, + localPropCache: MutableMap> + ): List { + if (!isZoomInRange(styleLayer, zoom)) { +// println(" missed by zoom") + return emptyList() + } + + if (tile == null || tile.layers.isEmpty()) return emptyList() + + val tileLayer = tile.layers.find { it.name == styleLayer.sourceLayer } + + if (tileLayer == null) { + return emptyList() + } + + // The sprite and the text of the sprite MAY be in different features, but in the same tile, + // because their points match. Therefore, this is one element, but in what order they were drawn, + // we do not know. Therefore, if the points match, then the text should be placed under the sprite, and if it is a sprite, then draw it above the text + val symbols = mutableListOf() + + for (feature in tileLayer.features) { + val featureIdKey = feature.id?.toString() ?: feature.hashCode().toString() + val propertyKey = if (tileX != 0 || tileY != 0) "T-$tileX-$tileY-${tileLayer.name}-$featureIdKey" else null + val featureProperties = if (propertyKey != null) { + localPropCache.getOrPut(propertyKey) { extractFeatureProperties(feature, tileLayer) } + } else { + extractFeatureProperties(feature, tileLayer) + } + + val isShouldRenderFeature = shouldRenderFeature(feature, tileLayer, styleLayer, zoom, featureProperties) + if (!isShouldRenderFeature) continue + + val extent = tileLayer.extent ?: 4096 + + symbolsPainter.produceSymbol( + id = feature.id?.toString() ?: "unknown_${feature.hashCode()}", + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + tileX = tileX, + tileY = tileY, + density = density, + layerIndex = layerIndex + ).let { symbol-> + symbols.addAll(symbol) + } + } + return symbols + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/TileRenderer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/TileRenderer.kt new file mode 100644 index 00000000..5a99a73a --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/TileRenderer.kt @@ -0,0 +1,206 @@ +package ovh.plrapps.mapcompose.vector.renderer + +import androidx.compose.ui.graphics.drawscope.DrawScope +import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +import ovh.plrapps.mapcompose.vector.spec.Tile +import ovh.plrapps.mapcompose.vector.spec.style.* +import ovh.plrapps.mapcompose.vector.utils.LruCache +import kotlinx.coroutines.sync.Mutex + +class TileRenderer( + configuration: MapLibreConfiguration, + private val pathCache: LruCache, + private val pathCacheMutex: Mutex, + private val localPropCache: MutableMap> +) : BaseRenderer(configuration = configuration) { + private val painters = mutableMapOf>() + + suspend fun render( + canvas: DrawScope, + tile: Tile?, + styleLayer: Layer, + zoom: Double, + canvasSize: Int, + actualZoom: Double, + tileKey: String? = null + ) { + if (!isZoomInRange(styleLayer, zoom)) { + // println(" missed by zoom") + return + } + when (styleLayer) { + is SymbolLayer -> {return} + is BackgroundLayer -> { + painters + .getOrPut(styleLayer) { + BackgroundLayerPainter() + }.let { + it as BackgroundLayerPainter + } + .paint( + canvas = canvas, + feature = Tile.Feature( + id = -1, + type = Tile.GeomType.POINT, + geometry = emptyList(), + tags = emptyList() + ), + style = styleLayer, + canvasSize = canvasSize, + extent = 4096, + zoom = zoom, + featureProperties = null, + actualZoom = actualZoom, + ) + } + is CircleLayer, + is FillLayer, + is LineLayer, + is SymbolLayer, + is FillExtrusionLayer, + is HeatmapLayer, + is RasterLayer, + is SkyLayer, + is HillshadeLayer -> { + if (tile == null || tile.layers.isEmpty()) return + val tileLayer = tile.layers.find { it.name == styleLayer.sourceLayer } + if (tileLayer == null) { +// println("source-layer '${styleLayer.sourceLayer}' not found") + return + } + val extent = tileLayer.extent ?: 4096 + val painter = painters + .getOrPut(styleLayer) { + when (styleLayer) { + is SymbolLayer, + is BackgroundLayer -> throw IllegalStateException("BackgroundLayer cant be here") + is CircleLayer -> CircleLayerPainter() + is FillExtrusionLayer -> FillExtrusionPainter() + is FillLayer -> FillLayerPainter(pathCache, pathCacheMutex) + is HeatmapLayer -> HeatmapLayerPainter() + is HillshadeLayer -> HillshadeLayerPainter() + is LineLayer -> LineLayerPainter(pathCache, pathCacheMutex) + is RasterLayer -> RasterLayerPainter() + is SkyLayer -> SkyLayerPainter() + } + } + + for (feature in tileLayer.features) { + val featureIdKey = feature.id?.toString() ?: feature.hashCode().toString() + val propertyKey = if (tileKey != null) "$tileKey-${tileLayer.name}-$featureIdKey" else null + val featureProperties = if (propertyKey != null) { + localPropCache.getOrPut(propertyKey) { extractFeatureProperties(feature, tileLayer) } + } else { + extractFeatureProperties(feature, tileLayer) + } + + val isShouldRenderFeature = shouldRenderFeature(feature, tileLayer, styleLayer, zoom, featureProperties) + if (!isShouldRenderFeature) continue + + val featureKey = if (tileKey != null) "$tileKey-${styleLayer.id}-$featureIdKey" else null + + when (styleLayer) { + is CircleLayer -> (painter as CircleLayerPainter).paint( + canvas = canvas, + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + featureKey = featureKey + ) + + is FillLayer -> (painter as FillLayerPainter).paint( + canvas = canvas, + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + featureKey = featureKey + ) + + is LineLayer -> (painter as LineLayerPainter).paint( + canvas = canvas, + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + featureKey = featureKey + ) + + is SymbolLayer -> { /*do nothing; render happened in separate place*/} + is BackgroundLayer -> throw IllegalStateException("BackgroundLayer cant be here") + is FillExtrusionLayer -> (painter as FillExtrusionPainter).paint( + canvas = canvas, + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + featureKey = featureKey + ) + + is HeatmapLayer -> (painter as HeatmapLayerPainter).paint( + canvas = canvas, + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + featureKey = featureKey + ) + + is HillshadeLayer -> (painter as HillshadeLayerPainter).paint( + canvas = canvas, + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + featureKey = featureKey + ) + + is RasterLayer -> (painter as RasterLayerPainter).paint( + canvas = canvas, + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + featureKey = featureKey + ) + + is SkyLayer -> (painter as SkyLayerPainter).paint( + canvas = canvas, + feature = feature, + style = styleLayer, + canvasSize = canvasSize, + extent = extent, + zoom = zoom, + featureProperties = featureProperties, + actualZoom = actualZoom, + featureKey = featureKey + ) + } + } + } + } + } +} + diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/CollisionDetector.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/CollisionDetector.kt new file mode 100644 index 00000000..bee34abf --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/CollisionDetector.kt @@ -0,0 +1,53 @@ +package ovh.plrapps.mapcompose.vector.renderer.collision + +import androidx.compose.ui.geometry.Rect +import ovh.plrapps.mapcompose.vector.utils.rtree.Rtree + +class CollisionDetector { + private val rtree = Rtree() + + fun wouldCollide(label: LabelPlacement): Boolean { + if (label.ignorePlacement) return false + if (label.overlapMode == OverlapMode.Always) return false + + val candidates = rtree.search(label.obb.getAABB()) + return candidates.any { existing -> + !existing.ignorePlacement && + label.obb.intersects(existing.obb) && + when (label.overlapMode) { + // Never: blocked by any non-ignore symbol + OverlapMode.Never -> true + // Cooperative: blocked only by Never symbols; can overlap other Cooperative/Always + OverlapMode.Cooperative -> existing.overlapMode == OverlapMode.Never + // Always: never blocked (unreachable, handled above) + OverlapMode.Always -> false + } + } + } + + fun tryPlaceLabel(label: LabelPlacement): Boolean { + if (label.ignorePlacement) return true + if (wouldCollide(label)) return false + // Insert everything except ignore-placement labels. + // Even Always/Cooperative labels are inserted so they can block Never symbols placed later. + rtree.insert(label.obb.getAABB(), label) + return true + } + + fun insert(label: LabelPlacement) { + if (!label.ignorePlacement) { + rtree.insert(label.obb.getAABB(), label) + } + } + + fun clear() { + rtree.clear() + } +} + +fun Rect.intersects(other: Rect): Boolean { + return this.left < other.right && + this.right > other.left && + this.top < other.bottom && + this.bottom > other.top +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LabelPlacement.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LabelPlacement.kt new file mode 100644 index 00000000..1d3309de --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LabelPlacement.kt @@ -0,0 +1,17 @@ +package ovh.plrapps.mapcompose.vector.renderer.collision + +import androidx.compose.ui.geometry.Rect +import ovh.plrapps.mapcompose.vector.utils.obb.OBB +import ovh.plrapps.mapcompose.vector.utils.obb.ObbPoint + +data class LabelPlacement( + val text: String, + val position: ObbPoint, + val angle: Float, + val bounds: Rect, + val obb: OBB, + val layerIndex: Int, + val inLayerPriority: Double, + val overlapMode: OverlapMode, + val ignorePlacement: Boolean, +) diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LineLabelPlacement.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LineLabelPlacement.kt new file mode 100644 index 00000000..79c3ecd5 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LineLabelPlacement.kt @@ -0,0 +1,78 @@ +package ovh.plrapps.mapcompose.vector.renderer.collision + +import kotlin.math.PI +import kotlin.math.abs +import kotlin.math.atan2 +import kotlin.math.sqrt + +class LineLabelPlacement { + companion object { + fun calculatePlacements( + points: List>, + textWidth: Float, + spacing: Float, + maxAngleDeg: Float = 45f + ): List, Float>> { + if (points.size < 2) return emptyList() + + val n = points.size + + // Precompute per-segment lengths, angles, and cumulative distance at each point. + val segLen = FloatArray(n - 1) + val segAngle = FloatArray(n - 1) + val cumDist = FloatArray(n) + cumDist[0] = 0f + + for (i in 0 until n - 1) { + val dx = points[i + 1].first - points[i].first + val dy = points[i + 1].second - points[i].second + val len = sqrt(dx * dx + dy * dy) + segLen[i] = len + segAngle[i] = if (len > 0f) atan2(dy, dx) * 180f / PI.toFloat() + else if (i > 0) segAngle[i - 1] else 0f + cumDist[i + 1] = cumDist[i] + len + } + + val placements = mutableListOf, Float>>() + + for (i in 0 until n - 1) { + val len = segLen[i] + if (len == 0f) continue + + val p1 = points[i] + val dx = points[i + 1].first - p1.first + val dy = points[i + 1].second - p1.second + val angle = segAngle[i] + + var localDist = spacing / 2f + while (localDist + textWidth / 2f <= len) { + val globalPos = cumDist[i] + localDist + val spanStart = globalPos - textWidth / 2f + val spanEnd = globalPos + textWidth / 2f + + // Reject if any interior corner within the label span is too sharp. + var tooSharp = false + for (j in 1 until n - 1) { + val cd = cumDist[j] + if (cd <= spanStart) continue + if (cd >= spanEnd) break + var delta = abs(segAngle[j] - segAngle[j - 1]) + if (delta > 180f) delta = 360f - delta + if (delta > maxAngleDeg) { tooSharp = true; break } + } + + if (!tooSharp) { + val t = localDist / len + placements.add( + (p1.first + t * dx to p1.second + t * dy) to angle + ) + } + + localDist += spacing + } + } + + return placements + } + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/OverlapMode.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/OverlapMode.kt new file mode 100644 index 00000000..53c66821 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/OverlapMode.kt @@ -0,0 +1,21 @@ +package ovh.plrapps.mapcompose.vector.renderer.collision + +/** + * Controls whether a symbol can overlap other symbols. + * + * Mirrors the MapLibre `icon-overlap` / `text-overlap` spec values. + * The older `icon-allow-overlap` / `text-allow-overlap` booleans map to [Never] (false) / [Always] (true). + */ +enum class OverlapMode { + /** Symbol is hidden when it collides with any other visible symbol. (default) */ + Never, + + /** Symbol is always visible regardless of collisions. Blocks [Never] symbols placed later. */ + Always, + + /** + * Symbol is visible unless it collides with a [Never] symbol. + * Two [Cooperative] symbols may overlap each other freely. + */ + Cooperative, +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/utils/MVTViewport.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/utils/MVTViewport.kt new file mode 100644 index 00000000..212b6dc7 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/renderer/utils/MVTViewport.kt @@ -0,0 +1,15 @@ +package ovh.plrapps.mapcompose.vector.renderer.utils + +import androidx.compose.ui.geometry.Rect + +data class MVTViewport( + val width: Float, + val height: Float, + val bearing: Float, + val pitch: Float, + val zoom: Float, + val tileMatrix: Map +) + +val MVTViewport.bbox + get() = Rect(left = 0f, top = 0f, right = width, bottom = height) \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/layout.json b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/layout.json new file mode 100644 index 00000000..7b3321d0 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/layout.json @@ -0,0 +1,240 @@ +{ + "line": { + "groups": [ + { + "title": "Paint properties", + "type": "properties", + "fields": [ + "line-opacity", + "line-color", + "line-width", + "line-offset", + "line-blur", + "line-dasharray", + "line-pattern", + "line-translate", + "line-translate-anchor", + "line-gap-width" + ] + }, + { + "title": "Layout properties", + "type": "properties", + "fields": [ + "line-cap", + "line-join", + "line-miter-limit", + "line-round-limit" + ] + } + ] + }, + "background": { + "groups": [ + { + "title": "Paint properties", + "type": "properties", + "fields": [ + "background-color", + "background-pattern", + "background-opacity" + ] + } + ] + }, + "fill": { + "groups": [ + { + "title": "Paint properties", + "type": "properties", + "fields": [ + "fill-opacity", + "fill-color", + "fill-antialias", + "fill-outline-color", + "fill-pattern", + "fill-translate", + "fill-translate-anchor" + ] + } + ] + }, + "fill-extrusion": { + "groups": [ + { + "title": "Paint properties", + "type": "properties", + "fields": [ + "fill-extrusion-opacity", + "fill-extrusion-color", + "fill-extrusion-translate", + "fill-extrusion-translate-anchor", + "fill-extrusion-pattern", + "fill-extrusion-height", + "fill-extrusion-base", + "fill-extrusion-vertical-gradient" + ] + } + ] + }, + "circle": { + "groups": [ + { + "title": "Paint properties", + "type": "properties", + "fields": [ + "circle-color", + "circle-opacity", + "circle-stroke-color", + "circle-stroke-opacity", + "circle-blur", + "circle-radius", + "circle-stroke-width", + "circle-pitch-scale", + "circle-translate", + "circle-translate-anchor", + "circle-pitch-alignment" + ] + } + ] + }, + "symbol": { + "groups": [ + { + "title": "General layout properties", + "type": "properties", + "fields": [ + "symbol-placement", + "symbol-spacing", + "symbol-avoid-edges", + "symbol-z-order" + ] + }, + { + "title": "Text layout properties", + "type": "properties", + "fields": [ + "text-field", + "text-font", + "text-size", + "text-line-height", + "text-padding", + "text-allow-overlap", + "text-ignore-placement", + "text-pitch-alignment", + "text-rotation-alignment", + "text-max-width", + "text-letter-spacing", + "text-justify", + "text-anchor", + "text-max-angle", + "text-writing-mode", + "text-rotate", + "text-keep-upright", + "text-transform", + "text-offset", + "text-optional", + "text-variable-anchor", + "text-radial-offset" + ] + }, + { + "title": "Icon layout properties", + "type": "properties", + "fields": [ + "icon-image", + "icon-allow-overlap", + "icon-ignore-placement", + "icon-optional", + "icon-rotation-alignment", + "icon-size", + "icon-text-fit", + "icon-text-fit-padding", + "icon-rotate", + "icon-padding", + "icon-keep-upright", + "icon-offset", + "icon-anchor", + "icon-pitch-alignment" + ] + }, + { + "title": "Text paint properties", + "type": "properties", + "fields": [ + "text-color", + "text-opacity", + "text-halo-color", + "text-halo-width", + "text-halo-blur", + "text-translate", + "text-translate-anchor" + ] + }, + { + "title": "Icon paint properties", + "type": "properties", + "fields": [ + "icon-color", + "icon-opacity", + "icon-halo-color", + "icon-halo-width", + "icon-halo-blur", + "icon-translate", + "icon-translate-anchor" + ] + } + ] + }, + "raster": { + "groups": [ + { + "title": "Paint properties", + "type": "properties", + "fields": [ + "raster-opacity", + "raster-hue-rotate", + "raster-brightness-min", + "raster-brightness-max", + "raster-saturation", + "raster-contrast", + "raster-fade-duration", + "raster-resampling" + ] + } + ] + }, + "hillshade": { + "groups": [ + { + "title": "Paint properties", + "type": "properties", + "fields": [ + "hillshade-illumination-direction", + "hillshade-illumination-anchor", + "hillshade-exaggeration", + "hillshade-shadow-color", + "hillshade-highlight-color", + "hillshade-accent-color" + ] + } + ] + }, + "heatmap": { + "groups": [ + { + "title": "Paint properties", + "type": "properties", + "fields": [ + "heatmap-radius", + "heatmap-weight", + "heatmap-intensity", + "heatmap-opacity" + ] + } + ] + }, + "invalid": { + "groups": [] + } +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/sprites/Sprite.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/sprites/Sprite.kt new file mode 100644 index 00000000..21116964 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/sprites/Sprite.kt @@ -0,0 +1,14 @@ +package ovh.plrapps.mapcompose.vector.spec.sprites + +import kotlinx.serialization.Serializable + +@Serializable +data class Sprite( + val width: Int, + val height: Int, + val x: Int, + val y: Int, + val stretchX: Pair, Pair>? = null, + val stretchY: Pair, Pair>? = null, + val sdf: Boolean = false, +) \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/Filter.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/Filter.kt new file mode 100644 index 00000000..c0c3d224 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/Filter.kt @@ -0,0 +1,511 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import kotlinx.serialization.* +import kotlinx.serialization.json.* +import kotlinx.serialization.descriptors.* +import kotlinx.serialization.encoding.* + +fun equalsWithNumberCoercion(a: Any?, b: Any?): Boolean { + return when { + a is Number && b is Number -> a.toDouble() == b.toDouble() + else -> a == b + } +} + +@Serializable(with = FilterSerializer::class) +sealed class Filter { + companion object { + const val TYPE_PROPERTY = "\$type" + } + + abstract fun process(featureProperties: Map, zoom: Double): Boolean + + @Serializable + @SerialName("all") + data class All(val filters: List) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return filters.all { it.process(featureProperties, zoom) } + } + } + + @Serializable + @SerialName("any") + data class AnyOf(val filters: List) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return filters.any { it.process(featureProperties, zoom) } + } + } + + @Serializable + @SerialName("none") + data class None(val filters: List) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return filters.none { it.process(featureProperties, zoom) } + } + } + + @Serializable + @SerialName("==") + data class Eq(val left: FilterOperand, val right: FilterOperand) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return equalsWithNumberCoercion(leftValue, rightValue) + } + } + + @Serializable + @SerialName("!=") + data class Neq(val left: FilterOperand, val right: FilterOperand) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return !equalsWithNumberCoercion(leftValue, rightValue) + } + } + + @Serializable + @SerialName(">") + data class Gt(val left: FilterOperand, val right: FilterOperand) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue is Number && rightValue is Number -> leftValue.toDouble() > rightValue.toDouble() + leftValue is String && rightValue is String -> leftValue > rightValue + else -> false + } + } + } + + @Serializable + @SerialName(">=") + data class Gte(val left: FilterOperand, val right: FilterOperand) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue is Number && rightValue is Number -> leftValue.toDouble() >= rightValue.toDouble() + leftValue is String && rightValue is String -> leftValue >= rightValue + else -> false + } + } + } + + @Serializable + @SerialName("<") + data class Lt(val left: FilterOperand, val right: FilterOperand) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue is Number && rightValue is Number -> leftValue.toDouble() < rightValue.toDouble() + leftValue is String && rightValue is String -> leftValue < rightValue + else -> false + } + } + } + + @Serializable + @SerialName("<=") + data class Lte(val left: FilterOperand, val right: FilterOperand) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue is Number && rightValue is Number -> leftValue.toDouble() <= rightValue.toDouble() + leftValue is String && rightValue is String -> leftValue <= rightValue + else -> false + } + } + } + + @Serializable + @SerialName("in") + data class InList(val key: FilterOperand, val values: List) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val keyValue = key.evaluate(featureProperties, zoom) + return values.any { it.evaluate(featureProperties, zoom) == keyValue } + } + } + + @Serializable + @SerialName("!in") + data class NotInList(val key: FilterOperand, val values: List) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val keyValue = key.evaluate(featureProperties, zoom) + return values.none { it.evaluate(featureProperties, zoom) == keyValue } + } + } + + @Serializable + @SerialName("has") + data class Has(val key: String) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return featureProperties.containsKey(key) + } + } + + @Serializable + @SerialName("!has") + data class NotHas(val key: String) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return !featureProperties.containsKey(key) + } + } + + @Serializable + data class ZoomGreaterThan( + @Contextual val value: Number + ) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return zoom > value.toDouble() + } + } + + @Serializable + data class ZoomGreaterThanOrEqual( + @Contextual val value: Number + ) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return zoom >= value.toDouble() + } + } + + @Serializable + data class ZoomLessThan( + @Contextual val value: Number + ) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return zoom < value.toDouble() + } + } + + @Serializable + data class ZoomLessThanOrEqual( + @Contextual val value: Number + ) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return zoom <= value.toDouble() + } + } + + @Serializable + data class Type( + val value: String + ) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + return featureProperties["type"] as? String == value + } + } + + // Output is Filter rather than Boolean so nested filter expressions (e.g. ["case",...]) work as outputs. + // Filter.All(emptyList()) = always-true, Filter.AnyOf(emptyList()) = always-false. + data class Match( + val input: FilterOperand, + val cases: List, Filter>>, + val default: Filter + ) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + val inputValue = input.evaluate(featureProperties, zoom) + for ((values, result) in cases) { + if (values.any { equalsWithNumberCoercion(inputValue, it) }) { + return result.process(featureProperties, zoom) + } + } + return default.process(featureProperties, zoom) + } + } + + data class Case( + val conditions: List>, + val default: Filter + ) : Filter() { + override fun process(featureProperties: Map, zoom: Double): Boolean { + for ((condition, result) in conditions) { + if (condition.process(featureProperties, zoom)) { + return result.process(featureProperties, zoom) + } + } + return default.process(featureProperties, zoom) + } + } +} + +@Serializable +sealed class FilterOperand { + abstract fun evaluate(featureProperties: Map, zoom: Double): Any? + + @Serializable + @SerialName("get") + data class Get(val property: String) : FilterOperand() { + override fun evaluate(featureProperties: Map, zoom: Double): Any? { + return featureProperties[property] + } + } + + @Serializable + @SerialName("to-boolean") + data class ToBoolean(val operand: FilterOperand) : FilterOperand() { + override fun evaluate(featureProperties: Map, zoom: Double): Any? { + val value = operand.evaluate(featureProperties, zoom) + return when (value) { + null -> false + is Boolean -> value + is String -> value.isNotEmpty() + is Number -> value.toDouble() != 0.0 + is Collection<*> -> value.isNotEmpty() + else -> true + } + } + } + + @Serializable + data class Literal(@Contextual val value: Any) : FilterOperand() { + override fun evaluate(featureProperties: Map, zoom: Double): Any? { + return value + } + } + + @Serializable + @SerialName("null") + object NullLiteral : FilterOperand() { + override fun evaluate(featureProperties: Map, zoom: Double): Any? = null + } +} + +@OptIn(ExperimentalSerializationApi::class) +@Serializer(forClass = Any::class) +object AnySerializer : KSerializer { + override val descriptor = PrimitiveSerialDescriptor("Any", PrimitiveKind.STRING) + + override fun serialize(encoder: Encoder, value: Any) { + when (value) { + is String -> encoder.encodeString(value) + is Number -> encoder.encodeDouble(value.toDouble()) + is Boolean -> encoder.encodeBoolean(value) + else -> throw SerializationException("Unsupported type: ${value::class}") + } + } + + override fun deserialize(decoder: Decoder): Any { + return when (val value = decoder.decodeString()) { + "true" -> true + "false" -> false + else -> { + value.toDoubleOrNull() ?: value + } + } + } +} + +object FilterSerializer : KSerializer { + override val descriptor: SerialDescriptor = + buildClassSerialDescriptor("Filter") + + override fun deserialize(decoder: Decoder): Filter { + val input = decoder as? JsonDecoder ?: error("FilterSerializer only works with JSON") + val json = input.decodeJsonElement() + val arr = json.jsonArray + if (arr.isEmpty()) error("Filter array is empty") + // Guard: arr[0] must be a string primitive (the operator). Array-first expressions + // are unknown filter forms — treat them as always-true (show all features). + val firstEl = arr.getOrNull(0) + if (firstEl !is JsonPrimitive) return Filter.All(emptyList()) + val op = firstEl.content + + fun getOperand(el: JsonElement, isKey: Boolean = false): FilterOperand = + when { + el is JsonArray && el.size == 2 && (el[0] as? JsonPrimitive)?.content == "get" -> + FilterOperand.Get(el[1].jsonPrimitive.content) + el is JsonArray && el.size == 2 && (el[0] as? JsonPrimitive)?.content == "to-boolean" -> + FilterOperand.ToBoolean(getOperand(el[1])) + el is JsonPrimitive && el.isString && isKey -> + FilterOperand.Get(el.content) + el is JsonPrimitive && el.isString && !isKey -> + FilterOperand.Literal(el.content) + el is JsonPrimitive -> + FilterOperand.Literal(el.booleanOrNull ?: el.longOrNull ?: el.doubleOrNull ?: el.content) + el is JsonArray && (el.getOrNull(0) as? JsonPrimitive)?.content == "geometry-type" -> + FilterOperand.Get("type") + else -> + FilterOperand.NullLiteral + } + + // Decodes a match/case output element. Outputs can be boolean literals or nested filter + // expressions (e.g. ["case",...] or ["!=",...]). Boolean true/false are represented as + // Filter.All(emptyList()) and Filter.AnyOf(emptyList()) respectively. + fun decodeOutput(el: JsonElement): Filter = when { + el is JsonPrimitive && el.booleanOrNull == true -> Filter.All(emptyList()) + el is JsonPrimitive && el.booleanOrNull == false -> Filter.AnyOf(emptyList()) + el is JsonArray -> input.json.decodeFromJsonElement(FilterSerializer, el) + else -> Filter.All(emptyList()) + } + + return when (op) { + "all" -> Filter.All(arr.drop(1).map { input.json.decodeFromJsonElement(FilterSerializer, it) }) + "any" -> Filter.AnyOf(arr.drop(1).map { input.json.decodeFromJsonElement(FilterSerializer, it) }) + "none" -> Filter.None(arr.drop(1).map { input.json.decodeFromJsonElement(FilterSerializer, it) }) + "==" -> Filter.Eq(getOperand(arr[1], isKey = true), getOperand(arr[2])) + "!=" -> Filter.Neq(getOperand(arr[1], isKey = true), getOperand(arr[2])) + ">" -> Filter.Gt(getOperand(arr[1], isKey = true), getOperand(arr[2])) + ">=" -> Filter.Gte(getOperand(arr[1], isKey = true), getOperand(arr[2])) + "<" -> Filter.Lt(getOperand(arr[1], isKey = true), getOperand(arr[2])) + "<=" -> Filter.Lte(getOperand(arr[1], isKey = true), getOperand(arr[2])) + "in" -> Filter.InList(getOperand(arr[1], isKey = true), arr.drop(2).map { getOperand(it, isKey = false) }) + "!in" -> Filter.NotInList(getOperand(arr[1], isKey = true), arr.drop(2).map { getOperand(it, isKey = false) }) + "has" -> (arr.getOrNull(1) as? JsonPrimitive)?.content?.let { Filter.Has(it) } ?: Filter.All(emptyList()) + "!has" -> (arr.getOrNull(1) as? JsonPrimitive)?.content?.let { Filter.NotHas(it) } ?: Filter.All(emptyList()) + "to-boolean" -> Filter.Eq(getOperand(arr[1]), FilterOperand.Literal(true)) + "match" -> { + fun parseLabel(el: JsonElement): Any { + val p = el.jsonPrimitive + return p.booleanOrNull ?: p.longOrNull ?: p.doubleOrNull ?: p.content + } + val inputOp = getOperand(arr[1], isKey = true) + val cases = mutableListOf, Filter>>() + var i = 2 + while (i < arr.size - 1) { + val labels: List = when (val labelEl = arr[i]) { + is JsonArray -> labelEl.map { parseLabel(it) } + else -> listOf(parseLabel(arr[i])) + } + val output = decodeOutput(arr[i + 1]) + cases.add(Pair(labels, output)) + i += 2 + } + val default = decodeOutput(arr.last()) + Filter.Match(inputOp, cases, default) + } + "case" -> { + val conditions = mutableListOf>() + var i = 1 + while (i < arr.size - 1) { + val condition = input.json.decodeFromJsonElement(FilterSerializer, arr[i]) + val result = decodeOutput(arr[i + 1]) + conditions.add(Pair(condition, result)) + i += 2 + } + val default = decodeOutput(arr.last()) + Filter.Case(conditions, default) + } + else -> error("Unknown filter operator: $op") + } + } + + override fun serialize(encoder: Encoder, value: Filter) { + val output = encoder as? JsonEncoder ?: error("FilterSerializer only works with JSON") + + fun outputToJson(f: Filter): JsonElement = when { + f is Filter.All && f.filters.isEmpty() -> JsonPrimitive(true) + f is Filter.AnyOf && f.filters.isEmpty() -> JsonPrimitive(false) + else -> output.json.encodeToJsonElement(FilterSerializer, f) + } + + val arr = when (value) { + is Filter.All -> buildJsonArray { + add(JsonPrimitive("all")) + value.filters.forEach { add(output.json.encodeToJsonElement(FilterSerializer, it)) } + } + is Filter.AnyOf -> buildJsonArray { + add(JsonPrimitive("any")) + value.filters.forEach { add(output.json.encodeToJsonElement(FilterSerializer, it)) } + } + is Filter.None -> buildJsonArray { + add(JsonPrimitive("none")) + value.filters.forEach { add(output.json.encodeToJsonElement(FilterSerializer, it)) } + } + is Filter.Eq -> buildJsonArray { + add(JsonPrimitive("==")) + add(operandToJson(value.left)) + add(operandToJson(value.right)) + } + is Filter.Neq -> buildJsonArray { + add(JsonPrimitive("!=")) + add(operandToJson(value.left)) + add(operandToJson(value.right)) + } + is Filter.Gt -> buildJsonArray { + add(JsonPrimitive(">")) + add(operandToJson(value.left)) + add(operandToJson(value.right)) + } + is Filter.Gte -> buildJsonArray { + add(JsonPrimitive(">=")) + add(operandToJson(value.left)) + add(operandToJson(value.right)) + } + is Filter.Lt -> buildJsonArray { + add(JsonPrimitive("<")) + add(operandToJson(value.left)) + add(operandToJson(value.right)) + } + is Filter.Lte -> buildJsonArray { + add(JsonPrimitive("<=")) + add(operandToJson(value.left)) + add(operandToJson(value.right)) + } + is Filter.InList -> buildJsonArray { + add(JsonPrimitive("in")) + add(operandToJson(value.key)) + value.values.forEach { add(operandToJson(it)) } + } + is Filter.NotInList -> buildJsonArray { + add(JsonPrimitive("!in")) + add(operandToJson(value.key)) + value.values.forEach { add(operandToJson(it)) } + } + is Filter.Has -> buildJsonArray { + add(JsonPrimitive("has")) + add(JsonPrimitive(value.key)) + } + is Filter.NotHas -> buildJsonArray { + add(JsonPrimitive("!has")) + add(JsonPrimitive(value.key)) + } + is Filter.Match -> buildJsonArray { + add(JsonPrimitive("match")) + add(operandToJson(value.input)) + for ((labels, result) in value.cases) { + if (labels.size == 1) { + add(labelToJson(labels[0])) + } else { + add(buildJsonArray { labels.forEach { add(labelToJson(it)) } }) + } + add(outputToJson(result)) + } + add(outputToJson(value.default)) + } + is Filter.Case -> buildJsonArray { + add(JsonPrimitive("case")) + for ((condition, result) in value.conditions) { + add(output.json.encodeToJsonElement(FilterSerializer, condition)) + add(outputToJson(result)) + } + add(outputToJson(value.default)) + } + else -> error("Serialization not implemented for this filter type") + } + output.encodeJsonElement(arr) + } + + private fun operandToJson(op: FilterOperand): JsonElement = when (op) { + is FilterOperand.Get -> buildJsonArray { + add(JsonPrimitive("get")) + add(JsonPrimitive(op.property)) + } + is FilterOperand.ToBoolean -> buildJsonArray { + add(JsonPrimitive("to-boolean")) + add(operandToJson(op.operand)) + } + is FilterOperand.Literal -> Json.encodeToJsonElement(AnySerializer, op.value) + is FilterOperand.NullLiteral -> JsonNull + } + + private fun labelToJson(v: Any): JsonElement = when (v) { + is Boolean -> JsonPrimitive(v) + is Number -> JsonPrimitive(v) + is String -> JsonPrimitive(v) + else -> JsonPrimitive(v.toString()) + } +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/Layer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/Layer.kt new file mode 100644 index 00000000..f76c8419 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/Layer.kt @@ -0,0 +1,193 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import kotlinx.serialization.ExperimentalSerializationApi +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.JsonClassDiscriminator +import ovh.plrapps.mapcompose.vector.spec.style.background.BackgroundLayout +import ovh.plrapps.mapcompose.vector.spec.style.background.BackgroundPaint +import ovh.plrapps.mapcompose.vector.spec.style.circle.CircleLayout +import ovh.plrapps.mapcompose.vector.spec.style.circle.CirclePaint +import ovh.plrapps.mapcompose.vector.spec.style.fill.FillLayout +import ovh.plrapps.mapcompose.vector.spec.style.fill.FillPaint +import ovh.plrapps.mapcompose.vector.spec.style.fillExtrusion.FillExtrusionLayout +import ovh.plrapps.mapcompose.vector.spec.style.fillExtrusion.FillExtrusionPaint +import ovh.plrapps.mapcompose.vector.spec.style.heatmap.HeatmapLayout +import ovh.plrapps.mapcompose.vector.spec.style.heatmap.HeatmapPaint +import ovh.plrapps.mapcompose.vector.spec.style.hillshade.HillshadeLayout +import ovh.plrapps.mapcompose.vector.spec.style.hillshade.HillshadePaint +import ovh.plrapps.mapcompose.vector.spec.style.line.LineLayout +import ovh.plrapps.mapcompose.vector.spec.style.line.LinePaint +import ovh.plrapps.mapcompose.vector.spec.style.raster.RasterLayout +import ovh.plrapps.mapcompose.vector.spec.style.raster.RasterPaint +import ovh.plrapps.mapcompose.vector.spec.style.sky.SkyLayout +import ovh.plrapps.mapcompose.vector.spec.style.sky.SkyPaint +import ovh.plrapps.mapcompose.vector.spec.style.symbol.SymbolLayout +import ovh.plrapps.mapcompose.vector.spec.style.symbol.SymbolPaint + +@OptIn(ExperimentalSerializationApi::class) +@JsonClassDiscriminator("type") +@Serializable +sealed class Layer { + abstract val id: String + abstract val type: String + abstract val source: String? + @SerialName("source-layer") + abstract val sourceLayer: String? + abstract val filter: Filter? + abstract val minzoom: Double? + abstract val maxzoom: Double? + abstract val layout: LayoutInterface? + abstract val paint: PaintInterface? +} + +@Serializable +@SerialName("line") +data class LineLayer( + override val id: String, + override val type: String = "line", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: LineLayout? = null, + override val paint: LinePaint? = null, +) : Layer() + +@Serializable +@SerialName("fill") +data class FillLayer( + override val id: String, + override val type: String = "fill", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: FillLayout? = null, + override val paint: FillPaint? = null, +) : Layer() + +@Serializable +@SerialName("symbol") +data class SymbolLayer( + override val id: String, + override val type: String = "symbol", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: SymbolLayout? = null, + override val paint: SymbolPaint? = null, +) : Layer() + +@Serializable +@SerialName("circle") +data class CircleLayer( + override val id: String, + override val type: String = "circle", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: CircleLayout? = null, + override val paint: CirclePaint? = null, +) : Layer() + +@Serializable +@SerialName("background") +data class BackgroundLayer( + override val id: String, + override val type: String = "background", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: BackgroundLayout? = null, + override val paint: BackgroundPaint? = null, +) : Layer() + +@Serializable +@SerialName("raster") +data class RasterLayer( + override val id: String, + override val type: String = "raster", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: RasterLayout? = null, + override val paint: RasterPaint? = null, +) : Layer() + +@Serializable +@SerialName("hillshade") +data class HillshadeLayer( + override val id: String, + override val type: String = "hillshade", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: HillshadeLayout? = null, + override val paint: HillshadePaint? = null, +) : Layer() + +@Serializable +@SerialName("heatmap") +data class HeatmapLayer( + override val id: String, + override val type: String = "heatmap", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: HeatmapLayout? = null, + override val paint: HeatmapPaint? = null, +) : Layer() + +@Serializable +@SerialName("fill-extrusion") +data class FillExtrusionLayer( + override val id: String, + override val type: String = "fill-extrusion", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val layout: FillExtrusionLayout? = null, + override val paint: FillExtrusionPaint? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null +) : Layer() + +@Serializable +@SerialName("sky") +data class SkyLayer( + override val id: String, + override val type: String = "sky", + override val source: String? = null, + @SerialName("source-layer") + override val sourceLayer: String? = null, + override val filter: Filter? = null, + override val minzoom: Double? = null, + override val maxzoom: Double? = null, + override val layout: SkyLayout? = null, + override val paint: SkyPaint? = null, +) : Layer() + diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutInterface.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutInterface.kt new file mode 100644 index 00000000..7dae1dc6 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutInterface.kt @@ -0,0 +1,5 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +interface LayoutInterface { + val visibility: String? +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutType.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutType.kt new file mode 100644 index 00000000..00237a42 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutType.kt @@ -0,0 +1,21 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +enum class LayoutType { + FILL, + LINE, + SYMBOL, + CIRCLE, + HEATMAP, + RASTER, + HILLSHADE, + FILL_EXTRUSION, + UNDEFINED, + BACKGROUND; + + companion object { + fun parse(type: String): LayoutType { + val normalized = type.uppercase().replace('-', '_').trim() + return LayoutType.entries.find { it.name == normalized } ?: UNDEFINED + } + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/MapLibreStyle.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/MapLibreStyle.kt new file mode 100644 index 00000000..f42b15e2 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/MapLibreStyle.kt @@ -0,0 +1,56 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import kotlinx.serialization.builtins.ListSerializer +import kotlinx.serialization.json.* +import ovh.plrapps.mapcompose.vector.data.json + +/** + * https://maplibre.org/maplibre-style-spec/ + */ +@Serializable +data class MapLibreStyle( + @SerialName("version") var version: Int? = null, + @SerialName("name") var name: String? = null, + @SerialName("center") var center: List = emptyList(), + @SerialName("zoom") var zoom: Float? = null, + @SerialName("bearing") var bearing: Double? = null, + @SerialName("pitch") var pitch: Double? = null, + @SerialName("sources") var sources: Map? = emptyMap(), + @SerialName("sprite") var sprite: JsonElement? = null, + @SerialName("glyphs") var glyphs: String? = null, + @SerialName("layers") var layers: List = emptyList(), + @SerialName("id") var id: String? = null +) + +@Serializable +data class Source( + val type: String? = null, + + // For TileJSON reference + val url: String? = null, + + // For inline tile source definition + val tiles: List? = null, + val minzoom: Int? = null, + val maxzoom: Int? = null, + val attribution: String? = null +) + +@Serializable +data class SpriteSource(val id: String?, val url: String?) + +val MapLibreStyle.sprites: List + get() { + val element = this.sprite + return when(element) { + is JsonPrimitive -> listOf(SpriteSource(id = "", element.contentOrNull)) + is JsonArray -> { + json.decodeFromJsonElement(ListSerializer(SpriteSource.serializer()), element) + } + is JsonObject, + JsonNull, + null -> emptyList() + } + } \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/PaintInterface.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/PaintInterface.kt new file mode 100644 index 00000000..49010a35 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/PaintInterface.kt @@ -0,0 +1,3 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +interface PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/background/BackgroundLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/background/BackgroundLayout.kt new file mode 100644 index 00000000..cbfb6319 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/background/BackgroundLayout.kt @@ -0,0 +1,9 @@ +package ovh.plrapps.mapcompose.vector.spec.style.background + +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface + +@Serializable +data class BackgroundLayout( + override val visibility: String? = "visible" +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/background/BackgroundPaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/background/BackgroundPaint.kt new file mode 100644 index 00000000..456bd0bb --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/background/BackgroundPaint.kt @@ -0,0 +1,21 @@ +package ovh.plrapps.mapcompose.vector.spec.style.background + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValueColorSerializer + +@Serializable +data class BackgroundPaint( + @SerialName("background-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val backgroundColor: ExpressionOrValue? = null, + + @SerialName("background-pattern") + val backgroundPattern: ExpressionOrValue? = null, + + @SerialName("background-opacity") + val backgroundOpacity: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/circle/CircleLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/circle/CircleLayout.kt new file mode 100644 index 00000000..4ec55a5b --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/circle/CircleLayout.kt @@ -0,0 +1,13 @@ +package ovh.plrapps.mapcompose.vector.spec.style.circle + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue + +@Serializable +data class CircleLayout( + @SerialName("circle-sort-key") + val circleSortKey: ExpressionOrValue? = null, + override val visibility: String? = "visible" +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/circle/CirclePaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/circle/CirclePaint.kt new file mode 100644 index 00000000..f97f54dc --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/circle/CirclePaint.kt @@ -0,0 +1,50 @@ +package ovh.plrapps.mapcompose.vector.spec.style.circle + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValueColorSerializer + +@Serializable +data class CirclePaint( + @SerialName("circle-radius") + val circleRadius: ExpressionOrValue? = null, + + @SerialName("circle-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val circleColor: ExpressionOrValue? = null, + + @SerialName("circle-blur") + val circleBlur: ExpressionOrValue? = null, + + @SerialName("circle-opacity") + val circleOpacity: ExpressionOrValue? = null, + + @SerialName("circle-translate") + val circleTranslate: ExpressionOrValue>? = null, + + @SerialName("circle-translate-anchor") + val circleTranslateAnchor: ExpressionOrValue? = null, + + @SerialName("circle-pitch-scale") + val circlePitchScale: ExpressionOrValue? = null, + + @SerialName("circle-pitch-alignment") + val circlePitchAlignment: ExpressionOrValue? = null, + + @SerialName("circle-stroke-width") + val circleStrokeWidth: ExpressionOrValue? = null, + + @SerialName("circle-stroke-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val circleStrokeColor: ExpressionOrValue? = null, + + @SerialName("circle-stroke-opacity") + val circleStrokeOpacity: ExpressionOrValue? = null, + + @SerialName("circle-sort-key") + val circleSortKey: ExpressionOrValue? = null + +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fill/FillLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fill/FillLayout.kt new file mode 100644 index 00000000..9aac4f78 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fill/FillLayout.kt @@ -0,0 +1,14 @@ +package ovh.plrapps.mapcompose.vector.spec.style.fill + +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable + +@Serializable +data class FillLayout( + @SerialName("fill-sort-key") + val fillSortKey: ExpressionOrValue? = null, + + override val visibility: String? = "visible" +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fill/FillPaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fill/FillPaint.kt new file mode 100644 index 00000000..60edf6b5 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fill/FillPaint.kt @@ -0,0 +1,34 @@ +package ovh.plrapps.mapcompose.vector.spec.style.fill + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValueColorSerializer + +@Serializable +data class FillPaint( + @SerialName("fill-antialias") + val fillAntialias: ExpressionOrValue? = null, + + @SerialName("fill-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val fillColor: ExpressionOrValue? = null, + + @SerialName("fill-opacity") + val fillOpacity: ExpressionOrValue? = null, + + @SerialName("fill-outline-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val fillOutlineColor: ExpressionOrValue? = null, + + @SerialName("fill-pattern") + val fillPattern: ExpressionOrValue? = null, + + @SerialName("fill-translate") + val fillTranslate: ExpressionOrValue>? = null, + + @SerialName("fill-translate-anchor") + val fillTranslateAnchor: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fillExtrusion/FillExtrusionLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fillExtrusion/FillExtrusionLayout.kt new file mode 100644 index 00000000..d3e1676e --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fillExtrusion/FillExtrusionLayout.kt @@ -0,0 +1,10 @@ +package ovh.plrapps.mapcompose.vector.spec.style.fillExtrusion + +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface + +@Serializable +data class FillExtrusionLayout( + override val visibility: String? = "visible" + +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fillExtrusion/FillExtrusionPaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fillExtrusion/FillExtrusionPaint.kt new file mode 100644 index 00000000..e6f7594e --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/fillExtrusion/FillExtrusionPaint.kt @@ -0,0 +1,33 @@ +package ovh.plrapps.mapcompose.vector.spec.style.fillExtrusion + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue + +@Serializable +data class FillExtrusionPaint( + @SerialName("fill-extrusion-opacity") + val fillExtrusionOpacity: ExpressionOrValue? = null, + + @SerialName("fill-extrusion-color") + val fillExtrusionColor: ExpressionOrValue? = null, + + @SerialName("fill-extrusion-translate") + val fillExtrusionTranslate: ExpressionOrValue>? = null, + + @SerialName("fill-extrusion-translate-anchor") + val fillExtrusionTranslateAnchor: ExpressionOrValue? = null, + + @SerialName("fill-extrusion-pattern") + val fillExtrusionPattern: ExpressionOrValue? = null, + + @SerialName("fill-extrusion-height") + val fillExtrusionHeight: ExpressionOrValue? = null, + + @SerialName("fill-extrusion-base") + val fillExtrusionBase: ExpressionOrValue? = null, + + @SerialName("fill-extrusion-vertical-gradient") + val fillExtrusionVerticalGradient: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/heatmap/HeatmapLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/heatmap/HeatmapLayout.kt new file mode 100644 index 00000000..13cb55f4 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/heatmap/HeatmapLayout.kt @@ -0,0 +1,9 @@ +package ovh.plrapps.mapcompose.vector.spec.style.heatmap + +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface + +@Serializable +data class HeatmapLayout( + override val visibility: String? = "visible" +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/heatmap/HeatmapPaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/heatmap/HeatmapPaint.kt new file mode 100644 index 00000000..dade0c2a --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/heatmap/HeatmapPaint.kt @@ -0,0 +1,24 @@ +package ovh.plrapps.mapcompose.vector.spec.style.heatmap + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue + +@Serializable +data class HeatmapPaint( + @SerialName("heatmap-weight") + val heatmapWeight: ExpressionOrValue? = null, + + @SerialName("heatmap-intensity") + val heatmapIntensity: ExpressionOrValue? = null, + + @SerialName("heatmap-color") + val heatmapColor: ExpressionOrValue? = null, + + @SerialName("heatmap-radius") + val heatmapRadius: ExpressionOrValue? = null, + + @SerialName("heatmap-opacity") + val heatmapOpacity: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/hillshade/HillshadeLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/hillshade/HillshadeLayout.kt new file mode 100644 index 00000000..2ad86664 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/hillshade/HillshadeLayout.kt @@ -0,0 +1,9 @@ +package ovh.plrapps.mapcompose.vector.spec.style.hillshade + +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface + +@Serializable +data class HillshadeLayout( + override val visibility: String? = "visible" +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/hillshade/HillshadePaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/hillshade/HillshadePaint.kt new file mode 100644 index 00000000..103b6582 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/hillshade/HillshadePaint.kt @@ -0,0 +1,32 @@ +package ovh.plrapps.mapcompose.vector.spec.style.hillshade + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValueColorSerializer + +@Serializable +data class HillshadePaint( + @SerialName("hillshade-accent-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val hillshadeAccentColor: ExpressionOrValue? = null, + + @SerialName("hillshade-exaggeration") + val hillshadeExaggeration: ExpressionOrValue? = null, + + @SerialName("hillshade-highlight-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val hillshadeHighlightColor: ExpressionOrValue? = null, + + @SerialName("hillshade-illumination-anchor") + val hillshadeIlluminationAnchor: ExpressionOrValue? = null, + + @SerialName("hillshade-illumination-direction") + val hillshadeIlluminationDirection: ExpressionOrValue? = null, + + @SerialName("hillshade-shadow-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val hillshadeShadowColor: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/line/LineLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/line/LineLayout.kt new file mode 100644 index 00000000..a40553c3 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/line/LineLayout.kt @@ -0,0 +1,23 @@ +package ovh.plrapps.mapcompose.vector.spec.style.line + +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable + +@Serializable +data class LineLayout( + @SerialName("line-cap") + val lineCap: ExpressionOrValue? = null, + + @SerialName("line-join") + val lineJoin: ExpressionOrValue? = null, + + @SerialName("line-miter-limit") + val lineMiterLimit: ExpressionOrValue? = null, + + @SerialName("line-round-limit") + val lineRoundLimit: ExpressionOrValue? = null, + + override val visibility: String? = "visible" +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/line/LinePaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/line/LinePaint.kt new file mode 100644 index 00000000..0fcf8550 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/line/LinePaint.kt @@ -0,0 +1,42 @@ +package ovh.plrapps.mapcompose.vector.spec.style.line + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValueColorSerializer + +@Serializable +data class LinePaint( + @SerialName("line-opacity") + val lineOpacity: ExpressionOrValue? = null, + + @SerialName("line-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val lineColor: ExpressionOrValue? = null, + + @SerialName("line-width") + val lineWidth: ExpressionOrValue? = null, + + @SerialName("line-offset") + val lineOffset: ExpressionOrValue? = null, + + @SerialName("line-blur") + val lineBlur: ExpressionOrValue? = null, + + @SerialName("line-dasharray") + val lineDasharray: ExpressionOrValue>? = null, + + @SerialName("line-pattern") + val linePattern: ExpressionOrValue? = null, + + @SerialName("line-translate") + val lineTranslate: ExpressionOrValue>? = null, + + @SerialName("line-translate-anchor") + val lineTranslateAnchor: ExpressionOrValue? = null, + + @SerialName("line-gap-width") + val lineGapWidth: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrColor.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrColor.kt new file mode 100644 index 00000000..7473b9cc --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrColor.kt @@ -0,0 +1,12 @@ +package ovh.plrapps.mapcompose.vector.spec.style.props + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.KSerializer +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ColorSerializer +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ExpressionOrValueSerializer + +val colorSerializer: KSerializer = ColorSerializer + + +object ExpressionOrValueColorSerializer : + KSerializer> by ExpressionOrValueSerializer(colorSerializer) diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValue.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValue.kt new file mode 100644 index 00000000..ac0a2d6a --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValue.kt @@ -0,0 +1,904 @@ +package ovh.plrapps.mapcompose.vector.spec.style.props + +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.lerp +import kotlinx.serialization.Contextual +import kotlinx.serialization.Serializable +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonElement +import kotlinx.serialization.json.JsonObject +import kotlinx.serialization.json.JsonPrimitive +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ExpressionOrValueSerializer +import ovh.plrapps.mapcompose.vector.spec.style.utils.knownExpressions +import kotlin.math.* + +@Serializable(with = ExpressionOrValueSerializer::class) +sealed class ExpressionOrValue { + open val source: String = "" + + data class Value(val value: T, override var source: String = "") : ExpressionOrValue() + data class Expression(val expr: Expr, override var source: String = "") : ExpressionOrValue() + + fun process( + featureProperties: Map? = null, + zoom: Double? = null + ): T? = when (this) { + is Value -> value + is Expression -> expr.evaluate(featureProperties, zoom) + } + + companion object { + fun isExpression(input: JsonElement): Boolean { + return when (input) { + is JsonArray -> { + val head = input.firstOrNull() + head is JsonPrimitive && head.isString && head.content in knownExpressions + } + + is JsonObject -> input.containsKey("stops") || + input.containsKey("type") || + input.containsKey("base") || + input.containsKey("property") + + else -> false + } + } + } +} + +@Serializable +sealed class Expr { + abstract fun evaluate( + featureProperties: Map?, + zoom: Double? + ): T? + + @Serializable + data class Get(val property: Expr<@Contextual Any?>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + val key = property.evaluate(featureProperties, zoom) as? String ?: return null + return featureProperties?.get(key) as? T + } + } + + @Serializable + + data class ToNumber(val input: Expr<@Contextual Any?>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val value = input.evaluate(featureProperties, zoom) + return when (value) { + is Number -> value.toDouble() + is String -> value.toDoubleOrNull() + else -> null + } + } + } + + @Serializable + data class Image(val input: Expr<@Contextual Any?>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): String? { + val value = input.evaluate(featureProperties, zoom) + return value?.toString() + } + } + + @Serializable + data class Step( + val input: Expr, + val default: Expr, + val stops: List>> + ) : Expr() { + override fun evaluate( + featureProperties: Map?, + zoom: Double? + ): T? { + val inputValue = input.evaluate(featureProperties, zoom) + if (inputValue == null) return default.evaluate(featureProperties, zoom) + + var matched: Expr? = null + for ((stop, valueExpr) in stops) { + if (inputValue < stop) break + matched = valueExpr + } + return (matched ?: default).evaluate(featureProperties, zoom) + } + } + + @Serializable + data class Constant(val value: T) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?) = value + } + + @Serializable + data class Match( + val input: Expr<@Contextual Any?>, + val branches: List, Expr>>, + val elseExpr: Expr + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + val inputValue = input.evaluate(featureProperties, zoom)?.toString() + for ((values, expr) in branches) { + if (inputValue != null && values.contains(inputValue)) { + return expr.evaluate(featureProperties, zoom) + } + } + return elseExpr.evaluate(featureProperties, zoom) + } + } + + @Serializable + data class ZoomStops(val stops: List>>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + val z: Double = zoom ?: return (stops.firstOrNull()?.second?.evaluate(featureProperties, zoom) as T?) + return stops.lastOrNull { it.first <= z }?.second?.evaluate(featureProperties, zoom) as T? + ?: stops.firstOrNull()?.second?.evaluate(featureProperties, zoom) as T? + } + } + + + @Serializable + data class Raw(val json: JsonElement) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?) = null + } + + @Serializable + data class Has(val property: String) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + return featureProperties?.containsKey(property) + } + } + + @Serializable + data class In( + val value: Expr<@Contextual Any?>, + @Contextual + val array: List + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return array.contains(evaluatedValue?.toString()) + } + } + + @Serializable + data class Case( + val conditions: List, Expr>>, + val default: Expr + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + for ((condition, result) in conditions) { + if (condition.evaluate(featureProperties, zoom) == true) { + return result.evaluate(featureProperties, zoom) + } + } + return default.evaluate(featureProperties, zoom) + } + } + + @Serializable + data class Coalesce(val values: List>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + for (expr in values) { + val result = expr.evaluate(featureProperties, zoom) + if (result != null) { + return result + } + } + return null + } + } + + @Serializable + data class At(val index: Int, val array: Expr<@Contextual Any?>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + val arrayValue = array.evaluate(featureProperties, zoom) ?: return null + return when (arrayValue) { + is List<*> -> arrayValue.getOrNull(index) as? T + else -> null + } + } + } + + @Serializable + data class Length(val array: Expr<@Contextual Any?>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Int? { + val arrayValue = array.evaluate(featureProperties, zoom) ?: return null + @Suppress("UNCHECKED_CAST") + return when (arrayValue) { + is List<*> -> arrayValue.size + is String -> arrayValue.length + else -> null + } + } + } + + @Serializable + data class Slice(val array: Expr<@Contextual Any?>, val start: Int, val end: Int?) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + val arrayValue = array.evaluate(featureProperties, zoom) ?: return null + return when (arrayValue) { + is List<*> -> { + val endIndex = end ?: arrayValue.size + arrayValue.subList(start, endIndex.coerceAtMost(arrayValue.size)) as? T + } + is String -> { + val endIndex = end ?: arrayValue.length + arrayValue.substring(start, endIndex.coerceAtMost(arrayValue.length)) as? T + } + else -> null + } + } + } + + @Serializable + data class NotEquals( + val left: Expr, + val right: Expr + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return leftValue != rightValue + } + } + + @Serializable + data class Equals( + val left: Expr, + val right: Expr + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return leftValue == rightValue + } + } + + @Serializable + data class LessThan( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue == null || rightValue == null -> null + leftValue is Number && rightValue is Number -> leftValue.toDouble() < rightValue.toDouble() + leftValue is String && rightValue is String -> leftValue < rightValue + else -> null + } + } + } + + @Serializable + data class LessThanOrEqual( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue == null || rightValue == null -> null + leftValue is Number && rightValue is Number -> leftValue.toDouble() <= rightValue.toDouble() + leftValue is String && rightValue is String -> leftValue <= rightValue + else -> null + } + } + } + + @Serializable + data class GreaterThan( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue == null || rightValue == null -> null + leftValue is Number && rightValue is Number -> leftValue.toDouble() > rightValue.toDouble() + leftValue is String && rightValue is String -> leftValue > rightValue + else -> null + } + } + } + + @Serializable + data class GreaterThanOrEqual( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue == null || rightValue == null -> null + leftValue is Number && rightValue is Number -> leftValue.toDouble() >= rightValue.toDouble() + leftValue is String && rightValue is String -> leftValue >= rightValue + else -> null + } + } + } + + @Serializable + data class All(val conditions: List>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + if (conditions.isEmpty()) return null + for (condition in conditions) { + val result = condition.evaluate(featureProperties, zoom) + if (result == null || !result) return result + } + return true + } + } + + @Serializable + data class AnyOf(val conditions: List>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + if (conditions.isEmpty()) return null + for (condition in conditions) { + val result = condition.evaluate(featureProperties, zoom) + if (result == true) return true + if (result == null) return null + } + return false + } + } + + @Serializable + data class Not(val condition: Expr) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val result = condition.evaluate(featureProperties, zoom) + return result?.not() + } + } + + @Serializable + data class Modulo( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue == null || rightValue == null -> null + leftValue is Number && rightValue is Number -> { + val divisor = rightValue.toDouble() + if (divisor == 0.0) null + else leftValue.toDouble() % divisor + } + + else -> null + } + } + } + + @Serializable + data class Power( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue == null || rightValue == null -> null + leftValue is Number && rightValue is Number -> { + val base = leftValue.toDouble() + val exponent = rightValue.toDouble() + base.pow(exponent) + } + + else -> null + } + } + } + + @Serializable + data class Abs( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> abs(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Acos( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> acos(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Asin( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> asin(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Atan( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> atan(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Ceil( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> ceil(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Cos( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> cos(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Floor( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> floor(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Ln( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> { + val doubleValue = evaluatedValue.toDouble() + if (doubleValue <= 0) null + else ln(doubleValue) + } + + else -> null + } + } + } + + @Serializable + data class Log10( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> { + val doubleValue = evaluatedValue.toDouble() + if (doubleValue <= 0) null + else log10(doubleValue) + } + + else -> null + } + } + } + + @Serializable + data class Max( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue == null || rightValue == null -> null + leftValue is Number && rightValue is Number -> + max(leftValue.toDouble(), rightValue.toDouble()) + + else -> null + } + } + } + + @Serializable + data class Min( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val leftValue = left.evaluate(featureProperties, zoom) + val rightValue = right.evaluate(featureProperties, zoom) + return when { + leftValue == null || rightValue == null -> null + leftValue is Number && rightValue is Number -> + min(leftValue.toDouble(), rightValue.toDouble()) + + else -> null + } + } + } + + @Serializable + data class Round( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> round(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Sin( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> sin(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Sqrt( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> { + val doubleValue = evaluatedValue.toDouble() + if (doubleValue < 0) null + else sqrt(doubleValue) + } + + else -> null + } + } + } + + @Serializable + data class Tan( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + is Number -> tan(evaluatedValue.toDouble()) + else -> null + } + } + } + + @Serializable + data class Stops(val stops: List>) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + if (stops.isEmpty()) return null + if (stops.size == 1) return stops.first().second + + val sortedStops = stops.sortedBy { it.first } + val value = zoom ?: return sortedStops.first().second + + return when { + value <= sortedStops.first().first -> sortedStops.first().second + value >= sortedStops.last().first -> sortedStops.last().second + else -> { + val index = sortedStops.indexOfLast { it.first <= value } + if (index < 0 || index == sortedStops.lastIndex) return null + val (lowerStop, lowerValue) = sortedStops[index] + val (upperStop, upperValue) = sortedStops[index + 1] + val t = (value - lowerStop) / (upperStop - lowerStop) + interpolate(t, lowerValue, upperValue) + } + } + } + } + + @Serializable + data class Interpolate( + val interpolation: InterpolationType, + val input: Expr<@Contextual Any?>, + val stops: List>> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + if (stops.isEmpty()) return null + if (stops.size == 1) return stops.first().second.evaluate(featureProperties, zoom) + + val sortedStops = stops.sortedBy { it.first } + val inputValue = input.evaluate(featureProperties, zoom) as? Double ?: return null + val firstStop = sortedStops.first() + val lastStop = sortedStops.last() + return when { + inputValue <= firstStop.first -> firstStop.second.evaluate(featureProperties, zoom) + inputValue >= lastStop.first -> lastStop.second.evaluate(featureProperties, zoom) + else -> { + val index = sortedStops.indexOfLast { it.first <= inputValue } + if (index < 0 || index == sortedStops.lastIndex) return null + val (lowerStop, lowerExpr) = sortedStops[index] + val (upperStop, upperExpr) = sortedStops[index + 1] + val t = when (interpolation) { + is InterpolationType.Linear -> (inputValue - lowerStop) / (upperStop - lowerStop) + is InterpolationType.Exponential -> { + val base = interpolation.base + if (base == 1.0) { + (inputValue - lowerStop) / (upperStop - lowerStop) + } else { + (base.pow((inputValue - lowerStop) / (upperStop - lowerStop)) - 1) / (base - 1) + } + } + + else -> (inputValue - lowerStop) / (upperStop - lowerStop) // fallback + } + val lowerValue = lowerExpr.evaluate(featureProperties, zoom) ?: return null + val upperValue = upperExpr.evaluate(featureProperties, zoom) ?: return null + interpolate(t, lowerValue, upperValue) + } + } + } + } + + @Serializable + data class Concat( + val left: Expr<@Contextual Any?>, + val right: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): T? { + val leftValue = left.evaluate(featureProperties, zoom) ?: return null + val rightValue = right.evaluate(featureProperties, zoom) ?: return null + return when { + leftValue is List<*> && rightValue is List<*> -> (leftValue + rightValue) as? T + else -> (leftValue.toString() + rightValue.toString()) as? T + } + } + } + + @Serializable + data class IndexOf( + val array: Expr<@Contextual Any?>, + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Int? { + val arrayValue = array.evaluate(featureProperties, zoom) ?: return null + val searchValue = value.evaluate(featureProperties, zoom) ?: return null + return when (arrayValue) { + is List<*> -> arrayValue.indexOf(searchValue) + is String -> arrayValue.indexOf(searchValue.toString()) + else -> null + } + } + } + + @Serializable + data class Downcase( + val value: Expr + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): String? { + val evaluatedValue = value.evaluate(featureProperties, zoom) ?: return null + return evaluatedValue.lowercase() + } + } + + @Serializable + data class Upcase( + val value: Expr + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): String? { + val evaluatedValue = value.evaluate(featureProperties, zoom) ?: return null + return evaluatedValue.uppercase() + } + } + + @Serializable + data class ToBoolean( + val value: Expr<@Contextual Any?> + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Boolean? { + val evaluatedValue = value.evaluate(featureProperties, zoom) + return when (evaluatedValue) { + null -> false + is String -> evaluatedValue.isNotEmpty() + is Number -> evaluatedValue.toDouble() != 0.0 && !evaluatedValue.toDouble().isNaN() + is Boolean -> evaluatedValue + else -> true + } + } + } + + @Serializable + data class ToString( + val value: Expr + ) : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): String? { + val evaluated = value.evaluate(featureProperties, zoom) + return when (evaluated) { + null -> "" + is String -> evaluated + is Boolean -> evaluated.toString() + is Number -> evaluated.toString() + is Color -> "rgba(${(evaluated.red * 255).toInt()},${(evaluated.green * 255).toInt()},${(evaluated.blue * 255).toInt()},${(evaluated.alpha * 100).toInt() / 100.0})" + is Map<*, *> -> { + val entries = evaluated.map { (k, v) -> + "\"${k}\":${ + when (v) { + null -> "null" + is String -> "\"$v\"" + is Number, is Boolean -> v.toString() + is Map<*, *>, is List<*> -> (ToString(Constant(v))).evaluate(null, null) + else -> "\"${v.toString()}\"" + } + }" + } + "{${entries.joinToString(",")}}" + } + + is List<*> -> { + val elements = evaluated.map { v -> + when (v) { + null -> "null" + is String -> "\"$v\"" + is Number, is Boolean -> v.toString() + is Map<*, *>, is List<*> -> (ToString(Constant(v))).evaluate(null, null) + else -> "\"${v.toString()}\"" + } + } + "[${elements.joinToString(",")}]" + } + + else -> evaluated.toString() + } + } + } + + @Serializable + object Zoom : Expr() { + override fun evaluate(featureProperties: Map?, zoom: Double?): Double? = zoom + } + + private fun nearest(value: Double, a: T, b: T): T = + if (abs(value - a.toDouble()) <= abs(value - b.toDouble())) a else b + + // TODO need test + fun interpolate(t: Double, a: T, b: T): T? { + return when { + a is Double && b is Double -> (a * (1 - t) + b * t) as T + a is Float && b is Float -> (a * (1 - t.toFloat()) + b * t.toFloat()) as T + a is Int && b is Int -> (a * (1 - t) + b * t).toInt() as T + a is Number && b is Number -> { + val at = a.toDouble() + val bt = b.toDouble() + (at * (1 - t) + bt * t) as T + } + a is Color && b is Color -> lerp(start = a, stop = b, fraction = t.toFloat()) as T + a is String && b is String -> if (t <= 0.5) a else b + else -> if (t < 0.5) a else b + } + } +} + +fun ExpressionOrValue?.processAsDouble( + featureProperties: Map? = null, + zoom: Double? = null +): Double? { + val p: ExpressionOrValue<*>? = this + return (p?.process(featureProperties, zoom) as? Number)?.toDouble() +} + +fun ExpressionOrValue?.processAsString( + featureProperties: Map? = null, + zoom: Double? = null +): String? { + val p: ExpressionOrValue<*>? = this + return p?.process(featureProperties, zoom)?.toString() +} + +fun ExpressionOrValue?.processAsColor( + featureProperties: Map? = null, + zoom: Double? = null +): Color? { + val p: ExpressionOrValue<*>? = this + return p?.process(featureProperties, zoom) as? Color +} + +fun ExpressionOrValue?.processAsBoolean( + featureProperties: Map? = null, + zoom: Double? = null +): Boolean? { + val p: ExpressionOrValue<*>? = this + return when (val result = p?.process(featureProperties, zoom)) { + is Boolean -> result + is String -> result.toBooleanStrictOrNull() + is Number -> result.toDouble() != 0.0 + else -> null + } +} + +fun ExpressionOrValue>?.processAsStringList( + featureProperties: Map? = null, + zoom: Double? = null +): List? { + val p: ExpressionOrValue<*>? = this + val result = p?.process(featureProperties, zoom) as? List<*> ?: return null + return result.map { it?.toString() ?: "" } +} + +fun ExpressionOrValue?.processAsFloat( + featureProperties: Map? = null, + zoom: Double? = null +): Float? { + val p: ExpressionOrValue<*>? = this + return (p?.process(featureProperties, zoom) as? Number)?.toFloat() +} + +fun ExpressionOrValue>?.processAsDoubleList( + featureProperties: Map? = null, + zoom: Double? = null +): List? { + val p: ExpressionOrValue<*>? = this + val result = p?.process(featureProperties, zoom) as? List<*> ?: return null + return result.mapNotNull { (it as? Number)?.toDouble() } +} + +@Serializable +sealed class InterpolationType { + @Serializable + object Linear : InterpolationType() + + @Serializable + data class Exponential(val base: Double) : InterpolationType() + + @Serializable + object Cubic : InterpolationType() + + @Serializable + object Step : InterpolationType() + + @Serializable + data class CubicBezier(val x1: Double, val y1: Double, val x2: Double, val y2: Double) : InterpolationType() +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/raster/RasterLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/raster/RasterLayout.kt new file mode 100644 index 00000000..ab98d94e --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/raster/RasterLayout.kt @@ -0,0 +1,9 @@ +package ovh.plrapps.mapcompose.vector.spec.style.raster + +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface + +@Serializable +data class RasterLayout( + override val visibility: String? = "visible" +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/raster/RasterPaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/raster/RasterPaint.kt new file mode 100644 index 00000000..4b7e716e --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/raster/RasterPaint.kt @@ -0,0 +1,26 @@ +package ovh.plrapps.mapcompose.vector.spec.style.raster + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue + +@Serializable +data class RasterPaint( + @SerialName("raster-opacity") + val rasterOpacity: ExpressionOrValue? = null, + @SerialName("raster-hue-rotate") + val rasterHueRotate: ExpressionOrValue? = null, + @SerialName("raster-brightness-min") + val rasterBrightnessMin: ExpressionOrValue? = null, + @SerialName("raster-brightness-max") + val rasterBrightnessMax: ExpressionOrValue? = null, + @SerialName("raster-saturation") + val rasterSaturation: ExpressionOrValue? = null, + @SerialName("raster-contrast") + val rasterContrast: ExpressionOrValue? = null, + @SerialName("raster-resampling") + val rasterResampling: ExpressionOrValue? = null, + @SerialName("raster-fade-duration") + val rasterFadeDuration: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ColorSerializer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ColorSerializer.kt new file mode 100644 index 00000000..d7c120cc --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ColorSerializer.kt @@ -0,0 +1,23 @@ +package ovh.plrapps.mapcompose.vector.spec.style.serializers + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.KSerializer +import kotlinx.serialization.descriptors.PrimitiveKind +import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor +import kotlinx.serialization.descriptors.SerialDescriptor +import kotlinx.serialization.encoding.Decoder +import kotlinx.serialization.encoding.Encoder +import ovh.plrapps.mapcompose.vector.spec.style.utils.ColorParser + +object ColorSerializer : KSerializer { + override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("Color", PrimitiveKind.STRING) + + override fun serialize(encoder: Encoder, value: Color) { + encoder.encodeString(ColorParser.colorToHexString(value)) + } + + override fun deserialize(decoder: Decoder): Color { + val string = decoder.decodeString() + return ColorParser.parseColorStringOrNull(string) ?: error("parse color error $string") + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExprSerializer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExprSerializer.kt new file mode 100644 index 00000000..52bae338 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExprSerializer.kt @@ -0,0 +1,1315 @@ +package ovh.plrapps.mapcompose.vector.spec.style.serializers + +import kotlinx.serialization.Contextual +import kotlinx.serialization.ExperimentalSerializationApi +import kotlinx.serialization.KSerializer +import kotlinx.serialization.SerializationException +import kotlinx.serialization.Serializer +import kotlinx.serialization.descriptors.SerialDescriptor +import kotlinx.serialization.descriptors.buildClassSerialDescriptor +import kotlinx.serialization.encoding.Decoder +import kotlinx.serialization.encoding.Encoder +import kotlinx.serialization.json.* +import ovh.plrapps.mapcompose.vector.spec.style.props.Expr +import ovh.plrapps.mapcompose.vector.spec.style.props.InterpolationType +import ovh.plrapps.mapcompose.vector.spec.style.utils.isExpr +import ovh.plrapps.mapcompose.vector.spec.style.utils.normalizeLegacyExpression + +object ExprSerializerFactory { + fun create(valueSerializer: KSerializer): KSerializer> { + return ExprSerializer(valueSerializer) + } +} + +@OptIn(ExperimentalSerializationApi::class) +@Serializer(forClass = Expr::class) +class ExprSerializer( + private val valueSerializer: KSerializer +) : KSerializer> { + + override val descriptor: SerialDescriptor = buildClassSerialDescriptor("Expr") + + private fun serializeGet(value: Expr.Get, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("get"), + encoder.json.encodeToJsonElement(valueSerializer, (value as T)) + ) + ) + ) + } + + private fun serializeMatch(value: Expr.Match, encoder: JsonEncoder) { + val elements = mutableListOf(JsonPrimitive("match")) + // input + elements.add(serializeExpr(value.input, encoder)) + + for ((values, expr) in value.branches) { + if (values.size == 1) { + elements.add(JsonPrimitive(values[0])) + } else { + elements.add(JsonArray(values.map { JsonPrimitive(it) })) + } + elements.add(serializeExpr(expr, encoder)) + } + // else + elements.add(serializeExpr(value.elseExpr, encoder)) + encoder.encodeJsonElement(JsonArray(elements)) + } + + private fun serializeZoomStops(value: Expr.ZoomStops, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("zoom"), + JsonArray(value.stops.map { (zoom, value) -> + JsonArray( + listOf( + JsonPrimitive(zoom), + encoder.json.encodeToJsonElement(valueSerializer, (value as T)) + ) + ) + }) + ) + ) + ) + } + + private fun serializeConstant(value: Expr.Constant, encoder: JsonEncoder) { + encoder.encodeJsonElement(encoder.json.encodeToJsonElement(valueSerializer, value.value)) + } + + private fun serializeRaw(value: Expr.Raw, encoder: JsonEncoder) { + encoder.encodeJsonElement(value.json) + } + + private fun serializeStops(value: Expr.Stops, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonObject( + mapOf( + "stops" to JsonArray(value.stops.map { (stop, value) -> + JsonArray( + listOf( + JsonPrimitive(stop), + encoder.json.encodeToJsonElement(valueSerializer, value) + ) + ) + }) + ) + ) + ) + } + + private fun serializeHas(value: Expr.Has, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("has"), + JsonPrimitive(value.property) + ) + ) + ) + } + + private fun serializeIn(value: Expr.In, encoder: JsonEncoder) { + val evaluatedValue = value.value.evaluate(null, null) + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("in"), + JsonPrimitive(evaluatedValue?.toString() ?: ""), + JsonArray(value.array.map { JsonPrimitive(it) }) + ) + ) + ) + } + + private fun serializeCase(value: Expr.Case, encoder: JsonEncoder) { + val elements = mutableListOf(JsonPrimitive("case")) + value.conditions.forEach { (condition, result) -> + elements.add(serializeExpr(condition, encoder)) + elements.add(serializeExpr(result, encoder)) + } + elements.add(serializeExpr(value.default, encoder)) + encoder.encodeJsonElement(JsonArray(elements)) + } + + private fun serializeCoalesce(value: Expr.Coalesce, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("coalesce") + ) + value.values.map { expr -> + val evaluatedValue = expr.evaluate(null, null) + when (evaluatedValue) { + null -> JsonNull + is T -> encoder.json.encodeToJsonElement(valueSerializer, evaluatedValue) + else -> JsonPrimitive(evaluatedValue.toString()) + } + }) + ) + } + + private fun serializeInterpolate(value: Expr.Interpolate, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("interpolate"), + JsonArray( + listOf( + JsonPrimitive( + when (value.interpolation) { + is InterpolationType.Linear -> "linear" + is InterpolationType.Exponential -> "exponential" + is InterpolationType.Cubic -> "cubic" + is InterpolationType.Step -> "step" + is InterpolationType.CubicBezier -> "cubic-bezier" + } + ) + ) + ), + JsonPrimitive(value.input.toString()) + ) + value.stops.flatMap { (stop, expr) -> + listOf( + JsonPrimitive(stop), + serializeExpr(expr, encoder) + ) + }) + ) + } + + private fun serializeAt(value: Expr.At, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("at"), + JsonPrimitive(value.index), + serializeExpr(value.array, encoder) + ) + ) + ) + } + + private fun serializeLength(value: Expr.Length, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("length"), + serializeExpr(value.array, encoder) + ) + ) + ) + } + + private fun serializeSlice(value: Expr.Slice, encoder: JsonEncoder) { + val elements = mutableListOf( + JsonPrimitive("slice"), + serializeExpr(value.array, encoder), + JsonPrimitive(value.start) + ) + if (value.end != null) { + elements.add(JsonPrimitive(value.end)) + } + encoder.encodeJsonElement(JsonArray(elements)) + } + + private fun serializeNotEquals(value: Expr.NotEquals<*, *>, encoder: JsonEncoder) { + val leftElement = when (val left = value.left) { + is Expr.Get<*> -> JsonArray( + listOf( + JsonPrimitive("get"), + encoder.json.encodeToJsonElement(valueSerializer, (value as T)) + ) + ) + + else -> JsonPrimitive(left.evaluate(null, null)?.toString() ?: "") + } + + val rightElement = when (val right = value.right) { + is Expr.Get<*> -> JsonArray( + listOf( + JsonPrimitive("get"), + encoder.json.encodeToJsonElement(valueSerializer, (value as T)) + ) + ) + + else -> JsonPrimitive(right.evaluate(null, null)?.toString() ?: "") + } + + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("!="), + leftElement, + rightElement + ) + ) + ) + } + + private fun serializeEquals(value: Expr.Equals<*, *>, encoder: JsonEncoder) { + val leftElement = when (val left = value.left) { + is Expr.Get<*> -> JsonArray( + listOf( + JsonPrimitive("get"), + encoder.json.encodeToJsonElement(valueSerializer, (value as T)) + ) + ) + + else -> JsonPrimitive(left.evaluate(null, null)?.toString() ?: "") + } + + val rightElement = when (val right = value.right) { + is Expr.Get<*> -> JsonArray( + listOf( + JsonPrimitive("get"), + encoder.json.encodeToJsonElement(valueSerializer, (value as T)) + ) + ) + + else -> JsonPrimitive(right.evaluate(null, null)?.toString() ?: "") + } + + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("=="), + leftElement, + rightElement + ) + ) + ) + } + + private fun serializeExpr(expr: Expr<@Contextual Any?>, jsonEncoder: JsonEncoder): JsonElement { + return when (expr) { + is Expr.Get -> JsonArray( + listOf( + JsonPrimitive("get"), + jsonEncoder.json.encodeToJsonElement(valueSerializer, (expr as T)) + ) + ) + + is Expr.Constant -> when (val value = expr.value) { + is String -> JsonPrimitive(value) + is Number -> JsonPrimitive(value) + is Boolean -> JsonPrimitive(value) + else -> JsonNull + } + + is Expr.Concat<*> -> JsonArray( + listOf( + JsonPrimitive("concat"), + serializeExpr(expr.left, jsonEncoder), + serializeExpr(expr.right, jsonEncoder) + ) + ) + + else -> JsonNull + } + } + + private fun serializeLessThan(expr: Expr.LessThan, jsonEncoder: JsonEncoder) { + jsonEncoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("<"), + serializeExpr(expr.left, jsonEncoder), + serializeExpr(expr.right, jsonEncoder) + ) + ) + ) + } + + private fun serializeLessThanOrEqual(expr: Expr.LessThanOrEqual, jsonEncoder: JsonEncoder) { + jsonEncoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("<="), + serializeExpr(expr.left, jsonEncoder), + serializeExpr(expr.right, jsonEncoder) + ) + ) + ) + } + + private fun serializeGreaterThan(expr: Expr.GreaterThan, jsonEncoder: JsonEncoder) { + jsonEncoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive(">"), + serializeExpr(expr.left, jsonEncoder), + serializeExpr(expr.right, jsonEncoder) + ) + ) + ) + } + + private fun serializeGreaterThanOrEqual(expr: Expr.GreaterThanOrEqual, jsonEncoder: JsonEncoder) { + jsonEncoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive(">="), + serializeExpr(expr.left, jsonEncoder), + serializeExpr(expr.right, jsonEncoder) + ) + ) + ) + } + + private fun serializeAll(value: Expr.All, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("all") + ) + value.conditions.map { condition -> + serializeExpr(condition, encoder) + }) + ) + } + + private fun serializeAnyOf(value: Expr.AnyOf, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("any") + ) + value.conditions.map { condition -> + serializeExpr(condition, encoder) + }) + ) + } + + private fun serializeNot(value: Expr.Not, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("!"), + serializeExpr(value.condition, encoder) + ) + ) + ) + } + + private fun serializeModulo(value: Expr.Modulo, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("%"), + serializeExpr(value.left, encoder), + serializeExpr(value.right, encoder) + ) + ) + ) + } + + private fun serializePower(value: Expr.Power, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("^"), + serializeExpr(value.left, encoder), + serializeExpr(value.right, encoder) + ) + ) + ) + } + + private fun serializeAbs(value: Expr.Abs, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("abs"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeAcos(value: Expr.Acos, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("acos"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeAsin(value: Expr.Asin, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("asin"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeAtan(value: Expr.Atan, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("atan"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeCeil(value: Expr.Ceil, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("ceil"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeCos(value: Expr.Cos, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("cos"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeFloor(value: Expr.Floor, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("floor"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeLn(value: Expr.Ln, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("ln"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeLog10(value: Expr.Log10, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("log10"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeMax(value: Expr.Max, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("max"), + serializeExpr(value.left, encoder), + serializeExpr(value.right, encoder) + ) + ) + ) + } + + private fun serializeMin(value: Expr.Min, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("min"), + serializeExpr(value.left, encoder), + serializeExpr(value.right, encoder) + ) + ) + ) + } + + private fun serializeRound(value: Expr.Round, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("round"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeSin(value: Expr.Sin, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("sin"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeSqrt(value: Expr.Sqrt, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("sqrt"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeTan(value: Expr.Tan, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("tan"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeConcat(value: Expr.Concat, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("concat"), + serializeExpr(value.left, encoder), + serializeExpr(value.right, encoder) + ) + ) + ) + } + + private fun serializeIndexOf(value: Expr.IndexOf, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("index-of"), + serializeExpr(value.array, encoder), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeDowncase(value: Expr.Downcase, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("downcase"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeUpcase(value: Expr.Upcase, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("upcase"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeToBoolean(value: Expr.ToBoolean, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("to-boolean"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + private fun serializeToStringExpr(value: Expr.ToString<*>, encoder: JsonEncoder) { + encoder.encodeJsonElement( + JsonArray( + listOf( + JsonPrimitive("to-string"), + serializeExpr(value.value, encoder) + ) + ) + ) + } + + override fun serialize(encoder: Encoder, value: Expr) { + val jsonEncoder = + encoder as? JsonEncoder ?: throw SerializationException("This serializer can only be used with Json") + + // FIXME not working + when (value) { + is Expr.Get -> serializeGet(value, jsonEncoder) + is Expr.Match -> serializeMatch(value, jsonEncoder) + is Expr.ZoomStops -> serializeZoomStops(value, jsonEncoder) + is Expr.Constant -> serializeConstant(value, jsonEncoder) + is Expr.Raw -> serializeRaw(value, jsonEncoder) + is Expr.Has<*> -> serializeHas(value as Expr.Has, jsonEncoder) + is Expr.In<*> -> serializeIn(value as Expr.In, jsonEncoder) + is Expr.Case -> serializeCase(value, jsonEncoder) + is Expr.Coalesce -> serializeCoalesce(value, jsonEncoder) + is Expr.At -> serializeAt(value, jsonEncoder) + is Expr.Length<*> -> serializeLength(value as Expr.Length, jsonEncoder) + is Expr.Slice<*> -> serializeSlice(value as Expr.Slice, jsonEncoder) + is Expr.NotEquals<*, *> -> serializeNotEquals(value as Expr.NotEquals<*, *>, jsonEncoder) + is Expr.Equals<*, *> -> serializeEquals(value as Expr.Equals<*, *>, jsonEncoder) + is Expr.LessThan -> serializeLessThan(value, jsonEncoder) + is Expr.LessThanOrEqual -> serializeLessThanOrEqual(value, jsonEncoder) + is Expr.GreaterThan -> serializeGreaterThan(value, jsonEncoder) + is Expr.GreaterThanOrEqual -> serializeGreaterThanOrEqual(value, jsonEncoder) + + is Expr.Stops -> serializeStops(value, jsonEncoder) + is Expr.Interpolate -> serializeInterpolate(value, jsonEncoder) + is Expr.All -> serializeAll(value, jsonEncoder) + is Expr.AnyOf -> serializeAnyOf(value, jsonEncoder) + is Expr.Not -> serializeNot(value, jsonEncoder) + is Expr.Modulo -> serializeModulo(value, jsonEncoder) + is Expr.Power -> serializePower(value, jsonEncoder) + is Expr.Abs -> serializeAbs(value, jsonEncoder) + is Expr.Acos -> serializeAcos(value, jsonEncoder) + is Expr.Asin -> serializeAsin(value, jsonEncoder) + is Expr.Atan -> serializeAtan(value, jsonEncoder) + is Expr.Ceil -> serializeCeil(value, jsonEncoder) + is Expr.Cos -> serializeCos(value, jsonEncoder) + is Expr.Floor -> serializeFloor(value, jsonEncoder) + is Expr.Ln -> serializeLn(value, jsonEncoder) + is Expr.Log10 -> serializeLog10(value, jsonEncoder) + is Expr.Max -> serializeMax(value, jsonEncoder) + is Expr.Min -> serializeMin(value, jsonEncoder) + is Expr.Round -> serializeRound(value, jsonEncoder) + is Expr.Sin -> serializeSin(value, jsonEncoder) + is Expr.Sqrt -> serializeSqrt(value, jsonEncoder) + is Expr.Tan -> serializeTan(value, jsonEncoder) + is Expr.Concat<*> -> serializeConcat(value as Expr.Concat, jsonEncoder) + is Expr.IndexOf<*> -> serializeIndexOf(value as Expr.IndexOf, jsonEncoder) + is Expr.Downcase -> serializeDowncase(value, jsonEncoder) + is Expr.Upcase -> serializeUpcase(value, jsonEncoder) + is Expr.ToBoolean -> serializeToBoolean(value, jsonEncoder) + is Expr.ToString<*> -> serializeToStringExpr(value, jsonEncoder) + is Expr.Zoom -> jsonEncoder.encodeJsonElement(JsonArray(listOf(JsonPrimitive("zoom")))) + is Expr.Step<*> -> jsonEncoder.encodeJsonElement(JsonArray(listOf(JsonPrimitive("step")))) + is Expr.ToNumber -> jsonEncoder.encodeJsonElement(JsonArray(listOf(JsonPrimitive("to-number")))) + is Expr.Image -> jsonEncoder.encodeJsonElement(JsonArray(listOf(JsonPrimitive("to-number")))) + } + } + + private fun extractNestedExpressionChunk(from: JsonArray, startIndex: Int): Pair { + if (from[startIndex] is JsonPrimitive) { + return from[startIndex] to 1 + } + if (from[startIndex] is JsonArray) { + val arr = from[startIndex] as JsonArray + return arr to 1 + } + throw SerializationException("Unknown element type in extractNestedExpressionChunk: ${from[startIndex]}") + } + + private fun deserializeGet(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Get { + if (element.size != 2) throw SerializationException("Invalid get expression") + return Expr.Get(deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true)) + } + + private fun deserializeToNumber( + element: JsonArray, + jsonDecoder: JsonDecoder, + isNested: Boolean + ): Expr { + if (element.size != 2) throw SerializationException("Invalid to-number expression") + val inputExpr = deserializeExpr(element[1], jsonDecoder, isNested) + return Expr.ToNumber(inputExpr) + } + + private fun deserializeMatch(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Match { + if (element.size < 4) throw SerializationException("Invalid match expression") + val input = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + val branches = mutableListOf, Expr>>() + var i = 2 + while (i < element.size - 1) { + val valuesElement = element[i] + val resultElement = element[i + 1] + val values = when (valuesElement) { + is JsonArray -> valuesElement.map { it.jsonPrimitive.content } + is JsonPrimitive -> listOf(valuesElement.content) + else -> throw SerializationException("Invalid match value type") + } + val result = deserializeExpr( + element = resultElement, + jsonDecoder = jsonDecoder, + isNested = resultElement !is JsonPrimitive + ) as Expr + branches.add(values to result) + i += 2 + } + val elseElement = element.last() + val elseExpr = deserializeExpr( + element = elseElement, + jsonDecoder = jsonDecoder, + isNested = elseElement !is JsonPrimitive + ) as Expr + return Expr.Match(input, branches, elseExpr) + } + + private fun deserializeZoomStops( + element: JsonArray, + jsonDecoder: JsonDecoder, + isNested: Boolean + ): Expr.ZoomStops { + if (element.size != 2) throw SerializationException("Invalid zoom expression") + val stops: List>> = element[1].jsonArray.map { stop -> + if (stop !is JsonArray || stop.size != 2) throw SerializationException("Invalid stop format") + val zoom: Double = stop[0].jsonPrimitive.content.toDouble() + val value: Expr<@Contextual Any?> = deserializeExpr(element = stop[1], jsonDecoder = jsonDecoder, isNested = true) + Pair( + first = zoom, + second = value, + ) + } + return Expr.ZoomStops(stops) + } + + private fun deserializeHas(element: JsonArray): Expr.Has { + if (element.size != 2) throw SerializationException("Invalid has expression") + return Expr.Has(element[1].jsonPrimitive.content) + } + + private fun deserializeIn(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.In { + if (element.size != 3) throw SerializationException("Invalid in expression $element") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + val array = (element[2] as JsonArray).map { it.jsonPrimitive.content } + return Expr.In(value, array) + } + + private fun deserializeCase(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Case { + if (element.size < 4) throw SerializationException("Invalid case expression") + val conditions = mutableListOf, Expr>>() + for (i in 1 until element.size - 1 step 2) { + val condition = deserializeExpr(element = element[i], jsonDecoder = jsonDecoder, isNested = true) + val resultEl = element[i + 1] + val result = deserializeExpr(element = resultEl, jsonDecoder = jsonDecoder, isNested = resultEl !is JsonPrimitive) as Expr + conditions.add(condition to result) + } + val defaultEl = element.last() + val default = deserializeExpr(element = defaultEl, jsonDecoder = jsonDecoder, isNested = defaultEl !is JsonPrimitive) as Expr + return Expr.Case(conditions, default) + } + + private fun deserializeCoalesce(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Coalesce { + if (element.size < 2) throw SerializationException("Invalid coalesce expression") + val values = element.drop(1).map { valueElement -> + deserializeExpr(element = valueElement, jsonDecoder = jsonDecoder, isNested = valueElement !is JsonPrimitive) as Expr + } + return Expr.Coalesce(values) + } + + private fun deserializeInterpolate( + element: JsonArray, + jsonDecoder: JsonDecoder, + isNested: Boolean + ): Expr.Interpolate { + if (element.size < 4) throw SerializationException("Invalid interpolate expression") + + val interpolationType = when (val interpolationElement = element[1]) { + is JsonPrimitive -> when (interpolationElement.content) { + "linear" -> InterpolationType.Linear + "exponential" -> InterpolationType.Exponential(1.0) // TODO + "cubic" -> InterpolationType.Cubic + "step" -> InterpolationType.Step + else -> throw SerializationException("Invalid interpolation type") + } + + is JsonArray -> when (interpolationElement[0].jsonPrimitive.content) { + "linear" -> InterpolationType.Linear + "exponential" -> InterpolationType.Exponential(interpolationElement[1].jsonPrimitive.double) + "cubic" -> InterpolationType.Cubic + "step" -> InterpolationType.Step + "cubic-bezier" -> InterpolationType.CubicBezier( + x1 = interpolationElement[1].jsonPrimitive.double, + y1 = interpolationElement[2].jsonPrimitive.double, + x2 = interpolationElement[3].jsonPrimitive.double, + y2 = interpolationElement[4].jsonPrimitive.double + ) + else -> throw SerializationException("Invalid interpolation type") + } + + else -> throw SerializationException("Invalid interpolation type") + } + + val input = element[2].let { inputElement -> + val isZoom = (inputElement is JsonPrimitive && inputElement.content == "zoom") || + (inputElement is JsonArray && inputElement.size == 1 && inputElement[0].let { it is JsonPrimitive && it.content == "zoom" }) + if (isZoom) { + Expr.Zoom + } else if (inputElement is JsonArray && isExpr(inputElement)) { + deserializeExpr(element = inputElement, jsonDecoder = jsonDecoder, isNested = true) as Expr + } else { + deserializeConstant(inputElement, jsonDecoder, true) + } + } + + val stops = mutableListOf>>() + var i = 3 + while (i < element.size) { + val stop = element[i++].jsonPrimitive.double + val (valueElement, consumed) = extractNestedExpressionChunk(element, i) + val expr = when (valueElement) { + is JsonPrimitive -> deserializeConstant(valueElement, jsonDecoder, isNested = isNested) + is JsonArray -> { + if (isExpr(valueElement)) { + deserializeExpr(valueElement, jsonDecoder, isNested = true) as Expr + } else { + deserializeConstant(valueElement, jsonDecoder, isNested = isNested) + } + } + + else -> throw SerializationException("Invalid stop value type") + } + stops.add(stop to expr) + i += consumed + } + + return Expr.Interpolate( + interpolation = interpolationType, + input = input, + stops = stops + ) + } + + private fun deserializeAt(element: JsonArray, jsonDecoder: JsonDecoder): Expr.At { + if (element.size != 3) throw SerializationException("Invalid at expression") + val index = element[1].jsonPrimitive.content.toInt() + val array = deserializeExpr(element[2], jsonDecoder, isNested = true) + return Expr.At(index, array) + } + + private fun deserializeLength(element: JsonArray, jsonDecoder: JsonDecoder): Expr.Length { + if (element.size != 2) throw SerializationException("Invalid length expression") + val array = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) + return Expr.Length(array) + } + + private fun deserializeSlice(element: JsonArray, jsonDecoder: JsonDecoder): Expr.Slice { + if (element.size < 3 || element.size > 4) throw SerializationException("Invalid slice expression") + val array = deserializeExpr(element[1], jsonDecoder, isNested = true) + val start = element[2].jsonPrimitive.content.toInt() + val end = if (element.size == 4) element[3].jsonPrimitive.content.toInt() else null + return Expr.Slice(array, start, end) + } + + private fun deserializeNotEquals( + element: JsonArray, + jsonDecoder: JsonDecoder, + isNested: Boolean + ): Expr.NotEquals<*, *> { + if (element.size != 3) throw SerializationException("Invalid not equals expression") + val left = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) + val right = deserializeExpr(element = element[2], jsonDecoder = jsonDecoder, isNested = true) + return Expr.NotEquals(left, right) + } + + private fun deserializeEquals(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Equals<*, *> { + if (element.size != 3) throw SerializationException("Invalid equals expression") + val left = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) + val right = deserializeExpr(element = element[2], jsonDecoder = jsonDecoder, isNested = true) + return Expr.Equals(left, right) + } + + private fun deserializeLessThan(input: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr<@Contextual Any?> { + if (input.size != 3) throw SerializationException("Invalid 'less than' expression format") + return Expr.LessThan( + deserializeExpr(element = input[1], jsonDecoder = jsonDecoder, isNested = true), + deserializeExpr(element = input[2], jsonDecoder = jsonDecoder, isNested = true) + ) as Expr + } + + private fun deserializeLessThanOrEqual(input: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr<@Contextual Any?> { + if (input.size != 3) throw SerializationException("Invalid 'less than or equal' expression format") + return Expr.LessThanOrEqual( + deserializeExpr(element = input[1], jsonDecoder = jsonDecoder, isNested = true), + deserializeExpr(element = input[2], jsonDecoder = jsonDecoder, isNested = true) + ) as Expr + } + + private fun deserializeGreaterThan(input: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr<@Contextual Any?> { + if (input.size != 3) throw SerializationException("Invalid 'greater than' expression format") + return Expr.GreaterThan( + deserializeExpr(element = input[1], jsonDecoder = jsonDecoder, isNested = true), + deserializeExpr(element = input[2], jsonDecoder = jsonDecoder, isNested = true) + ) as Expr + } + + private fun deserializeGreaterThanOrEqual(input: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr<@Contextual Any?> { + if (input.size != 3) throw SerializationException("Invalid 'greater than or equal' expression format") + return Expr.GreaterThanOrEqual( + deserializeExpr(element = input[1], jsonDecoder = jsonDecoder, isNested = true), + deserializeExpr(element = input[2], jsonDecoder = jsonDecoder, isNested = true) + ) as Expr + } + + private fun deserializeAll(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.All { + if (element.size < 2) throw SerializationException("Invalid all expression") + val conditions = element.drop(1).map { conditionElement -> + deserializeExpr(element = conditionElement, jsonDecoder = jsonDecoder, isNested = true) as Expr + } + return Expr.All(conditions) + } + + private fun deserializeAnyOf(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.AnyOf { + if (element.size < 2) throw SerializationException("Invalid any expression") + val conditions = element.drop(1).map { conditionElement -> + deserializeExpr(element = conditionElement, jsonDecoder = jsonDecoder, isNested = true) as Expr + } + return Expr.AnyOf(conditions) + } + + private fun deserializeNot(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Not { + if (element.size != 2) throw SerializationException("Invalid not expression") + val condition = + deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Not(condition) + } + + private fun deserializeModulo(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Modulo { + if (element.size != 3) throw SerializationException("Invalid modulo expression") + val left = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + val right = deserializeExpr(element = element[2], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Modulo(left, right) + } + + private fun deserializePower(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Power { + if (element.size != 3) throw SerializationException("Invalid power expression") + val left = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + val right = deserializeExpr(element = element[2], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Power(left, right) + } + + private fun deserializeAbs(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Abs { + if (element.size != 2) throw SerializationException("Invalid abs expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Abs(value) + } + + private fun deserializeAcos(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Acos { + if (element.size != 2) throw SerializationException("Invalid acos expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Acos(value) + } + + private fun deserializeAsin(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Asin { + if (element.size != 2) throw SerializationException("Invalid asin expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Asin(value) + } + + private fun deserializeAtan(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Atan { + if (element.size != 2) throw SerializationException("Invalid atan expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Atan(value) + } + + private fun deserializeCeil(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Ceil { + if (element.size != 2) throw SerializationException("Invalid ceil expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Ceil(value) + } + + private fun deserializeCos(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Cos { + if (element.size != 2) throw SerializationException("Invalid cos expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Cos(value) + } + + private fun deserializeFloor(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Floor { + if (element.size != 2) throw SerializationException("Invalid floor expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Floor(value) + } + + private fun deserializeLn(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Ln { + if (element.size != 2) throw SerializationException("Invalid ln expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Ln(value) + } + + private fun deserializeLog10(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Log10 { + if (element.size != 2) throw SerializationException("Invalid log10 expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Log10(value) + } + + private fun deserializeMax(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Max { + if (element.size != 3) throw SerializationException("Invalid max expression") + val left = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + val right = deserializeExpr(element = element[2], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Max(left, right) + } + + private fun deserializeMin(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Min { + if (element.size != 3) throw SerializationException("Invalid min expression") + val left = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + val right = deserializeExpr(element = element[2], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Min(left, right) + } + + private fun deserializeRound(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Round { + if (element.size != 2) throw SerializationException("Invalid round expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Round(value) + } + + private fun deserializeSin(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Sin { + if (element.size != 2) throw SerializationException("Invalid sin expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Sin(value) + } + + private fun deserializeSqrt(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Sqrt { + if (element.size != 2) throw SerializationException("Invalid sqrt expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Sqrt(value) + } + + private fun deserializeTan(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Tan { + if (element.size != 2) throw SerializationException("Invalid tan expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Tan(value) + } + + private fun deserializeConcat(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Concat { + if (element.size < 3) throw SerializationException("Invalid concat expression: needs at least 2 arguments") + val args = (1 until element.size).map { i -> + deserializeExpr(element = element[i], jsonDecoder = jsonDecoder, isNested = true) + } + @Suppress("UNCHECKED_CAST") + return args.drop(1).fold(args.first()) { acc, expr -> Expr.Concat(acc, expr) } as Expr.Concat + } + + private fun deserializeIndexOf(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.IndexOf { + if (element.size != 3) throw SerializationException("Invalid index-of expression") + val array = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) + val value = deserializeExpr(element = element[2], jsonDecoder = jsonDecoder, isNested = true) + return Expr.IndexOf(array, value) + } + + private fun deserializeDowncase(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Downcase { + if (element.size != 2) throw SerializationException("Invalid downcase expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Downcase(value) + } + + private fun deserializeUpcase(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Upcase { + if (element.size != 2) throw SerializationException("Invalid upcase expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.Upcase(value) + } + + private fun deserializeToBoolean(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.ToBoolean { + if (element.size != 2) throw SerializationException("Invalid to-boolean expression") + val value = deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + return Expr.ToBoolean(value) + } + + private fun deserializeToString(array: JsonArray, decoder: JsonDecoder, isNested: Boolean): Expr.ToString<*> { + require(array.size == 2) { "to-string expression must have exactly one argument" } + val value = deserializeExpr(element = array[1], jsonDecoder = decoder, isNested = true) as Expr + return Expr.ToString(value) + } + + private fun deserializeLiteral(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr { + if (element.size != 2) throw SerializationException("Invalid literal expression") + return deserializeExpr(element = element[1], jsonDecoder = jsonDecoder, isNested = true) as Expr + } + + private fun deserializeConstant( + element: JsonElement, + jsonDecoder: JsonDecoder, + isNested: Boolean = false + ): Expr.Constant { + return when (element) { + is JsonPrimitive -> { + if (isNested) { + if (element.isString) { + return Expr.Constant(element.content) as Expr.Constant + } + val booleanOrNull = element.booleanOrNull + if (booleanOrNull != null) { + return Expr.Constant(booleanOrNull) as Expr.Constant + } + + val doubleOrNull = element.doubleOrNull + if (doubleOrNull != null) { + return Expr.Constant(doubleOrNull) as Expr.Constant + } + + error("cant deserialize an element $element") + } else { + return Expr.Constant(jsonDecoder.json.decodeFromJsonElement(valueSerializer, element)) + } + } + + is JsonArray -> { + Expr.Constant(jsonDecoder.json.decodeFromJsonElement(valueSerializer, element)) + } + + else -> error("Unsupported constant type") + } as Expr.Constant + } + + private fun deserializeImage( + element: JsonArray, + jsonDecoder: JsonDecoder, + isNested: Boolean + ): Expr { + if (element.size != 2) throw SerializationException("Invalid image expression") + val nested = element[1] + val inputExpr = deserializeExpr(nested, jsonDecoder, isNested = nested is JsonArray && isExpr(nested)) + return Expr.Image(inputExpr) + } + + // ["format", value1, opts1, value2, opts2, ...] — values at odd indices, option objects at even indices. + // Extracts each value, concatenates them, or returns null if empty. + private fun deserializeFormat(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr<@Contextual Any?> { + val parts = (1 until element.size step 2) + .filter { element[it] !is JsonObject } + .map { deserializeExpr(element = element[it], jsonDecoder = jsonDecoder, isNested = true) } + return parts.firstOrNull() ?: Expr.Constant(null) + } + + private fun deserializeStep(element: JsonArray, jsonDecoder: JsonDecoder, isNested: Boolean): Expr.Step { + if (element.size < 3) throw SerializationException("Invalid step expression") + + val input = when (val inputElement = element[1]) { + is JsonArray -> { + when (inputElement[0].jsonPrimitive.content) { + "zoom" -> Expr.Zoom as Expr + else -> deserializeExpr( + element = inputElement, + jsonDecoder = jsonDecoder, + isNested = true + ) as Expr + } + } + + is JsonPrimitive -> deserializeConstant(inputElement, jsonDecoder, true) + else -> throw SerializationException("Invalid input expression") + } + + val defaultEl = element[2] + val default = deserializeExpr(element = defaultEl, jsonDecoder = jsonDecoder, isNested = defaultEl !is JsonPrimitive) as Expr + + val stops = mutableListOf>>() + var i = 3 + while (i < element.size - 1) { + val stop = element[i++].jsonPrimitive.double + val valueEl = element[i++] + val value = deserializeExpr(element = valueEl, jsonDecoder = jsonDecoder, isNested = valueEl !is JsonPrimitive) as Expr + stops.add(stop to value) + } + + return Expr.Step(input as Expr, default, stops) + } + + fun deserializeExpr(element: JsonElement, jsonDecoder: JsonDecoder, isNested: Boolean): Expr<@Contextual Any?> { + return when (element) { + is JsonPrimitive -> deserializeConstant(element = element, jsonDecoder = jsonDecoder, isNested = isNested) + is JsonObject -> { + if ("stops" in element || "type" in element || "property" in element) { + deserializeExpr( + element = normalizeLegacyExpression(element), + jsonDecoder = jsonDecoder, + isNested = true + ) + } else { + error("Unknown object expression: $element") + } + } + + is JsonArray -> { + if (!isExpr(element)) return deserializeConstant( + element = element, + jsonDecoder = jsonDecoder, + isNested = isNested + ) + val operator = element.firstOrNull()?.jsonPrimitive?.content + + when (operator) { + "get" -> deserializeGet(element, jsonDecoder, isNested) + "match" -> deserializeMatch(element, jsonDecoder, isNested) + "zoom" -> deserializeZoomStops(element, jsonDecoder, isNested) + "interpolate" -> deserializeInterpolate(element, jsonDecoder, isNested) + "has" -> deserializeHas(element) + "in" -> deserializeIn(element, jsonDecoder, isNested) + "case" -> deserializeCase(element, jsonDecoder, isNested) + "coalesce" -> deserializeCoalesce(element, jsonDecoder, isNested) + "at" -> deserializeAt(element, jsonDecoder) + "length" -> deserializeLength(element, jsonDecoder) + "slice" -> deserializeSlice(element, jsonDecoder) + "!=" -> deserializeNotEquals(element, jsonDecoder, isNested) + "==" -> deserializeEquals(element, jsonDecoder, isNested) + "<" -> deserializeLessThan(element, jsonDecoder, isNested) + "<=" -> deserializeLessThanOrEqual(element, jsonDecoder, isNested) + ">" -> deserializeGreaterThan(element, jsonDecoder, isNested) + ">=" -> deserializeGreaterThanOrEqual(element, jsonDecoder, isNested) + "all" -> deserializeAll(element, jsonDecoder, isNested) + "any" -> deserializeAnyOf(element, jsonDecoder, isNested) + "!" -> deserializeNot(element, jsonDecoder, isNested) + "%" -> deserializeModulo(element, jsonDecoder, isNested) + "^" -> deserializePower(element, jsonDecoder, isNested) + "abs" -> deserializeAbs(element, jsonDecoder, isNested) + "acos" -> deserializeAcos(element, jsonDecoder, isNested) + "asin" -> deserializeAsin(element, jsonDecoder, isNested) + "atan" -> deserializeAtan(element, jsonDecoder, isNested) + "ceil" -> deserializeCeil(element, jsonDecoder, isNested) + "cos" -> deserializeCos(element, jsonDecoder, isNested) + "floor" -> deserializeFloor(element, jsonDecoder, isNested) + "ln" -> deserializeLn(element, jsonDecoder, isNested) + "log10" -> deserializeLog10(element, jsonDecoder, isNested) + "max" -> deserializeMax(element, jsonDecoder, isNested) + "min" -> deserializeMin(element, jsonDecoder, isNested) + "round" -> deserializeRound(element, jsonDecoder, isNested) + "sin" -> deserializeSin(element, jsonDecoder, isNested) + "sqrt" -> deserializeSqrt(element, jsonDecoder, isNested) + "tan" -> deserializeTan(element, jsonDecoder, isNested) + "stops" -> deserializeZoomStops(element, jsonDecoder, isNested) + "concat" -> deserializeConcat(element, jsonDecoder, isNested) + "index-of" -> deserializeIndexOf(element, jsonDecoder, isNested) + "downcase" -> deserializeDowncase(element, jsonDecoder, isNested) + "upcase" -> deserializeUpcase(element, jsonDecoder, isNested) + "to-boolean" -> deserializeToBoolean(element, jsonDecoder, isNested) + "to-string" -> deserializeToString(element, jsonDecoder, isNested) + "literal" -> deserializeLiteral(element, jsonDecoder, isNested) + "step" -> deserializeStep(element, jsonDecoder, isNested) + "to-number" -> deserializeToNumber(element, jsonDecoder, isNested) + "image" -> deserializeImage(element, jsonDecoder, isNested) + "format" -> deserializeFormat(element, jsonDecoder, isNested) + else -> Expr.Constant(null) + } + } + } + } + + override fun deserialize(decoder: Decoder): Expr { + val jsonDecoder = + decoder as? JsonDecoder ?: throw SerializationException("This serializer can only be used with Json") + val element = jsonDecoder.decodeJsonElement() + + @Suppress("UNCHECKED_CAST") + return deserializeExpr(element = element, jsonDecoder = jsonDecoder, isNested = false) as Expr + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExpressionOrValueSerializer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExpressionOrValueSerializer.kt new file mode 100644 index 00000000..5de3c288 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExpressionOrValueSerializer.kt @@ -0,0 +1,83 @@ +package ovh.plrapps.mapcompose.vector.spec.style.serializers + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.* +import kotlinx.serialization.descriptors.SerialDescriptor +import kotlinx.serialization.descriptors.buildClassSerialDescriptor +import kotlinx.serialization.encoding.Decoder +import kotlinx.serialization.encoding.Encoder +import kotlinx.serialization.json.* +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import ovh.plrapps.mapcompose.vector.spec.style.utils.ColorParser +import ovh.plrapps.mapcompose.vector.spec.style.utils.normalizeLegacyExpression + +@OptIn(ExperimentalSerializationApi::class) +@Serializer(forClass = ExpressionOrValue::class) +class ExpressionOrValueSerializer( + private val valueSerializer: KSerializer +) : KSerializer> { + + private val exprSerializer = ExprSerializerFactory.create(valueSerializer) + + override val descriptor: SerialDescriptor = buildClassSerialDescriptor("ExpressionOrValue") + + @OptIn(ExperimentalSerializationApi::class) + override fun serialize(encoder: Encoder, value: ExpressionOrValue) { + val jsonEncoder = + encoder as? JsonEncoder ?: throw SerializationException("This serializer can only be used with Json") + + when (value) { + is ExpressionOrValue.Value -> { + when (valueSerializer) { + is ColorSerializer -> { + jsonEncoder.encodeJsonElement(JsonUnquotedLiteral(ColorParser.colorToHexString(value.value as Color))) + } + + else -> { + jsonEncoder.encodeJsonElement( + jsonEncoder.json.encodeToJsonElement( + valueSerializer, + value.value + ) + ) + } + } + } + + is ExpressionOrValue.Expression -> { + jsonEncoder.encodeJsonElement(jsonEncoder.json.encodeToJsonElement(exprSerializer, value.expr)) + } + } + } + + override fun deserialize(decoder: Decoder): ExpressionOrValue { + val jsonDecoder = + decoder as? JsonDecoder ?: throw SerializationException("This serializer can only be used with Json") + val element = jsonDecoder.decodeJsonElement() + val isExpression = ExpressionOrValue.isExpression(element) + return if (isExpression) { + ExpressionOrValue.Expression( + jsonDecoder.json.decodeFromJsonElement( + deserializer = exprSerializer, + element = if (element is JsonObject) normalizeLegacyExpression(element) else element + ), + source = element.toString() + ) + } else { + when (valueSerializer) { + is ColorSerializer -> { + val color = ColorParser.parseColorStringOrNull(element.jsonPrimitive.content) + ?: throw SerializationException("Invalid color format ${element.jsonPrimitive.content}") + ExpressionOrValue.Value(color as T, source = element.toString()) + } + + else -> { + ExpressionOrValue.Value( + jsonDecoder.json.decodeFromJsonElement(valueSerializer, element), + source = element.toString() + ) + } + } + } + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/sky/SkyLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/sky/SkyLayout.kt new file mode 100644 index 00000000..89e85415 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/sky/SkyLayout.kt @@ -0,0 +1,9 @@ +package ovh.plrapps.mapcompose.vector.spec.style.sky + +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface +import kotlinx.serialization.Serializable + +@Serializable +data class SkyLayout( + override val visibility: String? = "visible" +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/sky/SkyPaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/sky/SkyPaint.kt new file mode 100644 index 00000000..96da218e --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/sky/SkyPaint.kt @@ -0,0 +1,32 @@ +package ovh.plrapps.mapcompose.vector.spec.style.sky + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValueColorSerializer + +@Serializable +data class SkyPaint( + @SerialName("sky-atmosphere-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val skyAtmosphereColor: ExpressionOrValue? = null, + @SerialName("sky-atmosphere-halo-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val skyAtmosphereHaloColor: ExpressionOrValue? = null, + @SerialName("sky-atmosphere-sun-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val skyAtmosphereSunColor: ExpressionOrValue? = null, + @SerialName("sky-atmosphere-sun-intensity") + val skyAtmosphereSunIntensity: ExpressionOrValue? = null, + @SerialName("sky-gradient") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val skyGradient: ExpressionOrValue? = null, + @SerialName("sky-gradient-radius") + val skyGradientRadius: ExpressionOrValue? = null, + @SerialName("sky-opacity") + val skyOpacity: ExpressionOrValue? = null, + @SerialName("sky-type") + val skyType: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/SymbolLayout.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/SymbolLayout.kt new file mode 100644 index 00000000..4b46e83b --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/SymbolLayout.kt @@ -0,0 +1,140 @@ +package ovh.plrapps.mapcompose.vector.spec.style.symbol + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.LayoutInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue + +@Serializable +data class SymbolLayout( + override val visibility: String? = "visible", + + @SerialName("icon-allow-overlap") + val iconAllowOverlap: ExpressionOrValue? = null, + + @SerialName("icon-ignore-placement") + val iconIgnorePlacement: ExpressionOrValue? = null, + + @SerialName("icon-optional") + val iconOptional: ExpressionOrValue? = null, + + @SerialName("icon-rotation-alignment") + val iconRotationAlignment: ExpressionOrValue? = null, + + @SerialName("icon-size") + val iconSize: ExpressionOrValue? = null, + + @SerialName("icon-text-fit") + val iconTextFit: ExpressionOrValue? = null, + + @SerialName("icon-text-fit-padding") + val iconTextFitPadding: ExpressionOrValue>? = null, + + @SerialName("icon-image") + val iconImage: ExpressionOrValue? = null, + + @SerialName("icon-rotate") + val iconRotate: ExpressionOrValue? = null, + + @SerialName("icon-padding") + val iconPadding: ExpressionOrValue? = null, + + @SerialName("icon-keep-upright") + val iconKeepUpright: ExpressionOrValue? = null, + + @SerialName("icon-offset") + val iconOffset: ExpressionOrValue>? = null, + + @SerialName("icon-anchor") + val iconAnchor: ExpressionOrValue? = null, + + @SerialName("icon-pitch-alignment") + val iconPitchAlignment: ExpressionOrValue? = null, + + @SerialName("text-pitch-alignment") + val textPitchAlignment: ExpressionOrValue? = null, + + @SerialName("text-rotation-alignment") + val textRotationAlignment: ExpressionOrValue? = null, + + @SerialName("text-field") + val textField: ExpressionOrValue? = null, + + @SerialName("text-font") + val textFont: ExpressionOrValue>? = null, + + @SerialName("text-size") + val textSize: ExpressionOrValue? = null, + + @SerialName("text-max-width") + val textMaxWidth: ExpressionOrValue? = null, + + @SerialName("text-line-height") + val textLineHeight: ExpressionOrValue? = null, + + @SerialName("text-letter-spacing") + val textLetterSpacing: ExpressionOrValue? = null, + + @SerialName("text-justify") + val textJustify: ExpressionOrValue? = null, + + @SerialName("text-radial-offset") + val textRadialOffset: ExpressionOrValue? = null, + + @SerialName("text-variable-anchor") + val textVariableAnchor: ExpressionOrValue>? = null, + + @SerialName("text-anchor") + val textAnchor: ExpressionOrValue? = null, + + @SerialName("text-max-angle") + val textMaxAngle: ExpressionOrValue? = null, + + @SerialName("text-writing-mode") + val textWritingMode: ExpressionOrValue>? = null, + + @SerialName("text-rotate") + val textRotate: ExpressionOrValue? = null, + + @SerialName("text-padding") + val textPadding: ExpressionOrValue? = null, + + @SerialName("text-keep-upright") + val textKeepUpright: ExpressionOrValue? = null, + + @SerialName("text-transform") + val textTransform: ExpressionOrValue? = null, + + @SerialName("text-offset") + val textOffset: ExpressionOrValue>? = null, + + @SerialName("text-allow-overlap") + val textAllowOverlap: ExpressionOrValue? = null, + + @SerialName("text-ignore-placement") + val textIgnorePlacement: ExpressionOrValue? = null, + + @SerialName("text-optional") + val textOptional: ExpressionOrValue? = null, + + @SerialName("symbol-placement") + val symbolPlacement: ExpressionOrValue? = null, + + @SerialName("symbol-spacing") + val symbolSpacing: ExpressionOrValue? = null, + + @SerialName("symbol-avoid-edges") + val symbolAvoidEdges: ExpressionOrValue? = null, + + @SerialName("symbol-sort-key") + val symbolSortKey: ExpressionOrValue? = null, + + @SerialName("symbol-z-order") + val symbolZOrder: ExpressionOrValue? = null, + + @SerialName("icon-overlap") + val iconOverlap: ExpressionOrValue? = null, + + @SerialName("text-overlap") + val textOverlap: ExpressionOrValue? = null +) : LayoutInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/SymbolPaint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/SymbolPaint.kt new file mode 100644 index 00000000..248c68ce --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/SymbolPaint.kt @@ -0,0 +1,45 @@ +package ovh.plrapps.mapcompose.vector.spec.style.symbol + +import androidx.compose.ui.graphics.Color +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import ovh.plrapps.mapcompose.vector.spec.style.PaintInterface +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValueColorSerializer + +@Serializable +data class SymbolPaint( + @SerialName("icon-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val iconColor: ExpressionOrValue? = null, + + @SerialName("icon-halo-blur") + val iconHaloBlur: ExpressionOrValue? = null, + @SerialName("icon-halo-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val iconHaloColor: ExpressionOrValue? = null, + @SerialName("icon-halo-width") + val iconHaloWidth: ExpressionOrValue? = null, + @SerialName("icon-opacity") + val iconOpacity: ExpressionOrValue? = null, + @SerialName("icon-translate") + val iconTranslate: ExpressionOrValue>? = null, + @SerialName("icon-translate-anchor") + val iconTranslateAnchor: ExpressionOrValue? = null, + @SerialName("text-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val textColor: ExpressionOrValue? = null, + @SerialName("text-halo-blur") + val textHaloBlur: ExpressionOrValue? = null, + @SerialName("text-halo-color") + @Serializable(with = ExpressionOrValueColorSerializer::class) + val textHaloColor: ExpressionOrValue? = null, + @SerialName("text-halo-width") + val textHaloWidth: ExpressionOrValue? = null, + @SerialName("text-opacity") + val textOpacity: ExpressionOrValue? = null, + @SerialName("text-translate") + val textTranslate: ExpressionOrValue>? = null, + @SerialName("text-translate-anchor") + val textTranslateAnchor: ExpressionOrValue? = null +) : PaintInterface \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/TextAnchor.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/TextAnchor.kt new file mode 100644 index 00000000..b050b64e --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/symbol/TextAnchor.kt @@ -0,0 +1,44 @@ +package ovh.plrapps.mapcompose.vector.spec.style.symbol + +import kotlinx.serialization.KSerializer +import kotlinx.serialization.Serializable +import kotlinx.serialization.descriptors.PrimitiveKind +import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor +import kotlinx.serialization.descriptors.SerialDescriptor +import kotlinx.serialization.encoding.Decoder +import kotlinx.serialization.encoding.Encoder + +@Serializable(with = TextAnchorSerializer::class) +enum class TextAnchor(val value: String) { + Center("center"), + Left("left"), + Right("right"), + Top("top"), + Bottom("bottom"), + TopLeft("top-left"), + TopRight("top-right"), + BottomLeft("bottom-left"), + BottomRight("bottom-right"); + + companion object { + fun fromString(value: String?): TextAnchor { + return TextAnchor.entries.find { it.value.equals(value, ignoreCase = true) } ?: Center + } + + fun fromAny(value: Any?): TextAnchor? { + return when (value) { + is TextAnchor -> value + is String -> fromString(value) + else -> null + } + } + } +} + +object TextAnchorSerializer : KSerializer { + override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("TextAnchor", PrimitiveKind.STRING) + override fun deserialize(decoder: Decoder): TextAnchor = + TextAnchor.fromString(decoder.decodeString()) + override fun serialize(encoder: Encoder, value: TextAnchor) = + encoder.encodeString(value.value) +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/ColorParser.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/ColorParser.kt new file mode 100644 index 00000000..8c985dfe --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/ColorParser.kt @@ -0,0 +1,278 @@ +package ovh.plrapps.mapcompose.vector.spec.style.utils + +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.toArgb +import kotlin.math.roundToInt + +object ColorParser { + private val namedColors = mapOf( + "aliceblue" to Color(0xFFF0F8FF), + "antiquewhite" to Color(0xFFFAEBD7), + "aqua" to Color(0xFF00FFFF), + "aquamarine" to Color(0xFF7FFFD4), + "azure" to Color(0xFFF0FFFF), + "beige" to Color(0xFFF5F5DC), + "bisque" to Color(0xFFFFE4C4), + "black" to Color(0xFF000000), + "blanchedalmond" to Color(0xFFFFEBCD), + "blue" to Color(0xFF0000FF), + "blueviolet" to Color(0xFF8A2BE2), + "brown" to Color(0xFFA52A2A), + "burlywood" to Color(0xFFDEB887), + "cadetblue" to Color(0xFF5F9EA0), + "chartreuse" to Color(0xFF7FFF00), + "chocolate" to Color(0xFFD2691E), + "coral" to Color(0xFFFF7F50), + "cornflowerblue" to Color(0xFF6495ED), + "cornsilk" to Color(0xFFFFF8DC), + "crimson" to Color(0xFFDC143C), + "cyan" to Color(0xFF00FFFF), + "darkblue" to Color(0xFF00008B), + "darkcyan" to Color(0xFF008B8B), + "darkgoldenrod" to Color(0xFFB8860B), + "darkgray" to Color(0xFFA9A9A9), + "darkgreen" to Color(0xFF006400), + "darkgrey" to Color(0xFFA9A9A9), + "darkkhaki" to Color(0xFFBDB76B), + "darkmagenta" to Color(0xFF8B008B), + "darkolivegreen" to Color(0xFF556B2F), + "darkorange" to Color(0xFFFF8C00), + "darkorchid" to Color(0xFF9932CC), + "darkred" to Color(0xFF8B0000), + "darksalmon" to Color(0xFFE9967A), + "darkseagreen" to Color(0xFF8FBC8F), + "darkslateblue" to Color(0xFF483D8B), + "darkslategray" to Color(0xFF2F4F4F), + "darkslategrey" to Color(0xFF2F4F4F), + "darkturquoise" to Color(0xFF00CED1), + "darkviolet" to Color(0xFF9400D3), + "deeppink" to Color(0xFFFF1493), + "deepskyblue" to Color(0xFF00BFFF), + "dimgray" to Color(0xFF696969), + "dimgrey" to Color(0xFF696969), + "dodgerblue" to Color(0xFF1E90FF), + "firebrick" to Color(0xFFB22222), + "floralwhite" to Color(0xFFFFFAF0), + "forestgreen" to Color(0xFF228B22), + "fuchsia" to Color(0xFFFF00FF), + "gainsboro" to Color(0xFFDCDCDC), + "ghostwhite" to Color(0xFFF8F8FF), + "gold" to Color(0xFFFFD700), + "goldenrod" to Color(0xFFDAA520), + "gray" to Color(0xFF808080), + "green" to Color(0xFF008000), + "greenyellow" to Color(0xFFADFF2F), + "grey" to Color(0xFF808080), + "honeydew" to Color(0xFFF0FFF0), + "hotpink" to Color(0xFFFF69B4), + "indianred" to Color(0xFFCD5C5C), + "indigo" to Color(0xFF4B0082), + "ivory" to Color(0xFFFFFFF0), + "khaki" to Color(0xFFF0E68C), + "lavender" to Color(0xFFE6E6FA), + "lavenderblush" to Color(0xFFFFF0F5), + "lawngreen" to Color(0xFF7CFC00), + "lemonchiffon" to Color(0xFFFFFACD), + "lightblue" to Color(0xFFADD8E6), + "lightcoral" to Color(0xFFF08080), + "lightcyan" to Color(0xFFE0FFFF), + "lightgoldenrodyellow" to Color(0xFFFAFAD2), + "lightgray" to Color(0xFFD3D3D3), + "lightgreen" to Color(0xFF90EE90), + "lightgrey" to Color(0xFFD3D3D3), + "lightpink" to Color(0xFFFFB6C1), + "lightsalmon" to Color(0xFFFFA07A), + "lightseagreen" to Color(0xFF20B2AA), + "lightskyblue" to Color(0xFF87CEFA), + "lightslategray" to Color(0xFF778899), + "lightslategrey" to Color(0xFF778899), + "lightsteelblue" to Color(0xFFB0C4DE), + "lightyellow" to Color(0xFFFFFFE0), + "lime" to Color(0xFF00FF00), + "limegreen" to Color(0xFF32CD32), + "linen" to Color(0xFFFAF0E6), + "magenta" to Color(0xFFFF00FF), + "maroon" to Color(0xFF800000), + "mediumaquamarine" to Color(0xFF66CDAA), + "mediumblue" to Color(0xFF0000CD), + "mediumorchid" to Color(0xFFBA55D3), + "mediumpurple" to Color(0xFF9370DB), + "mediumseagreen" to Color(0xFF3CB371), + "mediumslateblue" to Color(0xFF7B68EE), + "mediumspringgreen" to Color(0xFF00FA9A), + "mediumturquoise" to Color(0xFF48D1CC), + "mediumvioletred" to Color(0xFFC71585), + "midnightblue" to Color(0xFF191970), + "mintcream" to Color(0xFFF5FFFA), + "mistyrose" to Color(0xFFFFE4E1), + "moccasin" to Color(0xFFFFE4B5), + "navajowhite" to Color(0xFFFFDEAD), + "navy" to Color(0xFF000080), + "oldlace" to Color(0xFFFDF5E6), + "olive" to Color(0xFF808000), + "olivedrab" to Color(0xFF6B8E23), + "orange" to Color(0xFFFFA500), + "orangered" to Color(0xFFFF4500), + "orchid" to Color(0xFFDA70D6), + "palegoldenrod" to Color(0xFFEEE8AA), + "palegreen" to Color(0xFF98FB98), + "paleturquoise" to Color(0xFFAFEEEE), + "palevioletred" to Color(0xFFDB7093), + "papayawhip" to Color(0xFFFFEFD5), + "peachpuff" to Color(0xFFFFDAB9), + "peru" to Color(0xFFCD853F), + "pink" to Color(0xFFFFC0CB), + "plum" to Color(0xFFDDA0DD), + "powderblue" to Color(0xFFB0E0E6), + "purple" to Color(0xFF800080), + "red" to Color(0xFFFF0000), + "rosybrown" to Color(0xFFBC8F8F), + "royalblue" to Color(0xFF4169E1), + "saddlebrown" to Color(0xFF8B4513), + "salmon" to Color(0xFFFA8072), + "sandybrown" to Color(0xFFF4A460), + "seagreen" to Color(0xFF2E8B57), + "seashell" to Color(0xFFFFF5EE), + "sienna" to Color(0xFFA0522D), + "silver" to Color(0xFFC0C0C0), + "skyblue" to Color(0xFF87CEEB), + "slateblue" to Color(0xFF6A5ACD), + "slategray" to Color(0xFF708090), + "slategrey" to Color(0xFF708090), + "snow" to Color(0xFFFFFAFA), + "springgreen" to Color(0xFF00FF7F), + "steelblue" to Color(0xFF4682B4), + "tan" to Color(0xFFD2B48C), + "teal" to Color(0xFF008080), + "thistle" to Color(0xFFD8BFD8), + "tomato" to Color(0xFFFF6347), + "turquoise" to Color(0xFF40E0D0), + "violet" to Color(0xFFEE82EE), + "wheat" to Color(0xFFF5DEB3), + "white" to Color(0xFFFFFFFF), + "whitesmoke" to Color(0xFFF5F5F5), + "yellow" to Color(0xFFFFFF00), + "yellowgreen" to Color(0xFF9ACD32) + ) + + fun parseColorString(color: String): Color { + return when { + color.startsWith("#") -> parseHex(color) + color.startsWith("rgb(") -> parseRgb(color) + color.startsWith("rgba(") -> parseRgba(color) + color.startsWith("hsl(") -> parseHsl(color) + color.startsWith("hsla(") -> parseHsla(color) + else -> namedColors[color.lowercase()] ?: parseError("unsupported color name $color") + } + } + + fun parseColorStringOrNull(color: String): Color? { + return try { + parseColorString(color) + } catch (e: Throwable) { + null + } + } + + fun colorToHexString(color: Color): String { + val argb = color.toArgb() + val r = (argb shr 16) and 0xFF + val g = (argb shr 8) and 0xFF + val b = argb and 0xFF + val a = (argb shr 24) and 0xFF + + fun toHex(value: Int) = value.toString(16).padStart(2, '0') + + return buildString { + append("#") + append(toHex(r)) + append(toHex(g)) + append(toHex(b)) + if (a != 0xFF) { + append(toHex(a)) + } + }.uppercase() + } + + private fun parseHex(hex: String): Color { + return when (hex.length) { + 4 -> { // #RGB + val r = hex.substring(1, 2).repeat(2).toInt(16) + val g = hex.substring(2, 3).repeat(2).toInt(16) + val b = hex.substring(3, 4).repeat(2).toInt(16) + Color(r, g, b) + } + + 7 -> { // #RRGGBB + val r = hex.substring(1, 3).toInt(16) + val g = hex.substring(3, 5).toInt(16) + val b = hex.substring(5, 7).toInt(16) + Color(r, g, b) + } + + 9 -> { // #RRGGBBAA + val r = hex.substring(1, 3).toInt(16) + val g = hex.substring(3, 5).toInt(16) + val b = hex.substring(5, 7).toInt(16) + val a = hex.substring(7, 9).toInt(16) + Color(r, g, b, a) + } + + else -> parseError("Invalid hex $hex") + } + } + + private fun parseRgb(rgb: String): Color { + val values = rgb.substring(4, rgb.length - 1) + .split(",") + .map { it.trim() } + .mapNotNull { it.toIntOrNull() } + return if (values.size == 3) { + Color(values[0], values[1], values[2]) + } else parseError("Invalid rgb $rgb") + } + + private fun parseRgba(rgba: String): Color { + val values = rgba.substring(5, rgba.length - 1) + .split(",") + .map { it.trim() } + return if (values.size == 4) { + val r = values[0].toIntOrNull() ?: parseError("Invalid rgba $rgba") + val g = values[1].toIntOrNull() ?: parseError("Invalid rgba $rgba") + val b = values[2].toIntOrNull() ?: parseError("Invalid rgba $rgba") + val alpha = values[3].toFloatOrNull() ?: parseError("Invalid rgba $rgba") + Color(r, g, b, (alpha * 255f).roundToInt()) + } else parseError("Invalid rgba $rgba") + } + + private fun parseHsl(hsl: String): Color { + val values = hsl.substring(4, hsl.length - 1) + .split(",") + .map { it.trim() } + return if (values.size == 3) { + val h = values[0].toFloatOrNull() ?: parseError("Invalid hsl $hsl") + val s = values[1].removeSuffix("%").toFloatOrNull() ?: parseError("Invalid hsl $hsl") + val l = values[2].removeSuffix("%").toFloatOrNull() ?: parseError("Invalid hsl $hsl") + Color.hsl(hue = h, saturation = s / 100f, lightness = l / 100f) + } else parseError("Invalid hsl $hsl") + } + + private fun parseHsla(hsla: String): Color { + val values = hsla.substring(5, hsla.length - 1) + .split(",") + .map { it.trim() } + return if (values.size == 4) { + val h = values[0].toFloatOrNull() ?: parseError("Invalid hsl $hsla") + val s = values[1].removeSuffix("%").toFloatOrNull() ?: parseError("Invalid hsl $hsla") + val l = values[2].removeSuffix("%").toFloatOrNull() ?: parseError("Invalid hsl $hsla") + val alpha = values[3].toFloatOrNull() ?: parseError("Invalid hsl $hsla") + Color.hsl(hue = h, saturation = s / 100f, lightness = l / 100f, alpha = alpha) + } else parseError("Invalid hsl $hsla") + } + + private fun parseError(msg: String): Nothing { + throw ColorParserException(msg) + } + + class ColorParserException(message: String) : Throwable(message = message) +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/KnownExpressions.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/KnownExpressions.kt new file mode 100644 index 00000000..1c0f4aa6 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/KnownExpressions.kt @@ -0,0 +1,44 @@ +package ovh.plrapps.mapcompose.vector.spec.style.utils + + +internal val knownExpressions = setOf( + // 🧮 Arithmetic + "+", "-", "*", "/", "%", "^", + + // 🧠 Type & Conversion + "typeof", "to-number", "to-string", "to-boolean", "to-color", "number-format", + + // 🎨 Color + "rgb", "rgba", "to-rgba", + + // 🔢 Math + "abs", "acos", "asin", "atan", "ceil", "cos", "e", "floor", "ln", "ln2", + "log10", "log2", "max", "min", "pi", "round", "sin", "sqrt", "tan", + + // 🔗 Logical + "!", "==", "!=", ">", ">=", "<", "<=", "all", "any", + + // 🔀 Control Flow + "case", "match", "coalesce", "step", "interpolate", "interpolate-hcl", "interpolate-lab", + + // 🧰 Data Manipulation + "get", "has", "in", "at", "index-of", "length", "slice", + + // 🧾 Feature + "feature-state", "geometry-type", "id", "properties", + + // 📷 Camera + "zoom", "line-progress", + + // 📦 Constants + "literal", + + // 🔡 String + "concat", "downcase", "upcase", "is-supported-script", "resolved-locale", + + // 🧠 Structures + "array", "boolean", "collator", "format", "image", "number", "object", "string", + + // 🧪 Variables + "let", "var" +) \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/isExpr.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/isExpr.kt new file mode 100644 index 00000000..6634908c --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/isExpr.kt @@ -0,0 +1,9 @@ +package ovh.plrapps.mapcompose.vector.spec.style.utils + +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonPrimitive + +internal fun isExpr(jsonElement: JsonArray): Boolean { + val first = jsonElement.firstOrNull() + return first is JsonPrimitive && first.isString && first.content in knownExpressions +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/normalizeLegacyExpression.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/normalizeLegacyExpression.kt new file mode 100644 index 00000000..3e0e2d15 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/normalizeLegacyExpression.kt @@ -0,0 +1,124 @@ +package ovh.plrapps.mapcompose.vector.spec.style.utils + +import kotlinx.serialization.ExperimentalSerializationApi +import kotlinx.serialization.json.* + +@OptIn(ExperimentalSerializationApi::class) +fun normalizeLegacyExpression(input: JsonObject): JsonArray { + + val type = input["type"]?.jsonPrimitive?.contentOrNull + val property = input["property"]?.jsonPrimitive?.contentOrNull + val stops = input["stops"] as? JsonArray + val base = input["base"]?.jsonPrimitive?.floatOrNull + + return when { + base != null && stops != null && property == null -> buildJsonArray { + add("interpolate") + add(buildJsonArray { + add("exponential") + add(base) + }) + add("zoom") + stops.forEach { stop -> + if (stop is JsonArray && stop.size == 2) { + add(stop[0]) + add(stop[1]) + } + } + } + // identity → ["get", property] + type == "identity" && property != null -> buildJsonArray { + add("get") + add(property) + } + + // exponential → ["interpolate", ["exponential", base], ["get", property], ...stops] + type == "exponential" && property != null && stops != null -> buildJsonArray { + add("interpolate") + add(buildJsonArray { + add("exponential") + add(JsonPrimitive(base ?: 1f)) + }) + add(buildJsonArray { + add("get") + add(property) + }) + stops.forEach { stop -> + if (stop is JsonArray && stop.size == 2) { + add(stop[0]) + add(stop[1]) + } + } + } + + type == "interval" && property != null && stops != null -> buildJsonArray { + add("step") + add(buildJsonArray { + add("get") + add(property) + }) + + val default = input["default"] ?: JsonPrimitive(0) + add(default) + + stops.forEach { stop -> + if (stop is JsonArray && stop.size == 2) { + add(stop[0]) + add(stop[1]) + } + } + } + + // categorical → ["match", ["get", property], ...] + type == "categorical" && property != null && stops != null -> buildJsonArray { + add("match") + add(buildJsonArray { + add("get") + add(property) + }) + stops.forEachIndexed { index, stop -> + if (stop is JsonArray && stop.size == 2) { + add(stop[0]) + add(stop[1]) + } + } + add(JsonPrimitive(null)) // default fallback + } + + // stops-only shorthand → assume interpolate linear + stops != null && property != null -> buildJsonArray { + add("interpolate") + add(buildJsonArray { add("linear") }) + add(buildJsonArray { + add("get") + add(property) + }) + stops.forEach { stop -> + if (stop is JsonArray && stop.size == 2) { + add(stop[0]) + add(stop[1]) + } + } + } + // stops-only without property → assume zoom-based interpolation + stops != null && property == null -> buildJsonArray { + add("interpolate") + add(buildJsonArray { add("linear") }) + add(JsonPrimitive("zoom")) + stops.forEach { stop -> + if (stop is JsonArray && stop.size == 2) { + add(stop[0]) + add(stop[1]) + } + } + } + + // only property → assume ["get", property] + property != null -> buildJsonArray { + add("get") + add(property) + } + + else -> error("unable to normalize legacy expression $input") // fallback + } +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/normalizePotentialLiteralArray.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/normalizePotentialLiteralArray.kt new file mode 100644 index 00000000..7c04f4cf --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/normalizePotentialLiteralArray.kt @@ -0,0 +1,17 @@ +package ovh.plrapps.mapcompose.vector.spec.style.utils + +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.add +import kotlinx.serialization.json.buildJsonArray + +// Not sure to use. for discuss +fun normalizePotentialLiteralArray(element: JsonArray): JsonArray { + return if (isExpr(element)) { + element // expression + } else { + buildJsonArray { + add("literal") + add(element) + } + } +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/tilejson/TileJson.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/tilejson/TileJson.kt new file mode 100644 index 00000000..78b9f3e3 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/tilejson/TileJson.kt @@ -0,0 +1,35 @@ +package ovh.plrapps.mapcompose.vector.spec.tilejson + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable + +@Serializable +data class TileJson( + val tilejson: String, + val name: String? = null, + val description: String? = null, + val version: String? = null, + val attribution: String? = null, + val template: String? = null, + val legend: String? = null, + val scheme: String = "xyz", + val tiles: List, + val grids: List? = null, + val data: List? = null, + val minzoom: Int = 0, + val maxzoom: Int = 22, + val bounds: List? = null, // [west, south, east, north] + val center: List? = null, // [lon, lat, zoom] + + @SerialName("vector_layers") + val vectorLayers: List? = null +) + +@Serializable +data class VectorLayer( + val id: String, + val description: String? = null, + val fields: Map = emptyMap(), + val minzoom: Int? = null, + val maxzoom: Int? = null +) diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/vector_tile.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/vector_tile.kt new file mode 100644 index 00000000..8bf4ff85 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/spec/vector_tile.kt @@ -0,0 +1,445 @@ +@file:OptIn(pbandk.PublicForGeneratedCode::class) + +package ovh.plrapps.mapcompose.vector.spec + +@pbandk.Export +data class Tile( + val layers: List = emptyList(), + override val unknownFields: Map = emptyMap(), + @property:pbandk.PbandkInternal + override val extensionFields: pbandk.ExtensionFieldSet = pbandk.ExtensionFieldSet() +) : pbandk.ExtendableMessage { + override operator fun plus(other: pbandk.Message?): Tile = protoMergeImpl(other) + override val descriptor: pbandk.MessageDescriptor get() = Companion.descriptor + override val protoSize: Int by lazy { super.protoSize } + companion object : pbandk.Message.Companion { + val defaultInstance: Tile by lazy { Tile() } + override fun decodeWith(u: pbandk.MessageDecoder): Tile = Tile.decodeWithImpl(u) + + override val descriptor: pbandk.MessageDescriptor = pbandk.MessageDescriptor( + fullName = "vector_tile.Tile", + messageClass = Tile::class, + messageCompanion = this, + fields = buildList(1) { + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "layers", + number = 3, + type = pbandk.FieldDescriptor.Type.Repeated(valueType = pbandk.FieldDescriptor.Type.Message(messageCompanion = Layer.Companion)), + jsonName = "layers", + value = Tile::layers + ) + ) + } + ) + } + + sealed class GeomType(override val value: Int, override val name: String? = null) : pbandk.Message.Enum { + override fun equals(other: Any?): Boolean = other is GeomType && other.value == value + override fun hashCode(): Int = value.hashCode() + override fun toString(): String = "Tile.GeomType.${name ?: "UNRECOGNIZED"}(value=$value)" + + object UNKNOWN : GeomType(0, "UNKNOWN") + object POINT : GeomType(1, "POINT") + object LINESTRING : GeomType(2, "LINESTRING") + object POLYGON : GeomType(3, "POLYGON") + class UNRECOGNIZED(value: Int) : GeomType(value) + + companion object : pbandk.Message.Enum.Companion { + val values: List by lazy { listOf(UNKNOWN, POINT, LINESTRING, POLYGON) } + override fun fromValue(value: Int): GeomType = values.firstOrNull { it.value == value } ?: UNRECOGNIZED(value) + override fun fromName(name: String): GeomType = values.firstOrNull { it.name == name } ?: throw IllegalArgumentException("No GeomType with name: $name") + } + } + + data class Value( + val stringValue: String? = null, + val floatValue: Float? = null, + val doubleValue: Double? = null, + val intValue: Long? = null, + val uintValue: Long? = null, + val sintValue: Long? = null, + val boolValue: Boolean? = null, + override val unknownFields: Map = emptyMap(), + @property:pbandk.PbandkInternal + override val extensionFields: pbandk.ExtensionFieldSet = pbandk.ExtensionFieldSet() + ) : pbandk.ExtendableMessage { + override operator fun plus(other: pbandk.Message?): Value = protoMergeImpl(other) + override val descriptor: pbandk.MessageDescriptor get() = Companion.descriptor + override val protoSize: Int by lazy { super.protoSize } + companion object : pbandk.Message.Companion { + val defaultInstance: Value by lazy { Value() } + override fun decodeWith(u: pbandk.MessageDecoder): Value = Value.decodeWithImpl(u) + + override val descriptor: pbandk.MessageDescriptor = pbandk.MessageDescriptor( + fullName = "vector_tile.Tile.Value", + messageClass = Value::class, + messageCompanion = this, + fields = buildList(7) { + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "string_value", + number = 1, + type = pbandk.FieldDescriptor.Type.Primitive.String(hasPresence = true), + jsonName = "stringValue", + value = Value::stringValue + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "float_value", + number = 2, + type = pbandk.FieldDescriptor.Type.Primitive.Float(hasPresence = true), + jsonName = "floatValue", + value = Value::floatValue + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "double_value", + number = 3, + type = pbandk.FieldDescriptor.Type.Primitive.Double(hasPresence = true), + jsonName = "doubleValue", + value = Value::doubleValue + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "int_value", + number = 4, + type = pbandk.FieldDescriptor.Type.Primitive.Int64(hasPresence = true), + jsonName = "intValue", + value = Value::intValue + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "uint_value", + number = 5, + type = pbandk.FieldDescriptor.Type.Primitive.UInt64(hasPresence = true), + jsonName = "uintValue", + value = Value::uintValue + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "sint_value", + number = 6, + type = pbandk.FieldDescriptor.Type.Primitive.SInt64(hasPresence = true), + jsonName = "sintValue", + value = Value::sintValue + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "bool_value", + number = 7, + type = pbandk.FieldDescriptor.Type.Primitive.Bool(hasPresence = true), + jsonName = "boolValue", + value = Value::boolValue + ) + ) + } + ) + } + } + + data class Feature( + val id: Long? = null, + val tags: List = emptyList(), + val type: GeomType? = null, + val geometry: List = emptyList(), + override val unknownFields: Map = emptyMap() + ) : pbandk.Message { + override operator fun plus(other: pbandk.Message?): Feature = protoMergeImpl(other) + override val descriptor: pbandk.MessageDescriptor get() = Companion.descriptor + override val protoSize: Int by lazy { super.protoSize } + companion object : pbandk.Message.Companion { + val defaultInstance: Feature by lazy { Feature() } + override fun decodeWith(u: pbandk.MessageDecoder): Feature = Feature.decodeWithImpl(u) + + override val descriptor: pbandk.MessageDescriptor = pbandk.MessageDescriptor( + fullName = "vector_tile.Tile.Feature", + messageClass = Feature::class, + messageCompanion = this, + fields = buildList(4) { + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "id", + number = 1, + type = pbandk.FieldDescriptor.Type.Primitive.UInt64(hasPresence = true), + jsonName = "id", + value = Feature::id + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "tags", + number = 2, + type = pbandk.FieldDescriptor.Type.Repeated(valueType = pbandk.FieldDescriptor.Type.Primitive.UInt32(), packed = true), + jsonName = "tags", + value = Feature::tags + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "type", + number = 3, + type = pbandk.FieldDescriptor.Type.Enum(enumCompanion = GeomType.Companion, hasPresence = true), + jsonName = "type", + value = Feature::type + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "geometry", + number = 4, + type = pbandk.FieldDescriptor.Type.Repeated(valueType = pbandk.FieldDescriptor.Type.Primitive.UInt32(), packed = true), + jsonName = "geometry", + value = Feature::geometry + ) + ) + } + ) + } + } + + data class Layer( + val version: Int, + val name: String, + val features: List = emptyList(), + val keys: List = emptyList(), + val values: List = emptyList(), + val extent: Int? = null, + override val unknownFields: Map = emptyMap(), + @property:pbandk.PbandkInternal + override val extensionFields: pbandk.ExtensionFieldSet = pbandk.ExtensionFieldSet() + ) : pbandk.ExtendableMessage { + override operator fun plus(other: pbandk.Message?): Layer = protoMergeImpl(other) + override val descriptor: pbandk.MessageDescriptor get() = Companion.descriptor + override val protoSize: Int by lazy { super.protoSize } + companion object : pbandk.Message.Companion { + override fun decodeWith(u: pbandk.MessageDecoder): Layer = Layer.decodeWithImpl(u) + + override val descriptor: pbandk.MessageDescriptor = pbandk.MessageDescriptor( + fullName = "vector_tile.Tile.Layer", + messageClass = Layer::class, + messageCompanion = this, + fields = buildList(6) { + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "name", + number = 1, + type = pbandk.FieldDescriptor.Type.Primitive.String(hasPresence = true), + jsonName = "name", + value = Layer::name + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "features", + number = 2, + type = pbandk.FieldDescriptor.Type.Repeated(valueType = pbandk.FieldDescriptor.Type.Message(messageCompanion = Feature.Companion)), + jsonName = "features", + value = Layer::features + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "keys", + number = 3, + type = pbandk.FieldDescriptor.Type.Repeated(valueType = pbandk.FieldDescriptor.Type.Primitive.String()), + jsonName = "keys", + value = Layer::keys + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "values", + number = 4, + type = pbandk.FieldDescriptor.Type.Repeated(valueType = pbandk.FieldDescriptor.Type.Message(messageCompanion = Value.Companion)), + jsonName = "values", + value = Layer::values + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "extent", + number = 5, + type = pbandk.FieldDescriptor.Type.Primitive.UInt32(hasPresence = true), + jsonName = "extent", + value = Layer::extent + ) + ) + add( + pbandk.FieldDescriptor( + messageDescriptor = this@Companion::descriptor, + name = "version", + number = 15, + type = pbandk.FieldDescriptor.Type.Primitive.UInt32(hasPresence = true), + jsonName = "version", + value = Layer::version + ) + ) + } + ) + } + } +} + +@pbandk.Export +@pbandk.JsName("orDefaultForTile") +fun Tile?.orDefault(): Tile = this ?: Tile.defaultInstance + +private fun Tile.protoMergeImpl(plus: pbandk.Message?): Tile = (plus as? Tile)?.let { + it.copy( + layers = layers + plus.layers, + unknownFields = unknownFields + plus.unknownFields + ) +} ?: this + +@Suppress("UNCHECKED_CAST") +private fun Tile.Companion.decodeWithImpl(u: pbandk.MessageDecoder): Tile { + var layers: pbandk.ListWithSize.Builder? = null + + val unknownFields = u.readMessage(this) { _fieldNumber, _fieldValue -> + when (_fieldNumber) { + 3 -> layers = (layers ?: pbandk.ListWithSize.Builder()).apply { this += _fieldValue as Sequence } + } + } + + return Tile(pbandk.ListWithSize.Builder.fixed(layers), unknownFields) +} + +@pbandk.Export +@pbandk.JsName("orDefaultForTileValue") +fun Tile.Value?.orDefault(): Tile.Value = this ?: Tile.Value.defaultInstance + +private fun Tile.Value.protoMergeImpl(plus: pbandk.Message?): Tile.Value = (plus as? Tile.Value)?.let { + it.copy( + stringValue = plus.stringValue ?: stringValue, + floatValue = plus.floatValue ?: floatValue, + doubleValue = plus.doubleValue ?: doubleValue, + intValue = plus.intValue ?: intValue, + uintValue = plus.uintValue ?: uintValue, + sintValue = plus.sintValue ?: sintValue, + boolValue = plus.boolValue ?: boolValue, + unknownFields = unknownFields + plus.unknownFields + ) +} ?: this + +@Suppress("UNCHECKED_CAST") +private fun Tile.Value.Companion.decodeWithImpl(u: pbandk.MessageDecoder): Tile.Value { + var stringValue: String? = null + var floatValue: Float? = null + var doubleValue: Double? = null + var intValue: Long? = null + var uintValue: Long? = null + var sintValue: Long? = null + var boolValue: Boolean? = null + + val unknownFields = u.readMessage(this) { _fieldNumber, _fieldValue -> + when (_fieldNumber) { + 1 -> stringValue = _fieldValue as String + 2 -> floatValue = _fieldValue as Float + 3 -> doubleValue = _fieldValue as Double + 4 -> intValue = _fieldValue as Long + 5 -> uintValue = _fieldValue as Long + 6 -> sintValue = _fieldValue as Long + 7 -> boolValue = _fieldValue as Boolean + } + } + + return Tile.Value(stringValue, floatValue, doubleValue, intValue, + uintValue, sintValue, boolValue, unknownFields) +} + +@pbandk.Export +@pbandk.JsName("orDefaultForTileFeature") +fun Tile.Feature?.orDefault(): Tile.Feature = this ?: Tile.Feature.defaultInstance + +private fun Tile.Feature.protoMergeImpl(plus: pbandk.Message?): Tile.Feature = (plus as? Tile.Feature)?.let { + it.copy( + id = plus.id ?: id, + tags = tags + plus.tags, + type = plus.type ?: type, + geometry = geometry + plus.geometry, + unknownFields = unknownFields + plus.unknownFields + ) +} ?: this + +@Suppress("UNCHECKED_CAST") +private fun Tile.Feature.Companion.decodeWithImpl(u: pbandk.MessageDecoder): Tile.Feature { + var id: Long? = null + var tags: pbandk.ListWithSize.Builder? = null + var type: Tile.GeomType? = null + var geometry: pbandk.ListWithSize.Builder? = null + + val unknownFields = u.readMessage(this) { _fieldNumber, _fieldValue -> + when (_fieldNumber) { + 1 -> id = _fieldValue as Long + 2 -> tags = (tags ?: pbandk.ListWithSize.Builder()).apply { this += _fieldValue as Sequence } + 3 -> type = _fieldValue as Tile.GeomType + 4 -> geometry = (geometry ?: pbandk.ListWithSize.Builder()).apply { this += _fieldValue as Sequence } + } + } + + return Tile.Feature(id, pbandk.ListWithSize.Builder.fixed(tags), type, pbandk.ListWithSize.Builder.fixed(geometry), unknownFields) +} + +private fun Tile.Layer.protoMergeImpl(plus: pbandk.Message?): Tile.Layer = (plus as? Tile.Layer)?.let { + it.copy( + features = features + plus.features, + keys = keys + plus.keys, + values = values + plus.values, + extent = plus.extent ?: extent, + unknownFields = unknownFields + plus.unknownFields + ) +} ?: this + +@Suppress("UNCHECKED_CAST") +private fun Tile.Layer.Companion.decodeWithImpl(u: pbandk.MessageDecoder): Tile.Layer { + var version: Int? = null + var name: String? = null + var features: pbandk.ListWithSize.Builder? = null + var keys: pbandk.ListWithSize.Builder? = null + var values: pbandk.ListWithSize.Builder? = null + var extent: Int? = null + + val unknownFields = u.readMessage(this) { _fieldNumber, _fieldValue -> + when (_fieldNumber) { + 1 -> name = _fieldValue as String + 2 -> features = (features ?: pbandk.ListWithSize.Builder()).apply { this += _fieldValue as Sequence } + 3 -> keys = (keys ?: pbandk.ListWithSize.Builder()).apply { this += _fieldValue as Sequence } + 4 -> values = (values ?: pbandk.ListWithSize.Builder()).apply { this += _fieldValue as Sequence } + 5 -> extent = _fieldValue as Int + 15 -> version = _fieldValue as Int + } + } + + if (version == null) { + throw pbandk.InvalidProtocolBufferException.missingRequiredField("version") + } + if (name == null) { + throw pbandk.InvalidProtocolBufferException.missingRequiredField("name") + } + return Tile.Layer(version, name, pbandk.ListWithSize.Builder.fixed(features), pbandk.ListWithSize.Builder.fixed(keys), + pbandk.ListWithSize.Builder.fixed(values), extent, unknownFields) +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/ui/state/SymbolState.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/ui/state/SymbolState.kt new file mode 100644 index 00000000..f1e78219 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/ui/state/SymbolState.kt @@ -0,0 +1,11 @@ +package ovh.plrapps.mapcompose.vector.ui.state + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.setValue +import ovh.plrapps.mapcompose.vector.renderer.Symbol + +internal class SymbolState { + var symbols by mutableStateOf>(emptyList()) + var visiblePhases by mutableStateOf(0..0) +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/ui/symbols/SymbolComposer.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/ui/symbols/SymbolComposer.kt new file mode 100644 index 00000000..6e06191f --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/ui/symbols/SymbolComposer.kt @@ -0,0 +1,74 @@ +package ovh.plrapps.mapcompose.vector.ui.symbols + +import androidx.compose.foundation.Canvas +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.runtime.Composable +import androidx.compose.ui.Modifier +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.graphics.drawscope.withTransform +import ovh.plrapps.mapcompose.ui.layout.grid +import ovh.plrapps.mapcompose.vector.ui.state.SymbolState +import ovh.plrapps.mapcompose.ui.state.ZoomPanRotateState +import ovh.plrapps.mapcompose.vector.renderer.Symbol +import kotlin.math.ceil + +@Composable +internal fun SymbolComposer( + modifier: Modifier, + zoomPRState: ZoomPanRotateState, + symbolState: SymbolState +) { + Canvas( + modifier = modifier.fillMaxSize() + ) { + val x0 = ((ceil(zoomPRState.scrollX / grid) * grid)).toInt() + val y0 = ((ceil(zoomPRState.scrollY / grid) * grid)).toInt() + + withTransform({ + rotate( + degrees = zoomPRState.rotation, + pivot = Offset( + x = zoomPRState.pivotX.toFloat(), + y = zoomPRState.pivotY.toFloat() + ) + ) + translate( + left = (-zoomPRState.scrollX + x0).toFloat(), + top = (-zoomPRState.scrollY + y0).toFloat() + ) + }) { + for (phase in symbolState.visiblePhases) { + val phaseOffsetPx = phase * zoomPRState.fullWidth * zoomPRState.scale + for (symbol in symbolState.symbols.reversed()) { + val canvasX: Float + val canvasY: Float + if (symbol is Symbol.Text && symbol.spriteAnchorGlobal != null && symbol.textOffset != null) { + canvasX = (symbol.spriteAnchorGlobal.x * zoomPRState.fullWidth * zoomPRState.scale - x0 + + symbol.textOffset.first + phaseOffsetPx).toFloat() + canvasY = (symbol.spriteAnchorGlobal.y * zoomPRState.fullHeight * zoomPRState.scale - y0 + + symbol.textOffset.second).toFloat() + } else { + canvasX = (symbol.global.x * zoomPRState.fullWidth * zoomPRState.scale - x0 + phaseOffsetPx).toFloat() + canvasY = (symbol.global.y * zoomPRState.fullHeight * zoomPRState.scale - y0).toFloat() + } + + val size = symbol.getInPixels() + val offsetX = size.width * symbol.align.x + val offsetY = size.height * symbol.align.y + + withTransform({ + translate(left = canvasX + offsetX, top = canvasY + offsetY) + if (symbol.viewportAligned) { + // Counter-rotate around the symbol's geographic reference point in local + // coords (= -offsetX, -offsetY), so the symbol stays horizontal on screen + // while its position still tracks the map-rotated viewport coordinate. + rotate(degrees = -zoomPRState.rotation, pivot = Offset(-offsetX, -offsetY)) + } + }) { + symbol.draw(this) + } + } + } + } + } +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/LruCache.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/LruCache.kt new file mode 100644 index 00000000..b2ace607 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/LruCache.kt @@ -0,0 +1,30 @@ +package ovh.plrapps.mapcompose.vector.utils + +class LruCache(private val maxSize: Int) { + private val cache = LinkedHashMap(0, 0.75f) + + fun get(key: K): V? { + val value = cache.remove(key) + if (value != null) { + cache[key] = value + } + return value + } + + fun put(key: K, value: V) { + cache.remove(key) + if (cache.size >= maxSize) { + val oldestKey = cache.keys.firstOrNull() + if (oldestKey != null) { + cache.remove(oldestKey) + } + } + cache[key] = value + } + + fun remove(key: K): V? { return cache.remove(key) } + + fun clear() { cache.clear() } + + fun size(): Int = cache.size +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/compose/RTreeCompose.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/compose/RTreeCompose.kt new file mode 100644 index 00000000..da908a18 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/compose/RTreeCompose.kt @@ -0,0 +1,34 @@ +package ovh.plrapps.mapcompose.vector.utils.compose + +import androidx.compose.ui.geometry.Rect +import ovh.plrapps.mapcompose.vector.utils.rtree.AABB +import ovh.plrapps.mapcompose.vector.utils.rtree.Rtree + +/** + * Converts Compose Rect to AABB + */ +fun Rect.toAABB(): AABB { + return AABB( + minX = left, + minY = top, + maxX = right, + maxY = bottom + ) +} + +/** + * Inserts a Compose Rect into R-tree with custom data + * @param id unique identifier for the item + * @param data custom data to store with the item + */ +fun Rtree.insert(id: String, rect: Rect, data: T) { + insert(rect.toAABB(), data) +} + +/** + * Searches for items in R-tree that intersect with the given Compose Rect + * @return list of found items with their data + */ +fun Rtree.search(rect: Rect): Set { + return search(rect.toAABB()) +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/compose/toOBB.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/compose/toOBB.kt new file mode 100644 index 00000000..5e12088b --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/compose/toOBB.kt @@ -0,0 +1,54 @@ +package ovh.plrapps.mapcompose.vector.utils.compose + +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Rect +import androidx.compose.ui.geometry.Size +import ovh.plrapps.mapcompose.vector.utils.obb.OBB +import ovh.plrapps.mapcompose.vector.utils.obb.ObbPoint +import ovh.plrapps.mapcompose.vector.utils.obb.Size as ObbSize + +/** + * Converts Compose Rect to OBB with specified rotation + * @param rotation rotation angle in degrees + */ +fun Rect.toOBB(rotation: Float = 0f): OBB { + return OBB( + center = ObbPoint( + x = (left + right) / 2, + y = (top + bottom) / 2 + ), + size = ovh.plrapps.mapcompose.vector.utils.obb.Size( + width = right - left, + height = bottom - top + ), + rotation = rotation + ) +} + +/** + * Converts Compose Offset to OBB Point + */ +fun Offset.toObbPoint(): ObbPoint { + return ObbPoint(x = x, y = y) +} + +/** + * Converts Compose Size to OBB Size + */ +fun Size.toObbSize(): ObbSize { + return ObbSize(width = width, height = height) +} + +/** + * Converts OBB Point to Compose Offset + */ +fun ObbPoint.toOffset(): Offset { + return Offset(x = x, y = y) +} + +/** + * Converts OBB Size to Compose Size + */ +fun ObbSize.toSize(): Size { + return Size(width = width, height = height) +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/Obb.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/Obb.kt new file mode 100644 index 00000000..cdd2b480 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/Obb.kt @@ -0,0 +1,98 @@ +package ovh.plrapps.mapcompose.vector.utils.obb + +import kotlin.math.cos +import kotlin.math.sin +import kotlin.math.PI +import ovh.plrapps.mapcompose.vector.utils.rtree.AABB + +class OBB( + val center: ObbPoint, + val size: Size, + val rotation: Float // in degrees +) { + // Convert rotation from degrees to radians + private val rotationRad = rotation * PI / 180.0 + + // Calculate rotation matrix components + private val cos = cos(rotationRad).toFloat() + private val sin = sin(rotationRad).toFloat() + + // Get the four corners of the OBB + fun getCorners(): List { + val halfWidth = size.width / 2 + val halfHeight = size.height / 2 + + // Calculate the corners before rotation + val corners = listOf( + ObbPoint(-halfWidth, -halfHeight), + ObbPoint(halfWidth, -halfHeight), + ObbPoint(halfWidth, halfHeight), + ObbPoint(-halfWidth, halfHeight) + ) + + // Rotate and translate each corner + return corners.map { corner -> + ObbPoint( + x = center.x + corner.x * cos - corner.y * sin, + y = center.y + corner.x * sin + corner.y * cos + ) + } + } + + // Get the axes of the OBB (normalized) + fun getAxes(): List { + return listOf( + ObbPoint(cos, sin), // First axis + ObbPoint(-sin, cos) // Second axis (perpendicular to first) + ) + } + + // Project a point onto an axis + private fun projectPoint(obbPoint: ObbPoint, axis: ObbPoint): Float { + return obbPoint.x * axis.x + obbPoint.y * axis.y + } + + // Project all corners onto an axis + private fun projectOBB(axis: ObbPoint): Pair { + val corners = getCorners() + val projections = corners.map { projectPoint(it, axis) } + return Pair( + projections.minOrNull() ?: 0f, + projections.maxOrNull() ?: 0f + ) + } + + // Check if two OBBs intersect using Separating Axis Theorem + fun intersects(other: OBB): Boolean { + // Get all axes to check + val axes = getAxes() + other.getAxes() + + // Project both OBBs onto each axis + for (axis in axes) { + val (min1, max1) = projectOBB(axis) + val (min2, max2) = other.projectOBB(axis) + + // If there is a gap, the OBBs do not intersect + if (max1 < min2 || max2 < min1) { + return false + } + } + + // If no gap was found on any axis, the OBBs intersect + return true + } + + // Get the AABB that contains this OBB + fun getAABB(): AABB { + val corners = getCorners() + val xs = corners.map { it.x } + val ys = corners.map { it.y } + + return AABB( + minX = xs.minOrNull() ?: 0f, + minY = ys.minOrNull() ?: 0f, + maxX = xs.maxOrNull() ?: 0f, + maxY = ys.maxOrNull() ?: 0f + ) + } +} diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/ObbPoint.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/ObbPoint.kt new file mode 100644 index 00000000..261b3794 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/ObbPoint.kt @@ -0,0 +1,3 @@ +package ovh.plrapps.mapcompose.vector.utils.obb + +data class ObbPoint(val x: Float, val y: Float) \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/README.md b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/README.md new file mode 100644 index 00000000..1c5f681c --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/README.md @@ -0,0 +1,66 @@ +# OBB (Oriented Bounding Box) Implementation + +## Description +Implementation of Oriented Bounding Box for precise intersection detection. OBB is a rectangle that can be rotated to any angle, providing a tighter fit around objects compared to AABB. + +## Key Features +- Support for rotated rectangles +- Precise intersection detection +- Efficient collision checking +- Support for 2D space +- Support for any rotation angle +- Support for any size + +## Usage +```kotlin +// Create OBB with center point, size and rotation +val obb = OBB( + center = Point(10f, 10f), + size = Size(20f, 10f), + rotation = 45f // degrees +) + +// Check intersection with another OBB +val otherObb = OBB( + center = Point(15f, 15f), + size = Size(10f, 10f), + rotation = 0f +) + +val isIntersecting = obb.intersects(otherObb) + +// Get corners of OBB +val corners = obb.getCorners() + +// Get AABB that contains this OBB +val aabb = obb.getAABB() +``` + +## Algorithm +OBB intersection test uses the Separating Axis Theorem (SAT): +1. Project both OBBs onto each other's axes +2. If there is a gap in any projection, the OBBs do not intersect +3. If there is no gap in any projection, the OBBs intersect + +## Performance +- O(n) complexity for intersection test, where n is the number of axes to check +- For 2D OBB, we need to check 4 axes (2 from each OBB) +- Much more precise than AABB, but slower +- Best used after AABB/R-tree filtering + +## Integration with R-tree +1. R-tree with AABB finds potential intersections +2. OBB performs precise intersection check only for candidates +3. This two-step approach provides both speed and accuracy + +## Notes +- OBB is more computationally expensive than AABB +- Should be used only for precise collision detection +- Best used in combination with R-tree for optimal performance +- Rotation is specified in degrees for simplicity +- All coordinates and sizes are in float for precision + +## Running Tests +```bash +./gradlew :composeApp:cleanJvmTest :composeApp:jvmTest --tests "ovh.plrapps.mapcompose.maplibre.utils.obb.ObbTest" +``` diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/Size.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/Size.kt new file mode 100644 index 00000000..5462d417 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/Size.kt @@ -0,0 +1,3 @@ +package ovh.plrapps.mapcompose.vector.utils.obb + +data class Size(val width: Float, val height: Float) \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/AABB.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/AABB.kt new file mode 100644 index 00000000..bc3cc961 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/AABB.kt @@ -0,0 +1,58 @@ +package ovh.plrapps.mapcompose.vector.utils.rtree + +data class AABB( + val minX: Float, + val minY: Float, + val maxX: Float, + val maxY: Float, +) { + init { + require(maxX >= minX && maxY >= minY) { "Invalid AABB: max coordinates must be greater than or equal to min coordinates" } + } + + val isPoint: Boolean = minX == maxX && minY == maxY + + private val cachedArea: Float = (maxX - minX) * (maxY - minY) + + private var cachedUnion: AABB? = null + private var cachedUnionWith: AABB? = null + + fun intersects(other: AABB): Boolean { + val intersectsX = maxX >= other.minX && minX <= other.maxX + val intersectsY = maxY >= other.minY && minY <= other.maxY + + return intersectsX && intersectsY + } + + fun contains(other: AABB): Boolean { + return minX <= other.minX && + maxX >= other.maxX && + minY <= other.minY && + maxY >= other.maxY + } + + fun union(other: AABB): AABB { + if (cachedUnionWith == other) { + return cachedUnion ?: run { + val result = AABB( + minOf(minX, other.minX), + minOf(minY, other.minY), + maxOf(maxX, other.maxX), + maxOf(maxY, other.maxY) + ) + cachedUnion = result + result + } + } + cachedUnionWith = other + cachedUnion = AABB( + minOf(minX, other.minX), + minOf(minY, other.minY), + maxOf(maxX, other.maxX), + maxOf(maxY, other.maxY) + ) + return cachedUnion!! + } + + fun area(): Float = cachedArea +} \ No newline at end of file diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/README.md b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/README.md new file mode 100644 index 00000000..e4ed95ed --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/README.md @@ -0,0 +1,86 @@ +# R-tree Implementation + +## Description +Implementation of a classical R-tree for efficient AABB (Axis-Aligned Bounding Box) intersection queries. +In this implementation, boundary touching is considered as intersection, which aligns with classical R-tree behavior. + +## Key Features +- AABB (Axis-Aligned Bounding Box) support +- Boundary touching is considered as intersection +- Efficient intersection queries +- Support for points (zero-sized AABBs) +- Support for negative coordinates +- Support for large and small numbers +- Multi-level structure with automatic node splitting +- Configurable node size (maxEntries and minEntries) + +## Performance Characteristics +- Average search speedup: 6.2x compared to naive search +- Optimal for small to medium search areas (5-7x speedup) +- Efficient for large datasets (50,000+ elements) +- Tree depth scales logarithmically with dataset size +- Memory efficient due to configurable node size + +## Tests +The implementation is covered by comprehensive tests that verify: + +### Basic Operations +- Element insertion and search +- Empty tree operations +- Size tracking +- Non-intersecting area queries + +### Edge Cases +- Points (zero-sized AABBs) +- Negative coordinates +- Very large numbers (1e6 - 1e7) +- Very small numbers (1e-6 - 1e-5) +- Boundary intersections (touching edges) +- Identical AABBs + +### Structural Tests +- Node splitting when exceeding maxEntries +- Multi-level tree structure +- Deep trees (500+ elements) +- Degenerate cases (lines) +- Tree rebalancing + +### Performance +- Search in large datasets (50,000 elements) +- Efficiency with multiple intersections +- Deep structure operations +- Comparison with naive search +- Various search area sizes + +## Usage +```kotlin +// Create tree with custom node size +val rtree = Rtree(maxEntries = 16, minEntries = 4) + +// Insert elements +rtree.insert(AABB(0f, 0f, 10f, 10f), "item1") + +// Search for intersections +val results = rtree.search(AABB(5f, 5f, 15f, 15f)) + +// Get size +val size = rtree.size() + +// Get tree depth +val depth = rtree.depth() +``` + +## Running Tests +```bash +./gradlew :composeApp:cleanJvmTest :composeApp:jvmTest --tests "ovh.plrapps.mapcompose.maplibre.utils.rtree.RtreeTest" +``` + +## Notes +- Implementation uses Kotlin Compose structures +- R-tree is used for fast candidate selection by AABB +- Precise intersection checks should be performed separately (e.g., using OBB) only for selected candidates +- Default node size (maxEntries=16, minEntries=4) provides good balance between search performance and memory usage +- Tree depth is automatically maintained during insertion + +## Algorithm +Detailed description of the R-tree algorithm can be found on [Wikipedia](https://en.wikipedia.org/wiki/R-tree) diff --git a/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/Rtree.kt b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/Rtree.kt new file mode 100644 index 00000000..b8e289a7 --- /dev/null +++ b/library/src/commonMain/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/Rtree.kt @@ -0,0 +1,278 @@ +package ovh.plrapps.mapcompose.vector.utils.rtree + +sealed class RTreeNode { + data class Leaf( + val entries: MutableList> = mutableListOf() + ) : RTreeNode() + + data class NonLeaf( + val children: MutableList, AABB>> = mutableListOf() + ) : RTreeNode() +} + +class Rtree( + private val maxEntries: Int = DEFAULT_MAX_ENTRIES, + private val minEntries: Int = DEFAULT_MIN_ENTRIES, + private val maxDepth: Int = DEFAULT_MAX_DEPTH +) { + companion object { + private const val DEFAULT_MAX_ENTRIES = 32 + private const val DEFAULT_MIN_ENTRIES = 2 + private const val DEFAULT_MAX_DEPTH = Int.MAX_VALUE + private val EMPTY_AABB = AABB(0f, 0f, 0f, 0f) + } + + private var root: RTreeNode = RTreeNode.Leaf() + private var size: Int = 0 + private var depth: Int = 0 + private val tempResults = mutableSetOf() + private val searchStack = mutableListOf>() + + fun insert(bounds: AABB, item: T) { + val splitResult = insertInternal(root, bounds, item, 0) + if (splitResult != null) { + val newRoot = RTreeNode.NonLeaf() + for (child in splitResult) { + newRoot.children.add(child to calcBounds(child)) + } + root = newRoot + depth++ + } + size++ + } + + private fun chooseSubtree(node: RTreeNode.NonLeaf, bounds: AABB): Int { + var bestChild = 0 + var minOverlap = Float.MAX_VALUE + var minArea = Float.MAX_VALUE + + for (i in node.children.indices) { + val (_, childBounds) = node.children[i] + val newBounds = childBounds.union(bounds) + + var overlap = 0f + for (j in node.children.indices) { + if (i != j) { + val (_, otherBounds) = node.children[j] + if (newBounds.intersects(otherBounds)) { + overlap += newBounds.intersectionArea(otherBounds) + } + } + } + + if (overlap < minOverlap) { + minOverlap = overlap + minArea = newBounds.area() - childBounds.area() + bestChild = i + } else if (overlap == minOverlap) { + // With equal overlap, we select the minimum increase in area + val areaIncrease = newBounds.area() - childBounds.area() + if (areaIncrease < minArea) { + minArea = areaIncrease + bestChild = i + } + } + } + + return bestChild + } + + private fun findSeeds(items: List, getBounds: (T) -> AABB): Pair { + var maxDistance = Float.MIN_VALUE + var seed1 = 0 + var seed2 = 1 + for (i in items.indices) { + for (j in (i + 1) until items.size) { + val bounds1 = getBounds(items[i]) + val bounds2 = getBounds(items[j]) + val distance = bounds1.area() + bounds2.area() - bounds1.union(bounds2).area() + if (distance > maxDistance) { + maxDistance = distance + seed1 = i + seed2 = j + } + } + } + return seed1 to seed2 + } + + private fun insertInternal(node: RTreeNode, bounds: AABB, item: T, currentDepth: Int): List>? { + if (currentDepth >= maxDepth) { + throw IllegalStateException("Maximum tree depth exceeded") + } + + return when (node) { + is RTreeNode.Leaf -> { + node.entries.add(bounds to item) + if (node.entries.size > maxEntries) splitLeaf(node).toList() else null + } + is RTreeNode.NonLeaf -> { + val bestChild = chooseSubtree(node, bounds) + val (child, _) = node.children[bestChild] + val splitResult = insertInternal(child, bounds, item, currentDepth + 1) + + if (splitResult != null) { + node.children.removeAt(bestChild) + for (newChild in splitResult) { + node.children.add(newChild to calcBounds(newChild)) + } + + if (node.children.size > maxEntries) { + splitNonLeaf(node).toList() + } else { + null + } + } else { + node.children[bestChild] = child to calcBounds(child) + null + } + } + } + } + + private fun splitLeaf(node: RTreeNode.Leaf): Pair, RTreeNode> { + if (node.entries.size <= 1) { + return node to RTreeNode.Leaf() + } + + val (seed1, seed2) = findSeeds(node.entries) { it.first } + + val leaf1 = RTreeNode.Leaf() + val leaf2 = RTreeNode.Leaf() + + var bounds1 = node.entries[seed1].first + var bounds2 = node.entries[seed2].first + + leaf1.entries.add(node.entries[seed1]) + leaf2.entries.add(node.entries[seed2]) + + val remaining = node.entries.filterIndexed { idx, _ -> idx != seed1 && idx != seed2 } + .sortedByDescending { entry -> + val area1 = bounds1.union(entry.first).area() - bounds1.area() + val area2 = bounds2.union(entry.first).area() - bounds2.area() + maxOf(area1, area2) + } + + for (entry in remaining) { + val area1 = bounds1.union(entry.first).area() - bounds1.area() + val area2 = bounds2.union(entry.first).area() - bounds2.area() + + if (area1 < area2 || (area1 == area2 && leaf1.entries.size <= leaf2.entries.size)) { + leaf1.entries.add(entry) + bounds1 = bounds1.union(entry.first) + } else { + leaf2.entries.add(entry) + bounds2 = bounds2.union(entry.first) + } + } + + node.entries.clear() + return leaf1 to leaf2 + } + + private fun splitNonLeaf(node: RTreeNode.NonLeaf): Pair, RTreeNode> { + if (node.children.size <= 1) { + return node to RTreeNode.NonLeaf() + } + + val (seed1, seed2) = findSeeds(node.children) { it.second } + + val n1 = RTreeNode.NonLeaf() + val n2 = RTreeNode.NonLeaf() + + var bounds1 = node.children[seed1].second + var bounds2 = node.children[seed2].second + + n1.children.add(node.children[seed1]) + n2.children.add(node.children[seed2]) + + val remaining = node.children.filterIndexed { idx, _ -> idx != seed1 && idx != seed2 } + .sortedByDescending { (_, bound) -> + val area1 = bounds1.union(bound).area() - bounds1.area() + val area2 = bounds2.union(bound).area() - bounds2.area() + maxOf(area1, area2) + } + + for ((child, bound) in remaining) { + val area1 = bounds1.union(bound).area() - bounds1.area() + val area2 = bounds2.union(bound).area() - bounds2.area() + + if (area1 < area2 || (area1 == area2 && n1.children.size <= n2.children.size)) { + n1.children.add(child to bound) + bounds1 = bounds1.union(bound) + } else { + n2.children.add(child to bound) + bounds2 = bounds2.union(bound) + } + } + + node.children.clear() + return n1 to n2 + } + + fun search(bounds: AABB): Set { + if (size == 0) return emptySet() + tempResults.clear() + searchInternal(root, bounds) + return tempResults.toSet() + } + + private fun searchInternal(node: RTreeNode, bounds: AABB) { + searchStack.clear() + searchStack.add(node) + + while (searchStack.isNotEmpty()) { + val current = searchStack.removeAt(searchStack.lastIndex) + when (current) { + is RTreeNode.Leaf -> { + for ((entryBounds, item) in current.entries) { + if (bounds.intersects(entryBounds)) { + tempResults.add(item) + } + } + } + is RTreeNode.NonLeaf -> { + for ((child, childBounds) in current.children) { + if (bounds.intersects(childBounds)) { + searchStack.add(child) + } + } + } + } + } + } + + fun size(): Int = size + + fun depth(): Int = depth + + fun clear() { + root = RTreeNode.Leaf() + size = 0 + depth = 0 + tempResults.clear() + searchStack.clear() + } + + private fun calcBounds(node: RTreeNode): AABB { + return when (node) { + is RTreeNode.Leaf -> { + if (node.entries.isEmpty()) EMPTY_AABB + else node.entries.fold(node.entries[0].first) { acc, (bounds, _) -> acc.union(bounds) } + } + is RTreeNode.NonLeaf -> { + if (node.children.isEmpty()) EMPTY_AABB + else node.children.fold(node.children[0].second) { acc, (_, bounds) -> acc.union(bounds) } + } + } + } +} + +private fun AABB.area(): Float = (maxX - minX) * (maxY - minY) + +private fun AABB.intersectionArea(other: AABB): Float { + if (!intersects(other)) return 0f + val width = minOf(maxX, other.maxX) - maxOf(minX, other.minX) + val height = minOf(maxY, other.maxY) - maxOf(minY, other.minY) + return width * height +} diff --git a/library/src/commonTest/composeResources/files/test_style_bright.json b/library/src/commonTest/composeResources/files/test_style_bright.json new file mode 100644 index 00000000..95dad4bb --- /dev/null +++ b/library/src/commonTest/composeResources/files/test_style_bright.json @@ -0,0 +1,2565 @@ +{ + "version": 8, + "name": "Bright", + "metadata": { + "mapbox:autocomposite": false, + "mapbox:groups": { + "1444849242106.713": {"collapsed": false, "name": "Places"}, + "1444849334699.1902": {"collapsed": true, "name": "Bridges"}, + "1444849345966.4436": {"collapsed": false, "name": "Roads"}, + "1444849354174.1904": {"collapsed": true, "name": "Tunnels"}, + "1444849364238.8171": {"collapsed": false, "name": "Buildings"}, + "1444849382550.77": {"collapsed": false, "name": "Water"}, + "1444849388993.3071": {"collapsed": false, "name": "Land"} + }, + "mapbox:type": "template", + "openmaptiles:mapbox:owner": "openmaptiles", + "openmaptiles:mapbox:source:url": "mapbox://openmaptiles.4qljc88t", + "openmaptiles:version": "3.x" + }, + "center": [0, 0], + "zoom": 1, + "bearing": 0, + "pitch": 0, + "sources": { + "openmaptiles": { + "tiles": [ + "https://api.maptiler.com/tiles/v3-openmaptiles/{z}/{x}/{y}.pbf?key=XXX" + ], + "minzoom": 0, + "maxzoom": 14, + "attribution": "© MapTiler © OpenStreetMap contributors", + "type": "vector" + } + }, + "sprite": "https://openmaptiles.github.io/osm-bright-gl-style/sprite", + "glyphs": "https://api.maptiler.com/fonts/{fontstack}/{range}.pbf?key={key}", + "layers": [ + { + "id": "background", + "type": "background", + "paint": {"background-color": "#f8f4f0"} + }, + { + "id": "landcover-glacier", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landcover", + "filter": ["==", "subclass", "glacier"], + "layout": {"visibility": "visible"}, + "paint": { + "fill-color": "#fff", + "fill-opacity": {"base": 1, "stops": [[0, 0.9], [10, 0.3]]} + } + }, + { + "id": "landuse-residential", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landuse", + "filter": [ + "all", + ["in", "class", "residential", "suburb", "neighbourhood"] + ], + "layout": {"visibility": "visible"}, + "paint": { + "fill-color": { + "base": 1, + "stops": [ + [12, "hsla(30, 19%, 90%, 0.4)"], + [16, "hsla(30, 19%, 90%, 0.2)"] + ] + } + } + }, + { + "id": "landuse-commercial", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landuse", + "filter": [ + "all", + ["==", "$type", "Polygon"], + ["==", "class", "commercial"] + ], + "layout": {"visibility": "visible"}, + "paint": {"fill-color": "hsla(0, 60%, 87%, 0.23)"} + }, + { + "id": "landuse-industrial", + "type": "fill", + "source": "openmaptiles", + "source-layer": "landuse", + "filter": [ + "all", + ["==", "$type", "Polygon"], + ["in", "class", "industrial", "garages", "dam"] + ], + "layout": {"visibility": "visible"}, + "paint": {"fill-color": "hsla(49, 100%, 88%, 0.34)"} + }, + { + "id": "landuse-cemetery", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landuse", + "filter": ["==", "class", "cemetery"], + "paint": {"fill-color": "#e0e4dd"} + }, + { + "id": "landuse-hospital", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landuse", + "filter": ["==", "class", "hospital"], + "paint": {"fill-color": "#fde"} + }, + { + "id": "landuse-school", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landuse", + "filter": ["==", "class", "school"], + "paint": {"fill-color": "#f0e8f8"} + }, + { + "id": "landuse-railway", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landuse", + "filter": ["==", "class", "railway"], + "layout": {"visibility": "visible"}, + "paint": {"fill-color": "hsla(30, 19%, 90%, 0.4)"} + }, + { + "id": "landcover-wood", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landcover", + "filter": ["==", "class", "wood"], + "paint": { + "fill-antialias": {"base": 1, "stops": [[0, false], [9, true]]}, + "fill-color": "#6a4", + "fill-opacity": 0.1, + "fill-outline-color": "hsla(0, 0%, 0%, 0.03)" + } + }, + { + "id": "landcover-grass", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "landcover", + "filter": ["==", "class", "grass"], + "paint": {"fill-color": "#d8e8c8", "fill-opacity": 1} + }, + { + "id": "landcover-grass-park", + "type": "fill", + "metadata": {"mapbox:group": "1444849388993.3071"}, + "source": "openmaptiles", + "source-layer": "park", + "filter": ["==", "class", "public_park"], + "paint": {"fill-color": "#d8e8c8", "fill-opacity": 0.8} + }, + { + "id": "waterway_tunnel", + "type": "line", + "source": "openmaptiles", + "source-layer": "waterway", + "minzoom": 14, + "filter": [ + "all", + ["in", "class", "river", "stream", "canal"], + ["==", "brunnel", "tunnel"] + ], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "#a0c8f0", + "line-dasharray": [2, 4], + "line-width": {"base": 1.3, "stops": [[13, 0.5], [20, 6]]} + } + }, + { + "id": "waterway-other", + "type": "line", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "waterway", + "filter": [ + "all", + ["!in", "class", "canal", "river", "stream"], + ["==", "intermittent", 0] + ], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "#a0c8f0", + "line-width": {"base": 1.3, "stops": [[13, 0.5], [20, 2]]} + } + }, + { + "id": "waterway-other-intermittent", + "type": "line", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "waterway", + "filter": [ + "all", + ["!in", "class", "canal", "river", "stream"], + ["==", "intermittent", 1] + ], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "#a0c8f0", + "line-dasharray": [4, 3], + "line-width": {"base": 1.3, "stops": [[13, 0.5], [20, 2]]} + } + }, + { + "id": "waterway-stream-canal", + "type": "line", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "waterway", + "filter": [ + "all", + ["in", "class", "canal", "stream"], + ["!=", "brunnel", "tunnel"], + ["==", "intermittent", 0] + ], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "#a0c8f0", + "line-width": {"base": 1.3, "stops": [[13, 0.5], [20, 6]]} + } + }, + { + "id": "waterway-stream-canal-intermittent", + "type": "line", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "waterway", + "filter": [ + "all", + ["in", "class", "canal", "stream"], + ["!=", "brunnel", "tunnel"], + ["==", "intermittent", 1] + ], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "#a0c8f0", + "line-dasharray": [4, 3], + "line-width": {"base": 1.3, "stops": [[13, 0.5], [20, 6]]} + } + }, + { + "id": "waterway-river", + "type": "line", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "waterway", + "filter": [ + "all", + ["==", "class", "river"], + ["!=", "brunnel", "tunnel"], + ["==", "intermittent", 0] + ], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "#a0c8f0", + "line-width": {"base": 1.2, "stops": [[10, 0.8], [20, 6]]} + } + }, + { + "id": "waterway-river-intermittent", + "type": "line", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "waterway", + "filter": [ + "all", + ["==", "class", "river"], + ["!=", "brunnel", "tunnel"], + ["==", "intermittent", 1] + ], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "#a0c8f0", + "line-dasharray": [3, 2.5], + "line-width": {"base": 1.2, "stops": [[10, 0.8], [20, 6]]} + } + }, + { + "id": "water-offset", + "type": "fill", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "water", + "maxzoom": 8, + "filter": ["==", "$type", "Polygon"], + "layout": {"visibility": "visible"}, + "paint": { + "fill-color": "#a0c8f0", + "fill-opacity": 1, + "fill-translate": {"base": 1, "stops": [[6, [2, 0]], [8, [0, 0]]]} + } + }, + { + "id": "water", + "type": "fill", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "water", + "filter": ["all", ["!=", "intermittent", 1], ["!=", "brunnel", "tunnel"]], + "layout": {"visibility": "visible"}, + "paint": {"fill-color": "hsl(210, 67%, 85%)"} + }, + { + "id": "water-intermittent", + "type": "fill", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "water", + "filter": ["all", ["==", "intermittent", 1]], + "layout": {"visibility": "visible"}, + "paint": {"fill-color": "hsl(210, 67%, 85%)", "fill-opacity": 0.7} + }, + { + "id": "water-pattern", + "type": "fill", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "water", + "filter": ["all"], + "layout": {"visibility": "visible"}, + "paint": {"fill-pattern": "wave", "fill-translate": [0, 2.5]} + }, + { + "id": "landcover-ice-shelf", + "type": "fill", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "landcover", + "filter": ["==", "subclass", "ice_shelf"], + "layout": {"visibility": "visible"}, + "paint": { + "fill-color": "#fff", + "fill-opacity": {"base": 1, "stops": [[0, 0.9], [10, 0.3]]} + } + }, + { + "id": "landcover-sand", + "type": "fill", + "metadata": {"mapbox:group": "1444849382550.77"}, + "source": "openmaptiles", + "source-layer": "landcover", + "filter": ["==", "class", "sand"], + "layout": {"visibility": "visible"}, + "paint": {"fill-color": "rgba(245, 238, 188, 1)", "fill-opacity": 1} + }, + { + "id": "building", + "type": "fill", + "metadata": {"mapbox:group": "1444849364238.8171"}, + "source": "openmaptiles", + "source-layer": "building", + "paint": { + "fill-antialias": true, + "fill-color": {"base": 1, "stops": [[15.5, "#f2eae2"], [16, "#dfdbd7"]]} + } + }, + { + "id": "building-top", + "type": "fill", + "metadata": {"mapbox:group": "1444849364238.8171"}, + "source": "openmaptiles", + "source-layer": "building", + "layout": {"visibility": "visible"}, + "paint": { + "fill-color": "#f2eae2", + "fill-opacity": {"base": 1, "stops": [[13, 0], [16, 1]]}, + "fill-outline-color": "#dfdbd7", + "fill-translate": {"base": 1, "stops": [[14, [0, 0]], [16, [-2, -2]]]} + } + }, + { + "id": "tunnel-service-track-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["in", "class", "service", "track"] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#cfcdca", + "line-dasharray": [0.5, 0.25], + "line-width": {"base": 1.2, "stops": [[15, 1], [16, 4], [20, 11]]} + } + }, + { + "id": "tunnel-motorway-link-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["==", "class", "motorway"], + ["==", "ramp", 1] + ], + "layout": {"line-join": "round", "visibility": "visible"}, + "paint": { + "line-color": "rgba(200, 147, 102, 1)", + "line-dasharray": [0.5, 0.25], + "line-width": { + "base": 1.2, + "stops": [[12, 1], [13, 3], [14, 4], [20, 15]] + } + } + }, + { + "id": "tunnel-minor-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["==", "brunnel", "tunnel"], ["==", "class", "minor"]], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#cfcdca", + "line-opacity": {"stops": [[12, 0], [12.5, 1]]}, + "line-width": { + "base": 1.2, + "stops": [[12, 0.5], [13, 1], [14, 4], [20, 15]] + }, + "line-dasharray": [0.5, 0.25] + } + }, + { + "id": "tunnel-link-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["in", "class", "trunk", "primary", "secondary", "tertiary"], + ["==", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#e9ac77", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[12, 1], [13, 3], [14, 4], [20, 15]] + }, + "line-dasharray": [0.5, 0.25] + } + }, + { + "id": "tunnel-secondary-tertiary-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["in", "class", "secondary", "tertiary"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#e9ac77", + "line-opacity": 1, + "line-width": {"base": 1.2, "stops": [[8, 1.5], [20, 17]]}, + "line-dasharray": [0.5, 0.25] + } + }, + { + "id": "tunnel-trunk-primary-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["in", "class", "primary", "trunk"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#e9ac77", + "line-width": { + "base": 1.2, + "stops": [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] + } + } + }, + { + "id": "tunnel-motorway-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["==", "class", "motorway"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round", "visibility": "visible"}, + "paint": { + "line-color": "#e9ac77", + "line-dasharray": [0.5, 0.25], + "line-width": { + "base": 1.2, + "stops": [[5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] + } + } + }, + { + "id": "tunnel-path-steps-casing", + "type": "line", + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "brunnel", "tunnel"], + ["==", "class", "path"], + ["==", "subclass", "steps"] + ], + "layout": {"line-cap": "butt", "line-join": "round"}, + "paint": { + "line-color": "#cfcdca", + "line-opacity": {"stops": [[12, 0], [12.5, 1]]}, + "line-width": { + "base": 1.2, + "stops": [[12, 0.5], [13, 1], [14, 2], [20, 9.25]] + }, + "line-dasharray": [0.5, 0.25] + } + }, + { + "id": "tunnel-path-steps", + "type": "line", + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "brunnel", "tunnel"], + ["==", "class", "path"], + ["==", "subclass", "steps"] + ], + "layout": {"line-join": "bevel", "line-cap": "butt"}, + "paint": { + "line-color": "#fff", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[13.5, 0], [14, 1.25], [20, 5.75]] + }, + "line-dasharray": [0.5, 0.25] + } + }, + { + "id": "tunnel-path", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "brunnel", "tunnel"], + ["==", "class", "path"], + ["!=", "subclass", "steps"] + ], + "paint": { + "line-color": "#cba", + "line-dasharray": [1.5, 0.75], + "line-width": {"base": 1.2, "stops": [[15, 1.2], [20, 4]]} + } + }, + { + "id": "tunnel-motorway-link", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["==", "class", "motorway"], + ["==", "ramp", 1] + ], + "layout": {"line-join": "round", "visibility": "visible"}, + "paint": { + "line-color": "rgba(244, 209, 158, 1)", + "line-width": { + "base": 1.2, + "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] + } + } + }, + { + "id": "tunnel-service-track", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["in", "class", "service", "track"] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fff", + "line-width": {"base": 1.2, "stops": [[15.5, 0], [16, 2], [20, 7.5]]} + } + }, + { + "id": "tunnel-link", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["in", "class", "trunk", "primary", "secondary", "tertiary"], + ["==", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fff4c6", + "line-width": { + "base": 1.2, + "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] + } + } + }, + { + "id": "tunnel-minor", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["==", "brunnel", "tunnel"], ["==", "class", "minor"]], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fff", + "line-opacity": 1, + "line-width": {"base": 1.2, "stops": [[13.5, 0], [14, 2.5], [20, 11.5]]} + } + }, + { + "id": "tunnel-secondary-tertiary", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["in", "class", "secondary", "tertiary"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fff4c6", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 10]]} + } + }, + { + "id": "tunnel-trunk-primary", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["in", "class", "primary", "trunk"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fff4c6", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]]} + } + }, + { + "id": "tunnel-motorway", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "tunnel"], + ["==", "class", "motorway"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round", "visibility": "visible"}, + "paint": { + "line-color": "#ffdaa6", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]]} + } + }, + { + "id": "tunnel-railway", + "type": "line", + "metadata": {"mapbox:group": "1444849354174.1904"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["==", "brunnel", "tunnel"], ["==", "class", "rail"]], + "paint": { + "line-color": "#bbb", + "line-dasharray": [2, 2], + "line-width": {"base": 1.4, "stops": [[14, 0.4], [15, 0.75], [20, 2]]} + } + }, + { + "id": "ferry", + "type": "line", + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["in", "class", "ferry"]], + "layout": {"line-join": "round", "visibility": "visible"}, + "paint": { + "line-color": "rgba(108, 159, 182, 1)", + "line-dasharray": [2, 2], + "line-width": 1.1 + } + }, + { + "id": "aeroway-taxiway-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "aeroway", + "minzoom": 12, + "filter": ["all", ["in", "class", "taxiway"]], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "rgba(153, 153, 153, 1)", + "line-opacity": 1, + "line-width": {"base": 1.5, "stops": [[11, 2], [17, 12]]} + } + }, + { + "id": "aeroway-runway-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "aeroway", + "minzoom": 12, + "filter": ["all", ["in", "class", "runway"]], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "rgba(153, 153, 153, 1)", + "line-opacity": 1, + "line-width": {"base": 1.5, "stops": [[11, 5], [17, 55]]} + } + }, + { + "id": "aeroway-area", + "type": "fill", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "aeroway", + "minzoom": 4, + "filter": [ + "all", + ["==", "$type", "Polygon"], + ["in", "class", "runway", "taxiway"] + ], + "layout": {"visibility": "visible"}, + "paint": { + "fill-color": "rgba(255, 255, 255, 1)", + "fill-opacity": {"base": 1, "stops": [[13, 0], [14, 1]]} + } + }, + { + "id": "aeroway-taxiway", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "aeroway", + "minzoom": 4, + "filter": [ + "all", + ["in", "class", "taxiway"], + ["==", "$type", "LineString"] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "rgba(255, 255, 255, 1)", + "line-opacity": {"base": 1, "stops": [[11, 0], [12, 1]]}, + "line-width": {"base": 1.5, "stops": [[11, 1], [17, 10]]} + } + }, + { + "id": "aeroway-runway", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "aeroway", + "minzoom": 4, + "filter": [ + "all", + ["in", "class", "runway"], + ["==", "$type", "LineString"] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "rgba(255, 255, 255, 1)", + "line-opacity": {"base": 1, "stops": [[11, 0], [12, 1]]}, + "line-width": {"base": 1.5, "stops": [[11, 4], [17, 50]]} + } + }, + { + "id": "road_area_pier", + "type": "fill", + "metadata": {}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["==", "$type", "Polygon"], ["==", "class", "pier"]], + "layout": {"visibility": "visible"}, + "paint": {"fill-antialias": true, "fill-color": "#f8f4f0"} + }, + { + "id": "road_pier", + "type": "line", + "metadata": {}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["==", "$type", "LineString"], ["in", "class", "pier"]], + "layout": {"line-cap": "round", "line-join": "round"}, + "paint": { + "line-color": "#f8f4f0", + "line-width": {"base": 1.2, "stops": [[15, 1], [17, 4]]} + } + }, + { + "id": "highway-area", + "type": "fill", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["==", "$type", "Polygon"], ["!in", "class", "pier"]], + "layout": {"visibility": "visible"}, + "paint": { + "fill-antialias": false, + "fill-color": "hsla(0, 0%, 89%, 0.56)", + "fill-opacity": 0.9, + "fill-outline-color": "#cfcdca" + } + }, + { + "id": "highway-path-steps-casing", + "type": "line", + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "path"], + ["in", "subclass", "steps"] + ], + "layout": {"line-cap": "butt", "line-join": "round"}, + "paint": { + "line-color": "#cfcdca", + "line-opacity": {"stops": [[12, 0], [12.5, 1]]}, + "line-width": { + "base": 1.2, + "stops": [[12, 0.5], [13, 1], [14, 2], [20, 9.25]] + } + } + }, + { + "id": "highway-motorway-link-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 12, + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "motorway"], + ["==", "ramp", 1] + ], + "layout": {"line-cap": "round", "line-join": "round"}, + "paint": { + "line-color": "#e9ac77", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[12, 1], [13, 3], [14, 4], [20, 15]] + } + } + }, + { + "id": "highway-link-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 13, + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["in", "class", "trunk", "primary", "secondary", "tertiary"], + ["==", "ramp", 1] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#e9ac77", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[12, 1], [13, 3], [14, 4], [20, 15]] + } + } + }, + { + "id": "highway-minor-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!=", "brunnel", "tunnel"], + ["in", "class", "minor", "service", "track"] + ], + "layout": {"line-cap": "round", "line-join": "round"}, + "paint": { + "line-color": "#cfcdca", + "line-opacity": {"stops": [[12, 0], [12.5, 1]]}, + "line-width": { + "base": 1.2, + "stops": [[12, 0.5], [13, 1], [14, 4], [20, 15]] + } + } + }, + { + "id": "highway-secondary-tertiary-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["in", "class", "secondary", "tertiary"], + ["!=", "ramp", 1] + ], + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#e9ac77", + "line-opacity": 1, + "line-width": {"base": 1.2, "stops": [[8, 1.5], [20, 17]]} + } + }, + { + "id": "highway-primary-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 5, + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["in", "class", "primary"], + ["!=", "ramp", 1] + ], + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#e9ac77", + "line-opacity": {"stops": [[7, 0], [8, 1]]}, + "line-width": { + "base": 1.2, + "stops": [[7, 0], [8, 0.6], [9, 1.5], [20, 22]] + } + } + }, + { + "id": "highway-trunk-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 5, + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["in", "class", "trunk"], + ["!=", "ramp", 1] + ], + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#e9ac77", + "line-opacity": {"stops": [[5, 0], [6, 1]]}, + "line-width": { + "base": 1.2, + "stops": [[5, 0], [6, 0.6], [7, 1.5], [20, 22]] + } + } + }, + { + "id": "highway-motorway-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 4, + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "motorway"], + ["!=", "ramp", 1] + ], + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#e9ac77", + "line-opacity": {"stops": [[4, 0], [5, 1]]}, + "line-width": { + "base": 1.2, + "stops": [[4, 0], [5, 0.4], [6, 0.6], [7, 1.5], [20, 22]] + } + } + }, + { + "id": "highway-path", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "path"], + ["!=", "subclass", "steps"] + ], + "paint": { + "line-color": "#cba", + "line-dasharray": [1.5, 0.75], + "line-width": {"base": 1.2, "stops": [[15, 1.2], [20, 4]]} + } + }, + { + "id": "highway-path-steps", + "type": "line", + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "path"], + ["==", "subclass", "steps"] + ], + "layout": {"line-join": "bevel", "line-cap": "butt"}, + "paint": { + "line-color": "#fff", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[13.5, 0], [14, 1.25], [20, 5.75]] + }, + "line-dasharray": [0.5, 0.25] + } + }, + { + "id": "highway-motorway-link", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 12, + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "motorway"], + ["==", "ramp", 1] + ], + "layout": {"line-cap": "round", "line-join": "round"}, + "paint": { + "line-color": "#fc8", + "line-width": { + "base": 1.2, + "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] + } + } + }, + { + "id": "highway-link", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 13, + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["in", "class", "trunk", "primary", "secondary", "tertiary"], + ["==", "ramp", 1] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#fea", + "line-width": { + "base": 1.2, + "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] + } + } + }, + { + "id": "highway-minor", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!=", "brunnel", "tunnel"], + ["in", "class", "minor", "service", "track"] + ], + "layout": {"line-cap": "round", "line-join": "round"}, + "paint": { + "line-color": "#fff", + "line-opacity": 1, + "line-width": {"base": 1.2, "stops": [[13.5, 0], [14, 2.5], [20, 11.5]]} + } + }, + { + "id": "highway-secondary-tertiary", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["!in", "brunnel", "bridge", "tunnel"], + ["in", "class", "secondary", "tertiary"], + ["!=", "ramp", 1] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#fea", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [8, 0.5], [20, 13]]} + } + }, + { + "id": "highway-primary", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!in", "brunnel", "bridge", "tunnel"], + ["in", "class", "primary"], + ["!=", "ramp", 1] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#fea", + "line-width": {"base": 1.2, "stops": [[8.5, 0], [9, 0.5], [20, 18]]} + } + }, + { + "id": "highway-trunk", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!in", "brunnel", "bridge", "tunnel"], + ["in", "class", "trunk"], + ["!=", "ramp", 1] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#fea", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]]} + } + }, + { + "id": "highway-motorway", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 5, + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "motorway"], + ["!=", "ramp", 1] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "#fc8", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]]} + } + }, + { + "id": "railway-transit", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "class", "transit"], + ["!in", "brunnel", "tunnel"] + ], + "layout": {"visibility": "visible"}, + "paint": { + "line-color": "hsla(0, 0%, 73%, 0.77)", + "line-width": {"base": 1.4, "stops": [[14, 0.4], [20, 1]]} + } + }, + { + "id": "railway-transit-hatching", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "class", "transit"], + ["!in", "brunnel", "tunnel"] + ], + "layout": {"visibility": "visible"}, + "paint": { + "line-color": "hsla(0, 0%, 73%, 0.68)", + "line-dasharray": [0.2, 8], + "line-width": {"base": 1.4, "stops": [[14.5, 0], [15, 2], [20, 6]]} + } + }, + { + "id": "railway-service", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "class", "rail"], + ["has", "service"] + ], + "paint": { + "line-color": "hsla(0, 0%, 73%, 0.77)", + "line-width": {"base": 1.4, "stops": [[14, 0.4], [20, 1]]} + } + }, + { + "id": "railway-service-hatching", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "class", "rail"], + ["has", "service"] + ], + "layout": {"visibility": "visible"}, + "paint": { + "line-color": "hsla(0, 0%, 73%, 0.68)", + "line-dasharray": [0.2, 8], + "line-width": {"base": 1.4, "stops": [[14.5, 0], [15, 2], [20, 6]]} + } + }, + { + "id": "railway", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!has", "service"], + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "rail"] + ], + "paint": { + "line-color": "#bbb", + "line-width": {"base": 1.4, "stops": [[14, 0.4], [15, 0.75], [20, 2]]} + } + }, + { + "id": "railway-hatching", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["!has", "service"], + ["!in", "brunnel", "bridge", "tunnel"], + ["==", "class", "rail"] + ], + "paint": { + "line-color": "#bbb", + "line-dasharray": [0.2, 8], + "line-width": {"base": 1.4, "stops": [[14.5, 0], [15, 3], [20, 8]]} + } + }, + { + "id": "bridge-motorway-link-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["==", "class", "motorway"], + ["==", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#e9ac77", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[12, 1], [13, 3], [14, 4], [20, 19]] + } + } + }, + { + "id": "bridge-link-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["in", "class", "trunk", "primary", "secondary", "tertiary"], + ["==", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#e9ac77", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[12, 1], [13, 3], [14, 4], [20, 19]] + } + } + }, + { + "id": "bridge-secondary-tertiary-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["in", "class", "secondary", "tertiary"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#e9ac77", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[5, 0.4], [7, 0.6], [8, 1.5], [20, 21]] + } + } + }, + { + "id": "bridge-trunk-primary-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["in", "class", "primary", "trunk"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "hsl(28, 76%, 67%)", + "line-width": { + "base": 1.2, + "stops": [[5, 0.4], [6, 0.6], [7, 1.5], [20, 26]] + } + } + }, + { + "id": "bridge-motorway-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["==", "class", "motorway"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#e9ac77", + "line-width": { + "base": 1.2, + "stops": [[5, 0.4], [6, 0.6], [7, 1.5], [20, 26]] + } + } + }, + { + "id": "bridge-minor-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "brunnel", "bridge"], + ["in", "class", "minor", "service", "track"] + ], + "layout": {"line-cap": "butt", "line-join": "round"}, + "paint": { + "line-color": "#cfcdca", + "line-opacity": {"stops": [[12, 0], [12.5, 1]]}, + "line-width": { + "base": 1.2, + "stops": [[12, 0.5], [13, 1], [14, 6], [20, 24]] + } + } + }, + { + "id": "bridge-path-casing", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "brunnel", "bridge"], + ["==", "class", "path"] + ], + "paint": { + "line-color": "#cfcdca", + "line-width": {"base": 1.2, "stops": [[15, 1.2], [20, 18]]} + } + }, + { + "id": "bridge-path-steps", + "type": "line", + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "brunnel", "bridge"], + ["==", "class", "path"], + ["==", "subclass", "steps"] + ], + "layout": {"line-join": "round", "line-cap": "butt"}, + "paint": { + "line-color": "#fff", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [[13.5, 0], [14, 1.25], [20, 5.75]] + }, + "line-dasharray": [0.5, 0.25] + } + }, + { + "id": "bridge-path", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "brunnel", "bridge"], + ["==", "class", "path"], + ["!=", "subclass", "steps"] + ], + "paint": { + "line-color": "#cba", + "line-dasharray": [1.5, 0.75], + "line-width": {"base": 1.2, "stops": [[15, 1.2], [20, 4]]} + } + }, + { + "id": "bridge-motorway-link", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["==", "class", "motorway"], + ["==", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fc8", + "line-width": { + "base": 1.2, + "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] + } + } + }, + { + "id": "bridge-link", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["in", "class", "trunk", "primary", "secondary", "tertiary"], + ["==", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fea", + "line-width": { + "base": 1.2, + "stops": [[12.5, 0], [13, 1.5], [14, 2.5], [20, 11.5]] + } + } + }, + { + "id": "bridge-minor", + "type": "line", + "metadata": {"mapbox:group": "1444849345966.4436"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "$type", "LineString"], + ["==", "brunnel", "bridge"], + ["in", "class", "minor", "service", "track"] + ], + "layout": {"line-cap": "round", "line-join": "round"}, + "paint": { + "line-color": "#fff", + "line-opacity": 1, + "line-width": {"base": 1.2, "stops": [[13.5, 0], [14, 2.5], [20, 11.5]]} + } + }, + { + "id": "bridge-secondary-tertiary", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["in", "class", "secondary", "tertiary"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fea", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [8, 0.5], [20, 13]]} + } + }, + { + "id": "bridge-trunk-primary", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["in", "class", "primary", "trunk"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fea", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]]} + } + }, + { + "id": "bridge-motorway", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": [ + "all", + ["==", "brunnel", "bridge"], + ["==", "class", "motorway"], + ["!=", "ramp", 1] + ], + "layout": {"line-join": "round"}, + "paint": { + "line-color": "#fc8", + "line-width": {"base": 1.2, "stops": [[6.5, 0], [7, 0.5], [20, 18]]} + } + }, + { + "id": "bridge-railway", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["==", "brunnel", "bridge"], ["==", "class", "rail"]], + "paint": { + "line-color": "#bbb", + "line-width": {"base": 1.4, "stops": [[14, 0.4], [15, 0.75], [20, 2]]} + } + }, + { + "id": "bridge-railway-hatching", + "type": "line", + "metadata": {"mapbox:group": "1444849334699.1902"}, + "source": "openmaptiles", + "source-layer": "transportation", + "filter": ["all", ["==", "brunnel", "bridge"], ["==", "class", "rail"]], + "paint": { + "line-color": "#bbb", + "line-dasharray": [0.2, 8], + "line-width": {"base": 1.4, "stops": [[14.5, 0], [15, 3], [20, 8]]} + } + }, + { + "id": "cablecar", + "type": "line", + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 13, + "filter": ["==", "subclass", "cable_car"], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "hsl(0, 0%, 70%)", + "line-width": {"base": 1, "stops": [[11, 1], [19, 2.5]]} + } + }, + { + "id": "cablecar-dash", + "type": "line", + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 13, + "filter": ["==", "subclass", "cable_car"], + "layout": {"line-cap": "round", "visibility": "visible"}, + "paint": { + "line-color": "hsl(0, 0%, 70%)", + "line-dasharray": [2, 3], + "line-width": {"base": 1, "stops": [[11, 3], [19, 5.5]]} + } + }, + { + "id": "boundary-land-level-4", + "type": "line", + "source": "openmaptiles", + "source-layer": "boundary", + "minzoom": 2, + "filter": [ + "all", + [">=", "admin_level", 3], + ["<=", "admin_level", 8], + ["!=", "maritime", 1] + ], + "layout": {"line-join": "round", "visibility": "visible"}, + "paint": { + "line-color": "#9e9cab", + "line-dasharray": [3, 1, 1, 1], + "line-width": {"base": 1.4, "stops": [[4, 0.4], [5, 1], [12, 3]]} + } + }, + { + "id": "boundary-land-level-2", + "type": "line", + "source": "openmaptiles", + "source-layer": "boundary", + "filter": [ + "all", + ["==", "admin_level", 2], + ["!=", "maritime", 1], + ["!=", "disputed", 1] + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(248, 7%, 66%)", + "line-width": { + "base": 1, + "stops": [[0, 0.6], [4, 1.4], [5, 2], [12, 8]] + } + } + }, + { + "id": "boundary-land-disputed", + "type": "line", + "source": "openmaptiles", + "source-layer": "boundary", + "filter": ["all", ["!=", "maritime", 1], ["==", "disputed", 1]], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(248, 7%, 70%)", + "line-dasharray": [1, 3], + "line-width": { + "base": 1, + "stops": [[0, 0.6], [4, 1.4], [5, 2], [12, 8]] + } + } + }, + { + "id": "boundary-water", + "type": "line", + "source": "openmaptiles", + "source-layer": "boundary", + "minzoom": 4, + "filter": ["all", ["in", "admin_level", 2, 4], ["==", "maritime", 1]], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "rgba(154, 189, 214, 1)", + "line-opacity": {"stops": [[6, 0.6], [10, 1]]}, + "line-width": { + "base": 1, + "stops": [[0, 0.6], [4, 1.4], [5, 2], [12, 8]] + } + } + }, + { + "id": "waterway-name", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "waterway", + "minzoom": 13, + "filter": ["all", ["==", "$type", "LineString"], ["has", "name"]], + "layout": { + "symbol-placement": "line", + "symbol-spacing": 350, + "text-field": "{name:latin} {name:nonlatin}", + "text-font": ["Noto Sans Italic"], + "text-letter-spacing": 0.2, + "text-max-width": 5, + "text-rotation-alignment": "map", + "text-size": 14 + }, + "paint": { + "text-color": "#74aee9", + "text-halo-color": "rgba(255,255,255,0.7)", + "text-halo-width": 1.5 + } + }, + { + "id": "water-name-lakeline", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "water_name", + "filter": ["==", "$type", "LineString"], + "layout": { + "symbol-placement": "line", + "symbol-spacing": 350, + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Italic"], + "text-letter-spacing": 0.2, + "text-max-width": 5, + "text-rotation-alignment": "map", + "text-size": 14 + }, + "paint": { + "text-color": "#74aee9", + "text-halo-color": "rgba(255,255,255,0.7)", + "text-halo-width": 1.5 + } + }, + { + "id": "water-name-ocean", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "water_name", + "filter": ["all", ["==", "$type", "Point"], ["==", "class", "ocean"]], + "layout": { + "symbol-placement": "point", + "symbol-spacing": 350, + "text-field": "{name:latin}", + "text-font": ["Noto Sans Italic"], + "text-letter-spacing": 0.2, + "text-max-width": 5, + "text-rotation-alignment": "map", + "text-size": 14 + }, + "paint": { + "text-color": "#74aee9", + "text-halo-color": "rgba(255,255,255,0.7)", + "text-halo-width": 1.5 + } + }, + { + "id": "water-name-other", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "water_name", + "filter": ["all", ["==", "$type", "Point"], ["!in", "class", "ocean"]], + "layout": { + "symbol-placement": "point", + "symbol-spacing": 350, + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Italic"], + "text-letter-spacing": 0.2, + "text-max-width": 5, + "text-rotation-alignment": "map", + "text-size": {"stops": [[0, 10], [6, 14]]}, + "visibility": "visible" + }, + "paint": { + "text-color": "#74aee9", + "text-halo-color": "rgba(255,255,255,0.7)", + "text-halo-width": 1.5 + } + }, + { + "id": "road_oneway", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 15, + "filter": [ + "all", + ["==", "oneway", 1], + [ + "in", + "class", + "motorway", + "trunk", + "primary", + "secondary", + "tertiary", + "minor", + "service" + ] + ], + "layout": { + "icon-image": "oneway", + "icon-padding": 2, + "icon-rotate": 90, + "icon-rotation-alignment": "map", + "icon-size": {"stops": [[15, 0.5], [19, 1]]}, + "symbol-placement": "line", + "symbol-spacing": 75 + }, + "paint": {"icon-opacity": 0.5} + }, + { + "id": "road_oneway_opposite", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "transportation", + "minzoom": 15, + "filter": [ + "all", + ["==", "oneway", -1], + [ + "in", + "class", + "motorway", + "trunk", + "primary", + "secondary", + "tertiary", + "minor", + "service" + ] + ], + "layout": { + "icon-image": "oneway", + "icon-padding": 2, + "icon-rotate": -90, + "icon-rotation-alignment": "map", + "icon-size": {"stops": [[15, 0.5], [19, 1]]}, + "symbol-placement": "line", + "symbol-spacing": 75 + }, + "paint": {"icon-opacity": 0.5} + }, + { + "id": "poi-level-3", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "poi", + "minzoom": 16, + "filter": [ + "all", + ["==", "$type", "Point"], + [">=", "rank", 25], + ["any", ["!has", "level"], ["==", "level", 0]] + ], + "layout": { + "icon-image": "{class}_11", + "text-anchor": "top", + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-max-width": 9, + "text-offset": [0, 0.6], + "text-padding": 2, + "text-size": 12, + "visibility": "visible" + }, + "paint": { + "text-color": "#666", + "text-halo-blur": 0.5, + "text-halo-color": "#ffffff", + "text-halo-width": 1 + } + }, + { + "id": "poi-level-2", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "poi", + "minzoom": 15, + "filter": [ + "all", + ["==", "$type", "Point"], + ["<=", "rank", 24], + [">=", "rank", 15], + ["any", ["!has", "level"], ["==", "level", 0]] + ], + "layout": { + "icon-image": "{class}_11", + "text-anchor": "top", + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-max-width": 9, + "text-offset": [0, 0.6], + "text-padding": 2, + "text-size": 12, + "visibility": "visible" + }, + "paint": { + "text-color": "#666", + "text-halo-blur": 0.5, + "text-halo-color": "#ffffff", + "text-halo-width": 1 + } + }, + { + "id": "poi-level-1", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "poi", + "minzoom": 14, + "filter": [ + "all", + ["==", "$type", "Point"], + ["<=", "rank", 14], + ["has", "name"], + ["any", ["!has", "level"], ["==", "level", 0]] + ], + "layout": { + "icon-image": "{class}_11", + "text-anchor": "top", + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-max-width": 9, + "text-offset": [0, 0.6], + "text-padding": 2, + "text-size": 12, + "visibility": "visible" + }, + "paint": { + "text-color": "#666", + "text-halo-blur": 0.5, + "text-halo-color": "#ffffff", + "text-halo-width": 1 + } + }, + { + "id": "poi-railway", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "poi", + "minzoom": 13, + "filter": [ + "all", + ["==", "$type", "Point"], + ["has", "name"], + ["==", "class", "railway"], + ["==", "subclass", "station"] + ], + "layout": { + "icon-allow-overlap": false, + "icon-ignore-placement": false, + "icon-image": "{class}_11", + "icon-optional": false, + "text-allow-overlap": false, + "text-anchor": "top", + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-ignore-placement": false, + "text-max-width": 9, + "text-offset": [0, 0.6], + "text-optional": true, + "text-padding": 2, + "text-size": 12 + }, + "paint": { + "text-color": "#666", + "text-halo-blur": 0.5, + "text-halo-color": "#ffffff", + "text-halo-width": 1 + } + }, + { + "id": "highway-name-path", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "transportation_name", + "minzoom": 15.5, + "filter": ["==", "class", "path"], + "layout": { + "symbol-placement": "line", + "text-field": "{name:latin} {name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-rotation-alignment": "map", + "text-size": {"base": 1, "stops": [[13, 12], [14, 13]]} + }, + "paint": { + "text-color": "hsl(30, 23%, 62%)", + "text-halo-color": "#f8f4f0", + "text-halo-width": 0.5 + } + }, + { + "id": "highway-name-minor", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "transportation_name", + "minzoom": 15, + "filter": [ + "all", + ["==", "$type", "LineString"], + ["in", "class", "minor", "service", "track"] + ], + "layout": { + "symbol-placement": "line", + "text-field": "{name:latin} {name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-rotation-alignment": "map", + "text-size": {"base": 1, "stops": [[13, 12], [14, 13]]} + }, + "paint": { + "text-color": "#765", + "text-halo-blur": 0.5, + "text-halo-width": 1 + } + }, + { + "id": "highway-name-major", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "transportation_name", + "minzoom": 12.2, + "filter": ["in", "class", "primary", "secondary", "tertiary", "trunk"], + "layout": { + "symbol-placement": "line", + "text-field": "{name:latin} {name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-rotation-alignment": "map", + "text-size": {"base": 1, "stops": [[13, 12], [14, 13]]} + }, + "paint": { + "text-color": "#765", + "text-halo-blur": 0.5, + "text-halo-width": 1 + } + }, + { + "id": "highway-shield", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "transportation_name", + "minzoom": 8, + "filter": [ + "all", + ["<=", "ref_length", 6], + ["==", "$type", "LineString"], + ["!in", "network", "us-interstate", "us-highway", "us-state"] + ], + "layout": { + "icon-image": "road_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-placement": {"base": 1, "stops": [[10, "point"], [11, "line"]]}, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": ["Noto Sans Regular"], + "text-rotation-alignment": "viewport", + "text-size": 10 + }, + "paint": {} + }, + { + "id": "highway-shield-us-interstate", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "transportation_name", + "minzoom": 7, + "filter": [ + "all", + ["<=", "ref_length", 6], + ["==", "$type", "LineString"], + ["in", "network", "us-interstate"] + ], + "layout": { + "icon-image": "{network}_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-placement": { + "base": 1, + "stops": [[7, "point"], [7, "line"], [8, "line"]] + }, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": ["Noto Sans Regular"], + "text-rotation-alignment": "viewport", + "text-size": 10 + }, + "paint": {"text-color": "rgba(0, 0, 0, 1)"} + }, + { + "id": "highway-shield-us-other", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "transportation_name", + "minzoom": 9, + "filter": [ + "all", + ["<=", "ref_length", 6], + ["==", "$type", "LineString"], + ["in", "network", "us-highway", "us-state"] + ], + "layout": { + "icon-image": "{network}_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-placement": {"base": 1, "stops": [[10, "point"], [11, "line"]]}, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": ["Noto Sans Regular"], + "text-rotation-alignment": "viewport", + "text-size": 10 + }, + "paint": {"text-color": "rgba(0, 0, 0, 1)"} + }, + { + "id": "airport-label-major", + "type": "symbol", + "source": "openmaptiles", + "source-layer": "aerodrome_label", + "minzoom": 10, + "filter": ["all", ["has", "iata"]], + "layout": { + "icon-image": "airport_11", + "icon-size": 1, + "text-anchor": "top", + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-max-width": 9, + "text-offset": [0, 0.6], + "text-optional": true, + "text-padding": 2, + "text-size": 12, + "visibility": "visible" + }, + "paint": { + "text-color": "#666", + "text-halo-blur": 0.5, + "text-halo-color": "#ffffff", + "text-halo-width": 1 + } + }, + { + "id": "place-other", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": [ + "!in", + "class", + "city", + "town", + "village", + "state", + "country", + "continent" + ], + "layout": { + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Bold"], + "text-letter-spacing": 0.1, + "text-max-width": 9, + "text-size": {"base": 1.2, "stops": [[12, 10], [15, 14]]}, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "#633", + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 1.2 + } + }, + { + "id": "place-village", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": ["==", "class", "village"], + "layout": { + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-max-width": 8, + "text-size": {"base": 1.2, "stops": [[10, 12], [15, 22]]}, + "visibility": "visible" + }, + "paint": { + "text-color": "#333", + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 1.2 + } + }, + { + "id": "place-town", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": ["==", "class", "town"], + "layout": { + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-max-width": 8, + "text-size": {"base": 1.2, "stops": [[10, 14], [15, 24]]}, + "visibility": "visible" + }, + "paint": { + "text-color": "#333", + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 1.2 + } + }, + { + "id": "place-city", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": ["all", ["!=", "capital", 2], ["==", "class", "city"]], + "layout": { + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-max-width": 8, + "text-size": {"base": 1.2, "stops": [[7, 14], [11, 24]]}, + "visibility": "visible" + }, + "paint": { + "text-color": "#333", + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 1.2 + } + }, + { + "id": "place-city-capital", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": ["all", ["==", "capital", 2], ["==", "class", "city"]], + "layout": { + "icon-image": "star_11", + "icon-size": 0.8, + "text-anchor": "left", + "text-field": "{name:latin}\n{name:nonlatin}", + "text-font": ["Noto Sans Regular"], + "text-max-width": 8, + "text-offset": [0.4, 0], + "text-size": {"base": 1.2, "stops": [[7, 14], [11, 24]]}, + "visibility": "visible" + }, + "paint": { + "text-color": "#333", + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 1.2 + } + }, + { + "id": "place-state", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": ["in", "class", "state"], + "layout": { + "text-field": "{name:latin}", + "text-font": ["Noto Sans Bold"], + "text-letter-spacing": 0.1, + "text-max-width": 9, + "text-size": {"base": 1.2, "stops": [[12, 10], [15, 14]]}, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "#633", + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 1.2 + } + }, + { + "id": "place-country-other", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": [ + "all", + ["==", "class", "country"], + [">=", "rank", 3], + ["!has", "iso_a2"] + ], + "layout": { + "text-field": "{name:latin}", + "text-font": ["Noto Sans Italic"], + "text-max-width": 6.25, + "text-size": {"stops": [[3, 11], [7, 17]]}, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "#334", + "text-halo-blur": 1, + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 2 + } + }, + { + "id": "place-country-3", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": [ + "all", + ["==", "class", "country"], + [">=", "rank", 3], + ["has", "iso_a2"] + ], + "layout": { + "text-field": "{name:latin}", + "text-font": ["Noto Sans Bold"], + "text-max-width": 6.25, + "text-size": {"stops": [[3, 11], [7, 17]]}, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "#334", + "text-halo-blur": 1, + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 2 + } + }, + { + "id": "place-country-2", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": [ + "all", + ["==", "class", "country"], + ["==", "rank", 2], + ["has", "iso_a2"] + ], + "layout": { + "text-field": "{name:latin}", + "text-font": ["Noto Sans Bold"], + "text-max-width": 6.25, + "text-size": {"stops": [[2, 11], [5, 17]]}, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "#334", + "text-halo-blur": 1, + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 2 + } + }, + { + "id": "place-country-1", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "filter": [ + "all", + ["==", "class", "country"], + ["==", "rank", 1], + ["has", "iso_a2"] + ], + "layout": { + "text-field": "{name:latin}", + "text-font": ["Noto Sans Bold"], + "text-max-width": 6.25, + "text-size": {"stops": [[1, 11], [4, 17]]}, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "#334", + "text-halo-blur": 1, + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 2 + } + }, + { + "id": "place-continent", + "type": "symbol", + "metadata": {"mapbox:group": "1444849242106.713"}, + "source": "openmaptiles", + "source-layer": "place", + "maxzoom": 1, + "filter": ["==", "class", "continent"], + "layout": { + "text-field": "{name:latin}", + "text-font": ["Noto Sans Bold"], + "text-max-width": 6.25, + "text-size": 14, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "#334", + "text-halo-blur": 1, + "text-halo-color": "rgba(255,255,255,0.8)", + "text-halo-width": 2 + } + } + ], + "id": "bright" +} \ No newline at end of file diff --git a/library/src/commonTest/composeResources/files/test_style_bright_sprite.json b/library/src/commonTest/composeResources/files/test_style_bright_sprite.json new file mode 100644 index 00000000..27fb85e7 --- /dev/null +++ b/library/src/commonTest/composeResources/files/test_style_bright_sprite.json @@ -0,0 +1,709 @@ +{ + "airfield_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 21, + "y": 0 + }, + "airport_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 0, + "y": 21 + }, + "alcohol_shop_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 17, + "y": 21 + }, + "amusement_park_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 34, + "y": 21 + }, + "aquarium_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 51, + "y": 21 + }, + "art_gallery_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 38, + "y": 0 + }, + "attraction_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 55, + "y": 0 + }, + "bakery_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 0, + "y": 38 + }, + "bank_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 17, + "y": 38 + }, + "bar_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 34, + "y": 38 + }, + "beer_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 51, + "y": 38 + }, + "bicycle_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 0, + "y": 55 + }, + "bicycle_rental_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 17, + "y": 55 + }, + "bus_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 34, + "y": 55 + }, + "cafe_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 51, + "y": 55 + }, + "campsite_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 68, + "y": 21 + }, + "car_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 85, + "y": 21 + }, + "castle_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 102, + "y": 21 + }, + "cemetery_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 119, + "y": 21 + }, + "cinema_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 136, + "y": 21 + }, + "circle_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 68, + "y": 38 + }, + "circle_stroked_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 85, + "y": 38 + }, + "clothing_store_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 102, + "y": 38 + }, + "college_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 119, + "y": 38 + }, + "dentist_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 136, + "y": 38 + }, + "doctor_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 68, + "y": 55 + }, + "dog_park_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 85, + "y": 55 + }, + "drinking_water_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 102, + "y": 55 + }, + "embassy_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 119, + "y": 55 + }, + "entrance_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 136, + "y": 55 + }, + "fast_food_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 72, + "y": 0 + }, + "ferry_terminal_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 89, + "y": 0 + }, + "fire_station_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 106, + "y": 0 + }, + "fuel_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 123, + "y": 0 + }, + "garden_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 140, + "y": 0 + }, + "golf_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 0, + "y": 72 + }, + "grocery_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 17, + "y": 72 + }, + "harbor_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 34, + "y": 72 + }, + "heliport_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 51, + "y": 72 + }, + "hospital_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 68, + "y": 72 + }, + "ice_cream_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 85, + "y": 72 + }, + "information_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 102, + "y": 72 + }, + "laundry_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 119, + "y": 72 + }, + "library_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 136, + "y": 72 + }, + "lodging_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 0, + "y": 89 + }, + "marker_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 17, + "y": 89 + }, + "monument_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 34, + "y": 89 + }, + "mountain_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 51, + "y": 89 + }, + "museum_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 68, + "y": 89 + }, + "music_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 85, + "y": 89 + }, + "oneway": { + "height": 21, + "pixelRatio": 1, + "width": 21, + "x": 0, + "y": 0 + }, + "park_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 102, + "y": 89 + }, + "pharmacy_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 119, + "y": 89 + }, + "picnic_site_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 136, + "y": 89 + }, + "pitch_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 0, + "y": 106 + }, + "place_of_worship_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 17, + "y": 106 + }, + "playground_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 34, + "y": 106 + }, + "police_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 51, + "y": 106 + }, + "post_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 68, + "y": 106 + }, + "prison_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 85, + "y": 106 + }, + "rail_light_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 102, + "y": 106 + }, + "rail_metro_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 119, + "y": 106 + }, + "railway_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 136, + "y": 106 + }, + "religious_christian_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 0, + "y": 123 + }, + "religious_jewish_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 17, + "y": 123 + }, + "religious_muslim_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 34, + "y": 123 + }, + "restaurant_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 51, + "y": 123 + }, + "road_1": { + "height": 14, + "pixelRatio": 1, + "width": 14, + "x": 280, + "y": 21 + }, + "road_2": { + "height": 14, + "pixelRatio": 1, + "width": 20, + "x": 294, + "y": 21 + }, + "road_3": { + "height": 14, + "pixelRatio": 1, + "width": 25, + "x": 153, + "y": 38 + }, + "road_4": { + "height": 14, + "pixelRatio": 1, + "width": 31, + "x": 178, + "y": 38 + }, + "road_5": { + "height": 14, + "pixelRatio": 1, + "width": 36, + "x": 209, + "y": 38 + }, + "road_6": { + "height": 14, + "pixelRatio": 1, + "width": 40, + "x": 245, + "y": 38 + }, + "rocket_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 68, + "y": 123 + }, + "school_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 85, + "y": 123 + }, + "shop_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 102, + "y": 123 + }, + "stadium_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 119, + "y": 123 + }, + "star_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 136, + "y": 123 + }, + "suitcase_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 0, + "y": 140 + }, + "swimming_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 17, + "y": 140 + }, + "theatre_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 34, + "y": 140 + }, + "toilet_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 51, + "y": 140 + }, + "town_hall_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 68, + "y": 140 + }, + "triangle_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 85, + "y": 140 + }, + "triangle_stroked_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 102, + "y": 140 + }, + "us-highway_1": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 119, + "y": 140 + }, + "us-highway_2": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 136, + "y": 140 + }, + "us-highway_3": { + "height": 17, + "pixelRatio": 1, + "width": 21, + "x": 153, + "y": 21 + }, + "us-interstate_1": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 174, + "y": 21 + }, + "us-interstate_2": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 191, + "y": 21 + }, + "us-interstate_3": { + "height": 17, + "pixelRatio": 1, + "width": 21, + "x": 208, + "y": 21 + }, + "us-state_1": { + "height": 14, + "pixelRatio": 1, + "width": 17, + "x": 314, + "y": 21 + }, + "us-state_2": { + "height": 14, + "pixelRatio": 1, + "width": 22, + "x": 285, + "y": 38 + }, + "us-state_3": { + "height": 14, + "pixelRatio": 1, + "width": 27, + "x": 307, + "y": 38 + }, + "us-state_4": { + "height": 14, + "pixelRatio": 1, + "width": 32, + "x": 153, + "y": 55 + }, + "us-state_5": { + "height": 14, + "pixelRatio": 1, + "width": 37, + "x": 185, + "y": 55 + }, + "us-state_6": { + "height": 14, + "pixelRatio": 1, + "width": 42, + "x": 222, + "y": 55 + }, + "veterinary_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 229, + "y": 21 + }, + "volcano_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 246, + "y": 21 + }, + "wave": { + "height": 8, + "pixelRatio": 1, + "width": 16, + "x": 264, + "y": 55 + }, + "zoo_11": { + "height": 17, + "pixelRatio": 1, + "width": 17, + "x": 263, + "y": 21 + } +} \ No newline at end of file diff --git a/library/src/commonTest/composeResources/files/test_style_bright_sprite.png b/library/src/commonTest/composeResources/files/test_style_bright_sprite.png new file mode 100644 index 00000000..79cafb16 Binary files /dev/null and b/library/src/commonTest/composeResources/files/test_style_bright_sprite.png differ diff --git a/library/src/commonTest/composeResources/files/test_style_simple.json b/library/src/commonTest/composeResources/files/test_style_simple.json new file mode 100644 index 00000000..4e3d981d --- /dev/null +++ b/library/src/commonTest/composeResources/files/test_style_simple.json @@ -0,0 +1,546 @@ +{ + "id": "43f36e14-e3f5-43c1-84c0-50a9c80dc5c7", + "name": "MapLibre", + "zoom": 0, + "pitch": 0, + "center": [ + 17.65431710431244, + 32.954120326746775 + ], + "glyphs": "https://demotiles.maplibre.org/font/{fontstack}/{range}.pbf", + "layers": [ + { + "id": "background", + "type": "background", + "paint": { + "background-color": "#D8F2FF" + }, + "filter": [ + "all" + ], + "layout": { + "visibility": "visible" + }, + "maxzoom": 24 + }, + { + "id": "coastline", + "type": "line", + "paint": { + "line-blur": 0.5, + "line-color": "#198EC8", + "line-width": { + "stops": [ + [ + 0, + 2 + ], + [ + 6, + 6 + ], + [ + 14, + 9 + ], + [ + 22, + 18 + ] + ] + } + }, + "filter": [ + "all" + ], + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "source": "maplibre", + "maxzoom": 24, + "minzoom": 0, + "source-layer": "countries" + }, + { + "id": "countries-fill", + "type": "fill", + "paint": { + "fill-color": [ + "match", + [ + "get", + "ADM0_A3" + ], + [ + "ARM", + "ATG", + "AUS", + "BTN", + "CAN", + "COG", + "CZE", + "GHA", + "GIN", + "HTI", + "ISL", + "JOR", + "KHM", + "KOR", + "LVA", + "MLT", + "MNE", + "MOZ", + "PER", + "SAH", + "SGP", + "SLV", + "SOM", + "TJK", + "TUV", + "UKR", + "WSM" + ], + "#D6C7FF", + [ + "AZE", + "BGD", + "CHL", + "CMR", + "CSI", + "DEU", + "DJI", + "GUY", + "HUN", + "IOA", + "JAM", + "LBN", + "LBY", + "LSO", + "MDG", + "MKD", + "MNG", + "MRT", + "NIU", + "NZL", + "PCN", + "PYF", + "SAU", + "SHN", + "STP", + "TTO", + "UGA", + "UZB", + "ZMB" + ], + "#EBCA8A", + [ + "AGO", + "ASM", + "ATF", + "BDI", + "BFA", + "BGR", + "BLZ", + "BRA", + "CHN", + "CRI", + "ESP", + "HKG", + "HRV", + "IDN", + "IRN", + "ISR", + "KNA", + "LBR", + "LCA", + "MAC", + "MUS", + "NOR", + "PLW", + "POL", + "PRI", + "SDN", + "TUN", + "UMI", + "USA", + "USG", + "VIR", + "VUT" + ], + "#C1E599", + [ + "ARE", + "ARG", + "BHS", + "CIV", + "CLP", + "DMA", + "ETH", + "GAB", + "GRD", + "HMD", + "IND", + "IOT", + "IRL", + "IRQ", + "ITA", + "KOS", + "LUX", + "MEX", + "NAM", + "NER", + "PHL", + "PRT", + "RUS", + "SEN", + "SUR", + "TZA", + "VAT" + ], + "#E7E58F", + [ + "AUT", + "BEL", + "BHR", + "BMU", + "BRB", + "CYN", + "DZA", + "EST", + "FLK", + "GMB", + "GUM", + "HND", + "JEY", + "KGZ", + "LIE", + "MAF", + "MDA", + "NGA", + "NRU", + "SLB", + "SOL", + "SRB", + "SWZ", + "THA", + "TUR", + "VEN", + "VGB" + ], + "#98DDA1", + [ + "AIA", + "BIH", + "BLM", + "BRN", + "CAF", + "CHE", + "COM", + "CPV", + "CUB", + "ECU", + "ESB", + "FSM", + "GAZ", + "GBR", + "GEO", + "KEN", + "LTU", + "MAR", + "MCO", + "MDV", + "NFK", + "NPL", + "PNG", + "PRY", + "QAT", + "SLE", + "SPM", + "SYC", + "TCA", + "TKM", + "TLS", + "VNM", + "WEB", + "WSB", + "YEM", + "ZWE" + ], + "#83D5F4", + [ + "ABW", + "ALB", + "AND", + "ATC", + "BOL", + "COD", + "CUW", + "CYM", + "CYP", + "EGY", + "FJI", + "GGY", + "IMN", + "KAB", + "KAZ", + "KWT", + "LAO", + "MLI", + "MNP", + "MSR", + "MYS", + "NIC", + "NLD", + "PAK", + "PAN", + "PRK", + "ROU", + "SGS", + "SVN", + "SWE", + "TGO", + "TWN", + "VCT", + "ZAF" + ], + "#B1BBF9", + [ + "ATA", + "GRL" + ], + "#FFFFFF", + "#EAB38F" + ] + }, + "filter": [ + "all" + ], + "layout": { + "visibility": "visible" + }, + "source": "maplibre", + "maxzoom": 24, + "source-layer": "countries" + }, + { + "id": "countries-boundary", + "type": "line", + "paint": { + "line-color": "rgba(255, 255, 255, 1)", + "line-width": { + "stops": [ + [ + 1, + 1 + ], + [ + 6, + 2 + ], + [ + 14, + 6 + ], + [ + 22, + 12 + ] + ] + }, + "line-opacity": { + "stops": [ + [ + 3, + 0.5 + ], + [ + 6, + 1 + ] + ] + } + }, + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "source": "maplibre", + "maxzoom": 24, + "source-layer": "countries" + }, + { + "id": "geolines", + "type": "line", + "paint": { + "line-color": "#1077B0", + "line-opacity": 1, + "line-dasharray": [ + 3, + 3 + ] + }, + "filter": [ + "all", + [ + "!=", + "name", + "International Date Line" + ] + ], + "layout": { + "visibility": "visible" + }, + "source": "maplibre", + "maxzoom": 24, + "source-layer": "geolines" + }, + { + "id": "geolines-label", + "type": "symbol", + "paint": { + "text-color": "#1077B0", + "text-halo-blur": 1, + "text-halo-color": "rgba(255, 255, 255, 1)", + "text-halo-width": 1 + }, + "filter": [ + "all", + [ + "!=", + "name", + "International Date Line" + ] + ], + "layout": { + "text-font": [ + "Open Sans Semibold" + ], + "text-size": { + "stops": [ + [ + 2, + 12 + ], + [ + 6, + 16 + ] + ] + }, + "text-field": "{name}", + "visibility": "visible", + "symbol-placement": "line" + }, + "source": "maplibre", + "maxzoom": 24, + "minzoom": 1, + "source-layer": "geolines" + }, + { + "id": "countries-label", + "type": "symbol", + "paint": { + "text-color": "rgba(8, 37, 77, 1)", + "text-halo-blur": { + "stops": [ + [ + 2, + 0.2 + ], + [ + 6, + 0 + ] + ] + }, + "text-halo-color": "rgba(255, 255, 255, 1)", + "text-halo-width": { + "stops": [ + [ + 2, + 1 + ], + [ + 6, + 1.6 + ] + ] + } + }, + "filter": [ + "all" + ], + "layout": { + "text-font": [ + "Open Sans Semibold" + ], + "text-size": { + "stops": [ + [ + 2, + 10 + ], + [ + 4, + 12 + ], + [ + 6, + 16 + ] + ] + }, + "text-field": { + "stops": [ + [ + 2, + "{ABBREV}" + ], + [ + 4, + "{NAME}" + ] + ] + }, + "visibility": "visible", + "text-max-width": 10, + "text-transform": { + "stops": [ + [ + 0, + "uppercase" + ], + [ + 2, + "none" + ] + ] + } + }, + "source": "maplibre", + "maxzoom": 24, + "minzoom": 2, + "source-layer": "centroids" + } + ], + "bearing": 0, + "sources": { + "maplibre": { + "tiles": [ + "https://demotiles.maplibre.org/tiles/{z}/{x}/{y}.pbf" + ], + "minzoom": 0, + "maxzoom": 6, + "attribution": "© MapLibre demo", + "type": "vector" + } + }, + "version": 8, + "metadata": { + "maptiler:copyright": "This style was generated on MapTiler Cloud. Usage is governed by the license terms in https://github.com/maplibre/demotiles/blob/gh-pages/LICENSE", + "openmaptiles:version": "3.x" + } +} \ No newline at end of file diff --git a/library/src/commonTest/composeResources/files/test_style_street_v2.json b/library/src/commonTest/composeResources/files/test_style_street_v2.json new file mode 100644 index 00000000..504156ed --- /dev/null +++ b/library/src/commonTest/composeResources/files/test_style_street_v2.json @@ -0,0 +1,8252 @@ +{ + "version": 8, + "id": "streets-v2", + "name": "Streets", + "sources": { + "maptiler_attribution": { + "attribution": "© MapTiler © OpenStreetMap contributors", + "type": "vector" + }, + "maptiler_planet": { + "tiles": [ + "https://api.maptiler.com/tiles/v3/{z}/{x}/{y}.pbf?key=XXX" + ], + "type": "vector", + "minzoom": 0, + "maxzoom": 15, + "attribution": "© MapTiler © OpenStreetMap contributors" + } + }, + "layers": [ + { + "id": "Background", + "type": "background", + "layout": { + "visibility": "visible" + }, + "paint": { + "background-color": { + "stops": [ + [ + 6, + "hsl(47,79%,94%)" + ], + [ + 14, + "hsl(42,49%,93%)" + ] + ] + } + } + }, + { + "id": "Meadow", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "globallandcover", + "maxzoom": 8, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(75,51%,85%)", + "fill-opacity": { + "stops": [ + [ + 0, + 1 + ], + [ + 8, + 0.1 + ] + ] + } + }, + "filter": [ + "==", + "class", + "grass" + ] + }, + { + "id": "Scrub", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "globallandcover", + "maxzoom": 8, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(97,51%,80%)", + "fill-opacity": { + "stops": [ + [ + 0, + 1 + ], + [ + 8, + 0.1 + ] + ] + } + }, + "filter": [ + "==", + "class", + "scrub" + ] + }, + { + "id": "Crop", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "globallandcover", + "maxzoom": 8, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(50,67%,86%)", + "fill-opacity": { + "stops": [ + [ + 0, + 1 + ], + [ + 8, + 0.1 + ] + ] + } + }, + "filter": [ + "==", + "class", + "crop" + ] + }, + { + "id": "Glacier", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landcover", + "maxzoom": 24, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(0,0%,100%)", + "fill-opacity": { + "stops": [ + [ + 0, + 1 + ], + [ + 10, + 0.7 + ] + ] + } + }, + "filter": [ + "==", + "class", + "ice" + ] + }, + { + "id": "Forest", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "globallandcover", + "maxzoom": 8, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(119,38%,76%)", + "fill-opacity": { + "stops": [ + [ + 1, + 0.8 + ], + [ + 8, + 0 + ] + ] + } + }, + "filter": [ + "in", + "class", + "forest", + "tree" + ] + }, + { + "id": "Sand", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landcover", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": false, + "fill-color": "hsl(52,93%,89%)", + "fill-opacity": 0.85 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "sand" + ] + }, + { + "id": "Wood", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landcover", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(87,46%,85%)", + "fill-opacity": 1 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "wood" + ] + }, + { + "id": "Residential", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "maxzoom": 24, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": { + "base": 1, + "stops": [ + [ + 4, + "hsl(44,34%,87%)" + ], + [ + 16, + "hsl(54, 45%, 91%)" + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "class", + "residential", + "suburbs", + "neighbourhood" + ] + }, + { + "id": "Industrial", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "maxzoom": 24, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 9, + [ + "match", + [ + "get", + "class" + ], + [ + "industrial" + ], + "hsl(40,67%,90%)", + "quarry", + "hsla(32, 47%, 87%, 0.2)", + "hsl(60, 31%, 87%)" + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "industrial" + ], + "hsl(49,54%,90%)", + "quarry", + "hsla(32, 47%, 87%, 0.5)", + "hsl(60, 31%, 87%)" + ] + ], + "fill-opacity": [ + "step", + [ + "zoom" + ], + 1, + 9, + [ + "match", + [ + "get", + "class" + ], + "quarry", + 0, + 1 + ], + 10, + 1 + ] + }, + "metadata": {}, + "filter": [ + "in", + "class", + "industrial", + "quarry" + ] + }, + { + "id": "Grass", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landcover", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": false, + "fill-color": "hsl(103, 40%, 85%)", + "fill-opacity": 0.5 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "grass" + ] + }, + { + "id": "Airport zone", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "aeroway", + "minzoom": 11, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(0,0%,93%)", + "fill-opacity": 1 + }, + "metadata": {}, + "filter": [ + "==", + "$type", + "Polygon" + ] + }, + { + "id": "Pedestrian", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(43,100%,99%)", + "fill-opacity": 0.7 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Polygon" + ], + [ + "!has", + "brunnel" + ], + [ + "!in", + "class", + "bridge", + "pier" + ], + [ + "in", + "subclass", + "pedestrian", + "platform" + ] + ] + }, + { + "id": "Cemetery", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "minzoom": 9, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(0,0%,88%)", + "fill-opacity": { + "stops": [ + [ + 9, + 0.25 + ], + [ + 16, + 1 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "==", + "class", + "cemetery" + ] + }, + { + "id": "Hospital", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "minzoom": 9, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(12,63%,94%)", + "fill-opacity": { + "stops": [ + [ + 9, + 0.25 + ], + [ + 16, + 1 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "==", + "class", + "hospital" + ] + }, + { + "id": "Stadium", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "minzoom": 9, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(94, 100%, 88%)", + "fill-opacity": { + "stops": [ + [ + 9, + 0.25 + ], + [ + 16, + 1 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "class", + "pitch", + "stadium", + "playground" + ] + }, + { + "id": "School", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "landuse", + "minzoom": 9, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(194,52%,94%)", + "fill-opacity": { + "stops": [ + [ + 9, + 0.25 + ], + [ + 16, + 1 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "class", + "college", + "school", + "university" + ] + }, + { + "id": "River tunnel", + "type": "line", + "source": "maptiler_planet", + "source-layer": "waterway", + "minzoom": 14, + "layout": { + "line-cap": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(210,73%,78%)", + "line-dasharray": [ + 2, + 4 + ], + "line-opacity": 0.5, + "line-width": { + "base": 1.3, + "stops": [ + [ + 12, + 0.5 + ], + [ + 20, + 6 + ] + ] + } + }, + "filter": [ + "==", + "brunnel", + "tunnel" + ] + }, + { + "id": "River", + "type": "line", + "source": "maptiler_planet", + "source-layer": "waterway", + "layout": { + "line-cap": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(210,73%,78%)", + "line-width": { + "stops": [ + [ + 12, + 0.5 + ], + [ + 20, + 6 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "!=", + "brunnel", + "tunnel" + ] + }, + { + "id": "Water intermittent", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "water", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(205,91%,83%)", + "fill-opacity": 0.85 + }, + "metadata": {}, + "filter": [ + "==", + "intermittent", + 1 + ] + }, + { + "id": "Water", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "water", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(204,92%,75%)", + "fill-opacity": [ + "match", + [ + "get", + "intermittent" + ], + 1, + 0.85, + 1 + ] + }, + "metadata": {}, + "filter": [ + "!=", + "intermittent", + 1 + ] + }, + { + "id": "Aeroway", + "type": "line", + "source": "maptiler_planet", + "source-layer": "aeroway", + "minzoom": 11, + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,100%)", + "line-width": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 11, + [ + "match", + [ + "get", + "class" + ], + [ + "runway" + ], + 3, + 0.5 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "runway" + ], + 16, + 6 + ] + ] + }, + "metadata": {} + }, + { + "id": "Heliport", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "aeroway", + "minzoom": 11, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(0,0%,100%)", + "fill-opacity": 1 + }, + "metadata": {}, + "filter": [ + "in", + "class", + "helipad", + "heliport" + ] + }, + { + "id": "Ferry line", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 6, + "layout": { + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": { + "stops": [ + [ + 10, + "hsl(205,61%,63%)" + ], + [ + 16, + "hsl(205,67%,47%)" + ] + ] + }, + "line-dasharray": [ + 2, + 2 + ], + "line-opacity": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 6, + 0.5, + 7, + 0.8, + 8, + 1 + ], + "line-width": { + "stops": [ + [ + 10, + 0.5 + ], + [ + 14, + 1.1 + ] + ] + } + }, + "filter": [ + "==", + "class", + "ferry" + ] + }, + { + "id": "Tunnel outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": [ + "match", + [ + "get", + "class" + ], + "motorway", + "hsl(28,72%,69%)", + [ + "trunk", + "primary" + ], + "hsl(28,72%,69%)", + "hsl(36,5%,80%)" + ], + "line-dasharray": [ + 0.5, + 0.25 + ], + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 6, + 0, + 7, + 0.5, + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + [ + "trunk", + "primary" + ], + 2, + 0 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 2, + 6 + ], + [ + "trunk", + "primary" + ], + 3, + [ + "secondary", + "tertiary" + ], + 2, + [ + "minor", + "service", + "track" + ], + 1, + 0.5 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 8 + ], + [ + "trunk" + ], + 4, + [ + "primary" + ], + 6, + [ + "secondary" + ], + 6, + [ + "tertiary" + ], + 4, + [ + "minor", + "service", + "track" + ], + 3, + 3 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway", + "trunk", + "primary" + ], + 10, + [ + "secondary" + ], + 8, + [ + "tertiary" + ], + 8, + [ + "minor", + "service", + "track" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway", + "trunk", + "primary" + ], + 26, + [ + "secondary" + ], + 26, + [ + "tertiary" + ], + 26, + [ + "minor", + "service", + "track" + ], + 18, + 18 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "brunnel", + "tunnel" + ], + [ + "!in", + "class", + "bridge", + "ferry", + "rail", + "transit", + "pier", + "path", + "aerialway", + "motorway_construction", + "trunk_construction", + "primary_construction", + "secondary_construction", + "tertiary_construction", + "minor_construction", + "service_construction", + "track_construction" + ] + ] + }, + { + "id": "Tunnel", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": [ + "match", + [ + "get", + "class" + ], + "motorway", + "hsl(35,100%,76%)", + [ + "trunk", + "primary" + ], + "hsl(48,100%,88%)", + "hsl(0,0%,96%)" + ], + "line-opacity": 1, + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 5, + 0, + 6, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "brunnel" + ], + [ + "bridge" + ], + 0, + 1 + ], + [ + "trunk", + "primary" + ], + 0, + 0 + ], + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + [ + "trunk", + "primary" + ], + 1.5, + 1 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 1, + 4 + ], + [ + "trunk" + ], + 2.5, + [ + "primary" + ], + 2.5, + [ + "secondary", + "tertiary" + ], + 1.5, + [ + "minor", + "service", + "track" + ], + 1, + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 6 + ], + [ + "trunk" + ], + 3, + [ + "primary" + ], + 5, + [ + "secondary" + ], + 4, + [ + "tertiary" + ], + 3, + [ + "minor", + "service", + "track" + ], + 2, + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway", + "trunk", + "primary" + ], + 8, + [ + "secondary" + ], + 7, + [ + "tertiary" + ], + 6, + [ + "minor", + "service", + "track" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway", + "trunk", + "primary" + ], + 24, + [ + "secondary" + ], + 24, + [ + "tertiary" + ], + 24, + [ + "minor", + "service", + "track" + ], + 16, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "brunnel", + "tunnel" + ], + [ + "!in", + "class", + "ferry", + "rail", + "transit", + "pier", + "bridge", + "path", + "aerialway", + "motorway_construction", + "trunk_construction", + "primary_construction", + "secondary_construction", + "tertiary_construction", + "minor_construction", + "service_construction", + "track_construction" + ] + ] + }, + { + "id": "Railway tunnel", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,73%)", + "line-opacity": 0.5, + "line-width": { + "base": 1.4, + "stops": [ + [ + 14, + 0.4 + ], + [ + 15, + 0.75 + ], + [ + 20, + 2 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "rail" + ] + ] + }, + { + "id": "Railway tunnel hatching", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,73%)", + "line-dasharray": [ + 0.2, + 8 + ], + "line-opacity": 0.5, + "line-width": { + "base": 1.4, + "stops": [ + [ + 14.5, + 0 + ], + [ + 15, + 3 + ], + [ + 20, + 8 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "rail" + ] + ] + }, + { + "id": "Footway tunnel outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "round", + "line-join": "miter", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,100%)", + "line-opacity": 1, + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0 + ], + [ + 16, + 0 + ], + [ + 18, + 4 + ], + [ + 22, + 8 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path", + "pedestrian" + ], + [ + "==", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Footway tunnel", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,63%)", + "line-dasharray": { + "stops": [ + [ + 14, + [ + 1, + 0.5 + ] + ], + [ + 18, + [ + 1, + 0.25 + ] + ] + ] + }, + "line-opacity": 0.4, + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0.5 + ], + [ + 16, + 1 + ], + [ + 18, + 2 + ], + [ + 22, + 5 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path", + "pedestrian" + ], + [ + "==", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Pier", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(42,49%,93%)" + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Polygon" + ], + [ + "==", + "class", + "pier" + ] + ] + }, + { + "id": "Pier road", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(42,49%,93%)", + "line-width": { + "base": 1.2, + "stops": [ + [ + 15, + 1 + ], + [ + 17, + 4 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "class", + "pier" + ] + ] + }, + { + "id": "Bridge outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 13, + "maxzoom": 17, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(43, 50%, 93%)", + "line-opacity": 0.5, + "line-width": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 13, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 5, + 8 + ], + 15, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 15, + 22 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 20, + 24 + ] + ] + }, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "in", + "class", + "motorway", + "primary", + "trunk" + ] + ] + }, + { + "id": "Bridge", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-antialias": true, + "fill-color": "hsl(42,49%,93%)", + "fill-opacity": 0.6 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Polygon" + ], + [ + "==", + "brunnel", + "bridge" + ] + ] + }, + { + "id": "Minor road outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(36,5%,80%)", + "line-opacity": 1, + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 6, + 0, + 7, + 0.5, + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary", + "tertiary" + ], + 2, + [ + "minor", + "service", + "track" + ], + 1, + 0.5 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 6, + [ + "tertiary" + ], + 4, + [ + "minor", + "service", + "track" + ], + 3, + 3 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 8, + [ + "tertiary" + ], + 8, + [ + "minor", + "service", + "track" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 26, + [ + "tertiary" + ], + 26, + [ + "minor", + "service", + "track" + ], + 18, + 18 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "!in", + "class", + "aerialway", + "bridge", + "ferry", + "minor_construction", + "motorway", + "motorway_construction", + "path", + "path_construction", + "pier", + "primary", + "primary_construction", + "rail", + "secondary_construction", + "service_construction", + "tertiary_construction", + "track_construction", + "transit", + "trunk_construction" + ] + ] + }, + { + "id": "Major road outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(28,72%,69%)", + "line-opacity": 1, + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 6, + 0, + 7, + 0.5, + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 2.4, + 0 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 3, + 0.5 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk" + ], + 4, + [ + "primary" + ], + 6, + 3 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 10, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 26, + 18 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "in", + "class", + "primary", + "trunk" + ] + ] + }, + { + "id": "Highway outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(28,72%,69%)", + "line-opacity": 1, + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 6, + 0, + 7, + 0.5, + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + 0 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 2, + 6 + ], + 0.5 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 8 + ], + 3 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + 10, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + 26, + 18 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "motorway" + ] + ] + }, + { + "id": "Road under construction", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "square", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": [ + "match", + [ + "get", + "class" + ], + "motorway_construction", + "hsl(35,100%,76%)", + [ + "trunk_construction", + "primary_construction" + ], + "hsl(48,100%,83%)", + "hsl(0,0%,100%)" + ], + "line-dasharray": [ + 2, + 2 + ], + "line-opacity": [ + "case", + [ + "==", + [ + "get", + "brunnel" + ], + "tunnel" + ], + 0.7, + 1 + ], + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 5, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction" + ], + [ + "match", + [ + "get", + "brunnel" + ], + [ + "bridge" + ], + 0, + 0.5 + ], + [ + "trunk_construction", + "primary_construction" + ], + 0, + 0 + ], + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + [ + "trunk_construction", + "primary_construction" + ], + 1.5, + 1 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 1, + 4 + ], + [ + "trunk_construction" + ], + 2.5, + [ + "primary_construction" + ], + 2.5, + [ + "secondary_construction", + "tertiary_construction" + ], + 1.5, + [ + "minor_construction", + "service_construction", + "track_construction" + ], + 1, + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 6 + ], + [ + "trunk_construction" + ], + 3, + [ + "primary_construction" + ], + 5, + [ + "secondary_construction" + ], + 4, + [ + "tertiary_construction" + ], + 3, + [ + "minor_construction", + "service_construction", + "track_construction" + ], + 2, + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction", + "trunk_construction", + "primary_construction" + ], + 8, + [ + "secondary_construction" + ], + 7, + [ + "tertiary_construction" + ], + 6, + [ + "minor_construction", + "service_construction", + "track_construction" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway_construction", + "trunk_construction", + "primary_construction" + ], + 24, + [ + "secondary_construction" + ], + 24, + [ + "tertiary_construction" + ], + 24, + [ + "minor_construction", + "service_construction", + "track_construction" + ], + 16, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "in", + "class", + "motorway_construction", + "trunk_construction", + "primary_construction", + "secondary_construction", + "tertiary_construction", + "minor_construction", + "service_construction", + "track_construction" + ] + }, + { + "id": "Minor road", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,100%)", + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 5, + 0.5, + 10, + 1, + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary", + "tertiary" + ], + 1.5, + [ + "minor", + "service", + "track" + ], + 1, + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 4, + [ + "tertiary" + ], + 3, + [ + "minor", + "service", + "track" + ], + 2, + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 7, + [ + "tertiary" + ], + 6, + [ + "minor", + "service", + "track" + ], + 4, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "secondary" + ], + 24, + [ + "tertiary" + ], + 24, + [ + "minor", + "service", + "track" + ], + 16, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "!in", + "class", + "aerialway", + "bridge", + "ferry", + "minor_construction", + "motorway", + "motorway_construction", + "path", + "path_construction", + "pier", + "primary", + "primary_construction", + "rail", + "secondary_construction", + "service_construction", + "tertiary_construction", + "track_construction", + "transit", + "trunk_construction" + ] + ] + }, + { + "id": "Major road", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(48,100%,83%)", + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 1.5, + 1 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 2.5, + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk" + ], + 3, + [ + "primary" + ], + 5, + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 8, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "trunk", + "primary" + ], + 24, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "in", + "class", + "primary", + "trunk" + ] + ] + }, + { + "id": "Highway", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 4, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(35,100%,76%)", + "line-width": [ + "interpolate", + [ + "linear", + 2 + ], + [ + "zoom" + ], + 5, + 0.5, + 6, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "brunnel" + ], + [ + "bridge" + ], + 0, + 1 + ], + 0 + ], + 10, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 0, + 2.5 + ], + 1 + ], + 12, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 1, + 4 + ], + 1 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + [ + "match", + [ + "get", + "ramp" + ], + 1, + 5, + 6 + ], + 2 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + 8, + 4 + ], + 20, + [ + "match", + [ + "get", + "class" + ], + [ + "motorway" + ], + 24, + 16 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "!=", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "motorway" + ] + ] + }, + { + "id": "Path outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "round", + "line-join": "miter", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,100%)", + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0 + ], + [ + 16, + 0 + ], + [ + 18, + 4 + ], + [ + 22, + 8 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path", + "pedestrian" + ], + [ + "!=", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Path minor", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 79%)", + "line-dasharray": { + "stops": [ + [ + 14, + [ + 1, + 0.5 + ] + ], + [ + 18, + [ + 1, + 0.25 + ] + ] + ] + }, + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0.5 + ], + [ + 16, + 1 + ], + [ + 18, + 2 + ], + [ + 22, + 5 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path_pedestrian" + ], + [ + "!=", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Path", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 12, + "layout": { + "line-cap": "butt", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 79%)", + "line-dasharray": { + "stops": [ + [ + 14, + [ + 1, + 0.5 + ] + ], + [ + 18, + [ + 1, + 0.25 + ] + ] + ] + }, + "line-width": { + "base": 1.2, + "stops": [ + [ + 14, + 0.5 + ], + [ + 16, + 1 + ], + [ + 18, + 2 + ], + [ + 22, + 5 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "class", + "path", + "pedestrian" + ], + [ + "!=", + "brunnel", + "tunnel" + ] + ] + }, + { + "id": "Major rail", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": { + "stops": [ + [ + 8, + "hsl(0,0%,72%)" + ], + [ + 16, + "hsl(0,0%,70%)" + ] + ] + }, + "line-opacity": [ + "match", + [ + "get", + "service" + ], + "yard", + 0.5, + 1 + ], + "line-width": { + "base": 1.4, + "stops": [ + [ + 14, + 0.4 + ], + [ + 15, + 0.75 + ], + [ + 20, + 2 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "!in", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "rail" + ] + ] + }, + { + "id": "Major rail hatching", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,72%)", + "line-dasharray": [ + 0.2, + 9 + ], + "line-opacity": [ + "match", + [ + "get", + "service" + ], + "yard", + 0.5, + 1 + ], + "line-width": { + "base": 1.4, + "stops": [ + [ + 14.5, + 0 + ], + [ + 15, + 3 + ], + [ + 20, + 8 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "all", + [ + "!in", + "brunnel", + "tunnel" + ], + [ + "==", + "class", + "rail" + ] + ] + }, + { + "id": "Minor rail", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,73%)", + "line-width": { + "base": 1.4, + "stops": [ + [ + 14, + 0.4 + ], + [ + 15, + 0.75 + ], + [ + 20, + 2 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "subclass", + "light_rail", + "tram" + ] + }, + { + "id": "Minor rail hatching", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,73%)", + "line-dasharray": [ + 0.2, + 4 + ], + "line-width": { + "base": 1.4, + "stops": [ + [ + 14.5, + 0 + ], + [ + 15, + 2 + ], + [ + 20, + 6 + ] + ] + } + }, + "metadata": {}, + "filter": [ + "in", + "subclass", + "tram", + "light_rail" + ] + }, + { + "id": "Building", + "type": "fill", + "source": "maptiler_planet", + "source-layer": "building", + "minzoom": 13, + "maxzoom": 15, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-color": "hsl(30,6%,73%)", + "fill-opacity": 0.3, + "fill-outline-color": { + "base": 1, + "stops": [ + [ + 13, + "hsla(35, 6%, 79%, 0.3)" + ], + [ + 14, + "hsl(35, 6%, 79%)" + ] + ] + } + }, + "metadata": {} + }, + { + "id": "Building 3D", + "type": "fill-extrusion", + "source": "maptiler_planet", + "source-layer": "building", + "minzoom": 15, + "layout": { + "visibility": "visible" + }, + "paint": { + "fill-extrusion-base": { + "property": "render_min_height", + "type": "identity" + }, + "fill-extrusion-color": "hsl(44,14%,79%)", + "fill-extrusion-height": { + "property": "render_height", + "type": "identity" + }, + "fill-extrusion-opacity": 0.4 + }, + "metadata": {}, + "filter": [ + "!has", + "hide_3d" + ] + }, + { + "id": "Aqueduct outline", + "type": "line", + "source": "maptiler_planet", + "source-layer": "waterway", + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,51%)", + "line-width": { + "base": 1.3, + "stops": [ + [ + 14, + 1 + ], + [ + 20, + 6 + ] + ] + } + }, + "filter": [ + "==", + "brunnel", + "bridge" + ] + }, + { + "id": "Aqueduct", + "type": "line", + "source": "maptiler_planet", + "source-layer": "waterway", + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(204,92%,75%)", + "line-width": { + "base": 1.3, + "stops": [ + [ + 12, + 0.5 + ], + [ + 20, + 5 + ] + ] + } + }, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "brunnel", + "bridge" + ] + ] + }, + { + "id": "Cablecar", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 13, + "layout": { + "line-cap": "round", + "visibility": "visible" + }, + "paint": { + "line-blur": 1, + "line-color": "hsl(0,0%,100%)", + "line-width": { + "base": 1, + "stops": [ + [ + 13, + 2 + ], + [ + 19, + 4 + ] + ] + } + }, + "filter": [ + "==", + "class", + "aerialway" + ] + }, + { + "id": "Cablecar dash", + "type": "line", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 13, + "layout": { + "line-cap": "round", + "line-join": "bevel", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0,0%,64%)", + "line-dasharray": [ + 2, + 2 + ], + "line-width": { + "base": 1, + "stops": [ + [ + 13, + 1 + ], + [ + 19, + 2 + ] + ] + } + }, + "filter": [ + "==", + "class", + "aerialway" + ] + }, + { + "id": "Other border", + "type": "line", + "source": "maptiler_planet", + "source-layer": "boundary", + "minzoom": 3, + "layout": { + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 70%)", + "line-dasharray": [ + 2, + 1 + ], + "line-width": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 3, + 0.75, + 4, + 0.8, + 11, + [ + "case", + [ + "<=", + [ + "get", + "admin_level" + ], + 6 + ], + 1.75, + 1.5 + ], + 18, + [ + "case", + [ + "<=", + [ + "get", + "admin_level" + ], + 6 + ], + 3, + 2 + ] + ] + }, + "filter": [ + "all", + [ + "in", + "admin_level", + 3, + 4, + 5, + 6, + 7, + 8 + ], + [ + "==", + "maritime", + 0 + ] + ] + }, + { + "id": "Disputed border", + "type": "line", + "source": "maptiler_planet", + "source-layer": "boundary", + "minzoom": 0, + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 63%)", + "line-dasharray": [ + 2, + 2 + ], + "line-width": { + "stops": [ + [ + 1, + 0.5 + ], + [ + 5, + 1.5 + ], + [ + 10, + 2 + ], + [ + 24, + 12 + ] + ] + } + }, + "filter": [ + "all", + [ + "==", + "admin_level", + 2 + ], + [ + "==", + "disputed", + 1 + ], + [ + "==", + "maritime", + 0 + ] + ] + }, + { + "id": "Country border", + "type": "line", + "source": "maptiler_planet", + "source-layer": "boundary", + "minzoom": 0, + "layout": { + "line-cap": "round", + "line-join": "round", + "visibility": "visible" + }, + "paint": { + "line-color": "hsl(0, 0%, 54%)", + "line-width": { + "stops": [ + [ + 1, + 0.5 + ], + [ + 5, + 1.5 + ], + [ + 10, + 2 + ], + [ + 24, + 12 + ] + ] + } + }, + "filter": [ + "all", + [ + "==", + "admin_level", + 2 + ], + [ + "==", + "disputed", + 0 + ], + [ + "==", + "maritime", + 0 + ] + ] + }, + { + "id": "River labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "waterway", + "minzoom": 13, + "layout": { + "symbol-placement": "line", + "symbol-spacing": 400, + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-letter-spacing": 0.2, + "text-max-width": 5, + "text-rotation-alignment": "map", + "text-size": { + "stops": [ + [ + 12, + 8 + ], + [ + 16, + 14 + ], + [ + 22, + 20 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(205,84%,39%)", + "text-halo-blur": 1, + "text-halo-color": "hsl(202, 76%, 82%)", + "text-halo-width": { + "stops": [ + [ + 10, + 1 + ], + [ + 18, + 2 + ] + ] + } + }, + "filter": [ + "==", + "$type", + "LineString" + ] + }, + { + "id": "Ocean labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "water_name", + "minzoom": 0, + "layout": { + "symbol-placement": "point", + "text-field": "{name:en}", + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-max-width": 5, + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 1, + [ + "match", + [ + "get", + "class" + ], + [ + "ocean" + ], + 14, + 10 + ], + 3, + [ + "match", + [ + "get", + "class" + ], + [ + "ocean" + ], + 18, + 14 + ], + 9, + [ + "match", + [ + "get", + "class" + ], + [ + "ocean" + ], + 22, + 18 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "lake" + ], + 14, + [ + "sea" + ], + 20, + 26 + ] + ], + "visibility": "visible" + }, + "paint": { + "text-color": { + "stops": [ + [ + 1, + "hsl(203,54%,54%)" + ], + [ + 4, + "hsl(203,72%,39%)" + ] + ] + }, + "text-halo-blur": 1, + "text-halo-color": { + "stops": [ + [ + 1, + "hsla(196, 72%, 80%, 0.05)" + ], + [ + 3, + "hsla(200, 100%, 88%, 0.75)" + ] + ] + }, + "text-halo-width": 1, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 1, + [ + "match", + [ + "get", + "class" + ], + [ + "ocean" + ], + 1, + 0 + ], + 3, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "has", + "name" + ], + [ + "!=", + "class", + "lake" + ] + ] + }, + { + "id": "Lake labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "water_name", + "minzoom": 0, + "layout": { + "symbol-placement": "line", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-letter-spacing": 0.1, + "text-max-width": 5, + "text-size": { + "stops": [ + [ + 10, + 13 + ], + [ + 14, + 16 + ], + [ + 22, + 20 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(205,84%,39%)", + "text-halo-color": "hsla(0, 100%, 100%, 0.45)", + "text-halo-width": 1.5 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "class", + "lake" + ] + ] + }, + { + "id": "Housenumber", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "housenumber", + "minzoom": 18, + "layout": { + "text-field": "{housenumber}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-size": 10, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(26,10%,44%)", + "text-halo-blur": 1, + "text-halo-color": "hsl(21,64%,96%)", + "text-halo-width": 1 + } + }, + { + "id": "Gondola", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 13, + "layout": { + "symbol-placement": "line", + "text-anchor": "center", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-offset": [ + 0.8, + 0.8 + ], + "text-size": { + "base": 1, + "stops": [ + [ + 13, + 11 + ], + [ + 15, + 12 + ], + [ + 18, + 13 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,40%)", + "text-halo-blur": 1, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "metadata": {}, + "filter": [ + "in", + "subclass", + "gondola", + "cable_car" + ] + }, + { + "id": "Ferry", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 12, + "layout": { + "symbol-placement": "line", + "text-anchor": "center", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Italic", + "Noto Sans Italic" + ], + "text-offset": [ + 0.8, + 0.8 + ], + "text-size": { + "base": 1, + "stops": [ + [ + 13, + 11 + ], + [ + 15, + 12 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(205,84%,39%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsla(0, 0%, 100%, 0.15)", + "text-halo-width": 1 + }, + "filter": [ + "==", + "class", + "ferry" + ] + }, + { + "id": "Oneway", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation", + "minzoom": 16, + "layout": { + "icon-image": "oneway", + "icon-padding": 2, + "icon-rotate": [ + "match", + [ + "get", + "oneway" + ], + 1, + 0, + 0 + ], + "icon-rotation-alignment": "map", + "icon-size": { + "stops": [ + [ + 16, + 0.7 + ], + [ + 19, + 1 + ] + ] + }, + "symbol-placement": "line", + "symbol-spacing": 75, + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 65%)", + "icon-opacity": 0.5 + }, + "filter": [ + "all", + [ + "has", + "oneway" + ], + [ + "in", + "class", + "motorway", + "trunk", + "primary", + "secondary", + "tertiary", + "minor", + "service" + ] + ] + }, + { + "id": "Road labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 8, + "layout": { + "icon-allow-overlap": false, + "icon-ignore-placement": false, + "icon-keep-upright": false, + "symbol-placement": "line", + "symbol-spacing": [ + "step", + [ + "zoom" + ], + 250, + 21, + 1000 + ], + "text-allow-overlap": false, + "text-anchor": "center", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-ignore-placement": false, + "text-justify": "center", + "text-max-width": 10, + "text-offset": [ + 0, + 0.15 + ], + "text-optional": false, + "text-size": { + "stops": [ + [ + 13, + 10 + ], + [ + 14, + 11 + ], + [ + 18, + 13 + ], + [ + 22, + 15 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 16%)", + "text-color": "hsl(0, 0%, 16%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "metadata": {}, + "filter": [ + "all", + [ + "!in", + "subclass", + "gondola", + "cable_car" + ], + [ + "!in", + "class", + "ferry", + "service" + ] + ] + }, + { + "id": "Highway junction", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 16, + "layout": { + "icon-image": "exit_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-avoid-edges": true, + "symbol-placement": "point", + "symbol-spacing": 200, + "symbol-z-order": "auto", + "text-field": "{ref}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-offset": [ + 0, + 0.1 + ], + "text-rotation-alignment": "viewport", + "text-size": 9, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,21%)", + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "filter": [ + "all", + [ + ">", + "ref_length", + 0 + ], + [ + "==", + "$type", + "Point" + ], + [ + "==", + "subclass", + "junction" + ] + ] + }, + { + "id": "Highway shield", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 8, + "layout": { + "icon-image": "road_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-avoid-edges": true, + "symbol-placement": "line", + "symbol-spacing": { + "stops": [ + [ + 10, + 200 + ], + [ + 18, + 400 + ] + ] + }, + "text-field": "{ref}", + "text-font": [ + "match", + [ + "get", + "class" + ], + "motorway", + [ + "literal", + [ + "Roboto Bold", + "Noto Sans Bold" + ] + ], + [ + "literal", + [ + "Roboto Regular" + ] + ] + ], + "text-offset": [ + 0, + 0.05 + ], + "text-padding": 2, + "text-rotation-alignment": "viewport", + "text-size": 10, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 100%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "text-color": "hsl(0, 0%, 29%)", + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 1 + }, + "filter": [ + "all", + [ + "<=", + "ref_length", + 6 + ], + [ + "==", + "$type", + "LineString" + ], + [ + "!in", + "network", + "us-interstate", + "us-highway", + "us-state" + ], + [ + "!in", + "class", + "path" + ] + ] + }, + { + "id": "Highway shield (US)", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 7, + "layout": { + "icon-image": "{network}_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1.1, + "symbol-avoid-edges": true, + "symbol-placement": { + "base": 1, + "stops": [ + [ + 7, + "point" + ], + [ + 7, + "line" + ], + [ + 8, + "line" + ] + ] + }, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": [ + "match", + [ + "get", + "class" + ], + "motorway", + [ + "literal", + [ + "Roboto Bold", + "Noto Sans Bold" + ] + ], + [ + "literal", + [ + "Roboto Regular", + "Noto Sans Regular" + ] + ] + ], + "text-offset": [ + 0, + 0.05 + ], + "text-rotation-alignment": "viewport", + "text-size": 9, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 100%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "text-color": "hsl(0, 0%, 29%)", + "text-halo-color": "rgba(255, 255, 255, 1)", + "text-halo-width": 0 + }, + "filter": [ + "all", + [ + "<=", + "ref_length", + 6 + ], + [ + "==", + "$type", + "LineString" + ], + [ + "in", + "network", + "us-highway", + "us-state" + ], + [ + "!in", + "class", + "path" + ] + ] + }, + { + "id": "Highway shield interstate top (US)", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 7, + "layout": { + "icon-image": "{network}_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-placement": { + "base": 1, + "stops": [ + [ + 7, + "point" + ], + [ + 7, + "line" + ], + [ + 8, + "line" + ] + ] + }, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": [ + "match", + [ + "get", + "class" + ], + "motorway", + [ + "literal", + [ + "Roboto Bold", + "Noto Sans Bold" + ] + ], + [ + "literal", + [ + "Roboto Regular", + "Noto Sans Regular" + ] + ] + ], + "text-offset": [ + 0, + 0.1 + ], + "text-rotation-alignment": "viewport", + "text-size": 9, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(21, 100%, 45%)", + "icon-halo-color": "rgba(255, 255, 255, 1)", + "icon-halo-width": 1, + "icon-translate": [ + 0, + -4 + ], + "icon-translate-anchor": "viewport", + "text-color": "hsl(21, 100%, 45%)", + "text-halo-color": "rgba(255, 255, 255, 1)", + "text-halo-width": 0 + }, + "filter": [ + "all", + [ + "<=", + "ref_length", + 6 + ], + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "network", + "us-interstate" + ], + [ + "!in", + "class", + "path" + ] + ] + }, + { + "id": "Highway shield interstate (US)", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "transportation_name", + "minzoom": 7, + "layout": { + "icon-image": "{network}_{ref_length}", + "icon-rotation-alignment": "viewport", + "icon-size": 1, + "symbol-placement": { + "base": 1, + "stops": [ + [ + 7, + "point" + ], + [ + 7, + "line" + ], + [ + 8, + "line" + ] + ] + }, + "symbol-spacing": 200, + "text-field": "{ref}", + "text-font": [ + "match", + [ + "get", + "class" + ], + "motorway", + [ + "literal", + [ + "Roboto Bold", + "Noto Sans Bold" + ] + ], + [ + "literal", + [ + "Roboto Regular", + "Noto Sans Regular" + ] + ] + ], + "text-offset": [ + 0, + 0.1 + ], + "text-rotation-alignment": "viewport", + "text-size": 9, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(212, 79%, 42%)", + "icon-halo-color": "rgba(255, 255, 255, 1)", + "icon-halo-width": 1, + "text-color": "hsl(0, 0%, 100%)", + "text-halo-color": "rgba(255, 255, 255, 1)", + "text-halo-width": 0, + "text-translate": [ + 0, + -0.5 + ] + }, + "filter": [ + "all", + [ + "<=", + "ref_length", + 6 + ], + [ + "==", + "$type", + "LineString" + ], + [ + "==", + "network", + "us-interstate" + ], + [ + "!in", + "class", + "path" + ] + ] + }, + { + "id": "Public", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 16, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "bbq", + "cemetery", + "courthouse", + "drinking_water", + "fire_station", + "fountain", + "hairdresser", + "office", + "post", + "prison", + "recycling", + "shower", + "telephone", + "toilets", + "townhall", + "town_hall" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(51, 10%, 40%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "cemetery", + "courthouse", + "townhall", + "town_hall" + ], + 1, + 0 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "cemetery", + "courthouse", + "fire_station", + "townhall", + "town_hall", + "post" + ], + 1, + 0 + ], + 18, + 1 + ], + "text-color": "hsl(51, 10%, 40%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "cemetery", + "courthouse", + "townhall", + "town_hall" + ], + 1, + 0 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "atm", + "bank", + "cemetery", + "courthouse", + "fire_station", + "townhall", + "town_hall", + "post" + ], + 1, + 0 + ], + 18, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "atm", + "bank", + "bbq", + "cemetery", + "courthouse", + "drinking_water", + "fire_station", + "fountain", + "hairdresser", + "office", + "post", + "prison", + "recycling", + "shower", + "telephone", + "toilets", + "townhall", + "town_hall" + ] + ] + }, + { + "id": "Sport", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 16, + "layout": { + "icon-image": [ + "coalesce", + [ + "image", + [ + "to-string", + [ + "get", + "subclass" + ] + ] + ], + [ + "image", + [ + "get", + "class" + ] + ], + [ + "image", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(129, 65%, 30%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "playground", + "pitch", + "stadium", + "sports_hall", + "swimming_pool" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(129, 65%, 30%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "playground", + "pitch", + "stadium", + "sports_hall", + "swimming_pool" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "american_football", + "athletics", + "archery", + "baseball", + "basketball", + "climbing", + "equestrian", + "fitness", + "fitness_centre", + "golf", + "motor", + "multi", + "playground", + "pitch", + "running", + "sauna", + "soccer", + "sport", + "stadium", + "sports_centre", + "sports_hall", + "swimming", + "swimming_area", + "swimming_pool", + "tennis", + "volleyball", + "water_park" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Education", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 15, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "college", + "childcare", + "dancing_school", + "driving_school", + "kindergarten", + "school", + "university" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(175, 50%, 40%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 15, + [ + "match", + [ + "get", + "subclass" + ], + [ + "university" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "school", + "university" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(175, 50%, 40%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 15, + [ + "match", + [ + "get", + "subclass" + ], + [ + "university" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "school", + "university" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "college", + "childcare", + "dancing_school", + "driving_school", + "kindergarten", + "school", + "university" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Tourism", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "apartment", + "aquarium", + "attraction", + "campsite", + "camp_site", + "caravan_site", + "castle", + "chalet", + "guest_house", + "hotel", + "hostel", + "information", + "lodging", + "motel", + "reservoir", + "ruins", + "theme_park", + "zoo" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(283, 55%, 35%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "attraction" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "attraction", + "castle", + "hotel", + "zoo" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(283, 55%, 35%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "attraction" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "attraction", + "castle", + "hotel", + "zoo" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "apartment", + "aquarium", + "attraction", + "campsite", + "camp_site", + "caravan_site", + "castle", + "chalet", + "guest_house", + "hotel", + "hostel", + "information", + "lodging", + "motel", + "reservoir", + "ruins", + "theme_park", + "zoo" + ], + [ + "!=", + "subclass", + "board" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Culture", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "coalesce", + [ + "image", + [ + "to-string", + [ + "get", + "subclass" + ] + ] + ], + [ + "image", + [ + "get", + "class" + ] + ], + [ + "image", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(315, 35%, 50%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "museum" + ], + 1, + 0 + ], + 15, + [ + "match", + [ + "get", + "class" + ], + [ + "cinema", + "art_gallery", + "museum", + "theatre" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "cinema", + "art_gallery", + "library", + "museum", + "place_of_worship", + "theatre" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(315, 35%, 50%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "museum" + ], + 1, + 0 + ], + 15, + [ + "match", + [ + "get", + "class" + ], + [ + "cinema", + "art_gallery", + "museum", + "theatre" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "cinema", + "art_gallery", + "library", + "museum", + "place_of_worship", + "theatre" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "art_gallery", + "archeological_site", + "cinema", + "community_centre", + "gallery", + "library", + "monastery", + "monument", + "museum", + "opera", + "place_of_worship", + "planetarium", + "theatre" + ], + [ + "!=", + "subclass", + "artwork" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Shopping", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "coalesce", + [ + "image", + [ + "to-string", + [ + "get", + "subclass" + ] + ] + ], + [ + "image", + [ + "get", + "class" + ] + ], + [ + "image", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(18, 17%, 30%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "mall" + ], + 1, + 0 + ], + 15, + [ + "match", + [ + "get", + "subclass" + ], + [ + "mall", + "supermarket" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "bakery", + "chemist", + "mall", + "supermarket" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(18, 17%, 30%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "mall" + ], + 1, + 0 + ], + 15, + [ + "match", + [ + "get", + "subclass" + ], + [ + "mall", + "supermarket" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "bakery", + "chemist", + "mall", + "supermarket" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "all", + [ + "in", + "class", + "alcohol_shop", + "bakery", + "book", + "books", + "butcher", + "chemist", + "clothing_store", + "convenience", + "gift", + "grocery", + "laundry", + "mall", + "music", + "shop", + "supermarket" + ], + [ + "has", + "name" + ] + ] + ] + }, + { + "id": "Food", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "maxzoom": 22, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "bar", + "beer", + "cafe", + "fast_food", + "ice_cream", + "restaurant" + ], + [ + "get", + "class" + ], + [ + "biergarten", + "pub" + ], + "beer", + "", + [ + "get", + "class" + ], + [ + "food_court" + ], + "restaurant", + "dot" + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(18, 24%, 44%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 20 + ], + 1, + 0 + ], + 15, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 99 + ], + 1, + 0 + ], + 16, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 499 + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(18, 24%, 44%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 20 + ], + 1, + 0 + ], + 15, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 99 + ], + 1, + 0 + ], + 16, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 499 + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "bar", + "beer", + "biergarten", + "cafe", + "fast_food", + "food_court", + "ice_cream", + "pub", + "restaurant" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Transport", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "aerialway", + "bicycle", + "bicycle_parking", + "car", + "car_rental", + "car_repair", + "charging_station", + "cycle_barrier", + "ferry_terminal", + "fuel", + "harbor", + "motorcycle_parking", + "parking", + "parking_garage", + "parking_paid" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "dot", + "" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(215, 81%, 35%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "ferry_terminal", + "fuel", + "terminal" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "terminal", + "toll" + ], + 1, + 0 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "parking", + "parking_garage", + "parking_paid", + "terminal", + "toll" + ], + 1, + 0 + ], + 18, + 1 + ], + "text-color": "hsl(215, 81%, 35%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "class" + ], + [ + "ferry_terminal", + "fuel", + "terminal" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "terminal", + "toll" + ], + 1, + 0 + ], + 17, + [ + "match", + [ + "get", + "class" + ], + [ + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "parking", + "parking_garage", + "parking_paid", + "terminal", + "toll" + ], + 1, + 0 + ], + 18, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "bicycle", + "bicycle_parking", + "bicycle_rental", + "car", + "car_rental", + "car_repair", + "charging_station", + "ferry_terminal", + "fuel", + "harbor", + "heliport", + "highway_rest_area", + "motorcycle_parking", + "parking", + "parking_garage", + "parking_paid", + "scooter", + "terminal", + "toll" + ] + ] + }, + { + "id": "Park", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-anchor": "center", + "icon-image": "park", + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(82, 83%, 25%)", + "icon-halo-blur": 0, + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 10 + ], + 1, + 0 + ], + 15, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 99 + ], + 1, + 0 + ], + 16, + 1 + ], + "text-color": "hsl(82, 83%, 25%)", + "text-halo-blur": 0, + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 10 + ], + 1, + 0 + ], + 15, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 99 + ], + 1, + 0 + ], + 16, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "class", + "park" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Healthcare", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 14, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + [ + "clinic", + "dentist", + "doctors", + "doctor", + "first_aid", + "hospital", + "pharmacy", + "veterinary" + ], + [ + "get", + "class" + ], + [ + "case", + [ + "has", + "class" + ], + "", + "dot" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 12, + 10 + ], + [ + 16, + 12 + ], + [ + 22, + 14 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(6, 96%, 35%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "hospital" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "clinic", + "hospital" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(6, 96%, 35%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "hospital" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + [ + "clinic", + "hospital" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "$type", + "Point" + ], + [ + "in", + "class", + "clinic", + "dentist", + "doctors", + "first_aid", + "hospital", + "pharmacy", + "veterinary" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Place labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 4, + "layout": { + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "center", + "text-field": "{name}", + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-letter-spacing": [ + "match", + [ + "get", + "class" + ], + [ + "suburb", + "neighborhood", + "neighbourhood", + "quarter", + "island" + ], + 0.2, + 0 + ], + "text-max-width": [ + "match", + [ + "get", + "class" + ], + [ + "island" + ], + 6, + 8 + ], + "text-offset": [ + 0, + 0 + ], + "text-padding": 2, + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 3, + 11, + 8, + 13, + 11, + [ + "match", + [ + "get", + "class" + ], + "village", + 12, + [ + "suburb", + "neighbourhood", + "quarter", + "hamlet", + "isolated_dwelling" + ], + 9, + "island", + 8, + 12 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + "village", + 18, + [ + "suburb", + "neighbourhood", + "quarter", + "hamlet", + "isolated_dwelling" + ], + 15, + "island", + 11, + 16 + ] + ], + "text-transform": [ + "match", + [ + "get", + "class" + ], + [ + "suburb", + "neighborhood", + "neighbourhood", + "quarter", + "island" + ], + "uppercase", + "none" + ], + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,25%)", + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1.2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 1, + 8, + [ + "match", + [ + "get", + "class" + ], + [ + "island" + ], + 0, + 1 + ], + 9, + [ + "match", + [ + "get", + "class" + ], + [ + "island" + ], + 1, + 1 + ] + ] + }, + "metadata": {}, + "filter": [ + "!in", + "class", + "continent", + "country", + "state", + "region", + "province", + "city", + "town", + "place" + ] + }, + { + "id": "Station", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "poi", + "minzoom": 12, + "layout": { + "icon-image": [ + "match", + [ + "get", + "subclass" + ], + [ + "bus_stop", + "subway" + ], + [ + "get", + "subclass" + ], + "bus_station", + "bus_stop", + "station", + "railway", + "tram_stop", + "tramway", + [ + "case", + [ + "has", + "subclass" + ], + "dot", + "" + ] + ], + "icon-size": 1, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "top", + "text-field": "{name}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-line-height": 0.9, + "text-max-width": 9, + "text-offset": [ + 0, + 0.9 + ], + "text-optional": true, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 13, + 11 + ], + [ + 16, + 12 + ], + [ + 22, + 16 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(215, 83%, 53%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.8, + 16, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": 2, + "icon-opacity": [ + "step", + [ + "zoom" + ], + 0, + 12, + [ + "match", + [ + "get", + "subclass" + ], + [ + "station" + ], + 1, + 0 + ], + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "station", + "subway", + "tram_stop" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "bus_stop", + "station", + "subway", + "tram_stop" + ], + 1, + 0 + ], + 17, + 1 + ], + "text-color": "hsl(215, 83%, 53%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 12, + 1, + 14, + 0.5, + 16, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": 2, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 12, + [ + "match", + [ + "get", + "subclass" + ], + [ + "station" + ], + 1, + 0 + ], + 14, + [ + "match", + [ + "get", + "subclass" + ], + [ + "station", + "subway", + "tram_stop" + ], + 1, + 0 + ], + 16, + [ + "match", + [ + "get", + "subclass" + ], + [ + "bus_stop", + "station", + "subway", + "tram_stop" + ], + 1, + 0 + ], + 17, + 1 + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "in", + "class", + "bus", + "railway" + ], + [ + "has", + "name" + ] + ] + }, + { + "id": "Airport gate", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "aeroway", + "minzoom": 15, + "layout": { + "text-field": "{ref}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-size": { + "stops": [ + [ + 15, + 10 + ], + [ + 22, + 18 + ] + ] + }, + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,40%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "filter": [ + "==", + "class", + "gate" + ] + }, + { + "id": "Airport", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "aerodrome_label", + "minzoom": 8, + "layout": { + "icon-image": [ + "match", + [ + "get", + "class" + ], + "international", + "airport", + "airfield" + ], + "icon-size": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 0.6, + 10, + [ + "match", + [ + "get", + "class" + ], + "international", + 0.8, + 0.6 + ], + 16, + [ + "match", + [ + "get", + "class" + ], + "international", + 1, + 0.8 + ] + ], + "text-anchor": "top", + "text-field": { + "stops": [ + [ + 8, + " " + ], + [ + 9, + "{iata}" + ], + [ + 12, + "{name:en}" + ] + ] + }, + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-line-height": 1.2, + "text-max-width": 9, + "text-offset": [ + 0, + 0.8 + ], + "text-optional": true, + "text-padding": 2, + "text-size": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 9, + 9, + 10, + [ + "match", + [ + "get", + "class" + ], + "international", + 10, + 7 + ], + 14, + [ + "match", + [ + "get", + "class" + ], + "international", + 13, + 11 + ] + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(215, 83%, 53%)", + "icon-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 1, + 10, + 0.5, + 12, + 0 + ], + "icon-halo-color": "hsl(0, 0%, 100%)", + "icon-halo-width": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 1, + 12, + 2 + ], + "icon-opacity": 1, + "text-color": "hsl(215, 83%, 53%)", + "text-halo-blur": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 1, + 10, + 0.5, + 12, + 0 + ], + "text-halo-color": "hsl(0, 0%, 100%)", + "text-halo-width": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 8, + 1, + 12, + 2 + ] + }, + "filter": [ + "all", + [ + "has", + "iata" + ], + [ + "!in", + "class", + "public" + ] + ] + }, + { + "id": "State labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 3, + "maxzoom": 9, + "layout": { + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-letter-spacing": 0.1, + "text-max-width": 8, + "text-padding": 2, + "text-size": { + "stops": [ + [ + 3, + 9 + ], + [ + 5, + 10 + ], + [ + 6, + 11 + ] + ] + }, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(48,4%,44%)", + "text-halo-color": "hsla(0,0%,100%,0.75)", + "text-halo-width": 0.8, + "text-opacity": [ + "step", + [ + "zoom" + ], + 0, + 3, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 3 + ], + 1, + 0 + ], + 8, + [ + "case", + [ + "==", + [ + "get", + "rank" + ], + 0 + ], + 0, + 1 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "in", + "class", + "state", + "province" + ], + [ + "<=", + "rank", + 6 + ] + ] + }, + { + "id": "Town labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 4, + "maxzoom": 16, + "layout": { + "icon-allow-overlap": true, + "icon-image": { + "stops": [ + [ + 6, + "circle" + ], + [ + 12, + " " + ] + ] + }, + "icon-optional": false, + "icon-size": [ + "interpolate", + [ + "exponential", + 1 + ], + [ + "zoom" + ], + 6, + 0.3, + 14, + 0.4 + ], + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "bottom", + "text-field": [ + "coalesce", + [ + "get", + "name:en" + ], + [ + "get", + "name" + ] + ], + "text-font": [ + "Roboto Regular", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + -0.15 + ], + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 6, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 12 + ], + 11, + 10 + ], + 9, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 15 + ], + 13, + 12 + ], + 16, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 15 + ], + 22, + 20 + ] + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 20%, 99%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "text-color": [ + "interpolate", + [ + "linear" + ], + [ + "zoom" + ], + 6, + "hsl(0,0%,20%)", + 12, + "hsl(0,0%,0%)" + ], + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "town" + ] + }, + { + "id": "City labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 4, + "maxzoom": 16, + "layout": { + "icon-allow-overlap": true, + "icon-image": [ + "step", + [ + "zoom" + ], + "circle", + 13, + "" + ], + "icon-optional": false, + "icon-size": 0.4, + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "bottom", + "text-field": "{name:en}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + -0.15 + ], + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 4, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 2 + ], + 14, + 12 + ], + 8, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 4 + ], + 18, + 14 + ], + 12, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 4 + ], + 24, + 18 + ], + 16, + [ + "case", + [ + "<=", + [ + "get", + "rank" + ], + 4 + ], + 32, + 26 + ] + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 100%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "icon-opacity": 1, + "text-color": "hsl(0,0%,20%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 0.8 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "class", + "city" + ], + [ + "!=", + "capital", + 2 + ] + ] + }, + { + "id": "Capital city labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 4, + "maxzoom": 16, + "layout": { + "icon-allow-overlap": true, + "icon-image": [ + "step", + [ + "zoom" + ], + "circle", + 13, + "" + ], + "icon-optional": false, + "icon-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 4, + 0.45, + 10, + 0.5, + 11, + 0.6 + ], + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-anchor": "bottom", + "text-field": "{name:en}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-max-width": 8, + "text-offset": [ + 0, + -0.15 + ], + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 4, + 14, + 8, + 18, + 12, + 24, + 16, + 32 + ], + "visibility": "visible" + }, + "paint": { + "icon-color": "hsl(0, 0%, 100%)", + "icon-halo-color": "hsl(0, 0%, 29%)", + "icon-halo-width": 1, + "icon-opacity": 1, + "text-color": "hsl(0,0%,20%)", + "text-halo-blur": 0.5, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 0.8 + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "class", + "city" + ], + [ + "==", + "capital", + 2 + ] + ] + }, + { + "id": "Country labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "minzoom": 1, + "maxzoom": 12, + "layout": { + "symbol-sort-key": [ + "to-number", + [ + "get", + "rank" + ] + ], + "text-allow-overlap": false, + "text-field": "{name:en}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-letter-spacing": 0.07, + "text-max-width": { + "stops": [ + [ + 1, + 5 + ], + [ + 5, + 8 + ] + ] + }, + "text-padding": 1, + "text-size": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 0, + 8, + 1, + 10, + 4, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 2 + ], + 15, + 17 + ], + 8, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 2 + ], + 19, + 23 + ] + ], + "text-transform": "none", + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0, 0%, 20%)", + "text-halo-blur": 0.8, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1, + "text-opacity": [ + "interpolate", + [ + "linear", + 1 + ], + [ + "zoom" + ], + 4, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 4 + ], + 0, + 1 + ], + 5.9, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 4 + ], + 0, + 1 + ], + 6, + [ + "case", + [ + ">", + [ + "get", + "rank" + ], + 4 + ], + 1, + 1 + ] + ] + }, + "metadata": {}, + "filter": [ + "all", + [ + "==", + "class", + "country" + ], + [ + "has", + "iso_a2" + ], + [ + "!=", + "iso_a2", + "VA" + ] + ] + }, + { + "id": "Continent labels", + "type": "symbol", + "source": "maptiler_planet", + "source-layer": "place", + "maxzoom": 1, + "layout": { + "text-field": "{name:en}", + "text-font": [ + "Roboto Medium", + "Noto Sans Regular" + ], + "text-justify": "center", + "text-size": { + "stops": [ + [ + 0, + 12 + ], + [ + 2, + 13 + ] + ] + }, + "text-transform": "uppercase", + "visibility": "visible" + }, + "paint": { + "text-color": "hsl(0,0%,19%)", + "text-halo-blur": 1, + "text-halo-color": "hsl(0,0%,100%)", + "text-halo-width": 1 + }, + "metadata": {}, + "filter": [ + "==", + "class", + "continent" + ] + } + ], + "metadata": { + "maptiler:copyright": "You are licensed to use the style or its derivate for serving map tiles exclusively with MapTiler Server or MapTiler Cloud and in accordance with their licenses and terms. If you plan to use the style in a different way, contact us at sales@maptiler.com.", + "spaceColor": "hsl(203, 100%, 85%)" + }, + "glyphs": "https://api.maptiler.com/fonts/{fontstack}/{range}.pbf?key=Tp9K7a8qzMTkBSzO4EZb", + "sprite": "https://api.maptiler.com/maps/streets-v2/sprite", + "bearing": 0, + "pitch": 0, + "center": [ + 0, + 0 + ], + "zoom": 1 +} \ No newline at end of file diff --git a/library/src/commonTest/composeResources/files/test_style_street_v2_sprite.json b/library/src/commonTest/composeResources/files/test_style_street_v2_sprite.json new file mode 100644 index 00000000..577fed5a --- /dev/null +++ b/library/src/commonTest/composeResources/files/test_style_street_v2_sprite.json @@ -0,0 +1 @@ +{"us-highway_1":{"width":23,"height":23,"x":0,"y":0,"pixelRatio":1.0,"sdf":true},"us-highway_2":{"width":23,"height":23,"x":23,"y":0,"pixelRatio":1.0,"sdf":true},"us-highway_3":{"width":27,"height":23,"x":0,"y":23,"pixelRatio":1.0,"sdf":true},"us-interstate_1":{"width":23,"height":23,"x":46,"y":0,"pixelRatio":1.0,"sdf":true},"us-interstate_2":{"width":23,"height":23,"x":69,"y":0,"pixelRatio":1.0,"sdf":true},"us-interstate_3":{"width":27,"height":23,"x":27,"y":23,"pixelRatio":1.0,"sdf":true},"us-interstate_4":{"width":29,"height":22,"x":54,"y":23,"pixelRatio":1.0,"sdf":true},"us-interstate_5":{"width":34,"height":22,"x":0,"y":46,"pixelRatio":1.0,"sdf":true},"aerialway":{"width":21,"height":21,"x":34,"y":46,"pixelRatio":1.0,"sdf":true},"airfield":{"width":21,"height":21,"x":55,"y":46,"pixelRatio":1.0,"sdf":true},"airport":{"width":21,"height":21,"x":0,"y":68,"pixelRatio":1.0,"sdf":true},"alcohol_shop":{"width":21,"height":21,"x":21,"y":68,"pixelRatio":1.0,"sdf":true},"american_football":{"width":21,"height":21,"x":42,"y":68,"pixelRatio":1.0,"sdf":true},"animal_shelter":{"width":21,"height":21,"x":63,"y":68,"pixelRatio":1.0,"sdf":true},"aquarium":{"width":21,"height":21,"x":84,"y":68,"pixelRatio":1.0,"sdf":true},"art_gallery":{"width":21,"height":21,"x":105,"y":68,"pixelRatio":1.0,"sdf":true},"atm":{"width":21,"height":21,"x":126,"y":68,"pixelRatio":1.0,"sdf":true},"attraction":{"width":21,"height":21,"x":147,"y":68,"pixelRatio":1.0,"sdf":true},"bakery":{"width":21,"height":21,"x":76,"y":46,"pixelRatio":1.0,"sdf":true},"bank":{"width":21,"height":21,"x":97,"y":46,"pixelRatio":1.0,"sdf":true},"bar":{"width":21,"height":21,"x":118,"y":46,"pixelRatio":1.0,"sdf":true},"barrier":{"width":21,"height":21,"x":139,"y":46,"pixelRatio":1.0,"sdf":true},"baseball":{"width":21,"height":21,"x":160,"y":46,"pixelRatio":1.0,"sdf":true},"basketball":{"width":21,"height":21,"x":92,"y":0,"pixelRatio":1.0,"sdf":true},"bbq":{"width":21,"height":21,"x":113,"y":0,"pixelRatio":1.0,"sdf":true},"beach":{"width":21,"height":21,"x":134,"y":0,"pixelRatio":1.0,"sdf":true},"beer":{"width":21,"height":21,"x":155,"y":0,"pixelRatio":1.0,"sdf":true},"bicycle":{"width":21,"height":21,"x":83,"y":23,"pixelRatio":1.0,"sdf":true},"bicycle_parking":{"width":21,"height":21,"x":104,"y":23,"pixelRatio":1.0,"sdf":true},"bicycle_rental":{"width":21,"height":21,"x":125,"y":23,"pixelRatio":1.0,"sdf":true},"bicycle_share":{"width":21,"height":21,"x":146,"y":23,"pixelRatio":1.0,"sdf":true},"billiards":{"width":21,"height":21,"x":0,"y":89,"pixelRatio":1.0,"sdf":true},"board":{"width":21,"height":21,"x":21,"y":89,"pixelRatio":1.0,"sdf":true},"bollard":{"width":21,"height":21,"x":42,"y":89,"pixelRatio":1.0,"sdf":true},"bowling":{"width":21,"height":21,"x":63,"y":89,"pixelRatio":1.0,"sdf":true},"buddhist":{"width":21,"height":21,"x":84,"y":89,"pixelRatio":1.0,"sdf":true},"building":{"width":21,"height":21,"x":105,"y":89,"pixelRatio":1.0,"sdf":true},"bulldozer":{"width":21,"height":21,"x":126,"y":89,"pixelRatio":1.0,"sdf":true},"bus_guided":{"width":21,"height":21,"x":147,"y":89,"pixelRatio":1.0,"sdf":true},"bus_stop":{"width":21,"height":21,"x":0,"y":110,"pixelRatio":1.0,"sdf":true},"bus_trolley":{"width":21,"height":21,"x":21,"y":110,"pixelRatio":1.0,"sdf":true},"butcher":{"width":21,"height":21,"x":42,"y":110,"pixelRatio":1.0,"sdf":true},"cafe":{"width":21,"height":21,"x":63,"y":110,"pixelRatio":1.0,"sdf":true},"camper_trailer":{"width":21,"height":21,"x":84,"y":110,"pixelRatio":1.0,"sdf":true},"campfire":{"width":21,"height":21,"x":105,"y":110,"pixelRatio":1.0,"sdf":true},"campsite":{"width":21,"height":21,"x":126,"y":110,"pixelRatio":1.0,"sdf":true},"car":{"width":21,"height":21,"x":147,"y":110,"pixelRatio":1.0,"sdf":true},"car_rental":{"width":21,"height":21,"x":0,"y":131,"pixelRatio":1.0,"sdf":true},"car_repair":{"width":21,"height":21,"x":21,"y":131,"pixelRatio":1.0,"sdf":true},"casino":{"width":21,"height":21,"x":42,"y":131,"pixelRatio":1.0,"sdf":true},"castle":{"width":21,"height":21,"x":63,"y":131,"pixelRatio":1.0,"sdf":true},"caution":{"width":21,"height":21,"x":84,"y":131,"pixelRatio":1.0,"sdf":true},"cemetery":{"width":21,"height":21,"x":105,"y":131,"pixelRatio":1.0,"sdf":true},"charging_station":{"width":21,"height":21,"x":126,"y":131,"pixelRatio":1.0,"sdf":true},"christian":{"width":21,"height":21,"x":147,"y":131,"pixelRatio":1.0,"sdf":true},"cinema":{"width":21,"height":21,"x":0,"y":152,"pixelRatio":1.0,"sdf":true},"circle":{"width":21,"height":21,"x":21,"y":152,"pixelRatio":1.0,"sdf":true},"circle-dot":{"width":21,"height":21,"x":42,"y":152,"pixelRatio":1.0,"sdf":true},"circle-stroke":{"width":21,"height":21,"x":63,"y":152,"pixelRatio":1.0,"sdf":true},"city":{"width":21,"height":21,"x":84,"y":152,"pixelRatio":1.0,"sdf":true},"clothing_store":{"width":21,"height":21,"x":105,"y":152,"pixelRatio":1.0,"sdf":true},"college":{"width":21,"height":21,"x":126,"y":152,"pixelRatio":1.0,"sdf":true},"commercial":{"width":21,"height":21,"x":147,"y":152,"pixelRatio":1.0,"sdf":true},"communications_tower":{"width":21,"height":21,"x":168,"y":68,"pixelRatio":1.0,"sdf":true},"confectionery":{"width":21,"height":21,"x":189,"y":68,"pixelRatio":1.0,"sdf":true},"construction":{"width":21,"height":21,"x":210,"y":68,"pixelRatio":1.0,"sdf":true},"convenience":{"width":21,"height":21,"x":231,"y":68,"pixelRatio":1.0,"sdf":true},"cricket":{"width":21,"height":21,"x":252,"y":68,"pixelRatio":1.0,"sdf":true},"cross":{"width":21,"height":21,"x":273,"y":68,"pixelRatio":1.0,"sdf":true},"cycle_barrier":{"width":21,"height":21,"x":294,"y":68,"pixelRatio":1.0,"sdf":true},"dam":{"width":21,"height":21,"x":315,"y":68,"pixelRatio":1.0,"sdf":true},"danger":{"width":21,"height":21,"x":336,"y":68,"pixelRatio":1.0,"sdf":true},"defibrillator":{"width":21,"height":21,"x":168,"y":89,"pixelRatio":1.0,"sdf":true},"dentist":{"width":21,"height":21,"x":189,"y":89,"pixelRatio":1.0,"sdf":true},"diamond":{"width":21,"height":21,"x":210,"y":89,"pixelRatio":1.0,"sdf":true},"diamond_stroked":{"width":21,"height":21,"x":231,"y":89,"pixelRatio":1.0,"sdf":true},"diplomatic":{"width":21,"height":21,"x":252,"y":89,"pixelRatio":1.0,"sdf":true},"doctors":{"width":21,"height":21,"x":273,"y":89,"pixelRatio":1.0,"sdf":true},"dog_park":{"width":21,"height":21,"x":294,"y":89,"pixelRatio":1.0,"sdf":true},"drinking_water":{"width":21,"height":21,"x":315,"y":89,"pixelRatio":1.0,"sdf":true},"elevator":{"width":21,"height":21,"x":336,"y":89,"pixelRatio":1.0,"sdf":true},"emergency_phone":{"width":21,"height":21,"x":168,"y":110,"pixelRatio":1.0,"sdf":true},"entrance":{"width":21,"height":21,"x":189,"y":110,"pixelRatio":1.0,"sdf":true},"farm":{"width":21,"height":21,"x":210,"y":110,"pixelRatio":1.0,"sdf":true},"fast_food":{"width":21,"height":21,"x":231,"y":110,"pixelRatio":1.0,"sdf":true},"fence":{"width":21,"height":21,"x":252,"y":110,"pixelRatio":1.0,"sdf":true},"ferry_terminal":{"width":21,"height":21,"x":273,"y":110,"pixelRatio":1.0,"sdf":true},"fire_station":{"width":21,"height":21,"x":294,"y":110,"pixelRatio":1.0,"sdf":true},"fitness_centre":{"width":21,"height":21,"x":315,"y":110,"pixelRatio":1.0,"sdf":true},"florist":{"width":21,"height":21,"x":336,"y":110,"pixelRatio":1.0,"sdf":true},"fountain":{"width":21,"height":21,"x":168,"y":131,"pixelRatio":1.0,"sdf":true},"fuel":{"width":21,"height":21,"x":189,"y":131,"pixelRatio":1.0,"sdf":true},"furniture":{"width":21,"height":21,"x":210,"y":131,"pixelRatio":1.0,"sdf":true},"gaming":{"width":21,"height":21,"x":231,"y":131,"pixelRatio":1.0,"sdf":true},"garden":{"width":21,"height":21,"x":252,"y":131,"pixelRatio":1.0,"sdf":true},"garden_centre":{"width":21,"height":21,"x":273,"y":131,"pixelRatio":1.0,"sdf":true},"gate":{"width":21,"height":21,"x":294,"y":131,"pixelRatio":1.0,"sdf":true},"gift":{"width":21,"height":21,"x":315,"y":131,"pixelRatio":1.0,"sdf":true},"globe":{"width":21,"height":21,"x":336,"y":131,"pixelRatio":1.0,"sdf":true},"golf":{"width":21,"height":21,"x":168,"y":152,"pixelRatio":1.0,"sdf":true},"gondola":{"width":21,"height":21,"x":189,"y":152,"pixelRatio":1.0,"sdf":true},"grocery":{"width":21,"height":21,"x":210,"y":152,"pixelRatio":1.0,"sdf":true},"guidepost":{"width":21,"height":21,"x":231,"y":152,"pixelRatio":1.0,"sdf":true},"hairdresser":{"width":21,"height":21,"x":252,"y":152,"pixelRatio":1.0,"sdf":true},"harbor":{"width":21,"height":21,"x":273,"y":152,"pixelRatio":1.0,"sdf":true},"hardware":{"width":21,"height":21,"x":294,"y":152,"pixelRatio":1.0,"sdf":true},"heart":{"width":21,"height":21,"x":315,"y":152,"pixelRatio":1.0,"sdf":true},"heliport":{"width":21,"height":21,"x":336,"y":152,"pixelRatio":1.0,"sdf":true},"highway_rest_area":{"width":21,"height":21,"x":181,"y":46,"pixelRatio":1.0,"sdf":true},"hinduist":{"width":21,"height":21,"x":202,"y":46,"pixelRatio":1.0,"sdf":true},"historic":{"width":21,"height":21,"x":223,"y":46,"pixelRatio":1.0,"sdf":true},"home":{"width":21,"height":21,"x":244,"y":46,"pixelRatio":1.0,"sdf":true},"horse_riding":{"width":21,"height":21,"x":265,"y":46,"pixelRatio":1.0,"sdf":true},"hospital":{"width":21,"height":21,"x":286,"y":46,"pixelRatio":1.0,"sdf":true},"hot_spring":{"width":21,"height":21,"x":307,"y":46,"pixelRatio":1.0,"sdf":true},"ice_cream":{"width":21,"height":21,"x":328,"y":46,"pixelRatio":1.0,"sdf":true},"industry":{"width":21,"height":21,"x":176,"y":0,"pixelRatio":1.0,"sdf":true},"information":{"width":21,"height":21,"x":197,"y":0,"pixelRatio":1.0,"sdf":true},"jewelry":{"width":21,"height":21,"x":218,"y":0,"pixelRatio":1.0,"sdf":true},"jewish":{"width":21,"height":21,"x":239,"y":0,"pixelRatio":1.0,"sdf":true},"karaoke":{"width":21,"height":21,"x":260,"y":0,"pixelRatio":1.0,"sdf":true},"landmark":{"width":21,"height":21,"x":281,"y":0,"pixelRatio":1.0,"sdf":true},"laundry":{"width":21,"height":21,"x":302,"y":0,"pixelRatio":1.0,"sdf":true},"library":{"width":21,"height":21,"x":323,"y":0,"pixelRatio":1.0,"sdf":true},"lift_gate":{"width":21,"height":21,"x":344,"y":0,"pixelRatio":1.0,"sdf":true},"light_rail":{"width":21,"height":21,"x":167,"y":23,"pixelRatio":1.0,"sdf":true},"lighthouse":{"width":21,"height":21,"x":188,"y":23,"pixelRatio":1.0,"sdf":true},"lodging":{"width":21,"height":21,"x":209,"y":23,"pixelRatio":1.0,"sdf":true},"marker":{"width":21,"height":21,"x":251,"y":23,"pixelRatio":1.0,"sdf":true},"marker_stroked":{"width":21,"height":21,"x":272,"y":23,"pixelRatio":1.0,"sdf":true},"mobile_phone":{"width":21,"height":21,"x":293,"y":23,"pixelRatio":1.0,"sdf":true},"monorail":{"width":21,"height":21,"x":314,"y":23,"pixelRatio":1.0,"sdf":true},"monument":{"width":21,"height":21,"x":335,"y":23,"pixelRatio":1.0,"sdf":true},"motorcycle":{"width":21,"height":21,"x":0,"y":173,"pixelRatio":1.0,"sdf":true},"motorcycle_parking":{"width":21,"height":21,"x":21,"y":173,"pixelRatio":1.0,"sdf":true},"motorcycle_rental":{"width":21,"height":21,"x":42,"y":173,"pixelRatio":1.0,"sdf":true},"motorcycle_repair":{"width":21,"height":21,"x":63,"y":173,"pixelRatio":1.0,"sdf":true},"museum":{"width":21,"height":21,"x":84,"y":173,"pixelRatio":1.0,"sdf":true},"music":{"width":21,"height":21,"x":105,"y":173,"pixelRatio":1.0,"sdf":true},"muslim":{"width":21,"height":21,"x":126,"y":173,"pixelRatio":1.0,"sdf":true},"natural":{"width":21,"height":21,"x":147,"y":173,"pixelRatio":1.0,"sdf":true},"noodle":{"width":21,"height":21,"x":168,"y":173,"pixelRatio":1.0,"sdf":true},"obelisk":{"width":21,"height":21,"x":189,"y":173,"pixelRatio":1.0,"sdf":true},"observation_tower":{"width":21,"height":21,"x":210,"y":173,"pixelRatio":1.0,"sdf":true},"oneway":{"width":21,"height":21,"x":231,"y":173,"pixelRatio":1.0,"sdf":true},"optician":{"width":21,"height":21,"x":252,"y":173,"pixelRatio":1.0,"sdf":true},"outdoor":{"width":21,"height":21,"x":273,"y":173,"pixelRatio":1.0,"sdf":true},"paint":{"width":21,"height":21,"x":294,"y":173,"pixelRatio":1.0,"sdf":true},"park":{"width":21,"height":21,"x":315,"y":173,"pixelRatio":1.0,"sdf":true},"parking":{"width":21,"height":21,"x":336,"y":173,"pixelRatio":1.0,"sdf":true},"parking_garage":{"width":21,"height":21,"x":0,"y":194,"pixelRatio":1.0,"sdf":true},"parking_paid":{"width":21,"height":21,"x":21,"y":194,"pixelRatio":1.0,"sdf":true},"peak":{"width":21,"height":21,"x":42,"y":194,"pixelRatio":1.0,"sdf":true},"perfumery":{"width":21,"height":21,"x":63,"y":194,"pixelRatio":1.0,"sdf":true},"pharmacy":{"width":21,"height":21,"x":84,"y":194,"pixelRatio":1.0,"sdf":true},"picnic_site":{"width":21,"height":21,"x":105,"y":194,"pixelRatio":1.0,"sdf":true},"pin":{"width":21,"height":21,"x":126,"y":194,"pixelRatio":1.0,"sdf":true},"pipe":{"width":21,"height":21,"x":147,"y":194,"pixelRatio":1.0,"sdf":true},"pitch":{"width":21,"height":21,"x":168,"y":194,"pixelRatio":1.0,"sdf":true},"pizza":{"width":21,"height":21,"x":189,"y":194,"pixelRatio":1.0,"sdf":true},"place_of_worship":{"width":21,"height":21,"x":210,"y":194,"pixelRatio":1.0,"sdf":true},"playground":{"width":21,"height":21,"x":231,"y":194,"pixelRatio":1.0,"sdf":true},"police":{"width":21,"height":21,"x":252,"y":194,"pixelRatio":1.0,"sdf":true},"post":{"width":21,"height":21,"x":273,"y":194,"pixelRatio":1.0,"sdf":true},"prison":{"width":21,"height":21,"x":294,"y":194,"pixelRatio":1.0,"sdf":true},"racetrack":{"width":21,"height":21,"x":315,"y":194,"pixelRatio":1.0,"sdf":true},"radiation":{"width":21,"height":21,"x":336,"y":194,"pixelRatio":1.0,"sdf":true},"railway":{"width":21,"height":21,"x":0,"y":215,"pixelRatio":1.0,"sdf":true},"ranger_station":{"width":21,"height":21,"x":21,"y":215,"pixelRatio":1.0,"sdf":true},"recycling":{"width":21,"height":21,"x":42,"y":215,"pixelRatio":1.0,"sdf":true},"restaurant":{"width":21,"height":21,"x":63,"y":215,"pixelRatio":1.0,"sdf":true},"road_accident":{"width":21,"height":21,"x":84,"y":215,"pixelRatio":1.0,"sdf":true},"roadblock":{"width":21,"height":21,"x":105,"y":215,"pixelRatio":1.0,"sdf":true},"rocket":{"width":21,"height":21,"x":126,"y":215,"pixelRatio":1.0,"sdf":true},"school":{"width":21,"height":21,"x":147,"y":215,"pixelRatio":1.0,"sdf":true},"school_bus":{"width":21,"height":21,"x":168,"y":215,"pixelRatio":1.0,"sdf":true},"scooter":{"width":21,"height":21,"x":189,"y":215,"pixelRatio":1.0,"sdf":true},"sculpture":{"width":21,"height":21,"x":210,"y":215,"pixelRatio":1.0,"sdf":true},"seafood":{"width":21,"height":21,"x":231,"y":215,"pixelRatio":1.0,"sdf":true},"shinto":{"width":21,"height":21,"x":252,"y":215,"pixelRatio":1.0,"sdf":true},"shoes":{"width":21,"height":21,"x":273,"y":215,"pixelRatio":1.0,"sdf":true},"shop":{"width":21,"height":21,"x":294,"y":215,"pixelRatio":1.0,"sdf":true},"sikh":{"width":21,"height":21,"x":315,"y":215,"pixelRatio":1.0,"sdf":true},"skateboard":{"width":21,"height":21,"x":336,"y":215,"pixelRatio":1.0,"sdf":true},"snow":{"width":21,"height":21,"x":0,"y":236,"pixelRatio":1.0,"sdf":true},"soccer":{"width":21,"height":21,"x":21,"y":236,"pixelRatio":1.0,"sdf":true},"spring":{"width":21,"height":21,"x":42,"y":236,"pixelRatio":1.0,"sdf":true},"stadium":{"width":21,"height":21,"x":63,"y":236,"pixelRatio":1.0,"sdf":true},"star":{"width":21,"height":21,"x":84,"y":236,"pixelRatio":1.0,"sdf":true},"star_stroked":{"width":21,"height":21,"x":105,"y":236,"pixelRatio":1.0,"sdf":true},"statue":{"width":21,"height":21,"x":126,"y":236,"pixelRatio":1.0,"sdf":true},"subway":{"width":21,"height":21,"x":147,"y":236,"pixelRatio":1.0,"sdf":true},"suitcase":{"width":21,"height":21,"x":168,"y":236,"pixelRatio":1.0,"sdf":true},"sushi":{"width":21,"height":21,"x":189,"y":236,"pixelRatio":1.0,"sdf":true},"swimming":{"width":21,"height":21,"x":210,"y":236,"pixelRatio":1.0,"sdf":true},"swimming_pool":{"width":21,"height":21,"x":231,"y":236,"pixelRatio":1.0,"sdf":true},"tako":{"width":21,"height":21,"x":252,"y":236,"pixelRatio":1.0,"sdf":true},"taoist":{"width":21,"height":21,"x":273,"y":236,"pixelRatio":1.0,"sdf":true},"taxi":{"width":21,"height":21,"x":294,"y":236,"pixelRatio":1.0,"sdf":true},"teahouse":{"width":21,"height":21,"x":315,"y":236,"pixelRatio":1.0,"sdf":true},"telephone":{"width":21,"height":21,"x":336,"y":236,"pixelRatio":1.0,"sdf":true},"tennis":{"width":21,"height":21,"x":0,"y":257,"pixelRatio":1.0,"sdf":true},"terminal":{"width":21,"height":21,"x":21,"y":257,"pixelRatio":1.0,"sdf":true},"theatre":{"width":21,"height":21,"x":42,"y":257,"pixelRatio":1.0,"sdf":true},"theme_park":{"width":21,"height":21,"x":63,"y":257,"pixelRatio":1.0,"sdf":true},"toilets":{"width":21,"height":21,"x":84,"y":257,"pixelRatio":1.0,"sdf":true},"toll":{"width":21,"height":21,"x":105,"y":257,"pixelRatio":1.0,"sdf":true},"town":{"width":21,"height":21,"x":126,"y":257,"pixelRatio":1.0,"sdf":true},"town_hall":{"width":21,"height":21,"x":147,"y":257,"pixelRatio":1.0,"sdf":true},"tram_stop":{"width":21,"height":21,"x":168,"y":257,"pixelRatio":1.0,"sdf":true},"tramway":{"width":21,"height":21,"x":189,"y":257,"pixelRatio":1.0,"sdf":true},"transit":{"width":21,"height":21,"x":210,"y":257,"pixelRatio":1.0,"sdf":true},"truck":{"width":21,"height":21,"x":231,"y":257,"pixelRatio":1.0,"sdf":true},"tunnel":{"width":21,"height":21,"x":252,"y":257,"pixelRatio":1.0,"sdf":true},"veterinary":{"width":21,"height":21,"x":273,"y":257,"pixelRatio":1.0,"sdf":true},"viewpoint":{"width":21,"height":21,"x":294,"y":257,"pixelRatio":1.0,"sdf":true},"village":{"width":21,"height":21,"x":315,"y":257,"pixelRatio":1.0,"sdf":true},"volcano":{"width":21,"height":21,"x":336,"y":257,"pixelRatio":1.0,"sdf":true},"volleyball":{"width":21,"height":21,"x":0,"y":278,"pixelRatio":1.0,"sdf":true},"warehouse":{"width":21,"height":21,"x":21,"y":278,"pixelRatio":1.0,"sdf":true},"waste_basket":{"width":21,"height":21,"x":42,"y":278,"pixelRatio":1.0,"sdf":true},"watches":{"width":21,"height":21,"x":63,"y":278,"pixelRatio":1.0,"sdf":true},"water":{"width":21,"height":21,"x":84,"y":278,"pixelRatio":1.0,"sdf":true},"water_park":{"width":21,"height":21,"x":105,"y":278,"pixelRatio":1.0,"sdf":true},"water_tower":{"width":21,"height":21,"x":126,"y":278,"pixelRatio":1.0,"sdf":true},"watermill":{"width":21,"height":21,"x":147,"y":278,"pixelRatio":1.0,"sdf":true},"wetland":{"width":21,"height":21,"x":168,"y":278,"pixelRatio":1.0,"sdf":true},"wheelchair":{"width":21,"height":21,"x":189,"y":278,"pixelRatio":1.0,"sdf":true},"windmill":{"width":21,"height":21,"x":210,"y":278,"pixelRatio":1.0,"sdf":true},"wine":{"width":21,"height":21,"x":231,"y":278,"pixelRatio":1.0,"sdf":true},"zoo":{"width":21,"height":21,"x":252,"y":278,"pixelRatio":1.0,"sdf":true},"road_1":{"width":20,"height":20,"x":273,"y":278,"pixelRatio":1.0,"sdf":true},"us-state_1":{"width":23,"height":20,"x":293,"y":278,"pixelRatio":1.0,"sdf":true},"us-state_2":{"width":28,"height":20,"x":316,"y":278,"pixelRatio":1.0,"sdf":true},"us-state_3":{"width":33,"height":20,"x":0,"y":299,"pixelRatio":1.0,"sdf":true},"us-state_4":{"width":38,"height":20,"x":33,"y":299,"pixelRatio":1.0,"sdf":true},"us-state_5":{"width":43,"height":20,"x":71,"y":299,"pixelRatio":1.0,"sdf":true},"us-state_6":{"width":48,"height":20,"x":114,"y":299,"pixelRatio":1.0,"sdf":true},"road_2":{"width":24,"height":19,"x":162,"y":299,"pixelRatio":1.0,"sdf":true},"road_3":{"width":30,"height":19,"x":186,"y":299,"pixelRatio":1.0,"sdf":true},"road_4":{"width":36,"height":19,"x":216,"y":299,"pixelRatio":1.0,"sdf":true},"road_5":{"width":40,"height":19,"x":252,"y":299,"pixelRatio":1.0,"sdf":true},"road_6":{"width":44,"height":19,"x":292,"y":299,"pixelRatio":1.0,"sdf":true},"golf_green":{"width":17,"height":17,"x":336,"y":299,"pixelRatio":1.0,"sdf":true},"hut":{"width":18,"height":16,"x":344,"y":278,"pixelRatio":1.0,"sdf":true},"shelter":{"width":18,"height":16,"x":349,"y":46,"pixelRatio":1.0,"sdf":true},"triangle":{"width":18,"height":16,"x":0,"y":319,"pixelRatio":1.0,"sdf":true},"triangle_stroked":{"width":17,"height":16,"x":18,"y":319,"pixelRatio":1.0,"sdf":true},"square":{"width":14,"height":14,"x":35,"y":319,"pixelRatio":1.0,"sdf":true},"square_stroked":{"width":14,"height":14,"x":49,"y":319,"pixelRatio":1.0,"sdf":true},"dot":{"width":13,"height":13,"x":63,"y":319,"pixelRatio":1.0,"sdf":true},"bench":{"width":17,"height":11,"x":76,"y":319,"pixelRatio":1.0,"sdf":true}} \ No newline at end of file diff --git a/library/src/commonTest/composeResources/files/test_style_street_v2_sprite.png b/library/src/commonTest/composeResources/files/test_style_street_v2_sprite.png new file mode 100644 index 00000000..f7d1bd87 Binary files /dev/null and b/library/src/commonTest/composeResources/files/test_style_street_v2_sprite.png differ diff --git a/library/src/commonTest/composeResources/files/test_style_swisstopo.json b/library/src/commonTest/composeResources/files/test_style_swisstopo.json new file mode 100644 index 00000000..e2fb370e --- /dev/null +++ b/library/src/commonTest/composeResources/files/test_style_swisstopo.json @@ -0,0 +1 @@ +{"version": 8, "id": "0197406a-5d2f-7168-bee5-f191641499b7", "name": "lightbasemap_v1.19.0", "sources": {"relief_v1.0.0": {"url": "https://vectortiles.geo.admin.ch/tiles/ch.swisstopo.relief.vt/v1.0.0/tiles.json", "type": "vector"}, "base_v1.0.0": {"url": "https://vectortiles.geo.admin.ch/tiles/ch.swisstopo.base.vt/v1.0.0/tiles.json", "type": "vector"}}, "layers": [{"id": "background", "type": "background", "layout": {"visibility": "visible"}, "paint": {"background-color": "rgba(252, 252, 252, 1)"}}, {"id": "hillshade_grey", "type": "fill", "source": "relief_v1.0.0", "source-layer": "hillshade", "layout": {"visibility": "visible"}, "paint": {"fill-color": ["match", ["get", "luminosity"], -15, "rgb(200,210,213)", -14, "rgb(203,213,216)", -13, "rgb(207,215,218)", -12, "rgb(210,218,221)", -11, "rgb(213,221,224)", -10, "rgb(217,224,226)", -9, "rgb(220,227,229)", -8, "rgb(224,230,231)", -7, "rgb(227,232,234)", -6, "rgb(231,235,237)", -5, "rgb(234,238,239)", -4, "rgb(238,241,242)", -3, "rgb(241,244,245)", -2, "rgb(245,247,247)", -1, "rgb(248,249,250)", "rgb(252, 252, 252)"], "fill-opacity": {"stops": [[1, 0.5], [8, 1]]}}, "filter": ["all", ["<", "luminosity", 0]]}, {"id": "hillshade_yellow", "type": "fill", "source": "relief_v1.0.0", "source-layer": "hillshade", "minzoom": 6.0, "layout": {"visibility": "visible"}, "paint": {"fill-color": "rgba(255, 217, 5, 1)", "fill-opacity": ["interpolate", ["linear"], ["zoom"], 9, 0.015, 11, 0.02]}, "filter": ["all", [">", "luminosity", 0], ["!in", "mask", "rock", "ice", "scree"]]}, {"id": "scree_z17", "type": "fill", "source": "relief_v1.0.0", "source-layer": "scree", "minzoom": 17.0, "layout": {"visibility": "visible"}, "paint": {"fill-opacity": ["interpolate", ["linear"], ["zoom"], 9, 0, 11, 0.2, 14, 0.25], "fill-pattern": ["match", ["get", "weight"], 15, "scree_very_large_1", 10, "scree_very_large_2", 5, "scree_very_large_3", 1, "scree_very_large_4", ""]}}, {"id": "scree_z15", "type": "fill", "source": "relief_v1.0.0", "source-layer": "scree", "minzoom": 15.0, "maxzoom": 17.0, "layout": {"visibility": "visible"}, "paint": {"fill-opacity": ["interpolate", ["linear"], ["zoom"], 9, 0, 11, 0.2, 14, 0.25], "fill-pattern": ["match", ["get", "weight"], 15, "scree_large_1", 10, "scree_large_2", 5, "scree_large_3", 1, "scree_large_4", ""]}}, {"id": "scree_z13", "type": "fill", "source": "relief_v1.0.0", "source-layer": "scree", "minzoom": 13.0, "maxzoom": 15.0, "layout": {"visibility": "visible"}, "paint": {"fill-opacity": ["interpolate", ["linear"], ["zoom"], 11, 0, 12, 0.2, 14, 0.25], "fill-pattern": ["match", ["get", "weight"], 15, "scree_medium_1", 10, "scree_medium_2", 5, "scree_medium_3", 1, "scree_medium_4", ""]}}, {"id": "scree_z11", "type": "fill", "source": "relief_v1.0.0", "source-layer": "scree", "minzoom": 11.0, "maxzoom": 13.0, "layout": {"visibility": "visible"}, "paint": {"fill-opacity": ["interpolate", ["linear"], ["zoom"], 11, 0, 12, 0.2, 14, 0.25], "fill-pattern": ["match", ["get", "weight"], 15, "scree_small_1", 10, "scree_small_2", 5, "scree_small_3", 1, "scree_small_4", ""]}}, {"id": "contour_line", "type": "line", "source": "base_v1.0.0", "source-layer": "contour_line", "minzoom": 13.0, "layout": {"visibility": "visible"}, "paint": {"line-blur": 0.4, "line-color": ["match", ["get", "class"], ["ice", "water"], "rgb(0,136,208)", ["scree"], "rgb(0,0,0)", "rgb(191,138,64)"], "line-width": ["interpolate", ["exponential", 1], ["zoom"], 12, ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 0.75, 0], 14, ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 1, 0], 15, ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 1.5, [20, 40, 60, 80], 0.75, 0], 18, ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 2, [20, 40, 60, 80], 1.5, 1]], "line-opacity": ["interpolate", ["linear"], ["zoom"], 13, ["match", ["get", "class"], ["scree", "ice", "water"], 0.25, 0.45], 14, ["match", ["get", "class"], ["scree", "ice", "water"], 0.3, 0.55]]}, "metadata": {"maputnik:comment": "color: rgb(191,138,64)"}, "filter": ["all", ["!in", "class", "rock", "ice", "water"]]}, {"id": "landcover", "type": "fill", "source": "base_v1.0.0", "source-layer": "landcover", "minzoom": 5.0, "layout": {"visibility": "visible"}, "paint": {"fill-color": ["match", ["get", "class"], ["forest", "wood"], "rgb(186, 210, 172)", ["ice", "glacier"], "rgb(205, 232, 244)", "wetland", "rgb(204, 229, 245)", "sand", "rgb(240, 218, 188)", "rgb(215, 224, 209)"], "fill-opacity": ["interpolate", ["exponential", 1.5], ["zoom"], 5, 0, 6, ["match", ["get", "class"], ["ice", "glacier"], 0.3, 0], 10, ["match", ["get", "class"], ["ice", "glacier"], 0.2, 0], 11, ["match", ["get", "class"], ["ice", "glacier"], 0.2, 0.3], 14, ["match", ["get", "class"], ["ice", "glacier"], 0, 0.3]], "fill-antialias": false}, "filter": ["any", ["match", ["get", "subclass"], ["allotments", "forest", "glacier", "golf_course", "park", "plant_nursery", "recreation_ground", "scrub", "woody_plant", "loose_forest"], true, false], ["case", ["==", ["typeof", ["get", "class"]], "string"], ["match", ["get", "class"], ["sand"], true, false], false]]}, {"id": "landcover_casing", "type": "line", "source": "base_v1.0.0", "source-layer": "landcover", "minzoom": 10.0, "layout": {"visibility": "visible"}, "paint": {"line-blur": 0.5, "line-color": "rgb(186, 199, 172)", "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 6, 0, 11, 0.25, 16, 0.75], "line-opacity": ["interpolate", ["exponential", 1.5], ["zoom"], 12, 0, 14, 1]}, "filter": ["all", ["in", "subclass", "wood", "scrub", "recreation_ground", "park", "golf_course", "allotments", "plant_nursery", "forest"]]}, {"id": "landuse", "type": "fill", "source": "base_v1.0.0", "source-layer": "landuse", "layout": {"visibility": "visible"}, "paint": {"fill-color": ["match", ["get", "class"], ["pitch"], "rgb(224,234,221)", ["landfill", "quarry"], "rgb(240, 218, 188)", ["cemetery", "zoo"], "rgb(215, 224, 209)", ["parking"], "rgb(255, 255, 255)", "rgb(215, 224, 209)"], "fill-opacity": ["match", ["get", "class"], ["pitch"], 1, 0.3]}, "filter": ["all", ["in", "class", "landfill", "cemetery", "quarry", "zoo", "pitch"]]}, {"id": "landuse_outline", "type": "line", "source": "base_v1.0.0", "source-layer": "landuse", "layout": {"visibility": "visible"}, "paint": {"line-color": ["match", ["get", "class"], ["pitch"], "rgb(130, 130, 130)", "rgba(186, 199, 172, 1)"], "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 11, 0.25, 16, 0.75], "line-opacity": {"stops": [[14, 0], [15, 1]]}}, "filter": ["all", ["in", "class", "cemetery", "zoo", "pitch"]]}, {"id": "water_line_intermittent", "type": "line", "source": "base_v1.0.0", "source-layer": "waterway", "minzoom": 12.0, "layout": {"visibility": "visible"}, "paint": {"line-blur": 0, "line-color": "rgba(48, 48, 48, 1)", "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 13, ["match", ["to-string", ["get", "width"]], ["10", "9", "8"], 3.5, ["7", "6", "5"], 2.5, ["4", "3"], 1.5, ["1", "2"], 1, ["match", ["get", "class"], ["river", "canal"], 3.5, 1]], 16, ["match", ["to-string", ["get", "width"]], "10", 5, "9", 4.5, "8", 4, "7", 3.5, ["6", "5"], 3, "4", 2.5, "3", 2, "2", 1.5, "1", 1, ["match", ["get", "class"], ["river", "canal"], 5, 1.5]], 20, ["match", ["to-string", ["get", "width"]], "10", 10, "9", 9.6, "8", 8.9, "7", 8.2, "6", 7.5, "5", 6.8, "4", 6.1, "3", 5.4, "2", 4.7, "1", 4, ["match", ["get", "class"], ["river", "canal"], 10, 4]]], "line-offset": 0, "line-opacity": {"stops": [[13, 0.25], [16, 0.35]]}, "line-dasharray": {"stops": [[13, [0.5, 3]], [14, [0.75, 4.5]], [15, [1, 6]], [16, [1.25, 7.5]]]}}, "filter": ["all", ["==", "intermittent", 1]]}, {"id": "water_line", "type": "line", "source": "base_v1.0.0", "source-layer": "waterway", "minzoom": 7.0, "layout": {"visibility": "visible"}, "paint": {"line-blur": 0, "line-color": ["interpolate", ["linear"], ["zoom"], 10, "rgba(138, 195, 229, 1)", 16, ["match", ["get", "class"], ["river", "canal"], "rgba(160, 205, 236, 1)", "rgba(140, 185, 226, 1)"]], "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 7, 1, 10, ["match", ["to-string", ["get", "width"]], ["10", "9", "8", "7", "6"], 1.5, ["5", "4", "3", "2", "1"], 1, ["match", ["get", "class"], ["river", "canal"], 1.5, 1]], 13, ["match", ["to-string", ["get", "width"]], ["10", "9", "8"], 3.5, ["7", "6", "5"], 2.5, ["4", "3"], 1.5, ["1", "2"], 1, ["match", ["get", "class"], ["river", "canal"], 3.5, 1]], 16, ["match", ["to-string", ["get", "width"]], "10", 5, "9", 4.5, "8", 4, "7", 3.5, ["6", "5"], 3, "4", 2.5, "3", 2, "2", 1.5, "1", 1, ["match", ["get", "class"], ["river", "canal"], 5, 1.5]], 20, ["match", ["to-string", ["get", "width"]], "10", 10, "9", 9.6, "8", 8.9, "7", 8.2, "6", 7.5, "5", 6.8, "4", 6.1, "3", 5.4, "2", 4.7, "1", 4, ["match", ["get", "class"], ["river", "canal"], 10, 4]]], "line-offset": 0, "line-opacity": 0.7}, "filter": ["all", ["!=", "intermittent", 1], ["!in", "class", "riverbank", "shoreline", "shoreline_changing_level"]]}, {"id": "water", "type": "fill", "source": "base_v1.0.0", "source-layer": "water", "layout": {"visibility": "visible"}, "paint": {"fill-color": ["interpolate", ["exponential", 1.5], ["zoom"], 4, "rgb(209, 228, 240)", 10, "rgb(199, 224, 245)"]}}, {"id": "hachure", "type": "fill", "source": "relief_v1.0.0", "source-layer": "hachure", "layout": {"visibility": "visible"}, "paint": {"fill-color": ["match", ["get", "class"], 1, "rgba(32, 32, 32, 1)", "hsl(203, 60%, 46%)"], "fill-opacity": ["interpolate", ["linear"], ["zoom"], 9, 0, 11, 0.2, 14, 0.25], "fill-antialias": false}}, {"id": "contour_line_blue", "type": "line", "source": "base_v1.0.0", "source-layer": "contour_line", "minzoom": 13.0, "layout": {"visibility": "visible"}, "paint": {"line-blur": 0.4, "line-color": "rgb(0,136,208)", "line-width": ["interpolate", ["exponential", 1], ["zoom"], 12, ["case", ["has", "lake_depth"], ["match", ["%", ["to-number", ["get", "lake_depth"]], 100], 0, 0.75, 0], ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 0.75, 0]], 14, ["case", ["has", "lake_depth"], ["match", ["%", ["to-number", ["get", "lake_depth"]], 100], 0, 1, 0], ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 1, 0]], 15, ["case", ["has", "lake_depth"], ["match", ["%", ["to-number", ["get", "lake_depth"]], 100], 0, 1.5, [20, 40, 60, 80], 0.75, 0], ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 1.5, [20, 40, 60, 80], 0.75, 0]], 18, ["case", ["has", "lake_depth"], ["match", ["%", ["to-number", ["get", "lake_depth"]], 100], 0, 2, [20, 40, 60, 80], 1.5, 1], ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 2, [20, 40, 60, 80], 1.5, 1]]], "line-opacity": ["interpolate", ["linear"], ["zoom"], 13, ["match", ["get", "class"], ["scree", "ice", "water"], 0.25, 0.45], 14, ["match", ["get", "class"], ["scree", "ice", "water"], 0.3, 0.55]]}, "metadata": {"maputnik:comment": "color: rgb(191, 138, 64)"}, "filter": ["in", "class", "ice", "water"]}, {"id": "water_outline", "type": "line", "source": "base_v1.0.0", "source-layer": "water", "layout": {"visibility": "visible"}, "paint": {"line-blur": 0.5, "line-color": "rgba(133, 189, 224, 1)", "line-width": 0.5, "line-opacity": ["interpolate", ["exponential", 1.5], ["zoom"], 0, 0, 8, 1, 14, 0]}, "filter": ["all", ["!=", "class", "ocean"]]}, {"id": "pattern_landcover", "type": "fill", "source": "base_v1.0.0", "source-layer": "landcover", "minzoom": 13.0, "layout": {"visibility": "visible"}, "paint": {"fill-opacity": ["interpolate", ["exponential", 2], ["zoom"], 13, 0, 13.2, ["match", ["get", "class"], "orchard", 0.8, "vineyard", 0.6, 0.4], 17, 1], "fill-pattern": ["match", ["get", "subclass"], "orchard", "orchard_green", "swamp", "wetland_blue", "vineyard", "vinyard_green", ""], "fill-antialias": true}, "filter": ["in", "subclass", "orchard", "swamp", "vineyard"]}, {"id": "park", "type": "line", "source": "base_v1.0.0", "source-layer": "park", "minzoom": 7.0, "layout": {"visibility": "visible"}, "paint": {"line-color": "rgba(171, 197, 159, 1)", "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 9, 1.5, 15, 8, 18, 12], "line-opacity": ["interpolate", ["linear"], ["zoom"], 7, 0, 8, 1, 13, 1, 14, 0.6]}, "filter": ["all", ["in", "class", "national_park"]]}, {"id": "boundary_disputed", "type": "line", "source": "base_v1.0.0", "source-layer": "boundary", "layout": {"line-cap": "square", "line-join": "miter", "visibility": "visible"}, "paint": {"line-blur": 1, "line-color": {"stops": [[6, "hsl(300, 55%, 80%)"], [9, "hsl(315, 40%, 85%)"]]}, "line-width": ["interpolate", ["linear"], ["zoom"], 2, ["match", ["get", "admin_level"], 2, 1, 0], 3, ["match", ["get", "admin_level"], 2, 2, 1], 7, ["match", ["get", "admin_level"], 2, 4, 1.5], 18, ["match", ["get", "admin_level"], 2, 16, 10]], "line-opacity": {"stops": [[13, 1], [14, 0.7]]}, "line-dasharray": [1.5, 2.5]}, "filter": ["all", ["in", "admin_level", 2, 4], ["!=", "maritime", 1], ["==", "disputed", 1], ["==", "$type", "LineString"]]}, {"id": "boundary", "type": "line", "source": "base_v1.0.0", "source-layer": "boundary", "layout": {"line-cap": ["literal", "round"], "line-join": ["literal", "miter"], "visibility": "visible"}, "paint": {"line-blur": 1, "line-color": {"stops": [[6, "hsl(300, 55%, 80%)"], [9, "hsl(315, 40%, 85%)"]]}, "line-width": ["interpolate", ["linear"], ["zoom"], 2, ["match", ["get", "admin_level"], 2, 1, 0], 3, ["match", ["get", "admin_level"], 2, 2, 1], 7, ["match", ["get", "admin_level"], 2, 3, 1], 18, ["match", ["get", "admin_level"], 2, 16, 10]], "line-opacity": {"stops": [[13, 1], [14, 0.8]]}}, "filter": ["all", ["in", "admin_level", 2, 4], ["!=", "maritime", 1], ["!=", "disputed", 1], ["==", "$type", "LineString"]]}, {"id": "tunnel_public_transport", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 8.0, "layout": {"line-cap": "butt", "line-join": "miter", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 8, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 2.5, 0.6], 0.6], 0.6], 14, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 2.5, 0.6], 0.6], 0.6], 18, 0.4], "line-color": {"stops": [[7, "rgba(255, 50, 50, 1)"], [15, "rgba(255, 80, 80, 1)"]]}, "line-width": ["interpolate", ["linear"], ["zoom"], 9, ["match", ["get", "subclass"], "rail", 0.75, 0], 10, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 0, 0.75], 0.5], ["match", ["get", "subclass"], ["cable_car", "funicular"], 0.75, 0.5]], 14, ["match", ["get", "class"], "transit", 1, ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 0, 2], 1], ["match", ["get", "subclass"], ["cable_car", "funicular"], 1, 0]], 18, ["match", ["get", "class"], ["transit"], 1.5, ["match", ["get", "service"], ["yard", "siding"], 1.5, 2]]], "line-opacity": ["interpolate", ["linear"], ["zoom"], 8, 0, 9, ["match", ["get", "is_route"], 99, ["match", ["get", "class"], ["rail"], 0.8, 0], 0], 13, ["match", ["get", "subclass"], ["rail", "subway", "funicular", "rack_rail", "narrow_gauge"], 0.8, 0], 14, ["match", ["get", "subclass"], ["rail", "narrow_gauge", "funicular", "rack_rail", "subway"], ["match", ["get", "service"], ["yard", "siding"], 0, 0.8], 0], 14.5, 0.8], "line-dasharray": {"stops": [[13, [4, 2.5]], [14, [6, 3.75]], [15, [10, 6.25]], [16, [14, 8.75]]]}}, "filter": ["all", ["==", "brunnel", "tunnel"], ["in", "class", "rail", "transit", "cable_car", "gondola"], ["==", "$type", "LineString"]]}, {"id": "tunnel_road", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 7.0, "layout": {"line-cap": "butt", "line-join": "miter", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 7, 3, 8, 0.4], "line-color": {"stops": [[6, "rgba(170, 170, 170, 1)"], [11, "rgba(130, 130, 130, 1)"]]}, "line-width": ["interpolate", ["linear"], ["zoom"], 8, ["match", ["get", "is_route"], [5, 10, 99], 1, ["match", ["get", "ramp"], 1, 1, 0]], 10, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway", "trunk"], 1.2, ["primary", "secondary", "tertiary", "minor"], 1, 0], 0], 11, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway", "trunk"], 1.3, ["primary", "secondary", "tertiary", "minor"], 1, 0], 0.25], 13, ["match", ["get", "class"], ["motorway", "trunk"], 1.5, ["primary", "secondary", "tertiary", "minor"], 1, 0], 14, ["match", ["get", "class"], ["motorway", "trunk"], 2, ["primary", "secondary", "tertiary", "minor"], 1.5, 0], 15, ["match", ["get", "class"], ["motorway", "trunk"], 3, 2], 20, ["match", ["get", "class"], ["motorway", "trunk"], 5, 2.5]], "line-offset": 0, "line-opacity": ["step", ["zoom"], ["match", ["get", "oneway"], 2, 0, 1], 12, 1], "line-dasharray": {"stops": [[13, [3, 1.875]], [14, [4, 2.5]], [15, [5, 3.125]], [16, [6, 3.75]]]}}, "filter": ["all", ["==", "brunnel", "tunnel"], ["!in", "class", "rail", "ferry", "car_ferry", "transit", "cable_car", "chair_lift", "gondola", "drag_lift", "aerialway_transportation", "aerialway_closed", "aerialway_goods", "goods_conveyor", "path", "footway", "trail", "rail", "transit", "via_ferrata", "mask_terrain"], ["==", "$type", "LineString"]]}, {"id": "tunnel_pedestrian", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 6.0, "layout": {"line-cap": "butt", "line-join": "miter", "visibility": "visible"}, "paint": {"line-blur": 0.4, "line-color": "rgba(140, 140, 140, 1)", "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 15, 1.1, 20, 3], "line-offset": 0, "line-opacity": {"stops": [[14, 0], [15, 1]]}, "line-dasharray": {"stops": [[14, [1, 0.6]], [15, [1.5, 0.9]], [16, [2, 1.2]], [17, [3, 1.8]], [18, [6, 3.6]]]}}, "filter": ["all", ["==", "brunnel", "tunnel"], ["in", "class", "path", "footway", "trail"], ["==", "$type", "LineString"]]}, {"id": "construct_line", "type": "line", "source": "base_v1.0.0", "source-layer": "construct", "minzoom": 14.0, "layout": {"visibility": "visible"}, "paint": {"line-blur": 0.4, "line-color": "hsl(220, 10%, 67%)", "line-width": {"stops": [[15, 1], [18, 4]]}, "line-opacity": {"stops": [[14, 0], [15, 1]]}}, "filter": ["all", ["==", "class", "lock"]]}, {"id": "construct", "type": "fill", "source": "base_v1.0.0", "source-layer": "construct", "minzoom": 13.0, "layout": {"visibility": "visible"}, "paint": {"fill-color": ["interpolate", ["exponential", 1], ["zoom"], 13, ["match", ["get", "class"], "weir", "hsl(220, 10%, 82%)", "hsl(220, 10%, 86%)"], 17, ["match", ["get", "class"], "weir", "hsl(220, 10%, 75%)", "dam", "hsl(220, 10%, 82%)", "hsl(220, 10%, 86%)"]], "fill-opacity": ["interpolate", ["exponential", 1], ["zoom"], 12, 0, 13, ["match", ["get", "class"], "dam", 1, 0], 14, ["match", ["get", "class"], "dam", 1, 0], 15, 1]}, "filter": ["all", ["!=", "class", "lock"]]}, {"id": "aeroway_polygon_casing", "type": "line", "source": "base_v1.0.0", "source-layer": "aeroway", "minzoom": 11.0, "layout": {"line-cap": "round", "line-join": "round", "visibility": "visible"}, "paint": {"line-blur": 0.4, "line-color": "rgb(190, 190, 190)", "line-width": {"base": 1.5, "stops": [[13, 3], [15, 4], [17, 5]]}, "line-opacity": 1}, "filter": ["all", ["in", "class", "runway", "taxiway", "apron", "runway_grass"], ["==", "$type", "Polygon"]]}, {"id": "road_via_ferrata_trail", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 14.0, "layout": {"line-cap": "butt", "line-join": "bevel", "visibility": "visible"}, "paint": {"line-blur": {"stops": [[15, 0.1], [20, 0.4]]}, "line-color": {"stops": [[15, "rgba(20, 20, 20, 1)"], [18, "rgba(90, 90, 90, 1)"]]}, "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 15, 1.1, 20, 3], "line-opacity": {"stops": [[14, 0], [15, 1]]}, "line-dasharray": {"stops": [[15, [0.75, 2]], [16, [1.125, 3]], [17, [1.5, 4]], [18, [1.875, 5]]]}}, "metadata": {"maputnik:comment": "cannot be in the same layer as road_casings because dasharray doesn't support expressions"}, "filter": ["all", ["in", "class", "via_ferrata", "trail"], ["!in", "brunnel", "bridge", "tunnel"], ["==", "$type", "LineString"]]}, {"id": "building_ln", "type": "line", "source": "base_v1.0.0", "source-layer": "building_ln", "minzoom": 13.0, "layout": {"visibility": "visible"}, "paint": {"line-blur": 0.4, "line-color": ["match", ["get", "class"], "weir", "rgb(20, 136, 205)", "rgb(130, 130, 130)"], "line-width": {"stops": [[13, 0], [16, 2], [18, 3]]}, "line-opacity": ["match", ["get", "class"], "weir", 0.2, 1]}, "filter": ["all", ["match", ["get", "class"], ["horse_racing", "ski_jump", "toboggan", "track", "weir"], true, false], ["==", ["geometry-type"], "LineString"]]}, {"id": "road_path_footway_ferry", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 11.0, "layout": {"line-cap": "butt", "line-join": "bevel", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 15, 0.1, 20, 0.4], "line-color": ["match", ["get", "class"], ["ferry", "car_ferry"], "rgba(105, 187, 218, 1)", "rgba(115, 115, 115, 1)"], "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 13, 0.5, 15, 1.1, 20, 3], "line-opacity": ["interpolate", ["linear"], ["zoom"], 11, ["match", ["get", "is_route"], 11, 0.5, 0], 12, ["match", ["get", "is_route"], 11, ["match", ["get", "class"], ["path", "track", "footway"], 0.5, 0], 0], 14, 1], "line-dasharray": ["step", ["zoom"], ["literal", [6, 2]], 16, ["literal", [9, 3]], 17, ["literal", [12, 4]], 18, ["literal", [15, 5]]]}, "metadata": {"maputnik:comment": "cannot be in the same layer as road_casings because dasharray doesn't support expressions"}, "filter": ["all", ["match", ["get", "class"], ["footway", "footway_construction", "path", "path_construction", "ferry", "car_ferry"], true, false], ["match", ["get", "brunnel"], ["bridge", "tunnel"], ["match", ["get", "subclass"], "covered_bridge", true, false], true]]}, {"id": "road_casing", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 7.0, "layout": {"line-cap": "round", "line-join": "round", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 7, 3, 8, 0.4, 11, ["match", ["get", "is_route"], [11], 4, 0.4], 13, ["match", ["get", "class"], "track", 2, 0.4], 14, 0.4], "line-color": ["interpolate", ["exponential", 1.7], ["zoom"], 9, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(170, 136, 30)", "rgb(80, 80, 80)"], 15, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(139, 107, 63)", "rgb(90, 90, 90)"]], "line-width": ["interpolate", ["exponential", 2], ["zoom"], 7, 0, 8, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.5, 3], ["trunk"], 3, 3], 0], 9, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2, 3.5], ["trunk"], 3.5, 3], 0], 10, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2, 4], ["trunk"], 4, "primary", 3.5, "secondary", 3.5, "tertiary", 3, ["minor", "service"], 2.5, 0], ["match", ["get", "ramp"], 1, 2, 0]], 11, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2.5, 4.5], ["trunk"], 4.5, "primary", 4, "secondary", 4, "tertiary", 3.5, ["minor", "service"], 2.75, ["track", "path", "footway"], 0.5, 0], ["match", ["get", "ramp"], 1, 2.5, 0]], 12, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 2.75, 5], "primary", 5, "secondary", 4.5, "tertiary", 4, ["minor", "service"], 3, ["track", "path", "footway"], 0.75, 0], [11], ["match", ["get", "class"], ["motorway", "trunk", "primary", "secondary", "tertiary", "minor"], ["match", ["get", "ramp"], 1, 2.75, 0.75], ["track", "path", "footway"], 0.5, 0], ["match", ["get", "ramp"], 1, 2.75, 0]], 13, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 3, 6], ["trunk"], 6, "primary", 5.5, "secondary", 5, "tertiary", 4.5, ["minor", "service"], 3.5, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3, 1], 3], 11, ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 3, 6], "primary", 4, "secondary", 3.75, "tertiary", 3.75, ["minor", "service"], 3, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3, 0.5], 3], 0], 14, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 4, 7], ["trunk"], 7, "primary", 6.5, "secondary", 6, "tertiary", 5, ["minor", "service"], 4, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3.5, 0.75], 3.5], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 4, 7], "primary", 4.5, "secondary", 4, "tertiary", 4, ["minor", "service"], 3.5, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3.5, 0.75], 3.5]], 15, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 6.5, 8], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 8, 12], ["primary", "primary_construction"], 8, ["secondary", "secondary_construction"], 7, ["tertiary", "tertiary_construction"], 6, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 4, 1.1], 4.5], 16, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 10, 12], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 12, 15], ["primary", "primary_construction"], 12, ["secondary", "secondary_construction"], 11, ["tertiary", "tertiary_construction"], 10, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 9, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 8.5, 1.1], 8], 20, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 115, 130], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 130, 140], ["primary", "primary_construction"], 120, ["secondary", "secondary_construction"], 115, ["tertiary", "tertiary_construction"], 110, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 100, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 84, 5], 100]], "line-offset": 0, "line-opacity": 1}, "metadata": {"maputnik:comment": "casing color for motorway is brown"}, "filter": ["all", ["match", ["get", "class"], ["cable_car", "car_ferry", "chair_lift", "ferry", "gondola", "drag_lift", "aerialway_transportation", "aerialway_closed", "aerialway_goods", "goods_conveyor", "path", "footway", "trail", "rail", "transit", "via_ferrata", "mask_terrain"], false, true], ["match", ["get", "brunnel"], ["bridge", "tunnel"], ["match", ["get", "subclass"], "covered_bridge", true, false], true], ["==", ["geometry-type"], "LineString"]]}, {"id": "landuse_parking", "type": "fill", "source": "base_v1.0.0", "source-layer": "landuse", "layout": {"visibility": "visible"}, "paint": {"fill-color": "rgba(255, 255, 255, 1)", "fill-opacity": {"stops": [[14, 0], [15, 1]]}}, "filter": ["all", ["in", "class", "parking"]]}, {"id": "landuse_parking_outline", "type": "line", "source": "base_v1.0.0", "source-layer": "landuse", "layout": {"visibility": "visible"}, "paint": {"line-color": "rgba(130, 130, 130, 1)", "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 11, 0.25, 16, 0.75], "line-opacity": {"stops": [[14, 0], [15, 1]]}}, "filter": ["all", ["in", "class", "parking"]]}, {"id": "road_fill", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 7.0, "layout": {"line-cap": "round", "line-join": "round", "visibility": "visible"}, "paint": {"line-blur": {"stops": [[8, 0.4], [14, 0.1]]}, "line-color": ["interpolate", ["exponential", 1], ["zoom"], 9, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(255,230,160)", "rgb(255,255,255)"], 15, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(255, 224, 138)", "rgb(255,255,255)"]], "line-width": ["interpolate", ["exponential", 2], ["zoom"], 7, 0, 8, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.5, 2], ["trunk"], 2, 2], ["match", ["get", "ramp"], 1, 0.5, 0]], 9, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.75, 2.25], ["trunk"], 2.25, 2], ["match", ["get", "ramp"], 1, 0.75, 0]], 10, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.75, 2.75], ["trunk"], 2.75, "primary", 2.5, "secondary", 2.5, "tertiary", 2, ["minor", "service"], 1.5, 0], ["match", ["get", "ramp"], 1, 0.75, 0]], 11, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.25, 3.25], ["trunk"], 3.25, "primary", 3, "secondary", 3, "tertiary", 2.5, ["minor", "service"], 1.75, 0], ["match", ["get", "ramp"], 1, 1.25, 0]], 12, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.5, 3.75], ["trunk"], 3.75, "primary", 4, "secondary", 3.5, "tertiary", 3, ["minor", "service"], 2, 0], ["match", ["get", "ramp"], 1, 1.5, 0]], 13, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.75, 4.5], ["trunk"], 4.5, "primary", 4.5, "secondary", 4, "tertiary", 3.5, ["minor", "service"], 2.5, 2], 11, ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 1.75, 4.5], "primary", 3, "secondary", 2.75, "tertiary", 2.75, ["minor", "service"], 2, 2], ["match", ["get", "ramp"], 1, 1.75, 0]], 14, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2.75, 5.5], ["trunk"], 5.5, "primary", 5.5, "secondary", 5, "tertiary", 4, ["minor", "service"], 3, 2.5], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 2.75, 5.5], "primary", 3.5, "secondary", 3, "tertiary", 3, ["minor", "service"], 2.5, 2.5]], 15, ["match", ["get", "subclass"], "funicular", 3, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 5, 6.5], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 6.5, 10.5], ["primary", "primary_construction"], 6.5, ["secondary", "secondary_construction"], 5.5, ["tertiary", "tertiary_construction"], 4.5, ["minor", "minor_construction", "service", "service_construction"], 3.5, ["rail", "rail_construction"], 5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 1.25, 3]], 16, ["match", ["get", "subclass"], "funicular", 6, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 8, 10], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 10, 13], ["primary", "primary_construction"], 10, ["secondary", "secondary_construction"], 9, ["tertiary", "tertiary_construction"], 8, ["minor", "minor_construction", "service", "service_construction"], 7, ["rail", "rail_construction"], 9.5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 6.5, 6]], 20, ["match", ["get", "subclass"], "funicular", 20, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 112, 126], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 126, 136], ["primary", "primary_construction"], 117, ["secondary", "secondary_construction"], 112, ["tertiary", "tertiary_construction"], 107, ["minor", "minor_construction", "service", "service_construction"], 97, ["rail", "rail_construction"], 120, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 81, 92]]]}, "filter": ["all", ["match", ["get", "class"], ["cable_car", "car_ferry", "chair_lift", "ferry", "gondola", "drag_lift", "aerialway_transportation", "aerialway_closed", "aerialway_goods", "goods_conveyor", "path", "footway", "trail", "rail", "track", "transit", "via_ferrata", "mask_terrain"], false, true], ["match", ["get", "brunnel"], ["bridge", "tunnel"], ["match", ["get", "subclass"], "covered_bridge", true, false], true], ["==", ["geometry-type"], "LineString"]]}, {"id": "aeroway_polygon_fill", "type": "fill", "source": "base_v1.0.0", "source-layer": "aeroway", "minzoom": 11.0, "layout": {"visibility": "visible"}, "paint": {"fill-color": ["match", ["get", "class"], ["runway_grass"], "rgb(224,234,221)", "rgb(255, 255, 255)"], "fill-opacity": 1, "fill-antialias": true}, "filter": ["all", ["in", "class", "runway", "taxiway", "apron", "runway_grass"], ["==", "$type", "Polygon"]]}, {"id": "public_transport", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 8.0, "layout": {"visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 8, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 2.5, 0.6], 0.6], 0.6], 14, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 2.5, 0.6], 0.6], 0.6], 18, 0.4], "line-color": {"stops": [[7, "rgba(255, 50, 50, 1)"], [15, "rgba(255, 80, 80, 1)"]]}, "line-width": ["interpolate", ["linear"], ["zoom"], 9, ["match", ["get", "is_route"], 99, ["match", ["get", "subclass"], "rail", 0.75, 0], 0], 10, ["match", ["get", "is_route"], 99, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 0, 0.75], 0.5], 0.5], ["match", ["get", "subclass"], ["cable_car", "funicular"], 0.75, 0]], 14, ["match", ["get", "is_route"], 99, ["match", ["get", "class"], "transit", 1, ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], 2, 1], 0], ["match", ["get", "subclass"], ["cable_car", "funicular"], 1, 0]], 18, ["match", ["get", "class"], ["transit"], 1.5, ["match", ["get", "service"], ["yard", "siding"], 1.5, 2]]], "line-opacity": ["interpolate", ["linear"], ["zoom"], 8, 0, 9, ["match", ["get", "class"], ["rail"], 1, 0], 13, ["match", ["get", "class"], ["rail"], 1, 0], 14, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail", "funicular"], ["match", ["get", "service"], ["yard", "siding"], 0, 1], 0], 0], 14.5, 1]}, "filter": ["all", ["in", "class", "rail", "transit"], ["!in", "brunnel", "bridge", "tunnel"]]}, {"id": "building", "type": "fill", "source": "base_v1.0.0", "source-layer": "building", "minzoom": 13.0, "layout": {"visibility": "visible"}, "paint": {"fill-color": {"stops": [[13, "hsl(220, 10%, 82%)"], [17, "hsl(220, 10%, 75%)"]]}, "fill-opacity": {"stops": [[13, 0], [13.5, 1]]}}}, {"id": "building_casing", "type": "line", "source": "base_v1.0.0", "source-layer": "building", "minzoom": 15.0, "layout": {"visibility": "visible"}, "paint": {"line-color": "hsl(220, 10%, 67%)", "line-width": ["interpolate", ["linear"], ["zoom"], 15, 0.2, 18, 1.2], "line-opacity": ["interpolate", ["linear"], ["zoom"], 15, 0, 16, 0.5, 19, 1]}}, {"id": "l1_road_casing", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 7.0, "layout": {"line-cap": "butt", "line-join": "round", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 7, 3, 8, 0.4, 11, ["match", ["get", "is_route"], [11], 4, 0.4], 13, ["match", ["get", "class"], "track", 2, 0.4], 14, 0.4], "line-color": ["interpolate", ["exponential", 1.7], ["zoom"], 9, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(170, 136, 30)", "rgb(80, 80, 80)"], 15, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(139, 107, 63)", "rgb(90, 90, 90)"]], "line-width": ["interpolate", ["exponential", 2], ["zoom"], 7, 0, 8, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.5, 3], ["trunk"], 3, 3], 0], 9, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2, 3.5], ["trunk"], 3.5, 3], 0], 10, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2, 4], ["trunk"], 4, "primary", 3.5, "secondary", 3.5, "tertiary", 3, ["minor", "service"], 2.5, 0], ["match", ["get", "ramp"], 1, 2, 0]], 11, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2.5, 4.5], ["trunk"], 4.5, "primary", 4, "secondary", 4, "tertiary", 3.5, ["minor", "service"], 2.75, ["track", "path", "footway"], 0.5, 0], ["match", ["get", "ramp"], 1, 2.5, 0]], 12, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 2.75, 5], "primary", 5, "secondary", 4.5, "tertiary", 4, ["minor", "service"], 3, ["track", "path", "footway"], 0.75, 0], [11], ["match", ["get", "class"], ["motorway", "trunk", "primary", "secondary", "tertiary", "minor"], ["match", ["get", "ramp"], 1, 2.75, 0.75], ["track", "path", "footway"], 0.5, 0], ["match", ["get", "ramp"], 1, 2.75, 0]], 13, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 3, 6], ["trunk"], 6, "primary", 5.5, "secondary", 5, "tertiary", 4.5, ["minor", "service"], 3.5, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3, 1], 3], 11, ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 3, 6], "primary", 4, "secondary", 3.75, "tertiary", 3.75, ["minor", "service"], 3, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3, 0.5], 3], 0], 14, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 4, 7], ["trunk"], 7, "primary", 6.5, "secondary", 6, "tertiary", 5, ["minor", "service"], 4, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3.5, 0.75], 3.5], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 4, 7], "primary", 4.5, "secondary", 4, "tertiary", 4, ["minor", "service"], 3.5, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3.5, 0.75], 3.5]], 15, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 6.5, 8], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 8, 12], ["primary", "primary_construction"], 8, ["secondary", "secondary_construction"], 7, ["tertiary", "tertiary_construction"], 6, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 4, 1.1], 4.5], 16, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 10, 12], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 12, 15], ["primary", "primary_construction"], 12, ["secondary", "secondary_construction"], 11, ["tertiary", "tertiary_construction"], 10, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 9, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 8.5, 1.1], 8], 20, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 115, 130], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 130, 140], ["primary", "primary_construction"], 120, ["secondary", "secondary_construction"], 115, ["tertiary", "tertiary_construction"], 110, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 100, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 84, 5], 100]], "line-offset": 0, "line-opacity": 1}, "metadata": {"maputnik:comment": "casing color for motorway is brown"}, "filter": ["all", ["has", "layer"], ["==", "layer", 1], ["!in", "class", "rail", "ferry", "path", "track", "footway", "transit", "cable_car", "gondola", "drag_lift", "aerialway_transportation", "aerialway_closed", "aerialway_goods", "goods_conveyor", "mask_terrain", "via_ferrata"], ["==", "$type", "LineString"], ["!=", "subclass", "covered_bridge"]]}, {"id": "l1_fill", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 7.0, "layout": {"line-cap": "butt", "line-join": "round", "visibility": "visible"}, "paint": {"line-blur": {"stops": [[8, 0.4], [14, 0.1]]}, "line-color": ["interpolate", ["exponential", 1], ["zoom"], 9, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(255,230,160)", ["rail", "path", "track", "footway"], ["match", ["get", "subclass"], "funicular", "rgba(243,243,246,0)", "rgb(243,243,246)"], "rgb(255,255,255)", "rgb(243,243,246)", "rgb(255,255,255)"], 15, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(255, 224, 138)", ["rail", "path", "track", "footway"], ["match", ["get", "subclass"], "funicular", "rgba(243,243,246,0)", "rgb(243,243,246)"], "rgb(255,255,255)"]], "line-width": ["interpolate", ["exponential", 2], ["zoom"], 7, 0, 8, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.5, 2], ["trunk"], 2, 2], ["match", ["get", "ramp"], 1, 0.5, 0]], 9, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.75, 2.25], ["trunk"], 2.25, 2], ["match", ["get", "ramp"], 1, 0.75, 0]], 10, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.75, 2.75], ["trunk"], 2.75, "primary", 2.5, "secondary", 2.5, "tertiary", 2, ["minor", "service"], 1.5, 0], ["match", ["get", "ramp"], 1, 0.75, 0]], 11, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.25, 3.25], ["trunk"], 3.25, "primary", 3, "secondary", 3, "tertiary", 2.5, ["minor", "service"], 1.75, 0], ["match", ["get", "ramp"], 1, 1.25, 0]], 12, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.5, 3.75], ["trunk"], 3.75, "primary", 4, "secondary", 3.5, "tertiary", 3, ["minor", "service"], 2, 0], ["match", ["get", "ramp"], 1, 1.5, 0]], 13, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.75, 4.5], ["trunk"], 4.5, "primary", 4.5, "secondary", 4, "tertiary", 3.5, ["minor", "service"], 2.5, 2], 11, ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 1.75, 4.5], "primary", 3, "secondary", 2.75, "tertiary", 2.75, ["minor", "service"], 2, 2], ["match", ["get", "ramp"], 1, 1.75, 0]], 14, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2.75, 5.5], ["trunk"], 5.5, "primary", 5.5, "secondary", 5, "tertiary", 4, ["minor", "service"], 3, 1.5], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 2.75, 5.5], "primary", 3.5, "secondary", 3, "tertiary", 3, ["minor", "service"], 2.5, 2.5]], 15, ["match", ["get", "subclass"], "funicular", 3, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 5, 6.5], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 6.5, 10.5], ["primary", "primary_construction"], 6.5, ["secondary", "secondary_construction"], 5.5, ["tertiary", "tertiary_construction"], 4.5, ["minor", "minor_construction", "service", "service_construction"], 3.5, ["rail", "rail_construction"], 5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 1.25, 3]], 16, ["match", ["get", "subclass"], "funicular", 6, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 8, 10], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 10, 13], ["primary", "primary_construction"], 10, ["secondary", "secondary_construction"], 9, ["tertiary", "tertiary_construction"], 8, ["minor", "minor_construction", "service", "service_construction"], 7, ["rail", "rail_construction"], 9.5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 6.5, 6]], 20, ["match", ["get", "subclass"], "funicular", 20, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 112, 126], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 126, 136], ["primary", "primary_construction"], 117, ["secondary", "secondary_construction"], 112, ["tertiary", "tertiary_construction"], 107, ["minor", "minor_construction", "service", "service_construction"], 97, ["rail", "rail_construction"], 120, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 81, 92]]], "line-opacity": 1}, "filter": ["all", ["has", "layer"], ["==", "layer", 1], ["!in", "class", "ferry", "cable_car", "gondola", "drag_lift", "aerialway_transportation", "aerialway_closed", "aerialway_goods", "goods_conveyor", "mask_terrain", "via_ferrata"], ["==", "$type", "LineString"], ["!=", "subclass", "covered_bridge"]]}, {"id": "l1_2_pedestrian", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 11.0, "layout": {"line-cap": "butt", "line-join": "round", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 13, 2, 14, 0.4], "line-color": "rgb(90, 90, 90)", "line-width": ["interpolate", ["exponential", 1.5], ["zoom"], 11, 0, 13, 0.5, 15, 1.1, 20, 3], "line-opacity": ["match", ["get", "class"], ["track", "footway", "path"], 1, 0.5]}, "metadata": {"maputnik:comment": "casing color for motorway is brown"}, "filter": ["all", ["has", "layer"], [">", "layer", 0], ["in", "class", "track", "track_construction", "footway", "footway_construction", "path", "path_construction"], ["!=", "subclass", "covered_bridge"], ["==", "$type", "LineString"]]}, {"id": "l1_public_transport", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 10.0, "layout": {"line-cap": "round", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 8, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail"], ["match", ["get", "service"], ["yard", "siding"], 2.5, 0.6], 0.6], 0.6], 14, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail"], ["match", ["get", "service"], ["yard", "siding"], 2.5, 0.6], 0.6], 0.6], 18, 0.4], "line-color": {"stops": [[7, "rgba(255, 50, 50, 1)"], [15, "rgba(255, 80, 80, 1)"]]}, "line-width": ["interpolate", ["linear"], ["zoom"], 9, ["match", ["get", "is_route"], 99, ["match", ["get", "subclass"], "rail", 0.75, 0], 0], 10, ["match", ["get", "is_route"], 99, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 0, 0.75], 0.5], 0.5], ["match", ["get", "subclass"], ["cable_car", "funicular"], 0.75, 0]], 14, ["match", ["get", "is_route"], 99, ["match", ["get", "class"], "transit", 1, ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 0, 2], 1], 0], ["match", ["get", "subclass"], ["cable_car", "funicular"], 1, 0]], 18, ["match", ["get", "class"], ["transit"], 1.5, ["match", ["get", "service"], ["yard", "siding"], 1.5, 2]]], "line-opacity": ["interpolate", ["linear"], ["zoom"], 8, 0, 9, ["match", ["get", "class"], ["rail"], 1, 0], 12, ["match", ["get", "class"], ["rail"], 1, 0], 13, ["match", ["get", "class"], ["rail"], 1, 0], 14, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail", "funicular"], ["match", ["get", "service"], ["yard", "siding"], 0, 1], 0], 0], 14.5, 1]}, "filter": ["all", ["has", "layer"], ["==", "layer", 1], ["in", "class", "rail", "transit"], ["==", "$type", "LineString"], ["!=", "subclass", "covered_bridge"]]}, {"id": "l2_road_casing", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 7.0, "layout": {"line-cap": "butt", "line-join": "round", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 7, 3, 8, 0.4, 11, ["match", ["get", "is_route"], [11], 4, 0.4], 13, ["match", ["get", "class"], "track", 2, 0.4], 14, 0.4], "line-color": ["interpolate", ["exponential", 1.7], ["zoom"], 9, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(170, 136, 30)", "rgb(80, 80, 80)"], 15, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(139, 107, 63)", "rgb(90, 90, 90)"]], "line-width": ["interpolate", ["exponential", 2], ["zoom"], 7, 0, 8, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.5, 3], ["trunk"], 3, 3], 0], 9, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2, 3.5], ["trunk"], 3.5, 3], 0], 10, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2, 4], ["trunk"], 4, "primary", 3.5, "secondary", 3.5, "tertiary", 3, ["minor", "service"], 2.5, 0], ["match", ["get", "ramp"], 1, 2, 0]], 11, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2.5, 4.5], ["trunk"], 4.5, "primary", 4, "secondary", 4, "tertiary", 3.5, ["minor", "service"], 2.75, ["track", "path", "footway"], 0.5, 0], ["match", ["get", "ramp"], 1, 2.5, 0]], 12, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 2.75, 5], "primary", 5, "secondary", 4.5, "tertiary", 4, ["minor", "service"], 3, ["track", "path", "footway"], 0.75, 0], [11], ["match", ["get", "class"], ["motorway", "trunk", "primary", "secondary", "tertiary", "minor"], ["match", ["get", "ramp"], 1, 2.75, 0.75], ["track", "path", "footway"], 0.5, 0], ["match", ["get", "ramp"], 1, 2.75, 0]], 13, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 3, 6], ["trunk"], 6, "primary", 5.5, "secondary", 5, "tertiary", 4.5, ["minor", "service"], 3.5, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3, 1], 3], 11, ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 3, 6], "primary", 4, "secondary", 3.75, "tertiary", 3.75, ["minor", "service"], 3, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3, 0.5], 3], 0], 14, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 4, 7], ["trunk"], 7, "primary", 6.5, "secondary", 6, "tertiary", 5, ["minor", "service"], 4, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3.5, 0.75], 3.5], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 4, 7], "primary", 4.5, "secondary", 4, "tertiary", 4, ["minor", "service"], 3.5, ["track", "path", "footway"], ["match", ["get", "subclass"], "covered_bridge", 3.5, 0.75], 3.5]], 15, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 6.5, 8], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 8, 12], ["primary", "primary_construction"], 8, ["secondary", "secondary_construction"], 7, ["tertiary", "tertiary_construction"], 6, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 4, 1.1], 4.5], 16, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 10, 12], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 12, 15], ["primary", "primary_construction"], 12, ["secondary", "secondary_construction"], 11, ["tertiary", "tertiary_construction"], 10, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 9, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 8.5, 1.1], 8], 20, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 115, 130], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 130, 140], ["primary", "primary_construction"], 120, ["secondary", "secondary_construction"], 115, ["tertiary", "tertiary_construction"], 110, ["minor", "minor_construction", "service", "service_construction", "rail", "rail_construction"], 100, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], ["match", ["get", "subclass"], "covered_bridge", 84, 5], 100]], "line-offset": 0, "line-opacity": 1}, "metadata": {"maputnik:comment": "casing color for motorway is brown"}, "filter": ["all", ["has", "layer"], [">", "layer", 1], ["!in", "class", "rail", "ferry", "path", "track", "footway", "transit", "cable_car", "gondola", "drag_lift", "aerialway_transportation", "aerialway_closed", "aerialway_goods", "goods_conveyor", "mask_terrain", "via_ferrata"], ["==", "$type", "LineString"], ["!=", "subclass", "covered_bridge"]]}, {"id": "l2_fill", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 7.0, "layout": {"line-cap": "butt", "line-join": "round", "visibility": "visible"}, "paint": {"line-blur": {"stops": [[8, 0.4], [14, 0.1]]}, "line-color": ["interpolate", ["exponential", 1], ["zoom"], 9, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(255,230,160)", ["rail", "path", "track", "footway"], ["match", ["get", "subclass"], "funicular", "rgba(243,243,246,0)", "rgb(243,243,246)"], "rgb(255,255,255)", "rgb(243,243,246)", "rgb(255,255,255)"], 15, ["match", ["get", "class"], ["motorway", "trunk"], "rgb(255, 224, 138)", ["rail", "path", "track", "footway"], ["match", ["get", "subclass"], "funicular", "rgba(243,243,246,0)", "rgb(243,243,246)"], "rgb(255,255,255)"]], "line-width": ["interpolate", ["exponential", 2], ["zoom"], 7, 0, 8, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.5, 2], ["trunk"], 2, 2], ["match", ["get", "ramp"], 1, 0.5, 0]], 9, ["match", ["get", "is_route"], [5, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.75, 2.25], ["trunk"], 2.25, 2], ["match", ["get", "ramp"], 1, 0.75, 0]], 10, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 0.75, 2.75], ["trunk"], 2.75, "primary", 2.5, "secondary", 2.5, "tertiary", 2, ["minor", "service"], 1.5, 0], ["match", ["get", "ramp"], 1, 0.75, 0]], 11, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.25, 3.25], ["trunk"], 3.25, "primary", 3, "secondary", 3, "tertiary", 2.5, ["minor", "service"], 1.75, 0], ["match", ["get", "ramp"], 1, 1.25, 0]], 12, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.5, 3.75], ["trunk"], 3.75, "primary", 4, "secondary", 3.5, "tertiary", 3, ["minor", "service"], 2, 0], ["match", ["get", "ramp"], 1, 1.5, 0]], 13, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 1.75, 4.5], ["trunk"], 4.5, "primary", 4.5, "secondary", 4, "tertiary", 3.5, ["minor", "service"], 2.5, 2], 11, ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 1.75, 4.5], "primary", 3, "secondary", 2.75, "tertiary", 2.75, ["minor", "service"], 2, 2], ["match", ["get", "ramp"], 1, 1.75, 0]], 14, ["match", ["get", "is_route"], [5, 6, 7, 8, 10, 99], ["match", ["get", "class"], ["motorway"], ["match", ["get", "ramp"], 1, 2.75, 5.5], ["trunk"], 5.5, "primary", 5.5, "secondary", 5, "tertiary", 4, ["minor", "service"], 3, 2.5], ["match", ["get", "class"], ["motorway", "trunk"], ["match", ["get", "ramp"], 1, 2.75, 5.5], "primary", 3.5, "secondary", 3, "tertiary", 3, ["minor", "service"], 2.5, 2.5]], 15, ["match", ["get", "subclass"], "funicular", 3, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 5, 6.5], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 6.5, 10.5], ["primary", "primary_construction"], 6.5, ["secondary", "secondary_construction"], 5.5, ["tertiary", "tertiary_construction"], 4.5, ["minor", "minor_construction", "service", "service_construction"], 3.5, ["rail", "rail_construction"], 5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 1.25, 3]], 16, ["match", ["get", "subclass"], "funicular", 6, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 8, 10], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 10, 13], ["primary", "primary_construction"], 10, ["secondary", "secondary_construction"], 9, ["tertiary", "tertiary_construction"], 8, ["minor", "minor_construction", "service", "service_construction"], 7, ["rail", "rail_construction"], 9.5, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 6.5, 6]], 20, ["match", ["get", "subclass"], "funicular", 20, ["match", ["get", "class"], ["motorway", "motorway_construction"], ["match", ["get", "ramp"], 1, 112, 126], ["trunk", "trunk_construction"], ["match", ["get", "oneway"], 1, 126, 136], ["primary", "primary_construction"], 117, ["secondary", "secondary_construction"], 112, ["tertiary", "tertiary_construction"], 107, ["minor", "minor_construction", "service", "service_construction"], 97, ["rail", "rail_construction"], 120, ["track", "track_construction", "path", "path_construction", "footway", "footway_construction", "transit", "transit_construction"], 81, 92]]], "line-opacity": 1}, "filter": ["all", ["has", "layer"], [">", "layer", 1], ["!in", "class", "ferry", "cable_car", "gondola", "drag_lift", "aerialway_transportation", "aerialway_closed", "aerialway_goods", "goods_conveyor", "mask_terrain", "via_ferrata"], ["==", "$type", "LineString"], ["!=", "subclass", "covered_bridge"]]}, {"id": "l2_public_transport_aerialway", "type": "line", "source": "base_v1.0.0", "source-layer": "transportation", "minzoom": 10.0, "layout": {"line-cap": "round", "visibility": "visible"}, "paint": {"line-blur": ["interpolate", ["linear"], ["zoom"], 8, ["match", ["get", "class"], ["cable_car", "chair_lift", "gondola"], 0.25, ["rail"], ["match", ["get", "subclass"], ["rail"], ["match", ["get", "service"], ["yard", "siding"], 2.5, 0.6], 0.6], 0.6], 14, ["match", ["get", "class"], ["cable_car", "chair_lift", "gondola"], 0.25, ["rail"], ["match", ["get", "subclass"], ["rail"], ["match", ["get", "service"], ["yard", "siding"], 2.5, 0.6], 0.6], 0.6], 18, ["match", ["get", "class"], ["cable_car", "chair_lift", "gondola"], 0.25, 0.4]], "line-color": {"stops": [[7, "rgba(255, 50, 50, 1)"], [15, "rgba(255, 80, 80, 1)"]]}, "line-width": ["interpolate", ["linear"], ["zoom"], 9, ["match", ["get", "class"], ["cable_car", "chair_lift", "gondola"], 0.3, ["match", ["get", "is_route"], 99, ["match", ["get", "subclass"], "rail", 0.75, 0], 0]], 10, ["match", ["get", "is_route"], 99, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 0, 0.75], 0.5], 0.5], ["match", ["get", "class"], ["cable_car", "chair_lift", "gondola"], 0.4, ["match", ["get", "subclass"], ["cable_car", "funicular"], 0.75, 0]]], 14, ["match", ["get", "is_route"], 99, ["match", ["get", "class"], "transit", 1, ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail"], ["match", ["get", "service"], ["yard", "siding"], 0, 2], 1], 0], ["match", ["get", "class"], "cable_car", 1, ["chair_lift", "gondola"], 0.4, ["match", ["get", "subclass"], ["cable_car", "funicular"], 1, 0]]], 18, ["match", ["get", "class"], ["chair_lift", "gondola", "transit"], 1.5, ["match", ["get", "service"], ["yard", "siding"], 1.5, 2]]], "line-opacity": ["interpolate", ["linear"], ["zoom"], 8, 0, 9, ["match", ["get", "class"], ["rail"], 1, 0], 12, ["match", ["get", "class"], ["rail"], 1, 0], 13, ["match", ["get", "class"], ["cable_car", "gondola", "rail"], 1, 0], 14, ["match", ["get", "class"], ["rail"], ["match", ["get", "subclass"], ["rail", "narrow_gauge", "rack_rail", "funicular"], ["match", ["get", "service"], ["yard", "siding"], 0, 1], 0], ["cable_car", "gondola", "chair_lift"], 1, 0], 14.5, 1]}, "filter": ["all", ["match", ["get", "class"], ["cable_car", "chair_lift", "gondola"], true, ["rail", "rail_construction", "transit", "transit_construction"], ["case", ["has", "layer"], [">", ["get", "layer"], 1], false], false], ["==", ["geometry-type"], "LineString"]]}, {"id": "contour_line_pt", "type": "symbol", "source": "base_v1.0.0", "source-layer": "contour_line_pt", "minzoom": 14.0, "layout": {"icon-size": ["interpolate", ["linear"], ["zoom"], 14, 0.7, 16, ["match", ["%", ["to-number", ["get", "lake_depth"]], 100], 0, 0.9, 0.7]], "text-font": ["Frutiger Neue Italic"], "text-size": ["interpolate", ["exponential", 2], ["zoom"], 14, 10.5, 16, ["case", ["has", "lake_depth"], ["match", ["%", ["to-number", ["get", "lake_depth"]], 100], 0, 14, 12], ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 14, 12]]], "icon-image": ["case", ["has", "lake_depth"], "arrow_blue", ""], "text-field": ["case", ["has", "lake_depth"], ["get", "lake_depth"], ["get", "ele"]], "visibility": "visible", "icon-anchor": "center", "icon-offset": ["case", ["has", "lake_depth"], ["match", ["length", ["to-string", ["get", "lake_depth"]]], 1, ["literal", [-12, 0]], 2, ["literal", [-16, 0]], 3, ["literal", [-20, 0]], 4, ["literal", [-24, 0]], ["literal", [0, 0]]], ["literal", [0, 0]]], "icon-rotate": ["get", "direction"], "text-anchor": "center", "text-rotate": ["get", "direction"], "text-max-angle": 35, "symbol-avoid-edges": true, "text-letter-spacing": 0.1, "icon-pitch-alignment": "map", "icon-rotation-alignment": "map", "text-rotation-alignment": "map", "text-padding": ["interpolate", ["linear"], ["zoom"], 14, 20, 15, 12, 16, 80]}, "paint": {"text-color": ["match", ["get", "class"], "scree", "rgb(110, 110, 110)", "land", "rgb(179, 136, 77)", "water", "rgb(47, 134, 188)", "ice", "rgb(80, 123, 149)", "rgb(110, 110, 110)"], "icon-opacity": ["step", ["zoom"], ["match", ["%", ["to-number", ["get", "lake_depth"]], 100], 0, 0.8, 0], 15, 0.8], "text-halo-blur": 0.25, "text-halo-color": ["match", ["get", "class"], ["ice", "water"], "rgb(215, 243, 255)", "rgba(238, 238, 238, 0.9)"], "text-halo-width": 1, "text-opacity": ["step", ["zoom"], ["case", ["has", "lake_depth"], ["match", ["%", ["to-number", ["get", "lake_depth"]], 100], 0, 1, 0], ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 1, 0]], 15, ["match", ["get", "class"], "water", 1, ["match", ["%", ["to-number", ["get", "ele"]], 100], 0, 1, 0]], 16, 1]}, "filter": ["any", ["has", "lake_depth"], ["==", ["%", ["to-number", ["get", "ele"]], 20], 0]]}, {"id": "spot_elevation", "type": "symbol", "source": "base_v1.0.0", "source-layer": "spot_elevation", "minzoom": 9.0, "layout": {"icon-optional": false, "text-optional": false, "icon-size": ["interpolate", ["linear"], ["zoom"], 13, ["match", ["get", "class"], "lake_spot_depth", 0.6, 1], 16, ["match", ["get", "class"], "lake_spot_depth", 0.6, 1]], "text-font": ["match", ["get", "class"], "lake_elevation", ["literal", ["Frutiger Neue Italic"]], ["literal", ["Frutiger Neue Regular"]]], "text-size": ["interpolate", ["linear"], ["zoom"], 13, 10, 14, 10.5, 16, 13], "icon-image": ["match", ["get", "class"], "sinkhole", "arrow_brown", ["sinkhole_ice", "sinkhole_water", "lake_spot_depth"], "arrow_blue", ["sinkhole_rock", "sinkhole_scree"], "arrow_grey", ["spot_elevation", "terrain_spot_elevation"], "dot_dark_grey_3", "lake_elevation", ["case", ["has", "lake_depth"], "arrow_line_blue", ["==", ["length", ["to-string", ["get", "ele"]]], 3], "line_blue_short", "line_blue_long"], ""], "text-field": ["match", ["get", "class"], ["spot_elevation", "terrain_spot_elevation"], ["get", "ele"], ["sinkhole", "sinkhole_rock", "sinkhole_scree", "sinkhole_water", "sinkhole_ice"], "", "lake_spot_depth", ["get", "lake_depth"], ["case", ["has", "lake_depth"], ["concat", ["get", "ele"], "\n\n", ["get", "lake_depth"]], ["get", "ele"]]], "visibility": "visible", "icon-anchor": ["match", ["get", "class"], ["sinkhole", "sinkhole_rock", "sinkhole_scree", "sinkhole_water", "sinkhole_ice"], "bottom", "center"], "icon-padding": 30, "text-anchor": ["match", ["get", "class"], "lake_spot_depth", "left", "lake_elevation", "center", "bottom-right"], "symbol-placement": "point", "text-keep-upright": false, "text-offset": ["match", ["get", "class"], "lake_spot_depth", ["literal", [0.35, 0]], "lake_elevation", ["case", ["has", "lake_depth"], ["literal", [0.35, -0.6]], ["literal", [0.1, -0.7]]], ["literal", [-0.35, 0]]], "text-justify": "center", "text-line-height": 0.9, "icon-rotate": ["match", ["get", "class"], ["sinkhole", "sinkhole_rock", "sinkhole_scree", "sinkhole_water", "sinkhole_ice"], 15, 0]}, "paint": {"text-color": ["match", ["get", "class"], ["lake_spot_depth", "lake_elevation"], "rgb(47, 134, 188)", "rgba(80, 80, 80, 1)"], "icon-opacity": ["step", ["zoom"], ["match", ["get", "class"], ["lake_elevation"], 0.8, 0], 14, ["match", ["get", "class"], ["spot_elevation", "terrain_spot_elevation", "lake_elevation"], 0.8, 0], 15, ["match", ["get", "class"], ["spot_elevation", "terrain_spot_elevation", "lake_elevation"], 0.8, ["sinkhole", "sinkhole_ice", "sinkhole_water", "sinkhole_rock", "sinkhole_scree"], 0.6, 1]], "text-opacity": ["step", ["zoom"], ["match", ["get", "class"], "lake_elevation", 0.8, 0], 14, ["match", ["get", "class"], ["spot_elevation", "terrain_spot_elevation"], 1, ["lake_elevation"], 0.8, 0], 15, ["match", ["get", "class"], "lake_elevation", 0.8, 1]], "text-halo-blur": 0.25, "text-halo-color": ["match", ["get", "class"], ["lake_spot_depth", "lake_elevation"], "rgb(199, 224, 245)", "rgba(242, 242, 242, 0.6)"], "text-halo-width": 0.5}, "filter": ["!=", "class", "doline"]}, {"id": "transportation_label", "type": "symbol", "source": "base_v1.0.0", "source-layer": "transportation_name", "minzoom": 13.0, "layout": {"text-font": ["Frutiger Neue Condensed Regular"], "text-size": ["interpolate", ["exponential", 1.5], ["zoom"], 14, ["match", ["get", "class"], ["motorway", "trunk"], 11, 10.5], 18, ["match", ["get", "class"], ["motorway", "trunk"], 18, 16]], "text-field": "{name:latin}", "visibility": "visible", "text-anchor": "center", "text-offset": [0, 0], "text-padding": 2, "symbol-spacing": ["interpolate", ["linear"], ["zoom"], 15, 200, 18, 400], "symbol-z-order": "auto", "text-max-angle": 40, "text-transform": "none", "symbol-placement": "line", "text-keep-upright": true, "symbol-avoid-edges": true, "text-letter-spacing": 0.1, "text-pitch-alignment": "map", "text-rotation-alignment": "map"}, "paint": {"text-color": ["match", ["get", "class"], ["rail", "transit", "cable_car", "gondola", "chair_lift"], "rgba(255, 50, 50, 1)", ["ferry", "car_ferry"], "rgb(47, 134, 188)", "rgba(60, 60, 70, 1)"], "text-halo-blur": 0.2, "text-halo-color": ["match", ["get", "class"], ["rail", "transit", "cable_car", "gondola", "chair_lift", "motorway", "trunk"], "rgba(255, 255, 255, 0.6)", "rgba(255, 255, 255, 0.8)"], "text-halo-width": ["interpolate", ["linear"], ["zoom"], 14, ["match", ["get", "class"], ["rail", "transit", "cable_car", "gondola", "chair_lift"], 1.5, 1.5], 20, 3]}, "filter": ["all", ["!in", "class", "cable_car", "gondola", "chair_lift", "drag_lift", "aerialway_transportation", "aerialway_closed", "aerialway_goods", "goods_conveyor"], ["==", "$type", "LineString"]]}, {"id": "road_number", "type": "symbol", "source": "base_v1.0.0", "source-layer": "transportation_name", "minzoom": 13.0, "layout": {"icon-size": 1, "text-font": ["Frutiger Neue Condensed Bold"], "text-size": 10.5, "icon-image": "box_white_grey_casing_{ref_length}", "text-field": ["get", "ref"], "visibility": "visible", "icon-offset": [0, -0.5], "text-anchor": "center", "icon-padding": 2, "text-justify": "center", "icon-optional": false, "icon-text-fit": "none", "text-optional": false, "symbol-spacing": ["step", ["zoom"], 300, 10, 600, 14, 800], "symbol-z-order": "auto", "symbol-placement": "line", "icon-keep-upright": false, "text-keep-upright": true, "icon-allow-overlap": false, "symbol-avoid-edges": false, "text-letter-spacing": 0, "icon-pitch-alignment": "viewport", "text-pitch-alignment": "viewport", "icon-ignore-placement": false, "icon-rotation-alignment": "viewport", "text-rotation-alignment": "viewport"}, "paint": {"text-color": "rgba(64, 64, 64, 1)", "icon-opacity": 1, "text-opacity": 1, "text-halo-blur": 0, "text-halo-color": "rgba(0, 0, 0, 0)", "text-halo-width": 0}, "filter": ["all", ["in", "class", "motorway", "trunk", "primary"], ["has", "ref"], ["<=", "ref_length", 12], [">", "ref_length", 0], ["==", "$type", "LineString"]]}, {"id": "area_name_glacier_point_label", "type": "symbol", "source": "base_v1.0.0", "source-layer": "area_name", "minzoom": 14.0, "layout": {"text-font": ["Frutiger Neue Italic"], "text-size": ["interpolate", ["linear"], ["zoom"], 10, 11, 16, 20], "text-field": "{name:latin}", "visibility": "visible", "symbol-spacing": {"stops": [[12, 250], [14, 550]]}, "symbol-z-order": "auto", "text-max-width": 99999, "symbol-placement": "point", "text-keep-upright": true, "symbol-avoid-edges": true, "text-allow-overlap": false, "text-letter-spacing": 0.15, "text-pitch-alignment": "map", "text-ignore-placement": false, "text-rotation-alignment": "map"}, "paint": {"text-color": "rgb(47, 134, 188)", "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": 1}, "filter": ["all", ["==", "$type", "Point"], ["in", "subclass", "glacier"]]}, {"id": "area_name_glacier_line_label", "type": "symbol", "source": "base_v1.0.0", "source-layer": "area_name", "minzoom": 12.0, "layout": {"text-font": ["Frutiger Neue Italic"], "text-size": ["interpolate", ["linear"], ["zoom"], 10, 11, 16, 20], "text-field": "{name:latin}", "visibility": "visible", "symbol-spacing": {"stops": [[12, 250], [14, 550]]}, "symbol-z-order": "auto", "text-max-width": 99999, "symbol-placement": "line-center", "text-keep-upright": true, "symbol-avoid-edges": true, "text-allow-overlap": false, "text-letter-spacing": {"stops": [[10, 0.15], [12, 0.3]]}, "text-pitch-alignment": "map", "text-ignore-placement": false, "text-rotation-alignment": "map"}, "paint": {"text-color": "rgb(47, 134, 188)", "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": 1}, "filter": ["all", ["==", "$type", "LineString"], ["in", "subclass", "glacier"]]}, {"id": "poi_rank2", "type": "symbol", "source": "base_v1.0.0", "source-layer": "poi", "minzoom": 14.0, "layout": {"icon-size": 1, "text-font": ["Frutiger Neue Condensed Regular"], "text-size": ["interpolate", ["linear"], ["zoom"], 14, 12, 18, 18], "icon-image": ["match", ["get", "subclass"], ["aerialway_station", "bus_stop", "cable_car_station", "chair_lift_station", "elevator", "funicular_stop", "gondola_station", "halt", "subway_entrance", "subway_stop", "tram_stop"], "dot_red", ["camp_site", "caravan_site"], "camping_grey", ["car_ferry", "ferry", "ferry_terminal"], "dot_blue", "church_tower", "dot_circle_dark_grey_12", "communications_tower", "communications_tower_grey", ["golf", "golf_course"], "golf_grey", "hospital", "hospital_grey", "observation_tower", "observation_tower_grey", ["survey_point", "surveying_pyramid"], "dot_dark_grey_4", "waterfall", "waterfall_blue", "wind_turbine", "windturbine_grey", ""], "text-field": ["case", ["has", "name:latin"], ["get", "name:latin"], ""], "visibility": "visible", "icon-rotate": ["case", ["has", "direction"], ["get", "direction"], 0], "text-anchor": ["match", ["get", "subclass"], ["caravan_site", "camp_site", "church_tower", "golf_course", "golf", "hospital", "communications_tower", "waterfall", "observation_tower"], "left", ["ferry", "car_ferry", "ferry_terminal", "funicular_stop", "halt", "tram_stop", "bus_stop", "cable_car_station", "gondola_station", "chair_lift_station", "aerialway_station", "elevator", "subway_entrance", "subway_stop", "survey_point", "surveying_pyramid"], "bottom-left", "center"], "text-offset": ["match", ["get", "subclass"], ["ferry", "car_ferry", "ferry_terminal", "funicular_stop", "halt", "tram_stop", "bus_stop", "cable_car_station", "gondola_station", "chair_lift_station", "aerialway_station", "elevator", "subway_entrance", "subway_stop"], ["literal", [0.4, 0.1]], "observation_tower", ["literal", [0.5, 0.2]], "waterfall", ["literal", [0.5, 0.1]], ["literal", [0.8, 0.1]]], "text-justify": ["match", ["get", "subclass"], ["aerialway_station", "bus_stop", "cable_car_station", "chair_lift_station", "elevator", "funicular_stop", "gondola_station", "halt", "subway_entrance", "subway_stop", "tram_stop", "camp_site", "caravan_site", "car_ferry", "ferry", "ferry_terminal", "church_tower", "communications_tower", "golf", "golf_course", "hospital", "observation_tower", "survey_point", "surveying_pyramid", "waterfall", "wind_turbine"], "left", "center"], "icon-optional": false, "text-max-width": 10, "icon-allow-overlap": false, "icon-ignore-placement": false, "text-letter-spacing": ["match", ["get", "class"], ["park"], 0.05, 0], "icon-rotation-alignment": "map"}, "paint": {"text-color": ["match", ["get", "subclass"], ["ferry", "car_ferry", "ferry_terminal"], "rgb(47, 134, 188)", ["funicular_stop", "halt", "tram_stop", "bus_stop", "cable_car_station", "gondola_station", "chair_lift_station", "aerialway_station", "elevator", "subway_entrance", "subway_stop"], "rgba(255, 50, 50, 1)", ["weir", "waterfall"], "rgb(47, 134, 188)", "rgba(48, 48, 48, 1)"], "icon-opacity": ["step", ["zoom"], 0, 14, ["match", ["get", "class"], ["place_of_worship"], 1, ["match", ["get", "subclass"], ["wind_turbine", "caravan_site", "camp_site", "ferry", "ferry_terminal", "funicular_stop", "golf_course", "golf", "cemetery", "stadium", "park"], 1, 0]], 15, 1], "text-opacity": ["step", ["zoom"], 0, 14, ["match", ["get", "class"], ["place_of_worship"], 1, ["match", ["get", "subclass"], ["wind_turbine", "caravan_site", "camp_site", "ferry", "ferry_terminal", "funicular_stop", "golf_course", "golf", "cemetery", "stadium", "park"], 1, 0]], 15, 1], "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": ["interpolate", ["linear"], ["zoom"], 14, 1, 17, 2]}, "filter": ["any", ["match", ["get", "class"], ["place_of_worship", "monastery"], true, false], ["match", ["get", "subclass"], ["aerialway", "aerialway_station", "allottments", "antenna_area", "attraction", "building", "bus_stop", "cable_car_station", "camp_site", "cave", "cemetery", "chair_lift_station", "church_tower", "communications_tower", "dam", "driving_centre", "elevator", "entrance", "ferry", "ferry_terminal", "fuel", "funicular", "funicular_stop", "garden", "golf", "golf_course", "gondola_station", "halt", "horse_racing", "incineration_plant", "military", "monastery", "observation_tower", "observatory", "park", "pitch", "power", "power_plant", "prison", "ruins", "shooting", "solar", "sports_centre", "stadium", "subway_entrance", "subway_stop", "survey_point", "swimming_pool", "tower", "tram_stop", "wastewater_plant", "waterfall", "weir", "wind_turbine", "zoo"], true, false]]}, {"id": "peaks_rank2", "type": "symbol", "source": "base_v1.0.0", "source-layer": "mountain_peak", "minzoom": 10.0, "layout": {"icon-size": 1, "text-font": ["Frutiger Neue Italic"], "text-size": ["interpolate", ["linear"], ["zoom"], 10, ["case", ["<=", 4000, ["get", "ele"]], 14, ["<=", 3000, ["get", "ele"]], 13, ["<=", 2000, ["get", "ele"]], 12, 11], 18, ["case", ["<=", 4000, ["get", "ele"]], 23, ["<=", 3000, ["get", "ele"]], 22, ["<=", 2000, ["get", "ele"]], 21, 20]], "icon-image": ["step", ["zoom"], "", 10, "dot_dark_grey_4", 14, "dot_dark_grey_6", 18, "dot_dark_grey_8"], "text-field": ["format", ["get", "name:latin"], {}, "\n", {}, ["get", "ele"], {"font-scale": 0.75}], "visibility": "visible", "icon-anchor": "center", "text-anchor": "bottom", "icon-padding": 0, "text-justify": "auto", "text-padding": 2, "icon-optional": false, "text-optional": false, "symbol-z-order": ["literal", "auto"], "text-max-width": 8, "symbol-placement": "point", "text-line-height": 1.15, "icon-allow-overlap": false, "text-allow-overlap": false, "text-radial-offset": 0.3, "text-letter-spacing": 0.025, "icon-pitch-alignment": "auto", "icon-ignore-placement": false, "text-ignore-placement": false, "icon-rotation-alignment": "map"}, "paint": {"icon-color": "rgba(0, 0, 0, 1)", "text-color": "rgba(48, 48, 48, 1)", "icon-opacity": ["step", ["zoom"], 0, 8, ["match", ["get", "class"], "alpine_peak", 1, 0], 10, ["match", ["get", "class"], "alpine_peak", ["case", [">=", 2, ["get", "rank"]], 1, 0], 0], 11, ["match", ["get", "class"], ["alpine_peak", "main_peak"], ["case", [">=", 3, ["get", "rank"]], 1, 0], 0], 12, ["match", ["get", "class"], ["alpine_peak", "main_peak", "peak", "main_hill", "hill"], ["case", [">=", 4, ["get", "rank"]], 1, 0], 0], 13, ["match", ["get", "class"], ["alpine_peak", "main_peak", "peak", "main_hill", "hill"], 1, 0], 15, 1], "text-opacity": ["step", ["zoom"], 0, 8, ["match", ["get", "class"], "alpine_peak", 1, 0], 10, ["match", ["get", "class"], "alpine_peak", ["case", [">=", 2, ["get", "rank"]], 1, 0], 0], 11, ["match", ["get", "class"], ["alpine_peak", "main_peak"], ["case", [">=", 3, ["get", "rank"]], 1, 0], 0], 12, ["match", ["get", "class"], ["alpine_peak", "main_peak", "peak", "main_hill", "hill"], ["case", [">=", 4, ["get", "rank"]], 1, 0], 0], 13, ["match", ["get", "class"], ["alpine_peak", "main_peak", "peak", "main_hill", "hill"], 1, 0], 15, 1], "icon-halo-blur": 0, "text-halo-blur": 1, "icon-halo-color": "rgba(255, 255, 255, 1)", "icon-halo-width": 0, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": ["interpolate", ["linear"], ["zoom"], 12, 1.5, 18, 3]}, "filter": ["all", ["has", "rank"], [">", "rank", 1], ["!in", "class", "mountain_pass"]]}, {"id": "place_other", "type": "symbol", "source": "base_v1.0.0", "source-layer": "place", "minzoom": 12.0, "layout": {"icon-size": 1, "text-font": ["Frutiger Neue Condensed Medium"], "text-size": ["interpolate", ["cubic-bezier", 0.5, 0.1, 0.7, 1], ["zoom"], 4, ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], ["case", ["<=", 50, ["get", "population"]], 6, 4], ["case", ["<=", 5000, ["get", "population"]], 8, ["<=", 2000, ["get", "population"]], 6, 4]], 16, ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], ["case", ["<=", 50, ["get", "population"]], 20, 18], ["case", ["<=", 5000, ["get", "population"]], 22, ["<=", 2000, ["get", "population"]], 20, 18]]], "icon-image": ["step", ["zoom"], ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], "circle_dark_grey_4", ""], 12, ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], "circle_dark_grey_6", ""]], "text-field": ["get", "name:latin"], "visibility": "visible", "text-anchor": ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], "bottom-left", "center"], "text-offset": ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], ["literal", [0.3, 0.2]], ["literal", [0, 0]]], "text-justify": "auto", "text-padding": ["interpolate", ["linear"], ["zoom"], 10, 2, 13, 2, 14, 0], "icon-optional": false, "symbol-z-order": ["literal", "auto"], "text-max-width": 10, "text-transform": "none", "symbol-sort-key": ["to-number", ["get", "rank"]], "text-letter-spacing": 0.025, "icon-anchor": "center"}, "paint": {"text-color": "rgba(64, 64, 64, 1)", "icon-opacity": ["step", ["zoom"], 0, 11, ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], ["case", [">", 30, ["get", "rank"]], 1, 0], ["case", [">", 18, ["get", "rank"]], 1, 0]], 13, ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], ["case", [">", 31, ["get", "rank"]], 1, 0], 1], 14, 0], "text-opacity": ["step", ["zoom"], 0, 11, ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], ["case", [">", 30, ["get", "rank"]], 1, 0], 0], 13, ["match", ["get", "class"], ["hamlet", "isolated_dwelling"], ["case", [">", 31, ["get", "rank"]], 1, 0], 0], 14, 1], "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": ["interpolate", ["cubic-bezier", 0, 0.75, 0.25, 1], ["zoom"], 12, 1, 16, 2]}, "filter": ["!in", "class", "continent", "country", "state", "city", "town", "village"]}, {"id": "poi_rank1", "type": "symbol", "source": "base_v1.0.0", "source-layer": "poi", "minzoom": 11.0, "layout": {"icon-size": 1, "text-font": ["Frutiger Neue Condensed Regular"], "text-size": ["interpolate", ["linear"], ["zoom"], 13, ["match", ["get", "class"], "hazard", 15, 13], 18, ["match", ["get", "class"], "hazard", 24, 20]], "icon-image": ["match", ["get", "subclass"], "railway_station", "square_red", "castle", "castle_grey", ""], "text-field": ["case", ["has", "name:latin"], ["get", "name:latin"], ""], "visibility": "visible", "text-anchor": ["match", ["get", "subclass"], ["castle"], "left", "railway_station", "bottom-left", "center"], "text-offset": ["match", ["get", "subclass"], "railway_station", ["literal", [0.5, 0.15]], ["literal", [0.8, 0.15]]], "text-justify": "left", "text-padding": 10, "text-optional": false, "text-max-width": 10, "symbol-avoid-edges": true, "icon-rotation-alignment": "map"}, "paint": {"text-color": ["match", ["get", "subclass"], "railway_station", "rgba(255, 50, 50, 1)", ["match", ["get", "class"], "hazard", "rgb(139, 96, 37)", "rgba(48, 48, 48, 1)"]], "text-opacity": ["step", ["zoom"], ["match", ["get", "class"], "hazard", 1, 0], 14, 1], "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": ["interpolate", ["linear"], ["zoom"], 14, 1, 17, 2]}, "filter": ["any", ["in", "subclass", "castle", "railway_station"], ["==", "class", "hazard"]]}, {"id": "aerodrome_label", "type": "symbol", "source": "base_v1.0.0", "source-layer": "aerodrome_label", "minzoom": 11.0, "layout": {"icon-size": ["interpolate", ["linear"], ["zoom"], 11, 0.7, 14, 1], "text-font": ["Frutiger Neue Condensed Regular"], "text-size": ["interpolate", ["linear"], ["zoom"], 11, ["match", ["get", "class"], "international", 16, "regional", 16, 12], 14, ["match", ["get", "class"], "international", 20, "regional", 18, 16]], "icon-image": ["match", ["get", "class"], "international", "airplane_large_grey", "regional", "airplane_medium_grey", "other", "airplane_small_grey", "helipad", "helicopter_grey", ""], "text-field": ["get", "name:latin"], "visibility": "visible", "icon-anchor": "center", "text-anchor": "left", "text-offset": ["match", ["get", "class"], "helipad", ["literal", [0.9, 0.2]], ["literal", [0.9, 0]]], "text-justify": "center", "text-padding": 2, "text-transform": "none"}, "paint": {"text-color": "rgba(64, 64, 64, 1)", "icon-opacity": ["step", ["zoom"], 0, 11, ["match", ["get", "class"], ["international", "regional"], 1, 0], 12, 1], "text-opacity": ["step", ["zoom"], 0, 11, ["match", ["get", "class"], ["international", "regional"], 1, 0], 12, 1], "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.8)", "text-halo-width": ["interpolate", ["linear"], ["zoom"], 14, 1, 17, 2]}, "filter": ["all", ["!=", "class", "helipad"]]}, {"id": "place_town_village", "type": "symbol", "source": "base_v1.0.0", "source-layer": "place", "minzoom": 6.0, "maxzoom": 16.0, "layout": {"icon-size": 1, "text-font": ["match", ["get", "class"], "town", ["literal", ["Frutiger Neue Condensed Bold"]], ["literal", ["Frutiger Neue Condensed Medium"]]], "text-size": ["interpolate", ["cubic-bezier", 0.5, 0.1, 0.7, 1], ["zoom"], 4, 11, 10, ["match", ["get", "class"], "town", ["case", ["<=", 30000, ["get", "population"]], 20, 18], ["case", ["<=", 3000, ["get", "population"]], 16, 14]], 16, ["match", ["get", "class"], "town", ["case", ["<=", 30000, ["get", "population"]], 32, 28], ["case", ["<=", 3000, ["get", "population"]], 28, 24]]], "icon-image": ["step", ["zoom"], "circle_dark_grey_4", 6, ["match", ["get", "class"], "town", "circle_dark_grey_6", "circle_dark_grey_4"], 8, ["match", ["get", "class"], "town", "circle_dark_grey_8", "circle_dark_grey_6"], 10, ["match", ["get", "class"], "town", "circle_dark_grey_10", "circle_dark_grey_8"], 12, ["match", ["get", "class"], "town", "circle_dark_grey_12", "circle_dark_grey_10"]], "text-field": ["get", "name:latin"], "visibility": "visible", "text-anchor": ["literal", "bottom-left"], "text-radial-offset": 0.3, "text-justify": "auto", "text-padding": 2, "icon-optional": false, "symbol-z-order": ["literal", "auto"], "text-max-width": 10, "text-transform": ["match", ["get", "class"], "town", "uppercase", "none"], "symbol-sort-key": ["to-number", ["get", "rank"]], "symbol-placement": "point", "text-variable-anchor": ["literal", ["bottom-left", "top-left", "bottom-right", "top-right", "left", "right"]], "text-letter-spacing": 0.025}, "paint": {"text-color": "rgba(64, 64, 64, 1)", "icon-opacity": ["step", ["zoom"], 0, 6, ["match", ["get", "class"], "town", ["case", [">", 9, ["get", "rank"]], 1, ["match", ["get", "capital"], [2, 4], 1, 0]], 0], 7, ["match", ["get", "class"], "town", ["case", [">", 9, ["get", "rank"]], 1, ["match", ["get", "capital"], [2, 4], 1, 0]], ["match", ["get", "capital"], [2, 4], 1, 0]], 8, ["match", ["get", "class"], "town", 1, ["case", [">", 14, ["get", "rank"]], 1, 0]], 9, ["match", ["get", "class"], "town", 1, ["case", [">", 15, ["get", "rank"]], 1, 0]], 10, ["match", ["get", "class"], "town", 1, ["case", [">", 18, ["get", "rank"]], 1, 0]], 11, ["match", ["get", "class"], "town", 1, ["case", [">", 28, ["get", "rank"]], 1, 0]], 12, ["match", ["get", "class"], "town", 0, 1], 13, 0], "text-opacity": ["step", ["zoom"], 0, 6, ["match", ["get", "class"], "town", ["case", [">", 9, ["get", "rank"]], 1, ["match", ["get", "capital"], [2, 4], 1, 0]], 0], 7, ["match", ["get", "class"], "town", ["case", [">", 9, ["get", "rank"]], 1, ["match", ["get", "capital"], [2, 4], 1, 0]], ["match", ["get", "capital"], [2, 4], 1, 0]], 8, ["match", ["get", "class"], "town", 1, ["case", [">", 14, ["get", "rank"]], 1, 0]], 9, ["match", ["get", "class"], "town", 1, ["case", [">", 15, ["get", "rank"]], 1, 0]], 10, ["match", ["get", "class"], "town", 1, ["case", [">", 18, ["get", "rank"]], 1, 0]], 11, ["match", ["get", "class"], "town", 1, ["case", [">", 28, ["get", "rank"]], 1, 0]], 12, 1], "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": ["interpolate", ["cubic-bezier", 0, 0.75, 0.25, 1], ["zoom"], 12, 1, 16, ["match", ["get", "class"], "town", 3, 2]]}, "filter": ["in", "class", "town", "village"]}, {"id": "peaks_rank1", "type": "symbol", "source": "base_v1.0.0", "source-layer": "mountain_peak", "minzoom": 9.0, "layout": {"icon-size": 1, "text-font": ["Frutiger Neue Italic"], "text-size": ["interpolate", ["linear"], ["zoom"], 10, ["case", ["<=", 4000, ["get", "ele"]], 14, ["<=", 3000, ["get", "ele"]], 13, ["<=", 2000, ["get", "ele"]], 12, 11], 18, ["case", ["<=", 4000, ["get", "ele"]], 23, ["<=", 3000, ["get", "ele"]], 22, ["<=", 2000, ["get", "ele"]], 21, 20]], "icon-image": ["step", ["zoom"], "dot_dark_grey_4", 14, "dot_dark_grey_6", 18, "dot_dark_grey_8"], "text-field": ["format", ["get", "name:latin"], {}, "\n", {}, ["get", "ele"], {"font-scale": 0.75}], "visibility": "visible", "icon-anchor": "center", "icon-offset": [0, 0], "text-anchor": "bottom", "icon-padding": 2, "text-justify": "auto", "text-padding": 10, "icon-optional": false, "text-optional": false, "symbol-z-order": ["literal", "auto"], "text-max-width": 8, "symbol-placement": "point", "text-line-height": 1.15, "icon-allow-overlap": false, "text-allow-overlap": false, "text-radial-offset": 0.3, "text-letter-spacing": 0.025, "icon-pitch-alignment": "auto", "icon-ignore-placement": false, "text-ignore-placement": false, "icon-rotation-alignment": "map"}, "paint": {"icon-color": "rgba(0, 0, 0, 1)", "text-color": "rgba(48, 48, 48, 1)", "icon-opacity": ["step", ["zoom"], 0, 9, ["case", ["<=", 3200, ["get", "ele"]], 1, 0], 10, 1], "text-opacity": ["step", ["zoom"], 0, 9, ["case", ["<=", 3200, ["get", "ele"]], 1, 0], 10, 1], "icon-halo-blur": 0, "text-halo-blur": 1, "icon-halo-color": "rgba(255, 255, 255, 1)", "icon-halo-width": 0, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": ["interpolate", ["linear"], ["zoom"], 10, 1.5, 18, 3]}, "filter": ["all", ["has", "rank"], ["==", "rank", 1], ["!in", "class", "rocky_knoll", "saddle", "mountain_pass"]]}, {"id": "waterway_line_label", "type": "symbol", "source": "base_v1.0.0", "source-layer": "waterway", "minzoom": 9.0, "layout": {"text-font": ["Frutiger Neue Italic"], "text-size": ["interpolate", ["exponential", 1.5], ["zoom"], 10, 10.5, 16, ["match", ["to-string", ["get", "width"]], ["9", "10"], 18, ["7", "8"], 17, ["5", "6"], 16, "4", 15, "3", 14, "2", 13, "1", 12, ["match", ["get", "class"], ["river", "canal"], 18, 14]]], "text-field": ["get", "name:latin"], "visibility": "visible", "text-padding": 0, "symbol-spacing": 650, "symbol-z-order": "auto", "text-max-width": 9999, "symbol-placement": "line", "text-keep-upright": true, "text-allow-overlap": false, "text-letter-spacing": ["interpolate", ["linear"], ["zoom"], 8, 0.1, 12, ["match", ["get", "class"], ["river"], 0.4, 0.2]], "text-pitch-alignment": "map", "text-ignore-placement": false, "text-rotation-alignment": "map"}, "paint": {"text-color": "rgb(47, 134, 188)", "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": 2}, "filter": ["all", ["has", "name:latin"], ["case", ["has", "intermittent"], ["!=", ["get", "intermittent"], 1], true], ["==", ["geometry-type"], "LineString"]]}, {"id": "water_name_point_label", "type": "symbol", "source": "base_v1.0.0", "source-layer": "water_name", "minzoom": 7.0, "layout": {"text-font": ["Frutiger Neue Italic"], "text-size": ["interpolate", ["linear"], ["zoom"], 8, ["match", ["get", "size"], [10, 9], 12, [8, 7], 10, 10], 10, ["match", ["get", "size"], [10, 9], 22, [8, 7, 6], 18, [5, 4], 16, [3], 14, [2], 12, [1], 10, 10], 12, ["match", ["get", "size"], [10, 9], 24, [8, 7], 22, [6, 5, 4, 3], 20, [2], 16, [1], 12, 12], 14, ["match", ["get", "size"], [10, 9], 28, [8, 7], 26, [6, 5, 4, 3], 24, [2], 22, [1], 14, 12], 15, ["match", ["get", "size"], [10, 9], 30, [8, 7], 28, [6, 5, 4, 3], 26, [2], 24, [1], 18, 18]], "text-field": "{name:latin}", "visibility": "visible", "text-rotate": ["get", "direction"], "text-padding": 2, "symbol-spacing": 250, "symbol-z-order": "auto", "text-max-width": 20, "symbol-placement": "point", "text-keep-upright": true, "text-allow-overlap": false, "text-letter-spacing": ["interpolate", ["linear"], ["zoom"], 7, ["match", ["get", "size"], [10, 9, 8], 0.1, [7, 6], 0.04, [5, 4, 3], 0.02, [2], 0.01, 0.05], 16, ["match", ["get", "size"], [10, 9, 8], 0.7, [7, 6], 0.5, [5, 4, 3], 0.3, [2], 0.2, 0.1]], "text-pitch-alignment": "map", "text-ignore-placement": false, "text-rotation-alignment": "viewport"}, "paint": {"text-color": "rgb(47, 134, 188)", "text-opacity": ["step", ["zoom"], 0, 7, ["match", ["get", "size"], [10, 9, 8], 1, 0], 8, ["match", ["get", "size"], [10, 9, 8, 7, 6], 1, 0], 9, ["match", ["get", "size"], [10, 9, 8, 7, 6, 4, 3], 1, 0], 10, ["match", ["get", "size"], [10, 9, 8, 7, 6, 5, 4, 3, 2], 1, 0], 12, ["match", ["get", "size"], [10, 9, 8, 7, 6, 5, 4, 3, 2, 1], 1, 1]], "text-halo-blur": 0.25, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": 1}, "filter": ["all", ["==", "$type", "Point"], ["==", "class", "lake"]]}, {"id": "park_label", "type": "symbol", "source": "base_v1.0.0", "source-layer": "park", "minzoom": 8.0, "layout": {"text-font": ["Frutiger Neue Regular"], "text-size": ["interpolate", ["cubic-bezier", 0.5, 0.1, 0.7, 1], ["zoom"], 8, 14, 16, 28], "text-field": "{name:latin}", "visibility": "visible", "text-padding": ["interpolate", ["linear"], ["zoom"], 10, 2, 14, 10], "symbol-z-order": ["literal", "auto"]}, "paint": {"text-color": "rgba(70, 130, 25, 0.9)", "text-halo-blur": 1, "text-halo-color": "rgba(255, 255, 255, 0.8)", "text-halo-width": 1}, "filter": ["all", ["in", "class", "national_park"], ["==", "$type", "Point"]]}, {"id": "area_name_massif_label", "type": "symbol", "source": "base_v1.0.0", "source-layer": "area_name", "minzoom": 11.0, "layout": {"text-font": ["Frutiger Neue Regular"], "text-size": ["interpolate", ["linear"], ["zoom"], 10, 14, 16, 23], "text-field": "{name:latin}", "visibility": "visible", "symbol-spacing": {"stops": [[12, 250], [14, 550]]}, "symbol-z-order": "auto", "text-max-width": 99999, "symbol-placement": "point", "text-keep-upright": true, "symbol-avoid-edges": true, "text-allow-overlap": false, "text-letter-spacing": 0.07, "text-pitch-alignment": "viewport", "text-ignore-placement": false, "text-rotation-alignment": "viewport"}, "paint": {"text-color": "rgba(48, 48, 48, 1)", "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": 1}, "filter": ["all", ["==", "$type", "Point"], ["in", "subclass", "massif"]]}, {"id": "place_city", "type": "symbol", "source": "base_v1.0.0", "source-layer": "place", "minzoom": 2.0, "maxzoom": 14.0, "layout": {"icon-size": 1, "text-font": ["Frutiger Neue Condensed Bold"], "text-size": ["interpolate", ["cubic-bezier", 0.5, 0.1, 0.7, 1], ["zoom"], 1, 11, 4, 12, 16, 48], "icon-image": ["step", ["zoom"], "dot_circle_dark_grey_6", 6, "dot_circle_dark_grey_8", 8, "circle_circle_dark_grey_10", 10, "circle_circle_dark_grey_12", 12, "circle_circle_dark_grey_12"], "text-field": ["get", "name:latin"], "visibility": "visible", "text-anchor": "bottom-left", "text-offset": ["literal", [0.35, 0.1]], "text-justify": "auto", "text-padding": 10, "icon-optional": false, "symbol-z-order": ["literal", "auto"], "text-max-width": 10, "text-transform": "uppercase", "symbol-sort-key": ["to-number", ["get", "rank"]], "text-letter-spacing": 0.025}, "paint": {"text-color": "rgba(64, 64, 64, 1)", "icon-opacity": ["step", ["zoom"], 1, 11, 0], "text-opacity": 1, "text-halo-blur": 1, "text-halo-color": "rgba(242, 242, 242, 0.6)", "text-halo-width": ["interpolate", ["cubic-bezier", 0, 0.75, 0.25, 1], ["zoom"], 12, 1, 16, 3]}, "filter": ["all", ["==", "class", "city"]]}, {"id": "hazard", "type": "fill", "source": "base_v1.0.0", "source-layer": "landcover", "minzoom": 5.0, "layout": {"visibility": "visible"}, "paint": {"fill-color": "rgb(240, 218, 188)", "fill-opacity": 0.4, "fill-antialias": false}, "filter": ["==", "class", "hazard"]}, {"id": "place_country", "type": "symbol", "source": "base_v1.0.0", "source-layer": "place", "minzoom": 0.0, "maxzoom": 14.0, "layout": {"text-font": ["Frutiger Neue Condensed Regular"], "text-size": ["interpolate", ["linear"], ["zoom"], 1, 12, 7, 14, 11, 16, 18, 24], "text-field": "{name:latin}", "visibility": "visible", "text-max-width": 10, "text-transform": "uppercase", "text-letter-spacing": 0.12}, "paint": {"text-color": "rgba(145, 70, 145, 0.9)", "text-halo-blur": 1, "text-halo-color": "rgba(255, 255, 255, 0.8)", "text-halo-width": 1}, "filter": ["==", "class", "country"]}], "metadata": {"maptiler:template": {"groups": [{"id": "4rZcx2YUdbGIJ_xQaDQb6", "name": "label", "icon": "variant2", "layers": ["place_country", "place_city", "area_name_massif_label", "park_label", "water_name_point_label", "area_name_glacier_line_label", "area_name_glacier_point_label", "place_town_village", "place_other"]}, {"id": "spbW1YO3D6JmGqVeeVEo3", "name": "poi", "icon": "poi", "layers": ["poi_rank1", "poi_rank2"]}, {"id": "Egb2j0u2wyQyI8FftRcqF", "name": "mountain_peak", "icon": "terrain", "layers": ["peaks_rank1", "peaks_rank2"]}, {"id": "o-n3H-7f0sOIKwDFxFRaG", "name": "infrastructure", "icon": "builtUp", "layers": ["building_casing", "building", "building_ln", "construct", "construct_line"]}, {"id": "_olyvAt6o8QUN9qePUZap", "name": "transportation", "icon": "transport", "layers": ["road_number", "transportation_label", "l2_fill", "l2_road_casing", "l1_public_transport", "l1_fill", "l1_road_casing", "public_transport", "road_fill", "road_casing", "road_via_ferrata_trail", "tunnel_road", "tunnel_pedestrian", "tunnel_public_transport", "aerodrome_label", "aeroway_polygon_fill", "aeroway_polygon_casing", "landuse_parking", "landuse_parking_outline", "l2_public_transport_aerialway", "l1_2_pedestrian", "road_path_footway_ferry"]}, {"id": "z959Ue-RzB_dh5_EJgGry", "name": "boundary", "icon": "administrative", "layers": ["boundary", "boundary_disputed", "park"]}, {"id": "jQ4N1YUSpDNjoXrIHGNpp", "name": "water", "icon": "water", "layers": ["waterway_line_label", "water_outline", "water_line_intermittent", "water", "contour_line_blue", "water_line"]}, {"id": "QZWB1txCT3r3H5wy13N86", "name": "land", "icon": "nature", "layers": ["pattern_landcover", "landcover", "landcover_casing", "landuse_outline", "landuse", "hazard"]}, {"id": "terrain", "name": "terrain", "icon": "terrain", "layers": ["hillshade_grey", "hillshade_yellow", "hachure", "scree_z11", "scree_z13", "scree_z15", "scree_z17", "contour_line", "spot_elevation", "contour_line_pt"]}, {"id": "background", "name": "Background", "icon": "background", "layers": ["background"]}], "viewState": {"toolPanelType": "Layers", "mapType": "Style", "layersViewPanelType": "Verticality", "propertyPanelType": "Edit", "activeBlock": "QZWB1txCT3r3H5wy13N86", "selectedLayers": ["hazard"], "editorFocusProperty": null}, "userSettings": {"preferredViewPanelType": "Verticality"}, "spaceColor": "#F7FBFD"}, "ga:version": "v1.25.1", "ga:publisher": "CI-release:1b6976d1-03ac-41f1-8f4a-7346256d7d81", "ga:branch": "master"}, "glyphs": "https://vectortiles.geo.admin.ch/fonts/{fontstack}/{range}.pbf", "sprite": "https://vectortiles.geo.admin.ch/styles/ch.swisstopo.lightbasemap.vt/v1.25.1/sprite/sprite", "bearing": 0.0, "pitch": 0.0, "center": [8.349961425056108, 46.81133904939108], "zoom": 7.2512975045452235, "transition": {}} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/ComposeTestTemplate.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/ComposeTestTemplate.kt new file mode 100644 index 00000000..3a1acde2 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/ComposeTestTemplate.kt @@ -0,0 +1,30 @@ +package ovh.plrapps.mapcompose.vector + +/* +@OptIn(ExperimentalTestApi::class) +class ComposeTest { + + @Test + fun simpleCheck() = runComposeUiTest { + setContent { + var txt by remember { mutableStateOf("Go") } + Column { + Text( + text = txt, + modifier = Modifier.testTag("t_text") + ) + Button( + onClick = { txt += "." }, + modifier = Modifier.testTag("t_button") + ) { + Text("click me") + } + } + } + + onNodeWithTag("t_button").apply { + repeat(3) { performClick() } + } + onNodeWithTag("t_text").assertTextEquals("Go...") + } +}*/ diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/GeometryDecodersTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/GeometryDecodersTest.kt new file mode 100644 index 00000000..d36a3ea8 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/GeometryDecodersTest.kt @@ -0,0 +1,27 @@ +import kotlin.test.Test +import kotlin.test.assertEquals +import ovh.plrapps.mapcompose.vector.renderer.GeometryDecoders.Companion.tileCoordToCanvas +import ovh.plrapps.mapcompose.vector.renderer.GeometryDecoders.Companion.decodeZigZag + +class GeometryDecodersTest { + private fun encodeZigZag(n: Int): Int = (n shl 1) xor (n shr 31) + + @Test + fun testDecodeZigZag() { + val values = listOf(0, 1, -1, 2, -2, 123456, -123456, Int.MAX_VALUE / 2, -(Int.MAX_VALUE / 2) - 1) + for (n in values) { + val encoded = encodeZigZag(n) + assertEquals(n, decodeZigZag(encoded), "decodeZigZag(encodeZigZag($n))") + } + } + + @Test + fun testTileCoordToCanvas() { + // canvasSize = 256, extent = 4096, scale = 0.0625 + assertEquals(Pair(0f, 0f), tileCoordToCanvas(0, 0, 256, 4096)) + assertEquals(Pair(62.5f, 125f), tileCoordToCanvas(1000, 2000, 256, 4096)) + assertEquals(Pair(-6.25f, -6.25f), tileCoordToCanvas(-100, -100, 256, 4096)) + assertEquals(Pair(0f, -16f), tileCoordToCanvas(0, -16, 16, 16)) + assertEquals(Pair(250.625f, -1f), tileCoordToCanvas(4010, -16, 256, 4096)) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/CollisionDetectorTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/CollisionDetectorTest.kt new file mode 100644 index 00000000..17c42a3e --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/CollisionDetectorTest.kt @@ -0,0 +1,128 @@ +package ovh.plrapps.mapcompose.vector.renderer.collision + +import androidx.compose.ui.geometry.Rect +import androidx.compose.ui.test.ExperimentalTestApi +import kotlin.test.Test +import kotlin.test.assertFalse +import kotlin.test.assertTrue +import ovh.plrapps.mapcompose.vector.utils.obb.OBB +import ovh.plrapps.mapcompose.vector.utils.obb.ObbPoint +import ovh.plrapps.mapcompose.vector.utils.obb.Size as ObbSize + +@OptIn(ExperimentalTestApi::class) +class CollisionDetectorTest { + private fun label( + id: String, + x: Float, y: Float, w: Float, h: Float, + overlapMode: OverlapMode = OverlapMode.Never, + ignorePlacement: Boolean = false, + ) = LabelPlacement( + text = id, + position = ObbPoint(x + w / 2, y + h / 2), + angle = 0f, + bounds = Rect(x, y, x + w, y + h), + obb = OBB( + center = ObbPoint(x + w / 2, y + h / 2), + size = ObbSize(w, h), + rotation = 0f + ), + layerIndex = 0, + inLayerPriority = 0.0, + overlapMode = overlapMode, + ignorePlacement = ignorePlacement, + ) + + @Test + fun testIntersectsTrue() { + val r1 = Rect(0f, 0f, 10f, 10f) + val r2 = Rect(5f, 5f, 15f, 15f) + assertTrue(r1.intersects(r2)) + } + + @Test + fun testIntersectsFalse() { + val r1 = Rect(0f, 0f, 10f, 10f) + val r2 = Rect(11f, 11f, 20f, 20f) + assertFalse(r1.intersects(r2)) + } + + @Test + fun testNeverBlocksNever() { + val detector = CollisionDetector() + val p1 = label("A", 0f, 0f, 10f, 10f, OverlapMode.Never) + val p2 = label("B", 5f, 5f, 10f, 10f, OverlapMode.Never) + + assertTrue(detector.tryPlaceLabel(p1)) + assertFalse(detector.tryPlaceLabel(p2)) // collides with p1 + } + + @Test + fun testAlwaysIsPlacedAndBlocksNever() { + val detector = CollisionDetector() + val p1 = label("A", 0f, 0f, 10f, 10f, OverlapMode.Always) + val p2 = label("B", 5f, 5f, 10f, 10f, OverlapMode.Never) + + assertTrue(detector.tryPlaceLabel(p1)) // always placed + assertFalse(detector.tryPlaceLabel(p2)) // p1 (Always) blocks p2 (Never) + } + + @Test + fun testAlwaysDoesNotBlockAlways() { + val detector = CollisionDetector() + val p1 = label("A", 0f, 0f, 10f, 10f, OverlapMode.Always) + val p2 = label("B", 5f, 5f, 10f, 10f, OverlapMode.Always) + + assertTrue(detector.tryPlaceLabel(p1)) + assertTrue(detector.tryPlaceLabel(p2)) // Always is never blocked + } + + @Test + fun testCooperativeDoesNotBlockCooperative() { + val detector = CollisionDetector() + val p1 = label("A", 0f, 0f, 10f, 10f, OverlapMode.Cooperative) + val p2 = label("B", 5f, 5f, 10f, 10f, OverlapMode.Cooperative) + + assertTrue(detector.tryPlaceLabel(p1)) + assertTrue(detector.tryPlaceLabel(p2)) // two Cooperative symbols can overlap + } + + @Test + fun testNeverBlocksCooperative() { + val detector = CollisionDetector() + val p1 = label("A", 0f, 0f, 10f, 10f, OverlapMode.Never) + val p2 = label("B", 5f, 5f, 10f, 10f, OverlapMode.Cooperative) + + assertTrue(detector.tryPlaceLabel(p1)) + assertFalse(detector.tryPlaceLabel(p2)) // Never blocks Cooperative + } + + @Test + fun testCooperativeBlocksNever() { + val detector = CollisionDetector() + val p1 = label("A", 0f, 0f, 10f, 10f, OverlapMode.Cooperative) + val p2 = label("B", 5f, 5f, 10f, 10f, OverlapMode.Never) + + assertTrue(detector.tryPlaceLabel(p1)) + assertFalse(detector.tryPlaceLabel(p2)) // Cooperative is in tree → blocks Never + } + + @Test + fun testIgnorePlacementDoesNotBlockOthers() { + val detector = CollisionDetector() + val p1 = label("A", 0f, 0f, 10f, 10f, ignorePlacement = true) + val p2 = label("B", 5f, 5f, 10f, 10f, OverlapMode.Never) + + assertTrue(detector.tryPlaceLabel(p1)) // ignore-placement is always placed + assertTrue(detector.tryPlaceLabel(p2)) // p1 not in tree → doesn't block p2 + } + + @Test + fun testNonOverlappingNeverSymbolsAreAllPlaced() { + val detector = CollisionDetector() + val p1 = label("A", 0f, 0f, 10f, 10f, OverlapMode.Never) + val p2 = label("B", 20f, 0f, 10f, 10f, OverlapMode.Never) // no overlap + + assertTrue(detector.tryPlaceLabel(p1)) + assertTrue(detector.tryPlaceLabel(p2)) + } +} diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LineLabelPlacementTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LineLabelPlacementTest.kt new file mode 100644 index 00000000..c54bf782 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/renderer/collision/LineLabelPlacementTest.kt @@ -0,0 +1,53 @@ +package ovh.plrapps.mapcompose.vector.renderer.collision + +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class LineLabelPlacementTest { + @Test + fun testSingleSegmentOneLabel() { + val points = listOf(0f to 0f, 100f to 0f) + val textWidth = 40f + val spacing = 100f + val placements = LineLabelPlacement.calculatePlacements(points, textWidth, spacing) + assertEquals(1, placements.size) + val (pos, angle) = placements[0] + assertTrue(pos.first > 0 && pos.first < 100) + assertEquals(0f, angle) + } + + @Test + fun testLongSegmentMultipleLabels() { + val points = listOf(0f to 0f, 300f to 0f) + val textWidth = 40f + val spacing = 100f + val placements = LineLabelPlacement.calculatePlacements(points, textWidth, spacing) + assertTrue(placements.size > 1) + for (i in 1 until placements.size) { + val prev = placements[i-1].first.first + val curr = placements[i].first.first + assertTrue(curr > prev) + } + } + + @Test + fun testVerticalSegmentAngle() { + val points = listOf(0f to 0f, 0f to 100f) + val textWidth = 20f + val spacing = 50f + val placements = LineLabelPlacement.calculatePlacements(points, textWidth, spacing) + assertTrue(placements.isNotEmpty()) + val angle = placements[0].second + assertTrue(angle == 90f || angle == -90f) + } + + @Test + fun testNoPlacementIfTooShort() { + val points = listOf(0f to 0f, 10f to 0f) + val textWidth = 20f + val spacing = 100f + val placements = LineLabelPlacement.calculatePlacements(points, textWidth, spacing) + assertTrue(placements.isEmpty()) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/ColorParserTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/ColorParserTest.kt new file mode 100644 index 00000000..0aa278ad --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/ColorParserTest.kt @@ -0,0 +1,104 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import androidx.compose.ui.graphics.Color +import ovh.plrapps.mapcompose.vector.spec.style.utils.ColorParser +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull +import kotlin.test.assertNotNull + +class ColorParserTest { + private val parser = ColorParser + + @Test + fun `parse should handle hex colors`() { + assertEquals(Color(0xFF, 0x00, 0x00), parser.parseColorStringOrNull("#F00")) + assertEquals(Color(0x00, 0xFF, 0x00), parser.parseColorStringOrNull("#0F0")) + assertEquals(Color(0x00, 0x00, 0xFF), parser.parseColorStringOrNull("#00F")) + + assertEquals(Color(0xFF, 0x00, 0x00), parser.parseColorStringOrNull("#FF0000")) + assertEquals(Color(0x00, 0xFF, 0x00), parser.parseColorStringOrNull("#00FF00")) + assertEquals(Color(0x00, 0x00, 0xFF), parser.parseColorStringOrNull("#0000FF")) + + assertEquals(Color(0xFF, 0x00, 0x00, 0x80), parser.parseColorStringOrNull("#FF000080")) + assertEquals(Color(0x00, 0xFF, 0x00, 0x80), parser.parseColorStringOrNull("#00FF0080")) + assertEquals(Color(0x00, 0x00, 0xFF, 0x80), parser.parseColorStringOrNull("#0000FF80")) + + assertNull(parser.parseColorStringOrNull("#")) + assertNull(parser.parseColorStringOrNull("#12345")) + assertNull(parser.parseColorStringOrNull("#GGGGGG")) + } + + @Test + fun `parse should handle rgb colors`() { + assertEquals(Color(255, 0, 0), parser.parseColorStringOrNull("rgb(255, 0, 0)")) + assertEquals(Color(0, 255, 0), parser.parseColorStringOrNull("rgb(0, 255, 0)")) + assertEquals(Color(0, 0, 255), parser.parseColorStringOrNull("rgb(0, 0, 255)")) + assertEquals(Color(0xFF6495ED), parser.parseColorStringOrNull("cornflowerblue")) + assertEquals(Color(0xFF000000), parser.parseColorStringOrNull("black")) + assertEquals(Color(0xFFB22222), parser.parseColorStringOrNull("firebrick")) + + assertNull(parser.parseColorStringOrNull("rgb()")) + assertNull(parser.parseColorStringOrNull("rgb(255)")) + assertNull(parser.parseColorStringOrNull("rgb(255, 0)")) + assertNull(parser.parseColorStringOrNull("rgb(255, 0, 0, 0)")) + } + + @Test + fun `parse should handle rgba colors`() { + assertEquals(Color(255, 0, 0, 128), parser.parseColorStringOrNull("rgba(255, 0, 0, 0.5)")) + assertEquals(Color(0, 255, 0, 128), parser.parseColorStringOrNull("rgba(0, 255, 0, 0.5)")) + assertEquals(Color(0, 0, 255, 128), parser.parseColorStringOrNull("rgba(0, 0, 255, 0.5)")) + + // wrong RGBA colors + assertNull(parser.parseColorStringOrNull("rgba()")) + assertNull(parser.parseColorStringOrNull("rgba(255)")) + assertNull(parser.parseColorStringOrNull("rgba(255, 0)")) + assertNull(parser.parseColorStringOrNull("rgba(255, 0, 0)")) + } + + @Test + fun `parse should handle hsl colors`() { + assertEquals(Color(255, 0, 0), parser.parseColorStringOrNull("hsl(0, 100%, 50%)")) + assertEquals(Color(0, 255, 0), parser.parseColorStringOrNull("hsl(120, 100%, 50%)")) + assertEquals(Color(0, 0, 255), parser.parseColorStringOrNull("hsl(240, 100%, 50%)")) + + assertNull(parser.parseColorStringOrNull("hsl()")) + assertNull(parser.parseColorStringOrNull("hsl(0)")) + assertNull(parser.parseColorStringOrNull("hsl(0, 100%)")) + assertNull(parser.parseColorStringOrNull("hsl(0, 100%, 50%, 0.5)")) + } + + @Test + fun `parse should handle hsla colors`() { + assertEquals(Color(255, 0, 0, 128), parser.parseColorStringOrNull("hsla(0, 100%, 50%, 0.5)")) + assertEquals(Color(0, 255, 0, 128), parser.parseColorStringOrNull("hsla(120, 100%, 50%, 0.5)")) + assertEquals(Color(0, 0, 255, 128), parser.parseColorStringOrNull("hsla(240, 100%, 50%, 0.5)")) + + assertNull(parser.parseColorStringOrNull("hsla()")) + assertNull(parser.parseColorStringOrNull("hsla(0)")) + assertNull(parser.parseColorStringOrNull("hsla(0, 100%)")) + assertNull(parser.parseColorStringOrNull("hsla(0, 100%, 50%)")) + } + + @Test + fun `parse should handle null and invalid input`() { + assertNull(parser.parseColorStringOrNull("")) + assertNull(parser.parseColorStringOrNull("invalid")) + assertNull(parser.parseColorStringOrNull("color(255, 0, 0)")) + } + + @Test + fun `parse should handle hsl color`() { + val color = ColorParser.parseColorStringOrNull("hsl(75,51%,85%)") + assertNotNull(color) + assertEquals(Color.hsl(hue = 75F, saturation = 0.51f, lightness = 0.85f), color) + } + + @Test + fun `parse should handle hsla color`() { + val color = ColorParser.parseColorStringOrNull("hsla(9, 100%, 64%, 0.4)") + assertNotNull(color) + assertEquals(Color.hsl(hue = 9F, saturation = 1f, lightness = 0.64f, alpha = 0.4f), color) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/FilterTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/FilterTest.kt new file mode 100644 index 00000000..9450b86a --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/FilterTest.kt @@ -0,0 +1,469 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import kotlinx.serialization.json.* +import ovh.plrapps.mapcompose.vector.spec.style.Filter.Companion.TYPE_PROPERTY +import kotlin.test.* + +class FilterTest { + @Test + fun testEquals() { + val filter = Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test") + ) + assertTrue(filter.process(mapOf("name" to "test"), 0.0)) + assertFalse(filter.process(mapOf("name" to "other"), 0.0)) + } + + @Test + fun testNotEquals() { + val filter = Filter.Neq( + FilterOperand.Get("name"), + FilterOperand.Literal("test") + ) + assertFalse(filter.process(mapOf("name" to "test"), 0.0)) + assertTrue(filter.process(mapOf("name" to "other"), 0.0)) + } + + @Test + fun testGreaterThan() { + val filter = Filter.Gt( + FilterOperand.Get("count"), + FilterOperand.Literal(5) + ) + assertTrue(filter.process(mapOf("count" to 10), 0.0)) + assertFalse(filter.process(mapOf("count" to 3), 0.0)) + } + + @Test + fun testLessThan() { + val filter = Filter.Lt( + FilterOperand.Get("count"), + FilterOperand.Literal(5) + ) + assertTrue(filter.process(mapOf("count" to 3), 0.0)) + assertFalse(filter.process(mapOf("count" to 10), 0.0)) + } + + @Test + fun testIn() { + val filter = Filter.InList( + FilterOperand.Get("name"), + listOf( + FilterOperand.Literal("test1"), + FilterOperand.Literal("test2") + ) + ) + assertTrue(filter.process(mapOf("name" to "test1"), 0.0)) + assertTrue(filter.process(mapOf("name" to "test2"), 0.0)) + assertFalse(filter.process(mapOf("name" to "other"), 0.0)) + } + + @Test + fun testNotIn() { + val filter = Filter.NotInList( + FilterOperand.Get("name"), + listOf( + FilterOperand.Literal("test1"), + FilterOperand.Literal("test2") + ) + ) + assertFalse(filter.process(mapOf("name" to "test1"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test2"), 0.0)) + assertTrue(filter.process(mapOf("name" to "other"), 0.0)) + } + + @Test + fun testHas() { + val filter = Filter.Has("name") + assertTrue(filter.process(mapOf("name" to "test"), 0.0)) + assertFalse(filter.process(mapOf("other" to "test"), 0.0)) + } + + @Test + fun testNotHas() { + val filter = Filter.NotHas("name") + assertFalse(filter.process(mapOf("name" to "test"), 0.0)) + assertTrue(filter.process(mapOf("other" to "test"), 0.0)) + } + + @Test + fun testAll() { + val filter = Filter.All( + listOf( + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test") + ), + Filter.InList( + FilterOperand.Get("type"), + listOf(FilterOperand.Literal("point")) + ) + ) + ) + assertTrue(filter.process(mapOf("name" to "test", "type" to "point"), 0.0)) + assertFalse(filter.process(mapOf("name" to "other", "type" to "point"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test", "type" to "line"), 0.0)) + } + + @Test + fun testAny() { + val filter = Filter.AnyOf( + listOf( + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test1") + ), + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test2") + ) + ) + ) + assertTrue(filter.process(mapOf("name" to "test1"), 0.0)) + assertTrue(filter.process(mapOf("name" to "test2"), 0.0)) + assertFalse(filter.process(mapOf("name" to "other"), 0.0)) + } + + @Test + fun testNone() { + val filter = Filter.None( + listOf( + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test1") + ), + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test2") + ) + ) + ) + assertFalse(filter.process(mapOf("name" to "test1"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test2"), 0.0)) + assertTrue(filter.process(mapOf("name" to "other"), 0.0)) + } + + @Test + fun testNestedFilters() { + val filter = Filter.All( + listOf( + Filter.AnyOf( + listOf( + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test1") + ), + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test2") + ) + ) + ), + Filter.NotInList( + FilterOperand.Get("type"), + listOf(FilterOperand.Literal("line")) + ) + ) + ) + assertTrue(filter.process(mapOf("name" to "test1", "type" to "point"), 0.0)) + assertTrue(filter.process(mapOf("name" to "test2", "type" to "point"), 0.0)) + assertFalse(filter.process(mapOf("name" to "other", "type" to "point"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test1", "type" to "line"), 0.0)) + } + + @Test + fun testDeeplyNestedFilters() { + val filter = Filter.All( + listOf( + Filter.AnyOf( + listOf( + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test1") + ), + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test2") + ) + ) + ), + Filter.All( + listOf( + Filter.NotInList( + FilterOperand.Get("type"), + listOf(FilterOperand.Literal("line")) + ), + Filter.AnyOf( + listOf( + Filter.Eq( + FilterOperand.Get("color"), + FilterOperand.Literal("red") + ), + Filter.Eq( + FilterOperand.Get("color"), + FilterOperand.Literal("blue") + ) + ) + ) + ) + ) + ) + ) + assertTrue(filter.process(mapOf("name" to "test1", "type" to "point", "color" to "red"), 0.0)) + assertTrue(filter.process(mapOf("name" to "test2", "type" to "point", "color" to "blue"), 0.0)) + assertFalse(filter.process(mapOf("name" to "other", "type" to "point", "color" to "red"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test1", "type" to "line", "color" to "red"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test1", "type" to "point", "color" to "green"), 0.0)) + } + + @Test + fun testComplexNestedFilters() { + val filter = Filter.All( + listOf( + Filter.AnyOf( + listOf( + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test1") + ), + Filter.Eq( + FilterOperand.Get("name"), + FilterOperand.Literal("test2") + ) + ) + ), + Filter.All( + listOf( + Filter.NotInList( + FilterOperand.Get("type"), + listOf(FilterOperand.Literal("line")) + ), + Filter.AnyOf( + listOf( + Filter.Eq( + FilterOperand.Get("color"), + FilterOperand.Literal("red") + ), + Filter.Eq( + FilterOperand.Get("color"), + FilterOperand.Literal("blue") + ) + ) + ) + ) + ), + Filter.AnyOf( + listOf( + Filter.Eq( + FilterOperand.Get("size"), + FilterOperand.Literal("small") + ), + Filter.Eq( + FilterOperand.Get("size"), + FilterOperand.Literal("medium") + ) + ) + ) + ) + ) + assertTrue(filter.process(mapOf("name" to "test1", "type" to "point", "color" to "red", "size" to "small"), 0.0)) + assertTrue(filter.process(mapOf("name" to "test2", "type" to "point", "color" to "blue", "size" to "medium"), 0.0)) + assertFalse(filter.process(mapOf("name" to "other", "type" to "point", "color" to "red", "size" to "small"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test1", "type" to "line", "color" to "red", "size" to "small"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test1", "type" to "point", "color" to "green", "size" to "small"), 0.0)) + assertFalse(filter.process(mapOf("name" to "test1", "type" to "point", "color" to "red", "size" to "large"), 0.0)) + } + + @Test + fun testType() { + val filter = Filter.Type("point") + assertTrue(filter.process(mapOf("type" to "point"), 0.0)) + assertFalse(filter.process(mapOf("type" to "line"), 0.0)) + } + + @Test + fun testTypeWithOtherFilters() { + val filter = Filter.All( + listOf( + Filter.Type("point"), + Filter.Eq( + FilterOperand.Get("type"), + FilterOperand.Literal("point") + ) + ) + ) + assertTrue(filter.process(mapOf("type" to "point"), 0.0)) + assertFalse(filter.process(mapOf("type" to "line"), 0.0)) + } + + @Test + fun testTypeWithNestedFilters() { + val filter = Filter.All( + listOf( + Filter.AnyOf( + listOf( + Filter.Type("point"), + Filter.Type("line") + ) + ) + ) + ) + assertTrue(filter.process(mapOf("type" to "point"), 0.0)) + assertTrue(filter.process(mapOf("type" to "line"), 0.0)) + assertFalse(filter.process(mapOf("type" to "polygon"), 0.0)) + } + + @Test + fun testParseFilterJson() { + val json = """ + [ + "all", + ["in", "class", "residential", "suburb", "neighbourhood"] + ] + """.trimIndent() + + val filter = Json.decodeFromString(json) + assertTrue(filter is Filter.All) + assertEquals(1, filter.filters.size) + + val inFilter = filter.filters[0] + assertTrue(inFilter is Filter.InList) + assertTrue(inFilter.key is FilterOperand.Get) + assertEquals("class", inFilter.key.property) + assertEquals(3, inFilter.values.size) + assertTrue(inFilter.values.all { it is FilterOperand.Literal }) + assertEquals("residential", (inFilter.values[0] as FilterOperand.Literal).value) + assertEquals("suburb", (inFilter.values[1] as FilterOperand.Literal).value) + assertEquals("neighbourhood", (inFilter.values[2] as FilterOperand.Literal).value) + } + + @Test + fun testParseComplexFilterJson() { + val json = """ + [ + "all", + ["==", ["get", "type"], "Point"], + ["in", ["get", "class"], "bar", "cafe", "restaurant"], + ["has", "name"] + ] + """.trimIndent() + + val filter = Json.decodeFromString(json) + assertTrue(filter is Filter.All) + assertEquals(3, filter.filters.size) + + val typeFilter = filter.filters[0] + assertTrue(typeFilter is Filter.Eq) + assertTrue(typeFilter.left is FilterOperand.Get) + assertEquals("type", (typeFilter.left).property) + assertTrue(typeFilter.right is FilterOperand.Literal) + assertEquals("Point", (typeFilter.right).value) + + val inFilter = filter.filters[1] + assertTrue(inFilter is Filter.InList) + assertTrue(inFilter.key is FilterOperand.Get) + assertEquals("class", (inFilter.key).property) + assertEquals(3, inFilter.values.size) + assertTrue(inFilter.values.all { it is FilterOperand.Literal }) + assertEquals("bar", (inFilter.values[0] as FilterOperand.Literal).value) + assertEquals("cafe", (inFilter.values[1] as FilterOperand.Literal).value) + assertEquals("restaurant", (inFilter.values[2] as FilterOperand.Literal).value) + + val hasFilter = filter.filters[2] + assertTrue(hasFilter is Filter.Has) + assertEquals("name", hasFilter.key) + } + + @Test + fun testParseNestedFilterJson() { + val json = """ + [ + "all", + ["any", ["==", ["get", "class"], "primary"], ["==", ["get", "class"], "secondary"]], + ["!in", ["get", "class"], "bridge", "tunnel"] + ] + """.trimIndent() + + val filter = Json.decodeFromString(json) + assertTrue(filter is Filter.All) + assertEquals(2, filter.filters.size) + + val anyFilter = filter.filters[0] + assertTrue(anyFilter is Filter.AnyOf) + assertEquals(2, anyFilter.filters.size) + + val notInFilter = filter.filters[1] + assertTrue(notInFilter is Filter.NotInList) + assertTrue(notInFilter.key is FilterOperand.Get) + assertEquals("class", (notInFilter.key).property) + assertEquals(2, notInFilter.values.size) + assertTrue(notInFilter.values.all { it is FilterOperand.Literal }) + assertEquals("bridge", (notInFilter.values[0] as FilterOperand.Literal).value) + assertEquals("tunnel", (notInFilter.values[1] as FilterOperand.Literal).value) + } + + @Test + fun testParseTypeAndClassFilter() { + val json = """ + [ + "all", + ["==", "${TYPE_PROPERTY}", "Polygon"], + ["in", "class", "industrial", "garages", "dam"] + ] + """.trimIndent() + + val filter = Json.decodeFromString(json) + assertTrue(filter is Filter.All) + assertEquals(2, filter.filters.size) + + val typeFilter = filter.filters[0] + assertTrue(typeFilter is Filter.Eq) + assertTrue(typeFilter.left is FilterOperand.Get) + assertEquals(TYPE_PROPERTY, (typeFilter.left).property) + assertTrue(typeFilter.right is FilterOperand.Literal) + assertEquals("Polygon", (typeFilter.right).value) + + val inFilter = filter.filters[1] + assertTrue(inFilter is Filter.InList) + assertTrue(inFilter.key is FilterOperand.Get) + assertEquals("class", (inFilter.key).property) + assertEquals(3, inFilter.values.size) + assertTrue(inFilter.values.all { it is FilterOperand.Literal }) + assertEquals("industrial", (inFilter.values[0] as FilterOperand.Literal).value) + assertEquals("garages", (inFilter.values[1] as FilterOperand.Literal).value) + assertEquals("dam", (inFilter.values[2] as FilterOperand.Literal).value) + } + + @Test + fun testParseRiverBrunnelFilter() { + val json = """ + [ + "all", + ["in", "class", "river", "stream", "canal"], + ["==", "brunnel", "tunnel"] + ] + """.trimIndent() + + val filter = Json.decodeFromString(json) + assertTrue(filter is Filter.All) + assertEquals(2, filter.filters.size) + + val inFilter = filter.filters[0] + assertTrue(inFilter is Filter.InList) + assertTrue(inFilter.key is FilterOperand.Get) + assertEquals("class", (inFilter.key).property) + assertEquals(3, inFilter.values.size) + assertTrue(inFilter.values.all { it is FilterOperand.Literal }) + assertEquals("river", (inFilter.values[0] as FilterOperand.Literal).value) + assertEquals("stream", (inFilter.values[1] as FilterOperand.Literal).value) + assertEquals("canal", (inFilter.values[2] as FilterOperand.Literal).value) + + val eqFilter = filter.filters[1] + assertTrue(eqFilter is Filter.Eq) + assertTrue(eqFilter.left is FilterOperand.Get) + assertEquals("brunnel", (eqFilter.left).property) + assertTrue(eqFilter.right is FilterOperand.Literal) + assertEquals("tunnel", (eqFilter.right).value) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutTypeTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutTypeTest.kt new file mode 100644 index 00000000..d30cf5dc --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/LayoutTypeTest.kt @@ -0,0 +1,28 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import kotlin.test.Test +import kotlin.test.assertEquals + +class LayoutTypeTest { + @Test + fun `parse should handle different cases`() { + assertEquals(LayoutType.FILL, LayoutType.parse("fill")) + assertEquals(LayoutType.FILL, LayoutType.parse("FILL")) + assertEquals(LayoutType.FILL, LayoutType.parse("Fill")) + assertEquals(LayoutType.FILL, LayoutType.parse("fIlL")) + } + + @Test + fun `parse should handle hyphenated types`() { + assertEquals(LayoutType.FILL_EXTRUSION, LayoutType.parse("fill-extrusion")) + assertEquals(LayoutType.FILL_EXTRUSION, LayoutType.parse("FILL-EXTRUSION")) + assertEquals(LayoutType.FILL_EXTRUSION, LayoutType.parse("Fill-Extrusion")) + } + + @Test + fun `parse should return UNDEFINED for invalid input`() { + assertEquals(LayoutType.UNDEFINED, LayoutType.parse("invalid")) + assertEquals(LayoutType.UNDEFINED, LayoutType.parse("")) + assertEquals(LayoutType.UNDEFINED, LayoutType.parse(" ")) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleBright.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleBright.kt new file mode 100644 index 00000000..7a2faba4 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleBright.kt @@ -0,0 +1,134 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.produceState +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.test.ExperimentalTestApi +import androidx.compose.ui.test.runComposeUiTest +import kotlinx.io.Buffer +import kotlinx.io.RawSource +import org.jetbrains.compose.resources.ExperimentalResourceApi +import mapcompose_mp.library.generated.resources.Res +import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +import ovh.plrapps.mapcompose.vector.data.getMapLibreConfiguration +import ovh.plrapps.mapcompose.vector.spec.style.props.Expr +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertTrue + +@OptIn(ExperimentalTestApi::class) +class TestParseStyleBright { + + @OptIn(ExperimentalResourceApi::class) + @Test + fun `style_bright correct parsed`() = runComposeUiTest { + var simpleStyle: MapLibreConfiguration? = null + val loadResource: suspend (String) -> RawSource? = { url -> + when { + url.endsWith(".json") -> { + val resource = Res.readBytes("files/test_style_bright_sprite.json") + val buffer = Buffer() + buffer.write(resource) + buffer + } + url.endsWith(".png") -> { + val resource = Res.readBytes("files/test_style_bright_sprite.png") + val buffer = Buffer() + buffer.write(resource) + buffer + } + else -> null + } + } + + setContent { + val style by produceState(null) { + value = Res.readBytes("files/test_style_bright.json").decodeToString().let { source -> + getMapLibreConfiguration(style = source, loadResource = loadResource).getOrThrow() + } + } + simpleStyle = style + } + + waitUntil(timeoutMillis = 5000) { + simpleStyle != null + } + + val style = simpleStyle!!.style + + + assertEquals(8, style.version) + assertEquals("Bright", style.name) + assertEquals(listOf(0.0, 0.0), style.center) + assertEquals(1f, style.zoom) + assertEquals(0.0, style.bearing) + assertEquals(0.0, style.pitch) + + + val sources = style.sources + assertNotNull(sources) + assertEquals(1, sources.size) + + val openmaptiles = sources["openmaptiles"] + assertNotNull(openmaptiles) + assertEquals("vector", openmaptiles.type) + assertEquals(0, openmaptiles.minzoom) + assertEquals(14, openmaptiles.maxzoom) + assertNotNull(openmaptiles.tiles) + assertTrue(openmaptiles.tiles.isNotEmpty()) + assertNotNull(openmaptiles.attribution) + assertTrue(openmaptiles.attribution.contains("MapTiler")) + assertTrue(openmaptiles.attribution.contains("OpenStreetMap")) + + assertEquals("https://openmaptiles.github.io/osm-bright-gl-style/sprite", style.sprites.firstOrNull()?.url) + assertEquals("https://api.maptiler.com/fonts/{fontstack}/{range}.pbf?key={key}", style.glyphs) + + + val layers = style.layers + assertNotNull(layers) + assertTrue(layers.isNotEmpty()) + + val backgroundLayer = layers.find { it.id == "background" } as BackgroundLayer + assertNotNull(backgroundLayer) + assertEquals("background", backgroundLayer.type) + val bgColor = backgroundLayer.paint?.backgroundColor?.process() + assertEquals(Color(0xFFF8F4F0), bgColor) + + val landuseLayer = layers.find { it.id == "landuse-residential" } as FillLayer + assertNotNull(landuseLayer) + assertEquals("fill", landuseLayer.type) + assertEquals("openmaptiles", landuseLayer.source) + assertEquals("landuse", landuseLayer.sourceLayer) + + val landuseColor = landuseLayer.paint?.fillColor + assertNotNull(landuseColor) + assertTrue(landuseColor is ExpressionOrValue.Expression) + val interpolateExpr = landuseColor + assertTrue(interpolateExpr.expr is Expr.Interpolate) + val landuseStops = interpolateExpr.expr.stops + assertEquals(2, landuseStops.size) + assertEquals(Pair(12.0, Expr.Constant(Color.hsl(30f, 0.19f, 0.9f, 0.4f))), landuseStops[0]) + assertEquals(Pair(16.0, Expr.Constant(Color.hsl(30f, 0.19f, 0.9f, 0.2f))), landuseStops[1]) + + val waterwayLayer = layers.find { it.id == "waterway_tunnel" } as LineLayer + assertNotNull(waterwayLayer) + assertEquals("line", waterwayLayer.type) + assertEquals("openmaptiles", waterwayLayer.source) + assertEquals("waterway", waterwayLayer.sourceLayer) + + val lineWidth = waterwayLayer.paint?.lineWidth + assertNotNull(lineWidth) + assertTrue(lineWidth is ExpressionOrValue.Expression) + val lineWidthExpr = lineWidth + assertTrue(lineWidthExpr.expr is Expr.Interpolate) + val waterwayStops = lineWidthExpr.expr.stops + assertEquals(2, waterwayStops.size) + assertEquals(Pair(13.0, Expr.Constant(0.5)), waterwayStops[0]) + assertEquals(Pair(20.0, Expr.Constant(6.0)), waterwayStops[1]) + + val lineColor = waterwayLayer.paint.lineColor?.process() + assertEquals(Color(0xFFA0C8F0), lineColor) + } +} diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleSimple.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleSimple.kt new file mode 100644 index 00000000..844929ac --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleSimple.kt @@ -0,0 +1,127 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.produceState +import androidx.compose.ui.test.ExperimentalTestApi +import androidx.compose.ui.test.runComposeUiTest +import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +import ovh.plrapps.mapcompose.vector.data.getMapLibreConfiguration +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertTrue +import androidx.compose.ui.graphics.Color +import kotlinx.io.RawSource +import org.jetbrains.compose.resources.ExperimentalResourceApi +import mapcompose_mp.library.generated.resources.Res +import ovh.plrapps.mapcompose.vector.spec.style.props.Expr +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue + +@OptIn(ExperimentalTestApi::class) +class TestParseStyleSimple { + + @OptIn(ExperimentalResourceApi::class) + @Test + fun `style_simple correct parsed`() = runComposeUiTest { + var simpleStyle: MapLibreConfiguration? = null + val loadResource: suspend (String) -> RawSource? = { null } + + setContent { + val style by produceState(null) { + value = Res.readBytes("files/test_style_simple.json").decodeToString().let { source -> + getMapLibreConfiguration(style = source, loadResource = loadResource).getOrThrow() + } + } + simpleStyle = style + } + + waitUntil(timeoutMillis = 5000) { + simpleStyle != null + } + + val style = simpleStyle!!.style + + assertEquals(8, style.version) + assertEquals("MapLibre", style.name) + assertEquals(listOf(17.65431710431244, 32.954120326746775), style.center) + assertEquals(0f, style.zoom) + assertEquals(0.0, style.bearing) + assertEquals(0.0, style.pitch) + + val sources = style.sources + assertNotNull(sources) + assertEquals(1, sources.size) + val maplibreSource = sources["maplibre"] + assertNotNull(maplibreSource) + assertEquals("vector", maplibreSource.type) + + val layers = style.layers + assertNotNull(layers) + assertTrue(layers.isNotEmpty()) + + val backgroundLayer = layers.find { it.id == "background" } as BackgroundLayer + assertNotNull(backgroundLayer) + assertEquals("background", backgroundLayer.type) + val bgColor = backgroundLayer.paint?.backgroundColor?.process() + println("backgroundLayer.paint?.backgroundColor?.process() = $bgColor") + assertEquals(Color(0xFFD8F2FF), bgColor) + + val coastlineLayer = layers.find { it.id == "coastline" } as LineLayer + assertNotNull(coastlineLayer) + assertEquals("line", coastlineLayer.type) + val lineWidth = coastlineLayer.paint?.lineWidth + assertNotNull(lineWidth) + assertTrue(lineWidth is ExpressionOrValue.Expression) + val lineWidthExpr = lineWidth + assertTrue(lineWidthExpr.expr is Expr.Interpolate) + val stops = lineWidthExpr.expr.stops + assertEquals(4, stops.size) + assertEquals(Pair(0.0, Expr.Constant(2.0)), stops[0]) + assertEquals(Pair(6.0, Expr.Constant(6.0)), stops[1]) + assertEquals(Pair(14.0, Expr.Constant(9.0)), stops[2]) + assertEquals(Pair(22.0, Expr.Constant(18.0)), stops[3]) + val coastColor = coastlineLayer.paint.lineColor?.process() + println("coastlineLayer.paint?.lineColor?.process() = $coastColor") + assertEquals(Color(0xFF198EC8), coastColor) + assertEquals(0.5, coastlineLayer.paint.lineBlur?.process()) + + val countriesFillLayer = layers.find { it.id == "countries-fill" } as FillLayer + assertNotNull(countriesFillLayer) + val fillColor = countriesFillLayer.paint?.fillColor + assertNotNull(fillColor) + assertTrue(fillColor is ExpressionOrValue.Expression) + val matchExpr = fillColor + assertTrue(matchExpr.expr is Expr.Match) + val match = matchExpr.expr + assertNotNull(match.input) + assertTrue(match.input is Expr.Get<*>) + assertEquals("ADM0_A3", ((match.input).property as Expr.Constant).value) + assertTrue(match.branches.isNotEmpty()) + val firstBranch = match.branches[0] + println("firstBranch.first = ${firstBranch.first}") + println("firstBranch.second = ${firstBranch.second}") + println("firstBranch.second::class = ${firstBranch.second::class}") + assertTrue((firstBranch.first as List<*>).map { it.toString() }.contains("ARM")) + assertEquals(Color(0xFFD6C7FF), (firstBranch.second as Expr.Constant).value) + assertEquals(Color(0xFFEAB38F), (match.elseExpr as Expr.Constant).value) + + val geolinesLayer = layers.find { it.id == "geolines" } as LineLayer + assertNotNull(geolinesLayer) + + val countriesLabelLayer = layers.find { it.id == "countries-label" } as SymbolLayer + println("countriesLabelLayer = $countriesLabelLayer") + assertNotNull(countriesLabelLayer) + val textField = countriesLabelLayer.layout?.textField + println("textField = $textField") + assertNotNull(textField) + assertTrue(textField is ExpressionOrValue.Expression) + val textFieldExpr = textField + println("textFieldExpr.expr = ${textFieldExpr.expr}") + assertTrue(textFieldExpr.expr is Expr.Interpolate) + + val textFieldStops = textFieldExpr.expr.stops + assertEquals(2, textFieldStops.size) + assertEquals(Pair(2.0, Expr.Constant("{ABBREV}")), textFieldStops[0]) + assertEquals(Pair(4.0, Expr.Constant("{NAME}")), textFieldStops[1]) + } +} diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleStreetV2.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleStreetV2.kt new file mode 100644 index 00000000..4c369deb --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleStreetV2.kt @@ -0,0 +1,126 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.produceState +import androidx.compose.ui.test.ExperimentalTestApi +import androidx.compose.ui.test.runComposeUiTest +import ovh.plrapps.mapcompose.vector.data.MapLibreConfiguration +import ovh.plrapps.mapcompose.vector.data.getMapLibreConfiguration +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertTrue +import androidx.compose.ui.graphics.Color +import kotlinx.io.Buffer +import kotlinx.io.RawSource +import org.jetbrains.compose.resources.ExperimentalResourceApi +import mapcompose_mp.library.generated.resources.Res +import ovh.plrapps.mapcompose.vector.spec.style.props.Expr +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue + +@OptIn(ExperimentalTestApi::class) +class TestParseStyleStreetV2 { + + @OptIn(ExperimentalResourceApi::class) + @Test + fun `style_streetV2 correct parsed`() = runComposeUiTest { + var styleStreetV2: MapLibreConfiguration? = null + val loadResource: suspend (String) -> RawSource? = { url -> + when { + url.endsWith(".json") -> { + val resource = Res.readBytes("files/test_style_street_v2_sprite.json") + val buffer = Buffer() + buffer.write(resource) + buffer + } + url.endsWith(".png") -> { + val resource = Res.readBytes("files/test_style_street_v2_sprite.png") + val buffer = Buffer() + buffer.write(resource) + buffer + } + else -> null + } + } + + setContent { + val style by produceState(null) { + value = Res.readBytes("files/test_style_street_v2.json").decodeToString().let { source -> + getMapLibreConfiguration(style = source, loadResource = loadResource).getOrThrow() + } + } + styleStreetV2 = style + } + + waitUntil(timeoutMillis = 5000) { + styleStreetV2 != null + } + + val style = styleStreetV2!!.style + + assertEquals(8, style.version) + assertEquals("streets-v2", style.id) + assertEquals("Streets", style.name) + + val sources = style.sources + assertNotNull(sources) + assertEquals(2, sources.size) + + val maptilerAttribution = sources["maptiler_attribution"] + assertNotNull(maptilerAttribution) + assertEquals("vector", maptilerAttribution.type) + assertTrue(maptilerAttribution.attribution?.contains("MapTiler") == true) + + val maptilerPlanet = sources["maptiler_planet"] + assertNotNull(maptilerPlanet) + assertEquals("vector", maptilerPlanet.type) + assertEquals(0, maptilerPlanet.minzoom) + assertEquals(15, maptilerPlanet.maxzoom) + assertTrue(maptilerPlanet.tiles?.first()?.contains("api.maptiler.com") == true) + + val layers = style.layers + assertNotNull(layers) + assertTrue(layers.isNotEmpty()) + + val backgroundLayer = layers.find { it.id == "Background" } as BackgroundLayer + assertNotNull(backgroundLayer) + assertEquals("background", backgroundLayer.type) + val bgColor = backgroundLayer.paint?.backgroundColor + assertNotNull(bgColor) + assertTrue(bgColor is ExpressionOrValue.Expression) + val bgColorExpr = bgColor + assertTrue(bgColorExpr.expr is Expr.Interpolate) + val bgStops = bgColorExpr.expr.stops + assertEquals(2, bgStops.size) + assertEquals(Pair(6.0, Expr.Constant(Color.hsl( 47F, 0.79F, 0.94F))), bgStops[0]) + assertEquals(Pair(14.0, Expr.Constant(Color.hsl(42F, 0.49f, 0.93f))), bgStops[1]) + + val meadowLayer = layers.find { it.id == "Meadow" } as FillLayer + assertNotNull(meadowLayer) + assertEquals("fill", meadowLayer.type) + assertEquals("maptiler_planet", meadowLayer.source) + assertEquals("globallandcover", meadowLayer.sourceLayer) + assertEquals(8.toDouble(), meadowLayer.maxzoom) + val fillColor = meadowLayer.paint?.fillColor + assertNotNull(fillColor) + assertTrue(fillColor is ExpressionOrValue.Value) + assertEquals(Color.hsl(75f,0.51f,0.85f), fillColor.value) + val meadowColor = fillColor.process(null, null) + assertEquals(Color.hsl(hue = 75F, saturation = 0.51f, lightness = 0.85f), meadowColor) + val meadowOpacity = meadowLayer.paint.fillOpacity + assertNotNull(meadowOpacity) + assertTrue(meadowOpacity is ExpressionOrValue.Expression) + val meadowOpacityExpr = meadowOpacity as ExpressionOrValue.Expression<*> + assertTrue(meadowOpacityExpr.expr is Expr.Interpolate) + val meadowOpacityStops = meadowOpacityExpr.expr.stops + assertEquals(2, meadowOpacityStops.size) + assertEquals(Pair(0.0, Expr.Constant(1.0)), meadowOpacityStops[0]) + assertEquals(Pair(8.0, Expr.Constant(0.1)), meadowOpacityStops[1]) + + val forestLayer = layers.find { it.id == "Forest" } as FillLayer + assertNotNull(forestLayer) + assertEquals("fill", forestLayer.type) + val forestFilter = forestLayer.filter + assertNotNull(forestFilter) + } +} diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleSwisstopo.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleSwisstopo.kt new file mode 100644 index 00000000..b0c70ae3 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/TestParseStyleSwisstopo.kt @@ -0,0 +1,39 @@ +package ovh.plrapps.mapcompose.vector.spec.style + +import androidx.compose.runtime.getValue +import androidx.compose.runtime.produceState +import androidx.compose.ui.test.ExperimentalTestApi +import androidx.compose.ui.test.runComposeUiTest +import kotlin.test.Test +import kotlin.test.assertTrue +import org.jetbrains.compose.resources.ExperimentalResourceApi +import mapcompose_mp.library.generated.resources.Res +import ovh.plrapps.mapcompose.vector.data.json + +@OptIn(ExperimentalTestApi::class) +class TestParseStyleSwisstopo { + + @OptIn(ExperimentalResourceApi::class) + @Test + fun `style_swisstopo parses without error`() = runComposeUiTest { + var style: MapLibreStyle? = null + + setContent { + val result by produceState(null) { + val content = Res.readBytes("files/test_style_swisstopo.json").decodeToString() + value = json.decodeFromString(content) + } + style = result + } + + waitUntil(timeoutMillis = 5000) { style != null } + + val layers = style!!.layers + assertTrue(layers.isNotEmpty()) + + // Exercise every filter: verifies both deserialization and evaluation don't throw + for (layer in layers) { + layer.filter?.process(emptyMap(), 10.0) + } + } +} diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ConcatExpressionTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ConcatExpressionTest.kt new file mode 100644 index 00000000..c76b0f6b --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ConcatExpressionTest.kt @@ -0,0 +1,92 @@ +package ovh.plrapps.mapcompose.vector.spec.style.props + +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ExpressionOrValueSerializer +import kotlinx.serialization.json.Json +import kotlinx.serialization.builtins.ListSerializer +import kotlinx.serialization.builtins.serializer +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class ConcatExpressionTest { + private val json = Json { ignoreUnknownKeys = true } + + @Test + fun `test concat expression with constant arrays`() { + val expr = Expr.Concat>( + left = Expr.Constant(listOf("a", "b")), + right = Expr.Constant(listOf("c", "d")) + ) + + val result = expr.evaluate(emptyMap(), null) + assertTrue(result is List<*>) + assertEquals(4, result.size) + assertEquals(listOf("a", "b", "c", "d"), result) + } + + @Test + fun `test concat expression with get arrays`() { + val properties = mapOf( + "array1" to listOf("x", "y"), + "array2" to listOf("z", "w") + ) + + val expr = Expr.Concat>( + left = Expr.Get(Expr.Constant("array1")), + right = Expr.Get(Expr.Constant("array2")) + ) + + val result = expr.evaluate(properties, null) + assertTrue(result is List<*>) + assertEquals(4, result.size) + assertEquals(listOf("x", "y", "z", "w"), result) + } + + @Test + fun `test concat expression with mixed types`() { + val properties = mapOf( + "numbers" to listOf(1, 2), + "strings" to listOf("a", "b") + ) + + val expr = Expr.Concat( + left = Expr.Get(Expr.Constant("numbers")), + right = Expr.Get(Expr.Constant("strings")) + ) + + val result = expr.evaluate(properties, null) + assertTrue(result is List<*>) + assertEquals(4, result.size) + assertEquals(listOf(1, 2, "a", "b"), result) + } + + @Test + fun `test concat expression with null values`() { + val expr = Expr.Concat( + left = Expr.Get(Expr.Constant("nonexistent1")), + right = Expr.Get(Expr.Constant("nonexistent2")) + ) + + val result = expr.evaluate(emptyMap(), null) + assertEquals(null, result) + } + + @Test + fun `test concat expression deserialization`() { + val jsonStr = """["concat",["get","array1"],["get","array2"]]""" + val deserialized = json.decodeFromString( + ExpressionOrValueSerializer(ListSerializer(String.serializer())), + jsonStr + ) + + assertTrue(deserialized is ExpressionOrValue.Expression<*>) + val expression = deserialized as ExpressionOrValue.Expression> + assertTrue(expression.expr is Expr.Concat<*>) + + val concatExpr = expression.expr as Expr.Concat + assertTrue(concatExpr.left is Expr.Get<*>) + assertTrue(concatExpr.right is Expr.Get<*>) + assertEquals("array1", ((concatExpr.left as Expr.Get<*>).property as Expr.Constant).value) + assertEquals("array2", ((concatExpr.right as Expr.Get<*>).property as Expr.Constant).value) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValueColorInterpolateTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValueColorInterpolateTest.kt new file mode 100644 index 00000000..9ca0a29c --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValueColorInterpolateTest.kt @@ -0,0 +1,103 @@ +package ovh.plrapps.mapcompose.vector.spec.style.props + +import ovh.plrapps.mapcompose.vector.data.json +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ColorSerializer +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ExpressionOrValueSerializer +import kotlinx.serialization.builtins.serializer +import kotlin.test.Test +import kotlin.test.assertTrue +import kotlin.test.assertEquals + +class ExpressionOrValueColorInterpolateTest { + @Test + fun `deserialize interpolate with case`() { + val jsonStr = """["interpolate",["linear",1],["zoom"],3,0.75,4,0.8,11,["case",["<=",["get","admin_level"],6],1.75,1.5],18,["case",["<=",["get","admin_level"],6],3,2]]""" + val exprOrValue = json.decodeFromString(ExpressionOrValueSerializer(Float.serializer()), jsonStr) + // TODO, need to finish + assertTrue(exprOrValue is ExpressionOrValue.Expression) + } + + @Test + fun `deserialize interpolate with match and colors`() { + val jsonStr = """ + [ + "interpolate", + ["linear"], + ["zoom"], + 9, + [ + "match", + ["get", "class"], + ["industrial"], "hsl(40,67%,90%)", + "quarry", "hsla(32, 47%, 87%, 0.2)", + "hsl(60, 31%, 87%)" + ], + 16, + [ + "match", + ["get", "class"], + ["industrial"], "hsl(49,54%,90%)", + "quarry", "hsla(32, 47%, 87%, 0.5)", + "hsl(60, 31%, 87%)" + ] + ] + """.trimIndent() + + val exprOrValue = json.decodeFromString(ExpressionOrValueSerializer(ColorSerializer), jsonStr) + exprOrValue.process() + assertTrue(exprOrValue is ExpressionOrValue.Expression) + val expr = (exprOrValue).expr + assertTrue(expr is Expr.Interpolate) + val interpolate = expr + assertEquals(2, interpolate.stops.size) + interpolate.stops.forEach { (_, value) -> + assertTrue(value is Expr.Match<*> || value is Expr.Constant<*>) + } + } + + @Test + fun `deserialize step expression`() { + val jsonStr = """["step",["zoom"],1,9,["match",["get","class"],"quarry",0,1],10,1]""" + val exprOrValue = json.decodeFromString(ExpressionOrValueSerializer(Float.serializer()), jsonStr) + + assertTrue(exprOrValue is ExpressionOrValue.Expression) + val expr = (exprOrValue as ExpressionOrValue.Expression<*>).expr + assertTrue(expr is Expr.Step) + + val step = expr as Expr.Step<*> + assertEquals(Expr.Zoom, step.input) + assertEquals(Expr.Constant(1.0f), step.default) + assertEquals(2, step.stops.size) + + val (stop1, value1) = step.stops[0] + assertEquals(9.0, stop1) + assertTrue(value1 is Expr.Match<*>) + + val (stop2, value2) = step.stops[1] + assertEquals(10.0, stop2) + assertTrue(value2 is Expr.Constant<*>) + assertEquals(1.0f, (value2 as Expr.Constant<*>).value) + } + + @Test + fun `deserialize interpolate and process`() { + val jsonStr = """{ + "stops": [ + [ + 2, + "{ABBREV}" + ], + [ + 4, + "{NAME}" + ] + ] + }""" + val featureProperties = mapOf("NAME" to "United Kingdom", "ABBREV" to "U.K.") + val textField = json.decodeFromString(ExpressionOrValueSerializer(String.serializer()), jsonStr) + assertEquals("{ABBREV}", textField.process(featureProperties, zoom = 2.0)) + assertEquals("{ABBREV}", textField.process(featureProperties, zoom = 3.0)) + assertEquals("{NAME}", textField.process(featureProperties, zoom = 4.0)) + assertEquals("{NAME}", textField.process(featureProperties, zoom = 5.0)) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValueTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValueTest.kt new file mode 100644 index 00000000..dc9d1979 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/ExpressionOrValueTest.kt @@ -0,0 +1,420 @@ +package ovh.plrapps.mapcompose.vector.spec.style.props + +import androidx.compose.ui.graphics.Color +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ExpressionOrValueSerializer +import kotlinx.serialization.json.* +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull +import kotlin.test.assertTrue +import kotlin.test.assertFalse +import kotlinx.serialization.builtins.serializer +import ovh.plrapps.mapcompose.vector.data.json + +class ExpressionOrValueTest { + @Test + fun `Value should return its value`() { + val value: ExpressionOrValue = ExpressionOrValue.Value(42) + assertEquals(42, value.process()) + } + + @Test + fun `Expression with Get should return property value`() { + val expr: ExpressionOrValue = ExpressionOrValue.Expression(Expr.Get(Expr.Constant("name"))) + val properties = mapOf("name" to "test") + assertEquals("test", expr.process(featureProperties = properties)) + } + + @Test + fun `Expression with Match should return correct value`() { + val matchExpr = Expr.Match( + input = Expr.Get(Expr.Constant("type")), + branches = listOf( + listOf("residential") to Expr.Constant("local") + ), + elseExpr = Expr.Constant("other") + ) + val expr: ExpressionOrValue = ExpressionOrValue.Expression(matchExpr) + + val matchingProps = mapOf("type" to "residential") + assertEquals("local", expr.process(featureProperties = matchingProps)) + + val nonMatchingProps = mapOf("type" to "commercial") + assertEquals("other", expr.process(featureProperties = nonMatchingProps)) + } + + @Test + fun `Expression with ZoomStops should return correct value`() { + val stops = listOf( + 10.0 to Expr.Constant("small"), + 14.0 to Expr.Constant("medium"), + 18.0 to Expr.Constant("large") + ) + val expr: ExpressionOrValue = ExpressionOrValue.Expression(Expr.ZoomStops(stops)) + + assertEquals("small", expr.process(zoom = 8.0)) + assertEquals("small", expr.process(zoom = 12.0)) + assertEquals("medium", expr.process(zoom = 16.0)) + assertEquals("large", expr.process(zoom = 20.0)) + } + + @Test + fun `Expression with Interpolate Linear should interpolate numbers`() { + val interpolateExpr = Expr.Interpolate( + interpolation = InterpolationType.Linear, + input = Expr.Zoom, + stops = listOf( + 0.0 to Expr.Constant(0.0), + 10.0 to Expr.Constant(100.0) + ) + ) + val expr: ExpressionOrValue = ExpressionOrValue.Expression(interpolateExpr) + + // value Interpolated + assertEquals(50.0, expr.process(zoom = 5.0)) + } + + @Test + fun `Expression with Constant should return its value`() { + val expr: ExpressionOrValue = ExpressionOrValue.Expression(Expr.Constant("test")) + assertEquals("test", expr.process()) + } + + @Test + fun `Expression with Raw should return null`() { + val expr: ExpressionOrValue = + ExpressionOrValue.Expression(Expr.Raw(JsonNull)) + assertNull(expr.process()) + } + + @Test + fun `process should handle null properties and zoom`() { + val expr: ExpressionOrValue = ExpressionOrValue.Expression(Expr.Get(Expr.Constant("name"))) + assertNull(expr.process()) + assertNull(expr.process(featureProperties = emptyMap())) + } + + @Test + fun testNotEqualsExpressionWithConstants() { + val expr = Expr.NotEquals( + left = Expr.Constant("value1"), + right = Expr.Constant("value2") + ) + + val result = expr.evaluate(emptyMap(), 0.0) + assertTrue(result == true) + + val expr2 = Expr.NotEquals( + left = Expr.Constant("same"), + right = Expr.Constant("same") + ) + + val result2 = expr2.evaluate(emptyMap(), 0.0) + assertTrue(result2 == false) + } + + @Test + fun testNotEqualsExpressionWithGet() { + val properties = mapOf( + "prop1" to "value1", + "prop2" to "value2", + "prop3" to "value1" + ) + + val expr1 = Expr.NotEquals( + left = Expr.Get(Expr.Constant("prop1")), + right = Expr.Get(Expr.Constant("prop2")) + ) + assertTrue(expr1.evaluate(properties, 0.0) == true) + + val expr2 = Expr.NotEquals( + left = Expr.Get(Expr.Constant("prop1")), + right = Expr.Get(Expr.Constant("prop3")) + ) + assertTrue(expr2.evaluate(properties, 0.0) == false) + } + + @Test + fun testNotEqualsExpressionWithMixedTypes() { + val properties = mapOf( + "number" to 42, + "text" to "42" + ) + + val expr = Expr.NotEquals( + left = Expr.Get(Expr.Constant("number")), + right = Expr.Get(Expr.Constant("text")) + ) + assertTrue(expr.evaluate(properties, 0.0) == true) + } + + @Test + fun testNotEqualsExpressionWithNullValues() { + val properties = mapOf( + "existing" to "value", + "nullValue" to null + ) + + val expr1 = Expr.NotEquals( + left = Expr.Get(Expr.Constant("existing")), + right = Expr.Get(Expr.Constant("nonexistent")) + ) + assertTrue(expr1.evaluate(properties, 0.0) == true) + + val expr2 = Expr.NotEquals( + left = Expr.Get(Expr.Constant("nullValue")), + right = Expr.Get(Expr.Constant("nonexistent")) + ) + assertTrue(expr2.evaluate(properties, 0.0) == false) + } + + @Test + fun testEqualsExpressionWithConstants() { + val expr = Expr.Equals( + left = Expr.Constant("value1"), + right = Expr.Constant("value2") + ) + + val result = expr.evaluate(emptyMap(), 0.0) + assertTrue(result == false) + + val expr2 = Expr.Equals( + left = Expr.Constant("same"), + right = Expr.Constant("same") + ) + + val result2 = expr2.evaluate(emptyMap(), 0.0) + assertTrue(result2 == true) + } + + @Test + fun testEqualsExpressionWithGet() { + val properties = mapOf( + "prop1" to "value1", + "prop2" to "value2", + "prop3" to "value1" + ) + + val expr1 = Expr.Equals( + left = Expr.Get(Expr.Constant("prop1")), + right = Expr.Get(Expr.Constant("prop2")) + ) + assertTrue(expr1.evaluate(properties, 0.0) == false) + + val expr2 = Expr.Equals( + left = Expr.Get(Expr.Constant("prop1")), + right = Expr.Get(Expr.Constant("prop3")) + ) + assertTrue(expr2.evaluate(properties, 0.0) == true) + } + + @Test + fun testEqualsExpressionWithMixedTypes() { + val properties = mapOf( + "number" to 42, + "text" to "42" + ) + + val expr = Expr.Equals( + left = Expr.Get(Expr.Constant("number")), + right = Expr.Get(Expr.Constant("text")) + ) + assertTrue(expr.evaluate(properties, 0.0) == false) + } + + @Test + fun testEqualsExpressionWithNullValues() { + val properties = mapOf( + "existing" to "value", + "nullValue" to null + ) + + val expr1 = Expr.Equals( + left = Expr.Get(Expr.Constant("existing")), + right = Expr.Get(Expr.Constant("nonexistent")) + ) + assertTrue(expr1.evaluate(properties, 0.0) == false) + + val expr2 = Expr.Equals( + left = Expr.Get(Expr.Constant("nullValue")), + right = Expr.Get(Expr.Constant("nonexistent")) + ) + assertTrue(expr2.evaluate(properties, 0.0) == true) + } + + @Test + fun testToBooleanExpression() { + val nullExpr = Expr.ToBoolean(Expr.Constant(null)) + assertTrue(nullExpr.evaluate(null, null) == false) + + val emptyStringExpr = Expr.ToBoolean(Expr.Constant("")) + assertTrue(emptyStringExpr.evaluate(null, null) == false) + + val nonEmptyStringExpr = Expr.ToBoolean(Expr.Constant("test")) + assertTrue(nonEmptyStringExpr.evaluate(null, null) == true) + + val zeroExpr = Expr.ToBoolean(Expr.Constant(0)) + assertTrue(zeroExpr.evaluate(null, null) == false) + + val nonZeroExpr = Expr.ToBoolean(Expr.Constant(42)) + assertTrue(nonZeroExpr.evaluate(null, null) == true) + + val nanExpr = Expr.ToBoolean(Expr.Constant(Double.NaN)) + assertTrue(nanExpr.evaluate(null, null) == false) + + val trueExpr = Expr.ToBoolean(Expr.Constant(true)) + assertTrue(trueExpr.evaluate(null, null) == true) + + val falseExpr = Expr.ToBoolean(Expr.Constant(false)) + assertTrue(falseExpr.evaluate(null, null) == false) + + val objectExpr = Expr.ToBoolean(Expr.Constant(mapOf("key" to "value"))) + assertTrue(objectExpr.evaluate(null, null) == true) + } + + @Test + fun testToStringExpression() { + val nullExpr = Expr.ToString(Expr.Constant(null)) + assertEquals("", nullExpr.evaluate(null, null)) + + val emptyStringExpr = Expr.ToString(Expr.Constant("")) + assertEquals("", emptyStringExpr.evaluate(null, null)) + + val nonEmptyStringExpr = Expr.ToString(Expr.Constant("test")) + assertEquals("test", nonEmptyStringExpr.evaluate(null, null)) + + val trueExpr = Expr.ToString(Expr.Constant(true)) + assertEquals("true", trueExpr.evaluate(null, null)) + + val falseExpr = Expr.ToString(Expr.Constant(false)) + assertEquals("false", falseExpr.evaluate(null, null)) + + val numberExpr = Expr.ToString(Expr.Constant(42)) + assertEquals("42", numberExpr.evaluate(null, null)) + + val doubleExpr = Expr.ToString(Expr.Constant(3.14)) + assertEquals("3.14", doubleExpr.evaluate(null, null)) + + val colorExpr = Expr.ToString(Expr.Constant(Color(255, 0, 0, 128))) + assertEquals("rgba(255,0,0,0.5)", colorExpr.evaluate(null, null)) + + val objectExpr = Expr.ToString(Expr.Constant(mapOf("key" to "value"))) + assertEquals("""{"key":"value"}""", objectExpr.evaluate(null, null)) + + val arrayExpr = Expr.ToString(Expr.Constant(listOf(1, 2, 3))) + assertEquals("[1,2,3]", arrayExpr.evaluate(null, null)) + } + + @Test + fun `isExpression returns true for array with string first element`() { + val input = JsonArray(listOf(JsonPrimitive("get"), JsonPrimitive("name"))) + assertTrue(ExpressionOrValue.isExpression(input)) + } + + @Test + fun `isExpression returns false for empty array`() { + val input = JsonArray(emptyList()) + assertFalse(ExpressionOrValue.isExpression(input)) + } + + @Test + fun `isExpression returns false for array with non-string first element`() { + val input = JsonArray(listOf(JsonPrimitive(1), JsonPrimitive("name"))) + assertFalse(ExpressionOrValue.isExpression(input)) + } + + @Test + fun `isExpression returns true for object with stops property`() { + val input = JsonObject(mapOf("stops" to JsonArray(emptyList()))) + assertTrue(ExpressionOrValue.isExpression(input)) + } + + @Test + fun `isExpression returns false for object without stops property`() { + val input = JsonObject(mapOf("color" to JsonPrimitive("red"))) + assertFalse(ExpressionOrValue.isExpression(input)) + } + + @Test + fun `isExpression returns false for primitive value`() { + val input = JsonPrimitive("test") + assertFalse(ExpressionOrValue.isExpression(input)) + } + + @Test + fun `isExpression work 001`() { + val input = + ("""[ "match", [ "get", "class" ], [ "college", "childcare", "dancing_school", "driving_school", "kindergarten", "school", "university" ], [ "get", "class" ], [ "case", [ "has", "class" ], "", "dot" ] ]""") + val expr = json.decodeFromString>(input) + val feature = mapOf( + "class" to "school", + "name" to "Детский сад № 14", + "name:latin" to "Detskij sad № 14", + "name:nonlatin" to "Детский сад № 14", + "name_de" to "Детский сад № 14", + "name_en" to "Детский сад № 14", + "name_int" to "Detskij sad № 14", + "rank" to 11, + "subclass" to "kindergarten", + "\$type" to "Point" + ) + val result = expr.process(feature, 15.0) + assertEquals("school", result) + } + + @Test + fun `test case expression with equals condition`() { + val jsonStr = """ + [ + "case", + [ + "==", + [ + "get", + "brunnel" + ], + "tunnel" + ], + 0.7, + 1 + ] + """.trimIndent() + + val json = Json { ignoreUnknownKeys = true } + val exprOrValue = json.decodeFromString(ExpressionOrValueSerializer(Double.serializer()), jsonStr) + + assertTrue(exprOrValue is ExpressionOrValue.Expression) + val expr = (exprOrValue).expr + + assertTrue(expr is Expr.Case) + val caseExpr = expr + + assertEquals(1, caseExpr.conditions.size) + + val (condition, result) = caseExpr.conditions[0] + assertTrue(condition is Expr.Equals<*, *>) + val equalsExpr = condition + + assertTrue(equalsExpr.left is Expr.Get<*>) + val getExpr = equalsExpr.left + assertEquals("brunnel", (getExpr.property as Expr.Constant).value) + + assertTrue(equalsExpr.right is Expr.Constant<*>) + val constantExpr = equalsExpr.right + assertEquals("tunnel", constantExpr.value) + + assertTrue(result is Expr.Constant) + val resultExpr = result + assertEquals(0.7, resultExpr.value) + + assertTrue(caseExpr.default is Expr.Constant) + val defaultExpr = caseExpr.default + assertEquals(1.0, defaultExpr.value) + + val tunnelProps = mapOf("brunnel" to "tunnel") + val nonTunnelProps = mapOf("brunnel" to "bridge") + + assertEquals(0.7, exprOrValue.process(featureProperties = tunnelProps)) + assertEquals(1.0, exprOrValue.process(featureProperties = nonTunnelProps)) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/IndexOfExpressionTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/IndexOfExpressionTest.kt new file mode 100644 index 00000000..75e7ac14 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/IndexOfExpressionTest.kt @@ -0,0 +1,80 @@ +package ovh.plrapps.mapcompose.vector.spec.style.props + +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ExpressionOrValueSerializer +import kotlinx.serialization.json.Json +import kotlinx.serialization.builtins.serializer +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class IndexOfExpressionTest { + private val json = Json { ignoreUnknownKeys = true } + + @Test + fun `test index-of expression with constant array`() { + val expr = Expr.IndexOf( + array = Expr.Constant(listOf("a", "b", "c")), + value = Expr.Constant("b") + ) + + val result = expr.evaluate(emptyMap(), null) + assertEquals(1, result) + } + + @Test + fun `test index-of expression with get array`() { + val properties = mapOf( + "array" to listOf("x", "y", "z"), + "value" to "y" + ) + + val expr = Expr.IndexOf( + array = Expr.Get>(Expr.Constant("array")), + value = Expr.Get(Expr.Constant("value")) + ) + + val result = expr.evaluate(properties, null) + assertEquals(1, result) + } + + @Test + fun `test index-of expression with non-existent value`() { + val expr = Expr.IndexOf( + array = Expr.Constant(listOf("a", "b", "c")), + value = Expr.Constant("d") + ) + + val result = expr.evaluate(emptyMap(), null) + assertEquals(-1, result) + } + + @Test + fun `test index-of expression with null values`() { + val expr = Expr.IndexOf( + array = Expr.Get>(Expr.Constant("nonexistent")), + value = Expr.Constant("value") + ) + + val result = expr.evaluate(emptyMap(), null) + assertEquals(null, result) + } + + @Test + fun `test index-of expression deserialization`() { + val jsonStr = """["index-of",["get","array"],"value"]""" + val deserialized = json.decodeFromString( + ExpressionOrValueSerializer(Int.serializer()), + jsonStr + ) + + assertTrue(deserialized is ExpressionOrValue.Expression<*>) + val expression = deserialized as ExpressionOrValue.Expression + assertTrue(expression.expr is Expr.IndexOf<*>) + + val indexOfExpr = expression.expr as Expr.IndexOf + assertTrue(indexOfExpr.array is Expr.Get<*>) + assertTrue(indexOfExpr.value is Expr.Constant<*>) + assertEquals("array", ((indexOfExpr.array as Expr.Get<*>).property as Expr.Constant).value) + assertEquals("value", (indexOfExpr.value as Expr.Constant<*>).value) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/StepExprTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/StepExprTest.kt new file mode 100644 index 00000000..e67cf8c0 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/StepExprTest.kt @@ -0,0 +1,30 @@ +package ovh.plrapps.mapcompose.vector.spec.style.props + +import kotlin.test.Test +import kotlin.test.assertEquals + +class StepExprTest { + @Test + fun testStepEvaluate() { + val expr = Expr.Step( + input = Expr.Zoom, + default = Expr.Constant(0), + stops = listOf( + 14.0 to Expr.Constant(10), + 15.0 to Expr.Constant(20), + 16.0 to Expr.Constant(30), + 17.0 to Expr.Constant(40) + ) + ) + // input = 13 -> default + assertEquals(0, expr.evaluate(null, 13.0)) + // input = 14 -> match1 (10) + assertEquals(10, expr.evaluate(null, 14.0)) + // input = 15 -> match2 (20) + assertEquals(20, expr.evaluate(null, 15.0)) + // input = 16 -> match3 (30) + assertEquals(30, expr.evaluate(null, 16.0)) + // input = 18 -> last + assertEquals(40, expr.evaluate(null, 18.0)) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/StringCaseExpressionTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/StringCaseExpressionTest.kt new file mode 100644 index 00000000..87f48458 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/props/StringCaseExpressionTest.kt @@ -0,0 +1,72 @@ +package ovh.plrapps.mapcompose.vector.spec.style.props + +import ovh.plrapps.mapcompose.vector.spec.style.serializers.ExpressionOrValueSerializer +import kotlinx.serialization.json.Json +import kotlinx.serialization.builtins.serializer +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertNull + +class StringCaseExpressionTest { + private val json = Json { ignoreUnknownKeys = true } + + @Test + fun `test downcase expression with constant string`() { + val expr = Expr.Downcase(Expr.Constant("Hello World")) + val result = expr.evaluate(emptyMap(), null) + assertEquals("hello world", result) + } + + @Test + fun `test downcase expression with get string`() { + val expr = Expr.Downcase(Expr.Get(Expr.Constant("name"))) + val result = expr.evaluate(mapOf("name" to "Hello World"), null) + assertEquals("hello world", result) + } + + @Test + fun `test downcase expression with null value`() { + val expr = Expr.Downcase(Expr.Get(Expr.Constant("name"))) + val result = expr.evaluate(emptyMap(), null) + assertNull(result) + } + + @Test + fun `test upcase expression with constant string`() { + val expr = Expr.Upcase(Expr.Constant("Hello World")) + val result = expr.evaluate(emptyMap(), null) + assertEquals("HELLO WORLD", result) + } + + @Test + fun `test upcase expression with get string`() { + val expr = Expr.Upcase(Expr.Get(Expr.Constant("name"))) + val result = expr.evaluate(mapOf("name" to "Hello World"), null) + assertEquals("HELLO WORLD", result) + } + + @Test + fun `test upcase expression with null value`() { + val expr = Expr.Upcase(Expr.Get(Expr.Constant("name"))) + val result = expr.evaluate(emptyMap(), null) + assertNull(result) + } + + @Test + fun `test serialization and deserialization of downcase expression`() { + val original = ExpressionOrValue.Expression(Expr.Downcase(Expr.Constant("Hello World")), source="""["downcase","Hello World"]""") + val serializer = ExpressionOrValueSerializer(String.serializer()) + val jsonString = json.encodeToString(serializer, original) + val deserialized = json.decodeFromString(serializer, jsonString) + assertEquals(original, deserialized) + } + + @Test + fun `test serialization and deserialization of upcase expression`() { + val original = ExpressionOrValue.Expression(Expr.Upcase(Expr.Constant("Hello World")), source = """["upcase","Hello World"]""") + val serializer = ExpressionOrValueSerializer(String.serializer()) + val jsonString = json.encodeToString(serializer, original) + val deserialized = json.decodeFromString(serializer, jsonString) + assertEquals(original, deserialized) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExpressionOrValueSerializerTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExpressionOrValueSerializerTest.kt new file mode 100644 index 00000000..40db16db --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/serializers/ExpressionOrValueSerializerTest.kt @@ -0,0 +1,944 @@ +package ovh.plrapps.mapcompose.vector.spec.style.serializers + +import androidx.compose.ui.graphics.Color +import ovh.plrapps.mapcompose.vector.data.json +import ovh.plrapps.mapcompose.vector.spec.style.props.Expr +import ovh.plrapps.mapcompose.vector.spec.style.props.ExpressionOrValue +import kotlinx.serialization.builtins.serializer +import kotlinx.serialization.json.Json +import kotlinx.serialization.json.JsonArray +import kotlinx.serialization.json.JsonPrimitive +import kotlin.math.PI +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue +import kotlin.test.fail + +class ExpressionOrValueSerializerTest { + @Test + fun `test serialize simple int value`() { + val value = ExpressionOrValue.Value(42) + val serialized = json.encodeToString(ExpressionOrValueSerializer(Int.serializer()), value) + assertEquals("42", serialized) + } + + @Test + fun `test serialize color value`() { + val value = ExpressionOrValue.Value(Color(0xFF0000FF)) + val serialized = json.encodeToString(ExpressionOrValueSerializer(ColorSerializer), value) + assertEquals("#0000FF", serialized) + } + + @Test + fun `test deserialize simple int value`() { + val jsonStr = "42" + val deserialized = json.decodeFromString( + ExpressionOrValueSerializer(Int.serializer()), + jsonStr + ) + assertTrue(deserialized is ExpressionOrValue.Value) + assertEquals(42, deserialized.value) + } + + @Test + fun `test deserialize color value`() { + val jsonStr = "#0000FF" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(ColorSerializer), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Value) + assertEquals(Color(0xFF0000FF), deserialized.value) + } + + @Test + fun `test deserialize get expression`() { + val jsonStr = "[\"get\",\"name\"]" + val deserialized = json.decodeFromString( + ExpressionOrValueSerializer(String.serializer()), + jsonStr + ) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Get<*>) + } + + @Test + fun `test deserialize interpolate expression`() { + val jsonStr = "[\"interpolate\",[\"linear\"],[\"zoom\"],0,0,10,100]" + val deserialized = json.decodeFromString( + ExpressionOrValueSerializer(Double.serializer()), + jsonStr + ) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Interpolate<*>) + } + + @Test + fun `test deserialize match expression`() { + val jsonStr = "[\"match\",[\"get\",\"type\"],\"residential\",\"local\",\"other\"]" + val deserialized = + json.decodeFromString>(ExpressionOrValueSerializer(String.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Match<*>) + } + + @Test + fun `test deserialize stops expression`() { + val jsonStr = "{\"stops\":[[0,2],[6,6],[14,9],[22,18]]}" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Double.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Interpolate) + + val stops = (deserialized.expr).stops + assertEquals(4, stops.size) + assertEquals(0.0 to Expr.Constant(2.0), stops[0]) + assertEquals(6.0 to Expr.Constant(6.0), stops[1]) + assertEquals(14.0 to Expr.Constant(9.0), stops[2]) + assertEquals(22.0 to Expr.Constant(18.0), stops[3]) + } + + @Test + fun `test deserialize has expression`() { + val jsonStr = "[\"has\",\"name\"]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Has<*>) + assertEquals("name", (deserialized.expr).property) + } + + @Test + fun `test deserialize in expression`() { + val jsonStr = "[\"in\",[\"get\",\"type\"],[\"residential\",\"commercial\"]]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.In<*>) + val inExpr = deserialized.expr + assertTrue(inExpr.value is Expr.Get) + assertEquals(listOf("residential", "commercial"), inExpr.array) + } + + @Test + fun `test deserialize case expression`() { + val jsonStr = "[\"case\",[\"has\",\"name\"],\"named\",\"unnamed\"]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(String.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Case) + val caseExpr = deserialized.expr + assertEquals(1, caseExpr.conditions.size) + assertTrue(caseExpr.conditions[0].first is Expr.Has<*>) + assertTrue(caseExpr.conditions[0].second is Expr.Constant) + assertTrue(caseExpr.default is Expr.Constant) + } + + @Test + fun `test deserialize coalesce expression`() { + val jsonStr = "[\"coalesce\",[\"get\",\"name\"],[\"get\",\"title\"],\"unnamed\"]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(String.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Coalesce) + val coalesceExpr = deserialized.expr + assertEquals(3, coalesceExpr.values.size) + assertTrue(coalesceExpr.values[0] is Expr.Get) + assertTrue(coalesceExpr.values[1] is Expr.Get) + assertTrue(coalesceExpr.values[2] is Expr.Constant) + } + + @Test + fun `test deserialize invalid json`() { + try { + json.decodeFromString>( + ExpressionOrValueSerializer(Int.serializer()), + "invalid" + ) + fail("Expected exception was not thrown") + } catch (e: Exception) { + // Expected + } + } + + @Test + fun testNotEqualsExpressionDeserialization() { + val json = """["!=",["get","property1"],"value"]""" + val expr = Json.decodeFromString( + ExpressionOrValueSerializer(Boolean.serializer()), + json + ) as ExpressionOrValue.Expression + + val result = expr.expr.evaluate(mapOf("property1" to "different"), 0.0) + assertTrue(result == true) + + val result2 = expr.expr.evaluate(mapOf("property1" to "value"), 0.0) + assertTrue(result2 == false) + } + + @Test + fun testNotEqualsExpressionWithConstantsDeserialization() { + val json = """["!=","value1","value2"]""" + val expr = Json.decodeFromString( + ExpressionOrValueSerializer(Boolean.serializer()), + json + ) as ExpressionOrValue.Expression + + val result = expr.expr.evaluate(emptyMap(), 0.0) + assertTrue(result == true) + } + + @Test + fun testEqualsExpressionDeserialization() { + val json = """["==",["get","property1"],"value"]""" + val expr = Json.decodeFromString( + ExpressionOrValueSerializer(Boolean.serializer()), + json + ) as ExpressionOrValue.Expression + + val result = expr.expr.evaluate(mapOf("property1" to "different"), 0.0) + assertTrue(result == false) + + val result2 = expr.expr.evaluate(mapOf("property1" to "value"), 0.0) + assertTrue(result2 == true) + } + + @Test + fun testEqualsExpressionWithConstantsDeserialization() { + val json = """["==","value1","value2"]""" + val expr = Json.decodeFromString( + ExpressionOrValueSerializer(Boolean.serializer()), + json + ) as ExpressionOrValue.Expression + + val result = expr.expr.evaluate(emptyMap(), 0.0) + assertTrue(result == false) + } + + + @Test + fun `test deserialize equals expression`() { + val jsonStr = "[\"==\",[\"get\",\"name\"],\"test\"]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Equals<*, *>) + } + + @Test + fun `test equals expression with constants`() { + val expr = Expr.Equals( + Expr.Constant("test"), + Expr.Constant("test") + ) + assertEquals(true, expr.evaluate(null, null)) + } + + @Test + fun `test deserialize less than expression`() { + val jsonStr = "[\"<\",[\"get\",\"value\"],10]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.LessThan) + } + + @Test + fun `test deserialize less than or equal expression`() { + val jsonStr = "[\"<=\",[\"get\",\"value\"],10]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.LessThanOrEqual) + } + + @Test + fun `test deserialize greater than expression`() { + val jsonStr = "[\">\",[\"get\",\"value\"],10]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.GreaterThan) + } + + @Test + fun `test deserialize greater than or equal expression`() { + val jsonStr = "[\">=\",[\"get\",\"value\"],10]" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.GreaterThanOrEqual) + } + + @Test + fun `test evaluate less than expression`() { + val expr = Expr.LessThan( + Expr.Get(Expr.Constant("value")), + Expr.Constant(10) + ) + + assertEquals(true, expr.evaluate(mapOf("value" to 5), null)) + + assertEquals(false, expr.evaluate(mapOf("value" to 10), null)) + + assertEquals(false, expr.evaluate(mapOf("value" to 15), null)) + + assertEquals(null, expr.evaluate(emptyMap(), null)) + } + + @Test + fun `test evaluate less than or equal expression`() { + val expr = Expr.LessThanOrEqual( + Expr.Get(Expr.Constant("value")), + Expr.Constant(10) + ) + + assertEquals(true, expr.evaluate(mapOf("value" to 5), null)) + + assertEquals(true, expr.evaluate(mapOf("value" to 10), null)) + + assertEquals(false, expr.evaluate(mapOf("value" to 15), null)) + + assertEquals(null, expr.evaluate(emptyMap(), null)) + } + + @Test + fun `test evaluate greater than expression`() { + val expr = Expr.GreaterThan( + Expr.Get(Expr.Constant("value")), + Expr.Constant(10) + ) + + assertEquals(false, expr.evaluate(mapOf("value" to 5), null)) + + assertEquals(false, expr.evaluate(mapOf("value" to 10), null)) + + assertEquals(true, expr.evaluate(mapOf("value" to 15), null)) + + assertEquals(null, expr.evaluate(emptyMap(), null)) + } + + @Test + fun `test evaluate greater than or equal expression`() { + val expr = Expr.GreaterThanOrEqual( + Expr.Get(Expr.Constant("value")), + Expr.Constant(10) + ) + + assertEquals(false, expr.evaluate(mapOf("value" to 5), null)) + + assertEquals(true, expr.evaluate(mapOf("value" to 10), null)) + + assertEquals(true, expr.evaluate(mapOf("value" to 15), null)) + + assertEquals(null, expr.evaluate(emptyMap(), null)) + } + + @Test + fun `test evaluate string comparison`() { + val expr = Expr.LessThan( + Expr.Get(Expr.Constant("value")), + Expr.Constant("z") + ) + + assertEquals(true, expr.evaluate(mapOf("value" to "a"), null)) + assertEquals(false, expr.evaluate(mapOf("value" to "z"), null)) + assertEquals(false, expr.evaluate(mapOf("value" to "zz"), null)) + } + + @Test + fun `test evaluate mixed type comparison`() { + val expr = Expr.LessThan( + Expr.Get(Expr.Constant("value")), + Expr.Constant(10) + ) + + assertEquals(null, expr.evaluate(mapOf("value" to "string"), null)) + assertEquals(true, expr.evaluate(mapOf("value" to 5), null)) + assertEquals(false, expr.evaluate(mapOf("value" to 15), null)) + } + + @Test + fun `test deserialize all expression`() { + val jsonStr = """["all",["get","prop1"],["get","prop2"]]""" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.All) + assertEquals(2, (deserialized.expr).conditions.size) + } + + @Test + fun `test deserialize any expression`() { + val jsonStr = """["any",["get","prop1"],["get","prop2"]]""" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.AnyOf) + assertEquals(2, (deserialized.expr).conditions.size) + } + + @Test + fun `test deserialize not expression`() { + val jsonStr = """["!",["get","prop1"]]""" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Boolean.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Not) + } + + @Test + fun `test evaluate all expression`() { + val expr = Expr.All( + listOf( + Expr.Get(Expr.Constant("prop1")), + Expr.Get(Expr.Constant("prop2")) + ) + ) + + assertEquals(true, expr.evaluate(mapOf("prop1" to true, "prop2" to true), null)) + + assertEquals(false, expr.evaluate(mapOf("prop1" to true, "prop2" to false), null)) + + assertEquals(null, expr.evaluate(mapOf("prop1" to true), null)) + + assertEquals(null, Expr.All(emptyList()).evaluate(null, null)) + } + + @Test + fun `test evaluate any expression`() { + val expr = Expr.AnyOf( + listOf( + Expr.Get(Expr.Constant("prop1")), + Expr.Get(Expr.Constant("prop2")) + ) + ) + + assertEquals(true, expr.evaluate(mapOf("prop1" to true, "prop2" to false), null)) + + assertEquals(false, expr.evaluate(mapOf("prop1" to false, "prop2" to false), null)) + + assertEquals(null, expr.evaluate(mapOf("prop1" to false), null)) + + assertEquals(null, Expr.AnyOf(emptyList()).evaluate(null, null)) + } + + @Test + fun `test evaluate not expression`() { + val expr = Expr.Not(Expr.Get(Expr.Constant("prop1"))) + + assertEquals(false, expr.evaluate(mapOf("prop1" to true), null)) + + assertEquals(true, expr.evaluate(mapOf("prop1" to false), null)) + + assertEquals(null, expr.evaluate(emptyMap(), null)) + } + + @Test + fun `test complex logical expressions`() { + val expr = Expr.All( + listOf( + Expr.Not(Expr.Get(Expr.Constant("prop1"))), + Expr.AnyOf( + listOf( + Expr.Get(Expr.Constant("prop2")), + Expr.Get(Expr.Constant("prop3")) + ) + ) + ) + ) + + // prop1=false, prop2=true, prop3=false + assertEquals( + true, expr.evaluate( + mapOf( + "prop1" to false, + "prop2" to true, + "prop3" to false + ), null + ) + ) + + // prop1=true, prop2=false, prop3=false + assertEquals( + false, expr.evaluate( + mapOf( + "prop1" to true, + "prop2" to false, + "prop3" to false + ), null + ) + ) + + // prop1=false, prop2=false, prop3=false + assertEquals( + false, expr.evaluate( + mapOf( + "prop1" to false, + "prop2" to false, + "prop3" to false + ), null + ) + ) + } + + @Test + fun `test deserialize modulo expression`() { + val jsonStr = """["%",["get","value"],3]""" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Double.serializer()), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + assertTrue(deserialized.expr is Expr.Modulo) + } + + @Test + fun `test evaluate modulo expression`() { + val expr = Expr.Modulo(Expr.Get(Expr.Constant("value")), Expr.Constant(3)) + val exprWithZeroDivisor = Expr.Modulo(Expr.Constant(7), Expr.Constant(0)) + + assertEquals(1.0, expr.evaluate(mapOf("value" to 7), null)) + assertEquals(null, exprWithZeroDivisor.evaluate(emptyMap(), null)) + assertEquals(null, expr.evaluate(mapOf("value" to null), null)) + assertEquals(null, expr.evaluate(mapOf("value" to "not a number"), null)) + } + + @Test + fun `test evaluate modulo with different number types`() { + val expr = Expr.Modulo( + Expr.Get(Expr.Constant("value")), + Expr.Constant(3) + ) + + // Int + assertEquals(1.0, expr.evaluate(mapOf("value" to 7), null)) + + // Double + assertEquals(1.0, expr.evaluate(mapOf("value" to 7.0), null)) + + // Float + assertEquals(1.0, expr.evaluate(mapOf("value" to 7.0f), null)) + + // Long + assertEquals(1.0, expr.evaluate(mapOf("value" to 7L), null)) + } + + @Test + fun `test complex modulo expression`() { + val expr = Expr.Modulo( + Expr.Get(Expr.Constant("value")), + Expr.Modulo( + Expr.Get(Expr.Constant("divisor")), + Expr.Constant(2) + ) + ) + + // value = 7, divisor = 5 + // 7 % (5 % 2) = 7 % 1 = 0 + assertEquals( + 0.0, expr.evaluate( + mapOf( + "value" to 7, + "divisor" to 5 + ), null + ) + ) + + // value = 7, divisor = 4 + // 7 % (4 % 2) = 7 % 0 = null (div 0) + assertEquals( + null, expr.evaluate( + mapOf( + "value" to 7, + "divisor" to 4 + ), null + ) + ) + } + + @Test + fun `test evaluate power expression`() { + val expr = Expr.Power(Expr.Get(Expr.Constant("value")), Expr.Constant(2.0)) + assertEquals(4.0, expr.evaluate(mapOf("value" to 2.0), 0.0)) + assertEquals(9.0, expr.evaluate(mapOf("value" to 3.0), 0.0)) + assertEquals(null, expr.evaluate(mapOf("value" to null), 0.0)) + assertEquals(null, expr.evaluate(mapOf("value" to "not a number"), 0.0)) + } + + @Test + fun `test evaluate abs expression`() { + val expr = Expr.Abs(Expr.Get(Expr.Constant("value"))) + assertEquals(2.0, expr.evaluate(mapOf("value" to 2.0), 0.0)) + assertEquals(2.0, expr.evaluate(mapOf("value" to -2.0), 0.0)) + assertEquals(null, expr.evaluate(mapOf("value" to null), 0.0)) + assertEquals(null, expr.evaluate(mapOf("value" to "not a number"), 0.0)) + } + + @Test + fun `test evaluate trigonometric expressions`() { + val sinExpr = Expr.Sin(Expr.Get(Expr.Constant("value"))) + val cosExpr = Expr.Cos(Expr.Get(Expr.Constant("value"))) + val tanExpr = Expr.Tan(Expr.Get(Expr.Constant("value"))) + val asinExpr = Expr.Asin(Expr.Get(Expr.Constant("value"))) + val acosExpr = Expr.Acos(Expr.Get(Expr.Constant("value"))) + val atanExpr = Expr.Atan(Expr.Get(Expr.Constant("value"))) + + assertEquals(0.0, sinExpr.evaluate(mapOf("value" to 0.0), 0.0)) + assertEquals(1.0, cosExpr.evaluate(mapOf("value" to 0.0), 0.0)) + assertEquals(0.0, tanExpr.evaluate(mapOf("value" to 0.0), 0.0)) + assertEquals(0.0, asinExpr.evaluate(mapOf("value" to 0.0), 0.0)) + assertEquals(PI / 2, acosExpr.evaluate(mapOf("value" to 0.0), 0.0)) + assertEquals(0.0, atanExpr.evaluate(mapOf("value" to 0.0), 0.0)) + + assertEquals(null, sinExpr.evaluate(mapOf("value" to null), 0.0)) + assertEquals(null, sinExpr.evaluate(mapOf("value" to "not a number"), 0.0)) + } + + @Test + fun `test evaluate rounding expressions`() { + val ceilExpr = Expr.Ceil(Expr.Get(Expr.Constant("value"))) + val floorExpr = Expr.Floor(Expr.Get(Expr.Constant("value"))) + val roundExpr = Expr.Round(Expr.Get(Expr.Constant("value"))) + + assertEquals(3.0, ceilExpr.evaluate(mapOf("value" to 2.3), 0.0)) + assertEquals(2.0, floorExpr.evaluate(mapOf("value" to 2.3), 0.0)) + assertEquals(2.0, roundExpr.evaluate(mapOf("value" to 2.3), 0.0)) + + assertEquals(null, ceilExpr.evaluate(mapOf("value" to null), 0.0)) + assertEquals(null, ceilExpr.evaluate(mapOf("value" to "not a number"), 0.0)) + } + + @Test + fun `test evaluate logarithmic expressions`() { + val lnExpr = Expr.Ln(Expr.Get(Expr.Constant("value"))) + val log10Expr = Expr.Log10(Expr.Get(Expr.Constant("value"))) + + assertEquals(0.0, lnExpr.evaluate(mapOf("value" to 1.0), 0.0)) + assertEquals(0.0, log10Expr.evaluate(mapOf("value" to 1.0), 0.0)) + + assertEquals(null, lnExpr.evaluate(mapOf("value" to 0.0), 0.0)) + assertEquals(null, lnExpr.evaluate(mapOf("value" to -1.0), 0.0)) + assertEquals(null, lnExpr.evaluate(mapOf("value" to null), 0.0)) + assertEquals(null, lnExpr.evaluate(mapOf("value" to "not a number"), 0.0)) + } + + @Test + fun `test evaluate min max expressions`() { + val minExpr = Expr.Min(Expr.Get(Expr.Constant("value1")), Expr.Get(Expr.Constant("value2"))) + val maxExpr = Expr.Max(Expr.Get(Expr.Constant("value1")), Expr.Get(Expr.Constant("value2"))) + + assertEquals(2.0, minExpr.evaluate(mapOf("value1" to 2.0, "value2" to 3.0), 0.0)) + assertEquals(3.0, maxExpr.evaluate(mapOf("value1" to 2.0, "value2" to 3.0), 0.0)) + + assertEquals(null, minExpr.evaluate(mapOf("value1" to null, "value2" to 3.0), 0.0)) + assertEquals(null, minExpr.evaluate(mapOf("value1" to "not a number", "value2" to 3.0), 0.0)) + } + + @Test + fun `test evaluate sqrt expression`() { + val expr = Expr.Sqrt(Expr.Get(Expr.Constant("value"))) + assertEquals(2.0, expr.evaluate(mapOf("value" to 4.0), 0.0)) + assertEquals(null, expr.evaluate(mapOf("value" to -1.0), 0.0)) + assertEquals(null, expr.evaluate(mapOf("value" to null), 0.0)) + assertEquals(null, expr.evaluate(mapOf("value" to "not a number"), 0.0)) + } + + + + @Test + fun `test deserialize hsl color value`() { + val jsonStr = """"hsl(75, 51%, 85%)"""" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(ColorSerializer), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Value) + assertEquals(Color.hsl(hue = 75F, saturation = 0.51F, lightness = 0.85F), deserialized.value) + } + + @Test + fun `test deserialize expression color value`() { + val jsonStr = """[ + "match", + [ + "get", + "ADM0_A3" + ], + [ + "ARM", + "ATG", + "AUS", + "BTN", + "CAN", + "COG", + "CZE", + "GHA", + "GIN", + "HTI", + "ISL", + "JOR", + "KHM", + "KOR", + "LVA", + "MLT", + "MNE", + "MOZ", + "PER", + "SAH", + "SGP", + "SLV", + "SOM", + "TJK", + "TUV", + "UKR", + "WSM" + ], + "#D6C7FF", + [ + "AZE", + "BGD", + "CHL", + "CMR", + "CSI", + "DEU", + "DJI", + "GUY", + "HUN", + "IOA", + "JAM", + "LBN", + "LBY", + "LSO", + "MDG", + "MKD", + "MNG", + "MRT", + "NIU", + "NZL", + "PCN", + "PYF", + "SAU", + "SHN", + "STP", + "TTO", + "UGA", + "UZB", + "ZMB" + ], + "#EBCA8A", + [ + "AGO", + "ASM", + "ATF", + "BDI", + "BFA", + "BGR", + "BLZ", + "BRA", + "CHN", + "CRI", + "ESP", + "HKG", + "HRV", + "IDN", + "IRN", + "ISR", + "KNA", + "LBR", + "LCA", + "MAC", + "MUS", + "NOR", + "PLW", + "POL", + "PRI", + "SDN", + "TUN", + "UMI", + "USA", + "USG", + "VIR", + "VUT" + ], + "#C1E599", + [ + "ARE", + "ARG", + "BHS", + "CIV", + "CLP", + "DMA", + "ETH", + "GAB", + "GRD", + "HMD", + "IND", + "IOT", + "IRL", + "IRQ", + "ITA", + "KOS", + "LUX", + "MEX", + "NAM", + "NER", + "PHL", + "PRT", + "RUS", + "SEN", + "SUR", + "TZA", + "VAT" + ], + "#E7E58F", + [ + "AUT", + "BEL", + "BHR", + "BMU", + "BRB", + "CYN", + "DZA", + "EST", + "FLK", + "GMB", + "GUM", + "HND", + "JEY", + "KGZ", + "LIE", + "MAF", + "MDA", + "NGA", + "NRU", + "SLB", + "SOL", + "SRB", + "SWZ", + "THA", + "TUR", + "VEN", + "VGB" + ], + "#98DDA1", + [ + "AIA", + "BIH", + "BLM", + "BRN", + "CAF", + "CHE", + "COM", + "CPV", + "CUB", + "ECU", + "ESB", + "FSM", + "GAZ", + "GBR", + "GEO", + "KEN", + "LTU", + "MAR", + "MCO", + "MDV", + "NFK", + "NPL", + "PNG", + "PRY", + "QAT", + "SLE", + "SPM", + "SYC", + "TCA", + "TKM", + "TLS", + "VNM", + "WEB", + "WSB", + "YEM", + "ZWE" + ], + "#83D5F4", + [ + "ABW", + "ALB", + "AND", + "ATC", + "BOL", + "COD", + "CUW", + "CYM", + "CYP", + "EGY", + "FJI", + "GGY", + "IMN", + "KAB", + "KAZ", + "KWT", + "LAO", + "MLI", + "MNP", + "MSR", + "MYS", + "NIC", + "NLD", + "PAK", + "PAN", + "PRK", + "ROU", + "SGS", + "SVN", + "SWE", + "TGO", + "TWN", + "VCT", + "ZAF" + ], + "#B1BBF9", + [ + "ATA", + "GRL" + ], + "#FFFFFF", + "#EAB38F" + ]""" + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(ColorSerializer), jsonStr) + assertTrue(deserialized is ExpressionOrValue.Expression) + deserialized.expr as Expr.Match + val firstBranch = deserialized.expr.branches.first() + val matchExpr = deserialized.expr + assertEquals(Color(0xFFD6C7FF), (firstBranch.second as Expr.Constant).value) + assertEquals(Color(0xFFEAB38F), (matchExpr.elseExpr as Expr.Constant).value) + } + + @Test + fun `test deserialize legacy expression 001`() { + val input = """{ + "stops": [ + [ + 0, + 2 + ], + [ + 6, + 6 + ], + [ + 14, + 9 + ], + [ + 22, + 18 + ] + ] + }""" + + val deserialized = json.decodeFromString(ExpressionOrValueSerializer(Double.serializer()), input) + + assertEquals(6.0, deserialized.process(null, zoom = 6.0)) + + } + + @Test + fun toNumberTest() { + val input = JsonArray( + listOf( + JsonPrimitive("to-number"), + JsonArray( + listOf( + JsonPrimitive("get"), + JsonPrimitive("rank") + ) + ) + ) + ) + + val expr = json.decodeFromJsonElement(ExpressionOrValueSerializer(Double.serializer()), input) + + + val result = expr.process(mapOf("rank" to "123"), zoom = null) + assertEquals(123.0, result) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/NormalizeLegacyExpressionTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/NormalizeLegacyExpressionTest.kt new file mode 100644 index 00000000..76b67028 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/spec/style/utils/NormalizeLegacyExpressionTest.kt @@ -0,0 +1,166 @@ +package ovh.plrapps.mapcompose.vector.spec.style.utils + +import kotlinx.serialization.ExperimentalSerializationApi +import ovh.plrapps.mapcompose.vector.data.json +import kotlinx.serialization.json.* +import kotlin.test.Test +import kotlin.test.assertEquals + +class NormalizeLegacyExpressionTest { + + @Test + fun `test stops-only shorthand interpolation`() { + val input = JsonObject(mapOf( + "stops" to JsonArray(listOf( + JsonArray(listOf(JsonPrimitive(14), JsonArray(listOf(JsonPrimitive(1), JsonPrimitive(0.5))))), + JsonArray(listOf(JsonPrimitive(18), JsonArray(listOf(JsonPrimitive(1), JsonPrimitive(0.25))))) + )) + )) + + val expected = JsonArray(listOf( + JsonPrimitive("interpolate"), + JsonArray(listOf(JsonPrimitive("linear"))), + JsonPrimitive("zoom"), + JsonPrimitive(14), + JsonArray(listOf(JsonPrimitive(1), JsonPrimitive(0.5))), + JsonPrimitive(18), + JsonArray(listOf(JsonPrimitive(1), JsonPrimitive(0.25))) + )) + + val result = normalizeLegacyExpression(input) + assertEquals(expected, result) + } + + @Test + fun `test identity expression`() { + val input = JsonObject(mapOf( + "type" to JsonPrimitive("identity"), + "property" to JsonPrimitive("color") + )) + + val expected = JsonArray(listOf( + JsonPrimitive("get"), + JsonPrimitive("color") + )) + + val result = normalizeLegacyExpression(input) + assertEquals(expected, result) + } + + @Test + fun `test exponential interpolation`() { + val input = JsonObject(mapOf( + "type" to JsonPrimitive("exponential"), + "property" to JsonPrimitive("population"), + "base" to JsonPrimitive(1.5), + "stops" to JsonArray(listOf( + JsonArray(listOf(JsonPrimitive(0), JsonPrimitive(0))), + JsonArray(listOf(JsonPrimitive(1000000), JsonPrimitive(1))) + )) + )) + + val expected = JsonArray(listOf( + JsonPrimitive("interpolate"), + JsonArray(listOf( + JsonPrimitive("exponential"), + JsonPrimitive(1.5) + )), + JsonArray(listOf( + JsonPrimitive("get"), + JsonPrimitive("population") + )), + JsonPrimitive(0), + JsonPrimitive(0), + JsonPrimitive(1000000), + JsonPrimitive(1) + )) + + val result = normalizeLegacyExpression(input) + assertEquals(expected, result) + } + + @Test + fun `test interval expression`() { + val input = JsonObject(mapOf( + "type" to JsonPrimitive("interval"), + "property" to JsonPrimitive("population"), + "default" to JsonPrimitive("gray"), + "stops" to JsonArray(listOf( + JsonArray(listOf(JsonPrimitive(0), JsonPrimitive("red"))), + JsonArray(listOf(JsonPrimitive(1000000), JsonPrimitive("yellow"))), + JsonArray(listOf(JsonPrimitive(5000000), JsonPrimitive("green"))) + )) + )) + + val expected = buildJsonArray { + add("step") + add(buildJsonArray { + add("get") + add("population") + }) + add("gray") + add(0) + add("red") + add(1_000_000) + add("yellow") + add(5_000_000) + add("green") + } + + val result = normalizeLegacyExpression(input) + assertEquals(expected, result) + } + @Test + + fun `test zoom-based stops-only shorthand`() { + val input = """{"stops":[[14,[1,0.5]],[18,[1,0.25]]]}""" + val element = json.decodeFromString(input) + val expected = buildJsonArray { + add("interpolate") + add(buildJsonArray { add("linear") }) + add("zoom") + add(14) + add(buildJsonArray { + add(1) + add(0.5) + }) + add(18) + add(buildJsonArray { + add(1) + add(0.25) + }) + } + + val result = normalizeLegacyExpression(element) + assertEquals(expected, result) + } + + @OptIn(ExperimentalSerializationApi::class) + @Test + fun `test categorical expression`() { + val input = JsonObject(mapOf( + "type" to JsonPrimitive("categorical"), + "property" to JsonPrimitive("type"), + "stops" to JsonArray(listOf( + JsonArray(listOf(JsonPrimitive("residential"), JsonPrimitive("red"))), + JsonArray(listOf(JsonPrimitive("commercial"), JsonPrimitive("blue"))) + )) + )) + + val expected = JsonArray(listOf( + JsonPrimitive("match"), + JsonArray(listOf( + JsonPrimitive("get"), + JsonPrimitive("type") + )), + JsonPrimitive("residential"), + JsonPrimitive("red"), + JsonPrimitive("commercial"), + JsonPrimitive("blue"), + JsonPrimitive(null) + )) + + val result = normalizeLegacyExpression(input) + assertEquals(expected, result) + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/ObbTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/ObbTest.kt new file mode 100644 index 00000000..9c4d4459 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/utils/obb/ObbTest.kt @@ -0,0 +1,392 @@ +package ovh.plrapps.mapcompose.vector.utils.obb + +import kotlin.math.abs +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue +import kotlin.time.measureTime + +class ObbTest { + @Test + fun `test basic OBB creation`() { + val obb = OBB( + center = ObbPoint(10f, 10f), + size = Size(20f, 10f), + rotation = 0f + ) + + val corners = obb.getCorners() + assertEquals(4, corners.size) + + // For 0 rotation, corners should be: + // (-10, -5), (10, -5), (10, 5), (-10, 5) + val expectedCorners = listOf( + ObbPoint(0f, 5f), // (-10 + 10, -5 + 10) + ObbPoint(20f, 5f), // (10 + 10, -5 + 10) + ObbPoint(20f, 15f), // (10 + 10, 5 + 10) + ObbPoint(0f, 15f) // (-10 + 10, 5 + 10) + ) + + corners.forEachIndexed { index, corner -> + assertTrue( + abs(corner.x - expectedCorners[index].x) < 0.001f, + "X coordinate mismatch at corner $index" + ) + assertTrue( + abs(corner.y - expectedCorners[index].y) < 0.001f, + "Y coordinate mismatch at corner $index" + ) + } + } + + @Test + fun `test rotated OBB`() { + val obb = OBB( + center = ObbPoint(0f, 0f), + size = Size(20f, 10f), + rotation = 90f + ) + + val corners = obb.getCorners() + + // For 90-degree rotation, corners should be: + // (5, -10), (5, 10), (-5, 10), (-5, -10) + val expectedCorners = listOf( + ObbPoint(5f, -10f), + ObbPoint(5f, 10f), + ObbPoint(-5f, 10f), + ObbPoint(-5f, -10f) + ) + + corners.forEachIndexed { index, corner -> + assertTrue( + abs(corner.x - expectedCorners[index].x) < 0.001f, + "X coordinate mismatch at corner $index" + ) + assertTrue( + abs(corner.y - expectedCorners[index].y) < 0.001f, + "Y coordinate mismatch at corner $index" + ) + } + } + + @Test + fun `test OBB intersection`() { + // Two OBBs that clearly intersect + val obb1 = OBB( + center = ObbPoint(0f, 0f), + size = Size(20f, 10f), + rotation = 0f + ) + + val obb2 = OBB( + center = ObbPoint(5f, 5f), + size = Size(20f, 10f), + rotation = 45f + ) + + assertTrue(obb1.intersects(obb2)) + assertTrue(obb2.intersects(obb1)) + + // Two OBBs that clearly don't intersect + val obb3 = OBB( + center = ObbPoint(0f, 0f), + size = Size(20f, 10f), + rotation = 0f + ) + + val obb4 = OBB( + center = ObbPoint(30f, 30f), + size = Size(20f, 10f), + rotation = 0f + ) + + assertFalse(obb3.intersects(obb4)) + assertFalse(obb4.intersects(obb3)) + } + + @Test + fun `test OBB AABB conversion`() { + val obb = OBB( + center = ObbPoint(10f, 10f), + size = Size(20f, 10f), + rotation = 45f + ) + + val aabb = obb.getAABB() + + // AABB should contain all corners of the OBB + val corners = obb.getCorners() + corners.forEach { corner -> + assertTrue(corner.x >= aabb.minX && corner.x <= aabb.maxX) + assertTrue(corner.y >= aabb.minY && corner.y <= aabb.maxY) + } + } + + @Test + fun `test edge cases`() { + // Test with zero rotation + val obb1 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 0f + ) + + // Test with 180 degree rotation + val obb2 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 180f + ) + + // Test with negative rotation + val obb3 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = -45f + ) + + // Test with large rotation + val obb4 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 720f // Two full rotations + ) + + // All these OBBs should be equivalent + assertTrue(obb1.intersects(obb2)) + assertTrue(obb2.intersects(obb3)) + assertTrue(obb3.intersects(obb4)) + } + + @Test + fun `test performance`() { + val numTests = 1000 + val obbs = List(numTests) { i -> + OBB( + center = ObbPoint(i * 10f, i * 10f), + size = Size(20f, 10f), + rotation = i * 10f + ) + } + + var intersections = 0 + val duration = measureTime { + // Test all pairs of OBBs + for (i in 0 until numTests) { + for (j in i + 1 until numTests) { + if (obbs[i].intersects(obbs[j])) { + intersections++ + } + } + } + } + + println("Performed $numTests OBB intersection tests in ${duration.inWholeMilliseconds}ms") + println("Found $intersections intersections") + + // Verify that the test didn't take too long + assertTrue(duration.inWholeMilliseconds < 1000, "Performance test took too long: ${duration.inWholeMilliseconds}ms") + } + + @Test + fun `test floating point precision`() { + val obb1 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 45f + ) + + val obb2 = OBB( + center = ObbPoint(0.0001f, 0.0001f), + size = Size(10f, 10f), + rotation = 45f + ) + + assertTrue(obb1.intersects(obb2), "OBBs should intersect with small offset") + + // Test with very small size difference + val obb3 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10.0001f, 10.0001f), + rotation = 45f + ) + + assertTrue(obb1.intersects(obb3), "OBBs should intersect with small size difference") + } + + @Test + fun `test nested OBBs`() { + val outer = OBB( + center = ObbPoint(0f, 0f), + size = Size(20f, 20f), + rotation = 0f + ) + + val inner = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 45f + ) + + assertTrue(outer.intersects(inner), "Outer OBB should intersect with inner OBB") + + // Test with inner OBB at different positions + val inner2 = OBB( + center = ObbPoint(5f, 5f), + size = Size(10f, 10f), + rotation = 45f + ) + + assertTrue(outer.intersects(inner2), "Outer OBB should intersect with offset inner OBB") + + // Test with inner OBB touching the edge + val inner3 = OBB( + center = ObbPoint(10f, 0f), + size = Size(10f, 10f), + rotation = 45f + ) + + assertTrue(outer.intersects(inner3), "Outer OBB should intersect with edge-touching inner OBB") + } + + @Test + fun `test parallel OBBs`() { + val obb1 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 45f + ) + + val obb2 = OBB( + center = ObbPoint(15f, 15f), + size = Size(10f, 10f), + rotation = 45f + ) + + assertFalse(obb1.intersects(obb2), "Parallel OBBs should not intersect when separated") + + // Test with touching parallel OBBs + // For 45-degree rotation, the distance between centers should be 10/sqrt(2) ≈ 7.07 + val touchingObb = OBB( + center = ObbPoint(7.07f, 7.07f), + size = Size(10f, 10f), + rotation = 45f + ) + + assertTrue(obb1.intersects(touchingObb), "Parallel OBBs should intersect when touching") + + // Test with different sizes but same rotation + val obb4 = OBB( + center = ObbPoint(0f, 0f), + size = Size(20f, 20f), + rotation = 45f + ) + + assertTrue(obb1.intersects(obb4), "OBBs with same rotation but different sizes should intersect") + } + + @Test + fun `test edge cases with rotation`() { + // Test with very small rotation + val obb1 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 0.001f + ) + + val obb2 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 0f + ) + + assertTrue(obb1.intersects(obb2), "OBBs with very small rotation difference should intersect") + + // Test with very large rotation + val obb3 = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 360000f + ) + + assertTrue(obb2.intersects(obb3), "OBBs with very large rotation should be equivalent to 0 rotation") + } + + @Test + fun `test rotation sweep intersection`() { + // Create a fixed OBB in the center + val fixedObb = OBB( + center = ObbPoint(0f, 0f), + size = Size(10f, 10f), + rotation = 0f + ) + + // Create an array of OBBs that will rotate around the fixed one + val rotatingObbs = listOf( + // Should always intersect (centers coincide) + OBB(ObbPoint(0f, 0f), Size(10f, 10f), 0f), + // Should sometimes intersect (close to center) + OBB(ObbPoint(5f, 5f), Size(10f, 10f), 0f), + // Should sometimes intersect (on the boundary) + OBB(ObbPoint(10f, 10f), Size(10f, 10f), 0f), + // Should never intersect (too far) + OBB(ObbPoint(20f, 20f), Size(10f, 10f), 0f) + ) + + // Number of steps for a full rotation + val steps = 360 + val angleStep = 360f / steps + + // Counters for statistics + val intersectionStats = rotatingObbs.map { mutableMapOf() } + + // Check for each angle + for (step in 0 until steps) { + val angle = step * angleStep + + // Check each rotating OBB + rotatingObbs.forEachIndexed { index, obb -> + // Create a new OBB with current rotation angle + val rotatedObb = OBB( + center = obb.center, + size = obb.size, + rotation = angle + ) + + // Check intersection + val intersects = fixedObb.intersects(rotatedObb) + + // Update statistics + intersectionStats[index][intersects] = (intersectionStats[index][intersects] ?: 0) + 1 + + // Check expected behavior + when (index) { + 0 -> assertTrue(intersects, "Centered OBB should always intersect at angle $angle") + 3 -> assertFalse(intersects, "Distant OBB should never intersect at angle $angle") + } + } + } + + // Print statistics + println("\nIntersection statistics for full rotation:") + rotatingObbs.forEachIndexed { index, obb -> + val stats = intersectionStats[index] + val total = stats.values.sum() + val intersectionPercentage = (stats[true] ?: 0) * 100.0 / total + println("OBB $index (center: ${obb.center}, size: ${obb.size}):") + println(" Intersections: ${stats[true] ?: 0} (${intersectionPercentage.toInt()}%)") + println(" Non-intersections: ${stats[false] ?: 0} (${(100 - intersectionPercentage).toInt()}%)") + } + + // Verify that statistics match expectations + assertTrue(intersectionStats[0][true] == steps, "Centered OBB should intersect at all angles") + assertTrue(intersectionStats[3][false] == steps, "Distant OBB should never intersect") + + // Verify that boundary OBB has a reasonable number of intersections + val borderIntersections = intersectionStats[2][true] ?: 0 + assertTrue(borderIntersections > 0, "Border OBB should intersect at some angles") + assertTrue(borderIntersections < steps, "Border OBB should not intersect at all angles") + } +} \ No newline at end of file diff --git a/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/RtreeTest.kt b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/RtreeTest.kt new file mode 100644 index 00000000..4cb086a8 --- /dev/null +++ b/library/src/commonTest/kotlin/ovh/plrapps/mapcompose/vector/utils/rtree/RtreeTest.kt @@ -0,0 +1,483 @@ +package ovh.plrapps.mapcompose.vector.utils.rtree + +import kotlinx.datetime.Clock +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertFalse +import kotlin.test.assertTrue + +class RtreeTest { + @Test + fun `test basic insertion and search`() { + val rtree = Rtree() + val aabb1 = AABB(0f, 0f, 10f, 10f) + val aabb2 = AABB(5f, 5f, 15f, 15f) + + rtree.insert(aabb1, "item1") + rtree.insert(aabb2, "item2") + + val searchBounds = AABB(4f, 4f, 16f, 16f) + val results = rtree.search(searchBounds) + + assertEquals(2, results.size) + assertTrue(results.contains("item1")) + assertTrue(results.contains("item2")) + } + + @Test + fun `test node splitting`() { + val rtree = Rtree(maxEntries = 4, minEntries = 2) + + rtree.insert(AABB(0f, 0f, 10f, 10f), "item1") + rtree.insert(AABB(20f, 20f, 30f, 30f), "item2") + rtree.insert(AABB(40f, 40f, 50f, 50f), "item3") + rtree.insert(AABB(60f, 60f, 70f, 70f), "item4") + rtree.insert(AABB(80f, 80f, 90f, 90f), "item5") + + val allResults = rtree.search(AABB(0f, 0f, 100f, 100f)) + println("[test node splitting] allResults: $allResults, size: ${rtree.size()}") + assertEquals(5, allResults.size) + + val area1Results = rtree.search(AABB(0f, 0f, 15f, 15f)) + println("[test node splitting] area1Results: $area1Results") + assertEquals(1, area1Results.size) + assertTrue(area1Results.contains("item1")) + + val area2Results = rtree.search(AABB(15f, 15f, 35f, 35f)) + println("[test node splitting] area2Results: $area2Results") + assertEquals(1, area2Results.size) + assertTrue(area2Results.contains("item2")) + } + + @Test + fun `test AABB operations`() { + val aabb1 = AABB(0f, 0f, 10f, 10f) + val aabb2 = AABB(5f, 5f, 15f, 15f) + + assertTrue(aabb1.intersects(aabb2)) + assertTrue(aabb2.intersects(aabb1)) + + val union = aabb1.union(aabb2) + assertEquals(0f, union.minX) + assertEquals(0f, union.minY) + assertEquals(15f, union.maxX) + assertEquals(15f, union.maxY) + } + + @Test + fun `test size tracking`() { + val rtree = Rtree() + + assertEquals(0, rtree.size()) + + rtree.insert(AABB(0f, 0f, 10f, 10f), "item1") + assertEquals(1, rtree.size()) + + rtree.insert(AABB(5f, 5f, 15f, 15f), "item2") + assertEquals(2, rtree.size()) + } + + @Test + fun `test empty search results`() { + val rtree = Rtree() + rtree.insert(AABB(0f, 0f, 10f, 10f), "item1") + + val results = rtree.search(AABB(20f, 20f, 30f, 30f)) + assertTrue(results.isEmpty()) + } + + @Test + fun `test overlapping AABB`() { + val aabb1 = AABB(0f, 0f, 10f, 10f) + val aabb2 = AABB(10f, 10f, 20f, 20f) + val aabb3 = AABB(5f, 5f, 15f, 15f) + + assertTrue(aabb1.intersects(aabb3)) + assertTrue(aabb2.intersects(aabb3)) + assertTrue(aabb1.intersects(aabb2)) + } + + @Test + fun `test multiple levels of splitting`() { + val rtree = Rtree(maxEntries = 3, minEntries = 1) + + for (i in 0..9) { + rtree.insert(AABB(i * 10f, i * 10f, (i + 1) * 10f, (i + 1) * 10f), "item$i") + } + + val allResults = rtree.search(AABB(0f, 0f, 100f, 100f)) + assertEquals(10, allResults.size) + + val areaResults = rtree.search(AABB(25f, 25f, 35f, 35f)) + assertEquals(2, areaResults.size) + assertTrue(areaResults.contains("item2")) + assertTrue(areaResults.contains("item3")) + } + + @Test + fun `test AABB contains`() { + val outer = AABB(0f, 0f, 20f, 20f) + val inner = AABB(5f, 5f, 15f, 15f) + val overlapping = AABB(15f, 15f, 25f, 25f) + + assertTrue(outer.contains(inner)) + assertFalse(outer.contains(overlapping)) + assertFalse(inner.contains(outer)) + } + + @Test + fun `test boundary conditions`() { + val rtree = Rtree() + + // Test with zero dimensions (point) + rtree.insert(AABB(0f, 0f, 0f, 0f), "zero") + println("Tree size after insert: "+rtree.size()) + + // Search for the same point + val zeroResults1 = rtree.search(AABB(0f, 0f, 0f, 0f)) + println("zeroResults1: $zeroResults1") + assertEquals(1, zeroResults1.size) + assertTrue(zeroResults1.contains("zero")) + + // Search in area containing the point + val zeroResults2 = rtree.search(AABB(-1f, -1f, 1f, 1f)) + println("zeroResults2: $zeroResults2") + assertEquals(1, zeroResults2.size) + assertTrue(zeroResults2.contains("zero")) + + // Test with negative coordinates + rtree.insert(AABB(-10f, -10f, -5f, -5f), "negative") + println("Tree size after second insert: "+rtree.size()) + + // Full intersection + val negativeResults1 = rtree.search(AABB(-15f, -15f, 0f, 0f)) + println("negativeResults1: $negativeResults1") + assertEquals(2, negativeResults1.size) + assertTrue(negativeResults1.contains("negative")) + assertTrue(negativeResults1.contains("zero")) + + // Partial intersection + val negativeResults2 = rtree.search(AABB(-7f, -7f, -3f, -3f)) + println("negativeResults2: $negativeResults2") + assertEquals(1, negativeResults2.size) + assertTrue(negativeResults2.contains("negative")) + + // Boundary intersection (touching) + val negativeResults4 = rtree.search(AABB(-5f, -5f, 0f, 0f)) + println("negativeResults4: $negativeResults4") + assertEquals(2, negativeResults4.size) + assertTrue(negativeResults4.contains("negative")) + assertTrue(negativeResults4.contains("zero")) + + // Test with very large numbers + rtree.insert(AABB(1e6f, 1e6f, 1e7f, 1e7f), "large") + val largeResults = rtree.search(AABB(5e5f, 5e5f, 2e6f, 2e6f)) + println("largeResults: $largeResults") + assertEquals(1, largeResults.size) + assertTrue(largeResults.contains("large")) + + // Test with very small numbers + rtree.insert(AABB(1e-6f, 1e-6f, 1e-5f, 1e-5f), "small") + val smallResults = rtree.search(AABB(0f, 0f, 1e-4f, 1e-4f)) + println("smallResults: $smallResults") + assertTrue(smallResults.contains("small")) + assertTrue(smallResults.contains("zero")) + assertEquals(2, smallResults.size) + } + + @Test + fun `test empty tree operations`() { + val rtree = Rtree() + + // Check search in empty tree + val emptyResults = rtree.search(AABB(0f, 0f, 10f, 10f)) + assertTrue(emptyResults.isEmpty()) + + // Check size of empty tree + assertEquals(0, rtree.size()) + } + + @Test + fun `test exact same bounding boxes`() { + val rtree = Rtree() + val aabb = AABB(0f, 0f, 10f, 10f) + + // Insert several elements with the same bbox + rtree.insert(aabb, "item1") + rtree.insert(aabb, "item2") + rtree.insert(aabb, "item3") + + val results = rtree.search(aabb) + assertEquals(3, results.size) + assertTrue(results.containsAll(listOf("item1", "item2", "item3"))) + } + + @Test + fun `test boundary intersection`() { + val rtree = Rtree() + + // Create elements that touch boundaries + rtree.insert(AABB(0f, 0f, 10f, 10f), "item1") + rtree.insert(AABB(10f, 0f, 20f, 10f), "item2") // Touches on X + rtree.insert(AABB(0f, 10f, 10f, 20f), "item3") // Touches on Y + rtree.insert(AABB(10f, 10f, 20f, 20f), "item4") // Touches on corner + + // Search in area including all elements + val results = rtree.search(AABB(0f, 0f, 20f, 20f)) + assertEquals(4, results.size) + } + + @Test + fun `test deep tree structure`() { + val rtree = Rtree() + for (i in 0..500) { + rtree.insert(AABB(i.toFloat(), i.toFloat(), (i + 10).toFloat(), (i + 10).toFloat()), "item$i") + } + val results = rtree.search(AABB(5f, 5f, 15f, 15f)) + assertTrue(results.size >= 15) + for (i in 0..14) { + assertTrue(results.contains("item$i")) + } + } + + @Test + fun `test degenerate cases`() { + val rtree = Rtree() + for (i in 0..5) { + rtree.insert(AABB(0f, i * 10f, 10f, (i + 1) * 10f), "xline$i") + } + for (i in 0..5) { + rtree.insert(AABB(i * 10f, 0f, (i + 1) * 10f, 10f), "yline$i") + } + val xResults = rtree.search(AABB(0f, 0f, 10f, 60f)) + assertTrue(xResults.size >= 7) + for (i in 0..5) { + assertTrue(xResults.contains("xline$i")) + } + val yResults = rtree.search(AABB(0f, 0f, 60f, 10f)) + assertTrue(yResults.size >= 7) + for (i in 0..5) { + assertTrue(yResults.contains("yline$i")) + } + } + + @Test + fun `test node removal and rebalancing`() { + val rtree = Rtree(maxEntries = 4, minEntries = 2) + + // Fill the tree + for (i in 0..5) { + rtree.insert(AABB(i * 10f, i * 10f, (i + 1) * 10f, (i + 1) * 10f), "item$i") + } + + // Check that all elements are accessible + val results = rtree.search(AABB(0f, 0f, 60f, 60f)) + assertEquals(6, results.size) + + // Check search in separate areas + val areaResults = rtree.search(AABB(0f, 0f, 15f, 15f)) + assertEquals(2, areaResults.size) + assertTrue(areaResults.contains("item0")) + assertTrue(areaResults.contains("item1")) + } + + @Test + fun `test non intersecting search`() { + val rtree = Rtree() + + // Insert elements in a specific area + rtree.insert(AABB(0f, 0f, 10f, 10f), "item1") + rtree.insert(AABB(20f, 20f, 30f, 30f), "item2") + + // Search in area not intersecting with any element + val results = rtree.search(AABB(40f, 40f, 50f, 50f)) + assertTrue(results.isEmpty()) + + // Search in partially intersecting area + val partialResults = rtree.search(AABB(5f, 5f, 25f, 25f)) + assertTrue(partialResults.isNotEmpty()) + } + + @Test + fun `test large dataset performance`() { + val rtree = Rtree(maxEntries = 16, minEntries = 4) // Reduce node size for better balance + val numElements = 50_000 + val gridSize = 100 // Grid size 100x100 + + // List to store all elements for naive search + val allElements = mutableListOf>() + + println("Starting insertion of $numElements elements...") + + // Create and shuffle indices for random insertion order + val indices = (0 until numElements).shuffled() + + // Insert elements in random order with varying sizes + for (i in indices) { + val x = (i % gridSize) * 10 + val y = (i / gridSize) * 10 + // Add random element size from 5 to 15 + val size = 5 + (i % 11) + val bounds = AABB( + x.toFloat(), + y.toFloat(), + (x + size).toFloat(), + (y + size).toFloat() + ) + rtree.insert(bounds, "item$i") + allElements.add(bounds to "item$i") + + if (i % 1000 == 0) { + println("Inserted $i elements, current depth: ${rtree.depth()}") + println("Sample bounds for item$i: $bounds") + } + } + + println("Final tree depth: ${rtree.depth()}") + println("Tree size: ${rtree.size()}") + + // Check size + assertEquals(numElements, rtree.size()) + + // Check depth - for 50,000 elements with maxEntries=16 we expect depth around 4-5 + val expectedMinDepth = 4 + val expectedMaxDepth = 6 + assertTrue( + rtree.depth() in expectedMinDepth..expectedMaxDepth, + "Tree depth should be between $expectedMinDepth and $expectedMaxDepth for $numElements elements with maxEntries=16" + ) + + // Search in different areas + val searchAreas = listOf( + // Exact matches with elements + AABB(0f, 0f, 10f, 10f), // Should find elements at (0,0) + AABB(500f, 500f, 510f, 510f), // Should find elements at (500,500) + AABB(990f, 990f, 1000f, 1000f), // Should find elements at (990,990) + + // Large search areas + AABB(0f, 0f, 100f, 100f), // Should find all elements in 100x100 square + AABB(400f, 400f, 600f, 600f), // Should find all elements in 200x200 square + + // Random search areas + AABB(123f, 456f, 133f, 466f), // Random area + AABB(789f, 321f, 799f, 331f), // Random area + + // Edge cases + AABB(-10f, -10f, 0f, 0f), // Area outside grid + AABB(1000f, 1000f, 1010f, 1010f) // Area outside grid + ) + + // Create results string + val results = StringBuilder() + var totalRtreeTime = 0L + var totalNaiveTime = 0L + var totalElementsFound = 0 + + for (area in searchAreas) { + println("\nSearching in area: $area") + + // R-tree search + val rtreeStartTime = Clock.System.now() + val rtreeResults = rtree.search(area) + val rtreeEndTime = Clock.System.now() + val rtreeTime = rtreeEndTime - rtreeStartTime + totalRtreeTime += rtreeTime.inWholeMilliseconds + + // Naive search + val naiveStartTime = Clock.System.now() + val naiveResults = allElements + .filter { (bounds, _) -> bounds.intersects(area) } + .map { it.second } + .toSet() + val naiveEndTime = Clock.System.now() + val naiveTime = naiveEndTime - naiveStartTime + totalNaiveTime += naiveTime.inWholeMilliseconds + totalElementsFound += naiveResults.size + + // Print detailed results + println("R-tree found ${rtreeResults.size} elements") + println("Naive search found ${naiveResults.size} elements") + if (rtreeResults.isNotEmpty()) { + println("Sample R-tree results: ${rtreeResults.take(5)}") + } + if (naiveResults.isNotEmpty()) { + println("Sample naive results: ${naiveResults.take(5)}") + } + + results.append("\nSearch in area $area:\n") + results.append("R-tree: found ${rtreeResults.size} elements in ${rtreeTime.inWholeMilliseconds}ms\n") + results.append("Naive: found ${naiveResults.size} elements in ${naiveTime.inWholeMilliseconds}ms\n") + results.append("Speedup: ${naiveTime.inWholeMilliseconds.toDouble() / rtreeTime.inWholeMilliseconds}x\n") + + // Verify correctness + assertEquals(naiveResults, rtreeResults, "Search results should match") + + // Verify that R-tree is indeed faster + assertTrue(rtreeTime < naiveTime, "R-tree should be faster than naive search") + } + + // Print summary statistics + results.append("\nSummary Statistics:\n") + results.append("Total R-tree time: ${totalRtreeTime}ms\n") + results.append("Total Naive time: ${totalNaiveTime}ms\n") + results.append("Average speedup: ${totalNaiveTime.toDouble() / totalRtreeTime}x\n") + results.append("Tree depth: ${rtree.depth()}\n") + results.append("Total elements: ${rtree.size()}\n") + results.append("Average elements per search: ${totalElementsFound.toDouble() / searchAreas.size}\n") + + println(results.toString()) + } + + @Test + fun `test simple dataset`() { + val rtree = Rtree() + + // Create a simple grid of elements + for (i in 0..2) { + for (j in 0..2) { + val bounds = AABB( + i * 10f, j * 10f, + (i + 1) * 10f, (j + 1) * 10f + ) + val item = "item_${i}_${j}" + rtree.insert(bounds, item) + println("Inserted $item with bounds: $bounds") + } + } + + // Test search in different areas + val testAreas = listOf( + // Search in the middle element (should find all 9 elements due to boundary touching) + AABB(10f, 10f, 20f, 20f) to listOf( + "item_0_0", "item_0_1", "item_0_2", + "item_1_0", "item_1_1", "item_1_2", + "item_2_0", "item_2_1", "item_2_2" + ), + // Search in the corner (should find 4 elements due to boundary touching) + AABB(0f, 0f, 10f, 10f) to listOf( + "item_0_0", "item_0_1", + "item_1_0", "item_1_1" + ), + // Search overlapping two elements (should find 4 elements due to boundary touching) + AABB(5f, 5f, 15f, 15f) to listOf( + "item_0_0", "item_0_1", + "item_1_0", "item_1_1" + ), + // Search outside (should find item_2_2 because it touches at point (30,30)) + AABB(30f, 30f, 40f, 40f) to listOf("item_2_2") + ) + + for ((area, expectedItems) in testAreas) { + println("\nSearching in area: $area") + val results = rtree.search(area) + println("Found items: $results") + println("Expected items: $expectedItems") + + assertEquals( + expectedItems.toSet(), + results, + "Search in area $area should find exactly $expectedItems" + ) + } + } +} \ No newline at end of file diff --git a/library/src/desktopMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.desktop.kt b/library/src/desktopMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.desktop.kt new file mode 100644 index 00000000..ef9447d3 --- /dev/null +++ b/library/src/desktopMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.desktop.kt @@ -0,0 +1,33 @@ +package ovh.plrapps.mapcompose.vector.data + +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.toComposeImageBitmap +import org.jetbrains.skia.ColorAlphaType +import org.jetbrains.skia.ColorType +import org.jetbrains.skia.Image +import org.jetbrains.skia.ImageInfo + +internal actual fun imageBitmapFromArgb(argb: IntArray, width: Int, height: Int): ImageBitmap { + val info = ImageInfo( + width = width, + height = height, + colorType = ColorType.BGRA_8888, + alphaType = ColorAlphaType.PREMUL + ) + + val bytes = ByteArray(width * height * 4) + var j = 0 + for (px in argb) { + bytes[j++] = (px and 0xFF).toByte() // B + bytes[j++] = ((px ushr 8) and 0xFF).toByte() // G + bytes[j++] = ((px ushr 16) and 0xFF).toByte() // R + bytes[j++] = ((px ushr 24) and 0xFF).toByte() // A + } + + val skiaImage = Image.makeRaster(info, bytes, width * 4) + return skiaImage.toComposeImageBitmap() +} + +internal actual fun byteArrayToImageBitmap(bytes: ByteArray): ImageBitmap { + return Image.makeFromEncoded(bytes).toComposeImageBitmap() +} \ No newline at end of file diff --git a/library/src/desktopMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.desktop.kt b/library/src/desktopMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.desktop.kt new file mode 100644 index 00000000..22921acf --- /dev/null +++ b/library/src/desktopMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.desktop.kt @@ -0,0 +1,15 @@ +package ovh.plrapps.mapcompose.vector.data.extension + +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.asSkiaBitmap +import org.jetbrains.skia.EncodedImageFormat +import org.jetbrains.skia.Image + +actual fun ImageBitmap.toBytes(): ByteArray? { + val skiaBmp = this.asSkiaBitmap() + + return Image + .makeFromBitmap(skiaBmp) + .encodeToData(EncodedImageFormat.PNG) + ?.bytes +} \ No newline at end of file diff --git a/library/src/iosMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.ios.kt b/library/src/iosMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.ios.kt new file mode 100644 index 00000000..ef9447d3 --- /dev/null +++ b/library/src/iosMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.ios.kt @@ -0,0 +1,33 @@ +package ovh.plrapps.mapcompose.vector.data + +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.toComposeImageBitmap +import org.jetbrains.skia.ColorAlphaType +import org.jetbrains.skia.ColorType +import org.jetbrains.skia.Image +import org.jetbrains.skia.ImageInfo + +internal actual fun imageBitmapFromArgb(argb: IntArray, width: Int, height: Int): ImageBitmap { + val info = ImageInfo( + width = width, + height = height, + colorType = ColorType.BGRA_8888, + alphaType = ColorAlphaType.PREMUL + ) + + val bytes = ByteArray(width * height * 4) + var j = 0 + for (px in argb) { + bytes[j++] = (px and 0xFF).toByte() // B + bytes[j++] = ((px ushr 8) and 0xFF).toByte() // G + bytes[j++] = ((px ushr 16) and 0xFF).toByte() // R + bytes[j++] = ((px ushr 24) and 0xFF).toByte() // A + } + + val skiaImage = Image.makeRaster(info, bytes, width * 4) + return skiaImage.toComposeImageBitmap() +} + +internal actual fun byteArrayToImageBitmap(bytes: ByteArray): ImageBitmap { + return Image.makeFromEncoded(bytes).toComposeImageBitmap() +} \ No newline at end of file diff --git a/library/src/iosMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.ios.kt b/library/src/iosMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.ios.kt new file mode 100644 index 00000000..22921acf --- /dev/null +++ b/library/src/iosMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.ios.kt @@ -0,0 +1,15 @@ +package ovh.plrapps.mapcompose.vector.data.extension + +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.asSkiaBitmap +import org.jetbrains.skia.EncodedImageFormat +import org.jetbrains.skia.Image + +actual fun ImageBitmap.toBytes(): ByteArray? { + val skiaBmp = this.asSkiaBitmap() + + return Image + .makeFromBitmap(skiaBmp) + .encodeToData(EncodedImageFormat.PNG) + ?.bytes +} \ No newline at end of file diff --git a/library/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.wasmJs.kt b/library/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.wasmJs.kt new file mode 100644 index 00000000..ef9447d3 --- /dev/null +++ b/library/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/vector/data/SpriteManager.wasmJs.kt @@ -0,0 +1,33 @@ +package ovh.plrapps.mapcompose.vector.data + +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.toComposeImageBitmap +import org.jetbrains.skia.ColorAlphaType +import org.jetbrains.skia.ColorType +import org.jetbrains.skia.Image +import org.jetbrains.skia.ImageInfo + +internal actual fun imageBitmapFromArgb(argb: IntArray, width: Int, height: Int): ImageBitmap { + val info = ImageInfo( + width = width, + height = height, + colorType = ColorType.BGRA_8888, + alphaType = ColorAlphaType.PREMUL + ) + + val bytes = ByteArray(width * height * 4) + var j = 0 + for (px in argb) { + bytes[j++] = (px and 0xFF).toByte() // B + bytes[j++] = ((px ushr 8) and 0xFF).toByte() // G + bytes[j++] = ((px ushr 16) and 0xFF).toByte() // R + bytes[j++] = ((px ushr 24) and 0xFF).toByte() // A + } + + val skiaImage = Image.makeRaster(info, bytes, width * 4) + return skiaImage.toComposeImageBitmap() +} + +internal actual fun byteArrayToImageBitmap(bytes: ByteArray): ImageBitmap { + return Image.makeFromEncoded(bytes).toComposeImageBitmap() +} \ No newline at end of file diff --git a/library/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.wasmJs.kt b/library/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.wasmJs.kt new file mode 100644 index 00000000..22921acf --- /dev/null +++ b/library/src/wasmJsMain/kotlin/ovh/plrapps/mapcompose/vector/data/extension/ImageBitmap.wasmJs.kt @@ -0,0 +1,15 @@ +package ovh.plrapps.mapcompose.vector.data.extension + +import androidx.compose.ui.graphics.ImageBitmap +import androidx.compose.ui.graphics.asSkiaBitmap +import org.jetbrains.skia.EncodedImageFormat +import org.jetbrains.skia.Image + +actual fun ImageBitmap.toBytes(): ByteArray? { + val skiaBmp = this.asSkiaBitmap() + + return Image + .makeFromBitmap(skiaBmp) + .encodeToData(EncodedImageFormat.PNG) + ?.bytes +} \ No newline at end of file