@viamrobotics/motion-tools 1.13.0 → 1.14.0

package/dist/hooks/usePointclouds.svelte.js

@@ -8,9 +8,6 @@ import { RefetchRates } from '../components/overlay/RefreshRate.svelte';
 import { traits, useWorld } from '../ecs';
 import { useEnvironment } from './useEnvironment.svelte';
 import { createBufferGeometry, updateBufferGeometry } from '../attribute';
-const typeSafeObjectFromEntries = (entries) => {
-    return Object.fromEntries(entries);
-};
 const key = Symbol('pointcloud-context');
 export const providePointclouds = (partID) => {
     const environment = useEnvironment();
@@ -50,10 +47,8 @@ export const providePointclouds = (partID) => {
      */
     $effect(() => {
         for (const [name, query] of propQueries) {
-            if (name && query.data?.supportsPcd === false) {
-                if (disabledCameras.get(name) === undefined) {
-                    disabledCameras.set(name, true);
-                }
+            if (name && query.data?.supportsPcd === false && disabledCameras.get(name) === undefined) {
+                disabledCameras.set(name, true);
             }
         }
     });
@@ -62,7 +57,6 @@ export const providePointclouds = (partID) => {
         refetchInterval: interval === RefetchRates.MANUAL ? false : interval,
     });
     const queries = $derived(enabledClients.map((client) => [client.current.name, createResourceQuery(client, 'getPointCloud', () => options)]));
-    const queryMap = $derived(typeSafeObjectFromEntries(queries));
     $effect(() => {
         for (const [name, query] of queries) {
             untrack(() => {
@@ -79,39 +73,63 @@ export const providePointclouds = (partID) => {
     });
     const entities = new Map();
     $effect(() => {
+        const currentPartID = partID();
+        const activeQueryKeys = new Set();
         for (const [name, query] of queries) {
-            untrack(() => {
-                $effect(() => {
-                    const { data } = query;
-                    if (!data || data.length === 0)
+            const queryKey = `${currentPartID}:${name}`;
+            activeQueryKeys.add(queryKey);
+            $effect(() => {
+                const { data } = query;
+                let disposed = false;
+                const destroyEntity = () => {
+                    const entity = entities.get(queryKey);
+                    if (entity) {
+                        if (world.has(entity))
+                            entity.destroy();
+                        entities.delete(queryKey);
+                    }
+                };
+                if (!data || data.length === 0) {
+                    destroyEntity();
+                    return () => {
+                        disposed = true;
+                    };
+                }
+                parsePcdInWorker(data)
+                    .then(({ positions, colors }) => {
+                    if (disposed) {
                         return;
-                    parsePcdInWorker(data)
-                        .then(({ positions, colors }) => {
-                        const existing = entities.get(name);
-                        if (existing) {
-                            const geometry = existing.get(traits.BufferGeometry);
-                            if (geometry) {
-                                updateBufferGeometry(geometry, positions, colors);
-                                return;
-                            }
+                    }
+                    const existing = entities.get(queryKey);
+                    if (existing) {
+                        const geometry = existing.get(traits.BufferGeometry);
+                        if (geometry) {
+                            updateBufferGeometry(geometry, positions, colors);
+                            return;
                         }
-                        const geometry = createBufferGeometry(positions, colors);
-                        const entity = world.spawn(traits.Parent(name), traits.Name(`${name} pointcloud`), traits.BufferGeometry(geometry), traits.Points);
-                        entities.set(name, entity);
-                    })
-                        .catch((error) => {
-                        logs.add(error.reason, 'error');
-                    });
+                    }
+                    const geometry = createBufferGeometry(positions, colors);
+                    const entity = world.spawn(traits.Parent(name), traits.Name(`${name} pointcloud`), traits.BufferGeometry(geometry), traits.Points);
+                    entities.set(queryKey, entity);
+                })
+                    .catch((error) => {
+                    if (disposed) {
+                        return;
+                    }
+                    logs.add(error?.reason ?? error?.message ?? 'Failed to parse pointcloud', 'error');
                 });
+                return () => {
+                    disposed = true;
+                };
             });
         }
-        // Clean up old entities
-        for (const [name, entity] of entities) {
-            if (!queryMap[name]?.data) {
+        // clean up queries that disappeared entirely
+        for (const [queryKey, entity] of entities) {
+            if (!activeQueryKeys.has(queryKey)) {
                 if (world.has(entity)) {
                     entity.destroy();
                 }
-                entities.delete(name);
+                entities.delete(queryKey);
             }
         }
     });

package/dist/hooks/usePose.svelte.js

@@ -10,7 +10,7 @@ import { RefetchRates } from '../components/overlay/RefreshRate.svelte';
 import { useLogs } from './useLogs.svelte';
 import { useResourceByName } from './useResourceByName.svelte';
 import { useRefetchPoses } from './useRefetchPoses';
-const origingFrameComponentTypes = ['arm', 'gantry', 'gripper', 'base'];
+const originFrameComponentTypes = new Set(['arm', 'gantry', 'gripper', 'base']);
 export const usePose = (name, parent) => {
     const environment = useEnvironment();
     const logs = useLogs();
@@ -26,12 +26,8 @@ export const usePose = (name, parent) => {
     const frames = useFrames();
     let pose = $state();
     const interval = $derived(refreshRates.get(RefreshRates.poses));
-    const resolvedParent = $derived(origingFrameComponentTypes.includes(parentResource?.subtype ?? '')
-        ? `${parent()}_origin`
-        : parent());
-    const resolvedName = $derived(origingFrameComponentTypes.includes(resource?.subtype ?? '')
-        ? `${currentName}_origin`
-        : currentName);
+    const resolvedParent = $derived(originFrameComponentTypes.has(parentResource?.subtype ?? '') ? `${parent()}_origin` : parent());
+    const resolvedName = $derived(originFrameComponentTypes.has(resource?.subtype ?? '') ? `${currentName}_origin` : currentName);
     const query = createRobotQuery(robotClient, 'getPose', () => [resolvedName, resolvedParent ?? 'world', []], () => ({
         enabled: interval !== RefetchRates.OFF && environment.current.viewerMode === 'monitor',
         refetchInterval: interval === RefetchRates.MANUAL ? false : interval,

package/dist/hooks/useResizable.svelte.js

@@ -28,10 +28,11 @@ export const useResizable = (name, defaultDimensions) => {
         });
         observer.observe(target);
     };
+    const disconnect = () => {
+        observer?.disconnect();
+    };
     $effect(() => {
-        return () => {
-            observer?.disconnect();
-        };
+        return disconnect;
     });
     return {
         get current() {

package/dist/hooks/useSettings.svelte.js

@@ -30,11 +30,11 @@ const defaults = () => ({
     renderSubEntityHoverDetail: false,
     xrController: {
         left: {
-            scaleFactor: 1.0,
+            scaleFactor: 1,
             rotationEnabled: true,
         },
         right: {
-            scaleFactor: 1.0,
+            scaleFactor: 1,
             rotationEnabled: true,
         },
     },

package/dist/hooks/useWeblabs.svelte.js

@@ -17,6 +17,7 @@ const addCookie = (name, value, days, path = '/') => {
         date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000); // days in milliseconds
         expires = '; expires=' + date.toUTCString();
     }
+    // eslint-disable-next-line unicorn/no-document-cookie
     document.cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}${expires}; path=${path}`;
 };
 const getCookieExperiments = () => {
@@ -44,10 +45,10 @@ export const createWeblabs = () => {
     };
 };
 export const provideWeblabs = () => {
-    const urlExperiment = new URLSearchParams(window.location.search).get('experiment');
+    const urlExperiment = new URLSearchParams(globalThis.location.search).get('experiment');
     if (urlExperiment) {
         const experimentSet = new Set([...getCookieExperiments(), urlExperiment]);
-        addCookie('weblab_experiments', Array.from(experimentSet).join(','));
+        addCookie('weblab_experiments', [...experimentSet].join(','));
     }
     setContext(WEBLABS_CONTEXT_KEY, createWeblabs());
 };

package/dist/hooks/useWorldState.svelte.js

@@ -1,6 +1,8 @@
 import { WorldStateStoreClient, TransformChangeType, } from '@viamrobotics/sdk';
 import { createResourceClient, createResourceQuery, createResourceStream, useResourceNames, } from '@viamrobotics/svelte-sdk';
-import { parseMetadata } from '../WorldObject.svelte';
+import { parseMetadata } from '../metadata';
+import { asColor, asOpacity, isPerVertexColors, STRIDE } from '../buffer';
+import { Color } from 'three';
 import { usePartID } from './usePartID.svelte';
 import { traits, useWorld } from '../ecs';
 import { createPose } from '../transform';
@@ -9,6 +11,7 @@ import { createBox, createCapsule, createSphere } from '../geometry';
 import { parsePlyInput } from '../ply';
 import { parsePcdInWorker } from '../loaders/pcd';
 import { createBufferGeometry } from '../attribute';
+const colorUtil = new Color();
 export const provideWorldStates = () => {
     const partID = usePartID();
     const resourceNames = useResourceNames(() => partID.current, 'world_state_store');
@@ -40,46 +43,43 @@ const createWorldState = (client) => {
         if (parent && parent !== 'world') {
             entityTraits.push(traits.Parent(parent));
         }
-        if (metadata.color) {
-            entityTraits.push(traits.Color(metadata.color));
-        }
-        if (metadata.colors) {
-            entityTraits.push(traits.VertexColors(metadata.colors));
-        }
         if (transform.physicalObject) {
             if (transform.physicalObject.geometryType.case === 'pointcloud') {
+                const metadataColors = metadata.colors;
                 parsePcdInWorker(new Uint8Array(transform.physicalObject.geometryType.value.pointCloud)).then((pointcloud) => {
-                    // pcds are a special case since they have to be loaded in a worker and the trait will be added to the existing entity
                     const entity = entities.get(transform.uuidString);
                     if (!entity) {
                         console.error('Entity not found to add pointcloud trait to', transform.uuidString);
                         return;
                     }
-                    const geometry = createBufferGeometry(pointcloud.positions, pointcloud.colors);
+                    const numPoints = pointcloud.positions.length / STRIDE.POSITIONS;
+                    const vertexColors = metadataColors && isPerVertexColors(metadataColors, numPoints)
+                        ? metadataColors
+                        : pointcloud.colors;
+                    const geometry = createBufferGeometry(pointcloud.positions, vertexColors);
                     entity.add(traits.BufferGeometry(geometry));
                     entity.add(traits.Points);
+                    if (metadataColors && !isPerVertexColors(metadataColors, numPoints)) {
+                        asColor(metadataColors, colorUtil);
+                        entity.add(traits.Color({ r: colorUtil.r, g: colorUtil.g, b: colorUtil.b }));
+                        if (metadataColors.length % STRIDE.COLORS_RGBA === 0) {
+                            entity.add(traits.Opacity(asOpacity(metadataColors)));
+                        }
+                    }
+                    invalidate();
                 });
             }
             else {
+                if (metadata.colors) {
+                    asColor(metadata.colors, colorUtil);
+                    entityTraits.push(traits.Color({ r: colorUtil.r, g: colorUtil.g, b: colorUtil.b }));
+                    if (metadata.colors.length % STRIDE.COLORS_RGBA === 0) {
+                        entityTraits.push(traits.Opacity(asOpacity(metadata.colors)));
+                    }
+                }
                 entityTraits.push(traits.Geometry(transform.physicalObject));
             }
         }
-        if (metadata.shape === 'line' && metadata.points) {
-            const { points } = metadata;
-            const positions = new Float32Array(points.length * 3);
-            for (let i = 0, j = 0, l = points.length * 3; i < l; i += 3, j += 1) {
-                positions[i + 0] = points[j].x;
-                positions[i + 1] = points[j].y;
-                positions[i + 2] = points[j].z;
-            }
-            entityTraits.push(traits.LinePositions(positions), traits.PointColor(metadata.lineDotColor));
-        }
-        if (metadata.gltf) {
-            entityTraits.push(traits.GLTF({ source: { gltf: metadata.gltf }, animationName: '' }));
-        }
-        if (metadata.shape === 'arrow') {
-            entityTraits.push(traits.Arrow);
-        }
         entityTraits.push(traits.Name(transform.referenceFrame), traits.Pose(pose), traits.ShowAxesHelper, traits.WorldStateStoreAPI);
         const entity = world.spawn(...entityTraits);
         entities.set(transform.uuidString, entity);
@@ -189,15 +189,17 @@ const createWorldState = (client) => {
                 continue;
             }
             switch (event.changeType) {
-                case TransformChangeType.REMOVED:
+                case TransformChangeType.REMOVED: {
                     eventsByUUID.set(uuid, event);
                     break;
-                case TransformChangeType.ADDED:
+                }
+                case TransformChangeType.ADDED: {
                     if (existing.changeType !== TransformChangeType.REMOVED) {
                         eventsByUUID.set(uuid, event);
                     }
                     break;
-                case TransformChangeType.UPDATED:
+                }
+                case TransformChangeType.UPDATED: {
                     // merge with existing updated event
                     if (existing.changeType === TransformChangeType.UPDATED) {
                         existing.updatedFields ??= { paths: [] };
@@ -214,6 +216,7 @@ const createWorldState = (client) => {
                         eventsByUUID.set(uuid, event);
                     }
                     break;
+                }
             }
         }
         pendingEvents.push(...eventsByUUID.values());

package/dist/loaders/pcd/index.js

@@ -22,6 +22,7 @@ export const parsePcdInWorker = (data) => {
     return new Promise((resolve, reject) => {
         const id = ++requestId;
         pending.set(id, { resolve, reject });
-        worker.postMessage({ id, data }, [data.buffer]);
+        const copy = new Uint8Array(data);
+        worker.postMessage({ id, data: copy }, [copy.buffer]);
     });
 };