@jbroll/jscad-modeling 2.12.7 → 2.13.0

package/benchmarks/memory-test.js

@@ -0,0 +1,103 @@
+/**
+ * Memory impact test for PolygonTreeNode optimization
+ *
+ * Measures heap usage before and after boolean operations
+ */
+
+const { primitives, booleans } = require('../src')
+const { sphere, cube } = primitives
+const { union, subtract, intersect } = booleans
+
+// Force GC if available
+const gc = global.gc || (() => {})
+
+const formatBytes = (bytes) => {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  return `${(bytes / 1024 / 1024).toFixed(2)} MB`
+}
+
+const measureMemory = (label, fn, iterations = 5) => {
+  gc()
+  const before = process.memoryUsage()
+
+  const results = []
+  for (let i = 0; i < iterations; i++) {
+    results.push(fn())
+  }
+
+  gc()
+  const after = process.memoryUsage()
+
+  const heapDiff = after.heapUsed - before.heapUsed
+  const externalDiff = after.external - before.external
+
+  console.log(`${label}:`)
+  console.log(`  Heap used: ${formatBytes(before.heapUsed)} -> ${formatBytes(after.heapUsed)} (${heapDiff >= 0 ? '+' : ''}${formatBytes(heapDiff)})`)
+  console.log(`  Iterations: ${iterations}, Results retained: ${results.length}`)
+
+  // Return results to prevent GC from collecting them during measurement
+  return { heapDiff, results }
+}
+
+const runMemoryTests = () => {
+  console.log('Memory Impact Test')
+  console.log('==================')
+  console.log(`Node ${process.version}, GC available: ${!!global.gc}`)
+  if (!global.gc) {
+    console.log('Run with: node --expose-gc benchmarks/memory-test.js')
+  }
+  console.log()
+
+  // Test 1: Union of spheres (many polygons clipped)
+  console.log('--- Union Operations (high clip count) ---')
+  const s32a = sphere({ segments: 32 })
+  const s32b = sphere({ segments: 32, center: [0.5, 0, 0] })
+
+  measureMemory('union-sphere-32 x5', () => union(s32a, s32b), 5)
+  console.log()
+
+  // Test 2: Larger spheres
+  const s64a = sphere({ segments: 64 })
+  const s64b = sphere({ segments: 64, center: [0.5, 0, 0] })
+
+  measureMemory('union-sphere-64 x3', () => union(s64a, s64b), 3)
+  console.log()
+
+  // Test 3: Subtract (fewer clips)
+  console.log('--- Subtract Operations (moderate clip count) ---')
+  measureMemory('subtract-sphere-32 x5', () => subtract(s32a, s32b), 5)
+  console.log()
+
+  // Test 4: Chain of operations (accumulating dead nodes)
+  console.log('--- Chained Operations (accumulating) ---')
+  measureMemory('union-chain-10-cubes', () => {
+    let result = cube({ size: 2 })
+    for (let i = 1; i < 10; i++) {
+      result = union(result, cube({ size: 2, center: [i * 1.5, 0, 0] }))
+    }
+    return result
+  }, 3)
+  console.log()
+
+  // Test 5: Many small operations
+  console.log('--- Many Small Operations ---')
+  measureMemory('union-25-cubes-array', () => {
+    const cubes = []
+    for (let i = 0; i < 25; i++) {
+      cubes.push(cube({ size: 1, center: [i * 1.2, 0, 0] }))
+    }
+    return union(cubes)
+  }, 3)
+  console.log()
+
+  // Test 6: Measure polygon counts
+  console.log('--- Result Polygon Counts ---')
+  const unionResult = union(s32a, s32b)
+  const subtractResult = subtract(s32a, s32b)
+  console.log(`  sphere-32 polygons: ${s32a.polygons.length}`)
+  console.log(`  union result polygons: ${unionResult.polygons.length}`)
+  console.log(`  subtract result polygons: ${subtractResult.polygons.length}`)
+}
+
+runMemoryTests()

package/benchmarks/primitives.bench.js

