@gridspace/raster-path 1.0.6 → 1.0.7

package/src/test/tracing-test.cjs

@@ -0,0 +1,307 @@
+// tracing-test.cjs
+// Test for tracing mode using new RasterPath API
+// Tests: loadTool() + loadTerrain() + generateToolpaths() with input paths
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+const OUTPUT_DIR = path.join(__dirname, '../../test-output');
+const CURRENT_FILE = path.join(OUTPUT_DIR, 'tracing-current.json');
+
+if (!fs.existsSync(OUTPUT_DIR)) {
+    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+}
+
+let mainWindow;
+
+function createWindow() {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 800,
+        show: false,
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            enableBlinkFeatures: 'WebGPU',
+        }
+    });
+
+    const htmlPath = path.join(__dirname, '../../build/index.html');
+    mainWindow.loadFile(htmlPath);
+
+    mainWindow.webContents.on('did-finish-load', async () => {
+        console.log('✓ Page loaded');
+
+        const testScript = `
+            (async function() {
+                console.log('=== Tracing Mode Test ===');
+
+                if (!navigator.gpu) {
+                    return { error: 'WebGPU not available' };
+                }
+                console.log('✓ WebGPU available');
+
+                // Import RasterPath
+                const { RasterPath } = await import('./raster-path.js');
+
+                // Load STL files
+                console.log('\\nLoading STL files...');
+                const terrainResponse = await fetch('../benchmark/fixtures/terrain.stl');
+                const terrainBuffer = await terrainResponse.arrayBuffer();
+
+                const toolResponse = await fetch('../benchmark/fixtures/tool.stl');
+                const toolBuffer = await toolResponse.arrayBuffer();
+
+                console.log('✓ Loaded terrain.stl:', terrainBuffer.byteLength, 'bytes');
+                console.log('✓ Loaded tool.stl:', toolBuffer.byteLength, 'bytes');
+
+                // Parse STL files
+                function parseBinarySTL(buffer) {
+                    const dataView = new DataView(buffer);
+                    const numTriangles = dataView.getUint32(80, true);
+                    const positions = new Float32Array(numTriangles * 9);
+                    let offset = 84;
+
+                    for (let i = 0; i < numTriangles; i++) {
+                        offset += 12; // Skip normal
+                        for (let j = 0; j < 9; j++) {
+                            positions[i * 9 + j] = dataView.getFloat32(offset, true);
+                            offset += 4;
+                        }
+                        offset += 2; // Skip attribute byte count
+                    }
+                    return positions;
+                }
+
+                const terrainTriangles = parseBinarySTL(terrainBuffer);
+                const toolTriangles = parseBinarySTL(toolBuffer);
+                console.log('✓ Parsed terrain:', terrainTriangles.length / 9, 'triangles');
+                console.log('✓ Parsed tool:', toolTriangles.length / 9, 'triangles');
+
+                // Calculate terrain bounds for path generation
+                let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+                for (let i = 0; i < terrainTriangles.length; i += 3) {
+                    const x = terrainTriangles[i];
+                    const y = terrainTriangles[i + 1];
+                    minX = Math.min(minX, x);
+                    maxX = Math.max(maxX, x);
+                    minY = Math.min(minY, y);
+                    maxY = Math.max(maxY, y);
+                }
+                console.log('✓ Terrain bounds:',
+                    'X:', minX.toFixed(2), 'to', maxX.toFixed(2),
+                    'Y:', minY.toFixed(2), 'to', maxY.toFixed(2));
+
+                // Generate a simple horizontal scanline across the terrain center
+                const centerY = (minY + maxY) / 2;
+                const numSegments = 10; // Sparse to test densification
+                const path1 = new Float32Array(numSegments * 2);
+
+                console.log('\\nGenerating horizontal scanline test path...');
+                console.log('  Y (fixed):', centerY.toFixed(2), 'mm');
+                console.log('  X range:', minX.toFixed(2), 'to', maxX.toFixed(2), 'mm');
+
+                for (let i = 0; i < numSegments; i++) {
+                    const t = i / (numSegments - 1);
+                    path1[i * 2] = minX + t * (maxX - minX);      // X varies
+                    path1[i * 2 + 1] = centerY;                    // Y constant
+                }
+                console.log('✓ Generated path with', numSegments, 'vertices');
+
+                // Test parameters
+                const resolution = 0.1; // 0.1mm resolution for terrain raster
+                const step = 0.5;       // 0.5mm sampling resolution along path
+                const zFloor = -100;
+
+                console.log('\\nTest parameters:');
+                console.log('  Terrain resolution:', resolution, 'mm');
+                console.log('  Path sampling step:', step, 'mm');
+                console.log('  Z floor:', zFloor, 'mm');
+
+                // Create RasterPath instance for tracing mode
+                console.log('\\nInitializing RasterPath (tracing mode)...');
+                const raster = new RasterPath({
+                    mode: 'tracing',
+                    resolution: resolution
+                });
+                await raster.init();
+                console.log('✓ RasterPath initialized');
+
+                // Load tool
+                console.log('\\nLoading tool...');
+                const toolStartTime = performance.now();
+                await raster.loadTool({ triangles: toolTriangles });
+                const toolTime = performance.now() - toolStartTime;
+                console.log('✓ Tool loaded in', toolTime.toFixed(1), 'ms');
+
+                // Load terrain
+                console.log('\\nLoading terrain...');
+                const terrainStartTime = performance.now();
+                const terrainData = await raster.loadTerrain({
+                    triangles: terrainTriangles,
+                    zFloor: zFloor
+                });
+                const terrainTime = performance.now() - terrainStartTime;
+                console.log('✓ Terrain loaded in', terrainTime.toFixed(1), 'ms');
+                console.log('  Grid:', terrainData.width, 'x', terrainData.height);
+
+                // Check terrain data has actual values
+                const terrainSamples = [];
+                for (let i = 0; i < Math.min(10, terrainData.positions.length); i++) {
+                    terrainSamples.push(terrainData.positions[i].toFixed(3));
+                }
+                console.log('  Terrain Z samples:', terrainSamples.join(', '));
+                const nonEmpty = terrainData.positions.filter(z => z > -1e9).length;
+                console.log('  Non-empty terrain cells:', nonEmpty, '/', terrainData.positions.length,
+                           '(' + (100 * nonEmpty / terrainData.positions.length).toFixed(1) + '%)');
+
+                // Create reusable buffers for optimal iterative tracing
+                console.log('\\nCreating reusable tracing buffers...');
+                const buffersStartTime = performance.now();
+                await raster.createTracingBuffers();
+                const buffersTime = performance.now() - buffersStartTime;
+                console.log('✓ Reusable buffers created in', buffersTime.toFixed(1), 'ms');
+
+                // Generate traced toolpaths
+                console.log('\\nGenerating traced toolpaths...');
+                const toolpathStartTime = performance.now();
+                const result = await raster.generateToolpaths({
+                    paths: [path1],
+                    step: step,
+                    zFloor: zFloor,
+                    onProgress: (percent, info) => {
+                        console.log('  Progress:', percent + '%', 'Path', info.current, '/', info.total);
+                    }
+                });
+                const toolpathTime = performance.now() - toolpathStartTime;
+                console.log('✓ Toolpaths generated in', toolpathTime.toFixed(1), 'ms');
+
+                // Analyze results
+                console.log('\\nResults:');
+                console.log('  Number of output paths:', result.paths.length);
+
+                const outputPath = result.paths[0];
+                const numOutputPoints = outputPath.length / 3;
+                console.log('  Output path points:', numOutputPoints);
+                console.log('  Input path points:', numSegments);
+                console.log('  Densification factor:', (numOutputPoints / numSegments).toFixed(2) + 'x');
+
+                // Sample Z-values
+                const zValues = [];
+                for (let i = 0; i < outputPath.length; i += 3) {
+                    zValues.push(outputPath[i + 2]);
+                }
+                const minZ = Math.min(...zValues);
+                const maxZ = Math.max(...zValues);
+                const avgZ = zValues.reduce((a, b) => a + b, 0) / zValues.length;
+
+                console.log('\\nZ-depth statistics:');
+                console.log('  Min Z:', minZ.toFixed(3), 'mm');
+                console.log('  Max Z:', maxZ.toFixed(3), 'mm');
+                console.log('  Avg Z:', avgZ.toFixed(3), 'mm');
+                console.log('  Range:', (maxZ - minZ).toFixed(3), 'mm');
+
+                // Check GPU-computed maxZ
+                console.log('\\nGPU-computed maxZ:');
+                console.log('  result.maxZ:', result.maxZ);
+                console.log('  result.maxZ[0]:', result.maxZ[0].toFixed(3), 'mm');
+                console.log('  CPU maxZ (from walking path):', maxZ.toFixed(3), 'mm');
+                console.log('  Match:', Math.abs(result.maxZ[0] - maxZ) < 0.001 ? '✓' : '✗');
+
+                // Sample and display some output points
+                console.log('\\nOutput path samples:');
+                const numSamples = Math.min(5, numOutputPoints);
+                for (let i = 0; i < numSamples; i++) {
+                    const idx = Math.floor(i * numOutputPoints / numSamples);
+                    const x = outputPath[idx * 3].toFixed(2);
+                    const y = outputPath[idx * 3 + 1].toFixed(2);
+                    const z = outputPath[idx * 3 + 2].toFixed(2);
+                    console.log(\`  Point \${idx}: (\${x}, \${y}, \${z})\`);
+                }
+
+                // Verify that output path lies within terrain XY bounds
+                console.log('\\nVerifying path is within terrain bounds...');
+                let pathInBounds = true;
+                let pointsOutOfBounds = 0;
+                for (let i = 0; i < numOutputPoints; i++) {
+                    const x = outputPath[i * 3];
+                    const y = outputPath[i * 3 + 1];
+                    if (x < minX || x > maxX || y < minY || y > maxY) {
+                        pathInBounds = false;
+                        pointsOutOfBounds++;
+                    }
+                }
+                if (pathInBounds) {
+                    console.log('  ✓ All path points within terrain bounds');
+                } else {
+                    console.warn(\`  ⚠ \${pointsOutOfBounds}/\${numOutputPoints} points outside terrain bounds\`);
+                }
+
+                // Check if all Z values are zFloor (indicates no collision detection)
+                const allZFloor = zValues.every(z => z === zFloor);
+                if (allZFloor) {
+                    console.warn('  ⚠ All Z values are zFloor - no terrain collision detected');
+                    console.warn('  This may indicate a bug in collision detection or path/terrain mismatch');
+                } else {
+                    console.log('  ✓ Terrain collision detected');
+                }
+
+                // Cleanup
+                raster.terminate();
+                console.log('\\n✓ Test complete');
+
+                return {
+                    success: true,
+                    terrainLoad: terrainTime,
+                    toolLoad: toolTime,
+                    toolpathGeneration: toolpathTime,
+                    totalTime: toolTime + terrainTime + toolpathTime,
+                    inputPoints: numSegments,
+                    outputPoints: numOutputPoints,
+                    densificationFactor: numOutputPoints / numSegments,
+                    zStats: { minZ, maxZ, avgZ, range: maxZ - minZ },
+                    gpuMaxZ: result.maxZ[0],
+                    maxZMatch: Math.abs(result.maxZ[0] - maxZ) < 0.001,
+                    allZFloor: allZFloor
+                };
+            })();
+        `;
+
+        const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+        if (result.error) {
+            console.error('❌ Test failed:', result.error);
+            app.exit(1);
+            return;
+        }
+
+        console.log('\n=== Test Summary ===');
+        console.log('Terrain load:', result.terrainLoad.toFixed(1), 'ms');
+        console.log('Tool load:', result.toolLoad.toFixed(1), 'ms');
+        console.log('Toolpath generation:', result.toolpathGeneration.toFixed(1), 'ms');
+        console.log('Total time:', result.totalTime.toFixed(1), 'ms');
+        console.log('\nDensification:', result.inputPoints, '→', result.outputPoints,
+                    '(' + result.densificationFactor.toFixed(2) + 'x)');
+        console.log('Z-depth range:', result.zStats.range.toFixed(3), 'mm');
+        console.log('Collision detection:', result.allZFloor ? '❌ FAILED (all zFloor)' : '✓ Working');
+
+        // Save current results
+        fs.writeFileSync(CURRENT_FILE, JSON.stringify(result, null, 2));
+        console.log('\n✓ Results saved to:', CURRENT_FILE);
+
+        console.log('\n✅ Tracing mode test passed');
+        app.exit(0);
+    });
+
+    mainWindow.webContents.on('console-message', (event, level, message) => {
+        // Forward browser console to Node console (optional, for debugging)
+        // console.log('[Browser]', message);
+    });
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    app.quit();
+});

