@lumikmz/kmz 0.6.3 → 0.6.4

package/dist/index.mjs

@@ -738,6 +738,7 @@ function emitSmartOblique(folder, origin, enuWps, shootInterval, options) {
 	const lastIndex = enuWps.length - 1;
 	const pitch = folder.Placemark.smartObliqueGimbalPitch ?? degrees(-45);
 	const smartObliquePoints = buildSmartObliquePoints(Number(pitch), shootInterval);
+	let nextGroupId = 0;
 	const placemarks = enuWps.map((enu, index) => {
 		const coord = enuToLngLat(enu, origin);
 		const isLast = index === lastIndex;
@@ -754,41 +755,8 @@ function emitSmartOblique(folder, origin, enuWps, shootInterval, options) {
 			},
 			...COMMON_WP_EXTRAS
 		};
-		if (index === 0) placemark.actionGroup = [{
-			actionGroupId: 0,
-			actionGroupStartIndex: 0,
-			actionGroupEndIndex: lastIndex,
-			actionGroupMode: "sequence",
-			actionTrigger: { actionTriggerType: "reachPoint" },
-			action: [{
-				actionId: 0,
-				actionActuatorFunc: "gimbalAngleLock",
-				actionActuatorFuncParam: { payloadPositionIndex: 0 }
-			}, {
-				actionId: 1,
-				actionActuatorFunc: "startSmartOblique",
-				actionActuatorFuncParam: {
-					smartObliqueCycleMode: "unlimited",
-					payloadPositionIndex: 0,
-					smartObliquePoint: smartObliquePoints
-				}
-			}]
-		}];
-		else if (isLast) placemark.actionGroup = [{
-			actionGroupId: 1,
-			actionGroupStartIndex: lastIndex,
-			actionGroupEndIndex: lastIndex,
-			actionGroupMode: "sequence",
-			actionTrigger: { actionTriggerType: "reachPoint" },
-			action: [{
-				actionId: 0,
-				actionActuatorFunc: "stopSmartOblique",
-				actionActuatorFuncParam: { payloadPositionIndex: 0 }
-			}, {
-				actionId: 1,
-				actionActuatorFunc: "gimbalAngleUnlock"
-			}]
-		}];
+		if (index % 2 === 0 && index + 1 <= lastIndex) placemark.actionGroup = [smartObliqueStartGroup(index, index + 1, nextGroupId++, smartObliquePoints)];
+		else if (index % 2 === 1) placemark.actionGroup = [smartObliqueStopGroup(index, nextGroupId++)];
 		return placemark;
 	});
 	return {
@@ -800,6 +768,45 @@ function emitSmartOblique(folder, origin, enuWps, shootInterval, options) {
 		Placemark: placemarks
 	};
 }
