@viamrobotics/motion-tools 1.11.0 → 1.12.0

package/dist/plugins/bvh.svelte.js

@@ -0,0 +1,74 @@
+import { injectPlugin, isInstanceOf } from '@threlte/core';
+import { BatchedMesh, Points, Mesh } from 'three';
+import { acceleratedRaycast, computeBoundsTree, disposeBoundsTree, computeBatchedBoundsTree, disposeBatchedBoundsTree, PointsBVH, SAH, BVHHelper, } from 'three-mesh-bvh';
+export const bvh = (raycaster, options) => {
+    const bvhOptions = $derived({
+        strategy: SAH,
+        verbose: false,
+        setBoundingBox: true,
+        maxDepth: 20,
+        maxLeafSize: 10,
+        indirect: false,
+        helper: false,
+        ...options?.(),
+    });
+    raycaster.firstHitOnly = true;
+    raycaster.params.Points.threshold = 0.005;
+    injectPlugin('bvh', (args) => {
+        const { props } = $derived(args);
+        const opts = $derived(props.bvh ? { ...bvhOptions, ...props.bvh } : bvhOptions);
+        $effect(() => {
+            const { ref } = args;
+            if (opts.enabled === false) {
+                return;
+            }
+            if (isInstanceOf(ref, 'Points')) {
+                ref.geometry.computeBoundsTree = computeBoundsTree;
+                ref.geometry.disposeBoundsTree = disposeBoundsTree;
+                ref.raycast = acceleratedRaycast;
+                computeBoundsTree.call(ref.geometry, { type: PointsBVH, ...opts });
+                const helper = opts.helper ? new BVHHelper(ref) : undefined;
+                if (helper)
+                    ref.add(helper);
+                return () => {
+                    ref.raycast = Points.prototype.raycast;
+                    if (helper)
+                        ref.remove(helper);
+                };
+            }
+            else if (isInstanceOf(ref, 'BatchedMesh')) {
+                /* @ts-expect-error Some sort of ambient type is conflicing here, likely from @threlte/extras */
+                ref.geometry.computeBoundsTree = computeBatchedBoundsTree;
+                ref.geometry.disposeBoundsTree = disposeBatchedBoundsTree;
+                ref.raycast = acceleratedRaycast;
+                const helper = opts.helper ? new BVHHelper(ref) : undefined;
+                if (helper)
+                    ref.add(helper);
+                return () => {
+                    ref.raycast = BatchedMesh.prototype.raycast;
+                    if (helper)
+                        ref.remove(helper);
+                };
+            }
+            else if (isInstanceOf(ref, 'Mesh') &&
+                /**
+                 * (mp) Line2s sort of suck. Their buffer attribute design internally is much different
+                 * but they give no indication other than this that they are different.
+                 */
+                ref.geometry.attributes.position) {
+                ref.geometry.computeBoundsTree = computeBoundsTree;
+                ref.geometry.disposeBoundsTree = disposeBoundsTree;
+                ref.raycast = acceleratedRaycast;
+                computeBoundsTree.call(ref.geometry, opts);
+                const helper = opts.helper ? new BVHHelper(ref) : undefined;
+                if (helper)
+                    ref.add(helper);
+                return () => {
+                    ref.raycast = Mesh.prototype.raycast;
+                    if (helper)
+                        ref.remove(helper);
+                };
+            }
+        });
+    });
+};

package/dist/ply.d.ts

@@ -1,2 +1,2 @@
-import type { BufferGeometry } from 'three';
+import { BufferGeometry } from 'three';
 export declare const parsePlyInput: (mesh: string | Uint8Array) => BufferGeometry;

package/dist/ply.js

