Upload project files

kdl-wasm/web/tests/olp/geometry.test.ts

@@ -0,0 +1,146 @@
+import { describe, expect, it } from "vitest";
+import {
+  applyCalibrationRecords,
+  commercialExtensionBoundaries,
+  compareControllerLowSpeedRun,
+  createResourceLibraryTemplate,
+  detectBasicCollisions,
+  generatePathFromGeometry,
+  instantiateProcessTemplate,
+  locateCollisionTime,
+  sampleOlpProject,
+  validateOlpProject
+} from "../../src/olp/index.js";
+
+describe("OLP geometry, calibration, and multi-robot extensions", () => {
+  it("generates path targets from points, edges, and curves", () => {
+    const pointPath = generatePathFromGeometry(
+      { kind: "points", points: [[500, 0, 0], [600, 0, 0]] },
+      { pathId: "point_path", speedId: "v_linear", zoneId: "z10" }
+    );
+    const edgePath = generatePathFromGeometry(
+      { kind: "edge", start: [0, 0, 0], end: [100, 0, 0], samples: 3 },
+      { pathId: "edge_path" }
+    );
+    const curvePath = generatePathFromGeometry(
+      { kind: "curve", controlPoints: [[0, 0, 0], [50, 50, 0], [100, 0, 0]], samples: 3 },
+      { pathId: "curve_path", targetPrefix: "curve" }
+    );
+
+    expect(pointPath.targets.map((target) => target.pose)).toEqual([
+      [500, 0, 0, 0, 0, 0],
+      [600, 0, 0, 0, 0, 0]
+    ]);
+    expect(edgePath.targets.map((target) => target.pose?.[0])).toEqual([0, 50, 100]);
+    expect(curvePath.targets.map((target) => target.name)).toEqual(["curve_00", "curve_01", "curve_02"]);
+    expect(curvePath.path.points.map((point) => point.motion)).toEqual(["movej", "movel", "movel"]);
+  });
+
+  it("detects primitive collisions and locates the first time point", () => {
+    const project = sampleOlpProject();
+    const report = detectBasicCollisions([
+      { time: 0, pointId: "p0", position: [100, 0, 0] },
+      { time: 1.25, pointId: "p1", position: [550, 0, -40] }
+    ], project.resources.collisionObjects);
+
+    expect(report.ok).toBe(false);
+    expect(report.hits).toEqual([
+      expect.objectContaining({
+        objectId: "fixture_box",
+        pointId: "p1",
+        time: 1.25
+      })
+    ]);
+    expect(locateCollisionTime(report)).toBe(1.25);
+  });
+
+  it("saves and applies TCP/frame/base/external-axis calibration records", () => {
+    const project = sampleOlpProject();
+    const calibrated = applyCalibrationRecords(project, [
+      {
+        id: "tcp_cal_2",
+        name: "tcp_cal_2",
+        kind: "tcp",
+        targetResourceId: "tool_gripper",
+        poseDelta: [1, 2, 3, 0, 0, 0]
+      },
+      {
+        id: "fixture_cal_1",
+        name: "fixture_cal_1",
+        kind: "frame",
+        targetResourceId: "frame_fixture",
+        poseDelta: [10, 0, 0, 0, 0, 0]
+      },
+      {
+        id: "track_cal_1",
+        name: "track_cal_1",
+        kind: "external_axis",
+        targetResourceId: "track_1",
+        axisOffset: 2.5
+      }
+    ]);
+
+    expect(calibrated.resources.tools.find((tool) => tool.id === "tool_gripper")?.tcp).toEqual([1, 2, 103, 0, 0, 0]);
+    expect(calibrated.resources.frames.find((frame) => frame.id === "frame_fixture")?.pose).toEqual([810, 0, 0, 0, 0, 0]);
+    expect(calibrated.externalAxes[0]?.metadata).toEqual({ calibrationOffset: 2.5 });
+    expect(validateOlpProject(calibrated).ok).toBe(true);
+  });
+
+  it("creates resource library and process template delivery boundaries", () => {
+    const project = sampleOlpProject();
+    const library = createResourceLibraryTemplate(project);
+    const template = instantiateProcessTemplate(project.processTemplates[0]!, "pick_op");
+    const boundaries = commercialExtensionBoundaries();
+
+    expect(library).toMatchObject({
+      robots: [{ id: "robot_1", brand: "abb", model: "IRB120" }],
+      collisionObjects: [{ id: "fixture_box" }]
+    });
+    expect(template).toEqual({
+      operationId: "pick_op",
+      operationKind: "handling",
+      defaults: { speedId: "v_linear", zoneId: "z10" },
+      deliveryTags: ["source", "post", "report"]
+    });
+    expect(boundaries).toEqual(expect.arrayContaining([
+      expect.objectContaining({ feature: "cad_kernel", mvp: false }),
+      expect.objectContaining({ feature: "delivery_package", mvp: true })
+    ]));
+  });
+
+  it("reports multi-robot/external-axis low-speed controller verification boundaries", () => {
+    const project = sampleOlpProject();
+    const report = compareControllerLowSpeedRun([
+      {
+        pointId: "p01",
+        offline: [500, 0, 0, 0, 0, 0],
+        measured: [501, 0, 0, 0.1, 0, 0],
+        speedPercent: 10
+      },
+      {
+        pointId: "p02",
+        offline: [600, 0, 0, 0, 0, 0],
+        measured: [604, 0, 0, 0.5, 0, 0],
+        speedPercent: 10
+      }
+    ], {
+      positionMm: 5,
+      orientationDeg: 1
+    });
+
+    expect(project.motionGroups[0]).toMatchObject({
+      robotIds: ["robot_1"],
+      externalAxisIds: ["track_1"]
+    });
+    expect(report).toMatchObject({
+      status: "pass",
+      speedPercent: 10,
+      maxPositionErrorMm: 4,
+      maxOrientationErrorDeg: 0.5
+    });
+    expect(report.boundaries).toEqual(expect.arrayContaining([
+      expect.stringContaining("does not open a live controller communication session"),
+      expect.stringContaining("does not include a full CAD kernel")
+    ]));
+  });
+});