@viamrobotics/motion-tools 1.26.1 → 1.26.2

package/dist/hooks/useDrawAPI.svelte.js

@@ -1,7 +1,7 @@
 import { useThrelte } from '@threlte/core';
 import {} from 'koota';
 import { getContext, setContext } from 'svelte';
-import { Color, Vector3, Vector4 } from 'three';
+import { Color, Matrix4, Vector3, Vector4 } from 'three';
 import { NURBSCurve } from 'three/addons/curves/NURBSCurve.js';
 import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';
 import { UuidTool } from 'uuid-tool';
@@ -11,7 +11,7 @@ import { asRGB, STRIDE } from '../buffer';
 import { hierarchy, traits, useWorld } from '../ecs';
 import { createBox, createCapsule, createSphere } from '../geometry';
 import { parsePlyInput } from '../ply';
-import { createPose, createPoseFromFrame } from '../transform';
+import { createPose, createPoseFromFrame, poseToMatrix } from '../transform';
 import { useCameraControls } from './useControls.svelte';
 import { useDrawConnectionConfig } from './useDrawConnectionConfig.svelte';
 import { useLogs } from './useLogs.svelte';
@@ -126,7 +126,11 @@ export const provideDrawAPI = () => {
             const parent = frame.parent;
             const existing = entities.get(name);
             if (existing) {
-                existing.set(traits.Pose, pose);
+                const matrix = existing.get(traits.Matrix);
+                if (matrix) {
+                    poseToMatrix(pose, matrix);
+                    existing.changed(traits.Matrix);
+                }
                 hierarchy.setParent(existing, parent);
                 continue;
             }
@@ -146,7 +150,7 @@ export const provideDrawAPI = () => {
             if (frame.geometry) {
                 entityTraits.push(geometryTrait());
             }
-            entityTraits.push(traits.Name(name), traits.Pose(pose), traits.DrawAPI, traits.ReferenceFrame, traits.Removable, traits.ShowAxesHelper);
+            entityTraits.push(traits.Name(name), traits.Matrix(poseToMatrix(pose, new Matrix4())), traits.DrawAPI, traits.ReferenceFrame, traits.Removable, traits.ShowAxesHelper);
             const entity = world.spawn(...entityTraits);
             entities.set(name, entity);
         }
@@ -157,7 +161,11 @@ export const provideDrawAPI = () => {
         const pose = createPose(data.center);
         const existing = entities.get(name);
         if (existing) {
-            existing.set(traits.Pose, pose);
+            const matrix = existing.get(traits.Matrix);
+            if (matrix) {
+                poseToMatrix(pose, matrix);
+                existing.changed(traits.Matrix);
+            }
             return;
         }
         const geometryTrait = () => {
@@ -179,7 +187,7 @@ export const provideDrawAPI = () => {
         const entityTraits = [
             traits.Name(data.label ?? ++geometryIndex),
             ...hierarchy.parentTraits(parent),
-            traits.Pose(pose),
+            traits.Matrix(poseToMatrix(pose, new Matrix4())),
             traits.Color(colorUtil.set(color)),
             geometryTrait(),
             traits.DrawAPI,

package/dist/hooks/useFrames.svelte.js

@@ -2,9 +2,10 @@ import { MachineConnectionEvent, Transform } from '@viamrobotics/sdk';
 import { createRobotQuery, useConnectionStatus, useMachineStatus, useRobotClient, } from '@viamrobotics/svelte-sdk';
 import {} from 'koota';
 import { getContext, setContext, untrack } from 'svelte';
+import { Matrix4 } from 'three';
 import { resourceNameToColor, subtypeToColor } from '../color';
 import { hierarchy, traits, useWorld } from '../ecs';
-import { createPose } from '../transform';
+import { createPose, isPoseEqual, poseToMatrix } from '../transform';
 import { useConfigFrames } from './useConfigFrames.svelte';
 import { useEnvironment } from './useEnvironment.svelte';
 import { useFrameEditSession } from './useFrameEditSession.svelte';
@@ -171,34 +172,45 @@ export const provideFrames = (partID) => {
                     }
                     hierarchy.setParent(existing, parent);
                     if (color) {
-                        existing.set(traits.Color, color);
+                        const cur = existing.get(traits.Color);
+                        if (!cur || cur.r !== color.r || cur.g !== color.g || cur.b !== color.b) {
+                            existing.set(traits.Color, color);
+                        }
                     }
-                    if (center) {
+                    if (center && !isPoseEqual(existing.get(traits.Center), center)) {
                         existing.set(traits.Center, center);
                     }
                     traits.updateGeometryTrait(existing, frame.physicalObject);
                     if (!isEditMode && !partConfig.hasPendingSave) {
-                        existing.set(traits.Pose, pose);
+                        const baseline = existing.get(traits.Matrix);
+                        if (baseline) {
+                            poseToMatrix(pose, baseline);
+                            existing.changed(traits.Matrix);
+                        }
                     }
-                    if (!existing.has(traits.LivePose)) {
-                        existing.add(traits.LivePose(pose));
+                    if (!existing.has(traits.LiveMatrix)) {
+                        existing.add(traits.LiveMatrix(poseToMatrix(pose, new Matrix4())));
                     }
-                    // Skip the EditedPose overwrite while in edit mode. The merged
+                    // Skip the EditedMatrix overwrite while in edit mode. The merged
                     // `frames` source can differ from query.data once didRecentlyEdit
                     // flips (fragment overrides, round-trip drift), and writing those
                     // values would shift entities whose parents the user is portaling
                     // into — the gizmo's drag target moves underneath it. Once we're
                     // back in monitor mode, the next sync resumes the overwrite.
                     if (!isEditMode) {
-                        existing.set(traits.EditedPose, pose);
+                        const edited = existing.get(traits.EditedMatrix);
+                        if (edited) {
+                            poseToMatrix(pose, edited);
+                            existing.changed(traits.EditedMatrix);
+                        }
                     }
                     continue;
                 }
                 const entityTraits = [
                     traits.Name(name),
-                    traits.Pose(pose),
-                    traits.EditedPose(pose),
-                    traits.LivePose(pose),
+                    traits.Matrix(poseToMatrix(pose, new Matrix4())),
+                    traits.EditedMatrix(poseToMatrix(pose, new Matrix4())),
+                    traits.LiveMatrix(poseToMatrix(pose, new Matrix4())),
                     traits.FramesAPI,
                     traits.Transformable,
                     traits.ShowAxesHelper,

package/dist/hooks/useGeometries.svelte.js

@@ -7,7 +7,7 @@ import { resourceColors } from '../color';
 import { RefetchRates } from '../components/overlay/RefreshRate.svelte';
 import { hierarchy, traits, useWorld } from '../ecs';
 import { updateGeometryTrait } from '../ecs/traits';
-import { createPose } from '../transform';
+import { createPose, isPoseEqual } from '../transform';
 import { useEnvironment } from './useEnvironment.svelte';
 import { useLogs } from './useLogs.svelte';
 import { useResourceByName } from './useResourceByName.svelte';
@@ -91,7 +91,9 @@ export const provideGeometries = (partID) => {
                         const existing = entities.get(entityKey);
                         if (existing) {
                             hierarchy.setParent(existing, name);
-                            existing.set(traits.Center, center);
+                            if (!isPoseEqual(existing.get(traits.Center), center)) {
+                                existing.set(traits.Center, center);
+                            }
                             updateGeometryTrait(existing, geometry);
                             continue;
                         }

package/dist/hooks/usePartConfig.svelte.js

@@ -204,9 +204,40 @@ export const usePartConfig = () => {
     return getContext(key);
 };
 const useEmbeddedPartConfig = (props) => {
+    let hasPendingSave = $state(false);
+    let prevIsDirty = false;
+    let cleanSnapshot;
+    const snapshot = (current) => {
+        const json = current?.toJson?.();
+        return json === undefined ? undefined : JSON.stringify(json);
+    };
+    /**
+     * The host app owns saving, and we aren't notified directly. Set hasPendingSave
+     * to watch isDirty: true -> false transitions, representing a save.
+     *
+     * `useFrames` clears the flag on the next `revision` change
+     * once the server reports the new framesystem.
+     */
+    $effect.pre(() => {
+        const dirty = props.isDirty;
+        const current = props.current;
+        if (prevIsDirty && !dirty) {
+            const next = snapshot(current);
+            if (next !== undefined && cleanSnapshot !== undefined && next !== cleanSnapshot) {
+                hasPendingSave = true;
+            }
+            cleanSnapshot = next;
+        }
+        else if (!prevIsDirty && !dirty) {
+            cleanSnapshot = snapshot(current);
+        }
+        prevIsDirty = dirty;
+    });
     return {
         hasEditPermissions: true,
-        hasPendingSave: false,
+        get hasPendingSave() {
+            return hasPendingSave;
+        },
         get isDirty() {
             return props.isDirty;
         },
@@ -220,8 +251,12 @@ const useEmbeddedPartConfig = (props) => {
             const struct = Struct.fromJson(config);
             return props.setLocalPartConfig(struct);
         },
-        clearPendingSave() { },
-        setPendingSave() { },
+        clearPendingSave() {
+            hasPendingSave = false;
+        },
+        setPendingSave() {
+            hasPendingSave = true;
+        },
     };
 };
 const useStandalonePartConfig = (partID) => {

package/dist/hooks/useWorldState.svelte.js

@@ -1,13 +1,14 @@
 import { useThrelte } from '@threlte/core';
 import { Struct, TransformChangeType, WorldStateStoreClient, } from '@viamrobotics/sdk';
 import { createResourceClient, createResourceQuery, createResourceStream, useResourceNames, } from '@viamrobotics/svelte-sdk';
+import { Matrix4 } from 'three';
 import { asFloat32Array, inMeters } from '../buffer';
 import { createChunkLoader } from '../chunking';
 import { drawTransform, updateMetadata } from '../draw';
 import { traits, useWorld } from '../ecs';
 import { isPointCloud } from '../geometry';
 import { metadataFromStruct } from '../metadata';
-import { createPose } from '../transform';
+import { createPose, poseToMatrix } from '../transform';
 import { usePartID } from './usePartID.svelte';
 import { useRelationships } from './useRelationships.svelte';
 export const provideWorldStates = () => {
@@ -133,7 +134,14 @@ const createWorldState = (client) => {
         for (const path of changes) {
             if (typeof path === 'string') {
                 if (path.startsWith('poseInObserverFrame.pose')) {
-                    entity.set(traits.Pose, transform.poseInObserverFrame?.pose ?? createPose());
+                    const matrix = entity.get(traits.Matrix);
+                    if (matrix) {
+                        poseToMatrix(createPose(transform.poseInObserverFrame?.pose), matrix);
+                        entity.changed(traits.Matrix);
+                    }
+                    else {
+                        entity.add(traits.Matrix(poseToMatrix(createPose(transform.poseInObserverFrame?.pose), new Matrix4())));
+                    }
                 }
                 else if (path.startsWith('physicalObject') && transform.physicalObject) {
                     traits.updateGeometryTrait(entity, transform.physicalObject);

package/dist/transform.js

@@ -5,6 +5,20 @@ const euler = new Euler();
 const ov = new OrientationVector();
 const translation = new Vector3();
 const scale = new Vector3();
+const matA = new Matrix4();
+export const isPoseEqual = (a, b) => {
+    if (a === b)
+        return true;
+    if (!a || !b)
+        return false;
+    return (a.x === b.x &&
+        a.y === b.y &&
+        a.z === b.z &&
+        a.oX === b.oX &&
+        a.oY === b.oY &&
+        a.oZ === b.oZ &&
+        a.theta === b.theta);
+};
 export const createPose = (pose) => {
     // We should only default to the 0,0,1,0 orientation vector if the entire vector component is missing
     const oZ = pose?.oX === undefined && pose?.oY === undefined && pose?.oZ === undefined ? 1 : (pose?.oZ ?? 0);
@@ -84,20 +98,31 @@ export const poseToDirection = (pose) => {
     ov.set(pose.oX, pose.oY, pose.oZ, MathUtils.degToRad(pose.theta));
     return new Vector3(ov.x, ov.y, ov.z);
 };
-export const poseToMatrix = (pose) => {
+export const isFinitePose = (pose) => Number.isFinite(pose.x) &&
+    Number.isFinite(pose.y) &&
+    Number.isFinite(pose.z) &&
+    Number.isFinite(pose.oX) &&
+    Number.isFinite(pose.oY) &&
+    Number.isFinite(pose.oZ) &&
+    Number.isFinite(pose.theta);
+/**
+ * Build a TRS `Matrix4` (m) from a `Pose` (mm), writing into `matrix`.
+ */
+export const poseToMatrix = (pose, matrix) => {
     ov.set(pose.oX, pose.oY, pose.oZ, MathUtils.degToRad(pose.theta));
     ov.toQuaternion(quaternion);
-    const matrix = new Matrix4();
     matrix.makeRotationFromQuaternion(quaternion);
-    matrix.setPosition(pose.x, pose.y, pose.z);
+    matrix.setPosition(pose.x * 0.001, pose.y * 0.001, pose.z * 0.001);
     return matrix;
 };
-export const matrixToPose = (matrix) => {
-    const pose = createPose();
+/**
+ * Decompose a `Matrix4` (m) into a `Pose` (mm), writing into `pose`.
+ */
+export const matrixToPose = (matrix, pose) => {
     matrix.decompose(translation, quaternion, scale);
-    pose.x = translation.x;
-    pose.y = translation.y;
-    pose.z = translation.z;
+    pose.x = translation.x * 1000;
+    pose.y = translation.y * 1000;
+    pose.z = translation.z * 1000;
     ov.setFromQuaternion(quaternion);
     pose.oX = ov.x;
     pose.oY = ov.y;
@@ -105,16 +130,25 @@ export const matrixToPose = (matrix) => {
     pose.theta = MathUtils.radToDeg(ov.th);
     return pose;
 };
-export const composeRenderedPose = (livePose, baselinePose, editedPose) => matrixToPose(poseToMatrix(livePose)
-    .multiply(poseToMatrix(baselinePose).invert())
-    .multiply(poseToMatrix(editedPose)));
-export const composeEditedPoseForRenderedPose = (baselinePose, livePose, renderedPose) => matrixToPose(poseToMatrix(baselinePose)
-    .multiply(poseToMatrix(livePose).invert())
-    .multiply(poseToMatrix(renderedPose)));
-export const isFinitePose = (pose) => Number.isFinite(pose.x) &&
-    Number.isFinite(pose.y) &&
-    Number.isFinite(pose.z) &&
-    Number.isFinite(pose.oX) &&
-    Number.isFinite(pose.oY) &&
-    Number.isFinite(pose.oZ) &&
-    Number.isFinite(pose.theta);
+/**
+ * Compose the entity's local-to-parent transform: writes
+ * `live × baseline⁻¹ × edited` into `out`. Mirrors the formula
+ * `Frame.svelte` uses to blend live kinematics with user-staged edits;
+ * `worldMatrix.ts` premultiplies the result by the parent's `WorldMatrix`.
+ */
+export const composeLocalMatrix = (live, baseline, edited, out) => {
+    matA.copy(baseline).invert();
+    out.copy(live).multiply(matA).multiply(edited);
+    return out;
+};
+/**
+ * Inverse of `composeLocalMatrix` for the transform controls path:
+ * writes `baseline × live⁻¹ × target` into `out`. Solves for the
+ * `EditedMatrix` that, blended through `composeLocalMatrix`, renders
+ * to `target`.
+ */
+export const solveEditedMatrix = (baseline, live, target, out) => {
+    matA.copy(live).invert();
+    out.copy(baseline).multiply(matA).multiply(target);
+    return out;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viamrobotics/motion-tools",
-  "version": "1.26.1",
+  "version": "1.26.2",
   "description": "Motion visualization with Viam",
   "license": "Apache-2.0",
   "type": "module",
@@ -25,8 +25,8 @@
     "@testing-library/jest-dom": "6.8.0",
     "@testing-library/svelte": "5.2.8",
     "@testing-library/user-event": "^14.6.1",
-    "@threlte/core": "8.5.13",
-    "@threlte/extras": "9.15.2",
+    "@threlte/core": "8.5.14",
+    "@threlte/extras": "9.17.0",
     "@threlte/rapier": "3.4.1",
     "@threlte/xr": "1.6.0",
     "@types/bun": "1.2.21",

package/dist/components/overlay/left-pane/buildTree.d.ts

@@ -1,13 +0,0 @@
-import type { Entity, QueryResult, Trait } from 'koota';
-export interface TreeNode {
-    entity: Entity;
-    parent?: TreeNode;
-    children?: TreeNode[];
-}
-/**
- * Creates a tree representing parent child / relationships from a set of frames.
- */
-export declare const buildTreeNodes: (entities: QueryResult<[Trait]>) => {
-    rootNodes: TreeNode[];
-    nodeMap: Record<string, TreeNode | undefined>;
-};

package/dist/components/overlay/left-pane/buildTree.js

@@ -1,48 +0,0 @@
-import { hierarchy, traits } from '../../../ecs';
-function sortNodes(nodes) {
-    nodes.sort((a, b) => a.entity.get(traits.Name)?.localeCompare(b.entity.get(traits.Name) ?? '') ?? 0);
-}
-/**
- * Creates a tree representing parent child / relationships from a set of frames.
- */
-export const buildTreeNodes = (entities) => {
-    const nodeMap = {};
-    const rootNodes = [];
-    const childNodes = [];
-    for (const entity of entities) {
-        const parent = hierarchy.getParentName(entity);
-        const name = entity.get(traits.Name) ?? '';
-        const node = { entity };
-        nodeMap[name] = node;
-        if (!parent || parent === 'world') {
-            rootNodes.push(node);
-        }
-        else {
-            childNodes.push(node);
-        }
-    }
-    for (const node of childNodes) {
-        const parent = hierarchy.getParentName(node.entity);
-        if (parent) {
-            const parentNode = nodeMap[parent];
-            node.parent = parentNode;
-            if (parentNode) {
-                parentNode.children ??= [];
-                parentNode.children?.push(node);
-            }
-        }
-    }
-    for (const node of rootNodes) {
-        if (!node.children)
-            continue;
-        sortNodes(node.children);
-    }
-    for (const node of childNodes) {
-        if (!node.children)
-            continue;
-        sortNodes(node.children);
-    }
-    sortNodes(rootNodes);
-    sortNodes(childNodes);
-    return { rootNodes, nodeMap };
-};