@viamrobotics/motion-tools 0.1.0

package/dist/components/xr/PointDistance.svelte

@@ -0,0 +1,52 @@
+<script lang="ts">
+	import { T, useTask } from '@threlte/core'
+	import Draggable from './Draggable.svelte'
+	import { Mesh, Vector3 } from 'three'
+	import { Text, Billboard } from '@threlte/extras'
+
+	const mesh1 = new Mesh()
+	const mesh2 = new Mesh()
+	const distance = new Vector3()
+	const midpoint = new Vector3()
+
+	const pos1 = new Vector3()
+	const pos2 = new Vector3()
+
+	let text = $state('')
+	let textPosition = $state<[number, number, number]>([0, 0, 0])
+
+	useTask(() => {
+		distance.subVectors(mesh1.getWorldPosition(pos1), mesh2.getWorldPosition(pos2))
+		midpoint.addVectors(mesh1.getWorldPosition(pos1), mesh2.getWorldPosition(pos2)).divideScalar(2)
+		textPosition = midpoint.toArray()
+
+		const x = (distance.x ?? 0).toFixed(3)
+		const y = (distance.y ?? 0).toFixed(3)
+		const z = (distance.z ?? 0).toFixed(3)
+		text = `${x},${y},${z}`
+	})
+</script>
+
+<T.Group position={[-1, 1, 0]}>
+	<Draggable onPointerEnter={() => null}>
+		<T is={mesh1}>
+			<T.SphereGeometry args={[0.05]} />
+			<T.MeshStandardMaterial />
+		</T>
+	</Draggable>
+</T.Group>
+
+<T.Group position={textPosition}>
+	<Billboard>
+		<Text {text} />
+	</Billboard>
+</T.Group>
+
+<T.Group position={[-1.5, 1, 0]}>
+	<Draggable>
+		<T is={mesh2}>
+			<T.SphereGeometry args={[0.05]} />
+			<T.MeshStandardMaterial />
+		</T>
+	</Draggable>
+</T.Group>

package/dist/components/xr/PointDistance.svelte.d.ts

@@ -0,0 +1,3 @@
+declare const PointDistance: import("svelte").Component<Record<string, never>, {}, "">;
+type PointDistance = ReturnType<typeof PointDistance>;
+export default PointDistance;

package/dist/hooks/index.d.ts

@@ -0,0 +1 @@
+export { provideConnectionConfigs, useConnectionConfigs, useActiveConnectionConfig, } from './useConnectionConfigs.svelte';

package/dist/hooks/index.js

@@ -0,0 +1 @@
+export { provideConnectionConfigs, useConnectionConfigs, useActiveConnectionConfig, } from './useConnectionConfigs.svelte';

package/dist/hooks/useConnectionConfigs.svelte.d.ts

@@ -0,0 +1,17 @@
+interface ConnectionConfig {
+    host: string;
+    partId: string;
+    apiKeyId: string;
+    apiKeyValue: string;
+    signalingAddress: string;
+}
+interface Context {
+    current: ConnectionConfig[];
+}
+export declare const provideConnectionConfigs: () => void;
+export declare const useConnectionConfigs: () => Context;
+export declare const useActiveConnectionConfig: () => {
+    readonly current: ConnectionConfig | undefined;
+    set(index: number | undefined): void;
+};
+export {};

package/dist/hooks/useConnectionConfigs.svelte.js

@@ -0,0 +1,40 @@
+import { get, set } from 'idb-keyval';
+import { PersistedState } from 'runed';
+import { getContext, setContext } from 'svelte';
+import { envDialConfigs } from '../../routes/lib/configs';
+const key = Symbol('connection-config-context');
+const activeConfig = new PersistedState('active-connection-config', 0);
+export const provideConnectionConfigs = () => {
+    let connectionConfigs = $state([]);
+    get('connection-configs').then((response) => {
+        if (Array.isArray(response)) {
+            connectionConfigs = response;
+        }
+    });
+    $effect(() => {
+        set('connection-configs', $state.snapshot(connectionConfigs));
+    });
+    const envConfigs = Object.values(envDialConfigs);
+    setContext(key, {
+        get current() {
+            return [...envConfigs, ...connectionConfigs];
+        },
+    });
+};
+export const useConnectionConfigs = () => {
+    return getContext(key);
+};
+export const useActiveConnectionConfig = () => {
+    const connectionConfigs = useConnectionConfigs();
+    return {
+        get current() {
+            if (activeConfig.current === -1) {
+                return undefined;
+            }
+            return connectionConfigs.current.at(activeConfig.current);
+        },
+        set(index) {
+            activeConfig.current = index ?? -1;
+        },
+    };
+};