package/src/web/app.js

@@ -12,6 +12,7 @@ let zFloor = -100;
 let xStep = 5;
 let yStep = 5;
 let angleStep = 1.0; // degrees
+let traceStep = 0.5; // mm - sampling resolution for tracing mode
 let toolSize = 2.5; // mm - target tool diameter
 
 let modelSTL = null;  // ArrayBuffer (current, possibly rotated)
@@ -61,6 +62,7 @@ function saveParameters() {
     localStorage.setItem('raster-xStep', xStep);
     localStorage.setItem('raster-yStep', yStep);
     localStorage.setItem('raster-angleStep', angleStep);
+    localStorage.setItem('raster-traceStep', traceStep);
     localStorage.setItem('raster-toolSize', toolSize);
     console.log(`[App] Saved tool size: ${toolSize}mm`);
 
@@ -127,6 +129,12 @@ function loadParameters() {
         document.getElementById('angle-step').value = angleStep;
     }
 
+    const savedTraceStep = localStorage.getItem('raster-traceStep');
+    if (savedTraceStep !== null) {
+        traceStep = parseFloat(savedTraceStep);
+        document.getElementById('trace-step').value = traceStep;
+    }
+
     const savedToolSize = localStorage.getItem('raster-toolSize');
     if (savedToolSize !== null) {
         toolSize = parseFloat(savedToolSize);
@@ -545,8 +553,8 @@ async function rasterizeAll() {
             updateInfo(`Tool loaded in ${(t1 - t0).toFixed(0)}ms`);
         }
 
-        if (mode === 'planar') {
-            // Planar mode: rasterize terrain immediately
+        if (mode === 'planar' || mode === 'tracing') {
+            // Planar/Tracing mode: rasterize terrain immediately
             if (modelTriangles) {
                 updateInfo('Rasterizing terrain...');
                 const t0 = performance.now();
@@ -557,7 +565,7 @@ async function rasterizeAll() {
                 const t1 = performance.now();
                 updateInfo(`Terrain rasterized in ${(t1 - t0).toFixed(0)}ms`);
             }
-        } else {
+        } else if (mode === 'radial') {
             // Radial mode: MUST load tool FIRST
             if (!toolTriangles) {
                 updateInfo('Error: Radial mode requires tool to be loaded first');
@@ -608,30 +616,81 @@ async function generateToolpath() {
             updateInfo('Model must be rasterized first');
             return;
         }
-    } else {
+    } else if (mode === 'radial') {
         // Radial mode: terrain must be loaded (stored internally)
         if (!modelTriangles) {
             updateInfo('Model STL must be loaded');
             return;
         }
+    } else if (mode === 'tracing') {
+        // Tracing mode: terrain must be rasterized
+        if (!modelRasterData) {
+            updateInfo('Model must be rasterized first');
+            return;
+        }
     }
 
     try {
         const t0 = performance.now();
         updateInfo('Generating toolpath...');
 
-        // Unified API - works for both modes!
-        toolpathData = await rasterPath.generateToolpaths({
-            xStep: xStep,
-            yStep: yStep,
+        // Generate trace paths for tracing mode
+        let tracePaths = null;
+        if (mode === 'tracing') {
+            // Get model bounds from raster data
+            const bounds = modelRasterData.bounds;
+            const minX = bounds.min.x;
+            const maxX = bounds.max.x;
+            const minY = bounds.min.y;
+            const maxY = bounds.max.y;
+
+            // Create two cross paths: horizontal through center, vertical through center
+            const centerY = (minY + maxY) / 2;
+            const centerX = (minX + maxX) / 2;
+
+            tracePaths = [
+                new Float32Array([minX, centerY, maxX, centerY]),  // Horizontal line
+                new Float32Array([centerX, minY, centerX, maxY])   // Vertical line
+            ];
+
+            debug.log(`Generated trace paths: H(${minX.toFixed(2)}, ${centerY.toFixed(2)}) to (${maxX.toFixed(2)}, ${centerY.toFixed(2)})`);
+            debug.log(`                        V(${centerX.toFixed(2)}, ${minY.toFixed(2)}) to (${centerX.toFixed(2)}, ${maxY.toFixed(2)})`);
+        }
+
+        // Unified API - works for all modes!
+        const generateParams = {
             zFloor: zFloor
-        });
+        };
+
+        if (mode === 'tracing') {
+            generateParams.paths = tracePaths;
+            generateParams.step = traceStep;
+        } else {
+            generateParams.xStep = xStep;
+            generateParams.yStep = yStep;
+        }
+
+        toolpathData = await rasterPath.generateToolpaths(generateParams);
 
         const t1 = performance.now();
 
         if (mode === 'planar') {
             const numPoints = toolpathData.pathData.length;
             updateInfo(`Toolpath generated: ${numPoints.toLocaleString()} points in ${(t1 - t0).toFixed(0)}ms`);
+        } else if (mode === 'tracing') {
+            const totalPoints = toolpathData.paths.reduce((sum, path) => sum + path.length / 3, 0);
+            debug.log(`[Tracing] Generated ${toolpathData.paths.length} paths with ${totalPoints} total points`);
+
+            // Log sample Z values from each path
+            toolpathData.paths.forEach((path, idx) => {
+                const zValues = [];
+                for (let i = 2; i < Math.min(path.length, 15); i += 3) {
+                    zValues.push(path[i].toFixed(2));
+                }
+                debug.log(`[Tracing] Path ${idx} Z samples:`, zValues.join(', '));
+            });
+
+            updateInfo(`Toolpath generated: ${toolpathData.paths.length} paths, ${totalPoints.toLocaleString()} points in ${(t1 - t0).toFixed(0)}ms`);
         } else {
             // debug.log('[Radial] Toolpaths generated:', toolpathData);
             debug.log(`[Radial] Received ${toolpathData.strips.length} strips from worker, numStrips=${toolpathData.numStrips}`);
@@ -901,8 +960,8 @@ function displayModelRaster(wrapped) {
     const positions = [];
     const colors = [];
 
-    if (mode === 'planar') {
-        // Planar: terrain is dense (Z-only array)
+    if (mode === 'planar' || mode === 'tracing') {
+        // Planar/Tracing: terrain is dense (Z-only array)
         const { positions: rasterPos, bounds, gridWidth, gridHeight } = modelRasterData;
         const stepSize = resolution;
 
@@ -1057,6 +1116,59 @@ function displayToolpaths(wrapped) {
         return;
     }
 
+    if (mode === 'tracing') {
+        // Tracing toolpaths - array of XYZ paths
+        const { paths } = toolpathData;
+
+        // Calculate total points
+        let totalPoints = 0;
+        for (const path of paths) {
+            totalPoints += path.length / 3;
+        }
+
+        debug.log('[Toolpath Display] Tracing mode:', paths.length, 'paths,', totalPoints, 'total points');
+
+        // Preallocate typed arrays
+        const positions = new Float32Array(totalPoints * 3);
+        const colors = new Float32Array(totalPoints * 3);
+
+        let arrayIdx = 0;
+        for (let pathIdx = 0; pathIdx < paths.length; pathIdx++) {
+            const path = paths[pathIdx];
+            const numPoints = path.length / 3;
+
+            // Use different colors for each path
+            const color = pathIdx === 0 ? [1, 0.4, 0] : [0, 0.8, 1]; // Orange for horizontal, cyan for vertical
+
+            for (let i = 0; i < numPoints; i++) {
+                positions[arrayIdx] = path[i * 3];       // X
+                positions[arrayIdx + 1] = path[i * 3 + 1]; // Y
+                positions[arrayIdx + 2] = path[i * 3 + 2]; // Z
+
+                colors[arrayIdx] = color[0];
+                colors[arrayIdx + 1] = color[1];
+                colors[arrayIdx + 2] = color[2];
+
+                arrayIdx += 3;
+            }
+        }
+
+        // Create geometry
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+        geometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
+
+        const material = new THREE.PointsMaterial({
+            size: resolution * 1.5,
+            vertexColors: true
+        });
+
+        toolpathPoints = new THREE.Points(geometry, material);
+        rotatedGroup.add(toolpathPoints);
+
+        return; // Exit early for tracing mode
+    }
+
     if (mode === 'planar') {
         // Planar toolpaths
         const { pathData, numScanlines, pointsPerLine } = toolpathData;
@@ -1324,15 +1436,32 @@ function updateButtonStates() {
 // ============================================================================
 
 function updateModeUI() {
-    // Show/hide wrapped toggle and angle step for radial mode
+    // Show/hide mode-specific controls
     const wrappedContainer = document.getElementById('wrapped-container').classList;
     const angleStepContainer = document.getElementById('angle-step-container').classList;
+    const traceStepContainer = document.getElementById('trace-step-container').classList;
+    const xStepContainer = document.getElementById('x-step-container').classList;
+    const yStepContainer = document.getElementById('y-step-container').classList;
+
     if (mode === 'radial') {
         wrappedContainer.remove('hide');
         angleStepContainer.remove('hide');
+        traceStepContainer.add('hide');
+        xStepContainer.remove('hide');
+        yStepContainer.remove('hide');
+    } else if (mode === 'tracing') {
+        wrappedContainer.add('hide');
+        angleStepContainer.add('hide');
+        traceStepContainer.remove('hide');
+        xStepContainer.add('hide');
+        yStepContainer.add('hide');
     } else {
+        // planar
         wrappedContainer.add('hide');
         angleStepContainer.add('hide');
+        traceStepContainer.add('hide');
+        xStepContainer.remove('hide');
+        yStepContainer.remove('hide');
     }
 }
 
@@ -1452,6 +1581,16 @@ document.addEventListener('DOMContentLoaded', async () => {
         updateButtonStates();
     });
 
+    document.getElementById('trace-step').addEventListener('change', (e) => {
+        traceStep = parseFloat(e.target.value);
+        if (mode === 'tracing') {
+            toolpathData = null;  // Need to regenerate toolpath
+        }
+        saveParameters();
+        updateInfo(`Trace Step changed to ${traceStep}mm`);
+        updateButtonStates();
+    });
+
     // Tool size change
     document.getElementById('tool-size').addEventListener('change', async (e) => {
         toolSize = parseFloat(e.target.value);

package/src/web/index.html

@@ -53,6 +53,7 @@
                 <div class="mode-toggle">
                     <label><input type="radio" name="mode" value="planar" checked> Planar</label>
                     <label><input type="radio" name="mode" value="radial"> Radial</label>
+                    <label><input type="radio" name="mode" value="tracing"> Tracing</label>
                 </div>
             </div>
 
@@ -79,15 +80,18 @@
                 <label>
                     Z Floor: <input type="number" id="z-floor" value="-100" step="10" style="width: 70px;">
                 </label>
-                <label>
+                <label id="x-step-container">
                     X Step: <input type="number" id="x-step" value="5" min="1" max="50" style="width: 60px;">
                 </label>
-                <label>
+                <label id="y-step-container">
                     Y Step: <input type="number" id="y-step" value="5" min="1" max="50" style="width: 60px;">
                 </label>
                 <label id="angle-step-container" class="hide">
                     Angle Step (deg): <input type="number" id="angle-step" value="1" min="0.1" max="10" step="0.1" style="width: 60px;">
                 </label>
+                <label id="trace-step-container" class="hide">
+                    Trace Step (mm): <input type="number" id="trace-step" value="0.5" min="0.1" max="5" step="0.1" style="width: 60px;">
+                </label>
             </div>
 
             <div class="section">