initial commit
This commit is contained in:
1
android/.gitignore
vendored
Normal file
1
android/.gitignore
vendored
Normal file
@@ -0,0 +1 @@
|
||||
/build
|
||||
62
android/build.gradle.kts
Normal file
62
android/build.gradle.kts
Normal file
@@ -0,0 +1,62 @@
|
||||
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
|
||||
|
||||
plugins {
|
||||
alias(libs.plugins.android.application)
|
||||
alias(libs.plugins.kotlin.android)
|
||||
}
|
||||
|
||||
android {
|
||||
namespace = "com.icegps.geotools"
|
||||
compileSdk {
|
||||
version = release(36)
|
||||
}
|
||||
|
||||
defaultConfig {
|
||||
applicationId = "com.icegps.geotools"
|
||||
minSdk = 28
|
||||
targetSdk = 36
|
||||
versionCode = 1
|
||||
versionName = "1.0"
|
||||
|
||||
testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
|
||||
}
|
||||
|
||||
buildTypes {
|
||||
release {
|
||||
isMinifyEnabled = false
|
||||
proguardFiles(
|
||||
getDefaultProguardFile("proguard-android-optimize.txt"),
|
||||
"proguard-rules.pro"
|
||||
)
|
||||
}
|
||||
}
|
||||
buildFeatures {
|
||||
viewBinding = true
|
||||
}
|
||||
compileOptions {
|
||||
sourceCompatibility = JavaVersion.VERSION_17
|
||||
targetCompatibility = JavaVersion.VERSION_17
|
||||
}
|
||||
}
|
||||
|
||||
kotlin {
|
||||
compilerOptions.jvmTarget = JvmTarget.JVM_17
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation(libs.core.ktx)
|
||||
implementation(libs.androidx.appcompat)
|
||||
implementation(libs.material)
|
||||
implementation(libs.androidx.activity)
|
||||
implementation(libs.androidx.constraintlayout)
|
||||
implementation(libs.mapbox.maps)
|
||||
implementation(project(":math"))
|
||||
implementation(libs.androidx.lifecycle.runtime.ktx)
|
||||
implementation(project(":icegps-common"))
|
||||
implementation(project(":icegps-shared"))
|
||||
implementation(project(":icegps-triangulation"))
|
||||
|
||||
testImplementation(libs.junit)
|
||||
androidTestImplementation(libs.ext.junit)
|
||||
androidTestImplementation(libs.androidx.espresso.core)
|
||||
}
|
||||
21
android/proguard-rules.pro
vendored
Normal file
21
android/proguard-rules.pro
vendored
Normal file
@@ -0,0 +1,21 @@
|
||||
# Add project specific ProGuard rules here.
|
||||
# You can control the set of applied configuration files using the
|
||||
# proguardFiles setting in build.gradle.
|
||||
#
|
||||
# For more details, see
|
||||
# http://developer.android.com/guide/developing/tools/proguard.html
|
||||
|
||||
# If your project uses WebView with JS, uncomment the following
|
||||
# and specify the fully qualified class name to the JavaScript interface
|
||||
# class:
|
||||
#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
|
||||
# public *;
|
||||
#}
|
||||
|
||||
# Uncomment this to preserve the line number information for
|
||||
# debugging stack traces.
|
||||
#-keepattributes SourceFile,LineNumberTable
|
||||
|
||||
# If you keep the line number information, uncomment this to
|
||||
# hide the original source file name.
|
||||
#-renamesourcefileattribute SourceFile
|
||||
@@ -0,0 +1,24 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import androidx.test.platform.app.InstrumentationRegistry
|
||||
import androidx.test.ext.junit.runners.AndroidJUnit4
|
||||
|
||||
import org.junit.Test
|
||||
import org.junit.runner.RunWith
|
||||
|
||||
import org.junit.Assert.*
|
||||
|
||||
/**
|
||||
* Instrumented test, which will execute on an Android device.
|
||||
*
|
||||
* See [testing documentation](http://d.android.com/tools/testing).
|
||||
*/
|
||||
@RunWith(AndroidJUnit4::class)
|
||||
class ExampleInstrumentedTest {
|
||||
@Test
|
||||
fun useAppContext() {
|
||||
// Context of the app under test.
|
||||
val appContext = InstrumentationRegistry.getInstrumentation().targetContext
|
||||
assertEquals("com.icegps.geotools", appContext.packageName)
|
||||
}
|
||||
}
|
||||
25
android/src/main/AndroidManifest.xml
Normal file
25
android/src/main/AndroidManifest.xml
Normal file
@@ -0,0 +1,25 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
|
||||
<!-- Include this permission to grab user's general location -->
|
||||
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
|
||||
<!-- Include only if your app benefits from precise location access. -->
|
||||
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
|
||||
<application
|
||||
android:allowBackup="true"
|
||||
android:icon="@mipmap/ic_launcher"
|
||||
android:label="@string/app_name"
|
||||
android:roundIcon="@mipmap/ic_launcher_round"
|
||||
android:supportsRtl="true"
|
||||
android:theme="@style/Theme.Orx">
|
||||
<activity
|
||||
android:name=".MainActivity"
|
||||
android:exported="true">
|
||||
<intent-filter>
|
||||
<action android:name="android.intent.action.MAIN" />
|
||||
|
||||
<category android:name="android.intent.category.LAUNCHER" />
|
||||
</intent-filter>
|
||||
</activity>
|
||||
</application>
|
||||
|
||||
</manifest>
|
||||
427
android/src/main/java/com/icegps/geotools/ContoursManager.kt
Normal file
427
android/src/main/java/com/icegps/geotools/ContoursManager.kt
Normal file
@@ -0,0 +1,427 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import ColorBrewer2Type
|
||||
import android.content.Context
|
||||
import android.util.Log
|
||||
import colorBrewer2Palettes
|
||||
import com.icegps.math.geometry.Rectangle
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.icegps.geotools.catmullrom.CatmullRomChain2
|
||||
import com.icegps.geotools.ktx.area
|
||||
import com.icegps.geotools.ktx.toColorInt
|
||||
import com.icegps.geotools.ktx.toMapboxPoint
|
||||
import com.icegps.geotools.ktx.toast
|
||||
import com.icegps.geotools.marchingsquares.ShapeContour
|
||||
import com.icegps.geotools.marchingsquares.findContours
|
||||
import com.icegps.shared.ktx.TAG
|
||||
import com.icegps.triangulation.DelaunayTriangulation
|
||||
import com.icegps.triangulation.Triangle
|
||||
import com.mapbox.geojson.Feature
|
||||
import com.mapbox.geojson.FeatureCollection
|
||||
import com.mapbox.geojson.LineString
|
||||
import com.mapbox.geojson.Polygon
|
||||
import com.mapbox.maps.MapView
|
||||
import com.mapbox.maps.Style
|
||||
import com.mapbox.maps.extension.style.expressions.generated.Expression
|
||||
import com.mapbox.maps.extension.style.layers.addLayer
|
||||
import com.mapbox.maps.extension.style.layers.generated.fillLayer
|
||||
import com.mapbox.maps.extension.style.layers.generated.lineLayer
|
||||
import com.mapbox.maps.extension.style.layers.properties.generated.LineCap
|
||||
import com.mapbox.maps.extension.style.layers.properties.generated.LineJoin
|
||||
import com.mapbox.maps.extension.style.sources.addSource
|
||||
import com.mapbox.maps.extension.style.sources.generated.geoJsonSource
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.Job
|
||||
import kotlinx.coroutines.async
|
||||
import kotlinx.coroutines.awaitAll
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
import kotlin.math.max
|
||||
|
||||
class ContoursManager(
|
||||
private val context: Context,
|
||||
private val mapView: MapView,
|
||||
private val scope: CoroutineScope
|
||||
) {
|
||||
private val sourceId: String = "contours-source-id-10"
|
||||
private val layerId: String = "contours-layer-id-10"
|
||||
private val fillSourceId: String = "contours-fill-source-id-10"
|
||||
private val fillLayerId: String = "contours-fill-layer-id-10"
|
||||
private val gridSourceId: String = "grid-polygon-source-id"
|
||||
private val gridLayerId: String = "grid-polygon-layer-id"
|
||||
|
||||
private var contourSize: Int = 6
|
||||
private var heightRange: ClosedFloatingPointRange<Double> = 0.0..100.0
|
||||
private var cellSize: Double? = 10.0
|
||||
val simplePalette = SimplePalette(
|
||||
range = 0.0..100.0
|
||||
)
|
||||
|
||||
private var colors = colorBrewer2Palettes(
|
||||
numberOfColors = contourSize,
|
||||
paletteType = ColorBrewer2Type.Any
|
||||
).first().colors.reversed()
|
||||
|
||||
private var points: List<Vector3D> = emptyList()
|
||||
|
||||
private val polylineManager = PolylineManager(mapView)
|
||||
|
||||
fun updateContourSize(contourSize: Int) {
|
||||
this.contourSize = contourSize
|
||||
colors = colorBrewer2Palettes(
|
||||
numberOfColors = contourSize,
|
||||
paletteType = ColorBrewer2Type.Any
|
||||
).first().colors.reversed()
|
||||
}
|
||||
|
||||
fun updateCellSize(value: Double) {
|
||||
cellSize = value
|
||||
}
|
||||
|
||||
fun updatePoints(
|
||||
points: List<Vector3D>,
|
||||
) {
|
||||
this.points = points
|
||||
}
|
||||
|
||||
fun updateHeightRange(
|
||||
heightRange: ClosedFloatingPointRange<Double>? = null
|
||||
) {
|
||||
if (heightRange == null) {
|
||||
if (points.isEmpty()) {
|
||||
return
|
||||
}
|
||||
val height = points.map { it.z }
|
||||
val range = height.min()..height.max()
|
||||
this.heightRange = range
|
||||
simplePalette.setRange(range)
|
||||
} else {
|
||||
this.heightRange = heightRange
|
||||
simplePalette.setRange(heightRange)
|
||||
}
|
||||
}
|
||||
|
||||
private var isGridVisible: Boolean = true
|
||||
private var _gridModel = MutableStateFlow<GridModel?>(null)
|
||||
val gridModel = _gridModel.asStateFlow()
|
||||
|
||||
fun setGridVisible(visible: Boolean) {
|
||||
if (visible != isGridVisible) {
|
||||
isGridVisible = visible
|
||||
if (visible) {
|
||||
_gridModel.value?.let { gridModel ->
|
||||
mapView.displayGridModel(
|
||||
grid = gridModel,
|
||||
sourceId = gridSourceId,
|
||||
layerId = gridLayerId,
|
||||
palette = simplePalette::palette
|
||||
)
|
||||
}
|
||||
} else {
|
||||
mapView.mapboxMap.getStyle { style ->
|
||||
try {
|
||||
style.removeStyleLayer(gridLayerId)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
|
||||
if (style.styleSourceExists(gridSourceId)) {
|
||||
style.removeStyleSource(gridSourceId)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private var triangles: List<Triangle> = listOf()
|
||||
private var isTriangleVisible: Boolean = true
|
||||
|
||||
fun setTriangleVisible(visible: Boolean) {
|
||||
if (visible != isTriangleVisible) {
|
||||
isTriangleVisible = visible
|
||||
if (visible) {
|
||||
polylineManager.update(
|
||||
triangles.map {
|
||||
listOf(it.x1, it.x2, it.x3)
|
||||
.map { Vector3D(it.x, it.y, it.z) }
|
||||
}
|
||||
)
|
||||
} else {
|
||||
polylineManager.clearContours()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private var job: Job? = null
|
||||
|
||||
fun refresh() {
|
||||
val points = points
|
||||
if (points.size <= 3) {
|
||||
context.toast("points size ${points.size}")
|
||||
return
|
||||
}
|
||||
job?.cancel()
|
||||
scope.launch {
|
||||
mapView.mapboxMap.getStyle { style ->
|
||||
val step = heightRange.endInclusive / contourSize
|
||||
val zip = (0..contourSize).map { index ->
|
||||
heightRange.start + index * step
|
||||
}.zipWithNext { a, b -> a..b }
|
||||
val area = points.area
|
||||
val triangulation = DelaunayTriangulation(points)
|
||||
val triangles = triangulation.triangles()
|
||||
val cellSize: Double = if (cellSize == null || cellSize!! < 0.1) {
|
||||
(max(triangulation.points.area.width, triangulation.points.area.height) / 50)
|
||||
} else {
|
||||
cellSize!!
|
||||
}
|
||||
scope.launch {
|
||||
val gridModel = triangulationToGrid(
|
||||
delaunator = triangulation,
|
||||
cellSize = cellSize,
|
||||
)
|
||||
this@ContoursManager._gridModel.value = gridModel
|
||||
if (isGridVisible) mapView.displayGridModel(
|
||||
grid = gridModel,
|
||||
sourceId = gridSourceId,
|
||||
layerId = gridLayerId,
|
||||
palette = simplePalette::palette
|
||||
)
|
||||
}
|
||||
job = scope.launch(Dispatchers.Default) {
|
||||
val lineFeatures = mutableListOf<List<Feature>>()
|
||||
val features = zip.mapIndexed { index, range ->
|
||||
async {
|
||||
val contours = findContours(
|
||||
triangles = triangles,
|
||||
range = range,
|
||||
area = area,
|
||||
cellSize = cellSize
|
||||
)
|
||||
val color = colors[index].toColorInt()
|
||||
lineFeatures.add(contoursToLineFeatures(contours, color).flatten())
|
||||
contoursToPolygonFeatures(contours, color)
|
||||
}
|
||||
}.awaitAll()
|
||||
withContext(Dispatchers.Main) {
|
||||
if (false) setupLineLayer(
|
||||
style = style,
|
||||
sourceId = sourceId,
|
||||
layerId = layerId,
|
||||
features = lineFeatures.flatten()
|
||||
)
|
||||
setupFillLayer(
|
||||
style = style,
|
||||
sourceId = fillSourceId,
|
||||
layerId = fillLayerId,
|
||||
features = features.filterNotNull(),
|
||||
)
|
||||
Log.d(TAG, "refresh: 刷新完成")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun findContours(
|
||||
triangles: List<Triangle>,
|
||||
range: ClosedFloatingPointRange<Double>,
|
||||
area: Rectangle,
|
||||
cellSize: Double
|
||||
): List<ShapeContour> {
|
||||
return findContours(
|
||||
f = { v ->
|
||||
val triangle = triangles.firstOrNull { triangle ->
|
||||
isPointInTriangle3D(v, listOf(triangle.x1, triangle.x2, triangle.x3))
|
||||
}
|
||||
(triangle?.let { triangle ->
|
||||
val interpolate = interpolateHeight(
|
||||
point = v,
|
||||
triangle = listOf(
|
||||
triangle.x1,
|
||||
triangle.x2,
|
||||
triangle.x3,
|
||||
)
|
||||
)
|
||||
if (interpolate.z in range) -1.0
|
||||
else 1.0
|
||||
} ?: 1.0).also {
|
||||
Log.d(TAG, "findContours: ${v} -> ${it}")
|
||||
}
|
||||
},
|
||||
area = area,
|
||||
cellSize = cellSize,
|
||||
)
|
||||
}
|
||||
|
||||
private fun setupLineLayer(
|
||||
style: Style,
|
||||
sourceId: String,
|
||||
layerId: String,
|
||||
features: List<Feature>
|
||||
) {
|
||||
style.removeStyleLayer(layerId)
|
||||
style.removeStyleSource(sourceId)
|
||||
|
||||
val source = geoJsonSource(sourceId) {
|
||||
featureCollection(FeatureCollection.fromFeatures(features))
|
||||
}
|
||||
style.addSource(source)
|
||||
|
||||
val layer = lineLayer(layerId, sourceId) {
|
||||
lineColor(Expression.toColor(Expression.Companion.get("color"))) // 从属性获取颜色
|
||||
lineWidth(1.0)
|
||||
lineCap(LineCap.ROUND)
|
||||
lineJoin(LineJoin.ROUND)
|
||||
lineOpacity(0.8)
|
||||
}
|
||||
style.addLayer(layer)
|
||||
}
|
||||
|
||||
private fun setupFillLayer(
|
||||
style: Style,
|
||||
sourceId: String,
|
||||
layerId: String,
|
||||
features: List<Feature>
|
||||
) {
|
||||
style.removeStyleLayer(layerId)
|
||||
style.removeStyleSource(sourceId)
|
||||
|
||||
val source = geoJsonSource(sourceId) {
|
||||
featureCollection(FeatureCollection.fromFeatures(features))
|
||||
}
|
||||
style.addSource(source)
|
||||
|
||||
val layer = fillLayer(layerId, sourceId) {
|
||||
fillColor(Expression.Companion.toColor(Expression.get("color"))) // 从属性获取颜色
|
||||
fillOpacity(0.5)
|
||||
fillAntialias(true)
|
||||
}
|
||||
style.addLayer(layer)
|
||||
}
|
||||
|
||||
private var useCatmullRom: Boolean = true
|
||||
|
||||
fun setCatmullRom(enabled: Boolean) {
|
||||
useCatmullRom = enabled
|
||||
}
|
||||
|
||||
fun contoursToLineFeatures(contours: List<ShapeContour>, color: Int): List<List<Feature>> {
|
||||
return contours.drop(1).map { contour ->
|
||||
contour.segments.map { segment ->
|
||||
LineString.fromLngLats(
|
||||
listOf(
|
||||
segment.start.toMapboxPoint(),
|
||||
segment.end.toMapboxPoint()
|
||||
)
|
||||
)
|
||||
}.map { lineString ->
|
||||
Feature.fromGeometry(lineString).apply {
|
||||
// 将颜色Int转换为十六进制字符串
|
||||
addStringProperty("color", color.toHexColorString())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun contoursToPolygonFeatures(contours: List<ShapeContour>, color: Int): Feature? {
|
||||
val lists = contours.drop(0).filter { it.segments.isNotEmpty() }.map { contour ->
|
||||
val start = contour.segments[0].start
|
||||
listOf(start) + contour.segments.map { it.end }
|
||||
}.map {
|
||||
if (!useCatmullRom) return@map it
|
||||
val cmr = CatmullRomChain2(it, 1.0, loop = true)
|
||||
val contour = ShapeContour.fromPoints(cmr.positions(200), true)
|
||||
val start = contour.segments[0].start
|
||||
listOf(start) + contour.segments.map { it.end }
|
||||
}.map { points -> points.map { it.toMapboxPoint() } }
|
||||
|
||||
if (lists.isEmpty()) {
|
||||
Log.w(TAG, "contoursToPolygonFeatures: 没有有效的轮廓数据")
|
||||
return null
|
||||
}
|
||||
|
||||
val polygon = Polygon.fromLngLats(lists)
|
||||
return Feature.fromGeometry(polygon).apply {
|
||||
// 将颜色Int转换为十六进制字符串
|
||||
addStringProperty("color", color.toHexColorString())
|
||||
}
|
||||
}
|
||||
|
||||
fun Int.toHexColorString(): String {
|
||||
return String.format("#%06X", 0xFFFFFF and this)
|
||||
}
|
||||
|
||||
fun clearContours() {
|
||||
mapView.mapboxMap.getStyle { style ->
|
||||
try {
|
||||
style.removeStyleLayer(layerId)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
try {
|
||||
style.removeStyleSource(sourceId)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun isPointInTriangle3D(point: Vector2D, triangle: List<Vector3D>): Boolean {
|
||||
require(triangle.size == 3) { "三角形必须有3个顶点" }
|
||||
|
||||
val (v1, v2, v3) = triangle
|
||||
|
||||
// 计算重心坐标
|
||||
val denominator = (v2.y - v3.y) * (v1.x - v3.x) + (v3.x - v2.x) * (v1.y - v3.y)
|
||||
if (denominator == 0.0) return false // 退化三角形
|
||||
|
||||
val alpha = ((v2.y - v3.y) * (point.x - v3.x) + (v3.x - v2.x) * (point.y - v3.y)) / denominator
|
||||
val beta = ((v3.y - v1.y) * (point.x - v3.x) + (v1.x - v3.x) * (point.y - v3.y)) / denominator
|
||||
val gamma = 1.0 - alpha - beta
|
||||
|
||||
// 点在三角形内当且仅当所有重心坐标都在[0,1]范围内
|
||||
return alpha >= 0 && beta >= 0 && gamma >= 0 &&
|
||||
alpha <= 1 && beta <= 1 && gamma <= 1
|
||||
}
|
||||
|
||||
/**
|
||||
* 使用重心坐标计算点在三角形上的高度
|
||||
*
|
||||
* @param point 二维点 (x, y)
|
||||
* @param triangle 三角形的三个顶点
|
||||
* @return 三维点 (x, y, z)
|
||||
*/
|
||||
fun interpolateHeight(point: Vector2D, triangle: List<Vector3D>): Vector3D {
|
||||
/**
|
||||
* 计算点在三角形中的重心坐标
|
||||
*/
|
||||
fun calculateBarycentricCoordinates(
|
||||
point: Vector2D,
|
||||
v1: Vector3D,
|
||||
v2: Vector3D,
|
||||
v3: Vector3D
|
||||
): Triple<Double, Double, Double> {
|
||||
val denom = (v2.y - v3.y) * (v1.x - v3.x) + (v3.x - v2.x) * (v1.y - v3.y)
|
||||
|
||||
val alpha = ((v2.y - v3.y) * (point.x - v3.x) + (v3.x - v2.x) * (point.y - v3.y)) / denom
|
||||
val beta = ((v3.y - v1.y) * (point.x - v3.x) + (v1.x - v3.x) * (point.y - v3.y)) / denom
|
||||
val gamma = 1.0 - alpha - beta
|
||||
|
||||
return Triple(alpha, beta, gamma)
|
||||
}
|
||||
|
||||
require(triangle.size == 3) { "三角形必须有3个顶点" }
|
||||
|
||||
val (v1, v2, v3) = triangle
|
||||
|
||||
// 计算重心坐标
|
||||
val (alpha, beta, gamma) = calculateBarycentricCoordinates(point, v1, v2, v3)
|
||||
|
||||
// 使用重心坐标插值z值
|
||||
val z = alpha * v1.z + beta * v2.z + gamma * v3.z
|
||||
|
||||
return Vector3D(point.x, point.y, z)
|
||||
}
|
||||
197
android/src/main/java/com/icegps/geotools/ControllableArrow.kt
Normal file
197
android/src/main/java/com/icegps/geotools/ControllableArrow.kt
Normal file
@@ -0,0 +1,197 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import com.icegps.math.geometry.Angle
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.icegps.geotools.ktx.toMapboxPoint
|
||||
import com.mapbox.geojson.Feature
|
||||
import com.mapbox.geojson.FeatureCollection
|
||||
import com.mapbox.geojson.LineString
|
||||
import com.mapbox.geojson.Point
|
||||
import com.mapbox.geojson.Polygon
|
||||
import com.mapbox.maps.MapView
|
||||
import com.mapbox.maps.Style
|
||||
import com.mapbox.maps.extension.style.expressions.generated.Expression
|
||||
import com.mapbox.maps.extension.style.layers.addLayer
|
||||
import com.mapbox.maps.extension.style.layers.generated.FillLayer
|
||||
import com.mapbox.maps.extension.style.layers.generated.LineLayer
|
||||
import com.mapbox.maps.extension.style.layers.properties.generated.LineCap
|
||||
import com.mapbox.maps.extension.style.layers.properties.generated.LineJoin
|
||||
import com.mapbox.maps.extension.style.sources.addSource
|
||||
import com.mapbox.maps.extension.style.sources.generated.geoJsonSource
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.min
|
||||
import kotlin.math.sin
|
||||
|
||||
/**
|
||||
* 设置趋势箭头图层
|
||||
*/
|
||||
fun setupTrendLayer(
|
||||
style: Style,
|
||||
trendSourceId: String,
|
||||
trendLayerId: String,
|
||||
features: List<Feature>
|
||||
) {
|
||||
val trendSource = geoJsonSource(trendSourceId) {
|
||||
featureCollection(FeatureCollection.fromFeatures(features))
|
||||
}
|
||||
|
||||
try {
|
||||
style.removeStyleLayer(trendLayerId)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
|
||||
try {
|
||||
style.removeStyleLayer("$trendLayerId-head")
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
|
||||
if (style.styleSourceExists(trendSourceId)) {
|
||||
style.removeStyleSource(trendSourceId)
|
||||
}
|
||||
|
||||
style.addSource(trendSource)
|
||||
|
||||
val lineLayer = LineLayer(trendLayerId, trendSourceId).apply {
|
||||
lineColor(Expression.toColor(Expression.get("color")))
|
||||
lineWidth(4.0)
|
||||
lineCap(LineCap.ROUND)
|
||||
lineJoin(LineJoin.ROUND)
|
||||
}
|
||||
style.addLayer(lineLayer)
|
||||
|
||||
val headLayer = FillLayer("$trendLayerId-head", trendSourceId).apply {
|
||||
fillColor(Expression.toColor(Expression.get("color")))
|
||||
}
|
||||
style.addLayer(headLayer)
|
||||
}
|
||||
|
||||
fun MapView.displayControllableArrow(
|
||||
grid: GridModel,
|
||||
sourceId: String = "controllable-source-id-0",
|
||||
layerId: String = "controllable-layer-id-0",
|
||||
arrowScale: Double = 0.4,
|
||||
angle: Angle,
|
||||
onHeadArrowChange: (List<Point>) -> Unit
|
||||
) {
|
||||
mapboxMap.getStyle { style ->
|
||||
val centerX = (grid.minX + grid.maxX) / 2
|
||||
val centerY = (grid.minY + grid.maxY) / 2
|
||||
|
||||
val regionWidth = grid.maxX - grid.minX
|
||||
val regionHeight = grid.maxY - grid.minY
|
||||
val arrowLength = min(regionWidth, regionHeight) * arrowScale * 1.0
|
||||
|
||||
val arrowDirectionRad = angle.radians
|
||||
val endX = centerX + sin(arrowDirectionRad) * arrowLength
|
||||
val endY = centerY + cos(arrowDirectionRad) * arrowLength
|
||||
|
||||
val arrowLine = LineString.fromLngLats(
|
||||
listOf(
|
||||
Vector2D(centerX, centerY),
|
||||
Vector2D(endX, endY)
|
||||
).map { it.toMapboxPoint() }
|
||||
)
|
||||
|
||||
val arrowFeature = Feature.fromGeometry(arrowLine)
|
||||
arrowFeature.addStringProperty("color", "#0000FF")
|
||||
arrowFeature.addStringProperty("type", "overall-trend")
|
||||
|
||||
// 创建箭头头部
|
||||
val headSize = arrowLength * 0.2
|
||||
val leftRad = arrowDirectionRad + Math.PI * 0.8
|
||||
val rightRad = arrowDirectionRad - Math.PI * 0.8
|
||||
|
||||
val leftX = endX + sin(leftRad) * headSize
|
||||
val leftY = endY + cos(leftRad) * headSize
|
||||
val rightX = endX + sin(rightRad) * headSize
|
||||
val rightY = endY + cos(rightRad) * headSize
|
||||
|
||||
val headRing = listOf(
|
||||
Vector2D(endX, endY),
|
||||
Vector2D(leftX, leftY),
|
||||
Vector2D(rightX, rightY),
|
||||
Vector2D(endX, endY)
|
||||
).map { it.toMapboxPoint() }
|
||||
onHeadArrowChange(headRing)
|
||||
val headPolygon = Polygon.fromLngLats(listOf(headRing))
|
||||
val headFeature = Feature.fromGeometry(headPolygon)
|
||||
headFeature.addStringProperty("color", "#0000FF")
|
||||
headFeature.addStringProperty("type", "overall-trend")
|
||||
|
||||
val features = listOf(arrowFeature, headFeature)
|
||||
|
||||
// 设置图层
|
||||
setupTrendLayer(style, sourceId, layerId, features)
|
||||
}
|
||||
}
|
||||
|
||||
fun calculateArrowData(
|
||||
grid: GridModel,
|
||||
angle: Angle,
|
||||
arrowScale: Double = 0.4
|
||||
): ArrowData {
|
||||
val centerX = (grid.minX + grid.maxX) / 2
|
||||
val centerY = (grid.minY + grid.maxY) / 2
|
||||
|
||||
val regionWidth = grid.maxX - grid.minX
|
||||
val regionHeight = grid.maxY - grid.minY
|
||||
val arrowLength = min(regionWidth, regionHeight) * arrowScale * 1.0
|
||||
|
||||
val arrowDirectionRad = angle.radians
|
||||
val endX = centerX + sin(arrowDirectionRad) * arrowLength
|
||||
val endY = centerY + cos(arrowDirectionRad) * arrowLength
|
||||
|
||||
val arrowLine = listOf(
|
||||
Vector2D(centerX, centerY),
|
||||
Vector2D(endX, endY)
|
||||
)
|
||||
|
||||
// 创建箭头头部
|
||||
val headSize = arrowLength * 0.2
|
||||
val leftRad = arrowDirectionRad + Math.PI * 0.8
|
||||
val rightRad = arrowDirectionRad - Math.PI * 0.8
|
||||
|
||||
val leftX = endX + sin(leftRad) * headSize
|
||||
val leftY = endY + cos(leftRad) * headSize
|
||||
val rightX = endX + sin(rightRad) * headSize
|
||||
val rightY = endY + cos(rightRad) * headSize
|
||||
|
||||
val headRing = listOf(
|
||||
Vector2D(endX, endY),
|
||||
Vector2D(leftX, leftY),
|
||||
Vector2D(rightX, rightY),
|
||||
Vector2D(endX, endY)
|
||||
)
|
||||
return ArrowData(
|
||||
arrowLine = arrowLine,
|
||||
headRing = headRing
|
||||
)
|
||||
}
|
||||
|
||||
data class ArrowData(
|
||||
val arrowLine: List<Vector2D>,
|
||||
val headRing: List<Vector2D>
|
||||
)
|
||||
|
||||
fun MapView.displayControllableArrow(
|
||||
sourceId: String = "controllable-source-id-0",
|
||||
layerId: String = "controllable-layer-id-0",
|
||||
arrowData: ArrowData
|
||||
) {
|
||||
mapboxMap.getStyle { style ->
|
||||
val (arrowLine, headRing) = arrowData
|
||||
val arrowFeature = Feature.fromGeometry(LineString.fromLngLats(arrowLine.map { it.toMapboxPoint() }))
|
||||
arrowFeature.addStringProperty("color", "#0000FF")
|
||||
arrowFeature.addStringProperty("type", "overall-trend")
|
||||
|
||||
val headPolygon = Polygon.fromLngLats(listOf(headRing.map { it.toMapboxPoint() }))
|
||||
val headFeature = Feature.fromGeometry(headPolygon)
|
||||
headFeature.addStringProperty("color", "#0000FF")
|
||||
headFeature.addStringProperty("type", "overall-trend")
|
||||
|
||||
val features = listOf(arrowFeature, headFeature)
|
||||
|
||||
// 设置图层
|
||||
setupTrendLayer(style, sourceId, layerId, features)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import com.icegps.math.geometry.Angle
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.icegps.math.geometry.degrees
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.sin
|
||||
import kotlin.random.Random
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/25
|
||||
*/
|
||||
fun coordinateGenerate(): List<Vector3D> {
|
||||
val minX = -20.0
|
||||
val maxX = 20.0
|
||||
val minY = -20.0
|
||||
val maxY = 20.0
|
||||
val minZ = -20.0
|
||||
val maxZ = 20.0
|
||||
val x: () -> Double = { Random.nextDouble(minX, maxX) }
|
||||
val y: () -> Double = { Random.nextDouble(minY, maxY) }
|
||||
val z: () -> Double = { Random.nextDouble(minZ, maxZ) }
|
||||
val dPoints = (0..60).map {
|
||||
Vector3D(x(), y(), z())
|
||||
}
|
||||
return dPoints
|
||||
}
|
||||
|
||||
fun coordinateGenerate1(): List<List<Vector3D>> {
|
||||
/**
|
||||
* 绕 Z 轴旋转指定角度（弧度）
|
||||
*/
|
||||
fun Vector3D.rotateAroundZ(angle: Angle): Vector3D {
|
||||
val cosAngle = cos(angle.radians)
|
||||
val sinAngle = sin(angle.radians)
|
||||
|
||||
return Vector3D(
|
||||
x = x * cosAngle - y * sinAngle,
|
||||
y = x * sinAngle + y * cosAngle,
|
||||
z = z
|
||||
)
|
||||
}
|
||||
|
||||
val center = Vector3D()
|
||||
val direction = Vector3D(0.0, 1.0, -1.0)
|
||||
return (0..360).step(10).map {
|
||||
val nowDirection = direction.rotateAroundZ(it.degrees)
|
||||
listOf(2, 6, 10).map {
|
||||
center + nowDirection * it
|
||||
}
|
||||
}
|
||||
}
|
||||
144
android/src/main/java/com/icegps/geotools/DisplaySlopeResult.kt
Normal file
144
android/src/main/java/com/icegps/geotools/DisplaySlopeResult.kt
Normal file
@@ -0,0 +1,144 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import android.util.Log
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.icegps.geotools.ktx.toMapboxPoint
|
||||
import com.mapbox.geojson.Feature
|
||||
import com.mapbox.geojson.FeatureCollection
|
||||
import com.mapbox.geojson.Polygon
|
||||
import com.mapbox.maps.MapView
|
||||
import com.mapbox.maps.Style
|
||||
import com.mapbox.maps.extension.style.expressions.generated.Expression
|
||||
import com.mapbox.maps.extension.style.layers.addLayer
|
||||
import com.mapbox.maps.extension.style.layers.generated.FillLayer
|
||||
import com.mapbox.maps.extension.style.layers.generated.LineLayer
|
||||
import com.mapbox.maps.extension.style.sources.addSource
|
||||
import com.mapbox.maps.extension.style.sources.generated.geoJsonSource
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/26
|
||||
*/
|
||||
/**
|
||||
* 绘制斜坡设计结果
|
||||
*/
|
||||
fun MapView.displaySlopeResult(
|
||||
originalGrid: GridModel,
|
||||
slopeResult: SlopeResult,
|
||||
sourceId: String = "slope-result",
|
||||
layerId: String = "slope-layer",
|
||||
palette: (Double?) -> String,
|
||||
showDesignHeight: Boolean
|
||||
) {
|
||||
val elevationList = mutableListOf<Double>()
|
||||
mapboxMap.getStyle { style ->
|
||||
val features = mutableListOf<Feature>()
|
||||
val designGrid = slopeResult.designSurface
|
||||
|
||||
// 对比测试，将绘制到原来图形的左边
|
||||
// val minX = originalGrid.minX * 2 - originalGrid.maxX
|
||||
val minX = originalGrid.minX
|
||||
val maxY = originalGrid.maxY
|
||||
|
||||
val cellSize = originalGrid.cellSize
|
||||
|
||||
for (r in 0 until originalGrid.rows) {
|
||||
for (c in 0 until originalGrid.cols) {
|
||||
val originalElev = originalGrid.getValue(r, c) ?: continue
|
||||
val designElev = designGrid.getValue(r, c) ?: continue
|
||||
elevationList.add(designElev)
|
||||
|
||||
// 计算填挖高度
|
||||
val heightDiff = designElev - originalElev
|
||||
|
||||
// 计算栅格边界
|
||||
val x0 = minX + c * cellSize
|
||||
val y0 = maxY - r * cellSize
|
||||
val x1 = x0 + cellSize
|
||||
val y1 = y0 - cellSize
|
||||
|
||||
// 1. 创建多边形要素（背景色）
|
||||
val ring = listOf(
|
||||
Vector2D(x0, y0),
|
||||
Vector2D(x1, y0),
|
||||
Vector2D(x1, y1),
|
||||
Vector2D(x0, y1),
|
||||
Vector2D(x0, y0)
|
||||
).map { it.toMapboxPoint() }
|
||||
val poly = Polygon.fromLngLats(listOf(ring))
|
||||
val feature = Feature.fromGeometry(poly)
|
||||
|
||||
if (showDesignHeight) {
|
||||
// 显示设计高度，测试坡向是否正确，和高度是否计算正确
|
||||
feature.addStringProperty("color", palette(designElev))
|
||||
} else {
|
||||
// 显示高差
|
||||
feature.addStringProperty("color", palette(heightDiff))
|
||||
}
|
||||
// 显示原始高度
|
||||
// feature.addStringProperty("color", palette(originalElev))
|
||||
features.add(feature)
|
||||
}
|
||||
}
|
||||
|
||||
Log.d("displayGridWithDirectionArrows", "对比区域的土方量计算: ${elevationList.sum()}, 平均值：${elevationList.average()}")
|
||||
|
||||
// 设置图层
|
||||
setupEarthworkLayer(style, sourceId, layerId, features)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 完整的土方工程图层设置 - 修正版
|
||||
*/
|
||||
private fun setupEarthworkLayer(
|
||||
style: Style,
|
||||
sourceId: String,
|
||||
layerId: String,
|
||||
features: List<Feature>,
|
||||
) {
|
||||
// 创建数据源
|
||||
val source = geoJsonSource(sourceId) {
|
||||
featureCollection(FeatureCollection.fromFeatures(features))
|
||||
}
|
||||
|
||||
// 清理旧图层
|
||||
try {
|
||||
style.removeStyleLayer(layerId)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
try {
|
||||
style.removeStyleLayer("$layerId-arrow")
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
try {
|
||||
style.removeStyleLayer("$layerId-outline")
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
try {
|
||||
style.removeStyleLayer("$layerId-text")
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
|
||||
if (style.styleSourceExists(sourceId)) {
|
||||
style.removeStyleSource(sourceId)
|
||||
}
|
||||
|
||||
// 添加数据源
|
||||
style.addSource(source)
|
||||
|
||||
// 主填充图层
|
||||
val fillLayer = FillLayer(layerId, sourceId).apply {
|
||||
fillColor(Expression.toColor(Expression.get("color")))
|
||||
fillOpacity(0.7)
|
||||
}
|
||||
style.addLayer(fillLayer)
|
||||
|
||||
// 边框图层
|
||||
val outlineLayer = LineLayer("$layerId-outline", sourceId).apply {
|
||||
lineColor("#333333")
|
||||
lineWidth(1.0)
|
||||
lineOpacity(0.5)
|
||||
}
|
||||
style.addLayer(outlineLayer)
|
||||
}
|
||||
438
android/src/main/java/com/icegps/geotools/EarthworkManager.kt
Normal file
438
android/src/main/java/com/icegps/geotools/EarthworkManager.kt
Normal file
@@ -0,0 +1,438 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import android.graphics.PointF
|
||||
import android.util.Log
|
||||
import com.icegps.common.helper.GeoHelper
|
||||
import com.icegps.math.geometry.Angle
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.icegps.math.geometry.degrees
|
||||
import com.icegps.shared.ktx.TAG
|
||||
import com.mapbox.android.gestures.MoveGestureDetector
|
||||
import com.mapbox.geojson.Point
|
||||
import com.mapbox.maps.MapView
|
||||
import com.mapbox.maps.ScreenCoordinate
|
||||
import com.mapbox.maps.plugin.gestures.OnMoveListener
|
||||
import com.mapbox.maps.plugin.gestures.addOnMoveListener
|
||||
import com.mapbox.maps.plugin.gestures.removeOnMoveListener
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.asStateFlow
|
||||
import kotlinx.coroutines.flow.combine
|
||||
import kotlinx.coroutines.flow.launchIn
|
||||
import kotlin.math.abs
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.sin
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/26
|
||||
*/
|
||||
object SlopeCalculator {
|
||||
fun calculateSlope(
|
||||
grid: GridModel,
|
||||
slopeDirection: Double,
|
||||
slopePercentage: Double,
|
||||
baseHeightOffset: Double = 0.0
|
||||
): SlopeResult {
|
||||
val centerX = (grid.minX + grid.maxX) / 2
|
||||
val centerY = (grid.minY + grid.maxY) / 2
|
||||
|
||||
val elevations = grid.cells.filterNotNull()
|
||||
val baseElevation = elevations.average() + baseHeightOffset
|
||||
|
||||
val basePoint = Triple(centerX, centerY, baseElevation)
|
||||
|
||||
val earthworkResult = EarthworkCalculator.calculateForSlopeDesign(
|
||||
grid = grid,
|
||||
basePoint = basePoint,
|
||||
slope = slopePercentage,
|
||||
aspect = slopeDirection
|
||||
)
|
||||
|
||||
return SlopeResult(
|
||||
slopeDirection = slopeDirection,
|
||||
slopePercentage = slopePercentage,
|
||||
baseHeightOffset = baseHeightOffset,
|
||||
baseElevation = baseElevation,
|
||||
earthworkResult = earthworkResult,
|
||||
designSurface = generateSlopeDesignGrid(
|
||||
grid = grid,
|
||||
basePoint = basePoint,
|
||||
slopePercentage = slopePercentage,
|
||||
slopeDirection = slopeDirection
|
||||
)
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* 生成斜坡设计面网格（用于可视化）
|
||||
*/
|
||||
private fun generateSlopeDesignGrid(
|
||||
grid: GridModel,
|
||||
basePoint: Triple<Double, Double, Double>,
|
||||
slopePercentage: Double,
|
||||
slopeDirection: Double
|
||||
): GridModel {
|
||||
val designCells = Array<Double?>(grid.rows * grid.cols) { null }
|
||||
val (baseX, baseY, baseElev) = basePoint
|
||||
val slopeRatio = slopePercentage / 100.0
|
||||
|
||||
for (r in 0 until grid.rows) {
|
||||
for (c in 0 until grid.cols) {
|
||||
if (grid.getValue(r, c) != null) {
|
||||
val cellX = grid.minX + (c + 0.5) * (grid.maxX - grid.minX) / grid.cols
|
||||
val cellY = grid.minY + (r + 0.5) * (grid.maxY - grid.minY) / grid.rows
|
||||
|
||||
val designElev = calculateSlopeElevation(
|
||||
pointX = cellX,
|
||||
pointY = cellY,
|
||||
baseX = baseX,
|
||||
baseY = baseY,
|
||||
baseElev = baseElev,
|
||||
slopeRatio = slopeRatio,
|
||||
slopeDirection = slopeDirection
|
||||
)
|
||||
designCells[r * grid.cols + c] = designElev
|
||||
}
|
||||
}
|
||||
}
|
||||
return GridModel(
|
||||
minX = grid.minX,
|
||||
maxX = grid.maxX,
|
||||
minY = grid.minY,
|
||||
maxY = grid.maxY,
|
||||
rows = grid.rows,
|
||||
cols = grid.cols,
|
||||
cellSize = grid.cellSize,
|
||||
cells = designCells
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* 斜坡高程计算
|
||||
*/
|
||||
fun calculateSlopeElevation(
|
||||
pointX: Double,
|
||||
pointY: Double,
|
||||
baseX: Double,
|
||||
baseY: Double,
|
||||
baseElev: Double,
|
||||
slopeRatio: Double,
|
||||
slopeDirection: Double
|
||||
): Double {
|
||||
val dx = (pointX - baseX) * cos(Math.toRadians(baseY))
|
||||
val dy = (pointY - baseY)
|
||||
|
||||
val slopeRad = (slopeDirection.degrees - 90.degrees).normalized.radians
|
||||
|
||||
val projection = dx * cos(slopeRad) + dy * sin(slopeRad)
|
||||
val heightDiff = projection * slopeRatio
|
||||
|
||||
return baseElev + heightDiff
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 斜面设计
|
||||
*
|
||||
* @property slopeDirection 坡向 (度)
|
||||
* @property slopePercentage 坡度 (%)
|
||||
* @property baseHeightOffset 基准面高度偏移 (m)
|
||||
* @property baseElevation 基准点高程 (m)
|
||||
* @property earthworkResult 土方量结果
|
||||
* @property designSurface 设计面网格（用于可视化）
|
||||
*/
|
||||
data class SlopeResult(
|
||||
val slopeDirection: Double,
|
||||
val slopePercentage: Double,
|
||||
val baseHeightOffset: Double,
|
||||
val baseElevation: Double,
|
||||
val earthworkResult: EarthworkResult,
|
||||
val designSurface: GridModel
|
||||
)
|
||||
|
||||
object EarthworkCalculator {
|
||||
/**
|
||||
* @param grid 栅格网模型
|
||||
* @param designElevation 设计高程
|
||||
*/
|
||||
fun calculateForFlatDesign(
|
||||
grid: GridModel,
|
||||
designElevation: Double
|
||||
): EarthworkResult {
|
||||
var cutVolume = 0.0
|
||||
var fillVolume = 0.0
|
||||
var cutArea = 0.0
|
||||
var fillArea = 0.0
|
||||
val cellArea = grid.cellSize * grid.cellSize
|
||||
|
||||
for (r in 0 until grid.rows) {
|
||||
for (c in 0 until grid.cols) {
|
||||
val originalElev = grid.getValue(r, c) ?: continue
|
||||
|
||||
val heightDiff = designElevation - originalElev
|
||||
|
||||
val volume = heightDiff * cellArea
|
||||
|
||||
if (volume > 0) {
|
||||
fillVolume += volume
|
||||
fillArea += cellArea
|
||||
} else if (volume < 0) {
|
||||
cutVolume += abs(volume)
|
||||
cutArea += cellArea
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return EarthworkResult(
|
||||
cutVolume = cutVolume,
|
||||
fillVolume = fillVolume,
|
||||
netVolume = fillVolume - cutVolume,
|
||||
cutArea = cutArea,
|
||||
fillArea = fillArea,
|
||||
totalArea = cutArea + fillArea
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* 计算斜面设计的土方量
|
||||
*/
|
||||
fun calculateForSlopeDesign(
|
||||
grid: GridModel,
|
||||
basePoint: Triple<Double, Double, Double>,
|
||||
slope: Double,
|
||||
aspect: Double
|
||||
): EarthworkResult {
|
||||
var cutVolume = 0.0
|
||||
var fillVolume = 0.0
|
||||
var cutArea = 0.0
|
||||
var fillArea = 0.0
|
||||
val cellArea = grid.cellSize * grid.cellSize
|
||||
|
||||
val (baseX, baseY, baseElev) = basePoint
|
||||
val slopeRatio = slope / 100.0
|
||||
|
||||
for (r in 0 until grid.rows) {
|
||||
for (c in 0 until grid.cols) {
|
||||
val originalElev = grid.getValue(r, c) ?: continue
|
||||
|
||||
val cellX = grid.minX + (c + 0.5) * (grid.maxX - grid.minX) / grid.cols
|
||||
val cellY = grid.minY + (r + 0.5) * (grid.maxY - grid.minY) / grid.rows
|
||||
|
||||
val designElev = SlopeCalculator.calculateSlopeElevation(
|
||||
pointX = cellX,
|
||||
pointY = cellY,
|
||||
baseX = baseX,
|
||||
baseY = baseY,
|
||||
baseElev = baseElev,
|
||||
slopeRatio = slopeRatio,
|
||||
slopeDirection = aspect
|
||||
)
|
||||
|
||||
val heightElev = designElev - originalElev
|
||||
val volume = heightElev * cellArea
|
||||
|
||||
if (volume > 0) {
|
||||
fillVolume += volume
|
||||
fillArea += cellArea
|
||||
} else if (volume < 0) {
|
||||
cutVolume += abs(volume)
|
||||
cutArea += cellArea
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return EarthworkResult(
|
||||
cutVolume = cutVolume,
|
||||
fillVolume = fillVolume,
|
||||
netVolume = fillVolume - cutVolume,
|
||||
cutArea = cutArea,
|
||||
fillArea = fillArea,
|
||||
totalArea = cutArea + fillArea
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 土方量计算结果
|
||||
* @property cutVolume 挖方量 (m³)
|
||||
* @property fillVolume 填方量 (m³)
|
||||
* @property netVolume 净土方量 (m³)
|
||||
* @property cutArea 挖方面积 (m²)
|
||||
* @property fillArea 填方面积 (m²)
|
||||
* @property totalArea 总面积 (m²)
|
||||
*/
|
||||
data class EarthworkResult(
|
||||
val cutVolume: Double,
|
||||
val fillVolume: Double,
|
||||
val netVolume: Double,
|
||||
val cutArea: Double,
|
||||
val fillArea: Double,
|
||||
val totalArea: Double
|
||||
) {
|
||||
override fun toString(): String {
|
||||
return buildString {
|
||||
appendLine("EarthworkResult")
|
||||
appendLine("挖方: ${"%.1f".format(cutVolume)} m³")
|
||||
appendLine("填方: ${"%.1f".format(fillVolume)} m³")
|
||||
appendLine("净土方: ${"%.1f".format(netVolume)} m³")
|
||||
appendLine("挖方面积: ${"%.1f".format(cutArea)} m²")
|
||||
appendLine("填方面积: ${"%.1f".format(fillArea)} m²")
|
||||
appendLine("总面积：${"%.1f".format(totalArea)} m²")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class EarthworkManager(
|
||||
private val mapView: MapView,
|
||||
private val scope: CoroutineScope
|
||||
) {
|
||||
private val arrowSourceId: String = "controllable-source-id-0"
|
||||
private val arrowLayerId: String = "controllable-layer-id-0"
|
||||
private var listener: OnMoveListener? = null
|
||||
|
||||
private var gridModel = MutableStateFlow<GridModel?>(null)
|
||||
private val arrowHead = MutableStateFlow(emptyList<Vector2D>())
|
||||
private var arrowCenter = MutableStateFlow(Vector2D(0.0, 0.0))
|
||||
private var arrowEnd = MutableStateFlow(Vector2D(0.0, 1.0))
|
||||
private var _slopeDirection = MutableStateFlow(0.degrees)
|
||||
val slopeDirection = _slopeDirection.asStateFlow()
|
||||
private val _slopePercentage = MutableStateFlow(90.0)
|
||||
val slopePercentage = _slopePercentage.asStateFlow()
|
||||
private val _baseHeightOffset = MutableStateFlow(0.0)
|
||||
val baseHeightOffset = _baseHeightOffset.asStateFlow()
|
||||
|
||||
init {
|
||||
combine(
|
||||
arrowCenter,
|
||||
arrowEnd,
|
||||
gridModel
|
||||
) { center, arrow, gridModel ->
|
||||
gridModel?.let { gridModel ->
|
||||
// _slopeDirection.value = angle
|
||||
displayControllableArrow(gridModel, getSlopeDirection(arrow, center))
|
||||
}
|
||||
}.launchIn(scope)
|
||||
combine(
|
||||
_slopeDirection,
|
||||
gridModel
|
||||
) { slopeDirection, gridModel ->
|
||||
gridModel?.let {
|
||||
displayControllableArrow(it, slopeDirection)
|
||||
}
|
||||
}.launchIn(scope)
|
||||
}
|
||||
|
||||
private fun getSlopeDirection(
|
||||
arrow: Vector2D,
|
||||
center: Vector2D
|
||||
): Angle {
|
||||
val direction = (arrow - center)
|
||||
val atan2 = Angle.atan2(direction.x, direction.y, Vector2D.UP)
|
||||
val angle = atan2.normalized
|
||||
return angle
|
||||
}
|
||||
|
||||
private fun displayControllableArrow(gridModel: GridModel, slopeDirection: Angle) {
|
||||
val arrowData = calculateArrowData(
|
||||
grid = gridModel,
|
||||
angle = slopeDirection,
|
||||
)
|
||||
arrowHead.value = arrowData.headRing
|
||||
mapView.displayControllableArrow(
|
||||
sourceId = arrowSourceId,
|
||||
layerId = arrowLayerId,
|
||||
arrowData = arrowData,
|
||||
)
|
||||
}
|
||||
|
||||
fun Point.toVector2D(): Vector2D {
|
||||
val geoHelper = GeoHelper.getSharedInstance()
|
||||
val enu = geoHelper.wgs84ToENU(lon = longitude(), lat = latitude(), hgt = 0.0)
|
||||
return Vector2D(enu.x, enu.y)
|
||||
}
|
||||
|
||||
fun removeOnMoveListener() {
|
||||
listener?.let(mapView.mapboxMap::removeOnMoveListener)
|
||||
listener = null
|
||||
}
|
||||
|
||||
fun setupOnMoveListener() {
|
||||
listener = object : OnMoveListener {
|
||||
private var beginning: Boolean = false
|
||||
private var isDragging: Boolean = false
|
||||
private fun getCoordinate(focalPoint: PointF): Point {
|
||||
return mapView.mapboxMap.coordinateForPixel(ScreenCoordinate(focalPoint.x.toDouble(), focalPoint.y.toDouble()))
|
||||
}
|
||||
|
||||
override fun onMove(detector: MoveGestureDetector): Boolean {
|
||||
val focalPoint = detector.focalPoint
|
||||
val point = mapView.mapboxMap
|
||||
.coordinateForPixel(ScreenCoordinate(focalPoint.x.toDouble(), focalPoint.y.toDouble()))
|
||||
.toVector2D()
|
||||
|
||||
val isPointInPolygon = RayCastingAlgorithm.isPointInPolygon(
|
||||
point = point,
|
||||
polygon = arrowHead.value
|
||||
)
|
||||
|
||||
if (isPointInPolygon) {
|
||||
isDragging = true
|
||||
}
|
||||
if (isDragging) {
|
||||
arrowEnd.value = point
|
||||
}
|
||||
return isDragging
|
||||
}
|
||||
|
||||
override fun onMoveBegin(detector: MoveGestureDetector) {
|
||||
Log.d(TAG, "onMoveBegin: $detector")
|
||||
beginning = true
|
||||
}
|
||||
|
||||
override fun onMoveEnd(detector: MoveGestureDetector) {
|
||||
Log.d(TAG, "onMoveEnd: $detector")
|
||||
val point = getCoordinate(detector.focalPoint)
|
||||
val arrow = point.toVector2D()
|
||||
if (beginning && isDragging) {
|
||||
arrowEnd.value = arrow
|
||||
val center = arrowCenter.value
|
||||
_slopeDirection.value = getSlopeDirection(arrow, center)
|
||||
}
|
||||
Log.d(
|
||||
TAG,
|
||||
buildString {
|
||||
appendLine("onMoveEnd: ")
|
||||
appendLine("${point.longitude()}, ${point.latitude()}")
|
||||
}
|
||||
)
|
||||
isDragging = false
|
||||
beginning = false
|
||||
}
|
||||
}.also(mapView.mapboxMap::addOnMoveListener)
|
||||
}
|
||||
|
||||
fun updateGridModel(gridModel: GridModel) {
|
||||
this.gridModel.value = gridModel
|
||||
calculateArrowCenter(gridModel)
|
||||
}
|
||||
|
||||
private fun calculateArrowCenter(gridModel: GridModel) {
|
||||
val centerX = (gridModel.minX + gridModel.maxX) / 2
|
||||
val centerY = (gridModel.minY + gridModel.maxY) / 2
|
||||
arrowCenter.value = Vector2D(centerX, centerY)
|
||||
}
|
||||
|
||||
fun updateSlopeDirection(angle: Angle) {
|
||||
_slopeDirection.value = angle
|
||||
}
|
||||
|
||||
fun updateSlopePercentage(value: Double) {
|
||||
_slopePercentage.value = value
|
||||
}
|
||||
|
||||
fun updateDesignHeight(value: Double) {
|
||||
_baseHeightOffset.value = value
|
||||
}
|
||||
}
|
||||
83
android/src/main/java/com/icegps/geotools/GridDisplay.kt
Normal file
83
android/src/main/java/com/icegps/geotools/GridDisplay.kt
Normal file
@@ -0,0 +1,83 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import com.icegps.common.helper.GeoHelper
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.mapbox.geojson.Feature
|
||||
import com.mapbox.geojson.FeatureCollection
|
||||
import com.mapbox.geojson.Point
|
||||
import com.mapbox.geojson.Polygon
|
||||
import com.mapbox.maps.MapView
|
||||
import com.mapbox.maps.extension.style.expressions.generated.Expression
|
||||
import com.mapbox.maps.extension.style.layers.addLayer
|
||||
import com.mapbox.maps.extension.style.layers.generated.FillLayer
|
||||
import com.mapbox.maps.extension.style.sources.addSource
|
||||
import com.mapbox.maps.extension.style.sources.generated.geoJsonSource
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/25
|
||||
*/
|
||||
fun MapView.displayGridModel(
|
||||
grid: GridModel,
|
||||
sourceId: String,
|
||||
layerId: String,
|
||||
palette: (Double?) -> String,
|
||||
) {
|
||||
val geoHelper = GeoHelper.getSharedInstance()
|
||||
mapboxMap.getStyle { style ->
|
||||
val polygonFeatures = mutableListOf<Feature>()
|
||||
|
||||
val minX = grid.minX
|
||||
val maxY = grid.maxY
|
||||
val cellSize = grid.cellSize
|
||||
|
||||
for (r in 0 until grid.rows) {
|
||||
for (c in 0 until grid.cols) {
|
||||
val idx = r * grid.cols + c
|
||||
val v = grid.cells[idx] ?: continue
|
||||
|
||||
val x0 = minX + c * cellSize
|
||||
val y0 = maxY - r * cellSize
|
||||
val x1 = x0 + cellSize
|
||||
val y1 = y0 - cellSize
|
||||
|
||||
val ring = listOf(
|
||||
Vector2D(x0, y0),
|
||||
Vector2D(x1, y0),
|
||||
Vector2D(x1, y1),
|
||||
Vector2D(x0, y1),
|
||||
Vector2D(x0, y0),
|
||||
).map {
|
||||
geoHelper.enuToWGS84Object(GeoHelper.ENU(it.x, it.y))
|
||||
}.map {
|
||||
Point.fromLngLat(it.lon, it.lat)
|
||||
}
|
||||
val poly = Polygon.fromLngLats(listOf(ring))
|
||||
val polyFeature = Feature.fromGeometry(poly)
|
||||
polyFeature.addStringProperty("color", palette(v))
|
||||
polyFeature.addNumberProperty("value", v ?: -9999.0)
|
||||
polygonFeatures.add(polyFeature)
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
style.removeStyleLayer(layerId)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
|
||||
if (style.styleSourceExists(sourceId)) {
|
||||
style.removeStyleSource(sourceId)
|
||||
}
|
||||
|
||||
val polygonSource = geoJsonSource(sourceId) {
|
||||
featureCollection(FeatureCollection.fromFeatures(polygonFeatures))
|
||||
}
|
||||
style.addSource(polygonSource)
|
||||
|
||||
val fillLayer = FillLayer(layerId, sourceId).apply {
|
||||
fillColor(Expression.toColor(Expression.get("color")))
|
||||
fillOpacity(0.5)
|
||||
}
|
||||
style.addLayer(fillLayer)
|
||||
}
|
||||
}
|
||||
139
android/src/main/java/com/icegps/geotools/GridModel.kt
Normal file
139
android/src/main/java/com/icegps/geotools/GridModel.kt
Normal file
@@ -0,0 +1,139 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.icegps.triangulation.DelaunayTriangulation
|
||||
import kotlin.math.absoluteValue
|
||||
import kotlin.math.ceil
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/25
|
||||
*/
|
||||
data class GridModel(
|
||||
val minX: Double,
|
||||
val maxX: Double,
|
||||
val minY: Double,
|
||||
val maxY: Double,
|
||||
val rows: Int,
|
||||
val cols: Int,
|
||||
val cellSize: Double,
|
||||
val cells: Array<Double?>
|
||||
) {
|
||||
fun getValue(row: Int, col: Int): Double? {
|
||||
if (row !in 0..<rows || col < 0 || col >= cols) {
|
||||
return null
|
||||
}
|
||||
return cells[row * cols + col]
|
||||
}
|
||||
}
|
||||
|
||||
fun triangulationToGrid(
|
||||
delaunator: DelaunayTriangulation,
|
||||
cellSize: Double = 50.0,
|
||||
maxSidePixels: Int = 5000
|
||||
): GridModel {
|
||||
fun pointInTriangle(pt: Vector2D, a: Vector3D, b: Vector3D, c: Vector3D): Boolean {
|
||||
val v0x = c.x - a.x
|
||||
val v0y = c.y - a.y
|
||||
val v1x = b.x - a.x
|
||||
val v1y = b.y - a.y
|
||||
val v2x = pt.x - a.x
|
||||
val v2y = pt.y - a.y
|
||||
|
||||
val dot00 = v0x * v0x + v0y * v0y
|
||||
val dot01 = v0x * v1x + v0y * v1y
|
||||
val dot02 = v0x * v2x + v0y * v2y
|
||||
val dot11 = v1x * v1x + v1y * v1y
|
||||
val dot12 = v1x * v2x + v1y * v2y
|
||||
|
||||
val denom = dot00 * dot11 - dot01 * dot01
|
||||
if (denom == 0.0) return false
|
||||
val invDenom = 1.0 / denom
|
||||
val u = (dot11 * dot02 - dot01 * dot12) * invDenom
|
||||
val v = (dot00 * dot12 - dot01 * dot02) * invDenom
|
||||
return u >= 0 && v >= 0 && u + v <= 1
|
||||
}
|
||||
|
||||
fun barycentricInterpolateLegacy(pt: Vector2D, a: Vector3D, b: Vector3D, c: Vector3D, values: DoubleArray): Double {
|
||||
val area = { p1: Vector2D, p2: Vector3D, p3: Vector3D ->
|
||||
((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)).absoluteValue / 2.0
|
||||
}
|
||||
val area2 = { p1: Vector3D, p2: Vector3D, p3: Vector3D ->
|
||||
((p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y)).absoluteValue / 2.0
|
||||
}
|
||||
val areaTotal = area2(a, b, c)
|
||||
if (areaTotal == 0.0) return values[0]
|
||||
val wA = area(pt, b, c) / areaTotal
|
||||
val wB = area(pt, c, a) / areaTotal
|
||||
val wC = area(pt, a, b) / areaTotal
|
||||
return values[0] * wA + values[1] * wB + values[2] * wC
|
||||
}
|
||||
|
||||
|
||||
val pts = delaunator.points
|
||||
require(pts.isNotEmpty()) { "points empty" }
|
||||
|
||||
val x = pts.map { it.x }
|
||||
val y = pts.map { it.y }
|
||||
val minX = x.min()
|
||||
val maxX = x.max()
|
||||
val minY = y.min()
|
||||
val maxY = y.max()
|
||||
|
||||
val width = maxX - minX
|
||||
val height = maxY - minY
|
||||
|
||||
var cols = ceil(width / cellSize).toInt()
|
||||
var rows = ceil(height / cellSize).toInt()
|
||||
|
||||
// 防止过大
|
||||
if (cols > maxSidePixels) cols = maxSidePixels
|
||||
if (rows > maxSidePixels) rows = maxSidePixels
|
||||
|
||||
val cells = Array<Double?>(rows * cols) { null }
|
||||
|
||||
|
||||
val triangles = delaunator.triangles()
|
||||
|
||||
for (ti in 0 until triangles.size) {
|
||||
val (a, b, c) = triangles[ti]
|
||||
|
||||
val tminX = minOf(a.x, b.x, c.x)
|
||||
val tmaxX = maxOf(a.x, b.x, c.x)
|
||||
val tminY = minOf(a.y, b.y, c.y)
|
||||
val tmaxY = maxOf(a.y, b.y, c.y)
|
||||
|
||||
val colMin = ((tminX - minX) / cellSize).toInt().coerceIn(0, cols - 1)
|
||||
val colMax = ((tmaxX - minX) / cellSize).toInt().coerceIn(0, cols - 1)
|
||||
val rowMin = ((maxY - tmaxY) / cellSize).toInt().coerceIn(0, rows - 1)
|
||||
val rowMax = ((maxY - tminY) / cellSize).toInt().coerceIn(0, rows - 1)
|
||||
|
||||
val triVertexVals = doubleArrayOf(a.z, b.z, c.z)
|
||||
|
||||
for (r in rowMin..rowMax) {
|
||||
for (cIdx in colMin..colMax) {
|
||||
val centerX = minX + (cIdx + 0.5) * cellSize
|
||||
val centerY = maxY - (r + 0.5) * cellSize
|
||||
val pt = Vector2D(centerX, centerY)
|
||||
if (pointInTriangle(pt, a, b, c)) {
|
||||
val idx = r * cols + cIdx
|
||||
val valInterp = barycentricInterpolateLegacy(pt, a, b, c, triVertexVals)
|
||||
cells[idx] = valInterp
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val grid = GridModel(
|
||||
minX = minX,
|
||||
minY = minY,
|
||||
maxX = maxX,
|
||||
maxY = maxY,
|
||||
rows = rows,
|
||||
cols = cols,
|
||||
cellSize = cellSize,
|
||||
cells = cells
|
||||
)
|
||||
return grid
|
||||
}
|
||||
265
android/src/main/java/com/icegps/geotools/MainActivity.kt
Normal file
265
android/src/main/java/com/icegps/geotools/MainActivity.kt
Normal file
@@ -0,0 +1,265 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import android.os.Bundle
|
||||
import androidx.activity.enableEdgeToEdge
|
||||
import androidx.appcompat.app.AppCompatActivity
|
||||
import androidx.core.view.ViewCompat
|
||||
import androidx.core.view.WindowInsetsCompat
|
||||
import androidx.lifecycle.ViewModelProvider
|
||||
import androidx.lifecycle.lifecycleScope
|
||||
import com.google.android.material.slider.RangeSlider
|
||||
import com.google.android.material.slider.Slider
|
||||
import com.icegps.common.helper.GeoHelper
|
||||
import com.icegps.geotools.databinding.ActivityMainBinding
|
||||
import com.icegps.math.geometry.Angle
|
||||
import com.icegps.math.geometry.degrees
|
||||
import com.icegps.shared.model.GeoPoint
|
||||
import com.mapbox.geojson.Point
|
||||
import com.mapbox.maps.CameraOptions
|
||||
import com.mapbox.maps.MapView
|
||||
import com.mapbox.maps.plugin.gestures.addOnMapClickListener
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.combine
|
||||
import kotlinx.coroutines.flow.filterNotNull
|
||||
import kotlinx.coroutines.flow.launchIn
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.flow.onEach
|
||||
import kotlin.uuid.ExperimentalUuidApi
|
||||
import kotlin.uuid.Uuid
|
||||
|
||||
class MainActivity : AppCompatActivity() {
|
||||
private lateinit var binding: ActivityMainBinding
|
||||
private lateinit var mapView: MapView
|
||||
private val viewModel: MainViewModel by lazy {
|
||||
ViewModelProvider(this)[MainViewModel::class.java]
|
||||
}
|
||||
private lateinit var contoursManager: ContoursManager
|
||||
private lateinit var earthworkManager: EarthworkManager
|
||||
|
||||
init {
|
||||
initGeoHelper()
|
||||
}
|
||||
|
||||
override fun onCreate(savedInstanceState: Bundle?) {
|
||||
super.onCreate(savedInstanceState)
|
||||
enableEdgeToEdge()
|
||||
binding = ActivityMainBinding.inflate(layoutInflater)
|
||||
mapView = binding.mapView
|
||||
earthworkManager = EarthworkManager(mapView, lifecycleScope)
|
||||
setContentView(binding.root)
|
||||
ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets ->
|
||||
val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
|
||||
v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
|
||||
insets
|
||||
}
|
||||
|
||||
mapView.mapboxMap.setCamera(
|
||||
CameraOptions.Builder()
|
||||
.center(Point.fromLngLat(home.longitude, home.latitude))
|
||||
.pitch(0.0)
|
||||
.zoom(18.0)
|
||||
.bearing(0.0)
|
||||
.build()
|
||||
)
|
||||
|
||||
val points = coordinateGenerate()
|
||||
|
||||
// divider
|
||||
contoursManager = ContoursManager(
|
||||
context = this,
|
||||
mapView = mapView,
|
||||
scope = lifecycleScope
|
||||
)
|
||||
contoursManager.updateContourSize(6)
|
||||
contoursManager.updatePoints(points)
|
||||
val height = points.map { it.z }
|
||||
val min = height.min()
|
||||
val max = height.max()
|
||||
contoursManager.updateHeightRange((min / 2)..max)
|
||||
binding.heightRange.values = listOf(min.toFloat() / 2, max.toFloat())
|
||||
binding.heightRange.valueFrom = min.toFloat()
|
||||
binding.heightRange.valueTo = max.toFloat()
|
||||
contoursManager.refresh()
|
||||
|
||||
binding.sliderTargetHeight.addOnSliderTouchListener(
|
||||
object : Slider.OnSliderTouchListener {
|
||||
override fun onStartTrackingTouch(p0: Slider) {
|
||||
}
|
||||
|
||||
override fun onStopTrackingTouch(p0: Slider) {
|
||||
val present = p0.value / p0.valueTo
|
||||
// val targetHeight = ((valueRange.endInclusive - valueRange.start) * present) + valueRange.start
|
||||
|
||||
// val contours = findContours(triangles, targetHeight)
|
||||
// contoursTest.clearContours()
|
||||
// if (false) contoursTest.updateContours(contours)
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
binding.heightRange.addOnSliderTouchListener(
|
||||
object : RangeSlider.OnSliderTouchListener {
|
||||
override fun onStartTrackingTouch(slider: RangeSlider) {
|
||||
}
|
||||
|
||||
override fun onStopTrackingTouch(slider: RangeSlider) {
|
||||
contoursManager.updateHeightRange((slider.values.min().toDouble() - 1.0)..(slider.values.max().toDouble() + 1.0))
|
||||
contoursManager.refresh()
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
binding.switchGrid.setOnCheckedChangeListener { _, isChecked ->
|
||||
contoursManager.setGridVisible(isChecked)
|
||||
}
|
||||
binding.switchTriangle.setOnCheckedChangeListener { _, isChecked ->
|
||||
contoursManager.setTriangleVisible(isChecked)
|
||||
}
|
||||
binding.update.setOnClickListener {
|
||||
contoursManager.refresh()
|
||||
}
|
||||
binding.cellSize.addOnSliderTouchListener(
|
||||
object : Slider.OnSliderTouchListener {
|
||||
override fun onStartTrackingTouch(slider: Slider) {
|
||||
}
|
||||
|
||||
override fun onStopTrackingTouch(slider: Slider) {
|
||||
contoursManager.updateCellSize(slider.value.toDouble())
|
||||
contoursManager.refresh()
|
||||
}
|
||||
}
|
||||
)
|
||||
mapView.mapboxMap.addOnMapClickListener {
|
||||
viewModel.addPoint(it)
|
||||
true
|
||||
}
|
||||
binding.clearPoints.setOnClickListener {
|
||||
viewModel.clearPoints()
|
||||
}
|
||||
binding.slopeDirection.addOnSliderTouchListener(
|
||||
object : Slider.OnSliderTouchListener {
|
||||
override fun onStartTrackingTouch(slider: Slider) {
|
||||
}
|
||||
|
||||
override fun onStopTrackingTouch(slider: Slider) {
|
||||
earthworkManager.updateSlopeDirection(slider.value.degrees)
|
||||
}
|
||||
}
|
||||
)
|
||||
binding.slopePercentage.addOnSliderTouchListener(
|
||||
object : Slider.OnSliderTouchListener {
|
||||
override fun onStartTrackingTouch(slider: Slider) {
|
||||
}
|
||||
|
||||
override fun onStopTrackingTouch(slider: Slider) {
|
||||
earthworkManager.updateSlopePercentage(slider.value.toDouble())
|
||||
}
|
||||
}
|
||||
)
|
||||
binding.designHeight.addOnSliderTouchListener(
|
||||
object : Slider.OnSliderTouchListener {
|
||||
override fun onStartTrackingTouch(slider: Slider) {
|
||||
}
|
||||
|
||||
override fun onStopTrackingTouch(slider: Slider) {
|
||||
earthworkManager.updateDesignHeight(slider.value.toDouble())
|
||||
}
|
||||
}
|
||||
)
|
||||
binding.switchDesignSurface.setOnCheckedChangeListener { button, isChecked ->
|
||||
showDesignHeight.value = isChecked
|
||||
}
|
||||
earthworkManager.setupOnMoveListener()
|
||||
binding.switchSlopeResult.setOnCheckedChangeListener { _, isChecked ->
|
||||
slopeResultVisible.value = isChecked
|
||||
}
|
||||
initData()
|
||||
}
|
||||
|
||||
private val showDesignHeight = MutableStateFlow(false)
|
||||
private val slopeResultVisible = MutableStateFlow(false)
|
||||
|
||||
@OptIn(ExperimentalUuidApi::class)
|
||||
private fun initData() {
|
||||
viewModel.points.onEach {
|
||||
contoursManager.updatePoints(it)
|
||||
contoursManager.updateHeightRange()
|
||||
contoursManager.refresh()
|
||||
}.launchIn(lifecycleScope)
|
||||
contoursManager.gridModel.filterNotNull().onEach {
|
||||
earthworkManager.updateGridModel(it)
|
||||
}.launchIn(lifecycleScope)
|
||||
earthworkManager.slopeDirection.onEach {
|
||||
binding.slopeDirection.value = it.degrees.toFloat()
|
||||
}.launchIn(lifecycleScope)
|
||||
val slopeResultSourceId: String = Uuid.random().toString()
|
||||
val slopeResultLayerId: String = Uuid.random().toString()
|
||||
combine(
|
||||
earthworkManager.slopeDirection,
|
||||
earthworkManager.slopePercentage,
|
||||
earthworkManager.baseHeightOffset,
|
||||
contoursManager.gridModel,
|
||||
showDesignHeight,
|
||||
slopeResultVisible
|
||||
) {
|
||||
Params6(
|
||||
p1 = it[0] as Angle,
|
||||
p2 = it[1] as Double,
|
||||
p3 = it[2] as Double,
|
||||
p4 = it[3] as? GridModel?,
|
||||
p5 = it[4] as Boolean,
|
||||
p6 = it[5] as Boolean
|
||||
)
|
||||
}.map { (slopeDirection, slopePercentage, baseHeightOffset, gridModel, showDesignHeight, slopeResultVisible) ->
|
||||
if (!slopeResultVisible) {
|
||||
mapView.mapboxMap.getStyle { style ->
|
||||
style.removeStyleLayer(slopeResultLayerId)
|
||||
style.removeStyleLayer("${slopeResultLayerId}-outline")
|
||||
style.removeStyleSource(slopeResultSourceId)
|
||||
}
|
||||
} else gridModel?.let { gridModel ->
|
||||
val slopeResult: SlopeResult = SlopeCalculator.calculateSlope(
|
||||
grid = gridModel,
|
||||
slopeDirection = slopeDirection.degrees,
|
||||
slopePercentage = slopePercentage,
|
||||
baseHeightOffset = baseHeightOffset
|
||||
)
|
||||
mapView.displaySlopeResult(
|
||||
originalGrid = gridModel,
|
||||
slopeResult = slopeResult,
|
||||
sourceId = slopeResultSourceId,
|
||||
layerId = slopeResultLayerId,
|
||||
palette = contoursManager.simplePalette::palette,
|
||||
showDesignHeight = showDesignHeight
|
||||
)
|
||||
}
|
||||
}.launchIn(lifecycleScope)
|
||||
}
|
||||
}
|
||||
|
||||
data class Params6<
|
||||
out P1,
|
||||
out P2,
|
||||
out P3,
|
||||
out P4,
|
||||
out P5,
|
||||
out P6,
|
||||
>(
|
||||
val p1: P1,
|
||||
val p2: P2,
|
||||
val p3: P3,
|
||||
val p4: P4,
|
||||
val p5: P5,
|
||||
val p6: P6,
|
||||
)
|
||||
|
||||
val home = GeoPoint(114.476060, 22.771073, 30.897)
|
||||
|
||||
fun initGeoHelper(base: GeoPoint = home) {
|
||||
val geoHelper = GeoHelper.getSharedInstance()
|
||||
geoHelper.wgs84ToENU(
|
||||
lon = base.longitude,
|
||||
lat = base.latitude,
|
||||
hgt = base.altitude
|
||||
)
|
||||
}
|
||||
59
android/src/main/java/com/icegps/geotools/MainViewModel.kt
Normal file
59
android/src/main/java/com/icegps/geotools/MainViewModel.kt
Normal file
@@ -0,0 +1,59 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import android.app.Application
|
||||
import android.util.Log
|
||||
import androidx.lifecycle.AndroidViewModel
|
||||
import androidx.lifecycle.viewModelScope
|
||||
import com.icegps.common.helper.GeoHelper
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.icegps.geotools.ktx.toast
|
||||
import com.icegps.shared.SharedHttpClient
|
||||
import com.icegps.shared.SharedJson
|
||||
import com.icegps.shared.api.OpenElevation
|
||||
import com.icegps.shared.api.OpenElevationApi
|
||||
import com.icegps.shared.ktx.TAG
|
||||
import com.icegps.shared.model.GeoPoint
|
||||
import com.mapbox.geojson.Point
|
||||
import kotlinx.coroutines.flow.MutableStateFlow
|
||||
import kotlinx.coroutines.flow.SharingStarted
|
||||
import kotlinx.coroutines.flow.catch
|
||||
import kotlinx.coroutines.flow.debounce
|
||||
import kotlinx.coroutines.flow.filter
|
||||
import kotlinx.coroutines.flow.map
|
||||
import kotlinx.coroutines.flow.stateIn
|
||||
import kotlinx.coroutines.flow.update
|
||||
|
||||
class MainViewModel(private val context: Application) : AndroidViewModel(context) {
|
||||
private val geoHelper = GeoHelper.Companion.getSharedInstance()
|
||||
private val openElevation: OpenElevationApi = OpenElevation(SharedHttpClient(SharedJson()))
|
||||
|
||||
private val _points = MutableStateFlow<List<Point>>(emptyList())
|
||||
val points = _points.filter { it.size > 3 }.debounce(1000).map {
|
||||
openElevation.lookup(it.map { GeoPoint(it.longitude(), it.latitude(), it.altitude()) })
|
||||
}.catch {
|
||||
Log.e(TAG, "高程请求失败", it)
|
||||
context.toast("高程请求失败")
|
||||
}.map {
|
||||
it.map {
|
||||
val enu = geoHelper.wgs84ToENU(lon = it.longitude, lat = it.latitude, hgt = it.altitude)
|
||||
Vector3D(enu.x, enu.y, enu.z)
|
||||
}
|
||||
}.stateIn(
|
||||
scope = viewModelScope,
|
||||
started = SharingStarted.Companion.Eagerly,
|
||||
initialValue = emptyList()
|
||||
)
|
||||
|
||||
fun addPoint(point: Point) {
|
||||
context.toast("${point.longitude()}, ${point.latitude()}")
|
||||
_points.update {
|
||||
it.toMutableList().apply {
|
||||
add(point)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun clearPoints() {
|
||||
_points.value = emptyList()
|
||||
}
|
||||
}
|
||||
121
android/src/main/java/com/icegps/geotools/PolylineManager.kt
Normal file
121
android/src/main/java/com/icegps/geotools/PolylineManager.kt
Normal file
@@ -0,0 +1,121 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import android.graphics.Color
|
||||
import com.icegps.math.geometry.Line3D
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.icegps.geotools.ktx.toMapboxPoint
|
||||
import com.mapbox.geojson.Feature
|
||||
import com.mapbox.geojson.FeatureCollection
|
||||
import com.mapbox.geojson.LineString
|
||||
import com.mapbox.maps.MapView
|
||||
import com.mapbox.maps.Style
|
||||
import com.mapbox.maps.extension.style.layers.addLayer
|
||||
import com.mapbox.maps.extension.style.layers.generated.lineLayer
|
||||
import com.mapbox.maps.extension.style.layers.properties.generated.LineCap
|
||||
import com.mapbox.maps.extension.style.layers.properties.generated.LineJoin
|
||||
import com.mapbox.maps.extension.style.sources.addSource
|
||||
import com.mapbox.maps.extension.style.sources.generated.geoJsonSource
|
||||
|
||||
class PolylineManager(
|
||||
private val mapView: MapView
|
||||
) {
|
||||
private val sourceId: String = "polyline-source-id-0"
|
||||
private val layerId: String = "polyline-layer-id-0"
|
||||
|
||||
fun update(
|
||||
points: List<List<Vector3D>>
|
||||
) {
|
||||
val lineStrings: List<List<Feature>> = points.map {
|
||||
val lines = fromPoints(it, true)
|
||||
lines.map {
|
||||
LineString.fromLngLats(listOf(it.a.toMapboxPoint(), it.b.toMapboxPoint()))
|
||||
}
|
||||
}.map {
|
||||
it.map { Feature.fromGeometry(it) }
|
||||
}
|
||||
|
||||
mapView.mapboxMap.getStyle { style ->
|
||||
setupLineLayer(
|
||||
style = style,
|
||||
sourceId = sourceId,
|
||||
layerId = layerId,
|
||||
features = lineStrings.flatten()
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fun updateFeatures(
|
||||
features: List<Feature>
|
||||
) {
|
||||
mapView.mapboxMap.getStyle { style ->
|
||||
setupLineLayer(
|
||||
style = style,
|
||||
sourceId = sourceId,
|
||||
layerId = layerId,
|
||||
features = features
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private fun setupLineLayer(
|
||||
style: Style,
|
||||
sourceId: String,
|
||||
layerId: String,
|
||||
features: List<Feature>
|
||||
) {
|
||||
style.removeStyleLayer(layerId)
|
||||
style.removeStyleSource(sourceId)
|
||||
|
||||
val source = geoJsonSource(sourceId) {
|
||||
featureCollection(FeatureCollection.fromFeatures(features))
|
||||
}
|
||||
style.addSource(source)
|
||||
|
||||
val layer = lineLayer(layerId, sourceId) {
|
||||
lineColor(Color.RED)
|
||||
lineWidth(2.0)
|
||||
lineCap(LineCap.Companion.ROUND)
|
||||
lineJoin(LineJoin.Companion.ROUND)
|
||||
lineOpacity(0.8)
|
||||
}
|
||||
style.addLayer(layer)
|
||||
}
|
||||
|
||||
fun clearContours() {
|
||||
mapView.mapboxMap.getStyle { style ->
|
||||
try {
|
||||
style.removeStyleLayer(layerId)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
try {
|
||||
style.removeStyleSource(sourceId)
|
||||
} catch (_: Exception) {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun fromPoints(
|
||||
points: List<Vector3D>,
|
||||
closed: Boolean,
|
||||
) = if (points.isEmpty()) {
|
||||
emptyList()
|
||||
} else {
|
||||
if (!closed) {
|
||||
(0 until points.size - 1).map {
|
||||
Line3D(
|
||||
points[it],
|
||||
points[it + 1]
|
||||
)
|
||||
}
|
||||
} else {
|
||||
val d = (points.last() - points.first()).length
|
||||
val usePoints = if (d > 1E-6) points else points.dropLast(1)
|
||||
(usePoints.indices).map {
|
||||
Line3D(
|
||||
usePoints[it],
|
||||
usePoints[(it + 1) % usePoints.size]
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.icegps.math.geometry.toVector2D
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/26
|
||||
*/
|
||||
object RayCastingAlgorithm {
|
||||
/**
|
||||
* 使用射线法判断点是否在多边形内
|
||||
* @param point 测试点
|
||||
* @param polygon 多边形顶点列表
|
||||
* @return true如果在多边形内
|
||||
*/
|
||||
fun isPointInPolygon(point: Vector2D, polygon: List<Vector2D>): Boolean {
|
||||
if (polygon.size < 3) return false
|
||||
|
||||
val x = point.x
|
||||
val y = point.y
|
||||
var inside = false
|
||||
|
||||
var j = polygon.size - 1
|
||||
for (i in polygon.indices) {
|
||||
val xi = polygon[i].x
|
||||
val yi = polygon[i].y
|
||||
val xj = polygon[j].x
|
||||
val yj = polygon[j].y
|
||||
|
||||
val intersect = ((yi > y) != (yj > y)) && (x < (xj - xi) * (y - yi) / (yj - yi) + xi)
|
||||
|
||||
if (intersect) inside = !inside
|
||||
j = i
|
||||
}
|
||||
|
||||
return inside
|
||||
}
|
||||
|
||||
fun isPointInPolygon(point: Vector3D, polygon: List<Vector3D>): Boolean {
|
||||
return isPointInPolygon(point.toVector2D(), polygon.map { it.toVector2D() })
|
||||
}
|
||||
}
|
||||
123
android/src/main/java/com/icegps/geotools/SimplePalette.kt
Normal file
123
android/src/main/java/com/icegps/geotools/SimplePalette.kt
Normal file
@@ -0,0 +1,123 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import android.util.Log
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/25
|
||||
*/
|
||||
class SimplePalette(
|
||||
private var range: ClosedFloatingPointRange<Double>
|
||||
) {
|
||||
fun setRange(range: ClosedFloatingPointRange<Double>) {
|
||||
this.range = range
|
||||
}
|
||||
|
||||
private val colors: Map<Int, String>
|
||||
|
||||
init {
|
||||
colors = generateTerrainColorMap()
|
||||
}
|
||||
|
||||
fun palette(value: Double?): String {
|
||||
if (value == null) return "#00000000"
|
||||
val minH = range.start
|
||||
val maxH = range.endInclusive
|
||||
val normalized = ((value - minH) / (maxH - minH)).coerceIn(0.0, 1.0)
|
||||
return colors[(normalized * 255).toInt()] ?: "#00000000"
|
||||
}
|
||||
|
||||
fun palette1(value: Double?): String {
|
||||
return if (value == null) "#00000000" else {
|
||||
// 假设您已经知道高度范围，或者动态计算
|
||||
val minH = range.start
|
||||
val maxH = range.endInclusive
|
||||
val normalized = ((value - minH) / (maxH - minH)).coerceIn(0.0, 1.0)
|
||||
val alpha = (normalized * 255).toInt()
|
||||
String.format("#%02X%02X%02X", alpha, 0, 0)
|
||||
}.also {
|
||||
Log.d("simplePalette", "$value -> $it")
|
||||
}
|
||||
}
|
||||
|
||||
fun generateGrayscaleColorMap2(): MutableMap<Int, String> {
|
||||
val colorMap = mutableMapOf<Int, String>()
|
||||
|
||||
// 定义关键灰度点
|
||||
val black = Color(0, 0, 0) // 低地势 - 黑色
|
||||
val darkGray = Color(64, 64, 64) // 过渡
|
||||
val midGray = Color(128, 128, 128) // 中间
|
||||
val lightGray = Color(192, 192, 192) // 过渡
|
||||
val white = Color(255, 255, 255) // 高地势 - 白色
|
||||
|
||||
for (i in 0..255) {
|
||||
val position = i / 255.0
|
||||
|
||||
val color = when {
|
||||
position < 0.25 -> interpolateColor(black, darkGray, position / 0.25)
|
||||
position < 0.5 -> interpolateColor(darkGray, midGray, (position - 0.25) / 0.25)
|
||||
position < 0.75 -> interpolateColor(midGray, lightGray, (position - 0.5) / 0.25)
|
||||
else -> interpolateColor(lightGray, white, (position - 0.75) / 0.25)
|
||||
}
|
||||
colorMap[i] = color.toHex()
|
||||
}
|
||||
|
||||
return colorMap
|
||||
}
|
||||
|
||||
fun generateGrayscaleColorMap(): MutableMap<Int, String> {
|
||||
val colorMap = mutableMapOf<Int, String>()
|
||||
|
||||
for (i in 0..255) {
|
||||
// 从黑色到白色的线性渐变
|
||||
val grayValue = i
|
||||
val color = Color(grayValue, grayValue, grayValue)
|
||||
colorMap[i] = color.toHex()
|
||||
}
|
||||
|
||||
return colorMap
|
||||
}
|
||||
|
||||
fun generateTerrainColorMap(): MutableMap<Int, String> {
|
||||
val colorMap = mutableMapOf<Int, String>()
|
||||
|
||||
// 定义关键颜色点
|
||||
val blue = Color(0, 0, 255) // 低地势 - 蓝色
|
||||
val cyan = Color(0, 255, 255) // 中间过渡
|
||||
val green = Color(0, 255, 0) // 中间过渡
|
||||
val yellow = Color(255, 255, 0) // 中间过渡
|
||||
val red = Color(255, 0, 0) // 高地势 - 红色
|
||||
|
||||
for (i in 0..255) {
|
||||
val position = i / 255.0
|
||||
|
||||
val color = when {
|
||||
position < 0.25 -> interpolateColor(blue, cyan, position / 0.25)
|
||||
position < 0.5 -> interpolateColor(cyan, green, (position - 0.25) / 0.25)
|
||||
position < 0.75 -> interpolateColor(green, yellow, (position - 0.5) / 0.25)
|
||||
else -> interpolateColor(yellow, red, (position - 0.75) / 0.25)
|
||||
}
|
||||
colorMap[i] = color.toHex()
|
||||
}
|
||||
|
||||
return colorMap
|
||||
}
|
||||
|
||||
fun interpolateColor(start: Color, end: Color, fraction: Double): Color {
|
||||
val r = (start.red + (end.red - start.red) * fraction).toInt()
|
||||
val g = (start.green + (end.green - start.green) * fraction).toInt()
|
||||
val b = (start.blue + (end.blue - start.blue) * fraction).toInt()
|
||||
return Color(r, g, b)
|
||||
}
|
||||
|
||||
// Color类简化实现
|
||||
class Color(val red: Int, val green: Int, val blue: Int) {
|
||||
fun toArgb(): Int {
|
||||
return (0xFF shl 24) or (red shl 16) or (green shl 8) or blue
|
||||
}
|
||||
|
||||
fun toHex(): String {
|
||||
return String.format("#%06X", toArgb() and 0xFFFFFF)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
package com.icegps.geotools.catmullrom
|
||||
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.icegps.geotools.marchingsquares.Segment2D
|
||||
import com.icegps.geotools.marchingsquares.ShapeContour
|
||||
import kotlin.math.min
|
||||
import kotlin.math.pow
|
||||
|
||||
private const val almostZero = 0.00000001
|
||||
private const val almostOne = 0.99999999
|
||||
|
||||
/**
|
||||
* Creates a 2D Catmull-Rom spline curve.
|
||||
*
|
||||
* Can be represented as a segment drawn between [p1] and [p2],
|
||||
* while [p0] and [p3] are used as control points.
|
||||
*
|
||||
* Under some circumstances alpha can have
|
||||
* no perceptible effect, for example,
|
||||
* when creating closed shapes with the vertices
|
||||
* forming a regular 2D polygon.
|
||||
*
|
||||
* @param p0 The first control point.
|
||||
* @param p1 The starting anchor point.
|
||||
* @param p2 The ending anchor point.
|
||||
* @param p3 The second control point.
|
||||
* @param alpha The *tension* of the curve.
|
||||
* Use `0.0` for the uniform spline, `0.5` for the centripetal spline, `1.0` for the chordal spline.
|
||||
*/
|
||||
class CatmullRom2(val p0: Vector2D, val p1: Vector2D, val p2: Vector2D, val p3: Vector2D, val alpha: Double = 0.5) {
|
||||
/** Value of t for p0. */
|
||||
val t0: Double = 0.0
|
||||
|
||||
/** Value of t for p1. */
|
||||
val t1: Double = calculateT(t0, p0, p1)
|
||||
|
||||
/** Value of t for p2. */
|
||||
val t2: Double = calculateT(t1, p1, p2)
|
||||
|
||||
/** Value of t for p3. */
|
||||
val t3: Double = calculateT(t2, p2, p3)
|
||||
|
||||
fun position(rt: Double): Vector2D {
|
||||
val t = t1 + rt * (t2 - t1)
|
||||
val a1 = p0 * ((t1 - t) / (t1 - t0)) + p1 * ((t - t0) / (t1 - t0))
|
||||
val a2 = p1 * ((t2 - t) / (t2 - t1)) + p2 * ((t - t1) / (t2 - t1))
|
||||
val a3 = p2 * ((t3 - t) / (t3 - t2)) + p3 * ((t - t2) / (t3 - t2))
|
||||
|
||||
val b1 = a1 * ((t2 - t) / (t2 - t0)) + a2 * ((t - t0) / (t2 - t0))
|
||||
val b2 = a2 * ((t3 - t) / (t3 - t1)) + a3 * ((t - t1) / (t3 - t1))
|
||||
|
||||
val c = b1 * ((t2 - t) / (t2 - t1)) + b2 * ((t - t1) / (t2 - t1))
|
||||
return c
|
||||
}
|
||||
|
||||
private fun calculateT(t: Double, p0: Vector2D, p1: Vector2D): Double {
|
||||
val a = (p1.x - p0.x).pow(2.0) + (p1.y - p0.y).pow(2.0)
|
||||
val b = a.pow(0.5)
|
||||
val c = b.pow(alpha)
|
||||
return c + t
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates the 2D Catmull–Rom spline for a chain of points and returns the combined curve.
|
||||
*
|
||||
* For more details, see [CatmullRom2].
|
||||
*
|
||||
* @param points The [List] of 2D points where [CatmullRom2] is applied in groups of 4.
|
||||
* @param alpha The *tension* of the curve.
|
||||
* Use `0.0` for the uniform spline, `0.5` for the centripetal spline, `1.0` for the chordal spline.
|
||||
* @param loop Whether to connect the first and last point, such that it forms a closed shape.
|
||||
*/
|
||||
class CatmullRomChain2(points: List<Vector2D>, alpha: Double = 0.5, val loop: Boolean = false) {
|
||||
val segments = if (!loop) {
|
||||
val startPoints = points.take(2)
|
||||
val endPoints = points.takeLast(2)
|
||||
val mirrorStart =
|
||||
startPoints.first() - (startPoints.last() - startPoints.first()).normalized
|
||||
val mirrorEnd = endPoints.last() + (endPoints.last() - endPoints.first()).normalized
|
||||
|
||||
(listOf(mirrorStart) + points + listOf(mirrorEnd)).windowed(4, 1).map {
|
||||
CatmullRom2(it[0], it[1], it[2], it[3], alpha)
|
||||
}
|
||||
} else {
|
||||
val cleanPoints = if (loop && points.first().distanceTo(points.last()) <= 1.0E-6) {
|
||||
points.dropLast(1)
|
||||
} else {
|
||||
points
|
||||
}
|
||||
(cleanPoints + cleanPoints.take(3)).windowed(4, 1).map {
|
||||
CatmullRom2(it[0], it[1], it[2], it[3], alpha)
|
||||
}
|
||||
}
|
||||
|
||||
fun positions(steps: Int = segments.size * 4): List<Vector2D> {
|
||||
return (0..steps).map {
|
||||
position(it.toDouble() / steps)
|
||||
}
|
||||
}
|
||||
|
||||
fun position(rt: Double): Vector2D {
|
||||
val st = if (loop) rt.mod(1.0) else rt.coerceIn(0.0, 1.0)
|
||||
val segmentIndex = (min(almostOne, st) * segments.size).toInt()
|
||||
val t = (min(almostOne, st) * segments.size) - segmentIndex
|
||||
return segments[segmentIndex].position(t)
|
||||
}
|
||||
}
|
||||
|
||||
fun List<Vector2D>.catmullRom(alpha: Double = 0.5, closed: Boolean) = CatmullRomChain2(this, alpha, closed)
|
||||
|
||||
/** Converts spline to a [Segment]. */
|
||||
fun CatmullRom2.toSegment(): Segment2D {
|
||||
val d1a2 = (p1 - p0).length.pow(2 * alpha)
|
||||
val d2a2 = (p2 - p1).length.pow(2 * alpha)
|
||||
val d3a2 = (p3 - p2).length.pow(2 * alpha)
|
||||
val d1a = (p1 - p0).length.pow(alpha)
|
||||
val d2a = (p2 - p1).length.pow(alpha)
|
||||
val d3a = (p3 - p2).length.pow(alpha)
|
||||
|
||||
val b0 = p1
|
||||
val b1 = (p2 * d1a2 - p0 * d2a2 + p1 * (2 * d1a2 + 3 * d1a * d2a + d2a2)) / (3 * d1a * (d1a + d2a))
|
||||
val b2 = (p1 * d3a2 - p3 * d2a2 + p2 * (2 * d3a2 + 3 * d3a * d2a + d2a2)) / (3 * d3a * (d3a + d2a))
|
||||
val b3 = p2
|
||||
|
||||
return Segment2D(b0, b1, b2, b3)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Converts chain to a [ShapeContour].
|
||||
*/
|
||||
@Suppress("unused")
|
||||
fun CatmullRomChain2.toContour(): ShapeContour =
|
||||
ShapeContour(segments.map { it.toSegment() }, this.loop)
|
||||
427
android/src/main/java/com/icegps/geotools/color/ColorRGBa.kt
Normal file
427
android/src/main/java/com/icegps/geotools/color/ColorRGBa.kt
Normal file
@@ -0,0 +1,427 @@
|
||||
package com.icegps.geotools.color
|
||||
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.icegps.math.geometry.Vector4D
|
||||
import kotlinx.serialization.Serializable
|
||||
import kotlin.math.pow
|
||||
|
||||
@Serializable
|
||||
enum class Linearity(val certainty: Int) {
|
||||
/**
|
||||
* Represents a linear color space.
|
||||
*
|
||||
* LINEAR typically signifies that the values in the color space are in a linear relationship,
|
||||
* meaning there is no gamma correction or transformation applied to the data.
|
||||
*/
|
||||
LINEAR(1),
|
||||
|
||||
/**
|
||||
* Represents a standard RGB (sRGB) color space.
|
||||
*
|
||||
* SRGB typically refers to a non-linear color space with gamma correction applied,
|
||||
* designed for consistent color representation across devices.
|
||||
*/
|
||||
SRGB(1),
|
||||
;
|
||||
|
||||
fun leastCertain(other: Linearity): Linearity {
|
||||
return if (this.certainty <= other.certainty) {
|
||||
this
|
||||
} else {
|
||||
other
|
||||
}
|
||||
}
|
||||
|
||||
fun isEquivalent(other: Linearity): Boolean {
|
||||
return this == other
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a color in the RGBA color space. Each component, including red, green, blue, and alpha (opacity),
|
||||
* is represented as a `Double` in the range `[0.0, 1.0]`. The color can be defined in either linear or sRGB space,
|
||||
* determined by the `linearity` property.
|
||||
*
|
||||
* This class provides a wide variety of utility functions for manipulating and converting colors, such as shading,
|
||||
* opacity adjustment, and format transformations. It also includes methods for parsing colors from hexadecimal
|
||||
* notation or vectors.
|
||||
*
|
||||
* @property r Red component of the color as a value between `0.0` and `1.0`.
|
||||
* @property g Green component of the color as a value between `0.0` and `1.0`.
|
||||
* @property b Blue component of the color as a value between `0.0` and `1.0`.
|
||||
* @property alpha Alpha (opacity) component of the color as a value between `0.0` and `1.0`. Defaults to `1.0`.
|
||||
* @property linearity Indicates whether the color is defined in linear or sRGB space. Defaults to [Linearity.LINEAR].
|
||||
*/
|
||||
@Serializable
|
||||
@Suppress("EqualsOrHashCode") // generated equals() is ok, only hashCode() needs to be overridden
|
||||
data class ColorRGBa(
|
||||
val r: Double,
|
||||
val g: Double,
|
||||
val b: Double,
|
||||
val alpha: Double = 1.0,
|
||||
val linearity: Linearity = Linearity.LINEAR
|
||||
) {
|
||||
|
||||
enum class Component {
|
||||
R,
|
||||
G,
|
||||
B
|
||||
}
|
||||
|
||||
companion object {
|
||||
/**
|
||||
* Calculates a color from hexadecimal value. For values with transparency
|
||||
* use the [String] variant of this function.
|
||||
*/
|
||||
fun fromHex(hex: Int): ColorRGBa {
|
||||
val r = hex and (0xff0000) shr 16
|
||||
val g = hex and (0x00ff00) shr 8
|
||||
val b = hex and (0x0000ff)
|
||||
return ColorRGBa(r / 255.0, g / 255.0, b / 255.0, 1.0, Linearity.SRGB)
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculates a color from hexadecimal notation, like in CSS.
|
||||
*
|
||||
* Supports the following formats
|
||||
* * `RGB`
|
||||
* * `RGBA`
|
||||
* * `RRGGBB`
|
||||
* * `RRGGBBAA`
|
||||
*
|
||||
* where every character is a valid hex digit between `0..f` (case-insensitive).
|
||||
* Supports leading "#" or "0x".
|
||||
*/
|
||||
fun fromHex(hex: String): ColorRGBa {
|
||||
val pos = when {
|
||||
hex.startsWith("#") -> 1
|
||||
hex.startsWith("0x") -> 2
|
||||
else -> 0
|
||||
}
|
||||
|
||||
fun fromHex1(str: String, pos: Int): Double {
|
||||
return 17 * str[pos].digitToInt(16) / 255.0
|
||||
}
|
||||
|
||||
fun fromHex2(str: String, pos: Int): Double {
|
||||
return (16 * str[pos].digitToInt(16) + str[pos + 1].digitToInt(16)) / 255.0
|
||||
}
|
||||
return when (hex.length - pos) {
|
||||
3 -> ColorRGBa(fromHex1(hex, pos), fromHex1(hex, pos + 1), fromHex1(hex, pos + 2), 1.0, Linearity.SRGB)
|
||||
4 -> ColorRGBa(
|
||||
fromHex1(hex, pos),
|
||||
fromHex1(hex, pos + 1),
|
||||
fromHex1(hex, pos + 2),
|
||||
fromHex1(hex, pos + 3),
|
||||
Linearity.SRGB
|
||||
)
|
||||
|
||||
6 -> ColorRGBa(fromHex2(hex, pos), fromHex2(hex, pos + 2), fromHex2(hex, pos + 4), 1.0, Linearity.SRGB)
|
||||
8 -> ColorRGBa(
|
||||
fromHex2(hex, pos),
|
||||
fromHex2(hex, pos + 2),
|
||||
fromHex2(hex, pos + 4),
|
||||
fromHex2(hex, pos + 6),
|
||||
Linearity.SRGB
|
||||
)
|
||||
|
||||
else -> throw IllegalArgumentException("Invalid hex length/format for '$hex'")
|
||||
}
|
||||
}
|
||||
|
||||
/** @suppress */
|
||||
val PINK = fromHex(0xffc0cb)
|
||||
|
||||
/** @suppress */
|
||||
val BLACK = ColorRGBa(0.0, 0.0, 0.0, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val WHITE = ColorRGBa(1.0, 1.0, 1.0, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val RED = ColorRGBa(1.0, 0.0, 0.0, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val BLUE = ColorRGBa(0.0, 0.0, 1.0, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val GREEN = ColorRGBa(0.0, 1.0, 0.0, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val YELLOW = ColorRGBa(1.0, 1.0, 0.0, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val CYAN = ColorRGBa(0.0, 1.0, 1.0, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val MAGENTA = ColorRGBa(1.0, 0.0, 1.0, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val GRAY = ColorRGBa(0.5, 0.5, 0.5, 1.0, Linearity.SRGB)
|
||||
|
||||
/** @suppress */
|
||||
val TRANSPARENT = ColorRGBa(0.0, 0.0, 0.0, 0.0, Linearity.LINEAR)
|
||||
|
||||
/**
|
||||
* Create a ColorRGBa object from a [Vector3]
|
||||
* @param vector input vector, `[x, y, z]` is mapped to `[r, g, b]`
|
||||
* @param alpha optional alpha value, default is 1.0
|
||||
*/
|
||||
fun fromVector(vector: Vector3D, alpha: Double = 1.0, linearity: Linearity = Linearity.LINEAR): ColorRGBa {
|
||||
return ColorRGBa(vector.x, vector.y, vector.z, alpha, linearity)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Create a ColorRGBa object from a [Vector4]
|
||||
* @param vector input vector, `[x, y, z, w]` is mapped to `[r, g, b, a]`
|
||||
*/
|
||||
fun fromVector(vector: Vector4D, linearity: Linearity = Linearity.LINEAR): ColorRGBa {
|
||||
return ColorRGBa(vector.x, vector.y, vector.z, vector.w, linearity)
|
||||
}
|
||||
}
|
||||
|
||||
@Deprecated("Legacy alpha parameter name", ReplaceWith("alpha"))
|
||||
val a = alpha
|
||||
|
||||
/**
|
||||
* Creates a copy of color with adjusted opacity
|
||||
* @param factor a scaling factor used for the opacity
|
||||
* @return A [ColorRGBa] with scaled opacity
|
||||
* @see shade
|
||||
*/
|
||||
fun opacify(factor: Double): ColorRGBa = ColorRGBa(r, g, b, alpha * factor, linearity)
|
||||
|
||||
/**
|
||||
* Creates a copy of color with adjusted color
|
||||
* @param factor a scaling factor used for the opacity
|
||||
* @return A [ColorRGBa] with scaled colors
|
||||
* @see opacify
|
||||
*/
|
||||
fun shade(factor: Double): ColorRGBa = ColorRGBa(r * factor, g * factor, b * factor, alpha, linearity)
|
||||
|
||||
/**
|
||||
* Copy of the color with all of its fields clamped to `[0, 1]`
|
||||
*/
|
||||
|
||||
@Deprecated("Use clip() instead", replaceWith = ReplaceWith("clip()"))
|
||||
val saturated: ColorRGBa
|
||||
get() = clip()
|
||||
|
||||
/**
|
||||
* Copy of the color with all of its fields clamped to `[0, 1]`
|
||||
*/
|
||||
fun clip(): ColorRGBa = copy(
|
||||
r = r.coerceIn(0.0..1.0),
|
||||
g = g.coerceIn(0.0..1.0),
|
||||
b = b.coerceIn(0.0..1.0),
|
||||
alpha = alpha.coerceIn(0.0..1.0)
|
||||
)
|
||||
|
||||
|
||||
/**
|
||||
* Returns a new instance of [ColorRGBa] where the red, green, and blue components
|
||||
* are multiplied by the alpha value of the original color. The alpha value and linearity
|
||||
* remain unchanged.
|
||||
*
|
||||
* This computed property is commonly used for adjusting the color intensity based
|
||||
* on its transparency.
|
||||
*/
|
||||
val alphaMultiplied: ColorRGBa
|
||||
get() = ColorRGBa(r * alpha, g * alpha, b * alpha, alpha, linearity)
|
||||
|
||||
/**
|
||||
* The minimum value over `r`, `g`, `b`
|
||||
* @see maxValue
|
||||
*/
|
||||
val minValue get() = r.coerceAtMost(g).coerceAtMost(b)
|
||||
|
||||
/**
|
||||
* The maximum value over `r`, `g`, `b`
|
||||
* @see minValue
|
||||
*/
|
||||
val maxValue get() = r.coerceAtLeast(g).coerceAtLeast(b)
|
||||
|
||||
/**
|
||||
* calculate luminance value
|
||||
* luminance value is according to <a>https://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef</a>
|
||||
*/
|
||||
val luminance: Double
|
||||
get() = when (linearity) {
|
||||
Linearity.SRGB -> toLinear().luminance
|
||||
else -> 0.2126 * r + 0.7152 * g + 0.0722 * b
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts this color to the specified linearity.
|
||||
*
|
||||
* @param linearity The target linearity to which the color should be converted.
|
||||
* Supported values are [Linearity.SRGB] and [Linearity.LINEAR].
|
||||
* @return A [ColorRGBa] instance in the specified linearity.
|
||||
*/
|
||||
fun toLinearity(linearity: Linearity): ColorRGBa {
|
||||
return when (linearity) {
|
||||
Linearity.SRGB -> toSRGB()
|
||||
Linearity.LINEAR -> toLinear()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* calculate the contrast value between this color and the given color
|
||||
* contrast value is accordingo to <a>// see http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef</a>
|
||||
*/
|
||||
fun getContrastRatio(other: ColorRGBa): Double {
|
||||
val l1 = luminance
|
||||
val l2 = other.luminance
|
||||
return if (l1 > l2) (l1 + 0.05) / (l2 + 0.05) else (l2 + 0.05) / (l1 + 0.05)
|
||||
}
|
||||
|
||||
fun toLinear(): ColorRGBa {
|
||||
fun t(x: Double): Double {
|
||||
return if (x <= 0.04045) x / 12.92 else ((x + 0.055) / (1 + 0.055)).pow(2.4)
|
||||
}
|
||||
return when (linearity) {
|
||||
Linearity.SRGB -> ColorRGBa(t(r), t(g), t(b), alpha, Linearity.LINEAR)
|
||||
else -> this
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert to SRGB
|
||||
* @see toLinear
|
||||
*/
|
||||
fun toSRGB(): ColorRGBa {
|
||||
fun t(x: Double): Double {
|
||||
return if (x <= 0.0031308) 12.92 * x else (1 + 0.055) * x.pow(1.0 / 2.4) - 0.055
|
||||
}
|
||||
return when (linearity) {
|
||||
Linearity.LINEAR -> ColorRGBa(t(r), t(g), t(b), alpha, Linearity.SRGB)
|
||||
else -> this
|
||||
}
|
||||
}
|
||||
|
||||
fun toRGBa(): ColorRGBa = this
|
||||
|
||||
// This is here because the default hashing of enums on the JVM is not stable.
|
||||
override fun hashCode(): Int {
|
||||
var result = r.hashCode()
|
||||
result = 31 * result + g.hashCode()
|
||||
result = 31 * result + b.hashCode()
|
||||
result = 31 * result + alpha.hashCode()
|
||||
// here we overcome the unstable hash by using the ordinal value
|
||||
result = 31 * result + linearity.ordinal.hashCode()
|
||||
return result
|
||||
}
|
||||
|
||||
fun plus(right: ColorRGBa) = copy(
|
||||
r = r + right.r,
|
||||
g = g + right.g,
|
||||
b = b + right.b,
|
||||
alpha = alpha + right.alpha
|
||||
)
|
||||
|
||||
fun minus(right: ColorRGBa) = copy(
|
||||
r = r - right.r,
|
||||
g = g - right.g,
|
||||
b = b - right.b,
|
||||
alpha = alpha - right.alpha
|
||||
)
|
||||
|
||||
fun times(scale: Double) = copy(r = r * scale, g = g * scale, b = b * scale, alpha = alpha * scale)
|
||||
|
||||
fun mix(other: ColorRGBa, factor: Double): ColorRGBa {
|
||||
return mix(this, other, factor)
|
||||
}
|
||||
|
||||
fun toVector4(): Vector4D = Vector4D(r, g, b, alpha)
|
||||
|
||||
/**
|
||||
* Retrieves the color's RGBA component value based on the specified index:
|
||||
* [index] should be 0 for red, 1 for green, 2 for blue, 3 for alpha.
|
||||
* Other index values throw an [IndexOutOfBoundsException].
|
||||
*/
|
||||
operator fun get(index: Int) = when (index) {
|
||||
0 -> r
|
||||
1 -> g
|
||||
2 -> b
|
||||
3 -> alpha
|
||||
else -> throw IllegalArgumentException("unsupported index")
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Weighted mix between two colors in the generic RGB color space.
|
||||
* @param x the weighting of colors, a value 0.0 is equivalent to [left],
|
||||
* 1.0 is equivalent to [right] and at 0.5 both colors contribute to the result equally
|
||||
* @return a mix of [left] and [right] weighted by [x]
|
||||
*/
|
||||
fun mix(left: ColorRGBa, right: ColorRGBa, x: Double): ColorRGBa {
|
||||
val sx = x.coerceIn(0.0, 1.0)
|
||||
|
||||
if (left.linearity.isEquivalent(right.linearity)) {
|
||||
return ColorRGBa(
|
||||
(1.0 - sx) * left.r + sx * right.r,
|
||||
(1.0 - sx) * left.g + sx * right.g,
|
||||
(1.0 - sx) * left.b + sx * right.b,
|
||||
(1.0 - sx) * left.alpha + sx * right.alpha,
|
||||
linearity = left.linearity.leastCertain(right.linearity)
|
||||
)
|
||||
} else {
|
||||
return when (right.linearity) {
|
||||
Linearity.LINEAR -> {
|
||||
mix(left.toLinear(), right.toLinear(), x)
|
||||
}
|
||||
|
||||
Linearity.SRGB -> {
|
||||
mix(left.toSRGB(), right.toSRGB(), x)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Shorthand for calling [ColorRGBa].
|
||||
* Specify only one value to obtain a shade of gray.
|
||||
* @param r red in `[0,1]`
|
||||
* @param g green in `[0,1]`
|
||||
* @param b blue in `[0,1]`
|
||||
* @param a alpha in `[0,1]`, defaults to `1.0`
|
||||
*/
|
||||
fun rgb(r: Double, g: Double, b: Double, a: Double = 1.0) = ColorRGBa(r, g, b, a, linearity = Linearity.LINEAR)
|
||||
|
||||
/**
|
||||
* Shorthand for calling [ColorRGBa].
|
||||
* @param gray shade of gray in `[0,1]`
|
||||
* @param a alpha in `[0,1]`, defaults to `1.0`
|
||||
*/
|
||||
fun rgb(gray: Double, a: Double = 1.0) = ColorRGBa(gray, gray, gray, a, linearity = Linearity.LINEAR)
|
||||
|
||||
/**
|
||||
* Create a color in RGBa space
|
||||
* This function is a shorthand for using the ColorRGBa constructor
|
||||
* @param r red in `[0,1]`
|
||||
* @param g green in `[0,1]`
|
||||
* @param b blue in `[0,1]`
|
||||
* @param a alpha in `[0,1]`
|
||||
*/
|
||||
@Deprecated("Use rgb(r, g, b, a)", ReplaceWith("rgb(r, g, b, a)"), DeprecationLevel.WARNING)
|
||||
fun rgba(r: Double, g: Double, b: Double, a: Double) = ColorRGBa(r, g, b, a, linearity = Linearity.LINEAR)
|
||||
|
||||
/**
|
||||
* Shorthand for calling [ColorRGBa.fromHex].
|
||||
* Creates a [ColorRGBa] with [Linearity.SRGB] from a hex string.
|
||||
* @param hex string encoded hex value, for example `"ffc0cd"`
|
||||
*/
|
||||
fun rgb(hex: String) = ColorRGBa.fromHex(hex)
|
||||
|
||||
/**
|
||||
* Converts RGB integer color values into a ColorRGBa object with sRGB linearity.
|
||||
*
|
||||
* @param red The red component of the color, in the range 0-255.
|
||||
* @param green The green component of the color, in the range 0-255.
|
||||
* @param blue The blue component of the color, in the range 0-255.
|
||||
* @param alpha The alpha (transparency) component of the color, in the range 0-255. Default value is 255 (fully opaque).
|
||||
*/
|
||||
fun rgb(red: Int, green: Int, blue: Int, alpha: Int = 255) =
|
||||
ColorRGBa(red / 255.0, green / 255.0, blue / 255.0, alpha / 255.0, Linearity.SRGB)
|
||||
File diff suppressed because it is too large
Load Diff
23
android/src/main/java/com/icegps/geotools/ktx/ColorRGBa.kt
Normal file
23
android/src/main/java/com/icegps/geotools/ktx/ColorRGBa.kt
Normal file
@@ -0,0 +1,23 @@
|
||||
package com.icegps.geotools.ktx
|
||||
|
||||
import com.icegps.geotools.color.ColorRGBa
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/25
|
||||
*/
|
||||
fun ColorRGBa.toColorInt(): Int {
|
||||
val clampedR = r.coerceIn(0.0, 1.0)
|
||||
val clampedG = g.coerceIn(0.0, 1.0)
|
||||
val clampedB = b.coerceIn(0.0, 1.0)
|
||||
val clampedAlpha = alpha.coerceIn(0.0, 1.0)
|
||||
|
||||
return ((clampedAlpha * 255).toInt() shl 24) or
|
||||
((clampedR * 255).toInt() shl 16) or
|
||||
((clampedG * 255).toInt() shl 8) or
|
||||
((clampedB * 255).toInt())
|
||||
}
|
||||
|
||||
fun ColorRGBa.toColorHex(): String {
|
||||
return String.format("#%06X", 0xFFFFFF and toColorInt())
|
||||
}
|
||||
12
android/src/main/java/com/icegps/geotools/ktx/Context.kt
Normal file
12
android/src/main/java/com/icegps/geotools/ktx/Context.kt
Normal file
@@ -0,0 +1,12 @@
|
||||
package com.icegps.geotools.ktx
|
||||
|
||||
import android.content.Context
|
||||
import android.widget.Toast
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/25
|
||||
*/
|
||||
fun Context.toast(text: String, duration: Int = Toast.LENGTH_SHORT) {
|
||||
Toast.makeText(this, text, duration).show()
|
||||
}
|
||||
24
android/src/main/java/com/icegps/geotools/ktx/Vector2D.kt
Normal file
24
android/src/main/java/com/icegps/geotools/ktx/Vector2D.kt
Normal file
@@ -0,0 +1,24 @@
|
||||
package com.icegps.geotools.ktx
|
||||
|
||||
import com.icegps.common.helper.GeoHelper
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.mapbox.geojson.Point
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/26
|
||||
*/
|
||||
fun Vector2D.toMapboxPoint(): Point {
|
||||
val geoHelper = GeoHelper.getSharedInstance()
|
||||
val wgs84 = geoHelper.enuToWGS84Object(GeoHelper.ENU(x = x, y = y))
|
||||
return Point.fromLngLat(wgs84.lon, wgs84.lat)
|
||||
}
|
||||
|
||||
/**
|
||||
* Interpolates between the current vector and the given vector `o` by the specified mixing factor.
|
||||
*
|
||||
* @param o The target vector to interpolate towards.
|
||||
* @param mix A mixing factor between 0 and 1 where `0` results in the current vector and `1` results in the vector `o`.
|
||||
* @return A new vector that is the result of the interpolation.
|
||||
*/
|
||||
fun Vector2D.mix(o: Vector2D, mix: Double): Vector2D = this * (1 - mix) + o * mix
|
||||
32
android/src/main/java/com/icegps/geotools/ktx/Vector3D.kt
Normal file
32
android/src/main/java/com/icegps/geotools/ktx/Vector3D.kt
Normal file
@@ -0,0 +1,32 @@
|
||||
package com.icegps.geotools.ktx
|
||||
|
||||
import com.icegps.common.helper.GeoHelper
|
||||
import com.icegps.math.geometry.Rectangle
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.mapbox.geojson.Point
|
||||
|
||||
fun Vector3D.niceStr(): String {
|
||||
return "[$x, $y, $z]".format(this)
|
||||
}
|
||||
|
||||
fun List<Vector3D>.niceStr(): String {
|
||||
return joinToString(", ", "[", "]") {
|
||||
it.niceStr()
|
||||
}
|
||||
}
|
||||
|
||||
fun Vector3D.toMapboxPoint(): Point {
|
||||
val geoHelper = GeoHelper.getSharedInstance()
|
||||
return geoHelper.enuToWGS84Object(GeoHelper.ENU(x, y, z)).run {
|
||||
Point.fromLngLat(lon, lat, hgt)
|
||||
}
|
||||
}
|
||||
|
||||
val List<Vector3D>.area: Rectangle
|
||||
get() {
|
||||
val minX = minOf { it.x }
|
||||
val maxX = maxOf { it.x }
|
||||
val minY = minOf { it.y }
|
||||
val maxY = maxOf { it.y }
|
||||
return Rectangle(x = minX, y = minY, width = maxX - minX, height = maxY - minY)
|
||||
}
|
||||
@@ -0,0 +1,219 @@
|
||||
package com.icegps.geotools.marchingsquares
|
||||
|
||||
import com.icegps.math.geometry.Rectangle
|
||||
import com.icegps.math.geometry.Vector2D
|
||||
import com.icegps.math.geometry.Vector2I
|
||||
import com.icegps.geotools.ktx.mix
|
||||
import kotlin.math.max
|
||||
import kotlin.math.min
|
||||
|
||||
private const val closeEpsilon = 1E-6
|
||||
|
||||
data class Segment2D(
|
||||
val start: Vector2D,
|
||||
val control: List<Vector2D>,
|
||||
val end: Vector2D,
|
||||
val corner: Boolean = false
|
||||
)
|
||||
|
||||
fun Segment2D(start: Vector2D, end: Vector2D, corner: Boolean = true) =
|
||||
Segment2D(start, emptyList(), end, corner)
|
||||
|
||||
fun Segment2D(start: Vector2D, c0: Vector2D, c1: Vector2D, end: Vector2D, corner: Boolean = true) =
|
||||
Segment2D(start, listOf(c0, c1), end, corner)
|
||||
|
||||
data class ShapeContour(
|
||||
val segments: List<Segment2D>,
|
||||
val closed: Boolean,
|
||||
) {
|
||||
companion object {
|
||||
val EMPTY = ShapeContour(
|
||||
segments = emptyList(),
|
||||
closed = false,
|
||||
)
|
||||
|
||||
/**
|
||||
* Creates a ShapeContour from a list of points, specifying whether the contour is closed and its y-axis polarity.
|
||||
*
|
||||
* @param points A list of points (Vector2) defining the vertices of the contour.
|
||||
* @param closed Boolean indicating whether the contour should be closed (forms a loop).
|
||||
* @return A ShapeContour object representing the resulting contour.
|
||||
*/
|
||||
fun fromPoints(
|
||||
points: List<Vector2D>,
|
||||
closed: Boolean,
|
||||
): ShapeContour = if (points.isEmpty()) {
|
||||
EMPTY
|
||||
} else {
|
||||
if (!closed) {
|
||||
ShapeContour((0 until points.size - 1).map {
|
||||
Segment2D(
|
||||
points[it],
|
||||
points[it + 1]
|
||||
)
|
||||
}, false)
|
||||
} else {
|
||||
val d = (points.last() - points.first()).lengthSquared
|
||||
val usePoints = if (d > closeEpsilon) points else points.dropLast(1)
|
||||
ShapeContour((usePoints.indices).map {
|
||||
Segment2D(
|
||||
usePoints[it],
|
||||
usePoints[(it + 1) % usePoints.size]
|
||||
)
|
||||
}, true)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
data class LineSegment(val start: Vector2D, val end: Vector2D)
|
||||
|
||||
/**
|
||||
* Find contours for a function [f] using the marching squares algorithm. A contour is found when f(x) crosses zero.
|
||||
* @param f the function
|
||||
* @param area a rectangular area in which the function should be evaluated
|
||||
* @param cellSize the size of the cells, smaller size gives higher resolution
|
||||
* @param useInterpolation intersection points will be interpolated if true, default true
|
||||
* @return a list of [ShapeContour] instances
|
||||
*/
|
||||
fun findContours(
|
||||
f: (Vector2D) -> Double,
|
||||
area: Rectangle,
|
||||
cellSize: Double,
|
||||
useInterpolation: Boolean = true
|
||||
): List<ShapeContour> {
|
||||
val segments = mutableListOf<LineSegment>()
|
||||
val values = mutableMapOf<Vector2I, Double>()
|
||||
val segmentsMap = mutableMapOf<Vector2D, MutableList<LineSegment>>()
|
||||
|
||||
for (y in 0 until (area.height / cellSize).toInt()) {
|
||||
for (x in 0 until (area.width / cellSize).toInt()) {
|
||||
values[Vector2I(x, y)] = f(Vector2D(x * cellSize + area.x, y * cellSize + area.y))
|
||||
}
|
||||
}
|
||||
|
||||
val zero = 0.0
|
||||
for (y in 0 until (area.height / cellSize).toInt()) {
|
||||
for (x in 0 until (area.width / cellSize).toInt()) {
|
||||
|
||||
// Here we check if we are at a right or top border. This is to ensure we create closed contours
|
||||
// later on in the process.
|
||||
val v00 = if (x == 0 || y == 0) zero else (values[Vector2I(x, y)] ?: zero)
|
||||
val v10 = if (y == 0) zero else (values[Vector2I(x + 1, y)] ?: zero)
|
||||
val v01 = if (x == 0) zero else (values[Vector2I(x, y + 1)] ?: zero)
|
||||
val v11 = (values[Vector2I(x + 1, y + 1)] ?: zero)
|
||||
|
||||
val p00 = Vector2D(x.toDouble(), y.toDouble()) * cellSize + area.topLeft
|
||||
val p10 = Vector2D((x + 1).toDouble(), y.toDouble()) * cellSize + area.topLeft
|
||||
val p01 = Vector2D(x.toDouble(), (y + 1).toDouble()) * cellSize + area.topLeft
|
||||
val p11 = Vector2D((x + 1).toDouble(), (y + 1).toDouble()) * cellSize + area.topLeft
|
||||
|
||||
val index = (if (v00 >= 0.0) 1 else 0) +
|
||||
(if (v10 >= 0.0) 2 else 0) +
|
||||
(if (v01 >= 0.0) 4 else 0) +
|
||||
(if (v11 >= 0.0) 8 else 0)
|
||||
|
||||
fun blend(v1: Double, v2: Double): Double {
|
||||
if (useInterpolation) {
|
||||
require(!v1.isNaN() && !v2.isNaN()) {
|
||||
"Input values v1=$v1 or v2=$v2 are NaN, which is not allowed."
|
||||
}
|
||||
val f1 = min(v1, v2)
|
||||
val f2 = max(v1, v2)
|
||||
val v = (-f1) / (f2 - f1)
|
||||
|
||||
require(v == v && v in 0.0..1.0) {
|
||||
"Invalid value calculated during interpolation: v=$v"
|
||||
}
|
||||
|
||||
return if (f1 == v1) {
|
||||
v
|
||||
} else {
|
||||
1.0 - v
|
||||
}
|
||||
} else {
|
||||
return 0.5
|
||||
}
|
||||
}
|
||||
|
||||
fun emitLine(
|
||||
p00: Vector2D, p01: Vector2D, v00: Double, v01: Double,
|
||||
p10: Vector2D, p11: Vector2D, v10: Double, v11: Double
|
||||
) {
|
||||
val r0 = blend(v00, v01)
|
||||
val r1 = blend(v10, v11)
|
||||
|
||||
val v0 = p00.mix(p01, r0)
|
||||
val v1 = p10.mix(p11, r1)
|
||||
val l0 = LineSegment(v0, v1)
|
||||
segmentsMap.getOrPut(v1) { mutableListOf() }.add(l0)
|
||||
segmentsMap.getOrPut(v0) { mutableListOf() }.add(l0)
|
||||
segments.add(l0)
|
||||
}
|
||||
|
||||
when (index) {
|
||||
0, 15 -> {}
|
||||
1, 15 xor 1 -> {
|
||||
emitLine(p00, p01, v00, v01, p00, p10, v00, v10)
|
||||
}
|
||||
|
||||
2, 15 xor 2 -> {
|
||||
emitLine(p00, p10, v00, v10, p10, p11, v10, v11)
|
||||
}
|
||||
|
||||
3, 15 xor 3 -> {
|
||||
emitLine(p00, p01, v00, v01, p10, p11, v10, v11)
|
||||
}
|
||||
|
||||
4, 15 xor 4 -> {
|
||||
emitLine(p00, p01, v00, v01, p01, p11, v01, v11)
|
||||
}
|
||||
|
||||
5, 15 xor 5 -> {
|
||||
emitLine(p00, p10, v00, v10, p01, p11, v01, v11)
|
||||
}
|
||||
|
||||
6, 15 xor 6 -> {
|
||||
emitLine(p00, p01, v00, v01, p00, p10, v00, v10)
|
||||
emitLine(p01, p11, v01, v11, p10, p11, v10, v11)
|
||||
}
|
||||
|
||||
7, 15 xor 7 -> {
|
||||
emitLine(p01, p11, v01, v11, p10, p11, v10, v11)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
val processedSegments = mutableSetOf<LineSegment>()
|
||||
val contours = mutableListOf<ShapeContour>()
|
||||
for (segment in segments) {
|
||||
if (segment in processedSegments) {
|
||||
continue
|
||||
} else {
|
||||
val collected = mutableListOf<Vector2D>()
|
||||
var current: LineSegment? = segment
|
||||
var closed = true
|
||||
var lastVertex = Vector2D.INFINITY
|
||||
do {
|
||||
current!!
|
||||
if (lastVertex.squaredDistanceTo(current.start) > 1E-5) {
|
||||
collected.add(current.start)
|
||||
}
|
||||
lastVertex = current.start
|
||||
processedSegments.add(current)
|
||||
if (segmentsMap[current.start]!!.size < 2) {
|
||||
closed = false
|
||||
}
|
||||
val hold = current
|
||||
current = segmentsMap[current.start]?.firstOrNull { it !in processedSegments }
|
||||
if (current == null) {
|
||||
current = segmentsMap[hold.end]?.firstOrNull { it !in processedSegments }
|
||||
}
|
||||
} while (current != segment && current != null)
|
||||
|
||||
contours.add(ShapeContour.fromPoints(collected, closed = closed))
|
||||
}
|
||||
}
|
||||
return contours
|
||||
}
|
||||
170
android/src/main/res/drawable/ic_launcher_background.xml
Normal file
170
android/src/main/res/drawable/ic_launcher_background.xml
Normal file
@@ -0,0 +1,170 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
android:width="108dp"
|
||||
android:height="108dp"
|
||||
android:viewportWidth="108"
|
||||
android:viewportHeight="108">
|
||||
<path
|
||||
android:fillColor="#3DDC84"
|
||||
android:pathData="M0,0h108v108h-108z" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M9,0L9,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M19,0L19,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M29,0L29,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M39,0L39,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M49,0L49,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M59,0L59,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M69,0L69,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M79,0L79,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M89,0L89,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M99,0L99,108"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,9L108,9"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,19L108,19"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,29L108,29"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,39L108,39"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,49L108,49"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,59L108,59"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,69L108,69"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,79L108,79"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,89L108,89"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M0,99L108,99"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M19,29L89,29"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M19,39L89,39"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M19,49L89,49"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M19,59L89,59"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M19,69L89,69"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M19,79L89,79"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M29,19L29,89"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M39,19L39,89"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M49,19L49,89"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M59,19L59,89"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M69,19L69,89"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
<path
|
||||
android:fillColor="#00000000"
|
||||
android:pathData="M79,19L79,89"
|
||||
android:strokeWidth="0.8"
|
||||
android:strokeColor="#33FFFFFF" />
|
||||
</vector>
|
||||
30
android/src/main/res/drawable/ic_launcher_foreground.xml
Normal file
30
android/src/main/res/drawable/ic_launcher_foreground.xml
Normal file
@@ -0,0 +1,30 @@
|
||||
<vector xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
xmlns:aapt="http://schemas.android.com/aapt"
|
||||
android:width="108dp"
|
||||
android:height="108dp"
|
||||
android:viewportWidth="108"
|
||||
android:viewportHeight="108">
|
||||
<path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
|
||||
<aapt:attr name="android:fillColor">
|
||||
<gradient
|
||||
android:endX="85.84757"
|
||||
android:endY="92.4963"
|
||||
android:startX="42.9492"
|
||||
android:startY="49.59793"
|
||||
android:type="linear">
|
||||
<item
|
||||
android:color="#44000000"
|
||||
android:offset="0.0" />
|
||||
<item
|
||||
android:color="#00000000"
|
||||
android:offset="1.0" />
|
||||
</gradient>
|
||||
</aapt:attr>
|
||||
</path>
|
||||
<path
|
||||
android:fillColor="#FFFFFF"
|
||||
android:fillType="nonZero"
|
||||
android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
|
||||
android:strokeWidth="1"
|
||||
android:strokeColor="#00000000" />
|
||||
</vector>
|
||||
190
android/src/main/res/layout-port/activity_main.xml
Normal file
190
android/src/main/res/layout-port/activity_main.xml
Normal file
@@ -0,0 +1,190 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
xmlns:tools="http://schemas.android.com/tools"
|
||||
android:id="@+id/main"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="match_parent"
|
||||
android:orientation="vertical"
|
||||
tools:context=".MainActivity">
|
||||
|
||||
<com.mapbox.maps.MapView
|
||||
android:id="@+id/map_view"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="0dp"
|
||||
android:layout_weight="3" />
|
||||
|
||||
<ScrollView
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="0dp"
|
||||
android:layout_weight="1">
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:orientation="vertical">
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/slider_target_height"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:value="0"
|
||||
android:valueFrom="0"
|
||||
android:valueTo="100" />
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="栅格大小：" />
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/cell_size"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_weight="1"
|
||||
android:value="1"
|
||||
android:valueFrom="1"
|
||||
android:valueTo="100" />
|
||||
</LinearLayout>
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="高度范围：" />
|
||||
|
||||
<com.google.android.material.slider.RangeSlider
|
||||
android:id="@+id/height_range"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_weight="1"
|
||||
android:valueFrom="0"
|
||||
android:valueTo="100" />
|
||||
</LinearLayout>
|
||||
|
||||
<Switch
|
||||
android:id="@+id/switch_grid"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:switchPadding="16dp"
|
||||
android:text="栅格网" />
|
||||
|
||||
<Switch
|
||||
android:id="@+id/switch_triangle"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:switchPadding="16dp"
|
||||
android:text="三角网" />
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="坐标数量：" />
|
||||
|
||||
<TextView
|
||||
android:id="@+id/point_count"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content" />
|
||||
</LinearLayout>
|
||||
|
||||
<Button
|
||||
android:id="@+id/update"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="刷新界面" />
|
||||
|
||||
<Button
|
||||
android:id="@+id/clear_points"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="清除所有点" />
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="坡向(角度)：" />
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/slope_direction"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_weight="1"
|
||||
android:valueFrom="0"
|
||||
android:valueTo="360" />
|
||||
</LinearLayout>
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="坡度(%)：" />
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/slope_percentage"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_weight="1"
|
||||
android:valueFrom="0"
|
||||
android:valueTo="100" />
|
||||
</LinearLayout>
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="设计面高度(m)：" />
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/design_height"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:value="0"
|
||||
android:valueFrom="-100"
|
||||
android:valueTo="100" />
|
||||
</LinearLayout>
|
||||
|
||||
<Switch
|
||||
android:id="@+id/switch_design_surface"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:switchPadding="16dp"
|
||||
android:text="显示设计面" />
|
||||
|
||||
<Switch
|
||||
android:id="@+id/switch_slope_result"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:switchPadding="16dp"
|
||||
android:text="显示计算的坡面" />
|
||||
</LinearLayout>
|
||||
</ScrollView>
|
||||
</LinearLayout>
|
||||
186
android/src/main/res/layout/activity_main.xml
Normal file
186
android/src/main/res/layout/activity_main.xml
Normal file
@@ -0,0 +1,186 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
|
||||
xmlns:tools="http://schemas.android.com/tools"
|
||||
android:id="@+id/main"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="match_parent"
|
||||
android:orientation="horizontal"
|
||||
tools:context=".MainActivity">
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="match_parent"
|
||||
android:layout_weight="1"
|
||||
android:orientation="vertical"
|
||||
android:paddingTop="32dp">
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/slider_target_height"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:value="0"
|
||||
android:valueFrom="0"
|
||||
android:valueTo="100" />
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="栅格大小：" />
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/cell_size"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_weight="1"
|
||||
android:value="1"
|
||||
android:valueFrom="1"
|
||||
android:valueTo="100" />
|
||||
</LinearLayout>
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="高度范围：" />
|
||||
|
||||
<com.google.android.material.slider.RangeSlider
|
||||
android:id="@+id/height_range"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_weight="1"
|
||||
android:valueFrom="0"
|
||||
android:valueTo="100" />
|
||||
</LinearLayout>
|
||||
|
||||
<Switch
|
||||
android:id="@+id/switch_grid"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:switchPadding="16dp"
|
||||
android:text="栅格网" />
|
||||
|
||||
<Switch
|
||||
android:id="@+id/switch_triangle"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:switchPadding="16dp"
|
||||
android:text="三角网" />
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="坐标数量：" />
|
||||
|
||||
<TextView
|
||||
android:id="@+id/point_count"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content" />
|
||||
</LinearLayout>
|
||||
|
||||
<Button
|
||||
android:id="@+id/update"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="刷新界面" />
|
||||
|
||||
<Button
|
||||
android:id="@+id/clear_points"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="清除所有点" />
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="坡向(角度)：" />
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/slope_direction"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_weight="1"
|
||||
android:valueFrom="0"
|
||||
android:valueTo="360" />
|
||||
</LinearLayout>
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical"
|
||||
android:orientation="horizontal">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="坡度(%)：" />
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/slope_percentage"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_weight="1"
|
||||
android:valueFrom="0"
|
||||
android:valueTo="100" />
|
||||
</LinearLayout>
|
||||
|
||||
<LinearLayout
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:gravity="center_vertical">
|
||||
|
||||
<TextView
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:text="设计面高度(m)：" />
|
||||
|
||||
<com.google.android.material.slider.Slider
|
||||
android:id="@+id/design_height"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:value="0"
|
||||
android:valueFrom="-100"
|
||||
android:valueTo="100" />
|
||||
</LinearLayout>
|
||||
|
||||
<Switch
|
||||
android:id="@+id/switch_design_surface"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:switchPadding="16dp"
|
||||
android:text="显示设计面" />
|
||||
|
||||
<Switch
|
||||
android:id="@+id/switch_slope_result"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:switchPadding="16dp"
|
||||
android:text="显示计算的坡面" />
|
||||
</LinearLayout>
|
||||
|
||||
<com.mapbox.maps.MapView
|
||||
android:id="@+id/map_view"
|
||||
android:layout_width="0dp"
|
||||
android:layout_height="match_parent"
|
||||
android:layout_weight="3" />
|
||||
</LinearLayout>
|
||||
6
android/src/main/res/mipmap-anydpi/ic_launcher.xml
Normal file
6
android/src/main/res/mipmap-anydpi/ic_launcher.xml
Normal file
@@ -0,0 +1,6 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
|
||||
<background android:drawable="@drawable/ic_launcher_background" />
|
||||
<foreground android:drawable="@drawable/ic_launcher_foreground" />
|
||||
<monochrome android:drawable="@drawable/ic_launcher_foreground" />
|
||||
</adaptive-icon>
|
||||
6
android/src/main/res/mipmap-anydpi/ic_launcher_round.xml
Normal file
6
android/src/main/res/mipmap-anydpi/ic_launcher_round.xml
Normal file
@@ -0,0 +1,6 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
|
||||
<background android:drawable="@drawable/ic_launcher_background" />
|
||||
<foreground android:drawable="@drawable/ic_launcher_foreground" />
|
||||
<monochrome android:drawable="@drawable/ic_launcher_foreground" />
|
||||
</adaptive-icon>
|
||||
BIN
android/src/main/res/mipmap-hdpi/ic_launcher.webp
Normal file
BIN
android/src/main/res/mipmap-hdpi/ic_launcher.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.4 KiB |
BIN
android/src/main/res/mipmap-hdpi/ic_launcher_round.webp
Normal file
BIN
android/src/main/res/mipmap-hdpi/ic_launcher_round.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 2.8 KiB |
BIN
android/src/main/res/mipmap-mdpi/ic_launcher.webp
Normal file
BIN
android/src/main/res/mipmap-mdpi/ic_launcher.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 982 B |
BIN
android/src/main/res/mipmap-mdpi/ic_launcher_round.webp
Normal file
BIN
android/src/main/res/mipmap-mdpi/ic_launcher_round.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.7 KiB |
BIN
android/src/main/res/mipmap-xhdpi/ic_launcher.webp
Normal file
BIN
android/src/main/res/mipmap-xhdpi/ic_launcher.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.9 KiB |
BIN
android/src/main/res/mipmap-xhdpi/ic_launcher_round.webp
Normal file
BIN
android/src/main/res/mipmap-xhdpi/ic_launcher_round.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.8 KiB |
BIN
android/src/main/res/mipmap-xxhdpi/ic_launcher.webp
Normal file
BIN
android/src/main/res/mipmap-xxhdpi/ic_launcher.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 2.8 KiB |
BIN
android/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp
Normal file
BIN
android/src/main/res/mipmap-xxhdpi/ic_launcher_round.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 5.8 KiB |
BIN
android/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
Normal file
BIN
android/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 3.8 KiB |
BIN
android/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp
Normal file
BIN
android/src/main/res/mipmap-xxxhdpi/ic_launcher_round.webp
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 7.6 KiB |
7
android/src/main/res/values-night/themes.xml
Normal file
7
android/src/main/res/values-night/themes.xml
Normal file
@@ -0,0 +1,7 @@
|
||||
<resources xmlns:tools="http://schemas.android.com/tools">
|
||||
<!-- Base application theme. -->
|
||||
<style name="Base.Theme.Orx" parent="Theme.Material3.DayNight.NoActionBar">
|
||||
<!-- Customize your dark theme here. -->
|
||||
<!-- <item name="colorPrimary">@color/my_dark_primary</item> -->
|
||||
</style>
|
||||
</resources>
|
||||
5
android/src/main/res/values/colors.xml
Normal file
5
android/src/main/res/values/colors.xml
Normal file
@@ -0,0 +1,5 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<resources>
|
||||
<color name="black">#FF000000</color>
|
||||
<color name="white">#FFFFFFFF</color>
|
||||
</resources>
|
||||
4
android/src/main/res/values/mapbox_access_token.xml
Normal file
4
android/src/main/res/values/mapbox_access_token.xml
Normal file
@@ -0,0 +1,4 @@
|
||||
<?xml version="1.0" encoding="utf-8"?>
|
||||
<resources xmlns:tools="http://schemas.android.com/tools">
|
||||
<string name="mapbox_access_token" translatable="false" tools:ignore="UnusedResources">pk.eyJ1IjoienpxMSIsImEiOiJjbWYzbzV1MzQwMHJvMmpvbG1wbjJwdjUyIn0.LvKjIrCv9dAFcGxOM52f2Q</string>
|
||||
</resources>
|
||||
3
android/src/main/res/values/strings.xml
Normal file
3
android/src/main/res/values/strings.xml
Normal file
@@ -0,0 +1,3 @@
|
||||
<resources>
|
||||
<string name="app_name">icegps-orx</string>
|
||||
</resources>
|
||||
9
android/src/main/res/values/themes.xml
Normal file
9
android/src/main/res/values/themes.xml
Normal file
@@ -0,0 +1,9 @@
|
||||
<resources xmlns:tools="http://schemas.android.com/tools">
|
||||
<!-- Base application theme. -->
|
||||
<style name="Base.Theme.Orx" parent="Theme.Material3.DayNight.NoActionBar">
|
||||
<!-- Customize your light theme here. -->
|
||||
<!-- <item name="colorPrimary">@color/my_light_primary</item> -->
|
||||
</style>
|
||||
|
||||
<style name="Theme.Orx" parent="Base.Theme.Orx" />
|
||||
</resources>
|
||||
17
android/src/test/java/com/icegps/geotools/ExampleUnitTest.kt
Normal file
17
android/src/test/java/com/icegps/geotools/ExampleUnitTest.kt
Normal file
@@ -0,0 +1,17 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import org.junit.Test
|
||||
|
||||
import org.junit.Assert.*
|
||||
|
||||
/**
|
||||
* Example local unit test, which will execute on the development machine (host).
|
||||
*
|
||||
* See [testing documentation](http://d.android.com/tools/testing).
|
||||
*/
|
||||
class ExampleUnitTest {
|
||||
@Test
|
||||
fun addition_isCorrect() {
|
||||
assertEquals(4, 2 + 2)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
package com.icegps.geotools
|
||||
|
||||
import com.icegps.geotools.ktx.area
|
||||
import com.icegps.geotools.ktx.niceStr
|
||||
import com.icegps.math.geometry.Vector3D
|
||||
import com.icegps.triangulation.delaunayTriangulation
|
||||
import org.junit.Test
|
||||
import kotlin.math.max
|
||||
|
||||
/**
|
||||
* @author tabidachinokaze
|
||||
* @date 2025/11/26
|
||||
*/
|
||||
class TriangulationToGridTest {
|
||||
@Test
|
||||
fun testTriangulationToGrid() {
|
||||
val points = listOf(
|
||||
Vector3D(-10.0, 10.0, 0.0),
|
||||
Vector3D(10.0, 10.0, 10.0),
|
||||
Vector3D(-10.0, -10.0, 20.0),
|
||||
Vector3D(10.0, -10.0, 30.0),
|
||||
)
|
||||
points.map {
|
||||
it / 8
|
||||
}.niceStr().let(::println)
|
||||
val area = points.area
|
||||
val cellSize = max(area.x + area.width, area.y + area.height) / 10
|
||||
val triangulation = points.delaunayTriangulation()
|
||||
val triangles = triangulation.triangles()
|
||||
val grid = triangulationToGrid(
|
||||
delaunator = triangulation,
|
||||
cellSize = cellSize,
|
||||
)
|
||||
grid.string().let(::println)
|
||||
val slopeResult = SlopeCalculator.calculateSlope(
|
||||
grid = grid,
|
||||
slopeDirection = 0.0,
|
||||
slopePercentage = 100.0,
|
||||
baseHeightOffset = 0.0
|
||||
)
|
||||
slopeResult.designSurface.string().let(::println)
|
||||
println("原来的 Volume: ${grid.volumeSum()}")
|
||||
println("做坡的 Volume: ${slopeResult.designSurface.volumeSum()}")
|
||||
println(slopeResult.earthworkResult)
|
||||
}
|
||||
}
|
||||
|
||||
fun GridModel.string() = buildString {
|
||||
for (r in 0 until rows) {
|
||||
for (c in 0 until cols) {
|
||||
val originalElev = getValue(r, c) ?: continue
|
||||
append("${originalElev.format()}, ")
|
||||
}
|
||||
appendLine()
|
||||
}
|
||||
}
|
||||
|
||||
fun GridModel.volumeSum(): Double {
|
||||
var volume = 0.0
|
||||
for (r in 0 until rows) {
|
||||
for (c in 0 until cols) {
|
||||
val height = getValue(r, c) ?: continue
|
||||
volume += height
|
||||
}
|
||||
}
|
||||
return volume
|
||||
}
|
||||
|
||||
fun Double.format(): String {
|
||||
return "%.1f".format(this)
|
||||
}
|
||||
Reference in New Issue
Block a user