package/dist/hooks/useControls.svelte.d.ts

@@ -0,0 +1,7 @@
+interface Context {
+    active: boolean;
+    setActive: (value: boolean) => void;
+}
+export declare const provideTransformControls: () => void;
+export declare const useTransformControls: () => Context;
+export {};

package/dist/hooks/useControls.svelte.js

@@ -0,0 +1,16 @@
+import { getContext, setContext } from 'svelte';
+const key = Symbol('tranform-controls-context');
+export const provideTransformControls = () => {
+    let active = $state(false);
+    setContext(key, {
+        get active() {
+            return active;
+        },
+        setActive(value) {
+            active = value;
+        },
+    });
+};
+export const useTransformControls = () => {
+    return getContext(key);
+};

package/dist/hooks/useDraggable.svelte.d.ts

@@ -0,0 +1,2 @@
+export declare const provideDraggables: () => void;
+export declare const useDraggable: (name: string) => void;

package/dist/hooks/useDraggable.svelte.js

@@ -0,0 +1,25 @@
+import { PersistedState } from 'runed';
+import { setContext } from 'svelte';
+const key = Symbol('draggables-context');
+export const provideDraggables = () => { };
+export const useDraggable = (name) => {
+    const down = { x: 0, y: 0 };
+    const onDragMove = () => { };
+    const onDragStart = (event) => {
+        down.x = event.clientX;
+        down.y = event.clientY;
+    };
+    const onDragEnd = (event) => {
+        translate.current.x += event.clientX - down.x;
+        translate.current.y += event.clientY - down.y;
+    };
+    const translate = new PersistedState(`${name} draggable`, { x: 0, y: 0 });
+    setContext(key, {
+        onDragStart,
+        onDragMove,
+        onDragEnd,
+        get current() {
+            return translate.current;
+        },
+    });
+};

package/dist/hooks/useFrames.svelte.d.ts

@@ -0,0 +1,9 @@
+import { WorldObject } from '../WorldObject';
+interface FramesContext {
+    current: WorldObject[];
+    error?: Error;
+    fetching: boolean;
+}
+export declare const provideFrames: (partID: () => string) => void;
+export declare const useFrames: () => FramesContext;
+export {};

package/dist/hooks/useFrames.svelte.js

@@ -0,0 +1,50 @@
+import { getContext, setContext, untrack } from 'svelte';
+import { useRobotClient, createRobotQuery, useMachineStatus } from '@viamrobotics/svelte-sdk';
+import { WorldObject } from '../WorldObject';
+import { useRefreshRates } from './useRefreshRates.svelte';
+import { observe } from '@threlte/core';
+const key = Symbol('frames-context');
+export const provideFrames = (partID) => {
+    const refreshRates = useRefreshRates();
+    if (!refreshRates.has('Frames')) {
+        refreshRates.set('Frames', 1);
+    }
+    const client = useRobotClient(partID);
+    const query = createRobotQuery(client, 'frameSystemConfig');
+    const machineStatus = useMachineStatus(partID);
+    const revision = $derived(machineStatus.current?.config.revision);
+    const shouldFetch = $derived(refreshRates.get('Frames') === 1);
+    observe.pre(() => [revision], () => {
+        if (shouldFetch) {
+            untrack(() => query.current).refetch();
+        }
+    });
+    const current = $derived.by(() => {
+        const objects = [];
+        if (!shouldFetch) {
+            return objects;
+        }
+        for (const { frame } of query.current.data ?? []) {
+            if (frame) {
+                objects.push(new WorldObject(frame.referenceFrame, frame.poseInObserverFrame?.pose, frame.poseInObserverFrame?.referenceFrame, frame.physicalObject?.geometryType));
+            }
+        }
+        return objects;
+    });
+    const error = $derived(query.current.error ?? undefined);
+    const fetching = $derived(query.current.isFetching);
+    setContext(key, {
+        get current() {
+            return current;
+        },
+        get error() {
+            return error;
+        },
+        get fetching() {
+            return fetching;
+        },
+    });
+};
+export const useFrames = () => {
+    return getContext(key);
+};

package/dist/hooks/useGeometries.svelte.d.ts

@@ -0,0 +1,7 @@
+import { WorldObject } from '../WorldObject';
+interface Context {
+    current: WorldObject[];
+}
+export declare const provideGeometries: (partID: () => string) => void;
+export declare const useGeometries: () => Context;
+export {};

package/dist/hooks/useGeometries.svelte.js