+function smartObliqueStartGroup(startIndex, endIndex, groupId, smartObliquePoints) {
+	return {
+		actionGroupId: groupId,
+		actionGroupStartIndex: startIndex,
+		actionGroupEndIndex: endIndex,
+		actionGroupMode: "sequence",
+		actionTrigger: { actionTriggerType: "betweenAdjacentPoints" },
+		action: [{
+			actionId: 0,
+			actionActuatorFunc: "gimbalAngleLock",
+			actionActuatorFuncParam: { payloadPositionIndex: 0 }
+		}, {
+			actionId: 1,
+			actionActuatorFunc: "startSmartOblique",
+			actionActuatorFuncParam: {
+				smartObliqueCycleMode: "unlimited",
+				payloadPositionIndex: 0,
+				smartObliquePoint: smartObliquePoints
+			}
+		}]
+	};
+}
+function smartObliqueStopGroup(index, groupId) {
+	return {
+		actionGroupId: groupId,
+		actionGroupStartIndex: index,
+		actionGroupEndIndex: index,
+		actionGroupMode: "sequence",
+		actionTrigger: { actionTriggerType: "reachPoint" },
+		action: [{
+			actionId: 0,
+			actionActuatorFunc: "stopSmartOblique",
+			actionActuatorFuncParam: { payloadPositionIndex: 0 }
+		}, {
+			actionId: 1,
+			actionActuatorFunc: "gimbalAngleUnlock"
+		}]
+	};
+}
 function buildSmartObliquePoints(pitchDeg, shootInterval) {
 	const stayTime = Math.max(.1, shootInterval);
 	const obliquePitch = -Math.abs(pitchDeg || 45);

package/package.json

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

package/src/plan/plan-mapping2d.ts

@@ -472,6 +472,7 @@ function emitSmartOblique(
   const lastIndex = enuWps.length - 1;
   const pitch = folder.Placemark.smartObliqueGimbalPitch ?? degrees(-45);
   const smartObliquePoints = buildSmartObliquePoints(Number(pitch), shootInterval);
+  let nextGroupId = 0;
 
   const placemarks: WaylinesPlacemark[] = enuWps.map((enu, index) => {
     const coord = enuToLngLat(enu, origin);
@@ -492,50 +493,12 @@ function emitSmartOblique(
             },
       ...COMMON_WP_EXTRAS,
     };
-    if (index === 0) {
-      placemark.actionGroup = [
-        {
-          actionGroupId: 0,
-          actionGroupStartIndex: 0,
-          actionGroupEndIndex: lastIndex,
-          actionGroupMode: "sequence",
-          actionTrigger: { actionTriggerType: "reachPoint" },
-          action: [
-            {
-              actionId: 0,
-              actionActuatorFunc: "gimbalAngleLock",
-              actionActuatorFuncParam: { payloadPositionIndex: 0 },
-            },
-            {
-              actionId: 1,
-              actionActuatorFunc: "startSmartOblique",
-              actionActuatorFuncParam: {
-                smartObliqueCycleMode: "unlimited",
-                payloadPositionIndex: 0,
-                smartObliquePoint: smartObliquePoints,
-              },
-            },
-          ],
-        },
-      ];
-    } else if (isLast) {
+    if (index % 2 === 0 && index + 1 <= lastIndex) {
       placemark.actionGroup = [
-        {
-          actionGroupId: 1,
-          actionGroupStartIndex: lastIndex,
-          actionGroupEndIndex: lastIndex,
-          actionGroupMode: "sequence",
-          actionTrigger: { actionTriggerType: "reachPoint" },
-          action: [
-            {
-              actionId: 0,
-              actionActuatorFunc: "stopSmartOblique",
-              actionActuatorFuncParam: { payloadPositionIndex: 0 },
-            },
-            { actionId: 1, actionActuatorFunc: "gimbalAngleUnlock" },
-          ],
-        },
+        smartObliqueStartGroup(index, index + 1, nextGroupId++, smartObliquePoints),
       ];
+    } else if (index % 2 === 1) {
+      placemark.actionGroup = [smartObliqueStopGroup(index, nextGroupId++)];
     }
     return placemark;
   });
@@ -550,6 +513,55 @@ function emitSmartOblique(
   };
 }
 
+function smartObliqueStartGroup(
+  startIndex: number,
+  endIndex: number,
+  groupId: number,
+  smartObliquePoints: SmartObliquePoint[],
+) {
+  return {
+    actionGroupId: groupId,
+    actionGroupStartIndex: startIndex,
+    actionGroupEndIndex: endIndex,
+    actionGroupMode: "sequence" as const,
+    actionTrigger: { actionTriggerType: "betweenAdjacentPoints" as const },
+    action: [
+      {
+        actionId: 0,
+        actionActuatorFunc: "gimbalAngleLock" as const,
+        actionActuatorFuncParam: { payloadPositionIndex: 0 },
+      },
+      {
+        actionId: 1,
+        actionActuatorFunc: "startSmartOblique" as const,
+        actionActuatorFuncParam: {
+          smartObliqueCycleMode: "unlimited" as const,
+          payloadPositionIndex: 0,
+          smartObliquePoint: smartObliquePoints,
+        },
+      },
+    ],
+  };
+}
+
+function smartObliqueStopGroup(index: number, groupId: number) {
+  return {
+    actionGroupId: groupId,
+    actionGroupStartIndex: index,
+    actionGroupEndIndex: index,
+    actionGroupMode: "sequence" as const,
+    actionTrigger: { actionTriggerType: "reachPoint" as const },
+    action: [
+      {
+        actionId: 0,
+        actionActuatorFunc: "stopSmartOblique" as const,
+        actionActuatorFuncParam: { payloadPositionIndex: 0 },
+      },
+      { actionId: 1, actionActuatorFunc: "gimbalAngleUnlock" as const },
+    ],
+  };
+}
+
 function buildSmartObliquePoints(pitchDeg: number, shootInterval: number): SmartObliquePoint[] {
   const stayTime = Math.max(0.1, shootInterval);
   const obliquePitch = -Math.abs(pitchDeg || 45);

package/src/plan/plan.test.ts

@@ -370,16 +370,30 @@ describe("plan", () => {
     const funcs = wl.Folder[0]!.Placemark.flatMap((p) =>
       (p.actionGroup ?? []).flatMap((g) => g.action.map((a) => a.actionActuatorFunc)),
     );
-    expect(funcs.filter((fn) => fn === "startSmartOblique")).toHaveLength(1);
-    expect(funcs.filter((fn) => fn === "stopSmartOblique")).toHaveLength(1);
+    const scanlineCount = Math.floor(wl.Folder[0]!.Placemark.length / 2);
+    expect(funcs.filter((fn) => fn === "startSmartOblique")).toHaveLength(scanlineCount);
+    expect(funcs.filter((fn) => fn === "stopSmartOblique")).toHaveLength(scanlineCount);
     expect(funcs).toContain("gimbalAngleLock");
     expect(funcs).toContain("startSmartOblique");
     expect(funcs).toContain("stopSmartOblique");
     expect(funcs).toContain("gimbalAngleUnlock");
 
-    const start = wl.Folder[0]!.Placemark.flatMap((p) => p.actionGroup ?? [])
-      .flatMap((g) => g.action)
-      .find((a) => a.actionActuatorFunc === "startSmartOblique");
+    const groups = wl.Folder[0]!.Placemark.flatMap((p) => p.actionGroup ?? []);
+    const firstStartGroup = groups.find((g) =>
+      g.action.some((a) => a.actionActuatorFunc === "startSmartOblique"),
+    )!;
+    expect(firstStartGroup.actionGroupStartIndex).toBe(0);
+    expect(firstStartGroup.actionGroupEndIndex).toBe(1);
+    expect(firstStartGroup.actionTrigger.actionTriggerType).toBe("betweenAdjacentPoints");
+
+    const firstStopGroup = groups.find((g) =>
+      g.action.some((a) => a.actionActuatorFunc === "stopSmartOblique"),
+    )!;
+    expect(firstStopGroup.actionGroupStartIndex).toBe(1);
+    expect(firstStopGroup.actionGroupEndIndex).toBe(1);
+    expect(firstStopGroup.actionTrigger.actionTriggerType).toBe("reachPoint");
+
+    const start = firstStartGroup.action.find((a) => a.actionActuatorFunc === "startSmartOblique");
     expect(start?.actionActuatorFunc).toBe("startSmartOblique");
     if (start?.actionActuatorFunc === "startSmartOblique") {
       expect(start.actionActuatorFuncParam.smartObliqueCycleMode).toBe("unlimited");