@@ -0,0 +1,83 @@
+/**
+ * Primitive shape benchmarks
+ *
+ * Tests sphere, cylinder, torus creation - the key primitives
+ * that involve trigonometry and significant vertex generation.
+ */
+
+const { primitives } = require('../src')
+const { cube, sphere, cylinder, cylinderElliptic, torus, geodesicSphere, roundedCuboid, roundedCylinder } = primitives
+
+const name = 'Primitives'
+
+const benchmarks = [
+  // Cubes (baseline - very fast)
+  {
+    name: 'cube-default',
+    fn: () => cube()
+  },
+  {
+    name: 'roundedCuboid-default',
+    fn: () => roundedCuboid()
+  },
+
+  // Spheres - key optimization target (trig + many vertices)
+  {
+    name: 'sphere-16-segments',
+    fn: () => sphere({ segments: 16 })
+  },
+  {
+    name: 'sphere-32-segments',
+    fn: () => sphere({ segments: 32 })
+  },
+  {
+    name: 'sphere-64-segments',
+    fn: () => sphere({ segments: 64 })
+  },
+  {
+    name: 'sphere-128-segments',
+    fn: () => sphere({ segments: 128 })
+  },
+  {
+    name: 'geodesicSphere-frequency-6',
+    fn: () => geodesicSphere({ frequency: 6 })
+  },
+
+  // Cylinders - common primitive
+  {
+    name: 'cylinder-16-segments',
+    fn: () => cylinder({ segments: 16 })
+  },
+  {
+    name: 'cylinder-32-segments',
+    fn: () => cylinder({ segments: 32 })
+  },
+  {
+    name: 'cylinder-64-segments',
+    fn: () => cylinder({ segments: 64 })
+  },
+  {
+    name: 'cylinderElliptic-32-segments',
+    fn: () => cylinderElliptic({ segments: 32 })
+  },
+  {
+    name: 'roundedCylinder-32-segments',
+    fn: () => roundedCylinder({ segments: 32 })
+  },
+
+  // Torus - uses extrudeRotate internally
+  {
+    name: 'torus-16x16',
+    fn: () => torus({ innerSegments: 16, outerSegments: 16 })
+  },
+  {
+    name: 'torus-32x32',
+    fn: () => torus({ innerSegments: 32, outerSegments: 32 })
+  },
+  {
+    name: 'torus-64x64',
+    fn: () => torus({ innerSegments: 64, outerSegments: 64 })
+  }
+]
+
+module.exports = { name, benchmarks }

package/benchmarks/run.js

@@ -85,12 +85,46 @@ const runSuite = (name, benchmarks) => {
   return results
 }
 
+/**
+ * Generate timestamp for output file
+ */
+const getTimestamp = () => {
+  const now = new Date()
+  return now.toISOString().replace(/[:.]/g, '-').slice(0, 19)
+}
+
+/**
+ * Save results to JSON file
+ */
+const saveResults = (allResults, outputDir) => {
+  const timestamp = getTimestamp()
+  const outputFile = path.join(outputDir, `bench-${timestamp}.json`)
+
+  const output = {
+    timestamp: new Date().toISOString(),
+    node: process.version,
+    runs: BENCHMARK_RUNS,
+    warmup: WARMUP_RUNS,
+    results: allResults
+  }
+
+  fs.writeFileSync(outputFile, JSON.stringify(output, null, 2))
+  console.log(`Results saved to: ${outputFile}`)
+  return outputFile
+}
+
 /**
  * Load and run benchmark files
  */
 const main = () => {
   const args = process.argv.slice(2)
   const benchDir = __dirname
+  const outputDir = path.join(benchDir, 'results')
+
+  // Ensure results directory exists
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true })
+  }
 
   console.log('@jscad/modeling benchmarks')
   console.log(`Runs: ${BENCHMARK_RUNS} (+ ${WARMUP_RUNS} warmup)`)
@@ -134,6 +168,9 @@ const main = () => {
 
   console.log('\n' + '═'.repeat(60))
   console.log('Benchmark complete')
+
+  // Save results to timestamped file
+  saveResults(allResults, outputDir)
 }
 
 // Export for programmatic use

