@viamrobotics/motion-tools 1.15.7 → 1.16.0

package/dist/buf/common/v1/common_pb.d.ts

@@ -668,6 +668,44 @@ export declare class DoCommandResponse extends Message<DoCommandResponse> {
     static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): DoCommandResponse;
     static equals(a: DoCommandResponse | PlainMessage<DoCommandResponse> | undefined, b: DoCommandResponse | PlainMessage<DoCommandResponse> | undefined): boolean;
 }
+/**
+ * GetStatusRequest represents a generic GetStatus input
+ *
+ * @generated from message viam.common.v1.GetStatusRequest
+ */
+export declare class GetStatusRequest extends Message<GetStatusRequest> {
+    /**
+     * @generated from field: string name = 1;
+     */
+    name: string;
+    constructor(data?: PartialMessage<GetStatusRequest>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "viam.common.v1.GetStatusRequest";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetStatusRequest;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetStatusRequest;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetStatusRequest;
+    static equals(a: GetStatusRequest | PlainMessage<GetStatusRequest> | undefined, b: GetStatusRequest | PlainMessage<GetStatusRequest> | undefined): boolean;
+}
+/**
+ * GetStatusResponse represents a generic GetStatus output
+ *
+ * @generated from message viam.common.v1.GetStatusResponse
+ */
+export declare class GetStatusResponse extends Message<GetStatusResponse> {
+    /**
+     * @generated from field: google.protobuf.Struct result = 1;
+     */
+    result?: Struct;
+    constructor(data?: PartialMessage<GetStatusResponse>);
+    static readonly runtime: typeof proto3;
+    static readonly typeName = "viam.common.v1.GetStatusResponse";
+    static readonly fields: FieldList;
+    static fromBinary(bytes: Uint8Array, options?: Partial<BinaryReadOptions>): GetStatusResponse;
+    static fromJson(jsonValue: JsonValue, options?: Partial<JsonReadOptions>): GetStatusResponse;
+    static fromJsonString(jsonString: string, options?: Partial<JsonReadOptions>): GetStatusResponse;
+    static equals(a: GetStatusResponse | PlainMessage<GetStatusResponse> | undefined, b: GetStatusResponse | PlainMessage<GetStatusResponse> | undefined): boolean;
+}
 /**
  * @generated from message viam.common.v1.GetKinematicsRequest
  */

package/dist/buf/common/v1/common_pb.js

@@ -968,6 +968,70 @@ export class DoCommandResponse extends Message {
         return proto3.util.equals(DoCommandResponse, a, b);
     }
 }
+/**
+ * GetStatusRequest represents a generic GetStatus input
+ *
+ * @generated from message viam.common.v1.GetStatusRequest
+ */
+export class GetStatusRequest extends Message {
+    /**
+     * @generated from field: string name = 1;
+     */
+    name = "";
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "viam.common.v1.GetStatusRequest";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "name", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+    ]);
+    static fromBinary(bytes, options) {
+        return new GetStatusRequest().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetStatusRequest().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetStatusRequest().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetStatusRequest, a, b);
+    }
+}
+/**
+ * GetStatusResponse represents a generic GetStatus output
+ *
+ * @generated from message viam.common.v1.GetStatusResponse
+ */
+export class GetStatusResponse extends Message {
+    /**
+     * @generated from field: google.protobuf.Struct result = 1;
+     */
+    result;
+    constructor(data) {
+        super();
+        proto3.util.initPartial(data, this);
+    }
+    static runtime = proto3;
+    static typeName = "viam.common.v1.GetStatusResponse";
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "result", kind: "message", T: Struct },
+    ]);
+    static fromBinary(bytes, options) {
+        return new GetStatusResponse().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new GetStatusResponse().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new GetStatusResponse().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto3.util.equals(GetStatusResponse, a, b);
+    }
+}
 /**
  * @generated from message viam.common.v1.GetKinematicsRequest
  */

