map: fix survey transect connector detouring to polygon corner

With no turnaround distance, consecutive transects were joined by walking
the polygon ring in fixed vertex order, which always inserted the next
corner between lines and sent the vehicle out to a far corner and back
before resuming the correct line. moveAlongEdge now returns only the ring
vertices between the two boundary points along the shorter direction, and
none when they share an edge, so connectors become direct hops that stay
inside the survey area.

Author: ArturoManzoli

src/libs/map/utils-map.ts

@@ -1,5 +1,5 @@
 import * as turf from '@turf/turf'
-import type { Feature, Polygon } from 'geojson'
+import type { Feature, Point, Polygon, Position } from 'geojson'
 import * as L from 'leaflet'
 
 import { bearingBetween, calculateHaversineDistance, deltaBearing } from '@/libs/mission/general-estimates'
@@ -381,7 +381,7 @@ export const generateSurveyPath = (
 
         if (continuousPath.length > 0 && turnaroundDistance === 0) {
           const lastPoint = continuousPath[continuousPath.length - 1]
-          const edgePath = moveAlongEdge(poly, lastPoint, linePoints[0], diagonal)
+          const edgePath = moveAlongEdge(poly, lastPoint, linePoints[0])
           continuousPath.push(...edgePath)
         }
 
@@ -421,50 +421,65 @@ export const generateSurveyPath = (
 }
 
 /**
- * Moves along the edge of a polygon from start to end point.
- * @param {Feature<Polygon>} polygon - The polygon to move along.
+ * Finds the index of the polygon ring edge (the segment from coords[i] to coords[i + 1]) that a point lies on.
+ * @param {Feature<Point>} point - The point to locate.
+ * @param {Position[]} coords - The polygon ring coordinates (closed, first equals last).
+ * @returns {number} The edge index, or -1 if the point does not lie on any edge.
+ */
+const findRingEdgeIndex = (point: Feature<Point>, coords: Position[]): number => {
+  for (let i = 0; i < coords.length - 1; i++) {
+    // Small epsilon so floating-point drift on clipped boundary points still matches their edge.
+    if (turf.booleanPointOnLine(point, turf.lineString([coords[i], coords[i + 1]]), { epsilon: 1e-6 })) return i
+  }
+  return -1
+}
+
+/**
+ * Total length of the path start -> vertices -> end, in kilometers.
  * @param {L.LatLng} start - The starting point.
+ * @param {Position[]} vertices - The intermediate ring vertices.
  * @param {L.LatLng} end - The ending point.
- * @param {number} maxDistance - The maximum distance to move.
- * @returns {L.LatLng[]} The path along the edge.
+ * @returns {number} The path length, in kilometers.
  */
-export const moveAlongEdge = (
-  polygon: Feature<Polygon>,
-  start: L.LatLng,
-  end: L.LatLng,
-  maxDistance: number
-): L.LatLng[] => {
+const pathLengthThroughVertices = (start: L.LatLng, vertices: Position[], end: L.LatLng): number =>
+  turf.length(turf.lineString([[start.lng, start.lat], ...vertices, [end.lng, end.lat]]))
+
+/**
+ * Finds the shortest path hugging a polygon's boundary between two points that lie on that boundary, so
+ * consecutive survey transects are connected without overshooting into a far corner.
+ * @param {Feature<Polygon>} polygon - The polygon to move along.
+ * @param {L.LatLng} start - The starting point, expected to lie on the polygon boundary.
+ * @param {L.LatLng} end - The ending point, expected to lie on the polygon boundary.
+ * @returns {L.LatLng[]} The intermediate ring vertices between start and end, in the shorter direction. Empty
+ *   when both points lie on the same edge, so the caller connects them with a direct segment.
+ */
+const moveAlongEdge = (polygon: Feature<Polygon>, start: L.LatLng, end: L.LatLng): L.LatLng[] => {
   const coords = polygon.geometry.coordinates[0]
-  const path: L.LatLng[] = []
-  let remainingDistance = maxDistance
-  let currentPoint = turf.point([start.lng, start.lat])
-
-  for (let i = 0; i < coords.length; i++) {
-    const nextPoint = turf.point(coords[(i + 1) % coords.length])
-    const edgeLine = turf.lineString([coords[i], coords[(i + 1) % coords.length]])
-
-    if (turf.booleanPointOnLine(currentPoint, edgeLine)) {
-      while (remainingDistance > 0) {
-        const distance = turf.distance(currentPoint, nextPoint)
-        if (distance <= remainingDistance) {
-          path.push(L.latLng(nextPoint.geometry.coordinates[1], nextPoint.geometry.coordinates[0]))
-          remainingDistance -= distance
-          currentPoint = nextPoint
-          break
-        } else {
-          const move = turf.along(edgeLine, remainingDistance, { units: 'kilometers' })
-          path.push(L.latLng(move.geometry.coordinates[1], move.geometry.coordinates[0]))
-          break
-        }
-      }
-    }
+  const startEdge = findRingEdgeIndex(turf.point([start.lng, start.lat]), coords)
+  const endEdge = findRingEdgeIndex(turf.point([end.lng, end.lat]), coords)
 
-    if (turf.booleanPointOnLine(turf.point([end.lng, end.lat]), edgeLine)) {
-      break
-    }
+  if (startEdge === -1 || endEdge === -1 || startEdge === endEdge) return []
+
+  const vertexCount = coords.length - 1 // Ring is closed, so the last coordinate duplicates the first.
+
+  const forwardVertices: Position[] = []
+  for (let i = (startEdge + 1) % vertexCount; ; i = (i + 1) % vertexCount) {
+    forwardVertices.push(coords[i])
+    if (i === endEdge) break
   }
 
-  return path
+  const backwardVertices: Position[] = []
+  for (let i = startEdge; ; i = (i - 1 + vertexCount) % vertexCount) {
+    backwardVertices.push(coords[i])
+    if (i === (endEdge + 1) % vertexCount) break
+  }
+
+  const shorterVertices =
+    pathLengthThroughVertices(start, forwardVertices, end) <= pathLengthThroughVertices(start, backwardVertices, end)
+      ? forwardVertices
+      : backwardVertices
+
+  return shorterVertices.map((c) => L.latLng(c[1], c[0]))
 }
 
 /**