feat: sync latest run execution updates

web-rtcp-5axis-sim-plan/tests/node/verify_linear_unit_conversion.mjs

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+
+import {
+  linearUnitsToMetersFactor,
+  linearUnitsToMillimetersFactor,
+  linearValueToMeters,
+  linearValueToMillimeters,
+  normalizeLinearUnits,
+  resolveStateLinearUnits,
+} from "../../app/src/runtime/linear-units.js";
+import { createLinuxCncInterpreterRuntime } from "../../app/src/runtime/linuxcnc-interpreter-runtime.js";
+import { buildProgramExecutionTiming } from "../../app/src/runtime/execution-timing.js";
+import { axesToSceneMeters } from "../../app/src/visualization/five-axis-scene.js";
+
+function assertNear(actual, expected, label) {
+  assert.equal(Math.abs(actual - expected) < 1e-9, true, `${label}: expected ${expected}, got ${actual}`);
+}
+
+assert.equal(normalizeLinearUnits("MM"), "mm");
+assert.equal(normalizeLinearUnits("inch"), "inch");
+assert.equal(normalizeLinearUnits("meters"), "m");
+assertNear(linearUnitsToMetersFactor("mm"), 0.001, "mm to m factor");
+assertNear(linearUnitsToMetersFactor("inch"), 0.0254, "inch to m factor");
+assertNear(linearUnitsToMetersFactor("m"), 1, "m to m factor");
+assertNear(linearUnitsToMillimetersFactor("inch"), 25.4, "inch to mm factor");
+assertNear(linearValueToMeters(25.4, "mm"), 0.0254, "25.4 mm to meters");
+assertNear(linearValueToMeters(1, "inch"), 0.0254, "1 inch to meters");
+assertNear(linearValueToMillimeters(0.5, "m"), 500, "0.5 m to millimeters");
+
+const mmState = { profile: { traj: { linearUnits: "mm" } } };
+const inchState = { profile: { traj: { linearUnits: "inch" } } };
+const meterState = { profile: { traj: { linearUnits: "m" } } };
+const iniState = {
+  linuxCncIniConfig: { traj: { linearUnits: "inch" } },
+  profile: { traj: { linearUnits: "mm" } },
+};
+
+assert.equal(resolveStateLinearUnits(iniState), "inch");
+assert.deepEqual(axesToSceneMeters({ x: 25.4, y: -10, z: 2000 }, mmState), {
+  x: 0.0254,
+  y: -0.01,
+  z: 2,
+});
+assert.deepEqual(axesToSceneMeters({ x: 1, y: -0.5, z: 2 }, inchState), {
+  x: 0.0254,
+  y: -0.0127,
+  z: 0.0508,
+});
+assert.deepEqual(axesToSceneMeters({ x: 0.1, y: -0.2, z: 0.3 }, meterState), {
+  x: 0.1,
+  y: -0.2,
+  z: 0.3,
+});
+
+const inchTiming = buildProgramExecutionTiming({
+  profile: {
+    traj: {
+      linearUnits: "inch",
+      maxLinearVelocity: 2,
+      defaultLinearVelocity: 1,
+    },
+  },
+  defaultFeedRate: 1,
+  motion: [
+    { type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 } },
+    { type: "STRAIGHT_FEED", line: 2, axes: { x: 1, y: 0, z: 0 } },
+  ],
+});
+
+assert.equal(inchTiming.linearUnits, "inch");
+assertNear(inchTiming.segments[1].linearDistanceMm, 25.4, "inch segment distance in mm");
+assertNear(inchTiming.segments[1].velocityMmPerMin, 25.4, "inch feed velocity in mm/min");
+
+const mixedUnitsTiming = buildProgramExecutionTiming({
+  profile: {
+    traj: {
+      linearUnits: "mm",
+      maxLinearVelocity: 100,
+      defaultLinearVelocity: 10,
+    },
+  },
+  motion: [
+    { type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 }, linearUnits: "inch", feedRate: 10 },
+    { type: "STRAIGHT_FEED", line: 2, axes: { x: 1, y: 0, z: 0 }, linearUnits: "inch", feedRate: 10 },
+    { type: "STRAIGHT_FEED", line: 3, axes: { x: 25.4, y: 0, z: 0 }, linearUnits: "mm", feedRate: 100 },
+  ],
+});
+assertNear(mixedUnitsTiming.segments[1].linearDistanceMm, 25.4, "mixed units inch segment distance");
+assertNear(mixedUnitsTiming.segments[2].linearDistanceMm, 0, "mixed units unchanged position distance");
+
+const inverseTimeTiming = buildProgramExecutionTiming({
+  profile: {
+    traj: {
+      linearUnits: "mm",
+      maxLinearVelocity: 100,
+      defaultLinearVelocity: 10,
+    },
+  },
+  motion: [
+    { type: "STRAIGHT_FEED", line: 1, axes: { x: 0, y: 0, z: 0 }, linearUnits: "mm", feedMode: "inverse-time", feedRate: 120 },
+    { type: "STRAIGHT_FEED", line: 2, axes: { x: 10, y: 0, z: 0 }, linearUnits: "mm", feedMode: "inverse-time", feedRate: 120 },
+  ],
+});
+assertNear(inverseTimeTiming.segments[1].durationSeconds, 0.5, "G93 inverse-time F120 duration");
+assertNear(inverseTimeTiming.segments[1].velocityMmPerMin, 1200, "G93 inverse-time velocity");
+
+const interpreterRuntime = await createLinuxCncInterpreterRuntime();
+const inchExecution = interpreterRuntime.runProgram("G20 G90\nG1 X1 F10\nM2");
+const metricExecution = interpreterRuntime.runProgram("G21 G90\nG1 X25.4 F100\nM2");
+const inverseExecution = interpreterRuntime.runProgram("G21 G90 G93\nG1 X1 F120\nM2");
+
+assert.equal(inchExecution.motion[0].linearUnits, "inch");
+assert.equal(metricExecution.motion[0].linearUnits, "mm");
+assert.equal(inverseExecution.motion[0].feedMode, "inverse-time");
+assertNear(
+  axesToSceneMeters(inchExecution.motion[0].axes, mmState, inchExecution.motion[0].linearUnits).x,
+  0.0254,
+  "G20 interpreter motion uses inch scene conversion",
+);
+assertNear(
+  axesToSceneMeters(metricExecution.motion[0].axes, mmState, metricExecution.motion[0].linearUnits).x,
+  0.0254,
+  "G21 interpreter motion uses millimeter scene conversion",
+);
+
+console.log("linear_unit_conversion_smoke=ok");