diff options
Diffstat (limited to 'android-app/app')
4 files changed, 958 insertions, 21 deletions
diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/MainActivity.kt b/android-app/app/src/main/kotlin/com/example/androidapp/MainActivity.kt index 5a91a7a..f1f8c4d 100644 --- a/android-app/app/src/main/kotlin/com/example/androidapp/MainActivity.kt +++ b/android-app/app/src/main/kotlin/com/example/androidapp/MainActivity.kt @@ -2,11 +2,14 @@ package com.example.androidapp import android.Manifest import android.content.pm.PackageManager +import android.graphics.BitmapFactory import android.location.Location +import android.media.MediaPlayer import android.os.Bundle import android.util.Log import android.view.View import android.widget.Button +import android.widget.LinearLayout import android.widget.TextView import android.widget.Toast import androidx.activity.result.contract.ActivityResultContracts @@ -17,7 +20,17 @@ import androidx.lifecycle.lifecycleScope import com.google.android.material.floatingactionbutton.FloatingActionButton import org.maplibre.android.MapLibre import org.maplibre.android.maps.MapView +import org.maplibre.android.maps.MapLibreMap import org.maplibre.android.maps.Style +import org.maplibre.android.style.layers.CircleLayer +import org.maplibre.android.style.layers.PropertyFactory +import org.maplibre.android.style.layers.SymbolLayer +import org.maplibre.android.style.sources.GeoJsonSource +import com.mapbox.geojson.Feature +import com.mapbox.geojson.FeatureCollection +import com.mapbox.geojson.Point +import com.mapbox.geojson.Polygon +import com.mapbox.geojson.LineString import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.flow.distinctUntilChanged @@ -26,6 +39,13 @@ import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import java.util.Locale import java.util.concurrent.TimeUnit +import kotlinx.coroutines.tasks.await +import kotlin.math.cos +import kotlin.math.sin +import kotlin.math.sqrt +import kotlin.math.atan2 +import kotlin.math.toDegrees +import kotlin.math.toRadians data class MobWaypoint( val latitude: Double, @@ -40,6 +60,19 @@ class MainActivity : AppCompatActivity() { private lateinit var fabToggleInstruments: FloatingActionButton private lateinit var fabMob: FloatingActionButton + // MapLibreMap instance + private var maplibreMap: MapLibreMap? = null + + // MapLibre Layers and Sources for Anchor Watch + private val ANCHOR_POINT_SOURCE_ID = "anchor-point-source" + private val ANCHOR_CIRCLE_SOURCE_ID = "anchor-circle-source" + private val ANCHOR_POINT_LAYER_ID = "anchor-point-layer" + private val ANCHOR_CIRCLE_LAYER_ID = "anchor-circle-layer" + private val ANCHOR_ICON_ID = "anchor-icon" + + private var anchorPointSource: GeoJsonSource? = null + private var anchorCircleSource: GeoJsonSource? = null + // MOB UI elements private lateinit var mobNavigationContainer: ConstraintLayout private lateinit var mobValueDistance: TextView @@ -64,7 +97,20 @@ class MainActivity : AppCompatActivity() { private lateinit var valueSog: TextView private lateinit var valueVmg: TextView private lateinit var valueDepth: TextView - private lateinit var valuePolarPct: TextView + // Removed valuePolarPct as it's now handled by the PolarDiagramView + private lateinit var polarDiagramView: PolarDiagramView // Reference to the custom view + + // Anchor Watch UI elements + private lateinit var fabAnchor: FloatingActionButton + private lateinit var anchorConfigContainer: ConstraintLayout + private lateinit var anchorStatusText: TextView + private lateinit var anchorRadiusText: TextView + private lateinit var buttonDecreaseRadius: Button + private lateinit var buttonIncreaseRadius: Button + private lateinit var buttonSetAnchor: Button + private lateinit var buttonStopAnchor: Button + + private var currentWatchCircleRadius = AnchorWatchState.DEFAULT_WATCH_CIRCLE_RADIUS_METERS // Register the permissions callback, which handles the user's response to the // system permissions dialog. @@ -76,6 +122,7 @@ class MainActivity : AppCompatActivity() { Toast.makeText(this, "Location permissions granted", Toast.LENGTH_SHORT).show() locationService = LocationService(this) observeLocationUpdates() // Start observing location updates + observeAnchorWatchState() // Start observing anchor watch state } else { // Permissions denied, handle the case (e.g., show a message to the user) Toast.makeText(this, "Location permissions denied", Toast.LENGTH_LONG).show() @@ -94,18 +141,22 @@ class MainActivity : AppCompatActivity() { ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { requestPermissionLauncher.launch(arrayOf( Manifest.permission.ACCESS_FINE_LOCATION, - Manifest.permission.ACCESS_COARSE_LOCATION + Manifest.PERMISSION_ACCESS_COARSE_LOCATION )) } else { // Permissions already granted, initialize location service locationService = LocationService(this) observeLocationUpdates() // Start observing location updates + observeAnchorWatchState() // Start observing anchor watch state } mapView = findViewById(R.id.mapView) mapView?.onCreate(savedInstanceState) mapView?.getMapAsync { maplibreMap -> - maplibreMap.setStyle(Style.Builder().fromUri("https://tiles.openseamap.org/seamark/osm-bright/style.json")) + this.maplibreMap = maplibreMap // Assign to class member + maplibreMap.setStyle(Style.Builder().fromUri("https://tiles.openseamap.org/seamark/osm-bright/style.json")) { style -> + setupAnchorMapLayers(style) + } } instrumentDisplayContainer = findViewById(R.id.instrument_display_container) @@ -127,7 +178,54 @@ class MainActivity : AppCompatActivity() { valueSog = findViewById(R.id.value_sog) valueVmg = findViewById(R.id.value_vmg) valueDepth = findViewById(R.id.value_depth) - valuePolarPct = findViewById(R.id.value_polar_pct) + // Removed initialization for valuePolarPct + + // Initialize PolarDiagramView + polarDiagramView = findViewById(R.id.polar_diagram_view) + + // Set up mock polar data + val mockPolarTable = createMockPolarTable() + polarDiagramView.setPolarTable(mockPolarTable) + + // Simulate real-time updates for the polar diagram + lifecycleScope.launch { + var simulatedTws = 8.0 + var simulatedTwa = 40.0 + var simulatedBsp = mockPolarTable.interpolateBsp(simulatedTws, simulatedTwa) + + while (true) { + // Update instrument display with current simulated values + updateInstrumentDisplay( + aws = "%.1f".format(Locale.getDefault(), simulatedTws * 1.1), // AWS usually higher than TWS + tws = "%.1f".format(Locale.getDefault(), simulatedTws), + hdg = "---", // No mock for HDG + cog = "---", // No mock for COG + bsp = "%.1f".format(Locale.getDefault(), simulatedBsp), + sog = "%.1f".format(Locale.getDefault(), simulatedBsp * 0.95), // SOG usually slightly less than BSP + vmg = "%.1f".format(Locale.getDefault(), mockPolarTable.curves.firstOrNull { it.twS == simulatedTws }?.calculateVmg(simulatedTwa, simulatedBsp) ?: 0.0), + depth = getString(R.string.placeholder_depth_value), + polarPct = "%.0f%%".format(Locale.getDefault(), mockPolarTable.calculatePolarPercentage(simulatedTws, simulatedTwa, simulatedBsp)) + ) + polarDiagramView.setCurrentPerformance(simulatedTws, simulatedTwa, simulatedBsp) + + // Slowly change TWA to simulate sailing + simulatedTwa += 0.5 // Change by 0.5 degrees + if (simulatedTwa > 170) simulatedTwa = 40.0 // Reset or change direction + simulatedBsp = mockPolarTable.interpolateBsp(simulatedTws, simulatedTwa) + + kotlinx.coroutines.delay(1000) // Update every second + } + } + + // Initialize Anchor Watch UI elements + fabAnchor = findViewById(R.id.fab_anchor) + anchorConfigContainer = findViewById(R.id.anchor_config_container) + anchorStatusText = findViewById(R.id.anchor_status_text) + anchorRadiusText = findViewById(R.id.anchor_radius_text) + buttonDecreaseRadius = findViewById(R.id.button_decrease_radius) + buttonIncreaseRadius = findViewById(R.id.button_increase_radius) + buttonSetAnchor = findViewById(R.id.button_set_anchor) + buttonStopAnchor = findViewById(R.id.button_stop_anchor) // Set initial placeholder values updateInstrumentDisplay( @@ -156,11 +254,173 @@ class MainActivity : AppCompatActivity() { activateMob() } + fabAnchor.setOnClickListener { + if (anchorConfigContainer.visibility == View.VISIBLE) { + anchorConfigContainer.visibility = View.GONE + } else { + anchorConfigContainer.visibility = View.VISIBLE + // Ensure anchor radius display is updated when shown + anchorRadiusText.text = String.format(Locale.getDefault(), "Radius: %.1fm", currentWatchCircleRadius) + } + } + + buttonDecreaseRadius.setOnClickListener { + currentWatchCircleRadius = (currentWatchCircleRadius - 5).coerceAtLeast(10.0) // Minimum 10m + anchorRadiusText.text = String.format(Locale.getDefault(), "Radius: %.1fm", currentWatchCircleRadius) + if (::locationService.isInitialized) { + locationService.updateWatchCircleRadius(currentWatchCircleRadius) + } + } + + buttonIncreaseRadius.setOnClickListener { + currentWatchCircleRadius = (currentWatchCircleRadius + 5).coerceAtMost(200.0) // Maximum 200m + anchorRadiusText.text = String.format(Locale.getDefault(), "Radius: %.1fm", currentWatchCircleRadius) + if (::locationService.isInitialized) { + locationService.updateWatchCircleRadius(currentWatchCircleRadius) + } + } + + buttonSetAnchor.setOnClickListener { + if (::locationService.isInitialized) { + lifecycleScope.launch { + locationService.startAnchorWatch(currentWatchCircleRadius) + Toast.makeText(this@MainActivity, "Anchor watch set!", Toast.LENGTH_SHORT).show() + } + } else { + Toast.makeText(this, "Location service not initialized. Grant permissions first.", Toast.LENGTH_LONG).show() + } + } + + buttonStopAnchor.setOnClickListener { + if (::locationService.isInitialized) { + locationService.stopAnchorWatch() + Toast.makeText(this@MainActivity, "Anchor watch stopped.", Toast.LENGTH_SHORT).show() + } + } + mobRecoveredButton.setOnClickListener { recoverMob() } } + private fun createMockPolarTable(): PolarTable { + // Example polar data for a hypothetical boat + // TWS 6 knots + val polar6k = PolarCurve( + twS = 6.0, + points = listOf( + PolarPoint(tWa = 30.0, bSp = 3.0), + PolarPoint(tWa = 45.0, bSp = 4.0), + PolarPoint(tWa = 60.0, bSp = 4.5), + PolarPoint(tWa = 90.0, bSp = 4.8), + PolarPoint(tWa = 120.0, bSp = 4.0), + PolarPoint(tWa = 150.0, bSp = 3.0), + PolarPoint(tWa = 180.0, bSp = 2.0) + ) + ) + + // TWS 8 knots + val polar8k = PolarCurve( + twS = 8.0, + points = listOf( + PolarPoint(tWa = 30.0, bSp = 4.0), + PolarPoint(tWa = 45.0, bSp = 5.0), + PolarPoint(tWa = 60.0, bSp = 5.5), + PolarPoint(tWa = 90.0, bSp = 5.8), + PolarPoint(tWa = 120.0, bSp = 5.0), + PolarPoint(tWa = 150.0, bSp = 4.0), + PolarPoint(tWa = 180.0, bSp = 2.5) + ) + ) + + // TWS 10 knots + val polar10k = PolarCurve( + twS = 10.0, + points = listOf( + PolarPoint(tWa = 30.0, bSp = 5.0), + PolarPoint(tWa = 45.0, bSp = 6.0), + PolarPoint(tWa = 60.0, bSp = 6.5), + PolarPoint(tWa = 90.0, bSp = 6.8), + PolarPoint(tWa = 120.0, bSp = 6.0), + PolarPoint(tWa = 150.0, bSp = 4.5), + PolarPoint(tWa = 180.0, bSp = 3.0) + ) + ) + + return PolarTable(curves = listOf(polar6k, polar8k, polar10k)) + } + + + private fun setupAnchorMapLayers(style: Style) { + // Add anchor icon + style.addImage(ANCHOR_ICON_ID, BitmapFactory.decodeResource(resources, R.drawable.ic_anchor)) + + // Create sources + anchorPointSource = GeoJsonSource(ANCHOR_POINT_SOURCE_ID, FeatureCollection.fromFeatures(emptyList())) + anchorCircleSource = GeoJsonSource(ANCHOR_CIRCLE_SOURCE_ID, FeatureCollection.fromFeatures(emptyList())) + style.addSource(anchorPointSource!!) + style.addSource(anchorCircleSource!!) + + // Create layers + val anchorPointLayer = SymbolLayer(ANCHOR_POINT_LAYER_ID, ANCHOR_POINT_SOURCE_ID).apply { + setProperties( + PropertyFactory.iconImage(ANCHOR_ICON_ID), + PropertyFactory.iconAllowOverlap(true), + PropertyFactory.iconIgnorePlacement(true) + ) + } + val anchorCircleLayer = CircleLayer(ANCHOR_CIRCLE_LAYER_ID, ANCHOR_CIRCLE_SOURCE_ID).apply { + setProperties( + PropertyFactory.circleRadius(PropertyFactory.zoom().toExpression()), // Radius will be handled dynamically or by GeoJSON property + PropertyFactory.circleColor(ContextCompat.getColor(this@MainActivity, R.color.anchor_button_background)), + PropertyFactory.circleOpacity(0.3f), + PropertyFactory.circleStrokeWidth(2.0f), + PropertyFactory.circleStrokeColor(ContextCompat.getColor(this@MainActivity, R.color.anchor_button_background)) + ) + } + + style.addLayer(anchorCircleLayer) + style.addLayer(anchorPointLayer) + } + + private fun updateAnchorMapLayers(state: AnchorWatchState) { + maplibreMap?.getStyle { style -> + if (state.isActive && state.anchorLocation != null) { + // Update anchor point + val anchorPoint = Point.fromLngLat(state.anchorLocation.longitude, state.anchorLocation.latitude) + anchorPointSource?.setGeoJson(Feature.fromGeometry(anchorPoint)) + + // Update watch circle + val watchCirclePolygon = createWatchCirclePolygon(anchorPoint, state.watchCircleRadiusMeters) + anchorCircleSource?.setGeoJson(Feature.fromGeometry(watchCirclePolygon)) + + // Set layer visibility to visible + style.getLayer(ANCHOR_POINT_LAYER_ID)?.setProperties(PropertyFactory.visibility(PropertyFactory.visibility(PropertyFactory.VISIBLE))) + style.getLayer(ANCHOR_CIRCLE_LAYER_ID)?.setProperties(PropertyFactory.visibility(PropertyFactory.visibility(PropertyFactory.VISIBLE))) + } else { + // Clear sources and hide layers + anchorPointSource?.setGeoJson(FeatureCollection.fromFeatures(emptyList())) + anchorCircleSource?.setGeoJson(FeatureCollection.fromFeatures(emptyList())) + style.getLayer(ANCHOR_POINT_LAYER_ID)?.setProperties(PropertyFactory.visibility(PropertyFactory.visibility(PropertyFactory.NONE))) + style.getLayer(ANCHOR_CIRCLE_LAYER_ID)?.setProperties(PropertyFactory.visibility(PropertyFactory.visibility(PropertyFactory.NONE))) + } + } + } + + // Helper function to create a GeoJSON Polygon for a circle + private fun createWatchCirclePolygon(center: Point, radiusMeters: Double, steps: Int = 64): Polygon { + val coordinates = mutableListOf<Point>() + val earthRadius = 6371000.0 // Earth's radius in meters + + for (i in 0..steps) { + val angle = 2 * Math.PI * i / steps + val lat = center.latitude() + (radiusMeters / earthRadius) * (180 / Math.PI) * cos(angle) + val lon = center.longitude() + (radiusMeters / earthRadius) * (180 / Math.PI) * sin(angle) / cos(toRadians(center.latitude())) + coordinates.add(Point.fromLngLat(lon, lat)) + } + return Polygon.fromLngLats(listOf(coordinates)) + } + private fun observeLocationUpdates() { lifecycleScope.launch { locationService.getLocationUpdates().distinctUntilChanged().collect { gpsData -> @@ -187,6 +447,51 @@ class MainActivity : AppCompatActivity() { } } + private fun observeAnchorWatchState() { + lifecycleScope.launch { + locationService.anchorWatchState.collect { state -> + withContext(Dispatchers.Main) { + updateAnchorMapLayers(state) // Update map layers + if (state.isActive && state.anchorLocation != null) { + currentWatchCircleRadius = state.watchCircleRadiusMeters + anchorRadiusText.text = String.format(Locale.getDefault(), "Radius: %.1fm", currentWatchCircleRadius) + + locationService.fusedLocationClient.lastLocation.await()?.let { currentLocation -> + val distance = state.anchorLocation.distanceTo(currentLocation) + val distanceDiff = distance - state.watchCircleRadiusMeters + if (distanceDiff > 0) { + anchorStatusText.text = String.format( + Locale.getDefault(), + getString(R.string.anchor_active_dragging_format), + state.anchorLocation.latitude, + state.anchorLocation.longitude, + state.watchCircleRadiusMeters, + distance, + distanceDiff + ) + anchorStatusText.setTextColor(ContextCompat.getColor(this@MainActivity, R.color.instrument_text_alarm)) + } else { + anchorStatusText.text = String.format( + Locale.getDefault(), + getString(R.string.anchor_active_format), + state.anchorLocation.latitude, + state.anchorLocation.longitude, + state.watchCircleRadiusMeters, + distance, + -distanceDiff // distance FROM limit + ) + anchorStatusText.setTextColor(ContextCompat.getColor(this@MainActivity, R.color.instrument_text_normal)) + } + } + } else { + anchorStatusText.text = getString(R.string.anchor_inactive) + anchorStatusText.setTextColor(ContextCompat.getColor(this@MainActivity, R.color.instrument_text_normal)) + } + } + } + } + } + private fun activateMob() { if (::locationService.isInitialized) { CoroutineScope(Dispatchers.Main).launch { @@ -207,8 +512,11 @@ class MainActivity : AppCompatActivity() { instrumentDisplayContainer.visibility = View.GONE fabToggleInstruments.visibility = View.GONE fabMob.visibility = View.GONE + anchorConfigContainer.visibility = View.GONE // Hide anchor config + fabAnchor.visibility = View.GONE // Hide anchor FAB mobNavigationContainer.visibility = View.VISIBLE + // Sound continuous alarm mobMediaPlayer = MediaPlayer.create(this@MainActivity, R.raw.mob_alarm).apply { isLooping = true @@ -242,6 +550,8 @@ class MainActivity : AppCompatActivity() { // instrumentDisplayContainer visibility is controlled by fabToggleInstruments, so leave as is fabToggleInstruments.visibility = View.VISIBLE fabMob.visibility = View.VISIBLE + fabAnchor.visibility = View.VISIBLE // Show anchor FAB + anchorConfigContainer.visibility = View.GONE // Hide anchor config Toast.makeText(this, "MOB Recovery initiated.", Toast.LENGTH_SHORT).show() Log.d("MainActivity", "MOB Recovery initiated.") @@ -324,4 +634,4 @@ class MainActivity : AppCompatActivity() { mapView?.onDestroy() mobMediaPlayer?.release() // Ensure media player is released on destroy } -} +}
\ No newline at end of file diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/PolarData.kt b/android-app/app/src/main/kotlin/com/example/androidapp/PolarData.kt new file mode 100644 index 0000000..395b80f --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/PolarData.kt @@ -0,0 +1,229 @@ +package com.example.androidapp + +import kotlin.math.abs +import kotlin.math.cos +import kotlin.math.max +import kotlin.math.min +import kotlin.math.toRadians + +// Represents a single point on a polar curve: True Wind Angle and target Boat Speed +data class PolarPoint(val tWa: Double, val bSp: Double) + +// Represents a polar curve for a specific True Wind Speed +data class PolarCurve(val twS: Double, val points: List<PolarPoint>) { + init { + // Ensure points are sorted by TWA for correct interpolation + require(points.sortedBy { it.tWa } == points) { + "PolarPoints in a PolarCurve must be sorted by TWA." + } + } + + /** + * Interpolates the target Boat Speed (BSP) for a given True Wind Angle (TWA) + * within this specific polar curve (constant TWS). + * Uses linear interpolation. + * + * @param tWa The True Wind Angle in degrees. + * @return The interpolated Boat Speed (BSP) in knots, or 0.0 if outside the defined TWA range. + */ + fun interpolateBspForTwa(tWa: Double): Double { + if (points.isEmpty()) return 0.0 + if (tWa < points.first().tWa || tWa > points.last().tWa) { + // Extrapolate linearly if outside of range to avoid returning 0.0, + // or clamp to nearest value. For now, clamp to nearest. + return when { + tWa < points.first().tWa -> points.first().bSp + tWa > points.last().tWa -> points.last().bSp + else -> 0.0 // Should not happen with above checks + } + } + + // Find the two points that bracket the given TWA + val p2 = points.firstOrNull { it.tWa >= tWa } ?: return 0.0 + val p1 = points.lastOrNull { it.tWa < tWa } ?: return p2.bSp // If tWa is less than first point, return first point's BSP + + if (p1.tWa == p2.tWa) return p1.bSp // Should only happen if tWa exactly matches a point or only one point exists + + // Linear interpolation: BSP = BSP1 + (TWA - TWA1) * (BSP2 - BSP1) / (TWA2 - TWA1) + return p1.bSp + (tWa - p1.tWa) * (p2.bSp - p1.bSp) / (p2.tWa - p1.tWa) + } + + /** + * Calculates the Velocity Made Good (VMG) for a given TWA and BSP. + * VMG = BSP * cos(TWA) when TWA is relative to the wind (0=upwind, 180=downwind). + * In this context, TWA is the angle off the wind, so abs(TWA - 180) for downwind, abs(TWA) for upwind + * For optimal VMG calculations, we consider the angle to the wind direction. + * We'll use the absolute TWA for simplicity assuming the diagram shows absolute TWA off the wind axis. + */ + fun calculateVmg(tWa: Double, bSp: Double): Double { + // TWA is in degrees, convert to radians. + // VMG is the component of speed in the direction of the wind (or directly opposite). + // For upwind, smaller TWA means more directly into the wind, so VMG = BSP * cos(TWA) + // For downwind, TWA closer to 180 means more directly downwind, so VMG = BSP * cos(180 - TWA) + // Given that TWA in polars is usually 0-180 degrees (one side of the boat), + // we can simplify by taking the cosine of the angle to 0 or 180. + // For upwind VMG, we want to maximize BSP * cos(TWA). + // For downwind VMG, we want to maximize BSP * cos(abs(TWA - 180)). + val angleToWind = if (tWa <= 90) tWa else (180 - tWa) + return bSp * cos(toRadians(angleToWind)) + } + + /** + * Finds the TWA that yields the maximum upwind VMG for this polar curve. + */ + fun findOptimalUpwindTwa(): Double { + if (points.isEmpty()) return 0.0 + var maxVmg = -Double.MAX_VALUE + var optimalTwa = 0.0 + + // Iterate through small angle increments for better precision + // Consider angles typically used for upwind sailing (e.g., 20 to 50 degrees) + for (twaDeg in 20..50) { // Typical upwind range + val bsp = interpolateBspForTwa(twaDeg.toDouble()) + val vmg = calculateVmg(twaDeg.toDouble(), bsp) + if (vmg > maxVmg) { + maxVmg = vmg + optimalTwa = twaDeg.toDouble() + } + } + return optimalTwa + } + + /** + * Finds the TWA that yields the maximum downwind VMG for this polar curve. + */ + fun findOptimalDownwindTwa(): Double { + if (points.isEmpty()) return 0.0 + var maxVmg = -Double.MAX_VALUE + var optimalTwa = 0.0 + + // Iterate through small angle increments for better precision + // Consider angles typically used for downwind sailing (e.g., 130 to 170 degrees) + for (twaDeg in 130..170) { // Typical downwind range + val bsp = interpolateBspForTwa(twaDeg.toDouble()) + val vmg = calculateVmg(twaDeg.toDouble(), bsp) + if (vmg > maxVmg) { + maxVmg = vmg + optimalTwa = twaDeg.toDouble() + } + } + return optimalTwa + } +} + +// Represents the complete polar table for a boat, containing multiple PolarCurves for different TWS +data class PolarTable(val curves: List<PolarCurve>) { + init { + // Ensure curves are sorted by TWS for correct interpolation + require(curves.sortedBy { it.twS } == curves) { + "PolarCurves in a PolarTable must be sorted by TWS." + } + } + + /** + * Interpolates the target Boat Speed (BSP) for a given True Wind Speed (TWS) + * and True Wind Angle (TWA) using bi-linear interpolation. + * + * @param twS The True Wind Speed in knots. + * @param tWa The True Wind Angle in degrees. + * @return The interpolated Boat Speed (BSP) in knots, or 0.0 if outside defined ranges. + */ + fun interpolateBsp(twS: Double, tWa: Double): Double { + if (curves.isEmpty()) return 0.0 + + val twsCurves = curves.filter { curve -> + curve.points.any { it.tWa >= tWa } && curve.points.any { it.tWa <= tWa } + } + + if (twsCurves.isEmpty()) return 0.0 + + // Find the two curves that bracket the given TWS + val curve2 = twsCurves.firstOrNull { it.twS >= twS } + val curve1 = twsCurves.lastOrNull { it.twS < twS } + + return when { + curve1 == null && curve2 != null -> curve2.interpolateBspForTwa(tWa) // Below first TWS, use first curve + curve1 != null && curve2 == null -> curve1.interpolateBspForTwa(tWa) // Above last TWS, use last curve + curve1 != null && curve2 != null && curve1.twS == curve2.twS -> curve1.interpolateBspForTwa(tWa) // Exact TWS match or only one curve available + curve1 != null && curve2 != null -> { + // Bi-linear interpolation + val bsp1 = curve1.interpolateBspForTwa(tWa) + val bsp2 = curve2.interpolateBspForTwa(tWa) + + // BSP = BSP1 + (TWS - TWS1) * (BSP2 - BSP1) / (TWS2 - TWS1) + bsp1 + (twS - curve1.twS) * (bsp2 - bsp1) / (curve2.twS - curve1.twS) + } + else -> 0.0 // No suitable curves found + } + } + + /** + * Calculates the "Polar Percentage" for current boat performance. + * This is (current_BSP / target_BSP) * 100. + * + * @param currentTwS Current True Wind Speed. + * @param currentTwa Current True Wind Angle. + * @param currentBsp Current Boat Speed. + * @return Polar percentage, or 0.0 if target BSP cannot be determined. + */ + fun calculatePolarPercentage(currentTwS: Double, currentTwa: Double, currentBsp: Double): Double { + val targetBsp = interpolateBsp(currentTwS, currentTwa) + return if (targetBsp > 0.1) { // Avoid division by zero or near-zero target + (currentBsp / targetBsp) * 100.0 + } else { + 0.0 + } + } + + /** + * Finds the TWA that yields the maximum upwind VMG for a given TWS. + */ + fun findOptimalUpwindTwa(twS: Double): Double { + val twsCurves = curves.filter { curve -> + curve.points.isNotEmpty() + } + if (twsCurves.isEmpty()) return 0.0 + + val curve2 = twsCurves.firstOrNull { it.twS >= twS } + val curve1 = twsCurves.lastOrNull { it.twS < twS } + + return when { + curve1 == null && curve2 != null -> curve2.findOptimalUpwindTwa() + curve1 != null && curve2 == null -> curve1.findOptimalUpwindTwa() + curve1 != null && curve2 != null && curve1.twS == curve2.twS -> curve1.findOptimalUpwindTwa() + curve1 != null && curve2 != null -> { + // Interpolate optimal TWA + val optTwa1 = curve1.findOptimalUpwindTwa() + val optTwa2 = curve2.findOptimalUpwindTwa() + optTwa1 + (twS - curve1.twS) * (optTwa2 - optTwa1) / (curve2.twS - curve1.twS) + } + else -> 0.0 + } + } + + /** + * Finds the TWA that yields the maximum downwind VMG for a given TWS. + */ + fun findOptimalDownwindTwa(twS: Double): Double { + val twsCurves = curves.filter { curve -> + curve.points.isNotEmpty() + } + if (twsCurves.isEmpty()) return 0.0 + + val curve2 = twsCurves.firstOrNull { it.twS >= twS } + val curve1 = twsCurves.lastOrNull { it.twS < twS } + + return when { + curve1 == null && curve2 != null -> curve2.findOptimalDownwindTwa() + curve1 != null && curve2 == null -> curve1.findOptimalDownwindTwa() + curve1 != null && curve2 != null && curve1.twS == curve2.twS -> curve1.findOptimalDownwindTwa() + curve1 != null && curve2 != null -> { + // Interpolate optimal TWA + val optTwa1 = curve1.findOptimalDownwindTwa() + val optTwa2 = curve2.findOptimalDownwindTwa() + optTwa1 + (twS - curve1.twS) * (optTwa2 - optTwa1) / (curve2.twS - curve1.twS) + } + else -> 0.0 + } + } +} diff --git a/android-app/app/src/main/kotlin/com/example/androidapp/PolarDiagramView.kt b/android-app/app/src/main/kotlin/com/example/androidapp/PolarDiagramView.kt new file mode 100644 index 0000000..36e7071 --- /dev/null +++ b/android-app/app/src/main/kotlin/com/example/androidapp/PolarDiagramView.kt @@ -0,0 +1,403 @@ +package com.example.androidapp + +import android.content.Context +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.Paint +import android.graphics.RectF +import android.util.AttributeSet +import android.view.View +import kotlin.math.cos +import kotlin.math.min +import kotlin.math.sin +import kotlin.math.toRadians + +class PolarDiagramView @JvmOverloads constructor( + context: Context, + attrs: AttributeSet? = null, + defStyleAttr: Int = 0 +) : View(context, attrs, defStyleAttr) { + + private val gridPaint = Paint().apply { + color = Color.parseColor("#404040") // Dark gray for grid lines + style = Paint.Style.STROKE + strokeWidth = 1f + isAntiAlias = true + } + + private val textPaint = Paint().apply { + color = Color.WHITE + textSize = 24f + isAntiAlias = true + textAlign = Paint.Align.CENTER + } + + private val polarCurvePaint = Paint().apply { + color = Color.CYAN // Bright color for the polar curve + style = Paint.Style.STROKE + strokeWidth = 3f + isAntiAlias = true + } + + private val currentPerformancePaint = Paint().apply { + color = Color.RED // Red dot for current performance + style = Paint.Style.FILL + isAntiAlias = true + } + + private val noSailZonePaint = Paint().apply { + color = Color.parseColor("#80FF0000") // Semi-transparent red for no-sail zone + style = Paint.Style.FILL + isAntiAlias = true + } + + private val optimalVmgPaint = Paint().apply { + color = Color.GREEN // Green for optimal VMG angles + style = Paint.Style.STROKE + strokeWidth = 4f + isAntiAlias = true + } + + private var viewCenterX: Float = 0f + private var viewCenterY: Float = 0f + private var radius: Float = 0f + + // Data for rendering + private var polarTable: PolarTable? = null + private var currentTws: Double = 0.0 + private var currentTwa: Double = 0.0 + private var currentBsp: Double = 0.0 + + // Configuration for the diagram + private val maxSpeedKnots = 10.0 // Max speed for the outermost circle in knots + private val speedCircleInterval = 2.0 // Interval between speed circles in knots + private val twaInterval = 30 // Interval between TWA radial lines in degrees + private val noSailZoneAngle = 20.0 // Angle +/- from 0 degrees for no-sail zone + + override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) { + super.onSizeChanged(w, h, oldw, oldh) + viewCenterX = w / 2f + viewCenterY = h / 2f + radius = min(w, h) / 2f * 0.9f // Use 90% of the minimum dimension for radius + } + + override fun onDraw(canvas: Canvas) { + super.onDraw(canvas) + + // Draw basic diagram elements + drawGrid(canvas) + drawTwaLabels(canvas) + drawNoSailZone(canvas) + + // Draw polar curve if data is available + polarTable?.let { + drawPolarCurve(canvas, it, currentTws) + drawOptimalVmgAngles(canvas, it, currentTws) // Draw optimal VMG angles + } + + // Draw current performance if data is available and not zero + if (currentTws > 0 && currentTwa > 0 && currentBsp > 0) { + drawCurrentPerformance(canvas, currentTwa, currentBsp) + } + } + + private fun drawGrid(canvas: Canvas) { + // Draw TWA radial lines (0 to 360 degrees) + for (i in 0 until 360 step twaInterval) { + val angleRad = toRadians(i.toDouble()) + val x = viewCenterX + radius * cos(angleRad).toFloat() + val y = viewCenterY + radius * sin(angleRad).toFloat() + canvas.drawLine(viewCenterX, viewCenterY, x, y, gridPaint) + } + + // Draw speed circles + for (i in 0..maxSpeedKnots.toInt() step speedCircleInterval.toInt()) { + val currentRadius = (i / maxSpeedKnots * radius).toFloat() + canvas.drawCircle(viewCenterX, viewCenterY, currentRadius, gridPaint) + } + } + + private fun drawTwaLabels(canvas: Canvas) { + // Draw TWA labels around the perimeter + for (i in 0 until 360 step twaInterval) { + val displayAngleRad = toRadians(i.toDouble()) + // Position the text slightly outside the outermost circle + val textX = viewCenterX + (radius + 40) * cos(displayAngleRad).toFloat() + // Adjust textY to account for text height, so it's centered vertically on the arc + val textY = viewCenterY + (radius + 40) * sin(displayAngleRad).toFloat() + (textPaint.textSize / 3) + + // Map canvas angle (0=right, 90=down) to polar diagram angle (0=up, 90=right) + // Example: canvas 270 is polar 0, canvas 0 is polar 90, canvas 90 is polar 180, canvas 180 is polar 270 + val polarAngle = ( (i + 90) % 360 ) + canvas.drawText(polarAngle.toString(), textX, textY, textPaint) + } + + // Draw speed labels on the horizontal axis + for (i in 0..maxSpeedKnots.toInt() step speedCircleInterval.toInt()) { + if (i > 0) { + val currentRadius = (i / maxSpeedKnots * radius).toFloat() + // Left side + canvas.drawText(i.toString(), viewCenterX - currentRadius - 10, viewCenterY + (textPaint.textSize / 3), textPaint) + // Right side + canvas.drawText(i.toString(), viewCenterX + currentRadius + 10, viewCenterY + (textPaint.textSize / 3), textPaint) + } + } + } + + private fun drawNoSailZone(canvas: Canvas) { + // The no-sail zone is typically symmetric around the wind direction (0 TWA, which is 'up' on our diagram) + // In canvas coordinates, 'up' is -90 degrees or 270 degrees. + // So the arc will be centered around 270 degrees. + val startAngle = (270 - noSailZoneAngle).toFloat() + val sweepAngle = (2 * noSailZoneAngle).toFloat() + + val oval = RectF(viewCenterX - radius, viewCenterY - radius, viewCenterX + radius, viewCenterY + radius) + canvas.drawArc(oval, startAngle, sweepAngle, true, noSailZonePaint) + } + + + private fun drawPolarCurve(canvas: Canvas, polarTable: PolarTable, tws: Double) { + val path = android.graphics.Path() + var firstPoint = true + + // Iterate TWA from 0 to 180 for one side, and then mirror it for the other side. + // TWA 0 is upwind (canvas 270 deg) + // TWA 90 is beam (canvas 0/360 or 180 deg) + // TWA 180 is downwind (canvas 90 deg) + + // Generate points for 0 to 180 TWA (starboard side) + for (twa in 0..180) { + val bsp = polarTable.interpolateBsp(tws, twa.toDouble()) + if (bsp > 0) { + // Map TWA to canvas angle for the starboard side (0 TWA at 270, 90 TWA at 0, 180 TWA at 90) + val canvasAngle = (270 + twa).toDouble() % 360 + val currentRadius = (bsp / maxSpeedKnots * radius).toFloat() + val x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + val y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + + if (firstPoint) { + path.moveTo(x, y) + firstPoint = false + } else { + path.lineTo(x, y) + } + } + } + + // Generate points for 0 to -180 TWA (port side) by mirroring + // Start from 180 back to 0 to connect the curve + for (twa in 180 downTo 0) { + val bsp = polarTable.interpolateBsp(tws, twa.toDouble()) + if (bsp > 0) { + // Map negative TWA to canvas angle for the port side (0 TWA at 270, -90 TWA at 180, -180 TWA at 90) + val canvasAngle = (270 - twa).toDouble() // This maps TWA 0 to 270, TWA 90 to 180, TWA 180 to 90 + val currentRadius = (bsp / maxSpeedKnots * radius).toFloat() + val x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + val y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + + path.lineTo(x, y) // Continue drawing the path + } + } + canvas.drawPath(path, polarCurvePaint) + } + + + private fun drawCurrentPerformance(canvas: Canvas, twa: Double, bsp: Double) { + // Map TWA to canvas angle. + // Assuming TWA is provided as 0-180 (absolute angle off wind). + // If actual TWA (e.g., -30, 30) is passed, adjust accordingly. + // For drawing, we need a full 0-360 angle to represent actual boat heading relative to wind. + // Let's assume positive TWA is starboard and negative TWA is port. + val canvasAngle = if (twa >= 0) { + (270 + twa).toDouble() % 360 // Starboard side + } else { + (270 + twa).toDouble() // Port side (e.g., -30 TWA is 240 canvas angle) + } + + val currentRadius = (bsp / maxSpeedKnots * radius).toFloat() + val x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + val y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + + canvas.drawCircle(x, y, 10f, currentPerformancePaint) // Draw a small circle for current performance + } + + private fun drawOptimalVmgAngles(canvas: Canvas, polarTable: PolarTable, tws: Double) { + // Find optimal upwind TWA + val optimalUpwindTwa = polarTable.findOptimalUpwindTwa(tws) + if (optimalUpwindTwa > 0) { + // Draw a line indicating the optimal upwind TWA (both port and starboard) + val upwindBsp = polarTable.interpolateBsp(tws, optimalUpwindTwa) + val currentRadius = (upwindBsp / maxSpeedKnots * radius).toFloat() * 1.05f // Slightly longer + + // Starboard side + var canvasAngle = (270 + optimalUpwindTwa).toDouble() % 360 + var x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + var y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + canvas.drawLine(viewCenterX, viewCenterY, x, y, optimalVmgPaint) + + // Port side + canvasAngle = (270 - optimalUpwindTwa).toDouble() // Use negative TWA for port side + x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + canvas.drawLine(viewCenterX, viewCenterY, x, y, optimalVmgPaint) + } + + // Find optimal downwind TWA + val optimalDownwindTwa = polarTable.findOptimalDownwindTwa(tws) + if (optimalDownwindTwa > 0) { + // Draw a line indicating the optimal downwind TWA (both port and starboard) + val downwindBsp = polarTable.interpolateBsp(tws, optimalDownwindTwa) + val currentRadius = (downwindBsp / maxSpeedKnots * radius).toFloat() * 1.05f // Slightly longer + + // Starboard side + var canvasAngle = (270 + optimalDownwindTwa).toDouble() % 360 + var x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + var y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + canvas.drawLine(viewCenterX, viewCenterY, x, y, optimalVmgPaint) + + // Port side + canvasAngle = (270 - optimalDownwindTwa).toDouble() // Use negative TWA for port side + x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + canvas.drawLine(viewCenterX, viewCenterY, x, y, optimalVmgPaint) + } + } + + private fun drawGrid(canvas: Canvas) { + // Draw TWA radial lines (0 to 360 degrees) + for (i in 0 until 360 step twaInterval) { + val angleRad = toRadians(i.toDouble()) + val x = viewCenterX + radius * cos(angleRad).toFloat() + val y = viewCenterY + radius * sin(angleRad).toFloat() + canvas.drawLine(viewCenterX, viewCenterY, x, y, gridPaint) + } + + // Draw speed circles + for (i in 0..maxSpeedKnots.toInt() step speedCircleInterval.toInt()) { + val currentRadius = (i / maxSpeedKnots * radius).toFloat() + canvas.drawCircle(viewCenterX, viewCenterY, currentRadius, gridPaint) + } + } + + private fun drawTwaLabels(canvas: Canvas) { + // Draw TWA labels around the perimeter + for (i in 0 until 360 step twaInterval) { + val displayAngleRad = toRadians(i.toDouble()) + // Position the text slightly outside the outermost circle + val textX = viewCenterX + (radius + 40) * cos(displayAngleRad).toFloat() + // Adjust textY to account for text height, so it's centered vertically on the arc + val textY = viewCenterY + (radius + 40) * sin(displayAngleRad).toFloat() + (textPaint.textSize / 3) + + // Map canvas angle (0=right, 90=down) to polar diagram angle (0=up, 90=right) + // Example: canvas 270 is polar 0, canvas 0 is polar 90, canvas 90 is polar 180, canvas 180 is polar 270 + val polarAngle = ( (i + 90) % 360 ) + canvas.drawText(polarAngle.toString(), textX, textY, textPaint) + } + + // Draw speed labels on the horizontal axis + for (i in 0..maxSpeedKnots.toInt() step speedCircleInterval.toInt()) { + if (i > 0) { + val currentRadius = (i / maxSpeedKnots * radius).toFloat() + // Left side + canvas.drawText(i.toString(), viewCenterX - currentRadius - 10, viewCenterY + (textPaint.textSize / 3), textPaint) + // Right side + canvas.drawText(i.toString(), viewCenterX + currentRadius + 10, viewCenterY + (textPaint.textSize / 3), textPaint) + } + } + } + + private fun drawNoSailZone(canvas: Canvas) { + // The no-sail zone is typically symmetric around the wind direction (0 TWA, which is 'up' on our diagram) + // In canvas coordinates, 'up' is -90 degrees or 270 degrees. + // So the arc will be centered around 270 degrees. + val startAngle = (270 - noSailZoneAngle).toFloat() + val sweepAngle = (2 * noSailZoneAngle).toFloat() + + val oval = RectF(viewCenterX - radius, viewCenterY - radius, viewCenterX + radius, viewCenterY + radius) + canvas.drawArc(oval, startAngle, sweepAngle, true, noSailZonePaint) + } + + + private fun drawPolarCurve(canvas: Canvas, polarTable: PolarTable, tws: Double) { + val path = android.graphics.Path() + var firstPoint = true + + // Iterate TWA from 0 to 180 for one side, and then mirror it for the other side. + // TWA 0 is upwind (canvas 270 deg) + // TWA 90 is beam (canvas 0/360 or 180 deg) + // TWA 180 is downwind (canvas 90 deg) + + // Generate points for 0 to 180 TWA (starboard side) + for (twa in 0..180) { + val bsp = polarTable.interpolateBsp(tws, twa.toDouble()) + if (bsp > 0) { + // Map TWA to canvas angle for the starboard side (0 TWA at 270, 90 TWA at 0, 180 TWA at 90) + val canvasAngle = (270 + twa).toDouble() % 360 + val currentRadius = (bsp / maxSpeedKnots * radius).toFloat() + val x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + val y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + + if (firstPoint) { + path.moveTo(x, y) + firstPoint = false + } else { + path.lineTo(x, y) + } + } + } + + // Generate points for 0 to -180 TWA (port side) by mirroring + // Start from 180 back to 0 to connect the curve + for (twa in 180 downTo 0) { + val bsp = polarTable.interpolateBsp(tws, twa.toDouble()) + if (bsp > 0) { + // Map negative TWA to canvas angle for the port side (0 TWA at 270, -90 TWA at 180, -180 TWA at 90) + val canvasAngle = (270 - twa).toDouble() // This maps TWA 0 to 270, TWA 90 to 180, TWA 180 to 90 + val currentRadius = (bsp / maxSpeedKnots * radius).toFloat() + val x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + val y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + + path.lineTo(x, y) // Continue drawing the path + } + } + canvas.drawPath(path, polarCurvePaint) + } + + + private fun drawCurrentPerformance(canvas: Canvas, twa: Double, bsp: Double) { + // Map TWA to canvas angle. + // Assuming TWA is provided as 0-180 (absolute angle off wind). + // If actual TWA (e.g., -30, 30) is passed, adjust accordingly. + // For drawing, we need a full 0-360 angle to represent actual boat heading relative to wind. + // Let's assume positive TWA is starboard and negative TWA is port. + val canvasAngle = if (twa >= 0) { + (270 + twa).toDouble() % 360 // Starboard side + } else { + (270 + twa).toDouble() // Port side (e.g., -30 TWA is 240 canvas angle) + } + + val currentRadius = (bsp / maxSpeedKnots * radius).toFloat() + val x = viewCenterX + currentRadius * cos(toRadians(canvasAngle)).toFloat() + val y = viewCenterY + currentRadius * sin(toRadians(canvasAngle)).toFloat() + + canvas.drawCircle(x, y, 10f, currentPerformancePaint) // Draw a small circle for current performance + } + + /** + * Sets the polar table data for the view. + */ + fun setPolarTable(table: PolarTable) { + this.polarTable = table + invalidate() // Redraw the view + } + + /** + * Sets the current true wind speed, true wind angle, and boat speed. + */ + fun setCurrentPerformance(tws: Double, twa: Double, bsp: Double) { + this.currentTws = tws + this.currentTwa = twa + this.currentBsp = bsp + invalidate() // Redraw the view + } +} diff --git a/android-app/app/src/main/res/layout/activity_main.xml b/android-app/app/src/main/res/layout/activity_main.xml index 3df0645..4f38772 100644 --- a/android-app/app/src/main/res/layout/activity_main.xml +++ b/android-app/app/src/main/res/layout/activity_main.xml @@ -209,23 +209,18 @@ app:layout_constraintEnd_toStartOf="@+id/guideline_vertical_66" app:layout_constraintHorizontal_bias="0.5" /> - <!-- Polar % Instrument --> - <TextView - android:id="@+id/label_polar_pct" - style="@style/InstrumentLabel" - android:text="@string/instrument_label_polar_pct" - app:layout_constraintStart_toStartOf="@+id/guideline_vertical_66" - app:layout_constraintTop_toTopOf="@+id/guideline_horizontal_50" - app:layout_constraintEnd_toEndOf="parent" - app:layout_constraintHorizontal_bias="0.5" /> - <TextView - android:id="@+id/value_polar_pct" - style="@style/InstrumentPrimaryValue" - tools:text="---" - app:layout_constraintStart_toStartOf="@+id/guideline_vertical_66" - app:layout_constraintTop_toBottomOf="@+id/label_polar_pct" + <!-- Polar Diagram View --> + <com.example.androidapp.PolarDiagramView + android:id="@+id/polar_diagram_view" + android:layout_width="0dp" + android:layout_height="0dp" + android:layout_margin="16dp" + app:layout_constraintDimensionRatio="1:1" + app:layout_constraintStart_toStartOf="parent" app:layout_constraintEnd_toEndOf="parent" - app:layout_constraintHorizontal_bias="0.5" /> + app:layout_constraintTop_toBottomOf="@+id/label_vmg" + app:layout_constraintBottom_toBottomOf="parent" + /> </androidx.constraintlayout.widget.ConstraintLayout> |