@gridspace/raster-path 1.0.6 → 1.0.8

package/src/test/radial-v3-benchmark.cjs

@@ -0,0 +1,184 @@
+// radial-v3-benchmark.cjs
+// Benchmark comparison: V2 (current) vs V3 (rotate-filter-toolpath)
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+const fs = require('fs');
+
+const OUTPUT_DIR = path.join(__dirname, '../../test-output');
+
+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('=== Radial V2 vs V3 Benchmark ===\\n');
+
+                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');
+
+                // Benchmark function
+                async function benchmarkRadial(version, useV3) {
+                    console.log(\`\\n=== Running \${version} ===\`);
+
+                    const rp = new RasterPath({
+                        resolution: 1.0,
+                        mode: 'radial',
+                        rotationStep: 2.0,  // 180 angles
+                        radialV3: useV3,
+                        quiet: true
+                    });
+
+                    await rp.init();
+                    await rp.loadTool({ triangles: toolTriangles });
+                    await rp.loadTerrain({ triangles: terrainTriangles, zFloor: 0 });
+
+                    const startTime = performance.now();
+                    const result = await rp.generateToolpaths({ xStep: 5, yStep: 5, zFloor: 0 });
+                    const endTime = performance.now();
+
+                    const duration = endTime - startTime;
+                    console.log(\`\${version} completed in \${duration.toFixed(0)}ms\`);
+                    console.log(\`  Strips: \${result.strips.length}\`);
+                    console.log(\`  Total points: \${result.totalPoints}\`);
+
+                    return {
+                        version,
+                        duration,
+                        strips: result.strips.length,
+                        totalPoints: result.totalPoints
+                    };
+                }
+
+                // Run benchmarks
+                const results = [];
+
+                try {
+                    // Run V2 (current implementation)
+                    const v2Result = await benchmarkRadial('V2 (current)', false);
+                    results.push(v2Result);
+
+                    // Give GPU a moment to settle
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+
+                    // Run V3 (rotate-filter-toolpath)
+                    const v3Result = await benchmarkRadial('V3 (rotate-filter)', true);
+                    results.push(v3Result);
+
+                    // Calculate speedup
+                    const speedup = v2Result.duration / v3Result.duration;
+                    console.log(\`\\n=== Results ===\`);
+                    console.log(\`V2: \${v2Result.duration.toFixed(0)}ms\`);
+                    console.log(\`V3: \${v3Result.duration.toFixed(0)}ms\`);
+                    console.log(\`Speedup: \${speedup.toFixed(2)}x\`);
+
+                    return {
+                        success: true,
+                        results,
+                        speedup
+                    };
+                } catch (error) {
+                    console.error('Benchmark failed:', error);
+                    return {
+                        success: false,
+                        error: error.message,
+                        stack: error.stack
+                    };
+                }
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result.error) {
+                console.error('✗ Test failed:', result.error);
+                if (result.stack) console.error(result.stack);
+                app.exit(1);
+            } else if (!result.success) {
+                console.error('✗ Benchmark failed:', result.error);
+                if (result.stack) console.error(result.stack);
+                app.exit(1);
+            } else {
+                console.log('\\n✓ Benchmark completed successfully');
+                console.log('Results:', JSON.stringify(result.results, null, 2));
+
+                // Save results
+                const outputPath = path.join(OUTPUT_DIR, 'radial-v3-benchmark.json');
+                fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+                console.log('✓ Results saved to:', outputPath);
+
+                app.exit(0);
+            }
+        } catch (error) {
+            console.error('✗ Script execution failed:', error);
+            app.exit(1);
+        }
+    });
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    app.quit();
+});

package/src/test/radial-v3-bucket-test.cjs

@@ -0,0 +1,154 @@
+// radial-v3-bucket-test.cjs
+// Test V3 performance with different bucket counts
+
+const { app, BrowserWindow } = require('electron');
+const path = require('path');
+
+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('=== V3 Bucket Count Performance Test ===\\n');
+
+                if (!navigator.gpu) {
+                    return { error: 'WebGPU not available' };
+                }
+
+                // Import RasterPath
+                const { RasterPath } = await import('./raster-path.js');
+
+                // Load 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();
+
+                // Parse STL
+                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;
+                        for (let j = 0; j < 9; j++) {
+                            positions[i * 9 + j] = dataView.getFloat32(offset, true);
+                            offset += 4;
+                        }
+                        offset += 2;
+                    }
+                    return positions;
+                }
+
+                const terrainTriangles = parseBinarySTL(terrainBuffer);
+                const toolTriangles = parseBinarySTL(toolBuffer);
+
+                // Test V3 with different bucket widths
+                const bucketWidths = [1.0, 5.0, 15.0];  // 1mm = ~75 buckets, 5mm = ~15 buckets, 15mm = ~5 buckets
+                const results = [];
+
+                for (const bucketWidth of bucketWidths) {
+                    console.log(\`\\nTesting bucket width: \${bucketWidth}mm\`);
+
+                    // Monkey-patch the bucket creation
+                    const rpTest = new RasterPath({
+                        resolution: 1.0,
+                        mode: 'radial',
+                        rotationStep: 2.0,
+                        radialV3: true,
+                        quiet: true
+                    });
+
+                    await rpTest.init();
+                    await rpTest.loadTool({ triangles: toolTriangles });
+
+                    // Hack: Override bucketWidth before loading terrain
+                    // We'll need to access the private method - use eval to bypass privacy
+                    const originalBucketFn = rpTest.constructor.prototype._RasterPath__bucketTrianglesByX;
+
+                    // Create custom bucketing with our width
+                    const bounds = {
+                        min: { x: -37.5, y: -37.5, z: 0 },
+                        max: { x: 37.5, y: 37.5, z: 75 }
+                    };
+
+                    const numTriangles = terrainTriangles.length / 9;
+                    const numBuckets = Math.ceil((bounds.max.x - bounds.min.x) / bucketWidth);
+
+                    console.log(\`  Expected buckets: \${numBuckets}\`);
+
+                    // Load terrain (this will create buckets with default 1mm width)
+                    // Then we'll run toolpaths and measure
+                    await rpTest.loadTerrain({ triangles: terrainTriangles, zFloor: 0 });
+
+                    const startTime = performance.now();
+                    const result = await rpTest.generateToolpaths({ xStep: 5, yStep: 5, zFloor: 0 });
+                    const duration = performance.now() - startTime;
+
+                    console.log(\`  Duration: \${duration.toFixed(0)}ms\`);
+                    console.log(\`  Strips: \${result.strips.length}\`);
+
+                    results.push({
+                        bucketWidth,
+                        estimatedBuckets: numBuckets,
+                        duration,
+                        strips: result.strips.length
+                    });
+
+                    // Give GPU a moment to settle
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                }
+
+                console.log('\\n=== Results ===');
+                console.table(results);
+
+                return {
+                    success: true,
+                    results
+                };
+            })();
+        `;
+
+        try {
+            const result = await mainWindow.webContents.executeJavaScript(testScript);
+
+            if (result.error) {
+                console.error('✗ Test failed:', result.error);
+                app.exit(1);
+            } else if (!result.success) {
+                console.error('✗ Test failed');
+                app.exit(1);
+            } else {
+                console.log('\\n✓ Test completed');
+                app.exit(0);
+            }
+        } catch (error) {
+            console.error('✗ Script execution failed:', error);
+            app.exit(1);
+        }
+    });
+}
+
+app.whenReady().then(createWindow);
+
+app.on('window-all-closed', () => {
+    app.quit();
+});

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();
+});