@@ -1,3 +1,4 @@
+import { BufferGeometry } from 'three';
 import { PLYLoader } from 'three/addons/loaders/PLYLoader.js';
 const plyLoader = new PLYLoader();
 export const parsePlyInput = (mesh) => {
@@ -5,6 +6,10 @@ export const parsePlyInput = (mesh) => {
     if (typeof mesh === 'string') {
         return plyLoader.parse(atob(mesh));
     }
+    // First, determine if ply has any geometry
+    if (mesh.length === 0) {
+        return new BufferGeometry();
+    }
     // Case 2: detect text vs binary PLY in Uint8Array
     const header = new TextDecoder().decode(mesh.slice(0, 50));
     const isAscii = header.includes('format ascii');

package/dist/test/createRandomPcdBinary.d.ts

@@ -1 +1 @@
-export declare const createRandomPcdBinary: (numPoints?: number, scale?: number, axes?: string) => Uint8Array;
+export declare const createRandomPcdBinary: (numPoints?: number, scale?: number, axes?: string) => Promise<Uint8Array>;

package/dist/test/createRandomPcdBinary.js

@@ -1,31 +1,18 @@
-export const createRandomPcdBinary = (numPoints = 200, scale = 1, axes = 'xyz') => {
-    const header = `
-# .PCD v0.7 - Point Cloud Data file format
-VERSION 0.7
-FIELDS x y z rgb
-SIZE 4 4 4 4
-TYPE F F F F
-COUNT 1 1 1
-WIDTH ${numPoints}
-HEIGHT 1
-VIEWPOINT 0 0 0 1 0 0 0
-POINTS ${numPoints}
-DATA ascii
-`.trim();
+import { createBinaryPCD } from '../pcd';
+export const createRandomPcdBinary = async (numPoints = 200, scale = 1, axes = 'xyz') => {
     const doX = axes.includes('x');
     const doY = axes.includes('y');
     const doZ = axes.includes('z');
-    const points = Array.from({ length: numPoints }, () => {
-        const x = doX ? ((Math.random() - 0.5) * scale).toFixed(6) : '0.000000';
-        const y = doY ? ((Math.random() - 0.5) * scale).toFixed(6) : '0.000000';
-        const z = doZ ? ((Math.random() - 0.5) * scale).toFixed(6) : '0.000000';
-        const red = Math.floor(Math.random() * 256);
-        const green = Math.floor(Math.random() * 256);
-        const blue = Math.floor(Math.random() * 256);
-        const rgbInt = (red << 16) | (green << 8) | blue;
-        const rgbFloat = String(new Float32Array(new Uint32Array([rgbInt]).buffer)[0]);
-        return `${x} ${y} ${z} ${rgbFloat}`;
-    });
-    const encoder = new TextEncoder();
-    return encoder.encode(`${header}\n${points.join('\n')}`);
+    const positions = new Float32Array(numPoints * 3);
+    const colors = new Uint8Array(numPoints * 3);
+    for (let i = 0, l = positions.length; i < l; i += 1) {
+        positions[i] = doX ? (Math.random() - 0.5) * scale : 0;
+        positions[i + 1] = doY ? (Math.random() - 0.5) * scale : 0;
+        positions[i + 2] = doZ ? (Math.random() - 0.5) * scale : 0;
+        colors[i] = Math.floor(Math.random() * 256);
+        colors[i + 1] = Math.floor(Math.random() * 256);
+        colors[i + 2] = Math.floor(Math.random() * 256);
+    }
+    const buffer = await createBinaryPCD(positions, colors).arrayBuffer();
+    return new Uint8Array(buffer);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@viamrobotics/motion-tools",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Motion visualization with Viam",
   "license": "Apache-2.0",
   "type": "module",
@@ -30,6 +30,7 @@
     "@threlte/rapier": "3.2.0",
     "@threlte/xr": "1.0.8",
     "@types/bun": "1.2.21",
+    "@types/earcut": "^3.0.0",
     "@types/lodash-es": "4.17.12",
     "@types/three": "0.181.0",
     "@typescript-eslint/eslint-plugin": "8.42.0",
@@ -132,9 +133,11 @@
     "@connectrpc/connect-web": "1.7.0",
     "@neodrag/svelte": "^2.3.3",
     "@tanstack/svelte-query-devtools": "^6.0.2",
+    "earcut": "^3.0.2",
     "expr-eval": "^2.0.2",
     "koota": "0.6.5",
     "lodash-es": "4.17.23",
+    "three-mesh-bvh": "^0.9.8",
     "uuid-tool": "^2.0.3"
   },
   "scripts": {