@@ -0,0 +1,58 @@
+import { ArmClient, CameraClient, Geometry } from '@viamrobotics/sdk';
+import { createQueries, queryOptions } from '@tanstack/svelte-query';
+import { createResourceClient, useResourceNames } from '@viamrobotics/svelte-sdk';
+import { setContext, getContext } from 'svelte';
+import { fromStore, toStore } from 'svelte/store';
+import { useRefreshRates } from './useRefreshRates.svelte';
+import { WorldObject } from '../WorldObject';
+import { usePersistentUUIDs } from './usePersistentUUIDs.svelte';
+const key = Symbol('geometries-context');
+export const provideGeometries = (partID) => {
+    const refreshRates = useRefreshRates();
+    const arms = useResourceNames(partID, 'arm');
+    const cameras = useResourceNames(partID, 'camera');
+    const clients = $derived([
+        ...arms.current.map((arm) => createResourceClient(ArmClient, partID, () => arm.name)),
+        ...cameras.current.map((camera) => createResourceClient(CameraClient, partID, () => camera.name)),
+    ]);
+    if (!refreshRates.has('Geometries')) {
+        refreshRates.set('Geometries', 1000);
+    }
+    const options = $derived(clients.map((client) => {
+        const interval = refreshRates.get('Geometries');
+        return queryOptions({
+            enabled: interval !== -1 && client.current !== undefined,
+            refetchInterval: interval === 0 ? false : interval,
+            queryKey: ['partID', partID(), client.current?.name, 'getGeometries'],
+            queryFn: async () => {
+                if (!client.current) {
+                    throw new Error('No client');
+                }
+                const geometries = await client.current.getGeometries();
+                return { name: client.current.name, geometries };
+            },
+        });
+    }));
+    const { updateUUIDs } = usePersistentUUIDs();
+    const queries = fromStore(createQueries({ queries: toStore(() => options) }));
+    const geometries = $derived.by(() => {
+        const results = [];
+        for (const query of queries.current) {
+            if (!query.data)
+                continue;
+            for (const { center, label, geometryType } of query.data.geometries) {
+                results.push(new WorldObject(label, center, query.data.name, geometryType));
+            }
+        }
+        updateUUIDs(results);
+        return results;
+    });
+    setContext(key, {
+        get current() {
+            return geometries;
+        },
+    });
+};
+export const useGeometries = () => {
+    return getContext(key);
+};

package/dist/hooks/useMotionClient.svelte.d.ts

@@ -0,0 +1,8 @@
+interface Context {
+    names: string[];
+    current: string | undefined;
+    set(value?: string | undefined): void;
+}
+export declare const provideMotionClient: (partID: () => string) => void;
+export declare const useMotionClient: () => Context;
+export {};

package/dist/hooks/useMotionClient.svelte.js

@@ -0,0 +1,31 @@
+import { useResourceNames } from '@viamrobotics/svelte-sdk';
+import { getContext, setContext } from 'svelte';
+const key = Symbol('motion-client-context');
+export const provideMotionClient = (partID) => {
+    const motionResources = useResourceNames(partID, 'motion');
+    const motionNames = $derived(motionResources.current.map((resource) => resource.name));
+    let current = $state();
+    $effect.pre(() => {
+        if (current) {
+            return;
+        }
+        if (motionNames.includes('builtin')) {
+            current = 'builtin';
+        }
+        current = motionNames[0];
+    });
+    setContext(key, {
+        get names() {
+            return motionNames;
+        },
+        get current() {
+            return current;
+        },
+        set(value) {
+            current = value;
+        },
+    });
+};
+export const useMotionClient = () => {
+    return getContext(key);
+};

package/dist/hooks/useObjectEvents.svelte.d.ts

@@ -0,0 +1,9 @@
+import { type IntersectionEvent } from '@threlte/extras';
+export declare const useObjectEvents: (uuid: () => string) => {
+    readonly visible: boolean | undefined;
+    onpointerenter: (event: IntersectionEvent<MouseEvent>) => void;
+    onpointerleave: (event: IntersectionEvent<MouseEvent>) => void;
+    ondblclick: (event: IntersectionEvent<MouseEvent>) => void;
+    onclick: (event: IntersectionEvent<MouseEvent>) => void;
+    onpointermissed: () => void;
+};

package/dist/hooks/useObjectEvents.svelte.js