package/dist/buf/draw/v1/scene_pb.d.ts

@@ -52,11 +52,15 @@ export declare enum RenderShapes {
     NURBS = 5
 }
 /**
- * for orthographic camera props
- *
  * @generated from message draw.v1.OrthographicCamera
  */
 export declare class OrthographicCamera extends Message<OrthographicCamera> {
+    /**
+     * for orthographic camera props
+     *
+     * @generated from field: optional float zoom = 1;
+     */
+    zoom?: number;
     constructor(data?: PartialMessage<OrthographicCamera>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "draw.v1.OrthographicCamera";

package/dist/buf/draw/v1/scene_pb.js

@@ -73,18 +73,24 @@ proto3.util.setEnumType(RenderShapes, "draw.v1.RenderShapes", [
     { no: 5, name: "RENDER_SHAPES_NURBS" },
 ]);
 /**
- * for orthographic camera props
- *
  * @generated from message draw.v1.OrthographicCamera
  */
 export class OrthographicCamera extends Message {
+    /**
+     * for orthographic camera props
+     *
+     * @generated from field: optional float zoom = 1;
+     */
+    zoom;
     constructor(data) {
         super();
         proto3.util.initPartial(data, this);
     }
     static runtime = proto3;
     static typeName = "draw.v1.OrthographicCamera";
-    static fields = proto3.util.newFieldList(() => []);
+    static fields = proto3.util.newFieldList(() => [
+        { no: 1, name: "zoom", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
+    ]);
     static fromBinary(bytes, options) {
         return new OrthographicCamera().fromBinary(bytes, options);
     }

package/dist/components/Entities/Geometry.svelte

@@ -49,7 +49,7 @@ Renders a Viam Geometry object
 			return
 		}
 
-		return models.current[componentName]?.[id].clone()
+		return models.current[componentName]?.[id]?.clone() ?? undefined
 	})
 
 	$effect.pre(() => {

package/dist/components/PCD.svelte

@@ -9,9 +9,10 @@
 		data: Uint8Array
 		name?: string
 		renderOrder?: number
+		oncreate?: (positions: Float32Array, colors: Uint8Array | null) => void
 	}
 
-	let { data, name, renderOrder }: Props = $props()
+	let { data, name, renderOrder, oncreate }: Props = $props()
 
 	const world = useWorld()
 
@@ -32,6 +33,8 @@
 			}
 
 			entity = world.spawn(...entityTraits)
+
+			oncreate?.(positions, colors)
 		})
 
 		return () => {

package/dist/components/PCD.svelte.d.ts

@@ -2,6 +2,7 @@ interface Props {
     data: Uint8Array;
     name?: string;
     renderOrder?: number;
+    oncreate?: (positions: Float32Array, colors: Uint8Array | null) => void;
 }
 declare const PCD: import("svelte").Component<Props, {}, "">;
 type PCD = ReturnType<typeof PCD>;

package/dist/components/SceneProviders.svelte

@@ -16,7 +16,6 @@
 	import { provideGeometries } from '../hooks/useGeometries.svelte'
 	import { provideLinkedEntities } from '../hooks/useLinked.svelte'
 	import { provideLogs } from '../hooks/useLogs.svelte'
-	import { provideMachineSettings } from '../hooks/useMachineSettings.svelte'
 	import { usePartID } from '../hooks/usePartID.svelte'
 	import { providePointcloudObjects } from '../hooks/usePointcloudObjects.svelte'
 	import { providePointclouds } from '../hooks/usePointclouds.svelte'
@@ -37,7 +36,6 @@
 
 	provideCameraControls(() => cameraPose)
 	provideTransformControls()
-	provideMachineSettings()
 	provideLogs()
 
 	provideOrigin()

package/dist/components/{Lasso → Selection}/Debug.svelte

@@ -1,7 +1,7 @@
 <!--
 @component
 
-Shows all steps for querying points within a lasso selection
+Shows all steps for querying points within a selection
 -->
 <script lang="ts">
 	import type { Entity } from 'koota'
@@ -11,22 +11,22 @@ Shows all steps for querying points within a lasso selection
 
 	import { traits, useTrait } from '../../ecs'
 
-	import * as lassoTraits from './traits'
+	import * as selectionTraits from './traits'
 
 	const box3 = new Box3()
 	const min = new Vector3()
 	const max = new Vector3()
 
 	interface Props {
-		lasso: Entity
+		selection: Entity
 	}
 
-	let { lasso }: Props = $props()
+	let { selection }: Props = $props()
 
-	const indices = useTrait(() => lasso, lassoTraits.Indices)
-	const positions = useTrait(() => lasso, traits.LinePositions)
-	const box = useTrait(() => lasso, lassoTraits.Box)
-	const boxes = useTrait(() => lasso, lassoTraits.Boxes)
+	const indices = useTrait(() => selection, selectionTraits.Indices)
+	const positions = useTrait(() => selection, traits.LinePositions)
+	const box = useTrait(() => selection, selectionTraits.Box)
+	const boxes = useTrait(() => selection, selectionTraits.Boxes)
 
 	const geometry = new BufferGeometry()
 

package/dist/components/{Lasso → Selection}/Debug.svelte.d.ts

@@ -1,8 +1,8 @@
 import type { Entity } from 'koota';
 interface Props {
-    lasso: Entity;
+    selection: Entity;
 }
-/** Shows all steps for querying points within a lasso selection */
+/** Shows all steps for querying points within a selection */
 declare const Debug: import("svelte").Component<Props, {}, "">;
 type Debug = ReturnType<typeof Debug>;
 export default Debug;

package/dist/components/Selection/Ellipse.svelte

@@ -0,0 +1,293 @@
+<script lang="ts">
+	import type { ShapecastCallbacks } from 'three-mesh-bvh'
+
+	import { useThrelte } from '@threlte/core'
+	import earcut from 'earcut'
+	import { Not } from 'koota'
+	import { Box3, Triangle, Vector3 } from 'three'
+
+	import { createBufferGeometry } from '../../attribute'
+	import { traits, useQuery, useWorld } from '../../ecs'
+	import { useCameraControls } from '../../hooks/useControls.svelte'
+
+	import Debug from './Debug.svelte'
+	import * as selectionTraits from './traits'
+	import { getTriangleBoxesFromIndices, getTriangleFromIndex, raycast } from './utils'
+
+	interface Props {
+		active?: boolean
+		debug?: boolean
+	}
+
+	let { active = false, debug = false }: Props = $props()
+
+	const world = useWorld()
+	const controls = useCameraControls()
+	const { scene, dom, camera } = useThrelte()
+
+	const box3 = new Box3()
+	const min = new Vector3()
+	const max = new Vector3()
+
+	const triangle = new Triangle()
+	const triangleBox = new Box3()
+
+	let frameScheduled = false
+	let drawing = false
+
+	const onpointerdown = (event: PointerEvent) => {
+		if (!event.shiftKey || !active) return
+
+		const { x, y } = raycast(event, camera.current)
+
+		drawing = true
+
+		world.spawn(
+			traits.LinePositions(new Float32Array([x, y, 0])),
+			selectionTraits.StartPoint({ x, y }),
+			traits.LineWidth(1.5),
+			traits.RenderOrder(999),
+			traits.Material({ depthTest: false }),
+			traits.Color({ r: 1, g: 0, b: 0 }),
+			selectionTraits.Box({ minX: x, minY: y, maxX: x, maxY: y }),
+			selectionTraits.Ellipse
+		)
+
+		if (controls.current) {
+			controls.current.enabled = false
+		}
+	}
+
+	const onpointermove = (event: PointerEvent) => {
+		if (!drawing || !active) return
+
+		let ellipse = world.query(selectionTraits.Ellipse).at(-1)
+
+		if (!ellipse) return
+
+		if (frameScheduled) return
+
+		frameScheduled = true
+
+		/**
+		 * pointermove can execute at a rate much higher than screen
+		 * refresh, creating huge polygon vertex counts, so we cap it.
+		 */
+		requestAnimationFrame(() => {
+			frameScheduled = false
+
+			const { x, y } = raycast(event, camera.current)
+			const positions = ellipse.get(traits.LinePositions)
+			const startPoint = ellipse.get(selectionTraits.StartPoint)
+			const box = ellipse.get(selectionTraits.Box)
+
+			if (!positions || !box || !startPoint) return
+
+			let minX = startPoint.x
+			let minY = startPoint.y
+			let maxX = startPoint.x
+			let maxY = startPoint.y
+
+			if (x < minX) minX = x
+			else if (x > maxX) maxX = x
+
+			if (y < minY) minY = y
+			else if (y > maxY) maxY = y
+
+			const nextPositions = ellipsePoints(minX, maxX, minY, maxY, 100)
+
+			ellipse.set(traits.LinePositions, new Float32Array(nextPositions))
+			ellipse.set(selectionTraits.Box, { minX, minY, maxX, maxY })
+		})
+	}
+
+	const ellipsePoints = (
+		minX: number,
+		maxX: number,
+		minY: number,
+		maxY: number,
+		numPoints: number
+	): Float32Array => {
+		const cx = (minX + maxX) / 2
+		const cy = (minY + maxY) / 2
+		const rx = (maxX - minX) / 2
+		const ry = (maxY - minY) / 2
+
+		const points = new Float32Array(numPoints * 3)
+
+		for (let i = 0; i < numPoints; i++) {
+			const t = (i / numPoints) * 2 * Math.PI
+
+			points[i * 3] = cx + rx * Math.cos(t)
+			points[i * 3 + 1] = cy + ry * Math.sin(t)
+			points[i * 3 + 2] = 0
+		}
+
+		return points
+	}
+
+	const onpointerleave = () => {
+		if (!drawing || !active) return
+
+		onpointerup()
+	}
+
+	const onpointerup = () => {
+		if (!drawing || !active) return
+
+		drawing = false
+
+		let ellipse = world.query(selectionTraits.Ellipse).at(-1)
+
+		if (!ellipse) return
+
+		let positions = ellipse.get(traits.LinePositions)
+
+		if (!positions) return
+
+		if (controls.current) {
+			controls.current.enabled = true
+		}
+
+		const indices = earcut(positions, undefined, 3)
+		if (debug) {
+			ellipse.add(selectionTraits.Indices(new Uint16Array(indices)))
+		}
+
+		const boxes: selectionTraits.AABB[] = getTriangleBoxesFromIndices(indices, positions)
+		if (debug) {
+			ellipse.add(selectionTraits.Boxes(boxes))
+		}
+
+		const ellipseBox = ellipse.get(selectionTraits.Box)
+
+		if (!ellipseBox) return
+
+		min.set(ellipseBox.minX, ellipseBox.minY, Number.NEGATIVE_INFINITY)
+		max.set(ellipseBox.maxX, ellipseBox.maxY, Number.POSITIVE_INFINITY)
+		box3.set(min, max)
+
+		const enclosedPoints: number[] = []
+
+		for (const pointsEntity of world.query(
+			traits.Points,
+			Not(selectionTraits.SelectionEnclosedPoints)
+		)) {
+			const geometry = pointsEntity.get(traits.BufferGeometry)
+
+			if (!geometry) return
+
+			const points = scene.getObjectByName(pointsEntity as unknown as string)
+
+			if (!points) {
+				return
+			}
+
+			geometry.boundsTree?.shapecast({
+				intersectsBounds: (box) => {
+					return box.intersectsBox(box3)
+				},
+
+				intersectsPoint: (point: Vector3) => {
+					for (let i = 0, j = 0, l = indices.length; i < l; i += 3, j += 1) {
+						const { minX, minY, maxX, maxY } = boxes[j]
+
+						min.set(minX, minY, Number.NEGATIVE_INFINITY)
+						max.set(maxX, maxY, Number.POSITIVE_INFINITY)
+						triangleBox.set(min, max)
+
+						if (triangleBox.containsPoint(point)) {
+							getTriangleFromIndex(i, indices, positions, triangle)
+
+							if (triangle.containsPoint(point)) {
+								enclosedPoints.push(point.x, point.y, point.z)
+							}
+						}
+					}
+				},
+				// intersectsPoint is not yet in typedef, this can be removed when it is added
+			} as ShapecastCallbacks)
+		}
+
+		const ellipseResultGeometry = createBufferGeometry(new Float32Array(enclosedPoints))
+
+		world.spawn(
+			traits.Name('Ellipse result'),
+			traits.BufferGeometry(ellipseResultGeometry),
+			traits.Color({ r: 1, g: 0, b: 0 }),
+			traits.RenderOrder(999),
+			traits.Material({ depthTest: false }),
+			traits.Points,
+			traits.Removable,
+			selectionTraits.SelectionEnclosedPoints,
+			selectionTraits.PointsCapturedBy(ellipse)
+		)
+	}
+
+	const onkeydown = (event: KeyboardEvent) => {
+		if (event.key === 'Shift') {
+			dom.style.cursor = 'crosshair'
+		}
+	}
+
+	const onkeyup = (event: KeyboardEvent) => {
+		if (event.key === 'Shift') {
+			dom.style.removeProperty('cursor')
+		}
+	}
+
+	$effect(() => {
+		globalThis.addEventListener('keydown', onkeydown)
+		globalThis.addEventListener('keyup', onkeyup)
+		dom.addEventListener('pointerdown', onpointerdown)
+		dom.addEventListener('pointermove', onpointermove)
+		dom.addEventListener('pointerup', onpointerup)
+		dom.addEventListener('pointerleave', onpointerleave)
+
+		return () => {
+			globalThis.removeEventListener('keydown', onkeydown)
+			globalThis.removeEventListener('keyup', onkeyup)
+			dom.removeEventListener('pointerdown', onpointerdown)
+			dom.removeEventListener('pointermove', onpointermove)
+			dom.removeEventListener('pointerup', onpointerup)
+			dom.removeEventListener('pointerleave', onpointerleave)
+		}
+	})
+
+	const ellipses = useQuery(selectionTraits.Ellipse)
+
+	$effect(() => {
+		if (!controls.current) return
+
+		const currentControls = controls.current
+
+		const { minPolarAngle, maxPolarAngle } = currentControls
+
+		// Locks the camera to top down while this component is mounted
+		currentControls.polarAngle = 0
+		currentControls.minPolarAngle = 0
+		currentControls.maxPolarAngle = 0
+
+		return () => {
+			currentControls.minPolarAngle = minPolarAngle
+			currentControls.maxPolarAngle = maxPolarAngle
+		}
+	})
+
+	// On unmount, destroy all lasso related entities
+	$effect(() => {
+		return () => {
+			for (const entity of world.query(selectionTraits.SelectionEnclosedPoints)) {
+				if (world.has(entity)) {
+					entity.destroy()
+				}
+			}
+		}
+	})
+</script>
+
+{#if debug}
+	{#each ellipses.current as ellipse (ellipse)}
+		<Debug selection={ellipse} />
+	{/each}
+{/if}

package/dist/components/Selection/Ellipse.svelte.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    active?: boolean;
+    debug?: boolean;
+}
+declare const Ellipse: import("svelte").Component<Props, {}, "">;
+type Ellipse = ReturnType<typeof Ellipse>;
+export default Ellipse;