@lumikmz/kmz 0.6.0 → 0.6.2

package/dist/index.d.mts

@@ -903,6 +903,12 @@ interface WaylinesFolder {
 interface PlanOptions {
   lineSpacing?: Meters;
   shootInterval?: number;
+  resolveExecuteHeight?: (point: {
+    lng: number;
+    lat: number;
+    index: number;
+    waylineId: number;
+  }) => Meters;
 }
 /**
  * Compile a high-level `Template` into executable `Waylines`.

package/dist/index.mjs

@@ -406,6 +406,14 @@ function heightModeToExecuteMode$3(folder) {
 		case "realTimeFollowSurface": return "realTimeFollowSurface";
 	}
 }
+function executeHeightFor$1(folder, coord, index, waylineId, options) {
+	if (folder.waylineCoordinateSysParam.heightMode !== "aboveGroundLevel") return folder.Placemark.height;
+	return options?.resolveExecuteHeight?.({
+		...coord,
+		index,
+		waylineId
+	}) ?? folder.Placemark.height;
+}
 /** Desired damping distance; clamped down when segments are short. */
 const DESIRED_TURN_DAMPING_M = 10;
 /** Never consume more than this fraction of either adjacent segment. */
@@ -613,7 +621,7 @@ const COMMON_WP_EXTRAS = {
 * waypoint — it does NOT detour to the centre (that detour is elevation optimization,
 * not smart-swing). Mutates `placemarks` (appends two waypoints).
 */
-function appendElevationExcursion(placemarks, folder, origin, enuWps, shootInterval, startGroupId) {
+function appendElevationExcursion(placemarks, folder, origin, enuWps, shootInterval, startGroupId, options) {
 	const lastNadirIdx = enuWps.length - 1;
 	const obliqueStartIdx = placemarks.length;
 	const obliqueEndIdx = obliqueStartIdx + 1;
@@ -658,7 +666,7 @@ function appendElevationExcursion(placemarks, folder, origin, enuWps, shootInter
 	placemarks.push({
 		Point: { coordinates: lastNadirCoord },
 		index: obliqueStartIdx,
-		executeHeight: folder.Placemark.height,
+		executeHeight: executeHeightFor$1(folder, lastNadirCoord, obliqueStartIdx, 0, options),
 		waypointSpeed: folder.autoFlightSpeed,
 		waypointHeadingParam: mappingHeadingParam(obliqueHeading, true),
 		waypointTurnParam: stopTurn(),
@@ -668,7 +676,7 @@ function appendElevationExcursion(placemarks, folder, origin, enuWps, shootInter
 	placemarks.push({
 		Point: { coordinates: centroidCoord },
 		index: obliqueEndIdx,
-		executeHeight: folder.Placemark.height,
+		executeHeight: executeHeightFor$1(folder, centroidCoord, obliqueEndIdx, 0, options),
 		waypointSpeed: folder.autoFlightSpeed,
 		waypointHeadingParam: mappingHeadingParam(0, false),
 		waypointTurnParam: stopTurn(),
@@ -688,7 +696,7 @@ function appendElevationExcursion(placemarks, folder, origin, enuWps, shootInter
 * When `elevationOptimizeEnable` is set, a centroid excursion is appended (see
 * `appendElevationExcursion`); otherwise the route ends at the last grid waypoint.
 */
-function emitOrtho(folder, origin, enuWps, shootInterval) {
+function emitOrtho(folder, origin, enuWps, shootInterval, options) {
 	const lastIndex = enuWps.length - 1;
 	const startActions = shootSectionStartActions(-90, shootInterval, 0, lastIndex, 0);
 	const stopGroup = shootSectionStopActions(lastIndex, startActions.nextGroupId);
@@ -699,7 +707,7 @@ function emitOrtho(folder, origin, enuWps, shootInterval) {
 		const placemark = {
 			Point: { coordinates: coord },
 			index,
-			executeHeight: folder.Placemark.height,
+			executeHeight: executeHeightFor$1(folder, coord, index, 0, options),
 			waypointSpeed: folder.autoFlightSpeed,
 			waypointHeadingParam: mappingHeadingParam(headingAngle, !isLast),
 			waypointTurnParam: index === 0 || isLast ? stopTurn() : {
@@ -712,7 +720,7 @@ function emitOrtho(folder, origin, enuWps, shootInterval) {
 		else if (isLast) placemark.actionGroup = [stopGroup];
 		return placemark;
 	});
-	if (folder.Placemark.elevationOptimizeEnable) appendElevationExcursion(placemarks, folder, origin, enuWps, shootInterval, startActions.nextGroupId + 1);
+	if (folder.Placemark.elevationOptimizeEnable) appendElevationExcursion(placemarks, folder, origin, enuWps, shootInterval, startActions.nextGroupId + 1, options);
 	return {
 		templateId: folder.templateId,
 		waylineId: 0,
@@ -726,7 +734,7 @@ function emitOrtho(folder, origin, enuWps, shootInterval) {
 * Single-pass smart-oblique / quick-ortho (smartObliqueEnable=true):
 * The aircraft flies one grid while the gimbal swings (startSmartOblique/stopSmartOblique).
 */
-function emitSmartOblique(folder, origin, enuWps) {
+function emitSmartOblique(folder, origin, enuWps, options) {
 	const lastIndex = enuWps.length - 1;
 	const pitch = folder.Placemark.smartObliqueGimbalPitch ?? degrees(-45);
 	const placemarks = enuWps.map((enu, index) => {
@@ -736,7 +744,7 @@ function emitSmartOblique(folder, origin, enuWps) {
 		const placemark = {
 			Point: { coordinates: coord },
 			index,
-			executeHeight: folder.Placemark.height,
+			executeHeight: executeHeightFor$1(folder, coord, index, 0, options),
 			waypointSpeed: folder.autoFlightSpeed,
 			waypointHeadingParam: mappingHeadingParam(headingAngle, !isLast),
 			waypointTurnParam: index === 0 || isLast ? stopTurn() : {
@@ -787,11 +795,11 @@ function planMapping2d(template, options) {
 	const shootInterval = options.shootInterval ?? 2;
 	if (folder.Placemark.smartObliqueEnable === true) return {
 		missionConfig: template.missionConfig,
-		Folder: [emitSmartOblique(folder, origin, enuWps)]
+		Folder: [emitSmartOblique(folder, origin, enuWps, options)]
 	};
 	return {
 		missionConfig: template.missionConfig,
-		Folder: [emitOrtho(folder, origin, enuWps, shootInterval)]
+		Folder: [emitOrtho(folder, origin, enuWps, shootInterval, options)]
 	};
 }
 //#endregion
@@ -875,18 +883,28 @@ function planMapping3d(template, options) {
 				headingMode: pass.headingMode,
 				headingAngle: degrees(wrap180(baseDirection + pass.headingOffsetDeg)),
 				gimbalPitch: pass.pitch === "nadir" ? degrees(-90) : inclined,
-				interval: pass.interval
+				interval: pass.interval,
+				options
 			});
 		})
 	};
 }
+function executeHeightFor(folder, coord, index, waylineId, options) {
+	if (folder.waylineCoordinateSysParam.heightMode !== "aboveGroundLevel") return folder.Placemark.height;
+	return options?.resolveExecuteHeight?.({
+		...coord,
+		index,
+		waylineId
+	}) ?? folder.Placemark.height;
+}
 function buildPass(folder, waylineId, origin, enuWps, cfg) {
 	const lastIndex = enuWps.length - 1;
 	const placemarks = enuWps.map((enu, index) => {
+		const coord = enuToLngLat(enu, origin);
 		const placemark = {
-			Point: { coordinates: enuToLngLat(enu, origin) },
+			Point: { coordinates: coord },
 			index,
-			executeHeight: folder.Placemark.height,
+			executeHeight: executeHeightFor(folder, coord, index, waylineId, cfg.options),
 			waypointSpeed: folder.Placemark.inclinedFlightSpeed,
 			waypointHeadingParam: {
 				waypointHeadingMode: cfg.headingMode,
@@ -1043,7 +1061,7 @@ function planWaypoint(template) {
 	const placemarks = folder.Placemark.map((p, i) => {
 		const heading = p.useGlobalHeadingParam || p.waypointHeadingParam === void 0 ? folder.globalWaypointHeadingParam : p.waypointHeadingParam;
 		const turn = p.useGlobalTurnParam || p.waypointTurnParam === void 0 ? { waypointTurnMode: folder.globalWaypointTurnMode } : p.waypointTurnParam;
-		const executeHeight = p.useGlobalHeight || p.height === void 0 ? folder.globalHeight : p.height;
+		const executeHeight = folder.waylineCoordinateSysParam.heightMode === "aboveGroundLevel" && p.ellipsoidHeight !== void 0 ? p.ellipsoidHeight : p.useGlobalHeight || p.height === void 0 ? folder.globalHeight : p.height;
 		const waypointSpeed = p.useGlobalSpeed || p.waypointSpeed === void 0 ? folder.autoFlightSpeed : p.waypointSpeed;
 		return {
 			Point: p.Point,
@@ -1072,13 +1090,13 @@ function planWaypoint(template) {
 /**
 * Map a template heightMode to a waylines executeHeightMode.
 * - `EGM96` → `WGS84` (waylines spec doesn't expose EGM96; runtime resolves it).
-* - `aboveGroundLevel` → `realTimeFollowSurface` (closest executable analog).
+* - `aboveGroundLevel` → `WGS84` (waypoint waylines use per-point ellipsoid heights).
 */
 function heightModeToExecuteMode(mode) {
 	switch (mode) {
-		case "EGM96": return "WGS84";
+		case "EGM96":
+		case "aboveGroundLevel": return "WGS84";
 		case "relativeToStartPoint": return "relativeToStartPoint";
-		case "aboveGroundLevel":
 		case "realTimeFollowSurface": return "realTimeFollowSurface";
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumikmz/kmz",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "DJI KMZ/WPML domain model + plan() algorithm + validate(), spec-aligned types mirroring docs/kmz/",
   "license": "MIT",
   "type": "module",

package/src/plan/index.ts

@@ -28,6 +28,12 @@ import { planWaypoint } from "./plan-waypoint.js";
 export interface PlanOptions {
   lineSpacing?: Meters;
   shootInterval?: number;
+  resolveExecuteHeight?: (point: {
+    lng: number;
+    lat: number;
+    index: number;
+    waylineId: number;
+  }) => Meters;
 }
 
 const isWaypoint = (t: Template): t is WaypointTemplate => t.Folder.templateType === "waypoint";

package/src/plan/plan-mapping2d.ts

@@ -68,6 +68,19 @@ function heightModeToExecuteMode(folder: Mapping2dFolder): ExecuteHeightMode {
   }
 }
 
+function executeHeightFor(
+  folder: Mapping2dFolder,
+  coord: { lng: number; lat: number },
+  index: number,
+  waylineId: number,
+  options?: PlanOptions,
+): Meters {
+  if (folder.waylineCoordinateSysParam.heightMode !== "aboveGroundLevel") {
+    return folder.Placemark.height;
+  }
+  return options?.resolveExecuteHeight?.({ ...coord, index, waylineId }) ?? folder.Placemark.height;
+}
+
 /** Desired damping distance; clamped down when segments are short. */
 const DESIRED_TURN_DAMPING_M = 10;
 
@@ -295,6 +308,7 @@ function appendElevationExcursion(
   enuWps: readonly EnuPoint[],
   shootInterval: number,
   startGroupId: number,
+  options?: PlanOptions,
 ): void {
   const lastNadirIdx = enuWps.length - 1;
   const obliqueStartIdx = placemarks.length;
@@ -352,7 +366,7 @@ function appendElevationExcursion(
   placemarks.push({
     Point: { coordinates: lastNadirCoord }, // same position as last nadir
     index: obliqueStartIdx,
-    executeHeight: folder.Placemark.height,
+    executeHeight: executeHeightFor(folder, lastNadirCoord, obliqueStartIdx, 0, options),
     waypointSpeed: folder.autoFlightSpeed,
     waypointHeadingParam: mappingHeadingParam(obliqueHeading, true),
     waypointTurnParam: stopTurn(),
@@ -363,7 +377,7 @@ function appendElevationExcursion(
   placemarks.push({
     Point: { coordinates: centroidCoord },
     index: obliqueEndIdx,
-    executeHeight: folder.Placemark.height,
+    executeHeight: executeHeightFor(folder, centroidCoord, obliqueEndIdx, 0, options),
     waypointSpeed: folder.autoFlightSpeed,
     waypointHeadingParam: mappingHeadingParam(0, false),
     waypointTurnParam: stopTurn(),
@@ -389,6 +403,7 @@ function emitOrtho(
   origin: { lng: number; lat: number },
   enuWps: readonly EnuPoint[],
   shootInterval: number,
+  options?: PlanOptions,
 ): WaylinesFolder {
   const lastIndex = enuWps.length - 1;
   const startActions = shootSectionStartActions(-90, shootInterval, 0, lastIndex, 0);
@@ -401,7 +416,7 @@ function emitOrtho(
     const placemark: WaylinesPlacemark = {
       Point: { coordinates: coord },
       index,
-      executeHeight: folder.Placemark.height,
+      executeHeight: executeHeightFor(folder, coord, index, 0, options),
       waypointSpeed: folder.autoFlightSpeed,
       waypointHeadingParam: mappingHeadingParam(headingAngle, !isLast),
       waypointTurnParam:
@@ -429,6 +444,7 @@ function emitOrtho(
       enuWps,
       shootInterval,
       startActions.nextGroupId + 1,
+      options,
     );
   }
 
@@ -450,6 +466,7 @@ function emitSmartOblique(
   folder: Mapping2dFolder,
   origin: { lng: number; lat: number },
   enuWps: readonly EnuPoint[],
+  options?: PlanOptions,
 ): WaylinesFolder {
   const lastIndex = enuWps.length - 1;
   const pitch = folder.Placemark.smartObliqueGimbalPitch ?? degrees(-45);
@@ -461,7 +478,7 @@ function emitSmartOblique(
     const placemark: WaylinesPlacemark = {
       Point: { coordinates: coord },
       index,
-      executeHeight: folder.Placemark.height,
+      executeHeight: executeHeightFor(folder, coord, index, 0, options),
       waypointSpeed: folder.autoFlightSpeed,
       waypointHeadingParam: mappingHeadingParam(headingAngle, !isLast),
       waypointTurnParam:
@@ -539,13 +556,13 @@ export function planMapping2d(template: Mapping2dTemplate, options?: PlanOptions
   if (folder.Placemark.smartObliqueEnable === true) {
     return {
       missionConfig: template.missionConfig,
-      Folder: [emitSmartOblique(folder, origin, enuWps)],
+      Folder: [emitSmartOblique(folder, origin, enuWps, options)],
     };
   }
   // 正射 and 正射+智能摆拍 share the nadir grid; the centroid detour is driven by
   // elevationOptimizeEnable inside emitOrtho, not by quickOrthoMappingEnable.
   return {
     missionConfig: template.missionConfig,
-    Folder: [emitOrtho(folder, origin, enuWps, shootInterval)],
+    Folder: [emitOrtho(folder, origin, enuWps, shootInterval, options)],
   };
 }

package/src/plan/plan-mapping3d.ts

@@ -1,4 +1,4 @@
-import { degrees } from "../types/branded.js";
+import { degrees, type Meters } from "../types/branded.js";
 import type { Action, GimbalRotateAction } from "../types/action.js";
 import type { ExecuteHeightMode, WaypointHeadingMode } from "../types/enums.js";
 import type { Mapping3dFolder, Mapping3dTemplate } from "../types/template.js";
@@ -131,6 +131,7 @@ export function planMapping3d(template: Mapping3dTemplate, options?: PlanOptions
         headingAngle: degrees(wrap180(baseDirection + pass.headingOffsetDeg)),
         gimbalPitch: pass.pitch === "nadir" ? degrees(-90) : inclined,
         interval: pass.interval,
+        options,
       });
     }),
   };
@@ -141,6 +142,20 @@ interface PassConfig {
   headingAngle: ReturnType<typeof degrees>;
   gimbalPitch: ReturnType<typeof degrees>;
   interval: number;
+  options?: PlanOptions;
+}
+
+function executeHeightFor(
+  folder: Mapping3dFolder,
+  coord: { lng: number; lat: number },
+  index: number,
+  waylineId: number,
+  options?: PlanOptions,
+): Meters {
+  if (folder.waylineCoordinateSysParam.heightMode !== "aboveGroundLevel") {
+    return folder.Placemark.height;
+  }
+  return options?.resolveExecuteHeight?.({ ...coord, index, waylineId }) ?? folder.Placemark.height;
 }
 
 function buildPass(
@@ -152,10 +167,11 @@ function buildPass(
 ): WaylinesFolder {
   const lastIndex = enuWps.length - 1;
   const placemarks: WaylinesPlacemark[] = enuWps.map((enu, index) => {
+    const coord = enuToLngLat(enu, origin);
     const placemark: WaylinesPlacemark = {
-      Point: { coordinates: enuToLngLat(enu, origin) },
+      Point: { coordinates: coord },
       index,
-      executeHeight: folder.Placemark.height,
+      executeHeight: executeHeightFor(folder, coord, index, waylineId, cfg.options),
       waypointSpeed: folder.Placemark.inclinedFlightSpeed,
       waypointHeadingParam: {
         waypointHeadingMode: cfg.headingMode,

package/src/plan/plan-waypoint.ts

@@ -25,7 +25,12 @@ export function planWaypoint(template: WaypointTemplate): Waylines {
         : p.waypointTurnParam;
 
     const executeHeight =
-      p.useGlobalHeight || p.height === undefined ? folder.globalHeight : p.height;
+      folder.waylineCoordinateSysParam.heightMode === "aboveGroundLevel" &&
+      p.ellipsoidHeight !== undefined
+        ? p.ellipsoidHeight
+        : p.useGlobalHeight || p.height === undefined
+          ? folder.globalHeight
+          : p.height;
 
     const waypointSpeed =
       p.useGlobalSpeed || p.waypointSpeed === undefined ? folder.autoFlightSpeed : p.waypointSpeed;
@@ -58,17 +63,17 @@ export function planWaypoint(template: WaypointTemplate): Waylines {
 /**
  * Map a template heightMode to a waylines executeHeightMode.
  * - `EGM96` → `WGS84` (waylines spec doesn't expose EGM96; runtime resolves it).
- * - `aboveGroundLevel` → `realTimeFollowSurface` (closest executable analog).
+ * - `aboveGroundLevel` → `WGS84` (waypoint waylines use per-point ellipsoid heights).
  */
 function heightModeToExecuteMode(
   mode: WaypointFolder["waylineCoordinateSysParam"]["heightMode"],
 ): ExecuteHeightMode {
   switch (mode) {
     case "EGM96":
+    case "aboveGroundLevel":
       return "WGS84";
     case "relativeToStartPoint":
       return "relativeToStartPoint";
-    case "aboveGroundLevel":
     case "realTimeFollowSurface":
       return "realTimeFollowSurface";
   }

package/src/plan/plan.test.ts

@@ -61,6 +61,52 @@ describe("plan", () => {
     expect(waylines.missionConfig).toBe(template.missionConfig);
   });
 
+  it("waypoint aboveGroundLevel uses per-point ellipsoid heights as WGS84 executeHeight", () => {
+    const template: WaypointTemplate = {
+      missionConfig,
+      Folder: {
+        templateType: "waypoint",
+        templateId: 0,
+        waylineCoordinateSysParam: { coordinateMode: "WGS84", heightMode: "aboveGroundLevel" },
+        autoFlightSpeed: metersPerSecond(10),
+        globalWaypointTurnMode: "toPointAndStopWithDiscontinuityCurvature",
+        gimbalPitchMode: "manual",
+        globalHeight: meters(50),
+        globalWaypointHeadingParam: {
+          waypointHeadingMode: "followWayline",
+          waypointHeadingPathMode: "followBadArc",
+        },
+        Placemark: [
+          {
+            Point: { coordinates: { lng: 113.938, lat: 22.5397 } },
+            index: 0,
+            useGlobalHeight: false,
+            height: meters(80),
+            ellipsoidHeight: meters(180),
+            useGlobalSpeed: true,
+            useGlobalHeadingParam: true,
+            useGlobalTurnParam: true,
+          },
+          {
+            Point: { coordinates: { lng: 113.939, lat: 22.5407 } },
+            index: 1,
+            useGlobalHeight: false,
+            height: meters(90),
+            ellipsoidHeight: meters(190),
+            useGlobalSpeed: true,
+            useGlobalHeadingParam: true,
+            useGlobalTurnParam: true,
+          },
+        ],
+      },
+    };
+
+    const waylines = plan(template);
+
+    expect(waylines.Folder[0]!.executeHeightMode).toBe("WGS84");
+    expect(waylines.Folder[0]!.Placemark.map((p) => Number(p.executeHeight))).toEqual([180, 190]);
+  });
+
   it("compiles a mapping2d template into a serpentine scan", () => {
     const template: Mapping2dTemplate = {
       missionConfig,
@@ -130,6 +176,89 @@ describe("plan", () => {
     expect(plan(template, { lineSpacing: meters(30) }).Folder).toHaveLength(1);
   });
 
+  it("mapping2d aboveGroundLevel uses per-waypoint HAE from resolveExecuteHeight", () => {
+    const template: Mapping2dTemplate = {
+      missionConfig,
+      Folder: {
+        templateType: "mapping2d",
+        templateId: 2,
+        waylineCoordinateSysParam: { coordinateMode: "WGS84", heightMode: "aboveGroundLevel" },
+        autoFlightSpeed: metersPerSecond(10),
+        Placemark: {
+          elevationOptimizeEnable: false,
+          shootType: "distance",
+          direction: degrees(0),
+          margin: 0,
+          overlap: { orthoCameraOverlapH: 80, orthoCameraOverlapW: 70 },
+          ellipsoidHeight: meters(150),
+          height: meters(100),
+          Polygon: {
+            outerBoundaryIs: {
+              LinearRing: {
+                coordinates:
+                  "113.938,22.5397,0 113.940,22.5397,0 113.940,22.5407,0 113.938,22.5407,0 113.938,22.5397,0",
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const calls: Array<{ lng: number; lat: number; index: number; waylineId: number }> = [];
+    const waylines = plan(template, {
+      lineSpacing: meters(45),
+      resolveExecuteHeight: (arg) => {
+        calls.push(arg);
+        return meters(300 + arg.index);
+      },
+    });
+
+    expect(calls).toHaveLength(waylines.Folder[0]!.Placemark.length);
+    expect(calls[0]!.waylineId).toBe(0);
+    expect(calls[0]!.index).toBe(0);
+    expect(calls[0]!.lng).toBe(waylines.Folder[0]!.Placemark[0]!.Point.coordinates.lng);
+    expect(calls[0]!.lat).toBe(waylines.Folder[0]!.Placemark[0]!.Point.coordinates.lat);
+    expect(waylines.Folder[0]!.executeHeightMode).toBe("realTimeFollowSurface");
+    expect(waylines.Folder[0]!.Placemark[0]!.executeHeight).toBe(300);
+    expect(waylines.Folder[0]!.Placemark[1]!.executeHeight).toBe(301);
+  });
+
+  it("mapping2d realTimeFollowSurface keeps template height and does not call resolveExecuteHeight", () => {
+    const template: Mapping2dTemplate = {
+      missionConfig,
+      Folder: {
+        templateType: "mapping2d",
+        templateId: 2,
+        waylineCoordinateSysParam: { coordinateMode: "WGS84", heightMode: "realTimeFollowSurface" },
+        autoFlightSpeed: metersPerSecond(10),
+        Placemark: {
+          elevationOptimizeEnable: false,
+          shootType: "distance",
+          direction: degrees(0),
+          margin: 0,
+          overlap: { orthoCameraOverlapH: 80, orthoCameraOverlapW: 70 },
+          ellipsoidHeight: meters(150),
+          height: meters(100),
+          Polygon: {
+            outerBoundaryIs: {
+              LinearRing: {
+                coordinates:
+                  "113.938,22.5397,0 113.940,22.5397,0 113.940,22.5407,0 113.938,22.5407,0 113.938,22.5397,0",
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const waylines = plan(template, {
+      lineSpacing: meters(45),
+      resolveExecuteHeight: () => meters(300),
+    });
+
+    expect(waylines.Folder[0]!.Placemark[0]!.executeHeight).toBe(100);
+  });
+
   it("mapping2d ortho: grid density follows provided lineSpacing", () => {
     const template: Mapping2dTemplate = {
       missionConfig,
@@ -347,4 +476,54 @@ describe("plan", () => {
     // lines than the same-axis nadir pass, despite covering the same width.
     expect(wl.Folder[1]!.Placemark.length).toBeLessThan(wl.Folder[0]!.Placemark.length);
   });
+
+  it("mapping3d aboveGroundLevel uses per-waypoint HAE from resolveExecuteHeight for each pass", () => {
+    const template: Mapping3dTemplate = {
+      missionConfig,
+      Folder: {
+        templateType: "mapping3d",
+        templateId: 0,
+        waylineCoordinateSysParam: { coordinateMode: "WGS84", heightMode: "aboveGroundLevel" },
+        autoFlightSpeed: metersPerSecond(10),
+        Placemark: {
+          inclinedGimbalPitch: degrees(-45),
+          inclinedFlightSpeed: metersPerSecond(10),
+          shootType: "time",
+          direction: degrees(0),
+          margin: 0,
+          overlap: { orthoCameraOverlapH: 80, orthoCameraOverlapW: 70 },
+          ellipsoidHeight: meters(150),
+          height: meters(100),
+          Polygon: {
+            outerBoundaryIs: {
+              LinearRing: {
+                coordinates:
+                  "113.9380,22.5397,0 113.9460,22.5397,0 113.9460,22.5417,0 113.9380,22.5417,0 113.9380,22.5397,0",
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const calls: Array<{ lng: number; lat: number; index: number; waylineId: number }> = [];
+    const waylines = plan(template, {
+      lineSpacing: meters(45),
+      resolveExecuteHeight: (arg) => {
+        calls.push(arg);
+        return meters(500 + arg.waylineId * 100 + arg.index);
+      },
+    });
+
+    const placemarkCount = waylines.Folder.reduce(
+      (sum, folder) => sum + folder.Placemark.length,
+      0,
+    );
+    expect(calls).toHaveLength(placemarkCount);
+    expect(waylines.Folder.map((folder) => folder.Placemark[0]!.executeHeight)).toEqual([
+      500, 600, 700, 800, 900,
+    ]);
+    expect(calls.some((call) => call.waylineId === 4 && call.index === 0)).toBe(true);
+    expect(calls.every((call) => "heightMode" in call === false)).toBe(true);
+  });
 });