@@ -0,0 +1,31 @@
+import { useCursor } from '@threlte/extras';
+import { useFocused, useSelected } from './useSelection.svelte';
+import { useVisibility } from './useVisibility.svelte';
+export const useObjectEvents = (uuid) => {
+    const { onPointerEnter, onPointerLeave } = useCursor();
+    const selected = useSelected();
+    const focused = useFocused();
+    const visibility = useVisibility();
+    return {
+        get visible() {
+            return visibility.get(uuid());
+        },
+        onpointerenter: (event) => {
+            event.stopPropagation();
+            onPointerEnter();
+        },
+        onpointerleave: (event) => {
+            event.stopPropagation();
+            onPointerLeave();
+        },
+        ondblclick: (event) => {
+            event.stopPropagation();
+            focused.set(uuid());
+        },
+        onclick: (event) => {
+            event.stopPropagation();
+            selected.set(uuid());
+        },
+        onpointermissed: () => selected.set(),
+    };
+};

package/dist/hooks/useObjects.svelte.d.ts

@@ -0,0 +1,7 @@
+import type { WorldObject } from '../WorldObject';
+interface Context {
+    current: WorldObject[];
+}
+export declare const provideObjects: () => void;
+export declare const useObjects: () => Context;
+export {};

package/dist/hooks/useObjects.svelte.js

@@ -0,0 +1,33 @@
+import { getContext, setContext } from 'svelte';
+import { useFrames } from './useFrames.svelte';
+import { useGeometries } from './useGeometries.svelte';
+import { useStaticGeometries } from './useStaticGeometries.svelte';
+import { useShapes } from './useShapes.svelte';
+import { usePointClouds } from './usePointclouds.svelte';
+const key = Symbol('objects-context');
+export const provideObjects = () => {
+    const frames = useFrames();
+    const geometries = useGeometries();
+    const statics = useStaticGeometries();
+    const shapes = useShapes();
+    const points = usePointClouds();
+    const objects = $derived([
+        ...frames.current,
+        ...geometries.current,
+        ...points.current,
+        ...shapes.meshes,
+        ...shapes.models,
+        ...shapes.nurbs,
+        ...shapes.points,
+        ...statics.current,
+        ...shapes.poses,
+    ]);
+    setContext(key, {
+        get current() {
+            return objects;
+        },
+    });
+};
+export const useObjects = () => {
+    return getContext(key);
+};

package/dist/hooks/usePartID.svelte.d.ts

@@ -0,0 +1,6 @@
+interface Context {
+    current: string;
+}
+export declare const createPartIDContext: (partId: () => string) => Context;
+export declare const usePartID: () => Context;
+export {};

package/dist/hooks/usePartID.svelte.js

@@ -0,0 +1,14 @@
+import { getContext, setContext } from 'svelte';
+const key = Symbol('part-id-context');
+export const createPartIDContext = (partId) => {
+    const context = {
+        get current() {
+            return partId();
+        },
+    };
+    setContext(key, context);
+    return context;
+};
+export const usePartID = () => {
+    return getContext(key);
+};

package/dist/hooks/usePersistentUUIDs.svelte.d.ts

@@ -0,0 +1,5 @@
+import type { WorldObject } from '../WorldObject';
+export declare const usePersistentUUIDs: () => {
+    uuids: Map<string, string>;
+    updateUUIDs: (objects: WorldObject[]) => void;
+};

package/dist/hooks/usePersistentUUIDs.svelte.js

@@ -0,0 +1,14 @@
+export const usePersistentUUIDs = () => {
+    const uuids = new Map();
+    const updateUUIDs = (objects) => {
+        if (uuids.size === 0) {
+            for (const object of objects) {
+                uuids.set(object.name, object.uuid);
+            }
+        }
+        for (const object of objects) {
+            object.uuid = uuids.get(object.name) ?? object.uuid;
+        }
+    };
+    return { uuids, updateUUIDs };
+};

package/dist/hooks/usePointclouds.svelte.d.ts

@@ -0,0 +1,7 @@
+import { WorldObject, type PointsGeometry } from '../WorldObject';
+interface Context {
+    current: WorldObject<PointsGeometry>[];
+}
+export declare const providePointclouds: (partID: () => string) => void;
+export declare const usePointClouds: () => Context;
+export {};

package/dist/hooks/usePointclouds.svelte.js

