@lumikmz/kmz 0.10.0 → 0.11.1

package/src/plan/plan-mapping-strip.ts

@@ -15,9 +15,13 @@ import {
   type EnuPoint,
 } from "./geometry.js";
 import type { PlanOptions } from "./index.js";
+import {
+  measureStripMission,
+  selectStripRouteCandidates,
+  type StripRouteCandidate,
+} from "./strip-route-order.js";
 
 const POINT_EPS_M = 0.05;
-const MITER_LIMIT = 2.5;
 const MAX_ROUTE_COUNT = 1_000;
 const TURN_DAMPING_M = 10;
 
@@ -51,9 +55,11 @@ export interface MappingStripDerived {
   surveyAreaSize: number;
   regions: MappingStripRegion[];
   flightRoutes: MappingStripRegionRoute[];
+  /** Horizontal mission distance, including known ingress and finish travel. */
   totalFlightLength: Meters;
   photoSpacing: Meters;
   estimatedPhotoCount: number;
+  /** Estimated horizontal flying seconds at the configured work/transit speeds. */
   estimatedDuration: number;
 }
 
@@ -81,11 +87,9 @@ interface LocalRouteSegment {
   photoEnabled: boolean;
 }
 
-interface LocalRouteCandidate {
+interface LocalRouteCandidate extends StripRouteCandidate {
   lines: EnuPoint[][];
   segments: LocalRouteSegment[];
-  start: EnuPoint;
-  end: EnuPoint;
 }
 
 interface Triple extends LngLat {
@@ -189,61 +193,18 @@ function localRouteCandidate(
     });
   }
   const executable = joinSegmentPoints(segments);
+  const distinct = cleanLine(executable);
   return {
     lines,
     segments,
     start: executable[0]!,
     end: executable.at(-1)!,
+    entryDirection: segmentUnit(distinct[0]!, distinct[1]!),
+    exitDirection: segmentUnit(distinct.at(-2)!, distinct.at(-1)!),
+    length: lineLength(executable),
   };
 }
 
