@lumikmz/kmz 0.11.0 → 0.11.1

package/dist/index.mjs

@@ -944,13 +944,14 @@ function planMapping3d(template, options) {
 		missionConfig: template.missionConfig,
 		Folder: PASSES.map((pass, i) => {
 			const passSpacing = pass.pitch === "inclined" ? obliqueSpacing : lineSpacing;
-			return buildPass(folder, i, origin, orientPathToHome(surveyGrid(ringEnu, {
+			const enuWps = orientPathToHome(surveyGrid(ringEnu, {
 				directionDeg: baseDirection + pass.axisOffsetDeg,
 				marginM: folder.Placemark.margin,
 				lineSpacing: passSpacing,
 				phaseOffsetM: pass.halfPhase ? passSpacing / 2 : 0,
 				lengthwiseShiftM: -pass.lookSign * standoff
-			}), origin, template.missionConfig.takeOffRefPoint), {
+			}), origin, template.missionConfig.takeOffRefPoint);
+			return buildPass(folder, i, origin, enuWps, {
 				headingMode: pass.headingMode,
 				headingAngle: degrees(wrap180(baseDirection + pass.headingOffsetDeg)),
 				gimbalPitch: pass.pitch === "nadir" ? degrees(-90) : inclined,
@@ -1053,9 +1054,113 @@ function heightModeToExecuteMode$2(mode) {
 	}
 }
 //#endregion
+//#region src/plan/strip-route-order.ts
+const HEADING_COST_M = 10;
+const JUNCTION_DETOUR_WEIGHT = .5;
+const NEAR_EQUAL_TIME_S = 2;
+const TIME_EPS_S = 1e-8;
+const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+const headingChange = (a, b) => 1 - Math.max(-1, Math.min(1, a[0] * b[0] + a[1] * b[1]));
+const DEFAULT_TIMING = {
+	flightSpeed: 1,
+	transitSpeed: 1,
+	finishAction: "noAction"
+};
+function validateTiming(timing) {
+	if (![timing.flightSpeed, timing.transitSpeed].every((speed) => Number.isFinite(speed) && speed > 0)) throw new PlannerError("mappingStrip flight and transit speeds must be finite and greater than zero");
+}
+function finishDistance(end, first, home, finish) {
+	const target = finish === "goHome" ? home : finish === "gotoFirstWaypoint" ? first : void 0;
+	return target ? distance(end, target) : 0;
+}
+/** Horizontal-flight estimate; vertical motion, wind and acceleration are not modeled. */
+function measureStripMission(routes, home, timing) {
+	validateTiming(timing);
+	if (routes.length === 0) return {
+		distance: 0,
+		duration: 0
+	};
+	const first = routes[0].start;
+	const workLength = routes.reduce((sum, route) => sum + route.length, 0);
+	let transitLength = home ? distance(home, first) : 0;
+	for (let index = 1; index < routes.length; index++) transitLength += distance(routes[index - 1].end, routes[index].start);
+	transitLength += finishDistance(routes.at(-1).end, first, home, timing.finishAction);
+	return {
+		distance: workLength + transitLength,
+		duration: workLength / timing.flightSpeed + transitLength / timing.transitSpeed
+	};
+}
+function transitionPreference(previous, next, junction) {
+	const length = distance(previous.end, next.start);
+	const direction = length > .05 ? [(next.start[0] - previous.end[0]) / length, (next.start[1] - previous.end[1]) / length] : void 0;
+	const turn = direction ? headingChange(previous.exitDirection, direction) + headingChange(direction, next.entryDirection) : headingChange(previous.exitDirection, next.entryDirection);
+	const detour = junction ? Math.max(0, distance(previous.end, junction) + distance(junction, next.start) - length) : 0;
+	return HEADING_COST_M * turn + JUNCTION_DETOUR_WEIGHT * detour;
+}
+/** Optimize mission time, then favor nearer entries within a two-second total budget. */
+function selectStripRouteCandidates(groups, home, junctions = [], timing = DEFAULT_TIMING) {
+	if (groups.length === 0) return [];
+	validateTiming(timing);
+	if (groups.some((group) => group.length === 0)) throw new PlannerError("mappingStrip region has no route candidates");
+	const finals = [];
+	groups[0].forEach((first, firstIndex) => {
+		const ingress = home ? distance(home, first.start) : 0;
+		let times = groups[0].map((candidate, index) => index === firstIndex ? candidate.length / timing.flightSpeed + ingress / timing.transitSpeed : Infinity);
+		let preferences = groups[0].map((_, index) => index === firstIndex ? 0 : Infinity);
+		const back = [groups[0].map(() => -1)];
+		for (let index = 1; index < groups.length; index++) {
+			const parents = [];
+			const nextPreferences = [];
+			times = groups[index].map((candidate) => {
+				let bestTime = Infinity;
+				let bestPreference = Infinity;
+				let parent = 0;
+				groups[index - 1].forEach((previous, previousIndex) => {
+					const time = times[previousIndex] + candidate.length / timing.flightSpeed + distance(previous.end, candidate.start) / timing.transitSpeed;
+					const preference = preferences[previousIndex] + transitionPreference(previous, candidate, junctions[index - 1]);
+					if (time < bestTime - TIME_EPS_S || Math.abs(time - bestTime) <= TIME_EPS_S && preference < bestPreference) {
+						bestTime = time;
+						bestPreference = preference;
+						parent = previousIndex;
+					}
+				});
+				parents.push(parent);
+				nextPreferences.push(bestPreference);
+				return bestTime;
+			});
+			preferences = nextPreferences;
+			back.push(parents);
+		}
+		groups.at(-1).forEach((last, lastIndex) => {
+			if (!Number.isFinite(times[lastIndex])) return;
+			finals.push({
+				lastIndex,
+				ingress,
+				back,
+				time: times[lastIndex] + finishDistance(last.end, first.start, home, timing.finishAction) / timing.transitSpeed,
+				preference: preferences[lastIndex]
+			});
+		});
+	});
+	const fastest = Math.min(...finals.map((choice) => choice.time));
+	const chosen = finals.filter((choice) => choice.time <= fastest + NEAR_EQUAL_TIME_S + TIME_EPS_S).reduce((best, candidate) => {
+		if (candidate.ingress < best.ingress - .05) return candidate;
+		if (Math.abs(candidate.ingress - best.ingress) > .05) return best;
+		if (candidate.preference < best.preference - TIME_EPS_S) return candidate;
+		if (Math.abs(candidate.preference - best.preference) <= TIME_EPS_S && candidate.time < best.time) return candidate;
+		return best;
+	});
+	let selected = chosen.lastIndex;
+	const result = groups.map(() => 0);
+	for (let index = groups.length - 1; index >= 0; index--) {
+		result[index] = selected;
+		selected = chosen.back[index][selected];
+	}
+	return result;
+}
+//#endregion
 //#region src/plan/plan-mapping-strip.ts
 const POINT_EPS_M = .05;
-const MITER_LIMIT = 2.5;
 const MAX_ROUTE_COUNT = 1e3;
 const TURN_DAMPING_M = 10;
 function parseTriples(s) {
@@ -1122,47 +1227,17 @@ function localRouteCandidate(lines, centerLine, elevationOptimizeEnable) {
 		});
 	}
 	const executable = joinSegmentPoints(segments);
+	const distinct = cleanLine(executable);
 	return {
 		lines,
 		segments,
 		start: executable[0],
-		end: executable.at(-1)
+		end: executable.at(-1),
+		entryDirection: segmentUnit(distinct[0], distinct[1]),
+		exitDirection: segmentUnit(distinct.at(-2), distinct.at(-1)),
+		length: lineLength(executable)
 	};
 }
-function shortestCandidateIndexes(candidateGroups, startPoint) {
-	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 = [candidateGroups[0].map(() => -1)];
-	for (let regionIndex = 1; regionIndex < candidateGroups.length; regionIndex++) {
-		const previousCandidates = candidateGroups[regionIndex - 1];
-		const candidates = candidateGroups[regionIndex];
-		const nextCosts = [];
-		const nextPreviousIndexes = [];
-		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(segments) {
 	const result = [];
 	for (const segment of segments) if (result.length === 0) result.push(...segment.points);
@@ -1271,35 +1346,41 @@ function segmentUnit(a, b) {
 function leftNormal(direction) {
 	return [-direction[1], direction[0]];
 }
-function offsetPolyline(points, distance) {
-	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 = [];
-	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) {
+	const result = [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 = [points[index][0] + previousNormal[0] * distance, points[index][1] + previousNormal[1] * distance];
-		const nextOffset = [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);
-			continue;
-		}
-		const t = cross([nextOffset[0] - previousOffset[0], nextOffset[1] - previousOffset[1]], nextDirection) / denominator;
-		const intersection = [previousOffset[0] + previousDirection[0] * t, previousOffset[1] + previousDirection[1] * t];
-		if (Math.hypot(intersection[0] - points[index][0], intersection[1] - points[index][1]) <= Math.abs(distance) * MITER_LIMIT) out.push(intersection);
-		else out.push(previousOffset, nextOffset);
+		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;
+		result.push(points[index]);
 	}
-	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;
+	result.push(points.at(-1));
+	return result;
+}
+/**
+* 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, incoming, outgoing, distance) {
+	const previousNormal = leftNormal(incoming);
+	const nextNormal = leftNormal(outgoing);
+	const previousOffset = [point[0] + previousNormal[0] * distance, point[1] + previousNormal[1] * distance];
+	const nextOffset = [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 t = cross([nextOffset[0] - previousOffset[0], nextOffset[1] - previousOffset[1]], outgoing) / denominator;
+	return [[previousOffset[0] + incoming[0] * t, previousOffset[1] + incoming[1] * t]];
 }
-function corridorSide(points, distance, beforePoint, afterPoint) {
+function offsetSide(points, distance, beforePoint, afterPoint) {
+	if (distance === 0) return points.map((point) => [point[0], point[1]]);
+	points = simplifyStraightRuns(points);
 	const out = [];
 	for (let index = 0; index < points.length; index++) {
 		const point = points[index];
@@ -1316,56 +1397,119 @@ function corridorSide(points, distance, beforePoint, afterPoint) {
 			continue;
 		}
 		if (!previous || !next) continue;
-		const previousDirection = segmentUnit(previous, point);
-		const nextDirection = segmentUnit(point, next);
-		const previousNormal = leftNormal(previousDirection);
-		const nextNormal = leftNormal(nextDirection);
-		const previousOffset = [point[0] + previousNormal[0] * distance, point[1] + previousNormal[1] * distance];
-		const nextOffset = [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;
-		}
-		if (denominator * distance < 0) {
-			out.push(previousOffset, nextOffset);
-			continue;
+		const joint = offsetJoint(point, segmentUnit(previous, point), segmentUnit(point, next), distance);
+		if (joint.length === 2 && (index === 0 || index === points.length - 1)) {
+			const midpoint = [(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);
+}
+function validateCorridorJoins(points, left, right) {
+	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");
+	}
+}
+function corridorPolygon(points, left, right, beforePoint, afterPoint) {
+	return [...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, outgoing) {
+	const normal = [incoming[0] + outgoing[0], incoming[1] + outgoing[1]];
+	const length = Math.hypot(normal[0], normal[1]);
+	return length < 1e-9 ? void 0 : [normal[0] / length, normal[1] / length];
+}
+/** Keep the half-plane `dot(normal, point - origin) <= 0` (Sutherland–Hodgman). */
+function clipHalfPlane(ring, origin, normal) {
+	const signedDistance = (point) => {
+		const distance = normal[0] * (point[0] - origin[0]) + normal[1] * (point[1] - origin[1]);
+		return Math.abs(distance) < 1e-8 ? 0 : distance;
+	};
+	const out = [];
+	const push = (point) => {
+		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]);
 		}
-		const t = cross([nextOffset[0] - previousOffset[0], nextOffset[1] - previousOffset[1]], nextDirection) / denominator;
-		const intersection = [previousOffset[0] + previousDirection[0] * t, previousOffset[1] + previousDirection[1] * t];
-		if (Math.hypot(intersection[0] - point[0], intersection[1] - point[1]) <= Math.abs(distance) * MITER_LIMIT) out.push(intersection);
-		else out.push(previousOffset, nextOffset);
 	}
+	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;
 }
-function corridorPolygon(points, left, right, beforePoint, afterPoint) {
-	return [...corridorSide(points, left, beforePoint, afterPoint), ...corridorSide(points, -right, beforePoint, afterPoint).reverse()];
+/**
+* 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, centerLine, beforePoint, afterPoint) {
+	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, leftExtend, rightExtend, margin, lineSpacing) {
-	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 = [];
 	for (let index = 0; index < centerLine.length - 1; index++) {
 		const segment = [centerLine[index], centerLine[index + 1]];
-		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]) : void 0;
 		const hasSharpStart = previousDirection !== void 0 && Math.abs(cross(previousDirection, direction)) > Math.sin(5 * Math.PI / 180);
-		const lineCount = Math.max(1, Math.ceil(sourceSegmentLength / lineSpacing), hasSharpStart ? Math.ceil(longitudinalSpan / lineSpacing) : Math.round(longitudinalSpan / lineSpacing));
-		const phaseOffset = Math.max(0, (longitudinalSpan - (lineCount - 1) * lineSpacing) / 2);
-		const grid = surveyGrid(cell, {
+		const before = index > 0 ? centerLine[index - 1] : void 0;
+		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(scanSpan / lineSpacing) + 1 : Math.round(scanSpan / lineSpacing));
+		if (lines.length + lineCount > MAX_ROUTE_COUNT) throw new PlannerError("mappingStrip route count exceeds limit");
+		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 = [direction[1], -direction[0]];
@@ -1378,6 +1522,75 @@ function perpendicularRouteLines(centerLine, leftExtend, rightExtend, margin, li
 	}
 	return lines;
 }
+function pointInRing(point, polygon) {
+	let inside = false;
+	for (let index = 0; index < polygon.length; index++) {
+		const a = polygon[index];
+		const b = polygon[(index + 1) % polygon.length];
+		const edge = [b[0] - a[0], b[1] - a[1]];
+		const delta = [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, polygon) {
+	if (polygonArea(polygon) < 1e-8) return [[...line]];
+	const result = [];
+	let current;
+	for (let index = 1; index < line.length; index++) {
+		const a = line[index - 1];
+		const b = line[index];
+		const direction = [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 = [d[0] - c[0], d[1] - c[1]];
+			const denominator = cross(direction, edge);
+			if (Math.abs(denominator) < 1e-9) continue;
+			const delta = [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) => [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 = void 0;
+				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, margin) {
+	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) {
 	let area2 = 0;
 	for (let index = 0; index < points.length; index++) {
@@ -1427,6 +1640,7 @@ function deriveMappingStrip(template, options) {
 	const origin = centroid(triples);
 	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");
 	if (!(inputs.photoSpacing > 0 && Number.isFinite(inputs.photoSpacing))) throw new PlannerError("mappingStrip photoSpacing must be finite and greater than zero");
@@ -1435,20 +1649,40 @@ function deriveMappingStrip(template, options) {
 		...region,
 		beforePoint: index > 0 ? splitRegions[index - 1].centerLine.at(-2) : void 0,
 		afterPoint: index + 1 < splitRegions.length ? splitRegions[index + 1].centerLine[1] : void 0
-	})), folder.Placemark.stripMergedRegions).map((region) => ({
-		...region,
-		polygon: corridorPolygon(region.centerLine, folder.Placemark.leftExtend, folder.Placemark.rightExtend, region.beforePoint, region.afterPoint)
-	}));
+	})), folder.Placemark.stripMergedRegions).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 rawLines = perpendicular ? perpendicularRouteLines(region.centerLine, folder.Placemark.leftExtend, folder.Placemark.rightExtend, folder.Placemark.margin, inputs.lineSpacing) : offsets.map((offset) => offsetPolyline(region.centerLine, offset));
+	const regionGeometry = executionRegions.map((region) => {
+		const routeOffsets = [];
+		const rawLines = perpendicular ? perpendicularRouteLines(region.centerLine, folder.Placemark.leftExtend, folder.Placemark.rightExtend, 0, inputs.lineSpacing).flatMap((line) => clipWorkLine(line, region.polygon)).map((line) => extendWorkLine(line, folder.Placemark.margin)) : offsets.flatMap((offset) => {
+			const clipped = clipWorkLine(offsetSide(region.centerLine, offset, region.beforePoint, region.afterPoint), 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(candidateGroups, takeOffRefPoint ? lngLatToEnu(takeOffRefPoint, origin) : void 0);
+	const home = takeOffRefPoint ? lngLatToEnu(takeOffRefPoint, origin) : void 0;
+	const timing = {
+		flightSpeed: Number(folder.autoFlightSpeed),
+		transitSpeed: Number(template.missionConfig.globalTransitionalSpeed),
+		finishAction: template.missionConfig.finishAction
+	};
+	const selectedCandidateIndexes = selectStripRouteCandidates(candidateGroups, home, executionRegions.slice(1).map((region) => options?.regionOrderReversed ? region.centerLine.at(-1) : region.centerLine[0]), timing);
 	const flightRoutes = [];
 	let previousRegionEnd;
 	executionRegions.forEach((region, regionIndex) => {
@@ -1462,7 +1696,7 @@ function deriveMappingStrip(template, options) {
 		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,
@@ -1474,7 +1708,7 @@ function deriveMappingStrip(template, options) {
 		previousRegionEnd = candidate.end;
 	});
 	const surveyAreaLocal = corridorPolygon(centerLine, 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 + route.segments.filter(({ photoEnabled }) => photoEnabled).reduce((lineSum, segment) => {
 		let length = 0;
 		for (let index = 1; index < segment.points.length; index++) length += haversineMeters(segment.points[index - 1], segment.points[index]);
@@ -1493,10 +1727,10 @@ function deriveMappingStrip(template, options) {
 			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
 	};
 }
 function heightModeToExecuteMode$1(folder) {
@@ -1510,7 +1744,7 @@ function heightModeToExecuteMode$1(folder) {
 function turnDamping$1(points, index) {
 	const previous = haversineMeters(points[index - 1], points[index]);
 	const next = haversineMeters(points[index], points[index + 1]);
-	return meters(Math.min(TURN_DAMPING_M, previous * .45, next * .45));
+	return meters(Math.min(TURN_DAMPING_M, previous / 3, next / 3));
 }
 function shootingGroups(folder, startIndex, endIndex, firstGroupId, inputs) {
 	const lenses = folder.payloadParam?.imageFormat ?? ["visable"];
@@ -2069,9 +2303,7 @@ function validateTemplate(template) {
 		case "mappingStrip":
 			issues.push(...validateMappingStripFolder(template, path));
 			break;
-		case "targetdetection":
-			issues.push(...validateTargetDetectionFolder(template, path));
-			break;
+		case "targetdetection": issues.push(...validateTargetDetectionFolder(template, path));
 	}
 	return issues;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumikmz/kmz",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "description": "DJI KMZ/WPML domain model + plan() algorithm + validate(), spec-aligned types mirroring docs/kmz/",
   "license": "MIT",
   "type": "module",
@@ -15,8 +15,7 @@
     "./package.json": "./package.json"
   },
   "devDependencies": {
-    "vite-plus": "latest",
-    "vitest": "npm:@voidzero-dev/vite-plus-test@^0.1.20"
+    "vite-plus": "1.3.0"
   },
   "scripts": {
     "build": "vp pack"

package/src/plan/geometry.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it } from "vite-plus/test";
 import { offsetPolygon, rotateEnu, surveyGrid, type EnuPoint } from "./geometry.js";
 
 const SQUARE: EnuPoint[] = [