@lumikmz/kmz 0.7.1 → 0.9.0

package/src/plan/plan-mapping2d.ts

@@ -204,7 +204,7 @@ function shootSectionStartActions(
         actionActuatorFuncParam: {
           payloadPositionIndex: 0,
           useGlobalPayloadLensIndex: false,
-          payloadLensIndex: "visable",
+          payloadLensIndex: ["visable"],
           minShootInterval: shootInterval,
         },
       },
@@ -256,7 +256,7 @@ function shootSectionStopActions(
       {
         actionId: 0,
         actionActuatorFunc: "stopTimeLapse",
-        actionActuatorFuncParam: { payloadPositionIndex: 0, payloadLensIndex: "visable" },
+        actionActuatorFuncParam: { payloadPositionIndex: 0, payloadLensIndex: ["visable"] },
       },
       { actionId: 1, actionActuatorFunc: "gimbalAngleUnlock" } satisfies Action,
     ],

package/src/types/action.ts

@@ -293,8 +293,8 @@ export type StopSmartObliqueAction = ActionBase<"stopSmartOblique", StopSmartObl
 export interface StartTimeLapseParam {
   payloadPositionIndex: number;
   useGlobalPayloadLensIndex: boolean;
-  /** Single lens token (not a list — mapping strips use one lens). */
-  payloadLensIndex: LensType;
+  /** Comma-separated in WPML; may contain visible and infrared lenses together. */
+  payloadLensIndex: LensType[];
   /** Minimum shoot interval in seconds. Derived from `forwardGroundSpacing / speed`. */
   minShootInterval: number;
 }
@@ -303,7 +303,7 @@ export type StartTimeLapseAction = ActionBase<"startTimeLapse", StartTimeLapsePa
 /** Stops interval shooting for a mapping strip. */
 export interface StopTimeLapseParam {
   payloadPositionIndex: number;
-  payloadLensIndex: LensType;
+  payloadLensIndex: LensType[];
 }
 export type StopTimeLapseAction = ActionBase<"stopTimeLapse", StopTimeLapseParam>;
 

package/src/types/placemark.ts

@@ -118,12 +118,16 @@ export interface Mapping3dPlacemark {
 /** `Placemark` inside a `mappingStrip` Folder — uses a LineString; params live here. */
 export interface MappingStripPlacemark {
   caliFlightEnable: boolean;
+  /** Optional field observed in FlightHub 2 mappingStrip exports. */
+  elevationOptimizeEnable?: boolean;
   shootType: ShootType;
   direction: Degrees;
   /** Float meters (vs integer in mapping2d/3d). */
   margin: number;
   singleLineEnable: boolean;
   cuttingDistance: number;
+  /** FlightHub 2 region merge ranges, serialized as JSON (for example `[[1,3]]`). */
+  stripMergedRegions?: number[][];
   boundaryOptimEnable: boolean;
   leftExtend: number;
   rightExtend: number;

package/src/types/template.ts

@@ -24,6 +24,10 @@ interface TemplateDocumentBase {
   author?: string;
   createTime?: number;
   updateTime?: number;
+  jnCustom?: {
+    airportId?: string;
+    airportSn?: string;
+  };
   missionConfig: MissionConfig;
 }
 

package/src/validate/validate-template.ts

@@ -73,17 +73,65 @@ function validateMapping3dFolder(t: Mapping3dTemplate, path: string): Issue[] {
 }
 
 function validateMappingStripFolder(t: MappingStripTemplate, path: string): Issue[] {
-  const tuples = t.Folder.Placemark.LineString.coordinates.trim().split(/\s+/);
-  if (tuples.length < 2) {
-    return [
-      {
-        path: `${path}.Placemark.LineString`,
-        message: `LineString must have at least 2 vertices, got ${tuples.length}`,
+  const placemark = t.Folder.Placemark;
+  const tuples = placemark.LineString.coordinates.trim().split(/\s+/).filter(Boolean);
+  const distinct = new Set(
+    tuples.map((tuple) => {
+      const [lng, lat] = tuple.split(",");
+      return `${lng},${lat}`;
+    }),
+  );
+  const issues: Issue[] = [];
+  if (tuples.length < 2 || distinct.size < 2) {
+    issues.push({
+      path: `${path}.Placemark.LineString`,
+      message: "LineString must contain at least 2 distinct vertices",
+      severity: "error",
+    });
+  }
+  if (!Number.isFinite(placemark.leftExtend) || placemark.leftExtend < 0) {
+    issues.push({
+      path: `${path}.Placemark.leftExtend`,
+      message: "leftExtend must be finite and non-negative",
+      severity: "error",
+    });
+  }
+  if (!Number.isFinite(placemark.rightExtend) || placemark.rightExtend < 0) {
+    issues.push({
+      path: `${path}.Placemark.rightExtend`,
+      message: "rightExtend must be finite and non-negative",
+      severity: "error",
+    });
+  }
+  if (!Number.isFinite(placemark.cuttingDistance) || placemark.cuttingDistance <= 0) {
+    issues.push({
+      path: `${path}.Placemark.cuttingDistance`,
+      message: "cuttingDistance must be finite and greater than zero",
+      severity: "error",
+    });
+  }
+  if (placemark.stripMergedRegions) {
+    const ranges = placemark.stripMergedRegions
+      .map((range) => ({ start: range[0], end: range[1], length: range.length }))
+      .sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+    const malformed = ranges.some(
+      ({ start, end, length }, index) =>
+        length !== 2 ||
+        !Number.isInteger(start) ||
+        !Number.isInteger(end) ||
+        start! < 1 ||
+        end! < start! ||
+        (index > 0 && start! <= ranges[index - 1]!.end!),
+    );
+    if (malformed) {
+      issues.push({
+        path: `${path}.Placemark.stripMergedRegions`,
+        message: "stripMergedRegions must contain non-overlapping one-based [start,end] ranges",
         severity: "error",
-      },
-    ];
+      });
+    }
   }
-  return [];
+  return issues;
 }
 
 function validatePolygonRing(coords: string, path: string): Issue[] {