-function shortestCandidateIndexes(
-  candidateGroups: readonly LocalRouteCandidate[][],
-  startPoint: EnuPoint | undefined,
-): number[] {
-  if (candidateGroups.length === 0) return [];
-  let costs = candidateGroups[0]!.map((candidate) =>
-    startPoint
-      ? Math.hypot(candidate.start[0] - startPoint[0], candidate.start[1] - startPoint[1])
-      : 0,
-  );
-  const previousIndexes: number[][] = [candidateGroups[0]!.map(() => -1)];
-
-  for (let regionIndex = 1; regionIndex < candidateGroups.length; regionIndex++) {
-    const previousCandidates = candidateGroups[regionIndex - 1]!;
-    const candidates = candidateGroups[regionIndex]!;
-    const nextCosts: number[] = [];
-    const nextPreviousIndexes: number[] = [];
-    for (const candidate of candidates) {
-      let bestCost = Number.POSITIVE_INFINITY;
-      let bestPreviousIndex = 0;
-      previousCandidates.forEach((previous, previousIndex) => {
-        const transition = Math.hypot(
-          candidate.start[0] - previous.end[0],
-          candidate.start[1] - previous.end[1],
-        );
-        const cost = costs[previousIndex]! + transition;
-        if (cost < bestCost) {
-          bestCost = cost;
-          bestPreviousIndex = previousIndex;
-        }
-      });
-      nextCosts.push(bestCost);
-      nextPreviousIndexes.push(bestPreviousIndex);
-    }
-    costs = nextCosts;
-    previousIndexes.push(nextPreviousIndexes);
-  }
-
-  let selectedIndex = costs.reduce((best, cost, index) => (cost < costs[best]! ? index : best), 0);
-  const selected = Array.from({ length: candidateGroups.length }, () => 0);
-  for (let regionIndex = candidateGroups.length - 1; regionIndex >= 0; regionIndex--) {
-    selected[regionIndex] = selectedIndex;
-    selectedIndex = previousIndexes[regionIndex]![selectedIndex]!;
-  }
-  return selected;
-}
-
 function joinSegmentPoints<T>(segments: readonly { points: readonly T[] }[]): T[] {
   const result: T[] = [];
   for (const segment of segments) {
@@ -352,7 +313,7 @@ function applyMergedRegionRanges(
 
   const byStart = new Map(normalized.map((range) => [range.start, range]));
   const merged: LocalRegion[] = [];
-  for (let index = 0; index < regions.length; ) {
+  for (let index = 0; index < regions.length;) {
     const range = byStart.get(index);
     if (!range) {
       merged.push(regions[index]!);
@@ -391,57 +352,68 @@ function leftNormal(direction: EnuPoint): EnuPoint {
   return [-direction[1], direction[0]];
 }
 
-function offsetPolyline(points: readonly EnuPoint[], distance: number): EnuPoint[] {
-  if (distance === 0) return points.map((point) => [point[0], point[1]]);
-  const directions = points.slice(1).map((point, index) => segmentUnit(points[index]!, point));
-  const out: EnuPoint[] = [];
-  const firstNormal = leftNormal(directions[0]!);
-  out.push([points[0]![0] + firstNormal[0] * distance, points[0]![1] + firstNormal[1] * distance]);
-
+/** Simplify geometry only; source control points still determine distance cuts. */
+function simplifyStraightRuns(points: readonly EnuPoint[]): EnuPoint[] {
+  const result: EnuPoint[] = [points[0]!];
   for (let index = 1; index < points.length - 1; index++) {
-    const previousDirection = directions[index - 1]!;
-    const nextDirection = directions[index]!;
-    const previousNormal = leftNormal(previousDirection);
-    const nextNormal = leftNormal(nextDirection);
-    const previousOffset: EnuPoint = [
-      points[index]![0] + previousNormal[0] * distance,
-      points[index]![1] + previousNormal[1] * distance,
-    ];
-    const nextOffset: EnuPoint = [
-      points[index]![0] + nextNormal[0] * distance,
-      points[index]![1] + nextNormal[1] * distance,
-    ];
-    const denominator = cross(previousDirection, nextDirection);
-    if (Math.abs(denominator) < 1e-9) {
-      out.push(previousOffset);
+    const incoming = segmentUnit(result.at(-1)!, points[index]!);
+    const outgoing = segmentUnit(points[index]!, points[index + 1]!);
+    if (
+      Math.abs(cross(incoming, outgoing)) < 1e-8 &&
+      incoming[0] * outgoing[0] + incoming[1] * outgoing[1] > 0
+    )
       continue;
-    }
-    const delta: EnuPoint = [nextOffset[0] - previousOffset[0], nextOffset[1] - previousOffset[1]];
-    const t = cross(delta, nextDirection) / denominator;
-    const intersection: EnuPoint = [
-      previousOffset[0] + previousDirection[0] * t,
-      previousOffset[1] + previousDirection[1] * t,
-    ];
-    const miterLength = Math.hypot(
-      intersection[0] - points[index]![0],
-      intersection[1] - points[index]![1],
-    );
-    if (miterLength <= Math.abs(distance) * MITER_LIMIT) out.push(intersection);
-    else out.push(previousOffset, nextOffset);
+    result.push(points[index]!);
   }
+  result.push(points.at(-1)!);
+  return result;
+}
 
-  const lastNormal = leftNormal(directions.at(-1)!);
-  const last = points.at(-1)!;
-  out.push([last[0] + lastNormal[0] * distance, last[1] + lastNormal[1] * distance]);
-  return out;
+/**
+ * FlightHub square joins extend both outer offset edges to a line perpendicular
+ * to their bisector, one offset distance from the source vertex. Inner joins
+ * keep their true intersection: beveling a long inner miter creates a bow tie.
+ */
+function offsetJoint(
+  point: EnuPoint,
+  incoming: EnuPoint,
+  outgoing: EnuPoint,
+  distance: number,
+): EnuPoint[] {
+  const previousNormal = leftNormal(incoming);
+  const nextNormal = leftNormal(outgoing);
+  const previousOffset: EnuPoint = [
+    point[0] + previousNormal[0] * distance,
+    point[1] + previousNormal[1] * distance,
+  ];
+  const nextOffset: EnuPoint = [
+    point[0] + nextNormal[0] * distance,
+    point[1] + nextNormal[1] * distance,
+  ];
+  const denominator = cross(incoming, outgoing);
+  if (Math.abs(denominator) < 1e-9) return [previousOffset];
+
+  if (denominator * distance < 0) {
+    const turn = Math.atan2(denominator, incoming[0] * outgoing[0] + incoming[1] * outgoing[1]);
+    const extension = Math.abs(distance) * Math.tan(Math.abs(turn) / 4);
+    return [
+      [previousOffset[0] + incoming[0] * extension, previousOffset[1] + incoming[1] * extension],
+      [nextOffset[0] - outgoing[0] * extension, nextOffset[1] - outgoing[1] * extension],
+    ];
+  }
+  const delta: EnuPoint = [nextOffset[0] - previousOffset[0], nextOffset[1] - previousOffset[1]];
+  const t = cross(delta, outgoing) / denominator;
+  return [[previousOffset[0] + incoming[0] * t, previousOffset[1] + incoming[1] * t]];
 }
 
-function corridorSide(
+function offsetSide(
   points: readonly EnuPoint[],
   distance: number,
   beforePoint?: EnuPoint,
   afterPoint?: EnuPoint,
 ): EnuPoint[] {
+  if (distance === 0) return points.map((point) => [point[0], point[1]]);
+  points = simplifyStraightRuns(points);
   const out: EnuPoint[] = [];
   for (let index = 0; index < points.length; index++) {
     const point = points[index]!;
@@ -459,41 +431,57 @@ function corridorSide(
     }
     if (!previous || !next) continue;
 
-    const previousDirection = segmentUnit(previous, point);
-    const nextDirection = segmentUnit(point, next);
-    const previousNormal = leftNormal(previousDirection);
-    const nextNormal = leftNormal(nextDirection);
-    const previousOffset: EnuPoint = [
-      point[0] + previousNormal[0] * distance,
-      point[1] + previousNormal[1] * distance,
-    ];
-    const nextOffset: EnuPoint = [
-      point[0] + nextNormal[0] * distance,
-      point[1] + nextNormal[1] * distance,
-    ];
-    const denominator = cross(previousDirection, nextDirection);
-    if (Math.abs(denominator) < 1e-9) {
-      out.push(previousOffset);
-      continue;
-    }
+    const joint = offsetJoint(
+      point,
+      segmentUnit(previous, point),
+      segmentUnit(point, next),
+      distance,
+    );
+    if (joint.length === 2 && (index === 0 || index === points.length - 1)) {
+      // A cut vertex owns only its half of the square join. Both neighboring
+      // regions and their flight lines meet at this exact bisector midpoint.
+      const midpoint: EnuPoint = [
+        (joint[0]![0] + joint[1]![0]) / 2,
+        (joint[0]![1] + joint[1]![1]) / 2,
+      ];
+      out.push(...(index === 0 ? [midpoint, joint[1]!] : [joint[0]!, midpoint]));
+    } else out.push(...joint);
+  }
+  return cleanLine(out);
+}
 
-    // FlightHub uses a bevel on the outside of every bend. The inside remains
-    // a miter intersection so the corridor does not overlap itself at corners.
-    if (denominator * distance < 0) {
-      out.push(previousOffset, nextOffset);
-      continue;
-    }
-    const delta: EnuPoint = [nextOffset[0] - previousOffset[0], nextOffset[1] - previousOffset[1]];
-    const t = cross(delta, nextDirection) / denominator;
-    const intersection: EnuPoint = [
-      previousOffset[0] + previousDirection[0] * t,
-      previousOffset[1] + previousDirection[1] * t,
-    ];
-    const miterLength = Math.hypot(intersection[0] - point[0], intersection[1] - point[1]);
-    if (miterLength <= Math.abs(distance) * MITER_LIMIT) out.push(intersection);
-    else out.push(previousOffset, nextOffset);
+function validateCorridorJoins(points: readonly EnuPoint[], left: number, right: number): void {
+  points = simplifyStraightRuns(points);
+  const directions = points.slice(1).map((point, index) => segmentUnit(points[index]!, point));
+  const leftCuts = points.map(() => 0);
+  const rightCuts = points.map(() => 0);
+  for (let index = 1; index < points.length - 1; index++) {
+    const incoming = directions[index - 1]!;
+    const outgoing = directions[index]!;
+    const dot = incoming[0] * outgoing[0] + incoming[1] * outgoing[1];
+    const turn = Math.atan2(cross(incoming, outgoing), dot);
+    if (Math.PI - Math.abs(turn) < 1e-6)
+      throw new PlannerError("mappingStrip center line reverses direction at a corner");
+    const tangent = Math.tan(Math.abs(turn) / 2);
+    if (turn > 0) leftCuts[index] = left * tangent;
+    else rightCuts[index] = right * tangent;
+  }
+  for (let index = 0; index < directions.length; index++) {
+    const length = Math.hypot(
+      points[index + 1]![0] - points[index]![0],
+      points[index + 1]![1] - points[index]![1],
+    );
+    if (
+      Math.max(
+        leftCuts[index]! + leftCuts[index + 1]!,
+        rightCuts[index]! + rightCuts[index + 1]!,
+      ) >=
+      length - POINT_EPS_M
+    )
+      throw new PlannerError(
+        "mappingStrip corner offsets exceed the available center-line segment",
+      );
   }
-  return out;
 }
 
 function corridorPolygon(
@@ -504,11 +492,96 @@ function corridorPolygon(
   afterPoint?: EnuPoint,
 ): EnuPoint[] {
   return [
-    ...corridorSide(points, left, beforePoint, afterPoint),
-    ...corridorSide(points, -right, beforePoint, afterPoint).reverse(),
+    ...offsetSide(points, left, beforePoint, afterPoint),
+    ...offsetSide(points, -right, beforePoint, afterPoint).reverse(),
   ];
 }
 
+/**
+ * Bisector normal of the joint shared by two regions at a cut vertex. The seam is
+ * the line through the vertex perpendicular to this normal, i.e. the angle
+ * bisector: the incoming region keeps `dot <= 0`, the outgoing region `dot >= 0`.
+ */
+function jointSeamNormal(incoming: EnuPoint, outgoing: EnuPoint): EnuPoint | undefined {
+  const normal: EnuPoint = [incoming[0] + outgoing[0], incoming[1] + outgoing[1]];
+  const length = Math.hypot(normal[0], normal[1]);
+  return length < 1e-9 ? undefined : [normal[0] / length, normal[1] / length];
+}
+
+/** Keep the half-plane `dot(normal, point - origin) <= 0` (Sutherland–Hodgman). */
+function clipHalfPlane(ring: readonly EnuPoint[], origin: EnuPoint, normal: EnuPoint): EnuPoint[] {
+  const signedDistance = (point: EnuPoint) => {
+    const distance = normal[0] * (point[0] - origin[0]) + normal[1] * (point[1] - origin[1]);
+    // Roundoff at vertices already on the seam must not create extra crossings
+    // along the shared edge or remove a neighboring route's joint endpoint.
+    return Math.abs(distance) < 1e-8 ? 0 : distance;
+  };
+  const out: EnuPoint[] = [];
+  const push = (point: EnuPoint) => {
+    const last = out.at(-1);
+    if (last && Math.hypot(point[0] - last[0], point[1] - last[1]) < POINT_EPS_M) return;
+    out.push(point);
+  };
+  for (let index = 0; index < ring.length; index++) {
+    const a = ring[index]!;
+    const b = ring[(index + 1) % ring.length]!;
+    const da = signedDistance(a);
+    const db = signedDistance(b);
+    if (da <= 0) push([a[0], a[1]]);
+    if (da * db < 0) {
+      const t = da / (da - db);
+      push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+    }
+  }
+  while (
+    out.length > 1 &&
+    Math.hypot(out[0]![0] - out.at(-1)![0], out[0]![1] - out.at(-1)![1]) < POINT_EPS_M
+  )
+    out.pop();
+  return out;
+}
+
+/**
+ * Adjacent regions share a cut vertex and each included the full corridor joint
+ * there, so their rings used to overlap at the corner. Cut every shared end
+ * along the bisector seam instead: both rings then tile the corridor edge to
+ * edge while their union (the outer contour) is unchanged. A shorter join is not
+ * enough here — when the path folds back, the two corridor bands cross and the
+ * overlap extends far beyond the corner patch, which only a half-plane cut
+ * removes.
+ */
+function trimJointOverlap(
+  polygon: readonly EnuPoint[],
+  centerLine: readonly EnuPoint[],
+  beforePoint: EnuPoint | undefined,
+  afterPoint: EnuPoint | undefined,
+): EnuPoint[] {
+  // Contextual offset sides already split each end join at its seam. A global
+  // half-plane is only safe for a straight region: on a merged/folded region it
+  // would cut off distant bends lying behind the starting seam (including the
+  // acute corner in docs/wpmz). Straight cuts still need clipping when an inner
+  // miter extends beyond a nearby synthetic distance cut.
+  if (simplifyStraightRuns(centerLine).length > 2) return [...polygon];
+  let trimmed = [...polygon];
+  const first = centerLine[0]!;
+  const last = centerLine.at(-1)!;
+  if (beforePoint) {
+    const normal = jointSeamNormal(
+      segmentUnit(beforePoint, first),
+      segmentUnit(first, centerLine[1]!),
+    );
+    if (normal) trimmed = clipHalfPlane(trimmed, first, [-normal[0], -normal[1]]);
+  }
+  if (afterPoint) {
+    const normal = jointSeamNormal(
+      segmentUnit(centerLine.at(-2)!, last),
+      segmentUnit(last, afterPoint),
+    );
+    if (normal) trimmed = clipHalfPlane(trimmed, last, normal);
+  }
+  return trimmed.length >= 3 ? trimmed : [...polygon];
+}
+
 function perpendicularRouteLines(
   centerLine: readonly EnuPoint[],
   leftExtend: number,
@@ -516,37 +589,49 @@ function perpendicularRouteLines(
   margin: number,
   lineSpacing: number,
 ): EnuPoint[][] {
-  const left = offsetPolyline(centerLine, leftExtend);
-  const right = offsetPolyline(centerLine, -rightExtend);
-  if (left.length !== centerLine.length || right.length !== centerLine.length) {
-    throw new PlannerError("mappingStrip offset corridor cannot be segmented");
-  }
-
+  centerLine = simplifyStraightRuns(centerLine);
   const lines: EnuPoint[][] = [];
   for (let index = 0; index < centerLine.length - 1; index++) {
     const segment = [centerLine[index]!, centerLine[index + 1]!] as const;
-    const cell = [left[index]!, left[index + 1]!, right[index + 1]!, right[index]!];
     const direction = segmentUnit(segment[0], segment[1]);
-    const projections = cell.map((point) => point[0] * direction[0] + point[1] * direction[1]);
-    const longitudinalSpan = Math.max(...projections) - Math.min(...projections);
     const sourceSegmentLength = lineLength(segment);
     const previousDirection =
       index > 0 ? segmentUnit(centerLine[index - 1]!, segment[0]) : undefined;
     const hasSharpStart =
       previousDirection !== undefined &&
       Math.abs(cross(previousDirection, direction)) > Math.sin((5 * Math.PI) / 180);
+    const before = index > 0 ? centerLine[index - 1] : undefined;
+    const after = centerLine[index + 2];
+    const scanCell = trimJointOverlap(
+      corridorPolygon(segment, leftExtend, rightExtend, before, after),
+      segment,
+      before,
+      after,
+    );
+    const scanProjections = scanCell.map(
+      (point) => point[0] * direction[0] + point[1] * direction[1],
+    );
+    const scanSpan = Math.max(...scanProjections) - Math.min(...scanProjections);
     const lineCount = Math.max(
       1,
       Math.ceil(sourceSegmentLength / lineSpacing),
-      hasSharpStart
-        ? Math.ceil(longitudinalSpan / lineSpacing)
-        : Math.round(longitudinalSpan / lineSpacing),
+      // A direction change needs an additional boundary pass at the joint;
+      // count it against the finite square span, never the unbounded miter tip.
+      hasSharpStart ? Math.ceil(scanSpan / lineSpacing) + 1 : Math.round(scanSpan / lineSpacing),
     );
-    const phaseOffset = Math.max(0, (longitudinalSpan - (lineCount - 1) * lineSpacing) / 2);
-    const grid = surveyGrid(cell, {
+    if (lines.length + lineCount > MAX_ROUTE_COUNT)
+      throw new PlannerError("mappingStrip route count exceeds limit");
+    // Center the requested lines on the actual square cell. Tightening spacing
+    // increases overlap without emitting lines outside the work area.
+    const scanSpacing =
+      lineCount > 1
+        ? Math.min(lineSpacing, Math.max(POINT_EPS_M, scanSpan - POINT_EPS_M) / (lineCount - 1))
+        : lineSpacing;
+    const phaseOffset = Math.max(0, (scanSpan - (lineCount - 1) * scanSpacing) / 2);
+    const grid = surveyGrid(scanCell, {
       directionDeg: (bearingDeg(segment[0], segment[1]) + 90) % 360,
       marginM: margin,
-      lineSpacing,
+      lineSpacing: scanSpacing,
       phaseOffsetM: phaseOffset,
     });
     const flightDirection: EnuPoint = [direction[1], -direction[0]];
@@ -561,6 +646,93 @@ function perpendicularRouteLines(
   return lines;
 }
 
+function pointInRing(point: EnuPoint, polygon: readonly EnuPoint[]): boolean {
+  let inside = false;
+  for (let index = 0; index < polygon.length; index++) {
+    const a = polygon[index]!;
+    const b = polygon[(index + 1) % polygon.length]!;
+    const edge: EnuPoint = [b[0] - a[0], b[1] - a[1]];
+    const delta: EnuPoint = [point[0] - a[0], point[1] - a[1]];
+    const length = Math.hypot(...edge);
+    const projection = edge[0] * delta[0] + edge[1] * delta[1];
+    if (
+      length > 0 &&
+      Math.abs(cross(edge, delta)) < length * 1e-7 &&
+      projection >= -1e-7 &&
+      projection <= length * length + 1e-7
+    )
+      return true;
+    if (
+      a[1] > point[1] !== b[1] > point[1] &&
+      point[0] < a[0] + ((b[0] - a[0]) * (point[1] - a[1])) / (b[1] - a[1])
+    )
+      inside = !inside;
+  }
+  return inside;
+}
+
+/** Clip an open work polyline to a possibly concave region, retaining each span. */
+function clipWorkLine(line: readonly EnuPoint[], polygon: readonly EnuPoint[]): EnuPoint[][] {
+  // A zero-width single-line strip has no area to clip against.
+  if (polygonArea(polygon) < 1e-8) return [[...line]];
+  const result: EnuPoint[][] = [];
+  let current: EnuPoint[] | undefined;
+  for (let index = 1; index < line.length; index++) {
+    const a = line[index - 1]!;
+    const b = line[index]!;
+    const direction: EnuPoint = [b[0] - a[0], b[1] - a[1]];
+    const length = Math.hypot(...direction);
+    if (length < POINT_EPS_M) continue;
+    const cuts = [0, 1];
+    for (let edgeIndex = 0; edgeIndex < polygon.length; edgeIndex++) {
+      const c = polygon[edgeIndex]!;
+      const d = polygon[(edgeIndex + 1) % polygon.length]!;
+      const edge: EnuPoint = [d[0] - c[0], d[1] - c[1]];
+      const denominator = cross(direction, edge);
+      if (Math.abs(denominator) < 1e-9) continue;
+      const delta: EnuPoint = [c[0] - a[0], c[1] - a[1]];
+      const t = cross(delta, edge) / denominator;
+      const u = cross(delta, direction) / denominator;
+      if (t > 0 && t < 1 && u >= -1e-9 && u <= 1 + 1e-9) cuts.push(t);
+    }
+    cuts.sort((x, y) => x - y);
+    const at = (t: number): EnuPoint => [a[0] + t * direction[0], a[1] + t * direction[1]];
+    for (let cutIndex = 1; cutIndex < cuts.length; cutIndex++) {
+      const start = cuts[cutIndex - 1]!;
+      const end = cuts[cutIndex]!;
+      if ((end - start) * length < POINT_EPS_M) continue;
+      if (!pointInRing(at((start + end) / 2), polygon)) {
+        current = undefined;
+        continue;
+      }
+      const first = at(start);
+      const last = at(end);
+      if (
+        current &&
+        Math.hypot(current.at(-1)![0] - first[0], current.at(-1)![1] - first[1]) < POINT_EPS_M
+      )
+        current.push(last);
+      else {
+        current = [first, last];
+        result.push(current);
+      }
+    }
+  }
+  return result.map((points) => cleanLine(points));
+}
+
+function extendWorkLine(line: EnuPoint[], margin: number): EnuPoint[] {
+  if (margin === 0) return line;
+  const first = line[0]!;
+  const last = line.at(-1)!;
+  const direction = segmentUnit(first, last);
+  return [
+    [first[0] - direction[0] * margin, first[1] - direction[1] * margin],
+    ...line.slice(1, -1),
+    [last[0] + direction[0] * margin, last[1] + direction[1] * margin],
+  ];
+}
+
 function polygonArea(points: readonly EnuPoint[]): number {
   let area2 = 0;
   for (let index = 0; index < points.length; index++) {
@@ -638,6 +810,7 @@ export function deriveMappingStrip(
   const centerLine = cleanLine(triples.map((point) => lngLatToEnu(point, origin)));
   if (centerLine.length < 2)
     throw new PlannerError("mappingStrip requires two distinct center points");
+  validateCorridorJoins(centerLine, folder.Placemark.leftExtend, folder.Placemark.rightExtend);
   const inputs = normalizeInputs(folder, options);
   if (!(inputs.crossTrackFootprint > 0 && Number.isFinite(inputs.crossTrackFootprint)))
     throw new PlannerError("mappingStrip crossTrackFootprint must be finite and greater than zero");
@@ -654,42 +827,72 @@ export function deriveMappingStrip(
   const localRegions = applyMergedRegionRanges(
     contextualRegions,
     folder.Placemark.stripMergedRegions,
-  ).map((region) => ({
-    ...region,
-    polygon: corridorPolygon(
+  ).map((region) => {
+    const polygon = corridorPolygon(
       region.centerLine,
       folder.Placemark.leftExtend,
       folder.Placemark.rightExtend,
       region.beforePoint,
       region.afterPoint,
-    ),
-  }));
+    );
+    return {
+      ...region,
+      polygon: trimJointOverlap(polygon, region.centerLine, region.beforePoint, region.afterPoint),
+    };
+  });
   const offsets = routeOffsets(folder, inputs);
   const executionRegions = options?.regionOrderReversed
     ? [...localRegions].reverse()
     : localRegions;
   const perpendicular =
     options?.stripDirection === "perpendicular" && !folder.Placemark.singleLineEnable;
-  const candidateGroups = executionRegions.map((region) => {
+  const regionGeometry = executionRegions.map((region) => {
+    const routeOffsets: number[] = [];
     const rawLines = perpendicular
       ? perpendicularRouteLines(
           region.centerLine,
           folder.Placemark.leftExtend,
           folder.Placemark.rightExtend,
-          folder.Placemark.margin,
+          0,
           inputs.lineSpacing,
         )
-      : offsets.map((offset) => offsetPolyline(region.centerLine, offset));
+          .flatMap((line) => clipWorkLine(line, region.polygon))
+          .map((line) => extendWorkLine(line, folder.Placemark.margin))
+      : offsets.flatMap((offset) => {
+          const line = offsetSide(region.centerLine, offset, region.beforePoint, region.afterPoint);
+          const clipped = clipWorkLine(line, region.polygon);
+          routeOffsets.push(...clipped.map(() => offset));
+          return clipped;
+        });
     if (rawLines.length === 0)
       throw new PlannerError("mappingStrip region has no available flight routes");
-    return serpentineRouteVariants(rawLines).map((lines) =>
-      localRouteCandidate(lines, region.centerLine, folder.Placemark.elevationOptimizeEnable),
+    return { lines: rawLines, offsets: routeOffsets };
+  });
+  const candidateGroups = regionGeometry.map((geometry, index) => {
+    return serpentineRouteVariants(geometry.lines).map((lines) =>
+      localRouteCandidate(
+        lines,
+        executionRegions[index]!.centerLine,
+        folder.Placemark.elevationOptimizeEnable,
+      ),
     );
   });
   const takeOffRefPoint = template.missionConfig.takeOffRefPoint;
-  const selectedCandidateIndexes = shortestCandidateIndexes(
+  const home = takeOffRefPoint ? lngLatToEnu(takeOffRefPoint, origin) : undefined;
+  const timing = {
+    flightSpeed: Number(folder.autoFlightSpeed),
+    transitSpeed: Number(template.missionConfig.globalTransitionalSpeed),
+    finishAction: template.missionConfig.finishAction,
+  };
+  const selectedCandidateIndexes = selectStripRouteCandidates(
     candidateGroups,
-    takeOffRefPoint ? lngLatToEnu(takeOffRefPoint, origin) : undefined,
+    home,
+    executionRegions
+      .slice(1)
+      .map((region) =>
+        options?.regionOrderReversed ? region.centerLine.at(-1)! : region.centerLine[0]!,
+      ),
+    timing,
   );
   const flightRoutes: MappingStripRegionRoute[] = [];
   let previousRegionEnd: EnuPoint | undefined;
@@ -713,7 +916,7 @@ export function deriveMappingStrip(
     const executable = joinSegmentPoints(candidate.segments);
     flightRoutes.push({
       regionId: region.id,
-      routeOffsets: perpendicular ? [] : offsets.map(meters),
+      routeOffsets: regionGeometry[regionIndex]!.offsets.map(meters),
       routeLines: candidate.lines.map((line) => line.map((point) => enuToLngLat(point, origin))),
       segments: localSegments.map((segment) => ({
         ...segment,
@@ -730,7 +933,11 @@ export function deriveMappingStrip(
     folder.Placemark.leftExtend,
     folder.Placemark.rightExtend,
   );
-  const totalFlightLength = flightRoutes.reduce((sum, route) => sum + Number(route.length), 0);
+  const travel = measureStripMission(
+    candidateGroups.map((group, index) => group[selectedCandidateIndexes[index]!]!),
+    home,
+    timing,
+  );
   const estimatedPhotoCount = flightRoutes.reduce(
     (sum, route) =>
       sum +
@@ -758,10 +965,10 @@ export function deriveMappingStrip(
       polygon: region.polygon.map((point) => enuToLngLat(point, origin)),
     })),
     flightRoutes,
-    totalFlightLength: meters(totalFlightLength),
+    totalFlightLength: meters(travel.distance),
     photoSpacing: meters(inputs.photoSpacing),
     estimatedPhotoCount,
-    estimatedDuration: totalFlightLength / Number(folder.autoFlightSpeed),
+    estimatedDuration: travel.duration,
   };
 }
 
@@ -780,7 +987,7 @@ function heightModeToExecuteMode(folder: MappingStripFolder): ExecuteHeightMode
 function turnDamping(points: readonly LngLat[], index: number): Meters {
   const previous = haversineMeters(points[index - 1]!, points[index]!);
   const next = haversineMeters(points[index]!, points[index + 1]!);
-  return meters(Math.min(TURN_DAMPING_M, previous * 0.45, next * 0.45));
+  return meters(Math.min(TURN_DAMPING_M, previous / 3, next / 3));
 }
 
 function shootingGroups(