@@ -0,0 +1,58 @@
+import { createQueries, queryOptions } from '@tanstack/svelte-query';
+import { CameraClient } from '@viamrobotics/sdk';
+import { setContext, getContext } from 'svelte';
+import { fromStore, toStore } from 'svelte/store';
+import { createResourceClient, useResourceNames } from '@viamrobotics/svelte-sdk';
+import { parsePCD } from '../loaders/pcd';
+import { useRefreshRates } from './useRefreshRates.svelte';
+import { WorldObject } from '../WorldObject';
+import { usePersistentUUIDs } from './usePersistentUUIDs.svelte';
+const key = Symbol('pointcloud-context');
+export const providePointclouds = (partID) => {
+    const refreshRates = useRefreshRates();
+    const cameras = useResourceNames(partID, 'camera');
+    if (!refreshRates.has('Pointclouds')) {
+        refreshRates.set('Pointclouds', 5000);
+    }
+    const clients = $derived(cameras.current.map((camera) => createResourceClient(CameraClient, partID, () => camera.name)));
+    const options = $derived(clients.map((cameraClient) => {
+        const name = cameraClient.current?.name ?? '';
+        const interval = refreshRates.get('Pointclouds');
+        return queryOptions({
+            enabled: interval !== -1 && cameraClient.current !== undefined,
+            refetchInterval: interval === 0 ? false : interval,
+            queryKey: ['partID', partID(), name, 'getPointCloud'],
+            queryFn: async () => {
+                if (!cameraClient.current) {
+                    throw new Error('No camera client');
+                }
+                const response = await cameraClient.current.getPointCloud();
+                if (!response)
+                    return null;
+                const { positions, colors } = await parsePCD(new Uint8Array(response));
+                return new WorldObject(`${name}:pointcloud`, undefined, name, { case: 'points', value: new Float32Array(positions) }, colors ? { colors: new Float32Array(colors) } : undefined);
+            },
+        });
+    }));
+    const { updateUUIDs } = usePersistentUUIDs();
+    const queries = fromStore(createQueries({
+        queries: toStore(() => options),
+        combine: (results) => {
+            const data = results
+                .flatMap((result) => result.data)
+                .filter((data) => data !== null && data !== undefined);
+            updateUUIDs(data);
+            return {
+                data,
+            };
+        },
+    }));
+    setContext(key, {
+        get current() {
+            return queries.current.data;
+        },
+    });
+};
+export const usePointClouds = () => {
+    return getContext(key);
+};

package/dist/hooks/usePose.svelte.d.ts

@@ -0,0 +1,3 @@
+export declare const usePose: (name: () => string, parent: () => string | undefined) => {
+    readonly current: import("@viamrobotics/sdk/dist/gen/common/v1/common_pb").Pose | undefined;
+};

package/dist/hooks/usePose.svelte.js

@@ -0,0 +1,44 @@
+import { createResourceClient, useResourceNames } from '@viamrobotics/svelte-sdk';
+import { usePartID } from './usePartID.svelte';
+import { MotionClient } from '@viamrobotics/sdk';
+import { createQuery, queryOptions } from '@tanstack/svelte-query';
+import { useRefreshRates } from './useRefreshRates.svelte';
+import { fromStore, toStore } from 'svelte/store';
+import { useMotionClient } from './useMotionClient.svelte';
+export const usePose = (name, parent) => {
+    const refreshRates = useRefreshRates();
+    const partID = usePartID();
+    const motionClient = useMotionClient();
+    const resources = useResourceNames(() => partID.current);
+    const resource = $derived(resources.current.find((resource) => resource.name === name()));
+    const client = createResourceClient(MotionClient, () => partID.current, () => motionClient.current ?? '');
+    const interval = refreshRates.get('Poses');
+    const options = $derived(queryOptions({
+        enabled: interval !== -1 && client.current !== undefined && resource !== undefined,
+        refetchInterval: interval === 0 ? false : interval,
+        queryKey: [
+            'partID',
+            partID.current,
+            client.current?.name,
+            'getPose',
+            resource?.name,
+            parent(),
+        ],
+        queryFn: async () => {
+            if (!client.current || !resource) {
+                throw new Error('No client');
+            }
+            const pose = await client.current.getPose(resource, parent() ?? 'world', []);
+            return pose;
+        },
+    }));
+    const query = fromStore(createQuery(toStore(() => options)));
+    return {
+        get current() {
+            if (resource?.subtype === 'arm') {
+                return;
+            }
+            return query.current.data?.pose;
+        },
+    };
+};

package/dist/hooks/usePoses.svelte.d.ts

@@ -0,0 +1,12 @@
+import { PoseInFrame, ResourceName } from '@viamrobotics/sdk';
+type PoseWithComponent = PoseInFrame & {
+    component: ResourceName;
+};
+interface Context {
+    current: {
+        [k: string]: PoseWithComponent | undefined;
+    };
+}
+export declare const providePoses: (partID: () => string) => void;
+export declare const usePoses: () => Context;
+export {};