package/benchmarks/workflows.bench.js

@@ -0,0 +1,105 @@
+/**
+ * Typical workflow benchmarks
+ *
+ * Tests common modeling patterns that users actually do:
+ * - Create primitive, boolean op, transform
+ * - Multiple booleans in sequence
+ * - Mixed geometry types (cube vs cylinder)
+ */
+
+const { primitives, booleans, transforms } = require('../src')
+const { cube, sphere, cylinder, torus } = primitives
+const { union, subtract, intersect } = booleans
+const { translate, rotate, scale } = transforms
+
+const name = 'Workflows'
+
+// Pre-create some geometries for fair comparison
+const cube10 = cube({ size: 10 })
+const cyl16 = cylinder({ radius: 3, height: 15, segments: 16 })
+const cyl32 = cylinder({ radius: 3, height: 15, segments: 32 })
+const sphere16 = sphere({ radius: 5, segments: 16 })
+const sphere32 = sphere({ radius: 5, segments: 32 })
+
+const benchmarks = [
+  // Classic workflow: cube with hole
+  {
+    name: 'workflow-cube-subtract-cylinder-16',
+    fn: () => subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 16 }))
+  },
+  {
+    name: 'workflow-cube-subtract-cylinder-32',
+    fn: () => subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 32 }))
+  },
+
+  // Pre-created geometry (isolates boolean cost)
+  {
+    name: 'workflow-precreated-cube-subtract-cyl16',
+    fn: () => subtract(cube10, cyl16)
+  },
+  {
+    name: 'workflow-precreated-cube-subtract-cyl32',
+    fn: () => subtract(cube10, cyl32)
+  },
+
+  // Full pipeline: create, boolean, transform
+  {
+    name: 'workflow-full-cube-subtract-cyl-rotate',
+    fn: () => rotate([0, Math.PI / 4, 0], subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 16 })))
+  },
+  {
+    name: 'workflow-full-cube-subtract-cyl-translate',
+    fn: () => translate([10, 0, 0], subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 16 })))
+  },
+
+  // Multiple holes (common pattern)
+  {
+    name: 'workflow-cube-3-holes',
+    fn: () => {
+      const box = cube({ size: 10 })
+      const hole1 = cylinder({ radius: 1.5, height: 15, segments: 16 })
+      const hole2 = translate([3, 0, 0], hole1)
+      const hole3 = translate([-3, 0, 0], hole1)
+      return subtract(box, hole1, hole2, hole3)
+    }
+  },
+
+  // Union of shapes (assembly pattern)
+  {
+    name: 'workflow-union-cube-sphere-16',
+    fn: () => union(cube({ size: 8 }), translate([0, 0, 6], sphere({ radius: 5, segments: 16 })))
+  },
+  {
+    name: 'workflow-union-cube-sphere-32',
+    fn: () => union(cube({ size: 8 }), translate([0, 0, 6], sphere({ radius: 5, segments: 32 })))
+  },
+
+  // Intersect (less common but important)
+  {
+    name: 'workflow-intersect-cube-sphere-16',
+    fn: () => intersect(cube({ size: 10 }), sphere({ radius: 7, segments: 16 }))
+  },
+  {
+    name: 'workflow-intersect-cube-sphere-32',
+    fn: () => intersect(cube({ size: 10 }), sphere({ radius: 7, segments: 32 }))
+  },
+
+  // Chained operations
+  {
+    name: 'workflow-chain-subtract-union',
+    fn: () => {
+      const base = cube({ size: 10 })
+      const hole = cylinder({ radius: 3, height: 15, segments: 16 })
+      const top = translate([0, 0, 5], sphere({ radius: 3, segments: 16 }))
+      return union(subtract(base, hole), top)
+    }
+  },
+
+  // Scaling after boolean (tests transform application)
+  {
+    name: 'workflow-subtract-then-scale',
+    fn: () => scale([2, 2, 2], subtract(cube({ size: 10 }), cylinder({ radius: 3, height: 15, segments: 16 })))
+  }
+]
+
+module.exports = { name, benchmarks }